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);
  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)
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()