Reorganized Bullet physics files, added preliminary vehicle simulation files (disabled).

Requires some changes to projectfiles/makefiles/scons, for the added and removed files!

42 files changed, 1842 insertions, 947 deletions

diff --git a/extern/bullet/Bullet/BroadphaseCollision/BroadphaseInterface.h b/extern/bullet/Bullet/BroadphaseCollision/BroadphaseInterface.h
index 6f2f76ff812..022faecff5d 100644
--- a/extern/bullet/Bullet/BroadphaseCollision/BroadphaseInterface.h
+++ b/extern/bullet/Bullet/BroadphaseCollision/BroadphaseInterface.h
@@ -12,6 +12,7 @@
 #define 	BROADPHASE_INTERFACE_H
 
 
+
 struct	DispatcherInfo;
 class Dispatcher;
 struct BroadphaseProxy;
@@ -21,7 +22,7 @@ struct BroadphaseProxy;
 class BroadphaseInterface
 {
 public:
-	virtual BroadphaseProxy*	CreateProxy(  void *object,int type, const SimdVector3& min,  const SimdVector3& max) =0;
+	virtual BroadphaseProxy*	CreateProxy(  const SimdVector3& min,  const SimdVector3& max,int shapeType,void* userPtr ) =0;
 	virtual void	DestroyProxy(BroadphaseProxy* proxy)=0;
 	virtual void	SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin,const SimdVector3& aabbMax)=0;
 	virtual void	CleanProxyFromPairs(BroadphaseProxy* proxy)=0;
diff --git a/extern/bullet/Bullet/BroadphaseCollision/BroadphaseProxy.h b/extern/bullet/Bullet/BroadphaseCollision/BroadphaseProxy.h
index 235e2f1e465..da0c1f662c0 100644
--- a/extern/bullet/Bullet/BroadphaseCollision/BroadphaseProxy.h
+++ b/extern/bullet/Bullet/BroadphaseCollision/BroadphaseProxy.h
@@ -45,15 +45,19 @@ CONCAVE_SHAPES_START_HERE,
 ///BroadphaseProxy
 struct BroadphaseProxy
 {
+
+	//Usually the client CollisionObject or Rigidbody class
+	void*	m_clientObject;
+
+
 	BroadphaseProxy() :m_clientObject(0),m_clientObjectType(-1){}
-	BroadphaseProxy(void* object,int type)
-		:m_clientObject(object),
-		m_clientObjectType(type)
+	BroadphaseProxy(int shapeType,void* userPtr)
+		:m_clientObject(userPtr),
+		m_clientObjectType(shapeType)
 	{
 	}
 
-	void        *m_clientObject;
-
+	
 	int GetClientObjectType ( ) const { return m_clientObjectType;}
 
 	
diff --git a/extern/bullet/Bullet/BroadphaseCollision/CollisionAlgorithm.cpp b/extern/bullet/Bullet/BroadphaseCollision/CollisionAlgorithm.cpp
index 4f73fe2f6ad..1ef60341813 100644
--- a/extern/bullet/Bullet/BroadphaseCollision/CollisionAlgorithm.cpp
+++ b/extern/bullet/Bullet/BroadphaseCollision/CollisionAlgorithm.cpp
@@ -9,7 +9,7 @@
  * It is provided "as is" without express or implied warranty.
 */
 #include "CollisionAlgorithm.h"
-#include "CollisionDispatcher.h"
+#include "Dispatcher.h"
 
 CollisionAlgorithm::CollisionAlgorithm(const CollisionAlgorithmConstructionInfo& ci)
 {
diff --git a/extern/bullet/Bullet/BroadphaseCollision/CollisionDispatcher.cpp b/extern/bullet/Bullet/BroadphaseCollision/Dispatcher.cpp
index 4883bd9f8f9..7923e7a40ee 100644
--- a/extern/bullet/Bullet/BroadphaseCollision/CollisionDispatcher.cpp
+++ b/extern/bullet/Bullet/BroadphaseCollision/Dispatcher.cpp
@@ -8,7 +8,7 @@
  * of this software for any purpose.  
  * It is provided "as is" without express or implied warranty.
 */
-#include "CollisionDispatcher.h"
+#include "Dispatcher.h"
 
 Dispatcher::~Dispatcher()
 {
diff --git a/extern/bullet/Bullet/BroadphaseCollision/CollisionDispatcher.h b/extern/bullet/Bullet/BroadphaseCollision/Dispatcher.h
index 6d39ec7dea1..202aa6a41e8 100644
--- a/extern/bullet/Bullet/BroadphaseCollision/CollisionDispatcher.h
+++ b/extern/bullet/Bullet/BroadphaseCollision/Dispatcher.h
@@ -8,8 +8,8 @@
  * of this software for any purpose.  
  * It is provided "as is" without express or implied warranty.
 */
-#ifndef COLLISION_DISPATCHER_H
-#define COLLISION_DISPATCHER_H
+#ifndef _DISPATCHER_H
+#define _DISPATCHER_H
 
 class CollisionAlgorithm;
 struct BroadphaseProxy;
@@ -18,7 +18,7 @@ class RigidBody;
 enum CollisionDispatcherId
 {
 	RIGIDBODY_DISPATCHER = 0,
-	RAGDOLL_DISPATCHER
+	USERCALLBACK_DISPATCHER
 };
 
 class PersistentManifold;
@@ -45,7 +45,8 @@ struct DispatcherInfo
 	
 };
 
-/// Collision Dispatcher can be used in combination with broadphase and collision algorithms.
+/// Dispatcher can be used in combination with broadphase to dispatch overlapping pairs.
+/// For example for pairwise collision detection or user callbacks (game logic).
 class Dispatcher
 {
 
@@ -64,8 +65,11 @@ public:
 
 	virtual void ReleaseManifold(PersistentManifold* manifold)=0;
 
+	virtual bool	NeedsCollision(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1) = 0;
+
+
 
 };
 
 
-#endif //COLLISION_DISPATCHER_H
+#endif //_DISPATCHER_H
diff --git a/extern/bullet/Bullet/BroadphaseCollision/SimpleBroadphase.cpp b/extern/bullet/Bullet/BroadphaseCollision/SimpleBroadphase.cpp
index 823bfdc9edd..0cb282f4e0f 100644
--- a/extern/bullet/Bullet/BroadphaseCollision/SimpleBroadphase.cpp
+++ b/extern/bullet/Bullet/BroadphaseCollision/SimpleBroadphase.cpp
@@ -9,7 +9,7 @@
  * It is provided "as is" without express or implied warranty.
 */
 #include "SimpleBroadphase.h"
-#include "BroadphaseCollision/CollisionDispatcher.h"
+#include "BroadphaseCollision/Dispatcher.h"
 #include "BroadphaseCollision/CollisionAlgorithm.h"
 
 #include "SimdVector3.h"
@@ -43,7 +43,7 @@ SimpleBroadphase::~SimpleBroadphase()
 }
 
 
-BroadphaseProxy*	SimpleBroadphase::CreateProxy( void *object, int type, const SimdVector3& min,  const SimdVector3& max) 
+BroadphaseProxy*	SimpleBroadphase::CreateProxy(  const SimdVector3& min,  const SimdVector3& max,int shapeType,void* userPtr)
 {
 	if (m_numProxies >= SIMPLE_MAX_PROXIES)
 	{
@@ -53,7 +53,7 @@ BroadphaseProxy*	SimpleBroadphase::CreateProxy( void *object, int type, const Si
 	assert(min[0]<= max[0] && min[1]<= max[1] && min[2]<= max[2]);
 
 	int freeIndex= m_freeProxies[m_firstFreeProxy];
-	BroadphaseProxy* proxy = new (&m_proxies[freeIndex])SimpleBroadphaseProxy(object,type,min,max);
+	BroadphaseProxy* proxy = new (&m_proxies[freeIndex])SimpleBroadphaseProxy(min,max,shapeType,userPtr);
 	m_firstFreeProxy++;
 
 	m_pProxies[m_numProxies] = proxy;
@@ -151,6 +151,13 @@ void	SimpleBroadphase::AddOverlappingPair(BroadphaseProxy* proxy0,BroadphaseProx
 		assert(!m_OverlappingPairs[m_NumOverlapBroadphasePair].m_algorithms[i]);
 		m_OverlappingPairs[m_NumOverlapBroadphasePair].m_algorithms[i] = 0;
 	}
+
+	if (m_NumOverlapBroadphasePair >= SIMPLE_MAX_OVERLAP)
+	{
+		printf("Error: too many overlapping objects: m_NumOverlapBroadphasePair: %d\n",m_NumOverlapBroadphasePair);
+		assert(0);
+	}
+
 	m_NumOverlapBroadphasePair++;
 }
 	
diff --git a/extern/bullet/Bullet/BroadphaseCollision/SimpleBroadphase.h b/extern/bullet/Bullet/BroadphaseCollision/SimpleBroadphase.h
index df6964d0ad9..ee0873a9a1e 100644
--- a/extern/bullet/Bullet/BroadphaseCollision/SimpleBroadphase.h
+++ b/extern/bullet/Bullet/BroadphaseCollision/SimpleBroadphase.h
@@ -25,8 +25,8 @@ struct SimpleBroadphaseProxy : public BroadphaseProxy
 	
 	SimpleBroadphaseProxy() {};
 
-	SimpleBroadphaseProxy(void* object,int type,const SimdPoint3& minpt,const SimdPoint3& maxpt)
-	:BroadphaseProxy(object,type),
+	SimpleBroadphaseProxy(const SimdPoint3& minpt,const SimdPoint3& maxpt,int shapeType,void* userPtr)
+	:BroadphaseProxy(shapeType,userPtr),
 	m_min(minpt),m_max(maxpt)		
 	{
 	}
@@ -64,7 +64,8 @@ public:
 	SimpleBroadphase();
 	virtual ~SimpleBroadphase();
 
-	virtual BroadphaseProxy*	CreateProxy(  void *object,int type, const SimdVector3& min,  const SimdVector3& max) ;
+	virtual BroadphaseProxy*	CreateProxy(  const SimdVector3& min,  const SimdVector3& max,int shapeType,void* userPtr);
+
 	virtual void	DestroyProxy(BroadphaseProxy* proxy);
 	virtual void	SetAabb(BroadphaseProxy* proxy,const SimdVector3& aabbMin,const SimdVector3& aabbMax);
 	virtual void	CleanProxyFromPairs(BroadphaseProxy* proxy);
diff --git a/extern/bullet/Bullet/Bullet3_vc8.vcproj b/extern/bullet/Bullet/Bullet3_vc8.vcproj
index 4c8bc67557b..218a52fdb2f 100644
--- a/extern/bullet/Bullet/Bullet3_vc8.vcproj
+++ b/extern/bullet/Bullet/Bullet3_vc8.vcproj
@@ -234,6 +234,14 @@
 				>
 			</File>
 			<File
+				RelativePath=".\NarrowPhaseCollision\CollisionObject.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\NarrowPhaseCollision\CollisionObject.h"
+				>
+			</File>
+			<File
 				RelativePath=".\NarrowPhaseCollision\ContinuousConvexCollision.cpp"
 				>
 			</File>
@@ -502,11 +510,11 @@
 				>
 			</File>
 			<File
-				RelativePath=".\BroadphaseCollision\CollisionDispatcher.cpp"
+				RelativePath=".\BroadphaseCollision\Dispatcher.cpp"
 				>
 			</File>
 			<File
-				RelativePath=".\BroadphaseCollision\CollisionDispatcher.h"
+				RelativePath=".\BroadphaseCollision\Dispatcher.h"
 				>
 			</File>
 			<File
@@ -578,6 +586,66 @@
 				>
 			</File>
 		</Filter>
+		<Filter
+			Name="CollisionDispatch"
+			>
+			<File
+				RelativePath=".\CollisionDispatch\CollisionDispatcher.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\CollisionDispatcher.h"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\CollisionWorld.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\CollisionWorld.h"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\ConvexConcaveCollisionAlgorithm.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\ConvexConcaveCollisionAlgorithm.h"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\ConvexConvexAlgorithm.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\ConvexConvexAlgorithm.h"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\EmptyCollisionAlgorithm.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\EmptyCollisionAlgorithm.h"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\ManifoldResult.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\ManifoldResult.h"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\UnionFind.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\CollisionDispatch\UnionFind.h"
+				>
+			</File>
+		</Filter>
 		<File
 			RelativePath=".\CollisionShapes\BvhTriangleMeshShape.cpp"
 			>
diff --git a/extern/bullet/Bullet/CollisionDispatch/CollisionDispatcher.cpp b/extern/bullet/Bullet/CollisionDispatch/CollisionDispatcher.cpp
new file mode 100644
index 00000000000..778236cb55a
--- /dev/null
+++ b/extern/bullet/Bullet/CollisionDispatch/CollisionDispatcher.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2005 Erwin Coumans http://continuousphysics.com/Bullet/
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies.
+ * Erwin Coumans makes no representations about the suitability 
+ * of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+*/
+
+#include "CollisionDispatcher.h"
+
+
+#include "BroadphaseCollision/CollisionAlgorithm.h"
+#include "CollisionDispatch/ConvexConvexAlgorithm.h"
+#include "CollisionDispatch/EmptyCollisionAlgorithm.h"
+#include "CollisionDispatch/ConvexConcaveCollisionAlgorithm.h"
+
+#include "NarrowphaseCollision/CollisionObject.h"
+#include <algorithm>
+
+void CollisionDispatcher::FindUnions()
+{
+	if (m_useIslands)
+	{
+		for (int i=0;i<GetNumManifolds();i++)
+		{
+			const PersistentManifold* manifold = this->GetManifoldByIndexInternal(i);
+			//static objects (invmass 0.f) don't merge !
+			if ((((CollisionObject*)manifold->GetBody0()) && (((CollisionObject*)manifold->GetBody0())->mergesSimulationIslands())) &&
+				(((CollisionObject*)manifold->GetBody1()) && (((CollisionObject*)manifold->GetBody1())->mergesSimulationIslands())))
+			{
+
+				m_unionFind.unite(((CollisionObject*)manifold->GetBody0())->m_islandTag1,
+					((CollisionObject*)manifold->GetBody1())->m_islandTag1);
+			}
+			
+			
+		}
+	}
+	
+}
+	
+
+	
+CollisionDispatcher::CollisionDispatcher (): 
+	m_useIslands(true),
+		m_count(0)
+{
+	int i;
+	
+	for (i=0;i<MAX_BROADPHASE_COLLISION_TYPES;i++)
+	{
+		for (int j=0;j<MAX_BROADPHASE_COLLISION_TYPES;j++)
+		{
+			m_doubleDispatch[i][j] = 0;
+		}
+	}
+	
+	
+};
+	
+PersistentManifold*	CollisionDispatcher::GetNewManifold(void* b0,void* b1) 
+{ 
+
+	CollisionObject* body0 = (CollisionObject*)b0;
+	CollisionObject* body1 = (CollisionObject*)b1;
+	
+	PersistentManifold* manifold = new PersistentManifold (body0,body1);
+	m_manifoldsPtr.push_back(manifold);
+
+	return manifold;
+}
+
+	
+void CollisionDispatcher::ReleaseManifold(PersistentManifold* manifold)
+{
+	manifold->ClearManifold();
+
+	std::vector<PersistentManifold*>::iterator i =
+		std::find(m_manifoldsPtr.begin(), m_manifoldsPtr.end(), manifold);
+	if (!(i == m_manifoldsPtr.end()))
+	{
+		std::swap(*i, m_manifoldsPtr.back());
+		m_manifoldsPtr.pop_back();
+	}
+	
+	
+}
+
+	
+//
+// todo: this is random access, it can be walked 'cache friendly'!
+//
+void CollisionDispatcher::BuildAndProcessIslands(int numBodies, IslandCallback* callback)
+{
+	int i;
+
+
+	for (int islandId=0;islandId<numBodies;islandId++)
+	{
+
+		std::vector<PersistentManifold*>  islandmanifold;
+		
+		//int numSleeping = 0;
+
+		bool allSleeping = true;
+
+		for (i=0;i<GetNumManifolds();i++)
+		{
+			 PersistentManifold* manifold = this->GetManifoldByIndexInternal(i);
+			if ((((CollisionObject*)manifold->GetBody0()) && ((CollisionObject*)manifold->GetBody0())->m_islandTag1 == (islandId)) ||
+				(((CollisionObject*)manifold->GetBody1()) && ((CollisionObject*)manifold->GetBody1())->m_islandTag1 == (islandId)))
+			{
+
+				if ((((CollisionObject*)manifold->GetBody0()) && ((CollisionObject*)manifold->GetBody0())->GetActivationState()== ACTIVE_TAG) ||
+					(((CollisionObject*)manifold->GetBody1()) && ((CollisionObject*)manifold->GetBody1())->GetActivationState() == ACTIVE_TAG))
+				{
+					allSleeping = false;
+				}
+
+				islandmanifold.push_back(manifold);
+			}
+		}
+		if (allSleeping)
+		{
+			//tag all as 'ISLAND_SLEEPING'
+			for (i=0;i<islandmanifold.size();i++)
+			{
+				 PersistentManifold* manifold = islandmanifold[i];
+				if (((CollisionObject*)manifold->GetBody0()))	
+				{
+					((CollisionObject*)manifold->GetBody0())->SetActivationState( ISLAND_SLEEPING );
+				}
+				if (((CollisionObject*)manifold->GetBody1()))	
+				{
+					((CollisionObject*)manifold->GetBody1())->SetActivationState( ISLAND_SLEEPING);
+				}
+
+			}
+		} else
+		{
+
+			//tag all as 'ISLAND_SLEEPING'
+			for (i=0;i<islandmanifold.size();i++)
+			{
+				 PersistentManifold* manifold = islandmanifold[i];
+				 CollisionObject* body0 = (CollisionObject*)manifold->GetBody0();
+				 CollisionObject* body1 = (CollisionObject*)manifold->GetBody1();
+
+				if (body0)	
+				{
+					if ( body0->GetActivationState() == ISLAND_SLEEPING)
+					{
+						body0->SetActivationState( WANTS_DEACTIVATION);
+					}
+				}
+				if (body1)	
+				{
+					if ( body1->GetActivationState() == ISLAND_SLEEPING)
+					{
+						body1->SetActivationState(WANTS_DEACTIVATION);
+					}
+				}
+
+			}
+
+			callback->ProcessIsland(&islandmanifold[0],islandmanifold.size());
+
+		}
+	}
+}
+
+
+
+CollisionAlgorithm* CollisionDispatcher::InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
+{
+	m_count++;
+	
+	CollisionAlgorithmConstructionInfo ci;
+	ci.m_dispatcher = this;
+	
+	if (proxy0.IsConvexShape() && proxy1.IsConvexShape() )
+	{
+		return new ConvexConvexAlgorithm(0,ci,&proxy0,&proxy1);			
+	}
+
+	if (proxy0.IsConvexShape() && proxy1.IsConcaveShape())
+	{
+		return new ConvexConcaveCollisionAlgorithm(ci,&proxy0,&proxy1);
+	}
+
+	if (proxy1.IsConvexShape() && proxy0.IsConcaveShape())
+	{
+		return new ConvexConcaveCollisionAlgorithm(ci,&proxy1,&proxy0);
+	}
+
+	//failed to find an algorithm
+	return new EmptyAlgorithm(ci);
+	
+}
+
+bool	CollisionDispatcher::NeedsCollision(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
+{
+
+	CollisionObject* body0 = (CollisionObject*)proxy0.m_clientObject;
+	CollisionObject* body1 = (CollisionObject*)proxy1.m_clientObject;
+
+	assert(body0);
+	assert(body1);
+
+	bool needsCollision = true;
+
+	if ((body0->m_collisionFlags & CollisionObject::isStatic) && 
+		(body1->m_collisionFlags & CollisionObject::isStatic))
+		needsCollision = false;
+	
+	if ((body0->GetActivationState() == 2) &&(body1->GetActivationState() == 2))
+		needsCollision = false;
+	
+	return needsCollision ;
+
+}
\ No newline at end of file
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/ToiContactDispatcher.h b/extern/bullet/Bullet/CollisionDispatch/CollisionDispatcher.h
index b1793f70979..6c251823599 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/ToiContactDispatcher.h
+++ b/extern/bullet/Bullet/CollisionDispatch/CollisionDispatcher.h
@@ -1,18 +1,27 @@
-#ifndef TOI_CONTACT_DISPATCHER_H
-#define TOI_CONTACT_DISPATCHER_H
-
-#include "BroadphaseCollision/CollisionDispatcher.h"
+/*
+ * Copyright (c) 2002-2006 Erwin Coumans http://continuousphysics.com/Bullet/
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies.
+ * Erwin Coumans makes no representations about the suitability 
+ * of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+*/
+
+#ifndef COLLISION__DISPATCHER_H
+#define COLLISION__DISPATCHER_H
+
+#include "BroadphaseCollision/Dispatcher.h"
 #include "NarrowPhaseCollision/PersistentManifold.h"
 #include "CollisionDispatch/UnionFind.h"
 #include "BroadphaseCollision/BroadphaseProxy.h"
+#include <vector>
+
 
-class ConstraintSolver;
 class IDebugDraw;
 
-//island management
-#define ACTIVE_TAG 1
-#define ISLAND_SLEEPING 2
-#define WANTS_DEACTIVATION 3
+
 
 
 struct CollisionAlgorithmCreateFunc
@@ -28,25 +37,19 @@ struct CollisionAlgorithmCreateFunc
 		return 0;
 	}
 };
-#include <vector>
-///ToiContactDispatcher (Time of Impact) is the main collision dispatcher.
-///Basic implementation supports algorithms that handle ConvexConvex and ConvexConcave collision pairs.
+
+
+///CollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs.
 ///Time of Impact, Closest Points and Penetration Depth.
-class ToiContactDispatcher : public Dispatcher
+class CollisionDispatcher : public Dispatcher
 {
 	
-	bool m_useIslands;
-
-	
 	std::vector<PersistentManifold*>	m_manifoldsPtr;
 
-
 	UnionFind m_unionFind;
-	ConstraintSolver*	m_solver;
+
+	bool m_useIslands;
 	
-	float	m_sor;
-	float	m_tau;
-	float	m_damping;
 	
 	CollisionAlgorithmCreateFunc* m_doubleDispatch[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES];
 	
@@ -54,43 +57,47 @@ public:
 	
 	UnionFind& GetUnionFind() { return m_unionFind;}
 
-//	int	m_firstFreeManifold;
-	
-//	const PersistentManifold* GetManifoldByIndexInternal(int index)
-//	{
-//		return &m_manifolds[index];
-//	}
+	struct	IslandCallback
+	{
+		virtual	void	ProcessIsland(PersistentManifold**	manifolds,int numManifolds) = 0;
+	};
 
-	int	GetNumManifolds() { return m_manifoldsPtr.size();}
+
+	int	GetNumManifolds() const
+	{ 
+		return m_manifoldsPtr.size();
+	}
 
 	 PersistentManifold* GetManifoldByIndexInternal(int index)
 	{
-	return m_manifoldsPtr[index];
+		return m_manifoldsPtr[index];
 	}
 
+	 const PersistentManifold* GetManifoldByIndexInternal(int index) const
+	{
+		return m_manifoldsPtr[index];
+	}
 
-	void InitUnionFind()
+	void InitUnionFind(int n)
 	{
 		if (m_useIslands)
-			m_unionFind.reset();
+			m_unionFind.reset(n);
 	}
 	
 	void FindUnions();
 	
 	int m_count;
 	
-	ToiContactDispatcher (ConstraintSolver* solver);
+	CollisionDispatcher ();
 
 	virtual PersistentManifold*	GetNewManifold(void* b0,void* b1);
 	
 	virtual void ReleaseManifold(PersistentManifold* manifold);
 
-	//
-	// todo: this is random access, it can be walked 'cache friendly'!
-	//
-	virtual void SolveConstraints(float timeStep, int numIterations,int numRigidBodies,IDebugDraw* debugDrawer);
-	
 	
+	virtual void BuildAndProcessIslands(int numBodies, IslandCallback* callback);
+
+		
 	CollisionAlgorithm* FindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
 	{
 		CollisionAlgorithm* algo = InternalFindAlgorithm(proxy0,proxy1);
@@ -99,25 +106,14 @@ public:
 	
 	CollisionAlgorithm* InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1);
 	
-	virtual int GetUniqueId() { return RIGIDBODY_DISPATCHER;}
-	
-	void	SetSor(float sor)
-	{
-		m_sor = sor;
-	}
+	virtual bool	NeedsCollision(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1);
 
-	void	SetTau(float tau)
-	{
-		m_tau = tau;
-	}
+
+	virtual int GetUniqueId() { return RIGIDBODY_DISPATCHER;}
 	
-	void	SetDamping( float damping)
-	{
-		m_damping = damping;
-	}
 	
 
 };
 
-#endif //TOI_CONTACT_DISPATCHER_H
+#endif //COLLISION__DISPATCHER_H
 
diff --git a/extern/bullet/Bullet/CollisionDispatch/CollisionWorld.cpp b/extern/bullet/Bullet/CollisionDispatch/CollisionWorld.cpp
new file mode 100644
index 00000000000..da83ada22c4
--- /dev/null
+++ b/extern/bullet/Bullet/CollisionDispatch/CollisionWorld.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2002-2006 Erwin Coumans http://continuousphysics.com/Bullet/
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies.
+ * Erwin Coumans makes no representations about the suitability 
+ * of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+*/
+
+#include "CollisionWorld.h"
+#include "CollisionDispatcher.h"
+#include "NarrowphaseCollision/CollisionObject.h"
+#include "CollisionShapes/CollisionShape.h"
+
+#include "BroadphaseCollision/BroadphaseInterface.h"
+#include <algorithm>
+
+void	CollisionWorld::UpdateActivationState()
+{
+	m_dispatcher->InitUnionFind(m_collisionObjects.size());
+	
+	// put the index into m_controllers into m_tag	
+	{
+		std::vector<CollisionObject*>::iterator i;
+		
+		int index = 0;
+		for (i=m_collisionObjects.begin();
+		!(i==m_collisionObjects.end()); i++)
+		{
+			
+			CollisionObject*	collisionObject= (*i);
+			collisionObject->m_islandTag1 = index;
+			collisionObject->m_hitFraction = 1.f;
+			index++;
+			
+		}
+	}
+	// do the union find
+	
+	m_dispatcher->FindUnions();
+	
+	// put the islandId ('find' value) into m_tag	
+	{
+		UnionFind& unionFind = m_dispatcher->GetUnionFind();
+		
+		std::vector<CollisionObject*>::iterator i;
+		
+		int index = 0;
+		for (i=m_collisionObjects.begin();
+		!(i==m_collisionObjects.end()); i++)
+		{
+			CollisionObject* collisionObject= (*i);
+			
+			if (collisionObject->mergesSimulationIslands())
+			{
+				collisionObject->m_islandTag1 = unionFind.find(index);
+			} else
+			{
+				collisionObject->m_islandTag1 = -1;
+			}
+			index++;
+		}
+	}
+	
+}
+
+
+
+
+
+void	CollisionWorld::AddCollisionObject(CollisionObject* collisionObject)
+{
+		m_collisionObjects.push_back(collisionObject);
+
+		//calculate new AABB
+		SimdTransform trans = collisionObject->m_worldTransform;
+
+		SimdVector3	minAabb;
+		SimdVector3	maxAabb;
+		collisionObject->m_collisionShape->GetAabb(trans,minAabb,maxAabb);
+
+		int type = collisionObject->m_collisionShape->GetShapeType();
+		collisionObject->m_broadphaseHandle = GetBroadphase()->CreateProxy(
+			minAabb,
+			maxAabb,
+			type,
+			collisionObject
+			);
+		
+
+
+
+}
+
+
+void	CollisionWorld::RemoveCollisionObject(CollisionObject* collisionObject)
+{
+	
+	
+	bool removeFromBroadphase = false;
+	
+	{
+		BroadphaseInterface* scene = GetBroadphase();
+		BroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
+		
+		//
+		// only clear the cached algorithms
+		//
+		GetBroadphase()->CleanProxyFromPairs(bp);
+		GetBroadphase()->DestroyProxy(bp);
+	}
+
+
+	std::vector<CollisionObject*>::iterator i =	std::find(m_collisionObjects.begin(), m_collisionObjects.end(), collisionObject);
+		
+	if (!(i == m_collisionObjects.end()))
+		{
+			std::swap(*i, m_collisionObjects.back());
+			m_collisionObjects.pop_back();
+		}
+}
\ No newline at end of file
diff --git a/extern/bullet/Bullet/CollisionDispatch/CollisionWorld.h b/extern/bullet/Bullet/CollisionDispatch/CollisionWorld.h
new file mode 100644
index 00000000000..0c841417bad
--- /dev/null
+++ b/extern/bullet/Bullet/CollisionDispatch/CollisionWorld.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2002-2006 Erwin Coumans http://continuousphysics.com/Bullet/
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies.
+ * Erwin Coumans makes no representations about the suitability 
+ * of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+*/
+
+#ifndef COLLISION_WORLD_H
+#define COLLISION_WORLD_H
+
+struct CollisionObject;
+class CollisionDispatcher;
+class BroadphaseInterface;
+
+#include <vector>
+
+///CollisionWorld is interface and container for the collision detection
+class CollisionWorld
+{
+
+	std::vector<CollisionObject*>	m_collisionObjects;
+	
+	CollisionDispatcher*	m_dispatcher;
+
+	BroadphaseInterface*	m_broadphase;
+
+	public:
+
+	CollisionWorld(CollisionDispatcher* dispatcher,BroadphaseInterface* broadphase)
+		:m_dispatcher(dispatcher),
+		m_broadphase(broadphase)
+	{
+
+	}
+
+	virtual	void	UpdateActivationState();
+
+	BroadphaseInterface*	GetBroadphase()
+	{
+		return m_broadphase;
+	}
+
+	CollisionDispatcher*	GetDispatcher()
+	{
+		return m_dispatcher;
+	}
+
+	int	GetNumCollisionObjects() const
+	{
+		return m_collisionObjects.size();
+	}
+
+	void	AddCollisionObject(CollisionObject* collisionObject);
+
+	void	RemoveCollisionObject(CollisionObject* collisionObject);
+
+};
+
+
+#endif //COLLISION_WORLD_H
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/ConvexConcaveCollisionAlgorithm.cpp b/extern/bullet/Bullet/CollisionDispatch/ConvexConcaveCollisionAlgorithm.cpp
index 17c1dcd1caf..684fd72179f 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/ConvexConcaveCollisionAlgorithm.cpp
+++ b/extern/bullet/Bullet/CollisionDispatch/ConvexConcaveCollisionAlgorithm.cpp
@@ -10,15 +10,12 @@
 */
 
 #include "ConvexConcaveCollisionAlgorithm.h"
-#include "Dynamics/RigidBody.h"
+#include "NarrowPhaseCollision/CollisionObject.h"
 #include "CollisionShapes/MultiSphereShape.h"
-#include "ConstraintSolver/ContactConstraint.h"
 #include "CollisionShapes/BoxShape.h"
 #include "ConvexConvexAlgorithm.h"
 #include "BroadphaseCollision/BroadphaseProxy.h"
 #include "CollisionShapes/TriangleShape.h"
-#include "ConstraintSolver/ConstraintSolver.h"
-#include "ConstraintSolver/ContactSolverInfo.h"
 #include "CollisionDispatch/ManifoldResult.h"
 #include "NarrowPhaseCollision/RaycastCallback.h"
 #include "CollisionShapes/TriangleMeshShape.h"
@@ -76,29 +73,30 @@ void BoxTriangleCallback::ProcessTriangle(SimdVector3* triangle)
 	//printf("triangle %d",m_triangleCount++);
 
 
-	RigidBody* triangleBody = (RigidBody*)m_triangleProxy.m_clientObject;
-
 	//aabb filter is already applied!	
 
 	CollisionAlgorithmConstructionInfo ci;
 	ci.m_dispatcher = m_dispatcher;
 
-	ConvexShape* tmp = static_cast<ConvexShape*>(triangleBody->GetCollisionShape());
+	
 
 	if (m_boxProxy->IsConvexShape())
 	{
 		TriangleShape tm(triangle[0],triangle[1],triangle[2]);	
 		tm.SetMargin(m_collisionMarginTriangle);
+	
+		CollisionObject* ob = static_cast<CollisionObject*>(m_triangleProxy.m_clientObject);
 
-		RigidBody* triangleBody = (RigidBody* )m_triangleProxy.m_clientObject;
+		CollisionShape* tmpShape = ob->m_collisionShape;
+		ob->m_collisionShape = &tm;
 		
-		triangleBody->SetCollisionShape(&tm);
 		ConvexConvexAlgorithm cvxcvxalgo(m_manifoldPtr,ci,m_boxProxy,&m_triangleProxy);
-		triangleBody->SetCollisionShape(&tm);
 		cvxcvxalgo.ProcessCollision(m_boxProxy,&m_triangleProxy,m_timeStep,m_stepCount,m_useContinuous);
+		ob->m_collisionShape = tmpShape;
+
 	}
 
-	triangleBody->SetCollisionShape(tmp);
+	
 
 }
 
@@ -113,13 +111,16 @@ void	BoxTriangleCallback::SetTimeStepAndCounters(float timeStep,int stepCount,fl
 	m_collisionMarginTriangle = collisionMarginTriangle;
 
 	//recalc aabbs
-	RigidBody* boxBody = (RigidBody* )m_boxProxy->m_clientObject;
-	RigidBody* triBody = (RigidBody* )m_triangleProxy.m_clientObject;
+	CollisionObject* boxBody = (CollisionObject* )m_boxProxy->m_clientObject;
+	CollisionObject* triBody = (CollisionObject* )m_triangleProxy.m_clientObject;
 
 	SimdTransform boxInTriangleSpace;
-	boxInTriangleSpace = triBody->getCenterOfMassTransform().inverse() * boxBody->getCenterOfMassTransform();
+	boxInTriangleSpace = triBody->m_worldTransform.inverse() * boxBody->m_worldTransform;
+
+	CollisionShape* boxshape = static_cast<CollisionShape*>(boxBody->m_collisionShape);
+	CollisionShape* triangleShape = static_cast<CollisionShape*>(triBody->m_collisionShape);
 
-	boxBody->GetCollisionShape()->GetAabb(boxInTriangleSpace,m_aabbMin,m_aabbMax);
+	boxshape->GetAabb(boxInTriangleSpace,m_aabbMin,m_aabbMax);
 
 	float extraMargin = collisionMarginTriangle;//CONVEX_DISTANCE_MARGIN;//+0.1f;
 
@@ -142,15 +143,13 @@ void ConvexConcaveCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,Broadp
 	if (m_concave.GetClientObjectType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
 	{
 
-		RigidBody* convexbody = (RigidBody* )m_convex.m_clientObject;
-		RigidBody* concavebody = (RigidBody* )m_concave.m_clientObject;
-
-			//todo: move this in the dispatcher
-		if ((convexbody->GetActivationState() == 2) &&(concavebody->GetActivationState() == 2))
-		return;
+		if (!m_dispatcher->NeedsCollision(m_convex,m_concave))
+			return;
 
+		
 
-		TriangleMeshShape* triangleMesh = (TriangleMeshShape*) concavebody->GetCollisionShape();
+		CollisionObject*	triOb = static_cast<CollisionObject*>(m_concave.m_clientObject);
+		TriangleMeshShape* triangleMesh = static_cast<TriangleMeshShape*>( triOb->m_collisionShape);
 		
 		if (m_convex.IsConvexShape())
 		{
@@ -160,7 +159,7 @@ void ConvexConcaveCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,Broadp
 #ifdef USE_BOX_TRIANGLE
 			m_boxTriangleCallback.m_manifoldPtr->ClearManifold();
 #endif
-			m_boxTriangleCallback.m_manifoldPtr->SetBodies(convexbody,concavebody);		
+			m_boxTriangleCallback.m_manifoldPtr->SetBodies(m_convex.m_clientObject,m_concave.m_clientObject);
 
 			triangleMesh->ProcessAllTriangles( &m_boxTriangleCallback,m_boxTriangleCallback.GetAabbMin(),m_boxTriangleCallback.GetAabbMax());
 			
@@ -175,24 +174,11 @@ void ConvexConcaveCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,Broadp
 float ConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* ,BroadphaseProxy* ,float timeStep,int stepCount)
 {
 
-	return 1.f;
-
 	//quick approximation using raycast, todo: use proper continuou collision detection
-	RigidBody* convexbody = (RigidBody* )m_convex.m_clientObject;
-	const SimdVector3& from = convexbody->getCenterOfMassPosition();
-		
-	SimdVector3 radVec(0,0,0);
+	CollisionObject* convexbody = (CollisionObject* )m_convex.m_clientObject;
+	const SimdVector3& from = convexbody->m_worldTransform.getOrigin();
 	
-	float minradius = 0.05f;
-	float lenSqr = convexbody->getLinearVelocity().length2();
-	if (lenSqr > SIMD_EPSILON)
-	{
-		radVec = convexbody->getLinearVelocity();
-		radVec.normalize();
-		radVec *= minradius;
-	}
-
-	SimdVector3 to = from + radVec + convexbody->getLinearVelocity() * timeStep*1.01f;
+	SimdVector3 to = convexbody->m_nextPredictedWorldTransform.getOrigin();
 	//only do if the motion exceeds the 'radius'
 
 
@@ -206,9 +192,9 @@ float ConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* ,B
 	if (m_concave.GetClientObjectType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
 	{
 
-		RigidBody* concavebody = (RigidBody* )m_concave.m_clientObject;
+		CollisionObject* concavebody = (CollisionObject* )m_concave.m_clientObject;
 
-		TriangleMeshShape* triangleMesh = (TriangleMeshShape*) concavebody->GetCollisionShape();
+		TriangleMeshShape* triangleMesh = (TriangleMeshShape*) concavebody->m_collisionShape;
 		
 		if (triangleMesh)
 		{
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/ConvexConcaveCollisionAlgorithm.h b/extern/bullet/Bullet/CollisionDispatch/ConvexConcaveCollisionAlgorithm.h
index 366bdd02bb8..4e7fb982077 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/ConvexConcaveCollisionAlgorithm.h
+++ b/extern/bullet/Bullet/CollisionDispatch/ConvexConcaveCollisionAlgorithm.h
@@ -12,7 +12,7 @@
 #define CONVEX_CONCAVE_COLLISION_ALGORITHM_H
 
 #include "BroadphaseCollision/CollisionAlgorithm.h"
-#include "BroadphaseCollision/CollisionDispatcher.h"
+#include "BroadphaseCollision/Dispatcher.h"
 #include "BroadphaseCollision/BroadphaseInterface.h"
 #include "CollisionShapes/TriangleCallback.h"
 #include "NarrowPhaseCollision/PersistentManifold.h"
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/ConvexConvexAlgorithm.cpp b/extern/bullet/Bullet/CollisionDispatch/ConvexConvexAlgorithm.cpp
index fef5ef281b2..5fec6466f55 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/ConvexConvexAlgorithm.cpp
+++ b/extern/bullet/Bullet/CollisionDispatch/ConvexConvexAlgorithm.cpp
@@ -13,11 +13,11 @@
 #include <stdio.h>
 #include "NarrowPhaseCollision/DiscreteCollisionDetectorInterface.h"
 #include "BroadphaseCollision/BroadphaseInterface.h"
-#include "Dynamics/RigidBody.h"
+#include "NarrowPhaseCollision/CollisionObject.h"
 #include "CollisionShapes/ConvexShape.h"
 #include "NarrowPhaseCollision/GjkPairDetector.h"
 #include "BroadphaseCollision/BroadphaseProxy.h"
-#include "BroadphaseCollision/CollisionDispatcher.h"
+#include "CollisionDispatch/CollisionDispatcher.h"
 #include "CollisionShapes/BoxShape.h"
 #include "CollisionDispatch/ManifoldResult.h"
 
@@ -75,13 +75,8 @@ m_useEpa(!gUseEpa)
 {
 	CheckPenetrationDepthSolver();
 
-	RigidBody* body0 = (RigidBody*)m_box0.m_clientObject;
-	RigidBody* body1 = (RigidBody*)m_box1.m_clientObject;
-
-	if ((body0->getInvMass() != 0.f) || 
-		(body1->getInvMass() != 0.f))
 	{
-		if (!m_manifoldPtr)
+		if (!m_manifoldPtr && m_dispatcher->NeedsCollision(m_box0,m_box1))
 		{
 			m_manifoldPtr = m_dispatcher->GetNewManifold(proxy0->m_clientObject,proxy1->m_clientObject);
 			m_ownManifold = true;
@@ -169,32 +164,25 @@ void	ConvexConvexAlgorithm::CheckPenetrationDepthSolver()
 //
 void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy* ,float timeStep,int stepCount, bool useContinuous)
 {
-	CheckPenetrationDepthSolver();
-
-//	printf("ConvexConvexAlgorithm::ProcessCollision\n");
-
-	
-	RigidBody* body0 = (RigidBody*)m_box0.m_clientObject;
-	RigidBody* body1 = (RigidBody*)m_box1.m_clientObject;
-
-	//todo: move this in the dispatcher
-	if ((body0->GetActivationState() == 2) &&(body1->GetActivationState() == 2))
+	if (!m_manifoldPtr)
 		return;
 
+	CheckPenetrationDepthSolver();
 
-	if (!m_manifoldPtr)
-		return;
+//	printf("ConvexConvexAlgorithm::ProcessCollision\n");
 
-	if ((body0->getInvMass() == 0.f) && 
-		(body1->getInvMass() == 0.f))
-	{
+	bool needsCollision = m_dispatcher->NeedsCollision(m_box0,m_box1);
+	if (!needsCollision)
 		return;
-	}
-
-	ManifoldResult output(body0,body1,m_manifoldPtr);
 	
-	ConvexShape* min0 = static_cast<ConvexShape*>(body0->GetCollisionShape());
-	ConvexShape* min1 = static_cast<ConvexShape*>(body1->GetCollisionShape());	
+	CollisionObject*	col0 = static_cast<CollisionObject*>(m_box0.m_clientObject);
+	CollisionObject*	col1 = static_cast<CollisionObject*>(m_box1.m_clientObject);
+	
+	ManifoldResult output(col0,col1,m_manifoldPtr);
+	
+	ConvexShape* min0 = static_cast<ConvexShape*>(col0->m_collisionShape);
+	ConvexShape* min1 = static_cast<ConvexShape*>(col1->m_collisionShape);
+	
 	GjkPairDetector::ClosestPointInput input;
 
 	SphereShape	sphere(0.2f);
@@ -218,8 +206,8 @@ void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy
 
 	input.m_maximumDistanceSquared = 1e30;//
 	
-	input.m_transformA = body0->getCenterOfMassTransform();
-	input.m_transformB = body1->getCenterOfMassTransform();
+	input.m_transformA = col0->m_worldTransform;
+	input.m_transformB = col1->m_worldTransform;
     
 	m_gjkPairDetector.GetClosestPoints(input,output);
 
@@ -231,35 +219,20 @@ float	ConvexConvexAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,Broad
 	CheckPenetrationDepthSolver();
 
 
-	
-	RigidBody* body0 = (RigidBody*)m_box0.m_clientObject;
-	RigidBody* body1 = (RigidBody*)m_box1.m_clientObject;
+	bool needsCollision = m_dispatcher->NeedsCollision(m_box0,m_box1);
 
-	if (!m_manifoldPtr)
+	if (!needsCollision)
 		return 1.f;
 
-	if ((body0->getInvMass() == 0.f) && 
-		(body1->getInvMass() == 0.f))
-	{
-		return 1.f;
-	}
-
-
-	ConvexShape* min0 = static_cast<ConvexShape*>(body0->GetCollisionShape());
-	ConvexShape* min1 = static_cast<ConvexShape*>(body1->GetCollisionShape());	
 	
-	GjkPairDetector::ClosestPointInput input;
-	input.m_transformA = body0->getCenterOfMassTransform();
-	input.m_transformB = body1->getCenterOfMassTransform();
-	SimdTransform predictA,predictB;
-
-	body0->predictIntegratedTransform(timeStep,predictA);
-	body1->predictIntegratedTransform(timeStep,predictB);
-
-
+	CollisionObject* col0 = static_cast<CollisionObject*>(m_box0.m_clientObject);
+	CollisionObject* col1 = static_cast<CollisionObject*>(m_box1.m_clientObject);
+	
+	ConvexShape* min0 = static_cast<ConvexShape*>(col0->m_collisionShape);
+	ConvexShape* min1 = static_cast<ConvexShape*>(col1->m_collisionShape);
+	
 	ConvexCast::CastResult result;
 
-
 	VoronoiSimplexSolver voronoiSimplex;
 	//SubsimplexConvexCast ccd(&voronoiSimplex);
 	//GjkConvexCast ccd(&voronoiSimplex);
@@ -269,25 +242,22 @@ float	ConvexConvexAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,Broad
 	if (disableCcd)
 		return 1.f;
 
-	if (ccd.calcTimeOfImpact(input.m_transformA,predictA,input.m_transformB,predictB,result))
+	if (ccd.calcTimeOfImpact(col0->m_worldTransform,col0->m_nextPredictedWorldTransform,
+		col1->m_worldTransform,col1->m_nextPredictedWorldTransform,result))
 	{
 	
 		//store result.m_fraction in both bodies
-		int i;
-		i=0;
-		
-//		if (result.m_fraction< 0.1f)
-//			result.m_fraction = 0.1f;
-
-		if (body0->m_hitFraction > result.m_fraction)
-			body0->m_hitFraction  = result.m_fraction;
+	
+		if (col0->m_hitFraction	> result.m_fraction)
+			col0->m_hitFraction  = result.m_fraction;
 
-		if (body1->m_hitFraction > result.m_fraction)
-			body1->m_hitFraction  = result.m_fraction;
+		if (col1->m_hitFraction > result.m_fraction)
+			col1->m_hitFraction  = result.m_fraction;
 
 		return result.m_fraction;
 	}
 
+
 	return 1.f;
 
 
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/ConvexConvexAlgorithm.h b/extern/bullet/Bullet/CollisionDispatch/ConvexConvexAlgorithm.h
index b560e8d4c15..b560e8d4c15 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/ConvexConvexAlgorithm.h
+++ b/extern/bullet/Bullet/CollisionDispatch/ConvexConvexAlgorithm.h
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/EmptyCollisionAlgorithm.cpp b/extern/bullet/Bullet/CollisionDispatch/EmptyCollisionAlgorithm.cpp
index 632dc911770..632dc911770 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/EmptyCollisionAlgorithm.cpp
+++ b/extern/bullet/Bullet/CollisionDispatch/EmptyCollisionAlgorithm.cpp
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/EmptyCollisionAlgorithm.h b/extern/bullet/Bullet/CollisionDispatch/EmptyCollisionAlgorithm.h
index 371941193e4..371941193e4 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/EmptyCollisionAlgorithm.h
+++ b/extern/bullet/Bullet/CollisionDispatch/EmptyCollisionAlgorithm.h
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/ManifoldResult.cpp b/extern/bullet/Bullet/CollisionDispatch/ManifoldResult.cpp
index a5b13b1eccd..a3521c7503b 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/ManifoldResult.cpp
+++ b/extern/bullet/Bullet/CollisionDispatch/ManifoldResult.cpp
@@ -11,9 +11,9 @@
 
 #include "ManifoldResult.h"
 #include "NarrowPhaseCollision/PersistentManifold.h"
-#include "Dynamics/RigidBody.h"
+#include "NarrowPhaseCollision/CollisionObject.h"
 
-ManifoldResult::ManifoldResult(RigidBody* body0,RigidBody* body1,PersistentManifold* manifoldPtr)
+ManifoldResult::ManifoldResult(CollisionObject* body0,CollisionObject* body1,PersistentManifold* manifoldPtr)
 		:m_manifoldPtr(manifoldPtr),
 		m_body0(body0),
 		m_body1(body1)
@@ -25,8 +25,8 @@ void ManifoldResult::AddContactPoint(const SimdVector3& normalOnBInWorld,const S
 	if (depth > m_manifoldPtr->GetManifoldMargin())
 		return;
 
-	SimdTransform transAInv = m_body0->getCenterOfMassTransform().inverse();
-	SimdTransform transBInv= m_body1->getCenterOfMassTransform().inverse();
+	SimdTransform transAInv = m_body0->m_worldTransform.inverse();
+	SimdTransform transBInv= m_body1->m_worldTransform.inverse();
 	SimdVector3 pointA = pointInWorld + normalOnBInWorld * depth;
 	SimdVector3 localA = transAInv(pointA );
 	SimdVector3 localB = transBInv(pointInWorld);
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/ManifoldResult.h b/extern/bullet/Bullet/CollisionDispatch/ManifoldResult.h
index 8462469164e..a73ee09c3f7 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/ManifoldResult.h
+++ b/extern/bullet/Bullet/CollisionDispatch/ManifoldResult.h
@@ -13,19 +13,19 @@
 #define MANIFOLD_RESULT_H
 
 #include "NarrowPhaseCollision/DiscreteCollisionDetectorInterface.h"
-class RigidBody;
+struct CollisionObject;
 class PersistentManifold;
 
 
 class ManifoldResult : public DiscreteCollisionDetectorInterface::Result
 {
 	PersistentManifold* m_manifoldPtr;
-	RigidBody* m_body0;
-	RigidBody* m_body1;
+	CollisionObject* m_body0;
+	CollisionObject* m_body1;
 
 public:
 
-	ManifoldResult(RigidBody* body0,RigidBody* body1,PersistentManifold* manifoldPtr);
+	ManifoldResult(CollisionObject* body0,CollisionObject* body1,PersistentManifold* manifoldPtr);
 
 
 	virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth);
diff --git a/extern/bullet/Bullet/CollisionDispatch/UnionFind.cpp b/extern/bullet/Bullet/CollisionDispatch/UnionFind.cpp
new file mode 100644
index 00000000000..6a1e0b6e659
--- /dev/null
+++ b/extern/bullet/Bullet/CollisionDispatch/UnionFind.cpp
@@ -0,0 +1,85 @@
+#include "UnionFind.h"
+#include <assert.h>
+
+
+int UnionFind::find(int x)
+{ 
+	assert(x < m_N);
+	assert(x >= 0);
+
+	while (x != m_id[x]) 
+	{
+		x = m_id[x];
+		assert(x < m_N);
+		assert(x >= 0);
+
+	}
+	return x; 
+}
+
+UnionFind::~UnionFind()
+{
+	Free();
+
+}
+
+UnionFind::UnionFind()
+:m_id(0),
+m_sz(0),
+m_N(0)
+{ 
+
+}
+
+void	UnionFind::Allocate(int N)
+{
+	if (m_N < N)
+	{
+		Free();
+
+		m_N = N;
+		m_id = new int[N]; 
+		m_sz = new int[N];
+	}
+}
+void	UnionFind::Free()
+{
+	if (m_N)
+	{
+		m_N=0;
+		delete m_id;
+		delete m_sz;
+	}
+}
+
+
+void	UnionFind::reset(int N)
+{
+	Allocate(N);
+
+	for (int i = 0; i < m_N; i++) 
+	{ 
+		m_id[i] = i; m_sz[i] = 1; 
+	} 
+}
+
+
+int UnionFind ::find(int p, int q)
+{ 
+	return (find(p) == find(q)); 
+}
+
+void UnionFind ::unite(int p, int q)
+{
+	int i = find(p), j = find(q);
+	if (i == j) 
+		return;
+	if (m_sz[i] < m_sz[j])
+	{ 
+		m_id[i] = j; m_sz[j] += m_sz[i]; 
+	}
+	else 
+	{ 
+		m_id[j] = i; m_sz[i] += m_sz[j]; 
+	}
+}
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/UnionFind.h b/extern/bullet/Bullet/CollisionDispatch/UnionFind.h
index 0dc57783283..17cda1e8a61 100644
--- a/extern/bullet/BulletDynamics/CollisionDispatch/UnionFind.h
+++ b/extern/bullet/Bullet/CollisionDispatch/UnionFind.h
@@ -5,16 +5,24 @@
 class UnionFind
   {
     private:
-      int *id, *sz;
-	  int m_N;
+		int*	m_id;
+		int*	m_sz;
+		int m_N;
 
     public:
-      int find(int x);
-		UnionFind(int N);
-	  void	reset();
+		int find(int x);
+	  
+		UnionFind();
+		~UnionFind();
+
+	  void	reset(int N);
 
       int find(int p, int q);
       void unite(int p, int q);
+
+	  void	Allocate(int N);
+	  void	Free();
+
   };
 
 
diff --git a/extern/bullet/Bullet/NarrowPhaseCollision/CollisionObject.cpp b/extern/bullet/Bullet/NarrowPhaseCollision/CollisionObject.cpp
new file mode 100644
index 00000000000..ca95128acda
--- /dev/null
+++ b/extern/bullet/Bullet/NarrowPhaseCollision/CollisionObject.cpp
@@ -0,0 +1,19 @@
+#include "CollisionObject.h"
+
+
+
+void CollisionObject::SetActivationState(int newState) 
+{ 
+	m_activationState1 = newState;
+}
+
+void CollisionObject::activate()
+{
+		SetActivationState(1);
+		m_deactivationTime = 0.f;
+}
+
+bool CollisionObject::mergesSimulationIslands() const
+{
+	return ( !(m_collisionFlags & isStatic));
+}
diff --git a/extern/bullet/Bullet/NarrowPhaseCollision/CollisionObject.h b/extern/bullet/Bullet/NarrowPhaseCollision/CollisionObject.h
new file mode 100644
index 00000000000..c83d73938ee
--- /dev/null
+++ b/extern/bullet/Bullet/NarrowPhaseCollision/CollisionObject.h
@@ -0,0 +1,67 @@
+#ifndef COLLISION_OBJECT_H
+#define COLLISION_OBJECT_H
+
+#include "SimdTransform.h"
+
+//island management, m_activationState1
+#define ACTIVE_TAG 1
+#define ISLAND_SLEEPING 2
+#define WANTS_DEACTIVATION 3
+
+struct	BroadphaseProxy;
+class	CollisionShape;
+
+struct	CollisionObject
+{
+	SimdTransform	m_worldTransform;
+	
+	//m_nextPredictedWorldTransform is used for CCD and interpolation
+	SimdTransform	m_nextPredictedWorldTransform;
+	
+	enum CollisionFlags
+	{
+		isStatic = 1,
+	};
+
+	int				m_collisionFlags;
+
+	int				m_islandTag1;
+	int				m_activationState1;
+	float			m_deactivationTime;
+
+	BroadphaseProxy*	m_broadphaseHandle;
+	CollisionShape*		m_collisionShape;
+
+	//time of impact calculation
+	float			m_hitFraction; 
+
+	bool			mergesSimulationIslands() const;
+
+
+	CollisionObject()
+	:	m_activationState1(1),
+		m_deactivationTime(0.f),
+		m_collisionFlags(0),
+		m_hitFraction(1.f),
+		m_broadphaseHandle(0),
+		m_collisionShape(0)
+	{
+	}
+
+
+	void	SetCollisionShape(CollisionShape* collisionShape)
+	{
+		m_collisionShape = collisionShape;
+	}
+
+	int	GetActivationState() const { return m_activationState1;}
+	
+	void SetActivationState(int newState);
+
+	void	activate();
+
+
+
+};
+
+#endif //COLLISION_OBJECT_H
diff --git a/extern/bullet/Bullet/NarrowPhaseCollision/SubSimplexConvexCast.cpp b/extern/bullet/Bullet/NarrowPhaseCollision/SubSimplexConvexCast.cpp
index c665b7b0ced..c75bbb53936 100644
--- a/extern/bullet/Bullet/NarrowPhaseCollision/SubSimplexConvexCast.cpp
+++ b/extern/bullet/Bullet/NarrowPhaseCollision/SubSimplexConvexCast.cpp
@@ -115,7 +115,7 @@ bool	SubsimplexConvexCast::calcTimeOfImpact(
 	int numiter = MAX_ITERATIONS - maxIter;
 //	printf("number of iterations: %d", numiter);
 	result.m_fraction = lambda;
-	result.m_normal = n;
+	result.m_normal = -n;
 
 	return true;
 }
diff --git a/extern/bullet/BulletDynamics/BulletDynamics_vc8.vcproj b/extern/bullet/BulletDynamics/BulletDynamics_vc8.vcproj
index 2efa75b0f55..58e1e090b51 100644
--- a/extern/bullet/BulletDynamics/BulletDynamics_vc8.vcproj
+++ b/extern/bullet/BulletDynamics/BulletDynamics_vc8.vcproj
@@ -41,12 +41,12 @@
 				Optimization="0"
 				AdditionalIncludeDirectories="..\LinearMath;..\Bullet;..\BulletDynamics"
 				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="TRUE"
+				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="1"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
-				Detect64BitPortabilityProblems="TRUE"
+				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
 			/>
 			<Tool
@@ -72,7 +72,7 @@
 				Name="VCBscMakeTool"
 			/>
 			<Tool
-				Name="VCAppVerifierTool"
+				Name="VCFxCopTool"
 			/>
 			<Tool
 				Name="VCPostBuildEventTool"
@@ -107,7 +107,7 @@
 				RuntimeLibrary="0"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
-				Detect64BitPortabilityProblems="TRUE"
+				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="3"
 			/>
 			<Tool
@@ -133,7 +133,7 @@
 				Name="VCBscMakeTool"
 			/>
 			<Tool
-				Name="VCAppVerifierTool"
+				Name="VCFxCopTool"
 			/>
 			<Tool
 				Name="VCPostBuildEventTool"
@@ -208,54 +208,50 @@
 			</File>
 		</Filter>
 		<Filter
-			Name="CollisionDispatch"
+			Name="Vehicle"
 			>
 			<File
-				RelativePath=".\CollisionDispatch\ConvexConcaveCollisionAlgorithm.cpp"
+				RelativePath=".\Vehicle\RaycastVehicle.cpp"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\ConvexConcaveCollisionAlgorithm.h"
+				RelativePath=".\Vehicle\RaycastVehicle.h"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\ConvexConvexAlgorithm.cpp"
+				RelativePath=".\Vehicle\VehicleControl.h"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\ConvexConvexAlgorithm.h"
+				RelativePath=".\Vehicle\VehicleFrame.h"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\EmptyCollisionAlgorithm.cpp"
+				RelativePath=".\Vehicle\VehicleInputController.h"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\EmptyCollisionAlgorithm.h"
+				RelativePath=".\Vehicle\VehicleRaycaster.h"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\ManifoldResult.cpp"
+				RelativePath=".\Vehicle\VehicleTuning.cpp"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\ManifoldResult.h"
+				RelativePath=".\Vehicle\VehicleTuning.h"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\ToiContactDispatcher.cpp"
+				RelativePath=".\Vehicle\WheelInfo.cpp"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\ToiContactDispatcher.h"
+				RelativePath=".\Vehicle\WheelInfo.h"
 				>
 			</File>
 			<File
-				RelativePath=".\CollisionDispatch\UnionFind.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\CollisionDispatch\UnionFind.h"
+				RelativePath=".\Vehicle\WheelSkidInfo.h"
 				>
 			</File>
 		</Filter>
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/ToiContactDispatcher.cpp b/extern/bullet/BulletDynamics/CollisionDispatch/ToiContactDispatcher.cpp
deleted file mode 100644
index 3845f307a60..00000000000
--- a/extern/bullet/BulletDynamics/CollisionDispatch/ToiContactDispatcher.cpp
+++ /dev/null
@@ -1,213 +0,0 @@
-#include "ToiContactDispatcher.h"
-#include "ConstraintSolver/ConstraintSolver.h"
-#include "Dynamics/RigidBody.h"
-#include "BroadphaseCollision/CollisionAlgorithm.h"
-#include "ConstraintSolver/ContactSolverInfo.h"
-#include "CollisionDispatch/ConvexConvexAlgorithm.h"
-#include "CollisionDispatch/EmptyCollisionAlgorithm.h"
-#include "CollisionDispatch/ConvexConcaveCollisionAlgorithm.h"
-
-
-
-void ToiContactDispatcher::FindUnions()
-{
-	if (m_useIslands)
-	{
-		for (int i=0;i<GetNumManifolds();i++)
-		{
-			const PersistentManifold* manifold = this->GetManifoldByIndexInternal(i);
-			//static objects (invmass 0.f) don't merge !
-			if ((((RigidBody*)manifold->GetBody0()) && (((RigidBody*)manifold->GetBody0())->mergesSimulationIslands())) &&
-				(((RigidBody*)manifold->GetBody1()) && (((RigidBody*)manifold->GetBody1())->mergesSimulationIslands())))
-			{
-
-				m_unionFind.unite(((RigidBody*)manifold->GetBody0())->m_islandTag1,
-					((RigidBody*)manifold->GetBody1())->m_islandTag1);
-			}
-			
-			
-		}
-	}
-	
-}
-	
-
-	
-ToiContactDispatcher::ToiContactDispatcher (ConstraintSolver* solver): 
-	m_useIslands(true),
-		m_unionFind(MAX_RIGIDBODIES),
-		m_solver(solver),
-		m_count(0),
-		m_sor(1.3f),
-		m_tau(0.4f),
-		m_damping(0.9f)
-		
-{
-	int i;
-	
-	for (i=0;i<MAX_BROADPHASE_COLLISION_TYPES;i++)
-	{
-		for (int j=0;j<MAX_BROADPHASE_COLLISION_TYPES;j++)
-		{
-			m_doubleDispatch[i][j] = 0;
-		}
-	}
-	
-	
-};
-	
-PersistentManifold*	ToiContactDispatcher::GetNewManifold(void* b0,void* b1) 
-{ 
-
-	RigidBody* body0 = (RigidBody*)b0;
-	RigidBody* body1 = (RigidBody*)b1;
-	
-	PersistentManifold* manifold = new PersistentManifold (body0,body1);
-	m_manifoldsPtr.push_back(manifold);
-
-	return manifold;
-}
-#include <algorithm>
-	
-void ToiContactDispatcher::ReleaseManifold(PersistentManifold* manifold)
-{
-	manifold->ClearManifold();
-
-	std::vector<PersistentManifold*>::iterator i =
-		std::find(m_manifoldsPtr.begin(), m_manifoldsPtr.end(), manifold);
-	if (!(i == m_manifoldsPtr.end()))
-	{
-		std::swap(*i, m_manifoldsPtr.back());
-		m_manifoldsPtr.pop_back();
-	}
-	
-	
-}
-	
-	
-//
-// todo: this is random access, it can be walked 'cache friendly'!
-//
-void ToiContactDispatcher::SolveConstraints(float timeStep, int numIterations,int numRigidBodies,IDebugDraw* debugDrawer) 
-{
-	int i;
-
-
-	for (int islandId=0;islandId<numRigidBodies;islandId++)
-	{
-
-		std::vector<PersistentManifold*>  islandmanifold;
-		
-		//int numSleeping = 0;
-
-		bool allSleeping = true;
-
-		for (i=0;i<GetNumManifolds();i++)
-		{
-			 PersistentManifold* manifold = this->GetManifoldByIndexInternal(i);
-			if ((((RigidBody*)manifold->GetBody0()) && ((RigidBody*)manifold->GetBody0())->m_islandTag1 == (islandId)) ||
-				(((RigidBody*)manifold->GetBody1()) && ((RigidBody*)manifold->GetBody1())->m_islandTag1 == (islandId)))
-			{
-
-				if ((((RigidBody*)manifold->GetBody0()) && ((RigidBody*)manifold->GetBody0())->GetActivationState()== ACTIVE_TAG) ||
-					(((RigidBody*)manifold->GetBody1()) && ((RigidBody*)manifold->GetBody1())->GetActivationState() == ACTIVE_TAG))
-				{
-					allSleeping = false;
-				}
-
-				islandmanifold.push_back(manifold);
-			}
-		}
-		if (allSleeping)
-		{
-			//tag all as 'ISLAND_SLEEPING'
-			for (i=0;i<islandmanifold.size();i++)
-			{
-				 PersistentManifold* manifold = islandmanifold[i];
-				if (((RigidBody*)manifold->GetBody0()))	
-				{
-					((RigidBody*)manifold->GetBody0())->SetActivationState( ISLAND_SLEEPING );
-				}
-				if (((RigidBody*)manifold->GetBody1()))	
-				{
-					((RigidBody*)manifold->GetBody1())->SetActivationState( ISLAND_SLEEPING);
-				}
-
-			}
-		} else
-		{
-
-			//tag all as 'ISLAND_SLEEPING'
-			for (i=0;i<islandmanifold.size();i++)
-			{
-				 PersistentManifold* manifold = islandmanifold[i];
-				 RigidBody* body0 = (RigidBody*)manifold->GetBody0();
-				 RigidBody* body1 = (RigidBody*)manifold->GetBody1();
-
-				if (body0)	
-				{
-					if ( body0->GetActivationState() == ISLAND_SLEEPING)
-					{
-						body0->SetActivationState( WANTS_DEACTIVATION);
-					}
-				}
-				if (body1)	
-				{
-					if ( body1->GetActivationState() == ISLAND_SLEEPING)
-					{
-						body1->SetActivationState(WANTS_DEACTIVATION);
-					}
-				}
-
-			}
-
-			///This island solving can all be scheduled in parallel
-			ContactSolverInfo info;
-			info.m_friction = 0.9f;
-			info.m_numIterations = numIterations;
-			info.m_timeStep = timeStep;
-			
-			info.m_restitution = 0.0f;//m_restitution;
-			
-			info.m_sor = m_sor;
-			info.m_tau = m_tau;
-			info.m_damping = m_damping;
-
-			m_solver->SolveGroup( &islandmanifold[0], islandmanifold.size(),info,debugDrawer );
-
-		}
-	}
-
-
-
-
-}
-
-
-
-CollisionAlgorithm* ToiContactDispatcher::InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
-{
-	m_count++;
-	
-	CollisionAlgorithmConstructionInfo ci;
-	ci.m_dispatcher = this;
-	
-	if (proxy0.IsConvexShape() && proxy1.IsConvexShape() )
-	{
-		return new ConvexConvexAlgorithm(0,ci,&proxy0,&proxy1);			
-	}
-
-	if (proxy0.IsConvexShape() && proxy1.IsConcaveShape())
-	{
-		return new ConvexConcaveCollisionAlgorithm(ci,&proxy0,&proxy1);
-	}
-
-	if (proxy1.IsConvexShape() && proxy0.IsConcaveShape())
-	{
-		return new ConvexConcaveCollisionAlgorithm(ci,&proxy1,&proxy0);
-	}
-
-	//failed to find an algorithm
-	return new EmptyAlgorithm(ci);
-	
-}
diff --git a/extern/bullet/BulletDynamics/CollisionDispatch/UnionFind.cpp b/extern/bullet/BulletDynamics/CollisionDispatch/UnionFind.cpp
deleted file mode 100644
index 2983b409aa3..00000000000
--- a/extern/bullet/BulletDynamics/CollisionDispatch/UnionFind.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "UnionFind.h"
-#include <assert.h>
-
-
-int UnionFind::find(int x)
-{ 
-	assert(x < m_N);
-	assert(x >= 0);
-
-	while (x != id[x]) 
-	{
-		x = id[x];
-		assert(x < m_N);
-		assert(x >= 0);
-
-	}
-	return x; 
-}
-
-UnionFind::UnionFind(int N)
-:m_N(N)
-{ 
-	id = new int[N]; sz = new int[N];
-	reset();
-}
-
-void	UnionFind::reset()
-{
-	for (int i = 0; i < m_N; i++) 
-	{ 
-		id[i] = i; sz[i] = 1; 
-	} 
-}
-
-
-int UnionFind ::find(int p, int q)
-{ 
-	return (find(p) == find(q)); 
-}
-
-void UnionFind ::unite(int p, int q)
-{
-	int i = find(p), j = find(q);
-	if (i == j) 
-		return;
-	if (sz[i] < sz[j])
-	{ 
-		id[i] = j; sz[j] += sz[i]; 
-	}
-	else 
-	{ 
-		id[j] = i; sz[i] += sz[j]; 
-	}
-}
diff --git a/extern/bullet/BulletDynamics/Dynamics/RigidBody.cpp b/extern/bullet/BulletDynamics/Dynamics/RigidBody.cpp
index f7c31dd0d68..87152a59b44 100644
--- a/extern/bullet/BulletDynamics/Dynamics/RigidBody.cpp
+++ b/extern/bullet/BulletDynamics/Dynamics/RigidBody.cpp
@@ -9,10 +9,7 @@ float gLinearAirDamping = 1.f;
 static int uniqueId = 0;
 
 RigidBody::RigidBody( const MassProps& massProps,SimdScalar linearDamping,SimdScalar angularDamping,SimdScalar friction,SimdScalar restitution)
-: m_collisionShape(0),
-	m_activationState1(1),
-	m_deactivationTime(0.f),
-	m_hitFraction(1.f),
+: 
 	m_gravity(0.0f, 0.0f, 0.0f),
 	m_linearDamping(0.f),
 	m_angularDamping(0.5f),
@@ -32,11 +29,7 @@ RigidBody::RigidBody( const MassProps& massProps,SimdScalar linearDamping,SimdSc
 
 }
 
-void RigidBody::activate()
-{
-		SetActivationState(1);
-		m_deactivationTime = 0.f;
-}
+
 void RigidBody::setLinearVelocity(const SimdVector3& lin_vel)
 { 
 
@@ -52,13 +45,9 @@ void RigidBody::predictIntegratedTransform(SimdScalar timeStep,SimdTransform& pr
 	
 void	RigidBody::getAabb(SimdVector3& aabbMin,SimdVector3& aabbMax) const
 {
-	m_collisionShape ->GetAabb(m_worldTransform,aabbMin,aabbMax);
+	GetCollisionShape()->GetAabb(m_worldTransform,aabbMin,aabbMax);
 }
 
-void	RigidBody::SetCollisionShape(CollisionShape* mink)
-{
-	m_collisionShape = mink;
-}
 
 
 void RigidBody::setGravity(const SimdVector3& acceleration) 
@@ -69,15 +58,8 @@ void RigidBody::setGravity(const SimdVector3& acceleration)
 	}
 }
 
-bool RigidBody::mergesSimulationIslands() const
-{
-	return ( getInvMass() != 0) ;
-}
 
-void RigidBody::SetActivationState(int newState) 
-{ 
-	m_activationState1 = newState;
-}
+
 
 
 
@@ -110,7 +92,17 @@ void RigidBody::proceedToTransform(const SimdTransform& newTrans)
 
 void RigidBody::setMassProps(SimdScalar mass, const SimdVector3& inertia)
 {
-	m_inverseMass = mass != 0.0f ? 1.0f / mass : 0.0f;
+	if (mass == 0.f)
+	{
+		m_collisionFlags = CollisionObject::isStatic;
+		m_inverseMass = 0.f;
+	} else
+	{
+		m_collisionFlags = 0;
+		m_inverseMass = 1.0f / mass;
+	}
+	
+
 	m_invInertiaLocal.setValue(inertia[0] != 0.0f ? 1.0f / inertia[0]: 0.0f,
 						   inertia[1] != 0.0f ? 1.0f / inertia[1]: 0.0f,
 						   inertia[2] != 0.0f ? 1.0f / inertia[2]: 0.0f);
@@ -152,12 +144,6 @@ SimdQuaternion RigidBody::getOrientation() const
 void RigidBody::setCenterOfMassTransform(const SimdTransform& xform)
 {
 	m_worldTransform = xform;
-	SimdQuaternion orn;
-//	m_worldTransform.getBasis().getRotation(orn);
-//	orn.normalize();
-//	m_worldTransform.setBasis(SimdMatrix3x3(orn));
-
-//	m_worldTransform.getBasis().getRotation(m_orn1);
 	updateInertiaTensor();
 }
 
diff --git a/extern/bullet/BulletDynamics/Dynamics/RigidBody.h b/extern/bullet/BulletDynamics/Dynamics/RigidBody.h
index 9b213635616..370ffad5c41 100644
--- a/extern/bullet/BulletDynamics/Dynamics/RigidBody.h
+++ b/extern/bullet/BulletDynamics/Dynamics/RigidBody.h
@@ -4,6 +4,10 @@
 #include <vector>
 #include <SimdPoint3.h>
 #include <SimdTransform.h>
+#include "BroadphaseCollision/BroadphaseProxy.h"
+
+
+#include "NarrowPhaseCollision/CollisionObject.h"
 
 class CollisionShape;
 struct MassProps;
@@ -17,14 +21,14 @@ extern bool gUseEpa;
 
 /// RigidBody class for RigidBody Dynamics
 /// 
-class RigidBody  {
+class RigidBody  : public CollisionObject
+{
 public:
 
 	RigidBody(const MassProps& massProps,SimdScalar linearDamping,SimdScalar angularDamping,SimdScalar friction,SimdScalar restitution);
 
 	void			proceedToTransform(const SimdTransform& newTrans); 
 	
-	bool			mergesSimulationIslands() const;
 	
 	/// continuous collision detection needs prediction
 	void			predictIntegratedTransform(SimdScalar step, SimdTransform& predictedTransform) const;
@@ -35,7 +39,13 @@ public:
 	
 	void			setDamping(SimdScalar lin_damping, SimdScalar ang_damping);
 	
-	CollisionShape*	GetCollisionShape() { return m_collisionShape; }
+	inline const CollisionShape*	GetCollisionShape() const {
+		return m_collisionShape;
+	}
+
+	inline CollisionShape*	GetCollisionShape() {
+			return m_collisionShape;
+	}
 	
 	void			setMassProps(SimdScalar mass, const SimdVector3& inertia);
 	
@@ -121,12 +131,9 @@ public:
 		m_worldTransform.getOrigin() += v; 
 	}
 
-	void	SetCollisionShape(CollisionShape* mink);
-
+	
 	void	getAabb(SimdVector3& aabbMin,SimdVector3& aabbMax) const;
 
-	int	GetActivationState() const { return m_activationState1;}
-	void SetActivationState(int newState);
 
 	void	setRestitution(float rest)
 	{
@@ -144,10 +151,9 @@ public:
 	{
 		return m_friction;
 	}
-	void	activate();
 
 private:
-	SimdTransform	m_worldTransform;
+	
 	SimdMatrix3x3	m_invInertiaTensorWorld;
 	SimdVector3		m_gravity;	
 	SimdVector3		m_invInertiaLocal;
@@ -166,23 +172,36 @@ private:
 	SimdScalar		m_friction;
 	SimdScalar		m_restitution;
 
-	CollisionShape*	m_collisionShape;
+	BroadphaseProxy*	m_broadphaseProxy;
+
+
 
 	
 public:
+	const BroadphaseProxy*	GetBroadphaseProxy() const
+	{
+		return m_broadphaseProxy;
+	}
+	BroadphaseProxy*	GetBroadphaseProxy() 
+	{
+		return m_broadphaseProxy;
+	}
+	void	SetBroadphaseProxy(BroadphaseProxy* broadphaseProxy)
+	{
+		m_broadphaseProxy = broadphaseProxy;
+	}
+	
+
 	/// for ode solver-binding
 	dMatrix3		m_R;//temp
 	dMatrix3		m_I;
 	dMatrix3		m_invI;
-	int				m_islandTag1;//temp
-	int				m_activationState1;//temp
-	float			m_deactivationTime;
 
 	int				m_odeTag;
 	float		m_padding[1024];
 	SimdVector3		m_tacc;//temp
 	SimdVector3		m_facc;
-	SimdScalar		m_hitFraction; //time of impact calculation
+	
 
 	int	m_debugBodyId;
 };
diff --git a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.cpp b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.cpp
index 919d1f9e58c..2f8f4a4e2ab 100644
--- a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.cpp
+++ b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.cpp
@@ -3,7 +3,10 @@
 #include "Dynamics/RigidBody.h"
 #include "PHY_IMotionState.h"
 #include "BroadphaseCollision/BroadphaseProxy.h"
+#include "BroadphaseCollision/BroadphaseInterface.h"
 #include "CollisionShapes/ConvexShape.h"
+#include "CcdPhysicsEnvironment.h"
+
 
 class BP_Proxy;
 
@@ -20,55 +23,67 @@ float gAngularSleepingTreshold = 1.0f;
 
 SimdVector3 startVel(0,0,0);//-10000);
 CcdPhysicsController::CcdPhysicsController (const CcdConstructionInfo& ci)
+:m_cci(ci)
 {
 	m_collisionDelay = 0;
 	m_newClientInfo = 0;
 	
 	m_MotionState = ci.m_MotionState;
 
+	
+	
+	CreateRigidbody();
+	
+
+	
+	#ifdef WIN32
+	if (m_body->getInvMass())
+		m_body->setLinearVelocity(startVel);
+	#endif
 
+}
+
+SimdTransform	CcdPhysicsController::GetTransformFromMotionState(PHY_IMotionState* motionState)
+{
 	SimdTransform trans;
 	float tmp[3];
-	m_MotionState->getWorldPosition(tmp[0],tmp[1],tmp[2]);
+	motionState->getWorldPosition(tmp[0],tmp[1],tmp[2]);
 	trans.setOrigin(SimdVector3(tmp[0],tmp[1],tmp[2]));
 
 	SimdQuaternion orn;
-	m_MotionState->getWorldOrientation(orn[0],orn[1],orn[2],orn[3]);
+	motionState->getWorldOrientation(orn[0],orn[1],orn[2],orn[3]);
 	trans.setRotation(orn);
+	return trans;
 
-	MassProps mp(ci.m_mass, ci.m_localInertiaTensor);
+}
 
-	m_body = new RigidBody(mp,0,0,ci.m_friction,ci.m_restitution);
+void CcdPhysicsController::CreateRigidbody()
+{
 
-	m_body->SetCollisionShape( ci.m_collisionShape);
+	SimdTransform trans = GetTransformFromMotionState(m_cci.m_MotionState);
 
-	
-	m_broadphaseHandle = ci.m_broadphaseHandle;
+	MassProps mp(m_cci.m_mass, m_cci.m_localInertiaTensor);
 
+	m_body = new RigidBody(mp,0,0,m_cci.m_friction,m_cci.m_restitution);
+	m_body->m_collisionShape = m_cci.m_collisionShape;
+	
 
 	//
 	// init the rigidbody properly
 	//
 	
-	m_body->setMassProps(ci.m_mass, ci.m_localInertiaTensor);
-	m_body->setGravity( ci.m_gravity);
-
-	
-	m_body->setDamping(ci.m_linearDamping, ci.m_angularDamping);
-
-
+	m_body->setMassProps(m_cci.m_mass, m_cci.m_localInertiaTensor * m_cci.m_inertiaFactor);
+	m_body->setGravity( m_cci.m_gravity);
+	m_body->setDamping(m_cci.m_linearDamping, m_cci.m_angularDamping);
 	m_body->setCenterOfMassTransform( trans );
 
-	#ifdef WIN32
-	if (m_body->getInvMass())
-		m_body->setLinearVelocity(startVel);
-	#endif
 
 }
 
 CcdPhysicsController::~CcdPhysicsController()
 {
 	//will be reference counted, due to sharing
+	m_cci.m_physicsEnv->removeCcdPhysicsController(this);
 	delete m_MotionState;
 	delete m_body;
 }
@@ -88,20 +103,12 @@ bool		CcdPhysicsController::SynchronizeMotionStates(float time)
 
 	float scale[3];
 	m_MotionState->getWorldScaling(scale[0],scale[1],scale[2]);
-	
 	SimdVector3 scaling(scale[0],scale[1],scale[2]);
-	m_body->GetCollisionShape()->setLocalScaling(scaling);
+	GetCollisionShape()->setLocalScaling(scaling);
 
 	return true;
 }
 
-CollisionShape*	CcdPhysicsController::GetCollisionShape() 
-{ 
-	return m_body->GetCollisionShape();
-}
-
-
-
 		/**
 			WriteMotionStateToDynamics synchronizes dynas, kinematic and deformable entities (and do 'late binding')
 		*/
@@ -116,13 +123,60 @@ void		CcdPhysicsController::WriteDynamicsToMotionState()
 		// controller replication
 void		CcdPhysicsController::PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl)
 {
+	m_MotionState = motionstate;
+
+	
+
+	m_body = 0;
+	CreateRigidbody();
+	
+	m_cci.m_physicsEnv->addCcdPhysicsController(this);
+
+
+/*	SM_Object* dynaparent=0;
+	SumoPhysicsController* sumoparentctrl = (SumoPhysicsController* )parentctrl;
+	
+	if (sumoparentctrl)
+	{
+		dynaparent = sumoparentctrl->GetSumoObject();
+	}
+	
+	SM_Object* orgsumoobject = m_sumoObj;
+	
+	
+	m_sumoObj	=	new SM_Object(
+		orgsumoobject->getShapeHandle(), 
+		orgsumoobject->getMaterialProps(),			
+		orgsumoobject->getShapeProps(),
+		dynaparent);
+	
+	m_sumoObj->setRigidBody(orgsumoobject->isRigidBody());
+	
+	m_sumoObj->setMargin(orgsumoobject->getMargin());
+	m_sumoObj->setPosition(orgsumoobject->getPosition());
+	m_sumoObj->setOrientation(orgsumoobject->getOrientation());
+	//if it is a dyna, register for a callback
+	m_sumoObj->registerCallback(*this);
+	
+	m_sumoScene->add(* (m_sumoObj));
+	*/
+
+
+
 }
 
 		// kinematic methods
 void		CcdPhysicsController::RelativeTranslate(float dlocX,float dlocY,float dlocZ,bool local)
 {
+	SimdVector3 dloc(dlocX,dlocY,dlocZ);
 	SimdTransform xform = m_body->getCenterOfMassTransform();
-	xform.setOrigin(xform.getOrigin() + SimdVector3(dlocX,dlocY,dlocZ));
+
+	if (local)
+	{
+		dloc = xform.getBasis()*dloc;
+	}
+
+	xform.setOrigin(xform.getOrigin() + dloc);
 	this->m_body->setCenterOfMassTransform(xform);
 
 }
@@ -159,7 +213,11 @@ void CcdPhysicsController::GetWorldOrientation(SimdMatrix3x3& mat)
 
 void		CcdPhysicsController::getOrientation(float &quatImag0,float &quatImag1,float &quatImag2,float &quatReal)
 {
-
+	SimdQuaternion q = m_body->getCenterOfMassTransform().getRotation();
+	quatImag0 = q[0];
+	quatImag1 = q[1];
+	quatImag2 = q[2];
+	quatReal = q[3];
 }
 void		CcdPhysicsController::setOrientation(float quatImag0,float quatImag1,float quatImag2,float quatReal)
 {
@@ -186,31 +244,71 @@ void		CcdPhysicsController::resolveCombinedVelocities(float linvelX,float linvel
 
 void 		CcdPhysicsController::getPosition(PHY__Vector3&	pos) const
 {
-	assert(0);
+	const SimdTransform& xform = m_body->getCenterOfMassTransform();
+	pos[0] = xform.getOrigin().x();
+	pos[1] = xform.getOrigin().y();
+	pos[2] = xform.getOrigin().z();
 }
 
 void		CcdPhysicsController::setScaling(float scaleX,float scaleY,float scaleZ)
 {
+	if (!SimdFuzzyZero(m_cci.m_scaling.x()-scaleX) ||
+		!SimdFuzzyZero(m_cci.m_scaling.y()-scaleY) ||
+		!SimdFuzzyZero(m_cci.m_scaling.z()-scaleZ))
+	{
+		m_cci.m_scaling = SimdVector3(scaleX,scaleY,scaleZ);
+
+		if (m_body && m_body->GetCollisionShape())
+		{
+			m_body->GetCollisionShape()->setLocalScaling(m_cci.m_scaling);
+			m_body->GetCollisionShape()->CalculateLocalInertia(m_cci.m_mass, m_cci.m_localInertiaTensor);
+			m_body->setMassProps(m_cci.m_mass, m_cci.m_localInertiaTensor * m_cci.m_inertiaFactor);
+		}
+	}
 }
 		
 		// physics methods
 void		CcdPhysicsController::ApplyTorque(float torqueX,float torqueY,float torqueZ,bool local)
 {
+	SimdVector3 torque(torqueX,torqueY,torqueZ);
+	SimdTransform xform = m_body->getCenterOfMassTransform();
+	if (local)
+	{
+		torque	= xform.getBasis()*torque;
+	}
+	m_body->applyTorque(torque);
 }
+
 void		CcdPhysicsController::ApplyForce(float forceX,float forceY,float forceZ,bool local)
 {
+	SimdVector3 force(forceX,forceY,forceZ);
+	SimdTransform xform = m_body->getCenterOfMassTransform();
+	if (local)
+	{
+		force	= xform.getBasis()*force;
+	}
+	m_body->applyCentralForce(force);
 }
 void		CcdPhysicsController::SetAngularVelocity(float ang_velX,float ang_velY,float ang_velZ,bool local)
 {
 	SimdVector3 angvel(ang_velX,ang_velY,ang_velZ);
+	SimdTransform xform = m_body->getCenterOfMassTransform();
+	if (local)
+	{
+		angvel	= xform.getBasis()*angvel;
+	}
 
 	m_body->setAngularVelocity(angvel);
 
 }
 void		CcdPhysicsController::SetLinearVelocity(float lin_velX,float lin_velY,float lin_velZ,bool local)
 {
-
 	SimdVector3 linVel(lin_velX,lin_velY,lin_velZ);
+	SimdTransform xform = m_body->getCenterOfMassTransform();
+	if (local)
+	{
+		linVel	= xform.getBasis()*linVel;
+	}
 	m_body->setLinearVelocity(linVel);
 }
 void		CcdPhysicsController::applyImpulse(float attachX,float attachY,float attachZ, float impulseX,float impulseY,float impulseZ)
@@ -230,9 +328,29 @@ void		CcdPhysicsController::SetActive(bool active)
 		// reading out information from physics
 void		CcdPhysicsController::GetLinearVelocity(float& linvX,float& linvY,float& linvZ)
 {
+	const SimdVector3& linvel = this->m_body->getLinearVelocity();
+	linvX = linvel.x();
+	linvY = linvel.y();
+	linvZ = linvel.z();
+
 }
+
+void		CcdPhysicsController::GetAngularVelocity(float& angVelX,float& angVelY,float& angVelZ)
+{
+	const SimdVector3& angvel= m_body->getAngularVelocity();
+	angVelX = angvel.x();
+	angVelY = angvel.y();
+	angVelZ = angvel.z();
+}
+
 void		CcdPhysicsController::GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ)
 {
+	SimdVector3 pos(posX,posY,posZ);
+	SimdVector3 rel_pos = pos-m_body->getCenterOfMassPosition();
+	SimdVector3 linvel = m_body->getVelocityInLocalPoint(rel_pos);
+	linvX = linvel.x();
+	linvY = linvel.y();
+	linvZ = linvel.z();
 }
 void		CcdPhysicsController::getReactionForce(float& forceX,float& forceY,float& forceZ)
 {
@@ -278,8 +396,8 @@ bool CcdPhysicsController::wantsSleeping()
 	//disable deactivation
 	if (gDisableDeactivation || (gDeactivationTime == 0.f))
 		return false;
-	//2 == ISLAND_SLEEPING, 3 == WANTS_DEACTIVATION
-	if ( (m_body->GetActivationState() == 2) || (m_body->GetActivationState() == 3))
+
+	if ( (m_body->GetActivationState() == ISLAND_SLEEPING) || (m_body->GetActivationState() == WANTS_DEACTIVATION))
 		return true;
 
 	if (m_body->m_deactivationTime> gDeactivationTime)
diff --git a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.h b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.h
index 478e0e66a39..04d34fb1200 100644
--- a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.h
+++ b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsController.h
@@ -9,13 +9,18 @@
 #include "SimdVector3.h"
 #include "SimdScalar.h"	
 #include "SimdMatrix3x3.h"
+#include "SimdTransform.h"
+#include "Dynamics/RigidBody.h"
 
+
+#include "BroadphaseCollision/BroadphaseProxy.h" //for CollisionShape access
 class CollisionShape;
 
 extern float gDeactivationTime;
 extern float gLinearSleepingTreshold;
 extern float gAngularSleepingTreshold;
 extern bool gDisableDeactivation;
+class CcdPhysicsEnvironment;
 
 
 struct CcdConstructionInfo
@@ -27,22 +32,26 @@ struct CcdConstructionInfo
 		m_linearDamping(0.1f),
 		m_angularDamping(0.1f),
 		m_MotionState(0),
-		m_collisionShape(0)
-
+		m_physicsEnv(0),
+		m_inertiaFactor(1.f),
+		m_scaling(1.f,1.f,1.f)
 	{
 	}
+
 	SimdVector3	m_localInertiaTensor;
 	SimdVector3	m_gravity;
+	SimdVector3	m_scaling;
 	SimdScalar	m_mass;
 	SimdScalar	m_restitution;
 	SimdScalar	m_friction;
 	SimdScalar	m_linearDamping;
 	SimdScalar	m_angularDamping;
-	void*		m_broadphaseHandle;
-	class	PHY_IMotionState*			m_MotionState;
 
 	CollisionShape*			m_collisionShape;
-	
+	class	PHY_IMotionState*			m_MotionState;
+
+	CcdPhysicsEnvironment*	m_physicsEnv; //needed for self-replication
+	float	m_inertiaFactor;//tweak the inertia (hooked up to Blender 'formfactor'
 };
 
 
@@ -53,15 +62,19 @@ class CcdPhysicsController : public PHY_IPhysicsController
 {
 	RigidBody* m_body;
 	class	PHY_IMotionState*			m_MotionState;
+	
+
 	void*		m_newClientInfo;
 
+	CcdConstructionInfo	m_cci;//needed for replication
 	void GetWorldOrientation(SimdMatrix3x3& mat);
 
+	void CreateRigidbody();
+
 	public:
 	
 		int				m_collisionDelay;
 	
-		void*  m_broadphaseHandle;
 
 		CcdPhysicsController (const CcdConstructionInfo& ci);
 
@@ -70,7 +83,9 @@ class CcdPhysicsController : public PHY_IPhysicsController
 
 		RigidBody* GetRigidBody() { return m_body;}
 
-		CollisionShape*	GetCollisionShape();
+		CollisionShape*	GetCollisionShape() { 
+			return m_body->GetCollisionShape();
+		}
 		////////////////////////////////////
 		// PHY_IPhysicsController interface
 		////////////////////////////////////
@@ -109,6 +124,7 @@ class CcdPhysicsController : public PHY_IPhysicsController
 
 		// reading out information from physics
 		virtual void		GetLinearVelocity(float& linvX,float& linvY,float& linvZ);
+		virtual void		GetAngularVelocity(float& angVelX,float& angVelY,float& angVelZ);
 		virtual void		GetVelocity(const float posX,const float posY,const float posZ,float& linvX,float& linvY,float& linvZ); 
 		virtual	void		getReactionForce(float& forceX,float& forceY,float& forceZ);
 
@@ -132,6 +148,8 @@ class CcdPhysicsController : public PHY_IPhysicsController
 
 		void	UpdateDeactivation(float timeStep);
 
+		static SimdTransform	GetTransformFromMotionState(PHY_IMotionState* motionState);
+
 		void	SetAabb(const SimdVector3& aabbMin,const SimdVector3& aabbMax);
 
 
diff --git a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.cpp b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.cpp
index 558f294344a..2e464e9114c 100644
--- a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.cpp
+++ b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.cpp
@@ -6,9 +6,10 @@
 #include "Dynamics/RigidBody.h"
 #include "BroadphaseCollision/BroadphaseInterface.h"
 #include "BroadphaseCollision/SimpleBroadphase.h"
+#include "CollisionDispatch/CollisionWorld.h"
 
 #include "CollisionShapes/ConvexShape.h"
-#include "BroadphaseCollision/CollisionDispatcher.h"
+#include "BroadphaseCollision/Dispatcher.h"
 #include "NarrowPhaseCollision/PersistentManifold.h"
 #include "CollisionShapes/TriangleMeshShape.h"
 #include "ConstraintSolver/OdeConstraintSolver.h"
@@ -17,10 +18,12 @@
 #include "IDebugDraw.h"
 
 #include "NarrowPhaseCollision/VoronoiSimplexSolver.h"
-#include "NarrowPhaseCollision/SubsimplexConvexCast.h"
+#include "NarrowPhaseCollision/SubSimplexConvexCast.h"
+#include "NarrowPhaseCollision/GjkConvexCast.h"
 
-#include "CollisionDispatch/ToiContactDispatcher.h"
 
+#include "CollisionDispatch/CollisionDispatcher.h"
+#include "PHY_IMotionState.h"
 
 #include "CollisionDispatch/EmptyCollisionAlgorithm.h"
 #include "CollisionDispatch/UnionFind.h"
@@ -30,6 +33,17 @@
 
 bool useIslands = true;
 
+#ifdef NEW_BULLET_VEHICLE_SUPPORT
+#include "Vehicle/RaycastVehicle.h"
+#include "Vehicle/VehicleRaycaster.h"
+#include "Vehicle/VehicleTuning.h"
+#include "Vehicle/WheelInfo.h"
+#include "PHY_IVehicle.h"
+VehicleTuning	gTuning;
+
+#endif //NEW_BULLET_VEHICLE_SUPPORT
+#include "AabbUtil2.h"
+
 #include "ConstraintSolver/ConstraintSolver.h"
 #include "ConstraintSolver/Point2PointConstraint.h"
 //#include "BroadphaseCollision/QueryDispatcher.h"
@@ -44,9 +58,146 @@ void DrawRasterizerLine(const float* from,const float* to,int color);
 #include "ConstraintSolver/ContactConstraint.h"
 
 
-
 #include <stdio.h>
 
+#ifdef NEW_BULLET_VEHICLE_SUPPORT
+class WrapperVehicle : public PHY_IVehicle
+{
+
+	RaycastVehicle*	m_vehicle;
+	PHY_IPhysicsController*	m_chassis;
+		
+public:
+
+	WrapperVehicle(RaycastVehicle* vehicle,PHY_IPhysicsController* chassis)
+		:m_vehicle(vehicle),
+		m_chassis(chassis)
+	{
+	}
+
+	RaycastVehicle*	GetVehicle()
+	{
+		return m_vehicle;
+	}
+
+	PHY_IPhysicsController*	GetChassis()
+	{
+		return m_chassis;
+	}
+
+	virtual void	AddWheel(
+			PHY_IMotionState*	motionState,
+			PHY__Vector3	connectionPoint,
+			PHY__Vector3	downDirection,
+			PHY__Vector3	axleDirection,
+			float	suspensionRestLength,
+			float wheelRadius,
+			bool hasSteering
+		)
+	{
+		SimdVector3 connectionPointCS0(connectionPoint[0],connectionPoint[1],connectionPoint[2]);
+		SimdVector3 wheelDirectionCS0(downDirection[0],downDirection[1],downDirection[2]);
+		SimdVector3 wheelAxle(axleDirection[0],axleDirection[1],axleDirection[2]);
+		
+
+		WheelInfo& info = m_vehicle->AddWheel(connectionPointCS0,wheelDirectionCS0,wheelAxle,
+			suspensionRestLength,wheelRadius,gTuning,hasSteering);
+		info.m_clientInfo = motionState;
+		
+	}
+
+	void	SyncWheels()
+	{
+		int numWheels = GetNumWheels();
+		int i;
+		for (i=0;i<numWheels;i++)
+		{
+			WheelInfo& info = m_vehicle->GetWheelInfo(i);
+			PHY_IMotionState* motionState = (PHY_IMotionState*)info.m_clientInfo ;
+			SimdTransform trans = m_vehicle->GetWheelTransformWS(i);
+			SimdQuaternion orn = trans.getRotation();
+			const SimdVector3& pos = trans.getOrigin();
+			motionState->setWorldOrientation(orn.x(),orn.y(),orn.z(),orn[3]);
+			motionState->setWorldPosition(pos.x(),pos.y(),pos.z());
+
+		}
+	}
+
+	virtual	int		GetNumWheels() const
+	{
+		return m_vehicle->GetNumWheels();
+	}
+	
+	virtual void	GetWheelPosition(int wheelIndex,float& posX,float& posY,float& posZ) const
+	{
+		SimdTransform	trans = m_vehicle->GetWheelTransformWS(wheelIndex);
+		posX = trans.getOrigin().x();
+		posY = trans.getOrigin().y();
+		posZ = trans.getOrigin().z();
+	}
+	virtual void	GetWheelOrientationQuaternion(int wheelIndex,float& quatX,float& quatY,float& quatZ,float& quatW) const
+	{
+		SimdTransform	trans = m_vehicle->GetWheelTransformWS(wheelIndex);
+		SimdQuaternion quat = trans.getRotation();
+		SimdMatrix3x3 orn2(quat);
+
+		quatX = trans.getRotation().x();
+		quatY = trans.getRotation().y();
+		quatZ = trans.getRotation().z();
+		quatW = trans.getRotation()[3];
+		
+
+		//printf("test");
+
+
+	}
+
+	virtual float	GetWheelRotation(int wheelIndex) const
+	{
+		float rotation = 0.f;
+
+		if ((wheelIndex>=0) && (wheelIndex< m_vehicle->GetNumWheels()))
+		{
+			WheelInfo& info = m_vehicle->GetWheelInfo(wheelIndex);
+			rotation = info.m_rotation;
+		}
+		return rotation;
+
+	}
+
+
+	
+	virtual int	GetUserConstraintId() const
+	{
+		return m_vehicle->GetUserConstraintId();
+	}
+
+	virtual int	GetUserConstraintType() const
+	{
+		return m_vehicle->GetUserConstraintType();
+	}
+
+	virtual	void	SetSteeringValue(float steering,int wheelIndex)
+	{
+		m_vehicle->SetSteeringValue(steering,wheelIndex);
+	}
+
+	virtual	void	ApplyEngineForce(float force,int wheelIndex)
+	{
+		m_vehicle->ApplyEngineForce(force,wheelIndex);
+	}
+
+	virtual	void	ApplyBraking(float braking,int wheelIndex)
+	{
+		if ((wheelIndex>=0) && (wheelIndex< m_vehicle->GetNumWheels()))
+		{
+			WheelInfo& info = m_vehicle->GetWheelInfo(wheelIndex);
+			info.m_brake = braking;
+		}
+	}
+
+};
+#endif //NEW_BULLET_VEHICLE_SUPPORT
 
 
 
@@ -86,24 +237,23 @@ static void DrawAabb(IDebugDraw* debugDrawer,const SimdVector3& from,const SimdV
 
 
 
-CcdPhysicsEnvironment::CcdPhysicsEnvironment(ToiContactDispatcher* dispatcher,BroadphaseInterface* bp)
-:m_dispatcher(dispatcher),
-m_broadphase(bp),
-m_scalingPropagated(false),
+CcdPhysicsEnvironment::CcdPhysicsEnvironment(CollisionDispatcher* dispatcher,BroadphaseInterface* broadphase)
+:m_scalingPropagated(false),
 m_numIterations(30),
 m_ccdMode(0),
 m_solverType(-1)
 {
 
-	if (!m_dispatcher)
-	{
-		setSolverType(0);
-	}
+	if (!dispatcher)
+		dispatcher = new CollisionDispatcher();
 
-	if (!m_broadphase)
-	{
-		m_broadphase = new SimpleBroadphase();
-	}
+	
+	if(!broadphase)
+		broadphase = new SimpleBroadphase();
+		
+	setSolverType(0);
+	
+	m_collisionWorld = new CollisionWorld(dispatcher,broadphase);
 	
 	m_debugDrawer = 0;
 	m_gravity = SimdVector3(0.f,-10.f,0.f);
@@ -113,19 +263,24 @@ m_solverType(-1)
 
 void	CcdPhysicsEnvironment::addCcdPhysicsController(CcdPhysicsController* ctrl)
 {
-	ctrl->GetRigidBody()->setGravity( m_gravity );
+	RigidBody* body = ctrl->GetRigidBody();
+
+	body->setGravity( m_gravity );
 	m_controllers.push_back(ctrl);
 	
-	BroadphaseInterface* scene =  m_broadphase;
-	
+	m_collisionWorld->AddCollisionObject(body);
+
+	assert(body->m_broadphaseHandle);
 
+	BroadphaseInterface* scene =  GetBroadphase();
+
+	
 	CollisionShape* shapeinterface = ctrl->GetCollisionShape();
 	
 	assert(shapeinterface);
 	
 	const SimdTransform& t = ctrl->GetRigidBody()->getCenterOfMassTransform();
 	
-	RigidBody* body = ctrl->GetRigidBody();
 	
 	SimdPoint3 minAabb,maxAabb;
 	
@@ -162,17 +317,6 @@ void	CcdPhysicsEnvironment::addCcdPhysicsController(CcdPhysicsController* ctrl)
 	minAabb = SimdVector3(minAabbx,minAabby,minAabbz);
 	maxAabb = SimdVector3(maxAabbx,maxAabby,maxAabbz);
 	
-	if (!ctrl->m_broadphaseHandle)
-	{
-		int type = shapeinterface->GetShapeType();
-		ctrl->m_broadphaseHandle = scene->CreateProxy(
-			ctrl->GetRigidBody(),
-			type,
-			minAabb, 
-			maxAabb);
-	}
-	
-	
 	
 	
 	
@@ -193,7 +337,7 @@ void	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
 			if  ((&p2p->GetRigidBodyA() == ctrl->GetRigidBody() ||
 				(&p2p->GetRigidBodyB() == ctrl->GetRigidBody())))
 			{
-				removeConstraint(int(p2p));
+				 removeConstraint(p2p->GetUserConstraintId());
 				//only 1 constraint per constroller
 				break;
 			}
@@ -210,7 +354,7 @@ void	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
 			if  ((&p2p->GetRigidBodyA() == ctrl->GetRigidBody() ||
 				(&p2p->GetRigidBodyB() == ctrl->GetRigidBody())))
 			{
-				removeConstraint(int(p2p));
+				removeConstraint(p2p->GetUserConstraintId());
 				//only 1 constraint per constroller
 				break;
 			}
@@ -218,21 +362,9 @@ void	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
 	}
 	
 	
+	m_collisionWorld->RemoveCollisionObject(ctrl->GetRigidBody());
+
 	
-	bool removeFromBroadphase = false;
-	
-	{
-		BroadphaseInterface* scene = m_broadphase;
-		BroadphaseProxy* bp = (BroadphaseProxy*)ctrl->m_broadphaseHandle;
-		
-		if (removeFromBroadphase)
-		{
-		}
-		//
-		// only clear the cached algorithms
-		//
-		scene->CleanProxyFromPairs(bp);
-	}
 	{
 		std::vector<CcdPhysicsController*>::iterator i =
 			std::find(m_controllers.begin(), m_controllers.end(), ctrl);
@@ -244,67 +376,34 @@ void	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
 	}
 }
 
-void	CcdPhysicsEnvironment::UpdateActivationState()
+
+void	CcdPhysicsEnvironment::beginFrame()
 {
-	m_dispatcher->InitUnionFind();
-	
-	// put the index into m_controllers into m_tag	
+
+}
+
+bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
+{
+
+	if (!SimdFuzzyZero(timeStep))
 	{
-		std::vector<CcdPhysicsController*>::iterator i;
-		
-		int index = 0;
-		for (i=m_controllers.begin();
-		!(i==m_controllers.end()); i++)
-		{
-			CcdPhysicsController* ctrl = (*i);
-			RigidBody* body = ctrl->GetRigidBody();
-			body->m_islandTag1 = index;
-			body->m_hitFraction = 1.f;
-			index++;
-			
-		}
-	}
-	// do the union find
-	
-	m_dispatcher->FindUnions();
-	
-	// put the islandId ('find' value) into m_tag	
+		//Blender runs 30hertz, so subdivide so we get 60 hertz
+		proceedDeltaTimeOneStep(0.5f*timeStep);
+		proceedDeltaTimeOneStep(0.5f*timeStep);
+	} else
 	{
-		UnionFind& unionFind = m_dispatcher->GetUnionFind();
-		
-		std::vector<CcdPhysicsController*>::iterator i;
-		
-		int index = 0;
-		for (i=m_controllers.begin();
-		!(i==m_controllers.end()); i++)
-		{
-			CcdPhysicsController* ctrl = (*i);
-			RigidBody* body = ctrl->GetRigidBody();
-			
-			
-			if (body->mergesSimulationIslands())
-			{
-				body->m_islandTag1 = unionFind.find(index);
-			} else
-			{
-				body->m_islandTag1 = -1;
-			}
-			index++;
-		}
+		//todo: interpolate
 	}
-	
+	return true;
 }
-
-
-
 /// Perform an integration step of duration 'timeStep'.
-bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
+bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 {
 	
 	
 //	printf("CcdPhysicsEnvironment::proceedDeltaTime\n");
 	
-	if (timeStep == 0.f)
+	if (SimdFuzzyZero(timeStep))
 		return true;
 
 	if (m_debugDrawer)
@@ -314,15 +413,12 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 
 
 
-	//clamp hardcoded for now
-	if (timeStep > 0.02)
-		timeStep = 0.02;
 	
 	//this is needed because scaling is not known in advance, and scaling has to propagate to the shape
 	if (!m_scalingPropagated)
 	{
-		//SyncMotionStates(timeStep);
-		//m_scalingPropagated = true;
+		SyncMotionStates(timeStep);
+		m_scalingPropagated = true;
 	}
 
 
@@ -346,7 +442,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 			
 		}
 	}
-	BroadphaseInterface*	scene = m_broadphase;
+	BroadphaseInterface*	scene = GetBroadphase();
 	
 	
 	//
@@ -364,7 +460,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 	dispatchInfo.m_timeStep = timeStep;
 	dispatchInfo.m_stepCount = 0;
 
-	scene->DispatchAllCollisionPairs(*m_dispatcher,dispatchInfo);///numsubstep,g);
+	scene->DispatchAllCollisionPairs(*GetDispatcher(),dispatchInfo);///numsubstep,g);
 
 
 
@@ -373,12 +469,49 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 	
 	int numRigidBodies = m_controllers.size();
 	
-	UpdateActivationState();
+	m_collisionWorld->UpdateActivationState();
 
 	//contacts
 
 	
-	m_dispatcher->SolveConstraints(timeStep, m_numIterations ,numRigidBodies,m_debugDrawer);
+	struct InplaceSolverIslandCallback : public CollisionDispatcher::IslandCallback
+	{
+
+		ContactSolverInfo& m_solverInfo;
+		ConstraintSolver*	m_solver;
+		IDebugDraw*	m_debugDrawer;
+		
+		InplaceSolverIslandCallback(
+			ContactSolverInfo& solverInfo,
+			ConstraintSolver*	solver,
+			IDebugDraw*	debugDrawer)
+			:m_solverInfo(solverInfo),
+			m_solver(solver),
+			m_debugDrawer(debugDrawer)
+		{
+			
+		}
+		
+		virtual	void	ProcessIsland(PersistentManifold**	manifolds,int numManifolds)
+		{
+			m_solver->SolveGroup( manifolds, numManifolds,m_solverInfo,m_debugDrawer);
+		}
+		
+	};
+
+
+	m_solverInfo.m_friction = 0.9f;
+	m_solverInfo.m_numIterations = m_numIterations;
+	m_solverInfo.m_timeStep = timeStep;
+	m_solverInfo.m_restitution = 0.f;//m_restitution;
+
+	InplaceSolverIslandCallback	solverCallback(
+			m_solverInfo,
+			m_solver,
+			m_debugDrawer);
+
+	GetDispatcher()->BuildAndProcessIslands(numRigidBodies,&solverCallback);
+
 
 	for (int g=0;g<numsubstep;g++)
 	{
@@ -399,20 +532,27 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 			p2p->SolveConstraint( timeStep );
 			
 		}
-		/*
-		//vehicles
-		int numVehicles = m_vehicles.size();
-		for (i=0;i<numVehicles;i++)
-		{
-			Vehicle* vehicle = m_vehicles[i];
-			vehicle->UpdateVehicle( timeStep );
-		}
-		*/
-		
+
+
 		
 		
 	}
 	
+
+	#ifdef NEW_BULLET_VEHICLE_SUPPORT
+		//vehicles
+		int numVehicles = m_wrapperVehicles.size();
+		for (int i=0;i<numVehicles;i++)
+		{
+			WrapperVehicle* wrapperVehicle = m_wrapperVehicles[i];
+			RaycastVehicle* vehicle = wrapperVehicle->GetVehicle();
+			vehicle->UpdateVehicle( timeStep);
+		}
+#endif //NEW_BULLET_VEHICLE_SUPPORT
+
+		
+
+
 	{
 		
 		
@@ -447,7 +587,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 				minAabb -= manifoldExtraExtents;
 				maxAabb += manifoldExtraExtents;
 				
-				BroadphaseProxy* bp = (BroadphaseProxy*) ctrl->m_broadphaseHandle;
+				BroadphaseProxy* bp = body->m_broadphaseHandle;
 				if (bp)
 				{
 					
@@ -501,7 +641,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 				dispatchInfo.m_stepCount = 0;
 				dispatchInfo.m_dispatchFunc = DispatcherInfo::DISPATCH_CONTINUOUS;
 				
-				scene->DispatchAllCollisionPairs( *m_dispatcher,dispatchInfo);///numsubstep,g);
+				scene->DispatchAllCollisionPairs( *GetDispatcher(),dispatchInfo);///numsubstep,g);
 				toi = dispatchInfo.m_timeOfImpact;
 			}
 			
@@ -578,8 +718,26 @@ bool	CcdPhysicsEnvironment::proceedDeltaTime(double curTime,float timeStep)
 			
 	}
 	
+
+
 	SyncMotionStates(timeStep);
 
+	
+#ifdef NEW_BULLET_VEHICLE_SUPPORT
+		//sync wheels for vehicles
+		int numVehicles = m_wrapperVehicles.size();
+		for (int i=0;i<numVehicles;i++)
+		{
+			WrapperVehicle* wrapperVehicle = m_wrapperVehicles[i];
+			
+			for (int j=0;j<wrapperVehicle->GetVehicle()->GetNumWheels();j++)
+			{
+				wrapperVehicle->GetVehicle()->UpdateWheelTransform(j);
+			}
+			
+			wrapperVehicle->SyncWheels();
+		}
+#endif //NEW_BULLET_VEHICLE_SUPPORT
 	}
 	return true;
 }
@@ -622,16 +780,16 @@ void		CcdPhysicsEnvironment::setCcdMode(int ccdMode)
 
 void		CcdPhysicsEnvironment::setSolverSorConstant(float sor)
 {
-	m_dispatcher->SetSor(sor);
+	m_solverInfo.m_sor = sor;
 }
 
 void		CcdPhysicsEnvironment::setSolverTau(float tau)
 {
-	m_dispatcher->SetTau(tau);
+	m_solverInfo.m_tau = tau;
 }
 void		CcdPhysicsEnvironment::setSolverDamping(float damping)
 {
-	m_dispatcher->SetDamping(damping);
+	m_solverInfo.m_damping = damping;
 }
 
 
@@ -654,11 +812,9 @@ void		CcdPhysicsEnvironment::setSolverType(int solverType)
 		{
 			if (m_solverType != solverType)
 			{
-				if (m_dispatcher)
-					delete m_dispatcher;
-
-				SimpleConstraintSolver* solver= new SimpleConstraintSolver();
-				m_dispatcher = new ToiContactDispatcher(solver);
+				
+				m_solver = new SimpleConstraintSolver();
+				
 				break;
 			}
 		}
@@ -667,11 +823,8 @@ void		CcdPhysicsEnvironment::setSolverType(int solverType)
 	default:
 			if (m_solverType != solverType)
 			{
-				if (m_dispatcher)
-					delete m_dispatcher;
-
-				OdeConstraintSolver* solver= new OdeConstraintSolver();
-				m_dispatcher = new ToiContactDispatcher(solver);
+				m_solver = new OdeConstraintSolver();
+		
 				break;
 			}
 
@@ -719,6 +872,53 @@ void		CcdPhysicsEnvironment::setGravity(float x,float y,float z)
 }
 
 
+#ifdef NEW_BULLET_VEHICLE_SUPPORT
+
+class BlenderVehicleRaycaster : public VehicleRaycaster
+{
+	CcdPhysicsEnvironment* m_physEnv;
+	PHY_IPhysicsController*	m_chassis;
+
+public:
+	BlenderVehicleRaycaster(CcdPhysicsEnvironment* physEnv,PHY_IPhysicsController* chassis):
+	m_physEnv(physEnv),
+		m_chassis(chassis)
+	{
+	}
+
+	
+	virtual void* CastRay(const SimdVector3& from,const SimdVector3& to, VehicleRaycasterResult& result)
+	{
+		
+		
+		float hit[3];
+		float normal[3];
+
+		PHY_IPhysicsController*	ignore = m_chassis;
+		void* hitObject = m_physEnv->rayTest(ignore,from.x(),from.y(),from.z(),to.x(),to.y(),to.z(),hit[0],hit[1],hit[2],normal[0],normal[1],normal[2]);
+		if (hitObject)
+		{
+			result.m_hitPointInWorld[0] = hit[0];
+			result.m_hitPointInWorld[1] = hit[1];
+			result.m_hitPointInWorld[2] = hit[2];
+			result.m_hitNormalInWorld[0] = normal[0];
+			result.m_hitNormalInWorld[1] = normal[1];
+			result.m_hitNormalInWorld[2] = normal[2];
+			result.m_hitNormalInWorld.normalize();
+			//calc fraction? or put it in the interface?
+			//calc for now
+			
+			result.m_distFraction = (result.m_hitPointInWorld-from).length() / (to-from).length();
+			
+		}
+		//?
+		return hitObject;
+	}
+};
+#endif //NEW_BULLET_VEHICLE_SUPPORT
+
+static int gConstraintUid = 1;
+
 int			CcdPhysicsEnvironment::createConstraint(class PHY_IPhysicsController* ctrl0,class PHY_IPhysicsController* ctrl1,PHY_ConstraintType type,
 														float pivotX,float pivotY,float pivotZ,
 														float axisX,float axisY,float axisZ)
@@ -754,10 +954,31 @@ int			CcdPhysicsEnvironment::createConstraint(class PHY_IPhysicsController* ctrl
 			}
 			
 			m_p2pConstraints.push_back(p2p);
-			return 0;
+			p2p->SetUserConstraintId(gConstraintUid++);
+			p2p->SetUserConstraintType(type);
+			//64 bit systems can't cast pointer to int. could use size_t instead.
+			return p2p->GetUserConstraintId();
 			
 			break;
 		}
+#ifdef NEW_BULLET_VEHICLE_SUPPORT
+
+	case PHY_VEHICLE_CONSTRAINT:
+		{
+			VehicleTuning* tuning = new VehicleTuning();
+			RigidBody* chassis = rb0;
+			BlenderVehicleRaycaster* raycaster = new BlenderVehicleRaycaster(this,ctrl0);
+			RaycastVehicle* vehicle = new RaycastVehicle(*tuning,chassis,raycaster);
+			WrapperVehicle* wrapperVehicle = new WrapperVehicle(vehicle,ctrl0);
+			m_wrapperVehicles.push_back(wrapperVehicle);
+			vehicle->SetUserConstraintId(gConstraintUid++);
+			vehicle->SetUserConstraintType(type);
+			return vehicle->GetUserConstraintId();
+
+			break;
+		};
+#endif //NEW_BULLET_VEHICLE_SUPPORT
+
 	default:
 		{
 		}
@@ -769,19 +990,24 @@ int			CcdPhysicsEnvironment::createConstraint(class PHY_IPhysicsController* ctrl
 	
 }
 
-void		CcdPhysicsEnvironment::removeConstraint(int constraintid)
+void		CcdPhysicsEnvironment::removeConstraint(int	constraintId)
 {
+	std::vector<Point2PointConstraint*>::iterator i;
+		
+		//std::find(m_p2pConstraints.begin(), m_p2pConstraints.end(), 
+		//		(Point2PointConstraint *)p2p);
 	
-	Point2PointConstraint* p2p = (Point2PointConstraint*) constraintid;
-	
-	std::vector<Point2PointConstraint*>::iterator i =
-		std::find(m_p2pConstraints.begin(), m_p2pConstraints.end(), p2p);
-	
-	if (!(i == m_p2pConstraints.end()) )
-	{
-		std::swap(*i, m_p2pConstraints.back());
-		m_p2pConstraints.pop_back();
-	}
+		for (i=m_p2pConstraints.begin();
+		!(i==m_p2pConstraints.end()); i++)
+		{
+			Point2PointConstraint* p2p = (*i);
+			if (p2p->GetUserConstraintId() == constraintId)
+			{
+				std::swap(*i, m_p2pConstraints.back());
+				m_p2pConstraints.pop_back();
+				break;
+			}
+		}
 	
 }
 PHY_IPhysicsController* CcdPhysicsEnvironment::rayTest(PHY_IPhysicsController* ignoreClient, float fromX,float fromY,float fromZ, float toX,float toY,float toZ, 
@@ -792,11 +1018,21 @@ PHY_IPhysicsController* CcdPhysicsEnvironment::rayTest(PHY_IPhysicsController* i
 
 	SimdTransform	rayFromTrans,rayToTrans;
 	rayFromTrans.setIdentity();
-	rayFromTrans.setOrigin(SimdVector3(fromX,fromY,fromZ));
+
+	SimdVector3 rayFrom(fromX,fromY,fromZ);
+
+	rayFromTrans.setOrigin(rayFrom);
 	rayToTrans.setIdentity();
-	rayToTrans.setOrigin(SimdVector3(toX,toY,toZ));
+	SimdVector3 rayTo(toX,toY,toZ);
+	rayToTrans.setOrigin(rayTo);
 
+	//do culling based on aabb (rayFrom/rayTo)
+	SimdVector3 rayAabbMin = rayFrom;
+	SimdVector3 rayAabbMax = rayFrom;
+	rayAabbMin.setMin(rayTo);
+	rayAabbMax.setMax(rayTo);
 
+	
 	CcdPhysicsController* nearestHit = 0;
 	
 	std::vector<CcdPhysicsController*>::iterator i;
@@ -808,71 +1044,91 @@ PHY_IPhysicsController* CcdPhysicsEnvironment::rayTest(PHY_IPhysicsController* i
 	!(i==m_controllers.end()); i++)
 	{
 		CcdPhysicsController* ctrl = (*i);
+		if (ctrl == ignoreClient)
+			continue;
 		RigidBody* body = ctrl->GetRigidBody();
+		SimdVector3 bodyAabbMin,bodyAabbMax;
+		body->getAabb(bodyAabbMin,bodyAabbMax);
 
-		if (body->GetCollisionShape()->IsConvex())
-		{
-			ConvexCast::CastResult rayResult;
-			rayResult.m_fraction = 1.f;
+		//check aabb overlap
 
-			ConvexShape* convexShape = (ConvexShape*) body->GetCollisionShape();
-			VoronoiSimplexSolver	simplexSolver;
-			SubsimplexConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
-			
-			if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,body->getCenterOfMassTransform(),body->getCenterOfMassTransform(),rayResult))
+		if (TestAabbAgainstAabb2(rayAabbMin,rayAabbMax,bodyAabbMin,bodyAabbMax))
+		{
+			if (body->GetCollisionShape()->IsConvex())
 			{
-				//add hit
-				rayResult.m_normal.normalize();
-				if (rayResult.m_fraction < minFraction)
+				ConvexCast::CastResult rayResult;
+				rayResult.m_fraction = 1.f;
+
+				ConvexShape* convexShape = (ConvexShape*) body->GetCollisionShape();
+				VoronoiSimplexSolver	simplexSolver;
+				SubsimplexConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
+				//GjkConvexCast	convexCaster(&pointShape,convexShape,&simplexSolver);
+				
+				if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,body->getCenterOfMassTransform(),body->getCenterOfMassTransform(),rayResult))
 				{
+					//add hit
+					if (rayResult.m_normal.length2() > 0.0001f)
+					{
+						rayResult.m_normal.normalize();
+						if (rayResult.m_fraction < minFraction)
+						{
+
 
+							minFraction = rayResult.m_fraction;
+							nearestHit = ctrl;
+							normalX = rayResult.m_normal.getX();
+							normalY = rayResult.m_normal.getY();
+							normalZ = rayResult.m_normal.getZ();
+							SimdVector3 hitWorld;
+							hitWorld.setInterpolate3(rayFromTrans.getOrigin(),rayToTrans.getOrigin(),rayResult.m_fraction);
+							hitX = hitWorld.getX();
+							hitY = hitWorld.getY();
+							hitZ = hitWorld.getZ();
 
-					minFraction = rayResult.m_fraction;
-					nearestHit = ctrl;
-					normalX = rayResult.m_normal.getX();
-					normalY = rayResult.m_normal.getY();
-					normalZ = rayResult.m_normal.getZ();
-					hitX = rayResult.m_hitTransformA.getOrigin().getX();
-					hitY = rayResult.m_hitTransformA.getOrigin().getY();
-					hitZ = rayResult.m_hitTransformA.getOrigin().getZ();
+						}
+					}
 				}
 			}
-		}
-		else
-		{
-				if (body->GetCollisionShape()->IsConcave())
-				{
+			else
+			{
+					if (body->GetCollisionShape()->IsConcave())
+					{
 
-					TriangleMeshShape* triangleMesh = (TriangleMeshShape*)body->GetCollisionShape();
-					
-					SimdTransform worldToBody = body->getCenterOfMassTransform().inverse();
+						TriangleMeshShape* triangleMesh = (TriangleMeshShape*)body->GetCollisionShape();
+						
+						SimdTransform worldToBody = body->getCenterOfMassTransform().inverse();
 
-					SimdVector3 rayFromLocal = worldToBody * rayFromTrans.getOrigin();
-					SimdVector3 rayToLocal = worldToBody * rayToTrans.getOrigin();
+						SimdVector3 rayFromLocal = worldToBody * rayFromTrans.getOrigin();
+						SimdVector3 rayToLocal = worldToBody * rayToTrans.getOrigin();
 
-					RaycastCallback	rcb(rayFromLocal,rayToLocal);
-					rcb.m_hitFraction = minFraction;
+						RaycastCallback	rcb(rayFromLocal,rayToLocal);
+						rcb.m_hitFraction = minFraction;
 
-					SimdVector3 aabbMax(1e30f,1e30f,1e30f);
+						SimdVector3 rayAabbMinLocal = rayFromLocal;
+						rayAabbMinLocal.setMin(rayToLocal);
+						SimdVector3 rayAabbMaxLocal = rayFromLocal;
+						rayAabbMaxLocal.setMax(rayToLocal);
 
-					triangleMesh->ProcessAllTriangles(&rcb,-aabbMax,aabbMax);
-					if (rcb.m_hitFound)// && (rcb.m_hitFraction < minFraction))
-					{
-						nearestHit = ctrl;
-						minFraction = rcb.m_hitFraction;
-						SimdVector3 hitNormalWorld = body->getCenterOfMassTransform()(rcb.m_hitNormalLocal);
-
-						normalX = hitNormalWorld.getX();
-						normalY = hitNormalWorld.getY();
-						normalZ = hitNormalWorld.getZ();
-						SimdVector3 hitWorld;
-						hitWorld.setInterpolate3(rayFromTrans.getOrigin(),rayToTrans.getOrigin(),rcb.m_hitFraction);
-						hitX = hitWorld.getX();
-						hitY = hitWorld.getY();
-						hitZ = hitWorld.getZ();
-						
+						triangleMesh->ProcessAllTriangles(&rcb,rayAabbMinLocal,rayAabbMaxLocal);
+						if (rcb.m_hitFound)
+						{
+							nearestHit = ctrl;
+							minFraction = rcb.m_hitFraction;
+							SimdVector3 hitNormalWorld = body->getCenterOfMassTransform().getBasis()*rcb.m_hitNormalLocal;
+							hitNormalWorld.normalize();
+
+							normalX = hitNormalWorld.getX();
+							normalY = hitNormalWorld.getY();
+							normalZ = hitNormalWorld.getZ();
+							SimdVector3 hitWorld;
+							hitWorld.setInterpolate3(rayFromTrans.getOrigin(),rayToTrans.getOrigin(),rcb.m_hitFraction);
+							hitX = hitWorld.getX();
+							hitY = hitWorld.getY();
+							hitZ = hitWorld.getZ();
+							
+						}
 					}
-				}
+			}
 		}
 	}
 
@@ -894,23 +1150,36 @@ void CcdPhysicsEnvironment::getContactPoint(int i,float& hitX,float& hitY,float&
 
 
 
+BroadphaseInterface*	CcdPhysicsEnvironment::GetBroadphase()
+{ 
+	return m_collisionWorld->GetBroadphase(); 
+}
+
 
-Dispatcher* CcdPhysicsEnvironment::GetDispatcher()
+
+const CollisionDispatcher* CcdPhysicsEnvironment::GetDispatcher() const
 {
-	return m_dispatcher;
+	return m_collisionWorld->GetDispatcher();
+}
+
+CollisionDispatcher* CcdPhysicsEnvironment::GetDispatcher()
+{
+	return m_collisionWorld->GetDispatcher();
 }
 
 CcdPhysicsEnvironment::~CcdPhysicsEnvironment()
 {
 	
-	
-	m_vehicles.clear();
+#ifdef NEW_BULLET_VEHICLE_SUPPORT
+	m_wrapperVehicles.clear();
+#endif //NEW_BULLET_VEHICLE_SUPPORT
 	
 	//m_broadphase->DestroyScene();
 	//delete broadphase ? release reference on broadphase ?
 	
 	//first delete scene, then dispatcher, because pairs have to release manifolds on the dispatcher
-	delete m_dispatcher;
+	//delete m_dispatcher;
+	delete m_collisionWorld;
 	
 }
 
@@ -929,10 +1198,32 @@ CcdPhysicsController* CcdPhysicsEnvironment::GetPhysicsController( int index)
 
 int	CcdPhysicsEnvironment::GetNumManifolds() const
 {
-	return m_dispatcher->GetNumManifolds();
+	return GetDispatcher()->GetNumManifolds();
 }
 
 const PersistentManifold*	CcdPhysicsEnvironment::GetManifold(int index) const
 {
-	return m_dispatcher->GetManifoldByIndexInternal(index);
+	return GetDispatcher()->GetManifoldByIndexInternal(index);
 }
+
+
+
+#ifdef NEW_BULLET_VEHICLE_SUPPORT
+
+//complex constraint for vehicles
+PHY_IVehicle*	CcdPhysicsEnvironment::getVehicleConstraint(int constraintId)
+{
+	int i;
+
+	int numVehicles = m_wrapperVehicles.size();
+	for (i=0;i<numVehicles;i++)
+	{
+		WrapperVehicle* wrapperVehicle = m_wrapperVehicles[i];
+		if (wrapperVehicle->GetVehicle()->GetUserConstraintId() == constraintId)
+			return wrapperVehicle;
+	}
+
+	return 0;
+}
+
+#endif //NEW_BULLET_VEHICLE_SUPPORT
\ No newline at end of file
diff --git a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.h b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.h
index 8bacbad8914..46618df7c7c 100644
--- a/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.h
+++ b/extern/bullet/Extras/PhysicsInterface/CcdPhysics/CcdPhysicsEnvironment.h
@@ -9,11 +9,16 @@ class CcdPhysicsController;
 
 
 class Point2PointConstraint;
-class ToiContactDispatcher;
+class CollisionDispatcher;
 class Dispatcher;
 //#include "BroadphaseInterface.h"
 
-class Vehicle;
+//switch on/off new vehicle support
+#define NEW_BULLET_VEHICLE_SUPPORT 1
+
+#include "ConstraintSolver/ContactSolverInfo.h"
+
+class WrapperVehicle;
 class PersistentManifold;
 class BroadphaseInterface;
 class IDebugDraw;
@@ -24,14 +29,16 @@ class IDebugDraw;
 class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 {
 	SimdVector3 m_gravity;
-	BroadphaseInterface*	m_broadphase;
+	
 	IDebugDraw*	m_debugDrawer;
 	int	m_numIterations;
 	int	m_ccdMode;
 	int	m_solverType;
 	
+	ContactSolverInfo	m_solverInfo;
+
 	public:
-		CcdPhysicsEnvironment(ToiContactDispatcher* dispatcher=0, BroadphaseInterface* broadphase=0);
+		CcdPhysicsEnvironment(CollisionDispatcher* dispatcher=0, BroadphaseInterface* broadphase=0);
 
 		virtual		~CcdPhysicsEnvironment();
 
@@ -59,10 +66,12 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 		virtual void		setLinearAirDamping(float damping);
 		virtual void		setUseEpa(bool epa) ;
 
-		virtual	void		beginFrame() {};
+		virtual	void		beginFrame();
 		virtual void		endFrame() {};
 		/// Perform an integration step of duration 'timeStep'.
 		virtual	bool		proceedDeltaTime(double curTime,float timeStep);
+		bool				proceedDeltaTimeOneStep(float timeStep);
+
 		virtual	void		setFixedTimeStep(bool useFixedTimeStep,float fixedTimeStep){};
 		//returns 0.f if no fixed timestep is used
 
@@ -75,8 +84,17 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 		virtual int			createConstraint(class PHY_IPhysicsController* ctrl,class PHY_IPhysicsController* ctrl2,PHY_ConstraintType type,
 			float pivotX,float pivotY,float pivotZ,
 			float axisX,float axisY,float axisZ);
-		virtual void		removeConstraint(int constraintid);
+	    virtual void		removeConstraint(int	constraintid);
 
+#ifdef NEW_BULLET_VEHICLE_SUPPORT
+		//complex constraint for vehicles
+		virtual class PHY_IVehicle*	getVehicleConstraint(int constraintId);
+#else
+		virtual PHY_IVehicle*	getVehicleConstraint(int constraintId)
+		{
+			return 0;
+		}
+#endif //NEW_BULLET_VEHICLE_SUPPORT
 
 		virtual PHY_IPhysicsController* rayTest(PHY_IPhysicsController* ignoreClient, float fromX,float fromY,float fromZ, float toX,float toY,float toZ, 
 										float& hitX,float& hitY,float& hitZ,float& normalX,float& normalY,float& normalZ);
@@ -104,9 +122,12 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 
 		void	removeCcdPhysicsController(CcdPhysicsController* ctrl);
 
-		BroadphaseInterface*	GetBroadphase() { return m_broadphase; }
+		BroadphaseInterface*	GetBroadphase();
+
+		CollisionDispatcher* GetDispatcher();
+		
+		const CollisionDispatcher* GetDispatcher() const;
 
-		Dispatcher* GetDispatcher();
 
 		int	GetNumControllers();
 
@@ -118,16 +139,18 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 
 	private:
 		
-		void	UpdateActivationState();	
+		
 		void	SyncMotionStates(float timeStep);
 		
 		std::vector<CcdPhysicsController*> m_controllers;
 
 		std::vector<Point2PointConstraint*> m_p2pConstraints;
 
-		std::vector<Vehicle*>	m_vehicles;
+		std::vector<WrapperVehicle*>	m_wrapperVehicles;
 
-		class ToiContactDispatcher* m_dispatcher;
+		class CollisionWorld*	m_collisionWorld;
+		
+		class ConstraintSolver*	m_solver;
 
 		bool	m_scalingPropagated;
 
diff --git a/extern/bullet/Extras/PhysicsInterface/Common/PHY_IVehicle.cpp b/extern/bullet/Extras/PhysicsInterface/Common/PHY_IVehicle.cpp
new file mode 100644
index 00000000000..3879e83396f
--- /dev/null
+++ b/extern/bullet/Extras/PhysicsInterface/Common/PHY_IVehicle.cpp
@@ -0,0 +1,7 @@
+
+#include "PHY_IVehicle.h"
+
+PHY_IVehicle::~PHY_IVehicle()
+{
+
+}
diff --git a/extern/bullet/Extras/PhysicsInterface/Common/PHY_IVehicle.h b/extern/bullet/Extras/PhysicsInterface/Common/PHY_IVehicle.h
new file mode 100644
index 00000000000..0e6fe3379a2
--- /dev/null
+++ b/extern/bullet/Extras/PhysicsInterface/Common/PHY_IVehicle.h
@@ -0,0 +1,45 @@
+#ifndef PHY_IVEHICLE_H
+#define PHY_IVEHICLE_H
+
+//PHY_IVehicle provides a generic interface for (raycast based) vehicles. Mostly targetting 4 wheel cars and 2 wheel motorbikes.
+
+class PHY_IMotionState;
+#include "PHY_DynamicTypes.h"
+
+class PHY_IVehicle
+{
+public:
+
+	virtual ~PHY_IVehicle();
+	
+	virtual void	AddWheel(
+			PHY_IMotionState* motionState,
+			PHY__Vector3	connectionPoint,
+			PHY__Vector3	downDirection,
+			PHY__Vector3	axleDirection,
+			float	suspensionRestLength,
+			float wheelRadius,
+			bool hasSteering
+		) = 0;
+
+
+	virtual	int		GetNumWheels() const = 0;
+	
+	virtual void	GetWheelPosition(int wheelIndex,float& posX,float& posY,float& posZ) const = 0;
+	virtual void	GetWheelOrientationQuaternion(int wheelIndex,float& quatX,float& quatY,float& quatZ,float& quatW) const = 0;
+	virtual float	GetWheelRotation(int wheelIndex) const = 0;
+
+	virtual int	GetUserConstraintId() const =0;
+	virtual int	GetUserConstraintType() const =0;
+
+	//some basic steering/braking/tuning/balancing (bikes)
+
+	virtual	void	SetSteeringValue(float steering,int wheelIndex) = 0;
+
+	virtual	void	ApplyEngineForce(float force,int wheelIndex) = 0;
+
+	virtual	void	ApplyBraking(float braking,int wheelIndex) = 0;
+
+};
+
+#endif //PHY_IVEHICLE_H
diff --git a/extern/bullet/Extras/PhysicsInterface/Common/PhysicsInterfaceCommon/PhysicsInterfaceCommon_vc8.vcproj b/extern/bullet/Extras/PhysicsInterface/Common/PhysicsInterfaceCommon/PhysicsInterfaceCommon_vc8.vcproj
index 4df99f6db2c..b0c5fe09eaf 100644
--- a/extern/bullet/Extras/PhysicsInterface/Common/PhysicsInterfaceCommon/PhysicsInterfaceCommon_vc8.vcproj
+++ b/extern/bullet/Extras/PhysicsInterface/Common/PhysicsInterfaceCommon/PhysicsInterfaceCommon_vc8.vcproj
@@ -41,12 +41,12 @@
 				Optimization="0"
 				AdditionalIncludeDirectories="..\..\..\..\LinearMath"
 				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="TRUE"
+				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="1"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
-				Detect64BitPortabilityProblems="TRUE"
+				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
 			/>
 			<Tool
@@ -72,7 +72,7 @@
 				Name="VCBscMakeTool"
 			/>
 			<Tool
-				Name="VCAppVerifierTool"
+				Name="VCFxCopTool"
 			/>
 			<Tool
 				Name="VCPostBuildEventTool"
@@ -107,7 +107,7 @@
 				RuntimeLibrary="0"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
-				Detect64BitPortabilityProblems="TRUE"
+				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="3"
 			/>
 			<Tool
@@ -133,7 +133,7 @@
 				Name="VCBscMakeTool"
 			/>
 			<Tool
-				Name="VCAppVerifierTool"
+				Name="VCFxCopTool"
 			/>
 			<Tool
 				Name="VCPostBuildEventTool"
@@ -160,6 +160,10 @@
 				RelativePath="..\PHY_IPhysicsEnvironment.cpp"
 				>
 			</File>
+			<File
+				RelativePath="..\PHY_IVehicle.cpp"
+				>
+			</File>
 		</Filter>
 		<Filter
 			Name="Header Files"
@@ -183,6 +187,10 @@
 				>
 			</File>
 			<File
+				RelativePath="..\PHY_IVehicle.h"
+				>
+			</File>
+			<File
 				RelativePath="..\PHY_Pro.h"
 				>
 			</File>
@@ -198,4 +206,6 @@
 			>
 		</File>
 	</Files>
+	<Globals>
+	</Globals>
 </VisualStudioProject>
diff --git a/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp b/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
index fb268a6f95a..73b49150414 100644
--- a/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
+++ b/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
@@ -662,6 +662,7 @@ void	KX_ConvertODEEngineObject(KX_GameObject* gameobj,
 
 #include "CcdPhysicsEnvironment.h"
 #include "CcdPhysicsController.h"
+#include "BroadphaseCollision/BroadphaseInterface.h"
 
 #include "KX_BulletPhysicsController.h"
 #include "CollisionShapes/BoxShape.h"
@@ -1010,8 +1011,9 @@ void	KX_ConvertBulletObject(	class	KX_GameObject* gameobj,
 	bm->SetMargin(0.06);
 
 	ci.m_collisionShape = bm;
-	ci.m_broadphaseHandle = 0;
-	ci.m_friction = 5.f* smmaterial->m_friction;//tweak the friction a bit, so the default 0.5 works nice
+
+	
+	ci.m_friction = smmaterial->m_friction;//tweak the friction a bit, so the default 0.5 works nice
 	ci.m_restitution = smmaterial->m_restitution;
 	ci.m_physicsEnv = env;
 	// drag / damping is inverted
@@ -1028,6 +1030,7 @@ void	KX_ConvertBulletObject(	class	KX_GameObject* gameobj,
 	}
 
 	
+
 	gameobj->SetPhysicsController(physicscontroller,isbulletdyna);
 	physicscontroller->setNewClientInfo(gameobj->getClientInfo());		
 	bool isActor = objprop->m_isactor;
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
index 0db5ce4e668..2f8f4a4e2ab 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
@@ -3,6 +3,7 @@
 #include "Dynamics/RigidBody.h"
 #include "PHY_IMotionState.h"
 #include "BroadphaseCollision/BroadphaseProxy.h"
+#include "BroadphaseCollision/BroadphaseInterface.h"
 #include "CollisionShapes/ConvexShape.h"
 #include "CcdPhysicsEnvironment.h"
 
@@ -29,12 +30,10 @@ CcdPhysicsController::CcdPhysicsController (const CcdConstructionInfo& ci)
 	
 	m_MotionState = ci.m_MotionState;
 
-
-	m_broadphaseHandle = ci.m_broadphaseHandle;
-
-	m_collisionShape = ci.m_collisionShape;
-
+	
+	
 	CreateRigidbody();
+	
 
 	
 	#ifdef WIN32
@@ -44,21 +43,31 @@ CcdPhysicsController::CcdPhysicsController (const CcdConstructionInfo& ci)
 
 }
 
-void CcdPhysicsController::CreateRigidbody()
+SimdTransform	CcdPhysicsController::GetTransformFromMotionState(PHY_IMotionState* motionState)
 {
 	SimdTransform trans;
 	float tmp[3];
-	m_MotionState->getWorldPosition(tmp[0],tmp[1],tmp[2]);
+	motionState->getWorldPosition(tmp[0],tmp[1],tmp[2]);
 	trans.setOrigin(SimdVector3(tmp[0],tmp[1],tmp[2]));
 
 	SimdQuaternion orn;
-	m_MotionState->getWorldOrientation(orn[0],orn[1],orn[2],orn[3]);
+	motionState->getWorldOrientation(orn[0],orn[1],orn[2],orn[3]);
 	trans.setRotation(orn);
+	return trans;
+
+}
+
+void CcdPhysicsController::CreateRigidbody()
+{
+
+	SimdTransform trans = GetTransformFromMotionState(m_cci.m_MotionState);
 
 	MassProps mp(m_cci.m_mass, m_cci.m_localInertiaTensor);
 
 	m_body = new RigidBody(mp,0,0,m_cci.m_friction,m_cci.m_restitution);
+	m_body->m_collisionShape = m_cci.m_collisionShape;
 	
+
 	//
 	// init the rigidbody properly
 	//
@@ -74,7 +83,6 @@ void CcdPhysicsController::CreateRigidbody()
 CcdPhysicsController::~CcdPhysicsController()
 {
 	//will be reference counted, due to sharing
-	//delete m_collisionShape;
 	m_cci.m_physicsEnv->removeCcdPhysicsController(this);
 	delete m_MotionState;
 	delete m_body;
@@ -96,7 +104,7 @@ bool		CcdPhysicsController::SynchronizeMotionStates(float time)
 	float scale[3];
 	m_MotionState->getWorldScaling(scale[0],scale[1],scale[2]);
 	SimdVector3 scaling(scale[0],scale[1],scale[2]);
-	m_collisionShape->setLocalScaling(scaling);
+	GetCollisionShape()->setLocalScaling(scaling);
 
 	return true;
 }
@@ -115,12 +123,13 @@ void		CcdPhysicsController::WriteDynamicsToMotionState()
 		// controller replication
 void		CcdPhysicsController::PostProcessReplica(class PHY_IMotionState* motionstate,class PHY_IPhysicsController* parentctrl)
 {
-
 	m_MotionState = motionstate;
-	m_broadphaseHandle = 0;
+
+	
+
 	m_body = 0;
 	CreateRigidbody();
-			
+	
 	m_cci.m_physicsEnv->addCcdPhysicsController(this);
 
 
@@ -387,8 +396,8 @@ bool CcdPhysicsController::wantsSleeping()
 	//disable deactivation
 	if (gDisableDeactivation || (gDeactivationTime == 0.f))
 		return false;
-	//2 == ISLAND_SLEEPING, 3 == WANTS_DEACTIVATION
-	if ( (m_body->GetActivationState() == 2) || (m_body->GetActivationState() == 3))
+
+	if ( (m_body->GetActivationState() == ISLAND_SLEEPING) || (m_body->GetActivationState() == WANTS_DEACTIVATION))
 		return true;
 
 	if (m_body->m_deactivationTime> gDeactivationTime)
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.h b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
index 3becd14028a..04d34fb1200 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
@@ -9,7 +9,11 @@
 #include "SimdVector3.h"
 #include "SimdScalar.h"	
 #include "SimdMatrix3x3.h"
+#include "SimdTransform.h"
+#include "Dynamics/RigidBody.h"
 
+
+#include "BroadphaseCollision/BroadphaseProxy.h" //for CollisionShape access
 class CollisionShape;
 
 extern float gDeactivationTime;
@@ -28,7 +32,6 @@ struct CcdConstructionInfo
 		m_linearDamping(0.1f),
 		m_angularDamping(0.1f),
 		m_MotionState(0),
-		m_collisionShape(0),
 		m_physicsEnv(0),
 		m_inertiaFactor(1.f),
 		m_scaling(1.f,1.f,1.f)
@@ -43,10 +46,10 @@ struct CcdConstructionInfo
 	SimdScalar	m_friction;
 	SimdScalar	m_linearDamping;
 	SimdScalar	m_angularDamping;
-	void*		m_broadphaseHandle;
-	class	PHY_IMotionState*			m_MotionState;
 
 	CollisionShape*			m_collisionShape;
+	class	PHY_IMotionState*			m_MotionState;
+
 	CcdPhysicsEnvironment*	m_physicsEnv; //needed for self-replication
 	float	m_inertiaFactor;//tweak the inertia (hooked up to Blender 'formfactor'
 };
@@ -59,7 +62,8 @@ class CcdPhysicsController : public PHY_IPhysicsController
 {
 	RigidBody* m_body;
 	class	PHY_IMotionState*			m_MotionState;
-	CollisionShape*			m_collisionShape;
+	
+
 	void*		m_newClientInfo;
 
 	CcdConstructionInfo	m_cci;//needed for replication
@@ -71,7 +75,6 @@ class CcdPhysicsController : public PHY_IPhysicsController
 	
 		int				m_collisionDelay;
 	
-		void*  m_broadphaseHandle;
 
 		CcdPhysicsController (const CcdConstructionInfo& ci);
 
@@ -80,7 +83,9 @@ class CcdPhysicsController : public PHY_IPhysicsController
 
 		RigidBody* GetRigidBody() { return m_body;}
 
-		CollisionShape*	GetCollisionShape() { return m_collisionShape;}
+		CollisionShape*	GetCollisionShape() { 
+			return m_body->GetCollisionShape();
+		}
 		////////////////////////////////////
 		// PHY_IPhysicsController interface
 		////////////////////////////////////
@@ -143,6 +148,8 @@ class CcdPhysicsController : public PHY_IPhysicsController
 
 		void	UpdateDeactivation(float timeStep);
 
+		static SimdTransform	GetTransformFromMotionState(PHY_IMotionState* motionState);
+
 		void	SetAabb(const SimdVector3& aabbMin,const SimdVector3& aabbMax);
 
 
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
index afc2aa2c70f..9e175bdac27 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
@@ -6,20 +6,24 @@
 #include "Dynamics/RigidBody.h"
 #include "BroadphaseCollision/BroadphaseInterface.h"
 #include "BroadphaseCollision/SimpleBroadphase.h"
+#include "CollisionDispatch/CollisionWorld.h"
 
 #include "CollisionShapes/ConvexShape.h"
-#include "BroadphaseCollision/CollisionDispatcher.h"
+#include "BroadphaseCollision/Dispatcher.h"
 #include "NarrowPhaseCollision/PersistentManifold.h"
 #include "CollisionShapes/TriangleMeshShape.h"
 #include "ConstraintSolver/OdeConstraintSolver.h"
 #include "ConstraintSolver/SimpleConstraintSolver.h"
 
+
 #include "IDebugDraw.h"
 
 #include "NarrowPhaseCollision/VoronoiSimplexSolver.h"
 #include "NarrowPhaseCollision/SubSimplexConvexCast.h"
+#include "NarrowPhaseCollision/GjkConvexCast.h"
+
 
-#include "CollisionDispatch/ToiContactDispatcher.h"
+#include "CollisionDispatch/CollisionDispatcher.h"
 #include "PHY_IMotionState.h"
 
 #include "CollisionDispatch/EmptyCollisionAlgorithm.h"
@@ -33,9 +37,10 @@ bool useIslands = true;
 #ifdef NEW_BULLET_VEHICLE_SUPPORT
 #include "Vehicle/RaycastVehicle.h"
 #include "Vehicle/VehicleRaycaster.h"
-#include "Vehicle/VehicleTuning.h"
+
+#include "Vehicle/WheelInfo.h"
 #include "PHY_IVehicle.h"
-VehicleTuning	gTuning;
+RaycastVehicle::VehicleTuning	gTuning;
 
 #endif //NEW_BULLET_VEHICLE_SUPPORT
 #include "AabbUtil2.h"
@@ -233,24 +238,23 @@ static void DrawAabb(IDebugDraw* debugDrawer,const SimdVector3& from,const SimdV
 
 
 
-CcdPhysicsEnvironment::CcdPhysicsEnvironment(ToiContactDispatcher* dispatcher,BroadphaseInterface* bp)
-:m_dispatcher(dispatcher),
-m_broadphase(bp),
-m_scalingPropagated(false),
+CcdPhysicsEnvironment::CcdPhysicsEnvironment(CollisionDispatcher* dispatcher,BroadphaseInterface* broadphase)
+:m_scalingPropagated(false),
 m_numIterations(30),
 m_ccdMode(0),
 m_solverType(-1)
 {
 
-	if (!m_dispatcher)
-	{
-		setSolverType(0);
-	}
+	if (!dispatcher)
+		dispatcher = new CollisionDispatcher();
 
-	if (!m_broadphase)
-	{
-		m_broadphase = new SimpleBroadphase();
-	}
+	
+	if(!broadphase)
+		broadphase = new SimpleBroadphase();
+		
+	setSolverType(0);
+	
+	m_collisionWorld = new CollisionWorld(dispatcher,broadphase);
 	
 	m_debugDrawer = 0;
 	m_gravity = SimdVector3(0.f,-10.f,0.f);
@@ -260,10 +264,17 @@ m_solverType(-1)
 
 void	CcdPhysicsEnvironment::addCcdPhysicsController(CcdPhysicsController* ctrl)
 {
-	ctrl->GetRigidBody()->setGravity( m_gravity );
+	RigidBody* body = ctrl->GetRigidBody();
+
+	body->setGravity( m_gravity );
 	m_controllers.push_back(ctrl);
 	
-	BroadphaseInterface* scene =  m_broadphase;
+	m_collisionWorld->AddCollisionObject(body);
+
+	assert(body->m_broadphaseHandle);
+
+	BroadphaseInterface* scene =  GetBroadphase();
+
 	
 	CollisionShape* shapeinterface = ctrl->GetCollisionShape();
 	
@@ -271,7 +282,6 @@ void	CcdPhysicsEnvironment::addCcdPhysicsController(CcdPhysicsController* ctrl)
 	
 	const SimdTransform& t = ctrl->GetRigidBody()->getCenterOfMassTransform();
 	
-	RigidBody* body = ctrl->GetRigidBody();
 	
 	SimdPoint3 minAabb,maxAabb;
 	
@@ -308,17 +318,6 @@ void	CcdPhysicsEnvironment::addCcdPhysicsController(CcdPhysicsController* ctrl)
 	minAabb = SimdVector3(minAabbx,minAabby,minAabbz);
 	maxAabb = SimdVector3(maxAabbx,maxAabby,maxAabbz);
 	
-	if (!ctrl->m_broadphaseHandle)
-	{
-		int type = shapeinterface->GetShapeType();
-		ctrl->m_broadphaseHandle = scene->CreateProxy(
-			ctrl->GetRigidBody(),
-			type,
-			minAabb, 
-			maxAabb);
-	}
-	
-	body->SetCollisionShape( shapeinterface );
 	
 	
 	
@@ -364,23 +363,9 @@ void	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
 	}
 	
 	
-	
-	bool removeFromBroadphase = false;
-	
-	{
-		BroadphaseInterface* scene = m_broadphase;
-		BroadphaseProxy* bp = (BroadphaseProxy*)ctrl->m_broadphaseHandle;
-		
-		if (removeFromBroadphase)
-		{
+	m_collisionWorld->RemoveCollisionObject(ctrl->GetRigidBody());
 
-		}
-		//
-		// only clear the cached algorithms
-		//
-		scene->CleanProxyFromPairs(bp);
-		scene->DestroyProxy(bp);//??
-	}
+	
 	{
 		std::vector<CcdPhysicsController*>::iterator i =
 			std::find(m_controllers.begin(), m_controllers.end(), ctrl);
@@ -392,56 +377,6 @@ void	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
 	}
 }
 
-void	CcdPhysicsEnvironment::UpdateActivationState()
-{
-	m_dispatcher->InitUnionFind();
-	
-	// put the index into m_controllers into m_tag	
-	{
-		std::vector<CcdPhysicsController*>::iterator i;
-		
-		int index = 0;
-		for (i=m_controllers.begin();
-		!(i==m_controllers.end()); i++)
-		{
-			CcdPhysicsController* ctrl = (*i);
-			RigidBody* body = ctrl->GetRigidBody();
-			body->m_islandTag1 = index;
-			body->m_hitFraction = 1.f;
-			index++;
-			
-		}
-	}
-	// do the union find
-	
-	m_dispatcher->FindUnions();
-	
-	// put the islandId ('find' value) into m_tag	
-	{
-		UnionFind& unionFind = m_dispatcher->GetUnionFind();
-		
-		std::vector<CcdPhysicsController*>::iterator i;
-		
-		int index = 0;
-		for (i=m_controllers.begin();
-		!(i==m_controllers.end()); i++)
-		{
-			CcdPhysicsController* ctrl = (*i);
-			RigidBody* body = ctrl->GetRigidBody();
-			
-			
-			if (body->mergesSimulationIslands())
-			{
-				body->m_islandTag1 = unionFind.find(index);
-			} else
-			{
-				body->m_islandTag1 = -1;
-			}
-			index++;
-		}
-	}
-	
-}
 
 void	CcdPhysicsEnvironment::beginFrame()
 {
@@ -504,11 +439,12 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 			{
 				body->applyForces( timeStep);
 				body->integrateVelocities( timeStep);
+				body->predictIntegratedTransform(timeStep,body->m_nextPredictedWorldTransform);
 			}
 			
 		}
 	}
-	BroadphaseInterface*	scene = m_broadphase;
+	BroadphaseInterface*	scene = GetBroadphase();
 	
 	
 	//
@@ -526,7 +462,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 	dispatchInfo.m_timeStep = timeStep;
 	dispatchInfo.m_stepCount = 0;
 
-	scene->DispatchAllCollisionPairs(*m_dispatcher,dispatchInfo);///numsubstep,g);
+	scene->DispatchAllCollisionPairs(*GetDispatcher(),dispatchInfo);///numsubstep,g);
 
 
 
@@ -535,12 +471,51 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 	
 	int numRigidBodies = m_controllers.size();
 	
-	UpdateActivationState();
+	m_collisionWorld->UpdateActivationState();
+
+	
 
 	//contacts
 
 	
-	m_dispatcher->SolveConstraints(timeStep, m_numIterations ,numRigidBodies,m_debugDrawer);
+	struct InplaceSolverIslandCallback : public CollisionDispatcher::IslandCallback
+	{
+
+		ContactSolverInfo& m_solverInfo;
+		ConstraintSolver*	m_solver;
+		IDebugDraw*	m_debugDrawer;
+		
+		InplaceSolverIslandCallback(
+			ContactSolverInfo& solverInfo,
+			ConstraintSolver*	solver,
+			IDebugDraw*	debugDrawer)
+			:m_solverInfo(solverInfo),
+			m_solver(solver),
+			m_debugDrawer(debugDrawer)
+		{
+			
+		}
+		
+		virtual	void	ProcessIsland(PersistentManifold**	manifolds,int numManifolds)
+		{
+			m_solver->SolveGroup( manifolds, numManifolds,m_solverInfo,m_debugDrawer);
+		}
+		
+	};
+
+
+	m_solverInfo.m_friction = 0.9f;
+	m_solverInfo.m_numIterations = m_numIterations;
+	m_solverInfo.m_timeStep = timeStep;
+	m_solverInfo.m_restitution = 0.f;//m_restitution;
+
+	InplaceSolverIslandCallback	solverCallback(
+			m_solverInfo,
+			m_solver,
+			m_debugDrawer);
+
+	GetDispatcher()->BuildAndProcessIslands(numRigidBodies,&solverCallback);
+
 
 	for (int g=0;g<numsubstep;g++)
 	{
@@ -562,7 +537,13 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 			
 		}
 
-#ifdef NEW_BULLET_VEHICLE_SUPPORT
+
+		
+		
+	}
+	
+
+	#ifdef NEW_BULLET_VEHICLE_SUPPORT
 		//vehicles
 		int numVehicles = m_wrapperVehicles.size();
 		for (int i=0;i<numVehicles;i++)
@@ -574,10 +555,6 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 #endif //NEW_BULLET_VEHICLE_SUPPORT
 
 		
-		
-		
-	}
-	
 
 
 	{
@@ -614,7 +591,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 				minAabb -= manifoldExtraExtents;
 				maxAabb += manifoldExtraExtents;
 				
-				BroadphaseProxy* bp = (BroadphaseProxy*) ctrl->m_broadphaseHandle;
+				BroadphaseProxy* bp = body->m_broadphaseHandle;
 				if (bp)
 				{
 					
@@ -668,7 +645,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 				dispatchInfo.m_stepCount = 0;
 				dispatchInfo.m_dispatchFunc = DispatcherInfo::DISPATCH_CONTINUOUS;
 				
-				scene->DispatchAllCollisionPairs( *m_dispatcher,dispatchInfo);///numsubstep,g);
+				scene->DispatchAllCollisionPairs( *GetDispatcher(),dispatchInfo);///numsubstep,g);
 				toi = dispatchInfo.m_timeOfImpact;
 			}
 			
@@ -689,9 +666,10 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 					RigidBody* body = ctrl->GetRigidBody();
 					if (body->GetActivationState() != ISLAND_SLEEPING)
 					{
+
 						body->predictIntegratedTransform(timeStep*	toi, predictedTrans);
 						body->proceedToTransform( predictedTrans);
-
+			
 					}
 				}
 				
@@ -759,7 +737,7 @@ bool	CcdPhysicsEnvironment::proceedDeltaTimeOneStep(float timeStep)
 			
 			for (int j=0;j<wrapperVehicle->GetVehicle()->GetNumWheels();j++)
 			{
-				wrapperVehicle->GetVehicle()->UpdateWheelTransformsWS(wrapperVehicle->GetVehicle()->GetWheelInfo(j));
+				wrapperVehicle->GetVehicle()->UpdateWheelTransform(j);
 			}
 			
 			wrapperVehicle->SyncWheels();
@@ -807,16 +785,16 @@ void		CcdPhysicsEnvironment::setCcdMode(int ccdMode)
 
 void		CcdPhysicsEnvironment::setSolverSorConstant(float sor)
 {
-	m_dispatcher->SetSor(sor);
+	m_solverInfo.m_sor = sor;
 }
 
 void		CcdPhysicsEnvironment::setSolverTau(float tau)
 {
-	m_dispatcher->SetTau(tau);
+	m_solverInfo.m_tau = tau;
 }
 void		CcdPhysicsEnvironment::setSolverDamping(float damping)
 {
-	m_dispatcher->SetDamping(damping);
+	m_solverInfo.m_damping = damping;
 }
 
 
@@ -839,11 +817,9 @@ void		CcdPhysicsEnvironment::setSolverType(int solverType)
 		{
 			if (m_solverType != solverType)
 			{
-				if (m_dispatcher)
-					delete m_dispatcher;
-
-				SimpleConstraintSolver* solver= new SimpleConstraintSolver();
-				m_dispatcher = new ToiContactDispatcher(solver);
+				
+				m_solver = new SimpleConstraintSolver();
+				
 				break;
 			}
 		}
@@ -852,11 +828,8 @@ void		CcdPhysicsEnvironment::setSolverType(int solverType)
 	default:
 			if (m_solverType != solverType)
 			{
-				if (m_dispatcher)
-					delete m_dispatcher;
-
-				OdeConstraintSolver* solver= new OdeConstraintSolver();
-				m_dispatcher = new ToiContactDispatcher(solver);
+				m_solver = new OdeConstraintSolver();
+		
 				break;
 			}
 
@@ -1022,11 +995,10 @@ int			CcdPhysicsEnvironment::createConstraint(class PHY_IPhysicsController* ctrl
 
 	case PHY_VEHICLE_CONSTRAINT:
 		{
-			VehicleTuning* tuning = new VehicleTuning();
+			RaycastVehicle::VehicleTuning* tuning = new RaycastVehicle::VehicleTuning();
 			RigidBody* chassis = rb0;
 			BlenderVehicleRaycaster* raycaster = new BlenderVehicleRaycaster(this,ctrl0);
 			RaycastVehicle* vehicle = new RaycastVehicle(*tuning,chassis,raycaster);
-			vehicle->SetBalance(false);
 			WrapperVehicle* wrapperVehicle = new WrapperVehicle(vehicle,ctrl0);
 			m_wrapperVehicles.push_back(wrapperVehicle);
 			vehicle->SetUserConstraintId(gConstraintUid++);
@@ -1120,6 +1092,7 @@ PHY_IPhysicsController* CcdPhysicsEnvironment::rayTest(PHY_IPhysicsController* i
 				ConvexShape* convexShape = (ConvexShape*) body->GetCollisionShape();
 				VoronoiSimplexSolver	simplexSolver;
 				SubsimplexConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
+				//GjkConvexCast	convexCaster(&pointShape,convexShape,&simplexSolver);
 				
 				if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,body->getCenterOfMassTransform(),body->getCenterOfMassTransform(),rayResult))
 				{
@@ -1136,9 +1109,12 @@ PHY_IPhysicsController* CcdPhysicsEnvironment::rayTest(PHY_IPhysicsController* i
 							normalX = rayResult.m_normal.getX();
 							normalY = rayResult.m_normal.getY();
 							normalZ = rayResult.m_normal.getZ();
-							hitX = rayResult.m_hitTransformA.getOrigin().getX();
-							hitY = rayResult.m_hitTransformA.getOrigin().getY();
-							hitZ = rayResult.m_hitTransformA.getOrigin().getZ();
+							SimdVector3 hitWorld;
+							hitWorld.setInterpolate3(rayFromTrans.getOrigin(),rayToTrans.getOrigin(),rayResult.m_fraction);
+							hitX = hitWorld.getX();
+							hitY = hitWorld.getY();
+							hitZ = hitWorld.getZ();
+
 						}
 					}
 				}
@@ -1158,12 +1134,18 @@ PHY_IPhysicsController* CcdPhysicsEnvironment::rayTest(PHY_IPhysicsController* i
 						RaycastCallback	rcb(rayFromLocal,rayToLocal);
 						rcb.m_hitFraction = minFraction;
 
-						triangleMesh->ProcessAllTriangles(&rcb,rayAabbMin,rayAabbMax);
-						if (rcb.m_hitFound)// && (rcb.m_hitFraction < minFraction))
+						SimdVector3 rayAabbMinLocal = rayFromLocal;
+						rayAabbMinLocal.setMin(rayToLocal);
+						SimdVector3 rayAabbMaxLocal = rayFromLocal;
+						rayAabbMaxLocal.setMax(rayToLocal);
+
+						triangleMesh->ProcessAllTriangles(&rcb,rayAabbMinLocal,rayAabbMaxLocal);
+						if (rcb.m_hitFound)
 						{
 							nearestHit = ctrl;
 							minFraction = rcb.m_hitFraction;
-							SimdVector3 hitNormalWorld = body->getCenterOfMassTransform()(rcb.m_hitNormalLocal);
+							SimdVector3 hitNormalWorld = body->getCenterOfMassTransform().getBasis()*rcb.m_hitNormalLocal;
+							hitNormalWorld.normalize();
 
 							normalX = hitNormalWorld.getX();
 							normalY = hitNormalWorld.getY();
@@ -1198,10 +1180,21 @@ void CcdPhysicsEnvironment::getContactPoint(int i,float& hitX,float& hitY,float&
 
 
 
+BroadphaseInterface*	CcdPhysicsEnvironment::GetBroadphase()
+{ 
+	return m_collisionWorld->GetBroadphase(); 
+}
+
+
+
+const CollisionDispatcher* CcdPhysicsEnvironment::GetDispatcher() const
+{
+	return m_collisionWorld->GetDispatcher();
+}
 
-Dispatcher* CcdPhysicsEnvironment::GetDispatcher()
+CollisionDispatcher* CcdPhysicsEnvironment::GetDispatcher()
 {
-	return m_dispatcher;
+	return m_collisionWorld->GetDispatcher();
 }
 
 CcdPhysicsEnvironment::~CcdPhysicsEnvironment()
@@ -1215,7 +1208,8 @@ CcdPhysicsEnvironment::~CcdPhysicsEnvironment()
 	//delete broadphase ? release reference on broadphase ?
 	
 	//first delete scene, then dispatcher, because pairs have to release manifolds on the dispatcher
-	delete m_dispatcher;
+	//delete m_dispatcher;
+	delete m_collisionWorld;
 	
 }
 
@@ -1234,12 +1228,12 @@ CcdPhysicsController* CcdPhysicsEnvironment::GetPhysicsController( int index)
 
 int	CcdPhysicsEnvironment::GetNumManifolds() const
 {
-	return m_dispatcher->GetNumManifolds();
+	return GetDispatcher()->GetNumManifolds();
 }
 
 const PersistentManifold*	CcdPhysicsEnvironment::GetManifold(int index) const
 {
-	return m_dispatcher->GetManifoldByIndexInternal(index);
+	return GetDispatcher()->GetManifoldByIndexInternal(index);
 }
 
 
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
index 9664e9b6233..49061197a98 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
@@ -9,13 +9,15 @@ class CcdPhysicsController;
 
 
 class Point2PointConstraint;
-class ToiContactDispatcher;
+class CollisionDispatcher;
 class Dispatcher;
 //#include "BroadphaseInterface.h"
 
 //switch on/off new vehicle support
 //#define NEW_BULLET_VEHICLE_SUPPORT 1
 
+#include "ConstraintSolver/ContactSolverInfo.h"
+
 class WrapperVehicle;
 class PersistentManifold;
 class BroadphaseInterface;
@@ -27,14 +29,16 @@ class IDebugDraw;
 class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 {
 	SimdVector3 m_gravity;
-	BroadphaseInterface*	m_broadphase;
+	
 	IDebugDraw*	m_debugDrawer;
 	int	m_numIterations;
 	int	m_ccdMode;
 	int	m_solverType;
 	
+	ContactSolverInfo	m_solverInfo;
+
 	public:
-		CcdPhysicsEnvironment(ToiContactDispatcher* dispatcher=0, BroadphaseInterface* broadphase=0);
+		CcdPhysicsEnvironment(CollisionDispatcher* dispatcher=0, BroadphaseInterface* broadphase=0);
 
 		virtual		~CcdPhysicsEnvironment();
 
@@ -118,9 +122,12 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 
 		void	removeCcdPhysicsController(CcdPhysicsController* ctrl);
 
-		BroadphaseInterface*	GetBroadphase() { return m_broadphase; }
+		BroadphaseInterface*	GetBroadphase();
+
+		CollisionDispatcher* GetDispatcher();
+		
+		const CollisionDispatcher* GetDispatcher() const;
 
-		Dispatcher* GetDispatcher();
 
 		int	GetNumControllers();
 
@@ -132,7 +139,7 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 
 	private:
 		
-		void	UpdateActivationState();	
+		
 		void	SyncMotionStates(float timeStep);
 		
 		std::vector<CcdPhysicsController*> m_controllers;
@@ -141,7 +148,9 @@ class CcdPhysicsEnvironment : public PHY_IPhysicsEnvironment
 
 		std::vector<WrapperVehicle*>	m_wrapperVehicles;
 
-		class ToiContactDispatcher* m_dispatcher;
+		class CollisionWorld*	m_collisionWorld;
+		
+		class ConstraintSolver*	m_solver;
 
 		bool	m_scalingPropagated;