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] == 
'[')
 
   45                         buffer[i] = memName[i];
 
   65         for (
int i = 0; i < 7; 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])
 
   99         for (
int i = 0; i < 7; i++)
 
  139         if (header[6] == 
'd')
 
  144         char *ver = header + 9;
 
  151         int littleEndian = 1;
 
  152         littleEndian = ((
char *)&littleEndian)[0];
 
  155         if (header[7] == 
'-')
 
  165         if (header[8] == 
'V')
 
  167                 if (littleEndian == 1)
 
  170         else if (littleEndian == 0)
 
  201                 setFileDNA(verboseMode, memDna, memDnaLength);
 
  210                 char *tempBuffer = blenderData;
 
  216                         if (!
mDataStart && strncmp(tempBuffer, 
"REND", 4) == 0)
 
  219                         if (strncmp(tempBuffer, 
"DNA1", 4) == 0)
 
  235                         else if (strncmp(tempBuffer, 
"SDNANAME", 8) == 0)
 
  237                                 dna.
oldPtr = blenderData + i;
 
  279         int littleEndian = 1;
 
  280         littleEndian = ((
char *)&littleEndian)[0];
 
  312         const char s[] = 
"SoftBodyMaterialData";
 
  314         if (strncmp((
char *)&dataChunk.
code, 
"ARAY", 4) == 0)
 
  318                 if (strncmp(oldType, s, szs) == 0)
 
  326         for (
int i = 0; i < dataChunk.
nr; i++)
 
  335         const bool VOID_IS_8 = ((
sizeof(
void *) == 8));
 
  341                         if ((c->
code & 0xFFFF) == 0)
 
  350                         if ((c->
code & 0xFFFF) == 0)
 
  362                         if ((c->
code & 0xFFFF) == 0)
 
  371                         if ((c->
code & 0xFFFF) == 0)
 
  386         char *data = &ptr[offset];
 
  393         intPtr = (
int *)data;
 
  403         if (strncmp(data, 
"SDNA", 4) == 0)
 
  411                 if (strncmp(data + 4, 
"SDNA", 4) == 0)
 
  431         for (i = 0; i < dataLen; i++)
 
  447         assert(strncmp(cp, 
"TYPE", 4) == 0);
 
  460         for (i = 0; i < dataLen; i++)
 
  476         assert(strncmp(cp, 
"TLEN", 4) == 0);
 
  479         shtPtr = (
short *)intPtr;
 
  480         for (i = 0; i < dataLen; i++, shtPtr++)
 
  500         intPtr = (
int *)shtPtr;
 
  502         assert(strncmp(cp, 
"STRC", 4) == 0);
 
  514         shtPtr = (
short *)intPtr;
 
  515         for (i = 0; i < dataLen; i++)
 
  526                         for (
int a = 0; a < len; a++, shtPtr += 2)
 
  539         FILE *f = fopen(fileName, 
"wb");
 
  549         int littleEndian = 1;
 
  550         littleEndian = ((
char *)&littleEndian)[0];
 
  567         bool ignoreEndianFlag = 
true;
 
  573         char *dataPtrHead = 0;
 
  589                         if (dataChunk.
dna_nr >= 0)
 
  591                                 swap(dataPtrHead, dataChunk, ignoreEndianFlag);
 
  620         bool ignoreEndianFlag = 
false;
 
  623                 swap(head, dataChunk, ignoreEndianFlag);
 
  628                 short *oldStruct, *curStruct;
 
  629                 char *oldType, *newType;
 
  630                 int oldLen, curLen, reverseOld;
 
  639                         if ((strcmp(oldType, 
"btQuantizedBvhNodeData") == 0) && oldLen == 20)
 
  643                         if ((strcmp(oldType, 
"btShortIntIndexData") == 0))
 
  646                                 char *dataAlloc = 
new char[(dataChunk.
nr * allocLen) + 1];
 
  647                                 memset(dataAlloc, 0, (dataChunk.
nr * allocLen) + 1);
 
  648                                 short *dest = (
short *)dataAlloc;
 
  649                                 const short *src = (
short *)head;
 
  650                                 for (
int i = 0; i < dataChunk.
nr; i++)
 
  664                 if (strcmp(
"Link", oldType) != 0)
 
  668                         if ((reverseOld != -1))
 
  679                                 assert((strcmp(oldType, newType) == 0) && 
"internal error, struct mismatch!");
 
  684                                 int allocLen = (curLen);
 
  685                                 char *dataAlloc = 
new char[(dataChunk.
nr * allocLen) + 1];
 
  686                                 memset(dataAlloc, 0, (dataChunk.
nr * allocLen));
 
  691                                 char *cur = dataAlloc;
 
  693                                 for (
int block = 0; block < dataChunk.
nr; block++)
 
  695                                         bool fixupPointers = 
true;
 
  713 #ifdef DEBUG_EQUAL_STRUCTS 
  718                 printf(
"%s equal structure, just memcpy\n", oldType);
 
  722         char *dataAlloc = 
new char[(dataChunk.
len) + 1];
 
  723         memset(dataAlloc, 0, dataChunk.
len + 1);
 
  728         memcpy(dataAlloc, head, dataChunk.
len);
 
  735         if (old_dna == -1) 
return;
 
  736         if (new_dna == -1) 
return;
 
  744                 memcpy(strcPtr, dtPtr, len);
 
  749         char *memType, *memName, *cpc, *cpo;
 
  750         short *fileStruct, *filePtrOld, *memoryStruct, *firstStruct;
 
  751         int elementLength, 
size, revType, old_nr, new_nr, fpLen;
 
  752         short firstStructType;
 
  757         firstStruct = fileStruct;
 
  759         filePtrOld = fileStruct;
 
  763         elementLength = memoryStruct[1];
 
  768         for (
int ele = 0; ele < elementLength; ele++, memoryStruct += 2)
 
  776                 if (revType != -1 && memoryStruct[0] >= firstStructType && memName[0] != 
'*')
 
  778                         cpo = 
getFileElement(firstStruct, memName, memType, dtPtr, &filePtrOld);
 
  787                                         parseStruct(cpc, cpo, old_nr, new_nr, fixupPointers);
 
  794                                         for (
int i = 0; i < arrayLen; i++)
 
  796                                                 parseStruct(tmpCpc, tmpCpo, old_nr, new_nr, fixupPointers);
 
  797                                                 tmpCpc += 
size / arrayLen;
 
  798                                                 tmpCpo += fpLen / arrayLen;
 
  816 static void getElement(
int arrayLen, 
const char *cur, 
const char *old, 
char *oldPtr, 
char *curData)
 
  818 #define getEle(value, current, type, cast, size, ptr) \ 
  819         if (strcmp(current, type) == 0)                   \ 
  821                 value = (*(cast *)ptr);                       \ 
  825 #define setEle(value, current, type, cast, size, ptr) \ 
  826         if (strcmp(current, type) == 0)                   \ 
  828                 (*(cast *)ptr) = (cast)value;                 \ 
  833         for (
int i = 0; i < arrayLen; i++)
 
  835                 getEle(value, old, 
"char", 
char, 
sizeof(
char), oldPtr);
 
  836                 setEle(value, cur, 
"char", 
char, 
sizeof(
char), curData);
 
  837                 getEle(value, old, 
"short", 
short, 
sizeof(
short), oldPtr);
 
  838                 setEle(value, cur, 
"short", 
short, 
sizeof(
short), curData);
 
  839                 getEle(value, old, 
"ushort", 
unsigned short, 
sizeof(
unsigned short), oldPtr);
 
  840                 setEle(value, cur, 
"ushort", 
unsigned short, 
sizeof(
unsigned short), curData);
 
  841                 getEle(value, old, 
"int", 
int, 
sizeof(
int), oldPtr);
 
  842                 setEle(value, cur, 
"int", 
int, 
sizeof(
int), curData);
 
  843                 getEle(value, old, 
"long", 
int, 
sizeof(
int), oldPtr);
 
  844                 setEle(value, cur, 
"long", 
int, 
sizeof(
int), curData);
 
  845                 getEle(value, old, 
"float", 
float, 
sizeof(
float), oldPtr);
 
  846                 setEle(value, cur, 
"float", 
float, 
sizeof(
float), curData);
 
  847                 getEle(value, old, 
"double", 
double, 
sizeof(
double), oldPtr);
 
  848                 setEle(value, cur, 
"double", 
double, 
sizeof(
double), curData);
 
  857                 if (type == 2 || type == 3)
 
  859                         short *sp = (
short *)data;
 
  860                         for (
int i = 0; i < arraySize; i++)
 
  866                 if (type > 3 && type < 8)
 
  870                         for (
int i = 0; i < arraySize; i++)
 
  892         if (ptrFile == ptrMem)
 
  894                 memcpy(dst, src, ptrMem);
 
  896         else if (ptrMem == 4 && ptrFile == 8)
 
  915                         *((
int *)dst) = (int)(longValue >> 3);
 
  918         else if (ptrMem == 8 && ptrFile == 4)
 
  929                         *((
long64 *)dst) = *((
int *)src);
 
  934                 printf(
"%d %d\n", ptrFile, ptrMem);
 
  935                 assert(0 && 
"Invalid pointer len");
 
  940 void bFile::getMatchingFileDNA(
short *dna_addr, 
const char *lookupName, 
const char *lookupType, 
char *strcData, 
char *data, 
bool fixupPointers)
 
  946         int len = dna_addr[1];
 
  949         for (
int i = 0; i < len; i++, dna_addr += 2)
 
  958                         if ((strcmp(type, 
"short") == 0) && (strcmp(name, 
"int") == 0))
 
  964                 if (strcmp(lookupName, name) == 0)
 
  985                                                 cpc = (
char *)strcData;
 
  988                                                 for (
int a = 0; a < arrayLen; a++)
 
 1010                         else if (strcmp(type, lookupType) == 0)
 
 1011                                 memcpy(strcData, data, eleLen);
 
 1013                                 getElement(arrayLen, lookupType, type, data, strcData);
 
 1025         short *old = firstStruct;  
 
 1026         int elementLength = old[1];
 
 1029         for (
int i = 0; i < elementLength; i++, old += 2)
 
 1035                 if (strcmp(lookupName, name) == 0)
 
 1037                         if (strcmp(type, lookupType) == 0)
 
 1053         if (dna_nr == -1) 
return;
 
 1058         int elementLen = strc[1];
 
 1064         for (
int i = 0; i < elementLen; i++, strc += 2)
 
 1070                 if (strc[0] >= first && name[0] != 
'*')
 
 1081                                 for (
int i = 0; i < arrayLen; i++)
 
 1083                                         swapStruct(old_nr, tmpBuf, ignoreEndianFlag);
 
 1084                                         tmpBuf += 
size / arrayLen;
 
 1093                         swapData(buf, strc[0], arrayLen, ignoreEndianFlag);
 
 1108                 void **ptrptr = (
void **)cur;
 
 1109                 void *ptr = *ptrptr;
 
 1125                 void **ptrptr = (
void **)cur;
 
 1133                         int blockLen = block->
len / ptrFile;
 
 1138                                 char *newPtr = 
new char[blockLen * ptrMem];
 
 1140                                 memset(newPtr, 0, blockLen * ptrMem);
 
 1142                                 void **onarray = (
void **)onptr;
 
 1143                                 char *oldPtr = (
char *)onarray;
 
 1146                                 while (blockLen-- > 0)
 
 1151                                         void **tptr = (
void **)(newPtr + p * ptrMem);
 
 1170         short oldLen = fileDna->
getLength(oldStruct[0]);
 
 1174         for (
int block = 0; block < dataChunk.
nr; block++)
 
 1187         short firstStructType = fileDna->
getStruct(0)[0];
 
 1189         char *elemPtr = strcPtr;
 
 1191         short int *oldStruct = fileDna->
getStruct(dna_nr);
 
 1193         int elementLength = oldStruct[1];
 
 1198         for (
int ele = 0; ele < elementLength; ele++, oldStruct += 2)
 
 1200                 memType = fileDna->
getType(oldStruct[0]);
 
 1201                 memName = fileDna->
getName(oldStruct[1]);
 
 1204                 if (memName[0] == 
'*')
 
 1208                                 void **array = (
void **)elemPtr;
 
 1209                                 for (
int a = 0; a < arrayLen; a++)
 
 1213                                                 for (
int i = 0; i < recursion; i++)
 
 1218                                                 printf(
"<%s type=\"pointer\"> ", &memName[1]);
 
 1219                                                 printf(
"%p ", array[a]);
 
 1220                                                 printf(
"</%s>\n", &memName[1]);
 
 1228                                 void **ptrptr = (
void **)elemPtr;
 
 1229                                 void *ptr = *ptrptr;
 
 1232                                         for (
int i = 0; i < recursion; i++)
 
 1236                                         printf(
"<%s type=\"pointer\"> ", &memName[1]);
 
 1238                                         printf(
"</%s>\n", &memName[1]);
 
 1246                                         if (memName[1] == 
'*' && ptrptr && *ptrptr)
 
 1249                                                 void **array = (
void **)*(ptrptr);
 
 1250                                                 void *np = array[0];
 
 1255                                                         if (np) array[n] = np;
 
 1269                         if (oldStruct[0] >= firstStructType)  
 
 1279                                         for (
int i = 0; i < recursion; i++)
 
 1286                                                 printf(
"<%s type=\"%s\" count=%d>\n", cleanName, memType, arrayLen);
 
 1290                                                 printf(
"<%s type=\"%s\">\n", cleanName, memType);
 
 1294                                 for (
int i = 0; i < arrayLen; i++)
 
 1300                                         for (
int i = 0; i < recursion; i++)
 
 1304                                         printf(
"</%s>\n", cleanName);
 
 1314                                                 printf(
"too long\n");
 
 1320                                                 bool isIntegerType = (strcmp(memType, 
"char") == 0) || (strcmp(memType, 
"int") == 0) || (strcmp(memType, 
"short") == 0);
 
 1324                                                         const char *newtype = 
"int";
 
 1327                                                         char *tmp = elemPtr;
 
 1328                                                         dbPtr = &dbarray[0];
 
 1335                                                                 getElement(arrayLen, newtype, memType, tmp, (
char *)dbPtr);
 
 1336                                                                 for (i = 0; i < recursion; i++)
 
 1339                                                                         printf(
"<%s type=\"%s\">", cleanName, memType);
 
 1341                                                                         printf(
"<%s type=\"%s\" count=%d>", cleanName, memType, arrayLen);
 
 1342                                                                 for (i = 0; i < arrayLen; i++)
 
 1343                                                                         printf(
" %d ", dbPtr[i]);
 
 1344                                                                 printf(
"</%s>\n", cleanName);
 
 1349                                                         const char *newtype = 
"double";
 
 1352                                                         char *tmp = elemPtr;
 
 1353                                                         dbPtr = &dbarray[0];
 
 1357                                                                 getElement(arrayLen, newtype, memType, tmp, (
char *)dbPtr);
 
 1358                                                                 for (i = 0; i < recursion; i++)
 
 1365                                                                         printf(
"<%s type=\"%s\">", memName, memType);
 
 1369                                                                         printf(
"<%s type=\"%s\" count=%d>", cleanName, memType, arrayLen);
 
 1371                                                                 for (i = 0; i < arrayLen; i++)
 
 1372                                                                         printf(
" %f ", dbPtr[i]);
 
 1373                                                                 printf(
"</%s>\n", cleanName);
 
 1404                         printf(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
 
 1406                         printf(
"<bullet_physics version=%d itemcount = %d>\n", 
btGetVersion(), numitems);
 
 1408                 for (
int i = 0; i < 
m_chunks.size(); i++)
 
 1416                                 char *oldType = fileDna->
getType(oldStruct[0]);
 
 1419                                         printf(
" <%s pointer=%p>\n", oldType, dataChunk.
oldPtr);
 
 1424                                         printf(
" </%s>\n", oldType);
 
 1433                         printf(
"</bullet_physics>\n");
 
 1451         for (i = 0; i < 
m_chunks.size(); i++)
 
 1461         for (i = 0; i < 
m_chunks.size(); i++)
 
 1464                 char *codeptr = (
char *)&dataChunk.
code;
 
 1465                 char codestr[5] = {codeptr[0], codeptr[1], codeptr[2], codeptr[3], 0};
 
 1467                 short *newStruct = dna->
getStruct(dataChunk.dna_nr);
 
 1468                 char *typeName = dna->
getType(newStruct[0]);
 
 1469                 printf(
"%3d: %s  ", i, typeName);
 
 1471                 printf(
"code=%s  ", codestr);
 
 1473                 printf(
"ptr=%p  ", dataChunk.oldPtr);
 
 1474                 printf(
"len=%d  ", dataChunk.len);
 
 1475                 printf(
"nr=%d  ", dataChunk.nr);
 
 1476                 if (dataChunk.nr != 1)
 
 1487         ifd.just_print_it = 1;
 
 1488         for (i=0; i<bf->m_blocks.size(); ++i) 
 
 1490                 BlendBlock* bb = bf->m_blocks[i];
 
 1491                 printf(
"tag='%s'\tptr=%p\ttype=%s\t[%4d]",              bb->tag, bb,bf->types[bb->type_index].name,bb->m_array_entries_.size());
 
 1492                 block_ID_finder(bb, bf, &ifd);
 
 1498 void bFile::writeChunks(FILE *fp, 
bool fixupPointers)
 
 1502         for (
int i = 0; i < 
m_chunks.size(); i++)
 
 1507                 short *oldStruct, *curStruct;
 
 1508                 char *oldType, *newType;
 
 1509                 int curLen, reverseOld;
 
 1512                 oldType = fileDna->
getType(oldStruct[0]);
 
 1517                 if ((reverseOld != -1))
 
 1525                         assert((strcmp(oldType, newType) == 0) && 
"internal error, struct mismatch!");
 
 1528                         dataChunk.
dna_nr = reverseOld;
 
 1529                         if (strcmp(
"Link", oldType) != 0)
 
 1531                                 dataChunk.
len = curLen * dataChunk.
nr;
 
 1539                         fwrite(&dataChunk, 
sizeof(
bChunkInd), 1, fp);
 
 1541                         short int *curStruct1;
 
 1543                         assert(curStruct1 == curStruct);
 
 1548                         fwrite(cur, dataChunk.
len, 1, fp);
 
 1552                         printf(
"serious error, struct mismatch: don't write\n");
 
 1561         bool varies = 
false;
 
 1586                                 if ((chunk.
code & 0xFFFF) == 0)
 
 1594                         memcpy(dataChunk, &chunk, 
sizeof(
bChunkInd));
 
 1603                                 if ((c.
code & 0xFFFF) == 0)
 
 1611                         memcpy(dataChunk, &c, 
sizeof(
bChunkInd));
 
 1643                                 if ((chunk.
code & 0xFFFF) == 0)
 
 1651                         memcpy(dataChunk, &chunk, 
sizeof(
bChunkInd));
 
 1660                                 if ((c.
code & 0xFFFF) == 0)
 
 1667                         memcpy(dataChunk, &c, 
sizeof(
bChunkInd));
 
 1671         if (dataChunk->
len < 0)
 
 1675         print (
"----------");
 
 1676         print (dataChunk->
code);
 
 1677         print (dataChunk->
len);
 
 1678         print (dataChunk->old);
 
 1679         print (dataChunk->
dna_nr);
 
 1680         print (dataChunk->
nr);