CoCalc -- quad_intersector

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

4
#pragma once
5

6
#include "quadv.h"
7
#include "triangle_intersector_moeller.h"
8

9
namespace embree
10
{
11
  namespace isa
12
  {
13
    template<int M>
14
    struct QuadHitM
15
    {
16
      __forceinline QuadHitM() {}
17

18
      __forceinline QuadHitM(const vbool<M>& valid,
19
                             const vfloat<M>& U,
20
                             const vfloat<M>& V,
21
                             const vfloat<M>& T,
22
                             const vfloat<M>& absDen,
23
                             const Vec3vf<M>& Ng,
24
                             const vbool<M>& flags)
25
        : U(U), V(V), T(T), absDen(absDen), tri_Ng(Ng), valid(valid), flags(flags) {}
26

27
      __forceinline void finalize()
28
      {
29
        const vfloat<M> rcpAbsDen = rcp(absDen);
30
        vt = T * rcpAbsDen;
31
        const vfloat<M> u = min(U * rcpAbsDen,1.0f);
32
        const vfloat<M> v = min(V * rcpAbsDen,1.0f);
33
        const vfloat<M> u1 = vfloat<M>(1.0f) - u;
34
        const vfloat<M> v1 = vfloat<M>(1.0f) - v;
35
#if !defined(__AVX__) || defined(EMBREE_BACKFACE_CULLING)
36
        vu = select(flags,u1,u);
37
        vv = select(flags,v1,v);
38
        vNg = Vec3vf<M>(tri_Ng.x,tri_Ng.y,tri_Ng.z);
39
#else
40
        const vfloat<M> flip = select(flags,vfloat<M>(-1.0f),vfloat<M>(1.0f));
41
        vv = select(flags,u1,v);
42
        vu = select(flags,v1,u);
43
        vNg = Vec3vf<M>(flip*tri_Ng.x,flip*tri_Ng.y,flip*tri_Ng.z);
44
#endif
45
      }
46

47
      __forceinline Vec2f uv(const size_t i)
48
      {
49
        const float u = vu[i];
50
        const float v = vv[i];
51
        return Vec2f(u,v);
52
      }
53

54
      __forceinline float   t(const size_t i) { return vt[i]; }
55
      __forceinline Vec3fa Ng(const size_t i) { return Vec3fa(vNg.x[i],vNg.y[i],vNg.z[i]); }
56

57
    private:
58
      vfloat<M> U;
59
      vfloat<M> V;
60
      vfloat<M> T;
61
      vfloat<M> absDen;
62
      Vec3vf<M> tri_Ng;
63

64
    public:
65
      vbool<M> valid;
66
      vfloat<M> vu;
67
      vfloat<M> vv;
68
      vfloat<M> vt;
69
      Vec3vf<M> vNg;
70

71
    public:
72
      const vbool<M> flags;
73
    };
74

75
    template<int K>
76
    struct QuadHitK
77
    {
78
      __forceinline QuadHitK(const vfloat<K>& U,
79
                             const vfloat<K>& V,
80
                             const vfloat<K>& T,
81
                             const vfloat<K>& absDen,
82
                             const Vec3vf<K>& Ng,
83
                             const vbool<K>& flags)
84
        : U(U), V(V), T(T), absDen(absDen), flags(flags), tri_Ng(Ng) {}
85

86
      __forceinline std::tuple<vfloat<K>,vfloat<K>,vfloat<K>,Vec3vf<K>> operator() () const
87
      {
88
        const vfloat<K> rcpAbsDen = rcp(absDen);
89
        const vfloat<K> t = T * rcpAbsDen;
90
        const vfloat<K> u0 = min(U * rcpAbsDen,1.0f);
91
        const vfloat<K> v0 = min(V * rcpAbsDen,1.0f);
92
        const vfloat<K> u1 = vfloat<K>(1.0f) - u0;
93
        const vfloat<K> v1 = vfloat<K>(1.0f) - v0;
94
        const vfloat<K> u = select(flags,u1,u0);
95
        const vfloat<K> v = select(flags,v1,v0);
96
        const Vec3vf<K> Ng(tri_Ng.x,tri_Ng.y,tri_Ng.z);
97
        return std::make_tuple(u,v,t,Ng);
98
      }
99

100
    private:
101
      const vfloat<K> U;
102
      const vfloat<K> V;
103
      const vfloat<K> T;
104
      const vfloat<K> absDen;
105
      const vbool<K> flags;
106
      const Vec3vf<K> tri_Ng;
107
    };
108

109
    /* ----------------------------- */
110
    /* -- single ray intersectors -- */
111
    /* ----------------------------- */
112

113

114
    template<int M, bool filter>
115
    struct QuadMIntersector1MoellerTrumbore;
116

117
    /*! Intersects M quads with 1 ray */
118
    template<int M, bool filter>
119
    struct QuadMIntersector1MoellerTrumbore
120
    {
121
      __forceinline QuadMIntersector1MoellerTrumbore() {}
122

123
      __forceinline QuadMIntersector1MoellerTrumbore(const Ray& ray, const void* ptr) {}
124

125
      __forceinline void intersect(RayHit& ray, RayQueryContext* context,
126
                                   const Vec3vf<M>& v0, const Vec3vf<M>& v1, const Vec3vf<M>& v2, const Vec3vf<M>& v3,
127
                                   const vuint<M>& geomID, const vuint<M>& primID) const
128
      {
129
        UVIdentity<M> mapUV;
130
        MoellerTrumboreHitM<M,UVIdentity<M>> hit(mapUV);
131
        MoellerTrumboreIntersector1<M> intersector(ray,nullptr);
132
        Intersect1EpilogM<M,filter> epilog(ray,context,geomID,primID);
133

134
        /* intersect first triangle */
135
        if (intersector.intersect(ray,v0,v1,v3,mapUV,hit)) 
136
          epilog(hit.valid,hit);
137

138
        /* intersect second triangle */
139
        if (intersector.intersect(ray,v2,v3,v1,mapUV,hit)) 
140
        {
141
          hit.U = hit.absDen - hit.U;
142
          hit.V = hit.absDen - hit.V;
143
          epilog(hit.valid,hit);
144
        }
145
      }
146
      
147
      __forceinline bool occluded(Ray& ray, RayQueryContext* context,
148
                                  const Vec3vf<M>& v0, const Vec3vf<M>& v1, const Vec3vf<M>& v2, const Vec3vf<M>& v3,
149
                                  const vuint<M>& geomID, const vuint<M>& primID) const
150
      {
151
        UVIdentity<M> mapUV;
152
        MoellerTrumboreHitM<M,UVIdentity<M>> hit(mapUV);
153
        MoellerTrumboreIntersector1<M> intersector(ray,nullptr);
154
        Occluded1EpilogM<M,filter> epilog(ray,context,geomID,primID);
155

156
        /* intersect first triangle */
157
        if (intersector.intersect(ray,v0,v1,v3,mapUV,hit)) 
158
        {
159
          if (epilog(hit.valid,hit))
160
            return true;
161
        }
162

163
        /* intersect second triangle */
164
        if (intersector.intersect(ray,v2,v3,v1,mapUV,hit)) 
165
        {
166
          hit.U = hit.absDen - hit.U;
167
          hit.V = hit.absDen - hit.V;
168
          if (epilog(hit.valid,hit))
169
            return true;
170
        }
171
        return false;
172
      }
173
    };
174

175
#if defined(__AVX__)
176

177
    /*! Intersects 4 quads with 1 ray using AVX */
178
    template<bool filter>
179
    struct QuadMIntersector1MoellerTrumbore<4,filter>
180
    {
181
      __forceinline QuadMIntersector1MoellerTrumbore() {}
182

183
      __forceinline QuadMIntersector1MoellerTrumbore(const Ray& ray, const void* ptr) {}
184
      
185
      template<typename Epilog>
186
      __forceinline bool intersect(Ray& ray, const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3, const Epilog& epilog) const
187
      {
188
        const Vec3vf8 vtx0(vfloat8(v0.x,v2.x),vfloat8(v0.y,v2.y),vfloat8(v0.z,v2.z));
189
#if !defined(EMBREE_BACKFACE_CULLING)
190
        const Vec3vf8 vtx1(vfloat8(v1.x),vfloat8(v1.y),vfloat8(v1.z));
191
        const Vec3vf8 vtx2(vfloat8(v3.x),vfloat8(v3.y),vfloat8(v3.z));        
192
#else
193
        const Vec3vf8 vtx1(vfloat8(v1.x,v3.x),vfloat8(v1.y,v3.y),vfloat8(v1.z,v3.z));
194
        const Vec3vf8 vtx2(vfloat8(v3.x,v1.x),vfloat8(v3.y,v1.y),vfloat8(v3.z,v1.z));
195
#endif
196
        UVIdentity<8> mapUV;
197
        MoellerTrumboreHitM<8,UVIdentity<8>> hit(mapUV);
198
        MoellerTrumboreIntersector1<8> intersector(ray,nullptr);
199
        const vbool8 flags(0,0,0,0,1,1,1,1);
200
        if (unlikely(intersector.intersect(ray,vtx0,vtx1,vtx2,mapUV,hit)))
201
        {
202
          vfloat8 U = hit.U, V = hit.V, absDen = hit.absDen;
203

204
#if !defined(EMBREE_BACKFACE_CULLING)
205
          hit.U = select(flags,absDen-V,U);
206
          hit.V = select(flags,absDen-U,V);
207
          hit.vNg *= select(flags,vfloat8(-1.0f),vfloat8(1.0f)); // FIXME: use XOR
208
#else
209
          hit.U = select(flags,absDen-U,U);
210
          hit.V = select(flags,absDen-V,V);
211
#endif
212
          if (unlikely(epilog(hit.valid,hit)))
213
            return true;
214
        }
215
        return false;
216
      }
217
      
218
      __forceinline bool intersect(RayHit& ray, RayQueryContext* context,
219
                                   const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3, 
220
                                   const vuint4& geomID, const vuint4& primID) const
221
      {
222
        return intersect(ray,v0,v1,v2,v3,Intersect1EpilogM<8,filter>(ray,context,vuint8(geomID),vuint8(primID)));
223
      }
224
      
225
      __forceinline bool occluded(Ray& ray, RayQueryContext* context,
226
                                  const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3, 
227
                                  const vuint4& geomID, const vuint4& primID) const
228
      {
229
        return intersect(ray,v0,v1,v2,v3,Occluded1EpilogM<8,filter>(ray,context,vuint8(geomID),vuint8(primID)));
230
      }
231
    };
232

233
#endif
234

235
    /* ----------------------------- */
236
    /* -- ray packet intersectors -- */
237
    /* ----------------------------- */
238

239

240
    struct MoellerTrumboreIntersector1KTriangleM
241
    {
242
      /*! Intersect k'th ray from ray packet of size K with M triangles. */
243
      template<int M, int K, typename Epilog>
244
      static  __forceinline bool intersect(RayK<K>& ray,
245
                                           size_t k,
246
                                           const Vec3vf<M>& tri_v0,
247
                                           const Vec3vf<M>& tri_e1,
248
                                           const Vec3vf<M>& tri_e2,
249
                                           const Vec3vf<M>& tri_Ng,
250
                                           const vbool<M>& flags,
251
                                           const Epilog& epilog)
252
      {
253
        /* calculate denominator */
254
        const Vec3vf<M> O = broadcast<vfloat<M>>(ray.org,k);
255
        const Vec3vf<M> D = broadcast<vfloat<M>>(ray.dir,k);
256
        const Vec3vf<M> C = Vec3vf<M>(tri_v0) - O;
257
        const Vec3vf<M> R = cross(C,D);
258
        const vfloat<M> den = dot(Vec3vf<M>(tri_Ng),D);
259
        const vfloat<M> absDen = abs(den);
260
        const vfloat<M> sgnDen = signmsk(den);
261
        
262
        /* perform edge tests */
263
        const vfloat<M> U = dot(R,Vec3vf<M>(tri_e2)) ^ sgnDen;
264
        const vfloat<M> V = dot(R,Vec3vf<M>(tri_e1)) ^ sgnDen;
265
        
266
        /* perform backface culling */
267
#if defined(EMBREE_BACKFACE_CULLING)
268
        vbool<M> valid = (den < vfloat<M>(zero)) & (U >= 0.0f) & (V >= 0.0f) & (U+V<=absDen);
269
#else
270
        vbool<M> valid = (den != vfloat<M>(zero)) & (U >= 0.0f) & (V >= 0.0f) & (U+V<=absDen);
271
#endif
272
        if (likely(none(valid))) return false;
273
        
274
        /* perform depth test */
275
        const vfloat<M> T = dot(Vec3vf<M>(tri_Ng),C) ^ sgnDen;
276
        valid &= (absDen*vfloat<M>(ray.tnear()[k]) < T) & (T <= absDen*vfloat<M>(ray.tfar[k]));
277
        if (likely(none(valid))) return false;
278
        
279
        /* calculate hit information */
280
        QuadHitM<M> hit(valid,U,V,T,absDen,tri_Ng,flags);
281
        return epilog(valid,hit);
282
      }
283
      
284
      template<int M, int K, typename Epilog>
285
      static __forceinline bool intersect1(RayK<K>& ray,
286
                                           size_t k,
287
                                           const Vec3vf<M>& v0,
288
                                           const Vec3vf<M>& v1,
289
                                           const Vec3vf<M>& v2,
290
                                           const vbool<M>& flags,
291
                                           const Epilog& epilog)
292
      {
293
        const Vec3vf<M> e1 = v0-v1;
294
        const Vec3vf<M> e2 = v2-v0;
295
        const Vec3vf<M> Ng = cross(e2,e1);
296
        return intersect<M,K>(ray,k,v0,e1,e2,Ng,flags,epilog);
297
      }
298
    };
299

300
    template<int M, int K, bool filter>
301
    struct QuadMIntersectorKMoellerTrumboreBase
302
    {
303
      __forceinline QuadMIntersectorKMoellerTrumboreBase(const vbool<K>& valid, const RayK<K>& ray) {}
304
            
305
      /*! Intersects K rays with one of M triangles. */
306
      template<typename Epilog>
307
      __forceinline vbool<K> intersectK(const vbool<K>& valid0,
308
                                        RayK<K>& ray,
309
                                        const Vec3vf<K>& tri_v0,
310
                                        const Vec3vf<K>& tri_e1,
311
                                        const Vec3vf<K>& tri_e2,
312
                                        const Vec3vf<K>& tri_Ng,
313
                                        const vbool<K>& flags,
314
                                        const Epilog& epilog) const
315
      { 
316
        /* calculate denominator */
317
        vbool<K> valid = valid0;
318
        const Vec3vf<K> C = tri_v0 - ray.org;
319
        const Vec3vf<K> R = cross(C,ray.dir);
320
        const vfloat<K> den = dot(tri_Ng,ray.dir);
321
        const vfloat<K> absDen = abs(den);
322
        const vfloat<K> sgnDen = signmsk(den);
323
        
324
        /* test against edge p2 p0 */
325
        const vfloat<K> U = dot(R,tri_e2) ^ sgnDen;
326
        valid &= U >= 0.0f;
327
        if (likely(none(valid))) return false;
328
        
329
        /* test against edge p0 p1 */
330
        const vfloat<K> V = dot(R,tri_e1) ^ sgnDen;
331
        valid &= V >= 0.0f;
332
        if (likely(none(valid))) return false;
333
        
334
        /* test against edge p1 p2 */
335
        const vfloat<K> W = absDen-U-V;
336
        valid &= W >= 0.0f;
337
        if (likely(none(valid))) return false;
338
        
339
        /* perform depth test */
340
        const vfloat<K> T = dot(tri_Ng,C) ^ sgnDen;
341
        valid &= (absDen*ray.tnear() < T) & (T <= absDen*ray.tfar);
342
        if (unlikely(none(valid))) return false;
343
        
344
        /* perform backface culling */
345
#if defined(EMBREE_BACKFACE_CULLING)
346
        valid &= den < vfloat<K>(zero);
347
        if (unlikely(none(valid))) return false;
348
#else
349
        valid &= den != vfloat<K>(zero);
350
        if (unlikely(none(valid))) return false;
351
#endif
352
        
353
        /* calculate hit information */
354
        QuadHitK<K> hit(U,V,T,absDen,tri_Ng,flags);
355
        return epilog(valid,hit);
356
      }
357
      
358
      /*! Intersects K rays with one of M quads. */
359
      template<typename Epilog>
360
      __forceinline vbool<K> intersectK(const vbool<K>& valid0, 
361
                                        RayK<K>& ray,
362
                                        const Vec3vf<K>& tri_v0,
363
                                        const Vec3vf<K>& tri_v1,
364
                                        const Vec3vf<K>& tri_v2,
365
                                        const vbool<K>& flags,
366
                                        const Epilog& epilog) const
367
      {
368
        const Vec3vf<K> e1 = tri_v0-tri_v1;
369
        const Vec3vf<K> e2 = tri_v2-tri_v0;
370
        const Vec3vf<K> Ng = cross(e2,e1);
371
        return intersectK(valid0,ray,tri_v0,e1,e2,Ng,flags,epilog);
372
      }
373

374
      /*! Intersects K rays with one of M quads. */
375
      template<typename Epilog>
376
      __forceinline bool intersectK(const vbool<K>& valid0, 
377
                                    RayK<K>& ray,
378
                                    const Vec3vf<K>& v0,
379
                                    const Vec3vf<K>& v1,
380
                                    const Vec3vf<K>& v2,
381
                                    const Vec3vf<K>& v3,
382
                                    const Epilog& epilog) const
383
      {
384
        intersectK(valid0,ray,v0,v1,v3,vbool<K>(false),epilog);
385
        if (none(valid0)) return true;
386
        intersectK(valid0,ray,v2,v3,v1,vbool<K>(true ),epilog);
387
        return none(valid0);
388
      }
389
    };
390

391
    template<int M, int K, bool filter>
392
    struct QuadMIntersectorKMoellerTrumbore : public QuadMIntersectorKMoellerTrumboreBase<M,K,filter>
393
    {
394
      __forceinline QuadMIntersectorKMoellerTrumbore(const vbool<K>& valid, const RayK<K>& ray)
395
        : QuadMIntersectorKMoellerTrumboreBase<M,K,filter>(valid,ray) {}
396

397
      __forceinline void intersect1(RayHitK<K>& ray, size_t k, RayQueryContext* context,
398
                                    const Vec3vf<M>& v0, const Vec3vf<M>& v1, const Vec3vf<M>& v2, const Vec3vf<M>& v3,
399
                                    const vuint<M>& geomID, const vuint<M>& primID) const
400
      {
401
        Intersect1KEpilogM<M,K,filter> epilog(ray,k,context,geomID,primID);
402
        MoellerTrumboreIntersector1KTriangleM::intersect1<M,K>(ray,k,v0,v1,v3,vbool<M>(false),epilog);
403
        MoellerTrumboreIntersector1KTriangleM::intersect1<M,K>(ray,k,v2,v3,v1,vbool<M>(true ),epilog);
404
      }
405
      
406
      __forceinline bool occluded1(RayK<K>& ray, size_t k, RayQueryContext* context,
407
                                   const Vec3vf<M>& v0, const Vec3vf<M>& v1, const Vec3vf<M>& v2, const Vec3vf<M>& v3,
408
                                   const vuint<M>& geomID, const vuint<M>& primID) const
409
      {
410
        Occluded1KEpilogM<M,K,filter> epilog(ray,k,context,geomID,primID);
411
        if (MoellerTrumboreIntersector1KTriangleM::intersect1<M,K>(ray,k,v0,v1,v3,vbool<M>(false),epilog)) return true;
412
        if (MoellerTrumboreIntersector1KTriangleM::intersect1<M,K>(ray,k,v2,v3,v1,vbool<M>(true ),epilog)) return true;
413
        return false;
414
      }
415
    };
416

417

418
#if defined(__AVX__)
419

420
    /*! Intersects 4 quads with 1 ray using AVX */
421
    template<int K, bool filter>
422
    struct QuadMIntersectorKMoellerTrumbore<4,K,filter> : public QuadMIntersectorKMoellerTrumboreBase<4,K,filter>
423
    {
424
      __forceinline QuadMIntersectorKMoellerTrumbore(const vbool<K>& valid, const RayK<K>& ray)
425
        : QuadMIntersectorKMoellerTrumboreBase<4,K,filter>(valid,ray) {}
426
      
427
      template<typename Epilog>
428
      __forceinline bool intersect1(RayK<K>& ray, size_t k,
429
                                    const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3, const Epilog& epilog) const
430
      {
431
        const Vec3vf8 vtx0(vfloat8(v0.x,v2.x),vfloat8(v0.y,v2.y),vfloat8(v0.z,v2.z));
432
#if !defined(EMBREE_BACKFACE_CULLING)
433
        const Vec3vf8 vtx1(vfloat8(v1.x),vfloat8(v1.y),vfloat8(v1.z));
434
        const Vec3vf8 vtx2(vfloat8(v3.x),vfloat8(v3.y),vfloat8(v3.z));
435
#else
436
        const Vec3vf8 vtx1(vfloat8(v1.x,v3.x),vfloat8(v1.y,v3.y),vfloat8(v1.z,v3.z));
437
        const Vec3vf8 vtx2(vfloat8(v3.x,v1.x),vfloat8(v3.y,v1.y),vfloat8(v3.z,v1.z));
438
#endif
439
        const vbool8 flags(0,0,0,0,1,1,1,1);
440
        return MoellerTrumboreIntersector1KTriangleM::intersect1<8,K>(ray,k,vtx0,vtx1,vtx2,flags,epilog); 
441
      }
442
      
443
      __forceinline bool intersect1(RayHitK<K>& ray, size_t k, RayQueryContext* context,
444
                                    const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3, 
445
                                    const vuint4& geomID, const vuint4& primID) const
446
      {
447
        return intersect1(ray,k,v0,v1,v2,v3,Intersect1KEpilogM<8,K,filter>(ray,k,context,vuint8(geomID),vuint8(primID)));
448
      }
449
      
450
      __forceinline bool occluded1(RayK<K>& ray, size_t k, RayQueryContext* context,
451
                                   const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3, 
452
                                   const vuint4& geomID, const vuint4& primID) const
453
      {
454
        return intersect1(ray,k,v0,v1,v2,v3,Occluded1KEpilogM<8,K,filter>(ray,k,context,vuint8(geomID),vuint8(primID)));
455
      }
456
    };
457

458
#endif
459
  }
460
}
461

462
Product

Resources

Company
