Back to index

supertuxkart  0.5+dfsg1
Classes | Public Member Functions | Protected Member Functions | Protected Attributes
btAxisSweep3Internal< BP_FP_INT_TYPE > Class Template Reference

btAxisSweep3Internal is an internal template class that implements sweep and prune. Dont use this class directly, use btAxisSweep3 or bt32BitAxisSweep3 instead. More...

#include <btAxisSweep3.h>

Inheritance diagram for btAxisSweep3Internal< BP_FP_INT_TYPE >:
Inheritance graph
[legend]
Collaboration diagram for btAxisSweep3Internal< BP_FP_INT_TYPE >:
Collaboration graph
[legend]

List of all members.

Classes

class  Edge

Public Member Functions

 ATTRIBUTE_ALIGNED16 (class) Handle
 btAxisSweep3Internal (const btPoint3 &worldAabbMin, const btPoint3 &worldAabbMax, BP_FP_INT_TYPE handleMask, BP_FP_INT_TYPE handleSentinel, BP_FP_INT_TYPE maxHandles=16384, btOverlappingPairCache *pairCache=0)
virtual ~btAxisSweep3Internal ()
BP_FP_INT_TYPE getNumHandles () const
virtual void calculateOverlappingPairs (btDispatcher *dispatcher)
 calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb
BP_FP_INT_TYPE addHandle (const btPoint3 &aabbMin, const btPoint3 &aabbMax, void *pOwner, short int collisionFilterGroup, short int collisionFilterMask, btDispatcher *dispatcher, void *multiSapProxy)
void removeHandle (BP_FP_INT_TYPE handle, btDispatcher *dispatcher)
void updateHandle (BP_FP_INT_TYPE handle, const btPoint3 &aabbMin, const btPoint3 &aabbMax, btDispatcher *dispatcher)
SIMD_FORCE_INLINE Handle * getHandle (BP_FP_INT_TYPE index) const
void processAllOverlappingPairs (btOverlapCallback *callback)
virtual btBroadphaseProxy * createProxy (const btVector3 &aabbMin, const btVector3 &aabbMax, int shapeType, void *userPtr, short int collisionFilterGroup, short int collisionFilterMask, btDispatcher *dispatcher, void *multiSapProxy)
virtual void destroyProxy (btBroadphaseProxy *proxy, btDispatcher *dispatcher)
virtual void setAabb (btBroadphaseProxy *proxy, const btVector3 &aabbMin, const btVector3 &aabbMax, btDispatcher *dispatcher)
bool testAabbOverlap (btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
btOverlappingPairCachegetOverlappingPairCache ()
const btOverlappingPairCachegetOverlappingPairCache () const
void setOverlappingPairUserCallback (btOverlappingPairCallback *pairCallback)
const btOverlappingPairCallbackgetOverlappingPairUserCallback () const
virtual void getBroadphaseAabb (btVector3 &aabbMin, btVector3 &aabbMax) const
 getAabb returns the axis aligned bounding box in the 'global' coordinate frame will add some transform later
virtual void printStats ()

Protected Member Functions

BP_FP_INT_TYPE allocHandle ()
void freeHandle (BP_FP_INT_TYPE handle)
bool testOverlap (int ignoreAxis, const Handle *pHandleA, const Handle *pHandleB)
void quantize (BP_FP_INT_TYPE *out, const btPoint3 &point, int isMax) const
void sortMinDown (int axis, BP_FP_INT_TYPE edge, btDispatcher *dispatcher, bool updateOverlaps)
void sortMinUp (int axis, BP_FP_INT_TYPE edge, btDispatcher *dispatcher, bool updateOverlaps)
void sortMaxDown (int axis, BP_FP_INT_TYPE edge, btDispatcher *dispatcher, bool updateOverlaps)
void sortMaxUp (int axis, BP_FP_INT_TYPE edge, btDispatcher *dispatcher, bool updateOverlaps)

Protected Attributes

BP_FP_INT_TYPE m_bpHandleMask
BP_FP_INT_TYPE m_handleSentinel
btPoint3 m_worldAabbMin
btPoint3 m_worldAabbMax
btVector3 m_quantize
BP_FP_INT_TYPE m_numHandles
BP_FP_INT_TYPE m_maxHandles
Handle * m_pHandles
BP_FP_INT_TYPE m_firstFreeHandle
Edgem_pEdges [3]
btOverlappingPairCachem_pairCache
btOverlappingPairCallbackm_userPairCallback
 btOverlappingPairCallback is an additional optional user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache.
bool m_ownsPairCache
int m_invalidPair

Detailed Description

template<typename BP_FP_INT_TYPE>
class btAxisSweep3Internal< BP_FP_INT_TYPE >

btAxisSweep3Internal is an internal template class that implements sweep and prune. Dont use this class directly, use btAxisSweep3 or bt32BitAxisSweep3 instead.

Definition at line 34 of file btAxisSweep3.h.


Constructor & Destructor Documentation

template<typename BP_FP_INT_TYPE>
btAxisSweep3Internal< BP_FP_INT_TYPE >::btAxisSweep3Internal ( const btPoint3 worldAabbMin,
const btPoint3 worldAabbMax,
BP_FP_INT_TYPE  handleMask,
BP_FP_INT_TYPE  handleSentinel,
BP_FP_INT_TYPE  maxHandles = 16384,
btOverlappingPairCache pairCache = 0 
)

Definition at line 242 of file btAxisSweep3.h.

:m_bpHandleMask(handleMask),
m_handleSentinel(handleSentinel),
m_pairCache(pairCache),
m_userPairCallback(0),
m_ownsPairCache(false),
m_invalidPair(0)
{
       BP_FP_INT_TYPE maxHandles = userMaxHandles+1;//need to add one sentinel handle

       if (!m_pairCache)
       {
              void* ptr = btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16);
              m_pairCache = new(ptr) btHashedOverlappingPairCache();
              m_ownsPairCache = true;
       }

       //assert(bounds.HasVolume());

       // init bounds
       m_worldAabbMin = worldAabbMin;
       m_worldAabbMax = worldAabbMax;

       btVector3 aabbSize = m_worldAabbMax - m_worldAabbMin;

       BP_FP_INT_TYPE       maxInt = m_handleSentinel;

       m_quantize = btVector3(btScalar(maxInt),btScalar(maxInt),btScalar(maxInt)) / aabbSize;

       // allocate handles buffer and put all handles on free list
       void* ptr = btAlignedAlloc(sizeof(Handle)*maxHandles,16);
       m_pHandles = new(ptr) Handle[maxHandles];
       m_maxHandles = maxHandles;
       m_numHandles = 0;

       // handle 0 is reserved as the null index, and is also used as the sentinel
       m_firstFreeHandle = 1;
       {
              for (BP_FP_INT_TYPE i = m_firstFreeHandle; i < maxHandles; i++)
                     m_pHandles[i].SetNextFree(i + 1);
              m_pHandles[maxHandles - 1].SetNextFree(0);
       }

       {
              // allocate edge buffers
              for (int i = 0; i < 3; i++)
              {
                     void* ptr = btAlignedAlloc(sizeof(Edge)*maxHandles*2,16);
                     m_pEdges[i] = new(ptr) Edge[maxHandles * 2];
              }
       }
       //removed overlap management

       // make boundary sentinels
       
       m_pHandles[0].m_clientObject = 0;

       for (int axis = 0; axis < 3; axis++)
       {
              m_pHandles[0].m_minEdges[axis] = 0;
              m_pHandles[0].m_maxEdges[axis] = 1;

              m_pEdges[axis][0].m_pos = 0;
              m_pEdges[axis][0].m_handle = 0;
              m_pEdges[axis][1].m_pos = m_handleSentinel;
              m_pEdges[axis][1].m_handle = 0;
#ifdef DEBUG_BROADPHASE
              debugPrintAxis(axis);
#endif //DEBUG_BROADPHASE

       }

}
template<typename BP_FP_INT_TYPE >
btAxisSweep3Internal< BP_FP_INT_TYPE >::~btAxisSweep3Internal ( ) [virtual]

Definition at line 317 of file btAxisSweep3.h.

{
       
       for (int i = 2; i >= 0; i--)
       {
              btAlignedFree(m_pEdges[i]);
       }
       btAlignedFree(m_pHandles);

       if (m_ownsPairCache)
       {
              m_pairCache->~btOverlappingPairCache();
              btAlignedFree(m_pairCache);
       }
}

Member Function Documentation

template<typename BP_FP_INT_TYPE >
BP_FP_INT_TYPE btAxisSweep3Internal< BP_FP_INT_TYPE >::addHandle ( const btPoint3 aabbMin,
const btPoint3 aabbMax,
void *  pOwner,
short int  collisionFilterGroup,
short int  collisionFilterMask,
btDispatcher dispatcher,
void *  multiSapProxy 
)

Definition at line 376 of file btAxisSweep3.h.

{
       // quantize the bounds
       BP_FP_INT_TYPE min[3], max[3];
       quantize(min, aabbMin, 0);
       quantize(max, aabbMax, 1);

       // allocate a handle
       BP_FP_INT_TYPE handle = allocHandle();
       

       Handle* pHandle = getHandle(handle);
       
       pHandle->m_uniqueId = handle;
       //pHandle->m_pOverlaps = 0;
       pHandle->m_clientObject = pOwner;
       pHandle->m_collisionFilterGroup = collisionFilterGroup;
       pHandle->m_collisionFilterMask = collisionFilterMask;
       pHandle->m_multiSapParentProxy = multiSapProxy;

       // compute current limit of edge arrays
       BP_FP_INT_TYPE limit = m_numHandles * 2;

       
       // insert new edges just inside the max boundary edge
       for (BP_FP_INT_TYPE axis = 0; axis < 3; axis++)
       {

              m_pHandles[0].m_maxEdges[axis] += 2;

              m_pEdges[axis][limit + 1] = m_pEdges[axis][limit - 1];

              m_pEdges[axis][limit - 1].m_pos = min[axis];
              m_pEdges[axis][limit - 1].m_handle = handle;

              m_pEdges[axis][limit].m_pos = max[axis];
              m_pEdges[axis][limit].m_handle = handle;

              pHandle->m_minEdges[axis] = limit - 1;
              pHandle->m_maxEdges[axis] = limit;
       }

       // now sort the new edges to their correct position
       sortMinDown(0, pHandle->m_minEdges[0], dispatcher,false);
       sortMaxDown(0, pHandle->m_maxEdges[0], dispatcher,false);
       sortMinDown(1, pHandle->m_minEdges[1], dispatcher,false);
       sortMaxDown(1, pHandle->m_maxEdges[1], dispatcher,false);
       sortMinDown(2, pHandle->m_minEdges[2], dispatcher,true);
       sortMaxDown(2, pHandle->m_maxEdges[2], dispatcher,true);


       return handle;
}
template<typename BP_FP_INT_TYPE >
BP_FP_INT_TYPE btAxisSweep3Internal< BP_FP_INT_TYPE >::allocHandle ( ) [protected]

Definition at line 352 of file btAxisSweep3.h.

{
       assert(m_firstFreeHandle);

       BP_FP_INT_TYPE handle = m_firstFreeHandle;
       m_firstFreeHandle = getHandle(handle)->GetNextFree();
       m_numHandles++;

       return handle;
}
template<typename BP_FP_INT_TYPE>
btAxisSweep3Internal< BP_FP_INT_TYPE >::ATTRIBUTE_ALIGNED16 ( class  ) [inline]

Definition at line 54 of file btAxisSweep3.h.

                                         : public btBroadphaseProxy
       {
       public:
       BT_DECLARE_ALIGNED_ALLOCATOR();
       
              // indexes into the edge arrays
              BP_FP_INT_TYPE m_minEdges[3], m_maxEdges[3];            // 6 * 2 = 12
//            BP_FP_INT_TYPE m_uniqueId;
              BP_FP_INT_TYPE m_pad;
              
              //void* m_pOwner; this is now in btBroadphaseProxy.m_clientObject
       
              SIMD_FORCE_INLINE void SetNextFree(BP_FP_INT_TYPE next) {m_minEdges[0] = next;}
              SIMD_FORCE_INLINE BP_FP_INT_TYPE GetNextFree() const {return m_minEdges[0];}
       };            // 24 bytes + 24 for Edge structures = 44 bytes total per entry
template<typename BP_FP_INT_TYPE >
void btAxisSweep3Internal< BP_FP_INT_TYPE >::calculateOverlappingPairs ( btDispatcher dispatcher) [virtual]

calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb

if you don't like to skip the invalid pairs in the array, execute following code:

Implements btBroadphaseInterface.

Definition at line 492 of file btAxisSweep3.h.

{

       if (m_pairCache->hasDeferredRemoval())
       {
       
              btBroadphasePairArray&      overlappingPairArray = m_pairCache->getOverlappingPairArray();

              //perform a sort, to find duplicates and to sort 'invalid' pairs to the end
              overlappingPairArray.quickSort(btBroadphasePairSortPredicate());

              overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
              m_invalidPair = 0;

              
              int i;

              btBroadphasePair previousPair;
              previousPair.m_pProxy0 = 0;
              previousPair.m_pProxy1 = 0;
              previousPair.m_algorithm = 0;
              
              
              for (i=0;i<overlappingPairArray.size();i++)
              {
              
                     btBroadphasePair& pair = overlappingPairArray[i];

                     bool isDuplicate = (pair == previousPair);

                     previousPair = pair;

                     bool needsRemoval = false;

                     if (!isDuplicate)
                     {
                            bool hasOverlap = testAabbOverlap(pair.m_pProxy0,pair.m_pProxy1);

                            if (hasOverlap)
                            {
                                   needsRemoval = false;//callback->processOverlap(pair);
                            } else
                            {
                                   needsRemoval = true;
                            }
                     } else
                     {
                            //remove duplicate
                            needsRemoval = true;
                            //should have no algorithm
                            btAssert(!pair.m_algorithm);
                     }
                     
                     if (needsRemoval)
                     {
                            m_pairCache->cleanOverlappingPair(pair,dispatcher);

              //            m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
              //            m_overlappingPairArray.pop_back();
                            pair.m_pProxy0 = 0;
                            pair.m_pProxy1 = 0;
                            m_invalidPair++;
                            gOverlappingPairs--;
                     } 
                     
              }

       #define CLEAN_INVALID_PAIRS 1
       #ifdef CLEAN_INVALID_PAIRS

              //perform a sort, to sort 'invalid' pairs to the end
              overlappingPairArray.quickSort(btBroadphasePairSortPredicate());

              overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
              m_invalidPair = 0;
       #endif//CLEAN_INVALID_PAIRS
              
              //printf("overlappingPairArray.size()=%d\n",overlappingPairArray.size());
       }



       

}

Here is the call graph for this function:

template<typename BP_FP_INT_TYPE >
btBroadphaseProxy * btAxisSweep3Internal< BP_FP_INT_TYPE >::createProxy ( const btVector3 aabbMin,
const btVector3 aabbMax,
int  shapeType,
void *  userPtr,
short int  collisionFilterGroup,
short int  collisionFilterMask,
btDispatcher dispatcher,
void *  multiSapProxy 
) [virtual]

Implements btBroadphaseInterface.

Definition at line 210 of file btAxisSweep3.h.

{
              (void)shapeType;
              BP_FP_INT_TYPE handleId = addHandle(aabbMin,aabbMax, userPtr,collisionFilterGroup,collisionFilterMask,dispatcher,multiSapProxy);
              
              Handle* handle = getHandle(handleId);
                            
              return handle;
}
template<typename BP_FP_INT_TYPE >
void btAxisSweep3Internal< BP_FP_INT_TYPE >::destroyProxy ( btBroadphaseProxy *  proxy,
btDispatcher dispatcher 
) [virtual]

Implements btBroadphaseInterface.

Definition at line 223 of file btAxisSweep3.h.

{
       Handle* handle = static_cast<Handle*>(proxy);
       removeHandle(handle->m_uniqueId,dispatcher);
}
template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::freeHandle ( BP_FP_INT_TYPE  handle) [protected]

Definition at line 364 of file btAxisSweep3.h.

{
       assert(handle > 0 && handle < m_maxHandles);

       getHandle(handle)->SetNextFree(m_firstFreeHandle);
       m_firstFreeHandle = handle;

       m_numHandles--;
}
template<typename BP_FP_INT_TYPE>
virtual void btAxisSweep3Internal< BP_FP_INT_TYPE >::getBroadphaseAabb ( btVector3 aabbMin,
btVector3 aabbMax 
) const [inline, virtual]

getAabb returns the axis aligned bounding box in the 'global' coordinate frame will add some transform later

Implements btBroadphaseInterface.

Definition at line 161 of file btAxisSweep3.h.

       {
              aabbMin = m_worldAabbMin;
              aabbMax = m_worldAabbMax;
       }
template<typename BP_FP_INT_TYPE>
SIMD_FORCE_INLINE Handle* btAxisSweep3Internal< BP_FP_INT_TYPE >::getHandle ( BP_FP_INT_TYPE  index) const [inline]

Definition at line 130 of file btAxisSweep3.h.

{return m_pHandles + index;}
template<typename BP_FP_INT_TYPE>
BP_FP_INT_TYPE btAxisSweep3Internal< BP_FP_INT_TYPE >::getNumHandles ( ) const [inline]

Definition at line 120 of file btAxisSweep3.h.

       {
              return m_numHandles;
       }
template<typename BP_FP_INT_TYPE>
btOverlappingPairCache* btAxisSweep3Internal< BP_FP_INT_TYPE >::getOverlappingPairCache ( ) [inline, virtual]

Implements btBroadphaseInterface.

Definition at line 141 of file btAxisSweep3.h.

       {
              return m_pairCache;
       }
template<typename BP_FP_INT_TYPE>
const btOverlappingPairCache* btAxisSweep3Internal< BP_FP_INT_TYPE >::getOverlappingPairCache ( ) const [inline, virtual]

Implements btBroadphaseInterface.

Definition at line 145 of file btAxisSweep3.h.

       {
              return m_pairCache;
       }
template<typename BP_FP_INT_TYPE>
const btOverlappingPairCallback* btAxisSweep3Internal< BP_FP_INT_TYPE >::getOverlappingPairUserCallback ( ) const [inline]

Definition at line 154 of file btAxisSweep3.h.

       {
              return m_userPairCallback;
       }
template<typename BP_FP_INT_TYPE>
virtual void btAxisSweep3Internal< BP_FP_INT_TYPE >::printStats ( ) [inline, virtual]

Implements btBroadphaseInterface.

Definition at line 167 of file btAxisSweep3.h.

       {
/*            printf("btAxisSweep3.h\n");
              printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles);
              printf("aabbMin=%f,%f,%f,aabbMax=%f,%f,%f\n",m_worldAabbMin.getX(),m_worldAabbMin.getY(),m_worldAabbMin.getZ(),
                     m_worldAabbMax.getX(),m_worldAabbMax.getY(),m_worldAabbMax.getZ());
                     */

       }
template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::processAllOverlappingPairs ( btOverlapCallback callback)
template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::quantize ( BP_FP_INT_TYPE *  out,
const btPoint3 point,
int  isMax 
) const [protected]

Definition at line 334 of file btAxisSweep3.h.

{
       btPoint3 clampedPoint(point);
       


       clampedPoint.setMax(m_worldAabbMin);
       clampedPoint.setMin(m_worldAabbMax);

       btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize;
       out[0] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getX() & m_bpHandleMask) | isMax);
       out[1] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getY() & m_bpHandleMask) | isMax);
       out[2] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getZ() & m_bpHandleMask) | isMax);
       
}

Here is the call graph for this function:

template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::removeHandle ( BP_FP_INT_TYPE  handle,
btDispatcher dispatcher 
)

Definition at line 432 of file btAxisSweep3.h.

{

       Handle* pHandle = getHandle(handle);

       //explicitly remove the pairs containing the proxy
       //we could do it also in the sortMinUp (passing true)
       //todo: compare performance
       if (!m_pairCache->hasDeferredRemoval())
       {
              m_pairCache->removeOverlappingPairsContainingProxy(pHandle,dispatcher);
       }

       // compute current limit of edge arrays
       int limit = m_numHandles * 2;
       
       int axis;

       for (axis = 0;axis<3;axis++)
       {
              m_pHandles[0].m_maxEdges[axis] -= 2;
       }

       // remove the edges by sorting them up to the end of the list
       for ( axis = 0; axis < 3; axis++)
       {
              Edge* pEdges = m_pEdges[axis];
              BP_FP_INT_TYPE max = pHandle->m_maxEdges[axis];
              pEdges[max].m_pos = m_handleSentinel;

              sortMaxUp(axis,max,dispatcher,false);


              BP_FP_INT_TYPE i = pHandle->m_minEdges[axis];
              pEdges[i].m_pos = m_handleSentinel;


              sortMinUp(axis,i,dispatcher,false);

              pEdges[limit-1].m_handle = 0;
              pEdges[limit-1].m_pos = m_handleSentinel;
              
#ifdef DEBUG_BROADPHASE
                     debugPrintAxis(axis,false);
#endif //DEBUG_BROADPHASE


       }


       // free the handle
       freeHandle(handle);

       
}
template<typename BP_FP_INT_TYPE >
void btAxisSweep3Internal< BP_FP_INT_TYPE >::setAabb ( btBroadphaseProxy *  proxy,
const btVector3 aabbMin,
const btVector3 aabbMax,
btDispatcher dispatcher 
) [virtual]

Implements btBroadphaseInterface.

Definition at line 230 of file btAxisSweep3.h.

{
       Handle* handle = static_cast<Handle*>(proxy);
       updateHandle(handle->m_uniqueId,aabbMin,aabbMax,dispatcher);

}
template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::setOverlappingPairUserCallback ( btOverlappingPairCallback pairCallback) [inline]

Definition at line 150 of file btAxisSweep3.h.

       {
              m_userPairCallback = pairCallback;
       }
template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::sortMaxDown ( int  axis,
BP_FP_INT_TYPE  edge,
btDispatcher dispatcher,
bool  updateOverlaps 
) [protected]

Definition at line 782 of file btAxisSweep3.h.

{

       Edge* pEdge = m_pEdges[axis] + edge;
       Edge* pPrev = pEdge - 1;
       Handle* pHandleEdge = getHandle(pEdge->m_handle);

       while (pEdge->m_pos < pPrev->m_pos)
       {
              Handle* pHandlePrev = getHandle(pPrev->m_handle);

              if (!pPrev->IsMax())
              {
                     // if previous edge was a minimum remove any overlap between the two handles
                     if (updateOverlaps)
                     {
                            //this is done during the overlappingpairarray iteration/narrowphase collision

                            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,dispatcher);
                     


                     }

                     // update edge reference in other handle
                     pHandlePrev->m_minEdges[axis]++;;
              }
              else
                     pHandlePrev->m_maxEdges[axis]++;

              pHandleEdge->m_maxEdges[axis]--;

              // swap the edges
              Edge swap = *pEdge;
              *pEdge = *pPrev;
              *pPrev = swap;

              // decrement
              pEdge--;
              pPrev--;
       }

       
#ifdef DEBUG_BROADPHASE
       debugPrintAxis(axis);
#endif //DEBUG_BROADPHASE

}

Here is the call graph for this function:

template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::sortMaxUp ( int  axis,
BP_FP_INT_TYPE  edge,
btDispatcher dispatcher,
bool  updateOverlaps 
) [protected]

Definition at line 837 of file btAxisSweep3.h.

{
       Edge* pEdge = m_pEdges[axis] + edge;
       Edge* pNext = pEdge + 1;
       Handle* pHandleEdge = getHandle(pEdge->m_handle);

       while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos))
       {
              Handle* pHandleNext = getHandle(pNext->m_handle);

              if (!pNext->IsMax())
              {
                     // if next edge is a minimum check the bounds and add an overlap if necessary
                     if (updateOverlaps && testOverlap(axis, pHandleEdge, pHandleNext))
                     {
                            Handle* handle0 = getHandle(pEdge->m_handle);
                            Handle* handle1 = getHandle(pNext->m_handle);
                            m_pairCache->addOverlappingPair(handle0,handle1);
                            if (m_userPairCallback)
                                   m_userPairCallback->addOverlappingPair(handle0,handle1);
                     }

                     // update edge reference in other handle
                     pHandleNext->m_minEdges[axis]--;
              }
              else
                     pHandleNext->m_maxEdges[axis]--;

              pHandleEdge->m_maxEdges[axis]++;

              // swap the edges
              Edge swap = *pEdge;
              *pEdge = *pNext;
              *pNext = swap;

              // increment
              pEdge++;
              pNext++;
       }
       
}

Here is the call graph for this function:

template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::sortMinDown ( int  axis,
BP_FP_INT_TYPE  edge,
btDispatcher dispatcher,
bool  updateOverlaps 
) [protected]

Definition at line 683 of file btAxisSweep3.h.

{

       Edge* pEdge = m_pEdges[axis] + edge;
       Edge* pPrev = pEdge - 1;
       Handle* pHandleEdge = getHandle(pEdge->m_handle);

       while (pEdge->m_pos < pPrev->m_pos)
       {
              Handle* pHandlePrev = getHandle(pPrev->m_handle);

              if (pPrev->IsMax())
              {
                     // if previous edge is a maximum check the bounds and add an overlap if necessary
                     if (updateOverlaps && testOverlap(axis,pHandleEdge, pHandlePrev))
                     {
                            m_pairCache->addOverlappingPair(pHandleEdge,pHandlePrev);
                            if (m_userPairCallback)
                                   m_userPairCallback->addOverlappingPair(pHandleEdge,pHandlePrev);

                            //AddOverlap(pEdge->m_handle, pPrev->m_handle);

                     }

                     // update edge reference in other handle
                     pHandlePrev->m_maxEdges[axis]++;
              }
              else
                     pHandlePrev->m_minEdges[axis]++;

              pHandleEdge->m_minEdges[axis]--;

              // swap the edges
              Edge swap = *pEdge;
              *pEdge = *pPrev;
              *pPrev = swap;

              // decrement
              pEdge--;
              pPrev--;
       }

#ifdef DEBUG_BROADPHASE
       debugPrintAxis(axis);
#endif //DEBUG_BROADPHASE

}

Here is the call graph for this function:

template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::sortMinUp ( int  axis,
BP_FP_INT_TYPE  edge,
btDispatcher dispatcher,
bool  updateOverlaps 
) [protected]

Definition at line 733 of file btAxisSweep3.h.

{
       Edge* pEdge = m_pEdges[axis] + edge;
       Edge* pNext = pEdge + 1;
       Handle* pHandleEdge = getHandle(pEdge->m_handle);

       while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos))
       {
              Handle* pHandleNext = getHandle(pNext->m_handle);

              if (pNext->IsMax())
              {

                     // if next edge is maximum remove any overlap between the two handles
                     if (updateOverlaps)
                     {
                            Handle* handle0 = getHandle(pEdge->m_handle);
                            Handle* handle1 = getHandle(pNext->m_handle);

                            m_pairCache->removeOverlappingPair(handle0,handle1,dispatcher);       
                            if (m_userPairCallback)
                                   m_userPairCallback->removeOverlappingPair(handle0,handle1,dispatcher);
                            
                     }


                     // update edge reference in other handle
                     pHandleNext->m_maxEdges[axis]--;
              }
              else
                     pHandleNext->m_minEdges[axis]--;

              pHandleEdge->m_minEdges[axis]++;

              // swap the edges
              Edge swap = *pEdge;
              *pEdge = *pNext;
              *pNext = swap;

              // increment
              pEdge++;
              pNext++;
       }


}

Here is the call graph for this function:

template<typename BP_FP_INT_TYPE >
bool btAxisSweep3Internal< BP_FP_INT_TYPE >::testAabbOverlap ( btBroadphaseProxy *  proxy0,
btBroadphaseProxy *  proxy1 
)

Definition at line 581 of file btAxisSweep3.h.

{
       const Handle* pHandleA = static_cast<Handle*>(proxy0);
       const Handle* pHandleB = static_cast<Handle*>(proxy1);
       
       //optimization 1: check the array index (memory address), instead of the m_pos

       for (int axis = 0; axis < 3; axis++)
       { 
              if (pHandleA->m_maxEdges[axis] < pHandleB->m_minEdges[axis] || 
                     pHandleB->m_maxEdges[axis] < pHandleA->m_minEdges[axis]) 
              { 
                     return false; 
              } 
       } 
       return true;
}
template<typename BP_FP_INT_TYPE >
bool btAxisSweep3Internal< BP_FP_INT_TYPE >::testOverlap ( int  ignoreAxis,
const Handle *  pHandleA,
const Handle *  pHandleB 
) [protected]

Definition at line 600 of file btAxisSweep3.h.

{
       //optimization 1: check the array index (memory address), instead of the m_pos

       for (int axis = 0; axis < 3; axis++)
       { 
              if (axis != ignoreAxis)
              {
                     if (pHandleA->m_maxEdges[axis] < pHandleB->m_minEdges[axis] || 
                            pHandleB->m_maxEdges[axis] < pHandleA->m_minEdges[axis]) 
                     { 
                            return false; 
                     } 
              }
       } 

       //optimization 2: only 2 axis need to be tested (conflicts with 'delayed removal' optimization)

       /*for (int axis = 0; axis < 3; axis++)
       {
              if (m_pEdges[axis][pHandleA->m_maxEdges[axis]].m_pos < m_pEdges[axis][pHandleB->m_minEdges[axis]].m_pos ||
                     m_pEdges[axis][pHandleB->m_maxEdges[axis]].m_pos < m_pEdges[axis][pHandleA->m_minEdges[axis]].m_pos)
              {
                     return false;
              }
       }
       */

       return true;
}
template<typename BP_FP_INT_TYPE>
void btAxisSweep3Internal< BP_FP_INT_TYPE >::updateHandle ( BP_FP_INT_TYPE  handle,
const btPoint3 aabbMin,
const btPoint3 aabbMax,
btDispatcher dispatcher 
)

Definition at line 632 of file btAxisSweep3.h.

{
//     assert(bounds.IsFinite());
       //assert(bounds.HasVolume());

       Handle* pHandle = getHandle(handle);

       // quantize the new bounds
       BP_FP_INT_TYPE min[3], max[3];
       quantize(min, aabbMin, 0);
       quantize(max, aabbMax, 1);

       // update changed edges
       for (int axis = 0; axis < 3; axis++)
       {
              BP_FP_INT_TYPE emin = pHandle->m_minEdges[axis];
              BP_FP_INT_TYPE emax = pHandle->m_maxEdges[axis];

              int dmin = (int)min[axis] - (int)m_pEdges[axis][emin].m_pos;
              int dmax = (int)max[axis] - (int)m_pEdges[axis][emax].m_pos;

              m_pEdges[axis][emin].m_pos = min[axis];
              m_pEdges[axis][emax].m_pos = max[axis];

              // expand (only adds overlaps)
              if (dmin < 0)
                     sortMinDown(axis, emin,dispatcher,true);

              if (dmax > 0)
                     sortMaxUp(axis, emax,dispatcher,true);

              // shrink (only removes overlaps)
              if (dmin > 0)
                     sortMinUp(axis, emin,dispatcher,true);

              if (dmax < 0)
                     sortMaxDown(axis, emax,dispatcher,true);

#ifdef DEBUG_BROADPHASE
       debugPrintAxis(axis);
#endif //DEBUG_BROADPHASE
       }

       
}

Member Data Documentation

template<typename BP_FP_INT_TYPE>
BP_FP_INT_TYPE btAxisSweep3Internal< BP_FP_INT_TYPE >::m_bpHandleMask [protected]

Definition at line 38 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
BP_FP_INT_TYPE btAxisSweep3Internal< BP_FP_INT_TYPE >::m_firstFreeHandle [protected]

Definition at line 80 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
BP_FP_INT_TYPE btAxisSweep3Internal< BP_FP_INT_TYPE >::m_handleSentinel [protected]

Definition at line 39 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
int btAxisSweep3Internal< BP_FP_INT_TYPE >::m_invalidPair [protected]

Definition at line 91 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
BP_FP_INT_TYPE btAxisSweep3Internal< BP_FP_INT_TYPE >::m_maxHandles [protected]

Definition at line 78 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
BP_FP_INT_TYPE btAxisSweep3Internal< BP_FP_INT_TYPE >::m_numHandles [protected]

Definition at line 77 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
bool btAxisSweep3Internal< BP_FP_INT_TYPE >::m_ownsPairCache [protected]

Definition at line 89 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
btOverlappingPairCache* btAxisSweep3Internal< BP_FP_INT_TYPE >::m_pairCache [protected]

Definition at line 84 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
Edge* btAxisSweep3Internal< BP_FP_INT_TYPE >::m_pEdges[3] [protected]

Definition at line 82 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
Handle* btAxisSweep3Internal< BP_FP_INT_TYPE >::m_pHandles [protected]

Definition at line 79 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
btVector3 btAxisSweep3Internal< BP_FP_INT_TYPE >::m_quantize [protected]

Definition at line 75 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
btOverlappingPairCallback* btAxisSweep3Internal< BP_FP_INT_TYPE >::m_userPairCallback [protected]

btOverlappingPairCallback is an additional optional user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache.

Definition at line 87 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
btPoint3 btAxisSweep3Internal< BP_FP_INT_TYPE >::m_worldAabbMax [protected]

Definition at line 73 of file btAxisSweep3.h.

template<typename BP_FP_INT_TYPE>
btPoint3 btAxisSweep3Internal< BP_FP_INT_TYPE >::m_worldAabbMin [protected]

Definition at line 68 of file btAxisSweep3.h.


The documentation for this class was generated from the following file: