/* 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); }