Bullet Collision Detection & Physics Library
btCollisionDispatcher.cpp
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 #include "btCollisionDispatcher.h"
17 #include "LinearMath/btQuickprof.h"
18 
20 
27 
28 #ifdef BT_DEBUG
29 #include <stdio.h>
30 #endif
31 
32 btCollisionDispatcher::btCollisionDispatcher(btCollisionConfiguration* collisionConfiguration) : m_dispatcherFlags(btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD),
33  m_collisionConfiguration(collisionConfiguration)
34 {
35  int i;
36 
38 
40 
42 
43  for (i = 0; i < MAX_BROADPHASE_COLLISION_TYPES; i++)
44  {
45  for (int j = 0; j < MAX_BROADPHASE_COLLISION_TYPES; j++)
46  {
50  }
51  }
52 }
53 
55 {
56  m_doubleDispatchContactPoints[proxyType0][proxyType1] = createFunc;
57 }
58 
60 {
61  m_doubleDispatchClosestPoints[proxyType0][proxyType1] = createFunc;
62 }
63 
65 {
66 }
67 
69 {
70  //btAssert(gNumManifold < 65535);
71 
72  //optional relative contact breaking threshold, turned on by default (use setDispatcherFlags to switch off feature for improved performance)
73 
76 
77  btScalar contactProcessingThreshold = btMin(body0->getContactProcessingThreshold(), body1->getContactProcessingThreshold());
78 
80  if (NULL == mem)
81  {
82  //we got a pool memory overflow, by default we fallback to dynamically allocate memory. If we require a contiguous contact pool then assert.
84  {
85  mem = btAlignedAlloc(sizeof(btPersistentManifold), 16);
86  }
87  else
88  {
89  btAssert(0);
90  //make sure to increase the m_defaultMaxPersistentManifoldPoolSize in the btDefaultCollisionConstructionInfo/btDefaultCollisionConfiguration
91  return 0;
92  }
93  }
94  btPersistentManifold* manifold = new (mem) btPersistentManifold(body0, body1, 0, contactBreakingThreshold, contactProcessingThreshold);
95  manifold->m_index1a = m_manifoldsPtr.size();
96  m_manifoldsPtr.push_back(manifold);
97 
98  return manifold;
99 }
100 
102 {
103  manifold->clearManifold();
104 }
105 
107 {
108  //printf("releaseManifold: gNumManifold %d\n",gNumManifold);
109  clearManifold(manifold);
110 
111  int findIndex = manifold->m_index1a;
112  btAssert(findIndex < m_manifoldsPtr.size());
113  m_manifoldsPtr.swap(findIndex, m_manifoldsPtr.size() - 1);
114  m_manifoldsPtr[findIndex]->m_index1a = findIndex;
116 
117  manifold->~btPersistentManifold();
119  {
121  }
122  else
123  {
124  btAlignedFree(manifold);
125  }
126 }
127 
129 {
131 
132  ci.m_dispatcher1 = this;
133  ci.m_manifold = sharedManifold;
134  btCollisionAlgorithm* algo = 0;
135  if (algoType == BT_CONTACT_POINT_ALGORITHMS)
136  {
137  algo = m_doubleDispatchContactPoints[body0Wrap->getCollisionShape()->getShapeType()][body1Wrap->getCollisionShape()->getShapeType()]->CreateCollisionAlgorithm(ci, body0Wrap, body1Wrap);
138  }
139  else
140  {
141  algo = m_doubleDispatchClosestPoints[body0Wrap->getCollisionShape()->getShapeType()][body1Wrap->getCollisionShape()->getShapeType()]->CreateCollisionAlgorithm(ci, body0Wrap, body1Wrap);
142  }
143 
144  return algo;
145 }
146 
148 {
149  //here you can do filtering
150  bool hasResponse =
151  (body0->hasContactResponse() && body1->hasContactResponse());
152  //no response between two static/kinematic bodies:
153  hasResponse = hasResponse &&
154  ((!body0->isStaticOrKinematicObject()) || (!body1->isStaticOrKinematicObject()));
155  return hasResponse;
156 }
157 
159 {
160  btAssert(body0);
161  btAssert(body1);
162 
163  bool needsCollision = true;
164 
165 #ifdef BT_DEBUG
167  {
168  //broadphase filtering already deals with this
169  if (body0->isStaticOrKinematicObject() && body1->isStaticOrKinematicObject())
170  {
172  printf("warning btCollisionDispatcher::needsCollision: static-static collision!\n");
173  }
174  }
175 #endif //BT_DEBUG
176 
177  if ((!body0->isActive()) && (!body1->isActive()))
178  needsCollision = false;
179  else if ((!body0->checkCollideWith(body1)) || (!body1->checkCollideWith(body0)))
180  needsCollision = false;
181 
182  return needsCollision;
183 }
184 
188 {
191 
192 public:
194  : m_dispatchInfo(dispatchInfo),
195  m_dispatcher(dispatcher)
196  {
197  }
198 
199  /*btCollisionPairCallback& operator=(btCollisionPairCallback& other)
200  {
201  m_dispatchInfo = other.m_dispatchInfo;
202  m_dispatcher = other.m_dispatcher;
203  return *this;
204  }
205  */
206 
208 
209  virtual bool processOverlap(btBroadphasePair& pair)
210  {
212  return false;
213  }
214 };
215 
217 {
218  //m_blockedForChanges = true;
219 
220  btCollisionPairCallback collisionCallback(dispatchInfo, this);
221 
222  {
223  BT_PROFILE("processAllOverlappingPairs");
224  pairCache->processAllOverlappingPairs(&collisionCallback, dispatcher, dispatchInfo);
225  }
226 
227  //m_blockedForChanges = false;
228 }
229 
230 //by default, Bullet will use this near callback
232 {
233  btCollisionObject* colObj0 = (btCollisionObject*)collisionPair.m_pProxy0->m_clientObject;
234  btCollisionObject* colObj1 = (btCollisionObject*)collisionPair.m_pProxy1->m_clientObject;
235 
236  if (dispatcher.needsCollision(colObj0, colObj1))
237  {
238  btCollisionObjectWrapper obj0Wrap(0, colObj0->getCollisionShape(), colObj0, colObj0->getWorldTransform(), -1, -1);
239  btCollisionObjectWrapper obj1Wrap(0, colObj1->getCollisionShape(), colObj1, colObj1->getWorldTransform(), -1, -1);
240 
241  //dispatcher will keep algorithms persistent in the collision pair
242  if (!collisionPair.m_algorithm)
243  {
244  collisionPair.m_algorithm = dispatcher.findAlgorithm(&obj0Wrap, &obj1Wrap, 0, BT_CONTACT_POINT_ALGORITHMS);
245  }
246 
247  if (collisionPair.m_algorithm)
248  {
249  btManifoldResult contactPointResult(&obj0Wrap, &obj1Wrap);
250 
252  {
253  //discrete collision detection query
254 
255  collisionPair.m_algorithm->processCollision(&obj0Wrap, &obj1Wrap, dispatchInfo, &contactPointResult);
256  }
257  else
258  {
259  //continuous collision detection query, time of impact (toi)
260  btScalar toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0, colObj1, dispatchInfo, &contactPointResult);
261  if (dispatchInfo.m_timeOfImpact > toi)
262  dispatchInfo.m_timeOfImpact = toi;
263  }
264  }
265  }
266 }
267 
269 {
271  if (NULL == mem)
272  {
273  //warn user for overflow?
274  return btAlignedAlloc(static_cast<size_t>(size), 16);
275  }
276  return mem;
277 }
278 
280 {
282  {
284  }
285  else
286  {
287  btAlignedFree(ptr);
288  }
289 }
btCollisionConfiguration.h
btCollisionDispatcher::m_persistentManifoldPoolAllocator
btPoolAllocator * m_persistentManifoldPoolAllocator
Definition: btCollisionDispatcher.h:55
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:48
btCollisionDispatcher::getNearCallback
btNearCallback getNearCallback() const
Definition: btCollisionDispatcher.h:129
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:47
btCollisionShape.h
btCollisionDispatcher::m_manifoldsPtr
btAlignedObjectArray< btPersistentManifold * > m_manifoldsPtr
Definition: btCollisionDispatcher.h:47
btCollisionShape::getShapeType
int getShapeType() const
Definition: btCollisionShape.h:106
btCollisionShape::getContactBreakingThreshold
virtual btScalar getContactBreakingThreshold(btScalar defaultContactThresholdFactor) const
Definition: btCollisionShape.cpp:42
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:294
btCollisionDispatcher::m_doubleDispatchClosestPoints
btCollisionAlgorithmCreateFunc * m_doubleDispatchClosestPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES]
Definition: btCollisionDispatcher.h:59
btCollisionObjectWrapper.h
btCollisionDispatcher::m_collisionConfiguration
btCollisionConfiguration * m_collisionConfiguration
Definition: btCollisionDispatcher.h:61
btCollisionObjectWrapper
Definition: btCollisionObjectWrapper.h:17
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition: btDispatcher.h:76
btCollisionPairCallback::btCollisionPairCallback
btCollisionPairCallback(const btDispatcherInfo &dispatchInfo, btCollisionDispatcher *dispatcher)
Definition: btCollisionDispatcher.cpp:193
btCollisionAlgorithmCreateFunc::CreateCollisionAlgorithm
virtual btCollisionAlgorithm * CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo &, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap)
Definition: btCollisionCreateFunc.h:36
btCollisionPairCallback::m_dispatchInfo
const btDispatcherInfo & m_dispatchInfo
Definition: btCollisionDispatcher.cpp:189
btDispatcherInfo::DISPATCH_DISCRETE
Definition: btDispatcher.h:34
btCollisionDispatcher::clearManifold
virtual void clearManifold(btPersistentManifold *manifold)
Definition: btCollisionDispatcher.cpp:101
btCollisionAlgorithm::calculateTimeOfImpact
virtual btScalar calculateTimeOfImpact(btCollisionObject *body0, btCollisionObject *body1, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)=0
btCollisionDispatcher::m_collisionAlgorithmPoolAllocator
btPoolAllocator * m_collisionAlgorithmPoolAllocator
Definition: btCollisionDispatcher.h:53
btPersistentManifold::clearManifold
void clearManifold()
Definition: btPersistentManifold.h:245
btDispatcherInfo::m_dispatchFunc
int m_dispatchFunc
Definition: btDispatcher.h:55
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:46
BT_CONTACT_POINT_ALGORITHMS
Definition: btDispatcher.h:70
btPoolAllocator::freeMemory
void freeMemory(void *ptr)
Definition: btPoolAllocator.h:100
ebtDispatcherQueryType
ebtDispatcherQueryType
Definition: btDispatcher.h:68
btCollisionDispatcher
btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs.
Definition: btCollisionDispatcher.h:42
btCollisionAlgorithm::processCollision
virtual void processCollision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)=0
btMin
const T & btMin(const T &a, const T &b)
Definition: btMinMax.h:21
btOverlappingPairCache::processAllOverlappingPairs
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *dispatcher)=0
btCollisionDispatcher::CD_STATIC_STATIC_REPORTED
Definition: btCollisionDispatcher.h:66
btCollisionAlgorithm
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
Definition: btCollisionAlgorithm.h:53
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:203
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:365
btCollisionObject::checkCollideWith
bool checkCollideWith(const btCollisionObject *co) const
Definition: btCollisionObject.h:572
btCollisionConfiguration::getCollisionAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1)=0
btCollisionAlgorithmCreateFunc
Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm.
Definition: btCollisionCreateFunc.h:26
btAssert
#define btAssert(x)
Definition: btScalar.h:133
btCollisionPairCallback::processOverlap
virtual bool processOverlap(btBroadphasePair &pair)
Definition: btCollisionDispatcher.cpp:209
btCollisionDispatcher::freeCollisionAlgorithm
virtual void freeCollisionAlgorithm(void *ptr)
Definition: btCollisionDispatcher.cpp:279
btAlignedObjectArray::swap
void swap(int index0, int index1)
Definition: btAlignedObjectArray.h:389
btManifoldResult
btManifoldResult is a helper class to manage contact results.
Definition: btManifoldResult.h:47
btOverlappingPairCache.h
btCollisionDispatcher::m_doubleDispatchContactPoints
btCollisionAlgorithmCreateFunc * m_doubleDispatchContactPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES]
Definition: btCollisionDispatcher.h:57
btCollisionAlgorithmConstructionInfo
Definition: btCollisionAlgorithm.h:32
btCollisionObjectWrapper::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObjectWrapper.h:40
btBroadphasePair::m_pProxy1
btBroadphaseProxy * m_pProxy1
Definition: btBroadphaseProxy.h:216
btBroadphaseProxy::m_clientObject
void * m_clientObject
Definition: btBroadphaseProxy.h:102
btCollisionDispatcher::findAlgorithm
btCollisionAlgorithm * findAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, btPersistentManifold *sharedManifold, ebtDispatcherQueryType queryType)
Definition: btCollisionDispatcher.cpp:128
btOverlappingPairCache
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
Definition: btOverlappingPairCache.h:50
btAlignedObjectArray::pop_back
void pop_back()
Definition: btAlignedObjectArray.h:192
btBroadphasePair::m_algorithm
btCollisionAlgorithm * m_algorithm
Definition: btBroadphaseProxy.h:218
btCollisionDispatcher::getNewManifold
virtual btPersistentManifold * getNewManifold(const btCollisionObject *b0, const btCollisionObject *b1)
Definition: btCollisionDispatcher.cpp:68
btCollisionObject::getContactProcessingThreshold
btScalar getContactProcessingThreshold() const
Definition: btCollisionObject.h:188
btBroadphasePair::m_pProxy0
btBroadphaseProxy * m_pProxy0
Definition: btBroadphaseProxy.h:215
btDispatcherInfo::m_timeOfImpact
btScalar m_timeOfImpact
Definition: btDispatcher.h:56
btPoolAllocator::allocate
void * allocate(int size)
Definition: btPoolAllocator.h:71
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition: btPersistentManifold.h:63
btCollisionObject::hasContactResponse
bool hasContactResponse() const
Definition: btCollisionObject.h:208
btCollisionDispatcher::setNearCallback
void setNearCallback(btNearCallback nearCallback)
Definition: btCollisionDispatcher.h:124
MAX_BROADPHASE_COLLISION_TYPES
Definition: btBroadphaseProxy.h:78
btCollisionAlgorithmConstructionInfo::m_manifold
btPersistentManifold * m_manifold
Definition: btCollisionAlgorithm.h:46
btCollisionPairCallback::m_dispatcher
btCollisionDispatcher * m_dispatcher
Definition: btCollisionDispatcher.cpp:190
btCollisionAlgorithmConstructionInfo::m_dispatcher1
btDispatcher * m_dispatcher1
Definition: btCollisionAlgorithm.h:45
btCollisionDispatcher::registerCollisionCreateFunc
void registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc *createFunc)
registerCollisionCreateFunc allows registration of custom/alternative collision create functions
Definition: btCollisionDispatcher.cpp:54
btDispatcherInfo
Definition: btDispatcher.h:30
btCollisionDispatcher::btCollisionDispatcher
btCollisionDispatcher(btCollisionConfiguration *collisionConfiguration)
Definition: btCollisionDispatcher.cpp:32
btCollisionDispatcher::releaseManifold
virtual void releaseManifold(btPersistentManifold *manifold)
Definition: btCollisionDispatcher.cpp:106
btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD
Definition: btCollisionDispatcher.h:67
btCollisionDispatcher::allocateCollisionAlgorithm
virtual void * allocateCollisionAlgorithm(int size)
Definition: btCollisionDispatcher.cpp:268
btCollisionPairCallback
interface for iterating all overlapping collision pairs, no matter how those pairs are stored (array,...
Definition: btCollisionDispatcher.cpp:187
btCollisionPairCallback::~btCollisionPairCallback
virtual ~btCollisionPairCallback()
Definition: btCollisionDispatcher.cpp:207
btCollisionConfiguration::getCollisionAlgorithmPool
virtual btPoolAllocator * getCollisionAlgorithmPool()=0
btPersistentManifold::m_index1a
int m_index1a
Definition: btPersistentManifold.h:88
btCollisionDispatcher::m_dispatcherFlags
int m_dispatcherFlags
Definition: btCollisionDispatcher.h:45
btCollisionDispatcher::~btCollisionDispatcher
virtual ~btCollisionDispatcher()
Definition: btCollisionDispatcher.cpp:64
btQuickprof.h
btCollisionDispatcher::dispatchAllCollisionPairs
virtual void dispatchAllCollisionPairs(btOverlappingPairCache *pairCache, const btDispatcherInfo &dispatchInfo, btDispatcher *dispatcher)
Definition: btCollisionDispatcher.cpp:216
btCollisionObject::isActive
bool isActive() const
Definition: btCollisionObject.h:292
btCollisionDispatcher::registerClosestPointsCreateFunc
void registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc *createFunc)
Definition: btCollisionDispatcher.cpp:59
btCollisionDispatcher::needsResponse
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)
Definition: btCollisionDispatcher.cpp:147
btCollisionObject.h
btPoolAllocator::validPtr
bool validPtr(void *ptr)
Definition: btPoolAllocator.h:88
btCollisionDispatcher::defaultNearCallback
static void defaultNearCallback(btBroadphasePair &collisionPair, btCollisionDispatcher &dispatcher, const btDispatcherInfo &dispatchInfo)
Definition: btCollisionDispatcher.cpp:231
btCollisionConfiguration::getClosestPointsAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1)=0
btCollisionConfiguration::getPersistentManifoldPool
virtual btPoolAllocator * getPersistentManifoldPool()=0
memory pools
gContactBreakingThreshold
btScalar gContactBreakingThreshold
Definition: btPersistentManifold.cpp:26
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:264
btCollisionDispatcher::CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION
Definition: btCollisionDispatcher.h:68
btCollisionConfiguration
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
Definition: btCollisionConfiguration.h:26
btPoolAllocator.h
BT_PROFILE
#define BT_PROFILE(name)
Definition: btQuickprof.h:197
size
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
btBroadphasePair
The btBroadphasePair class contains a pair of aabb-overlapping objects.
Definition: btBroadphaseProxy.h:177
btCollisionDispatcher.h
btCollisionAlgorithm.h
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:149
btCollisionDispatcher::needsCollision
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)
Definition: btCollisionDispatcher.cpp:158
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:224
btOverlapCallback
Definition: btOverlappingPairCache.h:28