From 1e0cfcfd3af917a12402f955e6c80ea1b4999321 Mon Sep 17 00:00:00 2001 From: Erwin Coumans Date: Fri, 26 Sep 2008 23:20:31 +0000 Subject: fixed some outstanding issues with Bullet soft bodies: 1) re-allocate a pool allocator, if one of the soft body collision algorithms is larger than max pool element size 2) manage child shapes properly, and call RemoveReferences on the m_sparsesdf --- .../btDefaultCollisionConfiguration.h | 3 + extern/bullet2/src/BulletSoftBody/btSoftBody.h | 5 ++ .../btSoftBodyConcaveCollisionAlgorithm.cpp | 65 ++++++++-------------- .../btSoftBodyConcaveCollisionAlgorithm.h | 35 ++++++++++++ .../btSoftBodyRigidBodyCollisionConfiguration.cpp | 27 +++++++++ extern/bullet2/src/LinearMath/btPoolAllocator.h | 5 ++ 6 files changed, 98 insertions(+), 42 deletions(-) (limited to 'extern/bullet2') diff --git a/extern/bullet2/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h b/extern/bullet2/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h index 4f5af5f048c..df48ee95a18 100644 --- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h +++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h @@ -48,6 +48,8 @@ struct btDefaultCollisionConstructionInfo class btDefaultCollisionConfiguration : public btCollisionConfiguration { +protected: + int m_persistentManifoldPoolSize; btStackAlloc* m_stackAlloc; @@ -56,6 +58,7 @@ class btDefaultCollisionConfiguration : public btCollisionConfiguration btPoolAllocator* m_persistentManifoldPool; bool m_ownsPersistentManifoldPool; + btPoolAllocator* m_collisionAlgorithmPool; bool m_ownsCollisionAlgorithmPool; diff --git a/extern/bullet2/src/BulletSoftBody/btSoftBody.h b/extern/bullet2/src/BulletSoftBody/btSoftBody.h index 7a6bfd53205..b6d7c17b754 100644 --- a/extern/bullet2/src/BulletSoftBody/btSoftBody.h +++ b/extern/bullet2/src/BulletSoftBody/btSoftBody.h @@ -609,6 +609,11 @@ public: btAlignedObjectArray m_userIndexMapping; + btSoftBodyWorldInfo* getWorldInfo() + { + return m_worldInfo; + } + virtual void setCollisionShape(btCollisionShape* collisionShape) { //don't do anything, due to the internal shape hack: todo: fix this diff --git a/extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.cpp b/extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.cpp index 3bcfe492107..9da765372d1 100644 --- a/extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.cpp +++ b/extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.cpp @@ -74,35 +74,23 @@ btSoftBodyTriangleCallback::~btSoftBodyTriangleCallback() void btSoftBodyTriangleCallback::clearCache() { - //m_dispatcher->clearManifold(m_manifoldPtr); + for (int i=0;im_childShape); + m_softBody->getWorldInfo()->m_sparsesdf.RemoveReferences(tmp->m_childShape);//necessary? + delete tmp->m_childShape; + } + m_shapeCache.clear(); }; -static const int maxParts = 1; -static const int maxTriangleIndex = 100*100; - -btCollisionShape* shapeCache[maxParts][maxTriangleIndex]; - - void btSoftBodyTriangleCallback::processTriangle(btVector3* triangle,int partId, int triangleIndex) { - static bool hackedFirst = true; - if (hackedFirst) - { - hackedFirst = false; - int i,j; - for (i=0;i(m_triBody); + btCollisionObject* ob = static_cast(m_triBody); btCollisionAlgorithmConstructionInfo ci; ci.m_dispatcher1 = m_dispatcher; @@ -114,18 +102,17 @@ btCollisionObject* ob = static_cast(m_triBody); m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(triangle[1]),color); m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(triangle[2]),color); m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color); - - //btVector3 center = triangle[0] + triangle[1]+triangle[2]; - //center *= btScalar(0.333333); - //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(center),color); - //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(center),color); - //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(center),color); - } - if (shapeCache[partId][triangleIndex]) + btTriIndex triIndex(partId,triangleIndex,0); + btHashKey triKey(triIndex.getUid()); + + + btTriIndex* shapeIndex = m_shapeCache[triKey]; + if (shapeIndex) { - btCollisionShape* tm = shapeCache[partId][triangleIndex]; + btCollisionShape* tm = shapeIndex->m_childShape; + btAssert(tm); //copy over user pointers to temporary shape tm->setUserPointer(ob->getRootCollisionShape()->getUserPointer()); @@ -145,13 +132,6 @@ btCollisionObject* ob = static_cast(m_triBody); //aabb filter is already applied! - - - - - - - //btCollisionObject* colObj = static_cast(m_convexProxy->m_clientObject); // if (m_softBody->getCollisionShape()->getShapeType()== @@ -194,10 +174,11 @@ btCollisionObject* ob = static_cast(m_triBody); colAlgo->processCollision(m_softBody,m_triBody,*m_dispatchInfoPtr,m_resultOut); colAlgo->~btCollisionAlgorithm(); ci.m_dispatcher1->freeCollisionAlgorithm(colAlgo); + + ob->internalSetTemporaryCollisionShape( tmpShape ); -// delete tm; - - shapeCache[partId][triangleIndex] = tm; + triIndex.m_childShape = tm; + m_shapeCache.insert(triKey,triIndex); } diff --git a/extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h b/extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h index adb91329a4c..08ac3f11e20 100644 --- a/extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h +++ b/extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h @@ -25,6 +25,39 @@ class btDispatcher; #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" class btSoftBody; +class btCollisionShape; + +#include "LinearMath/btHashMap.h" + +#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" //for definition of MAX_NUM_PARTS_IN_BITS + +struct btTriIndex +{ + int m_PartIdTriangleIndex; + class btCollisionShape* m_childShape; + + btTriIndex(int partId,int triangleIndex,btCollisionShape* shape) + { + m_PartIdTriangleIndex = (partId<<(31-MAX_NUM_PARTS_IN_BITS)) | triangleIndex; + m_childShape = shape; + } + + int getTriangleIndex() const + { + // Get only the lower bits where the triangle index is stored + return (m_PartIdTriangleIndex&~((~0)<<(31-MAX_NUM_PARTS_IN_BITS))); + } + int getPartId() const + { + // Get only the highest bits where the part index is stored + return (m_PartIdTriangleIndex>>(31-MAX_NUM_PARTS_IN_BITS)); + } + int getUid() const + { + return m_PartIdTriangleIndex; + } +}; + ///For each triangle in the concave mesh that overlaps with the AABB of a soft body (m_softBody), processTriangle is called. class btSoftBodyTriangleCallback : public btTriangleCallback @@ -40,6 +73,8 @@ class btSoftBodyTriangleCallback : public btTriangleCallback btDispatcher* m_dispatcher; const btDispatcherInfo* m_dispatchInfoPtr; btScalar m_collisionMarginTriangle; + + btHashMap,btTriIndex> m_shapeCache; public: int m_triangleCount; diff --git a/extern/bullet2/src/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp b/extern/bullet2/src/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp index e62f35567b0..e79dd214e62 100644 --- a/extern/bullet2/src/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp +++ b/extern/bullet2/src/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp @@ -18,6 +18,8 @@ subject to the following restrictions: #include "btSoftBodyConcaveCollisionAlgorithm.h" #include "btSoftSoftCollisionAlgorithm.h" +#include "LinearMath/btPoolAllocator.h" + #define ENABLE_SOFTBODY_CONCAVE_COLLISIONS 1 btSoftBodyRigidBodyCollisionConfiguration::btSoftBodyRigidBodyCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo) @@ -44,6 +46,31 @@ btSoftBodyRigidBodyCollisionConfiguration::btSoftBodyRigidBodyCollisionConfigura m_swappedSoftRigidConcaveCreateFunc->m_swapped=true; #endif + //replace pool by a new one, with potential larger size + + if (m_ownsCollisionAlgorithmPool && m_collisionAlgorithmPool) + { + int curElemSize = m_collisionAlgorithmPool->getElementSize(); + ///calculate maximum element size, big enough to fit any collision algorithm in the memory pool + + + int maxSize0 = sizeof(btSoftSoftCollisionAlgorithm); + int maxSize1 = sizeof(btSoftRigidCollisionAlgorithm); + int maxSize2 = sizeof(btSoftBodyConcaveCollisionAlgorithm); + + int collisionAlgorithmMaxElementSize = btMax(maxSize0,maxSize1); + collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize2); + if (collisionAlgorithmMaxElementSize > curElemSize) + { + btAlignedFree(m_collisionAlgorithmPool); + void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16); + m_collisionAlgorithmPool = new(mem) btPoolAllocator(collisionAlgorithmMaxElementSize,constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize); + } + } + + + + } btSoftBodyRigidBodyCollisionConfiguration::~btSoftBodyRigidBodyCollisionConfiguration() diff --git a/extern/bullet2/src/LinearMath/btPoolAllocator.h b/extern/bullet2/src/LinearMath/btPoolAllocator.h index e9620ac5faa..39d2559c747 100644 --- a/extern/bullet2/src/LinearMath/btPoolAllocator.h +++ b/extern/bullet2/src/LinearMath/btPoolAllocator.h @@ -91,6 +91,11 @@ public: } } + int getElementSize() const + { + return m_elemSize; + } + }; -- cgit v1.2.3