Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source
This commit is contained in:
erwin.coumans
2008-03-14 01:20:23 +00:00
parent 06a9b3dfc9
commit 9a19b66659
6 changed files with 46 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/BulletCollision/BroadphaseCollision/btAxisSweep3.h
View File

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

2
src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp
View File

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

125
src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp
View File

@@ -27,51 +27,24 @@ int gRemovePairs =0;
int gAddedPairs =0; int gAddedPairs =0;
int gFindPairs =0; int gFindPairs =0;
btOverlappingPairCache::btOverlappingPairCache():
btHashedOverlappingPairCache::btHashedOverlappingPairCache():
m_overlapFilterCallback(0), m_overlapFilterCallback(0),
m_blockedForChanges(false) m_blockedForChanges(false)
{ {
int initialAllocatedSize= 2; int initialAllocatedSize= 2;
m_overlappingPairArray.reserve(initialAllocatedSize); m_overlappingPairArray.reserve(initialAllocatedSize);
#ifdef USE_HASH_PAIRCACHE
growTables(); 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 //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) 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 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 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++; gFindPairs++;
@@ -242,7 +161,7 @@ btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* prox
#include <stdio.h> #include <stdio.h>
void btHashedOverlappingPairCache::growTables() void btOverlappingPairCache::growTables()
{ {
int newCapacity = m_overlappingPairArray.capacity(); 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 proxyId1 = proxy0->getUid();
int proxyId2 = proxy1->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++; gRemovePairs++;
@@ -428,7 +347,7 @@ void* btHashedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* pro
} }
#include <stdio.h> #include <stdio.h>
void btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher) void btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
{ {
int i; 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 #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 //don't add overlap with own
assert(proxy0 != proxy1); 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. ///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) ///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 ///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)) if (!needsBroadphaseCollision(proxy0,proxy1))
return 0; return 0;
@@ -529,7 +451,7 @@ btBroadphasePair* btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseP
#include <stdio.h> #include <stdio.h>
void btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher) void btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
{ {
int i; int i;
@@ -554,3 +476,4 @@ void btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback*
#endif //USE_HASH_PAIRCACHE

56
src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h
View File

@@ -20,13 +20,13 @@ subject to the following restrictions:
#include "btBroadphaseInterface.h" #include "btBroadphaseInterface.h"
#include "btBroadphaseProxy.h" #include "btBroadphaseProxy.h"
#include "btOverlappingPairCallback.h"
#include "LinearMath/btPoint3.h" #include "LinearMath/btPoint3.h"
#include "LinearMath/btAlignedObjectArray.h" #include "LinearMath/btAlignedObjectArray.h"
class btDispatcher; 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 struct btOverlapCallback
{ {
@@ -34,7 +34,6 @@ struct btOverlapCallback
{} {}
//return true for deletion of the pair //return true for deletion of the pair
virtual bool processOverlap(btBroadphasePair& pair) = 0; virtual bool processOverlap(btBroadphasePair& pair) = 0;
}; };
struct btOverlapFilterCallback struct btOverlapFilterCallback
@@ -45,9 +44,9 @@ struct btOverlapFilterCallback
virtual bool needBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const = 0; 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 /// 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; 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; btBroadphasePairArray m_overlappingPairArray;
btOverlapFilterCallback* m_overlapFilterCallback; btOverlapFilterCallback* m_overlapFilterCallback;
@@ -90,13 +65,13 @@ class btHashedOverlappingPairCache : public btOverlappingPairCache
public: public:
btHashedOverlappingPairCache(); btOverlappingPairCache();
virtual ~btHashedOverlappingPairCache(); virtual ~btOverlappingPairCache();
void removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher); 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 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, // Add a pair and return the new pair. If the pair already exists,
// no new pair is created and the old one is returned. // 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++; gAddedPairs++;
@@ -128,7 +103,7 @@ public:
virtual void processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher); virtual void processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
virtual btBroadphasePair* getOverlappingPairArrayPtr() btBroadphasePair* getOverlappingPairArrayPtr()
{ {
return &m_overlappingPairArray[0]; return &m_overlappingPairArray[0];
} }
@@ -252,13 +227,13 @@ public:
#else//USE_HASH_PAIRCACHE
#define USE_LAZY_REMOVAL 1 #define USE_LAZY_REMOVAL 1
///btOverlappingPairCache maintains the objects with overlapping AABB ///btOverlappingPairCache maintains the objects with overlapping AABB
///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase ///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
class btSortedOverlappingPairCache : public btOverlappingPairCache class btOverlappingPairCache
{ {
protected: protected:
//avoid brute-force finding all the time //avoid brute-force finding all the time
@@ -272,8 +247,8 @@ class btSortedOverlappingPairCache : public btOverlappingPairCache
public: public:
btSortedOverlappingPairCache(); btOverlappingPairCache();
virtual ~btSortedOverlappingPairCache(); virtual ~btOverlappingPairCache();
virtual void processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher); virtual void processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
@@ -341,6 +316,7 @@ class btSortedOverlappingPairCache : public btOverlappingPairCache
} }
}; };
#endif //USE_HASH_PAIRCACHE
#endif //OVERLAPPING_PAIR_CACHE_H #endif //OVERLAPPING_PAIR_CACHE_H

9
src/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h
View File

@@ -17,9 +17,6 @@ subject to the following restrictions:
#ifndef OVERLAPPING_PAIR_CALLBACK_H #ifndef OVERLAPPING_PAIR_CALLBACK_H
#define 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 ///btOverlappingPairCallback provides user callback to keep track of overlap between objects, like a collision sensor
class btOverlappingPairCallback 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;
}; };

2
src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp
View File

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