diff --git a/src/BulletCollision/CollisionDispatch/btCollisionConfiguration.h b/src/BulletCollision/CollisionDispatch/btCollisionConfiguration.h new file mode 100644 index 000000000..7471ecf93 --- /dev/null +++ b/src/BulletCollision/CollisionDispatch/btCollisionConfiguration.h @@ -0,0 +1,53 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/ + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +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. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_COLLISION_CONFIGURATION +#define BT_COLLISION_CONFIGURATION +///btCollisionConfiguration allows to configure Bullet collision detection +///stack allocator size, default collision algorithms and persistent manifold pool size +///todo: describe the meaning +class btCollisionConfiguration +{ + +public: + + virtual ~btCollisionConfiguration() + { + } + + ///pool size for the persistent contact manifold + virtual int getMaxPersistentManifoldPoolSize() = 0; + + virtual int getStackAllocatorSize() = 0; + + virtual int getCollisionAlgorithmPoolSize() = 0; + + virtual int getCollisionAlgorithmMaxElementSize() = 0; + + virtual btCollisionAlgorithmCreateFunc* getConvexConvexCollisionCreateFunc() = 0; + + virtual btCollisionAlgorithmCreateFunc* getConvexConcaveCollisionCreateFunc() = 0; + + virtual btCollisionAlgorithmCreateFunc* getSwappedConvexConcaveCollisionCreateFunc() = 0; + + virtual btCollisionAlgorithmCreateFunc* getCompoundCollisionCreateFunc() = 0; + + virtual btCollisionAlgorithmCreateFunc* getSwappedCompoundCollisionCreateFunc() = 0; + + virtual btCollisionAlgorithmCreateFunc* getEmptyCollisionCreateFunc() = 0; + +}; + +#endif //BT_COLLISION_CONFIGURATION \ No newline at end of file diff --git a/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp b/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp new file mode 100644 index 000000000..0805c31f7 --- /dev/null +++ b/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.cpp @@ -0,0 +1,112 @@ + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/ + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +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. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#include "btDefaultCollisionConfiguration.h" + +#include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h" +#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h" + +btDefaultCollisionConfiguration::btDefaultCollisionConfiguration() +:m_persistentManifoldPoolSize(16384), +m_stackAllocatorSize(2*1024*1024), +m_collisionAlgorithmPoolSize(16384), +m_collisionAlgorithmMaxElementSize(0) +{ + + //default CreationFunctions, filling the m_doubleDispatch table + m_convexConvexCreateFunc = new btConvexConvexAlgorithm::CreateFunc; + m_convexConcaveCreateFunc = new btConvexConcaveCollisionAlgorithm::CreateFunc; + m_swappedConvexConcaveCreateFunc = new btConvexConcaveCollisionAlgorithm::SwappedCreateFunc; + m_compoundCreateFunc = new btCompoundCollisionAlgorithm::CreateFunc; + m_swappedCompoundCreateFunc = new btCompoundCollisionAlgorithm::SwappedCreateFunc; + m_emptyCreateFunc = new btEmptyAlgorithm::CreateFunc; + + ///calculate maximum element size, big enough to fit any collision algorithm in the memory pool + int maxSize = sizeof(btConvexConvexAlgorithm); + int maxSize2 = sizeof(btConvexConcaveCollisionAlgorithm); + int maxSize3 = sizeof(btCompoundCollisionAlgorithm); + int maxSize4 = sizeof(btEmptyAlgorithm); + + m_collisionAlgorithmMaxElementSize = btMax(maxSize,maxSize2); + m_collisionAlgorithmMaxElementSize = btMax(elemSize,maxSize3); + m_collisionAlgorithmMaxElementSize = btMax(elemSize,maxSize4); + +} + +btDefaultCollisionConfiguration::~btDefaultCollisionConfiguration() +{ + delete m_convexConvexCreateFunc; + delete m_convexConcaveCreateFunc; + delete m_swappedConvexConcaveCreateFunc; + delete m_compoundCreateFunc; + delete m_swappedCompoundCreateFunc; + delete m_emptyCreateFunc; + +} + + ///pool size for the persistent contact manifold +int btDefaultCollisionConfiguration::getPersistentManifoldPoolSize() +{ + return m_persistentManifoldPoolSize; +} + +int btDefaultCollisionConfiguration::getStackAllocatorSize() +{ + return m_stackAllocatorSize; +} + +int btDefaultCollisionConfiguration::getCollisionAlgorithmPoolSize() +{ + return m_collisionAlgorithmPoolSize; +} + +int btDefaultCollisionConfiguration::getCollisionAlgorithmMaxElementSize() +{ + return m_collisionAlgorithmMaxElementSize; + +} + +btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getConvexConvexCollisionCreateFunc() +{ + return m_convexConvexCreateFunc; +} + +btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getConvexConcaveCollisionCreateFunc() +{ + return m_convexConcaveCreateFunc; +} + +btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getSwappedConvexConcaveCollisionCreateFunc() +{ + return m_swappedConvexConcaveCreateFunc; +} + +btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getCompoundCollisionCreateFunc() +{ + return m_compoundCreateFunc; +} + +btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getSwappedCompoundCollisionCreateFunc() +{ + return m_swappedCompoundCreateFunc; +} + +btCollisionAlgorithmCreateFunc* btDefaultCollisionConfiguration::getEmptyCollisionCreateFunc() +{ + return m_emptyCreateFunc; +} diff --git a/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h b/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h new file mode 100644 index 000000000..2377140d0 --- /dev/null +++ b/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h @@ -0,0 +1,72 @@ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/ + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +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. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef BT_DEFAULT_COLLISION_CONFIGURATION +#define BT_DEFAULT_COLLISION_CONFIGURATION + +#include "btCollisionConfiguration.h" + +///btCollisionConfiguration allows to configure Bullet collision detection +///stack allocator size, default collision algorithms and persistent manifold pool size +///todo: describe the meaning +class btDefaultCollisionConfiguration +{ + + int m_persistentManifoldPoolSize; + + int m_stackAllocatorSize; + + int collisionAlgorithmPoolSize; + + int collisionAlgorithmMaxElementSize; + + //default CreationFunctions, filling the m_doubleDispatch table + btCollisionAlgorithmCreateFunc* m_convexConvexCreateFunc; + btCollisionAlgorithmCreateFunc* m_convexConcaveCreateFunc; + btCollisionAlgorithmCreateFunc* m_swappedConvexConcaveCreateFunc; + btCollisionAlgorithmCreateFunc* m_compoundCreateFunc; + btCollisionAlgorithmCreateFunc* m_swappedCompoundCreateFunc; + btCollisionAlgorithmCreateFunc* m_emptyCreateFunc; + +public: + + btDefaultCollisionConfiguration(); + + virtual ~btDefaultCollisionConfiguration(); + + ///pool size for the persistent contact manifold + virtual int getPersistentManifoldPoolSize(); + + virtual int getStackAllocatorSize(); + + virtual int getCollisionAlgorithmPoolSize(); + + virtual int getCollisionAlgorithmMaxElementSize(); + + virtual btCollisionAlgorithmCreateFunc* getConvexConvexCollisionCreateFunc(); + + virtual btCollisionAlgorithmCreateFunc* getConvexConcaveCollisionCreateFunc(); + + virtual btCollisionAlgorithmCreateFunc* getSwappedConvexConcaveCollisionCreateFunc(); + + virtual btCollisionAlgorithmCreateFunc* getCompoundCollisionCreateFunc(); + + virtual btCollisionAlgorithmCreateFunc* getSwappedCompoundCollisionCreateFunc(); + + virtual btCollisionAlgorithmCreateFunc* getEmptyCollisionCreateFunc(); + +}; + +#endif //BT_DEFAULT_COLLISION_CONFIGURATION \ No newline at end of file