// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
#include "device.h"
#include "buffer.h"
#include "../common/point_query.h"
#include "../builders/priminfo.h"
#include "../builders/priminfo_mb.h"
namespace embree
{
class Scene;
class Geometry;
struct GeometryCounts
{
__forceinline GeometryCounts()
: numFilterFunctions(0),
numTriangles(0), numMBTriangles(0),
numQuads(0), numMBQuads(0),
numBezierCurves(0), numMBBezierCurves(0),
numLineSegments(0), numMBLineSegments(0),
numSubdivPatches(0), numMBSubdivPatches(0),
numUserGeometries(0), numMBUserGeometries(0),
numInstancesCheap(0), numMBInstancesCheap(0),
numInstancesExpensive(0), numMBInstancesExpensive(0),
numInstanceArrays(0), numMBInstanceArrays(0),
numGrids(0), numMBGrids(0),
numSubGrids(0), numMBSubGrids(0),
numPoints(0), numMBPoints(0) {}
__forceinline size_t size() const {
return numTriangles + numQuads + numBezierCurves + numLineSegments + numSubdivPatches + numUserGeometries + numInstancesCheap + numInstancesExpensive + numInstanceArrays + numGrids + numPoints
+ numMBTriangles + numMBQuads + numMBBezierCurves + numMBLineSegments + numMBSubdivPatches + numMBUserGeometries + numMBInstancesCheap + numMBInstancesExpensive + numMBInstanceArrays + numMBGrids + numMBPoints;
}
__forceinline unsigned int enabledGeometryTypesMask() const
{
unsigned int mask = 0;
if (numTriangles) mask |= 1 << 0;
if (numQuads) mask |= 1 << 1;
if (numBezierCurves+numLineSegments) mask |= 1 << 2;
if (numSubdivPatches) mask |= 1 << 3;
if (numUserGeometries) mask |= 1 << 4;
if (numInstancesCheap) mask |= 1 << 5;
if (numInstancesExpensive) mask |= 1 << 6;
if (numInstanceArrays) mask |= 1 << 7;
if (numGrids) mask |= 1 << 8;
if (numPoints) mask |= 1 << 9;
unsigned int maskMB = 0;
if (numMBTriangles) maskMB |= 1 << 0;
if (numMBQuads) maskMB |= 1 << 1;
if (numMBBezierCurves+numMBLineSegments) maskMB |= 1 << 2;
if (numMBSubdivPatches) maskMB |= 1 << 3;
if (numMBUserGeometries) maskMB |= 1 << 4;
if (numMBInstancesCheap) maskMB |= 1 << 5;
if (numMBInstancesExpensive) maskMB |= 1 << 6;
if (numMBInstanceArrays) maskMB |= 1 << 7;
if (numMBGrids) maskMB |= 1 << 8;
if (numMBPoints) maskMB |= 1 << 9;
return (mask<<8) + maskMB;
}
__forceinline GeometryCounts operator+ (GeometryCounts const & rhs) const
{
GeometryCounts ret;
ret.numFilterFunctions = numFilterFunctions + rhs.numFilterFunctions;
ret.numTriangles = numTriangles + rhs.numTriangles;
ret.numMBTriangles = numMBTriangles + rhs.numMBTriangles;
ret.numQuads = numQuads + rhs.numQuads;
ret.numMBQuads = numMBQuads + rhs.numMBQuads;
ret.numBezierCurves = numBezierCurves + rhs.numBezierCurves;
ret.numMBBezierCurves = numMBBezierCurves + rhs.numMBBezierCurves;
ret.numLineSegments = numLineSegments + rhs.numLineSegments;
ret.numMBLineSegments = numMBLineSegments + rhs.numMBLineSegments;
ret.numSubdivPatches = numSubdivPatches + rhs.numSubdivPatches;
ret.numMBSubdivPatches = numMBSubdivPatches + rhs.numMBSubdivPatches;
ret.numUserGeometries = numUserGeometries + rhs.numUserGeometries;
ret.numMBUserGeometries = numMBUserGeometries + rhs.numMBUserGeometries;
ret.numInstancesCheap = numInstancesCheap + rhs.numInstancesCheap;
ret.numMBInstancesCheap = numMBInstancesCheap + rhs.numMBInstancesCheap;
ret.numInstancesExpensive = numInstancesExpensive + rhs.numInstancesExpensive;
ret.numMBInstancesExpensive = numMBInstancesExpensive + rhs.numMBInstancesExpensive;
ret.numInstanceArrays = numInstanceArrays + rhs.numInstanceArrays;
ret.numMBInstanceArrays = numMBInstanceArrays + rhs.numMBInstanceArrays;
ret.numGrids = numGrids + rhs.numGrids;
ret.numMBGrids = numMBGrids + rhs.numMBGrids;
ret.numSubGrids = numSubGrids + rhs.numSubGrids;
ret.numMBSubGrids = numMBSubGrids + rhs.numMBSubGrids;
ret.numPoints = numPoints + rhs.numPoints;
ret.numMBPoints = numMBPoints + rhs.numMBPoints;
return ret;
}
size_t numFilterFunctions; //!< number of geometries with filter functions enabled
size_t numTriangles; //!< number of enabled triangles
size_t numMBTriangles; //!< number of enabled motion blurred triangles
size_t numQuads; //!< number of enabled quads
size_t numMBQuads; //!< number of enabled motion blurred quads
size_t numBezierCurves; //!< number of enabled curves
size_t numMBBezierCurves; //!< number of enabled motion blurred curves
size_t numLineSegments; //!< number of enabled line segments
size_t numMBLineSegments; //!< number of enabled line motion blurred segments
size_t numSubdivPatches; //!< number of enabled subdivision patches
size_t numMBSubdivPatches; //!< number of enabled motion blurred subdivision patches
size_t numUserGeometries; //!< number of enabled user geometries
size_t numMBUserGeometries; //!< number of enabled motion blurred user geometries
size_t numInstancesCheap; //!< number of enabled cheap instances
size_t numMBInstancesCheap; //!< number of enabled motion blurred cheap instances
size_t numInstancesExpensive; //!< number of enabled expensive instances
size_t numMBInstancesExpensive; //!< number of enabled motion blurred expensive instances
size_t numInstanceArrays; //!< number of enabled instance arrays
size_t numMBInstanceArrays; //!< number of enabled motion blurred instance arrays
size_t numGrids; //!< number of enabled grid geometries
size_t numMBGrids; //!< number of enabled motion blurred grid geometries
size_t numSubGrids; //!< number of enabled grid geometries
size_t numMBSubGrids; //!< number of enabled motion blurred grid geometries
size_t numPoints; //!< number of enabled points
size_t numMBPoints; //!< number of enabled motion blurred points
};
/*! Base class all geometries are derived from */
class Geometry : public RefCount
{
ALIGNED_CLASS_USM_(16);
friend class Scene;
public:
/*! type of geometry */
enum GType
{
GTY_FLAT_LINEAR_CURVE = 0,
GTY_ROUND_LINEAR_CURVE = 1,
GTY_ORIENTED_LINEAR_CURVE = 2,
GTY_CONE_LINEAR_CURVE = 3,
GTY_FLAT_BEZIER_CURVE = 4,
GTY_ROUND_BEZIER_CURVE = 5,
GTY_ORIENTED_BEZIER_CURVE = 6,
GTY_FLAT_BSPLINE_CURVE = 8,
GTY_ROUND_BSPLINE_CURVE = 9,
GTY_ORIENTED_BSPLINE_CURVE = 10,
GTY_FLAT_HERMITE_CURVE = 12,
GTY_ROUND_HERMITE_CURVE = 13,
GTY_ORIENTED_HERMITE_CURVE = 14,
GTY_FLAT_CATMULL_ROM_CURVE = 16,
GTY_ROUND_CATMULL_ROM_CURVE = 17,
GTY_ORIENTED_CATMULL_ROM_CURVE = 18,
GTY_TRIANGLE_MESH = 20,
GTY_QUAD_MESH = 21,
GTY_GRID_MESH = 22,
GTY_SUBDIV_MESH = 23,
GTY_SPHERE_POINT = 25,
GTY_DISC_POINT = 26,
GTY_ORIENTED_DISC_POINT = 27,
GTY_USER_GEOMETRY = 29,
GTY_INSTANCE_CHEAP = 30,
GTY_INSTANCE_EXPENSIVE = 31,
GTY_INSTANCE_ARRAY = 24,
GTY_END = 32,
GTY_BASIS_LINEAR = 0,
GTY_BASIS_BEZIER = 4,
GTY_BASIS_BSPLINE = 8,
GTY_BASIS_HERMITE = 12,
GTY_BASIS_CATMULL_ROM = 16,
GTY_BASIS_MASK = 28,
GTY_SUBTYPE_FLAT_CURVE = 0,
GTY_SUBTYPE_ROUND_CURVE = 1,
GTY_SUBTYPE_ORIENTED_CURVE = 2,
GTY_SUBTYPE_MASK = 3,
};
enum GSubType
{
GTY_SUBTYPE_DEFAULT= 0,
GTY_SUBTYPE_INSTANCE_LINEAR = 0,
GTY_SUBTYPE_INSTANCE_QUATERNION = 1
};
enum GTypeMask
{
MTY_FLAT_LINEAR_CURVE = 1ul << GTY_FLAT_LINEAR_CURVE,
MTY_ROUND_LINEAR_CURVE = 1ul << GTY_ROUND_LINEAR_CURVE,
MTY_CONE_LINEAR_CURVE = 1ul << GTY_CONE_LINEAR_CURVE,
MTY_ORIENTED_LINEAR_CURVE = 1ul << GTY_ORIENTED_LINEAR_CURVE,
MTY_FLAT_BEZIER_CURVE = 1ul << GTY_FLAT_BEZIER_CURVE,
MTY_ROUND_BEZIER_CURVE = 1ul << GTY_ROUND_BEZIER_CURVE,
MTY_ORIENTED_BEZIER_CURVE = 1ul << GTY_ORIENTED_BEZIER_CURVE,
MTY_FLAT_BSPLINE_CURVE = 1ul << GTY_FLAT_BSPLINE_CURVE,
MTY_ROUND_BSPLINE_CURVE = 1ul << GTY_ROUND_BSPLINE_CURVE,
MTY_ORIENTED_BSPLINE_CURVE = 1ul << GTY_ORIENTED_BSPLINE_CURVE,
MTY_FLAT_HERMITE_CURVE = 1ul << GTY_FLAT_HERMITE_CURVE,
MTY_ROUND_HERMITE_CURVE = 1ul << GTY_ROUND_HERMITE_CURVE,
MTY_ORIENTED_HERMITE_CURVE = 1ul << GTY_ORIENTED_HERMITE_CURVE,
MTY_FLAT_CATMULL_ROM_CURVE = 1ul << GTY_FLAT_CATMULL_ROM_CURVE,
MTY_ROUND_CATMULL_ROM_CURVE = 1ul << GTY_ROUND_CATMULL_ROM_CURVE,
MTY_ORIENTED_CATMULL_ROM_CURVE = 1ul << GTY_ORIENTED_CATMULL_ROM_CURVE,
MTY_CURVE2 = MTY_FLAT_LINEAR_CURVE | MTY_ROUND_LINEAR_CURVE | MTY_CONE_LINEAR_CURVE | MTY_ORIENTED_LINEAR_CURVE,
MTY_CURVE4 = MTY_FLAT_BEZIER_CURVE | MTY_ROUND_BEZIER_CURVE | MTY_ORIENTED_BEZIER_CURVE |
MTY_FLAT_BSPLINE_CURVE | MTY_ROUND_BSPLINE_CURVE | MTY_ORIENTED_BSPLINE_CURVE |
MTY_FLAT_HERMITE_CURVE | MTY_ROUND_HERMITE_CURVE | MTY_ORIENTED_HERMITE_CURVE |
MTY_FLAT_CATMULL_ROM_CURVE | MTY_ROUND_CATMULL_ROM_CURVE | MTY_ORIENTED_CATMULL_ROM_CURVE,
MTY_SPHERE_POINT = 1ul << GTY_SPHERE_POINT,
MTY_DISC_POINT = 1ul << GTY_DISC_POINT,
MTY_ORIENTED_DISC_POINT = 1ul << GTY_ORIENTED_DISC_POINT,
MTY_POINTS = MTY_SPHERE_POINT | MTY_DISC_POINT | MTY_ORIENTED_DISC_POINT,
MTY_CURVES = MTY_CURVE2 | MTY_CURVE4 | MTY_POINTS,
MTY_TRIANGLE_MESH = 1ul << GTY_TRIANGLE_MESH,
MTY_QUAD_MESH = 1ul << GTY_QUAD_MESH,
MTY_GRID_MESH = 1ul << GTY_GRID_MESH,
MTY_SUBDIV_MESH = 1ul << GTY_SUBDIV_MESH,
MTY_USER_GEOMETRY = 1ul << GTY_USER_GEOMETRY,
MTY_INSTANCE_CHEAP = 1ul << GTY_INSTANCE_CHEAP,
MTY_INSTANCE_EXPENSIVE = 1ul << GTY_INSTANCE_EXPENSIVE,
MTY_INSTANCE = MTY_INSTANCE_CHEAP | MTY_INSTANCE_EXPENSIVE,
MTY_INSTANCE_ARRAY = 1ul << GTY_INSTANCE_ARRAY,
MTY_ALL = -1
};
static const char* gtype_names[GTY_END];
enum class State : unsigned {
MODIFIED = 0,
COMMITTED = 1,
};
public:
/*! Geometry constructor */
Geometry (Device* device, GType gtype, unsigned int numPrimitives, unsigned int numTimeSteps);
/*! Geometry destructor */
virtual ~Geometry();
public:
/*! tests if geometry is enabled */
__forceinline bool isEnabled() const { return enabled; }
/*! tests if geometry is disabled */
__forceinline bool isDisabled() const { return !isEnabled(); }
/* checks if argument version of filter functions are enabled */
__forceinline bool hasArgumentFilterFunctions() const {
return argumentFilterEnabled;
}
/*! tests if that geometry has some filter function set */
__forceinline bool hasGeometryFilterFunctions () const {
return (intersectionFilterN != nullptr) || (occlusionFilterN != nullptr);
}
/*! returns geometry type */
__forceinline GType getType() const { return gtype; }
/*! returns curve type */
__forceinline GType getCurveType() const { return (GType)(gtype & GTY_SUBTYPE_MASK); }
/*! returns curve basis */
__forceinline GType getCurveBasis() const { return (GType)(gtype & GTY_BASIS_MASK); }
/*! returns geometry type mask */
__forceinline GTypeMask getTypeMask() const { return (GTypeMask)(1 << gtype); }
/*! returns true of geometry contains motion blur */
__forceinline bool hasMotionBlur () const {
return numTimeSteps > 1;
}
/*! returns number of primitives */
__forceinline size_t size() const { return numPrimitives; }
/*! sets the number of primitives */
virtual void setNumPrimitives(unsigned int numPrimitives_in);
/*! sets number of time steps */
virtual void setNumTimeSteps (unsigned int numTimeSteps_in);
/*! sets motion blur time range */
void setTimeRange (const BBox1f range);
/*! gets motion blur time range */
BBox1f getTimeRange () const;
/*! sets number of vertex attributes */
virtual void setVertexAttributeCount (unsigned int N) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! sets number of topologies */
virtual void setTopologyCount (unsigned int N) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! sets the build quality */
void setBuildQuality(RTCBuildQuality quality_in)
{
this->quality = quality_in;
Geometry::update();
}
/* calculate time segment itime and fractional time ftime */
__forceinline int timeSegment(float time, float& ftime) const {
return getTimeSegment(time,time_range.lower,time_range.upper,fnumTimeSegments,ftime);
}
template<int N>
__forceinline vint<N> timeSegment(const vfloat<N>& time, vfloat<N>& ftime) const {
return getTimeSegment<N>(time,vfloat<N>(time_range.lower),vfloat<N>(time_range.upper),vfloat<N>(fnumTimeSegments),ftime);
}
/* calculate overlapping time segment range */
__forceinline range<int> timeSegmentRange(const BBox1f& range) const {
return getTimeSegmentRange(range,time_range,fnumTimeSegments);
}
/* returns time that corresponds to time step */
__forceinline float timeStep(const int i) const {
assert(i>=0 && i<(int)numTimeSteps);
return time_range.lower + time_range.size()*float(i)/fnumTimeSegments;
}
/*! for all geometries */
public:
/*! Enable geometry. */
virtual void enable();
/*! Update geometry. */
void update();
/*! commit of geometry */
virtual void commit();
/*! Update geometry buffer. */
virtual void updateBuffer(RTCBufferType type, unsigned int slot) {
update(); // update everything for geometries not supporting this call
}
/*! Disable geometry. */
virtual void disable();
/*! Verify the geometry */
virtual bool verify() { return true; }
/*! called before every build */
virtual void preCommit();
/*! called after every build */
virtual void postCommit();
virtual void addElementsToCount (GeometryCounts & counts) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
};
/*! sets constant tessellation rate for the geometry */
virtual void setTessellationRate(float N) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Sets the maximal curve radius scale allowed by min-width feature. */
virtual void setMaxRadiusScale(float s) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Set user data pointer. */
virtual void setUserData(void* ptr);
/*! Get user data pointer. */
__forceinline void* getUserData() const {
return userPtr;
}
/*! interpolates user data to the specified u/v location */
virtual void interpolate(const RTCInterpolateArguments* const args) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! interpolates user data to the specified u/v locations */
virtual void interpolateN(const RTCInterpolateNArguments* const args);
/* point query api */
bool pointQuery(PointQuery* query, PointQueryContext* context);
/*! for subdivision surfaces only */
public:
virtual void setSubdivisionMode (unsigned topologyID, RTCSubdivisionMode mode) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
virtual void setVertexAttributeTopology(unsigned int vertexBufferSlot, unsigned int indexBufferSlot) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Set displacement function. */
virtual void setDisplacementFunction (RTCDisplacementFunctionN filter) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
virtual unsigned int getFirstHalfEdge(unsigned int faceID) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
virtual unsigned int getFace(unsigned int edgeID) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
virtual unsigned int getNextHalfEdge(unsigned int edgeID) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
virtual unsigned int getPreviousHalfEdge(unsigned int edgeID) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
virtual unsigned int getOppositeHalfEdge(unsigned int topologyID, unsigned int edgeID) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! get fast access to first vertex buffer if applicable */
virtual float * getCompactVertexArray () const {
return nullptr;
}
/*! Returns the modified counter - how many times the geo has been modified */
__forceinline unsigned int getModCounter () const {
return modCounter_;
}
/*! for triangle meshes and bezier curves only */
public:
/*! Sets ray mask. */
virtual void setMask(unsigned mask) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Sets specified buffer. */
virtual void setBuffer(RTCBufferType type, unsigned int slot, RTCFormat format, const Ref<Buffer>& buffer, size_t offset, size_t stride, unsigned int num) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Gets specified buffer. */
virtual void* getBuffer(RTCBufferType type, unsigned int slot) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Set intersection filter function for ray packets of size N. */
virtual void setIntersectionFilterFunctionN (RTCFilterFunctionN filterN);
/*! Set occlusion filter function for ray packets of size N. */
virtual void setOcclusionFilterFunctionN (RTCFilterFunctionN filterN);
/* Enables argument version of intersection or occlusion filter function. */
virtual void enableFilterFunctionFromArguments (bool enable) {
argumentFilterEnabled = enable;
}
/*! for instances only */
public:
/*! Sets the instanced scene */
virtual void setInstancedScene(const Ref<Scene>& scene) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Sets the instanced scenes */
virtual void setInstancedScenes(const RTCScene* scenes, size_t numScenes) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Sets transformation of the instance */
virtual void setTransform(const AffineSpace3fa& transform, unsigned int timeStep) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Sets transformation of the instance */
virtual void setQuaternionDecomposition(const AffineSpace3ff& qd, unsigned int timeStep) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Returns the transformation of the instance */
virtual AffineSpace3fa getTransform(float time) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Returns the transformation of the instance */
virtual AffineSpace3fa getTransform(size_t instance, float time) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! for user geometries only */
public:
/*! Set bounds function. */
virtual void setBoundsFunction (RTCBoundsFunction bounds, void* userPtr) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Set intersect function for ray packets of size N. */
virtual void setIntersectFunctionN (RTCIntersectFunctionN intersect) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Set occlusion function for ray packets of size N. */
virtual void setOccludedFunctionN (RTCOccludedFunctionN occluded) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
}
/*! Set point query function. */
void setPointQueryFunction(RTCPointQueryFunction func);
/*! returns number of time segments */
__forceinline unsigned numTimeSegments () const {
return numTimeSteps-1;
}
public:
virtual PrimInfo createPrimRefArray(PrimRef* prims, const range<size_t>& r, size_t k, unsigned int geomID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"createPrimRefArray not implemented for this geometry");
}
PrimInfo createPrimRefArray(mvector<PrimRef>& prims, const range<size_t>& r, size_t k, unsigned int geomID) const {
return createPrimRefArray(prims.data(),r,k,geomID);
}
PrimInfo createPrimRefArray(avector<PrimRef>& prims, const range<size_t>& r, size_t k, unsigned int geomID) const {
return createPrimRefArray(prims.data(),r,k,geomID);
}
virtual PrimInfo createPrimRefArray(mvector<PrimRef>& prims, mvector<SubGridBuildData>& sgrids, const range<size_t>& r, size_t k, unsigned int geomID) const {
return createPrimRefArray(prims,r,k,geomID);
}
virtual PrimInfo createPrimRefArrayMB(mvector<PrimRef>& prims, size_t itime, const range<size_t>& r, size_t k, unsigned int geomID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"createPrimRefMBArray not implemented for this geometry");
}
/*! Calculates the PrimRef over the complete time interval */
virtual PrimInfo createPrimRefArrayMB(PrimRef* prims, const BBox1f& t0t1, const range<size_t>& r, size_t k, unsigned int geomID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"createPrimRefMBArray not implemented for this geometry");
}
PrimInfo createPrimRefArrayMB(mvector<PrimRef>& prims, const BBox1f& t0t1, const range<size_t>& r, size_t k, unsigned int geomID) const {
return createPrimRefArrayMB(prims.data(),t0t1,r,k,geomID);
}
PrimInfo createPrimRefArrayMB(avector<PrimRef>& prims, const BBox1f& t0t1, const range<size_t>& r, size_t k, unsigned int geomID) const {
return createPrimRefArrayMB(prims.data(),t0t1,r,k,geomID);
}
virtual PrimInfoMB createPrimRefMBArray(mvector<PrimRefMB>& prims, const BBox1f& t0t1, const range<size_t>& r, size_t k, unsigned int geomID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"createPrimRefMBArray not implemented for this geometry");
}
virtual PrimInfoMB createPrimRefMBArray(mvector<PrimRefMB>& prims, mvector<SubGridBuildData>& sgrids, const BBox1f& t0t1, const range<size_t>& r, size_t k, unsigned int geomID) const {
return createPrimRefMBArray(prims,t0t1,r,k,geomID);
}
virtual LinearSpace3fa computeAlignedSpace(const size_t primID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"computeAlignedSpace not implemented for this geometry");
}
virtual LinearSpace3fa computeAlignedSpaceMB(const size_t primID, const BBox1f time_range) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"computeAlignedSpace not implemented for this geometry");
}
virtual Vec3fa computeDirection(unsigned int primID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"computeDirection not implemented for this geometry");
}
virtual Vec3fa computeDirection(unsigned int primID, size_t time) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"computeDirection not implemented for this geometry");
}
virtual BBox3fa vbounds(size_t primID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"vbounds not implemented for this geometry");
}
virtual BBox3fa vbounds(const LinearSpace3fa& space, size_t primID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"vbounds not implemented for this geometry");
}
virtual BBox3fa vbounds(const Vec3fa& ofs, const float scale, const float r_scale0, const LinearSpace3fa& space, size_t i, size_t itime = 0) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"vbounds not implemented for this geometry");
}
virtual LBBox3fa vlinearBounds(size_t primID, const BBox1f& time_range) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"vlinearBounds not implemented for this geometry");
}
virtual LBBox3fa vlinearBounds(size_t primID, const BBox1f& time_range, const SubGridBuildData * const sgrids) const {
return vlinearBounds(primID,time_range);
}
virtual LBBox3fa vlinearBounds(const LinearSpace3fa& space, size_t primID, const BBox1f& time_range) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"vlinearBounds not implemented for this geometry");
}
virtual LBBox3fa vlinearBounds(const Vec3fa& ofs, const float scale, const float r_scale0, const LinearSpace3fa& space, size_t primID, const BBox1f& time_range) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"vlinearBounds not implemented for this geometry");
}
public:
__forceinline bool hasIntersectionFilter() const { return intersectionFilterN != nullptr; }
__forceinline bool hasOcclusionFilter() const { return occlusionFilterN != nullptr; }
public:
Device* device; //!< device this geometry belongs to
void* userPtr; //!< user pointer
unsigned int numPrimitives; //!< number of primitives of this geometry
unsigned int numTimeSteps; //!< number of time steps
float fnumTimeSegments; //!< number of time segments (precalculation)
BBox1f time_range; //!< motion blur time range
unsigned int mask; //!< for masking out geometry
unsigned int modCounter_ = 1; //!< counter for every modification - used to rebuild scenes when geo is modified
struct {
GType gtype : 8; //!< geometry type
GSubType gsubtype : 8; //!< geometry subtype
RTCBuildQuality quality : 3; //!< build quality for geometry
unsigned state : 2;
bool enabled : 1; //!< true if geometry is enabled
bool argumentFilterEnabled : 1; //!< true if argument filter functions are enabled for this geometry
};
RTCFilterFunctionN intersectionFilterN;
RTCFilterFunctionN occlusionFilterN;
RTCPointQueryFunction pointQueryFunc;
};
}