From 1a4bc0d8a55123b06fdb7e866da9a8b9172446a4 Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Sun, 16 Nov 2014 20:52:54 +0100 Subject: [PATCH] Added more geometric function tests --- readme.txt | 2 +- test/core/core_func_geometric.cpp | 195 ++++++++++++++++++++++++------ 2 files changed, 156 insertions(+), 41 deletions(-) diff --git a/readme.txt b/readme.txt index 1690d847..6f7e6cb0 100644 --- a/readme.txt +++ b/readme.txt @@ -37,7 +37,7 @@ More informations in GLM manual: http://glm.g-truc.net/glm.pdf ================================================================================ -GLM 0.9.6.0: 2014-XX-XX +GLM 0.9.6.0: 2014-11-XX -------------------------------------------------------------------------------- Features: - Added transparent use of SIMD instructions for vec4 and mat4 types diff --git a/test/core/core_func_geometric.cpp b/test/core/core_func_geometric.cpp index 07aa34c9..62038895 100644 --- a/test/core/core_func_geometric.cpp +++ b/test/core/core_func_geometric.cpp @@ -2,69 +2,184 @@ // OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net) /////////////////////////////////////////////////////////////////////////////////////////////////// // Created : 2011-01-15 -// Updated : 2011-11-14 +// Updated : 2014-11-16 // Licence : This source is under MIT licence // File : test/core/func_geometric.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// #include +#include #include +#include +#include -int test_reflect() +namespace length { - int Error = 0; - + int test() { - glm::vec2 A(1.0f,-1.0f); - glm::vec2 B(0.0f, 1.0f); - glm::vec2 C = glm::reflect(A, B); - Error += C == glm::vec2(1.0, 1.0) ? 0 : 1; + float Length1 = glm::length(glm::vec1(1)); + float Length2 = glm::length(glm::vec2(1, 0)); + float Length3 = glm::length(glm::vec3(1, 0, 0)); + float Length4 = glm::length(glm::vec4(1, 0, 0, 0)); + + int Error = 0; + + Error += glm::abs(Length1 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Length2 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Length3 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Length4 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; + + return Error; } +}//namespace length - { - glm::dvec2 A(1.0f,-1.0f); - glm::dvec2 B(0.0f, 1.0f); - glm::dvec2 C = glm::reflect(A, B); - Error += C == glm::dvec2(1.0, 1.0) ? 0 : 1; - } - - return Error; -} - -int test_refract() +namespace distance { - int Error = 0; - + int test() { - float A(-1.0f); - float B(1.0f); - float C = glm::refract(A, B, 0.5f); - Error += C == -1.0f ? 0 : 1; - } + float Distance1 = glm::distance(glm::vec1(1), glm::vec1(1)); + float Distance2 = glm::distance(glm::vec2(1, 0), glm::vec2(1, 0)); + float Distance3 = glm::distance(glm::vec3(1, 0, 0), glm::vec3(1, 0, 0)); + float Distance4 = glm::distance(glm::vec4(1, 0, 0, 0), glm::vec4(1, 0, 0, 0)); + int Error = 0; + + Error += glm::abs(Distance1) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Distance2) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Distance3) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Distance4) < std::numeric_limits::epsilon() ? 0 : 1; + + return Error; + } +}//namespace distance + +namespace dot +{ + int test() { - glm::vec2 A(0.0f,-1.0f); - glm::vec2 B(0.0f, 1.0f); - glm::vec2 C = glm::refract(A, B, 0.5f); - Error += glm::all(glm::epsilonEqual(C, glm::vec2(0.0, -1.0), 0.0001f)) ? 0 : 1; - } + float Dot1 = glm::dot(glm::vec1(1), glm::vec1(1)); + float Dot2 = glm::dot(glm::vec2(1), glm::vec2(1)); + float Dot3 = glm::dot(glm::vec3(1), glm::vec3(1)); + float Dot4 = glm::dot(glm::vec4(1), glm::vec4(1)); + int Error = 0; + + Error += glm::abs(Dot1 - 1.0f) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Dot2 - 2.0f) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Dot3 - 3.0f) < std::numeric_limits::epsilon() ? 0 : 1; + Error += glm::abs(Dot4 - 4.0f) < std::numeric_limits::epsilon() ? 0 : 1; + + return Error; + } +}//namespace dot + +namespace cross +{ + int test() { - glm::dvec2 A(0.0f,-1.0f); - glm::dvec2 B(0.0f, 1.0f); - glm::dvec2 C = glm::refract(A, B, 0.5); - Error += C == glm::dvec2(0.0, -1.0) ? 0 : 1; - } + glm::vec3 Cross1 = glm::cross(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0)); + glm::vec3 Cross2 = glm::cross(glm::vec3(0, 1, 0), glm::vec3(1, 0, 0)); - return Error; -} + int Error = 0; + + Error += glm::all(glm::lessThan(glm::abs(Cross1 - glm::vec3(0, 0, 1)), glm::vec3(std::numeric_limits::epsilon()))) ? 0 : 1; + Error += glm::all(glm::lessThan(glm::abs(Cross2 - glm::vec3(0, 0,-1)), glm::vec3(std::numeric_limits::epsilon()))) ? 0 : 1; + + return Error; + } +}//namespace cross + +namespace normalize +{ + int test() + { + glm::vec3 Normalize1 = glm::normalize(glm::vec3(1, 0, 0)); + glm::vec3 Normalize2 = glm::normalize(glm::vec3(2, 0, 0)); + + int Error = 0; + + Error += glm::all(glm::lessThan(glm::abs(Normalize1 - glm::vec3(1, 0, 0)), glm::vec3(std::numeric_limits::epsilon()))) ? 0 : 1; + Error += glm::all(glm::lessThan(glm::abs(Normalize2 - glm::vec3(1, 0, 0)), glm::vec3(std::numeric_limits::epsilon()))) ? 0 : 1; + + return Error; + } +}//namespace normalize + +namespace faceforward +{ + int test() + { + return 0; + } +}//namespace faceforward + +namespace reflect +{ + int test() + { + int Error = 0; + + { + glm::vec2 A(1.0f,-1.0f); + glm::vec2 B(0.0f, 1.0f); + glm::vec2 C = glm::reflect(A, B); + Error += C == glm::vec2(1.0, 1.0) ? 0 : 1; + } + + { + glm::dvec2 A(1.0f,-1.0f); + glm::dvec2 B(0.0f, 1.0f); + glm::dvec2 C = glm::reflect(A, B); + Error += C == glm::dvec2(1.0, 1.0) ? 0 : 1; + } + + return Error; + } +}//namespace reflect + +namespace refract +{ + int test() + { + int Error = 0; + + { + float A(-1.0f); + float B(1.0f); + float C = glm::refract(A, B, 0.5f); + Error += C == -1.0f ? 0 : 1; + } + + { + glm::vec2 A(0.0f,-1.0f); + glm::vec2 B(0.0f, 1.0f); + glm::vec2 C = glm::refract(A, B, 0.5f); + Error += glm::all(glm::epsilonEqual(C, glm::vec2(0.0, -1.0), 0.0001f)) ? 0 : 1; + } + + { + glm::dvec2 A(0.0f,-1.0f); + glm::dvec2 B(0.0f, 1.0f); + glm::dvec2 C = glm::refract(A, B, 0.5); + Error += C == glm::dvec2(0.0, -1.0) ? 0 : 1; + } + + return Error; + } +}//namespace refract int main() { int Error(0); - Error += test_reflect(); - Error += test_refract(); + Error += length::test(); + Error += distance::test(); + Error += dot::test(); + Error += cross::test(); + Error += normalize::test(); + Error += faceforward::test(); + Error += reflect::test(); + Error += refract::test(); return Error; }