From cb4ca81d9b4b09664a797bcc2b8cf94accb8a2a1 Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Thu, 9 Aug 2018 14:46:38 +0200 Subject: [PATCH] Clean up quaternion relational API --- glm/ext/quaternion_geometric.hpp | 2 +- glm/ext/quaternion_relational.hpp | 36 ------- glm/ext/quaternion_relational.inl | 39 +------- glm/gtc/quaternion.hpp | 129 +++++++------------------ glm/gtc/quaternion.inl | 36 +++++++ test/ext/CMakeLists.txt | 1 + test/ext/ext_quaternion_geometric.cpp | 85 ++++++++++++++++ test/ext/ext_quaternion_relational.cpp | 128 +++++------------------- 8 files changed, 187 insertions(+), 269 deletions(-) create mode 100644 test/ext/ext_quaternion_geometric.cpp diff --git a/glm/ext/quaternion_geometric.hpp b/glm/ext/quaternion_geometric.hpp index cc209aa2..33f2875d 100644 --- a/glm/ext/quaternion_geometric.hpp +++ b/glm/ext/quaternion_geometric.hpp @@ -35,7 +35,7 @@ namespace glm /// @addtogroup ext_quaternion_geometric /// @{ - /// Returns the length of the quaternion. + /// Returns the norm of a quaternions /// /// @tparam T Floating-point scalar types. /// diff --git a/glm/ext/quaternion_relational.hpp b/glm/ext/quaternion_relational.hpp index e5dd2318..28cb6d0e 100644 --- a/glm/ext/quaternion_relational.hpp +++ b/glm/ext/quaternion_relational.hpp @@ -22,42 +22,6 @@ namespace glm /// @addtogroup ext_quaternion_relational /// @{ - /// Returns the component-wise comparison result of x < y. - /// - /// @tparam T Floating-point scalar types - /// @tparam Q Value from qualifier enum - /// - /// @see ext_quaternion_relational - template - GLM_FUNC_DECL vec<4, bool, Q> lessThan(qua const& x, qua const& y); - - /// Returns the component-wise comparison of result x <= y. - /// - /// @tparam T Floating-point scalar types - /// @tparam Q Value from qualifier enum - /// - /// @see ext_quaternion_relational - template - GLM_FUNC_DECL vec<4, bool, Q> lessThanEqual(qua const& x, qua const& y); - - /// Returns the component-wise comparison of result x > y. - /// - /// @tparam T Floating-point scalar types - /// @tparam Q Value from qualifier enum - /// - /// @see ext_quaternion_relational - template - GLM_FUNC_DECL vec<4, bool, Q> greaterThan(qua const& x, qua const& y); - - /// Returns the component-wise comparison of result x >= y. - /// - /// @tparam T Floating-point scalar types - /// @tparam Q Value from qualifier enum - /// - /// @see ext_quaternion_relational - template - GLM_FUNC_DECL vec<4, bool, Q> greaterThanEqual(qua const& x, qua const& y); - /// Returns the component-wise comparison of result x == y. /// /// @tparam T Floating-point scalar types diff --git a/glm/ext/quaternion_relational.inl b/glm/ext/quaternion_relational.inl index be071c29..6d4adc09 100644 --- a/glm/ext/quaternion_relational.inl +++ b/glm/ext/quaternion_relational.inl @@ -1,43 +1,8 @@ -#include "../detail/compute_vector_relational.hpp" +#include "./quaternion_geometric.hpp" +#include "../vector_relational.hpp" namespace glm { - template - GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThan(qua const& x, qua const& y) - { - vec<4, bool, Q> Result; - for(length_t i = 0; i < x.length(); ++i) - Result[i] = x[i] < y[i]; - return Result; - } - - template - GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThanEqual(qua const& x, qua const& y) - { - vec<4, bool, Q> Result; - for(length_t i = 0; i < x.length(); ++i) - Result[i] = x[i] <= y[i]; - return Result; - } - - template - GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThan(qua const& x, qua const& y) - { - vec<4, bool, Q> Result; - for(length_t i = 0; i < x.length(); ++i) - Result[i] = x[i] > y[i]; - return Result; - } - - template - GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThanEqual(qua const& x, qua const& y) - { - vec<4, bool, Q> Result; - for(length_t i = 0; i < x.length(); ++i) - Result[i] = x[i] >= y[i]; - return Result; - } - template GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua const& x, qua const& y) { diff --git a/glm/gtc/quaternion.hpp b/glm/gtc/quaternion.hpp index e326ff4f..fe49fd98 100644 --- a/glm/gtc/quaternion.hpp +++ b/glm/gtc/quaternion.hpp @@ -37,34 +37,6 @@ namespace glm /// @addtogroup gtc_quaternion /// @{ - /// Builds an identity quaternion. - template - GLM_FUNC_DECL GLM_CONSTEXPR genType identity(); - - /// Returns the length of the quaternion. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL T length(qua const& q); - - /// Returns the normalized quaternion. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL qua normalize(qua const& q); - - /// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL T dot(qua const& x, qua const& y); - /// Spherical linear interpolation of two quaternions. /// The interpolation is oriented and the rotation is performed at constant speed. /// For short path spherical linear interpolation, use the slerp function. @@ -221,71 +193,6 @@ namespace glm template GLM_FUNC_DECL qua angleAxis(T const& angle, vec<3, T, Q> const& axis); - /// Returns the component-wise comparison result of x < y. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL vec<4, bool, Q> lessThan(qua const& x, qua const& y); - - /// Returns the component-wise comparison of result x <= y. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL vec<4, bool, Q> lessThanEqual(qua const& x, qua const& y); - - /// Returns the component-wise comparison of result x > y. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL vec<4, bool, Q> greaterThan(qua const& x, qua const& y); - - /// Returns the component-wise comparison of result x >= y. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL vec<4, bool, Q> greaterThanEqual(qua const& x, qua const& y); - - /// Returns the component-wise comparison of result x == y. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL vec<4, bool, Q> equal(qua const& x, qua const& y); - - /// Returns the component-wise comparison of |x - y| < epsilon. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL vec<4, bool, Q> equal(qua const& x, qua const& y, T epsilon); - - /// Returns the component-wise comparison of result x != y. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua const& x, qua const& y); - - /// Returns the component-wise comparison of |x - y| >= epsilon. - /// - /// @tparam T Floating-point scalar types. - /// - /// @see gtc_quaternion - template - GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua const& x, qua const& y, T epsilon); - - /// Returns true if x holds a NaN (not a number) /// representation in the underlying implementation's set of /// floating point representations. Returns false otherwise, @@ -312,6 +219,42 @@ namespace glm template GLM_FUNC_DECL vec<4, bool, Q> isinf(qua const& x); + /// Returns the component-wise comparison result of x < y. + /// + /// @tparam T Floating-point scalar types + /// @tparam Q Value from qualifier enum + /// + /// @see ext_quaternion_relational + template + GLM_FUNC_DECL vec<4, bool, Q> lessThan(qua const& x, qua const& y); + + /// Returns the component-wise comparison of result x <= y. + /// + /// @tparam T Floating-point scalar types + /// @tparam Q Value from qualifier enum + /// + /// @see ext_quaternion_relational + template + GLM_FUNC_DECL vec<4, bool, Q> lessThanEqual(qua const& x, qua const& y); + + /// Returns the component-wise comparison of result x > y. + /// + /// @tparam T Floating-point scalar types + /// @tparam Q Value from qualifier enum + /// + /// @see ext_quaternion_relational + template + GLM_FUNC_DECL vec<4, bool, Q> greaterThan(qua const& x, qua const& y); + + /// Returns the component-wise comparison of result x >= y. + /// + /// @tparam T Floating-point scalar types + /// @tparam Q Value from qualifier enum + /// + /// @see ext_quaternion_relational + template + GLM_FUNC_DECL vec<4, bool, Q> greaterThanEqual(qua const& x, qua const& y); + /// @} } //namespace glm diff --git a/glm/gtc/quaternion.inl b/glm/gtc/quaternion.inl index 1a0c4f2c..a548ccb7 100644 --- a/glm/gtc/quaternion.inl +++ b/glm/gtc/quaternion.inl @@ -336,6 +336,42 @@ namespace glm return vec<4, bool, Q>(isinf(q.x), isinf(q.y), isinf(q.z), isinf(q.w)); } + + template + GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThan(qua const& A, qua const& B) + { + vec<4, bool, Q> Result; + for(length_t i = 0; i < x.length(); ++i) + Result[i] = x[i] < y[i]; + return Result; + } + + template + GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThanEqual(qua const& x, qua const& y) + { + vec<4, bool, Q> Result; + for(length_t i = 0; i < x.length(); ++i) + Result[i] = x[i] <= y[i]; + return Result; + } + + template + GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThan(qua const& x, qua const& y) + { + vec<4, bool, Q> Result; + for(length_t i = 0; i < x.length(); ++i) + Result[i] = x[i] > y[i]; + return Result; + } + + template + GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThanEqual(qua const& x, qua const& y) + { + vec<4, bool, Q> Result; + for(length_t i = 0; i < x.length(); ++i) + Result[i] = x[i] >= y[i]; + return Result; + } }//namespace glm #if GLM_CONFIG_SIMD == GLM_ENABLE diff --git a/test/ext/CMakeLists.txt b/test/ext/CMakeLists.txt index 181a7ba1..407b6307 100644 --- a/test/ext/CMakeLists.txt +++ b/test/ext/CMakeLists.txt @@ -1,4 +1,5 @@ glmCreateTestGTC(ext_matrix_relational) +glmCreateTestGTC(ext_quaternion_geometric) glmCreateTestGTC(ext_quaternion_relational) glmCreateTestGTC(ext_quaternion_type) glmCreateTestGTC(ext_scalar_relational) diff --git a/test/ext/ext_quaternion_geometric.cpp b/test/ext/ext_quaternion_geometric.cpp new file mode 100644 index 00000000..a4f8df30 --- /dev/null +++ b/test/ext/ext_quaternion_geometric.cpp @@ -0,0 +1,85 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +static int test_angle() +{ + int Error = 0; + + { + glm::quat const Q = glm::quat(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0)); + float const A = glm::degrees(glm::angle(Q)); + Error += glm::equal(A, 90.0f, glm::epsilon()) ? 0 : 1; + } + + { + glm::quat const Q = glm::quat(glm::vec3(0, 1, 0), glm::vec3(1, 0, 0)); + float const A = glm::degrees(glm::angle(Q)); + Error += glm::equal(A, 90.0f, glm::epsilon()) ? 0 : 1; + } + + return Error; +} + +static int test_length() +{ + int Error = 0; + + { + float const A = glm::length(glm::quat(1, 0, 0, 0)); + Error += glm::equal(A, 1.0f, glm::epsilon()) ? 0 : 1; + } + + { + float const A = glm::length(glm::quat(1, glm::vec3(0))); + Error += glm::equal(A, 1.0f, glm::epsilon()) ? 0 : 1; + } + + { + float const A = glm::length(glm::quat(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0))); + Error += glm::equal(A, 1.0f, glm::epsilon()) ? 0 : 1; + } + + return Error; +} + +static int test_normalize() +{ + int Error = 0; + + { + glm::quat const A = glm::quat(1, 0, 0, 0); + glm::quat const N = glm::normalize(A); + Error += glm::all(glm::equal(A, N, glm::epsilon())) ? 0 : 1; + } + + { + glm::quat const A = glm::quat(1, glm::vec3(0)); + glm::quat const N = glm::normalize(A); + Error += glm::all(glm::equal(A, N, glm::epsilon())) ? 0 : 1; + } + + return Error; +} + + +int main() +{ + int Error = 0; + + Error += test_angle(); + Error += test_length(); + Error += test_normalize(); + + return Error; +} diff --git a/test/ext/ext_quaternion_relational.cpp b/test/ext/ext_quaternion_relational.cpp index 7d7fae14..7f51fdc9 100644 --- a/test/ext/ext_quaternion_relational.cpp +++ b/test/ext/ext_quaternion_relational.cpp @@ -1,127 +1,51 @@ #include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include -#include +#include +#include +#include -template -static int test_operators() +template +static int test_equal() { int Error = 0; - { - genType const A(1); - genType const B(1); - - genType const C = A + B; - Error += glm::all(glm::equal(C, genType(2), glm::epsilon())) ? 0 : 1; - - genType const D = A - B; - Error += glm::all(glm::equal(D, genType(0), glm::epsilon())) ? 0 : 1; - - genType const E = A * B; - Error += glm::all(glm::equal(E, genType(1), glm::epsilon())) ? 0 : 1; - - genType const F = A / B; - Error += glm::all(glm::equal(F, genType(1), glm::epsilon())) ? 0 : 1; - } + quaType const Q(1, 0, 0, 0); + quaType const P(1, 0, 0, 0); + Error += glm::all(glm::equal(Q, P, glm::epsilon())) ? 0 : 1; return Error; } -template -static int test_ctor() +template +static int test_notEqual() { int Error = 0; - glm::vec1 const A = genType(1); - - glm::vec1 const E(genType(1)); - Error += glm::all(glm::equal(A, E, glm::epsilon())) ? 0 : 1; - - glm::vec1 const F(E); - Error += glm::all(glm::equal(A, F, glm::epsilon())) ? 0 : 1; - - genType const B = genType(1); - genType const G(glm::vec2(1)); - Error += glm::all(glm::equal(B, G, glm::epsilon())) ? 0 : 1; - - genType const H(glm::vec3(1)); - Error += glm::all(glm::equal(B, H, glm::epsilon())) ? 0 : 1; - - genType const I(glm::vec4(1)); - Error += glm::all(glm::equal(B, I, glm::epsilon())) ? 0 : 1; + quaType const Q(1, 0, 0, 0); + quaType const P(1, 0, 0, 0); + Error += glm::any(glm::notEqual(Q, P, glm::epsilon())) ? 1 : 0; return Error; } -template -static int test_size() -{ - int Error = 0; - - Error += sizeof(glm::vec1) == sizeof(genType) ? 0 : 1; - Error += genType().length() == 1 ? 0 : 1; - Error += genType::length() == 1 ? 0 : 1; - - return Error; -} - -template -static int test_relational() -{ - int Error = 0; - - genType const A(1); - genType const B(1); - genType const C(0); - - Error += all(equal(A, B, glm::epsilon())) ? 0 : 1; - Error += any(notEqual(A, C, glm::epsilon())) ? 0 : 1; - - return Error; -} - -template -static int test_constexpr() -{ -# if GLM_CONFIG_CONSTEXP == GLM_ENABLE - static_assert(genType::length() == 1, "GLM: Failed constexpr"); -# endif - - return 0; -} - int main() { int Error = 0; - Error += test_operators(); - Error += test_operators(); - Error += test_operators(); - Error += test_operators(); + Error += test_equal(); + Error += test_equal(); + Error += test_equal(); + Error += test_equal(); - Error += test_ctor(); - Error += test_ctor(); - Error += test_ctor(); - Error += test_ctor(); - - Error += test_size(); - Error += test_size(); - Error += test_size(); - Error += test_size(); - - Error += test_relational(); - Error += test_relational(); - Error += test_relational(); - Error += test_relational(); - - Error += test_constexpr(); - Error += test_constexpr(); - Error += test_constexpr(); - Error += test_constexpr(); + Error += test_notEqual(); + Error += test_notEqual(); + Error += test_notEqual(); + Error += test_notEqual(); return Error; }