* Adjustment: Update Bullet version to 3.24.

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/CMakeLists.txt

@@ -0,0 +1,53 @@
+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
+                                        RUNTIME DESTINATION bin
+                                        LIBRARY DESTINATION lib${LIB_SUFFIX}
+                                        ARCHIVE 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)

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/bChunk.cpp

@@ -0,0 +1,69 @@
+/*
+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

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/bChunk.h

@@ -0,0 +1,84 @@
+/*
+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));
+}  // namespace bParse
+
+#endif  //__BCHUNK_H__

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/bCommon.h

@@ -0,0 +1,40 @@
+/*
+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;
+}  // namespace bParse
+
+#endif  //__BCOMMON_H__

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/bDNA.cpp

@@ -0,0 +1,617 @@
+/*
+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));  //DNA 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++;
+	}
+
+	cp = btAlignPointer(cp, 4);
+
+	/*
+		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++;
+	}
+
+	cp = btAlignPointer(cp, 4);
+
+	/*
+		TLEN (4 bytes)
+		<len> (short) the lengths of types
+		<len>
+	*/
+
+	// Parse type lens
+	intPtr = (int *)cp;
+	assert(strncmp(cp, "TLEN", 4) == 0);
+	intPtr++;
+
+	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

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/bDNA.h

@@ -0,0 +1,101 @@
+/*
+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;
+};
+}  // namespace bParse
+
+#endif  //__BDNA_H__

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/bDefines.h

@@ -0,0 +1,152 @@
+/* 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 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__

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/bFile.h

@@ -0,0 +1,166 @@
+/*
+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,
+	FD_FILEDNA_IS_MEMDNA = 256
+};
+
+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);
+
+	virtual 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;
+	}
+
+	void setFileDNAisMemoryDNA()
+	{
+		mFlags |= FD_FILEDNA_IS_MEMDNA;
+	}
+
+	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);
+
+	virtual void setFileDNA(int verboseMode, char* buffer, int len);
+
+	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);
+};
+}  // namespace bParse
+
+#endif  //__BFILE_H__

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/btBulletFile.cpp

@@ -0,0 +1,425 @@
+/*
+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;
+
+	int remain = mFileLen;
+
+	mDataStart = 12;
+	remain -= 12;
+
+	//invalid/empty file?
+	if (remain < sizeof(bChunkInd))
+		return;
+
+	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_CONTACTMANIFOLD_CODE)
+				{
+					m_contactManifolds.push_back((bStructHandle*)id);
+				}
+				if (dataChunk.code == BT_MULTIBODY_CODE)
+				{
+					m_multiBodies.push_back((bStructHandle*)id);
+				}
+
+				if (dataChunk.code == BT_MB_LINKCOLLIDER_CODE)
+				{
+					m_multiBodyLinkColliders.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;
+		remain -= seek;
+		if (remain <= 0)
+			break;
+
+		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);
+                memset(m_DnaCopy, 0, sBulletDNAlen64);
+		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);
+}

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/btBulletFile.h

@@ -0,0 +1,80 @@
+/*
+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_multiBodies;
+
+	btAlignedObjectArray<bStructHandle*> m_multiBodyLinkColliders;
+
+	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<bStructHandle*> m_contactManifolds;
+
+	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);
+};
+};  // namespace bParse
+
+#endif  //BT_BULLET_FILE_H

Engine/lib/bullet/Extras/Serialize/BulletFileLoader/premake4.lua

@@ -0,0 +1,16 @@
+	project "BulletFileLoader"
+		
+	kind "StaticLib"
+	
+	if os.is("Linux") then
+	    buildoptions{"-fPIC"}
+	end
+	 
+	includedirs {
+		"../../../src"
+	}
+	 
+	files {
+		"**.cpp",
+		"**.h"
+	}