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

Bullet Collision Detection & Physics Library

btDefaultCollisionConfiguration.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 "btDefaultCollisionConfiguration.h"
17
18 #include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h"
19 #include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h"
20 #include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h"
21 #include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h"
22 #include "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h"
23
24 #include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h"
25 #include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h"
26 #include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h"
27 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
28 #include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h"
29 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
30 #include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h"
31 #include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"
32 #include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h"
33 #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
34
35
36
37 #include "LinearMath/btPoolAllocator.h"
38
39
40
41
42
43 btDefaultCollisionConfiguration::btDefaultCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo)
44 //btDefaultCollisionConfiguration::btDefaultCollisionConfiguration(btStackAlloc* stackAlloc,btPoolAllocator* persistentManifoldPool,btPoolAllocator* collisionAlgorithmPool)
45 {
46
47 void* mem = NULL;
48 if (constructionInfo.m_useEpaPenetrationAlgorithm)
49 {
50 mem = btAlignedAlloc(sizeof(btGjkEpaPenetrationDepthSolver),16);
51 m_pdSolver = new (mem)btGjkEpaPenetrationDepthSolver;
52 }else
53 {
54 mem = btAlignedAlloc(sizeof(btMinkowskiPenetrationDepthSolver),16);
55 m_pdSolver = new (mem)btMinkowskiPenetrationDepthSolver;
56 }
57
58 //default CreationFunctions, filling the m_doubleDispatch table
59 mem = btAlignedAlloc(sizeof(btConvexConvexAlgorithm::CreateFunc),16);
60 m_convexConvexCreateFunc = new(mem) btConvexConvexAlgorithm::CreateFunc(m_pdSolver);
61 mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc),16);
62 m_convexConcaveCreateFunc = new (mem)btConvexConcaveCollisionAlgorithm::CreateFunc;
63 mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc),16);
64 m_swappedConvexConcaveCreateFunc = new (mem)btConvexConcaveCollisionAlgorithm::SwappedCreateFunc;
65 mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::CreateFunc),16);
66 m_compoundCreateFunc = new (mem)btCompoundCollisionAlgorithm::CreateFunc;
67
68 mem = btAlignedAlloc(sizeof(btCompoundCompoundCollisionAlgorithm::CreateFunc),16);
69 m_compoundCompoundCreateFunc = new (mem)btCompoundCompoundCollisionAlgorithm::CreateFunc;
70
71 mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::SwappedCreateFunc),16);
72 m_swappedCompoundCreateFunc = new (mem)btCompoundCollisionAlgorithm::SwappedCreateFunc;
73 mem = btAlignedAlloc(sizeof(btEmptyAlgorithm::CreateFunc),16);
74 m_emptyCreateFunc = new(mem) btEmptyAlgorithm::CreateFunc;
75
76 mem = btAlignedAlloc(sizeof(btSphereSphereCollisionAlgorithm::CreateFunc),16);
77 m_sphereSphereCF = new(mem) btSphereSphereCollisionAlgorithm::CreateFunc;
78 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
79 mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc),16);
80 m_sphereBoxCF = new(mem) btSphereBoxCollisionAlgorithm::CreateFunc;
81 mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc),16);
82 m_boxSphereCF = new (mem)btSphereBoxCollisionAlgorithm::CreateFunc;
83 m_boxSphereCF->m_swapped = true;
84 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
85
86 mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc),16);
87 m_sphereTriangleCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
88 mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc),16);
89 m_triangleSphereCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
90 m_triangleSphereCF->m_swapped = true;
91
92 mem = btAlignedAlloc(sizeof(btBoxBoxCollisionAlgorithm::CreateFunc),16);
93 m_boxBoxCF = new(mem)btBoxBoxCollisionAlgorithm::CreateFunc;
94
95 //convex versus plane
96 mem = btAlignedAlloc (sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc),16);
97 m_convexPlaneCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc;
98 mem = btAlignedAlloc (sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc),16);
99 m_planeConvexCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc;
100 m_planeConvexCF->m_swapped = true;
101
103 int maxSize = sizeof(btConvexConvexAlgorithm);
104 int maxSize2 = sizeof(btConvexConcaveCollisionAlgorithm);
105 int maxSize3 = sizeof(btCompoundCollisionAlgorithm);
106 int maxSize4 = sizeof(btCompoundCompoundCollisionAlgorithm);
107
108 int collisionAlgorithmMaxElementSize = btMax(maxSize,constructionInfo.m_customCollisionAlgorithmMaxElementSize);
109 collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize2);
110 collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize3);
111 collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize4);
112
113 if (constructionInfo.m_persistentManifoldPool)
114 {
115 m_ownsPersistentManifoldPool = false;
116 m_persistentManifoldPool = constructionInfo.m_persistentManifoldPool;
117 } else
118 {
119 m_ownsPersistentManifoldPool = true;
120 void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
121 m_persistentManifoldPool = new (mem) btPoolAllocator(sizeof(btPersistentManifold),constructionInfo.m_defaultMaxPersistentManifoldPoolSize);
122 }
123
124 collisionAlgorithmMaxElementSize = (collisionAlgorithmMaxElementSize+16)&0xffffffffffff0;
125 if (constructionInfo.m_collisionAlgorithmPool)
126 {
127 m_ownsCollisionAlgorithmPool = false;
128 m_collisionAlgorithmPool = constructionInfo.m_collisionAlgorithmPool;
129 } else
130 {
131 m_ownsCollisionAlgorithmPool = true;
132 void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
133 m_collisionAlgorithmPool = new(mem) btPoolAllocator(collisionAlgorithmMaxElementSize,constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize);
134 }
135
136
137 }
138
139 btDefaultCollisionConfiguration::~btDefaultCollisionConfiguration()
140 {
141 if (m_ownsCollisionAlgorithmPool)
142 {
143 m_collisionAlgorithmPool->~btPoolAllocator();
144 btAlignedFree(m_collisionAlgorithmPool);
145 }
146 if (m_ownsPersistentManifoldPool)
147 {
148 m_persistentManifoldPool->~btPoolAllocator();
149 btAlignedFree(m_persistentManifoldPool);
150 }
151
152 m_convexConvexCreateFunc->~btCollisionAlgorithmCreateFunc();
153 btAlignedFree( m_convexConvexCreateFunc);
154
155 m_convexConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();
156 btAlignedFree( m_convexConcaveCreateFunc);
157 m_swappedConvexConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();
158 btAlignedFree( m_swappedConvexConcaveCreateFunc);
159
160 m_compoundCreateFunc->~btCollisionAlgorithmCreateFunc();
161 btAlignedFree( m_compoundCreateFunc);
162
163 m_compoundCompoundCreateFunc->~btCollisionAlgorithmCreateFunc();
164 btAlignedFree(m_compoundCompoundCreateFunc);
165
166 m_swappedCompoundCreateFunc->~btCollisionAlgorithmCreateFunc();
167 btAlignedFree( m_swappedCompoundCreateFunc);
168
169 m_emptyCreateFunc->~btCollisionAlgorithmCreateFunc();
170 btAlignedFree( m_emptyCreateFunc);
171
172 m_sphereSphereCF->~btCollisionAlgorithmCreateFunc();
173 btAlignedFree( m_sphereSphereCF);
174
175 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
176 m_sphereBoxCF->~btCollisionAlgorithmCreateFunc();
177 btAlignedFree( m_sphereBoxCF);
178 m_boxSphereCF->~btCollisionAlgorithmCreateFunc();
179 btAlignedFree( m_boxSphereCF);
180 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
181
182 m_sphereTriangleCF->~btCollisionAlgorithmCreateFunc();
183 btAlignedFree( m_sphereTriangleCF);
184 m_triangleSphereCF->~btCollisionAlgorithmCreateFunc();
185 btAlignedFree( m_triangleSphereCF);
186 m_boxBoxCF->~btCollisionAlgorithmCreateFunc();
187 btAlignedFree( m_boxBoxCF);
188
189 m_convexPlaneCF->~btCollisionAlgorithmCreateFunc();
190 btAlignedFree( m_convexPlaneCF);
191 m_planeConvexCF->~btCollisionAlgorithmCreateFunc();
192 btAlignedFree( m_planeConvexCF);
193
194 m_pdSolver->~btConvexPenetrationDepthSolver();
195
196 btAlignedFree(m_pdSolver);
197
198
199 }
200
201 btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1)
202 {
203
204
205 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE))
206 {
207 return m_sphereSphereCF;
208 }
209 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
210 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE))
211 {
212 return m_sphereBoxCF;
213 }
214
215 if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE))
216 {
217 return m_boxSphereCF;
218 }
219 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
220
221
222 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1 == TRIANGLE_SHAPE_PROXYTYPE))
223 {
224 return m_sphereTriangleCF;
225 }
226
227 if ((proxyType0 == TRIANGLE_SHAPE_PROXYTYPE) && (proxyType1 == SPHERE_SHAPE_PROXYTYPE))
228 {
229 return m_triangleSphereCF;
230 }
231
232 if (btBroadphaseProxy::isConvex(proxyType0) && (proxyType1 == STATIC_PLANE_PROXYTYPE))
233 {
234 return m_convexPlaneCF;
235 }
236
237 if (btBroadphaseProxy::isConvex(proxyType1) && (proxyType0 == STATIC_PLANE_PROXYTYPE))
238 {
239 return m_planeConvexCF;
240 }
241
242
243
244 if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConvex(proxyType1))
245 {
246 return m_convexConvexCreateFunc;
247 }
248
249 if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConcave(proxyType1))
250 {
251 return m_convexConcaveCreateFunc;
252 }
253
254 if (btBroadphaseProxy::isConvex(proxyType1) && btBroadphaseProxy::isConcave(proxyType0))
255 {
256 return m_swappedConvexConcaveCreateFunc;
257 }
258
259
260 if (btBroadphaseProxy::isCompound(proxyType0) && btBroadphaseProxy::isCompound(proxyType1))
261 {
262 return m_compoundCompoundCreateFunc;
263 }
264
265 if (btBroadphaseProxy::isCompound(proxyType0))
266 {
267 return m_compoundCreateFunc;
268 }
269 else
270 {
271 if (btBroadphaseProxy::isCompound(proxyType1))
272 {
273 return m_swappedCompoundCreateFunc;
274 }
275 }
276
277 //failed to find an algorithm
278 return m_emptyCreateFunc;
279
280 }
281
282 btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc(int proxyType0,int proxyType1)
283 {
284
285
286
287 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
288 {
289 return m_sphereSphereCF;
290 }
291 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
292 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1==BOX_SHAPE_PROXYTYPE))
293 {
294 return m_sphereBoxCF;
295 }
296
297 if ((proxyType0 == BOX_SHAPE_PROXYTYPE ) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
298 {
299 return m_boxSphereCF;
300 }
301 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
302
303
304 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE ) && (proxyType1==TRIANGLE_SHAPE_PROXYTYPE))
305 {
306 return m_sphereTriangleCF;
307 }
308
309 if ((proxyType0 == TRIANGLE_SHAPE_PROXYTYPE ) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
310 {
311 return m_triangleSphereCF;
312 }
313
314 if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE))
315 {
316 return m_boxBoxCF;
317 }
318
319 if (btBroadphaseProxy::isConvex(proxyType0) && (proxyType1 == STATIC_PLANE_PROXYTYPE))
320 {
321 return m_convexPlaneCF;
322 }
323
324 if (btBroadphaseProxy::isConvex(proxyType1) && (proxyType0 == STATIC_PLANE_PROXYTYPE))
325 {
326 return m_planeConvexCF;
327 }
328
329
330
331 if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConvex(proxyType1))
332 {
333 return m_convexConvexCreateFunc;
334 }
335
336 if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConcave(proxyType1))
337 {
338 return m_convexConcaveCreateFunc;
339 }
340
341 if (btBroadphaseProxy::isConvex(proxyType1) && btBroadphaseProxy::isConcave(proxyType0))
342 {
343 return m_swappedConvexConcaveCreateFunc;
344 }
345
346
347 if (btBroadphaseProxy::isCompound(proxyType0) && btBroadphaseProxy::isCompound(proxyType1))
348 {
349 return m_compoundCompoundCreateFunc;
350 }
351
352 if (btBroadphaseProxy::isCompound(proxyType0))
353 {
354 return m_compoundCreateFunc;
355 } else
356 {
357 if (btBroadphaseProxy::isCompound(proxyType1))
358 {
359 return m_swappedCompoundCreateFunc;
360 }
361 }
362
363 //failed to find an algorithm
364 return m_emptyCreateFunc;
365 }
366
367 void btDefaultCollisionConfiguration::setConvexConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
368 {
369 btConvexConvexAlgorithm::CreateFunc* convexConvex = (btConvexConvexAlgorithm::CreateFunc*) m_convexConvexCreateFunc;
370 convexConvex->m_numPerturbationIterations = numPerturbationIterations;
371 convexConvex->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
372 }
373
374 void btDefaultCollisionConfiguration::setPlaneConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
375 {
376 btConvexPlaneCollisionAlgorithm::CreateFunc* cpCF = (btConvexPlaneCollisionAlgorithm::CreateFunc*)m_convexPlaneCF;
377 cpCF->m_numPerturbationIterations = numPerturbationIterations;
378 cpCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
379
380 btConvexPlaneCollisionAlgorithm::CreateFunc* pcCF = (btConvexPlaneCollisionAlgorithm::CreateFunc*)m_planeConvexCF;
381 pcCF->m_numPerturbationIterations = numPerturbationIterations;
382 pcCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
383 }
btConvexConvexAlgorithm::CreateFunc
Definition: btConvexConvexAlgorithm.h:88
btMinkowskiPenetrationDepthSolver.h
btDefaultCollisionConfiguration::m_convexPlaneCF
btCollisionAlgorithmCreateFunc * m_convexPlaneCF
Definition: btDefaultCollisionConfiguration.h:83
btDefaultCollisionConstructionInfo::m_persistentManifoldPool
btPoolAllocator * m_persistentManifoldPool
Definition: btDefaultCollisionConfiguration.h:25
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition: btPersistentManifold.h:63
btDefaultCollisionConfiguration::m_ownsCollisionAlgorithmPool
bool m_ownsCollisionAlgorithmPool
Definition: btDefaultCollisionConfiguration.h:61
SPHERE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:40
btCompoundCompoundCollisionAlgorithm
btCompoundCompoundCollisionAlgorithm supports collision between two btCompoundCollisionShape shapes ...
Definition: btCompoundCompoundCollisionAlgorithm.h:38
btSphereTriangleCollisionAlgorithm.h
btConvexConcaveCollisionAlgorithm::CreateFunc
Definition: btConvexConcaveCollisionAlgorithm.h:107
btDefaultCollisionConfiguration::setConvexConvexMultipointIterations
void setConvexConvexMultipointIterations(int numPerturbationIterations=3, int minimumPointsPerturbationThreshold=3)
Use this method to allow to generate multiple contact points between at once, between two objects usi...
Definition: btDefaultCollisionConfiguration.cpp:367
btBoxBoxCollisionAlgorithm.h
btDefaultCollisionConfiguration::m_collisionAlgorithmPool
btPoolAllocator * m_collisionAlgorithmPool
Definition: btDefaultCollisionConfiguration.h:60
btDefaultCollisionConfiguration::m_pdSolver
btConvexPenetrationDepthSolver * m_pdSolver
Definition: btDefaultCollisionConfiguration.h:64
btConvexPlaneCollisionAlgorithm::CreateFunc::m_numPerturbationIterations
int m_numPerturbationIterations
Definition: btConvexPlaneCollisionAlgorithm.h:59
btSphereSphereCollisionAlgorithm.h
btBroadphaseProxy::isCompound
static bool isCompound(int proxyType)
Definition: btBroadphaseProxy.h:153
btConvexPlaneCollisionAlgorithm::CreateFunc
Definition: btConvexPlaneCollisionAlgorithm.h:57
btDefaultCollisionConstructionInfo
Definition: btDefaultCollisionConfiguration.h:23
btCompoundCollisionAlgorithm::SwappedCreateFunc
Definition: btCompoundCollisionAlgorithm.h:93
btDefaultCollisionConstructionInfo::m_customCollisionAlgorithmMaxElementSize
int m_customCollisionAlgorithmMaxElementSize
Definition: btDefaultCollisionConfiguration.h:29
btDefaultCollisionConstructionInfo::m_collisionAlgorithmPool
btPoolAllocator * m_collisionAlgorithmPool
Definition: btDefaultCollisionConfiguration.h:26
BOX_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:31
btDefaultCollisionConfiguration::m_boxBoxCF
btCollisionAlgorithmCreateFunc * m_boxBoxCF
Definition: btDefaultCollisionConfiguration.h:79
btDefaultCollisionConfiguration.h
btDefaultCollisionConfiguration::m_triangleSphereCF
btCollisionAlgorithmCreateFunc * m_triangleSphereCF
Definition: btDefaultCollisionConfiguration.h:81
btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1)
Definition: btDefaultCollisionConfiguration.cpp:282
btDefaultCollisionConfiguration::m_ownsPersistentManifoldPool
bool m_ownsPersistentManifoldPool
Definition: btDefaultCollisionConfiguration.h:57
btDefaultCollisionConstructionInfo::m_defaultMaxCollisionAlgorithmPoolSize
int m_defaultMaxCollisionAlgorithmPoolSize
Definition: btDefaultCollisionConfiguration.h:28
btCompoundCollisionAlgorithm.h
btDefaultCollisionConfiguration::btDefaultCollisionConfiguration
btDefaultCollisionConfiguration(const btDefaultCollisionConstructionInfo &constructionInfo=btDefaultCollisionConstructionInfo())
Definition: btDefaultCollisionConfiguration.cpp:43
btConvexPenetrationDepthSolver::~btConvexPenetrationDepthSolver
virtual ~btConvexPenetrationDepthSolver()
Definition: btConvexPenetrationDepthSolver.h:30
btConvexConcaveCollisionAlgorithm.h
btCompoundCollisionAlgorithm::CreateFunc
Definition: btCompoundCollisionAlgorithm.h:84
btSphereSphereCollisionAlgorithm::CreateFunc
Definition: btSphereSphereCollisionAlgorithm.h:54
btDefaultCollisionConfiguration::m_swappedConvexConcaveCreateFunc
btCollisionAlgorithmCreateFunc * m_swappedConvexConcaveCreateFunc
Definition: btDefaultCollisionConfiguration.h:69
TRIANGLE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:32
btDefaultCollisionConfiguration::~btDefaultCollisionConfiguration
virtual ~btDefaultCollisionConfiguration()
Definition: btDefaultCollisionConfiguration.cpp:139
btConvexPlaneCollisionAlgorithm.h
btCollisionAlgorithmCreateFunc
Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm.
Definition: btCollisionCreateFunc.h:26
btSphereBoxCollisionAlgorithm.h
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:48
btDefaultCollisionConstructionInfo::m_useEpaPenetrationAlgorithm
int m_useEpaPenetrationAlgorithm
Definition: btDefaultCollisionConfiguration.h:30
btMinkowskiPenetrationDepthSolver
MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation.
Definition: btMinkowskiPenetrationDepthSolver.h:23
btDefaultCollisionConfiguration::m_persistentManifoldPool
btPoolAllocator * m_persistentManifoldPool
Definition: btDefaultCollisionConfiguration.h:56
btSphereBoxCollisionAlgorithm::CreateFunc
Definition: btSphereBoxCollisionAlgorithm.h:57
btBoxBoxCollisionAlgorithm::CreateFunc
Definition: btBoxBoxCollisionAlgorithm.h:53
btEmptyAlgorithm::CreateFunc
Definition: btEmptyCollisionAlgorithm.h:41
btPoolAllocator.h
btDefaultCollisionConfiguration::getClosestPointsAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1)
Definition: btDefaultCollisionConfiguration.cpp:201
btDefaultCollisionConfiguration::m_emptyCreateFunc
btCollisionAlgorithmCreateFunc * m_emptyCreateFunc
Definition: btDefaultCollisionConfiguration.h:74
btConvexConcaveCollisionAlgorithm
btConvexConcaveCollisionAlgorithm supports collision between convex shapes and (concave) trianges mes...
Definition: btConvexConcaveCollisionAlgorithm.h:82
btDefaultCollisionConfiguration::setPlaneConvexMultipointIterations
void setPlaneConvexMultipointIterations(int numPerturbationIterations=3, int minimumPointsPerturbationThreshold=3)
Definition: btDefaultCollisionConfiguration.cpp:374
btDefaultCollisionConfiguration::m_sphereTriangleCF
btCollisionAlgorithmCreateFunc * m_sphereTriangleCF
Definition: btDefaultCollisionConfiguration.h:80
btDefaultCollisionConfiguration::m_sphereSphereCF
btCollisionAlgorithmCreateFunc * m_sphereSphereCF
Definition: btDefaultCollisionConfiguration.h:75
btGjkEpaPenetrationDepthSolver
EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to calculate the penetration depth be...
Definition: btGjkEpaPenetrationDepthSolver.h:24
btDefaultCollisionConfiguration::m_planeConvexCF
btCollisionAlgorithmCreateFunc * m_planeConvexCF
Definition: btDefaultCollisionConfiguration.h:82
btDefaultCollisionConfiguration::m_compoundCreateFunc
btCollisionAlgorithmCreateFunc * m_compoundCreateFunc
Definition: btDefaultCollisionConfiguration.h:70
btConvexConvexAlgorithm::CreateFunc::m_numPerturbationIterations
int m_numPerturbationIterations
Definition: btConvexConvexAlgorithm.h:92
btEmptyCollisionAlgorithm.h
btPoolAllocator
The btPoolAllocator class allows to efficiently allocate a large pool of objects, instead of dynamica...
Definition: btPoolAllocator.h:24
btCompoundCompoundCollisionAlgorithm::CreateFunc
Definition: btCompoundCompoundCollisionAlgorithm.h:67
btCompoundCollisionAlgorithm
btCompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision s...
Definition: btCompoundCollisionAlgorithm.h:38
btBroadphaseProxy::isConcave
static bool isConcave(int proxyType)
Definition: btBroadphaseProxy.h:148
btMax
const T & btMax(const T &a, const T &b)
Definition: btMinMax.h:29
btVoronoiSimplexSolver.h
btDefaultCollisionConfiguration::m_boxSphereCF
btCollisionAlgorithmCreateFunc * m_boxSphereCF
Definition: btDefaultCollisionConfiguration.h:77
btSphereTriangleCollisionAlgorithm::CreateFunc
Definition: btSphereTriangleCollisionAlgorithm.h:54
btConvexConvexAlgorithm
Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation.
Definition: btConvexConvexAlgorithm.h:41
btDefaultCollisionConfiguration::m_compoundCompoundCreateFunc
btCollisionAlgorithmCreateFunc * m_compoundCompoundCreateFunc
Definition: btDefaultCollisionConfiguration.h:71
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:47
btDefaultCollisionConfiguration::m_convexConcaveCreateFunc
btCollisionAlgorithmCreateFunc * m_convexConcaveCreateFunc
Definition: btDefaultCollisionConfiguration.h:68
btDefaultCollisionConstructionInfo::m_defaultMaxPersistentManifoldPoolSize
int m_defaultMaxPersistentManifoldPoolSize
Definition: btDefaultCollisionConfiguration.h:27
btConvexPlaneCollisionAlgorithm::CreateFunc::m_minimumPointsPerturbationThreshold
int m_minimumPointsPerturbationThreshold
Definition: btConvexPlaneCollisionAlgorithm.h:60
btConvexConcaveCollisionAlgorithm::SwappedCreateFunc
Definition: btConvexConcaveCollisionAlgorithm.h:116
btConvexConvexAlgorithm::CreateFunc::m_minimumPointsPerturbationThreshold
int m_minimumPointsPerturbationThreshold
Definition: btConvexConvexAlgorithm.h:93
btBroadphaseProxy::isConvex
static bool isConvex(int proxyType)
Definition: btBroadphaseProxy.h:138
btPoolAllocator::~btPoolAllocator
~btPoolAllocator()
Definition: btPoolAllocator.h:52
btDefaultCollisionConfiguration::m_sphereBoxCF
btCollisionAlgorithmCreateFunc * m_sphereBoxCF
Definition: btDefaultCollisionConfiguration.h:76
btCollisionAlgorithmCreateFunc::m_swapped
bool m_swapped
Definition: btCollisionCreateFunc.h:28
btDefaultCollisionConfiguration::m_convexConvexCreateFunc
btCollisionAlgorithmCreateFunc * m_convexConvexCreateFunc
Definition: btDefaultCollisionConfiguration.h:67
btGjkEpaPenetrationDepthSolver.h
btConvexConvexAlgorithm.h
STATIC_PLANE_PROXYTYPE
Definition: btBroadphaseProxy.h:67
btDefaultCollisionConfiguration::m_swappedCompoundCreateFunc
btCollisionAlgorithmCreateFunc * m_swappedCompoundCreateFunc
Definition: btDefaultCollisionConfiguration.h:73
btCollisionAlgorithmCreateFunc::~btCollisionAlgorithmCreateFunc
virtual ~btCollisionAlgorithmCreateFunc()
Definition: btCollisionCreateFunc.h:34
btCompoundCompoundCollisionAlgorithm.h