diff --git a/src/BulletCollision/BroadphaseCollision/btAxisSweep3.h b/src/BulletCollision/BroadphaseCollision/btAxisSweep3.h index d36df6e66..5a09c8747 100644 --- a/src/BulletCollision/BroadphaseCollision/btAxisSweep3.h +++ b/src/BulletCollision/BroadphaseCollision/btAxisSweep3.h @@ -226,8 +226,8 @@ m_invalidPair(0) { if (!m_pairCache) { - void* ptr = btAlignedAlloc(sizeof(btOverlappingPairCache),16); - m_pairCache = new(ptr) btOverlappingPairCache(); + void* ptr = btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16); + m_pairCache = new(ptr) btHashedOverlappingPairCache(); m_ownsPairCache = true; } @@ -463,9 +463,8 @@ extern int gOverlappingPairs; template void btAxisSweep3Internal::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::calculateOverlappingPairs(btDispatche //printf("overlappingPairArray.size()=%d\n",overlappingPairArray.size()); } -#endif //USE_LAZY_REMOVAL + @@ -715,7 +714,7 @@ void btAxisSweep3Internal::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::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::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 + } diff --git a/src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp b/src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp index 2799b2248..f9acbf949 100644 --- a/src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp +++ b/src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp @@ -31,8 +31,8 @@ m_invalidPair(0) if (!m_overlappingPairs) { m_ownsPairCache = true; - void* mem = btAlignedAlloc(sizeof(btOverlappingPairCache),16); - m_overlappingPairs = new (mem)btOverlappingPairCache(); + void* mem = btAlignedAlloc(sizeof(btSortedOverlappingPairCache),16); + m_overlappingPairs = new (mem)btSortedOverlappingPairCache(); } struct btMultiSapOverlapFilterCallback : public btOverlapFilterCallback diff --git a/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp b/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp index 0ef2c46b2..f5ab7924a 100644 --- a/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp +++ b/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* btOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) +btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) { gFindPairs++; @@ -161,7 +165,7 @@ btBroadphasePair* btOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, bt #include -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 -void btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher) +void btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher) { int i; @@ -369,30 +373,27 @@ void btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callb } } -#else - - -void* btOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1, btDispatcher* dispatcher ) +void* btSortedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1, btDispatcher* dispatcher ) { -#ifndef USE_LAZY_REMOVAL - - btBroadphasePair findPair(*proxy0,*proxy1); - - int findIndex = m_overlappingPairArray.findLinearSearch(findPair); - if (findIndex < m_overlappingPairArray.size()) + if (!hasDeferredRemoval()) { - gOverlappingPairs--; - btBroadphasePair& pair = m_overlappingPairArray[findIndex]; - void* userData = pair.m_userInfo; - cleanOverlappingPair(pair,dispatcher); - - m_overlappingPairArray.swap(findIndex,m_overlappingPairArray.capacity()-1); - m_overlappingPairArray.pop_back(); - return userData; + btBroadphasePair findPair(*proxy0,*proxy1); + + int findIndex = m_overlappingPairArray.findLinearSearch(findPair); + if (findIndex < m_overlappingPairArray.size()) + { + gOverlappingPairs--; + btBroadphasePair& pair = m_overlappingPairArray[findIndex]; + void* userData = pair.m_userInfo; + cleanOverlappingPair(pair,dispatcher); + + m_overlappingPairArray.swap(findIndex,m_overlappingPairArray.capacity()-1); + 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 -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); +} diff --git a/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h b/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h index c3a9339e0..2228a8451 100644 --- a/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h +++ b/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 -#define USE_HASH_PAIRCACHE 1 - +typedef btAlignedObjectArray btBroadphasePairArray; 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 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(); - virtual ~btOverlappingPairCache(); + btHashedOverlappingPairCache(); + 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 - -///btOverlappingPairCache maintains the objects with overlapping AABB +///btSortedOverlappingPairCache 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 @@ -241,14 +270,17 @@ 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(); - virtual ~btOverlappingPairCache(); + btSortedOverlappingPairCache(); + 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 diff --git a/src/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h b/src/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h index a174ac6ad..078570bba 100644 --- a/src/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h +++ b/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; }; diff --git a/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp b/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp index 1e5fe0d1b..560b7db6f 100644 --- a/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp +++ b/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp @@ -44,8 +44,8 @@ btSimpleBroadphase::btSimpleBroadphase(int maxProxies, btOverlappingPairCache* o if (!overlappingPairCache) { - void* mem = btAlignedAlloc(sizeof(btOverlappingPairCache),16); - m_pairCache = new (mem)btOverlappingPairCache(); + void* mem = btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16); + m_pairCache = new (mem)btHashedOverlappingPairCache(); m_ownsPairCache = true; }