void btHashedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
{
///need to keep hashmap in sync with pair address, so rebuild all
btBroadphasePairArray tmpPairs;
int i;
for (i=0;i<m_overlappingPairArray.size();i++)
{
tmpPairs.push_back(m_overlappingPairArray[i]);
}
for (i=0;i<tmpPairs.size();i++)
{
removeOverlappingPair(tmpPairs[i].m_pProxy0,tmpPairs[i].m_pProxy1,dispatcher);
}
for (i = 0; i < m_next.size(); i++)
{
m_next[i] = BT_NULL_PAIR;
}
tmpPairs.quickSort(btBroadphasePairSortPredicate());
for (i=0;i<tmpPairs.size();i++)
{
addOverlappingPair(tmpPairs[i].m_pProxy0,tmpPairs[i].m_pProxy1);
}
}
/**
* Sorts the minimum end point for specified axis and removes overlapping pair if necessary.
*/
void SweepAndPrune::sortMinUp(unsigned int axis, unsigned int endPointIndex, bool testOverlap)
{
BodyEndPoint *endPoint = &sortedEndPoints[axis][endPointIndex];
BodyEndPoint *nextEndPoint = &sortedEndPoints[axis][endPointIndex+1];
while(endPoint->getValue() > nextEndPoint->getValue())
{
//update indexes in bodies
if(nextEndPoint->isMin())
{
nextEndPoint->getBodyBox()->min[axis]--;
}else
{
const int axis1 = (1 << axis) & 3;
const int axis2 = (1 << axis1) & 3;
if(testOverlap && isOverlap(endPoint->getBodyBox(), nextEndPoint->getBodyBox(), axis1, axis2))
{
removeOverlappingPair(endPoint->getBodyBox(), nextEndPoint->getBodyBox());
}
nextEndPoint->getBodyBox()->max[axis]--;
}
endPoint->getBodyBox()->min[axis]++;
//swap end points
BodyEndPoint tmp = *endPoint;
*endPoint = *nextEndPoint;
*nextEndPoint = tmp;
//increment
endPoint++;
nextEndPoint++;
}
}
/**
* Sorts the minimum end point for specified axis and removes overlapping pair if necessary.
*/
void SweepAndPrune::sortMaxDown(unsigned int axis, unsigned int endPointIndex, bool testOverlap)
{
BodyEndPoint *endPoint = &sortedEndPoints[axis][endPointIndex];
BodyEndPoint *prevEndPoint = &sortedEndPoints[axis][endPointIndex-1];
while(endPoint->getValue() < prevEndPoint->getValue())
{
//update indexes in bodies
if(prevEndPoint->isMin())
{
const int axis1 = (1 << axis) & 3;
const int axis2 = (1 << axis1) & 3;
if(testOverlap && isOverlap(endPoint->getBodyBox(), prevEndPoint->getBodyBox(), axis1, axis2))
{
removeOverlappingPair(endPoint->getBodyBox(), prevEndPoint->getBodyBox());
}
prevEndPoint->getBodyBox()->min[axis]++;
}else
{
prevEndPoint->getBodyBox()->max[axis]++;
}
endPoint->getBodyBox()->max[axis]--;
//swap end points
BodyEndPoint tmp = *endPoint;
*endPoint = *prevEndPoint;
*prevEndPoint = tmp;
//decrement
endPoint--;
prevEndPoint--;
}
}
void btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
{
BT_PROFILE("btHashedOverlappingPairCache::processAllOverlappingPairs");
int i;
// printf("m_overlappingPairArray.size()=%d\n",m_overlappingPairArray.size());
for (i=0;i<m_overlappingPairArray.size();)
{
btBroadphasePair* pair = &m_overlappingPairArray[i];
if (callback->processOverlap(*pair))
{
removeOverlappingPair(pair->m_pProxy0,pair->m_pProxy1,dispatcher);
} else
{
i++;
}
}
}
void btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher, const struct btDispatcherInfo& dispatchInfo)
{
if (dispatchInfo.m_deterministicOverlappingPairs)
{
btBroadphasePairArray& pa = getOverlappingPairArray();
btAlignedObjectArray<MyPairIndex> indices;
{
BT_PROFILE("sortOverlappingPairs");
indices.resize(pa.size());
for (int i=0;i<indices.size();i++)
{
const btBroadphasePair& p = pa[i];
const int uidA0 = p.m_pProxy0 ? p.m_pProxy0->m_uniqueId : -1;
const int uidA1 = p.m_pProxy1 ? p.m_pProxy1->m_uniqueId : -1;
indices[i].m_uidA0 = uidA0;
indices[i].m_uidA1 = uidA1;
indices[i].m_orgIndex = i;
}
indices.quickSort(MyPairIndeSortPredicate());
}
{
BT_PROFILE("btHashedOverlappingPairCache::processAllOverlappingPairs");
int i;
for (i=0;i<indices.size();)
{
btBroadphasePair* pair = &pa[indices[i].m_orgIndex];
if (callback->processOverlap(*pair))
{
removeOverlappingPair(pair->m_pProxy0,pair->m_pProxy1,dispatcher);
} else
{
i++;
}
}
}
} else
{
processAllOverlappingPairs(callback, dispatcher);
}
}
void b3HashedOverlappingPairCache::processAllOverlappingPairs(b3OverlapCallback* callback,b3Dispatcher* dispatcher)
{
int i;
// printf("m_overlappingPairArray.size()=%d\n",m_overlappingPairArray.size());
for (i=0;i<m_overlappingPairArray.size();)
{
b3BroadphasePair* pair = &m_overlappingPairArray[i];
if (callback->processOverlap(*pair))
{
removeOverlappingPair(pair->x,pair->y,dispatcher);
b3g_overlappingPairs--;
} else
{
i++;
}
}
}
