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/subgrid.h"
21#include "../common/accelinstance.h"
22
23namespace embree
24{
25 DECLARE_SYMBOL2(Accel::Collider,BVH4ColliderUserGeom);
26
27 DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector4i,void);
28 DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector8i,void);
29 DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector4v,void);
30 DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector8v,void);
31 DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector4iMB,void);
32 DECLARE_ISA_FUNCTION(VirtualCurveIntersector*,VirtualCurveIntersector8iMB,void);
33
34 DECLARE_SYMBOL2(Accel::Intersector1,BVH4OBBVirtualCurveIntersector1);
35 DECLARE_SYMBOL2(Accel::Intersector1,BVH4OBBVirtualCurveIntersector1MB);
36 DECLARE_SYMBOL2(Accel::Intersector1,BVH4OBBVirtualCurveIntersectorRobust1);
37 DECLARE_SYMBOL2(Accel::Intersector1,BVH4OBBVirtualCurveIntersectorRobust1MB);
38
39 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4Intersector1Moeller);
40 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4iIntersector1Moeller);
41 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4vIntersector1Pluecker);
42 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4iIntersector1Pluecker);
43
44 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4vMBIntersector1Moeller);
45 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4iMBIntersector1Moeller);
46 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4vMBIntersector1Pluecker);
47 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Triangle4iMBIntersector1Pluecker);
48
49 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4vIntersector1Moeller);
50 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4iIntersector1Moeller);
51 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4vIntersector1Pluecker);
52 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4iIntersector1Pluecker);
53
54 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4iMBIntersector1Moeller);
55 DECLARE_SYMBOL2(Accel::Intersector1,BVH4Quad4iMBIntersector1Pluecker);
56
57 DECLARE_SYMBOL2(Accel::Intersector1,QBVH4Triangle4iIntersector1Pluecker);
58 DECLARE_SYMBOL2(Accel::Intersector1,QBVH4Quad4iIntersector1Pluecker);
59
60 DECLARE_SYMBOL2(Accel::Intersector1,BVH4SubdivPatch1Intersector1);
61 DECLARE_SYMBOL2(Accel::Intersector1,BVH4SubdivPatch1MBIntersector1);
62
63 DECLARE_SYMBOL2(Accel::Intersector1,BVH4VirtualIntersector1);
64 DECLARE_SYMBOL2(Accel::Intersector1,BVH4VirtualMBIntersector1);
65
66 DECLARE_SYMBOL2(Accel::Intersector1,BVH4InstanceIntersector1);
67 DECLARE_SYMBOL2(Accel::Intersector1,BVH4InstanceMBIntersector1);
68
69 DECLARE_SYMBOL2(Accel::Intersector1,BVH4GridIntersector1Moeller);
70 DECLARE_SYMBOL2(Accel::Intersector1,BVH4GridMBIntersector1Moeller);
71 DECLARE_SYMBOL2(Accel::Intersector1,BVH4GridIntersector1Pluecker);
72
73 DECLARE_SYMBOL2(Accel::Intersector4,BVH4OBBVirtualCurveIntersector4Hybrid);
74 DECLARE_SYMBOL2(Accel::Intersector4,BVH4OBBVirtualCurveIntersector4HybridMB);
75 DECLARE_SYMBOL2(Accel::Intersector4,BVH4OBBVirtualCurveIntersectorRobust4Hybrid);
76 DECLARE_SYMBOL2(Accel::Intersector4,BVH4OBBVirtualCurveIntersectorRobust4HybridMB);
77
78 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4Intersector4HybridMoeller);
79 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4Intersector4HybridMoellerNoFilter);
80 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4iIntersector4HybridMoeller);
81 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4vIntersector4HybridPluecker);
82 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4iIntersector4HybridPluecker);
83
84 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4vMBIntersector4HybridMoeller);
85 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4iMBIntersector4HybridMoeller);
86 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4vMBIntersector4HybridPluecker);
87 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Triangle4iMBIntersector4HybridPluecker);
88
89 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4vIntersector4HybridMoeller);
90 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4vIntersector4HybridMoellerNoFilter);
91 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4iIntersector4HybridMoeller);
92 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4vIntersector4HybridPluecker);
93 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4iIntersector4HybridPluecker);
94
95 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4iMBIntersector4HybridMoeller);
96 DECLARE_SYMBOL2(Accel::Intersector4,BVH4Quad4iMBIntersector4HybridPluecker);
97
98 DECLARE_SYMBOL2(Accel::Intersector4,BVH4SubdivPatch1Intersector4);
99 DECLARE_SYMBOL2(Accel::Intersector4,BVH4SubdivPatch1MBIntersector4);
100
101 DECLARE_SYMBOL2(Accel::Intersector4,BVH4VirtualIntersector4Chunk);
102 DECLARE_SYMBOL2(Accel::Intersector4,BVH4VirtualMBIntersector4Chunk);
103
104 DECLARE_SYMBOL2(Accel::Intersector4,BVH4InstanceIntersector4Chunk);
105 DECLARE_SYMBOL2(Accel::Intersector4,BVH4InstanceMBIntersector4Chunk);
106
107 DECLARE_SYMBOL2(Accel::Intersector4,BVH4GridIntersector4HybridMoeller);
108 DECLARE_SYMBOL2(Accel::Intersector4,BVH4GridMBIntersector4HybridMoeller);
109 DECLARE_SYMBOL2(Accel::Intersector4,BVH4GridIntersector4HybridPluecker);
110
111 DECLARE_SYMBOL2(Accel::Intersector8,BVH4OBBVirtualCurveIntersector8Hybrid);
112 DECLARE_SYMBOL2(Accel::Intersector8,BVH4OBBVirtualCurveIntersector8HybridMB);
113 DECLARE_SYMBOL2(Accel::Intersector8,BVH4OBBVirtualCurveIntersectorRobust8Hybrid);
114 DECLARE_SYMBOL2(Accel::Intersector8,BVH4OBBVirtualCurveIntersectorRobust8HybridMB);
115
116 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4Intersector8HybridMoeller);
117 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4Intersector8HybridMoellerNoFilter);
118 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4iIntersector8HybridMoeller);
119 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4vIntersector8HybridPluecker);
120 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4iIntersector8HybridPluecker);
121
122 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4vMBIntersector8HybridMoeller);
123 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4iMBIntersector8HybridMoeller);
124 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4vMBIntersector8HybridPluecker);
125 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Triangle4iMBIntersector8HybridPluecker);
126
127 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4vIntersector8HybridMoeller);
128 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4vIntersector8HybridMoellerNoFilter);
129 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4iIntersector8HybridMoeller);
130 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4vIntersector8HybridPluecker);
131 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4iIntersector8HybridPluecker);
132
133 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4iMBIntersector8HybridMoeller);
134 DECLARE_SYMBOL2(Accel::Intersector8,BVH4Quad4iMBIntersector8HybridPluecker);
135
136 DECLARE_SYMBOL2(Accel::Intersector8,BVH4SubdivPatch1Intersector8);
137 DECLARE_SYMBOL2(Accel::Intersector8,BVH4SubdivPatch1MBIntersector8);
138
139 DECLARE_SYMBOL2(Accel::Intersector8,BVH4VirtualIntersector8Chunk);
140 DECLARE_SYMBOL2(Accel::Intersector8,BVH4VirtualMBIntersector8Chunk);
141
142 DECLARE_SYMBOL2(Accel::Intersector8,BVH4InstanceIntersector8Chunk);
143 DECLARE_SYMBOL2(Accel::Intersector8,BVH4InstanceMBIntersector8Chunk);
144
145 DECLARE_SYMBOL2(Accel::Intersector8,BVH4GridIntersector8HybridMoeller);
146 DECLARE_SYMBOL2(Accel::Intersector8,BVH4GridMBIntersector8HybridMoeller);
147 DECLARE_SYMBOL2(Accel::Intersector8,BVH4GridIntersector8HybridPluecker);
148
149 DECLARE_SYMBOL2(Accel::Intersector16,BVH4OBBVirtualCurveIntersector16Hybrid);
150 DECLARE_SYMBOL2(Accel::Intersector16,BVH4OBBVirtualCurveIntersector16HybridMB);
151 DECLARE_SYMBOL2(Accel::Intersector16,BVH4OBBVirtualCurveIntersectorRobust16Hybrid);
152 DECLARE_SYMBOL2(Accel::Intersector16,BVH4OBBVirtualCurveIntersectorRobust16HybridMB);
153
154 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4Intersector16HybridMoeller);
155 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4Intersector16HybridMoellerNoFilter);
156 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4iIntersector16HybridMoeller);
157 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4vIntersector16HybridPluecker);
158 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4iIntersector16HybridPluecker);
159
160 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4vMBIntersector16HybridMoeller);
161 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4iMBIntersector16HybridMoeller);
162 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4vMBIntersector16HybridPluecker);
163 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Triangle4iMBIntersector16HybridPluecker);
164
165 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4vIntersector16HybridMoeller);
166 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4vIntersector16HybridMoellerNoFilter);
167 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4iIntersector16HybridMoeller);
168 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4vIntersector16HybridPluecker);
169 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4iIntersector16HybridPluecker);
170
171 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4iMBIntersector16HybridMoeller);
172 DECLARE_SYMBOL2(Accel::Intersector16,BVH4Quad4iMBIntersector16HybridPluecker);
173
174 DECLARE_SYMBOL2(Accel::Intersector16,BVH4SubdivPatch1Intersector16);
175 DECLARE_SYMBOL2(Accel::Intersector16,BVH4SubdivPatch1MBIntersector16);
176
177 DECLARE_SYMBOL2(Accel::Intersector16,BVH4VirtualIntersector16Chunk);
178 DECLARE_SYMBOL2(Accel::Intersector16,BVH4VirtualMBIntersector16Chunk);
179
180 DECLARE_SYMBOL2(Accel::Intersector16,BVH4InstanceIntersector16Chunk);
181 DECLARE_SYMBOL2(Accel::Intersector16,BVH4InstanceMBIntersector16Chunk);
182
183 DECLARE_SYMBOL2(Accel::Intersector16,BVH4GridIntersector16HybridMoeller);
184 DECLARE_SYMBOL2(Accel::Intersector16,BVH4GridMBIntersector16HybridMoeller);
185 DECLARE_SYMBOL2(Accel::Intersector16,BVH4GridIntersector16HybridPluecker);
186
187 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4IntersectorStreamPacketFallback);
188
189 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Triangle4IntersectorStreamMoeller);
190 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Triangle4IntersectorStreamMoellerNoFilter);
191 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Triangle4iIntersectorStreamMoeller);
192 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Triangle4vIntersectorStreamPluecker);
193 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Triangle4iIntersectorStreamPluecker);
194
195 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Quad4vIntersectorStreamMoeller);
196 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Quad4vIntersectorStreamMoellerNoFilter);
197 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Quad4iIntersectorStreamMoeller);
198 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Quad4vIntersectorStreamPluecker);
199 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4Quad4iIntersectorStreamPluecker);
200
201 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4VirtualIntersectorStream);
202 DECLARE_SYMBOL2(Accel::IntersectorN,BVH4InstanceIntersectorStream);
203
204 DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelTriangle4MeshSAH,void* COMMA Scene* COMMA bool);
205 DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelTriangle4vMeshSAH,void* COMMA Scene* COMMA bool);
206 DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelTriangle4iMeshSAH,void* COMMA Scene* COMMA bool);
207 DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelQuadMeshSAH,void* COMMA Scene* COMMA bool);
208 DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelVirtualSAH,void* COMMA Scene* COMMA bool);
209 DECLARE_ISA_FUNCTION(Builder*,BVH4BuilderTwoLevelInstanceSAH,void* COMMA Scene* COMMA Geometry::GTypeMask COMMA bool);
210
211 DECLARE_ISA_FUNCTION(Builder*,BVH4Curve4vBuilder_OBB_New,void* COMMA Scene* COMMA size_t);
212 DECLARE_ISA_FUNCTION(Builder*,BVH4Curve4iBuilder_OBB_New,void* COMMA Scene* COMMA size_t);
213 DECLARE_ISA_FUNCTION(Builder*,BVH4OBBCurve4iMBBuilder_OBB,void* COMMA Scene* COMMA size_t);
214 DECLARE_ISA_FUNCTION(Builder*,BVH4Curve8iBuilder_OBB_New,void* COMMA Scene* COMMA size_t);
215 DECLARE_ISA_FUNCTION(Builder*,BVH4OBBCurve8iMBBuilder_OBB,void* COMMA Scene* COMMA size_t);
216
217 DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4SceneBuilderSAH,void* COMMA Scene* COMMA size_t);
218 DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4vSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
219 DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
220 DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4iMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
221 DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4vMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
222 DECLARE_ISA_FUNCTION(Builder*,BVH4QuantizedTriangle4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
223
224 DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4vSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
225 DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
226 DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4iMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
227 DECLARE_ISA_FUNCTION(Builder*,BVH4QuantizedQuad4iSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
228
229 DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4SceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
230 DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4vSceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
231 DECLARE_ISA_FUNCTION(Builder*,BVH4Triangle4iSceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
232
233 DECLARE_ISA_FUNCTION(Builder*,BVH4Quad4vSceneBuilderFastSpatialSAH,void* COMMA Scene* COMMA size_t);
234
235 DECLARE_ISA_FUNCTION(Builder*,BVH4VirtualSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
236 DECLARE_ISA_FUNCTION(Builder*,BVH4VirtualMBSceneBuilderSAH,void* COMMA Scene* COMMA size_t);
237
238 DECLARE_ISA_FUNCTION(Builder*,BVH4InstanceSceneBuilderSAH,void* COMMA Scene* COMMA Geometry::GTypeMask);
239 DECLARE_ISA_FUNCTION(Builder*,BVH4InstanceMBSceneBuilderSAH,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(features: bfeatures);
258 selectIntersectors(features: 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
270 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Curve4vBuilder_OBB_New));
271 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Curve4iBuilder_OBB_New));
272 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4OBBCurve4iMBBuilder_OBB));
273 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX(features,BVH4Curve8iBuilder_OBB_New));
274 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX(features,BVH4OBBCurve8iMBBuilder_OBB));
275
276 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4SceneBuilderSAH));
277 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4vSceneBuilderSAH));
278 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4iSceneBuilderSAH));
279 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4iMBSceneBuilderSAH));
280 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4vMBSceneBuilderSAH));
281 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4QuantizedTriangle4iSceneBuilderSAH));
282
283 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Quad4vSceneBuilderSAH));
284 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Quad4iSceneBuilderSAH));
285 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Quad4iMBSceneBuilderSAH));
286 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4QuantizedQuad4iSceneBuilderSAH));
287
288 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4SceneBuilderFastSpatialSAH));
289 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4vSceneBuilderFastSpatialSAH));
290 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Triangle4iSceneBuilderFastSpatialSAH));
291
292 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4Quad4vSceneBuilderFastSpatialSAH));
293
294 IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4VirtualSceneBuilderSAH));
295 IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4VirtualMBSceneBuilderSAH));
296
297 IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4InstanceSceneBuilderSAH));
298 IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4InstanceMBSceneBuilderSAH));
299
300 IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4GridSceneBuilderSAH));
301 IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4GridMBSceneBuilderSAH));
302
303 IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4SubdivPatch1BuilderSAH));
304 IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_AVX(features,BVH4SubdivPatch1MBBuilderSAH));
305 }
306
307 void BVH4Factory::selectIntersectors(int features)
308 {
309 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,VirtualCurveIntersector4i));
310 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,VirtualCurveIntersector8i));
311 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,VirtualCurveIntersector4v));
312 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,VirtualCurveIntersector8v));
313 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,VirtualCurveIntersector4iMB));
314 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,VirtualCurveIntersector8iMB));
315
316 /* select intersectors1 */
317 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector1));
318 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector1MB));
319 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust1));
320 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust1MB));
321
322 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector1Moeller));
323 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,BVH4Triangle4iIntersector1Moeller));
324 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,BVH4Triangle4vIntersector1Pluecker));
325 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,BVH4Triangle4iIntersector1Pluecker));
326
327 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector1Moeller));
328 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector1Moeller));
329 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector1Pluecker));
330 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector1Pluecker));
331
332 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector1Moeller));
333 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector1Moeller));
334 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector1Pluecker));
335 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector1Pluecker));
336
337 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector1Pluecker));
338 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector1Moeller));
339
340 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,QBVH4Triangle4iIntersector1Pluecker));
341 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX512(features,QBVH4Quad4iIntersector1Pluecker));
342
343 IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4SubdivPatch1Intersector1));
344 IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4SubdivPatch1MBIntersector1));
345
346 IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualIntersector1));
347 IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualMBIntersector1));
348
349 IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceIntersector1));
350 IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceMBIntersector1));
351
352 IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridIntersector1Moeller));
353 IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridMBIntersector1Moeller))
354 IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridIntersector1Pluecker));
355
356#if defined (EMBREE_RAY_PACKETS)
357
358 /* select intersectors4 */
359 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector4Hybrid));
360 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector4HybridMB));
361 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust4Hybrid));
362 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_DEFAULT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust4HybridMB));
363
364 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector4HybridMoeller));
365 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector4HybridMoellerNoFilter));
366 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersector4HybridMoeller));
367 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vIntersector4HybridPluecker));
368 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersector4HybridPluecker));
369
370 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector4HybridMoeller));
371 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector4HybridMoeller));
372 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector4HybridPluecker));
373 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector4HybridPluecker));
374
375 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector4HybridMoeller));
376 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector4HybridMoellerNoFilter));
377 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector4HybridMoeller));
378 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector4HybridPluecker));
379 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector4HybridPluecker));
380
381 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector4HybridMoeller));
382 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector4HybridPluecker));
383
384 IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4SubdivPatch1Intersector4));
385 IF_ENABLED_SUBDIV(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4SubdivPatch1MBIntersector4));
386
387 IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualIntersector4Chunk));
388 IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualMBIntersector4Chunk));
389
390 IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceIntersector4Chunk));
391 IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceMBIntersector4Chunk));
392
393 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector4HybridMoeller));
394
395 IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridIntersector4HybridMoeller));
396 IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridMBIntersector4HybridMoeller));
397 IF_ENABLED_GRIDS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4GridIntersector4HybridPluecker));
398
399 /* select intersectors8 */
400 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector8Hybrid));
401 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersector8HybridMB));
402 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust8Hybrid));
403 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust8HybridMB));
404
405 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector8HybridMoeller));
406 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4Intersector8HybridMoellerNoFilter));
407 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersector8HybridMoeller));
408 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4vIntersector8HybridPluecker));
409 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersector8HybridPluecker));
410
411 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector8HybridMoeller));
412 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector8HybridMoeller));
413 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4vMBIntersector8HybridPluecker));
414 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Triangle4iMBIntersector8HybridPluecker));
415
416 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector8HybridMoeller));
417 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector8HybridMoellerNoFilter));
418 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector8HybridMoeller));
419 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4vIntersector8HybridPluecker));
420 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4iIntersector8HybridPluecker));
421
422 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector8HybridMoeller));
423 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4Quad4iMBIntersector8HybridPluecker));
424
425 IF_ENABLED_SUBDIV(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4SubdivPatch1Intersector8));
426 IF_ENABLED_SUBDIV(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4SubdivPatch1MBIntersector8));
427
428 IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4VirtualIntersector8Chunk));
429 IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4VirtualMBIntersector8Chunk));
430
431 IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4InstanceIntersector8Chunk));
432 IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4InstanceMBIntersector8Chunk));
433
434 IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4GridIntersector8HybridMoeller));
435 IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4GridMBIntersector8HybridMoeller));
436 IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX_AVX2_AVX512(features,BVH4GridIntersector8HybridPluecker));
437
438 /* select intersectors16 */
439 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH4OBBVirtualCurveIntersector16Hybrid));
440 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH4OBBVirtualCurveIntersector16HybridMB));
441 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust16Hybrid));
442 IF_ENABLED_CURVES_OR_POINTS(SELECT_SYMBOL_INIT_AVX512(features,BVH4OBBVirtualCurveIntersectorRobust16HybridMB));
443
444 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4Intersector16HybridMoeller));
445 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4Intersector16HybridMoellerNoFilter));
446 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4iIntersector16HybridMoeller));
447 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4vIntersector16HybridPluecker));
448 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4iIntersector16HybridPluecker));
449
450 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4vMBIntersector16HybridMoeller));
451 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4iMBIntersector16HybridMoeller));
452 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4vMBIntersector16HybridPluecker));
453 IF_ENABLED_TRIS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Triangle4iMBIntersector16HybridPluecker));
454
455 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4vIntersector16HybridMoeller));
456 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4vIntersector16HybridMoellerNoFilter));
457 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4iIntersector16HybridMoeller));
458 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4vIntersector16HybridPluecker));
459 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4iIntersector16HybridPluecker));
460
461 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4iMBIntersector16HybridMoeller));
462 IF_ENABLED_QUADS(SELECT_SYMBOL_INIT_AVX512(features,BVH4Quad4iMBIntersector16HybridPluecker));
463
464 IF_ENABLED_SUBDIV(SELECT_SYMBOL_INIT_AVX512(features,BVH4SubdivPatch1Intersector16));
465 IF_ENABLED_SUBDIV(SELECT_SYMBOL_INIT_AVX512(features,BVH4SubdivPatch1MBIntersector16));
466
467 IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX512(features,BVH4VirtualIntersector16Chunk));
468 IF_ENABLED_USER(SELECT_SYMBOL_INIT_AVX512(features,BVH4VirtualMBIntersector16Chunk));
469
470 IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX512(features,BVH4InstanceIntersector16Chunk));
471 IF_ENABLED_INSTANCE(SELECT_SYMBOL_INIT_AVX512(features,BVH4InstanceMBIntersector16Chunk));
472
473 IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX512(features,BVH4GridIntersector16HybridMoeller));
474 IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX512(features,BVH4GridMBIntersector16HybridMoeller));
475 IF_ENABLED_GRIDS(SELECT_SYMBOL_INIT_AVX512(features,BVH4GridIntersector16HybridPluecker));
476
477 /* select stream intersectors */
478 SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4IntersectorStreamPacketFallback);
479
480 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4IntersectorStreamMoeller));
481 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4IntersectorStreamMoellerNoFilter));
482 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersectorStreamMoeller));
483 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4vIntersectorStreamPluecker));
484 IF_ENABLED_TRIS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Triangle4iIntersectorStreamPluecker));
485
486 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersectorStreamMoeller));
487 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersectorStreamMoellerNoFilter));
488 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersectorStreamMoeller));
489 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4vIntersectorStreamPluecker));
490 IF_ENABLED_QUADS(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4Quad4iIntersectorStreamPluecker));
491
492 IF_ENABLED_USER(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4VirtualIntersectorStream));
493
494 IF_ENABLED_INSTANCE(SELECT_SYMBOL_DEFAULT_SSE42_AVX_AVX2_AVX512(features,BVH4InstanceIntersectorStream));
495
496#endif
497 }
498
499 Accel::Intersectors BVH4Factory::BVH4OBBVirtualCurveIntersectors(BVH4* bvh, VirtualCurveIntersector* leafIntersector, IntersectVariant ivariant)
500 {
501 switch (ivariant) {
502 case IntersectVariant::FAST:
503 {
504 Accel::Intersectors intersectors;
505 intersectors.ptr = bvh;
506 intersectors.leafIntersector = leafIntersector;
507 intersectors.intersector1 = BVH4OBBVirtualCurveIntersector1();
508#if defined (EMBREE_RAY_PACKETS)
509 intersectors.intersector4 = BVH4OBBVirtualCurveIntersector4Hybrid();
510 intersectors.intersector8 = BVH4OBBVirtualCurveIntersector8Hybrid();
511 intersectors.intersector16 = BVH4OBBVirtualCurveIntersector16Hybrid();
512 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
513#endif
514 return intersectors;
515 }
516 case IntersectVariant::ROBUST:
517 {
518 Accel::Intersectors intersectors;
519 intersectors.ptr = bvh;
520 intersectors.leafIntersector = leafIntersector;
521 intersectors.intersector1 = BVH4OBBVirtualCurveIntersectorRobust1();
522#if defined (EMBREE_RAY_PACKETS)
523 intersectors.intersector4 = BVH4OBBVirtualCurveIntersectorRobust4Hybrid();
524 intersectors.intersector8 = BVH4OBBVirtualCurveIntersectorRobust8Hybrid();
525 intersectors.intersector16 = BVH4OBBVirtualCurveIntersectorRobust16Hybrid();
526 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
527#endif
528 return intersectors;
529 }
530 default: assert(false);
531 }
532 return Accel::Intersectors();
533 }
534
535 Accel::Intersectors BVH4Factory::BVH4OBBVirtualCurveIntersectorsMB(BVH4* bvh, VirtualCurveIntersector* leafIntersector, IntersectVariant ivariant)
536 {
537 switch (ivariant) {
538 case IntersectVariant::FAST:
539 {
540 Accel::Intersectors intersectors;
541 intersectors.ptr = bvh;
542 intersectors.leafIntersector = leafIntersector;
543 intersectors.intersector1 = BVH4OBBVirtualCurveIntersector1MB();
544#if defined (EMBREE_RAY_PACKETS)
545 intersectors.intersector4 = BVH4OBBVirtualCurveIntersector4HybridMB();
546 intersectors.intersector8 = BVH4OBBVirtualCurveIntersector8HybridMB();
547 intersectors.intersector16 = BVH4OBBVirtualCurveIntersector16HybridMB();
548 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
549#endif
550 return intersectors;
551 }
552 case IntersectVariant::ROBUST:
553 {
554 Accel::Intersectors intersectors;
555 intersectors.ptr = bvh;
556 intersectors.leafIntersector = leafIntersector;
557 intersectors.intersector1 = BVH4OBBVirtualCurveIntersectorRobust1MB();
558#if defined (EMBREE_RAY_PACKETS)
559 intersectors.intersector4 = BVH4OBBVirtualCurveIntersectorRobust4HybridMB();
560 intersectors.intersector8 = BVH4OBBVirtualCurveIntersectorRobust8HybridMB();
561 intersectors.intersector16 = BVH4OBBVirtualCurveIntersectorRobust16HybridMB();
562 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
563#endif
564 return intersectors;
565 }
566 default: assert(false);
567 }
568 return Accel::Intersectors();
569 }
570
571 Accel::Intersectors BVH4Factory::BVH4Triangle4Intersectors(BVH4* bvh, IntersectVariant ivariant)
572 {
573 assert(ivariant == IntersectVariant::FAST);
574 Accel::Intersectors intersectors;
575 intersectors.ptr = bvh;
576 intersectors.intersector1 = BVH4Triangle4Intersector1Moeller();
577#if defined (EMBREE_RAY_PACKETS)
578 intersectors.intersector4_filter = BVH4Triangle4Intersector4HybridMoeller();
579 intersectors.intersector4_nofilter = BVH4Triangle4Intersector4HybridMoellerNoFilter();
580 intersectors.intersector8_filter = BVH4Triangle4Intersector8HybridMoeller();
581 intersectors.intersector8_nofilter = BVH4Triangle4Intersector8HybridMoellerNoFilter();
582 intersectors.intersector16_filter = BVH4Triangle4Intersector16HybridMoeller();
583 intersectors.intersector16_nofilter = BVH4Triangle4Intersector16HybridMoellerNoFilter();
584 intersectors.intersectorN_filter = BVH4Triangle4IntersectorStreamMoeller();
585 intersectors.intersectorN_nofilter = BVH4Triangle4IntersectorStreamMoellerNoFilter();
586#endif
587 return intersectors;
588 }
589
590 Accel::Intersectors BVH4Factory::BVH4Triangle4vIntersectors(BVH4* bvh, IntersectVariant ivariant)
591 {
592 assert(ivariant == IntersectVariant::ROBUST);
593 Accel::Intersectors intersectors;
594 intersectors.ptr = bvh;
595 intersectors.intersector1 = BVH4Triangle4vIntersector1Pluecker();
596#if defined (EMBREE_RAY_PACKETS)
597 intersectors.intersector4 = BVH4Triangle4vIntersector4HybridPluecker();
598 intersectors.intersector8 = BVH4Triangle4vIntersector8HybridPluecker();
599 intersectors.intersector16 = BVH4Triangle4vIntersector16HybridPluecker();
600 intersectors.intersectorN = BVH4Triangle4vIntersectorStreamPluecker();
601#endif
602 return intersectors;
603 }
604
605 Accel::Intersectors BVH4Factory::BVH4Triangle4iIntersectors(BVH4* bvh, IntersectVariant ivariant)
606 {
607 switch (ivariant) {
608 case IntersectVariant::FAST:
609 {
610 Accel::Intersectors intersectors;
611 intersectors.ptr = bvh;
612 intersectors.intersector1 = BVH4Triangle4iIntersector1Moeller();
613#if defined (EMBREE_RAY_PACKETS)
614 intersectors.intersector4 = BVH4Triangle4iIntersector4HybridMoeller();
615 intersectors.intersector8 = BVH4Triangle4iIntersector8HybridMoeller();
616 intersectors.intersector16 = BVH4Triangle4iIntersector16HybridMoeller();
617 intersectors.intersectorN = BVH4Triangle4iIntersectorStreamMoeller();
618#endif
619 return intersectors;
620 }
621 case IntersectVariant::ROBUST:
622 {
623 Accel::Intersectors intersectors;
624 intersectors.ptr = bvh;
625 intersectors.intersector1 = BVH4Triangle4iIntersector1Pluecker();
626#if defined (EMBREE_RAY_PACKETS)
627 intersectors.intersector4 = BVH4Triangle4iIntersector4HybridPluecker();
628 intersectors.intersector8 = BVH4Triangle4iIntersector8HybridPluecker();
629 intersectors.intersector16 = BVH4Triangle4iIntersector16HybridPluecker();
630 intersectors.intersectorN = BVH4Triangle4iIntersectorStreamPluecker();
631#endif
632 return intersectors;
633 }
634 }
635 return Accel::Intersectors();
636 }
637
638 Accel::Intersectors BVH4Factory::BVH4Triangle4vMBIntersectors(BVH4* bvh, IntersectVariant ivariant)
639 {
640 switch (ivariant) {
641 case IntersectVariant::FAST:
642 {
643 Accel::Intersectors intersectors;
644 intersectors.ptr = bvh;
645 intersectors.intersector1 = BVH4Triangle4vMBIntersector1Moeller();
646#if defined (EMBREE_RAY_PACKETS)
647 intersectors.intersector4 = BVH4Triangle4vMBIntersector4HybridMoeller();
648 intersectors.intersector8 = BVH4Triangle4vMBIntersector8HybridMoeller();
649 intersectors.intersector16 = BVH4Triangle4vMBIntersector16HybridMoeller();
650 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
651#endif
652 return intersectors;
653 }
654 case IntersectVariant::ROBUST:
655 {
656 Accel::Intersectors intersectors;
657 intersectors.ptr = bvh;
658 intersectors.intersector1 = BVH4Triangle4vMBIntersector1Pluecker();
659#if defined (EMBREE_RAY_PACKETS)
660 intersectors.intersector4 = BVH4Triangle4vMBIntersector4HybridPluecker();
661 intersectors.intersector8 = BVH4Triangle4vMBIntersector8HybridPluecker();
662 intersectors.intersector16 = BVH4Triangle4vMBIntersector16HybridPluecker();
663 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
664#endif
665 return intersectors;
666 }
667 }
668 return Accel::Intersectors();
669 }
670
671 Accel::Intersectors BVH4Factory::BVH4Triangle4iMBIntersectors(BVH4* bvh, IntersectVariant ivariant)
672 {
673 switch (ivariant) {
674 case IntersectVariant::FAST:
675 {
676 Accel::Intersectors intersectors;
677 intersectors.ptr = bvh;
678 intersectors.intersector1 = BVH4Triangle4iMBIntersector1Moeller();
679#if defined (EMBREE_RAY_PACKETS)
680 intersectors.intersector4 = BVH4Triangle4iMBIntersector4HybridMoeller();
681 intersectors.intersector8 = BVH4Triangle4iMBIntersector8HybridMoeller();
682 intersectors.intersector16 = BVH4Triangle4iMBIntersector16HybridMoeller();
683 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
684#endif
685 return intersectors;
686 }
687 case IntersectVariant::ROBUST:
688 {
689 Accel::Intersectors intersectors;
690 intersectors.ptr = bvh;
691 intersectors.intersector1 = BVH4Triangle4iMBIntersector1Pluecker();
692#if defined (EMBREE_RAY_PACKETS)
693 intersectors.intersector4 = BVH4Triangle4iMBIntersector4HybridPluecker();
694 intersectors.intersector8 = BVH4Triangle4iMBIntersector8HybridPluecker();
695 intersectors.intersector16 = BVH4Triangle4iMBIntersector16HybridPluecker();
696 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
697#endif
698 return intersectors;
699 }
700 }
701 return Accel::Intersectors();
702 }
703
704 Accel::Intersectors BVH4Factory::BVH4Quad4vIntersectors(BVH4* bvh, IntersectVariant ivariant)
705 {
706 switch (ivariant) {
707 case IntersectVariant::FAST:
708 {
709 Accel::Intersectors intersectors;
710 intersectors.ptr = bvh;
711 intersectors.intersector1 = BVH4Quad4vIntersector1Moeller();
712#if defined (EMBREE_RAY_PACKETS)
713 intersectors.intersector4_filter = BVH4Quad4vIntersector4HybridMoeller();
714 intersectors.intersector4_nofilter = BVH4Quad4vIntersector4HybridMoellerNoFilter();
715 intersectors.intersector8_filter = BVH4Quad4vIntersector8HybridMoeller();
716 intersectors.intersector8_nofilter = BVH4Quad4vIntersector8HybridMoellerNoFilter();
717 intersectors.intersector16_filter = BVH4Quad4vIntersector16HybridMoeller();
718 intersectors.intersector16_nofilter = BVH4Quad4vIntersector16HybridMoellerNoFilter();
719 intersectors.intersectorN_filter = BVH4Quad4vIntersectorStreamMoeller();
720 intersectors.intersectorN_nofilter = BVH4Quad4vIntersectorStreamMoellerNoFilter();
721#endif
722 return intersectors;
723 }
724 case IntersectVariant::ROBUST:
725 {
726 Accel::Intersectors intersectors;
727 intersectors.ptr = bvh;
728 intersectors.intersector1 = BVH4Quad4vIntersector1Pluecker();
729#if defined (EMBREE_RAY_PACKETS)
730 intersectors.intersector4 = BVH4Quad4vIntersector4HybridPluecker();
731 intersectors.intersector8 = BVH4Quad4vIntersector8HybridPluecker();
732 intersectors.intersector16 = BVH4Quad4vIntersector16HybridPluecker();
733 intersectors.intersectorN = BVH4Quad4vIntersectorStreamPluecker();
734#endif
735 return intersectors;
736 }
737 }
738 return Accel::Intersectors();
739 }
740
741 Accel::Intersectors BVH4Factory::BVH4Quad4iIntersectors(BVH4* bvh, IntersectVariant ivariant)
742 {
743 switch (ivariant) {
744 case IntersectVariant::FAST:
745 {
746 Accel::Intersectors intersectors;
747 intersectors.ptr = bvh;
748 intersectors.intersector1 = BVH4Quad4iIntersector1Moeller();
749#if defined (EMBREE_RAY_PACKETS)
750 intersectors.intersector4 = BVH4Quad4iIntersector4HybridMoeller();
751 intersectors.intersector8 = BVH4Quad4iIntersector8HybridMoeller();
752 intersectors.intersector16= BVH4Quad4iIntersector16HybridMoeller();
753 intersectors.intersectorN = BVH4Quad4iIntersectorStreamMoeller();
754#endif
755 return intersectors;
756 }
757 case IntersectVariant::ROBUST:
758 {
759 Accel::Intersectors intersectors;
760 intersectors.ptr = bvh;
761 intersectors.intersector1 = BVH4Quad4iIntersector1Pluecker();
762#if defined (EMBREE_RAY_PACKETS)
763 intersectors.intersector4 = BVH4Quad4iIntersector4HybridPluecker();
764 intersectors.intersector8 = BVH4Quad4iIntersector8HybridPluecker();
765 intersectors.intersector16= BVH4Quad4iIntersector16HybridPluecker();
766 intersectors.intersectorN = BVH4Quad4iIntersectorStreamPluecker();
767#endif
768 return intersectors;
769 }
770 }
771 return Accel::Intersectors();
772 }
773
774 Accel::Intersectors BVH4Factory::BVH4Quad4iMBIntersectors(BVH4* bvh, IntersectVariant ivariant)
775 {
776 switch (ivariant) {
777 case IntersectVariant::FAST:
778 {
779 Accel::Intersectors intersectors;
780 intersectors.ptr = bvh;
781 intersectors.intersector1 = BVH4Quad4iMBIntersector1Moeller();
782#if defined (EMBREE_RAY_PACKETS)
783 intersectors.intersector4 = BVH4Quad4iMBIntersector4HybridMoeller();
784 intersectors.intersector8 = BVH4Quad4iMBIntersector8HybridMoeller();
785 intersectors.intersector16= BVH4Quad4iMBIntersector16HybridMoeller();
786 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
787#endif
788 return intersectors;
789 }
790 case IntersectVariant::ROBUST:
791 {
792 Accel::Intersectors intersectors;
793 intersectors.ptr = bvh;
794 intersectors.intersector1 = BVH4Quad4iMBIntersector1Pluecker();
795#if defined (EMBREE_RAY_PACKETS)
796 intersectors.intersector4 = BVH4Quad4iMBIntersector4HybridPluecker();
797 intersectors.intersector8 = BVH4Quad4iMBIntersector8HybridPluecker();
798 intersectors.intersector16= BVH4Quad4iMBIntersector16HybridPluecker();
799 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
800#endif
801 return intersectors;
802 }
803 }
804 return Accel::Intersectors();
805 }
806
807 Accel::Intersectors BVH4Factory::QBVH4Triangle4iIntersectors(BVH4* bvh)
808 {
809 Accel::Intersectors intersectors;
810 intersectors.ptr = bvh;
811 intersectors.intersector1 = QBVH4Triangle4iIntersector1Pluecker();
812 return intersectors;
813 }
814
815 Accel::Intersectors BVH4Factory::QBVH4Quad4iIntersectors(BVH4* bvh)
816 {
817 Accel::Intersectors intersectors;
818 intersectors.ptr = bvh;
819 intersectors.intersector1 = QBVH4Quad4iIntersector1Pluecker();
820 return intersectors;
821 }
822
823 Accel::Intersectors BVH4Factory::BVH4UserGeometryIntersectors(BVH4* bvh)
824 {
825 Accel::Intersectors intersectors;
826 intersectors.ptr = bvh;
827 intersectors.intersector1 = BVH4VirtualIntersector1();
828#if defined (EMBREE_RAY_PACKETS)
829 intersectors.intersector4 = BVH4VirtualIntersector4Chunk();
830 intersectors.intersector8 = BVH4VirtualIntersector8Chunk();
831 intersectors.intersector16 = BVH4VirtualIntersector16Chunk();
832 intersectors.intersectorN = BVH4VirtualIntersectorStream();
833#endif
834 intersectors.collider = BVH4ColliderUserGeom();
835 return intersectors;
836 }
837
838 Accel::Intersectors BVH4Factory::BVH4UserGeometryMBIntersectors(BVH4* bvh)
839 {
840 Accel::Intersectors intersectors;
841 intersectors.ptr = bvh;
842 intersectors.intersector1 = BVH4VirtualMBIntersector1();
843#if defined (EMBREE_RAY_PACKETS)
844 intersectors.intersector4 = BVH4VirtualMBIntersector4Chunk();
845 intersectors.intersector8 = BVH4VirtualMBIntersector8Chunk();
846 intersectors.intersector16 = BVH4VirtualMBIntersector16Chunk();
847 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
848#endif
849 return intersectors;
850 }
851
852 Accel::Intersectors BVH4Factory::BVH4InstanceIntersectors(BVH4* bvh)
853 {
854 Accel::Intersectors intersectors;
855 intersectors.ptr = bvh;
856 intersectors.intersector1 = BVH4InstanceIntersector1();
857#if defined (EMBREE_RAY_PACKETS)
858 intersectors.intersector4 = BVH4InstanceIntersector4Chunk();
859 intersectors.intersector8 = BVH4InstanceIntersector8Chunk();
860 intersectors.intersector16 = BVH4InstanceIntersector16Chunk();
861 intersectors.intersectorN = BVH4InstanceIntersectorStream();
862#endif
863 return intersectors;
864 }
865
866 Accel::Intersectors BVH4Factory::BVH4InstanceMBIntersectors(BVH4* bvh)
867 {
868 Accel::Intersectors intersectors;
869 intersectors.ptr = bvh;
870 intersectors.intersector1 = BVH4InstanceMBIntersector1();
871#if defined (EMBREE_RAY_PACKETS)
872 intersectors.intersector4 = BVH4InstanceMBIntersector4Chunk();
873 intersectors.intersector8 = BVH4InstanceMBIntersector8Chunk();
874 intersectors.intersector16 = BVH4InstanceMBIntersector16Chunk();
875 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
876#endif
877 return intersectors;
878 }
879
880 Accel::Intersectors BVH4Factory::BVH4SubdivPatch1Intersectors(BVH4* bvh)
881 {
882 Accel::Intersectors intersectors;
883 intersectors.ptr = bvh;
884 intersectors.intersector1 = BVH4SubdivPatch1Intersector1();
885#if defined (EMBREE_RAY_PACKETS)
886 intersectors.intersector4 = BVH4SubdivPatch1Intersector4();
887 intersectors.intersector8 = BVH4SubdivPatch1Intersector8();
888 intersectors.intersector16 = BVH4SubdivPatch1Intersector16();
889 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
890#endif
891 return intersectors;
892 }
893
894 Accel::Intersectors BVH4Factory::BVH4SubdivPatch1MBIntersectors(BVH4* bvh)
895 {
896 Accel::Intersectors intersectors;
897 intersectors.ptr = bvh;
898 intersectors.intersector1 = BVH4SubdivPatch1MBIntersector1();
899#if defined (EMBREE_RAY_PACKETS)
900 intersectors.intersector4 = BVH4SubdivPatch1MBIntersector4();
901 intersectors.intersector8 = BVH4SubdivPatch1MBIntersector8();
902 intersectors.intersector16 = BVH4SubdivPatch1MBIntersector16();
903 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
904#endif
905 return intersectors;
906 }
907
908 Accel* BVH4Factory::BVH4OBBVirtualCurve4i(Scene* scene, IntersectVariant ivariant)
909 {
910 BVH4* accel = new BVH4(Curve4i::type,scene);
911 Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectors(bvh: accel,leafIntersector: VirtualCurveIntersector4i(),ivariant);
912
913 Builder* builder = nullptr;
914 if (scene->device->hair_builder == "default" ) builder = BVH4Curve4iBuilder_OBB_New(accel,scene,0);
915 else if (scene->device->hair_builder == "sah" ) builder = BVH4Curve4iBuilder_OBB_New(accel,scene,0);
916 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve4i>");
917
918 return new AccelInstance(accel,builder,intersectors);
919 }
920
921#if defined(EMBREE_TARGET_SIMD8)
922 Accel* BVH4Factory::BVH4OBBVirtualCurve8i(Scene* scene, IntersectVariant ivariant)
923 {
924 BVH4* accel = new BVH4(Curve8i::type,scene);
925 Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectors(accel,VirtualCurveIntersector8i(),ivariant);
926
927 Builder* builder = nullptr;
928 if (scene->device->hair_builder == "default" ) builder = BVH4Curve8iBuilder_OBB_New(accel,scene,0);
929 else if (scene->device->hair_builder == "sah" ) builder = BVH4Curve8iBuilder_OBB_New(accel,scene,0);
930 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve8i>");
931
932 return new AccelInstance(accel,builder,intersectors);
933 }
934#endif
935
936 Accel* BVH4Factory::BVH4OBBVirtualCurve4v(Scene* scene, IntersectVariant ivariant)
937 {
938 BVH4* accel = new BVH4(Curve4v::type,scene);
939 Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectors(bvh: accel,leafIntersector: VirtualCurveIntersector4v(),ivariant);
940
941 Builder* builder = nullptr;
942 if (scene->device->hair_builder == "default" ) builder = BVH4Curve4vBuilder_OBB_New(accel,scene,0);
943 else if (scene->device->hair_builder == "sah" ) builder = BVH4Curve4vBuilder_OBB_New(accel,scene,0);
944 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve4v>");
945
946 return new AccelInstance(accel,builder,intersectors);
947 }
948
949 Accel* BVH4Factory::BVH4OBBVirtualCurve4iMB(Scene* scene, IntersectVariant ivariant)
950 {
951 BVH4* accel = new BVH4(Curve4iMB::type,scene);
952 Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectorsMB(bvh: accel,leafIntersector: VirtualCurveIntersector4iMB(),ivariant);
953
954 Builder* builder = nullptr;
955 if (scene->device->hair_builder == "default" ) builder = BVH4OBBCurve4iMBBuilder_OBB(accel,scene,0);
956 else if (scene->device->hair_builder == "sah" ) builder = BVH4OBBCurve4iMBBuilder_OBB(accel,scene,0);
957 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve4iMB>");
958
959 return new AccelInstance(accel,builder,intersectors);
960 }
961
962#if defined(EMBREE_TARGET_SIMD8)
963 Accel* BVH4Factory::BVH4OBBVirtualCurve8iMB(Scene* scene, IntersectVariant ivariant)
964 {
965 BVH4* accel = new BVH4(Curve8iMB::type,scene);
966 Accel::Intersectors intersectors = BVH4OBBVirtualCurveIntersectorsMB(accel,VirtualCurveIntersector8iMB(), ivariant);
967
968 Builder* builder = nullptr;
969 if (scene->device->hair_builder == "default" ) builder = BVH4OBBCurve8iMBBuilder_OBB(accel,scene,0);
970 else if (scene->device->hair_builder == "sah" ) builder = BVH4OBBCurve8iMBBuilder_OBB(accel,scene,0);
971 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->hair_builder+" for BVH4OBB<VirtualCurve8iMB>");
972
973 return new AccelInstance(accel,builder,intersectors);
974 }
975#endif
976
977 Accel* BVH4Factory::BVH4Triangle4(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
978 {
979 BVH4* accel = new BVH4(Triangle4::type,scene);
980
981 Accel::Intersectors intersectors;
982 if (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4Intersectors(bvh: accel,ivariant);
983 else if (scene->device->tri_traverser == "fast" ) intersectors = BVH4Triangle4Intersectors(bvh: accel,ivariant: IntersectVariant::FAST);
984 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser+" for BVH4<Triangle4>");
985
986 Builder* builder = nullptr;
987 if (scene->device->tri_builder == "default") {
988 switch (bvariant) {
989 case BuildVariant::STATIC : builder = BVH4Triangle4SceneBuilderSAH(accel,scene,0); break;
990 case BuildVariant::DYNAMIC : builder = BVH4BuilderTwoLevelTriangle4MeshSAH(accel,scene,false); break;
991 case BuildVariant::HIGH_QUALITY: builder = BVH4Triangle4SceneBuilderFastSpatialSAH(accel,scene,0); break;
992 }
993 }
994 else if (scene->device->tri_builder == "sah" ) builder = BVH4Triangle4SceneBuilderSAH(accel,scene,0);
995 else if (scene->device->tri_builder == "sah_fast_spatial" ) builder = BVH4Triangle4SceneBuilderFastSpatialSAH(accel,scene,0);
996 else if (scene->device->tri_builder == "sah_presplit") builder = BVH4Triangle4SceneBuilderSAH(accel,scene,MODE_HIGH_QUALITY);
997 else if (scene->device->tri_builder == "dynamic" ) builder = BVH4BuilderTwoLevelTriangle4MeshSAH(accel,scene,false);
998 else if (scene->device->tri_builder == "morton" ) builder = BVH4BuilderTwoLevelTriangle4MeshSAH(accel,scene,true);
999 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH4<Triangle4>");
1000
1001 return new AccelInstance(accel,builder,intersectors);
1002 }
1003
1004 Accel* BVH4Factory::BVH4Triangle4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1005 {
1006 BVH4* accel = new BVH4(Triangle4v::type,scene);
1007
1008 Accel::Intersectors intersectors;
1009 if (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4vIntersectors(bvh: accel,ivariant);
1010 else if (scene->device->tri_traverser == "fast" ) intersectors = BVH4Triangle4vIntersectors(bvh: accel,ivariant: IntersectVariant::FAST);
1011 else if (scene->device->tri_traverser == "robust" ) intersectors = BVH4Triangle4vIntersectors(bvh: accel,ivariant: IntersectVariant::ROBUST);
1012 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser+" for BVH4<Triangle4>");
1013
1014 Builder* builder = nullptr;
1015 if (scene->device->tri_builder == "default") {
1016 switch (bvariant) {
1017 case BuildVariant::STATIC : builder = BVH4Triangle4vSceneBuilderSAH(accel,scene,0); break;
1018 case BuildVariant::DYNAMIC : builder = BVH4BuilderTwoLevelTriangle4vMeshSAH(accel,scene,false); break;
1019 case BuildVariant::HIGH_QUALITY: builder = BVH4Triangle4vSceneBuilderFastSpatialSAH(accel,scene,0); break;
1020 }
1021 }
1022 else if (scene->device->tri_builder == "sah" ) builder = BVH4Triangle4vSceneBuilderSAH(accel,scene,0);
1023 else if (scene->device->tri_builder == "sah_fast_spatial" ) builder = BVH4Triangle4vSceneBuilderFastSpatialSAH(accel,scene,0);
1024 else if (scene->device->tri_builder == "sah_presplit") builder = BVH4Triangle4vSceneBuilderSAH(accel,scene,MODE_HIGH_QUALITY);
1025 else if (scene->device->tri_builder == "dynamic" ) builder = BVH4BuilderTwoLevelTriangle4vMeshSAH(accel,scene,false);
1026 else if (scene->device->tri_builder == "morton" ) builder = BVH4BuilderTwoLevelTriangle4vMeshSAH(accel,scene,true);
1027 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH4<Triangle4v>");
1028
1029 return new AccelInstance(accel,builder,intersectors);
1030 }
1031
1032 Accel* BVH4Factory::BVH4Triangle4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1033 {
1034 BVH4* accel = new BVH4(Triangle4i::type,scene);
1035
1036 Accel::Intersectors intersectors;
1037 if (scene->device->tri_traverser == "default") intersectors = BVH4Triangle4iIntersectors(bvh: accel,ivariant);
1038 else if (scene->device->tri_traverser == "fast" ) intersectors = BVH4Triangle4iIntersectors(bvh: accel,ivariant: IntersectVariant::FAST);
1039 else if (scene->device->tri_traverser == "robust" ) intersectors = BVH4Triangle4iIntersectors(bvh: accel,ivariant: IntersectVariant::ROBUST);
1040 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser+" for BVH4<Triangle4i>");
1041
1042 Builder* builder = nullptr;
1043 if (scene->device->tri_builder == "default" ) {
1044 switch (bvariant) {
1045 case BuildVariant::STATIC : builder = BVH4Triangle4iSceneBuilderSAH(accel,scene,0); break;
1046 case BuildVariant::DYNAMIC : builder = BVH4BuilderTwoLevelTriangle4iMeshSAH(accel,scene,false); break;
1047 case BuildVariant::HIGH_QUALITY: builder = BVH4Triangle4iSceneBuilderFastSpatialSAH(accel,scene,0); break;
1048 }
1049 }
1050 else if (scene->device->tri_builder == "sah" ) builder = BVH4Triangle4iSceneBuilderSAH(accel,scene,0);
1051 else if (scene->device->tri_builder == "sah_fast_spatial" ) builder = BVH4Triangle4iSceneBuilderFastSpatialSAH(accel,scene,0);
1052 else if (scene->device->tri_builder == "sah_presplit") builder = BVH4Triangle4iSceneBuilderSAH(accel,scene,MODE_HIGH_QUALITY);
1053 else if (scene->device->tri_builder == "dynamic" ) builder = BVH4BuilderTwoLevelTriangle4iMeshSAH(accel,scene,false);
1054 else if (scene->device->tri_builder == "morton" ) builder = BVH4BuilderTwoLevelTriangle4iMeshSAH(accel,scene,true);
1055 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder+" for BVH4<Triangle4i>");
1056
1057 return new AccelInstance(accel,builder,intersectors);
1058 }
1059
1060 Accel* BVH4Factory::BVH4Triangle4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1061 {
1062 BVH4* accel = new BVH4(Triangle4i::type,scene);
1063
1064 Accel::Intersectors intersectors;
1065 if (scene->device->tri_traverser_mb == "default") intersectors = BVH4Triangle4iMBIntersectors(bvh: accel,ivariant);
1066 else if (scene->device->tri_traverser_mb == "fast" ) intersectors = BVH4Triangle4iMBIntersectors(bvh: accel,ivariant: IntersectVariant::FAST);
1067 else if (scene->device->tri_traverser_mb == "robust" ) intersectors = BVH4Triangle4iMBIntersectors(bvh: accel,ivariant: IntersectVariant::ROBUST);
1068 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser_mb+" for BVH4<Triangle4iMB>");
1069
1070 Builder* builder = nullptr;
1071 if (scene->device->tri_builder_mb == "default") {
1072 switch (bvariant) {
1073 case BuildVariant::STATIC : builder = BVH4Triangle4iMBSceneBuilderSAH(accel,scene,0); break;
1074 case BuildVariant::DYNAMIC : assert(false); break; // FIXME: implement
1075 case BuildVariant::HIGH_QUALITY: assert(false); break;
1076 }
1077 }
1078 else if (scene->device->tri_builder_mb == "internal_time_splits") builder = BVH4Triangle4iMBSceneBuilderSAH(accel,scene,0);
1079 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder_mb+" for BVH4<Triangle4iMB>");
1080
1081 return new AccelInstance(accel,builder,intersectors);
1082 }
1083
1084 Accel* BVH4Factory::BVH4Triangle4vMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1085 {
1086 BVH4* accel = new BVH4(Triangle4vMB::type,scene);
1087
1088 Accel::Intersectors intersectors;
1089 if (scene->device->tri_traverser_mb == "default") intersectors = BVH4Triangle4vMBIntersectors(bvh: accel,ivariant);
1090 else if (scene->device->tri_traverser_mb == "fast" ) intersectors = BVH4Triangle4vMBIntersectors(bvh: accel,ivariant: IntersectVariant::FAST);
1091 else if (scene->device->tri_traverser_mb == "robust" ) intersectors = BVH4Triangle4vMBIntersectors(bvh: accel,ivariant: IntersectVariant::ROBUST);
1092 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown traverser "+scene->device->tri_traverser_mb+" for BVH4<Triangle4vMB>");
1093
1094 Builder* builder = nullptr;
1095 if (scene->device->tri_builder_mb == "default") {
1096 switch (bvariant) {
1097 case BuildVariant::STATIC : builder = BVH4Triangle4vMBSceneBuilderSAH(accel,scene,0); break;
1098 case BuildVariant::DYNAMIC : assert(false); break; // FIXME: implement
1099 case BuildVariant::HIGH_QUALITY: assert(false); break;
1100 }
1101 }
1102 else if (scene->device->tri_builder_mb == "internal_time_splits") builder = BVH4Triangle4vMBSceneBuilderSAH(accel,scene,0);
1103 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->tri_builder_mb+" for BVH4<Triangle4vMB>");
1104
1105 return new AccelInstance(accel,builder,intersectors);
1106 }
1107
1108 Accel* BVH4Factory::BVH4Quad4v(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1109 {
1110 BVH4* accel = new BVH4(Quad4v::type,scene);
1111 Accel::Intersectors intersectors = BVH4Quad4vIntersectors(bvh: accel,ivariant);
1112
1113 Builder* builder = nullptr;
1114 if (scene->device->quad_builder == "default") {
1115 switch (bvariant) {
1116 case BuildVariant::STATIC : builder = BVH4Quad4vSceneBuilderSAH(accel,scene,0); break;
1117 case BuildVariant::DYNAMIC : builder = BVH4BuilderTwoLevelQuadMeshSAH(accel,scene,false); break;
1118 case BuildVariant::HIGH_QUALITY: builder = BVH4Quad4vSceneBuilderFastSpatialSAH(accel,scene,0); break;
1119 }
1120 }
1121 else if (scene->device->quad_builder == "sah" ) builder = BVH4Quad4vSceneBuilderSAH(accel,scene,0);
1122 else if (scene->device->quad_builder == "sah_fast_spatial" ) builder = BVH4Quad4vSceneBuilderFastSpatialSAH(accel,scene,0);
1123 else if (scene->device->quad_builder == "dynamic" ) builder = BVH4BuilderTwoLevelQuadMeshSAH(accel,scene,false);
1124 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder+" for BVH4<Quad4v>");
1125
1126 return new AccelInstance(accel,builder,intersectors);
1127 }
1128
1129 Accel* BVH4Factory::BVH4Quad4i(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1130 {
1131 BVH4* accel = new BVH4(Quad4i::type,scene);
1132 Accel::Intersectors intersectors = BVH4Quad4iIntersectors(bvh: accel,ivariant);
1133
1134 Builder* builder = nullptr;
1135 if (scene->device->quad_builder == "default") {
1136 switch (bvariant) {
1137 case BuildVariant::STATIC : builder = BVH4Quad4iSceneBuilderSAH(accel,scene,0); break;
1138 case BuildVariant::DYNAMIC : assert(false); break; // FIXME: implement
1139 case BuildVariant::HIGH_QUALITY: assert(false); break; // FIXME: implement
1140 }
1141 }
1142 else if (scene->device->quad_builder == "sah") builder = BVH4Quad4iSceneBuilderSAH(accel,scene,0);
1143 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder+" for BVH4<Quad4i>");
1144
1145 return new AccelInstance(accel,builder,intersectors);
1146 }
1147
1148 Accel* BVH4Factory::BVH4Quad4iMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1149 {
1150 BVH4* accel = new BVH4(Quad4i::type,scene);
1151 Accel::Intersectors intersectors = BVH4Quad4iMBIntersectors(bvh: accel,ivariant);
1152
1153 Builder* builder = nullptr;
1154 if (scene->device->quad_builder_mb == "default") {
1155 switch (bvariant) {
1156 case BuildVariant::STATIC : builder = BVH4Quad4iMBSceneBuilderSAH(accel,scene,0); break;
1157 case BuildVariant::DYNAMIC : assert(false); break; // FIXME: implement
1158 case BuildVariant::HIGH_QUALITY: assert(false); break;
1159 }
1160 }
1161 else if (scene->device->quad_builder_mb == "sah") builder = BVH4Quad4iMBSceneBuilderSAH(accel,scene,0);
1162 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->quad_builder_mb+" for BVH4<Quad4iMB>");
1163
1164 return new AccelInstance(accel,builder,intersectors);
1165 }
1166
1167 Accel* BVH4Factory::BVH4QuantizedQuad4i(Scene* scene)
1168 {
1169 BVH4* accel = new BVH4(Quad4i::type,scene);
1170 Builder* builder = BVH4QuantizedQuad4iSceneBuilderSAH(accel,scene,0);
1171 Accel::Intersectors intersectors = QBVH4Quad4iIntersectors(bvh: accel);
1172 return new AccelInstance(accel,builder,intersectors);
1173 }
1174
1175 Accel* BVH4Factory::BVH4QuantizedTriangle4i(Scene* scene)
1176 {
1177 BVH4* accel = new BVH4(Triangle4i::type,scene);
1178 Builder* builder = BVH4QuantizedTriangle4iSceneBuilderSAH(accel,scene,0);
1179 Accel::Intersectors intersectors = QBVH4Triangle4iIntersectors(bvh: accel);
1180 return new AccelInstance(accel,builder,intersectors);
1181 }
1182
1183 Accel* BVH4Factory::BVH4SubdivPatch1(Scene* scene)
1184 {
1185 BVH4* accel = new BVH4(SubdivPatch1::type,scene);
1186 Accel::Intersectors intersectors = BVH4SubdivPatch1Intersectors(bvh: accel);
1187 Builder* builder = BVH4SubdivPatch1BuilderSAH(accel,scene,0);
1188 return new AccelInstance(accel,builder,intersectors);
1189 }
1190
1191 Accel* BVH4Factory::BVH4SubdivPatch1MB(Scene* scene)
1192 {
1193 BVH4* accel = new BVH4(SubdivPatch1::type,scene);
1194 Accel::Intersectors intersectors = BVH4SubdivPatch1MBIntersectors(bvh: accel);
1195 Builder* builder = BVH4SubdivPatch1MBBuilderSAH(accel,scene,0);
1196 return new AccelInstance(accel,builder,intersectors);
1197 }
1198
1199 Accel* BVH4Factory::BVH4UserGeometry(Scene* scene, BuildVariant bvariant)
1200 {
1201 BVH4* accel = new BVH4(Object::type,scene);
1202 Accel::Intersectors intersectors = BVH4UserGeometryIntersectors(bvh: accel);
1203
1204 Builder* builder = nullptr;
1205 if (scene->device->object_builder == "default") {
1206 switch (bvariant) {
1207 case BuildVariant::STATIC : builder = BVH4VirtualSceneBuilderSAH(accel,scene,0); break;
1208 case BuildVariant::DYNAMIC : builder = BVH4BuilderTwoLevelVirtualSAH(accel,scene,false); break;
1209 case BuildVariant::HIGH_QUALITY: assert(false); break;
1210 }
1211 }
1212 else if (scene->device->object_builder == "sah") builder = BVH4VirtualSceneBuilderSAH(accel,scene,0);
1213 else if (scene->device->object_builder == "dynamic") builder = BVH4BuilderTwoLevelVirtualSAH(accel,scene,false);
1214 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH4<Object>");
1215
1216 return new AccelInstance(accel,builder,intersectors);
1217 }
1218
1219 Accel* BVH4Factory::BVH4UserGeometryMB(Scene* scene)
1220 {
1221 BVH4* accel = new BVH4(Object::type,scene);
1222 Accel::Intersectors intersectors = BVH4UserGeometryMBIntersectors(bvh: accel);
1223 Builder* builder = BVH4VirtualMBSceneBuilderSAH(accel,scene,0);
1224 return new AccelInstance(accel,builder,intersectors);
1225 }
1226
1227 Accel* BVH4Factory::BVH4Instance(Scene* scene, bool isExpensive, BuildVariant bvariant)
1228 {
1229 BVH4* accel = new BVH4(InstancePrimitive::type,scene);
1230 Accel::Intersectors intersectors = BVH4InstanceIntersectors(bvh: accel);
1231 auto gtype = isExpensive ? Geometry::MTY_INSTANCE_EXPENSIVE : Geometry::MTY_INSTANCE_CHEAP;
1232 // Builder* builder = BVH4InstanceSceneBuilderSAH(accel,scene,gtype);
1233
1234 Builder* builder = nullptr;
1235 if (scene->device->object_builder == "default") {
1236 switch (bvariant) {
1237 case BuildVariant::STATIC : builder = BVH4InstanceSceneBuilderSAH(accel,scene,gtype); break;
1238 case BuildVariant::DYNAMIC : builder = BVH4BuilderTwoLevelInstanceSAH(accel,scene,gtype,false); break;
1239 case BuildVariant::HIGH_QUALITY: assert(false); break;
1240 }
1241 }
1242 else if (scene->device->object_builder == "sah") builder = BVH4InstanceSceneBuilderSAH(accel,scene,gtype);
1243 else if (scene->device->object_builder == "dynamic") builder = BVH4BuilderTwoLevelInstanceSAH(accel,scene,gtype,false);
1244 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->object_builder+" for BVH4<Object>");
1245
1246 return new AccelInstance(accel,builder,intersectors);
1247 }
1248
1249 Accel* BVH4Factory::BVH4InstanceMB(Scene* scene, bool isExpensive)
1250 {
1251 BVH4* accel = new BVH4(InstancePrimitive::type,scene);
1252 Accel::Intersectors intersectors = BVH4InstanceMBIntersectors(bvh: accel);
1253 auto gtype = isExpensive ? Geometry::MTY_INSTANCE_EXPENSIVE : Geometry::MTY_INSTANCE_CHEAP;
1254 Builder* builder = BVH4InstanceMBSceneBuilderSAH(accel,scene,gtype);
1255 return new AccelInstance(accel,builder,intersectors);
1256 }
1257
1258 Accel::Intersectors BVH4Factory::BVH4GridIntersectors(BVH4* bvh, IntersectVariant ivariant)
1259 {
1260 Accel::Intersectors intersectors;
1261 intersectors.ptr = bvh;
1262 if (ivariant == IntersectVariant::FAST)
1263 {
1264 intersectors.intersector1 = BVH4GridIntersector1Moeller();
1265#if defined (EMBREE_RAY_PACKETS)
1266 intersectors.intersector4 = BVH4GridIntersector4HybridMoeller();
1267 intersectors.intersector8 = BVH4GridIntersector8HybridMoeller();
1268 intersectors.intersector16 = BVH4GridIntersector16HybridMoeller();
1269 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
1270#endif
1271 }
1272 else /* if (ivariant == IntersectVariant::ROBUST) */
1273 {
1274 intersectors.intersector1 = BVH4GridIntersector1Pluecker();
1275#if defined (EMBREE_RAY_PACKETS)
1276 intersectors.intersector4 = BVH4GridIntersector4HybridPluecker();
1277 intersectors.intersector8 = BVH4GridIntersector8HybridPluecker();
1278 intersectors.intersector16 = BVH4GridIntersector16HybridPluecker();
1279 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
1280#endif
1281 }
1282 return intersectors;
1283 }
1284
1285 Accel::Intersectors BVH4Factory::BVH4GridMBIntersectors(BVH4* bvh, IntersectVariant ivariant)
1286 {
1287 Accel::Intersectors intersectors;
1288 intersectors.ptr = bvh;
1289 intersectors.intersector1 = BVH4GridMBIntersector1Moeller();
1290#if defined (EMBREE_RAY_PACKETS)
1291 intersectors.intersector4 = BVH4GridMBIntersector4HybridMoeller();
1292 intersectors.intersector8 = BVH4GridMBIntersector8HybridMoeller();
1293 intersectors.intersector16 = BVH4GridMBIntersector16HybridMoeller();
1294 intersectors.intersectorN = BVH4IntersectorStreamPacketFallback();
1295#endif
1296 return intersectors;
1297 }
1298
1299 Accel* BVH4Factory::BVH4Grid(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1300 {
1301 BVH4* accel = new BVH4(SubGridQBVH4::type,scene);
1302 Accel::Intersectors intersectors = BVH4GridIntersectors(bvh: accel,ivariant);
1303
1304 Builder* builder = nullptr;
1305 if (scene->device->object_builder == "default") {
1306 builder = BVH4GridSceneBuilderSAH(accel,scene,0);
1307 }
1308 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->grid_builder+" for BVH4<GridMesh>");
1309
1310 return new AccelInstance(accel,builder,intersectors);
1311 }
1312
1313 Accel* BVH4Factory::BVH4GridMB(Scene* scene, BuildVariant bvariant, IntersectVariant ivariant)
1314 {
1315 BVH4* accel = new BVH4(SubGridQBVH4::type,scene);
1316 Accel::Intersectors intersectors = BVH4GridMBIntersectors(bvh: accel,ivariant);
1317 Builder* builder = nullptr;
1318 if (scene->device->object_builder == "default") {
1319 builder = BVH4GridMBSceneBuilderSAH(accel,scene,0);
1320 }
1321 else throw_RTCError(RTC_ERROR_INVALID_ARGUMENT,"unknown builder "+scene->device->grid_builder+" for BVH4MB<GridMesh>");
1322 return new AccelInstance(accel,builder,intersectors);
1323 }
1324
1325}
1326

source code of qtquick3d/src/3rdparty/embree/kernels/bvh/bvh4_factory.cpp