fixed some outstanding issues with Bullet soft bodies:
authorErwin Coumans <blender@erwincoumans.com>
Fri, 26 Sep 2008 23:20:31 +0000 (23:20 +0000)
committerErwin Coumans <blender@erwincoumans.com>
Fri, 26 Sep 2008 23:20:31 +0000 (23:20 +0000)
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

extern/bullet2/src/BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h
extern/bullet2/src/BulletSoftBody/btSoftBody.h
extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.cpp
extern/bullet2/src/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h
extern/bullet2/src/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.cpp
extern/bullet2/src/LinearMath/btPoolAllocator.h

index 4f5af5f048c88e50a5fb618827cc3d53e7340f69..df48ee95a18c3c8af89bfebeaeaad14c17964cca 100644 (file)
@@ -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;
 
index 7a6bfd53205cdbb33bd826d4e2d59c9203a60f80..b6d7c17b754e2dc57c94c081a350c26a6db5e24d 100644 (file)
@@ -609,6 +609,11 @@ public:
 
        btAlignedObjectArray<int>       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
index 3bcfe492107a2adb6b86fcc3728be6b250dc826e..9da765372d1b42063608d630b9529c1dcfb24743 100644 (file)
@@ -74,35 +74,23 @@ btSoftBodyTriangleCallback::~btSoftBodyTriangleCallback()
 
 void   btSoftBodyTriangleCallback::clearCache()
 {
-       //m_dispatcher->clearManifold(m_manifoldPtr);
+       for (int i=0;i<m_shapeCache.size();i++)
+       {
+               btTriIndex* tmp = m_shapeCache.getAtIndex(i);
+               btAssert(tmp);
+               btAssert(tmp->m_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<maxParts;i++)
-               {
-                       for (j=0;j<maxTriangleIndex;j++)
-                       {
-                               shapeCache[i][j]=0;
-                       }
-               }
-       }
-       //just for debugging purposes
+       //just for debugging purposes
        //printf("triangle %d",m_triangleCount++);
-btCollisionObject* ob = static_cast<btCollisionObject*>(m_triBody);
+       btCollisionObject* ob = static_cast<btCollisionObject*>(m_triBody);
        btCollisionAlgorithmConstructionInfo ci;
        ci.m_dispatcher1 = m_dispatcher;
 
@@ -114,18 +102,17 @@ btCollisionObject* ob = static_cast<btCollisionObject*>(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<btTriIndex> 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<btCollisionObject*>(m_triBody);
 
        //aabb filter is already applied!       
 
-
-       
-
-       
-
-
-
        //btCollisionObject* colObj = static_cast<btCollisionObject*>(m_convexProxy->m_clientObject);
        
 //     if (m_softBody->getCollisionShape()->getShapeType()==
@@ -194,10 +174,11 @@ btCollisionObject* ob = static_cast<btCollisionObject*>(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);
 
        }
 
index adb91329a4c4d7e3b7abea69b65117403165eb72..08ac3f11e2020dd5a0d11ea8c67dc144abfba9b1 100644 (file)
@@ -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<btHashKey<btTriIndex>,btTriIndex> m_shapeCache;
        
 public:
 int    m_triangleCount;
index e62f35567b098fe67d9fbaac97f501ff0239f47f..e79dd214e6200e911f6856237198bad16a79dc57 100644 (file)
@@ -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()
index e9620ac5faa385fb05fd76590573621f0a69c2c7..39d2559c74737a5e418c7cb866557c02070329b9 100644 (file)
@@ -91,6 +91,11 @@ public:
         }
        }
 
+       int     getElementSize() const
+       {
+               return m_elemSize;
+       }
+
 
 };