// Copyright 2009-2021 Intel Corporation // SPDX-License-Identifier: Apache-2.0 #pragma once #include "geometry.h" #include "accel.h" namespace embree { struct MotionDerivativeCoefficients; /*! Instanced acceleration structure */ struct Instance : public Geometry { ALIGNED_STRUCT_(16); static const Geometry::GTypeMask geom_type = Geometry::MTY_INSTANCE; public: Instance (Device* device, Accel* object = nullptr, unsigned int numTimeSteps = 1); ~Instance(); private: Instance (const Instance& other) DELETED; // do not implement Instance& operator= (const Instance& other) DELETED; // do not implement private: LBBox3fa nonlinearBounds(const BBox1f& time_range_in, const BBox1f& geom_time_range, float geom_time_segments) const; BBox3fa boundSegment(size_t itime, BBox3fa const& obbox0, BBox3fa const& obbox1, BBox3fa const& bbox0, BBox3fa const& bbox1, float t_min, float t_max) const; /* calculates the (correct) interpolated bounds */ __forceinline BBox3fa bounds(size_t itime0, size_t itime1, float f) const { if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION)) return xfmBounds(slerp(local2world[itime0], local2world[itime1], f), lerp(getObjectBounds(itime0), getObjectBounds(itime1), f)); return xfmBounds(lerp(local2world[itime0], local2world[itime1], f), lerp(getObjectBounds(itime0), getObjectBounds(itime1), f)); } public: virtual void setNumTimeSteps (unsigned int numTimeSteps) override; virtual void setInstancedScene(const Ref<Scene>& scene) override; virtual void setTransform(const AffineSpace3fa& local2world, unsigned int timeStep) override; virtual void setQuaternionDecomposition(const AffineSpace3ff& qd, unsigned int timeStep) override; virtual AffineSpace3fa getTransform(float time) override; virtual void setMask (unsigned mask) override; virtual void build() {} virtual void addElementsToCount (GeometryCounts & counts) const override; virtual void commit() override; public: /*! calculates the bounds of instance */ __forceinline BBox3fa bounds(size_t i) const { assert(i == 0); if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION)) return xfmBounds(quaternionDecompositionToAffineSpace(local2world[0]),object->bounds.bounds()); return xfmBounds(local2world[0],object->bounds.bounds()); } /*! gets the bounds of the instanced scene */ __forceinline BBox3fa getObjectBounds(size_t itime) const { return object->getBounds(timeStep(itime)); } /*! calculates the bounds of instance */ __forceinline BBox3fa bounds(size_t i, size_t itime) const { assert(i == 0); if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION)) return xfmBounds(quaternionDecompositionToAffineSpace(local2world[itime]),getObjectBounds(itime)); return xfmBounds(local2world[itime],getObjectBounds(itime)); } /*! calculates the linear bounds of the i'th primitive for the specified time range */ __forceinline LBBox3fa linearBounds(size_t i, const BBox1f& dt) const { assert(i == 0); LBBox3fa lbbox = nonlinearBounds(dt, time_range, fnumTimeSegments); return lbbox; } /*! calculates the build bounds of the i'th item, if it's valid */ __forceinline bool buildBounds(size_t i, BBox3fa* bbox = nullptr) const { assert(i==0); const BBox3fa b = bounds(i); if (bbox) *bbox = b; return isvalid(b); } /*! calculates the build bounds of the i'th item at the itime'th time segment, if it's valid */ __forceinline bool buildBounds(size_t i, size_t itime, BBox3fa& bbox) const { assert(i==0); const LBBox3fa bounds = linearBounds(i,itime); bbox = bounds.bounds (); return isvalid(bounds); } /* gets version info of topology */ unsigned int getTopologyVersion() const { return numPrimitives; } /* returns true if topology changed */ bool topologyChanged(unsigned int otherVersion) const { return numPrimitives != otherVersion; } /*! check if the i'th primitive is valid between the specified time range */ __forceinline bool valid(size_t i, const range<size_t>& itime_range) const { assert(i == 0); for (size_t itime = itime_range.begin(); itime <= itime_range.end(); itime++) if (!isvalid(bounds(i,itime))) return false; return true; } __forceinline AffineSpace3fa getLocal2World() const { if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION)) return quaternionDecompositionToAffineSpace(local2world[0]); return local2world[0]; } __forceinline AffineSpace3fa getLocal2World(float t) const { float ftime; const unsigned int itime = timeSegment(t, ftime); if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION)) return slerp(local2world[itime+0],local2world[itime+1],ftime); return lerp(local2world[itime+0],local2world[itime+1],ftime); } __forceinline AffineSpace3fa getWorld2Local() const { return world2local0; } __forceinline AffineSpace3fa getWorld2Local(float t) const { return rcp(getLocal2World(t)); } template<int K> __forceinline AffineSpace3vf<K> getWorld2Local(const vbool<K>& valid, const vfloat<K>& t) const { if (unlikely(gsubtype == GTY_SUBTYPE_INSTANCE_QUATERNION)) return getWorld2LocalSlerp<K>(valid, t); return getWorld2LocalLerp<K>(valid, t); } private: template<int K> __forceinline AffineSpace3vf<K> getWorld2LocalSlerp(const vbool<K>& valid, const vfloat<K>& t) const { vfloat<K> ftime; const vint<K> itime_k = timeSegment<K>(t, ftime); assert(any(valid)); const size_t index = bsf(movemask(valid)); const int itime = itime_k[index]; if (likely(all(valid, itime_k == vint<K>(itime)))) { return rcp(slerp(AffineSpace3vff<K>(local2world[itime+0]), AffineSpace3vff<K>(local2world[itime+1]), ftime)); } else { AffineSpace3vff<K> space0,space1; vbool<K> valid1 = valid; while (any(valid1)) { vbool<K> valid2; const int itime = next_unique(valid1, itime_k, valid2); space0 = select(valid2, AffineSpace3vff<K>(local2world[itime+0]), space0); space1 = select(valid2, AffineSpace3vff<K>(local2world[itime+1]), space1); } return rcp(slerp(space0, space1, ftime)); } } template<int K> __forceinline AffineSpace3vf<K> getWorld2LocalLerp(const vbool<K>& valid, const vfloat<K>& t) const { vfloat<K> ftime; const vint<K> itime_k = timeSegment<K>(t, ftime); assert(any(valid)); const size_t index = bsf(movemask(valid)); const int itime = itime_k[index]; if (likely(all(valid, itime_k == vint<K>(itime)))) { return rcp(lerp(AffineSpace3vf<K>((AffineSpace3fa)local2world[itime+0]), AffineSpace3vf<K>((AffineSpace3fa)local2world[itime+1]), ftime)); } else { AffineSpace3vf<K> space0,space1; vbool<K> valid1 = valid; while (any(valid1)) { vbool<K> valid2; const int itime = next_unique(valid1, itime_k, valid2); space0 = select(valid2, AffineSpace3vf<K>((AffineSpace3fa)local2world[itime+0]), space0); space1 = select(valid2, AffineSpace3vf<K>((AffineSpace3fa)local2world[itime+1]), space1); } return rcp(lerp(space0, space1, ftime)); } } public: Accel* object; //!< pointer to instanced acceleration structure AffineSpace3ff* local2world; //!< transformation from local space to world space for each timestep (either normal matrix or quaternion decomposition) AffineSpace3fa world2local0; //!< transformation from world space to local space for timestep 0 }; namespace isa { struct InstanceISA : public Instance { InstanceISA (Device* device) : Instance(device) {} PrimInfo createPrimRefArray(mvector<PrimRef>& prims, const range<size_t>& r, size_t k, unsigned int geomID) const { assert(r.begin() == 0); assert(r.end() == 1); PrimInfo pinfo(empty); BBox3fa b = empty; if (!buildBounds(0,&b)) return pinfo; // const BBox3fa b = bounds(0); // if (!isvalid(b)) return pinfo; const PrimRef prim(b,geomID,unsigned(0)); pinfo.add_center2(prim); prims[k++] = prim; return pinfo; } PrimInfo createPrimRefArrayMB(mvector<PrimRef>& prims, size_t itime, const range<size_t>& r, size_t k, unsigned int geomID) const { assert(r.begin() == 0); assert(r.end() == 1); PrimInfo pinfo(empty); BBox3fa b = empty; if (!buildBounds(0,&b)) return pinfo; // if (!valid(0,range<size_t>(itime))) return pinfo; // const PrimRef prim(linearBounds(0,itime).bounds(),geomID,unsigned(0)); const PrimRef prim(b,geomID,unsigned(0)); pinfo.add_center2(prim); prims[k++] = prim; return pinfo; } PrimInfoMB createPrimRefMBArray(mvector<PrimRefMB>& prims, const BBox1f& t0t1, const range<size_t>& r, size_t k, unsigned int geomID) const { assert(r.begin() == 0); assert(r.end() == 1); PrimInfoMB pinfo(empty); if (!valid(0, timeSegmentRange(t0t1))) return pinfo; const PrimRefMB prim(linearBounds(0,t0t1),this->numTimeSegments(),this->time_range,this->numTimeSegments(),geomID,unsigned(0)); pinfo.add_primref(prim); prims[k++] = prim; return pinfo; } }; } DECLARE_ISA_FUNCTION(Instance*, createInstance, Device*); }