Changeset 8284 for code/branches/kicklib2/src/external/bullet/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp

Timestamp:

Apr 21, 2011, 6:58:23 PM (14 years ago)

Author:

rgrieder

Message:

Merged revisions 7978 - 8096 from kicklib to kicklib2.

Location:

code/branches/kicklib2

Files:

• . (modified) (1 prop)
• src/external/bullet/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp (modified) (7 diffs)

code/branches/kicklib2/src/external/bullet/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp

@@ -1 +1 @@
 /*
 Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
 
 This software is provided 'as-is', without any express or implied warranty.
@@ -18 +18 @@
 #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
 #include "BulletCollision/CollisionShapes/btOptimizedBvh.h"
+#include "LinearMath/btSerializer.h"
 
 ///Bvh Concave triangle mesh is a static-triangle mesh shape with Bounding Volume Hierarchy optimization.
@@ -24 +25 @@
 :btTriangleMeshShape(meshInterface),
 m_bvh(0),
+m_triangleInfoMap(0),
 m_useQuantizedAabbCompression(useQuantizedAabbCompression),
 m_ownsBvh(false)
@@ -31 +33 @@
 #ifndef DISABLE_BVH
 
-        btVector3 bvhAabbMin,bvhAabbMax;
-        if(meshInterface->hasPremadeAabb())
-        {
-                meshInterface->getPremadeAabb(&bvhAabbMin, &bvhAabbMax);
-        }
-        else
-        {
-                meshInterface->calculateAabbBruteForce(bvhAabbMin,bvhAabbMax);
-        }
-        
         if (buildBvh)
         {
-                void* mem = btAlignedAlloc(sizeof(btOptimizedBvh),16);
-                m_bvh = new (mem) btOptimizedBvh();
-                m_bvh->build(meshInterface,m_useQuantizedAabbCompression,bvhAabbMin,bvhAabbMax);
-                m_ownsBvh = true;
+                buildOptimizedBvh();
         }
 
@@ -56 +45 @@
 :btTriangleMeshShape(meshInterface),
 m_bvh(0),
+m_triangleInfoMap(0),
 m_useQuantizedAabbCompression(useQuantizedAabbCompression),
 m_ownsBvh(false)
@@ -344 +334 @@
    {
       btTriangleMeshShape::setLocalScaling(scaling);
-      if (m_ownsBvh)
-      {
-         m_bvh->~btOptimizedBvh();
-         btAlignedFree(m_bvh);
-      }
-      ///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work
-      void* mem = btAlignedAlloc(sizeof(btOptimizedBvh),16);
-      m_bvh = new(mem) btOptimizedBvh();
-      //rebuild the bvh...
-      m_bvh->build(m_meshInterface,m_useQuantizedAabbCompression,m_localAabbMin,m_localAabbMax);
-      m_ownsBvh = true;
+          buildOptimizedBvh();
    }
+}
+
+void   btBvhTriangleMeshShape::buildOptimizedBvh()
+{
+        if (m_ownsBvh)
+        {
+                m_bvh->~btOptimizedBvh();
+                btAlignedFree(m_bvh);
+        }
+        ///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work
+        void* mem = btAlignedAlloc(sizeof(btOptimizedBvh),16);
+        m_bvh = new(mem) btOptimizedBvh();
+        //rebuild the bvh...
+        m_bvh->build(m_meshInterface,m_useQuantizedAabbCompression,m_localAabbMin,m_localAabbMax);
+        m_ownsBvh = true;
 }
 
@@ -373 +368 @@
 
 
+
+///fills the dataBuffer and returns the struct name (and 0 on failure)
+const char*     btBvhTriangleMeshShape::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+        btTriangleMeshShapeData* trimeshData = (btTriangleMeshShapeData*) dataBuffer;
+
+        btCollisionShape::serialize(&trimeshData->m_collisionShapeData,serializer);
+
+        m_meshInterface->serialize(&trimeshData->m_meshInterface, serializer);
+
+        trimeshData->m_collisionMargin = float(m_collisionMargin);
+
+        
+
+        if (m_bvh && !(serializer->getSerializationFlags()&BT_SERIALIZE_NO_BVH))
+        {
+                void* chunk = serializer->findPointer(m_bvh);
+                if (chunk)
+                {
+#ifdef BT_USE_DOUBLE_PRECISION
+                        trimeshData->m_quantizedDoubleBvh = (btQuantizedBvhData*)chunk;
+                        trimeshData->m_quantizedFloatBvh = 0;
+#else
+                        trimeshData->m_quantizedFloatBvh  = (btQuantizedBvhData*)chunk;
+                        trimeshData->m_quantizedDoubleBvh= 0;
+#endif //BT_USE_DOUBLE_PRECISION
+                } else
+                {
+
+#ifdef BT_USE_DOUBLE_PRECISION
+                        trimeshData->m_quantizedDoubleBvh = (btQuantizedBvhData*)serializer->getUniquePointer(m_bvh);
+                        trimeshData->m_quantizedFloatBvh = 0;
+#else
+                        trimeshData->m_quantizedFloatBvh  = (btQuantizedBvhData*)serializer->getUniquePointer(m_bvh);
+                        trimeshData->m_quantizedDoubleBvh= 0;
+#endif //BT_USE_DOUBLE_PRECISION
+        
+                        int sz = m_bvh->calculateSerializeBufferSizeNew();
+                        btChunk* chunk = serializer->allocate(sz,1);
+                        const char* structType = m_bvh->serialize(chunk->m_oldPtr, serializer);
+                        serializer->finalizeChunk(chunk,structType,BT_QUANTIZED_BVH_CODE,m_bvh);
+                }
+        } else
+        {
+                trimeshData->m_quantizedFloatBvh = 0;
+                trimeshData->m_quantizedDoubleBvh = 0;
+        }
+
+        
+
+        if (m_triangleInfoMap && !(serializer->getSerializationFlags()&BT_SERIALIZE_NO_TRIANGLEINFOMAP))
+        {
+                void* chunk = serializer->findPointer(m_triangleInfoMap);
+                if (chunk)
+                {
+                        trimeshData->m_triangleInfoMap = (btTriangleInfoMapData*)chunk;
+                } else
+                {
+                        trimeshData->m_triangleInfoMap = (btTriangleInfoMapData*)serializer->getUniquePointer(m_triangleInfoMap);
+                        int sz = m_triangleInfoMap->calculateSerializeBufferSize();
+                        btChunk* chunk = serializer->allocate(sz,1);
+                        const char* structType = m_triangleInfoMap->serialize(chunk->m_oldPtr, serializer);
+                        serializer->finalizeChunk(chunk,structType,BT_TRIANLGE_INFO_MAP,m_triangleInfoMap);
+                }
+        } else
+        {
+                trimeshData->m_triangleInfoMap = 0;
+        }
+
+        return "btTriangleMeshShapeData";
+}
+
+void    btBvhTriangleMeshShape::serializeSingleBvh(btSerializer* serializer) const
+{
+        if (m_bvh)
+        {
+                int len = m_bvh->calculateSerializeBufferSizeNew(); //make sure not to use calculateSerializeBufferSize because it is used for in-place
+                btChunk* chunk = serializer->allocate(len,1);
+                const char* structType = m_bvh->serialize(chunk->m_oldPtr, serializer);
+                serializer->finalizeChunk(chunk,structType,BT_QUANTIZED_BVH_CODE,(void*)m_bvh);
+        }
+}
+
+void    btBvhTriangleMeshShape::serializeSingleTriangleInfoMap(btSerializer* serializer) const
+{
+        if (m_triangleInfoMap)
+        {
+                int len = m_triangleInfoMap->calculateSerializeBufferSize();
+                btChunk* chunk = serializer->allocate(len,1);
+                const char* structType = m_triangleInfoMap->serialize(chunk->m_oldPtr, serializer);
+                serializer->finalizeChunk(chunk,structType,BT_TRIANLGE_INFO_MAP,(void*)m_triangleInfoMap);
+        }
+}
+
+
+
+