More work on serialization and BulletFileLoader

Extras/CMakeLists.txt

@@ -1 +1 @@
-SUBDIRS( glui  ConvexDecomposition BulletColladaConverter LibXML COLLADA_DOM GIMPACTUtils )
+SUBDIRS( glui  ConvexDecomposition BulletColladaConverter LibXML COLLADA_DOM GIMPACTUtils Serialize)

Extras/Serialize/BlenderSerialize/CMakeLists.txt

@@ -0,0 +1,7 @@
+INCLUDE_DIRECTORIES( ${BULLET_PHYSICS_SOURCE_DIR}/src  
+${BULLET_PHYSICS_SOURCE_DIR}/src
+${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BulletFileLoader
+${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BlenderSerialize
+)
+
+ADD_LIBRARY(BlenderSerialize dna249.cpp dna249-64bit.cpp bBlenderFile.cpp  bBlenderFile.h bMain.cpp bMain.h )

Extras/Serialize/BlenderSerialize/bBlenderFile.cpp

@@ -0,0 +1,224 @@
+/*
+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 "bBlenderFile.h"
+#include "bMain.h"
+#include "bDefines.h"
+#include "bDNA.h"
+#include <stdio.h>
+#include <string.h>
+
+// 32 && 64 bit versions
+extern unsigned char DNAstr[];
+extern int DNAlen;
+
+extern unsigned char DNAstr64[];
+extern int DNAlen64;
+
+
+using namespace bParse;
+
+bBlenderFile::bBlenderFile(const char* fileName)
+:bFile(fileName, "BLENDER")
+{
+	mMain= new bMain(this, fileName, mVersion);
+}
+
+
+
+bBlenderFile::bBlenderFile(char *memoryBuffer, int len)
+:bFile(memoryBuffer,len, "BLENDER"),
+mMain(0)
+{
+	mMain= new bMain(this, "memoryBuf", mVersion);
+}
+
+
+bBlenderFile::~bBlenderFile()
+{
+	delete mMain;
+}
+
+
+bMain* bBlenderFile::getMain()
+{
+	return mMain;
+}
+
+// ----------------------------------------------------- //
+void bBlenderFile::parseData()
+{
+	printf ("Building datablocks\n");
+	printf ("Chunk size = %d\n",CHUNK_HEADER_LEN);
+	printf ("File chunk size = %d\n", ChunkUtils::getOffset(mFlags));
+
+	const bool swap = (mFlags&FD_ENDIAN_SWAP)!=0;
+	
+
+
+	char *dataPtr = mFileBuffer+mDataStart;
+
+	bChunkInd dataChunk;
+	dataChunk.code = 0;
+
+
+	//dataPtr += ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
+	int seek = ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
+	//dataPtr += ChunkUtils::getOffset(mFlags);
+	char *dataPtrHead = 0;
+
+	while (dataChunk.code != DNA1)
+	{
+		
+
+
+
+		// one behind
+		if (dataChunk.code == SDNA) break;
+		//if (dataChunk.code == DNA1) break;
+
+		// same as (BHEAD+DATA dependancy)
+		dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
+		char *id = readStruct(dataPtrHead, dataChunk);
+
+		// lookup maps
+		if (id)
+		{
+			mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)id);
+
+			m_chunks.push_back(dataChunk);
+			// block it
+			bListBasePtr *listID = mMain->getListBasePtr(dataChunk.code);
+			if (listID)
+				listID->push_back((bStructHandle*)id);
+		}
+
+		if (dataChunk.code == GLOB)
+		{
+			m_glob = (bStructHandle*) id;
+		}
+
+		// next please!
+		dataPtr += seek;
+
+		seek =  ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
+		if (seek < 0)
+			break;
+	}
+
+}
+
+void	bBlenderFile::addDataBlock(char* dataBlock)
+{
+	mMain->addDatablock(dataBlock);
+}
+
+
+
+
+
+// 32 && 64 bit versions
+extern unsigned char DNAstr[];
+extern int DNAlen;
+
+//unsigned char DNAstr[]={0};
+//int DNAlen=0;
+
+
+extern unsigned char DNAstr64[];
+extern int DNAlen64;
+
+
+void	bBlenderFile::writeDNA(FILE* fp)
+{
+
+	bChunkInd dataChunk;
+	dataChunk.code = DNA1;
+	dataChunk.dna_nr = 0;
+	dataChunk.nr = 1;
+	
+	if (VOID_IS_8)
+	{
+		dataChunk.len = DNAlen64;
+		dataChunk.oldPtr = DNAstr64;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(DNAstr64, DNAlen64,1,fp);
+	}
+	else
+	{
+		dataChunk.len = DNAlen;
+		dataChunk.oldPtr = DNAstr;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(DNAstr, DNAlen,1,fp);
+	}
+}
+
+void	bBlenderFile::parse(bool verboseDumpAllTypes)
+{
+	if (VOID_IS_8)
+	{
+		parseInternal(verboseDumpAllTypes,(char*)DNAstr64,DNAlen64);
+	}
+	else
+	{
+		parseInternal(verboseDumpAllTypes,(char*)DNAstr,DNAlen);
+	}
+}
+
+// experimental
+int		bBlenderFile::write(const char* fileName, bool fixupPointers)
+{
+	FILE *fp = fopen(fileName, "wb");
+	if (fp)
+	{
+		char header[SIZEOFBLENDERHEADER] ;
+		memcpy(header, m_headerString, 7);
+		int endian= 1;
+		endian= ((char*)&endian)[0];
+
+		if (endian)
+		{
+			header[7] = '_';
+		} else
+		{
+			header[7] = '-';
+		}
+		if (VOID_IS_8)
+		{
+			header[8]='V';
+		} else
+		{
+			header[8]='v';
+		}
+
+		header[9] = '2';
+		header[10] = '4';
+		header[11] = '9';
+		
+		fwrite(header,SIZEOFBLENDERHEADER,1,fp);
+
+		writeChunks(fp, fixupPointers);
+
+		writeDNA(fp);
+
+		fclose(fp);
+		
+	} else
+	{
+		printf("Error: cannot open file %s for writing\n",fileName);
+		return 0;
+	}
+	return 1;
+}

Extras/Serialize/BlenderSerialize/bBlenderFile.h

@@ -0,0 +1,63 @@
+/*
+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.
+*/
+
+#ifndef B_BLENDER_FILE_H
+#define B_BLENDER_FILE_H
+
+
+#include "bFile.h"
+
+namespace bParse {
+
+	// ----------------------------------------------------- //
+	class bBlenderFile : public bFile
+	{
+
+	protected:
+		bMain*				mMain;
+
+		bStructHandle*		m_glob;
+
+		
+	public:
+
+		bBlenderFile(const char* fileName);
+
+		bBlenderFile(char *memoryBuffer, int len);
+
+		virtual ~bBlenderFile();
+
+		bMain* getMain();
+
+		virtual	void	addDataBlock(char* dataBlock);
+
+		bStructHandle*		getFileGlobal()
+		{
+			return m_glob;
+		}
+
+		// experimental
+		virtual int		write(const char* fileName, bool fixupPointers = false);
+
+		virtual	void	parse(bool verboseDumpAllTypes);
+
+		virtual	void parseData();
+
+		virtual	void	writeDNA(FILE* fp);
+
+	};
+};
+
+#endif //B_BLENDER_FILE_H

Extras/Serialize/BlenderSerialize/bMain.cpp

@@ -0,0 +1,392 @@
+/*
+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 "bMain.h"
+#include "bBlenderFile.h"
+#include "bDefines.h"
+#include "bChunk.h"
+#include "bDNA.h"
+
+using namespace bParse;
+
+
+// ----------------------------------------------------- //
+bMain::bMain(bBlenderFile *filePtr, const char *baseName, int fileVersion)
+	:	mFP(filePtr),
+		mVersion(fileVersion),
+		mName(baseName)	
+{
+	mData.insert(ID_SCE,bListBasePtr());
+	mData.insert(ID_LI,bListBasePtr());
+	mData.insert(ID_OB,bListBasePtr());
+	mData.insert(ID_ME,bListBasePtr());
+	mData.insert(ID_CU,bListBasePtr());
+	mData.insert(ID_MB,bListBasePtr());
+	mData.insert(ID_MA,bListBasePtr());
+	mData.insert(ID_TE,bListBasePtr());
+	mData.insert(ID_IM,bListBasePtr());
+	mData.insert(ID_WV,bListBasePtr());
+	mData.insert(ID_LT,bListBasePtr());
+	mData.insert(ID_LA,bListBasePtr());
+	mData.insert(ID_CA,bListBasePtr());
+	mData.insert(ID_IP,bListBasePtr());
+	mData.insert(ID_KE,bListBasePtr());
+	mData.insert(ID_WO,bListBasePtr());
+	mData.insert(ID_SCR,bListBasePtr());
+	mData.insert(ID_VF,bListBasePtr());
+	mData.insert(ID_TXT,bListBasePtr());
+	mData.insert(ID_SO,bListBasePtr());
+	mData.insert(ID_GR,bListBasePtr());
+	mData.insert(ID_AR,bListBasePtr());
+	mData.insert(ID_AC,bListBasePtr());
+	mData.insert(ID_NT,bListBasePtr());
+	mData.insert(ID_BR,bListBasePtr());
+	mData.insert(ID_SCRIPT, bListBasePtr());
+}
+
+
+// ----------------------------------------------------- //
+bMain::~bMain()
+{
+	// allocated data blocks!
+
+	int sz = mPool.size();
+	for (int i=0;i<sz;i++)
+	{
+		delete [] mPool[i];
+	}
+}
+
+// ----------------------------------------------------- //
+int bMain::getVersion()
+{
+	return mVersion;
+}
+
+// ----------------------------------------------------- //
+const char *bMain::getName()
+{
+	return mName;
+}
+
+// ----------------------------------------------------- //
+void bMain::addDatablock(void *allocated)
+{
+	assert(allocated);
+	mPool.push_back((bStructHandle*)allocated);
+}
+
+
+
+
+// ------------------------------------------------------------//
+void bMain::linkList(void *listBasePtr)
+{
+
+	struct ListBase // local Blender::ListBase
+	{
+		void *first;
+		void *last;
+	};
+
+	struct Link // local Blender::Link
+	{
+		void *next;
+		void *prev;
+	};
+
+
+	ListBase *base = (ListBase*)listBasePtr;
+
+	if (!base || !base->first)
+		return;
+
+	base->first = mFP->findLibPointer(base->first);
+	if (!base->first)
+	{
+		base->last = 0;
+		return;
+	}
+
+	void *prev = 0;
+	Link *l = (Link*)base->first;
+	while (l)
+	{
+		l->next = mFP->findLibPointer(l->next);
+		l->prev = l->next;
+		prev = l->next;
+		l = (Link*)l->next;
+	}
+}
+
+// ------------------------------------------------------------//
+bListBasePtr* bMain::getListBasePtr(int listBaseCode)
+{
+	bListBasePtr *ptr = _findCode(listBaseCode);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::_findCode(int code)
+{
+	
+	bListBasePtr* lbPtr = mData.find(code);
+	return lbPtr;
+}
+
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getScene()
+{
+	bListBasePtr *ptr = _findCode(ID_SCE);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getLibrary()
+{
+	bListBasePtr *ptr = _findCode(ID_LI);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getObject()
+{
+	bListBasePtr *ptr = _findCode(ID_OB);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getMesh()
+{
+	bListBasePtr *ptr = _findCode(ID_ME);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getCurve()
+{
+	bListBasePtr *ptr = _findCode(ID_CU);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getMball()
+{
+	bListBasePtr *ptr = _findCode(ID_MB);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getMat()
+{
+	bListBasePtr *ptr = _findCode(ID_MA);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getTex()
+{
+	bListBasePtr *ptr = _findCode(ID_TE);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getImage()
+{
+	bListBasePtr *ptr = _findCode(ID_IM);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getWave()
+{
+	bListBasePtr *ptr = _findCode(ID_WV);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getLatt()
+{
+	bListBasePtr *ptr = _findCode(ID_LT);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getLamp()
+{
+	bListBasePtr *ptr = _findCode(ID_LA);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getCamera()
+{
+	bListBasePtr *ptr = _findCode(ID_CA);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getIpo()
+{
+	bListBasePtr *ptr = _findCode(ID_IP);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getKey()
+{
+	bListBasePtr *ptr = _findCode(ID_KE);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getWorld()
+{
+	bListBasePtr *ptr = _findCode(ID_WO);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getScreen()
+{
+	bListBasePtr *ptr = _findCode(ID_SCR);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getScript()
+{
+	bListBasePtr *ptr = _findCode(ID_SCRIPT);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getVfont()
+{
+	bListBasePtr *ptr = _findCode(ID_VF);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getText()
+{
+	bListBasePtr *ptr = _findCode(ID_TXT);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getSound()
+{
+	bListBasePtr *ptr = _findCode(ID_SO);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getGroup()
+{
+	bListBasePtr *ptr = _findCode(ID_GR);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getArmature()
+{
+	bListBasePtr *ptr = _findCode(ID_AR);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getAction()
+{
+	bListBasePtr *ptr = _findCode(ID_AC);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getNodetree()
+{
+	bListBasePtr *ptr = _findCode(ID_NT);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+// ------------------------------------------------------------//
+bListBasePtr *bMain::getBrush()
+{
+	bListBasePtr *ptr = _findCode(ID_BR);
+	if (!ptr)
+		return 0;
+	return ptr;
+}
+
+
+
+//eof

Extras/Serialize/BlenderSerialize/bMain.h

@@ -0,0 +1,110 @@
+/*
+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.
+*/
+
+#ifndef __BMAIN_H__
+#define __BMAIN_H__
+
+#include "bCommon.h"
+#include "bChunk.h"
+#include "LinearMath/btHashMap.h"
+
+
+namespace bParse
+{
+	class bDNA;
+
+	class bBlenderFile;
+};
+
+
+
+namespace bParse {
+
+
+	// ----------------------------------------------------- //
+	
+	typedef	btHashMap<btHashInt,bListBasePtr> bMainDataMap;
+
+
+
+	// ----------------------------------------------------- //
+	class bMain
+	{
+	//private:
+	public:
+		bBlenderFile*			mFP;
+		bListBasePtr	mPool;
+
+		int				mVersion;
+		const char*		mName;
+
+		bMainDataMap	mData;
+
+	
+
+
+		bListBasePtr *_findCode(int code);
+
+	public:
+		bMain(bBlenderFile  *filePtr, const char *baseName, int fileVersion);
+		~bMain();
+
+		int getVersion();
+		const char *getName();
+
+		bListBasePtr *getListBasePtr(int listBaseCode);
+
+
+		bListBasePtr *getScene();
+		bListBasePtr *getLibrary();
+		bListBasePtr *getObject();
+		bListBasePtr *getMesh();
+		bListBasePtr *getCurve();
+		bListBasePtr *getMball();
+		bListBasePtr *getMat();
+		bListBasePtr *getTex();
+		bListBasePtr *getImage();
+		bListBasePtr *getWave();
+		bListBasePtr *getLatt();
+		bListBasePtr *getLamp();
+		bListBasePtr *getCamera();
+		bListBasePtr *getIpo();
+		bListBasePtr *getKey();
+		bListBasePtr *getWorld();
+		bListBasePtr *getScreen();
+		bListBasePtr *getScript();
+		bListBasePtr *getVfont();
+		bListBasePtr *getText();
+		bListBasePtr *getSound();
+		bListBasePtr *getGroup();
+		bListBasePtr *getArmature();
+		bListBasePtr *getAction();
+		bListBasePtr *getNodetree();
+		bListBasePtr *getBrush();
+
+
+		
+		// tracking allocated memory
+		void addDatablock(void *allocated);
+
+
+		// --
+		
+		void linkList(void *listBasePtr);
+	};
+}
+
+
+#endif//__BMAIN_H__

Extras/Serialize/BulletFileLoader/CMakeLists.txt

@@ -0,0 +1,17 @@
+INCLUDE_DIRECTORIES( 
+	${BULLET_PHYSICS_SOURCE_DIR}/src  
+)
+
+ADD_LIBRARY(
+BulletFileLoader 
+bChunk.cpp 
+bChunk.h 
+bCommon.h 
+bDefines.h 
+bDNA.cpp 
+bDNA.h 
+bFile.cpp 
+bFile.h
+btBulletFile.cpp 
+btBulletFile.h 
+)

Extras/Serialize/BulletFileLoader/autogenerated/bullet.h

@@ -0,0 +1,32 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_H__
+#define __BULLET_H__
+#include "bullet_PointerArray.h"
+#include "bullet_btPhysicsSystem.h"
+#include "bullet_ListBase.h"
+#include "bullet_btVector3Data.h"
+#include "bullet_btMatrix3x3Data.h"
+#include "bullet_btTransformData.h"
+#include "bullet_btCollisionShapeData.h"
+#include "bullet_btConvexInternalShapeData.h"
+#include "bullet_btCollisionObjectData.h"
+#include "bullet_btRigidBodyData.h"
+#endif//__BULLET_H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_Common.h

@@ -0,0 +1,40 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLETCOMMON_H__
+#define __BULLETCOMMON_H__
+
+// put an empty struct in the case
+typedef struct bInvalidHandle {
+	int unused;
+}bInvalidHandle;
+
+namespace Bullet {
+    class PointerArray;
+    class btPhysicsSystem;
+    class ListBase;
+    class btVector3Data;
+    class btMatrix3x3Data;
+    class btTransformData;
+    class btCollisionShapeData;
+    class btConvexInternalShapeData;
+    class btCollisionObjectData;
+    class btRigidBodyData;
+}
+#endif//__BULLETCOMMON_H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_ListBase.h

@@ -0,0 +1,40 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_LISTBASE__H__
+#define __BULLET_LISTBASE__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class ListBase
+    {
+    public:
+        void *first;
+        void *last;
+    };
+}
+
+
+#endif//__BULLET_LISTBASE__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_PointerArray.h

@@ -0,0 +1,41 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_POINTERARRAY__H__
+#define __BULLET_POINTERARRAY__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class PointerArray
+    {
+    public:
+        int m_size;
+        int m_capacity;
+        void *m_data;
+    };
+}
+
+
+#endif//__BULLET_POINTERARRAY__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_btCollisionObjectData.h

@@ -0,0 +1,63 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_BTCOLLISIONOBJECTDATA__H__
+#define __BULLET_BTCOLLISIONOBJECTDATA__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+#include "bullet_btTransformData.h"
+#include "bullet_btVector3Data.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class btCollisionObjectData
+    {
+    public:
+        btTransformData m_worldTransform;
+        btTransformData m_interpolationWorldTransform;
+        btVector3Data m_interpolationLinearVelocity;
+        btVector3Data m_interpolationAngularVelocity;
+        btVector3Data m_anisotropicFriction;
+        int m_hasAnisotropicFriction;
+        btScalar m_contactProcessingThreshold;
+        void *m_broadphaseHandle;
+        void *m_collisionShape;
+        btCollisionShapeData *m_rootCollisionShape;
+        int m_collisionFlags;
+        int m_islandTag1;
+        int m_companionId;
+        int m_activationState1;
+        btScalar m_deactivationTime;
+        btScalar m_friction;
+        btScalar m_restitution;
+        int m_internalType;
+        void *m_userObjectPointer;
+        btScalar m_hitFraction;
+        btScalar m_ccdSweptSphereRadius;
+        btScalar m_ccdMotionThreshold;
+        int m_checkCollideWith;
+    };
+}
+
+
+#endif//__BULLET_BTCOLLISIONOBJECTDATA__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_btCollisionShapeData.h

@@ -0,0 +1,41 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_BTCOLLISIONSHAPEDATA__H__
+#define __BULLET_BTCOLLISIONSHAPEDATA__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class btCollisionShapeData
+    {
+    public:
+        void *m_userPointer;
+        int m_shapeType;
+        char m_padding[4];
+    };
+}
+
+
+#endif//__BULLET_BTCOLLISIONSHAPEDATA__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_btConvexInternalShapeData.h

@@ -0,0 +1,45 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_BTCONVEXINTERNALSHAPEDATA__H__
+#define __BULLET_BTCONVEXINTERNALSHAPEDATA__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+#include "bullet_btCollisionShapeData.h"
+#include "bullet_btVector3Data.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class btConvexInternalShapeData
+    {
+    public:
+        btCollisionShapeData m_collisionShapeData;
+        btVector3Data m_localScaling;
+        btVector3Data m_implicitShapeDimensions;
+        btScalar m_collisionMargin;
+        char m_padding[4];
+    };
+}
+
+
+#endif//__BULLET_BTCONVEXINTERNALSHAPEDATA__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_btMatrix3x3Data.h

@@ -0,0 +1,40 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_BTMATRIX3X3DATA__H__
+#define __BULLET_BTMATRIX3X3DATA__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+#include "bullet_btVector3Data.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class btMatrix3x3Data
+    {
+    public:
+        btVector3Data m_el[3];
+    };
+}
+
+
+#endif//__BULLET_BTMATRIX3X3DATA__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_btPhysicsSystem.h

@@ -0,0 +1,42 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_BTPHYSICSSYSTEM__H__
+#define __BULLET_BTPHYSICSSYSTEM__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+#include "bullet_PointerArray.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class btPhysicsSystem
+    {
+    public:
+        PointerArray m_collisionShapes;
+        PointerArray m_collisionObjects;
+        PointerArray m_constraints;
+    };
+}
+
+
+#endif//__BULLET_BTPHYSICSSYSTEM__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_btRigidBodyData.h

@@ -0,0 +1,62 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_BTRIGIDBODYDATA__H__
+#define __BULLET_BTRIGIDBODYDATA__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+#include "bullet_btCollisionObjectData.h"
+#include "bullet_btMatrix3x3Data.h"
+#include "bullet_btVector3Data.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class btRigidBodyData
+    {
+    public:
+        btCollisionObjectData m_collisionObjectData;
+        btMatrix3x3Data m_invInertiaTensorWorld;
+        btVector3Data m_linearVelocity;
+        btVector3Data m_angularVelocity;
+        btScalar m_inverseMass;
+        btVector3Data m_angularFactor;
+        btVector3Data m_linearFactor;
+        btVector3Data m_gravity;
+        btVector3Data m_gravity_acceleration;
+        btVector3Data m_invInertiaLocal;
+        btVector3Data m_totalForce;
+        btVector3Data m_totalTorque;
+        btScalar m_linearDamping;
+        btScalar m_angularDamping;
+        int m_additionalDamping;
+        btScalar m_additionalDampingFactor;
+        btScalar m_additionalLinearDampingThresholdSqr;
+        btScalar m_additionalAngularDampingThresholdSqr;
+        btScalar m_additionalAngularDampingFactor;
+        btScalar m_linearSleepingThreshold;
+        btScalar m_angularSleepingThreshold;
+    };
+}
+
+
+#endif//__BULLET_BTRIGIDBODYDATA__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_btTransformData.h

@@ -0,0 +1,42 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_BTTRANSFORMDATA__H__
+#define __BULLET_BTTRANSFORMDATA__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+#include "bullet_btMatrix3x3Data.h"
+#include "bullet_btVector3Data.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class btTransformData
+    {
+    public:
+        btMatrix3x3Data m_basis;
+        btVector3Data m_origin;
+    };
+}
+
+
+#endif//__BULLET_BTTRANSFORMDATA__H__

Extras/Serialize/BulletFileLoader/autogenerated/bullet_btVector3Data.h

@@ -0,0 +1,39 @@
+/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+#ifndef __BULLET_BTVECTOR3DATA__H__
+#define __BULLET_BTVECTOR3DATA__H__
+
+
+// -------------------------------------------------- //
+#include "bullet_Common.h"
+
+namespace Bullet {
+
+
+    // ---------------------------------------------- //
+    class btVector3Data
+    {
+    public:
+        btScalar m_floats[4];
+    };
+}
+
+
+#endif//__BULLET_BTVECTOR3DATA__H__

Extras/Serialize/BulletFileLoader/bChunk.cpp

@@ -0,0 +1,188 @@
+/*
+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 <memory.h>
+#include "bChunk.h"
+#include "bDefines.h"
+#include "bFile.h"
+
+using namespace bParse;
+
+
+// ----------------------------------------------------- //
+short ChunkUtils::swapShort(short sht)
+{
+	SWITCH_SHORT(sht);
+	return sht;
+}
+
+// ----------------------------------------------------- //
+int ChunkUtils::swapInt(int inte)
+{
+	SWITCH_INT(inte);
+	return inte;
+}
+
+// ----------------------------------------------------- //
+long64 ChunkUtils::swapLong64(long64 lng)
+{
+	SWITCH_LONGINT(lng);
+	return lng;
+}
+
+// ----------------------------------------------------- //
+int ChunkUtils::getOffset(int flags)
+{
+	// if the file is saved in a
+	// different format, get the
+	// file's chunk size
+	int res = CHUNK_HEADER_LEN;
+
+	if (VOID_IS_8)
+	{
+		if (flags &FD_BITS_VARIES)
+			res = sizeof(bChunkPtr4);
+	}
+	else
+	{
+		if (flags &FD_BITS_VARIES)
+			res = sizeof(bChunkPtr8);
+	}
+	return res;
+}
+
+
+// ----------------------------------------------------- //
+int ChunkUtils::getNextBlock(bChunkInd *dataChunk,  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.old		= head.old;
+			chunk.dna_nr	= head.dna_nr;
+			chunk.nr		= head.nr;
+
+			if (swap)
+			{
+				if ((chunk.code & 0xFFFF)==0)
+					chunk.code >>=16;
+
+				SWITCH_INT(chunk.len);
+				SWITCH_INT(chunk.dna_nr);
+				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;
+
+				SWITCH_INT(c.len);
+				SWITCH_INT(c.dna_nr);
+				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;
+
+			long64 oldPtr =0;
+
+			memcpy(&oldPtr, &head.old, 8);
+			chunk.old = (int)(oldPtr >> 3);
+
+			chunk.dna_nr = head.dna_nr;
+			chunk.nr = head.nr;
+
+			if (swap)
+			{
+				if ((chunk.code & 0xFFFF)==0)
+					chunk.code >>=16;
+
+				SWITCH_INT(chunk.len);
+				SWITCH_INT(chunk.dna_nr);
+				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;
+
+				SWITCH_INT(c.len);
+				SWITCH_INT(c.dna_nr);
+				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+getOffset(flags));
+}
+
+
+
+//eof

Extras/Serialize/BulletFileLoader/bChunk.h

@@ -0,0 +1,85 @@
+/*
+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.
+*/
+
+#ifndef __BCHUNK_H__
+#define __BCHUNK_H__
+
+
+#ifdef WIN32
+	#define long64 __int64
+#else
+	#define long64 long long
+#endif
+
+
+namespace bParse {
+
+
+	// ----------------------------------------------------- //
+	class bChunkPtr4
+	{
+	public:
+		bChunkPtr4(){}
+		int code;
+		int len;
+		int old;
+		int dna_nr;
+		int nr;
+	};
+
+	// ----------------------------------------------------- //
+	class bChunkPtr8
+	{
+	public:
+		bChunkPtr8(){}
+		int code,  len;
+		long64 old;
+		int dna_nr, nr;
+	};
+
+	// ----------------------------------------------------- //
+	class bChunkInd
+	{
+	public:
+		bChunkInd(){}
+		int code, len;
+		void *oldPtr;
+		int dna_nr, nr;
+	};
+
+
+	// ----------------------------------------------------- //
+	class ChunkUtils
+	{
+	public:
+		// buffer offset util
+		static int getNextBlock(bChunkInd *dataChunk,  char *dataPtr, const int flags);
+		
+		// file chunk offset
+		static int getOffset(int flags);
+
+		// endian utils
+		static short swapShort(short sht);
+		static int swapInt(int inte);
+		static long64 swapLong64(long64 lng);
+
+	};
+
+
+	const int CHUNK_HEADER_LEN = ((sizeof(bChunkInd)));
+	const bool VOID_IS_8 = ((sizeof(void*)==8));
+}
+
+#endif//__BCHUNK_H__

Extras/Serialize/BulletFileLoader/bCommon.h

@@ -0,0 +1,39 @@
+/*
+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.
+*/
+
+#ifndef __BCOMMON_H__
+#define __BCOMMON_H__
+
+
+#include <assert.h>
+//#include "bLog.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+namespace bParse {
+
+	class bMain;
+	class bFileData;
+	class bFile;
+	class bDNA;
+
+	// delete void* undefined
+	typedef struct bStructHandle {int unused;}bStructHandle;
+	typedef btAlignedObjectArray<bStructHandle*>	bListBasePtr;
+	typedef btHashMap<btHashPtr, bStructHandle*> bPtrMap;
+}
+
+
+#endif//__BCOMMON_H__

Extras/Serialize/BulletFileLoader/bDNA.cpp

@@ -0,0 +1,624 @@
+/*
+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 <assert.h>
+
+#include "bDNA.h"
+#include "bChunk.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace bParse;
+
+
+// ----------------------------------------------------- //
+bDNA::bDNA()
+	:	mPtrLen(0)
+{
+	// --
+}
+
+// ----------------------------------------------------- //
+bDNA::~bDNA()
+{
+	// --
+}
+
+// ----------------------------------------------------- //
+bool bDNA::lessThan(bDNA *file)
+{
+	return ( m_Names.size() < file->m_Names.size());
+}
+
+// ----------------------------------------------------- //
+char *bDNA::getName(int ind)
+{
+	assert(ind <= (int)m_Names.size());
+	return m_Names[ind].m_name;
+}
+
+
+// ----------------------------------------------------- //
+char *bDNA::getType(int ind)
+{
+	assert(ind<=  (int)mTypes.size());
+	return mTypes[ind];
+}
+
+
+// ----------------------------------------------------- //
+short *bDNA::getStruct(int ind)
+{
+	assert(ind <=  (int)mStructs.size());
+	return mStructs[ind];
+}
+
+
+// ----------------------------------------------------- //
+short bDNA::getLength(int ind)
+{
+	assert(ind <=  (int)mTlens.size());
+	return mTlens[ind];
+}
+
+
+// ----------------------------------------------------- //
+int bDNA::getReverseType(short type)
+{
+
+	int* intPtr = mStructReverse.find(type);
+	if (intPtr)
+		return *intPtr;
+
+	return -1;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getReverseType(const char *type)
+{
+
+	btHashString key(type);
+	int* valuePtr = mTypeLookup.find(key);
+	if (valuePtr)
+		return *valuePtr;
+	
+	return -1;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getNumStructs()
+{
+	return (int)mStructs.size();
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagNotEqual(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	return mCMPFlags[dna_nr] == FDF_STRUCT_NEQU;
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagEqual(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	int flag = mCMPFlags[dna_nr];
+	return  flag == FDF_STRUCT_EQU;
+}
+
+// ----------------------------------------------------- //
+bool bDNA::flagNone(int dna_nr)
+{
+	assert(dna_nr <=	(int)mCMPFlags.size());
+	return mCMPFlags[dna_nr] == FDF_NONE;
+}
+
+// ----------------------------------------------------- //
+int bDNA::getPointerSize()
+{
+	return mPtrLen;
+}
+
+// ----------------------------------------------------- //
+void bDNA::initRecurseCmpFlags(int iter)
+{
+	// iter is FDF_STRUCT_NEQU
+
+	short *oldStrc = mStructs[iter];
+	short type = oldStrc[0];
+
+	for (int i=0; i<(int)mStructs.size(); i++)
+	{
+		if (i != iter && mCMPFlags[i] == FDF_STRUCT_EQU )
+		{
+			short *curStruct = mStructs[i];
+			int eleLen = curStruct[1];
+			curStruct+=2;
+
+			for (int j=0; j<eleLen; j++, curStruct+=2)
+			{
+				if (curStruct[0] == type)
+				{
+					//char *name = m_Names[curStruct[1]].m_name;
+					//if (name[0] != '*')
+					if (m_Names[curStruct[1]].m_isPointer)
+					{
+						mCMPFlags[i] = FDF_STRUCT_NEQU;
+						initRecurseCmpFlags(i);
+					}
+				}
+			}
+		}
+	}
+}
+
+// ----------------------------------------------------- //
+void bDNA::initCmpFlags(bDNA *memDNA)
+{
+
+    // compare the file to memory
+	// this ptr should be the file data
+
+
+	assert(!m_Names.size() == 0 && "SDNA empty!");
+	mCMPFlags.resize(mStructs.size(), FDF_NONE);
+
+
+
+	for (int i=0; i<(int)mStructs.size(); i++)
+	{
+		short *oldStruct = mStructs[i];
+
+		int oldLookup = getReverseType(oldStruct[0]);
+		if (oldLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+//#define SLOW_FORWARD_COMPATIBLE 1
+#ifdef SLOW_FORWARD_COMPATIBLE
+		char* typeName = mTypes[oldLookup];
+		int newLookup = memDNA->getReverseType(typeName);
+		if (newLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+		short *curStruct = memDNA->mStructs[newLookup];
+#else
+		// memory for file
+
+		if (oldLookup < memDNA->mStructs.size())
+		{
+			short *curStruct = memDNA->mStructs[oldLookup];
+#endif	
+	
+		
+
+			// rebuild...
+			mCMPFlags[i] = FDF_STRUCT_NEQU;
+
+#if 1
+			if (curStruct[1] == oldStruct[1])
+			{
+				// type len same ...
+				if (mTlens[oldStruct[0]] == memDNA->mTlens[curStruct[0]])
+				{
+					bool isSame = true;
+					int elementLength = oldStruct[1];
+
+
+					curStruct+=2;
+					oldStruct+=2;
+
+
+					for (int j=0; j<elementLength; j++, curStruct+=2, oldStruct+=2)
+					{
+						// type the same
+						if (strcmp(mTypes[oldStruct[0]], memDNA->mTypes[curStruct[0]])!=0)
+						{
+							isSame=false;
+							break;
+						}
+
+						// name the same
+						if (strcmp(m_Names[oldStruct[1]].m_name, memDNA->m_Names[curStruct[1]].m_name)!=0)
+						{
+							isSame=false;
+							break;
+						}
+					}
+					// flag valid ==
+					if (isSame)
+						mCMPFlags[i] = FDF_STRUCT_EQU;
+				}
+			}
+#endif
+		}
+	}
+
+
+
+
+
+	// recurse in
+	for (int i=0; i<(int)mStructs.size(); i++)
+	{
+		if (mCMPFlags[i] == FDF_STRUCT_NEQU)
+			initRecurseCmpFlags(i);
+	}
+}
+
+
+
+
+static int name_is_array(char* name, int* dim1, int* dim2) {
+	int len = strlen(name);
+	/*fprintf(stderr,"[%s]",name);*/
+	/*if (len >= 1) {
+	if (name[len-1] != ']')
+	return 1;
+	}
+	return 0;*/
+	char *bp;
+	int num;
+	if (dim1) {
+		*dim1 = 1;
+	}
+	if (dim2) {
+		*dim2 = 1;
+	}
+	bp = strchr(name, '[');
+	if (!bp) {
+		return 0;
+	}
+	num = 0;
+	while (++bp < name+len-1) {
+		const char c = *bp;
+		if (c == ']') {
+			break;
+		}
+		if (c <= '9' && c >= '0') {
+			num *= 10;
+			num += (c - '0');
+		} else {
+			printf("array parse error.\n");
+			return 0;
+		}
+	}
+	if (dim2) {
+		*dim2 = num;
+	}
+
+	/* find second dim, if any. */
+	bp = strchr(bp, '[');
+	if (!bp) {
+		return 1; /* at least we got the first dim. */
+	}
+	num = 0;
+	while (++bp < name+len-1) {
+		const char c = *bp;
+		if (c == ']') {
+			break;
+		}
+		if (c <= '9' && c >= '0') {
+			num *= 10;
+			num += (c - '0');
+		} else {
+			printf("array2 parse error.\n");
+			return 1;
+		}
+	}
+	if (dim1) {
+		if (dim2) {
+			*dim1 = *dim2;
+			*dim2 = num;
+		} else {
+			*dim1 = num;
+		}
+	}
+
+	return 1;
+}
+
+
+// ----------------------------------------------------- //
+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++;
+
+	cp = (char*)intPtr;
+	for (int i=0; i<dataLen; i++)
+	{
+		bNameInfo info;
+		info.m_name = cp;
+		info.m_isPointer = (info.m_name[0] == '*') || (info.m_name[1] == '*');
+		name_is_array(info.m_name,&info.m_dim0,&info.m_dim1);
+		m_Names.push_back(info);
+		while (*cp)cp++;
+		cp++;
+	}
+
+	
+	{
+		nr= (long)cp;
+		long mask=3;
+		nr= ((nr+3)&~3)-nr;
+		while (nr--)
+		{
+			cp++;
+		}
+	}
+
+
+	/*
+		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++;
+
+	cp = (char*)intPtr;
+	for (int i=0; i<dataLen; i++)
+	{
+		mTypes.push_back(cp);
+		while (*cp)cp++;
+		cp++;
+	}
+
+{
+		nr= (long)cp;
+		long mask=3;
+		nr= ((nr+3)&~3)-nr;
+		while (nr--)
+		{
+			cp++;
+		}
+	}
+
+
+	/*
+		TLEN (4 bytes)
+		<len> (short) the lengths of types
+		<len>
+	*/
+
+	// Parse type lens
+	intPtr = (int*)cp;
+	assert(strncmp(cp, "TLEN", 4)==0); intPtr++;
+
+	dataLen = (int)mTypes.size();
+
+	shtPtr = (short*)intPtr;
+	for (int i=0; i<dataLen; i++, shtPtr++)
+	{
+		if (swap)
+			shtPtr[0] = ChunkUtils::swapShort(shtPtr[0]);
+		mTlens.push_back(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++;
+
+
+	shtPtr = (short*)intPtr;
+	for (int i=0; i<dataLen; i++)
+	{
+		mStructs.push_back (shtPtr);
+		if (swap)
+		{
+			shtPtr[0]= ChunkUtils::swapShort(shtPtr[0]);
+			shtPtr[1]= ChunkUtils::swapShort(shtPtr[1]);
+
+			int len = 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;
+	}
+
+
+	// build reverse lookups
+	for (int i=0; i<(int)mStructs.size(); i++)
+	{
+		short *strc = mStructs.at(i);
+		if (!mPtrLen && strcmp(mTypes[strc[0]],"ListBase")==0)
+		{
+			mPtrLen = mTlens[strc[0]]/2;
+		}
+
+		mStructReverse.insert(strc[0], i);
+		mTypeLookup.insert(btHashString(mTypes[strc[0]]),i);
+	}
+}
+
+
+// ----------------------------------------------------- //
+int bDNA::getArraySize(char* string)
+{
+	int ret = 1;
+	int len = strlen(string);
+
+	
+	char* next = 0;
+	for (int i=0; i<len; i++)
+	{
+		char c = string[i];
+
+		if (c == '[')
+			next = &string[i+1];
+		else if (c==']')
+			if (next)
+				ret *= atoi(next);
+	}
+
+//	print (string << ' ' << ret);
+	return ret;
+}
+
+
+void bDNA::dumpTypeDefinitions()
+{
+	int i;
+
+	int numTypes = mTypes.size();
+	
+	for (i=0;i<numTypes;i++)
+	{
+
+	}
+
+	for (int i=0; i<(int)mStructs.size(); i++)
+	{
+		int totalBytes=0;
+		short *oldStruct = mStructs[i];
+
+		int oldLookup = getReverseType(oldStruct[0]);
+		if (oldLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+
+		short* newStruct = mStructs[oldLookup];
+		char* typeName = mTypes[newStruct[0]];
+		printf("%3d: %s ",i,typeName);
+		
+		//char *name = mNames[oldStruct[1]];
+		int len = oldStruct[1];
+		printf(" (%d fields) ",len);
+		oldStruct+=2;
+
+		printf("{");
+		int j;
+		for (j=0; j<len; ++j,oldStruct+=2) {
+			const char* name = m_Names[oldStruct[1]].m_name;
+			printf("%s %s",	mTypes[oldStruct[0]],name);
+			int elemNumBytes= 0;
+			int arrayDimensions = getArraySizeNew(oldStruct[1]);
+
+			if (m_Names[oldStruct[1]].m_isPointer)
+			{
+				elemNumBytes = VOID_IS_8 ? 8 : 4;
+			} else
+			{
+				elemNumBytes = getLength(oldStruct[0]);
+			}
+			printf(" /* %d bytes */",elemNumBytes*arrayDimensions);
+			
+			if (j == len-1) {
+				printf(";}");
+			} else {
+				printf("; ");
+			}
+			totalBytes+=elemNumBytes*arrayDimensions;
+		}
+		printf("\ntotalBytes=%d\n\n",totalBytes);
+
+	}
+	
+
+
+#if 0
+	/* dump out display of types and their sizes */
+	for (i=0; i<bf->types_count; ++i) {
+		/* if (!bf->types[i].is_struct)*/
+		{
+			printf("%3d: sizeof(%s%s)=%d",
+				i,
+				bf->types[i].is_struct ? "struct " : "atomic ",
+				bf->types[i].name, bf->types[i].size);
+			if (bf->types[i].is_struct) {
+				int j;
+				printf(", %d fields: { ", bf->types[i].fieldtypes_count);
+				for (j=0; j<bf->types[i].fieldtypes_count; ++j) {
+					printf("%s %s",
+						bf->types[bf->types[i].fieldtypes[j]].name,
+						bf->names[bf->types[i].fieldnames[j]]);
+					if (j == bf->types[i].fieldtypes_count-1) {
+						printf(";}");
+					} else {
+						printf("; ");
+					}
+				}
+			}
+			printf("\n\n");
+
+		}
+	}
+#endif
+
+}
+
+
+
+
+//eof
+
+

Extras/Serialize/BulletFileLoader/bDNA.h

@@ -0,0 +1,109 @@
+/*
+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.
+*/
+
+#ifndef __BDNA_H__
+#define __BDNA_H__
+
+
+#include "bCommon.h"
+
+namespace bParse {
+
+	struct	bNameInfo
+	{
+		char*	m_name;
+		bool	m_isPointer;
+		int		m_dim0;
+		int		m_dim1;
+	};
+
+	class bDNA
+	{
+	public:
+		bDNA();
+		~bDNA();
+
+		void init(char *data, int len, bool swap=false);
+
+		int getArraySize(char* str);
+		int getArraySizeNew(short name)
+		{
+			const bNameInfo& nameInfo = m_Names[name];
+			return nameInfo.m_dim0*nameInfo.m_dim1;
+		}
+		int getElementSize(short type, short name)
+		{
+			const bNameInfo& nameInfo = m_Names[name];
+			int size = nameInfo.m_isPointer ? mPtrLen*nameInfo.m_dim0*nameInfo.m_dim1 : mTlens[type]*nameInfo.m_dim0*nameInfo.m_dim1;
+			return size;
+		}
+
+		int	getNumNames() const
+		{
+			return m_Names.size();
+		}
+
+		char *getName(int ind);
+		char *getType(int ind);
+		short *getStruct(int ind);
+		short getLength(int ind);
+		int getReverseType(short type);
+		int getReverseType(const char *type);
+
+
+		int getNumStructs();
+
+		//
+		bool lessThan(bDNA* other);
+
+		void initCmpFlags(bDNA *memDNA);
+		bool flagNotEqual(int dna_nr);
+		bool flagEqual(int dna_nr);
+		bool flagNone(int dna_nr);
+
+
+		int getPointerSize();
+
+		void	dumpTypeDefinitions();
+
+	
+	private:
+		enum FileDNAFlags
+		{
+			FDF_NONE=0,
+			FDF_STRUCT_NEQU,
+			FDF_STRUCT_EQU
+		};
+
+		void initRecurseCmpFlags(int i);
+
+		btAlignedObjectArray<int>			mCMPFlags;
+
+		btAlignedObjectArray<bNameInfo>			m_Names;
+		btAlignedObjectArray<char*>			mTypes;
+		btAlignedObjectArray<short*>			mStructs;
+		btAlignedObjectArray<short>			mTlens;
+		btHashMap<btHashInt, int>			mStructReverse;
+		btHashMap<btHashString,int>	mTypeLookup;
+
+		int							mPtrLen;
+
+
+
+	};
+}
+
+
+#endif//__BDNA_H__

Extras/Serialize/BulletFileLoader/bDefines.h

@@ -0,0 +1,140 @@
+/* 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.
+*/
+#ifndef __B_DEFINES_H__
+#define __B_DEFINES_H__
+
+
+// MISC defines, see BKE_global.h, BKE_utildefines.h
+#define SIZEOFBLENDERHEADER 12
+
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
+#	define MAKE_ID(a,b,c,d) ( (int)(a)<<24 | (int)(b)<<16 | (c)<<8 | (d) )
+#else
+#	define MAKE_ID(a,b,c,d) ( (int)(d)<<24 | (int)(c)<<16 | (b)<<8 | (a) )
+#endif
+
+
+// ------------------------------------------------------------
+#if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
+#	define MAKE_ID2(c, d) ( (c)<<8 | (d) )
+#	define MOST_SIG_BYTE   0
+#	define BBIG_ENDIAN
+#else
+#	define MAKE_ID2(c, d) ( (d)<<8 | (c) )
+#	define MOST_SIG_BYTE  1
+#	define BLITTLE_ENDIAN
+#endif
+
+// ------------------------------------------------------------
+#define ID_SCE		MAKE_ID2('S', 'C')
+#define ID_LI		MAKE_ID2('L', 'I')
+#define ID_OB		MAKE_ID2('O', 'B')
+#define ID_ME		MAKE_ID2('M', 'E')
+#define ID_CU		MAKE_ID2('C', 'U')
+#define ID_MB		MAKE_ID2('M', 'B')
+#define ID_MA		MAKE_ID2('M', 'A')
+#define ID_TE		MAKE_ID2('T', 'E')
+#define ID_IM		MAKE_ID2('I', 'M')
+#define ID_IK		MAKE_ID2('I', 'K')
+#define ID_WV		MAKE_ID2('W', 'V')
+#define ID_LT		MAKE_ID2('L', 'T')
+#define ID_SE		MAKE_ID2('S', 'E')
+#define ID_LF		MAKE_ID2('L', 'F')
+#define ID_LA		MAKE_ID2('L', 'A')
+#define ID_CA		MAKE_ID2('C', 'A')
+#define ID_IP		MAKE_ID2('I', 'P')
+#define ID_KE		MAKE_ID2('K', 'E')
+#define ID_WO		MAKE_ID2('W', 'O')
+#define ID_SCR		MAKE_ID2('S', 'R')
+#define ID_VF		MAKE_ID2('V', 'F')
+#define ID_TXT		MAKE_ID2('T', 'X')
+#define ID_SO		MAKE_ID2('S', 'O')
+#define ID_SAMPLE	MAKE_ID2('S', 'A')
+#define ID_GR		MAKE_ID2('G', 'R')
+#define ID_ID		MAKE_ID2('I', 'D')
+#define ID_AR		MAKE_ID2('A', 'R')
+#define ID_AC		MAKE_ID2('A', 'C')
+#define ID_SCRIPT	MAKE_ID2('P', 'Y')
+#define ID_FLUIDSIM	MAKE_ID2('F', 'S')
+#define ID_NT		MAKE_ID2('N', 'T')
+#define ID_BR		MAKE_ID2('B', 'R')
+
+
+#define ID_SEQ		MAKE_ID2('S', 'Q')
+#define ID_CO		MAKE_ID2('C', 'O')
+#define ID_PO		MAKE_ID2('A', 'C')
+#define ID_NLA		MAKE_ID2('N', 'L')
+
+#define ID_VS		MAKE_ID2('V', 'S')
+#define ID_VN		MAKE_ID2('V', 'N')
+
+
+// ------------------------------------------------------------
+#define FORM MAKE_ID('F','O','R','M')
+#define DDG1 MAKE_ID('3','D','G','1')
+#define DDG2 MAKE_ID('3','D','G','2')
+#define DDG3 MAKE_ID('3','D','G','3')
+#define DDG4 MAKE_ID('3','D','G','4')
+#define GOUR MAKE_ID('G','O','U','R')
+#define BLEN MAKE_ID('B','L','E','N')
+#define DER_ MAKE_ID('D','E','R','_')
+#define V100 MAKE_ID('V','1','0','0')
+#define DATA MAKE_ID('D','A','T','A')
+#define GLOB MAKE_ID('G','L','O','B')
+#define IMAG MAKE_ID('I','M','A','G')
+#define TEST MAKE_ID('T','E','S','T')
+#define USER MAKE_ID('U','S','E','R')
+
+
+// ------------------------------------------------------------
+#define DNA1 MAKE_ID('D','N','A','1')
+#define REND MAKE_ID('R','E','N','D')
+#define ENDB MAKE_ID('E','N','D','B')
+#define NAME MAKE_ID('N','A','M','E')
+#define SDNA MAKE_ID('S','D','N','A')
+#define TYPE MAKE_ID('T','Y','P','E')
+#define TLEN MAKE_ID('T','L','E','N')
+#define STRC MAKE_ID('S','T','R','C')
+
+
+// ------------------------------------------------------------
+#define SWITCH_INT(a) { \
+    char s_i, *p_i; \
+    p_i= (char *)&(a); \
+    s_i=p_i[0]; p_i[0]=p_i[3]; p_i[3]=s_i; \
+    s_i=p_i[1]; p_i[1]=p_i[2]; p_i[2]=s_i; }
+
+// ------------------------------------------------------------
+#define SWITCH_SHORT(a)	{ \
+    char s_i, *p_i; \
+	p_i= (char *)&(a); \
+	s_i=p_i[0]; p_i[0]=p_i[1]; p_i[1]=s_i; }
+
+// ------------------------------------------------------------
+#define SWITCH_LONGINT(a) { \
+    char s_i, *p_i; \
+    p_i= (char *)&(a);  \
+    s_i=p_i[0]; p_i[0]=p_i[7]; p_i[7]=s_i; \
+    s_i=p_i[1]; p_i[1]=p_i[6]; p_i[6]=s_i; \
+    s_i=p_i[2]; p_i[2]=p_i[5]; p_i[5]=s_i; \
+    s_i=p_i[3]; p_i[3]=p_i[4]; p_i[4]=s_i; }
+
+#endif//__B_DEFINES_H__

Extras/Serialize/BulletFileLoader/bFile.h

@@ -0,0 +1,146 @@
+/*
+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.
+*/
+
+#ifndef __BFILE_H__
+#define __BFILE_H__
+
+#include "bCommon.h"
+#include "bChunk.h"
+#include <stdio.h>
+
+namespace bParse {
+
+	// ----------------------------------------------------- //
+	enum bFileFlags
+	{
+		FD_INVALID   =0,
+		FD_OK        =1,
+		FD_VOID_IS_8 =2,
+		FD_ENDIAN_SWAP      =4,
+		FD_FILE_64   =8,
+		FD_BITS_VARIES    =16,
+		FD_VERSION_VARIES = 32
+	};
+
+
+	// ----------------------------------------------------- //
+	class bFile
+	{
+	protected:
+		
+		char				m_headerString[7];
+
+		bool				mOwnsBuffer;
+		char*				mFileBuffer;
+		int					mFileLen;
+		int					mVersion;
+
+
+		bPtrMap				mLibPointers;
+
+		int					mDataStart;
+		bDNA*				mFileDNA;
+		bDNA*				mMemoryDNA;
+
+		btAlignedObjectArray<char*>	m_pointerFixupArray;
+		btAlignedObjectArray<char*>	m_pointerPtrFixupArray;
+		
+		btAlignedObjectArray<bChunkInd>	m_chunks;
+
+		// 
+	
+		bPtrMap				mDataPointers;
+
+
+		
+		int					mFlags;
+
+		virtual	void parseHeader();
+		
+		virtual	void parseData() = 0;
+
+		void resolvePointersMismatch();
+		void resolvePointersChunk(const bChunkInd& dataChunk, bool verboseDumpAllBlocks);
+
+		void resolvePointersStructRecursive(char *strcPtr, int old_dna, bool verboseDumpAllBlocks, int recursion);
+		void swapPtr(char *dst, char *src);
+
+		void parseStruct(char *strcPtr, char *dtPtr, int old_dna, int new_dna, bool fixupPointers);
+		void getMatchingFileDNA(short* old, const char* lookupName, const char* lookupType, char *strcData, char *data, bool fixupPointers);
+		char* getFileElement(short *firstStruct, char *lookupName, char *lookupType, char *data, short **foundPos);
+
+
+		void swap(char *head, class bChunkInd& ch);
+
+		void swapData(char *data, short type, int arraySize);
+		void swapStruct(int dna_nr, char *data);
+
+
+
+
+		char* readStruct(char *head, class bChunkInd& chunk);
+		char *getAsString(int code);
+
+		void	parseInternal(bool verboseDumpAllTypes, char* memDna,int memDnaLength);
+
+	public:
+		bFile(const char *filename, const char headerString[7]);
+		
+		//todo: make memoryBuffer const char
+		//bFile( const char *memoryBuffer, int len);
+		bFile( char *memoryBuffer, int len, const char headerString[7]);
+		~bFile();
+
+		bDNA*				getFileDNA()
+		{
+			return mFileDNA;
+		}
+
+		virtual	void	addDataBlock(char* dataBlock) = 0;
+
+		int	getFlags() const
+		{
+			return mFlags;
+		}
+
+		bPtrMap&		getLibPointers()
+		{
+			return mLibPointers;
+		}
+		
+		void* findLibPointer(void *ptr);
+
+		bool ok();
+
+		virtual	void parse(bool verboseDumpAllTypes) = 0;
+
+		virtual	int	write(const char* fileName, bool fixupPointers=false) = 0;
+
+		virtual	void	writeChunks(FILE* fp, bool fixupPointers );
+
+		virtual	void	writeDNA(FILE* fp) = 0;
+
+		void	updateOldPointers();
+		void	resolvePointers(bool verboseDumpAllBlocks);
+
+		void	dumpChunks(bDNA* dna);
+		
+
+		
+	};
+}
+
+
+#endif//__BFILE_H__

Extras/Serialize/BulletFileLoader/btBulletFile.cpp

@@ -0,0 +1,252 @@
+/*
+bParse
+Copyright (c) 2006-2010 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 "btBulletFile.h"
+#include "bDefines.h"
+#include "bDNA.h"
+#include <string.h>
+
+
+// 32 && 64 bit versions
+extern unsigned char sBulletDNAstr[];
+extern int sBulletDNAlen;
+
+//not yetto. extern unsigned char DNAstr64[];
+//not yetto. extern int DNAlen64;
+
+
+using namespace bParse;
+
+btBulletFile::btBulletFile()
+:bFile("", "BULLET ")
+{
+	mMemoryDNA = new bDNA();
+	mMemoryDNA->init((char*)sBulletDNAstr,sBulletDNAlen);
+}
+
+
+btBulletFile::btBulletFile(const char* fileName)
+:bFile(fileName, "BULLET ")
+{
+}
+
+
+
+btBulletFile::btBulletFile(char *memoryBuffer, int len)
+:bFile(memoryBuffer,len, "BULLET ")
+{
+
+}
+
+
+btBulletFile::~btBulletFile()
+{
+
+}
+
+
+
+// ----------------------------------------------------- //
+void btBulletFile::parseData()
+{
+	printf ("Building datablocks");
+	printf ("Chunk size = %d",CHUNK_HEADER_LEN);
+	printf ("File chunk size = %d",ChunkUtils::getOffset(mFlags));
+
+	const bool swap = (mFlags&FD_ENDIAN_SWAP)!=0;
+	
+
+	mDataStart = 12;
+
+	char *dataPtr = mFileBuffer+mDataStart;
+
+	bChunkInd dataChunk;
+	dataChunk.code = 0;
+
+
+	//dataPtr += ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
+	int seek = ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
+	//dataPtr += ChunkUtils::getOffset(mFlags);
+	char *dataPtrHead = 0;
+
+	while (dataChunk.code != DNA1)
+	{
+		
+
+
+
+		// one behind
+		if (dataChunk.code == SDNA) break;
+		//if (dataChunk.code == DNA1) break;
+
+		// same as (BHEAD+DATA dependancy)
+		dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
+		char *id = readStruct(dataPtrHead, dataChunk);
+
+		// lookup maps
+		if (id)
+		{
+			mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)id);
+
+			m_chunks.push_back(dataChunk);
+			// block it
+			//bListBasePtr *listID = mMain->getListBasePtr(dataChunk.code);
+			//if (listID)
+			//	listID->push_back((bStructHandle*)id);
+		}
+
+		if (dataChunk.code == BT_RIGIDBODY_CODE)
+		{
+			m_rigidBodies.push_back((bStructHandle*) id);
+		}
+		
+		if (dataChunk.code == BT_COLLISIONOBJECT_CODE)
+		{
+			m_collisionObjects.push_back((bStructHandle*) id);
+		}
+
+		if (dataChunk.code == BT_SHAPE_CODE)
+		{
+			m_collisionShapes.push_back((bStructHandle*) id);
+		}
+
+//		if (dataChunk.code == GLOB)
+//		{
+//			m_glob = (bStructHandle*) id;
+//		}
+
+		// next please!
+		dataPtr += seek;
+
+		seek =  ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
+		if (seek < 0)
+			break;
+	}
+
+}
+
+void	btBulletFile::addDataBlock(char* dataBlock)
+{
+	//mMain->addDatablock(dataBlock);
+}
+
+
+
+
+void	btBulletFile::writeDNA(FILE* fp)
+{
+
+	bChunkInd dataChunk;
+	dataChunk.code = DNA1;
+	dataChunk.dna_nr = 0;
+	dataChunk.nr = 1;
+	
+	if (VOID_IS_8)
+	{
+		//dataChunk.len = DNAlen64;
+		//dataChunk.oldPtr = DNAstr64;
+		//fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		//fwrite(DNAstr64, DNAlen64,1,fp);
+	}
+	else
+	{
+		dataChunk.len = sBulletDNAlen;
+		dataChunk.oldPtr = sBulletDNAstr;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
+	}
+}
+
+
+void	btBulletFile::parse(bool verboseDumpAllTypes)
+{
+	if (VOID_IS_8)
+	{
+		exit(0);
+		//parseInternal(verboseDumpAllTypes,(char*)DNAstr64,DNAlen64);
+	}
+	else
+	{
+		parseInternal(verboseDumpAllTypes,(char*)sBulletDNAstr,sBulletDNAlen);
+	}
+}
+
+// experimental
+int		btBulletFile::write(const char* fileName, bool fixupPointers)
+{
+	FILE *fp = fopen(fileName, "wb");
+	if (fp)
+	{
+		char header[SIZEOFBLENDERHEADER] ;
+		memcpy(header, m_headerString, 7);
+		int endian= 1;
+		endian= ((char*)&endian)[0];
+
+		if (endian)
+		{
+			header[7] = '_';
+		} else
+		{
+			header[7] = '-';
+		}
+		if (VOID_IS_8)
+		{
+			header[8]='V';
+		} else
+		{
+			header[8]='v';
+		}
+
+		header[9] = '2';
+		header[10] = '7';
+		header[11] = '5';
+		
+		fwrite(header,SIZEOFBLENDERHEADER,1,fp);
+
+		writeChunks(fp, fixupPointers);
+
+		writeDNA(fp);
+
+		fclose(fp);
+		
+	} else
+	{
+		printf("Error: cannot open file %s for writing\n",fileName);
+		return 0;
+	}
+	return 1;
+}
+
+
+
+void	btBulletFile::addStruct(const	char* structType,void* data, int len, void* oldPtr, int code)
+{
+	
+	bParse::bChunkInd dataChunk;
+	dataChunk.code = code;
+	dataChunk.nr = 1;
+	dataChunk.len = len;
+	dataChunk.dna_nr = mMemoryDNA->getReverseType(structType);
+	dataChunk.oldPtr = oldPtr;
+
+	///Perform structure size validation
+	short* structInfo= mMemoryDNA->getStruct(dataChunk.dna_nr);
+	int elemBytes = mMemoryDNA->getLength(structInfo[0]);
+//	int elemBytes = mMemoryDNA->getElementSize(structInfo[0],structInfo[1]);
+	assert(len==elemBytes);
+
+	mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)data);
+	m_chunks.push_back(dataChunk);
+}

Extras/Serialize/BulletFileLoader/btBulletFile.h

@@ -0,0 +1,72 @@
+/*
+bParse
+Copyright (c) 2006-2010 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.
+*/
+
+#ifndef BT_BULLET_FILE_H
+#define BT_BULLET_FILE_H
+
+
+#include "bFile.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "bDefines.h"
+
+#define BT_COLLISIONOBJECT_CODE MAKE_ID('C','O','B','J')
+#define BT_RIGIDBODY_CODE		MAKE_ID('R','B','D','Y')
+#define BT_BOXSHAPE_CODE		MAKE_ID('B','O','X','S')
+#define BT_SHAPE_CODE			MAKE_ID('S','H','A','P')
+
+
+namespace bParse {
+
+	// ----------------------------------------------------- //
+	class btBulletFile : public bFile
+	{
+
+	protected:
+	
+				
+	public:
+
+		btAlignedObjectArray<bStructHandle*>	m_rigidBodies;
+
+		btAlignedObjectArray<bStructHandle*>	m_collisionObjects;
+
+		btAlignedObjectArray<bStructHandle*>	m_collisionShapes;
+
+		btBulletFile();
+
+		btBulletFile(const char* fileName);
+
+		btBulletFile(char *memoryBuffer, int len);
+
+		virtual ~btBulletFile();
+
+		virtual	void	addDataBlock(char* dataBlock);
+	
+
+		// experimental
+		virtual int		write(const char* fileName, bool fixupPointers=false);
+
+		virtual	void	parse(bool verboseDumpAllTypes);
+
+		virtual	void parseData();
+
+		virtual	void	writeDNA(FILE* fp);
+
+		void	addStruct(const char* structType,void* data, int len, void* oldPtr, int code);
+
+	};
+};
+
+#endif //BT_BULLET_FILE_H

Extras/Serialize/CMakeLists.txt

@@ -0,0 +1,9 @@
+
+SUBDIRS ( BulletSerialize )
+
+
+
+# makesdna and HeaderGenerator are for advanced use only
+# makesdna can re-generate the binary DNA representing the Bullet serialization structures
+# Be very careful modifying any of this, otherwise the .bullet format becomes incompatible
+#SUBDIRS ( BulletFileLoader BlenderSerialize HeaderGenerator makesdna)

Extras/Serialize/HeaderGenerator/CMakeLists.txt

@@ -0,0 +1,23 @@
+###############################################################################
+PROJECT(GEN)
+FILE(GLOB cpp_SRC "*.cpp")
+FILE(GLOB h_SRC "*.h")
+
+
+SET(includes 
+  .
+	${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BulletFileLoader
+	${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BlenderSerialize
+	${BULLET_PHYSICS_SOURCE_DIR}/src
+)
+
+
+LINK_LIBRARIES(
+	 BulletFileLoader BlenderSerialize LinearMath
+)
+
+INCLUDE_DIRECTORIES(${includes})
+
+SET(Main_LIBS  LinearMath)
+
+ADD_EXECUTABLE(HeaderGenerator ${cpp_SRC} ${h_SRC})

Extras/Serialize/HeaderGenerator/apiGen.cpp

@@ -0,0 +1,463 @@
+/* Copyright (C) 2006 Charlie C
+*
+* 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 <sstream>
+#include "bDNA.h"
+#include "bBlenderFile.h"
+#include "btBulletFile.h"
+#include "bCommon.h"
+#include <map>
+#include <vector>
+
+bool isBulletFile = false;
+
+using namespace bParse;
+typedef std::string bString;
+
+///////////////////////////////////////////////////////////////////////////////
+typedef std::map<bString, bString> bStringMap;
+typedef std::vector<class bVariable> bVariableList;
+typedef std::vector<bString> bStringList;
+
+
+///////////////////////////////////////////////////////////////////////////////
+static FILE *dump = 0;
+static bDNA *mDNA =0;
+static bStringMap mStructs;
+
+
+///////////////////////////////////////////////////////////////////////////////
+class bVariable
+{
+public:
+	bVariable();
+	~bVariable();
+
+
+	bString dataType;
+	bString variableName;
+
+
+	bString functionName;
+	bString classCtor;
+
+	bString memberVariable;
+	bString memberDataType;
+	bString functionArgs;
+
+
+	void initialize(bString dataType, bString variable, bStringMap refDataTable);
+
+	bool isPtr;
+	bool isFunctionPtr;
+	bool isPtrToPtr;
+	bool isArray;
+	bool isCharArray;
+	bool isListBase;
+	bool isPadding;
+	bool isCommentedOut;
+	bool isGeneratedType;
+	bool isbString;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+bool dataTypeStandard(bString dataType)
+{
+	if (dataType == "char")
+		return true;
+	if (dataType == "short")
+		return true;
+	if (dataType == "int")
+		return true;
+	if (dataType == "long")
+		return true;
+	if (dataType == "float")
+		return true;
+	if (dataType == "double")
+		return true;
+	if (dataType == "void")
+		return true;
+	if (dataType == "btScalar")
+		return true;
+	return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void writeTemplate(short *structData)
+{
+	bString type = mDNA->getType(structData[0]);
+	bString className=type;
+	bString prefix = isBulletFile? "bullet_" : "blender_";
+	
+	int thisLen = structData[1];
+	structData+=2;
+
+	bString fileName = prefix+type;
+
+	bVariableList dataTypes;
+	bStringMap includeFiles;
+
+
+	for (int dataVal =0; dataVal<thisLen; dataVal++, structData+=2)
+	{
+		bString dataType = mDNA->getType(structData[0]);
+		bString dataName = mDNA->getName(structData[1]);
+		{
+			bString newDataType = "";
+			bString newDataName = "";
+			
+			bStringMap::iterator addB = mStructs.find(dataType);
+			if (addB != mStructs.end())
+			{
+				newDataType = addB->second;
+				newDataName = dataName;
+			}
+
+			else 
+			{
+				if (dataTypeStandard(dataType))
+				{
+					newDataType = dataType;
+					newDataName = dataName;
+				}
+				else
+				{
+					// Unresolved
+					// set it to an empty struct
+					// if it's not a ptr generate an error
+					newDataType = "bInvalidHandle";
+					newDataName = dataName;
+
+					if (dataName[0] != '*')
+					{
+					}
+
+				} 
+			}
+
+			if (!newDataType.empty() && !newDataName.empty())
+			{
+				bVariable var = bVariable();
+				var.initialize(newDataType, newDataName, mStructs);
+				dataTypes.push_back(var);
+			}
+		}
+
+
+		bStringMap::iterator include = mStructs.find(dataType);
+		if (include != mStructs.end())
+		{
+			if (dataName[0] != '*') 
+			{
+				if (includeFiles.find(dataType)== includeFiles.end())
+				{
+					includeFiles[dataType]=prefix+dataType;
+				}
+			}
+		}
+	}
+
+
+	fprintf(dump, "###############################################################\n");
+	fprintf(dump, "%s = bStructClass()\n", fileName.c_str());
+	fprintf(dump, "%s.name = '%s'\n", fileName.c_str(), className.c_str());
+	fprintf(dump, "%s.filename = '%s'\n", fileName.c_str(), fileName.c_str());
+
+	bVariableList::iterator vars = dataTypes.begin();
+	while (vars!= dataTypes.end())
+	{
+		fprintf(dump, "%s.dataTypes.append('%s %s')\n", fileName.c_str(), vars->dataType.c_str(), vars->variableName.c_str());
+		vars++;
+	}
+
+	bStringMap::iterator inc = includeFiles.begin();
+	while (inc != includeFiles.end())
+	{
+		fprintf(dump, "%s.includes.append('%s.h')\n", fileName.c_str(), inc->second.c_str());
+		inc++;
+	}
+	fprintf(dump, "DataTypeList.append(%s)\n", fileName.c_str());
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+char data[]={
+"\n"
+"class bStructClass:\n"
+"    def __init__(self):\n"
+"       self.name = \"\";\n"
+"       self.filename = \"\";\n"
+"       self.includes = []\n"
+"       self.dataTypes = []\n"
+"\n\n"
+"DataTypeList = []\n"
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc,char** argv)
+{
+	using namespace bParse;
+	dump = fopen("dump.py", "w");
+
+	if (!dump) return 0;
+	fprintf(dump, "%s\n", data);
+
+	
+	char* filename = "../../../Demos/SerializeDemo/testFile.bullet";
+	
+	if (argc==2)
+		filename = argv[1];
+
+	bString fileStr(filename);
+	bString extension(".bullet");
+
+	int index2 = fileStr.find(extension);
+	if (index2>=0)
+		isBulletFile=true;
+
+	
+	FILE* fp = fopen (filename,"rb");
+
+	if (!fp)
+	{
+		printf("error: file not found %s\n",filename);
+		exit(0);
+	}
+
+	char* memBuf = 0;
+	int len = 0;
+
+	long currentpos = ftell(fp); /* save current cursor position */
+	long newpos;
+	int bytesRead;
+
+	fseek(fp, 0, SEEK_END); /* seek to end */
+	newpos = ftell(fp); /* find position of end -- this is the length */
+	fseek(fp, currentpos, SEEK_SET); /* restore previous cursor position */
+	
+	len = newpos;
+	
+	memBuf = (char*)malloc(len);
+	bytesRead = fread(memBuf,len,1,fp);
+
+	bool swap = false;
+
+	
+	if (isBulletFile)
+	{
+		btBulletFile f(memBuf,len);
+		swap = f.getFlags() & FD_ENDIAN_SWAP;
+	} else
+	{
+		bBlenderFile	f(memBuf,len);
+		swap = f.getFlags() & FD_ENDIAN_SWAP;
+	}
+
+	
+	
+
+
+	char *blenderData = memBuf;
+	int sdnaPos=0;
+	int mDataStart = 12;
+
+	char *tempBuffer = blenderData;
+	for (int i=0; i<len; i++)
+	{
+		// looking for the data's starting position
+		// and the start of SDNA decls
+
+		if (!mDataStart && strncmp(tempBuffer, "REND", 4)==0)
+			mDataStart = i;
+		if (!sdnaPos && strncmp(tempBuffer, "SDNA", 4)==0)
+			sdnaPos = i;
+
+		if (mDataStart && sdnaPos) break;
+		tempBuffer++;
+	}
+
+	
+
+	FILE* fpdna = fopen("dnaString.txt","w");
+	char buf[1024];
+
+	for (int i=0;i<len-sdnaPos;i++)
+	{
+		int dnaval = (memBuf+sdnaPos)[i];
+
+		if ((i%32)==0)
+		{
+			sprintf(buf,"%d,\n",dnaval);
+			
+		} else
+		{
+			sprintf(buf,"%d,",dnaval);
+		}
+		
+		
+		fwrite(buf,strlen(buf),1,fpdna);
+	}
+
+	fclose(fpdna);
+
+
+
+	mDNA = new bDNA();
+	//mDNA->initMemory();
+	
+	mDNA->init(memBuf+sdnaPos, len-sdnaPos, swap);
+	
+
+	for (int i=0; i<mDNA->getNumStructs(); i++)
+	{
+		short *structData = mDNA->getStruct(i);
+		bString type = mDNA->getType(structData[0]);
+
+		bString className = type;
+		mStructs[type]=className;
+	}
+
+
+	for (int i=0; i<mDNA->getNumStructs(); i++)
+	{
+		short *structData = mDNA->getStruct(i);
+		writeTemplate(structData);
+	}
+
+	delete mDNA;
+	fclose(dump);
+	return 0;
+}
+///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+int _getArraySize(char* str)
+{
+	int a, mul=1;
+	char stri[100], *cp=0;
+	int len = (int)strlen(str);
+
+	memcpy(stri, str, len+1);
+	for (a=0; a<len; a++)
+	{
+		if (str[a]== '[')
+			cp= &(stri[a+1]);
+		else if ( str[a]==']' && cp)
+		{
+			stri[a]= 0;
+			mul*= atoi(cp);
+		}
+	}
+	return mul;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+bVariable::bVariable()
+	:	dataType("invalid"),
+		variableName("invalid"),
+		functionName(""),
+		classCtor(""),
+		memberVariable(""),
+		memberDataType(""),
+		functionArgs(""),
+		isPtr(false),
+		isFunctionPtr(false),
+		isPtrToPtr(false),
+		isArray(false),
+		isCharArray(false),
+		isListBase(false),
+		isPadding(false),
+		isCommentedOut(false),
+		isGeneratedType(false),
+		isbString(false)
+{
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+bVariable::~bVariable()
+{
+	dataType.clear();
+	variableName.clear();
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+void bVariable::initialize(bString type, bString variable, bStringMap refDataTable)
+{
+	dataType = type;
+	variableName = variable;
+
+	if (variableName[0] == '*')
+	{
+		isPtr = true;
+		if (variableName[1] == '*')
+			isPtrToPtr = true;
+	}
+	if (variableName[0] == '(')
+		if (variableName[1] == '*')
+			isFunctionPtr = true;
+
+	if (variableName[variableName.size()-1] == ']')
+	{
+		isArray = true;
+		if (type == "char")
+			isCharArray = true;
+	}
+
+	if (type == "ListBase")
+		isListBase = true;
+
+	if (variableName[0] == 'p')
+	{
+		bString sub = variableName.substr(0,3);
+		if (sub == "pad")
+			isPadding = true;
+	}
+	if (dataType[0] == '/' && dataType[1] == '/')
+		isCommentedOut = true;
+
+
+	if (refDataTable.find(dataType) != refDataTable.end())
+		isGeneratedType = true;
+
+	if (!isBulletFile)
+	{
+		// replace valid float arrays
+		if (dataType == "float" && isArray)
+		{
+			int size = _getArraySize((char*)variableName.c_str());
+			if (size==3)
+			{
+				dataType = "vec3f";
+				variableName = variableName.substr(0, variableName.find_first_of("["));
+			}
+			if (size==4)
+			{
+				dataType = "vec4f";
+				variableName = variableName.substr(0, variableName.find_first_of("["));
+			}
+		}
+	}
+	memberDataType = dataType;
+	functionArgs = variableName;
+}
+
+// eof

Extras/Serialize/HeaderGenerator/blenderGenerate.py

@@ -0,0 +1,111 @@
+import dump
+
+
+header = """/* Copyright (C) 2006 Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+"""
+
+dtList = dump.DataTypeList
+
+out = "../BlenderSerialize/autogenerated/"
+spaces = 4
+
+def addSpaces(file, space):
+	for i in range(0, space):
+		file.write(" ")
+
+def write(file, spaces, string):
+	addSpaces(file, spaces)
+	file.write(string)
+
+###################################################################################
+blender = open(out+"blender.h", 'w')
+blender.write(header)
+blender.write("#ifndef __BLENDER_H__\n")
+blender.write("#define __BLENDER_H__\n")
+for dt in dtList:
+	blender.write("#include \"%s.h\"\n"%dt.filename)
+
+blender.write("#endif//__BLENDER_H__")
+blender.close()
+
+###################################################################################
+blenderC = open(out+"blender_Common.h", 'w')
+blenderC.write(header)
+blenderC.write("#ifndef __BLENDERCOMMON_H__\n")
+blenderC.write("#define __BLENDERCOMMON_H__\n")
+
+strUnRes = """
+// put an empty struct in the case
+typedef struct bInvalidHandle {
+	int unused;
+}bInvalidHandle;
+
+"""
+blenderC.write(strUnRes)
+
+blenderC.write("namespace Blender {\n")
+for dt in dtList:
+	write(blenderC, 4, "class %s;\n"%dt.name)
+
+blenderC.write("}\n")
+blenderC.write("#endif//__BLENDERCOMMON_H__")
+blenderC.close()
+
+
+for dt in dtList:
+	fp = open(out+dt.filename+".h", 'w')
+	
+	fp.write(header)
+	strUpper = dt.filename.upper()
+	
+	fp.write("#ifndef __%s__H__\n"%strUpper)
+	fp.write("#define __%s__H__\n"%strUpper)
+	fp.write("\n\n")
+	
+	
+	fp.write("// -------------------------------------------------- //\n")
+	fp.write("#include \"blender_Common.h\"\n")
+
+	for i in dt.includes:
+		fp.write("#include \"%s\"\n"%i)
+
+	fp.write("\nnamespace Blender {\n")
+	fp.write("\n\n")
+
+	addSpaces(fp,4)
+	fp.write("// ---------------------------------------------- //\n")
+
+
+	write(fp, 4, "class %s\n"%dt.name)
+
+	write(fp, 4, "{\n")
+	write(fp, 4, "public:\n")
+	for i in dt.dataTypes:
+		write(fp, 8, i+";\n")
+
+
+	write(fp, 4, "};\n")
+	fp.write("}\n")
+	fp.write("\n\n")
+	fp.write("#endif//__%s__H__\n"%strUpper)
+	fp.close()
+
+	

Extras/Serialize/HeaderGenerator/bulletGenerate.py

@@ -0,0 +1,111 @@
+import dump
+
+
+header = """/* Copyright (C) 2006-2009 Erwin Coumans & Charlie C
+*
+* 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.
+*/
+// Auto generated from makesdna dna.c
+"""
+
+dtList = dump.DataTypeList
+
+out = "../BulletFileLoader/autogenerated/"
+spaces = 4
+
+def addSpaces(file, space):
+	for i in range(0, space):
+		file.write(" ")
+
+def write(file, spaces, string):
+	addSpaces(file, spaces)
+	file.write(string)
+
+###################################################################################
+blender = open(out+"bullet.h", 'w')
+blender.write(header)
+blender.write("#ifndef __BULLET_H__\n")
+blender.write("#define __BULLET_H__\n")
+for dt in dtList:
+	blender.write("#include \"%s.h\"\n"%dt.filename)
+
+blender.write("#endif//__BULLET_H__")
+blender.close()
+
+###################################################################################
+blenderC = open(out+"bullet_Common.h", 'w')
+blenderC.write(header)
+blenderC.write("#ifndef __BULLETCOMMON_H__\n")
+blenderC.write("#define __BULLETCOMMON_H__\n")
+
+strUnRes = """
+// put an empty struct in the case
+typedef struct bInvalidHandle {
+	int unused;
+}bInvalidHandle;
+
+"""
+blenderC.write(strUnRes)
+
+blenderC.write("namespace Bullet {\n")
+for dt in dtList:
+	write(blenderC, 4, "class %s;\n"%dt.name)
+
+blenderC.write("}\n")
+blenderC.write("#endif//__BULLETCOMMON_H__")
+blenderC.close()
+
+
+for dt in dtList:
+	fp = open(out+dt.filename+".h", 'w')
+	
+	fp.write(header)
+	strUpper = dt.filename.upper()
+	
+	fp.write("#ifndef __%s__H__\n"%strUpper)
+	fp.write("#define __%s__H__\n"%strUpper)
+	fp.write("\n\n")
+	
+	
+	fp.write("// -------------------------------------------------- //\n")
+	fp.write("#include \"bullet_Common.h\"\n")
+
+	for i in dt.includes:
+		fp.write("#include \"%s\"\n"%i)
+
+	fp.write("\nnamespace Bullet {\n")
+	fp.write("\n\n")
+
+	addSpaces(fp,4)
+	fp.write("// ---------------------------------------------- //\n")
+
+
+	write(fp, 4, "class %s\n"%dt.name)
+
+	write(fp, 4, "{\n")
+	write(fp, 4, "public:\n")
+	for i in dt.dataTypes:
+		write(fp, 8, i+";\n")
+
+
+	write(fp, 4, "};\n")
+	fp.write("}\n")
+	fp.write("\n\n")
+	fp.write("#endif//__%s__H__\n"%strUpper)
+	fp.close()
+
+	

Extras/Serialize/HeaderGenerator/createDnaString.bat

@@ -0,0 +1,3 @@
+Debug\HeaderGenerator.exe
+
+python bulletGenerate.py

Extras/Serialize/makesdna/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 2.4)
+   
+IF(COMMAND cmake_policy)
+   cmake_policy(SET CMP0003 NEW)
+ENDIF(COMMAND cmake_policy)
+
+INCLUDE_DIRECTORIES(${BULLET_PHYSICS_SOURCE_DIR}/src )
+
+#FILE(GLOB INC_FILES ../*.h)
+
+SET (INC_FILES
+	DNA_rigidbody.h
+	
+	${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btVector3.h
+	${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btMatrix3x3.h
+	${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btTransform.h
+	${BULLET_PHYSICS_SOURCE_DIR}/src/BulletCollision/CollisionShapes/btCollisionShape.h
+	${BULLET_PHYSICS_SOURCE_DIR}/src/BulletCollision/CollisionShapes/btConvexInternalShape.h
+	${BULLET_PHYSICS_SOURCE_DIR}/src/BulletCollision/CollisionDispatch/btCollisionObject.h
+)
+
+# Build makesdna executable
+SET(SRC makesdna.cpp)
+ADD_EXECUTABLE(makesdna ${SRC} ${INC_FILES})
+
+# Output BulletDNA.c
+ADD_CUSTOM_COMMAND(
+	OUTPUT ${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btSerializer.cpp
+	COMMAND ${CMAKE_CFG_INTDIR}/makesdna ${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btSerializer.cpp ${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/CommonSerialize/
+	DEPENDS makesdna
+)
+
+# Build bf_dna library
+SET(SRC  ${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btSerializer.cpp)
+ADD_LIBRARY(BulletDNA ${SRC} ${INC_FILES})
+
+MESSAGE(STATUS "Configuring makesdna")

Extras/Serialize/makesdna/DNA_rigidbody.h

@@ -0,0 +1,29 @@
+
+#ifndef DNA_RIGIDBODY_H
+#define DNA_RIGIDBODY_H
+
+
+struct	PointerArray
+{
+	int		m_size;
+	int		m_capacity;
+	void	*m_data;
+};
+
+
+struct btPhysicsSystem
+{
+	PointerArray	m_collisionShapes;
+	PointerArray	m_collisionObjects;
+	PointerArray	m_constraints;
+};
+
+///we need this to compute the pointer sizes
+struct ListBase
+{
+	void *first;
+	void *last;
+};
+
+
+#endif