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 aiMatrix3x3.inl nuclear@0: * @brief Inline implementation of the 3x3 matrix operators nuclear@0: */ nuclear@0: #ifndef AI_MATRIX3x3_INL_INC nuclear@0: #define AI_MATRIX3x3_INL_INC nuclear@0: nuclear@0: #ifdef __cplusplus nuclear@0: #include "matrix3x3.h" nuclear@0: nuclear@0: #include "matrix4x4.h" nuclear@0: #include nuclear@0: #include nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: // Construction from a 4x4 matrix. The remaining parts of the matrix are ignored. nuclear@0: template nuclear@0: inline aiMatrix3x3t::aiMatrix3x3t( const aiMatrix4x4t& pMatrix) nuclear@0: { nuclear@0: a1 = pMatrix.a1; a2 = pMatrix.a2; a3 = pMatrix.a3; nuclear@0: b1 = pMatrix.b1; b2 = pMatrix.b2; b3 = pMatrix.b3; nuclear@0: c1 = pMatrix.c1; c2 = pMatrix.c2; c3 = pMatrix.c3; nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline aiMatrix3x3t& aiMatrix3x3t::operator *= (const aiMatrix3x3t& m) nuclear@0: { nuclear@0: *this = aiMatrix3x3t(m.a1 * a1 + m.b1 * a2 + m.c1 * a3, nuclear@0: m.a2 * a1 + m.b2 * a2 + m.c2 * a3, nuclear@0: m.a3 * a1 + m.b3 * a2 + m.c3 * a3, nuclear@0: m.a1 * b1 + m.b1 * b2 + m.c1 * b3, nuclear@0: m.a2 * b1 + m.b2 * b2 + m.c2 * b3, nuclear@0: m.a3 * b1 + m.b3 * b2 + m.c3 * b3, nuclear@0: m.a1 * c1 + m.b1 * c2 + m.c1 * c3, nuclear@0: m.a2 * c1 + m.b2 * c2 + m.c2 * c3, nuclear@0: m.a3 * c1 + m.b3 * c2 + m.c3 * c3); nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: template nuclear@0: aiMatrix3x3t::operator aiMatrix3x3t () const nuclear@0: { nuclear@0: return aiMatrix3x3t(static_cast(a1),static_cast(a2),static_cast(a3), nuclear@0: static_cast(b1),static_cast(b2),static_cast(b3), nuclear@0: static_cast(c1),static_cast(c2),static_cast(c3)); nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline aiMatrix3x3t aiMatrix3x3t::operator* (const aiMatrix3x3t& m) const nuclear@0: { nuclear@0: aiMatrix3x3t temp( *this); nuclear@0: temp *= m; nuclear@0: return temp; nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline TReal* aiMatrix3x3t::operator[] (unsigned int p_iIndex) nuclear@0: { nuclear@0: return &this->a1 + p_iIndex * 3; nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline const TReal* aiMatrix3x3t::operator[] (unsigned int p_iIndex) const nuclear@0: { nuclear@0: return &this->a1 + p_iIndex * 3; nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline bool aiMatrix3x3t::operator== (const aiMatrix4x4t m) const nuclear@0: { nuclear@0: return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && nuclear@0: b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && nuclear@0: c1 == m.c1 && c2 == m.c2 && c3 == m.c3; nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline bool aiMatrix3x3t::operator!= (const aiMatrix4x4t m) const nuclear@0: { nuclear@0: return !(*this == m); nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline aiMatrix3x3t& aiMatrix3x3t::Transpose() nuclear@0: { nuclear@0: // (TReal&) don't remove, GCC complains cause of packed fields nuclear@0: std::swap( (TReal&)a2, (TReal&)b1); nuclear@0: std::swap( (TReal&)a3, (TReal&)c1); nuclear@0: std::swap( (TReal&)b3, (TReal&)c2); nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline TReal aiMatrix3x3t::Determinant() const nuclear@0: { nuclear@0: return a1*b2*c3 - a1*b3*c2 + a2*b3*c1 - a2*b1*c3 + a3*b1*c2 - a3*b2*c1; nuclear@0: } nuclear@0: nuclear@0: // ---------------------------------------------------------------------------------------- nuclear@0: template nuclear@0: inline aiMatrix3x3t& aiMatrix3x3t::Inverse() nuclear@0: { nuclear@0: // Compute the reciprocal determinant nuclear@0: 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 at least qnans are easy to nuclear@0: // spot. XXX we might throw an exception instead, which would nuclear@0: // be even much better to spot :/. nuclear@0: const TReal nan = std::numeric_limits::quiet_NaN(); nuclear@0: *this = aiMatrix3x3t( nan,nan,nan,nan,nan,nan,nan,nan,nan); nuclear@0: nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: TReal invdet = static_cast(1.0) / det; nuclear@0: nuclear@0: aiMatrix3x3t res; nuclear@0: res.a1 = invdet * (b2 * c3 - b3 * c2); nuclear@0: res.a2 = -invdet * (a2 * c3 - a3 * c2); nuclear@0: res.a3 = invdet * (a2 * b3 - a3 * b2); nuclear@0: res.b1 = -invdet * (b1 * c3 - b3 * c1); nuclear@0: res.b2 = invdet * (a1 * c3 - a3 * c1); nuclear@0: res.b3 = -invdet * (a1 * b3 - a3 * b1); nuclear@0: res.c1 = invdet * (b1 * c2 - b2 * c1); nuclear@0: res.c2 = -invdet * (a1 * c2 - a2 * c1); nuclear@0: res.c3 = invdet * (a1 * b2 - a2 * b1); nuclear@0: *this = res; nuclear@0: nuclear@0: return *this; nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline aiMatrix3x3t& aiMatrix3x3t::RotationZ(TReal a, aiMatrix3x3t& out) nuclear@0: { nuclear@0: out.a1 = out.b2 = ::cos(a); nuclear@0: out.b1 = ::sin(a); nuclear@0: out.a2 = - out.b1; nuclear@0: nuclear@0: out.a3 = out.b3 = out.c1 = out.c2 = 0.f; nuclear@0: out.c3 = 1.f; nuclear@0: 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 aiMatrix3x3t& aiMatrix3x3t::Rotation( TReal a, const aiVector3t& axis, aiMatrix3x3t& 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: nuclear@0: return out; nuclear@0: } nuclear@0: nuclear@0: // ------------------------------------------------------------------------------------------------ nuclear@0: template nuclear@0: inline aiMatrix3x3t& aiMatrix3x3t::Translation( const aiVector2t& v, aiMatrix3x3t& out) nuclear@0: { nuclear@0: out = aiMatrix3x3t(); nuclear@0: out.a3 = v.x; nuclear@0: out.b3 = v.y; 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 aiMatrix3x3t& aiMatrix3x3t::FromToMatrix(const aiVector3t& from, nuclear@0: const aiVector3t& to, aiMatrix3x3t& mtx) nuclear@0: { nuclear@0: const TReal e = from * to; nuclear@0: const TReal f = (e < 0)? -e:e; nuclear@0: nuclear@0: if (f > static_cast(1.0) - static_cast(0.00001)) /* "from" and "to"-vector almost parallel */ nuclear@0: { nuclear@0: aiVector3D u,v; /* temporary storage vectors */ nuclear@0: aiVector3D x; /* vector most nearly orthogonal to "from" */ nuclear@0: nuclear@0: x.x = (from.x > 0.0)? from.x : -from.x; nuclear@0: x.y = (from.y > 0.0)? from.y : -from.y; nuclear@0: x.z = (from.z > 0.0)? from.z : -from.z; nuclear@0: nuclear@0: if (x.x < x.y) nuclear@0: { nuclear@0: if (x.x < x.z) nuclear@0: { nuclear@0: x.x = static_cast(1.0); x.y = x.z = static_cast(0.0); nuclear@0: } nuclear@0: else nuclear@0: { nuclear@0: x.z = static_cast(1.0); x.y = x.z = static_cast(0.0); nuclear@0: } nuclear@0: } nuclear@0: else nuclear@0: { nuclear@0: if (x.y < x.z) nuclear@0: { nuclear@0: x.y = static_cast(1.0); x.x = x.z = static_cast(0.0); nuclear@0: } nuclear@0: else nuclear@0: { nuclear@0: x.z = static_cast(1.0); x.x = x.y = static_cast(0.0); nuclear@0: } nuclear@0: } nuclear@0: nuclear@0: u.x = x.x - from.x; u.y = x.y - from.y; u.z = x.z - from.z; nuclear@0: v.x = x.x - to.x; v.y = x.y - to.y; v.z = x.z - to.z; nuclear@0: nuclear@0: const TReal c1 = static_cast(2.0) / (u * u); nuclear@0: const TReal c2 = static_cast(2.0) / (v * v); nuclear@0: const TReal c3 = c1 * c2 * (u * v); nuclear@0: nuclear@0: for (unsigned int i = 0; i < 3; i++) nuclear@0: { nuclear@0: for (unsigned int j = 0; j < 3; j++) nuclear@0: { nuclear@0: mtx[i][j] = - c1 * u[i] * u[j] - c2 * v[i] * v[j] nuclear@0: + c3 * v[i] * u[j]; nuclear@0: } nuclear@0: mtx[i][i] += static_cast(1.0); nuclear@0: } nuclear@0: } nuclear@0: else /* the most common case, unless "from"="to", or "from"=-"to" */ nuclear@0: { nuclear@0: const aiVector3D v = from ^ to; nuclear@0: /* ... use this hand optimized version (9 mults less) */ nuclear@0: const TReal h = static_cast(1.0)/(static_cast(1.0) + e); /* optimization by Gottfried Chen */ nuclear@0: const TReal hvx = h * v.x; nuclear@0: const TReal hvz = h * v.z; nuclear@0: const TReal hvxy = hvx * v.y; nuclear@0: const TReal hvxz = hvx * v.z; nuclear@0: const TReal hvyz = hvz * v.y; nuclear@0: mtx[0][0] = e + hvx * v.x; nuclear@0: mtx[0][1] = hvxy - v.z; nuclear@0: mtx[0][2] = hvxz + v.y; nuclear@0: nuclear@0: mtx[1][0] = hvxy + v.z; nuclear@0: mtx[1][1] = e + h * v.y * v.y; nuclear@0: mtx[1][2] = hvyz - v.x; nuclear@0: nuclear@0: mtx[2][0] = hvxz - v.y; nuclear@0: mtx[2][1] = hvyz + v.x; nuclear@0: mtx[2][2] = e + hvz * v.z; nuclear@0: } nuclear@0: return mtx; nuclear@0: } nuclear@0: nuclear@0: nuclear@0: #endif // __cplusplus nuclear@0: #endif // AI_MATRIX3x3_INL_INC