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

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btCollisionDispatcher.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 "btCollisionDispatcher.h"
17#include "LinearMath/btQuickprof.h"
18
19#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
20
21#include "BulletCollision/CollisionShapes/btCollisionShape.h"
22#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
23#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
24#include "LinearMath/btPoolAllocator.h"
25#include "BulletCollision/CollisionDispatch/btCollisionConfiguration.h"
26#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
27
28#ifdef BT_DEBUG
29#include <stdio.h>
30#endif
31
32btCollisionDispatcher::btCollisionDispatcher(btCollisionConfiguration* collisionConfiguration) : m_dispatcherFlags(btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD),
33 m_collisionConfiguration(collisionConfiguration)
34{
35 int i;
36
37 setNearCallback(defaultNearCallback);
38
39 m_collisionAlgorithmPoolAllocator = collisionConfiguration->getCollisionAlgorithmPool();
40
41 m_persistentManifoldPoolAllocator = collisionConfiguration->getPersistentManifoldPool();
42
43 for (i = 0; i < MAX_BROADPHASE_COLLISION_TYPES; i++)
44 {
45 for (int j = 0; j < MAX_BROADPHASE_COLLISION_TYPES; j++)
46 {
47 m_doubleDispatchContactPoints[i][j] = m_collisionConfiguration->getCollisionAlgorithmCreateFunc(i, j);
48 btAssert(m_doubleDispatchContactPoints[i][j]);
49 m_doubleDispatchClosestPoints[i][j] = m_collisionConfiguration->getClosestPointsAlgorithmCreateFunc(i, j);
50 }
51 }
52}
53
54 void btCollisionDispatcher::registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc)
55{
56 m_doubleDispatchContactPoints[proxyType0][proxyType1] = createFunc;
57}
58
59 void btCollisionDispatcher::registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc* createFunc)
60{
61 m_doubleDispatchClosestPoints[proxyType0][proxyType1] = createFunc;
62}
63
64btCollisionDispatcher::~btCollisionDispatcher()
65{
66}
67
68 btPersistentManifold* btCollisionDispatcher::getNewManifold(const btCollisionObject* body0, const btCollisionObject* body1)
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
74 btScalar contactBreakingThreshold = (m_dispatcherFlags & btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD) ? btMin(body0->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold), body1->getCollisionShape()->getContactBreakingThreshold(gContactBreakingThreshold))
75 : gContactBreakingThreshold;
76
77 btScalar contactProcessingThreshold = btMin(body0->getContactProcessingThreshold(), body1->getContactProcessingThreshold());
78
79 void* mem = m_persistentManifoldPoolAllocator->allocate(sizeof(btPersistentManifold));
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.
83 if ((m_dispatcherFlags & CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION) == 0)
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
101 void btCollisionDispatcher::clearManifold(btPersistentManifold* manifold)
102{
103 manifold->clearManifold();
104}
105
106 void btCollisionDispatcher::releaseManifold(btPersistentManifold* manifold)
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;
115 m_manifoldsPtr.pop_back();
116
117 manifold->~btPersistentManifold();
118 if (m_persistentManifoldPoolAllocator->validPtr(manifold))
119 {
120 m_persistentManifoldPoolAllocator->freeMemory(manifold);
121 }
122 else
123 {
124 btAlignedFree(manifold);
125 }
126}
127
128 btCollisionAlgorithm* btCollisionDispatcher::findAlgorithm(const btCollisionObjectWrapper* body0Wrap, const btCollisionObjectWrapper* body1Wrap, btPersistentManifold* sharedManifold, ebtDispatcherQueryType algoType)
129{
130 btCollisionAlgorithmConstructionInfo ci;
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
147 bool btCollisionDispatcher::needsResponse(const btCollisionObject* body0, const btCollisionObject* body1)
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
158 bool btCollisionDispatcher::needsCollision(const btCollisionObject* body0, const btCollisionObject* body1)
159{
160 btAssert(body0);
161 btAssert(body1);
162
163 bool needsCollision = true;
164
165#ifdef BT_DEBUG
166 if (!(m_dispatcherFlags & btCollisionDispatcher::CD_STATIC_STATIC_REPORTED))
167 {
168 //broadphase filtering already deals with this
169 if (body0->isStaticOrKinematicObject() && body1->isStaticOrKinematicObject())
170 {
171 m_dispatcherFlags |= btCollisionDispatcher::CD_STATIC_STATIC_REPORTED;
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
187 class btCollisionPairCallback : public btOverlapCallback
188{
189 const btDispatcherInfo& m_dispatchInfo;
190 btCollisionDispatcher* m_dispatcher;
191
192public:
193 btCollisionPairCallback(const btDispatcherInfo& dispatchInfo, btCollisionDispatcher* dispatcher)
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
207 virtual ~btCollisionPairCallback() {}
208
209 virtual bool processOverlap(btBroadphasePair& pair)
210 {
211 (*m_dispatcher->getNearCallback())(pair, *m_dispatcher, m_dispatchInfo);
212 return false;
213 }
214};
215
216 void btCollisionDispatcher::dispatchAllCollisionPairs(btOverlappingPairCache* pairCache, const btDispatcherInfo& dispatchInfo, btDispatcher* dispatcher)
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
231 void btCollisionDispatcher::defaultNearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo)
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
251 if (dispatchInfo.m_dispatchFunc == btDispatcherInfo::DISPATCH_DISCRETE)
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
268 void* btCollisionDispatcher::allocateCollisionAlgorithm(int size)
269{
270 void* mem = m_collisionAlgorithmPoolAllocator->allocate(size);
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
279 void btCollisionDispatcher::freeCollisionAlgorithm(void* ptr)
280{
281 if (m_collisionAlgorithmPoolAllocator->validPtr(ptr))
282 {
283 m_collisionAlgorithmPoolAllocator->freeMemory(ptr);
284 }
285 else
286 {
287 btAlignedFree(ptr);
288 }
289}
btAlignedFree
#define btAlignedFree(ptr)
Definition btAlignedAllocator.h:47
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition btAlignedAllocator.h:46
MAX_BROADPHASE_COLLISION_TYPES
@ MAX_BROADPHASE_COLLISION_TYPES
Definition btBroadphaseProxy.h:78
btCollisionAlgorithm.h
btCollisionConfiguration.h
btCollisionDispatcher.h
btCollisionObjectWrapper.h
btCollisionObject.h
btCollisionShape.h
gContactBreakingThreshold
btScalar gContactBreakingThreshold
Definition btPersistentManifold.cpp:26
size
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition btDbvt.cpp:52
ebtDispatcherQueryType
ebtDispatcherQueryType
Definition btDispatcher.h:69
BT_CONTACT_POINT_ALGORITHMS
@ BT_CONTACT_POINT_ALGORITHMS
Definition btDispatcher.h:70
btMin
const T & btMin(const T &a, const T &b)
Definition btMinMax.h:21
btOverlappingPairCache.h
btPoolAllocator.h
btQuickprof.h
BT_PROFILE
#define BT_PROFILE(name)
Definition btQuickprof.h:198
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition btScalar.h:314
btAssert
#define btAssert(x)
Definition btScalar.h:153
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition btAlignedObjectArray.h:142
btAlignedObjectArray::swap
void swap(int index0, int index1)
Definition btAlignedObjectArray.h:382
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition btAlignedObjectArray.h:257
btAlignedObjectArray::pop_back
void pop_back()
Definition btAlignedObjectArray.h:185
btCollisionAlgorithm
btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatche...
Definition btCollisionAlgorithm.h:54
btCollisionAlgorithm::processCollision
virtual void processCollision(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)=0
btCollisionAlgorithm::calculateTimeOfImpact
virtual btScalar calculateTimeOfImpact(btCollisionObject *body0, btCollisionObject *body1, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)=0
btCollisionConfiguration
btCollisionConfiguration allows to configure Bullet collision detection stack allocator size,...
Definition btCollisionConfiguration.h:27
btCollisionConfiguration::getPersistentManifoldPool
virtual btPoolAllocator * getPersistentManifoldPool()=0
memory pools
btCollisionConfiguration::getCollisionAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1)=0
btCollisionConfiguration::getCollisionAlgorithmPool
virtual btPoolAllocator * getCollisionAlgorithmPool()=0
btCollisionConfiguration::getClosestPointsAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1)=0
btCollisionDispatcher
btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs.
Definition btCollisionDispatcher.h:43
btCollisionDispatcher::m_doubleDispatchClosestPoints
btCollisionAlgorithmCreateFunc * m_doubleDispatchClosestPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES]
Definition btCollisionDispatcher.h:57
btCollisionDispatcher::m_dispatcherFlags
int m_dispatcherFlags
Definition btCollisionDispatcher.h:45
btCollisionDispatcher::releaseManifold
virtual void releaseManifold(btPersistentManifold *manifold)
Definition btCollisionDispatcher.cpp:106
btCollisionDispatcher::registerClosestPointsCreateFunc
void registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc *createFunc)
Definition btCollisionDispatcher.cpp:59
btCollisionDispatcher::m_collisionConfiguration
btCollisionConfiguration * m_collisionConfiguration
Definition btCollisionDispatcher.h:59
btCollisionDispatcher::needsCollision
virtual bool needsCollision(const btCollisionObject *body0, const btCollisionObject *body1)
Definition btCollisionDispatcher.cpp:158
btCollisionDispatcher::btCollisionDispatcher
btCollisionDispatcher(btCollisionConfiguration *collisionConfiguration)
Definition btCollisionDispatcher.cpp:32
btCollisionDispatcher::getNearCallback
btNearCallback getNearCallback() const
Definition btCollisionDispatcher.h:131
btCollisionDispatcher::setNearCallback
void setNearCallback(btNearCallback nearCallback)
Definition btCollisionDispatcher.h:126
btCollisionDispatcher::getNewManifold
virtual btPersistentManifold * getNewManifold(const btCollisionObject *b0, const btCollisionObject *b1)
Definition btCollisionDispatcher.cpp:68
btCollisionDispatcher::freeCollisionAlgorithm
virtual void freeCollisionAlgorithm(void *ptr)
Definition btCollisionDispatcher.cpp:279
btCollisionDispatcher::~btCollisionDispatcher
virtual ~btCollisionDispatcher()
Definition btCollisionDispatcher.cpp:64
btCollisionDispatcher::m_doubleDispatchContactPoints
btCollisionAlgorithmCreateFunc * m_doubleDispatchContactPoints[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES]
Definition btCollisionDispatcher.h:55
btCollisionDispatcher::defaultNearCallback
static void defaultNearCallback(btBroadphasePair &collisionPair, btCollisionDispatcher &dispatcher, const btDispatcherInfo &dispatchInfo)
Definition btCollisionDispatcher.cpp:231
btCollisionDispatcher::dispatchAllCollisionPairs
virtual void dispatchAllCollisionPairs(btOverlappingPairCache *pairCache, const btDispatcherInfo &dispatchInfo, btDispatcher *dispatcher)
Definition btCollisionDispatcher.cpp:216
btCollisionDispatcher::m_collisionAlgorithmPoolAllocator
btPoolAllocator * m_collisionAlgorithmPoolAllocator
Definition btCollisionDispatcher.h:51
btCollisionDispatcher::clearManifold
virtual void clearManifold(btPersistentManifold *manifold)
Definition btCollisionDispatcher.cpp:101
btCollisionDispatcher::needsResponse
virtual bool needsResponse(const btCollisionObject *body0, const btCollisionObject *body1)
Definition btCollisionDispatcher.cpp:147
btCollisionDispatcher::findAlgorithm
btCollisionAlgorithm * findAlgorithm(const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, btPersistentManifold *sharedManifold, ebtDispatcherQueryType queryType)
Definition btCollisionDispatcher.cpp:128
btCollisionDispatcher::CD_STATIC_STATIC_REPORTED
@ CD_STATIC_STATIC_REPORTED
Definition btCollisionDispatcher.h:64
btCollisionDispatcher::CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD
@ CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD
Definition btCollisionDispatcher.h:65
btCollisionDispatcher::CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION
@ CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION
Definition btCollisionDispatcher.h:66
btCollisionDispatcher::allocateCollisionAlgorithm
virtual void * allocateCollisionAlgorithm(int size)
Definition btCollisionDispatcher.cpp:268
btCollisionDispatcher::m_manifoldsPtr
btAlignedObjectArray< btPersistentManifold * > m_manifoldsPtr
Definition btCollisionDispatcher.h:47
btCollisionDispatcher::m_persistentManifoldPoolAllocator
btPoolAllocator * m_persistentManifoldPoolAllocator
Definition btCollisionDispatcher.h:53
btCollisionDispatcher::registerCollisionCreateFunc
void registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc *createFunc)
registerCollisionCreateFunc allows registration of custom/alternative collision create functions
Definition btCollisionDispatcher.cpp:54
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition btCollisionObject.h:51
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition btCollisionObject.h:207
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition btCollisionObject.h:379
btCollisionObject::hasContactResponse
bool hasContactResponse() const
Definition btCollisionObject.h:212
btCollisionObject::isActive
bool isActive() const
Definition btCollisionObject.h:306
btCollisionObject::checkCollideWith
bool checkCollideWith(const btCollisionObject *co) const
Definition btCollisionObject.h:596
btCollisionObject::getContactProcessingThreshold
btScalar getContactProcessingThreshold() const
Definition btCollisionObject.h:192
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition btCollisionObject.h:228
btCollisionPairCallback
interface for iterating all overlapping collision pairs, no matter how those pairs are stored (array,...
Definition btCollisionDispatcher.cpp:188
btCollisionPairCallback::processOverlap
virtual bool processOverlap(btBroadphasePair &pair)
Definition btCollisionDispatcher.cpp:209
btCollisionPairCallback::m_dispatcher
btCollisionDispatcher * m_dispatcher
Definition btCollisionDispatcher.cpp:190
btCollisionPairCallback::m_dispatchInfo
const btDispatcherInfo & m_dispatchInfo
Definition btCollisionDispatcher.cpp:189
btCollisionPairCallback::~btCollisionPairCallback
virtual ~btCollisionPairCallback()
Definition btCollisionDispatcher.cpp:207
btCollisionPairCallback::btCollisionPairCallback
btCollisionPairCallback(const btDispatcherInfo &dispatchInfo, btCollisionDispatcher *dispatcher)
Definition btCollisionDispatcher.cpp:193
btCollisionShape::getShapeType
int getShapeType() const
Definition btCollisionShape.h:107
btCollisionShape::getContactBreakingThreshold
virtual btScalar getContactBreakingThreshold(btScalar defaultContactThresholdFactor) const
Definition btCollisionShape.cpp:42
btDispatcher
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
Definition btDispatcher.h:77
btManifoldResult
btManifoldResult is a helper class to manage contact results.
Definition btManifoldResult.h:48
btOverlappingPairCache
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
Definition btOverlappingPairCache.h:51
btOverlappingPairCache::processAllOverlappingPairs
virtual void processAllOverlappingPairs(btOverlapCallback *, btDispatcher *dispatcher)=0
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition btPersistentManifold.h:65
btPersistentManifold::clearManifold
void clearManifold()
Definition btPersistentManifold.h:248
btPersistentManifold::m_index1a
int m_index1a
Definition btPersistentManifold.h:88
btPoolAllocator::freeMemory
void freeMemory(void *ptr)
Definition btPoolAllocator.h:100
btPoolAllocator::validPtr
bool validPtr(void *ptr)
Definition btPoolAllocator.h:88
btPoolAllocator::allocate
void * allocate(int size)
Definition btPoolAllocator.h:71
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_pProxy0
btBroadphaseProxy * m_pProxy0
Definition btBroadphaseProxy.h:208
btBroadphasePair::m_algorithm
btCollisionAlgorithm * m_algorithm
Definition btBroadphaseProxy.h:211
btBroadphaseProxy::m_clientObject
void * m_clientObject
Definition btBroadphaseProxy.h:102
btCollisionAlgorithmConstructionInfo
Definition btCollisionAlgorithm.h:33
btCollisionAlgorithmConstructionInfo::m_manifold
btPersistentManifold * m_manifold
Definition btCollisionAlgorithm.h:46
btCollisionAlgorithmConstructionInfo::m_dispatcher1
btDispatcher * m_dispatcher1
Definition btCollisionAlgorithm.h:45
btCollisionAlgorithmCreateFunc
Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm.
Definition btCollisionCreateFunc.h:27
btCollisionAlgorithmCreateFunc::CreateCollisionAlgorithm
virtual btCollisionAlgorithm * CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo &, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap)
Definition btCollisionCreateFunc.h:36
btCollisionObjectWrapper
Definition btCollisionObjectWrapper.h:18
btCollisionObjectWrapper::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition btCollisionObjectWrapper.h:46
btDispatcherInfo
Definition btDispatcher.h:31
btDispatcherInfo::m_dispatchFunc
int m_dispatchFunc
Definition btDispatcher.h:55
btDispatcherInfo::DISPATCH_DISCRETE
@ DISPATCH_DISCRETE
Definition btDispatcher.h:34
btDispatcherInfo::m_timeOfImpact
btScalar m_timeOfImpact
Definition btDispatcher.h:56
btOverlapCallback
Definition btOverlappingPairCache.h:29