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)
200 char *tempBuffer = blenderData;
206 if (!
mDataStart && strncmp(tempBuffer,
"REND", 4)==0)
209 if (strncmp(tempBuffer,
"DNA1", 4)==0)
223 else if (strncmp(tempBuffer,
"SDNANAME", 8) ==0)
225 dna.
oldPtr = blenderData + i;
226 dna.
len = mFileLen-i;
273 littleEndian= ((
char*)&littleEndian)[0];
315 const char s[] =
"SoftBodyMaterialData";
317 if (strncmp((
char*)&dataChunk.
code,
"ARAY",4)==0)
321 if (strncmp(oldType,s,szs)==0)
330 for (
int i=0; i<dataChunk.
nr; i++)
339 const bool VOID_IS_8 = ((
sizeof(
void*)==8));
345 if ((c->
code & 0xFFFF)==0)
353 if ((c->
code & 0xFFFF)==0)
365 if ((c->
code & 0xFFFF)==0)
374 if ((c->
code & 0xFFFF)==0)
392 char* data = &ptr[offset];
395 int *intPtr=0;
short *shtPtr=0;
396 char *cp = 0;
int dataLen =0;
long nr=0;
407 if (strncmp(data,
"SDNA", 4)==0)
415 if (strncmp(data+4,
"SDNA", 4)==0)
438 for ( i=0; i<dataLen; i++)
464 assert(strncmp(cp,
"TYPE", 4)==0); intPtr++;
476 for ( i=0; i<dataLen; i++)
501 assert(strncmp(cp,
"TLEN", 4)==0); intPtr++;
504 shtPtr = (
short*)intPtr;
505 for ( i=0; i<dataLen; i++, shtPtr++)
525 intPtr = (
int*)shtPtr;
527 assert(strncmp(cp,
"STRC", 4)==0);
540 shtPtr = (
short*)intPtr;
541 for ( i=0; i<dataLen; i++)
553 for (
int a=0; a<len; a++, shtPtr+=2)
567 FILE* f = fopen(fileName,
"wb");
579 littleEndian= ((
char*)&littleEndian)[0];
602 bool ignoreEndianFlag =
true;
608 char *dataPtrHead = 0;
626 swap(dataPtrHead, dataChunk,ignoreEndianFlag);
629 printf(
"unknown chunk\n");
643 mFlags &= ~FD_ENDIAN_SWAP;
657 bool ignoreEndianFlag =
false;
660 swap(head, dataChunk, ignoreEndianFlag);
667 short *oldStruct,*curStruct;
668 char *oldType, *newType;
669 int oldLen, curLen, reverseOld;
679 if ((strcmp(oldType,
"btQuantizedBvhNodeData")==0)&&oldLen==20)
683 if ((strcmp(oldType,
"btShortIntIndexData")==0))
686 char *dataAlloc =
new char[(dataChunk.
nr*allocLen)+1];
687 memset(dataAlloc, 0, (dataChunk.
nr*allocLen)+1);
688 short* dest = (
short*) dataAlloc;
689 const short* src = (
short*) head;
690 for (
int i=0;i<dataChunk.
nr;i++)
693 if (
mFlags &FD_ENDIAN_SWAP)
706 if (strcmp(
"Link",oldType)!=0)
710 if ((reverseOld!=-1))
723 assert((strcmp(oldType, newType)==0) &&
"internal error, struct mismatch!");
729 int allocLen = (curLen);
730 char *dataAlloc =
new char[(dataChunk.
nr*allocLen)+1];
731 memset(dataAlloc, 0, (dataChunk.
nr*allocLen));
736 char *cur = dataAlloc;
738 for (
int block=0; block<dataChunk.
nr; block++)
740 bool fixupPointers =
true;
756 #ifdef DEBUG_EQUAL_STRUCTS 761 printf(
"%s equal structure, just memcpy\n",oldType);
766 char *dataAlloc =
new char[(dataChunk.
len)+1];
767 memset(dataAlloc, 0, dataChunk.
len+1);
773 memcpy(dataAlloc, head, dataChunk.
len);
782 if (old_dna == -1)
return;
783 if (new_dna == -1)
return;
791 memcpy(strcPtr, dtPtr, len);
796 char *memType, *memName, *cpc, *cpo;
797 short *fileStruct, *filePtrOld, *memoryStruct, *firstStruct;
798 int elementLength,
size, revType, old_nr, new_nr, fpLen;
799 short firstStructType;
805 firstStruct = fileStruct;
808 filePtrOld = fileStruct;
812 elementLength = memoryStruct[1];
815 cpc = strcPtr; cpo = 0;
816 for (
int ele=0; ele<elementLength; ele++, memoryStruct+=2)
825 if (revType != -1 && memoryStruct[0]>=firstStructType && memName[0] !=
'*')
827 cpo =
getFileElement(firstStruct, memName, memType, dtPtr, &filePtrOld);
836 parseStruct(cpc, cpo, old_nr, new_nr,fixupPointers);
842 for (
int i=0;i<arrayLen;i++)
844 parseStruct(tmpCpc, tmpCpo, old_nr, new_nr,fixupPointers);
845 tmpCpc += size/arrayLen;
846 tmpCpo += fpLen/arrayLen;
866 static void getElement(
int arrayLen,
const char *cur,
const char *old,
char *oldPtr,
char *curData)
868 #define getEle(value, current, type, cast, size, ptr)\ 869 if (strcmp(current, type)==0)\ 871 value = (*(cast*)ptr);\ 875 #define setEle(value, current, type, cast, size, ptr)\ 876 if (strcmp(current, type)==0)\ 878 (*(cast*)ptr) = (cast)value;\ 883 for (
int i=0; i<arrayLen; i++)
885 getEle(value, old,
"char",
char,
sizeof(
char), oldPtr);
886 setEle(value, cur,
"char",
char,
sizeof(
char), curData);
887 getEle(value, old,
"short",
short,
sizeof(
short), oldPtr);
888 setEle(value, cur,
"short",
short,
sizeof(
short), curData);
889 getEle(value, old,
"ushort",
unsigned short,
sizeof(
unsigned short), oldPtr);
890 setEle(value, cur,
"ushort",
unsigned short,
sizeof(
unsigned short), curData);
891 getEle(value, old,
"int",
int,
sizeof(
int), oldPtr);
892 setEle(value, cur,
"int",
int,
sizeof(
int), curData);
893 getEle(value, old,
"long",
int,
sizeof(
int), oldPtr);
894 setEle(value, cur,
"long",
int,
sizeof(
int), curData);
895 getEle(value, old,
"float",
float,
sizeof(
float), oldPtr);
896 setEle(value, cur,
"float",
float,
sizeof(
float), curData);
897 getEle(value, old,
"double",
double,
sizeof(
double), oldPtr);
898 setEle(value, cur,
"double",
double,
sizeof(
double), curData);
908 if (type == 2 || type == 3)
910 short *sp = (
short*)data;
911 for (
int i=0; i<arraySize; i++)
917 if (type>3 && type <8)
921 for (
int i=0; i<arraySize; i++)
946 if (ptrFile == ptrMem)
948 memcpy(dst, src, ptrMem);
950 else if (ptrMem==4 && ptrFile==8)
968 *((
int*)dst) = (int)(longValue>>3);
972 else if (ptrMem==8 && ptrFile==4)
982 *((
long64*)dst)= *((
int*)src);
987 printf (
"%d %d\n", ptrFile,ptrMem);
988 assert(0 &&
"Invalid pointer len");
996 void bFile::getMatchingFileDNA(
short* dna_addr,
const char* lookupName,
const char* lookupType,
char *strcData,
char *data,
bool fixupPointers)
1002 int len = dna_addr[1];
1005 for (
int i=0; i<len; i++, dna_addr+=2)
1016 if ((strcmp(type,
"short")==0)&&(strcmp(name,
"int")==0))
1022 if (strcmp(lookupName, name)==0)
1043 cpc = (
char*)strcData;
1046 for (
int a=0; a<arrayLen; a++)
1069 else if (strcmp(type, lookupType)==0)
1070 memcpy(strcData, data, eleLen);
1072 getElement(arrayLen, lookupType, type, data, strcData);
1085 short *old = firstStruct;
1086 int elementLength = old[1];
1089 for (
int i=0; i<elementLength; i++, old+=2)
1095 if (strcmp(lookupName, name)==0)
1097 if (strcmp(type, lookupType)==0)
1114 if (dna_nr == -1)
return;
1119 int elementLen= strc[1];
1125 for (
int i=0; i<elementLen; i++, strc+=2)
1131 if (strc[0] >= first && name[0]!=
'*')
1141 for (
int i=0;i<arrayLen;i++)
1144 tmpBuf+=size/arrayLen;
1153 swapData(buf, strc[0], arrayLen,ignoreEndianFlag);
1168 void** ptrptr = (
void**) cur;
1169 void* ptr = *ptrptr;
1185 void** ptrptr = (
void**)cur;
1194 int blockLen = block->
len / ptrFile;
1199 char *newPtr =
new char[blockLen * ptrMem];
1201 memset(newPtr, 0, blockLen * ptrMem);
1203 void **onarray = (
void**)onptr;
1204 char *oldPtr = (
char*)onarray;
1207 while (blockLen-- > 0)
1212 void **tptr = (
void**)(newPtr + p * ptrMem);
1232 short oldLen = fileDna->
getLength(oldStruct[0]);
1236 for (
int block=0; block<dataChunk.
nr; block++)
1251 short firstStructType = fileDna->
getStruct(0)[0];
1254 char* elemPtr= strcPtr;
1256 short int* oldStruct = fileDna->
getStruct(dna_nr);
1258 int elementLength = oldStruct[1];
1263 for (
int ele=0; ele<elementLength; ele++, oldStruct+=2)
1266 memType = fileDna->
getType(oldStruct[0]);
1267 memName = fileDna->
getName(oldStruct[1]);
1272 if (memName[0] ==
'*')
1276 void **array= (
void**)elemPtr;
1277 for (
int a=0; a<arrayLen; a++)
1281 for (
int i=0;i<recursion;i++)
1286 printf(
"<%s type=\"pointer\"> ",&memName[1]);
1287 printf(
"%d ", array[a]);
1288 printf(
"</%s>\n",&memName[1]);
1296 void** ptrptr = (
void**) elemPtr;
1297 void* ptr = *ptrptr;
1300 for (
int i=0;i<recursion;i++)
1304 printf(
"<%s type=\"pointer\"> ",&memName[1]);
1306 printf(
"</%s>\n",&memName[1]);
1314 if (memName[1] ==
'*' && ptrptr && *ptrptr)
1317 void **array= (
void**)*(ptrptr);
1323 if (np) array[n]= np;
1335 if (oldStruct[0]>=firstStructType)
1345 for (
int i=0;i<recursion;i++)
1352 printf(
"<%s type=\"%s\" count=%d>\n",cleanName,memType, arrayLen);
1355 printf(
"<%s type=\"%s\">\n",cleanName,memType);
1359 for (
int i=0;i<arrayLen;i++)
1363 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1365 for (
int i=0;i<recursion;i++)
1369 printf(
"</%s>\n",cleanName);
1379 printf(
"too long\n");
1384 bool isIntegerType = (strcmp(memType,
"char")==0) || (strcmp(memType,
"int")==0) || (strcmp(memType,
"short")==0);
1388 const char* newtype=
"int";
1391 char* tmp = elemPtr;
1392 dbPtr = &dbarray[0];
1399 getElement(arrayLen, newtype,memType, tmp, (
char*)dbPtr);
1400 for (i=0;i<recursion;i++)
1403 printf(
"<%s type=\"%s\">",cleanName,memType);
1405 printf(
"<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
1406 for (i=0;i<arrayLen;i++)
1407 printf(
" %d ",dbPtr[i]);
1408 printf(
"</%s>\n",cleanName);
1412 const char* newtype=
"double";
1415 char* tmp = elemPtr;
1416 dbPtr = &dbarray[0];
1420 getElement(arrayLen, newtype,memType, tmp, (
char*)dbPtr);
1421 for (i=0;i<recursion;i++)
1428 printf(
"<%s type=\"%s\">",memName,memType);
1432 printf(
"<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
1434 for (i=0;i<arrayLen;i++)
1435 printf(
" %f ",dbPtr[i]);
1436 printf(
"</%s>\n",cleanName);
1471 printf(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
1473 printf(
"<bullet_physics version=%d itemcount = %d>\n",
btGetVersion(), numitems);
1475 for (
int i=0;i<
m_chunks.size();i++)
1483 char* oldType = fileDna->
getType(oldStruct[0]);
1485 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1486 printf(
" <%s pointer=%d>\n",oldType,dataChunk.
oldPtr);
1490 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1491 printf(
" </%s>\n",oldType);
1497 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1499 printf(
"</bullet_physics>\n");
1535 char* codeptr = (
char*)&dataChunk.
code;
1536 char codestr[5] = {codeptr[0],codeptr[1],codeptr[2],codeptr[3],0};
1538 short* newStruct = dna->
getStruct(dataChunk.dna_nr);
1539 char* typeName = dna->
getType(newStruct[0]);
1540 printf(
"%3d: %s ",i,typeName);
1542 printf(
"code=%s ",codestr);
1544 printf(
"ptr=%p ",dataChunk.oldPtr);
1545 printf(
"len=%d ",dataChunk.len);
1546 printf(
"nr=%d ",dataChunk.nr);
1547 if (dataChunk.nr!=1)
1562 ifd.just_print_it = 1;
1563 for (i=0; i<bf->m_blocks.size(); ++i)
1565 BlendBlock* bb = bf->m_blocks[i];
1566 printf(
"tag='%s'\tptr=%p\ttype=%s\t[%4d]", bb->tag, bb,bf->types[bb->type_index].name,bb->m_array_entries_.size());
1567 block_ID_finder(bb, bf, &ifd);
1579 for (
int i=0;i<
m_chunks.size();i++)
1584 short *oldStruct,*curStruct;
1585 char *oldType, *newType;
1586 int oldLen, curLen, reverseOld;
1589 oldType = fileDna->
getType(oldStruct[0]);
1590 oldLen = fileDna->
getLength(oldStruct[0]);
1595 if ((reverseOld!=-1))
1603 assert((strcmp(oldType, newType)==0) &&
"internal error, struct mismatch!");
1607 dataChunk.
dna_nr = reverseOld;
1608 if (strcmp(
"Link",oldType)!=0)
1610 dataChunk.
len = curLen * dataChunk.
nr;
1617 fwrite(&dataChunk,
sizeof(
bChunkInd),1,fp);
1621 short int* curStruct1;
1623 assert(curStruct1 == curStruct);
1628 fwrite(cur,dataChunk.
len,1,fp);
1631 printf(
"serious error, struct mismatch: don't write\n");
1642 bool varies =
false;
1668 if ((chunk.
code & 0xFFFF)==0)
1677 memcpy(dataChunk, &chunk,
sizeof(
bChunkInd));
1686 if ((c.
code & 0xFFFF)==0)
1694 memcpy(dataChunk, &c,
sizeof(
bChunkInd));
1727 if ((chunk.
code & 0xFFFF)==0)
1735 memcpy(dataChunk, &chunk,
sizeof(
bChunkInd));
1744 if ((c.
code & 0xFFFF)==0)
1751 memcpy(dataChunk, &c,
sizeof(
bChunkInd));
1755 if (dataChunk->
len < 0)
1759 print (
"----------");
1760 print (dataChunk->
code);
1761 print (dataChunk->
len);
1762 print (dataChunk->old);
1763 print (dataChunk->
dna_nr);
1764 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)
char * readStruct(char *head, class bChunkInd &chunk)
virtual void parseData()=0
const Value * find(const Key &key) const
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)
const T & at(int n) const
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)
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)
int size() const
return the number of elements in the array
bPtrMap & getLibPointers()
#define getEle(value, current, type, cast, size, ptr)
btAlignedObjectArray< bChunkInd > m_chunks
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)
virtual void writeChunks(FILE *fp, bool fixupPointers)
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()