27 #define SIZEOFBLENDERHEADER 12
28 #define MAX_ARRAY_LENGTH 512
30 #define MAX_STRLEN 1024
34 int slen = strlen(memName);
37 for (
int i=0;i<slen;i++)
39 if (memName[i]==
']'||memName[i]==
'[')
44 buffer[i] = memName[i];
70 FILE *fp = fopen(filename,
"rb");
73 fseek(fp, 0L, SEEK_END);
75 fseek(fp, 0L, SEEK_SET);
89 bFile::bFile(
char *memoryBuffer,
int len,
const char headerString[7])
146 if (header[6] ==
'd')
151 char *ver = header+9;
159 littleEndian= ((
char*)&littleEndian)[0];
173 if (littleEndian ==1)
218 char *tempBuffer = blenderData;
224 if (!
mDataStart && strncmp(tempBuffer,
"REND", 4)==0)
227 if (strncmp(tempBuffer,
"DNA1", 4)==0)
241 else if (strncmp(tempBuffer,
"SDNANAME", 8) ==0)
243 dna.
oldPtr = blenderData + i;
244 dna.
len = mFileLen-i;
291 littleEndian= ((
char*)&littleEndian)[0];
333 const char s[] =
"SoftBodyMaterialData";
335 if (strncmp((
char*)&dataChunk.
code,
"ARAY",4)==0)
339 if (strncmp(oldType,s,szs)==0)
348 for (
int i=0; i<dataChunk.
nr; i++)
357 const bool VOID_IS_8 = ((
sizeof(
void*)==8));
363 if ((c->
code & 0xFFFF)==0)
371 if ((c->
code & 0xFFFF)==0)
383 if ((c->
code & 0xFFFF)==0)
392 if ((c->
code & 0xFFFF)==0)
410 char* data = &ptr[offset];
413 int *intPtr=0;
short *shtPtr=0;
414 char *cp = 0;
int dataLen =0;
long nr=0;
425 if (strncmp(data,
"SDNA", 4)==0)
433 if (strncmp(data+4,
"SDNA", 4)==0)
456 for ( i=0; i<dataLen; i++)
482 assert(strncmp(cp,
"TYPE", 4)==0); intPtr++;
494 for ( i=0; i<dataLen; i++)
519 assert(strncmp(cp,
"TLEN", 4)==0); intPtr++;
522 shtPtr = (
short*)intPtr;
523 for ( i=0; i<dataLen; i++, shtPtr++)
543 intPtr = (
int*)shtPtr;
545 assert(strncmp(cp,
"STRC", 4)==0);
558 shtPtr = (
short*)intPtr;
559 for ( i=0; i<dataLen; i++)
571 for (
int a=0; a<len; a++, shtPtr+=2)
585 FILE* f = fopen(fileName,
"wb");
597 littleEndian= ((
char*)&littleEndian)[0];
620 bool ignoreEndianFlag =
true;
626 char *dataPtrHead = 0;
644 swap(dataPtrHead, dataChunk,ignoreEndianFlag);
647 printf(
"unknown chunk\n");
661 mFlags &= ~FD_ENDIAN_SWAP;
675 bool ignoreEndianFlag =
false;
678 swap(head, dataChunk, ignoreEndianFlag);
685 short *oldStruct,*curStruct;
686 char *oldType, *newType;
687 int oldLen, curLen, reverseOld;
697 if ((strcmp(oldType,
"btQuantizedBvhNodeData")==0)&&oldLen==20)
701 if ((strcmp(oldType,
"btShortIntIndexData")==0))
704 char *dataAlloc =
new char[(dataChunk.
nr*allocLen)+1];
705 memset(dataAlloc, 0, (dataChunk.
nr*allocLen)+1);
706 short* dest = (
short*) dataAlloc;
707 const short* src = (
short*) head;
708 for (
int i=0;i<dataChunk.
nr;i++)
711 if (
mFlags &FD_ENDIAN_SWAP)
724 if (strcmp(
"Link",oldType)!=0)
728 if ((reverseOld!=-1))
741 assert((strcmp(oldType, newType)==0) &&
"internal error, struct mismatch!");
747 int allocLen = (curLen);
748 char *dataAlloc =
new char[(dataChunk.
nr*allocLen)+1];
749 memset(dataAlloc, 0, (dataChunk.
nr*allocLen));
754 char *cur = dataAlloc;
756 for (
int block=0; block<dataChunk.
nr; block++)
758 bool fixupPointers =
true;
774 #ifdef DEBUG_EQUAL_STRUCTS
779 printf(
"%s equal structure, just memcpy\n",oldType);
784 char *dataAlloc =
new char[(dataChunk.
len)+1];
785 memset(dataAlloc, 0, dataChunk.
len+1);
791 memcpy(dataAlloc, head, dataChunk.
len);
800 if (old_dna == -1)
return;
801 if (new_dna == -1)
return;
809 memcpy(strcPtr, dtPtr, len);
814 char *memType, *memName, *cpc, *cpo;
815 short *fileStruct, *filePtrOld, *memoryStruct, *firstStruct;
816 int elementLength,
size, revType, old_nr, new_nr, fpLen;
817 short firstStructType;
823 firstStruct = fileStruct;
826 filePtrOld = fileStruct;
830 elementLength = memoryStruct[1];
833 cpc = strcPtr; cpo = 0;
834 for (
int ele=0; ele<elementLength; ele++, memoryStruct+=2)
843 if (revType != -1 && memoryStruct[0]>=firstStructType && memName[0] !=
'*')
845 cpo =
getFileElement(firstStruct, memName, memType, dtPtr, &filePtrOld);
854 parseStruct(cpc, cpo, old_nr, new_nr,fixupPointers);
860 for (
int i=0;i<arrayLen;i++)
862 parseStruct(tmpCpc, tmpCpo, old_nr, new_nr,fixupPointers);
863 tmpCpc += size/arrayLen;
864 tmpCpo += fpLen/arrayLen;
884 static void getElement(
int arrayLen,
const char *cur,
const char *old,
char *oldPtr,
char *curData)
886 #define getEle(value, current, type, cast, size, ptr)\
887 if (strcmp(current, type)==0)\
889 value = (*(cast*)ptr);\
893 #define setEle(value, current, type, cast, size, ptr)\
894 if (strcmp(current, type)==0)\
896 (*(cast*)ptr) = (cast)value;\
901 for (
int i=0; i<arrayLen; i++)
903 getEle(value, old,
"char",
char,
sizeof(
char), oldPtr);
904 setEle(value, cur,
"char",
char,
sizeof(
char), curData);
905 getEle(value, old,
"short",
short,
sizeof(
short), oldPtr);
906 setEle(value, cur,
"short",
short,
sizeof(
short), curData);
907 getEle(value, old,
"ushort",
unsigned short,
sizeof(
unsigned short), oldPtr);
908 setEle(value, cur,
"ushort",
unsigned short,
sizeof(
unsigned short), curData);
909 getEle(value, old,
"int",
int,
sizeof(
int), oldPtr);
910 setEle(value, cur,
"int",
int,
sizeof(
int), curData);
911 getEle(value, old,
"long",
int,
sizeof(
int), oldPtr);
912 setEle(value, cur,
"long",
int,
sizeof(
int), curData);
913 getEle(value, old,
"float",
float,
sizeof(
float), oldPtr);
914 setEle(value, cur,
"float",
float,
sizeof(
float), curData);
915 getEle(value, old,
"double",
double,
sizeof(
double), oldPtr);
916 setEle(value, cur,
"double",
double,
sizeof(
double), curData);
926 if (type == 2 || type == 3)
928 short *sp = (
short*)data;
929 for (
int i=0; i<arraySize; i++)
935 if (type>3 && type <8)
939 for (
int i=0; i<arraySize; i++)
964 if (ptrFile == ptrMem)
966 memcpy(dst, src, ptrMem);
968 else if (ptrMem==4 && ptrFile==8)
986 *((
int*)dst) = (int)(longValue>>3);
990 else if (ptrMem==8 && ptrFile==4)
1000 *((
long64*)dst)= *((
int*)src);
1005 printf (
"%d %d\n", ptrFile,ptrMem);
1006 assert(0 &&
"Invalid pointer len");
1014 void bFile::getMatchingFileDNA(
short* dna_addr,
const char* lookupName,
const char* lookupType,
char *strcData,
char *data,
bool fixupPointers)
1020 int len = dna_addr[1];
1023 for (
int i=0; i<len; i++, dna_addr+=2)
1034 if ((strcmp(type,
"short")==0)&&(strcmp(name,
"int")==0))
1040 if (strcmp(lookupName, name)==0)
1061 cpc = (
char*)strcData;
1064 for (
int a=0; a<arrayLen; a++)
1087 else if (strcmp(type, lookupType)==0)
1088 memcpy(strcData, data, eleLen);
1090 getElement(arrayLen, lookupType, type, data, strcData);
1103 short *old = firstStruct;
1104 int elementLength = old[1];
1107 for (
int i=0; i<elementLength; i++, old+=2)
1113 if (strcmp(lookupName, name)==0)
1115 if (strcmp(type, lookupType)==0)
1132 if (dna_nr == -1)
return;
1137 int elementLen= strc[1];
1143 for (
int i=0; i<elementLen; i++, strc+=2)
1149 if (strc[0] >= first && name[0]!=
'*')
1159 for (
int i=0;i<arrayLen;i++)
1162 tmpBuf+=size/arrayLen;
1171 swapData(buf, strc[0], arrayLen,ignoreEndianFlag);
1186 void** ptrptr = (
void**) cur;
1187 void* ptr = *ptrptr;
1203 void** ptrptr = (
void**)cur;
1212 int blockLen = block->
len / ptrFile;
1217 char *newPtr =
new char[blockLen * ptrMem];
1219 memset(newPtr, 0, blockLen * ptrMem);
1221 void **onarray = (
void**)onptr;
1222 char *oldPtr = (
char*)onarray;
1225 while (blockLen-- > 0)
1230 void **tptr = (
void**)(newPtr + p * ptrMem);
1250 short oldLen = fileDna->
getLength(oldStruct[0]);
1254 for (
int block=0; block<dataChunk.
nr; block++)
1269 short firstStructType = fileDna->
getStruct(0)[0];
1272 char* elemPtr= strcPtr;
1274 short int* oldStruct = fileDna->
getStruct(dna_nr);
1276 int elementLength = oldStruct[1];
1281 for (
int ele=0; ele<elementLength; ele++, oldStruct+=2)
1284 memType = fileDna->
getType(oldStruct[0]);
1285 memName = fileDna->
getName(oldStruct[1]);
1290 if (memName[0] ==
'*')
1294 void **array= (
void**)elemPtr;
1295 for (
int a=0; a<arrayLen; a++)
1299 for (
int i=0;i<recursion;i++)
1304 printf(
"<%s type=\"pointer\"> ",&memName[1]);
1305 printf(
"%d ", array[a]);
1306 printf(
"</%s>\n",&memName[1]);
1314 void** ptrptr = (
void**) elemPtr;
1315 void* ptr = *ptrptr;
1318 for (
int i=0;i<recursion;i++)
1322 printf(
"<%s type=\"pointer\"> ",&memName[1]);
1324 printf(
"</%s>\n",&memName[1]);
1332 if (memName[1] ==
'*' && ptrptr && *ptrptr)
1335 void **array= (
void**)*(ptrptr);
1341 if (np) array[n]= np;
1353 if (oldStruct[0]>=firstStructType)
1363 for (
int i=0;i<recursion;i++)
1370 printf(
"<%s type=\"%s\" count=%d>\n",cleanName,memType, arrayLen);
1373 printf(
"<%s type=\"%s\">\n",cleanName,memType);
1377 for (
int i=0;i<arrayLen;i++)
1381 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1383 for (
int i=0;i<recursion;i++)
1387 printf(
"</%s>\n",cleanName);
1397 printf(
"too long\n");
1402 bool isIntegerType = (strcmp(memType,
"char")==0) || (strcmp(memType,
"int")==0) || (strcmp(memType,
"short")==0);
1406 const char* newtype=
"int";
1409 char* tmp = elemPtr;
1410 dbPtr = &dbarray[0];
1417 getElement(arrayLen, newtype,memType, tmp, (
char*)dbPtr);
1418 for (i=0;i<recursion;i++)
1421 printf(
"<%s type=\"%s\">",cleanName,memType);
1423 printf(
"<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
1424 for (i=0;i<arrayLen;i++)
1425 printf(
" %d ",dbPtr[i]);
1426 printf(
"</%s>\n",cleanName);
1430 const char* newtype=
"double";
1433 char* tmp = elemPtr;
1434 dbPtr = &dbarray[0];
1438 getElement(arrayLen, newtype,memType, tmp, (
char*)dbPtr);
1439 for (i=0;i<recursion;i++)
1446 printf(
"<%s type=\"%s\">",memName,memType);
1450 printf(
"<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
1452 for (i=0;i<arrayLen;i++)
1453 printf(
" %f ",dbPtr[i]);
1454 printf(
"</%s>\n",cleanName);
1489 printf(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
1491 printf(
"<bullet_physics version=%d itemcount = %d>\n",
btGetVersion(), numitems);
1493 for (
int i=0;i<
m_chunks.size();i++)
1501 char* oldType = fileDna->
getType(oldStruct[0]);
1503 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1504 printf(
" <%s pointer=%d>\n",oldType,dataChunk.
oldPtr);
1508 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1509 printf(
" </%s>\n",oldType);
1515 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1517 printf(
"</bullet_physics>\n");
1553 char* codeptr = (
char*)&dataChunk.
code;
1554 char codestr[5] = {codeptr[0],codeptr[1],codeptr[2],codeptr[3],0};
1556 short* newStruct = dna->
getStruct(dataChunk.dna_nr);
1557 char* typeName = dna->
getType(newStruct[0]);
1558 printf(
"%3d: %s ",i,typeName);
1560 printf(
"code=%s ",codestr);
1562 printf(
"ptr=%p ",dataChunk.oldPtr);
1563 printf(
"len=%d ",dataChunk.len);
1564 printf(
"nr=%d ",dataChunk.nr);
1565 if (dataChunk.nr!=1)
1580 ifd.just_print_it = 1;
1581 for (i=0; i<bf->m_blocks.size(); ++i)
1583 BlendBlock* bb = bf->m_blocks[i];
1584 printf(
"tag='%s'\tptr=%p\ttype=%s\t[%4d]", bb->tag, bb,bf->types[bb->type_index].name,bb->m_array_entries_.size());
1585 block_ID_finder(bb, bf, &ifd);
1593 void bFile::writeChunks(FILE* fp,
bool fixupPointers)
1597 for (
int i=0;i<
m_chunks.size();i++)
1602 short *oldStruct,*curStruct;
1603 char *oldType, *newType;
1604 int curLen, reverseOld;
1607 oldType = fileDna->
getType(oldStruct[0]);
1613 if ((reverseOld!=-1))
1621 assert((strcmp(oldType, newType)==0) &&
"internal error, struct mismatch!");
1625 dataChunk.
dna_nr = reverseOld;
1626 if (strcmp(
"Link",oldType)!=0)
1628 dataChunk.
len = curLen * dataChunk.
nr;
1635 fwrite(&dataChunk,
sizeof(
bChunkInd),1,fp);
1639 short int* curStruct1;
1641 assert(curStruct1 == curStruct);
1646 fwrite(cur,dataChunk.
len,1,fp);
1649 printf(
"serious error, struct mismatch: don't write\n");
1660 bool varies =
false;
1686 if ((chunk.
code & 0xFFFF)==0)
1695 memcpy(dataChunk, &chunk,
sizeof(
bChunkInd));
1704 if ((c.
code & 0xFFFF)==0)
1712 memcpy(dataChunk, &c,
sizeof(
bChunkInd));
1745 if ((chunk.
code & 0xFFFF)==0)
1753 memcpy(dataChunk, &chunk,
sizeof(
bChunkInd));
1762 if ((c.
code & 0xFFFF)==0)
1769 memcpy(dataChunk, &c,
sizeof(
bChunkInd));
1773 if (dataChunk->
len < 0)
1777 print (
"----------");
1778 print (dataChunk->
code);
1779 print (dataChunk->
len);
1780 print (dataChunk->old);
1781 print (dataChunk->
dna_nr);
1782 print (dataChunk->
nr);
void push_back(const T &_Val)
void resolvePointersChunk(const bChunkInd &dataChunk, int verboseMode)
this loop only works fine if the Blender DNA structure of the file matches the headerfiles ...
#define setEle(value, current, type, cast, size, ptr)
btAlignedObjectArray< char * > m_pointerPtrFixupArray
int getNextBlock(bChunkInd *dataChunk, const char *dataPtr, const int flags)
int getArraySizeNew(short name)
bool lessThan(bDNA *other)
const T & at(int n) const
char * readStruct(char *head, class bChunkInd &chunk)
virtual void parseData()=0
virtual void parseInternal(int verboseMode, char *memDna, int memDnaLength)
static void getElement(int arrayLen, const char *cur, const char *old, char *oldPtr, char *curData)
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
virtual void addDataBlock(char *dataBlock)=0
void dumpTypeDefinitions()
void dumpChunks(bDNA *dna)
int resolvePointersStructRecursive(char *strcPtr, int old_dna, int verboseMode, int recursion)
bFile(const char *filename, const char headerString[7])
void initCmpFlags(bDNA *memDNA)
#define SIZEOFBLENDERHEADER
void swapLen(char *dataPtr)
static int swapInt(int inte)
#define SWITCH_LONGINT(a)
int size() const
return the number of elements in the array
btAlignedObjectArray< char * > m_pointerFixupArray
void resolvePointers(int verboseMode)
Resolve pointers replaces the original pointers in structures, and linked lists by the new in-memory ...
void swapStruct(int dna_nr, char *data, bool ignoreEndianFlag)
void insert(const Key &key, const Value &value)
void parseStruct(char *strcPtr, char *dtPtr, int old_dna, int new_dna, bool fixupPointers)
void safeSwapPtr(char *dst, const char *src)
const char * getCleanName(const char *memName, char *buffer)
virtual void parseHeader()
void writeFile(const char *fileName)
const Value * find(const Key &key) const
bPtrMap & getLibPointers()
#define getEle(value, current, type, cast, size, ptr)
btAlignedObjectArray< bChunkInd > m_chunks
virtual void setFileDNA(int verboseMode, char *buffer, int len)
short * getStruct(int ind)
void getMatchingFileDNA(short *old, const char *lookupName, const char *lookupType, char *strcData, char *data, bool fixupPointers)
void init(char *data, int len, bool swap=false)
bool flagEqual(int dna_nr)
void * findLibPointer(void *ptr)
void swapData(char *data, short type, int arraySize, bool ignoreEndianFlag)
int getElementSize(short type, short name)
char * getFileElement(short *firstStruct, char *lookupName, char *lookupType, char *data, short **foundPos)
static short swapShort(short sht)
void swap(char *head, class bChunkInd &ch, bool ignoreEndianFlag)
const T & btMin(const T &a, const T &b)
int getReverseType(short type)
btHashMap< btHashPtr, bChunkInd > m_chunkPtrPtrMap
static int getOffset(int flags)
void resolvePointersMismatch()