nuclear@0: /* nuclear@0: --------------------------------------------------------------------------- nuclear@0: Open Asset Import Library (assimp) nuclear@0: --------------------------------------------------------------------------- nuclear@0: nuclear@0: Copyright (c) 2006-2012, assimp team nuclear@0: nuclear@0: All rights reserved. nuclear@0: nuclear@0: Redistribution and use of this software in source and binary forms, nuclear@0: with or without modification, are permitted provided that the following nuclear@0: conditions are met: nuclear@0: nuclear@0: * Redistributions of source code must retain the above nuclear@0: copyright notice, this list of conditions and the nuclear@0: following disclaimer. nuclear@0: nuclear@0: * Redistributions in binary form must reproduce the above nuclear@0: copyright notice, this list of conditions and the nuclear@0: following disclaimer in the documentation and/or other nuclear@0: materials provided with the distribution. nuclear@0: nuclear@0: * Neither the name of the assimp team, nor the names of its nuclear@0: contributors may be used to endorse or promote products nuclear@0: derived from this software without specific prior nuclear@0: written permission of the assimp team. nuclear@0: nuclear@0: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS nuclear@0: "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT nuclear@0: LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR nuclear@0: A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT nuclear@0: OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, nuclear@0: SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT nuclear@0: LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, nuclear@0: DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY nuclear@0: THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT nuclear@0: (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE nuclear@0: OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. nuclear@0: --------------------------------------------------------------------------- nuclear@0: */ nuclear@0: nuclear@0: /** @file aiMatrix4x4t.inl nuclear@0: * @brief Inline implementation of the 4x4 matrix operators nuclear@0: */ nuclear@0: #ifndef AI_MATRIX4x4_INL_INC nuclear@0: #define AI_MATRIX4x4_INL_INC nuclear@0: nuclear@0: #ifdef __cplusplus nuclear@0: nuclear@0: #include "matrix4x4.h" nuclear@0: #include "matrix3x3.h" nuclear@0: #include "quaternion.h" nuclear@0: nuclear@0: #include nuclear@0: #include nuclear@0: #include nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: aiMatrix4x4t ::aiMatrix4x4t () : nuclear@0: a1(1.0f), a2(), a3(), a4(), nuclear@0: b1(), b2(1.0f), b3(), b4(), nuclear@0: c1(), c2(), c3(1.0f), c4(), nuclear@0: d1(), d2(), d3(), d4(1.0f) nuclear@0: { nuclear@0: nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: aiMatrix4x4t ::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4, nuclear@0: TReal _b1, TReal _b2, TReal _b3, TReal _b4, nuclear@0: TReal _c1, TReal _c2, TReal _c3, TReal _c4, nuclear@0: TReal _d1, TReal _d2, TReal _d3, TReal _d4) : nuclear@0: a1(_a1), a2(_a2), a3(_a3), a4(_a4), nuclear@0: b1(_b1), b2(_b2), b3(_b3), b4(_b4), nuclear@0: c1(_c1), c2(_c2), c3(_c3), c4(_c4), nuclear@0: d1(_d1), d2(_d2), d3(_d3), d4(_d4) nuclear@0: { nuclear@0: nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: template nuclear@0: aiMatrix4x4t::operator aiMatrix4x4t () const nuclear@0: { nuclear@0: return aiMatrix4x4t(static_cast(a1),static_cast(a2),static_cast(a3),static_cast(a4), nuclear@0: static_cast(b1),static_cast(b2),static_cast(b3),static_cast(b4), nuclear@0: static_cast(c1),static_cast(c2),static_cast(c3),static_cast(c4), nuclear@0: static_cast(d1),static_cast(d2),static_cast(d3),static_cast(d4)); nuclear@0: } nuclear@0: nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t::aiMatrix4x4t (const aiMatrix3x3t& m) nuclear@0: { nuclear@0: a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast(0.0); nuclear@0: b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast(0.0); nuclear@0: c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast(0.0); nuclear@0: d1 = static_cast(0.0); d2 = static_cast(0.0); d3 = static_cast(0.0); d4 = static_cast(1.0); nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::operator *= (const aiMatrix4x4t& m) nuclear@0: { nuclear@0: *this = aiMatrix4x4t( nuclear@0: m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4, nuclear@0: m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4, nuclear@0: m.a3 * a1 + m.b3 * a2 + m.c3 * a3 + m.d3 * a4, nuclear@0: m.a4 * a1 + m.b4 * a2 + m.c4 * a3 + m.d4 * a4, nuclear@0: m.a1 * b1 + m.b1 * b2 + m.c1 * b3 + m.d1 * b4, nuclear@0: m.a2 * b1 + m.b2 * b2 + m.c2 * b3 + m.d2 * b4, nuclear@0: m.a3 * b1 + m.b3 * b2 + m.c3 * b3 + m.d3 * b4, nuclear@0: m.a4 * b1 + m.b4 * b2 + m.c4 * b3 + m.d4 * b4, nuclear@0: m.a1 * c1 + m.b1 * c2 + m.c1 * c3 + m.d1 * c4, nuclear@0: m.a2 * c1 + m.b2 * c2 + m.c2 * c3 + m.d2 * c4, nuclear@0: m.a3 * c1 + m.b3 * c2 + m.c3 * c3 + m.d3 * c4, nuclear@0: m.a4 * c1 + m.b4 * c2 + m.c4 * c3 + m.d4 * c4, nuclear@0: m.a1 * d1 + m.b1 * d2 + m.c1 * d3 + m.d1 * d4, nuclear@0: m.a2 * d1 + m.b2 * d2 + m.c2 * d3 + m.d2 * d4, nuclear@0: m.a3 * d1 + m.b3 * d2 + m.c3 * d3 + m.d3 * d4, nuclear@0: m.a4 * d1 + m.b4 * d2 + m.c4 * d3 + m.d4 * d4); nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t aiMatrix4x4t::operator* (const aiMatrix4x4t& m) const nuclear@0: { nuclear@0: aiMatrix4x4t temp( *this); nuclear@0: temp *= m; nuclear@0: return temp; nuclear@0: } nuclear@0: nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::Transpose() nuclear@0: { nuclear@0: // (TReal&) don't remove, GCC complains cause of packed fields nuclear@0: std::swap( (TReal&)b1, (TReal&)a2); nuclear@0: std::swap( (TReal&)c1, (TReal&)a3); nuclear@0: std::swap( (TReal&)c2, (TReal&)b3); nuclear@0: std::swap( (TReal&)d1, (TReal&)a4); nuclear@0: std::swap( (TReal&)d2, (TReal&)b4); nuclear@0: std::swap( (TReal&)d3, (TReal&)c4); nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline TReal aiMatrix4x4t::Determinant() const nuclear@0: { nuclear@0: return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4 nuclear@0: + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4 nuclear@0: - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3 nuclear@0: + a3*b4*c1*d2 - a3*b4*c2*d1 + a3*b1*c2*d4 - a3*b1*c4*d2 nuclear@0: + a3*b2*c4*d1 - a3*b2*c1*d4 - a4*b1*c2*d3 + a4*b1*c3*d2 nuclear@0: - a4*b2*c3*d1 + a4*b2*c1*d3 - a4*b3*c1*d2 + a4*b3*c2*d1; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::Inverse() nuclear@0: { nuclear@0: // Compute the reciprocal determinant nuclear@0: const TReal det = Determinant(); nuclear@0: if(det == static_cast(0.0)) nuclear@0: { nuclear@0: // Matrix not invertible. Setting all elements to nan is not really nuclear@0: // correct in a mathematical sense but it is easy to debug for the nuclear@0: // programmer. nuclear@0: const TReal nan = std::numeric_limits::quiet_NaN(); nuclear@0: *this = aiMatrix4x4t( nuclear@0: nan,nan,nan,nan, nuclear@0: nan,nan,nan,nan, nuclear@0: nan,nan,nan,nan, nuclear@0: nan,nan,nan,nan); nuclear@0: nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: const TReal invdet = static_cast(1.0) / det; nuclear@0: nuclear@0: aiMatrix4x4t res; nuclear@0: res.a1 = invdet * (b2 * (c3 * d4 - c4 * d3) + b3 * (c4 * d2 - c2 * d4) + b4 * (c2 * d3 - c3 * d2)); nuclear@0: res.a2 = -invdet * (a2 * (c3 * d4 - c4 * d3) + a3 * (c4 * d2 - c2 * d4) + a4 * (c2 * d3 - c3 * d2)); nuclear@0: res.a3 = invdet * (a2 * (b3 * d4 - b4 * d3) + a3 * (b4 * d2 - b2 * d4) + a4 * (b2 * d3 - b3 * d2)); nuclear@0: res.a4 = -invdet * (a2 * (b3 * c4 - b4 * c3) + a3 * (b4 * c2 - b2 * c4) + a4 * (b2 * c3 - b3 * c2)); nuclear@0: res.b1 = -invdet * (b1 * (c3 * d4 - c4 * d3) + b3 * (c4 * d1 - c1 * d4) + b4 * (c1 * d3 - c3 * d1)); nuclear@0: res.b2 = invdet * (a1 * (c3 * d4 - c4 * d3) + a3 * (c4 * d1 - c1 * d4) + a4 * (c1 * d3 - c3 * d1)); nuclear@0: res.b3 = -invdet * (a1 * (b3 * d4 - b4 * d3) + a3 * (b4 * d1 - b1 * d4) + a4 * (b1 * d3 - b3 * d1)); nuclear@0: res.b4 = invdet * (a1 * (b3 * c4 - b4 * c3) + a3 * (b4 * c1 - b1 * c4) + a4 * (b1 * c3 - b3 * c1)); nuclear@0: res.c1 = invdet * (b1 * (c2 * d4 - c4 * d2) + b2 * (c4 * d1 - c1 * d4) + b4 * (c1 * d2 - c2 * d1)); nuclear@0: res.c2 = -invdet * (a1 * (c2 * d4 - c4 * d2) + a2 * (c4 * d1 - c1 * d4) + a4 * (c1 * d2 - c2 * d1)); nuclear@0: res.c3 = invdet * (a1 * (b2 * d4 - b4 * d2) + a2 * (b4 * d1 - b1 * d4) + a4 * (b1 * d2 - b2 * d1)); nuclear@0: res.c4 = -invdet * (a1 * (b2 * c4 - b4 * c2) + a2 * (b4 * c1 - b1 * c4) + a4 * (b1 * c2 - b2 * c1)); nuclear@0: res.d1 = -invdet * (b1 * (c2 * d3 - c3 * d2) + b2 * (c3 * d1 - c1 * d3) + b3 * (c1 * d2 - c2 * d1)); nuclear@0: res.d2 = invdet * (a1 * (c2 * d3 - c3 * d2) + a2 * (c3 * d1 - c1 * d3) + a3 * (c1 * d2 - c2 * d1)); nuclear@0: res.d3 = -invdet * (a1 * (b2 * d3 - b3 * d2) + a2 * (b3 * d1 - b1 * d3) + a3 * (b1 * d2 - b2 * d1)); nuclear@0: res.d4 = invdet * (a1 * (b2 * c3 - b3 * c2) + a2 * (b3 * c1 - b1 * c3) + a3 * (b1 * c2 - b2 * c1)); nuclear@0: *this = res; nuclear@0: nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline TReal* aiMatrix4x4t::operator[](unsigned int p_iIndex) nuclear@0: { nuclear@0: // XXX this is UB. Has been for years. The fact that it works now does not make it better. nuclear@0: return &this->a1 + p_iIndex * 4; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline const TReal* aiMatrix4x4t::operator[](unsigned int p_iIndex) const nuclear@0: { nuclear@0: // XXX same nuclear@0: return &this->a1 + p_iIndex * 4; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline bool aiMatrix4x4t::operator== (const aiMatrix4x4t m) const nuclear@0: { nuclear@0: return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 && nuclear@0: b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 && nuclear@0: c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 && nuclear@0: d1 == m.d1 && d2 == m.d2 && d3 == m.d3 && d4 == m.d4); nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline bool aiMatrix4x4t::operator!= (const aiMatrix4x4t m) const nuclear@0: { nuclear@0: return !(*this == m); nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline void aiMatrix4x4t::Decompose (aiVector3t& scaling, aiQuaterniont& rotation, nuclear@0: aiVector3t& position) const nuclear@0: { nuclear@0: const aiMatrix4x4t& _this = *this; nuclear@0: nuclear@0: // extract translation nuclear@0: position.x = _this[0][3]; nuclear@0: position.y = _this[1][3]; nuclear@0: position.z = _this[2][3]; nuclear@0: nuclear@0: // extract the rows of the matrix nuclear@0: aiVector3t vRows[3] = { nuclear@0: aiVector3t(_this[0][0],_this[1][0],_this[2][0]), nuclear@0: aiVector3t(_this[0][1],_this[1][1],_this[2][1]), nuclear@0: aiVector3t(_this[0][2],_this[1][2],_this[2][2]) nuclear@0: }; nuclear@0: nuclear@0: // extract the scaling factors nuclear@0: scaling.x = vRows[0].Length(); nuclear@0: scaling.y = vRows[1].Length(); nuclear@0: scaling.z = vRows[2].Length(); nuclear@0: nuclear@0: // and the sign of the scaling nuclear@0: if (Determinant() < 0) { nuclear@0: scaling.x = -scaling.x; nuclear@0: scaling.y = -scaling.y; nuclear@0: scaling.z = -scaling.z; nuclear@0: } nuclear@0: nuclear@0: // and remove all scaling from the matrix nuclear@0: if(scaling.x) nuclear@0: { nuclear@0: vRows[0] /= scaling.x; nuclear@0: } nuclear@0: if(scaling.y) nuclear@0: { nuclear@0: vRows[1] /= scaling.y; nuclear@0: } nuclear@0: if(scaling.z) nuclear@0: { nuclear@0: vRows[2] /= scaling.z; nuclear@0: } nuclear@0: nuclear@0: // build a 3x3 rotation matrix nuclear@0: aiMatrix3x3t m(vRows[0].x,vRows[1].x,vRows[2].x, nuclear@0: vRows[0].y,vRows[1].y,vRows[2].y, nuclear@0: vRows[0].z,vRows[1].z,vRows[2].z); nuclear@0: nuclear@0: // and generate the rotation quaternion from it nuclear@0: rotation = aiQuaterniont(m); nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline void aiMatrix4x4t::DecomposeNoScaling (aiQuaterniont& rotation, nuclear@0: aiVector3t& position) const nuclear@0: { nuclear@0: const aiMatrix4x4t& _this = *this; nuclear@0: nuclear@0: // extract translation nuclear@0: position.x = _this[0][3]; nuclear@0: position.y = _this[1][3]; nuclear@0: position.z = _this[2][3]; nuclear@0: nuclear@0: // extract rotation nuclear@0: rotation = aiQuaterniont((aiMatrix3x3t)_this); nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::FromEulerAnglesXYZ(const aiVector3t& blubb) nuclear@0: { nuclear@0: return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z); nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::FromEulerAnglesXYZ(TReal x, TReal y, TReal z) nuclear@0: { nuclear@0: aiMatrix4x4t& _this = *this; nuclear@0: nuclear@0: TReal cr = cos( x ); nuclear@0: TReal sr = sin( x ); nuclear@0: TReal cp = cos( y ); nuclear@0: TReal sp = sin( y ); nuclear@0: TReal cy = cos( z ); nuclear@0: TReal sy = sin( z ); nuclear@0: nuclear@0: _this.a1 = cp*cy ; nuclear@0: _this.a2 = cp*sy; nuclear@0: _this.a3 = -sp ; nuclear@0: nuclear@0: TReal srsp = sr*sp; nuclear@0: TReal crsp = cr*sp; nuclear@0: nuclear@0: _this.b1 = srsp*cy-cr*sy ; nuclear@0: _this.b2 = srsp*sy+cr*cy ; nuclear@0: _this.b3 = sr*cp ; nuclear@0: nuclear@0: _this.c1 = crsp*cy+sr*sy ; nuclear@0: _this.c2 = crsp*sy-sr*cy ; nuclear@0: _this.c3 = cr*cp ; nuclear@0: nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline bool aiMatrix4x4t::IsIdentity() const nuclear@0: { nuclear@0: // Use a small epsilon to solve floating-point inaccuracies nuclear@0: const static TReal epsilon = 10e-3f; nuclear@0: nuclear@0: return (a2 <= epsilon && a2 >= -epsilon && nuclear@0: a3 <= epsilon && a3 >= -epsilon && nuclear@0: a4 <= epsilon && a4 >= -epsilon && nuclear@0: b1 <= epsilon && b1 >= -epsilon && nuclear@0: b3 <= epsilon && b3 >= -epsilon && nuclear@0: b4 <= epsilon && b4 >= -epsilon && nuclear@0: c1 <= epsilon && c1 >= -epsilon && nuclear@0: c2 <= epsilon && c2 >= -epsilon && nuclear@0: c4 <= epsilon && c4 >= -epsilon && nuclear@0: d1 <= epsilon && d1 >= -epsilon && nuclear@0: d2 <= epsilon && d2 >= -epsilon && nuclear@0: d3 <= epsilon && d3 >= -epsilon && nuclear@0: a1 <= 1.f+epsilon && a1 >= 1.f-epsilon && nuclear@0: b2 <= 1.f+epsilon && b2 >= 1.f-epsilon && nuclear@0: c3 <= 1.f+epsilon && c3 >= 1.f-epsilon && nuclear@0: d4 <= 1.f+epsilon && d4 >= 1.f-epsilon); nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::RotationX(TReal a, aiMatrix4x4t& out) nuclear@0: { nuclear@0: /* nuclear@0: | 1 0 0 0 | nuclear@0: M = | 0 cos(A) -sin(A) 0 | nuclear@0: | 0 sin(A) cos(A) 0 | nuclear@0: | 0 0 0 1 | */ nuclear@0: out = aiMatrix4x4t(); nuclear@0: out.b2 = out.c3 = cos(a); nuclear@0: out.b3 = -(out.c2 = sin(a)); nuclear@0: return out; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::RotationY(TReal a, aiMatrix4x4t& out) nuclear@0: { nuclear@0: /* nuclear@0: | cos(A) 0 sin(A) 0 | nuclear@0: M = | 0 1 0 0 | nuclear@0: | -sin(A) 0 cos(A) 0 | nuclear@0: | 0 0 0 1 | nuclear@0: */ nuclear@0: out = aiMatrix4x4t(); nuclear@0: out.a1 = out.c3 = cos(a); nuclear@0: out.c1 = -(out.a3 = sin(a)); nuclear@0: return out; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::RotationZ(TReal a, aiMatrix4x4t& out) nuclear@0: { nuclear@0: /* nuclear@0: | cos(A) -sin(A) 0 0 | nuclear@0: M = | sin(A) cos(A) 0 0 | nuclear@0: | 0 0 1 0 | nuclear@0: | 0 0 0 1 | */ nuclear@0: out = aiMatrix4x4t(); nuclear@0: out.a1 = out.b2 = cos(a); nuclear@0: out.a2 = -(out.b1 = sin(a)); nuclear@0: return out; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: // Returns a rotation matrix for a rotation around an arbitrary axis. nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::Rotation( TReal a, const aiVector3t& axis, aiMatrix4x4t& out) nuclear@0: { nuclear@0: TReal c = cos( a), s = sin( a), t = 1 - c; nuclear@0: TReal x = axis.x, y = axis.y, z = axis.z; nuclear@0: nuclear@0: // Many thanks to MathWorld and Wikipedia nuclear@0: out.a1 = t*x*x + c; out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y; nuclear@0: out.b1 = t*x*y + s*z; out.b2 = t*y*y + c; out.b3 = t*y*z - s*x; nuclear@0: out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c; nuclear@0: out.a4 = out.b4 = out.c4 = static_cast(0.0); nuclear@0: out.d1 = out.d2 = out.d3 = static_cast(0.0); nuclear@0: out.d4 = static_cast(1.0); nuclear@0: nuclear@0: return out; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::Translation( const aiVector3t& v, aiMatrix4x4t& out) nuclear@0: { nuclear@0: out = aiMatrix4x4t(); nuclear@0: out.a4 = v.x; nuclear@0: out.b4 = v.y; nuclear@0: out.c4 = v.z; nuclear@0: return out; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::Scaling( const aiVector3t& v, aiMatrix4x4t& out) nuclear@0: { nuclear@0: out = aiMatrix4x4t(); nuclear@0: out.a1 = v.x; nuclear@0: out.b2 = v.y; nuclear@0: out.c3 = v.z; nuclear@0: return out; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: /** A function for creating a rotation matrix that rotates a vector called nuclear@0: * "from" into another vector called "to". nuclear@0: * Input : from[3], to[3] which both must be *normalized* non-zero vectors nuclear@0: * Output: mtx[3][3] -- a 3x3 matrix in colum-major form nuclear@0: * Authors: Tomas Möller, John Hughes nuclear@0: * "Efficiently Building a Matrix to Rotate One Vector to Another" nuclear@0: * Journal of Graphics Tools, 4(4):1-4, 1999 nuclear@0: */ nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix4x4t& aiMatrix4x4t::FromToMatrix(const aiVector3t& from, nuclear@0: const aiVector3t& to, aiMatrix4x4t& mtx) nuclear@0: { nuclear@0: aiMatrix3x3t m3; nuclear@0: aiMatrix3x3t::FromToMatrix(from,to,m3); nuclear@0: mtx = aiMatrix4x4t(m3); nuclear@0: return mtx; nuclear@0: } nuclear@0: nuclear@0: #endif // __cplusplus nuclear@0: #endif // AI_MATRIX4x4_INL_INC