second attempt to some pair management changes, allow to choose pair cache at run-time.

use btNullPairCache, btHashedOverlappingPairCache or btSortedOverlappingPairCache

src/BulletCollision/BroadphaseCollision/btAxisSweep3.h

@@ -226,8 +226,8 @@ m_invalidPair(0)
 {
 	if (!m_pairCache)
 	{
-		void* ptr = btAlignedAlloc(sizeof(btOverlappingPairCache),16);
+		void* ptr = btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16);
-		m_pairCache = new(ptr) btOverlappingPairCache();
+		m_pairCache = new(ptr) btHashedOverlappingPairCache();
 		m_ownsPairCache = true;
 	}
 
@@ -463,9 +463,8 @@ extern int gOverlappingPairs;
 template <typename BP_FP_INT_TYPE>
 void	btAxisSweep3Internal<BP_FP_INT_TYPE>::calculateOverlappingPairs(btDispatcher* dispatcher)
 {
-#ifdef USE_LAZY_REMOVAL
 
-	if (m_ownsPairCache)
+	if (m_ownsPairCache && m_pairCache->hasDeferredRemoval())
 	{
 	
 		btBroadphasePairArray&	overlappingPairArray = m_pairCache->getOverlappingPairArray();
@@ -542,7 +541,7 @@ void	btAxisSweep3Internal<BP_FP_INT_TYPE>::calculateOverlappingPairs(btDispatche
 		
 		//printf("overlappingPairArray.size()=%d\n",overlappingPairArray.size());
 	}
-#endif //USE_LAZY_REMOVAL
+
 
 
 	
@@ -715,7 +714,7 @@ void btAxisSweep3Internal<BP_FP_INT_TYPE>::sortMinUp(int axis, BP_FP_INT_TYPE ed
 
 		if (pNext->IsMax())
 		{
-#ifndef USE_LAZY_REMOVAL
+
 			// if next edge is maximum remove any overlap between the two handles
 			if (updateOverlaps)
 			{
@@ -724,10 +723,10 @@ void btAxisSweep3Internal<BP_FP_INT_TYPE>::sortMinUp(int axis, BP_FP_INT_TYPE ed
 
 				m_pairCache->removeOverlappingPair(handle0,handle1,dispatcher);	
 				if (m_userPairCallback)
-					m_userPairCallback->removeOverlappingPair(handle0,handle1);
+					m_userPairCallback->removeOverlappingPair(handle0,handle1,dispatcher);
 				
 			}
-#endif //USE_LAZY_REMOVAL
+
 
 			// update edge reference in other handle
 			pHandleNext->m_maxEdges[axis]--;
@@ -769,14 +768,14 @@ void btAxisSweep3Internal<BP_FP_INT_TYPE>::sortMaxDown(int axis, BP_FP_INT_TYPE
 			if (updateOverlaps)
 			{
 				//this is done during the overlappingpairarray iteration/narrowphase collision
-#ifndef USE_LAZY_REMOVAL
+
 				Handle* handle0 = getHandle(pEdge->m_handle);
 				Handle* handle1 = getHandle(pPrev->m_handle);
 				m_pairCache->removeOverlappingPair(handle0,handle1,dispatcher);
 				if (m_userPairCallback)
-					m_userPairCallback->removeOverlappingPair(handle0,handle1);
+					m_userPairCallback->removeOverlappingPair(handle0,handle1,dispatcher);
+			
 
-#endif //USE_LAZY_REMOVAL		
 
 			}
 

src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp

@@ -31,8 +31,8 @@ m_invalidPair(0)
 	if (!m_overlappingPairs)
 	{
 		m_ownsPairCache = true;
-		void* mem = btAlignedAlloc(sizeof(btOverlappingPairCache),16);
+		void* mem = btAlignedAlloc(sizeof(btSortedOverlappingPairCache),16);
-		m_overlappingPairs = new (mem)btOverlappingPairCache();
+		m_overlappingPairs = new (mem)btSortedOverlappingPairCache();
 	}
 
 	struct btMultiSapOverlapFilterCallback : public btOverlapFilterCallback

src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp

@@ -1,4 +1,3 @@
-
 /*
 Bullet Continuous Collision Detection and Physics Library
 Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
@@ -27,24 +26,29 @@ 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
 }
 
 
-btOverlappingPairCache::~btOverlappingPairCache()
+
+
+btHashedOverlappingPairCache::~btHashedOverlappingPairCache()
 {
 	//todo/test: show we erase/delete data, or is it automatic
 }
 
-void	btOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
+
+
+void	btHashedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
 {
 	if (pair.m_algorithm)
 	{
@@ -57,7 +61,9 @@ void	btOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispa
 }
 
 
-void	btOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+
+
+void	btHashedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
 {
 
 	class	CleanPairCallback : public btOverlapCallback
@@ -91,7 +97,10 @@ void	btOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDisp
 
 }
 
-void	btOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+
+
+
+void	btHashedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
 {
 
 	class	RemovePairCallback : public btOverlapCallback
@@ -118,15 +127,10 @@ void	btOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseP
 }
 
 
-#ifdef USE_HASH_PAIRCACHE
 
 
 
-
+btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
-
-
-
-btBroadphasePair* btOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
 {
 	gFindPairs++;
 
@@ -161,7 +165,7 @@ btBroadphasePair* btOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, bt
 
 #include <stdio.h>
 
-void	btOverlappingPairCache::growTables()
+void	btHashedOverlappingPairCache::growTables()
 {
 
 	int newCapacity = m_overlappingPairArray.capacity();
@@ -203,7 +207,7 @@ void	btOverlappingPairCache::growTables()
 	}
 }
 
-btBroadphasePair* btOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
+btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
 {
 	int proxyId1 = proxy0->getUid();
 	int proxyId2 = proxy1->getUid();
@@ -248,7 +252,7 @@ btBroadphasePair* btOverlappingPairCache::internalAddPair(btBroadphaseProxy* pro
 
 
 
-void* btOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1,btDispatcher* dispatcher)
+void* btHashedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1,btDispatcher* dispatcher)
 {
 	gRemovePairs++;
 
@@ -347,7 +351,7 @@ void* btOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, b
 }
 #include <stdio.h>
 
-void	btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
+void	btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
 {
 
 	int i;
@@ -369,15 +373,12 @@ void	btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callb
 	}
 }
 
-#else
 
 
-
+void*	btSortedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1, btDispatcher* dispatcher )
-
+{
-void*	btOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1, btDispatcher* dispatcher )
+	if (!hasDeferredRemoval())
 	{
-#ifndef USE_LAZY_REMOVAL
-
 		btBroadphasePair findPair(*proxy0,*proxy1);
 
 		int findIndex = m_overlappingPairArray.findLinearSearch(findPair);
@@ -392,7 +393,7 @@ void*	btOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,bt
 			m_overlappingPairArray.pop_back();
 			return userData;
 		}
-#endif //USE_LAZY_REMOVAL
+	}
 
 	return 0;
 }
@@ -404,7 +405,7 @@ void*	btOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,bt
 
 
 
-btBroadphasePair*	btOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+btBroadphasePair*	btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 {
 	//don't add overlap with own
 	assert(proxy0 != proxy1);
@@ -423,7 +424,7 @@ btBroadphasePair*	btOverlappingPairCache::addOverlappingPair(btBroadphaseProxy*
 ///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*	btOverlappingPairCache::findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+ btBroadphasePair*	btSortedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 {
 	if (!needsBroadphaseCollision(proxy0,proxy1))
 		return 0;
@@ -451,7 +452,7 @@ btBroadphasePair*	btOverlappingPairCache::addOverlappingPair(btBroadphaseProxy*
 
 #include <stdio.h>
 
-void	btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
+void	btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
 {
 
 	int i;
@@ -476,4 +477,90 @@ void	btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callb
 
 
 
-#endif //USE_HASH_PAIRCACHE
+
+btSortedOverlappingPairCache::btSortedOverlappingPairCache():
+	m_overlapFilterCallback(0),
+	m_blockedForChanges(false),
+	m_hasDeferredRemoval(true)
+{
+	int initialAllocatedSize= 2;
+	m_overlappingPairArray.reserve(initialAllocatedSize);
+}
+
+btSortedOverlappingPairCache::~btSortedOverlappingPairCache()
+{
+	//todo/test: show we erase/delete data, or is it automatic
+}
+
+void	btSortedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
+{
+	if (pair.m_algorithm)
+	{
+		{
+			pair.m_algorithm->~btCollisionAlgorithm();
+			dispatcher->freeCollisionAlgorithm(pair.m_algorithm);
+			pair.m_algorithm=0;
+		}
+	}
+}
+
+
+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	btSortedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+{
+
+	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);
+}

src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h

@@ -1,4 +1,3 @@
-
 /*
 Bullet Continuous Collision Detection and Physics Library
 Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
@@ -20,13 +19,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;
 
-///disable the USE_HASH_PAIRCACHE define to use a pair manager that sorts the pairs to find duplicates/non-overlap
+typedef btAlignedObjectArray<btBroadphasePair>	btBroadphasePairArray;
-#define USE_HASH_PAIRCACHE 1
-
 
 struct	btOverlapCallback
 {
@@ -34,6 +33,7 @@ struct	btOverlapCallback
 	{}
 	//return true for deletion of the pair
 	virtual bool	processOverlap(btBroadphasePair& pair) = 0;
+
 };
 
 struct btOverlapFilterCallback
@@ -44,12 +44,11 @@ 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
+
+
+
 
 extern int gRemovePairs;
 extern int gAddedPairs;
@@ -57,7 +56,36 @@ extern int gFindPairs;
 
 const int BT_NULL_PAIR=0xffffffff;
 
-class btOverlappingPairCache
+///btOverlappingPairCache is an interface that allows different ways of pair management.
+///btHashedOverlappingPairCache or btSortedOverlappingPairCache are two implementations.
+class btOverlappingPairCache : public btOverlappingPairCallback
+{
+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;
+
+	virtual bool	hasDeferredRemoval() = 0;
+
+};
+
+/// Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com
+class btHashedOverlappingPairCache : public btOverlappingPairCache
 {
 	btBroadphasePairArray	m_overlappingPairArray;
 	btOverlapFilterCallback* m_overlapFilterCallback;
@@ -65,13 +93,13 @@ class btOverlappingPairCache
 
 
 public:
-	btOverlappingPairCache();
+	btHashedOverlappingPairCache();
-	virtual ~btOverlappingPairCache();
+	virtual ~btHashedOverlappingPairCache();
 
 	
 	void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
 
-	void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
+	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
 	
 	SIMD_FORCE_INLINE bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
 	{
@@ -86,7 +114,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.
-	SIMD_FORCE_INLINE	btBroadphasePair* 	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+	virtual btBroadphasePair* 	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
 	{
 		gAddedPairs++;
 
@@ -103,7 +131,7 @@ public:
 	
 	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
 
-	btBroadphasePair*	getOverlappingPairArrayPtr()
+	virtual btBroadphasePair*	getOverlappingPairArrayPtr()
 	{
 		return &m_overlappingPairArray[0];
 	}
@@ -217,6 +245,10 @@ private:
 		return &m_overlappingPairArray[index];
 	}
 
+	virtual bool	hasDeferredRemoval()
+	{
+		return false;
+	}
 
 public:
 	
@@ -227,13 +259,10 @@ public:
 
 
 
-#else//USE_HASH_PAIRCACHE
 
-#define USE_LAZY_REMOVAL 1
+///btSortedOverlappingPairCache maintains the objects with overlapping AABB
-
-///btOverlappingPairCache maintains the objects with overlapping AABB
 ///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
-class	btOverlappingPairCache
+class	btSortedOverlappingPairCache : public btOverlappingPairCache
 {
 	protected:
 		//avoid brute-force finding all the time
@@ -242,13 +271,16 @@ class	btOverlappingPairCache
 		//during the dispatch, check that user doesn't destroy/create proxy
 		bool		m_blockedForChanges;
 
+		///by default, do the removal during the pair traversal
+		bool		m_hasDeferredRemoval;
+		
 		//if set, use the callback instead of the built in filter in needBroadphaseCollision
 		btOverlapFilterCallback* m_overlapFilterCallback;
 
 	public:
 			
-		btOverlappingPairCache();	
+		btSortedOverlappingPairCache();	
-		virtual ~btOverlappingPairCache();
+		virtual ~btSortedOverlappingPairCache();
 
 		virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
 
@@ -315,8 +347,87 @@ class	btOverlappingPairCache
 			m_overlapFilterCallback = callback;
 		}
 
+		virtual bool	hasDeferredRemoval()
+		{
+			return m_hasDeferredRemoval;
+		}
+
+
 };
-#endif //USE_HASH_PAIRCACHE
+
+
+
+///btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and testing.
+class btNullPairCache : public btOverlappingPairCache
+{
+
+	btBroadphasePairArray	m_overlappingPairArray;
+
+public:
+
+	virtual btBroadphasePair*	getOverlappingPairArrayPtr()
+	{
+		return &m_overlappingPairArray[0];
+	}
+	const btBroadphasePair*	getOverlappingPairArrayPtr() const
+	{
+		return &m_overlappingPairArray[0];
+	}
+	btBroadphasePairArray&	getOverlappingPairArray()
+	{
+		return m_overlappingPairArray;
+	}
+	
+	virtual	void	cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
+	{
+
+	}
+
+	virtual int getNumOverlappingPairs() const
+	{
+		return 0;
+	}
+
+	virtual void	cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
+	{
+
+	}
+
+	virtual	void setOverlapFilterCallback(btOverlapFilterCallback* callback)
+	{
+	}
+
+	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher)
+	{
+	}
+
+	virtual btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
+	{
+		return 0;
+	}
+
+	virtual bool	hasDeferredRemoval()
+	{
+		return true;
+	}
+
+	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+	{
+		return 0;
+	}
+
+	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher)
+	{
+		return 0;
+	}
+
+	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0,btDispatcher* dispatcher)
+	{
+	}
+
+
+};
+
 
 #endif //OVERLAPPING_PAIR_CACHE_H
 

src/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h

@@ -17,6 +17,9 @@ 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
 {
@@ -26,11 +29,11 @@ public:
 
 	}
 	
-	virtual void	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) = 0;
+	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) = 0;
 
-	virtual void	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) = 0;
+	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher) = 0;
 
-	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0) = 0;
+	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0,btDispatcher* dispatcher) = 0;
 
 };
 

src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp

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