From f6ae02c608438c5a90170938b2249c6c959e3b38 Mon Sep 17 00:00:00 2001 From: Ian Caven Date: Tue, 20 Mar 2012 11:04:30 -0700 Subject: [PATCH] Changes to compile with CUDA --- glm/core/type_half.hpp | 238 ++--- glm/core/type_mat3x3.inl | 1627 +++++++++++++++--------------- glm/gtc/half_float.inl | 2026 +++++++++++++++++++------------------- 3 files changed, 1954 insertions(+), 1937 deletions(-) diff --git a/glm/core/type_half.hpp b/glm/core/type_half.hpp index 1d933511..08bbf6d0 100644 --- a/glm/core/type_half.hpp +++ b/glm/core/type_half.hpp @@ -1,119 +1,119 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Mathematics (glm.g-truc.net) -/// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file glm/core/type_half.hpp -/// @date 2008-08-17 / 2011-09-20 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - -#ifndef glm_core_type_half -#define glm_core_type_half - -#include - -namespace glm{ -namespace detail -{ - typedef short hdata; - - float toFloat32(hdata value); - hdata toFloat16(float const & value); - - /// 16-bit floating point type. - /// @ingroup gtc_half_float - class half - { - public: - // Constructors - GLM_FUNC_DECL half(); - GLM_FUNC_DECL half(half const & s); - - template - GLM_FUNC_DECL explicit half(U const & s); - - // Cast - template - GLM_FUNC_DECL operator U() const; - - // Unary updatable operators - GLM_FUNC_DECL half& operator= (half const & s); - GLM_FUNC_DECL half& operator+=(half const & s); - GLM_FUNC_DECL half& operator-=(half const & s); - GLM_FUNC_DECL half& operator*=(half const & s); - GLM_FUNC_DECL half& operator/=(half const & s); - GLM_FUNC_DECL half& operator++(); - GLM_FUNC_DECL half& operator--(); - - GLM_FUNC_DECL float toFloat() const{return toFloat32(data);} - - GLM_FUNC_DECL hdata _data() const{return data;} - - private: - hdata data; - }; - - half operator+ (half const & s1, half const & s2); - - half operator- (half const & s1, half const & s2); - - half operator* (half const & s1, half const & s2); - - half operator/ (half const & s1, half const & s2); - - // Unary constant operators - half operator- (half const & s); - - half operator-- (half const & s, int); - - half operator++ (half const & s, int); - - bool operator==( - detail::half const & x, - detail::half const & y); - - bool operator!=( - detail::half const & x, - detail::half const & y); - - bool operator<( - detail::half const & x, - detail::half const & y); - - bool operator<=( - detail::half const & x, - detail::half const & y); - - bool operator>( - detail::half const & x, - detail::half const & y); - - bool operator>=( - detail::half const & x, - detail::half const & y); - -}//namespace detail -}//namespace glm - -#include "type_half.inl" - -#endif//glm_core_type_half +/////////////////////////////////////////////////////////////////////////////////// +/// OpenGL Mathematics (glm.g-truc.net) +/// +/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Permission is hereby granted, free of charge, to any person obtaining a copy +/// of this software and associated documentation files (the "Software"), to deal +/// in the Software without restriction, including without limitation the rights +/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +/// copies of the Software, and to permit persons to whom the Software is +/// furnished to do so, subject to the following conditions: +/// +/// The above copyright notice and this permission notice shall be included in +/// all copies or substantial portions of the Software. +/// +/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +/// THE SOFTWARE. +/// +/// @ref core +/// @file glm/core/type_half.hpp +/// @date 2008-08-17 / 2011-09-20 +/// @author Christophe Riccio +/////////////////////////////////////////////////////////////////////////////////// + +#ifndef glm_core_type_half +#define glm_core_type_half + +#include + +namespace glm{ +namespace detail +{ + typedef short hdata; + + GLM_FUNC_DECL float toFloat32(hdata value); + hdata toFloat16(float const & value); + + /// 16-bit floating point type. + /// @ingroup gtc_half_float + class half + { + public: + // Constructors + GLM_FUNC_DECL half(); + GLM_FUNC_DECL half(half const & s); + + template + GLM_FUNC_DECL explicit half(U const & s); + + // Cast + template + GLM_FUNC_DECL operator U() const; + + // Unary updatable operators + GLM_FUNC_DECL half& operator= (half const & s); + GLM_FUNC_DECL half& operator+=(half const & s); + GLM_FUNC_DECL half& operator-=(half const & s); + GLM_FUNC_DECL half& operator*=(half const & s); + GLM_FUNC_DECL half& operator/=(half const & s); + GLM_FUNC_DECL half& operator++(); + GLM_FUNC_DECL half& operator--(); + + GLM_FUNC_DECL float toFloat() const{return toFloat32(data);} + + GLM_FUNC_DECL hdata _data() const{return data;} + + private: + hdata data; + }; + + half operator+ (half const & s1, half const & s2); + + half operator- (half const & s1, half const & s2); + + half operator* (half const & s1, half const & s2); + + half operator/ (half const & s1, half const & s2); + + // Unary constant operators + half operator- (half const & s); + + half operator-- (half const & s, int); + + half operator++ (half const & s, int); + + bool operator==( + detail::half const & x, + detail::half const & y); + + bool operator!=( + detail::half const & x, + detail::half const & y); + + bool operator<( + detail::half const & x, + detail::half const & y); + + bool operator<=( + detail::half const & x, + detail::half const & y); + + bool operator>( + detail::half const & x, + detail::half const & y); + + bool operator>=( + detail::half const & x, + detail::half const & y); + +}//namespace detail +}//namespace glm + +#include "type_half.inl" + +#endif//glm_core_type_half diff --git a/glm/core/type_mat3x3.inl b/glm/core/type_mat3x3.inl index d94ad05c..5de6718f 100644 --- a/glm/core/type_mat3x3.inl +++ b/glm/core/type_mat3x3.inl @@ -1,812 +1,815 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Mathematics (glm.g-truc.net) -/// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref core -/// @file glm/core/type_mat3x3.inl -/// @date 2005-01-27 / 2011-06-15 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - -namespace glm{ -namespace detail -{ - template - GLM_FUNC_QUALIFIER typename tmat3x3::size_type tmat3x3::length() const - { - return 3; - } - - template - GLM_FUNC_QUALIFIER typename tmat3x3::size_type tmat3x3::col_size() - { - return 3; - } - - template - GLM_FUNC_QUALIFIER typename tmat3x3::size_type tmat3x3::row_size() - { - return 3; - } - - ////////////////////////////////////// - // Accesses - - template - GLM_FUNC_QUALIFIER typename tmat3x3::col_type & - tmat3x3::operator[] - ( - size_type i - ) - { - assert(i < this->length()); - return this->value[i]; - } - - template - GLM_FUNC_QUALIFIER typename tmat3x3::col_type const & - tmat3x3::operator[] - ( - size_type i - ) const - { - assert(i < this->length()); - return this->value[i]; - } - - ////////////////////////////////////////////////////////////// - // Constructors - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3() - { - value_type const Zero(0); - value_type const One(1); - this->value[0] = col_type(One, Zero, Zero); - this->value[1] = col_type(Zero, One, Zero); - this->value[2] = col_type(Zero, Zero, One); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat3x3 const & m - ) - { - this->value[0] = m.value[0]; - this->value[1] = m.value[1]; - this->value[2] = m.value[2]; - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - ctor - ) - {} - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - value_type const & s - ) - { - value_type const Zero(0); - this->value[0] = col_type(s, Zero, Zero); - this->value[1] = col_type(Zero, s, Zero); - this->value[2] = col_type(Zero, Zero, s); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - value_type const & x0, value_type const & y0, value_type const & z0, - value_type const & x1, value_type const & y1, value_type const & z1, - value_type const & x2, value_type const & y2, value_type const & z2 - ) - { - this->value[0] = col_type(x0, y0, z0); - this->value[1] = col_type(x1, y1, z1); - this->value[2] = col_type(x2, y2, z2); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - col_type const & v0, - col_type const & v1, - col_type const & v2 - ) - { - this->value[0] = v0; - this->value[1] = v1; - this->value[2] = v2; - } - - ////////////////////////////////////// - // Convertion constructors - template - template - GLM_FUNC_DECL tmat3x3::tmat3x3 - ( - U const & s - ) - { - value_type const Zero(0); - this->value[0] = tvec3(value_type(s), Zero, Zero); - this->value[1] = tvec3(Zero, value_type(s), Zero); - this->value[2] = tvec3(Zero, Zero, value_type(s)); - } - - template - template < - typename X1, typename Y1, typename Z1, - typename X2, typename Y2, typename Z2, - typename X3, typename Y3, typename Z3> - GLM_FUNC_DECL tmat3x3::tmat3x3 - ( - X1 const & x1, Y1 const & y1, Z1 const & z1, - X2 const & x2, Y2 const & y2, Z2 const & z2, - X3 const & x3, Y3 const & y3, Z3 const & z3 - ) - { - this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1)); - this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2)); - this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3)); - } - - template - template - GLM_FUNC_DECL tmat3x3::tmat3x3 - ( - tvec3 const & v1, - tvec3 const & v2, - tvec3 const & v3 - ) - { - this->value[0] = col_type(v1); - this->value[1] = col_type(v2); - this->value[2] = col_type(v3); - } - - ////////////////////////////////////////////////////////////// - // Conversions - - template - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat3x3 const & m - ) - { - this->value[0] = col_type(m[0]); - this->value[1] = col_type(m[1]); - this->value[2] = col_type(m[2]); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat2x2 const & m - ) - { - this->value[0] = col_type(m[0], value_type(0)); - this->value[1] = col_type(m[1], value_type(0)); - this->value[2] = col_type(detail::tvec2(0), value_type(1)); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat4x4 const & m - ) - { - this->value[0] = col_type(m[0]); - this->value[1] = col_type(m[1]); - this->value[2] = col_type(m[2]); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat2x3 const & m - ) - { - this->value[0] = m[0]; - this->value[1] = m[1]; - this->value[2] = col_type(detail::tvec2(0), value_type(1)); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat3x2 const & m - ) - { - this->value[0] = col_type(m[0], value_type(0)); - this->value[1] = col_type(m[1], value_type(0)); - this->value[2] = col_type(m[2], value_type(1)); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat2x4 const & m - ) - { - this->value[0] = col_type(m[0]); - this->value[1] = col_type(m[1]); - this->value[2] = col_type(detail::tvec2(0), value_type(1)); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat4x2 const & m - ) - { - this->value[0] = col_type(m[0], value_type(0)); - this->value[1] = col_type(m[1], value_type(0)); - this->value[2] = col_type(m[2], value_type(1)); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat3x4 const & m - ) - { - this->value[0] = col_type(m[0]); - this->value[1] = col_type(m[1]); - this->value[2] = col_type(m[2]); - } - - template - GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 - ( - tmat4x3 const & m - ) - { - this->value[0] = m[0]; - this->value[1] = m[1]; - this->value[2] = m[2]; - } - - ////////////////////////////////////////////////////////////// - // Operators - - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator= - ( - tmat3x3 const & m - ) - { - this->value[0] = m[0]; - this->value[1] = m[1]; - this->value[2] = m[2]; - return *this; - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator= - ( - tmat3x3 const & m - ) - { - this->value[0] = m[0]; - this->value[1] = m[1]; - this->value[2] = m[2]; - return *this; - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator+= - ( - U const & s - ) - { - this->value[0] += s; - this->value[1] += s; - this->value[2] += s; - return *this; - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator+= - ( - tmat3x3 const & m - ) - { - this->value[0] += m[0]; - this->value[1] += m[1]; - this->value[2] += m[2]; - return *this; - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator-= - ( - U const & s - ) - { - this->value[0] -= s; - this->value[1] -= s; - this->value[2] -= s; - return *this; - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator-= - ( - tmat3x3 const & m - ) - { - this->value[0] -= m[0]; - this->value[1] -= m[1]; - this->value[2] -= m[2]; - return *this; - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator*= - ( - U const & s - ) - { - this->value[0] *= s; - this->value[1] *= s; - this->value[2] *= s; - return *this; - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator*= - ( - tmat3x3 const & m - ) - { - return (*this = *this * m); - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator/= - ( - U const & s - ) - { - this->value[0] /= s; - this->value[1] /= s; - this->value[2] /= s; - return *this; - } - - template - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator/= - ( - tmat3x3 const & m - ) - { - return (*this = *this / m); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator++ () - { - ++this->value[0]; - ++this->value[1]; - ++this->value[2]; - return *this; - } - - template - GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator-- () - { - --this->value[0]; - --this->value[1]; - --this->value[2]; - return *this; - } - - template - GLM_FUNC_QUALIFIER tmat3x3 tmat3x3::_inverse() const - { - T S00 = value[0][0]; - T S01 = value[0][1]; - T S02 = value[0][2]; - - T S10 = value[1][0]; - T S11 = value[1][1]; - T S12 = value[1][2]; - - T S20 = value[2][0]; - T S21 = value[2][1]; - T S22 = value[2][2]; -/* - tmat3x3 Inverse( - + (S11 * S22 - S21 * S12), - - (S10 * S22 - S20 * S12), - + (S10 * S21 - S20 * S11), - - (S01 * S22 - S21 * S02), - + (S00 * S22 - S20 * S02), - - (S00 * S21 - S20 * S01), - + (S01 * S12 - S11 * S02), - - (S00 * S12 - S10 * S02), - + (S00 * S11 - S10 * S01)); -*/ - tmat3x3 Inverse( - S11 * S22 - S21 * S12, - S12 * S20 - S22 * S10, - S10 * S21 - S20 * S11, - S02 * S21 - S01 * S22, - S00 * S22 - S02 * S20, - S01 * S20 - S00 * S21, - S12 * S01 - S11 * S02, - S10 * S02 - S12 * S00, - S11 * S00 - S10 * S01); - - T Determinant = S00 * (S11 * S22 - S21 * S12) - - S10 * (S01 * S22 - S21 * S02) - + S20 * (S01 * S12 - S11 * S02); - - Inverse /= Determinant; - return Inverse; - } - - ////////////////////////////////////////////////////////////// - // Binary operators - - template - GLM_FUNC_QUALIFIER tmat3x3 operator+ - ( - tmat3x3 const & m, - typename tmat3x3::value_type const & s - ) - { - return tmat3x3( - m[0] + s, - m[1] + s, - m[2] + s); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator+ - ( - typename tmat3x3::value_type const & s, - tmat3x3 const & m - ) - { - return tmat3x3( - m[0] + s, - m[1] + s, - m[2] + s); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator+ - ( - tmat3x3 const & m1, - tmat3x3 const & m2 - ) - { - return tmat3x3( - m1[0] + m2[0], - m1[1] + m2[1], - m1[2] + m2[2]); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator- - ( - tmat3x3 const & m, - typename tmat3x3::value_type const & s - ) - { - return tmat3x3( - m[0] - s, - m[1] - s, - m[2] - s); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator- - ( - typename tmat3x3::value_type const & s, - tmat3x3 const & m - ) - { - return tmat3x3( - s - m[0], - s - m[1], - s - m[2]); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator- - ( - tmat3x3 const & m1, - tmat3x3 const & m2 - ) - { - return tmat3x3( - m1[0] - m2[0], - m1[1] - m2[1], - m1[2] - m2[2]); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator* - ( - tmat3x3 const & m, - typename tmat3x3::value_type const & s - ) - { - return tmat3x3( - m[0] * s, - m[1] * s, - m[2] * s); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator* - ( - typename tmat3x3::value_type const & s, - tmat3x3 const & m - ) - { - return tmat3x3( - m[0] * s, - m[1] * s, - m[2] * s); - } - - template - GLM_FUNC_QUALIFIER typename tmat3x3::col_type operator* - ( - tmat3x3 const & m, - typename tmat3x3::row_type const & v - ) - { - return typename tmat3x3::col_type( - m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, - m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z, - m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z); - } - - template - GLM_FUNC_QUALIFIER typename tmat3x3::row_type operator* - ( - typename tmat3x3::col_type const & v, - tmat3x3 const & m - ) - { - return typename tmat3x3::row_type( - m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z, - m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z, - m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator* - ( - tmat3x3 const & m1, - tmat3x3 const & m2 - ) - { - typename tmat3x3::value_type const SrcA00 = m1[0][0]; - typename tmat3x3::value_type const SrcA01 = m1[0][1]; - typename tmat3x3::value_type const SrcA02 = m1[0][2]; - typename tmat3x3::value_type const SrcA10 = m1[1][0]; - typename tmat3x3::value_type const SrcA11 = m1[1][1]; - typename tmat3x3::value_type const SrcA12 = m1[1][2]; - typename tmat3x3::value_type const SrcA20 = m1[2][0]; - typename tmat3x3::value_type const SrcA21 = m1[2][1]; - typename tmat3x3::value_type const SrcA22 = m1[2][2]; - - typename tmat3x3::value_type const SrcB00 = m2[0][0]; - typename tmat3x3::value_type const SrcB01 = m2[0][1]; - typename tmat3x3::value_type const SrcB02 = m2[0][2]; - typename tmat3x3::value_type const SrcB10 = m2[1][0]; - typename tmat3x3::value_type const SrcB11 = m2[1][1]; - typename tmat3x3::value_type const SrcB12 = m2[1][2]; - typename tmat3x3::value_type const SrcB20 = m2[2][0]; - typename tmat3x3::value_type const SrcB21 = m2[2][1]; - typename tmat3x3::value_type const SrcB22 = m2[2][2]; - - tmat3x3 Result(tmat3x3::null); - Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02; - Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02; - Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02; - Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12; - Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12; - Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12; - Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22; - Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22; - Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22; - return Result; - } - - template - GLM_FUNC_QUALIFIER tmat2x3 operator* - ( - tmat3x3 const & m1, - tmat2x3 const & m2 - ) - { - return tmat2x3( - m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], - m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], - m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], - m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], - m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], - m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]); - } - - template - GLM_FUNC_QUALIFIER tmat4x3 operator* - ( - tmat3x3 const & m1, - tmat4x3 const & m2 - ) - { - return tmat4x3( - m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], - m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], - m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], - m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], - m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], - m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2], - m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], - m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2], - m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2], - m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2], - m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2], - m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator/ - ( - tmat3x3 const & m, - typename tmat3x3::value_type const & s - ) - { - return tmat3x3( - m[0] / s, - m[1] / s, - m[2] / s); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator/ - ( - typename tmat3x3::value_type const & s, - tmat3x3 const & m - ) - { - return tmat3x3( - s / m[0], - s / m[1], - s / m[2]); - } - - template - GLM_FUNC_QUALIFIER typename tmat3x3::col_type operator/ - ( - tmat3x3 const & m, - typename tmat3x3::row_type const & v - ) - { - return m._inverse() * v; - } - - template - GLM_FUNC_QUALIFIER typename tmat3x3::row_type operator/ - ( - typename tmat3x3::col_type const & v, - tmat3x3 const & m - ) - { - return v * m._inverse(); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 operator/ - ( - tmat3x3 const & m1, - tmat3x3 const & m2 - ) - { - return m1 * m2._inverse(); - } - - // Unary constant operators - template - GLM_FUNC_QUALIFIER tmat3x3 const operator- - ( - tmat3x3 const & m - ) - { - return tmat3x3( - -m[0], - -m[1], - -m[2]); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 const operator++ - ( - tmat3x3 const & m, - int - ) - { - return tmat3x3( - m[0] + T(1), - m[1] + T(1), - m[2] + T(1)); - } - - template - GLM_FUNC_QUALIFIER tmat3x3 const operator-- - ( - tmat3x3 const & m, - int - ) - { - return tmat3x3( - m[0] - T(1), - m[1] - T(1), - m[2] - T(1)); - } - - ////////////////////////////////////// - // Boolean operators - - template - GLM_FUNC_QUALIFIER bool operator== - ( - tmat3x3 const & m1, - tmat3x3 const & m2 - ) - { - return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); - } - - template - GLM_FUNC_QUALIFIER bool operator!= - ( - tmat3x3 const & m1, - tmat3x3 const & m2 - ) - { - return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); - } - -} //namespace detail -} //namespace glm +/////////////////////////////////////////////////////////////////////////////////// +/// OpenGL Mathematics (glm.g-truc.net) +/// +/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Permission is hereby granted, free of charge, to any person obtaining a copy +/// of this software and associated documentation files (the "Software"), to deal +/// in the Software without restriction, including without limitation the rights +/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +/// copies of the Software, and to permit persons to whom the Software is +/// furnished to do so, subject to the following conditions: +/// +/// The above copyright notice and this permission notice shall be included in +/// all copies or substantial portions of the Software. +/// +/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +/// THE SOFTWARE. +/// +/// @ref core +/// @file glm/core/type_mat3x3.inl +/// @date 2005-01-27 / 2011-06-15 +/// @author Christophe Riccio +/////////////////////////////////////////////////////////////////////////////////// + +namespace glm{ +namespace detail +{ + template + GLM_FUNC_QUALIFIER typename tmat3x3::size_type tmat3x3::length() const + { + return 3; + } + + template + GLM_FUNC_QUALIFIER typename tmat3x3::size_type tmat3x3::col_size() + { + return 3; + } + + template + GLM_FUNC_QUALIFIER typename tmat3x3::size_type tmat3x3::row_size() + { + return 3; + } + + ////////////////////////////////////// + // Accesses + + template + GLM_FUNC_QUALIFIER typename tmat3x3::col_type & + tmat3x3::operator[] + ( + size_type i + ) + { + assert(i < this->length()); + return this->value[i]; + } + + template + GLM_FUNC_QUALIFIER typename tmat3x3::col_type const & + tmat3x3::operator[] + ( + size_type i + ) const + { + #if !(GLM_COMPILER & GLM_COMPILER_CUDA) + assert(i < this->length()); + #endif + + return this->value[i]; + } + + ////////////////////////////////////////////////////////////// + // Constructors + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3() + { + value_type const Zero(0); + value_type const One(1); + this->value[0] = col_type(One, Zero, Zero); + this->value[1] = col_type(Zero, One, Zero); + this->value[2] = col_type(Zero, Zero, One); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat3x3 const & m + ) + { + this->value[0] = m.value[0]; + this->value[1] = m.value[1]; + this->value[2] = m.value[2]; + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + ctor + ) + {} + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + value_type const & s + ) + { + value_type const Zero(0); + this->value[0] = col_type(s, Zero, Zero); + this->value[1] = col_type(Zero, s, Zero); + this->value[2] = col_type(Zero, Zero, s); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + value_type const & x0, value_type const & y0, value_type const & z0, + value_type const & x1, value_type const & y1, value_type const & z1, + value_type const & x2, value_type const & y2, value_type const & z2 + ) + { + this->value[0] = col_type(x0, y0, z0); + this->value[1] = col_type(x1, y1, z1); + this->value[2] = col_type(x2, y2, z2); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + col_type const & v0, + col_type const & v1, + col_type const & v2 + ) + { + this->value[0] = v0; + this->value[1] = v1; + this->value[2] = v2; + } + + ////////////////////////////////////// + // Convertion constructors + template + template + GLM_FUNC_DECL tmat3x3::tmat3x3 + ( + U const & s + ) + { + value_type const Zero(0); + this->value[0] = tvec3(value_type(s), Zero, Zero); + this->value[1] = tvec3(Zero, value_type(s), Zero); + this->value[2] = tvec3(Zero, Zero, value_type(s)); + } + + template + template < + typename X1, typename Y1, typename Z1, + typename X2, typename Y2, typename Z2, + typename X3, typename Y3, typename Z3> + GLM_FUNC_DECL tmat3x3::tmat3x3 + ( + X1 const & x1, Y1 const & y1, Z1 const & z1, + X2 const & x2, Y2 const & y2, Z2 const & z2, + X3 const & x3, Y3 const & y3, Z3 const & z3 + ) + { + this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1)); + this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2)); + this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3)); + } + + template + template + GLM_FUNC_DECL tmat3x3::tmat3x3 + ( + tvec3 const & v1, + tvec3 const & v2, + tvec3 const & v3 + ) + { + this->value[0] = col_type(v1); + this->value[1] = col_type(v2); + this->value[2] = col_type(v3); + } + + ////////////////////////////////////////////////////////////// + // Conversions + + template + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat3x3 const & m + ) + { + this->value[0] = col_type(m[0]); + this->value[1] = col_type(m[1]); + this->value[2] = col_type(m[2]); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat2x2 const & m + ) + { + this->value[0] = col_type(m[0], value_type(0)); + this->value[1] = col_type(m[1], value_type(0)); + this->value[2] = col_type(detail::tvec2(0), value_type(1)); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat4x4 const & m + ) + { + this->value[0] = col_type(m[0]); + this->value[1] = col_type(m[1]); + this->value[2] = col_type(m[2]); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat2x3 const & m + ) + { + this->value[0] = m[0]; + this->value[1] = m[1]; + this->value[2] = col_type(detail::tvec2(0), value_type(1)); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat3x2 const & m + ) + { + this->value[0] = col_type(m[0], value_type(0)); + this->value[1] = col_type(m[1], value_type(0)); + this->value[2] = col_type(m[2], value_type(1)); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat2x4 const & m + ) + { + this->value[0] = col_type(m[0]); + this->value[1] = col_type(m[1]); + this->value[2] = col_type(detail::tvec2(0), value_type(1)); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat4x2 const & m + ) + { + this->value[0] = col_type(m[0], value_type(0)); + this->value[1] = col_type(m[1], value_type(0)); + this->value[2] = col_type(m[2], value_type(1)); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat3x4 const & m + ) + { + this->value[0] = col_type(m[0]); + this->value[1] = col_type(m[1]); + this->value[2] = col_type(m[2]); + } + + template + GLM_FUNC_QUALIFIER tmat3x3::tmat3x3 + ( + tmat4x3 const & m + ) + { + this->value[0] = m[0]; + this->value[1] = m[1]; + this->value[2] = m[2]; + } + + ////////////////////////////////////////////////////////////// + // Operators + + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator= + ( + tmat3x3 const & m + ) + { + this->value[0] = m[0]; + this->value[1] = m[1]; + this->value[2] = m[2]; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator= + ( + tmat3x3 const & m + ) + { + this->value[0] = m[0]; + this->value[1] = m[1]; + this->value[2] = m[2]; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator+= + ( + U const & s + ) + { + this->value[0] += s; + this->value[1] += s; + this->value[2] += s; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator+= + ( + tmat3x3 const & m + ) + { + this->value[0] += m[0]; + this->value[1] += m[1]; + this->value[2] += m[2]; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator-= + ( + U const & s + ) + { + this->value[0] -= s; + this->value[1] -= s; + this->value[2] -= s; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator-= + ( + tmat3x3 const & m + ) + { + this->value[0] -= m[0]; + this->value[1] -= m[1]; + this->value[2] -= m[2]; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator*= + ( + U const & s + ) + { + this->value[0] *= s; + this->value[1] *= s; + this->value[2] *= s; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator*= + ( + tmat3x3 const & m + ) + { + return (*this = *this * m); + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator/= + ( + U const & s + ) + { + this->value[0] /= s; + this->value[1] /= s; + this->value[2] /= s; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator/= + ( + tmat3x3 const & m + ) + { + return (*this = *this / m); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator++ () + { + ++this->value[0]; + ++this->value[1]; + ++this->value[2]; + return *this; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 & tmat3x3::operator-- () + { + --this->value[0]; + --this->value[1]; + --this->value[2]; + return *this; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 tmat3x3::_inverse() const + { + T S00 = value[0][0]; + T S01 = value[0][1]; + T S02 = value[0][2]; + + T S10 = value[1][0]; + T S11 = value[1][1]; + T S12 = value[1][2]; + + T S20 = value[2][0]; + T S21 = value[2][1]; + T S22 = value[2][2]; +/* + tmat3x3 Inverse( + + (S11 * S22 - S21 * S12), + - (S10 * S22 - S20 * S12), + + (S10 * S21 - S20 * S11), + - (S01 * S22 - S21 * S02), + + (S00 * S22 - S20 * S02), + - (S00 * S21 - S20 * S01), + + (S01 * S12 - S11 * S02), + - (S00 * S12 - S10 * S02), + + (S00 * S11 - S10 * S01)); +*/ + tmat3x3 Inverse( + S11 * S22 - S21 * S12, + S12 * S20 - S22 * S10, + S10 * S21 - S20 * S11, + S02 * S21 - S01 * S22, + S00 * S22 - S02 * S20, + S01 * S20 - S00 * S21, + S12 * S01 - S11 * S02, + S10 * S02 - S12 * S00, + S11 * S00 - S10 * S01); + + T Determinant = S00 * (S11 * S22 - S21 * S12) + - S10 * (S01 * S22 - S21 * S02) + + S20 * (S01 * S12 - S11 * S02); + + Inverse /= Determinant; + return Inverse; + } + + ////////////////////////////////////////////////////////////// + // Binary operators + + template + GLM_FUNC_QUALIFIER tmat3x3 operator+ + ( + tmat3x3 const & m, + typename tmat3x3::value_type const & s + ) + { + return tmat3x3( + m[0] + s, + m[1] + s, + m[2] + s); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator+ + ( + typename tmat3x3::value_type const & s, + tmat3x3 const & m + ) + { + return tmat3x3( + m[0] + s, + m[1] + s, + m[2] + s); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator+ + ( + tmat3x3 const & m1, + tmat3x3 const & m2 + ) + { + return tmat3x3( + m1[0] + m2[0], + m1[1] + m2[1], + m1[2] + m2[2]); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator- + ( + tmat3x3 const & m, + typename tmat3x3::value_type const & s + ) + { + return tmat3x3( + m[0] - s, + m[1] - s, + m[2] - s); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator- + ( + typename tmat3x3::value_type const & s, + tmat3x3 const & m + ) + { + return tmat3x3( + s - m[0], + s - m[1], + s - m[2]); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator- + ( + tmat3x3 const & m1, + tmat3x3 const & m2 + ) + { + return tmat3x3( + m1[0] - m2[0], + m1[1] - m2[1], + m1[2] - m2[2]); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator* + ( + tmat3x3 const & m, + typename tmat3x3::value_type const & s + ) + { + return tmat3x3( + m[0] * s, + m[1] * s, + m[2] * s); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator* + ( + typename tmat3x3::value_type const & s, + tmat3x3 const & m + ) + { + return tmat3x3( + m[0] * s, + m[1] * s, + m[2] * s); + } + + template + GLM_FUNC_QUALIFIER typename tmat3x3::col_type operator* + ( + tmat3x3 const & m, + typename tmat3x3::row_type const & v + ) + { + return typename tmat3x3::col_type( + m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, + m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z, + m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z); + } + + template + GLM_FUNC_QUALIFIER typename tmat3x3::row_type operator* + ( + typename tmat3x3::col_type const & v, + tmat3x3 const & m + ) + { + return typename tmat3x3::row_type( + m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z, + m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z, + m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator* + ( + tmat3x3 const & m1, + tmat3x3 const & m2 + ) + { + typename tmat3x3::value_type const SrcA00 = m1[0][0]; + typename tmat3x3::value_type const SrcA01 = m1[0][1]; + typename tmat3x3::value_type const SrcA02 = m1[0][2]; + typename tmat3x3::value_type const SrcA10 = m1[1][0]; + typename tmat3x3::value_type const SrcA11 = m1[1][1]; + typename tmat3x3::value_type const SrcA12 = m1[1][2]; + typename tmat3x3::value_type const SrcA20 = m1[2][0]; + typename tmat3x3::value_type const SrcA21 = m1[2][1]; + typename tmat3x3::value_type const SrcA22 = m1[2][2]; + + typename tmat3x3::value_type const SrcB00 = m2[0][0]; + typename tmat3x3::value_type const SrcB01 = m2[0][1]; + typename tmat3x3::value_type const SrcB02 = m2[0][2]; + typename tmat3x3::value_type const SrcB10 = m2[1][0]; + typename tmat3x3::value_type const SrcB11 = m2[1][1]; + typename tmat3x3::value_type const SrcB12 = m2[1][2]; + typename tmat3x3::value_type const SrcB20 = m2[2][0]; + typename tmat3x3::value_type const SrcB21 = m2[2][1]; + typename tmat3x3::value_type const SrcB22 = m2[2][2]; + + tmat3x3 Result(tmat3x3::null); + Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02; + Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02; + Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02; + Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12; + Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12; + Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12; + Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22; + Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22; + Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat2x3 operator* + ( + tmat3x3 const & m1, + tmat2x3 const & m2 + ) + { + return tmat2x3( + m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], + m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], + m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], + m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], + m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], + m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]); + } + + template + GLM_FUNC_QUALIFIER tmat4x3 operator* + ( + tmat3x3 const & m1, + tmat4x3 const & m2 + ) + { + return tmat4x3( + m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2], + m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2], + m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2], + m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2], + m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2], + m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2], + m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2], + m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2], + m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2], + m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2], + m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2], + m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator/ + ( + tmat3x3 const & m, + typename tmat3x3::value_type const & s + ) + { + return tmat3x3( + m[0] / s, + m[1] / s, + m[2] / s); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator/ + ( + typename tmat3x3::value_type const & s, + tmat3x3 const & m + ) + { + return tmat3x3( + s / m[0], + s / m[1], + s / m[2]); + } + + template + GLM_FUNC_QUALIFIER typename tmat3x3::col_type operator/ + ( + tmat3x3 const & m, + typename tmat3x3::row_type const & v + ) + { + return m._inverse() * v; + } + + template + GLM_FUNC_QUALIFIER typename tmat3x3::row_type operator/ + ( + typename tmat3x3::col_type const & v, + tmat3x3 const & m + ) + { + return v * m._inverse(); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 operator/ + ( + tmat3x3 const & m1, + tmat3x3 const & m2 + ) + { + return m1 * m2._inverse(); + } + + // Unary constant operators + template + GLM_FUNC_QUALIFIER tmat3x3 const operator- + ( + tmat3x3 const & m + ) + { + return tmat3x3( + -m[0], + -m[1], + -m[2]); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 const operator++ + ( + tmat3x3 const & m, + int + ) + { + return tmat3x3( + m[0] + T(1), + m[1] + T(1), + m[2] + T(1)); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 const operator-- + ( + tmat3x3 const & m, + int + ) + { + return tmat3x3( + m[0] - T(1), + m[1] - T(1), + m[2] - T(1)); + } + + ////////////////////////////////////// + // Boolean operators + + template + GLM_FUNC_QUALIFIER bool operator== + ( + tmat3x3 const & m1, + tmat3x3 const & m2 + ) + { + return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); + } + + template + GLM_FUNC_QUALIFIER bool operator!= + ( + tmat3x3 const & m1, + tmat3x3 const & m2 + ) + { + return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); + } + +} //namespace detail +} //namespace glm diff --git a/glm/gtc/half_float.inl b/glm/gtc/half_float.inl index 8b504518..a61d34ef 100644 --- a/glm/gtc/half_float.inl +++ b/glm/gtc/half_float.inl @@ -1,1009 +1,1023 @@ -/////////////////////////////////////////////////////////////////////////////////// -/// OpenGL Mathematics (glm.g-truc.net) -/// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) -/// Permission is hereby granted, free of charge, to any person obtaining a copy -/// of this software and associated documentation files (the "Software"), to deal -/// in the Software without restriction, including without limitation the rights -/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -/// copies of the Software, and to permit persons to whom the Software is -/// furnished to do so, subject to the following conditions: -/// -/// The above copyright notice and this permission notice shall be included in -/// all copies or substantial portions of the Software. -/// -/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -/// THE SOFTWARE. -/// -/// @ref gtc_half_float -/// @file glm/gtc/half_float.inl -/// @date 2009-04-29 / 2011-06-05 -/// @author Christophe Riccio -/////////////////////////////////////////////////////////////////////////////////// - -namespace glm{ -namespace detail -{ -#if(!GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE()) - - ////////////////////////////////////// - // hvec2 - - GLM_FUNC_QUALIFIER tvec2::size_type tvec2::length() const +/////////////////////////////////////////////////////////////////////////////////// +/// OpenGL Mathematics (glm.g-truc.net) +/// +/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Permission is hereby granted, free of charge, to any person obtaining a copy +/// of this software and associated documentation files (the "Software"), to deal +/// in the Software without restriction, including without limitation the rights +/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +/// copies of the Software, and to permit persons to whom the Software is +/// furnished to do so, subject to the following conditions: +/// +/// The above copyright notice and this permission notice shall be included in +/// all copies or substantial portions of the Software. +/// +/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +/// THE SOFTWARE. +/// +/// @ref gtc_half_float +/// @file glm/gtc/half_float.inl +/// @date 2009-04-29 / 2011-06-05 +/// @author Christophe Riccio +/////////////////////////////////////////////////////////////////////////////////// + +namespace glm{ +namespace detail +{ +#if(!GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE()) + + ////////////////////////////////////// + // hvec2 + + GLM_FUNC_QUALIFIER tvec2::size_type tvec2::length() const + { + return 2; + } + + GLM_FUNC_QUALIFIER tvec2::size_type tvec2::value_size() + { + return 2; + } + + ////////////////////////////////////// + // Accesses + + GLM_FUNC_QUALIFIER half & tvec2::operator[](tvec2::size_type i) { - return 2; - } - - GLM_FUNC_QUALIFIER tvec2::size_type tvec2::value_size() + #if !(GLM_COMPILER & GLM_COMPILER_CUDA) + assert(/*i >= tvec2::size_type(0) && */i < tvec2::value_size()); + #endif + + return (&x)[i]; + } + + GLM_FUNC_QUALIFIER half const & tvec2::operator[](tvec2::size_type i) const { - return 2; - } - - ////////////////////////////////////// - // Accesses - - GLM_FUNC_QUALIFIER half & tvec2::operator[](tvec2::size_type i) + #if !(GLM_COMPILER & GLM_COMPILER_CUDA) + assert(/*i >= tvec2::size_type(0) && */i < tvec2::value_size()); + #endif + + return (&x)[i]; + } + + ////////////////////////////////////// + // Implicit basic constructors + + GLM_FUNC_QUALIFIER tvec2::tvec2() : + x(half(0.f)), + y(half(0.f)) + {} + + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + tvec2 const & v + ) : + x(v.x), + y(v.y) + {} + + ////////////////////////////////////// + // Explicit basic constructors + + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + half const & s + ) : + x(s), + y(s) + {} + + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + half const & s1, + half const & s2 + ) : + x(s1), + y(s2) + {} + + ////////////////////////////////////// + // Swizzle constructors + + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + tref2 const & r + ) : + x(r.x), + y(r.y) + {} + + ////////////////////////////////////// + // Convertion scalar constructors + + template + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + U const & x + ) : + x(half(x)), + y(half(x)) + {} + + template + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + U const & x, + V const & y + ) : + x(half(x)), + y(half(y)) + {} + + ////////////////////////////////////// + // Convertion vector constructors + + template + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + tvec2 const & v + ) : + x(half(v.x)), + y(half(v.y)) + {} + + template + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + tvec3 const & v + ) : + x(half(v.x)), + y(half(v.y)) + {} + + template + GLM_FUNC_QUALIFIER tvec2::tvec2 + ( + tvec4 const & v + ) : + x(half(v.x)), + y(half(v.y)) + {} + + ////////////////////////////////////// + // Unary arithmetic operators + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator= + ( + tvec2 const & v + ) + { + this->x = v.x; + this->y = v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator+= + ( + half const & s + ) + { + this->x += s; + this->y += s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator+= + ( + tvec2 const & v + ) + { + this->x += v.x; + this->y += v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator-= + ( + half const & s + ) + { + this->x -= s; + this->y -= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator-= + ( + tvec2 const & v + ) + { + this->x -= v.x; + this->y -= v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2& tvec2::operator*= + ( + half const & s + ) + { + this->x *= s; + this->y *= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator*= + ( + tvec2 const & v + ) + { + this->x *= v.x; + this->y *= v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator/= + ( + half const & s + ) + { + this->x /= s; + this->y /= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator/= + ( + tvec2 const & v + ) + { + this->x /= v.x; + this->y /= v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2 & tvec2::operator++() + { + ++this->x; + ++this->y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2& tvec2::operator--() + { + --this->x; + --this->y; + return *this; + } + + ////////////////////////////////////// + // Swizzle operators + + GLM_FUNC_QUALIFIER half tvec2::swizzle(comp x) const + { + return (*this)[x]; + } + + GLM_FUNC_QUALIFIER tvec2 tvec2::swizzle(comp x, comp y) const + { + return tvec2( + (*this)[x], + (*this)[y]); + } + + GLM_FUNC_QUALIFIER tvec3 tvec2::swizzle(comp x, comp y, comp z) const + { + return tvec3( + (*this)[x], + (*this)[y], + (*this)[z]); + } + + GLM_FUNC_QUALIFIER tvec4 tvec2::swizzle(comp x, comp y, comp z, comp w) const + { + return tvec4( + (*this)[x], + (*this)[y], + (*this)[z], + (*this)[w]); + } + + GLM_FUNC_QUALIFIER tref2 tvec2::swizzle(comp x, comp y) + { + return tref2( + (*this)[x], + (*this)[y]); + } + + ////////////////////////////////////// + // hvec3 + + GLM_FUNC_QUALIFIER tvec3::size_type tvec3::length() const + { + return 3; + } + + GLM_FUNC_QUALIFIER tvec3::size_type tvec3::value_size() + { + return 3; + } + + ////////////////////////////////////// + // Accesses + + GLM_FUNC_QUALIFIER half & tvec3::operator[] + ( + tvec3::size_type i + ) + { + #if !(GLM_COMPILER & GLM_COMPILER_CUDA) + assert(/*i >= tvec3::size_type(0) &&*/ i < tvec3::value_size()); + #endif + + return (&x)[i]; + } + + GLM_FUNC_QUALIFIER half const & tvec3::operator[] + ( + tvec3::size_type i + ) const + { + #if !(GLM_COMPILER & GLM_COMPILER_CUDA) + assert(/*i >= tvec3::size_type(0) &&*/ i < tvec3::value_size()); + #endif + + return (&x)[i]; + } + + ////////////////////////////////////// + // Implicit basic constructors + + GLM_FUNC_QUALIFIER tvec3::tvec3() : + x(half(0)), + y(half(0)), + z(half(0)) + {} + + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + tvec3 const & v + ) : + x(v.x), + y(v.y), + z(v.z) + {} + + ////////////////////////////////////// + // Explicit basic constructors + + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + half const & s + ) : + x(s), + y(s), + z(s) + {} + + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + half const & s0, + half const & s1, + half const & s2 + ) : + x(s0), + y(s1), + z(s2) + {} + + ////////////////////////////////////// + // Swizzle constructors + + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + tref3 const & r + ) : + x(r.x), + y(r.y), + z(r.z) + {} + + ////////////////////////////////////// + // Convertion scalar constructors + + template + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + U const & x + ) : + x(half(x)), + y(half(x)), + z(half(x)) + {} + + template + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + A const & x, + B const & y, + C const & z + ) : + x(half(x)), + y(half(y)), + z(half(z)) + {} + + ////////////////////////////////////// + // Convertion vector constructors + + template + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + tvec2 const & v, + B const & s + ) : + x(half(v.x)), + y(half(v.y)), + z(half(s)) + {} + + template + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + A const & s, + tvec2 const & v + ) : + x(half(s)), + y(half(v.x)), + z(half(v.y)) + {} + + template + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + tvec3 const & v + ) : + x(half(v.x)), + y(half(v.y)), + z(half(v.z)) + {} + + template + GLM_FUNC_QUALIFIER tvec3::tvec3 + ( + tvec4 const & v + ) : + x(half(v.x)), + y(half(v.y)), + z(half(v.z)) + {} + + ////////////////////////////////////// + // Unary arithmetic operators + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator= + ( + tvec3 const & v + ) + { + this->x = v.x; + this->y = v.y; + this->z = v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator+= + ( + half const & s + ) + { + this->x += s; + this->y += s; + this->z += s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator+= + ( + tvec3 const & v + ) + { + this->x += v.x; + this->y += v.y; + this->z += v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator-= + ( + half const & s + ) + { + this->x -= s; + this->y -= s; + this->z -= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator-= + ( + tvec3 const & v + ) + { + this->x -= v.x; + this->y -= v.y; + this->z -= v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator*= + ( + half const & s + ) + { + this->x *= s; + this->y *= s; + this->z *= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator*= + ( + tvec3 const & v + ) + { + this->x *= v.x; + this->y *= v.y; + this->z *= v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator/= + ( + half const & s + ) + { + this->x /= s; + this->y /= s; + this->z /= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator/= + ( + tvec3 const & v + ) + { + this->x /= v.x; + this->y /= v.y; + this->z /= v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator++() + { + ++this->x; + ++this->y; + ++this->z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3 & tvec3::operator--() + { + --this->x; + --this->y; + --this->z; + return *this; + } + + ////////////////////////////////////// + // Swizzle operators + + GLM_FUNC_QUALIFIER half tvec3::swizzle(comp x) const + { + return (*this)[x]; + } + + GLM_FUNC_QUALIFIER tvec2 tvec3::swizzle(comp x, comp y) const + { + return tvec2( + (*this)[x], + (*this)[y]); + } + + GLM_FUNC_QUALIFIER tvec3 tvec3::swizzle(comp x, comp y, comp z) const + { + return tvec3( + (*this)[x], + (*this)[y], + (*this)[z]); + } + + GLM_FUNC_QUALIFIER tvec4 tvec3::swizzle(comp x, comp y, comp z, comp w) const + { + return tvec4( + (*this)[x], + (*this)[y], + (*this)[z], + (*this)[w]); + } + + GLM_FUNC_QUALIFIER tref3 tvec3::swizzle(comp x, comp y, comp z) + { + return tref3( + (*this)[x], + (*this)[y], + (*this)[z]); + } + + ////////////////////////////////////// + // hvec4 + + GLM_FUNC_QUALIFIER tvec4::size_type tvec4::length() const + { + return 4; + } + + GLM_FUNC_QUALIFIER tvec4::size_type tvec4::value_size() + { + return 4; + } + + ////////////////////////////////////// + // Accesses + + GLM_FUNC_QUALIFIER half & tvec4::operator[] + ( + tvec4::size_type i + ) + { + #if !(GLM_COMPILER & GLM_COMPILER_CUDA) + assert(/*i >= tvec4::size_type(0) && */i < tvec4::value_size()); + #endif + + return (&x)[i]; + } + + GLM_FUNC_QUALIFIER half const & tvec4::operator[] + ( + tvec4::size_type i + ) const { - assert(/*i >= tvec2::size_type(0) && */i < tvec2::value_size()); - return (&x)[i]; - } - - GLM_FUNC_QUALIFIER half const & tvec2::operator[](tvec2::size_type i) const - { - assert(/*i >= tvec2::size_type(0) && */i < tvec2::value_size()); - return (&x)[i]; - } - - ////////////////////////////////////// - // Implicit basic constructors - - GLM_FUNC_QUALIFIER tvec2::tvec2() : - x(half(0.f)), - y(half(0.f)) - {} - - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - tvec2 const & v - ) : - x(v.x), - y(v.y) - {} - - ////////////////////////////////////// - // Explicit basic constructors - - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - half const & s - ) : - x(s), - y(s) - {} - - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - half const & s1, - half const & s2 - ) : - x(s1), - y(s2) - {} - - ////////////////////////////////////// - // Swizzle constructors - - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - tref2 const & r - ) : - x(r.x), - y(r.y) - {} - - ////////////////////////////////////// - // Convertion scalar constructors - - template - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - U const & x - ) : - x(half(x)), - y(half(x)) - {} - - template - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - U const & x, - V const & y - ) : - x(half(x)), - y(half(y)) - {} - - ////////////////////////////////////// - // Convertion vector constructors - - template - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - tvec2 const & v - ) : - x(half(v.x)), - y(half(v.y)) - {} - - template - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - tvec3 const & v - ) : - x(half(v.x)), - y(half(v.y)) - {} - - template - GLM_FUNC_QUALIFIER tvec2::tvec2 - ( - tvec4 const & v - ) : - x(half(v.x)), - y(half(v.y)) - {} - - ////////////////////////////////////// - // Unary arithmetic operators - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator= - ( - tvec2 const & v - ) - { - this->x = v.x; - this->y = v.y; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator+= - ( - half const & s - ) - { - this->x += s; - this->y += s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator+= - ( - tvec2 const & v - ) - { - this->x += v.x; - this->y += v.y; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator-= - ( - half const & s - ) - { - this->x -= s; - this->y -= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator-= - ( - tvec2 const & v - ) - { - this->x -= v.x; - this->y -= v.y; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2& tvec2::operator*= - ( - half const & s - ) - { - this->x *= s; - this->y *= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator*= - ( - tvec2 const & v - ) - { - this->x *= v.x; - this->y *= v.y; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator/= - ( - half const & s - ) - { - this->x /= s; - this->y /= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator/= - ( - tvec2 const & v - ) - { - this->x /= v.x; - this->y /= v.y; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2 & tvec2::operator++() - { - ++this->x; - ++this->y; - return *this; - } - - GLM_FUNC_QUALIFIER tvec2& tvec2::operator--() - { - --this->x; - --this->y; - return *this; - } - - ////////////////////////////////////// - // Swizzle operators - - GLM_FUNC_QUALIFIER half tvec2::swizzle(comp x) const - { - return (*this)[x]; - } - - GLM_FUNC_QUALIFIER tvec2 tvec2::swizzle(comp x, comp y) const - { - return tvec2( - (*this)[x], - (*this)[y]); - } - - GLM_FUNC_QUALIFIER tvec3 tvec2::swizzle(comp x, comp y, comp z) const - { - return tvec3( - (*this)[x], - (*this)[y], - (*this)[z]); - } - - GLM_FUNC_QUALIFIER tvec4 tvec2::swizzle(comp x, comp y, comp z, comp w) const - { - return tvec4( - (*this)[x], - (*this)[y], - (*this)[z], - (*this)[w]); - } - - GLM_FUNC_QUALIFIER tref2 tvec2::swizzle(comp x, comp y) - { - return tref2( - (*this)[x], - (*this)[y]); - } - - ////////////////////////////////////// - // hvec3 - - GLM_FUNC_QUALIFIER tvec3::size_type tvec3::length() const - { - return 3; - } - - GLM_FUNC_QUALIFIER tvec3::size_type tvec3::value_size() - { - return 3; - } - - ////////////////////////////////////// - // Accesses - - GLM_FUNC_QUALIFIER half & tvec3::operator[] - ( - tvec3::size_type i - ) - { - assert(/*i >= tvec3::size_type(0) &&*/ i < tvec3::value_size()); - - return (&x)[i]; - } - - GLM_FUNC_QUALIFIER half const & tvec3::operator[] - ( - tvec3::size_type i - ) const - { - assert(/*i >= tvec3::size_type(0) &&*/ i < tvec3::value_size()); - - return (&x)[i]; - } - - ////////////////////////////////////// - // Implicit basic constructors - - GLM_FUNC_QUALIFIER tvec3::tvec3() : - x(half(0)), - y(half(0)), - z(half(0)) - {} - - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - tvec3 const & v - ) : - x(v.x), - y(v.y), - z(v.z) - {} - - ////////////////////////////////////// - // Explicit basic constructors - - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - half const & s - ) : - x(s), - y(s), - z(s) - {} - - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - half const & s0, - half const & s1, - half const & s2 - ) : - x(s0), - y(s1), - z(s2) - {} - - ////////////////////////////////////// - // Swizzle constructors - - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - tref3 const & r - ) : - x(r.x), - y(r.y), - z(r.z) - {} - - ////////////////////////////////////// - // Convertion scalar constructors - - template - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - U const & x - ) : - x(half(x)), - y(half(x)), - z(half(x)) - {} - - template - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - A const & x, - B const & y, - C const & z - ) : - x(half(x)), - y(half(y)), - z(half(z)) - {} - - ////////////////////////////////////// - // Convertion vector constructors - - template - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - tvec2 const & v, - B const & s - ) : - x(half(v.x)), - y(half(v.y)), - z(half(s)) - {} - - template - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - A const & s, - tvec2 const & v - ) : - x(half(s)), - y(half(v.x)), - z(half(v.y)) - {} - - template - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - tvec3 const & v - ) : - x(half(v.x)), - y(half(v.y)), - z(half(v.z)) - {} - - template - GLM_FUNC_QUALIFIER tvec3::tvec3 - ( - tvec4 const & v - ) : - x(half(v.x)), - y(half(v.y)), - z(half(v.z)) - {} - - ////////////////////////////////////// - // Unary arithmetic operators - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator= - ( - tvec3 const & v - ) - { - this->x = v.x; - this->y = v.y; - this->z = v.z; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator+= - ( - half const & s - ) - { - this->x += s; - this->y += s; - this->z += s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator+= - ( - tvec3 const & v - ) - { - this->x += v.x; - this->y += v.y; - this->z += v.z; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator-= - ( - half const & s - ) - { - this->x -= s; - this->y -= s; - this->z -= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator-= - ( - tvec3 const & v - ) - { - this->x -= v.x; - this->y -= v.y; - this->z -= v.z; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator*= - ( - half const & s - ) - { - this->x *= s; - this->y *= s; - this->z *= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator*= - ( - tvec3 const & v - ) - { - this->x *= v.x; - this->y *= v.y; - this->z *= v.z; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator/= - ( - half const & s - ) - { - this->x /= s; - this->y /= s; - this->z /= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator/= - ( - tvec3 const & v - ) - { - this->x /= v.x; - this->y /= v.y; - this->z /= v.z; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator++() - { - ++this->x; - ++this->y; - ++this->z; - return *this; - } - - GLM_FUNC_QUALIFIER tvec3 & tvec3::operator--() - { - --this->x; - --this->y; - --this->z; - return *this; - } - - ////////////////////////////////////// - // Swizzle operators - - GLM_FUNC_QUALIFIER half tvec3::swizzle(comp x) const - { - return (*this)[x]; - } - - GLM_FUNC_QUALIFIER tvec2 tvec3::swizzle(comp x, comp y) const - { - return tvec2( - (*this)[x], - (*this)[y]); - } - - GLM_FUNC_QUALIFIER tvec3 tvec3::swizzle(comp x, comp y, comp z) const - { - return tvec3( - (*this)[x], - (*this)[y], - (*this)[z]); - } - - GLM_FUNC_QUALIFIER tvec4 tvec3::swizzle(comp x, comp y, comp z, comp w) const - { - return tvec4( - (*this)[x], - (*this)[y], - (*this)[z], - (*this)[w]); - } - - GLM_FUNC_QUALIFIER tref3 tvec3::swizzle(comp x, comp y, comp z) - { - return tref3( - (*this)[x], - (*this)[y], - (*this)[z]); - } - - ////////////////////////////////////// - // hvec4 - - GLM_FUNC_QUALIFIER tvec4::size_type tvec4::length() const - { - return 4; - } - - GLM_FUNC_QUALIFIER tvec4::size_type tvec4::value_size() - { - return 4; - } - - ////////////////////////////////////// - // Accesses - - GLM_FUNC_QUALIFIER half & tvec4::operator[] - ( - tvec4::size_type i - ) - { - assert(/*i >= tvec4::size_type(0) && */i < tvec4::value_size()); - - return (&x)[i]; - } - - GLM_FUNC_QUALIFIER half const & tvec4::operator[] - ( - tvec4::size_type i - ) const - { - assert(/*i >= tvec4::size_type(0) && */i < tvec4::value_size()); - - return (&x)[i]; - } - - ////////////////////////////////////// - // Implicit basic constructors - - GLM_FUNC_QUALIFIER tvec4::tvec4() : - x(half(0)), - y(half(0)), - z(half(0)), - w(half(0)) - {} - - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - tvec4 const & v - ) : - x(v.x), - y(v.y), - z(v.z), - w(v.w) - {} - - ////////////////////////////////////// - // Explicit basic constructors - - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - half const & s - ) : - x(s), - y(s), - z(s), - w(s) - {} - - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - half const & s1, - half const & s2, - half const & s3, - half const & s4 - ) : - x(s1), - y(s2), - z(s3), - w(s4) - {} - - ////////////////////////////////////// - // Swizzle constructors - - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - tref4 const & r - ) : - x(r.x), - y(r.y), - z(r.z), - w(r.w) - {} - - ////////////////////////////////////// - // Convertion scalar constructors - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - U const & x - ) : - x(half(x)), - y(half(x)), - z(half(x)), - w(half(x)) - {} - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - A const & x, - B const & y, - C const & z, - D const & w - ) : - x(half(x)), - y(half(y)), - z(half(z)), - w(half(w)) - {} - - ////////////////////////////////////// - // Convertion vector constructors - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - tvec2 const & v, - B const & s1, - C const & s2 - ) : - x(half(v.x)), - y(half(v.y)), - z(half(s1)), - w(half(s2)) - {} - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - A const & s1, - tvec2 const & v, - C const & s2 - ) : - x(half(s1)), - y(half(v.x)), - z(half(v.y)), - w(half(s2)) - {} - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - A const & s1, - B const & s2, - tvec2 const & v - ) : - x(half(s1)), - y(half(s2)), - z(half(v.x)), - w(half(v.y)) - {} - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - tvec3 const & v, - B const & s - ) : - x(half(v.x)), - y(half(v.y)), - z(half(v.z)), - w(half(s)) - {} - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - A const & s, - tvec3 const & v - ) : - x(half(s)), - y(half(v.x)), - z(half(v.y)), - w(half(v.z)) - {} - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - tvec2 const & v1, - tvec2 const & v2 - ) : - x(half(v1.x)), - y(half(v1.y)), - z(half(v2.x)), - w(half(v2.y)) - {} - - template - GLM_FUNC_QUALIFIER tvec4::tvec4 - ( - tvec4 const & v - ) : - x(half(v.x)), - y(half(v.y)), - z(half(v.z)), - w(half(v.w)) - {} - - ////////////////////////////////////// - // Unary arithmetic operators - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator= - ( - tvec4 const & v - ) - { - this->x = v.x; - this->y = v.y; - this->z = v.z; - this->w = v.w; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator+= - ( - half const & s - ) - { - this->x += s; - this->y += s; - this->z += s; - this->w += s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator+= - ( - tvec4 const & v - ) - { - this->x += v.x; - this->y += v.y; - this->z += v.z; - this->w += v.w; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator-= - ( - half const & s - ) - { - this->x -= s; - this->y -= s; - this->z -= s; - this->w -= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator-= - ( - tvec4 const & v - ) - { - this->x -= v.x; - this->y -= v.y; - this->z -= v.z; - this->w -= v.w; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator*= - ( - half const & s - ) - { - this->x *= s; - this->y *= s; - this->z *= s; - this->w *= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator*= - ( - tvec4 const & v - ) - { - this->x *= v.x; - this->y *= v.y; - this->z *= v.z; - this->w *= v.w; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator/= - ( - half const & s - ) - { - this->x /= s; - this->y /= s; - this->z /= s; - this->w /= s; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator/= - ( - tvec4 const & v - ) - { - this->x /= v.x; - this->y /= v.y; - this->z /= v.z; - this->w /= v.w; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator++() - { - ++this->x; - ++this->y; - ++this->z; - ++this->w; - return *this; - } - - GLM_FUNC_QUALIFIER tvec4& tvec4::operator--() - { - --this->x; - --this->y; - --this->z; - --this->w; - return *this; - } - - ////////////////////////////////////// - // Swizzle operators - - GLM_FUNC_QUALIFIER half tvec4::swizzle(comp x) const - { - return (*this)[x]; - } - - GLM_FUNC_QUALIFIER tvec2 tvec4::swizzle(comp x, comp y) const - { - return tvec2( - (*this)[x], - (*this)[y]); - } - - GLM_FUNC_QUALIFIER tvec3 tvec4::swizzle(comp x, comp y, comp z) const - { - return tvec3( - (*this)[x], - (*this)[y], - (*this)[z]); - } - - GLM_FUNC_QUALIFIER tvec4 tvec4::swizzle(comp x, comp y, comp z, comp w) const - { - return tvec4( - (*this)[x], - (*this)[y], - (*this)[z], - (*this)[w]); - } - - GLM_FUNC_QUALIFIER tref4 tvec4::swizzle(comp x, comp y, comp z, comp w) - { - return tref4( - (*this)[x], - (*this)[y], - (*this)[z], - (*this)[w]); - } - -#endif//(!GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE()) - -}//namespace detail -}//namespace glm + #if !(GLM_COMPILER & GLM_COMPILER_CUDA) + assert(/*i >= tvec4::size_type(0) && */i < tvec4::value_size()); + #endif + + return (&x)[i]; + } + + ////////////////////////////////////// + // Implicit basic constructors + + GLM_FUNC_QUALIFIER tvec4::tvec4() : + x(half(0)), + y(half(0)), + z(half(0)), + w(half(0)) + {} + + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + tvec4 const & v + ) : + x(v.x), + y(v.y), + z(v.z), + w(v.w) + {} + + ////////////////////////////////////// + // Explicit basic constructors + + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + half const & s + ) : + x(s), + y(s), + z(s), + w(s) + {} + + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + half const & s1, + half const & s2, + half const & s3, + half const & s4 + ) : + x(s1), + y(s2), + z(s3), + w(s4) + {} + + ////////////////////////////////////// + // Swizzle constructors + + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + tref4 const & r + ) : + x(r.x), + y(r.y), + z(r.z), + w(r.w) + {} + + ////////////////////////////////////// + // Convertion scalar constructors + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + U const & x + ) : + x(half(x)), + y(half(x)), + z(half(x)), + w(half(x)) + {} + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + A const & x, + B const & y, + C const & z, + D const & w + ) : + x(half(x)), + y(half(y)), + z(half(z)), + w(half(w)) + {} + + ////////////////////////////////////// + // Convertion vector constructors + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + tvec2 const & v, + B const & s1, + C const & s2 + ) : + x(half(v.x)), + y(half(v.y)), + z(half(s1)), + w(half(s2)) + {} + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + A const & s1, + tvec2 const & v, + C const & s2 + ) : + x(half(s1)), + y(half(v.x)), + z(half(v.y)), + w(half(s2)) + {} + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + A const & s1, + B const & s2, + tvec2 const & v + ) : + x(half(s1)), + y(half(s2)), + z(half(v.x)), + w(half(v.y)) + {} + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + tvec3 const & v, + B const & s + ) : + x(half(v.x)), + y(half(v.y)), + z(half(v.z)), + w(half(s)) + {} + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + A const & s, + tvec3 const & v + ) : + x(half(s)), + y(half(v.x)), + z(half(v.y)), + w(half(v.z)) + {} + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + tvec2 const & v1, + tvec2 const & v2 + ) : + x(half(v1.x)), + y(half(v1.y)), + z(half(v2.x)), + w(half(v2.y)) + {} + + template + GLM_FUNC_QUALIFIER tvec4::tvec4 + ( + tvec4 const & v + ) : + x(half(v.x)), + y(half(v.y)), + z(half(v.z)), + w(half(v.w)) + {} + + ////////////////////////////////////// + // Unary arithmetic operators + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator= + ( + tvec4 const & v + ) + { + this->x = v.x; + this->y = v.y; + this->z = v.z; + this->w = v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator+= + ( + half const & s + ) + { + this->x += s; + this->y += s; + this->z += s; + this->w += s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator+= + ( + tvec4 const & v + ) + { + this->x += v.x; + this->y += v.y; + this->z += v.z; + this->w += v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator-= + ( + half const & s + ) + { + this->x -= s; + this->y -= s; + this->z -= s; + this->w -= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator-= + ( + tvec4 const & v + ) + { + this->x -= v.x; + this->y -= v.y; + this->z -= v.z; + this->w -= v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator*= + ( + half const & s + ) + { + this->x *= s; + this->y *= s; + this->z *= s; + this->w *= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator*= + ( + tvec4 const & v + ) + { + this->x *= v.x; + this->y *= v.y; + this->z *= v.z; + this->w *= v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator/= + ( + half const & s + ) + { + this->x /= s; + this->y /= s; + this->z /= s; + this->w /= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator/= + ( + tvec4 const & v + ) + { + this->x /= v.x; + this->y /= v.y; + this->z /= v.z; + this->w /= v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator++() + { + ++this->x; + ++this->y; + ++this->z; + ++this->w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4& tvec4::operator--() + { + --this->x; + --this->y; + --this->z; + --this->w; + return *this; + } + + ////////////////////////////////////// + // Swizzle operators + + GLM_FUNC_QUALIFIER half tvec4::swizzle(comp x) const + { + return (*this)[x]; + } + + GLM_FUNC_QUALIFIER tvec2 tvec4::swizzle(comp x, comp y) const + { + return tvec2( + (*this)[x], + (*this)[y]); + } + + GLM_FUNC_QUALIFIER tvec3 tvec4::swizzle(comp x, comp y, comp z) const + { + return tvec3( + (*this)[x], + (*this)[y], + (*this)[z]); + } + + GLM_FUNC_QUALIFIER tvec4 tvec4::swizzle(comp x, comp y, comp z, comp w) const + { + return tvec4( + (*this)[x], + (*this)[y], + (*this)[z], + (*this)[w]); + } + + GLM_FUNC_QUALIFIER tref4 tvec4::swizzle(comp x, comp y, comp z, comp w) + { + return tref4( + (*this)[x], + (*this)[y], + (*this)[z], + (*this)[w]); + } + +#endif//(!GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE()) + +}//namespace detail +}//namespace glm