19 #ifndef BT_AXIS_SWEEP_3_INTERNAL_H 20 #define BT_AXIS_SWEEP_3_INTERNAL_H 30 #define USE_OVERLAP_TEST_ON_REMOVES 1 35 template <
typename BP_FP_INT_TYPE>
53 BP_FP_INT_TYPE
IsMax()
const {
return static_cast<BP_FP_INT_TYPE>(
m_pos & 1);}
108 bool testOverlap2D(
const Handle* pHandleA,
const Handle* pHandleB,
int axis0,
int axis1);
110 #ifdef DEBUG_BROADPHASE 111 void debugPrintAxis(
int axis,
bool checkCardinality=
true);
112 #endif //DEBUG_BROADPHASE 205 #ifdef DEBUG_BROADPHASE 208 template <
typename BP_FP_INT_TYPE>
211 int numEdges = m_pHandles[0].m_maxEdges[axis];
212 printf(
"SAP Axis %d, numEdges=%d\n",axis,numEdges);
215 for (i=0;i<numEdges+1;i++)
217 Edge* pEdge = m_pEdges[axis] + i;
218 Handle* pHandlePrev = getHandle(pEdge->m_handle);
219 int handleIndex = pEdge->IsMax()? pHandlePrev->m_maxEdges[axis] : pHandlePrev->m_minEdges[axis];
221 beginOrEnd=pEdge->IsMax()?
'E':
'B';
222 printf(
" [%c,h=%d,p=%x,i=%d]\n",beginOrEnd,pEdge->m_handle,pEdge->m_pos,handleIndex);
225 if (checkCardinality)
226 btAssert(numEdges == m_numHandles*2+1);
228 #endif //DEBUG_BROADPHASE 230 template <
typename BP_FP_INT_TYPE>
234 BP_FP_INT_TYPE handleId = addHandle(aabbMin,aabbMax, userPtr,collisionFilterGroup,collisionFilterMask,dispatcher);
236 Handle* handle = getHandle(handleId);
238 if (m_raycastAccelerator)
240 btBroadphaseProxy* rayProxy = m_raycastAccelerator->
createProxy(aabbMin,aabbMax,shapeType,userPtr,collisionFilterGroup,collisionFilterMask,dispatcher);
241 handle->m_dbvtProxy = rayProxy;
248 template <
typename BP_FP_INT_TYPE>
251 Handle* handle = static_cast<Handle*>(proxy);
252 if (m_raycastAccelerator)
253 m_raycastAccelerator->
destroyProxy(handle->m_dbvtProxy,dispatcher);
254 removeHandle(static_cast<BP_FP_INT_TYPE>(handle->m_uniqueId), dispatcher);
257 template <
typename BP_FP_INT_TYPE>
260 Handle* handle = static_cast<Handle*>(proxy);
261 handle->m_aabbMin = aabbMin;
262 handle->m_aabbMax = aabbMax;
263 updateHandle(static_cast<BP_FP_INT_TYPE>(handle->m_uniqueId), aabbMin, aabbMax,dispatcher);
264 if (m_raycastAccelerator)
265 m_raycastAccelerator->
setAabb(handle->m_dbvtProxy,aabbMin,aabbMax,dispatcher);
269 template <
typename BP_FP_INT_TYPE>
272 if (m_raycastAccelerator)
274 m_raycastAccelerator->
rayTest(rayFrom,rayTo,rayCallback,aabbMin,aabbMax);
278 BP_FP_INT_TYPE axis = 0;
280 for (BP_FP_INT_TYPE i=1;i<m_numHandles*2+1;i++)
282 if (m_pEdges[axis][i].IsMax())
284 rayCallback.
process(getHandle(m_pEdges[axis][i].m_handle));
290 template <
typename BP_FP_INT_TYPE>
293 if (m_raycastAccelerator)
295 m_raycastAccelerator->
aabbTest(aabbMin,aabbMax,callback);
299 BP_FP_INT_TYPE axis = 0;
301 for (BP_FP_INT_TYPE i=1;i<m_numHandles*2+1;i++)
303 if (m_pEdges[axis][i].IsMax())
305 Handle* handle = getHandle(m_pEdges[axis][i].m_handle);
317 template <
typename BP_FP_INT_TYPE>
320 Handle* pHandle = static_cast<Handle*>(proxy);
321 aabbMin = pHandle->m_aabbMin;
322 aabbMax = pHandle->m_aabbMax;
326 template <
typename BP_FP_INT_TYPE>
329 Handle* pHandle = static_cast<Handle*>(proxy);
331 unsigned short vecInMin[3];
332 unsigned short vecInMax[3];
334 vecInMin[0] = m_pEdges[0][pHandle->m_minEdges[0]].m_pos ;
335 vecInMax[0] = m_pEdges[0][pHandle->m_maxEdges[0]].m_pos +1 ;
336 vecInMin[1] = m_pEdges[1][pHandle->m_minEdges[1]].m_pos ;
337 vecInMax[1] = m_pEdges[1][pHandle->m_maxEdges[1]].m_pos +1 ;
338 vecInMin[2] = m_pEdges[2][pHandle->m_minEdges[2]].m_pos ;
339 vecInMax[2] = m_pEdges[2][pHandle->m_maxEdges[2]].m_pos +1 ;
342 aabbMin += m_worldAabbMin;
345 aabbMax += m_worldAabbMin;
351 template <
typename BP_FP_INT_TYPE>
353 :m_bpHandleMask(handleMask),
354 m_handleSentinel(handleSentinel),
355 m_pairCache(pairCache),
356 m_userPairCallback(0),
357 m_ownsPairCache(false),
359 m_raycastAccelerator(0)
361 BP_FP_INT_TYPE maxHandles = static_cast<BP_FP_INT_TYPE>(userMaxHandles+1);
370 if (!disableRaycastAccelerator)
399 m_pHandles[i].SetNextFree(static_cast<BP_FP_INT_TYPE>(i + 1));
405 for (
int i = 0; i < 3; i++)
417 for (
int axis = 0; axis < 3; axis++)
426 #ifdef DEBUG_BROADPHASE 427 debugPrintAxis(axis);
428 #endif //DEBUG_BROADPHASE 434 template <
typename BP_FP_INT_TYPE>
437 if (m_raycastAccelerator)
445 for (
int i = 2; i >= 0; i--)
449 delete [] m_pHandles;
458 template <
typename BP_FP_INT_TYPE>
461 #ifdef OLD_CLAMPING_METHOD 465 clampedPoint.
setMax(m_worldAabbMin);
466 clampedPoint.
setMin(m_worldAabbMax);
467 btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize;
468 out[0] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.
getX() & m_bpHandleMask) | isMax);
469 out[1] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.
getY() & m_bpHandleMask) | isMax);
470 out[2] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.
getZ() & m_bpHandleMask) | isMax);
472 btVector3 v = (point - m_worldAabbMin) * m_quantize;
473 out[0]=(v[0]<=0)?(BP_FP_INT_TYPE)isMax:(v[0]>=m_handleSentinel)?(BP_FP_INT_TYPE)((m_handleSentinel&m_bpHandleMask)|isMax):(BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[0]&m_bpHandleMask)|isMax);
474 out[1]=(v[1]<=0)?(BP_FP_INT_TYPE)isMax:(v[1]>=m_handleSentinel)?(BP_FP_INT_TYPE)((m_handleSentinel&m_bpHandleMask)|isMax):(BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[1]&m_bpHandleMask)|isMax);
475 out[2]=(v[2]<=0)?(BP_FP_INT_TYPE)isMax:(v[2]>=m_handleSentinel)?(BP_FP_INT_TYPE)((m_handleSentinel&m_bpHandleMask)|isMax):(BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v[2]&m_bpHandleMask)|isMax);
476 #endif //OLD_CLAMPING_METHOD 480 template <
typename BP_FP_INT_TYPE>
485 BP_FP_INT_TYPE handle = m_firstFreeHandle;
486 m_firstFreeHandle = getHandle(handle)->GetNextFree();
492 template <
typename BP_FP_INT_TYPE>
495 btAssert(handle > 0 && handle < m_maxHandles);
497 getHandle(handle)->SetNextFree(m_firstFreeHandle);
498 m_firstFreeHandle = handle;
504 template <
typename BP_FP_INT_TYPE>
508 BP_FP_INT_TYPE min[3], max[3];
509 quantize(min, aabbMin, 0);
510 quantize(max, aabbMax, 1);
513 BP_FP_INT_TYPE handle = allocHandle();
516 Handle* pHandle = getHandle(handle);
518 pHandle->m_uniqueId = static_cast<int>(handle);
520 pHandle->m_clientObject = pOwner;
521 pHandle->m_collisionFilterGroup = collisionFilterGroup;
522 pHandle->m_collisionFilterMask = collisionFilterMask;
525 BP_FP_INT_TYPE limit = static_cast<BP_FP_INT_TYPE>(m_numHandles * 2);
529 for (BP_FP_INT_TYPE axis = 0; axis < 3; axis++)
532 m_pHandles[0].m_maxEdges[axis] += 2;
534 m_pEdges[axis][limit + 1] = m_pEdges[axis][limit - 1];
536 m_pEdges[axis][limit - 1].m_pos = min[axis];
537 m_pEdges[axis][limit - 1].m_handle = handle;
539 m_pEdges[axis][limit].m_pos = max[axis];
540 m_pEdges[axis][limit].m_handle = handle;
542 pHandle->m_minEdges[axis] = static_cast<BP_FP_INT_TYPE>(limit - 1);
543 pHandle->m_maxEdges[axis] = limit;
547 sortMinDown(0, pHandle->m_minEdges[0], dispatcher,
false);
548 sortMaxDown(0, pHandle->m_maxEdges[0], dispatcher,
false);
549 sortMinDown(1, pHandle->m_minEdges[1], dispatcher,
false);
550 sortMaxDown(1, pHandle->m_maxEdges[1], dispatcher,
false);
551 sortMinDown(2, pHandle->m_minEdges[2], dispatcher,
true);
552 sortMaxDown(2, pHandle->m_maxEdges[2], dispatcher,
true);
559 template <
typename BP_FP_INT_TYPE>
563 Handle* pHandle = getHandle(handle);
574 int limit = static_cast<int>(m_numHandles * 2);
578 for (axis = 0;axis<3;axis++)
580 m_pHandles[0].m_maxEdges[axis] -= 2;
584 for ( axis = 0; axis < 3; axis++)
586 Edge* pEdges = m_pEdges[axis];
587 BP_FP_INT_TYPE max = pHandle->m_maxEdges[axis];
588 pEdges[max].m_pos = m_handleSentinel;
590 sortMaxUp(axis,max,dispatcher,
false);
593 BP_FP_INT_TYPE i = pHandle->m_minEdges[axis];
594 pEdges[i].m_pos = m_handleSentinel;
597 sortMinUp(axis,i,dispatcher,
false);
599 pEdges[limit-1].m_handle = 0;
600 pEdges[limit-1].m_pos = m_handleSentinel;
602 #ifdef DEBUG_BROADPHASE 603 debugPrintAxis(axis,
false);
604 #endif //DEBUG_BROADPHASE 616 template <
typename BP_FP_INT_TYPE>
619 if (m_numHandles == 0)
621 m_firstFreeHandle = 1;
623 for (BP_FP_INT_TYPE i = m_firstFreeHandle; i < m_maxHandles; i++)
624 m_pHandles[i].SetNextFree(static_cast<BP_FP_INT_TYPE>(i + 1));
625 m_pHandles[m_maxHandles - 1].SetNextFree(0);
634 template <
typename BP_FP_INT_TYPE>
646 overlappingPairArray.
resize(overlappingPairArray.
size() - m_invalidPair);
658 for (i=0;i<overlappingPairArray.
size();i++)
663 bool isDuplicate = (pair == previousPair);
667 bool needsRemoval =
false;
676 needsRemoval =
false;
704 #define CLEAN_INVALID_PAIRS 1 705 #ifdef CLEAN_INVALID_PAIRS 710 overlappingPairArray.
resize(overlappingPairArray.
size() - m_invalidPair);
712 #endif//CLEAN_INVALID_PAIRS 720 template <
typename BP_FP_INT_TYPE>
723 const Handle* pHandleA = static_cast<Handle*>(proxy0);
724 const Handle* pHandleB = static_cast<Handle*>(proxy1);
728 for (
int axis = 0; axis < 3; axis++)
730 if (pHandleA->m_maxEdges[axis] < pHandleB->m_minEdges[axis] ||
731 pHandleB->m_maxEdges[axis] < pHandleA->m_minEdges[axis])
739 template <
typename BP_FP_INT_TYPE>
744 if (pHandleA->m_maxEdges[axis0] < pHandleB->m_minEdges[axis0] ||
745 pHandleB->m_maxEdges[axis0] < pHandleA->m_minEdges[axis0] ||
746 pHandleA->m_maxEdges[axis1] < pHandleB->m_minEdges[axis1] ||
747 pHandleB->m_maxEdges[axis1] < pHandleA->m_minEdges[axis1])
754 template <
typename BP_FP_INT_TYPE>
760 Handle* pHandle = getHandle(handle);
763 BP_FP_INT_TYPE min[3], max[3];
764 quantize(min, aabbMin, 0);
765 quantize(max, aabbMax, 1);
768 for (
int axis = 0; axis < 3; axis++)
770 BP_FP_INT_TYPE emin = pHandle->m_minEdges[axis];
771 BP_FP_INT_TYPE emax = pHandle->m_maxEdges[axis];
773 int dmin = (int)min[axis] - (
int)m_pEdges[axis][emin].m_pos;
774 int dmax = (int)max[axis] - (
int)m_pEdges[axis][emax].m_pos;
776 m_pEdges[axis][emin].m_pos = min[axis];
777 m_pEdges[axis][emax].m_pos = max[axis];
781 sortMinDown(axis, emin,dispatcher,
true);
784 sortMaxUp(axis, emax,dispatcher,
true);
788 sortMinUp(axis, emin,dispatcher,
true);
791 sortMaxDown(axis, emax,dispatcher,
true);
793 #ifdef DEBUG_BROADPHASE 794 debugPrintAxis(axis);
795 #endif //DEBUG_BROADPHASE 805 template <
typename BP_FP_INT_TYPE>
809 Edge* pEdge = m_pEdges[axis] + edge;
810 Edge* pPrev = pEdge - 1;
811 Handle* pHandleEdge = getHandle(pEdge->m_handle);
813 while (pEdge->m_pos < pPrev->m_pos)
815 Handle* pHandlePrev = getHandle(pPrev->m_handle);
820 const int axis1 = (1 << axis) & 3;
821 const int axis2 = (1 << axis1) & 3;
822 if (updateOverlaps && testOverlap2D(pHandleEdge, pHandlePrev,axis1,axis2))
825 if (m_userPairCallback)
833 pHandlePrev->m_maxEdges[axis]++;
836 pHandlePrev->m_minEdges[axis]++;
838 pHandleEdge->m_minEdges[axis]--;
850 #ifdef DEBUG_BROADPHASE 851 debugPrintAxis(axis);
852 #endif //DEBUG_BROADPHASE 857 template <
typename BP_FP_INT_TYPE>
860 Edge* pEdge = m_pEdges[axis] + edge;
861 Edge* pNext = pEdge + 1;
862 Handle* pHandleEdge = getHandle(pEdge->m_handle);
864 while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos))
866 Handle* pHandleNext = getHandle(pNext->m_handle);
870 Handle* handle0 = getHandle(pEdge->m_handle);
871 Handle* handle1 = getHandle(pNext->m_handle);
872 const int axis1 = (1 << axis) & 3;
873 const int axis2 = (1 << axis1) & 3;
878 && testOverlap2D(handle0,handle1,axis1,axis2)
879 #endif //USE_OVERLAP_TEST_ON_REMOVES 885 if (m_userPairCallback)
892 pHandleNext->m_maxEdges[axis]--;
895 pHandleNext->m_minEdges[axis]--;
897 pHandleEdge->m_minEdges[axis]++;
913 template <
typename BP_FP_INT_TYPE>
917 Edge* pEdge = m_pEdges[axis] + edge;
918 Edge* pPrev = pEdge - 1;
919 Handle* pHandleEdge = getHandle(pEdge->m_handle);
921 while (pEdge->m_pos < pPrev->m_pos)
923 Handle* pHandlePrev = getHandle(pPrev->m_handle);
928 Handle* handle0 = getHandle(pEdge->m_handle);
929 Handle* handle1 = getHandle(pPrev->m_handle);
930 const int axis1 = (1 << axis) & 3;
931 const int axis2 = (1 << axis1) & 3;
935 && testOverlap2D(handle0,handle1,axis1,axis2)
936 #endif //USE_OVERLAP_TEST_ON_REMOVES 943 if (m_userPairCallback)
951 pHandlePrev->m_minEdges[axis]++;;
954 pHandlePrev->m_maxEdges[axis]++;
956 pHandleEdge->m_maxEdges[axis]--;
969 #ifdef DEBUG_BROADPHASE 970 debugPrintAxis(axis);
971 #endif //DEBUG_BROADPHASE 976 template <
typename BP_FP_INT_TYPE>
979 Edge* pEdge = m_pEdges[axis] + edge;
980 Edge* pNext = pEdge + 1;
981 Handle* pHandleEdge = getHandle(pEdge->m_handle);
983 while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos))
985 Handle* pHandleNext = getHandle(pNext->m_handle);
987 const int axis1 = (1 << axis) & 3;
988 const int axis2 = (1 << axis1) & 3;
993 if (updateOverlaps && testOverlap2D(pHandleEdge, pHandleNext,axis1,axis2))
995 Handle* handle0 = getHandle(pEdge->m_handle);
996 Handle* handle1 = getHandle(pNext->m_handle);
998 if (m_userPairCallback)
1003 pHandleNext->m_minEdges[axis]--;
1006 pHandleNext->m_maxEdges[axis]--;
1008 pHandleEdge->m_maxEdges[axis]++;
virtual void aabbTest(const btVector3 &aabbMin, const btVector3 &aabbMax, btBroadphaseAabbCallback &callback)
virtual void resetPool(btDispatcher *dispatcher)
reset broadphase internal structures, to ensure determinism/reproducability
void quantize(BP_FP_INT_TYPE *out, const btVector3 &point, int isMax) const
virtual void rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, btBroadphaseRayCallback &rayCallback, const btVector3 &aabbMin=btVector3(0, 0, 0), const btVector3 &aabbMax=btVector3(0, 0, 0))
virtual void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)=0
#define USE_OVERLAP_TEST_ON_REMOVES
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
The btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase.
btBroadphaseProxy * m_dbvtProxy
virtual bool hasDeferredRemoval()=0
btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing.
void sortMaxUp(int axis, BP_FP_INT_TYPE edge, btDispatcher *dispatcher, bool updateOverlaps)
virtual void printStats()
virtual void getAabb(btBroadphaseProxy *proxy, btVector3 &aabbMin, btVector3 &aabbMax) const
void freeHandle(BP_FP_INT_TYPE handle)
BP_FP_INT_TYPE IsMax() const
#define SIMD_FORCE_INLINE
const btScalar & getY() const
Return the y value.
The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees...
BP_FP_INT_TYPE m_handleSentinel
void processAllOverlappingPairs(btOverlapCallback *callback)
BP_FP_INT_TYPE m_firstFreeHandle
bool TestAabbAgainstAabb2(const btVector3 &aabbMin1, const btVector3 &aabbMax1, const btVector3 &aabbMin2, const btVector3 &aabbMax2)
conservative test for overlap between two aabbs
void removeHandle(BP_FP_INT_TYPE handle, btDispatcher *dispatcher)
BP_FP_INT_TYPE m_minEdges[3]
BT_DECLARE_ALIGNED_ALLOCATOR()
BP_FP_INT_TYPE GetNextFree() const
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
const btScalar & getZ() const
Return the z value.
bool testAabbOverlap(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
BP_FP_INT_TYPE getNumHandles() const
virtual void setAabb(btBroadphaseProxy *proxy, const btVector3 &aabbMin, const btVector3 &aabbMax, btDispatcher *dispatcher)
BP_FP_INT_TYPE m_maxHandles
virtual btBroadphasePairArray & getOverlappingPairArray()=0
virtual void calculateOverlappingPairs(btDispatcher *dispatcher)
calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during th...
BP_FP_INT_TYPE addHandle(const btVector3 &aabbMin, const btVector3 &aabbMax, void *pOwner, int collisionFilterGroup, int collisionFilterMask, btDispatcher *dispatcher)
virtual void destroyProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
virtual void destroyProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
virtual void rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, btBroadphaseRayCallback &rayCallback, const btVector3 &aabbMin=btVector3(0, 0, 0), const btVector3 &aabbMax=btVector3(0, 0, 0))
void updateHandle(BP_FP_INT_TYPE handle, const btVector3 &aabbMin, const btVector3 &aabbMax, btDispatcher *dispatcher)
#define btAlignedFree(ptr)
BP_FP_INT_TYPE m_maxEdges[3]
void sortMinUp(int axis, BP_FP_INT_TYPE edge, btDispatcher *dispatcher, bool updateOverlaps)
virtual void setAabb(btBroadphaseProxy *proxy, const btVector3 &aabbMin, const btVector3 &aabbMax, btDispatcher *dispatcher)
void setOverlappingPairUserCallback(btOverlappingPairCallback *pairCallback)
bool testOverlap2D(const Handle *pHandleA, const Handle *pHandleB, int axis0, int axis1)
BP_FP_INT_TYPE m_bpHandleMask
virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy *proxy0, btDispatcher *dispatcher)=0
The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
const btOverlappingPairCache * getOverlappingPairCache() const
virtual ~btOverlappingPairCache()
Handle * getHandle(BP_FP_INT_TYPE index) const
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
btBroadphaseProxy * m_pProxy1
void sortMinDown(int axis, BP_FP_INT_TYPE edge, btDispatcher *dispatcher, bool updateOverlaps)
btCollisionAlgorithm * m_algorithm
btOverlappingPairCache * m_nullPairCache
btVector3 can be used to represent 3D points and vectors.
virtual bool process(const btBroadphaseProxy *proxy)=0
int size() const
return the number of elements in the array
btOverlappingPairCache * m_pairCache
btBroadphaseProxy * m_pProxy0
const btOverlappingPairCallback * getOverlappingPairUserCallback() const
btDbvtBroadphase * m_raycastAccelerator
additional dynamic aabb structure, used to accelerate ray cast queries.
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=0
BP_FP_INT_TYPE allocHandle()
void sortMaxDown(int axis, BP_FP_INT_TYPE edge, btDispatcher *dispatcher, bool updateOverlaps)
void resize(int newsize, const T &fillData=T())
The internal templace class btAxisSweep3Internal implements the sweep and prune broadphase.
btOverlappingPairCache * getOverlappingPairCache()
void SetNextFree(BP_FP_INT_TYPE next)
#define btAlignedAlloc(size, alignment)
BP_FP_INT_TYPE m_numHandles
void setMax(const btVector3 &other)
Set each element to the max of the current values and the values of another btVector3.
virtual ~btAxisSweep3Internal()
void unQuantize(btBroadphaseProxy *proxy, btVector3 &aabbMin, btVector3 &aabbMax) const
unQuantize should be conservative: aabbMin/aabbMax should be larger then 'getAabb' result
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
BT_DECLARE_ALIGNED_ALLOCATOR()
btAxisSweep3Internal(const btVector3 &worldAabbMin, const btVector3 &worldAabbMax, BP_FP_INT_TYPE handleMask, BP_FP_INT_TYPE handleSentinel, BP_FP_INT_TYPE maxHandles=16384, btOverlappingPairCache *pairCache=0, bool disableRaycastAccelerator=false)
virtual void getBroadphaseAabb(btVector3 &aabbMin, btVector3 &aabbMax) const
getAabb returns the axis aligned bounding box in the 'global' coordinate frame will add some transfor...
btBroadphaseProxy * createProxy(const btVector3 &aabbMin, const btVector3 &aabbMax, int shapeType, void *userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher *dispatcher)
Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman,...
const btScalar & getX() const
Return the x value.
The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/rem...
void setMin(const btVector3 &other)
Set each element to the min of the current values and the values of another btVector3.
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
void quickSort(const L &CompareFunc)
virtual void * removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher)=0
virtual btBroadphaseProxy * createProxy(const btVector3 &aabbMin, const btVector3 &aabbMax, int shapeType, void *userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher *dispatcher)
virtual void aabbTest(const btVector3 &aabbMin, const btVector3 &aabbMax, btBroadphaseAabbCallback &callback)
btOverlappingPairCallback * m_userPairCallback
btOverlappingPairCallback is an additional optional user callback for adding/removing overlapping pai...
The btBroadphasePair class contains a pair of aabb-overlapping objects.