From 76375afff23712393a6769794d219dbbbeb1202e Mon Sep 17 00:00:00 2001
From: "erwin.coumans" <erwin.coumans@08e121b0-ae19-0410-a57b-3be3395fd4fd>
Date: Wed, 14 Mar 2012 03:52:29 +0000
Subject: [PATCH] revert quickSort change in commit
 http://code.google.com/p/bullet/source/detail?r=2527 and fix the underlying
 sort issue in VoronoiFractureDemo (store intermediate values in memory to
 avoid problems) @todo: rewrite the island management to avoid sort for better
 performance Thanks to Peter Kyme for the report, fixes Issue 607

---
 .../VoronoiFractureDemo.cpp                   |  7 ++-
 .../btSimulationIslandManager.cpp             |  4 +-
 src/LinearMath/btAlignedObjectArray.h         | 60 ++++++++-----------
 3 files changed, 33 insertions(+), 38 deletions(-)

diff --git a/Demos/VoronoiFractureDemo/VoronoiFractureDemo.cpp b/Demos/VoronoiFractureDemo/VoronoiFractureDemo.cpp
index a316477e8..d3dca4cee 100644
--- a/Demos/VoronoiFractureDemo/VoronoiFractureDemo.cpp
+++ b/Demos/VoronoiFractureDemo/VoronoiFractureDemo.cpp
@@ -184,7 +184,12 @@ struct pointCmp
 {
 	bool operator()(const btVector3& p1, const btVector3& p2) const
 	{
-		return ((p1-curVoronoiPoint).length2() < (p2-curVoronoiPoint).length2());
+		float v1 = (p1-curVoronoiPoint).length2();
+		float v2 = (p2-curVoronoiPoint).length2();
+		bool result0 = v1 < v2;
+		//bool result1 = ((btScalar)(p1-curVoronoiPoint).length2()) < ((btScalar)(p2-curVoronoiPoint).length2());
+		//apparently result0 is not always result1, because extended precision used in registered is different from precision when values are stored in memory
+		return result0;
 	}
 };
 
diff --git a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
index cc0b2a6d5..871c64415 100644
--- a/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
+++ b/src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
@@ -377,8 +377,10 @@ void btSimulationIslandManager::buildAndProcessIslands(btDispatcher* dispatcher,
 
 		int numManifolds = int (m_islandmanifold.size());
 
-		//we should do radix sort, it it much faster (O(n) instead of O (n log2(n))
+		//tried a radix sort, but quicksort/heapsort seems still faster
+		//@todo rewrite island management
 		m_islandmanifold.quickSort(btPersistentManifoldSortPredicate());
+		//m_islandmanifold.heapSort(btPersistentManifoldSortPredicate());
 
 		//now process all active islands (sets of manifolds for now)
 
diff --git a/src/LinearMath/btAlignedObjectArray.h b/src/LinearMath/btAlignedObjectArray.h
index 0179fd071..36090e13c 100644
--- a/src/LinearMath/btAlignedObjectArray.h
+++ b/src/LinearMath/btAlignedObjectArray.h
@@ -313,46 +313,34 @@ protected:
 				}
 		};
 	
-		template <typename L>
-		int partition (const L& CompareFunc, int lo, int hi, int pivotIndex)
-		{
-			if (pivotIndex != lo)
-				swap (lo, pivotIndex);
-
-			pivotIndex = lo;
-			lo++;
-			while (lo <= hi)
-			{
-				//if (m_data[low] <= m_data[pivotIndex]) -> we don't have a <= so we use !(b<a) as a<=b 
-				if (!CompareFunc(m_data[pivotIndex],m_data[lo]))
-					lo++;
-				else if (CompareFunc(m_data[pivotIndex],m_data[hi]))
-					hi--;
-				else
-					swap(lo,hi);
-			}
-			if (hi != pivotIndex)
-				swap(pivotIndex, hi);
-			return hi;
-		}
 
 		template <typename L>
 		void quickSortInternal(const L& CompareFunc,int lo, int hi)
 		{
-			if (lo>=hi)
-				return;
-			int pivotIndex = (lo+hi)/2;
-			pivotIndex = partition(CompareFunc,lo,hi,pivotIndex);
-			
-			//  recursion, exclude the pivot
-			if (lo<pivotIndex) 
-			{
-				quickSortInternal( CompareFunc, lo, pivotIndex-1);
-			}
-			if (pivotIndex<hi) 
-			{
-				quickSortInternal( CompareFunc, pivotIndex+1, hi);
-			}
+		//  lo is the lower index, hi is the upper index
+		//  of the region of array a that is to be sorted
+			int i=lo, j=hi;
+			T x=m_data[(lo+hi)/2];
+
+			//  partition
+			do
+			{    
+				while (CompareFunc(m_data[i],x)) 
+					i++; 
+				while (CompareFunc(x,m_data[j])) 
+					j--;
+				if (i<=j)
+				{
+					swap(i,j);
+					i++; j--;
+				}
+			} while (i<=j);
+
+			//  recursion
+			if (lo<j) 
+				quickSortInternal( CompareFunc, lo, j);
+			if (i<hi) 
+				quickSortInternal( CompareFunc, i, hi);
 		}