Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Preparation for serialization of btTriangleInfoMap

Browse Source 
Add flags to disable bvh and triangleinfomap serialization

btSerializer::setSerializationFlags(flags)
flag can have value BT_SERIALIZE_NO_BVH, BT_SERIALIZE_NO_TRIANGLEINFOMAP
This commit is contained in:
erwin.coumans
2010-02-24 02:49:41 +00:00
parent e156967762
commit f5fabd2676
7 changed files with 188 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Extras/Serialize/BulletFileLoader/btBulletFile.cpp
View File

@@ -167,6 +167,11 @@ void btBulletFile::parseData()
m_bvhs.push_back((bStructHandle*) id);
}
if (dataChunk.code == BT_TRIANLGE_INFO_MAP)
{
m_triangleInfoMaps.push_back((bStructHandle*) id);
}
if (dataChunk.code == BT_COLLISIONOBJECT_CODE)
{
m_collisionObjects.push_back((bStructHandle*) id);

4
Extras/Serialize/BulletFileLoader/btBulletFile.h
View File

@@ -26,7 +26,7 @@ subject to the following restrictions:
#define BT_CONSTRAINT_CODE MAKE_ID('C','O','N','S')
#define BT_BOXSHAPE_CODE MAKE_ID('B','O','X','S')
#define BT_QUANTIZED_BVH_CODE MAKE_ID('Q','B','V','H')
#define BT_TRIANLGE_INFO_MAP MAKE_ID('T','M','A','P')
#define BT_SHAPE_CODE MAKE_ID('S','H','A','P')
@@ -53,6 +53,8 @@ namespace bParse {
btAlignedObjectArray<bStructHandle*> m_bvhs;
btAlignedObjectArray<bStructHandle*> m_triangleInfoMaps;
btBulletFile();
btBulletFile(const char* fileName);

3
Extras/Serialize/makesdna/makesdna.cpp
View File

@@ -133,6 +133,7 @@ typedef unsigned long uintptr_t;
#include "BulletCollision/CollisionShapes/btCompoundShape.h"
#include "BulletCollision/CollisionShapes/btCylinderShape.h"
#include "BulletCollision/CollisionShapes/btCapsuleShape.h"
#include "BulletCollision/CollisionShapes/btTriangleInfoMap.h"
#include "BulletCollision/Gimpact/btGImpactShape.h"
#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h"
@@ -171,6 +172,7 @@ char *includefiles[] = {
"../../../src/BulletCollision/CollisionShapes/btCompoundShape.h",
"../../../src/BulletCollision/CollisionShapes/btCylinderShape.h",
"../../../src/BulletCollision/CollisionShapes/btCapsuleShape.h",
"../../../src/BulletCollision/CollisionShapes/btTriangleInfoMap.h",
"../../../src/BulletCollision/Gimpact/btGImpactShape.h",
"../../../src/BulletCollision/CollisionShapes/btConvexHullShape.h",
"../../../src/BulletCollision/CollisionDispatch/btCollisionObject.h",
@@ -561,6 +563,7 @@ const char* skipStructTypes[]=
"Euler",
"btConstraintInfo2",
"btConstraintSetting",
"btTriangleInfo",
""
};

25
src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
View File

@@ -379,7 +379,9 @@ const char* btBvhTriangleMeshShape::serialize(void* dataBuffer, btSerializer* se
trimeshData->m_collisionMargin = float(m_collisionMargin);
if (m_bvh)
if (m_bvh && !(serializer->getSerializationFlags()&BT_SERIALIZE_NO_BVH))
{
void* chunk = serializer->findPointer(m_bvh);
if (chunk)
@@ -413,6 +415,27 @@ const char* btBvhTriangleMeshShape::serialize(void* dataBuffer, btSerializer* se
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*)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";
}

132
src/BulletCollision/CollisionShapes/btTriangleInfoMap.h
View File

@@ -78,6 +78,8 @@ struct btTriangleInfoMap : public btInternalTriangleInfoMap
///fills the dataBuffer and returns the struct name (and 0 on failure)
virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
void deSerialize(struct btTriangleInfoMapData& data);
};
struct btTriangleInfoData
@@ -90,22 +92,22 @@ struct btTriangleInfoData
struct btTriangleInfoMapData
{
int *m_hashTablePtr;
int *m_nextPtr;
btTriangleInfoData *m_valueArrayPtr;
int *m_keyArrayPtr;
float m_convexEpsilon;
float m_planarEpsilon;
float m_equalVertexThreshold;
float m_edgeDistanceThreshold;
float m_zeroAreaThreshold;
int m_hashTableSize;
int *m_hashTablePtr;
int m_nextSize;
int *m_nextPtr;
int m_hashTableSize;
int m_numValues;
btTriangleInfoData *m_valueArrayPtr;
int m_numKeys;
int *m_keyArrayPtr;
char m_padding[4];
};
SIMD_FORCE_INLINE int btTriangleInfoMap::calculateSerializeBufferSize() const
@@ -113,11 +115,121 @@ SIMD_FORCE_INLINE int btTriangleInfoMap::calculateSerializeBufferSize() const
return sizeof(btTriangleInfoMapData);
}
///fills the dataBuffer and returns the struct name (and 0 on failure)
///fills the dataBuffer and returns the struct name (and 0 on failure)
SIMD_FORCE_INLINE const char* btTriangleInfoMap::serialize(void* dataBuffer, btSerializer* serializer) const
{
///todo
return 0;
btTriangleInfoMapData* tmapData = (btTriangleInfoMapData*) dataBuffer;
tmapData->m_convexEpsilon = m_convexEpsilon;
tmapData->m_planarEpsilon = m_planarEpsilon;
tmapData->m_equalVertexThreshold = m_equalVertexThreshold;
tmapData->m_edgeDistanceThreshold = m_edgeDistanceThreshold;
tmapData->m_zeroAreaThreshold = m_zeroAreaThreshold;
tmapData->m_hashTableSize = m_hashTable.size();
tmapData->m_hashTablePtr = tmapData->m_hashTableSize ? (int*)&m_hashTable[0] : 0;
if (tmapData->m_hashTablePtr)
{
//serialize an int buffer
int sz = sizeof(int);
int numElem = tmapData->m_hashTableSize;
btChunk* chunk = serializer->allocate(sz,numElem);
int* memPtr = (int*)chunk->m_oldPtr;
for (int i=0;i<numElem;i++,memPtr++)
{
*memPtr = m_hashTable[i];
}
serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*)&m_hashTable[0]);
}
tmapData->m_nextSize = m_next.size();
tmapData->m_nextPtr = tmapData->m_nextSize? (int*)&m_next[0]: 0;
if (tmapData->m_nextPtr)
{
int sz = sizeof(int);
int numElem = tmapData->m_nextSize;
btChunk* chunk = serializer->allocate(sz,numElem);
int* memPtr = (int*)chunk->m_oldPtr;
for (int i=0;i<numElem;i++,memPtr++)
{
*memPtr = m_next[i];
}
serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*)&m_next[0]);
}
tmapData->m_numValues = m_valueArray.size();
tmapData->m_valueArrayPtr = tmapData->m_numValues ? (btTriangleInfoData*)&m_valueArray[0]: 0;
if (tmapData->m_valueArrayPtr)
{
int sz = sizeof(btTriangleInfoData);
int numElem = tmapData->m_numValues;
btChunk* chunk = serializer->allocate(sz,numElem);
btTriangleInfoData* memPtr = (btTriangleInfoData*)chunk->m_oldPtr;
for (int i=0;i<numElem;i++,memPtr++)
{
memPtr->m_edgeV0V1Angle = m_valueArray[i].m_edgeV0V1Angle;
memPtr->m_edgeV1V2Angle = m_valueArray[i].m_edgeV1V2Angle;
memPtr->m_edgeV2V0Angle = m_valueArray[i].m_edgeV2V0Angle;
memPtr->m_flags = m_valueArray[i].m_flags;
}
serializer->finalizeChunk(chunk,"btTriangleInfoData",BT_ARRAY_CODE,(void*) &m_valueArray[0]);
}
tmapData->m_numKeys = m_keyArray.size();
tmapData->m_keyArrayPtr = tmapData->m_numKeys ? (int*)&m_keyArray[0] : 0;
if (tmapData->m_keyArrayPtr)
{
int sz = sizeof(int);
int numElem = tmapData->m_numValues;
btChunk* chunk = serializer->allocate(sz,numElem);
int* memPtr = (int*)chunk->m_oldPtr;
for (int i=0;i<numElem;i++,memPtr++)
{
*memPtr = m_keyArray[i].getUid1();
}
serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*) &m_keyArray[0]);
}
return "btTriangleInfoMapData";
}
///fills the dataBuffer and returns the struct name (and 0 on failure)
SIMD_FORCE_INLINE void btTriangleInfoMap::deSerialize(btTriangleInfoMapData& tmapData )
{
m_convexEpsilon = tmapData.m_convexEpsilon;
m_planarEpsilon = tmapData.m_planarEpsilon;
m_equalVertexThreshold = tmapData.m_equalVertexThreshold;
m_edgeDistanceThreshold = tmapData.m_edgeDistanceThreshold;
m_zeroAreaThreshold = tmapData.m_zeroAreaThreshold;
m_hashTable.resize(tmapData.m_hashTableSize);
int i =0;
for (i=0;i<tmapData.m_hashTableSize;i++)
{
m_hashTable[i] = tmapData.m_hashTablePtr[i];
}
m_next.resize(tmapData.m_nextSize);
for (i=0;i<tmapData.m_nextSize;i++)
{
m_next[i] = tmapData.m_nextPtr[i];
}
m_valueArray.resize(tmapData.m_numValues);
for (i=0;i<tmapData.m_numValues;i++)
{
m_valueArray[i].m_edgeV0V1Angle = tmapData.m_valueArrayPtr[i].m_edgeV0V1Angle;
m_valueArray[i].m_edgeV1V2Angle = tmapData.m_valueArrayPtr[i].m_edgeV1V2Angle;
m_valueArray[i].m_edgeV2V0Angle = tmapData.m_valueArrayPtr[i].m_edgeV2V0Angle;
m_valueArray[i].m_flags = tmapData.m_valueArrayPtr[i].m_flags;
}
m_keyArray.resize(tmapData.m_numKeys,btHashInt(0));
for (i=0;i<tmapData.m_numKeys;i++)
{
m_keyArray[i].setUid1(tmapData.m_keyArrayPtr[i]);
}
}

5
src/LinearMath/btHashMap.h
View File

@@ -72,6 +72,11 @@ public:
return m_uid;
}
void setUid1(int uid)
{
m_uid = uid;
}
bool equals(const btHashInt& other) const
{
return getUid1() == other.getUid1();

27
src/LinearMath/btSerializer.h
View File

@@ -59,6 +59,12 @@ public:
int m_number;
};
enum btSerializationFlags
{
BT_SERIALIZE_NO_BVH = 1,
BT_SERIALIZE_NO_TRIANGLEINFOMAP = 2
};
class btSerializer
{
@@ -86,6 +92,10 @@ public:
virtual void serializeName(const char* ptr) = 0;
virtual int getSerializationFlags() const = 0;
virtual void setSerializationFlags(int flags) = 0;
};
@@ -102,6 +112,7 @@ public:
#define BT_CONSTRAINT_CODE MAKE_ID('C','O','N','S')
#define BT_BOXSHAPE_CODE MAKE_ID('B','O','X','S')
#define BT_QUANTIZED_BVH_CODE MAKE_ID('Q','B','V','H')
#define BT_TRIANLGE_INFO_MAP MAKE_ID('T','M','A','P')
#define BT_SHAPE_CODE MAKE_ID('S','H','A','P')
#define BT_ARRAY_CODE MAKE_ID('A','R','A','Y')
@@ -129,6 +140,8 @@ class btDefaultSerializer : public btSerializer
void* m_dna;
int m_dnaLength;
int m_serializationFlags;
btAlignedObjectArray<btChunk*> m_chunkPtrs;
@@ -343,7 +356,8 @@ public:
:m_totalSize(totalSize),
m_currentSize(0),
m_dna(0),
m_dnaLength(0)
m_dnaLength(0),
m_serializationFlags(0)
{
m_buffer = (unsigned char*)btAlignedAlloc(totalSize, 16);
@@ -527,6 +541,17 @@ public:
}
}
}
virtual int getSerializationFlags() const
{
return m_serializationFlags;
}
virtual void setSerializationFlags(int flags)
{
m_serializationFlags = flags;
}
};