add the 'extras' and Bullet 2 tests, to make it easier to create a new intermediate release

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,225 @@
+/*
+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 = 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 dependency)
+		dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
+		char *id = readStruct(dataPtrHead, dataChunk);
+
+		// lookup maps
+		if (id)
+		{
+            m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
+			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 =  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(int verboseMode)
+{
+	if (VOID_IS_8)
+	{
+		parseInternal(verboseMode,(char*)DNAstr64,DNAlen64);
+	}
+	else
+	{
+		parseInternal(verboseMode,(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(int verboseMode);
+
+		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,49 @@
+INCLUDE_DIRECTORIES( 
+	${BULLET_PHYSICS_SOURCE_DIR}/src  
+)
+
+SET(BulletFileLoader_SRCS
+bChunk.cpp
+bDNA.cpp
+bFile.cpp
+btBulletFile.cpp
+)
+
+SET(BulletFileLoader_HDRS
+bChunk.h
+bCommon.h
+bDefines.h
+bDNA.h
+bFile.h
+btBulletFile.h
+)
+
+ADD_LIBRARY(BulletFileLoader ${BulletFileLoader_SRCS} ${BulletFileLoader_HDRS})
+
+IF (BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(BulletFileLoader LinearMath)
+ENDIF (BUILD_SHARED_LIBS)
+
+SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES VERSION ${BULLET_VERSION}) 
+SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES SOVERSION ${BULLET_VERSION})
+
+IF (INSTALL_EXTRA_LIBS)
+        IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+                #FILES_MATCHING requires CMake 2.6
+                IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+                        IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                                INSTALL(TARGETS BulletFileLoader DESTINATION .)
+                        ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                                INSTALL(TARGETS BulletFileLoader DESTINATION lib${LIB_SUFFIX})
+                                INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h"  PATTERN
+".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
+                        ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+
+                IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+                        SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES FRAMEWORK true)
+                        SET_TARGET_PROPERTIES(BulletFileLoader PROPERTIES PUBLIC_HEADER "${BulletFileLoader_HDRS}")
+                ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+        ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+ENDIF (INSTALL_EXTRA_LIBS)

Extras/Serialize/BulletFileLoader/bChunk.cpp

@@ -0,0 +1,75 @@
+/*
+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 "bChunk.h"
+#include "bDefines.h"
+#include "bFile.h"
+
+#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.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;
+}
+
+
+
+
+
+//eof

Extras/Serialize/BulletFileLoader/bChunk.h

@@ -0,0 +1,92 @@
+/*
+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__
+
+#if defined (_WIN32) && ! defined (__MINGW32__)
+	#define long64 __int64
+#elif defined (__MINGW32__)	
+	#include <stdint.h>
+	#define long64 int64_t
+#else
+	#define long64 long long
+#endif
+
+
+namespace bParse {
+
+
+	// ----------------------------------------------------- //
+	class bChunkPtr4
+	{
+	public:
+		bChunkPtr4(){}
+		int code;
+		int len;
+		union
+		{
+			int m_uniqueInt;
+		};
+		int dna_nr;
+		int nr;
+	};
+
+	// ----------------------------------------------------- //
+	class bChunkPtr8
+	{
+	public:
+		bChunkPtr8(){}
+		int code,  len;
+		union
+		{
+			long64 oldPrev;
+			int	m_uniqueInts[2];
+		};
+		int dna_nr, nr;
+	};
+
+	// ----------------------------------------------------- //
+	class bChunkInd
+	{
+	public:
+		bChunkInd(){}
+		int code, len;
+		void *oldPtr;
+		int dna_nr, nr;
+	};
+
+
+	// ----------------------------------------------------- //
+	class ChunkUtils
+	{
+	public:
+		
+		// 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,644 @@
+/*
+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>
+
+//this define will force traversal of structures, to check backward (and forward) compatibility
+//#define TEST_BACKWARD_FORWARD_COMPATIBILITY
+
+
+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);
+
+
+
+	int i;
+	for ( i=0; i<(int)mStructs.size(); i++)
+	{
+		short *oldStruct = mStructs[i];
+
+		int oldLookup = getReverseType(oldStruct[0]);
+		if (oldLookup == -1)
+		{
+			mCMPFlags[i] = FDF_NONE;
+			continue;
+		}
+		//char* typeName = mTypes[oldStruct[0]];
+
+//#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;
+
+#ifndef TEST_BACKWARD_FORWARD_COMPATIBILITY
+
+			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
+						//const char* typeFileDNA = mTypes[oldStruct[0]];
+						//const char* typeMemDNA = mTypes[curStruct[0]];
+						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 ( 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) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+	cp = (char*)intPtr;
+	int i;
+	for ( 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) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+	cp = (char*)intPtr;
+	for ( 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 ( 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) 
+	{
+		*intPtr = ChunkUtils::swapInt(*intPtr);
+	}
+	dataLen = *intPtr;
+	intPtr++;
+
+
+	shtPtr = (short*)intPtr;
+	for ( 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 ( 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 ( 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,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 __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,165 @@
+/*
+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,
+		FD_DOUBLE_PRECISION =64,
+		FD_BROKEN_DNA = 128
+	};
+
+	enum bFileVerboseMode
+	{
+		FD_VERBOSE_EXPORT_XML = 1,
+		FD_VERBOSE_DUMP_DNA_TYPE_DEFINITIONS = 2,
+		FD_VERBOSE_DUMP_CHUNKS = 4,
+		FD_VERBOSE_DUMP_FILE_INFO=8,
+	};
+	// ----------------------------------------------------- //
+	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;
+        btHashMap<btHashPtr, bChunkInd> m_chunkPtrPtrMap;
+
+        // 
+	
+		bPtrMap				mDataPointers;
+
+		
+		int					mFlags;
+
+		// ////////////////////////////////////////////////////////////////////////////
+
+			// buffer offset util
+		int getNextBlock(bChunkInd *dataChunk,  const char *dataPtr, const int flags);
+		void safeSwapPtr(char *dst, const char *src);
+
+		virtual	void parseHeader();
+		
+		virtual	void parseData() = 0;
+
+		void resolvePointersMismatch();
+		void resolvePointersChunk(const bChunkInd& dataChunk, int verboseMode);
+
+		int resolvePointersStructRecursive(char *strcPtr, int old_dna, int verboseMode, 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, bool ignoreEndianFlag);
+		void swapData(char *data, short type, int arraySize, bool ignoreEndianFlag);
+		void swapStruct(int dna_nr, char *data, bool ignoreEndianFlag);
+		void swapLen(char *dataPtr);
+		void swapDNA(char* ptr);
+
+
+		char* readStruct(char *head, class bChunkInd& chunk);
+		char *getAsString(int code);
+
+		void	parseInternal(int verboseMode, 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]);
+		virtual ~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(int verboseMode) = 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(int verboseMode);
+
+		void	dumpChunks(bDNA* dna);
+		
+		int		getVersion() const
+		{
+			return mVersion;
+		}
+		//pre-swap the endianness, so that data loaded on a target with different endianness doesn't need to be swapped
+		void preSwap();
+		void writeFile(const char* fileName);
+
+	};
+}
+
+
+#endif//__BFILE_H__

Extras/Serialize/BulletFileLoader/btBulletFile.cpp

@@ -0,0 +1,423 @@
+/*
+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"
+
+#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
+#include <memory.h>
+#endif
+#include <string.h>
+
+
+// 32 && 64 bit versions
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+#ifdef _WIN64
+extern char sBulletDNAstr64[];
+extern int sBulletDNAlen64;
+#else
+extern char sBulletDNAstr[];
+extern int sBulletDNAlen;
+#endif //_WIN64
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+
+extern char sBulletDNAstr64[];
+extern int sBulletDNAlen64;
+extern char sBulletDNAstr[];
+extern int sBulletDNAlen;
+
+#endif //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+
+using namespace bParse;
+
+btBulletFile::btBulletFile()
+:bFile("", "BULLET ")
+{
+	mMemoryDNA = new bDNA(); //this memory gets released in the bFile::~bFile destructor,@todo not consistent with the rule 'who allocates it, has to deallocate it"
+
+	m_DnaCopy = 0;
+
+
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+#ifdef _WIN64
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
+#else//_WIN64
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
+#endif//_WIN64
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		m_DnaCopy = (char*) btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
+	}
+	else
+	{
+		m_DnaCopy =(char*) btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+}
+
+
+
+btBulletFile::btBulletFile(const char* fileName)
+:bFile(fileName, "BULLET ")
+{
+	m_DnaCopy = 0;
+}
+
+
+
+btBulletFile::btBulletFile(char *memoryBuffer, int len)
+:bFile(memoryBuffer,len, "BULLET ")
+{
+	m_DnaCopy = 0;
+}
+
+
+btBulletFile::~btBulletFile()
+{
+	if (m_DnaCopy)
+		btAlignedFree(m_DnaCopy);
+
+	
+	while (m_dataBlocks.size())
+	{
+		char* dataBlock = m_dataBlocks[m_dataBlocks.size()-1];
+		delete[] dataBlock;
+		m_dataBlocks.pop_back();
+	}
+
+}
+
+
+
+// ----------------------------------------------------- //
+void btBulletFile::parseData()
+{
+//	printf ("Building datablocks");
+//	printf ("Chunk size = %d",CHUNK_HEADER_LEN);
+//	printf ("File chunk size = %d",ChunkUtils::getOffset(mFlags));
+
+	const bool brokenDNA = (mFlags&FD_BROKEN_DNA)!=0;
+
+	//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 = getNextBlock(&dataChunk, dataPtr, mFlags);
+	
+	
+	if (mFlags &FD_ENDIAN_SWAP) 
+		swapLen(dataPtr);
+
+	//dataPtr += ChunkUtils::getOffset(mFlags);
+	char *dataPtrHead = 0;
+
+	while (dataChunk.code != DNA1)
+	{
+		if (!brokenDNA || (dataChunk.code != BT_QUANTIZED_BVH_CODE) )
+		{
+
+			// one behind
+			if (dataChunk.code == SDNA) break;
+			//if (dataChunk.code == DNA1) break;
+
+			// same as (BHEAD+DATA dependency)
+			dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
+			if (dataChunk.dna_nr>=0)
+			{
+				char *id = readStruct(dataPtrHead, dataChunk);
+
+				// lookup maps
+				if (id)
+				{
+					m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
+					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_SOFTBODY_CODE)
+				{
+					m_softBodies.push_back((bStructHandle*) id);
+				}
+				
+				if (dataChunk.code == BT_RIGIDBODY_CODE)
+				{
+					m_rigidBodies.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_DYNAMICSWORLD_CODE)
+				{
+					m_dynamicsWorldInfo.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_CONSTRAINT_CODE)
+				{
+					m_constraints.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_QUANTIZED_BVH_CODE)
+				{
+					m_bvhs.push_back((bStructHandle*) id);
+				}
+
+				if (dataChunk.code == BT_TRIANLGE_INFO_MAP)
+				{
+					m_triangleInfoMaps.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;
+		//		}
+			} else
+			{
+				printf("unknown chunk\n");
+
+				mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)dataPtrHead);
+			}
+		} else
+		{
+			printf("skipping BT_QUANTIZED_BVH_CODE due to broken DNA\n");
+		}
+
+		
+		dataPtr += seek;
+
+		seek =  getNextBlock(&dataChunk, dataPtr, mFlags);
+		if (mFlags &FD_ENDIAN_SWAP) 
+			swapLen(dataPtr);
+
+		if (seek < 0)
+			break;
+	}
+
+}
+
+void	btBulletFile::addDataBlock(char* dataBlock)
+{
+	m_dataBlocks.push_back(dataBlock);
+
+}
+
+
+
+
+void	btBulletFile::writeDNA(FILE* fp)
+{
+
+	bChunkInd dataChunk;
+	dataChunk.code = DNA1;
+	dataChunk.dna_nr = 0;
+	dataChunk.nr = 1;
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES	
+	if (VOID_IS_8)
+	{
+#ifdef _WIN64
+		dataChunk.len = sBulletDNAlen64;
+		dataChunk.oldPtr = sBulletDNAstr64;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
+#else
+		btAssert(0);
+#endif
+	}
+	else
+	{
+#ifndef _WIN64
+		dataChunk.len = sBulletDNAlen;
+		dataChunk.oldPtr = sBulletDNAstr;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
+#else//_WIN64
+		btAssert(0);
+#endif//_WIN64
+	}
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		dataChunk.len = sBulletDNAlen64;
+		dataChunk.oldPtr = sBulletDNAstr64;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
+	}
+	else
+	{
+		dataChunk.len = sBulletDNAlen;
+		dataChunk.oldPtr = sBulletDNAstr;
+		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
+		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+}
+
+
+void	btBulletFile::parse(int verboseMode)
+{
+#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+#ifdef _WIN64
+		
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		parseInternal(verboseMode,(char*)sBulletDNAstr64,sBulletDNAlen64);
+#else
+		btAssert(0);
+#endif
+	}
+	else
+	{
+#ifndef _WIN64
+
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen);
+#else
+		btAssert(0);
+#endif
+	}
+#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	if (VOID_IS_8)
+	{
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
+		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen64);
+	}
+	else
+	{
+		if (m_DnaCopy)
+			delete m_DnaCopy;
+		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
+		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
+		parseInternal(verboseMode,m_DnaCopy,sBulletDNAlen);
+	}
+#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
+	
+	//the parsing will convert to cpu endian
+	mFlags &=~FD_ENDIAN_SWAP;
+
+	int littleEndian= 1;
+	littleEndian= ((char*)&littleEndian)[0];
+	
+	mFileBuffer[8] = littleEndian?'v':'V';
+	
+}
+
+// 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;
+	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,83 @@
+/*
+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"
+
+#include "LinearMath/btSerializer.h"
+
+
+
+namespace bParse {
+
+	// ----------------------------------------------------- //
+	class btBulletFile : public bFile
+	{
+		
+
+	protected:
+	
+		char*	m_DnaCopy;
+				
+	public:
+
+		btAlignedObjectArray<bStructHandle*>	m_softBodies;
+
+		btAlignedObjectArray<bStructHandle*>	m_rigidBodies;
+
+		btAlignedObjectArray<bStructHandle*>	m_collisionObjects;
+
+		btAlignedObjectArray<bStructHandle*>	m_collisionShapes;
+
+		btAlignedObjectArray<bStructHandle*>	m_constraints;
+
+		btAlignedObjectArray<bStructHandle*>	m_bvhs;
+
+		btAlignedObjectArray<bStructHandle*>	m_triangleInfoMaps;
+
+		btAlignedObjectArray<bStructHandle*>	m_dynamicsWorldInfo;
+
+		btAlignedObjectArray<char*>				m_dataBlocks;
+		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(int verboseMode);
+
+		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/BulletFileLoader/premake4.lua

@@ -0,0 +1,12 @@
+	project "BulletFileLoader"
+		
+	kind "StaticLib"
+	targetdir "../../lib"
+	includedirs {
+		"../../../src"
+	}
+	 
+	files {
+		"**.cpp",
+		"**.h"
+	}

Extras/Serialize/BulletWorldImporter/CMakeLists.txt

@@ -0,0 +1,40 @@
+INCLUDE_DIRECTORIES( 
+	${BULLET_PHYSICS_SOURCE_DIR}/src
+	${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BulletFileLoader
+)
+
+ADD_LIBRARY(
+BulletWorldImporter 
+btBulletWorldImporter.cpp 
+btBulletWorldImporter.h 
+btWorldImporter.cpp 
+btWorldImporter.h 
+)
+
+SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES VERSION ${BULLET_VERSION})
+SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES SOVERSION ${BULLET_VERSION})
+
+IF (BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(BulletWorldImporter BulletDynamics BulletCollision BulletFileLoader LinearMath)
+ENDIF (BUILD_SHARED_LIBS)
+
+IF (INSTALL_EXTRA_LIBS)
+	IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+		#FILES_MATCHING requires CMake 2.6
+		IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+			IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+				INSTALL(TARGETS BulletWorldImporter DESTINATION .)
+			ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+				INSTALL(TARGETS BulletWorldImporter DESTINATION lib${LIB_SUFFIX})
+				INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h"  PATTERN
+".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
+			ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+		ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+
+		IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+			SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES FRAMEWORK true)
+			SET_TARGET_PROPERTIES(BulletWorldImporter PROPERTIES PUBLIC_HEADER "btBulletWorldImporter.h")
+		ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+	ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+ENDIF (INSTALL_EXTRA_LIBS)

Extras/Serialize/BulletWorldImporter/btBulletWorldImporter.cpp

@@ -0,0 +1,362 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+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 "btBulletWorldImporter.h"
+#include "../BulletFileLoader/btBulletFile.h"
+
+#include "btBulletDynamicsCommon.h"
+#include "BulletCollision/Gimpact/btGImpactShape.h"
+
+
+
+//#define USE_INTERNAL_EDGE_UTILITY
+#ifdef USE_INTERNAL_EDGE_UTILITY
+#include "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h"
+#endif //USE_INTERNAL_EDGE_UTILITY
+
+btBulletWorldImporter::btBulletWorldImporter(btDynamicsWorld* world)
+	:btWorldImporter(world)
+{
+}
+
+btBulletWorldImporter::~btBulletWorldImporter()
+{
+}
+
+
+bool	btBulletWorldImporter::loadFile( const char* fileName, const char* preSwapFilenameOut)
+{
+	bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(fileName);
+
+	
+	bool result = loadFileFromMemory(bulletFile2);
+	//now you could save the file in 'native' format using
+	//bulletFile2->writeFile("native.bullet");
+	if (result)
+	{
+		if (preSwapFilenameOut)
+		{
+			bulletFile2->preSwap();
+			bulletFile2->writeFile(preSwapFilenameOut);
+		}
+		
+	}
+	delete bulletFile2;
+	
+	return result;
+
+}
+
+
+
+bool	btBulletWorldImporter::loadFileFromMemory( char* memoryBuffer, int len)
+{
+	bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(memoryBuffer,len);
+
+	bool result = loadFileFromMemory(bulletFile2);
+
+	delete bulletFile2;
+
+	return result;
+}
+
+
+
+
+bool	btBulletWorldImporter::loadFileFromMemory(  bParse::btBulletFile* bulletFile2)
+{
+	bool ok = (bulletFile2->getFlags()& bParse::FD_OK)!=0;
+	
+	if (ok)
+		bulletFile2->parse(m_verboseMode);
+	else 
+		return false;
+	
+	if (m_verboseMode & bParse::FD_VERBOSE_DUMP_CHUNKS)
+	{
+		bulletFile2->dumpChunks(bulletFile2->getFileDNA());
+	}
+
+	return convertAllObjects(bulletFile2);
+
+}
+
+bool	btBulletWorldImporter::convertAllObjects(  bParse::btBulletFile* bulletFile2)
+{
+
+	m_shapeMap.clear();
+	m_bodyMap.clear();
+
+	int i;
+	
+	for (i=0;i<bulletFile2->m_bvhs.size();i++)
+	{
+		btOptimizedBvh* bvh = createOptimizedBvh();
+
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btQuantizedBvhDoubleData* bvhData = (btQuantizedBvhDoubleData*)bulletFile2->m_bvhs[i];
+			bvh->deSerializeDouble(*bvhData);
+		} else
+		{
+			btQuantizedBvhFloatData* bvhData = (btQuantizedBvhFloatData*)bulletFile2->m_bvhs[i];
+			bvh->deSerializeFloat(*bvhData);
+		}
+		m_bvhMap.insert(bulletFile2->m_bvhs[i],bvh);
+	}
+
+
+
+	
+
+	for (i=0;i<bulletFile2->m_collisionShapes.size();i++)
+	{
+		btCollisionShapeData* shapeData = (btCollisionShapeData*)bulletFile2->m_collisionShapes[i];
+		btCollisionShape* shape = convertCollisionShape(shapeData);
+		if (shape)
+		{
+	//		printf("shapeMap.insert(%x,%x)\n",shapeData,shape);
+			m_shapeMap.insert(shapeData,shape);
+		}
+
+		if (shape&& shapeData->m_name)
+		{
+			char* newname = duplicateName(shapeData->m_name);
+			m_objectNameMap.insert(shape,newname);
+			m_nameShapeMap.insert(newname,shape);
+		}
+	}
+
+	
+
+
+	
+	for (int i=0;i<bulletFile2->m_dynamicsWorldInfo.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btDynamicsWorldDoubleData* solverInfoData = (btDynamicsWorldDoubleData*)bulletFile2->m_dynamicsWorldInfo[i];
+			btContactSolverInfo solverInfo;
+
+			btVector3 gravity;
+			gravity.deSerializeDouble(solverInfoData->m_gravity);
+
+			solverInfo.m_tau = btScalar(solverInfoData->m_solverInfo.m_tau);
+			solverInfo.m_damping = btScalar(solverInfoData->m_solverInfo.m_damping);
+			solverInfo.m_friction = btScalar(solverInfoData->m_solverInfo.m_friction);
+			solverInfo.m_timeStep = btScalar(solverInfoData->m_solverInfo.m_timeStep);
+
+			solverInfo.m_restitution = btScalar(solverInfoData->m_solverInfo.m_restitution);
+			solverInfo.m_maxErrorReduction = btScalar(solverInfoData->m_solverInfo.m_maxErrorReduction);
+			solverInfo.m_sor = btScalar(solverInfoData->m_solverInfo.m_sor);
+			solverInfo.m_erp = btScalar(solverInfoData->m_solverInfo.m_erp);
+
+			solverInfo.m_erp2 = btScalar(solverInfoData->m_solverInfo.m_erp2);
+			solverInfo.m_globalCfm = btScalar(solverInfoData->m_solverInfo.m_globalCfm);
+			solverInfo.m_splitImpulsePenetrationThreshold = btScalar(solverInfoData->m_solverInfo.m_splitImpulsePenetrationThreshold);
+			solverInfo.m_splitImpulseTurnErp = btScalar(solverInfoData->m_solverInfo.m_splitImpulseTurnErp);
+		
+			solverInfo.m_linearSlop = btScalar(solverInfoData->m_solverInfo.m_linearSlop);
+			solverInfo.m_warmstartingFactor = btScalar(solverInfoData->m_solverInfo.m_warmstartingFactor);
+			solverInfo.m_maxGyroscopicForce = btScalar(solverInfoData->m_solverInfo.m_maxGyroscopicForce);
+			solverInfo.m_singleAxisRollingFrictionThreshold = btScalar(solverInfoData->m_solverInfo.m_singleAxisRollingFrictionThreshold);
+		
+			solverInfo.m_numIterations = solverInfoData->m_solverInfo.m_numIterations;
+			solverInfo.m_solverMode = solverInfoData->m_solverInfo.m_solverMode;
+			solverInfo.m_restingContactRestitutionThreshold = solverInfoData->m_solverInfo.m_restingContactRestitutionThreshold;
+			solverInfo.m_minimumSolverBatchSize = solverInfoData->m_solverInfo.m_minimumSolverBatchSize;
+		
+			solverInfo.m_splitImpulse = solverInfoData->m_solverInfo.m_splitImpulse;
+
+			setDynamicsWorldInfo(gravity,solverInfo);
+		} else
+		{
+			btDynamicsWorldFloatData* solverInfoData = (btDynamicsWorldFloatData*)bulletFile2->m_dynamicsWorldInfo[i];
+			btContactSolverInfo solverInfo;
+
+			btVector3 gravity;
+			gravity.deSerializeFloat(solverInfoData->m_gravity);
+
+			solverInfo.m_tau = solverInfoData->m_solverInfo.m_tau;
+			solverInfo.m_damping = solverInfoData->m_solverInfo.m_damping;
+			solverInfo.m_friction = solverInfoData->m_solverInfo.m_friction;
+			solverInfo.m_timeStep = solverInfoData->m_solverInfo.m_timeStep;
+
+			solverInfo.m_restitution = solverInfoData->m_solverInfo.m_restitution;
+			solverInfo.m_maxErrorReduction = solverInfoData->m_solverInfo.m_maxErrorReduction;
+			solverInfo.m_sor = solverInfoData->m_solverInfo.m_sor;
+			solverInfo.m_erp = solverInfoData->m_solverInfo.m_erp;
+
+			solverInfo.m_erp2 = solverInfoData->m_solverInfo.m_erp2;
+			solverInfo.m_globalCfm = solverInfoData->m_solverInfo.m_globalCfm;
+			solverInfo.m_splitImpulsePenetrationThreshold = solverInfoData->m_solverInfo.m_splitImpulsePenetrationThreshold;
+			solverInfo.m_splitImpulseTurnErp = solverInfoData->m_solverInfo.m_splitImpulseTurnErp;
+		
+			solverInfo.m_linearSlop = solverInfoData->m_solverInfo.m_linearSlop;
+			solverInfo.m_warmstartingFactor = solverInfoData->m_solverInfo.m_warmstartingFactor;
+			solverInfo.m_maxGyroscopicForce = solverInfoData->m_solverInfo.m_maxGyroscopicForce;
+			solverInfo.m_singleAxisRollingFrictionThreshold = solverInfoData->m_solverInfo.m_singleAxisRollingFrictionThreshold;
+		
+			solverInfo.m_numIterations = solverInfoData->m_solverInfo.m_numIterations;
+			solverInfo.m_solverMode = solverInfoData->m_solverInfo.m_solverMode;
+			solverInfo.m_restingContactRestitutionThreshold = solverInfoData->m_solverInfo.m_restingContactRestitutionThreshold;
+			solverInfo.m_minimumSolverBatchSize = solverInfoData->m_solverInfo.m_minimumSolverBatchSize;
+		
+			solverInfo.m_splitImpulse = solverInfoData->m_solverInfo.m_splitImpulse;
+
+			setDynamicsWorldInfo(gravity,solverInfo);
+		}
+	}
+
+
+	for (i=0;i<bulletFile2->m_rigidBodies.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btRigidBodyDoubleData* colObjData = (btRigidBodyDoubleData*)bulletFile2->m_rigidBodies[i];
+			convertRigidBodyDouble(colObjData);
+		} else
+		{
+			btRigidBodyFloatData* colObjData = (btRigidBodyFloatData*)bulletFile2->m_rigidBodies[i];
+			convertRigidBodyFloat(colObjData);
+		}
+
+		
+	}
+
+	for (i=0;i<bulletFile2->m_collisionObjects.size();i++)
+	{
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			btCollisionObjectDoubleData* colObjData = (btCollisionObjectDoubleData*)bulletFile2->m_collisionObjects[i];
+			btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape);
+			if (shapePtr && *shapePtr)
+			{
+				btTransform startTransform;
+				colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f;
+				startTransform.deSerializeDouble(colObjData->m_worldTransform);
+				
+				btCollisionShape* shape = (btCollisionShape*)*shapePtr;
+				btCollisionObject* body = createCollisionObject(startTransform,shape,colObjData->m_name);
+				body->setFriction(btScalar(colObjData->m_friction));
+				body->setRestitution(btScalar(colObjData->m_restitution));
+				
+#ifdef USE_INTERNAL_EDGE_UTILITY
+				if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+				{
+					btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
+					if (trimesh->getTriangleInfoMap())
+					{
+						body->setCollisionFlags(body->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+					}
+				}
+#endif //USE_INTERNAL_EDGE_UTILITY
+				m_bodyMap.insert(colObjData,body);
+			} else
+			{
+				printf("error: no shape found\n");
+			}
+	
+		} else
+		{
+			btCollisionObjectFloatData* colObjData = (btCollisionObjectFloatData*)bulletFile2->m_collisionObjects[i];
+			btCollisionShape** shapePtr = m_shapeMap.find(colObjData->m_collisionShape);
+			if (shapePtr && *shapePtr)
+			{
+				btTransform startTransform;
+				colObjData->m_worldTransform.m_origin.m_floats[3] = 0.f;
+				startTransform.deSerializeFloat(colObjData->m_worldTransform);
+				
+				btCollisionShape* shape = (btCollisionShape*)*shapePtr;
+				btCollisionObject* body = createCollisionObject(startTransform,shape,colObjData->m_name);
+
+#ifdef USE_INTERNAL_EDGE_UTILITY
+				if (shape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
+				{
+					btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)shape;
+					if (trimesh->getTriangleInfoMap())
+					{
+						body->setCollisionFlags(body->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+					}
+				}
+#endif //USE_INTERNAL_EDGE_UTILITY
+				m_bodyMap.insert(colObjData,body);
+			} else
+			{
+				printf("error: no shape found\n");
+			}
+		}
+		
+	}
+
+	
+	for (i=0;i<bulletFile2->m_constraints.size();i++)
+	{
+		btTypedConstraintData2* constraintData = (btTypedConstraintData2*)bulletFile2->m_constraints[i];
+		btTypedConstraintFloatData* singleC = (btTypedConstraintFloatData*)bulletFile2->m_constraints[i];
+		btTypedConstraintDoubleData* doubleC = (btTypedConstraintDoubleData*)bulletFile2->m_constraints[i];
+
+		btCollisionObject** colAptr = m_bodyMap.find(constraintData->m_rbA);
+		btCollisionObject** colBptr = m_bodyMap.find(constraintData->m_rbB);
+
+		btRigidBody* rbA = 0;
+		btRigidBody* rbB = 0;
+
+		if (colAptr)
+		{
+			rbA = btRigidBody::upcast(*colAptr);
+			if (!rbA)
+				rbA = &getFixedBody();
+		}
+		if (colBptr)
+		{
+			rbB = btRigidBody::upcast(*colBptr);
+			if (!rbB)
+				rbB = &getFixedBody();
+		}
+		if (!rbA && !rbB)
+			continue;
+				
+		bool isDoublePrecisionData = (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)!=0;
+		
+		if (isDoublePrecisionData)
+		{
+			if (bulletFile2->getVersion()>=282)
+			{
+				btTypedConstraintDoubleData* dc = (btTypedConstraintDoubleData*)constraintData;
+				convertConstraintDouble(dc, rbA,rbB, bulletFile2->getVersion());
+			} else
+			{
+				//double-precision constraints were messed up until 2.82, try to recover data...
+				
+				btTypedConstraintData* oldData = (btTypedConstraintData*)constraintData;
+				
+				convertConstraintBackwardsCompatible281(oldData, rbA,rbB, bulletFile2->getVersion());
+
+			}
+		}
+		else
+		{
+			btTypedConstraintFloatData* dc = (btTypedConstraintFloatData*)constraintData;
+			convertConstraintFloat(dc, rbA,rbB, bulletFile2->getVersion());
+		}
+		
+
+	}
+
+	return true;
+}
+

Extras/Serialize/BulletWorldImporter/btBulletWorldImporter.h

@@ -0,0 +1,68 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+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 BULLET_WORLD_IMPORTER_H
+#define BULLET_WORLD_IMPORTER_H
+
+
+#include "btWorldImporter.h"
+
+
+class btBulletFile;
+
+
+
+
+namespace bParse
+{
+	class btBulletFile;
+	
+};
+
+
+
+///The btBulletWorldImporter is a starting point to import .bullet files.
+///note that not all data is converted yet. You are expected to override or modify this class.
+///See Bullet/Demos/SerializeDemo for a derived class that extract btSoftBody objects too.
+class btBulletWorldImporter : public btWorldImporter
+{
+
+
+public:
+	
+	btBulletWorldImporter(btDynamicsWorld* world=0);
+
+	virtual ~btBulletWorldImporter();
+
+	///if you pass a valid preSwapFilenameOut, it will save a new file with a different endianness 
+	///this pre-swapped file can be loaded without swapping on a target platform of different endianness
+	bool	loadFile(const char* fileName, const char* preSwapFilenameOut=0);
+
+	///the memoryBuffer might be modified (for example if endian swaps are necessary)
+	bool	loadFileFromMemory(char *memoryBuffer, int len);
+
+	bool	loadFileFromMemory(bParse::btBulletFile* file);
+
+	//call make sure bulletFile2 has been parsed, either using btBulletFile::parse or btBulletWorldImporter::loadFileFromMemory
+	virtual	bool	convertAllObjects(bParse::btBulletFile* file);
+
+	
+
+
+};
+
+#endif //BULLET_WORLD_IMPORTER_H
+

Extras/Serialize/BulletWorldImporter/btWorldImporter.h

@@ -0,0 +1,212 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+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_WORLD_IMPORTER_H
+#define BT_WORLD_IMPORTER_H
+
+#include "LinearMath/btTransform.h"
+#include "LinearMath/btVector3.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#include "LinearMath/btHashMap.h"
+
+class btCollisionShape;
+class btCollisionObject;
+class btRigidBody;
+class btTypedConstraint;
+class btDynamicsWorld;
+struct ConstraintInput;
+class btRigidBodyColladaInfo;
+struct btCollisionShapeData;
+class btTriangleIndexVertexArray;
+class btStridingMeshInterface;
+struct btStridingMeshInterfaceData;
+class btGImpactMeshShape;
+class btOptimizedBvh;
+struct btTriangleInfoMap;
+class btBvhTriangleMeshShape;
+class btPoint2PointConstraint;
+class btHingeConstraint;
+class btConeTwistConstraint;
+class btGeneric6DofConstraint;
+class btGeneric6DofSpringConstraint;
+class btSliderConstraint;
+class btGearConstraint;
+struct btContactSolverInfo;
+struct btTypedConstraintData;
+struct btTypedConstraintFloatData;
+struct btTypedConstraintDoubleData;
+
+struct btRigidBodyDoubleData;
+struct btRigidBodyFloatData;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btRigidBodyData btRigidBodyDoubleData
+#else
+#define btRigidBodyData btRigidBodyFloatData
+#endif//BT_USE_DOUBLE_PRECISION
+
+
+class btWorldImporter
+{
+protected:
+	btDynamicsWorld* m_dynamicsWorld;
+	
+	int m_verboseMode;
+
+	btAlignedObjectArray<btCollisionShape*>  m_allocatedCollisionShapes;
+	btAlignedObjectArray<btCollisionObject*> m_allocatedRigidBodies;
+	btAlignedObjectArray<btTypedConstraint*> m_allocatedConstraints;
+	btAlignedObjectArray<btOptimizedBvh*>	 m_allocatedBvhs;
+	btAlignedObjectArray<btTriangleInfoMap*> m_allocatedTriangleInfoMaps;
+	btAlignedObjectArray<btTriangleIndexVertexArray*> m_allocatedTriangleIndexArrays;
+	btAlignedObjectArray<btStridingMeshInterfaceData*> m_allocatedbtStridingMeshInterfaceDatas;
+
+	btAlignedObjectArray<char*>				m_allocatedNames;
+
+	btAlignedObjectArray<int*>				m_indexArrays;
+	btAlignedObjectArray<short int*>		m_shortIndexArrays;
+	btAlignedObjectArray<unsigned char*>	m_charIndexArrays;
+
+	btAlignedObjectArray<btVector3FloatData*>	m_floatVertexArrays;
+	btAlignedObjectArray<btVector3DoubleData*>	m_doubleVertexArrays;
+
+
+	btHashMap<btHashPtr,btOptimizedBvh*>	m_bvhMap;
+	btHashMap<btHashPtr,btTriangleInfoMap*>	m_timMap;
+	
+	btHashMap<btHashString,btCollisionShape*>	m_nameShapeMap;
+	btHashMap<btHashString,btRigidBody*>	m_nameBodyMap;
+	btHashMap<btHashString,btTypedConstraint*>	m_nameConstraintMap;
+	btHashMap<btHashPtr,const char*>	m_objectNameMap;
+
+	btHashMap<btHashPtr,btCollisionShape*>	m_shapeMap;
+	btHashMap<btHashPtr,btCollisionObject*>	m_bodyMap;
+
+
+	//methods
+
+	static btRigidBody& getFixedBody();
+
+	char*	duplicateName(const char* name);
+
+	btCollisionShape* convertCollisionShape(  btCollisionShapeData* shapeData  );
+	
+	void	convertConstraintBackwardsCompatible281(btTypedConstraintData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertConstraintFloat(btTypedConstraintFloatData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertConstraintDouble(btTypedConstraintDoubleData* constraintData, btRigidBody* rbA, btRigidBody* rbB, int fileVersion);
+	void	convertRigidBodyFloat(btRigidBodyFloatData* colObjData);
+	void	convertRigidBodyDouble( btRigidBodyDoubleData* colObjData);
+
+public:
+	
+	btWorldImporter(btDynamicsWorld* world);
+	
+	virtual ~btWorldImporter();
+
+		///delete all memory collision shapes, rigid bodies, constraints etc. allocated during the load.
+	///make sure you don't use the dynamics world containing objects after you call this method
+	virtual void deleteAllData();
+
+	void	setVerboseMode(int verboseMode)
+	{
+		m_verboseMode = verboseMode;
+	}
+
+	int getVerboseMode() const
+	{
+		return m_verboseMode;
+	}
+
+		// query for data
+	int	getNumCollisionShapes() const;
+	btCollisionShape* getCollisionShapeByIndex(int index);
+	int getNumRigidBodies() const;
+	btCollisionObject* getRigidBodyByIndex(int index) const;
+	int getNumConstraints() const;
+	btTypedConstraint* getConstraintByIndex(int index) const;
+	int getNumBvhs() const;
+	btOptimizedBvh*  getBvhByIndex(int index) const;
+	int getNumTriangleInfoMaps() const;
+	btTriangleInfoMap* getTriangleInfoMapByIndex(int index) const;
+	
+	// queris involving named objects
+	btCollisionShape* getCollisionShapeByName(const char* name);
+	btRigidBody* getRigidBodyByName(const char* name);
+	btTypedConstraint* getConstraintByName(const char* name);
+	const char*	getNameForPointer(const void* ptr) const;
+
+	///those virtuals are called by load and can be overridden by the user
+
+	virtual void	setDynamicsWorldInfo(const btVector3& gravity, const btContactSolverInfo& solverInfo);
+
+	//bodies
+	virtual btRigidBody*  createRigidBody(bool isDynamic, 	btScalar mass, 	const btTransform& startTransform,	btCollisionShape* shape,const char* bodyName);
+	virtual btCollisionObject*  createCollisionObject(	const btTransform& startTransform,	btCollisionShape* shape,const char* bodyName);
+
+	///shapes
+
+	virtual btCollisionShape* createPlaneShape(const btVector3& planeNormal,btScalar planeConstant);
+	virtual btCollisionShape* createBoxShape(const btVector3& halfExtents);
+	virtual btCollisionShape* createSphereShape(btScalar radius);
+	virtual btCollisionShape* createCapsuleShapeX(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeY(btScalar radius, btScalar height);
+	virtual btCollisionShape* createCapsuleShapeZ(btScalar radius, btScalar height);
+	
+	virtual btCollisionShape* createCylinderShapeX(btScalar radius,btScalar height);
+	virtual btCollisionShape* createCylinderShapeY(btScalar radius,btScalar height);
+	virtual btCollisionShape* createCylinderShapeZ(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeX(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeY(btScalar radius,btScalar height);
+	virtual btCollisionShape* createConeShapeZ(btScalar radius,btScalar height);
+	virtual class btTriangleIndexVertexArray*	createTriangleMeshContainer();
+	virtual	btBvhTriangleMeshShape* createBvhTriangleMeshShape(btStridingMeshInterface* trimesh, btOptimizedBvh* bvh);
+	virtual btCollisionShape* createConvexTriangleMeshShape(btStridingMeshInterface* trimesh);
+	virtual btGImpactMeshShape* createGimpactShape(btStridingMeshInterface* trimesh);
+	virtual btStridingMeshInterfaceData* createStridingMeshInterfaceData(btStridingMeshInterfaceData* interfaceData);
+
+	virtual class btConvexHullShape* createConvexHullShape();
+	virtual class btCompoundShape* createCompoundShape();
+	virtual class btScaledBvhTriangleMeshShape* createScaledTrangleMeshShape(btBvhTriangleMeshShape* meshShape,const btVector3& localScalingbtBvhTriangleMeshShape);
+
+	virtual class btMultiSphereShape* createMultiSphereShape(const btVector3* positions,const btScalar* radi,int numSpheres);
+
+	virtual btTriangleIndexVertexArray* createMeshInterface(btStridingMeshInterfaceData& meshData);
+
+	///acceleration and connectivity structures
+	virtual btOptimizedBvh*	createOptimizedBvh();
+	virtual btTriangleInfoMap* createTriangleInfoMap();
+
+	///constraints
+	virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB);
+	virtual btPoint2PointConstraint* createPoint2PointConstraint(btRigidBody& rbA,const btVector3& pivotInA);
+	virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA=false);
+	virtual btHingeConstraint* createHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA=false);
+	virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA,btRigidBody& rbB,const btTransform& rbAFrame, const btTransform& rbBFrame);
+	virtual btConeTwistConstraint* createConeTwistConstraint(btRigidBody& rbA,const btTransform& rbAFrame);
+	virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+    virtual btGeneric6DofConstraint* createGeneric6DofConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameB);
+	virtual btGeneric6DofSpringConstraint* createGeneric6DofSpringConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+	virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
+    virtual btSliderConstraint* createSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA);
+	virtual btGearConstraint* createGearConstraint(btRigidBody& rbA, btRigidBody& rbB, const btVector3& axisInA,const btVector3& axisInB, btScalar ratio);
+	
+
+
+
+};
+
+
+#endif //BT_WORLD_IMPORTER_H

Extras/Serialize/BulletWorldImporter/premake4.lua

@@ -0,0 +1,13 @@
+	project "BulletWorldImporter"
+		
+	kind "StaticLib"
+	targetdir "../../lib"
+	includedirs {
+		"../BulletFileLoader",
+		"../../../src"
+	}
+	 
+	files {
+		"**.cpp",
+		"**.h"
+	}

Extras/Serialize/BulletXmlWorldImporter/CMakeLists.txt

@@ -0,0 +1,47 @@
+INCLUDE_DIRECTORIES( 
+	${BULLET_PHYSICS_SOURCE_DIR}/src
+	${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BulletFileLoader
+	${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/BulletWorldImporter
+)
+
+ADD_LIBRARY(
+	BulletXmlWorldImporter 
+	btBulletXmlWorldImporter.cpp 
+	btBulletXmlWorldImporter.h 
+	string_split.cpp
+	string_split.h
+	tinyxml.cpp
+	tinyxml.h
+	tinystr.cpp
+	tinystr.h
+	tinyxmlerror.cpp
+	tinyxmlparser.cpp
+)
+
+SET_TARGET_PROPERTIES(BulletXmlWorldImporter  PROPERTIES VERSION ${BULLET_VERSION})
+SET_TARGET_PROPERTIES(BulletXmlWorldImporter PROPERTIES SOVERSION ${BULLET_VERSION})
+
+IF (BUILD_SHARED_LIBS)
+        TARGET_LINK_LIBRARIES(BulletXmlWorldImporter BulletWorldImporter BulletDynamics BulletCollision BulletFileLoader LinearMath)
+ENDIF (BUILD_SHARED_LIBS)
+
+IF (INSTALL_EXTRA_LIBS)
+	IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+		#FILES_MATCHING requires CMake 2.6
+		IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+			IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+				INSTALL(TARGETS BulletXmlWorldImporter DESTINATION .)
+			ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+				INSTALL(TARGETS BulletXmlWorldImporter DESTINATION lib${LIB_SUFFIX})
+				INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h"  PATTERN
+".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
+			ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+		ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
+
+		IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+			SET_TARGET_PROPERTIES(BulletXmlWorldImporter PROPERTIES FRAMEWORK true)
+			SET_TARGET_PROPERTIES(BulletXmlWorldImporter PROPERTIES PUBLIC_HEADER "btBulletXmlWorldImporter.h")
+		ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
+	ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+ENDIF (INSTALL_EXTRA_LIBS)

Extras/Serialize/BulletXmlWorldImporter/btBulletXmlWorldImporter.cpp

@@ -0,0 +1,871 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+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 "btBulletXmlWorldImporter.h"
+#include "tinyxml.h"
+#include "btBulletDynamicsCommon.h"
+#include "string_split.h"
+
+
+btBulletXmlWorldImporter::btBulletXmlWorldImporter(btDynamicsWorld* world)
+	:btWorldImporter(world),
+	m_fileVersion(-1),
+	m_fileOk(false)
+{
+
+}
+
+btBulletXmlWorldImporter::~btBulletXmlWorldImporter()
+{
+
+}
+
+
+static int get_double_attribute_by_name(const TiXmlElement* pElement, const char* attribName,double* value)
+{
+	if ( !pElement ) 
+		return 0;
+
+	const TiXmlAttribute* pAttrib=pElement->FirstAttribute();
+	while (pAttrib)
+	{
+		if (pAttrib->Name()==attribName)
+			if (pAttrib->QueryDoubleValue(value)==TIXML_SUCCESS)
+				return 1;
+		pAttrib=pAttrib->Next();
+	}
+	return 0;
+}
+
+
+static int get_int_attribute_by_name(const TiXmlElement* pElement, const char* attribName,int* value)
+{
+	if ( !pElement ) 
+		return 0;
+
+	const TiXmlAttribute* pAttrib=pElement->FirstAttribute();
+	while (pAttrib)
+	{
+		if (!strcmp(pAttrib->Name(),attribName))
+			if (pAttrib->QueryIntValue(value)==TIXML_SUCCESS)
+				return 1;
+//		if (pAttrib->QueryDoubleValue(&dval)==TIXML_SUCCESS) printf( " d=%1.1f", dval);
+		pAttrib=pAttrib->Next();
+	}
+	return 0;
+}
+
+void stringToFloatArray(const std::string& string, btAlignedObjectArray<float>& floats)
+{
+	btAlignedObjectArray<std::string> pieces;
+
+    bullet_utils::split( pieces, string, " ");
+    for ( int i = 0; i < pieces.size(); ++i)
+	{
+		assert(pieces[i]!="");
+        floats.push_back((float)atof(pieces[i].c_str()));
+    }
+	  
+}
+
+static btVector3FloatData TextToVector3Data(const char* txt)
+{
+	btAssert(txt);
+	btAlignedObjectArray<float> floats;
+	stringToFloatArray(txt, floats);
+	assert(floats.size()==4);
+
+	btVector3FloatData vec4;
+	vec4.m_floats[0] = floats[0];
+	vec4.m_floats[1] = floats[1];
+	vec4.m_floats[2] = floats[2];
+	vec4.m_floats[3] = floats[3];
+	return vec4;
+}
+
+void btBulletXmlWorldImporter::deSerializeVector3FloatData(TiXmlNode* pParent,btAlignedObjectArray<btVector3FloatData>& vectors)
+{
+	TiXmlNode* flNode = pParent->FirstChild("m_floats");
+	btAssert(flNode);
+	while (flNode && flNode->FirstChild())
+	{
+		TiXmlText* pText = flNode->FirstChild()->ToText();
+//		printf("value = %s\n",pText->Value());
+		btVector3FloatData vec4 = TextToVector3Data(pText->Value());
+		vectors.push_back(vec4);
+		flNode = flNode->NextSibling();
+	}
+	
+}
+
+
+#define SET_INT_VALUE(xmlnode, targetdata, argname) \
+	btAssert((xmlnode)->FirstChild(#argname) && (xmlnode)->FirstChild(#argname)->ToElement());\
+	if ((xmlnode)->FirstChild(#argname) && (xmlnode)->FirstChild(#argname)->ToElement())\
+		(targetdata)->argname= (int)atof(xmlnode->FirstChild(#argname)->ToElement()->GetText());
+
+
+#define SET_FLOAT_VALUE(xmlnode, targetdata, argname) \
+	btAssert((xmlnode)->FirstChild(#argname) && (xmlnode)->FirstChild(#argname)->ToElement());\
+	if ((xmlnode)->FirstChild(#argname) && (xmlnode)->FirstChild(#argname)->ToElement())\
+		(targetdata)->argname= (float)atof(xmlnode->FirstChild(#argname)->ToElement()->GetText());
+
+
+#define SET_POINTER_VALUE(xmlnode, targetdata, argname, pointertype) \
+	{\
+		TiXmlNode* node = xmlnode->FirstChild(#argname);\
+		btAssert(node);\
+		if (node)\
+		{\
+			const char* txt = (node)->ToElement()->GetText();\
+			(targetdata).argname= (pointertype) (int) atof(txt);\
+		}\
+	}
+
+#define SET_VECTOR4_VALUE(xmlnode, targetdata, argname) \
+	{\
+		TiXmlNode* flNode = xmlnode->FirstChild(#argname);\
+		btAssert(flNode);\
+		if (flNode && flNode->FirstChild())\
+		{\
+			const char* txt= flNode->FirstChild()->ToElement()->GetText();\
+			btVector3FloatData vec4 = TextToVector3Data(txt);\
+			(targetdata)->argname.m_floats[0] = vec4.m_floats[0];\
+			(targetdata)->argname.m_floats[1] = vec4.m_floats[1];\
+			(targetdata)->argname.m_floats[2] = vec4.m_floats[2];\
+			(targetdata)->argname.m_floats[3] = vec4.m_floats[3];\
+		}\
+	}
+
+
+#define SET_MATRIX33_VALUE(n, targetdata, argname) \
+{\
+	TiXmlNode* xmlnode = n->FirstChild(#argname);\
+	btAssert(xmlnode);\
+	if (xmlnode)\
+	{\
+		TiXmlNode* eleNode = xmlnode->FirstChild("m_el");\
+		btAssert(eleNode);\
+		if (eleNode&& eleNode->FirstChild())\
+		{\
+			const char* txt= eleNode->FirstChild()->ToElement()->GetText();\
+			btVector3FloatData vec4 = TextToVector3Data(txt);\
+			(targetdata)->argname.m_el[0].m_floats[0] = vec4.m_floats[0];\
+			(targetdata)->argname.m_el[0].m_floats[1] = vec4.m_floats[1];\
+			(targetdata)->argname.m_el[0].m_floats[2] = vec4.m_floats[2];\
+			(targetdata)->argname.m_el[0].m_floats[3] = vec4.m_floats[3];\
+			\
+			TiXmlNode* n1 = eleNode->FirstChild()->NextSibling();\
+			btAssert(n1);\
+			if (n1)\
+			{\
+				const char* txt= n1->ToElement()->GetText();\
+				btVector3FloatData vec4 = TextToVector3Data(txt);\
+				(targetdata)->argname.m_el[1].m_floats[0] = vec4.m_floats[0];\
+				(targetdata)->argname.m_el[1].m_floats[1] = vec4.m_floats[1];\
+				(targetdata)->argname.m_el[1].m_floats[2] = vec4.m_floats[2];\
+				(targetdata)->argname.m_el[1].m_floats[3] = vec4.m_floats[3];\
+			\
+				TiXmlNode* n2 = n1->NextSibling();\
+				btAssert(n2);\
+				if (n2)\
+				{\
+					const char* txt= n2->ToElement()->GetText();\
+					btVector3FloatData vec4 = TextToVector3Data(txt);\
+					(targetdata)->argname.m_el[2].m_floats[0] = vec4.m_floats[0];\
+					(targetdata)->argname.m_el[2].m_floats[1] = vec4.m_floats[1];\
+					(targetdata)->argname.m_el[2].m_floats[2] = vec4.m_floats[2];\
+					(targetdata)->argname.m_el[2].m_floats[3] = vec4.m_floats[3];\
+				}\
+			}\
+		}\
+	}\
+}\
+
+#define SET_TRANSFORM_VALUE(n, targetdata, argname) \
+{\
+	TiXmlNode* trNode = n->FirstChild(#argname);\
+	btAssert(trNode);\
+	if (trNode)\
+	{\
+		SET_VECTOR4_VALUE(trNode,&(targetdata)->argname,m_origin)\
+		SET_MATRIX33_VALUE(trNode, &(targetdata)->argname,m_basis)\
+	}\
+}\
+
+
+void btBulletXmlWorldImporter::deSerializeCollisionShapeData(TiXmlNode* pParent, btCollisionShapeData* colShapeData)
+{
+		SET_INT_VALUE(pParent,colShapeData,m_shapeType)
+		colShapeData->m_name = 0;
+}
+
+
+
+void btBulletXmlWorldImporter::deSerializeConvexHullShapeData(TiXmlNode* pParent)
+{
+	int ptr;
+	get_int_attribute_by_name(pParent->ToElement(),"pointer",&ptr);
+	
+	btConvexHullShapeData* convexHullData = (btConvexHullShapeData*)btAlignedAlloc(sizeof(btConvexHullShapeData), 16);
+
+	TiXmlNode* xmlConvexInt = pParent->FirstChild("m_convexInternalShapeData");
+	btAssert(xmlConvexInt);
+
+	TiXmlNode* xmlColShape = xmlConvexInt ->FirstChild("m_collisionShapeData");
+	btAssert(xmlColShape);
+
+	deSerializeCollisionShapeData(xmlColShape,&convexHullData->m_convexInternalShapeData.m_collisionShapeData);
+	
+	SET_FLOAT_VALUE(xmlConvexInt,&convexHullData->m_convexInternalShapeData,m_collisionMargin)
+	SET_VECTOR4_VALUE(xmlConvexInt,&convexHullData->m_convexInternalShapeData,m_localScaling)
+	SET_VECTOR4_VALUE(xmlConvexInt,&convexHullData->m_convexInternalShapeData,m_implicitShapeDimensions)
+
+	SET_POINTER_VALUE(pParent,*convexHullData,m_unscaledPointsFloatPtr,btVector3FloatData*);
+	SET_POINTER_VALUE(pParent,*convexHullData,m_unscaledPointsDoublePtr,btVector3DoubleData*);
+	SET_INT_VALUE(pParent,convexHullData,m_numUnscaledPoints);
+
+	m_collisionShapeData.push_back((btCollisionShapeData*)convexHullData);
+	m_pointerLookup.insert((void*)ptr,convexHullData);
+}
+
+void btBulletXmlWorldImporter::deSerializeCompoundShapeChildData(TiXmlNode* pParent)
+{
+	int ptr;
+	get_int_attribute_by_name(pParent->ToElement(),"pointer",&ptr);
+
+	int numChildren = 0;
+	btAlignedObjectArray<btCompoundShapeChildData>* compoundChildArrayPtr = new btAlignedObjectArray<btCompoundShapeChildData>;
+	{
+		TiXmlNode* transNode = pParent->FirstChild("m_transform");
+		TiXmlNode* colShapeNode = pParent->FirstChild("m_childShape");
+		TiXmlNode* marginNode = pParent->FirstChild("m_childMargin");
+		TiXmlNode* childTypeNode = pParent->FirstChild("m_childShapeType");
+
+		int i=0;
+		while (transNode && colShapeNode && marginNode && childTypeNode)
+		{
+			compoundChildArrayPtr->expandNonInitializing();
+			SET_VECTOR4_VALUE (transNode,&compoundChildArrayPtr->at(i).m_transform,m_origin)
+			SET_MATRIX33_VALUE(transNode,&compoundChildArrayPtr->at(i).m_transform,m_basis)
+
+			const char* txt = (colShapeNode)->ToElement()->GetText();
+			compoundChildArrayPtr->at(i).m_childShape = (btCollisionShapeData*) (int) atof(txt);
+			
+			btAssert(childTypeNode->ToElement());
+			if (childTypeNode->ToElement())
+			{
+				compoundChildArrayPtr->at(i).m_childShapeType =  (int)atof(childTypeNode->ToElement()->GetText());
+			}
+
+			btAssert(marginNode->ToElement());
+			if (marginNode->ToElement())
+			{
+				compoundChildArrayPtr->at(i).m_childMargin = (float)atof(marginNode->ToElement()->GetText());
+			}
+
+			transNode = transNode->NextSibling("m_transform");
+			colShapeNode = colShapeNode->NextSibling("m_childShape");
+			marginNode = marginNode->NextSibling("m_childMargin");
+			childTypeNode = childTypeNode->NextSibling("m_childShapeType");
+			i++;
+		}
+		
+		numChildren = i;
+		
+	}
+
+	btAssert(numChildren);
+	if (numChildren)
+	{
+		m_compoundShapeChildDataArrays.push_back(compoundChildArrayPtr);
+		btCompoundShapeChildData* cd = &compoundChildArrayPtr->at(0);
+		m_pointerLookup.insert((void*)ptr,cd);
+	}
+	
+}
+
+void btBulletXmlWorldImporter::deSerializeCompoundShapeData(TiXmlNode* pParent)
+{
+	int ptr;
+	get_int_attribute_by_name(pParent->ToElement(),"pointer",&ptr);
+
+	btCompoundShapeData* compoundData = (btCompoundShapeData*) btAlignedAlloc(sizeof(btCompoundShapeData),16); 
+
+	TiXmlNode* xmlColShape = pParent ->FirstChild("m_collisionShapeData");
+	btAssert(xmlColShape);
+	deSerializeCollisionShapeData(xmlColShape,&compoundData->m_collisionShapeData);
+	
+	SET_INT_VALUE(pParent, compoundData,m_numChildShapes);
+
+	TiXmlNode* xmlShapeData = pParent->FirstChild("m_collisionShapeData");
+	btAssert(xmlShapeData );
+
+	{
+		TiXmlNode* node = pParent->FirstChild("m_childShapePtr");\
+		btAssert(node);
+		while (node)
+		{
+			const char* txt = (node)->ToElement()->GetText();
+			compoundData->m_childShapePtr = (btCompoundShapeChildData*) (int) atof(txt);
+			node = node->NextSibling("m_childShapePtr");
+		}
+		//SET_POINTER_VALUE(xmlColShape, *compoundData,m_childShapePtr,btCompoundShapeChildData*);
+		
+	}
+	SET_FLOAT_VALUE(pParent, compoundData,m_collisionMargin);
+
+	m_collisionShapeData.push_back((btCollisionShapeData*)compoundData);
+	m_pointerLookup.insert((void*)ptr,compoundData);
+
+}
+
+void btBulletXmlWorldImporter::deSerializeStaticPlaneShapeData(TiXmlNode* pParent)
+{
+	int ptr;
+	get_int_attribute_by_name(pParent->ToElement(),"pointer",&ptr);
+
+	btStaticPlaneShapeData* planeData = (btStaticPlaneShapeData*) btAlignedAlloc(sizeof(btStaticPlaneShapeData),16);
+
+	TiXmlNode* xmlShapeData = pParent->FirstChild("m_collisionShapeData");
+	btAssert(xmlShapeData );
+	deSerializeCollisionShapeData(xmlShapeData,&planeData->m_collisionShapeData);
+
+	SET_VECTOR4_VALUE(pParent, planeData,m_localScaling);
+	SET_VECTOR4_VALUE(pParent, planeData,m_planeNormal);
+	SET_FLOAT_VALUE(pParent, planeData,m_planeConstant);
+
+	m_collisionShapeData.push_back((btCollisionShapeData*)planeData);
+	m_pointerLookup.insert((void*)ptr,planeData);
+
+}
+
+void btBulletXmlWorldImporter::deSerializeDynamicsWorldData(TiXmlNode* pParent)
+{
+	btContactSolverInfo solverInfo;
+	//btVector3 gravity(0,0,0);
+
+	//setDynamicsWorldInfo(gravity,solverInfo);
+
+	//gravity and world info
+}
+
+void btBulletXmlWorldImporter::deSerializeConvexInternalShapeData(TiXmlNode* pParent)
+{
+	int ptr=0;
+	get_int_attribute_by_name(pParent->ToElement(),"pointer",&ptr);
+	
+
+	btConvexInternalShapeData* convexShape = (btConvexInternalShapeData*) btAlignedAlloc(sizeof(btConvexInternalShapeData),16);
+	memset(convexShape,0,sizeof(btConvexInternalShapeData));
+
+	TiXmlNode* xmlShapeData = pParent->FirstChild("m_collisionShapeData");
+	btAssert(xmlShapeData );
+
+	deSerializeCollisionShapeData(xmlShapeData,&convexShape->m_collisionShapeData);
+
+	
+	SET_FLOAT_VALUE(pParent,convexShape,m_collisionMargin)
+	SET_VECTOR4_VALUE(pParent,convexShape,m_localScaling)
+	SET_VECTOR4_VALUE(pParent,convexShape,m_implicitShapeDimensions)
+
+	m_collisionShapeData.push_back((btCollisionShapeData*)convexShape);
+	m_pointerLookup.insert((void*)ptr,convexShape);
+
+}
+
+/*
+enum btTypedConstraintType
+{
+	POINT2POINT_CONSTRAINT_TYPE=3,
+	HINGE_CONSTRAINT_TYPE,
+	CONETWIST_CONSTRAINT_TYPE,
+//	D6_CONSTRAINT_TYPE,
+	SLIDER_CONSTRAINT_TYPE,
+	CONTACT_CONSTRAINT_TYPE,
+	D6_SPRING_CONSTRAINT_TYPE,
+	GEAR_CONSTRAINT_TYPE,
+	MAX_CONSTRAINT_TYPE
+};
+*/
+
+
+void btBulletXmlWorldImporter::deSerializeGeneric6DofConstraintData(TiXmlNode* pParent)
+{
+	int ptr=0;
+	get_int_attribute_by_name(pParent->ToElement(),"pointer",&ptr);
+	
+	btGeneric6DofConstraintData2* dof6Data = (btGeneric6DofConstraintData2*)btAlignedAlloc(sizeof(btGeneric6DofConstraintData2),16);
+
+	
+	TiXmlNode* n = pParent->FirstChild("m_typeConstraintData");
+	if (n)
+	{
+		SET_POINTER_VALUE(n,dof6Data->m_typeConstraintData,m_rbA,btRigidBodyData*);
+		SET_POINTER_VALUE(n,dof6Data->m_typeConstraintData,m_rbB,btRigidBodyData*);
+		dof6Data->m_typeConstraintData.m_name = 0;//tbd
+		SET_INT_VALUE(n,&dof6Data->m_typeConstraintData,m_objectType);
+		SET_INT_VALUE(n,&dof6Data->m_typeConstraintData,m_userConstraintType);
+		SET_INT_VALUE(n,&dof6Data->m_typeConstraintData,m_userConstraintId);
+		SET_INT_VALUE(n,&dof6Data->m_typeConstraintData,m_needsFeedback);
+		SET_FLOAT_VALUE(n,&dof6Data->m_typeConstraintData,m_appliedImpulse);
+		SET_FLOAT_VALUE(n,&dof6Data->m_typeConstraintData,m_dbgDrawSize);
+		SET_INT_VALUE(n,&dof6Data->m_typeConstraintData,m_disableCollisionsBetweenLinkedBodies);
+		SET_INT_VALUE(n,&dof6Data->m_typeConstraintData,m_overrideNumSolverIterations);
+		SET_FLOAT_VALUE(n,&dof6Data->m_typeConstraintData,m_breakingImpulseThreshold);
+		SET_INT_VALUE(n,&dof6Data->m_typeConstraintData,m_isEnabled);
+
+	}	
+
+	SET_TRANSFORM_VALUE( pParent, dof6Data, m_rbAFrame);
+	SET_TRANSFORM_VALUE( pParent, dof6Data, m_rbBFrame);
+	SET_VECTOR4_VALUE(pParent, dof6Data, m_linearUpperLimit);
+	SET_VECTOR4_VALUE(pParent, dof6Data, m_linearLowerLimit);
+	SET_VECTOR4_VALUE(pParent, dof6Data, m_angularUpperLimit);
+	SET_VECTOR4_VALUE(pParent, dof6Data, m_angularLowerLimit);
+	SET_INT_VALUE(pParent, dof6Data,m_useLinearReferenceFrameA);
+	SET_INT_VALUE(pParent, dof6Data,m_useOffsetForConstraintFrame);
+	
+	m_constraintData.push_back((btTypedConstraintData2*)dof6Data);
+	m_pointerLookup.insert((void*)ptr,dof6Data);
+}
+
+void btBulletXmlWorldImporter::deSerializeRigidBodyFloatData(TiXmlNode* pParent)
+{
+	int ptr=0;
+	if (!get_int_attribute_by_name(pParent->ToElement(),"pointer",&ptr))
+	{
+		m_fileOk = false;
+		return;
+	}
+	
+	btRigidBodyData* rbData = (btRigidBodyData*)btAlignedAlloc(sizeof(btRigidBodyData),16);
+	
+	TiXmlNode* n = pParent->FirstChild("m_collisionObjectData");
+
+	if (n)
+	{
+		SET_POINTER_VALUE(n,rbData->m_collisionObjectData,m_collisionShape, void*);
+		SET_TRANSFORM_VALUE(n,&rbData->m_collisionObjectData,m_worldTransform);
+		SET_TRANSFORM_VALUE(n,&rbData->m_collisionObjectData,m_interpolationWorldTransform);
+		SET_VECTOR4_VALUE(n,&rbData->m_collisionObjectData,m_interpolationLinearVelocity)
+		SET_VECTOR4_VALUE(n,&rbData->m_collisionObjectData,m_interpolationAngularVelocity)
+		SET_VECTOR4_VALUE(n,&rbData->m_collisionObjectData,m_anisotropicFriction)
+		SET_FLOAT_VALUE(n,&rbData->m_collisionObjectData,m_contactProcessingThreshold);
+		SET_FLOAT_VALUE(n,&rbData->m_collisionObjectData,m_deactivationTime);
+		SET_FLOAT_VALUE(n,&rbData->m_collisionObjectData,m_friction);
+		SET_FLOAT_VALUE(n,&rbData->m_collisionObjectData,m_restitution);
+		SET_FLOAT_VALUE(n,&rbData->m_collisionObjectData,m_hitFraction);
+		SET_FLOAT_VALUE(n,&rbData->m_collisionObjectData,m_ccdSweptSphereRadius);
+		SET_FLOAT_VALUE(n,&rbData->m_collisionObjectData,m_ccdMotionThreshold);
+		SET_INT_VALUE(n,&rbData->m_collisionObjectData,m_hasAnisotropicFriction);
+		SET_INT_VALUE(n,&rbData->m_collisionObjectData,m_collisionFlags);
+		SET_INT_VALUE(n,&rbData->m_collisionObjectData,m_islandTag1);
+		SET_INT_VALUE(n,&rbData->m_collisionObjectData,m_companionId);
+		SET_INT_VALUE(n,&rbData->m_collisionObjectData,m_activationState1);
+		SET_INT_VALUE(n,&rbData->m_collisionObjectData,m_internalType);
+		SET_INT_VALUE(n,&rbData->m_collisionObjectData,m_checkCollideWith);
+	}
+
+//	SET_VECTOR4_VALUE(pParent,rbData,m_linearVelocity);
+
+	SET_MATRIX33_VALUE(pParent,rbData,m_invInertiaTensorWorld);
+
+
+	SET_VECTOR4_VALUE(pParent,rbData,m_linearVelocity)
+	SET_VECTOR4_VALUE(pParent,rbData,m_angularVelocity)
+	SET_VECTOR4_VALUE(pParent,rbData,m_angularFactor)
+	SET_VECTOR4_VALUE(pParent,rbData,m_linearFactor)
+	SET_VECTOR4_VALUE(pParent,rbData,m_gravity)
+	SET_VECTOR4_VALUE(pParent,rbData,m_gravity_acceleration )
+	SET_VECTOR4_VALUE(pParent,rbData,m_invInertiaLocal)
+	SET_VECTOR4_VALUE(pParent,rbData,m_totalTorque)
+	SET_VECTOR4_VALUE(pParent,rbData,m_totalForce)
+	SET_FLOAT_VALUE(pParent,rbData,m_inverseMass);
+	SET_FLOAT_VALUE(pParent,rbData,m_linearDamping);
+	SET_FLOAT_VALUE(pParent,rbData,m_angularDamping);
+	SET_FLOAT_VALUE(pParent,rbData,m_additionalDampingFactor);
+	SET_FLOAT_VALUE(pParent,rbData,m_additionalLinearDampingThresholdSqr);
+	SET_FLOAT_VALUE(pParent,rbData,m_additionalAngularDampingThresholdSqr);
+	SET_FLOAT_VALUE(pParent,rbData,m_additionalAngularDampingFactor);
+	SET_FLOAT_VALUE(pParent,rbData,m_angularSleepingThreshold);
+	SET_FLOAT_VALUE(pParent,rbData,m_linearSleepingThreshold);
+	SET_INT_VALUE(pParent,rbData,m_additionalDamping);
+
+
+	m_rigidBodyData.push_back(rbData);
+	m_pointerLookup.insert((void*)ptr,rbData);
+	
+//	rbData->m_collisionObjectData.m_collisionShape = (void*) (int)atof(txt);
+}
+
+/*
+	TETRAHEDRAL_SHAPE_PROXYTYPE,
+	CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE,
+	,
+	CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE,
+	CUSTOM_POLYHEDRAL_SHAPE_TYPE,
+//implicit convex shapes
+IMPLICIT_CONVEX_SHAPES_START_HERE,
+	SPHERE_SHAPE_PROXYTYPE,
+	MULTI_SPHERE_SHAPE_PROXYTYPE,
+	CAPSULE_SHAPE_PROXYTYPE,
+	CONE_SHAPE_PROXYTYPE,
+	CONVEX_SHAPE_PROXYTYPE,
+	CYLINDER_SHAPE_PROXYTYPE,
+	UNIFORM_SCALING_SHAPE_PROXYTYPE,
+	MINKOWSKI_SUM_SHAPE_PROXYTYPE,
+	MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,
+	BOX_2D_SHAPE_PROXYTYPE,
+	CONVEX_2D_SHAPE_PROXYTYPE,
+	CUSTOM_CONVEX_SHAPE_TYPE,
+//concave shapes
+CONCAVE_SHAPES_START_HERE,
+	//keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
+	TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	///used for demo integration FAST/Swift collision library and Bullet
+	FAST_CONCAVE_MESH_PROXYTYPE,
+	//terrain
+	TERRAIN_SHAPE_PROXYTYPE,
+///Used for GIMPACT Trimesh integration
+	GIMPACT_SHAPE_PROXYTYPE,
+///Multimaterial mesh
+    MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE,
+	
+	,
+	,
+	CUSTOM_CONCAVE_SHAPE_TYPE,
+CONCAVE_SHAPES_END_HERE,
+
+	,
+
+	SOFTBODY_SHAPE_PROXYTYPE,
+	HFFLUID_SHAPE_PROXYTYPE,
+	HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
+	INVALID_SHAPE_PROXYTYPE,
+
+	MAX_BROADPHASE_COLLISION_TYPES
+*/
+
+void	btBulletXmlWorldImporter::fixupConstraintData(btTypedConstraintData2* tcd)
+{
+	if (tcd->m_rbA)
+	{
+		btRigidBodyData** ptrptr = (btRigidBodyData**)m_pointerLookup.find(tcd->m_rbA);
+		btAssert(ptrptr);
+		tcd->m_rbA = ptrptr? *ptrptr : 0;
+	}
+	if (tcd->m_rbB)
+	{
+		btRigidBodyData** ptrptr = (btRigidBodyData**)m_pointerLookup.find(tcd->m_rbB);
+		btAssert(ptrptr);
+		tcd->m_rbB = ptrptr? *ptrptr : 0;
+	}
+		
+}
+
+void	btBulletXmlWorldImporter::fixupCollisionDataPointers(btCollisionShapeData* shapeData)
+{
+
+		switch (shapeData->m_shapeType)
+		{
+
+		case COMPOUND_SHAPE_PROXYTYPE:
+			{
+				btCompoundShapeData* compound = (btCompoundShapeData*) shapeData;
+				
+				void** cdptr = m_pointerLookup.find((void*)compound->m_childShapePtr);
+				btCompoundShapeChildData** c = (btCompoundShapeChildData**)cdptr;
+				btAssert(c);
+				if (c)
+				{
+					compound->m_childShapePtr = *c;
+				} else
+				{
+					compound->m_childShapePtr = 0;
+				}
+				break;
+			}
+
+		case CONVEX_HULL_SHAPE_PROXYTYPE:
+			{
+				btConvexHullShapeData* convexData = (btConvexHullShapeData*)shapeData;
+				btVector3FloatData** ptrptr = (btVector3FloatData**)m_pointerLookup.find((void*)convexData->m_unscaledPointsFloatPtr);
+				btAssert(ptrptr);
+				if (ptrptr)
+				{
+					convexData->m_unscaledPointsFloatPtr = *ptrptr;
+				} else
+				{
+					convexData->m_unscaledPointsFloatPtr = 0;
+				}
+				break;
+			}
+
+		case BOX_SHAPE_PROXYTYPE:
+		case TRIANGLE_SHAPE_PROXYTYPE:
+		case STATIC_PLANE_PROXYTYPE:
+		case EMPTY_SHAPE_PROXYTYPE:
+			break;
+
+		default:
+			{
+				btAssert(0);
+			}
+		}
+}
+
+
+void btBulletXmlWorldImporter::auto_serialize_root_level_children(TiXmlNode* pParent)
+{
+	int numChildren = 0;
+	btAssert(pParent);
+	if (pParent)
+	{
+		TiXmlNode*pChild; 
+		for ( pChild = pParent->FirstChild(); pChild != 0; pChild = pChild->NextSibling(), numChildren++) 
+		{
+//			printf("child Name=%s\n", pChild->Value());
+			if (!strcmp(pChild->Value(),"btVector3FloatData"))
+			{
+				int ptr;
+				get_int_attribute_by_name(pChild->ToElement(),"pointer",&ptr);
+				
+				btAlignedObjectArray<btVector3FloatData> v;
+				deSerializeVector3FloatData(pChild,v);
+				int numVectors = v.size();
+				btVector3FloatData* vectors= (btVector3FloatData*) btAlignedAlloc(sizeof(btVector3FloatData)*numVectors,16);
+				for (int i=0;i<numVectors;i++)
+					vectors[i] = v[i];
+				m_floatVertexArrays.push_back(vectors);
+				m_pointerLookup.insert((void*)ptr,vectors);
+				continue;
+			}
+
+			if (!strcmp(pChild->Value(),"btGeneric6DofConstraintData"))
+			{
+				deSerializeGeneric6DofConstraintData(pChild);
+				continue;
+			}
+
+			if (!strcmp(pChild->Value(),"btStaticPlaneShapeData"))
+			{
+				deSerializeStaticPlaneShapeData(pChild);
+				continue;
+			}
+
+			if (!strcmp(pChild->Value(),"btCompoundShapeData"))
+			{
+				deSerializeCompoundShapeData(pChild);
+				continue;
+			}
+
+			if (!strcmp(pChild->Value(),"btCompoundShapeChildData"))
+			{
+				deSerializeCompoundShapeChildData(pChild);
+				continue;
+			}
+
+			if (!strcmp(pChild->Value(),"btConvexHullShapeData"))
+			{
+				deSerializeConvexHullShapeData(pChild);
+				continue;
+			}
+
+			if (!strcmp(pChild->Value(),"btDynamicsWorldFloatData"))
+			{
+				deSerializeDynamicsWorldData(pChild);
+				continue;
+			}
+			
+
+			if (!strcmp(pChild->Value(),"btConvexInternalShapeData"))
+			{
+				deSerializeConvexInternalShapeData(pChild);
+				continue;
+			}
+			if (!strcmp(pChild->Value(),"btRigidBodyFloatData"))
+			{
+				deSerializeRigidBodyFloatData(pChild);
+				continue;
+			}
+
+			//printf("Error: btBulletXmlWorldImporter doesn't support %s yet\n", pChild->Value());
+		//	btAssert(0);
+		}
+	} 
+
+	///=================================================================
+	///fixup pointers in various places, in the right order
+
+	//fixup compoundshape child data
+	for (int i=0;i<m_compoundShapeChildDataArrays.size();i++)
+	{
+		btAlignedObjectArray<btCompoundShapeChildData>* childDataArray = m_compoundShapeChildDataArrays[i];
+		for (int c=0;c<childDataArray->size();c++)
+		{
+			btCompoundShapeChildData* childData = &childDataArray->at(c);
+			btCollisionShapeData** ptrptr = (btCollisionShapeData**)m_pointerLookup[childData->m_childShape];
+			btAssert(ptrptr);
+			if (ptrptr)
+			{
+				childData->m_childShape = *ptrptr;
+			}
+		}
+	}
+
+	for (int i=0;i<this->m_collisionShapeData.size();i++)
+	{
+		btCollisionShapeData* shapeData = m_collisionShapeData[i];
+		fixupCollisionDataPointers(shapeData);
+		
+	}
+	
+	///now fixup pointers
+	for (int i=0;i<m_rigidBodyData.size();i++)
+	{
+		btRigidBodyData* rbData = m_rigidBodyData[i];
+		
+		void** ptrptr = m_pointerLookup.find(rbData->m_collisionObjectData.m_collisionShape);
+		//btAssert(ptrptr);
+		rbData->m_collisionObjectData.m_broadphaseHandle = 0;
+		rbData->m_collisionObjectData.m_rootCollisionShape = 0;
+		rbData->m_collisionObjectData.m_name = 0;//tbd
+		if (ptrptr)
+		{
+			rbData->m_collisionObjectData.m_collisionShape = *ptrptr;
+		}
+	}
+
+	
+
+	for (int i=0;i<m_constraintData.size();i++)
+	{
+		btTypedConstraintData2* tcd = m_constraintData[i];
+		fixupConstraintData(tcd);
+		
+	}
+	///=================================================================
+	///convert data into Bullet data in the right order
+
+	///convert collision shapes
+	for (int i=0;i<this->m_collisionShapeData.size();i++)
+	{
+		btCollisionShapeData* shapeData = m_collisionShapeData[i];
+		btCollisionShape* shape = convertCollisionShape(shapeData);
+		if (shape)
+		{
+			m_shapeMap.insert(shapeData,shape);
+		}
+		if (shape&& shapeData->m_name)
+		{
+			char* newname = duplicateName(shapeData->m_name);
+			m_objectNameMap.insert(shape,newname);
+			m_nameShapeMap.insert(newname,shape);
+		}
+	}
+
+	for (int i=0;i<m_rigidBodyData.size();i++)
+	{
+#ifdef BT_USE_DOUBLE_PRECISION
+		convertRigidBodyDouble(m_rigidBodyData[i]);
+#else
+		convertRigidBodyFloat(m_rigidBodyData[i]);
+#endif
+	}
+
+	for (int i=0;i<m_constraintData.size();i++)
+	{
+		btTypedConstraintData2* tcd = m_constraintData[i];
+		bool isDoublePrecision = false;
+		btRigidBody* rbA = 0;
+		btRigidBody* rbB = 0;
+		{
+			btCollisionObject** ptrptr = m_bodyMap.find(tcd->m_rbA);
+			if (ptrptr)
+			{
+				rbA = btRigidBody::upcast(*ptrptr);
+			}
+		}
+		{
+			btCollisionObject** ptrptr = m_bodyMap.find(tcd->m_rbB);
+			if (ptrptr)
+			{
+				rbB = btRigidBody::upcast(*ptrptr);
+			}
+		}
+		if (rbA || rbB)
+		{
+			btAssert(0);//todo
+			//convertConstraint(tcd,rbA,rbB,isDoublePrecision, m_fileVersion);
+		}
+
+	}
+}
+
+void btBulletXmlWorldImporter::auto_serialize(TiXmlNode* pParent)
+{
+//	TiXmlElement* root = pParent->FirstChildElement("bullet_physics");
+	if (pParent)
+	{
+		TiXmlNode*pChild; 
+		for ( pChild = pParent->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) 
+		{
+			if (pChild->Type()==TiXmlNode::TINYXML_ELEMENT)
+			{
+//				printf("root Name=%s\n", pChild->Value());
+				auto_serialize_root_level_children(pChild);
+			}
+		}
+	} else
+	{
+		printf("ERROR: no bullet_physics element\n");
+	}
+}
+
+
+
+
+bool btBulletXmlWorldImporter::loadFile(const char* fileName)
+{
+	TiXmlDocument doc(fileName);
+
+	bool loadOkay = doc.LoadFile();
+	//dump_to_stdout(&doc,0);
+	
+
+	if (loadOkay)
+	{
+		if (get_int_attribute_by_name(doc.FirstChildElement()->ToElement(),"version", &m_fileVersion))
+		{
+			if (m_fileVersion==281)
+			{
+				m_fileOk = true;
+				int itemcount;
+				get_int_attribute_by_name(doc.FirstChildElement()->ToElement(),"itemcount", &itemcount);
+
+				auto_serialize(&doc);
+				return m_fileOk;
+
+			}
+		}
+	}
+	return false;
+}
+
+
+
+

Extras/Serialize/BulletXmlWorldImporter/btBulletXmlWorldImporter.h

@@ -0,0 +1,87 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+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_XML_WORLD_IMPORTER_H
+#define BT_BULLET_XML_WORLD_IMPORTER_H
+
+#include "LinearMath/btScalar.h"
+
+class btDynamicsWorld;
+class TiXmlNode;
+struct btConvexInternalShapeData;
+struct btCollisionShapeData;
+#ifdef BT_USE_DOUBLE_PRECISION
+struct btRigidBodyDoubleData;
+struct btTypedConstraintDoubleData;
+#define btRigidBodyData btRigidBodyDoubleData
+#define btTypedConstraintData2 btTypedConstraintDoubleData
+#else
+struct btRigidBodyFloatData;
+struct btTypedConstraintFloatData;
+#define btTypedConstraintData2 btTypedConstraintFloatData
+#define btRigidBodyData btRigidBodyFloatData
+#endif//BT_USE_DOUBLE_PRECISION
+
+
+struct btCompoundShapeChildData;
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btWorldImporter.h"
+
+class btBulletXmlWorldImporter : public btWorldImporter
+{
+
+protected:
+	btAlignedObjectArray<btCollisionShapeData*>			m_collisionShapeData;
+	btAlignedObjectArray<btAlignedObjectArray<btCompoundShapeChildData>* >		m_compoundShapeChildDataArrays;
+	btAlignedObjectArray<btRigidBodyData*>				m_rigidBodyData;
+	btAlignedObjectArray<btTypedConstraintData2*>		m_constraintData;
+	btHashMap<btHashPtr,void*>							m_pointerLookup;
+	int													m_fileVersion;
+	bool												m_fileOk;
+
+	void auto_serialize_root_level_children(TiXmlNode* pParent);
+	void auto_serialize(TiXmlNode* pParent);
+
+	void deSerializeVector3FloatData(TiXmlNode* pParent,btAlignedObjectArray<btVector3FloatData>& vectors);
+
+	void	fixupCollisionDataPointers(btCollisionShapeData* shapeData);
+	void	fixupConstraintData(btTypedConstraintData2* tcd);
+
+	//collision shapes data
+	void deSerializeCollisionShapeData(TiXmlNode* pParent,btCollisionShapeData* colShapeData);
+	void deSerializeConvexInternalShapeData(TiXmlNode* pParent);
+	void deSerializeStaticPlaneShapeData(TiXmlNode* pParent);
+	void deSerializeCompoundShapeData(TiXmlNode* pParent);
+	void deSerializeCompoundShapeChildData(TiXmlNode* pParent);
+	void deSerializeConvexHullShapeData(TiXmlNode* pParent);
+	void deSerializeDynamicsWorldData(TiXmlNode* parent);
+	
+	///bodies
+	void deSerializeRigidBodyFloatData(TiXmlNode* pParent);
+
+	///constraints
+	void deSerializeGeneric6DofConstraintData(TiXmlNode* pParent);
+
+	public:
+		btBulletXmlWorldImporter(btDynamicsWorld* world);
+
+		virtual ~btBulletXmlWorldImporter();
+		
+		bool loadFile(const char* fileName);
+
+};
+
+#endif //BT_BULLET_XML_WORLD_IMPORTER_H

Extras/Serialize/BulletXmlWorldImporter/premake4.lua

@@ -0,0 +1,14 @@
+	project "BulletXmlWorldImporter"
+		
+	kind "StaticLib"
+	targetdir "../../lib"
+	includedirs {
+		"../BulletWorldImporter",
+		"../BulletFileLoader",
+		"../../../src"
+	}
+	 
+	files {
+		"**.cpp",
+		"**.h"
+	}

Extras/Serialize/BulletXmlWorldImporter/string_split.cpp

@@ -0,0 +1,250 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+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 <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "string_split.h"
+
+///todo: remove stl dependency
+
+namespace bullet_utils
+{
+    void split( btAlignedObjectArray<std::string>&pieces, const std::string& vector_str, const std::string& separator)
+	{
+		char** strArray = str_split(vector_str.c_str(),separator.c_str());
+		int numSubStr = str_array_len(strArray);
+		for (int i=0;i<numSubStr;i++)
+			pieces.push_back(std::string(strArray[i]));
+		str_array_free(strArray);
+	}
+
+};
+
+
+
+/* Append an item to a dynamically allocated array of strings. On failure,
+ return NULL, in which case the original array is intact. The item
+ string is dynamically copied. If the array is NULL, allocate a new
+ array. Otherwise, extend the array. Make sure the array is always
+ NULL-terminated. Input string might not be '\0'-terminated. */
+char **str_array_append(char **array, size_t nitems, const char *item,
+                        size_t itemlen)
+{
+    /* Make a dynamic copy of the item. */
+    char *copy;
+    if (item == NULL)
+        copy = NULL;
+    else {
+        copy = (char*)malloc(itemlen + 1);
+        if (copy == NULL)
+            return NULL;
+        memcpy(copy, item, itemlen);
+        copy[itemlen] = '\0';
+    }
+	
+    /* Extend array with one element. Except extend it by two elements,
+	 in case it did not yet exist. This might mean it is a teeny bit
+	 too big, but we don't care. */
+    array = (char**)realloc(array, (nitems + 2) * sizeof(array[0]));
+    if (array == NULL) {
+        free(copy);
+        return NULL;
+    }
+	
+    /* Add copy of item to array, and return it. */
+    array[nitems] = copy;
+    array[nitems+1] = NULL;
+    return array;
+}
+
+
+/* Free a dynamic array of dynamic strings. */
+void str_array_free(char **array)
+{
+    if (array == NULL)
+        return;
+    for (size_t i = 0; array[i] != NULL; ++i)
+        free(array[i]);
+    free(array);
+}
+
+
+/* Split a string into substrings. Return dynamic array of dynamically
+ allocated substrings, or NULL if there was an error. Caller is
+ expected to free the memory, for example with str_array_free. */
+char **str_split(const char *input, const char *sep)
+{
+    size_t nitems = 0;
+    char **array = NULL;
+    const char *start = input;
+    const char *next = strstr(start, sep);
+    size_t seplen = strlen(sep);
+    const char *item;
+    size_t itemlen;
+	
+    for (;;) {
+        next = strstr(start, sep);
+        if (next == NULL) {
+            /* Add the remaining string (or empty string, if input ends with
+			 separator. */
+            char **newstr = str_array_append(array, nitems, start, strlen(start));
+            if (newstr == NULL) {
+                str_array_free(array);
+                return NULL;
+            }
+            array = newstr;
+            ++nitems;
+            break;
+        } else if (next == input) {
+            /* Input starts with separator. */
+            item = "";
+            itemlen = 0;
+        } else {
+            item = start;
+            itemlen = next - item;
+        }
+        char **newstr = str_array_append(array, nitems, item, itemlen);
+        if (newstr == NULL) {
+            str_array_free(array);
+            return NULL;
+        }
+        array = newstr;
+        ++nitems;
+        start = next + seplen;
+    }
+	
+    if (nitems == 0) {
+        /* Input does not contain separator at all. */
+        assert(array == NULL);
+        array = str_array_append(array, nitems, input, strlen(input));
+    }
+	
+    return array;
+}
+
+
+/* Return length of a NULL-delimited array of strings. */
+size_t str_array_len(char **array)
+{
+    size_t len;
+	
+    for (len = 0; array[len] != NULL; ++len)
+        continue;
+    return len;
+}
+
+#ifdef UNIT_TEST_STRING
+
+#define MAX_OUTPUT 20
+
+
+int main(void)
+{
+    struct {
+        const char *input;
+        const char *sep;
+        char *output[MAX_OUTPUT];
+    } tab[] = {
+        /* Input is empty string. Output should be a list with an empty
+		 string. */
+        {
+            "",
+            "and",
+            {
+                "",
+                NULL,
+            },
+        },
+        /* Input is exactly the separator. Output should be two empty
+		 strings. */
+        {
+            "and",
+            "and",
+            {
+                "",
+                "",
+                NULL,
+            },
+        },
+        /* Input is non-empty, but does not have separator. Output should
+		 be the same string. */
+        {
+            "foo",
+            "and",
+            {
+                "foo",
+                NULL,
+            },
+        },
+        /* Input is non-empty, and does have separator. */
+        {
+            "foo bar 1 and foo bar 2",
+            " and ",
+            {
+                "foo bar 1",
+                "foo bar 2",
+                NULL,
+            },
+        },
+    };
+    const int tab_len = sizeof(tab) / sizeof(tab[0]);
+    bool errors;
+	
+    errors = false;
+	
+    for (int i = 0; i < tab_len; ++i) {
+        printf("test %d\n", i);
+		
+        char **output = str_split(tab[i].input, tab[i].sep);
+        if (output == NULL) {
+            fprintf(stderr, "output is NULL\n");
+            errors = true;
+            break;
+        }
+        size_t num_output = str_array_len(output);
+        printf("num_output %lu\n", (unsigned long) num_output);
+		
+        size_t num_correct = str_array_len(tab[i].output);
+        if (num_output != num_correct) {
+            fprintf(stderr, "wrong number of outputs (%lu, not %lu)\n",
+                    (unsigned long) num_output, (unsigned long) num_correct);
+            errors = true;
+        } else {
+            for (size_t j = 0; j < num_output; ++j) {
+                if (strcmp(tab[i].output[j], output[j]) != 0) {
+                    fprintf(stderr, "output[%lu] is '%s' not '%s'\n",
+                            (unsigned long) j, output[j], tab[i].output[j]);
+                    errors = true;
+                    break;
+                }
+            }
+        }
+		
+        str_array_free(output);
+        printf("\n");
+    }
+	
+    if (errors)
+        return EXIT_FAILURE;
+    return 0;
+}
+
+#endif//
+
+

Extras/Serialize/BulletXmlWorldImporter/string_split.h

@@ -0,0 +1,49 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2012 Erwin Coumans  http://bulletphysics.org
+
+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.
+*/
+
+///The string split C code is by Lars Wirzenius
+///See http://stackoverflow.com/questions/2531605/how-to-split-a-string-with-a-delimiter-larger-than-one-single-char
+
+
+#ifndef STRING_SPLIT_H
+#define STRING_SPLIT_H
+
+#include <cstring>
+#include "LinearMath/btAlignedObjectArray.h"
+
+#include <string>
+
+namespace bullet_utils
+{
+	void split( btAlignedObjectArray<std::string>&pieces, const std::string& vector_str, const std::string& separator);
+};
+
+///The string split C code is by Lars Wirzenius
+///See http://stackoverflow.com/questions/2531605/how-to-split-a-string-with-a-delimiter-larger-than-one-single-char
+
+
+/* Split a string into substrings. Return dynamic array of dynamically
+ allocated substrings, or NULL if there was an error. Caller is
+ expected to free the memory, for example with str_array_free. */
+char**	str_split(const char* input, const char* sep);
+
+/* Free a dynamic array of dynamic strings. */
+void str_array_free(char** array);
+
+/* Return length of a NULL-delimited array of strings. */
+size_t str_array_len(char** array);
+
+#endif //STRING_SPLIT_H
+

Extras/Serialize/BulletXmlWorldImporter/tinystr.cpp

@@ -0,0 +1,111 @@
+/*
+www.sourceforge.net/projects/tinyxml
+
+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 TIXML_USE_STL
+
+#include "tinystr.h"
+
+// Error value for find primitive
+const TiXmlString::size_type TiXmlString::npos = static_cast< TiXmlString::size_type >(-1);
+
+
+// Null rep.
+TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
+
+
+void TiXmlString::reserve (size_type cap)
+{
+	if (cap > capacity())
+	{
+		TiXmlString tmp;
+		tmp.init(length(), cap);
+		memcpy(tmp.start(), data(), length());
+		swap(tmp);
+	}
+}
+
+
+TiXmlString& TiXmlString::assign(const char* str, size_type len)
+{
+	size_type cap = capacity();
+	if (len > cap || cap > 3*(len + 8))
+	{
+		TiXmlString tmp;
+		tmp.init(len);
+		memcpy(tmp.start(), str, len);
+		swap(tmp);
+	}
+	else
+	{
+		memmove(start(), str, len);
+		set_size(len);
+	}
+	return *this;
+}
+
+
+TiXmlString& TiXmlString::append(const char* str, size_type len)
+{
+	size_type newsize = length() + len;
+	if (newsize > capacity())
+	{
+		reserve (newsize + capacity());
+	}
+	memmove(finish(), str, len);
+	set_size(newsize);
+	return *this;
+}
+
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
+{
+	TiXmlString tmp;
+	tmp.reserve(a.length() + b.length());
+	tmp += a;
+	tmp += b;
+	return tmp;
+}
+
+TiXmlString operator + (const TiXmlString & a, const char* b)
+{
+	TiXmlString tmp;
+	TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
+	tmp.reserve(a.length() + b_len);
+	tmp += a;
+	tmp.append(b, b_len);
+	return tmp;
+}
+
+TiXmlString operator + (const char* a, const TiXmlString & b)
+{
+	TiXmlString tmp;
+	TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
+	tmp.reserve(a_len + b.length());
+	tmp.append(a, a_len);
+	tmp += b;
+	return tmp;
+}
+
+
+#endif	// TIXML_USE_STL

Extras/Serialize/BulletXmlWorldImporter/tinystr.h

@@ -0,0 +1,305 @@
+/*
+www.sourceforge.net/projects/tinyxml
+
+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 TIXML_USE_STL
+
+#ifndef TIXML_STRING_INCLUDED
+#define TIXML_STRING_INCLUDED
+
+#include <assert.h>
+#include <string.h>
+
+/*	The support for explicit isn't that universal, and it isn't really
+	required - it is used to check that the TiXmlString class isn't incorrectly
+	used. Be nice to old compilers and macro it here:
+*/
+#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
+	// Microsoft visual studio, version 6 and higher.
+	#define TIXML_EXPLICIT explicit
+#elif defined(__GNUC__) && (__GNUC__ >= 3 )
+	// GCC version 3 and higher.s
+	#define TIXML_EXPLICIT explicit
+#else
+	#define TIXML_EXPLICIT
+#endif
+
+
+/*
+   TiXmlString is an emulation of a subset of the std::string template.
+   Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
+   Only the member functions relevant to the TinyXML project have been implemented.
+   The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
+   a string and there's no more room, we allocate a buffer twice as big as we need.
+*/
+class TiXmlString
+{
+  public :
+	// The size type used
+  	typedef size_t size_type;
+
+	// Error value for find primitive
+	static const size_type npos; // = -1;
+
+
+	// TiXmlString empty constructor
+	TiXmlString () : rep_(&nullrep_)
+	{
+	}
+
+	// TiXmlString copy constructor
+	TiXmlString ( const TiXmlString & copy) : rep_(0)
+	{
+		init(copy.length());
+		memcpy(start(), copy.data(), length());
+	}
+
+	// TiXmlString constructor, based on a string
+	TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
+	{
+		init( static_cast<size_type>( strlen(copy) ));
+		memcpy(start(), copy, length());
+	}
+
+	// TiXmlString constructor, based on a string
+	TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
+	{
+		init(len);
+		memcpy(start(), str, len);
+	}
+
+	// TiXmlString destructor
+	~TiXmlString ()
+	{
+		quit();
+	}
+
+	TiXmlString& operator = (const char * copy)
+	{
+		return assign( copy, (size_type)strlen(copy));
+	}
+
+	TiXmlString& operator = (const TiXmlString & copy)
+	{
+		return assign(copy.start(), copy.length());
+	}
+
+
+	// += operator. Maps to append
+	TiXmlString& operator += (const char * suffix)
+	{
+		return append(suffix, static_cast<size_type>( strlen(suffix) ));
+	}
+
+	// += operator. Maps to append
+	TiXmlString& operator += (char single)
+	{
+		return append(&single, 1);
+	}
+
+	// += operator. Maps to append
+	TiXmlString& operator += (const TiXmlString & suffix)
+	{
+		return append(suffix.data(), suffix.length());
+	}
+
+
+	// Convert a TiXmlString into a null-terminated char *
+	const char * c_str () const { return rep_->str; }
+
+	// Convert a TiXmlString into a char * (need not be null terminated).
+	const char * data () const { return rep_->str; }
+
+	// Return the length of a TiXmlString
+	size_type length () const { return rep_->size; }
+
+	// Alias for length()
+	size_type size () const { return rep_->size; }
+
+	// Checks if a TiXmlString is empty
+	bool empty () const { return rep_->size == 0; }
+
+	// Return capacity of string
+	size_type capacity () const { return rep_->capacity; }
+
+
+	// single char extraction
+	const char& at (size_type index) const
+	{
+		assert( index < length() );
+		return rep_->str[ index ];
+	}
+
+	// [] operator
+	char& operator [] (size_type index) const
+	{
+		assert( index < length() );
+		return rep_->str[ index ];
+	}
+
+	// find a char in a string. Return TiXmlString::npos if not found
+	size_type find (char lookup) const
+	{
+		return find(lookup, 0);
+	}
+
+	// find a char in a string from an offset. Return TiXmlString::npos if not found
+	size_type find (char tofind, size_type offset) const
+	{
+		if (offset >= length()) return npos;
+
+		for (const char* p = c_str() + offset; *p != '\0'; ++p)
+		{
+		   if (*p == tofind) return static_cast< size_type >( p - c_str() );
+		}
+		return npos;
+	}
+
+	void clear ()
+	{
+		//Lee:
+		//The original was just too strange, though correct:
+		//	TiXmlString().swap(*this);
+		//Instead use the quit & re-init:
+		quit();
+		init(0,0);
+	}
+
+	/*	Function to reserve a big amount of data when we know we'll need it. Be aware that this
+		function DOES NOT clear the content of the TiXmlString if any exists.
+	*/
+	void reserve (size_type cap);
+
+	TiXmlString& assign (const char* str, size_type len);
+
+	TiXmlString& append (const char* str, size_type len);
+
+	void swap (TiXmlString& other)
+	{
+		Rep* r = rep_;
+		rep_ = other.rep_;
+		other.rep_ = r;
+	}
+
+  private:
+
+	void init(size_type sz) { init(sz, sz); }
+	void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
+	char* start() const { return rep_->str; }
+	char* finish() const { return rep_->str + rep_->size; }
+
+	struct Rep
+	{
+		size_type size, capacity;
+		char str[1];
+	};
+
+	void init(size_type sz, size_type cap)
+	{
+		if (cap)
+		{
+			// Lee: the original form:
+			//	rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
+			// doesn't work in some cases of new being overloaded. Switching
+			// to the normal allocation, although use an 'int' for systems
+			// that are overly picky about structure alignment.
+			const size_type bytesNeeded = sizeof(Rep) + cap;
+			const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
+			rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
+
+			rep_->str[ rep_->size = sz ] = '\0';
+			rep_->capacity = cap;
+		}
+		else
+		{
+			rep_ = &nullrep_;
+		}
+	}
+
+	void quit()
+	{
+		if (rep_ != &nullrep_)
+		{
+			// The rep_ is really an array of ints. (see the allocator, above).
+			// Cast it back before delete, so the compiler won't incorrectly call destructors.
+			delete [] ( reinterpret_cast<int*>( rep_ ) );
+		}
+	}
+
+	Rep * rep_;
+	static Rep nullrep_;
+
+} ;
+
+
+inline bool operator == (const TiXmlString & a, const TiXmlString & b)
+{
+	return    ( a.length() == b.length() )				// optimization on some platforms
+	       && ( strcmp(a.c_str(), b.c_str()) == 0 );	// actual compare
+}
+inline bool operator < (const TiXmlString & a, const TiXmlString & b)
+{
+	return strcmp(a.c_str(), b.c_str()) < 0;
+}
+
+inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
+inline bool operator >  (const TiXmlString & a, const TiXmlString & b) { return b < a; }
+inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); }
+inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); }
+
+inline bool operator == (const TiXmlString & a, const char* b) { return strcmp(a.c_str(), b) == 0; }
+inline bool operator == (const char* a, const TiXmlString & b) { return b == a; }
+inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); }
+inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); }
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
+TiXmlString operator + (const TiXmlString & a, const char* b);
+TiXmlString operator + (const char* a, const TiXmlString & b);
+
+
+/*
+   TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
+   Only the operators that we need for TinyXML have been developped.
+*/
+class TiXmlOutStream : public TiXmlString
+{
+public :
+
+	// TiXmlOutStream << operator.
+	TiXmlOutStream & operator << (const TiXmlString & in)
+	{
+		*this += in;
+		return *this;
+	}
+
+	// TiXmlOutStream << operator.
+	TiXmlOutStream & operator << (const char * in)
+	{
+		*this += in;
+		return *this;
+	}
+
+} ;
+
+#endif	// TIXML_STRING_INCLUDED
+#endif	// TIXML_USE_STL

Extras/Serialize/BulletXmlWorldImporter/tinyxmlerror.cpp

@@ -0,0 +1,52 @@
+/*
+www.sourceforge.net/projects/tinyxml
+Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.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 "tinyxml.h"
+
+// The goal of the seperate error file is to make the first
+// step towards localization. tinyxml (currently) only supports
+// english error messages, but the could now be translated.
+//
+// It also cleans up the code a bit.
+//
+
+const char* TiXmlBase::errorString[ TiXmlBase::TIXML_ERROR_STRING_COUNT ] =
+{
+	"No error",
+	"Error",
+	"Failed to open file",
+	"Error parsing Element.",
+	"Failed to read Element name",
+	"Error reading Element value.",
+	"Error reading Attributes.",
+	"Error: empty tag.",
+	"Error reading end tag.",
+	"Error parsing Unknown.",
+	"Error parsing Comment.",
+	"Error parsing Declaration.",
+	"Error document empty.",
+	"Error null (0) or unexpected EOF found in input stream.",
+	"Error parsing CDATA.",
+	"Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.",
+};

Extras/Serialize/CMakeLists.txt

@@ -0,0 +1,20 @@
+
+IF (BUILD_BLEND_DEMO OR INTERNAL_UPDATE_SERIALIZATION_STRUCTURES)
+	SUBDIRS(BlenderSerialize )
+ENDIF()
+
+
+IF(INTERNAL_UPDATE_SERIALIZATION_STRUCTURES)
+
+# 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 BulletXmlWorldImporter BulletWorldImporter HeaderGenerator makesdna)
+
+ELSE(INTERNAL_UPDATE_SERIALIZATION_STRUCTURES)
+
+	SUBDIRS ( BulletFileLoader BulletXmlWorldImporter BulletWorldImporter )
+
+ENDIF (INTERNAL_UPDATE_SERIALIZATION_STRUCTURES)
+

Extras/Serialize/HeaderGenerator/CMakeLists.txt

@@ -0,0 +1,32 @@
+###############################################################################
+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})
+
+IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
+	ADD_CUSTOM_COMMAND(
+		TARGET HeaderGenerator 
+		POST_BUILD
+		COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/HeaderGenerator/createDnaString.bat ${CMAKE_CURRENT_BINARY_DIR}/createDnaString.bat
+		COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${BULLET_PHYSICS_SOURCE_DIR}/Extras/Serialize/HeaderGenerator/bulletGenerate.py ${CMAKE_CURRENT_BINARY_DIR}/bulletGenerate.py
+	)
+ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)

Extras/Serialize/HeaderGenerator/apiGen.cpp

@@ -0,0 +1,464 @@
+/* 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>
+#include <string.h>
+
+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)!=0;
+	} else
+	{
+		bBlenderFile	f(memBuf,len);
+		swap = (f.getFlags() & FD_ENDIAN_SWAP)!=0;
+	}
+
+	
+	
+
+
+	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,83 @@
+import dump
+
+
+header = """/* Copyright (C) 2011 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 Bullet/Extras/HeaderGenerator/bulletGenerate.py
+"""
+
+dtList = dump.DataTypeList
+
+out = "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("struct %s;\n"%dt.filename)
+
+
+###################################################################################
+
+blender.write("namespace Bullet {\n")
+
+strUnRes = """
+// put an empty struct in the case
+typedef struct bInvalidHandle {
+	int unused;
+}bInvalidHandle;
+
+"""
+blender.write(strUnRes)
+
+for dt in dtList:
+	write(blender, 4, "class %s;\n"%dt.name)
+
+
+for dt in dtList:
+		
+	strUpper = dt.filename.upper()
+	
+	blender.write("// -------------------------------------------------- //\n")
+
+	write(blender, 4, "class %s\n"%dt.name)
+
+	write(blender, 4, "{\n")
+	write(blender, 4, "public:\n")
+	for i in dt.dataTypes:
+		write(blender, 8, i+";\n")
+
+	write(blender, 4, "};\n")
+	
+	blender.write("\n\n")
+	
+blender.write("}\n")
+blender.write("#endif//__BULLET_H__")
+blender.close()

Extras/Serialize/HeaderGenerator/createDnaString.bat

@@ -0,0 +1,7 @@
+delete dnaString.txt
+
+mkdir autogenerated
+
+Debug\HeaderGenerator.exe
+
+python bulletGenerate.py

Extras/Serialize/ReadBulletSample/BulletDataExtractor.cpp

@@ -0,0 +1,345 @@
+
+#include "BulletDataExtractor.h"
+#include "../BulletFileLoader/btBulletFile.h"
+
+#include <stdio.h>
+
+///work-in-progress 
+///This ReadBulletSample is kept as simple as possible without dependencies to the Bullet SDK.
+///It can be used to load .bullet data for other physics SDKs
+///For a more complete example how to load and convert Bullet data using the Bullet SDK check out
+///the Bullet/Demos/SerializeDemo and Bullet/Serialize/BulletWorldImporter
+
+using namespace Bullet;
+
+enum LocalBroadphaseNativeTypes
+{
+	// polyhedral convex shapes
+	BOX_SHAPE_PROXYTYPE,
+	TRIANGLE_SHAPE_PROXYTYPE,
+	TETRAHEDRAL_SHAPE_PROXYTYPE,
+	CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE,
+	CONVEX_HULL_SHAPE_PROXYTYPE,
+	CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE,
+	CUSTOM_POLYHEDRAL_SHAPE_TYPE,
+//implicit convex shapes
+IMPLICIT_CONVEX_SHAPES_START_HERE,
+	SPHERE_SHAPE_PROXYTYPE,
+	MULTI_SPHERE_SHAPE_PROXYTYPE,
+	CAPSULE_SHAPE_PROXYTYPE,
+	CONE_SHAPE_PROXYTYPE,
+	CONVEX_SHAPE_PROXYTYPE,
+	CYLINDER_SHAPE_PROXYTYPE,
+	UNIFORM_SCALING_SHAPE_PROXYTYPE,
+	MINKOWSKI_SUM_SHAPE_PROXYTYPE,
+	MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,
+	BOX_2D_SHAPE_PROXYTYPE,
+	CONVEX_2D_SHAPE_PROXYTYPE,
+	CUSTOM_CONVEX_SHAPE_TYPE,
+//concave shapes
+CONCAVE_SHAPES_START_HERE,
+	//keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
+	TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	///used for demo integration FAST/Swift collision library and Bullet
+	FAST_CONCAVE_MESH_PROXYTYPE,
+	//terrain
+	TERRAIN_SHAPE_PROXYTYPE,
+///Used for GIMPACT Trimesh integration
+	GIMPACT_SHAPE_PROXYTYPE,
+///Multimaterial mesh
+    MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE,
+	
+	EMPTY_SHAPE_PROXYTYPE,
+	STATIC_PLANE_PROXYTYPE,
+	CUSTOM_CONCAVE_SHAPE_TYPE,
+CONCAVE_SHAPES_END_HERE,
+
+	COMPOUND_SHAPE_PROXYTYPE,
+
+	SOFTBODY_SHAPE_PROXYTYPE,
+	HFFLUID_SHAPE_PROXYTYPE,
+	HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
+	INVALID_SHAPE_PROXYTYPE,
+
+	MAX_BROADPHASE_COLLISION_TYPES
+	
+};
+
+btBulletDataExtractor::btBulletDataExtractor()
+{
+}
+
+btBulletDataExtractor::~btBulletDataExtractor()
+{
+}
+
+void btBulletDataExtractor::convertAllObjects(bParse::btBulletFile* bulletFile2)
+{
+	int i;
+
+	for (i=0;i<bulletFile2->m_collisionShapes.size();i++)
+	{
+		btCollisionShapeData* shapeData = (btCollisionShapeData*)bulletFile2->m_collisionShapes[i];
+		if (shapeData->m_name)
+			printf("converting shape %s\n", shapeData->m_name);
+		void* shape = convertCollisionShape(shapeData);
+	}
+
+}
+
+
+
+void* btBulletDataExtractor::convertCollisionShape(  btCollisionShapeData* shapeData  )
+{
+	void* shape = 0;
+
+	switch (shapeData->m_shapeType)
+		{
+	case STATIC_PLANE_PROXYTYPE:
+		{
+			btStaticPlaneShapeData* planeData = (btStaticPlaneShapeData*)shapeData;
+			void* shape = createPlaneShape(planeData->m_planeNormal,planeData->m_planeConstant, planeData->m_localScaling);
+			break;
+		}
+
+		case CYLINDER_SHAPE_PROXYTYPE:
+		case CAPSULE_SHAPE_PROXYTYPE:
+		case BOX_SHAPE_PROXYTYPE:
+		case SPHERE_SHAPE_PROXYTYPE:
+		case MULTI_SPHERE_SHAPE_PROXYTYPE:
+		case CONVEX_HULL_SHAPE_PROXYTYPE:
+			{
+				btConvexInternalShapeData* bsd = (btConvexInternalShapeData*)shapeData;
+				
+				switch (shapeData->m_shapeType)
+				{
+					case BOX_SHAPE_PROXYTYPE:
+						{
+							shape = createBoxShape(bsd->m_implicitShapeDimensions, bsd->m_localScaling,bsd->m_collisionMargin);
+							break;
+						}
+					case SPHERE_SHAPE_PROXYTYPE:
+						{
+							shape = createSphereShape(bsd->m_implicitShapeDimensions.m_floats[0],bsd->m_localScaling, bsd->m_collisionMargin);
+							break;
+						}
+#if 0
+					case CAPSULE_SHAPE_PROXYTYPE:
+						{
+							btCapsuleShapeData* capData = (btCapsuleShapeData*)shapeData;
+							switch (capData->m_upAxis)
+							{
+							case 0:
+								{
+									shape = createCapsuleShapeX(implicitShapeDimensions.getY(),2*implicitShapeDimensions.getX());
+									break;
+								}
+							case 1:
+								{
+									shape = createCapsuleShapeY(implicitShapeDimensions.getX(),2*implicitShapeDimensions.getY());
+									break;
+								}
+							case 2:
+								{
+									shape = createCapsuleShapeZ(implicitShapeDimensions.getX(),2*implicitShapeDimensions.getZ());
+									break;
+								}
+							default:
+								{
+									printf("error: wrong up axis for btCapsuleShape\n");
+								}
+
+							};
+							
+							break;
+						}
+					case CYLINDER_SHAPE_PROXYTYPE:
+						{
+							btCylinderShapeData* cylData = (btCylinderShapeData*) shapeData;
+							btVector3 halfExtents = implicitShapeDimensions+margin;
+							switch (cylData->m_upAxis)
+							{
+							case 0:
+								{
+									shape = createCylinderShapeX(halfExtents.getY(),halfExtents.getX());
+									break;
+								}
+							case 1:
+								{
+									shape = createCylinderShapeY(halfExtents.getX(),halfExtents.getY());
+									break;
+								}
+							case 2:
+								{
+									shape = createCylinderShapeZ(halfExtents.getX(),halfExtents.getZ());
+									break;
+								}
+							default:
+								{
+									printf("unknown Cylinder up axis\n");
+								}
+
+							};
+							
+
+							
+							break;
+						}
+					case MULTI_SPHERE_SHAPE_PROXYTYPE:
+						{
+							btMultiSphereShapeData* mss = (btMultiSphereShapeData*)bsd;
+							int numSpheres = mss->m_localPositionArraySize;
+							int i;
+							for ( i=0;i<numSpheres;i++)
+							{
+								tmpPos[i].deSerializeFloat(mss->m_localPositionArrayPtr[i].m_pos);
+								radii[i] = mss->m_localPositionArrayPtr[i].m_radius;
+							}
+							shape = new btMultiSphereShape(&tmpPos[0],&radii[0],numSpheres);
+							break;
+						}
+					case CONVEX_HULL_SHAPE_PROXYTYPE:
+						{
+							btConvexHullShapeData* convexData = (btConvexHullShapeData*)bsd;
+							int numPoints = convexData->m_numUnscaledPoints;
+
+							btAlignedObjectArray<btVector3> tmpPoints;
+							tmpPoints.resize(numPoints);
+							int i;
+							for ( i=0;i<numPoints;i++)
+							{
+							if (convexData->m_unscaledPointsFloatPtr)
+								tmpPoints[i].deSerialize(convexData->m_unscaledPointsFloatPtr[i]);
+							if (convexData->m_unscaledPointsDoublePtr)
+								tmpPoints[i].deSerializeDouble(convexData->m_unscaledPointsDoublePtr[i]);
+							}
+							shape = createConvexHullShape();
+
+							return shape;
+							break;
+						}
+#endif
+
+					default:
+						{
+							printf("error: cannot create shape type (%d)\n",shapeData->m_shapeType);
+						}
+				}
+
+				break;
+			}
+#if 0
+		case TRIANGLE_MESH_SHAPE_PROXYTYPE:
+		{
+			btTriangleMeshShapeData* trimesh = (btTriangleMeshShapeData*)shapeData;
+			btTriangleIndexVertexArray* meshInterface = createMeshInterface(trimesh->m_meshInterface);
+			if (!meshInterface->getNumSubParts())
+			{
+				return 0;
+			}
+
+			btVector3 scaling; scaling.deSerializeFloat(trimesh->m_meshInterface.m_scaling);
+			meshInterface->setScaling(scaling);
+
+
+			btOptimizedBvh* bvh = 0;
+
+			btBvhTriangleMeshShape* trimeshShape = createBvhTriangleMeshShape(meshInterface,bvh);
+			trimeshShape->setMargin(trimesh->m_collisionMargin);
+			shape = trimeshShape;
+
+			if (trimesh->m_triangleInfoMap)
+			{
+				btTriangleInfoMap* map = createTriangleInfoMap();
+				map->deSerialize(*trimesh->m_triangleInfoMap);
+				trimeshShape->setTriangleInfoMap(map);
+
+#ifdef USE_INTERNAL_EDGE_UTILITY
+				gContactAddedCallback = btAdjustInternalEdgeContactsCallback;
+#endif //USE_INTERNAL_EDGE_UTILITY
+
+			}
+
+			//printf("trimesh->m_collisionMargin=%f\n",trimesh->m_collisionMargin);
+			break;
+		}
+		case COMPOUND_SHAPE_PROXYTYPE:
+			{
+				btCompoundShapeData* compoundData = (btCompoundShapeData*)shapeData;
+				btCompoundShape* compoundShape = createCompoundShape();
+
+
+				btAlignedObjectArray<btCollisionShape*> childShapes;
+				for (int i=0;i<compoundData->m_numChildShapes;i++)
+				{
+					btCollisionShape* childShape = convertCollisionShape(compoundData->m_childShapePtr[i].m_childShape);
+					if (childShape)
+					{
+						btTransform localTransform;
+						localTransform.deSerializeFloat(compoundData->m_childShapePtr[i].m_transform);
+						compoundShape->addChildShape(localTransform,childShape);
+					} else
+					{
+						printf("error: couldn't create childShape for compoundShape\n");
+					}
+					
+				}
+				shape = compoundShape;
+
+				break;
+			}
+
+			case GIMPACT_SHAPE_PROXYTYPE:
+		{
+			btGImpactMeshShapeData* gimpactData = (btGImpactMeshShapeData*) shapeData;
+			if (gimpactData->m_gimpactSubType == CONST_GIMPACT_TRIMESH_SHAPE)
+			{
+				btTriangleIndexVertexArray* meshInterface = createMeshInterface(gimpactData->m_meshInterface);
+				btGImpactMeshShape* gimpactShape = createGimpactShape(meshInterface);
+				btVector3 localScaling;
+				localScaling.deSerializeFloat(gimpactData->m_localScaling);
+				gimpactShape->setLocalScaling(localScaling);
+				gimpactShape->setMargin(btScalar(gimpactData->m_collisionMargin));
+				gimpactShape->updateBound();
+				shape = gimpactShape;
+			} else
+			{
+				printf("unsupported gimpact sub type\n");
+			}
+			break;
+		}
+		case SOFTBODY_SHAPE_PROXYTYPE:
+			{
+				return 0;
+			}
+#endif 
+		default:
+			{
+				printf("unsupported shape type (%d)\n",shapeData->m_shapeType);
+			}
+		}
+
+		return shape;
+	
+}
+
+void* btBulletDataExtractor::createBoxShape( const Bullet::btVector3FloatData& halfDimensions, const Bullet::btVector3FloatData& localScaling, float collisionMargin)
+{
+	printf("createBoxShape with halfDimensions %f,%f,%f\n",halfDimensions.m_floats[0], halfDimensions.m_floats[1],halfDimensions.m_floats[2]);
+	return 0;
+}
+
+void* btBulletDataExtractor::createSphereShape( float radius, const Bullet::btVector3FloatData& localScaling, float collisionMargin)
+{
+	printf("createSphereShape with radius %f\n",radius);
+	return 0;
+}
+
+
+void* btBulletDataExtractor::createPlaneShape( const btVector3FloatData& planeNormal, float planeConstant, const Bullet::btVector3FloatData& localScaling)
+{
+	printf("createPlaneShape with normal %f,%f,%f and planeConstant\n",planeNormal.m_floats[0], planeNormal.m_floats[1],planeNormal.m_floats[2],planeConstant);
+	return 0;
+}
+

Extras/Serialize/ReadBulletSample/BulletDataExtractor.h

@@ -0,0 +1,32 @@
+#ifndef BULLET_DATA_EXTRACTOR_H
+#define BULLET_DATA_EXTRACTOR_H
+
+
+#include "../BulletFileLoader/autogenerated/bullet.h"
+
+namespace bParse
+{
+	class btBulletFile;
+};
+
+class btBulletDataExtractor
+{
+	public:
+
+	btBulletDataExtractor();
+	
+	virtual ~btBulletDataExtractor();
+	
+	virtual void convertAllObjects(bParse::btBulletFile* bulletFile);
+	
+	virtual void* convertCollisionShape(  Bullet::btCollisionShapeData* shapeData  );
+
+	virtual void* createPlaneShape( const Bullet::btVector3FloatData& planeNormal, float planeConstant, const Bullet::btVector3FloatData& localScaling);
+	
+	virtual void* createBoxShape( const Bullet::btVector3FloatData& halfDimensions, const Bullet::btVector3FloatData& localScaling, float collisionMargin);
+
+	virtual void* createSphereShape( float radius, const Bullet::btVector3FloatData& localScaling, float collisionMargin);
+
+};
+	
+#endif //BULLET_DATA_EXTRACTOR_H

Extras/Serialize/ReadBulletSample/CMakeLists.txt

@@ -0,0 +1,33 @@
+
+INCLUDE_DIRECTORIES(
+${BULLET_PHYSICS_SOURCE_DIR}/src 
+)
+
+LINK_LIBRARIES(
+	BulletFileLoader
+)
+IF (WIN32)
+	SET(ADDITIONAL_SRC
+		${BULLET_PHYSICS_SOURCE_DIR}/build/bullet.rc
+	)
+ENDIF()
+
+SET(READBULLET_SRC
+		main.cpp
+		BulletDataExtractor.cpp
+		BulletDataExtractor.h
+		${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btSerializer.cpp
+		${BULLET_PHYSICS_SOURCE_DIR}/src/LinearMath/btAlignedAllocator.cpp
+)
+
+ADD_EXECUTABLE(AppReadBulletSample
+	${READBULLET_SRC} 
+	${ADDITIONAL_SRC}
+)
+
+
+IF (INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES)
+			SET_TARGET_PROPERTIES(AppReadBulletSample PROPERTIES  DEBUG_POSTFIX "_Debug")
+			SET_TARGET_PROPERTIES(AppReadBulletSample PROPERTIES  MINSIZEREL_POSTFIX "_MinsizeRel")
+			SET_TARGET_PROPERTIES(AppReadBulletSample PROPERTIES  RELWITHDEBINFO_POSTFIX "_RelWithDebugInfo")
+ENDIF(INTERNAL_ADD_POSTFIX_EXECUTABLE_NAMES)

Extras/Serialize/ReadBulletSample/main.cpp

@@ -0,0 +1,63 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2011 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+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 <stdio.h>
+#include "../BulletFileLoader/btBulletFile.h"
+#include "BulletDataExtractor.h"
+
+///This ReadBulletSample is kept as simple as possible without dependencies to the Bullet SDK.
+///It can be used to load .bullet data for other physics SDKs
+///For a more complete example how to load and convert Bullet data using the Bullet SDK check out
+///the Bullet/Demos/SerializeDemo and Bullet/Serialize/BulletWorldImporter
+
+int main(int argc, char** argv)
+{
+	const char* fileName="testFile.bullet";
+	bool verboseDumpAllTypes = false;
+
+	bParse::btBulletFile* bulletFile2 = new bParse::btBulletFile(fileName);
+
+	bool ok = (bulletFile2->getFlags()& bParse::FD_OK)!=0;
+	
+	if (ok)
+		bulletFile2->parse(verboseDumpAllTypes);
+	else
+	{
+		printf("Error loading file %s.\n",fileName);
+		exit(0);
+	}
+	ok = (bulletFile2->getFlags()& bParse::FD_OK)!=0;
+	if (!ok)
+	{
+		printf("Error parsing file %s.\n",fileName);
+		exit(0);
+	}
+	
+	if (verboseDumpAllTypes)
+	{
+		bulletFile2->dumpChunks(bulletFile2->getFileDNA());
+	}
+
+
+	btBulletDataExtractor extractor;
+	
+	extractor.convertAllObjects(bulletFile2);
+
+	delete bulletFile2;
+
+	return 0;
+}
+

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