diff --git a/doc/api/a00023_source.html b/doc/api/a00023_source.html index 73a0ccfdb..57bc29141 100644 --- a/doc/api/a00023_source.html +++ b/doc/api/a00023_source.html @@ -87,7 +87,7 @@ $(function() {
15  {
16  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
17  {
-
18  GLM_STATIC_ASSERT(
+
18  static_assert(
19  std::numeric_limits<genFIType>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits<genFIType>::is_signed,
20  "'abs' only accept floating-point and integer scalar or vector inputs");
21 
@@ -112,7 +112,7 @@ $(function() {
40  {
41  GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x)
42  {
-
43  GLM_STATIC_ASSERT(
+
43  static_assert(
44  (!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
45  "'abs' only accept floating-point and integer scalar or vector inputs");
46  return x;
diff --git a/doc/api/a00035_source.html b/doc/api/a00035_source.html index 504e985c3..a0ee7e4d2 100644 --- a/doc/api/a00035_source.html +++ b/doc/api/a00035_source.html @@ -501,11 +501,11 @@ $(function() {
438 // Static assert
439 
440 #if GLM_HAS_STATIC_ASSERT
-
441 # define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
+
441 # define static_assert(x, message) static_assert(x, message)
442 #elif GLM_COMPILER & GLM_COMPILER_VC
-
443 # define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
+
443 # define static_assert(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
444 #else
-
445 # define GLM_STATIC_ASSERT(x, message) assert(x)
+
445 # define static_assert(x, message) assert(x)
446 #endif//GLM_LANG
447 
449 // Qualifiers
diff --git a/doc/api/a00740_source.html b/doc/api/a00740_source.html index fbf09be38..304ad4623 100644 --- a/doc/api/a00740_source.html +++ b/doc/api/a00740_source.html @@ -97,19 +97,19 @@ $(function() {
32  template<std::size_t I,glm::length_t L,typename T,glm::qualifier Q>
33  struct tuple_element<I, glm::vec<L,T,Q>>
34  {
-
35  GLM_STATIC_ASSERT(I < L,"Index out of bounds");
+
35  static_assert(I < L,"Index out of bounds");
36  typedef T type;
37  };
38  template<std::size_t I, glm::length_t C, glm::length_t R, typename T, glm::qualifier Q>
39  struct tuple_element<I, glm::mat<C,R, T, Q>>
40  {
-
41  GLM_STATIC_ASSERT(I < C, "Index out of bounds");
+
41  static_assert(I < C, "Index out of bounds");
42  typedef glm::vec<R,T,Q> type;
43  };
44  template<std::size_t I, typename T, glm::qualifier Q>
45  struct tuple_element<I, glm::qua<T, Q>>
46  {
-
47  GLM_STATIC_ASSERT(I < 4, "Index out of bounds");
+
47  static_assert(I < 4, "Index out of bounds");
48  typedef T type;
49  };
50 
diff --git a/glm/detail/compute_common.hpp b/glm/detail/compute_common.hpp index 83362bc7b..127d2479d 100644 --- a/glm/detail/compute_common.hpp +++ b/glm/detail/compute_common.hpp @@ -15,7 +15,7 @@ namespace detail { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) { - GLM_STATIC_ASSERT( + static_assert( std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_signed, "'abs' only accept floating-point and integer scalar or vector inputs"); @@ -40,7 +40,7 @@ namespace detail { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) { - GLM_STATIC_ASSERT( + static_assert( (!std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'abs' only accept floating-point and integer scalar or vector inputs"); return x; diff --git a/glm/detail/func_common.inl b/glm/detail/func_common.inl index 37314596d..390541528 100644 --- a/glm/detail/func_common.inl +++ b/glm/detail/func_common.inl @@ -16,7 +16,7 @@ namespace glm template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType min(genType x, genType y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); return (y < x) ? y : x; } @@ -24,7 +24,7 @@ namespace glm template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType max(genType x, genType y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); return (x < y) ? y : x; } @@ -89,7 +89,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, vec const& a) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return vec(vec(x) * (static_cast(1) - a) + vec(y) * a); } @@ -112,7 +112,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, U const& a) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return vec(vec(x) * (static_cast(1) - a) + vec(y) * a); } @@ -132,7 +132,7 @@ namespace detail { GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, U const& a) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); return static_cast(static_cast(x) * (static_cast(1) - a) + static_cast(y) * a); } @@ -220,7 +220,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& a, vec const& b) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'mod' only accept floating-point inputs. Include for integer inputs."); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'mod' only accept floating-point inputs. Include for integer inputs."); return a - b * floor(a / b); } }; @@ -275,7 +275,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& edge0, vec const& edge1, vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs"); vec const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast(0), static_cast(1))); return tmp * tmp * (static_cast(3) - static_cast(2) * tmp); } @@ -349,7 +349,7 @@ namespace detail template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genFIType sign(genFIType x) { - GLM_STATIC_ASSERT( + static_assert( std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || (std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'sign' only accept signed inputs"); @@ -360,7 +360,7 @@ namespace detail template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec sign(vec const& x) { - GLM_STATIC_ASSERT( + static_assert( std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || (std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'sign' only accept signed inputs"); @@ -372,21 +372,21 @@ namespace detail template GLM_FUNC_QUALIFIER vec floor(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'floor' only accept floating-point inputs."); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'floor' only accept floating-point inputs."); return detail::compute_floor::value>::call(x); } template GLM_FUNC_QUALIFIER vec trunc(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'trunc' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'trunc' only accept floating-point inputs"); return detail::compute_trunc::value>::call(x); } template GLM_FUNC_QUALIFIER vec round(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'round' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'round' only accept floating-point inputs"); return detail::compute_round::value>::call(x); } @@ -395,8 +395,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType roundEven(genType const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); - + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); return genType(int(x + genType(int(x) % 2))); } */ @@ -405,7 +404,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType roundEven(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); int Integer = static_cast(x); genType IntegerPart = static_cast(Integer); @@ -436,7 +435,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec roundEven(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'roundEven' only accept floating-point inputs"); return detail::functor1::call(roundEven, x); } @@ -445,7 +444,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec ceil(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceil' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceil' only accept floating-point inputs"); return detail::compute_ceil::value>::call(x); } @@ -459,7 +458,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec fract(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fract' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fract' only accept floating-point inputs"); return detail::compute_fract::value>::call(x); } @@ -547,7 +546,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType modf(genType x, genType & i) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'modf' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'modf' only accept floating-point inputs"); return std::modf(x, &i); } @@ -597,7 +596,7 @@ namespace detail template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec min(vec const& a, T b) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); return detail::compute_min_vector::value>::call(a, vec(b)); } @@ -611,7 +610,7 @@ namespace detail template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec max(vec const& a, T b) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); return detail::compute_max_vector::value>::call(a, vec(b)); } @@ -625,21 +624,21 @@ namespace detail template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType clamp(genType x, genType minVal, genType maxVal) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); return min(max(x, minVal), maxVal); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec clamp(vec const& x, T minVal, T maxVal) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); return detail::compute_clamp_vector::value>::call(x, vec(minVal), vec(maxVal)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec clamp(vec const& x, vec const& minVal, vec const& maxVal) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_integer, "'clamp' only accept floating-point or integer inputs"); return detail::compute_clamp_vector::value>::call(x, minVal, maxVal); } @@ -684,7 +683,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs"); + static_assert(std::numeric_limits::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))); return tmp * tmp * (genType(3) - genType(2) * tmp); @@ -707,7 +706,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec isnan(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs"); vec Result(0); for (length_t l = 0; l < v.length(); ++l) @@ -720,7 +719,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec isinf(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs"); vec Result(0); for (length_t l = 0; l < v.length(); ++l) @@ -809,7 +808,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType frexp(genType x, int& exp) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'frexp' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'frexp' only accept floating-point inputs"); return std::frexp(x, &exp); } @@ -817,7 +816,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec frexp(vec const& v, vec& exp) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'frexp' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'frexp' only accept floating-point inputs"); vec Result(0); for (length_t l = 0; l < v.length(); ++l) @@ -828,7 +827,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType ldexp(genType const& x, int const& exp) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ldexp' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ldexp' only accept floating-point inputs"); return std::ldexp(x, exp); } @@ -836,7 +835,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec ldexp(vec const& v, vec const& exp) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ldexp' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ldexp' only accept floating-point inputs"); vec Result(0); for (length_t l = 0; l < v.length(); ++l) diff --git a/glm/detail/func_exponential.inl b/glm/detail/func_exponential.inl index fc7695def..167d91d30 100644 --- a/glm/detail/func_exponential.inl +++ b/glm/detail/func_exponential.inl @@ -17,7 +17,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'log2' only accept floating-point inputs. Include for integer inputs."); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'log2' only accept floating-point inputs. Include for integer inputs."); return detail::functor1::call(log2, v); } @@ -108,7 +108,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec sqrt(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sqrt' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sqrt' only accept floating-point inputs"); return detail::compute_sqrt::value>::call(x); } @@ -122,7 +122,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec inversesqrt(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'inversesqrt' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'inversesqrt' only accept floating-point inputs"); return detail::compute_inversesqrt::value>::call(x); } }//namespace glm diff --git a/glm/detail/func_geometric.inl b/glm/detail/func_geometric.inl index 8f3cc7734..aea7a715e 100644 --- a/glm/detail/func_geometric.inl +++ b/glm/detail/func_geometric.inl @@ -74,7 +74,7 @@ namespace detail { GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<3, T, Q> call(vec<3, T, Q> const& x, vec<3, T, Q> const& y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); return vec<3, T, Q>( x.y * y.z - y.y * x.z, @@ -84,7 +84,7 @@ namespace detail GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<4, T, Q> call(vec<4, T, Q> const& x, vec<4, T, Q> const& y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); return vec<4, T, Q>( x.y * y.z - y.y * x.z, @@ -99,7 +99,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return v * inversesqrt(dot(v, v)); } @@ -110,7 +110,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& N, vec const& I, vec const& Nref) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return dot(Nref, I) < static_cast(0) ? N : -N; } @@ -143,7 +143,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType length(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); return abs(x); } @@ -151,7 +151,7 @@ namespace detail template GLM_FUNC_QUALIFIER T length(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); return detail::compute_length::value>::call(v); } @@ -160,7 +160,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType distance(genType const& p0, genType const& p1) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'distance' accepts only floating-point inputs"); return length(p1 - p0); } @@ -175,14 +175,14 @@ namespace detail template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(T x, T y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return x * y; } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(vec const& x, vec const& y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); } @@ -197,7 +197,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType normalize(genType const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return x < genType(0) ? genType(-1) : genType(1); } @@ -205,7 +205,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec normalize(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); return detail::compute_normalize::value>::call(x); } @@ -240,7 +240,7 @@ namespace detail template GLM_FUNC_QUALIFIER genType refract(genType const& I, genType const& N, genType eta) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); genType const dotValue(dot(N, I)); genType const k(static_cast(1) - eta * eta * (static_cast(1) - dotValue * dotValue)); return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast(k >= static_cast(0)); @@ -249,7 +249,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec refract(vec const& I, vec const& N, T eta) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); return detail::compute_refract::value>::call(I, N, eta); } }//namespace glm diff --git a/glm/detail/func_integer.inl b/glm/detail/func_integer.inl index d0f6a84d5..739606db9 100644 --- a/glm/detail/func_integer.inl +++ b/glm/detail/func_integer.inl @@ -253,7 +253,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec bitfieldExtract(vec const& Value, int Offset, int Bits) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldExtract' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'bitfieldExtract' only accept integer inputs"); return (Value >> static_cast(Offset)) & static_cast(detail::mask(Bits)); } @@ -262,7 +262,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const& Base, genIUType const& Insert, int Offset, int Bits) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldInsert' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldInsert' only accept integer values"); return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x; } @@ -270,7 +270,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec bitfieldInsert(vec const& Base, vec const& Insert, int Offset, int Bits) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldInsert' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldInsert' only accept integer values"); T const Mask = detail::mask(static_cast(Bits)) << Offset; return (Base & ~Mask) | ((Insert << static_cast(Offset)) & Mask); @@ -285,7 +285,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); return bitfieldReverse(glm::vec<1, genIUType, glm::defaultp>(x)).x; } @@ -293,7 +293,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec bitfieldReverse(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); vec x(v); x = detail::compute_bitfieldReverseStep::value, sizeof(T) * 8>= 2>::call(x, static_cast(0x5555555555555555ull), static_cast( 1)); @@ -313,7 +313,7 @@ namespace detail template GLM_FUNC_QUALIFIER int bitCount(genIUType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); return bitCount(glm::vec<1, genIUType, glm::defaultp>(x)).x; } @@ -321,7 +321,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec bitCount(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) @@ -346,7 +346,7 @@ namespace detail template GLM_FUNC_QUALIFIER int findLSB(genIUType Value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); return detail::compute_findLSB::call(Value); } @@ -354,7 +354,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec findLSB(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); return detail::functor1::call(findLSB, x); } @@ -363,7 +363,7 @@ namespace detail template GLM_FUNC_QUALIFIER int findMSB(genIUType v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); return findMSB(vec<1, genIUType>(v)).x; } @@ -371,7 +371,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec findMSB(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); return detail::compute_findMSB_vec(sizeof(T) * 8)>::call(v); } diff --git a/glm/detail/func_matrix.inl b/glm/detail/func_matrix.inl index 9c7f7eb76..d44f0a30a 100644 --- a/glm/detail/func_matrix.inl +++ b/glm/detail/func_matrix.inl @@ -20,7 +20,7 @@ namespace detail struct compute_matrixCompMult_type { GLM_FUNC_QUALIFIER static mat call(mat const& x, mat const& y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs, include to discard this restriction."); return detail::compute_matrixCompMult::value>::call(x, y); } @@ -41,7 +41,7 @@ namespace detail struct compute_outerProduct_type { GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait::type call(vec const& c, vec const& r) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs, include to discard this restriction."); return detail::compute_outerProduct::call(c, r); @@ -231,7 +231,7 @@ namespace detail struct compute_transpose_type { GLM_FUNC_QUALIFIER static mat call(mat const& m) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs, include to discard this restriction."); return detail::compute_transpose::value>::call(m); } @@ -290,7 +290,7 @@ namespace detail GLM_FUNC_QUALIFIER static T call(mat const& m) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs, include to discard this restriction."); return detail::compute_determinant::value>::call(m); } @@ -473,7 +473,7 @@ namespace detail template GLM_FUNC_QUALIFIER mat inverse(mat const& m) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs"); return detail::compute_inverse::value>::call(m); } }//namespace glm diff --git a/glm/detail/func_matrix_simd.inl b/glm/detail/func_matrix_simd.inl index 9e47bf707..1db701b55 100644 --- a/glm/detail/func_matrix_simd.inl +++ b/glm/detail/func_matrix_simd.inl @@ -12,7 +12,7 @@ namespace detail template struct compute_matrixCompMult<4, 4, float, Q, true> { - GLM_STATIC_ASSERT(detail::is_aligned::value, "Specialization requires aligned"); + static_assert(detail::is_aligned::value, "Specialization requires aligned"); GLM_FUNC_QUALIFIER static mat<4, 4, float, Q> call(mat<4, 4, float, Q> const& x, mat<4, 4, float, Q> const& y) { diff --git a/glm/detail/func_trigonometric.inl b/glm/detail/func_trigonometric.inl index c31937feb..1f8fbc77f 100644 --- a/glm/detail/func_trigonometric.inl +++ b/glm/detail/func_trigonometric.inl @@ -8,7 +8,7 @@ namespace glm template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'radians' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'radians' only accept floating-point input"); return degrees * static_cast(0.01745329251994329576923690768489); } @@ -23,7 +23,7 @@ namespace glm template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'degrees' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'degrees' only accept floating-point input"); return radians * static_cast(57.295779513082320876798154814105); } @@ -83,7 +83,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType atan(genType y, genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'atan' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'atan' only accept floating-point input"); return ::std::atan2(y, x); } diff --git a/glm/detail/setup.hpp b/glm/detail/setup.hpp index 7f208303b..946d35b03 100644 --- a/glm/detail/setup.hpp +++ b/glm/detail/setup.hpp @@ -144,18 +144,6 @@ /////////////////////////////////////////////////////////////////////////////////// // Has of C++ features -// N1720 -#if GLM_COMPILER & GLM_COMPILER_CLANG -# define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert) -#elif GLM_LANG & GLM_LANG_CXX11_FLAG -# define GLM_HAS_STATIC_ASSERT 1 -#else -# define GLM_HAS_STATIC_ASSERT ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\ - ((GLM_COMPILER & GLM_COMPILER_CUDA)) || \ - ((GLM_COMPILER & GLM_COMPILER_VC)) || \ - ((GLM_COMPILER & GLM_COMPILER_HIP)))) -#endif - // N1988 #if GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_EXTENDED_INTEGER_TYPE 1 @@ -411,17 +399,6 @@ # define GLM_NULLPTR 0 #endif -/////////////////////////////////////////////////////////////////////////////////// -// Static assert - -#if GLM_HAS_STATIC_ASSERT -# define GLM_STATIC_ASSERT(x, message) static_assert(x, message) -#elif GLM_COMPILER & GLM_COMPILER_VC -# define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1] -#else -# define GLM_STATIC_ASSERT(x, message) assert(x) -#endif//GLM_LANG - /////////////////////////////////////////////////////////////////////////////////// // Qualifiers diff --git a/glm/detail/type_mat4x4.inl b/glm/detail/type_mat4x4.inl index 9b8120347..270c07b79 100644 --- a/glm/detail/type_mat4x4.inl +++ b/glm/detail/type_mat4x4.inl @@ -122,25 +122,25 @@ namespace glm : value{col_type(x1, y1, z1, w1), col_type(x2, y2, z2, w2), col_type(x3, y3, z3, w3), col_type(x4, y4, z4, w4)} # endif { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid."); # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(x1, y1, z1, w1); @@ -157,10 +157,10 @@ namespace glm : value{col_type(v1), col_type(v2), col_type(v3), col_type(v4)} # endif { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid."); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid."); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_CONFIG_UNRESTRICTED_GENTYPE, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid."); # if !GLM_HAS_INITIALIZER_LISTS this->value[0] = col_type(v1); diff --git a/glm/ext/quaternion_common.inl b/glm/ext/quaternion_common.inl index ad171f9d4..fb2556d1e 100644 --- a/glm/ext/quaternion_common.inl +++ b/glm/ext/quaternion_common.inl @@ -3,7 +3,7 @@ namespace glm template GLM_FUNC_QUALIFIER qua mix(qua const& x, qua const& y, T a) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'mix' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'mix' only accept floating-point inputs"); T const cosTheta = dot(x, y); @@ -28,7 +28,7 @@ namespace glm template GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua lerp(qua const& x, qua const& y, T a) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'lerp' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'lerp' only accept floating-point inputs"); // Lerp is only defined in [0, 1] assert(a >= static_cast(0)); @@ -40,7 +40,7 @@ namespace glm template GLM_FUNC_QUALIFIER qua slerp(qua const& x, qua const& y, T a) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'slerp' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'slerp' only accept floating-point inputs"); qua z = y; @@ -75,8 +75,8 @@ namespace glm template GLM_FUNC_QUALIFIER qua slerp(qua const& x, qua const& y, T a, S k) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'slerp' only accept floating-point inputs"); - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'slerp' only accept integer for spin count"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'slerp' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_integer, "'slerp' only accept integer for spin count"); qua z = y; @@ -124,7 +124,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec<4, bool, Q> isnan(qua const& q) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isnan' only accept floating-point inputs"); + static_assert(std::numeric_limits::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)); } @@ -132,7 +132,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec<4, bool, Q> isinf(qua const& q) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isinf' only accept floating-point inputs"); + static_assert(std::numeric_limits::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)); } diff --git a/glm/ext/quaternion_geometric.inl b/glm/ext/quaternion_geometric.inl index e68eec99b..c7a7a3363 100644 --- a/glm/ext/quaternion_geometric.inl +++ b/glm/ext/quaternion_geometric.inl @@ -3,7 +3,7 @@ namespace glm template GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(qua const& x, qua const& y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'dot' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'dot' accepts only floating-point inputs"); return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); } diff --git a/glm/ext/scalar_common.inl b/glm/ext/scalar_common.inl index 7e457b15e..afb02ace2 100644 --- a/glm/ext/scalar_common.inl +++ b/glm/ext/scalar_common.inl @@ -29,7 +29,7 @@ namespace glm template GLM_FUNC_QUALIFIER T (fmin)(T a, T b, T c) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input"); if (isnan(a)) return (fmin)(b, c); @@ -43,7 +43,7 @@ namespace glm template GLM_FUNC_QUALIFIER T (fmin)(T a, T b, T c, T d) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmin' only accept floating-point input"); if (isnan(a)) return (fmin)(b, c, d); @@ -61,7 +61,7 @@ namespace glm template GLM_FUNC_QUALIFIER T (fmax)(T a, T b, T c) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input"); if (isnan(a)) return (fmax)(b, c); @@ -75,7 +75,7 @@ namespace glm template GLM_FUNC_QUALIFIER T (fmax)(T a, T b, T c, T d) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fmax' only accept floating-point input"); if (isnan(a)) return (fmax)(b, c, d); @@ -92,7 +92,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType fclamp(genType x, genType minVal, genType maxVal) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fclamp' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fclamp' only accept floating-point or integer inputs"); return fmin((fmax)(x, minVal), maxVal); } @@ -128,7 +128,7 @@ namespace glm template GLM_FUNC_QUALIFIER int iround(genType const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'iround' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'iround' only accept floating-point inputs"); assert(static_cast(0.0) <= x); return static_cast(x + static_cast(0.5)); @@ -137,7 +137,7 @@ namespace glm template GLM_FUNC_QUALIFIER uint uround(genType const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'uround' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'uround' only accept floating-point inputs"); assert(static_cast(0.0) <= x); return static_cast(x + static_cast(0.5)); diff --git a/glm/ext/scalar_constants.inl b/glm/ext/scalar_constants.inl index b928e5118..b7e283933 100644 --- a/glm/ext/scalar_constants.inl +++ b/glm/ext/scalar_constants.inl @@ -5,14 +5,14 @@ namespace glm template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'epsilon' only accepts floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'epsilon' only accepts floating-point inputs"); return std::numeric_limits::epsilon(); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'pi' only accepts floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'pi' only accepts floating-point inputs"); return static_cast(3.14159265358979323846264338327950288); } diff --git a/glm/ext/scalar_integer.inl b/glm/ext/scalar_integer.inl index d416197e8..73fa1618f 100644 --- a/glm/ext/scalar_integer.inl +++ b/glm/ext/scalar_integer.inl @@ -26,7 +26,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& x) { - GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); + static_assert(!std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); vec const Sign(sign(x)); @@ -48,7 +48,7 @@ namespace detail { GLM_FUNC_QUALIFIER static vec call(vec const& x) { - GLM_STATIC_ASSERT(!std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); + static_assert(!std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'ceilPowerOfTwo' only accept integer scalar or vector inputs"); vec v(x); @@ -159,7 +159,7 @@ namespace detail template GLM_FUNC_QUALIFIER bool isPowerOfTwo(genIUType Value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isPowerOfTwo' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'isPowerOfTwo' only accept integer inputs"); genIUType const Result = glm::abs(Value); return !(Result & (Result - 1)); @@ -168,7 +168,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIUType nextPowerOfTwo(genIUType value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextPowerOfTwo' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'nextPowerOfTwo' only accept integer inputs"); return detail::compute_ceilPowerOfTwo<1, genIUType, defaultp, std::numeric_limits::is_signed>::call(vec<1, genIUType, defaultp>(value)).x; } @@ -176,7 +176,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIUType prevPowerOfTwo(genIUType value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevPowerOfTwo' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'prevPowerOfTwo' only accept integer inputs"); return isPowerOfTwo(value) ? value : static_cast(static_cast(1) << static_cast(findMSB(value))); } @@ -184,7 +184,7 @@ namespace detail template GLM_FUNC_QUALIFIER bool isMultiple(genIUType Value, genIUType Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); return isMultiple(vec<1, genIUType>(Value), vec<1, genIUType>(Multiple)).x; } @@ -192,7 +192,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIUType nextMultiple(genIUType Source, genIUType Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); return detail::compute_ceilMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } @@ -200,7 +200,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIUType prevMultiple(genIUType Source, genIUType Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); return detail::compute_floorMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } @@ -208,7 +208,7 @@ namespace detail template GLM_FUNC_QUALIFIER int findNSB(genIUType x, int significantBitCount) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findNSB' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'findNSB' only accept integer inputs"); if(bitCount(x) < significantBitCount) return -1; diff --git a/glm/ext/scalar_reciprocal.inl b/glm/ext/scalar_reciprocal.inl index 0cd5f87b4..4b73ae154 100644 --- a/glm/ext/scalar_reciprocal.inl +++ b/glm/ext/scalar_reciprocal.inl @@ -9,7 +9,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType sec(genType angle) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sec' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sec' only accept floating-point values"); return genType(1) / glm::cos(angle); } @@ -17,7 +17,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType csc(genType angle) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csc' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csc' only accept floating-point values"); return genType(1) / glm::sin(angle); } @@ -25,7 +25,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType cot(genType angle) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cot' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cot' only accept floating-point values"); genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0); return glm::tan(pi_over_2 - angle); @@ -35,7 +35,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType asec(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asec' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asec' only accept floating-point values"); return acos(genType(1) / x); } @@ -43,7 +43,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType acsc(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsc' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsc' only accept floating-point values"); return asin(genType(1) / x); } @@ -51,7 +51,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType acot(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acot' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acot' only accept floating-point values"); genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0); return pi_over_2 - atan(x); @@ -61,7 +61,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType sech(genType angle) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sech' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sech' only accept floating-point values"); return genType(1) / glm::cosh(angle); } @@ -69,7 +69,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType csch(genType angle) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csch' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csch' only accept floating-point values"); return genType(1) / glm::sinh(angle); } @@ -77,7 +77,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType coth(genType angle) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'coth' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'coth' only accept floating-point values"); return glm::cosh(angle) / glm::sinh(angle); } @@ -85,7 +85,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType asech(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asech' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asech' only accept floating-point values"); return acosh(genType(1) / x); } @@ -93,7 +93,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType acsch(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsch' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsch' only accept floating-point values"); return asinh(genType(1) / x); } @@ -101,7 +101,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType acoth(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acoth' only accept floating-point values"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acoth' only accept floating-point values"); return atanh(genType(1) / x); } }//namespace glm diff --git a/glm/ext/scalar_ulp.inl b/glm/ext/scalar_ulp.inl index 1834a69dc..f69a4b340 100644 --- a/glm/ext/scalar_ulp.inl +++ b/glm/ext/scalar_ulp.inl @@ -210,7 +210,7 @@ namespace glm template GLM_FUNC_QUALIFIER T nextFloat(T x, int ULPs) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'nextFloat' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'nextFloat' only accept floating-point input"); assert(ULPs >= 0); T temp = x; @@ -232,7 +232,7 @@ namespace glm template GLM_FUNC_QUALIFIER T prevFloat(T x, int ULPs) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'prevFloat' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'prevFloat' only accept floating-point input"); assert(ULPs >= 0); T temp = x; diff --git a/glm/ext/vector_common.inl b/glm/ext/vector_common.inl index 67817fc55..67c2e10d3 100644 --- a/glm/ext/vector_common.inl +++ b/glm/ext/vector_common.inl @@ -5,84 +5,84 @@ namespace glm template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec min(vec const& x, vec const& y, vec const& z) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); return glm::min(glm::min(x, y), z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec min(vec const& x, vec const& y, vec const& z, vec const& w) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'min' only accept floating-point or integer inputs"); return glm::min(glm::min(x, y), glm::min(z, w)); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec max(vec const& x, vec const& y, vec const& z) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); return glm::max(glm::max(x, y), z); } template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec max(vec const& x, vec const& y, vec const& z, vec const& w) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); + static_assert(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer, "'max' only accept floating-point or integer inputs"); return glm::max(glm::max(x, y), glm::max(z, w)); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, T b) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); return detail::functor2::call(fmin, a, vec(b)); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, vec const& b) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); return detail::functor2::call(fmin, a, b); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, vec const& b, vec const& c) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); return fmin(fmin(a, b), c); } template GLM_FUNC_QUALIFIER vec fmin(vec const& a, vec const& b, vec const& c, vec const& d) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'fmin' only accept floating-point inputs"); return fmin(fmin(a, b), fmin(c, d)); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, T b) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); return detail::functor2::call(fmax, a, vec(b)); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, vec const& b) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); return detail::functor2::call(fmax, a, b); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, vec const& b, vec const& c) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); return fmax(fmax(a, b), c); } template GLM_FUNC_QUALIFIER vec fmax(vec const& a, vec const& b, vec const& c, vec const& d) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'fmax' only accept floating-point inputs"); return fmax(fmax(a, b), fmax(c, d)); } @@ -130,7 +130,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec iround(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); assert(all(lessThanEqual(vec(0), x))); return vec(x + static_cast(0.5)); @@ -139,7 +139,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec uround(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); assert(all(lessThanEqual(vec(0), x))); return vec(x + static_cast(0.5)); diff --git a/glm/ext/vector_integer.inl b/glm/ext/vector_integer.inl index cefb132e2..85c5887f1 100644 --- a/glm/ext/vector_integer.inl +++ b/glm/ext/vector_integer.inl @@ -5,7 +5,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec isPowerOfTwo(vec const& Value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isPowerOfTwo' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'isPowerOfTwo' only accept integer inputs"); vec const Result(abs(Value)); return equal(Result & (Result - vec(1)), vec(0)); @@ -14,7 +14,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec nextPowerOfTwo(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextPowerOfTwo' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'nextPowerOfTwo' only accept integer inputs"); return detail::compute_ceilPowerOfTwo::is_signed>::call(v); } @@ -22,7 +22,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec prevPowerOfTwo(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevPowerOfTwo' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'prevPowerOfTwo' only accept integer inputs"); return detail::functor1::call(prevPowerOfTwo, v); } @@ -30,7 +30,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec isMultiple(vec const& Value, T Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); return equal(Value % Multiple, vec(0)); } @@ -38,7 +38,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec isMultiple(vec const& Value, vec const& Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'isMultiple' only accept integer inputs"); return equal(Value % Multiple, vec(0)); } @@ -46,7 +46,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec nextMultiple(vec const& Source, T Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); return detail::functor2::call(nextMultiple, Source, vec(Multiple)); } @@ -54,7 +54,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec nextMultiple(vec const& Source, vec const& Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'nextMultiple' only accept integer inputs"); return detail::functor2::call(nextMultiple, Source, Multiple); } @@ -62,7 +62,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec prevMultiple(vec const& Source, T Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); return detail::functor2::call(prevMultiple, Source, vec(Multiple)); } @@ -70,7 +70,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec prevMultiple(vec const& Source, vec const& Multiple) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'prevMultiple' only accept integer inputs"); return detail::functor2::call(prevMultiple, Source, Multiple); } @@ -78,7 +78,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec findNSB(vec const& Source, vec SignificantBitCount) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findNSB' only accept integer inputs"); + static_assert(std::numeric_limits::is_integer, "'findNSB' only accept integer inputs"); return detail::functor2_vec_int::call(findNSB, Source, SignificantBitCount); } diff --git a/glm/ext/vector_reciprocal.inl b/glm/ext/vector_reciprocal.inl index b85102a2f..cfa66fcae 100644 --- a/glm/ext/vector_reciprocal.inl +++ b/glm/ext/vector_reciprocal.inl @@ -9,7 +9,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec sec(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sec' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sec' only accept floating-point inputs"); return static_cast(1) / detail::functor1::call(cos, x); } @@ -17,7 +17,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec csc(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csc' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csc' only accept floating-point inputs"); return static_cast(1) / detail::functor1::call(sin, x); } @@ -25,7 +25,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec cot(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cot' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cot' only accept floating-point inputs"); T const pi_over_2 = static_cast(3.1415926535897932384626433832795 / 2.0); return detail::functor1::call(tan, pi_over_2 - x); } @@ -34,7 +34,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec asec(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asec' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asec' only accept floating-point inputs"); return detail::functor1::call(acos, static_cast(1) / x); } @@ -42,7 +42,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec acsc(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsc' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsc' only accept floating-point inputs"); return detail::functor1::call(asin, static_cast(1) / x); } @@ -50,7 +50,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec acot(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acot' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acot' only accept floating-point inputs"); T const pi_over_2 = static_cast(3.1415926535897932384626433832795 / 2.0); return pi_over_2 - detail::functor1::call(atan, x); } @@ -59,7 +59,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec sech(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sech' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'sech' only accept floating-point inputs"); return static_cast(1) / detail::functor1::call(cosh, x); } @@ -67,7 +67,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec csch(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csch' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'csch' only accept floating-point inputs"); return static_cast(1) / detail::functor1::call(sinh, x); } @@ -75,7 +75,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec coth(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'coth' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'coth' only accept floating-point inputs"); return glm::cosh(x) / glm::sinh(x); } @@ -83,7 +83,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec asech(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asech' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'asech' only accept floating-point inputs"); return detail::functor1::call(acosh, static_cast(1) / x); } @@ -91,7 +91,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec acsch(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsch' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acsch' only accept floating-point inputs"); return detail::functor1::call(asinh, static_cast(1) / x); } @@ -99,7 +99,7 @@ namespace glm template GLM_FUNC_QUALIFIER vec acoth(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acoth' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'acoth' only accept floating-point inputs"); return detail::functor1::call(atanh, static_cast(1) / x); } }//namespace glm diff --git a/glm/gtc/bitfield.inl b/glm/gtc/bitfield.inl index cbfd3888c..786e7c1c5 100644 --- a/glm/gtc/bitfield.inl +++ b/glm/gtc/bitfield.inl @@ -229,7 +229,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIUType mask(genIUType Bits) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'mask' accepts only integer values"); + static_assert(std::numeric_limits::is_integer, "'mask' accepts only integer values"); return Bits >= static_cast(sizeof(genIUType) * 8) ? ~static_cast(0) : (static_cast(1) << Bits) - static_cast(1); } @@ -241,7 +241,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec mask(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'mask' accepts only integer values"); + static_assert(std::numeric_limits::is_integer, "'mask' accepts only integer values"); return detail::functor1::call(mask, v); } @@ -249,7 +249,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIType bitfieldRotateRight(genIType In, int Shift) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); int const BitSize = static_cast(sizeof(genIType) * 8); return (In << static_cast(Shift)) | (In >> static_cast(BitSize - Shift)); @@ -258,7 +258,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec bitfieldRotateRight(vec const& In, int Shift) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); int const BitSize = static_cast(sizeof(T) * 8); return (In << static_cast(Shift)) | (In >> static_cast(BitSize - Shift)); @@ -267,7 +267,7 @@ namespace detail template GLM_FUNC_QUALIFIER genIType bitfieldRotateLeft(genIType In, int Shift) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); int const BitSize = static_cast(sizeof(genIType) * 8); return (In >> static_cast(Shift)) | (In << static_cast(BitSize - Shift)); @@ -276,7 +276,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec bitfieldRotateLeft(vec const& In, int Shift) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); int const BitSize = static_cast(sizeof(T) * 8); return (In >> static_cast(Shift)) | (In << static_cast(BitSize - Shift)); diff --git a/glm/gtc/packing.inl b/glm/gtc/packing.inl index 30462bc53..97aba4b46 100644 --- a/glm/gtc/packing.inl +++ b/glm/gtc/packing.inl @@ -685,8 +685,8 @@ namespace detail template GLM_FUNC_QUALIFIER vec packUnorm(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); + static_assert(std::numeric_limits::is_integer, "uintType must be an integer type"); + static_assert(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(round(clamp(v, static_cast(0), static_cast(1)) * static_cast(std::numeric_limits::max()))); } @@ -694,8 +694,8 @@ namespace detail template GLM_FUNC_QUALIFIER vec unpackUnorm(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); + static_assert(std::numeric_limits::is_integer, "uintType must be an integer type"); + static_assert(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(v) * (static_cast(1) / static_cast(std::numeric_limits::max())); } @@ -703,8 +703,8 @@ namespace detail template GLM_FUNC_QUALIFIER vec packSnorm(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); + static_assert(std::numeric_limits::is_integer, "uintType must be an integer type"); + static_assert(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return vec(round(clamp(v , static_cast(-1), static_cast(1)) * static_cast(std::numeric_limits::max()))); } @@ -712,8 +712,8 @@ namespace detail template GLM_FUNC_QUALIFIER vec unpackSnorm(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "floatType must be a floating point type"); + static_assert(std::numeric_limits::is_integer, "uintType must be an integer type"); + static_assert(std::numeric_limits::is_iec559, "floatType must be a floating point type"); return clamp(vec(v) * (static_cast(1) / static_cast(std::numeric_limits::max())), static_cast(-1), static_cast(1)); } diff --git a/glm/gtc/ulp.inl b/glm/gtc/ulp.inl index 9f5b82d5c..e4d455c0c 100644 --- a/glm/gtc/ulp.inl +++ b/glm/gtc/ulp.inl @@ -19,7 +19,7 @@ namespace glm template GLM_FUNC_QUALIFIER T next_float(T x, int ULPs) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'next_float' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'next_float' only accept floating-point input"); assert(ULPs >= 0); T temp = x; @@ -41,7 +41,7 @@ namespace glm template GLM_FUNC_QUALIFIER T prev_float(T x, int ULPs) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'prev_float' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'prev_float' only accept floating-point input"); assert(ULPs >= 0); T temp = x; diff --git a/glm/gtx/common.inl b/glm/gtx/common.inl index d8ce11958..d194417d4 100644 --- a/glm/gtx/common.inl +++ b/glm/gtx/common.inl @@ -29,7 +29,7 @@ namespace detail template GLM_FUNC_QUALIFIER bool isdenormal(T const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); return std::fpclassify(x) == FP_SUBNORMAL; } @@ -40,7 +40,7 @@ namespace detail vec<1, T, Q> const& x ) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); return typename vec<1, T, Q>::bool_type( isdenormal(x.x)); @@ -52,7 +52,7 @@ namespace detail vec<2, T, Q> const& x ) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); return typename vec<2, T, Q>::bool_type( isdenormal(x.x), @@ -65,7 +65,7 @@ namespace detail vec<3, T, Q> const& x ) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); return typename vec<3, T, Q>::bool_type( isdenormal(x.x), @@ -79,7 +79,7 @@ namespace detail vec<4, T, Q> const& x ) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'isdenormal' only accept floating-point inputs"); return typename vec<4, T, Q>::bool_type( isdenormal(x.x), diff --git a/glm/gtx/component_wise.inl b/glm/gtx/component_wise.inl index a2eac83fb..c133928d4 100644 --- a/glm/gtx/component_wise.inl +++ b/glm/gtx/component_wise.inl @@ -78,7 +78,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec compNormalize(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter"); + static_assert(std::numeric_limits::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter"); return detail::compute_compNormalize::is_integer, std::numeric_limits::is_signed>::call(v); } @@ -86,7 +86,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec compScale(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter"); + static_assert(std::numeric_limits::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter"); return detail::compute_compScale::is_integer, std::numeric_limits::is_signed>::call(v); } diff --git a/glm/gtx/exterior_product.inl b/glm/gtx/exterior_product.inl index 690085d6f..324760719 100644 --- a/glm/gtx/exterior_product.inl +++ b/glm/gtx/exterior_product.inl @@ -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_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cross' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'cross' accepts only floating-point inputs"); return v.x * u.y - u.x * v.y; } diff --git a/glm/gtx/fast_square_root.inl b/glm/gtx/fast_square_root.inl index 60fdb7a5a..5a5757fae 100644 --- a/glm/gtx/fast_square_root.inl +++ b/glm/gtx/fast_square_root.inl @@ -6,7 +6,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType fastSqrt(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastSqrt' only accept floating-point input"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastSqrt' only accept floating-point input"); return genType(1) / fastInverseSqrt(x); } @@ -34,7 +34,7 @@ namespace glm template GLM_FUNC_QUALIFIER genType fastLength(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastLength' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastLength' only accept floating-point inputs"); return abs(x); } @@ -42,7 +42,7 @@ namespace glm template GLM_FUNC_QUALIFIER T fastLength(vec const& x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastLength' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'fastLength' only accept floating-point inputs"); return fastSqrt(dot(x, x)); } diff --git a/glm/gtx/norm.inl b/glm/gtx/norm.inl index 4a9f79645..cdaa560d0 100644 --- a/glm/gtx/norm.inl +++ b/glm/gtx/norm.inl @@ -18,28 +18,28 @@ namespace detail template GLM_FUNC_QUALIFIER genType length2(genType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'length2' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'length2' accepts only floating-point inputs"); return x * x; } template GLM_FUNC_QUALIFIER T length2(vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'length2' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'length2' accepts only floating-point inputs"); return detail::compute_length2::value>::call(v); } template GLM_FUNC_QUALIFIER T distance2(T p0, T p1) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'distance2' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'distance2' accepts only floating-point inputs"); return length2(p1 - p0); } template GLM_FUNC_QUALIFIER T distance2(vec const& p0, vec const& p1) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'distance2' accepts only floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'distance2' accepts only floating-point inputs"); return length2(p1 - p0); } diff --git a/glm/gtx/structured_bindings.hpp b/glm/gtx/structured_bindings.hpp index 8475007ca..2c39efd8f 100644 --- a/glm/gtx/structured_bindings.hpp +++ b/glm/gtx/structured_bindings.hpp @@ -32,19 +32,19 @@ namespace std { template struct tuple_element> { - GLM_STATIC_ASSERT(I < L,"Index out of bounds"); + static_assert(I < L,"Index out of bounds"); typedef T type; }; template struct tuple_element> { - GLM_STATIC_ASSERT(I < C, "Index out of bounds"); + static_assert(I < C, "Index out of bounds"); typedef glm::vec type; }; template struct tuple_element> { - GLM_STATIC_ASSERT(I < 4, "Index out of bounds"); + static_assert(I < 4, "Index out of bounds"); typedef T type; }; diff --git a/glm/gtx/structured_bindings.inl b/glm/gtx/structured_bindings.inl index 54d613bd3..694f58396 100644 --- a/glm/gtx/structured_bindings.inl +++ b/glm/gtx/structured_bindings.inl @@ -2,34 +2,34 @@ namespace glm { template GLM_CONSTEXPR T& get(vec& v) { - GLM_STATIC_ASSERT(I < L, "Index out of bounds"); + static_assert(I < L, "Index out of bounds"); return v[I]; } template GLM_CONSTEXPR T const& get(vec const& v) { - GLM_STATIC_ASSERT(I < L, "Index out of bounds"); + static_assert(I < L, "Index out of bounds"); return v[I]; } template GLM_CONSTEXPR vec& get(mat& m) { - GLM_STATIC_ASSERT(I < C, "Index out of bounds"); + static_assert(I < C, "Index out of bounds"); return m[I]; } template GLM_CONSTEXPR vec const& get(mat const& m) { - GLM_STATIC_ASSERT(I < C, "Index out of bounds"); + static_assert(I < C, "Index out of bounds"); return m[I]; } template GLM_CONSTEXPR T& get(qua& q) { - GLM_STATIC_ASSERT(I < 4, "Index out of bounds"); + static_assert(I < 4, "Index out of bounds"); return q[I]; } template GLM_CONSTEXPR T const& get(qua const& q) { - GLM_STATIC_ASSERT(I < 4, "Index out of bounds"); + static_assert(I < 4, "Index out of bounds"); return q[I]; } @@ -37,17 +37,17 @@ namespace glm template GLM_CONSTEXPR T get(vec const&& v) { - GLM_STATIC_ASSERT(I < L, "Index out of bounds"); + static_assert(I < L, "Index out of bounds"); return v[I]; } template GLM_CONSTEXPR vec get(mat const&& m) { - GLM_STATIC_ASSERT(I < C, "Index out of bounds"); + static_assert(I < C, "Index out of bounds"); return m[I]; } template GLM_CONSTEXPR T get(qua const&& q) { - GLM_STATIC_ASSERT(I < 4, "Index out of bounds"); + static_assert(I < 4, "Index out of bounds"); return q[I]; } #endif diff --git a/glm/gtx/vector_angle.inl b/glm/gtx/vector_angle.inl index 11e1a2183..deb540524 100644 --- a/glm/gtx/vector_angle.inl +++ b/glm/gtx/vector_angle.inl @@ -9,21 +9,21 @@ namespace glm genType const& y ) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); return acos(clamp(dot(x, y), genType(-1), genType(1))); } template GLM_FUNC_QUALIFIER T angle(vec const& x, vec const& y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'angle' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'angle' only accept floating-point inputs"); return acos(clamp(dot(x, y), T(-1), T(1))); } template GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'orientedAngle' only accept floating-point inputs"); + static_assert(std::numeric_limits::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 partialCross = x.x * y.y - y.x * x.y; @@ -37,7 +37,7 @@ namespace glm template 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::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'orientedAngle' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'orientedAngle' only accept floating-point inputs"); T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0)); diff --git a/glm/gtx/vector_query.inl b/glm/gtx/vector_query.inl index d1a5c9be4..299fb63fa 100644 --- a/glm/gtx/vector_query.inl +++ b/glm/gtx/vector_query.inl @@ -79,7 +79,7 @@ namespace detail template GLM_FUNC_QUALIFIER bool areCollinear(vec const& v0, vec const& v1, T const& epsilon) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'areCollinear' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'areCollinear' only accept floating-point inputs"); return detail::compute_areCollinear::call(v0, v1, epsilon); } @@ -87,7 +87,7 @@ namespace detail template GLM_FUNC_QUALIFIER bool areOrthogonal(vec const& v0, vec const& v1, T const& epsilon) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'areOrthogonal' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'areOrthogonal' only accept floating-point inputs"); return abs(dot(v0, v1)) <= max( static_cast(1), @@ -97,7 +97,7 @@ namespace detail template GLM_FUNC_QUALIFIER bool isNormalized(vec const& v, T const& epsilon) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isNormalized' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'isNormalized' only accept floating-point inputs"); return abs(length(v) - static_cast(1)) <= static_cast(2) * epsilon; } @@ -105,7 +105,7 @@ namespace detail template GLM_FUNC_QUALIFIER bool isNull(vec const& v, T const& epsilon) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isNull' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'isNull' only accept floating-point inputs"); return length(v) <= epsilon; } @@ -113,7 +113,7 @@ namespace detail template GLM_FUNC_QUALIFIER vec isCompNull(vec const& v, T const& epsilon) { - GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isCompNull' only accept floating-point inputs"); + static_assert(std::numeric_limits::is_iec559, "'isCompNull' only accept floating-point inputs"); return detail::compute_isCompNull::call(v, epsilon); } diff --git a/test/core/core_func_common.cpp b/test/core/core_func_common.cpp index 99eaa8798..80691491b 100644 --- a/test/core/core_func_common.cpp +++ b/test/core/core_func_common.cpp @@ -950,7 +950,7 @@ namespace sign template GLM_FUNC_QUALIFIER genFIType sign_if(genFIType x) { - GLM_STATIC_ASSERT( + static_assert( std::numeric_limits::is_iec559 || (std::numeric_limits::is_signed && std::numeric_limits::is_integer), "'sign' only accept signed inputs"); @@ -972,7 +972,7 @@ namespace sign template GLM_FUNC_QUALIFIER genFIType sign_alu1(genFIType x) { - GLM_STATIC_ASSERT( + static_assert( std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); @@ -985,7 +985,7 @@ namespace sign GLM_FUNC_QUALIFIER int sign_alu2(int x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); + static_assert(std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); # if GLM_COMPILER & GLM_COMPILER_VC # pragma warning(push) @@ -1002,7 +1002,7 @@ namespace sign template GLM_FUNC_QUALIFIER genFIType sign_sub(genFIType x) { - GLM_STATIC_ASSERT( + static_assert( std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); @@ -1012,7 +1012,7 @@ namespace sign template GLM_FUNC_QUALIFIER genFIType sign_cmp(genFIType x) { - GLM_STATIC_ASSERT( + static_assert( std::numeric_limits::is_signed && std::numeric_limits::is_integer, "'sign' only accept integer inputs"); diff --git a/test/core/core_func_integer.cpp b/test/core/core_func_integer.cpp index 268db0eae..d76018503 100644 --- a/test/core/core_func_integer.cpp +++ b/test/core/core_func_integer.cpp @@ -163,7 +163,7 @@ namespace bitfieldReverse template GLM_FUNC_QUALIFIER glm::vec bitfieldReverseLoop(glm::vec const& v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); glm::vec Result(0); T const BitSize = static_cast(sizeof(T) * 8); @@ -567,7 +567,7 @@ namespace findMSB template static int findMSB_intrinsic(genIUType Value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); if(Value == 0) return -1; @@ -582,7 +582,7 @@ namespace findMSB template static int findMSB_avx(genIUType Value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); if(Value == 0) return -1; @@ -594,7 +594,7 @@ namespace findMSB template static int findMSB_095(genIUType Value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); if(Value == genIUType(0) || Value == genIUType(-1)) return -1; @@ -618,7 +618,7 @@ namespace findMSB template static int findMSB_nlz1(genIUType x) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); if (x == 0) return -1; @@ -970,7 +970,7 @@ namespace findLSB template static int findLSB_intrinsic(genIUType Value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); if(Value == 0) return -1; @@ -984,7 +984,7 @@ namespace findLSB template static int findLSB_095(genIUType Value) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); if(Value == 0) return -1; @@ -1397,7 +1397,7 @@ namespace bitCount template inline int bitCount_if(T v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); int Count(0); for(T i = 0, n = static_cast(sizeof(T) * 8); i < n; ++i) @@ -1411,7 +1411,7 @@ namespace bitCount template inline int bitCount_vec(T v) { - GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); + static_assert(std::numeric_limits::is_integer, "'bitCount' only accept integer values"); int Count(0); for(T i = 0, n = static_cast(sizeof(T) * 8); i < n; ++i) diff --git a/test/ext/ext_matrix_int2x2_sized.cpp b/test/ext/ext_matrix_int2x2_sized.cpp index 93b6e8662..bf2d1c3b2 100644 --- a/test/ext/ext_matrix_int2x2_sized.cpp +++ b/test/ext/ext_matrix_int2x2_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT - static_assert(sizeof(glm::i8mat2x2) == 4, "int8 size isn't 1 byte on this platform"); - static_assert(sizeof(glm::i16mat2x2) == 8, "int16 size isn't 2 bytes on this platform"); - static_assert(sizeof(glm::i32mat2x2) == 16, "int32 size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::i64mat2x2) == 32, "int64 size isn't 8 bytes on this platform"); -#endif +static_assert(sizeof(glm::i8mat2x2) == 4, "int8 size isn't 1 byte on this platform"); +static_assert(sizeof(glm::i16mat2x2) == 8, "int16 size isn't 2 bytes on this platform"); +static_assert(sizeof(glm::i32mat2x2) == 16, "int32 size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::i64mat2x2) == 32, "int64 size isn't 8 bytes on this platform"); static int test_comp() { diff --git a/test/ext/ext_matrix_int2x3_sized.cpp b/test/ext/ext_matrix_int2x3_sized.cpp index 058f57be4..e9b09bfaf 100644 --- a/test/ext/ext_matrix_int2x3_sized.cpp +++ b/test/ext/ext_matrix_int2x3_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8mat2x3) == 6, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16mat2x3) == 12, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32mat2x3) == 24, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64mat2x3) == 48, "int64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_int2x4_sized.cpp b/test/ext/ext_matrix_int2x4_sized.cpp index c20198dae..783fc58a6 100644 --- a/test/ext/ext_matrix_int2x4_sized.cpp +++ b/test/ext/ext_matrix_int2x4_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8mat2x4) == 8, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16mat2x4) == 16, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32mat2x4) == 32, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64mat2x4) == 64, "int64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_int3x2_sized.cpp b/test/ext/ext_matrix_int3x2_sized.cpp index 1d14029ee..3df236fd6 100644 --- a/test/ext/ext_matrix_int3x2_sized.cpp +++ b/test/ext/ext_matrix_int3x2_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8mat3x2) == 6, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16mat3x2) == 12, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32mat3x2) == 24, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64mat3x2) == 48, "int64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_int3x3_sized.cpp b/test/ext/ext_matrix_int3x3_sized.cpp index d82836c49..831504bed 100644 --- a/test/ext/ext_matrix_int3x3_sized.cpp +++ b/test/ext/ext_matrix_int3x3_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8mat3x3) == 9, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16mat3x3) == 18, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32mat3x3) == 36, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64mat3x3) == 72, "int64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_int3x4_sized.cpp b/test/ext/ext_matrix_int3x4_sized.cpp index 52b7d52b8..c8f4152b8 100644 --- a/test/ext/ext_matrix_int3x4_sized.cpp +++ b/test/ext/ext_matrix_int3x4_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8mat3x4) == 12, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16mat3x4) == 24, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32mat3x4) == 48, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64mat3x4) == 96, "int64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_int4x2_sized.cpp b/test/ext/ext_matrix_int4x2_sized.cpp index 3c4566f9f..0459c2f63 100644 --- a/test/ext/ext_matrix_int4x2_sized.cpp +++ b/test/ext/ext_matrix_int4x2_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8mat4x2) == 8, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16mat4x2) == 16, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32mat4x2) == 32, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64mat4x2) == 64, "int64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_int4x3_sized.cpp b/test/ext/ext_matrix_int4x3_sized.cpp index fb882af7e..5af79f13b 100644 --- a/test/ext/ext_matrix_int4x3_sized.cpp +++ b/test/ext/ext_matrix_int4x3_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8mat4x3) == 12, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16mat4x3) == 24, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32mat4x3) == 48, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64mat4x3) == 96, "int64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_int4x4_sized.cpp b/test/ext/ext_matrix_int4x4_sized.cpp index 02769ea98..24a298634 100644 --- a/test/ext/ext_matrix_int4x4_sized.cpp +++ b/test/ext/ext_matrix_int4x4_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8mat4x4) == 16, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16mat4x4) == 32, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32mat4x4) == 64, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64mat4x4) == 128, "int64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_uint2x2_sized.cpp b/test/ext/ext_matrix_uint2x2_sized.cpp index a9bd49c73..57547158c 100644 --- a/test/ext/ext_matrix_uint2x2_sized.cpp +++ b/test/ext/ext_matrix_uint2x2_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT - static_assert(sizeof(glm::u8mat2x2) == 4, "uint8 size isn't 1 byte on this platform"); - static_assert(sizeof(glm::u16mat2x2) == 8, "uint16 size isn't 2 bytes on this platform"); - static_assert(sizeof(glm::u32mat2x2) == 16, "uint32 size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::u64mat2x2) == 32, "uint64 size isn't 8 bytes on this platform"); -#endif +static_assert(sizeof(glm::u8mat2x2) == 4, "uint8 size isn't 1 byte on this platform"); +static_assert(sizeof(glm::u16mat2x2) == 8, "uint16 size isn't 2 bytes on this platform"); +static_assert(sizeof(glm::u32mat2x2) == 16, "uint32 size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::u64mat2x2) == 32, "uint64 size isn't 8 bytes on this platform"); static int test_comp() { diff --git a/test/ext/ext_matrix_uint2x3_sized.cpp b/test/ext/ext_matrix_uint2x3_sized.cpp index 0b7589385..28a22c664 100644 --- a/test/ext/ext_matrix_uint2x3_sized.cpp +++ b/test/ext/ext_matrix_uint2x3_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8mat2x3) == 6, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16mat2x3) == 12, "uint16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32mat2x3) == 24, "uint32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64mat2x3) == 48, "uint64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_uint2x4_sized.cpp b/test/ext/ext_matrix_uint2x4_sized.cpp index 84af4dd11..284dfb094 100644 --- a/test/ext/ext_matrix_uint2x4_sized.cpp +++ b/test/ext/ext_matrix_uint2x4_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8mat2x4) == 8, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16mat2x4) == 16, "uint16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32mat2x4) == 32, "uint32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64mat2x4) == 64, "uint64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_uint3x2_sized.cpp b/test/ext/ext_matrix_uint3x2_sized.cpp index 3c035e23c..830ae02f1 100644 --- a/test/ext/ext_matrix_uint3x2_sized.cpp +++ b/test/ext/ext_matrix_uint3x2_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8mat3x2) == 6, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16mat3x2) == 12, "uint16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32mat3x2) == 24, "uint32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64mat3x2) == 48, "uint64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_uint3x3_sized.cpp b/test/ext/ext_matrix_uint3x3_sized.cpp index 64384ede3..312baab64 100644 --- a/test/ext/ext_matrix_uint3x3_sized.cpp +++ b/test/ext/ext_matrix_uint3x3_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8mat3x3) == 9, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16mat3x3) == 18, "uint16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32mat3x3) == 36, "uint32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64mat3x3) == 72, "uint64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_uint3x4_sized.cpp b/test/ext/ext_matrix_uint3x4_sized.cpp index 7f743dfe1..5787f1a60 100644 --- a/test/ext/ext_matrix_uint3x4_sized.cpp +++ b/test/ext/ext_matrix_uint3x4_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8mat3x4) == 12, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16mat3x4) == 24, "uint16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32mat3x4) == 48, "uint32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64mat3x4) == 96, "uint64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_uint4x2_sized.cpp b/test/ext/ext_matrix_uint4x2_sized.cpp index 2b4453f95..454640e07 100644 --- a/test/ext/ext_matrix_uint4x2_sized.cpp +++ b/test/ext/ext_matrix_uint4x2_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8mat4x2) == 8, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16mat4x2) == 16, "uint16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32mat4x2) == 32, "uint32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64mat4x2) == 64, "uint64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_uint4x3_sized.cpp b/test/ext/ext_matrix_uint4x3_sized.cpp index 2820bde19..f484252c3 100644 --- a/test/ext/ext_matrix_uint4x3_sized.cpp +++ b/test/ext/ext_matrix_uint4x3_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8mat4x3) == 12, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16mat4x3) == 24, "uint16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32mat4x3) == 48, "uint32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64mat4x3) == 96, "uint64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_matrix_uint4x4_sized.cpp b/test/ext/ext_matrix_uint4x4_sized.cpp index 8f9e239cf..bb80c2e7a 100644 --- a/test/ext/ext_matrix_uint4x4_sized.cpp +++ b/test/ext/ext_matrix_uint4x4_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8mat4x4) == 16, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16mat4x4) == 32, "uint16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32mat4x4) == 64, "uint32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64mat4x4) == 128, "uint64 size isn't 8 bytes on this platform"); -#endif static int test_comp() { diff --git a/test/ext/ext_scalar_int_sized.cpp b/test/ext/ext_scalar_int_sized.cpp index b55c6ca7f..d4c2d0166 100644 --- a/test/ext/ext_scalar_int_sized.cpp +++ b/test/ext/ext_scalar_int_sized.cpp @@ -1,13 +1,11 @@ #include -#if GLM_HAS_STATIC_ASSERT - static_assert(sizeof(glm::int8) == 1, "int8 size isn't 1 byte on this platform"); - static_assert(sizeof(glm::int16) == 2, "int16 size isn't 2 bytes on this platform"); - static_assert(sizeof(glm::int32) == 4, "int32 size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::int64) == 8, "int64 size isn't 8 bytes on this platform"); - static_assert(sizeof(glm::int16) == sizeof(short), "signed short size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::int32) == sizeof(int), "signed int size isn't 4 bytes on this platform"); -#endif +static_assert(sizeof(glm::int8) == 1, "int8 size isn't 1 byte on this platform"); +static_assert(sizeof(glm::int16) == 2, "int16 size isn't 2 bytes on this platform"); +static_assert(sizeof(glm::int32) == 4, "int32 size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::int64) == 8, "int64 size isn't 8 bytes on this platform"); +static_assert(sizeof(glm::int16) == sizeof(short), "signed short size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::int32) == sizeof(int), "signed int size isn't 4 bytes on this platform"); static int test_size() { diff --git a/test/ext/ext_scalar_uint_sized.cpp b/test/ext/ext_scalar_uint_sized.cpp index 1122947d4..2d4731a5f 100644 --- a/test/ext/ext_scalar_uint_sized.cpp +++ b/test/ext/ext_scalar_uint_sized.cpp @@ -1,13 +1,11 @@ #include -#if GLM_HAS_STATIC_ASSERT - static_assert(sizeof(glm::uint8) == 1, "uint8 size isn't 1 byte on this platform"); - static_assert(sizeof(glm::uint16) == 2, "uint16 size isn't 2 bytes on this platform"); - static_assert(sizeof(glm::uint32) == 4, "uint32 size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::uint64) == 8, "uint64 size isn't 8 bytes on this platform"); - static_assert(sizeof(glm::uint16) == sizeof(unsigned short), "unsigned short size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::uint32) == sizeof(unsigned int), "unsigned int size isn't 4 bytes on this platform"); -#endif +static_assert(sizeof(glm::uint8) == 1, "uint8 size isn't 1 byte on this platform"); +static_assert(sizeof(glm::uint16) == 2, "uint16 size isn't 2 bytes on this platform"); +static_assert(sizeof(glm::uint32) == 4, "uint32 size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::uint64) == 8, "uint64 size isn't 8 bytes on this platform"); +static_assert(sizeof(glm::uint16) == sizeof(unsigned short), "unsigned short size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::uint32) == sizeof(unsigned int), "unsigned int size isn't 4 bytes on this platform"); static int test_size() { diff --git a/test/ext/ext_vector_int1_sized.cpp b/test/ext/ext_vector_int1_sized.cpp index c262f495d..a4f73e0b8 100644 --- a/test/ext/ext_vector_int1_sized.cpp +++ b/test/ext/ext_vector_int1_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT - static_assert(sizeof(glm::i8vec1) == 1, "int8 size isn't 1 byte on this platform"); - static_assert(sizeof(glm::i16vec1) == 2, "int16 size isn't 2 bytes on this platform"); - static_assert(sizeof(glm::i32vec1) == 4, "int32 size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::i64vec1) == 8, "int64 size isn't 8 bytes on this platform"); -#endif +static_assert(sizeof(glm::i8vec1) == 1, "int8 size isn't 1 byte on this platform"); +static_assert(sizeof(glm::i16vec1) == 2, "int16 size isn't 2 bytes on this platform"); +static_assert(sizeof(glm::i32vec1) == 4, "int32 size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::i64vec1) == 8, "int64 size isn't 8 bytes on this platform"); static int test_size() { diff --git a/test/ext/ext_vector_int2_sized.cpp b/test/ext/ext_vector_int2_sized.cpp index f4ad8b6be..20a079ba9 100644 --- a/test/ext/ext_vector_int2_sized.cpp +++ b/test/ext/ext_vector_int2_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT - static_assert(sizeof(glm::i8vec2) == 2, "int8 size isn't 1 byte on this platform"); - static_assert(sizeof(glm::i16vec2) == 4, "int16 size isn't 2 bytes on this platform"); - static_assert(sizeof(glm::i32vec2) == 8, "int32 size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::i64vec2) == 16, "int64 size isn't 8 bytes on this platform"); -#endif +static_assert(sizeof(glm::i8vec2) == 2, "int8 size isn't 1 byte on this platform"); +static_assert(sizeof(glm::i16vec2) == 4, "int16 size isn't 2 bytes on this platform"); +static_assert(sizeof(glm::i32vec2) == 8, "int32 size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::i64vec2) == 16, "int64 size isn't 8 bytes on this platform"); static int test_size() { diff --git a/test/ext/ext_vector_int3_sized.cpp b/test/ext/ext_vector_int3_sized.cpp index c51bfe712..84dff428f 100644 --- a/test/ext/ext_vector_int3_sized.cpp +++ b/test/ext/ext_vector_int3_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT - static_assert(sizeof(glm::i8vec3) == 3, "int8 size isn't 1 byte on this platform"); - static_assert(sizeof(glm::i16vec3) == 6, "int16 size isn't 2 bytes on this platform"); - static_assert(sizeof(glm::i32vec3) == 12, "int32 size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::i64vec3) == 24, "int64 size isn't 8 bytes on this platform"); -#endif +static_assert(sizeof(glm::i8vec3) == 3, "int8 size isn't 1 byte on this platform"); +static_assert(sizeof(glm::i16vec3) == 6, "int16 size isn't 2 bytes on this platform"); +static_assert(sizeof(glm::i32vec3) == 12, "int32 size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::i64vec3) == 24, "int64 size isn't 8 bytes on this platform"); static int test_size() { diff --git a/test/ext/ext_vector_int4_sized.cpp b/test/ext/ext_vector_int4_sized.cpp index 93fd9ed2f..b51e955e3 100644 --- a/test/ext/ext_vector_int4_sized.cpp +++ b/test/ext/ext_vector_int4_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::i8vec4) == 4, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::i16vec4) == 8, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::i32vec4) == 16, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::i64vec4) == 32, "int64 size isn't 8 bytes on this platform"); -#endif static int test_size() { diff --git a/test/ext/ext_vector_uint1_sized.cpp b/test/ext/ext_vector_uint1_sized.cpp index f2e4624f8..d916a73d1 100644 --- a/test/ext/ext_vector_uint1_sized.cpp +++ b/test/ext/ext_vector_uint1_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT - static_assert(sizeof(glm::u8vec1) == 1, "uint8 size isn't 1 byte on this platform"); - static_assert(sizeof(glm::u16vec1) == 2, "uint16 size isn't 2 bytes on this platform"); - static_assert(sizeof(glm::u32vec1) == 4, "uint32 size isn't 4 bytes on this platform"); - static_assert(sizeof(glm::u64vec1) == 8, "uint64 size isn't 8 bytes on this platform"); -#endif +static_assert(sizeof(glm::u8vec1) == 1, "uint8 size isn't 1 byte on this platform"); +static_assert(sizeof(glm::u16vec1) == 2, "uint16 size isn't 2 bytes on this platform"); +static_assert(sizeof(glm::u32vec1) == 4, "uint32 size isn't 4 bytes on this platform"); +static_assert(sizeof(glm::u64vec1) == 8, "uint64 size isn't 8 bytes on this platform"); static int test_size() { diff --git a/test/ext/ext_vector_uint2_sized.cpp b/test/ext/ext_vector_uint2_sized.cpp index 9c0977ee2..dfd98c792 100644 --- a/test/ext/ext_vector_uint2_sized.cpp +++ b/test/ext/ext_vector_uint2_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8vec2) == 2, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16vec2) == 4, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32vec2) == 8, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64vec2) == 16, "int64 size isn't 8 bytes on this platform"); -#endif static int test_size() { diff --git a/test/ext/ext_vector_uint3_sized.cpp b/test/ext/ext_vector_uint3_sized.cpp index 4cc2e4487..6b38f5b8a 100644 --- a/test/ext/ext_vector_uint3_sized.cpp +++ b/test/ext/ext_vector_uint3_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8vec3) == 3, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16vec3) == 6, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32vec3) == 12, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64vec3) == 24, "int64 size isn't 8 bytes on this platform"); -#endif static int test_size() { diff --git a/test/ext/ext_vector_uint4_sized.cpp b/test/ext/ext_vector_uint4_sized.cpp index 9e7ffe750..49833e604 100644 --- a/test/ext/ext_vector_uint4_sized.cpp +++ b/test/ext/ext_vector_uint4_sized.cpp @@ -1,11 +1,9 @@ #include -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::u8vec4) == 4, "int8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::u16vec4) == 8, "int16 size isn't 2 bytes on this platform"); static_assert(sizeof(glm::u32vec4) == 16, "int32 size isn't 4 bytes on this platform"); static_assert(sizeof(glm::u64vec4) == 32, "int64 size isn't 8 bytes on this platform"); -#endif static int test_size() { diff --git a/test/gtc/gtc_type_aligned.cpp b/test/gtc/gtc_type_aligned.cpp index b98131e16..b7f9ce727 100644 --- a/test/gtc/gtc_type_aligned.cpp +++ b/test/gtc/gtc_type_aligned.cpp @@ -10,19 +10,19 @@ #include #include -GLM_STATIC_ASSERT(glm::detail::is_aligned::value, "aligned_lowp is not aligned"); -GLM_STATIC_ASSERT(glm::detail::is_aligned::value, "aligned_mediump is not aligned"); -GLM_STATIC_ASSERT(glm::detail::is_aligned::value, "aligned_highp is not aligned"); -GLM_STATIC_ASSERT(!glm::detail::is_aligned::value, "packed_highp is aligned"); -GLM_STATIC_ASSERT(!glm::detail::is_aligned::value, "packed_mediump is aligned"); -GLM_STATIC_ASSERT(!glm::detail::is_aligned::value, "packed_lowp is aligned"); +static_assert(glm::detail::is_aligned::value, "aligned_lowp is not aligned"); +static_assert(glm::detail::is_aligned::value, "aligned_mediump is not aligned"); +static_assert(glm::detail::is_aligned::value, "aligned_highp is not aligned"); +static_assert(!glm::detail::is_aligned::value, "packed_highp is aligned"); +static_assert(!glm::detail::is_aligned::value, "packed_mediump is aligned"); +static_assert(!glm::detail::is_aligned::value, "packed_lowp is aligned"); struct my_vec4_packed { glm::uint32 a; glm::vec4 b; }; -GLM_STATIC_ASSERT(sizeof(my_vec4_packed) == sizeof(glm::uint32) + sizeof(glm::vec4), "glm::vec4 packed is not correct"); +static_assert(sizeof(my_vec4_packed) == sizeof(glm::uint32) + sizeof(glm::vec4), "glm::vec4 packed is not correct"); #if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push @@ -34,7 +34,7 @@ struct my_vec4_aligned glm::uint32 a; glm::aligned_vec4 b; }; -GLM_STATIC_ASSERT(sizeof(my_vec4_aligned) == sizeof(glm::aligned_vec4) * 2, "glm::vec4 aligned is not correct"); +static_assert(sizeof(my_vec4_aligned) == sizeof(glm::aligned_vec4) * 2, "glm::vec4 aligned is not correct"); #if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic pop @@ -45,14 +45,14 @@ struct my_dvec4_packed glm::uint64 a; glm::dvec4 b; }; -GLM_STATIC_ASSERT(sizeof(my_dvec4_packed) == sizeof(glm::uint64) + sizeof(glm::dvec4), "glm::dvec4 packed is not correct"); +static_assert(sizeof(my_dvec4_packed) == sizeof(glm::uint64) + sizeof(glm::dvec4), "glm::dvec4 packed is not correct"); struct my_dvec4_aligned { glm::uint64 a; glm::aligned_dvec4 b; }; -//GLM_STATIC_ASSERT(sizeof(my_dvec4_aligned) == sizeof(glm::aligned_dvec4) * 2, "glm::dvec4 aligned is not correct"); +//static_assert(sizeof(my_dvec4_aligned) == sizeof(glm::aligned_dvec4) * 2, "glm::dvec4 aligned is not correct"); #if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push @@ -69,7 +69,7 @@ struct my_ivec4_packed # pragma clang diagnostic pop #endif -GLM_STATIC_ASSERT(sizeof(my_ivec4_packed) == sizeof(glm::uint32) + sizeof(glm::ivec4), "glm::ivec4 packed is not correct"); +static_assert(sizeof(my_ivec4_packed) == sizeof(glm::uint32) + sizeof(glm::ivec4), "glm::ivec4 packed is not correct"); #if GLM_COMPILER & GLM_COMPILER_CLANG # pragma clang diagnostic push @@ -86,14 +86,14 @@ struct my_ivec4_aligned # pragma clang diagnostic pop #endif -GLM_STATIC_ASSERT(sizeof(my_ivec4_aligned) == sizeof(glm::aligned_ivec4) * 2, "glm::ivec4 aligned is not correct"); +static_assert(sizeof(my_ivec4_aligned) == sizeof(glm::aligned_ivec4) * 2, "glm::ivec4 aligned is not correct"); struct my_u8vec4_packed { glm::uint32 a; glm::u8vec4 b; }; -GLM_STATIC_ASSERT(sizeof(my_u8vec4_packed) == sizeof(glm::uint32) + sizeof(glm::u8vec4), "glm::u8vec4 packed is not correct"); +static_assert(sizeof(my_u8vec4_packed) == sizeof(glm::uint32) + sizeof(glm::u8vec4), "glm::u8vec4 packed is not correct"); static int test_copy_vec4() { diff --git a/test/gtc/gtc_type_precision.cpp b/test/gtc/gtc_type_precision.cpp index 27dbb6948..a205b52ee 100644 --- a/test/gtc/gtc_type_precision.cpp +++ b/test/gtc/gtc_type_precision.cpp @@ -7,7 +7,6 @@ # include #endif -#if GLM_HAS_STATIC_ASSERT static_assert(sizeof(glm::lowp_u8vec1) == 1, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::mediump_u8vec1) == 1, "uint8 size isn't 1 byte on this platform"); static_assert(sizeof(glm::highp_u8vec1) == 1, "uint8 size isn't 1 byte on this platform"); @@ -143,8 +142,6 @@ static_assert(sizeof(glm::lowp_u64vec4) == 32, "uint64 size isn't 8 bytes on thi static_assert(sizeof(glm::mediump_u64vec4) == 32, "uint64 size isn't 8 bytes on this platform"); static_assert(sizeof(glm::highp_u64vec4) == 32, "uint64 size isn't 8 bytes on this platform"); -#endif - static int test_scalar_size() { int Error = 0;