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 = btAlignedAlloc(sizeof(btVoronoiSimplexSolver),16);
48 m_simplexSolver = new (mem)btVoronoiSimplexSolver();
49
50 if (constructionInfo.m_useEpaPenetrationAlgorithm)
51 {
52 mem = btAlignedAlloc(sizeof(btGjkEpaPenetrationDepthSolver),16);
53 m_pdSolver = new (mem)btGjkEpaPenetrationDepthSolver;
54 }else
55 {
56 mem = btAlignedAlloc(sizeof(btMinkowskiPenetrationDepthSolver),16);
57 m_pdSolver = new (mem)btMinkowskiPenetrationDepthSolver;
58 }
59
60 //default CreationFunctions, filling the m_doubleDispatch table
61 mem = btAlignedAlloc(sizeof(btConvexConvexAlgorithm::CreateFunc),16);
62 m_convexConvexCreateFunc = new(mem) btConvexConvexAlgorithm::CreateFunc(m_simplexSolver,m_pdSolver);
63 mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc),16);
64 m_convexConcaveCreateFunc = new (mem)btConvexConcaveCollisionAlgorithm::CreateFunc;
65 mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc),16);
66 m_swappedConvexConcaveCreateFunc = new (mem)btConvexConcaveCollisionAlgorithm::SwappedCreateFunc;
67 mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::CreateFunc),16);
68 m_compoundCreateFunc = new (mem)btCompoundCollisionAlgorithm::CreateFunc;
69
70 mem = btAlignedAlloc(sizeof(btCompoundCompoundCollisionAlgorithm::CreateFunc),16);
71 m_compoundCompoundCreateFunc = new (mem)btCompoundCompoundCollisionAlgorithm::CreateFunc;
72
73 mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::SwappedCreateFunc),16);
74 m_swappedCompoundCreateFunc = new (mem)btCompoundCollisionAlgorithm::SwappedCreateFunc;
75 mem = btAlignedAlloc(sizeof(btEmptyAlgorithm::CreateFunc),16);
76 m_emptyCreateFunc = new(mem) btEmptyAlgorithm::CreateFunc;
77
78 mem = btAlignedAlloc(sizeof(btSphereSphereCollisionAlgorithm::CreateFunc),16);
79 m_sphereSphereCF = new(mem) btSphereSphereCollisionAlgorithm::CreateFunc;
80 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
81 mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc),16);
82 m_sphereBoxCF = new(mem) btSphereBoxCollisionAlgorithm::CreateFunc;
83 mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc),16);
84 m_boxSphereCF = new (mem)btSphereBoxCollisionAlgorithm::CreateFunc;
85 m_boxSphereCF->m_swapped = true;
86 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
87
88 mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc),16);
89 m_sphereTriangleCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
90 mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc),16);
91 m_triangleSphereCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
92 m_triangleSphereCF->m_swapped = true;
93
94 mem = btAlignedAlloc(sizeof(btBoxBoxCollisionAlgorithm::CreateFunc),16);
95 m_boxBoxCF = new(mem)btBoxBoxCollisionAlgorithm::CreateFunc;
96
97 //convex versus plane
98 mem = btAlignedAlloc (sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc),16);
99 m_convexPlaneCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc;
100 mem = btAlignedAlloc (sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc),16);
101 m_planeConvexCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc;
102 m_planeConvexCF->m_swapped = true;
103
105 int maxSize = sizeof(btConvexConvexAlgorithm);
106 int maxSize2 = sizeof(btConvexConcaveCollisionAlgorithm);
107 int maxSize3 = sizeof(btCompoundCollisionAlgorithm);
108 int maxSize4 = sizeof(btCompoundCompoundCollisionAlgorithm);
109
110 int collisionAlgorithmMaxElementSize = btMax(maxSize,constructionInfo.m_customCollisionAlgorithmMaxElementSize);
111 collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize2);
112 collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize3);
113 collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize4);
114
115 if (constructionInfo.m_persistentManifoldPool)
116 {
117 m_ownsPersistentManifoldPool = false;
118 m_persistentManifoldPool = constructionInfo.m_persistentManifoldPool;
119 } else
120 {
121 m_ownsPersistentManifoldPool = true;
122 void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
123 m_persistentManifoldPool = new (mem) btPoolAllocator(sizeof(btPersistentManifold),constructionInfo.m_defaultMaxPersistentManifoldPoolSize);
124 }
125
126 collisionAlgorithmMaxElementSize = (collisionAlgorithmMaxElementSize+16)&0xffffffffffff0;
127 if (constructionInfo.m_collisionAlgorithmPool)
128 {
129 m_ownsCollisionAlgorithmPool = false;
130 m_collisionAlgorithmPool = constructionInfo.m_collisionAlgorithmPool;
131 } else
132 {
133 m_ownsCollisionAlgorithmPool = true;
134 void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
135 m_collisionAlgorithmPool = new(mem) btPoolAllocator(collisionAlgorithmMaxElementSize,constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize);
136 }
137
138
139 }
140
141 btDefaultCollisionConfiguration::~btDefaultCollisionConfiguration()
142 {
143 if (m_ownsCollisionAlgorithmPool)
144 {
145 m_collisionAlgorithmPool->~btPoolAllocator();
146 btAlignedFree(m_collisionAlgorithmPool);
147 }
148 if (m_ownsPersistentManifoldPool)
149 {
150 m_persistentManifoldPool->~btPoolAllocator();
151 btAlignedFree(m_persistentManifoldPool);
152 }
153
154 m_convexConvexCreateFunc->~btCollisionAlgorithmCreateFunc();
155 btAlignedFree( m_convexConvexCreateFunc);
156
157 m_convexConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();
158 btAlignedFree( m_convexConcaveCreateFunc);
159 m_swappedConvexConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();
160 btAlignedFree( m_swappedConvexConcaveCreateFunc);
161
162 m_compoundCreateFunc->~btCollisionAlgorithmCreateFunc();
163 btAlignedFree( m_compoundCreateFunc);
164
165 m_compoundCompoundCreateFunc->~btCollisionAlgorithmCreateFunc();
166 btAlignedFree(m_compoundCompoundCreateFunc);
167
168 m_swappedCompoundCreateFunc->~btCollisionAlgorithmCreateFunc();
169 btAlignedFree( m_swappedCompoundCreateFunc);
170
171 m_emptyCreateFunc->~btCollisionAlgorithmCreateFunc();
172 btAlignedFree( m_emptyCreateFunc);
173
174 m_sphereSphereCF->~btCollisionAlgorithmCreateFunc();
175 btAlignedFree( m_sphereSphereCF);
176
177 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
178 m_sphereBoxCF->~btCollisionAlgorithmCreateFunc();
179 btAlignedFree( m_sphereBoxCF);
180 m_boxSphereCF->~btCollisionAlgorithmCreateFunc();
181 btAlignedFree( m_boxSphereCF);
182 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
183
184 m_sphereTriangleCF->~btCollisionAlgorithmCreateFunc();
185 btAlignedFree( m_sphereTriangleCF);
186 m_triangleSphereCF->~btCollisionAlgorithmCreateFunc();
187 btAlignedFree( m_triangleSphereCF);
188 m_boxBoxCF->~btCollisionAlgorithmCreateFunc();
189 btAlignedFree( m_boxBoxCF);
190
191 m_convexPlaneCF->~btCollisionAlgorithmCreateFunc();
192 btAlignedFree( m_convexPlaneCF);
193 m_planeConvexCF->~btCollisionAlgorithmCreateFunc();
194 btAlignedFree( m_planeConvexCF);
195
196 m_simplexSolver->~btVoronoiSimplexSolver();
197 btAlignedFree(m_simplexSolver);
198
199 m_pdSolver->~btConvexPenetrationDepthSolver();
200
201 btAlignedFree(m_pdSolver);
202
203
204 }
205
206
207 btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc(int proxyType0,int proxyType1)
208 {
209
210
211
212 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
213 {
214 return m_sphereSphereCF;
215 }
216 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
217 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1==BOX_SHAPE_PROXYTYPE))
218 {
219 return m_sphereBoxCF;
220 }
221
222 if ((proxyType0 == BOX_SHAPE_PROXYTYPE ) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
223 {
224 return m_boxSphereCF;
225 }
226 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
227
228
229 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE ) && (proxyType1==TRIANGLE_SHAPE_PROXYTYPE))
230 {
231 return m_sphereTriangleCF;
232 }
233
234 if ((proxyType0 == TRIANGLE_SHAPE_PROXYTYPE ) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
235 {
236 return m_triangleSphereCF;
237 }
238
239 if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE))
240 {
241 return m_boxBoxCF;
242 }
243
244 if (btBroadphaseProxy::isConvex(proxyType0) && (proxyType1 == STATIC_PLANE_PROXYTYPE))
245 {
246 return m_convexPlaneCF;
247 }
248
249 if (btBroadphaseProxy::isConvex(proxyType1) && (proxyType0 == STATIC_PLANE_PROXYTYPE))
250 {
251 return m_planeConvexCF;
252 }
253
254
255
256 if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConvex(proxyType1))
257 {
258 return m_convexConvexCreateFunc;
259 }
260
261 if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConcave(proxyType1))
262 {
263 return m_convexConcaveCreateFunc;
264 }
265
266 if (btBroadphaseProxy::isConvex(proxyType1) && btBroadphaseProxy::isConcave(proxyType0))
267 {
268 return m_swappedConvexConcaveCreateFunc;
269 }
270
271
272 if (btBroadphaseProxy::isCompound(proxyType0) && btBroadphaseProxy::isCompound(proxyType1))
273 {
274 return m_compoundCompoundCreateFunc;
275 }
276
277 if (btBroadphaseProxy::isCompound(proxyType0))
278 {
279 return m_compoundCreateFunc;
280 } else
281 {
282 if (btBroadphaseProxy::isCompound(proxyType1))
283 {
284 return m_swappedCompoundCreateFunc;
285 }
286 }
287
288 //failed to find an algorithm
289 return m_emptyCreateFunc;
290 }
291
292 void btDefaultCollisionConfiguration::setConvexConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
293 {
294 btConvexConvexAlgorithm::CreateFunc* convexConvex = (btConvexConvexAlgorithm::CreateFunc*) m_convexConvexCreateFunc;
295 convexConvex->m_numPerturbationIterations = numPerturbationIterations;
296 convexConvex->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
297 }
298
299 void btDefaultCollisionConfiguration::setPlaneConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
300 {
301 btConvexPlaneCollisionAlgorithm::CreateFunc* cpCF = (btConvexPlaneCollisionAlgorithm::CreateFunc*)m_convexPlaneCF;
302 cpCF->m_numPerturbationIterations = numPerturbationIterations;
303 cpCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
304
305 btConvexPlaneCollisionAlgorithm::CreateFunc* pcCF = (btConvexPlaneCollisionAlgorithm::CreateFunc*)m_planeConvexCF;
306 pcCF->m_numPerturbationIterations = numPerturbationIterations;
307 pcCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
308 }
btConvexConvexAlgorithm::CreateFunc
Definition: btConvexConvexAlgorithm.h:89
btMinkowskiPenetrationDepthSolver.h
btDefaultCollisionConfiguration::m_convexPlaneCF
btCollisionAlgorithmCreateFunc * m_convexPlaneCF
Definition: btDefaultCollisionConfiguration.h:84
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:54
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:40
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:292
btBoxBoxCollisionAlgorithm.h
btDefaultCollisionConfiguration::m_collisionAlgorithmPool
btPoolAllocator * m_collisionAlgorithmPool
Definition: btDefaultCollisionConfiguration.h:60
btDefaultCollisionConfiguration::m_pdSolver
btConvexPenetrationDepthSolver * m_pdSolver
Definition: btDefaultCollisionConfiguration.h:65
btConvexPlaneCollisionAlgorithm::CreateFunc::m_numPerturbationIterations
int m_numPerturbationIterations
Definition: btConvexPlaneCollisionAlgorithm.h:59
btSphereSphereCollisionAlgorithm.h
btBroadphaseProxy::isCompound
static bool isCompound(int proxyType)
Definition: btBroadphaseProxy.h:154
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:80
btDefaultCollisionConfiguration.h
btDefaultCollisionConfiguration::m_triangleSphereCF
btCollisionAlgorithmCreateFunc * m_triangleSphereCF
Definition: btDefaultCollisionConfiguration.h:82
btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1)
Definition: btDefaultCollisionConfiguration.cpp:207
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
btVoronoiSimplexSolver
btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points...
Definition: btVoronoiSimplexSolver.h:95
btDefaultCollisionConfiguration::m_swappedConvexConcaveCreateFunc
btCollisionAlgorithmCreateFunc * m_swappedConvexConcaveCreateFunc
Definition: btDefaultCollisionConfiguration.h:70
TRIANGLE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:32
btDefaultCollisionConfiguration::m_simplexSolver
btVoronoiSimplexSolver * m_simplexSolver
Definition: btDefaultCollisionConfiguration.h:64
btDefaultCollisionConfiguration::~btDefaultCollisionConfiguration
virtual ~btDefaultCollisionConfiguration()
Definition: btDefaultCollisionConfiguration.cpp:141
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::m_emptyCreateFunc
btCollisionAlgorithmCreateFunc * m_emptyCreateFunc
Definition: btDefaultCollisionConfiguration.h:75
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:299
btDefaultCollisionConfiguration::m_sphereTriangleCF
btCollisionAlgorithmCreateFunc * m_sphereTriangleCF
Definition: btDefaultCollisionConfiguration.h:81
btDefaultCollisionConfiguration::m_sphereSphereCF
btCollisionAlgorithmCreateFunc * m_sphereSphereCF
Definition: btDefaultCollisionConfiguration.h:76
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:83
btDefaultCollisionConfiguration::m_compoundCreateFunc
btCollisionAlgorithmCreateFunc * m_compoundCreateFunc
Definition: btDefaultCollisionConfiguration.h:71
btConvexConvexAlgorithm::CreateFunc::m_numPerturbationIterations
int m_numPerturbationIterations
Definition: btConvexConvexAlgorithm.h:94
btEmptyCollisionAlgorithm.h
btPoolAllocator
The btPoolAllocator class allows to efficiently allocate a large pool of objects, instead of dynamica...
Definition: btPoolAllocator.h:23
btCompoundCompoundCollisionAlgorithm::CreateFunc
Definition: btCompoundCompoundCollisionAlgorithm.h:69
btCompoundCollisionAlgorithm
btCompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision s...
Definition: btCompoundCollisionAlgorithm.h:38
btBroadphaseProxy::isConcave
static bool isConcave(int proxyType)
Definition: btBroadphaseProxy.h:149
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:78
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:72
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:47
btDefaultCollisionConfiguration::m_convexConcaveCreateFunc
btCollisionAlgorithmCreateFunc * m_convexConcaveCreateFunc
Definition: btDefaultCollisionConfiguration.h:69
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:95
btBroadphaseProxy::isConvex
static bool isConvex(int proxyType)
Definition: btBroadphaseProxy.h:139
btPoolAllocator::~btPoolAllocator
~btPoolAllocator()
Definition: btPoolAllocator.h:50
btDefaultCollisionConfiguration::m_sphereBoxCF
btCollisionAlgorithmCreateFunc * m_sphereBoxCF
Definition: btDefaultCollisionConfiguration.h:77
btCollisionAlgorithmCreateFunc::m_swapped
bool m_swapped
Definition: btCollisionCreateFunc.h:28
btDefaultCollisionConfiguration::m_convexConvexCreateFunc
btCollisionAlgorithmCreateFunc * m_convexConvexCreateFunc
Definition: btDefaultCollisionConfiguration.h:68
btGjkEpaPenetrationDepthSolver.h
btConvexConvexAlgorithm.h
STATIC_PLANE_PROXYTYPE
Definition: btBroadphaseProxy.h:67
btDefaultCollisionConfiguration::m_swappedCompoundCreateFunc
btCollisionAlgorithmCreateFunc * m_swappedCompoundCreateFunc
Definition: btDefaultCollisionConfiguration.h:74
btCollisionAlgorithmCreateFunc::~btCollisionAlgorithmCreateFunc
virtual ~btCollisionAlgorithmCreateFunc()
Definition: btCollisionCreateFunc.h:34
btCompoundCompoundCollisionAlgorithm.h