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)
290 lines
10 KiB
C++
290 lines
10 KiB
C++
// Copyright 2009-2021 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#pragma once
|
|
|
|
#include "bbox.h"
|
|
#include "range.h"
|
|
|
|
namespace embree
|
|
{
|
|
template<typename T>
|
|
__forceinline std::pair<T,T> globalLinear(const std::pair<T,T>& v, const BBox1f& dt)
|
|
{
|
|
const float rcp_dt_size = float(1.0f)/dt.size();
|
|
const T g0 = lerp(v.first,v.second,-dt.lower*rcp_dt_size);
|
|
const T g1 = lerp(v.first,v.second,(1.0f-dt.lower)*rcp_dt_size);
|
|
return std::make_pair(g0,g1);
|
|
}
|
|
|
|
template<typename T>
|
|
struct LBBox
|
|
{
|
|
public:
|
|
__forceinline LBBox () {}
|
|
|
|
template<typename T1>
|
|
__forceinline LBBox ( const LBBox<T1>& other )
|
|
: bounds0(other.bounds0), bounds1(other.bounds1) {}
|
|
|
|
__forceinline LBBox& operator= ( const LBBox& other ) {
|
|
bounds0 = other.bounds0; bounds1 = other.bounds1; return *this;
|
|
}
|
|
|
|
__forceinline LBBox (EmptyTy)
|
|
: bounds0(EmptyTy()), bounds1(EmptyTy()) {}
|
|
|
|
__forceinline explicit LBBox ( const BBox<T>& bounds)
|
|
: bounds0(bounds), bounds1(bounds) { }
|
|
|
|
__forceinline LBBox ( const BBox<T>& bounds0, const BBox<T>& bounds1)
|
|
: bounds0(bounds0), bounds1(bounds1) { }
|
|
|
|
LBBox ( const avector<BBox<T>>& bounds )
|
|
{
|
|
assert(bounds.size());
|
|
BBox<T> b0 = bounds.front();
|
|
BBox<T> b1 = bounds.back();
|
|
for (size_t i=1; i<bounds.size()-1; i++) {
|
|
const float f = float(i)/float(bounds.size()-1);
|
|
const BBox<T> bt = lerp(b0,b1,f);
|
|
const T dlower = min(bounds[i].lower-bt.lower,T(zero));
|
|
const T dupper = max(bounds[i].upper-bt.upper,T(zero));
|
|
b0.lower += dlower; b1.lower += dlower;
|
|
b0.upper += dupper; b1.upper += dupper;
|
|
}
|
|
bounds0 = b0;
|
|
bounds1 = b1;
|
|
}
|
|
|
|
/*! calculates the linear bounds of a primitive for the specified time range */
|
|
template<typename BoundsFunc>
|
|
__forceinline LBBox(const BoundsFunc& bounds, const BBox1f& time_range, float numTimeSegments)
|
|
{
|
|
const float lower = time_range.lower*numTimeSegments;
|
|
const float upper = time_range.upper*numTimeSegments;
|
|
const float ilowerf = floor(lower);
|
|
const float iupperf = ceil(upper);
|
|
const int ilower = (int)ilowerf;
|
|
const int iupper = (int)iupperf;
|
|
|
|
const BBox<T> blower0 = bounds(ilower);
|
|
const BBox<T> bupper1 = bounds(iupper);
|
|
|
|
if (iupper-ilower == 1) {
|
|
bounds0 = lerp(blower0, bupper1, lower-ilowerf);
|
|
bounds1 = lerp(bupper1, blower0, iupperf-upper);
|
|
return;
|
|
}
|
|
|
|
const BBox<T> blower1 = bounds(ilower+1);
|
|
const BBox<T> bupper0 = bounds(iupper-1);
|
|
BBox<T> b0 = lerp(blower0, blower1, lower-ilowerf);
|
|
BBox<T> b1 = lerp(bupper1, bupper0, iupperf-upper);
|
|
|
|
for (int i = ilower+1; i < iupper; i++)
|
|
{
|
|
const float f = (float(i)/numTimeSegments - time_range.lower) / time_range.size();
|
|
const BBox<T> bt = lerp(b0, b1, f);
|
|
const BBox<T> bi = bounds(i);
|
|
const T dlower = min(bi.lower-bt.lower, T(zero));
|
|
const T dupper = max(bi.upper-bt.upper, T(zero));
|
|
b0.lower += dlower; b1.lower += dlower;
|
|
b0.upper += dupper; b1.upper += dupper;
|
|
}
|
|
|
|
bounds0 = b0;
|
|
bounds1 = b1;
|
|
}
|
|
|
|
/*! calculates the linear bounds of a primitive for the specified time range */
|
|
template<typename BoundsFunc>
|
|
__forceinline LBBox(const BoundsFunc& bounds, const BBox1f& time_range_in, const BBox1f& geom_time_range, float geom_time_segments)
|
|
{
|
|
/* normalize global time_range_in to local geom_time_range */
|
|
const BBox1f time_range((time_range_in.lower-geom_time_range.lower)/geom_time_range.size(),
|
|
(time_range_in.upper-geom_time_range.lower)/geom_time_range.size());
|
|
|
|
const float lower = time_range.lower*geom_time_segments;
|
|
const float upper = time_range.upper*geom_time_segments;
|
|
const float ilowerf = floor(lower);
|
|
const float iupperf = ceil(upper);
|
|
const float ilowerfc = max(0.0f,ilowerf);
|
|
const float iupperfc = min(iupperf,geom_time_segments);
|
|
const int ilowerc = (int)ilowerfc;
|
|
const int iupperc = (int)iupperfc;
|
|
assert(iupperc-ilowerc > 0);
|
|
|
|
/* this larger iteration range guarantees that we process borders of geom_time_range is (partially) inside time_range_in */
|
|
const int ilower_iter = max(-1,(int)ilowerf);
|
|
const int iupper_iter = min((int)iupperf,(int)geom_time_segments+1);
|
|
|
|
const BBox<T> blower0 = bounds(ilowerc);
|
|
const BBox<T> bupper1 = bounds(iupperc);
|
|
if (iupper_iter-ilower_iter == 1) {
|
|
bounds0 = lerp(blower0, bupper1, max(0.0f,lower-ilowerfc));
|
|
bounds1 = lerp(bupper1, blower0, max(0.0f,iupperfc-upper));
|
|
return;
|
|
}
|
|
|
|
const BBox<T> blower1 = bounds(ilowerc+1);
|
|
const BBox<T> bupper0 = bounds(iupperc-1);
|
|
BBox<T> b0 = lerp(blower0, blower1, max(0.0f,lower-ilowerfc));
|
|
BBox<T> b1 = lerp(bupper1, bupper0, max(0.0f,iupperfc-upper));
|
|
|
|
for (int i = ilower_iter+1; i < iupper_iter; i++)
|
|
{
|
|
const float f = (float(i)/geom_time_segments - time_range.lower) / time_range.size();
|
|
const BBox<T> bt = lerp(b0, b1, f);
|
|
const BBox<T> bi = bounds(i);
|
|
const T dlower = min(bi.lower-bt.lower, T(zero));
|
|
const T dupper = max(bi.upper-bt.upper, T(zero));
|
|
b0.lower += dlower; b1.lower += dlower;
|
|
b0.upper += dupper; b1.upper += dupper;
|
|
}
|
|
|
|
bounds0 = b0;
|
|
bounds1 = b1;
|
|
}
|
|
|
|
/*! calculates the linear bounds of a primitive for the specified time range */
|
|
template<typename BoundsFunc>
|
|
__forceinline LBBox(const BoundsFunc& bounds, const range<int>& time_range, int numTimeSegments)
|
|
{
|
|
const int ilower = time_range.begin();
|
|
const int iupper = time_range.end();
|
|
|
|
BBox<T> b0 = bounds(ilower);
|
|
BBox<T> b1 = bounds(iupper);
|
|
|
|
if (iupper-ilower == 1)
|
|
{
|
|
bounds0 = b0;
|
|
bounds1 = b1;
|
|
return;
|
|
}
|
|
|
|
for (int i = ilower+1; i<iupper; i++)
|
|
{
|
|
const float f = float(i - time_range.begin()) / float(time_range.size());
|
|
const BBox<T> bt = lerp(b0, b1, f);
|
|
const BBox<T> bi = bounds(i);
|
|
const T dlower = min(bi.lower-bt.lower, T(zero));
|
|
const T dupper = max(bi.upper-bt.upper, T(zero));
|
|
b0.lower += dlower; b1.lower += dlower;
|
|
b0.upper += dupper; b1.upper += dupper;
|
|
}
|
|
|
|
bounds0 = b0;
|
|
bounds1 = b1;
|
|
}
|
|
|
|
public:
|
|
|
|
__forceinline bool empty() const {
|
|
return bounds().empty();
|
|
}
|
|
|
|
__forceinline BBox<T> bounds () const {
|
|
return merge(bounds0,bounds1);
|
|
}
|
|
|
|
__forceinline BBox<T> interpolate( const float t ) const {
|
|
return lerp(bounds0,bounds1,t);
|
|
}
|
|
|
|
__forceinline LBBox<T> interpolate( const BBox1f& dt ) const {
|
|
return LBBox<T>(interpolate(dt.lower),interpolate(dt.upper));
|
|
}
|
|
|
|
__forceinline void extend( const LBBox& other ) {
|
|
bounds0.extend(other.bounds0);
|
|
bounds1.extend(other.bounds1);
|
|
}
|
|
|
|
__forceinline float expectedHalfArea() const;
|
|
|
|
__forceinline float expectedHalfArea(const BBox1f& dt) const {
|
|
return interpolate(dt).expectedHalfArea();
|
|
}
|
|
|
|
__forceinline float expectedApproxHalfArea() const {
|
|
return 0.5f*(halfArea(bounds0) + halfArea(bounds1));
|
|
}
|
|
|
|
/* calculates bounds for [0,1] time range from bounds in dt time range */
|
|
__forceinline LBBox global(const BBox1f& dt) const
|
|
{
|
|
const float rcp_dt_size = 1.0f/dt.size();
|
|
const BBox<T> b0 = interpolate(-dt.lower*rcp_dt_size);
|
|
const BBox<T> b1 = interpolate((1.0f-dt.lower)*rcp_dt_size);
|
|
return LBBox(b0,b1);
|
|
}
|
|
|
|
/*! Comparison Operators */
|
|
//template<typename TT> friend __forceinline bool operator==( const LBBox<TT>& a, const LBBox<TT>& b ) { return a.bounds0 == b.bounds0 && a.bounds1 == b.bounds1; }
|
|
//template<typename TT> friend __forceinline bool operator!=( const LBBox<TT>& a, const LBBox<TT>& b ) { return a.bounds0 != b.bounds0 || a.bounds1 != b.bounds1; }
|
|
friend __forceinline bool operator==( const LBBox& a, const LBBox& b ) { return a.bounds0 == b.bounds0 && a.bounds1 == b.bounds1; }
|
|
friend __forceinline bool operator!=( const LBBox& a, const LBBox& b ) { return a.bounds0 != b.bounds0 || a.bounds1 != b.bounds1; }
|
|
|
|
/*! output operator */
|
|
friend __forceinline embree_ostream operator<<(embree_ostream cout, const LBBox& box) {
|
|
return cout << "LBBox { " << box.bounds0 << "; " << box.bounds1 << " }";
|
|
}
|
|
|
|
public:
|
|
BBox<T> bounds0, bounds1;
|
|
};
|
|
|
|
/*! tests if box is finite */
|
|
template<typename T>
|
|
__forceinline bool isvalid( const LBBox<T>& v ) {
|
|
return isvalid(v.bounds0) && isvalid(v.bounds1);
|
|
}
|
|
|
|
template<typename T>
|
|
__forceinline bool isvalid_non_empty( const LBBox<T>& v ) {
|
|
return isvalid_non_empty(v.bounds0) && isvalid_non_empty(v.bounds1);
|
|
}
|
|
|
|
template<typename T>
|
|
__forceinline T expectedArea(const T& a0, const T& a1, const T& b0, const T& b1)
|
|
{
|
|
const T da = a1-a0;
|
|
const T db = b1-b0;
|
|
return a0*b0+(a0*db+da*b0)*T(0.5f) + da*db*T(1.0f/3.0f);
|
|
}
|
|
|
|
template<> __forceinline float LBBox<Vec3fa>::expectedHalfArea() const
|
|
{
|
|
const Vec3fa d0 = bounds0.size();
|
|
const Vec3fa d1 = bounds1.size();
|
|
return reduce_add(expectedArea(Vec3fa(d0.x,d0.y,d0.z),
|
|
Vec3fa(d1.x,d1.y,d1.z),
|
|
Vec3fa(d0.y,d0.z,d0.x),
|
|
Vec3fa(d1.y,d1.z,d1.x)));
|
|
}
|
|
|
|
template<typename T>
|
|
__forceinline float expectedApproxHalfArea(const LBBox<T>& box) {
|
|
return box.expectedApproxHalfArea();
|
|
}
|
|
|
|
template<typename T>
|
|
__forceinline LBBox<T> merge(const LBBox<T>& a, const LBBox<T>& b) {
|
|
return LBBox<T>(merge(a.bounds0, b.bounds0), merge(a.bounds1, b.bounds1));
|
|
}
|
|
|
|
/*! subset relation */
|
|
template<typename T> __inline bool subset( const LBBox<T>& a, const LBBox<T>& b ) {
|
|
return subset(a.bounds0,b.bounds0) && subset(a.bounds1,b.bounds1);
|
|
}
|
|
|
|
/*! default template instantiations */
|
|
typedef LBBox<float> LBBox1f;
|
|
typedef LBBox<Vec2f> LBBox2f;
|
|
typedef LBBox<Vec3f> LBBox3f;
|
|
typedef LBBox<Vec3fa> LBBox3fa;
|
|
typedef LBBox<Vec3fx> LBBox3fx;
|
|
}
|