need to fix an issue, before making the paircache change.

src/BulletCollision/BroadphaseCollision/btAxisSweep3.h

@@ -227,7 +227,7 @@ m_invalidPair(0)
 	if (!m_pairCache)
 	{
 		void* ptr = btAlignedAlloc(sizeof(btOverlappingPairCache),16);
-		m_pairCache = new(ptr) btHashedOverlappingPairCache();
+		m_pairCache = new(ptr) btOverlappingPairCache();
 		m_ownsPairCache = true;
 	}
 

src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp

@@ -32,7 +32,7 @@ m_invalidPair(0)
 	{
 		m_ownsPairCache = true;
 		void* mem = btAlignedAlloc(sizeof(btOverlappingPairCache),16);
-		m_overlappingPairs = new (mem)btHashedOverlappingPairCache();
+		m_overlappingPairs = new (mem)btOverlappingPairCache();
 	}
 
 	struct btMultiSapOverlapFilterCallback : public btOverlapFilterCallback

src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp

@@ -27,51 +27,24 @@ int gRemovePairs =0;
 int gAddedPairs =0;
 int gFindPairs =0;
 
-
+btOverlappingPairCache::btOverlappingPairCache():
-
-
-btHashedOverlappingPairCache::btHashedOverlappingPairCache():
 	m_overlapFilterCallback(0),
 	m_blockedForChanges(false)
 {
 	int initialAllocatedSize= 2;
 	m_overlappingPairArray.reserve(initialAllocatedSize);
+#ifdef USE_HASH_PAIRCACHE
 	growTables();
+#endif //USE_HASH_PAIRCACHE
 }
 
 
-btSortedOverlappingPairCache::btSortedOverlappingPairCache():
+btOverlappingPairCache::~btOverlappingPairCache()
-	m_overlapFilterCallback(0),
-	m_blockedForChanges(false)
-{
-	int initialAllocatedSize= 2;
-	m_overlappingPairArray.reserve(initialAllocatedSize);
-}
-
-
-btHashedOverlappingPairCache::~btHashedOverlappingPairCache()
 {
 	//todo/test: show we erase/delete data, or is it automatic
 }
 
-btSortedOverlappingPairCache::~btSortedOverlappingPairCache()
+void	btOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
-{
-	//todo/test: show we erase/delete data, or is it automatic
-}
-
-void	btHashedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
-{
-	if (pair.m_algorithm)
-	{
-		{
-			pair.m_algorithm->~btCollisionAlgorithm();
-			dispatcher->freeCollisionAlgorithm(pair.m_algorithm);
-			pair.m_algorithm=0;
-		}
-	}
-}
-
-void	btSortedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
 {
 	if (pair.m_algorithm)
 	{
@@ -84,7 +57,7 @@ void	btSortedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,b
 }
 
 
-void	btHashedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+void	btOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
 {
 
 	class	CleanPairCallback : public btOverlapCallback
@@ -118,42 +91,7 @@ void	btHashedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,
 
 }
 
-
+void	btOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
-void	btSortedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
-{
-
-	class	CleanPairCallback : public btOverlapCallback
-	{
-		btBroadphaseProxy* m_cleanProxy;
-		btOverlappingPairCache*	m_pairCache;
-		btDispatcher* m_dispatcher;
-
-	public:
-		CleanPairCallback(btBroadphaseProxy* cleanProxy,btOverlappingPairCache* pairCache,btDispatcher* dispatcher)
-			:m_cleanProxy(cleanProxy),
-			m_pairCache(pairCache),
-			m_dispatcher(dispatcher)
-		{
-		}
-		virtual	bool	processOverlap(btBroadphasePair& pair)
-		{
-			if ((pair.m_pProxy0 == m_cleanProxy) ||
-				(pair.m_pProxy1 == m_cleanProxy))
-			{
-				m_pairCache->cleanOverlappingPair(pair,m_dispatcher);
-			}
-			return false;
-		}
-		
-	};
-
-	CleanPairCallback cleanPairs(proxy,this,dispatcher);
-
-	processAllOverlappingPairs(&cleanPairs,dispatcher);
-
-}
-
-void	btHashedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
 {
 
 	class	RemovePairCallback : public btOverlapCallback
@@ -180,34 +118,15 @@ void	btHashedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroad
 }
 
 
-void	btSortedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+#ifdef USE_HASH_PAIRCACHE
-{
-
-	class	RemovePairCallback : public btOverlapCallback
-	{
-		btBroadphaseProxy* m_obsoleteProxy;
-
-	public:
-		RemovePairCallback(btBroadphaseProxy* obsoleteProxy)
-			:m_obsoleteProxy(obsoleteProxy)
-		{
-		}
-		virtual	bool	processOverlap(btBroadphasePair& pair)
-		{
-			return ((pair.m_pProxy0 == m_obsoleteProxy) ||
-				(pair.m_pProxy1 == m_obsoleteProxy));
-		}
-		
-	};
 
 
-	RemovePairCallback removeCallback(proxy);
-
-	processAllOverlappingPairs(&removeCallback,dispatcher);
-}
 
 
-btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
+
+
+
+btBroadphasePair* btOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
 {
 	gFindPairs++;
 
@@ -242,7 +161,7 @@ btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* prox
 
 #include <stdio.h>
 
-void	btHashedOverlappingPairCache::growTables()
+void	btOverlappingPairCache::growTables()
 {
 
 	int newCapacity = m_overlappingPairArray.capacity();
@@ -284,7 +203,7 @@ void	btHashedOverlappingPairCache::growTables()
 	}
 }
 
-btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
+btBroadphasePair* btOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
 {
 	int proxyId1 = proxy0->getUid();
 	int proxyId2 = proxy1->getUid();
@@ -329,7 +248,7 @@ btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProx
 
 
 
-void* btHashedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1,btDispatcher* dispatcher)
+void* btOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1,btDispatcher* dispatcher)
 {
 	gRemovePairs++;
 
@@ -428,7 +347,7 @@ void* btHashedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* pro
 }
 #include <stdio.h>
 
-void	btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
+void	btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
 {
 
 	int i;
@@ -450,9 +369,12 @@ void	btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback*
 	}
 }
 
+#else
 
 
-void*	btSortedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1, btDispatcher* dispatcher )
+
+
+void*	btOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1, btDispatcher* dispatcher )
 {
 #ifndef USE_LAZY_REMOVAL
 
@@ -482,7 +404,7 @@ void*	btSortedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* pro
 
 
 
-btBroadphasePair*	btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+btBroadphasePair*	btOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 {
 	//don't add overlap with own
 	assert(proxy0 != proxy1);
@@ -501,7 +423,7 @@ btBroadphasePair*	btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseP
 ///use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed.
 ///we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address)
 ///Also we can use a 2D bitmap, which can be useful for a future GPU implementation
- btBroadphasePair*	btSortedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+ btBroadphasePair*	btOverlappingPairCache::findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 {
 	if (!needsBroadphaseCollision(proxy0,proxy1))
 		return 0;
@@ -529,7 +451,7 @@ btBroadphasePair*	btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseP
 
 #include <stdio.h>
 
-void	btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
+void	btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
 {
 
 	int i;
@@ -554,3 +476,4 @@ void	btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback*
 
 
 
+#endif //USE_HASH_PAIRCACHE

src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h

@@ -20,13 +20,13 @@ subject to the following restrictions:
 
 #include "btBroadphaseInterface.h"
 #include "btBroadphaseProxy.h"
-#include "btOverlappingPairCallback.h"
-
 #include "LinearMath/btPoint3.h"
 #include "LinearMath/btAlignedObjectArray.h"
 class btDispatcher;
 
-typedef btAlignedObjectArray<btBroadphasePair>	btBroadphasePairArray;
+///disable the USE_HASH_PAIRCACHE define to use a pair manager that sorts the pairs to find duplicates/non-overlap
+#define USE_HASH_PAIRCACHE 1
+
 
 struct	btOverlapCallback
 {
@@ -34,7 +34,6 @@ struct	btOverlapCallback
 	{}
 	//return true for deletion of the pair
 	virtual bool	processOverlap(btBroadphasePair& pair) = 0;
-
 };
 
 struct btOverlapFilterCallback
@@ -45,9 +44,9 @@ struct btOverlapFilterCallback
 	virtual bool	needBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const = 0;
 };
 
+typedef btAlignedObjectArray<btBroadphasePair>	btBroadphasePairArray;
 
-
+#ifdef USE_HASH_PAIRCACHE
-
 
 
 /// Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com
@@ -58,31 +57,7 @@ extern int gFindPairs;
 
 const int BT_NULL_PAIR=0xffffffff;
 
-class btOverlappingPairCache : public btOverlappingPairCallback
+class btOverlappingPairCache
-{
-public:
-
-	virtual btBroadphasePair*	getOverlappingPairArrayPtr() = 0;
-	
-	virtual const btBroadphasePair*	getOverlappingPairArrayPtr() const = 0;
-
-	virtual btBroadphasePairArray&	getOverlappingPairArray() = 0;
-
-	virtual	void	cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher) = 0;
-
-	virtual int getNumOverlappingPairs() const = 0;
-
-	virtual void	cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher) = 0;
-
-	virtual	void setOverlapFilterCallback(btOverlapFilterCallback* callback) = 0;
-
-	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher) = 0;
-
-	virtual btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) = 0;
-
-};
-
-class btHashedOverlappingPairCache : public btOverlappingPairCache
 {
 	btBroadphasePairArray	m_overlappingPairArray;
 	btOverlapFilterCallback* m_overlapFilterCallback;
@@ -90,13 +65,13 @@ class btHashedOverlappingPairCache : public btOverlappingPairCache
 
 
 public:
-	btHashedOverlappingPairCache();
+	btOverlappingPairCache();
-	virtual ~btHashedOverlappingPairCache();
+	virtual ~btOverlappingPairCache();
 
 	
 	void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
 
-	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
+	void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
 	
 	SIMD_FORCE_INLINE bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
 	{
@@ -111,7 +86,7 @@ public:
 
 	// Add a pair and return the new pair. If the pair already exists,
 	// no new pair is created and the old one is returned.
-	virtual btBroadphasePair* 	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+	SIMD_FORCE_INLINE	btBroadphasePair* 	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 	{
 		gAddedPairs++;
 
@@ -128,7 +103,7 @@ public:
 	
 	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
 
-	virtual btBroadphasePair*	getOverlappingPairArrayPtr()
+	btBroadphasePair*	getOverlappingPairArrayPtr()
 	{
 		return &m_overlappingPairArray[0];
 	}
@@ -252,13 +227,13 @@ public:
 
 
 
-
+#else//USE_HASH_PAIRCACHE
 
 #define USE_LAZY_REMOVAL 1
 
 ///btOverlappingPairCache maintains the objects with overlapping AABB
 ///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
-class	btSortedOverlappingPairCache : public btOverlappingPairCache
+class	btOverlappingPairCache
 {
 	protected:
 		//avoid brute-force finding all the time
@@ -272,8 +247,8 @@ class	btSortedOverlappingPairCache : public btOverlappingPairCache
 
 	public:
 			
-		btSortedOverlappingPairCache();	
+		btOverlappingPairCache();	
-		virtual ~btSortedOverlappingPairCache();
+		virtual ~btOverlappingPairCache();
 
 		virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
 
@@ -341,6 +316,7 @@ class	btSortedOverlappingPairCache : public btOverlappingPairCache
 		}
 
 };
+#endif //USE_HASH_PAIRCACHE
 
 #endif //OVERLAPPING_PAIR_CACHE_H
 

src/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h

@@ -17,9 +17,6 @@ subject to the following restrictions:
 #ifndef OVERLAPPING_PAIR_CALLBACK_H
 #define OVERLAPPING_PAIR_CALLBACK_H
 
-class btDispatcher;
-struct  btBroadphasePair;
-
 ///btOverlappingPairCallback provides user callback to keep track of overlap between objects, like a collision sensor
 class btOverlappingPairCallback
 {
@@ -29,11 +26,11 @@ public:
 
 	}
 	
-	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) = 0;
+	virtual void	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) = 0;
 
-	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher) = 0;
+	virtual void	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) = 0;
 
-	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0,btDispatcher* dispatcher) = 0;
+	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0) = 0;
 
 };
 

src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp

@@ -45,7 +45,7 @@ btSimpleBroadphase::btSimpleBroadphase(int maxProxies, btOverlappingPairCache* o
 	if (!overlappingPairCache)
 	{
 		void* mem = btAlignedAlloc(sizeof(btOverlappingPairCache),16);
-		m_pairCache = new (mem)btHashedOverlappingPairCache();
+		m_pairCache = new (mem)btOverlappingPairCache();
 		m_ownsPairCache = true;
 	}