// Copyright 2009-2020 Intel Corporation // SPDX-License-Identifier: Apache-2.0 #pragma once #include "vec3.h" #include "quaternion.h" namespace embree { //////////////////////////////////////////////////////////////////////////////// /// 3D Linear Transform (3x3 Matrix) //////////////////////////////////////////////////////////////////////////////// template struct LinearSpace3 { typedef T Vector; typedef typename T::Scalar Scalar; /*! default matrix constructor */ __forceinline LinearSpace3 ( ) {} __forceinline LinearSpace3 ( const LinearSpace3& other ) { vx = other.vx; vy = other.vy; vz = other.vz; } __forceinline LinearSpace3& operator=( const LinearSpace3& other ) { vx = other.vx; vy = other.vy; vz = other.vz; return *this; } template __forceinline LinearSpace3( const LinearSpace3& s ) : vx(s.vx), vy(s.vy), vz(s.vz) {} /*! matrix construction from column vectors */ __forceinline LinearSpace3(const Vector& vx, const Vector& vy, const Vector& vz) : vx(vx), vy(vy), vz(vz) {} /*! construction from quaternion */ __forceinline LinearSpace3( const QuaternionT& q ) : vx((q.r*q.r + q.i*q.i - q.j*q.j - q.k*q.k), 2.0f*(q.i*q.j + q.r*q.k), 2.0f*(q.i*q.k - q.r*q.j)) , vy(2.0f*(q.i*q.j - q.r*q.k), (q.r*q.r - q.i*q.i + q.j*q.j - q.k*q.k), 2.0f*(q.j*q.k + q.r*q.i)) , vz(2.0f*(q.i*q.k + q.r*q.j), 2.0f*(q.j*q.k - q.r*q.i), (q.r*q.r - q.i*q.i - q.j*q.j + q.k*q.k)) {} /*! matrix construction from row mayor data */ __forceinline LinearSpace3(const Scalar& m00, const Scalar& m01, const Scalar& m02, const Scalar& m10, const Scalar& m11, const Scalar& m12, const Scalar& m20, const Scalar& m21, const Scalar& m22) : vx(m00,m10,m20), vy(m01,m11,m21), vz(m02,m12,m22) {} /*! compute the determinant of the matrix */ __forceinline const Scalar det() const { return dot(vx,cross(vy,vz)); } /*! compute adjoint matrix */ __forceinline const LinearSpace3 adjoint() const { return LinearSpace3(cross(vy,vz),cross(vz,vx),cross(vx,vy)).transposed(); } /*! compute inverse matrix */ __forceinline const LinearSpace3 inverse() const { return adjoint()/det(); } /*! compute transposed matrix */ __forceinline const LinearSpace3 transposed() const { return LinearSpace3(vx.x,vx.y,vx.z,vy.x,vy.y,vy.z,vz.x,vz.y,vz.z); } /*! returns first row of matrix */ __forceinline Vector row0() const { return Vector(vx.x,vy.x,vz.x); } /*! returns second row of matrix */ __forceinline Vector row1() const { return Vector(vx.y,vy.y,vz.y); } /*! returns third row of matrix */ __forceinline Vector row2() const { return Vector(vx.z,vy.z,vz.z); } //////////////////////////////////////////////////////////////////////////////// /// Constants //////////////////////////////////////////////////////////////////////////////// __forceinline LinearSpace3( ZeroTy ) : vx(zero), vy(zero), vz(zero) {} __forceinline LinearSpace3( OneTy ) : vx(one, zero, zero), vy(zero, one, zero), vz(zero, zero, one) {} /*! return matrix for scaling */ static __forceinline LinearSpace3 scale(const Vector& s) { return LinearSpace3(s.x, 0, 0, 0 , s.y, 0, 0 , 0, s.z); } /*! return matrix for rotation around arbitrary axis */ static __forceinline LinearSpace3 rotate(const Vector& _u, const Scalar& r) { Vector u = normalize(_u); Scalar s = sin(r), c = cos(r); return LinearSpace3(u.x*u.x+(1-u.x*u.x)*c, u.x*u.y*(1-c)-u.z*s, u.x*u.z*(1-c)+u.y*s, u.x*u.y*(1-c)+u.z*s, u.y*u.y+(1-u.y*u.y)*c, u.y*u.z*(1-c)-u.x*s, u.x*u.z*(1-c)-u.y*s, u.y*u.z*(1-c)+u.x*s, u.z*u.z+(1-u.z*u.z)*c); } public: /*! the column vectors of the matrix */ Vector vx,vy,vz; }; /*! compute transposed matrix */ template<> __forceinline const LinearSpace3 LinearSpace3::transposed() const { vfloat4 rx,ry,rz; transpose((vfloat4&)vx,(vfloat4&)vy,(vfloat4&)vz,vfloat4(zero),rx,ry,rz); return LinearSpace3(Vec3fa(rx),Vec3fa(ry),Vec3fa(rz)); } template __forceinline const LinearSpace3 transposed(const LinearSpace3& xfm) { return xfm.transposed(); } //////////////////////////////////////////////////////////////////////////////// // Unary Operators //////////////////////////////////////////////////////////////////////////////// template __forceinline LinearSpace3 operator -( const LinearSpace3& a ) { return LinearSpace3(-a.vx,-a.vy,-a.vz); } template __forceinline LinearSpace3 operator +( const LinearSpace3& a ) { return LinearSpace3(+a.vx,+a.vy,+a.vz); } template __forceinline LinearSpace3 rcp ( const LinearSpace3& a ) { return a.inverse(); } /* constructs a coordinate frame form a normalized normal */ template __forceinline LinearSpace3 frame(const T& N) { const T dx0(0,N.z,-N.y); const T dx1(-N.z,0,N.x); const T dx = normalize(select(dot(dx0,dx0) > dot(dx1,dx1),dx0,dx1)); const T dy = normalize(cross(N,dx)); return LinearSpace3(dx,dy,N); } /* constructs a coordinate frame from a normal and approximate x-direction */ template __forceinline LinearSpace3 frame(const T& N, const T& dxi) { if (abs(dot(dxi,N)) > 0.99f) return frame(N); // fallback in case N and dxi are very parallel const T dx = normalize(cross(dxi,N)); const T dy = normalize(cross(N,dx)); return LinearSpace3(dx,dy,N); } /* clamps linear space to range -1 to +1 */ template __forceinline LinearSpace3 clamp(const LinearSpace3& space) { return LinearSpace3(clamp(space.vx,T(-1.0f),T(1.0f)), clamp(space.vy,T(-1.0f),T(1.0f)), clamp(space.vz,T(-1.0f),T(1.0f))); } //////////////////////////////////////////////////////////////////////////////// // Binary Operators //////////////////////////////////////////////////////////////////////////////// template __forceinline LinearSpace3 operator +( const LinearSpace3& a, const LinearSpace3& b ) { return LinearSpace3(a.vx+b.vx,a.vy+b.vy,a.vz+b.vz); } template __forceinline LinearSpace3 operator -( const LinearSpace3& a, const LinearSpace3& b ) { return LinearSpace3(a.vx-b.vx,a.vy-b.vy,a.vz-b.vz); } template __forceinline LinearSpace3 operator*(const typename T::Scalar & a, const LinearSpace3& b) { return LinearSpace3(a*b.vx, a*b.vy, a*b.vz); } template __forceinline T operator*(const LinearSpace3& a, const T & b) { return madd(T(b.x),a.vx,madd(T(b.y),a.vy,T(b.z)*a.vz)); } template __forceinline LinearSpace3 operator*(const LinearSpace3& a, const LinearSpace3& b) { return LinearSpace3(a*b.vx, a*b.vy, a*b.vz); } template __forceinline LinearSpace3 operator/(const LinearSpace3& a, const typename T::Scalar & b) { return LinearSpace3(a.vx/b, a.vy/b, a.vz/b); } template __forceinline LinearSpace3 operator/(const LinearSpace3& a, const LinearSpace3& b) { return a * rcp(b); } template __forceinline LinearSpace3& operator *=( LinearSpace3& a, const LinearSpace3& b ) { return a = a * b; } template __forceinline LinearSpace3& operator /=( LinearSpace3& a, const LinearSpace3& b ) { return a = a / b; } template __forceinline T xfmPoint (const LinearSpace3& s, const T & a) { return madd(T(a.x),s.vx,madd(T(a.y),s.vy,T(a.z)*s.vz)); } template __forceinline T xfmVector(const LinearSpace3& s, const T & a) { return madd(T(a.x),s.vx,madd(T(a.y),s.vy,T(a.z)*s.vz)); } template __forceinline T xfmNormal(const LinearSpace3& s, const T & a) { return xfmVector(s.inverse().transposed(),a); } //////////////////////////////////////////////////////////////////////////////// /// Comparison Operators //////////////////////////////////////////////////////////////////////////////// template __forceinline bool operator ==( const LinearSpace3& a, const LinearSpace3& b ) { return a.vx == b.vx && a.vy == b.vy && a.vz == b.vz; } template __forceinline bool operator !=( const LinearSpace3& a, const LinearSpace3& b ) { return a.vx != b.vx || a.vy != b.vy || a.vz != b.vz; } //////////////////////////////////////////////////////////////////////////////// /// Select //////////////////////////////////////////////////////////////////////////////// template __forceinline LinearSpace3 select ( const typename T::Scalar::Bool& s, const LinearSpace3& t, const LinearSpace3& f ) { return LinearSpace3(select(s,t.vx,f.vx),select(s,t.vy,f.vy),select(s,t.vz,f.vz)); } /*! blending */ template __forceinline LinearSpace3 lerp(const LinearSpace3& l0, const LinearSpace3& l1, const float t) { return LinearSpace3(lerp(l0.vx,l1.vx,t), lerp(l0.vy,l1.vy,t), lerp(l0.vz,l1.vz,t)); } //////////////////////////////////////////////////////////////////////////////// /// Output Operators //////////////////////////////////////////////////////////////////////////////// template static embree_ostream operator<<(embree_ostream cout, const LinearSpace3& m) { return cout << "{ vx = " << m.vx << ", vy = " << m.vy << ", vz = " << m.vz << "}"; } /*! Shortcuts for common linear spaces. */ typedef LinearSpace3 LinearSpace3f; typedef LinearSpace3 LinearSpace3fa; typedef LinearSpace3 LinearSpace3fx; typedef LinearSpace3 LinearSpace3ff; template using LinearSpace3vf = LinearSpace3>>; typedef LinearSpace3>> LinearSpace3vf4; typedef LinearSpace3>> LinearSpace3vf8; typedef LinearSpace3>> LinearSpace3vf16; /*! blending */ template __forceinline LinearSpace3 lerp(const LinearSpace3& l0, const LinearSpace3& l1, const S& t) { return LinearSpace3(lerp(l0.vx,l1.vx,t), lerp(l0.vy,l1.vy,t), lerp(l0.vz,l1.vz,t)); } }