godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/thirdparty/bullet/Bullet3Serialize/Bullet2FileLoader/b3File.cpp

1740 lines
37 KiB
C++
Raw Normal View History

Vendor thirdparty Bullet source for upcoming physics server backend
2017-08-01 12:30:58 +00:00
/*
bParse
Copyright (c) 2006-2009 Charlie C & Erwin Coumans http://gamekit.googlecode.com
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "b3File.h"
#include "b3Common.h"
#include "b3Chunk.h"
#include "b3DNA.h"
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "b3Defines.h"
#include "Bullet3Serialize/Bullet2FileLoader/b3Serializer.h"
#include "Bullet3Common/b3AlignedAllocator.h"
#include "Bullet3Common/b3MinMax.h"
#define B3_SIZEOFBLENDERHEADER 12
#define MAX_ARRAY_LENGTH 512
using namespace bParse;
#define MAX_STRLEN 1024
const char* getCleanName(const char* memName, char* buffer)
{
int slen = strlen(memName);
assert(slen<MAX_STRLEN);
slen=b3Min(slen,MAX_STRLEN);
for (int i=0;i<slen;i++)
{
if (memName[i]==']'||memName[i]=='[')
{
buffer[i] = 0;//'_';
} else
{
buffer[i] = memName[i];
}
}
buffer[slen]=0;
return buffer;
}
// ----------------------------------------------------- //
bFile::bFile(const char *filename, const char headerString[7])
: mOwnsBuffer(true),
mFileBuffer(0),
mFileLen(0),
mVersion(0),
mDataStart(0),
mFileDNA(0),
mMemoryDNA(0),
mFlags(FD_INVALID)
{
for (int i=0;i<7;i++)
{
m_headerString[i] = headerString[i];
}
FILE *fp = fopen(filename, "rb");
if (fp)
{
fseek(fp, 0L, SEEK_END);
mFileLen = ftell(fp);
fseek(fp, 0L, SEEK_SET);
mFileBuffer = (char*)malloc(mFileLen+1);
int bytesRead;
bytesRead = fread(mFileBuffer, mFileLen, 1, fp);
fclose(fp);
//
parseHeader();
}
}
// ----------------------------------------------------- //
bFile::bFile( char *memoryBuffer, int len, const char headerString[7])
: mOwnsBuffer(false),
mFileBuffer(0),
mFileLen(0),
mVersion(0),
mDataStart(0),
mFileDNA(0),
mMemoryDNA(0),
mFlags(FD_INVALID)
{
for (int i=0;i<7;i++)
{
m_headerString[i] = headerString[i];
}
mFileBuffer = memoryBuffer;
mFileLen = len;
parseHeader();
}
// ----------------------------------------------------- //
bFile::~bFile()
{
if (mOwnsBuffer && mFileBuffer)
{
free(mFileBuffer);
mFileBuffer = 0;
}
delete mMemoryDNA;
delete mFileDNA;
}
// ----------------------------------------------------- //
void bFile::parseHeader()
{
if (!mFileLen || !mFileBuffer)
return;
char *blenderBuf = mFileBuffer;
char header[B3_SIZEOFBLENDERHEADER+1] ;
memcpy(header, blenderBuf, B3_SIZEOFBLENDERHEADER);
header[B3_SIZEOFBLENDERHEADER]='\0';
if (strncmp(header, m_headerString, 6)!=0)
{
memcpy(header, m_headerString, B3_SIZEOFBLENDERHEADER);
return;
}
if (header[6] == 'd')
{
mFlags |= FD_DOUBLE_PRECISION;
}
char *ver = header+9;
mVersion = atoi(ver);
if (mVersion <= 241)
{
//printf("Warning, %d not fully tested : <= 242\n", mVersion);
}
int littleEndian= 1;
littleEndian= ((char*)&littleEndian)[0];
// swap ptr sizes...
if (header[7]=='-')
{
mFlags |= FD_FILE_64;
if (!VOID_IS_8)
mFlags |= FD_BITS_VARIES;
}
else if (VOID_IS_8) mFlags |= FD_BITS_VARIES;
// swap endian...
if (header[8]=='V')
{
if (littleEndian ==1)
mFlags |= FD_ENDIAN_SWAP;
}
else
if (littleEndian==0)
mFlags |= FD_ENDIAN_SWAP;
mFlags |= FD_OK;
}
// ----------------------------------------------------- //
bool bFile::ok()
{
return (mFlags &FD_OK)!=0;
}
// ----------------------------------------------------- //
void bFile::parseInternal(int verboseMode, char* memDna,int memDnaLength)
{
if ( (mFlags &FD_OK) ==0)
return;
char *blenderData = mFileBuffer;
bChunkInd dna;
dna.oldPtr = 0;
char *tempBuffer = blenderData;
for (int i=0; i<mFileLen; i++)
{
// looking for the data's starting position
// and the start of SDNA decls
if (!mDataStart && strncmp(tempBuffer, "REND", 4)==0)
mDataStart = i;
if (strncmp(tempBuffer, "DNA1", 4)==0)
{
// read the DNA1 block and extract SDNA
if (getNextBlock(&dna, tempBuffer, mFlags) > 0)
{
if (strncmp((tempBuffer + ChunkUtils::getOffset(mFlags)), "SDNANAME", 8) ==0)
dna.oldPtr = (tempBuffer + ChunkUtils::getOffset(mFlags));
else dna.oldPtr = 0;
}
else dna.oldPtr = 0;
}
// Some Bullet files are missing the DNA1 block
// In Blender it's DNA1 + ChunkUtils::getOffset() + SDNA + NAME
// In Bullet tests its SDNA + NAME
else if (strncmp(tempBuffer, "SDNANAME", 8) ==0)
{
dna.oldPtr = blenderData + i;
dna.len = mFileLen-i;
// Also no REND block, so exit now.
if (mVersion==276) break;
}
if (mDataStart && dna.oldPtr) break;
tempBuffer++;
}
if (!dna.oldPtr || !dna.len)
{
//printf("Failed to find DNA1+SDNA pair\n");
mFlags &= ~FD_OK;
return;
}
mFileDNA = new bDNA();
///mFileDNA->init will convert part of DNA file endianness to current CPU endianness if necessary
mFileDNA->init((char*)dna.oldPtr, dna.len, (mFlags & FD_ENDIAN_SWAP)!=0);
if (mVersion==276)
{
int i;
for (i=0;i<mFileDNA->getNumNames();i++)
{
if (strcmp(mFileDNA->getName(i),"int")==0)
{
mFlags |= FD_BROKEN_DNA;
}
}
if ((mFlags&FD_BROKEN_DNA)!=0)
{
//printf("warning: fixing some broken DNA version\n");
}
}
if (verboseMode & FD_VERBOSE_DUMP_DNA_TYPE_DEFINITIONS)
mFileDNA->dumpTypeDefinitions();
mMemoryDNA = new bDNA();
int littleEndian= 1;
littleEndian= ((char*)&littleEndian)[0];
mMemoryDNA->init(memDna,memDnaLength,littleEndian==0);
///@todo we need a better version check, add version/sub version info from FileGlobal into memory DNA/header files
if (mMemoryDNA->getNumNames() != mFileDNA->getNumNames())
{
mFlags |= FD_VERSION_VARIES;
//printf ("Warning, file DNA is different than built in, performance is reduced. Best to re-export file with a matching version/platform");
}
// as long as it kept up to date it will be ok!!
if (mMemoryDNA->lessThan(mFileDNA))
{
//printf ("Warning, file DNA is newer than built in.");
}
mFileDNA->initCmpFlags(mMemoryDNA);
parseData();
resolvePointers(verboseMode);
updateOldPointers();
}
// ----------------------------------------------------- //
void bFile::swap(char *head, bChunkInd& dataChunk, bool ignoreEndianFlag)
{
char *data = head;
short *strc = mFileDNA->getStruct(dataChunk.dna_nr);
const char s[] = "SoftBodyMaterialData";
int szs = sizeof(s);
if (strncmp((char*)&dataChunk.code,"ARAY",4)==0)
{
short *oldStruct = mFileDNA->getStruct(dataChunk.dna_nr);
char *oldType = mFileDNA->getType(oldStruct[0]);
if (strncmp(oldType,s,szs)==0)
{
return;
}
}
int len = mFileDNA->getLength(strc[0]);
for (int i=0; i<dataChunk.nr; i++)
{
swapStruct(dataChunk.dna_nr, data,ignoreEndianFlag);
data+=len;
}
}
void bFile::swapLen(char *dataPtr)
{
const bool VOID_IS_8 = ((sizeof(void*)==8));
if (VOID_IS_8)
{
if (mFlags &FD_BITS_VARIES)
{
bChunkPtr4*c = (bChunkPtr4*) dataPtr;
if ((c->code & 0xFFFF)==0)
c->code >>=16;
B3_SWITCH_INT(c->len);
B3_SWITCH_INT(c->dna_nr);
B3_SWITCH_INT(c->nr);
} else
{
bChunkPtr8* c = (bChunkPtr8*) dataPtr;
if ((c->code & 0xFFFF)==0)
c->code >>=16;
B3_SWITCH_INT(c->len);
B3_SWITCH_INT(c->dna_nr);
B3_SWITCH_INT(c->nr);
}
} else
{
if (mFlags &FD_BITS_VARIES)
{
bChunkPtr8*c = (bChunkPtr8*) dataPtr;
if ((c->code & 0xFFFF)==0)
c->code >>=16;
B3_SWITCH_INT(c->len);
B3_SWITCH_INT(c->dna_nr);
B3_SWITCH_INT(c->nr);
} else
{
bChunkPtr4* c = (bChunkPtr4*) dataPtr;
if ((c->code & 0xFFFF)==0)
c->code >>=16;
B3_SWITCH_INT(c->len);
B3_SWITCH_INT(c->dna_nr);
B3_SWITCH_INT(c->nr);
}
}
}
void bFile::swapDNA(char* ptr)
{
bool swap = ((mFlags & FD_ENDIAN_SWAP)!=0);
char* data = &ptr[20];
// void bDNA::init(char *data, int len, bool swap)
int *intPtr=0;short *shtPtr=0;
char *cp = 0;int dataLen =0;
//long nr=0;
intPtr = (int*)data;
/*
SDNA (4 bytes) (magic number)
NAME (4 bytes)
<nr> (4 bytes) amount of names (int)
<string>
<string>
*/
if (strncmp(data, "SDNA", 4)==0)
{
// skip ++ NAME
intPtr++; intPtr++;
}
// Parse names
if (swap)
dataLen = ChunkUtils::swapInt(*intPtr);
else
dataLen = *intPtr;
*intPtr = ChunkUtils::swapInt(*intPtr);
intPtr++;
cp = (char*)intPtr;
int i;
for ( i=0; i<dataLen; i++)
{
while (*cp)cp++;
cp++;
}
cp = b3AlignPointer(cp,4);
/*
TYPE (4 bytes)
<nr> amount of types (int)
<string>
<string>
*/
intPtr = (int*)cp;
assert(strncmp(cp, "TYPE", 4)==0); intPtr++;
if (swap)
dataLen = ChunkUtils::swapInt(*intPtr);
else
dataLen = *intPtr;
*intPtr = ChunkUtils::swapInt(*intPtr);
intPtr++;
cp = (char*)intPtr;
for ( i=0; i<dataLen; i++)
{
while (*cp)cp++;
cp++;
}
cp = b3AlignPointer(cp,4);
/*
TLEN (4 bytes)
<len> (short) the lengths of types
<len>
*/
// Parse type lens
intPtr = (int*)cp;
assert(strncmp(cp, "TLEN", 4)==0); intPtr++;
shtPtr = (short*)intPtr;
for ( i=0; i<dataLen; i++, shtPtr++)
{
//??????if (swap)
shtPtr[0] = ChunkUtils::swapShort(shtPtr[0]);
}
if (dataLen & 1)
shtPtr++;
/*
STRC (4 bytes)
<nr> amount of structs (int)
<typenr>
<nr_of_elems>
<typenr>
<namenr>
<typenr>
<namenr>
*/
intPtr = (int*)shtPtr;
cp = (char*)intPtr;
assert(strncmp(cp, "STRC", 4)==0);
intPtr++;
if (swap)
dataLen = ChunkUtils::swapInt(*intPtr);
else
dataLen = *intPtr;
*intPtr = ChunkUtils::swapInt(*intPtr);
intPtr++;
shtPtr = (short*)intPtr;
for ( i=0; i<dataLen; i++)
{
//if (swap)
{
int len = shtPtr[1];
shtPtr[0]= ChunkUtils::swapShort(shtPtr[0]);
shtPtr[1]= ChunkUtils::swapShort(shtPtr[1]);
shtPtr+= 2;
for (int a=0; a<len; a++, shtPtr+=2)
{
shtPtr[0]= ChunkUtils::swapShort(shtPtr[0]);
shtPtr[1]= ChunkUtils::swapShort(shtPtr[1]);
}
}
// else
// shtPtr+= (2*shtPtr[1])+2;
}
}
void bFile::writeFile(const char* fileName)
{
FILE* f = fopen(fileName,"wb");
fwrite(mFileBuffer,1,mFileLen,f);
fclose(f);
}
void bFile::preSwap()
{
//const bool brokenDNA = (mFlags&FD_BROKEN_DNA)!=0;
//FD_ENDIAN_SWAP
//byte 8 determines the endianness of the file, little (v) versus big (V)
int littleEndian= 1;
littleEndian= ((char*)&littleEndian)[0];
if (mFileBuffer[8]=='V')
{
mFileBuffer[8]='v';
}
else
{
mFileBuffer[8]='V';
}
mDataStart = 12;
char *dataPtr = mFileBuffer+mDataStart;
bChunkInd dataChunk;
dataChunk.code = 0;
bool ignoreEndianFlag = true;
//we always want to swap here
int seek = getNextBlock(&dataChunk, dataPtr, mFlags);
//dataPtr += ChunkUtils::getOffset(mFlags);
char *dataPtrHead = 0;
while (1)
{
// one behind
if (dataChunk.code == B3_SDNA || dataChunk.code==B3_DNA1 || dataChunk.code == B3_TYPE || dataChunk.code == B3_TLEN || dataChunk.code==B3_STRC)
{
swapDNA(dataPtr);
break;
} else
{
//if (dataChunk.code == DNA1) break;
dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
swapLen(dataPtr);
if (dataChunk.dna_nr>=0)
{
swap(dataPtrHead, dataChunk,ignoreEndianFlag);
} else
{
//printf("unknown chunk\n");
}
}
// next please!
dataPtr += seek;
seek = getNextBlock(&dataChunk, dataPtr, mFlags);
if (seek < 0)
break;
}
if (mFlags & FD_ENDIAN_SWAP)
{
mFlags &= ~FD_ENDIAN_SWAP;
} else
{
mFlags |= FD_ENDIAN_SWAP;
}
}
// ----------------------------------------------------- //
char* bFile::readStruct(char *head, bChunkInd& dataChunk)
{
bool ignoreEndianFlag = false;
if (mFlags & FD_ENDIAN_SWAP)
swap(head, dataChunk, ignoreEndianFlag);
if (!mFileDNA->flagEqual(dataChunk.dna_nr))
{
// Ouch! need to rebuild the struct
short *oldStruct,*curStruct;
char *oldType, *newType;
int oldLen, curLen, reverseOld;
oldStruct = mFileDNA->getStruct(dataChunk.dna_nr);
oldType = mFileDNA->getType(oldStruct[0]);
oldLen = mFileDNA->getLength(oldStruct[0]);
if ((mFlags&FD_BROKEN_DNA)!=0)
{
if ((strcmp(oldType,"b3QuantizedBvhNodeData")==0)&&oldLen==20)
{
return 0;
}
if ((strcmp(oldType,"b3ShortIntIndexData")==0))
{
int allocLen = 2;
char *dataAlloc = new char[(dataChunk.nr*allocLen)+1];
memset(dataAlloc, 0, (dataChunk.nr*allocLen)+1);
short* dest = (short*) dataAlloc;
const short* src = (short*) head;
for (int i=0;i<dataChunk.nr;i++)
{
dest[i] = src[i];
if (mFlags &FD_ENDIAN_SWAP)
{
B3_SWITCH_SHORT(dest[i]);
}
}
addDataBlock(dataAlloc);
return dataAlloc;
}
}
///don't try to convert Link block data, just memcpy it. Other data can be converted.
if (strcmp("Link",oldType)!=0)
{
reverseOld = mMemoryDNA->getReverseType(oldType);
if ((reverseOld!=-1))
{
// make sure it's here
//assert(reverseOld!= -1 && "getReverseType() returned -1, struct required!");
//
curStruct = mMemoryDNA->getStruct(reverseOld);
newType = mMemoryDNA->getType(curStruct[0]);
curLen = mMemoryDNA->getLength(curStruct[0]);
// make sure it's the same
assert((strcmp(oldType, newType)==0) && "internal error, struct mismatch!");
// numBlocks * length
int allocLen = (curLen);
char *dataAlloc = new char[(dataChunk.nr*allocLen)+1];
memset(dataAlloc, 0, (dataChunk.nr*allocLen));
// track allocated
addDataBlock(dataAlloc);
char *cur = dataAlloc;
char *old = head;
for (int block=0; block<dataChunk.nr; block++)
{
bool fixupPointers = true;
parseStruct(cur, old, dataChunk.dna_nr, reverseOld, fixupPointers);
mLibPointers.insert(old,(bStructHandle*)cur);
cur += curLen;
old += oldLen;
}
return dataAlloc;
}
} else
{
//printf("Link found\n");
}
} else
{
//#define DEBUG_EQUAL_STRUCTS
#ifdef DEBUG_EQUAL_STRUCTS
short *oldStruct;
char *oldType;
oldStruct = mFileDNA->getStruct(dataChunk.dna_nr);
oldType = mFileDNA->getType(oldStruct[0]);
printf("%s equal structure, just memcpy\n",oldType);
#endif //
}
char *dataAlloc = new char[(dataChunk.len)+1];
memset(dataAlloc, 0, dataChunk.len+1);
// track allocated
addDataBlock(dataAlloc);
memcpy(dataAlloc, head, dataChunk.len);
return dataAlloc;
}
// ----------------------------------------------------- //
void bFile::parseStruct(char *strcPtr, char *dtPtr, int old_dna, int new_dna, bool fixupPointers)
{
if (old_dna == -1) return;
if (new_dna == -1) return;
//disable this, because we need to fixup pointers/ListBase
if (0)//mFileDNA->flagEqual(old_dna))
{
short *strc = mFileDNA->getStruct(old_dna);
int len = mFileDNA->getLength(strc[0]);
memcpy(strcPtr, dtPtr, len);
return;
}
// Ok, now build the struct
char *memType, *memName, *cpc, *cpo;
short *fileStruct, *filePtrOld, *memoryStruct, *firstStruct;
int elementLength, size, revType, old_nr, new_nr, fpLen;
short firstStructType;
// File to memory lookup
memoryStruct = mMemoryDNA->getStruct(new_dna);
fileStruct = mFileDNA->getStruct(old_dna);
firstStruct = fileStruct;
filePtrOld = fileStruct;
firstStructType = mMemoryDNA->getStruct(0)[0];
// Get number of elements
elementLength = memoryStruct[1];
memoryStruct+=2;
cpc = strcPtr; cpo = 0;
for (int ele=0; ele<elementLength; ele++, memoryStruct+=2)
{
memType = mMemoryDNA->getType(memoryStruct[0]);
memName = mMemoryDNA->getName(memoryStruct[1]);
size = mMemoryDNA->getElementSize(memoryStruct[0], memoryStruct[1]);
revType = mMemoryDNA->getReverseType(memoryStruct[0]);
if (revType != -1 && memoryStruct[0]>=firstStructType && memName[0] != '*')
{
cpo = getFileElement(firstStruct, memName, memType, dtPtr, &filePtrOld);
if (cpo)
{
int arrayLen = mFileDNA->getArraySizeNew(filePtrOld[1]);
old_nr = mFileDNA->getReverseType(memType);
new_nr = revType;
fpLen = mFileDNA->getElementSize(filePtrOld[0], filePtrOld[1]);
if (arrayLen==1)
{
parseStruct(cpc, cpo, old_nr, new_nr,fixupPointers);
} else
{
char* tmpCpc = cpc;
char* tmpCpo = cpo;
for (int i=0;i<arrayLen;i++)
{
parseStruct(tmpCpc, tmpCpo, old_nr, new_nr,fixupPointers);
tmpCpc += size/arrayLen;
tmpCpo += fpLen/arrayLen;
}
}
cpc+=size;
cpo+=fpLen;
}
else
cpc+=size;
}
else
{
getMatchingFileDNA(fileStruct, memName, memType, cpc, dtPtr,fixupPointers);
cpc+=size;
}
}
}
// ----------------------------------------------------- //
static void getElement(int arrayLen, const char *cur, const char *old, char *oldPtr, char *curData)
{
#define b3GetEle(value, current, type, cast, size, ptr)\
if (strcmp(current, type)==0)\
{\
value = (*(cast*)ptr);\
ptr += size;\
}
#define b3SetEle(value, current, type, cast, size, ptr)\
if (strcmp(current, type)==0)\
{\
(*(cast*)ptr) = (cast)value;\
ptr += size;\
}
double value = 0.0;
for (int i=0; i<arrayLen; i++)
{
b3GetEle(value, old, "char", char, sizeof(char), oldPtr);
b3SetEle(value, cur, "char", char, sizeof(char), curData);
b3GetEle(value, old, "short", short, sizeof(short), oldPtr);
b3SetEle(value, cur, "short", short, sizeof(short), curData);
b3GetEle(value, old, "ushort", unsigned short, sizeof(unsigned short), oldPtr);
b3SetEle(value, cur, "ushort", unsigned short, sizeof(unsigned short), curData);
b3GetEle(value, old, "int", int, sizeof(int), oldPtr);
b3SetEle(value, cur, "int", int, sizeof(int), curData);
b3GetEle(value, old, "long", int, sizeof(int), oldPtr);
b3SetEle(value, cur, "long", int, sizeof(int), curData);
b3GetEle(value, old, "float", float, sizeof(float), oldPtr);
b3SetEle(value, cur, "float", float, sizeof(float), curData);
b3GetEle(value, old, "double", double, sizeof(double), oldPtr);
b3SetEle(value, cur, "double", double, sizeof(double), curData);
}
}
// ----------------------------------------------------- //
void bFile::swapData(char *data, short type, int arraySize,bool ignoreEndianFlag)
{
if (ignoreEndianFlag || (mFlags &FD_ENDIAN_SWAP))
{
if (type == 2 || type == 3)
{
short *sp = (short*)data;
for (int i=0; i<arraySize; i++)
{
sp[0] = ChunkUtils::swapShort(sp[0]);
sp++;
}
}
if (type>3 && type <8)
{
char c;
char *cp = data;
for (int i=0; i<arraySize; i++)
{
c = cp[0];
cp[0] = cp[3];
cp[3] = c;
c = cp[1];
cp[1] = cp[2];
cp[2] = c;
cp+=4;
}
}
}
}
void bFile::safeSwapPtr(char *dst, const char *src)
{
int ptrFile = mFileDNA->getPointerSize();
int ptrMem = mMemoryDNA->getPointerSize();
if (!src && !dst)
return;
if (ptrFile == ptrMem)
{
memcpy(dst, src, ptrMem);
}
else if (ptrMem==4 && ptrFile==8)
{
b3PointerUid* oldPtr = (b3PointerUid*)src;
b3PointerUid* newPtr = (b3PointerUid*)dst;
if (oldPtr->m_uniqueIds[0] == oldPtr->m_uniqueIds[1])
{
//Bullet stores the 32bit unique ID in both upper and lower part of 64bit pointers
//so it can be used to distinguish between .blend and .bullet
newPtr->m_uniqueIds[0] = oldPtr->m_uniqueIds[0];
} else
{
//deal with pointers the Blender .blend style way, see
//readfile.c in the Blender source tree
b3Long64 longValue = *((b3Long64*)src);
//endian swap for 64bit pointer otherwise truncation will fail due to trailing zeros
if (mFlags & FD_ENDIAN_SWAP)
B3_SWITCH_LONGINT(longValue);
*((int*)dst) = (int)(longValue>>3);
}
}
else if (ptrMem==8 && ptrFile==4)
{
b3PointerUid* oldPtr = (b3PointerUid*)src;
b3PointerUid* newPtr = (b3PointerUid*)dst;
if (oldPtr->m_uniqueIds[0] == oldPtr->m_uniqueIds[1])
{
newPtr->m_uniqueIds[0] = oldPtr->m_uniqueIds[0];
newPtr->m_uniqueIds[1] = 0;
} else
{
*((b3Long64*)dst)= *((int*)src);
}
}
else
{
printf ("%d %d\n", ptrFile,ptrMem);
assert(0 && "Invalid pointer len");
}
}
// ----------------------------------------------------- //
void bFile::getMatchingFileDNA(short* dna_addr, const char* lookupName, const char* lookupType, char *strcData, char *data, bool fixupPointers)
{
// find the matching memory dna data
// to the file being loaded. Fill the
// memory with the file data...
int len = dna_addr[1];
dna_addr+=2;
for (int i=0; i<len; i++, dna_addr+=2)
{
const char* type = mFileDNA->getType(dna_addr[0]);
const char* name = mFileDNA->getName(dna_addr[1]);
int eleLen = mFileDNA->getElementSize(dna_addr[0], dna_addr[1]);
if ((mFlags&FD_BROKEN_DNA)!=0)
{
if ((strcmp(type,"short")==0)&&(strcmp(name,"int")==0))
{
eleLen = 0;
}
}
if (strcmp(lookupName, name)==0)
{
//int arrayLenold = mFileDNA->getArraySize((char*)name.c_str());
int arrayLen = mFileDNA->getArraySizeNew(dna_addr[1]);
//assert(arrayLenold == arrayLen);
if (name[0] == '*')
{
// cast pointers
int ptrFile = mFileDNA->getPointerSize();
int ptrMem = mMemoryDNA->getPointerSize();
safeSwapPtr(strcData,data);
if (fixupPointers)
{
if (arrayLen > 1)
{
//void **sarray = (void**)strcData;
//void **darray = (void**)data;
char *cpc, *cpo;
cpc = (char*)strcData;
cpo = (char*)data;
for (int a=0; a<arrayLen; a++)
{
safeSwapPtr(cpc, cpo);
m_pointerFixupArray.push_back(cpc);
cpc += ptrMem;
cpo += ptrFile;
}
}
else
{
if (name[1] == '*')
m_pointerPtrFixupArray.push_back(strcData);
else
m_pointerFixupArray.push_back(strcData);
}
}
else
{
// printf("skipped %s %s : %x\n",type.c_str(),name.c_str(),strcData);
}
}
else if (strcmp(type, lookupType)==0)
memcpy(strcData, data, eleLen);
else
getElement(arrayLen, lookupType, type, data, strcData);
// --
return;
}
data+=eleLen;
}
}
// ----------------------------------------------------- //
char* bFile::getFileElement(short *firstStruct, char *lookupName, char *lookupType, char *data, short **foundPos)
{
short *old = firstStruct;//mFileDNA->getStruct(old_nr);
int elementLength = old[1];
old+=2;
for (int i=0; i<elementLength; i++, old+=2)
{
char* type = mFileDNA->getType(old[0]);
char* name = mFileDNA->getName(old[1]);
int len = mFileDNA->getElementSize(old[0], old[1]);
if (strcmp(lookupName, name)==0)
{
if (strcmp(type, lookupType)==0)
{
if (foundPos)
*foundPos = old;
return data;
}
return 0;
}
data+=len;
}
return 0;
}
// ----------------------------------------------------- //
void bFile::swapStruct(int dna_nr, char *data,bool ignoreEndianFlag)
{
if (dna_nr == -1) return;
short *strc = mFileDNA->getStruct(dna_nr);
//short *firstStrc = strc;
int elementLen= strc[1];
strc+=2;
short first = mFileDNA->getStruct(0)[0];
char *buf = data;
for (int i=0; i<elementLen; i++, strc+=2)
{
char *type = mFileDNA->getType(strc[0]);
char *name = mFileDNA->getName(strc[1]);
int size = mFileDNA->getElementSize(strc[0], strc[1]);
if (strc[0] >= first && name[0]!='*')
{
int old_nr = mFileDNA->getReverseType(type);
int arrayLen = mFileDNA->getArraySizeNew(strc[1]);
if (arrayLen==1)
{
swapStruct(old_nr,buf,ignoreEndianFlag);
} else
{
char* tmpBuf = buf;
for (int i=0;i<arrayLen;i++)
{
swapStruct(old_nr,tmpBuf,ignoreEndianFlag);
tmpBuf+=size/arrayLen;
}
}
}
else
{
//int arrayLenOld = mFileDNA->getArraySize(name);
int arrayLen = mFileDNA->getArraySizeNew(strc[1]);
//assert(arrayLenOld == arrayLen);
swapData(buf, strc[0], arrayLen,ignoreEndianFlag);
}
buf+=size;
}
}
void bFile::resolvePointersMismatch()
{
// printf("resolvePointersStructMismatch\n");
int i;
for (i=0;i< m_pointerFixupArray.size();i++)
{
char* cur = m_pointerFixupArray.at(i);
void** ptrptr = (void**) cur;
void* ptr = *ptrptr;
ptr = findLibPointer(ptr);
if (ptr)
{
//printf("Fixup pointer!\n");
*(ptrptr) = ptr;
} else
{
// printf("pointer not found: %x\n",cur);
}
}
for (i=0; i<m_pointerPtrFixupArray.size(); i++)
{
char* cur= m_pointerPtrFixupArray.at(i);
void** ptrptr = (void**)cur;
bChunkInd *block = m_chunkPtrPtrMap.find(*ptrptr);
if (block)
{
int ptrMem = mMemoryDNA->getPointerSize();
int ptrFile = mFileDNA->getPointerSize();
int blockLen = block->len / ptrFile;
void *onptr = findLibPointer(*ptrptr);
if (onptr)
{
char *newPtr = new char[blockLen * ptrMem];
addDataBlock(newPtr);
memset(newPtr, 0, blockLen * ptrMem);
void **onarray = (void**)onptr;
char *oldPtr = (char*)onarray;
int p = 0;
while (blockLen-- > 0)
{
b3PointerUid dp = {{0}};
safeSwapPtr((char*)dp.m_uniqueIds, oldPtr);
void **tptr = (void**)(newPtr + p * ptrMem);
*tptr = findLibPointer(dp.m_ptr);
oldPtr += ptrFile;
++p;
}
*ptrptr = newPtr;
}
}
}
}
///this loop only works fine if the Blender DNA structure of the file matches the headerfiles
void bFile::resolvePointersChunk(const bChunkInd& dataChunk, int verboseMode)
{
bParse::bDNA* fileDna = mFileDNA ? mFileDNA : mMemoryDNA;
short int* oldStruct = fileDna->getStruct(dataChunk.dna_nr);
short oldLen = fileDna->getLength(oldStruct[0]);
//char* structType = fileDna->getType(oldStruct[0]);
char* cur = (char*)findLibPointer(dataChunk.oldPtr);
for (int block=0; block<dataChunk.nr; block++)
{
resolvePointersStructRecursive(cur,dataChunk.dna_nr, verboseMode,1);
cur += oldLen;
}
}
int bFile::resolvePointersStructRecursive(char *strcPtr, int dna_nr, int verboseMode,int recursion)
{
bParse::bDNA* fileDna = mFileDNA ? mFileDNA : mMemoryDNA;
char* memType;
char* memName;
short firstStructType = fileDna->getStruct(0)[0];
char* elemPtr= strcPtr;
short int* oldStruct = fileDna->getStruct(dna_nr);
int elementLength = oldStruct[1];
oldStruct+=2;
int totalSize = 0;
for (int ele=0; ele<elementLength; ele++, oldStruct+=2)
{
memType = fileDna->getType(oldStruct[0]);
memName = fileDna->getName(oldStruct[1]);
int arrayLen = fileDna->getArraySizeNew(oldStruct[1]);
if (memName[0] == '*')
{
if (arrayLen > 1)
{
void **array= (void**)elemPtr;
for (int a=0; a<arrayLen; a++)
{
if (verboseMode & FD_VERBOSE_EXPORT_XML)
{
for (int i=0;i<recursion;i++)
{
printf(" ");
}
//skip the *
printf("<%s type=\"pointer\"> ",&memName[1]);
printf("%p ", array[a]);
printf("</%s>\n",&memName[1]);
}
array[a] = findLibPointer(array[a]);
}
}
else
{
void** ptrptr = (void**) elemPtr;
void* ptr = *ptrptr;
if (verboseMode & FD_VERBOSE_EXPORT_XML)
{
for (int i=0;i<recursion;i++)
{
printf(" ");
}
printf("<%s type=\"pointer\"> ",&memName[1]);
printf("%p ", ptr);
printf("</%s>\n",&memName[1]);
}
ptr = findLibPointer(ptr);
if (ptr)
{
// printf("Fixup pointer at 0x%x from 0x%x to 0x%x!\n",ptrptr,*ptrptr,ptr);
*(ptrptr) = ptr;
if (memName[1] == '*' && ptrptr && *ptrptr)
{
// This will only work if the given **array is continuous
void **array= (void**)*(ptrptr);
void *np= array[0];
int n=0;
while (np)
{
np= findLibPointer(array[n]);
if (np) array[n]= np;
n++;
}
}
} else
{
// printf("Cannot fixup pointer at 0x%x from 0x%x to 0x%x!\n",ptrptr,*ptrptr,ptr);
}
}
} else
{
int revType = fileDna->getReverseType(oldStruct[0]);
if (oldStruct[0]>=firstStructType) //revType != -1 &&
{
char cleanName[MAX_STRLEN];
getCleanName(memName,cleanName);
int arrayLen = fileDna->getArraySizeNew(oldStruct[1]);
int byteOffset = 0;
if (verboseMode & FD_VERBOSE_EXPORT_XML)
{
for (int i=0;i<recursion;i++)
{
printf(" ");
}
if (arrayLen>1)
{
printf("<%s type=\"%s\" count=%d>\n",cleanName,memType, arrayLen);
} else
{
printf("<%s type=\"%s\">\n",cleanName,memType);
}
}
for (int i=0;i<arrayLen;i++)
{
byteOffset += resolvePointersStructRecursive(elemPtr+byteOffset,revType, verboseMode,recursion+1);
}
if (verboseMode & FD_VERBOSE_EXPORT_XML)
{
for (int i=0;i<recursion;i++)
{
printf(" ");
}
printf("</%s>\n",cleanName);
}
} else
{
//export a simple type
if (verboseMode & FD_VERBOSE_EXPORT_XML)
{
if (arrayLen>MAX_ARRAY_LENGTH)
{
printf("too long\n");
} else
{
//printf("%s %s\n",memType,memName);
bool isIntegerType = (strcmp(memType,"char")==0) || (strcmp(memType,"int")==0) || (strcmp(memType,"short")==0);
if (isIntegerType)
{
const char* newtype="int";
int dbarray[MAX_ARRAY_LENGTH];
int* dbPtr = 0;
char* tmp = elemPtr;
dbPtr = &dbarray[0];
if (dbPtr)
{
char cleanName[MAX_STRLEN];
getCleanName(memName,cleanName);
int i;
getElement(arrayLen, newtype,memType, tmp, (char*)dbPtr);
for (i=0;i<recursion;i++)
printf(" ");
if (arrayLen==1)
printf("<%s type=\"%s\">",cleanName,memType);
else
printf("<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
for (i=0;i<arrayLen;i++)
printf(" %d ",dbPtr[i]);
printf("</%s>\n",cleanName);
}
} else
{
const char* newtype="double";
double dbarray[MAX_ARRAY_LENGTH];
double* dbPtr = 0;
char* tmp = elemPtr;
dbPtr = &dbarray[0];
if (dbPtr)
{
int i;
getElement(arrayLen, newtype,memType, tmp, (char*)dbPtr);
for (i=0;i<recursion;i++)
printf(" ");
char cleanName[MAX_STRLEN];
getCleanName(memName,cleanName);
if (arrayLen==1)
{
printf("<%s type=\"%s\">",memName,memType);
}
else
{
printf("<%s type=\"%s\" count=%d>",cleanName,memType,arrayLen);
}
for (i=0;i<arrayLen;i++)
printf(" %f ",dbPtr[i]);
printf("</%s>\n",cleanName);
}
}
}
}
}
}
int size = fileDna->getElementSize(oldStruct[0], oldStruct[1]);
totalSize += size;
elemPtr+=size;
}
return totalSize;
}
///Resolve pointers replaces the original pointers in structures, and linked lists by the new in-memory structures
void bFile::resolvePointers(int verboseMode)
{
bParse::bDNA* fileDna = mFileDNA ? mFileDNA : mMemoryDNA;
//char *dataPtr = mFileBuffer+mDataStart;
if (1) //mFlags & (FD_BITS_VARIES | FD_VERSION_VARIES))
{
resolvePointersMismatch();
}
{
if (verboseMode & FD_VERBOSE_EXPORT_XML)
{
printf("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
int numitems = m_chunks.size();
printf("<bullet_physics version=%d itemcount = %d>\n", b3GetVersion(), numitems);
}
for (int i=0;i<m_chunks.size();i++)
{
const bChunkInd& dataChunk = m_chunks.at(i);
if (!mFileDNA || fileDna->flagEqual(dataChunk.dna_nr))
{
//dataChunk.len
short int* oldStruct = fileDna->getStruct(dataChunk.dna_nr);
char* oldType = fileDna->getType(oldStruct[0]);
if (verboseMode & FD_VERBOSE_EXPORT_XML)
printf(" <%s pointer=%p>\n",oldType,dataChunk.oldPtr);
resolvePointersChunk(dataChunk, verboseMode);
if (verboseMode & FD_VERBOSE_EXPORT_XML)
printf(" </%s>\n",oldType);
} else
{
//printf("skipping mStruct\n");
}
}
if (verboseMode & FD_VERBOSE_EXPORT_XML)
{
printf("</bullet_physics>\n");
}
}
}
// ----------------------------------------------------- //
void* bFile::findLibPointer(void *ptr)
{
bStructHandle** ptrptr = getLibPointers().find(ptr);
if (ptrptr)
return *ptrptr;
return 0;
}
void bFile::updateOldPointers()
{
int i;
for (i=0;i<m_chunks.size();i++)
{
bChunkInd& dataChunk = m_chunks[i];
dataChunk.oldPtr = findLibPointer(dataChunk.oldPtr);
}
}
void bFile::dumpChunks(bParse::bDNA* dna)
{
int i;
for (i=0;i<m_chunks.size();i++)
{
bChunkInd& dataChunk = m_chunks[i];
char* codeptr = (char*)&dataChunk.code;
char codestr[5] = {codeptr[0],codeptr[1],codeptr[2],codeptr[3],0};
short* newStruct = dna->getStruct(dataChunk.dna_nr);
char* typeName = dna->getType(newStruct[0]);
printf("%3d: %s ",i,typeName);
printf("code=%s ",codestr);
printf("ptr=%p ",dataChunk.oldPtr);
printf("len=%d ",dataChunk.len);
printf("nr=%d ",dataChunk.nr);
if (dataChunk.nr!=1)
{
printf("not 1\n");
}
printf("\n");
}
#if 0
IDFinderData ifd;
ifd.success = 0;
ifd.IDname = NULL;
ifd.just_print_it = 1;
for (i=0; i<bf->m_blocks.size(); ++i)
{
BlendBlock* bb = bf->m_blocks[i];
printf("tag='%s'\tptr=%p\ttype=%s\t[%4d]", bb->tag, bb,bf->types[bb->type_index].name,bb->m_array_entries_.size());
block_ID_finder(bb, bf, &ifd);
printf("\n");
}
#endif
}
void bFile::writeChunks(FILE* fp, bool fixupPointers)
{
bParse::bDNA* fileDna = mFileDNA ? mFileDNA : mMemoryDNA;
for (int i=0;i<m_chunks.size();i++)
{
bChunkInd& dataChunk = m_chunks.at(i);
// Ouch! need to rebuild the struct
short *oldStruct,*curStruct;
char *oldType, *newType;
int oldLen, curLen, reverseOld;
oldStruct = fileDna->getStruct(dataChunk.dna_nr);
oldType = fileDna->getType(oldStruct[0]);
oldLen = fileDna->getLength(oldStruct[0]);
///don't try to convert Link block data, just memcpy it. Other data can be converted.
reverseOld = mMemoryDNA->getReverseType(oldType);
if ((reverseOld!=-1))
{
// make sure it's here
//assert(reverseOld!= -1 && "getReverseType() returned -1, struct required!");
//
curStruct = mMemoryDNA->getStruct(reverseOld);
newType = mMemoryDNA->getType(curStruct[0]);
// make sure it's the same
assert((strcmp(oldType, newType)==0) && "internal error, struct mismatch!");
curLen = mMemoryDNA->getLength(curStruct[0]);
dataChunk.dna_nr = reverseOld;
if (strcmp("Link",oldType)!=0)
{
dataChunk.len = curLen * dataChunk.nr;
} else
{
// printf("keep length of link = %d\n",dataChunk.len);
}
//write the structure header
fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
short int* curStruct1;
curStruct1 = mMemoryDNA->getStruct(dataChunk.dna_nr);
assert(curStruct1 == curStruct);
char* cur = fixupPointers ? (char*)findLibPointer(dataChunk.oldPtr) : (char*)dataChunk.oldPtr;
//write the actual contents of the structure(s)
fwrite(cur,dataChunk.len,1,fp);
} else
{
printf("serious error, struct mismatch: don't write\n");
}
}
}
// ----------------------------------------------------- //
int bFile::getNextBlock(bChunkInd *dataChunk, const char *dataPtr, const int flags)
{
bool swap = false;
bool varies = false;
if (flags &FD_ENDIAN_SWAP)
swap = true;
if (flags &FD_BITS_VARIES)
varies = true;
if (VOID_IS_8)
{
if (varies)
{
bChunkPtr4 head;
memcpy(&head, dataPtr, sizeof(bChunkPtr4));
bChunkPtr8 chunk;
chunk.code = head.code;
chunk.len = head.len;
chunk.m_uniqueInts[0] = head.m_uniqueInt;
chunk.m_uniqueInts[1] = 0;
chunk.dna_nr = head.dna_nr;
chunk.nr = head.nr;
if (swap)
{
if ((chunk.code & 0xFFFF)==0)
chunk.code >>=16;
B3_SWITCH_INT(chunk.len);
B3_SWITCH_INT(chunk.dna_nr);
B3_SWITCH_INT(chunk.nr);
}
memcpy(dataChunk, &chunk, sizeof(bChunkInd));
}
else
{
bChunkPtr8 c;
memcpy(&c, dataPtr, sizeof(bChunkPtr8));
if (swap)
{
if ((c.code & 0xFFFF)==0)
c.code >>=16;
B3_SWITCH_INT(c.len);
B3_SWITCH_INT(c.dna_nr);
B3_SWITCH_INT(c.nr);
}
memcpy(dataChunk, &c, sizeof(bChunkInd));
}
}
else
{
if (varies)
{
bChunkPtr8 head;
memcpy(&head, dataPtr, sizeof(bChunkPtr8));
bChunkPtr4 chunk;
chunk.code = head.code;
chunk.len = head.len;
if (head.m_uniqueInts[0]==head.m_uniqueInts[1])
{
chunk.m_uniqueInt = head.m_uniqueInts[0];
} else
{
b3Long64 oldPtr =0;
memcpy(&oldPtr, &head.m_uniqueInts[0], 8);
if (swap)
B3_SWITCH_LONGINT(oldPtr);
chunk.m_uniqueInt = (int)(oldPtr >> 3);
}
chunk.dna_nr = head.dna_nr;
chunk.nr = head.nr;
if (swap)
{
if ((chunk.code & 0xFFFF)==0)
chunk.code >>=16;
B3_SWITCH_INT(chunk.len);
B3_SWITCH_INT(chunk.dna_nr);
B3_SWITCH_INT(chunk.nr);
}
memcpy(dataChunk, &chunk, sizeof(bChunkInd));
}
else
{
bChunkPtr4 c;
memcpy(&c, dataPtr, sizeof(bChunkPtr4));
if (swap)
{
if ((c.code & 0xFFFF)==0)
c.code >>=16;
B3_SWITCH_INT(c.len);
B3_SWITCH_INT(c.dna_nr);
B3_SWITCH_INT(c.nr);
}
memcpy(dataChunk, &c, sizeof(bChunkInd));
}
}
if (dataChunk->len < 0)
return -1;
#if 0
print ("----------");
print (dataChunk->code);
print (dataChunk->len);
print (dataChunk->old);
print (dataChunk->dna_nr);
print (dataChunk->nr);
#endif
return (dataChunk->len+ChunkUtils::getOffset(flags));
}
//eof