Bullet Collision Detection & Physics Library: btOverlappingPairCache.cpp Source File

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btOverlappingPairCache.cpp
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. 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.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
16#include "btOverlappingPairCache.h"
17
18#include "btDispatcher.h"
19#include "btCollisionAlgorithm.h"
20#include "LinearMath/btAabbUtil2.h"
21
22#include <stdio.h>
23
24btHashedOverlappingPairCache::btHashedOverlappingPairCache() : m_overlapFilterCallback(0),
25 m_ghostPairCallback(0)
26{
27 int initialAllocatedSize = 2;
28 m_overlappingPairArray.reserve(initialAllocatedSize);
29 growTables();
30}
31
32btHashedOverlappingPairCache::~btHashedOverlappingPairCache()
33{
34}
35
36 void btHashedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher)
37{
38 if (pair.m_algorithm && dispatcher)
39 {
40 {
41 pair.m_algorithm->~btCollisionAlgorithm();
42 dispatcher->freeCollisionAlgorithm(pair.m_algorithm);
43 pair.m_algorithm = 0;
44 }
45 }
46}
47
48 void btHashedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher)
49{
50 class CleanPairCallback : public btOverlapCallback
51 {
52 btBroadphaseProxy* m_cleanProxy;
53 btOverlappingPairCache* m_pairCache;
54 btDispatcher* m_dispatcher;
55
56 public:
57 CleanPairCallback(btBroadphaseProxy* cleanProxy, btOverlappingPairCache* pairCache, btDispatcher* dispatcher)
58 : m_cleanProxy(cleanProxy),
59 m_pairCache(pairCache),
60 m_dispatcher(dispatcher)
61 {
62 }
63 virtual bool processOverlap(btBroadphasePair& pair)
64 {
65 if ((pair.m_pProxy0 == m_cleanProxy) ||
66 (pair.m_pProxy1 == m_cleanProxy))
67 {
68 m_pairCache->cleanOverlappingPair(pair, m_dispatcher);
69 }
70 return false;
71 }
72 };
73
74 CleanPairCallback cleanPairs(proxy, this, dispatcher);
75
76 processAllOverlappingPairs(&cleanPairs, dispatcher);
77}
78
79 void btHashedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher)
80{
81 class RemovePairCallback : public btOverlapCallback
82 {
83 btBroadphaseProxy* m_obsoleteProxy;
84
85 public:
86 RemovePairCallback(btBroadphaseProxy* obsoleteProxy)
87 : m_obsoleteProxy(obsoleteProxy)
88 {
89 }
90 virtual bool processOverlap(btBroadphasePair& pair)
91 {
92 return ((pair.m_pProxy0 == m_obsoleteProxy) ||
93 (pair.m_pProxy1 == m_obsoleteProxy));
94 }
95 };
96
97 RemovePairCallback removeCallback(proxy);
98
99 processAllOverlappingPairs(&removeCallback, dispatcher);
100}
101
102 btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
103{
104 if (proxy0->m_uniqueId > proxy1->m_uniqueId)
105 btSwap(proxy0, proxy1);
106 int proxyId1 = proxy0->getUid();
107 int proxyId2 = proxy1->getUid();
108
109 /*if (proxyId1 > proxyId2)
110 btSwap(proxyId1, proxyId2);*/
111
112 int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1));
113
114 if (hash >= m_hashTable.size())
115 {
116 return NULL;
117 }
118
119 int index = m_hashTable[hash];
120 while (index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
121 {
122 index = m_next[index];
123 }
124
125 if (index == BT_NULL_PAIR)
126 {
127 return NULL;
128 }
129
130 btAssert(index < m_overlappingPairArray.size());
131
132 return &m_overlappingPairArray[index];
133}
134
135//#include <stdio.h>
136
137 void btHashedOverlappingPairCache::growTables()
138{
139 int newCapacity = m_overlappingPairArray.capacity();
140
141 if (m_hashTable.size() < newCapacity)
142 {
143 //grow hashtable and next table
144 int curHashtableSize = m_hashTable.size();
145
146 m_hashTable.resize(newCapacity);
147 m_next.resize(newCapacity);
148
149 int i;
150
151 for (i = 0; i < newCapacity; ++i)
152 {
153 m_hashTable[i] = BT_NULL_PAIR;
154 }
155 for (i = 0; i < newCapacity; ++i)
156 {
157 m_next[i] = BT_NULL_PAIR;
158 }
159
160 for (i = 0; i < curHashtableSize; i++)
161 {
162 const btBroadphasePair& pair = m_overlappingPairArray[i];
163 int proxyId1 = pair.m_pProxy0->getUid();
164 int proxyId2 = pair.m_pProxy1->getUid();
165 /*if (proxyId1 > proxyId2)
166 btSwap(proxyId1, proxyId2);*/
167 int hashValue = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); // New hash value with new mask
168 m_next[i] = m_hashTable[hashValue];
169 m_hashTable[hashValue] = i;
170 }
171 }
172}
173
174 btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
175{
176 if (proxy0->m_uniqueId > proxy1->m_uniqueId)
177 btSwap(proxy0, proxy1);
178 int proxyId1 = proxy0->getUid();
179 int proxyId2 = proxy1->getUid();
180
181 /*if (proxyId1 > proxyId2)
182 btSwap(proxyId1, proxyId2);*/
183
184 int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1)); // New hash value with new mask
185
186 btBroadphasePair* pair = internalFindPair(proxy0, proxy1, hash);
187 if (pair != NULL)
188 {
189 return pair;
190 }
191 /*for(int i=0;i<m_overlappingPairArray.size();++i)
192 {
193 if( (m_overlappingPairArray[i].m_pProxy0==proxy0)&&
194 (m_overlappingPairArray[i].m_pProxy1==proxy1))
195 {
196 printf("Adding duplicated %u<>%u\r\n",proxyId1,proxyId2);
197 internalFindPair(proxy0, proxy1, hash);
198 }
199 }*/
200 int count = m_overlappingPairArray.size();
201 int oldCapacity = m_overlappingPairArray.capacity();
202 void* mem = &m_overlappingPairArray.expandNonInitializing();
203
204 //this is where we add an actual pair, so also call the 'ghost'
205 if (m_ghostPairCallback)
206 m_ghostPairCallback->addOverlappingPair(proxy0, proxy1);
207
208 int newCapacity = m_overlappingPairArray.capacity();
209
210 if (oldCapacity < newCapacity)
211 {
212 growTables();
213 //hash with new capacity
214 hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1));
215 }
216
217 pair = new (mem) btBroadphasePair(*proxy0, *proxy1);
218 // pair->m_pProxy0 = proxy0;
219 // pair->m_pProxy1 = proxy1;
220 pair->m_algorithm = 0;
221 pair->m_internalTmpValue = 0;
222
223 m_next[count] = m_hashTable[hash];
224 m_hashTable[hash] = count;
225
226 return pair;
227}
228
229 void* btHashedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher)
230{
231 if (proxy0->m_uniqueId > proxy1->m_uniqueId)
232 btSwap(proxy0, proxy1);
233 int proxyId1 = proxy0->getUid();
234 int proxyId2 = proxy1->getUid();
235
236 /*if (proxyId1 > proxyId2)
237 btSwap(proxyId1, proxyId2);*/
238
239 int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity() - 1));
240
241 btBroadphasePair* pair = internalFindPair(proxy0, proxy1, hash);
242 if (pair == NULL)
243 {
244 return 0;
245 }
246
247 cleanOverlappingPair(*pair, dispatcher);
248
249 void* userData = pair->m_internalInfo1;
250
251 btAssert(pair->m_pProxy0->getUid() == proxyId1);
252 btAssert(pair->m_pProxy1->getUid() == proxyId2);
253
254 int pairIndex = int(pair - &m_overlappingPairArray[0]);
255 btAssert(pairIndex < m_overlappingPairArray.size());
256
257 // Remove the pair from the hash table.
258 int index = m_hashTable[hash];
259 btAssert(index != BT_NULL_PAIR);
260
261 int previous = BT_NULL_PAIR;
262 while (index != pairIndex)
263 {
264 previous = index;
265 index = m_next[index];
266 }
267
268 if (previous != BT_NULL_PAIR)
269 {
270 btAssert(m_next[previous] == pairIndex);
271 m_next[previous] = m_next[pairIndex];
272 }
273 else
274 {
275 m_hashTable[hash] = m_next[pairIndex];
276 }
277
278 // We now move the last pair into spot of the
279 // pair being removed. We need to fix the hash
280 // table indices to support the move.
281
282 int lastPairIndex = m_overlappingPairArray.size() - 1;
283
284 if (m_ghostPairCallback)
285 m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1, dispatcher);
286
287 // If the removed pair is the last pair, we are done.
288 if (lastPairIndex == pairIndex)
289 {
290 m_overlappingPairArray.pop_back();
291 return userData;
292 }
293
294 // Remove the last pair from the hash table.
295 const btBroadphasePair* last = &m_overlappingPairArray[lastPairIndex];
296 /* missing swap here too, Nat. */
297 int lastHash = static_cast<int>(getHash(static_cast<unsigned int>(last->m_pProxy0->getUid()), static_cast<unsigned int>(last->m_pProxy1->getUid())) & (m_overlappingPairArray.capacity() - 1));
298
299 index = m_hashTable[lastHash];
300 btAssert(index != BT_NULL_PAIR);
301
302 previous = BT_NULL_PAIR;
303 while (index != lastPairIndex)
304 {
305 previous = index;
306 index = m_next[index];
307 }
308
309 if (previous != BT_NULL_PAIR)
310 {
311 btAssert(m_next[previous] == lastPairIndex);
312 m_next[previous] = m_next[lastPairIndex];
313 }
314 else
315 {
316 m_hashTable[lastHash] = m_next[lastPairIndex];
317 }
318
319 // Copy the last pair into the remove pair's spot.
320 m_overlappingPairArray[pairIndex] = m_overlappingPairArray[lastPairIndex];
321
322 // Insert the last pair into the hash table
323 m_next[pairIndex] = m_hashTable[lastHash];
324 m_hashTable[lastHash] = pairIndex;
325
326 m_overlappingPairArray.pop_back();
327
328 return userData;
329}
330//#include <stdio.h>
331#include "LinearMath/btQuickprof.h"
332 void btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher)
333{
334 BT_PROFILE("btHashedOverlappingPairCache::processAllOverlappingPairs");
335 int i;
336
337 // printf("m_overlappingPairArray.size()=%d\n",m_overlappingPairArray.size());
338 for (i = 0; i < m_overlappingPairArray.size();)
339 {
340 btBroadphasePair* pair = &m_overlappingPairArray[i];
341 if (callback->processOverlap(*pair))
342 {
343 removeOverlappingPair(pair->m_pProxy0, pair->m_pProxy1, dispatcher);
344 }
345 else
346 {
347 i++;
348 }
349 }
350}
351
352 struct MyPairIndex
353{
354 int m_orgIndex;
355 int m_uidA0;
356 int m_uidA1;
357};
358
359 class MyPairIndeSortPredicate
360{
361public:
362 bool operator()(const MyPairIndex& a, const MyPairIndex& b) const
363 {
364 const int uidA0 = a.m_uidA0;
365 const int uidB0 = b.m_uidA0;
366 const int uidA1 = a.m_uidA1;
367 const int uidB1 = b.m_uidA1;
368 return uidA0 > uidB0 || (uidA0 == uidB0 && uidA1 > uidB1);
369 }
370};
371
372 void btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher, const struct btDispatcherInfo& dispatchInfo)
373{
374 if (dispatchInfo.m_deterministicOverlappingPairs)
375 {
376 btBroadphasePairArray& pa = getOverlappingPairArray();
377 btAlignedObjectArray<MyPairIndex> indices;
378 {
379 BT_PROFILE("sortOverlappingPairs");
380 indices.resize(pa.size());
381 for (int i = 0; i < indices.size(); i++)
382 {
383 const btBroadphasePair& p = pa[i];
384 const int uidA0 = p.m_pProxy0 ? p.m_pProxy0->m_uniqueId : -1;
385 const int uidA1 = p.m_pProxy1 ? p.m_pProxy1->m_uniqueId : -1;
386
387 indices[i].m_uidA0 = uidA0;
388 indices[i].m_uidA1 = uidA1;
389 indices[i].m_orgIndex = i;
390 }
391 indices.quickSort(MyPairIndeSortPredicate());
392 }
393 {
394 BT_PROFILE("btHashedOverlappingPairCache::processAllOverlappingPairs");
395 int i;
396 for (i = 0; i < indices.size();)
397 {
398 btBroadphasePair* pair = &pa[indices[i].m_orgIndex];
399 if (callback->processOverlap(*pair))
400 {
401 removeOverlappingPair(pair->m_pProxy0, pair->m_pProxy1, dispatcher);
402 }
403 else
404 {
405 i++;
406 }
407 }
408 }
409 }
410 else
411 {
412 processAllOverlappingPairs(callback, dispatcher);
413 }
414}
415
416 void btHashedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
417{
419 btBroadphasePairArray tmpPairs;
420 int i;
421 for (i = 0; i < m_overlappingPairArray.size(); i++)
422 {
423 tmpPairs.push_back(m_overlappingPairArray[i]);
424 }
425
426 for (i = 0; i < tmpPairs.size(); i++)
427 {
428 removeOverlappingPair(tmpPairs[i].m_pProxy0, tmpPairs[i].m_pProxy1, dispatcher);
429 }
430
431 for (i = 0; i < m_next.size(); i++)
432 {
433 m_next[i] = BT_NULL_PAIR;
434 }
435
436 tmpPairs.quickSort(btBroadphasePairSortPredicate());
437
438 for (i = 0; i < tmpPairs.size(); i++)
439 {
440 addOverlappingPair(tmpPairs[i].m_pProxy0, tmpPairs[i].m_pProxy1);
441 }
442}
443
444 void* btSortedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, btDispatcher* dispatcher)
445{
446 if (!hasDeferredRemoval())
447 {
448 btBroadphasePair findPair(*proxy0, *proxy1);
449
450 int findIndex = m_overlappingPairArray.findLinearSearch(findPair);
451 if (findIndex < m_overlappingPairArray.size())
452 {
453 btBroadphasePair& pair = m_overlappingPairArray[findIndex];
454 void* userData = pair.m_internalInfo1;
455 cleanOverlappingPair(pair, dispatcher);
456 if (m_ghostPairCallback)
457 m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1, dispatcher);
458
459 m_overlappingPairArray.swap(findIndex, m_overlappingPairArray.capacity() - 1);
460 m_overlappingPairArray.pop_back();
461 return userData;
462 }
463 }
464
465 return 0;
466}
467
468 btBroadphasePair* btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
469{
470 //don't add overlap with own
471 btAssert(proxy0 != proxy1);
472
473 if (!needsBroadphaseCollision(proxy0, proxy1))
474 return 0;
475
476 void* mem = &m_overlappingPairArray.expandNonInitializing();
477 btBroadphasePair* pair = new (mem) btBroadphasePair(*proxy0, *proxy1);
478
479 if (m_ghostPairCallback)
480 m_ghostPairCallback->addOverlappingPair(proxy0, proxy1);
481 return pair;
482}
483
488 btBroadphasePair* btSortedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
489{
490 if (!needsBroadphaseCollision(proxy0, proxy1))
491 return 0;
492
493 btBroadphasePair tmpPair(*proxy0, *proxy1);
494 int findIndex = m_overlappingPairArray.findLinearSearch(tmpPair);
495
496 if (findIndex < m_overlappingPairArray.size())
497 {
498 //btAssert(it != m_overlappingPairSet.end());
499 btBroadphasePair* pair = &m_overlappingPairArray[findIndex];
500 return pair;
501 }
502 return 0;
503}
504
505//#include <stdio.h>
506
507 void btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback, btDispatcher* dispatcher)
508{
509 int i;
510
511 for (i = 0; i < m_overlappingPairArray.size();)
512 {
513 btBroadphasePair* pair = &m_overlappingPairArray[i];
514 if (callback->processOverlap(*pair))
515 {
516 cleanOverlappingPair(*pair, dispatcher);
517 pair->m_pProxy0 = 0;
518 pair->m_pProxy1 = 0;
519 m_overlappingPairArray.swap(i, m_overlappingPairArray.size() - 1);
520 m_overlappingPairArray.pop_back();
521 }
522 else
523 {
524 i++;
525 }
526 }
527}
528
529btSortedOverlappingPairCache::btSortedOverlappingPairCache() : m_blockedForChanges(false),
530 m_hasDeferredRemoval(true),
531 m_overlapFilterCallback(0),
532 m_ghostPairCallback(0)
533{
534 int initialAllocatedSize = 2;
535 m_overlappingPairArray.reserve(initialAllocatedSize);
536}
537
538btSortedOverlappingPairCache::~btSortedOverlappingPairCache()
539{
540}
541
542 void btSortedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair, btDispatcher* dispatcher)
543{
544 if (pair.m_algorithm)
545 {
546 {
547 pair.m_algorithm->~btCollisionAlgorithm();
548 dispatcher->freeCollisionAlgorithm(pair.m_algorithm);
549 pair.m_algorithm = 0;
550 }
551 }
552}
553
554 void btSortedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy, btDispatcher* dispatcher)
555{
556 class CleanPairCallback : public btOverlapCallback
557 {
558 btBroadphaseProxy* m_cleanProxy;
559 btOverlappingPairCache* m_pairCache;
560 btDispatcher* m_dispatcher;
561
562 public:
563 CleanPairCallback(btBroadphaseProxy* cleanProxy, btOverlappingPairCache* pairCache, btDispatcher* dispatcher)
564 : m_cleanProxy(cleanProxy),
565 m_pairCache(pairCache),
566 m_dispatcher(dispatcher)
567 {
568 }
569 virtual bool processOverlap(btBroadphasePair& pair)
570 {
571 if ((pair.m_pProxy0 == m_cleanProxy) ||
572 (pair.m_pProxy1 == m_cleanProxy))
573 {
574 m_pairCache->cleanOverlappingPair(pair, m_dispatcher);
575 }
576 return false;
577 }
578 };
579
580 CleanPairCallback cleanPairs(proxy, this, dispatcher);
581
582 processAllOverlappingPairs(&cleanPairs, dispatcher);
583}
584
585 void btSortedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher)
586{
587 class RemovePairCallback : public btOverlapCallback
588 {
589 btBroadphaseProxy* m_obsoleteProxy;
590
591 public:
592 RemovePairCallback(btBroadphaseProxy* obsoleteProxy)
593 : m_obsoleteProxy(obsoleteProxy)
594 {
595 }
596 virtual bool processOverlap(btBroadphasePair& pair)
597 {
598 return ((pair.m_pProxy0 == m_obsoleteProxy) ||
599 (pair.m_pProxy1 == m_obsoleteProxy));
600 }
601 };
602
603 RemovePairCallback removeCallback(proxy);
604
605 processAllOverlappingPairs(&removeCallback, dispatcher);
606}
607
608 void btSortedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
609{
610 //should already be sorted
611}
btAabbUtil2.h
btCollisionAlgorithm.h
btDispatcher.h
btOverlappingPairCache.h
BT_NULL_PAIR
const int BT_NULL_PAIR
Definition btOverlappingPairCache.h:46
btQuickprof.h
BT_PROFILE
#define BT_PROFILE(name)
Definition btQuickprof.h:198
btSwap
void btSwap(T &a, T &b)
Definition btScalar.h:643
btAssert
#define btAssert(x)
Definition btScalar.h:153
MyPairIndeSortPredicate
Definition btOverlappingPairCache.cpp:360
MyPairIndeSortPredicate::operator()
bool operator()(const MyPairIndex &a, const MyPairIndex &b) const
Definition btOverlappingPairCache.cpp:362
btAlignedObjectArray< btBroadphasePair >
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition btAlignedObjectArray.h:142
btAlignedObjectArray::findLinearSearch
int findLinearSearch(const T &key) const
Definition btAlignedObjectArray.h:438
btAlignedObjectArray::resize
void resize(int newsize, const T &fillData=T())
Definition btAlignedObjectArray.h:203
btAlignedObjectArray::swap
void swap(int index0, int index1)
Definition btAlignedObjectArray.h:382
btAlignedObjectArray::expandNonInitializing
T & expandNonInitializing()
Definition btAlignedObjectArray.h:230
btAlignedObjectArray::quickSort
void quickSort(const L &CompareFunc)
Definition btAlignedObjectArray.h:341
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition btAlignedObjectArray.h:257
btAlignedObjectArray::capacity
int capacity() const
return the pre-allocated (reserved) elements, this is at least as large as the total number of elemen...
Definition btAlignedObjectArray.h:275
btAlignedObjectArray::reserve
void reserve(int _Count)
Definition btAlignedObjectArray.h:280
btAlignedObjectArray::pop_back
void pop_back()
Definition btAlignedObjectArray.h:185
btBroadphasePairSortPredicate
Definition btBroadphaseProxy.h:228
btCollisionAlgorithm::~btCollisionAlgorithm
virtual ~btCollisionAlgorithm()
Definition btCollisionAlgorithm.h:66
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition btDispatcher.h:77
btDispatcher::freeCollisionAlgorithm
virtual void freeCollisionAlgorithm(void *ptr)=0
btHashedOverlappingPairCache::removeOverlappingPairsContainingProxy
void removeOverlappingPairsContainingProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:79
btHashedOverlappingPairCache::cleanOverlappingPair
void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:36
btHashedOverlappingPairCache::cleanProxyFromPairs
void cleanProxyFromPairs(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:48
btHashedOverlappingPairCache::~btHashedOverlappingPairCache
virtual ~btHashedOverlappingPairCache()
Definition btOverlappingPairCache.cpp:32
btHashedOverlappingPairCache::m_next
btAlignedObjectArray< int > m_next
Definition btOverlappingPairCache.h:95
btHashedOverlappingPairCache::m_overlappingPairArray
btBroadphasePairArray m_overlappingPairArray
Definition btOverlappingPairCache.h:90
btHashedOverlappingPairCache::findPair
btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
Definition btOverlappingPairCache.cpp:102
btHashedOverlappingPairCache::sortOverlappingPairs
virtual void sortOverlappingPairs(btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:416
btHashedOverlappingPairCache::internalFindPair
btBroadphasePair * internalFindPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, int hash)
Definition btOverlappingPairCache.h:217
btHashedOverlappingPairCache::addOverlappingPair
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
Definition btOverlappingPairCache.h:121
btHashedOverlappingPairCache::btHashedOverlappingPairCache
btHashedOverlappingPairCache()
Definition btOverlappingPairCache.cpp:24
btHashedOverlappingPairCache::internalAddPair
btBroadphasePair * internalAddPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
Definition btOverlappingPairCache.cpp:174
btHashedOverlappingPairCache::equalsPair
bool equalsPair(const btBroadphasePair &pair, int proxyId1, int proxyId2)
Definition btOverlappingPairCache.h:182
btHashedOverlappingPairCache::removeOverlappingPair
virtual void * removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:229
btHashedOverlappingPairCache::getHash
unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
Definition btOverlappingPairCache.h:203
btHashedOverlappingPairCache::growTables
void growTables()
Definition btOverlappingPairCache.cpp:137
btHashedOverlappingPairCache::m_hashTable
btAlignedObjectArray< int > m_hashTable
Definition btOverlappingPairCache.h:94
btHashedOverlappingPairCache::m_ghostPairCallback
btOverlappingPairCallback * m_ghostPairCallback
Definition btOverlappingPairCache.h:96
btHashedOverlappingPairCache::getOverlappingPairArray
btBroadphasePairArray & getOverlappingPairArray()
Definition btOverlappingPairCache.h:145
btHashedOverlappingPairCache::processAllOverlappingPairs
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:332
btOverlappingPairCache
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
Definition btOverlappingPairCache.h:51
btOverlappingPairCache::cleanOverlappingPair
virtual void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)=0
btOverlappingPairCallback::removeOverlappingPair
virtual void * removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher)=0
btOverlappingPairCallback::addOverlappingPair
virtual btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)=0
btSortedOverlappingPairCache::processAllOverlappingPairs
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:507
btSortedOverlappingPairCache::btSortedOverlappingPairCache
btSortedOverlappingPairCache()
Definition btOverlappingPairCache.cpp:529
btSortedOverlappingPairCache::addOverlappingPair
btBroadphasePair * addOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
Definition btOverlappingPairCache.cpp:468
btSortedOverlappingPairCache::~btSortedOverlappingPairCache
virtual ~btSortedOverlappingPairCache()
Definition btOverlappingPairCache.cpp:538
btSortedOverlappingPairCache::hasDeferredRemoval
virtual bool hasDeferredRemoval()
Definition btOverlappingPairCache.h:339
btSortedOverlappingPairCache::findPair
btBroadphasePair * findPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1)
this findPair becomes really slow.
Definition btOverlappingPairCache.cpp:488
btSortedOverlappingPairCache::needsBroadphaseCollision
bool needsBroadphaseCollision(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1) const
Definition btOverlappingPairCache.h:293
btSortedOverlappingPairCache::removeOverlappingPairsContainingProxy
void removeOverlappingPairsContainingProxy(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:585
btSortedOverlappingPairCache::m_ghostPairCallback
btOverlappingPairCallback * m_ghostPairCallback
Definition btOverlappingPairCache.h:273
btSortedOverlappingPairCache::cleanOverlappingPair
void cleanOverlappingPair(btBroadphasePair &pair, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:542
btSortedOverlappingPairCache::removeOverlappingPair
void * removeOverlappingPair(btBroadphaseProxy *proxy0, btBroadphaseProxy *proxy1, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:444
btSortedOverlappingPairCache::m_overlappingPairArray
btBroadphasePairArray m_overlappingPairArray
Definition btOverlappingPairCache.h:262
btSortedOverlappingPairCache::cleanProxyFromPairs
void cleanProxyFromPairs(btBroadphaseProxy *proxy, btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:554
btSortedOverlappingPairCache::sortOverlappingPairs
virtual void sortOverlappingPairs(btDispatcher *dispatcher)
Definition btOverlappingPairCache.cpp:608
MyPairIndex
Definition btOverlappingPairCache.cpp:353
MyPairIndex::m_uidA1
int m_uidA1
Definition btOverlappingPairCache.cpp:356
MyPairIndex::m_uidA0
int m_uidA0
Definition btOverlappingPairCache.cpp:355
MyPairIndex::m_orgIndex
int m_orgIndex
Definition btOverlappingPairCache.cpp:354
btBroadphasePair
The btBroadphasePair class contains a pair of aabb-overlapping objects.
Definition btBroadphaseProxy.h:179
btBroadphasePair::m_pProxy1
btBroadphaseProxy * m_pProxy1
Definition btBroadphaseProxy.h:209
btBroadphasePair::m_internalTmpValue
int m_internalTmpValue
Definition btBroadphaseProxy.h:214
btBroadphasePair::m_pProxy0
btBroadphaseProxy * m_pProxy0
Definition btBroadphaseProxy.h:208
btBroadphasePair::m_algorithm
btCollisionAlgorithm * m_algorithm
Definition btBroadphaseProxy.h:211
btBroadphasePair::m_internalInfo1
void * m_internalInfo1
Definition btBroadphaseProxy.h:213
btBroadphaseProxy
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
Definition btBroadphaseProxy.h:86
btBroadphaseProxy::getUid
int getUid() const
Definition btBroadphaseProxy.h:111
btBroadphaseProxy::m_uniqueId
int m_uniqueId
Definition btBroadphaseProxy.h:106
btDispatcherInfo
Definition btDispatcher.h:31
btDispatcherInfo::m_deterministicOverlappingPairs
bool m_deterministicOverlappingPairs
Definition btDispatcher.h:65
btOverlapCallback
Definition btOverlappingPairCache.h:29
btOverlapCallback::processOverlap
virtual bool processOverlap(btBroadphasePair &pair)=0