CPU implementation of btCudaBroadphase added.
It is called bt3DGridBroadphase and btCudaBroadphase is now derived from it rater than from btSimpleBroadphase Test of bt3DGridBroadphase was added to CDTestFramework
This commit is contained in:
rponom
@@ -34,39 +34,8 @@ btCudaBroadphase::btCudaBroadphase(const btVector3& worldAabbMin,const btVector3
|
||||
int maxSmallProxies, int maxLargeProxies, int maxPairsPerBody,
|
||||
int maxBodiesPerCell,
|
||||
btScalar cellFactorAABB) :
|
||||
btSimpleBroadphase(maxSmallProxies,
|
||||
// new (btAlignedAlloc(sizeof(btSortedOverlappingPairCache),16)) btSortedOverlappingPairCache),
|
||||
new (btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache),
|
||||
m_bInitialized(false),
|
||||
m_numBodies(0)
|
||||
bt3DGridBroadphase(worldAabbMin, worldAabbMax, gridSizeX, gridSizeY, gridSizeZ, maxSmallProxies, maxLargeProxies, maxPairsPerBody, maxBodiesPerCell,cellFactorAABB)
|
||||
{
|
||||
m_ownsPairCache = true;
|
||||
m_params.m_gridSizeX = gridSizeX;
|
||||
m_params.m_gridSizeY = gridSizeY;
|
||||
m_params.m_gridSizeZ = gridSizeZ;
|
||||
m_params.m_numCells = m_params.m_gridSizeX * m_params.m_gridSizeY * m_params.m_gridSizeZ;
|
||||
btVector3 w_org = worldAabbMin;
|
||||
m_params.m_worldOriginX = w_org.getX();
|
||||
m_params.m_worldOriginY = w_org.getY();
|
||||
m_params.m_worldOriginZ = w_org.getZ();
|
||||
btVector3 w_size = worldAabbMax - worldAabbMin;
|
||||
m_params.m_cellSizeX = w_size.getX() / m_params.m_gridSizeX;
|
||||
m_params.m_cellSizeY = w_size.getY() / m_params.m_gridSizeY;
|
||||
m_params.m_cellSizeZ = w_size.getZ() / m_params.m_gridSizeZ;
|
||||
m_maxRadius = btMin(btMin(m_params.m_cellSizeX, m_params.m_cellSizeY), m_params.m_cellSizeZ);
|
||||
m_maxRadius *= btScalar(0.5f);
|
||||
m_params.m_numBodies = m_numBodies;
|
||||
m_params.m_maxBodiesPerCell = maxBodiesPerCell;
|
||||
|
||||
m_numLargeHandles = 0;
|
||||
m_maxLargeHandles = maxLargeProxies;
|
||||
|
||||
m_maxPairsPerBody = maxPairsPerBody;
|
||||
|
||||
m_cellFactorAABB = cellFactorAABB;
|
||||
|
||||
m_LastLargeHandleIndex = -1;
|
||||
|
||||
_initialize();
|
||||
} // btCudaBroadphase::btCudaBroadphase()
|
||||
|
||||
@@ -83,34 +52,6 @@ btCudaBroadphase::~btCudaBroadphase()
|
||||
|
||||
void btCudaBroadphase::_initialize()
|
||||
{
|
||||
assert(!m_bInitialized);
|
||||
// allocate host storage
|
||||
m_hBodiesHash = new unsigned int[m_maxHandles * 2];
|
||||
memset(m_hBodiesHash, 0x00, m_maxHandles*2*sizeof(unsigned int));
|
||||
|
||||
m_hCellStart = new unsigned int[m_params.m_numCells];
|
||||
memset(m_hCellStart, 0x00, m_params.m_numCells * sizeof(unsigned int));
|
||||
|
||||
m_hPairBuffStartCurr = new unsigned int[m_maxHandles * 2 + 2];
|
||||
// --------------- for now, init with m_maxPairsPerBody for each body
|
||||
m_hPairBuffStartCurr[0] = 0;
|
||||
m_hPairBuffStartCurr[1] = 0;
|
||||
for(int i = 1; i <= m_maxHandles; i++)
|
||||
{
|
||||
m_hPairBuffStartCurr[i * 2] = m_hPairBuffStartCurr[(i-1) * 2] + m_maxPairsPerBody;
|
||||
m_hPairBuffStartCurr[i * 2 + 1] = 0;
|
||||
}
|
||||
//----------------
|
||||
unsigned int numAABB = m_maxHandles + m_maxLargeHandles;
|
||||
m_hAABB = new btCuda3F1U[numAABB * 2]; // AABB Min & Max
|
||||
|
||||
m_hPairBuff = new unsigned int[m_maxHandles * m_maxPairsPerBody];
|
||||
memset(m_hPairBuff, 0x00, m_maxHandles * m_maxPairsPerBody * sizeof(unsigned int)); // needed?
|
||||
|
||||
m_hPairScan = new unsigned int[m_maxHandles + 1];
|
||||
|
||||
m_hPairOut = new unsigned int[m_maxHandles * m_maxPairsPerBody];
|
||||
|
||||
// allocate GPU data
|
||||
btCuda_allocateArray((void**)&m_dBodiesHash[0], m_maxHandles * 2 * sizeof(unsigned int));
|
||||
btCuda_allocateArray((void**)&m_dBodiesHash[1], m_maxHandles * 2 * sizeof(unsigned int));
|
||||
@@ -123,34 +64,12 @@ void btCudaBroadphase::_initialize()
|
||||
btCuda_allocateArray((void**)&m_dPairBuffStartCurr, (m_maxHandles * 2 + 1) * sizeof(unsigned int));
|
||||
btCuda_copyArrayToDevice(m_dPairBuffStartCurr, m_hPairBuffStartCurr, (m_maxHandles * 2 + 1) * sizeof(unsigned int));
|
||||
|
||||
unsigned int numAABB = m_maxHandles + m_maxLargeHandles;
|
||||
btCuda_allocateArray((void**)&m_dAABB, numAABB * sizeof(btCuda3F1U) * 2);
|
||||
|
||||
btCuda_allocateArray((void**)&m_dPairScan, (m_maxHandles + 1) * sizeof(unsigned int));
|
||||
|
||||
btCuda_allocateArray((void**)&m_dPairOut, m_maxHandles * m_maxPairsPerBody * sizeof(unsigned int));
|
||||
|
||||
btCuda_setParameters(&m_params);
|
||||
|
||||
// large proxies
|
||||
|
||||
// allocate handles buffer and put all handles on free list
|
||||
m_pLargeHandlesRawPtr = btAlignedAlloc(sizeof(btSimpleBroadphaseProxy) * m_maxLargeHandles, 16);
|
||||
m_pLargeHandles = new(m_pLargeHandlesRawPtr) btSimpleBroadphaseProxy[m_maxLargeHandles];
|
||||
m_firstFreeLargeHandle = 0;
|
||||
{
|
||||
for (int i = m_firstFreeLargeHandle; i < m_maxLargeHandles; i++)
|
||||
{
|
||||
m_pLargeHandles[i].SetNextFree(i + 1);
|
||||
m_pLargeHandles[i].m_uniqueId = m_maxHandles+2+i;
|
||||
}
|
||||
m_pLargeHandles[m_maxLargeHandles - 1].SetNextFree(0);
|
||||
}
|
||||
|
||||
// debug data
|
||||
m_numPairsAdded = 0;
|
||||
m_numOverflows = 0;
|
||||
|
||||
m_bInitialized = true;
|
||||
} // btCudaBroadphase::_initialize()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
@@ -179,324 +98,104 @@ void btCudaBroadphase::_finalize()
|
||||
m_bInitialized = false;
|
||||
} // btCudaBroadphase::_finalize()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
//--------------------------------------------------------------------------
|
||||
//
|
||||
// overrides for CUDA version
|
||||
//
|
||||
//--------------------------------------------------------------------------
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher)
|
||||
void btCudaBroadphase::prepareAABB()
|
||||
{
|
||||
if(m_numHandles <= 0)
|
||||
{
|
||||
BT_PROFILE("addLarge2LargePairsToCache -- CPU");
|
||||
addLarge2LargePairsToCache(dispatcher);
|
||||
return;
|
||||
}
|
||||
bt3DGridBroadphase::prepareAABB();
|
||||
btCuda_copyArrayToDevice(m_dAABB, m_hAABB, sizeof(btCuda3F1U) * 2 * (m_numHandles + m_numLargeHandles));
|
||||
return;
|
||||
} // btCudaBroadphase::prepareAABB()
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
// update constants
|
||||
btCuda_setParameters(&m_params);
|
||||
void btCudaBroadphase::setParameters(btCudaBroadphaseParams* hostParams)
|
||||
{
|
||||
btCuda_setParameters(hostParams);
|
||||
return;
|
||||
} // btCudaBroadphase::setParameters()
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
// move AABB array to GPU
|
||||
{
|
||||
BT_PROFILE("copy AABB");
|
||||
// do it faster ?
|
||||
btCuda3F1U* pBB = m_hAABB;
|
||||
int i;
|
||||
int new_largest_index = -1;
|
||||
unsigned int num_small = 0;
|
||||
|
||||
for(i = 0; i <= m_LastHandleIndex; i++)
|
||||
{
|
||||
btSimpleBroadphaseProxy* proxy0 = &m_pHandles[i];
|
||||
if(!proxy0->m_clientObject)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
new_largest_index = i;
|
||||
pBB->fx = proxy0->m_aabbMin.getX();
|
||||
pBB->fy = proxy0->m_aabbMin.getY();
|
||||
pBB->fz = proxy0->m_aabbMin.getZ();
|
||||
pBB->uw = i;
|
||||
pBB++;
|
||||
pBB->fx = proxy0->m_aabbMax.getX();
|
||||
pBB->fy = proxy0->m_aabbMax.getY();
|
||||
pBB->fz = proxy0->m_aabbMax.getZ();
|
||||
pBB->uw = num_small;
|
||||
pBB++;
|
||||
num_small++;
|
||||
}
|
||||
m_LastHandleIndex = new_largest_index;
|
||||
new_largest_index = -1;
|
||||
unsigned int num_large = 0;
|
||||
for(i = 0; i <= m_LastLargeHandleIndex; i++)
|
||||
{
|
||||
btSimpleBroadphaseProxy* proxy0 = &m_pLargeHandles[i];
|
||||
if(!proxy0->m_clientObject)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
new_largest_index = i;
|
||||
pBB->fx = proxy0->m_aabbMin.getX();
|
||||
pBB->fy = proxy0->m_aabbMin.getY();
|
||||
pBB->fz = proxy0->m_aabbMin.getZ();
|
||||
pBB->uw = i + m_maxHandles;
|
||||
pBB++;
|
||||
pBB->fx = proxy0->m_aabbMax.getX();
|
||||
pBB->fy = proxy0->m_aabbMax.getY();
|
||||
pBB->fz = proxy0->m_aabbMax.getZ();
|
||||
pBB->uw = num_large + m_maxHandles;
|
||||
pBB++;
|
||||
num_large++;
|
||||
}
|
||||
m_LastLargeHandleIndex = new_largest_index;
|
||||
// paranoid checks
|
||||
btAssert(num_small == m_numHandles);
|
||||
btAssert(num_large == m_numLargeHandles);
|
||||
}
|
||||
|
||||
{
|
||||
BT_PROFILE("CopyBB to CUDA");
|
||||
btCuda_copyArrayToDevice(m_dAABB, m_hAABB, sizeof(btCuda3F1U) * 2 * (m_numHandles + m_numLargeHandles));
|
||||
}
|
||||
// calculate hash
|
||||
{
|
||||
BT_PROFILE("calcHash -- CUDA");
|
||||
btCuda_calcHashAABB(m_dAABB, m_dBodiesHash[0], m_numHandles);
|
||||
}
|
||||
void btCudaBroadphase::calcHashAABB()
|
||||
{
|
||||
BT_PROFILE("btCuda_calcHashAABB");
|
||||
btCuda_calcHashAABB(m_dAABB, m_dBodiesHash[0], m_numHandles);
|
||||
// btCuda_copyArrayFromDevice((void*)m_hBodiesHash, (void*)m_dBodiesHash[0], sizeof(unsigned int) * 2 * m_numHandles);
|
||||
// sort bodies based on hash
|
||||
{
|
||||
BT_PROFILE("RadixSort-- CUDA");
|
||||
RadixSort((KeyValuePair*)m_dBodiesHash[0], (KeyValuePair*)m_dBodiesHash[1], m_numHandles, 32);
|
||||
}
|
||||
// find start of each cell
|
||||
{
|
||||
BT_PROFILE("Find cell start -- CUDA");
|
||||
btCuda_findCellStart(m_dBodiesHash[0], m_dCellStart, m_numHandles, m_params.m_numCells);
|
||||
}
|
||||
return;
|
||||
} // btCudaBroadphase::calcHashAABB()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::sortHash()
|
||||
{
|
||||
BT_PROFILE("RadixSort-- CUDA");
|
||||
RadixSort((KeyValuePair*)m_dBodiesHash[0], (KeyValuePair*)m_dBodiesHash[1], m_numHandles, 32);
|
||||
return;
|
||||
} // btCudaBroadphase::sortHash()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::findCellStart()
|
||||
{
|
||||
BT_PROFILE("btCuda_findCellStart");
|
||||
btCuda_findCellStart(m_dBodiesHash[0], m_dCellStart, m_numHandles, m_params.m_numCells);
|
||||
// btCuda_copyArrayFromDevice((void*)m_hBodiesHash, (void*)m_dBodiesHash[0], sizeof(unsigned int) * 2 * m_numHandles);
|
||||
// btCuda_copyArrayFromDevice((void*)m_hCellStart, (void*)m_dCellStart, sizeof(unsigned int) * m_params.m_numCells);
|
||||
{
|
||||
BT_PROFILE("FindOverlappingPairs -- CUDA");
|
||||
btCuda_findOverlappingPairs(m_dAABB, m_dBodiesHash[0], m_dCellStart, m_dPairBuff, m_dPairBuffStartCurr, m_numHandles);
|
||||
}
|
||||
{
|
||||
BT_PROFILE("FindPairsLarge -- CUDA");
|
||||
btCuda_findPairsLarge(m_dAABB, m_dBodiesHash[0], m_dCellStart, m_dPairBuff, m_dPairBuffStartCurr, m_numHandles, m_numLargeHandles);
|
||||
}
|
||||
{
|
||||
BT_PROFILE("ComputePairCacheChanges -- CUDA");
|
||||
btCuda_computePairCacheChanges(m_dPairBuff, m_dPairBuffStartCurr, m_dPairScan, m_dAABB, m_numHandles);
|
||||
}
|
||||
{
|
||||
BT_PROFILE("scanOverlappingPairBuff -- CPU");
|
||||
btCuda_copyArrayFromDevice(m_hPairScan, m_dPairScan, sizeof(unsigned int)*(m_numHandles + 1));
|
||||
scanOverlappingPairBuffCPU();
|
||||
btCuda_copyArrayToDevice(m_dPairScan, m_hPairScan, sizeof(unsigned int)*(m_numHandles + 1));
|
||||
}
|
||||
{
|
||||
BT_PROFILE("SqueezeOverlappingPairBuff -- CUDA");
|
||||
btCuda_squeezeOverlappingPairBuff(m_dPairBuff, m_dPairBuffStartCurr, m_dPairScan, m_dPairOut, m_dAABB, m_numHandles);
|
||||
}
|
||||
{
|
||||
BT_PROFILE("SqueezeOverlappingPairBuff -- CUDA");
|
||||
btCuda_copyArrayFromDevice(m_hPairOut, m_dPairOut, sizeof(unsigned int) * m_hPairScan[m_numHandles]);
|
||||
}
|
||||
{
|
||||
BT_PROFILE("addPairsToCache -- CPU");
|
||||
addPairsToCacheCPU(dispatcher);
|
||||
}
|
||||
{
|
||||
BT_PROFILE("addLarge2LargePairsToCache -- CPU");
|
||||
addLarge2LargePairsToCache(dispatcher);
|
||||
}
|
||||
return;
|
||||
} // btCudaBroadphase::calculateOverlappingPairs()
|
||||
} // btCudaBroadphase::findCellStart()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::scanOverlappingPairBuffCPU()
|
||||
void btCudaBroadphase::findOverlappingPairs()
|
||||
{
|
||||
m_hPairScan[0] = 0;
|
||||
for(int i = 1; i <= m_numHandles; i++)
|
||||
{
|
||||
unsigned int delta = m_hPairScan[i];
|
||||
m_hPairScan[i] = m_hPairScan[i-1] + delta;
|
||||
}
|
||||
} // btCudaBroadphase::scanOverlappingPairBuffCPU()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::addPairsToCacheCPU(btDispatcher* dispatcher)
|
||||
{
|
||||
m_numPairsAdded = 0;
|
||||
m_numPairsRemoved = 0;
|
||||
for(int i = 0; i < m_numHandles; i++)
|
||||
{
|
||||
unsigned int num = m_hPairScan[i+1] - m_hPairScan[i];
|
||||
if(!num)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
unsigned int* pInp = m_hPairOut + m_hPairScan[i];
|
||||
unsigned int index0 = m_hAABB[i * 2].uw;
|
||||
btSimpleBroadphaseProxy* proxy0 = &m_pHandles[index0];
|
||||
for(unsigned int j = 0; j < num; j++)
|
||||
{
|
||||
unsigned int indx1_s = pInp[j];
|
||||
unsigned int index1 = indx1_s & (~BT_CUDA_PAIR_ANY_FLG);
|
||||
btSimpleBroadphaseProxy* proxy1;
|
||||
if(index1 < (unsigned int)m_maxHandles)
|
||||
{
|
||||
proxy1 = &m_pHandles[index1];
|
||||
}
|
||||
else
|
||||
{
|
||||
index1 -= m_maxHandles;
|
||||
btAssert((index1 >= 0) && (index1 < (unsigned int)m_maxLargeHandles));
|
||||
proxy1 = &m_pLargeHandles[index1];
|
||||
}
|
||||
if(indx1_s & BT_CUDA_PAIR_NEW_FLG)
|
||||
{
|
||||
m_pairCache->addOverlappingPair(proxy0,proxy1);
|
||||
m_numPairsAdded++;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pairCache->removeOverlappingPair(proxy0,proxy1,dispatcher);
|
||||
m_numPairsRemoved++;
|
||||
}
|
||||
}
|
||||
}
|
||||
} // btCudaBroadphase::addPairsToCacheCPU()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
btBroadphaseProxy* btCudaBroadphase::createProxy( const btVector3& aabbMin, const btVector3& aabbMax,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* multiSapProxy)
|
||||
{
|
||||
btBroadphaseProxy* proxy;
|
||||
bool bIsLarge = isLargeProxy(aabbMin, aabbMax);
|
||||
if(bIsLarge)
|
||||
{
|
||||
if (m_numLargeHandles >= m_maxLargeHandles)
|
||||
{
|
||||
btAssert(0);
|
||||
return 0; //should never happen, but don't let the game crash ;-)
|
||||
}
|
||||
btAssert((aabbMin[0]<= aabbMax[0]) && (aabbMin[1]<= aabbMax[1]) && (aabbMin[2]<= aabbMax[2]));
|
||||
int newHandleIndex = allocLargeHandle();
|
||||
proxy = new (&m_pLargeHandles[newHandleIndex])btSimpleBroadphaseProxy(aabbMin,aabbMax,shapeType,userPtr,collisionFilterGroup,collisionFilterMask,multiSapProxy);
|
||||
}
|
||||
else
|
||||
{
|
||||
proxy = btSimpleBroadphase::createProxy(aabbMin, aabbMax, shapeType, userPtr, collisionFilterGroup, collisionFilterMask, dispatcher, multiSapProxy);
|
||||
}
|
||||
return proxy;
|
||||
} // btCudaBroadphase::createProxy()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::destroyProxy(btBroadphaseProxy* proxy, btDispatcher* dispatcher)
|
||||
{
|
||||
bool bIsLarge = isLargeProxy(proxy);
|
||||
if(bIsLarge)
|
||||
{
|
||||
|
||||
btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxy);
|
||||
freeLargeHandle(proxy0);
|
||||
// TODO : remove pair from cache on GPU as well !!!
|
||||
// UPD: they will not be used anyway, so don't waste time
|
||||
m_pairCache->removeOverlappingPairsContainingProxy(proxy,dispatcher);
|
||||
}
|
||||
else
|
||||
{
|
||||
btSimpleBroadphase::destroyProxy(proxy, dispatcher);
|
||||
}
|
||||
BT_PROFILE("btCuda_findOverlappingPairs");
|
||||
btCuda_findOverlappingPairs(m_dAABB, m_dBodiesHash[0], m_dCellStart, m_dPairBuff, m_dPairBuffStartCurr, m_numHandles);
|
||||
return;
|
||||
} // btCudaBroadphase::destroyProxy()
|
||||
} // btCudaBroadphase::findOverlappingPairs()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
bool btCudaBroadphase::isLargeProxy(const btVector3& aabbMin, const btVector3& aabbMax)
|
||||
void btCudaBroadphase::findPairsLarge()
|
||||
{
|
||||
btVector3 diag = aabbMax - aabbMin;
|
||||
btScalar radius = diag.length() * btScalar(0.5f);
|
||||
|
||||
radius *= m_cellFactorAABB; // user-defined factor
|
||||
|
||||
return (radius > m_maxRadius);
|
||||
} // btCudaBroadphase::isLargeProxy()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
bool btCudaBroadphase::isLargeProxy(btBroadphaseProxy* proxy)
|
||||
{
|
||||
return (proxy->getUid() >= (m_maxHandles+2));
|
||||
} // btCudaBroadphase::isLargeProxy()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::addLarge2LargePairsToCache(btDispatcher* dispatcher)
|
||||
{
|
||||
int i,j;
|
||||
if (m_numLargeHandles <= 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
int new_largest_index = -1;
|
||||
for(i = 0; i <= m_LastLargeHandleIndex; i++)
|
||||
{
|
||||
btSimpleBroadphaseProxy* proxy0 = &m_pLargeHandles[i];
|
||||
if(!proxy0->m_clientObject)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
new_largest_index = i;
|
||||
for(j = i + 1; j <= m_LastLargeHandleIndex; j++)
|
||||
{
|
||||
btSimpleBroadphaseProxy* proxy1 = &m_pLargeHandles[j];
|
||||
if(!proxy1->m_clientObject)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
btAssert(proxy0 != proxy1);
|
||||
btSimpleBroadphaseProxy* p0 = getSimpleProxyFromProxy(proxy0);
|
||||
btSimpleBroadphaseProxy* p1 = getSimpleProxyFromProxy(proxy1);
|
||||
if(aabbOverlap(p0,p1))
|
||||
{
|
||||
if (!m_pairCache->findPair(proxy0,proxy1))
|
||||
{
|
||||
m_pairCache->addOverlappingPair(proxy0,proxy1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(m_pairCache->findPair(proxy0,proxy1))
|
||||
{
|
||||
m_pairCache->removeOverlappingPair(proxy0,proxy1,dispatcher);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
m_LastLargeHandleIndex = new_largest_index;
|
||||
BT_PROFILE("btCuda_findPairsLarge");
|
||||
btCuda_findPairsLarge(m_dAABB, m_dBodiesHash[0], m_dCellStart, m_dPairBuff, m_dPairBuffStartCurr, m_numHandles, m_numLargeHandles);
|
||||
return;
|
||||
} // btCudaBroadphase::addLarge2LargePairsToCache()
|
||||
} // btCudaBroadphase::findPairsLarge()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback)
|
||||
void btCudaBroadphase::computePairCacheChanges()
|
||||
{
|
||||
btSimpleBroadphase::rayTest(rayFrom, rayTo, rayCallback);
|
||||
for (int i=0; i <= m_LastLargeHandleIndex; i++)
|
||||
{
|
||||
btSimpleBroadphaseProxy* proxy = &m_pLargeHandles[i];
|
||||
if(!proxy->m_clientObject)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
rayCallback.process(proxy);
|
||||
}
|
||||
} // btCudaBroadphase::rayTest()
|
||||
BT_PROFILE("btCuda_computePairCacheChanges");
|
||||
btCuda_computePairCacheChanges(m_dPairBuff, m_dPairBuffStartCurr, m_dPairScan, m_dAABB, m_numHandles);
|
||||
return;
|
||||
} // btCudaBroadphase::computePairCacheChanges()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::scanOverlappingPairBuff()
|
||||
{
|
||||
btCuda_copyArrayFromDevice(m_hPairScan, m_dPairScan, sizeof(unsigned int)*(m_numHandles + 1));
|
||||
bt3DGridBroadphase::scanOverlappingPairBuff();
|
||||
btCuda_copyArrayToDevice(m_dPairScan, m_hPairScan, sizeof(unsigned int)*(m_numHandles + 1));
|
||||
return;
|
||||
} // btCudaBroadphase::scanOverlappingPairBuff()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void btCudaBroadphase::squeezeOverlappingPairBuff()
|
||||
{
|
||||
BT_PROFILE("btCuda_squeezeOverlappingPairBuff");
|
||||
btCuda_squeezeOverlappingPairBuff(m_dPairBuff, m_dPairBuffStartCurr, m_dPairScan, m_dPairOut, m_dAABB, m_numHandles);
|
||||
btCuda_copyArrayFromDevice(m_hPairOut, m_dPairOut, sizeof(unsigned int) * m_hPairScan[m_numHandles]);
|
||||
return;
|
||||
} // btCudaBroadphase::squeezeOverlappingPairBuff()
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user