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()
 		}
 	}
 
-	
+	*/
+
 
 }