CoCalc -- bvh8_factory.cpp

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/embree/kernels/bvh/bvh8_factory.cpp
⁹⁹⁰⁶ views
1
// Copyright 2009-2021 Intel Corporation
2
// SPDX-License-Identifier: Apache-2.0
3

4
#include "../common/isa.h" // to define EMBREE_TARGET_SIMD8
5

6
#if defined (EMBREE_TARGET_SIMD8)
7

8
#include "bvh8_factory.h"
9
#include "../bvh/bvh.h"
10

11
#include "../geometry/curveNv.h"
12
#include "../geometry/curveNi.h"
13
#include "../geometry/curveNi_mb.h"
14
#include "../geometry/linei.h"
15
#include "../geometry/triangle.h"
16
#include "../geometry/trianglev.h"
17
#include "../geometry/trianglev_mb.h"
18
#include "../geometry/trianglei.h"
19
#include "../geometry/quadv.h"
20
#include "../geometry/quadi.h"
21
#include "../geometry/subdivpatch1.h"
22
#include "../geometry/object.h"
23
#include "../geometry/instance.h"
24
#include "../geometry/instance_array.h"
25
#include "../geometry/subgrid.h"
26
#include "../common/accelinstance.h"
27

28
namespace embree
29
{
30
  DECLARE_SYMBOL2(Accel::Collider,BVH8ColliderUserGeom);
31
  
32
  DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector8v,void);
33
  DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector8iMB,void);
34
  
35
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8OBBVirtualCurveIntersector1);
36
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8OBBVirtualCurveIntersector1MB);
37
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8OBBVirtualCurveIntersectorRobust1);
38
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8OBBVirtualCurveIntersectorRobust1MB);
39

40
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4Intersector1Moeller);
41
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4iIntersector1Moeller);
42
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4vIntersector1Pluecker);
43
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4iIntersector1Pluecker);
44

45
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4vIntersector1Woop);
46

47
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4vMBIntersector1Moeller);
48
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4iMBIntersector1Moeller);
49
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4vMBIntersector1Pluecker);
50
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Triangle4iMBIntersector1Pluecker);
51

52
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Quad4vIntersector1Moeller);
53
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Quad4iIntersector1Moeller);
54
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Quad4vIntersector1Pluecker);
55
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Quad4iIntersector1Pluecker);
56

57
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Quad4iMBIntersector1Moeller);
58
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8Quad4iMBIntersector1Pluecker);
59

60
  DECLARE_SYMBOL2(Accel::Intersector1,QBVH8Triangle4iIntersector1Pluecker);
61
  DECLARE_SYMBOL2(Accel::Intersector1,QBVH8Triangle4Intersector1Moeller);
62
  DECLARE_SYMBOL2(Accel::Intersector1,QBVH8Quad4iIntersector1Pluecker);
63

64
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8VirtualIntersector1);
65
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8VirtualMBIntersector1);
66

67
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8InstanceIntersector1);
68
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8InstanceMBIntersector1);
69

70
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8InstanceArrayIntersector1);
71
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8InstanceArrayMBIntersector1);
72

73
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8GridIntersector1Moeller);
74
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8GridMBIntersector1Moeller);
75
  DECLARE_SYMBOL2(Accel::Intersector1,BVH8GridIntersector1Pluecker);
76

77
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8OBBVirtualCurveIntersector4Hybrid);
78
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8OBBVirtualCurveIntersector4HybridMB);
79
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8OBBVirtualCurveIntersectorRobust4Hybrid);
80
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8OBBVirtualCurveIntersectorRobust4HybridMB);
81

82
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4Intersector4HybridMoeller);
83
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4Intersector4HybridMoellerNoFilter);
84
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4iIntersector4HybridMoeller);
85
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4vIntersector4HybridPluecker);
86
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4iIntersector4HybridPluecker);
87

88
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4vMBIntersector4HybridMoeller);
89
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4iMBIntersector4HybridMoeller);
90
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4vMBIntersector4HybridPluecker);
91
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Triangle4iMBIntersector4HybridPluecker);
92

93
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Quad4vIntersector4HybridMoeller);
94
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Quad4vIntersector4HybridMoellerNoFilter);
95
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Quad4iIntersector4HybridMoeller);
96
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Quad4vIntersector4HybridPluecker);
97
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Quad4iIntersector4HybridPluecker);
98

99
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Quad4iMBIntersector4HybridMoeller);
100
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8Quad4iMBIntersector4HybridPluecker);
101

102
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8VirtualIntersector4Chunk);
103
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8VirtualMBIntersector4Chunk);
104

105
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8InstanceIntersector4Chunk);
106
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8InstanceMBIntersector4Chunk);
107

108
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8InstanceArrayIntersector4Chunk);
109
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8InstanceArrayMBIntersector4Chunk);
110

111
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8GridIntersector4HybridMoeller);
112
  DECLARE_SYMBOL2(Accel::Intersector4,BVH8GridIntersector4HybridPluecker);
113

114
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8OBBVirtualCurveIntersector8Hybrid);
115
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8OBBVirtualCurveIntersector8HybridMB);
116
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8OBBVirtualCurveIntersectorRobust8Hybrid);
117
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8OBBVirtualCurveIntersectorRobust8HybridMB);
118

119
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4Intersector8HybridMoeller);
120
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4Intersector8HybridMoellerNoFilter);
121
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4iIntersector8HybridMoeller);
122
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4vIntersector8HybridPluecker);
123
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4iIntersector8HybridPluecker);
124

125
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4vMBIntersector8HybridMoeller);
126
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4iMBIntersector8HybridMoeller);
127
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4vMBIntersector8HybridPluecker);
128
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Triangle4iMBIntersector8HybridPluecker);
129

130
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Quad4vIntersector8HybridMoeller);
131
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Quad4vIntersector8HybridMoellerNoFilter);
132
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Quad4iIntersector8HybridMoeller);
133
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Quad4vIntersector8HybridPluecker);
134
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Quad4iIntersector8HybridPluecker);
135

136
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Quad4iMBIntersector8HybridMoeller);
137
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8Quad4iMBIntersector8HybridPluecker);
138

139
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8VirtualIntersector8Chunk);
140
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8VirtualMBIntersector8Chunk);
141

142
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8InstanceIntersector8Chunk);
143
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8InstanceMBIntersector8Chunk);
144

145
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8InstanceArrayIntersector8Chunk);
146
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8InstanceArrayMBIntersector8Chunk);
147

148
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8GridIntersector8HybridMoeller);
149
  DECLARE_SYMBOL2(Accel::Intersector8,BVH8GridIntersector8HybridPluecker);
150

151
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8OBBVirtualCurveIntersector16Hybrid);
152
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8OBBVirtualCurveIntersector16HybridMB);
153
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8OBBVirtualCurveIntersectorRobust16Hybrid);
154
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8OBBVirtualCurveIntersectorRobust16HybridMB);
155

156
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4Intersector16HybridMoeller);
157
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4Intersector16HybridMoellerNoFilter);
158
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4iIntersector16HybridMoeller);
159
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4vIntersector16HybridPluecker);
160
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4iIntersector16HybridPluecker);
161

162
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4vMBIntersector16HybridMoeller);
163
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4iMBIntersector16HybridMoeller);
164
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4vMBIntersector16HybridPluecker);
165
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Triangle4iMBIntersector16HybridPluecker);
166

167
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Quad4vIntersector16HybridMoeller);
168
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Quad4vIntersector16HybridMoellerNoFilter);
169
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Quad4iIntersector16HybridMoeller);
170
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Quad4vIntersector16HybridPluecker);
171
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Quad4iIntersector16HybridPluecker);
172

173
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Quad4iMBIntersector16HybridMoeller);
174
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8Quad4iMBIntersector16HybridPluecker);
175

176
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8VirtualIntersector16Chunk);
177
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8VirtualMBIntersector16Chunk);
178

179
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8InstanceIntersector16Chunk);
180
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8InstanceMBIntersector16Chunk);
181

182
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8InstanceArrayIntersector16Chunk);
183
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8InstanceArrayMBIntersector16Chunk);
184

185
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8GridIntersector16HybridMoeller);
186
  DECLARE_SYMBOL2(Accel::Intersector16,BVH8GridIntersector16HybridPluecker);
187

188
  DECLARE_ISA_FUNCTION(Builder*,BVH8Curve8vBuilder_OBB_New,void* COMMA Scene* COMMA size_t);
189
  DECLARE_ISA_FUNCTION(Builder*,BVH8OBBCurve8iMBBuilder_OBB,void* COMMA Scene* COMMA size_t);
190

191
  DECLARE_ISA_FUNCTION(Builder*,BVH8Triangle4SceneBuilderSAH,void* COMMA Scene* COMMA size_t);
192
  DECLARE_ISA_FUNCTION(Builder*,BVH8Triangle4vSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
193
  DECLARE_ISA_FUNCTION(Builder*,BVH8Triangle4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
194
  DECLARE_ISA_FUNCTION(Builder*,BVH8Triangle4iMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
195
  DECLARE_ISA_FUNCTION(Builder*,BVH8Triangle4vMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
196
  DECLARE_ISA_FUNCTION(Builder*,BVH8QuantizedTriangle4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
197
  DECLARE_ISA_FUNCTION(Builder*,BVH8QuantizedTriangle4SceneBuilderSAH,void* COMMA Scene* COMMA size_t);
198

199
  DECLARE_ISA_FUNCTION(Builder*,BVH8Quad4vSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
200
  DECLARE_ISA_FUNCTION(Builder*,BVH8Quad4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
201
  DECLARE_ISA_FUNCTION(Builder*,BVH8Quad4iMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
202
  DECLARE_ISA_FUNCTION(Builder*,BVH8QuantizedQuad4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
203

204
  DECLARE_ISA_FUNCTION(Builder*,BVH8VirtualSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
205
  DECLARE_ISA_FUNCTION(Builder*,BVH8VirtualMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
206
  
207
  DECLARE_ISA_FUNCTION(Builder*,BVH8InstanceSceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
208
  DECLARE_ISA_FUNCTION(Builder*,BVH8InstanceMBSceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
209

210
  DECLARE_ISA_FUNCTION(Builder*,BVH8InstanceArraySceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
211
  DECLARE_ISA_FUNCTION(Builder*,BVH8InstanceArrayMBSceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
212

213
  DECLARE_ISA_FUNCTION(Builder*,BVH8Triangle4SceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
214
  DECLARE_ISA_FUNCTION(Builder*,BVH8Triangle4vSceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
215
  DECLARE_ISA_FUNCTION(Builder*,BVH8Quad4vSceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
216
  DECLARE_ISA_FUNCTION(Builder*,BVH8GridSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
217
  DECLARE_ISA_FUNCTION(Builder*,BVH8GridMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
218

219
  DECLARE_ISA_FUNCTION(Builder*,BVH8BuilderTwoLevelTriangle4MeshSAH,void* COMMA Scene* COMMA bool);
220
  DECLARE_ISA_FUNCTION(Builder*,BVH8BuilderTwoLevelTriangle4vMeshSAH,void* COMMA Scene* COMMA bool);
221
  DECLARE_ISA_FUNCTION(Builder*,BVH8BuilderTwoLevelTriangle4iMeshSAH,void* COMMA Scene* COMMA bool);
222
  DECLARE_ISA_FUNCTION(Builder*,BVH8BuilderTwoLevelQuadMeshSAH,void* COMMA Scene* COMMA bool);
223
  DECLARE_ISA_FUNCTION(Builder*,BVH8BuilderTwoLevelVirtualSAH,void* COMMA Scene* COMMA bool);
224
  DECLARE_ISA_FUNCTION(Builder*,BVH8BuilderTwoLevelInstanceSAH,void* COMMA Scene* COMMA Geometry::GTypeMask COMMA bool);
225
  DECLARE_ISA_FUNCTION(Builder*,BVH8BuilderTwoLevelInstanceArraySAH,void* COMMA Scene* COMMA Geometry::GTypeMask COMMA bool);
226

227
  BVH8Factory::BVH8Factory(int bfeatures, int ifeatures)
228
  {
229
    SELECT_SYMBOL_INIT_AVX(ifeatures,BVH8ColliderUserGeom);
230
    
231
    selectBuilders(bfeatures);
232
    selectIntersectors(ifeatures);
233
  }
234

235
  void BVH8Factory::selectBuilders(int features)
236
  {
237
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX(features,BVH8Curve8vBuilder_OBB_New));
238
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX(features,BVH8OBBCurve8iMBBuilder_OBB));
239

240
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8Triangle4SceneBuilderSAH));
241
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8Triangle4vSceneBuilderSAH));
242
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8Triangle4iSceneBuilderSAH));
243
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8Triangle4iMBSceneBuilderSAH));
244
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8Triangle4vMBSceneBuilderSAH));
245
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8QuantizedTriangle4iSceneBuilderSAH));
246
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8QuantizedTriangle4SceneBuilderSAH));
247

248
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX(features,BVH8Quad4vSceneBuilderSAH));
249
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX(features,BVH8Quad4iSceneBuilderSAH));
250
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX(features,BVH8Quad4iMBSceneBuilderSAH));
251
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX(features,BVH8QuantizedQuad4iSceneBuilderSAH));
252

253
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX(features,BVH8VirtualSceneBuilderSAH));
254
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX(features,BVH8VirtualMBSceneBuilderSAH));
255

256
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX(features,BVH8InstanceSceneBuilderSAH));
257
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX(features,BVH8InstanceMBSceneBuilderSAH));
258

259
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX(features,BVH8InstanceArraySceneBuilderSAH));
260
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX(features,BVH8InstanceArrayMBSceneBuilderSAH));
261
    
262
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX(features,BVH8GridSceneBuilderSAH));
263
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX(features,BVH8GridMBSceneBuilderSAH));
264

265
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8Triangle4SceneBuilderFastSpatialSAH));
266
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX(features,BVH8Triangle4vSceneBuilderFastSpatialSAH));
267
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX(features,BVH8Quad4vSceneBuilderFastSpatialSAH));
268

269
    IF_ENABLED_TRIS  (SELECT_SYMBOL_INIT_AVX(features,BVH8BuilderTwoLevelTriangle4MeshSAH));
270
    IF_ENABLED_TRIS  (SELECT_SYMBOL_INIT_AVX(features,BVH8BuilderTwoLevelTriangle4vMeshSAH));
271
    IF_ENABLED_TRIS  (SELECT_SYMBOL_INIT_AVX(features,BVH8BuilderTwoLevelTriangle4iMeshSAH));
272
    IF_ENABLED_QUADS (SELECT_SYMBOL_INIT_AVX(features,BVH8BuilderTwoLevelQuadMeshSAH));
273
    IF_ENABLED_USER  (SELECT_SYMBOL_INIT_AVX(features,BVH8BuilderTwoLevelVirtualSAH));
274
    IF_ENABLED_INSTANCE (SELECT_SYMBOL_INIT_AVX(features,BVH8BuilderTwoLevelInstanceSAH));
275
    IF_ENABLED_INSTANCE_ARRAY (SELECT_SYMBOL_INIT_AVX(features,BVH8BuilderTwoLevelInstanceArraySAH));
276
  }
277

278
  void BVH8Factory::selectIntersectors(int features)
279
  {
280
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,VirtualCurveIntersector8v));
281
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,VirtualCurveIntersector8iMB));
282
    
283
    /* select intersectors1 */
284
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersector1));
285
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersector1MB));
286
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersectorRobust1));
287
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersectorRobust1MB));
288

289
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4Intersector1Moeller));
290
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iIntersector1Moeller));
291
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vIntersector1Pluecker));
292
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iIntersector1Pluecker));
293

294
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vIntersector1Woop));
295

296
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vMBIntersector1Moeller));
297
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iMBIntersector1Moeller));
298
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vMBIntersector1Pluecker));
299
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iMBIntersector1Pluecker));
300

301
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4vIntersector1Moeller));
302
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4iIntersector1Moeller));
303
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4vIntersector1Pluecker));
304
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4iIntersector1Pluecker));
305

306
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4iMBIntersector1Moeller));
307
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4iMBIntersector1Pluecker));
308

309
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,QBVH8Triangle4iIntersector1Pluecker));
310
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,QBVH8Triangle4Intersector1Moeller));
311
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,QBVH8Quad4iIntersector1Pluecker));
312

313
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8VirtualIntersector1));
314
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8VirtualMBIntersector1));
315

316
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceIntersector1));
317
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceMBIntersector1));
318

319
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceArrayIntersector1));
320
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceArrayMBIntersector1));
321

322
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8GridIntersector1Moeller));
323
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8GridMBIntersector1Moeller))
324
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8GridIntersector1Pluecker));
325

326
#if defined (EMBREE_RAY_PACKETS)
327

328
    /* select intersectors4 */
329
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersector4Hybrid));
330
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersector4HybridMB));
331
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersectorRobust4Hybrid));
332
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersectorRobust4HybridMB));
333

334
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4Intersector4HybridMoeller));
335
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4Intersector4HybridMoellerNoFilter));
336
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iIntersector4HybridMoeller));
337
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vIntersector4HybridPluecker));
338
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iIntersector4HybridPluecker));
339

340
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vMBIntersector4HybridMoeller));
341
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iMBIntersector4HybridMoeller));
342
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vMBIntersector4HybridPluecker));
343
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iMBIntersector4HybridPluecker));
344

345
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4vIntersector4HybridMoeller));
346
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4vIntersector4HybridMoellerNoFilter));
347
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4iIntersector4HybridMoeller));
348
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4vIntersector4HybridPluecker));
349
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4iIntersector4HybridPluecker));
350

351
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2(features,BVH8Quad4iMBIntersector4HybridMoeller));
352
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2(features,BVH8Quad4iMBIntersector4HybridPluecker));
353

354
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8VirtualIntersector4Chunk));
355
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8VirtualMBIntersector4Chunk));
356

357
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceIntersector4Chunk));
358
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceMBIntersector4Chunk));
359

360
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceArrayIntersector4Chunk));
361
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceArrayMBIntersector4Chunk));
362

363
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8GridIntersector4HybridMoeller));
364
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8GridIntersector4HybridPluecker));
365

366
    /* select intersectors8 */
367
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersector8Hybrid));
368
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersector8HybridMB));
369
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersectorRobust8Hybrid));
370
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8OBBVirtualCurveIntersectorRobust8HybridMB));
371

372
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4Intersector8HybridMoeller));
373
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4Intersector8HybridMoellerNoFilter));
374
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iIntersector8HybridMoeller));
375
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vIntersector8HybridPluecker));
376
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iIntersector8HybridPluecker));
377

378
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vMBIntersector8HybridMoeller));
379
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iMBIntersector8HybridMoeller));
380
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4vMBIntersector8HybridPluecker));
381
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Triangle4iMBIntersector8HybridPluecker));
382

383
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4vIntersector8HybridMoeller));
384
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4vIntersector8HybridMoellerNoFilter));
385
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4iIntersector8HybridMoeller));
386
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4vIntersector8HybridPluecker));
387
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8Quad4iIntersector8HybridPluecker));
388

389
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2(features,BVH8Quad4iMBIntersector8HybridMoeller));
390
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2(features,BVH8Quad4iMBIntersector8HybridPluecker));
391

392
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8VirtualIntersector8Chunk));
393
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8VirtualMBIntersector8Chunk));
394

395
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceIntersector8Chunk));
396
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceMBIntersector8Chunk));
397

398
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceArrayIntersector8Chunk));
399
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8InstanceArrayMBIntersector8Chunk));
400

401
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8GridIntersector8HybridMoeller));
402
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH8GridIntersector8HybridPluecker));
403

404
    /* select intersectors16 */
405
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH8OBBVirtualCurveIntersector16Hybrid));
406
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH8OBBVirtualCurveIntersector16HybridMB));
407
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH8OBBVirtualCurveIntersectorRobust16Hybrid));
408
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH8OBBVirtualCurveIntersectorRobust16HybridMB));
409

410
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4Intersector16HybridMoeller));
411
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4Intersector16HybridMoellerNoFilter));
412
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4iIntersector16HybridMoeller));
413
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4vIntersector16HybridPluecker));
414
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4iIntersector16HybridPluecker));
415

416
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4vMBIntersector16HybridMoeller));
417
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4iMBIntersector16HybridMoeller));
418
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4vMBIntersector16HybridPluecker));
419
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Triangle4iMBIntersector16HybridPluecker));
420

421
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Quad4vIntersector16HybridMoeller));
422
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Quad4vIntersector16HybridMoellerNoFilter));
423
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Quad4iIntersector16HybridMoeller));
424
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Quad4vIntersector16HybridPluecker));
425
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Quad4iIntersector16HybridPluecker));
426

427
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Quad4iMBIntersector16HybridMoeller));
428
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH8Quad4iMBIntersector16HybridPluecker));
429

430
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX512(features,BVH8VirtualIntersector16Chunk));
431
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX512(features,BVH8VirtualMBIntersector16Chunk));
432

433
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX512(features,BVH8InstanceIntersector16Chunk));
434
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX512(features,BVH8InstanceMBIntersector16Chunk));
435

436
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX512(features,BVH8InstanceArrayIntersector16Chunk));
437
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX512(features,BVH8InstanceArrayMBIntersector16Chunk));
438

439
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX512(features,BVH8GridIntersector16HybridMoeller));
440
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX512(features,BVH8GridIntersector16HybridPluecker));
441

442
#endif
443
  }
444

445
  Accel::Intersectors BVH8Factory::BVH8OBBVirtualCurveIntersectors(BVH8* bvh, VirtualCurveIntersector* leafIntersector, IntersectVariant ivariant)
446
  {
447
    switch (ivariant) {
448
    case IntersectVariant::FAST:
449
    {
450
      Accel::Intersectors intersectors;
451
      intersectors.ptr = bvh;
452
      intersectors.leafIntersector = leafIntersector;
453
      intersectors.intersector1  = BVH8OBBVirtualCurveIntersector1();
454
#if defined (EMBREE_RAY_PACKETS)
455
      intersectors.intersector4  = BVH8OBBVirtualCurveIntersector4Hybrid();
456
      intersectors.intersector8  = BVH8OBBVirtualCurveIntersector8Hybrid();
457
      intersectors.intersector16 = BVH8OBBVirtualCurveIntersector16Hybrid();
458
#endif
459
      return intersectors;
460
    }
461
    case IntersectVariant::ROBUST:
462
    {
463
      Accel::Intersectors intersectors;
464
      intersectors.ptr = bvh;
465
      intersectors.leafIntersector = leafIntersector;
466
      intersectors.intersector1  = BVH8OBBVirtualCurveIntersectorRobust1();
467
#if defined (EMBREE_RAY_PACKETS)
468
      intersectors.intersector4  = BVH8OBBVirtualCurveIntersectorRobust4Hybrid();
469
      intersectors.intersector8  = BVH8OBBVirtualCurveIntersectorRobust8Hybrid();
470
      intersectors.intersector16 = BVH8OBBVirtualCurveIntersectorRobust16Hybrid();
471
#endif
472
      return intersectors;
473
    }
474
    default: assert(false);
475
    }
476
    return Accel::Intersectors();
477
  }
478

479
  Accel::Intersectors BVH8Factory::BVH8OBBVirtualCurveIntersectorsMB(BVH8* bvh, VirtualCurveIntersector* leafIntersector, IntersectVariant ivariant)
480
  {
481
    switch (ivariant) {
482
    case IntersectVariant::FAST:
483
    {
484
      Accel::Intersectors intersectors;
485
      intersectors.ptr = bvh;
486
      intersectors.leafIntersector = leafIntersector;
487
      intersectors.intersector1  = BVH8OBBVirtualCurveIntersector1MB();
488
#if defined (EMBREE_RAY_PACKETS)
489
      intersectors.intersector4  = BVH8OBBVirtualCurveIntersector4HybridMB();
490
      intersectors.intersector8  = BVH8OBBVirtualCurveIntersector8HybridMB();
491
      intersectors.intersector16 = BVH8OBBVirtualCurveIntersector16HybridMB();
492
#endif
493
      return intersectors;
494
    }
495
    case IntersectVariant::ROBUST:
496
    {
497
      Accel::Intersectors intersectors;
498
      intersectors.ptr = bvh;
499
      intersectors.leafIntersector = leafIntersector;
500
      intersectors.intersector1  = BVH8OBBVirtualCurveIntersectorRobust1MB();
501
#if defined (EMBREE_RAY_PACKETS)
502
      intersectors.intersector4  = BVH8OBBVirtualCurveIntersectorRobust4HybridMB();
503
      intersectors.intersector8  = BVH8OBBVirtualCurveIntersectorRobust8HybridMB();
504
      intersectors.intersector16 = BVH8OBBVirtualCurveIntersectorRobust16HybridMB();
505
#endif
506
      return intersectors;
507
    }
508
    default: assert(false);
509
    }
510
    return Accel::Intersectors();
511
  }
512

513
  Accel::Intersectors BVH8Factory::BVH8Triangle4Intersectors(BVH8* bvh, IntersectVariant ivariant)
514
  {
515
    assert(ivariant == IntersectVariant::FAST);
516
    Accel::Intersectors intersectors;
517
    intersectors.ptr = bvh;
518
    intersectors.intersector1           = BVH8Triangle4Intersector1Moeller();
519
#if defined (EMBREE_RAY_PACKETS)
520
    intersectors.intersector4_filter    = BVH8Triangle4Intersector4HybridMoeller();
521
    intersectors.intersector4_nofilter  = BVH8Triangle4Intersector4HybridMoellerNoFilter();
522
    intersectors.intersector8_filter    = BVH8Triangle4Intersector8HybridMoeller();
523
    intersectors.intersector8_nofilter  = BVH8Triangle4Intersector8HybridMoellerNoFilter();
524
    intersectors.intersector16_filter   = BVH8Triangle4Intersector16HybridMoeller();
525
    intersectors.intersector16_nofilter = BVH8Triangle4Intersector16HybridMoellerNoFilter();
526
#endif
527
    return intersectors;
528
  }
529

530
  Accel::Intersectors BVH8Factory::BVH8Triangle4vIntersectors(BVH8* bvh, IntersectVariant ivariant)
531
  {
532
    Accel::Intersectors intersectors;
533
    intersectors.ptr = bvh;
534
#define ENABLE_WOOP_TEST 0
535
#if ENABLE_WOOP_TEST == 0
536
    //assert(ivariant == IntersectVariant::ROBUST);
537
    intersectors.intersector1    = BVH8Triangle4vIntersector1Pluecker();
538
#else
539
    intersectors.intersector1    = BVH8Triangle4vIntersector1Woop();
540
#endif
541

542
#if defined (EMBREE_RAY_PACKETS)
543
    intersectors.intersector4    = BVH8Triangle4vIntersector4HybridPluecker();
544
    intersectors.intersector8    = BVH8Triangle4vIntersector8HybridPluecker();
545
    intersectors.intersector16   = BVH8Triangle4vIntersector16HybridPluecker();
546
#endif
547
    return intersectors;
548
  }
549

550
  Accel::Intersectors BVH8Factory::BVH8Triangle4iIntersectors(BVH8* bvh, IntersectVariant ivariant)
551
  {
552
    switch (ivariant) {
553
    case IntersectVariant::FAST:
554
    {
555
      Accel::Intersectors intersectors;
556
      intersectors.ptr = bvh;
557
      intersectors.intersector1  = BVH8Triangle4iIntersector1Moeller();
558
#if defined (EMBREE_RAY_PACKETS)
559
      intersectors.intersector4  = BVH8Triangle4iIntersector4HybridMoeller();
560
      intersectors.intersector8  = BVH8Triangle4iIntersector8HybridMoeller();
561
      intersectors.intersector16 = BVH8Triangle4iIntersector16HybridMoeller();
562
#endif
563
      return intersectors;
564
    }
565
    case IntersectVariant::ROBUST:
566
    {
567
      Accel::Intersectors intersectors;
568
      intersectors.ptr = bvh;
569
      intersectors.intersector1  = BVH8Triangle4iIntersector1Pluecker();
570
#if defined (EMBREE_RAY_PACKETS)
571
      intersectors.intersector4  = BVH8Triangle4iIntersector4HybridPluecker();
572
      intersectors.intersector8  = BVH8Triangle4iIntersector8HybridPluecker();
573
      intersectors.intersector16 = BVH8Triangle4iIntersector16HybridPluecker();
574
#endif
575
      return intersectors;
576
    }
577
    }
578
    return Accel::Intersectors();
579
  }
580

581
  Accel::Intersectors BVH8Factory::BVH8Triangle4vMBIntersectors(BVH8* bvh, IntersectVariant ivariant)
582
  {
583
    switch (ivariant) {
584
    case IntersectVariant::FAST:
585
    {
586
      Accel::Intersectors intersectors;
587
      intersectors.ptr = bvh;
588
      intersectors.intersector1  = BVH8Triangle4vMBIntersector1Moeller();
589
#if defined (EMBREE_RAY_PACKETS)
590
      intersectors.intersector4  = BVH8Triangle4vMBIntersector4HybridMoeller();
591
      intersectors.intersector8  = BVH8Triangle4vMBIntersector8HybridMoeller();
592
      intersectors.intersector16 = BVH8Triangle4vMBIntersector16HybridMoeller();
593
#endif
594
      return intersectors;
595
    }
596
    case IntersectVariant::ROBUST:
597
    {
598
      Accel::Intersectors intersectors;
599
      intersectors.ptr = bvh;
600
      intersectors.intersector1  = BVH8Triangle4vMBIntersector1Pluecker();
601
#if defined (EMBREE_RAY_PACKETS)
602
      intersectors.intersector4  = BVH8Triangle4vMBIntersector4HybridPluecker();
603
      intersectors.intersector8  = BVH8Triangle4vMBIntersector8HybridPluecker();
604
      intersectors.intersector16 = BVH8Triangle4vMBIntersector16HybridPluecker();
605
#endif
606
      return intersectors;
607
    }
608
    }
609
    return Accel::Intersectors();
610
  }
611

612
  Accel::Intersectors BVH8Factory::BVH8Triangle4iMBIntersectors(BVH8* bvh, IntersectVariant ivariant)
613
  {
614
    switch (ivariant) {
615
    case IntersectVariant::FAST:
616
    {
617
      Accel::Intersectors intersectors;
618
      intersectors.ptr = bvh;
619
      intersectors.intersector1  = BVH8Triangle4iMBIntersector1Moeller();
620
#if defined (EMBREE_RAY_PACKETS)
621
      intersectors.intersector4  = BVH8Triangle4iMBIntersector4HybridMoeller();
622
      intersectors.intersector8  = BVH8Triangle4iMBIntersector8HybridMoeller();
623
      intersectors.intersector16 = BVH8Triangle4iMBIntersector16HybridMoeller();
624
#endif
625
      return intersectors;
626
    }
627
    case IntersectVariant::ROBUST:
628
    {
629
      Accel::Intersectors intersectors;
630
      intersectors.ptr = bvh;
631
      intersectors.intersector1  = BVH8Triangle4iMBIntersector1Pluecker();
632
#if defined (EMBREE_RAY_PACKETS)
633
      intersectors.intersector4  = BVH8Triangle4iMBIntersector4HybridPluecker();
634
      intersectors.intersector8  = BVH8Triangle4iMBIntersector8HybridPluecker();
635
      intersectors.intersector16 = BVH8Triangle4iMBIntersector16HybridPluecker();
636
#endif
637
      return intersectors;
638
    }
639
    }
640
    return Accel::Intersectors();
641
  }
642

643
  Accel::Intersectors BVH8Factory::BVH8Quad4vIntersectors(BVH8* bvh, IntersectVariant ivariant)
644
  {
645
    switch (ivariant) {
646
    case IntersectVariant::FAST:
647
    {
648
      Accel::Intersectors intersectors;
649
      intersectors.ptr = bvh;
650
      intersectors.intersector1           = BVH8Quad4vIntersector1Moeller();
651
#if defined (EMBREE_RAY_PACKETS)
652
      intersectors.intersector4_filter    = BVH8Quad4vIntersector4HybridMoeller();
653
      intersectors.intersector4_nofilter  = BVH8Quad4vIntersector4HybridMoellerNoFilter();
654
      intersectors.intersector8_filter    = BVH8Quad4vIntersector8HybridMoeller();
655
      intersectors.intersector8_nofilter  = BVH8Quad4vIntersector8HybridMoellerNoFilter();
656
      intersectors.intersector16_filter   = BVH8Quad4vIntersector16HybridMoeller();
657
      intersectors.intersector16_nofilter = BVH8Quad4vIntersector16HybridMoellerNoFilter();
658
#endif
659
      return intersectors;
660
    }
661
    case IntersectVariant::ROBUST:
662
    {
663
      Accel::Intersectors intersectors;
664
      intersectors.ptr = bvh;
665
      intersectors.intersector1  = BVH8Quad4vIntersector1Pluecker();
666
#if defined (EMBREE_RAY_PACKETS)
667
      intersectors.intersector4  = BVH8Quad4vIntersector4HybridPluecker();
668
      intersectors.intersector8  = BVH8Quad4vIntersector8HybridPluecker();
669
      intersectors.intersector16 = BVH8Quad4vIntersector16HybridPluecker();
670
#endif
671
      return intersectors;
672
    }
673
    }
674
    return Accel::Intersectors();
675
  }
676

677
  Accel::Intersectors BVH8Factory::BVH8Quad4iIntersectors(BVH8* bvh, IntersectVariant ivariant)
678
  {
679
    switch (ivariant) {
680
    case IntersectVariant::FAST:
681
    {
682
      Accel::Intersectors intersectors;
683
      intersectors.ptr = bvh;
684
      intersectors.intersector1  = BVH8Quad4iIntersector1Moeller();
685
#if defined (EMBREE_RAY_PACKETS)
686
      intersectors.intersector4  = BVH8Quad4iIntersector4HybridMoeller();
687
      intersectors.intersector8  = BVH8Quad4iIntersector8HybridMoeller();
688
      intersectors.intersector16 = BVH8Quad4iIntersector16HybridMoeller();
689
#endif
690
      return intersectors;
691
    }
692
    case IntersectVariant::ROBUST:
693
    {
694
      Accel::Intersectors intersectors;
695
      intersectors.ptr = bvh;
696
      intersectors.intersector1  = BVH8Quad4iIntersector1Pluecker();
697
#if defined (EMBREE_RAY_PACKETS)
698
      intersectors.intersector4  = BVH8Quad4iIntersector4HybridPluecker();
699
      intersectors.intersector8  = BVH8Quad4iIntersector8HybridPluecker();
700
      intersectors.intersector16 = BVH8Quad4iIntersector16HybridPluecker();
701
#endif
702
      return intersectors;
703
    }
704
    }
705
    return Accel::Intersectors();
706
  }
707

708
  Accel::Intersectors BVH8Factory::BVH8Quad4iMBIntersectors(BVH8* bvh, IntersectVariant ivariant)
709
  {
710
    switch (ivariant) {
711
    case IntersectVariant::FAST:
712
    {
713
      Accel::Intersectors intersectors;
714
      intersectors.ptr = bvh;
715
      intersectors.intersector1  = BVH8Quad4iMBIntersector1Moeller();
716
#if defined (EMBREE_RAY_PACKETS)
717
      intersectors.intersector4  = BVH8Quad4iMBIntersector4HybridMoeller();
718
      intersectors.intersector8  = BVH8Quad4iMBIntersector8HybridMoeller();
719
      intersectors.intersector16 = BVH8Quad4iMBIntersector16HybridMoeller();
720
#endif
721
      return intersectors;
722
    }
723
    case IntersectVariant::ROBUST:
724
    {
725
      Accel::Intersectors intersectors;
726
      intersectors.ptr = bvh;
727
      intersectors.intersector1  = BVH8Quad4iMBIntersector1Pluecker();
728
#if defined (EMBREE_RAY_PACKETS)
729
      intersectors.intersector4  = BVH8Quad4iMBIntersector4HybridPluecker();
730
      intersectors.intersector8  = BVH8Quad4iMBIntersector8HybridPluecker();
731
      intersectors.intersector16 = BVH8Quad4iMBIntersector16HybridPluecker();
732
#endif
733
      return intersectors;
734
    }
735
    }
736
    return Accel::Intersectors();
737
  }
738

739
  Accel::Intersectors BVH8Factory::QBVH8Triangle4iIntersectors(BVH8* bvh)
740
  {
741
    Accel::Intersectors intersectors;
742
    intersectors.ptr = bvh;
743
    intersectors.intersector1 = QBVH8Triangle4iIntersector1Pluecker();
744
    return intersectors;
745
  }
746

747
  Accel::Intersectors BVH8Factory::QBVH8Triangle4Intersectors(BVH8* bvh)
748
  {
749
    Accel::Intersectors intersectors;
750
    intersectors.ptr = bvh;
751
    intersectors.intersector1 = QBVH8Triangle4Intersector1Moeller();
752
    return intersectors;
753
  }
754

755
  Accel::Intersectors BVH8Factory::QBVH8Quad4iIntersectors(BVH8* bvh)
756
  {
757
    Accel::Intersectors intersectors;
758
    intersectors.ptr = bvh;
759
    intersectors.intersector1 = QBVH8Quad4iIntersector1Pluecker();
760
    return intersectors;
761
  }
762

763
  Accel::Intersectors BVH8Factory::BVH8UserGeometryIntersectors(BVH8* bvh)
764
  {
765
    Accel::Intersectors intersectors;
766
    intersectors.ptr = bvh;
767
    intersectors.intersector1  = BVH8VirtualIntersector1();
768
#if defined (EMBREE_RAY_PACKETS)
769
    intersectors.intersector4  = BVH8VirtualIntersector4Chunk();
770
    intersectors.intersector8  = BVH8VirtualIntersector8Chunk();
771
    intersectors.intersector16 = BVH8VirtualIntersector16Chunk();
772
#endif
773
    intersectors.collider      = BVH8ColliderUserGeom();
774
    return intersectors;
775
  }
776

777
  Accel::Intersectors BVH8Factory::BVH8UserGeometryMBIntersectors(BVH8* bvh)
778
  {
779
    Accel::Intersectors intersectors;
780
    intersectors.ptr = bvh;
781
    intersectors.intersector1  = BVH8VirtualMBIntersector1();
782
#if defined (EMBREE_RAY_PACKETS)
783
    intersectors.intersector4  = BVH8VirtualMBIntersector4Chunk();
784
    intersectors.intersector8  = BVH8VirtualMBIntersector8Chunk();
785
    intersectors.intersector16 = BVH8VirtualMBIntersector16Chunk();
786
#endif
787
    return intersectors;
788
  }
789

790
  Accel::Intersectors BVH8Factory::BVH8InstanceIntersectors(BVH8* bvh)
791
  {
792
    Accel::Intersectors intersectors;
793
    intersectors.ptr = bvh;
794
    intersectors.intersector1  = BVH8InstanceIntersector1();
795
#if defined (EMBREE_RAY_PACKETS)
796
    intersectors.intersector4  = BVH8InstanceIntersector4Chunk();
797
    intersectors.intersector8  = BVH8InstanceIntersector8Chunk();
798
    intersectors.intersector16 = BVH8InstanceIntersector16Chunk();
799
#endif
800
    return intersectors;
801
  }
802

803
  Accel::Intersectors BVH8Factory::BVH8InstanceArrayIntersectors(BVH8* bvh)
804
  {
805
    Accel::Intersectors intersectors;
806
    intersectors.ptr = bvh;
807
    intersectors.intersector1  = BVH8InstanceArrayIntersector1();
808
#if defined (EMBREE_RAY_PACKETS)
809
    intersectors.intersector4  = BVH8InstanceArrayIntersector4Chunk();
810
    intersectors.intersector8  = BVH8InstanceArrayIntersector8Chunk();
811
    intersectors.intersector16 = BVH8InstanceArrayIntersector16Chunk();
812
#endif
813
    return intersectors;
814
  }
815

816
  Accel::Intersectors BVH8Factory::BVH8InstanceMBIntersectors(BVH8* bvh)
817
  {
818
    Accel::Intersectors intersectors;
819
    intersectors.ptr = bvh;
820
    intersectors.intersector1  = BVH8InstanceMBIntersector1();
821
#if defined (EMBREE_RAY_PACKETS)
822
    intersectors.intersector4  = BVH8InstanceMBIntersector4Chunk();
823
    intersectors.intersector8  = BVH8InstanceMBIntersector8Chunk();
824
    intersectors.intersector16 = BVH8InstanceMBIntersector16Chunk();
825
#endif
826
    return intersectors;
827
  }
828

829
  Accel::Intersectors BVH8Factory::BVH8InstanceArrayMBIntersectors(BVH8* bvh)
830
  {
831
    Accel::Intersectors intersectors;
832
    intersectors.ptr = bvh;
833
    intersectors.intersector1  = BVH8InstanceArrayMBIntersector1();
834
#if defined (EMBREE_RAY_PACKETS)
835
    intersectors.intersector4  = BVH8InstanceArrayMBIntersector4Chunk();
836
    intersectors.intersector8  = BVH8InstanceArrayMBIntersector8Chunk();
837
    intersectors.intersector16 = BVH8InstanceArrayMBIntersector16Chunk();
838
#endif
839
    return intersectors;
840
  }
841

842
  Accel* BVH8Factory::BVH8OBBVirtualCurve8v(Scene* scene, IntersectVariant ivariant)
843
  {
844
    BVH8* accel = new BVH8(Curve8v::type,scene);
845
    Accel::Intersectors intersectors = BVH8OBBVirtualCurveIntersectors(accel,VirtualCurveIntersector8v(),ivariant);
846
    Builder* builder = BVH8Curve8vBuilder_OBB_New(accel,scene,0);
847
    return new AccelInstance(accel,builder,intersectors);
848
  }
849

850
  Accel* BVH8Factory::BVH8OBBVirtualCurve8iMB(Scene* scene, IntersectVariant ivariant)
851
  {
852
    BVH8* accel = new BVH8(Curve8iMB::type,scene);
853
    Accel::Intersectors intersectors = BVH8OBBVirtualCurveIntersectorsMB(accel,VirtualCurveIntersector8iMB(),ivariant);
854
    Builder* builder = BVH8OBBCurve8iMBBuilder_OBB(accel,scene,0);
855
    return new AccelInstance(accel,builder,intersectors);
856
  }
857

858
  Accel* BVH8Factory::BVH8Triangle4(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
859
  {
860
    BVH8* accel = new BVH8(Triangle4::type,scene);
861
    Accel::Intersectors intersectors= BVH8Triangle4Intersectors(accel,ivariant);
862
    Builder* builder = nullptr;
863
    if (scene->device->tri_builder == "default")  {
864
      switch (bvariant) {
865
      case BuildVariant::STATIC      : builder = BVH8Triangle4SceneBuilderSAH(accel,scene,0); break;
866
      case BuildVariant::DYNAMIC     : builder = BVH8BuilderTwoLevelTriangle4MeshSAH(accel,scene,false); break;
867
      case BuildVariant::HIGH_QUALITY: builder = BVH8Triangle4SceneBuilderFastSpatialSAH(accel,scene,0); break;
868
      }
869
    }
870
    else if (scene->device->tri_builder == "sah"         )  builder = BVH8Triangle4SceneBuilderSAH(accel,scene,0);
871
    else if (scene->device->tri_builder == "sah_fast_spatial")  builder = BVH8Triangle4SceneBuilderFastSpatialSAH(accel,scene,0);
872
    else if (scene->device->tri_builder == "sah_presplit")     builder = BVH8Triangle4SceneBuilderSAH(accel,scene,MODE_HIGH_QUALITY);
873
    else if (scene->device->tri_builder == "dynamic"     ) builder = BVH8BuilderTwoLevelTriangle4MeshSAH(accel,scene,false);
874
    else if (scene->device->tri_builder == "morton"     ) builder = BVH8BuilderTwoLevelTriangle4MeshSAH(accel,scene,true);
875
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH8<Triangle4>");
876

877
    return new AccelInstance(accel,builder,intersectors);
878
  }
879

880
  Accel* BVH8Factory::BVH8Triangle4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
881
  {
882
    BVH8* accel = new BVH8(Triangle4v::type,scene);
883
    Accel::Intersectors intersectors= BVH8Triangle4vIntersectors(accel,ivariant);
884
    Builder* builder = nullptr;
885
    if (scene->device->tri_builder == "default")  {
886
      switch (bvariant) {
887
      case BuildVariant::STATIC      : builder = BVH8Triangle4vSceneBuilderSAH(accel,scene,0); break;
888
      case BuildVariant::DYNAMIC     : builder = BVH8BuilderTwoLevelTriangle4vMeshSAH(accel,scene,false); break;
889
      case BuildVariant::HIGH_QUALITY: builder = BVH8Triangle4vSceneBuilderFastSpatialSAH(accel,scene,0); break;
890
      }
891
    }
892
    else if (scene->device->tri_builder == "sah_fast_spatial")  builder = BVH8Triangle4SceneBuilderFastSpatialSAH(accel,scene,0);
893
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH8<Triangle4v>");
894
    return new AccelInstance(accel,builder,intersectors);
895
  }
896

897
  Accel* BVH8Factory::BVH8Triangle4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
898
  {
899
    BVH8* accel = new BVH8(Triangle4i::type,scene);
900
    Accel::Intersectors intersectors = BVH8Triangle4iIntersectors(accel,ivariant);
901

902
    Builder* builder = nullptr;
903
    if (scene->device->tri_builder == "default") {
904
      switch (bvariant) {
905
      case BuildVariant::STATIC      : builder = BVH8Triangle4iSceneBuilderSAH(accel,scene,0); break;
906
      case BuildVariant::DYNAMIC     : builder = BVH8BuilderTwoLevelTriangle4iMeshSAH(accel,scene,false); break;
907
      case BuildVariant::HIGH_QUALITY: assert(false); break; // FIXME: implement
908
      }
909
    }
910
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH8<Triangle4i>");
911

912
    return new AccelInstance(accel,builder,intersectors);
913
  }
914

915
  Accel* BVH8Factory::BVH8Triangle4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
916
  {
917
    BVH8* accel = new BVH8(Triangle4i::type,scene);
918
    Accel::Intersectors intersectors = BVH8Triangle4iMBIntersectors(accel,ivariant);
919

920
    Builder* builder = nullptr;
921
    if (scene->device->tri_builder_mb == "default") { // FIXME: implement
922
      switch (bvariant) {
923
      case BuildVariant::STATIC      : builder = BVH8Triangle4iMBSceneBuilderSAH(accel,scene,0); break;
924
      case BuildVariant::DYNAMIC     : assert(false); break; // FIXME: implement
925
      case BuildVariant::HIGH_QUALITY: assert(false); break;
926
      }
927
    }
928
    else if (scene->device->tri_builder_mb == "internal_time_splits")  builder = BVH8Triangle4iMBSceneBuilderSAH(accel,scene,0);
929
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder_mb+" for BVH8<Triangle4iMB>");
930

931
    return new AccelInstance(accel,builder,intersectors);
932
  }
933

934
  Accel* BVH8Factory::BVH8Triangle4vMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
935
  {
936
    BVH8* accel = new BVH8(Triangle4vMB::type,scene);
937
    Accel::Intersectors intersectors= BVH8Triangle4vMBIntersectors(accel,ivariant);
938

939
    Builder* builder = nullptr;
940
    if (scene->device->tri_builder_mb == "default") {
941
      switch (bvariant) {
942
      case BuildVariant::STATIC      : builder = BVH8Triangle4vMBSceneBuilderSAH(accel,scene,0); break;
943
      case BuildVariant::DYNAMIC     : assert(false); break; // FIXME: implement
944
      case BuildVariant::HIGH_QUALITY: assert(false); break;
945
      }
946
    }
947
    else if (scene->device->tri_builder_mb == "internal_time_splits")  builder = BVH8Triangle4vMBSceneBuilderSAH(accel,scene,0);
948
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder_mb+" for BVH8<Triangle4vMB>");
949

950
    return new AccelInstance(accel,builder,intersectors);
951
  }
952

953
  Accel* BVH8Factory::BVH8QuantizedTriangle4i(Scene* scene)
954
  {
955
    BVH8* accel = new BVH8(Triangle4i::type,scene);
956
    Accel::Intersectors intersectors = QBVH8Triangle4iIntersectors(accel);
957
    Builder* builder = BVH8QuantizedTriangle4iSceneBuilderSAH(accel,scene,0);
958
    return new AccelInstance(accel,builder,intersectors);
959
  }
960

961
  Accel* BVH8Factory::BVH8QuantizedTriangle4(Scene* scene)
962
  {
963
    BVH8* accel = new BVH8(Triangle4::type,scene);
964
    Accel::Intersectors intersectors = QBVH8Triangle4Intersectors(accel);
965
    Builder* builder = BVH8QuantizedTriangle4SceneBuilderSAH(accel,scene,0);
966
    return new AccelInstance(accel,builder,intersectors);
967
  }
968

969
  Accel* BVH8Factory::BVH8Quad4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
970
  {
971
    BVH8* accel = new BVH8(Quad4v::type,scene);
972
    Accel::Intersectors intersectors = BVH8Quad4vIntersectors(accel,ivariant);
973

974
    Builder* builder = nullptr;
975
    if (scene->device->quad_builder == "default") {
976
      switch (bvariant) {
977
      case BuildVariant::STATIC      : builder = BVH8Quad4vSceneBuilderSAH(accel,scene,0); break;
978
      case BuildVariant::DYNAMIC     : builder = BVH8BuilderTwoLevelQuadMeshSAH(accel,scene,false); break;
979
      case BuildVariant::HIGH_QUALITY: builder = BVH8Quad4vSceneBuilderFastSpatialSAH(accel,scene,0); break;
980
      }
981
    }
982
    else if (scene->device->quad_builder == "dynamic"      ) builder = BVH8BuilderTwoLevelQuadMeshSAH(accel,scene,false);
983
    else if (scene->device->quad_builder == "morton"       ) builder = BVH8BuilderTwoLevelQuadMeshSAH(accel,scene,true);
984
    else if (scene->device->quad_builder == "sah_fast_spatial" ) builder = BVH8Quad4vSceneBuilderFastSpatialSAH(accel,scene,0);
985
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder+" for BVH8<Quad4v>");
986

987
    return new AccelInstance(accel,builder,intersectors);
988
  }
989

990
  Accel* BVH8Factory::BVH8Quad4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
991
  {
992
    BVH8* accel = new BVH8(Quad4i::type,scene);
993
    Accel::Intersectors intersectors = BVH8Quad4iIntersectors(accel,ivariant);
994

995
    Builder* builder = nullptr;
996
    if (scene->device->quad_builder == "default") {
997
      switch (bvariant) {
998
      case BuildVariant::STATIC      : builder = BVH8Quad4iSceneBuilderSAH(accel,scene,0); break;
999
      case BuildVariant::DYNAMIC     : assert(false); break; // FIXME: implement
1000
      case BuildVariant::HIGH_QUALITY: assert(false); break; // FIXME: implement
1001
      }
1002
    }
1003
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder+" for BVH8<Quad4i>");
1004

1005
    return new AccelInstance(accel,builder,intersectors);
1006
  }
1007

1008
  Accel* BVH8Factory::BVH8Quad4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1009
  {
1010
    BVH8* accel = new BVH8(Quad4i::type,scene);
1011
    Accel::Intersectors intersectors = BVH8Quad4iMBIntersectors(accel,ivariant);
1012

1013
    Builder* builder = nullptr;
1014
    if (scene->device->quad_builder_mb == "default") {
1015
      switch (bvariant) {
1016
      case BuildVariant::STATIC      : builder = BVH8Quad4iMBSceneBuilderSAH(accel,scene,0); break;
1017
      case BuildVariant::DYNAMIC     : assert(false); break; // FIXME: implement
1018
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1019
      }
1020
    }
1021
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder_mb+" for BVH8<Quad4i>");
1022

1023
    return new AccelInstance(accel,builder,intersectors);
1024
  }
1025

1026
  Accel* BVH8Factory::BVH8QuantizedQuad4i(Scene* scene)
1027
  {
1028
    BVH8* accel = new BVH8(Quad4i::type,scene);
1029
    Accel::Intersectors intersectors = QBVH8Quad4iIntersectors(accel);
1030
    Builder* builder = nullptr;
1031
    if      (scene->device->quad_builder == "default"     ) builder = BVH8QuantizedQuad4iSceneBuilderSAH(accel,scene,0);
1032
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder+" for QBVH8<Quad4i>");
1033
    return new AccelInstance(accel,builder,intersectors);
1034
  }
1035

1036
  Accel* BVH8Factory::BVH8UserGeometry(Scene* scene, BuildVariant bvariant)
1037
  {
1038
    BVH8* accel = new BVH8(Object::type,scene);
1039
    Accel::Intersectors intersectors = BVH8UserGeometryIntersectors(accel);
1040

1041
    Builder* builder = nullptr;
1042
    if (scene->device->object_builder == "default") {
1043
      switch (bvariant) {
1044
      case BuildVariant::STATIC      : builder = BVH8VirtualSceneBuilderSAH(accel,scene,0); break;
1045
      case BuildVariant::DYNAMIC     : builder = BVH8BuilderTwoLevelVirtualSAH(accel,scene,false); break;
1046
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1047
      }
1048
    }
1049
    else if (scene->device->object_builder == "sah") builder = BVH8VirtualSceneBuilderSAH(accel,scene,0);
1050
    else if (scene->device->object_builder == "dynamic") builder = BVH8BuilderTwoLevelVirtualSAH(accel,scene,false);
1051
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH8<Object>");
1052

1053
    return new AccelInstance(accel,builder,intersectors);
1054
  }
1055

1056
  Accel* BVH8Factory::BVH8UserGeometryMB(Scene* scene)
1057
  {
1058
    BVH8* accel = new BVH8(Object::type,scene);
1059
    Accel::Intersectors intersectors = BVH8UserGeometryMBIntersectors(accel);
1060
    Builder* builder = BVH8VirtualMBSceneBuilderSAH(accel,scene,0);
1061
    return new AccelInstance(accel,builder,intersectors);
1062
  }
1063

1064
  Accel* BVH8Factory::BVH8Instance(Scene* scene, bool isExpensive, BuildVariant bvariant)
1065
  {
1066
    BVH8* accel = new BVH8(InstancePrimitive::type,scene);
1067
    Accel::Intersectors intersectors = BVH8InstanceIntersectors(accel);
1068
    auto gtype = isExpensive ? Geometry::MTY_INSTANCE_EXPENSIVE : Geometry::MTY_INSTANCE; 
1069
    // Builder* builder = BVH8InstanceSceneBuilderSAH(accel,scene,gtype);
1070

1071
    Builder* builder = nullptr;
1072
    if (scene->device->object_builder == "default") {
1073
      switch (bvariant) {
1074
      case BuildVariant::STATIC      : builder = BVH8InstanceSceneBuilderSAH(accel,scene,gtype);; break;
1075
      case BuildVariant::DYNAMIC     : builder = BVH8BuilderTwoLevelInstanceSAH(accel,scene,gtype,false); break;
1076
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1077
      }
1078
    }
1079
    else if (scene->device->object_builder == "sah") builder = BVH8InstanceSceneBuilderSAH(accel,scene,gtype);
1080
    else if (scene->device->object_builder == "dynamic") builder = BVH8BuilderTwoLevelInstanceSAH(accel,scene,gtype,false);
1081
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH8<Object>");
1082

1083
    return new AccelInstance(accel,builder,intersectors);
1084
  }
1085

1086
  Accel* BVH8Factory::BVH8InstanceArray(Scene* scene, BuildVariant bvariant)
1087
  {
1088
    BVH8* accel = new BVH8(InstanceArrayPrimitive::type,scene);
1089
    Accel::Intersectors intersectors = BVH8InstanceArrayIntersectors(accel);
1090
    auto gtype = Geometry::MTY_INSTANCE_ARRAY;
1091
    // Builder* builder = BVH8InstanceSceneBuilderSAH(accel,scene,gtype);
1092

1093
    Builder* builder = nullptr;
1094
    if (scene->device->object_builder == "default") {
1095
      switch (bvariant) {
1096
      case BuildVariant::STATIC      : builder = BVH8InstanceArraySceneBuilderSAH(accel,scene,gtype); break;
1097
      case BuildVariant::DYNAMIC     : builder = BVH8BuilderTwoLevelInstanceArraySAH(accel,scene,gtype,false); break;
1098
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1099
      }
1100
    }
1101
    else if (scene->device->object_builder == "sah") builder = BVH8InstanceArraySceneBuilderSAH(accel,scene,gtype);
1102
    else if (scene->device->object_builder == "dynamic") builder = BVH8BuilderTwoLevelInstanceArraySAH(accel,scene,gtype,false);
1103
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH8<Object>");
1104

1105
    return new AccelInstance(accel,builder,intersectors);
1106
  }
1107

1108
  Accel* BVH8Factory::BVH8InstanceMB(Scene* scene, bool isExpensive)
1109
  {
1110
    BVH8* accel = new BVH8(InstancePrimitive::type,scene);
1111
    Accel::Intersectors intersectors = BVH8InstanceMBIntersectors(accel);
1112
    auto gtype = isExpensive ? Geometry::MTY_INSTANCE_EXPENSIVE : Geometry::MTY_INSTANCE; 
1113
    Builder* builder = BVH8InstanceMBSceneBuilderSAH(accel,scene,gtype);
1114
    return new AccelInstance(accel,builder,intersectors);
1115
  }
1116

1117
  Accel* BVH8Factory::BVH8InstanceArrayMB(Scene* scene)
1118
  {
1119
    BVH8* accel = new BVH8(InstanceArrayPrimitive::type,scene);
1120
    Accel::Intersectors intersectors = BVH8InstanceArrayMBIntersectors(accel);
1121
    auto gtype = Geometry::MTY_INSTANCE_ARRAY;
1122
    Builder* builder = BVH8InstanceArrayMBSceneBuilderSAH(accel,scene,gtype);
1123
    return new AccelInstance(accel,builder,intersectors);
1124
  }
1125

1126
  Accel::Intersectors BVH8Factory::BVH8GridIntersectors(BVH8* bvh, IntersectVariant ivariant)
1127
  {
1128
    Accel::Intersectors intersectors;
1129
    intersectors.ptr = bvh;
1130
    if (ivariant == IntersectVariant::FAST)
1131
    {
1132
      intersectors.intersector1  = BVH8GridIntersector1Moeller();
1133
#if defined (EMBREE_RAY_PACKETS)
1134
      intersectors.intersector4  = BVH8GridIntersector4HybridMoeller();
1135
      intersectors.intersector8  = BVH8GridIntersector8HybridMoeller();
1136
      intersectors.intersector16 = BVH8GridIntersector16HybridMoeller();
1137
#endif
1138
    }
1139
    else /* if (ivariant == IntersectVariant::ROBUST) */
1140
    {
1141
      intersectors.intersector1  = BVH8GridIntersector1Pluecker();
1142
#if defined (EMBREE_RAY_PACKETS)
1143
      intersectors.intersector4  = BVH8GridIntersector4HybridPluecker();
1144
      intersectors.intersector8  = BVH8GridIntersector8HybridPluecker();
1145
      intersectors.intersector16 = BVH8GridIntersector16HybridPluecker();
1146
#endif            
1147
    }
1148
    return intersectors;
1149
  }
1150

1151
  Accel::Intersectors BVH8Factory::BVH8GridMBIntersectors(BVH8* bvh, IntersectVariant ivariant)
1152
  {
1153
    Accel::Intersectors intersectors;
1154
    intersectors.ptr = bvh;
1155
    intersectors.intersector1  = BVH8GridMBIntersector1Moeller();
1156
#if defined (EMBREE_RAY_PACKETS)
1157
    intersectors.intersector4  = nullptr;
1158
    intersectors.intersector8  = nullptr;
1159
    intersectors.intersector16 = nullptr;
1160
#endif
1161
    return intersectors;
1162
  }
1163

1164
  Accel* BVH8Factory::BVH8Grid(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1165
  {
1166
    BVH8* accel = new BVH8(SubGridQBVH8::type,scene);
1167
    Accel::Intersectors intersectors = BVH8GridIntersectors(accel,ivariant);
1168
    Builder* builder = nullptr;
1169
    if (scene->device->grid_builder == "default") {
1170
      builder = BVH8GridSceneBuilderSAH(accel,scene,0);
1171
    }
1172
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH4<GridMesh>");
1173

1174
    return new AccelInstance(accel,builder,intersectors);    
1175
  }
1176

1177
  Accel* BVH8Factory::BVH8GridMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1178
  {
1179
    BVH8* accel = new BVH8(SubGridQBVH8::type,scene);
1180
    Accel::Intersectors intersectors = BVH8GridMBIntersectors(accel,ivariant);
1181
    Builder* builder = nullptr;
1182
    if (scene->device->grid_builder_mb == "default") {
1183
      builder = BVH8GridMBSceneBuilderSAH(accel,scene,0);
1184
    }
1185
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH8MB<GridMesh>");
1186
    return new AccelInstance(accel,builder,intersectors);        
1187
  }
1188
}
1189

1190
#endif
1191

1192
Product

Resources

Company
