mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-09 21:45:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

(GLM) Get rid of GLM_STATIC_ASSERT entirely

Browse Source
This commit is contained in:
twinaphex 2016-11-03 12:51:26 +01:00
parent cb8231a962
commit 0f369ff3a9
5 changed files with 0 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
deps/glm/detail/func_integer.inl vendored
View File

@ -107,8 +107,6 @@ namespace glm
uint & Borrow 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<uint32>(0) : static_cast<uint32>(1);
if(y >= x) if(y >= x)
return y - x; return y - x;
@ -167,8 +165,6 @@ namespace glm
uint & lsb uint & lsb
) )
{ {
GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
uint64 Value64 = static_cast<uint64>(x) * static_cast<uint64>(y); uint64 Value64 = static_cast<uint64>(x) * static_cast<uint64>(y);
msb = Value64 >> 32; msb = Value64 >> 32;
lsb = Value64; lsb = Value64;
@ -226,8 +222,6 @@ namespace glm
int & lsb int & lsb
) )
{ {
GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
int64 Value64 = static_cast<int64>(x) * static_cast<int64>(y); int64 Value64 = static_cast<int64>(x) * static_cast<int64>(y);
msb = Value64 >> 32; msb = Value64 >> 32;
lsb = Value64; lsb = Value64;
@ -346,7 +340,6 @@ namespace glm
int const & Bits int const & Bits
) )
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
assert(Offset + Bits <= sizeof(genIUType)); assert(Offset + Bits <= sizeof(genIUType));
if(Bits == 0) if(Bits == 0)
@ -408,8 +401,6 @@ namespace glm
template <typename genIUType> template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value) GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
genIUType Out = 0; genIUType Out = 0;
std::size_t BitSize = sizeof(genIUType) * 8; std::size_t BitSize = sizeof(genIUType) * 8;
for(std::size_t i = 0; i < BitSize; ++i) for(std::size_t i = 0; i < BitSize; ++i)
@ -424,8 +415,6 @@ namespace glm
template <typename genIUType> template <typename genIUType>
GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value) GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
int Count = 0; int Count = 0;
for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i) for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
{ {
@ -478,7 +467,6 @@ namespace glm
genIUType const & Value genIUType const & Value
) )
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
if(Value == 0) if(Value == 0)
return -1; return -1;
@ -532,7 +520,6 @@ namespace glm
genIUType const & Value genIUType const & Value
) )
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
if(Value == 0) if(Value == 0)
return -1; return -1;
@ -540,29 +527,6 @@ namespace glm
_BitScanReverse(&Result, Value); _BitScanReverse(&Result, Value);
return int(Result); return int(Result);
} }
/*
// __builtin_clz seems to be buggy as it crasks for some values, from 0x00200000 to 80000000
#elif((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC40))
template <typename genIUType>
GLM_FUNC_QUALIFIER int findMSB
(
genIUType const & Value
)
{
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
if(Value == 0)
return -1;
// clz returns the number or trailing 0-bits; see
// http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Other-Builtins.html
//
// NoteBecause __builtin_clz only works for unsigned ints, this
// implementation will not work for 64-bit integers.
//
return 31 - __builtin_clzl(Value);
}
*/
#else #else
/* SSE implementation idea /* SSE implementation idea
@ -589,8 +553,6 @@ namespace glm
genIUType const & Value genIUType const & Value
) )
{ {
GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
if(Value == genIUType(0) || Value == genIUType(-1)) if(Value == genIUType(0) || Value == genIUType(-1))
return -1; return -1;
else if(Value > 0) else if(Value > 0)

6
deps/glm/detail/func_matrix.inl vendored
View File

@ -421,8 +421,6 @@ namespace detail
template <typename T, precision P, template <typename, precision> class matType> template <typename T, precision P, template <typename, precision> class matType>
GLM_FUNC_QUALIFIER matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y) GLM_FUNC_QUALIFIER matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'matrixCompMult' only accept floating-point inputs");
matType<T, P> result(matType<T, P>::_null); matType<T, P> result(matType<T, P>::_null);
for(length_t i = 0; i < result.length(); ++i) for(length_t i = 0; i < result.length(); ++i)
result[i] = x[i] * y[i]; result[i] = x[i] * y[i];
@ -432,28 +430,24 @@ namespace detail
template<typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB> template<typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r) GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'outerProduct' only accept floating-point inputs");
return detail::compute_outerProduct<vecTypeA, vecTypeB, T, P>::call(c, r); return detail::compute_outerProduct<vecTypeA, vecTypeB, T, P>::call(c, r);
} }
template <typename T, precision P, template <typename, precision> class matType> template <typename T, precision P, template <typename, precision> class matType>
GLM_FUNC_QUALIFIER typename matType<T, P>::transpose_type transpose(matType<T, P> const & m) GLM_FUNC_QUALIFIER typename matType<T, P>::transpose_type transpose(matType<T, P> const & m)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'transpose' only accept floating-point inputs");
return detail::compute_transpose<matType, T, P>::call(m); return detail::compute_transpose<matType, T, P>::call(m);
} }
template <typename T, precision P, template <typename, precision> class matType> template <typename T, precision P, template <typename, precision> class matType>
GLM_FUNC_QUALIFIER T determinant(matType<T, P> const & m) GLM_FUNC_QUALIFIER T determinant(matType<T, P> const & m)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'determinant' only accept floating-point inputs");
return detail::compute_determinant<matType, T, P>::call(m); return detail::compute_determinant<matType, T, P>::call(m);
} }
template <typename T, precision P, template <typename, precision> class matType> template <typename T, precision P, template <typename, precision> class matType>
GLM_FUNC_QUALIFIER matType<T, P> inverse(matType<T, P> const & m) GLM_FUNC_QUALIFIER matType<T, P> inverse(matType<T, P> const & m)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inverse' only accept floating-point inputs");
return detail::compute_inverse<matType, T, P>::call(m); return detail::compute_inverse<matType, T, P>::call(m);
} }

21
deps/glm/detail/setup.hpp vendored
View File

@ -486,13 +486,6 @@
// http://gcc.gnu.org/projects/cxx0x.html // http://gcc.gnu.org/projects/cxx0x.html
// http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx // http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx
// N1720
#define GLM_HAS_STATIC_ASSERT ( \
(GLM_LANG & GLM_LANG_CXX11_FLAG) || \
((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC10)) || \
((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC43)) || \
__has_feature(cxx_static_assert))
// N1988 // N1988
#define GLM_HAS_EXTENDED_INTEGER_TYPE ( \ #define GLM_HAS_EXTENDED_INTEGER_TYPE ( \
(GLM_LANG & GLM_LANG_CXX11_FLAG) || \ (GLM_LANG & GLM_LANG_CXX11_FLAG) || \
@ -612,20 +605,6 @@
//#define GLM_FORCE_RADIANS //#define GLM_FORCE_RADIANS
///////////////////////////////////////////////////////////////////////////////////////////////////
// Static assert
#if GLM_HAS_STATIC_ASSERT
# define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
#elif(defined(BOOST_STATIC_ASSERT))
# define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
#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)
# define GLM_STATIC_ASSERT_NULL
#endif//GLM_LANG
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
// Qualifiers // Qualifiers

8
deps/glm/detail/type_float.hpp vendored
View File

@ -80,14 +80,6 @@ namespace detail
typedef float float32; typedef float float32;
typedef double float64; typedef double float64;
////////////////////
// check type sizes
#ifndef GLM_STATIC_ASSERT_NULL
GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
#endif//GLM_STATIC_ASSERT_NULL
/// @} /// @}
}//namespace glm }//namespace glm

15
deps/glm/detail/type_int.hpp vendored
View File

@ -171,21 +171,6 @@ namespace detail
typedef unsigned int uint; 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 }//namespace glm
#endif//glm_core_type_int #endif//glm_core_type_int