/* called by the C++ code for initialization */
extern "C" void device_init (int8* cfg)
{
/* initialize ray tracing core */
rtcInit(cfg);
/* set error handler */
rtcSetErrorFunction(error_handler);
/* set start render mode */
renderPixel = renderPixelStandard;
/* create random bounding boxes */
const size_t N = 2300000;
isa::PrimInfo pinfo(empty);
vector_t<PrimRef> prims;
for (size_t i=0; i<N; i++) {
const Vec3fa p = 1000.0f*Vec3fa(drand48(),drand48(),drand48());
const BBox3fa b = BBox3fa(p,p+Vec3fa(1.0f));
pinfo.add(b);
const PrimRef prim = PrimRef(b,i);
prims.push_back(prim);
}
build_sah(prims,pinfo);
build_morton(prims,pinfo);
}
/* called by the C++ code for initialization */
extern "C" void device_init (char* cfg)
{
/* create new Embree device */
g_device = rtcNewDevice(cfg);
error_handler(rtcDeviceGetError(g_device));
/* set error handler */
rtcDeviceSetErrorFunction(g_device,error_handler);
/* set start render mode */
renderTile = renderTileStandard;
/* create random bounding boxes */
const size_t N = 2300000;
isa::PrimInfo pinfo(empty);
avector<PrimRef> prims;
for (size_t i=0; i<N; i++) {
const float x = float(drand48());
const float y = float(drand48());
const float z = float(drand48());
const Vec3fa p = 1000.0f*Vec3fa(x,y,z);
const BBox3fa b = BBox3fa(p,p+Vec3fa(1.0f));
pinfo.add(b);
const PrimRef prim = PrimRef(b,i);
prims.push_back(prim);
}
build_sah(prims,pinfo);
build_morton(prims,pinfo);
}
void BVH4BuilderTopLevel::build(size_t threadIndex, size_t threadCount)
{
/* delete some objects */
size_t N = scene->size();
for (size_t i=N; i<objects.size(); i++) {
delete builders[i]; builders[i] = NULL;
delete objects[i]; objects[i] = NULL;
}
/* resize object array if scene got larger */
if (objects.size() < N) {
objects.resize(N);
builders.resize(N);
}
refs.resize(N);
nextRef = 0;
/* sequential create of acceleration structures */
for (size_t i=0; i<N; i++)
create_object(i);
/* parallel build of acceleration structures */
if (N) scheduler->dispatchTask(threadIndex,threadCount,_task_build_parallel,this,N,"toplevel_build_parallel");
/* perform builds that need all threads */
for (size_t i=0; i<allThreadBuilds.size(); i++) {
build(threadIndex,threadCount,allThreadBuilds[i]);
}
allThreadBuilds.clear();
/* ignore empty scenes */
refs.resize(nextRef);
double t0 = 0.0;
if (g_verbose >= 2) {
std::cout << "building BVH4<" << bvh->primTy.name << "> with " << TOSTRING(isa) << "::TopLevel SAH builder ... " << std::flush;
t0 = getSeconds();
}
/* open all large nodes */
open_sequential();
prims.resize(refs.size());
for (size_t i=0; i<refs.size(); i++) {
prims[i] = PrimRef(refs[i].bounds(),(size_t)refs[i].node);
}
BVH4TopLevelBuilderFastT::build(threadIndex,threadCount,prims.begin(),prims.size());
}
void PrimRefGen<Heuristic>::task_gen_parallel(size_t threadIndex, size_t threadCount, size_t taskIndex, size_t taskCount, TaskScheduler::Event* event)
{
Heuristic& heuristic = heuristics[taskIndex];
new (&heuristic) Heuristic(pinfo,geom);
/* static work allocation */
size_t g = work[taskIndex].startGroup;
size_t i = work[taskIndex].startPrim;
size_t numPrims = work[taskIndex].numPrims;
size_t numGroupPrims = numPrims ? geom->prims(g) : 0;
size_t numAddedPrims = 0;
BBox3fa geomBound = empty, centBound = empty;
typename atomic_set<PrimRefBlock>::item* block = prims.insert(alloc->malloc(threadIndex));
for (size_t p=0; p<numPrims; p++, i++)
{
/* goto next group */
while (i == numGroupPrims) {
g++; i = 0;
numGroupPrims = geom->prims(g);
}
const BBox3fa b = geom->bounds(g,i);
if (b.empty()) continue;
numAddedPrims++;
geomBound.extend(b);
centBound.extend(center2(b));
const PrimRef prim = PrimRef(b,g,i);
if (likely(block->insert(prim))) continue;
heuristic.bin(block->base(),block->size());
block = prims.insert(alloc->malloc(threadIndex));
block->insert(prim);
}
heuristic.bin(block->base(),block->size());
geomBounds[taskIndex] = geomBound;
centBounds[taskIndex] = centBound;
work[taskIndex].numPrims = numAddedPrims;
}
void BVH4BuilderTwoLevel::build(size_t threadIndex, size_t threadCount)
{
/* delete some objects */
size_t N = scene->size();
if (N < objects.size()) {
parallel_for(N, objects.size(), [&] (const range<size_t>& r) {
for (size_t i=r.begin(); i<r.end(); i++) {
delete builders[i]; builders[i] = nullptr;
delete objects[i]; objects[i] = nullptr;
}
});
}
/* reset memory allocator */
bvh->alloc.reset();
/* skip build for empty scene */
const size_t numPrimitives = scene->getNumPrimitives<TriangleMesh,1>();
if (numPrimitives == 0) {
prims.resize(0);
bvh->set(BVH4::emptyNode,empty,0);
return;
}
double t0 = bvh->preBuild(TOSTRING(isa) "::BVH4BuilderTwoLevel");
#if PROFILE
profile(2,20,numPrimitives,[&] (ProfileTimer& timer)
{
#endif
/* resize object array if scene got larger */
if (objects.size() < N) objects.resize(N);
if (builders.size() < N) builders.resize(N);
if (refs.size() < N) refs.resize(N);
nextRef = 0;
/* create of acceleration structures */
parallel_for(size_t(0), N, [&] (const range<size_t>& r)
{
for (size_t objectID=r.begin(); objectID<r.end(); objectID++)
{
TriangleMesh* mesh = scene->getTriangleMeshSafe(objectID);
/* verify meshes got deleted properly */
if (mesh == nullptr || mesh->numTimeSteps != 1) {
assert(objectID < objects.size () && objects[objectID] == nullptr);
assert(objectID < builders.size() && builders[objectID] == nullptr);
continue;
}
/* create BVH and builder for new meshes */
if (objects[objectID] == nullptr)
createTriangleMeshAccel(mesh,(AccelData*&)objects[objectID],builders[objectID]);
}
});
/* parallel build of acceleration structures */
parallel_for(size_t(0), N, [&] (const range<size_t>& r)
{
for (size_t objectID=r.begin(); objectID<r.end(); objectID++)
{
/* ignore if no triangle mesh or not enabled */
TriangleMesh* mesh = scene->getTriangleMeshSafe(objectID);
if (mesh == nullptr || !mesh->isEnabled() || mesh->numTimeSteps != 1)
continue;
BVH4* object = objects [objectID]; assert(object);
Builder* builder = builders[objectID]; assert(builder);
/* build object if it got modified */
#if !PROFILE
if (mesh->isModified())
#endif
builder->build(0,0);
/* create build primitive */
if (!object->bounds.empty())
refs[nextRef++] = BVH4BuilderTwoLevel::BuildRef(object->bounds,object->root);
}
});
/* fast path for single geometry scenes */
if (nextRef == 1) {
bvh->set(refs[0].node,refs[0].bounds(),numPrimitives);
return;
}
/* open all large nodes */
refs.resize(nextRef);
open_sequential(numPrimitives);
/* fast path for small geometries */
if (refs.size() == 1) {
bvh->set(refs[0].node,refs[0].bounds(),numPrimitives);
return;
}
/* compute PrimRefs */
prims.resize(refs.size());
const PrimInfo pinfo = parallel_reduce(size_t(0), refs.size(), size_t(1024), PrimInfo(empty), [&] (const range<size_t>& r) -> PrimInfo
{
PrimInfo pinfo(empty);
for (size_t i=r.begin(); i<r.end(); i++) {
pinfo.add(refs[i].bounds());
prims[i] = PrimRef(refs[i].bounds(),(size_t)refs[i].node);
}
return pinfo;
}, [] (const PrimInfo& a, const PrimInfo& b) { return PrimInfo::merge(a,b); });
/* skip if all objects where empty */
if (pinfo.size() == 0)
bvh->set(BVH4::emptyNode,empty,0);
/* otherwise build toplevel hierarchy */
else
{
BVH4::NodeRef root;
BVHBuilderBinnedSAH::build<BVH4::NodeRef>
(root,
[&] { return bvh->alloc.threadLocal2(); },
[&] (const isa::BVHBuilderBinnedSAH::BuildRecord& current, BVHBuilderBinnedSAH::BuildRecord* children, const size_t N, FastAllocator::ThreadLocal2* alloc) -> int
{
BVH4::Node* node = (BVH4::Node*) alloc->alloc0.malloc(sizeof(BVH4::Node)); node->clear();
for (size_t i=0; i<N; i++) {
node->set(i,children[i].pinfo.geomBounds);
children[i].parent = (size_t*)&node->child(i);
}
*current.parent = bvh->encodeNode(node);
return 0;
},
[&] (const BVHBuilderBinnedSAH::BuildRecord& current, FastAllocator::ThreadLocal2* alloc) -> int
{
assert(current.prims.size() == 1);
*current.parent = (BVH4::NodeRef) prims[current.prims.begin()].ID();
return 1;
},
[&] (size_t dn) { bvh->scene->progressMonitor(0); },
prims.data(),pinfo,BVH4::N,BVH4::maxBuildDepthLeaf,4,1,1,1.0f,1.0f);
bvh->set(root,pinfo.geomBounds,numPrimitives);
}
#if PROFILE
});
#endif
bvh->alloc.cleanup();
bvh->postBuild(t0);
}
