CoCalc -- bvh_builder

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/embree/kernels/bvh/bvh_builder_sah.cpp
⁹⁹⁰⁶ views
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/primrefgen.h"
7
#include "../builders/splitter.h"
8

9
#include "../geometry/linei.h"
10
#include "../geometry/triangle.h"
11
#include "../geometry/trianglev.h"
12
#include "../geometry/trianglev_mb.h"
13
#include "../geometry/trianglei.h"
14
#include "../geometry/quadv.h"
15
#include "../geometry/quadi.h"
16
#include "../geometry/object.h"
17
#include "../geometry/instance.h"
18
#include "../geometry/instance_array.h"
19
#include "../geometry/subgrid.h"
20

21
#include "../common/state.h"
22
#include "../../common/algorithms/parallel_for_for.h"
23
#include "../../common/algorithms/parallel_for_for_prefix_sum.h"
24

25
#define PROFILE 0
26
#define PROFILE_RUNS 20
27

28
namespace embree
29
{
30
  namespace isa
31
  {
32
    template<int N, typename Primitive>
33
    struct CreateLeaf
34
    {
35
      typedef BVHN<N> BVH;
36
      typedef typename BVH::NodeRef NodeRef;
37

38
      __forceinline CreateLeaf (BVH* bvh) : bvh(bvh) {}
39

40
      __forceinline NodeRef operator() (const PrimRef* prims, const range<size_t>& set, const FastAllocator::CachedAllocator& alloc) const
41
      {
42
        size_t n = set.size();
43
        size_t items = Primitive::blocks(n);
44
        size_t start = set.begin();
45
        Primitive* accel = (Primitive*) alloc.malloc1(items*sizeof(Primitive),BVH::byteAlignment);
46
        typename BVH::NodeRef node = BVH::encodeLeaf((char*)accel,items);
47
        for (size_t i=0; i<items; i++) {
48
          accel[i].fill(prims,start,set.end(),bvh->scene);
49
        }
50
        return node;
51
      }
52

53
      BVH* bvh;
54
    };
55

56

57
    template<int N, typename Primitive>
58
    struct CreateLeafQuantized
59
    {
60
      typedef BVHN<N> BVH;
61
      typedef typename BVH::NodeRef NodeRef;
62

63
      __forceinline CreateLeafQuantized (BVH* bvh) : bvh(bvh) {}
64

65
      __forceinline NodeRef operator() (const PrimRef* prims, const range<size_t>& set, const FastAllocator::CachedAllocator& alloc) const
66
      {
67
        size_t n = set.size();
68
        size_t items = Primitive::blocks(n);
69
        size_t start = set.begin();
70
        Primitive* accel = (Primitive*) alloc.malloc1(items*sizeof(Primitive),BVH::byteAlignment);
71
        typename BVH::NodeRef node = BVH::encodeLeaf((char*)accel,items);
72
        for (size_t i=0; i<items; i++) {
73
          accel[i].fill(prims,start,set.end(),bvh->scene);
74
        }
75
        return node;
76
      }
77

78
      BVH* bvh;
79
    };
80

81
    /************************************************************************************/
82
    /************************************************************************************/
83
    /************************************************************************************/
84
    /************************************************************************************/
85

86
    template<int N, typename Primitive>
87
    struct BVHNBuilderSAH : public Builder
88
    {
89
      typedef BVHN<N> BVH;
90
      typedef typename BVHN<N>::NodeRef NodeRef;
91

92
      BVH* bvh;
93
      Scene* scene;
94
      Geometry* mesh;
95
      mvector<PrimRef> prims;
96
      GeneralBVHBuilder::Settings settings;
97
      Geometry::GTypeMask gtype_;
98
      unsigned int geomID_ = std::numeric_limits<unsigned int>::max ();
99
      bool primrefarrayalloc;
100
      unsigned int numPreviousPrimitives = 0;
101

102
      BVHNBuilderSAH (BVH* bvh, Scene* scene, const size_t sahBlockSize, const float intCost, const size_t minLeafSize, const size_t maxLeafSize,
103
                      const Geometry::GTypeMask gtype, bool primrefarrayalloc = false)
104
        : bvh(bvh), scene(scene), mesh(nullptr), prims(scene->device,0),
105
          settings(sahBlockSize, minLeafSize, min(maxLeafSize,Primitive::max_size()*BVH::maxLeafBlocks), travCost, intCost, DEFAULT_SINGLE_THREAD_THRESHOLD), gtype_(gtype), primrefarrayalloc(primrefarrayalloc) {}
106

107
      BVHNBuilderSAH (BVH* bvh, Geometry* mesh, unsigned int geomID, const size_t sahBlockSize, const float intCost, const size_t minLeafSize, const size_t maxLeafSize, const Geometry::GTypeMask gtype)
108
        : bvh(bvh), scene(nullptr), mesh(mesh), prims(bvh->device,0), settings(sahBlockSize, minLeafSize, min(maxLeafSize,Primitive::max_size()*BVH::maxLeafBlocks), travCost, intCost, DEFAULT_SINGLE_THREAD_THRESHOLD), gtype_(gtype), geomID_(geomID), primrefarrayalloc(false) {}
109

110
      // FIXME: shrink bvh->alloc in destructor here and in other builders too
111

112
      void build()
113
      {
114
        /* we reset the allocator when the mesh size changed */
115
        if (mesh && mesh->numPrimitives != numPreviousPrimitives) {
116
          bvh->alloc.clear();
117
        }
118

119
        /* if we use the primrefarray for allocations we have to take it back from the BVH */
120
        if (settings.primrefarrayalloc != size_t(inf))
121
          bvh->alloc.unshare(prims);
122

123
	/* skip build for empty scene */
124
        const size_t numPrimitives = mesh ? mesh->size() : scene->getNumPrimitives(gtype_,false);
125
        numPreviousPrimitives = numPrimitives;
126
        if (numPrimitives == 0) {
127
          bvh->clear();
128
          prims.clear();
129
          return;
130
        }
131

132
        double t0 = bvh->preBuild(mesh ? "" : TOSTRING(isa) "::BVH" + toString(N) + "BuilderSAH");
133

134
#if PROFILE
135
        profile(2,PROFILE_RUNS,numPrimitives,[&] (ProfileTimer& timer) {
136
#endif
137

138
            /* create primref array */
139
            if (primrefarrayalloc) {
140
              settings.primrefarrayalloc = numPrimitives/1000;
141
              if (settings.primrefarrayalloc < 1000)
142
                settings.primrefarrayalloc = inf;
143
            }
144

145
            /* enable os_malloc for two level build */
146
            if (mesh)
147
              bvh->alloc.setOSallocation(true);
148

149
            /* initialize allocator */
150
            const size_t node_bytes = numPrimitives*sizeof(typename BVH::AABBNodeMB)/(4*N);
151
            const size_t leaf_bytes = size_t(1.2*Primitive::blocks(numPrimitives)*sizeof(Primitive));
152
            bvh->alloc.init_estimate(node_bytes+leaf_bytes);
153
            settings.singleThreadThreshold = bvh->alloc.fixSingleThreadThreshold(N,DEFAULT_SINGLE_THREAD_THRESHOLD,numPrimitives,node_bytes+leaf_bytes);
154
            prims.resize(numPrimitives);
155

156
            PrimInfo pinfo = mesh ?
157
              createPrimRefArray(mesh,geomID_,numPrimitives,prims,bvh->scene->progressInterface) :
158
              createPrimRefArray(scene,gtype_,false,numPrimitives,prims,bvh->scene->progressInterface);
159

160
            /* pinfo might has zero size due to invalid geometry */
161
            if (unlikely(pinfo.size() == 0))
162
            {
163
              bvh->clear();
164
              prims.clear();
165
              return;
166
            }
167

168
            /* call BVH builder */
169
            NodeRef root = BVHNBuilderVirtual<N>::build(&bvh->alloc,CreateLeaf<N,Primitive>(bvh),bvh->scene->progressInterface,prims.data(),pinfo,settings);
170
            bvh->set(root,LBBox3fa(pinfo.geomBounds),pinfo.size());
171
            bvh->layoutLargeNodes(size_t(pinfo.size()*0.005f));
172

173
#if PROFILE
174
          });
175
#endif
176

177
        /* if we allocated using the primrefarray we have to keep it alive */
178
        if (settings.primrefarrayalloc != size_t(inf))
179
          bvh->alloc.share(prims);
180

181
        /* for static geometries we can do some cleanups */
182
        else if (scene && scene->isStaticAccel()) {
183
          prims.clear();
184
        }
185
	bvh->cleanup();
186
        bvh->postBuild(t0);
187
      }
188

189
      void clear() {
190
        prims.clear();
191
      }
192
    };
193

194
    /************************************************************************************/
195
    /************************************************************************************/
196
    /************************************************************************************/
197
    /************************************************************************************/
198

199
    template<int N, typename Primitive>
200
    struct BVHNBuilderSAHQuantized : public Builder
201
    {
202
      typedef BVHN<N> BVH;
203
      typedef typename BVHN<N>::NodeRef NodeRef;
204

205
      BVH* bvh;
206
      Scene* scene;
207
      Geometry* mesh;
208
      mvector<PrimRef> prims;
209
      GeneralBVHBuilder::Settings settings;
210
      Geometry::GTypeMask gtype_;
211
      unsigned int geomID_ = std::numeric_limits<unsigned int>::max();
212
      unsigned int numPreviousPrimitives = 0;
213

214
      BVHNBuilderSAHQuantized (BVH* bvh, Scene* scene, const size_t sahBlockSize, const float intCost, const size_t minLeafSize, const size_t maxLeafSize, const Geometry::GTypeMask gtype)
215
        : bvh(bvh), scene(scene), mesh(nullptr), prims(scene->device,0), settings(sahBlockSize, minLeafSize, min(maxLeafSize,Primitive::max_size()*BVH::maxLeafBlocks), travCost, intCost, DEFAULT_SINGLE_THREAD_THRESHOLD), gtype_(gtype) {}
216

217
      BVHNBuilderSAHQuantized (BVH* bvh, Geometry* mesh, unsigned int geomID, const size_t sahBlockSize, const float intCost, const size_t minLeafSize, const size_t maxLeafSize, const Geometry::GTypeMask gtype)
218
        : bvh(bvh), scene(nullptr), mesh(mesh), prims(bvh->device,0), settings(sahBlockSize, minLeafSize, min(maxLeafSize,Primitive::max_size()*BVH::maxLeafBlocks), travCost, intCost, DEFAULT_SINGLE_THREAD_THRESHOLD), gtype_(gtype), geomID_(geomID) {}
219

220
      // FIXME: shrink bvh->alloc in destructor here and in other builders too
221

222
      void build()
223
      {
224
        /* we reset the allocator when the mesh size changed */
225
        if (mesh && mesh->numPrimitives != numPreviousPrimitives) {
226
          bvh->alloc.clear();
227
        }
228

229
	/* skip build for empty scene */
230
        const size_t numPrimitives = mesh ? mesh->size() : scene->getNumPrimitives(gtype_,false);
231
        numPreviousPrimitives = numPrimitives;
232
        if (numPrimitives == 0) {
233
          prims.clear();
234
          bvh->clear();
235
          return;
236
        }
237

238
        double t0 = bvh->preBuild(mesh ? "" : TOSTRING(isa) "::QBVH" + toString(N) + "BuilderSAH");
239

240
#if PROFILE
241
        profile(2,PROFILE_RUNS,numPrimitives,[&] (ProfileTimer& timer) {
242
#endif
243
            /* create primref array */
244
            prims.resize(numPrimitives);
245
            PrimInfo pinfo = mesh ?
246
              createPrimRefArray(mesh,geomID_,numPrimitives,prims,bvh->scene->progressInterface) :
247
	      createPrimRefArray(scene,gtype_,false,numPrimitives,prims,bvh->scene->progressInterface);
248

249
            /* enable os_malloc for two level build */
250
            if (mesh)
251
              bvh->alloc.setOSallocation(true);
252

253
            /* call BVH builder */
254
            const size_t node_bytes = numPrimitives*sizeof(typename BVH::QuantizedNode)/(4*N);
255
            const size_t leaf_bytes = size_t(1.2*Primitive::blocks(numPrimitives)*sizeof(Primitive));
256
            bvh->alloc.init_estimate(node_bytes+leaf_bytes);
257
            settings.singleThreadThreshold = bvh->alloc.fixSingleThreadThreshold(N,DEFAULT_SINGLE_THREAD_THRESHOLD,numPrimitives,node_bytes+leaf_bytes);
258
            NodeRef root = BVHNBuilderQuantizedVirtual<N>::build(&bvh->alloc,CreateLeafQuantized<N,Primitive>(bvh),bvh->scene->progressInterface,prims.data(),pinfo,settings);
259
            bvh->set(root,LBBox3fa(pinfo.geomBounds),pinfo.size());
260
            //bvh->layoutLargeNodes(pinfo.size()*0.005f); // FIXME: COPY LAYOUT FOR LARGE NODES !!!
261
#if PROFILE
262
          });
263
#endif
264

265
	/* clear temporary data for static geometry */
266
	if (scene && scene->isStaticAccel()) {
267
          prims.clear();
268
        }
269
	bvh->cleanup();
270
        bvh->postBuild(t0);
271
      }
272

273
      void clear() {
274
        prims.clear();
275
      }
276
    };
277

278
    /************************************************************************************/
279
    /************************************************************************************/
280
    /************************************************************************************/
281
    /************************************************************************************/
282

283

284
    template<int N, typename Primitive>
285
    struct CreateLeafGrid
286
    {
287
      typedef BVHN<N> BVH;
288
      typedef typename BVH::NodeRef NodeRef;
289

290
      __forceinline CreateLeafGrid (BVH* bvh, const SubGridBuildData * const sgrids) : bvh(bvh),sgrids(sgrids) {}
291

292
      __forceinline NodeRef operator() (const PrimRef* prims, const range<size_t>& set, const FastAllocator::CachedAllocator& alloc) const
293
      {
294
        const size_t items = set.size(); //Primitive::blocks(n);
295
        const size_t start = set.begin();
296

297
        /* collect all subsets with unique geomIDs */
298
        assert(items <= N);
299
        unsigned int geomIDs[N];
300
        unsigned int num_geomIDs = 1;
301
        geomIDs[0] = prims[start].geomID();
302

303
        for (size_t i=1;i<items;i++)
304
        {
305
          bool found = false;
306
          const unsigned int new_geomID = prims[start+i].geomID();
307
          for (size_t j=0;j<num_geomIDs;j++)
308
            if (new_geomID == geomIDs[j])
309
            { found = true; break; }
310
          if (!found) 
311
            geomIDs[num_geomIDs++] = new_geomID;
312
        }
313

314
        /* allocate all leaf memory in one single block */
315
        SubGridQBVHN<N>* accel = (SubGridQBVHN<N>*) alloc.malloc1(num_geomIDs*sizeof(SubGridQBVHN<N>),BVH::byteAlignment);
316
        typename BVH::NodeRef node = BVH::encodeLeaf((char*)accel,num_geomIDs);
317

318
        for (size_t g=0;g<num_geomIDs;g++)
319
        {
320
          unsigned int x[N];
321
          unsigned int y[N];
322
          unsigned int primID[N];
323
          BBox3fa bounds[N];
324
          unsigned int pos = 0;
325
          for (size_t i=0;i<items;i++)
326
          {
327
            if (unlikely(prims[start+i].geomID() != geomIDs[g])) continue;
328

329
            const SubGridBuildData& sgrid_bd = sgrids[prims[start+i].primID()];
330
            x[pos] = sgrid_bd.sx;
331
            y[pos] = sgrid_bd.sy;
332
            primID[pos] = sgrid_bd.primID;
333
            bounds[pos] = prims[start+i].bounds();
334
            pos++;
335
          }
336
          assert(pos <= N);
337
          new (&accel[g]) SubGridQBVHN<N>(x,y,primID,bounds,geomIDs[g],pos);
338
        }
339

340
        return node;
341
      }
342

343
      BVH* bvh;
344
      const SubGridBuildData * const sgrids;
345
    };
346

347

348
    template<int N>
349
    struct BVHNBuilderSAHGrid : public Builder
350
    {
351
      typedef BVHN<N> BVH;
352
      typedef typename BVHN<N>::NodeRef NodeRef;
353
      
354
      BVH* bvh;
355
      Scene* scene;
356
      GridMesh* mesh;
357
      mvector<PrimRef> prims;
358
      mvector<SubGridBuildData> sgrids;
359
      GeneralBVHBuilder::Settings settings;
360
      const unsigned int geomID_ = std::numeric_limits<unsigned int>::max();
361
      unsigned int numPreviousPrimitives = 0;
362

363
      BVHNBuilderSAHGrid (BVH* bvh, Scene* scene, const size_t sahBlockSize, const float intCost, const size_t minLeafSize, const size_t maxLeafSize, const size_t mode)
364
        : bvh(bvh), scene(scene), mesh(nullptr), prims(scene->device,0), sgrids(scene->device,0), settings(sahBlockSize, minLeafSize, min(maxLeafSize,BVH::maxLeafBlocks), travCost, intCost, DEFAULT_SINGLE_THREAD_THRESHOLD) {}
365

366
      BVHNBuilderSAHGrid (BVH* bvh, GridMesh* mesh, unsigned int geomID, const size_t sahBlockSize, const float intCost, const size_t minLeafSize, const size_t maxLeafSize, const size_t mode)
367
        : bvh(bvh), scene(nullptr), mesh(mesh), prims(bvh->device,0), sgrids(scene->device,0), settings(sahBlockSize, minLeafSize, min(maxLeafSize,BVH::maxLeafBlocks), travCost, intCost, DEFAULT_SINGLE_THREAD_THRESHOLD), geomID_(geomID) {}
368

369
      void build()
370
      {
371
        /* we reset the allocator when the mesh size changed */
372
        if (mesh && mesh->numPrimitives != numPreviousPrimitives) {
373
          bvh->alloc.clear();
374
        }
375
        
376
        /* if we use the primrefarray for allocations we have to take it back from the BVH */
377
        if (settings.primrefarrayalloc != size_t(inf))
378
          bvh->alloc.unshare(prims);
379

380
        const size_t numGridPrimitives = mesh ? mesh->size() : scene->getNumPrimitives(GridMesh::geom_type,false);
381
        numPreviousPrimitives = numGridPrimitives;
382

383

384
        PrimInfo pinfo = mesh ? createPrimRefArrayGrids(mesh,prims,sgrids) : createPrimRefArrayGrids(scene,prims,sgrids);
385
        const size_t numPrimitives = pinfo.size();
386
        /* no primitives */
387
        if (numPrimitives == 0) {
388
          bvh->clear();
389
          prims.clear();
390
          sgrids.clear();
391
          return;
392
        }
393

394
        double t0 = bvh->preBuild(mesh ? "" : TOSTRING(isa) "::BVH" + toString(N) + "BuilderSAH");
395

396
        /* create primref array */
397
        settings.primrefarrayalloc = numPrimitives/1000;
398
        if (settings.primrefarrayalloc < 1000)
399
          settings.primrefarrayalloc = inf;
400

401
        /* enable os_malloc for two level build */
402
        if (mesh)
403
          bvh->alloc.setOSallocation(true);
404

405
        /* initialize allocator */
406
        const size_t node_bytes = numPrimitives*sizeof(typename BVH::AABBNodeMB)/(4*N);
407
        const size_t leaf_bytes = size_t(1.2*(float)numPrimitives/N * sizeof(SubGridQBVHN<N>));
408

409
        bvh->alloc.init_estimate(node_bytes+leaf_bytes);
410
        settings.singleThreadThreshold = bvh->alloc.fixSingleThreadThreshold(N,DEFAULT_SINGLE_THREAD_THRESHOLD,numPrimitives,node_bytes+leaf_bytes);
411

412
        /* pinfo might has zero size due to invalid geometry */
413
        if (unlikely(pinfo.size() == 0))
414
        {
415
          bvh->clear();
416
          sgrids.clear();
417
          prims.clear();
418
          return;
419
        }
420

421
        /* call BVH builder */
422
        NodeRef root = BVHNBuilderVirtual<N>::build(&bvh->alloc,CreateLeafGrid<N,SubGridQBVHN<N>>(bvh,sgrids.data()),bvh->scene->progressInterface,prims.data(),pinfo,settings);
423
        bvh->set(root,LBBox3fa(pinfo.geomBounds),pinfo.size());
424
        bvh->layoutLargeNodes(size_t(pinfo.size()*0.005f));
425

426
        /* clear temporary array */
427
        sgrids.clear();
428

429
        /* if we allocated using the primrefarray we have to keep it alive */
430
        if (settings.primrefarrayalloc != size_t(inf))
431
          bvh->alloc.share(prims);
432

433
        /* for static geometries we can do some cleanups */
434
        else if (scene && scene->isStaticAccel()) {
435
          prims.clear();
436
        }
437
	bvh->cleanup();
438
        bvh->postBuild(t0);
439
      }
440

441
      void clear() {
442
        prims.clear();
443
      }
444
    };
445

446
    /************************************************************************************/
447
    /************************************************************************************/
448
    /************************************************************************************/
449
    /************************************************************************************/
450

451
    
452
#if defined(EMBREE_GEOMETRY_TRIANGLE)
453
    Builder* BVH4Triangle4MeshBuilderSAH  (void* bvh, TriangleMesh* mesh, unsigned int geomID, size_t mode) { return new BVHNBuilderSAH<4,Triangle4>((BVH4*)bvh,mesh,geomID,4,1.0f,4,inf,TriangleMesh::geom_type); }
454
    Builder* BVH4Triangle4vMeshBuilderSAH (void* bvh, TriangleMesh* mesh, unsigned int geomID, size_t mode) { return new BVHNBuilderSAH<4,Triangle4v>((BVH4*)bvh,mesh,geomID,4,1.0f,4,inf,TriangleMesh::geom_type); }
455
    Builder* BVH4Triangle4iMeshBuilderSAH (void* bvh, TriangleMesh* mesh, unsigned int geomID, size_t mode) { return new BVHNBuilderSAH<4,Triangle4i>((BVH4*)bvh,mesh,geomID,4,1.0f,4,inf,TriangleMesh::geom_type); }
456

457
    Builder* BVH4Triangle4SceneBuilderSAH  (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<4,Triangle4>((BVH4*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type); }
458
    Builder* BVH4Triangle4vSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<4,Triangle4v>((BVH4*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type); }
459
    Builder* BVH4Triangle4iSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<4,Triangle4i>((BVH4*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type,true); }
460

461
    Builder* BVH4QuantizedTriangle4iSceneBuilderSAH (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAHQuantized<4,Triangle4i>((BVH4*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type); }
462
#if defined(__AVX__)
463
    Builder* BVH8Triangle4MeshBuilderSAH  (void* bvh, TriangleMesh* mesh, unsigned int geomID, size_t mode) { return new BVHNBuilderSAH<8,Triangle4>((BVH8*)bvh,mesh,geomID,4,1.0f,4,inf,TriangleMesh::geom_type); }
464
    Builder* BVH8Triangle4vMeshBuilderSAH (void* bvh, TriangleMesh* mesh, unsigned int geomID, size_t mode) { return new BVHNBuilderSAH<8,Triangle4v>((BVH8*)bvh,mesh,geomID,4,1.0f,4,inf,TriangleMesh::geom_type); }
465
    Builder* BVH8Triangle4iMeshBuilderSAH (void* bvh, TriangleMesh* mesh, unsigned int geomID, size_t mode) { return new BVHNBuilderSAH<8,Triangle4i>((BVH8*)bvh,mesh,geomID,4,1.0f,4,inf,TriangleMesh::geom_type); }
466

467
    Builder* BVH8Triangle4SceneBuilderSAH  (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<8,Triangle4>((BVH8*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type); }
468
    Builder* BVH8Triangle4vSceneBuilderSAH  (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<8,Triangle4v>((BVH8*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type); }
469
    Builder* BVH8Triangle4iSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<8,Triangle4i>((BVH8*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type,true); }
470
    Builder* BVH8QuantizedTriangle4iSceneBuilderSAH  (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAHQuantized<8,Triangle4i>((BVH8*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type); }
471
    Builder* BVH8QuantizedTriangle4SceneBuilderSAH  (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAHQuantized<8,Triangle4>((BVH8*)bvh,scene,4,1.0f,4,inf,TriangleMesh::geom_type); }
472

473
    
474

475
#endif
476
#endif
477

478
#if defined(EMBREE_GEOMETRY_QUAD)
479
    Builder* BVH4Quad4vMeshBuilderSAH     (void* bvh, QuadMesh* mesh, unsigned int geomID, size_t mode)     { return new BVHNBuilderSAH<4,Quad4v>((BVH4*)bvh,mesh,geomID,4,1.0f,4,inf,QuadMesh::geom_type); }
480
    Builder* BVH4Quad4iMeshBuilderSAH     (void* bvh, QuadMesh* mesh, unsigned int geomID, size_t mode)     { return new BVHNBuilderSAH<4,Quad4i>((BVH4*)bvh,mesh,geomID,4,1.0f,4,inf,QuadMesh::geom_type); }
481
    Builder* BVH4Quad4vSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<4,Quad4v>((BVH4*)bvh,scene,4,1.0f,4,inf,QuadMesh::geom_type); }
482
    Builder* BVH4Quad4iSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<4,Quad4i>((BVH4*)bvh,scene,4,1.0f,4,inf,QuadMesh::geom_type,true); }
483
    Builder* BVH4QuantizedQuad4vSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAHQuantized<4,Quad4v>((BVH4*)bvh,scene,4,1.0f,4,inf,QuadMesh::geom_type); }
484
    Builder* BVH4QuantizedQuad4iSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAHQuantized<4,Quad4i>((BVH4*)bvh,scene,4,1.0f,4,inf,QuadMesh::geom_type); }
485

486
#if defined(__AVX__)
487
    Builder* BVH8Quad4vSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<8,Quad4v>((BVH8*)bvh,scene,4,1.0f,4,inf,QuadMesh::geom_type); }
488
    Builder* BVH8Quad4iSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAH<8,Quad4i>((BVH8*)bvh,scene,4,1.0f,4,inf,QuadMesh::geom_type,true); }
489
    Builder* BVH8QuantizedQuad4vSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAHQuantized<8,Quad4v>((BVH8*)bvh,scene,4,1.0f,4,inf,QuadMesh::geom_type); }
490
    Builder* BVH8QuantizedQuad4iSceneBuilderSAH     (void* bvh, Scene* scene, size_t mode) { return new BVHNBuilderSAHQuantized<8,Quad4i>((BVH8*)bvh,scene,4,1.0f,4,inf,QuadMesh::geom_type); }
491
    Builder* BVH8Quad4vMeshBuilderSAH     (void* bvh, QuadMesh* mesh, unsigned int geomID, size_t mode)     { return new BVHNBuilderSAH<8,Quad4v>((BVH8*)bvh,mesh,geomID,4,1.0f,4,inf,QuadMesh::geom_type); }
492

493
#endif
494
#endif
495

496
#if defined(EMBREE_GEOMETRY_USER)
497

498
    Builder* BVH4VirtualSceneBuilderSAH    (void* bvh, Scene* scene, size_t mode) {
499
      int minLeafSize = scene->device->object_accel_min_leaf_size;
500
      int maxLeafSize = scene->device->object_accel_max_leaf_size;
501
      return new BVHNBuilderSAH<4,Object>((BVH4*)bvh,scene,4,1.0f,minLeafSize,maxLeafSize,UserGeometry::geom_type);
502
    }
503

504
    Builder* BVH4VirtualMeshBuilderSAH    (void* bvh, UserGeometry* mesh, unsigned int geomID, size_t mode) {
505
      return new BVHNBuilderSAH<4,Object>((BVH4*)bvh,mesh,geomID,4,1.0f,1,inf,UserGeometry::geom_type);
506
    }
507
#if defined(__AVX__)
508

509
    Builder* BVH8VirtualSceneBuilderSAH    (void* bvh, Scene* scene, size_t mode) {
510
      int minLeafSize = scene->device->object_accel_min_leaf_size;
511
      int maxLeafSize = scene->device->object_accel_max_leaf_size;
512
      return new BVHNBuilderSAH<8,Object>((BVH8*)bvh,scene,8,1.0f,minLeafSize,maxLeafSize,UserGeometry::geom_type);
513
    }
514

515
    Builder* BVH8VirtualMeshBuilderSAH    (void* bvh, UserGeometry* mesh, unsigned int geomID, size_t mode) {
516
      return new BVHNBuilderSAH<8,Object>((BVH8*)bvh,mesh,geomID,8,1.0f,1,inf,UserGeometry::geom_type);
517
    }
518
#endif
519
#endif
520

521
#if defined(EMBREE_GEOMETRY_INSTANCE)
522
    Builder* BVH4InstanceSceneBuilderSAH (void* bvh, Scene* scene, Geometry::GTypeMask gtype) {
523
      return new BVHNBuilderSAH<4,InstancePrimitive>((BVH4*)bvh,scene,4,1.0f,1,1,gtype);
524
    }
525
    Builder* BVH4InstanceMeshBuilderSAH (void* bvh, Instance* mesh, Geometry::GTypeMask gtype, unsigned int geomID, size_t mode) {
526
      return new BVHNBuilderSAH<4,InstancePrimitive>((BVH4*)bvh,mesh,geomID,4,1.0f,1,inf,gtype);
527
    }
528
#if defined(__AVX__)
529
    Builder* BVH8InstanceSceneBuilderSAH (void* bvh, Scene* scene, Geometry::GTypeMask gtype) {
530
      return new BVHNBuilderSAH<8,InstancePrimitive>((BVH8*)bvh,scene,8,1.0f,1,1,gtype);
531
    }
532
    Builder* BVH8InstanceMeshBuilderSAH (void* bvh, Instance* mesh, Geometry::GTypeMask gtype, unsigned int geomID, size_t mode) {
533
      return new BVHNBuilderSAH<8,InstancePrimitive>((BVH8*)bvh,mesh,geomID,8,1.0f,1,1,gtype);
534
    }
535
#endif
536
#endif
537

538
#if defined(EMBREE_GEOMETRY_INSTANCE_ARRAY)
539
    Builder* BVH4InstanceArraySceneBuilderSAH (void* bvh, Scene* scene, Geometry::GTypeMask gtype) {
540
      return new BVHNBuilderSAH<4,InstanceArrayPrimitive>((BVH4*)bvh,scene,4,1.0f,1,1,gtype);
541
    }
542
    Builder* BVH4InstanceArrayMeshBuilderSAH (void* bvh, InstanceArray* mesh, Geometry::GTypeMask gtype, unsigned int geomID, size_t mode) {
543
      return new BVHNBuilderSAH<4,InstanceArrayPrimitive>((BVH4*)bvh,mesh,geomID,4,1.0f,1,1,gtype);
544
    }
545
#if defined(__AVX__)
546
    Builder* BVH8InstanceArraySceneBuilderSAH (void* bvh, Scene* scene, Geometry::GTypeMask gtype) {
547
      return new BVHNBuilderSAH<8,InstanceArrayPrimitive>((BVH8*)bvh,scene,8,1.0f,1,1,gtype);
548
    }
549
    Builder* BVH8InstanceArrayMeshBuilderSAH (void* bvh, InstanceArray* mesh, Geometry::GTypeMask gtype, unsigned int geomID, size_t mode) {
550
      return new BVHNBuilderSAH<8,InstanceArrayPrimitive>((BVH8*)bvh,mesh,geomID,8,1.0f,1,1,gtype);
551
    }
552
#endif
553
#endif
554

555
#if defined(EMBREE_GEOMETRY_GRID)
556
    Builder* BVH4GridMeshBuilderSAH  (void* bvh, GridMesh* mesh, unsigned int geomID, size_t mode) { return new BVHNBuilderSAHGrid<4>((BVH4*)bvh,mesh,geomID,4,1.0f,4,4,mode); }
557
    Builder* BVH4GridSceneBuilderSAH (void* bvh, Scene* scene, size_t mode)   { return new BVHNBuilderSAHGrid<4>((BVH4*)bvh,scene,4,1.0f,4,4,mode); } // FIXME: check whether cost factors are correct
558

559
#if defined(__AVX__)
560
    Builder* BVH8GridMeshBuilderSAH  (void* bvh, GridMesh* mesh, unsigned int geomID, size_t mode) { return new BVHNBuilderSAHGrid<8>((BVH8*)bvh,mesh,geomID,8,1.0f,8,8,mode); }
561
    Builder* BVH8GridSceneBuilderSAH (void* bvh, Scene* scene, size_t mode)   { return new BVHNBuilderSAHGrid<8>((BVH8*)bvh,scene,8,1.0f,8,8,mode); } // FIXME: check whether cost factors are correct
562
#endif
563
#endif
564
  }
565
}
566

567
Product

Resources

Company
