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);
    90 bFile::bFile( 
char *memoryBuffer, 
int len, 
const char headerString[7])
   100         for (
int i=0;i<7;i++)
   147         if (header[6] == 
'd')
   152         char *ver = header+9;
   160         littleEndian= ((
char*)&littleEndian)[0];
   174                 if (littleEndian ==1)
   219                 char *tempBuffer = blenderData;
   225                         if (!
mDataStart && strncmp(tempBuffer, 
"REND", 4)==0)
   228                         if (strncmp(tempBuffer, 
"DNA1", 4)==0)
   242                         else if (strncmp(tempBuffer, 
"SDNANAME", 8) ==0)
   244                                 dna.
oldPtr = blenderData + i;
   245                                 dna.
len = mFileLen-i;
   292         littleEndian= ((
char*)&littleEndian)[0];
   334         const char s[] = 
"SoftBodyMaterialData";
   336         if (strncmp((
char*)&dataChunk.
code,
"ARAY",4)==0)
   340                 if (strncmp(oldType,s,szs)==0)
   349         for (
int i=0; i<dataChunk.
nr; i++)
   358         const bool VOID_IS_8 = ((
sizeof(
void*)==8));
   364                         if ((c->
code & 0xFFFF)==0)
   372                         if ((c->
code & 0xFFFF)==0)
   384                         if ((c->
code & 0xFFFF)==0)
   393                         if ((c->
code & 0xFFFF)==0)
   411         char* data = &ptr[offset];
   414         int *intPtr=0;
short *shtPtr=0;
   415         char *cp = 0;
int dataLen =0;
   426         if (strncmp(data, 
"SDNA", 4)==0)
   434                 if (strncmp(data+4, 
"SDNA", 4)==0)
   457         for ( i=0; i<dataLen; i++)
   475         assert(strncmp(cp, 
"TYPE", 4)==0); intPtr++;
   487         for ( i=0; i<dataLen; i++)
   503         assert(strncmp(cp, 
"TLEN", 4)==0); intPtr++;
   506         shtPtr = (
short*)intPtr;
   507         for ( i=0; i<dataLen; i++, shtPtr++)
   527         intPtr = (
int*)shtPtr;
   529         assert(strncmp(cp, 
"STRC", 4)==0); 
   542         shtPtr = (
short*)intPtr;
   543         for ( i=0; i<dataLen; i++)
   555                         for (
int a=0; a<len; a++, shtPtr+=2)
   569         FILE* f = fopen(fileName,
"wb");
   581         littleEndian= ((
char*)&littleEndian)[0];
   604         bool ignoreEndianFlag = 
true;
   610         char *dataPtrHead = 0;
   628                                 swap(dataPtrHead, dataChunk,ignoreEndianFlag);
   645                 mFlags &= ~FD_ENDIAN_SWAP;
   659         bool ignoreEndianFlag = 
false;
   662                 swap(head, dataChunk, ignoreEndianFlag);
   669                 short *oldStruct,*curStruct;
   670                 char *oldType, *newType;
   671                 int oldLen, curLen, reverseOld;
   681                         if ((strcmp(oldType,
"btQuantizedBvhNodeData")==0)&&oldLen==20)
   685                         if ((strcmp(oldType,
"btShortIntIndexData")==0))
   688                         char *dataAlloc = 
new char[(dataChunk.
nr*allocLen)+1];
   689                                 memset(dataAlloc, 0, (dataChunk.
nr*allocLen)+1);
   690                                 short* dest = (
short*) dataAlloc;
   691                                 const short* src = (
short*) head;
   692                                 for (
int i=0;i<dataChunk.
nr;i++)
   695                                         if (
mFlags &FD_ENDIAN_SWAP)
   708                 if (strcmp(
"Link",oldType)!=0)
   712                         if ((reverseOld!=-1))
   725                                 assert((strcmp(oldType, newType)==0) && 
"internal error, struct mismatch!");
   731                 int allocLen = (curLen);
   732                         char *dataAlloc = 
new char[(dataChunk.
nr*allocLen)+1];
   733                                 memset(dataAlloc, 0, (dataChunk.
nr*allocLen));
   738                                 char *cur = dataAlloc;
   740                                 for (
int block=0; block<dataChunk.
nr; block++)
   742                                         bool fixupPointers = 
true;
   758 #ifdef DEBUG_EQUAL_STRUCTS   763                 printf(
"%s equal structure, just memcpy\n",oldType);
   768         char *dataAlloc = 
new char[(dataChunk.
len)+1];
   769         memset(dataAlloc, 0, dataChunk.
len+1);
   775         memcpy(dataAlloc, head, dataChunk.
len);
   784         if (old_dna == -1) 
return;
   785         if (new_dna == -1) 
return;
   793                 memcpy(strcPtr, dtPtr, len);
   798         char *memType, *memName, *cpc, *cpo;
   799         short *fileStruct, *filePtrOld, *memoryStruct, *firstStruct;
   800         int elementLength, 
size, revType, old_nr, new_nr, fpLen;
   801         short firstStructType;
   807         firstStruct = fileStruct;
   810         filePtrOld = fileStruct;
   814         elementLength = memoryStruct[1];
   817         cpc = strcPtr; cpo = 0;
   818         for (
int ele=0; ele<elementLength; ele++, memoryStruct+=2)
   827                 if (revType != -1 && memoryStruct[0]>=firstStructType && memName[0] != 
'*')
   829                         cpo = 
getFileElement(firstStruct, memName, memType, dtPtr, &filePtrOld);
   838                                         parseStruct(cpc, cpo, old_nr, new_nr,fixupPointers);
   844                                         for (
int i=0;i<arrayLen;i++)
   846                                                 parseStruct(tmpCpc, tmpCpo, old_nr, new_nr,fixupPointers);
   847                                                 tmpCpc += size/arrayLen;
   848                                                 tmpCpo += fpLen/arrayLen;
   868 static void getElement(
int arrayLen, 
const char *cur, 
const char *old, 
char *oldPtr, 
char *curData)
   870 #define getEle(value, current, type, cast, size, ptr)\   871         if (strcmp(current, type)==0)\   873                 value = (*(cast*)ptr);\   877 #define setEle(value, current, type, cast, size, ptr)\   878         if (strcmp(current, type)==0)\   880                 (*(cast*)ptr) = (cast)value;\   885         for (
int i=0; i<arrayLen; i++)
   887                 getEle(value, old, 
"char",   
char,   
sizeof(
char),   oldPtr);
   888                 setEle(value, cur, 
"char",   
char,   
sizeof(
char),   curData);
   889                 getEle(value, old, 
"short",  
short,  
sizeof(
short),  oldPtr);
   890                 setEle(value, cur, 
"short",  
short,  
sizeof(
short),  curData);
   891                 getEle(value, old, 
"ushort",  
unsigned short,  
sizeof(
unsigned short),  oldPtr);
   892                 setEle(value, cur, 
"ushort",  
unsigned short,  
sizeof(
unsigned short),  curData);
   893                 getEle(value, old, 
"int",    
int,    
sizeof(
int),    oldPtr);
   894                 setEle(value, cur, 
"int",    
int,    
sizeof(
int),    curData);
   895                 getEle(value, old, 
"long",   
int,    
sizeof(
int),    oldPtr);
   896                 setEle(value, cur, 
"long",   
int,    
sizeof(
int),    curData);
   897                 getEle(value, old, 
"float",  
float,  
sizeof(
float),  oldPtr);
   898                 setEle(value, cur, 
"float",  
float,  
sizeof(
float),  curData);
   899                 getEle(value, old, 
"double", 
double, 
sizeof(
double), oldPtr);
   900                 setEle(value, cur, 
"double", 
double, 
sizeof(
double), curData);
   910                 if (type == 2 || type == 3)
   912                         short *sp = (
short*)data;
   913                         for (
int i=0; i<arraySize; i++)
   919                 if (type>3 && type <8)
   923                         for (
int i=0; i<arraySize; i++)
   948         if (ptrFile == ptrMem)
   950                 memcpy(dst, src, ptrMem);
   952         else if (ptrMem==4 && ptrFile==8)
   970                         *((
int*)dst) = (int)(longValue>>3);
   974         else if (ptrMem==8 && ptrFile==4)
   984                         *((
long64*)dst)= *((
int*)src);
   989                 printf (
"%d %d\n", ptrFile,ptrMem);
   990                 assert(0 && 
"Invalid pointer len");
   998 void bFile::getMatchingFileDNA(
short* dna_addr, 
const char* lookupName,  
const char* lookupType, 
char *strcData, 
char *data, 
bool fixupPointers)
  1004         int len = dna_addr[1];
  1007         for (
int i=0; i<len; i++, dna_addr+=2)
  1018                         if ((strcmp(type,
"short")==0)&&(strcmp(name,
"int")==0))
  1024                 if (strcmp(lookupName, name)==0)
  1045                                                 cpc = (
char*)strcData;
  1048                                                 for (
int a=0; a<arrayLen; a++)
  1071                         else if (strcmp(type, lookupType)==0)
  1072                                 memcpy(strcData, data, eleLen);
  1074                                 getElement(arrayLen, lookupType, type, data, strcData);
  1087         short *old = firstStruct;
  1088         int elementLength = old[1];
  1091         for (
int i=0; i<elementLength; i++, old+=2)
  1097                 if (strcmp(lookupName, name)==0)
  1099                         if (strcmp(type, lookupType)==0)
  1116         if (dna_nr == -1) 
return;
  1121         int elementLen= strc[1];
  1127         for (
int i=0; i<elementLen; i++, strc+=2)
  1133                 if (strc[0] >= first && name[0]!=
'*')
  1143                                 for (
int i=0;i<arrayLen;i++)
  1146                                         tmpBuf+=size/arrayLen;
  1155                         swapData(buf, strc[0], arrayLen,ignoreEndianFlag);
  1170                 void** ptrptr = (
void**) cur;
  1171                 void* ptr = *ptrptr;
  1187                 void** ptrptr = (
void**)cur;
  1196                         int blockLen = block->
len / ptrFile;
  1201                                 char *newPtr = 
new char[blockLen * ptrMem];
  1203                                 memset(newPtr, 0, blockLen * ptrMem);
  1205                                 void **onarray = (
void**)onptr;
  1206                                 char *oldPtr = (
char*)onarray;
  1209                                 while (blockLen-- > 0)
  1214                                         void **tptr = (
void**)(newPtr + p * ptrMem);
  1234         short oldLen = fileDna->
getLength(oldStruct[0]);
  1238         for (
int block=0; block<dataChunk.
nr; block++)
  1253         short   firstStructType = fileDna->
getStruct(0)[0];
  1256         char* elemPtr= strcPtr;
  1258         short int* oldStruct = fileDna->
getStruct(dna_nr);
  1260         int elementLength = oldStruct[1];
  1265         for (
int ele=0; ele<elementLength; ele++, oldStruct+=2)
  1268                 memType = fileDna->
getType(oldStruct[0]);
  1269                 memName = fileDna->
getName(oldStruct[1]);
  1274                 if (memName[0] == 
'*')
  1278                                 void **array= (
void**)elemPtr;
  1279                                 for (
int a=0; a<arrayLen; a++)
  1283                                                 for (
int i=0;i<recursion;i++)
  1288                                                 printf(
"<%s type=\"pointer\"> ",&memName[1]);
  1289                                                 printf(
"%p ", array[a]);
  1290                                                 printf(
"</%s>\n",&memName[1]);
  1298                                 void** ptrptr = (
void**) elemPtr;
  1299                                 void* ptr = *ptrptr;
  1302                                         for (
int i=0;i<recursion;i++)
  1306                                         printf(
"<%s type=\"pointer\"> ",&memName[1]);
  1308                                         printf(
"</%s>\n",&memName[1]);
  1316                                         if (memName[1] == 
'*' && ptrptr && *ptrptr)
  1319                                                 void **array= (
void**)*(ptrptr);
  1325                                                         if (np) array[n]= np;
  1337                         if (oldStruct[0]>=firstStructType) 
  1347                                         for (
int i=0;i<recursion;i++)
  1354                                                 printf(
"<%s type=\"%s\" count=%d>\n",cleanName,memType, arrayLen);
  1357                                                 printf(
"<%s type=\"%s\">\n",cleanName,memType);
  1361                                 for (
int i=0;i<arrayLen;i++)
  1365                                 if (verboseMode & FD_VERBOSE_EXPORT_XML)
  1367                                         for (
int i=0;i<recursion;i++)
  1371                                         printf(
"</%s>\n",cleanName);
  1381                                                 printf(
"too long\n");
  1386                                                 bool isIntegerType = (strcmp(memType,
"char")==0) || (strcmp(memType,
"int")==0) || (strcmp(memType,
"short")==0);
  1390                                                         const char* newtype=
"int";
  1393                                                         char* tmp = elemPtr;
  1394                                                         dbPtr = &dbarray[0];
  1401                                                                 getElement(arrayLen, newtype,memType, tmp, (
char*)dbPtr);
  1402                                                                 for (i=0;i<recursion;i++)
  1405                                                                         printf(
"<%s type=\"%s\">",cleanName,memType);
  1407                                                                         printf(
"<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
  1408                                                                 for (i=0;i<arrayLen;i++)
  1409                                                                         printf(
" %d ",dbPtr[i]);
  1410                                                                 printf(
"</%s>\n",cleanName);
  1414                                                         const char* newtype=
"double";
  1417                                                         char* tmp = elemPtr;
  1418                                                         dbPtr = &dbarray[0];
  1422                                                                 getElement(arrayLen, newtype,memType, tmp, (
char*)dbPtr);
  1423                                                                 for (i=0;i<recursion;i++)
  1430                                                                         printf(
"<%s type=\"%s\">",memName,memType);
  1434                                                                         printf(
"<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
  1436                                                                 for (i=0;i<arrayLen;i++)
  1437                                                                         printf(
" %f ",dbPtr[i]);
  1438                                                                 printf(
"</%s>\n",cleanName);
  1473                         printf(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
  1475                         printf(
"<bullet_physics version=%d itemcount = %d>\n", 
btGetVersion(), numitems);
  1477                 for (
int i=0;i<
m_chunks.size();i++)
  1485                                 char* oldType = fileDna->
getType(oldStruct[0]);
  1487                                 if (verboseMode & FD_VERBOSE_EXPORT_XML)
  1488                                         printf(
" <%s pointer=%p>\n",oldType,dataChunk.
oldPtr);
  1492                                 if (verboseMode & FD_VERBOSE_EXPORT_XML)
  1493                                         printf(
" </%s>\n",oldType);
  1499                         if (verboseMode & FD_VERBOSE_EXPORT_XML)
  1501                                 printf(
"</bullet_physics>\n");
  1537                 char* codeptr = (
char*)&dataChunk.
code;
  1538                 char codestr[5] = {codeptr[0],codeptr[1],codeptr[2],codeptr[3],0};
  1540                 short* newStruct = dna->
getStruct(dataChunk.dna_nr);
  1541                 char* typeName = dna->
getType(newStruct[0]);
  1542                 printf(
"%3d: %s  ",i,typeName);
  1544                 printf(
"code=%s  ",codestr);
  1546                 printf(
"ptr=%p  ",dataChunk.oldPtr);
  1547                 printf(
"len=%d  ",dataChunk.len);
  1548                 printf(
"nr=%d  ",dataChunk.nr);
  1549                 if (dataChunk.nr!=1)
  1564         ifd.just_print_it = 1;
  1565         for (i=0; i<bf->m_blocks.size(); ++i) 
  1567                 BlendBlock* bb = bf->m_blocks[i];
  1568                 printf(
"tag='%s'\tptr=%p\ttype=%s\t[%4d]",              bb->tag, bb,bf->types[bb->type_index].name,bb->m_array_entries_.size());
  1569                 block_ID_finder(bb, bf, &ifd);
  1581         for (
int i=0;i<
m_chunks.size();i++)
  1586                 short *oldStruct,*curStruct;
  1587                 char *oldType, *newType;
  1588                 int  curLen, reverseOld;
  1591                 oldType = fileDna->
getType(oldStruct[0]);
  1597                 if ((reverseOld!=-1))
  1605                         assert((strcmp(oldType, newType)==0) && 
"internal error, struct mismatch!");
  1609                         dataChunk.
dna_nr = reverseOld;
  1610                         if (strcmp(
"Link",oldType)!=0)
  1612                                 dataChunk.
len = curLen * dataChunk.
nr;
  1619                         fwrite(&dataChunk,
sizeof(
bChunkInd),1,fp);
  1623                         short int* curStruct1;
  1625                         assert(curStruct1 == curStruct);
  1630                         fwrite(cur,dataChunk.
len,1,fp);
  1633                         printf(
"serious error, struct mismatch: don't write\n");
  1644         bool varies = 
false;
  1670                                 if ((chunk.
code & 0xFFFF)==0)
  1679                         memcpy(dataChunk, &chunk, 
sizeof(
bChunkInd));
  1688                                 if ((c.
code & 0xFFFF)==0)
  1696                         memcpy(dataChunk, &c, 
sizeof(
bChunkInd));
  1729                                 if ((chunk.
code & 0xFFFF)==0)
  1737                         memcpy(dataChunk, &chunk, 
sizeof(
bChunkInd));
  1746                                 if ((c.
code & 0xFFFF)==0)
  1753                         memcpy(dataChunk, &c, 
sizeof(
bChunkInd));
  1757         if (dataChunk->
len < 0)
  1761         print (
"----------");
  1762         print (dataChunk->
code);
  1763         print (dataChunk->
len);
  1764         print (dataChunk->old);
  1765         print (dataChunk->
dna_nr);
  1766         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()