// Copyright 2009-2021 Intel Corporation // SPDX-License-Identifier: Apache-2.0 #pragma once #include "default.h" #include "ray.h" #include "point_query.h" #include "context.h" namespace embree { class Scene; /*! Base class for the acceleration structure data. */ class AccelData : public RefCount { ALIGNED_CLASS_(16); public: enum Type { TY_UNKNOWN = 0, TY_ACCELN = 1, TY_ACCEL_INSTANCE = 2, TY_BVH4 = 3, TY_BVH8 = 4 }; public: AccelData (const Type type) : bounds(empty), type(type) {} /*! notifies the acceleration structure about the deletion of some geometry */ virtual void deleteGeometry(size_t geomID) {}; /*! clears the acceleration structure data */ virtual void clear() = 0; /*! returns normal bounds */ __forceinline BBox3fa getBounds() const { return bounds.bounds(); } /*! returns bounds for some time */ __forceinline BBox3fa getBounds(float t) const { return bounds.interpolate(t); } /*! returns linear bounds */ __forceinline LBBox3fa getLinearBounds() const { return bounds; } /*! checks if acceleration structure is empty */ __forceinline bool isEmpty() const { return bounds.bounds0.lower.x == float(pos_inf); } public: LBBox3fa bounds; // linear bounds Type type; }; /*! Base class for all intersectable and buildable acceleration structures. */ class Accel : public AccelData { ALIGNED_CLASS_(16); public: struct Intersectors; /*! Type of collide function */ typedef void (*CollideFunc)(void* bvh0, void* bvh1, RTCCollideFunc callback, void* userPtr); /*! Type of point query function */ typedef bool(*PointQueryFunc)(Intersectors* This, /*!< this pointer to accel */ PointQuery* query, /*!< point query for lookup */ PointQueryContext* context); /*!< point query context */ /*! Type of intersect function pointer for single rays. */ typedef void (*IntersectFunc)(Intersectors* This, /*!< this pointer to accel */ RTCRayHit& ray, /*!< ray to intersect */ IntersectContext* context); /*! Type of intersect function pointer for ray packets of size 4. */ typedef void (*IntersectFunc4)(const void* valid, /*!< pointer to valid mask */ Intersectors* This, /*!< this pointer to accel */ RTCRayHit4& ray, /*!< ray packet to intersect */ IntersectContext* context); /*! Type of intersect function pointer for ray packets of size 8. */ typedef void (*IntersectFunc8)(const void* valid, /*!< pointer to valid mask */ Intersectors* This, /*!< this pointer to accel */ RTCRayHit8& ray, /*!< ray packet to intersect */ IntersectContext* context); /*! Type of intersect function pointer for ray packets of size 16. */ typedef void (*IntersectFunc16)(const void* valid, /*!< pointer to valid mask */ Intersectors* This, /*!< this pointer to accel */ RTCRayHit16& ray, /*!< ray packet to intersect */ IntersectContext* context); /*! Type of intersect function pointer for ray packets of size N. */ typedef void (*IntersectFuncN)(Intersectors* This, /*!< this pointer to accel */ RTCRayHitN** ray, /*!< ray stream to intersect */ const size_t N, /*!< number of rays in stream */ IntersectContext* context /*!< layout flags */); /*! Type of occlusion function pointer for single rays. */ typedef void (*OccludedFunc) (Intersectors* This, /*!< this pointer to accel */ RTCRay& ray, /*!< ray to test occlusion */ IntersectContext* context); /*! Type of occlusion function pointer for ray packets of size 4. */ typedef void (*OccludedFunc4) (const void* valid, /*!< pointer to valid mask */ Intersectors* This, /*!< this pointer to accel */ RTCRay4& ray, /*!< ray packet to test occlusion. */ IntersectContext* context); /*! Type of occlusion function pointer for ray packets of size 8. */ typedef void (*OccludedFunc8) (const void* valid, /*!< pointer to valid mask */ Intersectors* This, /*!< this pointer to accel */ RTCRay8& ray, /*!< ray packet to test occlusion. */ IntersectContext* context); /*! Type of occlusion function pointer for ray packets of size 16. */ typedef void (*OccludedFunc16) (const void* valid, /*!< pointer to valid mask */ Intersectors* This, /*!< this pointer to accel */ RTCRay16& ray, /*!< ray packet to test occlusion. */ IntersectContext* context); /*! Type of intersect function pointer for ray packets of size N. */ typedef void (*OccludedFuncN)(Intersectors* This, /*!< this pointer to accel */ RTCRayN** ray, /*!< ray stream to test occlusion */ const size_t N, /*!< number of rays in stream */ IntersectContext* context /*!< layout flags */); typedef void (*ErrorFunc) (); struct Collider { Collider (ErrorFunc error = nullptr) : collide((CollideFunc)error), name(nullptr) {} Collider (CollideFunc collide, const char* name) : collide(collide), name(name) {} operator bool() const { return name; } public: CollideFunc collide; const char* name; }; struct Intersector1 { Intersector1 (ErrorFunc error = nullptr) : intersect((IntersectFunc)error), occluded((OccludedFunc)error), name(nullptr) {} Intersector1 (IntersectFunc intersect, OccludedFunc occluded, const char* name) : intersect(intersect), occluded(occluded), pointQuery(nullptr), name(name) {} Intersector1 (IntersectFunc intersect, OccludedFunc occluded, PointQueryFunc pointQuery, const char* name) : intersect(intersect), occluded(occluded), pointQuery(pointQuery), name(name) {} operator bool() const { return name; } public: static const char* type; IntersectFunc intersect; OccludedFunc occluded; PointQueryFunc pointQuery; const char* name; }; struct Intersector4 { Intersector4 (ErrorFunc error = nullptr) : intersect((IntersectFunc4)error), occluded((OccludedFunc4)error), name(nullptr) {} Intersector4 (IntersectFunc4 intersect, OccludedFunc4 occluded, const char* name) : intersect(intersect), occluded(occluded), name(name) {} operator bool() const { return name; } public: static const char* type; IntersectFunc4 intersect; OccludedFunc4 occluded; const char* name; }; struct Intersector8 { Intersector8 (ErrorFunc error = nullptr) : intersect((IntersectFunc8)error), occluded((OccludedFunc8)error), name(nullptr) {} Intersector8 (IntersectFunc8 intersect, OccludedFunc8 occluded, const char* name) : intersect(intersect), occluded(occluded), name(name) {} operator bool() const { return name; } public: static const char* type; IntersectFunc8 intersect; OccludedFunc8 occluded; const char* name; }; struct Intersector16 { Intersector16 (ErrorFunc error = nullptr) : intersect((IntersectFunc16)error), occluded((OccludedFunc16)error), name(nullptr) {} Intersector16 (IntersectFunc16 intersect, OccludedFunc16 occluded, const char* name) : intersect(intersect), occluded(occluded), name(name) {} operator bool() const { return name; } public: static const char* type; IntersectFunc16 intersect; OccludedFunc16 occluded; const char* name; }; struct IntersectorN { IntersectorN (ErrorFunc error = nullptr) : intersect((IntersectFuncN)error), occluded((OccludedFuncN)error), name(nullptr) {} IntersectorN (IntersectFuncN intersect, OccludedFuncN occluded, const char* name) : intersect(intersect), occluded(occluded), name(name) {} operator bool() const { return name; } public: static const char* type; IntersectFuncN intersect; OccludedFuncN occluded; const char* name; }; struct Intersectors { Intersectors() : ptr(nullptr), leafIntersector(nullptr), collider(nullptr), intersector1(nullptr), intersector4(nullptr), intersector8(nullptr), intersector16(nullptr), intersectorN(nullptr) {} Intersectors (ErrorFunc error) : ptr(nullptr), leafIntersector(nullptr), collider(error), intersector1(error), intersector4(error), intersector8(error), intersector16(error), intersectorN(error) {} void print(size_t ident) { if (collider.name) { for (size_t i=0; i<ident; i++) std::cout << " "; std::cout << "collider = " << collider.name << std::endl; } if (intersector1.name) { for (size_t i=0; i<ident; i++) std::cout << " "; std::cout << "intersector1 = " << intersector1.name << std::endl; } if (intersector4.name) { for (size_t i=0; i<ident; i++) std::cout << " "; std::cout << "intersector4 = " << intersector4.name << std::endl; } if (intersector8.name) { for (size_t i=0; i<ident; i++) std::cout << " "; std::cout << "intersector8 = " << intersector8.name << std::endl; } if (intersector16.name) { for (size_t i=0; i<ident; i++) std::cout << " "; std::cout << "intersector16 = " << intersector16.name << std::endl; } if (intersectorN.name) { for (size_t i=0; i<ident; i++) std::cout << " "; std::cout << "intersectorN = " << intersectorN.name << std::endl; } } void select(bool filter) { if (intersector4_filter) { if (filter) intersector4 = intersector4_filter; else intersector4 = intersector4_nofilter; } if (intersector8_filter) { if (filter) intersector8 = intersector8_filter; else intersector8 = intersector8_nofilter; } if (intersector16_filter) { if (filter) intersector16 = intersector16_filter; else intersector16 = intersector16_nofilter; } if (intersectorN_filter) { if (filter) intersectorN = intersectorN_filter; else intersectorN = intersectorN_nofilter; } } __forceinline bool pointQuery (PointQuery* query, PointQueryContext* context) { assert(intersector1.pointQuery); return intersector1.pointQuery(this,query,context); } /*! collides two scenes */ __forceinline void collide (Accel* scene0, Accel* scene1, RTCCollideFunc callback, void* userPtr) { assert(collider.collide); collider.collide(scene0->intersectors.ptr,scene1->intersectors.ptr,callback,userPtr); } /*! Intersects a single ray with the scene. */ __forceinline void intersect (RTCRayHit& ray, IntersectContext* context) { assert(intersector1.intersect); intersector1.intersect(this,ray,context); } /*! Intersects a packet of 4 rays with the scene. */ __forceinline void intersect4 (const void* valid, RTCRayHit4& ray, IntersectContext* context) { assert(intersector4.intersect); intersector4.intersect(valid,this,ray,context); } /*! Intersects a packet of 8 rays with the scene. */ __forceinline void intersect8 (const void* valid, RTCRayHit8& ray, IntersectContext* context) { assert(intersector8.intersect); intersector8.intersect(valid,this,ray,context); } /*! Intersects a packet of 16 rays with the scene. */ __forceinline void intersect16 (const void* valid, RTCRayHit16& ray, IntersectContext* context) { assert(intersector16.intersect); intersector16.intersect(valid,this,ray,context); } /*! Intersects a stream of N rays in SOA layout with the scene. */ __forceinline void intersectN (RTCRayHitN** rayN, const size_t N, IntersectContext* context) { assert(intersectorN.intersect); intersectorN.intersect(this,rayN,N,context); } #if defined(__SSE__) __forceinline void intersect(const vbool4& valid, RayHitK<4>& ray, IntersectContext* context) { const vint<4> mask = valid.mask32(); intersect4(&mask,(RTCRayHit4&)ray,context); } #endif #if defined(__AVX__) __forceinline void intersect(const vbool8& valid, RayHitK<8>& ray, IntersectContext* context) { const vint<8> mask = valid.mask32(); intersect8(&mask,(RTCRayHit8&)ray,context); } #endif #if defined(__AVX512F__) __forceinline void intersect(const vbool16& valid, RayHitK<16>& ray, IntersectContext* context) { const vint<16> mask = valid.mask32(); intersect16(&mask,(RTCRayHit16&)ray,context); } #endif template<int K> __forceinline void intersectN (RayHitK<K>** rayN, const size_t N, IntersectContext* context) { intersectN((RTCRayHitN**)rayN,N,context); } /*! Tests if single ray is occluded by the scene. */ __forceinline void occluded (RTCRay& ray, IntersectContext* context) { assert(intersector1.occluded); intersector1.occluded(this,ray,context); } /*! Tests if a packet of 4 rays is occluded by the scene. */ __forceinline void occluded4 (const void* valid, RTCRay4& ray, IntersectContext* context) { assert(intersector4.occluded); intersector4.occluded(valid,this,ray,context); } /*! Tests if a packet of 8 rays is occluded by the scene. */ __forceinline void occluded8 (const void* valid, RTCRay8& ray, IntersectContext* context) { assert(intersector8.occluded); intersector8.occluded(valid,this,ray,context); } /*! Tests if a packet of 16 rays is occluded by the scene. */ __forceinline void occluded16 (const void* valid, RTCRay16& ray, IntersectContext* context) { assert(intersector16.occluded); intersector16.occluded(valid,this,ray,context); } /*! Tests if a stream of N rays in SOA layout is occluded by the scene. */ __forceinline void occludedN (RTCRayN** rayN, const size_t N, IntersectContext* context) { assert(intersectorN.occluded); intersectorN.occluded(this,rayN,N,context); } #if defined(__SSE__) __forceinline void occluded(const vbool4& valid, RayK<4>& ray, IntersectContext* context) { const vint<4> mask = valid.mask32(); occluded4(&mask,(RTCRay4&)ray,context); } #endif #if defined(__AVX__) __forceinline void occluded(const vbool8& valid, RayK<8>& ray, IntersectContext* context) { const vint<8> mask = valid.mask32(); occluded8(&mask,(RTCRay8&)ray,context); } #endif #if defined(__AVX512F__) __forceinline void occluded(const vbool16& valid, RayK<16>& ray, IntersectContext* context) { const vint<16> mask = valid.mask32(); occluded16(&mask,(RTCRay16&)ray,context); } #endif template<int K> __forceinline void occludedN (RayK<K>** rayN, const size_t N, IntersectContext* context) { occludedN((RTCRayN**)rayN,N,context); } /*! Tests if single ray is occluded by the scene. */ __forceinline void intersect(RTCRay& ray, IntersectContext* context) { occluded(ray, context); } /*! Tests if a packet of K rays is occluded by the scene. */ template<int K> __forceinline void intersect(const vbool<K>& valid, RayK<K>& ray, IntersectContext* context) { occluded(valid, ray, context); } /*! Tests if a packet of N rays in SOA layout is occluded by the scene. */ template<int K> __forceinline void intersectN(RayK<K>** rayN, const size_t N, IntersectContext* context) { occludedN(rayN, N, context); } public: AccelData* ptr; void* leafIntersector; Collider collider; Intersector1 intersector1; Intersector4 intersector4; Intersector4 intersector4_filter; Intersector4 intersector4_nofilter; Intersector8 intersector8; Intersector8 intersector8_filter; Intersector8 intersector8_nofilter; Intersector16 intersector16; Intersector16 intersector16_filter; Intersector16 intersector16_nofilter; IntersectorN intersectorN; IntersectorN intersectorN_filter; IntersectorN intersectorN_nofilter; }; public: /*! Construction */ Accel (const AccelData::Type type) : AccelData(type) {} /*! Construction */ Accel (const AccelData::Type type, const Intersectors& intersectors) : AccelData(type), intersectors(intersectors) {} /*! Virtual destructor */ virtual ~Accel() {} /*! makes the acceleration structure immutable */ virtual void immutable () {} /*! build acceleration structure */ virtual void build () = 0; public: Intersectors intersectors; }; #define DEFINE_COLLIDER(symbol,collider) \ Accel::Collider symbol() { \ return Accel::Collider((Accel::CollideFunc)collider::collide, \ TOSTRING(isa) "::" TOSTRING(symbol)); \ } #define DEFINE_INTERSECTOR1(symbol,intersector) \ Accel::Intersector1 symbol() { \ return Accel::Intersector1((Accel::IntersectFunc )intersector::intersect, \ (Accel::OccludedFunc )intersector::occluded, \ (Accel::PointQueryFunc)intersector::pointQuery,\ TOSTRING(isa) "::" TOSTRING(symbol)); \ } #define DEFINE_INTERSECTOR4(symbol,intersector) \ Accel::Intersector4 symbol() { \ return Accel::Intersector4((Accel::IntersectFunc4)intersector::intersect, \ (Accel::OccludedFunc4)intersector::occluded, \ TOSTRING(isa) "::" TOSTRING(symbol)); \ } #define DEFINE_INTERSECTOR8(symbol,intersector) \ Accel::Intersector8 symbol() { \ return Accel::Intersector8((Accel::IntersectFunc8)intersector::intersect, \ (Accel::OccludedFunc8)intersector::occluded, \ TOSTRING(isa) "::" TOSTRING(symbol)); \ } #define DEFINE_INTERSECTOR16(symbol,intersector) \ Accel::Intersector16 symbol() { \ return Accel::Intersector16((Accel::IntersectFunc16)intersector::intersect, \ (Accel::OccludedFunc16)intersector::occluded, \ TOSTRING(isa) "::" TOSTRING(symbol)); \ } #define DEFINE_INTERSECTORN(symbol,intersector) \ Accel::IntersectorN symbol() { \ return Accel::IntersectorN((Accel::IntersectFuncN)intersector::intersect, \ (Accel::OccludedFuncN)intersector::occluded, \ TOSTRING(isa) "::" TOSTRING(symbol)); \ } /* ray stream filter interface */ typedef void (*intersectStreamAOS_func)(Scene* scene, RTCRayHit* _rayN, const size_t N, const size_t stride, IntersectContext* context); typedef void (*intersectStreamAOP_func)(Scene* scene, RTCRayHit** _rayN, const size_t N, IntersectContext* context); typedef void (*intersectStreamSOA_func)(Scene* scene, char* rayN, const size_t N, const size_t streams, const size_t stream_offset, IntersectContext* context); typedef void (*intersectStreamSOP_func)(Scene* scene, const RTCRayHitNp* rayN, const size_t N, IntersectContext* context); typedef void (*occludedStreamAOS_func)(Scene* scene, RTCRay* _rayN, const size_t N, const size_t stride, IntersectContext* context); typedef void (*occludedStreamAOP_func)(Scene* scene, RTCRay** _rayN, const size_t N, IntersectContext* context); typedef void (*occludedStreamSOA_func)(Scene* scene, char* rayN, const size_t N, const size_t streams, const size_t stream_offset, IntersectContext* context); typedef void (*occludedStreamSOP_func)(Scene* scene, const RTCRayNp* rayN, const size_t N, IntersectContext* context); struct RayStreamFilterFuncs { RayStreamFilterFuncs() : intersectAOS(nullptr), intersectAOP(nullptr), intersectSOA(nullptr), intersectSOP(nullptr), occludedAOS(nullptr), occludedAOP(nullptr), occludedSOA(nullptr), occludedSOP(nullptr) {} RayStreamFilterFuncs(void (*ptr) ()) : intersectAOS((intersectStreamAOS_func) ptr), intersectAOP((intersectStreamAOP_func) ptr), intersectSOA((intersectStreamSOA_func) ptr), intersectSOP((intersectStreamSOP_func) ptr), occludedAOS((occludedStreamAOS_func) ptr), occludedAOP((occludedStreamAOP_func) ptr), occludedSOA((occludedStreamSOA_func) ptr), occludedSOP((occludedStreamSOP_func) ptr) {} RayStreamFilterFuncs(intersectStreamAOS_func intersectAOS, intersectStreamAOP_func intersectAOP, intersectStreamSOA_func intersectSOA, intersectStreamSOP_func intersectSOP, occludedStreamAOS_func occludedAOS, occludedStreamAOP_func occludedAOP, occludedStreamSOA_func occludedSOA, occludedStreamSOP_func occludedSOP) : intersectAOS(intersectAOS), intersectAOP(intersectAOP), intersectSOA(intersectSOA), intersectSOP(intersectSOP), occludedAOS(occludedAOS), occludedAOP(occludedAOP), occludedSOA(occludedSOA), occludedSOP(occludedSOP) {} public: intersectStreamAOS_func intersectAOS; intersectStreamAOP_func intersectAOP; intersectStreamSOA_func intersectSOA; intersectStreamSOP_func intersectSOP; occludedStreamAOS_func occludedAOS; occludedStreamAOP_func occludedAOP; occludedStreamSOA_func occludedSOA; occludedStreamSOP_func occludedSOP; }; typedef RayStreamFilterFuncs (*RayStreamFilterFuncsType)(); }