16#ifndef BT_SERIALIZER_H
17#define BT_SERIALIZER_H
22#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
109#define BT_HEADER_LENGTH 12
110#if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
111# define BT_MAKE_ID(a,b,c,d) ( (int)(a)<<24 | (int)(b)<<16 | (c)<<8 | (d) )
113# define BT_MAKE_ID(a,b,c,d) ( (int)(d)<<24 | (int)(c)<<16 | (b)<<8 | (a) )
117#define BT_MULTIBODY_CODE BT_MAKE_ID('M','B','D','Y')
118#define BT_SOFTBODY_CODE BT_MAKE_ID('S','B','D','Y')
119#define BT_COLLISIONOBJECT_CODE BT_MAKE_ID('C','O','B','J')
120#define BT_RIGIDBODY_CODE BT_MAKE_ID('R','B','D','Y')
121#define BT_CONSTRAINT_CODE BT_MAKE_ID('C','O','N','S')
122#define BT_BOXSHAPE_CODE BT_MAKE_ID('B','O','X','S')
123#define BT_QUANTIZED_BVH_CODE BT_MAKE_ID('Q','B','V','H')
124#define BT_TRIANLGE_INFO_MAP BT_MAKE_ID('T','M','A','P')
125#define BT_SHAPE_CODE BT_MAKE_ID('S','H','A','P')
126#define BT_ARRAY_CODE BT_MAKE_ID('A','R','A','Y')
127#define BT_SBMATERIAL_CODE BT_MAKE_ID('S','B','M','T')
128#define BT_SBNODE_CODE BT_MAKE_ID('S','B','N','D')
129#define BT_DYNAMICSWORLD_CODE BT_MAKE_ID('D','W','L','D')
130#define BT_DNA_CODE BT_MAKE_ID('D','N','A','1')
239 littleEndian= ((
char*)&littleEndian)[0];
243 memcpy(
m_dna,bdnaOrg,dnalen);
248 char *cp = 0;
int dataLen =0;
249 intPtr = (
int*)
m_dna;
259 if (strncmp((
const char*)
m_dna,
"SDNA", 4)==0)
275 for ( i=0; i<dataLen; i++)
291 btAssert(strncmp(cp,
"TYPE", 4)==0); intPtr++;
301 for (i=0; i<dataLen; i++)
319 btAssert(strncmp(cp,
"TLEN", 4)==0); intPtr++;
321 dataLen = (int)
mTypes.size();
323 shtPtr = (
short*)intPtr;
324 for (i=0; i<dataLen; i++, shtPtr++)
328 mTlens.push_back(shtPtr[0]);
331 if (dataLen & 1) shtPtr++;
344 intPtr = (
int*)shtPtr;
346 btAssert(strncmp(cp,
"STRC", 4)==0); intPtr++;
354 shtPtr = (
short*)intPtr;
355 for (i=0; i<dataLen; i++)
367 for (
int a=0; a<len; a++, shtPtr+=2)
375 shtPtr+= (2*shtPtr[1])+2;
380 for (i=0; i<(int)
mStructs.size(); i++)
411 const bool VOID_IS_8 = ((
sizeof(
void*)==8));
413#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
452 const bool VOID_IS_8 = ((
sizeof(
void*) == 8));
462 const bool VOID_IS_8 = ((
sizeof(
void*) == 8));
480#ifdef BT_USE_DOUBLE_PRECISION
481 memcpy(buffer,
"BULLETd", 7);
483 memcpy(buffer,
"BULLETf", 7);
487 littleEndian= ((
char*)&littleEndian)[0];
489 if (
sizeof(
void*)==8)
537 unsigned char* currentPtr =
m_buffer;
546 currentPtr+=curLength;
622 unsigned char* ptr = 0;
644 unsigned char* data = ptr +
sizeof(
btChunk);
648 chunk->m_oldPtr = data;
649 chunk->m_length = int(
size)*numElements;
650 chunk->m_number = numElements;
660 const char*
const * namePtr =
m_nameMap.find(ptr);
661 if (namePtr && *namePtr)
685 int padding = ((newLen+3)&~3)-newLen;
690 char* destinationName = (
char*)chunk->
m_oldPtr;
691 for (
int i=0;i<len;i++)
693 destinationName[i] = name[i];
695 destinationName[len] = 0;
727#ifdef ENABLE_INMEMORY_SERIALIZER
738 btInMemorySerializer(
int totalSize=0,
unsigned char* buffer=0)
746 m_uid2ChunkPtr.
clear();
753 btChunk* findChunkFromUniquePointer(
void* uniquePointer)
755 btChunk** chkPtr = m_uid2ChunkPtr[uniquePointer];
766 m_names2Ptr.
insert(name,ptr);
779 btChunk* chunk = findChunkFromUniquePointer(oldPtr);
785 const char* n = (
const char*) oldPtr;
786 const void** ptr = m_names2Ptr[n];
792 void** ptr2 = m_skipPointers[oldPtr];
819 m_chunkP.insert(oldPtr,oldPtr);
823 m_uid2ChunkPtr.
insert(uid,chunk);
829 #ifdef BT_USE_DOUBLE_PRECISION
838 #ifdef BT_USE_DOUBLE_PRECISION
847 #ifdef BT_USE_DOUBLE_PRECISION
856 #ifdef BT_USE_DOUBLE_PRECISION
865 #ifdef BT_USE_DOUBLE_PRECISION
896 return m_uid2ChunkPtr.
size();
901 return *m_uid2ChunkPtr.
getAtIndex(chunkIndex);
#define btAlignedFree(ptr)
#define btAlignedAlloc(size, alignment)
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
#define SIMD_FORCE_INLINE
unsigned btSwapEndian(unsigned val)
T * btAlignPointer(T *unalignedPtr, size_t alignment)
align a pointer to the provided alignment, upwards
@ BT_SERIALIZE_NO_DUPLICATE_ASSERT
@ BT_SERIALIZE_NO_TRIANGLEINFOMAP
#define BT_SBMATERIAL_CODE
#define BT_COLLISIONOBJECT_CODE
#define BT_TRIANLGE_INFO_MAP
#define BT_QUANTIZED_BVH_CODE
#define BT_RIGIDBODY_CODE
int btStrLen(const char *str)
#define BT_DYNAMICSWORLD_CODE
#define BT_CONSTRAINT_CODE
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
The btDefaultSerializer is the main Bullet serialization class.
void initDNA(const char *bdnaOrg, int dnalen)
virtual const char * findNameForPointer(const void *ptr) const
virtual void setSerializationFlags(int flags)
btAlignedObjectArray< char * > mTypes
static const char * getMemoryDna()
virtual ~btDefaultSerializer()
btHashMap< btHashPtr, btPointerUid > m_uniquePointers
virtual void * getUniquePointer(void *oldPtr)
virtual unsigned char * internalAlloc(size_t size)
btAlignedObjectArray< btChunk * > m_chunkPtrs
virtual void * findPointer(void *oldPtr)
virtual void serializeName(const char *name)
virtual void startSerialization()
int getReverseType(const char *type) const
btAlignedObjectArray< short > mTlens
virtual int getSerializationFlags() const
const btChunk * getChunk(int chunkIndex) const
virtual void registerNameForPointer(const void *ptr, const char *name)
btHashMap< btHashPtr, void * > m_chunkP
virtual int getCurrentBufferSize() const
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)
btHashMap< btHashInt, int > mStructReverse
virtual void finishSerialization()
btDefaultSerializer(int totalSize=0, unsigned char *buffer=0)
void writeHeader(unsigned char *buffer) const
btHashMap< btHashString, int > mTypeLookup
btHashMap< btHashPtr, void * > m_skipPointers
btHashMap< btHashPtr, const char * > m_nameMap
static int getMemoryDnaSizeInBytes()
virtual const unsigned char * getBufferPointer() const
btAlignedObjectArray< short * > mStructs
virtual btChunk * allocate(size_t size, int numElements)
The btHashMap template class implements a generic and lightweight hashmap.
void insert(const Key &key, const Value &value)
const Value * getAtIndex(int index) const
virtual btChunk * allocate(size_t size, int numElements)=0
virtual void setSerializationFlags(int flags)=0
virtual int getCurrentBufferSize() const =0
virtual void * getUniquePointer(void *oldPtr)=0
virtual int getSerializationFlags() const =0
virtual void serializeName(const char *ptr)=0
virtual void finishSerialization()=0
virtual const char * findNameForPointer(const void *ptr) const =0
virtual void startSerialization()=0
virtual const btChunk * getChunk(int chunkIndex) const =0
virtual int getNumChunks() const =0
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
virtual const unsigned char * getBufferPointer() const =0
virtual void registerNameForPointer(const void *ptr, const char *name)=0
virtual void * findPointer(void *oldPtr)=0
btAlignedObjectArray< struct btQuantizedBvhDoubleData * > m_bvhsDouble
btAlignedObjectArray< struct btTypedConstraintData * > m_constraintData
btAlignedObjectArray< struct btRigidBodyDoubleData * > m_rigidBodyDataDouble
btAlignedObjectArray< struct btCollisionObjectFloatData * > m_collisionObjectDataFloat
btAlignedObjectArray< struct btSoftBodyDoubleData * > m_softBodyDoubleData
btAlignedObjectArray< struct btRigidBodyFloatData * > m_rigidBodyDataFloat
btAlignedObjectArray< struct btTypedConstraintDoubleData * > m_constraintDataDouble
btAlignedObjectArray< struct btDynamicsWorldDoubleData * > m_dynamicWorldInfoDataDouble
btAlignedObjectArray< struct btTypedConstraintFloatData * > m_constraintDataFloat
btAlignedObjectArray< struct btCollisionObjectDoubleData * > m_collisionObjectDataDouble
btAlignedObjectArray< struct btCollisionShapeData * > m_colShapeData
btAlignedObjectArray< struct btDynamicsWorldFloatData * > m_dynamicWorldInfoDataFloat
btBulletSerializedArrays()
btAlignedObjectArray< struct btQuantizedBvhFloatData * > m_bvhsFloat
btAlignedObjectArray< struct btSoftBodyFloatData * > m_softBodyFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
very basic hashable string implementation, compatible with btHashMap
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64