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 
17 
23 
27 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
29 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
34 
36 
38 //btDefaultCollisionConfiguration::btDefaultCollisionConfiguration(btStackAlloc* stackAlloc,btPoolAllocator* persistentManifoldPool,btPoolAllocator* collisionAlgorithmPool)
39 {
40  void* mem = NULL;
41  if (constructionInfo.m_useEpaPenetrationAlgorithm)
42  {
45  }
46  else
47  {
50  }
51 
52  //default CreationFunctions, filling the m_doubleDispatch table
61 
64 
69 
72 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
77  m_boxSphereCF->m_swapped = true;
78 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
79 
85 
88 
89  //convex versus plane
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  {
111  }
112  else
113  {
115  void* mem = btAlignedAlloc(sizeof(btPoolAllocator), 16);
117  }
118 
119  collisionAlgorithmMaxElementSize = (collisionAlgorithmMaxElementSize + 16) & 0xffffffffffff0;
120  if (constructionInfo.m_collisionAlgorithmPool)
121  {
124  }
125  else
126  {
128  void* mem = btAlignedAlloc(sizeof(btPoolAllocator), 16);
129  m_collisionAlgorithmPool = new (mem) btPoolAllocator(collisionAlgorithmMaxElementSize, constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize);
130  }
131 }
132 
134 {
136  {
139  }
141  {
144  }
145 
148 
153 
156 
159 
162 
165 
168 
169 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
174 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
175 
182 
187 
189 
191 }
192 
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  {
234  }
235 
236  if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConcave(proxyType1))
237  {
239  }
240 
241  if (btBroadphaseProxy::isConvex(proxyType1) && btBroadphaseProxy::isConcave(proxyType0))
242  {
244  }
245 
246  if (btBroadphaseProxy::isCompound(proxyType0) && btBroadphaseProxy::isCompound(proxyType1))
247  {
249  }
250 
251  if (btBroadphaseProxy::isCompound(proxyType0))
252  {
253  return m_compoundCreateFunc;
254  }
255  else
256  {
257  if (btBroadphaseProxy::isCompound(proxyType1))
258  {
260  }
261  }
262 
263  //failed to find an algorithm
264  return m_emptyCreateFunc;
265 }
266 
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  {
313  }
314 
315  if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConcave(proxyType1))
316  {
318  }
319 
320  if (btBroadphaseProxy::isConvex(proxyType1) && btBroadphaseProxy::isConcave(proxyType0))
321  {
323  }
324 
325  if (btBroadphaseProxy::isCompound(proxyType0) && btBroadphaseProxy::isCompound(proxyType1))
326  {
328  }
329 
330  if (btBroadphaseProxy::isCompound(proxyType0))
331  {
332  return m_compoundCreateFunc;
333  }
334  else
335  {
336  if (btBroadphaseProxy::isCompound(proxyType1))
337  {
339  }
340  }
341 
342  //failed to find an algorithm
343  return m_emptyCreateFunc;
344 }
345 
346 void btDefaultCollisionConfiguration::setConvexConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
347 {
349  convexConvex->m_numPerturbationIterations = numPerturbationIterations;
350  convexConvex->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
351 }
352 
353 void btDefaultCollisionConfiguration::setPlaneConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
354 {
356  cpCF->m_numPerturbationIterations = numPerturbationIterations;
357  cpCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
358 
360  pcCF->m_numPerturbationIterations = numPerturbationIterations;
361  pcCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
362 }
btDefaultCollisionConfiguration::m_planeConvexCF
btCollisionAlgorithmCreateFunc * m_planeConvexCF
Definition: btDefaultCollisionConfiguration.h:76
btCollisionAlgorithmCreateFunc::m_swapped
bool m_swapped
Definition: btCollisionCreateFunc.h:28
btSphereSphereCollisionAlgorithm::CreateFunc
Definition: btSphereSphereCollisionAlgorithm.h:54
btCollisionAlgorithmCreateFunc::~btCollisionAlgorithmCreateFunc
virtual ~btCollisionAlgorithmCreateFunc()
Definition: btCollisionCreateFunc.h:34
btConvexConvexAlgorithm::CreateFunc::m_numPerturbationIterations
int m_numPerturbationIterations
Definition: btConvexConvexAlgorithm.h:86
btDefaultCollisionConfiguration::m_boxBoxCF
btCollisionAlgorithmCreateFunc * m_boxBoxCF
Definition: btDefaultCollisionConfiguration.h:73
btDefaultCollisionConfiguration::m_swappedCompoundCreateFunc
btCollisionAlgorithmCreateFunc * m_swappedCompoundCreateFunc
Definition: btDefaultCollisionConfiguration.h:67
btEmptyCollisionAlgorithm.h
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:47
btSphereTriangleCollisionAlgorithm::CreateFunc
Definition: btSphereTriangleCollisionAlgorithm.h:54
btCompoundCollisionAlgorithm.h
btGjkEpaPenetrationDepthSolver.h
btBroadphaseProxy::isCompound
static bool isCompound(int proxyType)
Definition: btBroadphaseProxy.h:150
btDefaultCollisionConfiguration::m_sphereBoxCF
btCollisionAlgorithmCreateFunc * m_sphereBoxCF
Definition: btDefaultCollisionConfiguration.h:70
btDefaultCollisionConstructionInfo::m_defaultMaxCollisionAlgorithmPoolSize
int m_defaultMaxCollisionAlgorithmPoolSize
Definition: btDefaultCollisionConfiguration.h:28
btSphereSphereCollisionAlgorithm.h
btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1)
Definition: btDefaultCollisionConfiguration.cpp:267
btDefaultCollisionConstructionInfo::m_collisionAlgorithmPool
btPoolAllocator * m_collisionAlgorithmPool
Definition: btDefaultCollisionConfiguration.h:26
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:46
btConvexConcaveCollisionAlgorithm::CreateFunc
Definition: btConvexConcaveCollisionAlgorithm.h:98
btConvexConvexAlgorithm
Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation.
Definition: btConvexConvexAlgorithm.h:41
btDefaultCollisionConfiguration::m_convexConcaveCreateFunc
btCollisionAlgorithmCreateFunc * m_convexConcaveCreateFunc
Definition: btDefaultCollisionConfiguration.h:62
btDefaultCollisionConfiguration::m_ownsPersistentManifoldPool
bool m_ownsPersistentManifoldPool
Definition: btDefaultCollisionConfiguration.h:52
btBroadphaseProxy::isConvex
static bool isConvex(int proxyType)
Definition: btBroadphaseProxy.h:135
btDefaultCollisionConfiguration::m_compoundCompoundCreateFunc
btCollisionAlgorithmCreateFunc * m_compoundCompoundCreateFunc
Definition: btDefaultCollisionConfiguration.h:65
btGjkEpaPenetrationDepthSolver
EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to calculate the penetration depth be...
Definition: btGjkEpaPenetrationDepthSolver.h:24
btMax
const T & btMax(const T &a, const T &b)
Definition: btMinMax.h:27
btPoolAllocator::~btPoolAllocator
~btPoolAllocator()
Definition: btPoolAllocator.h:51
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_swappedConvexConcaveCreateFunc
btCollisionAlgorithmCreateFunc * m_swappedConvexConcaveCreateFunc
Definition: btDefaultCollisionConfiguration.h:63
btSphereTriangleCollisionAlgorithm.h
btCollisionAlgorithmCreateFunc
Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm.
Definition: btCollisionCreateFunc.h:26
TRIANGLE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:31
btBroadphaseProxy::isConcave
static bool isConcave(int proxyType)
Definition: btBroadphaseProxy.h:145
btEmptyAlgorithm::CreateFunc
Definition: btEmptyCollisionAlgorithm.h:39
btCompoundCompoundCollisionAlgorithm
btCompoundCompoundCollisionAlgorithm supports collision between two btCompoundCollisionShape shapes
Definition: btCompoundCompoundCollisionAlgorithm.h:40
btConvexPlaneCollisionAlgorithm::CreateFunc::m_minimumPointsPerturbationThreshold
int m_minimumPointsPerturbationThreshold
Definition: btConvexPlaneCollisionAlgorithm.h:59
btDefaultCollisionConstructionInfo::m_customCollisionAlgorithmMaxElementSize
int m_customCollisionAlgorithmMaxElementSize
Definition: btDefaultCollisionConfiguration.h:29
btDefaultCollisionConfiguration::m_sphereSphereCF
btCollisionAlgorithmCreateFunc * m_sphereSphereCF
Definition: btDefaultCollisionConfiguration.h:69
btDefaultCollisionConfiguration::m_persistentManifoldPool
btPoolAllocator * m_persistentManifoldPool
Definition: btDefaultCollisionConfiguration.h:51
btCompoundCollisionAlgorithm::SwappedCreateFunc
Definition: btCompoundCollisionAlgorithm.h:89
btDefaultCollisionConfiguration::m_triangleSphereCF
btCollisionAlgorithmCreateFunc * m_triangleSphereCF
Definition: btDefaultCollisionConfiguration.h:75
btDefaultCollisionConfiguration::m_emptyCreateFunc
btCollisionAlgorithmCreateFunc * m_emptyCreateFunc
Definition: btDefaultCollisionConfiguration.h:68
btBoxBoxCollisionAlgorithm::CreateFunc
Definition: btBoxBoxCollisionAlgorithm.h:52
btDefaultCollisionConfiguration::getClosestPointsAlgorithmCreateFunc
virtual btCollisionAlgorithmCreateFunc * getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1)
Definition: btDefaultCollisionConfiguration.cpp:193
btConvexConcaveCollisionAlgorithm
btConvexConcaveCollisionAlgorithm supports collision between convex shapes and (concave) trianges mes...
Definition: btConvexConcaveCollisionAlgorithm.h:76
btVoronoiSimplexSolver.h
btConvexPlaneCollisionAlgorithm::CreateFunc
Definition: btConvexPlaneCollisionAlgorithm.h:56
BOX_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:30
btDefaultCollisionConfiguration::m_boxSphereCF
btCollisionAlgorithmCreateFunc * m_boxSphereCF
Definition: btDefaultCollisionConfiguration.h:71
btSphereBoxCollisionAlgorithm.h
btDefaultCollisionConfiguration::m_ownsCollisionAlgorithmPool
bool m_ownsCollisionAlgorithmPool
Definition: btDefaultCollisionConfiguration.h:55
btDefaultCollisionConfiguration.h
btPersistentManifold
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
Definition: btPersistentManifold.h:63
btConvexPlaneCollisionAlgorithm::CreateFunc::m_numPerturbationIterations
int m_numPerturbationIterations
Definition: btConvexPlaneCollisionAlgorithm.h:58
btDefaultCollisionConfiguration::m_convexPlaneCF
btCollisionAlgorithmCreateFunc * m_convexPlaneCF
Definition: btDefaultCollisionConfiguration.h:77
btMinkowskiPenetrationDepthSolver.h
btMinkowskiPenetrationDepthSolver
MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation.
Definition: btMinkowskiPenetrationDepthSolver.h:23
btCompoundCompoundCollisionAlgorithm::CreateFunc
Definition: btCompoundCompoundCollisionAlgorithm.h:63
btCompoundCollisionAlgorithm
btCompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision s...
Definition: btCompoundCollisionAlgorithm.h:38
btConvexConcaveCollisionAlgorithm::SwappedCreateFunc
Definition: btConvexConcaveCollisionAlgorithm.h:107
btDefaultCollisionConfiguration::~btDefaultCollisionConfiguration
virtual ~btDefaultCollisionConfiguration()
Definition: btDefaultCollisionConfiguration.cpp:133
SPHERE_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:39
btConvexConvexAlgorithm::CreateFunc
Definition: btConvexConvexAlgorithm.h:83
btDefaultCollisionConfiguration::m_collisionAlgorithmPool
btPoolAllocator * m_collisionAlgorithmPool
Definition: btDefaultCollisionConfiguration.h:54
btDefaultCollisionConfiguration::m_pdSolver
btConvexPenetrationDepthSolver * m_pdSolver
Definition: btDefaultCollisionConfiguration.h:58
btConvexConvexAlgorithm::CreateFunc::m_minimumPointsPerturbationThreshold
int m_minimumPointsPerturbationThreshold
Definition: btConvexConvexAlgorithm.h:87
btDefaultCollisionConfiguration::m_convexConvexCreateFunc
btCollisionAlgorithmCreateFunc * m_convexConvexCreateFunc
Definition: btDefaultCollisionConfiguration.h:61
btCompoundCollisionAlgorithm::CreateFunc
Definition: btCompoundCollisionAlgorithm.h:80
btDefaultCollisionConstructionInfo::m_useEpaPenetrationAlgorithm
int m_useEpaPenetrationAlgorithm
Definition: btDefaultCollisionConfiguration.h:30
btSphereBoxCollisionAlgorithm::CreateFunc
Definition: btSphereBoxCollisionAlgorithm.h:56
btConvexConcaveCollisionAlgorithm.h
btConvexPlaneCollisionAlgorithm.h
btDefaultCollisionConfiguration::setPlaneConvexMultipointIterations
void setPlaneConvexMultipointIterations(int numPerturbationIterations=3, int minimumPointsPerturbationThreshold=3)
Definition: btDefaultCollisionConfiguration.cpp:353
btCompoundCompoundCollisionAlgorithm.h
btPoolAllocator
The btPoolAllocator class allows to efficiently allocate a large pool of objects, instead of dynamica...
Definition: btPoolAllocator.h:23
btBoxBoxCollisionAlgorithm.h
btDefaultCollisionConfiguration::m_compoundCreateFunc
btCollisionAlgorithmCreateFunc * m_compoundCreateFunc
Definition: btDefaultCollisionConfiguration.h:64
btDefaultCollisionConfiguration::btDefaultCollisionConfiguration
btDefaultCollisionConfiguration(const btDefaultCollisionConstructionInfo &constructionInfo=btDefaultCollisionConstructionInfo())
Definition: btDefaultCollisionConfiguration.cpp:37
btDefaultCollisionConstructionInfo::m_defaultMaxPersistentManifoldPoolSize
int m_defaultMaxPersistentManifoldPoolSize
Definition: btDefaultCollisionConfiguration.h:27
STATIC_PLANE_PROXYTYPE
Definition: btBroadphaseProxy.h:66
btPoolAllocator.h
btConvexConvexAlgorithm.h
btDefaultCollisionConfiguration::m_sphereTriangleCF
btCollisionAlgorithmCreateFunc * m_sphereTriangleCF
Definition: btDefaultCollisionConfiguration.h:74
btConvexPenetrationDepthSolver::~btConvexPenetrationDepthSolver
virtual ~btConvexPenetrationDepthSolver()
Definition: btConvexPenetrationDepthSolver.h:28
btDefaultCollisionConstructionInfo::m_persistentManifoldPool
btPoolAllocator * m_persistentManifoldPool
Definition: btDefaultCollisionConfiguration.h:25
btDefaultCollisionConstructionInfo
Definition: btDefaultCollisionConfiguration.h:23