Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 #include "btDefaultCollisionConfiguration.h"
00017
00018 #include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h"
00019 #include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h"
00020 #include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h"
00021 #include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h"
00022 #include "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h"
00023 #include "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h"
00024 #include "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h"
00025 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
00026 #include "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h"
00027 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
00028 #include "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h"
00029 #include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"
00030 #include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h"
00031 #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
00032
00033
00034
00035 #include "LinearMath/btStackAlloc.h"
00036 #include "LinearMath/btPoolAllocator.h"
00037
00038
00039
00040
00041
00042 btDefaultCollisionConfiguration::btDefaultCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo)
00043
00044 {
00045
00046 void* mem = btAlignedAlloc(sizeof(btVoronoiSimplexSolver),16);
00047 m_simplexSolver = new (mem)btVoronoiSimplexSolver();
00048
00049 if (constructionInfo.m_useEpaPenetrationAlgorithm)
00050 {
00051 mem = btAlignedAlloc(sizeof(btGjkEpaPenetrationDepthSolver),16);
00052 m_pdSolver = new (mem)btGjkEpaPenetrationDepthSolver;
00053 }else
00054 {
00055 mem = btAlignedAlloc(sizeof(btMinkowskiPenetrationDepthSolver),16);
00056 m_pdSolver = new (mem)btMinkowskiPenetrationDepthSolver;
00057 }
00058
00059
00060 mem = btAlignedAlloc(sizeof(btConvexConvexAlgorithm::CreateFunc),16);
00061 m_convexConvexCreateFunc = new(mem) btConvexConvexAlgorithm::CreateFunc(m_simplexSolver,m_pdSolver);
00062 mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc),16);
00063 m_convexConcaveCreateFunc = new (mem)btConvexConcaveCollisionAlgorithm::CreateFunc;
00064 mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc),16);
00065 m_swappedConvexConcaveCreateFunc = new (mem)btConvexConcaveCollisionAlgorithm::SwappedCreateFunc;
00066 mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::CreateFunc),16);
00067 m_compoundCreateFunc = new (mem)btCompoundCollisionAlgorithm::CreateFunc;
00068 mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::SwappedCreateFunc),16);
00069 m_swappedCompoundCreateFunc = new (mem)btCompoundCollisionAlgorithm::SwappedCreateFunc;
00070 mem = btAlignedAlloc(sizeof(btEmptyAlgorithm::CreateFunc),16);
00071 m_emptyCreateFunc = new(mem) btEmptyAlgorithm::CreateFunc;
00072
00073 mem = btAlignedAlloc(sizeof(btSphereSphereCollisionAlgorithm::CreateFunc),16);
00074 m_sphereSphereCF = new(mem) btSphereSphereCollisionAlgorithm::CreateFunc;
00075 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
00076 mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc),16);
00077 m_sphereBoxCF = new(mem) btSphereBoxCollisionAlgorithm::CreateFunc;
00078 mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc),16);
00079 m_boxSphereCF = new (mem)btSphereBoxCollisionAlgorithm::CreateFunc;
00080 m_boxSphereCF->m_swapped = true;
00081 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
00082
00083 mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc),16);
00084 m_sphereTriangleCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
00085 mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc),16);
00086 m_triangleSphereCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
00087 m_triangleSphereCF->m_swapped = true;
00088
00089 mem = btAlignedAlloc(sizeof(btBoxBoxCollisionAlgorithm::CreateFunc),16);
00090 m_boxBoxCF = new(mem)btBoxBoxCollisionAlgorithm::CreateFunc;
00091
00092
00093 mem = btAlignedAlloc (sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc),16);
00094 m_convexPlaneCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc;
00095 mem = btAlignedAlloc (sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc),16);
00096 m_planeConvexCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc;
00097 m_planeConvexCF->m_swapped = true;
00098
00100 int maxSize = sizeof(btConvexConvexAlgorithm);
00101 int maxSize2 = sizeof(btConvexConcaveCollisionAlgorithm);
00102 int maxSize3 = sizeof(btCompoundCollisionAlgorithm);
00103 int sl = sizeof(btConvexSeparatingDistanceUtil);
00104 sl = sizeof(btGjkPairDetector);
00105 int collisionAlgorithmMaxElementSize = btMax(maxSize,constructionInfo.m_customCollisionAlgorithmMaxElementSize);
00106 collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize2);
00107 collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize3);
00108
00109 if (constructionInfo.m_stackAlloc)
00110 {
00111 m_ownsStackAllocator = false;
00112 this->m_stackAlloc = constructionInfo.m_stackAlloc;
00113 } else
00114 {
00115 m_ownsStackAllocator = true;
00116 void* mem = btAlignedAlloc(sizeof(btStackAlloc),16);
00117 m_stackAlloc = new(mem)btStackAlloc(constructionInfo.m_defaultStackAllocatorSize);
00118 }
00119
00120 if (constructionInfo.m_persistentManifoldPool)
00121 {
00122 m_ownsPersistentManifoldPool = false;
00123 m_persistentManifoldPool = constructionInfo.m_persistentManifoldPool;
00124 } else
00125 {
00126 m_ownsPersistentManifoldPool = true;
00127 void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
00128 m_persistentManifoldPool = new (mem) btPoolAllocator(sizeof(btPersistentManifold),constructionInfo.m_defaultMaxPersistentManifoldPoolSize);
00129 }
00130
00131 if (constructionInfo.m_collisionAlgorithmPool)
00132 {
00133 m_ownsCollisionAlgorithmPool = false;
00134 m_collisionAlgorithmPool = constructionInfo.m_collisionAlgorithmPool;
00135 } else
00136 {
00137 m_ownsCollisionAlgorithmPool = true;
00138 void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
00139 m_collisionAlgorithmPool = new(mem) btPoolAllocator(collisionAlgorithmMaxElementSize,constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize);
00140 }
00141
00142
00143 }
00144
00145 btDefaultCollisionConfiguration::~btDefaultCollisionConfiguration()
00146 {
00147 if (m_ownsStackAllocator)
00148 {
00149 m_stackAlloc->destroy();
00150 m_stackAlloc->~btStackAlloc();
00151 btAlignedFree(m_stackAlloc);
00152 }
00153 if (m_ownsCollisionAlgorithmPool)
00154 {
00155 m_collisionAlgorithmPool->~btPoolAllocator();
00156 btAlignedFree(m_collisionAlgorithmPool);
00157 }
00158 if (m_ownsPersistentManifoldPool)
00159 {
00160 m_persistentManifoldPool->~btPoolAllocator();
00161 btAlignedFree(m_persistentManifoldPool);
00162 }
00163
00164 m_convexConvexCreateFunc->~btCollisionAlgorithmCreateFunc();
00165 btAlignedFree( m_convexConvexCreateFunc);
00166
00167 m_convexConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();
00168 btAlignedFree( m_convexConcaveCreateFunc);
00169 m_swappedConvexConcaveCreateFunc->~btCollisionAlgorithmCreateFunc();
00170 btAlignedFree( m_swappedConvexConcaveCreateFunc);
00171
00172 m_compoundCreateFunc->~btCollisionAlgorithmCreateFunc();
00173 btAlignedFree( m_compoundCreateFunc);
00174
00175 m_swappedCompoundCreateFunc->~btCollisionAlgorithmCreateFunc();
00176 btAlignedFree( m_swappedCompoundCreateFunc);
00177
00178 m_emptyCreateFunc->~btCollisionAlgorithmCreateFunc();
00179 btAlignedFree( m_emptyCreateFunc);
00180
00181 m_sphereSphereCF->~btCollisionAlgorithmCreateFunc();
00182 btAlignedFree( m_sphereSphereCF);
00183
00184 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
00185 m_sphereBoxCF->~btCollisionAlgorithmCreateFunc();
00186 btAlignedFree( m_sphereBoxCF);
00187 m_boxSphereCF->~btCollisionAlgorithmCreateFunc();
00188 btAlignedFree( m_boxSphereCF);
00189 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
00190
00191 m_sphereTriangleCF->~btCollisionAlgorithmCreateFunc();
00192 btAlignedFree( m_sphereTriangleCF);
00193 m_triangleSphereCF->~btCollisionAlgorithmCreateFunc();
00194 btAlignedFree( m_triangleSphereCF);
00195 m_boxBoxCF->~btCollisionAlgorithmCreateFunc();
00196 btAlignedFree( m_boxBoxCF);
00197
00198 m_convexPlaneCF->~btCollisionAlgorithmCreateFunc();
00199 btAlignedFree( m_convexPlaneCF);
00200 m_planeConvexCF->~btCollisionAlgorithmCreateFunc();
00201 btAlignedFree( m_planeConvexCF);
00202
00203 m_simplexSolver->~btVoronoiSimplexSolver();
00204 btAlignedFree(m_simplexSolver);
00205
00206 m_pdSolver->~btConvexPenetrationDepthSolver();
00207
00208 btAlignedFree(m_pdSolver);
00209
00210
00211 }
00212
00213
00214 btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getCollisionAlgorithmCreateFunc(int proxyType0,int proxyType1)
00215 {
00216
00217
00218
00219 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
00220 {
00221 return m_sphereSphereCF;
00222 }
00223 #ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
00224 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE) && (proxyType1==BOX_SHAPE_PROXYTYPE))
00225 {
00226 return m_sphereBoxCF;
00227 }
00228
00229 if ((proxyType0 == BOX_SHAPE_PROXYTYPE ) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
00230 {
00231 return m_boxSphereCF;
00232 }
00233 #endif //USE_BUGGY_SPHERE_BOX_ALGORITHM
00234
00235
00236 if ((proxyType0 == SPHERE_SHAPE_PROXYTYPE ) && (proxyType1==TRIANGLE_SHAPE_PROXYTYPE))
00237 {
00238 return m_sphereTriangleCF;
00239 }
00240
00241 if ((proxyType0 == TRIANGLE_SHAPE_PROXYTYPE ) && (proxyType1==SPHERE_SHAPE_PROXYTYPE))
00242 {
00243 return m_triangleSphereCF;
00244 }
00245
00246 if ((proxyType0 == BOX_SHAPE_PROXYTYPE) && (proxyType1 == BOX_SHAPE_PROXYTYPE))
00247 {
00248 return m_boxBoxCF;
00249 }
00250
00251 if (btBroadphaseProxy::isConvex(proxyType0) && (proxyType1 == STATIC_PLANE_PROXYTYPE))
00252 {
00253 return m_convexPlaneCF;
00254 }
00255
00256 if (btBroadphaseProxy::isConvex(proxyType1) && (proxyType0 == STATIC_PLANE_PROXYTYPE))
00257 {
00258 return m_planeConvexCF;
00259 }
00260
00261
00262
00263 if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConvex(proxyType1))
00264 {
00265 return m_convexConvexCreateFunc;
00266 }
00267
00268 if (btBroadphaseProxy::isConvex(proxyType0) && btBroadphaseProxy::isConcave(proxyType1))
00269 {
00270 return m_convexConcaveCreateFunc;
00271 }
00272
00273 if (btBroadphaseProxy::isConvex(proxyType1) && btBroadphaseProxy::isConcave(proxyType0))
00274 {
00275 return m_swappedConvexConcaveCreateFunc;
00276 }
00277
00278 if (btBroadphaseProxy::isCompound(proxyType0))
00279 {
00280 return m_compoundCreateFunc;
00281 } else
00282 {
00283 if (btBroadphaseProxy::isCompound(proxyType1))
00284 {
00285 return m_swappedCompoundCreateFunc;
00286 }
00287 }
00288
00289
00290 return m_emptyCreateFunc;
00291 }
00292
00293 void btDefaultCollisionConfiguration::setConvexConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
00294 {
00295 btConvexConvexAlgorithm::CreateFunc* convexConvex = (btConvexConvexAlgorithm::CreateFunc*) m_convexConvexCreateFunc;
00296 convexConvex->m_numPerturbationIterations = numPerturbationIterations;
00297 convexConvex->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
00298 }
00299
00300 void btDefaultCollisionConfiguration::setPlaneConvexMultipointIterations(int numPerturbationIterations, int minimumPointsPerturbationThreshold)
00301 {
00302 btConvexPlaneCollisionAlgorithm::CreateFunc* cpCF = (btConvexPlaneCollisionAlgorithm::CreateFunc*)m_convexPlaneCF;
00303 cpCF->m_numPerturbationIterations = numPerturbationIterations;
00304 cpCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
00305
00306 btConvexPlaneCollisionAlgorithm::CreateFunc* pcCF = (btConvexPlaneCollisionAlgorithm::CreateFunc*)m_planeConvexCF;
00307 pcCF->m_numPerturbationIterations = numPerturbationIterations;
00308 pcCF->m_minimumPointsPerturbationThreshold = minimumPointsPerturbationThreshold;
00309 }