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

52 files changed, 1752 insertions, 492 deletions

diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btBoxShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btBoxShape.cpp
index b5f80de4557..636b0046c13 100644
--- 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));
 
 }
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btBoxShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btBoxShape.h
index ee451a9b6c0..bc42f146c7c 100644
--- 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);
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp
index 3bd0a317545..8da554ef14d 100644
--- 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);
+
 	}
 }
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h
index 59a27e8641a..4914d9f959c 100644
--- 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;
-	
-	
+	bool m_useQuantizedAabbCompression;
+	bool m_pad[12];////need padding due to alignment
+
 public:
-	btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface);
 
+	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
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCapsuleShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btCapsuleShape.cpp
new file mode 100644
index 00000000000..b7e15172da2
--- /dev/null
+++ 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);
+
+}
+
+
+
+
+
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCapsuleShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btCapsuleShape.h
new file mode 100644
index 00000000000..27da8adefa5
--- /dev/null
+++ 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
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionMargin.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionMargin.h
index 377f0e506a2..4730264d3df 100644
--- 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)
 
 
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionShape.cpp
index 5474a201c37..81d82428f4c 100644
--- 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();
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btCollisionShape.h
index 7b2a00a1c57..96268734a83 100644
--- 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;
 
 };	
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCompoundShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btCompoundShape.cpp
index 88ae8c7dfd4..a4712b3e925 100644
--- 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);
 
 }
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCompoundShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btCompoundShape.h
index 84188bc8b76..2d384bd2180 100644
--- 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;
 	}
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConcaveShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btConcaveShape.cpp
index 7cd35a91860..5103500a012 100644
--- 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.))
 {
 
 }
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConcaveShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btConcaveShape.h
index 2bbba88bc44..73f974e4ee9 100644
--- 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;
 	}
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConeShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btConeShape.cpp
index 46232b3187c..207b3024bc3 100644
--- 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;
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConeShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btConeShape.h
index 52d925fe714..3ccda5b12c6 100644
--- 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));
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp
index 5af6e5f03d9..deb3954b5c3 100644
--- 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;
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexHullShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexHullShape.h
index beea0e63201..3fd5e382525 100644
--- 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;
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexShape.cpp
index 9537235ff8a..7edf1ea6db8 100644
--- 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__
+
  }
 
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexShape.h
index 0de334b3521..746f383dfc7 100644
--- 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);
 	}
 
 
 
-};
+}
+;
 
 
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.cpp
index 9d8e7e1408e..614ec977793 100644
--- 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();
+}
\ No newline at end of file
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h
index 86e871c6c0b..34ee7af744c 100644
--- 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;
 
 };
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCylinderShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btCylinderShape.cpp
index 16b263474f0..1666afb3b88 100644
--- 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;
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btCylinderShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btCylinderShape.h
index bb0e4298abc..c78890c887a 100644
--- 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();
 	}
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btEmptyShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btEmptyShape.cpp
index c63f4a9c571..dcc486f194b 100644
--- 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);
 }
 
 	
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btEmptyShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btEmptyShape.h
index c16149e55fb..8ec53444976 100644
--- 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"
 
 
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp
index 57132ee9512..5a359c0cff1 100644
--- 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)
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h
index e4cc9d42d59..85fd49638ce 100644
--- 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
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.cpp
index 4bf8c478a53..b213f3819a4 100644
--- 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);
 }
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btMinkowskiSumShape.h
index e974f57a4c2..489b7ddde1e 100644
--- 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;}
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btMultiSphereShape.cpp
index fde4d95da14..6015a618082 100644
--- 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);
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btMultiSphereShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btMultiSphereShape.h
index 2dde9d3855a..be044dbc16a 100644
--- 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
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btOptimizedBvh.cpp
index 37f15e1dcc4..44438a24455 100644
--- 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);
 		}
 	};
+	
+
+
+	int numLeafNodes = 0;
 
 	
+	if (m_useQuantization)
+	{
 
-	NodeTriangleCallback	callback(m_leafNodes);
+		//initialize quantization values
+		setQuantizationValues(bvhAabbMin,bvhAabbMax);
+
+		QuantizedNodeTriangleCallback	callback(m_quantizedLeafNodes,this);
+
+	
+		triangles->InternalProcessAllTriangles(&callback,m_bvhAabbMin,m_bvhAabbMax);
 
-	btVector3 aabbMin(-1e30f,-1e30f,-1e30f);
-	btVector3 aabbMax(1e30f,1e30f,1e30f);
+		//now we have an array of leafnodes in m_leafNodes
+		numLeafNodes = m_quantizedLeafNodes.size();
 
-	triangles->InternalProcessAllTriangles(&callback,aabbMin,aabbMax);
 
-	//now we have an array of leafnodes in m_leafNodes
+		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);
+
+	///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];
 
-	///create the leafnodes first
-//	btOptimizedBvhNode* leafNodes = new btOptimizedBvhNode;
+		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::walkRecursiveQuantizedTreeAgainstQueryAabb(const btQuantizedBvhNode* currentNode,btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const
+{
+	btAssert(m_useQuantization);
+	
+	bool aabbOverlap, isLeafNode;
 
-void	btOptimizedBvh::walkStacklessTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const
+	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
 {
-	int escapeIndex, curIndex = 0;
+	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 < m_curNodeIndex)
+	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];
+	}
+}
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btOptimizedBvh.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btOptimizedBvh.h
index cb76cb23340..d5159586344 100644
--- 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
 
-	btVector3	m_aabbMin;
-	btVector3	m_aabbMax;
 
-//these 2 pointers are obsolete, the stackless traversal just uses the escape index
-	btOptimizedBvhNode*	m_leftChild;
-	btOptimizedBvhNode*	m_rightChild;
+///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;
+
+	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;
+	}
+}
+;
 
+/// 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
+	};
 
-public:
-	btOptimizedBvh();
+	btTraversalMode	m_traversalMode;
 
-	virtual ~btOptimizedBvh();
 	
-	void	build(btStridingMeshInterface* triangles);
 
-	btOptimizedBvhNode*	buildTree	(NodeArray&	leafNodes,int startIndex,int endIndex);
 
-	int	calcSplittingAxis(NodeArray&	leafNodes,int startIndex,int endIndex);
+	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:
 
-	int	sortAndCalcSplittingIndex(NodeArray&	leafNodes,int startIndex,int endIndex,int splitAxis);
 	
-	void	walkTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
+
+	void	buildTree	(int startIndex,int endIndex);
+
+	int	calcSplittingAxis(int startIndex,int endIndex);
+
+	int	sortAndCalcSplittingIndex(int startIndex,int endIndex,int splitAxis);
 	
-	void	walkStacklessTree(btOptimizedBvhNode* rootNode,btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
+	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;
 	
 
-	//OptimizedBvhNode*	GetRootNode() { return m_rootNode1;}
+	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();
 
-	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
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp
index 6f2272cc454..bbc4ba62af6 100644
--- 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;
+	}
+}
+
+
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h
index a404504ba86..c35f7512663 100644
--- 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;
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btSphereShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btSphereShape.cpp
index 39e458c0f22..ca65dd03f3e 100644
--- 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);
 
 }
 
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btSphereShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btSphereShape.h
index 2db6a872b40..66521664087 100644
--- 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
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btStaticPlaneShape.cpp
index 8c7022ba83b..4fbaafa1b93 100644
--- 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)
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btStaticPlaneShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btStaticPlaneShape.h
index 65b30e1ff06..f59cc0c3347 100644
--- 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.
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp
index 76b5859be7e..03ca1ae7736 100644
--- 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;
+}
\ No newline at end of file
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btStridingMeshInterface.h
index 830cbb28200..d7b354b7855 100644
--- 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
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTetrahedronShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btTetrahedronShape.cpp
index 7cb40c4fac1..3aa1eda9964 100644
--- 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;
 }
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTetrahedronShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btTetrahedronShape.h
index 9e17a248f84..94bc4ec0fa5 100644
--- 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).
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleBuffer.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleBuffer.h
index 9a623403846..3805c519d22 100644
--- 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
 {
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleCallback.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleCallback.h
index 7b2337498ec..fbb87bc4fd8 100644
--- 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
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.cpp
index 7400d372bee..00847861cf1 100644
--- 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);
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h
index 3ec827c03d9..6ab6a762b39 100644
--- 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
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMesh.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMesh.cpp
index 489fe1bbcaa..98c54ef45f8 100644
--- 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;
 }
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMesh.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMesh.h
index 1be03d70436..525f5336b48 100644
--- 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;}
 
 		
 };
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMeshShape.cpp
index cd2bf7261d1..ed81897b515 100644
--- 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);
 		
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMeshShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleMeshShape.h
index 4bf000f0c8d..e6173e47640 100644
--- 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";}
diff --git a/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleShape.h b/extern/bullet2/src/BulletCollision/CollisionShapes/btTriangleShape.h
index 3284a599ea7..c2e240c051c 100644
--- 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.);
 		}