anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Add GLM_FORCE_UNRESTRICTED_FLOAT to skip static assert when using not float types

Browse Source
master
christophe ago%!(EXTRA string=2 years) committed by Christophe
parent 229f3eced4
commit 869f9da00e
17 changed files with 105 additions and 105 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      glm/detail/compute_common.hpp
  2. 68
      glm/detail/func_common.inl
  3. 8
      glm/detail/func_exponential.inl
  4. 12
      glm/detail/func_trigonometric.inl
  5. 12
      glm/ext/quaternion_common.inl
  6. 2
      glm/ext/quaternion_geometric.inl
  7. 18
      glm/ext/scalar_common.inl
  8. 4
      glm/ext/scalar_constants.inl
  9. 4
      glm/ext/scalar_integer.inl
  10. 24
      glm/ext/scalar_reciprocal.inl
  11. 4
      glm/ext/scalar_ulp.inl
  12. 24
      glm/ext/vector_reciprocal.inl
  13. 4
      glm/gtc/ulp.inl
  14. 10
      glm/gtx/common.inl
  15. 2
      glm/gtx/exterior_product.inl
  16. 6
      glm/gtx/fast_square_root.inl
  17. 6
      glm/gtx/vector_angle.inl

2
glm/detail/compute_common.hpp
Unescape View File

@ -16,7 +16,7 @@ namespace detail
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(
std::numeric_limits<genFIType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || std::numeric_limits<genFIType>::is_signed, std::numeric_limits<genFIType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<genFIType>::is_signed,
"'abs' only accept floating-point and integer scalar or vector inputs"); "'abs' only accept floating-point and integer scalar or vector inputs");
return x >= genFIType(0) ? x : -x; return x >= genFIType(0) ? x : -x;

68
glm/detail/func_common.inl
Unescape View File

@ -16,7 +16,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType min(genType x, genType y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType min(genType x, genType y)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || std::numeric_limits<genType>::is_integer, "'min' only accept floating-point or integer inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<genType>::is_integer, "'min' only accept floating-point or integer inputs");
return (y < x) ? y : x; return (y < x) ? y : x;
} }
@ -24,7 +24,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType max(genType x, genType y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType max(genType x, genType y)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || std::numeric_limits<genType>::is_integer, "'max' only accept floating-point or integer inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<genType>::is_integer, "'max' only accept floating-point or integer inputs");
return (x < y) ? y : x; return (x < y) ? y : x;
} }
@ -44,7 +44,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType round(genType x) GLM_FUNC_QUALIFIER genType round(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'round' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'round' only accept floating-point inputs");
return x < static_cast<genType>(0) ? static_cast<genType>(int(x - static_cast<genType>(0.5))) : static_cast<genType>(int(x + static_cast<genType>(0.5))); return x < static_cast<genType>(0) ? static_cast<genType>(int(x - static_cast<genType>(0.5))) : static_cast<genType>(int(x + static_cast<genType>(0.5)));
} }
@ -57,7 +57,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType trunc(genType x) GLM_FUNC_QUALIFIER genType trunc(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'trunc' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'trunc' only accept floating-point inputs");
return x < static_cast<genType>(0) ? -std::floor(-x) : std::floor(x); return x < static_cast<genType>(0) ? -std::floor(-x) : std::floor(x);
} }
@ -82,7 +82,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
return vec<L, T, Q>(vec<L, U, Q>(x) * (static_cast<U>(1) - a) + vec<L, U, Q>(y) * a); return vec<L, T, Q>(vec<L, U, Q>(x) * (static_cast<U>(1) - a) + vec<L, U, Q>(y) * a);
} }
@ -105,7 +105,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U const& a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
return vec<L, T, Q>(vec<L, U, Q>(x) * (static_cast<U>(1) - a) + vec<L, U, Q>(y) * a); return vec<L, T, Q>(vec<L, U, Q>(x) * (static_cast<U>(1) - a) + vec<L, U, Q>(y) * a);
} }
@ -125,7 +125,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(T const& x, T const& y, U const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(T const& x, T const& y, U const& a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
return static_cast<T>(static_cast<U>(x) * (static_cast<U>(1) - a) + static_cast<U>(y) * a); return static_cast<T>(static_cast<U>(x) * (static_cast<U>(1) - a) + static_cast<U>(y) * a);
} }
@ -213,7 +213,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& a, vec<L, T, Q> const& b) GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs."); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
return a - b * floor(a / b); return a - b * floor(a / b);
} }
}; };
@ -259,7 +259,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& edge0, vec<L, T, Q> const& edge1, vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
vec<L, T, Q> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1))); vec<L, T, Q> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp); return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
} }
@ -284,7 +284,7 @@ namespace detail
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genFIType sign(genFIType x) GLM_FUNC_QUALIFIER GLM_CONSTEXPR genFIType sign(genFIType x)
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(
std::numeric_limits<genFIType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer), std::numeric_limits<genFIType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
"'sign' only accept signed inputs"); "'sign' only accept signed inputs");
return detail::compute_sign<1, genFIType, defaultp, return detail::compute_sign<1, genFIType, defaultp,
@ -295,7 +295,7 @@ namespace detail
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> sign(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> sign(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer), std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
"'sign' only accept signed inputs"); "'sign' only accept signed inputs");
return detail::compute_sign<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x); return detail::compute_sign<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
@ -306,21 +306,21 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> floor(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> floor(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'floor' only accept floating-point inputs."); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'floor' only accept floating-point inputs.");
return detail::compute_floor<L, T, Q, detail::is_aligned<Q>::value>::call(x); return detail::compute_floor<L, T, Q, detail::is_aligned<Q>::value>::call(x);
} }
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> trunc(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> trunc(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'trunc' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'trunc' only accept floating-point inputs");
return detail::compute_trunc<L, T, Q, detail::is_aligned<Q>::value>::call(x); return detail::compute_trunc<L, T, Q, detail::is_aligned<Q>::value>::call(x);
} }
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> round(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> round(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'round' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'round' only accept floating-point inputs");
return detail::compute_round<L, T, Q, detail::is_aligned<Q>::value>::call(x); return detail::compute_round<L, T, Q, detail::is_aligned<Q>::value>::call(x);
} }
@ -329,7 +329,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType roundEven(genType const& x) GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs");
return genType(int(x + genType(int(x) % 2))); return genType(int(x + genType(int(x) % 2)));
} }
@ -339,7 +339,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType roundEven(genType x) GLM_FUNC_QUALIFIER genType roundEven(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs");
int Integer = static_cast<int>(x); int Integer = static_cast<int>(x);
genType IntegerPart = static_cast<genType>(Integer); genType IntegerPart = static_cast<genType>(Integer);
@ -370,7 +370,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> roundEven(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> roundEven(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs");
return detail::functor1<vec, L, T, T, Q>::call(roundEven, x); return detail::functor1<vec, L, T, T, Q>::call(roundEven, x);
} }
@ -379,7 +379,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> ceil(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> ceil(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'ceil' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceil' only accept floating-point inputs");
return detail::compute_ceil<L, T, Q, detail::is_aligned<Q>::value>::call(x); return detail::compute_ceil<L, T, Q, detail::is_aligned<Q>::value>::call(x);
} }
@ -393,7 +393,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> fract(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> fract(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fract' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fract' only accept floating-point inputs");
return detail::compute_fract<L, T, Q, detail::is_aligned<Q>::value>::call(x); return detail::compute_fract<L, T, Q, detail::is_aligned<Q>::value>::call(x);
} }
@ -426,7 +426,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType modf(genType x, genType & i) GLM_FUNC_QUALIFIER genType modf(genType x, genType & i)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'modf' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'modf' only accept floating-point inputs");
return std::modf(x, &i); return std::modf(x, &i);
} }
@ -476,7 +476,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, T b) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> min(vec<L, T, Q> const& a, T b)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || std::numeric_limits<T>::is_integer, "'min' only accept floating-point or integer inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<T>::is_integer, "'min' only accept floating-point or integer inputs");
return detail::compute_min_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b)); return detail::compute_min_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b));
} }
@ -490,7 +490,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& a, T b) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> max(vec<L, T, Q> const& a, T b)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || std::numeric_limits<T>::is_integer, "'max' only accept floating-point or integer inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<T>::is_integer, "'max' only accept floating-point or integer inputs");
return detail::compute_max_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b)); return detail::compute_max_vector<L, T, Q, detail::is_aligned<Q>::value>::call(a, vec<L, T, Q>(b));
} }
@ -504,21 +504,21 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal) GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || std::numeric_limits<genType>::is_integer, "'clamp' only accept floating-point or integer inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<genType>::is_integer, "'clamp' only accept floating-point or integer inputs");
return min(max(x, minVal), maxVal); return min(max(x, minVal), maxVal);
} }
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, T minVal, T maxVal) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, T minVal, T maxVal)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, vec<L, T, Q>(minVal), vec<L, T, Q>(maxVal)); return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, vec<L, T, Q>(minVal), vec<L, T, Q>(maxVal));
} }
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> clamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<T>::is_integer, "'clamp' only accept floating-point or integer inputs");
return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, minVal, maxVal); return detail::compute_clamp_vector<L, T, Q, detail::is_aligned<Q>::value>::call(x, minVal, maxVal);
} }
@ -563,7 +563,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x) GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1))); genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)));
return tmp * tmp * (genType(3) - genType(2) * tmp); return tmp * tmp * (genType(3) - genType(2) * tmp);
@ -587,7 +587,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER bool isnan(genType x) GLM_FUNC_QUALIFIER bool isnan(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs");
# if GLM_HAS_CXX11_STL # if GLM_HAS_CXX11_STL
return std::isnan(x); return std::isnan(x);
@ -612,7 +612,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, bool, Q> isnan(vec<L, T, Q> const& v) GLM_FUNC_QUALIFIER vec<L, bool, Q> isnan(vec<L, T, Q> const& v)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs");
vec<L, bool, Q> Result; vec<L, bool, Q> Result;
for (length_t l = 0; l < v.length(); ++l) for (length_t l = 0; l < v.length(); ++l)
@ -626,7 +626,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER bool isinf(genType x) GLM_FUNC_QUALIFIER bool isinf(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs");
# if GLM_HAS_CXX11_STL # if GLM_HAS_CXX11_STL
return std::isinf(x); return std::isinf(x);
@ -654,7 +654,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, bool, Q> isinf(vec<L, T, Q> const& v) GLM_FUNC_QUALIFIER vec<L, bool, Q> isinf(vec<L, T, Q> const& v)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs");
vec<L, bool, Q> Result; vec<L, bool, Q> Result;
for (length_t l = 0; l < v.length(); ++l) for (length_t l = 0; l < v.length(); ++l)
@ -751,7 +751,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType frexp(genType x, int& exp) GLM_FUNC_QUALIFIER genType frexp(genType x, int& exp)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'frexp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'frexp' only accept floating-point inputs");
return std::frexp(x, &exp); return std::frexp(x, &exp);
} }
@ -759,7 +759,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> frexp(vec<L, T, Q> const& v, vec<L, int, Q>& exp) GLM_FUNC_QUALIFIER vec<L, T, Q> frexp(vec<L, T, Q> const& v, vec<L, int, Q>& exp)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'frexp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'frexp' only accept floating-point inputs");
vec<L, T, Q> Result; vec<L, T, Q> Result;
for (length_t l = 0; l < v.length(); ++l) for (length_t l = 0; l < v.length(); ++l)
@ -770,7 +770,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType ldexp(genType const& x, int const& exp) GLM_FUNC_QUALIFIER genType ldexp(genType const& x, int const& exp)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'ldexp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ldexp' only accept floating-point inputs");
return std::ldexp(x, exp); return std::ldexp(x, exp);
} }
@ -778,7 +778,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> ldexp(vec<L, T, Q> const& v, vec<L, int, Q> const& exp) GLM_FUNC_QUALIFIER vec<L, T, Q> ldexp(vec<L, T, Q> const& v, vec<L, int, Q> const& exp)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'ldexp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ldexp' only accept floating-point inputs");
vec<L, T, Q> Result; vec<L, T, Q> Result;
for (length_t l = 0; l < v.length(); ++l) for (length_t l = 0; l < v.length(); ++l)

8
glm/detail/func_exponential.inl
Unescape View File

@ -25,7 +25,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v) GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'log2' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs."); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'log2' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
return detail::functor1<vec, L, T, T, Q>::call(log2, v); return detail::functor1<vec, L, T, T, Q>::call(log2, v);
} }
@ -97,7 +97,7 @@ namespace detail
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType exp2(genType x) GLM_FUNC_QUALIFIER genType exp2(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'exp2' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'exp2' only accept floating-point inputs");
return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x); return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
} }
@ -127,7 +127,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> sqrt(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> sqrt(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'sqrt' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sqrt' only accept floating-point inputs");
return detail::compute_sqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x); return detail::compute_sqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
} }
@ -141,7 +141,7 @@ namespace detail
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> inversesqrt(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> inversesqrt(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'inversesqrt' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'inversesqrt' only accept floating-point inputs");
return detail::compute_inversesqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x); return detail::compute_inversesqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
} }
}//namespace glm }//namespace glm

12
glm/detail/func_trigonometric.inl
Unescape View File

@ -8,7 +8,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees) GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'radians' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'radians' only accept floating-point input");
return degrees * static_cast<genType>(0.01745329251994329576923690768489); return degrees * static_cast<genType>(0.01745329251994329576923690768489);
} }
@ -23,7 +23,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians) GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'degrees' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'degrees' only accept floating-point input");
return radians * static_cast<genType>(57.295779513082320876798154814105); return radians * static_cast<genType>(57.295779513082320876798154814105);
} }
@ -83,7 +83,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType atan(genType y, genType x) GLM_FUNC_QUALIFIER genType atan(genType y, genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'atan' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'atan' only accept floating-point input");
return ::std::atan2(y, x); return ::std::atan2(y, x);
} }
@ -136,7 +136,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType asinh(genType x) GLM_FUNC_QUALIFIER genType asinh(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'asinh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asinh' only accept floating-point input");
return (x < static_cast<genType>(0) ? static_cast<genType>(-1) : (x > static_cast<genType>(0) ? static_cast<genType>(1) : static_cast<genType>(0))) * log(std::abs(x) + sqrt(static_cast<genType>(1) + x * x)); return (x < static_cast<genType>(0) ? static_cast<genType>(-1) : (x > static_cast<genType>(0) ? static_cast<genType>(1) : static_cast<genType>(0))) * log(std::abs(x) + sqrt(static_cast<genType>(1) + x * x));
} }
@ -155,7 +155,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType acosh(genType x) GLM_FUNC_QUALIFIER genType acosh(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acosh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acosh' only accept floating-point input");
if(x < static_cast<genType>(1)) if(x < static_cast<genType>(1))
return static_cast<genType>(0); return static_cast<genType>(0);
@ -176,7 +176,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType atanh(genType x) GLM_FUNC_QUALIFIER genType atanh(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'atanh' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'atanh' only accept floating-point input");
if(std::abs(x) >= static_cast<genType>(1)) if(std::abs(x) >= static_cast<genType>(1))
return 0; return 0;

12
glm/ext/quaternion_common.inl
Unescape View File

@ -3,7 +3,7 @@ namespace glm
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> mix(qua<T, Q> const& x, qua<T, Q> const& y, T a) GLM_FUNC_QUALIFIER qua<T, Q> mix(qua<T, Q> const& x, qua<T, Q> const& y, T a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'mix' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'mix' only accept floating-point inputs");
T const cosTheta = dot(x, y); T const cosTheta = dot(x, y);
@ -28,7 +28,7 @@ namespace glm
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'lerp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'lerp' only accept floating-point inputs");
// Lerp is only defined in [0, 1] // Lerp is only defined in [0, 1]
assert(a >= static_cast<T>(0)); assert(a >= static_cast<T>(0));
@ -40,7 +40,7 @@ namespace glm
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a) GLM_FUNC_QUALIFIER qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'slerp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'slerp' only accept floating-point inputs");
qua<T, Q> z = y; qua<T, Q> z = y;
@ -75,7 +75,7 @@ namespace glm
template<typename T, typename S, qualifier Q> template<typename T, typename S, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a, S k) GLM_FUNC_QUALIFIER qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a, S k)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'slerp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'slerp' only accept floating-point inputs");
GLM_STATIC_ASSERT(std::numeric_limits<S>::is_integer, "'slerp' only accept integer for spin count"); GLM_STATIC_ASSERT(std::numeric_limits<S>::is_integer, "'slerp' only accept integer for spin count");
qua<T, Q> z = y; qua<T, Q> z = y;
@ -124,7 +124,7 @@ namespace glm
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, bool, Q> isnan(qua<T, Q> const& q) GLM_FUNC_QUALIFIER vec<4, bool, Q> isnan(qua<T, Q> const& q)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs");
return vec<4, bool, Q>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w)); return vec<4, bool, Q>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w));
} }
@ -132,7 +132,7 @@ namespace glm
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, bool, Q> isinf(qua<T, Q> const& q) GLM_FUNC_QUALIFIER vec<4, bool, Q> isinf(qua<T, Q> const& q)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs");
return vec<4, bool, Q>(isinf(q.x), isinf(q.y), isinf(q.z), isinf(q.w)); return vec<4, bool, Q>(isinf(q.x), isinf(q.y), isinf(q.z), isinf(q.w));
} }

2
glm/ext/quaternion_geometric.inl
Unescape View File

@ -3,7 +3,7 @@ namespace glm
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(qua<T, Q> const& x, qua<T, Q> const& y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(qua<T, Q> const& x, qua<T, Q> const& y)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'dot' accepts only floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'dot' accepts only floating-point inputs");
return detail::compute_dot<qua<T, Q>, T, detail::is_aligned<Q>::value>::call(x, y); return detail::compute_dot<qua<T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
} }

18
glm/ext/scalar_common.inl
Unescape View File

@ -30,7 +30,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T fmin(T a, T b) GLM_FUNC_QUALIFIER T fmin(T a, T b)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input");
if (isnan(a)) if (isnan(a))
return b; return b;
@ -41,7 +41,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T fmin(T a, T b, T c) GLM_FUNC_QUALIFIER T fmin(T a, T b, T c)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input");
if (isnan(a)) if (isnan(a))
return fmin(b, c); return fmin(b, c);
@ -55,7 +55,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T fmin(T a, T b, T c, T d) GLM_FUNC_QUALIFIER T fmin(T a, T b, T c, T d)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input");
if (isnan(a)) if (isnan(a))
return fmin(b, c, d); return fmin(b, c, d);
@ -75,7 +75,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T fmax(T a, T b) GLM_FUNC_QUALIFIER T fmax(T a, T b)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input");
if (isnan(a)) if (isnan(a))
return b; return b;
@ -86,7 +86,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T fmax(T a, T b, T c) GLM_FUNC_QUALIFIER T fmax(T a, T b, T c)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input");
if (isnan(a)) if (isnan(a))
return fmax(b, c); return fmax(b, c);
@ -100,7 +100,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T fmax(T a, T b, T c, T d) GLM_FUNC_QUALIFIER T fmax(T a, T b, T c, T d)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input");
if (isnan(a)) if (isnan(a))
return fmax(b, c, d); return fmax(b, c, d);
@ -117,7 +117,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType fclamp(genType x, genType minVal, genType maxVal) GLM_FUNC_QUALIFIER genType fclamp(genType x, genType minVal, genType maxVal)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fclamp' only accept floating-point or integer inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fclamp' only accept floating-point or integer inputs");
return fmin(fmax(x, minVal), maxVal); return fmin(fmax(x, minVal), maxVal);
} }
@ -153,7 +153,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER int iround(genType const& x) GLM_FUNC_QUALIFIER int iround(genType const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'iround' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'iround' only accept floating-point inputs");
assert(static_cast<genType>(0.0) <= x); assert(static_cast<genType>(0.0) <= x);
return static_cast<int>(x + static_cast<genType>(0.5)); return static_cast<int>(x + static_cast<genType>(0.5));
@ -162,7 +162,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER uint uround(genType const& x) GLM_FUNC_QUALIFIER uint uround(genType const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'uround' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'uround' only accept floating-point inputs");
assert(static_cast<genType>(0.0) <= x); assert(static_cast<genType>(0.0) <= x);
return static_cast<uint>(x + static_cast<genType>(0.5)); return static_cast<uint>(x + static_cast<genType>(0.5));

4
glm/ext/scalar_constants.inl
Unescape View File

@ -5,14 +5,14 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon()
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'epsilon' only accepts floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'epsilon' only accepts floating-point inputs");
return std::numeric_limits<genType>::epsilon(); return std::numeric_limits<genType>::epsilon();
} }
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi()
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'pi' only accepts floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'pi' only accepts floating-point inputs");
return static_cast<genType>(3.14159265358979323846264338327950288); return static_cast<genType>(3.14159265358979323846264338327950288);
} }

4
glm/ext/scalar_integer.inl
Unescape View File

@ -26,7 +26,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
vec<L, T, Q> const Sign(sign(x)); vec<L, T, Q> const Sign(sign(x));
@ -48,7 +48,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
vec<L, T, Q> v(x); vec<L, T, Q> v(x);

24
glm/ext/scalar_reciprocal.inl
Unescape View File

@ -9,7 +9,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType sec(genType angle) GLM_FUNC_QUALIFIER genType sec(genType angle)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'sec' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sec' only accept floating-point values");
return genType(1) / glm::cos(angle); return genType(1) / glm::cos(angle);
} }
@ -17,7 +17,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType csc(genType angle) GLM_FUNC_QUALIFIER genType csc(genType angle)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'csc' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csc' only accept floating-point values");
return genType(1) / glm::sin(angle); return genType(1) / glm::sin(angle);
} }
@ -25,7 +25,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType cot(genType angle) GLM_FUNC_QUALIFIER genType cot(genType angle)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'cot' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cot' only accept floating-point values");
genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0); genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0);
return glm::tan(pi_over_2 - angle); return glm::tan(pi_over_2 - angle);
@ -35,7 +35,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType asec(genType x) GLM_FUNC_QUALIFIER genType asec(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'asec' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asec' only accept floating-point values");
return acos(genType(1) / x); return acos(genType(1) / x);
} }
@ -43,7 +43,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType acsc(genType x) GLM_FUNC_QUALIFIER genType acsc(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acsc' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsc' only accept floating-point values");
return asin(genType(1) / x); return asin(genType(1) / x);
} }
@ -51,7 +51,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType acot(genType x) GLM_FUNC_QUALIFIER genType acot(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acot' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acot' only accept floating-point values");
genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0); genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0);
return pi_over_2 - atan(x); return pi_over_2 - atan(x);
@ -61,7 +61,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType sech(genType angle) GLM_FUNC_QUALIFIER genType sech(genType angle)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'sech' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sech' only accept floating-point values");
return genType(1) / glm::cosh(angle); return genType(1) / glm::cosh(angle);
} }
@ -69,7 +69,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType csch(genType angle) GLM_FUNC_QUALIFIER genType csch(genType angle)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'csch' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csch' only accept floating-point values");
return genType(1) / glm::sinh(angle); return genType(1) / glm::sinh(angle);
} }
@ -77,7 +77,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType coth(genType angle) GLM_FUNC_QUALIFIER genType coth(genType angle)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'coth' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'coth' only accept floating-point values");
return glm::cosh(angle) / glm::sinh(angle); return glm::cosh(angle) / glm::sinh(angle);
} }
@ -85,7 +85,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType asech(genType x) GLM_FUNC_QUALIFIER genType asech(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'asech' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asech' only accept floating-point values");
return acosh(genType(1) / x); return acosh(genType(1) / x);
} }
@ -93,7 +93,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType acsch(genType x) GLM_FUNC_QUALIFIER genType acsch(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acsch' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsch' only accept floating-point values");
return asinh(genType(1) / x); return asinh(genType(1) / x);
} }
@ -101,7 +101,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType acoth(genType x) GLM_FUNC_QUALIFIER genType acoth(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acoth' only accept floating-point values"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acoth' only accept floating-point values");
return atanh(genType(1) / x); return atanh(genType(1) / x);
} }
}//namespace glm }//namespace glm

4
glm/ext/scalar_ulp.inl
Unescape View File

@ -219,7 +219,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T nextFloat(T x, int ULPs) GLM_FUNC_QUALIFIER T nextFloat(T x, int ULPs)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'next_float' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'next_float' only accept floating-point input");
assert(ULPs >= 0); assert(ULPs >= 0);
T temp = x; T temp = x;
@ -257,7 +257,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T prevFloat(T x, int ULPs) GLM_FUNC_QUALIFIER T prevFloat(T x, int ULPs)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'prev_float' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'prev_float' only accept floating-point input");
assert(ULPs >= 0); assert(ULPs >= 0);
T temp = x; T temp = x;

24
glm/ext/vector_reciprocal.inl
Unescape View File

@ -9,7 +9,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> sec(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> sec(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'sec' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sec' only accept floating-point inputs");
return static_cast<T>(1) / detail::functor1<vec, L, T, T, Q>::call(cos, x); return static_cast<T>(1) / detail::functor1<vec, L, T, T, Q>::call(cos, x);
} }
@ -17,7 +17,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> csc(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> csc(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'csc' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csc' only accept floating-point inputs");
return static_cast<T>(1) / detail::functor1<vec, L, T, T, Q>::call(sin, x); return static_cast<T>(1) / detail::functor1<vec, L, T, T, Q>::call(sin, x);
} }
@ -25,7 +25,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> cot(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> cot(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'cot' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cot' only accept floating-point inputs");
T const pi_over_2 = static_cast<T>(3.1415926535897932384626433832795 / 2.0); T const pi_over_2 = static_cast<T>(3.1415926535897932384626433832795 / 2.0);
return detail::functor1<vec, L, T, T, Q>::call(tan, pi_over_2 - x); return detail::functor1<vec, L, T, T, Q>::call(tan, pi_over_2 - x);
} }
@ -34,7 +34,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> asec(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> asec(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'asec' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asec' only accept floating-point inputs");
return detail::functor1<vec, L, T, T, Q>::call(acos, static_cast<T>(1) / x); return detail::functor1<vec, L, T, T, Q>::call(acos, static_cast<T>(1) / x);
} }
@ -42,7 +42,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> acsc(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> acsc(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acsc' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsc' only accept floating-point inputs");
return detail::functor1<vec, L, T, T, Q>::call(asin, static_cast<T>(1) / x); return detail::functor1<vec, L, T, T, Q>::call(asin, static_cast<T>(1) / x);
} }
@ -50,7 +50,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> acot(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> acot(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acot' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acot' only accept floating-point inputs");
T const pi_over_2 = static_cast<T>(3.1415926535897932384626433832795 / 2.0); T const pi_over_2 = static_cast<T>(3.1415926535897932384626433832795 / 2.0);
return pi_over_2 - detail::functor1<vec, L, T, T, Q>::call(atan, x); return pi_over_2 - detail::functor1<vec, L, T, T, Q>::call(atan, x);
} }
@ -59,7 +59,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> sech(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> sech(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'sech' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sech' only accept floating-point inputs");
return static_cast<T>(1) / detail::functor1<vec, L, T, T, Q>::call(cosh, x); return static_cast<T>(1) / detail::functor1<vec, L, T, T, Q>::call(cosh, x);
} }
@ -67,7 +67,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> csch(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> csch(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'csch' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csch' only accept floating-point inputs");
return static_cast<T>(1) / detail::functor1<vec, L, T, T, Q>::call(sinh, x); return static_cast<T>(1) / detail::functor1<vec, L, T, T, Q>::call(sinh, x);
} }
@ -75,7 +75,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> coth(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> coth(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'coth' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'coth' only accept floating-point inputs");
return glm::cosh(x) / glm::sinh(x); return glm::cosh(x) / glm::sinh(x);
} }
@ -83,7 +83,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> asech(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> asech(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'asech' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asech' only accept floating-point inputs");
return detail::functor1<vec, L, T, T, Q>::call(acosh, static_cast<T>(1) / x); return detail::functor1<vec, L, T, T, Q>::call(acosh, static_cast<T>(1) / x);
} }
@ -91,7 +91,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> acsch(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> acsch(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acsch' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsch' only accept floating-point inputs");
return detail::functor1<vec, L, T, T, Q>::call(asinh, static_cast<T>(1) / x); return detail::functor1<vec, L, T, T, Q>::call(asinh, static_cast<T>(1) / x);
} }
@ -99,7 +99,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> acoth(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER vec<L, T, Q> acoth(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'acoth' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acoth' only accept floating-point inputs");
return detail::functor1<vec, L, T, T, Q>::call(atanh, static_cast<T>(1) / x); return detail::functor1<vec, L, T, T, Q>::call(atanh, static_cast<T>(1) / x);
} }
}//namespace glm }//namespace glm

4
glm/gtc/ulp.inl
Unescape View File

@ -35,7 +35,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T next_float(T x, int ULPs) GLM_FUNC_QUALIFIER T next_float(T x, int ULPs)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'next_float' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'next_float' only accept floating-point input");
assert(ULPs >= 0); assert(ULPs >= 0);
T temp = x; T temp = x;
@ -73,7 +73,7 @@ namespace glm
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T prev_float(T x, int ULPs) GLM_FUNC_QUALIFIER T prev_float(T x, int ULPs)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'prev_float' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'prev_float' only accept floating-point input");
assert(ULPs >= 0); assert(ULPs >= 0);
T temp = x; T temp = x;

10
glm/gtx/common.inl
Unescape View File

@ -29,7 +29,7 @@ namespace detail
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER bool isdenormal(T const& x) GLM_FUNC_QUALIFIER bool isdenormal(T const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs");
# if GLM_HAS_CXX11_STL # if GLM_HAS_CXX11_STL
return std::fpclassify(x) == FP_SUBNORMAL; return std::fpclassify(x) == FP_SUBNORMAL;
@ -44,7 +44,7 @@ namespace detail
vec<1, T, Q> const& x vec<1, T, Q> const& x
) )
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs");
return typename vec<1, T, Q>::bool_type( return typename vec<1, T, Q>::bool_type(
isdenormal(x.x)); isdenormal(x.x));
@ -56,7 +56,7 @@ namespace detail
vec<2, T, Q> const& x vec<2, T, Q> const& x
) )
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs");
return typename vec<2, T, Q>::bool_type( return typename vec<2, T, Q>::bool_type(
isdenormal(x.x), isdenormal(x.x),
@ -69,7 +69,7 @@ namespace detail
vec<3, T, Q> const& x vec<3, T, Q> const& x
) )
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs");
return typename vec<3, T, Q>::bool_type( return typename vec<3, T, Q>::bool_type(
isdenormal(x.x), isdenormal(x.x),
@ -83,7 +83,7 @@ namespace detail
vec<4, T, Q> const& x vec<4, T, Q> const& x
) )
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs");
return typename vec<4, T, Q>::bool_type( return typename vec<4, T, Q>::bool_type(
isdenormal(x.x), isdenormal(x.x),

2
glm/gtx/exterior_product.inl
Unescape View File

@ -10,7 +10,7 @@ namespace detail
{ {
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'cross' accepts only floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cross' accepts only floating-point inputs");
return v.x * u.y - u.x * v.y; return v.x * u.y - u.x * v.y;
} }

6
glm/gtx/fast_square_root.inl
Unescape View File

@ -6,7 +6,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType fastSqrt(genType x) GLM_FUNC_QUALIFIER genType fastSqrt(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fastSqrt' only accept floating-point input"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastSqrt' only accept floating-point input");
return genType(1) / fastInverseSqrt(x); return genType(1) / fastInverseSqrt(x);
} }
@ -34,7 +34,7 @@ namespace glm
template<typename genType> template<typename genType>
GLM_FUNC_QUALIFIER genType fastLength(genType x) GLM_FUNC_QUALIFIER genType fastLength(genType x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fastLength' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastLength' only accept floating-point inputs");
return abs(x); return abs(x);
} }
@ -42,7 +42,7 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER T fastLength(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER T fastLength(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'fastLength' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastLength' only accept floating-point inputs");
return fastSqrt(dot(x, x)); return fastSqrt(dot(x, x));
} }

6
glm/gtx/vector_angle.inl
Unescape View File

@ -16,14 +16,14 @@ namespace glm
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER T angle(vec<L, T, Q> const& x, vec<L, T, Q> const& y) GLM_FUNC_QUALIFIER T angle(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'angle' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'angle' only accept floating-point inputs");
return acos(clamp(dot(x, y), T(-1), T(1))); return acos(clamp(dot(x, y), T(-1), T(1)));
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y) GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'orientedAngle' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'orientedAngle' only accept floating-point inputs");
T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); T const Angle(acos(clamp(dot(x, y), T(-1), T(1))));
T const partialCross = x.x * y.y - y.x * x.y; T const partialCross = x.x * y.y - y.x * x.y;
@ -37,7 +37,7 @@ namespace glm
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref) GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_FORCE_UNRESTRICTED_FLOAT, "'orientedAngle' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'orientedAngle' only accept floating-point inputs");
T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); T const Angle(acos(clamp(dot(x, y), T(-1), T(1))));
return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0)); return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0));

Write Preview
Loading…
Cancel
Save