Bullet Collision Detection & Physics Library: btBulletFile.cpp Source File

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btBulletFile.cpp
Go to the documentation of this file.
1 /*
2 bParse
3 Copyright (c) 2006-2010 Erwin Coumans http://gamekit.googlecode.com
4
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15
16 #include "btBulletFile.h"
17 #include "bDefines.h"
18 #include "bDNA.h"
19
20 #if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
21 #include <memory.h>
22 #endif
23 #include <string.h>
24
25
26 // 32 && 64 bit versions
27 #ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
28 #ifdef _WIN64
29 extern char sBulletDNAstr64[];
30 extern int sBulletDNAlen64;
31 #else
32 extern char sBulletDNAstr[];
33 extern int sBulletDNAlen;
34 #endif //_WIN64
35 #else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
36
37 extern char sBulletDNAstr64[];
38 extern int sBulletDNAlen64;
39 extern char sBulletDNAstr[];
40 extern int sBulletDNAlen;
41
42 #endif //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
43
44 using namespace bParse;
45
46 btBulletFile::btBulletFile()
47 :bFile("", "BULLET ")
48 {
49 mMemoryDNA = new bDNA(); //this memory gets released in the bFile::~bFile destructor,@todo not consistent with the rule 'who allocates it, has to deallocate it"
50
51 m_DnaCopy = 0;
52
53
54 #ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
55 #ifdef _WIN64
56 m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
57 memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
58 mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
59 #else//_WIN64
60 m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
61 memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
62 mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
63 #endif//_WIN64
64 #else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
65 if (VOID_IS_8)
66 {
67 m_DnaCopy = (char*) btAlignedAlloc(sBulletDNAlen64,16);
68 memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
69 mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
70 }
71 else
72 {
73 m_DnaCopy =(char*) btAlignedAlloc(sBulletDNAlen,16);
74 memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
75 mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
76 }
77 #endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
78 }
79
80
81
82 btBulletFile::btBulletFile(const char* fileName)
83 :bFile(fileName, "BULLET ")
84 {
85 m_DnaCopy = 0;
86 }
87
88
89
90 btBulletFile::btBulletFile(char *memoryBuffer, int len)
91 :bFile(memoryBuffer,len, "BULLET ")
92 {
93 m_DnaCopy = 0;
94 }
95
96
97 btBulletFile::~btBulletFile()
98 {
99 if (m_DnaCopy)
100 btAlignedFree(m_DnaCopy);
101
102
103 while (m_dataBlocks.size())
104 {
105 char* dataBlock = m_dataBlocks[m_dataBlocks.size()-1];
106 delete[] dataBlock;
107 m_dataBlocks.pop_back();
108 }
109
110 }
111
112
113
114 // ----------------------------------------------------- //
115 void btBulletFile::parseData()
116 {
117 // printf ("Building datablocks");
118 // printf ("Chunk size = %d",CHUNK_HEADER_LEN);
119 // printf ("File chunk size = %d",ChunkUtils::getOffset(mFlags));
120
121 const bool brokenDNA = (mFlags&FD_BROKEN_DNA)!=0;
122
123 //const bool swap = (mFlags&FD_ENDIAN_SWAP)!=0;
124
125
126 mDataStart = 12;
127
128 char *dataPtr = mFileBuffer+mDataStart;
129
130 bChunkInd dataChunk;
131 dataChunk.code = 0;
132
133
134 //dataPtr += ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
135 int seek = getNextBlock(&dataChunk, dataPtr, mFlags);
136
137
138 if (mFlags &FD_ENDIAN_SWAP)
139 swapLen(dataPtr);
140
141 //dataPtr += ChunkUtils::getOffset(mFlags);
142 char *dataPtrHead = 0;
143
144 while (dataChunk.code != DNA1)
145 {
146 if (!brokenDNA || (dataChunk.code != BT_QUANTIZED_BVH_CODE) )
147 {
148
149 // one behind
150 if (dataChunk.code == SDNA) break;
151 //if (dataChunk.code == DNA1) break;
152
153 // same as (BHEAD+DATA dependency)
154 dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
155 if (dataChunk.dna_nr>=0)
156 {
157 char *id = readStruct(dataPtrHead, dataChunk);
158
159 // lookup maps
160 if (id)
161 {
162 m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
163 mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)id);
164
165 m_chunks.push_back(dataChunk);
166 // block it
167 //bListBasePtr *listID = mMain->getListBasePtr(dataChunk.code);
168 //if (listID)
169 // listID->push_back((bStructHandle*)id);
170 }
171
172 if (dataChunk.code == BT_SOFTBODY_CODE)
173 {
174 m_softBodies.push_back((bStructHandle*) id);
175 }
176
177 if (dataChunk.code == BT_RIGIDBODY_CODE)
178 {
179 m_rigidBodies.push_back((bStructHandle*) id);
180 }
181
182 if (dataChunk.code == BT_DYNAMICSWORLD_CODE)
183 {
184 m_dynamicsWorldInfo.push_back((bStructHandle*) id);
185 }
186
187 if (dataChunk.code == BT_CONSTRAINT_CODE)
188 {
189 m_constraints.push_back((bStructHandle*) id);
190 }
191
192 if (dataChunk.code == BT_QUANTIZED_BVH_CODE)
193 {
194 m_bvhs.push_back((bStructHandle*) id);
195 }
196
197 if (dataChunk.code == BT_TRIANLGE_INFO_MAP)
198 {
199 m_triangleInfoMaps.push_back((bStructHandle*) id);
200 }
201
202 if (dataChunk.code == BT_COLLISIONOBJECT_CODE)
203 {
204 m_collisionObjects.push_back((bStructHandle*) id);
205 }
206
207 if (dataChunk.code == BT_SHAPE_CODE)
208 {
209 m_collisionShapes.push_back((bStructHandle*) id);
210 }
211
212 // if (dataChunk.code == GLOB)
213 // {
214 // m_glob = (bStructHandle*) id;
215 // }
216 } else
217 {
218 printf("unknown chunk\n");
219
220 mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)dataPtrHead);
221 }
222 } else
223 {
224 printf("skipping BT_QUANTIZED_BVH_CODE due to broken DNA\n");
225 }
226
227
228 dataPtr += seek;
229
230 seek = getNextBlock(&dataChunk, dataPtr, mFlags);
231 if (mFlags &FD_ENDIAN_SWAP)
232 swapLen(dataPtr);
233
234 if (seek < 0)
235 break;
236 }
237
238 }
239
240 void btBulletFile::addDataBlock(char* dataBlock)
241 {
242 m_dataBlocks.push_back(dataBlock);
243
244 }
245
246
247
248
249 void btBulletFile::writeDNA(FILE* fp)
250 {
251
252 bChunkInd dataChunk;
253 dataChunk.code = DNA1;
254 dataChunk.dna_nr = 0;
255 dataChunk.nr = 1;
256 #ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
257 if (VOID_IS_8)
258 {
259 #ifdef _WIN64
260 dataChunk.len = sBulletDNAlen64;
261 dataChunk.oldPtr = sBulletDNAstr64;
262 fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
263 fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
264 #else
265 btAssert(0);
266 #endif
267 }
268 else
269 {
270 #ifndef _WIN64
271 dataChunk.len = sBulletDNAlen;
272 dataChunk.oldPtr = sBulletDNAstr;
273 fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
274 fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
275 #else//_WIN64
276 btAssert(0);
277 #endif//_WIN64
278 }
279 #else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
280 if (VOID_IS_8)
281 {
282 dataChunk.len = sBulletDNAlen64;
283 dataChunk.oldPtr = sBulletDNAstr64;
284 fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
285 fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
286 }
287 else
288 {
289 dataChunk.len = sBulletDNAlen;
290 dataChunk.oldPtr = sBulletDNAstr;
291 fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
292 fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
293 }
294 #endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
295 }
296
297
298 void btBulletFile::parse(int verboseMode)
299 {
300 #ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
301 if (VOID_IS_8)
302 {
303 #ifdef _WIN64
304
305 if (m_DnaCopy)
306 delete m_DnaCopy;
307 m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
308 memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
309 parseInternal(verboseMode,(char*)sBulletDNAstr64,sBulletDNAlen64);
310 #else
311 btAssert(0);
312 #endif
313 }
314 else
315 {
316 #ifndef _WIN64
317
318 if (m_DnaCopy)
319 delete m_DnaCopy;
320 m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
321 memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
322 parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen);
323 #else
324 btAssert(0);
325 #endif
326 }
327 #else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
328 if (VOID_IS_8)
329 {
330 if (m_DnaCopy)
331 delete m_DnaCopy;
332 m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
333 memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
334 parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen64);
335 }
336 else
337 {
338 if (m_DnaCopy)
339 delete m_DnaCopy;
340 m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
341 memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
342 parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen);
343 }
344 #endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
345
346 //the parsing will convert to cpu endian
347 mFlags &=~FD_ENDIAN_SWAP;
348
349 int littleEndian= 1;
350 littleEndian= ((char*)&littleEndian)[0];
351
352 mFileBuffer[8] = littleEndian?'v':'V';
353
354 }
355
356 // experimental
357 int btBulletFile::write(const char* fileName, bool fixupPointers)
358 {
359 FILE *fp = fopen(fileName, "wb");
360 if (fp)
361 {
362 char header[SIZEOFBLENDERHEADER] ;
363 memcpy(header, m_headerString, 7);
364 int endian= 1;
365 endian= ((char*)&endian)[0];
366
367 if (endian)
368 {
369 header[7] = '_';
370 } else
371 {
372 header[7] = '-';
373 }
374 if (VOID_IS_8)
375 {
376 header[8]='V';
377 } else
378 {
379 header[8]='v';
380 }
381
382 header[9] = '2';
383 header[10] = '7';
384 header[11] = '5';
385
386 fwrite(header,SIZEOFBLENDERHEADER,1,fp);
387
388 writeChunks(fp, fixupPointers);
389
390 writeDNA(fp);
391
392 fclose(fp);
393
394 } else
395 {
396 printf("Error: cannot open file %s for writing\n",fileName);
397 return 0;
398 }
399 return 1;
400 }
401
402
403
404 void btBulletFile::addStruct(const char* structType,void* data, int len, void* oldPtr, int code)
405 {
406
407 bParse::bChunkInd dataChunk;
408 dataChunk.code = code;
409 dataChunk.nr = 1;
410 dataChunk.len = len;
411 dataChunk.dna_nr = mMemoryDNA->getReverseType(structType);
412 dataChunk.oldPtr = oldPtr;
413
415 short* structInfo= mMemoryDNA->getStruct(dataChunk.dna_nr);
416 int elemBytes;
417 elemBytes= mMemoryDNA->getLength(structInfo[0]);
418 // int elemBytes = mMemoryDNA->getElementSize(structInfo[0],structInfo[1]);
419 assert(len==elemBytes);
420
421 mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)data);
422 m_chunks.push_back(dataChunk);
423 }
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:276
bDNA.h
bParse::btBulletFile::m_dataBlocks
btAlignedObjectArray< char * > m_dataBlocks
Definition: btBulletFile.h:57
bParse::bFile::getNextBlock
int getNextBlock(bChunkInd *dataChunk, const char *dataPtr, const int flags)
Definition: bFile.cpp:1639
bParse::btBulletFile::m_triangleInfoMaps
btAlignedObjectArray< bStructHandle * > m_triangleInfoMaps
Definition: btBulletFile.h:53
BT_CONSTRAINT_CODE
#define BT_CONSTRAINT_CODE
Definition: btSerializer.h:119
sBulletDNAlen64
int sBulletDNAlen64
Definition: btSerializer.cpp:1091
bParse::bChunkInd::nr
int nr
Definition: bChunk.h:68
bParse::bFile
Definition: bFile.h:47
bParse::bFile::mMemoryDNA
bDNA * mMemoryDNA
Definition: bFile.h:63
bParse::btBulletFile::m_constraints
btAlignedObjectArray< bStructHandle * > m_constraints
Definition: btBulletFile.h:49
bParse::bFile::readStruct
char * readStruct(char *head, class bChunkInd &chunk)
Definition: bFile.cpp:655
bParse::bFile::parseInternal
void parseInternal(int verboseMode, char *memDna, int memDnaLength)
Definition: bFile.cpp:191
BT_QUANTIZED_BVH_CODE
#define BT_QUANTIZED_BVH_CODE
Definition: btSerializer.h:121
bParse::btBulletFile::m_DnaCopy
char * m_DnaCopy
Definition: btBulletFile.h:37
btBulletFile.h
bParse::bChunkInd::len
int len
Definition: bChunk.h:66
bParse::bChunkInd
Definition: bChunk.h:62
btAssert
#define btAssert(x)
Definition: btScalar.h:113
bParse::btBulletFile::addStruct
void addStruct(const char *structType, void *data, int len, void *oldPtr, int code)
Definition: btBulletFile.cpp:404
bParse::bFile::mFileBuffer
char * mFileBuffer
Definition: bFile.h:54
bParse::btBulletFile::m_collisionObjects
btAlignedObjectArray< bStructHandle * > m_collisionObjects
Definition: btBulletFile.h:45
BT_SOFTBODY_CODE
#define BT_SOFTBODY_CODE
Definition: btSerializer.h:116
BT_DYNAMICSWORLD_CODE
#define BT_DYNAMICSWORLD_CODE
Definition: btSerializer.h:127
bParse::bChunkInd::dna_nr
int dna_nr
Definition: bChunk.h:68
SDNA
#define SDNA
Definition: bDefines.h:112
bParse::btBulletFile::writeDNA
virtual void writeDNA(FILE *fp)
Definition: btBulletFile.cpp:249
bParse::FD_BROKEN_DNA
Definition: bFile.h:36
bParse::bFile::swapLen
void swapLen(char *dataPtr)
Definition: bFile.cpp:337
bParse::bStructHandle
Definition: bCommon.h:33
DNA1
#define DNA1
Definition: bDefines.h:108
sBulletDNAlen
int sBulletDNAlen
Definition: btSerializer.cpp:545
bParse::FD_ENDIAN_SWAP
Definition: bFile.h:31
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:149
bParse::btBulletFile::parse
virtual void parse(int verboseMode)
Definition: btBulletFile.cpp:298
bParse::bChunkInd::oldPtr
void * oldPtr
Definition: bChunk.h:67
bParse::VOID_IS_8
const bool VOID_IS_8
Definition: bChunk.h:89
bParse::bChunkInd::code
int code
Definition: bChunk.h:66
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:42
btHashMap::insert
void insert(const Key &key, const Value &value)
Definition: btHashMap.h:269
bParse::bFile::mFlags
int mFlags
Definition: bFile.h:76
btAlignedObjectArray::pop_back
void pop_back()
Definition: btAlignedObjectArray.h:193
bParse::btBulletFile::m_softBodies
btAlignedObjectArray< bStructHandle * > m_softBodies
Definition: btBulletFile.h:41
BT_COLLISIONOBJECT_CODE
#define BT_COLLISIONOBJECT_CODE
Definition: btSerializer.h:117
sBulletDNAstr
char sBulletDNAstr[]
only the 32bit versions for now
Definition: btSerializer.cpp:1
SIZEOFBLENDERHEADER
#define SIZEOFBLENDERHEADER
Definition: bDefines.h:24
bParse::btBulletFile::btBulletFile
btBulletFile()
Definition: btBulletFile.cpp:46
bParse::bFile::mDataStart
int mDataStart
Definition: bFile.h:61
bParse::btBulletFile::write
virtual int write(const char *fileName, bool fixupPointers=false)
Definition: btBulletFile.cpp:357
bParse::btBulletFile::addDataBlock
virtual void addDataBlock(char *dataBlock)
Definition: btBulletFile.cpp:240
bParse::btBulletFile::m_bvhs
btAlignedObjectArray< bStructHandle * > m_bvhs
Definition: btBulletFile.h:51
BT_RIGIDBODY_CODE
#define BT_RIGIDBODY_CODE
Definition: btSerializer.h:118
bParse::bFile::m_chunks
btAlignedObjectArray< bChunkInd > m_chunks
Definition: bFile.h:68
bParse
Definition: btBulletWorldImporter.h:29
bParse::btBulletFile::m_collisionShapes
btAlignedObjectArray< bStructHandle * > m_collisionShapes
Definition: btBulletFile.h:47
bParse::bDNA
Definition: bDNA.h:32
bParse::bDNA::getStruct
short * getStruct(int ind)
Definition: bDNA.cpp:66
bDefines.h
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:41
bParse::bDNA::init
void init(char *data, int len, bool swap=false)
Definition: bDNA.cpp:348
bParse::bFile::writeChunks
virtual void writeChunks(FILE *fp, bool fixupPointers)
Definition: bFile.cpp:1575
BT_TRIANLGE_INFO_MAP
#define BT_TRIANLGE_INFO_MAP
Definition: btSerializer.h:122
bParse::btBulletFile::m_dynamicsWorldInfo
btAlignedObjectArray< bStructHandle * > m_dynamicsWorldInfo
Definition: btBulletFile.h:55
bParse::bFile::m_headerString
char m_headerString[7]
Definition: bFile.h:51
BT_SHAPE_CODE
#define BT_SHAPE_CODE
Definition: btSerializer.h:123
bParse::btBulletFile::parseData
virtual void parseData()
Definition: btBulletFile.cpp:115
bParse::btBulletFile::m_rigidBodies
btAlignedObjectArray< bStructHandle * > m_rigidBodies
Definition: btBulletFile.h:43
bParse::bFile::mLibPointers
bPtrMap mLibPointers
Definition: bFile.h:59
bParse::bDNA::getReverseType
int getReverseType(short type)
Definition: bDNA.cpp:82
bParse::bFile::m_chunkPtrPtrMap
btHashMap< btHashPtr, bChunkInd > m_chunkPtrPtrMap
Definition: bFile.h:69
bParse::btBulletFile::~btBulletFile
virtual ~btBulletFile()
Definition: btBulletFile.cpp:97
bParse::bDNA::getLength
short getLength(int ind)
Definition: bDNA.cpp:74
bParse::ChunkUtils::getOffset
static int getOffset(int flags)
Definition: bChunk.cpp:51
sBulletDNAstr64
char sBulletDNAstr64[]
Definition: btSerializer.cpp:547