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

Added constexpr test #794

Browse Source
master
Groove ago%!(EXTRA string=7 years)
parent 5df76e830d
commit 178314a67d
8 changed files with 299 additions and 14 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. 4
      glm/detail/qualifier.hpp
  2. 8
      glm/detail/setup.hpp
  3. 2
      glm/gtc/matrix_transform.hpp
  4. 2
      glm/gtc/matrix_transform.inl
  5. 8
      glm/gtc/quaternion.hpp
  6. 10
      glm/gtc/quaternion.inl
  7. 1
      test/core/CMakeLists.txt
  8. 278
      test/core/core_cpp_constexpr.cpp

4
glm/detail/qualifier.hpp
Unescape View File

@ -178,7 +178,7 @@ namespace detail
template<typename genType>
struct init_gentype<genType, GENTYPE_QUAT>
{
GLM_FUNC_QUALIFIER static genType identity()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
{
return genType(1, 0, 0, 0);
}
@ -187,7 +187,7 @@ namespace detail
template<typename genType>
struct init_gentype<genType, GENTYPE_MAT>
{
GLM_FUNC_QUALIFIER static genType identity()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genType identity()
{
return genType(1);
}

8
glm/detail/setup.hpp
Unescape View File

@ -533,9 +533,11 @@ namespace glm
}//namespace glm
///////////////////////////////////////////////////////////////////////////////////
// countof
// constexpr
#if GLM_HAS_CONSTEXPR
# define GLM_USE_CONSTEXP GLM_ENABLE
namespace glm
{
template<typename T, std::size_t N>
@ -546,8 +548,12 @@ namespace glm
}//namespace glm
# define GLM_COUNTOF(arr) glm::countof(arr)
#elif defined(_MSC_VER)
# define GLM_USE_CONSTEXP GLM_DISABLE
# define GLM_COUNTOF(arr) _countof(arr)
#else
# define GLM_USE_CONSTEXP GLM_DISABLE
# define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
#endif

2
glm/gtc/matrix_transform.hpp
Unescape View File

@ -38,7 +38,7 @@ namespace glm
/// Builds an identity matrix.
template<typename genType>
GLM_FUNC_DECL genType identity();
GLM_FUNC_DECL GLM_CONSTEXPR genType identity();
/// Builds a translation 4 * 4 matrix created from a vector of 3 components.
///

2
glm/gtc/matrix_transform.inl
Unescape View File

@ -8,7 +8,7 @@
namespace glm
{
template<typename genType>
GLM_FUNC_QUALIFIER genType identity()
GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType identity()
{
return detail::init_gentype<genType, detail::genTypeTrait<genType>::GENTYPE>::identity();
}

8
glm/gtc/quaternion.hpp
Unescape View File

@ -57,7 +57,7 @@ namespace glm
GLM_FUNC_DECL static GLM_CONSTEXPR length_type length(){return 4;}
GLM_FUNC_DECL T & operator[](length_type i);
GLM_FUNC_DECL T const& operator[](length_type i) const;
GLM_FUNC_DECL GLM_CONSTEXPR T const& operator[](length_type i) const;
// -- Implicit basic constructors --
@ -156,14 +156,14 @@ namespace glm
// -- Boolean operators --
template<typename T, qualifier Q>
GLM_FUNC_DECL bool operator==(tquat<T, Q> const& q1, tquat<T, Q> const& q2);
GLM_FUNC_DECL GLM_CONSTEXPR bool operator==(tquat<T, Q> const& q1, tquat<T, Q> const& q2);
template<typename T, qualifier Q>
GLM_FUNC_DECL bool operator!=(tquat<T, Q> const& q1, tquat<T, Q> const& q2);
GLM_FUNC_DECL GLM_CONSTEXPR bool operator!=(tquat<T, Q> const& q1, tquat<T, Q> const& q2);
/// Builds an identity quaternion.
template<typename genType>
GLM_FUNC_DECL genType identity();
GLM_FUNC_DECL GLM_CONSTEXPR genType identity();
/// Returns the length of the quaternion.
///

10
glm/gtc/quaternion.inl
Unescape View File

@ -82,7 +82,7 @@ namespace detail
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER T const& tquat<T, Q>::operator[](typename tquat<T, Q>::length_type i) const
GLM_FUNC_QUALIFIER GLM_CONSTEXPR T const& tquat<T, Q>::operator[](typename tquat<T, Q>::length_type i) const
{
assert(i >= 0 && i < this->length());
return (&x)[i];
@ -377,15 +377,15 @@ namespace detail
// -- Boolean operators --
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER bool operator==(tquat<T, Q> const& q1, tquat<T, Q> const& q2)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator==(tquat<T, Q> const& q1, tquat<T, Q> const& q2)
{
return all(epsilonEqual(q1, q2, epsilon<T>()));
return q1.x == q2.x && q1.y == q2.y && q1.z == q2.z && q1.w == q2.w;
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER bool operator!=(tquat<T, Q> const& q1, tquat<T, Q> const& q2)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool operator!=(tquat<T, Q> const& q1, tquat<T, Q> const& q2)
{
return any(epsilonNotEqual(q1, q2, epsilon<T>()));
return q1.x != q2.x || q1.y != q2.y || q1.z != q2.z || q1.w != q2.w;
}
// -- Operations --

1
test/core/CMakeLists.txt
Unescape View File

@ -1,3 +1,4 @@
glmCreateTestGTC(core_cpp_constexpr)
glmCreateTestGTC(core_cpp_defaulted_ctor)
glmCreateTestGTC(core_force_aligned_gentypes)
glmCreateTestGTC(core_force_ctor_init)

278
test/core/core_cpp_constexpr.cpp
Unescape View File

@ -0,0 +1,278 @@
#include <glm/glm.hpp>
#if GLM_USE_CONSTEXP == GLM_ENABLE
#include <glm/gtc/constants.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/ext/vector_relational.hpp>
#include <glm/ext/vec1.hpp>
static int test_vec1()
{
int Error = 0;
{
constexpr glm::ivec1 O(glm::ivec1(1));
static_assert(glm::ivec1(1) == O, "GLM: Failed constexpr");
constexpr glm::ivec1 P(1);
static_assert(glm::ivec1(1) == P, "GLM: Failed constexpr");
}
{
constexpr glm::ivec1 L(glm::ivec2(1, 2));
static_assert(glm::ivec1(1) == L, "GLM: Failed constexpr");
constexpr glm::ivec1 M(glm::ivec3(1, 2, 3));
static_assert(glm::ivec1(1) == M, "GLM: Failed constexpr");
constexpr glm::ivec1 N(glm::ivec4(1, 2, 3, 4));
static_assert(glm::ivec1(1) == N, "GLM: Failed constexpr");
}
{
static_assert(glm::vec1(1.0f).x > 0.0f, "GLM: Failed constexpr");
static_assert(glm::vec1::length() == 1, "GLM: Failed constexpr");
}
{
constexpr glm::bvec1 A1(true);
constexpr glm::bvec1 A2(true);
constexpr glm::bvec1 B1(false);
constexpr glm::bvec1 B2(false);
static_assert(A1 == A2 && B1 == B2, "GLM: Failed constexpr");
static_assert(A1 == A2 || B1 == B2, "GLM: Failed constexpr");
}
return Error;
}
static int test_vec2()
{
int Error = 0;
{
constexpr glm::ivec2 O(glm::ivec1(1));
static_assert(glm::ivec2(1) == O, "GLM: Failed constexpr");
constexpr glm::ivec2 A(1);
static_assert(glm::ivec2(1) == A, "GLM: Failed constexpr");
}
{
constexpr glm::ivec2 F(glm::ivec1(1), glm::ivec1(2));
static_assert(glm::ivec2(1, 2) == F, "GLM: Failed constexpr");
constexpr glm::ivec2 G(1, glm::ivec1(2));
static_assert(glm::ivec2(1, 2) == G, "GLM: Failed constexpr");
constexpr glm::ivec2 H(glm::ivec1(1), 2);
static_assert(glm::ivec2(1, 2) == H, "GLM: Failed constexpr");
constexpr glm::ivec2 I(1, 2);
static_assert(glm::ivec2(1, 2) == I, "GLM: Failed constexpr");
}
{
constexpr glm::ivec2 L(glm::ivec2(1, 2));
static_assert(glm::ivec2(1, 2) == L, "GLM: Failed constexpr");
constexpr glm::ivec2 M(glm::ivec3(1, 2, 3));
static_assert(glm::ivec2(1, 2) == M, "GLM: Failed constexpr");
constexpr glm::ivec2 N(glm::ivec4(1, 2, 3, 4));
static_assert(glm::ivec2(1, 2) == N, "GLM: Failed constexpr");
}
{
static_assert(glm::vec2(1.0f).x > 0.0f, "GLM: Failed constexpr");
static_assert(glm::vec2(1.0f, -1.0f).x > 0.0f, "GLM: Failed constexpr");
static_assert(glm::vec2(1.0f, -1.0f).y < 0.0f, "GLM: Failed constexpr");
static_assert(glm::vec2::length() == 2, "GLM: Failed constexpr");
}
{
constexpr glm::bvec2 A1(true);
constexpr glm::bvec2 A2(true);
constexpr glm::bvec2 B1(false);
constexpr glm::bvec2 B2(false);
static_assert(A1 == A2 && B1 == B2, "GLM: Failed constexpr");
static_assert(A1 == A2 || B1 == B2, "GLM: Failed constexpr");
}
return Error;
}
static int test_vec3()
{
int Error = 0;
{
constexpr glm::ivec3 O(glm::ivec1(1));
static_assert(glm::ivec3(1) == O, "GLM: Failed constexpr");
constexpr glm::ivec3 A(1);
static_assert(glm::ivec3(1) == A, "GLM: Failed constexpr");
}
{
constexpr glm::ivec3 B(glm::ivec2(1, 2), 3);
static_assert(glm::ivec3(1, 2, 3) == B, "GLM: Failed constexpr");
constexpr glm::ivec3 C(1, glm::ivec2(2, 3));
static_assert(glm::ivec3(1, 2, 3) == C, "GLM: Failed constexpr");
constexpr glm::ivec3 D(glm::ivec1(1), glm::ivec2(2, 3));
static_assert(glm::ivec3(1, 2, 3) == D, "GLM: Failed constexpr");
constexpr glm::ivec3 E(glm::ivec2(1, 2), glm::ivec1(3));
static_assert(glm::ivec3(1, 2, 3) == E, "GLM: Failed constexpr");
}
{
constexpr glm::ivec3 F(glm::ivec1(1), glm::ivec1(2), glm::ivec1(3));
static_assert(glm::ivec3(1, 2, 3) == F, "GLM: Failed constexpr");
constexpr glm::ivec3 G(1, glm::ivec1(2), glm::ivec1(3));
static_assert(glm::ivec3(1, 2, 3) == G, "GLM: Failed constexpr");
constexpr glm::ivec3 H(glm::ivec1(1), 2, glm::ivec1(3));
static_assert(glm::ivec3(1, 2, 3) == H, "GLM: Failed constexpr");
constexpr glm::ivec3 I(1, 2, glm::ivec1(3));
static_assert(glm::ivec3(1, 2, 3) == I, "GLM: Failed constexpr");
constexpr glm::ivec3 J(glm::ivec1(1), glm::ivec1(2), 3);
static_assert(glm::ivec3(1, 2, 3) == J, "GLM: Failed constexpr");
constexpr glm::ivec3 K(1, glm::ivec1(2), 3);
static_assert(glm::ivec3(1, 2, 3) == K, "GLM: Failed constexpr");
constexpr glm::ivec3 L(glm::ivec1(1), 2, 3);
static_assert(glm::ivec3(1, 2, 3) == L, "GLM: Failed constexpr");
constexpr glm::ivec3 M(1, 2, 3);
static_assert(glm::ivec3(1, 2, 3) == M, "GLM: Failed constexpr");
}
{
constexpr glm::ivec3 N(glm::ivec4(1, 2, 3, 4));
static_assert(glm::ivec3(1, 2, 3) == N, "GLM: Failed constexpr");
}
{
static_assert(glm::vec3(1.0f).x > 0.0f, "GLM: Failed constexpr");
static_assert(glm::vec3(1.0f, -1.0f, -1.0f).x > 0.0f, "GLM: Failed constexpr");
static_assert(glm::vec3(1.0f, -1.0f, -1.0f).y < 0.0f, "GLM: Failed constexpr");
static_assert(glm::vec3::length() == 3, "GLM: Failed constexpr");
}
{
constexpr glm::bvec3 A1(true);
constexpr glm::bvec3 A2(true);
constexpr glm::bvec3 B1(false);
constexpr glm::bvec3 B2(false);
static_assert(A1 == A2 && B1 == B2, "GLM: Failed constexpr");
static_assert(A1 == A2 || B1 == B2, "GLM: Failed constexpr");
}
return Error;
}
static int test_vec4()
{
int Error = 0;
{
constexpr glm::ivec4 O(glm::ivec4(1));
static_assert(glm::ivec4(1) == O, "GLM: Failed constexpr");
constexpr glm::ivec4 A(1);
static_assert(glm::ivec4(1) == A, "GLM: Failed constexpr");
constexpr glm::ivec4 N(glm::ivec4(1, 2, 3, 4));
static_assert(glm::ivec4(1, 2, 3, 4) == N, "GLM: Failed constexpr");
}
{
constexpr glm::ivec4 A(glm::ivec3(1, 2, 3), 4);
static_assert(glm::ivec4(1, 2, 3, 4) == A, "GLM: Failed constexpr");
constexpr glm::ivec4 B(glm::ivec2(1, 2), glm::ivec2(3, 4));
static_assert(glm::ivec4(1, 2, 3, 4) == B, "GLM: Failed constexpr");
constexpr glm::ivec4 C(1, glm::ivec3(2, 3, 4));
static_assert(glm::ivec4(1, 2, 3, 4) == C, "GLM: Failed constexpr");
constexpr glm::ivec4 D(glm::ivec1(1), glm::ivec2(2, 3), glm::ivec1(4));
static_assert(glm::ivec4(1, 2, 3, 4) == D, "GLM: Failed constexpr");
constexpr glm::ivec4 E(glm::ivec2(1, 2), glm::ivec1(3), glm::ivec1(4));
static_assert(glm::ivec4(1, 2, 3, 4) == E, "GLM: Failed constexpr");
constexpr glm::ivec4 F(glm::ivec1(1), glm::ivec1(2), glm::ivec2(3, 4));
static_assert(glm::ivec4(1, 2, 3, 4) == F, "GLM: Failed constexpr");
}
{
static_assert(glm::ivec4(1).x > 0, "GLM: Failed constexpr");
static_assert(glm::ivec4(1.0f, -1.0f, -1.0f, 1.0f).x > 0, "GLM: Failed constexpr");
static_assert(glm::ivec4(1.0f, -1.0f, -1.0f, 1.0f).y < 0, "GLM: Failed constexpr");
static_assert(glm::ivec4::length() == 4, "GLM: Failed constexpr");
}
{
constexpr glm::bvec4 A1(true);
constexpr glm::bvec4 A2(true);
constexpr glm::bvec4 B1(false);
constexpr glm::bvec4 B2(false);
static_assert(A1 == A2 && B1 == B2, "GLM: Failed constexpr");
static_assert(A1 == A2 || B1 == B2, "GLM: Failed constexpr");
}
return Error;
}
static int test_quat()
{
int Error = 0;
{
static_assert(glm::quat::length() == 4, "GLM: Failed constexpr");
static_assert(glm::quat(1.0f, glm::vec3(0.0f)).w > 0.0f, "GLM: Failed constexpr");
static_assert(glm::quat(1.0f, 0.0f, 0.0f, 0.0f).w > 0.0f, "GLM: Failed constexpr");
glm::quat constexpr Q = glm::identity<glm::quat>();
static_assert(Q.x - glm::quat(1.0f, glm::vec3(0.0f)).x <= glm::epsilon<float>(), "GLM: Failed constexpr");
}
return Error;
}
static int test_mat2x2()
{
int Error = 0;
static_assert(glm::mat2x2::length() == 2, "GLM: Failed constexpr");
return Error;
}
#endif//GLM_USE_CONSTEXP == GLM_ENABLE
int main()
{
int Error = 0;
# if GLM_USE_CONSTEXP == GLM_ENABLE
Error += test_vec1();
Error += test_vec2();
Error += test_vec3();
Error += test_vec4();
Error += test_quat();
Error += test_mat2x2();
# endif//GLM_USE_CONSTEXP == GLM_ENABLE
return Error;
}
Write Preview
Loading…
Cancel
Save