Revision control
++ // 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
++ }