CoCalc -- curveNi_mb_intersector.h

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/embree/kernels/geometry/curveNi_mb_intersector.h
⁹⁹⁰⁵ views
1
// Copyright 2009-2021 Intel Corporation
2
// SPDX-License-Identifier: Apache-2.0
3

4
#pragma once
5

6
#include "curveNi_mb.h"
7
#include "../subdiv/linear_bezier_patch.h"
8

9
#include "roundline_intersector.h"
10
#include "coneline_intersector.h"
11
#include "curve_intersector_ribbon.h"
12
#include "curve_intersector_oriented.h"
13
#include "curve_intersector_sweep.h"
14

15
namespace embree
16
{
17
  namespace isa
18
  {
19
    template<int M>
20
      struct CurveNiMBIntersector1
21
    {
22
      typedef CurveNiMB<M> Primitive;
23
      typedef Vec3vf<M> Vec3vfM;
24
      typedef LinearSpace3<Vec3vfM>LinearSpace3vfM;
25
      typedef CurvePrecalculations1 Precalculations;
26

27
      static __forceinline vbool<M> intersect(Ray& ray, const Primitive& prim, vfloat<M>& tNear_o)
28
      {
29
        const size_t N = prim.N;
30
#if __SYCL_DEVICE_ONLY__
31
        const Vec3f offset = *prim.offset(N);
32
        const float scale  = *prim.scale(N);
33
#else
34
        const vfloat4 offset_scale = vfloat4::loadu(prim.offset(N));
35
        const Vec3fa offset = Vec3fa(offset_scale);
36
        const Vec3fa scale = Vec3fa(shuffle<3,3,3,3>(offset_scale));
37
#endif
38
        const Vec3fa org1 = (ray.org-offset)*scale;
39
        const Vec3fa dir1 = ray.dir*scale;
40
        
41
        const LinearSpace3vfM space(vfloat<M>::load(prim.bounds_vx_x(N)), vfloat<M>::load(prim.bounds_vx_y(N)), vfloat<M>::load(prim.bounds_vx_z(N)),
42
                                    vfloat<M>::load(prim.bounds_vy_x(N)), vfloat<M>::load(prim.bounds_vy_y(N)), vfloat<M>::load(prim.bounds_vy_z(N)),
43
                                    vfloat<M>::load(prim.bounds_vz_x(N)), vfloat<M>::load(prim.bounds_vz_y(N)), vfloat<M>::load(prim.bounds_vz_z(N)));
44

45
        const Vec3vfM dir2 = xfmVector(space,Vec3vfM(dir1));
46
        const Vec3vfM org2 = xfmPoint (space,Vec3vfM(org1));
47
        const Vec3vfM rcp_dir2 = rcp_safe(dir2);
48

49
        const vfloat<M> ltime = (ray.time()-prim.time_offset(N))*prim.time_scale(N);
50
        const vfloat<M> vx_lower0 = vfloat<M>::load(prim.bounds_vx_lower0(N));
51
        const vfloat<M> vx_lower1 = vfloat<M>::load(prim.bounds_vx_lower1(N));
52
        const vfloat<M> vx_lower = madd(ltime,vx_lower1-vx_lower0,vx_lower0);
53
        const vfloat<M> vx_upper0 = vfloat<M>::load(prim.bounds_vx_upper0(N));
54
        const vfloat<M> vx_upper1 = vfloat<M>::load(prim.bounds_vx_upper1(N));
55
        const vfloat<M> vx_upper = madd(ltime,vx_upper1-vx_upper0,vx_upper0);
56

57
        const vfloat<M> vy_lower0 = vfloat<M>::load(prim.bounds_vy_lower0(N));
58
        const vfloat<M> vy_lower1 = vfloat<M>::load(prim.bounds_vy_lower1(N));
59
        const vfloat<M> vy_lower = madd(ltime,vy_lower1-vy_lower0,vy_lower0);
60
        const vfloat<M> vy_upper0 = vfloat<M>::load(prim.bounds_vy_upper0(N));
61
        const vfloat<M> vy_upper1 = vfloat<M>::load(prim.bounds_vy_upper1(N));
62
        const vfloat<M> vy_upper = madd(ltime,vy_upper1-vy_upper0,vy_upper0);
63
        
64
        const vfloat<M> vz_lower0 = vfloat<M>::load(prim.bounds_vz_lower0(N));
65
        const vfloat<M> vz_lower1 = vfloat<M>::load(prim.bounds_vz_lower1(N));
66
        const vfloat<M> vz_lower = madd(ltime,vz_lower1-vz_lower0,vz_lower0);
67
        const vfloat<M> vz_upper0 = vfloat<M>::load(prim.bounds_vz_upper0(N));
68
        const vfloat<M> vz_upper1 = vfloat<M>::load(prim.bounds_vz_upper1(N));
69
        const vfloat<M> vz_upper = madd(ltime,vz_upper1-vz_upper0,vz_upper0);
70
       
71
        const vfloat<M> t_lower_x = (vx_lower-vfloat<M>(org2.x))*vfloat<M>(rcp_dir2.x);
72
        const vfloat<M> t_upper_x = (vx_upper-vfloat<M>(org2.x))*vfloat<M>(rcp_dir2.x);
73
        const vfloat<M> t_lower_y = (vy_lower-vfloat<M>(org2.y))*vfloat<M>(rcp_dir2.y);
74
        const vfloat<M> t_upper_y = (vy_upper-vfloat<M>(org2.y))*vfloat<M>(rcp_dir2.y);
75
        const vfloat<M> t_lower_z = (vz_lower-vfloat<M>(org2.z))*vfloat<M>(rcp_dir2.z);
76
        const vfloat<M> t_upper_z = (vz_upper-vfloat<M>(org2.z))*vfloat<M>(rcp_dir2.z);
77

78
        const vfloat<M> round_up  (1.0f+3.0f*float(ulp));
79
        const vfloat<M> round_down(1.0f-3.0f*float(ulp));
80
        const vfloat<M> tNear = round_down*max(mini(t_lower_x,t_upper_x),mini(t_lower_y,t_upper_y),mini(t_lower_z,t_upper_z),vfloat<M>(ray.tnear()));
81
        const vfloat<M> tFar  = round_up  *min(maxi(t_lower_x,t_upper_x),maxi(t_lower_y,t_upper_y),maxi(t_lower_z,t_upper_z),vfloat<M>(ray.tfar));
82
        tNear_o = tNear;
83
        return (vint<M>(step) < vint<M>(prim.N)) & (tNear <= tFar);
84
      }
85

86
      template<typename Intersector, typename Epilog>
87
        static __forceinline void intersect_t(const Precalculations& pre, RayHit& ray, RayQueryContext* context, const Primitive& prim)
88
      {
89
        vfloat<M> tNear;
90
        vbool<M> valid = intersect(ray,prim,tNear);
91

92
        const size_t N = prim.N;
93
        size_t mask = movemask(valid);
94
        while (mask)
95
        {
96
          const size_t i = bscf(mask);
97
          STAT3(normal.trav_prims,1,1,1);
98
          const unsigned int geomID = prim.geomID(N);
99
          const unsigned int primID = prim.primID(N)[i];
100
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
101
          Vec3ff a0,a1,a2,a3; geom->gather(a0,a1,a2,a3,geom->curve(primID),ray.time());
102

103
          Intersector().intersect(pre,ray,context,geom,primID,a0,a1,a2,a3,Epilog(ray,context,geomID,primID));
104
          mask &= movemask(tNear <= vfloat<M>(ray.tfar));
105
        }
106
      }
107

108
      template<typename Intersector, typename Epilog>
109
        static __forceinline bool occluded_t(const Precalculations& pre, Ray& ray, RayQueryContext* context, const Primitive& prim)
110
      {
111
        vfloat<M> tNear;
112
        vbool<M> valid = intersect(ray,prim,tNear);
113

114
        const size_t N = prim.N;
115
        size_t mask = movemask(valid);
116
        while (mask)
117
        {
118
          const size_t i = bscf(mask);
119
          STAT3(shadow.trav_prims,1,1,1);
120
          const unsigned int geomID = prim.geomID(N);
121
          const unsigned int primID = prim.primID(N)[i];
122
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
123
          Vec3ff a0,a1,a2,a3; geom->gather(a0,a1,a2,a3,geom->curve(primID),ray.time());
124

125
          if (Intersector().intersect(pre,ray,context,geom,primID,a0,a1,a2,a3,Epilog(ray,context,geomID,primID)))
126
              return true;
127

128
          mask &= movemask(tNear <= vfloat<M>(ray.tfar));
129
        }
130
        return false;
131
      }
132

133
      template<typename Intersector, typename Epilog>
134
        static __forceinline void intersect_n(const Precalculations& pre, RayHit& ray, RayQueryContext* context, const Primitive& prim)
135
      {
136
        vfloat<M> tNear;
137
        vbool<M> valid = intersect(ray,prim,tNear);
138

139
        const size_t N = prim.N;
140
        size_t mask = movemask(valid);
141
        while (mask)
142
        {
143
          const size_t i = bscf(mask);
144
          STAT3(normal.trav_prims,1,1,1);
145
          const unsigned int geomID = prim.geomID(N);
146
          const unsigned int primID = prim.primID(N)[i];
147
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
148
          const TensorLinearCubicBezierSurface3fa curve = geom->getNormalOrientedCurve<typename Intersector::SourceCurve3ff, typename Intersector::SourceCurve3fa, TensorLinearCubicBezierSurface3fa>(context, ray.org, primID,ray.time());
149
          Intersector().intersect(pre,ray,context,geom,primID,curve,Epilog(ray,context,geomID,primID));
150
          mask &= movemask(tNear <= vfloat<M>(ray.tfar));
151
        }
152
      }
153

154
      template<typename Intersector, typename Epilog>
155
        static __forceinline bool occluded_n(const Precalculations& pre, Ray& ray, RayQueryContext* context, const Primitive& prim)
156
      {
157
        vfloat<M> tNear;
158
        vbool<M> valid = intersect(ray,prim,tNear);
159

160
        const size_t N = prim.N;
161
        size_t mask = movemask(valid);
162
        while (mask)
163
        {
164
          const size_t i = bscf(mask);
165
          STAT3(shadow.trav_prims,1,1,1);
166
          const unsigned int geomID = prim.geomID(N);
167
          const unsigned int primID = prim.primID(N)[i];
168
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
169
          const TensorLinearCubicBezierSurface3fa curve = geom->getNormalOrientedCurve<typename Intersector::SourceCurve3ff, typename Intersector::SourceCurve3fa, TensorLinearCubicBezierSurface3fa>(context, ray.org, primID,ray.time());
170

171
          if (Intersector().intersect(pre,ray,context,geom,primID,curve,Epilog(ray,context,geomID,primID)))
172
              return true;
173

174
          mask &= movemask(tNear <= vfloat<M>(ray.tfar));
175
        }
176
        return false;
177
      }
178

179
      template<typename Intersector, typename Epilog>
180
        static __forceinline void intersect_h(const Precalculations& pre, RayHit& ray, RayQueryContext* context, const Primitive& prim)
181
      {
182
        vfloat<M> tNear;
183
        vbool<M> valid = intersect(ray,prim,tNear);
184

185
        const size_t N = prim.N;
186
        size_t mask = movemask(valid);
187
        while (mask)
188
        {
189
          const size_t i = bscf(mask);
190
          STAT3(normal.trav_prims,1,1,1);
191
          const unsigned int geomID = prim.geomID(N);
192
          const unsigned int primID = prim.primID(N)[i];
193
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
194
          Vec3ff p0,t0,p1,t1; geom->gather_hermite(p0,t0,p1,t1,geom->curve(primID),ray.time());
195
          Intersector().intersect(pre,ray,context,geom,primID,p0,t0,p1,t1,Epilog(ray,context,geomID,primID));
196
          mask &= movemask(tNear <= vfloat<M>(ray.tfar));
197
        }
198
      }
199

200
      template<typename Intersector, typename Epilog>
201
        static __forceinline bool occluded_h(const Precalculations& pre, Ray& ray, RayQueryContext* context, const Primitive& prim)
202
      {
203
        vfloat<M> tNear;
204
        vbool<M> valid = intersect(ray,prim,tNear);
205

206
        const size_t N = prim.N;
207
        size_t mask = movemask(valid);
208
        while (mask)
209
        {
210
          const size_t i = bscf(mask);
211
          STAT3(shadow.trav_prims,1,1,1);
212
          const unsigned int geomID = prim.geomID(N);
213
          const unsigned int primID = prim.primID(N)[i];
214
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
215
          Vec3ff p0,t0,p1,t1; geom->gather_hermite(p0,t0,p1,t1,geom->curve(primID),ray.time());
216
          if (Intersector().intersect(pre,ray,context,geom,primID,p0,t0,p1,t1,Epilog(ray,context,geomID,primID)))
217
              return true;
218

219
          mask &= movemask(tNear <= vfloat<M>(ray.tfar));
220
        }
221
        return false;
222
      }
223

224
      template<typename Intersector, typename Epilog>
225
        static __forceinline void intersect_hn(const Precalculations& pre, RayHit& ray, RayQueryContext* context, const Primitive& prim)
226
      {
227
        vfloat<M> tNear;
228
        vbool<M> valid = intersect(ray,prim,tNear);
229

230
        const size_t N = prim.N;
231
        size_t mask = movemask(valid);
232
        while (mask)
233
        {
234
          const size_t i = bscf(mask);
235
          STAT3(normal.trav_prims,1,1,1);
236
          const unsigned int geomID = prim.geomID(N);
237
          const unsigned int primID = prim.primID(N)[i];
238
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
239
          const TensorLinearCubicBezierSurface3fa curve = geom->getNormalOrientedHermiteCurve<typename Intersector::SourceCurve3ff, typename Intersector::SourceCurve3fa, TensorLinearCubicBezierSurface3fa>(context, ray.org, primID,ray.time());
240
          Intersector().intersect(pre,ray,context,geom,primID,curve,Epilog(ray,context,geomID,primID));
241
          mask &= movemask(tNear <= vfloat<M>(ray.tfar));
242
        }
243
      }
244

245
      template<typename Intersector, typename Epilog>
246
        static __forceinline bool occluded_hn(const Precalculations& pre, Ray& ray, RayQueryContext* context, const Primitive& prim)
247
      {
248
        vfloat<M> tNear;
249
        vbool<M> valid = intersect(ray,prim,tNear);
250

251
        const size_t N = prim.N;
252
        size_t mask = movemask(valid);
253
        while (mask)
254
        {
255
          const size_t i = bscf(mask);
256
          STAT3(shadow.trav_prims,1,1,1);
257
          const unsigned int geomID = prim.geomID(N);
258
          const unsigned int primID = prim.primID(N)[i];
259
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
260
          const TensorLinearCubicBezierSurface3fa curve = geom->getNormalOrientedHermiteCurve<typename Intersector::SourceCurve3ff, typename Intersector::SourceCurve3fa, TensorLinearCubicBezierSurface3fa>(context, ray.org, primID,ray.time());
261
          if (Intersector().intersect(pre,ray,context,geom,primID,curve,Epilog(ray,context,geomID,primID)))
262
              return true;
263

264
          mask &= movemask(tNear <= vfloat<M>(ray.tfar));
265
        }
266
        return false;
267
      }
268
    };
269

270
    template<int M, int K>
271
      struct CurveNiMBIntersectorK
272
    {
273
      typedef CurveNiMB<M> Primitive;
274
      typedef Vec3vf<M> Vec3vfM;
275
      typedef LinearSpace3<Vec3vfM>LinearSpace3vfM;
276
      typedef CurvePrecalculationsK<K> Precalculations;
277

278
      static __forceinline vbool<M> intersect(RayK<K>& ray, const size_t k, const Primitive& prim, vfloat<M>& tNear_o)
279
      {
280
        const size_t N = prim.N;
281
#if __SYCL_DEVICE_ONLY__
282
        const Vec3f offset = *prim.offset(N);
283
        const float scale  = *prim.scale(N);
284
#else
285
        const vfloat4 offset_scale = vfloat4::loadu(prim.offset(N));
286
        const Vec3fa offset = Vec3fa(offset_scale);
287
        const Vec3fa scale = Vec3fa(shuffle<3,3,3,3>(offset_scale));
288
#endif
289
        const Vec3fa ray_org(ray.org.x[k],ray.org.y[k],ray.org.z[k]);
290
        const Vec3fa ray_dir(ray.dir.x[k],ray.dir.y[k],ray.dir.z[k]);
291
        const Vec3fa org1 = (ray_org-offset)*scale;
292
        const Vec3fa dir1 = ray_dir*scale;
293
        
294
        const LinearSpace3vfM space(vfloat<M>::load(prim.bounds_vx_x(N)), vfloat<M>::load(prim.bounds_vx_y(N)), vfloat<M>::load(prim.bounds_vx_z(N)),
295
                                    vfloat<M>::load(prim.bounds_vy_x(N)), vfloat<M>::load(prim.bounds_vy_y(N)), vfloat<M>::load(prim.bounds_vy_z(N)),
296
                                    vfloat<M>::load(prim.bounds_vz_x(N)), vfloat<M>::load(prim.bounds_vz_y(N)), vfloat<M>::load(prim.bounds_vz_z(N)));
297

298
        const Vec3vfM dir2 = xfmVector(space,Vec3vfM(dir1));
299
        const Vec3vfM org2 = xfmPoint (space,Vec3vfM(org1));
300
        const Vec3vfM rcp_dir2 = rcp_safe(dir2);
301

302
        const vfloat<M> ltime = (ray.time()[k]-prim.time_offset(N))*prim.time_scale(N);
303
        const vfloat<M> vx_lower0 = vfloat<M>::load(prim.bounds_vx_lower0(N));
304
        const vfloat<M> vx_lower1 = vfloat<M>::load(prim.bounds_vx_lower1(N));
305
        const vfloat<M> vx_lower = madd(ltime,vx_lower1-vx_lower0,vx_lower0);
306
        const vfloat<M> vx_upper0 = vfloat<M>::load(prim.bounds_vx_upper0(N));
307
        const vfloat<M> vx_upper1 = vfloat<M>::load(prim.bounds_vx_upper1(N));
308
        const vfloat<M> vx_upper = madd(ltime,vx_upper1-vx_upper0,vx_upper0);
309

310
        const vfloat<M> vy_lower0 = vfloat<M>::load(prim.bounds_vy_lower0(N));
311
        const vfloat<M> vy_lower1 = vfloat<M>::load(prim.bounds_vy_lower1(N));
312
        const vfloat<M> vy_lower = madd(ltime,vy_lower1-vy_lower0,vy_lower0);
313
        const vfloat<M> vy_upper0 = vfloat<M>::load(prim.bounds_vy_upper0(N));
314
        const vfloat<M> vy_upper1 = vfloat<M>::load(prim.bounds_vy_upper1(N));
315
        const vfloat<M> vy_upper = madd(ltime,vy_upper1-vy_upper0,vy_upper0);
316
        
317
        const vfloat<M> vz_lower0 = vfloat<M>::load(prim.bounds_vz_lower0(N));
318
        const vfloat<M> vz_lower1 = vfloat<M>::load(prim.bounds_vz_lower1(N));
319
        const vfloat<M> vz_lower = madd(ltime,vz_lower1-vz_lower0,vz_lower0);
320
        const vfloat<M> vz_upper0 = vfloat<M>::load(prim.bounds_vz_upper0(N));
321
        const vfloat<M> vz_upper1 = vfloat<M>::load(prim.bounds_vz_upper1(N));
322
        const vfloat<M> vz_upper = madd(ltime,vz_upper1-vz_upper0,vz_upper0);
323
       
324
        const vfloat<M> t_lower_x = (vx_lower-vfloat<M>(org2.x))*vfloat<M>(rcp_dir2.x);
325
        const vfloat<M> t_upper_x = (vx_upper-vfloat<M>(org2.x))*vfloat<M>(rcp_dir2.x);
326
        const vfloat<M> t_lower_y = (vy_lower-vfloat<M>(org2.y))*vfloat<M>(rcp_dir2.y);
327
        const vfloat<M> t_upper_y = (vy_upper-vfloat<M>(org2.y))*vfloat<M>(rcp_dir2.y);
328
        const vfloat<M> t_lower_z = (vz_lower-vfloat<M>(org2.z))*vfloat<M>(rcp_dir2.z);
329
        const vfloat<M> t_upper_z = (vz_upper-vfloat<M>(org2.z))*vfloat<M>(rcp_dir2.z);
330

331
        const vfloat<M> round_up  (1.0f+3.0f*float(ulp));
332
        const vfloat<M> round_down(1.0f-3.0f*float(ulp));
333
        const vfloat<M> tNear = round_down*max(mini(t_lower_x,t_upper_x),mini(t_lower_y,t_upper_y),mini(t_lower_z,t_upper_z),vfloat<M>(ray.tnear()[k]));
334
        const vfloat<M> tFar  = round_up  *min(maxi(t_lower_x,t_upper_x),maxi(t_lower_y,t_upper_y),maxi(t_lower_z,t_upper_z),vfloat<M>(ray.tfar[k]));
335
        tNear_o = tNear;
336
        return (vint<M>(step) < vint<M>(prim.N)) & (tNear <= tFar);
337
      }
338

339
      template<typename Intersector, typename Epilog>
340
        static __forceinline void intersect_t(Precalculations& pre, RayHitK<K>& ray, const size_t k, RayQueryContext* context, const Primitive& prim)
341
      {
342
        
343
        vfloat<M> tNear;
344
        vbool<M> valid = intersect(ray,k,prim,tNear);
345

346
        const size_t N = prim.N;
347
        size_t mask = movemask(valid);
348
        while (mask)
349
        {
350
          const size_t i = bscf(mask);
351
          STAT3(normal.trav_prims,1,1,1);
352
          const unsigned int geomID = prim.geomID(N);
353
          const unsigned int primID = prim.primID(N)[i];
354
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
355
          Vec3ff a0,a1,a2,a3; geom->gather(a0,a1,a2,a3,geom->curve(primID),ray.time()[k]);
356

357
          Intersector().intersect(pre,ray,k,context,geom,primID,a0,a1,a2,a3,Epilog(ray,k,context,geomID,primID));
358
          mask &= movemask(tNear <= vfloat<M>(ray.tfar[k]));
359
        }
360
      }
361

362
      template<typename Intersector, typename Epilog>
363
        static __forceinline bool occluded_t(Precalculations& pre, RayK<K>& ray, const size_t k, RayQueryContext* context, const Primitive& prim)
364
      {
365
        vfloat<M> tNear;
366
        vbool<M> valid = intersect(ray,k,prim,tNear);
367

368
        const size_t N = prim.N;
369
        size_t mask = movemask(valid);
370
        while (mask)
371
        {
372
          const size_t i = bscf(mask);
373
          STAT3(shadow.trav_prims,1,1,1);
374
          const unsigned int geomID = prim.geomID(N);
375
          const unsigned int primID = prim.primID(N)[i];
376
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
377
          Vec3ff a0,a1,a2,a3; geom->gather(a0,a1,a2,a3,geom->curve(primID),ray.time()[k]);
378

379
          if (Intersector().intersect(pre,ray,k,context,geom,primID,a0,a1,a2,a3,Epilog(ray,k,context,geomID,primID)))
380
            return true;
381

382
          mask &= movemask(tNear <= vfloat<M>(ray.tfar[k]));
383
        }
384
        return false;
385
      }
386

387
      template<typename Intersector, typename Epilog>
388
        static __forceinline void intersect_n(Precalculations& pre, RayHitK<K>& ray, const size_t k, RayQueryContext* context, const Primitive& prim)
389
      {
390
        
391
        vfloat<M> tNear;
392
        vbool<M> valid = intersect(ray,k,prim,tNear);
393

394
        const size_t N = prim.N;
395
        size_t mask = movemask(valid);
396
        while (mask)
397
        {
398
          const size_t i = bscf(mask);
399
          STAT3(normal.trav_prims,1,1,1);
400
          const unsigned int geomID = prim.geomID(N);
401
          const unsigned int primID = prim.primID(N)[i];
402
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
403
          const Vec3fa ray_org(ray.org.x[k], ray.org.y[k], ray.org.z[k]);
404
          const TensorLinearCubicBezierSurface3fa curve = geom->getNormalOrientedCurve<typename Intersector::SourceCurve3ff, typename Intersector::SourceCurve3fa, TensorLinearCubicBezierSurface3fa>(context, ray_org, primID,ray.time()[k]);
405
          Intersector().intersect(pre,ray,k,context,geom,primID,curve,Epilog(ray,k,context,geomID,primID));
406
          mask &= movemask(tNear <= vfloat<M>(ray.tfar[k]));
407
        }
408
      }
409

410
      template<typename Intersector, typename Epilog>
411
        static __forceinline bool occluded_n(Precalculations& pre, RayK<K>& ray, const size_t k, RayQueryContext* context, const Primitive& prim)
412
      {
413
        vfloat<M> tNear;
414
        vbool<M> valid = intersect(ray,k,prim,tNear);
415

416
        const size_t N = prim.N;
417
        size_t mask = movemask(valid);
418
        while (mask)
419
        {
420
          const size_t i = bscf(mask);
421
          STAT3(shadow.trav_prims,1,1,1);
422
          const unsigned int geomID = prim.geomID(N);
423
          const unsigned int primID = prim.primID(N)[i];
424
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
425
          const Vec3fa ray_org(ray.org.x[k], ray.org.y[k], ray.org.z[k]);
426
          const TensorLinearCubicBezierSurface3fa curve = geom->getNormalOrientedCurve<typename Intersector::SourceCurve3ff, typename Intersector::SourceCurve3fa, TensorLinearCubicBezierSurface3fa>(context, ray_org, primID,ray.time()[k]);
427
          
428
          if (Intersector().intersect(pre,ray,k,context,geom,primID,curve,Epilog(ray,k,context,geomID,primID)))
429
            return true;
430

431
          mask &= movemask(tNear <= vfloat<M>(ray.tfar[k]));
432
        }
433
        return false;
434
      }
435

436
      template<typename Intersector, typename Epilog>
437
        static __forceinline void intersect_h(Precalculations& pre, RayHitK<K>& ray, const size_t k, RayQueryContext* context, const Primitive& prim)
438
      {
439
        
440
        vfloat<M> tNear;
441
        vbool<M> valid = intersect(ray,k,prim,tNear);
442

443
        const size_t N = prim.N;
444
        size_t mask = movemask(valid);
445
        while (mask)
446
        {
447
          const size_t i = bscf(mask);
448
          STAT3(normal.trav_prims,1,1,1);
449
          const unsigned int geomID = prim.geomID(N);
450
          const unsigned int primID = prim.primID(N)[i];
451
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
452
          Vec3ff p0,t0,p1,t1; geom->gather_hermite(p0,t0,p1,t1,geom->curve(primID),ray.time()[k]);
453
          Intersector().intersect(pre,ray,k,context,geom,primID,p0,t0,p1,t1,Epilog(ray,k,context,geomID,primID));
454
          mask &= movemask(tNear <= vfloat<M>(ray.tfar[k]));
455
        }
456
      }
457

458
      template<typename Intersector, typename Epilog>
459
        static __forceinline bool occluded_h(Precalculations& pre, RayK<K>& ray, const size_t k, RayQueryContext* context, const Primitive& prim)
460
      {
461
        vfloat<M> tNear;
462
        vbool<M> valid = intersect(ray,k,prim,tNear);
463

464
        const size_t N = prim.N;
465
        size_t mask = movemask(valid);
466
        while (mask)
467
        {
468
          const size_t i = bscf(mask);
469
          STAT3(shadow.trav_prims,1,1,1);
470
          const unsigned int geomID = prim.geomID(N);
471
          const unsigned int primID = prim.primID(N)[i];
472
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
473
          Vec3ff p0,t0,p1,t1; geom->gather_hermite(p0,t0,p1,t1,geom->curve(primID),ray.time()[k]);
474
          if (Intersector().intersect(pre,ray,k,context,geom,primID,p0,t0,p1,t1,Epilog(ray,k,context,geomID,primID)))
475
            return true;
476

477
          mask &= movemask(tNear <= vfloat<M>(ray.tfar[k]));
478
        }
479
        return false;
480
      }
481

482
      template<typename Intersector, typename Epilog>
483
        static __forceinline void intersect_hn(Precalculations& pre, RayHitK<K>& ray, const size_t k, RayQueryContext* context, const Primitive& prim)
484
      {
485
        
486
        vfloat<M> tNear;
487
        vbool<M> valid = intersect(ray,k,prim,tNear);
488

489
        const size_t N = prim.N;
490
        size_t mask = movemask(valid);
491
        while (mask)
492
        {
493
          const size_t i = bscf(mask);
494
          STAT3(normal.trav_prims,1,1,1);
495
          const unsigned int geomID = prim.geomID(N);
496
          const unsigned int primID = prim.primID(N)[i];
497
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
498
          const Vec3fa ray_org(ray.org.x[k], ray.org.y[k], ray.org.z[k]);
499
          const TensorLinearCubicBezierSurface3fa curve = geom->getNormalOrientedHermiteCurve<typename Intersector::SourceCurve3ff, typename Intersector::SourceCurve3fa, TensorLinearCubicBezierSurface3fa>(context, ray_org, primID,ray.time()[k]);
500
          Intersector().intersect(pre,ray,k,context,geom,primID,curve,Epilog(ray,k,context,geomID,primID));
501
          mask &= movemask(tNear <= vfloat<M>(ray.tfar[k]));
502
        }
503
      }
504

505
      template<typename Intersector, typename Epilog>
506
        static __forceinline bool occluded_hn(Precalculations& pre, RayK<K>& ray, const size_t k, RayQueryContext* context, const Primitive& prim)
507
      {
508
        vfloat<M> tNear;
509
        vbool<M> valid = intersect(ray,k,prim,tNear);
510

511
        const size_t N = prim.N;
512
        size_t mask = movemask(valid);
513
        while (mask)
514
        {
515
          const size_t i = bscf(mask);
516
          STAT3(shadow.trav_prims,1,1,1);
517
          const unsigned int geomID = prim.geomID(N);
518
          const unsigned int primID = prim.primID(N)[i];
519
          const CurveGeometry* geom = context->scene->get<CurveGeometry>(geomID);
520
          const Vec3fa ray_org(ray.org.x[k], ray.org.y[k], ray.org.z[k]);
521
          const TensorLinearCubicBezierSurface3fa curve = geom->getNormalOrientedHermiteCurve<typename Intersector::SourceCurve3ff, typename Intersector::SourceCurve3fa, TensorLinearCubicBezierSurface3fa>(context, ray_org, primID,ray.time()[k]);
522
          if (Intersector().intersect(pre,ray,k,context,geom,primID,curve,Epilog(ray,k,context,geomID,primID)))
523
            return true;
524

525
          mask &= movemask(tNear <= vfloat<M>(ray.tfar[k]));
526
        }
527
        return false;
528
      }
529
    };
530
  }
531
}
532

533
Product

Resources

Company
