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

optional define for 32bit handles in Broadphase, which allows number of objects to exceed 32767

Browse Source
This commit is contained in:
ejcoumans
2007-03-12 20:14:29 +00:00
parent c856a61dce
commit b2351c84f3
2 changed files with 65 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp
View File

@@ -23,7 +23,7 @@
btBroadphaseProxy* btAxisSweep3::createProxy( const btVector3& min, const btVector3& max,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask) btBroadphaseProxy* btAxisSweep3::createProxy( const btVector3& min, const btVector3& max,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask)
{ {
unsigned short handleId = addHandle(min,max, userPtr,collisionFilterGroup,collisionFilterMask); BP_FP_INT_TYPE handleId = addHandle(min,max, userPtr,collisionFilterGroup,collisionFilterMask);
Handle* handle = getHandle(handleId); Handle* handle = getHandle(handleId);
@@ -54,7 +54,7 @@ btAxisSweep3::btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAab
//assert(bounds.HasVolume()); //assert(bounds.HasVolume());
// 1 handle is reserved as sentinel // 1 handle is reserved as sentinel
assert(maxHandles > 1 && maxHandles < 32767); assert(maxHandles > 1 && maxHandles < BP_MAX_HANDLES);
// init bounds // init bounds
m_worldAabbMin = worldAabbMin; m_worldAabbMin = worldAabbMin;
@@ -95,7 +95,7 @@ btAxisSweep3::btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAab
m_pEdges[axis][0].m_pos = 0; m_pEdges[axis][0].m_pos = 0;
m_pEdges[axis][0].m_handle = 0; m_pEdges[axis][0].m_handle = 0;
m_pEdges[axis][1].m_pos = 0xffff; m_pEdges[axis][1].m_pos = BP_HANDLE_SENTINEL;
m_pEdges[axis][1].m_handle = 0; m_pEdges[axis][1].m_handle = 0;
} }
} }
@@ -108,7 +108,7 @@ btAxisSweep3::~btAxisSweep3()
delete[] m_pHandles; delete[] m_pHandles;
} }
void btAxisSweep3::quantize(unsigned short* out, const btPoint3& point, int isMax) const void btAxisSweep3::quantize(BP_FP_INT_TYPE* out, const btPoint3& point, int isMax) const
{ {
btPoint3 clampedPoint(point); btPoint3 clampedPoint(point);
@@ -118,26 +118,26 @@ void btAxisSweep3::quantize(unsigned short* out, const btPoint3& point, int isMa
clampedPoint.setMin(m_worldAabbMax); clampedPoint.setMin(m_worldAabbMax);
btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize; btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize;
out[0] = (unsigned short)(((int)v.getX() & 0xfffc) | isMax); out[0] = (BP_FP_INT_TYPE)(((int)v.getX() & BP_HANDLE_MASK) | isMax);
out[1] = (unsigned short)(((int)v.getY() & 0xfffc) | isMax); out[1] = (BP_FP_INT_TYPE)(((int)v.getY() & BP_HANDLE_MASK) | isMax);
out[2] = (unsigned short)(((int)v.getZ() & 0xfffc) | isMax); out[2] = (BP_FP_INT_TYPE)(((int)v.getZ() & BP_HANDLE_MASK) | isMax);
} }
unsigned short btAxisSweep3::allocHandle() BP_FP_INT_TYPE btAxisSweep3::allocHandle()
{ {
assert(m_firstFreeHandle); assert(m_firstFreeHandle);
unsigned short handle = m_firstFreeHandle; BP_FP_INT_TYPE handle = m_firstFreeHandle;
m_firstFreeHandle = getHandle(handle)->GetNextFree(); m_firstFreeHandle = getHandle(handle)->GetNextFree();
m_numHandles++; m_numHandles++;
return handle; return handle;
} }
void btAxisSweep3::freeHandle(unsigned short handle) void btAxisSweep3::freeHandle(BP_FP_INT_TYPE handle)
{ {
assert(handle > 0 && handle < m_maxHandles); assert(handle > 0 && handle < m_maxHandles);
@@ -149,15 +149,15 @@ void btAxisSweep3::freeHandle(unsigned short handle)
unsigned short btAxisSweep3::addHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask) BP_FP_INT_TYPE btAxisSweep3::addHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask)
{ {
// quantize the bounds // quantize the bounds
unsigned short min[3], max[3]; BP_FP_INT_TYPE min[3], max[3];
quantize(min, aabbMin, 0); quantize(min, aabbMin, 0);
quantize(max, aabbMax, 1); quantize(max, aabbMax, 1);
// allocate a handle // allocate a handle
unsigned short handle = allocHandle(); BP_FP_INT_TYPE handle = allocHandle();
assert(handle!= 0xcdcd); assert(handle!= 0xcdcd);
Handle* pHandle = getHandle(handle); Handle* pHandle = getHandle(handle);
@@ -202,7 +202,7 @@ unsigned short btAxisSweep3::addHandle(const btPoint3& aabbMin,const btPoint3& a
} }
void btAxisSweep3::removeHandle(unsigned short handle) void btAxisSweep3::removeHandle(BP_FP_INT_TYPE handle)
{ {
Handle* pHandle = getHandle(handle); Handle* pHandle = getHandle(handle);
@@ -220,9 +220,9 @@ void btAxisSweep3::removeHandle(unsigned short handle)
{ {
Edge* pEdges = m_pEdges[axis]; Edge* pEdges = m_pEdges[axis];
int maxEdge= pHandle->m_maxEdges[axis]; int maxEdge= pHandle->m_maxEdges[axis];
pEdges[maxEdge].m_pos = 0xffff; pEdges[maxEdge].m_pos = BP_HANDLE_SENTINEL;
int minEdge = pHandle->m_minEdges[axis]; int minEdge = pHandle->m_minEdges[axis];
pEdges[minEdge].m_pos = 0xffff; pEdges[minEdge].m_pos = BP_HANDLE_SENTINEL;
} }
// remove the edges by sorting them up to the end of the list // remove the edges by sorting them up to the end of the list
@@ -230,17 +230,17 @@ void btAxisSweep3::removeHandle(unsigned short handle)
{ {
Edge* pEdges = m_pEdges[axis]; Edge* pEdges = m_pEdges[axis];
int max = pHandle->m_maxEdges[axis]; int max = pHandle->m_maxEdges[axis];
pEdges[max].m_pos = 0xffff; pEdges[max].m_pos = BP_HANDLE_SENTINEL;
sortMaxUp(axis,max,false); sortMaxUp(axis,max,false);
int i = pHandle->m_minEdges[axis]; int i = pHandle->m_minEdges[axis];
pEdges[i].m_pos = 0xffff; pEdges[i].m_pos = BP_HANDLE_SENTINEL;
sortMinUp(axis,i,false); sortMinUp(axis,i,false);
pEdges[limit-1].m_handle = 0; pEdges[limit-1].m_handle = 0;
pEdges[limit-1].m_pos = 0xffff; pEdges[limit-1].m_pos = BP_HANDLE_SENTINEL;
} }
@@ -372,7 +372,7 @@ bool btAxisSweep3::testOverlap(int ignoreAxis,const Handle* pHandleA, const Hand
return true; return true;
} }
void btAxisSweep3::updateHandle(unsigned short handle, const btPoint3& aabbMin,const btPoint3& aabbMax) void btAxisSweep3::updateHandle(BP_FP_INT_TYPE handle, const btPoint3& aabbMin,const btPoint3& aabbMax)
{ {
// assert(bounds.IsFinite()); // assert(bounds.IsFinite());
//assert(bounds.HasVolume()); //assert(bounds.HasVolume());
@@ -380,15 +380,15 @@ void btAxisSweep3::updateHandle(unsigned short handle, const btPoint3& aabbMin,c
Handle* pHandle = getHandle(handle); Handle* pHandle = getHandle(handle);
// quantize the new bounds // quantize the new bounds
unsigned short min[3], max[3]; BP_FP_INT_TYPE min[3], max[3];
quantize(min, aabbMin, 0); quantize(min, aabbMin, 0);
quantize(max, aabbMax, 1); quantize(max, aabbMax, 1);
// update changed edges // update changed edges
for (int axis = 0; axis < 3; axis++) for (int axis = 0; axis < 3; axis++)
{ {
unsigned short emin = pHandle->m_minEdges[axis]; BP_FP_INT_TYPE emin = pHandle->m_minEdges[axis];
unsigned short emax = pHandle->m_maxEdges[axis]; BP_FP_INT_TYPE emax = pHandle->m_maxEdges[axis];
int dmin = (int)min[axis] - (int)m_pEdges[axis][emin].m_pos; int dmin = (int)min[axis] - (int)m_pEdges[axis][emin].m_pos;
int dmax = (int)max[axis] - (int)m_pEdges[axis][emax].m_pos; int dmax = (int)max[axis] - (int)m_pEdges[axis][emax].m_pos;
@@ -415,7 +415,7 @@ void btAxisSweep3::updateHandle(unsigned short handle, const btPoint3& aabbMin,c
} }
// sorting a min edge downwards can only ever *add* overlaps // sorting a min edge downwards can only ever *add* overlaps
void btAxisSweep3::sortMinDown(int axis, unsigned short edge, bool updateOverlaps) void btAxisSweep3::sortMinDown(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps)
{ {
Edge* pEdge = m_pEdges[axis] + edge; Edge* pEdge = m_pEdges[axis] + edge;
Edge* pPrev = pEdge - 1; Edge* pPrev = pEdge - 1;
@@ -456,7 +456,7 @@ void btAxisSweep3::sortMinDown(int axis, unsigned short edge, bool updateOverlap
} }
// sorting a min edge upwards can only ever *remove* overlaps // sorting a min edge upwards can only ever *remove* overlaps
void btAxisSweep3::sortMinUp(int axis, unsigned short edge, bool updateOverlaps) void btAxisSweep3::sortMinUp(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps)
{ {
Edge* pEdge = m_pEdges[axis] + edge; Edge* pEdge = m_pEdges[axis] + edge;
Edge* pNext = pEdge + 1; Edge* pNext = pEdge + 1;
@@ -500,7 +500,7 @@ void btAxisSweep3::sortMinUp(int axis, unsigned short edge, bool updateOverlaps)
} }
// sorting a max edge downwards can only ever *remove* overlaps // sorting a max edge downwards can only ever *remove* overlaps
void btAxisSweep3::sortMaxDown(int axis, unsigned short edge, bool updateOverlaps) void btAxisSweep3::sortMaxDown(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps)
{ {
Edge* pEdge = m_pEdges[axis] + edge; Edge* pEdge = m_pEdges[axis] + edge;
Edge* pPrev = pEdge - 1; Edge* pPrev = pEdge - 1;
@@ -550,7 +550,7 @@ void btAxisSweep3::sortMaxDown(int axis, unsigned short edge, bool updateOverlap
} }
// sorting a max edge upwards can only ever *add* overlaps // sorting a max edge upwards can only ever *add* overlaps
void btAxisSweep3::sortMaxUp(int axis, unsigned short edge, bool updateOverlaps) void btAxisSweep3::sortMaxUp(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps)
{ {
Edge* pEdge = m_pEdges[axis] + edge; Edge* pEdge = m_pEdges[axis] + edge;
Edge* pNext = pEdge + 1; Edge* pNext = pEdge + 1;

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

@@ -24,6 +24,22 @@
#include "btOverlappingPairCache.h" #include "btOverlappingPairCache.h"
#include "btBroadphaseProxy.h" #include "btBroadphaseProxy.h"
//Enable BP_USE_FIXEDPOINT_INT_32 if you need more then 32767 objects
//#define BP_USE_FIXEDPOINT_INT_32 1
#ifdef BP_USE_FIXEDPOINT_INT_32
#define BP_FP_INT_TYPE unsigned int
#define BP_MAX_HANDLES 1500000 //arbitrary maximum number of handles
#define BP_HANDLE_SENTINEL 0xffffffff
#define BP_HANDLE_MASK 0xfffffffc
#else BP_USE_FIXEDPOINT_INT_32
#define BP_FP_INT_TYPE unsigned short int
#define BP_MAX_HANDLES 32767
#define BP_HANDLE_SENTINEL 0xffff
#define BP_HANDLE_MASK 0xfffe
#endif //BP_USE_FIXEDPOINT_INT_32
/// btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase. /// btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase.
/// It uses arrays rather then lists for storage of the 3 axis. Also it operates using integer coordinates instead of floats. /// It uses arrays rather then lists for storage of the 3 axis. Also it operates using integer coordinates instead of floats.
/// The testOverlap check is optimized to check the array index, rather then the actual AABB coordinates/pos /// The testOverlap check is optimized to check the array index, rather then the actual AABB coordinates/pos
@@ -36,10 +52,10 @@ public:
class Edge class Edge
{ {
public: public:
unsigned short m_pos; // low bit is min/max BP_FP_INT_TYPE m_pos; // low bit is min/max
unsigned short m_handle; BP_FP_INT_TYPE m_handle;
unsigned short IsMax() const {return m_pos & 1;} BP_FP_INT_TYPE IsMax() const {return m_pos & 1;}
}; };
public: public:
@@ -48,14 +64,14 @@ public:
public: public:
// indexes into the edge arrays // indexes into the edge arrays
unsigned short m_minEdges[3], m_maxEdges[3]; // 6 * 2 = 12 BP_FP_INT_TYPE m_minEdges[3], m_maxEdges[3]; // 6 * 2 = 12
unsigned short m_handleId; BP_FP_INT_TYPE m_handleId;
unsigned short m_pad; BP_FP_INT_TYPE m_pad;
//void* m_pOwner; this is now in btBroadphaseProxy.m_clientObject //void* m_pOwner; this is now in btBroadphaseProxy.m_clientObject
inline void SetNextFree(unsigned short next) {m_minEdges[0] = next;} inline void SetNextFree(BP_FP_INT_TYPE next) {m_minEdges[0] = next;}
inline unsigned short GetNextFree() const {return m_minEdges[0];} inline BP_FP_INT_TYPE GetNextFree() const {return m_minEdges[0];}
}; // 24 bytes + 24 for Edge structures = 44 bytes total per entry }; // 24 bytes + 24 for Edge structures = 44 bytes total per entry
@@ -68,29 +84,29 @@ private:
int m_numHandles; // number of active handles int m_numHandles; // number of active handles
int m_maxHandles; // max number of handles int m_maxHandles; // max number of handles
Handle* m_pHandles; // handles pool Handle* m_pHandles; // handles pool
unsigned short m_firstFreeHandle; // free handles list BP_FP_INT_TYPE m_firstFreeHandle; // free handles list
Edge* m_pEdges[3]; // edge arrays for the 3 axes (each array has m_maxHandles * 2 + 2 sentinel entries) Edge* m_pEdges[3]; // edge arrays for the 3 axes (each array has m_maxHandles * 2 + 2 sentinel entries)
int m_invalidPair; int m_invalidPair;
// allocation/deallocation // allocation/deallocation
unsigned short allocHandle(); BP_FP_INT_TYPE allocHandle();
void freeHandle(unsigned short handle); void freeHandle(BP_FP_INT_TYPE handle);
bool testOverlap(int ignoreAxis,const Handle* pHandleA, const Handle* pHandleB); bool testOverlap(int ignoreAxis,const Handle* pHandleA, const Handle* pHandleB);
//Overlap* AddOverlap(unsigned short handleA, unsigned short handleB); //Overlap* AddOverlap(BP_FP_INT_TYPE handleA, BP_FP_INT_TYPE handleB);
//void RemoveOverlap(unsigned short handleA, unsigned short handleB); //void RemoveOverlap(BP_FP_INT_TYPE handleA, BP_FP_INT_TYPE handleB);
void quantize(unsigned short* out, const btPoint3& point, int isMax) const; void quantize(BP_FP_INT_TYPE* out, const btPoint3& point, int isMax) const;
void sortMinDown(int axis, unsigned short edge, bool updateOverlaps = true); void sortMinDown(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps = true);
void sortMinUp(int axis, unsigned short edge, bool updateOverlaps = true); void sortMinUp(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps = true);
void sortMaxDown(int axis, unsigned short edge, bool updateOverlaps = true); void sortMaxDown(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps = true);
void sortMaxUp(int axis, unsigned short edge, bool updateOverlaps = true); void sortMaxUp(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps = true);
public: public:
btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAabbMax, int maxHandles = 16384); btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAabbMax, int maxHandles = 16384);
@@ -101,10 +117,10 @@ public:
//this is performed incrementally by sweep and prune (add pair), and during pair traversal (remove pair) //this is performed incrementally by sweep and prune (add pair), and during pair traversal (remove pair)
} }
unsigned short addHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask); BP_FP_INT_TYPE addHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask);
void removeHandle(unsigned short handle); void removeHandle(BP_FP_INT_TYPE handle);
void updateHandle(unsigned short handle, const btPoint3& aabbMin,const btPoint3& aabbMax); void updateHandle(BP_FP_INT_TYPE handle, const btPoint3& aabbMin,const btPoint3& aabbMax);
inline Handle* getHandle(unsigned short index) const {return m_pHandles + index;} inline Handle* getHandle(BP_FP_INT_TYPE index) const {return m_pHandles + index;}
void processAllOverlappingPairs(btOverlapCallback* callback); void processAllOverlappingPairs(btOverlapCallback* callback);