CoCalc -- bvh4_factory.cpp

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

4
#include "bvh4_factory.h"
5
#include "../bvh/bvh.h"
6

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

24
namespace embree
25
{
26
  DECLARE_SYMBOL2(Accel::Collider,BVH4ColliderUserGeom);
27

28
  DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector4i,void);
29
  DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector8i,void);
30
  DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector4v,void);
31
  DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector8v,void);
32
  DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector4iMB,void);
33
  DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector8iMB,void);
34
    
35
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4OBBVirtualCurveIntersector1);
36
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4OBBVirtualCurveIntersector1MB);
37
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4OBBVirtualCurveIntersectorRobust1);
38
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4OBBVirtualCurveIntersectorRobust1MB);
39

40
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4Intersector1Moeller);
41
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4iIntersector1Moeller);
42
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4vIntersector1Pluecker);
43
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4iIntersector1Pluecker);
44

45
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4vMBIntersector1Moeller);
46
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4iMBIntersector1Moeller);
47
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4vMBIntersector1Pluecker);
48
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4iMBIntersector1Pluecker);
49

50
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4vIntersector1Moeller);
51
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4iIntersector1Moeller);
52
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4vIntersector1Pluecker);
53
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4iIntersector1Pluecker);
54

55
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4iMBIntersector1Moeller);
56
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4iMBIntersector1Pluecker);
57

58
  DECLARE_SYMBOL2(Accel::Intersector1,QBVH4Triangle4iIntersector1Pluecker);
59
  DECLARE_SYMBOL2(Accel::Intersector1,QBVH4Quad4iIntersector1Pluecker);
60

61
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4SubdivPatch1Intersector1);
62
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4SubdivPatch1MBIntersector1);
63
  
64
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4VirtualIntersector1);
65
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4VirtualMBIntersector1);
66

67
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4InstanceIntersector1);
68
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4InstanceMBIntersector1);
69

70
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4InstanceArrayIntersector1);
71
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4InstanceArrayMBIntersector1);
72

73
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4GridIntersector1Moeller);
74
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4GridMBIntersector1Moeller);
75
  DECLARE_SYMBOL2(Accel::Intersector1,BVH4GridIntersector1Pluecker);
76

77
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4OBBVirtualCurveIntersector4Hybrid);
78
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4OBBVirtualCurveIntersector4HybridMB);
79
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4OBBVirtualCurveIntersectorRobust4Hybrid);
80
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4OBBVirtualCurveIntersectorRobust4HybridMB);
81

82
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4Intersector4HybridMoeller);
83
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4Intersector4HybridMoellerNoFilter);
84
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4iIntersector4HybridMoeller);
85
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4vIntersector4HybridPluecker);
86
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4iIntersector4HybridPluecker);
87

88
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4vMBIntersector4HybridMoeller);
89
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4iMBIntersector4HybridMoeller);
90
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4vMBIntersector4HybridPluecker);
91
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4iMBIntersector4HybridPluecker);
92

93
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4vIntersector4HybridMoeller);
94
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4vIntersector4HybridMoellerNoFilter);
95
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4iIntersector4HybridMoeller);
96
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4vIntersector4HybridPluecker);
97
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4iIntersector4HybridPluecker);
98

99
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4iMBIntersector4HybridMoeller);
100
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4iMBIntersector4HybridPluecker);
101

102
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4SubdivPatch1Intersector4);
103
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4SubdivPatch1MBIntersector4);
104
  
105
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4VirtualIntersector4Chunk);
106
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4VirtualMBIntersector4Chunk);
107

108
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4InstanceIntersector4Chunk);
109
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4InstanceMBIntersector4Chunk);
110

111
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4InstanceArrayIntersector4Chunk);
112
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4InstanceArrayMBIntersector4Chunk);
113

114
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4GridIntersector4HybridMoeller);
115
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4GridMBIntersector4HybridMoeller);
116
  DECLARE_SYMBOL2(Accel::Intersector4,BVH4GridIntersector4HybridPluecker);
117

118
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4OBBVirtualCurveIntersector8Hybrid);
119
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4OBBVirtualCurveIntersector8HybridMB);
120
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4OBBVirtualCurveIntersectorRobust8Hybrid);
121
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4OBBVirtualCurveIntersectorRobust8HybridMB);
122

123
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4Intersector8HybridMoeller);
124
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4Intersector8HybridMoellerNoFilter);
125
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4iIntersector8HybridMoeller);
126
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4vIntersector8HybridPluecker);
127
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4iIntersector8HybridPluecker);
128

129
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4vMBIntersector8HybridMoeller);
130
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4iMBIntersector8HybridMoeller);
131
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4vMBIntersector8HybridPluecker);
132
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4iMBIntersector8HybridPluecker);
133

134
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4vIntersector8HybridMoeller);
135
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4vIntersector8HybridMoellerNoFilter);
136
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4iIntersector8HybridMoeller);
137
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4vIntersector8HybridPluecker);
138
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4iIntersector8HybridPluecker);
139

140
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4iMBIntersector8HybridMoeller);
141
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4iMBIntersector8HybridPluecker);
142

143
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4SubdivPatch1Intersector8);
144
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4SubdivPatch1MBIntersector8);
145
  
146
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4VirtualIntersector8Chunk);
147
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4VirtualMBIntersector8Chunk);
148

149
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4InstanceIntersector8Chunk);
150
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4InstanceMBIntersector8Chunk);
151

152
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4InstanceArrayIntersector8Chunk);
153
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4InstanceArrayMBIntersector8Chunk);
154

155
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4GridIntersector8HybridMoeller);
156
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4GridMBIntersector8HybridMoeller);
157
  DECLARE_SYMBOL2(Accel::Intersector8,BVH4GridIntersector8HybridPluecker);
158

159
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4OBBVirtualCurveIntersector16Hybrid);
160
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4OBBVirtualCurveIntersector16HybridMB);
161
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4OBBVirtualCurveIntersectorRobust16Hybrid);
162
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4OBBVirtualCurveIntersectorRobust16HybridMB);
163

164
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4Intersector16HybridMoeller);
165
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4Intersector16HybridMoellerNoFilter);
166
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4iIntersector16HybridMoeller);
167
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4vIntersector16HybridPluecker);
168
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4iIntersector16HybridPluecker);
169

170
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4vMBIntersector16HybridMoeller);
171
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4iMBIntersector16HybridMoeller);
172
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4vMBIntersector16HybridPluecker);
173
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4iMBIntersector16HybridPluecker);
174

175
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4vIntersector16HybridMoeller);
176
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4vIntersector16HybridMoellerNoFilter);
177
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4iIntersector16HybridMoeller);
178
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4vIntersector16HybridPluecker);
179
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4iIntersector16HybridPluecker);
180

181
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4iMBIntersector16HybridMoeller);
182
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4iMBIntersector16HybridPluecker);
183

184
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4SubdivPatch1Intersector16);
185
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4SubdivPatch1MBIntersector16);
186
  
187
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4VirtualIntersector16Chunk);
188
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4VirtualMBIntersector16Chunk);
189

190
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4InstanceIntersector16Chunk);
191
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4InstanceMBIntersector16Chunk);
192

193
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4InstanceArrayIntersector16Chunk);
194
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4InstanceArrayMBIntersector16Chunk);
195

196
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4GridIntersector16HybridMoeller);
197
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4GridMBIntersector16HybridMoeller);
198
  DECLARE_SYMBOL2(Accel::Intersector16,BVH4GridIntersector16HybridPluecker);
199

200
  DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelTriangle4MeshSAH,void* COMMA Scene* COMMA bool);
201
  DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelTriangle4vMeshSAH,void* COMMA Scene* COMMA bool);
202
  DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelTriangle4iMeshSAH,void* COMMA Scene* COMMA bool);
203
  DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelQuadMeshSAH,void* COMMA Scene* COMMA bool);
204
  DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelVirtualSAH,void* COMMA Scene* COMMA bool);
205
  DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelInstanceSAH,void* COMMA Scene* COMMA Geometry::GTypeMask COMMA bool);
206
  DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelInstanceArraySAH,void* COMMA Scene* COMMA Geometry::GTypeMask COMMA bool);
207

208
  DECLARE_ISA_FUNCTION(Builder*,BVH4Curve4vBuilder_OBB_New,void* COMMA Scene* COMMA size_t);
209
  DECLARE_ISA_FUNCTION(Builder*,BVH4Curve4iBuilder_OBB_New,void* COMMA Scene* COMMA size_t);
210
  DECLARE_ISA_FUNCTION(Builder*,BVH4OBBCurve4iMBBuilder_OBB,void* COMMA Scene* COMMA size_t);
211
  DECLARE_ISA_FUNCTION(Builder*,BVH4Curve8iBuilder_OBB_New,void* COMMA Scene* COMMA size_t);
212
  DECLARE_ISA_FUNCTION(Builder*,BVH4OBBCurve8iMBBuilder_OBB,void* COMMA Scene* COMMA size_t);
213

214
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4SceneBuilderSAH,void* COMMA Scene* COMMA size_t);
215
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4vSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
216
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
217
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4iMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
218
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4vMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
219
  DECLARE_ISA_FUNCTION(Builder*,BVH4QuantizedTriangle4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
220

221
  DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4vSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
222
  DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
223
  DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4iMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
224
  DECLARE_ISA_FUNCTION(Builder*,BVH4QuantizedQuad4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
225

226
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4SceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
227
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4vSceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
228
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4iSceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
229

230
  DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4vSceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
231

232
  DECLARE_ISA_FUNCTION(Builder*,BVH4VirtualSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
233
  DECLARE_ISA_FUNCTION(Builder*,BVH4VirtualMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
234

235
  DECLARE_ISA_FUNCTION(Builder*,BVH4InstanceSceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
236
  DECLARE_ISA_FUNCTION(Builder*,BVH4InstanceMBSceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
237

238
  DECLARE_ISA_FUNCTION(Builder*,BVH4InstanceArraySceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
239
  DECLARE_ISA_FUNCTION(Builder*,BVH4InstanceArrayMBSceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
240

241
  DECLARE_ISA_FUNCTION(Builder*,BVH4GridSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
242
  DECLARE_ISA_FUNCTION(Builder*,BVH4GridMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
243

244
  DECLARE_ISA_FUNCTION(Builder*,BVH4SubdivPatch1BuilderSAH,void* COMMA Scene* COMMA size_t);
245
  DECLARE_ISA_FUNCTION(Builder*,BVH4SubdivPatch1MBBuilderSAH,void* COMMA Scene* COMMA size_t);
246

247
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4MeshRefitSAH,void* COMMA TriangleMesh* COMMA unsigned int COMMA size_t);
248
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4vMeshRefitSAH,void* COMMA TriangleMesh* COMMA unsigned int COMMA size_t);
249
  DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4iMeshRefitSAH,void* COMMA TriangleMesh* COMMA unsigned int COMMA size_t);
250
  DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4vMeshRefitSAH,void* COMMA QuadMesh* COMMA unsigned int COMMA size_t);
251
  DECLARE_ISA_FUNCTION(Builder*,BVH4VirtualMeshRefitSAH,void* COMMA UserGeometry* COMMA unsigned int COMMA size_t);
252

253
  BVH4Factory::BVH4Factory(int bfeatures, int ifeatures)
254
  {
255
    SELECT_SYMBOL_DEFAULT_AVX_AVX2(ifeatures,BVH4ColliderUserGeom);
256

257
    selectBuilders(bfeatures);
258
    selectIntersectors(ifeatures);
259
  }
260

261
  void BVH4Factory::selectBuilders(int features)
262
  {
263
    IF_ENABLED_TRIS (SELECT_SYMBOL_DEFAULT_AVX(features,BVH4BuilderTwoLevelTriangle4MeshSAH));
264
    IF_ENABLED_TRIS (SELECT_SYMBOL_DEFAULT_AVX(features,BVH4BuilderTwoLevelTriangle4iMeshSAH));
265
    IF_ENABLED_TRIS (SELECT_SYMBOL_DEFAULT_AVX(features,BVH4BuilderTwoLevelTriangle4vMeshSAH));
266
    IF_ENABLED_QUADS (SELECT_SYMBOL_DEFAULT_AVX(features,BVH4BuilderTwoLevelQuadMeshSAH));
267
    IF_ENABLED_USER (SELECT_SYMBOL_DEFAULT_AVX(features,BVH4BuilderTwoLevelVirtualSAH));
268
    IF_ENABLED_INSTANCE (SELECT_SYMBOL_DEFAULT_AVX(features,BVH4BuilderTwoLevelInstanceSAH));
269
    IF_ENABLED_INSTANCE_ARRAY (SELECT_SYMBOL_DEFAULT_AVX(features,BVH4BuilderTwoLevelInstanceArraySAH));
270

271
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Curve4vBuilder_OBB_New));
272
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Curve4iBuilder_OBB_New));
273
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4OBBCurve4iMBBuilder_OBB));
274
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX(features,BVH4Curve8iBuilder_OBB_New));
275
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX(features,BVH4OBBCurve8iMBBuilder_OBB));
276

277
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4SceneBuilderSAH));
278
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4vSceneBuilderSAH));
279
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4iSceneBuilderSAH));
280
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4iMBSceneBuilderSAH));
281
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4vMBSceneBuilderSAH));
282
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4QuantizedTriangle4iSceneBuilderSAH));
283

284
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Quad4vSceneBuilderSAH));
285
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Quad4iSceneBuilderSAH));
286
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Quad4iMBSceneBuilderSAH));
287
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4QuantizedQuad4iSceneBuilderSAH));
288

289
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4SceneBuilderFastSpatialSAH));
290
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4vSceneBuilderFastSpatialSAH));
291
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4iSceneBuilderFastSpatialSAH));
292

293
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Quad4vSceneBuilderFastSpatialSAH));
294

295
    IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4VirtualSceneBuilderSAH));
296
    IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4VirtualMBSceneBuilderSAH));
297

298
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4InstanceSceneBuilderSAH));
299
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4InstanceMBSceneBuilderSAH));
300

301
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4InstanceArraySceneBuilderSAH));
302
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4InstanceArrayMBSceneBuilderSAH));
303

304
    IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4GridSceneBuilderSAH));
305
    IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4GridMBSceneBuilderSAH));
306

307
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4SubdivPatch1BuilderSAH));
308
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4SubdivPatch1MBBuilderSAH));
309
  }
310

311
  void BVH4Factory::selectIntersectors(int features)
312
  {
313
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,VirtualCurveIntersector4i));
314
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,VirtualCurveIntersector8i));
315
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,VirtualCurveIntersector4v));
316
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,VirtualCurveIntersector8v));
317
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,VirtualCurveIntersector4iMB));
318
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,VirtualCurveIntersector8iMB));
319
    
320
    /* select intersectors1 */
321
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector1));
322
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector1MB));
323
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust1));
324
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust1MB));
325
    
326
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector1Moeller));
327
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,BVH4Triangle4iIntersector1Moeller));
328
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,BVH4Triangle4vIntersector1Pluecker));
329
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,BVH4Triangle4iIntersector1Pluecker));
330

331
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector1Moeller));
332
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector1Moeller));
333
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector1Pluecker));
334
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector1Pluecker));
335

336
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector1Moeller));
337
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector1Moeller));
338
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector1Pluecker));
339
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector1Pluecker));
340

341
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector1Pluecker));
342
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector1Moeller));
343

344
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,QBVH4Triangle4iIntersector1Pluecker));
345
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,QBVH4Quad4iIntersector1Pluecker));
346

347
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4SubdivPatch1Intersector1));
348
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4SubdivPatch1MBIntersector1));
349
    
350
    IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualIntersector1));
351
    IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualMBIntersector1));
352

353
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceIntersector1));
354
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceMBIntersector1));
355

356
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceArrayIntersector1));
357
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceArrayMBIntersector1));
358

359
    IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridIntersector1Moeller));
360
    IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridMBIntersector1Moeller))
361
    IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridIntersector1Pluecker));
362

363
#if defined (EMBREE_RAY_PACKETS)
364

365
    /* select intersectors4 */
366
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector4Hybrid));
367
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector4HybridMB));
368
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust4Hybrid));
369
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust4HybridMB));
370

371
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector4HybridMoeller));
372
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector4HybridMoellerNoFilter));
373
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersector4HybridMoeller));
374
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vIntersector4HybridPluecker));
375
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersector4HybridPluecker));
376

377
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector4HybridMoeller));
378
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector4HybridMoeller));
379
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector4HybridPluecker));
380
    IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector4HybridPluecker));
381

382
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector4HybridMoeller));
383
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector4HybridMoellerNoFilter));
384
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector4HybridMoeller));
385
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector4HybridPluecker));
386
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector4HybridPluecker));
387

388
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector4HybridMoeller));
389
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector4HybridPluecker));
390

391
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4SubdivPatch1Intersector4));
392
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4SubdivPatch1MBIntersector4));
393
    
394
    IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualIntersector4Chunk));
395
    IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualMBIntersector4Chunk));
396

397
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceIntersector4Chunk));
398
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceMBIntersector4Chunk));
399

400
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceArrayIntersector4Chunk));
401
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceArrayMBIntersector4Chunk));
402

403
    IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector4HybridMoeller));
404

405
    IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridIntersector4HybridMoeller));
406
    IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridMBIntersector4HybridMoeller));
407
    IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridIntersector4HybridPluecker));
408

409
    /* select intersectors8 */
410
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector8Hybrid));
411
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector8HybridMB));
412
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust8Hybrid));
413
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust8HybridMB));
414

415
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector8HybridMoeller));
416
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector8HybridMoellerNoFilter));
417
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersector8HybridMoeller));
418
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4vIntersector8HybridPluecker));
419
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersector8HybridPluecker));
420

421
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector8HybridMoeller));
422
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector8HybridMoeller));
423
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector8HybridPluecker));
424
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector8HybridPluecker));
425

426
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector8HybridMoeller));
427
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector8HybridMoellerNoFilter));
428
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector8HybridMoeller));
429
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector8HybridPluecker));
430
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector8HybridPluecker));
431

432
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector8HybridMoeller));
433
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector8HybridPluecker));
434

435
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4SubdivPatch1Intersector8));
436
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4SubdivPatch1MBIntersector8));
437

438
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4VirtualIntersector8Chunk));
439
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4VirtualMBIntersector8Chunk));
440

441
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4InstanceIntersector8Chunk));
442
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4InstanceMBIntersector8Chunk));
443

444
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4InstanceArrayIntersector8Chunk));
445
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4InstanceArrayMBIntersector8Chunk));
446

447
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4GridIntersector8HybridMoeller));
448
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4GridMBIntersector8HybridMoeller));
449
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4GridIntersector8HybridPluecker));
450

451
    /* select intersectors16 */
452
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH4OBBVirtualCurveIntersector16Hybrid));
453
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH4OBBVirtualCurveIntersector16HybridMB));
454
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust16Hybrid));
455
    IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust16HybridMB));
456

457
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4Intersector16HybridMoeller));
458
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4Intersector16HybridMoellerNoFilter));
459
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4iIntersector16HybridMoeller));
460
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4vIntersector16HybridPluecker));
461
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4iIntersector16HybridPluecker));
462

463
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4vMBIntersector16HybridMoeller));
464
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4iMBIntersector16HybridMoeller));
465
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4vMBIntersector16HybridPluecker));
466
    IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4iMBIntersector16HybridPluecker));
467

468
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4vIntersector16HybridMoeller));
469
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4vIntersector16HybridMoellerNoFilter));
470
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4iIntersector16HybridMoeller));
471
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4vIntersector16HybridPluecker));
472
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4iIntersector16HybridPluecker));
473

474
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4iMBIntersector16HybridMoeller));
475
    IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4iMBIntersector16HybridPluecker));
476

477
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_INIT_AVX512(features,BVH4SubdivPatch1Intersector16));
478
    IF_ENABLED_SUBDIV(SELECT_SYMBOL_INIT_AVX512(features,BVH4SubdivPatch1MBIntersector16));
479
    
480
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX512(features,BVH4VirtualIntersector16Chunk));
481
    IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX512(features,BVH4VirtualMBIntersector16Chunk));
482

483
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX512(features,BVH4InstanceIntersector16Chunk));
484
    IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX512(features,BVH4InstanceMBIntersector16Chunk));
485

486
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX512(features,BVH4InstanceArrayIntersector16Chunk));
487
    IF_ENABLED_INSTANCE_ARRAY(SELECT_SYMBOL_INIT_AVX512(features,BVH4InstanceArrayMBIntersector16Chunk));
488

489
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX512(features,BVH4GridIntersector16HybridMoeller));
490
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX512(features,BVH4GridMBIntersector16HybridMoeller));
491
    IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX512(features,BVH4GridIntersector16HybridPluecker));
492

493
#endif
494
  }
495

496
  Accel::Intersectors BVH4Factory::BVH4OBBVirtualCurveIntersectors(BVH4* bvh, VirtualCurveIntersector* leafIntersector, IntersectVariant ivariant)
497
  {
498
    switch (ivariant) {
499
    case IntersectVariant::FAST:
500
    {
501
      Accel::Intersectors intersectors;
502
      intersectors.ptr = bvh;
503
      intersectors.leafIntersector = leafIntersector;
504
      intersectors.intersector1  = BVH4OBBVirtualCurveIntersector1();
505
#if defined (EMBREE_RAY_PACKETS)
506
      intersectors.intersector4  = BVH4OBBVirtualCurveIntersector4Hybrid();
507
      intersectors.intersector8  = BVH4OBBVirtualCurveIntersector8Hybrid();
508
      intersectors.intersector16 = BVH4OBBVirtualCurveIntersector16Hybrid();
509
#endif
510
      return intersectors;
511
    }
512
    case IntersectVariant::ROBUST:
513
    {
514
      Accel::Intersectors intersectors;
515
      intersectors.ptr = bvh;
516
      intersectors.leafIntersector = leafIntersector;
517
      intersectors.intersector1  = BVH4OBBVirtualCurveIntersectorRobust1();
518
#if defined (EMBREE_RAY_PACKETS)
519
      intersectors.intersector4  = BVH4OBBVirtualCurveIntersectorRobust4Hybrid();
520
      intersectors.intersector8  = BVH4OBBVirtualCurveIntersectorRobust8Hybrid();
521
      intersectors.intersector16 = BVH4OBBVirtualCurveIntersectorRobust16Hybrid();
522
#endif
523
      return intersectors;
524
    }
525
    default: assert(false);
526
    }
527
    return Accel::Intersectors();
528
  }
529

530
  Accel::Intersectors BVH4Factory::BVH4OBBVirtualCurveIntersectorsMB(BVH4* bvh, VirtualCurveIntersector* leafIntersector, IntersectVariant ivariant)
531
  {
532
    switch (ivariant) {
533
    case IntersectVariant::FAST:
534
    {
535
      Accel::Intersectors intersectors;
536
      intersectors.ptr = bvh;
537
      intersectors.leafIntersector = leafIntersector;
538
      intersectors.intersector1  = BVH4OBBVirtualCurveIntersector1MB();
539
#if defined (EMBREE_RAY_PACKETS)
540
      intersectors.intersector4  = BVH4OBBVirtualCurveIntersector4HybridMB();
541
      intersectors.intersector8  = BVH4OBBVirtualCurveIntersector8HybridMB();
542
      intersectors.intersector16 = BVH4OBBVirtualCurveIntersector16HybridMB();
543
#endif
544
      return intersectors;
545
    }
546
    case IntersectVariant::ROBUST:
547
    {
548
      Accel::Intersectors intersectors;
549
      intersectors.ptr = bvh;
550
      intersectors.leafIntersector = leafIntersector;
551
      intersectors.intersector1  = BVH4OBBVirtualCurveIntersectorRobust1MB();
552
#if defined (EMBREE_RAY_PACKETS)
553
      intersectors.intersector4  = BVH4OBBVirtualCurveIntersectorRobust4HybridMB();
554
      intersectors.intersector8  = BVH4OBBVirtualCurveIntersectorRobust8HybridMB();
555
      intersectors.intersector16 = BVH4OBBVirtualCurveIntersectorRobust16HybridMB();
556
#endif
557
      return intersectors;
558
    }
559
    default: assert(false);
560
    }
561
    return Accel::Intersectors();
562
  }
563

564
  Accel::Intersectors BVH4Factory::BVH4Triangle4Intersectors(BVH4* bvh, IntersectVariant ivariant)
565
  {
566
    assert(ivariant == IntersectVariant::FAST);
567
    Accel::Intersectors intersectors;
568
    intersectors.ptr = bvh;
569
    intersectors.intersector1           = BVH4Triangle4Intersector1Moeller();
570
#if defined (EMBREE_RAY_PACKETS)
571
    intersectors.intersector4_filter    = BVH4Triangle4Intersector4HybridMoeller();
572
    intersectors.intersector4_nofilter  = BVH4Triangle4Intersector4HybridMoellerNoFilter();
573
    intersectors.intersector8_filter    = BVH4Triangle4Intersector8HybridMoeller();
574
    intersectors.intersector8_nofilter  = BVH4Triangle4Intersector8HybridMoellerNoFilter();
575
    intersectors.intersector16_filter   = BVH4Triangle4Intersector16HybridMoeller();
576
    intersectors.intersector16_nofilter = BVH4Triangle4Intersector16HybridMoellerNoFilter();
577
#endif
578
    return intersectors;
579
  }
580

581
  Accel::Intersectors BVH4Factory::BVH4Triangle4vIntersectors(BVH4* bvh, IntersectVariant ivariant)
582
  {
583
    assert(ivariant == IntersectVariant::ROBUST);
584
    Accel::Intersectors intersectors;
585
    intersectors.ptr = bvh;
586
    intersectors.intersector1  = BVH4Triangle4vIntersector1Pluecker();
587
#if defined (EMBREE_RAY_PACKETS)
588
    intersectors.intersector4  = BVH4Triangle4vIntersector4HybridPluecker();
589
    intersectors.intersector8  = BVH4Triangle4vIntersector8HybridPluecker();
590
    intersectors.intersector16 = BVH4Triangle4vIntersector16HybridPluecker();
591
#endif
592
    return intersectors;
593
  }
594

595
  Accel::Intersectors BVH4Factory::BVH4Triangle4iIntersectors(BVH4* bvh, IntersectVariant ivariant)
596
  {
597
    switch (ivariant) {
598
    case IntersectVariant::FAST:
599
    {
600
      Accel::Intersectors intersectors;
601
      intersectors.ptr = bvh;
602
      intersectors.intersector1  = BVH4Triangle4iIntersector1Moeller();
603
#if defined (EMBREE_RAY_PACKETS)
604
      intersectors.intersector4  = BVH4Triangle4iIntersector4HybridMoeller();
605
      intersectors.intersector8  = BVH4Triangle4iIntersector8HybridMoeller();
606
      intersectors.intersector16 = BVH4Triangle4iIntersector16HybridMoeller();
607
#endif
608
      return intersectors;
609
    }
610
    case IntersectVariant::ROBUST:
611
    {
612
      Accel::Intersectors intersectors;
613
      intersectors.ptr = bvh;
614
      intersectors.intersector1  = BVH4Triangle4iIntersector1Pluecker();
615
#if defined (EMBREE_RAY_PACKETS)
616
      intersectors.intersector4  = BVH4Triangle4iIntersector4HybridPluecker();
617
      intersectors.intersector8  = BVH4Triangle4iIntersector8HybridPluecker();
618
      intersectors.intersector16 = BVH4Triangle4iIntersector16HybridPluecker();
619
#endif
620
      return intersectors;
621
    }
622
    }
623
    return Accel::Intersectors();
624
  }
625

626
  Accel::Intersectors BVH4Factory::BVH4Triangle4vMBIntersectors(BVH4* bvh, IntersectVariant ivariant)
627
  {
628
    switch (ivariant) {
629
    case IntersectVariant::FAST:
630
    {
631
      Accel::Intersectors intersectors;
632
      intersectors.ptr = bvh;
633
      intersectors.intersector1  = BVH4Triangle4vMBIntersector1Moeller();
634
#if defined (EMBREE_RAY_PACKETS)
635
      intersectors.intersector4  = BVH4Triangle4vMBIntersector4HybridMoeller();
636
      intersectors.intersector8  = BVH4Triangle4vMBIntersector8HybridMoeller();
637
      intersectors.intersector16 = BVH4Triangle4vMBIntersector16HybridMoeller();
638
#endif
639
      return intersectors;
640
    }
641
    case IntersectVariant::ROBUST:
642
    {
643
      Accel::Intersectors intersectors;
644
      intersectors.ptr = bvh;
645
      intersectors.intersector1  = BVH4Triangle4vMBIntersector1Pluecker();
646
#if defined (EMBREE_RAY_PACKETS)
647
      intersectors.intersector4  = BVH4Triangle4vMBIntersector4HybridPluecker();
648
      intersectors.intersector8  = BVH4Triangle4vMBIntersector8HybridPluecker();
649
      intersectors.intersector16 = BVH4Triangle4vMBIntersector16HybridPluecker();
650
#endif
651
      return intersectors;
652
    }
653
    }
654
    return Accel::Intersectors();
655
  }
656

657
  Accel::Intersectors BVH4Factory::BVH4Triangle4iMBIntersectors(BVH4* bvh, IntersectVariant ivariant)
658
  {
659
    switch (ivariant) {
660
    case IntersectVariant::FAST:
661
    {
662
      Accel::Intersectors intersectors;
663
      intersectors.ptr = bvh;
664
      intersectors.intersector1  = BVH4Triangle4iMBIntersector1Moeller();
665
#if defined (EMBREE_RAY_PACKETS)
666
      intersectors.intersector4  = BVH4Triangle4iMBIntersector4HybridMoeller();
667
      intersectors.intersector8  = BVH4Triangle4iMBIntersector8HybridMoeller();
668
      intersectors.intersector16 = BVH4Triangle4iMBIntersector16HybridMoeller();
669
#endif
670
      return intersectors;
671
    }
672
    case IntersectVariant::ROBUST:
673
    {
674
      Accel::Intersectors intersectors;
675
      intersectors.ptr = bvh;
676
      intersectors.intersector1  = BVH4Triangle4iMBIntersector1Pluecker();
677
#if defined (EMBREE_RAY_PACKETS)
678
      intersectors.intersector4  = BVH4Triangle4iMBIntersector4HybridPluecker();
679
      intersectors.intersector8  = BVH4Triangle4iMBIntersector8HybridPluecker();
680
      intersectors.intersector16 = BVH4Triangle4iMBIntersector16HybridPluecker();
681
#endif
682
      return intersectors;
683
    }
684
    }
685
    return Accel::Intersectors();
686
  }
687

688
  Accel::Intersectors BVH4Factory::BVH4Quad4vIntersectors(BVH4* bvh, IntersectVariant ivariant)
689
  {
690
    switch (ivariant) {
691
    case IntersectVariant::FAST:
692
    {
693
      Accel::Intersectors intersectors;
694
      intersectors.ptr = bvh;
695
      intersectors.intersector1           = BVH4Quad4vIntersector1Moeller();
696
#if defined (EMBREE_RAY_PACKETS)
697
      intersectors.intersector4_filter    = BVH4Quad4vIntersector4HybridMoeller();
698
      intersectors.intersector4_nofilter  = BVH4Quad4vIntersector4HybridMoellerNoFilter();
699
      intersectors.intersector8_filter    = BVH4Quad4vIntersector8HybridMoeller();
700
      intersectors.intersector8_nofilter  = BVH4Quad4vIntersector8HybridMoellerNoFilter();
701
      intersectors.intersector16_filter   = BVH4Quad4vIntersector16HybridMoeller();
702
      intersectors.intersector16_nofilter = BVH4Quad4vIntersector16HybridMoellerNoFilter();
703
#endif
704
      return intersectors;
705
    }
706
    case IntersectVariant::ROBUST:
707
    {
708
      Accel::Intersectors intersectors;
709
      intersectors.ptr = bvh;
710
      intersectors.intersector1  = BVH4Quad4vIntersector1Pluecker();
711
#if defined (EMBREE_RAY_PACKETS)
712
      intersectors.intersector4  = BVH4Quad4vIntersector4HybridPluecker();
713
      intersectors.intersector8  = BVH4Quad4vIntersector8HybridPluecker();
714
      intersectors.intersector16 = BVH4Quad4vIntersector16HybridPluecker();
715
#endif
716
      return intersectors;
717
    }
718
    }
719
    return Accel::Intersectors();
720
  }
721

722
  Accel::Intersectors BVH4Factory::BVH4Quad4iIntersectors(BVH4* bvh, IntersectVariant ivariant)
723
  {
724
    switch (ivariant) {
725
    case IntersectVariant::FAST:
726
    {
727
      Accel::Intersectors intersectors;
728
      intersectors.ptr = bvh;
729
      intersectors.intersector1 = BVH4Quad4iIntersector1Moeller();
730
#if defined (EMBREE_RAY_PACKETS)
731
      intersectors.intersector4 = BVH4Quad4iIntersector4HybridMoeller();
732
      intersectors.intersector8 = BVH4Quad4iIntersector8HybridMoeller();
733
      intersectors.intersector16= BVH4Quad4iIntersector16HybridMoeller();
734
#endif
735
      return intersectors;
736
    }
737
    case IntersectVariant::ROBUST:
738
    {
739
      Accel::Intersectors intersectors;
740
      intersectors.ptr = bvh;
741
      intersectors.intersector1 = BVH4Quad4iIntersector1Pluecker();
742
#if defined (EMBREE_RAY_PACKETS)
743
      intersectors.intersector4 = BVH4Quad4iIntersector4HybridPluecker();
744
      intersectors.intersector8 = BVH4Quad4iIntersector8HybridPluecker();
745
      intersectors.intersector16= BVH4Quad4iIntersector16HybridPluecker();
746
#endif
747
      return intersectors;
748
    }
749
    }
750
    return Accel::Intersectors();
751
  }
752

753
  Accel::Intersectors BVH4Factory::BVH4Quad4iMBIntersectors(BVH4* bvh, IntersectVariant ivariant)
754
  {
755
    switch (ivariant) {
756
    case IntersectVariant::FAST:
757
    {
758
      Accel::Intersectors intersectors;
759
      intersectors.ptr = bvh;
760
      intersectors.intersector1 = BVH4Quad4iMBIntersector1Moeller();
761
#if defined (EMBREE_RAY_PACKETS)
762
      intersectors.intersector4 = BVH4Quad4iMBIntersector4HybridMoeller();
763
      intersectors.intersector8 = BVH4Quad4iMBIntersector8HybridMoeller();
764
      intersectors.intersector16= BVH4Quad4iMBIntersector16HybridMoeller();
765
#endif
766
      return intersectors;
767
    }
768
    case IntersectVariant::ROBUST:
769
    {
770
      Accel::Intersectors intersectors;
771
      intersectors.ptr = bvh;
772
      intersectors.intersector1 = BVH4Quad4iMBIntersector1Pluecker();
773
#if defined (EMBREE_RAY_PACKETS)
774
      intersectors.intersector4 = BVH4Quad4iMBIntersector4HybridPluecker();
775
      intersectors.intersector8 = BVH4Quad4iMBIntersector8HybridPluecker();
776
      intersectors.intersector16= BVH4Quad4iMBIntersector16HybridPluecker();
777
#endif
778
      return intersectors;
779
    }
780
    }
781
    return Accel::Intersectors();
782
  }
783

784
  Accel::Intersectors BVH4Factory::QBVH4Triangle4iIntersectors(BVH4* bvh)
785
  {
786
    Accel::Intersectors intersectors;
787
    intersectors.ptr = bvh;
788
    intersectors.intersector1 = QBVH4Triangle4iIntersector1Pluecker();
789
    return intersectors;
790
  }
791

792
  Accel::Intersectors BVH4Factory::QBVH4Quad4iIntersectors(BVH4* bvh)
793
  {
794
    Accel::Intersectors intersectors;
795
    intersectors.ptr = bvh;
796
    intersectors.intersector1 = QBVH4Quad4iIntersector1Pluecker();
797
    return intersectors;
798
  }
799

800
  Accel::Intersectors BVH4Factory::BVH4UserGeometryIntersectors(BVH4* bvh)
801
  {
802
    Accel::Intersectors intersectors;
803
    intersectors.ptr = bvh;
804
    intersectors.intersector1  = BVH4VirtualIntersector1();
805
#if defined (EMBREE_RAY_PACKETS)
806
    intersectors.intersector4  = BVH4VirtualIntersector4Chunk();
807
    intersectors.intersector8  = BVH4VirtualIntersector8Chunk();
808
    intersectors.intersector16 = BVH4VirtualIntersector16Chunk();
809
#endif
810
    intersectors.collider      = BVH4ColliderUserGeom();
811
    return intersectors;
812
  }
813

814
  Accel::Intersectors BVH4Factory::BVH4UserGeometryMBIntersectors(BVH4* bvh)
815
  {
816
    Accel::Intersectors intersectors;
817
    intersectors.ptr = bvh;
818
    intersectors.intersector1  = BVH4VirtualMBIntersector1();
819
#if defined (EMBREE_RAY_PACKETS)
820
    intersectors.intersector4  = BVH4VirtualMBIntersector4Chunk();
821
    intersectors.intersector8  = BVH4VirtualMBIntersector8Chunk();
822
    intersectors.intersector16 = BVH4VirtualMBIntersector16Chunk();
823
#endif
824
    return intersectors;
825
  }
826

827
  Accel::Intersectors BVH4Factory::BVH4InstanceIntersectors(BVH4* bvh)
828
  {
829
    Accel::Intersectors intersectors;
830
    intersectors.ptr = bvh;
831
    intersectors.intersector1  = BVH4InstanceIntersector1();
832
#if defined (EMBREE_RAY_PACKETS)
833
    intersectors.intersector4  = BVH4InstanceIntersector4Chunk();
834
    intersectors.intersector8  = BVH4InstanceIntersector8Chunk();
835
    intersectors.intersector16 = BVH4InstanceIntersector16Chunk();
836
#endif
837
    return intersectors;
838
  }
839

840
  Accel::Intersectors BVH4Factory::BVH4InstanceMBIntersectors(BVH4* bvh)
841
  {
842
    Accel::Intersectors intersectors;
843
    intersectors.ptr = bvh;
844
    intersectors.intersector1  = BVH4InstanceMBIntersector1();
845
#if defined (EMBREE_RAY_PACKETS)
846
    intersectors.intersector4  = BVH4InstanceMBIntersector4Chunk();
847
    intersectors.intersector8  = BVH4InstanceMBIntersector8Chunk();
848
    intersectors.intersector16 = BVH4InstanceMBIntersector16Chunk();
849
#endif
850
    return intersectors;
851
  }
852

853
  Accel::Intersectors BVH4Factory::BVH4InstanceArrayIntersectors(BVH4* bvh)
854
  {
855
    Accel::Intersectors intersectors;
856
    intersectors.ptr = bvh;
857
    intersectors.intersector1  = BVH4InstanceArrayIntersector1();
858
#if defined (EMBREE_RAY_PACKETS)
859
    intersectors.intersector4  = BVH4InstanceArrayIntersector4Chunk();
860
    intersectors.intersector8  = BVH4InstanceArrayIntersector8Chunk();
861
    intersectors.intersector16 = BVH4InstanceArrayIntersector16Chunk();
862
#endif
863
    return intersectors;
864
  }
865

866
  Accel::Intersectors BVH4Factory::BVH4InstanceArrayMBIntersectors(BVH4* bvh)
867
  {
868
    Accel::Intersectors intersectors;
869
    intersectors.ptr = bvh;
870
    intersectors.intersector1  = BVH4InstanceArrayMBIntersector1();
871
#if defined (EMBREE_RAY_PACKETS)
872
    intersectors.intersector4  = BVH4InstanceArrayMBIntersector4Chunk();
873
    intersectors.intersector8  = BVH4InstanceArrayMBIntersector8Chunk();
874
    intersectors.intersector16 = BVH4InstanceArrayMBIntersector16Chunk();
875
#endif
876
    return intersectors;
877
  }
878
  
879
  Accel::Intersectors BVH4Factory::BVH4SubdivPatch1Intersectors(BVH4* bvh)
880
  {
881
    Accel::Intersectors intersectors;
882
    intersectors.ptr = bvh;
883
    intersectors.intersector1  = BVH4SubdivPatch1Intersector1();
884
#if defined (EMBREE_RAY_PACKETS)
885
    intersectors.intersector4  = BVH4SubdivPatch1Intersector4();
886
    intersectors.intersector8  = BVH4SubdivPatch1Intersector8();
887
    intersectors.intersector16 = BVH4SubdivPatch1Intersector16();
888
#endif
889
    return intersectors;
890
  }
891

892
  Accel::Intersectors BVH4Factory::BVH4SubdivPatch1MBIntersectors(BVH4* bvh)
893
  {
894
    Accel::Intersectors intersectors;
895
    intersectors.ptr = bvh;
896
    intersectors.intersector1  = BVH4SubdivPatch1MBIntersector1();
897
#if defined (EMBREE_RAY_PACKETS)
898
    intersectors.intersector4  = BVH4SubdivPatch1MBIntersector4();
899
    intersectors.intersector8  = BVH4SubdivPatch1MBIntersector8();
900
    intersectors.intersector16 = BVH4SubdivPatch1MBIntersector16();
901
#endif
902
    return intersectors;
903
  }
904

905
  Accel* BVH4Factory::BVH4OBBVirtualCurve4i(Scene* scene, IntersectVariant ivariant)
906
  {
907
    BVH4* accel = new BVH4(Curve4i::type,scene);
908
    Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectors(accel,VirtualCurveIntersector4i(),ivariant);
909

910
    Builder* builder = nullptr;
911
    if      (scene->device->hair_builder == "default"     ) builder = BVH4Curve4iBuilder_OBB_New(accel,scene,0);
912
    else if (scene->device->hair_builder == "sah"         ) builder = BVH4Curve4iBuilder_OBB_New(accel,scene,0);
913
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve4i>");
914

915
    return new AccelInstance(accel,builder,intersectors);
916
  }
917

918
#if defined(EMBREE_TARGET_SIMD8)
919
  Accel* BVH4Factory::BVH4OBBVirtualCurve8i(Scene* scene, IntersectVariant ivariant)
920
  {
921
    BVH4* accel = new BVH4(Curve8i::type,scene);
922
    Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectors(accel,VirtualCurveIntersector8i(),ivariant);
923

924
    Builder* builder = nullptr;
925
    if      (scene->device->hair_builder == "default"     ) builder = BVH4Curve8iBuilder_OBB_New(accel,scene,0);
926
    else if (scene->device->hair_builder == "sah"         ) builder = BVH4Curve8iBuilder_OBB_New(accel,scene,0);
927
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve8i>");
928

929
    return new AccelInstance(accel,builder,intersectors);
930
  }
931
#endif
932

933
  Accel* BVH4Factory::BVH4OBBVirtualCurve4v(Scene* scene, IntersectVariant ivariant)
934
  {
935
    BVH4* accel = new BVH4(Curve4v::type,scene);
936
    Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectors(accel,VirtualCurveIntersector4v(),ivariant);
937

938
    Builder* builder = nullptr;
939
    if      (scene->device->hair_builder == "default"     ) builder = BVH4Curve4vBuilder_OBB_New(accel,scene,0);
940
    else if (scene->device->hair_builder == "sah"         ) builder = BVH4Curve4vBuilder_OBB_New(accel,scene,0);
941
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve4v>");
942

943
    return new AccelInstance(accel,builder,intersectors);
944
  }
945

946
  Accel* BVH4Factory::BVH4OBBVirtualCurve4iMB(Scene* scene, IntersectVariant ivariant)
947
  {
948
    BVH4* accel = new BVH4(Curve4iMB::type,scene);
949
    Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectorsMB(accel,VirtualCurveIntersector4iMB(),ivariant);
950

951
    Builder* builder = nullptr;
952
    if      (scene->device->hair_builder == "default"     ) builder = BVH4OBBCurve4iMBBuilder_OBB(accel,scene,0);
953
    else if (scene->device->hair_builder == "sah"         ) builder = BVH4OBBCurve4iMBBuilder_OBB(accel,scene,0);
954
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve4iMB>");
955

956
    return new AccelInstance(accel,builder,intersectors);
957
  }
958

959
#if defined(EMBREE_TARGET_SIMD8)
960
  Accel* BVH4Factory::BVH4OBBVirtualCurve8iMB(Scene* scene, IntersectVariant ivariant)
961
  {
962
    BVH4* accel = new BVH4(Curve8iMB::type,scene);
963
    Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectorsMB(accel,VirtualCurveIntersector8iMB(), ivariant);
964

965
    Builder* builder = nullptr;
966
    if      (scene->device->hair_builder == "default"     ) builder = BVH4OBBCurve8iMBBuilder_OBB(accel,scene,0);
967
    else if (scene->device->hair_builder == "sah"         ) builder = BVH4OBBCurve8iMBBuilder_OBB(accel,scene,0);
968
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve8iMB>");
969

970
    return new AccelInstance(accel,builder,intersectors);
971
  }
972
#endif
973
  
974
  Accel* BVH4Factory::BVH4Triangle4(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
975
  {
976
    BVH4* accel = new BVH4(Triangle4::type,scene);
977

978
    Accel::Intersectors intersectors;
979
    if      (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4Intersectors(accel,ivariant);
980
    else if (scene->device->tri_traverser == "fast"   ) intersectors = BVH4Triangle4Intersectors(accel,IntersectVariant::FAST);
981
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser+" for BVH4<Triangle4>");
982

983
    Builder* builder = nullptr;
984
    if (scene->device->tri_builder == "default") {
985
      switch (bvariant) {
986
      case BuildVariant::STATIC      : builder = BVH4Triangle4SceneBuilderSAH(accel,scene,0); break;
987
      case BuildVariant::DYNAMIC     : builder = BVH4BuilderTwoLevelTriangle4MeshSAH(accel,scene,false); break;
988
      case BuildVariant::HIGH_QUALITY: builder = BVH4Triangle4SceneBuilderFastSpatialSAH(accel,scene,0); break;
989
      }
990
    }
991
    else if (scene->device->tri_builder == "sah"         ) builder = BVH4Triangle4SceneBuilderSAH(accel,scene,0);
992
    else if (scene->device->tri_builder == "sah_fast_spatial" ) builder = BVH4Triangle4SceneBuilderFastSpatialSAH(accel,scene,0);
993
    else if (scene->device->tri_builder == "sah_presplit") builder = BVH4Triangle4SceneBuilderSAH(accel,scene,MODE_HIGH_QUALITY);
994
    else if (scene->device->tri_builder == "dynamic"     ) builder = BVH4BuilderTwoLevelTriangle4MeshSAH(accel,scene,false);
995
    else if (scene->device->tri_builder == "morton"      ) builder = BVH4BuilderTwoLevelTriangle4MeshSAH(accel,scene,true);
996
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH4<Triangle4>");
997

998
    return new AccelInstance(accel,builder,intersectors);
999
  }
1000

1001
  Accel* BVH4Factory::BVH4Triangle4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1002
  {
1003
    BVH4* accel = new BVH4(Triangle4v::type,scene);
1004

1005
    Accel::Intersectors intersectors;
1006
    if      (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4vIntersectors(accel,ivariant);
1007
    else if (scene->device->tri_traverser == "fast"   ) intersectors = BVH4Triangle4vIntersectors(accel,IntersectVariant::FAST);
1008
    else if (scene->device->tri_traverser == "robust" ) intersectors = BVH4Triangle4vIntersectors(accel,IntersectVariant::ROBUST);
1009
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser+" for BVH4<Triangle4>");
1010

1011
    Builder* builder = nullptr;
1012
    if (scene->device->tri_builder == "default") {
1013
      switch (bvariant) {
1014
      case BuildVariant::STATIC      : builder = BVH4Triangle4vSceneBuilderSAH(accel,scene,0); break;
1015
      case BuildVariant::DYNAMIC     : builder = BVH4BuilderTwoLevelTriangle4vMeshSAH(accel,scene,false); break;
1016
      case BuildVariant::HIGH_QUALITY: builder = BVH4Triangle4vSceneBuilderFastSpatialSAH(accel,scene,0); break;
1017
      }
1018
    }
1019
    else if (scene->device->tri_builder == "sah"         ) builder = BVH4Triangle4vSceneBuilderSAH(accel,scene,0);
1020
    else if (scene->device->tri_builder == "sah_fast_spatial" ) builder = BVH4Triangle4vSceneBuilderFastSpatialSAH(accel,scene,0);
1021
    else if (scene->device->tri_builder == "sah_presplit") builder = BVH4Triangle4vSceneBuilderSAH(accel,scene,MODE_HIGH_QUALITY);
1022
    else if (scene->device->tri_builder == "dynamic"     ) builder = BVH4BuilderTwoLevelTriangle4vMeshSAH(accel,scene,false);
1023
    else if (scene->device->tri_builder == "morton"      ) builder = BVH4BuilderTwoLevelTriangle4vMeshSAH(accel,scene,true);
1024
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH4<Triangle4v>");
1025

1026
    return new AccelInstance(accel,builder,intersectors);
1027
  }
1028

1029
  Accel* BVH4Factory::BVH4Triangle4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1030
  {
1031
    BVH4* accel = new BVH4(Triangle4i::type,scene);
1032

1033
    Accel::Intersectors intersectors;
1034
    if      (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4iIntersectors(accel,ivariant);
1035
    else if (scene->device->tri_traverser == "fast"   ) intersectors = BVH4Triangle4iIntersectors(accel,IntersectVariant::FAST);
1036
    else if (scene->device->tri_traverser == "robust" ) intersectors = BVH4Triangle4iIntersectors(accel,IntersectVariant::ROBUST);
1037
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser+" for BVH4<Triangle4i>");
1038

1039
    Builder* builder = nullptr;
1040
    if (scene->device->tri_builder == "default"     ) {
1041
      switch (bvariant) {
1042
      case BuildVariant::STATIC      : builder = BVH4Triangle4iSceneBuilderSAH(accel,scene,0); break;
1043
      case BuildVariant::DYNAMIC     : builder = BVH4BuilderTwoLevelTriangle4iMeshSAH(accel,scene,false); break;
1044
      case BuildVariant::HIGH_QUALITY: builder = BVH4Triangle4iSceneBuilderFastSpatialSAH(accel,scene,0); break;
1045
      }
1046
    }
1047
    else if (scene->device->tri_builder == "sah"         ) builder = BVH4Triangle4iSceneBuilderSAH(accel,scene,0);
1048
    else if (scene->device->tri_builder == "sah_fast_spatial" ) builder = BVH4Triangle4iSceneBuilderFastSpatialSAH(accel,scene,0);
1049
    else if (scene->device->tri_builder == "sah_presplit") builder = BVH4Triangle4iSceneBuilderSAH(accel,scene,MODE_HIGH_QUALITY);
1050
    else if (scene->device->tri_builder == "dynamic"     ) builder = BVH4BuilderTwoLevelTriangle4iMeshSAH(accel,scene,false);
1051
    else if (scene->device->tri_builder == "morton"      ) builder = BVH4BuilderTwoLevelTriangle4iMeshSAH(accel,scene,true);
1052
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH4<Triangle4i>");
1053

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

1057
  Accel* BVH4Factory::BVH4Triangle4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1058
  {
1059
    BVH4* accel = new BVH4(Triangle4i::type,scene);
1060

1061
    Accel::Intersectors intersectors;
1062
    if      (scene->device->tri_traverser_mb == "default") intersectors = BVH4Triangle4iMBIntersectors(accel,ivariant);
1063
    else if (scene->device->tri_traverser_mb == "fast"   ) intersectors = BVH4Triangle4iMBIntersectors(accel,IntersectVariant::FAST);
1064
    else if (scene->device->tri_traverser_mb == "robust" ) intersectors = BVH4Triangle4iMBIntersectors(accel,IntersectVariant::ROBUST);
1065
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser_mb+" for BVH4<Triangle4iMB>");
1066

1067
    Builder* builder = nullptr;
1068
    if (scene->device->tri_builder_mb == "default") {
1069
      switch (bvariant) {
1070
      case BuildVariant::STATIC      : builder = BVH4Triangle4iMBSceneBuilderSAH(accel,scene,0); break;
1071
      case BuildVariant::DYNAMIC     : assert(false); break; // FIXME: implement
1072
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1073
      }
1074
    }
1075
    else  if (scene->device->tri_builder_mb == "internal_time_splits") builder = BVH4Triangle4iMBSceneBuilderSAH(accel,scene,0);
1076
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder_mb+" for BVH4<Triangle4iMB>");
1077

1078
    return new AccelInstance(accel,builder,intersectors);
1079
  }
1080

1081
  Accel* BVH4Factory::BVH4Triangle4vMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1082
  {
1083
    BVH4* accel = new BVH4(Triangle4vMB::type,scene);
1084

1085
    Accel::Intersectors intersectors;
1086
    if      (scene->device->tri_traverser_mb == "default") intersectors = BVH4Triangle4vMBIntersectors(accel,ivariant);
1087
    else if (scene->device->tri_traverser_mb == "fast"   ) intersectors = BVH4Triangle4vMBIntersectors(accel,IntersectVariant::FAST);
1088
    else if (scene->device->tri_traverser_mb == "robust" ) intersectors = BVH4Triangle4vMBIntersectors(accel,IntersectVariant::ROBUST);
1089
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser_mb+" for BVH4<Triangle4vMB>");
1090

1091
    Builder* builder = nullptr;
1092
    if (scene->device->tri_builder_mb == "default") {
1093
      switch (bvariant) {
1094
      case BuildVariant::STATIC      : builder = BVH4Triangle4vMBSceneBuilderSAH(accel,scene,0); break;
1095
      case BuildVariant::DYNAMIC     : assert(false); break; // FIXME: implement
1096
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1097
      }
1098
    }
1099
    else  if (scene->device->tri_builder_mb == "internal_time_splits") builder = BVH4Triangle4vMBSceneBuilderSAH(accel,scene,0);
1100
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder_mb+" for BVH4<Triangle4vMB>");
1101

1102
    return new AccelInstance(accel,builder,intersectors);
1103
  }
1104

1105
  Accel* BVH4Factory::BVH4Quad4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1106
  {
1107
    BVH4* accel = new BVH4(Quad4v::type,scene);
1108
    Accel::Intersectors intersectors = BVH4Quad4vIntersectors(accel,ivariant);
1109

1110
    Builder* builder = nullptr;
1111
    if (scene->device->quad_builder == "default") {
1112
      switch (bvariant) {
1113
      case BuildVariant::STATIC      : builder = BVH4Quad4vSceneBuilderSAH(accel,scene,0); break;
1114
      case BuildVariant::DYNAMIC     : builder = BVH4BuilderTwoLevelQuadMeshSAH(accel,scene,false); break;
1115
      case BuildVariant::HIGH_QUALITY: builder = BVH4Quad4vSceneBuilderFastSpatialSAH(accel,scene,0); break;
1116
      }
1117
    }
1118
    else if (scene->device->quad_builder == "sah"              ) builder = BVH4Quad4vSceneBuilderSAH(accel,scene,0);
1119
    else if (scene->device->quad_builder == "sah_fast_spatial" ) builder = BVH4Quad4vSceneBuilderFastSpatialSAH(accel,scene,0);
1120
    else if (scene->device->quad_builder == "dynamic"          ) builder = BVH4BuilderTwoLevelQuadMeshSAH(accel,scene,false);
1121
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder+" for BVH4<Quad4v>");
1122

1123
    return new AccelInstance(accel,builder,intersectors);
1124
  }
1125

1126
  Accel* BVH4Factory::BVH4Quad4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1127
  {
1128
    BVH4* accel = new BVH4(Quad4i::type,scene);
1129
    Accel::Intersectors intersectors = BVH4Quad4iIntersectors(accel,ivariant);
1130

1131
    Builder* builder = nullptr;
1132
    if (scene->device->quad_builder == "default") {
1133
      switch (bvariant) {
1134
      case BuildVariant::STATIC      : builder = BVH4Quad4iSceneBuilderSAH(accel,scene,0); break;
1135
      case BuildVariant::DYNAMIC     : assert(false); break; // FIXME: implement
1136
      case BuildVariant::HIGH_QUALITY: assert(false); break; // FIXME: implement
1137
      }
1138
    }
1139
    else if (scene->device->quad_builder == "sah") builder = BVH4Quad4iSceneBuilderSAH(accel,scene,0);
1140
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder+" for BVH4<Quad4i>");
1141

1142
    return new AccelInstance(accel,builder,intersectors);
1143
  }
1144

1145
  Accel* BVH4Factory::BVH4Quad4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1146
  {
1147
    BVH4* accel = new BVH4(Quad4i::type,scene);
1148
    Accel::Intersectors intersectors = BVH4Quad4iMBIntersectors(accel,ivariant);
1149

1150
    Builder* builder = nullptr;
1151
    if (scene->device->quad_builder_mb == "default") {
1152
      switch (bvariant) {
1153
      case BuildVariant::STATIC      : builder = BVH4Quad4iMBSceneBuilderSAH(accel,scene,0); break;
1154
      case BuildVariant::DYNAMIC     : assert(false); break; // FIXME: implement
1155
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1156
      }
1157
    }
1158
    else if (scene->device->quad_builder_mb == "sah") builder = BVH4Quad4iMBSceneBuilderSAH(accel,scene,0);
1159
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder_mb+" for BVH4<Quad4iMB>");
1160

1161
    return new AccelInstance(accel,builder,intersectors);
1162
  }
1163

1164
  Accel* BVH4Factory::BVH4QuantizedQuad4i(Scene* scene)
1165
  {
1166
    BVH4* accel = new BVH4(Quad4i::type,scene);
1167
    Builder* builder = BVH4QuantizedQuad4iSceneBuilderSAH(accel,scene,0);
1168
    Accel::Intersectors intersectors = QBVH4Quad4iIntersectors(accel);
1169
    return new AccelInstance(accel,builder,intersectors);
1170
  }
1171

1172
  Accel* BVH4Factory::BVH4QuantizedTriangle4i(Scene* scene)
1173
  {
1174
    BVH4* accel = new BVH4(Triangle4i::type,scene);
1175
    Builder* builder = BVH4QuantizedTriangle4iSceneBuilderSAH(accel,scene,0);
1176
    Accel::Intersectors intersectors = QBVH4Triangle4iIntersectors(accel);
1177
    return new AccelInstance(accel,builder,intersectors);
1178
  }
1179

1180
  Accel* BVH4Factory::BVH4SubdivPatch1(Scene* scene)
1181
  {
1182
    BVH4* accel = new BVH4(SubdivPatch1::type,scene);
1183
    Accel::Intersectors intersectors = BVH4SubdivPatch1Intersectors(accel);
1184
    Builder* builder = BVH4SubdivPatch1BuilderSAH(accel,scene,0);
1185
    return new AccelInstance(accel,builder,intersectors);
1186
  }
1187

1188
  Accel* BVH4Factory::BVH4SubdivPatch1MB(Scene* scene)
1189
  {
1190
    BVH4* accel = new BVH4(SubdivPatch1::type,scene);
1191
    Accel::Intersectors intersectors = BVH4SubdivPatch1MBIntersectors(accel);
1192
    Builder* builder = BVH4SubdivPatch1MBBuilderSAH(accel,scene,0);
1193
    return new AccelInstance(accel,builder,intersectors);
1194
  }
1195

1196
  Accel* BVH4Factory::BVH4UserGeometry(Scene* scene, BuildVariant bvariant)
1197
  {
1198
    BVH4* accel = new BVH4(Object::type,scene);
1199
    Accel::Intersectors intersectors = BVH4UserGeometryIntersectors(accel);
1200

1201
    Builder* builder = nullptr;
1202
    if (scene->device->object_builder == "default") {
1203
      switch (bvariant) {
1204
      case BuildVariant::STATIC      : builder = BVH4VirtualSceneBuilderSAH(accel,scene,0); break;
1205
      case BuildVariant::DYNAMIC     : builder = BVH4BuilderTwoLevelVirtualSAH(accel,scene,false); break;
1206
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1207
      }
1208
    }
1209
    else if (scene->device->object_builder == "sah") builder = BVH4VirtualSceneBuilderSAH(accel,scene,0);
1210
    else if (scene->device->object_builder == "dynamic") builder = BVH4BuilderTwoLevelVirtualSAH(accel,scene,false);
1211
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH4<Object>");
1212

1213
    return new AccelInstance(accel,builder,intersectors);
1214
  }
1215

1216
  Accel* BVH4Factory::BVH4UserGeometryMB(Scene* scene)
1217
  {
1218
    BVH4* accel = new BVH4(Object::type,scene);
1219
    Accel::Intersectors intersectors = BVH4UserGeometryMBIntersectors(accel);
1220
    Builder* builder = BVH4VirtualMBSceneBuilderSAH(accel,scene,0);
1221
    return new AccelInstance(accel,builder,intersectors);
1222
  }
1223

1224
  Accel* BVH4Factory::BVH4Instance(Scene* scene, bool isExpensive, BuildVariant bvariant)
1225
  {
1226
    BVH4* accel = new BVH4(InstancePrimitive::type,scene);
1227
    Accel::Intersectors intersectors = BVH4InstanceIntersectors(accel);
1228
    auto gtype = isExpensive ? Geometry::MTY_INSTANCE_EXPENSIVE : Geometry::MTY_INSTANCE_CHEAP;
1229
    // Builder* builder = BVH4InstanceSceneBuilderSAH(accel,scene,gtype);
1230

1231
    Builder* builder = nullptr;
1232
    if (scene->device->object_builder == "default") {
1233
      switch (bvariant) {
1234
      case BuildVariant::STATIC      : builder = BVH4InstanceSceneBuilderSAH(accel,scene,gtype); break;
1235
      case BuildVariant::DYNAMIC     : builder = BVH4BuilderTwoLevelInstanceSAH(accel,scene,gtype,false); break;
1236
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1237
      }
1238
    }
1239
    else if (scene->device->object_builder == "sah") builder = BVH4InstanceSceneBuilderSAH(accel,scene,gtype);
1240
    else if (scene->device->object_builder == "dynamic") builder = BVH4BuilderTwoLevelInstanceSAH(accel,scene,gtype,false);
1241
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH4<Object>");
1242

1243
    return new AccelInstance(accel,builder,intersectors);
1244
  }
1245

1246
  Accel* BVH4Factory::BVH4InstanceMB(Scene* scene, bool isExpensive)
1247
  {
1248
    BVH4* accel = new BVH4(InstancePrimitive::type,scene);
1249
    Accel::Intersectors intersectors = BVH4InstanceMBIntersectors(accel);
1250
    auto gtype = isExpensive ? Geometry::MTY_INSTANCE_EXPENSIVE : Geometry::MTY_INSTANCE_CHEAP;
1251
    Builder* builder = BVH4InstanceMBSceneBuilderSAH(accel,scene,gtype);
1252
    return new AccelInstance(accel,builder,intersectors);
1253
  }
1254

1255
  Accel* BVH4Factory::BVH4InstanceArray(Scene* scene, BuildVariant bvariant)
1256
  {
1257
    BVH4* accel = new BVH4(InstanceArrayPrimitive::type,scene);
1258
    Accel::Intersectors intersectors = BVH4InstanceArrayIntersectors(accel);
1259
    auto gtype = Geometry::MTY_INSTANCE_ARRAY;
1260

1261
    Builder* builder = nullptr;
1262
    if (scene->device->object_builder == "default") {
1263
      switch (bvariant) {
1264
      case BuildVariant::STATIC      : builder = BVH4InstanceArraySceneBuilderSAH(accel,scene,gtype); break;
1265
      case BuildVariant::DYNAMIC     : builder = BVH4BuilderTwoLevelInstanceArraySAH(accel,scene,gtype,false); break;
1266
      case BuildVariant::HIGH_QUALITY: assert(false); break;
1267
      }
1268
    }
1269
    else if (scene->device->object_builder == "sah") { builder = BVH4InstanceArraySceneBuilderSAH(accel,scene,gtype); }
1270
    else if (scene->device->object_builder == "dynamic") { builder = BVH4BuilderTwoLevelInstanceArraySAH(accel,scene,gtype,false); }
1271
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH4<Object>");
1272

1273
    return new AccelInstance(accel,builder,intersectors);
1274
  }
1275

1276
  Accel* BVH4Factory::BVH4InstanceArrayMB(Scene* scene)
1277
  {
1278
    BVH4* accel = new BVH4(InstanceArrayPrimitive::type,scene);
1279
    Accel::Intersectors intersectors = BVH4InstanceArrayMBIntersectors(accel);
1280
    Builder* builder = BVH4InstanceArrayMBSceneBuilderSAH(accel,scene,Geometry::MTY_INSTANCE_ARRAY);
1281
    return new AccelInstance(accel,builder,intersectors);
1282
  }
1283

1284
  Accel::Intersectors BVH4Factory::BVH4GridIntersectors(BVH4* bvh, IntersectVariant ivariant)
1285
  {
1286
    Accel::Intersectors intersectors;
1287
    intersectors.ptr = bvh;
1288
    if (ivariant == IntersectVariant::FAST)
1289
    {
1290
      intersectors.intersector1  = BVH4GridIntersector1Moeller();
1291
#if defined (EMBREE_RAY_PACKETS)
1292
      intersectors.intersector4  = BVH4GridIntersector4HybridMoeller();
1293
      intersectors.intersector8  = BVH4GridIntersector8HybridMoeller();
1294
      intersectors.intersector16 = BVH4GridIntersector16HybridMoeller();
1295
#endif
1296
    }
1297
    else /* if (ivariant == IntersectVariant::ROBUST) */
1298
    {
1299
      intersectors.intersector1  = BVH4GridIntersector1Pluecker();
1300
#if defined (EMBREE_RAY_PACKETS)
1301
      intersectors.intersector4  = BVH4GridIntersector4HybridPluecker();
1302
      intersectors.intersector8  = BVH4GridIntersector8HybridPluecker();
1303
      intersectors.intersector16 = BVH4GridIntersector16HybridPluecker();
1304
#endif      
1305
    }
1306
    return intersectors;
1307
  }
1308

1309
  Accel::Intersectors BVH4Factory::BVH4GridMBIntersectors(BVH4* bvh, IntersectVariant ivariant)
1310
  {
1311
    Accel::Intersectors intersectors;
1312
    intersectors.ptr = bvh;
1313
    intersectors.intersector1  = BVH4GridMBIntersector1Moeller();
1314
#if defined (EMBREE_RAY_PACKETS)
1315
    intersectors.intersector4  = BVH4GridMBIntersector4HybridMoeller();
1316
    intersectors.intersector8  = BVH4GridMBIntersector8HybridMoeller();
1317
    intersectors.intersector16 = BVH4GridMBIntersector16HybridMoeller();
1318
#endif
1319
    return intersectors;
1320
  }
1321

1322
  Accel* BVH4Factory::BVH4Grid(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1323
  {
1324
    BVH4* accel = new BVH4(SubGridQBVH4::type,scene);
1325
    Accel::Intersectors intersectors = BVH4GridIntersectors(accel,ivariant);
1326

1327
    Builder* builder = nullptr;
1328
    if (scene->device->object_builder == "default") {
1329
      builder = BVH4GridSceneBuilderSAH(accel,scene,0);
1330
    }
1331
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->grid_builder+" for BVH4<GridMesh>");
1332
    
1333
    return new AccelInstance(accel,builder,intersectors);    
1334
  }
1335

1336
  Accel* BVH4Factory::BVH4GridMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1337
  {
1338
    BVH4* accel = new BVH4(SubGridQBVH4::type,scene);
1339
    Accel::Intersectors intersectors = BVH4GridMBIntersectors(accel,ivariant);
1340
    Builder* builder = nullptr;
1341
    if (scene->device->object_builder == "default") {
1342
      builder = BVH4GridMBSceneBuilderSAH(accel,scene,0);
1343
    }
1344
    else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->grid_builder+" for BVH4MB<GridMesh>");
1345
    return new AccelInstance(accel,builder,intersectors);        
1346
  }
1347

1348
}
1349

1350
Product

Resources

Company
