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)
361 lines
15 KiB
C++
361 lines
15 KiB
C++
// Copyright 2009-2021 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#pragma once
|
|
|
|
#include "linearspace2.h"
|
|
#include "linearspace3.h"
|
|
#include "quaternion.h"
|
|
#include "bbox.h"
|
|
#include "vec4.h"
|
|
|
|
namespace embree
|
|
{
|
|
#define VectorT typename L::Vector
|
|
#define ScalarT typename L::Vector::Scalar
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Affine Space
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename L>
|
|
struct AffineSpaceT
|
|
{
|
|
L l; /*< linear part of affine space */
|
|
VectorT p; /*< affine part of affine space */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Constructors, Assignment, Cast, Copy Operations
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
__forceinline AffineSpaceT ( ) { }
|
|
__forceinline AffineSpaceT ( const AffineSpaceT& other ) { l = other.l; p = other.p; }
|
|
__forceinline AffineSpaceT ( const L & other ) { l = other ; p = VectorT(zero); }
|
|
__forceinline AffineSpaceT& operator=( const AffineSpaceT& other ) { l = other.l; p = other.p; return *this; }
|
|
|
|
__forceinline AffineSpaceT( const VectorT& vx, const VectorT& vy, const VectorT& vz, const VectorT& p ) : l(vx,vy,vz), p(p) {}
|
|
__forceinline AffineSpaceT( const L& l, const VectorT& p ) : l(l), p(p) {}
|
|
|
|
template<typename L1> __forceinline AffineSpaceT( const AffineSpaceT<L1>& s ) : l(s.l), p(s.p) {}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Constants
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
__forceinline AffineSpaceT( ZeroTy ) : l(zero), p(zero) {}
|
|
__forceinline AffineSpaceT( OneTy ) : l(one), p(zero) {}
|
|
|
|
/*! return matrix for scaling */
|
|
static __forceinline AffineSpaceT scale(const VectorT& s) { return L::scale(s); }
|
|
|
|
/*! return matrix for translation */
|
|
static __forceinline AffineSpaceT translate(const VectorT& p) { return AffineSpaceT(one,p); }
|
|
|
|
/*! return matrix for rotation, only in 2D */
|
|
static __forceinline AffineSpaceT rotate(const ScalarT& r) { return L::rotate(r); }
|
|
|
|
/*! return matrix for rotation around arbitrary point (2D) or axis (3D) */
|
|
static __forceinline AffineSpaceT rotate(const VectorT& u, const ScalarT& r) { return L::rotate(u,r); }
|
|
|
|
/*! return matrix for rotation around arbitrary axis and point, only in 3D */
|
|
static __forceinline AffineSpaceT rotate(const VectorT& p, const VectorT& u, const ScalarT& r) { return translate(+p) * rotate(u,r) * translate(-p); }
|
|
|
|
/*! return matrix for looking at given point, only in 3D */
|
|
static __forceinline AffineSpaceT lookat(const VectorT& eye, const VectorT& point, const VectorT& up) {
|
|
VectorT Z = normalize(point-eye);
|
|
VectorT U = normalize(cross(up,Z));
|
|
VectorT V = normalize(cross(Z,U));
|
|
return AffineSpaceT(L(U,V,Z),eye);
|
|
}
|
|
|
|
};
|
|
|
|
// template specialization to get correct identity matrix for type AffineSpace3fa
|
|
template<>
|
|
__forceinline AffineSpaceT<LinearSpace3ff>::AffineSpaceT( OneTy ) : l(one), p(0.f, 0.f, 0.f, 1.f) {}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Unary Operators
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename L> __forceinline AffineSpaceT<L> operator -( const AffineSpaceT<L>& a ) { return AffineSpaceT<L>(-a.l,-a.p); }
|
|
template<typename L> __forceinline AffineSpaceT<L> operator +( const AffineSpaceT<L>& a ) { return AffineSpaceT<L>(+a.l,+a.p); }
|
|
template<typename L> __forceinline AffineSpaceT<L> rcp( const AffineSpaceT<L>& a ) { L il = rcp(a.l); return AffineSpaceT<L>(il,-(il*a.p)); }
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Binary Operators
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename L> __forceinline const AffineSpaceT<L> operator +( const AffineSpaceT<L>& a, const AffineSpaceT<L>& b ) { return AffineSpaceT<L>(a.l+b.l,a.p+b.p); }
|
|
template<typename L> __forceinline const AffineSpaceT<L> operator -( const AffineSpaceT<L>& a, const AffineSpaceT<L>& b ) { return AffineSpaceT<L>(a.l-b.l,a.p-b.p); }
|
|
|
|
template<typename L> __forceinline const AffineSpaceT<L> operator *( const ScalarT & a, const AffineSpaceT<L>& b ) { return AffineSpaceT<L>(a*b.l,a*b.p); }
|
|
template<typename L> __forceinline const AffineSpaceT<L> operator *( const AffineSpaceT<L>& a, const AffineSpaceT<L>& b ) { return AffineSpaceT<L>(a.l*b.l,a.l*b.p+a.p); }
|
|
template<typename L> __forceinline const AffineSpaceT<L> operator /( const AffineSpaceT<L>& a, const AffineSpaceT<L>& b ) { return a * rcp(b); }
|
|
template<typename L> __forceinline const AffineSpaceT<L> operator /( const AffineSpaceT<L>& a, const ScalarT & b ) { return a * rcp(b); }
|
|
|
|
template<typename L> __forceinline AffineSpaceT<L>& operator *=( AffineSpaceT<L>& a, const AffineSpaceT<L>& b ) { return a = a * b; }
|
|
template<typename L> __forceinline AffineSpaceT<L>& operator *=( AffineSpaceT<L>& a, const ScalarT & b ) { return a = a * b; }
|
|
template<typename L> __forceinline AffineSpaceT<L>& operator /=( AffineSpaceT<L>& a, const AffineSpaceT<L>& b ) { return a = a / b; }
|
|
template<typename L> __forceinline AffineSpaceT<L>& operator /=( AffineSpaceT<L>& a, const ScalarT & b ) { return a = a / b; }
|
|
|
|
template<typename L> __forceinline VectorT xfmPoint (const AffineSpaceT<L>& m, const VectorT& p) { return madd(VectorT(p.x),m.l.vx,madd(VectorT(p.y),m.l.vy,madd(VectorT(p.z),m.l.vz,m.p))); }
|
|
template<typename L> __forceinline VectorT xfmVector(const AffineSpaceT<L>& m, const VectorT& v) { return xfmVector(m.l,v); }
|
|
template<typename L> __forceinline VectorT xfmNormal(const AffineSpaceT<L>& m, const VectorT& n) { return xfmNormal(m.l,n); }
|
|
|
|
__forceinline const BBox<Vec3fa> xfmBounds(const AffineSpaceT<LinearSpace3<Vec3fa> >& m, const BBox<Vec3fa>& b)
|
|
{
|
|
BBox3fa dst = empty;
|
|
const Vec3fa p0(b.lower.x,b.lower.y,b.lower.z); dst.extend(xfmPoint(m,p0));
|
|
const Vec3fa p1(b.lower.x,b.lower.y,b.upper.z); dst.extend(xfmPoint(m,p1));
|
|
const Vec3fa p2(b.lower.x,b.upper.y,b.lower.z); dst.extend(xfmPoint(m,p2));
|
|
const Vec3fa p3(b.lower.x,b.upper.y,b.upper.z); dst.extend(xfmPoint(m,p3));
|
|
const Vec3fa p4(b.upper.x,b.lower.y,b.lower.z); dst.extend(xfmPoint(m,p4));
|
|
const Vec3fa p5(b.upper.x,b.lower.y,b.upper.z); dst.extend(xfmPoint(m,p5));
|
|
const Vec3fa p6(b.upper.x,b.upper.y,b.lower.z); dst.extend(xfmPoint(m,p6));
|
|
const Vec3fa p7(b.upper.x,b.upper.y,b.upper.z); dst.extend(xfmPoint(m,p7));
|
|
return dst;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// Comparison Operators
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename L> __forceinline bool operator ==( const AffineSpaceT<L>& a, const AffineSpaceT<L>& b ) { return a.l == b.l && a.p == b.p; }
|
|
template<typename L> __forceinline bool operator !=( const AffineSpaceT<L>& a, const AffineSpaceT<L>& b ) { return a.l != b.l || a.p != b.p; }
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// Select
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename L> __forceinline AffineSpaceT<L> select ( const typename L::Vector::Scalar::Bool& s, const AffineSpaceT<L>& t, const AffineSpaceT<L>& f ) {
|
|
return AffineSpaceT<L>(select(s,t.l,f.l),select(s,t.p,f.p));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Output Operators
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<typename L> static embree_ostream operator<<(embree_ostream cout, const AffineSpaceT<L>& m) {
|
|
return cout << "{ l = " << m.l << ", p = " << m.p << " }";
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Template Instantiations
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef AffineSpaceT<LinearSpace2f> AffineSpace2f;
|
|
typedef AffineSpaceT<LinearSpace3f> AffineSpace3f;
|
|
typedef AffineSpaceT<LinearSpace3fa> AffineSpace3fa;
|
|
typedef AffineSpaceT<LinearSpace3fx> AffineSpace3fx;
|
|
typedef AffineSpaceT<LinearSpace3ff> AffineSpace3ff;
|
|
typedef AffineSpaceT<Quaternion3f > OrthonormalSpace3f;
|
|
|
|
template<int N> using AffineSpace3vf = AffineSpaceT<LinearSpace3<Vec3<vfloat<N>>>>;
|
|
typedef AffineSpaceT<LinearSpace3<Vec3<vfloat<4>>>> AffineSpace3vf4;
|
|
typedef AffineSpaceT<LinearSpace3<Vec3<vfloat<8>>>> AffineSpace3vf8;
|
|
typedef AffineSpaceT<LinearSpace3<Vec3<vfloat<16>>>> AffineSpace3vf16;
|
|
|
|
template<int N> using AffineSpace3vff = AffineSpaceT<LinearSpace3<Vec4<vfloat<N>>>>;
|
|
typedef AffineSpaceT<LinearSpace3<Vec4<vfloat<4>>>> AffineSpace3vfa4;
|
|
typedef AffineSpaceT<LinearSpace3<Vec4<vfloat<8>>>> AffineSpace3vfa8;
|
|
typedef AffineSpaceT<LinearSpace3<Vec4<vfloat<16>>>> AffineSpace3vfa16;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
/// Interpolation
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
template<typename T, typename R>
|
|
__forceinline AffineSpaceT<T> lerp(const AffineSpaceT<T>& M0,
|
|
const AffineSpaceT<T>& M1,
|
|
const R& t)
|
|
{
|
|
return AffineSpaceT<T>(lerp(M0.l,M1.l,t),lerp(M0.p,M1.p,t));
|
|
}
|
|
|
|
// slerp interprets the 16 floats of the matrix M = D * R * S as components of
|
|
// three matrizes (D, R, S) that are interpolated individually.
|
|
template<typename T> __forceinline AffineSpaceT<LinearSpace3<Vec3<T>>>
|
|
slerp(const AffineSpaceT<LinearSpace3<Vec4<T>>>& M0,
|
|
const AffineSpaceT<LinearSpace3<Vec4<T>>>& M1,
|
|
const T& t)
|
|
{
|
|
QuaternionT<T> q0(M0.p.w, M0.l.vx.w, M0.l.vy.w, M0.l.vz.w);
|
|
QuaternionT<T> q1(M1.p.w, M1.l.vx.w, M1.l.vy.w, M1.l.vz.w);
|
|
QuaternionT<T> q = slerp(q0, q1, t);
|
|
|
|
AffineSpaceT<LinearSpace3<Vec3<T>>> S = lerp(M0, M1, t);
|
|
AffineSpaceT<LinearSpace3<Vec3<T>>> D(one);
|
|
D.p.x = S.l.vx.y;
|
|
D.p.y = S.l.vx.z;
|
|
D.p.z = S.l.vy.z;
|
|
S.l.vx.y = 0;
|
|
S.l.vx.z = 0;
|
|
S.l.vy.z = 0;
|
|
|
|
AffineSpaceT<LinearSpace3<Vec3<T>>> R = LinearSpace3<Vec3<T>>(q);
|
|
return D * R * S;
|
|
}
|
|
|
|
// this is a specialized version for Vec3fa because that does
|
|
// not play along nicely with the other templated Vec3/Vec4 types
|
|
__forceinline AffineSpace3fa slerp(const AffineSpace3ff& M0,
|
|
const AffineSpace3ff& M1,
|
|
const float& t)
|
|
{
|
|
Quaternion3f q0(M0.p.w, M0.l.vx.w, M0.l.vy.w, M0.l.vz.w);
|
|
Quaternion3f q1(M1.p.w, M1.l.vx.w, M1.l.vy.w, M1.l.vz.w);
|
|
Quaternion3f q = slerp(q0, q1, t);
|
|
|
|
AffineSpace3fa S = lerp(M0, M1, t);
|
|
AffineSpace3fa D(one);
|
|
D.p.x = S.l.vx.y;
|
|
D.p.y = S.l.vx.z;
|
|
D.p.z = S.l.vy.z;
|
|
S.l.vx.y = 0;
|
|
S.l.vx.z = 0;
|
|
S.l.vy.z = 0;
|
|
|
|
AffineSpace3fa R = LinearSpace3fa(q);
|
|
return D * R * S;
|
|
}
|
|
|
|
__forceinline AffineSpace3fa quaternionDecompositionToAffineSpace(const AffineSpace3ff& qd)
|
|
{
|
|
// compute affine transform from quaternion decomposition
|
|
Quaternion3f q(qd.p.w, qd.l.vx.w, qd.l.vy.w, qd.l.vz.w);
|
|
AffineSpace3fa M = qd;
|
|
AffineSpace3fa D(one);
|
|
D.p.x = M.l.vx.y;
|
|
D.p.y = M.l.vx.z;
|
|
D.p.z = M.l.vy.z;
|
|
M.l.vx.y = 0;
|
|
M.l.vx.z = 0;
|
|
M.l.vy.z = 0;
|
|
AffineSpace3fa R = LinearSpace3fa(q);
|
|
return D * R * M;
|
|
}
|
|
|
|
__forceinline void quaternionDecomposition(const AffineSpace3ff& qd, Vec3fa& T, Quaternion3f& q, AffineSpace3fa& S)
|
|
{
|
|
q = Quaternion3f(qd.p.w, qd.l.vx.w, qd.l.vy.w, qd.l.vz.w);
|
|
S = qd;
|
|
T.x = qd.l.vx.y;
|
|
T.y = qd.l.vx.z;
|
|
T.z = qd.l.vy.z;
|
|
S.l.vx.y = 0;
|
|
S.l.vx.z = 0;
|
|
S.l.vy.z = 0;
|
|
}
|
|
|
|
__forceinline AffineSpace3fx quaternionDecomposition(Vec3fa const& T, Quaternion3f const& q, AffineSpace3fa const& S)
|
|
{
|
|
AffineSpace3ff M = S;
|
|
M.l.vx.w = q.i;
|
|
M.l.vy.w = q.j;
|
|
M.l.vz.w = q.k;
|
|
M.p.w = q.r;
|
|
M.l.vx.y = T.x;
|
|
M.l.vx.z = T.y;
|
|
M.l.vy.z = T.z;
|
|
return M;
|
|
}
|
|
|
|
struct __aligned(16) QuaternionDecomposition
|
|
{
|
|
float scale_x = 1.f;
|
|
float scale_y = 1.f;
|
|
float scale_z = 1.f;
|
|
float skew_xy = 0.f;
|
|
float skew_xz = 0.f;
|
|
float skew_yz = 0.f;
|
|
float shift_x = 0.f;
|
|
float shift_y = 0.f;
|
|
float shift_z = 0.f;
|
|
float quaternion_r = 1.f;
|
|
float quaternion_i = 0.f;
|
|
float quaternion_j = 0.f;
|
|
float quaternion_k = 0.f;
|
|
float translation_x = 0.f;
|
|
float translation_y = 0.f;
|
|
float translation_z = 0.f;
|
|
};
|
|
|
|
__forceinline QuaternionDecomposition quaternionDecomposition(AffineSpace3ff const& M)
|
|
{
|
|
QuaternionDecomposition qd;
|
|
qd.scale_x = M.l.vx.x;
|
|
qd.scale_y = M.l.vy.y;
|
|
qd.scale_z = M.l.vz.z;
|
|
qd.shift_x = M.p.x;
|
|
qd.shift_y = M.p.y;
|
|
qd.shift_z = M.p.z;
|
|
qd.translation_x = M.l.vx.y;
|
|
qd.translation_y = M.l.vx.z;
|
|
qd.translation_z = M.l.vy.z;
|
|
qd.skew_xy = M.l.vy.x;
|
|
qd.skew_xz = M.l.vz.x;
|
|
qd.skew_yz = M.l.vz.y;
|
|
qd.quaternion_r = M.p.w;
|
|
qd.quaternion_i = M.l.vx.w;
|
|
qd.quaternion_j = M.l.vy.w;
|
|
qd.quaternion_k = M.l.vz.w;
|
|
return qd;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/*
|
|
* ! Template Specialization for 2D: return matrix for rotation around point
|
|
* (rotation around arbitrarty vector is not meaningful in 2D)
|
|
*/
|
|
template<> __forceinline
|
|
AffineSpace2f AffineSpace2f::rotate(const Vec2f& p, const float& r) {
|
|
return translate(+p)*AffineSpace2f(LinearSpace2f::rotate(r))*translate(-p);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Similarity Transform
|
|
//
|
|
// checks, if M is a similarity transformation, i.e if there exists a factor D
|
|
// such that for all x,y: distance(Mx, My) = D * distance(x, y)
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
__forceinline bool similarityTransform(const AffineSpace3fa& M, float* D)
|
|
{
|
|
if (D) *D = 0.f;
|
|
if (abs(dot(M.l.vx, M.l.vy)) > 1e-5f) return false;
|
|
if (abs(dot(M.l.vx, M.l.vz)) > 1e-5f) return false;
|
|
if (abs(dot(M.l.vy, M.l.vz)) > 1e-5f) return false;
|
|
|
|
const float D_x = dot(M.l.vx, M.l.vx);
|
|
const float D_y = dot(M.l.vy, M.l.vy);
|
|
const float D_z = dot(M.l.vz, M.l.vz);
|
|
|
|
if (abs(D_x - D_y) > 1e-5f ||
|
|
abs(D_x - D_z) > 1e-5f ||
|
|
abs(D_y - D_z) > 1e-5f)
|
|
return false;
|
|
|
|
if (D) *D = sqrtf(D_x);
|
|
return true;
|
|
}
|
|
|
|
__forceinline void AffineSpace3fa_store_unaligned(const AffineSpace3fa &source, AffineSpace3fa* ptr)
|
|
{
|
|
Vec3fa::storeu(&ptr->l.vx, source.l.vx);
|
|
Vec3fa::storeu(&ptr->l.vy, source.l.vy);
|
|
Vec3fa::storeu(&ptr->l.vz, source.l.vz);
|
|
Vec3fa::storeu(&ptr->p, source.p);
|
|
}
|
|
|
|
__forceinline AffineSpace3fa AffineSpace3fa_load_unaligned(AffineSpace3fa* ptr)
|
|
{
|
|
AffineSpace3fa space;
|
|
space.l.vx = Vec3fa::loadu(&ptr->l.vx);
|
|
space.l.vy = Vec3fa::loadu(&ptr->l.vy);
|
|
space.l.vz = Vec3fa::loadu(&ptr->l.vz);
|
|
space.p = Vec3fa::loadu(&ptr->p);
|
|
return space;
|
|
}
|
|
|
|
#undef VectorT
|
|
#undef ScalarT
|
|
}
|