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 
20 #include "btBroadphaseInterface.h"
21 #include "btBroadphaseProxy.h"
23 
26 
28 
30 {
32  {}
33  //return true for deletion of the pair
34  virtual bool processOverlap(btBroadphasePair& pair) = 0;
35 
36 };
37 
39 {
41  {}
42  // return true when pairs need collision
43  virtual bool needBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const = 0;
44 };
45 
46 
47 
48 
49 
50 
51 
52 extern int gRemovePairs;
53 extern int gAddedPairs;
54 extern int gFindPairs;
55 
56 const int BT_NULL_PAIR=0xffffffff;
57 
61 {
62 public:
63  virtual ~btOverlappingPairCache() {} // this is needed so we can get to the derived class destructor
64 
65  virtual btBroadphasePair* getOverlappingPairArrayPtr() = 0;
66 
67  virtual const btBroadphasePair* getOverlappingPairArrayPtr() const = 0;
68 
69  virtual btBroadphasePairArray& getOverlappingPairArray() = 0;
70 
71  virtual void cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher) = 0;
72 
73  virtual int getNumOverlappingPairs() const = 0;
74 
75  virtual void cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher) = 0;
76 
77  virtual void setOverlapFilterCallback(btOverlapFilterCallback* callback) = 0;
78 
79  virtual void processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher) = 0;
80 
81  virtual btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) = 0;
82 
83  virtual bool hasDeferredRemoval() = 0;
84 
85  virtual void setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)=0;
86 
87  virtual void sortOverlappingPairs(btDispatcher* dispatcher) = 0;
88 
89 
90 };
91 
93 
95 {
98 
99 protected:
100 
104 
105 
106 public:
108 
110  virtual ~btHashedOverlappingPairCache();
111 
112 
113  void removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
114 
115  virtual void* removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
116 
118  {
119  if (m_overlapFilterCallback)
120  return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1);
121 
122  bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
123  collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
124 
125  return collides;
126  }
127 
128  // Add a pair and return the new pair. If the pair already exists,
129  // no new pair is created and the old one is returned.
131  {
132  gAddedPairs++;
133 
134  if (!needsBroadphaseCollision(proxy0,proxy1))
135  return 0;
136 
137  return internalAddPair(proxy0,proxy1);
138  }
139 
140 
141 
142  void cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
143 
144 
145  virtual void processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
146 
148  {
149  return &m_overlappingPairArray[0];
150  }
151 
153  {
154  return &m_overlappingPairArray[0];
155  }
156 
158  {
159  return m_overlappingPairArray;
160  }
161 
163  {
164  return m_overlappingPairArray;
165  }
166 
167  void cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher);
168 
169 
170 
171  btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1);
172 
173  int GetCount() const { return m_overlappingPairArray.size(); }
174 // btBroadphasePair* GetPairs() { return m_pairs; }
175 
177  {
178  return m_overlapFilterCallback;
179  }
180 
182  {
183  m_overlapFilterCallback = callback;
184  }
185 
187  {
188  return m_overlappingPairArray.size();
189  }
190 private:
191 
192  btBroadphasePair* internalAddPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
193 
194  void growTables();
195 
196  SIMD_FORCE_INLINE bool equalsPair(const btBroadphasePair& pair, int proxyId1, int proxyId2)
197  {
198  return pair.m_pProxy0->getUid() == proxyId1 && pair.m_pProxy1->getUid() == proxyId2;
199  }
200 
201  /*
202  // Thomas Wang's hash, see: http://www.concentric.net/~Ttwang/tech/inthash.htm
203  // This assumes proxyId1 and proxyId2 are 16-bit.
204  SIMD_FORCE_INLINE int getHash(int proxyId1, int proxyId2)
205  {
206  int key = (proxyId2 << 16) | proxyId1;
207  key = ~key + (key << 15);
208  key = key ^ (key >> 12);
209  key = key + (key << 2);
210  key = key ^ (key >> 4);
211  key = key * 2057;
212  key = key ^ (key >> 16);
213  return key;
214  }
215  */
216 
217 
218 
219  SIMD_FORCE_INLINE unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
220  {
221  int key = static_cast<int>(((unsigned int)proxyId1) | (((unsigned int)proxyId2) <<16));
222  // Thomas Wang's hash
223 
224  key += ~(key << 15);
225  key ^= (key >> 10);
226  key += (key << 3);
227  key ^= (key >> 6);
228  key += ~(key << 11);
229  key ^= (key >> 16);
230  return static_cast<unsigned int>(key);
231  }
232 
233 
234 
235 
236 
238  {
239  int proxyId1 = proxy0->getUid();
240  int proxyId2 = proxy1->getUid();
241  #if 0 // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat.
242  if (proxyId1 > proxyId2)
243  btSwap(proxyId1, proxyId2);
244  #endif
245 
246  int index = m_hashTable[hash];
247 
248  while( index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
249  {
250  index = m_next[index];
251  }
252 
253  if ( index == BT_NULL_PAIR )
254  {
255  return NULL;
256  }
257 
258  btAssert(index < m_overlappingPairArray.size());
259 
260  return &m_overlappingPairArray[index];
261  }
262 
263  virtual bool hasDeferredRemoval()
264  {
265  return false;
266  }
267 
269  {
270  m_ghostPairCallback = ghostPairCallback;
271  }
272 
273  virtual void sortOverlappingPairs(btDispatcher* dispatcher);
274 
275 
276 
277 };
278 
279 
280 
281 
285 {
286  protected:
287  //avoid brute-force finding all the time
289 
290  //during the dispatch, check that user doesn't destroy/create proxy
292 
295 
296  //if set, use the callback instead of the built in filter in needBroadphaseCollision
298 
300 
301  public:
302 
304  virtual ~btSortedOverlappingPairCache();
305 
306  virtual void processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
307 
308  void* removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
309 
310  void cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher);
311 
312  btBroadphasePair* addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
313 
314  btBroadphasePair* findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
315 
316 
317  void cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
318 
319  void removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
320 
321 
323  {
324  if (m_overlapFilterCallback)
325  return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1);
326 
327  bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
328  collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
329 
330  return collides;
331  }
332 
334  {
335  return m_overlappingPairArray;
336  }
337 
339  {
340  return m_overlappingPairArray;
341  }
342 
343 
344 
345 
347  {
348  return &m_overlappingPairArray[0];
349  }
350 
352  {
353  return &m_overlappingPairArray[0];
354  }
355 
357  {
358  return m_overlappingPairArray.size();
359  }
360 
362  {
363  return m_overlapFilterCallback;
364  }
365 
367  {
368  m_overlapFilterCallback = callback;
369  }
370 
371  virtual bool hasDeferredRemoval()
372  {
373  return m_hasDeferredRemoval;
374  }
375 
377  {
378  m_ghostPairCallback = ghostPairCallback;
379  }
380 
381  virtual void sortOverlappingPairs(btDispatcher* dispatcher);
382 
383 
384 };
385 
386 
387 
390 {
391 
393 
394 public:
395 
397  {
398  return &m_overlappingPairArray[0];
399  }
401  {
402  return &m_overlappingPairArray[0];
403  }
405  {
406  return m_overlappingPairArray;
407  }
408 
409  virtual void cleanOverlappingPair(btBroadphasePair& /*pair*/,btDispatcher* /*dispatcher*/)
410  {
411 
412  }
413 
414  virtual int getNumOverlappingPairs() const
415  {
416  return 0;
417  }
418 
419  virtual void cleanProxyFromPairs(btBroadphaseProxy* /*proxy*/,btDispatcher* /*dispatcher*/)
420  {
421 
422  }
423 
425  {
426  }
427 
429  {
430  }
431 
433  {
434  return 0;
435  }
436 
437  virtual bool hasDeferredRemoval()
438  {
439  return true;
440  }
441 
442  virtual void setInternalGhostPairCallback(btOverlappingPairCallback* /* ghostPairCallback */)
443  {
444 
445  }
446 
448  {
449  return 0;
450  }
451 
452  virtual void* removeOverlappingPair(btBroadphaseProxy* /*proxy0*/,btBroadphaseProxy* /*proxy1*/,btDispatcher* /*dispatcher*/)
453  {
454  return 0;
455  }
456 
457  virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy* /*proxy0*/,btDispatcher* /*dispatcher*/)
458  {
459  }
460 
461  virtual void sortOverlappingPairs(btDispatcher* dispatcher)
462  {
463  (void) dispatcher;
464  }
465 
466 
467 };
468 
469 
470 #endif //BT_OVERLAPPING_PAIR_CACHE_H
471 
472 
btOverlapFilterCallback * getOverlapFilterCallback()
btOverlapFilterCallback * m_overlapFilterCallback
const int BT_NULL_PAIR
btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing...
btBroadphasePair * internalFindPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, int hash)
virtual int getNumOverlappingPairs() const
btAlignedObjectArray< int > m_hashTable
#define btAssert(x)
Definition: btScalar.h:114
virtual bool hasDeferredRemoval()
btBroadphasePairArray & getOverlappingPairArray()
btOverlappingPairCallback * m_ghostPairCallback
#define SIMD_FORCE_INLINE
Definition: btScalar.h:64
btBroadphasePairArray m_overlappingPairArray
bool equalsPair(const btBroadphasePair &pair, int proxyId1, int proxyId2)
const btBroadphasePair * getOverlappingPairArrayPtr() const
const btBroadphasePairArray & getOverlappingPairArray() const
btOverlappingPairCallback * m_ghostPairCallback
btOverlapFilterCallback * m_overlapFilterCallback
bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const
virtual void cleanProxyFromPairs(btBroadphaseProxy *, btDispatcher *)
virtual btBroadphasePair * getOverlappingPairArrayPtr()
void setOverlapFilterCallback(btOverlapFilterCallback *callback)
virtual btBroadphasePair * getOverlappingPairArrayPtr()
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *)
The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases.
unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
const btBroadphasePair * getOverlappingPairArrayPtr() const
btBroadphasePairArray & getOverlappingPairArray()
void btSwap(T &a, T &b)
Definition: btScalar.h:586
btOverlapFilterCallback * getOverlapFilterCallback()
bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const
virtual void removeOverlappingPairsContainingProxy(btBroadphaseProxy *, btDispatcher *)
const btBroadphasePairArray & getOverlappingPairArray() const
int gFindPairs
int gAddedPairs
btSortedOverlappingPairCache maintains the objects with overlapping AABB Typically managed by the Bro...
void setOverlapFilterCallback(btOverlapFilterCallback *callback)
virtual bool needBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const =0
virtual bool processOverlap(btBroadphasePair &pair)=0
btAlignedObjectArray< int > m_next
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
btBroadphaseProxy * m_pProxy1
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:65
const btBroadphasePair * getOverlappingPairArrayPtr() const
int size() const
return the number of elements in the array
btBroadphasePairArray m_overlappingPairArray
btBroadphaseProxy * m_pProxy0
virtual void cleanOverlappingPair(btBroadphasePair &, btDispatcher *)
virtual void setInternalGhostPairCallback(btOverlappingPairCallback *ghostPairCallback)
btAlignedObjectArray< btBroadphasePair > btBroadphasePairArray
virtual void setInternalGhostPairCallback(btOverlappingPairCallback *)
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:389
virtual void setOverlapFilterCallback(btOverlapFilterCallback *)
virtual void setInternalGhostPairCallback(btOverlappingPairCallback *ghostPairCallback)
btBroadphasePairArray m_overlappingPairArray
bool m_hasDeferredRemoval
by default, do the removal during the pair traversal
virtual void sortOverlappingPairs(btDispatcher *dispatcher)
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
virtual btBroadphasePair * findPair(btBroadphaseProxy *, btBroadphaseProxy *)
btBroadphasePairArray & getOverlappingPairArray()
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:75
Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman...
virtual void * removeOverlappingPair(btBroadphaseProxy *, btBroadphaseProxy *, btDispatcher *)
The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/rem...
int gRemovePairs
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *, btBroadphaseProxy *)
The btBroadphasePair class contains a pair of aabb-overlapping objects.
btBroadphasePair * getOverlappingPairArrayPtr()