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)
272 lines
9.8 KiB
C++
272 lines
9.8 KiB
C++
// 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*);
|
|
}
|