1// Copyright 2009-2021 Intel Corporation
2// SPDX-License-Identifier: Apache-2.0
3
4#include "bvh.h"
5#include "bvh_builder.h"
6#include "../builders/bvh_builder_msmblur.h"
7
8#include "../builders/primrefgen.h"
9#include "../builders/splitter.h"
10
11#include "../geometry/linei.h"
12#include "../geometry/triangle.h"
13#include "../geometry/trianglev.h"
14#include "../geometry/trianglev_mb.h"
15#include "../geometry/trianglei.h"
16#include "../geometry/quadv.h"
17#include "../geometry/quadi.h"
18#include "../geometry/object.h"
19#include "../geometry/instance.h"
20#include "../geometry/subgrid.h"
21
22#include "../common/state.h"
23
24// FIXME: remove after removing BVHNBuilderMBlurRootTimeSplitsSAH
25#include "../../common/algorithms/parallel_for_for.h"
26#include "../../common/algorithms/parallel_for_for_prefix_sum.h"
27
28
29namespace embree
30{
31 namespace isa
32 {
33
34#if 0
35 template<int N, typename Primitive>
36 struct CreateMBlurLeaf
37 {
38 typedef BVHN<N> BVH;
39 typedef typename BVH::NodeRef NodeRef;
40 typedef typename BVH::NodeRecordMB NodeRecordMB;
41
42 __forceinline CreateMBlurLeaf (BVH* bvh, PrimRef* prims, size_t time) : bvh(bvh), prims(prims), time(time) {}
43
44 __forceinline NodeRecordMB operator() (const PrimRef* prims, const range<size_t>& set, const FastAllocator::CachedAllocator& alloc) const
45 {
46 size_t items = Primitive::blocks(set.size());
47 size_t start = set.begin();
48 for (size_t i=start; i<end; i++) assert((*current.prims.prims)[start].geomID() == (*current.prims.prims)[i].geomID()); // assert that all geomIDs are identical
49 Primitive* accel = (Primitive*) alloc.malloc1(items*sizeof(Primitive),BVH::byteAlignment);
50 NodeRef node = bvh->encodeLeaf((char*)accel,items);
51
52 LBBox3fa allBounds = empty;
53 for (size_t i=0; i<items; i++)
54 allBounds.extend(accel[i].fillMB(prims, start, set.end(), bvh->scene, time));
55
56 return NodeRecordMB(node,allBounds);
57 }
58
59 BVH* bvh;
60 PrimRef* prims;
61 size_t time;
62 };
63#endif
64
65 template<int N, typename Mesh, typename Primitive>
66 struct CreateMSMBlurLeaf
67 {
68 typedef BVHN<N> BVH;
69 typedef typename BVH::NodeRef NodeRef;
70 typedef typename BVH::NodeRecordMB4D NodeRecordMB4D;
71
72 __forceinline CreateMSMBlurLeaf (BVH* bvh) : bvh(bvh) {}
73
74 __forceinline const NodeRecordMB4D operator() (const BVHBuilderMSMBlur::BuildRecord& current, const FastAllocator::CachedAllocator& alloc) const
75 {
76 size_t items = Primitive::blocks(current.prims.size());
77 size_t start = current.prims.begin();
78 size_t end = current.prims.end();
79 for (size_t i=start; i<end; i++) assert((*current.prims.prims)[start].geomID() == (*current.prims.prims)[i].geomID()); // assert that all geomIDs are identical
80 Primitive* accel = (Primitive*) alloc.malloc1(items*sizeof(Primitive),BVH::byteNodeAlignment);
81 NodeRef node = bvh->encodeLeaf((char*)accel,items);
82 LBBox3fa allBounds = empty;
83 for (size_t i=0; i<items; i++)
84 allBounds.extend(accel[i].fillMB(current.prims.prims->data(), start, current.prims.end(), bvh->scene, current.prims.time_range));
85 return NodeRecordMB4D(node,allBounds,current.prims.time_range);
86 }
87
88 BVH* bvh;
89 };
90
91 /* Motion blur BVH with 4D nodes and internal time splits */
92 template<int N, typename Mesh, typename Primitive>
93 struct BVHNBuilderMBlurSAH : public Builder
94 {
95 typedef BVHN<N> BVH;
96 typedef typename BVHN<N>::NodeRef NodeRef;
97 typedef typename BVHN<N>::NodeRecordMB NodeRecordMB;
98 typedef typename BVHN<N>::AABBNodeMB AABBNodeMB;
99
100 BVH* bvh;
101 Scene* scene;
102 const size_t sahBlockSize;
103 const float intCost;
104 const size_t minLeafSize;
105 const size_t maxLeafSize;
106 const Geometry::GTypeMask gtype_;
107
108 BVHNBuilderMBlurSAH (BVH* bvh, Scene* scene, const size_t sahBlockSize, const float intCost, const size_t minLeafSize, const size_t maxLeafSize, const Geometry::GTypeMask gtype)
109 : bvh(bvh), scene(scene), sahBlockSize(sahBlockSize), intCost(intCost), minLeafSize(minLeafSize), maxLeafSize(min(maxLeafSize,Primitive::max_size()*BVH::maxLeafBlocks)), gtype_(gtype) {}
110
111 void build()
112 {
113 /* skip build for empty scene */
114 const size_t numPrimitives = scene->getNumPrimitives(gtype_,true);
115 if (numPrimitives == 0) { bvh->clear(); return; }
116
117 double t0 = bvh->preBuild(TOSTRING(isa) "::BVH" + toString(N) + "BuilderMBlurSAH");
118
119#if PROFILE
120 profile(2,PROFILE_RUNS,numPrimitives,[&] (ProfileTimer& timer) {
121#endif
122
123 //const size_t numTimeSteps = scene->getNumTimeSteps<typename Mesh::type_t,true>();
124 //const size_t numTimeSegments = numTimeSteps-1; assert(numTimeSteps > 1);
125
126 /*if (numTimeSegments == 1)
127 buildSingleSegment(numPrimitives);
128 else*/
129 buildMultiSegment(numPrimitives);
130
131#if PROFILE
132 });
133#endif
134
135 /* clear temporary data for static geometry */
136 bvh->cleanup();
137 bvh->postBuild(t0);
138 }
139
140#if 0 // No longer compatible when time_ranges are present for geometries. Would have to create temporal nodes sometimes, and put only a single geometry into leaf.
141 void buildSingleSegment(size_t numPrimitives)
142 {
143 /* create primref array */
144 mvector<PrimRef> prims(scene->device,numPrimitives);
145 const PrimInfo pinfo = createPrimRefArrayMBlur(scene,gtype_,numPrimitives,prims,bvh->scene->progressInterface,0);
146 /* early out if no valid primitives */
147 if (pinfo.size() == 0) { bvh->clear(); return; }
148 /* estimate acceleration structure size */
149 const size_t node_bytes = pinfo.size()*sizeof(AABBNodeMB)/(4*N);
150 const size_t leaf_bytes = size_t(1.2*Primitive::blocks(pinfo.size())*sizeof(Primitive));
151 bvh->alloc.init_estimate(node_bytes+leaf_bytes);
152
153 /* settings for BVH build */
154 GeneralBVHBuilder::Settings settings;
155 settings.branchingFactor = N;
156 settings.maxDepth = BVH::maxBuildDepthLeaf;
157 settings.logBlockSize = bsr(sahBlockSize);
158 settings.minLeafSize = min(minLeafSize,maxLeafSize);
159 settings.maxLeafSize = maxLeafSize;
160 settings.travCost = travCost;
161 settings.intCost = intCost;
162 settings.singleThreadThreshold = bvh->alloc.fixSingleThreadThreshold(N,DEFAULT_SINGLE_THREAD_THRESHOLD,pinfo.size(),node_bytes+leaf_bytes);
163
164 /* build hierarchy */
165 auto root = BVHBuilderBinnedSAH::build<NodeRecordMB>
166 (typename BVH::CreateAlloc(bvh),typename BVH::AABBNodeMB::Create(),typename BVH::AABBNodeMB::Set(),
167 CreateMBlurLeaf<N,Primitive>(bvh,prims.data(),0),bvh->scene->progressInterface,
168 prims.data(),pinfo,settings);
169
170 bvh->set(root.ref,root.lbounds,pinfo.size());
171 }
172#endif
173
174 void buildMultiSegment(size_t numPrimitives)
175 {
176 /* create primref array */
177 mvector<PrimRefMB> prims(scene->device,numPrimitives);
178 PrimInfoMB pinfo = createPrimRefArrayMSMBlur(scene,gtype_,numPrimitives,prims,bvh->scene->progressInterface);
179
180 /* early out if no valid primitives */
181 if (pinfo.size() == 0) { bvh->clear(); return; }
182
183 /* estimate acceleration structure size */
184 const size_t node_bytes = pinfo.num_time_segments*sizeof(AABBNodeMB)/(4*N);
185 const size_t leaf_bytes = size_t(1.2*Primitive::blocks(pinfo.num_time_segments)*sizeof(Primitive));
186 bvh->alloc.init_estimate(node_bytes+leaf_bytes);
187
188 /* settings for BVH build */
189 BVHBuilderMSMBlur::Settings settings;
190 settings.branchingFactor = N;
191 settings.maxDepth = BVH::maxDepth;
192 settings.logBlockSize = bsr(sahBlockSize);
193 settings.minLeafSize = min(minLeafSize,maxLeafSize);
194 settings.maxLeafSize = maxLeafSize;
195 settings.travCost = travCost;
196 settings.intCost = intCost;
197 settings.singleLeafTimeSegment = Primitive::singleTimeSegment;
198 settings.singleThreadThreshold = bvh->alloc.fixSingleThreadThreshold(N,DEFAULT_SINGLE_THREAD_THRESHOLD,pinfo.size(),node_bytes+leaf_bytes);
199
200 /* build hierarchy */
201 auto root =
202 BVHBuilderMSMBlur::build<NodeRef>(prims,pinfo,scene->device,
203 RecalculatePrimRef<Mesh>(scene),
204 typename BVH::CreateAlloc(bvh),
205 typename BVH::AABBNodeMB4D::Create(),
206 typename BVH::AABBNodeMB4D::Set(),
207 CreateMSMBlurLeaf<N,Mesh,Primitive>(bvh),
208 bvh->scene->progressInterface,
209 settings);
210
211 bvh->set(root.ref,root.lbounds,pinfo.num_time_segments);
212 }
213
214 void clear() {
215 }
216 };
217
218 /************************************************************************************/
219 /************************************************************************************/
220 /************************************************************************************/
221 /************************************************************************************/
222
223 struct GridRecalculatePrimRef
224 {
225 Scene* scene;
226 const SubGridBuildData * const sgrids;
227
228 __forceinline GridRecalculatePrimRef (Scene* scene, const SubGridBuildData * const sgrids)
229 : scene(scene), sgrids(sgrids) {}
230
231 __forceinline PrimRefMB operator() (const PrimRefMB& prim, const BBox1f time_range) const
232 {
233 const unsigned int geomID = prim.geomID();
234 const GridMesh* mesh = scene->get<GridMesh>(geomID);
235 const unsigned int buildID = prim.primID();
236 const SubGridBuildData &subgrid = sgrids[buildID];
237 const unsigned int primID = subgrid.primID;
238 const size_t x = subgrid.x();
239 const size_t y = subgrid.y();
240 const LBBox3fa lbounds = mesh->linearBounds(mesh->grid(primID),x,y,time_range);
241 const unsigned num_time_segments = mesh->numTimeSegments();
242 const range<int> tbounds = mesh->timeSegmentRange(time_range);
243 return PrimRefMB (lbounds, tbounds.size(), mesh->time_range, num_time_segments, geomID, buildID);
244 }
245
246 __forceinline LBBox3fa linearBounds(const PrimRefMB& prim, const BBox1f time_range) const {
247 const unsigned int geomID = prim.geomID();
248 const GridMesh* mesh = scene->get<GridMesh>(geomID);
249 const unsigned int buildID = prim.primID();
250 const SubGridBuildData &subgrid = sgrids[buildID];
251 const unsigned int primID = subgrid.primID;
252 const size_t x = subgrid.x();
253 const size_t y = subgrid.y();
254 return mesh->linearBounds(mesh->grid(primID),x,y,time_range);
255 }
256
257 };
258
259 template<int N>
260 struct CreateMSMBlurLeafGrid
261 {
262 typedef BVHN<N> BVH;
263 typedef typename BVH::NodeRef NodeRef;
264 typedef typename BVH::NodeRecordMB4D NodeRecordMB4D;
265
266 __forceinline CreateMSMBlurLeafGrid (Scene* scene, BVH* bvh, const SubGridBuildData * const sgrids) : scene(scene), bvh(bvh), sgrids(sgrids) {}
267
268 __forceinline const NodeRecordMB4D operator() (const BVHBuilderMSMBlur::BuildRecord& current, const FastAllocator::CachedAllocator& alloc) const
269 {
270 const size_t items = current.prims.size();
271 const size_t start = current.prims.begin();
272
273 const PrimRefMB* prims = current.prims.prims->data();
274 /* collect all subsets with unique geomIDs */
275 assert(items <= N);
276 unsigned int geomIDs[N];
277 unsigned int num_geomIDs = 1;
278 geomIDs[0] = prims[start].geomID();
279
280 for (size_t i=1;i<items;i++)
281 {
282 bool found = false;
283 const unsigned int new_geomID = prims[start+i].geomID();
284 for (size_t j=0;j<num_geomIDs;j++)
285 if (new_geomID == geomIDs[j])
286 { found = true; break; }
287 if (!found)
288 geomIDs[num_geomIDs++] = new_geomID;
289 }
290
291 /* allocate all leaf memory in one single block */
292 SubGridMBQBVHN<N>* accel = (SubGridMBQBVHN<N>*) alloc.malloc1(num_geomIDs*sizeof(SubGridMBQBVHN<N>),BVH::byteAlignment);
293 typename BVH::NodeRef node = bvh->encodeLeaf((char*)accel,num_geomIDs);
294
295 LBBox3fa allBounds = empty;
296
297 for (size_t g=0;g<num_geomIDs;g++)
298 {
299 const GridMesh* __restrict__ const mesh = scene->get<GridMesh>(geomIDs[g]);
300 unsigned int x[N];
301 unsigned int y[N];
302 unsigned int primID[N];
303 BBox3fa bounds0[N];
304 BBox3fa bounds1[N];
305 unsigned int pos = 0;
306 for (size_t i=0;i<items;i++)
307 {
308 if (unlikely(prims[start+i].geomID() != geomIDs[g])) continue;
309
310 const SubGridBuildData &sgrid_bd = sgrids[prims[start+i].primID()];
311 x[pos] = sgrid_bd.sx;
312 y[pos] = sgrid_bd.sy;
313 primID[pos] = sgrid_bd.primID;
314 const size_t x = sgrid_bd.x();
315 const size_t y = sgrid_bd.y();
316 LBBox3fa newBounds = mesh->linearBounds(mesh->grid(sgrid_bd.primID),x,y,current.prims.time_range);
317 allBounds.extend(newBounds);
318 bounds0[pos] = newBounds.bounds0;
319 bounds1[pos] = newBounds.bounds1;
320 pos++;
321 }
322 assert(pos <= N);
323 new (&accel[g]) SubGridMBQBVHN<N>(x,y,primID,bounds0,bounds1,geomIDs[g],current.prims.time_range.lower,1.0f/current.prims.time_range.size(),pos);
324 }
325 return NodeRecordMB4D(node,allBounds,current.prims.time_range);
326 }
327
328 Scene *scene;
329 BVH* bvh;
330 const SubGridBuildData * const sgrids;
331 };
332
333#if 0
334 template<int N>
335 struct CreateLeafGridMB
336 {
337 typedef BVHN<N> BVH;
338 typedef typename BVH::NodeRef NodeRef;
339 typedef typename BVH::NodeRecordMB NodeRecordMB;
340
341 __forceinline CreateLeafGridMB (Scene* scene, BVH* bvh, const SubGridBuildData * const sgrids)
342 : scene(scene), bvh(bvh), sgrids(sgrids) {}
343
344 __forceinline NodeRecordMB operator() (const PrimRef* prims, const range<size_t>& set, const FastAllocator::CachedAllocator& alloc) const
345 {
346 const size_t items = set.size();
347 const size_t start = set.begin();
348
349 /* collect all subsets with unique geomIDs */
350 assert(items <= N);
351 unsigned int geomIDs[N];
352 unsigned int num_geomIDs = 1;
353 geomIDs[0] = prims[start].geomID();
354
355 for (size_t i=1;i<items;i++)
356 {
357 bool found = false;
358 const unsigned int new_geomID = prims[start+i].geomID();
359 for (size_t j=0;j<num_geomIDs;j++)
360 if (new_geomID == geomIDs[j])
361 { found = true; break; }
362 if (!found)
363 geomIDs[num_geomIDs++] = new_geomID;
364 }
365
366 /* allocate all leaf memory in one single block */
367 SubGridMBQBVHN<N>* accel = (SubGridMBQBVHN<N>*) alloc.malloc1(num_geomIDs*sizeof(SubGridMBQBVHN<N>),BVH::byteAlignment);
368 typename BVH::NodeRef node = bvh->encodeLeaf((char*)accel,num_geomIDs);
369
370 LBBox3fa allBounds = empty;
371
372 for (size_t g=0;g<num_geomIDs;g++)
373 {
374 const GridMesh* __restrict__ const mesh = scene->get<GridMesh>(geomIDs[g]);
375
376 unsigned int x[N];
377 unsigned int y[N];
378 unsigned int primID[N];
379 BBox3fa bounds0[N];
380 BBox3fa bounds1[N];
381 unsigned int pos = 0;
382 for (size_t i=0;i<items;i++)
383 {
384 if (unlikely(prims[start+i].geomID() != geomIDs[g])) continue;
385
386 const SubGridBuildData &sgrid_bd = sgrids[prims[start+i].primID()];
387 x[pos] = sgrid_bd.sx;
388 y[pos] = sgrid_bd.sy;
389 primID[pos] = sgrid_bd.primID;
390 const size_t x = sgrid_bd.x();
391 const size_t y = sgrid_bd.y();
392 bool MAYBE_UNUSED valid0 = mesh->buildBounds(mesh->grid(sgrid_bd.primID),x,y,0,bounds0[pos]);
393 bool MAYBE_UNUSED valid1 = mesh->buildBounds(mesh->grid(sgrid_bd.primID),x,y,1,bounds1[pos]);
394 assert(valid0);
395 assert(valid1);
396 allBounds.extend(LBBox3fa(bounds0[pos],bounds1[pos]));
397 pos++;
398 }
399 new (&accel[g]) SubGridMBQBVHN<N>(x,y,primID,bounds0,bounds1,geomIDs[g],0.0f,1.0f,pos);
400 }
401 return NodeRecordMB(node,allBounds);
402 }
403
404 Scene *scene;
405 BVH* bvh;
406 const SubGridBuildData * const sgrids;
407 };
408#endif
409
410
411 /* Motion blur BVH with 4D nodes and internal time splits */
412 template<int N>
413 struct BVHNBuilderMBlurSAHGrid : public Builder
414 {
415 typedef BVHN<N> BVH;
416 typedef typename BVHN<N>::NodeRef NodeRef;
417 typedef typename BVHN<N>::NodeRecordMB NodeRecordMB;
418 typedef typename BVHN<N>::AABBNodeMB AABBNodeMB;
419
420 BVH* bvh;
421 Scene* scene;
422 const size_t sahBlockSize;
423 const float intCost;
424 const size_t minLeafSize;
425 const size_t maxLeafSize;
426 mvector<SubGridBuildData> sgrids;
427
428
429 BVHNBuilderMBlurSAHGrid (BVH* bvh, Scene* scene, const size_t sahBlockSize, const float intCost, const size_t minLeafSize, const size_t maxLeafSize)
430 : bvh(bvh), scene(scene), sahBlockSize(sahBlockSize), intCost(intCost), minLeafSize(minLeafSize), maxLeafSize(min(maxLeafSize,BVH::maxLeafBlocks)), sgrids(scene->device,0) {}
431
432
433 PrimInfo createPrimRefArrayMBlurGrid(Scene* scene, mvector<PrimRef>& prims, BuildProgressMonitor& progressMonitor, size_t itime)
434 {
435 /* first run to get #primitives */
436 ParallelForForPrefixSumState<PrimInfo> pstate;
437 Scene::Iterator<GridMesh,true> iter(scene);
438
439 pstate.init(iter,size_t(1024));
440
441 /* iterate over all meshes in the scene */
442 PrimInfo pinfo = parallel_for_for_prefix_sum0( pstate, iter, PrimInfo(empty), [&](GridMesh* mesh, const range<size_t>& r, size_t k, size_t geomID) -> PrimInfo {
443
444 PrimInfo pinfo(empty);
445 for (size_t j=r.begin(); j<r.end(); j++)
446 {
447 if (!mesh->valid(j,range<size_t>(0,1))) continue;
448 BBox3fa bounds = empty;
449 const PrimRef prim(bounds,unsigned(geomID),unsigned(j));
450 pinfo.add_center2(prim,mesh->getNumSubGrids(j));
451 }
452 return pinfo;
453 }, [](const PrimInfo& a, const PrimInfo& b) -> PrimInfo { return PrimInfo::merge(a,b); });
454
455 size_t numPrimitives = pinfo.size();
456 if (numPrimitives == 0) return pinfo;
457
458 /* resize arrays */
459 sgrids.resize(numPrimitives);
460 prims.resize(numPrimitives);
461
462 /* second run to fill primrefs and SubGridBuildData arrays */
463 pinfo = parallel_for_for_prefix_sum1( pstate, iter, PrimInfo(empty), [&](GridMesh* mesh, const range<size_t>& r, size_t k, size_t geomID, const PrimInfo& base) -> PrimInfo {
464
465 k = base.size();
466 size_t p_index = k;
467 PrimInfo pinfo(empty);
468 for (size_t j=r.begin(); j<r.end(); j++)
469 {
470 const GridMesh::Grid &g = mesh->grid(j);
471 if (!mesh->valid(j,range<size_t>(0,1))) continue;
472
473 for (unsigned int y=0; y<g.resY-1u; y+=2)
474 for (unsigned int x=0; x<g.resX-1u; x+=2)
475 {
476 BBox3fa bounds = empty;
477 if (!mesh->buildBounds(g,x,y,itime,bounds)) continue; // get bounds of subgrid
478 const PrimRef prim(bounds,unsigned(geomID),unsigned(p_index));
479 pinfo.add_center2(prim);
480 sgrids[p_index] = SubGridBuildData(x | g.get3x3FlagsX(x), y | g.get3x3FlagsY(y), unsigned(j));
481 prims[p_index++] = prim;
482 }
483 }
484 return pinfo;
485 }, [](const PrimInfo& a, const PrimInfo& b) -> PrimInfo { return PrimInfo::merge(a,b); });
486
487 assert(pinfo.size() == numPrimitives);
488 return pinfo;
489 }
490
491 PrimInfoMB createPrimRefArrayMSMBlurGrid(Scene* scene, mvector<PrimRefMB>& prims, BuildProgressMonitor& progressMonitor, BBox1f t0t1 = BBox1f(0.0f,1.0f))
492 {
493 /* first run to get #primitives */
494 ParallelForForPrefixSumState<PrimInfoMB> pstate;
495 Scene::Iterator<GridMesh,true> iter(scene);
496
497 pstate.init(iter,size_t(1024));
498 /* iterate over all meshes in the scene */
499 PrimInfoMB pinfoMB = parallel_for_for_prefix_sum0( pstate, iter, PrimInfoMB(empty), [&](GridMesh* mesh, const range<size_t>& r, size_t k, size_t /*geomID*/) -> PrimInfoMB {
500
501 PrimInfoMB pinfoMB(empty);
502 for (size_t j=r.begin(); j<r.end(); j++)
503 {
504 if (!mesh->valid(j, mesh->timeSegmentRange(t0t1))) continue;
505 LBBox3fa bounds(empty);
506 PrimInfoMB gridMB(0,mesh->getNumSubGrids(j));
507 pinfoMB.merge(gridMB);
508 }
509 return pinfoMB;
510 }, [](const PrimInfoMB& a, const PrimInfoMB& b) -> PrimInfoMB { return PrimInfoMB::merge2(a,b); });
511
512 size_t numPrimitives = pinfoMB.size();
513 if (numPrimitives == 0) return pinfoMB;
514
515 /* resize arrays */
516 sgrids.resize(numPrimitives);
517 prims.resize(numPrimitives);
518 /* second run to fill primrefs and SubGridBuildData arrays */
519 pinfoMB = parallel_for_for_prefix_sum1( pstate, iter, PrimInfoMB(empty), [&](GridMesh* mesh, const range<size_t>& r, size_t k, size_t geomID, const PrimInfoMB& base) -> PrimInfoMB {
520
521 k = base.size();
522 size_t p_index = k;
523 PrimInfoMB pinfoMB(empty);
524 for (size_t j=r.begin(); j<r.end(); j++)
525 {
526 if (!mesh->valid(j, mesh->timeSegmentRange(t0t1))) continue;
527 const GridMesh::Grid &g = mesh->grid(j);
528
529 for (unsigned int y=0; y<g.resY-1u; y+=2)
530 for (unsigned int x=0; x<g.resX-1u; x+=2)
531 {
532 const PrimRefMB prim(mesh->linearBounds(g,x,y,t0t1),mesh->numTimeSegments(),mesh->time_range,mesh->numTimeSegments(),unsigned(geomID),unsigned(p_index));
533 pinfoMB.add_primref(prim);
534 sgrids[p_index] = SubGridBuildData(x | g.get3x3FlagsX(x), y | g.get3x3FlagsY(y), unsigned(j));
535 prims[p_index++] = prim;
536 }
537 }
538 return pinfoMB;
539 }, [](const PrimInfoMB& a, const PrimInfoMB& b) -> PrimInfoMB { return PrimInfoMB::merge2(a,b); });
540
541 assert(pinfoMB.size() == numPrimitives);
542 pinfoMB.time_range = t0t1;
543 return pinfoMB;
544 }
545
546 void build()
547 {
548 /* skip build for empty scene */
549 const size_t numPrimitives = scene->getNumPrimitives(GridMesh::geom_type,true);
550 if (numPrimitives == 0) { bvh->clear(); return; }
551
552 double t0 = bvh->preBuild(TOSTRING(isa) "::BVH" + toString(N) + "BuilderMBlurSAHGrid");
553
554 //const size_t numTimeSteps = scene->getNumTimeSteps<GridMesh,true>();
555 //const size_t numTimeSegments = numTimeSteps-1; assert(numTimeSteps > 1);
556 //if (numTimeSegments == 1)
557 // buildSingleSegment(numPrimitives);
558 //else
559 buildMultiSegment(numPrimitives);
560
561 /* clear temporary data for static geometry */
562 bvh->cleanup();
563 bvh->postBuild(t0);
564 }
565
566#if 0
567 void buildSingleSegment(size_t numPrimitives)
568 {
569 /* create primref array */
570 mvector<PrimRef> prims(scene->device,numPrimitives);
571 const PrimInfo pinfo = createPrimRefArrayMBlurGrid(scene,prims,bvh->scene->progressInterface,0);
572 /* early out if no valid primitives */
573 if (pinfo.size() == 0) { bvh->clear(); return; }
574
575 /* estimate acceleration structure size */
576 const size_t node_bytes = pinfo.size()*sizeof(AABBNodeMB)/(4*N);
577 //TODO: check leaf_bytes
578 const size_t leaf_bytes = size_t(1.2*(float)numPrimitives/N * sizeof(SubGridQBVHN<N>));
579 bvh->alloc.init_estimate(node_bytes+leaf_bytes);
580
581 /* settings for BVH build */
582 GeneralBVHBuilder::Settings settings;
583 settings.branchingFactor = N;
584 settings.maxDepth = BVH::maxBuildDepthLeaf;
585 settings.logBlockSize = bsr(sahBlockSize);
586 settings.minLeafSize = min(minLeafSize,maxLeafSize);
587 settings.maxLeafSize = maxLeafSize;
588 settings.travCost = travCost;
589 settings.intCost = intCost;
590 settings.singleThreadThreshold = bvh->alloc.fixSingleThreadThreshold(N,DEFAULT_SINGLE_THREAD_THRESHOLD,pinfo.size(),node_bytes+leaf_bytes);
591
592 /* build hierarchy */
593 auto root = BVHBuilderBinnedSAH::build<NodeRecordMB>
594 (typename BVH::CreateAlloc(bvh),
595 typename BVH::AABBNodeMB::Create(),
596 typename BVH::AABBNodeMB::Set(),
597 CreateLeafGridMB<N>(scene,bvh,sgrids.data()),
598 bvh->scene->progressInterface,
599 prims.data(),pinfo,settings);
600
601 bvh->set(root.ref,root.lbounds,pinfo.size());
602 }
603#endif
604
605 void buildMultiSegment(size_t numPrimitives)
606 {
607 /* create primref array */
608 mvector<PrimRefMB> prims(scene->device,numPrimitives);
609 PrimInfoMB pinfo = createPrimRefArrayMSMBlurGrid(scene,prims,bvh->scene->progressInterface);
610
611 /* early out if no valid primitives */
612 if (pinfo.size() == 0) { bvh->clear(); return; }
613
614
615
616 GridRecalculatePrimRef recalculatePrimRef(scene,sgrids.data());
617
618 /* estimate acceleration structure size */
619 const size_t node_bytes = pinfo.num_time_segments*sizeof(AABBNodeMB)/(4*N);
620 //FIXME: check leaf_bytes
621 //const size_t leaf_bytes = size_t(1.2*Primitive::blocks(pinfo.num_time_segments)*sizeof(SubGridQBVHN<N>));
622 const size_t leaf_bytes = size_t(1.2*(float)numPrimitives/N * sizeof(SubGridQBVHN<N>));
623
624 bvh->alloc.init_estimate(node_bytes+leaf_bytes);
625
626 /* settings for BVH build */
627 BVHBuilderMSMBlur::Settings settings;
628 settings.branchingFactor = N;
629 settings.maxDepth = BVH::maxDepth;
630 settings.logBlockSize = bsr(sahBlockSize);
631 settings.minLeafSize = min(minLeafSize,maxLeafSize);
632 settings.maxLeafSize = maxLeafSize;
633 settings.travCost = travCost;
634 settings.intCost = intCost;
635 settings.singleLeafTimeSegment = false;
636 settings.singleThreadThreshold = bvh->alloc.fixSingleThreadThreshold(N,DEFAULT_SINGLE_THREAD_THRESHOLD,pinfo.size(),node_bytes+leaf_bytes);
637
638 /* build hierarchy */
639 auto root =
640 BVHBuilderMSMBlur::build<NodeRef>(prims,pinfo,scene->device,
641 recalculatePrimRef,
642 typename BVH::CreateAlloc(bvh),
643 typename BVH::AABBNodeMB4D::Create(),
644 typename BVH::AABBNodeMB4D::Set(),
645 CreateMSMBlurLeafGrid<N>(scene,bvh,sgrids.data()),
646 bvh->scene->progressInterface,
647 settings);
648 bvh->set(root.ref,root.lbounds,pinfo.num_time_segments);
649 }
650
651 void clear() {
652 }
653 };
654
655 /************************************************************************************/
656 /************************************************************************************/
657 /************************************************************************************/
658 /************************************************************************************/
659
660#if defined(EMBREE_GEOMETRY_TRIANGLE)
661 Builder* BVH4Triangle4iMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderMBlurSAH<4,TriangleMesh,Triangle4i>((BVH4*)bvh,scene,4,1.0f,4,inf,Geometry::MTY_TRIANGLE_MESH); }
662 Builder* BVH4Triangle4vMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderMBlurSAH<4,TriangleMesh,Triangle4vMB>((BVH4*)bvh,scene,4,1.0f,4,inf,Geometry::MTY_TRIANGLE_MESH); }
663#if defined(__AVX__)
664 Builder* BVH8Triangle4iMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderMBlurSAH<8,TriangleMesh,Triangle4i>((BVH8*)bvh,scene,4,1.0f,4,inf,Geometry::MTY_TRIANGLE_MESH); }
665 Builder* BVH8Triangle4vMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderMBlurSAH<8,TriangleMesh,Triangle4vMB>((BVH8*)bvh,scene,4,1.0f,4,inf,Geometry::MTY_TRIANGLE_MESH); }
666#endif
667#endif
668
669#if defined(EMBREE_GEOMETRY_QUAD)
670 Builder* BVH4Quad4iMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderMBlurSAH<4,QuadMesh,Quad4i>((BVH4*)bvh,scene,4,1.0f,4,inf,Geometry::MTY_QUAD_MESH); }
671#if defined(__AVX__)
672 Builder* BVH8Quad4iMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderMBlurSAH<8,QuadMesh,Quad4i>((BVH8*)bvh,scene,4,1.0f,4,inf,Geometry::MTY_QUAD_MESH); }
673#endif
674#endif
675
676#if defined(EMBREE_GEOMETRY_USER)
677 Builder* BVH4VirtualMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) {
678 int minLeafSize = scene->device->object_accel_mb_min_leaf_size;
679 int maxLeafSize = scene->device->object_accel_mb_max_leaf_size;
680 return new BVHNBuilderMBlurSAH<4,UserGeometry,Object>((BVH4*)bvh,scene,4,1.0f,minLeafSize,maxLeafSize,Geometry::MTY_USER_GEOMETRY);
681 }
682#if defined(__AVX__)
683 Builder* BVH8VirtualMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) {
684 int minLeafSize = scene->device->object_accel_mb_min_leaf_size;
685 int maxLeafSize = scene->device->object_accel_mb_max_leaf_size;
686 return new BVHNBuilderMBlurSAH<8,UserGeometry,Object>((BVH8*)bvh,scene,8,1.0f,minLeafSize,maxLeafSize,Geometry::MTY_USER_GEOMETRY);
687 }
688#endif
689#endif
690
691#if defined(EMBREE_GEOMETRY_INSTANCE)
692 Builder* BVH4InstanceMBSceneBuilderSAH (void* bvh, Scene* scene, Geometry::GTypeMask gtype) { return new BVHNBuilderMBlurSAH<4,Instance,InstancePrimitive>((BVH4*)bvh,scene,4,1.0f,1,1,gtype); }
693#if defined(__AVX__)
694 Builder* BVH8InstanceMBSceneBuilderSAH (void* bvh, Scene* scene, Geometry::GTypeMask gtype) { return new BVHNBuilderMBlurSAH<8,Instance,InstancePrimitive>((BVH8*)bvh,scene,8,1.0f,1,1,gtype); }
695#endif
696#endif
697
698#if defined(EMBREE_GEOMETRY_GRID)
699 Builder* BVH4GridMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderMBlurSAHGrid<4>((BVH4*)bvh,scene,4,1.0f,4,4); }
700#if defined(__AVX__)
701 Builder* BVH8GridMBSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderMBlurSAHGrid<8>((BVH8*)bvh,scene,8,1.0f,8,8); }
702#endif
703#endif
704 }
705}
706