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++)
474 assert(strncmp(cp,
"TYPE", 4)==0); intPtr++;
486 for ( i=0; i<dataLen; i++)
502 assert(strncmp(cp,
"TLEN", 4)==0); intPtr++;
505 shtPtr = (
short*)intPtr;
506 for ( i=0; i<dataLen; i++, shtPtr++)
526 intPtr = (
int*)shtPtr;
528 assert(strncmp(cp,
"STRC", 4)==0);
541 shtPtr = (
short*)intPtr;
542 for ( i=0; i<dataLen; i++)
554 for (
int a=0; a<len; a++, shtPtr+=2)
568 FILE* f = fopen(fileName,
"wb");
580 littleEndian= ((
char*)&littleEndian)[0];
603 bool ignoreEndianFlag =
true;
609 char *dataPtrHead = 0;
627 swap(dataPtrHead, dataChunk,ignoreEndianFlag);
644 mFlags &= ~FD_ENDIAN_SWAP;
658 bool ignoreEndianFlag =
false;
661 swap(head, dataChunk, ignoreEndianFlag);
668 short *oldStruct,*curStruct;
669 char *oldType, *newType;
670 int oldLen, curLen, reverseOld;
680 if ((strcmp(oldType,
"btQuantizedBvhNodeData")==0)&&oldLen==20)
684 if ((strcmp(oldType,
"btShortIntIndexData")==0))
687 char *dataAlloc =
new char[(dataChunk.
nr*allocLen)+1];
688 memset(dataAlloc, 0, (dataChunk.
nr*allocLen)+1);
689 short* dest = (
short*) dataAlloc;
690 const short* src = (
short*) head;
691 for (
int i=0;i<dataChunk.
nr;i++)
694 if (
mFlags &FD_ENDIAN_SWAP)
707 if (strcmp(
"Link",oldType)!=0)
711 if ((reverseOld!=-1))
724 assert((strcmp(oldType, newType)==0) &&
"internal error, struct mismatch!");
730 int allocLen = (curLen);
731 char *dataAlloc =
new char[(dataChunk.
nr*allocLen)+1];
732 memset(dataAlloc, 0, (dataChunk.
nr*allocLen));
737 char *cur = dataAlloc;
739 for (
int block=0; block<dataChunk.
nr; block++)
741 bool fixupPointers =
true;
757 #ifdef DEBUG_EQUAL_STRUCTS 762 printf(
"%s equal structure, just memcpy\n",oldType);
767 char *dataAlloc =
new char[(dataChunk.
len)+1];
768 memset(dataAlloc, 0, dataChunk.
len+1);
774 memcpy(dataAlloc, head, dataChunk.
len);
783 if (old_dna == -1)
return;
784 if (new_dna == -1)
return;
792 memcpy(strcPtr, dtPtr, len);
797 char *memType, *memName, *cpc, *cpo;
798 short *fileStruct, *filePtrOld, *memoryStruct, *firstStruct;
799 int elementLength,
size, revType, old_nr, new_nr, fpLen;
800 short firstStructType;
806 firstStruct = fileStruct;
809 filePtrOld = fileStruct;
813 elementLength = memoryStruct[1];
816 cpc = strcPtr; cpo = 0;
817 for (
int ele=0; ele<elementLength; ele++, memoryStruct+=2)
826 if (revType != -1 && memoryStruct[0]>=firstStructType && memName[0] !=
'*')
828 cpo =
getFileElement(firstStruct, memName, memType, dtPtr, &filePtrOld);
837 parseStruct(cpc, cpo, old_nr, new_nr,fixupPointers);
843 for (
int i=0;i<arrayLen;i++)
845 parseStruct(tmpCpc, tmpCpo, old_nr, new_nr,fixupPointers);
846 tmpCpc += size/arrayLen;
847 tmpCpo += fpLen/arrayLen;
867 static void getElement(
int arrayLen,
const char *cur,
const char *old,
char *oldPtr,
char *curData)
869 #define getEle(value, current, type, cast, size, ptr)\ 870 if (strcmp(current, type)==0)\ 872 value = (*(cast*)ptr);\ 876 #define setEle(value, current, type, cast, size, ptr)\ 877 if (strcmp(current, type)==0)\ 879 (*(cast*)ptr) = (cast)value;\ 884 for (
int i=0; i<arrayLen; i++)
886 getEle(value, old,
"char",
char,
sizeof(
char), oldPtr);
887 setEle(value, cur,
"char",
char,
sizeof(
char), curData);
888 getEle(value, old,
"short",
short,
sizeof(
short), oldPtr);
889 setEle(value, cur,
"short",
short,
sizeof(
short), curData);
890 getEle(value, old,
"ushort",
unsigned short,
sizeof(
unsigned short), oldPtr);
891 setEle(value, cur,
"ushort",
unsigned short,
sizeof(
unsigned short), curData);
892 getEle(value, old,
"int",
int,
sizeof(
int), oldPtr);
893 setEle(value, cur,
"int",
int,
sizeof(
int), curData);
894 getEle(value, old,
"long",
int,
sizeof(
int), oldPtr);
895 setEle(value, cur,
"long",
int,
sizeof(
int), curData);
896 getEle(value, old,
"float",
float,
sizeof(
float), oldPtr);
897 setEle(value, cur,
"float",
float,
sizeof(
float), curData);
898 getEle(value, old,
"double",
double,
sizeof(
double), oldPtr);
899 setEle(value, cur,
"double",
double,
sizeof(
double), curData);
909 if (type == 2 || type == 3)
911 short *sp = (
short*)data;
912 for (
int i=0; i<arraySize; i++)
918 if (type>3 && type <8)
922 for (
int i=0; i<arraySize; i++)
947 if (ptrFile == ptrMem)
949 memcpy(dst, src, ptrMem);
951 else if (ptrMem==4 && ptrFile==8)
969 *((
int*)dst) = (int)(longValue>>3);
973 else if (ptrMem==8 && ptrFile==4)
983 *((
long64*)dst)= *((
int*)src);
988 printf (
"%d %d\n", ptrFile,ptrMem);
989 assert(0 &&
"Invalid pointer len");
997 void bFile::getMatchingFileDNA(
short* dna_addr,
const char* lookupName,
const char* lookupType,
char *strcData,
char *data,
bool fixupPointers)
1003 int len = dna_addr[1];
1006 for (
int i=0; i<len; i++, dna_addr+=2)
1017 if ((strcmp(type,
"short")==0)&&(strcmp(name,
"int")==0))
1023 if (strcmp(lookupName, name)==0)
1044 cpc = (
char*)strcData;
1047 for (
int a=0; a<arrayLen; a++)
1070 else if (strcmp(type, lookupType)==0)
1071 memcpy(strcData, data, eleLen);
1073 getElement(arrayLen, lookupType, type, data, strcData);
1086 short *old = firstStruct;
1087 int elementLength = old[1];
1090 for (
int i=0; i<elementLength; i++, old+=2)
1096 if (strcmp(lookupName, name)==0)
1098 if (strcmp(type, lookupType)==0)
1115 if (dna_nr == -1)
return;
1120 int elementLen= strc[1];
1126 for (
int i=0; i<elementLen; i++, strc+=2)
1132 if (strc[0] >= first && name[0]!=
'*')
1142 for (
int i=0;i<arrayLen;i++)
1145 tmpBuf+=size/arrayLen;
1154 swapData(buf, strc[0], arrayLen,ignoreEndianFlag);
1169 void** ptrptr = (
void**) cur;
1170 void* ptr = *ptrptr;
1186 void** ptrptr = (
void**)cur;
1195 int blockLen = block->
len / ptrFile;
1200 char *newPtr =
new char[blockLen * ptrMem];
1202 memset(newPtr, 0, blockLen * ptrMem);
1204 void **onarray = (
void**)onptr;
1205 char *oldPtr = (
char*)onarray;
1208 while (blockLen-- > 0)
1213 void **tptr = (
void**)(newPtr + p * ptrMem);
1233 short oldLen = fileDna->
getLength(oldStruct[0]);
1237 for (
int block=0; block<dataChunk.
nr; block++)
1252 short firstStructType = fileDna->
getStruct(0)[0];
1255 char* elemPtr= strcPtr;
1257 short int* oldStruct = fileDna->
getStruct(dna_nr);
1259 int elementLength = oldStruct[1];
1264 for (
int ele=0; ele<elementLength; ele++, oldStruct+=2)
1267 memType = fileDna->
getType(oldStruct[0]);
1268 memName = fileDna->
getName(oldStruct[1]);
1273 if (memName[0] ==
'*')
1277 void **array= (
void**)elemPtr;
1278 for (
int a=0; a<arrayLen; a++)
1282 for (
int i=0;i<recursion;i++)
1287 printf(
"<%s type=\"pointer\"> ",&memName[1]);
1288 printf(
"%d ", array[a]);
1289 printf(
"</%s>\n",&memName[1]);
1297 void** ptrptr = (
void**) elemPtr;
1298 void* ptr = *ptrptr;
1301 for (
int i=0;i<recursion;i++)
1305 printf(
"<%s type=\"pointer\"> ",&memName[1]);
1307 printf(
"</%s>\n",&memName[1]);
1315 if (memName[1] ==
'*' && ptrptr && *ptrptr)
1318 void **array= (
void**)*(ptrptr);
1324 if (np) array[n]= np;
1336 if (oldStruct[0]>=firstStructType)
1346 for (
int i=0;i<recursion;i++)
1353 printf(
"<%s type=\"%s\" count=%d>\n",cleanName,memType, arrayLen);
1356 printf(
"<%s type=\"%s\">\n",cleanName,memType);
1360 for (
int i=0;i<arrayLen;i++)
1364 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1366 for (
int i=0;i<recursion;i++)
1370 printf(
"</%s>\n",cleanName);
1380 printf(
"too long\n");
1385 bool isIntegerType = (strcmp(memType,
"char")==0) || (strcmp(memType,
"int")==0) || (strcmp(memType,
"short")==0);
1389 const char* newtype=
"int";
1392 char* tmp = elemPtr;
1393 dbPtr = &dbarray[0];
1400 getElement(arrayLen, newtype,memType, tmp, (
char*)dbPtr);
1401 for (i=0;i<recursion;i++)
1404 printf(
"<%s type=\"%s\">",cleanName,memType);
1406 printf(
"<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
1407 for (i=0;i<arrayLen;i++)
1408 printf(
" %d ",dbPtr[i]);
1409 printf(
"</%s>\n",cleanName);
1413 const char* newtype=
"double";
1416 char* tmp = elemPtr;
1417 dbPtr = &dbarray[0];
1421 getElement(arrayLen, newtype,memType, tmp, (
char*)dbPtr);
1422 for (i=0;i<recursion;i++)
1429 printf(
"<%s type=\"%s\">",memName,memType);
1433 printf(
"<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
1435 for (i=0;i<arrayLen;i++)
1436 printf(
" %f ",dbPtr[i]);
1437 printf(
"</%s>\n",cleanName);
1472 printf(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
1474 printf(
"<bullet_physics version=%d itemcount = %d>\n",
btGetVersion(), numitems);
1476 for (
int i=0;i<
m_chunks.size();i++)
1484 char* oldType = fileDna->
getType(oldStruct[0]);
1486 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1487 printf(
" <%s pointer=%d>\n",oldType,dataChunk.
oldPtr);
1491 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1492 printf(
" </%s>\n",oldType);
1498 if (verboseMode & FD_VERBOSE_EXPORT_XML)
1500 printf(
"</bullet_physics>\n");
1536 char* codeptr = (
char*)&dataChunk.
code;
1537 char codestr[5] = {codeptr[0],codeptr[1],codeptr[2],codeptr[3],0};
1539 short* newStruct = dna->
getStruct(dataChunk.dna_nr);
1540 char* typeName = dna->
getType(newStruct[0]);
1541 printf(
"%3d: %s ",i,typeName);
1543 printf(
"code=%s ",codestr);
1545 printf(
"ptr=%p ",dataChunk.oldPtr);
1546 printf(
"len=%d ",dataChunk.len);
1547 printf(
"nr=%d ",dataChunk.nr);
1548 if (dataChunk.nr!=1)
1563 ifd.just_print_it = 1;
1564 for (i=0; i<bf->m_blocks.size(); ++i)
1566 BlendBlock* bb = bf->m_blocks[i];
1567 printf(
"tag='%s'\tptr=%p\ttype=%s\t[%4d]", bb->tag, bb,bf->types[bb->type_index].name,bb->m_array_entries_.size());
1568 block_ID_finder(bb, bf, &ifd);
1580 for (
int i=0;i<
m_chunks.size();i++)
1585 short *oldStruct,*curStruct;
1586 char *oldType, *newType;
1587 int curLen, reverseOld;
1590 oldType = fileDna->
getType(oldStruct[0]);
1596 if ((reverseOld!=-1))
1604 assert((strcmp(oldType, newType)==0) &&
"internal error, struct mismatch!");
1608 dataChunk.
dna_nr = reverseOld;
1609 if (strcmp(
"Link",oldType)!=0)
1611 dataChunk.
len = curLen * dataChunk.
nr;
1618 fwrite(&dataChunk,
sizeof(
bChunkInd),1,fp);
1622 short int* curStruct1;
1624 assert(curStruct1 == curStruct);
1629 fwrite(cur,dataChunk.
len,1,fp);
1632 printf(
"serious error, struct mismatch: don't write\n");
1643 bool varies =
false;
1669 if ((chunk.
code & 0xFFFF)==0)
1678 memcpy(dataChunk, &chunk,
sizeof(
bChunkInd));
1687 if ((c.
code & 0xFFFF)==0)
1695 memcpy(dataChunk, &c,
sizeof(
bChunkInd));
1728 if ((chunk.
code & 0xFFFF)==0)
1736 memcpy(dataChunk, &chunk,
sizeof(
bChunkInd));
1745 if ((c.
code & 0xFFFF)==0)
1752 memcpy(dataChunk, &c,
sizeof(
bChunkInd));
1756 if (dataChunk->
len < 0)
1760 print (
"----------");
1761 print (dataChunk->
code);
1762 print (dataChunk->
len);
1763 print (dataChunk->old);
1764 print (dataChunk->
dna_nr);
1765 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
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)
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
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)
virtual void writeChunks(FILE *fp, bool fixupPointers)
bool flagEqual(int dna_nr)
T * btAlignPointer(T *unalignedPtr, size_t alignment)
align a pointer to the provided alignment, upwards
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()