quad_intersector_moeller.h

++ // Copyright 2009-2021 Intel Corporation

++ // SPDX-License-Identifier: Apache-2.0

++

++ #pragma once

++

++ #include "quadv.h"

++ #include "triangle_intersector_moeller.h"

++

++ namespace embree

++ {

++   namespace isa

++   {

++     template<int M>

++     struct QuadHitM

++     {

++       __forceinline QuadHitM() {}

++

++       __forceinline QuadHitM(const vbool<M>& valid,

++                              const vfloat<M>& U,

++                              const vfloat<M>& V,

++                              const vfloat<M>& T,

++                              const vfloat<M>& absDen,

++                              const Vec3vf<M>& Ng,

++                              const vbool<M>& flags)

++         : U(U), V(V), T(T), absDen(absDen), tri_Ng(Ng), valid(valid), flags(flags) {}

++

++       __forceinline void finalize()

++       {

++         const vfloat<M> rcpAbsDen = rcp(absDen);

++         vt = T * rcpAbsDen;

++         const vfloat<M> u = min(U * rcpAbsDen,1.0f);

++         const vfloat<M> v = min(V * rcpAbsDen,1.0f);

++         const vfloat<M> u1 = vfloat<M>(1.0f) - u;

++         const vfloat<M> v1 = vfloat<M>(1.0f) - v;

++ #if !defined(__AVX__) || defined(EMBREE_BACKFACE_CULLING)

++         vu = select(flags,u1,u);

++         vv = select(flags,v1,v);

++         vNg = Vec3vf<M>(tri_Ng.x,tri_Ng.y,tri_Ng.z);

++ #else

++         const vfloat<M> flip = select(flags,vfloat<M>(-1.0f),vfloat<M>(1.0f));

++         vv = select(flags,u1,v);

++         vu = select(flags,v1,u);

++         vNg = Vec3vf<M>(flip*tri_Ng.x,flip*tri_Ng.y,flip*tri_Ng.z);

++ #endif

++       }

++

++       __forceinline Vec2f uv(const size_t i)

++       {

++         const float u = vu[i];

++         const float v = vv[i];

++         return Vec2f(u,v);

++       }

++

++       __forceinline float   t(const size_t i) { return vt[i]; }

++       __forceinline Vec3fa Ng(const size_t i) { return Vec3fa(vNg.x[i],vNg.y[i],vNg.z[i]); }

++

++     private:

++       vfloat<M> U;

++       vfloat<M> V;

++       vfloat<M> T;

++       vfloat<M> absDen;

++       Vec3vf<M> tri_Ng;

++

++     public:

++       vbool<M> valid;

++       vfloat<M> vu;

++       vfloat<M> vv;

++       vfloat<M> vt;

++       Vec3vf<M> vNg;

++

++     public:

++       const vbool<M> flags;

++     };

++

++     template<int K>

++     struct QuadHitK

++     {

++       __forceinline QuadHitK(const vfloat<K>& U,

++                              const vfloat<K>& V,

++                              const vfloat<K>& T,

++                              const vfloat<K>& absDen,

++                              const Vec3vf<K>& Ng,

++                              const vbool<K>& flags)

++         : U(U), V(V), T(T), absDen(absDen), flags(flags), tri_Ng(Ng) {}

++

++       __forceinline std::tuple<vfloat<K>,vfloat<K>,vfloat<K>,Vec3vf<K>> operator() () const

++       {

++         const vfloat<K> rcpAbsDen = rcp(absDen);

++         const vfloat<K> t = T * rcpAbsDen;

++         const vfloat<K> u0 = min(U * rcpAbsDen,1.0f);

++         const vfloat<K> v0 = min(V * rcpAbsDen,1.0f);

++         const vfloat<K> u1 = vfloat<K>(1.0f) - u0;

++         const vfloat<K> v1 = vfloat<K>(1.0f) - v0;

++         const vfloat<K> u = select(flags,u1,u0);

++         const vfloat<K> v = select(flags,v1,v0);

++         const Vec3vf<K> Ng(tri_Ng.x,tri_Ng.y,tri_Ng.z);

++         return std::make_tuple(u,v,t,Ng);

++       }

++

++     private:

++       const vfloat<K> U;

++       const vfloat<K> V;

++       const vfloat<K> T;

++       const vfloat<K> absDen;

++       const vbool<K> flags;

++       const Vec3vf<K> tri_Ng;

++     };

++

++     /* ----------------------------- */

++     /* -- single ray intersectors -- */

++     /* ----------------------------- */

++

++

++     template<int M, bool filter>

++     struct QuadMIntersector1MoellerTrumbore;

++

++     /*! Intersects M quads with 1 ray */

++     template<int M, bool filter>

++     struct QuadMIntersector1MoellerTrumbore

++     {

++       __forceinline QuadMIntersector1MoellerTrumbore() {}

++

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

++

++       __forceinline void intersect(RayHit& ray, IntersectContext* context,

++                                    const Vec3vf<M>& v0, const Vec3vf<M>& v1, const Vec3vf<M>& v2, const Vec3vf<M>& v3,

++                                    const vuint<M>& geomID, const vuint<M>& primID) const

++       {

++         UVIdentity<M> mapUV;

++         MoellerTrumboreHitM<M,UVIdentity<M>> hit(mapUV);

++         MoellerTrumboreIntersector1<M> intersector(ray,nullptr);

++         Intersect1EpilogM<M,filter> epilog(ray,context,geomID,primID);

++

++         /* intersect first triangle */

++         if (intersector.intersect(ray,v0,v1,v3,mapUV,hit))

++           epilog(hit.valid,hit);

++

++         /* intersect second triangle */

++         if (intersector.intersect(ray,v2,v3,v1,mapUV,hit))

++         {

++           hit.U = hit.absDen - hit.U;

++           hit.V = hit.absDen - hit.V;

++           epilog(hit.valid,hit);

++         }

++       }

++

++       __forceinline bool occluded(Ray& ray, IntersectContext* context,

++                                   const Vec3vf<M>& v0, const Vec3vf<M>& v1, const Vec3vf<M>& v2, const Vec3vf<M>& v3,

++                                   const vuint<M>& geomID, const vuint<M>& primID) const

++       {

++         UVIdentity<M> mapUV;

++         MoellerTrumboreHitM<M,UVIdentity<M>> hit(mapUV);

++         MoellerTrumboreIntersector1<M> intersector(ray,nullptr);

++         Occluded1EpilogM<M,filter> epilog(ray,context,geomID,primID);

++

++         /* intersect first triangle */

++         if (intersector.intersect(ray,v0,v1,v3,mapUV,hit))

++         {

++           if (epilog(hit.valid,hit))

++             return true;

++         }

++

++         /* intersect second triangle */

++         if (intersector.intersect(ray,v2,v3,v1,mapUV,hit))

++         {

++           hit.U = hit.absDen - hit.U;

++           hit.V = hit.absDen - hit.V;

++           if (epilog(hit.valid,hit))

++             return true;

++         }

++         return false;

++       }

++     };

++

++ #if defined(__AVX__)

++

++     /*! Intersects 4 quads with 1 ray using AVX */

++     template<bool filter>

++     struct QuadMIntersector1MoellerTrumbore<4,filter>

++     {

++       __forceinline QuadMIntersector1MoellerTrumbore() {}

++

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

++

++       template<typename Epilog>

++       __forceinline bool intersect(Ray& ray, const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3, const Epilog& epilog) const

++       {

++         const Vec3vf8 vtx0(vfloat8(v0.x,v2.x),vfloat8(v0.y,v2.y),vfloat8(v0.z,v2.z));

++ #if !defined(EMBREE_BACKFACE_CULLING)

++         const Vec3vf8 vtx1(vfloat8(v1.x),vfloat8(v1.y),vfloat8(v1.z));

++         const Vec3vf8 vtx2(vfloat8(v3.x),vfloat8(v3.y),vfloat8(v3.z));

++ #else

++         const Vec3vf8 vtx1(vfloat8(v1.x,v3.x),vfloat8(v1.y,v3.y),vfloat8(v1.z,v3.z));

++         const Vec3vf8 vtx2(vfloat8(v3.x,v1.x),vfloat8(v3.y,v1.y),vfloat8(v3.z,v1.z));

++ #endif

++         UVIdentity<8> mapUV;

++         MoellerTrumboreHitM<8,UVIdentity<8>> hit(mapUV);

++         MoellerTrumboreIntersector1<8> intersector(ray,nullptr);

++         const vbool8 flags(0,0,0,0,1,1,1,1);

++         if (unlikely(intersector.intersect(ray,vtx0,vtx1,vtx2,mapUV,hit)))

++         {

++           vfloat8 U = hit.U, V = hit.V, absDen = hit.absDen;

++

++ #if !defined(EMBREE_BACKFACE_CULLING)

++           hit.U = select(flags,absDen-V,U);

++           hit.V = select(flags,absDen-U,V);

++           hit.vNg *= select(flags,vfloat8(-1.0f),vfloat8(1.0f)); // FIXME: use XOR

++ #else

++           hit.U = select(flags,absDen-U,U);

++           hit.V = select(flags,absDen-V,V);

++ #endif

++           if (unlikely(epilog(hit.valid,hit)))

++             return true;

++         }

++         return false;

++       }

++

++       __forceinline bool intersect(RayHit& ray, IntersectContext* context,

++                                    const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3,

++                                    const vuint4& geomID, const vuint4& primID) const

++       {

++         return intersect(ray,v0,v1,v2,v3,Intersect1EpilogM<8,filter>(ray,context,vuint8(geomID),vuint8(primID)));

++       }

++

++       __forceinline bool occluded(Ray& ray, IntersectContext* context,

++                                   const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3,

++                                   const vuint4& geomID, const vuint4& primID) const

++       {

++         return intersect(ray,v0,v1,v2,v3,Occluded1EpilogM<8,filter>(ray,context,vuint8(geomID),vuint8(primID)));

++       }

++     };

++

++ #endif

++

++     /* ----------------------------- */

++     /* -- ray packet intersectors -- */

++     /* ----------------------------- */

++

++

++     struct MoellerTrumboreIntersector1KTriangleM

++     {

++       /*! Intersect k'th ray from ray packet of size K with M triangles. */

++       template<int M, int K, typename Epilog>

++       static  __forceinline bool intersect(RayK<K>& ray,

++                                            size_t k,

++                                            const Vec3vf<M>& tri_v0,

++                                            const Vec3vf<M>& tri_e1,

++                                            const Vec3vf<M>& tri_e2,

++                                            const Vec3vf<M>& tri_Ng,

++                                            const vbool<M>& flags,

++                                            const Epilog& epilog)

++       {

++         /* calculate denominator */

++         const Vec3vf<M> O = broadcast<vfloat<M>>(ray.org,k);

++         const Vec3vf<M> D = broadcast<vfloat<M>>(ray.dir,k);

++         const Vec3vf<M> C = Vec3vf<M>(tri_v0) - O;

++         const Vec3vf<M> R = cross(C,D);

++         const vfloat<M> den = dot(Vec3vf<M>(tri_Ng),D);

++         const vfloat<M> absDen = abs(den);

++         const vfloat<M> sgnDen = signmsk(den);

++

++         /* perform edge tests */

++         const vfloat<M> U = dot(R,Vec3vf<M>(tri_e2)) ^ sgnDen;

++         const vfloat<M> V = dot(R,Vec3vf<M>(tri_e1)) ^ sgnDen;

++

++         /* perform backface culling */

++ #if defined(EMBREE_BACKFACE_CULLING)

++         vbool<M> valid = (den < vfloat<M>(zero)) & (U >= 0.0f) & (V >= 0.0f) & (U+V<=absDen);

++ #else

++         vbool<M> valid = (den != vfloat<M>(zero)) & (U >= 0.0f) & (V >= 0.0f) & (U+V<=absDen);

++ #endif

++         if (likely(none(valid))) return false;

++

++         /* perform depth test */

++         const vfloat<M> T = dot(Vec3vf<M>(tri_Ng),C) ^ sgnDen;

++         valid &= (absDen*vfloat<M>(ray.tnear()[k]) < T) & (T <= absDen*vfloat<M>(ray.tfar[k]));

++         if (likely(none(valid))) return false;

++

++         /* calculate hit information */

++         QuadHitM<M> hit(valid,U,V,T,absDen,tri_Ng,flags);

++         return epilog(valid,hit);

++       }

++

++       template<int M, int K, typename Epilog>

++       static __forceinline bool intersect1(RayK<K>& ray,

++                                            size_t k,

++                                            const Vec3vf<M>& v0,

++                                            const Vec3vf<M>& v1,

++                                            const Vec3vf<M>& v2,

++                                            const vbool<M>& flags,

++                                            const Epilog& epilog)

++       {

++         const Vec3vf<M> e1 = v0-v1;

++         const Vec3vf<M> e2 = v2-v0;

++         const Vec3vf<M> Ng = cross(e2,e1);

++         return intersect<M,K>(ray,k,v0,e1,e2,Ng,flags,epilog);

++       }

++     };

++

++     template<int M, int K, bool filter>

++     struct QuadMIntersectorKMoellerTrumboreBase

++     {

++       __forceinline QuadMIntersectorKMoellerTrumboreBase(const vbool<K>& valid, const RayK<K>& ray) {}

++

++       /*! Intersects K rays with one of M triangles. */

++       template<typename Epilog>

++       __forceinline vbool<K> intersectK(const vbool<K>& valid0,

++                                         RayK<K>& ray,

++                                         const Vec3vf<K>& tri_v0,

++                                         const Vec3vf<K>& tri_e1,

++                                         const Vec3vf<K>& tri_e2,

++                                         const Vec3vf<K>& tri_Ng,

++                                         const vbool<K>& flags,

++                                         const Epilog& epilog) const

++       {

++         /* calculate denominator */

++         vbool<K> valid = valid0;

++         const Vec3vf<K> C = tri_v0 - ray.org;

++         const Vec3vf<K> R = cross(C,ray.dir);

++         const vfloat<K> den = dot(tri_Ng,ray.dir);

++         const vfloat<K> absDen = abs(den);

++         const vfloat<K> sgnDen = signmsk(den);

++

++         /* test against edge p2 p0 */

++         const vfloat<K> U = dot(R,tri_e2) ^ sgnDen;

++         valid &= U >= 0.0f;

++         if (likely(none(valid))) return false;

++

++         /* test against edge p0 p1 */

++         const vfloat<K> V = dot(R,tri_e1) ^ sgnDen;

++         valid &= V >= 0.0f;

++         if (likely(none(valid))) return false;

++

++         /* test against edge p1 p2 */

++         const vfloat<K> W = absDen-U-V;

++         valid &= W >= 0.0f;

++         if (likely(none(valid))) return false;

++

++         /* perform depth test */

++         const vfloat<K> T = dot(tri_Ng,C) ^ sgnDen;

++         valid &= (absDen*ray.tnear() < T) & (T <= absDen*ray.tfar);

++         if (unlikely(none(valid))) return false;

++

++         /* perform backface culling */

++ #if defined(EMBREE_BACKFACE_CULLING)

++         valid &= den < vfloat<K>(zero);

++         if (unlikely(none(valid))) return false;

++ #else

++         valid &= den != vfloat<K>(zero);

++         if (unlikely(none(valid))) return false;

++ #endif

++

++         /* calculate hit information */

++         QuadHitK<K> hit(U,V,T,absDen,tri_Ng,flags);

++         return epilog(valid,hit);

++       }

++

++       /*! Intersects K rays with one of M quads. */

++       template<typename Epilog>

++       __forceinline vbool<K> intersectK(const vbool<K>& valid0,

++                                         RayK<K>& ray,

++                                         const Vec3vf<K>& tri_v0,

++                                         const Vec3vf<K>& tri_v1,

++                                         const Vec3vf<K>& tri_v2,

++                                         const vbool<K>& flags,

++                                         const Epilog& epilog) const

++       {

++         const Vec3vf<K> e1 = tri_v0-tri_v1;

++         const Vec3vf<K> e2 = tri_v2-tri_v0;

++         const Vec3vf<K> Ng = cross(e2,e1);

++         return intersectK(valid0,ray,tri_v0,e1,e2,Ng,flags,epilog);

++       }

++

++       /*! Intersects K rays with one of M quads. */

++       template<typename Epilog>

++       __forceinline bool intersectK(const vbool<K>& valid0,

++                                     RayK<K>& ray,

++                                     const Vec3vf<K>& v0,

++                                     const Vec3vf<K>& v1,

++                                     const Vec3vf<K>& v2,

++                                     const Vec3vf<K>& v3,

++                                     const Epilog& epilog) const

++       {

++         intersectK(valid0,ray,v0,v1,v3,vbool<K>(false),epilog);

++         if (none(valid0)) return true;

++         intersectK(valid0,ray,v2,v3,v1,vbool<K>(true ),epilog);

++         return none(valid0);

++       }

++     };

++

++     template<int M, int K, bool filter>

++     struct QuadMIntersectorKMoellerTrumbore : public QuadMIntersectorKMoellerTrumboreBase<M,K,filter>

++     {

++       __forceinline QuadMIntersectorKMoellerTrumbore(const vbool<K>& valid, const RayK<K>& ray)

++         : QuadMIntersectorKMoellerTrumboreBase<M,K,filter>(valid,ray) {}

++

++       __forceinline void intersect1(RayHitK<K>& ray, size_t k, IntersectContext* context,

++                                     const Vec3vf<M>& v0, const Vec3vf<M>& v1, const Vec3vf<M>& v2, const Vec3vf<M>& v3,

++                                     const vuint<M>& geomID, const vuint<M>& primID) const

++       {

++         Intersect1KEpilogM<M,K,filter> epilog(ray,k,context,geomID,primID);

++         MoellerTrumboreIntersector1KTriangleM::intersect1<M,K>(ray,k,v0,v1,v3,vbool<M>(false),epilog);

++         MoellerTrumboreIntersector1KTriangleM::intersect1<M,K>(ray,k,v2,v3,v1,vbool<M>(true ),epilog);

++       }

++

++       __forceinline bool occluded1(RayK<K>& ray, size_t k, IntersectContext* context,

++                                    const Vec3vf<M>& v0, const Vec3vf<M>& v1, const Vec3vf<M>& v2, const Vec3vf<M>& v3,

++                                    const vuint<M>& geomID, const vuint<M>& primID) const

++       {

++         Occluded1KEpilogM<M,K,filter> epilog(ray,k,context,geomID,primID);

++         if (MoellerTrumboreIntersector1KTriangleM::intersect1<M,K>(ray,k,v0,v1,v3,vbool<M>(false),epilog)) return true;

++         if (MoellerTrumboreIntersector1KTriangleM::intersect1<M,K>(ray,k,v2,v3,v1,vbool<M>(true ),epilog)) return true;

++         return false;

++       }

++     };

++

++

++ #if defined(__AVX__)

++

++     /*! Intersects 4 quads with 1 ray using AVX */

++     template<int K, bool filter>

++     struct QuadMIntersectorKMoellerTrumbore<4,K,filter> : public QuadMIntersectorKMoellerTrumboreBase<4,K,filter>

++     {

++       __forceinline QuadMIntersectorKMoellerTrumbore(const vbool<K>& valid, const RayK<K>& ray)

++         : QuadMIntersectorKMoellerTrumboreBase<4,K,filter>(valid,ray) {}

++

++       template<typename Epilog>

++       __forceinline bool intersect1(RayK<K>& ray, size_t k,

++                                     const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3, const Epilog& epilog) const

++       {

++         const Vec3vf8 vtx0(vfloat8(v0.x,v2.x),vfloat8(v0.y,v2.y),vfloat8(v0.z,v2.z));

++ #if !defined(EMBREE_BACKFACE_CULLING)

++         const Vec3vf8 vtx1(vfloat8(v1.x),vfloat8(v1.y),vfloat8(v1.z));

++         const Vec3vf8 vtx2(vfloat8(v3.x),vfloat8(v3.y),vfloat8(v3.z));

++ #else

++         const Vec3vf8 vtx1(vfloat8(v1.x,v3.x),vfloat8(v1.y,v3.y),vfloat8(v1.z,v3.z));

++         const Vec3vf8 vtx2(vfloat8(v3.x,v1.x),vfloat8(v3.y,v1.y),vfloat8(v3.z,v1.z));

++ #endif

++         const vbool8 flags(0,0,0,0,1,1,1,1);

++         return MoellerTrumboreIntersector1KTriangleM::intersect1<8,K>(ray,k,vtx0,vtx1,vtx2,flags,epilog);

++       }

++

++       __forceinline bool intersect1(RayHitK<K>& ray, size_t k, IntersectContext* context,

++                                     const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3,

++                                     const vuint4& geomID, const vuint4& primID) const

++       {

++         return intersect1(ray,k,v0,v1,v2,v3,Intersect1KEpilogM<8,K,filter>(ray,k,context,vuint8(geomID),vuint8(primID)));

++       }

++

++       __forceinline bool occluded1(RayK<K>& ray, size_t k, IntersectContext* context,

++                                    const Vec3vf4& v0, const Vec3vf4& v1, const Vec3vf4& v2, const Vec3vf4& v3,

++                                    const vuint4& geomID, const vuint4& primID) const

++       {

++         return intersect1(ray,k,v0,v1,v2,v3,Occluded1KEpilogM<8,K,filter>(ray,k,context,vuint8(geomID),vuint8(primID)));

++       }

++     };

++

++ #endif

++   }

++ }

Revision control