a69cc9f13d
Since Embree v3.13.0 supports AARCH64, switch back to the
official repo instead of using Embree-aarch64.
`thirdparty/embree/patches/godot-changes.patch` should now contain
an accurate diff of the changes done to the library.
(cherry picked from commit 767e374dce)
556 lines
23 KiB
C++
556 lines
23 KiB
C++
// 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)();
|
|
}
|