diff options
Diffstat (limited to 'src/libraries/glm/core/func_common.inl')
| -rwxr-xr-x | src/libraries/glm/core/func_common.inl | 1197 |
1 files changed, 1197 insertions, 0 deletions
diff --git a/src/libraries/glm/core/func_common.inl b/src/libraries/glm/core/func_common.inl new file mode 100755 index 0000000..9c1c047 --- /dev/null +++ b/src/libraries/glm/core/func_common.inl @@ -0,0 +1,1197 @@ +/////////////////////////////////////////////////////////////////////////////////// +/// 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/func_common.inl +/// @date 2008-08-03 / 2011-06-15 +/// @author Christophe Riccio +/////////////////////////////////////////////////////////////////////////////////// + +namespace glm{ +namespace detail +{ + template <typename genFIType, bool /*signed*/> + struct Abs_ + {}; + + template <typename genFIType> + struct Abs_<genFIType, true> + { + static genFIType get(genFIType const & x) + { + GLM_STATIC_ASSERT( + detail::type<genFIType>::is_float || + detail::type<genFIType>::is_int, "'abs' only accept floating-point and integer inputs"); + return x >= genFIType(0) ? x : -x; + // TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff; + } + }; + + template <typename genFIType> + struct Abs_<genFIType, false> + { + static genFIType get(genFIType const & x) + { + GLM_STATIC_ASSERT( + detail::type<genFIType>::is_uint, "'abs' only accept floating-point and integer inputs"); + return x; + } + }; +}//namespace detail + + // abs + template <typename genFIType> + GLM_FUNC_QUALIFIER genFIType abs + ( + genFIType const & x + ) + { + return detail::Abs_<genFIType, std::numeric_limits<genFIType>::is_signed>::get(x); + } + + VECTORIZE_VEC(abs) + + // sign + //Try something like based on x >> 31 to get the sign bit + template <typename genFIType> + GLM_FUNC_QUALIFIER genFIType sign + ( + genFIType const & x + ) + { + GLM_STATIC_ASSERT( + detail::type<genFIType>::is_float || + detail::type<genFIType>::is_int, "'sign' only accept signed inputs"); + + genFIType result; + if(x > genFIType(0)) + result = genFIType(1); + else if(x < genFIType(0)) + result = genFIType(-1); + else + result = genFIType(0); + return result; + } + + VECTORIZE_VEC(sign) + + // floor + template <> + GLM_FUNC_QUALIFIER detail::half floor<detail::half>(detail::half const & x) + { + return detail::half(::std::floor(float(x))); + } + + template <typename genType> + GLM_FUNC_QUALIFIER genType floor(genType const & x) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'floor' only accept floating-point inputs"); + + return ::std::floor(x); + } + + VECTORIZE_VEC(floor) + + // trunc + template <typename genType> + GLM_FUNC_QUALIFIER genType trunc(genType const & x) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'trunc' only accept floating-point inputs"); + return x < 0 ? -floor(-x) : floor(x); + } + + VECTORIZE_VEC(trunc) + + // round + template <typename genType> + GLM_FUNC_QUALIFIER genType round(genType const& x) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'round' only accept floating-point inputs"); + + if(x < 0) + return genType(int(x - genType(0.5))); + return genType(int(x + genType(0.5))); + } + + VECTORIZE_VEC(round) + +/* + // roundEven + template <typename genType> + GLM_FUNC_QUALIFIER genType roundEven(genType const& x) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'roundEven' only accept floating-point inputs"); + + return genType(int(x + genType(int(x) % 2))); + } +*/ + + // roundEven + template <typename genType> + GLM_FUNC_QUALIFIER genType roundEven(genType const & x) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'roundEven' only accept floating-point inputs"); + + int Integer = int(x); + genType IntegerPart = genType(Integer); + genType FractionalPart = fract(x); + + if(FractionalPart > genType(0.5) || FractionalPart < genType(0.5)) + { + return round(x); + } + else if((Integer % 2) == 0) + { + return IntegerPart; + } + else if(x <= genType(0)) // Work around... + { + return IntegerPart - 1; + } + else + { + return IntegerPart + 1; + } + //else // Bug on MinGW 4.5.2 + //{ + // return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0)); + //} + } + + VECTORIZE_VEC(roundEven) + + // ceil + template <typename genType> + GLM_FUNC_QUALIFIER genType ceil(genType const & x) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'ceil' only accept floating-point inputs"); + + return ::std::ceil(x); + } + + VECTORIZE_VEC(ceil) + + // fract + template <typename genType> + GLM_FUNC_QUALIFIER genType fract + ( + genType const & x + ) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'fract' only accept floating-point inputs"); + + return x - ::std::floor(x); + } + + VECTORIZE_VEC(fract) + + // mod + template <typename genType> + GLM_FUNC_QUALIFIER genType mod + ( + genType const & x, + genType const & y + ) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mod' only accept floating-point inputs"); + + return x - y * floor(x / y); + } + + VECTORIZE_VEC_SCA(mod) + VECTORIZE_VEC_VEC(mod) + + // modf + template <typename genType> + GLM_FUNC_QUALIFIER genType modf + ( + genType const & x, + genType & i + ) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'modf' only accept floating-point inputs"); + + return std::modf(x, &i); + } + + template <typename valType> + GLM_FUNC_QUALIFIER detail::tvec2<valType> modf + ( + detail::tvec2<valType> const & x, + detail::tvec2<valType> & i + ) + { + return detail::tvec2<valType>( + modf(x.x, i.x), + modf(x.y, i.y)); + } + + template <typename valType> + GLM_FUNC_QUALIFIER detail::tvec3<valType> modf + ( + detail::tvec3<valType> const & x, + detail::tvec3<valType> & i + ) + { + return detail::tvec3<valType>( + modf(x.x, i.x), + modf(x.y, i.y), + modf(x.z, i.z)); + } + + template <typename valType> + GLM_FUNC_QUALIFIER detail::tvec4<valType> modf + ( + detail::tvec4<valType> const & x, + detail::tvec4<valType> & i + ) + { + return detail::tvec4<valType>( + modf(x.x, i.x), + modf(x.y, i.y), + modf(x.z, i.z), + modf(x.w, i.w)); + } + + //// Only valid if (INT_MIN <= x-y <= INT_MAX) + //// min(x,y) + //r = y + ((x - y) & ((x - y) >> (sizeof(int) * + //CHAR_BIT – 1))); + //// max(x,y) + //r = x - ((x - y) & ((x - y) >> (sizeof(int) * + //CHAR_BIT - 1))); + + // min + template <typename genType> + GLM_FUNC_QUALIFIER genType min + ( + genType const & x, + genType const & y + ) + { + GLM_STATIC_ASSERT( + detail::type<genType>::is_float || + detail::type<genType>::is_int || + detail::type<genType>::is_uint, "'min' only accept numbers"); + + return x < y ? x : y; + } + + VECTORIZE_VEC_SCA(min) + VECTORIZE_VEC_VEC(min) + + // max + template <typename genType> + GLM_FUNC_QUALIFIER genType max + ( + genType const & x, + genType const & y + ) + { + GLM_STATIC_ASSERT( + detail::type<genType>::is_float || + detail::type<genType>::is_int || + detail::type<genType>::is_uint, "'max' only accept numbers"); + + return x > y ? x : y; + } + + VECTORIZE_VEC_SCA(max) + VECTORIZE_VEC_VEC(max) + + // clamp + template <typename valType> + GLM_FUNC_QUALIFIER valType clamp + ( + valType const & x, + valType const & minVal, + valType const & maxVal + ) + { + GLM_STATIC_ASSERT( + detail::type<valType>::is_float || + detail::type<valType>::is_int || + detail::type<valType>::is_uint, "'clamp' only accept numbers"); + + return min(maxVal, max(minVal, x)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> clamp + ( + detail::tvec2<T> const & x, + typename detail::tvec2<T>::value_type const & minVal, + typename detail::tvec2<T>::value_type const & maxVal + ) + { + return detail::tvec2<T>( + clamp(x.x, minVal, maxVal), + clamp(x.y, minVal, maxVal)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> clamp + ( + detail::tvec3<T> const & x, + typename detail::tvec3<T>::value_type const & minVal, + typename detail::tvec3<T>::value_type const & maxVal + ) + { + return detail::tvec3<T>( + clamp(x.x, minVal, maxVal), + clamp(x.y, minVal, maxVal), + clamp(x.z, minVal, maxVal)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> clamp + ( + detail::tvec4<T> const & x, + typename detail::tvec4<T>::value_type const & minVal, + typename detail::tvec4<T>::value_type const & maxVal + ) + { + return detail::tvec4<T>( + clamp(x.x, minVal, maxVal), + clamp(x.y, minVal, maxVal), + clamp(x.z, minVal, maxVal), + clamp(x.w, minVal, maxVal)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> clamp + ( + detail::tvec2<T> const & x, + detail::tvec2<T> const & minVal, + detail::tvec2<T> const & maxVal + ) + { + return detail::tvec2<T>( + clamp(x.x, minVal.x, maxVal.x), + clamp(x.y, minVal.y, maxVal.y)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> clamp + ( + detail::tvec3<T> const & x, + detail::tvec3<T> const & minVal, + detail::tvec3<T> const & maxVal + ) + { + return detail::tvec3<T>( + clamp(x.x, minVal.x, maxVal.x), + clamp(x.y, minVal.y, maxVal.y), + clamp(x.z, minVal.z, maxVal.z)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> clamp + ( + detail::tvec4<T> const & x, + detail::tvec4<T> const & minVal, + detail::tvec4<T> const & maxVal + ) + { + return detail::tvec4<T>( + clamp(x.x, minVal.x, maxVal.x), + clamp(x.y, minVal.y, maxVal.y), + clamp(x.z, minVal.z, maxVal.z), + clamp(x.w, minVal.w, maxVal.w)); + } + + // mix + template <typename genTypeT, typename genTypeU> + GLM_FUNC_QUALIFIER genTypeT mix + ( + genTypeT const & x, + genTypeT const & y, + genTypeU const & a + ) + { + // It could be a vector too + //GLM_STATIC_ASSERT( + // detail::type<genTypeT>::is_float && + // detail::type<genTypeU>::is_float); + + //return x + a * (y - x); + return genTypeT(genTypeU(x) + a * genTypeU(y - x)); + } + + template <typename valTypeA, typename valTypeB> + GLM_FUNC_QUALIFIER detail::tvec2<valTypeA> mix + ( + detail::tvec2<valTypeA> const & x, + detail::tvec2<valTypeA> const & y, + valTypeB const & a + ) + { + return detail::tvec2<valTypeA>( + detail::tvec2<valTypeB>(x) + a * detail::tvec2<valTypeB>(y - x)); + } + + template <typename valTypeA, typename valTypeB> + GLM_FUNC_QUALIFIER detail::tvec3<valTypeA> mix + ( + detail::tvec3<valTypeA> const & x, + detail::tvec3<valTypeA> const & y, + valTypeB const & a + ) + { + return detail::tvec3<valTypeA>( + detail::tvec3<valTypeB>(x) + a * detail::tvec3<valTypeB>(y - x)); + } + + template <typename valTypeA, typename valTypeB> + GLM_FUNC_QUALIFIER detail::tvec4<valTypeA> mix + ( + detail::tvec4<valTypeA> const & x, + detail::tvec4<valTypeA> const & y, + valTypeB const & a + ) + { + return detail::tvec4<valTypeA>( + detail::tvec4<valTypeB>(x) + a * detail::tvec4<valTypeB>(y - x)); + } + + template <typename valTypeA, typename valTypeB> + GLM_FUNC_QUALIFIER detail::tvec2<valTypeA> mix + ( + detail::tvec2<valTypeA> const & x, + detail::tvec2<valTypeA> const & y, + detail::tvec2<valTypeB> const & a + ) + { + return detail::tvec2<valTypeA>( + detail::tvec2<valTypeB>(x) + a * detail::tvec2<valTypeB>(y - x)); + } + + template <typename valTypeA, typename valTypeB> + GLM_FUNC_QUALIFIER detail::tvec3<valTypeA> mix + ( + detail::tvec3<valTypeA> const & x, + detail::tvec3<valTypeA> const & y, + detail::tvec3<valTypeB> const & a + ) + { + return detail::tvec3<valTypeA>( + detail::tvec3<valTypeB>(x) + a * detail::tvec3<valTypeB>(y - x)); + } + + template <typename valTypeA, typename valTypeB> + GLM_FUNC_QUALIFIER detail::tvec4<valTypeA> mix + ( + detail::tvec4<valTypeA> const & x, + detail::tvec4<valTypeA> const & y, + detail::tvec4<valTypeB> const & a + ) + { + return detail::tvec4<valTypeA>( + detail::tvec4<valTypeB>(x) + a * detail::tvec4<valTypeB>(y - x)); + } + + //template <typename genTypeT> + //GLM_FUNC_QUALIFIER genTypeT mix + //( + // genTypeT const & x, + // genTypeT const & y, + // float const & a + //) + //{ + // // It could be a vector too + // //GLM_STATIC_ASSERT( + // // detail::type<genTypeT>::is_float && + // // detail::type<genTypeU>::is_float); + + // return x + a * (y - x); + //} + + template <typename genType> + GLM_FUNC_QUALIFIER genType mix + ( + genType const & x, + genType const & y, + bool const & a + ) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs"); + + return a ? y : x; + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> mix + ( + detail::tvec2<T> const & x, + detail::tvec2<T> const & y, + typename detail::tvec2<T>::bool_type a + ) + { + GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs"); + + detail::tvec2<T> result; + for + ( + typename detail::tvec2<T>::size_type i = 0; + i < detail::tvec2<T>::value_size(); + ++i + ) + { + result[i] = a[i] ? y[i] : x[i]; + } + return result; + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> mix + ( + detail::tvec3<T> const & x, + detail::tvec3<T> const & y, + typename detail::tvec3<T>::bool_type a + ) + { + GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs"); + + detail::tvec3<T> result; + for + ( + typename detail::tvec3<T>::size_type i = 0; + i < detail::tvec3<T>::value_size(); + ++i + ) + { + result[i] = a[i] ? y[i] : x[i]; + } + return result; + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> mix + ( + detail::tvec4<T> const & x, + detail::tvec4<T> const & y, + typename detail::tvec4<T>::bool_type a + ) + { + GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs"); + + detail::tvec4<T> result; + for + ( + typename detail::tvec4<T>::size_type i = 0; + i < detail::tvec4<T>::value_size(); + ++i + ) + { + result[i] = a[i] ? y[i] : x[i]; + } + return result; + } + + // step + template <typename genType> + GLM_FUNC_QUALIFIER genType step + ( + genType const & edge, + genType const & x + ) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'step' only accept floating-point inputs"); + + return x < edge ? genType(0) : genType(1); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> step + ( + typename detail::tvec2<T>::value_type const & edge, + detail::tvec2<T> const & x + ) + { + return detail::tvec2<T>( + x.x < edge ? T(0) : T(1), + x.y < edge ? T(0) : T(1)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> step + ( + typename detail::tvec3<T>::value_type const & edge, + detail::tvec3<T> const & x + ) + { + return detail::tvec3<T>( + x.x < edge ? T(0) : T(1), + x.y < edge ? T(0) : T(1), + x.z < edge ? T(0) : T(1)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> step + ( + typename detail::tvec4<T>::value_type const & edge, + detail::tvec4<T> const & x + ) + { + return detail::tvec4<T>( + x.x < edge ? T(0) : T(1), + x.y < edge ? T(0) : T(1), + x.z < edge ? T(0) : T(1), + x.w < edge ? T(0) : T(1)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> step + ( + detail::tvec2<T> const & edge, + detail::tvec2<T> const & x + ) + { + return detail::tvec2<T>( + x.x < edge.x ? T(0) : T(1), + x.y < edge.y ? T(0) : T(1)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> step + ( + detail::tvec3<T> const & edge, + detail::tvec3<T> const & x + ) + { + return detail::tvec3<T>( + x.x < edge.x ? T(0) : T(1), + x.y < edge.y ? T(0) : T(1), + x.z < edge.z ? T(0) : T(1)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> step + ( + detail::tvec4<T> const & edge, + detail::tvec4<T> const & x + ) + { + return detail::tvec4<T>( + x.x < edge.x ? T(0) : T(1), + x.y < edge.y ? T(0) : T(1), + x.z < edge.z ? T(0) : T(1), + x.w < edge.w ? T(0) : T(1)); + } + + // smoothstep + template <typename genType> + GLM_FUNC_QUALIFIER genType smoothstep + ( + genType const & edge0, + genType const & edge1, + genType const & x + ) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'smoothstep' only accept floating-point inputs"); + + genType tmp = clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)); + return tmp * tmp * (genType(3) - genType(2) * tmp); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> smoothstep + ( + typename detail::tvec2<T>::value_type const & edge0, + typename detail::tvec2<T>::value_type const & edge1, + detail::tvec2<T> const & x + ) + { + return detail::tvec2<T>( + smoothstep(edge0, edge1, x.x), + smoothstep(edge0, edge1, x.y)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> smoothstep + ( + typename detail::tvec3<T>::value_type const & edge0, + typename detail::tvec3<T>::value_type const & edge1, + detail::tvec3<T> const & x + ) + { + return detail::tvec3<T>( + smoothstep(edge0, edge1, x.x), + smoothstep(edge0, edge1, x.y), + smoothstep(edge0, edge1, x.z)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> smoothstep + ( + typename detail::tvec4<T>::value_type const & edge0, + typename detail::tvec4<T>::value_type const & edge1, + detail::tvec4<T> const & x + ) + { + return detail::tvec4<T>( + smoothstep(edge0, edge1, x.x), + smoothstep(edge0, edge1, x.y), + smoothstep(edge0, edge1, x.z), + smoothstep(edge0, edge1, x.w)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> smoothstep + ( + detail::tvec2<T> const & edge0, + detail::tvec2<T> const & edge1, + detail::tvec2<T> const & x + ) + { + return detail::tvec2<T>( + smoothstep(edge0.x, edge1.x, x.x), + smoothstep(edge0.y, edge1.y, x.y)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> smoothstep + ( + detail::tvec3<T> const & edge0, + detail::tvec3<T> const & edge1, + detail::tvec3<T> const & x + ) + { + return detail::tvec3<T>( + smoothstep(edge0.x, edge1.x, x.x), + smoothstep(edge0.y, edge1.y, x.y), + smoothstep(edge0.z, edge1.z, x.z)); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> smoothstep + ( + detail::tvec4<T> const & edge0, + detail::tvec4<T> const & edge1, + detail::tvec4<T> const & x + ) + { + return detail::tvec4<T>( + smoothstep(edge0.x, edge1.x, x.x), + smoothstep(edge0.y, edge1.y, x.y), + smoothstep(edge0.z, edge1.z, x.z), + smoothstep(edge0.w, edge1.w, x.w)); + } + + // TODO: Not working on MinGW... + template <typename genType> + GLM_FUNC_QUALIFIER bool isnan(genType const & x) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isnan' only accept floating-point inputs"); + +# if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_INTEL)) + return _isnan(x) != 0; +# elif(GLM_COMPILER & GLM_COMPILER_GCC) +# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) + return _isnan(x) != 0; +# else + return std::isnan(x); +# endif +# else + return std::isnan(x); +# endif + } + + template <typename T> + GLM_FUNC_QUALIFIER typename detail::tvec2<T>::bool_type isnan + ( + detail::tvec2<T> const & x + ) + { + return typename detail::tvec2<T>::bool_type( + isnan(x.x), + isnan(x.y)); + } + + template <typename T> + GLM_FUNC_QUALIFIER typename detail::tvec3<T>::bool_type isnan + ( + detail::tvec3<T> const & x + ) + { + return typename detail::tvec3<T>::bool_type( + isnan(x.x), + isnan(x.y), + isnan(x.z)); + } + + template <typename T> + GLM_FUNC_QUALIFIER typename detail::tvec4<T>::bool_type isnan + ( + detail::tvec4<T> const & x + ) + { + return typename detail::tvec4<T>::bool_type( + isnan(x.x), + isnan(x.y), + isnan(x.z), + isnan(x.w)); + } + + template <typename genType> + GLM_FUNC_QUALIFIER bool isinf( + genType const & x) + { + GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isinf' only accept floating-point inputs"); + +# if(GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)) + return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF; +# elif(GLM_COMPILER & GLM_COMPILER_GCC) +# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) + return _isinf(x) != 0; +# else + return std::isinf(x); +# endif +# else + return std::isinf(x); +# endif +/* +# if(GLM_COMPILER & GLM_COMPILER_VC) + return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF; +# elif(GLM_COMPILER & GLM_COMPILER_GCC) +# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) + return _isinf(x) != 0; +# else + return std::isinf(x); +# endif +# elif(GLM_COMPILER & GLM_COMPILER_INTEL) + return isinf(x) != 0; +# else + return std::isinf(x); +# endif +*/ + } + + template <typename T> + GLM_FUNC_QUALIFIER typename detail::tvec2<T>::bool_type isinf + ( + detail::tvec2<T> const & x + ) + { + return typename detail::tvec2<T>::bool_type( + isinf(x.x), + isinf(x.y)); + } + + template <typename T> + GLM_FUNC_QUALIFIER typename detail::tvec3<T>::bool_type isinf + ( + detail::tvec3<T> const & x + ) + { + return typename detail::tvec3<T>::bool_type( + isinf(x.x), + isinf(x.y), + isinf(x.z)); + } + + template <typename T> + GLM_FUNC_QUALIFIER typename detail::tvec4<T>::bool_type isinf + ( + detail::tvec4<T> const & x + ) + { + return typename detail::tvec4<T>::bool_type( + isinf(x.x), + isinf(x.y), + isinf(x.z), + isinf(x.w)); + } + + GLM_FUNC_QUALIFIER int floatBitsToInt(float const & value) + { + union + { + float f; + int i; + } fi; + + fi.f = value; + return fi.i; + } + + GLM_FUNC_QUALIFIER detail::tvec2<int> floatBitsToInt + ( + detail::tvec2<float> const & value + ) + { + return detail::tvec2<int>( + floatBitsToInt(value.x), + floatBitsToInt(value.y)); + } + + GLM_FUNC_QUALIFIER detail::tvec3<int> floatBitsToInt + ( + detail::tvec3<float> const & value + ) + { + return detail::tvec3<int>( + floatBitsToInt(value.x), + floatBitsToInt(value.y), + floatBitsToInt(value.z)); + } + + GLM_FUNC_QUALIFIER detail::tvec4<int> floatBitsToInt + ( + detail::tvec4<float> const & value + ) + { + return detail::tvec4<int>( + floatBitsToInt(value.x), + floatBitsToInt(value.y), + floatBitsToInt(value.z), + floatBitsToInt(value.w)); + } + + GLM_FUNC_QUALIFIER uint floatBitsToUint(float const & value) + { + union + { + float f; + uint u; + } fu; + + fu.f = value; + return fu.u; + } + + GLM_FUNC_QUALIFIER detail::tvec2<uint> floatBitsToUint + ( + detail::tvec2<float> const & value + ) + { + return detail::tvec2<uint>( + floatBitsToUint(value.x), + floatBitsToUint(value.y)); + } + + GLM_FUNC_QUALIFIER detail::tvec3<uint> floatBitsToUint + ( + detail::tvec3<float> const & value + ) + { + return detail::tvec3<uint>( + floatBitsToUint(value.x), + floatBitsToUint(value.y), + floatBitsToUint(value.z)); + } + + GLM_FUNC_QUALIFIER detail::tvec4<uint> floatBitsToUint + ( + detail::tvec4<float> const & value + ) + { + return detail::tvec4<uint>( + floatBitsToUint(value.x), + floatBitsToUint(value.y), + floatBitsToUint(value.z), + floatBitsToUint(value.w)); + } + + GLM_FUNC_QUALIFIER float intBitsToFloat(int const & value) + { + union + { + float f; + int i; + } fi; + + fi.i = value; + return fi.f; + } + + GLM_FUNC_QUALIFIER detail::tvec2<float> intBitsToFloat + + ( + detail::tvec2<int> const & value + ) + { + return detail::tvec2<float>( + intBitsToFloat(value.x), + intBitsToFloat(value.y)); + } + + GLM_FUNC_QUALIFIER detail::tvec3<float> intBitsToFloat + ( + detail::tvec3<int> const & value + ) + { + return detail::tvec3<float>( + intBitsToFloat(value.x), + intBitsToFloat(value.y), + intBitsToFloat(value.z)); + } + + GLM_FUNC_QUALIFIER detail::tvec4<float> intBitsToFloat + ( + detail::tvec4<int> const & value + ) + { + return detail::tvec4<float>( + intBitsToFloat(value.x), + intBitsToFloat(value.y), + intBitsToFloat(value.z), + intBitsToFloat(value.w)); + } + + GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const & value) + { + union + { + float f; + uint u; + } fu; + + fu.u = value; + return fu.f; + } + + GLM_FUNC_QUALIFIER detail::tvec2<float> uintBitsToFloat + ( + detail::tvec2<uint> const & value + ) + { + return detail::tvec2<float>( + uintBitsToFloat(value.x), + uintBitsToFloat(value.y)); + } + + GLM_FUNC_QUALIFIER detail::tvec3<float> uintBitsToFloat + ( + detail::tvec3<uint> const & value + ) + { + return detail::tvec3<float>( + uintBitsToFloat(value.x), + uintBitsToFloat(value.y), + uintBitsToFloat(value.z)); + } + + GLM_FUNC_QUALIFIER detail::tvec4<float> uintBitsToFloat + ( + detail::tvec4<uint> const & value + ) + { + return detail::tvec4<float>( + uintBitsToFloat(value.x), + uintBitsToFloat(value.y), + uintBitsToFloat(value.z), + uintBitsToFloat(value.w)); + } + + template <typename genType> + GLM_FUNC_QUALIFIER genType fma + ( + genType const & a, + genType const & b, + genType const & c + ) + { + return a * b + c; + } + + template <typename genType> + GLM_FUNC_QUALIFIER genType frexp + ( + genType const & x, + int & exp + ) + { + return std::frexp(x, exp); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> frexp + ( + detail::tvec2<T> const & x, + detail::tvec2<int> & exp + ) + { + return std::frexp(x, exp); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> frexp + ( + detail::tvec3<T> const & x, + detail::tvec3<int> & exp + ) + { + return std::frexp(x, exp); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> frexp + ( + detail::tvec4<T> const & x, + detail::tvec4<int> & exp + ) + { + return std::frexp(x, exp); + } + + template <typename genType> + GLM_FUNC_QUALIFIER genType ldexp + ( + genType const & x, + int const & exp + ) + { + return std::frexp(x, exp); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec2<T> ldexp + ( + detail::tvec2<T> const & x, + detail::tvec2<int> const & exp + ) + { + return std::frexp(x, exp); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec3<T> ldexp + ( + detail::tvec3<T> const & x, + detail::tvec3<int> const & exp + ) + { + return std::frexp(x, exp); + } + + template <typename T> + GLM_FUNC_QUALIFIER detail::tvec4<T> ldexp + ( + detail::tvec4<T> const & x, + detail::tvec4<int> const & exp + ) + { + return std::frexp(x, exp); + } + +}//namespace glm |