summaryrefslogtreecommitdiff
path: root/thirdparty/embree-aarch64/kernels/geometry/trianglei.h
diff options
context:
space:
mode:
Diffstat (limited to 'thirdparty/embree-aarch64/kernels/geometry/trianglei.h')
-rw-r--r--thirdparty/embree-aarch64/kernels/geometry/trianglei.h442
1 files changed, 0 insertions, 442 deletions
diff --git a/thirdparty/embree-aarch64/kernels/geometry/trianglei.h b/thirdparty/embree-aarch64/kernels/geometry/trianglei.h
deleted file mode 100644
index 4f3118cc0c..0000000000
--- a/thirdparty/embree-aarch64/kernels/geometry/trianglei.h
+++ /dev/null
@@ -1,442 +0,0 @@
-// Copyright 2009-2020 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-
-#pragma once
-
-#include "primitive.h"
-#include "../common/scene.h"
-
-namespace embree
-{
- /* Stores M triangles from an indexed face set */
- template <int M>
- struct TriangleMi
- {
- /* Virtual interface to query information about the triangle type */
- struct Type : public PrimitiveType
- {
- const char* name() const;
- size_t sizeActive(const char* This) const;
- size_t sizeTotal(const char* This) const;
- size_t getBytes(const char* This) const;
- };
- static Type type;
-
- public:
-
- /* primitive supports multiple time segments */
- static const bool singleTimeSegment = false;
-
- /* Returns maximum number of stored triangles */
- static __forceinline size_t max_size() { return M; }
-
- /* Returns required number of primitive blocks for N primitives */
- static __forceinline size_t blocks(size_t N) { return (N+max_size()-1)/max_size(); }
-
- public:
-
- /* Default constructor */
- __forceinline TriangleMi() { }
-
- /* Construction from vertices and IDs */
- __forceinline TriangleMi(const vuint<M>& v0,
- const vuint<M>& v1,
- const vuint<M>& v2,
- const vuint<M>& geomIDs,
- const vuint<M>& primIDs)
-#if defined(EMBREE_COMPACT_POLYS)
- : geomIDs(geomIDs), primIDs(primIDs) {}
-#else
- : v0_(v0), v1_(v1), v2_(v2), geomIDs(geomIDs), primIDs(primIDs) {}
-#endif
-
- /* Returns a mask that tells which triangles are valid */
- __forceinline vbool<M> valid() const { return primIDs != vuint<M>(-1); }
-
- /* Returns if the specified triangle is valid */
- __forceinline bool valid(const size_t i) const { assert(i<M); return primIDs[i] != -1; }
-
- /* Returns the number of stored triangles */
- __forceinline size_t size() const { return bsf(~movemask(valid())); }
-
- /* Returns the geometry IDs */
- __forceinline vuint<M> geomID() const { return geomIDs; }
- __forceinline unsigned int geomID(const size_t i) const { assert(i<M); return geomIDs[i]; }
-
- /* Returns the primitive IDs */
- __forceinline vuint<M> primID() const { return primIDs; }
- __forceinline unsigned int primID(const size_t i) const { assert(i<M); return primIDs[i]; }
-
- /* Calculate the bounds of the triangles */
- __forceinline const BBox3fa bounds(const Scene *const scene, const size_t itime=0) const
- {
- BBox3fa bounds = empty;
- for (size_t i=0; i<M && valid(i); i++) {
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(i));
- bounds.extend(mesh->bounds(primID(i),itime));
- }
- return bounds;
- }
-
- /* Calculate the linear bounds of the primitive */
- __forceinline LBBox3fa linearBounds(const Scene *const scene, size_t itime) {
- return LBBox3fa(bounds(scene,itime+0),bounds(scene,itime+1));
- }
-
- __forceinline LBBox3fa linearBounds(const Scene *const scene, size_t itime, size_t numTimeSteps)
- {
- LBBox3fa allBounds = empty;
- for (size_t i=0; i<M && valid(i); i++)
- {
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(i));
- allBounds.extend(mesh->linearBounds(primID(i), itime, numTimeSteps));
- }
- return allBounds;
- }
-
- __forceinline LBBox3fa linearBounds(const Scene *const scene, const BBox1f time_range)
- {
- LBBox3fa allBounds = empty;
- for (size_t i=0; i<M && valid(i); i++)
- {
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(i));
- allBounds.extend(mesh->linearBounds(primID(i), time_range));
- }
- return allBounds;
- }
-
- /* Non-temporal store */
- __forceinline static void store_nt(TriangleMi* dst, const TriangleMi& src)
- {
-#if !defined(EMBREE_COMPACT_POLYS)
- vuint<M>::store_nt(&dst->v0_,src.v0_);
- vuint<M>::store_nt(&dst->v1_,src.v1_);
- vuint<M>::store_nt(&dst->v2_,src.v2_);
-#endif
- vuint<M>::store_nt(&dst->geomIDs,src.geomIDs);
- vuint<M>::store_nt(&dst->primIDs,src.primIDs);
- }
-
- /* Fill triangle from triangle list */
- template<typename PrimRefT>
- __forceinline void fill(const PrimRefT* prims, size_t& begin, size_t end, Scene* scene)
- {
- vuint<M> v0 = zero, v1 = zero, v2 = zero;
- vuint<M> geomID = -1, primID = -1;
- const PrimRefT* prim = &prims[begin];
-
- for (size_t i=0; i<M; i++)
- {
- if (begin<end) {
- geomID[i] = prim->geomID();
- primID[i] = prim->primID();
-#if !defined(EMBREE_COMPACT_POLYS)
- const TriangleMesh* mesh = scene->get<TriangleMesh>(prim->geomID());
- const TriangleMesh::Triangle& tri = mesh->triangle(prim->primID());
- unsigned int int_stride = mesh->vertices0.getStride()/4;
- v0[i] = tri.v[0] * int_stride;
- v1[i] = tri.v[1] * int_stride;
- v2[i] = tri.v[2] * int_stride;
-#endif
- begin++;
- } else {
- assert(i);
- if (likely(i > 0)) {
- geomID[i] = geomID[0];
- primID[i] = -1;
- v0[i] = v0[0];
- v1[i] = v0[0];
- v2[i] = v0[0];
- }
- }
- if (begin<end) prim = &prims[begin];
- }
- new (this) TriangleMi(v0,v1,v2,geomID,primID); // FIXME: use non temporal store
- }
-
- __forceinline LBBox3fa fillMB(const PrimRef* prims, size_t& begin, size_t end, Scene* scene, size_t itime)
- {
- fill(prims, begin, end, scene);
- return linearBounds(scene, itime);
- }
-
- __forceinline LBBox3fa fillMB(const PrimRefMB* prims, size_t& begin, size_t end, Scene* scene, const BBox1f time_range)
- {
- fill(prims, begin, end, scene);
- return linearBounds(scene, time_range);
- }
-
- /* Updates the primitive */
- __forceinline BBox3fa update(TriangleMesh* mesh)
- {
- BBox3fa bounds = empty;
- for (size_t i=0; i<M; i++)
- {
- if (primID(i) == -1) break;
- const unsigned int primId = primID(i);
- const TriangleMesh::Triangle& tri = mesh->triangle(primId);
- const Vec3fa p0 = mesh->vertex(tri.v[0]);
- const Vec3fa p1 = mesh->vertex(tri.v[1]);
- const Vec3fa p2 = mesh->vertex(tri.v[2]);
- bounds.extend(merge(BBox3fa(p0),BBox3fa(p1),BBox3fa(p2)));
- }
- return bounds;
- }
-
- protected:
-#if !defined(EMBREE_COMPACT_POLYS)
- vuint<M> v0_; // 4 byte offset of 1st vertex
- vuint<M> v1_; // 4 byte offset of 2nd vertex
- vuint<M> v2_; // 4 byte offset of 3rd vertex
-#endif
- vuint<M> geomIDs; // geometry ID of mesh
- vuint<M> primIDs; // primitive ID of primitive inside mesh
- };
-
- namespace isa
- {
-
- template<int M>
- struct TriangleMi : public embree::TriangleMi<M>
- {
-#if !defined(EMBREE_COMPACT_POLYS)
- using embree::TriangleMi<M>::v0_;
- using embree::TriangleMi<M>::v1_;
- using embree::TriangleMi<M>::v2_;
-#endif
- using embree::TriangleMi<M>::geomIDs;
- using embree::TriangleMi<M>::primIDs;
- using embree::TriangleMi<M>::geomID;
- using embree::TriangleMi<M>::primID;
- using embree::TriangleMi<M>::valid;
-
- /* loads a single vertex */
- template<int vid>
- __forceinline Vec3f getVertex(const size_t index, const Scene *const scene) const
- {
-#if defined(EMBREE_COMPACT_POLYS)
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(index));
- const TriangleMesh::Triangle& tri = mesh->triangle(primID(index));
- return (Vec3f) mesh->vertices[0][tri.v[vid]];
-#else
- const vuint<M>& v = getVertexOffset<vid>();
- const float* vertices = scene->vertices[geomID(index)];
- return (Vec3f&) vertices[v[index]];
-#endif
- }
-
- template<int vid, typename T>
- __forceinline Vec3<T> getVertex(const size_t index, const Scene *const scene, const size_t itime, const T& ftime) const
- {
-#if defined(EMBREE_COMPACT_POLYS)
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(index));
- const TriangleMesh::Triangle& tri = mesh->triangle(primID(index));
- const Vec3fa v0 = mesh->vertices[itime+0][tri.v[vid]];
- const Vec3fa v1 = mesh->vertices[itime+1][tri.v[vid]];
-#else
- const vuint<M>& v = getVertexOffset<vid>();
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(index));
- const float* vertices0 = (const float*) mesh->vertexPtr(0,itime+0);
- const float* vertices1 = (const float*) mesh->vertexPtr(0,itime+1);
- const Vec3fa v0 = Vec3fa::loadu(vertices0+v[index]);
- const Vec3fa v1 = Vec3fa::loadu(vertices1+v[index]);
-#endif
- const Vec3<T> p0(v0.x,v0.y,v0.z);
- const Vec3<T> p1(v1.x,v1.y,v1.z);
- return lerp(p0,p1,ftime);
- }
-
- template<int vid, int K, typename T>
- __forceinline Vec3<T> getVertex(const vbool<K>& valid, const size_t index, const Scene *const scene, const vint<K>& itime, const T& ftime) const
- {
- Vec3<T> p0, p1;
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(index));
-
- for (size_t mask=movemask(valid), i=bsf(mask); mask; mask=btc(mask,i), i=bsf(mask))
- {
-#if defined(EMBREE_COMPACT_POLYS)
- const TriangleMesh::Triangle& tri = mesh->triangle(primID(index));
- const Vec3fa v0 = mesh->vertices[itime[i]+0][tri.v[vid]];
- const Vec3fa v1 = mesh->vertices[itime[i]+1][tri.v[vid]];
-#else
- const vuint<M>& v = getVertexOffset<vid>();
- const float* vertices0 = (const float*) mesh->vertexPtr(0,itime[i]+0);
- const float* vertices1 = (const float*) mesh->vertexPtr(0,itime[i]+1);
- const Vec3fa v0 = Vec3fa::loadu(vertices0+v[index]);
- const Vec3fa v1 = Vec3fa::loadu(vertices1+v[index]);
-#endif
- p0.x[i] = v0.x; p0.y[i] = v0.y; p0.z[i] = v0.z;
- p1.x[i] = v1.x; p1.y[i] = v1.y; p1.z[i] = v1.z;
- }
- return (T(one)-ftime)*p0 + ftime*p1;
- }
-
- struct Triangle {
- vfloat4 v0,v1,v2;
- };
-
-#if defined(EMBREE_COMPACT_POLYS)
-
- __forceinline Triangle loadTriangle(const int i, const Scene* const scene) const
- {
- const unsigned int geomID = geomIDs[i];
- const unsigned int primID = primIDs[i];
- if (unlikely(primID == -1)) return { zero, zero, zero };
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID);
- const TriangleMesh::Triangle& tri = mesh->triangle(primID);
- const vfloat4 v0 = (vfloat4) mesh->vertices0[tri.v[0]];
- const vfloat4 v1 = (vfloat4) mesh->vertices0[tri.v[1]];
- const vfloat4 v2 = (vfloat4) mesh->vertices0[tri.v[2]];
- return { v0, v1, v2 };
- }
-
- __forceinline Triangle loadTriangle(const int i, const int itime, const TriangleMesh* const mesh) const
- {
- const unsigned int primID = primIDs[i];
- if (unlikely(primID == -1)) return { zero, zero, zero };
- const TriangleMesh::Triangle& tri = mesh->triangle(primID);
- const vfloat4 v0 = (vfloat4) mesh->vertices[itime][tri.v[0]];
- const vfloat4 v1 = (vfloat4) mesh->vertices[itime][tri.v[1]];
- const vfloat4 v2 = (vfloat4) mesh->vertices[itime][tri.v[2]];
- return { v0, v1, v2 };
- }
-
-#else
-
- __forceinline Triangle loadTriangle(const int i, const Scene* const scene) const
- {
- const float* vertices = scene->vertices[geomID(i)];
- const vfloat4 v0 = vfloat4::loadu(vertices + v0_[i]);
- const vfloat4 v1 = vfloat4::loadu(vertices + v1_[i]);
- const vfloat4 v2 = vfloat4::loadu(vertices + v2_[i]);
- return { v0, v1, v2 };
- }
-
- __forceinline Triangle loadTriangle(const int i, const int itime, const TriangleMesh* const mesh) const
- {
- const float* vertices = (const float*) mesh->vertexPtr(0,itime);
- const vfloat4 v0 = vfloat4::loadu(vertices + v0_[i]);
- const vfloat4 v1 = vfloat4::loadu(vertices + v1_[i]);
- const vfloat4 v2 = vfloat4::loadu(vertices + v2_[i]);
- return { v0, v1, v2 };
- }
-
-#endif
-
- /* Gather the triangles */
- __forceinline void gather(Vec3vf<M>& p0, Vec3vf<M>& p1, Vec3vf<M>& p2, const Scene* const scene) const;
-
- template<int K>
-#if defined(__INTEL_COMPILER) && (__INTEL_COMPILER < 2000) // workaround for compiler bug in ICC 2019
- __noinline
-#else
- __forceinline
-#endif
- void gather(const vbool<K>& valid,
- Vec3vf<K>& p0,
- Vec3vf<K>& p1,
- Vec3vf<K>& p2,
- const size_t index,
- const Scene* const scene,
- const vfloat<K>& time) const
- {
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(index));
-
- vfloat<K> ftime;
- const vint<K> itime = mesh->timeSegment(time, ftime);
-
- const size_t first = bsf(movemask(valid));
- if (likely(all(valid,itime[first] == itime)))
- {
- p0 = getVertex<0>(index, scene, itime[first], ftime);
- p1 = getVertex<1>(index, scene, itime[first], ftime);
- p2 = getVertex<2>(index, scene, itime[first], ftime);
- } else {
- p0 = getVertex<0>(valid, index, scene, itime, ftime);
- p1 = getVertex<1>(valid, index, scene, itime, ftime);
- p2 = getVertex<2>(valid, index, scene, itime, ftime);
- }
- }
-
- __forceinline void gather(Vec3vf<M>& p0,
- Vec3vf<M>& p1,
- Vec3vf<M>& p2,
- const TriangleMesh* mesh,
- const Scene *const scene,
- const int itime) const;
-
- __forceinline void gather(Vec3vf<M>& p0,
- Vec3vf<M>& p1,
- Vec3vf<M>& p2,
- const Scene *const scene,
- const float time) const;
-
-
-#if !defined(EMBREE_COMPACT_POLYS)
- template<int N> const vuint<M>& getVertexOffset() const;
-#endif
- };
-
-#if !defined(EMBREE_COMPACT_POLYS)
- template<> template<> __forceinline const vuint<4>& TriangleMi<4>::getVertexOffset<0>() const { return v0_; }
- template<> template<> __forceinline const vuint<4>& TriangleMi<4>::getVertexOffset<1>() const { return v1_; }
- template<> template<> __forceinline const vuint<4>& TriangleMi<4>::getVertexOffset<2>() const { return v2_; }
-#endif
-
- template<>
- __forceinline void TriangleMi<4>::gather(Vec3vf4& p0,
- Vec3vf4& p1,
- Vec3vf4& p2,
- const Scene* const scene) const
- {
- const Triangle tri0 = loadTriangle(0,scene);
- const Triangle tri1 = loadTriangle(1,scene);
- const Triangle tri2 = loadTriangle(2,scene);
- const Triangle tri3 = loadTriangle(3,scene);
- transpose(tri0.v0,tri1.v0,tri2.v0,tri3.v0,p0.x,p0.y,p0.z);
- transpose(tri0.v1,tri1.v1,tri2.v1,tri3.v1,p1.x,p1.y,p1.z);
- transpose(tri0.v2,tri1.v2,tri2.v2,tri3.v2,p2.x,p2.y,p2.z);
- }
-
- template<>
- __forceinline void TriangleMi<4>::gather(Vec3vf4& p0,
- Vec3vf4& p1,
- Vec3vf4& p2,
- const TriangleMesh* mesh,
- const Scene *const scene,
- const int itime) const
- {
- const Triangle tri0 = loadTriangle(0,itime,mesh);
- const Triangle tri1 = loadTriangle(1,itime,mesh);
- const Triangle tri2 = loadTriangle(2,itime,mesh);
- const Triangle tri3 = loadTriangle(3,itime,mesh);
- transpose(tri0.v0,tri1.v0,tri2.v0,tri3.v0,p0.x,p0.y,p0.z);
- transpose(tri0.v1,tri1.v1,tri2.v1,tri3.v1,p1.x,p1.y,p1.z);
- transpose(tri0.v2,tri1.v2,tri2.v2,tri3.v2,p2.x,p2.y,p2.z);
- }
-
- template<>
- __forceinline void TriangleMi<4>::gather(Vec3vf4& p0,
- Vec3vf4& p1,
- Vec3vf4& p2,
- const Scene *const scene,
- const float time) const
- {
- const TriangleMesh* mesh = scene->get<TriangleMesh>(geomID(0)); // in mblur mode all geometries are identical
-
- float ftime;
- const int itime = mesh->timeSegment(time, ftime);
-
- Vec3vf4 a0,a1,a2; gather(a0,a1,a2,mesh,scene,itime);
- Vec3vf4 b0,b1,b2; gather(b0,b1,b2,mesh,scene,itime+1);
- p0 = lerp(a0,b0,vfloat4(ftime));
- p1 = lerp(a1,b1,vfloat4(ftime));
- p2 = lerp(a2,b2,vfloat4(ftime));
- }
- }
-
- template<int M>
- typename TriangleMi<M>::Type TriangleMi<M>::type;
-
- typedef TriangleMi<4> Triangle4i;
-}
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-04 15:24:21 +0000