godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/thirdparty/bullet/Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.cpp

1367 lines
38 KiB
C++
Raw Normal View History

Vendor thirdparty Bullet source for upcoming physics server backend
2017-08-01 12:30:58 +00:00
bool searchIncremental3dSapOnGpu = true;
#include <limits.h>
#include "b3GpuSapBroadphase.h"
#include "Bullet3Common/b3Vector3.h"
#include "Bullet3OpenCL/ParallelPrimitives/b3LauncherCL.h"
#include "Bullet3OpenCL/ParallelPrimitives/b3PrefixScanFloat4CL.h"
#include "Bullet3OpenCL/Initialize/b3OpenCLUtils.h"
#include "kernels/sapKernels.h"
#include "Bullet3Common/b3MinMax.h"
#define B3_BROADPHASE_SAP_PATH "src/Bullet3OpenCL/BroadphaseCollision/kernels/sap.cl"
/*
b3OpenCLArray<int> m_pairCount;
b3OpenCLArray<b3SapAabb> m_allAabbsGPU;
b3AlignedObjectArray<b3SapAabb> m_allAabbsCPU;
virtual b3OpenCLArray<b3SapAabb>& getAllAabbsGPU()
{
return m_allAabbsGPU;
}
virtual b3AlignedObjectArray<b3SapAabb>& getAllAabbsCPU()
{
return m_allAabbsCPU;
}
b3OpenCLArray<b3Vector3> m_sum;
b3OpenCLArray<b3Vector3> m_sum2;
b3OpenCLArray<b3Vector3> m_dst;
b3OpenCLArray<int> m_smallAabbsMappingGPU;
b3AlignedObjectArray<int> m_smallAabbsMappingCPU;
b3OpenCLArray<int> m_largeAabbsMappingGPU;
b3AlignedObjectArray<int> m_largeAabbsMappingCPU;
b3OpenCLArray<b3Int4> m_overlappingPairs;
//temporary gpu work memory
b3OpenCLArray<b3SortData> m_gpuSmallSortData;
b3OpenCLArray<b3SapAabb> m_gpuSmallSortedAabbs;
class b3PrefixScanFloat4CL* m_prefixScanFloat4;
*/
b3GpuSapBroadphase::b3GpuSapBroadphase(cl_context ctx,cl_device_id device, cl_command_queue q , b3GpuSapKernelType kernelType)
:m_context(ctx),
m_device(device),
m_queue(q),
m_objectMinMaxIndexGPUaxis0(ctx,q),
m_objectMinMaxIndexGPUaxis1(ctx,q),
m_objectMinMaxIndexGPUaxis2(ctx,q),
m_objectMinMaxIndexGPUaxis0prev(ctx,q),
m_objectMinMaxIndexGPUaxis1prev(ctx,q),
m_objectMinMaxIndexGPUaxis2prev(ctx,q),
m_sortedAxisGPU0(ctx,q),
m_sortedAxisGPU1(ctx,q),
m_sortedAxisGPU2(ctx,q),
m_sortedAxisGPU0prev(ctx,q),
m_sortedAxisGPU1prev(ctx,q),
m_sortedAxisGPU2prev(ctx,q),
m_addedHostPairsGPU(ctx,q),
m_removedHostPairsGPU(ctx,q),
m_addedCountGPU(ctx,q),
m_removedCountGPU(ctx,q),
m_currentBuffer(-1),
m_pairCount(ctx,q),
m_allAabbsGPU(ctx,q),
m_sum(ctx,q),
m_sum2(ctx,q),
m_dst(ctx,q),
m_smallAabbsMappingGPU(ctx,q),
m_largeAabbsMappingGPU(ctx,q),
m_overlappingPairs(ctx,q),
m_gpuSmallSortData(ctx,q),
m_gpuSmallSortedAabbs(ctx,q)
{
const char* sapSrc = sapCL;
cl_int errNum=0;
b3Assert(m_context);
b3Assert(m_device);
cl_program sapProg = b3OpenCLUtils::compileCLProgramFromString(m_context,m_device,sapSrc,&errNum,"",B3_BROADPHASE_SAP_PATH);
b3Assert(errNum==CL_SUCCESS);
b3Assert(errNum==CL_SUCCESS);
#ifndef __APPLE__
m_prefixScanFloat4 = new b3PrefixScanFloat4CL(m_context,m_device,m_queue);
#else
m_prefixScanFloat4 = 0;
#endif
m_sapKernel = 0;
switch (kernelType)
{
case B3_GPU_SAP_KERNEL_BRUTE_FORCE_CPU:
{
m_sapKernel=0;
break;
}
case B3_GPU_SAP_KERNEL_BRUTE_FORCE_GPU:
{
m_sapKernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "computePairsKernelBruteForce",&errNum,sapProg );
break;
}
case B3_GPU_SAP_KERNEL_ORIGINAL:
{
m_sapKernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "computePairsKernelOriginal",&errNum,sapProg );
break;
}
case B3_GPU_SAP_KERNEL_BARRIER:
{
m_sapKernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "computePairsKernelBarrier",&errNum,sapProg );
break;
}
case B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY:
{
m_sapKernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "computePairsKernelLocalSharedMemory",&errNum,sapProg );
break;
}
default:
{
m_sapKernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "computePairsKernelLocalSharedMemory",&errNum,sapProg );
b3Error("Unknown 3D GPU SAP provided, fallback to computePairsKernelLocalSharedMemory");
}
};
m_sap2Kernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "computePairsKernelTwoArrays",&errNum,sapProg );
b3Assert(errNum==CL_SUCCESS);
m_prepareSumVarianceKernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "prepareSumVarianceKernel",&errNum,sapProg );
b3Assert(errNum==CL_SUCCESS);
m_flipFloatKernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "flipFloatKernel",&errNum,sapProg );
m_copyAabbsKernel= b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "copyAabbsKernel",&errNum,sapProg );
m_scatterKernel = b3OpenCLUtils::compileCLKernelFromString(m_context, m_device,sapSrc, "scatterKernel",&errNum,sapProg );
m_sorter = new b3RadixSort32CL(m_context,m_device,m_queue);
}
b3GpuSapBroadphase::~b3GpuSapBroadphase()
{
delete m_sorter;
delete m_prefixScanFloat4;
clReleaseKernel(m_scatterKernel);
clReleaseKernel(m_flipFloatKernel);
clReleaseKernel(m_copyAabbsKernel);
clReleaseKernel(m_sapKernel);
clReleaseKernel(m_sap2Kernel);
clReleaseKernel(m_prepareSumVarianceKernel);
}
/// conservative test for overlap between two aabbs
static bool TestAabbAgainstAabb2(const b3Vector3 &aabbMin1, const b3Vector3 &aabbMax1,
const b3Vector3 &aabbMin2, const b3Vector3 &aabbMax2)
{
bool overlap = true;
overlap = (aabbMin1.getX() > aabbMax2.getX() || aabbMax1.getX() < aabbMin2.getX()) ? false : overlap;
overlap = (aabbMin1.getZ() > aabbMax2.getZ() || aabbMax1.getZ() < aabbMin2.getZ()) ? false : overlap;
overlap = (aabbMin1.getY() > aabbMax2.getY() || aabbMax1.getY() < aabbMin2.getY()) ? false : overlap;
return overlap;
}
//http://stereopsis.com/radix.html
static unsigned int FloatFlip(float fl)
{
unsigned int f = *(unsigned int*)&fl;
unsigned int mask = -(int)(f >> 31) | 0x80000000;
return f ^ mask;
};
void b3GpuSapBroadphase::init3dSap()
{
if (m_currentBuffer<0)
{
m_allAabbsGPU.copyToHost(m_allAabbsCPU);
m_currentBuffer = 0;
for (int axis=0;axis<3;axis++)
{
for (int buf=0;buf<2;buf++)
{
int totalNumAabbs = m_allAabbsCPU.size();
int numEndPoints = 2*totalNumAabbs;
m_sortedAxisCPU[axis][buf].resize(numEndPoints);
if (buf==m_currentBuffer)
{
for (int i=0;i<totalNumAabbs;i++)
{
m_sortedAxisCPU[axis][buf][i*2].m_key = FloatFlip(m_allAabbsCPU[i].m_min[axis])-1;
m_sortedAxisCPU[axis][buf][i*2].m_value = i*2;
m_sortedAxisCPU[axis][buf][i*2+1].m_key = FloatFlip(m_allAabbsCPU[i].m_max[axis])+1;
m_sortedAxisCPU[axis][buf][i*2+1].m_value = i*2+1;
}
}
}
}
for (int axis=0;axis<3;axis++)
{
m_sorter->executeHost(m_sortedAxisCPU[axis][m_currentBuffer]);
}
for (int axis=0;axis<3;axis++)
{
//int totalNumAabbs = m_allAabbsCPU.size();
int numEndPoints = m_sortedAxisCPU[axis][m_currentBuffer].size();
m_objectMinMaxIndexCPU[axis][m_currentBuffer].resize(numEndPoints);
for (int i=0;i<numEndPoints;i++)
{
int destIndex = m_sortedAxisCPU[axis][m_currentBuffer][i].m_value;
int newDest = destIndex/2;
if (destIndex&1)
{
m_objectMinMaxIndexCPU[axis][m_currentBuffer][newDest].y=i;
} else
{
m_objectMinMaxIndexCPU[axis][m_currentBuffer][newDest].x=i;
}
}
}
}
}
static bool b3PairCmp(const b3Int4& p, const b3Int4& q)
{
return ((p.x<q.x) || ((p.x==q.x) && (p.y<q.y)));
}
static bool operator==(const b3Int4& a,const b3Int4& b)
{
return a.x == b.x && a.y == b.y;
};
static bool operator<(const b3Int4& a,const b3Int4& b)
{
return a.x < b.x || (a.x == b.x && a.y < b.y);
};
static bool operator>(const b3Int4& a,const b3Int4& b)
{
return a.x > b.x || (a.x == b.x && a.y > b.y);
};
b3AlignedObjectArray<b3Int4> addedHostPairs;
b3AlignedObjectArray<b3Int4> removedHostPairs;
b3AlignedObjectArray<b3SapAabb> preAabbs;
void b3GpuSapBroadphase::calculateOverlappingPairsHostIncremental3Sap()
{
//static int framepje = 0;
//printf("framepje=%d\n",framepje++);
B3_PROFILE("calculateOverlappingPairsHostIncremental3Sap");
addedHostPairs.resize(0);
removedHostPairs.resize(0);
b3Assert(m_currentBuffer>=0);
{
preAabbs.resize(m_allAabbsCPU.size());
for (int i=0;i<preAabbs.size();i++)
{
preAabbs[i]=m_allAabbsCPU[i];
}
}
if (m_currentBuffer<0)
return;
{
B3_PROFILE("m_allAabbsGPU.copyToHost");
m_allAabbsGPU.copyToHost(m_allAabbsCPU);
}
b3AlignedObjectArray<b3Int4> allPairs;
{
B3_PROFILE("m_overlappingPairs.copyToHost");
m_overlappingPairs.copyToHost(allPairs);
}
if (0)
{
{
printf("ab[40].min=%f,%f,%f,ab[40].max=%f,%f,%f\n",
m_allAabbsCPU[40].m_min[0], m_allAabbsCPU[40].m_min[1],m_allAabbsCPU[40].m_min[2],
m_allAabbsCPU[40].m_max[0], m_allAabbsCPU[40].m_max[1],m_allAabbsCPU[40].m_max[2]);
}
{
printf("ab[53].min=%f,%f,%f,ab[53].max=%f,%f,%f\n",
m_allAabbsCPU[53].m_min[0], m_allAabbsCPU[53].m_min[1],m_allAabbsCPU[53].m_min[2],
m_allAabbsCPU[53].m_max[0], m_allAabbsCPU[53].m_max[1],m_allAabbsCPU[53].m_max[2]);
}
{
b3Int4 newPair;
newPair.x = 40;
newPair.y = 53;
int index = allPairs.findBinarySearch(newPair);
printf("hasPair(40,53)=%d out of %d\n",index, allPairs.size());
{
int overlap = TestAabbAgainstAabb2((const b3Vector3&)m_allAabbsCPU[40].m_min, (const b3Vector3&)m_allAabbsCPU[40].m_max,(const b3Vector3&)m_allAabbsCPU[53].m_min,(const b3Vector3&)m_allAabbsCPU[53].m_max);
printf("overlap=%d\n",overlap);
}
if (preAabbs.size())
{
int prevOverlap = TestAabbAgainstAabb2((const b3Vector3&)preAabbs[40].m_min, (const b3Vector3&)preAabbs[40].m_max,(const b3Vector3&)preAabbs[53].m_min,(const b3Vector3&)preAabbs[53].m_max);
printf("prevoverlap=%d\n",prevOverlap);
} else
{
printf("unknown prevoverlap\n");
}
}
}
if (0)
{
for (int i=0;i<m_allAabbsCPU.size();i++)
{
//printf("aabb[%d] min=%f,%f,%f max=%f,%f,%f\n",i,m_allAabbsCPU[i].m_min[0],m_allAabbsCPU[i].m_min[1],m_allAabbsCPU[i].m_min[2], m_allAabbsCPU[i].m_max[0],m_allAabbsCPU[i].m_max[1],m_allAabbsCPU[i].m_max[2]);
}
for (int axis=0;axis<3;axis++)
{
for (int buf=0;buf<2;buf++)
{
b3Assert(m_sortedAxisCPU[axis][buf].size() == m_allAabbsCPU.size()*2);
}
}
}
m_currentBuffer = 1-m_currentBuffer;
int totalNumAabbs = m_allAabbsCPU.size();
{
B3_PROFILE("assign m_sortedAxisCPU(FloatFlip)");
for (int i=0;i<totalNumAabbs;i++)
{
unsigned int keyMin[3];
unsigned int keyMax[3];
for (int axis=0;axis<3;axis++)
{
float vmin=m_allAabbsCPU[i].m_min[axis];
float vmax = m_allAabbsCPU[i].m_max[axis];
keyMin[axis] = FloatFlip(vmin);
keyMax[axis] = FloatFlip(vmax);
m_sortedAxisCPU[axis][m_currentBuffer][i*2].m_key = keyMin[axis]-1;
m_sortedAxisCPU[axis][m_currentBuffer][i*2].m_value = i*2;
m_sortedAxisCPU[axis][m_currentBuffer][i*2+1].m_key = keyMax[axis]+1;
m_sortedAxisCPU[axis][m_currentBuffer][i*2+1].m_value = i*2+1;
}
//printf("aabb[%d] min=%u,%u,%u max %u,%u,%u\n", i,keyMin[0],keyMin[1],keyMin[2],keyMax[0],keyMax[1],keyMax[2]);
}
}
{
B3_PROFILE("sort m_sortedAxisCPU");
for (int axis=0;axis<3;axis++)
m_sorter->executeHost(m_sortedAxisCPU[axis][m_currentBuffer]);
}
#if 0
if (0)
{
for (int axis=0;axis<3;axis++)
{
//printf("axis %d\n",axis);
for (int i=0;i<m_sortedAxisCPU[axis][m_currentBuffer].size();i++)
{
//int key = m_sortedAxisCPU[axis][m_currentBuffer][i].m_key;
//int value = m_sortedAxisCPU[axis][m_currentBuffer][i].m_value;
//printf("[%d]=%d\n",i,value);
}
}
}
#endif
{
B3_PROFILE("assign m_objectMinMaxIndexCPU");
for (int axis=0;axis<3;axis++)
{
int totalNumAabbs = m_allAabbsCPU.size();
int numEndPoints = m_sortedAxisCPU[axis][m_currentBuffer].size();
m_objectMinMaxIndexCPU[axis][m_currentBuffer].resize(totalNumAabbs);
for (int i=0;i<numEndPoints;i++)
{
int destIndex = m_sortedAxisCPU[axis][m_currentBuffer][i].m_value;
int newDest = destIndex/2;
if (destIndex&1)
{
m_objectMinMaxIndexCPU[axis][m_currentBuffer][newDest].y=i;
} else
{
m_objectMinMaxIndexCPU[axis][m_currentBuffer][newDest].x=i;
}
}
}
}
#if 0
if (0)
{
printf("==========================\n");
for (int axis=0;axis<3;axis++)
{
unsigned int curMinIndex40 = m_objectMinMaxIndexCPU[axis][m_currentBuffer][40].x;
unsigned int curMaxIndex40 = m_objectMinMaxIndexCPU[axis][m_currentBuffer][40].y;
unsigned int prevMaxIndex40 = m_objectMinMaxIndexCPU[axis][1-m_currentBuffer][40].y;
unsigned int prevMinIndex40 = m_objectMinMaxIndexCPU[axis][1-m_currentBuffer][40].x;
int dmin40 = curMinIndex40 - prevMinIndex40;
int dmax40 = curMinIndex40 - prevMinIndex40;
printf("axis %d curMinIndex40=%d prevMinIndex40=%d\n",axis,curMinIndex40, prevMinIndex40);
printf("axis %d curMaxIndex40=%d prevMaxIndex40=%d\n",axis,curMaxIndex40, prevMaxIndex40);
}
printf(".........................\n");
for (int axis=0;axis<3;axis++)
{
unsigned int curMinIndex53 = m_objectMinMaxIndexCPU[axis][m_currentBuffer][53].x;
unsigned int curMaxIndex53 = m_objectMinMaxIndexCPU[axis][m_currentBuffer][53].y;
unsigned int prevMaxIndex53 = m_objectMinMaxIndexCPU[axis][1-m_currentBuffer][53].y;
unsigned int prevMinIndex53 = m_objectMinMaxIndexCPU[axis][1-m_currentBuffer][53].x;
int dmin40 = curMinIndex53 - prevMinIndex53;
int dmax40 = curMinIndex53 - prevMinIndex53;
printf("axis %d curMinIndex53=%d prevMinIndex53=%d\n",axis,curMinIndex53, prevMinIndex53);
printf("axis %d curMaxIndex53=%d prevMaxIndex53=%d\n",axis,curMaxIndex53, prevMaxIndex53);
}
}
#endif
int a = m_objectMinMaxIndexCPU[0][m_currentBuffer].size();
int b = m_objectMinMaxIndexCPU[1][m_currentBuffer].size();
int c = m_objectMinMaxIndexCPU[2][m_currentBuffer].size();
b3Assert(a==b);
b3Assert(b==c);
/*
if (searchIncremental3dSapOnGpu)
{
B3_PROFILE("computePairsIncremental3dSapKernelGPU");
int numObjects = m_objectMinMaxIndexCPU[0][m_currentBuffer].size();
int maxCapacity = 1024*1024;
{
B3_PROFILE("copy from host");
m_objectMinMaxIndexGPUaxis0.copyFromHost(m_objectMinMaxIndexCPU[0][m_currentBuffer]);
m_objectMinMaxIndexGPUaxis1.copyFromHost(m_objectMinMaxIndexCPU[1][m_currentBuffer]);
m_objectMinMaxIndexGPUaxis2.copyFromHost(m_objectMinMaxIndexCPU[2][m_currentBuffer]);
m_objectMinMaxIndexGPUaxis0prev.copyFromHost(m_objectMinMaxIndexCPU[0][1-m_currentBuffer]);
m_objectMinMaxIndexGPUaxis1prev.copyFromHost(m_objectMinMaxIndexCPU[1][1-m_currentBuffer]);
m_objectMinMaxIndexGPUaxis2prev.copyFromHost(m_objectMinMaxIndexCPU[2][1-m_currentBuffer]);
m_sortedAxisGPU0.copyFromHost(m_sortedAxisCPU[0][m_currentBuffer]);
m_sortedAxisGPU1.copyFromHost(m_sortedAxisCPU[1][m_currentBuffer]);
m_sortedAxisGPU2.copyFromHost(m_sortedAxisCPU[2][m_currentBuffer]);
m_sortedAxisGPU0prev.copyFromHost(m_sortedAxisCPU[0][1-m_currentBuffer]);
m_sortedAxisGPU1prev.copyFromHost(m_sortedAxisCPU[1][1-m_currentBuffer]);
m_sortedAxisGPU2prev.copyFromHost(m_sortedAxisCPU[2][1-m_currentBuffer]);
m_addedHostPairsGPU.resize(maxCapacity);
m_removedHostPairsGPU.resize(maxCapacity);
m_addedCountGPU.resize(0);
m_addedCountGPU.push_back(0);
m_removedCountGPU.resize(0);
m_removedCountGPU.push_back(0);
}
{
B3_PROFILE("launch1D");
b3LauncherCL launcher(m_queue, m_computePairsIncremental3dSapKernel,"m_computePairsIncremental3dSapKernel");
launcher.setBuffer(m_objectMinMaxIndexGPUaxis0.getBufferCL());
launcher.setBuffer(m_objectMinMaxIndexGPUaxis1.getBufferCL());
launcher.setBuffer(m_objectMinMaxIndexGPUaxis2.getBufferCL());
launcher.setBuffer(m_objectMinMaxIndexGPUaxis0prev.getBufferCL());
launcher.setBuffer(m_objectMinMaxIndexGPUaxis1prev.getBufferCL());
launcher.setBuffer(m_objectMinMaxIndexGPUaxis2prev.getBufferCL());
launcher.setBuffer(m_sortedAxisGPU0.getBufferCL());
launcher.setBuffer(m_sortedAxisGPU1.getBufferCL());
launcher.setBuffer(m_sortedAxisGPU2.getBufferCL());
launcher.setBuffer(m_sortedAxisGPU0prev.getBufferCL());
launcher.setBuffer(m_sortedAxisGPU1prev.getBufferCL());
launcher.setBuffer(m_sortedAxisGPU2prev.getBufferCL());
launcher.setBuffer(m_addedHostPairsGPU.getBufferCL());
launcher.setBuffer(m_removedHostPairsGPU.getBufferCL());
launcher.setBuffer(m_addedCountGPU.getBufferCL());
launcher.setBuffer(m_removedCountGPU.getBufferCL());
launcher.setConst(maxCapacity);
launcher.setConst( numObjects);
launcher.launch1D( numObjects);
clFinish(m_queue);
}
{
B3_PROFILE("copy to host");
int addedCountGPU = m_addedCountGPU.at(0);
m_addedHostPairsGPU.resize(addedCountGPU);
m_addedHostPairsGPU.copyToHost(addedHostPairs);
//printf("addedCountGPU=%d\n",addedCountGPU);
int removedCountGPU = m_removedCountGPU.at(0);
m_removedHostPairsGPU.resize(removedCountGPU);
m_removedHostPairsGPU.copyToHost(removedHostPairs);
//printf("removedCountGPU=%d\n",removedCountGPU);
}
}
else
*/
{
int numObjects = m_objectMinMaxIndexCPU[0][m_currentBuffer].size();
B3_PROFILE("actual search");
for (int i=0;i<numObjects;i++)
{
//int numObjects = m_objectMinMaxIndexCPU[axis][m_currentBuffer].size();
//int checkObjects[]={40,53};
//int numCheckObjects = sizeof(checkObjects)/sizeof(int);
//for (int a=0;a<numCheckObjects ;a++)
for (int axis=0;axis<3;axis++)
{
//int i = checkObjects[a];
unsigned int curMinIndex = m_objectMinMaxIndexCPU[axis][m_currentBuffer][i].x;
unsigned int curMaxIndex = m_objectMinMaxIndexCPU[axis][m_currentBuffer][i].y;
unsigned int prevMinIndex = m_objectMinMaxIndexCPU[axis][1-m_currentBuffer][i].x;
int dmin = curMinIndex - prevMinIndex;
unsigned int prevMaxIndex = m_objectMinMaxIndexCPU[axis][1-m_currentBuffer][i].y;
int dmax = curMaxIndex - prevMaxIndex;
if (dmin!=0)
{
//printf("for object %d, dmin=%d\n",i,dmin);
}
if (dmax!=0)
{
//printf("for object %d, dmax=%d\n",i,dmax);
}
for (int otherbuffer = 0;otherbuffer<2;otherbuffer++)
{
if (dmin!=0)
{
int stepMin = dmin<0 ? -1 : 1;
for (int j=prevMinIndex;j!=curMinIndex;j+=stepMin)
{
int otherIndex2 = m_sortedAxisCPU[axis][otherbuffer][j].y;
int otherIndex = otherIndex2/2;
if (otherIndex!=i)
{
bool otherIsMax = ((otherIndex2&1)!=0);
if (otherIsMax)
{
//bool overlap = TestAabbAgainstAabb2((const b3Vector3&)m_allAabbsCPU[i].m_min, (const b3Vector3&)m_allAabbsCPU[i].m_max,(const b3Vector3&)m_allAabbsCPU[otherIndex].m_min,(const b3Vector3&)m_allAabbsCPU[otherIndex].m_max);
//bool prevOverlap = TestAabbAgainstAabb2((const b3Vector3&)preAabbs[i].m_min, (const b3Vector3&)preAabbs[i].m_max,(const b3Vector3&)preAabbs[otherIndex].m_min,(const b3Vector3&)preAabbs[otherIndex].m_max);
bool overlap = true;
for (int ax=0;ax<3;ax++)
{
if ((m_objectMinMaxIndexCPU[ax][m_currentBuffer][i].x > m_objectMinMaxIndexCPU[ax][m_currentBuffer][otherIndex].y) ||
(m_objectMinMaxIndexCPU[ax][m_currentBuffer][i].y < m_objectMinMaxIndexCPU[ax][m_currentBuffer][otherIndex].x))
overlap=false;
}
// b3Assert(overlap2==overlap);
bool prevOverlap = true;
for (int ax=0;ax<3;ax++)
{
if ((m_objectMinMaxIndexCPU[ax][1-m_currentBuffer][i].x > m_objectMinMaxIndexCPU[ax][1-m_currentBuffer][otherIndex].y) ||
(m_objectMinMaxIndexCPU[ax][1-m_currentBuffer][i].y < m_objectMinMaxIndexCPU[ax][1-m_currentBuffer][otherIndex].x))
prevOverlap=false;
}
//b3Assert(overlap==overlap2);
if (dmin<0)
{
if (overlap && !prevOverlap)
{
//add a pair
b3Int4 newPair;
if (i<=otherIndex)
{
newPair.x = i;
newPair.y = otherIndex;
} else
{
newPair.x = otherIndex;
newPair.y = i;
}
addedHostPairs.push_back(newPair);
}
}
else
{
if (!overlap && prevOverlap)
{
//remove a pair
b3Int4 removedPair;
if (i<=otherIndex)
{
removedPair.x = i;
removedPair.y = otherIndex;
} else
{
removedPair.x = otherIndex;
removedPair.y = i;
}
removedHostPairs.push_back(removedPair);
}
}//otherisMax
}//if (dmin<0)
}//if (otherIndex!=i)
}//for (int j=
}
if (dmax!=0)
{
int stepMax = dmax<0 ? -1 : 1;
for (int j=prevMaxIndex;j!=curMaxIndex;j+=stepMax)
{
int otherIndex2 = m_sortedAxisCPU[axis][otherbuffer][j].y;
int otherIndex = otherIndex2/2;
if (otherIndex!=i)
{
//bool otherIsMin = ((otherIndex2&1)==0);
//if (otherIsMin)
{
//bool overlap = TestAabbAgainstAabb2((const b3Vector3&)m_allAabbsCPU[i].m_min, (const b3Vector3&)m_allAabbsCPU[i].m_max,(const b3Vector3&)m_allAabbsCPU[otherIndex].m_min,(const b3Vector3&)m_allAabbsCPU[otherIndex].m_max);
//bool prevOverlap = TestAabbAgainstAabb2((const b3Vector3&)preAabbs[i].m_min, (const b3Vector3&)preAabbs[i].m_max,(const b3Vector3&)preAabbs[otherIndex].m_min,(const b3Vector3&)preAabbs[otherIndex].m_max);
bool overlap = true;
for (int ax=0;ax<3;ax++)
{
if ((m_objectMinMaxIndexCPU[ax][m_currentBuffer][i].x > m_objectMinMaxIndexCPU[ax][m_currentBuffer][otherIndex].y) ||
(m_objectMinMaxIndexCPU[ax][m_currentBuffer][i].y < m_objectMinMaxIndexCPU[ax][m_currentBuffer][otherIndex].x))
overlap=false;
}
//b3Assert(overlap2==overlap);
bool prevOverlap = true;
for (int ax=0;ax<3;ax++)
{
if ((m_objectMinMaxIndexCPU[ax][1-m_currentBuffer][i].x > m_objectMinMaxIndexCPU[ax][1-m_currentBuffer][otherIndex].y) ||
(m_objectMinMaxIndexCPU[ax][1-m_currentBuffer][i].y < m_objectMinMaxIndexCPU[ax][1-m_currentBuffer][otherIndex].x))
prevOverlap=false;
}
if (dmax>0)
{
if (overlap && !prevOverlap)
{
//add a pair
b3Int4 newPair;
if (i<=otherIndex)
{
newPair.x = i;
newPair.y = otherIndex;
} else
{
newPair.x = otherIndex;
newPair.y = i;
}
addedHostPairs.push_back(newPair);
}
}
else
{
if (!overlap && prevOverlap)
{
//if (otherIndex2&1==0) -> min?
//remove a pair
b3Int4 removedPair;
if (i<=otherIndex)
{
removedPair.x = i;
removedPair.y = otherIndex;
} else
{
removedPair.x = otherIndex;
removedPair.y = i;
}
removedHostPairs.push_back(removedPair);
}
}
}//if (dmin<0)
}//if (otherIndex!=i)
}//for (int j=
}
}//for (int otherbuffer
}//for (int axis=0;
}//for (int i=0;i<numObjects
}
//remove duplicates and add/remove then to existing m_overlappingPairs
{
{
B3_PROFILE("sort allPairs");
allPairs.quickSort(b3PairCmp);
}
{
B3_PROFILE("sort addedHostPairs");
addedHostPairs.quickSort(b3PairCmp);
}
{
B3_PROFILE("sort removedHostPairs");
removedHostPairs.quickSort(b3PairCmp);
}
}
b3Int4 prevPair;
prevPair.x = -1;
prevPair.y = -1;
int uniqueRemovedPairs = 0;
b3AlignedObjectArray<int> removedPositions;
{
B3_PROFILE("actual removing");
for (int i=0;i<removedHostPairs.size();i++)
{
b3Int4 removedPair = removedHostPairs[i];
if ((removedPair.x != prevPair.x) || (removedPair.y != prevPair.y))
{
int index1 = allPairs.findBinarySearch(removedPair);
//#ifdef _DEBUG
int index2 = allPairs.findLinearSearch(removedPair);
b3Assert(index1==index2);
//b3Assert(index1!=allPairs.size());
if (index1<allPairs.size())
//#endif//_DEBUG
{
uniqueRemovedPairs++;
removedPositions.push_back(index1);
{
//printf("framepje(%d) remove pair(%d):%d,%d\n",framepje,i,removedPair.x,removedPair.y);
}
}
}
prevPair = removedPair;
}
if (uniqueRemovedPairs)
{
for (int i=0;i<removedPositions.size();i++)
{
allPairs[removedPositions[i]].x = INT_MAX ;
allPairs[removedPositions[i]].y = INT_MAX ;
}
allPairs.quickSort(b3PairCmp);
allPairs.resize(allPairs.size()-uniqueRemovedPairs);
}
}
//if (uniqueRemovedPairs)
// printf("uniqueRemovedPairs=%d\n",uniqueRemovedPairs);
//printf("removedHostPairs.size = %d\n",removedHostPairs.size());
prevPair.x = -1;
prevPair.y = -1;
int uniqueAddedPairs=0;
b3AlignedObjectArray<b3Int4> actualAddedPairs;
{
B3_PROFILE("actual adding");
for (int i=0;i<addedHostPairs.size();i++)
{
b3Int4 newPair = addedHostPairs[i];
if ((newPair.x != prevPair.x) || (newPair.y != prevPair.y))
{
//#ifdef _DEBUG
int index1 = allPairs.findBinarySearch(newPair);
int index2 = allPairs.findLinearSearch(newPair);
b3Assert(index1==index2);
b3Assert(index1==allPairs.size());
if (index1!=allPairs.size())
{
printf("??\n");
}
if (index1==allPairs.size())
//#endif //_DEBUG
{
uniqueAddedPairs++;
actualAddedPairs.push_back(newPair);
}
}
prevPair = newPair;
}
for (int i=0;i<actualAddedPairs.size();i++)
{
//printf("framepje (%d), new pair(%d):%d,%d\n",framepje,i,actualAddedPairs[i].x,actualAddedPairs[i].y);
allPairs.push_back(actualAddedPairs[i]);
}
}
//if (uniqueAddedPairs)
// printf("uniqueAddedPairs=%d\n", uniqueAddedPairs);
{
B3_PROFILE("m_overlappingPairs.copyFromHost");
m_overlappingPairs.copyFromHost(allPairs);
}
}
void b3GpuSapBroadphase::calculateOverlappingPairsHost(int maxPairs)
{
//test
// if (m_currentBuffer>=0)
// return calculateOverlappingPairsHostIncremental3Sap();
b3Assert(m_allAabbsCPU.size() == m_allAabbsGPU.size());
m_allAabbsGPU.copyToHost(m_allAabbsCPU);
int axis=0;
{
B3_PROFILE("CPU compute best variance axis");
b3Vector3 s=b3MakeVector3(0,0,0),s2=b3MakeVector3(0,0,0);
int numRigidBodies = m_smallAabbsMappingCPU.size();
for(int i=0;i<numRigidBodies;i++)
{
b3SapAabb aabb = this->m_allAabbsCPU[m_smallAabbsMappingCPU[i]];
b3Vector3 maxAabb=b3MakeVector3(aabb.m_max[0],aabb.m_max[1],aabb.m_max[2]);
b3Vector3 minAabb=b3MakeVector3(aabb.m_min[0],aabb.m_min[1],aabb.m_min[2]);
b3Vector3 centerAabb=(maxAabb+minAabb)*0.5f;
s += centerAabb;
s2 += centerAabb*centerAabb;
}
b3Vector3 v = s2 - (s*s) / (float)numRigidBodies;
if(v[1] > v[0])
axis = 1;
if(v[2] > v[axis])
axis = 2;
}
b3AlignedObjectArray<b3Int4> hostPairs;
{
int numSmallAabbs = m_smallAabbsMappingCPU.size();
for (int i=0;i<numSmallAabbs;i++)
{
b3SapAabb smallAabbi = m_allAabbsCPU[m_smallAabbsMappingCPU[i]];
//float reference = smallAabbi.m_max[axis];
for (int j=i+1;j<numSmallAabbs;j++)
{
b3SapAabb smallAabbj = m_allAabbsCPU[m_smallAabbsMappingCPU[j]];
if (TestAabbAgainstAabb2((b3Vector3&)smallAabbi.m_min, (b3Vector3&)smallAabbi.m_max,
(b3Vector3&)smallAabbj.m_min,(b3Vector3&)smallAabbj.m_max))
{
b3Int4 pair;
int a = smallAabbi.m_minIndices[3];
int b = smallAabbj.m_minIndices[3];
if (a<=b)
{
pair.x = a;//store the original index in the unsorted aabb array
pair.y = b;
} else
{
pair.x = b;//store the original index in the unsorted aabb array
pair.y = a;
}
hostPairs.push_back(pair);
}
}
}
}
{
int numSmallAabbs = m_smallAabbsMappingCPU.size();
for (int i=0;i<numSmallAabbs;i++)
{
b3SapAabb smallAabbi = m_allAabbsCPU[m_smallAabbsMappingCPU[i]];
//float reference = smallAabbi.m_max[axis];
int numLargeAabbs = m_largeAabbsMappingCPU.size();
for (int j=0;j<numLargeAabbs;j++)
{
b3SapAabb largeAabbj = m_allAabbsCPU[m_largeAabbsMappingCPU[j]];
if (TestAabbAgainstAabb2((b3Vector3&)smallAabbi.m_min, (b3Vector3&)smallAabbi.m_max,
(b3Vector3&)largeAabbj.m_min,(b3Vector3&)largeAabbj.m_max))
{
b3Int4 pair;
int a = largeAabbj.m_minIndices[3];
int b = smallAabbi.m_minIndices[3];
if (a<=b)
{
pair.x = a;
pair.y = b;//store the original index in the unsorted aabb array
} else
{
pair.x = b;
pair.y = a;//store the original index in the unsorted aabb array
}
hostPairs.push_back(pair);
}
}
}
}
if (hostPairs.size() > maxPairs)
{
hostPairs.resize(maxPairs);
}
if (hostPairs.size())
{
m_overlappingPairs.copyFromHost(hostPairs);
} else
{
m_overlappingPairs.resize(0);
}
//init3dSap();
}
void b3GpuSapBroadphase::reset()
{
m_allAabbsGPU.resize(0);
m_allAabbsCPU.resize(0);
m_smallAabbsMappingGPU.resize(0);
m_smallAabbsMappingCPU.resize(0);
m_pairCount.resize(0);
m_largeAabbsMappingGPU.resize(0);
m_largeAabbsMappingCPU.resize(0);
}
void b3GpuSapBroadphase::calculateOverlappingPairs(int maxPairs)
{
if (m_sapKernel==0)
{
calculateOverlappingPairsHost(maxPairs);
return;
}
//if (m_currentBuffer>=0)
// return calculateOverlappingPairsHostIncremental3Sap();
//calculateOverlappingPairsHost(maxPairs);
B3_PROFILE("GPU 1-axis SAP calculateOverlappingPairs");
int axis = 0;
{
//bool syncOnHost = false;
int numSmallAabbs = m_smallAabbsMappingCPU.size();
if (m_prefixScanFloat4 && numSmallAabbs)
{
B3_PROFILE("GPU compute best variance axis");
if (m_dst.size()!=(numSmallAabbs+1))
{
m_dst.resize(numSmallAabbs+128);
m_sum.resize(numSmallAabbs+128);
m_sum2.resize(numSmallAabbs+128);
m_sum.at(numSmallAabbs)=b3MakeVector3(0,0,0); //slow?
m_sum2.at(numSmallAabbs)=b3MakeVector3(0,0,0); //slow?
}
b3LauncherCL launcher(m_queue, m_prepareSumVarianceKernel ,"m_prepareSumVarianceKernel");
launcher.setBuffer(m_allAabbsGPU.getBufferCL());
launcher.setBuffer(m_smallAabbsMappingGPU.getBufferCL());
launcher.setBuffer(m_sum.getBufferCL());
launcher.setBuffer(m_sum2.getBufferCL());
launcher.setConst( numSmallAabbs );
int num = numSmallAabbs;
launcher.launch1D( num);
b3Vector3 s;
b3Vector3 s2;
m_prefixScanFloat4->execute(m_sum,m_dst,numSmallAabbs+1,&s);
m_prefixScanFloat4->execute(m_sum2,m_dst,numSmallAabbs+1,&s2);
b3Vector3 v = s2 - (s*s) / (float)numSmallAabbs;
if(v[1] > v[0])
axis = 1;
if(v[2] > v[axis])
axis = 2;
}
m_gpuSmallSortData.resize(numSmallAabbs);
#if 1
if (m_smallAabbsMappingGPU.size())
{
B3_PROFILE("flipFloatKernel");
b3BufferInfoCL bInfo[] = {
b3BufferInfoCL( m_allAabbsGPU.getBufferCL(), true ),
b3BufferInfoCL( m_smallAabbsMappingGPU.getBufferCL(), true),
b3BufferInfoCL( m_gpuSmallSortData.getBufferCL())};
b3LauncherCL launcher(m_queue, m_flipFloatKernel ,"m_flipFloatKernel");
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(b3BufferInfoCL) );
launcher.setConst( numSmallAabbs );
launcher.setConst( axis );
int num = numSmallAabbs;
launcher.launch1D( num);
clFinish(m_queue);
}
if (m_gpuSmallSortData.size())
{
B3_PROFILE("gpu radix sort");
m_sorter->execute(m_gpuSmallSortData);
clFinish(m_queue);
}
m_gpuSmallSortedAabbs.resize(numSmallAabbs);
if (numSmallAabbs)
{
B3_PROFILE("scatterKernel");
b3BufferInfoCL bInfo[] = {
b3BufferInfoCL( m_allAabbsGPU.getBufferCL(), true ),
b3BufferInfoCL( m_smallAabbsMappingGPU.getBufferCL(), true),
b3BufferInfoCL( m_gpuSmallSortData.getBufferCL(),true),
b3BufferInfoCL(m_gpuSmallSortedAabbs.getBufferCL())};
b3LauncherCL launcher(m_queue, m_scatterKernel ,"m_scatterKernel ");
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(b3BufferInfoCL) );
launcher.setConst( numSmallAabbs);
int num = numSmallAabbs;
launcher.launch1D( num);
clFinish(m_queue);
}
m_overlappingPairs.resize(maxPairs);
m_pairCount.resize(0);
m_pairCount.push_back(0);
int numPairs=0;
{
int numLargeAabbs = m_largeAabbsMappingGPU.size();
if (numLargeAabbs && numSmallAabbs)
{
//@todo
B3_PROFILE("sap2Kernel");
b3BufferInfoCL bInfo[] = {
b3BufferInfoCL( m_allAabbsGPU.getBufferCL() ),
b3BufferInfoCL( m_largeAabbsMappingGPU.getBufferCL() ),
b3BufferInfoCL( m_smallAabbsMappingGPU.getBufferCL() ),
b3BufferInfoCL( m_overlappingPairs.getBufferCL() ),
b3BufferInfoCL(m_pairCount.getBufferCL())};
b3LauncherCL launcher(m_queue, m_sap2Kernel,"m_sap2Kernel");
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(b3BufferInfoCL) );
launcher.setConst( numLargeAabbs );
launcher.setConst( numSmallAabbs);
launcher.setConst( axis );
launcher.setConst( maxPairs );
//@todo: use actual maximum work item sizes of the device instead of hardcoded values
launcher.launch2D( numLargeAabbs, numSmallAabbs,4,64);
numPairs = m_pairCount.at(0);
if (numPairs >maxPairs)
{
b3Error("Error running out of pairs: numPairs = %d, maxPairs = %d.\n", numPairs, maxPairs);
numPairs =maxPairs;
}
}
}
if (m_gpuSmallSortedAabbs.size())
{
B3_PROFILE("sapKernel");
b3BufferInfoCL bInfo[] = { b3BufferInfoCL( m_gpuSmallSortedAabbs.getBufferCL() ), b3BufferInfoCL( m_overlappingPairs.getBufferCL() ), b3BufferInfoCL(m_pairCount.getBufferCL())};
b3LauncherCL launcher(m_queue, m_sapKernel,"m_sapKernel");
launcher.setBuffers( bInfo, sizeof(bInfo)/sizeof(b3BufferInfoCL) );
launcher.setConst( numSmallAabbs );
launcher.setConst( axis );
launcher.setConst( maxPairs );
int num = numSmallAabbs;
#if 0
int buffSize = launcher.getSerializationBufferSize();
unsigned char* buf = new unsigned char[buffSize+sizeof(int)];
for (int i=0;i<buffSize+1;i++)
{
unsigned char* ptr = (unsigned char*)&buf[i];
*ptr = 0xff;
}
int actualWrite = launcher.serializeArguments(buf,buffSize);
unsigned char* cptr = (unsigned char*)&buf[buffSize];
// printf("buf[buffSize] = %d\n",*cptr);
assert(buf[buffSize]==0xff);//check for buffer overrun
int* ptr = (int*)&buf[buffSize];
*ptr = num;
FILE* f = fopen("m_sapKernelArgs.bin","wb");
fwrite(buf,buffSize+sizeof(int),1,f);
fclose(f);
#endif//
launcher.launch1D( num);
clFinish(m_queue);
numPairs = m_pairCount.at(0);
if (numPairs>maxPairs)
{
b3Error("Error running out of pairs: numPairs = %d, maxPairs = %d.\n", numPairs, maxPairs);
numPairs = maxPairs;
m_pairCount.resize(0);
m_pairCount.push_back(maxPairs);
}
}
#else
int numPairs = 0;
b3LauncherCL launcher(m_queue, m_sapKernel);
const char* fileName = "m_sapKernelArgs.bin";
FILE* f = fopen(fileName,"rb");
if (f)
{
int sizeInBytes=0;
if (fseek(f, 0, SEEK_END) || (sizeInBytes = ftell(f)) == EOF || fseek(f, 0, SEEK_SET))
{
printf("error, cannot get file size\n");
exit(0);
}
unsigned char* buf = (unsigned char*) malloc(sizeInBytes);
fread(buf,sizeInBytes,1,f);
int serializedBytes = launcher.deserializeArgs(buf, sizeInBytes,m_context);
int num = *(int*)&buf[serializedBytes];
launcher.launch1D( num);
b3OpenCLArray<int> pairCount(m_context, m_queue);
int numElements = launcher.m_arrays[2]->size()/sizeof(int);
pairCount.setFromOpenCLBuffer(launcher.m_arrays[2]->getBufferCL(),numElements);
numPairs = pairCount.at(0);
//printf("overlapping pairs = %d\n",numPairs);
b3AlignedObjectArray<b3Int4> hostOoverlappingPairs;
b3OpenCLArray<b3Int4> tmpGpuPairs(m_context,m_queue);
tmpGpuPairs.setFromOpenCLBuffer(launcher.m_arrays[1]->getBufferCL(),numPairs );
tmpGpuPairs.copyToHost(hostOoverlappingPairs);
m_overlappingPairs.copyFromHost(hostOoverlappingPairs);
//printf("hello %d\n", m_overlappingPairs.size());
free(buf);
fclose(f);
} else {
printf("error: cannot find file %s\n",fileName);
}
clFinish(m_queue);
#endif
m_overlappingPairs.resize(numPairs);
}//B3_PROFILE("GPU_RADIX SORT");
//init3dSap();
}
void b3GpuSapBroadphase::writeAabbsToGpu()
{
m_smallAabbsMappingGPU.copyFromHost(m_smallAabbsMappingCPU);
m_largeAabbsMappingGPU.copyFromHost(m_largeAabbsMappingCPU);
m_allAabbsGPU.copyFromHost(m_allAabbsCPU);//might not be necessary, the 'setupGpuAabbsFull' already takes care of this
}
void b3GpuSapBroadphase::createLargeProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr , int collisionFilterGroup, int collisionFilterMask)
{
int index = userPtr;
b3SapAabb aabb;
for (int i=0;i<4;i++)
{
aabb.m_min[i] = aabbMin[i];
aabb.m_max[i] = aabbMax[i];
}
aabb.m_minIndices[3] = index;
aabb.m_signedMaxIndices[3] = m_allAabbsCPU.size();
m_largeAabbsMappingCPU.push_back(m_allAabbsCPU.size());
m_allAabbsCPU.push_back(aabb);
}
void b3GpuSapBroadphase::createProxy(const b3Vector3& aabbMin, const b3Vector3& aabbMax, int userPtr , int collisionFilterGroup, int collisionFilterMask)
{
int index = userPtr;
b3SapAabb aabb;
for (int i=0;i<4;i++)
{
aabb.m_min[i] = aabbMin[i];
aabb.m_max[i] = aabbMax[i];
}
aabb.m_minIndices[3] = index;
aabb.m_signedMaxIndices[3] = m_allAabbsCPU.size();
m_smallAabbsMappingCPU.push_back(m_allAabbsCPU.size());
m_allAabbsCPU.push_back(aabb);
}
cl_mem b3GpuSapBroadphase::getAabbBufferWS()
{
return m_allAabbsGPU.getBufferCL();
}
int b3GpuSapBroadphase::getNumOverlap()
{
return m_overlappingPairs.size();
}
cl_mem b3GpuSapBroadphase::getOverlappingPairBuffer()
{
return m_overlappingPairs.getBufferCL();
}
b3OpenCLArray<b3Int4>& b3GpuSapBroadphase::getOverlappingPairsGPU()
{
return m_overlappingPairs;
}
b3OpenCLArray<int>& b3GpuSapBroadphase::getSmallAabbIndicesGPU()
{
return m_smallAabbsMappingGPU;
}
b3OpenCLArray<int>& b3GpuSapBroadphase::getLargeAabbIndicesGPU()
{
return m_largeAabbsMappingGPU;
}