Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

revert quickSort change in commit http://code.google.com/p/bullet/source/detail?r=2527 and fix the underlying sort issue

Browse Source 
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
This commit is contained in:
erwin.coumans
2012-03-14 03:52:29 +00:00
parent 52f9f6ed09
commit 76375afff2
3 changed files with 33 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
Demos/VoronoiFractureDemo/VoronoiFractureDemo.cpp
View File

@@ -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;
}
};

4
src/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp
View File

@@ -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)

60
src/LinearMath/btAlignedObjectArray.h
View File

@@ -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);
}