First stage in refactoring Bullet: moved Bullet Collision and Dynamics and LinearMath into src folder, and all files in Collision Detection and Dynamics have bt prefix.

Made all buildsystems to work again (jam, msvc, cmake)

src/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h

@@ -0,0 +1,43 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef COLLISION_CREATE_FUNC
+#define COLLISION_CREATE_FUNC
+
+#include <vector>
+
+typedef std::vector<struct CollisionObject*> CollisionObjectArray;
+class CollisionAlgorithm;
+struct BroadphaseProxy;
+struct CollisionAlgorithmConstructionInfo;
+
+
+struct CollisionAlgorithmCreateFunc
+{
+	bool m_swapped;
+	
+	CollisionAlgorithmCreateFunc()
+		:m_swapped(false)
+	{
+	}
+	virtual ~CollisionAlgorithmCreateFunc(){};
+
+	virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+	{
+		return 0;
+	}
+};
+#endif //COLLISION_CREATE_FUNC
+

src/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

@@ -0,0 +1,347 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "btCollisionDispatcher.h"
+
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h"
+#include "BulletCollision/CollisionShapes/btCollisionShape.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+#include <algorithm>
+#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
+
+int gNumManifold = 0;
+
+
+	
+
+	
+CollisionDispatcher::CollisionDispatcher (): 
+	m_useIslands(true),
+		m_defaultManifoldResult(0,0,0),
+		m_count(0)
+{
+	int i;
+	
+	//default CreationFunctions, filling the m_doubleDispatch table
+	m_convexConvexCreateFunc = new ConvexConvexAlgorithm::CreateFunc;
+	m_convexConcaveCreateFunc = new ConvexConcaveCollisionAlgorithm::CreateFunc;
+	m_swappedConvexConcaveCreateFunc = new ConvexConcaveCollisionAlgorithm::SwappedCreateFunc;
+	m_compoundCreateFunc = new CompoundCollisionAlgorithm::CreateFunc;
+	m_swappedCompoundCreateFunc = new CompoundCollisionAlgorithm::SwappedCreateFunc;
+	m_emptyCreateFunc = new EmptyAlgorithm::CreateFunc;
+
+	for (i=0;i<MAX_BROADPHASE_COLLISION_TYPES;i++)
+	{
+		for (int j=0;j<MAX_BROADPHASE_COLLISION_TYPES;j++)
+		{
+			m_doubleDispatch[i][j] = InternalFindCreateFunc(i,j);
+			assert(m_doubleDispatch[i][j]);
+		}
+	}
+	
+	
+};
+
+void CollisionDispatcher::RegisterCollisionCreateFunc(int proxyType0, int proxyType1, CollisionAlgorithmCreateFunc *createFunc)
+{
+	m_doubleDispatch[proxyType0][proxyType1] = createFunc;
+}
+
+CollisionDispatcher::~CollisionDispatcher()
+{
+	delete m_convexConvexCreateFunc;
+	delete m_convexConcaveCreateFunc;
+	delete m_swappedConvexConcaveCreateFunc;
+	delete m_compoundCreateFunc;
+	delete m_swappedCompoundCreateFunc;
+	delete m_emptyCreateFunc;
+}
+
+PersistentManifold*	CollisionDispatcher::GetNewManifold(void* b0,void* b1) 
+{ 
+	gNumManifold++;
+	
+	//ASSERT(gNumManifold < 65535);
+	
+
+	CollisionObject* body0 = (CollisionObject*)b0;
+	CollisionObject* body1 = (CollisionObject*)b1;
+	
+	PersistentManifold* manifold = new PersistentManifold (body0,body1);
+	m_manifoldsPtr.push_back(manifold);
+
+	return manifold;
+}
+
+void CollisionDispatcher::ClearManifold(PersistentManifold* manifold)
+{
+	manifold->ClearManifold();
+}
+
+	
+void CollisionDispatcher::ReleaseManifold(PersistentManifold* manifold)
+{
+	
+	gNumManifold--;
+
+	//printf("ReleaseManifold: gNumManifold %d\n",gNumManifold);
+
+	ClearManifold(manifold);
+
+	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();
+		delete manifold;
+
+	}
+	
+	
+}
+
+	
+
+CollisionAlgorithm* CollisionDispatcher::FindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
+{
+#define USE_DISPATCH_REGISTRY_ARRAY 1
+#ifdef USE_DISPATCH_REGISTRY_ARRAY
+	CollisionObject* body0 = (CollisionObject*)proxy0.m_clientObject;
+	CollisionObject* body1 = (CollisionObject*)proxy1.m_clientObject;
+	CollisionAlgorithmConstructionInfo ci;
+	ci.m_dispatcher = this;
+	CollisionAlgorithm* algo = m_doubleDispatch[body0->m_collisionShape->GetShapeType()][body1->m_collisionShape->GetShapeType()]
+	->CreateCollisionAlgorithm(ci,&proxy0,&proxy1);
+#else
+	CollisionAlgorithm* algo = InternalFindAlgorithm(proxy0,proxy1);
+#endif //USE_DISPATCH_REGISTRY_ARRAY
+	return algo;
+}
+
+
+CollisionAlgorithmCreateFunc* CollisionDispatcher::InternalFindCreateFunc(int proxyType0,int proxyType1)
+{
+	
+	if (BroadphaseProxy::IsConvex(proxyType0) && BroadphaseProxy::IsConvex(proxyType1))
+	{
+		return m_convexConvexCreateFunc;
+	}
+
+	if (BroadphaseProxy::IsConvex(proxyType0) && BroadphaseProxy::IsConcave(proxyType1))
+	{
+		return m_convexConcaveCreateFunc;
+	}
+
+	if (BroadphaseProxy::IsConvex(proxyType1) && BroadphaseProxy::IsConcave(proxyType0))
+	{
+		return m_swappedConvexConcaveCreateFunc;
+	}
+
+	if (BroadphaseProxy::IsCompound(proxyType0))
+	{
+		return m_compoundCreateFunc;
+	} else
+	{
+		if (BroadphaseProxy::IsCompound(proxyType1))
+		{
+			return m_swappedCompoundCreateFunc;
+		}
+	}
+
+	//failed to find an algorithm
+	return m_emptyCreateFunc;
+}
+
+
+
+CollisionAlgorithm* CollisionDispatcher::InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
+{
+	m_count++;
+	CollisionObject* body0 = (CollisionObject*)proxy0.m_clientObject;
+	CollisionObject* body1 = (CollisionObject*)proxy1.m_clientObject;
+
+	CollisionAlgorithmConstructionInfo ci;
+	ci.m_dispatcher = this;
+	
+	if (body0->m_collisionShape->IsConvex() && body1->m_collisionShape->IsConvex() )
+	{
+		return new ConvexConvexAlgorithm(0,ci,&proxy0,&proxy1);			
+	}
+
+	if (body0->m_collisionShape->IsConvex() && body1->m_collisionShape->IsConcave())
+	{
+		return new ConvexConcaveCollisionAlgorithm(ci,&proxy0,&proxy1);
+	}
+
+	if (body1->m_collisionShape->IsConvex() && body0->m_collisionShape->IsConcave())
+	{
+		return new ConvexConcaveCollisionAlgorithm(ci,&proxy1,&proxy0);
+	}
+
+	if (body0->m_collisionShape->IsCompound())
+	{
+		return new CompoundCollisionAlgorithm(ci,&proxy0,&proxy1);
+	} else
+	{
+		if (body1->m_collisionShape->IsCompound())
+		{
+			return new CompoundCollisionAlgorithm(ci,&proxy1,&proxy0);
+		}
+	}
+
+	//failed to find an algorithm
+	return new EmptyAlgorithm(ci);
+	
+}
+
+bool	CollisionDispatcher::NeedsResponse(const  CollisionObject& colObj0,const CollisionObject& colObj1)
+{
+
+	
+	//here you can do filtering
+	bool hasResponse = 
+		(!(colObj0.m_collisionFlags & CollisionObject::noContactResponse)) &&
+		(!(colObj1.m_collisionFlags & CollisionObject::noContactResponse));
+	hasResponse = hasResponse &&
+		(colObj0.IsActive() || colObj1.IsActive());
+	return hasResponse;
+}
+
+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->IsActive()) && (!body1->IsActive()))
+		needsCollision = false;
+	
+	return needsCollision ;
+
+}
+
+///allows the user to get contact point callbacks 
+ManifoldResult*	CollisionDispatcher::GetNewManifoldResult(CollisionObject* obj0,CollisionObject* obj1,PersistentManifold* manifold)
+{
+
+
+	//in-place, this prevents parallel dispatching, but just adding a list would fix that.
+	ManifoldResult* manifoldResult = new (&m_defaultManifoldResult)	ManifoldResult(obj0,obj1,manifold);
+	return manifoldResult;
+}
+	
+///allows the user to get contact point callbacks 
+void	CollisionDispatcher::ReleaseManifoldResult(ManifoldResult*)
+{
+
+}
+
+
+class CollisionPairCallback : public OverlapCallback
+{
+	DispatcherInfo& m_dispatchInfo;
+	CollisionDispatcher*	m_dispatcher;
+	int		m_dispatcherId;
+public:
+
+	CollisionPairCallback(DispatcherInfo& dispatchInfo,CollisionDispatcher*	dispatcher,int		dispatcherId)
+	:m_dispatchInfo(dispatchInfo),
+	m_dispatcher(dispatcher),
+	m_dispatcherId(dispatcherId)
+	{
+	}
+
+	virtual bool	ProcessOverlap(BroadphasePair& pair)
+	{
+		if (m_dispatcherId>= 0)
+		{
+			//dispatcher will keep algorithms persistent in the collision pair
+			if (!pair.m_algorithms[m_dispatcherId])
+			{
+				pair.m_algorithms[m_dispatcherId] = m_dispatcher->FindAlgorithm(
+					*pair.m_pProxy0,
+					*pair.m_pProxy1);
+			}
+
+			if (pair.m_algorithms[m_dispatcherId])
+			{
+				if (m_dispatchInfo.m_dispatchFunc == 		DispatcherInfo::DISPATCH_DISCRETE)
+				{
+					pair.m_algorithms[m_dispatcherId]->ProcessCollision(pair.m_pProxy0,pair.m_pProxy1,m_dispatchInfo);
+				} else
+				{
+					float toi = pair.m_algorithms[m_dispatcherId]->CalculateTimeOfImpact(pair.m_pProxy0,pair.m_pProxy1,m_dispatchInfo);
+					if (m_dispatchInfo.m_timeOfImpact > toi)
+						m_dispatchInfo.m_timeOfImpact = toi;
+
+				}
+			}
+		} else
+		{
+			//non-persistent algorithm dispatcher
+			CollisionAlgorithm* algo = m_dispatcher->FindAlgorithm(
+				*pair.m_pProxy0,
+				*pair.m_pProxy1);
+
+			if (algo)
+			{
+				if (m_dispatchInfo.m_dispatchFunc == 		DispatcherInfo::DISPATCH_DISCRETE)
+				{
+					algo->ProcessCollision(pair.m_pProxy0,pair.m_pProxy1,m_dispatchInfo);
+				} else
+				{
+					float toi = algo->CalculateTimeOfImpact(pair.m_pProxy0,pair.m_pProxy1,m_dispatchInfo);
+					if (m_dispatchInfo.m_timeOfImpact > toi)
+						m_dispatchInfo.m_timeOfImpact = toi;
+				}
+			}
+		}
+		return false;
+
+	}
+};
+
+
+void	CollisionDispatcher::DispatchAllCollisionPairs(OverlappingPairCache* pairCache,DispatcherInfo& dispatchInfo)
+{
+	//m_blockedForChanges = true;
+
+	int dispatcherId = GetUniqueId();
+
+	CollisionPairCallback	collisionCallback(dispatchInfo,this,dispatcherId);
+
+	pairCache->ProcessAllOverlappingPairs(&collisionCallback);
+
+	//m_blockedForChanges = false;
+
+}
+
+

src/BulletCollision/CollisionDispatch/btCollisionDispatcher.h

@@ -0,0 +1,115 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef COLLISION__DISPATCHER_H
+#define COLLISION__DISPATCHER_H
+
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+
+#include "BulletCollision/CollisionDispatch/btManifoldResult.h"
+
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+
+
+class IDebugDraw;
+class OverlappingPairCache;
+
+
+#include "btCollisionCreateFunc.h"
+
+
+
+
+///CollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs.
+///Time of Impact, Closest Points and Penetration Depth.
+class CollisionDispatcher : public Dispatcher
+{
+	
+	std::vector<PersistentManifold*>	m_manifoldsPtr;
+
+	bool m_useIslands;
+	
+	ManifoldResult	m_defaultManifoldResult;
+	
+	CollisionAlgorithmCreateFunc* m_doubleDispatch[MAX_BROADPHASE_COLLISION_TYPES][MAX_BROADPHASE_COLLISION_TYPES];
+	
+	CollisionAlgorithmCreateFunc* InternalFindCreateFunc(int proxyType0,int proxyType1);
+
+	//default CreationFunctions, filling the m_doubleDispatch table
+	CollisionAlgorithmCreateFunc*	m_convexConvexCreateFunc;
+	CollisionAlgorithmCreateFunc*	m_convexConcaveCreateFunc;
+	CollisionAlgorithmCreateFunc*	m_swappedConvexConcaveCreateFunc;
+	CollisionAlgorithmCreateFunc*	m_compoundCreateFunc;
+	CollisionAlgorithmCreateFunc*	m_swappedCompoundCreateFunc;
+	CollisionAlgorithmCreateFunc*   m_emptyCreateFunc;
+
+public:
+
+	///RegisterCollisionCreateFunc allows registration of custom/alternative collision create functions
+	void	RegisterCollisionCreateFunc(int proxyType0,int proxyType1, CollisionAlgorithmCreateFunc* createFunc);
+
+	int	GetNumManifolds() const
+	{ 
+		return m_manifoldsPtr.size();
+	}
+
+	 PersistentManifold* GetManifoldByIndexInternal(int index)
+	{
+		return m_manifoldsPtr[index];
+	}
+
+	 const PersistentManifold* GetManifoldByIndexInternal(int index) const
+	{
+		return m_manifoldsPtr[index];
+	}
+
+	int m_count;
+	
+	CollisionDispatcher ();
+	virtual ~CollisionDispatcher();
+
+	virtual PersistentManifold*	GetNewManifold(void* b0,void* b1);
+	
+	virtual void ReleaseManifold(PersistentManifold* manifold);
+
+	
+	///allows the user to get contact point callbacks 
+	virtual	ManifoldResult*	GetNewManifoldResult(CollisionObject* obj0,CollisionObject* obj1,PersistentManifold* manifold);
+
+	///allows the user to get contact point callbacks 
+	virtual	void	ReleaseManifoldResult(ManifoldResult*);
+
+	virtual void ClearManifold(PersistentManifold* manifold);
+
+			
+	CollisionAlgorithm* FindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1);
+	
+	CollisionAlgorithm* InternalFindAlgorithm(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1);
+	
+	virtual bool	NeedsCollision(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1);
+	
+	virtual bool	NeedsResponse(const CollisionObject& colObj0,const CollisionObject& colObj1);
+
+	virtual int GetUniqueId() { return RIGIDBODY_DISPATCHER;}
+	
+	virtual void	DispatchAllCollisionPairs(OverlappingPairCache* pairCache,DispatcherInfo& dispatchInfo);
+
+	
+
+};
+
+#endif //COLLISION__DISPATCHER_H
+

src/BulletCollision/CollisionDispatch/btCollisionObject.cpp

@@ -0,0 +1,56 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btCollisionObject.h"
+
+CollisionObject::CollisionObject()
+	:	m_collisionFlags(0),
+		m_activationState1(1),
+		m_deactivationTime(0.f),
+		m_broadphaseHandle(0),
+		m_collisionShape(0),
+		m_hitFraction(1.f),
+		m_ccdSweptShereRadius(0.f),
+		m_ccdSquareMotionTreshold(0.f)
+{
+	m_cachedInvertedWorldTransform.setIdentity();
+
+}
+
+
+void CollisionObject::SetActivationState(int newState) 
+{ 
+	if ( (m_activationState1 != DISABLE_DEACTIVATION) && (m_activationState1 != DISABLE_SIMULATION))
+		m_activationState1 = newState;
+}
+
+void CollisionObject::ForceActivationState(int newState)
+{
+	m_activationState1 = newState;
+}
+
+void CollisionObject::activate()
+{
+	if (!(m_collisionFlags & isStatic))
+	{
+		SetActivationState(1);
+		m_deactivationTime = 0.f;
+	}
+}
+
+bool CollisionObject::mergesSimulationIslands() const
+{
+	return ( !(m_collisionFlags & isStatic));
+}

src/BulletCollision/CollisionDispatch/btCollisionObject.h

@@ -0,0 +1,132 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef COLLISION_OBJECT_H
+#define COLLISION_OBJECT_H
+
+#include "LinearMath/SimdTransform.h"
+
+//island management, m_activationState1
+#define ACTIVE_TAG 1
+#define ISLAND_SLEEPING 2
+#define WANTS_DEACTIVATION 3
+#define DISABLE_DEACTIVATION 4
+#define DISABLE_SIMULATION 5
+
+struct	BroadphaseProxy;
+class	CollisionShape;
+
+/// CollisionObject can be used to manage collision detection objects. 
+/// CollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy.
+/// They can be added to the CollisionWorld.
+struct	CollisionObject
+{
+	SimdTransform	m_worldTransform;
+	
+	//m_interpolationWorldTransform is used for CCD and interpolation
+	//it can be either previous or future (predicted) transform
+	SimdTransform	m_interpolationWorldTransform;
+
+	SimdTransform	m_cachedInvertedWorldTransform;
+
+	enum CollisionFlags
+	{
+		isStatic = 1,
+		noContactResponse = 2,
+		customMaterialCallback = 4,//this allows per-triangle material (friction/restitution)
+	};
+
+	int				m_collisionFlags;
+
+	int				m_islandTag1;
+	int				m_activationState1;
+	float			m_deactivationTime;
+
+	SimdScalar		m_friction;
+	SimdScalar		m_restitution;
+
+	BroadphaseProxy*	m_broadphaseHandle;
+	CollisionShape*		m_collisionShape;
+
+	//users can point to their objects, m_userPointer is not used by Bullet
+	void*			m_userObjectPointer;
+
+	//m_internalOwner one is used by optional Bullet high level interface
+	void*			m_internalOwner;
+
+	///time of impact calculation
+	float			m_hitFraction; 
+	
+	///Swept sphere radius (0.0 by default), see ConvexConvexAlgorithm::
+	float			m_ccdSweptShereRadius;
+
+	/// Don't do continuous collision detection if square motion (in one step) is less then m_ccdSquareMotionTreshold
+	float			m_ccdSquareMotionTreshold;
+
+	bool			mergesSimulationIslands() const;
+
+	inline bool		IsStatic() const {
+		return m_collisionFlags & isStatic;
+	}
+
+	inline bool		HasContactResponse() {
+		return !(m_collisionFlags & noContactResponse);
+	}
+
+	
+
+
+	CollisionObject();
+
+
+	void	SetCollisionShape(CollisionShape* collisionShape)
+	{
+		m_collisionShape = collisionShape;
+	}
+
+	int	GetActivationState() const { return m_activationState1;}
+	
+	void SetActivationState(int newState);
+
+	void ForceActivationState(int newState);
+
+	void	activate();
+
+	inline bool IsActive() const
+	{
+		return ((GetActivationState() != ISLAND_SLEEPING) && (GetActivationState() != DISABLE_SIMULATION));
+	}
+
+		void	setRestitution(float rest)
+	{
+		m_restitution = rest;
+	}
+	float	getRestitution() const
+	{
+		return m_restitution;
+	}
+	void	setFriction(float frict)
+	{
+		m_friction = frict;
+	}
+	float	getFriction() const
+	{
+		return m_friction;
+	}
+
+
+};
+
+#endif //COLLISION_OBJECT_H

src/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

@@ -0,0 +1,322 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btCollisionWorld.h"
+#include "btCollisionDispatcher.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+#include "BulletCollision/CollisionShapes/btCollisionShape.h"
+#include "BulletCollision/CollisionShapes/btSphereShape.h" //for raycasting
+#include "BulletCollision/CollisionShapes/btTriangleMeshShape.h" //for raycasting
+#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+
+#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+#include "LinearMath/GenAabbUtil2.h"
+
+#include <algorithm>
+
+CollisionWorld::~CollisionWorld()
+{
+	//clean up remaining objects
+	std::vector<CollisionObject*>::iterator i;
+
+	for (i=m_collisionObjects.begin();
+	!(i==m_collisionObjects.end()); i++)
+
+	{
+		CollisionObject* collisionObject= (*i);
+		
+		BroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
+		if (bp)
+		{
+			//
+			// only clear the cached algorithms
+			//
+			GetBroadphase()->CleanProxyFromPairs(bp);
+			GetBroadphase()->DestroyProxy(bp);
+		}
+	}
+
+}
+
+
+
+
+
+
+
+
+
+
+void	CollisionWorld::AddCollisionObject(CollisionObject* collisionObject,short int collisionFilterGroup,short int collisionFilterMask)
+{
+		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,
+			collisionFilterGroup,
+			collisionFilterMask
+			);
+		
+
+
+
+}
+
+void	CollisionWorld::PerformDiscreteCollisionDetection()
+{
+	DispatcherInfo	dispatchInfo;
+	dispatchInfo.m_timeStep = 0.f;
+	dispatchInfo.m_stepCount = 0;
+
+	//update aabb (of all moved objects)
+
+	SimdVector3 aabbMin,aabbMax;
+	for (size_t i=0;i<m_collisionObjects.size();i++)
+	{
+		m_collisionObjects[i]->m_cachedInvertedWorldTransform = m_collisionObjects[i]->m_worldTransform.inverse();
+		m_collisionObjects[i]->m_collisionShape->GetAabb(m_collisionObjects[i]->m_worldTransform,aabbMin,aabbMax);
+		m_pairCache->SetAabb(m_collisionObjects[i]->m_broadphaseHandle,aabbMin,aabbMax);
+	}
+
+	m_pairCache->RefreshOverlappingPairs();
+
+	Dispatcher* dispatcher = GetDispatcher();
+	if (dispatcher)
+		dispatcher->DispatchAllCollisionPairs(m_pairCache,dispatchInfo);
+
+}
+
+
+void	CollisionWorld::RemoveCollisionObject(CollisionObject* collisionObject)
+{
+	
+	
+	//bool removeFromBroadphase = false;
+	
+	{
+		
+		BroadphaseProxy* bp = collisionObject->m_broadphaseHandle;
+		if (bp)
+		{
+			//
+			// only clear the cached algorithms
+			//
+			GetBroadphase()->CleanProxyFromPairs(bp);
+			GetBroadphase()->DestroyProxy(bp);
+			collisionObject->m_broadphaseHandle = 0;
+		}
+	}
+
+
+	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();
+		}
+}
+
+void	CollisionWorld::RayTestSingle(const SimdTransform& rayFromTrans,const SimdTransform& rayToTrans,
+					  CollisionObject* collisionObject,
+					  const CollisionShape* collisionShape,
+					  const SimdTransform& colObjWorldTransform,
+					  RayResultCallback& resultCallback)
+{
+	
+	SphereShape pointShape(0.0f);
+
+	if (collisionShape->IsConvex())
+			{
+				ConvexCast::CastResult castResult;
+				castResult.m_fraction = 1.f;//??
+
+				ConvexShape* convexShape = (ConvexShape*) collisionShape;
+				VoronoiSimplexSolver	simplexSolver;
+				SubsimplexConvexCast convexCaster(&pointShape,convexShape,&simplexSolver);
+				//GjkConvexCast	convexCaster(&pointShape,convexShape,&simplexSolver);
+				//ContinuousConvexCollision convexCaster(&pointShape,convexShape,&simplexSolver,0);
+				
+				if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
+				{
+					//add hit
+					if (castResult.m_normal.length2() > 0.0001f)
+					{
+						castResult.m_normal.normalize();
+						if (castResult.m_fraction < resultCallback.m_closestHitFraction)
+						{
+							
+
+							CollisionWorld::LocalRayResult localRayResult
+								(
+									collisionObject, 
+									0,
+									castResult.m_normal,
+									castResult.m_fraction
+								);
+
+							resultCallback.AddSingleResult(localRayResult);
+
+						}
+					}
+				}
+			}
+			else
+			{
+				
+				if (collisionShape->IsConcave())
+					{
+
+						TriangleMeshShape* triangleMesh = (TriangleMeshShape*)collisionShape;
+						
+						SimdTransform worldTocollisionObject = colObjWorldTransform.inverse();
+
+						SimdVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
+						SimdVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();
+
+						//ConvexCast::CastResult
+
+						struct BridgeTriangleRaycastCallback : public TriangleRaycastCallback 
+						{
+							CollisionWorld::RayResultCallback* m_resultCallback;
+							CollisionObject*	m_collisionObject;
+							TriangleMeshShape*	m_triangleMesh;
+
+							BridgeTriangleRaycastCallback( const SimdVector3& from,const SimdVector3& to,
+								CollisionWorld::RayResultCallback* resultCallback, CollisionObject* collisionObject,TriangleMeshShape*	triangleMesh):
+								TriangleRaycastCallback(from,to),
+									m_resultCallback(resultCallback),
+									m_collisionObject(collisionObject),
+									m_triangleMesh(triangleMesh)
+								{
+								}
+
+
+							virtual float ReportHit(const SimdVector3& hitNormalLocal, float hitFraction, int partId, int triangleIndex )
+							{
+								CollisionWorld::LocalShapeInfo	shapeInfo;
+								shapeInfo.m_shapePart = partId;
+								shapeInfo.m_triangleIndex = triangleIndex;
+								
+								CollisionWorld::LocalRayResult rayResult
+								(m_collisionObject, 
+									&shapeInfo,
+									hitNormalLocal,
+									hitFraction);
+								
+								return m_resultCallback->AddSingleResult(rayResult);
+								
+								
+							}
+	
+						};
+
+
+						BridgeTriangleRaycastCallback	rcb(rayFromLocal,rayToLocal,&resultCallback,collisionObject,triangleMesh);
+						rcb.m_hitFraction = resultCallback.m_closestHitFraction;
+
+						SimdVector3 rayAabbMinLocal = rayFromLocal;
+						rayAabbMinLocal.setMin(rayToLocal);
+						SimdVector3 rayAabbMaxLocal = rayFromLocal;
+						rayAabbMaxLocal.setMax(rayToLocal);
+
+						triangleMesh->ProcessAllTriangles(&rcb,rayAabbMinLocal,rayAabbMaxLocal);
+											
+					} else
+					{
+						//todo: use AABB tree or other BVH acceleration structure!
+						if (collisionShape->IsCompound())
+						{
+							const CompoundShape* compoundShape = static_cast<const CompoundShape*>(collisionShape);
+							int i=0;
+							for (i=0;i<compoundShape->GetNumChildShapes();i++)
+							{
+								SimdTransform childTrans = compoundShape->GetChildTransform(i);
+								const CollisionShape* childCollisionShape = compoundShape->GetChildShape(i);
+								SimdTransform childWorldTrans = colObjWorldTransform * childTrans;
+								RayTestSingle(rayFromTrans,rayToTrans,
+									collisionObject,
+									childCollisionShape,
+									childWorldTrans,
+									resultCallback);
+
+							}
+
+
+						}
+					}
+			}
+}
+
+void	CollisionWorld::RayTest(const SimdVector3& rayFromWorld, const SimdVector3& rayToWorld, RayResultCallback& resultCallback)
+{
+
+	
+	SimdTransform	rayFromTrans,rayToTrans;
+	rayFromTrans.setIdentity();
+	rayFromTrans.setOrigin(rayFromWorld);
+	rayToTrans.setIdentity();
+	
+	rayToTrans.setOrigin(rayToWorld);
+
+	//do culling based on aabb (rayFrom/rayTo)
+	SimdVector3 rayAabbMin = rayFromWorld;
+	SimdVector3 rayAabbMax = rayFromWorld;
+	rayAabbMin.setMin(rayToWorld);
+	rayAabbMax.setMax(rayToWorld);
+
+
+	/// brute force go over all objects. Once there is a broadphase, use that, or
+	/// add a raycast against aabb first.
+	
+	std::vector<CollisionObject*>::iterator iter;
+	
+	for (iter=m_collisionObjects.begin();
+	!(iter==m_collisionObjects.end()); iter++)
+	{
+		
+		CollisionObject*	collisionObject= (*iter);
+
+		//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
+		SimdVector3 collisionObjectAabbMin,collisionObjectAabbMax;
+		collisionObject->m_collisionShape->GetAabb(collisionObject->m_worldTransform,collisionObjectAabbMin,collisionObjectAabbMax);
+
+		//check aabb overlap
+
+		if (TestAabbAgainstAabb2(rayAabbMin,rayAabbMax,collisionObjectAabbMin,collisionObjectAabbMax))
+		{
+			RayTestSingle(rayFromTrans,rayToTrans,
+				collisionObject,
+					 collisionObject->m_collisionShape,
+					  collisionObject->m_worldTransform,
+					  resultCallback);
+			
+		}
+	}
+
+}

src/BulletCollision/CollisionDispatch/btCollisionWorld.h

@@ -0,0 +1,240 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+/**
+ * @mainpage Bullet Documentation
+ *
+ * @section intro_sec Introduction
+ * Bullet Collision Detection & Physics SDK
+ *
+ * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ).
+ *
+ * There is the Physics Forum for Feedback and General Collision Detection and Physics discussions.
+ * Please visit http://www.continuousphysics.com/Bullet/phpBB2/index.php
+ *
+ * @section install_sec Installation
+ *
+ * @subsection step1 Step 1: Download
+ * You can download the Bullet Physics Library from our website: http://www.continuousphysics.com/Bullet/
+ * @subsection step2 Step 2: Building
+ * Bullet comes with autogenerated Project Files for Microsoft Visual Studio 6, 7, 7.1 and 8.
+ * The main Workspace/Solution is located in Bullet/msvc/8/wksbullet.sln (replace 8 with your version).
+ * 
+ * Under other platforms, like Linux or Mac OS-X, Bullet can be build using either using cmake, http://www.cmake.org, or jam, http://www.perforce.com/jam/jam.html . cmake can autogenerate Xcode, KDevelop, MSVC and other build systems. just run cmake . in the root of Bullet.
+ * Jam is a build system that can build the library, demos and also autogenerate the MSVC Project Files.
+ * So if you are not using MSVC, you can run configure and jam .
+ * If you don't have jam installed, you can make jam from the included jam-2.5 sources, or download jam from ftp://ftp.perforce.com/pub/jam/
+ * 
+ * @subsection step3 Step 3: Testing demos
+ * Try to run and experiment with CcdPhysicsDemo executable as a starting point.
+ * Bullet can be used in several ways, as Full Rigid Body simulation, as Collision Detector Library or Low Level / Snippets like the GJK Closest Point calculation.
+ * The Dependencies can be seen in this documentation under Directories
+ * 
+ * @subsection step4 Step 4: Integrating in your application, Full Rigid Body Simulation
+ * Check out CcdPhysicsDemo how to create a CcdPhysicsEnvironment , CollisionShape and RigidBody, Stepping the simulation and synchronizing your derived version of the PHY_IMotionState class.
+ * @subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras)
+ * Bullet Collision Detection can also be used without the Dynamics/Extras.
+ * Check out CollisionWorld and CollisionObject, and the CollisionInterfaceDemo. Also in Extras/test_BulletOde.cpp there is a sample Collision Detection integration with Open Dynamics Engine, ODE, http://www.ode.org
+ * @subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation.
+ * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of GjkPairDetector.
+ *
+ * @section copyright Copyright
+ * Copyright (C) 2005-2006 Erwin Coumans, some contributions Copyright Gino van den Bergen, Christer Ericson, Simon Hobbs, Ricardo Padrela, F Richter(res), Stephane Redon
+ * Special thanks to all visitors of the Bullet Physics forum, and in particular above contributors, Dave Eberle, Dirk Gregorius, Erin Catto, Dave Eberle, Adam Moravanszky,
+ * Pierre Terdiman, Kenny Erleben, Russell Smith, Oliver Strunk, Jan Paul van Waveren.
+ * 
+ */
+ 
+ 
+
+#ifndef COLLISION_WORLD_H
+#define COLLISION_WORLD_H
+
+
+class CollisionShape;
+class BroadphaseInterface;
+#include "LinearMath/SimdVector3.h"
+#include "LinearMath/SimdTransform.h"
+#include "btCollisionObject.h"
+#include "btCollisionDispatcher.h" //for definition of CollisionObjectArray
+#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
+
+#include <vector>
+
+
+
+///CollisionWorld is interface and container for the collision detection
+class CollisionWorld
+{
+
+	
+
+	std::vector<CollisionObject*>	m_collisionObjects;
+	
+	Dispatcher*	m_dispatcher1;
+
+	OverlappingPairCache*	m_pairCache;
+	
+
+public:
+
+	CollisionWorld(Dispatcher* dispatcher,OverlappingPairCache* pairCache)
+		:m_dispatcher1(dispatcher),
+		m_pairCache(pairCache)
+	{
+
+	}
+	virtual ~CollisionWorld();
+
+
+	BroadphaseInterface*	GetBroadphase()
+	{
+		return m_pairCache;
+	}
+
+	OverlappingPairCache*	GetPairCache()
+	{
+		return m_pairCache;
+	}
+
+
+	Dispatcher*	GetDispatcher()
+	{
+		return m_dispatcher1;
+	}
+
+	///LocalShapeInfo gives extra information for complex shapes
+	///Currently, only TriangleMeshShape is available, so it just contains triangleIndex and subpart
+	struct	LocalShapeInfo
+	{
+		int	m_shapePart;
+		int	m_triangleIndex;
+		
+		//const CollisionShape*	m_shapeTemp;
+		//const SimdTransform*	m_shapeLocalTransform;
+	};
+
+	struct	LocalRayResult
+	{
+		LocalRayResult(const CollisionObject*	collisionObject, 
+			LocalShapeInfo*	localShapeInfo,
+			const SimdVector3&		hitNormalLocal,
+			float hitFraction)
+		:m_collisionObject(collisionObject),
+		m_localShapeInfo(m_localShapeInfo),
+		m_hitNormalLocal(hitNormalLocal),
+		m_hitFraction(hitFraction)
+		{
+		}
+
+		const CollisionObject*	m_collisionObject;
+		LocalShapeInfo*			m_localShapeInfo;
+		const SimdVector3&		m_hitNormalLocal;
+		float					m_hitFraction;
+
+	};
+
+	///RayResultCallback is used to report new raycast results
+	struct	RayResultCallback
+	{
+		virtual ~RayResultCallback()
+		{
+		}
+		float	m_closestHitFraction;
+		bool	HasHit()
+		{
+			return (m_closestHitFraction < 1.f);
+		}
+
+		RayResultCallback()
+			:m_closestHitFraction(1.f)
+		{
+		}
+		virtual	float	AddSingleResult(const LocalRayResult& rayResult) = 0;
+	};
+
+	struct	ClosestRayResultCallback : public RayResultCallback
+	{
+		ClosestRayResultCallback(SimdVector3	rayFromWorld,SimdVector3	rayToWorld)
+		:m_rayFromWorld(rayFromWorld),
+		m_rayToWorld(rayToWorld),
+		m_collisionObject(0)
+		{
+		}
+
+		SimdVector3	m_rayFromWorld;//used to calculate hitPointWorld from hitFraction
+		SimdVector3	m_rayToWorld;
+
+		SimdVector3	m_hitNormalWorld;
+		SimdVector3	m_hitPointWorld;
+		const CollisionObject*	m_collisionObject;
+		
+		virtual	float	AddSingleResult(const LocalRayResult& rayResult)
+		{
+
+//caller already does the filter on the m_closestHitFraction
+			assert(rayResult.m_hitFraction <= m_closestHitFraction);
+			
+			m_closestHitFraction = rayResult.m_hitFraction;
+			m_collisionObject = rayResult.m_collisionObject;
+			m_hitNormalWorld = m_collisionObject->m_worldTransform.getBasis()*rayResult.m_hitNormalLocal;
+			m_hitPointWorld.setInterpolate3(m_rayFromWorld,m_rayToWorld,rayResult.m_hitFraction);
+			return rayResult.m_hitFraction;
+		}
+	};
+
+
+	
+
+	int	GetNumCollisionObjects() const
+	{
+		return m_collisionObjects.size();
+	}
+
+	/// RayTest performs a raycast on all objects in the CollisionWorld, and calls the resultCallback
+	/// This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback.
+	void	RayTest(const SimdVector3& rayFromWorld, const SimdVector3& rayToWorld, RayResultCallback& resultCallback);
+
+	/// RayTestSingle performs a raycast call and calls the resultCallback. It is used internally by RayTest.
+	/// In a future implementation, we consider moving the ray test as a virtual method in CollisionShape.
+	/// This allows more customization.
+	void	RayTestSingle(const SimdTransform& rayFromTrans,const SimdTransform& rayToTrans,
+					  CollisionObject* collisionObject,
+					  const CollisionShape* collisionShape,
+					  const SimdTransform& colObjWorldTransform,
+					  RayResultCallback& resultCallback);
+
+	void	AddCollisionObject(CollisionObject* collisionObject,short int collisionFilterGroup=1,short int collisionFilterMask=1);
+
+	CollisionObjectArray& GetCollisionObjectArray()
+	{
+		return m_collisionObjects;
+	}
+
+	const CollisionObjectArray& GetCollisionObjectArray() const
+	{
+		return m_collisionObjects;
+	}
+
+
+	void	RemoveCollisionObject(CollisionObject* collisionObject);
+
+	virtual void	PerformDiscreteCollisionDetection();
+
+};
+
+
+#endif //COLLISION_WORLD_H

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

@@ -0,0 +1,146 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+
+
+CompoundCollisionAlgorithm::CompoundCollisionAlgorithm( const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+:m_dispatcher(ci.m_dispatcher),
+m_compoundProxy(*proxy0),
+m_otherProxy(*proxy1)
+{
+	CollisionObject* colObj = static_cast<CollisionObject*>(m_compoundProxy.m_clientObject);
+	assert (colObj->m_collisionShape->IsCompound());
+	
+	CompoundShape* compoundShape = static_cast<CompoundShape*>(colObj->m_collisionShape);
+	int numChildren = compoundShape->GetNumChildShapes();
+	m_childProxies.resize( numChildren );
+	int i;
+	for (i=0;i<numChildren;i++)
+	{
+		m_childProxies[i] = BroadphaseProxy(*proxy0);
+	}
+
+	m_childCollisionAlgorithms.resize(numChildren);
+	for (i=0;i<numChildren;i++)
+	{
+		CollisionShape* childShape = compoundShape->GetChildShape(i);
+		CollisionObject* colObj = static_cast<CollisionObject*>(m_childProxies[i].m_clientObject);
+		CollisionShape* orgShape = colObj->m_collisionShape;
+		colObj->m_collisionShape = childShape;
+		m_childCollisionAlgorithms[i] = m_dispatcher->FindAlgorithm(m_childProxies[i],m_otherProxy);
+		colObj->m_collisionShape =orgShape;
+	}
+}
+
+
+CompoundCollisionAlgorithm::~CompoundCollisionAlgorithm()
+{
+	int numChildren = m_childCollisionAlgorithms.size();
+	int i;
+	for (i=0;i<numChildren;i++)
+	{
+		delete m_childCollisionAlgorithms[i];
+	}
+}
+
+void CompoundCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy* ,const DispatcherInfo& dispatchInfo)
+{
+	CollisionObject* colObj = static_cast<CollisionObject*>(m_compoundProxy.m_clientObject);
+	assert (colObj->m_collisionShape->IsCompound());
+	
+	CompoundShape* compoundShape = static_cast<CompoundShape*>(colObj->m_collisionShape);
+
+	//We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
+	//If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
+	//given Proxy0 and Proxy1, if both have a tree, Tree0 and Tree1, this means:
+	//determine overlapping nodes of Proxy1 using Proxy0 AABB against Tree1
+	//then use each overlapping node AABB against Tree0
+	//and vise versa.
+
+
+	int numChildren = m_childCollisionAlgorithms.size();
+	int i;
+	for (i=0;i<numChildren;i++)
+	{
+		//temporarily exchange parent CollisionShape with childShape, and recurse
+		CollisionShape* childShape = compoundShape->GetChildShape(i);
+		CollisionObject* colObj = static_cast<CollisionObject*>(m_childProxies[i].m_clientObject);
+
+		//backup
+		SimdTransform	orgTrans = colObj->m_worldTransform;
+		CollisionShape* orgShape = colObj->m_collisionShape;
+
+		SimdTransform childTrans = compoundShape->GetChildTransform(i);
+		SimdTransform	newChildWorldTrans = orgTrans*childTrans ;
+		colObj->m_worldTransform = newChildWorldTrans;
+
+		colObj->m_collisionShape = childShape;
+		m_childCollisionAlgorithms[i]->ProcessCollision(&m_childProxies[i],&m_otherProxy,dispatchInfo);
+		//revert back
+		colObj->m_collisionShape =orgShape;
+		colObj->m_worldTransform = orgTrans;
+	}
+}
+
+float	CompoundCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+{
+	CollisionObject* colObj = static_cast<CollisionObject*>(m_compoundProxy.m_clientObject);
+	assert (colObj->m_collisionShape->IsCompound());
+	
+	CompoundShape* compoundShape = static_cast<CompoundShape*>(colObj->m_collisionShape);
+
+	//We will use the OptimizedBVH, AABB tree to cull potential child-overlaps
+	//If both proxies are Compound, we will deal with that directly, by performing sequential/parallel tree traversals
+	//given Proxy0 and Proxy1, if both have a tree, Tree0 and Tree1, this means:
+	//determine overlapping nodes of Proxy1 using Proxy0 AABB against Tree1
+	//then use each overlapping node AABB against Tree0
+	//and vise versa.
+
+	float hitFraction = 1.f;
+
+	int numChildren = m_childCollisionAlgorithms.size();
+	int i;
+	for (i=0;i<numChildren;i++)
+	{
+		//temporarily exchange parent CollisionShape with childShape, and recurse
+		CollisionShape* childShape = compoundShape->GetChildShape(i);
+		CollisionObject* colObj = static_cast<CollisionObject*>(m_childProxies[i].m_clientObject);
+
+		//backup
+		SimdTransform	orgTrans = colObj->m_worldTransform;
+		CollisionShape* orgShape = colObj->m_collisionShape;
+
+		SimdTransform childTrans = compoundShape->GetChildTransform(i);
+		SimdTransform	newChildWorldTrans = orgTrans*childTrans ;
+		colObj->m_worldTransform = newChildWorldTrans;
+
+		colObj->m_collisionShape = childShape;
+		float frac = m_childCollisionAlgorithms[i]->CalculateTimeOfImpact(&m_childProxies[i],&m_otherProxy,dispatchInfo);
+		if (frac<hitFraction)
+		{
+			hitFraction = frac;
+		}
+		//revert back
+		colObj->m_collisionShape =orgShape;
+		colObj->m_worldTransform = orgTrans;
+	}
+	return hitFraction;
+
+}
+
+

src/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h

@@ -0,0 +1,72 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef COMPOUND_COLLISION_ALGORITHM_H
+#define COMPOUND_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+class Dispatcher;
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include <vector>
+#include "btCollisionCreateFunc.h"
+
+/// CompoundCollisionAlgorithm  supports collision between CompoundCollisionShapes and other collision shapes
+/// Place holder, not fully implemented yet
+class CompoundCollisionAlgorithm  : public CollisionAlgorithm
+{
+	Dispatcher*	m_dispatcher;
+	BroadphaseProxy	m_compoundProxy;
+	BroadphaseProxy	m_otherProxy;
+	std::vector<BroadphaseProxy> m_childProxies;
+	std::vector<CollisionAlgorithm*> m_childCollisionAlgorithms;
+
+	BroadphaseProxy m_compound;
+
+	BroadphaseProxy m_other;
+
+	
+public:
+
+	CompoundCollisionAlgorithm( const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+
+	virtual ~CompoundCollisionAlgorithm();
+
+	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	float	CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	{
+		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		{
+			return new CompoundCollisionAlgorithm(ci,proxy0,proxy1);
+		}
+	};
+
+	struct SwappedCreateFunc :public 	CollisionAlgorithmCreateFunc
+	{
+		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		{
+			return new CompoundCollisionAlgorithm(ci,proxy1,proxy0);
+		}
+	};
+
+};
+
+#endif //COMPOUND_COLLISION_ALGORITHM_H

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

@@ -0,0 +1,307 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "btConvexConcaveCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+#include "BulletCollision/CollisionShapes/btMultiSphereShape.h"
+#include "btConvexConvexAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionShapes/btConcaveShape.h"
+#include "BulletCollision/CollisionDispatch/btManifoldResult.h"
+#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
+#include "BulletCollision/CollisionShapes/btTriangleShape.h"
+#include "BulletCollision/CollisionShapes/btSphereShape.h"
+#include "LinearMath/GenIDebugDraw.h"
+#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
+
+ConvexConcaveCollisionAlgorithm::ConvexConcaveCollisionAlgorithm( const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+: CollisionAlgorithm(ci),m_convex(*proxy0),m_concave(*proxy1),
+m_ConvexTriangleCallback(ci.m_dispatcher,proxy0,proxy1)
+
+{
+}
+
+ConvexConcaveCollisionAlgorithm::~ConvexConcaveCollisionAlgorithm()
+{
+}
+
+
+
+ConvexTriangleCallback::ConvexTriangleCallback(Dispatcher*  dispatcher,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1):
+  m_convexProxy(proxy0),m_triangleProxy(*proxy1),m_dispatcher(dispatcher),
+	m_dispatchInfoPtr(0)
+{
+
+	  //
+	  // create the manifold from the dispatcher 'manifold pool'
+	  //
+	  m_manifoldPtr = m_dispatcher->GetNewManifold(proxy0->m_clientObject,proxy1->m_clientObject);
+
+  	  ClearCache();
+}
+
+ConvexTriangleCallback::~ConvexTriangleCallback()
+{
+	ClearCache();
+	m_dispatcher->ReleaseManifold( m_manifoldPtr );
+  
+}
+  
+
+void	ConvexTriangleCallback::ClearCache()
+{
+	m_dispatcher->ClearManifold(m_manifoldPtr);
+};
+
+
+
+void ConvexTriangleCallback::ProcessTriangle(SimdVector3* triangle,int partId, int triangleIndex)
+{
+ 
+	//just for debugging purposes
+	//printf("triangle %d",m_triangleCount++);
+
+
+	//aabb filter is already applied!	
+
+	CollisionAlgorithmConstructionInfo ci;
+	ci.m_dispatcher = m_dispatcher;
+
+	CollisionObject* ob = static_cast<CollisionObject*>(m_triangleProxy.m_clientObject);
+
+
+	
+	///debug drawing of the overlapping triangles
+	if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && m_dispatchInfoPtr->m_debugDraw->GetDebugMode() > 0)
+	{
+		SimdVector3 color(255,255,0);
+		SimdTransform& tr = ob->m_worldTransform;
+		m_dispatchInfoPtr->m_debugDraw->DrawLine(tr(triangle[0]),tr(triangle[1]),color);
+		m_dispatchInfoPtr->m_debugDraw->DrawLine(tr(triangle[1]),tr(triangle[2]),color);
+		m_dispatchInfoPtr->m_debugDraw->DrawLine(tr(triangle[2]),tr(triangle[0]),color);
+
+		//SimdVector3 center = triangle[0] + triangle[1]+triangle[2];
+		//center *= 0.333333f;
+		//m_dispatchInfoPtr->m_debugDraw->DrawLine(tr(triangle[0]),tr(center),color);
+		//m_dispatchInfoPtr->m_debugDraw->DrawLine(tr(triangle[1]),tr(center),color);
+		//m_dispatchInfoPtr->m_debugDraw->DrawLine(tr(triangle[2]),tr(center),color);
+
+	}
+
+
+	CollisionObject* colObj = static_cast<CollisionObject*>(m_convexProxy->m_clientObject);
+	
+	if (colObj->m_collisionShape->IsConvex())
+	{
+		TriangleShape tm(triangle[0],triangle[1],triangle[2]);	
+		tm.SetMargin(m_collisionMarginTriangle);
+	
+		
+		CollisionShape* tmpShape = ob->m_collisionShape;
+		ob->m_collisionShape = &tm;
+		
+		///this should use the Dispatcher, so the actual registered algorithm is used
+		ConvexConvexAlgorithm cvxcvxalgo(m_manifoldPtr,ci,m_convexProxy,&m_triangleProxy);
+		cvxcvxalgo.SetShapeIdentifiers(-1,-1,partId,triangleIndex);
+		cvxcvxalgo.ProcessCollision(m_convexProxy,&m_triangleProxy,*m_dispatchInfoPtr);
+		ob->m_collisionShape = tmpShape;
+
+	}
+
+	
+
+}
+
+
+
+void	ConvexTriangleCallback::SetTimeStepAndCounters(float collisionMarginTriangle,const DispatcherInfo& dispatchInfo)
+{
+	m_dispatchInfoPtr = &dispatchInfo;
+	m_collisionMarginTriangle = collisionMarginTriangle;
+
+	//recalc aabbs
+	CollisionObject* convexBody = (CollisionObject* )m_convexProxy->m_clientObject;
+	CollisionObject* triBody = (CollisionObject* )m_triangleProxy.m_clientObject;
+
+	SimdTransform convexInTriangleSpace;
+	convexInTriangleSpace = triBody->m_worldTransform.inverse() * convexBody->m_worldTransform;
+
+	CollisionShape* convexShape = static_cast<CollisionShape*>(convexBody->m_collisionShape);
+	//CollisionShape* triangleShape = static_cast<CollisionShape*>(triBody->m_collisionShape);
+
+	convexShape->GetAabb(convexInTriangleSpace,m_aabbMin,m_aabbMax);
+
+	float extraMargin = collisionMarginTriangle;//CONVEX_DISTANCE_MARGIN;//+0.1f;
+
+	SimdVector3 extra(extraMargin,extraMargin,extraMargin);
+
+	m_aabbMax += extra;
+	m_aabbMin -= extra;
+	
+}
+
+void ConvexConcaveCollisionAlgorithm::ClearCache()
+{
+	m_ConvexTriangleCallback.ClearCache();
+
+}
+
+void ConvexConcaveCollisionAlgorithm::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy* ,const DispatcherInfo& dispatchInfo)
+{
+	
+	CollisionObject* convexBody = static_cast<CollisionObject* >(m_convex.m_clientObject);
+	CollisionObject* triBody = static_cast<CollisionObject* >(m_concave.m_clientObject);
+
+	if (triBody->m_collisionShape->IsConcave())
+	{
+
+		if (!m_dispatcher->NeedsCollision(m_convex,m_concave))
+			return;
+
+		
+
+		CollisionObject*	triOb = static_cast<CollisionObject*>(m_concave.m_clientObject);
+		ConcaveShape* concaveShape = static_cast<ConcaveShape*>( triOb->m_collisionShape);
+		
+		if (convexBody->m_collisionShape->IsConvex())
+		{
+			float collisionMarginTriangle = concaveShape->GetMargin();
+					
+			m_ConvexTriangleCallback.SetTimeStepAndCounters(collisionMarginTriangle,dispatchInfo);
+
+			//Disable persistency. previously, some older algorithm calculated all contacts in one go, so you can clear it here.
+			//m_dispatcher->ClearManifold(m_ConvexTriangleCallback.m_manifoldPtr);
+
+
+			m_ConvexTriangleCallback.m_manifoldPtr->SetBodies(m_convex.m_clientObject,m_concave.m_clientObject);
+
+			concaveShape->ProcessAllTriangles( &m_ConvexTriangleCallback,m_ConvexTriangleCallback.GetAabbMin(),m_ConvexTriangleCallback.GetAabbMax());
+			
+	
+		}
+
+	}
+
+}
+
+
+float ConvexConcaveCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* ,BroadphaseProxy* ,const DispatcherInfo& dispatchInfo)
+{
+
+	//quick approximation using raycast, todo: hook up to the continuous collision detection (one of the ConvexCast)
+	CollisionObject* convexbody = (CollisionObject* )m_convex.m_clientObject;
+	CollisionObject* triBody = static_cast<CollisionObject* >(m_concave.m_clientObject);
+
+	//only perform CCD above a certain treshold, this prevents blocking on the long run
+	//because object in a blocked ccd state (hitfraction<1) get their linear velocity halved each frame...
+	float squareMot0 = (convexbody->m_interpolationWorldTransform.getOrigin() - convexbody->m_worldTransform.getOrigin()).length2();
+	if (squareMot0 < convexbody->m_ccdSquareMotionTreshold)
+	{
+		return 1.f;
+	}
+
+	//const SimdVector3& from = convexbody->m_worldTransform.getOrigin();
+	//SimdVector3 to = convexbody->m_interpolationWorldTransform.getOrigin();
+	//todo: only do if the motion exceeds the 'radius'
+
+	SimdTransform convexFromLocal = triBody->m_cachedInvertedWorldTransform * convexbody->m_worldTransform;
+	SimdTransform convexToLocal = triBody->m_cachedInvertedWorldTransform * convexbody->m_interpolationWorldTransform;
+
+	struct LocalTriangleSphereCastCallback	: public TriangleCallback
+	{
+		SimdTransform m_ccdSphereFromTrans;
+		SimdTransform m_ccdSphereToTrans;
+		SimdTransform	m_meshTransform;
+
+		float	m_ccdSphereRadius;
+		float	m_hitFraction;
+	
+
+		LocalTriangleSphereCastCallback(const SimdTransform& from,const SimdTransform& to,float ccdSphereRadius,float hitFraction)
+			:m_ccdSphereFromTrans(from),
+			m_ccdSphereToTrans(to),
+			m_ccdSphereRadius(ccdSphereRadius),
+			m_hitFraction(hitFraction)
+		{			
+		}
+		
+		
+		virtual void ProcessTriangle(SimdVector3* triangle, int partId, int triangleIndex)
+		{
+			//do a swept sphere for now
+			SimdTransform ident;
+			ident.setIdentity();
+			ConvexCast::CastResult castResult;
+			castResult.m_fraction = m_hitFraction;
+			SphereShape	pointShape(m_ccdSphereRadius);
+			TriangleShape	triShape(triangle[0],triangle[1],triangle[2]);
+			VoronoiSimplexSolver	simplexSolver;
+			SubsimplexConvexCast convexCaster(&pointShape,&triShape,&simplexSolver);
+			//GjkConvexCast	convexCaster(&pointShape,convexShape,&simplexSolver);
+			//ContinuousConvexCollision convexCaster(&pointShape,convexShape,&simplexSolver,0);
+			//local space?
+
+			if (convexCaster.calcTimeOfImpact(m_ccdSphereFromTrans,m_ccdSphereToTrans,
+				ident,ident,castResult))
+			{
+				if (m_hitFraction > castResult.m_fraction)
+					m_hitFraction = castResult.m_fraction;
+			}
+
+		}
+
+	};
+
+
+	
+
+	
+	if (triBody->m_collisionShape->IsConcave())
+	{
+		SimdVector3 rayAabbMin = convexFromLocal.getOrigin();
+		rayAabbMin.setMin(convexToLocal.getOrigin());
+		SimdVector3 rayAabbMax = convexFromLocal.getOrigin();
+		rayAabbMax.setMax(convexToLocal.getOrigin());
+		rayAabbMin -= SimdVector3(convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius);
+		rayAabbMax += SimdVector3(convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius,convexbody->m_ccdSweptShereRadius);
+
+		float curHitFraction = 1.f; //is this available?
+		LocalTriangleSphereCastCallback raycastCallback(convexFromLocal,convexToLocal,
+		convexbody->m_ccdSweptShereRadius,curHitFraction);
+
+		raycastCallback.m_hitFraction = convexbody->m_hitFraction;
+
+		CollisionObject* concavebody = (CollisionObject* )m_concave.m_clientObject;
+
+		ConcaveShape* triangleMesh = (ConcaveShape*) concavebody->m_collisionShape;
+		
+		if (triangleMesh)
+		{
+			triangleMesh->ProcessAllTriangles(&raycastCallback,rayAabbMin,rayAabbMax);
+		}
+	
+
+
+		if (raycastCallback.m_hitFraction < convexbody->m_hitFraction)
+		{
+			convexbody->m_hitFraction = raycastCallback.m_hitFraction;
+			return raycastCallback.m_hitFraction;
+		}
+	}
+
+	return 1.f;
+
+}

src/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h

@@ -0,0 +1,111 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef CONVEX_CONCAVE_COLLISION_ALGORITHM_H
+#define CONVEX_CONCAVE_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+#include "BulletCollision/CollisionShapes/btTriangleCallback.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+class Dispatcher;
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "btCollisionCreateFunc.h"
+
+///For each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), ProcessTriangle is called.
+class ConvexTriangleCallback : public TriangleCallback
+{
+	BroadphaseProxy* m_convexProxy;
+	BroadphaseProxy m_triangleProxy;
+
+	SimdVector3	m_aabbMin;
+	SimdVector3	m_aabbMax ;
+
+	Dispatcher*	m_dispatcher;
+	const DispatcherInfo* m_dispatchInfoPtr;
+	float m_collisionMarginTriangle;
+	
+public:
+int	m_triangleCount;
+	
+	PersistentManifold*	m_manifoldPtr;
+
+	ConvexTriangleCallback(Dispatcher* dispatcher,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+
+	void	SetTimeStepAndCounters(float collisionMarginTriangle,const DispatcherInfo& dispatchInfo);
+
+	virtual ~ConvexTriangleCallback();
+
+	virtual void ProcessTriangle(SimdVector3* triangle, int partId, int triangleIndex);
+	
+	void ClearCache();
+
+	inline const SimdVector3& GetAabbMin() const
+	{
+		return m_aabbMin;
+	}
+	inline const SimdVector3& GetAabbMax() const
+	{
+		return m_aabbMax;
+	}
+
+};
+
+
+
+
+/// ConvexConcaveCollisionAlgorithm  supports collision between convex shapes and (concave) trianges meshes.
+class ConvexConcaveCollisionAlgorithm  : public CollisionAlgorithm
+{
+
+	BroadphaseProxy m_convex;
+
+	BroadphaseProxy m_concave;
+
+	ConvexTriangleCallback m_ConvexTriangleCallback;
+
+
+public:
+
+	ConvexConcaveCollisionAlgorithm( const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+
+	virtual ~ConvexConcaveCollisionAlgorithm();
+
+	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	float	CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	void	ClearCache();
+
+	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	{
+		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		{
+			return new ConvexConcaveCollisionAlgorithm(ci,proxy0,proxy1);
+		}
+	};
+
+	struct SwappedCreateFunc :public 	CollisionAlgorithmCreateFunc
+	{
+		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		{
+			return new ConvexConcaveCollisionAlgorithm(ci,proxy1,proxy0);
+		}
+	};
+
+};
+
+#endif //CONVEX_CONCAVE_COLLISION_ALGORITHM_H

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

@@ -0,0 +1,431 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btConvexConvexAlgorithm.h"
+
+#include <stdio.h>
+#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+#include "BulletCollision/CollisionShapes/btConvexShape.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "BulletCollision/CollisionShapes/btBoxShape.h"
+#include "BulletCollision/CollisionDispatch/btManifoldResult.h"
+
+#include "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h"
+#include "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h"
+#include "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h"
+
+
+
+#include "BulletCollision/CollisionShapes/btMinkowskiSumShape.h"
+#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+#include "BulletCollision/CollisionShapes/btSphereShape.h"
+
+#include "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h"
+
+//#include "NarrowPhaseCollision/EpaPenetrationDepthSolver.h"
+
+#ifdef WIN32
+#if _MSC_VER >= 1310
+//only use SIMD Hull code under Win32
+#ifdef TEST_HULL
+#define USE_HULL 1
+#endif //TEST_HULL
+#endif //_MSC_VER 
+#endif //WIN32
+
+
+#ifdef USE_HULL
+
+#include "NarrowPhaseCollision/Hull.h"
+#include "NarrowPhaseCollision/HullContactCollector.h"
+
+
+#endif //USE_HULL
+
+bool gUseEpa = false;
+
+
+#ifdef WIN32
+void DrawRasterizerLine(const float* from,const float* to,int color);
+#endif
+
+
+
+
+//#define PROCESS_SINGLE_CONTACT
+#ifdef WIN32
+bool gForceBoxBox = false;//false;//true;
+
+#else
+bool gForceBoxBox = false;//false;//true;
+#endif
+bool gBoxBoxUseGjk = true;//true;//false;
+bool gDisableConvexCollision = false;
+
+
+
+ConvexConvexAlgorithm::ConvexConvexAlgorithm(PersistentManifold* mf,const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+: CollisionAlgorithm(ci),
+m_gjkPairDetector(0,0,&m_simplexSolver,0),
+m_useEpa(!gUseEpa),
+m_box0(*proxy0),
+m_box1(*proxy1),
+m_ownManifold (false),
+m_manifoldPtr(mf),
+m_lowLevelOfDetail(false)
+{
+	CheckPenetrationDepthSolver();
+
+	{
+		if (!m_manifoldPtr && m_dispatcher->NeedsCollision(m_box0,m_box1))
+		{
+			m_manifoldPtr = m_dispatcher->GetNewManifold(proxy0->m_clientObject,proxy1->m_clientObject);
+			m_ownManifold = true;
+		}
+	}
+
+}
+
+
+
+ConvexConvexAlgorithm::~ConvexConvexAlgorithm()
+{
+	if (m_ownManifold)
+	{
+		if (m_manifoldPtr)
+			m_dispatcher->ReleaseManifold(m_manifoldPtr);
+	}
+}
+
+void	ConvexConvexAlgorithm ::SetLowLevelOfDetail(bool useLowLevel)
+{
+	m_lowLevelOfDetail = useLowLevel;
+}
+
+
+
+class FlippedContactResult : public DiscreteCollisionDetectorInterface::Result
+{
+	DiscreteCollisionDetectorInterface::Result* m_org;
+
+public:
+
+	FlippedContactResult(DiscreteCollisionDetectorInterface::Result* org)
+		: m_org(org)
+	{
+
+	}
+
+	virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)
+	{
+		SimdVector3 flippedNormal = -normalOnBInWorld;
+
+		m_org->AddContactPoint(flippedNormal,pointInWorld,depth);
+	}
+
+};
+
+static MinkowskiPenetrationDepthSolver	gPenetrationDepthSolver;
+
+//static EpaPenetrationDepthSolver	gEpaPenetrationDepthSolver;
+
+#ifdef USE_EPA
+Solid3EpaPenetrationDepth	gSolidEpaPenetrationSolver;
+#endif //USE_EPA
+
+void	ConvexConvexAlgorithm::CheckPenetrationDepthSolver()
+{
+	if (m_useEpa != gUseEpa)
+	{
+		m_useEpa  = gUseEpa;
+		if (m_useEpa)
+		{
+			
+		//	m_gjkPairDetector.SetPenetrationDepthSolver(&gEpaPenetrationDepthSolver);
+						
+			
+		} else
+		{
+			m_gjkPairDetector.SetPenetrationDepthSolver(&gPenetrationDepthSolver);
+		}
+	}
+	
+}
+
+#ifdef USE_HULL
+
+Transform	GetTransformFromSimdTransform(const SimdTransform& trans)
+{
+			//const SimdVector3& rowA0 = trans.getBasis().getRow(0);
+			////const SimdVector3& rowA1 = trans.getBasis().getRow(1);
+			//const SimdVector3& rowA2 = trans.getBasis().getRow(2);
+
+			SimdVector3 rowA0 = trans.getBasis().getColumn(0);
+			SimdVector3 rowA1 = trans.getBasis().getColumn(1);
+			SimdVector3 rowA2 = trans.getBasis().getColumn(2);
+
+
+			Vector3	x(rowA0.getX(),rowA0.getY(),rowA0.getZ());
+			Vector3	y(rowA1.getX(),rowA1.getY(),rowA1.getZ());
+			Vector3	z(rowA2.getX(),rowA2.getY(),rowA2.getZ());
+			
+			Matrix33 ornA(x,y,z);
+	
+			Point3 transA(
+				trans.getOrigin().getX(),
+				trans.getOrigin().getY(),
+				trans.getOrigin().getZ());
+
+			return Transform(ornA,transA);
+}
+
+class ManifoldResultCollector : public HullContactCollector
+{
+public:
+	ManifoldResult& m_manifoldResult;
+
+	ManifoldResultCollector(ManifoldResult& manifoldResult)
+		:m_manifoldResult(manifoldResult)
+	{
+
+	}
+	
+
+	virtual ~ManifoldResultCollector() {};
+
+	virtual int	BatchAddContactGroup(const Separation& sep,int numContacts,const Vector3& normalWorld,const Vector3& tangent,const Point3* positionsWorld,const float* depths)
+	{
+		for (int i=0;i<numContacts;i++)
+		{
+			//printf("numContacts = %i\n",numContacts);
+			SimdVector3 normalOnBInWorld(sep.m_axis.GetX(),sep.m_axis.GetY(),sep.m_axis.GetZ());
+			//normalOnBInWorld.normalize();
+			SimdVector3 pointInWorld(positionsWorld[i].GetX(),positionsWorld[i].GetY(),positionsWorld[i].GetZ());
+			float depth = -depths[i];
+			m_manifoldResult.AddContactPoint(normalOnBInWorld,pointInWorld,depth);
+
+		}
+		return 0;
+	}
+
+	virtual int		GetMaxNumContacts() const
+	{
+		return 4;
+	}
+
+};
+#endif //USE_HULL
+
+
+//
+// Convex-Convex collision algorithm
+//
+void ConvexConvexAlgorithm ::ProcessCollision (BroadphaseProxy* ,BroadphaseProxy* ,const DispatcherInfo& dispatchInfo)
+{
+
+	if (!m_manifoldPtr)
+		return;
+
+	CheckPenetrationDepthSolver();
+
+//	printf("ConvexConvexAlgorithm::ProcessCollision\n");
+
+	bool needsCollision = m_dispatcher->NeedsCollision(m_box0,m_box1);
+	if (!needsCollision)
+		return;
+	
+	CollisionObject*	col0 = static_cast<CollisionObject*>(m_box0.m_clientObject);
+	CollisionObject*	col1 = static_cast<CollisionObject*>(m_box1.m_clientObject);
+
+#ifdef USE_HULL
+
+
+	if (dispatchInfo.m_enableSatConvex)
+	{
+		if ((col0->m_collisionShape->IsPolyhedral()) &&
+			(col1->m_collisionShape->IsPolyhedral()))
+		{
+		
+			
+			PolyhedralConvexShape* polyhedron0 = static_cast<PolyhedralConvexShape*>(col0->m_collisionShape);
+			PolyhedralConvexShape* polyhedron1 = static_cast<PolyhedralConvexShape*>(col1->m_collisionShape);
+			if (polyhedron0->m_optionalHull && polyhedron1->m_optionalHull)
+			{
+				//printf("Hull-Hull");
+
+				//todo: cache this information, rather then initialize
+				Separation sep;
+				sep.m_featureA = 0;
+				sep.m_featureB = 0;
+				sep.m_contact = -1;
+				sep.m_separator = 0;
+
+				//convert from SimdTransform to Transform
+				
+				Transform trA = GetTransformFromSimdTransform(col0->m_worldTransform);
+				Transform trB = GetTransformFromSimdTransform(col1->m_worldTransform);
+
+				//either use persistent manifold or clear it every time
+				m_dispatcher->ClearManifold(m_manifoldPtr);
+				ManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
+
+				ManifoldResultCollector hullContactCollector(*resultOut);
+				
+				Hull::ProcessHullHull(sep,*polyhedron0->m_optionalHull,*polyhedron1->m_optionalHull,
+					trA,trB,&hullContactCollector);
+
+				
+				//user provided hull's, so we use SAT Hull collision detection
+				return;
+			}
+		}
+	}
+
+#endif //USE_HULL
+
+	
+	ManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
+	
+	ConvexShape* min0 = static_cast<ConvexShape*>(col0->m_collisionShape);
+	ConvexShape* min1 = static_cast<ConvexShape*>(col1->m_collisionShape);
+	
+	GjkPairDetector::ClosestPointInput input;
+
+
+	//TODO: if (dispatchInfo.m_useContinuous)
+	m_gjkPairDetector.SetMinkowskiA(min0);
+	m_gjkPairDetector.SetMinkowskiB(min1);
+	input.m_maximumDistanceSquared = min0->GetMargin() + min1->GetMargin() + m_manifoldPtr->GetContactBreakingTreshold();
+	input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
+	
+//	input.m_maximumDistanceSquared = 1e30f;
+	
+	input.m_transformA = col0->m_worldTransform;
+	input.m_transformB = col1->m_worldTransform;
+    
+	m_gjkPairDetector.GetClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
+
+	m_dispatcher->ReleaseManifoldResult(resultOut);
+}
+
+
+
+bool disableCcd = false;
+float	ConvexConvexAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+{
+	///Rather then checking ALL pairs, only calculate TOI when motion exceeds treshold
+    
+	///Linear motion for one of objects needs to exceed m_ccdSquareMotionTreshold
+	///col0->m_worldTransform,
+	float resultFraction = 1.f;
+
+	CollisionObject* col1 = static_cast<CollisionObject*>(m_box1.m_clientObject);
+	CollisionObject* col0 = static_cast<CollisionObject*>(m_box0.m_clientObject);
+
+	float squareMot0 = (col0->m_interpolationWorldTransform.getOrigin() - col0->m_worldTransform.getOrigin()).length2();
+    
+	if (squareMot0 < col0->m_ccdSquareMotionTreshold &&
+		squareMot0 < col0->m_ccdSquareMotionTreshold)
+		return resultFraction;
+
+
+
+	if (disableCcd)
+		return 1.f;
+
+	CheckPenetrationDepthSolver();
+
+	//An adhoc way of testing the Continuous Collision Detection algorithms
+	//One object is approximated as a sphere, to simplify things
+	//Starting in penetration should report no time of impact
+	//For proper CCD, better accuracy and handling of 'allowed' penetration should be added
+	//also the mainloop of the physics should have a kind of toi queue (something like Brian Mirtich's application of Timewarp for Rigidbodies)
+
+	bool needsCollision = m_dispatcher->NeedsCollision(m_box0,m_box1);
+
+	if (!needsCollision)
+		return 1.f;
+	
+		
+	/// Convex0 against sphere for Convex1
+	{
+		ConvexShape* convex0 = static_cast<ConvexShape*>(col0->m_collisionShape);
+
+		SphereShape	sphere1(col1->m_ccdSweptShereRadius); //todo: allow non-zero sphere sizes, for better approximation
+		ConvexCast::CastResult result;
+		VoronoiSimplexSolver voronoiSimplex;
+		//SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex);
+		///Simplification, one object is simplified as a sphere
+		GjkConvexCast ccd1( convex0 ,&sphere1,&voronoiSimplex);
+		//ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0);
+		if (ccd1.calcTimeOfImpact(col0->m_worldTransform,col0->m_interpolationWorldTransform,
+			col1->m_worldTransform,col1->m_interpolationWorldTransform,result))
+		{
+		
+			//store result.m_fraction in both bodies
+		
+			if (col0->m_hitFraction	> result.m_fraction)
+				col0->m_hitFraction  = result.m_fraction;
+
+			if (col1->m_hitFraction > result.m_fraction)
+				col1->m_hitFraction  = result.m_fraction;
+
+			if (resultFraction > result.m_fraction)
+				resultFraction = result.m_fraction;
+
+		}
+		
+		
+
+
+	}
+
+	/// Sphere (for convex0) against Convex1
+	{
+		ConvexShape* convex1 = static_cast<ConvexShape*>(col1->m_collisionShape);
+
+		SphereShape	sphere0(col0->m_ccdSweptShereRadius); //todo: allow non-zero sphere sizes, for better approximation
+		ConvexCast::CastResult result;
+		VoronoiSimplexSolver voronoiSimplex;
+		//SubsimplexConvexCast ccd0(&sphere,min0,&voronoiSimplex);
+		///Simplification, one object is simplified as a sphere
+		GjkConvexCast ccd1(&sphere0,convex1,&voronoiSimplex);
+		//ContinuousConvexCollision ccd(min0,min1,&voronoiSimplex,0);
+		if (ccd1.calcTimeOfImpact(col0->m_worldTransform,col0->m_interpolationWorldTransform,
+			col1->m_worldTransform,col1->m_interpolationWorldTransform,result))
+		{
+		
+			//store result.m_fraction in both bodies
+		
+			if (col0->m_hitFraction	> result.m_fraction)
+				col0->m_hitFraction  = result.m_fraction;
+
+			if (col1->m_hitFraction > result.m_fraction)
+				col1->m_hitFraction  = result.m_fraction;
+
+			if (resultFraction > result.m_fraction)
+				resultFraction = result.m_fraction;
+
+		}
+	}
+	
+	return resultFraction;
+
+}

src/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h

@@ -0,0 +1,83 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef CONVEX_CONVEX_ALGORITHM_H
+#define CONVEX_CONVEX_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h"
+#include "btCollisionCreateFunc.h"
+
+class ConvexPenetrationDepthSolver;
+
+///ConvexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations.
+class ConvexConvexAlgorithm : public CollisionAlgorithm
+{
+	//ConvexPenetrationDepthSolver*	m_penetrationDepthSolver;
+	VoronoiSimplexSolver	m_simplexSolver;
+	GjkPairDetector m_gjkPairDetector;
+	bool	m_useEpa;
+public:
+	BroadphaseProxy	m_box0;
+	BroadphaseProxy	m_box1;
+
+	bool	m_ownManifold;
+	PersistentManifold*	m_manifoldPtr;
+	bool			m_lowLevelOfDetail;
+
+	void	CheckPenetrationDepthSolver();
+
+	
+
+public:
+
+	ConvexConvexAlgorithm(PersistentManifold* mf,const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+
+	virtual ~ConvexConvexAlgorithm();
+
+	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	virtual float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	void	SetLowLevelOfDetail(bool useLowLevel);
+
+	virtual void SetShapeIdentifiers(int partId0,int index0,	int partId1,int index1)
+	{
+			m_gjkPairDetector.m_partId0=partId0;
+			m_gjkPairDetector.m_partId1=partId1;
+			m_gjkPairDetector.m_index0=index0;
+			m_gjkPairDetector.m_index1=index1;		
+	}
+
+	const PersistentManifold*	GetManifold()
+	{
+		return m_manifoldPtr;
+	}
+
+	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	{
+		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		{
+			return new ConvexConvexAlgorithm(0,ci,proxy0,proxy1);
+		}
+	};
+
+
+};
+
+#endif //CONVEX_CONVEX_ALGORITHM_H

src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.cpp

@@ -0,0 +1,35 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btEmptyCollisionAlgorithm.h"
+
+
+
+EmptyAlgorithm::EmptyAlgorithm(const CollisionAlgorithmConstructionInfo& ci)
+	: CollisionAlgorithm(ci)
+{
+}
+
+void EmptyAlgorithm::ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+{
+
+}
+
+float EmptyAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+{
+	return 1.f;
+}
+
+

src/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h

@@ -0,0 +1,46 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef EMPTY_ALGORITH
+#define EMPTY_ALGORITH
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "btCollisionCreateFunc.h"
+
+#define ATTRIBUTE_ALIGNED(a)
+
+///EmptyAlgorithm is a stub for unsupported collision pairs.
+///The dispatcher can dispatch a persistent EmptyAlgorithm to avoid a search every frame.
+class EmptyAlgorithm : public CollisionAlgorithm
+{
+
+public:
+	
+	EmptyAlgorithm(const CollisionAlgorithmConstructionInfo& ci);
+
+	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	virtual float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	{
+		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		{
+			return new EmptyAlgorithm(ci);
+		}
+	};
+
+} ATTRIBUTE_ALIGNED(16);
+
+#endif //EMPTY_ALGORITH

src/BulletCollision/CollisionDispatch/btManifoldResult.cpp

@@ -0,0 +1,101 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include "btManifoldResult.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+
+///This is to allow MaterialCombiner/Custom Friction/Restitution values
+ContactAddedCallback		gContactAddedCallback=0;
+
+///User can override this material combiner by implementing gContactAddedCallback and setting body0->m_collisionFlags |= CollisionObject::customMaterialCallback;
+inline SimdScalar	calculateCombinedFriction(const CollisionObject* body0,const CollisionObject* body1)
+{
+	SimdScalar friction = body0->getFriction() * body1->getFriction();
+
+	const SimdScalar MAX_FRICTION  = 10.f;
+	if (friction < -MAX_FRICTION)
+		friction = -MAX_FRICTION;
+	if (friction > MAX_FRICTION)
+		friction = MAX_FRICTION;
+	return friction;
+
+}
+
+inline SimdScalar	calculateCombinedRestitution(const CollisionObject* body0,const CollisionObject* body1)
+{
+	return body0->getRestitution() * body1->getRestitution();
+}
+
+
+
+ManifoldResult::ManifoldResult(CollisionObject* body0,CollisionObject* body1,PersistentManifold* manifoldPtr)
+		:m_manifoldPtr(manifoldPtr),
+		m_body0(body0),
+		m_body1(body1)
+	{
+	}
+
+
+void ManifoldResult::AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth)
+{
+	if (depth > m_manifoldPtr->GetContactBreakingTreshold())
+		return;
+
+
+	SimdTransform transAInv = m_body0->m_cachedInvertedWorldTransform;
+	SimdTransform transBInv= m_body1->m_cachedInvertedWorldTransform;
+
+	//transAInv = m_body0->m_worldTransform.inverse();
+	//transBInv= m_body1->m_worldTransform.inverse();
+	SimdVector3 pointA = pointInWorld + normalOnBInWorld * depth;
+	SimdVector3 localA = transAInv(pointA );
+	SimdVector3 localB = transBInv(pointInWorld);
+	ManifoldPoint newPt(localA,localB,normalOnBInWorld,depth);
+
+	
+
+	int insertIndex = m_manifoldPtr->GetCacheEntry(newPt);
+	if (insertIndex >= 0)
+	{
+
+// This is not needed, just use the old info!
+//		const ManifoldPoint& oldPoint = m_manifoldPtr->GetContactPoint(insertIndex);
+//		newPt.CopyPersistentInformation(oldPoint);
+//		m_manifoldPtr->ReplaceContactPoint(newPt,insertIndex);
+
+
+	} else
+	{
+
+		newPt.m_combinedFriction = calculateCombinedFriction(m_body0,m_body1);
+		newPt.m_combinedRestitution = calculateCombinedRestitution(m_body0,m_body1);
+
+		//User can override friction and/or restitution
+		if (gContactAddedCallback &&
+			//and if either of the two bodies requires custom material
+			 ((m_body0->m_collisionFlags & CollisionObject::customMaterialCallback) ||
+			   (m_body1->m_collisionFlags & CollisionObject::customMaterialCallback)))
+		{
+			//experimental feature info, for per-triangle material etc.
+			(*gContactAddedCallback)(newPt,m_body0,m_partId0,m_index0,m_body1,m_partId1,m_index1);
+		}
+
+		m_manifoldPtr->AddManifoldPoint(newPt);
+	}
+}
+

src/BulletCollision/CollisionDispatch/btManifoldResult.h

@@ -0,0 +1,60 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#ifndef MANIFOLD_RESULT_H
+#define MANIFOLD_RESULT_H
+
+#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
+struct CollisionObject;
+class PersistentManifold;
+class ManifoldPoint;
+
+typedef bool (*ContactAddedCallback)(ManifoldPoint& cp,	const CollisionObject* colObj0,int partId0,int index0,const CollisionObject* colObj1,int partId1,int index1);
+extern ContactAddedCallback		gContactAddedCallback;
+
+
+
+///ManifoldResult is a helper class to manage  contact results.
+class ManifoldResult : public DiscreteCollisionDetectorInterface::Result
+{
+	PersistentManifold* m_manifoldPtr;
+	CollisionObject* m_body0;
+	CollisionObject* m_body1;
+	int	m_partId0;
+	int m_partId1;
+	int m_index0;
+	int m_index1;
+public:
+
+	ManifoldResult(CollisionObject* body0,CollisionObject* body1,PersistentManifold* manifoldPtr);
+
+	virtual ~ManifoldResult() {};
+
+	virtual void SetShapeIdentifiers(int partId0,int index0,	int partId1,int index1)
+	{
+			m_partId0=partId0;
+			m_partId1=partId1;
+			m_index0=index0;
+			m_index1=index1;		
+	}
+
+	virtual void AddContactPoint(const SimdVector3& normalOnBInWorld,const SimdVector3& pointInWorld,float depth);
+
+
+
+};
+
+#endif //MANIFOLD_RESULT_H

src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

@@ -0,0 +1,276 @@
+
+#include "btSimulationIslandManager.h"
+#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
+
+#include <stdio.h>
+#include <algorithm>
+
+
+SimulationIslandManager::SimulationIslandManager()
+{
+}
+
+SimulationIslandManager::~SimulationIslandManager()
+{
+}
+
+
+void SimulationIslandManager::InitUnionFind(int n)
+{
+		m_unionFind.reset(n);
+}
+		
+
+void SimulationIslandManager::FindUnions(Dispatcher* dispatcher)
+{
+	
+	{
+		for (int i=0;i<dispatcher->GetNumManifolds();i++)
+		{
+			const PersistentManifold* manifold = dispatcher->GetManifoldByIndexInternal(i);
+			//static objects (invmass 0.f) don't merge !
+
+			 const  CollisionObject* colObj0 = static_cast<const CollisionObject*>(manifold->GetBody0());
+			 const  CollisionObject* colObj1 = static_cast<const CollisionObject*>(manifold->GetBody1());
+
+			 if (colObj0 && colObj1 && dispatcher->NeedsResponse(*colObj0,*colObj1))
+			 {
+				if (((colObj0) && ((colObj0)->mergesSimulationIslands())) &&
+					((colObj1) && ((colObj1)->mergesSimulationIslands())))
+				{
+
+					m_unionFind.unite((colObj0)->m_islandTag1,
+						(colObj1)->m_islandTag1);
+				}
+			 }
+			
+			
+		}
+	}
+	
+}
+
+
+void	SimulationIslandManager::UpdateActivationState(CollisionWorld* colWorld,Dispatcher* dispatcher)
+{
+	
+	InitUnionFind(colWorld->GetCollisionObjectArray().size());
+	
+	// put the index into m_controllers into m_tag	
+	{
+		std::vector<CollisionObject*>::iterator i;
+		
+		int index = 0;
+		for (i=colWorld->GetCollisionObjectArray().begin();
+		!(i==colWorld->GetCollisionObjectArray().end()); i++)
+		{
+			
+			CollisionObject*	collisionObject= (*i);
+			collisionObject->m_islandTag1 = index;
+			collisionObject->m_hitFraction = 1.f;
+			index++;
+			
+		}
+	}
+	// do the union find
+	
+	FindUnions(dispatcher);
+	
+
+	
+}
+
+
+
+
+void	SimulationIslandManager::StoreIslandActivationState(CollisionWorld* colWorld)
+{
+	// put the islandId ('find' value) into m_tag	
+	{
+		
+		
+		std::vector<CollisionObject*>::iterator i;
+		
+		int index = 0;
+		for (i=colWorld->GetCollisionObjectArray().begin();
+		!(i==colWorld->GetCollisionObjectArray().end()); i++)
+		{
+			CollisionObject* collisionObject= (*i);
+			
+			if (collisionObject->mergesSimulationIslands())
+			{
+				collisionObject->m_islandTag1 = m_unionFind.find(index);
+			} else
+			{
+				collisionObject->m_islandTag1 = -1;
+			}
+			index++;
+		}
+	}
+}
+
+inline	int	getIslandId(const PersistentManifold* lhs)
+{
+	int islandId;
+	const CollisionObject* rcolObj0 = static_cast<const CollisionObject*>(lhs->GetBody0());
+	const CollisionObject* rcolObj1 = static_cast<const CollisionObject*>(lhs->GetBody1());
+	islandId= rcolObj0->m_islandTag1>=0?rcolObj0->m_islandTag1:rcolObj1->m_islandTag1;
+	return islandId;
+
+}
+
+bool PersistentManifoldSortPredicate(const PersistentManifold* lhs, const PersistentManifold* rhs)
+{
+	int rIslandId0,lIslandId0;
+	rIslandId0 = getIslandId(rhs);
+	lIslandId0 = getIslandId(lhs);
+	return lIslandId0 < rIslandId0;
+}
+
+
+//
+// todo: this is random access, it can be walked 'cache friendly'!
+//
+void SimulationIslandManager::BuildAndProcessIslands(Dispatcher* dispatcher,CollisionObjectArray& collisionObjects, IslandCallback* callback)
+{
+	//we are going to sort the unionfind array, and store the element id in the size
+	//afterwards, we clean unionfind, to make sure no-one uses it anymore
+	
+	GetUnionFind().sortIslands();
+	int numElem = GetUnionFind().getNumElements();
+
+	int endIslandIndex=1;
+
+	//update the sleeping state for bodies, if all are sleeping
+	for (int startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
+	{
+		int islandId = GetUnionFind().getElement(startIslandIndex).m_id;
+		for (endIslandIndex = startIslandIndex+1;(endIslandIndex<numElem) && (GetUnionFind().getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
+		{
+		}
+
+		//int numSleeping = 0;
+
+		bool allSleeping = true;
+
+		int idx;
+		for (idx=startIslandIndex;idx<endIslandIndex;idx++)
+		{
+			int i = GetUnionFind().getElement(idx).m_sz;
+
+			CollisionObject* colObj0 = collisionObjects[i];
+			if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
+			{
+				printf("error in island management\n");
+			}
+
+			assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
+			if (colObj0->m_islandTag1 == islandId)
+			{
+				if (colObj0->GetActivationState()== ACTIVE_TAG)
+				{
+					allSleeping = false;
+				}
+				if (colObj0->GetActivationState()== DISABLE_DEACTIVATION)
+				{
+					allSleeping = false;
+				}
+			}
+		}
+		
+		if (allSleeping)
+		{
+			int idx;
+			for (idx=startIslandIndex;idx<endIslandIndex;idx++)
+			{
+				int i = GetUnionFind().getElement(idx).m_sz;
+				CollisionObject* colObj0 = collisionObjects[i];
+				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
+				{
+					printf("error in island management\n");
+				}
+
+				assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
+
+				if (colObj0->m_islandTag1 == islandId)
+				{
+					colObj0->SetActivationState( ISLAND_SLEEPING );
+				}
+			}
+		} else
+		{
+
+			int idx;
+			for (idx=startIslandIndex;idx<endIslandIndex;idx++)
+			{
+				int i = GetUnionFind().getElement(idx).m_sz;
+
+				CollisionObject* colObj0 = collisionObjects[i];
+				if ((colObj0->m_islandTag1 != islandId) && (colObj0->m_islandTag1 != -1))
+				{
+					printf("error in island management\n");
+				}
+
+				assert((colObj0->m_islandTag1 == islandId) || (colObj0->m_islandTag1 == -1));
+
+				if (colObj0->m_islandTag1 == islandId)
+				{
+					if ( colObj0->GetActivationState() == ISLAND_SLEEPING)
+					{
+						colObj0->SetActivationState( WANTS_DEACTIVATION);
+					}
+				}
+			}
+		}
+	}
+
+	std::vector<PersistentManifold*>  islandmanifold;
+	int i;
+	int maxNumManifolds = dispatcher->GetNumManifolds();
+	islandmanifold.reserve(maxNumManifolds);
+
+	for (i=0;i<maxNumManifolds ;i++)
+	{
+		 PersistentManifold* manifold = dispatcher->GetManifoldByIndexInternal(i);
+		 
+		 CollisionObject* colObj0 = static_cast<CollisionObject*>(manifold->GetBody0());
+		 CollisionObject* colObj1 = static_cast<CollisionObject*>(manifold->GetBody1());
+		
+		 //todo: check sleeping conditions!
+		 if (((colObj0) && colObj0->GetActivationState() != ISLAND_SLEEPING) ||
+			((colObj1) && colObj1->GetActivationState() != ISLAND_SLEEPING))
+		{
+			//filtering for response
+			if (dispatcher->NeedsResponse(*colObj0,*colObj1))
+				islandmanifold.push_back(manifold);
+		}
+	}
+
+	int numManifolds = islandmanifold.size();
+
+	// Sort manifolds, based on islands
+	// Sort the vector using predicate and std::sort
+	std::sort(islandmanifold.begin(), islandmanifold.end(), PersistentManifoldSortPredicate);
+
+	//now process all active islands (sets of manifolds for now)
+
+	int startManifoldIndex = 0;
+	int endManifoldIndex = 1;
+
+	for (startManifoldIndex=0;startManifoldIndex<numManifolds;startManifoldIndex = endManifoldIndex)
+	{
+		int islandId = getIslandId(islandmanifold[startManifoldIndex]);
+		for (endManifoldIndex = startManifoldIndex+1;(endManifoldIndex<numManifolds) && (islandId == getIslandId(islandmanifold[endManifoldIndex]));endManifoldIndex++)
+		{
+		}
+		/// Process the actual simulation, only if not sleeping/deactivated
+		int numIslandManifolds = endManifoldIndex-startManifoldIndex;
+		if (numIslandManifolds)
+		{
+			callback->ProcessIsland(&islandmanifold[startManifoldIndex],numIslandManifolds);
+		}
+	}
+}

src/BulletCollision/CollisionDispatch/btSimulationIslandManager.h

@@ -0,0 +1,60 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SIMULATION_ISLAND_MANAGER_H
+#define SIMULATION_ISLAND_MANAGER_H
+
+#include "BulletCollision/CollisionDispatch/btUnionFind.h"
+#include "btCollisionCreateFunc.h"
+
+class CollisionWorld;
+class Dispatcher;
+
+///SimulationIslandManager creates and handles simulation islands, using UnionFind
+class SimulationIslandManager
+{
+	UnionFind m_unionFind;
+
+public:
+	SimulationIslandManager();
+	virtual ~SimulationIslandManager();
+
+
+	void InitUnionFind(int n);	
+	
+		
+	UnionFind& GetUnionFind() { return m_unionFind;}
+
+	virtual	void	UpdateActivationState(CollisionWorld* colWorld,Dispatcher* dispatcher);
+	virtual	void	StoreIslandActivationState(CollisionWorld* world);
+
+
+	void	FindUnions(Dispatcher* dispatcher);
+
+	
+
+	struct	IslandCallback
+	{
+		virtual ~IslandCallback() {};
+
+		virtual	void	ProcessIsland(class PersistentManifold**	manifolds,int numManifolds) = 0;
+	};
+
+	void	BuildAndProcessIslands(Dispatcher* dispatcher,CollisionObjectArray& collisionObjects, IslandCallback* callback);
+
+};
+
+#endif //SIMULATION_ISLAND_MANAGER_H
+

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp

@@ -0,0 +1,81 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btSphereSphereCollisionAlgorithm.h"
+#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
+#include "BulletCollision/CollisionShapes/btSphereShape.h"
+#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
+
+SphereSphereCollisionAlgorithm::SphereSphereCollisionAlgorithm(PersistentManifold* mf,const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+: CollisionAlgorithm(ci),
+m_ownManifold(false),
+m_manifoldPtr(mf)
+{
+	if (!m_manifoldPtr && m_dispatcher->NeedsCollision(*proxy0,*proxy1))
+	{
+		m_manifoldPtr = m_dispatcher->GetNewManifold(proxy0->m_clientObject,proxy1->m_clientObject);
+		m_ownManifold = true;
+	}
+}
+
+SphereSphereCollisionAlgorithm::~SphereSphereCollisionAlgorithm()
+{
+	if (m_ownManifold)
+	{
+		if (m_manifoldPtr)
+			m_dispatcher->ReleaseManifold(m_manifoldPtr);
+	}
+}
+
+void SphereSphereCollisionAlgorithm::ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+{
+	if (!m_manifoldPtr)
+		return;
+
+	CollisionObject*	col0 = static_cast<CollisionObject*>(proxy0->m_clientObject);
+	CollisionObject*	col1 = static_cast<CollisionObject*>(proxy1->m_clientObject);
+	SphereShape* sphere0 = (SphereShape*)col0->m_collisionShape;
+	SphereShape* sphere1 = (SphereShape*)col1->m_collisionShape;
+
+	SimdVector3 diff = col0->m_worldTransform.getOrigin()-  col1->m_worldTransform.getOrigin();
+	float len = diff.length();
+	SimdScalar radius0 = sphere0->GetRadius();
+	SimdScalar radius1 = sphere1->GetRadius();
+
+	///iff distance positive, don't generate a new contact
+	if ( len > (radius0+radius1))
+		return;
+
+	///distance (negative means penetration)
+	SimdScalar dist = len - (radius0+radius1);
+
+	SimdVector3 normalOnSurfaceB = diff / len;
+	///point on A (worldspace)
+	SimdVector3 pos0 = col0->m_worldTransform.getOrigin() - radius0 * normalOnSurfaceB;
+	///point on B (worldspace)
+	SimdVector3 pos1 = col1->m_worldTransform.getOrigin() + radius1* normalOnSurfaceB;
+
+	/// report a contact. internally this will be kept persistent, and contact reduction is done
+	ManifoldResult* resultOut = m_dispatcher->GetNewManifoldResult(col0,col1,m_manifoldPtr);
+	resultOut->AddContactPoint(normalOnSurfaceB,pos1,dist);
+	m_dispatcher->ReleaseManifoldResult(resultOut);
+
+}
+
+float SphereSphereCollisionAlgorithm::CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo)
+{
+	//not yet
+	return 1.f;
+}

src/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h

@@ -0,0 +1,55 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SPHERE_SPHERE_COLLISION_ALGORITHM_H
+#define SPHERE_SPHERE_COLLISION_ALGORITHM_H
+
+#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
+#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h"
+#include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h"
+class PersistentManifold;
+
+/// SphereSphereCollisionAlgorithm  provides sphere-sphere collision detection.
+/// Other features are frame-coherency (persistent data) and collision response.
+/// Also provides the most basic sample for custom/user CollisionAlgorithm
+class SphereSphereCollisionAlgorithm : public CollisionAlgorithm
+{
+	bool	m_ownManifold;
+	PersistentManifold*	m_manifoldPtr;
+	
+public:
+	SphereSphereCollisionAlgorithm(const CollisionAlgorithmConstructionInfo& ci)
+		: CollisionAlgorithm(ci) {}
+
+	virtual void ProcessCollision (BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	virtual float CalculateTimeOfImpact(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1,const DispatcherInfo& dispatchInfo);
+
+	SphereSphereCollisionAlgorithm(PersistentManifold* mf,const CollisionAlgorithmConstructionInfo& ci,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
+
+	virtual ~SphereSphereCollisionAlgorithm();
+
+	struct CreateFunc :public 	CollisionAlgorithmCreateFunc
+	{
+		virtual	CollisionAlgorithm* CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo& ci, BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
+		{
+			return new SphereSphereCollisionAlgorithm(0,ci,proxy0,proxy1);
+		}
+	};
+
+};
+
+#endif //SPHERE_SPHERE_COLLISION_ALGORITHM_H
+

src/BulletCollision/CollisionDispatch/btUnionFind.cpp

@@ -0,0 +1,77 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btUnionFind.h"
+#include <assert.h>
+#include <algorithm>
+
+
+
+UnionFind::~UnionFind()
+{
+	Free();
+
+}
+
+UnionFind::UnionFind()
+{ 
+
+}
+
+void	UnionFind::Allocate(int N)
+{
+	m_elements.resize(N);
+}
+void	UnionFind::Free()
+{
+	m_elements.clear();
+}
+
+
+void	UnionFind::reset(int N)
+{
+	Allocate(N);
+
+	for (int i = 0; i < N; i++) 
+	{ 
+		m_elements[i].m_id = i; m_elements[i].m_sz = 1; 
+	} 
+}
+
+bool UnionFindElementSortPredicate(const Element& lhs, const Element& rhs)
+{
+	return lhs.m_id < rhs.m_id;
+}
+
+
+///this is a special operation, destroying the content of UnionFind.
+///it sorts the elements, based on island id, in order to make it easy to iterate over islands
+void	UnionFind::sortIslands()
+{
+
+	//first store the original body index, and islandId
+	int numElements = m_elements.size();
+	
+	for (int i=0;i<numElements;i++)
+	{
+		m_elements[i].m_id = find(i);
+		m_elements[i].m_sz = i;
+	}
+	
+	 // Sort the vector using predicate and std::sort
+	  std::sort(m_elements.begin(), m_elements.end(), UnionFindElementSortPredicate);
+
+}
+

src/BulletCollision/CollisionDispatch/btUnionFind.h

@@ -0,0 +1,117 @@
+/*
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef UNION_FIND_H
+#define UNION_FIND_H
+
+#include <vector>
+struct	Element
+{
+	int	m_id;
+	int	m_sz;
+};
+
+///UnionFind calculates connected subsets
+// Implements weighted Quick Union with path compression
+// optimization: could use short ints instead of ints (halving memory, would limit the number of rigid bodies to 64k, sounds reasonable)
+class UnionFind
+  {
+    private:
+		std::vector<Element>	m_elements;
+
+    public:
+	  
+		UnionFind();
+		~UnionFind();
+
+	
+		//this is a special operation, destroying the content of UnionFind.
+		//it sorts the elements, based on island id, in order to make it easy to iterate over islands
+		void	sortIslands();
+
+	  void	reset(int N);
+
+	  inline int	getNumElements() const
+	  {
+		  return m_elements.size();
+	  }
+	  inline bool  isRoot(int x) const
+	  {
+		  return (x == m_elements[x].m_id);
+	  }
+
+	  Element&	getElement(int index)
+	  {
+		  return m_elements[index];
+	  }
+	  const Element& getElement(int index) const
+	  {
+		  return m_elements[index];
+	  }
+   
+	  void	Allocate(int N);
+	  void	Free();
+
+
+
+
+	  int find(int p, int q)
+		{ 
+			return (find(p) == find(q)); 
+		}
+
+		void unite(int p, int q)
+		{
+			int i = find(p), j = find(q);
+			if (i == j) 
+				return;
+
+			//weighted quick union, this keeps the 'trees' balanced, and keeps performance of unite O( log(n) )
+			if (m_elements[i].m_sz < m_elements[j].m_sz)
+			{ 
+				m_elements[i].m_id = j; m_elements[j].m_sz += m_elements[i].m_sz; 
+			}
+			else 
+			{ 
+				m_elements[j].m_id = i; m_elements[i].m_sz += m_elements[j].m_sz; 
+			}
+		}
+
+		int find(int x)
+		{ 
+			//assert(x < m_N);
+			//assert(x >= 0);
+
+			while (x != m_elements[x].m_id) 
+			{
+		//not really a reason not to use path compression, and it flattens the trees/improves find performance dramatically
+		#define USE_PATH_COMPRESSION 1
+		#ifdef USE_PATH_COMPRESSION
+				//
+				m_elements[x].m_id = m_elements[m_elements[x].m_id].m_id;
+		#endif //
+				x = m_elements[x].m_id;
+				//assert(x < m_N);
+				//assert(x >= 0);
+
+			}
+			return x; 
+		}
+
+
+  };
+
+
+#endif //UNION_FIND_H