upgrade to latest Bullet 2.53. cross the fingers it doesn't break one of the exotic or less exotic platforms

2007-06-23 05:28:07 +00:00
parent 14ad8c9941
commit ca26aeb7b2
165 changed files with 5055 additions and 2217 deletions
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp
@@ -21,9 +21,34 @@

 #include <assert.h>

+#ifdef DEBUG_BROADPHASE
+#include <stdio.h>
+void btAxisSweep3::debugPrintAxis(int axis, bool checkCardinality)
+{
+	int numEdges = m_pHandles[0].m_maxEdges[axis];
+	printf("SAP Axis %d, numEdges=%d\n",axis,numEdges);
+
+	int i;
+	for (i=0;i<numEdges+1;i++)
+	{
+		Edge* pEdge = m_pEdges[axis] + i;
+		Handle* pHandlePrev = getHandle(pEdge->m_handle);
+		int handleIndex = pEdge->IsMax()? pHandlePrev->m_maxEdges[axis] : pHandlePrev->m_minEdges[axis];
+		char beginOrEnd;
+		beginOrEnd=pEdge->IsMax()?'E':'B';
+		printf("	[%c,h=%d,p=%x,i=%d]\n",beginOrEnd,pEdge->m_handle,pEdge->m_pos,handleIndex);
+	}
+
+	if (checkCardinality)
+		assert(numEdges == m_numHandles*2+1);
+}
+#endif //DEBUG_BROADPHASE
+
+
 btBroadphaseProxy*	btAxisSweep3::createProxy(  const btVector3& min,  const btVector3& max,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask)
 {
-		unsigned short handleId = addHandle(min,max, userPtr,collisionFilterGroup,collisionFilterMask);
+		(void)shapeType;
+		BP_FP_INT_TYPE handleId = addHandle(min,max, userPtr,collisionFilterGroup,collisionFilterMask);
 		
 		Handle* handle = getHandle(handleId);
 				
@@ -40,6 +65,7 @@ void	btAxisSweep3::setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,con
 {
 	Handle* handle = static_cast<Handle*>(proxy);
 	updateHandle(handle->m_handleId,aabbMin,aabbMax);
+
 }


@@ -50,10 +76,11 @@ void	btAxisSweep3::setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,con
 btAxisSweep3::btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAabbMax, int maxHandles)
 :btOverlappingPairCache()
 {
+	m_invalidPair = 0;
 	//assert(bounds.HasVolume());

 	// 1 handle is reserved as sentinel
-	assert(maxHandles > 1 && maxHandles < 32767);
+	btAssert(maxHandles > 1 && maxHandles < BP_MAX_HANDLES);

 	// init bounds
 	m_worldAabbMin = worldAabbMin;
@@ -61,7 +88,9 @@ btAxisSweep3::btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAab

 	btVector3 aabbSize = m_worldAabbMax - m_worldAabbMin;

-	m_quantize = btVector3(65535.0f,65535.0f,65535.0f) / aabbSize;
+	BP_FP_INT_TYPE	maxInt = BP_HANDLE_SENTINEL;
+
+	m_quantize = btVector3(btScalar(maxInt),btScalar(maxInt),btScalar(maxInt)) / aabbSize;

 	// allocate handles buffer and put all handles on free list
 	m_pHandles = new Handle[maxHandles];
@@ -71,7 +100,7 @@ btAxisSweep3::btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAab
 	// handle 0 is reserved as the null index, and is also used as the sentinel
 	m_firstFreeHandle = 1;
 	{
-		for (int i = m_firstFreeHandle; i < maxHandles; i++)
+		for (BP_FP_INT_TYPE i = m_firstFreeHandle; i < maxHandles; i++)
 			m_pHandles[i].SetNextFree(i + 1);
 		m_pHandles[maxHandles - 1].SetNextFree(0);
 	}
@@ -94,9 +123,14 @@ btAxisSweep3::btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAab

 		m_pEdges[axis][0].m_pos = 0;
 		m_pEdges[axis][0].m_handle = 0;
-		m_pEdges[axis][1].m_pos = 0xffff;
+		m_pEdges[axis][1].m_pos = BP_HANDLE_SENTINEL;
 		m_pEdges[axis][1].m_handle = 0;
+#ifdef DEBUG_BROADPHASE
+		debugPrintAxis(axis);
+#endif //DEBUG_BROADPHASE
+
 	}
+
 }

 btAxisSweep3::~btAxisSweep3()
@@ -107,43 +141,36 @@ btAxisSweep3::~btAxisSweep3()
 	delete[] m_pHandles;
 }

-void btAxisSweep3::quantize(unsigned short* out, const btPoint3& point, int isMax) const
+void btAxisSweep3::quantize(BP_FP_INT_TYPE* out, const btPoint3& point, int isMax) const
 {
 	btPoint3 clampedPoint(point);
-	/*
-	if (isMax)
-		clampedPoint += btVector3(10,10,10);
-	else
-	{
-		clampedPoint -= btVector3(10,10,10);
-	}
-	*/
+	


 	clampedPoint.setMax(m_worldAabbMin);
 	clampedPoint.setMin(m_worldAabbMax);

 	btVector3 v = (clampedPoint - m_worldAabbMin) * m_quantize;
-	out[0] = (unsigned short)(((int)v.getX() & 0xfffc) | isMax);
-	out[1] = (unsigned short)(((int)v.getY() & 0xfffc) | isMax);
-	out[2] = (unsigned short)(((int)v.getZ() & 0xfffc) | isMax);
+	out[0] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getX() & BP_HANDLE_MASK) | isMax);
+	out[1] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getY() & BP_HANDLE_MASK) | isMax);
+	out[2] = (BP_FP_INT_TYPE)(((BP_FP_INT_TYPE)v.getZ() & BP_HANDLE_MASK) | isMax);
 	
 }



-unsigned short btAxisSweep3::allocHandle()
+BP_FP_INT_TYPE btAxisSweep3::allocHandle()
 {
 	assert(m_firstFreeHandle);

-	unsigned short handle = m_firstFreeHandle;
+	BP_FP_INT_TYPE handle = m_firstFreeHandle;
 	m_firstFreeHandle = getHandle(handle)->GetNextFree();
 	m_numHandles++;

 	return handle;
 }

-void btAxisSweep3::freeHandle(unsigned short handle)
+void btAxisSweep3::freeHandle(BP_FP_INT_TYPE handle)
 {
 	assert(handle > 0 && handle < m_maxHandles);

@@ -155,15 +182,15 @@ void btAxisSweep3::freeHandle(unsigned short handle)



-unsigned short btAxisSweep3::addHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask)
+BP_FP_INT_TYPE btAxisSweep3::addHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask)
 {
 	// quantize the bounds
-	unsigned short min[3], max[3];
+	BP_FP_INT_TYPE min[3], max[3];
 	quantize(min, aabbMin, 0);
 	quantize(max, aabbMax, 1);

 	// allocate a handle
-	unsigned short handle = allocHandle();
+	BP_FP_INT_TYPE handle = allocHandle();
 	assert(handle!= 0xcdcd);

 	Handle* pHandle = getHandle(handle);
@@ -175,11 +202,13 @@ unsigned short btAxisSweep3::addHandle(const btPoint3& aabbMin,const btPoint3& a
 	pHandle->m_collisionFilterMask = collisionFilterMask;

 	// compute current limit of edge arrays
-	int limit = m_numHandles * 2;
+	BP_FP_INT_TYPE limit = m_numHandles * 2;

+	
 	// insert new edges just inside the max boundary edge
-	for (int axis = 0; axis < 3; axis++)
+	for (BP_FP_INT_TYPE axis = 0; axis < 3; axis++)
 	{
+
 		m_pHandles[0].m_maxEdges[axis] += 2;

 		m_pEdges[axis][limit + 1] = m_pEdges[axis][limit - 1];
@@ -202,14 +231,14 @@ unsigned short btAxisSweep3::addHandle(const btPoint3& aabbMin,const btPoint3& a
 	sortMinDown(2, pHandle->m_minEdges[2], true);
 	sortMaxDown(2, pHandle->m_maxEdges[2], true);

-	//PrintAxis(1);

 	return handle;
 }


-void btAxisSweep3::removeHandle(unsigned short handle)
+void btAxisSweep3::removeHandle(BP_FP_INT_TYPE handle)
 {
+	
 	Handle* pHandle = getHandle(handle);

 	//explicitly remove the pairs containing the proxy
@@ -220,42 +249,145 @@ void btAxisSweep3::removeHandle(unsigned short handle)

 	// compute current limit of edge arrays
 	int limit = m_numHandles * 2;
+	
 	int axis;

 	for (axis = 0;axis<3;axis++)
 	{
-		Edge* pEdges = m_pEdges[axis];
-		int maxEdge= pHandle->m_maxEdges[axis];
-		pEdges[maxEdge].m_pos = 0xffff;
-		int minEdge = pHandle->m_minEdges[axis];
-		pEdges[minEdge].m_pos = 0xffff;
+		m_pHandles[0].m_maxEdges[axis] -= 2;
 	}

 	// remove the edges by sorting them up to the end of the list
 	for ( axis = 0; axis < 3; axis++)
 	{
 		Edge* pEdges = m_pEdges[axis];
-		int max = pHandle->m_maxEdges[axis];
-		pEdges[max].m_pos = 0xffff;
+		BP_FP_INT_TYPE max = pHandle->m_maxEdges[axis];
+		pEdges[max].m_pos = BP_HANDLE_SENTINEL;

 		sortMaxUp(axis,max,false);
-		
-		int i = pHandle->m_minEdges[axis];
-		pEdges[i].m_pos = 0xffff;
+
+
+		BP_FP_INT_TYPE i = pHandle->m_minEdges[axis];
+		pEdges[i].m_pos = BP_HANDLE_SENTINEL;
+

 		sortMinUp(axis,i,false);

 		pEdges[limit-1].m_handle = 0;
-		pEdges[limit-1].m_pos = 0xffff;
+		pEdges[limit-1].m_pos = BP_HANDLE_SENTINEL;
+		
+#ifdef DEBUG_BROADPHASE
+			debugPrintAxis(axis,false);
+#endif //DEBUG_BROADPHASE
+

 	}

+
 	// free the handle
 	freeHandle(handle);

 	
 }

+extern int gOverlappingPairs;
+
+
+void	btAxisSweep3::refreshOverlappingPairs()
+{
+
+}
+void	btAxisSweep3::processAllOverlappingPairs(btOverlapCallback* callback)
+{
+
+	//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
+	m_overlappingPairArray.heapSort(btBroadphasePairSortPredicate());
+
+	//remove the 'invalid' ones
+#ifdef USE_POPBACK_REMOVAL
+	while (m_invalidPair>0)
+	{
+		m_invalidPair--;
+		m_overlappingPairArray.pop_back();
+	}
+#else	
+	m_overlappingPairArray.resize(m_overlappingPairArray.size() - m_invalidPair);
+	m_invalidPair = 0;
+#endif
+
+	
+	int i;
+
+	btBroadphasePair previousPair;
+	previousPair.m_pProxy0 = 0;
+	previousPair.m_pProxy1 = 0;
+	previousPair.m_algorithm = 0;
+	
+	
+	for (i=0;i<m_overlappingPairArray.size();i++)
+	{
+	
+		btBroadphasePair& pair = m_overlappingPairArray[i];
+
+		bool isDuplicate = (pair == previousPair);
+
+		previousPair = pair;
+
+		bool needsRemoval = false;
+
+		if (!isDuplicate)
+		{
+			bool hasOverlap = testOverlap(pair.m_pProxy0,pair.m_pProxy1);
+
+			if (hasOverlap)
+			{
+				needsRemoval = callback->processOverlap(pair);
+			} else
+			{
+				needsRemoval = true;
+			}
+		} else
+		{
+			//remove duplicate
+			needsRemoval = true;
+			//should have no algorithm
+			btAssert(!pair.m_algorithm);
+		}
+		
+		if (needsRemoval)
+		{
+			cleanOverlappingPair(pair);
+
+	//		m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
+	//		m_overlappingPairArray.pop_back();
+			pair.m_pProxy0 = 0;
+			pair.m_pProxy1 = 0;
+			m_invalidPair++;
+			gOverlappingPairs--;
+		} 
+		
+	}
+}
+
+
+bool btAxisSweep3::testOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
+{
+	const Handle* pHandleA = static_cast<Handle*>(proxy0);
+	const Handle* pHandleB = static_cast<Handle*>(proxy1);
+	
+	//optimization 1: check the array index (memory address), instead of the m_pos
+
+	for (int axis = 0; axis < 3; axis++)
+	{ 
+		if (pHandleA->m_maxEdges[axis] < pHandleB->m_minEdges[axis] || 
+			pHandleB->m_maxEdges[axis] < pHandleA->m_minEdges[axis]) 
+		{ 
+			return false; 
+		} 
+	} 
+	return true;
+}
+
 bool btAxisSweep3::testOverlap(int ignoreAxis,const Handle* pHandleA, const Handle* pHandleB)
 {
 	//optimization 1: check the array index (memory address), instead of the m_pos
@@ -272,7 +404,7 @@ bool btAxisSweep3::testOverlap(int ignoreAxis,const Handle* pHandleA, const Hand
 		}
 	} 

-	//optimization 2: only 2 axis need to be tested
+	//optimization 2: only 2 axis need to be tested (conflicts with 'delayed removal' optimization)

 	/*for (int axis = 0; axis < 3; axis++)
 	{
@@ -287,7 +419,7 @@ bool btAxisSweep3::testOverlap(int ignoreAxis,const Handle* pHandleA, const Hand
 	return true;
 }

-void btAxisSweep3::updateHandle(unsigned short handle, const btPoint3& aabbMin,const btPoint3& aabbMax)
+void btAxisSweep3::updateHandle(BP_FP_INT_TYPE handle, const btPoint3& aabbMin,const btPoint3& aabbMax)
 {
 //	assert(bounds.IsFinite());
 	//assert(bounds.HasVolume());
@@ -295,15 +427,15 @@ void btAxisSweep3::updateHandle(unsigned short handle, const btPoint3& aabbMin,c
 	Handle* pHandle = getHandle(handle);

 	// quantize the new bounds
-	unsigned short min[3], max[3];
+	BP_FP_INT_TYPE min[3], max[3];
 	quantize(min, aabbMin, 0);
 	quantize(max, aabbMax, 1);

 	// update changed edges
 	for (int axis = 0; axis < 3; axis++)
 	{
-		unsigned short emin = pHandle->m_minEdges[axis];
-		unsigned short emax = pHandle->m_maxEdges[axis];
+		BP_FP_INT_TYPE emin = pHandle->m_minEdges[axis];
+		BP_FP_INT_TYPE emax = pHandle->m_maxEdges[axis];

 		int dmin = (int)min[axis] - (int)m_pEdges[axis][emin].m_pos;
 		int dmax = (int)max[axis] - (int)m_pEdges[axis][emax].m_pos;
@@ -324,14 +456,22 @@ void btAxisSweep3::updateHandle(unsigned short handle, const btPoint3& aabbMin,c

 		if (dmax < 0)
 			sortMaxDown(axis, emax);
+
+#ifdef DEBUG_BROADPHASE
+	debugPrintAxis(axis);
+#endif //DEBUG_BROADPHASE
 	}

-	//PrintAxis(1);
+	
 }

+
+
+
 // sorting a min edge downwards can only ever *add* overlaps
-void btAxisSweep3::sortMinDown(int axis, unsigned short edge, bool updateOverlaps)
+void btAxisSweep3::sortMinDown(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps)
 {
+
 	Edge* pEdge = m_pEdges[axis] + edge;
 	Edge* pPrev = pEdge - 1;
 	Handle* pHandleEdge = getHandle(pEdge->m_handle);
@@ -368,16 +508,21 @@ void btAxisSweep3::sortMinDown(int axis, unsigned short edge, bool updateOverlap
 		pEdge--;
 		pPrev--;
 	}
+
+#ifdef DEBUG_BROADPHASE
+	debugPrintAxis(axis);
+#endif //DEBUG_BROADPHASE
+
 }

 // sorting a min edge upwards can only ever *remove* overlaps
-void btAxisSweep3::sortMinUp(int axis, unsigned short edge, bool updateOverlaps)
+void btAxisSweep3::sortMinUp(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps)
 {
 	Edge* pEdge = m_pEdges[axis] + edge;
 	Edge* pNext = pEdge + 1;
 	Handle* pHandleEdge = getHandle(pEdge->m_handle);

-	while (pEdge->m_pos > pNext->m_pos)
+	while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos))
 	{
 		Handle* pHandleNext = getHandle(pNext->m_handle);

@@ -386,10 +531,12 @@ void btAxisSweep3::sortMinUp(int axis, unsigned short edge, bool updateOverlaps)
 			// if next edge is maximum remove any overlap between the two handles
 			if (updateOverlaps)
 			{
+				/*
 				Handle* handle0 = getHandle(pEdge->m_handle);
 				Handle* handle1 = getHandle(pNext->m_handle);
 				btBroadphasePair tmpPair(*handle0,*handle1);
 				removeOverlappingPair(tmpPair);
+				*/

 			}

@@ -410,11 +557,14 @@ void btAxisSweep3::sortMinUp(int axis, unsigned short edge, bool updateOverlaps)
 		pEdge++;
 		pNext++;
 	}
+
+
 }

 // sorting a max edge downwards can only ever *remove* overlaps
-void btAxisSweep3::sortMaxDown(int axis, unsigned short edge, bool updateOverlaps)
+void btAxisSweep3::sortMaxDown(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps)
 {
+
 	Edge* pEdge = m_pEdges[axis] + edge;
 	Edge* pPrev = pEdge - 1;
 	Handle* pHandleEdge = getHandle(pEdge->m_handle);
@@ -428,6 +578,8 @@ void btAxisSweep3::sortMaxDown(int axis, unsigned short edge, bool updateOverlap
 			// if previous edge was a minimum remove any overlap between the two handles
 			if (updateOverlaps)
 			{
+				//this is done during the overlappingpairarray iteration/narrowphase collision
+				/*
 				Handle* handle0 = getHandle(pEdge->m_handle);
 				Handle* handle1 = getHandle(pPrev->m_handle);
 				btBroadphasePair* pair = findPair(handle0,handle1);
@@ -437,6 +589,8 @@ void btAxisSweep3::sortMaxDown(int axis, unsigned short edge, bool updateOverlap
 				{
 					removeOverlappingPair(*pair);
 				}
+				*/
+
 			}

 			// update edge reference in other handle
@@ -456,16 +610,22 @@ void btAxisSweep3::sortMaxDown(int axis, unsigned short edge, bool updateOverlap
 		pEdge--;
 		pPrev--;
 	}
+
+	
+#ifdef DEBUG_BROADPHASE
+	debugPrintAxis(axis);
+#endif //DEBUG_BROADPHASE
+
 }

 // sorting a max edge upwards can only ever *add* overlaps
-void btAxisSweep3::sortMaxUp(int axis, unsigned short edge, bool updateOverlaps)
+void btAxisSweep3::sortMaxUp(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps)
 {
 	Edge* pEdge = m_pEdges[axis] + edge;
 	Edge* pNext = pEdge + 1;
 	Handle* pHandleEdge = getHandle(pEdge->m_handle);

-	while (pEdge->m_pos > pNext->m_pos)
+	while (pNext->m_handle && (pEdge->m_pos >= pNext->m_pos))
 	{
 		Handle* pHandleNext = getHandle(pNext->m_handle);

@@ -496,4 +656,5 @@ void btAxisSweep3::sortMaxUp(int axis, unsigned short edge, bool updateOverlaps)
 		pEdge++;
 		pNext++;
 	}
+	
 }
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btAxisSweep3.h
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btAxisSweep3.h
@@ -19,11 +19,29 @@
 #ifndef AXIS_SWEEP_3_H
 #define AXIS_SWEEP_3_H

-#include "LinearMath/btPoint3.h"
-#include "LinearMath/btVector3.h"
+#include "../../LinearMath/btPoint3.h"
+#include "../../LinearMath/btVector3.h"
 #include "btOverlappingPairCache.h"
 #include "btBroadphaseProxy.h"

+
+//Enable BP_USE_FIXEDPOINT_INT_32 if you need more then 32767 objects
+//#define BP_USE_FIXEDPOINT_INT_32 1
+
+#ifdef BP_USE_FIXEDPOINT_INT_32
+	#define BP_FP_INT_TYPE unsigned int
+	#define BP_MAX_HANDLES 1500000 //arbitrary maximum number of handles
+	#define BP_HANDLE_SENTINEL 0x7fffffff
+	#define BP_HANDLE_MASK	0xfffffffe
+#else
+	#define BP_FP_INT_TYPE unsigned short int
+	#define BP_MAX_HANDLES 32767
+	#define BP_HANDLE_SENTINEL 0xffff
+	#define BP_HANDLE_MASK	0xfffe
+#endif //BP_USE_FIXEDPOINT_INT_32
+
+//#define DEBUG_BROADPHASE 1
+
 /// btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase.
 /// It uses arrays rather then lists for storage of the 3 axis. Also it operates using integer coordinates instead of floats.
 /// The testOverlap check is optimized to check the array index, rather then the actual AABB coordinates/pos
@@ -36,10 +54,10 @@ public:
 	class Edge
 	{
 	public:
-		unsigned short m_pos;			// low bit is min/max
-		unsigned short m_handle;
+		BP_FP_INT_TYPE m_pos;			// low bit is min/max
+		BP_FP_INT_TYPE m_handle;

-		unsigned short IsMax() const {return m_pos & 1;}
+		BP_FP_INT_TYPE IsMax() const {return m_pos & 1;}
 	};

 public:
@@ -48,14 +66,14 @@ public:
 	public:
 		
 		// indexes into the edge arrays
-		unsigned short m_minEdges[3], m_maxEdges[3];		// 6 * 2 = 12
-		unsigned short m_handleId;
-		unsigned short m_pad;
+		BP_FP_INT_TYPE m_minEdges[3], m_maxEdges[3];		// 6 * 2 = 12
+		BP_FP_INT_TYPE m_handleId;
+		BP_FP_INT_TYPE m_pad;
 		
 		//void* m_pOwner; this is now in btBroadphaseProxy.m_clientObject
 	
-		inline void SetNextFree(unsigned short next) {m_minEdges[0] = next;}
-		inline unsigned short GetNextFree() const {return m_minEdges[0];}
+		inline void SetNextFree(BP_FP_INT_TYPE next) {m_minEdges[0] = next;}
+		inline BP_FP_INT_TYPE GetNextFree() const {return m_minEdges[0];}
 	};		// 24 bytes + 24 for Edge structures = 44 bytes total per entry

 	
@@ -65,51 +83,56 @@ private:

 	btVector3 m_quantize;						// scaling factor for quantization

-	int m_numHandles;						// number of active handles
+	BP_FP_INT_TYPE m_numHandles;						// number of active handles
 	int m_maxHandles;						// max number of handles
 	Handle* m_pHandles;						// handles pool
-	unsigned short m_firstFreeHandle;		// free handles list
+	BP_FP_INT_TYPE m_firstFreeHandle;		// free handles list

 	Edge* m_pEdges[3];						// edge arrays for the 3 axes (each array has m_maxHandles * 2 + 2 sentinel entries)

+	int m_invalidPair;

 	// allocation/deallocation
-	unsigned short allocHandle();
-	void freeHandle(unsigned short handle);
+	BP_FP_INT_TYPE allocHandle();
+	void freeHandle(BP_FP_INT_TYPE handle);
 	

 	bool testOverlap(int ignoreAxis,const Handle* pHandleA, const Handle* pHandleB);

-	//Overlap* AddOverlap(unsigned short handleA, unsigned short handleB);
-	//void RemoveOverlap(unsigned short handleA, unsigned short handleB);
+#ifdef DEBUG_BROADPHASE
+	void debugPrintAxis(int axis,bool checkCardinality=true);
+#endif //DEBUG_BROADPHASE

-	void quantize(unsigned short* out, const btPoint3& point, int isMax) const;
+	//Overlap* AddOverlap(BP_FP_INT_TYPE handleA, BP_FP_INT_TYPE handleB);
+	//void RemoveOverlap(BP_FP_INT_TYPE handleA, BP_FP_INT_TYPE handleB);

-	void sortMinDown(int axis, unsigned short edge, bool updateOverlaps = true);
-	void sortMinUp(int axis, unsigned short edge, bool updateOverlaps = true);
-	void sortMaxDown(int axis, unsigned short edge, bool updateOverlaps = true);
-	void sortMaxUp(int axis, unsigned short edge, bool updateOverlaps = true);
+	void quantize(BP_FP_INT_TYPE* out, const btPoint3& point, int isMax) const;
+
+	void sortMinDown(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps = true);
+	void sortMinUp(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps = true);
+	void sortMaxDown(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps = true);
+	void sortMaxUp(int axis, BP_FP_INT_TYPE edge, bool updateOverlaps = true);

 public:
 	btAxisSweep3(const btPoint3& worldAabbMin,const btPoint3& worldAabbMax, int maxHandles = 16384);
 	virtual	~btAxisSweep3();

-	virtual void	refreshOverlappingPairs()
-	{
-		//this is replace by sweep and prune
-	}
+	virtual void	refreshOverlappingPairs();
 	
-	unsigned short addHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask);
-	void removeHandle(unsigned short handle);
-	void updateHandle(unsigned short handle, const btPoint3& aabbMin,const btPoint3& aabbMax);
-	inline Handle* getHandle(unsigned short index) const {return m_pHandles + index;}
+	BP_FP_INT_TYPE addHandle(const btPoint3& aabbMin,const btPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask);
+	void removeHandle(BP_FP_INT_TYPE handle);
+	void updateHandle(BP_FP_INT_TYPE handle, const btPoint3& aabbMin,const btPoint3& aabbMax);
+	inline Handle* getHandle(BP_FP_INT_TYPE index) const {return m_pHandles + index;}

+	void	processAllOverlappingPairs(btOverlapCallback* callback);

 	//Broadphase Interface
 	virtual btBroadphaseProxy*	createProxy(  const btVector3& min,  const btVector3& max,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask);
 	virtual void	destroyProxy(btBroadphaseProxy* proxy);
 	virtual void	setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax);
+	bool testOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);

 };

-#endif //AXIS_SWEEP_3_H
+#endif
+
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h
@@ -21,7 +21,7 @@ subject to the following restrictions:
 struct btDispatcherInfo;
 class btDispatcher;
 struct btBroadphaseProxy;
-#include "LinearMath/btVector3.h"
+#include "../../LinearMath/btVector3.h"

 ///BroadphaseInterface for aabb-overlapping object pairs
 class btBroadphaseInterface
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h
@@ -16,6 +16,7 @@ subject to the following restrictions:
 #ifndef BROADPHASE_PROXY_H
 #define BROADPHASE_PROXY_H

+#include "../../LinearMath/btScalar.h" //for SIMD_FORCE_INLINE


 /// btDispatcher uses these types
@@ -33,6 +34,7 @@ enum BroadphaseNativeTypes
 IMPLICIT_CONVEX_SHAPES_START_HERE,
 	SPHERE_SHAPE_PROXYTYPE,
 	MULTI_SPHERE_SHAPE_PROXYTYPE,
+	CAPSULE_SHAPE_PROXYTYPE,
 	CONE_SHAPE_PROXYTYPE,
 	CONVEX_SHAPE_PROXYTYPE,
 	CYLINDER_SHAPE_PROXYTYPE,
@@ -71,7 +73,7 @@ struct btBroadphaseProxy
 	        KinematicFilter = 4,
 	        DebrisFilter = 8,
 			SensorTrigger = 16,
-	        AllFilter = DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger,
+	        AllFilter = DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger
 	};

 	//Usually the client btCollisionObject or Rigidbody class
@@ -113,7 +115,8 @@ struct btBroadphaseProxy
 		return (proxyType == STATIC_PLANE_PROXYTYPE);
 	}
 	
-};
+}
+;

 class btCollisionAlgorithm;

@@ -128,14 +131,16 @@ struct btBroadphasePair
 		:
 	m_pProxy0(0),
 		m_pProxy1(0),
-		m_algorithm(0)
+		m_algorithm(0),
+		m_userInfo(0)
 	{
 	}

 	btBroadphasePair(const btBroadphasePair& other)
 		:		m_pProxy0(other.m_pProxy0),
 				m_pProxy1(other.m_pProxy1),
-				m_algorithm(other.m_algorithm)
+				m_algorithm(other.m_algorithm),
+				m_userInfo(other.m_userInfo)
 	{
 	}
 	btBroadphasePair(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1)
@@ -154,6 +159,7 @@ struct btBroadphasePair
        }

 		m_algorithm = 0;
+		m_userInfo = 0;

 	}
 	
@@ -161,15 +167,37 @@ struct btBroadphasePair
 	btBroadphaseProxy* m_pProxy1;
 	
 	mutable btCollisionAlgorithm* m_algorithm;
+	mutable void* m_userInfo;
+
 };

-
+/*
 //comparison for set operation, see Solid DT_Encounter
-inline bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) 
+SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) 
 { 
    return a.m_pProxy0 < b.m_pProxy0 || 
        (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); 
 }
+*/
+
+
+class btBroadphasePairSortPredicate
+{
+	public:
+
+		bool operator() ( const btBroadphasePair& a, const btBroadphasePair& b )
+		{
+			 return a.m_pProxy0 > b.m_pProxy0 || 
+				(a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 > b.m_pProxy1) ||
+				(a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 == b.m_pProxy1 && a.m_algorithm > b.m_algorithm); 
+		}
+};
+
+
+SIMD_FORCE_INLINE bool operator==(const btBroadphasePair& a, const btBroadphasePair& b) 
+{
+	 return (a.m_pProxy0 == b.m_pProxy0) && (a.m_pProxy1 == b.m_pProxy1);
+}


 #endif //BROADPHASE_PROXY_H
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h
@@ -16,6 +16,8 @@ subject to the following restrictions:
 #ifndef COLLISION_ALGORITHM_H
 #define COLLISION_ALGORITHM_H

+#include "../../LinearMath/btScalar.h"
+
 struct btBroadphaseProxy;
 class btDispatcher;
 class btManifoldResult;
@@ -34,6 +36,7 @@ struct btCollisionAlgorithmConstructionInfo
 	btCollisionAlgorithmConstructionInfo(btDispatcher* dispatcher,int temp)
 		:m_dispatcher(dispatcher)
 	{
+		(void)temp;
 	}

 	btDispatcher*	m_dispatcher;
@@ -66,7 +69,7 @@ public:

 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;

-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;

 };

--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDispatcher.h
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btDispatcher.h
@@ -16,6 +16,8 @@ subject to the following restrictions:
 #ifndef _DISPATCHER_H
 #define _DISPATCHER_H

+#include "../../LinearMath/btScalar.h"
+
 class btCollisionAlgorithm;
 struct btBroadphaseProxy;
 class btRigidBody;
@@ -34,10 +36,10 @@ struct btDispatcherInfo
 		DISPATCH_CONTINUOUS
 	};
 	btDispatcherInfo()
-		:m_timeStep(0.f),
+		:m_timeStep(btScalar(0.)),
 		m_stepCount(0),
 		m_dispatchFunc(DISPATCH_DISCRETE),
-		m_timeOfImpact(1.f),
+		m_timeOfImpact(btScalar(1.)),
 		m_useContinuous(false),
 		m_debugDraw(0),
 		m_enableSatConvex(false),
@@ -46,10 +48,10 @@ struct btDispatcherInfo
 	{

 	}
-	float	m_timeStep;
+	btScalar	m_timeStep;
 	int		m_stepCount;
 	int		m_dispatchFunc;
-	float	m_timeOfImpact;
+	btScalar	m_timeOfImpact;
 	bool	m_useContinuous;
 	class btIDebugDraw*	m_debugDraw;
 	bool	m_enableSatConvex;
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp
@@ -39,15 +39,15 @@ btOverlappingPairCache::~btOverlappingPairCache()
 void	btOverlappingPairCache::removeOverlappingPair(btBroadphasePair& findPair)
 {
 	
-	std::set<btBroadphasePair>::iterator it = m_overlappingPairSet.find(findPair);
-//	assert(it != m_overlappingPairSet.end());
-
-	if (it != m_overlappingPairSet.end())
+	int findIndex = m_overlappingPairArray.findLinearSearch(findPair);
+	if (findIndex < m_overlappingPairArray.size())
 	{
 		gOverlappingPairs--;
-		btBroadphasePair* pair = (btBroadphasePair*)(&(*it));
-		cleanOverlappingPair(*pair);	
-		m_overlappingPairSet.erase(it);
+		btBroadphasePair& pair = m_overlappingPairArray[findIndex];
+		cleanOverlappingPair(pair);
+		
+		m_overlappingPairArray.swap(findIndex,m_overlappingPairArray.size()-1);
+		m_overlappingPairArray.pop_back();
 	}
 }

@@ -78,7 +78,7 @@ void	btOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0,btBroa

 	btBroadphasePair pair(*proxy0,*proxy1);
 	
-	m_overlappingPairSet.insert(pair);
+	m_overlappingPairArray.push_back(pair);
 	gOverlappingPairs++;
 	
 }
@@ -93,13 +93,15 @@ void	btOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0,btBroa
 		return 0;

 	btBroadphasePair tmpPair(*proxy0,*proxy1);
-	std::set<btBroadphasePair>::iterator it = m_overlappingPairSet.find(tmpPair);
-	if ((it == m_overlappingPairSet.end()))
-		return 0;
+	int findIndex = m_overlappingPairArray.findLinearSearch(tmpPair);

-	//assert(it != m_overlappingPairSet.end());
-	 btBroadphasePair* pair = (btBroadphasePair*)(&(*it));
-	return pair;
+	if (findIndex < m_overlappingPairArray.size())
+	{
+		//assert(it != m_overlappingPairSet.end());
+		 btBroadphasePair* pair = &m_overlappingPairArray[findIndex];
+		return pair;
+	}
+	return 0;
 }


@@ -170,30 +172,23 @@ void	btOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseP

 void	btOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback)
 {
-	std::set<btBroadphasePair>::iterator it = m_overlappingPairSet.begin();
-	for (; !(it==m_overlappingPairSet.end());)
+
+	int i;
+
+	for (i=0;i<m_overlappingPairArray.size();)
 	{
 	
-		btBroadphasePair* pair = (btBroadphasePair*)(&(*it));
+		btBroadphasePair* pair = &m_overlappingPairArray[i];
 		if (callback->processOverlap(*pair))
 		{
 			cleanOverlappingPair(*pair);

-			std::set<btBroadphasePair>::iterator it2 = it;
-			//why does next line not compile under OS X??
-#ifdef MAC_OSX_FIXED_STL_SET
-			it2++;
-			it = m_overlappingPairSet.erase(it);
-			assert(it == it2);
-#else
-			it++;
-			m_overlappingPairSet.erase(it2);
-#endif //MAC_OSX_FIXED_STL_SET
-
+			m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
+			m_overlappingPairArray.pop_back();
 			gOverlappingPairs--;
 		} else
 		{
-			it++;
+			i++;
 		}
 	}
 }
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h
@@ -20,8 +20,8 @@ subject to the following restrictions:

 #include "btBroadphaseInterface.h"
 #include "btBroadphaseProxy.h"
-#include "LinearMath/btPoint3.h"
-#include <set>
+#include "../../LinearMath/btPoint3.h"
+#include "../../LinearMath/btAlignedObjectArray.h"


 struct	btOverlapCallback
@@ -37,47 +37,61 @@ virtual ~btOverlapCallback()
 ///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
 class	btOverlappingPairCache : public btBroadphaseInterface
 {
-	//avoid brute-force finding all the time
-	std::set<btBroadphasePair>	m_overlappingPairSet;
-	
-	//during the dispatch, check that user doesn't destroy/create proxy
-	bool		m_blockedForChanges;
-	
+	protected:
+		//avoid brute-force finding all the time
+		btAlignedObjectArray<btBroadphasePair>	m_overlappingPairArray;
+		
+		//during the dispatch, check that user doesn't destroy/create proxy
+		bool		m_blockedForChanges;
+		
 	public:
+			
+		btOverlappingPairCache();	
+		virtual ~btOverlappingPairCache();
+
+		virtual void	processAllOverlappingPairs(btOverlapCallback*);
+
+		void	removeOverlappingPair(btBroadphasePair& pair);
+
+		void	cleanOverlappingPair(btBroadphasePair& pair);
 		
-	btOverlappingPairCache();	
-	virtual ~btOverlappingPairCache();
+		void	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);

-	void	processAllOverlappingPairs(btOverlapCallback*);
-
-	void	removeOverlappingPair(btBroadphasePair& pair);
-
-	void	cleanOverlappingPair(btBroadphasePair& pair);
-	
-	void	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
-
-	btBroadphasePair*	findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
+		btBroadphasePair*	findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
+			
 		
-	
-	void	cleanProxyFromPairs(btBroadphaseProxy* proxy);
+		void	cleanProxyFromPairs(btBroadphaseProxy* proxy);

-	void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy);
+		void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy);


-	inline bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
-	{
-		bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
-		collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+		inline bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
+		{
+			bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
+			collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
+			
+			return collides;
+		}
+			
 		
-		return collides;
-	}
+
+		virtual void	refreshOverlappingPairs() =0;
+
+		btBroadphasePair*	getOverlappingPairArrayPtr()
+		{
+			return &m_overlappingPairArray[0];
+		}
+
+		const btBroadphasePair*	getOverlappingPairArrayPtr() const
+		{
+			return &m_overlappingPairArray[0];
+		}
+
+		int	getNumOverlappingPairs() const
+		{
+			return m_overlappingPairArray.size();
+		}
 		
-	
-
-	virtual void	refreshOverlappingPairs() =0;
-
-
-

 };
 #endif //OVERLAPPING_PAIR_CACHE_H
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp
@@ -20,7 +20,7 @@ subject to the following restrictions:
 #include "LinearMath/btVector3.h"
 #include "LinearMath/btTransform.h"
 #include "LinearMath/btMatrix3x3.h"
-#include <vector>
+#include <new>


 void	btSimpleBroadphase::validate()
@@ -85,8 +85,8 @@ btBroadphaseProxy*	btSimpleBroadphase::createProxy(  const btVector3& min,  cons

 	btSimpleBroadphaseProxy* proxy1 = &m_proxies[0];
 		
-	int index = proxy - proxy1;
-	assert(index == freeIndex);
+	int	index = int(proxy - proxy1);
+	btAssert(index == freeIndex);

 	m_pProxies[m_numProxies] = proxy;
 	m_numProxies++;
@@ -100,7 +100,8 @@ class	RemovingOverlapCallback : public btOverlapCallback
 protected:
 	virtual bool	processOverlap(btBroadphasePair& pair)
 	{
-		assert(0);
+		(void)pair;
+		btAssert(0);
 		return false;
 	}
 };
@@ -131,8 +132,8 @@ void	btSimpleBroadphase::destroyProxy(btBroadphaseProxy* proxyOrg)
 		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxyOrg);
 		btSimpleBroadphaseProxy* proxy1 = &m_proxies[0];
 	
-		int index = proxy0 - proxy1;
-		assert (index < m_maxProxies);
+		int index = int(proxy0 - proxy1);
+		btAssert (index < m_maxProxies);
 		m_freeProxies[--m_firstFreeProxy] = index;

 		removeOverlappingPairsContainingProxy(proxyOrg);
--- a/extern/bullet2/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h
+++ b/extern/bullet2/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h
@@ -31,6 +31,7 @@ struct btSimpleBroadphaseProxy : public btBroadphaseProxy
 	:btBroadphaseProxy(userPtr,collisionFilterGroup,collisionFilterMask),
 	m_min(minpt),m_max(maxpt)		
 	{
+		(void)shapeType;
 	}
 	

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp
@@ -13,6 +13,7 @@ subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */

+#include "LinearMath/btScalar.h"
 #include "SphereTriangleDetector.h"
 #include "BulletCollision/CollisionShapes/btTriangleShape.h"
 #include "BulletCollision/CollisionShapes/btSphereShape.h"
@@ -28,13 +29,14 @@ m_triangle(triangle)
 void	SphereTriangleDetector::getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw)
 {

+	(void)debugDraw;
 	const btTransform& transformA = input.m_transformA;
 	const btTransform& transformB = input.m_transformB;

 	btVector3 point,normal;
-	btScalar timeOfImpact = 1.f;
-	btScalar depth = 0.f;
-//	output.m_distance = 1e30f;
+	btScalar timeOfImpact = btScalar(1.);
+	btScalar depth = btScalar(0.);
+//	output.m_distance = btScalar(1e30);
 	//move sphere into triangle space
 	btTransform	sphereInTr = transformB.inverseTimes(transformA);

@@ -45,19 +47,19 @@ void	SphereTriangleDetector::getClosestPoints(const ClosestPointInput& input,Res

 }

-#define MAX_OVERLAP 0.f
+#define MAX_OVERLAP btScalar(0.)



 // See also geometrictools.com
 // Basic idea: D = |p - (lo + t0*lv)| where t0 = lv . (p - lo) / lv . lv
-float SegmentSqrDistance(const btVector3& from, const btVector3& to,const btVector3 &p, btVector3 &nearest) {
+btScalar SegmentSqrDistance(const btVector3& from, const btVector3& to,const btVector3 &p, btVector3 &nearest) {
 	btVector3 diff = p - from;
 	btVector3 v = to - from;
-	float t = v.dot(diff);
+	btScalar t = v.dot(diff);
 	
 	if (t > 0) {
-		float dotVV = v.dot(v);
+		btScalar dotVV = v.dot(v);
 		if (t < dotVV) {
 			t /= dotVV;
 			diff -= t*v;
@@ -80,7 +82,7 @@ bool SphereTriangleDetector::facecontains(const btVector3 &p,const btVector3* ve
 }

 ///combined discrete/continuous sphere-triangle
-bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, float &timeOfImpact)
+bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact)
 {

 	const btVector3* vertices = &m_triangle->getVertexPtr(0);
@@ -92,25 +94,25 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po
 	btVector3 normal = (vertices[1]-vertices[0]).cross(vertices[2]-vertices[0]);
 	normal.normalize();
 	btVector3 p1ToCentre = c - vertices[0];
-	float distanceFromPlane = p1ToCentre.dot(normal);
+	btScalar distanceFromPlane = p1ToCentre.dot(normal);

-	if (distanceFromPlane < 0.f)
+	if (distanceFromPlane < btScalar(0.))
 	{
 		//triangle facing the other way
 	
-		distanceFromPlane *= -1.f;
-		normal *= -1.f;
+		distanceFromPlane *= btScalar(-1.);
+		normal *= btScalar(-1.);
 	}

 	///todo: move this gContactBreakingThreshold into a proper structure
-	extern float gContactBreakingThreshold;
+	extern btScalar gContactBreakingThreshold;

-	float contactMargin = gContactBreakingThreshold;
+	btScalar contactMargin = gContactBreakingThreshold;
 	bool isInsideContactPlane = distanceFromPlane < r + contactMargin;
 	bool isInsideShellPlane = distanceFromPlane < r;
 	
-	float deltaDotNormal = delta.dot(normal);
-	if (!isInsideShellPlane && deltaDotNormal >= 0.0f)
+	btScalar deltaDotNormal = delta.dot(normal);
+	if (!isInsideShellPlane && deltaDotNormal >= btScalar(0.0))
 		return false;

 	// Check for contact / intersection
@@ -123,7 +125,7 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po
 			contactPoint = c - normal*distanceFromPlane;
 		} else {
 			// Could be inside one of the contact capsules
-			float contactCapsuleRadiusSqr = (r + contactMargin) * (r + contactMargin);
+			btScalar contactCapsuleRadiusSqr = (r + contactMargin) * (r + contactMargin);
 			btVector3 nearestOnEdge;
 			for (int i = 0; i < m_triangle->getNumEdges(); i++) {
 				
@@ -132,7 +134,7 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po
 				
 				m_triangle->getEdge(i,pa,pb);

-				float distanceSqr = SegmentSqrDistance(pa,pb,c, nearestOnEdge);
+				btScalar distanceSqr = SegmentSqrDistance(pa,pb,c, nearestOnEdge);
 				if (distanceSqr < contactCapsuleRadiusSqr) {
 					// Yep, we're inside a capsule
 					hasContact = true;
@@ -145,25 +147,22 @@ bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &po

 	if (hasContact) {
 		btVector3 contactToCentre = c - contactPoint;
-		float distanceSqr = contactToCentre.length2();
+		btScalar distanceSqr = contactToCentre.length2();
 		if (distanceSqr < (r - MAX_OVERLAP)*(r - MAX_OVERLAP)) {
-			float distance = btSqrt(distanceSqr);
-			if (1)
-			{
-				resultNormal = contactToCentre;
-				resultNormal.normalize();
-			}
+			btScalar distance = btSqrt(distanceSqr);
+			resultNormal = contactToCentre;
+			resultNormal.normalize();
 			point = contactPoint;
 			depth = -(r-distance);
 			return true;
 		}

-		if (delta.dot(contactToCentre) >= 0.0f) 
+		if (delta.dot(contactToCentre) >= btScalar(0.0)) 
 			return false;
 		
 		// Moving towards the contact point -> collision
 		point = contactPoint;
-		timeOfImpact = 0.0f;
+		timeOfImpact = btScalar(0.0);
 		return true;
 	}
 	
@@ -189,7 +188,7 @@ bool SphereTriangleDetector::pointInTriangle(const btVector3 vertices[], const b
 	btVector3 edge2_normal( edge2.cross(normal));
 	btVector3 edge3_normal( edge3.cross(normal));
 	
-	float r1, r2, r3;
+	btScalar r1, r2, r3;
 	r1 = edge1_normal.dot( p1_to_p );
 	r2 = edge2_normal.dot( p2_to_p );
 	r3 = edge3_normal.dot( p3_to_p );
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.h
@@ -16,8 +16,8 @@ subject to the following restrictions:
 #ifndef SPHERE_TRIANGLE_DETECTOR_H
 #define SPHERE_TRIANGLE_DETECTOR_H

-#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
-#include "LinearMath/btPoint3.h"
+#include "../NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+#include "../../LinearMath/btPoint3.h"


 class btSphereShape;
@@ -36,7 +36,7 @@ struct SphereTriangleDetector : public btDiscreteCollisionDetectorInterface

 private:

-	bool collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, float &timeOfImpact);
+	bool collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact);
 	bool pointInTriangle(const btVector3 vertices[], const btVector3 &normal, btVector3 *p );
 	bool facecontains(const btVector3 &p,const btVector3* vertices,btVector3& normal);

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h
@@ -16,9 +16,8 @@ subject to the following restrictions:
 #ifndef COLLISION_CREATE_FUNC
 #define COLLISION_CREATE_FUNC

-#include <vector>
-
-typedef std::vector<class btCollisionObject*> btCollisionObjectArray;
+#include "../../LinearMath/btAlignedObjectArray.h"
+typedef btAlignedObjectArray<class btCollisionObject*> btCollisionObjectArray;
 class btCollisionAlgorithm;
 class btCollisionObject;

@@ -35,8 +34,11 @@ struct btCollisionAlgorithmCreateFunc
 	}
 	virtual ~btCollisionAlgorithmCreateFunc(){};

-	virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
+	virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& , btCollisionObject* body0,btCollisionObject* body1)
 	{
+		
+		(void)body0;
+		(void)body1;
 		return 0;
 	}
 };
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp
@@ -25,7 +25,6 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h"
 #include "BulletCollision/CollisionShapes/btCollisionShape.h"
 #include "BulletCollision/CollisionDispatch/btCollisionObject.h"
-#include <algorithm>
 #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"

 int gNumManifold = 0;
@@ -33,16 +32,17 @@ int gNumManifold = 0;
 #include <stdio.h>

 	
-btCollisionDispatcher::btCollisionDispatcher(bool noDefaultAlgorithms)
-:m_useIslands(true),
-m_convexConvexCreateFunc(0),
+btCollisionDispatcher::btCollisionDispatcher(bool noDefaultAlgorithms):
 m_count(0),
+m_useIslands(true),
+m_convexConvexCreateFunc(0),
 m_convexConcaveCreateFunc(0),
 m_swappedConvexConcaveCreateFunc(0),
 m_compoundCreateFunc(0),
 m_swappedCompoundCreateFunc(0),
 m_emptyCreateFunc(0)
 {
+	(void)noDefaultAlgorithms;
 	int i;

 	setNearCallback(defaultNearCallback);
@@ -56,11 +56,14 @@ m_emptyCreateFunc(0)
 		}
 	}
 }
-
+//if you want to not link with the default collision algorithms, you can
+//define BT_EXCLUDE_DEFAULT_COLLISIONALGORITHM_REGISTRATION 
+//in your Bullet library build system
+#ifndef BT_EXCLUDE_DEFAULT_COLLISIONALGORITHM_REGISTRATION

 btCollisionDispatcher::btCollisionDispatcher (): 
-	m_useIslands(true),
-		m_count(0)
+	m_count(0),
+	m_useIslands(true)
 {
 	int i;

@@ -86,6 +89,9 @@ btCollisionDispatcher::btCollisionDispatcher ():
 	
 };

+#endif //BT_EXCLUDE_DEFAULT_COLLISIONALGORITHM_REGISTRATION
+
+
 void btCollisionDispatcher::registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc *createFunc)
 {
 	m_doubleDispatch[proxyType0][proxyType1] = createFunc;
@@ -129,20 +135,17 @@ void btCollisionDispatcher::releaseManifold(btPersistentManifold* manifold)
 	gNumManifold--;

 	//printf("releaseManifold: gNumManifold %d\n",gNumManifold);
-
 	clearManifold(manifold);

-	std::vector<btPersistentManifold*>::iterator i =
-		std::find(m_manifoldsPtr.begin(), m_manifoldsPtr.end(), manifold);
-	if (!(i == m_manifoldsPtr.end()))
+	///todo: this can be improved a lot, linear search might be slow part!
+	int findIndex = m_manifoldsPtr.findLinearSearch(manifold);
+	if (findIndex < m_manifoldsPtr.size())
 	{
-		std::swap(*i, m_manifoldsPtr.back());
+		m_manifoldsPtr.swap(findIndex,m_manifoldsPtr.size()-1);
 		m_manifoldsPtr.pop_back();
 		delete manifold;
-
 	}
 	
-	
 }

 	
@@ -164,6 +167,8 @@ btCollisionAlgorithm* btCollisionDispatcher::findAlgorithm(btCollisionObject* bo
 }


+#ifndef BT_EXCLUDE_DEFAULT_COLLISIONALGORITHM_REGISTRATION
+
 btCollisionAlgorithmCreateFunc* btCollisionDispatcher::internalFindCreateFunc(int proxyType0,int proxyType1)
 {
 	
@@ -197,6 +202,8 @@ btCollisionAlgorithmCreateFunc* btCollisionDispatcher::internalFindCreateFunc(in
 	return m_emptyCreateFunc;
 }

+#endif //BT_EXCLUDE_DEFAULT_COLLISIONALGORITHM_REGISTRATION
+

 #ifndef USE_DISPATCH_REGISTRY_ARRAY

@@ -288,6 +295,16 @@ public:
 	{
 	}

+	btCollisionPairCallback& operator=(btCollisionPairCallback& other)
+	{
+		m_dispatchInfo = other.m_dispatchInfo;
+		m_dispatcher = other.m_dispatcher;
+		return *this;
+	}
+
+	virtual ~btCollisionPairCallback() {}
+
+
 	virtual bool	processOverlap(btBroadphasePair& pair)
 	{
 		(*m_dispatcher->getNearCallback())(pair,*m_dispatcher,m_dispatchInfo);
@@ -337,7 +354,7 @@ void btCollisionDispatcher::defaultNearCallback(btBroadphasePair& collisionPair,
 				} else
 				{
 					//continuous collision detection query, time of impact (toi)
-					float toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0,colObj1,dispatchInfo,&contactPointResult);
+					btScalar toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0,colObj1,dispatchInfo,&contactPointResult);
 					if (dispatchInfo.m_timeOfImpact > toi)
 						dispatchInfo.m_timeOfImpact = toi;

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionDispatcher.h
@@ -16,13 +16,13 @@ subject to the following restrictions:
 #ifndef COLLISION__DISPATCHER_H
 #define COLLISION__DISPATCHER_H

-#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
-#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "../BroadphaseCollision/btDispatcher.h"
+#include "../NarrowPhaseCollision/btPersistentManifold.h"

-#include "BulletCollision/CollisionDispatch/btManifoldResult.h"
-
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "../CollisionDispatch/btManifoldResult.h"

+#include "../BroadphaseCollision/btBroadphaseProxy.h"
+#include "../../LinearMath/btAlignedObjectArray.h"

 class btIDebugDraw;
 class btOverlappingPairCache;
@@ -41,8 +41,9 @@ typedef void (*btNearCallback)(btBroadphasePair& collisionPair, btCollisionDispa
 ///Time of Impact, Closest Points and Penetration Depth.
 class btCollisionDispatcher : public btDispatcher
 {
+	int m_count;
 	
-	std::vector<btPersistentManifold*>	m_manifoldsPtr;
+	btAlignedObjectArray<btPersistentManifold*>	m_manifoldsPtr;

 	bool m_useIslands;
 	
@@ -68,7 +69,6 @@ class btCollisionDispatcher : public btDispatcher

 public:

-	
 	///registerCollisionCreateFunc allows registration of custom/alternative collision create functions
 	void	registerCollisionCreateFunc(int proxyType0,int proxyType1, btCollisionAlgorithmCreateFunc* createFunc);

@@ -92,8 +92,6 @@ public:
 		return m_manifoldsPtr[index];
 	}

-	int m_count;
-	
 	///the default constructor creates/register default collision algorithms, for convex, compound and concave shape support
 	btCollisionDispatcher ();

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.cpp
@@ -20,11 +20,11 @@ btCollisionObject::btCollisionObject()
 		m_collisionShape(0),
 		m_collisionFlags(0),
 		m_activationState1(1),
-		m_deactivationTime(0.f),
+		m_deactivationTime(btScalar(0.)),
 		m_userObjectPointer(0),
-		m_hitFraction(1.f),
-		m_ccdSweptSphereRadius(0.f),
-		m_ccdSquareMotionThreshold(0.f)
+		m_hitFraction(btScalar(1.)),
+		m_ccdSweptSphereRadius(btScalar(0.)),
+		m_ccdSquareMotionThreshold(btScalar(0.))
 {
 	
 }
@@ -46,7 +46,7 @@ void btCollisionObject::activate(bool forceActivation)
 	if (forceActivation || !(m_collisionFlags & (CF_STATIC_OBJECT|CF_KINEMATIC_OBJECT)))
 	{
 		setActivationState(ACTIVE_TAG);
-		m_deactivationTime = 0.f;
+		m_deactivationTime = btScalar(0.);
 	}
 }

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionObject.h
@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef COLLISION_OBJECT_H
 #define COLLISION_OBJECT_H

-#include "LinearMath/btTransform.h"
+#include "../../LinearMath/btTransform.h"

 //island management, m_activationState1
 #define ACTIVE_TAG 1
@@ -27,21 +27,19 @@ subject to the following restrictions:

 struct	btBroadphaseProxy;
 class	btCollisionShape;
-#include "LinearMath/btMotionState.h"
+#include "../../LinearMath/btMotionState.h"



 /// btCollisionObject can be used to manage collision detection objects. 
 /// btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy.
 /// They can be added to the btCollisionWorld.
-class	btCollisionObject
+ATTRIBUTE_ALIGNED16(class)	btCollisionObject
 {

 protected:

 	btTransform	m_worldTransform;
-	btBroadphaseProxy*	m_broadphaseHandle;
-	btCollisionShape*		m_collisionShape;

 	///m_interpolationWorldTransform is used for CCD and interpolation
 	///it can be either previous or future (predicted) transform
@@ -50,12 +48,16 @@ protected:
 	//without destroying the continuous interpolated motion (which uses this interpolation velocities)
 	btVector3	m_interpolationLinearVelocity;
 	btVector3	m_interpolationAngularVelocity;
+	btBroadphaseProxy*		m_broadphaseHandle;
+	btCollisionShape*		m_collisionShape;

 	int				m_collisionFlags;

 	int				m_islandTag1;
+	int				m_companionId;
+
 	int				m_activationState1;
-	float			m_deactivationTime;
+	btScalar			m_deactivationTime;

 	btScalar		m_friction;
 	btScalar		m_restitution;
@@ -67,13 +69,15 @@ protected:
 	void*			m_internalOwner;

 	///time of impact calculation
-	float			m_hitFraction; 
+	btScalar			m_hitFraction; 
 	
 	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	float			m_ccdSweptSphereRadius;
+	btScalar			m_ccdSweptSphereRadius;

 	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
-	float			m_ccdSquareMotionThreshold;
+	btScalar			m_ccdSquareMotionThreshold;
+	
+	char	m_pad[8];

 public:

@@ -82,7 +86,7 @@ public:
 		CF_STATIC_OBJECT= 1,
 		CF_KINEMATIC_OBJECT= 2,
 		CF_NO_CONTACT_RESPONSE = 4,
-		CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution)
+		CF_CUSTOM_MATERIAL_CALLBACK = 8//this allows per-triangle material (friction/restitution)
 	};


@@ -137,11 +141,11 @@ public:
 	
 	void setActivationState(int newState);

-	void	setDeactivationTime(float time)
+	void	setDeactivationTime(btScalar time)
 	{
 		m_deactivationTime = time;
 	}
-	float	getDeactivationTime() const
+	btScalar	getDeactivationTime() const
 	{
 		return m_deactivationTime;
 	}
@@ -155,19 +159,19 @@ public:
 		return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
 	}

-		void	setRestitution(float rest)
+		void	setRestitution(btScalar rest)
 	{
 		m_restitution = rest;
 	}
-	float	getRestitution() const
+	btScalar	getRestitution() const
 	{
 		return m_restitution;
 	}
-	void	setFriction(float frict)
+	void	setFriction(btScalar frict)
 	{
 		m_friction = frict;
 	}
-	float	getFriction() const
+	btScalar	getFriction() const
 	{
 		return m_friction;
 	}
@@ -251,12 +255,22 @@ public:
 		m_islandTag1 = tag;
 	}

-	const float			getHitFraction() const
+	const int getCompanionId() const
+	{
+		return	m_companionId;
+	}
+
+	void	setCompanionId(int id)
+	{
+		m_companionId = id;
+	}
+
+	const btScalar			getHitFraction() const
 	{
 		return m_hitFraction; 
 	}

-	void	setHitFraction(float hitFraction)
+	void	setHitFraction(btScalar hitFraction)
 	{
 		m_hitFraction = hitFraction;
 	}
@@ -273,25 +287,25 @@ public:
 	}
 	
 	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	float			getCcdSweptSphereRadius() const
+	btScalar			getCcdSweptSphereRadius() const
 	{
 		return m_ccdSweptSphereRadius;
 	}

 	///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
-	void	setCcdSweptSphereRadius(float radius)
+	void	setCcdSweptSphereRadius(btScalar radius)
 	{
 		m_ccdSweptSphereRadius = radius;
 	}

-	float 	getCcdSquareMotionThreshold() const
+	btScalar 	getCcdSquareMotionThreshold() const
 	{
 		return m_ccdSquareMotionThreshold;
 	}


 	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionThreshold
-	void	setCcdSquareMotionThreshold(float ccdSquareMotionThreshold)
+	void	setCcdSquareMotionThreshold(btScalar ccdSquareMotionThreshold)
 	{
 		m_ccdSquareMotionThreshold = ccdSquareMotionThreshold;
 	}
@@ -308,6 +322,7 @@ public:
 		m_userObjectPointer = userPointer;
 	}

-};
+}
+;

 #endif //COLLISION_OBJECT_H
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp
@@ -31,7 +31,6 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
 #include "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h"

-#include <algorithm>

 btCollisionWorld::btCollisionWorld(btDispatcher* dispatcher,btOverlappingPairCache* pairCache, int stackSize)
 :m_dispatcher1(dispatcher),
@@ -50,13 +49,10 @@ btCollisionWorld::~btCollisionWorld()
 	delete m_stackAlloc;

 	//clean up remaining objects
-	std::vector<btCollisionObject*>::iterator i;
-
-	for (i=m_collisionObjects.begin();
-	!(i==m_collisionObjects.end()); i++)
-
+	int i;
+	for (i=0;i<m_collisionObjects.size();i++)
 	{
-		btCollisionObject* collisionObject= (*i);
+		btCollisionObject* collisionObject= m_collisionObjects[i];
 		
 		btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
 		if (bp)
@@ -89,9 +85,7 @@ void	btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject,sho
 {

 	//check that the object isn't already added
-	std::vector<btCollisionObject*>::iterator i =	std::find(m_collisionObjects.begin(), m_collisionObjects.end(), collisionObject);
-	assert(i == m_collisionObjects.end());
-
+		btAssert( m_collisionObjects.findLinearSearch(collisionObject)  == m_collisionObjects.size());

 		m_collisionObjects.push_back(collisionObject);

@@ -125,13 +119,13 @@ void	btCollisionWorld::performDiscreteCollisionDetection()
 {
 	btDispatcherInfo& dispatchInfo = getDispatchInfo();

-	BEGIN_PROFILE("performDiscreteCollisionDetection");
+	BEGIN_PROFILE("perform Broadphase Collision Detection");


 	//update aabb (of all moved objects)

 	btVector3 aabbMin,aabbMax;
-	for (size_t i=0;i<m_collisionObjects.size();i++)
+	for (int i=0;i<m_collisionObjects.size();i++)
 	{
 		m_collisionObjects[i]->getCollisionShape()->getAabb(m_collisionObjects[i]->getWorldTransform(),aabbMin,aabbMax);
 		m_broadphasePairCache->setAabb(m_collisionObjects[i]->getBroadphaseHandle(),aabbMin,aabbMax);
@@ -139,6 +133,11 @@ void	btCollisionWorld::performDiscreteCollisionDetection()

 	m_broadphasePairCache->refreshOverlappingPairs();

+	
+	END_PROFILE("perform Broadphase Collision Detection");
+
+	BEGIN_PROFILE("performDiscreteCollisionDetection");
+
 	btDispatcher* dispatcher = getDispatcher();
 	if (dispatcher)
 		dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache,dispatchInfo);
@@ -169,15 +168,13 @@ void	btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
 	}


-	std::vector<btCollisionObject*>::iterator i =	std::find(m_collisionObjects.begin(), m_collisionObjects.end(), collisionObject);
-		
-	if (!(i == m_collisionObjects.end()))
-		{
-			std::swap(*i, m_collisionObjects.back());
-			m_collisionObjects.pop_back();
-		}
+	//swapremove
+	m_collisionObjects.remove(collisionObject);
+
 }

+
+
 void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
 					  btCollisionObject* collisionObject,
 					  const btCollisionShape* collisionShape,
@@ -185,12 +182,13 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 					  RayResultCallback& resultCallback)
 {
 	
-	btSphereShape pointShape(0.0f);
+	btSphereShape pointShape(btScalar(0.0));
+	pointShape.setMargin(0.f);

 	if (collisionShape->isConvex())
 			{
 				btConvexCast::CastResult castResult;
-				castResult.m_fraction = 1.f;//??
+				castResult.m_fraction = btScalar(1.);//??

 				btConvexShape* convexShape = (btConvexShape*) collisionShape;
 				btVoronoiSimplexSolver	simplexSolver;
@@ -201,7 +199,7 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 				if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
 				{
 					//add hit
-					if (castResult.m_normal.length2() > 0.0001f)
+					if (castResult.m_normal.length2() > btScalar(0.0001))
 					{
 						castResult.m_normal.normalize();
 						if (castResult.m_fraction < resultCallback.m_closestHitFraction)
@@ -252,7 +250,7 @@ void	btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans,const btTra
 								}


-							virtual float reportHit(const btVector3& hitNormalLocal, float hitFraction, int partId, int triangleIndex )
+							virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex )
 							{
 								btCollisionWorld::LocalShapeInfo	shapeInfo;
 								shapeInfo.m_shapePart = partId;
@@ -321,19 +319,16 @@ void	btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& r

 	/// go over all objects, and if the ray intersects their aabb, do a ray-shape query using convexCaster (CCD)
 	
-	std::vector<btCollisionObject*>::iterator iter;
-	
-	for (iter=m_collisionObjects.begin();
-	!(iter==m_collisionObjects.end()); iter++)
+	int i;
+	for (i=0;i<m_collisionObjects.size();i++)
 	{
-		
-		btCollisionObject*	collisionObject= (*iter);
+		btCollisionObject*	collisionObject= m_collisionObjects[i];

 		//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 		btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 		collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);

-		float hitLambda = 1.f; //could use resultCallback.m_closestHitFraction, but needs testing
+		btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing
 		btVector3 hitNormal;
 		if (btRayAabb(rayFromWorld,rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
 		{
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCollisionWorld.h
@@ -67,15 +67,12 @@ subject to the following restrictions:
 class btStackAlloc;
 class btCollisionShape;
 class btBroadphaseInterface;
-#include "LinearMath/btVector3.h"
-#include "LinearMath/btTransform.h"
+#include "../../LinearMath/btVector3.h"
+#include "../../LinearMath/btTransform.h"
 #include "btCollisionObject.h"
 #include "btCollisionDispatcher.h" //for definition of btCollisionObjectArray
-#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
-
-#include <vector>
-
-
+#include "../BroadphaseCollision/btOverlappingPairCache.h"
+#include "../../LinearMath/btAlignedObjectArray.h"

 ///CollisionWorld is interface and container for the collision detection
 class btCollisionWorld
@@ -84,7 +81,7 @@ class btCollisionWorld
 	
 protected:

-	std::vector<btCollisionObject*>	m_collisionObjects;
+	btAlignedObjectArray<btCollisionObject*>	m_collisionObjects;
 	
 	btDispatcher*	m_dispatcher1;

@@ -137,18 +134,18 @@ public:
 		LocalRayResult(btCollisionObject*	collisionObject, 
 			LocalShapeInfo*	localShapeInfo,
 			const btVector3&		hitNormalLocal,
-			float hitFraction)
+			btScalar hitFraction)
 		:m_collisionObject(collisionObject),
-		m_localShapeInfo(m_localShapeInfo),
+		m_localShapeInfo(localShapeInfo),
 		m_hitNormalLocal(hitNormalLocal),
 		m_hitFraction(hitFraction)
 		{
 		}

-		btCollisionObject*	m_collisionObject;
+		btCollisionObject*		m_collisionObject;
 		LocalShapeInfo*			m_localShapeInfo;
-		const btVector3&		m_hitNormalLocal;
-		float					m_hitFraction;
+		btVector3				m_hitNormalLocal;
+		btScalar				m_hitFraction;

 	};

@@ -158,17 +155,17 @@ public:
 		virtual ~RayResultCallback()
 		{
 		}
-		float	m_closestHitFraction;
+		btScalar	m_closestHitFraction;
 		bool	HasHit()
 		{
-			return (m_closestHitFraction < 1.f);
+			return (m_closestHitFraction < btScalar(1.));
 		}

 		RayResultCallback()
-			:m_closestHitFraction(1.f)
+			:m_closestHitFraction(btScalar(1.))
 		{
 		}
-		virtual	float	AddSingleResult(LocalRayResult& rayResult) = 0;
+		virtual	btScalar	AddSingleResult(LocalRayResult& rayResult) = 0;
 	};

 	struct	ClosestRayResultCallback : public RayResultCallback
@@ -187,7 +184,7 @@ public:
 		btVector3	m_hitPointWorld;
 		btCollisionObject*	m_collisionObject;
 		
-		virtual	float	AddSingleResult(LocalRayResult& rayResult)
+		virtual	btScalar	AddSingleResult(LocalRayResult& rayResult)
 		{

 //caller already does the filter on the m_closestHitFraction
@@ -216,7 +213,7 @@ public:
 	/// rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest.
 	/// In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape.
 	/// This allows more customization.
-	void	rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
+	static void	rayTestSingle(const btTransform& rayFromTrans,const btTransform& rayToTrans,
 					  btCollisionObject* collisionObject,
 					  const btCollisionShape* collisionShape,
 					  const btTransform& colObjWorldTransform,
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp
@@ -89,7 +89,7 @@ void btCompoundCollisionAlgorithm::processCollision (btCollisionObject* body0,bt
 	}
 }

-float	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {

 	btCollisionObject* colObj = m_isSwapped? body1 : body0;
@@ -106,7 +106,7 @@ float	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* bod
 	//then use each overlapping node AABB against Tree0
 	//and vise versa.

-	float hitFraction = 1.f;
+	btScalar hitFraction = btScalar(1.);

 	int numChildren = m_childCollisionAlgorithms.size();
 	int i;
@@ -124,7 +124,7 @@ float	btCompoundCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* bod
 		colObj->setWorldTransform( newChildWorldTrans );

 		colObj->setCollisionShape( childShape );
-		float frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj,otherObj,dispatchInfo,resultOut);
+		btScalar frac = m_childCollisionAlgorithms[i]->calculateTimeOfImpact(colObj,otherObj,dispatchInfo,resultOut);
 		if (frac<hitFraction)
 		{
 			hitFraction = frac;
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h
@@ -16,21 +16,21 @@ subject to the following restrictions:
 #ifndef COMPOUND_COLLISION_ALGORITHM_H
 #define COMPOUND_COLLISION_ALGORITHM_H

-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
-#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+#include "../BroadphaseCollision/btCollisionAlgorithm.h"
+#include "../BroadphaseCollision/btDispatcher.h"
+#include "../BroadphaseCollision/btBroadphaseInterface.h"

-#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "../NarrowPhaseCollision/btPersistentManifold.h"
 class btDispatcher;
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
-#include <vector>
+#include "../BroadphaseCollision/btBroadphaseProxy.h"
 #include "btCollisionCreateFunc.h"
+#include "../../LinearMath/btAlignedObjectArray.h"

 /// btCompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
 /// Place holder, not fully implemented yet
 class btCompoundCollisionAlgorithm  : public btCollisionAlgorithm
 {
-	std::vector<btCollisionAlgorithm*> m_childCollisionAlgorithms;
+	btAlignedObjectArray<btCollisionAlgorithm*> m_childCollisionAlgorithms;
 	bool m_isSwapped;
 	
 public:
@@ -41,7 +41,7 @@ public:

 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

-	float	calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	btScalar	calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

 	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp
@@ -95,7 +95,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i
 		m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color);

 		//btVector3 center = triangle[0] + triangle[1]+triangle[2];
-		//center *= 0.333333f;
+		//center *= btScalar(0.333333);
 		//m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(center),color);
 		//m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(center),color);
 		//m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(center),color);
@@ -134,7 +134,7 @@ void btConvexTriangleCallback::processTriangle(btVector3* triangle,int partId, i



-void	btConvexTriangleCallback::setTimeStepAndCounters(float collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+void	btConvexTriangleCallback::setTimeStepAndCounters(btScalar collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
 	m_dispatchInfoPtr = &dispatchInfo;
 	m_collisionMarginTriangle = collisionMarginTriangle;
@@ -146,7 +146,7 @@ void	btConvexTriangleCallback::setTimeStepAndCounters(float collisionMarginTrian
 	btCollisionShape* convexShape = static_cast<btCollisionShape*>(m_convexBody->getCollisionShape());
 	//CollisionShape* triangleShape = static_cast<btCollisionShape*>(triBody->m_collisionShape);
 	convexShape->getAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax);
-	float extraMargin = collisionMarginTriangle;
+	btScalar extraMargin = collisionMarginTriangle;
 	btVector3 extra(extraMargin,extraMargin,extraMargin);

 	m_aabbMax += extra;
@@ -176,7 +176,7 @@ void btConvexConcaveCollisionAlgorithm::processCollision (btCollisionObject* bod
 		
 		if (convexBody->getCollisionShape()->isConvex())
 		{
-			float collisionMarginTriangle = concaveShape->getMargin();
+			btScalar collisionMarginTriangle = concaveShape->getMargin();
 					
 			resultOut->setPersistentManifold(m_btConvexTriangleCallback.m_manifoldPtr);
 			m_btConvexTriangleCallback.setTimeStepAndCounters(collisionMarginTriangle,dispatchInfo,resultOut);
@@ -196,9 +196,10 @@ void btConvexConcaveCollisionAlgorithm::processCollision (btCollisionObject* bod
 }


-float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
-
+	(void)resultOut;
+	(void)dispatchInfo;
 	btCollisionObject* convexbody = m_isSwapped ? body1 : body0;
 	btCollisionObject* triBody = m_isSwapped ? body0 : body1;

@@ -207,10 +208,10 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject

 	//only perform CCD above a certain threshold, this prevents blocking on the long run
 	//because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
-	float squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2();
+	btScalar squareMot0 = (convexbody->getInterpolationWorldTransform().getOrigin() - convexbody->getWorldTransform().getOrigin()).length2();
 	if (squareMot0 < convexbody->getCcdSquareMotionThreshold())
 	{
-		return 1.f;
+		return btScalar(1.);
 	}

 	//const btVector3& from = convexbody->m_worldTransform.getOrigin();
@@ -227,11 +228,11 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 		btTransform m_ccdSphereToTrans;
 		btTransform	m_meshTransform;

-		float	m_ccdSphereRadius;
-		float	m_hitFraction;
+		btScalar	m_ccdSphereRadius;
+		btScalar	m_hitFraction;
 	

-		LocalTriangleSphereCastCallback(const btTransform& from,const btTransform& to,float ccdSphereRadius,float hitFraction)
+		LocalTriangleSphereCastCallback(const btTransform& from,const btTransform& to,btScalar ccdSphereRadius,btScalar hitFraction)
 			:m_ccdSphereFromTrans(from),
 			m_ccdSphereToTrans(to),
 			m_ccdSphereRadius(ccdSphereRadius),
@@ -242,6 +243,8 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 		
 		virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex)
 		{
+			(void)partId;
+			(void)triangleIndex;
 			//do a swept sphere for now
 			btTransform ident;
 			ident.setIdentity();
@@ -276,11 +279,11 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 		rayAabbMin.setMin(convexToLocal.getOrigin());
 		btVector3 rayAabbMax = convexFromLocal.getOrigin();
 		rayAabbMax.setMax(convexToLocal.getOrigin());
-		float ccdRadius0 = convexbody->getCcdSweptSphereRadius();
+		btScalar ccdRadius0 = convexbody->getCcdSweptSphereRadius();
 		rayAabbMin -= btVector3(ccdRadius0,ccdRadius0,ccdRadius0);
 		rayAabbMax += btVector3(ccdRadius0,ccdRadius0,ccdRadius0);

-		float curHitFraction = 1.f; //is this available?
+		btScalar curHitFraction = btScalar(1.); //is this available?
 		LocalTriangleSphereCastCallback raycastCallback(convexFromLocal,convexToLocal,
 			convexbody->getCcdSweptSphereRadius(),curHitFraction);

@@ -304,6 +307,6 @@ float btConvexConcaveCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject
 		}
 	}

-	return 1.f;
+	return btScalar(1.);

 }
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h
@@ -16,13 +16,13 @@ subject to the following restrictions:
 #ifndef CONVEX_CONCAVE_COLLISION_ALGORITHM_H
 #define CONVEX_CONCAVE_COLLISION_ALGORITHM_H

-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
-#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
-#include "BulletCollision/CollisionShapes/btTriangleCallback.h"
-#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "../BroadphaseCollision/btCollisionAlgorithm.h"
+#include "../BroadphaseCollision/btDispatcher.h"
+#include "../BroadphaseCollision/btBroadphaseInterface.h"
+#include "../CollisionShapes/btTriangleCallback.h"
+#include "../NarrowPhaseCollision/btPersistentManifold.h"
 class btDispatcher;
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h"
 #include "btCollisionCreateFunc.h"

 ///For each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), processTriangle is called.
@@ -38,7 +38,7 @@ class btConvexTriangleCallback : public btTriangleCallback

 	btDispatcher*	m_dispatcher;
 	const btDispatcherInfo* m_dispatchInfoPtr;
-	float m_collisionMarginTriangle;
+	btScalar m_collisionMarginTriangle;
 	
 public:
 int	m_triangleCount;
@@ -47,7 +47,7 @@ int	m_triangleCount;

 	btConvexTriangleCallback(btDispatcher* dispatcher,btCollisionObject* body0,btCollisionObject* body1,bool isSwapped);

-	void	setTimeStepAndCounters(float collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	void	setTimeStepAndCounters(btScalar collisionMarginTriangle,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

 	virtual ~btConvexTriangleCallback();

@@ -86,7 +86,7 @@ public:

 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

-	float	calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	btScalar	calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

 	void	clearCache();

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp
@@ -43,23 +43,9 @@ subject to the following restrictions:
 #include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"


-#ifdef WIN32
-#if _MSC_VER >= 1310
-//only use SIMD Hull code under Win32
-#ifdef TEST_HULL
-#define USE_HULL 1
-#endif //TEST_HULL
-#endif //_MSC_VER 
-#endif //WIN32


-#ifdef USE_HULL

-#include "NarrowPhaseCollision/Hull.h"
-#include "NarrowPhaseCollision/HullContactCollector.h"
-
-
-#endif //USE_HULL


 btConvexConvexAlgorithm::CreateFunc::CreateFunc()
@@ -76,6 +62,14 @@ btConvexConvexAlgorithm::CreateFunc::CreateFunc(btSimplexSolverInterface*			simp
 	m_pdSolver = pdSolver;
 }

+btConvexConvexAlgorithm::CreateFunc::~CreateFunc() 
+{ 
+   if (m_ownsSolvers){ 
+      delete m_simplexSolver; 
+      delete m_pdSolver; 
+   } 
+}
+
 btConvexConvexAlgorithm::btConvexConvexAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,btCollisionObject* body0,btCollisionObject* body1,btSimplexSolverInterface* simplexSolver, btConvexPenetrationDepthSolver* pdSolver)
 : btCollisionAlgorithm(ci),
 m_gjkPairDetector(0,0,simplexSolver,pdSolver),
@@ -83,6 +77,9 @@ m_ownManifold (false),
 m_manifoldPtr(mf),
 m_lowLevelOfDetail(false)
 {
+	(void)body0;
+	(void)body1;
+

 }

@@ -147,7 +144,7 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl
 	input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
 	input.m_stackAlloc = dispatchInfo.m_stackAllocator;

-//	input.m_maximumDistanceSquared = 1e30f;
+//	input.m_maximumDistanceSquared = btScalar(1e30);
 	
 	input.m_transformA = body0->getWorldTransform();
 	input.m_transformB = body1->getWorldTransform();
@@ -160,24 +157,26 @@ void btConvexConvexAlgorithm ::processCollision (btCollisionObject* body0,btColl


 bool disableCcd = false;
-float	btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar	btConvexConvexAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
+	(void)resultOut;
+	(void)dispatchInfo;
 	///Rather then checking ALL pairs, only calculate TOI when motion exceeds threshold
    
 	///Linear motion for one of objects needs to exceed m_ccdSquareMotionThreshold
 	///col0->m_worldTransform,
-	float resultFraction = 1.f;
+	btScalar resultFraction = btScalar(1.);


-	float squareMot0 = (col0->getInterpolationWorldTransform().getOrigin() - col0->getWorldTransform().getOrigin()).length2();
-	float squareMot1 = (col1->getInterpolationWorldTransform().getOrigin() - col1->getWorldTransform().getOrigin()).length2();
+	btScalar squareMot0 = (col0->getInterpolationWorldTransform().getOrigin() - col0->getWorldTransform().getOrigin()).length2();
+	btScalar squareMot1 = (col1->getInterpolationWorldTransform().getOrigin() - col1->getWorldTransform().getOrigin()).length2();
    
 	if (squareMot0 < col0->getCcdSquareMotionThreshold() &&
 		squareMot1 < col1->getCcdSquareMotionThreshold())
 		return resultFraction;

 	if (disableCcd)
-		return 1.f;
+		return btScalar(1.);


 	//An adhoc way of testing the Continuous Collision Detection algorithms
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h
@@ -16,11 +16,11 @@ subject to the following restrictions:
 #ifndef CONVEX_CONVEX_ALGORITHM_H
 #define CONVEX_CONVEX_ALGORITHM_H

-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
-#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
-#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
-#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+#include "../BroadphaseCollision/btCollisionAlgorithm.h"
+#include "../NarrowPhaseCollision/btGjkPairDetector.h"
+#include "../NarrowPhaseCollision/btPersistentManifold.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h"
+#include "../NarrowPhaseCollision/btVoronoiSimplexSolver.h"
 #include "btCollisionCreateFunc.h"

 class btConvexPenetrationDepthSolver;
@@ -44,7 +44,7 @@ public:

 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

 	void	setLowLevelOfDetail(bool useLowLevel);

@@ -62,6 +62,7 @@ public:
 		
 		CreateFunc(btSimplexSolverInterface*			simplexSolver, btConvexPenetrationDepthSolver* pdSolver);
 		CreateFunc();
+		virtual ~CreateFunc();

 		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
 		{
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp
@@ -22,14 +22,13 @@ btEmptyAlgorithm::btEmptyAlgorithm(const btCollisionAlgorithmConstructionInfo& c
 {
 }

-void btEmptyAlgorithm::processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+void btEmptyAlgorithm::processCollision (btCollisionObject* ,btCollisionObject* ,const btDispatcherInfo& ,btManifoldResult* )
 {
-
 }

-float btEmptyAlgorithm::calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btEmptyAlgorithm::calculateTimeOfImpact(btCollisionObject* ,btCollisionObject* ,const btDispatcherInfo& ,btManifoldResult* )
 {
-	return 1.f;
+	return btScalar(1.);
 }


--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h
@@ -15,7 +15,7 @@ subject to the following restrictions:

 #ifndef EMPTY_ALGORITH
 #define EMPTY_ALGORITH
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "../BroadphaseCollision/btCollisionAlgorithm.h"
 #include "btCollisionCreateFunc.h"

 #define ATTRIBUTE_ALIGNED(a)
@@ -31,12 +31,14 @@ public:

 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

 	struct CreateFunc :public 	btCollisionAlgorithmCreateFunc
 	{
 		virtual	btCollisionAlgorithm* CreateCollisionAlgorithm(btCollisionAlgorithmConstructionInfo& ci, btCollisionObject* body0,btCollisionObject* body1)
 		{
+			(void)body0;
+			(void)body1;
 			return new btEmptyAlgorithm(ci);
 		}
 	};
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btManifoldResult.cpp
@@ -27,7 +27,7 @@ inline btScalar	calculateCombinedFriction(const btCollisionObject* body0,const b
 {
 	btScalar friction = body0->getFriction() * body1->getFriction();

-	const btScalar MAX_FRICTION  = 10.f;
+	const btScalar MAX_FRICTION  = btScalar(10.);
 	if (friction < -MAX_FRICTION)
 		friction = -MAX_FRICTION;
 	if (friction > MAX_FRICTION)
@@ -53,7 +53,7 @@ btManifoldResult::btManifoldResult(btCollisionObject* body0,btCollisionObject* b
 }


-void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
+void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
 {
 	assert(m_manifoldPtr);
 	//order in manifold needs to match
@@ -63,15 +63,22 @@ void btManifoldResult::addContactPoint(const btVector3& normalOnBInWorld,const b

 	bool isSwapped = m_manifoldPtr->getBody0() != m_body0;

-	btTransform transAInv = isSwapped? m_rootTransB.inverse() : m_rootTransA.inverse();
-	btTransform transBInv = isSwapped? m_rootTransA.inverse() : m_rootTransB.inverse();
-
 	btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
-	btVector3 localA = transAInv(pointA );
-	btVector3 localB = transBInv(pointInWorld);
-	btManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);

+	btVector3 localA;
+	btVector3 localB;
 	
+	if (isSwapped)
+	{
+		localA = m_rootTransB.invXform(pointA );
+		localB = m_rootTransA.invXform(pointInWorld);
+	} else
+	{
+		localA = m_rootTransA.invXform(pointA );
+		localB = m_rootTransB.invXform(pointInWorld);
+	}
+
+	btManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);

 	int insertIndex = m_manifoldPtr->getCacheEntry(newPt);

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btManifoldResult.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btManifoldResult.h
@@ -23,7 +23,7 @@ class btManifoldPoint;

 #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"

-#include "LinearMath/btTransform.h"
+#include "../../LinearMath/btTransform.h"

 typedef bool (*ContactAddedCallback)(btManifoldPoint& cp,	const btCollisionObject* colObj0,int partId0,int index0,const btCollisionObject* colObj1,int partId1,int index1);
 extern ContactAddedCallback		gContactAddedCallback;
@@ -68,7 +68,7 @@ public:
 			m_index1=index1;		
 	}

-	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth);
+	virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth);



--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
@@ -8,8 +8,7 @@
 #include "BulletCollision/CollisionDispatch/btCollisionWorld.h"

 #include <stdio.h>
-#include <algorithm>
-
+#include "LinearMath/btQuickprof.h"

 btSimulationIslandManager::btSimulationIslandManager()
 {
@@ -33,7 +32,7 @@ void btSimulationIslandManager::findUnions(btDispatcher* dispatcher)
 		for (int i=0;i<dispatcher->getNumManifolds();i++)
 		{
 			const btPersistentManifold* manifold = dispatcher->getManifoldByIndexInternal(i);
-			//static objects (invmass 0.f) don't merge !
+			//static objects (invmass btScalar(0.)) don't merge !

 			 const  btCollisionObject* colObj0 = static_cast<const btCollisionObject*>(manifold->getBody0());
 			 const  btCollisionObject* colObj1 = static_cast<const btCollisionObject*>(manifold->getBody1());
@@ -57,16 +56,15 @@ void	btSimulationIslandManager::updateActivationState(btCollisionWorld* colWorld
 	
 	// put the index into m_controllers into m_tag	
 	{
-		std::vector<btCollisionObject*>::iterator i;
 		
 		int index = 0;
-		for (i=colWorld->getCollisionObjectArray().begin();
-		!(i==colWorld->getCollisionObjectArray().end()); i++)
+		int i;
+		for (i=0;i<colWorld->getCollisionObjectArray().size(); i++)
 		{
-			
-			btCollisionObject*	collisionObject= (*i);
+			btCollisionObject*	collisionObject= colWorld->getCollisionObjectArray()[i];
 			collisionObject->setIslandTag(index);
-			collisionObject->setHitFraction(1.f);
+			collisionObject->setCompanionId(-1);
+			collisionObject->setHitFraction(btScalar(1.));
 			index++;
 			
 		}
@@ -88,20 +86,19 @@ void	btSimulationIslandManager::storeIslandActivationState(btCollisionWorld* col
 	{
 		
 		
-		std::vector<btCollisionObject*>::iterator i;
-		
 		int index = 0;
-		for (i=colWorld->getCollisionObjectArray().begin();
-		!(i==colWorld->getCollisionObjectArray().end()); i++)
+		int i;
+		for (i=0;i<colWorld->getCollisionObjectArray().size();i++)
 		{
-			btCollisionObject* collisionObject= (*i);
-			
+			btCollisionObject* collisionObject= colWorld->getCollisionObjectArray()[i];
 			if (collisionObject->mergesSimulationIslands())
 			{
 				collisionObject->setIslandTag( m_unionFind.find(index) );
+				collisionObject->setCompanionId(-1);
 			} else
 			{
 				collisionObject->setIslandTag(-1);
+				collisionObject->setCompanionId(-2);
 			}
 			index++;
 		}
@@ -118,13 +115,21 @@ inline	int	getIslandId(const btPersistentManifold* lhs)

 }

-bool btPersistentManifoldSortPredicate(const btPersistentManifold* lhs, const btPersistentManifold* rhs)
+
+
+/// function object that routes calls to operator<
+class btPersistentManifoldSortPredicate
 {
-	int rIslandId0,lIslandId0;
-	rIslandId0 = getIslandId(rhs);
-	lIslandId0 = getIslandId(lhs);
-	return lIslandId0 < rIslandId0;
-}
+	public:
+
+		SIMD_FORCE_INLINE bool operator() ( const btPersistentManifold* lhs, const btPersistentManifold* rhs )
+		{
+			return getIslandId(lhs) < getIslandId(rhs);
+		}
+};
+
+
+


 //
@@ -132,6 +137,22 @@ bool btPersistentManifoldSortPredicate(const btPersistentManifold* lhs, const bt
 //
 void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback)
 {
+
+	
+	
+	/*if (0)
+	{
+		int maxNumManifolds = dispatcher->getNumManifolds();
+		btCollisionDispatcher* colDis = (btCollisionDispatcher*)dispatcher;
+		btPersistentManifold** manifold = colDis->getInternalManifoldPointer();
+		callback->ProcessIsland(&collisionObjects[0],collisionObjects.size(),manifold,maxNumManifolds, 0);
+		return;
+	}
+	*/
+
+
+	BEGIN_PROFILE("islandUnionFindAndHeapSort");
+	
 	//we are going to sort the unionfind array, and store the element id in the size
 	//afterwards, we clean unionfind, to make sure no-one uses it anymore
 	
@@ -139,9 +160,11 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 	int numElem = getUnionFind().getNumElements();

 	int endIslandIndex=1;
+	int startIslandIndex;
+

 	//update the sleeping state for bodies, if all are sleeping
-	for (int startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
+	for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
 	{
 		int islandId = getUnionFind().getElement(startIslandIndex).m_id;
 		for (endIslandIndex = startIslandIndex+1;(endIslandIndex<numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
@@ -224,7 +247,7 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 		}
 	}

-	std::vector<btPersistentManifold*>  islandmanifold;
+	btAlignedObjectArray<btPersistentManifold*>  islandmanifold;
 	int i;
 	int maxNumManifolds = dispatcher->getNumManifolds();
 	islandmanifold.reserve(maxNumManifolds);
@@ -261,63 +284,74 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,

 	// Sort manifolds, based on islands
 	// Sort the vector using predicate and std::sort
-	std::sort(islandmanifold.begin(), islandmanifold.end(), btPersistentManifoldSortPredicate);
+	//std::sort(islandmanifold.begin(), islandmanifold.end(), btPersistentManifoldSortPredicate);
+
+	//we should do radix sort, it it much faster (O(n) instead of O (n log2(n))
+	islandmanifold.heapSort(btPersistentManifoldSortPredicate());

 	//now process all active islands (sets of manifolds for now)

 	int startManifoldIndex = 0;
 	int endManifoldIndex = 1;

-	int islandId;
+	//int islandId;
+
+	END_PROFILE("islandUnionFindAndHeapSort");
+
+	btAlignedObjectArray<btCollisionObject*>	islandBodies;


-	 //traverse the simulation islands, and call the solver, unless all objects are sleeping/deactivated
-        for (int startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
-        {               
-                int islandId = getUnionFind().getElement(startIslandIndex).m_id;
-                                
-                                        
-               bool islandSleeping = false;
+	//traverse the simulation islands, and call the solver, unless all objects are sleeping/deactivated
+	for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
+	{
+		int islandId = getUnionFind().getElement(startIslandIndex).m_id;
+
+
+	       bool islandSleeping = false;
                
                for (endIslandIndex = startIslandIndex;(endIslandIndex<numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
                {
                        int i = getUnionFind().getElement(endIslandIndex).m_sz;
                        btCollisionObject* colObj0 = collisionObjects[i];
+						islandBodies.push_back(colObj0);
                        if (!colObj0->isActive())
                                islandSleeping = true;
                }
                

-                //find the accompanying contact manifold for this islandId
-                int numIslandManifolds = 0;
-                btPersistentManifold** startManifold = 0; 
+		//find the accompanying contact manifold for this islandId
+		int numIslandManifolds = 0;
+		btPersistentManifold** startManifold = 0;

-                if (startManifoldIndex<numManifolds)
-                {
-                        int curIslandId = getIslandId(islandmanifold[startManifoldIndex]);
-                        if (curIslandId == islandId)
-                        {
-                                startManifold = &islandmanifold[startManifoldIndex];
+		if (startManifoldIndex<numManifolds)
+		{
+			int curIslandId = getIslandId(islandmanifold[startManifoldIndex]);
+			if (curIslandId == islandId)
+			{
+				startManifold = &islandmanifold[startManifoldIndex];
+			
+				for (endManifoldIndex = startManifoldIndex+1;(endManifoldIndex<numManifolds) && (islandId == getIslandId(islandmanifold[endManifoldIndex]));endManifoldIndex++)
+				{

-                                for (endManifoldIndex = startManifoldIndex+1;(endManifoldIndex<numManifolds) && (islandId == getIslandId(islandmanifold[endManifoldIndex]));endManifoldIndex++)
-                                {
+				}
+				/// Process the actual simulation, only if not sleeping/deactivated
+				numIslandManifolds = endManifoldIndex-startManifoldIndex;
+			}

-                                }
-                                /// Process the actual simulation, only if not sleeping/deactivated
-                                numIslandManifolds = endManifoldIndex-startManifoldIndex;
-                        }
+		}

-                }
+		if (!islandSleeping)
+		{
+			callback->ProcessIsland(&islandBodies[0],islandBodies.size(),startManifold,numIslandManifolds, islandId);
+		}
+		
+		if (numIslandManifolds)
+		{
+			startManifoldIndex = endManifoldIndex;
+		}

-                if (!islandSleeping)
-                {
-                        callback->ProcessIsland(startManifold,numIslandManifolds, islandId);
-                }
-
-                if (numIslandManifolds)
-                {
-                        startManifoldIndex = endManifoldIndex;
-                }
-        }
+		islandBodies.resize(0);
+	}

+	
 }
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h
@@ -16,9 +16,10 @@ subject to the following restrictions:
 #ifndef SIMULATION_ISLAND_MANAGER_H
 #define SIMULATION_ISLAND_MANAGER_H

-#include "BulletCollision/CollisionDispatch/btUnionFind.h"
+#include "../CollisionDispatch/btUnionFind.h"
 #include "btCollisionCreateFunc.h"

+class btCollisionObject;
 class btCollisionWorld;
 class btDispatcher;

@@ -49,7 +50,7 @@ public:
 	{
 		virtual ~IslandCallback() {};

-		virtual	void	ProcessIsland(class btPersistentManifold**	manifolds,int numManifolds, int islandId) = 0;
+		virtual	void	ProcessIsland(btCollisionObject** bodies,int numBodies,class btPersistentManifold**	manifolds,int numManifolds, int islandId) = 0;
 	};

 	void	buildAndProcessIslands(btDispatcher* dispatcher,btCollisionObjectArray& collisionObjects, IslandCallback* callback);
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp
@@ -50,6 +50,8 @@ btSphereBoxCollisionAlgorithm::~btSphereBoxCollisionAlgorithm()

 void btSphereBoxCollisionAlgorithm::processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
+	(void)dispatchInfo;
+	(void)resultOut;
 	if (!m_manifoldPtr)
 		return;

@@ -64,7 +66,7 @@ void btSphereBoxCollisionAlgorithm::processCollision (btCollisionObject* body0,b
 	btVector3 sphereCenter = sphereObj->getWorldTransform().getOrigin();
 	btScalar radius = sphere0->getRadius();
 	
-	float dist = getSphereDistance(boxObj,pOnBox,pOnSphere,sphereCenter,radius);
+	btScalar dist = getSphereDistance(boxObj,pOnBox,pOnSphere,sphereCenter,radius);

 	if (dist < SIMD_EPSILON)
 	{
@@ -81,10 +83,15 @@ void btSphereBoxCollisionAlgorithm::processCollision (btCollisionObject* body0,b

 }

-float btSphereBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btSphereBoxCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
+	(void)resultOut;
+	(void)dispatchInfo;
+	(void)col0;
+	(void)col1;
+
 	//not yet
-	return 1.f;
+	return btScalar(1.);
 }


@@ -117,14 +124,14 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 	/////////////////////////////////////////////////

 	btVector3	tmp, prel, n[6], normal, v3P;
-	btScalar   fSep = 10000000.0f, fSepThis;
+	btScalar   fSep = btScalar(10000000.0), fSepThis;

-	n[0].setValue( -1.0f,  0.0f,  0.0f );
-	n[1].setValue(  0.0f, -1.0f,  0.0f );
-	n[2].setValue(  0.0f,  0.0f, -1.0f );
-	n[3].setValue(  1.0f,  0.0f,  0.0f );
-	n[4].setValue(  0.0f,  1.0f,  0.0f );
-	n[5].setValue(  0.0f,  0.0f,  1.0f );
+	n[0].setValue( btScalar(-1.0),  btScalar(0.0),  btScalar(0.0) );
+	n[1].setValue(  btScalar(0.0), btScalar(-1.0),  btScalar(0.0) );
+	n[2].setValue(  btScalar(0.0),  btScalar(0.0), btScalar(-1.0) );
+	n[3].setValue(  btScalar(1.0),  btScalar(0.0),  btScalar(0.0) );
+	n[4].setValue(  btScalar(0.0),  btScalar(1.0),  btScalar(0.0) );
+	n[5].setValue(  btScalar(0.0),  btScalar(0.0),  btScalar(1.0) );

 	// convert  point in local space
 	prel = m44T.invXform( sphereCenter);
@@ -136,7 +143,7 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 	for (int i=0;i<6;i++)
 	{
 		int j = i<3? 0:1;
-		if ( (fSepThis = ((v3P-bounds[j]) .dot(n[i]))) > 0.0f )
+		if ( (fSepThis = ((v3P-bounds[j]) .dot(n[i]))) > btScalar(0.0) )
 		{
 			v3P = v3P - n[i]*fSepThis;		
 			bFound = true;
@@ -154,9 +161,9 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 		pointOnBox = v3P + normal*margins;
 		v3PointOnSphere = prel - normal*fRadius;

-		if ( ((v3PointOnSphere - pointOnBox) .dot (normal)) > 0.0f )
+		if ( ((v3PointOnSphere - pointOnBox) .dot (normal)) > btScalar(0.0) )
 		{
-			return 1.0f;
+			return btScalar(1.0);
 		}

 		// transform back in world space
@@ -171,7 +178,7 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 		{
 			fSep = - btSqrt(fSeps2);
 			normal = (pointOnBox-v3PointOnSphere);
-			normal *= 1.f/fSep;
+			normal *= btScalar(1.)/fSep;
 		}

 		return fSep;
@@ -185,10 +192,10 @@ btScalar btSphereBoxCollisionAlgorithm::getSphereDistance(btCollisionObject* box
 	bounds[0] = boundsVec[0];
 	bounds[1] = boundsVec[1];

-	if ( fPenetration <= 0.0f )
+	if ( fPenetration <= btScalar(0.0) )
 		return (fPenetration-margins);
 	else
-		return 1.0f;
+		return btScalar(1.0);
 }

 btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration( btCollisionObject* boxObj,btVector3& pointOnBox, btVector3& v3PointOnSphere, const btVector3& sphereCenter, btScalar fRadius, const btVector3& aabbMin, const btVector3& aabbMax) 
@@ -200,14 +207,14 @@ btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration( btCollisionObject*
 	bounds[1] = aabbMax;

 	btVector3	p0, tmp, prel, n[6], normal;
-	btScalar   fSep = -10000000.0f, fSepThis;
+	btScalar   fSep = btScalar(-10000000.0), fSepThis;

-	n[0].setValue( -1.0f,  0.0f,  0.0f );
-	n[1].setValue(  0.0f, -1.0f,  0.0f );
-	n[2].setValue(  0.0f,  0.0f, -1.0f );
-	n[3].setValue(  1.0f,  0.0f,  0.0f );
-	n[4].setValue(  0.0f,  1.0f,  0.0f );
-	n[5].setValue(  0.0f,  0.0f,  1.0f );
+	n[0].setValue( btScalar(-1.0),  btScalar(0.0),  btScalar(0.0) );
+	n[1].setValue(  btScalar(0.0), btScalar(-1.0),  btScalar(0.0) );
+	n[2].setValue(  btScalar(0.0),  btScalar(0.0), btScalar(-1.0) );
+	n[3].setValue(  btScalar(1.0),  btScalar(0.0),  btScalar(0.0) );
+	n[4].setValue(  btScalar(0.0),  btScalar(1.0),  btScalar(0.0) );
+	n[5].setValue(  btScalar(0.0),  btScalar(0.0),  btScalar(1.0) );

 	const btTransform&	m44T = boxObj->getWorldTransform();

@@ -219,7 +226,7 @@ btScalar btSphereBoxCollisionAlgorithm::getSpherePenetration( btCollisionObject*
 	for (int i=0;i<6;i++)
 	{
 		int j = i<3 ? 0:1;
-		if ( (fSepThis = ((prel-bounds[j]) .dot( n[i]))-fRadius) > 0.0f )	return 1.0f;
+		if ( (fSepThis = ((prel-bounds[j]) .dot( n[i]))-fRadius) > btScalar(0.0) )	return btScalar(1.0);
 		if ( fSepThis > fSep )
 		{
 			p0 = bounds[j];	normal = (btVector3&)n[i];
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h
@@ -16,11 +16,11 @@ subject to the following restrictions:
 #ifndef SPHERE_BOX_COLLISION_ALGORITHM_H
 #define SPHERE_BOX_COLLISION_ALGORITHM_H

-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
-#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "../BroadphaseCollision/btCollisionAlgorithm.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h"
+#include "../CollisionDispatch/btCollisionCreateFunc.h"
 class btPersistentManifold;
-#include "LinearMath/btVector3.h"
+#include "../../LinearMath/btVector3.h"

 /// btSphereBoxCollisionAlgorithm  provides sphere-box collision detection.
 /// Other features are frame-coherency (persistent data) and collision response.
@@ -38,7 +38,7 @@ public:

 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

 	btScalar getSphereDistance( btCollisionObject* boxObj,btVector3& v3PointOnBox, btVector3& v3PointOnSphere, const btVector3& v3SphereCenter, btScalar fRadius );

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp
@@ -41,6 +41,8 @@ btSphereSphereCollisionAlgorithm::~btSphereSphereCollisionAlgorithm()

 void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
+	(void)dispatchInfo;
+
 	if (!m_manifoldPtr)
 		return;

@@ -48,7 +50,7 @@ void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0
 	btSphereShape* sphere1 = (btSphereShape*)col1->getCollisionShape();

 	btVector3 diff = col0->getWorldTransform().getOrigin()-  col1->getWorldTransform().getOrigin();
-	float len = diff.length();
+	btScalar len = diff.length();
 	btScalar radius0 = sphere0->getRadius();
 	btScalar radius1 = sphere1->getRadius();

@@ -71,8 +73,13 @@ void btSphereSphereCollisionAlgorithm::processCollision (btCollisionObject* col0

 }

-float btSphereSphereCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btSphereSphereCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
+	(void)col0;
+	(void)col1;
+	(void)dispatchInfo;
+	(void)resultOut;
+
 	//not yet
-	return 1.f;
+	return btScalar(1.);
 }
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h
@@ -16,9 +16,9 @@ subject to the following restrictions:
 #ifndef SPHERE_SPHERE_COLLISION_ALGORITHM_H
 #define SPHERE_SPHERE_COLLISION_ALGORITHM_H

-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
-#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "../BroadphaseCollision/btCollisionAlgorithm.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h"
+#include "../CollisionDispatch/btCollisionCreateFunc.h"
 class btPersistentManifold;

 /// btSphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
@@ -37,7 +37,7 @@ public:

 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

 	
 	virtual ~btSphereSphereCollisionAlgorithm();
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp
@@ -56,7 +56,7 @@ void btSphereTriangleCollisionAlgorithm::processCollision (btCollisionObject* co
 	SphereTriangleDetector detector(sphere,triangle);
 	
 	btDiscreteCollisionDetectorInterface::ClosestPointInput input;
-	input.m_maximumDistanceSquared = 1e30f;//todo: tighter bounds
+	input.m_maximumDistanceSquared = btScalar(1e30);//todo: tighter bounds
 	input.m_transformA = col0->getWorldTransform();
 	input.m_transformB = col1->getWorldTransform();

@@ -64,8 +64,13 @@ void btSphereTriangleCollisionAlgorithm::processCollision (btCollisionObject* co

 }

-float btSphereTriangleCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
+btScalar btSphereTriangleCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* col0,btCollisionObject* col1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
 {
+	(void)resultOut;
+	(void)dispatchInfo;
+	(void)col0;
+	(void)col1;
+
 	//not yet
-	return 1.f;
+	return btScalar(1.);
 }
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h
@@ -16,9 +16,9 @@ subject to the following restrictions:
 #ifndef SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
 #define SPHERE_TRIANGLE_COLLISION_ALGORITHM_H

-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
-#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+#include "../BroadphaseCollision/btCollisionAlgorithm.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h"
+#include "../CollisionDispatch/btCollisionCreateFunc.h"
 class btPersistentManifold;

 /// btSphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
@@ -38,7 +38,7 @@ public:

 	virtual void processCollision (btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

-	virtual float calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);
+	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut);

 	
 	virtual ~btSphereTriangleCollisionAlgorithm();
--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btUnionFind.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btUnionFind.cpp
@@ -15,7 +15,6 @@ subject to the following restrictions:

 #include "btUnionFind.h"
 #include <assert.h>
-#include <algorithm>



@@ -50,11 +49,16 @@ void	btUnionFind::reset(int N)
 	} 
 }

-bool btUnionFindElementSortPredicate(const btElement& lhs, const btElement& rhs)
-{
-	return lhs.m_id < rhs.m_id;
-}

+class btUnionFindElementSortPredicate
+{
+	public:
+
+		bool operator() ( const btElement& lhs, const btElement& rhs )
+		{
+			return lhs.m_id < rhs.m_id;
+		}
+};

 ///this is a special operation, destroying the content of btUnionFind.
 ///it sorts the elements, based on island id, in order to make it easy to iterate over islands
@@ -71,7 +75,9 @@ void	btUnionFind::sortIslands()
 	}
 	
 	 // Sort the vector using predicate and std::sort
-	  std::sort(m_elements.begin(), m_elements.end(), btUnionFindElementSortPredicate);
+	  //std::sort(m_elements.begin(), m_elements.end(), btUnionFindElementSortPredicate);
+	//perhaps use radix sort?
+	  m_elements.heapSort(btUnionFindElementSortPredicate());

 }

--- a/extern/bullet2/src/BulletCollision/CollisionDispatch/btUnionFind.h
+++ b/extern/bullet2/src/BulletCollision/CollisionDispatch/btUnionFind.h
@@ -16,7 +16,10 @@ subject to the following restrictions:
 #ifndef UNION_FIND_H
 #define UNION_FIND_H

-#include <vector>
+#include "../../LinearMath/btAlignedObjectArray.h"
+
+	#define USE_PATH_COMPRESSION 1
+
 struct	btElement
 {
 	int	m_id;
@@ -29,7 +32,7 @@ struct	btElement
 class btUnionFind
  {
    private:
-		std::vector<btElement>	m_elements;
+		btAlignedObjectArray<btElement>	m_elements;

    public:
 	  
@@ -78,6 +81,7 @@ class btUnionFind
 			if (i == j) 
 				return;

+#ifndef USE_PATH_COMPRESSION
 			//weighted quick union, this keeps the 'trees' balanced, and keeps performance of unite O( log(n) )
 			if (m_elements[i].m_sz < m_elements[j].m_sz)
 			{ 
@@ -87,6 +91,9 @@ class btUnionFind
 			{ 
 				m_elements[j].m_id = i; m_elements[i].m_sz += m_elements[j].m_sz; 
 			}
+#else
+			m_elements[i].m_id = j; m_elements[j].m_sz += m_elements[i].m_sz; 
+#endif //USE_PATH_COMPRESSION
 		}

 		int find(int x)
@@ -97,7 +104,7 @@ class btUnionFind
 			while (x != m_elements[x].m_id) 
 			{
 		//not really a reason not to use path compression, and it flattens the trees/improves find performance dramatically
-		#define USE_PATH_COMPRESSION 1
+	
 		#ifdef USE_PATH_COMPRESSION
 				//
 				m_elements[x].m_id = m_elements[m_elements[x].m_id].m_id;
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btBoxShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btBoxShape.cpp
@@ -42,17 +42,16 @@ void btBoxShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabb

 void	btBoxShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 {
-	//float margin = 0.f;
+	//btScalar margin = btScalar(0.);
 	btVector3 halfExtents = getHalfExtents();

-	btScalar lx=2.f*(halfExtents.x());
-	btScalar ly=2.f*(halfExtents.y());
-	btScalar lz=2.f*(halfExtents.z());
-
-	inertia[0] = mass/(12.0f) * (ly*ly + lz*lz);
-	inertia[1] = mass/(12.0f) * (lx*lx + lz*lz);
-	inertia[2] = mass/(12.0f) * (lx*lx + ly*ly);
+	btScalar lx=btScalar(2.)*(halfExtents.x());
+	btScalar ly=btScalar(2.)*(halfExtents.y());
+	btScalar lz=btScalar(2.)*(halfExtents.z());

+	inertia.setValue(mass/(btScalar(12.0)) * (ly*ly + lz*lz),
+					mass/(btScalar(12.0)) * (lx*lx + lz*lz),
+					mass/(btScalar(12.0)) * (lx*lx + ly*ly));

 }

--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btBoxShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btBoxShape.h
@@ -17,10 +17,10 @@ subject to the following restrictions:
 #define OBB_BOX_MINKOWSKI_H

 #include "btPolyhedralConvexShape.h"
-#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
-#include "LinearMath/btPoint3.h"
-#include "LinearMath/btSimdMinMax.h"
+#include "btCollisionMargin.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h"
+#include "../../LinearMath/btPoint3.h"
+#include "../../LinearMath/btSimdMinMax.h"

 ///btBoxShape implements both a feature based (vertex/edge/plane) and implicit (getSupportingVertex) Box
 class btBoxShape: public btPolyhedralConvexShape
@@ -41,9 +41,9 @@ public:
 		btVector3 halfExtents = getHalfExtents();
 		
 		btVector3 supVertex;
-		supVertex = btPoint3(vec.x() < btScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
-                     vec.y() < btScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
-                     vec.z() < btScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
+		supVertex = btPoint3(vec.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
+                     vec.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
+                     vec.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z()); 
  
 		return supVertex;
 	}
@@ -54,9 +54,9 @@ public:
 		btVector3 margin(getMargin(),getMargin(),getMargin());
 		halfExtents -= margin;

-		return btVector3(vec.x() < btScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
-                    vec.y() < btScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
-                    vec.z() < btScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
+		return btVector3(vec.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
+                    vec.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
+                    vec.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z()); 
 	}

 	virtual void	batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
@@ -69,9 +69,9 @@ public:
 		for (int i=0;i<numVectors;i++)
 		{
 			const btVector3& vec = vectors[i];
-			supportVerticesOut[i].setValue(vec.x() < btScalar(0.0f) ? -halfExtents.x() : halfExtents.x(),
-                    vec.y() < btScalar(0.0f) ? -halfExtents.y() : halfExtents.y(),
-                    vec.z() < btScalar(0.0f) ? -halfExtents.z() : halfExtents.z()); 
+			supportVerticesOut[i].setValue(vec.x() < btScalar(0.0) ? -halfExtents.x() : halfExtents.x(),
+                    vec.y() < btScalar(0.0) ? -halfExtents.y() : halfExtents.y(),
+                    vec.z() < btScalar(0.0) ? -halfExtents.z() : halfExtents.z()); 
 		}

 	}
@@ -132,27 +132,27 @@ public:
 		switch (i)
 		{
 		case 0:
-			plane.setValue(1.f,0.f,0.f);
+			plane.setValue(btScalar(1.),btScalar(0.),btScalar(0.));
 			plane[3] = -halfExtents.x();
 			break;
 		case 1:
-			plane.setValue(-1.f,0.f,0.f);
+			plane.setValue(btScalar(-1.),btScalar(0.),btScalar(0.));
 			plane[3] = -halfExtents.x();
 			break;
 		case 2:
-			plane.setValue(0.f,1.f,0.f);
+			plane.setValue(btScalar(0.),btScalar(1.),btScalar(0.));
 			plane[3] = -halfExtents.y();
 			break;
 		case 3:
-			plane.setValue(0.f,-1.f,0.f);
+			plane.setValue(btScalar(0.),btScalar(-1.),btScalar(0.));
 			plane[3] = -halfExtents.y();
 			break;
 		case 4:
-			plane.setValue(0.f,0.f,1.f);
+			plane.setValue(btScalar(0.),btScalar(0.),btScalar(1.));
 			plane[3] = -halfExtents.z();
 			break;
 		case 5:
-			plane.setValue(0.f,0.f,-1.f);
+			plane.setValue(btScalar(0.),btScalar(0.),btScalar(-1.));
 			plane[3] = -halfExtents.z();
 			break;
 		default:
@@ -265,22 +265,22 @@ public:
 		switch (index)
 		{
 		case 0:
-			penetrationVector.setValue(1.f,0.f,0.f);
+			penetrationVector.setValue(btScalar(1.),btScalar(0.),btScalar(0.));
 			break;
 		case 1:
-			penetrationVector.setValue(-1.f,0.f,0.f);
+			penetrationVector.setValue(btScalar(-1.),btScalar(0.),btScalar(0.));
 			break;
 		case 2:
-			penetrationVector.setValue(0.f,1.f,0.f);
+			penetrationVector.setValue(btScalar(0.),btScalar(1.),btScalar(0.));
 			break;
 		case 3:
-			penetrationVector.setValue(0.f,-1.f,0.f);
+			penetrationVector.setValue(btScalar(0.),btScalar(-1.),btScalar(0.));
 			break;
 		case 4:
-			penetrationVector.setValue(0.f,0.f,1.f);
+			penetrationVector.setValue(btScalar(0.),btScalar(0.),btScalar(1.));
 			break;
 		case 5:
-			penetrationVector.setValue(0.f,0.f,-1.f);
+			penetrationVector.setValue(btScalar(0.),btScalar(0.),btScalar(-1.));
 			break;
 		default:
 			assert(0);
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
@@ -18,21 +18,53 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
 #include "BulletCollision/CollisionShapes/btOptimizedBvh.h"

+
 ///Bvh Concave triangle mesh is a static-triangle mesh shape with Bounding Volume Hierarchy optimization.
 ///Uses an interface to access the triangles to allow for sharing graphics/physics triangles.
-btBvhTriangleMeshShape::btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface)
-:btTriangleMeshShape(meshInterface)
+btBvhTriangleMeshShape::btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression)
+:btTriangleMeshShape(meshInterface),m_useQuantizedAabbCompression(useQuantizedAabbCompression)
 {
 	//construct bvh from meshInterface
 #ifndef DISABLE_BVH

 	m_bvh = new btOptimizedBvh();
-	m_bvh->build(meshInterface);
+	btVector3 bvhAabbMin,bvhAabbMax;
+	meshInterface->calculateAabbBruteForce(bvhAabbMin,bvhAabbMax);
+	m_bvh->build(meshInterface,m_useQuantizedAabbCompression,bvhAabbMin,bvhAabbMax);

 #endif //DISABLE_BVH

 }

+btBvhTriangleMeshShape::btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression,const btVector3& bvhAabbMin,const btVector3& bvhAabbMax)
+:btTriangleMeshShape(meshInterface),m_useQuantizedAabbCompression(useQuantizedAabbCompression)
+{
+	//construct bvh from meshInterface
+#ifndef DISABLE_BVH
+
+	m_bvh = new btOptimizedBvh();
+	m_bvh->build(meshInterface,m_useQuantizedAabbCompression,bvhAabbMin,bvhAabbMax);
+
+#endif //DISABLE_BVH
+
+}
+
+void	btBvhTriangleMeshShape::partialRefitTree(const btVector3& aabbMin,const btVector3& aabbMax)
+{
+	m_bvh->refitPartial( m_meshInterface,aabbMin,aabbMax );
+	
+	m_localAabbMin.setMin(aabbMin);
+	m_localAabbMax.setMax(aabbMax);
+}
+
+
+void	btBvhTriangleMeshShape::refitTree()
+{
+	m_bvh->refit( m_meshInterface );
+	
+	recalcLocalAabb();
+}
+
 btBvhTriangleMeshShape::~btBvhTriangleMeshShape()
 {
 	delete m_bvh;
@@ -63,7 +95,7 @@ void	btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback,co
 		{
 		}
 				
-		virtual void processNode(const btOptimizedBvhNode* node)
+		virtual void processNode(int nodeSubPart, int nodeTriangleIndex)
 		{
 			const unsigned char *vertexbase;
 			int numverts;
@@ -84,19 +116,21 @@ void	btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback,co
 				indexstride,
 				numfaces,
 				indicestype,
-				node->m_subPart);
+				nodeSubPart);

-			int* gfxbase = (int*)(indexbase+node->m_triangleIndex*indexstride);
-			
+			int* gfxbase = (int*)(indexbase+nodeTriangleIndex*indexstride);
+	
 			const btVector3& meshScaling = m_meshInterface->getScaling();
 			for (int j=2;j>=0;j--)
 			{
 				
 				int graphicsindex = gfxbase[j];
+
+
 #ifdef DEBUG_TRIANGLE_MESH
 				printf("%d ,",graphicsindex);
 #endif //DEBUG_TRIANGLE_MESH
-				float* graphicsbase = (float*)(vertexbase+graphicsindex*stride);
+				btScalar* graphicsbase = (btScalar*)(vertexbase+graphicsindex*stride);

 				m_triangle[j] = btVector3(
 					graphicsbase[0]*meshScaling.getX(),
@@ -107,8 +141,8 @@ void	btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback,co
 #endif //DEBUG_TRIANGLE_MESH
 			}

-			m_callback->processTriangle(m_triangle,node->m_subPart,node->m_triangleIndex);
-			m_meshInterface->unLockReadOnlyVertexBase(node->m_subPart);
+			m_callback->processTriangle(m_triangle,nodeSubPart,nodeTriangleIndex);
+			m_meshInterface->unLockReadOnlyVertexBase(nodeSubPart);
 		}

 	};
@@ -130,8 +164,10 @@ void	btBvhTriangleMeshShape::setLocalScaling(const btVector3& scaling)
 	{
 		btTriangleMeshShape::setLocalScaling(scaling);
 		delete m_bvh;
+		///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work
 		m_bvh = new btOptimizedBvh();
-		m_bvh->build(m_meshInterface);
 		//rebuild the bvh...
+		m_bvh->build(m_meshInterface,m_useQuantizedAabbCompression,m_localAabbMin,m_localAabbMax);
+
 	}
 }
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
@@ -16,20 +16,26 @@ subject to the following restrictions:
 #ifndef BVH_TRIANGLE_MESH_SHAPE_H
 #define BVH_TRIANGLE_MESH_SHAPE_H

-#include "BulletCollision/CollisionShapes/btTriangleMeshShape.h"
-#include "BulletCollision/CollisionShapes/btOptimizedBvh.h"
+#include "btTriangleMeshShape.h"
+#include "btOptimizedBvh.h"

 ///Bvh Concave triangle mesh is a static-triangle mesh shape with Bounding Volume Hierarchy optimization.
 ///Uses an interface to access the triangles to allow for sharing graphics/physics triangles.
-class btBvhTriangleMeshShape : public btTriangleMeshShape
+ATTRIBUTE_ALIGNED16(class) btBvhTriangleMeshShape : public btTriangleMeshShape
 {

 	btOptimizedBvh*	m_bvh;
-	
-	
-public:
-	btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface);
+	bool m_useQuantizedAabbCompression;
+	bool m_pad[12];////need padding due to alignment

+public:
+
+	btBvhTriangleMeshShape() :btTriangleMeshShape(0) {};
+	btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression);
+
+	///optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb
+	btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression,const btVector3& bvhAabbMin,const btVector3& bvhAabbMax);
+	
 	virtual ~btBvhTriangleMeshShape();

 	
@@ -44,6 +50,10 @@ public:

 	virtual void	processAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const;

+	void	refitTree();
+
+	///for a fast incremental refit of parts of the tree. Note: the entire AABB of the tree will become more conservative, it never shrinks
+	void	partialRefitTree(const btVector3& aabbMin,const btVector3& aabbMax);

 	//debugging
 	virtual char*	getName()const {return "BVHTRIANGLEMESH";}
@@ -51,8 +61,15 @@ public:

 	virtual void	setLocalScaling(const btVector3& scaling);
 	
-
-
-};
+	btOptimizedBvh*	getOptimizedBvh()
+	{
+		return m_bvh;
+	}
+	bool	usesQuantizedAabbCompression() const
+	{
+		return	m_useQuantizedAabbCompression;
+	}
+}
+;

 #endif //BVH_TRIANGLE_MESH_SHAPE_H
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCapsuleShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCapsuleShape.cpp
@@ -0,0 +1,146 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "btCapsuleShape.h"
+
+#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
+#include "LinearMath/btQuaternion.h"
+
+btCapsuleShape::btCapsuleShape(btScalar radius, btScalar height)
+{
+	m_implicitShapeDimensions.setValue(radius,0.5f*height,radius);
+}
+
+ 
+ btVector3	btCapsuleShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0)const
+{
+
+	btVector3 supVec(0,0,0);
+
+	btScalar maxDot(btScalar(-1e30));
+
+	btVector3 vec = vec0;
+	btScalar lenSqr = vec.length2();
+	if (lenSqr < btScalar(0.0001))
+	{
+		vec.setValue(1,0,0);
+	} else
+	{
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
+		vec *= rlen;
+	}
+
+	btVector3 vtx;
+	btScalar newDot;
+	
+	btScalar radius = getRadius();
+
+
+	{
+		btVector3 pos(0,getHalfHeight(),0);
+		vtx = pos +vec*m_localScaling*(radius) - vec * getMargin();
+		newDot = vec.dot(vtx);
+		if (newDot > maxDot)
+		{
+			maxDot = newDot;
+			supVec = vtx;
+		}
+	}
+	{
+		btVector3 pos(0,-getHalfHeight(),0);
+		vtx = pos +vec*m_localScaling*(radius) - vec * getMargin();
+		newDot = vec.dot(vtx);
+		if (newDot > maxDot)
+		{
+			maxDot = newDot;
+			supVec = vtx;
+		}
+	}
+
+	return supVec;
+
+}
+
+ void	btCapsuleShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
+{
+
+	
+	btScalar radius = getRadius();
+
+	for (int j=0;j<numVectors;j++)
+	{
+		btScalar maxDot(btScalar(-1e30));
+		const btVector3& vec = vectors[j];
+
+		btVector3 vtx;
+		btScalar newDot;
+		{
+			btVector3 pos(0,getHalfHeight(),0);
+			vtx = pos +vec*m_localScaling*(radius) - vec * getMargin();
+			newDot = vec.dot(vtx);
+			if (newDot > maxDot)
+			{
+				maxDot = newDot;
+				supportVerticesOut[j] = vtx;
+			}
+		}
+		{
+			btVector3 pos(0,-getHalfHeight(),0);
+			vtx = pos +vec*m_localScaling*(radius) - vec * getMargin();
+			newDot = vec.dot(vtx);
+			if (newDot > maxDot)
+			{
+				maxDot = newDot;
+				supportVerticesOut[j] = vtx;
+			}
+		}
+		
+	}
+}
+
+
+void	btCapsuleShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
+{
+	//as an approximation, take the inertia of the box that bounds the spheres
+
+	btTransform ident;
+	ident.setIdentity();
+
+	
+	btScalar radius = getRadius();
+
+	btVector3 halfExtents(radius,radius+getHalfHeight(),radius);
+
+	btScalar margin = CONVEX_DISTANCE_MARGIN;
+
+	btScalar lx=btScalar(2.)*(halfExtents[0]+margin);
+	btScalar ly=btScalar(2.)*(halfExtents[1]+margin);
+	btScalar lz=btScalar(2.)*(halfExtents[2]+margin);
+	const btScalar x2 = lx*lx;
+	const btScalar y2 = ly*ly;
+	const btScalar z2 = lz*lz;
+	const btScalar scaledmass = mass * btScalar(.08333333);
+
+	inertia[0] = scaledmass * (y2+z2);
+	inertia[1] = scaledmass * (x2+z2);
+	inertia[2] = scaledmass * (x2+y2);
+
+}
+
+
+
+
+
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCapsuleShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCapsuleShape.h
@@ -0,0 +1,60 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef BT_CAPSULE_SHAPE_H
+#define BT_CAPSULE_SHAPE_H
+
+#include "btConvexShape.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types
+
+
+///btCapsuleShape represents a capsule around the Y axis
+///A more general solution that can represent capsules is the btMultiSphereShape
+class btCapsuleShape : public btConvexShape
+{
+
+public:
+	btCapsuleShape(btScalar radius,btScalar height);
+
+	///CollisionShape Interface
+	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia);
+
+	/// btConvexShape Interface
+	virtual btVector3	localGetSupportingVertexWithoutMargin(const btVector3& vec)const;
+
+	virtual void	batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;
+	
+	virtual int	getShapeType() const { return CAPSULE_SHAPE_PROXYTYPE; }
+
+	virtual char*	getName()const 
+	{
+		return "CapsuleShape";
+	}
+
+	btScalar	getRadius() const
+	{
+		return m_implicitShapeDimensions.getX();
+	}
+
+	btScalar	getHalfHeight() const
+	{
+		return m_implicitShapeDimensions.getY();
+	}
+
+};
+
+
+
+#endif //BT_CAPSULE_SHAPE_H
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionMargin.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionMargin.h
@@ -18,7 +18,7 @@ subject to the following restrictions:

 //used by Gjk and some other algorithms

-#define CONVEX_DISTANCE_MARGIN 0.04f// 0.1f//;//0.01f
+#define CONVEX_DISTANCE_MARGIN btScalar(0.04)// btScalar(0.1)//;//btScalar(0.01)



--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionShape.cpp
@@ -15,6 +15,16 @@ subject to the following restrictions:

 #include "BulletCollision/CollisionShapes/btCollisionShape.h"

+
+/*
+  Make sure this dummy function never changes so that it
+  can be used by probes that are checking whether the
+  library is actually installed.
+*/
+extern "C" void btBulletCollisionProbe () {}
+
+
+
 void	btCollisionShape::getBoundingSphere(btVector3& center,btScalar& radius) const
 {
 	btTransform tr;
@@ -23,14 +33,14 @@ void	btCollisionShape::getBoundingSphere(btVector3& center,btScalar& radius) con

 	getAabb(tr,aabbMin,aabbMax);

-	radius = (aabbMax-aabbMin).length()*0.5f;
-	center = (aabbMin+aabbMax)*0.5f;
+	radius = (aabbMax-aabbMin).length()*btScalar(0.5);
+	center = (aabbMin+aabbMax)*btScalar(0.5);
 }

-float	btCollisionShape::getAngularMotionDisc() const
+btScalar	btCollisionShape::getAngularMotionDisc() const
 {
 	btVector3	center;
-	float disc;
+	btScalar disc;
 	getBoundingSphere(center,disc);
 	disc += (center).length();
 	return disc;
@@ -41,25 +51,25 @@ void btCollisionShape::calculateTemporalAabb(const btTransform& curTrans,const b
 	//start with static aabb
 	getAabb(curTrans,temporalAabbMin,temporalAabbMax);

-	float temporalAabbMaxx = temporalAabbMax.getX();
-	float temporalAabbMaxy = temporalAabbMax.getY();
-	float temporalAabbMaxz = temporalAabbMax.getZ();
-	float temporalAabbMinx = temporalAabbMin.getX();
-	float temporalAabbMiny = temporalAabbMin.getY();
-	float temporalAabbMinz = temporalAabbMin.getZ();
+	btScalar temporalAabbMaxx = temporalAabbMax.getX();
+	btScalar temporalAabbMaxy = temporalAabbMax.getY();
+	btScalar temporalAabbMaxz = temporalAabbMax.getZ();
+	btScalar temporalAabbMinx = temporalAabbMin.getX();
+	btScalar temporalAabbMiny = temporalAabbMin.getY();
+	btScalar temporalAabbMinz = temporalAabbMin.getZ();

 	// add linear motion
 	btVector3 linMotion = linvel*timeStep;
 	//todo: simd would have a vector max/min operation, instead of per-element access
-	if (linMotion.x() > 0.f)
+	if (linMotion.x() > btScalar(0.))
 		temporalAabbMaxx += linMotion.x(); 
 	else
 		temporalAabbMinx += linMotion.x();
-	if (linMotion.y() > 0.f)
+	if (linMotion.y() > btScalar(0.))
 		temporalAabbMaxy += linMotion.y(); 
 	else
 		temporalAabbMiny += linMotion.y();
-	if (linMotion.z() > 0.f)
+	if (linMotion.z() > btScalar(0.))
 		temporalAabbMaxz += linMotion.z(); 
 	else
 		temporalAabbMinz += linMotion.z();
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionShape.h
@@ -16,18 +16,18 @@ subject to the following restrictions:
 #ifndef COLLISION_SHAPE_H
 #define COLLISION_SHAPE_H

-#include "LinearMath/btTransform.h"
-#include "LinearMath/btVector3.h"
-#include <LinearMath/btMatrix3x3.h>
-#include "LinearMath/btPoint3.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types
+#include "../../LinearMath/btTransform.h"
+#include "../../LinearMath/btVector3.h"
+#include "../../LinearMath/btMatrix3x3.h"
+#include "../../LinearMath/btPoint3.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h" //for the shape types

 ///btCollisionShape provides interface for collision shapes that can be shared among btCollisionObjects.
 class btCollisionShape
 {
 public:

-	btCollisionShape() :m_tempDebug(0)
+	btCollisionShape() 
 	{
 	}
 	virtual ~btCollisionShape()
@@ -40,14 +40,15 @@ public:
 	virtual void	getBoundingSphere(btVector3& center,btScalar& radius) const;

 	///getAngularMotionDisc returns the maximus radius needed for Conservative Advancement to handle time-of-impact with rotations.
-	virtual float	getAngularMotionDisc() const;
+	virtual btScalar	getAngularMotionDisc() const;

-	virtual int		getShapeType() const=0;

 	///calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep)
 	///result is conservative
 	void calculateTemporalAabb(const btTransform& curTrans,const btVector3& linvel,const btVector3& angvel,btScalar timeStep, btVector3& temporalAabbMin,btVector3& temporalAabbMax);

+#ifndef __SPU__
+
 	inline bool	isPolyhedral() const
 	{
 		return btBroadphaseProxy::isPolyhedral(getShapeType());
@@ -72,20 +73,20 @@ public:
 		return btBroadphaseProxy::isInfinite(getShapeType());
 	}

+	virtual int		getShapeType() const=0;
 	virtual void	setLocalScaling(const btVector3& scaling) =0;
 	virtual const btVector3& getLocalScaling() const =0;
-
 	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia) = 0;

+
 //debugging support
 	virtual char*	getName()const =0 ;
-	const char* getExtraDebugInfo() const { return m_tempDebug;}
-	void  setExtraDebugInfo(const char* extraDebugInfo) { m_tempDebug = extraDebugInfo;}
-	const char * m_tempDebug;
-//endif debugging support
+#endif //__SPU__

-	virtual void	setMargin(float margin) = 0;
-	virtual float	getMargin() const = 0;
+	
+
+	virtual void	setMargin(btScalar margin) = 0;
+	virtual btScalar	getMargin() const = 0;

 };	

--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCompoundShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCompoundShape.cpp
@@ -20,11 +20,11 @@ subject to the following restrictions:


 btCompoundShape::btCompoundShape()
-:m_localAabbMin(1e30f,1e30f,1e30f),
-m_localAabbMax(-1e30f,-1e30f,-1e30f),
+:m_localAabbMin(btScalar(1e30),btScalar(1e30),btScalar(1e30)),
+m_localAabbMax(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30)),
 m_aabbTree(0),
-m_collisionMargin(0.f),
-m_localScaling(1.f,1.f,1.f)
+m_collisionMargin(btScalar(0.)),
+m_localScaling(btScalar(1.),btScalar(1.),btScalar(1.))
 {
 }

@@ -60,8 +60,8 @@ void	btCompoundShape::addChildShape(const btTransform& localTransform,btCollisio
 	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
 void btCompoundShape::getAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	btVector3 localHalfExtents = 0.5f*(m_localAabbMax-m_localAabbMin);
-	btVector3 localCenter = 0.5f*(m_localAabbMax+m_localAabbMin);
+	btVector3 localHalfExtents = btScalar(0.5)*(m_localAabbMax-m_localAabbMin);
+	btVector3 localCenter = btScalar(0.5)*(m_localAabbMax+m_localAabbMin);
 	
 	btMatrix3x3 abs_b = trans.getBasis().absolute();  

@@ -84,15 +84,15 @@ void	btCompoundShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 	btVector3 aabbMin,aabbMax;
 	getAabb(ident,aabbMin,aabbMax);
 	
-	btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+	btVector3 halfExtents = (aabbMax-aabbMin)*btScalar(0.5);
 	
-	btScalar lx=2.f*(halfExtents.x());
-	btScalar ly=2.f*(halfExtents.y());
-	btScalar lz=2.f*(halfExtents.z());
+	btScalar lx=btScalar(2.)*(halfExtents.x());
+	btScalar ly=btScalar(2.)*(halfExtents.y());
+	btScalar lz=btScalar(2.)*(halfExtents.z());

-	inertia[0] = mass/(12.0f) * (ly*ly + lz*lz);
-	inertia[1] = mass/(12.0f) * (lx*lx + lz*lz);
-	inertia[2] = mass/(12.0f) * (lx*lx + ly*ly);
+	inertia[0] = mass/(btScalar(12.0)) * (ly*ly + lz*lz);
+	inertia[1] = mass/(btScalar(12.0)) * (lx*lx + lz*lz);
+	inertia[2] = mass/(btScalar(12.0)) * (lx*lx + ly*ly);

 }

--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCompoundShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCompoundShape.h
@@ -18,12 +18,11 @@ subject to the following restrictions:

 #include "btCollisionShape.h"

-#include "LinearMath/btVector3.h"
-#include "LinearMath/btTransform.h"
-#include "LinearMath/btMatrix3x3.h"
-#include <vector>
-#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
-#include "LinearMath/btAlignedObjectArray.h"
+#include "../../LinearMath/btVector3.h"
+#include "../../LinearMath/btTransform.h"
+#include "../../LinearMath/btMatrix3x3.h"
+#include "btCollisionMargin.h"
+#include "../../LinearMath/btAlignedObjectArray.h"

 class btOptimizedBvh;

@@ -85,11 +84,11 @@ public:
 	
 	virtual int	getShapeType() const { return COMPOUND_SHAPE_PROXYTYPE;}

-	virtual void	setMargin(float margin)
+	virtual void	setMargin(btScalar margin)
 	{
 		m_collisionMargin = margin;
 	}
-	virtual float	getMargin() const
+	virtual btScalar	getMargin() const
 	{
 		return m_collisionMargin;
 	}
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConcaveShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConcaveShape.cpp
@@ -17,7 +17,7 @@ subject to the following restrictions:

 #include "btConcaveShape.h"

-btConcaveShape::btConcaveShape() : m_collisionMargin(0.f)
+btConcaveShape::btConcaveShape() : m_collisionMargin(btScalar(0.))
 {

 }
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConcaveShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConcaveShape.h
@@ -16,9 +16,8 @@ subject to the following restrictions:
 #ifndef CONCAVE_SHAPE_H
 #define CONCAVE_SHAPE_H

-#include "BulletCollision/CollisionShapes/btCollisionShape.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
-
+#include "btCollisionShape.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types
 #include "btTriangleCallback.h"


@@ -27,7 +26,7 @@ subject to the following restrictions:
 class btConcaveShape : public btCollisionShape
 {
 protected:
-	float m_collisionMargin;
+	btScalar m_collisionMargin;

 public:
 	btConcaveShape();
@@ -36,10 +35,10 @@ public:

 	virtual void	processAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const = 0;

-	virtual float getMargin() const {
+	virtual btScalar getMargin() const {
 		return m_collisionMargin;
 	}
-	virtual void setMargin(float collisionMargin)
+	virtual void setMargin(btScalar collisionMargin)
 	{
 		m_collisionMargin = collisionMargin;
 	}
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConeShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConeShape.cpp
@@ -24,7 +24,7 @@ m_height(height)
 {
 	setConeUpIndex(1);
 	btVector3 halfExtents;
-	m_sinAngle = (m_radius / sqrt(m_radius * m_radius + m_height * m_height));
+	m_sinAngle = (m_radius / btSqrt(m_radius * m_radius + m_height * m_height));
 }

 btConeShapeZ::btConeShapeZ (btScalar radius,btScalar height):
@@ -67,15 +67,15 @@ void	btConeShape::setConeUpIndex(int upIndex)
 btVector3 btConeShape::coneLocalSupport(const btVector3& v) const
 {
 	
-	float halfHeight = m_height * 0.5f;
+	btScalar halfHeight = m_height * btScalar(0.5);

 if (v[m_coneIndices[1]] > v.length() * m_sinAngle)
 {
 	btVector3 tmp;

-	tmp[m_coneIndices[0]] = 0.f;
+	tmp[m_coneIndices[0]] = btScalar(0.);
 	tmp[m_coneIndices[1]] = halfHeight;
-	tmp[m_coneIndices[2]] = 0.f;
+	tmp[m_coneIndices[2]] = btScalar(0.);
 	return tmp;
 }
  else {
@@ -90,9 +90,9 @@ btVector3 btConeShape::coneLocalSupport(const btVector3& v) const
    }
    else  {
 		btVector3 tmp;
-		tmp[m_coneIndices[0]] = 0.f;
+		tmp[m_coneIndices[0]] = btScalar(0.);
 		tmp[m_coneIndices[1]] = -halfHeight;
-		tmp[m_coneIndices[2]] = 0.f;
+		tmp[m_coneIndices[2]] = btScalar(0.);
 		return tmp;
 	}
  }
@@ -117,12 +117,12 @@ void	btConeShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVect
 btVector3	btConeShape::localGetSupportingVertex(const btVector3& vec)  const
 {
 	btVector3 supVertex = coneLocalSupport(vec);
-	if ( getMargin()!=0.f )
+	if ( getMargin()!=btScalar(0.) )
 	{
 		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
-			vecnorm.setValue(-1.f,-1.f,-1.f);
+			vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		} 
 		vecnorm.normalize();
 		supVertex+= getMargin() * vecnorm;
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConeShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConeShape.h
@@ -17,16 +17,16 @@ subject to the following restrictions:
 #define CONE_MINKOWSKI_H

 #include "btConvexShape.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types

 ///btConeShape implements a Cone shape, around the Y axis
 class btConeShape : public btConvexShape

 {

-	float m_sinAngle;
-	float m_radius;
-	float m_height;
+	btScalar m_sinAngle;
+	btScalar m_radius;
+	btScalar m_height;
 	int		m_coneIndices[3];
 	btVector3 coneLocalSupport(const btVector3& v) const;

@@ -38,8 +38,8 @@ public:
 	virtual btVector3	localGetSupportingVertexWithoutMargin(const btVector3& vec) const;
 	virtual void	batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;

-	float getRadius() const { return m_radius;}
-	float getHeight() const { return m_height;}
+	btScalar getRadius() const { return m_radius;}
+	btScalar getHeight() const { return m_height;}


 	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia)
@@ -49,17 +49,17 @@ public:
 		btVector3 aabbMin,aabbMax;
 		getAabb(identity,aabbMin,aabbMax);

-		btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+		btVector3 halfExtents = (aabbMax-aabbMin)*btScalar(0.5);

-		float margin = getMargin();
+		btScalar margin = getMargin();

-		btScalar lx=2.f*(halfExtents.x()+margin);
-		btScalar ly=2.f*(halfExtents.y()+margin);
-		btScalar lz=2.f*(halfExtents.z()+margin);
+		btScalar lx=btScalar(2.)*(halfExtents.x()+margin);
+		btScalar ly=btScalar(2.)*(halfExtents.y()+margin);
+		btScalar lz=btScalar(2.)*(halfExtents.z()+margin);
 		const btScalar x2 = lx*lx;
 		const btScalar y2 = ly*ly;
 		const btScalar z2 = lz*lz;
-		const btScalar scaledmass = mass * 0.08333333f;
+		const btScalar scaledmass = mass * btScalar(0.08333333);

 		inertia = scaledmass * (btVector3(y2+z2,x2+z2,x2+y2));

--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp
@@ -19,7 +19,7 @@ subject to the following restrictions:



-btConvexHullShape ::btConvexHullShape (const float* points,int numPoints,int stride)
+btConvexHullShape ::btConvexHullShape (const btScalar* points,int numPoints,int stride)
 {
 	m_points.resize(numPoints);

@@ -30,26 +30,37 @@ btConvexHullShape ::btConvexHullShape (const float* points,int numPoints,int str
 		btPoint3* point = (btPoint3*)(pointsBaseAddress + i*stride);
 		m_points[i] = point[0];
 	}
+
+	recalcLocalAabb();
+
+}
+
+
+void btConvexHullShape::addPoint(const btPoint3& point)
+{
+	m_points.push_back(point);
+	recalcLocalAabb();
+
 }

 btVector3	btConvexHullShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0)const
 {
-	btVector3 supVec(0.f,0.f,0.f);
-	btScalar newDot,maxDot = -1e30f;
+	btVector3 supVec(btScalar(0.),btScalar(0.),btScalar(0.));
+	btScalar newDot,maxDot = btScalar(-1e30);

 	btVector3 vec = vec0;
 	btScalar lenSqr = vec.length2();
-	if (lenSqr < 0.0001f)
+	if (lenSqr < btScalar(0.0001))
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / btSqrt(lenSqr );
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 		vec *= rlen;
 	}


-	for (size_t i=0;i<m_points.size();i++)
+	for (int i=0;i<m_points.size();i++)
 	{
 		btPoint3 vtx = m_points[i] * m_localScaling;

@@ -70,10 +81,10 @@ void	btConvexHullShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const
 	{
 		for (int i=0;i<numVectors;i++)
 		{
-			supportVerticesOut[i][3] = -1e30f;
+			supportVerticesOut[i][3] = btScalar(-1e30);
 		}
 	}
-	for (size_t i=0;i<m_points.size();i++)
+	for (int i=0;i<m_points.size();i++)
 	{
 		btPoint3 vtx = m_points[i] * m_localScaling;

@@ -101,12 +112,12 @@ btVector3	btConvexHullShape::localGetSupportingVertex(const btVector3& vec)const
 {
 	btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec);

-	if ( getMargin()!=0.f )
+	if ( getMargin()!=btScalar(0.) )
 	{
 		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
-			vecnorm.setValue(-1.f,-1.f,-1.f);
+			vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		} 
 		vecnorm.normalize();
 		supVertex+= getMargin() * vecnorm;
@@ -153,13 +164,14 @@ int	btConvexHullShape::getNumPlanes() const
 	return 0;
 }

-void btConvexHullShape::getPlane(btVector3& planeNormal,btPoint3& planeSupport,int i ) const
+void btConvexHullShape::getPlane(btVector3& ,btPoint3& ,int ) const
 {
-	assert(0);
+
+	btAssert(0);
 }

 //not yet
-bool btConvexHullShape::isInside(const btPoint3& pt,btScalar tolerance) const
+bool btConvexHullShape::isInside(const btPoint3& ,btScalar ) const
 {
 	assert(0);
 	return false;
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexHullShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexHullShape.h
@@ -17,29 +17,37 @@ subject to the following restrictions:
 #define CONVEX_HULL_SHAPE_H

 #include "btPolyhedralConvexShape.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
-
-
-#include "LinearMath/btAlignedObjectArray.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types
+#include "../../LinearMath/btAlignedObjectArray.h"

 ///ConvexHullShape implements an implicit (getSupportingVertex) Convex Hull of a Point Cloud (vertices)
 ///No connectivity is needed. localGetSupportingVertex iterates linearly though all vertices.
 ///on modern hardware, due to cache coherency this isn't that bad. Complex algorithms tend to trash the cash.
 ///(memory is much slower then the cpu)
-class btConvexHullShape : public btPolyhedralConvexShape
+ATTRIBUTE_ALIGNED16(class) btConvexHullShape : public btPolyhedralConvexShape
 {
 	btAlignedObjectArray<btPoint3>	m_points;

 public:
-	///this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive float (x,y,z), the striding defines the number of bytes between each point, in memory.
+
+	
+	///this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive btScalar (x,y,z), the striding defines the number of bytes between each point, in memory.
 	///It is easier to not pass any points in the constructor, and just add one point at a time, using addPoint.
 	///btConvexHullShape make an internal copy of the points.
-	btConvexHullShape(const float* points=0,int numPoints=0, int stride=sizeof(btPoint3));
+	btConvexHullShape(const btScalar* points=0,int numPoints=0, int stride=sizeof(btPoint3));

-	void addPoint(const btPoint3& point)
+	void addPoint(const btPoint3& point);
+
+	btPoint3* getPoints()
 	{
-		m_points.push_back(point);
+		return &m_points[0];
 	}
+
+	int getNumPoints()
+	{
+		return m_points.size();
+	}
+
 	virtual btVector3	localGetSupportingVertex(const btVector3& vec)const;
 	virtual btVector3	localGetSupportingVertexWithoutMargin(const btVector3& vec)const;
 	virtual void	batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexShape.cpp
@@ -15,8 +15,9 @@ subject to the following restrictions:

 #include "btConvexShape.h"

+
 btConvexShape::btConvexShape()
-: m_localScaling(1.f,1.f,1.f),
+: m_localScaling(btScalar(1.),btScalar(1.),btScalar(1.)),
 m_collisionMargin(CONVEX_DISTANCE_MARGIN)
 {
 }
@@ -35,35 +36,42 @@ void	btConvexShape::getAabbSlow(const btTransform& trans,btVector3&minAabb,btVec
 	btScalar margin = getMargin();
 	for (int i=0;i<3;i++)
 	{
-		btVector3 vec(0.f,0.f,0.f);
-		vec[i] = 1.f;
+		btVector3 vec(btScalar(0.),btScalar(0.),btScalar(0.));
+		vec[i] = btScalar(1.);

 		btVector3 sv = localGetSupportingVertex(vec*trans.getBasis());

 		btVector3 tmp = trans(sv);
 		maxAabb[i] = tmp[i]+margin;
-		vec[i] = -1.f;
+		vec[i] = btScalar(-1.);
 		tmp = trans(localGetSupportingVertex(vec*trans.getBasis()));
 		minAabb[i] = tmp[i]-margin;
 	}
 };

+
 btVector3	btConvexShape::localGetSupportingVertex(const btVector3& vec)const
- {
+{
+#ifndef __SPU__
+
 	 btVector3	supVertex = localGetSupportingVertexWithoutMargin(vec);

-	if ( getMargin()!=0.f )
+	if ( getMargin()!=btScalar(0.) )
 	{
 		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
-			vecnorm.setValue(-1.f,-1.f,-1.f);
+			vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		} 
 		vecnorm.normalize();
 		supVertex+= getMargin() * vecnorm;
 	}
 	return supVertex;

+#else
+	return btVector3(0,0,0);
+#endif //__SPU__
+
 }


--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexShape.h
@@ -18,11 +18,10 @@ subject to the following restrictions:

 #include "btCollisionShape.h"

-#include "LinearMath/btVector3.h"
-#include "LinearMath/btTransform.h"
-#include "LinearMath/btMatrix3x3.h"
-#include <vector>
-#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
+#include "../../LinearMath/btVector3.h"
+#include "../../LinearMath/btTransform.h"
+#include "../../LinearMath/btMatrix3x3.h"
+#include "btCollisionMargin.h"

 //todo: get rid of this btConvexCastResult thing!
 struct btConvexCastResult;
@@ -31,9 +30,9 @@ struct btConvexCastResult;
 /// btConvexShape is an abstract shape interface.
 /// The explicit part provides plane-equations, the implicit part provides GetClosestPoint interface.
 /// used in combination with GJK or btConvexCast
-class btConvexShape : public btCollisionShape
+ATTRIBUTE_ALIGNED16(class) btConvexShape : public btCollisionShape
 {
-	
+
 protected:

 	//local scaling. collisionMargin is not scaled !
@@ -43,14 +42,27 @@ protected:
 	
 	btScalar	m_collisionMargin;

+	btScalar	m_padding[2];
+
+
+
+
 public:
 	btConvexShape();

+	virtual ~btConvexShape()
+	{
+
+	}
+
+
 	virtual btVector3	localGetSupportingVertex(const btVector3& vec)const;
+#ifndef __SPU__
 	virtual btVector3	localGetSupportingVertexWithoutMargin(const btVector3& vec) const= 0;
 	
 	//notice that the vectors should be unit length
 	virtual void	batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const= 0;
+#endif //#ifndef __SPU__

 	const btVector3& getImplicitShapeDimensions() const
 	{
@@ -74,12 +86,21 @@ public:
 		return m_localScaling;
 	}

+	const btVector3& getLocalScalingNV() const 
+	{
+		return m_localScaling;
+	}

-	virtual void	setMargin(float margin)
+	virtual void	setMargin(btScalar margin)
 	{
 		m_collisionMargin = margin;
 	}
-	virtual float	getMargin() const
+	virtual btScalar	getMargin() const
+	{
+		return m_collisionMargin;
+	}
+
+	btScalar	getMarginNV() const
 	{
 		return m_collisionMargin;
 	}
@@ -91,12 +112,15 @@ public:
 	
 	virtual void	getPreferredPenetrationDirection(int index, btVector3& penetrationVector) const
 	{
-		assert(0);
+		(void)penetrationVector;
+		(void)index;
+		btAssert(0);
 	}



-};
+}
+;



--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp
@@ -22,6 +22,7 @@ subject to the following restrictions:
 btConvexTriangleMeshShape ::btConvexTriangleMeshShape (btStridingMeshInterface* meshInterface)
 :m_stridingMesh(meshInterface)
 {
+	recalcLocalAabb();
 }


@@ -39,14 +40,17 @@ public:
 	btVector3 m_supportVecLocal;

 	LocalSupportVertexCallback(const btVector3& supportVecLocal)
-		: m_supportVertexLocal(0.f,0.f,0.f),
-		m_maxDot(-1e30f),
+		: m_supportVertexLocal(btScalar(0.),btScalar(0.),btScalar(0.)),
+		m_maxDot(btScalar(-1e30)),
                m_supportVecLocal(supportVecLocal)
 	{
 	}

 	virtual void internalProcessTriangleIndex(btVector3* triangle,int partId,int  triangleIndex)
 	{
+		(void)triangleIndex;
+		(void)partId;
+
 		for (int i=0;i<3;i++)
 		{
 			btScalar dot = m_supportVecLocal.dot(triangle[i]);
@@ -71,21 +75,21 @@ public:

 btVector3	btConvexTriangleMeshShape::localGetSupportingVertexWithoutMargin(const btVector3& vec0)const
 {
-	btVector3 supVec(0.f,0.f,0.f);
+	btVector3 supVec(btScalar(0.),btScalar(0.),btScalar(0.));

 	btVector3 vec = vec0;
 	btScalar lenSqr = vec.length2();
-	if (lenSqr < 0.0001f)
+	if (lenSqr < btScalar(0.0001))
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / btSqrt(lenSqr );
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 		vec *= rlen;
 	}

 	LocalSupportVertexCallback	supportCallback(vec);
-	btVector3 aabbMax(1e30f,1e30f,1e30f);
+	btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 	m_stridingMesh->InternalProcessAllTriangles(&supportCallback,-aabbMax,aabbMax);
 	supVec = supportCallback.GetSupportVertexLocal();

@@ -98,7 +102,7 @@ void	btConvexTriangleMeshShape::batchedUnitVectorGetSupportingVertexWithoutMargi
 	{
 		for (int i=0;i<numVectors;i++)
 		{
-			supportVerticesOut[i][3] = -1e30f;
+			supportVerticesOut[i][3] = btScalar(-1e30);
 		}
 	}
 	
@@ -109,7 +113,7 @@ void	btConvexTriangleMeshShape::batchedUnitVectorGetSupportingVertexWithoutMargi
 	{
 		const btVector3& vec = vectors[j];
 		LocalSupportVertexCallback	supportCallback(vec);
-		btVector3 aabbMax(1e30f,1e30f,1e30f);
+		btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 		m_stridingMesh->InternalProcessAllTriangles(&supportCallback,-aabbMax,aabbMax);
 		supportVerticesOut[j] = supportCallback.GetSupportVertexLocal();
 	}
@@ -122,12 +126,12 @@ btVector3	btConvexTriangleMeshShape::localGetSupportingVertex(const btVector3& v
 {
 	btVector3 supVertex = localGetSupportingVertexWithoutMargin(vec);

-	if ( getMargin()!=0.f )
+	if ( getMargin()!=btScalar(0.) )
 	{
 		btVector3 vecnorm = vec;
 		if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 		{
-			vecnorm.setValue(-1.f,-1.f,-1.f);
+			vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 		} 
 		vecnorm.normalize();
 		supVertex+= getMargin() * vecnorm;
@@ -157,14 +161,14 @@ int btConvexTriangleMeshShape::getNumEdges() const
 	return 0;
 }

-void btConvexTriangleMeshShape::getEdge(int i,btPoint3& pa,btPoint3& pb) const
+void btConvexTriangleMeshShape::getEdge(int ,btPoint3& ,btPoint3& ) const
 {
-	assert(0);	
+	btAssert(0);	
 }

-void btConvexTriangleMeshShape::getVertex(int i,btPoint3& vtx) const
+void btConvexTriangleMeshShape::getVertex(int ,btPoint3& ) const
 {
-	assert(0);
+	btAssert(0);
 }

 int	btConvexTriangleMeshShape::getNumPlanes() const
@@ -172,15 +176,15 @@ int	btConvexTriangleMeshShape::getNumPlanes() const
 	return 0;
 }

-void btConvexTriangleMeshShape::getPlane(btVector3& planeNormal,btPoint3& planeSupport,int i ) const
+void btConvexTriangleMeshShape::getPlane(btVector3& ,btPoint3& ,int  ) const
 {
-	assert(0);
+	btAssert(0);
 }

 //not yet
-bool btConvexTriangleMeshShape::isInside(const btPoint3& pt,btScalar tolerance) const
+bool btConvexTriangleMeshShape::isInside(const btPoint3& ,btScalar ) const
 {
-	assert(0);
+	btAssert(0);
 	return false;
 }

@@ -189,5 +193,13 @@ bool btConvexTriangleMeshShape::isInside(const btPoint3& pt,btScalar tolerance)
 void	btConvexTriangleMeshShape::setLocalScaling(const btVector3& scaling)
 {
 	m_stridingMesh->setScaling(scaling);
+	
+	recalcLocalAabb();
+	
 }

+
+const btVector3& btConvexTriangleMeshShape::getLocalScaling() const
+{
+	return m_stridingMesh->getScaling();
+}
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h
@@ -3,9 +3,8 @@


 #include "btPolyhedralConvexShape.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types

-#include <vector>

 /// btConvexTriangleMeshShape is a convex hull of a triangle mesh. If you just have a point cloud, you can use btConvexHullShape instead.
 /// It uses the btStridingMeshInterface instead of a point cloud. This can avoid the duplication of the triangle mesh data.
@@ -40,7 +39,8 @@ public:
 	virtual	bool isInside(const btPoint3& pt,btScalar tolerance) const;

 	
-	void	setLocalScaling(const btVector3& scaling);
+	virtual void	setLocalScaling(const btVector3& scaling);
+	virtual const btVector3& getLocalScaling() const;

 };

--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCylinderShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCylinderShape.cpp
@@ -16,23 +16,33 @@ subject to the following restrictions:
 #include "LinearMath/btPoint3.h"

 btCylinderShape::btCylinderShape (const btVector3& halfExtents)
-:btBoxShape(halfExtents)
+:btBoxShape(halfExtents),
+m_upAxis(1)
 {
-
+	recalcLocalAabb();
 }


 btCylinderShapeX::btCylinderShapeX (const btVector3& halfExtents)
 :btCylinderShape(halfExtents)
 {
+	m_upAxis = 0;
+	recalcLocalAabb();
 }


 btCylinderShapeZ::btCylinderShapeZ (const btVector3& halfExtents)
 :btCylinderShape(halfExtents)
 {
+	m_upAxis = 2;
+	recalcLocalAabb();
 }

+void btCylinderShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
+{
+	//skip the box 'getAabb'
+	btPolyhedralConvexShape::getAabb(t,aabbMin,aabbMax);
+}


 inline btVector3 CylinderLocalSupportX(const btVector3& halfExtents,const btVector3& v) 
@@ -46,8 +56,8 @@ const int ZZ = 2;
 	// extents of the cylinder is: X,Y is for radius, and Z for height


-	float radius = halfExtents[XX];
-	float halfHeight = halfExtents[cylinderUpAxis];
+	btScalar radius = halfExtents[XX];
+	btScalar halfHeight = halfExtents[cylinderUpAxis];


    btVector3 tmp;
@@ -87,8 +97,8 @@ const int YY = 1;
 const int ZZ = 2;


-	float radius = halfExtents[XX];
-	float halfHeight = halfExtents[cylinderUpAxis];
+	btScalar radius = halfExtents[XX];
+	btScalar halfHeight = halfExtents[cylinderUpAxis];


    btVector3 tmp;
@@ -124,8 +134,8 @@ const int ZZ = 1;
 	// extents of the cylinder is: X,Y is for radius, and Z for height


-	float radius = halfExtents[XX];
-	float halfHeight = halfExtents[cylinderUpAxis];
+	btScalar radius = halfExtents[XX];
+	btScalar halfHeight = halfExtents[cylinderUpAxis];


    btVector3 tmp;
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btCylinderShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btCylinderShape.h
@@ -17,22 +17,23 @@ subject to the following restrictions:
 #define CYLINDER_MINKOWSKI_H

 #include "btBoxShape.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
-#include "LinearMath/btVector3.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types
+#include "../../LinearMath/btVector3.h"

 /// implements cylinder shape interface
 class btCylinderShape : public btBoxShape

 {

+protected:
+
+	int	m_upAxis;
+
 public:
 	btCylinderShape (const btVector3& halfExtents);
 	
 	///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
-	void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
-	{
-		getAabbSlow(t,aabbMin,aabbMax);
-	}
+	void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;

 	virtual btVector3	localGetSupportingVertexWithoutMargin(const btVector3& vec)const;

@@ -44,12 +45,12 @@ public:
 		btVector3 supVertex;
 		supVertex = localGetSupportingVertexWithoutMargin(vec);
 		
-		if ( getMargin()!=0.f )
+		if ( getMargin()!=btScalar(0.) )
 		{
 			btVector3 vecnorm = vec;
 			if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 			{
-				vecnorm.setValue(-1.f,-1.f,-1.f);
+				vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 			} 
 			vecnorm.normalize();
 			supVertex+= getMargin() * vecnorm;
@@ -66,12 +67,12 @@ public:
 		return CYLINDER_SHAPE_PROXYTYPE;
 	}
 	
-	virtual int	getUpAxis() const
+	int	getUpAxis() const
 	{
-		return 1;
+		return m_upAxis;
 	}

-	virtual float getRadius() const
+	virtual btScalar getRadius() const
 	{
 		return getHalfExtents().getX();
 	}
@@ -93,17 +94,14 @@ public:

 	virtual btVector3	localGetSupportingVertexWithoutMargin(const btVector3& vec)const;
 	virtual void	batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const;
-	virtual int	getUpAxis() const
-	{
-		return 0;
-	}
+	
 		//debugging
 	virtual char*	getName()const
 	{
 		return "CylinderX";
 	}

-	virtual float getRadius() const
+	virtual btScalar getRadius() const
 	{
 		return getHalfExtents().getY();
 	}
@@ -128,7 +126,7 @@ public:
 		return "CylinderZ";
 	}

-	virtual float getRadius() const
+	virtual btScalar getRadius() const
 	{
 		return getHalfExtents().getX();
 	}
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btEmptyShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btEmptyShape.cpp
@@ -40,9 +40,9 @@ void btEmptyShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aa

 }

-void	btEmptyShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
+void	btEmptyShape::calculateLocalInertia(btScalar ,btVector3& )
 {
-	assert(0);
+	btAssert(0);
 }

 	
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btEmptyShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btEmptyShape.h
@@ -18,11 +18,10 @@ subject to the following restrictions:

 #include "btConcaveShape.h"

-#include "LinearMath/btVector3.h"
-#include "LinearMath/btTransform.h"
-#include "LinearMath/btMatrix3x3.h"
-#include <vector>
-#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
+#include "../../LinearMath/btVector3.h"
+#include "../../LinearMath/btTransform.h"
+#include "../../LinearMath/btMatrix3x3.h"
+#include "btCollisionMargin.h"



--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp
@@ -19,7 +19,7 @@ subject to the following restrictions:


 btHeightfieldTerrainShape::btHeightfieldTerrainShape()
-:m_localScaling(0.f,0.f,0.f)
+:m_localScaling(btScalar(0.),btScalar(0.),btScalar(0.))
 {
 }

@@ -30,11 +30,10 @@ btHeightfieldTerrainShape::~btHeightfieldTerrainShape()



-void btHeightfieldTerrainShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
+void btHeightfieldTerrainShape::getAabb(const btTransform& ,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	aabbMin.setValue(-1e30f,-1e30f,-1e30f);
-	aabbMax.setValue(1e30f,1e30f,1e30f);
-
+	aabbMin.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+	aabbMax.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 }


@@ -42,14 +41,17 @@ void btHeightfieldTerrainShape::getAabb(const btTransform& t,btVector3& aabbMin,

 void	btHeightfieldTerrainShape::processAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
+	(void)callback;
+	(void)aabbMax;
+	(void)aabbMin;

-	btVector3 halfExtents = (aabbMax - aabbMin) * 0.5f;
-	btScalar radius = halfExtents.length();
-	btVector3 center = (aabbMax + aabbMin) * 0.5f;
+	/*
+	btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5);
+	btVector3 center = (aabbMax + aabbMin) * btScalar(0.5);
 	
 	//TODO
 	//this is where the triangles are generated, given AABB and plane equation (normal/constant)
-/*
+
 	btVector3 tangentDir0,tangentDir1;

 	//tangentDir0/tangentDir1 can be precalculated
@@ -60,6 +62,7 @@ void	btHeightfieldTerrainShape::processAllTriangles(btTriangleCallback* callback
 	btVector3 projectedCenter = center - (m_planeNormal.dot(center) - m_planeConstant)*m_planeNormal;
 	
 	btVector3 triangle[3];
+	btScalar radius = halfExtents.length();
 	triangle[0] = projectedCenter + tangentDir0*radius + tangentDir1*radius;
 	triangle[1] = projectedCenter + tangentDir0*radius - tangentDir1*radius;
 	triangle[2] = projectedCenter - tangentDir0*radius - tangentDir1*radius;
@@ -75,11 +78,11 @@ void	btHeightfieldTerrainShape::processAllTriangles(btTriangleCallback* callback

 }

-void	btHeightfieldTerrainShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
+void	btHeightfieldTerrainShape::calculateLocalInertia(btScalar ,btVector3& inertia)
 {
 	//moving concave objects not supported
 	
-	inertia.setValue(0.f,0.f,0.f);
+	inertia.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 }

 void	btHeightfieldTerrainShape::setLocalScaling(const btVector3& scaling)
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h
@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef HEIGHTFIELD_TERRAIN_SHAPE_H
 #define HEIGHTFIELD_TERRAIN_SHAPE_H

-#include "BulletCollision/CollisionShapes/btConcaveShape.h"
+#include "btConcaveShape.h"

 ///btHeightfieldTerrainShape simulates a 2D heightfield terrain 
 class btHeightfieldTerrainShape : public btConcaveShape
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp
@@ -43,7 +43,7 @@ void	btMinkowskiSumShape::batchedUnitVectorGetSupportingVertexWithoutMargin(cons



-float	btMinkowskiSumShape::getMargin() const
+btScalar	btMinkowskiSumShape::getMargin() const
 {
 	return m_shapeA->getMargin() + m_shapeB->getMargin();
 }
@@ -51,6 +51,7 @@ float	btMinkowskiSumShape::getMargin() const

 void	btMinkowskiSumShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 {
-	assert(0);
+	(void)mass;
+	btAssert(0);
 	inertia.setValue(0,0,0);
 }
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h
@@ -17,7 +17,7 @@ subject to the following restrictions:
 #define MINKOWSKI_SUM_SHAPE_H

 #include "btConvexShape.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types

 /// btMinkowskiSumShape represents implicit (getSupportingVertex) based minkowski sum of two convex implicit shapes.
 class btMinkowskiSumShape : public btConvexShape
@@ -48,7 +48,7 @@ public:

 	virtual int	getShapeType() const { return MINKOWSKI_SUM_SHAPE_PROXYTYPE; }

-	virtual float	getMargin() const;
+	virtual btScalar	getMargin() const;

 	const btConvexShape*	getShapeA() const { return m_shapeA;}
 	const btConvexShape*	getShapeB() const { return m_shapeB;}
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp
@@ -20,7 +20,7 @@ subject to the following restrictions:
 btMultiSphereShape::btMultiSphereShape (const btVector3& inertiaHalfExtents,const btVector3* positions,const btScalar* radi,int numSpheres)
 :m_inertiaHalfExtents(inertiaHalfExtents)
 {
-	float startMargin = 1e30f;
+	btScalar startMargin = btScalar(1e30);

 	m_numSpheres = numSpheres;
 	for (int i=0;i<m_numSpheres;i++)
@@ -42,17 +42,17 @@ btMultiSphereShape::btMultiSphereShape (const btVector3& inertiaHalfExtents,cons
 	int i;
 	btVector3 supVec(0,0,0);

-	btScalar maxDot(-1e30f);
+	btScalar maxDot(btScalar(-1e30));


 	btVector3 vec = vec0;
 	btScalar lenSqr = vec.length2();
-	if (lenSqr < 0.0001f)
+	if (lenSqr < btScalar(0.0001))
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / btSqrt(lenSqr );
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 		vec *= rlen;
 	}

@@ -84,7 +84,7 @@ btMultiSphereShape::btMultiSphereShape (const btVector3& inertiaHalfExtents,cons

 	for (int j=0;j<numVectors;j++)
 	{
-		btScalar maxDot(-1e30f);
+		btScalar maxDot(btScalar(-1e30));

 		const btVector3& vec = vectors[j];

@@ -126,17 +126,17 @@ void	btMultiSphereShape::calculateLocalInertia(btScalar mass,btVector3& inertia)

 //	getAabb(ident,aabbMin,aabbMax);

-	btVector3 halfExtents = m_inertiaHalfExtents;//(aabbMax - aabbMin)* 0.5f;
+	btVector3 halfExtents = m_inertiaHalfExtents;//(aabbMax - aabbMin)* btScalar(0.5);

-	float margin = CONVEX_DISTANCE_MARGIN;
+	btScalar margin = CONVEX_DISTANCE_MARGIN;

-	btScalar lx=2.f*(halfExtents[0]+margin);
-	btScalar ly=2.f*(halfExtents[1]+margin);
-	btScalar lz=2.f*(halfExtents[2]+margin);
+	btScalar lx=btScalar(2.)*(halfExtents[0]+margin);
+	btScalar ly=btScalar(2.)*(halfExtents[1]+margin);
+	btScalar lz=btScalar(2.)*(halfExtents[2]+margin);
 	const btScalar x2 = lx*lx;
 	const btScalar y2 = ly*ly;
 	const btScalar z2 = lz*lz;
-	const btScalar scaledmass = mass * 0.08333333f;
+	const btScalar scaledmass = mass * btScalar(.08333333);

 	inertia[0] = scaledmass * (y2+z2);
 	inertia[1] = scaledmass * (x2+z2);
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btMultiSphereShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btMultiSphereShape.h
@@ -17,7 +17,7 @@ subject to the following restrictions:
 #define MULTI_SPHERE_MINKOWSKI_H

 #include "btConvexShape.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types

 #define MAX_NUM_SPHERES 5

--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
@@ -16,89 +16,373 @@ subject to the following restrictions:
 #include "btOptimizedBvh.h"
 #include "btStridingMeshInterface.h"
 #include "LinearMath/btAabbUtil2.h"
+#include "LinearMath/btIDebugDraw.h"


-btOptimizedBvh::btOptimizedBvh() :m_rootNode1(0), m_numNodes(0) 
+
+btOptimizedBvh::btOptimizedBvh() : m_useQuantization(false), 
+					m_traversalMode(TRAVERSAL_STACKLESS_CACHE_FRIENDLY)
+					//m_traversalMode(TRAVERSAL_STACKLESS)
+					//m_traversalMode(TRAVERSAL_RECURSIVE)
 { 

 }


-void btOptimizedBvh::build(btStridingMeshInterface* triangles)
+void btOptimizedBvh::build(btStridingMeshInterface* triangles, bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax)
 {
-	//int countTriangles = 0;
+	m_useQuantization = useQuantizedAabbCompression;

-	

 	// NodeArray	triangleNodes;

 	struct	NodeTriangleCallback : public btInternalTriangleIndexCallback
 	{
+
 		NodeArray&	m_triangleNodes;

+		NodeTriangleCallback& operator=(NodeTriangleCallback& other)
+		{
+			m_triangleNodes = other.m_triangleNodes;
+			return *this;
+		}
+		
 		NodeTriangleCallback(NodeArray&	triangleNodes)
 			:m_triangleNodes(triangleNodes)
 		{
-
 		}

 		virtual void internalProcessTriangleIndex(btVector3* triangle,int partId,int  triangleIndex)
 		{
-
 			btOptimizedBvhNode node;
-			node.m_aabbMin = btVector3(1e30f,1e30f,1e30f); 
-			node.m_aabbMax = btVector3(-1e30f,-1e30f,-1e30f); 
-			node.m_aabbMin.setMin(triangle[0]);
-			node.m_aabbMax.setMax(triangle[0]);
-			node.m_aabbMin.setMin(triangle[1]);
-			node.m_aabbMax.setMax(triangle[1]);
-			node.m_aabbMin.setMin(triangle[2]);
-			node.m_aabbMax.setMax(triangle[2]);
+			btVector3	aabbMin,aabbMax;
+			aabbMin.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+			aabbMax.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30)); 
+			aabbMin.setMin(triangle[0]);
+			aabbMax.setMax(triangle[0]);
+			aabbMin.setMin(triangle[1]);
+			aabbMax.setMax(triangle[1]);
+			aabbMin.setMin(triangle[2]);
+			aabbMax.setMax(triangle[2]);
+
+			//with quantization?
+			node.m_aabbMinOrg = aabbMin;
+			node.m_aabbMaxOrg = aabbMax;

 			node.m_escapeIndex = -1;
-			node.m_leftChild = 0;
-			node.m_rightChild = 0;
-
-
+	
 			//for child nodes
 			node.m_subPart = partId;
 			node.m_triangleIndex = triangleIndex;
-
-			
 			m_triangleNodes.push_back(node);
 		}
 	};
+	struct	QuantizedNodeTriangleCallback : public btInternalTriangleIndexCallback
+	{
+		QuantizedNodeArray&	m_triangleNodes;
+		const btOptimizedBvh* m_optimizedTree; // for quantization

+		QuantizedNodeTriangleCallback& operator=(QuantizedNodeTriangleCallback& other)
+		{
+			m_triangleNodes = other.m_triangleNodes;
+			m_optimizedTree = other.m_optimizedTree;
+			return *this;
+		}
+
+		QuantizedNodeTriangleCallback(QuantizedNodeArray&	triangleNodes,const btOptimizedBvh* tree)
+			:m_triangleNodes(triangleNodes),m_optimizedTree(tree)
+		{
+		}
+
+		virtual void internalProcessTriangleIndex(btVector3* triangle,int partId,int  triangleIndex)
+		{
+			btAssert(partId==0);
+			//negative indices are reserved for escapeIndex
+			btAssert(triangleIndex>=0);
+
+			btQuantizedBvhNode node;
+			btVector3	aabbMin,aabbMax;
+			aabbMin.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+			aabbMax.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30)); 
+			aabbMin.setMin(triangle[0]);
+			aabbMax.setMax(triangle[0]);
+			aabbMin.setMin(triangle[1]);
+			aabbMax.setMax(triangle[1]);
+			aabbMin.setMin(triangle[2]);
+			aabbMax.setMax(triangle[2]);
+
+			m_optimizedTree->quantizeWithClamp(&node.m_quantizedAabbMin[0],aabbMin);
+			m_optimizedTree->quantizeWithClamp(&node.m_quantizedAabbMax[0],aabbMax);
+
+			node.m_escapeIndexOrTriangleIndex = triangleIndex;
+
+			m_triangleNodes.push_back(node);
+		}
+	};
 	

-	NodeTriangleCallback	callback(m_leafNodes);

-	btVector3 aabbMin(-1e30f,-1e30f,-1e30f);
-	btVector3 aabbMax(1e30f,1e30f,1e30f);
+	int numLeafNodes = 0;

-	triangles->InternalProcessAllTriangles(&callback,aabbMin,aabbMax);
+	
+	if (m_useQuantization)
+	{

-	//now we have an array of leafnodes in m_leafNodes
+		//initialize quantization values
+		setQuantizationValues(bvhAabbMin,bvhAabbMax);
+
+		QuantizedNodeTriangleCallback	callback(m_quantizedLeafNodes,this);
+
+	
+		triangles->InternalProcessAllTriangles(&callback,m_bvhAabbMin,m_bvhAabbMax);
+
+		//now we have an array of leafnodes in m_leafNodes
+		numLeafNodes = m_quantizedLeafNodes.size();
+
+
+		m_quantizedContiguousNodes.resize(2*numLeafNodes);
+
+
+	} else
+	{
+		NodeTriangleCallback	callback(m_leafNodes);
+
+		btVector3 aabbMin(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+		btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+
+		triangles->InternalProcessAllTriangles(&callback,aabbMin,aabbMax);
+
+		//now we have an array of leafnodes in m_leafNodes
+		numLeafNodes = m_leafNodes.size();
+
+		m_contiguousNodes.resize(2*numLeafNodes);
+	}

-	m_contiguousNodes = new btOptimizedBvhNode[2*m_leafNodes.size()];
 	m_curNodeIndex = 0;

-	m_rootNode1 = buildTree(m_leafNodes,0,m_leafNodes.size());
+	buildTree(0,numLeafNodes);

-
-	///create the leafnodes first
-//	btOptimizedBvhNode* leafNodes = new btOptimizedBvhNode;
+	///if the entire tree is small then subtree size, we need to create a header info for the tree
+	if(m_useQuantization && !m_SubtreeHeaders.size())
+	{
+		btBvhSubtreeInfo& subtree = m_SubtreeHeaders.expand();
+		subtree.setAabbFromQuantizeNode(m_quantizedContiguousNodes[0]);
+		subtree.m_rootNodeIndex = 0;
+		subtree.m_subtreeSize = m_quantizedContiguousNodes[0].isLeafNode() ? 1 : m_quantizedContiguousNodes[0].getEscapeIndex();
+	}
 }

+
+
+void	btOptimizedBvh::refitPartial(btStridingMeshInterface* meshInterface,const btVector3& aabbMin,const btVector3& aabbMax)
+{
+	//incrementally initialize quantization values
+	btAssert(m_useQuantization);
+
+	btAssert(aabbMin.getX() > m_bvhAabbMin.getX());
+	btAssert(aabbMin.getY() > m_bvhAabbMin.getY());
+	btAssert(aabbMin.getZ() > m_bvhAabbMin.getZ());
+
+	btAssert(aabbMax.getX() < m_bvhAabbMax.getX());
+	btAssert(aabbMax.getY() < m_bvhAabbMax.getY());
+	btAssert(aabbMax.getZ() < m_bvhAabbMax.getZ());
+
+	///we should update all quantization values, using updateBvhNodes(meshInterface);
+	///but we only update chunks that overlap the given aabb
+	
+	unsigned short	quantizedQueryAabbMin[3];
+	unsigned short	quantizedQueryAabbMax[3];
+
+	quantizeWithClamp(&quantizedQueryAabbMin[0],aabbMin);
+	quantizeWithClamp(&quantizedQueryAabbMax[0],aabbMax);
+
+	int i;
+	for (i=0;i<this->m_SubtreeHeaders.size();i++)
+	{
+		btBvhSubtreeInfo& subtree = m_SubtreeHeaders[i];
+
+		bool overlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin,quantizedQueryAabbMax,subtree.m_quantizedAabbMin,subtree.m_quantizedAabbMax);
+		if (overlap)
+		{
+			updateBvhNodes(meshInterface,subtree.m_rootNodeIndex,subtree.m_rootNodeIndex+subtree.m_subtreeSize,i);
+
+			subtree.setAabbFromQuantizeNode(m_quantizedContiguousNodes[subtree.m_rootNodeIndex]);
+		}
+	}
+	
+}
+
+///just for debugging, to visualize the individual patches/subtrees
+#ifdef DEBUG_PATCH_COLORS
+btVector3 color[4]=
+{
+	btVector3(255,0,0),
+	btVector3(0,255,0),
+	btVector3(0,0,255),
+	btVector3(0,255,255)
+};
+#endif //DEBUG_PATCH_COLORS
+
+
+void	btOptimizedBvh::updateBvhNodes(btStridingMeshInterface* meshInterface,int firstNode,int endNode,int index)
+{
+	(void)index;
+
+	btAssert(m_useQuantization);
+
+	int nodeSubPart=0;
+
+	//get access info to trianglemesh data
+		const unsigned char *vertexbase;
+		int numverts;
+		PHY_ScalarType type;
+		int stride;
+		const unsigned char *indexbase;
+		int indexstride;
+		int numfaces;
+		PHY_ScalarType indicestype;
+		meshInterface->getLockedReadOnlyVertexIndexBase(&vertexbase,numverts,	type,stride,&indexbase,indexstride,numfaces,indicestype,nodeSubPart);
+
+		btVector3	triangleVerts[3];
+		btVector3	aabbMin,aabbMax;
+		const btVector3& meshScaling = meshInterface->getScaling();
+		
+		int i;
+		for (i=endNode-1;i>=firstNode;i--)
+		{
+
+
+			btQuantizedBvhNode& curNode = m_quantizedContiguousNodes[i];
+			if (curNode.isLeafNode())
+			{
+				//recalc aabb from triangle data
+				int nodeTriangleIndex = curNode.getTriangleIndex();
+				//triangles->getLockedReadOnlyVertexIndexBase(vertexBase,numVerts,
+
+				int* gfxbase = (int*)(indexbase+nodeTriangleIndex*indexstride);
+				
+				
+				for (int j=2;j>=0;j--)
+				{
+					
+					int graphicsindex = gfxbase[j];
+					btScalar* graphicsbase = (btScalar*)(vertexbase+graphicsindex*stride);
+#ifdef DEBUG_PATCH_COLORS
+					btVector3 mycolor = color[index&3];
+					graphicsbase[8] = mycolor.getX();
+					graphicsbase[9] = mycolor.getY();
+					graphicsbase[10] = mycolor.getZ();
+#endif //DEBUG_PATCH_COLORS
+
+
+					triangleVerts[j] = btVector3(
+						graphicsbase[0]*meshScaling.getX(),
+						graphicsbase[1]*meshScaling.getY(),
+						graphicsbase[2]*meshScaling.getZ());
+				}
+
+
+				
+				aabbMin.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+				aabbMax.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30)); 
+				aabbMin.setMin(triangleVerts[0]);
+				aabbMax.setMax(triangleVerts[0]);
+				aabbMin.setMin(triangleVerts[1]);
+				aabbMax.setMax(triangleVerts[1]);
+				aabbMin.setMin(triangleVerts[2]);
+				aabbMax.setMax(triangleVerts[2]);
+
+				quantizeWithClamp(&curNode.m_quantizedAabbMin[0],aabbMin);
+				quantizeWithClamp(&curNode.m_quantizedAabbMax[0],aabbMax);
+				
+			} else
+			{
+				//combine aabb from both children
+
+				btQuantizedBvhNode* leftChildNode = &m_quantizedContiguousNodes[i+1];
+				
+				btQuantizedBvhNode* rightChildNode = leftChildNode->isLeafNode() ? &m_quantizedContiguousNodes[i+2] :
+					&m_quantizedContiguousNodes[i+1+leftChildNode->getEscapeIndex()];
+				
+
+				{
+					for (int i=0;i<3;i++)
+					{
+						curNode.m_quantizedAabbMin[i] = leftChildNode->m_quantizedAabbMin[i];
+						if (curNode.m_quantizedAabbMin[i]>rightChildNode->m_quantizedAabbMin[i])
+							curNode.m_quantizedAabbMin[i]=rightChildNode->m_quantizedAabbMin[i];
+
+						curNode.m_quantizedAabbMax[i] = leftChildNode->m_quantizedAabbMax[i];
+						if (curNode.m_quantizedAabbMax[i] < rightChildNode->m_quantizedAabbMax[i])
+							curNode.m_quantizedAabbMax[i] = rightChildNode->m_quantizedAabbMax[i];
+					}
+				}
+			}
+
+		}
+
+		meshInterface->unLockReadOnlyVertexBase(nodeSubPart);
+
+		
+}
+
+void	btOptimizedBvh::setQuantizationValues(const btVector3& bvhAabbMin,const btVector3& bvhAabbMax,btScalar quantizationMargin)
+{
+	//enlarge the AABB to avoid division by zero when initializing the quantization values
+	btVector3 clampValue(quantizationMargin,quantizationMargin,quantizationMargin);
+	m_bvhAabbMin = bvhAabbMin - clampValue;
+	m_bvhAabbMax = bvhAabbMax + clampValue;
+	btVector3 aabbSize = m_bvhAabbMax - m_bvhAabbMin;
+	m_bvhQuantization = btVector3(btScalar(65535.0),btScalar(65535.0),btScalar(65535.0)) / aabbSize;
+}
+
+
+void	btOptimizedBvh::refit(btStridingMeshInterface* meshInterface)
+{
+	if (m_useQuantization)
+	{
+		//calculate new aabb
+		btVector3 aabbMin,aabbMax;
+		meshInterface->calculateAabbBruteForce(aabbMin,aabbMax);
+
+		setQuantizationValues(aabbMin,aabbMax);
+
+		updateBvhNodes(meshInterface,0,m_curNodeIndex,0);
+
+		///now update all subtree headers
+
+		int i;
+		for (i=0;i<m_SubtreeHeaders.size();i++)
+		{
+			btBvhSubtreeInfo& subtree = m_SubtreeHeaders[i];
+			subtree.setAabbFromQuantizeNode(m_quantizedContiguousNodes[subtree.m_rootNodeIndex]);
+		}
+
+	} else
+	{
+
+	}
+}
+
+
+
 btOptimizedBvh::~btOptimizedBvh()
 {
-	if (m_contiguousNodes)
-		delete []m_contiguousNodes;
 }

-btOptimizedBvhNode*	btOptimizedBvh::buildTree	(NodeArray&	leafNodes,int startIndex,int endIndex)
+#ifdef DEBUG_TREE_BUILDING
+int gStackDepth = 0;
+int gMaxStackDepth = 0;
+#endif //DEBUG_TREE_BUILDING
+
+void	btOptimizedBvh::buildTree	(int startIndex,int endIndex)
 {
-	btOptimizedBvhNode* internalNode;
+#ifdef DEBUG_TREE_BUILDING
+	gStackDepth++;
+	if (gStackDepth > gMaxStackDepth)
+		gMaxStackDepth = gStackDepth;
+#endif //DEBUG_TREE_BUILDING
+

 	int splitAxis, splitIndex, i;
 	int numIndices =endIndex-startIndex;
@@ -108,96 +392,172 @@ btOptimizedBvhNode*	btOptimizedBvh::buildTree	(NodeArray&	leafNodes,int startInd

 	if (numIndices==1)
 	{
-		return new (&m_contiguousNodes[m_curNodeIndex++]) btOptimizedBvhNode(leafNodes[startIndex]);
+#ifdef DEBUG_TREE_BUILDING
+		gStackDepth--;
+#endif //DEBUG_TREE_BUILDING
+		
+		assignInternalNodeFromLeafNode(m_curNodeIndex,startIndex);
+
+		m_curNodeIndex++;
+		return;	
 	}
 	//calculate Best Splitting Axis and where to split it. Sort the incoming 'leafNodes' array within range 'startIndex/endIndex'.
 	
-	splitAxis = calcSplittingAxis(leafNodes,startIndex,endIndex);
+	splitAxis = calcSplittingAxis(startIndex,endIndex);

-	splitIndex = sortAndCalcSplittingIndex(leafNodes,startIndex,endIndex,splitAxis);
+	splitIndex = sortAndCalcSplittingIndex(startIndex,endIndex,splitAxis);

-	internalNode = &m_contiguousNodes[m_curNodeIndex++];
+	int internalNodeIndex = m_curNodeIndex;
 	
-	internalNode->m_aabbMax.setValue(-1e30f,-1e30f,-1e30f);
-	internalNode->m_aabbMin.setValue(1e30f,1e30f,1e30f);
+	setInternalNodeAabbMax(m_curNodeIndex,btVector3(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30)));
+	setInternalNodeAabbMin(m_curNodeIndex,btVector3(btScalar(1e30),btScalar(1e30),btScalar(1e30)));
 	
 	for (i=startIndex;i<endIndex;i++)
 	{
-		internalNode->m_aabbMax.setMax(leafNodes[i].m_aabbMax);
-		internalNode->m_aabbMin.setMin(leafNodes[i].m_aabbMin);
+		mergeInternalNodeAabb(m_curNodeIndex,getAabbMin(i),getAabbMax(i));
 	}

+	m_curNodeIndex++;
 	

 	//internalNode->m_escapeIndex;
-	internalNode->m_leftChild = buildTree(leafNodes,startIndex,splitIndex);
-	internalNode->m_rightChild = buildTree(leafNodes,splitIndex,endIndex);
+	
+	int leftChildNodexIndex = m_curNodeIndex;
+
+	//build left child tree
+	buildTree(startIndex,splitIndex);
+
+	int rightChildNodexIndex = m_curNodeIndex;
+	//build right child tree
+	buildTree(splitIndex,endIndex);
+
+#ifdef DEBUG_TREE_BUILDING
+	gStackDepth--;
+#endif //DEBUG_TREE_BUILDING
+
+	int escapeIndex = m_curNodeIndex - curIndex;
+
+	if (m_useQuantization)
+	{
+		//escapeIndex is the number of nodes of this subtree
+		const int sizeQuantizedNode =sizeof(btQuantizedBvhNode);
+		const int treeSizeInBytes = escapeIndex * sizeQuantizedNode;
+		if (treeSizeInBytes > MAX_SUBTREE_SIZE_IN_BYTES)
+		{
+			updateSubtreeHeaders(leftChildNodexIndex,rightChildNodexIndex);
+		}
+	}
+
+	setInternalNodeEscapeIndex(internalNodeIndex,escapeIndex);

-	internalNode->m_escapeIndex  = m_curNodeIndex - curIndex;
-	return internalNode;
 }

-int	btOptimizedBvh::sortAndCalcSplittingIndex(NodeArray&	leafNodes,int startIndex,int endIndex,int splitAxis)
+void	btOptimizedBvh::updateSubtreeHeaders(int leftChildNodexIndex,int rightChildNodexIndex)
+{
+	btAssert(m_useQuantization);
+
+	btQuantizedBvhNode& leftChildNode = m_quantizedContiguousNodes[leftChildNodexIndex];
+	int leftSubTreeSize = leftChildNode.isLeafNode() ? 1 : leftChildNode.getEscapeIndex();
+	int leftSubTreeSizeInBytes =  leftSubTreeSize * sizeof(btQuantizedBvhNode);
+	
+	btQuantizedBvhNode& rightChildNode = m_quantizedContiguousNodes[rightChildNodexIndex];
+	int rightSubTreeSize = rightChildNode.isLeafNode() ? 1 : rightChildNode.getEscapeIndex();
+	int rightSubTreeSizeInBytes =  rightSubTreeSize * sizeof(btQuantizedBvhNode);
+
+	if(leftSubTreeSizeInBytes <= MAX_SUBTREE_SIZE_IN_BYTES)
+	{
+		btBvhSubtreeInfo& subtree = m_SubtreeHeaders.expand();
+		subtree.setAabbFromQuantizeNode(leftChildNode);
+		subtree.m_rootNodeIndex = leftChildNodexIndex;
+		subtree.m_subtreeSize = leftSubTreeSize;
+	}
+
+	if(rightSubTreeSizeInBytes <= MAX_SUBTREE_SIZE_IN_BYTES)
+	{
+		btBvhSubtreeInfo& subtree = m_SubtreeHeaders.expand();
+		subtree.setAabbFromQuantizeNode(rightChildNode);
+		subtree.m_rootNodeIndex = rightChildNodexIndex;
+		subtree.m_subtreeSize = rightSubTreeSize;
+	}
+}
+
+
+int	btOptimizedBvh::sortAndCalcSplittingIndex(int startIndex,int endIndex,int splitAxis)
 {
 	int i;
 	int splitIndex =startIndex;
 	int numIndices = endIndex - startIndex;
-	float splitValue;
+	btScalar splitValue;

-	btVector3 means(0.f,0.f,0.f);
+	btVector3 means(btScalar(0.),btScalar(0.),btScalar(0.));
 	for (i=startIndex;i<endIndex;i++)
 	{
-		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = btScalar(0.5)*(getAabbMax(i)+getAabbMin(i));
 		means+=center;
 	}
-	means *= (1.f/(float)numIndices);
+	means *= (btScalar(1.)/(btScalar)numIndices);
 	
 	splitValue = means[splitAxis];
 	
 	//sort leafNodes so all values larger then splitValue comes first, and smaller values start from 'splitIndex'.
 	for (i=startIndex;i<endIndex;i++)
 	{
-		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = btScalar(0.5)*(getAabbMax(i)+getAabbMin(i));
 		if (center[splitAxis] > splitValue)
 		{
 			//swap
-			btOptimizedBvhNode tmp = leafNodes[i];
-			leafNodes[i] = leafNodes[splitIndex];
-			leafNodes[splitIndex] = tmp;
+			swapLeafNodes(i,splitIndex);
 			splitIndex++;
 		}
 	}
-	if ((splitIndex==startIndex) || (splitIndex == (endIndex-1)))
+
+	//if the splitIndex causes unbalanced trees, fix this by using the center in between startIndex and endIndex
+	//otherwise the tree-building might fail due to stack-overflows in certain cases.
+	//unbalanced1 is unsafe: it can cause stack overflows
+	//bool unbalanced1 = ((splitIndex==startIndex) || (splitIndex == (endIndex-1)));
+
+	//unbalanced2 should work too: always use center (perfect balanced trees)	
+	//bool unbalanced2 = true;
+
+	//this should be safe too:
+	int rangeBalancedIndices = numIndices/3;
+	bool unbalanced = ((splitIndex<=(startIndex+rangeBalancedIndices)) || (splitIndex >=(endIndex-1-rangeBalancedIndices)));
+	
+	if (unbalanced)
 	{
 		splitIndex = startIndex+ (numIndices>>1);
 	}
+
+	bool unbal = (splitIndex==startIndex) || (splitIndex == (endIndex));
+	btAssert(!unbal);
+
 	return splitIndex;
 }


-int	btOptimizedBvh::calcSplittingAxis(NodeArray&	leafNodes,int startIndex,int endIndex)
+int	btOptimizedBvh::calcSplittingAxis(int startIndex,int endIndex)
 {
 	int i;

-	btVector3 means(0.f,0.f,0.f);
-	btVector3 variance(0.f,0.f,0.f);
+	btVector3 means(btScalar(0.),btScalar(0.),btScalar(0.));
+	btVector3 variance(btScalar(0.),btScalar(0.),btScalar(0.));
 	int numIndices = endIndex-startIndex;

 	for (i=startIndex;i<endIndex;i++)
 	{
-		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = btScalar(0.5)*(getAabbMax(i)+getAabbMin(i));
 		means+=center;
 	}
-	means *= (1.f/(float)numIndices);
+	means *= (btScalar(1.)/(btScalar)numIndices);
 		
 	for (i=startIndex;i<endIndex;i++)
 	{
-		btVector3 center = 0.5f*(leafNodes[i].m_aabbMax+leafNodes[i].m_aabbMin);
+		btVector3 center = btScalar(0.5)*(getAabbMax(i)+getAabbMin(i));
 		btVector3 diff2 = center-means;
 		diff2 = diff2 * diff2;
 		variance += diff2;
 	}
-	variance *= (1.f/	((float)numIndices-1)	);
+	variance *= (btScalar(1.)/	((btScalar)numIndices-1)	);
 	
 	return variance.maxAxis();
 }
@@ -208,11 +568,83 @@ void	btOptimizedBvh::reportAabbOverlappingNodex(btNodeOverlapCallback* nodeCallb
 {
 	//either choose recursive traversal (walkTree) or stackless (walkStacklessTree)

-	//walkTree(m_rootNode1,nodeCallback,aabbMin,aabbMax);

-	walkStacklessTree(m_rootNode1,nodeCallback,aabbMin,aabbMax);
+	if (m_useQuantization)
+	{
+		///quantize query AABB
+		unsigned short int quantizedQueryAabbMin[3];
+		unsigned short int quantizedQueryAabbMax[3];
+		quantizeWithClamp(quantizedQueryAabbMin,aabbMin);
+		quantizeWithClamp(quantizedQueryAabbMax,aabbMax);
+
+		switch (m_traversalMode)
+		{
+		case TRAVERSAL_STACKLESS:
+				walkStacklessQuantizedTree(nodeCallback,quantizedQueryAabbMin,quantizedQueryAabbMax,0,m_curNodeIndex);
+			break;
+		case TRAVERSAL_STACKLESS_CACHE_FRIENDLY:
+				walkStacklessQuantizedTreeCacheFriendly(nodeCallback,quantizedQueryAabbMin,quantizedQueryAabbMax);
+			break;
+		case TRAVERSAL_RECURSIVE:
+			{
+				const btQuantizedBvhNode* rootNode = &m_quantizedContiguousNodes[0];
+				walkRecursiveQuantizedTreeAgainstQueryAabb(rootNode,nodeCallback,quantizedQueryAabbMin,quantizedQueryAabbMax);
+			}
+			break;
+		default:
+			//unsupported
+			btAssert(0);
+		}
+	} else
+	{
+		walkStacklessTree(nodeCallback,aabbMin,aabbMax);
+	}
 }

+
+int maxIterations = 0;
+
+void	btOptimizedBvh::walkStacklessTree(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
+{
+	btAssert(!m_useQuantization);
+
+	const btOptimizedBvhNode* rootNode = &m_contiguousNodes[0];
+	int escapeIndex, curIndex = 0;
+	int walkIterations = 0;
+	bool aabbOverlap, isLeafNode;
+
+	while (curIndex < m_curNodeIndex)
+	{
+		//catch bugs in tree data
+		assert (walkIterations < m_curNodeIndex);
+
+		walkIterations++;
+		aabbOverlap = TestAabbAgainstAabb2(aabbMin,aabbMax,rootNode->m_aabbMinOrg,rootNode->m_aabbMaxOrg);
+		isLeafNode = rootNode->m_escapeIndex == -1;
+		
+		if (isLeafNode && aabbOverlap)
+		{
+			nodeCallback->processNode(rootNode->m_subPart,rootNode->m_triangleIndex);
+		} 
+		
+		if (aabbOverlap || isLeafNode)
+		{
+			rootNode++;
+			curIndex++;
+		} else
+		{
+			escapeIndex = rootNode->m_escapeIndex;
+			rootNode += escapeIndex;
+			curIndex += escapeIndex;
+		}
+	}
+	if (maxIterations < walkIterations)
+		maxIterations = walkIterations;
+
+}
+
+/*
+///this was the original recursive traversal, before we optimized towards stackless traversal
 void	btOptimizedBvh::walkTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
 	bool isLeafNode, aabbOverlap = TestAabbAgainstAabb2(aabbMin,aabbMax,rootNode->m_aabbMin,rootNode->m_aabbMax);
@@ -230,27 +662,82 @@ void	btOptimizedBvh::walkTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback
 	}

 }
+*/

-int maxIterations = 0;
-
-void	btOptimizedBvh::walkStacklessTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
+void btOptimizedBvh::walkRecursiveQuantizedTreeAgainstQueryAabb(const btQuantizedBvhNode* currentNode,btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const
 {
-	int escapeIndex, curIndex = 0;
-	int walkIterations = 0;
+	btAssert(m_useQuantization);
+	
 	bool aabbOverlap, isLeafNode;

-	while (curIndex < m_curNodeIndex)
+	aabbOverlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin,quantizedQueryAabbMax,currentNode->m_quantizedAabbMin,currentNode->m_quantizedAabbMax);
+	isLeafNode = currentNode->isLeafNode();
+		
+	if (aabbOverlap)
 	{
+		if (isLeafNode)
+		{
+			nodeCallback->processNode(0,currentNode->getTriangleIndex());
+		} else
+		{
+			//process left and right children
+			const btQuantizedBvhNode* leftChildNode = currentNode+1;
+			walkRecursiveQuantizedTreeAgainstQueryAabb(leftChildNode,nodeCallback,quantizedQueryAabbMin,quantizedQueryAabbMax);
+
+			const btQuantizedBvhNode* rightChildNode = leftChildNode->isLeafNode() ? leftChildNode+1:leftChildNode+leftChildNode->getEscapeIndex();
+			walkRecursiveQuantizedTreeAgainstQueryAabb(rightChildNode,nodeCallback,quantizedQueryAabbMin,quantizedQueryAabbMax);
+		}
+	}		
+}
+
+
+
+
+
+
+
+void	btOptimizedBvh::walkStacklessQuantizedTree(btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax,int startNodeIndex,int endNodeIndex) const
+{
+	btAssert(m_useQuantization);
+	
+	int curIndex = startNodeIndex;
+	int walkIterations = 0;
+	int subTreeSize = endNodeIndex - startNodeIndex;
+
+	const btQuantizedBvhNode* rootNode = &m_quantizedContiguousNodes[startNodeIndex];
+	int escapeIndex;
+	
+	bool aabbOverlap, isLeafNode;
+
+	while (curIndex < endNodeIndex)
+	{
+
+//#define VISUALLY_ANALYZE_BVH 1
+#ifdef VISUALLY_ANALYZE_BVH
+		//some code snippet to debugDraw aabb, to visually analyze bvh structure
+		static int drawPatch = 0;
+		//need some global access to a debugDrawer
+		extern btIDebugDraw* debugDrawerPtr;
+		if (curIndex==drawPatch)
+		{
+			btVector3 aabbMin,aabbMax;
+			aabbMin = unQuantize(rootNode->m_quantizedAabbMin);
+			aabbMax = unQuantize(rootNode->m_quantizedAabbMax);
+			btVector3	color(1,0,0);
+			debugDrawerPtr->drawAabb(aabbMin,aabbMax,color);
+		}
+#endif//VISUALLY_ANALYZE_BVH
+
 		//catch bugs in tree data
-		assert (walkIterations < m_curNodeIndex);
+		assert (walkIterations < subTreeSize);

 		walkIterations++;
-		aabbOverlap = TestAabbAgainstAabb2(aabbMin,aabbMax,rootNode->m_aabbMin,rootNode->m_aabbMax);
-		isLeafNode = (!rootNode->m_leftChild && !rootNode->m_rightChild);
+		aabbOverlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin,quantizedQueryAabbMax,rootNode->m_quantizedAabbMin,rootNode->m_quantizedAabbMax);
+		isLeafNode = rootNode->isLeafNode();
 		
 		if (isLeafNode && aabbOverlap)
 		{
-			nodeCallback->processNode(rootNode);
+			nodeCallback->processNode(0,rootNode->getTriangleIndex());
 		} 
 		
 		if (aabbOverlap || isLeafNode)
@@ -259,21 +746,100 @@ void	btOptimizedBvh::walkStacklessTree(btOptimizedBvhNode* rootNode,btNodeOverla
 			curIndex++;
 		} else
 		{
-			escapeIndex = rootNode->m_escapeIndex;
+			escapeIndex = rootNode->getEscapeIndex();
 			rootNode += escapeIndex;
 			curIndex += escapeIndex;
 		}
-		
 	}
-
 	if (maxIterations < walkIterations)
 		maxIterations = walkIterations;

 }

+//This traversal can be called from Playstation 3 SPU
+void	btOptimizedBvh::walkStacklessQuantizedTreeCacheFriendly(btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const
+{
+	btAssert(m_useQuantization);
+
+	int i;
+
+
+	for (i=0;i<this->m_SubtreeHeaders.size();i++)
+	{
+		const btBvhSubtreeInfo& subtree = m_SubtreeHeaders[i];
+
+		bool overlap = testQuantizedAabbAgainstQuantizedAabb(quantizedQueryAabbMin,quantizedQueryAabbMax,subtree.m_quantizedAabbMin,subtree.m_quantizedAabbMax);
+		if (overlap)
+		{
+			walkStacklessQuantizedTree(nodeCallback,quantizedQueryAabbMin,quantizedQueryAabbMax,
+				subtree.m_rootNodeIndex,
+				subtree.m_rootNodeIndex+subtree.m_subtreeSize);
+		}
+	}
+}
+
+
+

 void	btOptimizedBvh::reportSphereOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
-
+	(void)nodeCallback;
+	(void)aabbMin;
+	(void)aabbMax;
+	//not yet, please use aabb
+	btAssert(0);
 }

+
+void btOptimizedBvh::quantizeWithClamp(unsigned short* out, const btVector3& point) const
+{
+
+	btAssert(m_useQuantization);
+
+	btVector3 clampedPoint(point);
+	clampedPoint.setMax(m_bvhAabbMin);
+	clampedPoint.setMin(m_bvhAabbMax);
+
+	btVector3 v = (clampedPoint - m_bvhAabbMin) * m_bvhQuantization;
+	out[0] = (unsigned short)(v.getX()+0.5f);
+	out[1] = (unsigned short)(v.getY()+0.5f);
+	out[2] = (unsigned short)(v.getZ()+0.5f);		
+}
+
+btVector3	btOptimizedBvh::unQuantize(const unsigned short* vecIn) const
+{
+	btVector3	vecOut;
+	vecOut.setValue(
+		(btScalar)(vecIn[0]) / (m_bvhQuantization.getX()),
+		(btScalar)(vecIn[1]) / (m_bvhQuantization.getY()),
+		(btScalar)(vecIn[2]) / (m_bvhQuantization.getZ()));
+	vecOut += m_bvhAabbMin;
+	return vecOut;
+}
+
+
+void	btOptimizedBvh::swapLeafNodes(int i,int splitIndex)
+{
+	if (m_useQuantization)
+	{
+			btQuantizedBvhNode tmp = m_quantizedLeafNodes[i];
+			m_quantizedLeafNodes[i] = m_quantizedLeafNodes[splitIndex];
+			m_quantizedLeafNodes[splitIndex] = tmp;
+	} else
+	{
+			btOptimizedBvhNode tmp = m_leafNodes[i];
+			m_leafNodes[i] = m_leafNodes[splitIndex];
+			m_leafNodes[splitIndex] = tmp;
+	}
+}
+
+void	btOptimizedBvh::assignInternalNodeFromLeafNode(int internalNode,int leafNodeIndex)
+{
+	if (m_useQuantization)
+	{
+		m_quantizedContiguousNodes[internalNode] = m_quantizedLeafNodes[leafNodeIndex];
+	} else
+	{
+		m_contiguousNodes[internalNode] = m_leafNodes[leafNodeIndex];
+	}
+}
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btOptimizedBvh.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btOptimizedBvh.h
@@ -17,103 +17,313 @@ subject to the following restrictions:
 #define OPTIMIZED_BVH_H


-#include "LinearMath/btVector3.h"
+#include "../../LinearMath/btVector3.h"


 //http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp


-#include <vector>
-

 class btStridingMeshInterface;

-/// btOptimizedBvhNode contains both internal and leaf node information.
-/// It hasn't been optimized yet for storage. Some obvious optimizations are:
-/// Removal of the pointers (can already be done, they are not used for traversal)
-/// and storing aabbmin/max as quantized integers.
-/// 'subpart' doesn't need an integer either. It allows to re-use graphics triangle
-/// meshes stored in a non-uniform way (like batches/subparts of triangle-fans
-ATTRIBUTE_ALIGNED16 (struct btOptimizedBvhNode)
+//Note: currently we have 16 bytes per quantized node
+#define MAX_SUBTREE_SIZE_IN_BYTES  2048
+
+
+///btQuantizedBvhNode is a compressed aabb node, 16 bytes.
+///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).
+ATTRIBUTE_ALIGNED16	(struct) btQuantizedBvhNode
 {
+	
+	//12 bytes
+	unsigned short int	m_quantizedAabbMin[3];
+	unsigned short int	m_quantizedAabbMax[3];
+	//4 bytes
+	int	m_escapeIndexOrTriangleIndex;

-	btVector3	m_aabbMin;
-	btVector3	m_aabbMax;
+	bool isLeafNode() const
+	{
+		//skipindex is negative (internal node), triangleindex >=0 (leafnode)
+		return (m_escapeIndexOrTriangleIndex >= 0);
+	}
+	int getEscapeIndex() const
+	{
+		btAssert(!isLeafNode());
+		return -m_escapeIndexOrTriangleIndex;
+	}
+	int	getTriangleIndex() const
+	{
+		btAssert(isLeafNode());
+		return m_escapeIndexOrTriangleIndex;
+	}
+}
+;

-//these 2 pointers are obsolete, the stackless traversal just uses the escape index
-	btOptimizedBvhNode*	m_leftChild;
-	btOptimizedBvhNode*	m_rightChild;
+/// btOptimizedBvhNode contains both internal and leaf node information.
+/// Total node size is 44 bytes / node. You can use the compressed version of 16 bytes.
+ATTRIBUTE_ALIGNED16 (struct) btOptimizedBvhNode
+{
+	//32 bytes
+	btVector3	m_aabbMinOrg;
+	btVector3	m_aabbMaxOrg;

+	//4
 	int	m_escapeIndex;

+	//8
 	//for child nodes
 	int	m_subPart;
 	int	m_triangleIndex;
+	int	m_padding[5];//bad, due to alignment
+

 };

+
+///btBvhSubtreeInfo provides info to gather a subtree of limited size
+ATTRIBUTE_ALIGNED16(class) btBvhSubtreeInfo
+{
+public:
+	//12 bytes
+	unsigned short int	m_quantizedAabbMin[3];
+	unsigned short int	m_quantizedAabbMax[3];
+	//4 bytes, points to the root of the subtree
+	int			m_rootNodeIndex;
+	//4 bytes
+	int			m_subtreeSize;
+	int			m_padding[3];
+
+
+	void	setAabbFromQuantizeNode(const btQuantizedBvhNode& quantizedNode)
+	{
+		m_quantizedAabbMin[0] = quantizedNode.m_quantizedAabbMin[0];
+		m_quantizedAabbMin[1] = quantizedNode.m_quantizedAabbMin[1];
+		m_quantizedAabbMin[2] = quantizedNode.m_quantizedAabbMin[2];
+		m_quantizedAabbMax[0] = quantizedNode.m_quantizedAabbMax[0];
+		m_quantizedAabbMax[1] = quantizedNode.m_quantizedAabbMax[1];
+		m_quantizedAabbMax[2] = quantizedNode.m_quantizedAabbMax[2];
+	}
+}
+;
+
+
 class btNodeOverlapCallback
 {
 public:
 	virtual ~btNodeOverlapCallback() {};

-	virtual void processNode(const btOptimizedBvhNode* node) = 0;
+	virtual void processNode(int subPart, int triangleIndex) = 0;
 };

-#include "LinearMath/btAlignedAllocator.h"
-#include "LinearMath/btAlignedObjectArray.h"
+#include "../../LinearMath/btAlignedAllocator.h"
+#include "../../LinearMath/btAlignedObjectArray.h"

-//typedef std::vector< unsigned , allocator_type >     container_type;
-const unsigned size = (1 << 20);
-typedef btAlignedAllocator< btOptimizedBvhNode , size >  allocator_type;

-//typedef btAlignedObjectArray<btOptimizedBvhNode, allocator_type>	NodeArray;

+///for code readability:
 typedef btAlignedObjectArray<btOptimizedBvhNode>	NodeArray;
+typedef btAlignedObjectArray<btQuantizedBvhNode>	QuantizedNodeArray;
+typedef btAlignedObjectArray<btBvhSubtreeInfo>		BvhSubtreeInfoArray;


 ///OptimizedBvh store an AABB tree that can be quickly traversed on CPU (and SPU,GPU in future)
-class btOptimizedBvh
+ATTRIBUTE_ALIGNED16(class) btOptimizedBvh
 {
 	NodeArray			m_leafNodes;
+	NodeArray			m_contiguousNodes;

-	btOptimizedBvhNode*	m_rootNode1;
+	QuantizedNodeArray	m_quantizedLeafNodes;
+	
+	QuantizedNodeArray	m_quantizedContiguousNodes;
 	
-	btOptimizedBvhNode*	m_contiguousNodes;
 	int					m_curNodeIndex;

-	int					m_numNodes;
+
+	//quantization data
+	bool				m_useQuantization;
+	btVector3			m_bvhAabbMin;
+	btVector3			m_bvhAabbMax;
+	btVector3			m_bvhQuantization;
+
+	enum btTraversalMode
+	{
+		TRAVERSAL_STACKLESS = 0,
+		TRAVERSAL_STACKLESS_CACHE_FRIENDLY,
+		TRAVERSAL_RECURSIVE
+	};
+
+	btTraversalMode	m_traversalMode;
+
+	


+	BvhSubtreeInfoArray		m_SubtreeHeaders;
+
+
+	///two versions, one for quantized and normal nodes. This allows code-reuse while maintaining readability (no template/macro!)
+	///this might be refactored into a virtual, it is usually not calculated at run-time
+	void	setInternalNodeAabbMin(int nodeIndex, const btVector3& aabbMin)
+	{
+		if (m_useQuantization)
+		{
+			quantizeWithClamp(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0] ,aabbMin);
+		} else
+		{
+			m_contiguousNodes[nodeIndex].m_aabbMinOrg = aabbMin;
+
+		}
+	}
+	void	setInternalNodeAabbMax(int nodeIndex,const btVector3& aabbMax)
+	{
+		if (m_useQuantization)
+		{
+			quantizeWithClamp(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0],aabbMax);
+		} else
+		{
+			m_contiguousNodes[nodeIndex].m_aabbMaxOrg = aabbMax;
+		}
+	}
+
+	btVector3 getAabbMin(int nodeIndex) const
+	{
+		if (m_useQuantization)
+		{
+			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMin[0]);
+		}
+		//non-quantized
+		return m_leafNodes[nodeIndex].m_aabbMinOrg;
+
+	}
+	btVector3 getAabbMax(int nodeIndex) const
+	{
+		if (m_useQuantization)
+		{
+			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMax[0]);
+		} 
+		//non-quantized
+		return m_leafNodes[nodeIndex].m_aabbMaxOrg;
+		
+	}
+
+	void	setQuantizationValues(const btVector3& bvhAabbMin,const btVector3& bvhAabbMax,btScalar quantizationMargin=btScalar(1.0));
+	
+	void	setInternalNodeEscapeIndex(int nodeIndex, int escapeIndex)
+	{
+		if (m_useQuantization)
+		{
+			m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = -escapeIndex;
+		} 
+		else
+		{
+			m_contiguousNodes[nodeIndex].m_escapeIndex = escapeIndex;
+		}
+
+	}
+
+	void mergeInternalNodeAabb(int nodeIndex,const btVector3& newAabbMin,const btVector3& newAabbMax) 
+	{
+		if (m_useQuantization)
+		{
+			unsigned short int quantizedAabbMin[3];
+			unsigned short int quantizedAabbMax[3];
+			quantizeWithClamp(quantizedAabbMin,newAabbMin);
+			quantizeWithClamp(quantizedAabbMax,newAabbMax);
+			for (int i=0;i<3;i++)
+			{
+				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] > quantizedAabbMin[i])
+					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] = quantizedAabbMin[i];
+
+				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] < quantizedAabbMax[i])
+					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] = quantizedAabbMax[i];
+
+			}
+		} else
+		{
+			//non-quantized
+			m_contiguousNodes[nodeIndex].m_aabbMinOrg.setMin(newAabbMin);
+			m_contiguousNodes[nodeIndex].m_aabbMaxOrg.setMax(newAabbMax);		
+		}
+	}
+
+	void	swapLeafNodes(int firstIndex,int secondIndex);
+
+	void	assignInternalNodeFromLeafNode(int internalNode,int leafNodeIndex);
+
+protected:
+
+	
+
+	void	buildTree	(int startIndex,int endIndex);
+
+	int	calcSplittingAxis(int startIndex,int endIndex);
+
+	int	sortAndCalcSplittingIndex(int startIndex,int endIndex,int splitAxis);
+	
+	void	walkStacklessTree(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
+
+	void	walkStacklessQuantizedTree(btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax,int startNodeIndex,int endNodeIndex) const;
+
+	///tree traversal designed for small-memory processors like PS3 SPU
+	void	walkStacklessQuantizedTreeCacheFriendly(btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const;
+
+	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
+	void	walkRecursiveQuantizedTreeAgainstQueryAabb(const btQuantizedBvhNode* currentNode,btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const;
+
+	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
+	void	walkRecursiveQuantizedTreeAgainstQuantizedTree(const btQuantizedBvhNode* treeNodeA,const btQuantizedBvhNode* treeNodeB,btNodeOverlapCallback* nodeCallback) const;
+	
+
+	inline bool testQuantizedAabbAgainstQuantizedAabb(unsigned short int* aabbMin1,unsigned short int* aabbMax1,const unsigned short int* aabbMin2,const unsigned short int* aabbMax2) const
+	{
+		bool overlap = true;
+		overlap = (aabbMin1[0] > aabbMax2[0] || aabbMax1[0] < aabbMin2[0]) ? false : overlap;
+		overlap = (aabbMin1[2] > aabbMax2[2] || aabbMax1[2] < aabbMin2[2]) ? false : overlap;
+		overlap = (aabbMin1[1] > aabbMax2[1] || aabbMax1[1] < aabbMin2[1]) ? false : overlap;
+		return overlap;
+	}
+
+	void	updateSubtreeHeaders(int leftChildNodexIndex,int rightChildNodexIndex);

 public:
 	btOptimizedBvh();

 	virtual ~btOptimizedBvh();
-	
-	void	build(btStridingMeshInterface* triangles);

-	btOptimizedBvhNode*	buildTree	(NodeArray&	leafNodes,int startIndex,int endIndex);
-
-	int	calcSplittingAxis(NodeArray&	leafNodes,int startIndex,int endIndex);
-
-	int	sortAndCalcSplittingIndex(NodeArray&	leafNodes,int startIndex,int endIndex,int splitAxis);
-	
-	void	walkTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
-	
-	void	walkStacklessTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
-	
-
-	//OptimizedBvhNode*	GetRootNode() { return m_rootNode1;}
-
-	int					getNumNodes() { return m_numNodes;}
+	void	build(btStridingMeshInterface* triangles,bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax);

 	void	reportAabbOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;

 	void	reportSphereOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;

+	void quantizeWithClamp(unsigned short* out, const btVector3& point) const;
+	
+	btVector3	unQuantize(const unsigned short* vecIn) const;

-};
+	///setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees.
+	void	setTraversalMode(btTraversalMode	traversalMode)
+	{
+		m_traversalMode = traversalMode;
+	}
+
+	void	refit(btStridingMeshInterface* triangles);
+
+	void	refitPartial(btStridingMeshInterface* triangles,const btVector3& aabbMin, const btVector3& aabbMax);
+
+	void	updateBvhNodes(btStridingMeshInterface* meshInterface,int firstNode,int endNode,int index);
+
+
+	QuantizedNodeArray&	getQuantizedNodeArray()
+	{	
+		return	m_quantizedContiguousNodes;
+	}
+
+	BvhSubtreeInfoArray&	getSubtreeInfoArray()
+	{
+		return m_SubtreeHeaders;
+	}
+
+}
+;


 #endif //OPTIMIZED_BVH_H
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp
@@ -16,7 +16,10 @@ subject to the following restrictions:
 #include <BulletCollision/CollisionShapes/btPolyhedralConvexShape.h>

 btPolyhedralConvexShape::btPolyhedralConvexShape()
-:m_optionalHull(0)
+:m_localAabbMin(1,1,1),
+m_localAabbMax(-1,-1,-1),
+m_isLocalAabbValid(false),
+m_optionalHull(0)
 {

 }
@@ -28,16 +31,16 @@ btVector3	btPolyhedralConvexShape::localGetSupportingVertexWithoutMargin(const b
 	int i;
 	btVector3 supVec(0,0,0);

-	btScalar maxDot(-1e30f);
+	btScalar maxDot(btScalar(-1e30));

 	btVector3 vec = vec0;
 	btScalar lenSqr = vec.length2();
-	if (lenSqr < 0.0001f)
+	if (lenSqr < btScalar(0.0001))
 	{
 		vec.setValue(1,0,0);
 	} else
 	{
-		float rlen = 1.f / btSqrt(lenSqr );
+		btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 		vec *= rlen;
 	}

@@ -68,7 +71,7 @@ void	btPolyhedralConvexShape::batchedUnitVectorGetSupportingVertexWithoutMargin(

 	for (i=0;i<numVectors;i++)
 	{
-		supportVerticesOut[i][3] = -1e30f;
+		supportVerticesOut[i][3] = btScalar(-1e30);
 	}

 	for (int j=0;j<numVectors;j++)
@@ -96,23 +99,50 @@ void	btPolyhedralConvexShape::calculateLocalInertia(btScalar mass,btVector3& ine
 {
 	//not yet, return box inertia

-	float margin = getMargin();
+	btScalar margin = getMargin();

 	btTransform ident;
 	ident.setIdentity();
 	btVector3 aabbMin,aabbMax;
 	getAabb(ident,aabbMin,aabbMax);
-	btVector3 halfExtents = (aabbMax-aabbMin)*0.5f;
+	btVector3 halfExtents = (aabbMax-aabbMin)*btScalar(0.5);

-	btScalar lx=2.f*(halfExtents.x()+margin);
-	btScalar ly=2.f*(halfExtents.y()+margin);
-	btScalar lz=2.f*(halfExtents.z()+margin);
+	btScalar lx=btScalar(2.)*(halfExtents.x()+margin);
+	btScalar ly=btScalar(2.)*(halfExtents.y()+margin);
+	btScalar lz=btScalar(2.)*(halfExtents.z()+margin);
 	const btScalar x2 = lx*lx;
 	const btScalar y2 = ly*ly;
 	const btScalar z2 = lz*lz;
-	const btScalar scaledmass = mass * 0.08333333f;
+	const btScalar scaledmass = mass * btScalar(0.08333333);

 	inertia = scaledmass * (btVector3(y2+z2,x2+z2,x2+y2));

 }

+
+
+void btPolyhedralConvexShape::getAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
+{
+	getNonvirtualAabb(trans,aabbMin,aabbMax,getMargin());
+}
+
+
+
+
+void	btPolyhedralConvexShape::recalcLocalAabb()
+{
+	m_isLocalAabbValid = true;
+
+	for (int i=0;i<3;i++)
+	{
+		btVector3 vec(btScalar(0.),btScalar(0.),btScalar(0.));
+		vec[i] = btScalar(1.);
+		btVector3 tmp = localGetSupportingVertex(vec);
+		m_localAabbMax[i] = tmp[i]+m_collisionMargin;
+		vec[i] = btScalar(-1.);
+		tmp = localGetSupportingVertex(vec);
+		m_localAabbMin[i] = tmp[i]-m_collisionMargin;
+	}
+}
+
+
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h
@@ -16,15 +16,20 @@ subject to the following restrictions:
 #ifndef BU_SHAPE
 #define BU_SHAPE

-#include <LinearMath/btPoint3.h>
-#include <LinearMath/btMatrix3x3.h>
-#include <BulletCollision/CollisionShapes/btConvexShape.h>
+#include "../../LinearMath/btPoint3.h"
+#include "../../LinearMath/btMatrix3x3.h"
+#include "btConvexShape.h"


 ///PolyhedralConvexShape is an interface class for feature based (vertex/edge/face) convex shapes.
 class btPolyhedralConvexShape : public btConvexShape
 {

+protected:
+	btVector3	m_localAabbMin;
+	btVector3	m_localAabbMax;
+	bool		m_isLocalAabbValid;
+
 public:

 	btPolyhedralConvexShape();
@@ -36,6 +41,39 @@ public:
 	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia);


+	inline void getNonvirtualAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax, btScalar margin) const
+	{
+
+		//lazy evaluation of local aabb
+		btAssert(m_isLocalAabbValid);
+
+		btAssert(m_localAabbMin.getX() <= m_localAabbMax.getX());
+		btAssert(m_localAabbMin.getY() <= m_localAabbMax.getY());
+		btAssert(m_localAabbMin.getZ() <= m_localAabbMax.getZ());
+
+
+		btVector3 localHalfExtents = btScalar(0.5)*(m_localAabbMax-m_localAabbMin);
+		btVector3 localCenter = btScalar(0.5)*(m_localAabbMax+m_localAabbMin);
+		
+		btMatrix3x3 abs_b = trans.getBasis().absolute();  
+
+		btPoint3 center = trans(localCenter);
+
+		btVector3 extent = btVector3(abs_b[0].dot(localHalfExtents),
+			   abs_b[1].dot(localHalfExtents),
+			  abs_b[2].dot(localHalfExtents));
+		extent += btVector3(margin,margin,margin);
+
+		aabbMin = center - extent;
+		aabbMax = center + extent;
+
+		
+	}
+
+	
+	virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const;
+
+	void	recalcLocalAabb();

 	virtual int	getNumVertices() const = 0 ;
 	virtual int getNumEdges() const = 0;
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btSphereShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btSphereShape.cpp
@@ -26,14 +26,17 @@ btSphereShape ::btSphereShape (btScalar radius)

 btVector3	btSphereShape::localGetSupportingVertexWithoutMargin(const btVector3& vec)const
 {
-	return btVector3(0.f,0.f,0.f);
+	(void)vec;
+	return btVector3(btScalar(0.),btScalar(0.),btScalar(0.));
 }

 void	btSphereShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
 {
+	(void)vectors;
+
 	for (int i=0;i<numVectors;i++)
 	{
-		supportVerticesOut[i].setValue(0.f,0.f,0.f);
+		supportVerticesOut[i].setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 	}
 }

@@ -46,7 +49,7 @@ btVector3	btSphereShape::localGetSupportingVertex(const btVector3& vec)const
 	btVector3 vecnorm = vec;
 	if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
 	{
-		vecnorm.setValue(-1.f,-1.f,-1.f);
+		vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
 	} 
 	vecnorm.normalize();
 	supVertex+= getMargin() * vecnorm;
@@ -67,8 +70,8 @@ void btSphereShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& a

 void	btSphereShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 {
-	btScalar elem = 0.4f * mass * getMargin()*getMargin();
-	inertia[0] = inertia[1] = inertia[2] = elem;
+	btScalar elem = btScalar(0.4) * mass * getMargin()*getMargin();
+	inertia.setValue(elem,elem,elem);

 }

--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btSphereShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btSphereShape.h
@@ -17,10 +17,10 @@ subject to the following restrictions:
 #define SPHERE_MINKOWSKI_H

 #include "btConvexShape.h"
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
+#include "../BroadphaseCollision/btBroadphaseProxy.h" // for the types

 ///btSphereShape implements an implicit (getSupportingVertex) Sphere
-class btSphereShape : public btConvexShape
+ATTRIBUTE_ALIGNED16(class) btSphereShape : public btConvexShape

 {
 	
@@ -45,11 +45,11 @@ public:
 	//debugging
 	virtual char*	getName()const {return "SPHERE";}

-	virtual void	setMargin(float margin)
+	virtual void	setMargin(btScalar margin)
 	{
 		btConvexShape::setMargin(margin);
 	}
-	virtual float	getMargin() const
+	virtual btScalar	getMargin() const
 	{
 		//to improve gjk behaviour, use radius+margin as the full margin, so never get into the penetration case
 		//this means, non-uniform scaling is not supported anymore
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp
@@ -21,7 +21,7 @@ subject to the following restrictions:
 btStaticPlaneShape::btStaticPlaneShape(const btVector3& planeNormal,btScalar planeConstant)
 :m_planeNormal(planeNormal),
 m_planeConstant(planeConstant),
-m_localScaling(0.f,0.f,0.f)
+m_localScaling(btScalar(0.),btScalar(0.),btScalar(0.))
 {
 }

@@ -34,16 +34,19 @@ btStaticPlaneShape::~btStaticPlaneShape()

 void btStaticPlaneShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
 {
-	btVector3 infvec (1e30f,1e30f,1e30f);
+	(void)t;
+	/*
+	btVector3 infvec (btScalar(1e30),btScalar(1e30),btScalar(1e30));

 	btVector3 center = m_planeNormal*m_planeConstant;
 	aabbMin = center + infvec*m_planeNormal;
 	aabbMax = aabbMin;
 	aabbMin.setMin(center - infvec*m_planeNormal);
 	aabbMax.setMax(center - infvec*m_planeNormal); 
+	*/

-	aabbMin.setValue(-1e30f,-1e30f,-1e30f);
-	aabbMax.setValue(1e30f,1e30f,1e30f);
+	aabbMin.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+	aabbMax.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));

 }

@@ -53,9 +56,9 @@ void btStaticPlaneShape::getAabb(const btTransform& t,btVector3& aabbMin,btVecto
 void	btStaticPlaneShape::processAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {

-	btVector3 halfExtents = (aabbMax - aabbMin) * 0.5f;
+	btVector3 halfExtents = (aabbMax - aabbMin) * btScalar(0.5);
 	btScalar radius = halfExtents.length();
-	btVector3 center = (aabbMax + aabbMin) * 0.5f;
+	btVector3 center = (aabbMax + aabbMin) * btScalar(0.5);
 	
 	//this is where the triangles are generated, given AABB and plane equation (normal/constant)

@@ -85,9 +88,11 @@ void	btStaticPlaneShape::processAllTriangles(btTriangleCallback* callback,const

 void	btStaticPlaneShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 {
+	(void)mass;
+
 	//moving concave objects not supported
 	
-	inertia.setValue(0.f,0.f,0.f);
+	inertia.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 }

 void	btStaticPlaneShape::setLocalScaling(const btVector3& scaling)
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btStaticPlaneShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btStaticPlaneShape.h
@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef STATIC_PLANE_SHAPE_H
 #define STATIC_PLANE_SHAPE_H

-#include "BulletCollision/CollisionShapes/btConcaveShape.h"
+#include "btConcaveShape.h"


 ///StaticPlaneShape simulates an 'infinite' plane by dynamically reporting triangles approximated by intersection of the plane with the AABB.
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
@@ -23,6 +23,8 @@ btStridingMeshInterface::~btStridingMeshInterface()

 void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleIndexCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
+	(void)aabbMin;
+	(void)aabbMax;
 	int numtotalphysicsverts = 0;
 	int part,graphicssubparts = getNumSubParts();
 	const unsigned char * vertexbase;
@@ -33,7 +35,7 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 	int stride,numverts,numtriangles;
 	int gfxindex;
 	btVector3 triangle[3];
-	float* graphicsbase;
+	btScalar* graphicsbase;

 	btVector3 meshScaling = getScaling();

@@ -50,11 +52,11 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 				for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
 				{
 					int* tri_indices= (int*)(indexbase+gfxindex*indexstride);
-					graphicsbase = (float*)(vertexbase+tri_indices[0]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[0]*stride);
 					triangle[0].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),graphicsbase[2]*meshScaling.getZ());
-					graphicsbase = (float*)(vertexbase+tri_indices[1]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[1]*stride);
 					triangle[1].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),	graphicsbase[2]*meshScaling.getZ());
-					graphicsbase = (float*)(vertexbase+tri_indices[2]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[2]*stride);
 					triangle[2].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),	graphicsbase[2]*meshScaling.getZ());
 					callback->internalProcessTriangleIndex(triangle,part,gfxindex);
 				}
@@ -65,11 +67,11 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 				for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
 				{
 					short int* tri_indices= (short int*)(indexbase+gfxindex*indexstride);
-					graphicsbase = (float*)(vertexbase+tri_indices[0]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[0]*stride);
 					triangle[0].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),graphicsbase[2]*meshScaling.getZ());
-					graphicsbase = (float*)(vertexbase+tri_indices[1]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[1]*stride);
 					triangle[1].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),	graphicsbase[2]*meshScaling.getZ());
-					graphicsbase = (float*)(vertexbase+tri_indices[2]*stride);
+					graphicsbase = (btScalar*)(vertexbase+tri_indices[2]*stride);
 					triangle[2].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),	graphicsbase[2]*meshScaling.getZ());
 					callback->internalProcessTriangleIndex(triangle,part,gfxindex);
 				}
@@ -83,3 +85,40 @@ void	btStridingMeshInterface::InternalProcessAllTriangles(btInternalTriangleInde
 	}
 }

+void	btStridingMeshInterface::calculateAabbBruteForce(btVector3& aabbMin,btVector3& aabbMax)
+{
+
+	struct	AabbCalculationCallback : public btInternalTriangleIndexCallback
+	{
+		btVector3	m_aabbMin;
+		btVector3	m_aabbMax;
+
+		AabbCalculationCallback()
+		{
+			m_aabbMin.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+			m_aabbMax.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+		}
+
+		virtual void internalProcessTriangleIndex(btVector3* triangle,int partId,int  triangleIndex)
+		{
+			(void)partId;
+			(void)triangleIndex;
+
+			m_aabbMin.setMin(triangle[0]);
+			m_aabbMax.setMax(triangle[0]);
+			m_aabbMin.setMin(triangle[1]);
+			m_aabbMax.setMax(triangle[1]);
+			m_aabbMin.setMin(triangle[2]);
+			m_aabbMax.setMax(triangle[2]);
+		}
+	};
+
+		//first calculate the total aabb for all triangles
+	AabbCalculationCallback	aabbCallback;
+	aabbMin.setValue(btScalar(-1e30),btScalar(-1e30),btScalar(-1e30));
+	aabbMax.setValue(btScalar(1e30),btScalar(1e30),btScalar(1e30));
+	InternalProcessAllTriangles(&aabbCallback,aabbMin,aabbMax);
+
+	aabbMin = aabbCallback.m_aabbMin;
+	aabbMax = aabbCallback.m_aabbMax;
+}
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef STRIDING_MESHINTERFACE_H
 #define STRIDING_MESHINTERFACE_H

-#include "LinearMath/btVector3.h"
+#include "../../LinearMath/btVector3.h"
 #include "btTriangleCallback.h"

 /// PHY_ScalarType enumerates possible scalar types.
@@ -38,7 +38,7 @@ class  btStridingMeshInterface
 		btVector3 m_scaling;

 	public:
-		btStridingMeshInterface() :m_scaling(1.f,1.f,1.f)
+		btStridingMeshInterface() :m_scaling(btScalar(1.),btScalar(1.),btScalar(1.))
 		{

 		}
@@ -49,6 +49,8 @@ class  btStridingMeshInterface

 		void	InternalProcessAllTriangles(btInternalTriangleIndexCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const;

+		///brute force method to calculate aabb
+		void	calculateAabbBruteForce(btVector3& aabbMin,btVector3& aabbMax);

 		/// get read and write access to a subpart of a triangle mesh
 		/// this subpart has a continuous array of vertices and indices
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTetrahedronShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTetrahedronShape.cpp
@@ -58,6 +58,8 @@ btBU_Simplex1to4::btBU_Simplex1to4(const btPoint3& pt0,const btPoint3& pt1,const
 void btBU_Simplex1to4::addVertex(const btPoint3& pt)
 {
 	m_vertices[m_numVertices++] = pt;
+
+	recalcLocalAabb();
 }


@@ -176,17 +178,17 @@ int	btBU_Simplex1to4::getNumPlanes() const
 }


-void btBU_Simplex1to4::getPlane(btVector3& planeNormal,btPoint3& planeSupport,int i) const
+void btBU_Simplex1to4::getPlane(btVector3&, btPoint3& ,int ) const
 {
 	
 }

-int btBU_Simplex1to4::getIndex(int i) const
+int btBU_Simplex1to4::getIndex(int ) const
 {
 	return 0;
 }

-bool btBU_Simplex1to4::isInside(const btPoint3& pt,btScalar tolerance) const
+bool btBU_Simplex1to4::isInside(const btPoint3& ,btScalar ) const
 {
 	return false;
 }
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTetrahedronShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTetrahedronShape.h
@@ -17,8 +17,8 @@ subject to the following restrictions:
 #define BU_SIMPLEX_1TO4_SHAPE


-#include <BulletCollision/CollisionShapes/btPolyhedralConvexShape.h>
-#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "btPolyhedralConvexShape.h"
+#include "../BroadphaseCollision/btBroadphaseProxy.h"


 ///BU_Simplex1to4 implements feature based and implicit simplex of up to 4 vertices (tetrahedron, triangle, line, vertex).
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleBuffer.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleBuffer.h
@@ -17,8 +17,7 @@ subject to the following restrictions:
 #define BT_TRIANGLE_BUFFER_H

 #include "btTriangleCallback.h"
-//#include <vector>
-#include "LinearMath/btAlignedObjectArray.h"
+#include "../../LinearMath/btAlignedObjectArray.h"

 struct	btTriangle
 {
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleCallback.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleCallback.h
@@ -16,7 +16,7 @@ subject to the following restrictions:
 #ifndef TRIANGLE_CALLBACK_H
 #define TRIANGLE_CALLBACK_H

-#include "LinearMath/btVector3.h"
+#include "../../LinearMath/btVector3.h"


 class btTriangleCallback
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp
@@ -15,15 +15,15 @@ subject to the following restrictions:

 #include "btTriangleIndexVertexArray.h"

-btTriangleIndexVertexArray::btTriangleIndexVertexArray(int numTriangles,int* triangleIndexBase,int triangleIndexStride,int numVertices,float* vertexBase,int vertexStride)
+btTriangleIndexVertexArray::btTriangleIndexVertexArray(int numTriangles,int* triangleIndexBase,int triangleIndexStride,int numVertices,btScalar* vertexBase,int vertexStride)
 {
 	btIndexedMesh mesh;
 	
 	mesh.m_numTriangles = numTriangles;
-	mesh.m_triangleIndexBase = triangleIndexBase;
+	mesh.m_triangleIndexBase = (const unsigned char *)triangleIndexBase;
 	mesh.m_triangleIndexStride = triangleIndexStride;
 	mesh.m_numVertices = numVertices;
-	mesh.m_vertexBase = vertexBase;
+	mesh.m_vertexBase = (const unsigned char *)vertexBase;
 	mesh.m_vertexStride = vertexStride;
 	
 	addIndexedMesh(mesh);
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h
@@ -17,40 +17,44 @@ subject to the following restrictions:
 #define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H

 #include "btStridingMeshInterface.h"
-#include <LinearMath/btAlignedObjectArray.h>
+#include "../../LinearMath/btAlignedObjectArray.h"

 ///IndexedMesh indexes into existing vertex and index arrays, in a similar way OpenGL glDrawElements
 ///instead of the number of indices, we pass the number of triangles
 ///todo: explain with pictures
-struct	btIndexedMesh
-	{
-		int			m_numTriangles;
-		int*		m_triangleIndexBase;
-		int			m_triangleIndexStride;
-		int			m_numVertices;
-		float*		m_vertexBase;
-		int			m_vertexStride;
-	};
+ATTRIBUTE_ALIGNED16( struct)	btIndexedMesh
+{
+	int			m_numTriangles;
+	const unsigned char *		m_triangleIndexBase;
+	int			m_triangleIndexStride;
+	int			m_numVertices;
+	const unsigned char *		m_vertexBase;
+	int			m_vertexStride;
+	int			pad[2];
+}
+;
+
+
+typedef btAlignedObjectArray<btIndexedMesh>	IndexedMeshArray;

 ///TriangleIndexVertexArray allows to use multiple meshes, by indexing into existing triangle/index arrays.
 ///Additional meshes can be added using addIndexedMesh
 ///No duplcate is made of the vertex/index data, it only indexes into external vertex/index arrays.
 ///So keep those arrays around during the lifetime of this btTriangleIndexVertexArray.
-class btTriangleIndexVertexArray : public btStridingMeshInterface
+ATTRIBUTE_ALIGNED16( class) btTriangleIndexVertexArray : public btStridingMeshInterface
 {
-	btAlignedObjectArray<btIndexedMesh>	m_indexedMeshes;
+	IndexedMeshArray	m_indexedMeshes;
+	int m_pad[3];

 		
 public:

-	
-
 	btTriangleIndexVertexArray()
 	{
 	}

 	//just to be backwards compatible
-	btTriangleIndexVertexArray(int numTriangleIndices,int* triangleIndexBase,int triangleIndexStride,int numVertices,float* vertexBase,int vertexStride);
+	btTriangleIndexVertexArray(int numTriangleIndices,int* triangleIndexBase,int triangleIndexStride,int numVertices,btScalar* vertexBase,int vertexStride);
 	
 	void	addIndexedMesh(const btIndexedMesh& mesh)
 	{
@@ -64,19 +68,30 @@ public:

 	/// unLockVertexBase finishes the access to a subpart of the triangle mesh
 	/// make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished
-	virtual void	unLockVertexBase(int subpart) {}
+	virtual void	unLockVertexBase(int subpart) {(void)subpart;}

-	virtual void	unLockReadOnlyVertexBase(int subpart) const {}
+	virtual void	unLockReadOnlyVertexBase(int subpart) const {(void)subpart;}

 	/// getNumSubParts returns the number of seperate subparts
 	/// each subpart has a continuous array of vertices and indices
 	virtual int		getNumSubParts() const { 
 		return (int)m_indexedMeshes.size();
 	}
-	
-	virtual void	preallocateVertices(int numverts){}
-	virtual void	preallocateIndices(int numindices){}

-};
+	IndexedMeshArray&	getIndexedMeshArray()
+	{
+		return m_indexedMeshes;
+	}
+
+	const IndexedMeshArray&	getIndexedMeshArray() const
+	{
+		return m_indexedMeshes;
+	}
+
+	virtual void	preallocateVertices(int numverts){(void) numverts;}
+	virtual void	preallocateIndices(int numindices){(void) numindices;}
+
+}
+;

 #endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMesh.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMesh.cpp
@@ -16,7 +16,6 @@ subject to the following restrictions:
 #include "btTriangleMesh.h"
 #include <assert.h>

-static int	myindices[3] = {0,1,2};

 btTriangleMesh::btTriangleMesh ()
 {
@@ -25,31 +24,31 @@ btTriangleMesh::btTriangleMesh ()

 void	btTriangleMesh::getLockedVertexIndexBase(unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& stride,unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart)
 {
-	numverts = 3;
-	*vertexbase = (unsigned char*)&m_triangles[subpart];
+	(void)subpart;
+	numverts = m_vertices.size();
+	*vertexbase = (unsigned char*)&m_vertices[0];
 	type = PHY_FLOAT;
 	stride = sizeof(btVector3);

-
-	numfaces = 1;
-	*indexbase = (unsigned char*) &myindices[0];
+	numfaces = m_indices.size()/3;
+	*indexbase = (unsigned char*) &m_indices[0];
 	indicestype = PHY_INTEGER;
-	indexstride = sizeof(int);
+	indexstride = 3*sizeof(int);

 }

 void	btTriangleMesh::getLockedReadOnlyVertexIndexBase(const unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& stride,const unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart) const
 {
-	numverts = 3;
-	*vertexbase = (unsigned char*)&m_triangles[subpart];
+	(void)subpart;
+	numverts = m_vertices.size();
+	*vertexbase = (unsigned char*)&m_vertices[0];
 	type = PHY_FLOAT;
 	stride = sizeof(btVector3);

-
-	numfaces = 1;
-	*indexbase = (unsigned char*) &myindices[0];
+	numfaces = m_indices.size()/3;
+	*indexbase = (unsigned char*) &m_indices[0];
 	indicestype = PHY_INTEGER;
-	indexstride = sizeof(int);
+	indexstride = 3*sizeof(int);

 }

@@ -57,5 +56,5 @@ void	btTriangleMesh::getLockedReadOnlyVertexIndexBase(const unsigned char **vert

 int		btTriangleMesh::getNumSubParts() const
 {
-	return m_triangles.size();
+	return 1;
 }
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMesh.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMesh.h
@@ -17,42 +17,37 @@ subject to the following restrictions:
 #ifndef TRIANGLE_MESH_H
 #define TRIANGLE_MESH_H

-#include "BulletCollision/CollisionShapes/btStridingMeshInterface.h"
-#include <LinearMath/btVector3.h>
-#include "LinearMath/btAlignedObjectArray.h"
-struct btMyTriangle
-{
-	btVector3	m_vert0;
-	btVector3	m_vert1;
-	btVector3	m_vert2;
-};
+#include "btStridingMeshInterface.h"
+#include "../../LinearMath/btVector3.h"
+#include "../../LinearMath/btAlignedObjectArray.h"

 ///TriangleMesh provides storage for a concave triangle mesh. It can be used as data for the btTriangleMeshShape.
 class btTriangleMesh : public btStridingMeshInterface
 {
-	btAlignedObjectArray<btMyTriangle>	m_triangles;
+	btAlignedObjectArray<btVector3>	m_vertices;
+	btAlignedObjectArray<int>		m_indices;

 	public:
 		btTriangleMesh ();

 		void	addTriangle(const btVector3& vertex0,const btVector3& vertex1,const btVector3& vertex2)
 		{
-			btMyTriangle tri;
-			tri.m_vert0 = vertex0;
-			tri.m_vert1 = vertex1;
-			tri.m_vert2 = vertex2;
-			m_triangles.push_back(tri);
+			int curIndex = m_indices.size();
+			m_vertices.push_back(vertex0);
+			m_vertices.push_back(vertex1);
+			m_vertices.push_back(vertex2);
+
+			m_indices.push_back(curIndex++);
+			m_indices.push_back(curIndex++);
+			m_indices.push_back(curIndex++);
 		}

 		int getNumTriangles() const
 		{
-			return m_triangles.size();
+			return m_indices.size() / 3;
 		}

-		const btMyTriangle&	getTriangle(int index) const
-		{
-			return m_triangles[index];
-		}
+		

 //StridingMeshInterface interface implementation

@@ -62,16 +57,16 @@ class btTriangleMesh : public btStridingMeshInterface

 		/// unLockVertexBase finishes the access to a subpart of the triangle mesh
 		/// make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished
-		virtual void	unLockVertexBase(int subpart) {}
+		virtual void	unLockVertexBase(int subpart) {(void) subpart;}

-		virtual void	unLockReadOnlyVertexBase(int subpart) const {}
+		virtual void	unLockReadOnlyVertexBase(int subpart) const { (void) subpart;}

 		/// getNumSubParts returns the number of seperate subparts
 		/// each subpart has a continuous array of vertices and indices
 		virtual int		getNumSubParts() const;
 		
-		virtual void	preallocateVertices(int numverts){}
-		virtual void	preallocateIndices(int numindices){}
+		virtual void	preallocateVertices(int numverts){(void) numverts;}
+		virtual void	preallocateIndices(int numindices){(void) numindices;}

 		
 };
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp
@@ -40,8 +40,8 @@ btTriangleMeshShape::~btTriangleMeshShape()
 void btTriangleMeshShape::getAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
 {

-	btVector3 localHalfExtents = 0.5f*(m_localAabbMax-m_localAabbMin);
-	btVector3 localCenter = 0.5f*(m_localAabbMax+m_localAabbMin);
+	btVector3 localHalfExtents = btScalar(0.5)*(m_localAabbMax-m_localAabbMin);
+	btVector3 localCenter = btScalar(0.5)*(m_localAabbMax+m_localAabbMin);
 	
 	btMatrix3x3 abs_b = trans.getBasis().absolute();  

@@ -62,11 +62,11 @@ void	btTriangleMeshShape::recalcLocalAabb()
 {
 	for (int i=0;i<3;i++)
 	{
-		btVector3 vec(0.f,0.f,0.f);
-		vec[i] = 1.f;
+		btVector3 vec(btScalar(0.),btScalar(0.),btScalar(0.));
+		vec[i] = btScalar(1.);
 		btVector3 tmp = localGetSupportingVertex(vec);
 		m_localAabbMax[i] = tmp[i]+m_collisionMargin;
-		vec[i] = -1.f;
+		vec[i] = btScalar(-1.);
 		tmp = localGetSupportingVertex(vec);
 		m_localAabbMin[i] = tmp[i]-m_collisionMargin;
 	}
@@ -85,7 +85,7 @@ public:
 	btVector3 m_supportVecLocal;

 	SupportVertexCallback(const btVector3& supportVecWorld,const btTransform& trans)
-		: m_supportVertexLocal(0.f,0.f,0.f), m_worldTrans(trans) ,m_maxDot(-1e30f)
+		: m_supportVertexLocal(btScalar(0.),btScalar(0.),btScalar(0.)), m_worldTrans(trans) ,m_maxDot(btScalar(-1e30))
 		
 	{
 		m_supportVecLocal = supportVecWorld * m_worldTrans.getBasis();
@@ -93,6 +93,8 @@ public:

 	virtual void processTriangle( btVector3* triangle,int partId, int triangleIndex)
 	{
+		(void)partId;
+		(void)triangleIndex;
 		for (int i=0;i<3;i++)
 		{
 			btScalar dot = m_supportVecLocal.dot(triangle[i]);
@@ -138,8 +140,7 @@ const btVector3& btTriangleMeshShape::getLocalScaling() const

 void	btTriangleMeshShape::processAllTriangles(btTriangleCallback* callback,const btVector3& aabbMin,const btVector3& aabbMax) const
 {
-
-	struct FilteredCallback : public btInternalTriangleIndexCallback
+		struct FilteredCallback : public btInternalTriangleIndexCallback
 	{
 		btTriangleCallback* m_callback;
 		btVector3 m_aabbMin;
@@ -167,18 +168,19 @@ void	btTriangleMeshShape::processAllTriangles(btTriangleCallback* callback,const
 	FilteredCallback filterCallback(callback,aabbMin,aabbMax);

 	m_meshInterface->InternalProcessAllTriangles(&filterCallback,aabbMin,aabbMax);
-
 }





+
 void	btTriangleMeshShape::calculateLocalInertia(btScalar mass,btVector3& inertia)
 {
+	(void)mass;
 	//moving concave objects not supported
-	assert(0);
-	inertia.setValue(0.f,0.f,0.f);
+	btAssert(0);
+	inertia.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 }


@@ -191,7 +193,7 @@ btVector3 btTriangleMeshShape::localGetSupportingVertex(const btVector3& vec) co

 	SupportVertexCallback supportCallback(vec,ident);

-	btVector3 aabbMax(1e30f,1e30f,1e30f);
+	btVector3 aabbMax(btScalar(1e30),btScalar(1e30),btScalar(1e30));
 	
 	processAllTriangles(&supportCallback,-aabbMax,aabbMax);
 		
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMeshShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMeshShape.h
@@ -16,17 +16,17 @@ subject to the following restrictions:
 #ifndef TRIANGLE_MESH_SHAPE_H
 #define TRIANGLE_MESH_SHAPE_H

-#include "BulletCollision/CollisionShapes/btConcaveShape.h"
-#include "BulletCollision/CollisionShapes/btStridingMeshInterface.h"
+#include "btConcaveShape.h"
+#include "btStridingMeshInterface.h"


 ///Concave triangle mesh. Uses an interface to access the triangles to allow for sharing graphics/physics triangles.
 class btTriangleMeshShape : public btConcaveShape
 {
 protected:
-	btStridingMeshInterface* m_meshInterface;
 	btVector3	m_localAabbMin;
 	btVector3	m_localAabbMax;
+	btStridingMeshInterface* m_meshInterface;
 	

 public:
@@ -58,6 +58,16 @@ public:
 	virtual void	setLocalScaling(const btVector3& scaling);
 	virtual const btVector3& getLocalScaling() const;
 	
+	btStridingMeshInterface* getMeshInterface()
+	{
+		return m_meshInterface;
+	}
+
+	const btStridingMeshInterface* getMeshInterface() const
+	{
+		return m_meshInterface;
+	}
+

 	//debugging
 	virtual char*	getName()const {return "TRIANGLEMESH";}
--- a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleShape.h
+++ b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleShape.h
@@ -17,7 +17,7 @@ subject to the following restrictions:
 #define OBB_TRIANGLE_MINKOWSKI_H

 #include "btConvexShape.h"
-#include "BulletCollision/CollisionShapes/btBoxShape.h"
+#include "btBoxShape.h"

 class btTriangleShape : public btPolyhedralConvexShape
 {
@@ -57,6 +57,7 @@ public:
 		getVertex((i+1)%3,pb);
 	}

+
 	virtual void getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax)const 
 	{
 //		btAssert(0);
@@ -110,14 +111,16 @@ public:

 	virtual void getPlaneEquation(int i, btVector3& planeNormal,btPoint3& planeSupport) const
 	{
+		(void)i;
 		calcNormal(planeNormal);
 		planeSupport = m_vertices1[0];
 	}

 	virtual void	calculateLocalInertia(btScalar mass,btVector3& inertia)
 	{
+		(void)mass;
 		btAssert(0);
-		inertia.setValue(0.f,0.f,0.f);
+		inertia.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 	}

 		virtual	bool isInside(const btPoint3& pt,btScalar tolerance) const
@@ -166,7 +169,7 @@ public:
 		{
 			calcNormal(penetrationVector);
 			if (index)
-				penetrationVector *= -1.f;
+				penetrationVector *= btScalar(-1.);
 		}


--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp
@@ -49,28 +49,28 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(

 	/// compute linear and angular velocity for this interval, to interpolate
 	btVector3 linVelA,angVelA,linVelB,angVelB;
-	btTransformUtil::calculateVelocity(fromA,toA,1.f,linVelA,angVelA);
-	btTransformUtil::calculateVelocity(fromB,toB,1.f,linVelB,angVelB);
+	btTransformUtil::calculateVelocity(fromA,toA,btScalar(1.),linVelA,angVelA);
+	btTransformUtil::calculateVelocity(fromB,toB,btScalar(1.),linVelB,angVelB);

 	btScalar boundingRadiusA = m_convexA->getAngularMotionDisc();
 	btScalar boundingRadiusB = m_convexB->getAngularMotionDisc();

 	btScalar maxAngularProjectedVelocity = angVelA.length() * boundingRadiusA + angVelB.length() * boundingRadiusB;

-	float radius = 0.001f;
+	btScalar radius = btScalar(0.001);

-	btScalar lambda = 0.f;
+	btScalar lambda = btScalar(0.);
 	btVector3 v(1,0,0);

 	int maxIter = MAX_ITERATIONS;

 	btVector3 n;
-	n.setValue(0.f,0.f,0.f);
+	n.setValue(btScalar(0.),btScalar(0.),btScalar(0.));
 	bool hasResult = false;
 	btVector3 c;

-	float lastLambda = lambda;
-	//float epsilon = 0.001f;
+	btScalar lastLambda = lambda;
+	//btScalar epsilon = btScalar(0.001);

 	int numIter = 0;
 	//first solution, using GJK
@@ -79,8 +79,8 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 	btTransform identityTrans;
 	identityTrans.setIdentity();

-	btSphereShape	raySphere(0.0f);
-	raySphere.setMargin(0.f);
+	btSphereShape	raySphere(btScalar(0.0));
+	raySphere.setMargin(btScalar(0.));


 //	result.drawCoordSystem(sphereTr);
@@ -116,23 +116,23 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 			if (numIter > maxIter)
 				return false; //todo: report a failure

-			float dLambda = 0.f;
+			btScalar dLambda = btScalar(0.);

 			//calculate safe moving fraction from distance / (linear+rotational velocity)
 			
-			//float clippedDist  = GEN_min(angularConservativeRadius,dist);
-			//float clippedDist  = dist;
+			//btScalar clippedDist  = GEN_min(angularConservativeRadius,dist);
+			//btScalar clippedDist  = dist;
 			
-			float projectedLinearVelocity = (linVelB-linVelA).dot(n);
+			btScalar projectedLinearVelocity = (linVelB-linVelA).dot(n);
 			
 			dLambda = dist / (projectedLinearVelocity+ maxAngularProjectedVelocity);

 			lambda = lambda + dLambda;

-			if (lambda > 1.f)
+			if (lambda > btScalar(1.))
 				return false;

-			if (lambda < 0.f)
+			if (lambda < btScalar(0.))
 				return false;

 			//todo: next check with relative epsilon
@@ -159,7 +159,7 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 			gjk.getClosestPoints(input,pointCollector,0);
 			if (pointCollector.m_hasResult)
 			{
-				if (pointCollector.m_distance < 0.f)
+				if (pointCollector.m_distance < btScalar(0.))
 				{
 					//degenerate ?!
 					result.m_fraction = lastLambda;
@@ -188,9 +188,9 @@ bool	btContinuousConvexCollision::calcTimeOfImpact(
 //todo:
 	//if movement away from normal, discard result
 	btVector3 move = transBLocalTo.getOrigin() - transBLocalFrom.getOrigin();
-	if (result.m_fraction < 1.f)
+	if (result.m_fraction < btScalar(1.))
 	{
-		if (move.dot(result.m_normal) <= 0.f)
+		if (move.dot(result.m_normal) <= btScalar(0.))
 		{
 		}
 	}
--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btConvexCast.h
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btConvexCast.h
@@ -17,11 +17,11 @@ subject to the following restrictions:
 #ifndef CONVEX_CAST_H
 #define CONVEX_CAST_H

-#include <LinearMath/btTransform.h>
-#include <LinearMath/btVector3.h>
-#include <LinearMath/btScalar.h>
+#include "../../LinearMath/btTransform.h"
+#include "../../LinearMath/btVector3.h"
+#include "../../LinearMath/btScalar.h"
 class btMinkowskiSumShape;
-#include "LinearMath/btIDebugDraw.h"
+#include "../../LinearMath/btIDebugDraw.h"

 /// btConvexCast is an interface for Casting
 class btConvexCast
@@ -37,11 +37,11 @@ public:
 	{
 		//virtual bool	addRayResult(const btVector3& normal,btScalar	fraction) = 0;
 				
-		virtual void	DebugDraw(btScalar	fraction) {}
-		virtual void	drawCoordSystem(const btTransform& trans) {}
+		virtual void	DebugDraw(btScalar	fraction) {(void)fraction;}
+		virtual void	drawCoordSystem(const btTransform& trans) {(void)trans;}

 		CastResult()
-			:m_fraction(1e30f),
+			:m_fraction(btScalar(1e30)),
 			m_debugDrawer(0)
 		{
 		}
--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h
@@ -21,7 +21,7 @@ class btStackAlloc;
 class btVector3;
 #include "btSimplexSolverInterface.h"
 class btConvexShape;
-#include "LinearMath/btPoint3.h"
+#include "../../LinearMath/btPoint3.h"
 class btTransform;

 ///ConvexPenetrationDepthSolver provides an interface for penetration depth calculation.
--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h
@@ -16,8 +16,8 @@ subject to the following restrictions:

 #ifndef DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
 #define DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
-#include "LinearMath/btTransform.h"
-#include "LinearMath/btVector3.h"
+#include "../../LinearMath/btTransform.h"
+#include "../../LinearMath/btVector3.h"
 class btStackAlloc;

 /// This interface is made to be used by an iterative approach to do TimeOfImpact calculations
@@ -30,19 +30,18 @@ struct btDiscreteCollisionDetectorInterface
 	
 	struct Result
 	{
-		void operator delete(void* ptr) {};
 	
 		virtual ~Result(){}	

 		///setShapeIdentifiers provides experimental support for per-triangle material / custom material combiner
 		virtual void setShapeIdentifiers(int partId0,int index0,	int partId1,int index1)=0;
-		virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)=0;
+		virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)=0;
 	};

 	struct ClosestPointInput
 	{
 		ClosestPointInput()
-			:m_maximumDistanceSquared(1e30f),
+			:m_maximumDistanceSquared(btScalar(1e30)),
 			m_stackAlloc(0)
 		{
 		}
@@ -69,13 +68,13 @@ struct btStorageResult : public btDiscreteCollisionDetectorInterface::Result
 		btVector3	m_closestPointInB;
 		btScalar	m_distance; //negative means penetration !

-		btStorageResult() : m_distance(1e30f)
+		btStorageResult() : m_distance(btScalar(1e30))
 		{

 		}
 		virtual ~btStorageResult() {};

-		virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,float depth)
+		virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
 		{
 			if (depth < m_distance)
 			{
--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp
@@ -60,9 +60,9 @@ bool	btGjkConvexCast::calcTimeOfImpact(



-	float radius = 0.01f;
+	btScalar radius = btScalar(0.01);

-	btScalar lambda = 0.f;
+	btScalar lambda = btScalar(0.);
 	btVector3 s = rayFromLocalA.getOrigin();
 	btVector3 r = rayToLocalA.getOrigin()-rayFromLocalA.getOrigin();
 	btVector3 x = s;
@@ -71,7 +71,7 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 	bool hasResult = false;
 	btVector3 c;

-	float lastLambda = lambda;
+	btScalar lastLambda = lambda;

 	//first solution, using GJK

@@ -81,8 +81,8 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 	btTransform identityTrans;
 	identityTrans.setIdentity();

-	btSphereShape	raySphere(0.0f);
-	raySphere.setMargin(0.f);
+	btSphereShape	raySphere(btScalar(0.0));
+	raySphere.setMargin(btScalar(0.));

 	btTransform sphereTr;
 	sphereTr.setIdentity();
@@ -112,7 +112,7 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 		if (dist < radius)
 		{
 			//penetration
-			lastLambda = 1.f;
+			lastLambda = btScalar(1.);
 		}

 		//not close enough
@@ -143,7 +143,7 @@ bool	btGjkConvexCast::calcTimeOfImpact(
 			gjk.getClosestPoints(input,pointCollector,0);
 			if (pointCollector.m_hasResult)
 			{
-				if (pointCollector.m_distance < 0.f)
+				if (pointCollector.m_distance < btScalar(0.))
 				{
 					//degeneracy, report a hit
 					result.m_fraction = lastLambda;
@@ -160,7 +160,7 @@ bool	btGjkConvexCast::calcTimeOfImpact(

 		}

-		if (lastLambda < 1.f)
+		if (lastLambda < btScalar(1.))
 		{
 		
 			result.m_fraction = lastLambda;
--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h
@@ -18,9 +18,9 @@ subject to the following restrictions:
 #ifndef GJK_CONVEX_CAST_H
 #define GJK_CONVEX_CAST_H

-#include <BulletCollision/CollisionShapes/btCollisionMargin.h>
+#include "../CollisionShapes/btCollisionMargin.h"

-#include "LinearMath/btVector3.h"
+#include "../../LinearMath/btVector3.h"
 #include "btConvexCast.h"
 class btConvexShape;
 class btMinkowskiSumShape;
--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkEpa.h
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkEpa.h
@@ -21,7 +21,7 @@ Nov.2006

 #ifndef _05E48D53_04E0_49ad_BB0A_D74FE62E7366_
 #define _05E48D53_04E0_49ad_BB0A_D74FE62E7366_
-#include "BulletCollision/CollisionShapes/btConvexShape.h"
+#include "../CollisionShapes/btConvexShape.h"

 class btStackAlloc;

--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp
@@ -26,8 +26,11 @@ bool btGjkEpaPenetrationDepthSolver::calcPenDepth( btSimplexSolverInterface& sim
 											  class btIDebugDraw* debugDraw, btStackAlloc* stackAlloc )
 {

+	(void)debugDraw;
+	(void)v;
+	(void)simplexSolver;

-	const btScalar				radialmargin(0.f);
+	const btScalar				radialmargin(btScalar(0.));
 	
 	btGjkEpaSolver::sResults	results;
 	if(btGjkEpaSolver::Collide(	pConvexA,transformA,
--- a/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp
+++ b/extern/bullet2/src/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp
@@ -27,7 +27,7 @@ subject to the following restrictions:
 #endif

 //must be above the machine epsilon
-#define REL_ERROR2 1.0e-6f
+#define REL_ERROR2 btScalar(1.0e-6)

 //temp globals, to improve GJK/EPA/penetration calculations
 int gNumDeepPenetrationChecks = 0;
@@ -36,7 +36,7 @@ int gNumGjkChecks = 0;


 btGjkPairDetector::btGjkPairDetector(btConvexShape* objectA,btConvexShape* objectB,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSolver*	penetrationDepthSolver)
-:m_cachedSeparatingAxis(0.f,0.f,1.f),
+:m_cachedSeparatingAxis(btScalar(0.),btScalar(0.),btScalar(1.)),
 m_penetrationDepthSolver(penetrationDepthSolver),
 m_simplexSolver(simplexSolver),
 m_minkowskiA(objectA),
@@ -49,25 +49,25 @@ m_catchDegeneracies(1)

 void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw)
 {
-	btScalar distance=0.f;
-	btVector3	normalInB(0.f,0.f,0.f);
+	btScalar distance=btScalar(0.);
+	btVector3	normalInB(btScalar(0.),btScalar(0.),btScalar(0.));
 	btVector3 pointOnA,pointOnB;
 	btTransform	localTransA = input.m_transformA;
 	btTransform localTransB = input.m_transformB;
-	btVector3 positionOffset = (localTransA.getOrigin() + localTransB.getOrigin()) * 0.5f;
+	btVector3 positionOffset = (localTransA.getOrigin() + localTransB.getOrigin()) * btScalar(0.5);
 	localTransA.getOrigin() -= positionOffset;
 	localTransB.getOrigin() -= positionOffset;

-	float marginA = m_minkowskiA->getMargin();
-	float marginB = m_minkowskiB->getMargin();
+	btScalar marginA = m_minkowskiA->getMargin();
+	btScalar marginB = m_minkowskiB->getMargin();

 	gNumGjkChecks++;

 	//for CCD we don't use margins
 	if (m_ignoreMargin)
 	{
-		marginA = 0.f;
-		marginB = 0.f;
+		marginA = btScalar(0.);
+		marginB = btScalar(0.);
 	}

 	m_curIter = 0;
@@ -83,7 +83,7 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&

 	{
 		btScalar squaredDistance = SIMD_INFINITY;
-		btScalar delta = 0.f;
+		btScalar delta = btScalar(0.);
 		
 		btScalar margin = marginA + marginB;
 		
@@ -91,7 +91,8 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&

 		m_simplexSolver->reset();
 		
-		while (true)
+		for ( ; ; )
+		//while (true)
 		{

 			btVector3 seperatingAxisInA = (-m_cachedSeparatingAxis)* input.m_transformA.getBasis();
@@ -120,12 +121,12 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 				break;
 			}
 			// are we getting any closer ?
-			float f0 = squaredDistance - delta;
-			float f1 = squaredDistance * REL_ERROR2;
+			btScalar f0 = squaredDistance - delta;
+			btScalar f1 = squaredDistance * REL_ERROR2;

 			if (f0 <= f1)
 			{
-				if (f0 <= 0.f)
+				if (f0 <= btScalar(0.))
 				{
 					m_degenerateSimplex = 2;
 				}
@@ -191,7 +192,7 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 		{
 			m_simplexSolver->compute_points(pointOnA, pointOnB);
 			normalInB = pointOnA-pointOnB;
-			float lenSqr = m_cachedSeparatingAxis.length2();
+			btScalar lenSqr = m_cachedSeparatingAxis.length2();
 			//valid normal
 			if (lenSqr < 0.0001)
 			{
@@ -199,14 +200,14 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 			} 
 			if (lenSqr > SIMD_EPSILON*SIMD_EPSILON)
 			{
-				float rlen = 1.f / btSqrt(lenSqr );
+				btScalar rlen = btScalar(1.) / btSqrt(lenSqr );
 				normalInB *= rlen; //normalize
 				btScalar s = btSqrt(squaredDistance);
 			
 				btAssert(s > btScalar(0.0));
 				pointOnA -= m_cachedSeparatingAxis * (marginA / s);
 				pointOnB += m_cachedSeparatingAxis * (marginB / s);
-				distance = ((1.f/rlen) - margin);
+				distance = ((btScalar(1.)/rlen) - margin);
 				isValid = true;
 				
 				m_lastUsedMethod = 1;
@@ -243,11 +244,11 @@ void btGjkPairDetector::getClosestPoints(const ClosestPointInput& input,Result&
 				if (isValid2)
 				{
 					btVector3 tmpNormalInB = tmpPointOnB-tmpPointOnA;
-					float lenSqr = tmpNormalInB.length2();
+					btScalar lenSqr = tmpNormalInB.length2();
 					if (lenSqr > (SIMD_EPSILON*SIMD_EPSILON))
 					{
 						tmpNormalInB /= btSqrt(lenSqr);
-						float distance2 = -(tmpPointOnA-tmpPointOnB).length();
+						btScalar distance2 = -(tmpPointOnA-tmpPointOnB).length();
 						//only replace valid penetrations when the result is deeper (check)
 						if (!isValid || (distance2 < distance))
 						{
--- a/Show More
+++ b/Show More