Merge pull request #41 from astrofra/main

Fixed Bullet/Lua externs

extern/bullet3/CMakeLists.txt

@@ -361,6 +361,32 @@ add_library(BulletCollision STATIC EXCLUDE_FROM_ALL
 	Bullet3Collision/NarrowPhaseCollision/shared/b3UpdateAabbs.h)
 target_include_directories(BulletCollision PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
 
+add_library(BulletFileLoader STATIC EXCLUDE_FROM_ALL
+	Serialize/BulletFileLoader/bChunk.cpp
+	Serialize/BulletFileLoader/bDNA.cpp
+	Serialize/BulletFileLoader/bFile.cpp
+	Serialize/BulletFileLoader/btBulletFile.cpp
+	Serialize/BulletFileLoader/bChunk.h
+	Serialize/BulletFileLoader/bCommon.h
+	Serialize/BulletFileLoader/bDefines.h
+	Serialize/BulletFileLoader/bDNA.h
+	Serialize/BulletFileLoader/bFile.h
+	Serialize/BulletFileLoader/btBulletFile.h
+)
+target_include_directories(BulletFileLoader PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+target_link_libraries(BulletFileLoader PUBLIC LinearMath)
+ 
+add_library(BulletWorldImporter STATIC EXCLUDE_FROM_ALL
+	Serialize/BulletWorldImporter/btMultiBodyWorldImporter.cpp
+	Serialize/BulletWorldImporter/btMultiBodyWorldImporter.h
+	Serialize/BulletWorldImporter/btBulletWorldImporter.cpp
+	Serialize/BulletWorldImporter/btBulletWorldImporter.h
+	Serialize/BulletWorldImporter/btWorldImporter.cpp
+	Serialize/BulletWorldImporter/btWorldImporter.h
+)
+target_include_directories(BulletWorldImporter PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+target_link_libraries(BulletWorldImporter PUBLIC BulletFileLoader BulletDynamics)
+
 #
 add_library(BulletDynamics STATIC EXCLUDE_FROM_ALL
 	BulletDynamics/Character/btCharacterControllerInterface.h

extern/bullet3/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

extern/bullet3/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__

extern/bullet3/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__

extern/bullet3/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

extern/bullet3/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__

extern/bullet3/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__

extern/bullet3/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__

extern/bullet3/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);
+}

extern/bullet3/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

extern/bullet3/Serialize/BulletWorldImporter/btBulletWorldImporter.cpp

@@ -0,0 +1,337 @@
+/*
+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"
+#ifndef USE_GIMPACT
+#include "BulletCollision/Gimpact/btGImpactShape.h"
+#endif
+
+//#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];
+
+		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;
+}

extern/bullet3/Serialize/BulletWorldImporter/btBulletWorldImporter.h

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

extern/bullet3/Serialize/BulletWorldImporter/btMultiBodyWorldImporter.cpp

@@ -0,0 +1,571 @@
+#include "btMultiBodyWorldImporter.h"
+
+#include "LinearMath/btSerializer.h"
+#include "../BulletFileLoader/btBulletFile.h"
+#include "btBulletWorldImporter.h"
+#include "btBulletDynamicsCommon.h"
+#include "BulletDynamics/Featherstone/btMultiBody.h"
+#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+
+struct btMultiBodyWorldImporterInternalData
+{
+	btMultiBodyDynamicsWorld* m_mbDynamicsWorld;
+	btHashMap<btHashPtr, btMultiBody*> m_mbMap;
+};
+
+btMultiBodyWorldImporter::btMultiBodyWorldImporter(btMultiBodyDynamicsWorld* world)
+	: btBulletWorldImporter(world)
+{
+	m_data = new btMultiBodyWorldImporterInternalData;
+	m_data->m_mbDynamicsWorld = world;
+}
+
+btMultiBodyWorldImporter::~btMultiBodyWorldImporter()
+{
+	delete m_data;
+}
+
+void btMultiBodyWorldImporter::deleteAllData()
+{
+	btBulletWorldImporter::deleteAllData();
+}
+
+static btCollisionObjectDoubleData* getBody0FromContactManifold(btPersistentManifoldDoubleData* manifold)
+{
+	return (btCollisionObjectDoubleData*)manifold->m_body0;
+}
+static btCollisionObjectDoubleData* getBody1FromContactManifold(btPersistentManifoldDoubleData* manifold)
+{
+	return (btCollisionObjectDoubleData*)manifold->m_body1;
+}
+static btCollisionObjectFloatData* getBody0FromContactManifold(btPersistentManifoldFloatData* manifold)
+{
+	return (btCollisionObjectFloatData*)manifold->m_body0;
+}
+static btCollisionObjectFloatData* getBody1FromContactManifold(btPersistentManifoldFloatData* manifold)
+{
+	return (btCollisionObjectFloatData*)manifold->m_body1;
+}
+
+template <class T>
+void syncContactManifolds(T** contactManifolds, int numContactManifolds, btMultiBodyWorldImporterInternalData* m_data)
+{
+	m_data->m_mbDynamicsWorld->updateAabbs();
+	m_data->m_mbDynamicsWorld->computeOverlappingPairs();
+	btDispatcher* dispatcher = m_data->m_mbDynamicsWorld->getDispatcher();
+
+	btDispatcherInfo& dispatchInfo = m_data->m_mbDynamicsWorld->getDispatchInfo();
+
+	if (dispatcher)
+	{
+		btOverlappingPairCache* pairCache = m_data->m_mbDynamicsWorld->getBroadphase()->getOverlappingPairCache();
+		if (dispatcher)
+		{
+			dispatcher->dispatchAllCollisionPairs(pairCache, dispatchInfo, dispatcher);
+		}
+		int numExistingManifolds = m_data->m_mbDynamicsWorld->getDispatcher()->getNumManifolds();
+		btManifoldArray manifoldArray;
+		for (int i = 0; i < pairCache->getNumOverlappingPairs(); i++)
+		{
+			btBroadphasePair& pair = pairCache->getOverlappingPairArray()[i];
+			if (pair.m_algorithm)
+			{
+				pair.m_algorithm->getAllContactManifolds(manifoldArray);
+				//for each existing manifold, search a matching manifoldData and reconstruct
+				for (int m = 0; m < manifoldArray.size(); m++)
+				{
+					btPersistentManifold* existingManifold = manifoldArray[m];
+					int uid0 = existingManifold->getBody0()->getBroadphaseHandle()->m_uniqueId;
+					int uid1 = existingManifold->getBody1()->getBroadphaseHandle()->m_uniqueId;
+					int matchingManifoldIndex = -1;
+					for (int q = 0; q < numContactManifolds; q++)
+					{
+						if (uid0 == getBody0FromContactManifold(contactManifolds[q])->m_uniqueId && uid1 == getBody1FromContactManifold(contactManifolds[q])->m_uniqueId)
+						{
+							matchingManifoldIndex = q;
+						}
+					}
+					if (matchingManifoldIndex >= 0)
+					{
+						existingManifold->deSerialize(contactManifolds[matchingManifoldIndex]);
+					}
+					else
+					{
+						existingManifold->setNumContacts(0);
+						//printf("Issue: cannot find maching contact manifold (%d, %d), may cause issues in determinism.\n", uid0, uid1);
+					}
+
+					manifoldArray.clear();
+				}
+			}
+		}
+	}
+}
+
+template <class T>
+void syncMultiBody(T* mbd, btMultiBody* mb, btMultiBodyWorldImporterInternalData* m_data, btAlignedObjectArray<btQuaternion>& scratchQ, btAlignedObjectArray<btVector3>& scratchM)
+{
+	bool isFixedBase = mbd->m_baseMass == 0;
+	bool canSleep = false;
+	btVector3 baseInertia;
+	baseInertia.deSerialize(mbd->m_baseInertia);
+
+	btVector3 baseWorldPos;
+	baseWorldPos.deSerialize(mbd->m_baseWorldPosition);
+	mb->setBasePos(baseWorldPos);
+	btQuaternion baseWorldRot;
+	baseWorldRot.deSerialize(mbd->m_baseWorldOrientation);
+	mb->setWorldToBaseRot(baseWorldRot.inverse());
+	btVector3 baseLinVal;
+	baseLinVal.deSerialize(mbd->m_baseLinearVelocity);
+	btVector3 baseAngVel;
+	baseAngVel.deSerialize(mbd->m_baseAngularVelocity);
+	mb->setBaseVel(baseLinVal);
+	mb->setBaseOmega(baseAngVel);
+
+	for (int i = 0; i < mbd->m_numLinks; i++)
+	{
+		mb->getLink(i).m_absFrameTotVelocity.m_topVec.deSerialize(mbd->m_links[i].m_absFrameTotVelocityTop);
+		mb->getLink(i).m_absFrameTotVelocity.m_bottomVec.deSerialize(mbd->m_links[i].m_absFrameTotVelocityBottom);
+		mb->getLink(i).m_absFrameLocVelocity.m_topVec.deSerialize(mbd->m_links[i].m_absFrameLocVelocityTop);
+		mb->getLink(i).m_absFrameLocVelocity.m_bottomVec.deSerialize(mbd->m_links[i].m_absFrameLocVelocityBottom);
+
+		switch (mbd->m_links[i].m_jointType)
+		{
+			case btMultibodyLink::eFixed:
+			{
+				break;
+			}
+			case btMultibodyLink::ePrismatic:
+			{
+				mb->setJointPos(i, mbd->m_links[i].m_jointPos[0]);
+				mb->setJointVel(i, mbd->m_links[i].m_jointVel[0]);
+				break;
+			}
+			case btMultibodyLink::eRevolute:
+			{
+				mb->setJointPos(i, mbd->m_links[i].m_jointPos[0]);
+				mb->setJointVel(i, mbd->m_links[i].m_jointVel[0]);
+				break;
+			}
+			case btMultibodyLink::eSpherical:
+			{
+				btScalar jointPos[4] = {(btScalar)mbd->m_links[i].m_jointPos[0], (btScalar)mbd->m_links[i].m_jointPos[1], (btScalar)mbd->m_links[i].m_jointPos[2], (btScalar)mbd->m_links[i].m_jointPos[3]};
+				btScalar jointVel[3] = {(btScalar)mbd->m_links[i].m_jointVel[0], (btScalar)mbd->m_links[i].m_jointVel[1], (btScalar)mbd->m_links[i].m_jointVel[2]};
+				mb->setJointPosMultiDof(i, jointPos);
+				mb->setJointVelMultiDof(i, jointVel);
+
+				break;
+			}
+			case btMultibodyLink::ePlanar:
+			{
+				break;
+			}
+			default:
+			{
+			}
+		}
+	}
+	mb->forwardKinematics(scratchQ, scratchM);
+	mb->updateCollisionObjectWorldTransforms(scratchQ, scratchM);
+}
+
+template <class T>
+void convertMultiBody(T* mbd, btMultiBodyWorldImporterInternalData* m_data)
+{
+	bool isFixedBase = mbd->m_baseMass == 0;
+	bool canSleep = false;
+	btVector3 baseInertia;
+	baseInertia.deSerialize(mbd->m_baseInertia);
+	btMultiBody* mb = new btMultiBody(mbd->m_numLinks, mbd->m_baseMass, baseInertia, isFixedBase, canSleep);
+	mb->setHasSelfCollision(false);
+
+	btVector3 baseWorldPos;
+	baseWorldPos.deSerialize(mbd->m_baseWorldPosition);
+
+	btQuaternion baseWorldOrn;
+	baseWorldOrn.deSerialize(mbd->m_baseWorldOrientation);
+	mb->setBasePos(baseWorldPos);
+	mb->setWorldToBaseRot(baseWorldOrn.inverse());
+
+	m_data->m_mbMap.insert(mbd, mb);
+	for (int i = 0; i < mbd->m_numLinks; i++)
+	{
+		btVector3 localInertiaDiagonal;
+		localInertiaDiagonal.deSerialize(mbd->m_links[i].m_linkInertia);
+		btQuaternion parentRotToThis;
+		parentRotToThis.deSerialize(mbd->m_links[i].m_zeroRotParentToThis);
+		btVector3 parentComToThisPivotOffset;
+		parentComToThisPivotOffset.deSerialize(mbd->m_links[i].m_parentComToThisPivotOffset);
+		btVector3 thisPivotToThisComOffset;
+		thisPivotToThisComOffset.deSerialize(mbd->m_links[i].m_thisPivotToThisComOffset);
+
+		switch (mbd->m_links[i].m_jointType)
+		{
+			case btMultibodyLink::eFixed:
+			{
+				mb->setupFixed(i, mbd->m_links[i].m_linkMass, localInertiaDiagonal, mbd->m_links[i].m_parentIndex,
+							   parentRotToThis, parentComToThisPivotOffset, thisPivotToThisComOffset);
+				//search for the collider
+				//mbd->m_links[i].m_linkCollider
+				break;
+			}
+			case btMultibodyLink::ePrismatic:
+			{
+				btVector3 jointAxis;
+				jointAxis.deSerialize(mbd->m_links[i].m_jointAxisBottom[0]);
+				bool disableParentCollision = true;  //todo
+				mb->setupPrismatic(i, mbd->m_links[i].m_linkMass, localInertiaDiagonal, mbd->m_links[i].m_parentIndex,
+								   parentRotToThis, jointAxis, parentComToThisPivotOffset, thisPivotToThisComOffset, disableParentCollision);
+				mb->setJointPos(i, mbd->m_links[i].m_jointPos[0]);
+				mb->finalizeMultiDof();
+				mb->setJointVel(i, mbd->m_links[i].m_jointVel[0]);
+				break;
+			}
+			case btMultibodyLink::eRevolute:
+			{
+				btVector3 jointAxis;
+				jointAxis.deSerialize(mbd->m_links[i].m_jointAxisTop[0]);
+				bool disableParentCollision = true;  //todo
+				mb->setupRevolute(i, mbd->m_links[i].m_linkMass, localInertiaDiagonal, mbd->m_links[i].m_parentIndex,
+								  parentRotToThis, jointAxis, parentComToThisPivotOffset, thisPivotToThisComOffset, disableParentCollision);
+				mb->setJointPos(i, mbd->m_links[i].m_jointPos[0]);
+				mb->finalizeMultiDof();
+				mb->setJointVel(i, mbd->m_links[i].m_jointVel[0]);
+				break;
+			}
+			case btMultibodyLink::eSpherical:
+			{
+				btAssert(0);
+				bool disableParentCollision = true;  //todo
+				mb->setupSpherical(i, mbd->m_links[i].m_linkMass, localInertiaDiagonal, mbd->m_links[i].m_parentIndex,
+								   parentRotToThis, parentComToThisPivotOffset, thisPivotToThisComOffset, disableParentCollision);
+				btScalar jointPos[4] = {(btScalar)mbd->m_links[i].m_jointPos[0], (btScalar)mbd->m_links[i].m_jointPos[1], (btScalar)mbd->m_links[i].m_jointPos[2], (btScalar)mbd->m_links[i].m_jointPos[3]};
+				btScalar jointVel[3] = {(btScalar)mbd->m_links[i].m_jointVel[0], (btScalar)mbd->m_links[i].m_jointVel[1], (btScalar)mbd->m_links[i].m_jointVel[2]};
+				mb->setJointPosMultiDof(i, jointPos);
+				mb->finalizeMultiDof();
+				mb->setJointVelMultiDof(i, jointVel);
+
+				break;
+			}
+			case btMultibodyLink::ePlanar:
+			{
+				btAssert(0);
+				break;
+			}
+			default:
+			{
+				btAssert(0);
+			}
+		}
+	}
+}
+
+bool btMultiBodyWorldImporter::convertAllObjects(bParse::btBulletFile* bulletFile2)
+{
+	bool result = false;
+	btAlignedObjectArray<btQuaternion> scratchQ;
+	btAlignedObjectArray<btVector3> scratchM;
+
+	if (m_importerFlags & eRESTORE_EXISTING_OBJECTS)
+	{
+		//check if the snapshot is valid for the existing world
+		//equal number of objects, # links etc
+		if ((bulletFile2->m_multiBodies.size() != m_data->m_mbDynamicsWorld->getNumMultibodies()))
+		{
+			printf("btMultiBodyWorldImporter::convertAllObjects error: expected %d multibodies, got %d.\n", m_data->m_mbDynamicsWorld->getNumMultibodies(), bulletFile2->m_multiBodies.size());
+			result = false;
+			return result;
+		}
+		result = true;
+
+		//convert all multibodies
+		if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+		{
+			//for (int i = 0; i < bulletFile2->m_multiBodies.size(); i++)
+			for (int i = bulletFile2->m_multiBodies.size() - 1; i >= 0; i--)
+			{
+				btMultiBodyDoubleData* mbd = (btMultiBodyDoubleData*)bulletFile2->m_multiBodies[i];
+				btMultiBody* mb = m_data->m_mbDynamicsWorld->getMultiBody(i);
+				if (mbd->m_numLinks != mb->getNumLinks())
+				{
+					printf("btMultiBodyWorldImporter::convertAllObjects error: mismatch in number of links in a body (expected %d, found %d).\n", mbd->m_numLinks, mb->getNumLinks() );
+					result = false;
+					return result;
+				} else
+				{
+					syncMultiBody(mbd, mb, m_data, scratchQ, scratchM);
+				}
+			}
+
+			for (int i = bulletFile2->m_rigidBodies.size() - 1; i >= 0; i--)
+			{
+				btRigidBodyDoubleData* rbd = (btRigidBodyDoubleData*)bulletFile2->m_rigidBodies[i];
+				int foundRb = -1;
+				int uid = rbd->m_collisionObjectData.m_uniqueId;
+				for (int i = 0; i < m_data->m_mbDynamicsWorld->getNumCollisionObjects(); i++)
+				{
+					if (uid == m_data->m_mbDynamicsWorld->getCollisionObjectArray()[i]->getBroadphaseHandle()->m_uniqueId)
+					{
+						foundRb = i;
+						break;
+					}
+				}
+				if (foundRb >= 0)
+				{
+					btRigidBody* rb = btRigidBody::upcast(m_data->m_mbDynamicsWorld->getCollisionObjectArray()[foundRb]);
+					if (rb)
+					{
+						btTransform tr;
+						tr.deSerializeDouble(rbd->m_collisionObjectData.m_worldTransform);
+						rb->setWorldTransform(tr);
+						btVector3 linVel, angVel;
+						linVel.deSerializeDouble(rbd->m_linearVelocity);
+						angVel.deSerializeDouble(rbd->m_angularVelocity);
+						rb->setLinearVelocity(linVel);
+						rb->setAngularVelocity(angVel);
+					}
+					else
+					{
+						printf("btMultiBodyWorldImporter::convertAllObjects error: cannot find btRigidBody with bodyUniqueId %d\n", uid);
+						result = false;
+					}
+				}
+				else
+				{
+					printf("Error in btMultiBodyWorldImporter::convertAllObjects: didn't find bodyUniqueId: %d\n", uid);
+					result = false;
+				}
+			}
+
+			//todo: check why body1 pointer is not properly deserialized
+			for (int i = 0; i < bulletFile2->m_contactManifolds.size(); i++)
+			{
+				btPersistentManifoldDoubleData* manifoldData = (btPersistentManifoldDoubleData*)bulletFile2->m_contactManifolds[i];
+				{
+					void* ptr = bulletFile2->findLibPointer(manifoldData->m_body0);
+					if (ptr)
+					{
+						manifoldData->m_body0 = (btCollisionObjectDoubleData*)ptr;
+					}
+				}
+
+				{
+					void* ptr = bulletFile2->findLibPointer(manifoldData->m_body1);
+					if (ptr)
+					{
+						manifoldData->m_body1 = (btCollisionObjectDoubleData*)ptr;
+					}
+				}
+			}
+
+			if (bulletFile2->m_contactManifolds.size())
+			{
+				syncContactManifolds((btPersistentManifoldDoubleData**)&bulletFile2->m_contactManifolds[0], bulletFile2->m_contactManifolds.size(), m_data);
+			}
+		}
+		else
+		{
+			//single precision version
+			//for (int i = 0; i < bulletFile2->m_multiBodies.size(); i++)
+			for (int i = bulletFile2->m_multiBodies.size() - 1; i >= 0; i--)
+			{
+				btMultiBodyFloatData* mbd = (btMultiBodyFloatData*)bulletFile2->m_multiBodies[i];
+				btMultiBody* mb = m_data->m_mbDynamicsWorld->getMultiBody(i);
+				if (mbd->m_numLinks != mb->getNumLinks())
+				{
+					printf("btMultiBodyWorldImporter::convertAllObjects error: mismatch in number of links in a body (expected %d, found %d).\n", mbd->m_numLinks, mb->getNumLinks() );
+					result = false;
+					return result;
+				} else
+				{
+					syncMultiBody(mbd, mb, m_data, scratchQ, scratchM);
+				}
+			}
+
+			for (int i = bulletFile2->m_rigidBodies.size() - 1; i >= 0; i--)
+			{
+				btRigidBodyFloatData* rbd = (btRigidBodyFloatData*)bulletFile2->m_rigidBodies[i];
+				int foundRb = -1;
+				int uid = rbd->m_collisionObjectData.m_uniqueId;
+				for (int i = 0; i < m_data->m_mbDynamicsWorld->getNumCollisionObjects(); i++)
+				{
+					if (uid == m_data->m_mbDynamicsWorld->getCollisionObjectArray()[i]->getBroadphaseHandle()->m_uniqueId)
+					{
+						foundRb = i;
+						break;
+					}
+				}
+				if (foundRb >= 0)
+				{
+					btRigidBody* rb = btRigidBody::upcast(m_data->m_mbDynamicsWorld->getCollisionObjectArray()[foundRb]);
+					if (rb)
+					{
+						btTransform tr;
+						tr.deSerializeFloat(rbd->m_collisionObjectData.m_worldTransform);
+						rb->setWorldTransform(tr);
+						btVector3 linVel, angVel;
+						linVel.deSerializeFloat(rbd->m_linearVelocity);
+						angVel.deSerializeFloat(rbd->m_angularVelocity);
+						rb->setLinearVelocity(linVel);
+						rb->setAngularVelocity(angVel);
+					}
+					else
+					{
+						printf("btMultiBodyWorldImporter::convertAllObjects error: cannot find btRigidBody with bodyUniqueId %d\n", uid);
+						result = false;
+					}
+				}
+				else
+				{
+					printf("Error in btMultiBodyWorldImporter::convertAllObjects: didn't find bodyUniqueId: %d\n", uid);
+					result = false;
+				}
+			}
+
+			//todo: check why body1 pointer is not properly deserialized
+			for (int i = 0; i < bulletFile2->m_contactManifolds.size(); i++)
+			{
+				btPersistentManifoldFloatData* manifoldData = (btPersistentManifoldFloatData*)bulletFile2->m_contactManifolds[i];
+				{
+					void* ptr = bulletFile2->findLibPointer(manifoldData->m_body0);
+					if (ptr)
+					{
+						manifoldData->m_body0 = (btCollisionObjectFloatData*)ptr;
+					}
+				}
+				{
+					void* ptr = bulletFile2->findLibPointer(manifoldData->m_body1);
+					if (ptr)
+					{
+						manifoldData->m_body1 = (btCollisionObjectFloatData*)ptr;
+					}
+				}
+			}
+
+			if (bulletFile2->m_contactManifolds.size())
+			{
+				syncContactManifolds((btPersistentManifoldFloatData**)&bulletFile2->m_contactManifolds[0], bulletFile2->m_contactManifolds.size(), m_data);
+			}
+		}
+	}
+	else
+	{
+		result = btBulletWorldImporter::convertAllObjects(bulletFile2);
+
+		//convert all multibodies
+		for (int i = 0; i < bulletFile2->m_multiBodies.size(); i++)
+		{
+			if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+			{
+				btMultiBodyDoubleData* mbd = (btMultiBodyDoubleData*)bulletFile2->m_multiBodies[i];
+				convertMultiBody(mbd, m_data);
+			}
+			else
+			{
+				btMultiBodyFloatData* mbd = (btMultiBodyFloatData*)bulletFile2->m_multiBodies[i];
+				convertMultiBody(mbd, m_data);
+			}
+		}
+
+		//forward kinematics, so that the link world transforms are valid, for collision detection
+		for (int i = 0; i < m_data->m_mbMap.size(); i++)
+		{
+			btMultiBody** ptr = m_data->m_mbMap.getAtIndex(i);
+			if (ptr)
+			{
+				btMultiBody* mb = *ptr;
+				mb->finalizeMultiDof();
+				btVector3 linvel = mb->getBaseVel();
+				btVector3 angvel = mb->getBaseOmega();
+				mb->forwardKinematics(scratchQ, scratchM);
+			}
+		}
+
+		//convert all multibody link colliders
+		for (int i = 0; i < bulletFile2->m_multiBodyLinkColliders.size(); i++)
+		{
+			if (bulletFile2->getFlags() & bParse::FD_DOUBLE_PRECISION)
+			{
+				btMultiBodyLinkColliderDoubleData* mblcd = (btMultiBodyLinkColliderDoubleData*)bulletFile2->m_multiBodyLinkColliders[i];
+
+				btMultiBody** ptr = m_data->m_mbMap[mblcd->m_multiBody];
+				if (ptr)
+				{
+					btMultiBody* multiBody = *ptr;
+
+					btCollisionShape** shapePtr = m_shapeMap.find(mblcd->m_colObjData.m_collisionShape);
+					if (shapePtr && *shapePtr)
+					{
+						btTransform startTransform;
+						mblcd->m_colObjData.m_worldTransform.m_origin.m_floats[3] = 0.f;
+						startTransform.deSerializeDouble(mblcd->m_colObjData.m_worldTransform);
+
+						btCollisionShape* shape = (btCollisionShape*)*shapePtr;
+						if (shape)
+						{
+							btMultiBodyLinkCollider* col = new btMultiBodyLinkCollider(multiBody, mblcd->m_link);
+							col->setCollisionShape(shape);
+							//btCollisionObject* body = createCollisionObject(startTransform,shape,mblcd->m_colObjData.m_name);
+							col->setFriction(btScalar(mblcd->m_colObjData.m_friction));
+							col->setRestitution(btScalar(mblcd->m_colObjData.m_restitution));
+							//m_bodyMap.insert(colObjData,body);
+							if (mblcd->m_link == -1)
+							{
+								col->setWorldTransform(multiBody->getBaseWorldTransform());
+								multiBody->setBaseCollider(col);
+							}
+							else
+							{
+								col->setWorldTransform(multiBody->getLink(mblcd->m_link).m_cachedWorldTransform);
+								multiBody->getLink(mblcd->m_link).m_collider = col;
+							}
+							int mbLinkIndex = mblcd->m_link;
+
+							bool isDynamic = (mbLinkIndex < 0 && multiBody->hasFixedBase()) ? false : true;
+							int collisionFilterGroup = isDynamic ? int(btBroadphaseProxy::DefaultFilter) : int(btBroadphaseProxy::StaticFilter);
+							int collisionFilterMask = isDynamic ? int(btBroadphaseProxy::AllFilter) : int(btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
+
+#if 0
+							int colGroup = 0, colMask = 0;
+							int collisionFlags = mblcd->m_colObjData.m_collisionFlags;
+							if (collisionFlags & URDF_HAS_COLLISION_GROUP)
+							{
+								collisionFilterGroup = colGroup;
+							}
+							if (collisionFlags & URDF_HAS_COLLISION_MASK)
+							{
+								collisionFilterMask = colMask;
+							}
+#endif
+							m_data->m_mbDynamicsWorld->addCollisionObject(col, collisionFilterGroup, collisionFilterMask);
+						}
+					}
+					else
+					{
+						printf("error: no shape found\n");
+					}
+#if 0
+					//base and fixed? -> static, otherwise flag as dynamic
+
+					world1->addCollisionObject(col, collisionFilterGroup, collisionFilterMask);
+#endif
+				}
+			}
+		}
+
+		for (int i = 0; i < m_data->m_mbMap.size(); i++)
+		{
+			btMultiBody** ptr = m_data->m_mbMap.getAtIndex(i);
+			if (ptr)
+			{
+				btMultiBody* mb = *ptr;
+				mb->finalizeMultiDof();
+
+				m_data->m_mbDynamicsWorld->addMultiBody(mb);
+			}
+		}
+	}
+	return result;
+}

extern/bullet3/Serialize/BulletWorldImporter/btMultiBodyWorldImporter.h

@@ -0,0 +1,19 @@
+#ifndef BT_MULTIBODY_WORLD_IMPORTER_H
+#define BT_MULTIBODY_WORLD_IMPORTER_H
+
+#include "btBulletWorldImporter.h"
+
+class btMultiBodyWorldImporter : public btBulletWorldImporter
+{
+	struct btMultiBodyWorldImporterInternalData* m_data;
+
+public:
+	btMultiBodyWorldImporter(class btMultiBodyDynamicsWorld* world);
+	virtual ~btMultiBodyWorldImporter();
+
+	virtual bool convertAllObjects(bParse::btBulletFile* bulletFile2);
+
+	virtual void deleteAllData();
+};
+
+#endif  //BT_MULTIBODY_WORLD_IMPORTER_H

extern/bullet3/Serialize/BulletWorldImporter/btWorldImporter.h

@@ -0,0 +1,227 @@
+/*
+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 btGeneric6DofSpring2Constraint;
+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
+
+enum btWorldImporterFlags
+{
+	eRESTORE_EXISTING_OBJECTS = 1,  //don't create new objects
+};
+
+class btWorldImporter
+{
+protected:
+	btDynamicsWorld* m_dynamicsWorld;
+
+	int m_verboseMode;
+	int m_importerFlags;
+
+	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;
+	}
+
+	void setImporterFlags(int importerFlags)
+	{
+		m_importerFlags = importerFlags;
+	}
+
+	int getImporterFlags() const
+	{
+		return m_importerFlags;
+	}
+
+	// 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);
+
+	virtual class btHeightfieldTerrainShape* createHeightfieldShape(int heightStickWidth, int heightStickLength,
+		const void* heightfieldData, btScalar heightScale,
+		btScalar minHeight, btScalar maxHeight,
+		int upAxis, int heightDataType,
+		bool flipQuadEdges);
+
+	///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 btGeneric6DofSpring2Constraint* createGeneric6DofSpring2Constraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, int rotateOrder);
+
+	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

extern/lua/CMakeLists.txt

@@ -99,6 +99,8 @@ if(WIN32)
 	target_compile_definitions(libluadll PRIVATE _CRT_SECURE_NO_WARNINGS LUA_BUILD_AS_DLL)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Linux")
 	target_compile_definitions(libluadll PUBLIC LUA_USE_LINUX)
+elseif(APPLE)
+	target_compile_definitions(libluadll PUBLIC LUA_USE_MACOSX)
 endif()
 set_target_properties(libluadll PROPERTIES OUTPUT_NAME lua54)