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

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

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