| Bullet Collision Detection & Physics Library
    | 
 
 
 
Go to the documentation of this file.
   25                                                                                                                            m_ghostPairCallback(0)
 
   27         int initialAllocatedSize = 2;
 
   58                         : m_cleanProxy(cleanProxy),
 
   59                           m_pairCache(pairCache),
 
   60                           m_dispatcher(dispatcher)
 
   74         CleanPairCallback cleanPairs(proxy, 
this, dispatcher);
 
   87                         : m_obsoleteProxy(obsoleteProxy)
 
   92                         return ((pair.
m_pProxy0 == m_obsoleteProxy) ||
 
   97         RemovePairCallback removeCallback(proxy);
 
  106         int proxyId1 = proxy0->
getUid();
 
  107         int proxyId2 = proxy1->
getUid();
 
  151                 for (i = 0; i < newCapacity; ++i)
 
  155                 for (i = 0; i < newCapacity; ++i)
 
  160                 for (i = 0; i < curHashtableSize; i++)
 
  178         int proxyId1 = proxy0->
getUid();
 
  179         int proxyId2 = proxy1->
getUid();
 
  210         if (oldCapacity < newCapacity)
 
  233         int proxyId1 = proxy0->
getUid();
 
  234         int proxyId2 = proxy1->
getUid();
 
  262         while (index != pairIndex)
 
  288         if (lastPairIndex == pairIndex)
 
  303         while (index != lastPairIndex)
 
  334         BT_PROFILE(
"btHashedOverlappingPairCache::processAllOverlappingPairs");
 
  368                 return uidA0 > uidB0 || (uidA0 == uidB0 && uidA1 > uidB1);
 
  381                         for (
int i = 0; i < indices.
size(); i++)
 
  387                                 indices[i].m_uidA0 = uidA0;
 
  388                                 indices[i].m_uidA1 = uidA1;
 
  389                                 indices[i].m_orgIndex = i;
 
  394                         BT_PROFILE(
"btHashedOverlappingPairCache::processAllOverlappingPairs");
 
  396                         for (i = 0; i < indices.
size();)
 
  426         for (i = 0; i < tmpPairs.
size(); i++)
 
  438         for (i = 0; i < tmpPairs.
size(); i++)
 
  530                                                                                                                            m_hasDeferredRemoval(true),
 
  531                                                                                                                            m_overlapFilterCallback(0),
 
  532                                                                                                                            m_ghostPairCallback(0)
 
  534         int initialAllocatedSize = 2;
 
  564                         : m_cleanProxy(cleanProxy),
 
  565                           m_pairCache(pairCache),
 
  566                           m_dispatcher(dispatcher)
 
  580         CleanPairCallback cleanPairs(proxy, 
this, dispatcher);
 
  593                         : m_obsoleteProxy(obsoleteProxy)
 
  598                         return ((pair.
m_pProxy0 == m_obsoleteProxy) ||
 
  603         RemovePairCallback removeCallback(proxy);
 
  
btBroadphasePairArray m_overlappingPairArray
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *dispatcher)
btOverlappingPairCallback * m_ghostPairCallback
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
virtual ~btCollisionAlgorithm()
btHashedOverlappingPairCache()
unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
virtual void sortOverlappingPairs(btDispatcher *dispatcher)
btBroadphasePairArray & getOverlappingPairArray()
void quickSort(const L &CompareFunc)
int findLinearSearch(const T &key) const
void cleanProxyFromPairs(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
virtual void * removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher)=0
btSortedOverlappingPairCache()
btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
btAlignedObjectArray< int > m_next
btBroadphasePairArray m_overlappingPairArray
virtual void sortOverlappingPairs(btDispatcher *dispatcher)
virtual void freeCollisionAlgorithm(void *ptr)=0
void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)
btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
this findPair becomes really slow.
bool equalsPair(const btBroadphasePair &pair, int proxyId1, int proxyId2)
btOverlappingPairCallback * m_ghostPairCallback
void swap(int index0, int index1)
void resize(int newsize, const T &fillData=T())
btBroadphaseProxy * m_pProxy1
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
btCollisionAlgorithm * m_algorithm
virtual void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)=0
void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=0
btBroadphaseProxy * m_pProxy0
bool m_deterministicOverlappingPairs
virtual void * removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher)
void cleanProxyFromPairs(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
int capacity() const
return the pre-allocated (reserved) elements, this is at least as large as the total number of elemen...
void * removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher)
bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
btBroadphasePair * internalAddPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
bool operator()(const MyPairIndex &a, const MyPairIndex &b) const
void removeOverlappingPairsContainingProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
virtual bool hasDeferredRemoval()
void removeOverlappingPairsContainingProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
void push_back(const T &_Val)
virtual ~btSortedOverlappingPairCache()
T & expandNonInitializing()
btAlignedObjectArray< int > m_hashTable
btBroadphasePair * internalFindPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, int hash)
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *dispatcher)
The btBroadphasePair class contains a pair of aabb-overlapping objects.
int size() const
return the number of elements in the array
virtual ~btHashedOverlappingPairCache()
virtual bool processOverlap(btBroadphasePair &pair)=0