Bullet Collision Detection & Physics Library
btOverlappingPairCache.h
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
16 #ifndef BT_OVERLAPPING_PAIR_CACHE_H
17 #define BT_OVERLAPPING_PAIR_CACHE_H
18 
19 #include "btBroadphaseInterface.h"
20 #include "btBroadphaseProxy.h"
22 
24 class btDispatcher;
25 
27 
29 {
31  {
32  }
33  //return true for deletion of the pair
34  virtual bool processOverlap(btBroadphasePair& pair) = 0;
35 };
36 
38 {
40  {
41  }
42  // return true when pairs need collision
43  virtual bool needBroadphaseCollision(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) const = 0;
44 };
45 
46 const int BT_NULL_PAIR = 0xffffffff;
47 
51 {
52 public:
53  virtual ~btOverlappingPairCache() {} // this is needed so we can get to the derived class destructor
54 
56 
57  virtual const btBroadphasePair* getOverlappingPairArrayPtr() const = 0;
58 
60 
61  virtual void cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher) = 0;
62 
63  virtual int getNumOverlappingPairs() const = 0;
64  virtual bool needsBroadphaseCollision(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1) const = 0;
66  virtual void cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher) = 0;
67 
69 
71 
72  virtual void processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher, const struct btDispatcherInfo& /*dispatchInfo*/)
73  {
74  processAllOverlappingPairs(callback, dispatcher);
75  }
77 
78  virtual bool hasDeferredRemoval() = 0;
79 
80  virtual void setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback) = 0;
81 
82  virtual void sortOverlappingPairs(btDispatcher* dispatcher) = 0;
83 };
84 
86 
89 {
92 
93 protected:
97 
98 public:
100 
102  virtual ~btHashedOverlappingPairCache();
103 
104  void removeOverlappingPairsContainingProxy(btBroadphaseProxy * proxy, btDispatcher * dispatcher);
105 
106  virtual void* removeOverlappingPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1, btDispatcher * dispatcher);
107 
109  {
110  if (m_overlapFilterCallback)
111  return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1);
112 
113  bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
114  collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
115 
116  return collides;
117  }
118 
119  // Add a pair and return the new pair. If the pair already exists,
120  // no new pair is created and the old one is returned.
122  {
123  if (!needsBroadphaseCollision(proxy0, proxy1))
124  return 0;
125 
126  return internalAddPair(proxy0, proxy1);
127  }
128 
129  void cleanProxyFromPairs(btBroadphaseProxy * proxy, btDispatcher * dispatcher);
130 
131  virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher * dispatcher);
132 
133  virtual void processAllOverlappingPairs(btOverlapCallback * callback, btDispatcher * dispatcher, const struct btDispatcherInfo& dispatchInfo);
134 
136  {
137  return &m_overlappingPairArray[0];
138  }
139 
141  {
142  return &m_overlappingPairArray[0];
143  }
144 
146  {
147  return m_overlappingPairArray;
148  }
149 
151  {
152  return m_overlappingPairArray;
153  }
154 
155  void cleanOverlappingPair(btBroadphasePair & pair, btDispatcher * dispatcher);
156 
157  btBroadphasePair* findPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1);
158 
159  int GetCount() const { return m_overlappingPairArray.size(); }
160  // btBroadphasePair* GetPairs() { return m_pairs; }
161 
163  {
164  return m_overlapFilterCallback;
165  }
166 
168  {
169  m_overlapFilterCallback = callback;
170  }
171 
173  {
174  return m_overlappingPairArray.size();
175  }
176 
177 private:
178  btBroadphasePair* internalAddPair(btBroadphaseProxy * proxy0, btBroadphaseProxy * proxy1);
179 
180  void growTables();
181 
182  SIMD_FORCE_INLINE bool equalsPair(const btBroadphasePair& pair, int proxyId1, int proxyId2)
183  {
184  return pair.m_pProxy0->getUid() == proxyId1 && pair.m_pProxy1->getUid() == proxyId2;
185  }
186 
187  /*
188  // Thomas Wang's hash, see: http://www.concentric.net/~Ttwang/tech/inthash.htm
189  // This assumes proxyId1 and proxyId2 are 16-bit.
190  SIMD_FORCE_INLINE int getHash(int proxyId1, int proxyId2)
191  {
192  int key = (proxyId2 << 16) | proxyId1;
193  key = ~key + (key << 15);
194  key = key ^ (key >> 12);
195  key = key + (key << 2);
196  key = key ^ (key >> 4);
197  key = key * 2057;
198  key = key ^ (key >> 16);
199  return key;
200  }
201  */
202 
203  SIMD_FORCE_INLINE unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
204  {
205  unsigned int key = proxyId1 | (proxyId2 << 16);
206  // Thomas Wang's hash
207 
208  key += ~(key << 15);
209  key ^= (key >> 10);
210  key += (key << 3);
211  key ^= (key >> 6);
212  key += ~(key << 11);
213  key ^= (key >> 16);
214  return key;
215  }
216 
218  {
219  int proxyId1 = proxy0->getUid();
220  int proxyId2 = proxy1->getUid();
221 #if 0 // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat.
222  if (proxyId1 > proxyId2)
223  btSwap(proxyId1, proxyId2);
224 #endif
225 
226  int index = m_hashTable[hash];
227 
228  while (index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
229  {
230  index = m_next[index];
231  }
232 
233  if (index == BT_NULL_PAIR)
234  {
235  return NULL;
236  }
237 
238  btAssert(index < m_overlappingPairArray.size());
239 
240  return &m_overlappingPairArray[index];
241  }
242 
243  virtual bool hasDeferredRemoval()
244  {
245  return false;
246  }
247 
248  virtual void setInternalGhostPairCallback(btOverlappingPairCallback * ghostPairCallback)
249  {
250  m_ghostPairCallback = ghostPairCallback;
251  }
252 
253  virtual void sortOverlappingPairs(btDispatcher * dispatcher);
254 };
255 
259 {
260 protected:
261  //avoid brute-force finding all the time
263 
264  //during the dispatch, check that user doesn't destroy/create proxy
266 
269 
270  //if set, use the callback instead of the built in filter in needBroadphaseCollision
272 
274 
275 public:
278 
279  virtual void processAllOverlappingPairs(btOverlapCallback*, btDispatcher* dispatcher);
280 
281  void* removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher);
282 
283  void cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher);
284 
286 
288 
289  void cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher);
290 
292 
294  {
296  return m_overlapFilterCallback->needBroadphaseCollision(proxy0, proxy1);
297 
298  bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
299  collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
300 
301  return collides;
302  }
303 
305  {
306  return m_overlappingPairArray;
307  }
308 
310  {
311  return m_overlappingPairArray;
312  }
313 
315  {
316  return &m_overlappingPairArray[0];
317  }
318 
320  {
321  return &m_overlappingPairArray[0];
322  }
323 
325  {
326  return m_overlappingPairArray.size();
327  }
328 
330  {
332  }
333 
335  {
336  m_overlapFilterCallback = callback;
337  }
338 
339  virtual bool hasDeferredRemoval()
340  {
341  return m_hasDeferredRemoval;
342  }
343 
345  {
346  m_ghostPairCallback = ghostPairCallback;
347  }
348 
349  virtual void sortOverlappingPairs(btDispatcher* dispatcher);
350 };
351 
354 {
356 
357 public:
359  {
360  return &m_overlappingPairArray[0];
361  }
363  {
364  return &m_overlappingPairArray[0];
365  }
367  {
368  return m_overlappingPairArray;
369  }
370 
371  virtual void cleanOverlappingPair(btBroadphasePair& /*pair*/, btDispatcher* /*dispatcher*/)
372  {
373  }
374 
375  virtual int getNumOverlappingPairs() const
376  {
377  return 0;
378  }
379 
380  virtual void cleanProxyFromPairs(btBroadphaseProxy* /*proxy*/, btDispatcher* /*dispatcher*/)
381  {
382  }
383 
385  {
386  return true;
387  }
389  {
390  return 0;
391  }
393  {
394  }
395 
397  {
398  }
399 
401  {
402  return 0;
403  }
404 
405  virtual bool hasDeferredRemoval()
406  {
407  return true;
408  }
409 
410  virtual void setInternalGhostPairCallback(btOverlappingPairCallback* /* ghostPairCallback */)
411  {
412  }
413 
415  {
416  return 0;
417  }
418 
419  virtual void* removeOverlappingPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/, btDispatcher* /*dispatcher*/)
420  {
421  return 0;
422  }
423 
424  virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy* /*proxy0*/, btDispatcher* /*dispatcher*/)
425  {
426  }
427 
428  virtual void sortOverlappingPairs(btDispatcher* dispatcher)
429  {
430  (void)dispatcher;
431  }
432 };
433 
434 #endif //BT_OVERLAPPING_PAIR_CACHE_H
btSortedOverlappingPairCache::m_overlappingPairArray
btBroadphasePairArray m_overlappingPairArray
Definition: btOverlappingPairCache.h:262
btBroadphaseProxy::m_collisionFilterMask
int m_collisionFilterMask
Definition: btBroadphaseProxy.h:104
btSortedOverlappingPairCache::processAllOverlappingPairs
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *dispatcher)
Definition: btOverlappingPairCache.cpp:507
btHashedOverlappingPairCache::m_ghostPairCallback
btOverlappingPairCallback * m_ghostPairCallback
Definition: btOverlappingPairCache.h:96
btOverlappingPairCallback
The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/rem...
Definition: btOverlappingPairCallback.h:25
btNullPairCache::m_overlappingPairArray
btBroadphasePairArray m_overlappingPairArray
Definition: btOverlappingPairCache.h:355
btBroadphaseProxy
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
Definition: btBroadphaseProxy.h:86
BT_NULL_PAIR
const int BT_NULL_PAIR
Definition: btOverlappingPairCache.h:46
btSortedOverlappingPairCache::getOverlapFilterCallback
btOverlapFilterCallback * getOverlapFilterCallback()
Definition: btOverlappingPairCache.h:329
btNullPairCache::getNumOverlappingPairs
virtual int getNumOverlappingPairs() const
Definition: btOverlappingPairCache.h:375
btHashedOverlappingPairCache::setInternalGhostPairCallback
virtual void setInternalGhostPairCallback(btOverlappingPairCallback *ghostPairCallback)
Definition: btOverlappingPairCache.h:248
btOverlappingPairCache::getOverlappingPairArray
virtual btBroadphasePairArray & getOverlappingPairArray()=0
btSortedOverlappingPairCache::getOverlappingPairArray
btBroadphasePairArray & getOverlappingPairArray()
Definition: btOverlappingPairCache.h:304
btNullPairCache
btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing.
Definition: btOverlappingPairCache.h:354
btHashedOverlappingPairCache
Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman,...
Definition: btOverlappingPairCache.h:89
btSortedOverlappingPairCache::m_blockedForChanges
bool m_blockedForChanges
Definition: btOverlappingPairCache.h:265
btHashedOverlappingPairCache::getHash
unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
Definition: btOverlappingPairCache.h:203
btHashedOverlappingPairCache::getOverlapFilterCallback
btOverlapFilterCallback * getOverlapFilterCallback()
Definition: btOverlappingPairCache.h:162
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:77
btHashedOverlappingPairCache::BT_DECLARE_ALIGNED_ALLOCATOR
BT_DECLARE_ALIGNED_ALLOCATOR()
btSortedOverlappingPairCache::sortOverlappingPairs
virtual void sortOverlappingPairs(btDispatcher *dispatcher)
Definition: btOverlappingPairCache.cpp:608
btHashedOverlappingPairCache::getOverlappingPairArray
btBroadphasePairArray & getOverlappingPairArray()
Definition: btOverlappingPairCache.h:145
btNullPairCache::setOverlapFilterCallback
virtual void setOverlapFilterCallback(btOverlapFilterCallback *)
Definition: btOverlappingPairCache.h:392
btSortedOverlappingPairCache::cleanProxyFromPairs
void cleanProxyFromPairs(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
Definition: btOverlappingPairCache.cpp:554
btHashedOverlappingPairCache::getOverlappingPairArrayPtr
const btBroadphasePair * getOverlappingPairArrayPtr() const
Definition: btOverlappingPairCache.h:140
btOverlappingPairCache::getNumOverlappingPairs
virtual int getNumOverlappingPairs() const =0
btHashedOverlappingPairCache::setOverlapFilterCallback
void setOverlapFilterCallback(btOverlapFilterCallback *callback)
Definition: btOverlappingPairCache.h:167
btSortedOverlappingPairCache::btSortedOverlappingPairCache
btSortedOverlappingPairCache()
Definition: btOverlappingPairCache.cpp:529
btNullPairCache::getOverlappingPairArray
btBroadphasePairArray & getOverlappingPairArray()
Definition: btOverlappingPairCache.h:366
btNullPairCache::getOverlappingPairArrayPtr
const btBroadphasePair * getOverlappingPairArrayPtr() const
Definition: btOverlappingPairCache.h:362
btSortedOverlappingPairCache::getNumOverlappingPairs
int getNumOverlappingPairs() const
Definition: btOverlappingPairCache.h:324
btSortedOverlappingPairCache::m_overlapFilterCallback
btOverlapFilterCallback * m_overlapFilterCallback
Definition: btOverlappingPairCache.h:271
btBroadphaseProxy::m_collisionFilterGroup
int m_collisionFilterGroup
Definition: btBroadphaseProxy.h:103
btHashedOverlappingPairCache::m_next
btAlignedObjectArray< int > m_next
Definition: btOverlappingPairCache.h:95
btNullPairCache::findPair
virtual btBroadphasePair * findPair(btBroadphaseProxy *, btBroadphaseProxy *)
Definition: btOverlappingPairCache.h:400
btOverlappingPairCache::processAllOverlappingPairs
virtual void processAllOverlappingPairs(btOverlapCallback *callback, btDispatcher *dispatcher, const struct btDispatcherInfo &)
Definition: btOverlappingPairCache.h:72
btHashedOverlappingPairCache::m_overlappingPairArray
btBroadphasePairArray m_overlappingPairArray
Definition: btOverlappingPairCache.h:90
btHashedOverlappingPairCache::GetCount
int GetCount() const
Definition: btOverlappingPairCache.h:159
btOverlappingPairCache::processAllOverlappingPairs
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *dispatcher)=0
btSortedOverlappingPairCache::findPair
btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
this findPair becomes really slow.
Definition: btOverlappingPairCache.cpp:488
btHashedOverlappingPairCache::equalsPair
bool equalsPair(const btBroadphasePair &pair, int proxyId1, int proxyId2)
Definition: btOverlappingPairCache.h:182
btSortedOverlappingPairCache::m_ghostPairCallback
btOverlappingPairCallback * m_ghostPairCallback
Definition: btOverlappingPairCache.h:273
btAssert
#define btAssert(x)
Definition: btScalar.h:153
btSortedOverlappingPairCache::setOverlapFilterCallback
void setOverlapFilterCallback(btOverlapFilterCallback *callback)
Definition: btOverlappingPairCache.h:334
btHashedOverlappingPairCache::getOverlappingPairArrayPtr
virtual btBroadphasePair * getOverlappingPairArrayPtr()
Definition: btOverlappingPairCache.h:135
btOverlapFilterCallback
Definition: btOverlappingPairCache.h:38
btHashedOverlappingPairCache::getNumOverlappingPairs
int getNumOverlappingPairs() const
Definition: btOverlappingPairCache.h:172
btOverlappingPairCallback.h
btBroadphasePair::m_pProxy1
btBroadphaseProxy * m_pProxy1
Definition: btBroadphaseProxy.h:209
btNullPairCache::getOverlappingPairArrayPtr
virtual btBroadphasePair * getOverlappingPairArrayPtr()
Definition: btOverlappingPairCache.h:358
btOverlappingPairCache
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
Definition: btOverlappingPairCache.h:51
btSortedOverlappingPairCache::setInternalGhostPairCallback
virtual void setInternalGhostPairCallback(btOverlappingPairCallback *ghostPairCallback)
Definition: btOverlappingPairCache.h:344
btSortedOverlappingPairCache::addOverlappingPair
btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
Definition: btOverlappingPairCache.cpp:468
btOverlappingPairCache::getOverlappingPairArrayPtr
virtual btBroadphasePair * getOverlappingPairArrayPtr()=0
btHashedOverlappingPairCache::getOverlappingPairArray
const btBroadphasePairArray & getOverlappingPairArray() const
Definition: btOverlappingPairCache.h:150
btOverlappingPairCache::cleanOverlappingPair
virtual void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)=0
btNullPairCache::cleanOverlappingPair
virtual void cleanOverlappingPair(btBroadphasePair &, btDispatcher *)
Definition: btOverlappingPairCache.h:371
btOverlappingPairCache::needsBroadphaseCollision
virtual bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const =0
btBroadphaseProxy::getUid
int getUid() const
Definition: btBroadphaseProxy.h:111
btSortedOverlappingPairCache::getOverlappingPairArray
const btBroadphasePairArray & getOverlappingPairArray() const
Definition: btOverlappingPairCache.h:309
btSortedOverlappingPairCache::cleanOverlappingPair
void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)
Definition: btOverlappingPairCache.cpp:542
btBroadphasePair::m_pProxy0
btBroadphaseProxy * m_pProxy0
Definition: btBroadphaseProxy.h:208
btBroadphasePairArray
btAlignedObjectArray< btBroadphasePair > btBroadphasePairArray
Definition: btOverlappingPairCache.h:24
btNullPairCache::cleanProxyFromPairs
virtual void cleanProxyFromPairs(btBroadphaseProxy *, btDispatcher *)
Definition: btOverlappingPairCache.h:380
btOverlappingPairCache::hasDeferredRemoval
virtual bool hasDeferredRemoval()=0
btOverlappingPairCache::setOverlapFilterCallback
virtual void setOverlapFilterCallback(btOverlapFilterCallback *callback)=0
btHashedOverlappingPairCache::hasDeferredRemoval
virtual bool hasDeferredRemoval()
Definition: btOverlappingPairCache.h:243
btHashedOverlappingPairCache::m_overlapFilterCallback
btOverlapFilterCallback * m_overlapFilterCallback
Definition: btOverlappingPairCache.h:91
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:99
btNullPairCache::getOverlapFilterCallback
btOverlapFilterCallback * getOverlapFilterCallback()
Definition: btOverlappingPairCache.h:388
btNullPairCache::removeOverlappingPairsContainingProxy
virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy *, btDispatcher *)
Definition: btOverlappingPairCache.h:424
btSortedOverlappingPairCache::getOverlappingPairArrayPtr
const btBroadphasePair * getOverlappingPairArrayPtr() const
Definition: btOverlappingPairCache.h:319
btBroadphaseInterface.h
btSortedOverlappingPairCache::getOverlappingPairArrayPtr
btBroadphasePair * getOverlappingPairArrayPtr()
Definition: btOverlappingPairCache.h:314
btDispatcherInfo
Definition: btDispatcher.h:31
btAlignedObjectArray< btBroadphasePair >
btSwap
void btSwap(T &a, T &b)
Definition: btScalar.h:643
btOverlappingPairCache::setInternalGhostPairCallback
virtual void setInternalGhostPairCallback(btOverlappingPairCallback *ghostPairCallback)=0
btSortedOverlappingPairCache::m_hasDeferredRemoval
bool m_hasDeferredRemoval
by default, do the removal during the pair traversal
Definition: btOverlappingPairCache.h:268
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:98
btNullPairCache::removeOverlappingPair
virtual void * removeOverlappingPair(btBroadphaseProxy *, btBroadphaseProxy *, btDispatcher *)
Definition: btOverlappingPairCache.h:419
btBroadphaseProxy.h
btSortedOverlappingPairCache
btSortedOverlappingPairCache maintains the objects with overlapping AABB Typically managed by the Bro...
Definition: btOverlappingPairCache.h:259
btNullPairCache::addOverlappingPair
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *, btBroadphaseProxy *)
Definition: btOverlappingPairCache.h:414
btSortedOverlappingPairCache::removeOverlappingPair
void * removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher)
Definition: btOverlappingPairCache.cpp:444
btSortedOverlappingPairCache::needsBroadphaseCollision
bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const
Definition: btOverlappingPairCache.h:293
btOverlapFilterCallback::needBroadphaseCollision
virtual bool needBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const =0
btHashedOverlappingPairCache::addOverlappingPair
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
Definition: btOverlappingPairCache.h:121
btOverlapCallback::~btOverlapCallback
virtual ~btOverlapCallback()
Definition: btOverlappingPairCache.h:30
btOverlapFilterCallback::~btOverlapFilterCallback
virtual ~btOverlapFilterCallback()
Definition: btOverlappingPairCache.h:39
btOverlappingPairCache::findPair
virtual btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=0
btOverlappingPairCache::sortOverlappingPairs
virtual void sortOverlappingPairs(btDispatcher *dispatcher)=0
btNullPairCache::sortOverlappingPairs
virtual void sortOverlappingPairs(btDispatcher *dispatcher)
Definition: btOverlappingPairCache.h:428
btAlignedObjectArray.h
btNullPairCache::needsBroadphaseCollision
bool needsBroadphaseCollision(btBroadphaseProxy *, btBroadphaseProxy *) const
Definition: btOverlappingPairCache.h:384
btSortedOverlappingPairCache::hasDeferredRemoval
virtual bool hasDeferredRemoval()
Definition: btOverlappingPairCache.h:339
btSortedOverlappingPairCache::removeOverlappingPairsContainingProxy
void removeOverlappingPairsContainingProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
Definition: btOverlappingPairCache.cpp:585
btSortedOverlappingPairCache::~btSortedOverlappingPairCache
virtual ~btSortedOverlappingPairCache()
Definition: btOverlappingPairCache.cpp:538
btHashedOverlappingPairCache::needsBroadphaseCollision
bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const
Definition: btOverlappingPairCache.h:108
btOverlappingPairCache::cleanProxyFromPairs
virtual void cleanProxyFromPairs(btBroadphaseProxy *proxy, btDispatcher *dispatcher)=0
btHashedOverlappingPairCache::m_hashTable
btAlignedObjectArray< int > m_hashTable
Definition: btOverlappingPairCache.h:94
btHashedOverlappingPairCache::internalFindPair
btBroadphasePair * internalFindPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, int hash)
Definition: btOverlappingPairCache.h:217
btOverlappingPairCache::getOverlappingPairArrayPtr
virtual const btBroadphasePair * getOverlappingPairArrayPtr() const =0
btOverlappingPairCache::getOverlapFilterCallback
virtual btOverlapFilterCallback * getOverlapFilterCallback()=0
btNullPairCache::hasDeferredRemoval
virtual bool hasDeferredRemoval()
Definition: btOverlappingPairCache.h:405
btBroadphasePair
The btBroadphasePair class contains a pair of aabb-overlapping objects.
Definition: btBroadphaseProxy.h:179
btOverlappingPairCache::~btOverlappingPairCache
virtual ~btOverlappingPairCache()
Definition: btOverlappingPairCache.h:53
btNullPairCache::processAllOverlappingPairs
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *)
Definition: btOverlappingPairCache.h:396
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:142
btOverlapCallback::processOverlap
virtual bool processOverlap(btBroadphasePair &pair)=0
btOverlapCallback
Definition: btOverlappingPairCache.h:29
btNullPairCache::setInternalGhostPairCallback
virtual void setInternalGhostPairCallback(btOverlappingPairCallback *)
Definition: btOverlappingPairCache.h:410