started working on some serious performance improvements. now the union find is optimized, the broadphase add/remove overlapping pair was too slow. added a stl::set to keep track of overlapping pairs. this speeds up the set find/remove. work in progress.the SimpleBroadphase is broken. will be fixed tomorrow.

Did some tests with 3000 rigidbodies, works much smoother now :)

Bullet/BroadphaseCollision/AxisSweep3.cpp

@@ -215,7 +215,7 @@ void AxisSweep3::RemoveHandle(unsigned short handle)
 {
 	Handle* pHandle = GetHandle(handle);
 
-	RemoveOverlappingPairsContainingProxy(pHandle);
+	//RemoveOverlappingPairsContainingProxy(pHandle);
 
 
 	// compute current limit of edge arrays

Bullet/BroadphaseCollision/BroadphaseProxy.h

@@ -42,6 +42,9 @@ IMPLICIT_CONVEX_SHAPES_START_HERE,
 CONCAVE_SHAPES_START_HERE,
 	//keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
 	TRIANGLE_MESH_SHAPE_PROXYTYPE,
+	///used for demo integration FAST/Swift collision library and Bullet
+	FAST_CONCAVE_MESH_PROXYTYPE,
+
 	EMPTY_SHAPE_PROXYTYPE,
 	STATIC_PLANE_PROXYTYPE,
 CONCAVE_SHAPES_END_HERE,
@@ -124,17 +127,26 @@ struct BroadphasePair
 		}
 	}
 	BroadphasePair(BroadphaseProxy& proxy0,BroadphaseProxy& proxy1)
-		:
-		m_pProxy0(&proxy0),
-		m_pProxy1(&proxy1)
 	{
+
+		//keep them sorted, so the std::set operations work
+		if (&proxy0 < &proxy1)
+        { 
+            m_pProxy0 = &proxy0; 
+            m_pProxy1 = &proxy1; 
+        }
+        else 
+        { 
+			m_pProxy0 = &proxy1; 
+            m_pProxy1 = &proxy0; 
+        }
+
 		for (int i=0;i<SIMPLE_MAX_ALGORITHMS;i++)
-	{
+		{
 			m_algorithms[i] = 0;
 		}
 
 	}
-
 	
 	BroadphaseProxy* m_pProxy0;
 	BroadphaseProxy* m_pProxy1;
@@ -142,5 +154,14 @@ struct BroadphasePair
 	mutable CollisionAlgorithm* m_algorithms[SIMPLE_MAX_ALGORITHMS];
 };
 
+
+//comparison for set operation, see Solid DT_Encounter
+inline bool operator<(const BroadphasePair& a, const BroadphasePair& b) 
+{ 
+    return a.m_pProxy0 < b.m_pProxy0 || 
+        (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); 
+}
+
+
 #endif //BROADPHASE_PROXY_H
 

Bullet/BroadphaseCollision/Dispatcher.h

@@ -87,7 +87,7 @@ public:
 
 	virtual	void	ReleaseManifoldResult(ManifoldResult*)=0;
 
-	virtual void	DispatchAllCollisionPairs(struct BroadphasePair* pairs,int numPairs,DispatcherInfo& dispatchInfo)=0;
+	virtual void	DispatchAllCollisionPairs(OverlappingPairCache* pairCache,DispatcherInfo& dispatchInfo)=0;
 
 	virtual int GetNumManifolds() const = 0;
 

Bullet/BroadphaseCollision/OverlappingPairCache.cpp

@@ -24,26 +24,24 @@ subject to the following restrictions:
 
 OverlappingPairCache::OverlappingPairCache(int maxOverlap):
 m_blockedForChanges(false),
-m_NumOverlapBroadphasePair(0),
+//m_NumOverlapBroadphasePair(0),
 m_maxOverlap(maxOverlap)
 {
-	m_OverlappingPairs = new BroadphasePair[maxOverlap];
 }
 
 
 OverlappingPairCache::~OverlappingPairCache()
 {
-	delete [] m_OverlappingPairs;
+	//todo/test: show we erase/delete data, or is it automatic
 }
 
 
 void	OverlappingPairCache::RemoveOverlappingPair(BroadphasePair& pair)
 {
 	CleanOverlappingPair(pair);
-	int	index = &pair - &m_OverlappingPairs[0];
-	//remove efficiently, swap with the last
-	m_OverlappingPairs[index] = m_OverlappingPairs[m_NumOverlapBroadphasePair-1];
-	m_NumOverlapBroadphasePair--;
+	std::set<BroadphasePair>::iterator it = m_overlappingPairSet.find(pair);
+	assert(it != m_overlappingPairSet.end());
+	m_overlappingPairSet.erase(pair);
 }
 
 
@@ -75,25 +73,22 @@ void	OverlappingPairCache::AddOverlappingPair(BroadphaseProxy* proxy0,Broadphase
 
 
 	BroadphasePair pair(*proxy0,*proxy1);
-	m_OverlappingPairs[m_NumOverlapBroadphasePair] = pair;
-
+	
+	m_overlappingPairSet.insert(pair);
+	
+	
+#ifdef _DEBUG
+	/*
+	BroadphasePair& pr = (*newElem);
 	int i;
 	for (i=0;i<SIMPLE_MAX_ALGORITHMS;i++)
 	{
 		assert(!m_OverlappingPairs[m_NumOverlapBroadphasePair].m_algorithms[i]);
-		m_OverlappingPairs[m_NumOverlapBroadphasePair].m_algorithms[i] = 0;
+		//m_OverlappingPairs[m_NumOverlapBroadphasePair].m_algorithms[i] = 0;
 	}
+	*/
 
-	if (m_NumOverlapBroadphasePair >= m_maxOverlap)
-	{
-		//printf("Error: too many overlapping objects: m_NumOverlapBroadphasePair: %d\n",m_NumOverlapBroadphasePair);
-#ifdef DEBUG
-		assert(0);
-#endif 
-	} else
-	{
-		m_NumOverlapBroadphasePair++;
-	}
+#endif _DEBUG
 
 
 }
@@ -104,27 +99,25 @@ void	OverlappingPairCache::AddOverlappingPair(BroadphaseProxy* proxy0,Broadphase
 ///Also we can use a 2D bitmap, which can be useful for a future GPU implementation
 BroadphasePair*	OverlappingPairCache::FindPair(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1)
 {
-	BroadphasePair* foundPair = 0;
+	if (!NeedsCollision(proxy0,proxy1))
+		return 0;
 
-	int i;
-	for (i=m_NumOverlapBroadphasePair-1;i>=0;i--)
-	{
-		BroadphasePair& pair = m_OverlappingPairs[i];
-		if (((pair.m_pProxy0 == proxy0) && (pair.m_pProxy1 == proxy1)) ||
-			((pair.m_pProxy0 == proxy1) && (pair.m_pProxy1 == proxy0)))
-		{
-			foundPair = &pair;
-			return foundPair;
-		}
-	}	
+	BroadphasePair tmpPair(*proxy0,*proxy1);
+	std::set<BroadphasePair>::iterator it = m_overlappingPairSet.find(tmpPair);
+	if ((it == m_overlappingPairSet.end()))
+		return 0;
 
-	return foundPair;
+	//assert(it != m_overlappingPairSet.end());
+	BroadphasePair* pair = &(*it);
+	return pair;
 }
 
 
 
 void	OverlappingPairCache::CleanProxyFromPairs(BroadphaseProxy* proxy)
 {
+	assert(0);
+	/*
 	for (int i=0;i<m_NumOverlapBroadphasePair;i++)
 	{
 		BroadphasePair& pair = m_OverlappingPairs[i];
@@ -134,11 +127,17 @@ void	OverlappingPairCache::CleanProxyFromPairs(BroadphaseProxy* proxy)
 			CleanOverlappingPair(pair);
 		}
 	}
+	*/
+
 }
 
 void	OverlappingPairCache::RemoveOverlappingPairsContainingProxy(BroadphaseProxy* proxy)
 {
+
+	assert(0);
+	/*
 	int i;
+	
 	for ( i=m_NumOverlapBroadphasePair-1;i>=0;i--)
 	{
 		BroadphasePair& pair = m_OverlappingPairs[i];
@@ -148,7 +147,23 @@ void	OverlappingPairCache::RemoveOverlappingPairsContainingProxy(BroadphaseProxy
 			RemoveOverlappingPair(pair);
 		}
 	}
+	*/
+
 }
 
 
 
+void	OverlappingPairCache::ProcessAllOverlappingPairs(OverlapCallback* callback)
+{
+	std::set<BroadphasePair>::iterator it = m_overlappingPairSet.begin();
+	for (; !(it==m_overlappingPairSet.end());it++)
+	{
+		BroadphasePair& pair = (*it);
+		if (callback->ProcessOverlap(pair))
+		{
+			assert(0);
+			m_overlappingPairSet.erase(it);
+		}
+	}
+}
+

Bullet/BroadphaseCollision/OverlappingPairCache.h

@@ -21,35 +21,33 @@ subject to the following restrictions:
 #include "BroadphaseInterface.h"
 #include "BroadphaseProxy.h"
 #include "SimdPoint3.h"
+#include <set>
 
 
+struct	OverlapCallback
+{
+	//return true for deletion of the pair
+	virtual bool	ProcessOverlap(BroadphasePair& pair) = 0;
+};
+
 ///OverlappingPairCache maintains the objects with overlapping AABB
 ///Typically managed by the Broadphase, Axis3Sweep or SimpleBroadphase
 class	OverlappingPairCache : public BroadphaseInterface
 {
-
-	BroadphasePair*	m_OverlappingPairs;
-	int	m_NumOverlapBroadphasePair;
+	//avoid brute-force finding all the time
+	std::set<BroadphasePair>	m_overlappingPairSet;
+	
 	int m_maxOverlap;
 	
 	//during the dispatch, check that user doesn't destroy/create proxy
 	bool		m_blockedForChanges;
-
 	
 	public:
 		
 	OverlappingPairCache(int maxOverlap);	
 	virtual ~OverlappingPairCache();
-	
-	int		GetNumOverlappingPairs() const
-	{
-		return m_NumOverlapBroadphasePair;
-	}
 
-	BroadphasePair& GetOverlappingPair(int index)
-	{
-		return m_OverlappingPairs[index];
-	}
+	void	ProcessAllOverlappingPairs(OverlapCallback*);
 
 	void	RemoveOverlappingPair(BroadphasePair& pair);
 
@@ -58,8 +56,7 @@ class	OverlappingPairCache : public BroadphaseInterface
 	void	AddOverlappingPair(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
 
 	BroadphasePair*	FindPair(BroadphaseProxy* proxy0,BroadphaseProxy* proxy1);
-	
-	
+		
 	
 	void	CleanProxyFromPairs(BroadphaseProxy* proxy);
 

Bullet/BroadphaseCollision/SimpleBroadphase.cpp

@@ -95,7 +95,27 @@ BroadphaseProxy*	SimpleBroadphase::CreateProxy(  const SimdVector3& min,  const
 	return proxy;
 }
 
+class	RemovingOverlapCallback : public OverlapCallback
+{
+	virtual bool	ProcessOverlap(BroadphasePair& pair)
+	{
+		assert(0);
+	}
+};
 
+class RemovePairContainingProxy
+{
+
+	BroadphaseProxy*	m_targetProxy;
+
+	virtual bool ProcessOverlap(BroadphasePair& pair)
+	{
+		SimpleBroadphaseProxy* proxy0 = static_cast<SimpleBroadphaseProxy*>(pair.m_pProxy0);
+		SimpleBroadphaseProxy* proxy1 = static_cast<SimpleBroadphaseProxy*>(pair.m_pProxy1);
+
+		return ((m_targetProxy == proxy0 || m_targetProxy == proxy1));
+	};
+};
 
 void	SimpleBroadphase::DestroyProxy(BroadphaseProxy* proxyOrg)
 {
@@ -109,7 +129,24 @@ void	SimpleBroadphase::DestroyProxy(BroadphaseProxy* proxyOrg)
 		assert (index < m_maxProxies);
 		m_freeProxies[--m_firstFreeProxy] = index;
 
-		RemoveOverlappingPairsContainingProxy(proxyOrg);
+		//RemoveOverlappingPairsContainingProxy(proxyOrg);
+
+		assert(0);
+		//then remove non-overlapping ones
+		/*for (i=0;i<GetNumOverlappingPairs();i++)
+		{
+			BroadphasePair& pair = GetOverlappingPair(i);
+
+			SimpleBroadphaseProxy* proxy0 = GetSimpleProxyFromProxy(pair.m_pProxy0);
+			SimpleBroadphaseProxy* proxy1 = GetSimpleProxyFromProxy(pair.m_pProxy1);
+			if ((proxy0==proxyOrg) || (proxy1==proxyOrg))
+			{
+				RemoveOverlappingPair(pair);
+			}
+		}
+		*/
+
+
 
 		
 		for (i=0;i<m_numProxies;i++)
@@ -172,6 +209,8 @@ void	SimpleBroadphase::RefreshOverlappingPairs()
 		}
 	}
 
+	assert(0);
+	/*
 	//then remove non-overlapping ones
 	for (i=0;i<GetNumOverlappingPairs();i++)
 	{
@@ -185,7 +224,8 @@ void	SimpleBroadphase::RefreshOverlappingPairs()
 		}
 	}
 
-	
+	*/
+
 
 }
 

Bullet/CollisionDispatch/CollisionDispatcher.cpp

@@ -265,7 +265,72 @@ void	CollisionDispatcher::ReleaseManifoldResult(ManifoldResult*)
 }
 
 
-void	CollisionDispatcher::DispatchAllCollisionPairs(BroadphasePair* pairs,int numPairs,DispatcherInfo& dispatchInfo)
+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;
 
@@ -273,58 +338,9 @@ void	CollisionDispatcher::DispatchAllCollisionPairs(BroadphasePair* pairs,int nu
 
 	int dispatcherId = GetUniqueId();
 
-	
+	CollisionPairCallback	collisionCallback(dispatchInfo,this,dispatcherId);
 
-	for (i=0;i<numPairs;i++)
-	{
-
-		BroadphasePair& pair = pairs[i];
-
-		if (dispatcherId>= 0)
-		{
-			//dispatcher will keep algorithms persistent in the collision pair
-			if (!pair.m_algorithms[dispatcherId])
-			{
-				pair.m_algorithms[dispatcherId] = FindAlgorithm(
-					*pair.m_pProxy0,
-					*pair.m_pProxy1);
-			}
-
-			if (pair.m_algorithms[dispatcherId])
-			{
-				if (dispatchInfo.m_dispatchFunc == 		DispatcherInfo::DISPATCH_DISCRETE)
-				{
-					pair.m_algorithms[dispatcherId]->ProcessCollision(pair.m_pProxy0,pair.m_pProxy1,dispatchInfo);
-				} else
-				{
-					float toi = pair.m_algorithms[dispatcherId]->CalculateTimeOfImpact(pair.m_pProxy0,pair.m_pProxy1,dispatchInfo);
-					if (dispatchInfo.m_timeOfImpact > toi)
-						dispatchInfo.m_timeOfImpact = toi;
-
-				}
-			}
-		} else
-		{
-			//non-persistent algorithm dispatcher
-			CollisionAlgorithm* algo = FindAlgorithm(
-				*pair.m_pProxy0,
-				*pair.m_pProxy1);
-
-			if (algo)
-			{
-				if (dispatchInfo.m_dispatchFunc == 		DispatcherInfo::DISPATCH_DISCRETE)
-				{
-					algo->ProcessCollision(pair.m_pProxy0,pair.m_pProxy1,dispatchInfo);
-				} else
-				{
-					float toi = algo->CalculateTimeOfImpact(pair.m_pProxy0,pair.m_pProxy1,dispatchInfo);
-					if (dispatchInfo.m_timeOfImpact > toi)
-						dispatchInfo.m_timeOfImpact = toi;
-				}
-			}
-		}
-
-	}
+	pairCache->ProcessAllOverlappingPairs(&collisionCallback);
 
 	//m_blockedForChanges = false;
 

Bullet/CollisionDispatch/CollisionDispatcher.h

@@ -105,7 +105,7 @@ public:
 
 	virtual int GetUniqueId() { return RIGIDBODY_DISPATCHER;}
 	
-	virtual void	DispatchAllCollisionPairs(BroadphasePair* pairs,int numPairs,DispatcherInfo& dispatchInfo);
+	virtual void	DispatchAllCollisionPairs(OverlappingPairCache* pairCache,DispatcherInfo& dispatchInfo);
 
 	
 

Bullet/CollisionDispatch/CollisionWorld.cpp

@@ -108,7 +108,7 @@ void	CollisionWorld::PerformDiscreteCollisionDetection()
 
 	Dispatcher* dispatcher = GetDispatcher();
 	if (dispatcher)
-		dispatcher->DispatchAllCollisionPairs(&m_pairCache->GetOverlappingPair(0),m_pairCache->GetNumOverlappingPairs(),dispatchInfo);
+		dispatcher->DispatchAllCollisionPairs(m_pairCache,dispatchInfo);
 
 }
 

Bullet/CollisionDispatch/SphereSphereCollisionAlgorithm.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 "SphereSphereCollisionAlgorithm.h"
+#include "CollisionDispatch/CollisionDispatcher.h"
+#include "CollisionShapes/SphereShape.h"
+#include "CollisionDispatch/CollisionObject.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;
+}

Bullet/CollisionDispatch/SphereSphereCollisionAlgorithm.h

@@ -0,0 +1,54 @@
+/*
+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 "BroadphaseCollision/CollisionAlgorithm.h"
+#include "BroadphaseCollision/BroadphaseProxy.h"
+#include "CollisionDispatch/CollisionCreateFunc.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