diff options
Diffstat (limited to 'include/gal/opengl/glm/gtc/half_float.inl')
| -rw-r--r-- | include/gal/opengl/glm/gtc/half_float.inl | 1050 |
1 files changed, 1050 insertions, 0 deletions
diff --git a/include/gal/opengl/glm/gtc/half_float.inl b/include/gal/opengl/glm/gtc/half_float.inl new file mode 100644 index 0000000..57dae8e --- /dev/null +++ b/include/gal/opengl/glm/gtc/half_float.inl @@ -0,0 +1,1050 @@ +/////////////////////////////////////////////////////////////////////////////////// +/// OpenGL Mathematics (glm.g-truc.net) +/// +/// Copyright (c) 2005 - 2013 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 / 2012-11-06 +/// @author Christophe Riccio +/////////////////////////////////////////////////////////////////////////////////// + +namespace glm{ +namespace detail +{ +#if(GLM_COMPONENT == GLM_COMPONENT_CXX98) + + ////////////////////////////////////// + // hvec2 + + GLM_FUNC_QUALIFIER tvec2<half>::size_type tvec2<half>::length() const + { + return 2; + } + + GLM_FUNC_QUALIFIER tvec2<half>::size_type tvec2<half>::value_size() + { + return 2; + } + + ////////////////////////////////////// + // Accesses + + GLM_FUNC_QUALIFIER half & tvec2<half>::operator[](tvec2<half>::size_type i) + { + assert(/*i >= tvec2<half>::size_type(0) && */i < tvec2<half>::value_size()); + return (&x)[i]; + } + + GLM_FUNC_QUALIFIER half const & tvec2<half>::operator[](tvec2<half>::size_type i) const + { + assert(/*i >= tvec2<half>::size_type(0) && */i < tvec2<half>::value_size()); + return (&x)[i]; + } + + ////////////////////////////////////// + // Implicit basic constructors + + GLM_FUNC_QUALIFIER tvec2<half>::tvec2() : + x(half(0.f)), + y(half(0.f)) + {} + + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + tvec2<half> const & v + ) : + x(v.x), + y(v.y) + {} + + ////////////////////////////////////// + // Explicit basic constructors + + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + half const & s + ) : + x(s), + y(s) + {} + + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + half const & s1, + half const & s2 + ) : + x(s1), + y(s2) + {} + + ////////////////////////////////////// + // Swizzle constructors + + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + tref2<half> const & r + ) : + x(r.x), + y(r.y) + {} + + ////////////////////////////////////// + // Convertion scalar constructors + + template <typename U> + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + U const & x + ) : + x(half(x)), + y(half(x)) + {} + + template <typename U, typename V> + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + U const & x, + V const & y + ) : + x(half(x)), + y(half(y)) + {} + + ////////////////////////////////////// + // Convertion vector constructors + + template <typename U> + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + tvec2<U> const & v + ) : + x(half(v.x)), + y(half(v.y)) + {} + + template <typename U> + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + tvec3<U> const & v + ) : + x(half(v.x)), + y(half(v.y)) + {} + + template <typename U> + GLM_FUNC_QUALIFIER tvec2<half>::tvec2 + ( + tvec4<U> const & v + ) : + x(half(v.x)), + y(half(v.y)) + {} + + ////////////////////////////////////// + // Unary arithmetic operators + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator= + ( + tvec2<half> const & v + ) + { + this->x = v.x; + this->y = v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator+= + ( + half const & s + ) + { + this->x += s; + this->y += s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator+= + ( + tvec2<half> const & v + ) + { + this->x += v.x; + this->y += v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator-= + ( + half const & s + ) + { + this->x -= s; + this->y -= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator-= + ( + tvec2<half> const & v + ) + { + this->x -= v.x; + this->y -= v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half>& tvec2<half>::operator*= + ( + half const & s + ) + { + this->x *= s; + this->y *= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator*= + ( + tvec2<half> const & v + ) + { + this->x *= v.x; + this->y *= v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator/= + ( + half const & s + ) + { + this->x /= s; + this->y /= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator/= + ( + tvec2<half> const & v + ) + { + this->x /= v.x; + this->y /= v.y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator++() + { + ++this->x; + ++this->y; + return *this; + } + + GLM_FUNC_QUALIFIER tvec2<half>& tvec2<half>::operator--() + { + --this->x; + --this->y; + return *this; + } + + ////////////////////////////////////// + // Swizzle operators + + GLM_FUNC_QUALIFIER half tvec2<half>::swizzle(comp x) const + { + return (*this)[x]; + } + + GLM_FUNC_QUALIFIER tvec2<half> tvec2<half>::swizzle(comp x, comp y) const + { + return tvec2<half>( + (*this)[x], + (*this)[y]); + } + + GLM_FUNC_QUALIFIER tvec3<half> tvec2<half>::swizzle(comp x, comp y, comp z) const + { + return tvec3<half>( + (*this)[x], + (*this)[y], + (*this)[z]); + } + + GLM_FUNC_QUALIFIER tvec4<half> tvec2<half>::swizzle(comp x, comp y, comp z, comp w) const + { + return tvec4<half>( + (*this)[x], + (*this)[y], + (*this)[z], + (*this)[w]); + } + + GLM_FUNC_QUALIFIER tref2<half> tvec2<half>::swizzle(comp x, comp y) + { + return tref2<half>( + (*this)[x], + (*this)[y]); + } + + ////////////////////////////////////// + // hvec3 + + GLM_FUNC_QUALIFIER tvec3<half>::size_type tvec3<half>::length() const + { + return 3; + } + + GLM_FUNC_QUALIFIER tvec3<half>::size_type tvec3<half>::value_size() + { + return 3; + } + + ////////////////////////////////////// + // Accesses + + GLM_FUNC_QUALIFIER half & tvec3<half>::operator[] + ( + tvec3<half>::size_type i + ) + { + assert(/*i >= tvec3<half>::size_type(0) &&*/ i < tvec3<half>::value_size()); + + return (&x)[i]; + } + + GLM_FUNC_QUALIFIER half const & tvec3<half>::operator[] + ( + tvec3<half>::size_type i + ) const + { + assert(/*i >= tvec3<half>::size_type(0) &&*/ i < tvec3<half>::value_size()); + + return (&x)[i]; + } + + ////////////////////////////////////// + // Implicit basic constructors + + GLM_FUNC_QUALIFIER tvec3<half>::tvec3() : + x(half(0)), + y(half(0)), + z(half(0)) + {} + + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + tvec3<half> const & v + ) : + x(v.x), + y(v.y), + z(v.z) + {} + + ////////////////////////////////////// + // Explicit basic constructors + + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + half const & s + ) : + x(s), + y(s), + z(s) + {} + + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + half const & s0, + half const & s1, + half const & s2 + ) : + x(s0), + y(s1), + z(s2) + {} + + ////////////////////////////////////// + // Swizzle constructors + + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + tref3<half> const & r + ) : + x(r.x), + y(r.y), + z(r.z) + {} + + ////////////////////////////////////// + // Convertion scalar constructors + + template <typename U> + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + U const & x + ) : + x(half(x)), + y(half(x)), + z(half(x)) + {} + + template <typename A, typename B, typename C> + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + A const & x, + B const & y, + C const & z + ) : + x(half(x)), + y(half(y)), + z(half(z)) + {} + + ////////////////////////////////////// + // Convertion vector constructors + + template <typename A, typename B> + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + tvec2<A> const & v, + B const & s + ) : + x(half(v.x)), + y(half(v.y)), + z(half(s)) + {} + + template <typename A, typename B> + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + A const & s, + tvec2<B> const & v + ) : + x(half(s)), + y(half(v.x)), + z(half(v.y)) + {} + + template <typename U> + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + tvec3<U> const & v + ) : + x(half(v.x)), + y(half(v.y)), + z(half(v.z)) + {} + + template <typename U> + GLM_FUNC_QUALIFIER tvec3<half>::tvec3 + ( + tvec4<U> const & v + ) : + x(half(v.x)), + y(half(v.y)), + z(half(v.z)) + {} + + ////////////////////////////////////// + // Unary arithmetic operators + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator= + ( + tvec3<half> const & v + ) + { + this->x = v.x; + this->y = v.y; + this->z = v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator+= + ( + half const & s + ) + { + this->x += s; + this->y += s; + this->z += s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator+= + ( + tvec3<half> const & v + ) + { + this->x += v.x; + this->y += v.y; + this->z += v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator-= + ( + half const & s + ) + { + this->x -= s; + this->y -= s; + this->z -= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator-= + ( + tvec3<half> const & v + ) + { + this->x -= v.x; + this->y -= v.y; + this->z -= v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator*= + ( + half const & s + ) + { + this->x *= s; + this->y *= s; + this->z *= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator*= + ( + tvec3<half> const & v + ) + { + this->x *= v.x; + this->y *= v.y; + this->z *= v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator/= + ( + half const & s + ) + { + this->x /= s; + this->y /= s; + this->z /= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator/= + ( + tvec3<half> const & v + ) + { + this->x /= v.x; + this->y /= v.y; + this->z /= v.z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator++() + { + ++this->x; + ++this->y; + ++this->z; + return *this; + } + + GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator--() + { + --this->x; + --this->y; + --this->z; + return *this; + } + + ////////////////////////////////////// + // Swizzle operators + + GLM_FUNC_QUALIFIER half tvec3<half>::swizzle(comp x) const + { + return (*this)[x]; + } + + GLM_FUNC_QUALIFIER tvec2<half> tvec3<half>::swizzle(comp x, comp y) const + { + return tvec2<half>( + (*this)[x], + (*this)[y]); + } + + GLM_FUNC_QUALIFIER tvec3<half> tvec3<half>::swizzle(comp x, comp y, comp z) const + { + return tvec3<half>( + (*this)[x], + (*this)[y], + (*this)[z]); + } + + GLM_FUNC_QUALIFIER tvec4<half> tvec3<half>::swizzle(comp x, comp y, comp z, comp w) const + { + return tvec4<half>( + (*this)[x], + (*this)[y], + (*this)[z], + (*this)[w]); + } + + GLM_FUNC_QUALIFIER tref3<half> tvec3<half>::swizzle(comp x, comp y, comp z) + { + return tref3<half>( + (*this)[x], + (*this)[y], + (*this)[z]); + } + + ////////////////////////////////////// + // hvec4 + + GLM_FUNC_QUALIFIER tvec4<half>::size_type tvec4<half>::length() const + { + return 4; + } + + GLM_FUNC_QUALIFIER tvec4<half>::size_type tvec4<half>::value_size() + { + return 4; + } + + ////////////////////////////////////// + // Accesses + + GLM_FUNC_QUALIFIER half & tvec4<half>::operator[] + ( + tvec4<half>::size_type i + ) + { + assert(/*i >= tvec4<half>::size_type(0) && */i < tvec4<half>::value_size()); + + return (&x)[i]; + } + + GLM_FUNC_QUALIFIER half const & tvec4<half>::operator[] + ( + tvec4<half>::size_type i + ) const + { + assert(/*i >= tvec4<half>::size_type(0) && */i < tvec4<half>::value_size()); + + return (&x)[i]; + } + + ////////////////////////////////////// + // Implicit basic constructors + + GLM_FUNC_QUALIFIER tvec4<half>::tvec4() : + x(half(0)), + y(half(0)), + z(half(0)), + w(half(0)) + {} + + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + tvec4<half> const & v + ) : + x(v.x), + y(v.y), + z(v.z), + w(v.w) + {} + + ////////////////////////////////////// + // Explicit basic constructors + + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + half const & s + ) : + x(s), + y(s), + z(s), + w(s) + {} + + GLM_FUNC_QUALIFIER tvec4<half>::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<half>::tvec4 + ( + tref4<half> const & r + ) : + x(r.x), + y(r.y), + z(r.z), + w(r.w) + {} + + ////////////////////////////////////// + // Convertion scalar constructors + + template <typename U> + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + U const & x + ) : + x(half(x)), + y(half(x)), + z(half(x)), + w(half(x)) + {} + + template <typename A, typename B, typename C, typename D> + GLM_FUNC_QUALIFIER tvec4<half>::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 <typename A, typename B, typename C> + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + tvec2<A> const & v, + B const & s1, + C const & s2 + ) : + x(half(v.x)), + y(half(v.y)), + z(half(s1)), + w(half(s2)) + {} + + template <typename A, typename B, typename C> + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + A const & s1, + tvec2<B> const & v, + C const & s2 + ) : + x(half(s1)), + y(half(v.x)), + z(half(v.y)), + w(half(s2)) + {} + + template <typename A, typename B, typename C> + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + A const & s1, + B const & s2, + tvec2<C> const & v + ) : + x(half(s1)), + y(half(s2)), + z(half(v.x)), + w(half(v.y)) + {} + + template <typename A, typename B> + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + tvec3<A> const & v, + B const & s + ) : + x(half(v.x)), + y(half(v.y)), + z(half(v.z)), + w(half(s)) + {} + + template <typename A, typename B> + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + A const & s, + tvec3<B> const & v + ) : + x(half(s)), + y(half(v.x)), + z(half(v.y)), + w(half(v.z)) + {} + + template <typename A, typename B> + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + tvec2<A> const & v1, + tvec2<B> const & v2 + ) : + x(half(v1.x)), + y(half(v1.y)), + z(half(v2.x)), + w(half(v2.y)) + {} + + template <typename U> + GLM_FUNC_QUALIFIER tvec4<half>::tvec4 + ( + tvec4<U> 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<half>& tvec4<half>::operator= + ( + tvec4<half> const & v + ) + { + this->x = v.x; + this->y = v.y; + this->z = v.z; + this->w = v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator+= + ( + half const & s + ) + { + this->x += s; + this->y += s; + this->z += s; + this->w += s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator+= + ( + tvec4<half> const & v + ) + { + this->x += v.x; + this->y += v.y; + this->z += v.z; + this->w += v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator-= + ( + half const & s + ) + { + this->x -= s; + this->y -= s; + this->z -= s; + this->w -= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator-= + ( + tvec4<half> const & v + ) + { + this->x -= v.x; + this->y -= v.y; + this->z -= v.z; + this->w -= v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator*= + ( + half const & s + ) + { + this->x *= s; + this->y *= s; + this->z *= s; + this->w *= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator*= + ( + tvec4<half> const & v + ) + { + this->x *= v.x; + this->y *= v.y; + this->z *= v.z; + this->w *= v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator/= + ( + half const & s + ) + { + this->x /= s; + this->y /= s; + this->z /= s; + this->w /= s; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator/= + ( + tvec4<half> const & v + ) + { + this->x /= v.x; + this->y /= v.y; + this->z /= v.z; + this->w /= v.w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator++() + { + ++this->x; + ++this->y; + ++this->z; + ++this->w; + return *this; + } + + GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator--() + { + --this->x; + --this->y; + --this->z; + --this->w; + return *this; + } + + ////////////////////////////////////// + // Swizzle operators + + GLM_FUNC_QUALIFIER half tvec4<half>::swizzle(comp x) const + { + return (*this)[x]; + } + + GLM_FUNC_QUALIFIER tvec2<half> tvec4<half>::swizzle(comp x, comp y) const + { + return tvec2<half>( + (*this)[x], + (*this)[y]); + } + + GLM_FUNC_QUALIFIER tvec3<half> tvec4<half>::swizzle(comp x, comp y, comp z) const + { + return tvec3<half>( + (*this)[x], + (*this)[y], + (*this)[z]); + } + + GLM_FUNC_QUALIFIER tvec4<half> tvec4<half>::swizzle(comp x, comp y, comp z, comp w) const + { + return tvec4<half>( + (*this)[x], + (*this)[y], + (*this)[z], + (*this)[w]); + } + + GLM_FUNC_QUALIFIER tref4<half> tvec4<half>::swizzle(comp x, comp y, comp z, comp w) + { + return tref4<half>( + (*this)[x], + (*this)[y], + (*this)[z], + (*this)[w]); + } + +#endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98) + +}//namespace detail + + GLM_FUNC_QUALIFIER half abs(half const & x) + { + return float(x) >= float(0) ? x : -x; + } + + GLM_FUNC_QUALIFIER hvec2 abs(hvec2 const & v) + { + return hvec2( + float(v.x) >= float(0) ? v.x : -v.x, + float(v.y) >= float(0) ? v.y : -v.y); + } + + GLM_FUNC_QUALIFIER hvec3 abs(hvec3 const & v) + { + return hvec3( + float(v.x) >= float(0) ? v.x : -v.x, + float(v.y) >= float(0) ? v.y : -v.y, + float(v.z) >= float(0) ? v.z : -v.z); + } + + GLM_FUNC_QUALIFIER hvec4 abs(hvec4 const & v) + { + return hvec4( + float(v.x) >= float(0) ? v.x : -v.x, + float(v.y) >= float(0) ? v.y : -v.y, + float(v.z) >= float(0) ? v.z : -v.z, + float(v.w) >= float(0) ? v.w : -v.w); + } + + template <> + GLM_FUNC_QUALIFIER glm::half mix + ( + glm::half const & x, + glm::half const & y, + bool const & a + ) + { + return a ? y : x; + } + +}//namespace glm |