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

Reduce dependencies, added scalar EXT extensions

Browse Source
master
Christophe Riccio ago%!(EXTRA string=7 years)
parent 2a20695ce5
commit a21401d2a4
57 changed files with 785 additions and 612 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      glm/common.hpp
  2. 3
      glm/detail/_features.hpp
  3. 3
      glm/detail/_fixes.hpp
  4. 20
      glm/detail/_noise.hpp
  5. 3
      glm/detail/_swizzle.hpp
  6. 3
      glm/detail/_swizzle_func.hpp
  7. 3
      glm/detail/_vectorize.hpp
  8. 6
      glm/detail/func_common.inl
  9. 6
      glm/detail/func_geometric.inl
  10. 55
      glm/detail/func_integer.inl
  11. 1
      glm/detail/func_packing.inl
  12. 3
      glm/detail/func_packing_simd.inl
  13. 3
      glm/detail/func_trigonometric.inl
  14. 4
      glm/detail/func_vector_relational.inl
  15. 3
      glm/detail/func_vector_relational_simd.inl
  16. 7
      glm/detail/glm.cpp
  17. 4
      glm/detail/qualifier.hpp
  18. 148
      glm/detail/setup.hpp
  19. 3
      glm/detail/type_half.hpp
  20. 6
      glm/detail/type_half.inl
  21. 298
      glm/detail/type_int.hpp
  22. 30
      glm/detail/type_vec4.inl
  23. 97
      glm/ext.hpp
  24. 40
      glm/ext/scalar_constants.hpp
  25. 18
      glm/ext/scalar_constants.inl
  26. 16
      glm/ext/scalar_double.hpp
  27. 45
      glm/ext/scalar_float_sized.hpp
  28. 74
      glm/ext/scalar_int_sized.hpp
  29. 74
      glm/ext/scalar_uint_sized.hpp
  30. 8
      glm/ext/vector_uint1.hpp
  31. 6
      glm/ext/vector_uint1_precision.hpp
  32. 12
      glm/ext/vector_uint2.hpp
  33. 6
      glm/ext/vector_uint2_precision.hpp
  34. 6
      glm/ext/vector_uint3.hpp
  35. 6
      glm/ext/vector_uint3_precision.hpp
  36. 6
      glm/ext/vector_uint4.hpp
  37. 6
      glm/ext/vector_uint4_precision.hpp
  38. 3
      glm/gtc/bitfield.hpp
  39. 12
      glm/gtc/constants.hpp
  40. 14
      glm/gtc/constants.inl
  41. 5
      glm/gtc/random.hpp
  42. 2
      glm/gtc/random.inl
  43. 78
      glm/gtc/type_precision.hpp
  44. 3
      glm/gtc/ulp.hpp
  45. 11
      glm/gtc/ulp.inl
  46. 2
      glm/gtx/easing.hpp
  47. 2
      glm/gtx/raw_data.hpp
  48. 1
      glm/integer.hpp
  49. 1
      test/core/CMakeLists.txt
  50. 2
      test/core/core_func_integer.cpp
  51. 31
      test/core/core_type_float.cpp
  52. 35
      test/core/core_type_int.cpp
  53. 4
      test/ext/CMakeLists.txt
  54. 36
      test/ext/ext_scalar_constants.cpp
  55. 37
      test/ext/ext_scalar_float_sized.cpp
  56. 42
      test/ext/ext_scalar_int_sized.cpp
  57. 42
      test/ext/ext_scalar_uint_sized.cpp

2
glm/common.hpp
Unescape View File

@ -12,9 +12,7 @@
#pragma once
#include "detail/setup.hpp"
#include "detail/qualifier.hpp"
#include "detail/type_int.hpp"
#include "detail/_fixes.hpp"
namespace glm

3
glm/detail/_features.hpp
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/_features.hpp
#pragma once
// #define GLM_CXX98_EXCEPTIONS

3
glm/detail/_fixes.hpp
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/_fixes.hpp
#include <cmath>
//! Workaround for compatibility with other libraries

20
glm/detail/_noise.hpp
Unescape View File

@ -1,11 +1,5 @@
/// @ref core
/// @file glm/detail/_noise.hpp
#pragma once
#include "../vec2.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
#include "../common.hpp"
namespace glm{
@ -44,43 +38,43 @@ namespace detail
template<typename T>
GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
return static_cast<T>(1.79284291400159) - static_cast<T>(0.85373472095314) * r;
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
return (t * t * t) * (t * (t * static_cast<T>(6) - static_cast<T>(15)) + static_cast<T>(10));
}
}//namespace detail
}//namespace glm

3
glm/detail/_swizzle.hpp
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/_swizzle.hpp
#pragma once
namespace glm{

3
glm/detail/_swizzle_func.hpp
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/_swizzle_func.hpp
#pragma once
#define GLM_SWIZZLE_GEN_VEC2_ENTRY(T, P, CONST, A, B) \

3
glm/detail/_vectorize.hpp
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/_vectorize.hpp
#pragma once
namespace glm{

6
glm/detail/func_common.inl
Unescape View File

@ -30,9 +30,9 @@ namespace glm
// abs
template<>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR int32 abs(int32 x)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR int abs(int x)
{
int32 const y = x >> 31;
int const y = x >> (sizeof(int) * 8 - 1);
return (x ^ y) - y;
}
@ -155,7 +155,7 @@ namespace detail
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
{
T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
vec<L, T, Q> const y(vec<L, typename make_unsigned<T>::type, Q>(-x) >> typename make_unsigned<T>::type(Shift));
vec<L, T, Q> const y(vec<L, typename detail::make_unsigned<T>::type, Q>(-x) >> typename detail::make_unsigned<T>::type(Shift));
return (x >> Shift) | y;
}

6
glm/detail/func_geometric.inl
Unescape View File

@ -1,11 +1,5 @@
/// @ref core
/// @file glm/detail/func_geometric.inl
#include "../exponential.hpp"
#include "../common.hpp"
#include "type_vec2.hpp"
#include "type_vec4.hpp"
#include "type_float.hpp"
namespace glm{
namespace detail

55
glm/detail/func_integer.inl
Unescape View File

@ -1,10 +1,5 @@
/// @ref core
#include "type_vec1.hpp"
#include "type_vec2.hpp"
#include "type_vec3.hpp"
#include "type_vec4.hpp"
#include "type_int.hpp"
#include "_vectorize.hpp"
#if(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC)
# include <intrin.h>
@ -180,31 +175,29 @@ namespace detail
// uaddCarry
GLM_FUNC_QUALIFIER uint uaddCarry(uint const& x, uint const& y, uint & Carry)
{
uint64 const Value64(static_cast<uint64>(x) + static_cast<uint64>(y));
uint64 const Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
detail::uint64 const Value64(static_cast<detail::uint64>(x) + static_cast<detail::uint64>(y));
detail::uint64 const Max32((static_cast<detail::uint64>(1) << static_cast<detail::uint64>(32)) - static_cast<detail::uint64>(1));
Carry = Value64 > Max32 ? 1u : 0u;
return static_cast<uint32>(Value64 % (Max32 + static_cast<uint64>(1)));
return static_cast<uint>(Value64 % (Max32 + static_cast<detail::uint64>(1)));
}
template<length_t L, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, uint, Q> uaddCarry(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& Carry)
{
vec<L, uint64, Q> Value64(vec<L, uint64, Q>(x) + vec<L, uint64, Q>(y));
vec<L, uint64, Q> Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
Carry = mix(vec<L, uint32, Q>(0), vec<L, uint32, Q>(1), greaterThan(Value64, Max32));
return vec<L, uint32, Q>(Value64 % (Max32 + static_cast<uint64>(1)));
vec<L, detail::uint64, Q> Value64(vec<L, detail::uint64, Q>(x) + vec<L, detail::uint64, Q>(y));
vec<L, detail::uint64, Q> Max32((static_cast<detail::uint64>(1) << static_cast<detail::uint64>(32)) - static_cast<detail::uint64>(1));
Carry = mix(vec<L, uint, Q>(0), vec<L, uint, Q>(1), greaterThan(Value64, Max32));
return vec<L, uint, Q>(Value64 % (Max32 + static_cast<detail::uint64>(1)));
}
// usubBorrow
GLM_FUNC_QUALIFIER uint usubBorrow(uint const& x, uint const& y, uint & Borrow)
{
GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
Borrow = x >= y ? static_cast<uint32>(0) : static_cast<uint32>(1);
Borrow = x >= y ? static_cast<uint>(0) : static_cast<uint>(1);
if(y >= x)
return y - x;
else
return static_cast<uint32>((static_cast<int64>(1) << static_cast<int64>(32)) + (static_cast<int64>(y) - static_cast<int64>(x)));
return static_cast<uint>((static_cast<detail::int64>(1) << static_cast<detail::int64>(32)) + (static_cast<detail::int64>(y) - static_cast<detail::int64>(x)));
}
template<length_t L, qualifier Q>
@ -212,48 +205,40 @@ namespace detail
{
Borrow = mix(vec<L, uint, Q>(1), vec<L, uint, Q>(0), greaterThanEqual(x, y));
vec<L, uint, Q> const YgeX(y - x);
vec<L, uint, Q> const XgeY(vec<L, uint32, Q>((static_cast<int64>(1) << static_cast<int64>(32)) + (vec<L, int64, Q>(y) - vec<L, int64, Q>(x))));
vec<L, uint, Q> const XgeY(vec<L, uint, Q>((static_cast<detail::int64>(1) << static_cast<detail::int64>(32)) + (vec<L, detail::int64, Q>(y) - vec<L, detail::int64, Q>(x))));
return mix(XgeY, YgeX, greaterThanEqual(y, x));
}
// umulExtended
GLM_FUNC_QUALIFIER void umulExtended(uint const& x, uint const& y, uint & msb, uint & lsb)
{
GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
uint64 Value64 = static_cast<uint64>(x) * static_cast<uint64>(y);
msb = static_cast<uint>(Value64 >> static_cast<uint64>(32));
detail::uint64 Value64 = static_cast<detail::uint64>(x) * static_cast<detail::uint64>(y);
msb = static_cast<uint>(Value64 >> static_cast<detail::uint64>(32));
lsb = static_cast<uint>(Value64);
}
template<length_t L, qualifier Q>
GLM_FUNC_QUALIFIER void umulExtended(vec<L, uint, Q> const& x, vec<L, uint, Q> const& y, vec<L, uint, Q>& msb, vec<L, uint, Q>& lsb)
{
GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
vec<L, uint64, Q> Value64(vec<L, uint64, Q>(x) * vec<L, uint64, Q>(y));
msb = vec<L, uint32, Q>(Value64 >> static_cast<uint64>(32));
lsb = vec<L, uint32, Q>(Value64);
vec<L, detail::uint64, Q> Value64(vec<L, detail::uint64, Q>(x) * vec<L, detail::uint64, Q>(y));
msb = vec<L, uint, Q>(Value64 >> static_cast<detail::uint64>(32));
lsb = vec<L, uint, Q>(Value64);
}
// imulExtended
GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int& msb, int& lsb)
{
GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
int64 Value64 = static_cast<int64>(x) * static_cast<int64>(y);
msb = static_cast<int>(Value64 >> static_cast<int64>(32));
detail::int64 Value64 = static_cast<detail::int64>(x) * static_cast<detail::int64>(y);
msb = static_cast<int>(Value64 >> static_cast<detail::int64>(32));
lsb = static_cast<int>(Value64);
}
template<length_t L, qualifier Q>
GLM_FUNC_QUALIFIER void imulExtended(vec<L, int, Q> const& x, vec<L, int, Q> const& y, vec<L, int, Q>& msb, vec<L, int, Q>& lsb)
{
GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
vec<L, int64, Q> Value64(vec<L, int64, Q>(x) * vec<L, int64, Q>(y));
lsb = vec<L, int32, Q>(Value64 & static_cast<int64>(0xFFFFFFFF));
msb = vec<L, int32, Q>((Value64 >> static_cast<int64>(32)) & static_cast<int64>(0xFFFFFFFF));
vec<L, detail::int64, Q> Value64(vec<L, detail::int64, Q>(x) * vec<L, detail::int64, Q>(y));
lsb = vec<L, int, Q>(Value64 & static_cast<detail::int64>(0xFFFFFFFF));
msb = vec<L, int, Q>((Value64 >> static_cast<detail::int64>(32)) & static_cast<detail::int64>(0xFFFFFFFF));
}
// bitfieldExtract

1
glm/detail/func_packing.inl
Unescape View File

@ -3,7 +3,6 @@
#include "../common.hpp"
#include "type_half.hpp"
#include "../fwd.hpp"
namespace glm
{

3
glm/detail/func_packing_simd.inl
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/func_packing_simd.inl
namespace glm{
namespace detail
{

3
glm/detail/func_trigonometric.inl
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/func_trigonometric.inl
#include "_vectorize.hpp"
#include <cmath>
#include <limits>

4
glm/detail/func_vector_relational.inl
Unescape View File

@ -1,7 +1,3 @@
/// @ref core
#include "compute_vector_relational.hpp"
namespace glm
{
template<length_t L, typename T, qualifier Q>

3
glm/detail/func_vector_relational_simd.inl
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/func_vector_relational_simd.inl
namespace glm{
namespace detail
{

7
glm/detail/glm.cpp
Unescape View File

@ -3,10 +3,13 @@
#define GLM_FORCE_MESSAGES
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/glm.hpp>
#include <glm/gtx/dual_quaternion.hpp>
#include <glm/gtc/vec1.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/dual_quaternion.hpp>
#include <glm/ext/scalar_float_sized.hpp>
#include <glm/ext/scalar_int_sized.hpp>
#include <glm/ext/scalar_uint_sized.hpp>
#include <glm/glm.hpp>
namespace glm
{

4
glm/detail/qualifier.hpp
Unescape View File

@ -1,10 +1,6 @@
/// @ref core
/// @file glm/detail/qualifier.hpp
#pragma once
#include "setup.hpp"
#include "type_int.hpp"
namespace glm
{

148
glm/detail/setup.hpp
Unescape View File

@ -335,6 +335,7 @@
((GLM_COMPILER & GLM_COMPILER_CUDA))))
#endif
//
#if defined(GLM_FORCE_PURE)
# define GLM_HAS_BITSCAN_WINDOWS 0
#else
@ -569,6 +570,153 @@ namespace glm
# define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
#endif
///////////////////////////////////////////////////////////////////////////////////
// uint
namespace glm{
namespace detail
{
template<typename T>
struct is_int
{
enum test {value = 0};
};
template<>
struct is_int<unsigned int>
{
enum test {value = ~0};
};
template<>
struct is_int<signed int>
{
enum test {value = ~0};
};
}//namespace detail
typedef unsigned int uint;
}//namespace glm
///////////////////////////////////////////////////////////////////////////////////
// 64-bit int
#if GLM_HAS_EXTENDED_INTEGER_TYPE
# include <cstdint>
#endif
namespace glm{
namespace detail
{
# if GLM_HAS_EXTENDED_INTEGER_TYPE
typedef std::uint64_t uint64;
typedef std::int64_t int64;
# elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
typedef uint64_t uint64;
typedef int64_t int64;
# elif GLM_COMPILER & GLM_COMPILER_VC
typedef unsigned __int64 uint64;
typedef signed __int64 int64;
# elif GLM_COMPILER & GLM_COMPILER_GCC
# pragma GCC diagnostic ignored "-Wlong-long"
__extension__ typedef unsigned long long uint64;
__extension__ typedef signed long long int64;
# elif (GLM_COMPILER & GLM_COMPILER_CLANG)
# pragma clang diagnostic ignored "-Wc++11-long-long"
typedef unsigned long long uint64;
typedef signed long long int64;
# else//unknown compiler
typedef unsigned long long uint64;
typedef signed long long int64;
# endif
}//namespace detail
}//namespace glm
///////////////////////////////////////////////////////////////////////////////////
// make_unsigned
#if GLM_HAS_MAKE_SIGNED
# include <type_traits>
namespace glm{
namespace detail
{
using std::make_unsigned;
}//namespace detail
}//namespace glm
#else
namespace glm{
namespace detail
{
template<typename genType>
struct make_unsigned
{};
template<>
struct make_unsigned<char>
{
typedef unsigned char type;
};
template<>
struct make_unsigned<short>
{
typedef unsigned short type;
};
template<>
struct make_unsigned<int>
{
typedef unsigned int type;
};
template<>
struct make_unsigned<long>
{
typedef unsigned long type;
};
template<>
struct make_unsigned<int64>
{
typedef uint64 type;
};
template<>
struct make_unsigned<unsigned char>
{
typedef unsigned char type;
};
template<>
struct make_unsigned<unsigned short>
{
typedef unsigned short type;
};
template<>
struct make_unsigned<unsigned int>
{
typedef unsigned int type;
};
template<>
struct make_unsigned<unsigned long>
{
typedef unsigned long type;
};
template<>
struct make_unsigned<uint64>
{
typedef uint64 type;
};
}//namespace detail
}//namespace glm
#endif
///////////////////////////////////////////////////////////////////////////////////
// Configure the use of defaulted initialized types

3
glm/detail/type_half.hpp
Unescape View File

@ -1,6 +1,3 @@
/// @ref core
/// @file glm/detail/type_half.hpp
#pragma once
#include "setup.hpp"

6
glm/detail/type_half.inl
Unescape View File

@ -1,5 +1,3 @@
/// @ref core
namespace glm{
namespace detail
{
@ -22,12 +20,12 @@ namespace detail
f(f_)
{}
GLM_FUNC_QUALIFIER uif32(uint32 i_) :
GLM_FUNC_QUALIFIER uif32(unsigned int i_) :
i(i_)
{}
float f;
uint32 i;
unsigned int i;
};
GLM_FUNC_QUALIFIER float toFloat32(hdata value)

298
glm/detail/type_int.hpp
Unescape View File

@ -1,298 +0,0 @@
/// @ref core
/// @file glm/detail/type_int.hpp
#pragma once
#include "setup.hpp"
#if GLM_HAS_MAKE_SIGNED
# include <type_traits>
#endif
#if GLM_HAS_EXTENDED_INTEGER_TYPE
# include <cstdint>
#endif
namespace glm{
namespace detail
{
# if GLM_HAS_EXTENDED_INTEGER_TYPE
typedef std::int8_t int8;
typedef std::int16_t int16;
typedef std::int32_t int32;
typedef std::int64_t int64;
typedef std::uint8_t uint8;
typedef std::uint16_t uint16;
typedef std::uint32_t uint32;
typedef std::uint64_t uint64;
# else
# if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
typedef int64_t sint64;
typedef uint64_t uint64;
# elif GLM_COMPILER & GLM_COMPILER_VC
typedef signed __int64 sint64;
typedef unsigned __int64 uint64;
# elif GLM_COMPILER & GLM_COMPILER_GCC
# pragma GCC diagnostic ignored "-Wlong-long"
__extension__ typedef signed long long sint64;
__extension__ typedef unsigned long long uint64;
# elif (GLM_COMPILER & GLM_COMPILER_CLANG)
# pragma clang diagnostic ignored "-Wc++11-long-long"
typedef signed long long sint64;
typedef unsigned long long uint64;
# else//unknown compiler
typedef signed long long sint64;
typedef unsigned long long uint64;
# endif//GLM_COMPILER
typedef signed char int8;
typedef signed short int16;
typedef signed int int32;
typedef sint64 int64;
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef uint64 uint64;
#endif//
typedef signed int lowp_int_t;
typedef signed int mediump_int_t;
typedef signed int highp_int_t;
typedef unsigned int lowp_uint_t;
typedef unsigned int mediump_uint_t;
typedef unsigned int highp_uint_t;
# if GLM_HAS_MAKE_SIGNED
using std::make_signed;
using std::make_unsigned;
# else//GLM_HAS_MAKE_SIGNED
template<typename genType>
struct make_signed
{};
template<>
struct make_signed<char>
{
typedef char type;
};
template<>
struct make_signed<short>
{
typedef short type;
};
template<>
struct make_signed<int>
{
typedef int type;
};
template<>
struct make_signed<long>
{
typedef long type;
};
template<>
struct make_signed<unsigned char>
{
typedef char type;
};
template<>
struct make_signed<unsigned short>
{
typedef short type;
};
template<>
struct make_signed<unsigned int>
{
typedef int type;
};
template<>
struct make_signed<unsigned long>
{
typedef long type;
};
template<typename genType>
struct make_unsigned
{};
template<>
struct make_unsigned<char>
{
typedef unsigned char type;
};
template<>
struct make_unsigned<short>
{
typedef unsigned short type;
};
template<>
struct make_unsigned<int>
{
typedef unsigned int type;
};
template<>
struct make_unsigned<long>
{
typedef unsigned long type;
};
template<>
struct make_unsigned<unsigned char>
{
typedef unsigned char type;
};
template<>
struct make_unsigned<unsigned short>
{
typedef unsigned short type;
};
template<>
struct make_unsigned<unsigned int>
{
typedef unsigned int type;
};
template<>
struct make_unsigned<unsigned long>
{
typedef unsigned long type;
};
template<>
struct make_signed<long long>
{
typedef long long type;
};
template<>
struct make_signed<unsigned long long>
{
typedef long long type;
};
template<>
struct make_unsigned<long long>
{
typedef unsigned long long type;
};
template<>
struct make_unsigned<unsigned long long>
{
typedef unsigned long long type;
};
# endif//GLM_HAS_MAKE_SIGNED
}//namespace detail
typedef detail::int8 int8;
typedef detail::int16 int16;
typedef detail::int32 int32;
typedef detail::int64 int64;
typedef detail::uint8 uint8;
typedef detail::uint16 uint16;
typedef detail::uint32 uint32;
typedef detail::uint64 uint64;
/// @addtogroup core_precision
/// @{
/// Low qualifier signed integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::lowp_int_t lowp_int;
/// Medium qualifier signed integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::mediump_int_t mediump_int;
/// High qualifier signed integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::highp_int_t highp_int;
/// Low qualifier unsigned integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::lowp_uint_t lowp_uint;
/// Medium qualifier unsigned integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::mediump_uint_t mediump_uint;
/// High qualifier unsigned integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::highp_uint_t highp_uint;
#if GLM_CONFIG_PRECISION_INT == GLM_LOWP
typedef lowp_int int_t;
#elif GLM_CONFIG_PRECISION_INT == GLM_MEDIUMP
typedef mediump_int int_t;
#else
typedef highp_int int_t;
#endif
#if GLM_CONFIG_PRECISION_UINT == GLM_LOWP
typedef lowp_uint uint_t;
#elif GLM_CONFIG_PRECISION_UINT == GLM_MEDIUMP
typedef mediump_uint uint_t;
#else
typedef highp_uint uint_t;
#endif
/// Unsigned integer type.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
typedef unsigned int uint;
/// @}
////////////////////
// check type sizes
#ifndef GLM_STATIC_ASSERT_NULL
GLM_STATIC_ASSERT(sizeof(glm::int8) == 1, "int8 size isn't 1 byte on this platform");
GLM_STATIC_ASSERT(sizeof(glm::int16) == 2, "int16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::int32) == 4, "int32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::int64) == 8, "int64 size isn't 8 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint8) == 1, "uint8 size isn't 1 byte on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
#endif//GLM_STATIC_ASSERT_NULL
}//namespace glm

30
glm/detail/type_vec4.inl
Unescape View File

@ -5,36 +5,6 @@
namespace glm{
namespace detail
{
template<typename T>
struct is_int
{
enum test {value = 0};
};
template<>
struct is_int<uint32>
{
enum test {value = ~0};
};
template<>
struct is_int<int32>
{
enum test {value = ~0};
};
template<>
struct is_int<uint64>
{
enum test {value = ~0};
};
template<>
struct is_int<int64>
{
enum test {value = ~0};
};
template<typename T, qualifier Q, bool Aligned>
struct compute_vec4_add
{

97
glm/ext.hpp
Unescape View File

@ -13,8 +13,105 @@
# pragma message("GLM: All extensions included (not recommended)")
#endif//GLM_MESSAGES
#include "./ext/matrix_double2x2.hpp"
#include "./ext/matrix_double2x2_precision.hpp"
#include "./ext/matrix_double2x3.hpp"
#include "./ext/matrix_double2x3_precision.hpp"
#include "./ext/matrix_double2x4.hpp"
#include "./ext/matrix_double2x4_precision.hpp"
#include "./ext/matrix_double3x2.hpp"
#include "./ext/matrix_double3x2_precision.hpp"
#include "./ext/matrix_double3x3.hpp"
#include "./ext/matrix_double3x3_precision.hpp"
#include "./ext/matrix_double3x4.hpp"
#include "./ext/matrix_double3x4_precision.hpp"
#include "./ext/matrix_double4x2.hpp"
#include "./ext/matrix_double4x2_precision.hpp"
#include "./ext/matrix_double4x3.hpp"
#include "./ext/matrix_double4x3_precision.hpp"
#include "./ext/matrix_double4x4.hpp"
#include "./ext/matrix_double4x4_precision.hpp"
#include "./ext/matrix_float2x2.hpp"
#include "./ext/matrix_float2x2_precision.hpp"
#include "./ext/matrix_float2x3.hpp"
#include "./ext/matrix_float2x3_precision.hpp"
#include "./ext/matrix_float2x4.hpp"
#include "./ext/matrix_float2x4_precision.hpp"
#include "./ext/matrix_float3x2.hpp"
#include "./ext/matrix_float3x2_precision.hpp"
#include "./ext/matrix_float3x3.hpp"
#include "./ext/matrix_float3x3_precision.hpp"
#include "./ext/matrix_float3x4.hpp"
#include "./ext/matrix_float3x4_precision.hpp"
#include "./ext/matrix_float4x2.hpp"
#include "./ext/matrix_float4x2_precision.hpp"
#include "./ext/matrix_float4x3.hpp"
#include "./ext/matrix_float4x3_precision.hpp"
#include "./ext/matrix_float4x4.hpp"
#include "./ext/matrix_float4x4_precision.hpp"
#include "./ext/matrix_relational.hpp"
#include "./ext/quaternion_double.hpp"
#include "./ext/quaternion_double_precision.hpp"
#include "./ext/quaternion_float.hpp"
#include "./ext/quaternion_float_precision.hpp"
#include "./ext/quaternion_geometric.hpp"
#include "./ext/quaternion_relational.hpp"
#include "./ext/scalar_constants.hpp"
#include "./ext/scalar_float_sized.hpp"
#include "./ext/scalar_int_sized.hpp"
#include "./ext/scalar_relational.hpp"
#include "./ext/vector_bool1.hpp"
#include "./ext/vector_bool1_precision.hpp"
#include "./ext/vector_bool2.hpp"
#include "./ext/vector_bool2_precision.hpp"
#include "./ext/vector_bool3.hpp"
#include "./ext/vector_bool3_precision.hpp"
#include "./ext/vector_bool4.hpp"
#include "./ext/vector_bool4_precision.hpp"
#include "./ext/vector_double1.hpp"
#include "./ext/vector_double1_precision.hpp"
#include "./ext/vector_double2.hpp"
#include "./ext/vector_double2_precision.hpp"
#include "./ext/vector_double3.hpp"
#include "./ext/vector_double3_precision.hpp"
#include "./ext/vector_double4.hpp"
#include "./ext/vector_double4_precision.hpp"
#include "./ext/vector_float1.hpp"
#include "./ext/vector_float1_precision.hpp"
#include "./ext/vector_float2.hpp"
#include "./ext/vector_float2_precision.hpp"
#include "./ext/vector_float3.hpp"
#include "./ext/vector_float3_precision.hpp"
#include "./ext/vector_float4.hpp"
#include "./ext/vector_float4_precision.hpp"
#include "./ext/vector_int1.hpp"
#include "./ext/vector_int1_precision.hpp"
#include "./ext/vector_int2.hpp"
#include "./ext/vector_int2_precision.hpp"
#include "./ext/vector_int3.hpp"
#include "./ext/vector_int3_precision.hpp"
#include "./ext/vector_int4.hpp"
#include "./ext/vector_int4_precision.hpp"
#include "./ext/vector_relational.hpp"
#include "./ext/vector_uint1.hpp"
#include "./ext/vector_uint1_precision.hpp"
#include "./ext/vector_uint2.hpp"
#include "./ext/vector_uint2_precision.hpp"
#include "./ext/vector_uint3.hpp"
#include "./ext/vector_uint3_precision.hpp"
#include "./ext/vector_uint4.hpp"
#include "./ext/vector_uint4_precision.hpp"
#include "./gtc/bitfield.hpp"
#include "./gtc/color_space.hpp"
#include "./gtc/constants.hpp"

40
glm/ext/scalar_constants.hpp
Unescape View File

@ -0,0 +1,40 @@
/// @ref ext_scalar_constants
/// @file glm/ext/scalar_constants.hpp
///
/// @see core (dependence)
///
/// @defgroup ext_scalar_constants GLM_EXT_scalar_constants
/// @ingroup ext
///
/// Include <glm/ext/scalar_constants.hpp> to use the features of this extension.
///
/// Provide a list of constants and precomputed useful values.
#pragma once
// Dependencies
#include "../detail/setup.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_constants extension included")
#endif
namespace glm
{
/// @addtogroup ext_scalar_constants
/// @{
/// Return the epsilon constant for floating point types.
/// @see ext_scalar_constants
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon();
/// Return the pi constant for floating point types.
/// @see ext_scalar_constants
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType pi();
/// @}
} //namespace glm
#include "scalar_constants.inl"

18
glm/ext/scalar_constants.inl
Unescape View File

@ -0,0 +1,18 @@
#include <limits>
namespace glm
{
template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon()
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'epsilon' only accepts floating-point inputs");
return std::numeric_limits<genType>::epsilon();
}
template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi()
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'epsilon' only accepts floating-point inputs");
return static_cast<genType>(3.14159265358979323846264338327950288);
}
} //namespace glm

16
glm/detail/type_float.hpp → glm/ext/scalar_double.hpp
Unescape View File

@ -1,5 +1,14 @@
/// @ref core
/// @file glm/detail/type_float.hpp
/// @ref ext_scalar_double
/// @file glm/ext/scalar_double.hpp
///
/// @see core (dependence)
///
/// @defgroup ext_scalar_double GLM_EXT_scalar_double
/// @ingroup ext
///
/// Include <glm/ext/scalar_double.hpp> to use the features of this extension.
///
/// Exposes double scalar type.
#pragma once
@ -59,12 +68,9 @@ namespace detail
////////////////////
// check type sizes
#ifndef GLM_STATIC_ASSERT_NULL
GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
# ifndef GLM_FORCE_SINGLE_ONLY
GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
# endif//GLM_FORCE_SINGLE_ONLY
#endif//GLM_STATIC_ASSERT_NULL
/// @}

45
glm/ext/scalar_float_sized.hpp
Unescape View File

@ -0,0 +1,45 @@
/// @ref ext_scalar_float_sized
/// @file glm/ext/scalar_float_sized.hpp
///
/// @see core (dependence)
///
/// @defgroup ext_scalar_float_sized GLM_EXT_scalar_float_sized
/// @ingroup ext
///
/// Include <glm/ext/scalar_float_sized.hpp> to use the features of this extension.
///
/// Exposes float scalar type.
#pragma once
#include "../detail/setup.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_float_sized extension included")
#endif
namespace glm
{
/// @addtogroup ext_scalar_float
/// @{
/// Low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see ext_vector_relational
typedef float float32;
# ifndef GLM_FORCE_SINGLE_ONLY
/// Low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see ext_vector_relational
typedef double float64;
# endif//GLM_FORCE_SINGLE_ONLY
/// @}
}//namespace glm

74
glm/ext/scalar_int_sized.hpp
Unescape View File

@ -0,0 +1,74 @@
/// @ref ext_scalar_int_sized
/// @file glm/ext/scalar_int_sized.hpp
///
/// @see core (dependence)
///
/// @defgroup ext_scalar_int_sized GLM_EXT_scalar_int_sized
/// @ingroup ext
///
/// Include <glm/ext/scalar_int_sized.hpp> to use the features of this extension.
///
/// Exposes signed integer scalar type.
#pragma once
#include "../detail/setup.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_int_sized extension included")
#endif
namespace glm{
namespace detail
{
# if GLM_HAS_EXTENDED_INTEGER_TYPE
typedef std::int8_t int8;
typedef std::int16_t int16;
typedef std::int32_t int32;
# else
typedef char int8;
typedef short int16;
typedef int int32;
#endif//
template<>
struct is_int<int8>
{
enum test {value = ~0};
};
template<>
struct is_int<int16>
{
enum test {value = ~0};
};
template<>
struct is_int<int64>
{
enum test {value = ~0};
};
}//namespace detail
/// @addtogroup ext_scalar_int_sized
/// @{
/// 8 bit signed integer type.
/// @see ext_scalar_int_sized
typedef detail::int8 int8;
/// 16 bit signed integer type.
/// @see ext_scalar_int_sized
typedef detail::int16 int16;
/// 32 bit signed integer type.
/// @see ext_scalar_int_sized
typedef detail::int32 int32;
/// 64 bit signed integer type.
/// @see ext_scalar_int_sized
typedef detail::int64 int64;
/// @}
}//namespace glm

74
glm/ext/scalar_uint_sized.hpp
Unescape View File

@ -0,0 +1,74 @@
/// @ref ext_scalar_uint_sized
/// @file glm/ext/scalar_uint_sized.hpp
///
/// @see core (dependence)
///
/// @defgroup ext_scalar_uint_sized GLM_EXT_scalar_uint_sized
/// @ingroup ext
///
/// Include <glm/ext/scalar_uint_sized.hpp> to use the features of this extension.
///
/// Exposes unsigned integer scalar type.
#pragma once
#include "../detail/setup.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_EXT_scalar_uint_sized extension included")
#endif
namespace glm{
namespace detail
{
# if GLM_HAS_EXTENDED_INTEGER_TYPE
typedef std::uint8_t uint8;
typedef std::uint16_t uint16;
typedef std::uint32_t uint32;
# else
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
#endif
template<>
struct is_int<uint8>
{
enum test {value = ~0};
};
template<>
struct is_int<uint16>
{
enum test {value = ~0};
};
template<>
struct is_int<uint64>
{
enum test {value = ~0};
};
}//namespace detail
/// @addtogroup ext_scalar_uint_sized
/// @{
/// 8 bit unsigned integer type.
/// @see ext_scalar_uint_sized
typedef detail::uint8 uint8;
/// 16 bit unsigned integer type.
/// @see ext_scalar_uint_sized
typedef detail::uint16 uint16;
/// 32 bit unsigned integer type.
/// @see ext_scalar_uint_sized
typedef detail::uint32 uint32;
/// 64 bit unsigned integer type.
/// @see ext_scalar_uint_sized
typedef detail::uint64 uint64;
/// @}
}//namespace glm

8
glm/ext/vector_uint1.hpp
Unescape View File

@ -24,14 +24,14 @@ namespace glm
/// @{
# if GLM_CONFIG_PRECISION_UINT == GLM_LOWP
typedef vec<1, uint, lowp> uvec1;
typedef vec<1, unsigned int, lowp> uvec1;
# elif GLM_CONFIG_PRECISION_UINT == GLM_MEDIUMP
typedef vec<1, uint, mediump> uvec1;
# else
typedef vec<1, unsigned int, mediump> uvec1;
# elif GLM_CONFIG_PRECISION_UINT == GLM_HIGHP
/// 1 component vector of unsigned integer numbers.
///
/// @see ext_vector_uint1 extension.
typedef vec<1, uint, highp> uvec1;
typedef vec<1, unsigned int, highp> uvec1;
# endif
/// @}

6
glm/ext/vector_uint1_precision.hpp
Unescape View File

@ -26,17 +26,17 @@ namespace glm
/// 1 component vector of unsigned integer values.
///
/// @see ext_vec1
typedef vec<1, uint, highp> highp_uvec1;
typedef vec<1, unsigned int, highp> highp_uvec1;
/// 1 component vector of unsigned integer values.
///
/// @see ext_vec1
typedef vec<1, uint, mediump> mediump_uvec1;
typedef vec<1, unsigned int, mediump> mediump_uvec1;
/// 1 component vector of unsigned integer values.
///
/// @see ext_vec1
typedef vec<1, uint, lowp> lowp_uvec1;
typedef vec<1, unsigned int, lowp> lowp_uvec1;
/// @}
}//namespace glm

12
glm/ext/vector_uint2.hpp
Unescape View File

@ -9,15 +9,15 @@ namespace glm
/// @addtogroup core
/// @{
# if(defined(GLM_PRECISION_LOWP_UINT))
typedef vec<2, uint, lowp> uvec2;
# elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef vec<2, uint, mediump> uvec2;
# else //defined(GLM_PRECISION_HIGHP_UINT)
# if GLM_CONFIG_PRECISION_UINT == GLM_LOWP
typedef vec<2, unsigned int, lowp> uvec2;
# elif GLM_CONFIG_PRECISION_UINT == GLM_MEDIUMP
typedef vec<2, unsigned int, mediump> uvec2;
# elif GLM_CONFIG_PRECISION_UINT == GLM_HIGHP
/// 2 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<2, uint, highp> uvec2;
typedef vec<2, unsigned int, highp> uvec2;
# endif//GLM_PRECISION
/// @}

6
glm/ext/vector_uint2_precision.hpp
Unescape View File

@ -13,19 +13,19 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, uint, highp> highp_uvec2;
typedef vec<2, unsigned int, highp> highp_uvec2;
/// 2 components vector of medium qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, uint, mediump> mediump_uvec2;
typedef vec<2, unsigned int, mediump> mediump_uvec2;
/// 2 components vector of low qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, uint, lowp> lowp_uvec2;
typedef vec<2, unsigned int, lowp> lowp_uvec2;
/// @}
}//namespace glm

6
glm/ext/vector_uint3.hpp
Unescape View File

@ -10,14 +10,14 @@ namespace glm
/// @{
# if(defined(GLM_PRECISION_LOWP_UINT))
typedef vec<3, uint, lowp> uvec3;
typedef vec<3, unsigned int, lowp> uvec3;
# elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef vec<3, uint, mediump> uvec3;
typedef vec<3, unsigned int, mediump> uvec3;
# else //defined(GLM_PRECISION_HIGHP_UINT)
/// 3 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<3, uint, highp> uvec3;
typedef vec<3, unsigned int, highp> uvec3;
# endif//GLM_PRECISION
/// @}

6
glm/ext/vector_uint3_precision.hpp
Unescape View File

@ -14,19 +14,19 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, uint, highp> highp_uvec3;
typedef vec<3, unsigned int, highp> highp_uvec3;
/// 3 components vector of medium qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, uint, mediump> mediump_uvec3;
typedef vec<3, unsigned int, mediump> mediump_uvec3;
/// 3 components vector of low qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, uint, lowp> lowp_uvec3;
typedef vec<3, unsigned int, lowp> lowp_uvec3;
/// @}
}//namespace glm

6
glm/ext/vector_uint4.hpp
Unescape View File

@ -10,14 +10,14 @@ namespace glm
/// @{
# if(defined(GLM_PRECISION_LOWP_UINT))
typedef vec<4, uint, lowp> uvec4;
typedef vec<4, unsigned int, lowp> uvec4;
# elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef vec<4, uint, mediump> uvec4;
typedef vec<4, unsigned int, mediump> uvec4;
# else //defined(GLM_PRECISION_HIGHP_UINT)
/// 4 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef vec<4, uint, highp> uvec4;
typedef vec<4, unsigned int, highp> uvec4;
# endif//GLM_PRECISION
/// @}

6
glm/ext/vector_uint4_precision.hpp
Unescape View File

@ -13,19 +13,19 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, uint, highp> highp_uvec4;
typedef vec<4, unsigned int, highp> highp_uvec4;
/// 4 components vector of medium qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, uint, mediump> mediump_uvec4;
typedef vec<4, unsigned int, mediump> mediump_uvec4;
/// 4 components vector of low qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, uint, lowp> lowp_uvec4;
typedef vec<4, unsigned int, lowp> lowp_uvec4;
/// @}
}//namespace glm

3
glm/gtc/bitfield.hpp
Unescape View File

@ -16,8 +16,9 @@
#pragma once
// Dependencies
#include "../ext/scalar_int_sized.hpp"
#include "../ext/scalar_uint_sized.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/type_int.hpp"
#include "../detail/_vectorize.hpp"
#include "type_precision.hpp"
#include <limits>

12
glm/gtc/constants.hpp
Unescape View File

@ -13,7 +13,7 @@
#pragma once
// Dependencies
#include "../detail/setup.hpp"
#include "../ext/scalar_constants.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_GTC_constants extension included")
@ -24,11 +24,6 @@ namespace glm
/// @addtogroup gtc_constants
/// @{
/// Return the epsilon constant for floating point types.
/// @see gtc_constants
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon();
/// Return 0.
/// @see gtc_constants
template<typename genType>
@ -39,11 +34,6 @@ namespace glm
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType one();
/// Return the pi constant.
/// @see gtc_constants
template<typename genType>
GLM_FUNC_DECL GLM_CONSTEXPR genType pi();
/// Return pi * 2.
/// @see gtc_constants
template<typename genType>

14
glm/gtc/constants.inl
Unescape View File

@ -1,15 +1,7 @@
/// @ref gtc_constants
#include <limits>
namespace glm
{
template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon()
{
return std::numeric_limits<genType>::epsilon();
}
template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType zero()
{
@ -22,12 +14,6 @@ namespace glm
return genType(1);
}
template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi()
{
return genType(3.14159265358979323846264338327950288);
}
template<typename genType>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType two_pi()
{

5
glm/gtc/random.hpp
Unescape View File

@ -14,8 +14,9 @@
#pragma once
// Dependency:
#include "../vec2.hpp"
#include "../vec3.hpp"
#include "../ext/scalar_int_sized.hpp"
#include "../ext/scalar_uint_sized.hpp"
#include "../detail/qualifier.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_GTC_random extension included")

2
glm/gtc/random.inl
Unescape View File

@ -1,5 +1,3 @@
/// @ref gtc_random
#include "../geometric.hpp"
#include "../exponential.hpp"
#include "../trigonometric.hpp"

78
glm/gtc/type_precision.hpp
Unescape View File

@ -19,18 +19,21 @@
// Dependency:
#include "../gtc/quaternion.hpp"
#include "../gtc/vec1.hpp"
#include "../vec2.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
#include "../mat2x2.hpp"
#include "../mat2x3.hpp"
#include "../mat2x4.hpp"
#include "../mat3x2.hpp"
#include "../mat3x3.hpp"
#include "../mat3x4.hpp"
#include "../mat4x2.hpp"
#include "../mat4x3.hpp"
#include "../mat4x4.hpp"
#include "../ext/scalar_float_sized.hpp"
#include "../ext/scalar_int_sized.hpp"
#include "../ext/scalar_uint_sized.hpp"
#include "../detail/type_vec2.hpp"
#include "../detail/type_vec3.hpp"
#include "../detail/type_vec4.hpp"
#include "../detail/type_mat2x2.hpp"
#include "../detail/type_mat2x3.hpp"
#include "../detail/type_mat2x4.hpp"
#include "../detail/type_mat3x2.hpp"
#include "../detail/type_mat3x3.hpp"
#include "../detail/type_mat3x4.hpp"
#include "../detail/type_mat4x2.hpp"
#include "../detail/type_mat4x3.hpp"
#include "../detail/type_mat4x4.hpp"
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_GTC_type_precision extension included")
@ -738,19 +741,19 @@ namespace glm
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 lowp_float32;
typedef float32 lowp_float32;
/// Low 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 lowp_float64;
typedef float64 lowp_float64;
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 lowp_float32_t;
typedef float32 lowp_float32_t;
/// Low 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 lowp_float64_t;
typedef float64 lowp_float64_t;
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
@ -762,19 +765,19 @@ namespace glm
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 lowp_float32;
typedef float32 lowp_float32;
/// Low 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 lowp_float64;
typedef float64 lowp_float64;
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 lowp_float32_t;
typedef float32 lowp_float32_t;
/// Low 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 lowp_float64_t;
typedef float64 lowp_float64_t;
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
@ -787,19 +790,19 @@ namespace glm
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 lowp_float32;
typedef float32 lowp_float32;
/// Low 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 lowp_float64;
typedef float64 lowp_float64;
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 lowp_float32_t;
typedef float32 lowp_float32_t;
/// Low 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 lowp_float64_t;
typedef float64 lowp_float64_t;
/// Low 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
@ -812,19 +815,19 @@ namespace glm
/// Medium 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 mediump_float32;
typedef float32 mediump_float32;
/// Medium 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 mediump_float64;
typedef float64 mediump_float64;
/// Medium 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 mediump_float32_t;
typedef float32 mediump_float32_t;
/// Medium 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 mediump_float64_t;
typedef float64 mediump_float64_t;
/// Medium 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
@ -837,19 +840,19 @@ namespace glm
/// High 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 highp_float32;
typedef float32 highp_float32;
/// High 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 highp_float64;
typedef float64 highp_float64;
/// High 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 highp_float32_t;
typedef float32 highp_float32_t;
/// High 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 highp_float64_t;
typedef float64 highp_float64_t;
/// High 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
@ -1943,24 +1946,17 @@ namespace glm
/// 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 float32;
/// 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 float32_t;
typedef float32 float32_t;
/// 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef float32 f32;
# ifndef GLM_FORCE_SINGLE_ONLY
/// 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 float64;
/// 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 float64_t;
typedef float64 float64_t;
/// 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision

3
glm/gtc/ulp.hpp
Unescape View File

@ -15,9 +15,6 @@
#pragma once
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/type_int.hpp"
#include "../gtc/constants.hpp"
#include "../ext/vector_relational.hpp"

11
glm/gtc/ulp.inl
Unescape View File

@ -7,7 +7,6 @@
/// software is freely granted, provided that this notice
/// is preserved.
#include "../detail/type_int.hpp"
#include "epsilon.hpp"
#include <cmath>
#include <cfloat>
@ -30,8 +29,8 @@ typedef union
double value;
struct
{
glm::detail::int32 lsw;
glm::detail::int32 msw;
int lsw;
int msw;
} parts;
} ieee_double_shape_type;
@ -71,7 +70,7 @@ namespace detail
GLM_FUNC_QUALIFIER float nextafterf(float x, float y)
{
volatile float t;
glm::detail::int32 hx, hy, ix, iy;
int hx, hy, ix, iy;
GLM_GET_FLOAT_WORD(hx, x);
GLM_GET_FLOAT_WORD(hy, y);
@ -125,8 +124,8 @@ namespace detail
GLM_FUNC_QUALIFIER double nextafter(double x, double y)
{
volatile double t;
glm::detail::int32 hx, hy, ix, iy;
glm::detail::uint32 lx, ly;
int hx, hy, ix, iy;
unsigned int lx, ly;
GLM_EXTRACT_WORDS(hx, lx, x);
GLM_EXTRACT_WORDS(hy, ly, y);

2
glm/gtx/easing.hpp
Unescape View File

@ -19,9 +19,7 @@
// Dependency:
#include "../glm.hpp"
#include "../gtc/constants.hpp"
#include "../detail/setup.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/type_int.hpp"
#ifndef GLM_ENABLE_EXPERIMENTAL
# error "GLM: GLM_GTX_easing is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."

2
glm/gtx/raw_data.hpp
Unescape View File

@ -13,8 +13,8 @@
#pragma once
// Dependencies
#include "../ext/scalar_uint_sized.hpp"
#include "../detail/setup.hpp"
#include "../detail/type_int.hpp"
#ifndef GLM_ENABLE_EXPERIMENTAL
# error "GLM: GLM_GTX_raw_data is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it."

1
glm/integer.hpp
Unescape View File

@ -14,7 +14,6 @@
#pragma once
#include "detail/setup.hpp"
#include "detail/qualifier.hpp"
#include "common.hpp"
#include "vector_relational.hpp"

1
test/core/CMakeLists.txt
Unescape View File

@ -10,7 +10,6 @@ glmCreateTestGTC(core_force_xyzw_only)
glmCreateTestGTC(core_type_aligned)
glmCreateTestGTC(core_type_cast)
glmCreateTestGTC(core_type_ctor)
glmCreateTestGTC(core_type_float)
glmCreateTestGTC(core_type_int)
glmCreateTestGTC(core_type_length)
glmCreateTestGTC(core_type_mat2x2)

2
test/core/core_func_integer.cpp
Unescape View File

@ -8,6 +8,8 @@
#include <glm/ext/vector_uint2.hpp>
#include <glm/ext/vector_uint3.hpp>
#include <glm/ext/vector_uint4.hpp>
#include <glm/ext/scalar_int_sized.hpp>
#include <glm/ext/scalar_uint_sized.hpp>
#include <vector>
#include <ctime>
#include <cstdio>

31
test/core/core_type_float.cpp
Unescape View File

@ -1,31 +0,0 @@
#include <glm/glm.hpp>
int test_float_size()
{
return
sizeof(glm::float_t) != sizeof(glm::lowp_float) &&
sizeof(glm::float_t) != sizeof(glm::mediump_float) &&
sizeof(glm::float_t) != sizeof(glm::highp_float);
}
int test_float_precision()
{
return (
sizeof(glm::lowp_float) <= sizeof(glm::mediump_float) &&
sizeof(glm::mediump_float) <= sizeof(glm::highp_float)) ? 0 : 1;
}
int test_vec2()
{
return 0;
}
int main()
{
int Error = 0;
Error += test_float_size();
Error += test_float_precision();
return Error;
}

35
test/core/core_type_int.cpp
Unescape View File

@ -1,34 +1,5 @@
#include <glm/glm.hpp>
static int test_int_size()
{
return
sizeof(glm::int_t) != sizeof(glm::lowp_int) &&
sizeof(glm::int_t) != sizeof(glm::mediump_int) &&
sizeof(glm::int_t) != sizeof(glm::highp_int);
}
static int test_uint_size()
{
return
sizeof(glm::uint_t) != sizeof(glm::lowp_uint) &&
sizeof(glm::uint_t) != sizeof(glm::mediump_uint) &&
sizeof(glm::uint_t) != sizeof(glm::highp_uint);
}
static int test_int_precision()
{
return (
sizeof(glm::lowp_int) <= sizeof(glm::mediump_int) &&
sizeof(glm::mediump_int) <= sizeof(glm::highp_int)) ? 0 : 1;
}
static int test_uint_precision()
{
return (
sizeof(glm::lowp_uint) <= sizeof(glm::mediump_uint) &&
sizeof(glm::mediump_uint) <= sizeof(glm::highp_uint)) ? 0 : 1;
}
#include <glm/ext/scalar_int_sized.hpp>
static int test_bit_operator()
{
@ -49,10 +20,6 @@ int main()
{
int Error = 0;
Error += test_int_size();
Error += test_int_precision();
Error += test_uint_size();
Error += test_uint_precision();
Error += test_bit_operator();
return Error;

4
test/ext/CMakeLists.txt
Unescape View File

@ -2,6 +2,10 @@ glmCreateTestGTC(ext_matrix_relational)
glmCreateTestGTC(ext_quaternion_geometric)
glmCreateTestGTC(ext_quaternion_relational)
glmCreateTestGTC(ext_quaternion_type)
glmCreateTestGTC(ext_scalar_constants)
glmCreateTestGTC(ext_scalar_float_sized)
glmCreateTestGTC(ext_scalar_int_sized)
glmCreateTestGTC(ext_scalar_uint_sized)
glmCreateTestGTC(ext_scalar_relational)
glmCreateTestGTC(ext_vec1)
glmCreateTestGTC(ext_vector_vec1)

36
test/ext/ext_scalar_constants.cpp
Unescape View File

@ -0,0 +1,36 @@
#include <glm/ext/scalar_constants.hpp>
template <typename valType>
static int test_epsilon()
{
int Error = 0;
valType const Test = glm::epsilon<valType>();
Error += Test > static_cast<valType>(0) ? 0 : 1;
return Error;
}
template <typename valType>
static int test_pi()
{
int Error = 0;
valType const Test = glm::pi<valType>();
Error += Test > static_cast<valType>(3.14) ? 0 : 1;
Error += Test < static_cast<valType>(3.15) ? 0 : 1;
return Error;
}
int main()
{
int Error = 0;
Error += test_epsilon<float>();
Error += test_epsilon<double>();
Error += test_pi<float>();
Error += test_pi<double>();
return Error;
}

37
test/ext/ext_scalar_float_sized.cpp
Unescape View File

@ -0,0 +1,37 @@
#include <glm/ext/scalar_float_sized.hpp>
GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
#ifndef GLM_FORCE_SINGLE_ONLY
GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
#endif//GLM_FORCE_SINGLE_ONLY
static int test_float_size()
{
int Error = 0;
Error += sizeof(glm::float32) == sizeof(float) ? 0 : 1;
Error += sizeof(glm::float64) == sizeof(double) ? 0 : 1;
return Error;
}
static int test_float_precision()
{
int Error = 0;
Error += sizeof(float) <= sizeof(double) ? 0 : 1;
Error += sizeof(glm::float32) < sizeof(glm::float64) ? 0 : 1;
return Error;
}
int main()
{
int Error = 0;
Error += test_float_size();
Error += test_float_precision();
return Error;
}

42
test/ext/ext_scalar_int_sized.cpp
Unescape View File

@ -0,0 +1,42 @@
#include <glm/ext/scalar_int_sized.hpp>
GLM_STATIC_ASSERT(sizeof(glm::int8) == 1, "int8 size isn't 1 byte on this platform");
GLM_STATIC_ASSERT(sizeof(glm::int16) == 2, "int16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::int32) == 4, "int32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::int64) == 8, "int64 size isn't 8 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::int16) == sizeof(short), "signed short size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::int32) == sizeof(int), "signed int size isn't 4 bytes on this platform");
static int test_size()
{
int Error = 0;
Error += sizeof(glm::int8) == 1 ? 0 : 1;
Error += sizeof(glm::int16) == 2 ? 0 : 1;
Error += sizeof(glm::int32) == 4 ? 0 : 1;
Error += sizeof(glm::int64) == 8 ? 0 : 1;
return Error;
}
static int test_comp()
{
int Error = 0;
Error += sizeof(glm::int8) < sizeof(glm::int16) ? 0 : 1;
Error += sizeof(glm::int16) < sizeof(glm::int32) ? 0 : 1;
Error += sizeof(glm::int32) < sizeof(glm::int64) ? 0 : 1;
return Error;
}
int main()
{
int Error = 0;
Error += test_size();
Error += test_comp();
return Error;
}

42
test/ext/ext_scalar_uint_sized.cpp
Unescape View File

@ -0,0 +1,42 @@
#include <glm/ext/scalar_uint_sized.hpp>
GLM_STATIC_ASSERT(sizeof(glm::uint8) == 1, "uint8 size isn't 1 byte on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint16) == sizeof(unsigned short), "unsigned short size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::uint32) == sizeof(unsigned int), "unsigned int size isn't 4 bytes on this platform");
static int test_size()
{
int Error = 0;
Error += sizeof(glm::uint8) == 1 ? 0 : 1;
Error += sizeof(glm::uint16) == 2 ? 0 : 1;
Error += sizeof(glm::uint32) == 4 ? 0 : 1;
Error += sizeof(glm::uint64) == 8 ? 0 : 1;
return Error;
}
static int test_comp()
{
int Error = 0;
Error += sizeof(glm::uint8) < sizeof(glm::uint16) ? 0 : 1;
Error += sizeof(glm::uint16) < sizeof(glm::uint32) ? 0 : 1;
Error += sizeof(glm::uint32) < sizeof(glm::uint64) ? 0 : 1;
return Error;
}
int main()
{
int Error = 0;
Error += test_size();
Error += test_comp();
return Error;
}
Write Preview
Loading…
Cancel
Save