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