From 9ab9e95ce5a2a8a2b8f6c12670c23a8b8df689e8 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 12 Sep 2019 06:56:44 +0300 Subject: [PATCH 001/103] Custom Built-in Unit Test Suite (#105) * tests: new built-in test runner * tests: update tests for new builtin test api * tests: print test suite logs * tests: remove cmocka from build files * tests: colorize test suite log and remove redundant prints --- .github/workflows/ccpp.yml | 24 ---------- .gitignore | 2 +- Makefile.am | 14 ++---- configure.ac | 2 +- post-build.sh | 24 ---------- test/include/common.h | 81 +++++++++++++++++++++++++++++++ test/runner.c | 68 ++++++++++++++++++++++++++ test/src/test_affine.c | 27 ++++++----- test/src/test_bezier.c | 17 +++---- test/src/test_cam.c | 29 ++++++------ test/src/test_clamp.c | 25 +++++----- test/src/test_common.c | 96 +++++++++++++++++++++---------------- test/src/test_common.h | 35 +++++--------- test/src/test_euler.c | 15 +++--- test/src/test_main.c | 48 ------------------- test/src/test_mat3.c | 59 +++++++++++++++-------- test/src/test_mat4.c | 74 +++++++++++++++++------------ test/src/test_project.c | 11 +++-- test/src/test_quat.c | 51 ++++++++++---------- test/src/test_tests.h | 46 ------------------ test/src/test_vec3.c | 57 +++++++++++----------- test/src/test_vec4.c | 74 ++++++++++++++--------------- test/tests.h | 97 ++++++++++++++++++++++++++++++++++++++ 23 files changed, 561 insertions(+), 415 deletions(-) delete mode 100644 .github/workflows/ccpp.yml delete mode 100644 post-build.sh create mode 100644 test/include/common.h create mode 100644 test/runner.c delete mode 100644 test/src/test_main.c delete mode 100644 test/src/test_tests.h create mode 100644 test/tests.h diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml deleted file mode 100644 index 3621c64..0000000 --- a/.github/workflows/ccpp.yml +++ /dev/null @@ -1,24 +0,0 @@ -name: C/C++ CI - -on: [push] - -jobs: - build: - - runs-on: ${{ matrix.os }} - strategy: - matrix: - os: [ubuntu-latest, macOS-latest] - - steps: - - uses: actions/checkout@v1 - - name: dependencies - run: sh ./build-deps.sh - - name: autogen - run: sh autogen.sh - - name: configure - run: ./configure - - name: make - run: make - - name: make check - run: make check diff --git a/.gitignore b/.gitignore index 0655cc2..90ccabb 100644 --- a/.gitignore +++ b/.gitignore @@ -51,7 +51,6 @@ cscope.* test/*.trs test/test_* *.log -test-* test/.libs/* test/tests cglm_arm/* @@ -71,3 +70,4 @@ win/x85 win/Debug cglm-test-ios* /cglm.pc +test-driver diff --git a/Makefile.am b/Makefile.am index 922aefe..d0a8c3a 100644 --- a/Makefile.am +++ b/Makefile.am @@ -7,7 +7,6 @@ #****************************************************************************** ACLOCAL_AMFLAGS = -I m4 - AM_CFLAGS = -Wall \ -std=gnu99 \ -O3 \ @@ -19,12 +18,9 @@ lib_LTLIBRARIES = libcglm.la libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0 checkLDFLAGS = -L./.libs \ - -L./test/lib/cmocka/build/src \ - -lcmocka \ -lm \ -lcglm -checkCFLAGS = -I./test/lib/cmocka/include \ - -I./include +checkCFLAGS = -I./include check_PROGRAMS = test/tests TESTS = $(check_PROGRAMS) @@ -140,8 +136,8 @@ libcglm_la_SOURCES=\ src/bezier.c test_tests_SOURCES=\ + test/runner.c \ test/src/test_common.c \ - test/src/test_main.c \ test/src/test_mat4.c \ test/src/test_cam.c \ test/src/test_project.c \ @@ -160,7 +156,7 @@ pkgconfig_DATA=cglm.pc # the source directory that post-build.sh is in. When not # using a prefix, $VPATH will be unset, so we need to fall # back to using . to run the script. -export VPATH +#export VPATH -all-local: - sh $${VPATH:-.}/post-build.sh +# all-local: +# sh $${VPATH:-.}/post-build.sh diff --git a/configure.ac b/configure.ac index 071ac47..23de6da 100644 --- a/configure.ac +++ b/configure.ac @@ -8,7 +8,7 @@ AC_PREREQ([2.69]) AC_INIT([cglm], [0.6.0], [info@recp.me]) -AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects]) +AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests]) AC_CONFIG_MACRO_DIR([m4]) AC_CONFIG_SRCDIR([src/]) diff --git a/post-build.sh b/post-build.sh deleted file mode 100644 index 6fa6e7a..0000000 --- a/post-build.sh +++ /dev/null @@ -1,24 +0,0 @@ -#! /bin/sh -# -# Copyright (c), Recep Aslantas. -# -# MIT License (MIT), http://opensource.org/licenses/MIT -# Full license can be found in the LICENSE file -# - -cd $(dirname "$0") - -mkdir -p "$(pwd)/.libs" - -libmocka_folder=$(pwd)/test/lib/cmocka/build/src/ - -if [ "$(uname)" = "Darwin" ]; then - libcmocka=libcmocka.0.dylib -else - libcmocka=libcmocka.so.0 -fi - -libcmocka_path="$libmocka_folder$libcmocka" -if [ -f "$libcmocka_path" ]; then - ln -sf "$libcmocka_path" "$(pwd)/.libs/$libcmocka"; -fi diff --git a/test/include/common.h b/test/include/common.h new file mode 100644 index 0000000..e58edc2 --- /dev/null +++ b/test/include/common.h @@ -0,0 +1,81 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#ifndef tests_common_h +#define tests_common_h + +#include +#include + +#include +#include +#include + +typedef struct test_status_t { + const char *msg; + int status; +} test_status_t; + +typedef test_status_t (*fntest)(void); + +typedef struct test_entry_t { + char *name; + fntest entry; + int ret; + int show_output; +} test_entry_t; + +#define RESET "\033[0m" +#define BLACK "\033[30m" /* Black */ +#define RED "\033[31m" /* Red */ +#define GREEN "\033[32m" /* Green */ +#define YELLOW "\033[33m" /* Yellow */ +#define BLUE "\033[34m" /* Blue */ +#define MAGENTA "\033[35m" /* Magenta */ +#define CYAN "\033[36m" /* Cyan */ +#define WHITE "\033[37m" /* White */ +#define BOLDBLACK "\033[1m\033[30m" /* Bold Black */ +#define BOLDRED "\033[1m\033[31m" /* Bold Red */ +#define BOLDGREEN "\033[1m\033[32m" /* Bold Green */ +#define BOLDYELLOW "\033[1m\033[33m" /* Bold Yellow */ +#define BOLDBLUE "\033[1m\033[34m" /* Bold Blue */ +#define BOLDMAGENTA "\033[1m\033[35m" /* Bold Magenta */ +#define BOLDCYAN "\033[1m\033[36m" /* Bold Cyan */ +#define BOLDWHITE "\033[1m\033[37m" /* Bold White */ + +#define TEST_DECLARE(FUN) test_status_t test_ ## FUN(void); +#define TEST_ENTRY(FUN) { #FUN, test_ ## FUN, 0, 0 }, +#define TEST_LIST static test_entry_t tests[] = + +#define ASSERT_EXT(expr, msg) \ + if (!(expr)) { \ + fprintf(stderr, \ + RED " assert fail" RESET \ + " in " BOLDCYAN "%s " RESET \ + "on " BOLDMAGENTA "line %d" RESET \ + " : " BOLDWHITE " ASSERT(%s)\n" RESET, \ + __FILE__, \ + __LINE__, \ + #expr); \ + return (test_status_t){msg, 0}; \ + } + +#define ASSERT_ARG1(expr) ASSERT_EXT(expr, NULL) +#define ASSERT_ARG2(expr, msg) ASSERT_EXT(expr, msg) +#define ASSERT_ARG3(arg1, arg2, arg3, ...) arg3 + +#define ASSERT_CHOOSER(...) ASSERT_ARG3(__VA_ARGS__, ASSERT_ARG2, ASSERT_ARG1) +#define ASSERT(...) do { ASSERT_CHOOSER(__VA_ARGS__)(__VA_ARGS__) } while(0); + +#define TEST_OK 1 +#define TEST_SUCCESS return (test_status_t){NULL, TEST_OK}; + +#define TEST_IMPL(FUN) \ + test_status_t test_ ## FUN (void); \ + test_status_t test_ ## FUN() + +#endif /* common_h */ diff --git a/test/runner.c b/test/runner.c new file mode 100644 index 0000000..10f8d11 --- /dev/null +++ b/test/runner.c @@ -0,0 +1,68 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "include/common.h" +#include "tests.h" + +#include + +int +main(int argc, const char * argv[]) { + test_entry_t *entry; + test_status_t st; + int32_t i, count, passed, failed; + + passed = failed = 0; + count = sizeof(tests) / sizeof(tests[0]); + + fprintf(stderr, CYAN "\nWelcome to cglm tests\n\n" RESET); + + for (i = 0; i < count; i++) { + entry = tests + i; + st = entry->entry(); + + if (!st.status) { + fprintf(stderr, + BOLDRED " 𐄂" BOLDWHITE " %s " RESET, + entry->name); + if (st.msg) { + fprintf(stderr, + YELLOW "- %s" RESET, + st.msg); + } + + fprintf(stderr, "\n"); + + failed++; + } else { + fprintf(stderr, + GREEN " ✔︎" RESET " %s\n" + , + entry->name); + passed++; + } + } + + if (failed == 0) { + fprintf(stderr, BOLDGREEN "\n All tests are passed 🎉\n" RESET); + } + + fprintf(stderr, + CYAN "\ncglm test results:\n" RESET + "------------------\n" + + MAGENTA "%d" RESET " tests are runned, " + GREEN "%d" RESET " %s passed, " + RED "%d" RESET " %s failed\n\n" RESET, + passed + failed, + passed, + passed > 1 ? "are" : "is", + failed, + failed > 1 ? "are" : "is"); + + return failed; +} diff --git a/test/src/test_affine.c b/test/src/test_affine.c index bb1be15..c78b6b2 100644 --- a/test/src/test_affine.c +++ b/test/src/test_affine.c @@ -7,8 +7,7 @@ #include "test_common.h" -void -test_affine(void **state) { +TEST_IMPL(affine) { mat4 t1, t2, t3, t4, t5; /* test translate is postmultiplied */ @@ -18,7 +17,7 @@ test_affine(void **state) { glmc_mat4_mul(t1, t2, t3); /* R * T */ glm_translate(t1, (vec3){34, 57, 36}); - test_assert_mat4_eq(t1, t3); + ASSERT(test_assert_mat4_eq(t1, t3).status == 1) /* test rotate is postmultiplied */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -27,7 +26,7 @@ test_affine(void **state) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glm_rotate(t2, GLM_PI_4f, GLM_YUP); - test_assert_mat4_eq(t2, t3); + ASSERT(test_assert_mat4_eq(t2, t3).status == 1) /* test scale is postmultiplied */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -38,7 +37,7 @@ test_affine(void **state) { glmc_mat4_mul(t3, t4, t5); /* T * R * S */ glm_scale(t3, (vec3){3, 5, 6}); - test_assert_mat4_eq(t3, t5); + ASSERT(test_assert_mat4_eq(t3, t5).status == 1) /* test translate_x */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -46,7 +45,7 @@ test_affine(void **state) { glmc_mat4_mul(t1, t2, t3); /* R * T */ glm_translate_x(t1, 34); - test_assert_mat4_eq(t1, t3); + ASSERT(test_assert_mat4_eq(t1, t3).status == 1) /* test translate_y */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -54,7 +53,7 @@ test_affine(void **state) { glmc_mat4_mul(t1, t2, t3); /* R * T */ glm_translate_y(t1, 57); - test_assert_mat4_eq(t1, t3); + ASSERT(test_assert_mat4_eq(t1, t3).status == 1) /* test translate_z */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -62,7 +61,7 @@ test_affine(void **state) { glmc_mat4_mul(t1, t2, t3); /* R * T */ glm_translate_z(t1, 36); - test_assert_mat4_eq(t1, t3); + ASSERT(test_assert_mat4_eq(t1, t3).status == 1) /* test rotate_x */ glmc_rotate_make(t1, GLM_PI_4f, (vec3){1, 0, 0}); @@ -71,7 +70,7 @@ test_affine(void **state) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glm_rotate_x(t2, GLM_PI_4f, t2); - test_assert_mat4_eq(t2, t3); + ASSERT(test_assert_mat4_eq(t2, t3).status == 1) /* test rotate_y */ glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 1, 0}); @@ -80,7 +79,7 @@ test_affine(void **state) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glm_rotate_y(t2, GLM_PI_4f, t2); - test_assert_mat4_eq(t2, t3); + ASSERT(test_assert_mat4_eq(t2, t3).status == 1) /* test rotate_z */ glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1}); @@ -89,7 +88,7 @@ test_affine(void **state) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glm_rotate_z(t2, GLM_PI_4f, t2); - test_assert_mat4_eq(t2, t3); + ASSERT(test_assert_mat4_eq(t2, t3).status == 1) /* test rotate */ glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1}); @@ -98,7 +97,7 @@ test_affine(void **state) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glmc_rotate(t2, GLM_PI_4f, (vec3){0, 0, 1}); - test_assert_mat4_eq(t3, t2); + ASSERT(test_assert_mat4_eq(t3, t2).status == 1) /* test scale_uni */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -109,5 +108,7 @@ test_affine(void **state) { glmc_mat4_mul(t3, t4, t5); /* T * R * S */ glm_scale_uni(t3, 3); - test_assert_mat4_eq(t3, t5); + ASSERT(test_assert_mat4_eq(t3, t5).status == 1) + + TEST_SUCCESS } diff --git a/test/src/test_bezier.c b/test/src/test_bezier.c index 1c7bb11..460c47a 100644 --- a/test/src/test_bezier.c +++ b/test/src/test_bezier.c @@ -35,8 +35,7 @@ test_hermite_plain(float s, float p0, float t0, float t1, float p1) { + t1 * (sss - ss); } -void -test_bezier(void **state) { +TEST_IMPL(bezier) { float s, p0, p1, c0, c1, smc, Bs, Bs_plain; s = test_rand(); @@ -50,16 +49,18 @@ test_bezier(void **state) { Bs = glm_bezier(s, p0, c0, c1, p1); Bs_plain = test_bezier_plain(s, p0, c0, c1, p1); - assert_true(glm_eq(Bs, Bs_plain)); - test_assert_eqf(smc, Bs_plain); - test_assert_eqf(Bs, smc); + ASSERT(glm_eq(Bs, Bs_plain)); + ASSERT(test_assert_eqf(smc, Bs_plain).status == 1) + ASSERT(test_assert_eqf(Bs, smc).status == 1) /* test cubic hermite */ smc = glm_smc(s, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1}); Bs = glm_hermite(s, p0, c0, c1, p1); Bs_plain = test_hermite_plain(s, p0, c0, c1, p1); - assert_true(glm_eq(Bs, Bs_plain)); - assert_true(glm_eq(smc, Bs_plain)); - assert_true(glm_eq(Bs, smc)); + ASSERT(glm_eq(Bs, Bs_plain)); + ASSERT(glm_eq(smc, Bs_plain)); + ASSERT(glm_eq(Bs, smc)); + + TEST_SUCCESS } diff --git a/test/src/test_cam.c b/test/src/test_cam.c index c1f31e1..889e295 100644 --- a/test/src/test_cam.c +++ b/test/src/test_cam.c @@ -7,25 +7,24 @@ #include "test_common.h" -void -test_camera_lookat(void **state) { - mat4 view1, view2; +TEST_IMPL(camera_lookat) { + mat4 view1, view2; vec3 center, - eye = {0.024f, 14.6f, 67.04f}, - dir = {0.0f, 0.0f, -1.0f}, - up = {0.0f, 1.0f, 0.0f} - ; + eye = {0.024f, 14.6f, 67.04f}, + dir = {0.0f, 0.0f, -1.0f}, + up = {0.0f, 1.0f, 0.0f}; glm_vec3_add(eye, dir, center); glm_lookat(eye, center, up, view1); glm_look(eye, dir, up, view2); - test_assert_mat4_eq(view1, view2); + ASSERT(test_assert_mat4_eq(view1, view2).status == 1) + + TEST_SUCCESS } -void -test_camera_decomp(void **state) { +TEST_IMPL(camera_decomp) { mat4 proj, proj2; vec4 sizes; float aspect, fovy, nearVal, farVal; @@ -36,9 +35,9 @@ test_camera_decomp(void **state) { farVal = 100.0f; glm_perspective(fovy, aspect, nearVal, farVal, proj); - assert_true(fabsf(aspect - glm_persp_aspect(proj)) < FLT_EPSILON); - assert_true(fabsf(fovy - glm_persp_fovy(proj)) < FLT_EPSILON); - assert_true(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON); + ASSERT(fabsf(aspect - glm_persp_aspect(proj)) < FLT_EPSILON) + ASSERT(fabsf(fovy - glm_persp_fovy(proj)) < FLT_EPSILON) + ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < FLT_EPSILON) glm_persp_sizes(proj, fovy, sizes); @@ -50,5 +49,7 @@ test_camera_decomp(void **state) { farVal, proj2); - test_assert_mat4_eq(proj, proj2); + ASSERT(test_assert_mat4_eq(proj, proj2).status == 1) + + TEST_SUCCESS } diff --git a/test/src/test_clamp.c b/test/src/test_clamp.c index 70d684b..30e70f4 100644 --- a/test/src/test_clamp.c +++ b/test/src/test_clamp.c @@ -7,24 +7,25 @@ #include "test_common.h" -void -test_clamp(void **state) { +TEST_IMPL(clamp) { vec3 v3 = {15.07, 0.4, 17.3}; vec4 v4 = {5.07, 2.3, 1.3, 1.4}; - assert_true(glm_clamp(1.6f, 0.0f, 1.0f) == 1.0f); - assert_true(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f); - assert_true(glm_clamp(0.6f, 0.0f, 1.0f) == 0.6f); + ASSERT(glm_clamp(1.6f, 0.0f, 1.0f) == 1.0f) + ASSERT(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f) + ASSERT(glm_clamp(0.6f, 0.0f, 1.0f) == 0.6f) glm_vec3_clamp(v3, 0.0, 1.0); glm_vec4_clamp(v4, 1.5, 3.0); - assert_true(v3[0] == 1.0f); - assert_true(v3[1] == 0.4f); - assert_true(v3[2] == 1.0f); + ASSERT(v3[0] == 1.0f) + ASSERT(v3[1] == 0.4f) + ASSERT(v3[2] == 1.0f) - assert_true(v4[0] == 3.0f); - assert_true(v4[1] == 2.3f); - assert_true(v4[2] == 1.5f); - assert_true(v4[3] == 1.5f); + ASSERT(v4[0] == 3.0f) + ASSERT(v4[1] == 2.3f) + ASSERT(v4[2] == 1.5f) + ASSERT(v4[3] == 1.5f) + + TEST_SUCCESS } diff --git a/test/src/test_common.c b/test/src/test_common.c index d734e72..4e966b5 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -4,11 +4,7 @@ */ #include "test_common.h" -#include -#include - -#define m 4 -#define n 4 +#include void test_rand_mat4(mat4 dest) { @@ -86,85 +82,105 @@ test_rand_quat(versor q) { glm_quat_normalize(q); } -void +test_status_t test_assert_mat4_eq(mat4 m1, mat4 m2) { int i, j, k; - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) { - for (k = 0; k < m; k++) - assert_true(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009) } } + + TEST_SUCCESS } -void +test_status_t test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) { int i, j, k; - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) { - for (k = 0; k < m; k++) - assert_true(fabsf(m1[i][j] - m2[i][j]) <= eps); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps); } } + + TEST_SUCCESS } -void +test_status_t test_assert_mat3_eq(mat3 m1, mat3 m2) { int i, j, k; for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { for (k = 0; k < 3; k++) - assert_true(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009); + ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009); } } + + TEST_SUCCESS } -void +test_status_t test_assert_eqf(float a, float b) { - assert_true(fabsf(a - b) <= 0.000009); /* rounding errors */ + ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */ + + TEST_SUCCESS } -void +test_status_t test_assert_vec3_eq(vec3 v1, vec3 v2) { - assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ - assert_true(fabsf(v1[1] - v2[1]) <= 0.000009); - assert_true(fabsf(v1[2] - v2[2]) <= 0.000009); + ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ + ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009); + ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009); + + TEST_SUCCESS } -void +test_status_t test_assert_vec3s_eq(vec3s v1, vec3s v2) { test_assert_vec3_eq(v1.raw, v2.raw); + + TEST_SUCCESS } -void +test_status_t test_assert_vec4_eq(vec4 v1, vec4 v2) { - assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ - assert_true(fabsf(v1[1] - v2[1]) <= 0.000009); - assert_true(fabsf(v1[2] - v2[2]) <= 0.000009); - assert_true(fabsf(v1[3] - v2[3]) <= 0.000009); + ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ + ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009); + ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009); + ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009); + + TEST_SUCCESS } -void +test_status_t test_assert_vec4s_eq(vec4s v1, vec4s v2) { test_assert_vec4_eq(v1.raw, v2.raw); + + TEST_SUCCESS } -void +test_status_t test_assert_quat_eq_abs(versor v1, versor v2) { - assert_true(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */ - assert_true(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009); - assert_true(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009); - assert_true(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009); + ASSERT(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */ + ASSERT(fabsf(fabsf(v1[1]) - fabsf(v2[1])) <= 0.0009); + ASSERT(fabsf(fabsf(v1[2]) - fabsf(v2[2])) <= 0.0009); + ASSERT(fabsf(fabsf(v1[3]) - fabsf(v2[3])) <= 0.0009); + + TEST_SUCCESS } -void +test_status_t test_assert_quat_eq(versor v1, versor v2) { - assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ - assert_true(fabsf(v1[1] - v2[1]) <= 0.000009); - assert_true(fabsf(v1[2] - v2[2]) <= 0.000009); - assert_true(fabsf(v1[3] - v2[3]) <= 0.000009); + ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */ + ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009); + ASSERT(fabsf(v1[2] - v2[2]) <= 0.000009); + ASSERT(fabsf(v1[3] - v2[3]) <= 0.000009); + + TEST_SUCCESS } diff --git a/test/src/test_common.h b/test/src/test_common.h index 690d249..73d9502 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -8,20 +8,7 @@ #ifndef test_common_h #define test_common_h -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include +#include "../include/common.h" void test_rand_mat4(mat4 dest); @@ -29,34 +16,34 @@ test_rand_mat4(mat4 dest); void test_rand_mat3(mat3 dest); -void +test_status_t test_assert_eqf(float a, float b); -void +test_status_t test_assert_mat4_eq(mat4 m1, mat4 m2); -void +test_status_t test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps); -void +test_status_t test_assert_mat3_eq(mat3 m1, mat3 m2); -void +test_status_t test_assert_vec3_eq(vec3 v1, vec3 v2); -void +test_status_t test_assert_vec3s_eq(vec3s v1, vec3s v2); -void +test_status_t test_assert_vec4_eq(vec4 v1, vec4 v2); -void +test_status_t test_assert_vec4s_eq(vec4s v1, vec4s v2); -void +test_status_t test_assert_quat_eq(versor v1, versor v2); -void +test_status_t test_assert_quat_eq_abs(versor v1, versor v2); void diff --git a/test/src/test_euler.c b/test/src/test_euler.c index b71c4cb..74618b3 100644 --- a/test/src/test_euler.c +++ b/test/src/test_euler.c @@ -7,10 +7,9 @@ #include "test_common.h" -void -test_euler(void **state) { - mat4 rot1, rot2; - vec3 inAngles, outAngles; +TEST_IMPL(euler) { + mat4 rot1, rot2; + vec3 inAngles, outAngles; inAngles[0] = glm_rad(-45.0f); /* X angle */ inAngles[1] = glm_rad(88.0f); /* Y angle */ @@ -22,11 +21,11 @@ test_euler(void **state) { glmc_euler_angles(rot1, outAngles); /* angles must be equal in that range */ - test_assert_vec3_eq(inAngles, outAngles); + ASSERT(test_assert_vec3_eq(inAngles, outAngles).status == 1) /* matrices must be equal */ glmc_euler_xyz(outAngles, rot2); - test_assert_mat4_eq(rot1, rot2); + ASSERT(test_assert_mat4_eq(rot1, rot2).status == 1) /* change range */ inAngles[0] = glm_rad(-145.0f); /* X angle */ @@ -40,5 +39,7 @@ test_euler(void **state) { /* matrices must be equal */ glmc_euler_xyz(outAngles, rot2); - test_assert_mat4_eq(rot1, rot2); + ASSERT(test_assert_mat4_eq(rot1, rot2).status == 1) + + TEST_SUCCESS } diff --git a/test/src/test_main.c b/test/src/test_main.c deleted file mode 100644 index 8ce1673..0000000 --- a/test/src/test_main.c +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * MIT License (MIT), http://opensource.org/licenses/MIT - */ - -#include "test_common.h" -#include "test_tests.h" - -int -main(int argc, const char * argv[]) { - const struct CMUnitTest tests[] = { - /* mat4 */ - cmocka_unit_test(test_mat4), - - /* mat3 */ - cmocka_unit_test(test_mat3), - - /* camera */ - cmocka_unit_test(test_camera_lookat), - cmocka_unit_test(test_camera_decomp), - - /* project */ - cmocka_unit_test(test_project), - - /* vector */ - cmocka_unit_test(test_clamp), - - /* euler */ - cmocka_unit_test(test_euler), - - /* quaternion */ - cmocka_unit_test(test_quat), - - /* vec4 */ - cmocka_unit_test(test_vec4), - - /* vec3 */ - cmocka_unit_test(test_vec3), - - /* affine */ - cmocka_unit_test(test_affine), - - /* bezier */ - cmocka_unit_test(test_bezier) - }; - - return cmocka_run_group_tests(tests, NULL, NULL); -} diff --git a/test/src/test_mat3.c b/test/src/test_mat3.c index e0de7c6..6f43dd4 100644 --- a/test/src/test_mat3.c +++ b/test/src/test_mat3.c @@ -10,25 +10,33 @@ #define m 3 #define n 3 -void -test_mat3(void **state) { - mat3 m1 = GLM_MAT3_IDENTITY_INIT; - mat3 m2 = GLM_MAT3_IDENTITY_INIT; - mat3 m3; - mat3 m4 = GLM_MAT3_ZERO_INIT; - mat3 m5; - int i, j, k; - +TEST_IMPL(mat3_identity) { + mat3 m1 = GLM_MAT3_IDENTITY_INIT; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + mat3 m3; + int i, j; + /* test identity matrix multiplication */ glmc_mat3_mul(m1, m2, m3); for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { - if (i == j) - assert_true(glm_eq(m3[i][j], 1.0f)); - else - assert_true(glm_eq(m3[i][j], 0.0f)); + if (i == j) { + ASSERT(glm_eq(m3[i][j], 1.0f)) + } else { + ASSERT(glm_eq(m3[i][j], 0.0f)) + } } } + + TEST_SUCCESS +} + +TEST_IMPL(mat3_mul) { + mat3 m1 = GLM_MAT3_IDENTITY_INIT; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + mat3 m3; + mat3 m4 = GLM_MAT3_ZERO_INIT; + int i, j, k; /* test random matrices */ /* random matrices */ @@ -43,16 +51,27 @@ test_mat3(void **state) { m4[i][j] += m1[k][j] * m2[i][k]; } } + + ASSERT(test_assert_mat3_eq(m3, m4).status == 1) + + TEST_SUCCESS +} - test_assert_mat3_eq(m3, m4); - +TEST_IMPL(mat3_inv) { + mat3 m1 = GLM_MAT3_IDENTITY_INIT; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + mat3 m3; + int i; + for (i = 0; i < 100000; i++) { - test_rand_mat3(m3); - test_rand_mat3(m4); + test_rand_mat3(m1); + test_rand_mat3(m2); /* test inverse precise */ - glmc_mat3_inv(m3, m4); - glmc_mat3_inv(m4, m5); - test_assert_mat3_eq(m3, m5); + glmc_mat3_inv(m1, m2); + glmc_mat3_inv(m2, m3); + ASSERT(test_assert_mat3_eq(m1, m3).status == 1) } + + TEST_SUCCESS } diff --git a/test/src/test_mat4.c b/test/src/test_mat4.c index f369829..49ae8ca 100644 --- a/test/src/test_mat4.c +++ b/test/src/test_mat4.c @@ -10,45 +10,63 @@ #define m 4 #define n 4 -void -test_mat4(void **state) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; - mat4 m2 = GLM_MAT4_IDENTITY_INIT; - mat4 m3; - mat4 m4 = GLM_MAT4_ZERO_INIT; - mat4 m5; - int i, j, k; - +TEST_IMPL(mat4_identity) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + int i, j; + /* test identity matrix multiplication */ glm_mat4_mul(m1, m2, m3); for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { - if (i == j) - assert_true(glm_eq(m3[i][j], 1.0f)); - else - assert_true(glm_eq(m3[i][j], 0.0f)); + if (i == j) { + ASSERT(glm_eq(m3[i][j], 1.0f)) + } else { + ASSERT(glm_eq(m3[i][j], 0.0f)) + } } } + + TEST_SUCCESS +} +TEST_IMPL(mat4_mul) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + mat4 m4 = GLM_MAT4_ZERO_INIT; + int i, j, k; + /* test random matrices */ /* random matrices */ test_rand_mat4(m1); test_rand_mat4(m2); - + glm_mat4_mul(m1, m2, m3); for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { for (k = 0; k < m; k++) - /* column-major */ + /* column-major */ m4[i][j] += m1[k][j] * m2[i][k]; } } - - test_assert_mat4_eq(m3, m4); - + + ASSERT(test_assert_mat4_eq(m3, m4).status == TEST_OK) + /* test pre compiled */ glmc_mat4_mul(m1, m2, m3); - test_assert_mat4_eq(m3, m4); + ASSERT(test_assert_mat4_eq(m3, m4).status == TEST_OK) + + TEST_SUCCESS +} + +TEST_IMPL(mat4_all) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + mat4 m4 = GLM_MAT4_ZERO_INIT; + mat4 m5; + int i; for (i = 0; i < 100000; i++) { test_rand_mat4(m3); @@ -57,14 +75,14 @@ test_mat4(void **state) { /* test inverse precise */ glm_mat4_inv_precise(m3, m4); glm_mat4_inv_precise(m4, m5); - test_assert_mat4_eq(m3, m5); + ASSERT(test_assert_mat4_eq(m3, m5).status == TEST_OK) test_rand_mat4(m3); test_rand_mat4(m4); glmc_mat4_inv_precise(m3, m4); glmc_mat4_inv_precise(m4, m5); - test_assert_mat4_eq(m3, m5); + ASSERT(test_assert_mat4_eq(m3, m5).status == TEST_OK) /* test inverse rcp */ test_rand_mat4(m3); @@ -72,23 +90,21 @@ test_mat4(void **state) { glm_mat4_inv_fast(m3, m4); glm_mat4_inv_fast(m4, m5); - test_assert_mat4_eq2(m3, m5, 0.0009f); + ASSERT(test_assert_mat4_eq2(m3, m5, 0.0009f).status == TEST_OK) test_rand_mat4(m3); test_rand_mat4(m4); glmc_mat4_inv(m3, m4); glmc_mat4_inv(m4, m5); - test_assert_mat4_eq2(m3, m5, 0.0009f); + ASSERT(test_assert_mat4_eq2(m3, m5, 0.0009f).status == TEST_OK) } - /* print */ - glm_mat4_print(m3, stderr); - glm_mat4_print(m4, stderr); - /* test determinant */ - assert_int_equal(glm_mat4_det(m1), glmc_mat4_det(m1)); + ASSERT(glm_mat4_det(m1) == glmc_mat4_det(m1)) #if defined( __SSE2__ ) - assert_int_equal(glmc_mat4_det(m1), glm_mat4_det_sse2(m1)); + ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1)) #endif + + TEST_SUCCESS } diff --git a/test/src/test_project.c b/test/src/test_project.c index 4cdac9e..d590423 100644 --- a/test/src/test_project.c +++ b/test/src/test_project.c @@ -7,8 +7,7 @@ #include "test_common.h" -void -test_project(void **state) { +TEST_IMPL(project) { mat4 model, view, proj, mvp; vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f}; vec3 pos = {13.0f, 45.0f, 0.74f}; @@ -25,7 +24,9 @@ test_project(void **state) { /* unprojected of projected vector must be same as original one */ /* we used 0.01 because of projection floating point errors */ - assert_true(fabsf(pos[0] - unprojected[0]) < 0.01); - assert_true(fabsf(pos[1] - unprojected[1]) < 0.01); - assert_true(fabsf(pos[2] - unprojected[2]) < 0.01); + ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01); + ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01); + ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01); + + TEST_SUCCESS } diff --git a/test/src/test_quat.c b/test/src/test_quat.c index d0cc27c..97ddd49 100644 --- a/test/src/test_quat.c +++ b/test/src/test_quat.c @@ -16,8 +16,7 @@ test_quat_mul_raw(versor p, versor q, versor dest) { dest[3] = p[3] * q[3] - p[0] * q[0] - p[1] * q[1] - p[2] * q[2]; } -void -test_quat(void **state) { +TEST_IMPL(quat) { mat4 inRot, outRot, view1, view2, rot1, rot2; versor inQuat, outQuat, q3, q4, q5; vec3 eye, axis, imag, v1, v2; @@ -25,9 +24,10 @@ test_quat(void **state) { /* 0. test identiy quat */ glm_quat_identity(q4); - assert_true(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f))); + ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f))) + glm_quat_mat4(q4, rot1); - test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009); + ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1) /* 1. test quat to mat and mat to quat */ for (i = 0; i < 1000; i++) { @@ -38,16 +38,17 @@ test_quat(void **state) { glmc_quat_mat4(outQuat, outRot); /* 2. test first quat and generated one equality */ - test_assert_quat_eq_abs(inQuat, outQuat); + ASSERT(test_assert_quat_eq_abs(inQuat, outQuat).status == 1); /* 3. test first rot and second rotation */ - test_assert_mat4_eq2(inRot, outRot, 0.000009); /* almost equal */ + /* almost equal */ + ASSERT(test_assert_mat4_eq2(inRot, outRot, 0.000009).status == 1); /* 4. test SSE mul and raw mul */ #if defined( __SSE__ ) || defined( __SSE2__ ) test_quat_mul_raw(inQuat, outQuat, q3); glm_quat_mul_sse2(inQuat, outQuat, q4); - test_assert_quat_eq(q3, q4); + ASSERT(test_assert_quat_eq(q3, q4).status == 1); #endif } @@ -61,7 +62,7 @@ test_quat(void **state) { /* create view matrix with quaternion */ glm_quat_look(eye, q3, view2); - test_assert_mat4_eq2(view1, view2, 0.000009); + ASSERT(test_assert_mat4_eq2(view1, view2, 0.000009).status == 1); /* 6. test quaternion rotation matrix result */ test_rand_quat(q3); @@ -71,7 +72,7 @@ test_quat(void **state) { glm_quat_axis(q3, axis); glm_rotate_make(rot2, glm_quat_angle(q3), axis); - test_assert_mat4_eq2(rot1, rot2, 0.000009); + ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1); /* 7. test quaternion multiplication (hamilton product), final rotation = first rotation + second = quat1 * quat2 @@ -91,7 +92,7 @@ test_quat(void **state) { glm_quat_mat4(q5, rot2); /* result must be same (almost) */ - test_assert_mat4_eq2(rot1, rot2, 0.000009); + ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) /* 8. test quaternion for look rotation */ @@ -101,26 +102,26 @@ test_quat(void **state) { /* result must be identity */ glm_quat_identity(q4); - test_assert_quat_eq(q3, q4); + ASSERT(test_assert_quat_eq(q3, q4).status == 1) /* look at from 0, 0, 1 to zero, direction = 0, 0, -1 */ glm_quat_forp(GLM_ZUP, GLM_VEC3_ZERO, (vec3){0, 0, -1}, GLM_YUP, q3); /* result must be identity */ glm_quat_identity(q4); - test_assert_quat_eq(q3, q4); + ASSERT(test_assert_quat_eq(q3, q4).status == 1) /* 8.2 perpendicular */ glm_quat_for(GLM_XUP, (vec3){0, 0, -1}, GLM_YUP, q3); /* result must be -90 */ glm_quatv(q4, glm_rad(-90.0f), GLM_YUP); - test_assert_quat_eq(q3, q4); + ASSERT(test_assert_quat_eq(q3, q4).status == 1) /* 9. test imag, real */ /* 9.1 real */ - assert_true(glm_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f))); + ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f))) /* 9.1 imag */ glm_quat_imag(q4, imag); @@ -130,7 +131,7 @@ test_quat(void **state) { axis[1] = sinf(glm_rad(-90.0f) * 0.5f) * 1.0f; axis[2] = 0.0f; - assert_true(glm_vec3_eqv_eps(imag, axis)); + ASSERT(glm_vec3_eqv_eps(imag, axis)); /* 9.2 axis */ glm_quat_axis(q4, axis); @@ -138,7 +139,7 @@ test_quat(void **state) { imag[1] = -1.0f; imag[2] = 0.0f; - test_assert_vec3_eq(imag, axis); + ASSERT(test_assert_vec3_eq(imag, axis).status == 1); /* 10. test rotate vector using quat */ /* (0,0,-1) around (1,0,0) must give (0,1,0) */ @@ -152,11 +153,11 @@ test_quat(void **state) { glm_quat_rotatev(q3, v2, v2); /* result must be : (0,1,0) */ - assert_true(fabsf(v1[0]) <= 0.00009f - && fabsf(v1[1] - 1.0f) <= 0.00009f - && fabsf(v1[2]) <= 0.00009f); + ASSERT(fabsf(v1[0]) <= 0.00009f + && fabsf(v1[1] - 1.0f) <= 0.00009f + && fabsf(v1[2]) <= 0.00009f) - test_assert_vec3_eq(v1, v2); + ASSERT(test_assert_vec3_eq(v1, v2).status == 1) /* 11. test rotate transform */ glm_translate_make(rot1, (vec3){-10.0, 45.0f, 8.0f}); @@ -167,7 +168,7 @@ test_quat(void **state) { glm_quat_rotate(rot2, q3, rot2); /* result must be same (almost) */ - test_assert_mat4_eq2(rot1, rot2, 0.000009); + ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP); glm_translate(rot1, (vec3){-10.0, 45.0f, 8.0f}); @@ -178,7 +179,7 @@ test_quat(void **state) { glm_translate(rot2, (vec3){-10.0, 45.0f, 8.0f}); /* result must be same (almost) */ - test_assert_mat4_eq2(rot1, rot2, 0.000009); + ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) /* reverse */ glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP); @@ -186,7 +187,7 @@ test_quat(void **state) { glm_quat_rotate(rot1, q3, rot1); /* result must be identity */ - test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009); + ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1) test_rand_quat(q3); @@ -195,7 +196,9 @@ test_quat(void **state) { glm_quat_mul(q3, q4, q5); glm_quat_identity(q3); - test_assert_quat_eq(q3, q5); + ASSERT(test_assert_quat_eq(q3, q5).status == 1) /* TODO: add tests for slerp, lerp */ + + TEST_SUCCESS } diff --git a/test/src/test_tests.h b/test/src/test_tests.h deleted file mode 100644 index 618cc9f..0000000 --- a/test/src/test_tests.h +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * MIT License (MIT), http://opensource.org/licenses/MIT - */ - -#ifndef test_tests_h -#define test_tests_h - -/* mat4 */ -void test_mat4(void **state); - -/* mat3 */ -void test_mat3(void **state); - -/* camera */ -void -test_camera_lookat(void **state); - -void -test_camera_decomp(void **state); - -void -test_project(void **state); - -void -test_clamp(void **state); - -void -test_euler(void **state); - -void -test_quat(void **state); - -void -test_vec4(void **state); - -void -test_vec3(void **state); - -void -test_affine(void **state); - -void -test_bezier(void **state); - -#endif /* test_tests_h */ diff --git a/test/src/test_vec3.c b/test/src/test_vec3.c index 19af4aa..c529cc2 100644 --- a/test/src/test_vec3.c +++ b/test/src/test_vec3.c @@ -7,65 +7,64 @@ #include "test_common.h" -void -test_vec3(void **state) { - mat3 rot1m3; - mat4 rot1; - vec3 v, v1, v2; +TEST_IMPL(vec3) { + mat3 rot1m3; + mat4 rot1; + vec3 v, v1, v2; vec3s vs1, vs2, vs3, vs4; /* test zero */ glm_vec3_zero(v); - test_assert_vec3_eq(GLM_VEC3_ZERO, v); + ASSERT(test_assert_vec3_eq(GLM_VEC3_ZERO, v).status == 1) /* test one */ glm_vec3_one(v); - test_assert_vec3_eq(GLM_VEC3_ONE, v); + ASSERT(test_assert_vec3_eq(GLM_VEC3_ONE, v).status == 1) /* adds, subs, div, divs, mul */ glm_vec3_add(v, GLM_VEC3_ONE, v); - assert_true(glmc_vec3_eq_eps(v, 2)); + ASSERT(glmc_vec3_eq_eps(v, 2)) glm_vec3_adds(v, 10, v); - assert_true(glmc_vec3_eq_eps(v, 12)); + ASSERT(glmc_vec3_eq_eps(v, 12)) glm_vec3_sub(v, GLM_VEC3_ONE, v); - assert_true(glmc_vec3_eq_eps(v, 11)); + ASSERT(glmc_vec3_eq_eps(v, 11)) glm_vec3_subs(v, 1, v); - assert_true(glmc_vec3_eq_eps(v, 10)); + ASSERT(glmc_vec3_eq_eps(v, 10)) glm_vec3_broadcast(2, v1); glm_vec3_div(v, v1, v); - assert_true(glmc_vec3_eq_eps(v, 5)); + ASSERT(glmc_vec3_eq_eps(v, 5)) glm_vec3_divs(v, 0.5, v); - assert_true(glmc_vec3_eq_eps(v, 10)); + ASSERT(glmc_vec3_eq_eps(v, 10)) glm_vec3_mul(v, v1, v); - assert_true(glmc_vec3_eq_eps(v, 20)); + ASSERT(glmc_vec3_eq_eps(v, 20)) glm_vec3_scale(v, 0.5, v); - assert_true(glmc_vec3_eq_eps(v, 10)); + ASSERT(glmc_vec3_eq_eps(v, 10)) glm_vec3_normalize_to(v, v1); - glm_vec3_scale(v1, 0.8, v1); - glm_vec3_scale_as(v, 0.8, v); - test_assert_vec3_eq(v1, v); + glm_vec3_scale(v1, 0.8f, v1); + glm_vec3_scale_as(v, 0.8f, v); + ASSERT(test_assert_vec3_eq(v1, v).status == 1) /* addadd, subadd, muladd */ glm_vec3_one(v); glm_vec3_addadd(GLM_VEC3_ONE, GLM_VEC3_ONE, v); - assert_true(glmc_vec3_eq_eps(v, 3)); + ASSERT(glmc_vec3_eq_eps(v, 3)) glm_vec3_subadd(GLM_VEC3_ONE, GLM_VEC3_ZERO, v); - assert_true(glmc_vec3_eq_eps(v, 4)); + ASSERT(glmc_vec3_eq_eps(v, 4)) glm_vec3_broadcast(2, v1); glm_vec3_broadcast(3, v2); glm_vec3_muladd(v1, v2, v); - assert_true(glmc_vec3_eq_eps(v, 10)); + ASSERT(glmc_vec3_eq_eps(v, 10)) /* rotate */ glm_vec3_copy(GLM_YUP, v); @@ -74,8 +73,8 @@ test_vec3(void **state) { glm_mat4_pick3(rot1, rot1m3); glm_vec3_rotate_m3(rot1m3, v, v2); - test_assert_vec3_eq(v1, v2); - test_assert_vec3_eq(v1, GLM_ZUP); + ASSERT(test_assert_vec3_eq(v1, v2).status == 1) + ASSERT(test_assert_vec3_eq(v1, GLM_ZUP).status == 1) /* structs */ vs1 = test_rand_vec3s(); @@ -83,7 +82,7 @@ test_vec3(void **state) { vs3 = glms_vec3_add(vs1, vs2); vs4 = glms_vec3_maxv(vs1, vs3); - test_assert_vec3s_eq(vs3, vs4); + ASSERT(test_assert_vec3s_eq(vs3, vs4).status == 1) /* swizzle */ @@ -92,22 +91,24 @@ test_vec3(void **state) { v1[1] = 2; v1[2] = 3; glm_vec3_swizzle(v1, GLM_ZYX, v1); - test_assert_vec3_eq(v1, (vec3){3, 2, 1}); + ASSERT(test_assert_vec3_eq(v1, (vec3){3, 2, 1}).status == 1) glm_vec3_swizzle(v1, GLM_XXX, v1); - test_assert_vec3_eq(v1, (vec3){3, 3, 3}); + ASSERT(test_assert_vec3_eq(v1, (vec3){3, 3, 3}).status == 1) v1[0] = 1; v1[1] = 2; v1[2] = 3; glm_vec3_swizzle(v1, GLM_YYY, v1); - test_assert_vec3_eq(v1, (vec3){2, 2, 2}); + ASSERT(test_assert_vec3_eq(v1, (vec3){2, 2, 2}).status == 1) v1[0] = 1; v1[1] = 2; v1[2] = 3; glm_vec3_swizzle(v1, GLM_ZZZ, v1); - test_assert_vec3_eq(v1, (vec3){3, 3, 3}); + ASSERT(test_assert_vec3_eq(v1, (vec3){3, 3, 3}).status == 1) + + TEST_SUCCESS } diff --git a/test/src/test_vec4.c b/test/src/test_vec4.c index 2e9d12e..df59274 100644 --- a/test/src/test_vec4.c +++ b/test/src/test_vec4.c @@ -62,8 +62,7 @@ test_vec4_clamp(vec4 v, float minVal, float maxVal) { v[3] = glm_clamp(v[3], minVal, maxVal); } -void -test_vec4(void **state) { +TEST_IMPL(vec4) { vec4 v, v1, v2, v3, v4; vec4s vs1, vs2, vs3, vs4; int i; @@ -75,7 +74,7 @@ test_vec4(void **state) { d1 = glm_vec4_dot(v, v); d2 = test_vec4_dot(v, v); - assert_true(fabsf(d1 - d2) <= 0.000009); + ASSERT(fabsf(d1 - d2) <= 0.000009) /* 2. test SIMD normalize */ test_vec4_normalize_to(v, v1); @@ -98,62 +97,65 @@ test_vec4(void **state) { test_rand_vec4(v1); test_rand_vec4(v2); d1 = glm_vec4_distance(v1, v2); - d2 = sqrtf(powf(v1[0]-v2[0], 2.0f) + pow(v1[1]-v2[1], 2.0f) + pow(v1[2]-v2[2], 2.0f) + pow(v1[3]-v2[3], 2.0f)); - assert_true(fabsf(d1 - d2) <= 0.000009); + d2 = sqrtf(powf(v1[0] - v2[0], 2.0f) + + pow(v1[1] - v2[1], 2.0f) + + pow(v1[2] - v2[2], 2.0f) + + pow(v1[3] - v2[3], 2.0f)); + ASSERT(fabsf(d1 - d2) <= 0.000009) } /* test zero */ glm_vec4_zero(v); - test_assert_vec4_eq(GLM_VEC4_ZERO, v); + ASSERT(test_assert_vec4_eq(GLM_VEC4_ZERO, v).status == 1) /* test one */ glm_vec4_one(v); - test_assert_vec4_eq(GLM_VEC4_ONE, v); + ASSERT(test_assert_vec4_eq(GLM_VEC4_ONE, v).status == 1) /* adds, subs, div, divs, mul */ glm_vec4_add(v, GLM_VEC4_ONE, v); - assert_true(glmc_vec4_eq_eps(v, 2)); + ASSERT(glmc_vec4_eq_eps(v, 2)) glm_vec4_adds(v, 10, v); - assert_true(glmc_vec4_eq_eps(v, 12)); + ASSERT(glmc_vec4_eq_eps(v, 12)) glm_vec4_sub(v, GLM_VEC4_ONE, v); - assert_true(glmc_vec4_eq_eps(v, 11)); + ASSERT(glmc_vec4_eq_eps(v, 11)) glm_vec4_subs(v, 1, v); - assert_true(glmc_vec4_eq_eps(v, 10)); + ASSERT(glmc_vec4_eq_eps(v, 10)) glm_vec4_broadcast(2, v1); glm_vec4_div(v, v1, v); - assert_true(glmc_vec4_eq_eps(v, 5)); + ASSERT(glmc_vec4_eq_eps(v, 5)) glm_vec4_divs(v, 0.5, v); - assert_true(glmc_vec4_eq_eps(v, 10)); + ASSERT(glmc_vec4_eq_eps(v, 10)) glm_vec4_mul(v, v1, v); - assert_true(glmc_vec4_eq_eps(v, 20)); + ASSERT(glmc_vec4_eq_eps(v, 20)) glm_vec4_scale(v, 0.5, v); - assert_true(glmc_vec4_eq_eps(v, 10)); + ASSERT(glmc_vec4_eq_eps(v, 10)) glm_vec4_normalize_to(v, v1); glm_vec4_scale(v1, 0.8, v1); glm_vec4_scale_as(v, 0.8, v); - test_assert_vec4_eq(v1, v); + ASSERT(test_assert_vec4_eq(v1, v).status == 1) /* addadd, subadd, muladd */ glm_vec4_one(v); glm_vec4_addadd(GLM_VEC4_ONE, GLM_VEC4_ONE, v); - assert_true(glmc_vec4_eq_eps(v, 3)); + ASSERT(glmc_vec4_eq_eps(v, 3)) glm_vec4_subadd(GLM_VEC4_ONE, GLM_VEC4_ZERO, v); - assert_true(glmc_vec4_eq_eps(v, 4)); + ASSERT(glmc_vec4_eq_eps(v, 4)) glm_vec4_broadcast(2, v1); glm_vec4_broadcast(3, v2); glm_vec4_muladd(v1, v2, v); - assert_true(glmc_vec4_eq_eps(v, 10)); + ASSERT(glmc_vec4_eq_eps(v, 10)) /* min, max */ test_rand_vec4(v1); @@ -161,27 +163,21 @@ test_vec4(void **state) { glm_vec4_maxv(v1, v2, v3); test_vec4_maxv(v1, v2, v4); - test_assert_vec4_eq(v3, v4); + ASSERT(test_assert_vec4_eq(v3, v4).status == 1) glm_vec4_minv(v1, v2, v3); test_vec4_minv(v1, v2, v4); - test_assert_vec4_eq(v3, v4); - - glm_vec4_print(v3, stderr); - glm_vec4_print(v4, stderr); + ASSERT(test_assert_vec4_eq(v3, v4).status == 1) /* clamp */ glm_vec4_clamp(v3, 0.1, 0.8); test_vec4_clamp(v4, 0.1, 0.8); - test_assert_vec4_eq(v3, v4); + ASSERT(test_assert_vec4_eq(v3, v4).status == 1) - glm_vec4_print(v3, stderr); - glm_vec4_print(v4, stderr); - - assert_true(v3[0] >= 0.0999 && v3[0] <= 0.80001); /* rounding erros */ - assert_true(v3[1] >= 0.0999 && v3[1] <= 0.80001); - assert_true(v3[2] >= 0.0999 && v3[2] <= 0.80001); - assert_true(v3[3] >= 0.0999 && v3[3] <= 0.80001); + ASSERT(v3[0] >= 0.0999 && v3[0] <= 0.80001) /* rounding erros */ + ASSERT(v3[1] >= 0.0999 && v3[1] <= 0.80001) + ASSERT(v3[2] >= 0.0999 && v3[2] <= 0.80001) + ASSERT(v3[3] >= 0.0999 && v3[3] <= 0.80001) /* swizzle */ @@ -192,10 +188,10 @@ test_vec4(void **state) { v1[3] = 4; glm_vec4_swizzle(v1, GLM_WZYX, v1); - test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1}); + ASSERT(test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1}).status == 1) glm_vec4_swizzle(v1, GLM_XXXX, v1); - test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}); + ASSERT(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}).status == 1) v1[0] = 1; v1[1] = 2; @@ -203,7 +199,7 @@ test_vec4(void **state) { v1[3] = 4; glm_vec4_swizzle(v1, GLM_YYYY, v1); - test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2}); + ASSERT(test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2}).status == 1) v1[0] = 1; v1[1] = 2; @@ -211,7 +207,7 @@ test_vec4(void **state) { v1[3] = 4; glm_vec4_swizzle(v1, GLM_ZZZZ, v1); - test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3}); + ASSERT(test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3}).status == 1) v1[0] = 1; v1[1] = 2; @@ -219,7 +215,7 @@ test_vec4(void **state) { v1[3] = 4; glm_vec4_swizzle(v1, GLM_WWWW, v1); - test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}); + ASSERT(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}).status == 1) /* structs */ vs1 = test_rand_vec4s(); @@ -227,5 +223,7 @@ test_vec4(void **state) { vs3 = glms_vec4_add(vs1, vs2); vs4 = glms_vec4_maxv(vs1, vs3); - test_assert_vec4s_eq(vs3, vs4); + ASSERT(test_assert_vec4s_eq(vs3, vs4).status == 1) + + TEST_SUCCESS } diff --git a/test/tests.h b/test/tests.h new file mode 100644 index 0000000..88562f3 --- /dev/null +++ b/test/tests.h @@ -0,0 +1,97 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#ifndef tests_h +#define tests_h + +#include "include/common.h" + +/* + * To register a test: + * 1. use TEST_DECLARE() to forward declare test + * 2. use TEST_ENTRY() to add test to list + */ + +/* mat4 */ +TEST_DECLARE(mat4_identity) +TEST_DECLARE(mat4_mul) +TEST_DECLARE(mat4_all) + +TEST_DECLARE(affine) + +/* mat3 */ +TEST_DECLARE(mat3_identity) +TEST_DECLARE(mat3_mul) +TEST_DECLARE(mat3_inv) + +/* camera */ +TEST_DECLARE(camera_lookat) +TEST_DECLARE(camera_decomp) + +/* project */ +TEST_DECLARE(project) + +/* utils */ +TEST_DECLARE(clamp) + +/* euler */ +TEST_DECLARE(euler) + +/* quat */ +TEST_DECLARE(quat) + +/* bezier */ +TEST_DECLARE(bezier) + +/* vec3 */ +TEST_DECLARE(vec3) + +/* vec4 */ +TEST_DECLARE(vec4) + +/*****************************************************************************/ + +TEST_LIST { + /* mat4 */ + TEST_ENTRY(mat4_identity) + TEST_ENTRY(mat4_mul) + TEST_ENTRY(mat4_all) + + TEST_ENTRY(affine) + + /* mat3 */ + TEST_ENTRY(mat3_identity) + TEST_ENTRY(mat3_mul) + TEST_ENTRY(mat3_inv) + + /* camera */ + TEST_ENTRY(camera_lookat) + TEST_ENTRY(camera_decomp) + + /* project */ + TEST_ENTRY(project) + + /* utils */ + TEST_ENTRY(clamp) + + /* euler */ + TEST_ENTRY(euler) + + /* quat */ + TEST_ENTRY(quat) + + /* bezier */ + TEST_ENTRY(bezier) + + /* vec3 */ + TEST_ENTRY(vec3) + + /* vec4 */ + TEST_ENTRY(vec4) +}; + +#endif /* tests_h */ From 092da3e189080d56aa7fce905e06fbbb535226ce Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 12 Sep 2019 07:01:09 +0300 Subject: [PATCH 002/103] Update README.md --- README.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/README.md b/README.md index 65049dd..bfc2e0d 100644 --- a/README.md +++ b/README.md @@ -134,14 +134,10 @@ glm_inv_tr(modelMat); ### Unix (Autotools) ```bash -$ sh ./build-deps.sh # run only once (dependencies) [Optional]. -$ # You can pass this step if you don't want to run `make check` for tests. -$ # cglm uses cmocka for tests and it may reqiure cmake for building it -$ $ sh autogen.sh $ ./configure $ make -$ make check # [Optional] (if you run `sh ./build-deps.sh`) +$ make check # [Optional] $ [sudo] make install ``` From 981fd5ee440ae012d336590a84a42b909872745a Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 12 Sep 2019 07:01:49 +0300 Subject: [PATCH 003/103] Delete build-deps.sh --- build-deps.sh | 23 ----------------------- 1 file changed, 23 deletions(-) delete mode 100644 build-deps.sh diff --git a/build-deps.sh b/build-deps.sh deleted file mode 100644 index 20365ba..0000000 --- a/build-deps.sh +++ /dev/null @@ -1,23 +0,0 @@ -#! /bin/sh -# -# Copyright (c), Recep Aslantas. -# -# MIT License (MIT), http://opensource.org/licenses/MIT -# Full license can be found in the LICENSE file -# - -# check if deps are pulled -git submodule update --init --recursive - -cd $(dirname "$0") - -# general deps: gcc make autoconf automake libtool cmake - -# test - cmocka -cd ./test/lib/cmocka -rm -rf build -mkdir -p build -cd build -cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Debug .. -make -j8 -cd ../../../../ From 712cbee580bcec6644ca25bfdceecdee123f5b64 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 12 Sep 2019 07:10:37 +0300 Subject: [PATCH 004/103] remove cmocka from submodules and update docs --- .gitmodules | 3 --- .travis.yml | 7 +++---- CONTRIBUTING.md | 4 ++-- README.md | 2 +- docs/source/build.rst | 8 +------- test/lib/cmocka | 1 - 6 files changed, 7 insertions(+), 18 deletions(-) delete mode 160000 test/lib/cmocka diff --git a/.gitmodules b/.gitmodules index 4a3bbdc..e69de29 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +0,0 @@ -[submodule "test/lib/cmocka"] - path = test/lib/cmocka - url = git://git.cryptomilk.org/projects/cmocka.git diff --git a/.travis.yml b/.travis.yml index 9f2a546..b4b2df0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -37,7 +37,6 @@ branches: - master script: - - sh ./build-deps.sh - sh ./autogen.sh - if [[ "$CC" == "gcc" && "$CODE_COVERAGE" == "ON" ]]; then ./configure CFLAGS="-ftest-coverage -fprofile-arcs"; @@ -49,7 +48,7 @@ script: after_success: - if [[ "$CC" == "gcc" && "$CODE_COVERAGE" == "ON" ]]; then - pip install --user cpp-coveralls && + pip install --user cpp-coveralls && coveralls --build-root . --exclude lib @@ -58,5 +57,5 @@ after_success: --verbose; fi -after_failure: - - cat ./test-suite.log +# after_failure: +# - cat ./test-suite.log diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 567642d..f25a6ab 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,11 +1,11 @@ # CONTRIBUTING -Any contributions (code, documentation, ...) are welcome. This project uses [cmocka](http://cmocka.org) for testing, you may need to check their documentation +Any contributions (code, documentation, ...) are welcome. # New Features - This library may not accept all new features, it is better to create an issue and get approval before coding - You must add test for every new feature -- The feature must be compiled in both UNIX/POSIX systems (e.g. macos, linux...) and Windows +- The feature must be compiled on both UNIX/POSIX systems (e.g. macos, linux...) and Windows # Code Style This library is written with C99, don't try to add C++ files (yes it can compiled into lib), diff --git a/README.md b/README.md index bfc2e0d..624d18c 100644 --- a/README.md +++ b/README.md @@ -138,7 +138,7 @@ $ sh autogen.sh $ ./configure $ make $ make check # [Optional] -$ [sudo] make install +$ [sudo] make install # [Optional] ``` This will also install pkg-config files so you can use diff --git a/docs/source/build.rst b/docs/source/build.rst index c725ab4..c62fe0c 100644 --- a/docs/source/build.rst +++ b/docs/source/build.rst @@ -1,10 +1,7 @@ Build cglm ================================ -| **cglm** does not have external dependencies except for unit testing. When you pulled **cglm** repo with submodules all dependencies will be pulled too. `build-deps.sh` will pull all dependencies/submodules and build for you. - -External dependencies: - * cmocka - for unit testing +| **cglm** does not have any external dependencies. **NOTE:** If you only need to inline versions, you don't need to build **cglm**, you don't need to link it to your program. @@ -16,8 +13,6 @@ Unix (Autotools): .. code-block:: bash :linenos: - $ sh ./build-deps.sh # run this only once (dependencies) - $ sh autogen.sh $ ./configure $ make @@ -65,4 +60,3 @@ Example build: $ cd cglm/docs $ sphinx-build source build - diff --git a/test/lib/cmocka b/test/lib/cmocka deleted file mode 160000 index 5f61d2f..0000000 --- a/test/lib/cmocka +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 5f61d2f188b0254f6ad74f9d9f84705923ece1fd From 176cc28510b700fc06d4fdf848171a9247a8aedd Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 12 Sep 2019 07:11:49 +0300 Subject: [PATCH 005/103] now working on v0.6.1 --- configure.ac | 2 +- docs/source/conf.py | 4 ++-- include/cglm/version.h | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/configure.ac b/configure.ac index 23de6da..45dc219 100644 --- a/configure.ac +++ b/configure.ac @@ -7,7 +7,7 @@ #***************************************************************************** AC_PREREQ([2.69]) -AC_INIT([cglm], [0.6.0], [info@recp.me]) +AC_INIT([cglm], [0.6.1], [info@recp.me]) AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests]) AC_CONFIG_MACRO_DIR([m4]) diff --git a/docs/source/conf.py b/docs/source/conf.py index 4cd1de2..d56ecfd 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -62,9 +62,9 @@ author = u'Recep Aslantas' # built documents. # # The short X.Y version. -version = u'0.6.0' +version = u'0.6.1' # The full version, including alpha/beta/rc tags. -release = u'0.6.0' +release = u'0.6.1' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/include/cglm/version.h b/include/cglm/version.h index 5843f4b..7926667 100644 --- a/include/cglm/version.h +++ b/include/cglm/version.h @@ -10,6 +10,6 @@ #define CGLM_VERSION_MAJOR 0 #define CGLM_VERSION_MINOR 6 -#define CGLM_VERSION_PATCH 0 +#define CGLM_VERSION_PATCH 1 #endif /* cglm_version_h */ From 80c2b3712dadc47e5d21656b0fb5a4d2605e42f8 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 12 Sep 2019 17:10:31 +0300 Subject: [PATCH 006/103] tests: print elapsed time to run a test --- test/runner.c | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/test/runner.c b/test/runner.c index 10f8d11..35fcac3 100644 --- a/test/runner.c +++ b/test/runner.c @@ -9,12 +9,14 @@ #include "tests.h" #include +#include int main(int argc, const char * argv[]) { test_entry_t *entry; test_status_t st; int32_t i, count, passed, failed; + double start, end, elapsed; passed = failed = 0; count = sizeof(tests) / sizeof(tests[0]); @@ -22,8 +24,11 @@ main(int argc, const char * argv[]) { fprintf(stderr, CYAN "\nWelcome to cglm tests\n\n" RESET); for (i = 0; i < count; i++) { - entry = tests + i; - st = entry->entry(); + entry = tests + i; + start = clock(); + st = entry->entry(); + end = clock(); + elapsed = (end - start) / CLOCKS_PER_SEC; if (!st.status) { fprintf(stderr, @@ -39,10 +44,14 @@ main(int argc, const char * argv[]) { failed++; } else { - fprintf(stderr, - GREEN " ✔︎" RESET " %s\n" - , - entry->name); + fprintf(stderr, GREEN " ✔︎" RESET " %s - " , entry->name); + + if (elapsed > 0.01) + fprintf(stderr, YELLOW "%.2f", elapsed); + else + fprintf(stderr, "0"); + + fprintf(stderr, "s\n" RESET); passed++; } } @@ -58,7 +67,7 @@ main(int argc, const char * argv[]) { MAGENTA "%d" RESET " tests are runned, " GREEN "%d" RESET " %s passed, " RED "%d" RESET " %s failed\n\n" RESET, - passed + failed, + count, passed, passed > 1 ? "are" : "is", failed, From 32e5784564fe90226944822c3596c04b296375b9 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 12 Sep 2019 23:54:24 +0300 Subject: [PATCH 007/103] test: improve runner output and add assert helper for inline functions --- test/include/common.h | 1 + test/runner.c | 39 +++++++++++++++++++++++++++++---------- test/src/test_affine.c | 22 +++++++++++----------- test/src/test_bezier.c | 4 ++-- test/src/test_cam.c | 4 ++-- test/src/test_euler.c | 8 ++++---- test/src/test_mat3.c | 4 ++-- test/src/test_quat.c | 32 ++++++++++++++++---------------- test/src/test_vec3.c | 20 ++++++++++---------- test/src/test_vec4.c | 24 ++++++++++++------------ 10 files changed, 89 insertions(+), 69 deletions(-) diff --git a/test/include/common.h b/test/include/common.h index e58edc2..07b0fb6 100644 --- a/test/include/common.h +++ b/test/include/common.h @@ -70,6 +70,7 @@ typedef struct test_entry_t { #define ASSERT_CHOOSER(...) ASSERT_ARG3(__VA_ARGS__, ASSERT_ARG2, ASSERT_ARG1) #define ASSERT(...) do { ASSERT_CHOOSER(__VA_ARGS__)(__VA_ARGS__) } while(0); +#define ASSERTIFY(expr) ASSERT((expr).status == 1, (expr).msg) #define TEST_OK 1 #define TEST_SUCCESS return (test_status_t){NULL, TEST_OK}; diff --git a/test/runner.c b/test/runner.c index 35fcac3..886e956 100644 --- a/test/runner.c +++ b/test/runner.c @@ -10,25 +10,43 @@ #include #include +#include int main(int argc, const char * argv[]) { test_entry_t *entry; test_status_t st; - int32_t i, count, passed, failed; - double start, end, elapsed; + int32_t i, count, passed, failed, maxlen; + double start, end, elapsed, total; - passed = failed = 0; + passed = failed = maxlen = 0; + total = 0.0; count = sizeof(tests) / sizeof(tests[0]); - + fprintf(stderr, CYAN "\nWelcome to cglm tests\n\n" RESET); - + + for (i = 0; i < count; i++) { + int32_t len; + + entry = tests + i; + len = (int32_t)strlen(entry->name); + + maxlen = GLM_MAX(maxlen, len); + } + + maxlen += 5; + + fprintf(stderr, + BOLDWHITE " %-*s %-*s\n", + maxlen, "Test Name", maxlen, "Elapsed Time"); + for (i = 0; i < count; i++) { entry = tests + i; start = clock(); st = entry->entry(); end = clock(); elapsed = (end - start) / CLOCKS_PER_SEC; + total += elapsed; if (!st.status) { fprintf(stderr, @@ -44,14 +62,14 @@ main(int argc, const char * argv[]) { failed++; } else { - fprintf(stderr, GREEN " ✔︎" RESET " %s - " , entry->name); + fprintf(stderr, GREEN " ✔︎" RESET " %-*s ", maxlen, entry->name); if (elapsed > 0.01) - fprintf(stderr, YELLOW "%.2f", elapsed); + fprintf(stderr, YELLOW "%.2fs", elapsed); else fprintf(stderr, "0"); - fprintf(stderr, "s\n" RESET); + fprintf(stderr, "\n" RESET); passed++; } } @@ -61,12 +79,13 @@ main(int argc, const char * argv[]) { } fprintf(stderr, - CYAN "\ncglm test results:\n" RESET - "------------------\n" + CYAN "\ncglm test results (%0.2fs):\n" RESET + "--------------------------\n" MAGENTA "%d" RESET " tests are runned, " GREEN "%d" RESET " %s passed, " RED "%d" RESET " %s failed\n\n" RESET, + total, count, passed, passed > 1 ? "are" : "is", diff --git a/test/src/test_affine.c b/test/src/test_affine.c index c78b6b2..4f51aea 100644 --- a/test/src/test_affine.c +++ b/test/src/test_affine.c @@ -17,7 +17,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t1, t2, t3); /* R * T */ glm_translate(t1, (vec3){34, 57, 36}); - ASSERT(test_assert_mat4_eq(t1, t3).status == 1) + ASSERTIFY(test_assert_mat4_eq(t1, t3)) /* test rotate is postmultiplied */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -26,7 +26,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glm_rotate(t2, GLM_PI_4f, GLM_YUP); - ASSERT(test_assert_mat4_eq(t2, t3).status == 1) + ASSERTIFY(test_assert_mat4_eq(t2, t3)) /* test scale is postmultiplied */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -37,7 +37,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t3, t4, t5); /* T * R * S */ glm_scale(t3, (vec3){3, 5, 6}); - ASSERT(test_assert_mat4_eq(t3, t5).status == 1) + ASSERTIFY(test_assert_mat4_eq(t3, t5)) /* test translate_x */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -45,7 +45,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t1, t2, t3); /* R * T */ glm_translate_x(t1, 34); - ASSERT(test_assert_mat4_eq(t1, t3).status == 1) + ASSERTIFY(test_assert_mat4_eq(t1, t3)) /* test translate_y */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -53,7 +53,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t1, t2, t3); /* R * T */ glm_translate_y(t1, 57); - ASSERT(test_assert_mat4_eq(t1, t3).status == 1) + ASSERTIFY(test_assert_mat4_eq(t1, t3)) /* test translate_z */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -61,7 +61,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t1, t2, t3); /* R * T */ glm_translate_z(t1, 36); - ASSERT(test_assert_mat4_eq(t1, t3).status == 1) + ASSERTIFY(test_assert_mat4_eq(t1, t3)) /* test rotate_x */ glmc_rotate_make(t1, GLM_PI_4f, (vec3){1, 0, 0}); @@ -70,7 +70,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glm_rotate_x(t2, GLM_PI_4f, t2); - ASSERT(test_assert_mat4_eq(t2, t3).status == 1) + ASSERTIFY(test_assert_mat4_eq(t2, t3)) /* test rotate_y */ glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 1, 0}); @@ -79,7 +79,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glm_rotate_y(t2, GLM_PI_4f, t2); - ASSERT(test_assert_mat4_eq(t2, t3).status == 1) + ASSERTIFY(test_assert_mat4_eq(t2, t3)) /* test rotate_z */ glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1}); @@ -88,7 +88,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glm_rotate_z(t2, GLM_PI_4f, t2); - ASSERT(test_assert_mat4_eq(t2, t3).status == 1) + ASSERTIFY(test_assert_mat4_eq(t2, t3)) /* test rotate */ glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1}); @@ -97,7 +97,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t2, t1, t3); /* T * R */ glmc_rotate(t2, GLM_PI_4f, (vec3){0, 0, 1}); - ASSERT(test_assert_mat4_eq(t3, t2).status == 1) + ASSERTIFY(test_assert_mat4_eq(t3, t2)) /* test scale_uni */ glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); @@ -108,7 +108,7 @@ TEST_IMPL(affine) { glmc_mat4_mul(t3, t4, t5); /* T * R * S */ glm_scale_uni(t3, 3); - ASSERT(test_assert_mat4_eq(t3, t5).status == 1) + ASSERTIFY(test_assert_mat4_eq(t3, t5)) TEST_SUCCESS } diff --git a/test/src/test_bezier.c b/test/src/test_bezier.c index 460c47a..8c22e65 100644 --- a/test/src/test_bezier.c +++ b/test/src/test_bezier.c @@ -50,8 +50,8 @@ TEST_IMPL(bezier) { Bs_plain = test_bezier_plain(s, p0, c0, c1, p1); ASSERT(glm_eq(Bs, Bs_plain)); - ASSERT(test_assert_eqf(smc, Bs_plain).status == 1) - ASSERT(test_assert_eqf(Bs, smc).status == 1) + ASSERTIFY(test_assert_eqf(smc, Bs_plain)) + ASSERTIFY(test_assert_eqf(Bs, smc)) /* test cubic hermite */ smc = glm_smc(s, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1}); diff --git a/test/src/test_cam.c b/test/src/test_cam.c index 889e295..270e577 100644 --- a/test/src/test_cam.c +++ b/test/src/test_cam.c @@ -19,7 +19,7 @@ TEST_IMPL(camera_lookat) { glm_look(eye, dir, up, view2); - ASSERT(test_assert_mat4_eq(view1, view2).status == 1) + ASSERTIFY(test_assert_mat4_eq(view1, view2)) TEST_SUCCESS } @@ -49,7 +49,7 @@ TEST_IMPL(camera_decomp) { farVal, proj2); - ASSERT(test_assert_mat4_eq(proj, proj2).status == 1) + ASSERTIFY(test_assert_mat4_eq(proj, proj2)) TEST_SUCCESS } diff --git a/test/src/test_euler.c b/test/src/test_euler.c index 74618b3..b71e0f0 100644 --- a/test/src/test_euler.c +++ b/test/src/test_euler.c @@ -21,11 +21,11 @@ TEST_IMPL(euler) { glmc_euler_angles(rot1, outAngles); /* angles must be equal in that range */ - ASSERT(test_assert_vec3_eq(inAngles, outAngles).status == 1) + ASSERTIFY(test_assert_vec3_eq(inAngles, outAngles)) /* matrices must be equal */ glmc_euler_xyz(outAngles, rot2); - ASSERT(test_assert_mat4_eq(rot1, rot2).status == 1) + ASSERTIFY(test_assert_mat4_eq(rot1, rot2)) /* change range */ inAngles[0] = glm_rad(-145.0f); /* X angle */ @@ -39,7 +39,7 @@ TEST_IMPL(euler) { /* matrices must be equal */ glmc_euler_xyz(outAngles, rot2); - ASSERT(test_assert_mat4_eq(rot1, rot2).status == 1) - + ASSERTIFY(test_assert_mat4_eq(rot1, rot2)) + TEST_SUCCESS } diff --git a/test/src/test_mat3.c b/test/src/test_mat3.c index 6f43dd4..4d9dc07 100644 --- a/test/src/test_mat3.c +++ b/test/src/test_mat3.c @@ -52,7 +52,7 @@ TEST_IMPL(mat3_mul) { } } - ASSERT(test_assert_mat3_eq(m3, m4).status == 1) + ASSERTIFY(test_assert_mat3_eq(m3, m4)) TEST_SUCCESS } @@ -70,7 +70,7 @@ TEST_IMPL(mat3_inv) { /* test inverse precise */ glmc_mat3_inv(m1, m2); glmc_mat3_inv(m2, m3); - ASSERT(test_assert_mat3_eq(m1, m3).status == 1) + ASSERTIFY(test_assert_mat3_eq(m1, m3)) } TEST_SUCCESS diff --git a/test/src/test_quat.c b/test/src/test_quat.c index 97ddd49..220d7a5 100644 --- a/test/src/test_quat.c +++ b/test/src/test_quat.c @@ -27,7 +27,7 @@ TEST_IMPL(quat) { ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f))) glm_quat_mat4(q4, rot1); - ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1) + ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009)) /* 1. test quat to mat and mat to quat */ for (i = 0; i < 1000; i++) { @@ -38,17 +38,17 @@ TEST_IMPL(quat) { glmc_quat_mat4(outQuat, outRot); /* 2. test first quat and generated one equality */ - ASSERT(test_assert_quat_eq_abs(inQuat, outQuat).status == 1); + ASSERTIFY(test_assert_quat_eq_abs(inQuat, outQuat)); /* 3. test first rot and second rotation */ /* almost equal */ - ASSERT(test_assert_mat4_eq2(inRot, outRot, 0.000009).status == 1); + ASSERTIFY(test_assert_mat4_eq2(inRot, outRot, 0.000009)); /* 4. test SSE mul and raw mul */ #if defined( __SSE__ ) || defined( __SSE2__ ) test_quat_mul_raw(inQuat, outQuat, q3); glm_quat_mul_sse2(inQuat, outQuat, q4); - ASSERT(test_assert_quat_eq(q3, q4).status == 1); + ASSERTIFY(test_assert_quat_eq(q3, q4)); #endif } @@ -62,7 +62,7 @@ TEST_IMPL(quat) { /* create view matrix with quaternion */ glm_quat_look(eye, q3, view2); - ASSERT(test_assert_mat4_eq2(view1, view2, 0.000009).status == 1); + ASSERTIFY(test_assert_mat4_eq2(view1, view2, 0.000009)); /* 6. test quaternion rotation matrix result */ test_rand_quat(q3); @@ -72,7 +72,7 @@ TEST_IMPL(quat) { glm_quat_axis(q3, axis); glm_rotate_make(rot2, glm_quat_angle(q3), axis); - ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1); + ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009)); /* 7. test quaternion multiplication (hamilton product), final rotation = first rotation + second = quat1 * quat2 @@ -92,7 +92,7 @@ TEST_IMPL(quat) { glm_quat_mat4(q5, rot2); /* result must be same (almost) */ - ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) + ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009)) /* 8. test quaternion for look rotation */ @@ -102,21 +102,21 @@ TEST_IMPL(quat) { /* result must be identity */ glm_quat_identity(q4); - ASSERT(test_assert_quat_eq(q3, q4).status == 1) + ASSERTIFY(test_assert_quat_eq(q3, q4)) /* look at from 0, 0, 1 to zero, direction = 0, 0, -1 */ glm_quat_forp(GLM_ZUP, GLM_VEC3_ZERO, (vec3){0, 0, -1}, GLM_YUP, q3); /* result must be identity */ glm_quat_identity(q4); - ASSERT(test_assert_quat_eq(q3, q4).status == 1) + ASSERTIFY(test_assert_quat_eq(q3, q4)) /* 8.2 perpendicular */ glm_quat_for(GLM_XUP, (vec3){0, 0, -1}, GLM_YUP, q3); /* result must be -90 */ glm_quatv(q4, glm_rad(-90.0f), GLM_YUP); - ASSERT(test_assert_quat_eq(q3, q4).status == 1) + ASSERTIFY(test_assert_quat_eq(q3, q4)) /* 9. test imag, real */ @@ -139,7 +139,7 @@ TEST_IMPL(quat) { imag[1] = -1.0f; imag[2] = 0.0f; - ASSERT(test_assert_vec3_eq(imag, axis).status == 1); + ASSERTIFY(test_assert_vec3_eq(imag, axis)); /* 10. test rotate vector using quat */ /* (0,0,-1) around (1,0,0) must give (0,1,0) */ @@ -157,7 +157,7 @@ TEST_IMPL(quat) { && fabsf(v1[1] - 1.0f) <= 0.00009f && fabsf(v1[2]) <= 0.00009f) - ASSERT(test_assert_vec3_eq(v1, v2).status == 1) + ASSERTIFY(test_assert_vec3_eq(v1, v2)) /* 11. test rotate transform */ glm_translate_make(rot1, (vec3){-10.0, 45.0f, 8.0f}); @@ -168,7 +168,7 @@ TEST_IMPL(quat) { glm_quat_rotate(rot2, q3, rot2); /* result must be same (almost) */ - ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) + ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009)) glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP); glm_translate(rot1, (vec3){-10.0, 45.0f, 8.0f}); @@ -179,7 +179,7 @@ TEST_IMPL(quat) { glm_translate(rot2, (vec3){-10.0, 45.0f, 8.0f}); /* result must be same (almost) */ - ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) + ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009)) /* reverse */ glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP); @@ -187,7 +187,7 @@ TEST_IMPL(quat) { glm_quat_rotate(rot1, q3, rot1); /* result must be identity */ - ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1) + ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009)) test_rand_quat(q3); @@ -196,7 +196,7 @@ TEST_IMPL(quat) { glm_quat_mul(q3, q4, q5); glm_quat_identity(q3); - ASSERT(test_assert_quat_eq(q3, q5).status == 1) + ASSERTIFY(test_assert_quat_eq(q3, q5)) /* TODO: add tests for slerp, lerp */ diff --git a/test/src/test_vec3.c b/test/src/test_vec3.c index c529cc2..5db3b32 100644 --- a/test/src/test_vec3.c +++ b/test/src/test_vec3.c @@ -15,11 +15,11 @@ TEST_IMPL(vec3) { /* test zero */ glm_vec3_zero(v); - ASSERT(test_assert_vec3_eq(GLM_VEC3_ZERO, v).status == 1) + ASSERTIFY(test_assert_vec3_eq(GLM_VEC3_ZERO, v)) /* test one */ glm_vec3_one(v); - ASSERT(test_assert_vec3_eq(GLM_VEC3_ONE, v).status == 1) + ASSERTIFY(test_assert_vec3_eq(GLM_VEC3_ONE, v)) /* adds, subs, div, divs, mul */ glm_vec3_add(v, GLM_VEC3_ONE, v); @@ -50,7 +50,7 @@ TEST_IMPL(vec3) { glm_vec3_normalize_to(v, v1); glm_vec3_scale(v1, 0.8f, v1); glm_vec3_scale_as(v, 0.8f, v); - ASSERT(test_assert_vec3_eq(v1, v).status == 1) + ASSERTIFY(test_assert_vec3_eq(v1, v)) /* addadd, subadd, muladd */ glm_vec3_one(v); @@ -73,8 +73,8 @@ TEST_IMPL(vec3) { glm_mat4_pick3(rot1, rot1m3); glm_vec3_rotate_m3(rot1m3, v, v2); - ASSERT(test_assert_vec3_eq(v1, v2).status == 1) - ASSERT(test_assert_vec3_eq(v1, GLM_ZUP).status == 1) + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + ASSERTIFY(test_assert_vec3_eq(v1, GLM_ZUP)) /* structs */ vs1 = test_rand_vec3s(); @@ -82,7 +82,7 @@ TEST_IMPL(vec3) { vs3 = glms_vec3_add(vs1, vs2); vs4 = glms_vec3_maxv(vs1, vs3); - ASSERT(test_assert_vec3s_eq(vs3, vs4).status == 1) + ASSERTIFY(test_assert_vec3s_eq(vs3, vs4)) /* swizzle */ @@ -91,24 +91,24 @@ TEST_IMPL(vec3) { v1[1] = 2; v1[2] = 3; glm_vec3_swizzle(v1, GLM_ZYX, v1); - ASSERT(test_assert_vec3_eq(v1, (vec3){3, 2, 1}).status == 1) + ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 2, 1})) glm_vec3_swizzle(v1, GLM_XXX, v1); - ASSERT(test_assert_vec3_eq(v1, (vec3){3, 3, 3}).status == 1) + ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 3, 3})) v1[0] = 1; v1[1] = 2; v1[2] = 3; glm_vec3_swizzle(v1, GLM_YYY, v1); - ASSERT(test_assert_vec3_eq(v1, (vec3){2, 2, 2}).status == 1) + ASSERTIFY(test_assert_vec3_eq(v1, (vec3){2, 2, 2})) v1[0] = 1; v1[1] = 2; v1[2] = 3; glm_vec3_swizzle(v1, GLM_ZZZ, v1); - ASSERT(test_assert_vec3_eq(v1, (vec3){3, 3, 3}).status == 1) + ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 3, 3})) TEST_SUCCESS } diff --git a/test/src/test_vec4.c b/test/src/test_vec4.c index df59274..7c1e62f 100644 --- a/test/src/test_vec4.c +++ b/test/src/test_vec4.c @@ -106,11 +106,11 @@ TEST_IMPL(vec4) { /* test zero */ glm_vec4_zero(v); - ASSERT(test_assert_vec4_eq(GLM_VEC4_ZERO, v).status == 1) + ASSERTIFY(test_assert_vec4_eq(GLM_VEC4_ZERO, v)) /* test one */ glm_vec4_one(v); - ASSERT(test_assert_vec4_eq(GLM_VEC4_ONE, v).status == 1) + ASSERTIFY(test_assert_vec4_eq(GLM_VEC4_ONE, v)) /* adds, subs, div, divs, mul */ glm_vec4_add(v, GLM_VEC4_ONE, v); @@ -141,7 +141,7 @@ TEST_IMPL(vec4) { glm_vec4_normalize_to(v, v1); glm_vec4_scale(v1, 0.8, v1); glm_vec4_scale_as(v, 0.8, v); - ASSERT(test_assert_vec4_eq(v1, v).status == 1) + ASSERTIFY(test_assert_vec4_eq(v1, v)) /* addadd, subadd, muladd */ glm_vec4_one(v); @@ -163,16 +163,16 @@ TEST_IMPL(vec4) { glm_vec4_maxv(v1, v2, v3); test_vec4_maxv(v1, v2, v4); - ASSERT(test_assert_vec4_eq(v3, v4).status == 1) + ASSERTIFY(test_assert_vec4_eq(v3, v4)) glm_vec4_minv(v1, v2, v3); test_vec4_minv(v1, v2, v4); - ASSERT(test_assert_vec4_eq(v3, v4).status == 1) + ASSERTIFY(test_assert_vec4_eq(v3, v4)) /* clamp */ glm_vec4_clamp(v3, 0.1, 0.8); test_vec4_clamp(v4, 0.1, 0.8); - ASSERT(test_assert_vec4_eq(v3, v4).status == 1) + ASSERTIFY(test_assert_vec4_eq(v3, v4)) ASSERT(v3[0] >= 0.0999 && v3[0] <= 0.80001) /* rounding erros */ ASSERT(v3[1] >= 0.0999 && v3[1] <= 0.80001) @@ -188,10 +188,10 @@ TEST_IMPL(vec4) { v1[3] = 4; glm_vec4_swizzle(v1, GLM_WZYX, v1); - ASSERT(test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1}).status == 1) + ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1})) glm_vec4_swizzle(v1, GLM_XXXX, v1); - ASSERT(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}).status == 1) + ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4})) v1[0] = 1; v1[1] = 2; @@ -199,7 +199,7 @@ TEST_IMPL(vec4) { v1[3] = 4; glm_vec4_swizzle(v1, GLM_YYYY, v1); - ASSERT(test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2}).status == 1) + ASSERTIFY(test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2})) v1[0] = 1; v1[1] = 2; @@ -207,7 +207,7 @@ TEST_IMPL(vec4) { v1[3] = 4; glm_vec4_swizzle(v1, GLM_ZZZZ, v1); - ASSERT(test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3}).status == 1) + ASSERTIFY(test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3})) v1[0] = 1; v1[1] = 2; @@ -215,7 +215,7 @@ TEST_IMPL(vec4) { v1[3] = 4; glm_vec4_swizzle(v1, GLM_WWWW, v1); - ASSERT(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4}).status == 1) + ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4})) /* structs */ vs1 = test_rand_vec4s(); @@ -223,7 +223,7 @@ TEST_IMPL(vec4) { vs3 = glms_vec4_add(vs1, vs2); vs4 = glms_vec4_maxv(vs1, vs3); - ASSERT(test_assert_vec4s_eq(vs3, vs4).status == 1) + ASSERTIFY(test_assert_vec4s_eq(vs3, vs4)) TEST_SUCCESS } From 5aa047efdfe300b67b8a7343df6eb411f52e9e45 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 13 Sep 2019 09:40:18 +0300 Subject: [PATCH 008/103] tests: run tests on windows --- test/include/common.h | 10 ++++++++++ test/runner.c | 4 ++-- test/src/test_cam.c | 8 ++++---- test/src/test_clamp.c | 4 ++-- test/src/test_quat.c | 16 ++++++++-------- test/src/test_vec4.c | 18 +++++++++--------- win/cglm.sln | 17 +++++++++++++++-- win/cglm.vcxproj.filters | 4 ---- 8 files changed, 50 insertions(+), 31 deletions(-) diff --git a/test/include/common.h b/test/include/common.h index e58edc2..09f60cc 100644 --- a/test/include/common.h +++ b/test/include/common.h @@ -78,4 +78,14 @@ typedef struct test_entry_t { test_status_t test_ ## FUN (void); \ test_status_t test_ ## FUN() +#if defined(_WIN32) +# define srand48(x) srand((int)(x)) +# define drand48() ((float)(rand() / RAND_MAX)) +# define OK_TEXT "ok:" +# define FAIL_TEXT "fail:" +#else +# define OK_TEXT "✔︎" +# define FAIL_TEXT "𐄂" +#endif + #endif /* common_h */ diff --git a/test/runner.c b/test/runner.c index 35fcac3..4912edc 100644 --- a/test/runner.c +++ b/test/runner.c @@ -32,7 +32,7 @@ main(int argc, const char * argv[]) { if (!st.status) { fprintf(stderr, - BOLDRED " 𐄂" BOLDWHITE " %s " RESET, + BOLDRED " " FAIL_TEXT BOLDWHITE " %s " RESET, entry->name); if (st.msg) { fprintf(stderr, @@ -44,7 +44,7 @@ main(int argc, const char * argv[]) { failed++; } else { - fprintf(stderr, GREEN " ✔︎" RESET " %s - " , entry->name); + fprintf(stderr, GREEN " " OK_TEXT RESET " %s - " , entry->name); if (elapsed > 0.01) fprintf(stderr, YELLOW "%.2f", elapsed); diff --git a/test/src/test_cam.c b/test/src/test_cam.c index 889e295..13f5bf9 100644 --- a/test/src/test_cam.c +++ b/test/src/test_cam.c @@ -41,10 +41,10 @@ TEST_IMPL(camera_decomp) { glm_persp_sizes(proj, fovy, sizes); - glm_frustum(-sizes[0] * 0.5, - sizes[0] * 0.5, - -sizes[1] * 0.5, - sizes[1] * 0.5, + glm_frustum(-sizes[0] * 0.5f, + sizes[0] * 0.5f, + -sizes[1] * 0.5f, + sizes[1] * 0.5f, nearVal, farVal, proj2); diff --git a/test/src/test_clamp.c b/test/src/test_clamp.c index 30e70f4..1d1c0c2 100644 --- a/test/src/test_clamp.c +++ b/test/src/test_clamp.c @@ -8,8 +8,8 @@ #include "test_common.h" TEST_IMPL(clamp) { - vec3 v3 = {15.07, 0.4, 17.3}; - vec4 v4 = {5.07, 2.3, 1.3, 1.4}; + vec3 v3 = {15.07f, 0.4f, 17.3f}; + vec4 v4 = {5.07f, 2.3f, 1.3f, 1.4f}; ASSERT(glm_clamp(1.6f, 0.0f, 1.0f) == 1.0f) ASSERT(glm_clamp(-1.6f, 0.0f, 1.0f) == 0.0f) diff --git a/test/src/test_quat.c b/test/src/test_quat.c index 97ddd49..8ea458e 100644 --- a/test/src/test_quat.c +++ b/test/src/test_quat.c @@ -27,7 +27,7 @@ TEST_IMPL(quat) { ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f))) glm_quat_mat4(q4, rot1); - ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1) + ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f).status == 1) /* 1. test quat to mat and mat to quat */ for (i = 0; i < 1000; i++) { @@ -42,7 +42,7 @@ TEST_IMPL(quat) { /* 3. test first rot and second rotation */ /* almost equal */ - ASSERT(test_assert_mat4_eq2(inRot, outRot, 0.000009).status == 1); + ASSERT(test_assert_mat4_eq2(inRot, outRot, 0.000009f).status == 1); /* 4. test SSE mul and raw mul */ #if defined( __SSE__ ) || defined( __SSE2__ ) @@ -62,7 +62,7 @@ TEST_IMPL(quat) { /* create view matrix with quaternion */ glm_quat_look(eye, q3, view2); - ASSERT(test_assert_mat4_eq2(view1, view2, 0.000009).status == 1); + ASSERT(test_assert_mat4_eq2(view1, view2, 0.000009f).status == 1); /* 6. test quaternion rotation matrix result */ test_rand_quat(q3); @@ -72,7 +72,7 @@ TEST_IMPL(quat) { glm_quat_axis(q3, axis); glm_rotate_make(rot2, glm_quat_angle(q3), axis); - ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1); + ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009f).status == 1); /* 7. test quaternion multiplication (hamilton product), final rotation = first rotation + second = quat1 * quat2 @@ -92,7 +92,7 @@ TEST_IMPL(quat) { glm_quat_mat4(q5, rot2); /* result must be same (almost) */ - ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) + ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009f).status == 1) /* 8. test quaternion for look rotation */ @@ -168,7 +168,7 @@ TEST_IMPL(quat) { glm_quat_rotate(rot2, q3, rot2); /* result must be same (almost) */ - ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) + ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009f).status == 1) glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP); glm_translate(rot1, (vec3){-10.0, 45.0f, 8.0f}); @@ -179,7 +179,7 @@ TEST_IMPL(quat) { glm_translate(rot2, (vec3){-10.0, 45.0f, 8.0f}); /* result must be same (almost) */ - ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009).status == 1) + ASSERT(test_assert_mat4_eq2(rot1, rot2, 0.000009f).status == 1) /* reverse */ glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP); @@ -187,7 +187,7 @@ TEST_IMPL(quat) { glm_quat_rotate(rot1, q3, rot1); /* result must be identity */ - ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009).status == 1) + ASSERT(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f).status == 1) test_rand_quat(q3); diff --git a/test/src/test_vec4.c b/test/src/test_vec4.c index df59274..0a1b58e 100644 --- a/test/src/test_vec4.c +++ b/test/src/test_vec4.c @@ -98,9 +98,9 @@ TEST_IMPL(vec4) { test_rand_vec4(v2); d1 = glm_vec4_distance(v1, v2); d2 = sqrtf(powf(v1[0] - v2[0], 2.0f) - + pow(v1[1] - v2[1], 2.0f) - + pow(v1[2] - v2[2], 2.0f) - + pow(v1[3] - v2[3], 2.0f)); + + powf(v1[1] - v2[1], 2.0f) + + powf(v1[2] - v2[2], 2.0f) + + powf(v1[3] - v2[3], 2.0f)); ASSERT(fabsf(d1 - d2) <= 0.000009) } @@ -129,18 +129,18 @@ TEST_IMPL(vec4) { glm_vec4_div(v, v1, v); ASSERT(glmc_vec4_eq_eps(v, 5)) - glm_vec4_divs(v, 0.5, v); + glm_vec4_divs(v, 0.5f, v); ASSERT(glmc_vec4_eq_eps(v, 10)) glm_vec4_mul(v, v1, v); ASSERT(glmc_vec4_eq_eps(v, 20)) - glm_vec4_scale(v, 0.5, v); + glm_vec4_scale(v, 0.5f, v); ASSERT(glmc_vec4_eq_eps(v, 10)) glm_vec4_normalize_to(v, v1); - glm_vec4_scale(v1, 0.8, v1); - glm_vec4_scale_as(v, 0.8, v); + glm_vec4_scale(v1, 0.8f, v1); + glm_vec4_scale_as(v, 0.8f, v); ASSERT(test_assert_vec4_eq(v1, v).status == 1) /* addadd, subadd, muladd */ @@ -170,8 +170,8 @@ TEST_IMPL(vec4) { ASSERT(test_assert_vec4_eq(v3, v4).status == 1) /* clamp */ - glm_vec4_clamp(v3, 0.1, 0.8); - test_vec4_clamp(v4, 0.1, 0.8); + glm_vec4_clamp(v3, 0.1f, 0.8f); + test_vec4_clamp(v4, 0.1f, 0.8f); ASSERT(test_assert_vec4_eq(v3, v4).status == 1) ASSERT(v3[0] >= 0.0999 && v3[0] <= 0.80001) /* rounding erros */ diff --git a/win/cglm.sln b/win/cglm.sln index 6316235..04f08b4 100644 --- a/win/cglm.sln +++ b/win/cglm.sln @@ -1,10 +1,12 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 15 -VisualStudioVersion = 15.0.26403.7 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29123.88 MinimumVisualStudioVersion = 10.0.40219.1 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cglm", "cglm.vcxproj", "{CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cglm-test", "cglm-test.vcxproj", "{200E0DF1-7532-44E6-8273-84FB92C5557E}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|x64 = Debug|x64 @@ -21,8 +23,19 @@ Global {CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}.Release|x64.Build.0 = Release|x64 {CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}.Release|x86.ActiveCfg = Release|Win32 {CA8BCAF9-CD25-4133-8F62-3D1449B5D2FC}.Release|x86.Build.0 = Release|Win32 + {200E0DF1-7532-44E6-8273-84FB92C5557E}.Debug|x64.ActiveCfg = Debug|x64 + {200E0DF1-7532-44E6-8273-84FB92C5557E}.Debug|x64.Build.0 = Debug|x64 + {200E0DF1-7532-44E6-8273-84FB92C5557E}.Debug|x86.ActiveCfg = Debug|Win32 + {200E0DF1-7532-44E6-8273-84FB92C5557E}.Debug|x86.Build.0 = Debug|Win32 + {200E0DF1-7532-44E6-8273-84FB92C5557E}.Release|x64.ActiveCfg = Release|x64 + {200E0DF1-7532-44E6-8273-84FB92C5557E}.Release|x64.Build.0 = Release|x64 + {200E0DF1-7532-44E6-8273-84FB92C5557E}.Release|x86.ActiveCfg = Release|Win32 + {200E0DF1-7532-44E6-8273-84FB92C5557E}.Release|x86.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {2AEF23C9-433B-428B-BEBC-068BF3AC9A65} + EndGlobalSection EndGlobal diff --git a/win/cglm.vcxproj.filters b/win/cglm.vcxproj.filters index a9e3f47..21c554c 100644 --- a/win/cglm.vcxproj.filters +++ b/win/cglm.vcxproj.filters @@ -5,10 +5,6 @@ {93995380-89BD-4b04-88EB-625FBE52EBFB} h;hh;hpp;hxx;hm;inl;inc;xsd - - {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} - rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms - {4FC737F1-C7A5-4376-A066-2A32D752A2FF} cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx From 551ed1bd2046043ee5f6f50a3eb1593d61c5261b Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 14 Sep 2019 11:57:35 +0300 Subject: [PATCH 009/103] tests: improve ASSERTIFY --- test/include/common.h | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/test/include/common.h b/test/include/common.h index 26abb72..45bd156 100644 --- a/test/include/common.h +++ b/test/include/common.h @@ -70,7 +70,21 @@ typedef struct test_entry_t { #define ASSERT_CHOOSER(...) ASSERT_ARG3(__VA_ARGS__, ASSERT_ARG2, ASSERT_ARG1) #define ASSERT(...) do { ASSERT_CHOOSER(__VA_ARGS__)(__VA_ARGS__) } while(0); -#define ASSERTIFY(expr) ASSERT((expr).status == 1, (expr).msg) +#define ASSERTIFY(expr) do { \ + test_status_t ts; \ + ts = expr; \ + if (ts.status != 1) { \ + fprintf(stderr, \ + RED " assert fail" RESET \ + " in " BOLDCYAN "%s " RESET \ + "on " BOLDMAGENTA "line %d" RESET \ + " : " BOLDWHITE " ASSERTIFY(%s)\n" RESET, \ + __FILE__, \ + __LINE__, \ + #expr); \ + return (test_status_t){ts.msg, 0}; \ + } \ + } while(0); #define TEST_OK 1 #define TEST_SUCCESS return (test_status_t){NULL, TEST_OK}; @@ -80,8 +94,7 @@ typedef struct test_entry_t { test_status_t test_ ## FUN() #if defined(_WIN32) -# define srand48(x) srand((int)(x)) -# define drand48() ((float)(rand() / RAND_MAX)) +# define drand48() ((float)(rand() / (RAND_MAX + 1.0))) # define OK_TEXT "ok:" # define FAIL_TEXT "fail:" #else From 0ed88cfda8c03af106faab8d2bdb2369f82051ad Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 14 Sep 2019 12:46:04 +0300 Subject: [PATCH 010/103] test: fix running test on windows (msvc) --- test/include/common.h | 2 ++ test/runner.c | 3 ++- test/src/test_vec4.c | 17 ++++++++++------- 3 files changed, 14 insertions(+), 8 deletions(-) diff --git a/test/include/common.h b/test/include/common.h index 45bd156..7459d57 100644 --- a/test/include/common.h +++ b/test/include/common.h @@ -97,9 +97,11 @@ typedef struct test_entry_t { # define drand48() ((float)(rand() / (RAND_MAX + 1.0))) # define OK_TEXT "ok:" # define FAIL_TEXT "fail:" +# define FINAL_TEXT "^_^" #else # define OK_TEXT "✔︎" # define FAIL_TEXT "𐄂" +# define FINAL_TEXT "🎉" #endif #endif /* common_h */ diff --git a/test/runner.c b/test/runner.c index 2af6b67..7d4d858 100644 --- a/test/runner.c +++ b/test/runner.c @@ -74,7 +74,8 @@ main(int argc, const char * argv[]) { } if (failed == 0) { - fprintf(stderr, BOLDGREEN "\n All tests are passed 🎉\n" RESET); + fprintf(stderr, + BOLDGREEN "\n All tests are passed " FINAL_TEXT "\n" RESET); } fprintf(stderr, diff --git a/test/src/test_vec4.c b/test/src/test_vec4.c index 3995b9f..160f1e7 100644 --- a/test/src/test_vec4.c +++ b/test/src/test_vec4.c @@ -63,11 +63,14 @@ test_vec4_clamp(vec4 v, float minVal, float maxVal) { } TEST_IMPL(vec4) { - vec4 v, v1, v2, v3, v4; + vec4 v, v1, v2, v3, v4, one, zero; vec4s vs1, vs2, vs3, vs4; int i; float d1, d2; + glm_vec4_one(one); + glm_vec4_zero(zero); + for (i = 0; i < 1000; i++) { /* 1. test SSE/SIMD dot product */ test_rand_vec4(v); @@ -106,20 +109,20 @@ TEST_IMPL(vec4) { /* test zero */ glm_vec4_zero(v); - ASSERTIFY(test_assert_vec4_eq(GLM_VEC4_ZERO, v)) + ASSERTIFY(test_assert_vec4_eq(zero, v)) /* test one */ glm_vec4_one(v); - ASSERTIFY(test_assert_vec4_eq(GLM_VEC4_ONE, v)) + ASSERTIFY(test_assert_vec4_eq(one, v)) /* adds, subs, div, divs, mul */ - glm_vec4_add(v, GLM_VEC4_ONE, v); + glm_vec4_add(v, one, v); ASSERT(glmc_vec4_eq_eps(v, 2)) glm_vec4_adds(v, 10, v); ASSERT(glmc_vec4_eq_eps(v, 12)) - glm_vec4_sub(v, GLM_VEC4_ONE, v); + glm_vec4_sub(v, one, v); ASSERT(glmc_vec4_eq_eps(v, 11)) glm_vec4_subs(v, 1, v); @@ -146,10 +149,10 @@ TEST_IMPL(vec4) { /* addadd, subadd, muladd */ glm_vec4_one(v); - glm_vec4_addadd(GLM_VEC4_ONE, GLM_VEC4_ONE, v); + glm_vec4_addadd(one, one, v); ASSERT(glmc_vec4_eq_eps(v, 3)) - glm_vec4_subadd(GLM_VEC4_ONE, GLM_VEC4_ZERO, v); + glm_vec4_subadd(one, zero, v); ASSERT(glmc_vec4_eq_eps(v, 4)) glm_vec4_broadcast(2, v1); From 3af861b61e83bc0bf033d0587bbec33c815050b5 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 14 Sep 2019 16:01:43 +0300 Subject: [PATCH 011/103] Update README.md --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 624d18c..fc5ed4b 100644 --- a/README.md +++ b/README.md @@ -166,6 +166,10 @@ if `msbuild` won't work (because of multi version VS) then try to build with `de $ devenv cglm.sln /Build Release ``` +#### Running Tests on Windows + +You can see test project in same visual studio solution file. It is enough to run that project to run tests. + ### Building Docs First you need install Sphinx: http://www.sphinx-doc.org/en/master/usage/installation.html then: From cf411515346886587b86fa72fd44ebcc8e6cd02b Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 14 Sep 2019 16:18:45 +0300 Subject: [PATCH 012/103] Update troubleshooting.rst --- docs/source/troubleshooting.rst | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/source/troubleshooting.rst b/docs/source/troubleshooting.rst index e4cea9f..ad6a009 100644 --- a/docs/source/troubleshooting.rst +++ b/docs/source/troubleshooting.rst @@ -57,6 +57,13 @@ For instance you may called **glm_vec4_** functions for **vec3** data type. It will try to write 32 byte but since **vec3** is 24 byte it should throw memory access error or exit the app without saying anything. +**UPDATE - IMPORTANT:** + + | On MSVC or some other compilers, if alignment is enabled (default) then double check alignment requirements if you got a crash. + + | If you send GLM_VEC4_ONE or similar macros directly to a function, it may be crashed. + | Because compiler may not apply alignment as defined on **typedef** to that macro while passing it (on stack) to a function. + Wrong Results: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ From fbcbccbf01634db2fdb329b4db9b7ec8b3958740 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 14 Sep 2019 16:20:33 +0300 Subject: [PATCH 013/103] Update cglm.podspec --- cglm.podspec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cglm.podspec b/cglm.podspec index f49c294..bb6fe23 100644 --- a/cglm.podspec +++ b/cglm.podspec @@ -2,7 +2,7 @@ Pod::Spec.new do |s| # Description s.name = "cglm" - s.version = "0.5.1" + s.version = "0.6.1" s.summary = "📽 Optimized OpenGL/Graphics Math (glm) for C" s.description = <<-DESC cglm is math library for graphics programming for C. It is similar to original glm but it is written for C instead of C++ (you can use here too). See the documentation or README for all features. From 92f196965e09645ec97a19ff6fd182a8ad6ec109 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 14 Sep 2019 16:22:28 +0300 Subject: [PATCH 014/103] Update .gitignore --- win/.gitignore | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/win/.gitignore b/win/.gitignore index da6703c..96c0a51 100644 --- a/win/.gitignore +++ b/win/.gitignore @@ -1,4 +1,9 @@ !cglm.sln + !cglm.vcxproj !cglm.vcxproj.filters + +!cglm-test.vcxproj +!cglm-test.vcxproj.filters + !packages.config From f4f9d85caa5d00365f5265acab967f314e8a7cc9 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 15 Sep 2019 15:09:52 +0300 Subject: [PATCH 015/103] tests: add more tests for mat4 --- test/include/common.h | 16 +-- test/src/test_common.c | 44 +++++++ test/src/test_common.h | 9 ++ test/src/test_mat4.c | 257 +++++++++++++++++++++++++++++++++-------- test/tests.h | 57 ++++++++- 5 files changed, 324 insertions(+), 59 deletions(-) diff --git a/test/include/common.h b/test/include/common.h index 7459d57..0b4a6d8 100644 --- a/test/include/common.h +++ b/test/include/common.h @@ -51,6 +51,13 @@ typedef struct test_entry_t { #define TEST_ENTRY(FUN) { #FUN, test_ ## FUN, 0, 0 }, #define TEST_LIST static test_entry_t tests[] = +#define TEST_OK 1 +#define TEST_SUCCESS return (test_status_t){NULL, TEST_OK}; + +#define TEST_IMPL(FUN) \ + test_status_t test_ ## FUN (void); \ + test_status_t test_ ## FUN() + #define ASSERT_EXT(expr, msg) \ if (!(expr)) { \ fprintf(stderr, \ @@ -73,7 +80,7 @@ typedef struct test_entry_t { #define ASSERTIFY(expr) do { \ test_status_t ts; \ ts = expr; \ - if (ts.status != 1) { \ + if (ts.status != TEST_OK) { \ fprintf(stderr, \ RED " assert fail" RESET \ " in " BOLDCYAN "%s " RESET \ @@ -86,13 +93,6 @@ typedef struct test_entry_t { } \ } while(0); -#define TEST_OK 1 -#define TEST_SUCCESS return (test_status_t){NULL, TEST_OK}; - -#define TEST_IMPL(FUN) \ - test_status_t test_ ## FUN (void); \ - test_status_t test_ ## FUN() - #if defined(_WIN32) # define drand48() ((float)(rand() / (RAND_MAX + 1.0))) # define OK_TEXT "ok:" diff --git a/test/src/test_common.c b/test/src/test_common.c index 4e966b5..9999e3d 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -124,6 +124,50 @@ test_assert_mat3_eq(mat3 m1, mat3 m2) { TEST_SUCCESS } +test_status_t +test_assert_mat3_eqt(mat3 m1, mat3 m2) { + int i, j, k; + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + for (k = 0; k < 3; k++) + ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009); + } + } + + TEST_SUCCESS +} + +test_status_t +test_assert_mat4_eq_identity(mat4 m4) { + int i, j; + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + if (i == j) { + ASSERT(glm_eq(m4[i][j], 1.0f)) + } else { + ASSERT(glm_eq(m4[i][j], 0.0f)) + } + } + } + + TEST_SUCCESS +} + +test_status_t +test_assert_mat4_eq_zero(mat4 m4) { + int i, j; + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + ASSERT(glm_eq(m4[i][j], 0.0f)) + } + } + + TEST_SUCCESS +} + test_status_t test_assert_eqf(float a, float b) { ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */ diff --git a/test/src/test_common.h b/test/src/test_common.h index 73d9502..13b9310 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -25,9 +25,18 @@ test_assert_mat4_eq(mat4 m1, mat4 m2); test_status_t test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps); +test_status_t +test_assert_mat4_eq_identity(mat4 m4); + +test_status_t +test_assert_mat4_eq_zero(mat4 m4); + test_status_t test_assert_mat3_eq(mat3 m1, mat3 m2); +test_status_t +test_assert_mat3_eqt(mat3 m1, mat3 m2); + test_status_t test_assert_vec3_eq(vec3 v1, vec3 v2); diff --git a/test/src/test_mat4.c b/test/src/test_mat4.c index 49ae8ca..713aa7f 100644 --- a/test/src/test_mat4.c +++ b/test/src/test_mat4.c @@ -10,58 +10,209 @@ #define m 4 #define n 4 -TEST_IMPL(mat4_identity) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; +#define A_MATRIX {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}} +#define A_MATRIX3 {{1,2,3},{5,6,7},{9,10,11}} + +TEST_IMPL(glm_mat4_ucopy) { + mat4 m1 = A_MATRIX; mat4 m2 = GLM_MAT4_IDENTITY_INIT; - mat4 m3; - int i, j; - - /* test identity matrix multiplication */ - glm_mat4_mul(m1, m2, m3); - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) { - if (i == j) { - ASSERT(glm_eq(m3[i][j], 1.0f)) - } else { - ASSERT(glm_eq(m3[i][j], 0.0f)) - } - } - } - + + glm_mat4_ucopy(m1, m2); + + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + TEST_SUCCESS } -TEST_IMPL(mat4_mul) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; - mat4 m2 = GLM_MAT4_IDENTITY_INIT; - mat4 m3; - mat4 m4 = GLM_MAT4_ZERO_INIT; - int i, j, k; - +TEST_IMPL(glm_mat4_copy) { + mat4 m1 = A_MATRIX; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + + glm_mat4_copy(m1, m2); + + test_assert_mat4_eq(m1, m2); + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_identity) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + + glm_mat4_identity(m3); + + ASSERTIFY(test_assert_mat4_eq_identity(m1)) + ASSERTIFY(test_assert_mat4_eq_identity(m2)) + ASSERTIFY(test_assert_mat4_eq_identity(m3)) + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_identity_array) { + int i, count; + mat4 matrices[4] = { + A_MATRIX, + A_MATRIX, + A_MATRIX, + A_MATRIX + }; + + count = 4; + + glm_mat4_identity_array(matrices, count); + + for (i = 0; i < count; i++) { + ASSERTIFY(test_assert_mat4_eq_identity(matrices[i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_zero) { + mat4 m1 = GLM_MAT4_ZERO_INIT; + mat4 m2 = GLM_MAT4_ZERO_INIT; + mat4 m3; + + glm_mat4_zero(m3); + + ASSERTIFY(test_assert_mat4_eq_zero(m1)) + ASSERTIFY(test_assert_mat4_eq_zero(m2)) + ASSERTIFY(test_assert_mat4_eq_zero(m3)) + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_pick3) { + mat4 m1 = A_MATRIX; + mat3 m2 = GLM_MAT3_ZERO_INIT; + mat3 m3 = A_MATRIX3; + + glm_mat4_pick3(m1, m2); + + ASSERTIFY(test_assert_mat3_eq(m2, m3)) + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_pick3t) { + mat4 m1 = A_MATRIX; + mat3 m2 = GLM_MAT3_ZERO_INIT; + mat3 m3 = A_MATRIX3; + + glm_mat4_pick3t(m1, m2); + + ASSERTIFY(test_assert_mat3_eqt(m2, m3)) + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_ins3) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat3 m2 = A_MATRIX3; + int i, j; + + glm_mat4_ins3(m2, m1); + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + ASSERT(m1[i][j] == m2[i][j]) + } + } + + ASSERT(glm_eq(m1[3][0], 0.0f)) + ASSERT(glm_eq(m1[3][1], 0.0f)) + ASSERT(glm_eq(m1[3][2], 0.0f)) + ASSERT(glm_eq(m1[3][3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_mul) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + mat4 m4 = GLM_MAT4_ZERO_INIT; + int i, j, k; + /* test random matrices */ /* random matrices */ test_rand_mat4(m1); test_rand_mat4(m2); - + glm_mat4_mul(m1, m2, m3); for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { for (k = 0; k < m; k++) - /* column-major */ + /* column-major */ m4[i][j] += m1[k][j] * m2[i][k]; } } - - ASSERT(test_assert_mat4_eq(m3, m4).status == TEST_OK) - + + ASSERTIFY(test_assert_mat4_eq(m3, m4)) + /* test pre compiled */ glmc_mat4_mul(m1, m2, m3); - ASSERT(test_assert_mat4_eq(m3, m4).status == TEST_OK) - + ASSERTIFY(test_assert_mat4_eq(m3, m4)) + TEST_SUCCESS } -TEST_IMPL(mat4_all) { +TEST_IMPL(glm_mat4_mulN) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_mulv) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_mulv3) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_trace) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_trace3) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_quat) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_transpose_to) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_transpose) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_scale_p) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_scale) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_det) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + + test_rand_mat4(m1); + + /* test determinant */ + ASSERT(glm_mat4_det(m1) == glmc_mat4_det(m1)) +#if defined( __SSE2__ ) + ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1)) +#endif + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_inv) { mat4 m1 = GLM_MAT4_IDENTITY_INIT; mat4 m3; mat4 m4 = GLM_MAT4_ZERO_INIT; @@ -71,33 +222,33 @@ TEST_IMPL(mat4_all) { for (i = 0; i < 100000; i++) { test_rand_mat4(m3); test_rand_mat4(m4); - + /* test inverse precise */ - glm_mat4_inv_precise(m3, m4); - glm_mat4_inv_precise(m4, m5); - ASSERT(test_assert_mat4_eq(m3, m5).status == TEST_OK) - + glm_mat4_inv(m3, m4); + glm_mat4_inv(m4, m5); + ASSERTIFY(test_assert_mat4_eq(m3, m5)) + test_rand_mat4(m3); test_rand_mat4(m4); glmc_mat4_inv_precise(m3, m4); glmc_mat4_inv_precise(m4, m5); - ASSERT(test_assert_mat4_eq(m3, m5).status == TEST_OK) - + ASSERTIFY(test_assert_mat4_eq(m3, m5)) + /* test inverse rcp */ test_rand_mat4(m3); test_rand_mat4(m4); - + glm_mat4_inv_fast(m3, m4); glm_mat4_inv_fast(m4, m5); - ASSERT(test_assert_mat4_eq2(m3, m5, 0.0009f).status == TEST_OK) - + ASSERTIFY(test_assert_mat4_eq2(m3, m5, 0.0009f)) + test_rand_mat4(m3); test_rand_mat4(m4); - + glmc_mat4_inv(m3, m4); glmc_mat4_inv(m4, m5); - ASSERT(test_assert_mat4_eq2(m3, m5, 0.0009f).status == TEST_OK) + ASSERTIFY(test_assert_mat4_eq2(m3, m5, 0.0009f)) } /* test determinant */ @@ -105,6 +256,22 @@ TEST_IMPL(mat4_all) { #if defined( __SSE2__ ) ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1)) #endif - + + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_inv_fast) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_swap_col) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_swap_row) { + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_rmc) { TEST_SUCCESS } diff --git a/test/tests.h b/test/tests.h index 88562f3..1229842 100644 --- a/test/tests.h +++ b/test/tests.h @@ -17,9 +17,32 @@ */ /* mat4 */ -TEST_DECLARE(mat4_identity) -TEST_DECLARE(mat4_mul) -TEST_DECLARE(mat4_all) +TEST_DECLARE(glm_mat4_ucopy) +TEST_DECLARE(glm_mat4_copy) +TEST_DECLARE(glm_mat4_identity) +TEST_DECLARE(glm_mat4_identity_array) +TEST_DECLARE(glm_mat4_zero) +TEST_DECLARE(glm_mat4_pick3) +TEST_DECLARE(glm_mat4_pick3t) +TEST_DECLARE(glm_mat4_ins3) +TEST_DECLARE(glm_mat4_mul) +TEST_DECLARE(glm_mat4_mulN) +TEST_DECLARE(glm_mat4_mulv) +TEST_DECLARE(glm_mat4_mulv3) +TEST_DECLARE(glm_mat4_trace) +TEST_DECLARE(glm_mat4_trace3) +TEST_DECLARE(glm_mat4_quat) +TEST_DECLARE(glm_mat4_transpose_to) +TEST_DECLARE(glm_mat4_transpose) +TEST_DECLARE(glm_mat4_scale_p) +TEST_DECLARE(glm_mat4_scale) +TEST_DECLARE(glm_mat4_det) +TEST_DECLARE(glm_mat4_inv) +TEST_DECLARE(glm_mat4_inv_fast) +TEST_DECLARE(glm_mat4_swap_col) +TEST_DECLARE(glm_mat4_swap_row) +TEST_DECLARE(glm_mat4_rmc) + TEST_DECLARE(affine) @@ -57,9 +80,31 @@ TEST_DECLARE(vec4) TEST_LIST { /* mat4 */ - TEST_ENTRY(mat4_identity) - TEST_ENTRY(mat4_mul) - TEST_ENTRY(mat4_all) + TEST_ENTRY(glm_mat4_ucopy) + TEST_ENTRY(glm_mat4_copy) + TEST_ENTRY(glm_mat4_identity) + TEST_ENTRY(glm_mat4_identity_array) + TEST_ENTRY(glm_mat4_zero) + TEST_ENTRY(glm_mat4_pick3) + TEST_ENTRY(glm_mat4_pick3t) + TEST_ENTRY(glm_mat4_ins3) + TEST_ENTRY(glm_mat4_mul) + TEST_ENTRY(glm_mat4_mulN) + TEST_ENTRY(glm_mat4_mulv) + TEST_ENTRY(glm_mat4_mulv3) + TEST_ENTRY(glm_mat4_trace) + TEST_ENTRY(glm_mat4_trace3) + TEST_ENTRY(glm_mat4_quat) + TEST_ENTRY(glm_mat4_transpose_to) + TEST_ENTRY(glm_mat4_transpose) + TEST_ENTRY(glm_mat4_scale_p) + TEST_ENTRY(glm_mat4_scale) + TEST_ENTRY(glm_mat4_det) + TEST_ENTRY(glm_mat4_inv) + TEST_ENTRY(glm_mat4_inv_fast) + TEST_ENTRY(glm_mat4_swap_col) + TEST_ENTRY(glm_mat4_swap_row) + TEST_ENTRY(glm_mat4_rmc) TEST_ENTRY(affine) From 39dc61af5427c2df5be27e1f421a3755ac1adc29 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 15 Sep 2019 19:33:41 +0300 Subject: [PATCH 016/103] tests: add a few test for mat4 --- .gitignore | 1 + include/cglm/mat4.h | 3 ++ test/src/test_mat4.c | 72 ++++++++++++++++++++++++++++++++++++++++---- 3 files changed, 70 insertions(+), 6 deletions(-) diff --git a/.gitignore b/.gitignore index 90ccabb..8f9fd0c 100644 --- a/.gitignore +++ b/.gitignore @@ -71,3 +71,4 @@ win/Debug cglm-test-ios* /cglm.pc test-driver +Default-568h@2x.png diff --git a/include/cglm/mat4.h b/include/cglm/mat4.h index e6b916b..7a72f97 100644 --- a/include/cglm/mat4.h +++ b/include/cglm/mat4.h @@ -446,6 +446,9 @@ glm_mat4_quat(mat4 m, versor dest) { /*! * @brief multiply vector with mat4 * + * actually the result is vec4, after multiplication the last component + * is trimmed. if you need it don't use this func. + * * @param[in] m mat4(affine transform) * @param[in] v vec3 * @param[in] last 4th item to make it vec4 diff --git a/test/src/test_mat4.c b/test/src/test_mat4.c index 713aa7f..2a9568b 100644 --- a/test/src/test_mat4.c +++ b/test/src/test_mat4.c @@ -7,9 +7,6 @@ #include "test_common.h" -#define m 4 -#define n 4 - #define A_MATRIX {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}} #define A_MATRIX3 {{1,2,3},{5,6,7},{9,10,11}} @@ -141,9 +138,9 @@ TEST_IMPL(glm_mat4_mul) { test_rand_mat4(m2); glm_mat4_mul(m1, m2, m3); - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) { - for (k = 0; k < m; k++) + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) /* column-major */ m4[i][j] += m1[k][j] * m2[i][k]; } @@ -159,22 +156,85 @@ TEST_IMPL(glm_mat4_mul) { } TEST_IMPL(glm_mat4_mulN) { + mat4 res1, res2; + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + mat4 m3 = A_MATRIX; + + mat4 *matrices[] = { + &m1, &m2, &m3 + }; + + glm_mat4_mulN(matrices, sizeof(matrices) / sizeof(matrices[0]), res1); + + glm_mat4_mul(*matrices[0], *matrices[1], res2); + glm_mat4_mul(res2, *matrices[2], res2); + + ASSERTIFY(test_assert_mat4_eq(res1, res1)) + TEST_SUCCESS } TEST_IMPL(glm_mat4_mulv) { + vec4 res; + mat4 mat = A_MATRIX; + vec4 v = {1.0f, 2.0f, 3.0f, 4.0f}; + int i; + + glm_mat4_mulv(mat, v, res); + + for (i = 0; i < 4; i++) { + ASSERT(glm_eq(res[i], + v[0] * mat[0][i] + + v[1] * mat[1][i] + + v[2] * mat[2][i] + + v[3] * mat[3][i])) + } + TEST_SUCCESS } TEST_IMPL(glm_mat4_mulv3) { + vec4 res; + mat4 mat = A_MATRIX; + vec3 v = {1.0f, 2.0f, 3.0f}; + float last; + int i; + + last = 1.0f; + + glm_mat4_mulv3(mat, v, last, res); + + for (i = 0; i < 3; i++) { + ASSERT(glm_eq(res[i], + v[0] * mat[0][i] + + v[1] * mat[1][i] + + v[2] * mat[2][i] + + last * mat[3][i])) + } + TEST_SUCCESS } TEST_IMPL(glm_mat4_trace) { + mat4 mat = A_MATRIX; + float trace; + + trace = glm_mat4_trace(mat); + + ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3])) + TEST_SUCCESS } TEST_IMPL(glm_mat4_trace3) { + mat4 mat = A_MATRIX; + float trace; + + trace = glm_mat4_trace3(mat); + + ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) + TEST_SUCCESS } From 033d0b0fedd95b107cbcbd654fe9a00c3f5f5f7c Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 16 Sep 2019 10:17:55 +0300 Subject: [PATCH 017/103] tests, win: add visual studio test project files --- win/cglm-test.vcxproj | 189 ++++++++++++++++++++++++++++++++++ win/cglm-test.vcxproj.filters | 65 ++++++++++++ 2 files changed, 254 insertions(+) create mode 100644 win/cglm-test.vcxproj create mode 100644 win/cglm-test.vcxproj.filters diff --git a/win/cglm-test.vcxproj b/win/cglm-test.vcxproj new file mode 100644 index 0000000..c833e6c --- /dev/null +++ b/win/cglm-test.vcxproj @@ -0,0 +1,189 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + + + + + + + + + + {ca8bcaf9-cd25-4133-8f62-3d1449b5d2fc} + + + + 16.0 + {200E0DF1-7532-44E6-8273-84FB92C5557E} + Win32Proj + cglmtest + 10.0 + + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + false + + + true + + + true + + + false + + + + + + Level3 + MaxSpeed + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + ../include;%(AdditionalIncludeDirectories) + + + Console + true + true + true + %(AdditionalDependencies) + + + + + + + Level3 + Disabled + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + ../include;%(AdditionalIncludeDirectories) + + + Console + true + %(AdditionalDependencies) + + + + + + + Level3 + Disabled + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + ../include;%(AdditionalIncludeDirectories) + + + Console + true + %(AdditionalDependencies) + + + + + + + Level3 + MaxSpeed + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + ../include;%(AdditionalIncludeDirectories) + + + Console + true + true + true + %(AdditionalDependencies) + + + + + + \ No newline at end of file diff --git a/win/cglm-test.vcxproj.filters b/win/cglm-test.vcxproj.filters new file mode 100644 index 0000000..c68818e --- /dev/null +++ b/win/cglm-test.vcxproj.filters @@ -0,0 +1,65 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;ipp;xsd + + + + + src + + + src + + + src + + + src + + + src + + + src + + + src + + + src + + + src + + + src + + + src + + + src + + + src + + + + + include + + + include + + + include + + + \ No newline at end of file From 971d753392df594537c06762adc66398af1b5e4e Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Tue, 17 Sep 2019 18:26:45 +0300 Subject: [PATCH 018/103] tests: add some missing tests for mat4 --- test/src/test_common.c | 14 ++++ test/src/test_common.h | 3 + test/src/test_mat4.c | 174 ++++++++++++++++++++++++++++++++--------- test/tests.h | 2 + 4 files changed, 156 insertions(+), 37 deletions(-) diff --git a/test/src/test_common.c b/test/src/test_common.c index 9999e3d..d2b6271 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -96,6 +96,20 @@ test_assert_mat4_eq(mat4 m1, mat4 m2) { TEST_SUCCESS } +test_status_t +test_assert_mat4_eqt(mat4 m1, mat4 m2) { + int i, j, k; + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009) + } + } + + TEST_SUCCESS +} + test_status_t test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) { int i, j, k; diff --git a/test/src/test_common.h b/test/src/test_common.h index 13b9310..155f21c 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -22,6 +22,9 @@ test_assert_eqf(float a, float b); test_status_t test_assert_mat4_eq(mat4 m1, mat4 m2); +test_status_t +test_assert_mat4_eqt(mat4 m1, mat4 m2); + test_status_t test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps); diff --git a/test/src/test_mat4.c b/test/src/test_mat4.c index 2a9568b..21e7fd5 100644 --- a/test/src/test_mat4.c +++ b/test/src/test_mat4.c @@ -149,7 +149,7 @@ TEST_IMPL(glm_mat4_mul) { ASSERTIFY(test_assert_mat4_eq(m3, m4)) /* test pre compiled */ - glmc_mat4_mul(m1, m2, m3); + glm_mat4_mul(m1, m2, m3); ASSERTIFY(test_assert_mat4_eq(m3, m4)) TEST_SUCCESS @@ -239,22 +239,90 @@ TEST_IMPL(glm_mat4_trace3) { } TEST_IMPL(glm_mat4_quat) { + mat4 m1, m2; + versor q1, q2, q3; + vec3 axis1; + vec3 axis2 = {1.9f, 2.3f, 4.5f}; + + glm_quat(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + glm_quat_mat4(q1, m1); + glm_mat4_quat(m1, q2); + + glm_rotate_make(m2, GLM_PI_4, axis2); + glm_mat4_quat(m1, q3); + + glm_quat_axis(q3, axis1); + + glm_vec3_normalize(axis1); + glm_vec3_normalize(axis2); + + ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) + ASSERTIFY(test_assert_vec4_eq(q1, q2)) + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + ASSERTIFY(test_assert_vec4_eq(q1, q3)) + TEST_SUCCESS } TEST_IMPL(glm_mat4_transpose_to) { + mat4 mat = A_MATRIX; + mat4 m1; + + glm_mat4_transpose_to(mat, m1); + + ASSERTIFY(test_assert_mat4_eqt(mat, m1)) + TEST_SUCCESS } TEST_IMPL(glm_mat4_transpose) { + mat4 mat = A_MATRIX; + mat4 m1; + + glm_mat4_copy(mat, m1); + glm_mat4_transpose(m1); + + ASSERTIFY(test_assert_mat4_eqt(mat, m1)) + TEST_SUCCESS } TEST_IMPL(glm_mat4_scale_p) { + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + int i, j, k, scale; + + scale = rand() % 100; + + glm_mat4_scale_p(m1, scale); + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + } + } + TEST_SUCCESS } TEST_IMPL(glm_mat4_scale) { + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + int i, j, k, scale; + + scale = rand() % 100; + + glm_mat4_scale(m1, scale); + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + } + } + TEST_SUCCESS } @@ -273,62 +341,94 @@ TEST_IMPL(glm_mat4_det) { } TEST_IMPL(glm_mat4_inv) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; - mat4 m3; - mat4 m4 = GLM_MAT4_ZERO_INIT; - mat4 m5; + mat4 m1, m2, m3; int i; for (i = 0; i < 100000; i++) { - test_rand_mat4(m3); - test_rand_mat4(m4); + test_rand_mat4(m1); + test_rand_mat4(m2); /* test inverse precise */ - glm_mat4_inv(m3, m4); - glm_mat4_inv(m4, m5); - ASSERTIFY(test_assert_mat4_eq(m3, m5)) - - test_rand_mat4(m3); - test_rand_mat4(m4); - - glmc_mat4_inv_precise(m3, m4); - glmc_mat4_inv_precise(m4, m5); - ASSERTIFY(test_assert_mat4_eq(m3, m5)) - - /* test inverse rcp */ - test_rand_mat4(m3); - test_rand_mat4(m4); - - glm_mat4_inv_fast(m3, m4); - glm_mat4_inv_fast(m4, m5); - ASSERTIFY(test_assert_mat4_eq2(m3, m5, 0.0009f)) - - test_rand_mat4(m3); - test_rand_mat4(m4); - - glmc_mat4_inv(m3, m4); - glmc_mat4_inv(m4, m5); - ASSERTIFY(test_assert_mat4_eq2(m3, m5, 0.0009f)) + glm_mat4_inv(m1, m2); + glm_mat4_inv(m2, m3); + ASSERTIFY(test_assert_mat4_eq(m1, m3)) } - /* test determinant */ - ASSERT(glm_mat4_det(m1) == glmc_mat4_det(m1)) -#if defined( __SSE2__ ) - ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1)) -#endif + TEST_SUCCESS +} + +TEST_IMPL(glm_mat4_inv_precise) { + mat4 m1, m2, m3; + int i; + + for (i = 0; i < 100000; i++) { + test_rand_mat4(m1); + test_rand_mat4(m2); + + glm_mat4_inv_precise(m1, m2); + glm_mat4_inv_precise(m2, m3); + ASSERTIFY(test_assert_mat4_eq(m1, m3)) + } TEST_SUCCESS } TEST_IMPL(glm_mat4_inv_fast) { + mat4 m1, m2, m3; + int i; + + for (i = 0; i < 100000; i++) { + test_rand_mat4(m1); + test_rand_mat4(m2); + + /* test inverse precise */ + glm_mat4_inv_fast(m1, m2); + glm_mat4_inv_fast(m2, m3); + ASSERTIFY(test_assert_mat4_eq2(m1, m3, 0.0009f)) + } + TEST_SUCCESS } TEST_IMPL(glm_mat4_swap_col) { + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + + glm_mat4_swap_col(m1, 0, 1); + glm_mat4_swap_col(m1, 2, 3); + + ASSERTIFY(test_assert_vec4_eq(m1[0], m2[1])) + ASSERTIFY(test_assert_vec4_eq(m1[1], m2[0])) + ASSERTIFY(test_assert_vec4_eq(m1[2], m2[3])) + ASSERTIFY(test_assert_vec4_eq(m1[3], m2[2])) + TEST_SUCCESS } TEST_IMPL(glm_mat4_swap_row) { + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + + glm_mat4_swap_row(m1, 0, 1); + glm_mat4_swap_row(m1, 2, 3); + + ASSERT(glm_eq(m1[0][0], m2[0][1])) + ASSERT(glm_eq(m1[0][1], m2[0][0])) + ASSERT(glm_eq(m1[0][2], m2[0][3])) + ASSERT(glm_eq(m1[0][3], m2[0][2])) + ASSERT(glm_eq(m1[1][0], m2[1][1])) + ASSERT(glm_eq(m1[1][1], m2[1][0])) + ASSERT(glm_eq(m1[1][2], m2[1][3])) + ASSERT(glm_eq(m1[1][3], m2[1][2])) + ASSERT(glm_eq(m1[2][0], m2[2][1])) + ASSERT(glm_eq(m1[2][1], m2[2][0])) + ASSERT(glm_eq(m1[2][2], m2[2][3])) + ASSERT(glm_eq(m1[2][3], m2[2][2])) + ASSERT(glm_eq(m1[3][0], m2[3][1])) + ASSERT(glm_eq(m1[3][1], m2[3][0])) + ASSERT(glm_eq(m1[3][2], m2[3][3])) + ASSERT(glm_eq(m1[3][3], m2[3][2])) + TEST_SUCCESS } diff --git a/test/tests.h b/test/tests.h index 1229842..01b05d4 100644 --- a/test/tests.h +++ b/test/tests.h @@ -39,6 +39,7 @@ TEST_DECLARE(glm_mat4_scale) TEST_DECLARE(glm_mat4_det) TEST_DECLARE(glm_mat4_inv) TEST_DECLARE(glm_mat4_inv_fast) +TEST_DECLARE(glm_mat4_inv_precise) TEST_DECLARE(glm_mat4_swap_col) TEST_DECLARE(glm_mat4_swap_row) TEST_DECLARE(glm_mat4_rmc) @@ -102,6 +103,7 @@ TEST_LIST { TEST_ENTRY(glm_mat4_det) TEST_ENTRY(glm_mat4_inv) TEST_ENTRY(glm_mat4_inv_fast) + TEST_ENTRY(glm_mat4_inv_precise) TEST_ENTRY(glm_mat4_swap_col) TEST_ENTRY(glm_mat4_swap_row) TEST_ENTRY(glm_mat4_rmc) From 0377b99f80e900b44a3bd03de02d4d9ee61ba679 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 18 Sep 2019 17:07:15 +0300 Subject: [PATCH 019/103] mat4: add zero for call --- include/cglm/call/mat4.h | 4 ++++ src/mat4.c | 6 ++++++ 2 files changed, 10 insertions(+) diff --git a/include/cglm/call/mat4.h b/include/cglm/call/mat4.h index 54fbcbe..1c71da1 100644 --- a/include/cglm/call/mat4.h +++ b/include/cglm/call/mat4.h @@ -33,6 +33,10 @@ CGLM_EXPORT void glmc_mat4_identity_array(mat4 * __restrict mat, size_t count); +CGLM_EXPORT +void +glmc_mat4_zero(mat4 mat); + CGLM_EXPORT void glmc_mat4_pick3(mat4 mat, mat3 dest); diff --git a/src/mat4.c b/src/mat4.c index c648a6e..a9f39c6 100644 --- a/src/mat4.c +++ b/src/mat4.c @@ -32,6 +32,12 @@ glmc_mat4_identity_array(mat4 * __restrict mat, size_t count) { glm_mat4_identity_array(mat, count); } +CGLM_EXPORT +void +glmc_mat4_zero(mat4 mat) { + glm_mat4_zero(mat); +} + CGLM_EXPORT void glmc_mat4_pick3(mat4 mat, mat3 dest) { From a1283282efb87e8ba1bbb52de0241dbca265ac55 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 18 Sep 2019 17:07:40 +0300 Subject: [PATCH 020/103] tests: update test design to test both call and inline versions --- test/include/common.h | 10 +- test/src/test_mat4.c | 435 ++-------------------------------------- test/src/test_mat4.h | 456 ++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 51 +++++ 4 files changed, 528 insertions(+), 424 deletions(-) create mode 100644 test/src/test_mat4.h diff --git a/test/include/common.h b/test/include/common.h index 0b4a6d8..d3d03a9 100644 --- a/test/include/common.h +++ b/test/include/common.h @@ -54,10 +54,18 @@ typedef struct test_entry_t { #define TEST_OK 1 #define TEST_SUCCESS return (test_status_t){NULL, TEST_OK}; -#define TEST_IMPL(FUN) \ +#define TEST_IMPL_ARG1(FUN) \ test_status_t test_ ## FUN (void); \ test_status_t test_ ## FUN() +#define TEST_IMPL_ARG2(PREFIX, FUN) TEST_IMPL_ARG1(PREFIX ## FUN) +#define TEST_IMPL_ARG3(arg1, arg2, arg3, ...) arg3 + +#define TEST_IMPL_CHOOSER(...) \ + TEST_IMPL_ARG3(__VA_ARGS__, TEST_IMPL_ARG2, TEST_IMPL_ARG1) + +#define TEST_IMPL(...) TEST_IMPL_CHOOSER(__VA_ARGS__)(__VA_ARGS__) + #define ASSERT_EXT(expr, msg) \ if (!(expr)) { \ fprintf(stderr, \ diff --git a/test/src/test_mat4.c b/test/src/test_mat4.c index 21e7fd5..b12daf9 100644 --- a/test/src/test_mat4.c +++ b/test/src/test_mat4.c @@ -5,433 +5,22 @@ * Full license can be found in the LICENSE file */ -#include "test_common.h" +/* test inline mat4 */ -#define A_MATRIX {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}} -#define A_MATRIX3 {{1,2,3},{5,6,7},{9,10,11}} +#define GLM_PREFIX glm_ +#define GLM(X) (glm_ ## X) -TEST_IMPL(glm_mat4_ucopy) { - mat4 m1 = A_MATRIX; - mat4 m2 = GLM_MAT4_IDENTITY_INIT; +#include "test_mat4.h" - glm_mat4_ucopy(m1, m2); +#undef GLM +#undef GLM_PREFIX - ASSERTIFY(test_assert_mat4_eq(m1, m2)) +/* test pre-compiled mat4 */ - TEST_SUCCESS -} +#define GLM_PREFIX glmc_ +#define GLM(X) (glmc_ ## X) -TEST_IMPL(glm_mat4_copy) { - mat4 m1 = A_MATRIX; - mat4 m2 = GLM_MAT4_IDENTITY_INIT; +#include "test_mat4.h" - glm_mat4_copy(m1, m2); - - test_assert_mat4_eq(m1, m2); - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_identity) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; - mat4 m2 = GLM_MAT4_IDENTITY_INIT; - mat4 m3; - - glm_mat4_identity(m3); - - ASSERTIFY(test_assert_mat4_eq_identity(m1)) - ASSERTIFY(test_assert_mat4_eq_identity(m2)) - ASSERTIFY(test_assert_mat4_eq_identity(m3)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_identity_array) { - int i, count; - mat4 matrices[4] = { - A_MATRIX, - A_MATRIX, - A_MATRIX, - A_MATRIX - }; - - count = 4; - - glm_mat4_identity_array(matrices, count); - - for (i = 0; i < count; i++) { - ASSERTIFY(test_assert_mat4_eq_identity(matrices[i])) - } - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_zero) { - mat4 m1 = GLM_MAT4_ZERO_INIT; - mat4 m2 = GLM_MAT4_ZERO_INIT; - mat4 m3; - - glm_mat4_zero(m3); - - ASSERTIFY(test_assert_mat4_eq_zero(m1)) - ASSERTIFY(test_assert_mat4_eq_zero(m2)) - ASSERTIFY(test_assert_mat4_eq_zero(m3)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_pick3) { - mat4 m1 = A_MATRIX; - mat3 m2 = GLM_MAT3_ZERO_INIT; - mat3 m3 = A_MATRIX3; - - glm_mat4_pick3(m1, m2); - - ASSERTIFY(test_assert_mat3_eq(m2, m3)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_pick3t) { - mat4 m1 = A_MATRIX; - mat3 m2 = GLM_MAT3_ZERO_INIT; - mat3 m3 = A_MATRIX3; - - glm_mat4_pick3t(m1, m2); - - ASSERTIFY(test_assert_mat3_eqt(m2, m3)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_ins3) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; - mat3 m2 = A_MATRIX3; - int i, j; - - glm_mat4_ins3(m2, m1); - - for (i = 0; i < 3; i++) { - for (j = 0; j < 3; j++) { - ASSERT(m1[i][j] == m2[i][j]) - } - } - - ASSERT(glm_eq(m1[3][0], 0.0f)) - ASSERT(glm_eq(m1[3][1], 0.0f)) - ASSERT(glm_eq(m1[3][2], 0.0f)) - ASSERT(glm_eq(m1[3][3], 1.0f)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_mul) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; - mat4 m2 = GLM_MAT4_IDENTITY_INIT; - mat4 m3; - mat4 m4 = GLM_MAT4_ZERO_INIT; - int i, j, k; - - /* test random matrices */ - /* random matrices */ - test_rand_mat4(m1); - test_rand_mat4(m2); - - glm_mat4_mul(m1, m2, m3); - for (i = 0; i < 4; i++) { - for (j = 0; j < 4; j++) { - for (k = 0; k < 4; k++) - /* column-major */ - m4[i][j] += m1[k][j] * m2[i][k]; - } - } - - ASSERTIFY(test_assert_mat4_eq(m3, m4)) - - /* test pre compiled */ - glm_mat4_mul(m1, m2, m3); - ASSERTIFY(test_assert_mat4_eq(m3, m4)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_mulN) { - mat4 res1, res2; - mat4 m1 = A_MATRIX; - mat4 m2 = A_MATRIX; - mat4 m3 = A_MATRIX; - - mat4 *matrices[] = { - &m1, &m2, &m3 - }; - - glm_mat4_mulN(matrices, sizeof(matrices) / sizeof(matrices[0]), res1); - - glm_mat4_mul(*matrices[0], *matrices[1], res2); - glm_mat4_mul(res2, *matrices[2], res2); - - ASSERTIFY(test_assert_mat4_eq(res1, res1)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_mulv) { - vec4 res; - mat4 mat = A_MATRIX; - vec4 v = {1.0f, 2.0f, 3.0f, 4.0f}; - int i; - - glm_mat4_mulv(mat, v, res); - - for (i = 0; i < 4; i++) { - ASSERT(glm_eq(res[i], - v[0] * mat[0][i] - + v[1] * mat[1][i] - + v[2] * mat[2][i] - + v[3] * mat[3][i])) - } - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_mulv3) { - vec4 res; - mat4 mat = A_MATRIX; - vec3 v = {1.0f, 2.0f, 3.0f}; - float last; - int i; - - last = 1.0f; - - glm_mat4_mulv3(mat, v, last, res); - - for (i = 0; i < 3; i++) { - ASSERT(glm_eq(res[i], - v[0] * mat[0][i] - + v[1] * mat[1][i] - + v[2] * mat[2][i] - + last * mat[3][i])) - } - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_trace) { - mat4 mat = A_MATRIX; - float trace; - - trace = glm_mat4_trace(mat); - - ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3])) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_trace3) { - mat4 mat = A_MATRIX; - float trace; - - trace = glm_mat4_trace3(mat); - - ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_quat) { - mat4 m1, m2; - versor q1, q2, q3; - vec3 axis1; - vec3 axis2 = {1.9f, 2.3f, 4.5f}; - - glm_quat(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); - glm_quat_mat4(q1, m1); - glm_mat4_quat(m1, q2); - - glm_rotate_make(m2, GLM_PI_4, axis2); - glm_mat4_quat(m1, q3); - - glm_quat_axis(q3, axis1); - - glm_vec3_normalize(axis1); - glm_vec3_normalize(axis2); - - ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4)) - ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) - ASSERTIFY(test_assert_vec4_eq(q1, q2)) - ASSERTIFY(test_assert_mat4_eq(m1, m2)) - ASSERTIFY(test_assert_vec4_eq(q1, q3)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_transpose_to) { - mat4 mat = A_MATRIX; - mat4 m1; - - glm_mat4_transpose_to(mat, m1); - - ASSERTIFY(test_assert_mat4_eqt(mat, m1)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_transpose) { - mat4 mat = A_MATRIX; - mat4 m1; - - glm_mat4_copy(mat, m1); - glm_mat4_transpose(m1); - - ASSERTIFY(test_assert_mat4_eqt(mat, m1)) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_scale_p) { - mat4 m1 = A_MATRIX; - mat4 m2 = A_MATRIX; - int i, j, k, scale; - - scale = rand() % 100; - - glm_mat4_scale_p(m1, scale); - - for (i = 0; i < 4; i++) { - for (j = 0; j < 4; j++) { - for (k = 0; k < 4; k++) - ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) - } - } - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_scale) { - mat4 m1 = A_MATRIX; - mat4 m2 = A_MATRIX; - int i, j, k, scale; - - scale = rand() % 100; - - glm_mat4_scale(m1, scale); - - for (i = 0; i < 4; i++) { - for (j = 0; j < 4; j++) { - for (k = 0; k < 4; k++) - ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) - } - } - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_det) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; - - test_rand_mat4(m1); - - /* test determinant */ - ASSERT(glm_mat4_det(m1) == glmc_mat4_det(m1)) -#if defined( __SSE2__ ) - ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1)) -#endif - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_inv) { - mat4 m1, m2, m3; - int i; - - for (i = 0; i < 100000; i++) { - test_rand_mat4(m1); - test_rand_mat4(m2); - - /* test inverse precise */ - glm_mat4_inv(m1, m2); - glm_mat4_inv(m2, m3); - ASSERTIFY(test_assert_mat4_eq(m1, m3)) - } - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_inv_precise) { - mat4 m1, m2, m3; - int i; - - for (i = 0; i < 100000; i++) { - test_rand_mat4(m1); - test_rand_mat4(m2); - - glm_mat4_inv_precise(m1, m2); - glm_mat4_inv_precise(m2, m3); - ASSERTIFY(test_assert_mat4_eq(m1, m3)) - } - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_inv_fast) { - mat4 m1, m2, m3; - int i; - - for (i = 0; i < 100000; i++) { - test_rand_mat4(m1); - test_rand_mat4(m2); - - /* test inverse precise */ - glm_mat4_inv_fast(m1, m2); - glm_mat4_inv_fast(m2, m3); - ASSERTIFY(test_assert_mat4_eq2(m1, m3, 0.0009f)) - } - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_swap_col) { - mat4 m1 = A_MATRIX; - mat4 m2 = A_MATRIX; - - glm_mat4_swap_col(m1, 0, 1); - glm_mat4_swap_col(m1, 2, 3); - - ASSERTIFY(test_assert_vec4_eq(m1[0], m2[1])) - ASSERTIFY(test_assert_vec4_eq(m1[1], m2[0])) - ASSERTIFY(test_assert_vec4_eq(m1[2], m2[3])) - ASSERTIFY(test_assert_vec4_eq(m1[3], m2[2])) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_swap_row) { - mat4 m1 = A_MATRIX; - mat4 m2 = A_MATRIX; - - glm_mat4_swap_row(m1, 0, 1); - glm_mat4_swap_row(m1, 2, 3); - - ASSERT(glm_eq(m1[0][0], m2[0][1])) - ASSERT(glm_eq(m1[0][1], m2[0][0])) - ASSERT(glm_eq(m1[0][2], m2[0][3])) - ASSERT(glm_eq(m1[0][3], m2[0][2])) - ASSERT(glm_eq(m1[1][0], m2[1][1])) - ASSERT(glm_eq(m1[1][1], m2[1][0])) - ASSERT(glm_eq(m1[1][2], m2[1][3])) - ASSERT(glm_eq(m1[1][3], m2[1][2])) - ASSERT(glm_eq(m1[2][0], m2[2][1])) - ASSERT(glm_eq(m1[2][1], m2[2][0])) - ASSERT(glm_eq(m1[2][2], m2[2][3])) - ASSERT(glm_eq(m1[2][3], m2[2][2])) - ASSERT(glm_eq(m1[3][0], m2[3][1])) - ASSERT(glm_eq(m1[3][1], m2[3][0])) - ASSERT(glm_eq(m1[3][2], m2[3][3])) - ASSERT(glm_eq(m1[3][3], m2[3][2])) - - TEST_SUCCESS -} - -TEST_IMPL(glm_mat4_rmc) { - TEST_SUCCESS -} +#undef GLM +#undef GLM_PREFIX diff --git a/test/src/test_mat4.h b/test/src/test_mat4.h new file mode 100644 index 0000000..316e12a --- /dev/null +++ b/test/src/test_mat4.h @@ -0,0 +1,456 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +#define A_MATRIX {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}} +#define A_MATRIX3 {{1,2,3},{5,6,7},{9,10,11}} + +TEST_IMPL(GLM_PREFIX, mat4_ucopy) { + mat4 m1 = A_MATRIX; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + + GLM(mat4_ucopy)(m1, m2); + + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_copy) { + mat4 m1 = A_MATRIX; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + + GLM(mat4_copy)(m1, m2); + + test_assert_mat4_eq(m1, m2); + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_identity) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + + GLM(mat4_identity)(m3); + + ASSERTIFY(test_assert_mat4_eq_identity(m1)) + ASSERTIFY(test_assert_mat4_eq_identity(m2)) + ASSERTIFY(test_assert_mat4_eq_identity(m3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_identity_array) { + int i, count; + mat4 matrices[4] = { + A_MATRIX, + A_MATRIX, + A_MATRIX, + A_MATRIX + }; + + count = 4; + + GLM(mat4_identity_array)(matrices, count); + + for (i = 0; i < count; i++) { + ASSERTIFY(test_assert_mat4_eq_identity(matrices[i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_zero) { + mat4 m1 = GLM_MAT4_ZERO_INIT; + mat4 m2 = GLM_MAT4_ZERO_INIT; + mat4 m3; + + GLM(mat4_zero)(m3); + + ASSERTIFY(test_assert_mat4_eq_zero(m1)) + ASSERTIFY(test_assert_mat4_eq_zero(m2)) + ASSERTIFY(test_assert_mat4_eq_zero(m3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_pick3) { + mat4 m1 = A_MATRIX; + mat3 m2 = GLM_MAT3_ZERO_INIT; + mat3 m3 = A_MATRIX3; + + GLM(mat4_pick3)(m1, m2); + + ASSERTIFY(test_assert_mat3_eq(m2, m3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_pick3t) { + mat4 m1 = A_MATRIX; + mat3 m2 = GLM_MAT3_ZERO_INIT; + mat3 m3 = A_MATRIX3; + + GLM(mat4_pick3t)(m1, m2); + + ASSERTIFY(test_assert_mat3_eqt(m2, m3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_ins3) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat3 m2 = A_MATRIX3; + int i, j; + + GLM(mat4_ins3)(m2, m1); + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + ASSERT(m1[i][j] == m2[i][j]) + } + } + + ASSERT(glm_eq(m1[3][0], 0.0f)) + ASSERT(glm_eq(m1[3][1], 0.0f)) + ASSERT(glm_eq(m1[3][2], 0.0f)) + ASSERT(glm_eq(m1[3][3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_mul) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + mat4 m4 = GLM_MAT4_ZERO_INIT; + int i, j, k; + + /* test random matrices */ + /* random matrices */ + test_rand_mat4(m1); + test_rand_mat4(m2); + + GLM(mat4_mul)(m1, m2, m3); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + /* column-major */ + m4[i][j] += m1[k][j] * m2[i][k]; + } + } + + ASSERTIFY(test_assert_mat4_eq(m3, m4)) + + /* test pre compiled */ + GLM(mat4_mul)(m1, m2, m3); + ASSERTIFY(test_assert_mat4_eq(m3, m4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_mulN) { + mat4 res1, res2; + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + mat4 m3 = A_MATRIX; + + mat4 *matrices[] = { + &m1, &m2, &m3 + }; + + GLM(mat4_mulN)(matrices, sizeof(matrices) / sizeof(matrices[0]), res1); + + GLM(mat4_mul)(*matrices[0], *matrices[1], res2); + GLM(mat4_mul)(res2, *matrices[2], res2); + + ASSERTIFY(test_assert_mat4_eq(res1, res1)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_mulv) { + vec4 res; + mat4 mat = A_MATRIX; + vec4 v = {1.0f, 2.0f, 3.0f, 4.0f}; + int i; + + GLM(mat4_mulv)(mat, v, res); + + for (i = 0; i < 4; i++) { + ASSERT(glm_eq(res[i], + v[0] * mat[0][i] + + v[1] * mat[1][i] + + v[2] * mat[2][i] + + v[3] * mat[3][i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_mulv3) { + vec4 res; + mat4 mat = A_MATRIX; + vec3 v = {1.0f, 2.0f, 3.0f}; + float last; + int i; + + last = 1.0f; + + GLM(mat4_mulv3)(mat, v, last, res); + + for (i = 0; i < 3; i++) { + ASSERT(glm_eq(res[i], + v[0] * mat[0][i] + + v[1] * mat[1][i] + + v[2] * mat[2][i] + + last * mat[3][i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_trace) { + mat4 mat = A_MATRIX; + float trace; + + trace = glm_mat4_trace(mat); + + ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_trace3) { + mat4 mat = A_MATRIX; + float trace; + + trace = GLM(mat4_trace3)(mat); + + ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_quat) { + mat4 m1, m2; + versor q1, q2, q3; + vec3 axis1; + vec3 axis2 = {1.9f, 2.3f, 4.5f}; + + GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat_mat4)(q1, m1); + GLM(mat4_quat)(m1, q2); + + GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(mat4_quat)(m1, q3); + + GLM(quat_axis)(q3, axis1); + + GLM(vec3_normalize)(axis1); + GLM(vec3_normalize)(axis2); + + ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) + ASSERTIFY(test_assert_vec4_eq(q1, q2)) + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + ASSERTIFY(test_assert_vec4_eq(q1, q3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_transpose_to) { + mat4 mat = A_MATRIX; + mat4 m1; + + GLM(mat4_transpose_to)(mat, m1); + + ASSERTIFY(test_assert_mat4_eqt(mat, m1)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_transpose) { + mat4 mat = A_MATRIX; + mat4 m1; + + GLM(mat4_copy)(mat, m1); + GLM(mat4_transpose)(m1); + + ASSERTIFY(test_assert_mat4_eqt(mat, m1)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_scale_p) { + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + int i, j, k, scale; + + scale = rand() % 100; + + GLM(mat4_scale_p)(m1, scale); + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + } + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_scale) { + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + int i, j, k, scale; + + scale = rand() % 100; + + GLM(mat4_scale)(m1, scale); + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + } + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_det) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + + test_rand_mat4(m1); + + /* test determinant */ + ASSERT(glm_mat4_det(m1) == glmc_mat4_det(m1)) +#if defined( __SSE2__ ) + ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1)) +#endif + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_inv) { + mat4 m1, m2, m3; + int i; + + for (i = 0; i < 100000; i++) { + test_rand_mat4(m1); + test_rand_mat4(m2); + + /* test inverse precise */ + GLM(mat4_inv)(m1, m2); + GLM(mat4_inv)(m2, m3); + ASSERTIFY(test_assert_mat4_eq(m1, m3)) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_inv_precise) { + mat4 m1, m2, m3; + int i; + + for (i = 0; i < 100000; i++) { + test_rand_mat4(m1); + test_rand_mat4(m2); + + glm_mat4_inv_precise(m1, m2); + glm_mat4_inv_precise(m2, m3); + ASSERTIFY(test_assert_mat4_eq(m1, m3)) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_inv_fast) { + mat4 m1, m2, m3; + int i; + + for (i = 0; i < 100000; i++) { + test_rand_mat4(m1); + test_rand_mat4(m2); + + /* test inverse precise */ + GLM(mat4_inv_fast)(m1, m2); + GLM(mat4_inv_fast)(m2, m3); + ASSERTIFY(test_assert_mat4_eq2(m1, m3, 0.0009f)) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_swap_col) { + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + + GLM(mat4_swap_col)(m1, 0, 1); + GLM(mat4_swap_col)(m1, 2, 3); + + ASSERTIFY(test_assert_vec4_eq(m1[0], m2[1])) + ASSERTIFY(test_assert_vec4_eq(m1[1], m2[0])) + ASSERTIFY(test_assert_vec4_eq(m1[2], m2[3])) + ASSERTIFY(test_assert_vec4_eq(m1[3], m2[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_swap_row) { + mat4 m1 = A_MATRIX; + mat4 m2 = A_MATRIX; + + GLM(mat4_swap_row)(m1, 0, 1); + GLM(mat4_swap_row)(m1, 2, 3); + + ASSERT(glm_eq(m1[0][0], m2[0][1])) + ASSERT(glm_eq(m1[0][1], m2[0][0])) + ASSERT(glm_eq(m1[0][2], m2[0][3])) + ASSERT(glm_eq(m1[0][3], m2[0][2])) + ASSERT(glm_eq(m1[1][0], m2[1][1])) + ASSERT(glm_eq(m1[1][1], m2[1][0])) + ASSERT(glm_eq(m1[1][2], m2[1][3])) + ASSERT(glm_eq(m1[1][3], m2[1][2])) + ASSERT(glm_eq(m1[2][0], m2[2][1])) + ASSERT(glm_eq(m1[2][1], m2[2][0])) + ASSERT(glm_eq(m1[2][2], m2[2][3])) + ASSERT(glm_eq(m1[2][3], m2[2][2])) + ASSERT(glm_eq(m1[3][0], m2[3][1])) + ASSERT(glm_eq(m1[3][1], m2[3][0])) + ASSERT(glm_eq(m1[3][2], m2[3][3])) + ASSERT(glm_eq(m1[3][3], m2[3][2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat4_rmc) { + mat4 mat = A_MATRIX; + vec4 v = {1.0f, 2.0f, 3.0f, 4.0f}; + vec4 v1; + float r1, r2; + int i; + + r1 = GLM(mat4_rmc)(v, mat, v); + + for (i = 0; i < 4; i++) { + v1[i] = v[0] * mat[i][0] + + v[1] * mat[i][1] + + v[2] * mat[i][2] + + v[3] * mat[i][3]; + } + + r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2] + v[3] * v1[3]; + + ASSERT(glm_eq(r1, r2)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 01b05d4..bb5e89a 100644 --- a/test/tests.h +++ b/test/tests.h @@ -44,6 +44,31 @@ TEST_DECLARE(glm_mat4_swap_col) TEST_DECLARE(glm_mat4_swap_row) TEST_DECLARE(glm_mat4_rmc) +TEST_DECLARE(glmc_mat4_ucopy) +TEST_DECLARE(glmc_mat4_copy) +TEST_DECLARE(glmc_mat4_identity) +TEST_DECLARE(glmc_mat4_identity_array) +TEST_DECLARE(glmc_mat4_zero) +TEST_DECLARE(glmc_mat4_pick3) +TEST_DECLARE(glmc_mat4_pick3t) +TEST_DECLARE(glmc_mat4_ins3) +TEST_DECLARE(glmc_mat4_mul) +TEST_DECLARE(glmc_mat4_mulN) +TEST_DECLARE(glmc_mat4_mulv) +TEST_DECLARE(glmc_mat4_mulv3) +TEST_DECLARE(glmc_mat4_trace) +TEST_DECLARE(glmc_mat4_trace3) +TEST_DECLARE(glmc_mat4_quat) +TEST_DECLARE(glmc_mat4_transpose_to) +TEST_DECLARE(glmc_mat4_transpose) +TEST_DECLARE(glmc_mat4_scale_p) +TEST_DECLARE(glmc_mat4_scale) +TEST_DECLARE(glmc_mat4_det) +TEST_DECLARE(glmc_mat4_inv) +TEST_DECLARE(glmc_mat4_inv_fast) +TEST_DECLARE(glmc_mat4_swap_col) +TEST_DECLARE(glmc_mat4_swap_row) +TEST_DECLARE(glmc_mat4_rmc) TEST_DECLARE(affine) @@ -108,6 +133,32 @@ TEST_LIST { TEST_ENTRY(glm_mat4_swap_row) TEST_ENTRY(glm_mat4_rmc) + TEST_ENTRY(glmc_mat4_ucopy) + TEST_ENTRY(glmc_mat4_copy) + TEST_ENTRY(glmc_mat4_identity) + TEST_ENTRY(glmc_mat4_identity_array) + TEST_ENTRY(glmc_mat4_zero) + TEST_ENTRY(glmc_mat4_pick3) + TEST_ENTRY(glmc_mat4_pick3t) + TEST_ENTRY(glmc_mat4_ins3) + TEST_ENTRY(glmc_mat4_mul) + TEST_ENTRY(glmc_mat4_mulN) + TEST_ENTRY(glmc_mat4_mulv) + TEST_ENTRY(glmc_mat4_mulv3) + TEST_ENTRY(glmc_mat4_trace) + TEST_ENTRY(glmc_mat4_trace3) + TEST_ENTRY(glmc_mat4_quat) + TEST_ENTRY(glmc_mat4_transpose_to) + TEST_ENTRY(glmc_mat4_transpose) + TEST_ENTRY(glmc_mat4_scale_p) + TEST_ENTRY(glmc_mat4_scale) + TEST_ENTRY(glmc_mat4_det) + TEST_ENTRY(glmc_mat4_inv) + TEST_ENTRY(glmc_mat4_inv_fast) + TEST_ENTRY(glmc_mat4_swap_col) + TEST_ENTRY(glmc_mat4_swap_row) + TEST_ENTRY(glmc_mat4_rmc) + TEST_ENTRY(affine) /* mat3 */ From 79087a9813f0b28e0cd4aae2f0dc21c8efcb4609 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 18 Sep 2019 23:33:10 +0300 Subject: [PATCH 021/103] mat4: add zero for call --- include/cglm/call/mat3.h | 4 ++++ src/mat3.c | 6 ++++++ 2 files changed, 10 insertions(+) diff --git a/include/cglm/call/mat3.h b/include/cglm/call/mat3.h index fbd8270..36dcb27 100644 --- a/include/cglm/call/mat3.h +++ b/include/cglm/call/mat3.h @@ -24,6 +24,10 @@ CGLM_EXPORT void glmc_mat3_identity(mat3 mat); +CGLM_EXPORT +void +glmc_mat3_zero(mat3 mat); + CGLM_EXPORT void glmc_mat3_identity_array(mat3 * __restrict mat, size_t count); diff --git a/src/mat3.c b/src/mat3.c index 337f1f1..1286bd9 100644 --- a/src/mat3.c +++ b/src/mat3.c @@ -20,6 +20,12 @@ glmc_mat3_identity(mat3 mat) { glm_mat3_identity(mat); } +CGLM_EXPORT +void +glmc_mat3_zero(mat3 mat) { + glm_mat3_zero(mat); +} + CGLM_EXPORT void glmc_mat3_identity_array(mat3 * __restrict mat, size_t count) { From 78f38db4802ce19e803c59e76cbbcad0ab5ad2a9 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 18 Sep 2019 23:33:41 +0300 Subject: [PATCH 022/103] tests: add missing tests for mat3 --- test/src/test_common.c | 30 ++++ test/src/test_common.h | 6 + test/src/test_mat3.c | 75 ++-------- test/src/test_mat3.h | 307 +++++++++++++++++++++++++++++++++++++++++ test/tests.h | 72 +++++++++- 5 files changed, 421 insertions(+), 69 deletions(-) create mode 100644 test/src/test_mat3.h diff --git a/test/src/test_common.c b/test/src/test_common.c index d2b6271..7c808be 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -152,6 +152,36 @@ test_assert_mat3_eqt(mat3 m1, mat3 m2) { TEST_SUCCESS } +test_status_t +test_assert_mat3_eq_identity(mat3 m3) { + int i, j; + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + if (i == j) { + ASSERT(glm_eq(m3[i][j], 1.0f)) + } else { + ASSERT(glm_eq(m3[i][j], 0.0f)) + } + } + } + + TEST_SUCCESS +} + +test_status_t +test_assert_mat3_eq_zero(mat3 m3) { + int i, j; + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + ASSERT(glm_eq(m3[i][j], 0.0f)) + } + } + + TEST_SUCCESS +} + test_status_t test_assert_mat4_eq_identity(mat4 m4) { int i, j; diff --git a/test/src/test_common.h b/test/src/test_common.h index 155f21c..2ebe227 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -40,6 +40,12 @@ test_assert_mat3_eq(mat3 m1, mat3 m2); test_status_t test_assert_mat3_eqt(mat3 m1, mat3 m2); +test_status_t +test_assert_mat3_eq_identity(mat3 m3); + +test_status_t +test_assert_mat3_eq_zero(mat3 m3); + test_status_t test_assert_vec3_eq(vec3 v1, vec3 v2); diff --git a/test/src/test_mat3.c b/test/src/test_mat3.c index 4d9dc07..0c9cf98 100644 --- a/test/src/test_mat3.c +++ b/test/src/test_mat3.c @@ -5,73 +5,22 @@ * Full license can be found in the LICENSE file */ -#include "test_common.h" +/* test inline mat3 */ -#define m 3 -#define n 3 +#define GLM_PREFIX glm_ +#define GLM(X) (glm_ ## X) -TEST_IMPL(mat3_identity) { - mat3 m1 = GLM_MAT3_IDENTITY_INIT; - mat3 m2 = GLM_MAT3_IDENTITY_INIT; - mat3 m3; - int i, j; - - /* test identity matrix multiplication */ - glmc_mat3_mul(m1, m2, m3); - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) { - if (i == j) { - ASSERT(glm_eq(m3[i][j], 1.0f)) - } else { - ASSERT(glm_eq(m3[i][j], 0.0f)) - } - } - } - - TEST_SUCCESS -} +#include "test_mat3.h" -TEST_IMPL(mat3_mul) { - mat3 m1 = GLM_MAT3_IDENTITY_INIT; - mat3 m2 = GLM_MAT3_IDENTITY_INIT; - mat3 m3; - mat3 m4 = GLM_MAT3_ZERO_INIT; - int i, j, k; +#undef GLM +#undef GLM_PREFIX - /* test random matrices */ - /* random matrices */ - test_rand_mat3(m1); - test_rand_mat3(m2); +/* test pre-compiled mat3 */ - glmc_mat3_mul(m1, m2, m3); - for (i = 0; i < m; i++) { - for (j = 0; j < n; j++) { - for (k = 0; k < m; k++) - /* column-major */ - m4[i][j] += m1[k][j] * m2[i][k]; - } - } - - ASSERTIFY(test_assert_mat3_eq(m3, m4)) - - TEST_SUCCESS -} +#define GLM_PREFIX glmc_ +#define GLM(X) (glmc_ ## X) -TEST_IMPL(mat3_inv) { - mat3 m1 = GLM_MAT3_IDENTITY_INIT; - mat3 m2 = GLM_MAT3_IDENTITY_INIT; - mat3 m3; - int i; - - for (i = 0; i < 100000; i++) { - test_rand_mat3(m1); - test_rand_mat3(m2); +#include "test_mat3.h" - /* test inverse precise */ - glmc_mat3_inv(m1, m2); - glmc_mat3_inv(m2, m3); - ASSERTIFY(test_assert_mat3_eq(m1, m3)) - } - - TEST_SUCCESS -} +#undef GLM +#undef GLM_PREFIX diff --git a/test/src/test_mat3.h b/test/src/test_mat3.h new file mode 100644 index 0000000..d45c3d6 --- /dev/null +++ b/test/src/test_mat3.h @@ -0,0 +1,307 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +#define A_MATRIX {{1,2,3},{5,6,7},{9,10,11}} + +TEST_IMPL(GLM_PREFIX, mat3_copy) { + mat3 m1 = A_MATRIX; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + + GLM(mat3_copy)(m1, m2); + + test_assert_mat3_eq(m1, m2); + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_identity) { + mat3 m1 = GLM_MAT3_IDENTITY_INIT; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + mat3 m3; + + GLM(mat3_identity)(m3); + + ASSERTIFY(test_assert_mat3_eq_identity(m1)) + ASSERTIFY(test_assert_mat3_eq_identity(m2)) + ASSERTIFY(test_assert_mat3_eq_identity(m3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_identity_array) { + int i, count; + mat3 matrices[4] = { + A_MATRIX, + A_MATRIX, + A_MATRIX, + A_MATRIX + }; + + count = 4; + + GLM(mat3_identity_array)(matrices, count); + + for (i = 0; i < count; i++) { + ASSERTIFY(test_assert_mat3_eq_identity(matrices[i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_zero) { + mat3 m1 = GLM_MAT3_ZERO_INIT; + mat3 m2 = GLM_MAT3_ZERO_INIT; + mat3 m3; + + GLM(mat3_zero)(m3); + + ASSERTIFY(test_assert_mat3_eq_zero(m1)) + ASSERTIFY(test_assert_mat3_eq_zero(m2)) + ASSERTIFY(test_assert_mat3_eq_zero(m3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_mul) { + mat3 m1 = GLM_MAT3_IDENTITY_INIT; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + mat3 m3; + mat3 m4 = GLM_MAT3_ZERO_INIT; + int i, j, k; + + /* test random matrices */ + /* random matrices */ + test_rand_mat3(m1); + test_rand_mat3(m2); + + GLM(mat3_mul)(m1, m2, m3); + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + for (k = 0; k < 3; k++) + /* column-major */ + m4[i][j] += m1[k][j] * m2[i][k]; + } + } + + ASSERTIFY(test_assert_mat3_eq(m3, m4)) + + /* test pre compiled */ + GLM(mat3_mul)(m1, m2, m3); + ASSERTIFY(test_assert_mat3_eq(m3, m4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_mulv) { + vec4 res; + mat3 mat = A_MATRIX; + vec4 v = {1.0f, 2.0f, 3.0f, 4.0f}; + int i; + + GLM(mat3_mulv)(mat, v, res); + + for (i = 0; i < 3; i++) { + ASSERT(glm_eq(res[i], + v[0] * mat[0][i] + + v[1] * mat[1][i] + + v[2] * mat[2][i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_trace) { + mat3 mat = A_MATRIX; + float trace; + + trace = glm_mat3_trace(mat); + + ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_quat) { + mat3 m1, m3; + mat4 m2; + versor q1, q2, q3; + vec3 axis1; + vec3 axis2 = {1.9f, 2.3f, 4.5f}; + + GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat_mat3)(q1, m1); + GLM(mat3_quat)(m1, q2); + + GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(mat3_quat)(m1, q3); + + GLM(quat_axis)(q3, axis1); + + GLM(vec3_normalize)(axis1); + GLM(vec3_normalize)(axis2); + + glm_mat4_pick3(m2, m3); + + ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) + ASSERTIFY(test_assert_vec4_eq(q1, q2)) + ASSERTIFY(test_assert_mat3_eq(m1, m3)) + ASSERTIFY(test_assert_vec4_eq(q1, q3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_transpose_to) { + mat3 mat = A_MATRIX; + mat3 m1; + + GLM(mat3_transpose_to)(mat, m1); + + ASSERTIFY(test_assert_mat3_eqt(mat, m1)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_transpose) { + mat3 mat = A_MATRIX; + mat3 m1; + + GLM(mat3_copy)(mat, m1); + GLM(mat3_transpose)(m1); + + ASSERTIFY(test_assert_mat3_eqt(mat, m1)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_scale) { + mat3 m1 = A_MATRIX; + mat3 m2 = A_MATRIX; + int i, j, k, scale; + + scale = rand() % 100; + + GLM(mat3_scale)(m1, scale); + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + for (k = 0; k < 3; k++) + ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + } + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_det) { + mat3 mat; + + float a = mat[0][0], b = mat[0][1], c = mat[0][2], + d = mat[1][0], e = mat[1][1], f = mat[1][2], + g = mat[2][0], h = mat[2][1], i = mat[2][2]; + + float det1, det2; + + det1 = a * (e * i - h * f) - d * (b * i - c * h) + g * (b * f - c * e); + det2 = glm_mat3_det(mat); + + test_rand_mat3(mat); + + ASSERT(glm_eq(det1, det2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_inv) { + mat3 m1 = GLM_MAT3_IDENTITY_INIT; + mat3 m2 = GLM_MAT3_IDENTITY_INIT; + mat3 m3; + int i; + + for (i = 0; i < 100000; i++) { + test_rand_mat3(m1); + test_rand_mat3(m2); + + /* test inverse precise */ + glmc_mat3_inv(m1, m2); + glmc_mat3_inv(m2, m3); + ASSERTIFY(test_assert_mat3_eq(m1, m3)) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_swap_col) { + mat3 m1 = A_MATRIX; + mat3 m2 = A_MATRIX; + + GLM(mat3_swap_col)(m1, 0, 1); + + ASSERTIFY(test_assert_vec3_eq(m1[0], m2[1])) + ASSERTIFY(test_assert_vec3_eq(m1[1], m2[0])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_swap_row) { + mat3 m1 = A_MATRIX; + mat3 m2 = A_MATRIX; + + GLM(mat3_swap_row)(m1, 0, 1); + + ASSERT(glm_eq(m1[0][0], m2[0][1])) + ASSERT(glm_eq(m1[0][1], m2[0][0])) + ASSERT(glm_eq(m1[0][2], m2[0][2])) + + ASSERT(glm_eq(m1[1][0], m2[1][1])) + ASSERT(glm_eq(m1[1][1], m2[1][0])) + ASSERT(glm_eq(m1[1][2], m2[1][2])) + + ASSERT(glm_eq(m1[2][0], m2[2][1])) + ASSERT(glm_eq(m1[2][1], m2[2][0])) + ASSERT(glm_eq(m1[2][2], m2[2][2])) + + GLM(mat3_swap_row)(m1, 1, 2); + + ASSERT(glm_eq(m1[0][0], m2[0][1])) + ASSERT(glm_eq(m1[0][1], m2[0][2])) + ASSERT(glm_eq(m1[0][2], m2[0][0])) + + ASSERT(glm_eq(m1[1][0], m2[1][1])) + ASSERT(glm_eq(m1[1][1], m2[1][2])) + ASSERT(glm_eq(m1[1][2], m2[1][0])) + + ASSERT(glm_eq(m1[2][0], m2[2][1])) + ASSERT(glm_eq(m1[2][1], m2[2][2])) + ASSERT(glm_eq(m1[2][2], m2[2][0])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mat3_rmc) { + mat3 mat = A_MATRIX; + vec3 v = {11.0f, 12.0f, 13.0f}; + vec3 v1; + float r1, r2; + int i; + + r1 = GLM(mat3_rmc)(v, mat, v); + + for (i = 0; i < 3; i++) { + v1[i] = v[0] * mat[i][0] + + v[1] * mat[i][1] + + v[2] * mat[i][2]; + } + + r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2]; + + ASSERT(glm_eq(r1, r2)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index bb5e89a..a3bf582 100644 --- a/test/tests.h +++ b/test/tests.h @@ -73,9 +73,39 @@ TEST_DECLARE(glmc_mat4_rmc) TEST_DECLARE(affine) /* mat3 */ -TEST_DECLARE(mat3_identity) -TEST_DECLARE(mat3_mul) -TEST_DECLARE(mat3_inv) +TEST_DECLARE(glm_mat3_copy) +TEST_DECLARE(glm_mat3_identity) +TEST_DECLARE(glm_mat3_identity_array) +TEST_DECLARE(glm_mat3_zero) +TEST_DECLARE(glm_mat3_mul) +TEST_DECLARE(glm_mat3_mulv) +TEST_DECLARE(glm_mat3_trace) +TEST_DECLARE(glm_mat3_quat) +TEST_DECLARE(glm_mat3_transpose_to) +TEST_DECLARE(glm_mat3_transpose) +TEST_DECLARE(glm_mat3_scale) +TEST_DECLARE(glm_mat3_det) +TEST_DECLARE(glm_mat3_inv) +TEST_DECLARE(glm_mat3_swap_col) +TEST_DECLARE(glm_mat3_swap_row) +TEST_DECLARE(glm_mat3_rmc) + +TEST_DECLARE(glmc_mat3_copy) +TEST_DECLARE(glmc_mat3_identity) +TEST_DECLARE(glmc_mat3_identity_array) +TEST_DECLARE(glmc_mat3_zero) +TEST_DECLARE(glmc_mat3_mul) +TEST_DECLARE(glmc_mat3_mulv) +TEST_DECLARE(glmc_mat3_trace) +TEST_DECLARE(glmc_mat3_quat) +TEST_DECLARE(glmc_mat3_transpose_to) +TEST_DECLARE(glmc_mat3_transpose) +TEST_DECLARE(glmc_mat3_scale) +TEST_DECLARE(glmc_mat3_det) +TEST_DECLARE(glmc_mat3_inv) +TEST_DECLARE(glmc_mat3_swap_col) +TEST_DECLARE(glmc_mat3_swap_row) +TEST_DECLARE(glmc_mat3_rmc) /* camera */ TEST_DECLARE(camera_lookat) @@ -162,9 +192,39 @@ TEST_LIST { TEST_ENTRY(affine) /* mat3 */ - TEST_ENTRY(mat3_identity) - TEST_ENTRY(mat3_mul) - TEST_ENTRY(mat3_inv) + TEST_ENTRY(glm_mat3_copy) + TEST_ENTRY(glm_mat3_identity) + TEST_ENTRY(glm_mat3_identity_array) + TEST_ENTRY(glm_mat3_zero) + TEST_ENTRY(glm_mat3_mul) + TEST_ENTRY(glm_mat3_mulv) + TEST_ENTRY(glm_mat3_trace) + TEST_ENTRY(glm_mat3_quat) + TEST_ENTRY(glm_mat3_transpose_to) + TEST_ENTRY(glm_mat3_transpose) + TEST_ENTRY(glm_mat3_scale) + TEST_ENTRY(glm_mat3_det) + TEST_ENTRY(glm_mat3_inv) + TEST_ENTRY(glm_mat3_swap_col) + TEST_ENTRY(glm_mat3_swap_row) + TEST_ENTRY(glm_mat3_rmc) + + TEST_ENTRY(glmc_mat3_copy) + TEST_ENTRY(glmc_mat3_identity) + TEST_ENTRY(glmc_mat3_identity_array) + TEST_ENTRY(glmc_mat3_zero) + TEST_ENTRY(glmc_mat3_mul) + TEST_ENTRY(glmc_mat3_mulv) + TEST_ENTRY(glmc_mat3_trace) + TEST_ENTRY(glmc_mat3_quat) + TEST_ENTRY(glmc_mat3_transpose_to) + TEST_ENTRY(glmc_mat3_transpose) + TEST_ENTRY(glmc_mat3_scale) + TEST_ENTRY(glmc_mat3_det) + TEST_ENTRY(glmc_mat3_inv) + TEST_ENTRY(glmc_mat3_swap_col) + TEST_ENTRY(glmc_mat3_swap_row) + TEST_ENTRY(glmc_mat3_rmc) /* camera */ TEST_ENTRY(camera_lookat) From 7797ee7b06fbcc9b30f1ec1d33b1840dd1b92358 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 19 Sep 2019 00:02:38 +0300 Subject: [PATCH 023/103] Update .travis.yml --- .travis.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index b4b2df0..3ff8f33 100644 --- a/.travis.yml +++ b/.travis.yml @@ -39,7 +39,7 @@ branches: script: - sh ./autogen.sh - if [[ "$CC" == "gcc" && "$CODE_COVERAGE" == "ON" ]]; then - ./configure CFLAGS="-ftest-coverage -fprofile-arcs"; + ./configure CFLAGS="-ftest-coverage -fprofile-arcs -coverage"; else ./configure; fi @@ -55,6 +55,7 @@ after_success: --exclude test --gcov-options '\-lp' --verbose; + bash <(curl -s https://codecov.io/bash) fi # after_failure: From e5fd735e622f582000c8ef6687f6032ec4d9bd51 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 19 Sep 2019 00:09:56 +0300 Subject: [PATCH 024/103] Update .travis.yml --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 3ff8f33..31b5574 100644 --- a/.travis.yml +++ b/.travis.yml @@ -54,8 +54,8 @@ after_success: --exclude lib --exclude test --gcov-options '\-lp' - --verbose; - bash <(curl -s https://codecov.io/bash) + --verbose && + bash <(curl -s https://codecov.io/bash); fi # after_failure: From 8ac767fd2cea6b5a058625987469f3b581cc0994 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 19 Sep 2019 00:27:26 +0300 Subject: [PATCH 025/103] tests: fix mat3, mat4 tests --- test/src/test_mat3.h | 26 +++++++++++++----------- test/src/test_mat4.h | 37 ++++++++++++++++++++++++++-------- test/src/tests-test_mat4.gcno | Bin 0 -> 83560 bytes 3 files changed, 43 insertions(+), 20 deletions(-) create mode 100644 test/src/tests-test_mat4.gcno diff --git a/test/src/test_mat3.h b/test/src/test_mat3.h index d45c3d6..0659a2e 100644 --- a/test/src/test_mat3.h +++ b/test/src/test_mat3.h @@ -120,7 +120,7 @@ TEST_IMPL(GLM_PREFIX, mat3_trace) { mat3 mat = A_MATRIX; float trace; - trace = glm_mat3_trace(mat); + trace = GLM(mat3_trace)(mat); ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) @@ -146,7 +146,7 @@ TEST_IMPL(GLM_PREFIX, mat3_quat) { GLM(vec3_normalize)(axis1); GLM(vec3_normalize)(axis2); - glm_mat4_pick3(m2, m3); + GLM(mat4_pick3)(m2, m3); ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) @@ -201,18 +201,20 @@ TEST_IMPL(GLM_PREFIX, mat3_scale) { TEST_IMPL(GLM_PREFIX, mat3_det) { mat3 mat; - - float a = mat[0][0], b = mat[0][1], c = mat[0][2], - d = mat[1][0], e = mat[1][1], f = mat[1][2], - g = mat[2][0], h = mat[2][1], i = mat[2][2]; - + float a, b, c, + d, e, f, + g, h, i; float det1, det2; - det1 = a * (e * i - h * f) - d * (b * i - c * h) + g * (b * f - c * e); - det2 = glm_mat3_det(mat); - test_rand_mat3(mat); + a = mat[0][0]; b = mat[0][1]; c = mat[0][2]; + d = mat[1][0]; e = mat[1][1]; f = mat[1][2]; + g = mat[2][0]; h = mat[2][1]; i = mat[2][2]; + + det1 = a * (e * i - h * f) - d * (b * i - c * h) + g * (b * f - c * e); + det2 = GLM(mat3_det)(mat); + ASSERT(glm_eq(det1, det2)) TEST_SUCCESS @@ -229,8 +231,8 @@ TEST_IMPL(GLM_PREFIX, mat3_inv) { test_rand_mat3(m2); /* test inverse precise */ - glmc_mat3_inv(m1, m2); - glmc_mat3_inv(m2, m3); + GLM(mat3_inv)(m1, m2); + GLM(mat3_inv)(m2, m3); ASSERTIFY(test_assert_mat3_eq(m1, m3)) } diff --git a/test/src/test_mat4.h b/test/src/test_mat4.h index 316e12a..e6aceff 100644 --- a/test/src/test_mat4.h +++ b/test/src/test_mat4.h @@ -220,7 +220,7 @@ TEST_IMPL(GLM_PREFIX, mat4_trace) { mat4 mat = A_MATRIX; float trace; - trace = glm_mat4_trace(mat); + trace = GLM(mat4_trace)(mat); ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3])) @@ -327,15 +327,36 @@ TEST_IMPL(GLM_PREFIX, mat4_scale) { } TEST_IMPL(GLM_PREFIX, mat4_det) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 mat = GLM_MAT4_IDENTITY_INIT; + float t[6]; + float a, b, c, d, + e, f, g, h, + i, j, k, l, + m, n, o, p; + float det1, det2; - test_rand_mat4(m1); + test_rand_mat4(mat); - /* test determinant */ - ASSERT(glm_mat4_det(m1) == glmc_mat4_det(m1)) -#if defined( __SSE2__ ) - ASSERT(glmc_mat4_det(m1) == glm_mat4_det_sse2(m1)) -#endif + a = mat[0][0]; b = mat[0][1]; c = mat[0][2]; d = mat[0][3]; + e = mat[1][0]; f = mat[1][1]; g = mat[1][2]; h = mat[1][3]; + i = mat[2][0]; j = mat[2][1]; k = mat[2][2]; l = mat[2][3]; + m = mat[3][0]; n = mat[3][1]; o = mat[3][2]; p = mat[3][3]; + + t[0] = k * p - o * l; + t[1] = j * p - n * l; + t[2] = j * o - n * k; + t[3] = i * p - m * l; + t[4] = i * o - m * k; + t[5] = i * n - m * j; + + det1 = a * (f * t[0] - g * t[1] + h * t[2]) + - b * (e * t[0] - g * t[3] + h * t[4]) + + c * (e * t[1] - f * t[3] + h * t[5]) + - d * (e * t[2] - f * t[4] + g * t[5]); + + det2 = GLM(mat4_det(mat)); + + ASSERT(glm_eq(det1, det2)) TEST_SUCCESS } diff --git a/test/src/tests-test_mat4.gcno b/test/src/tests-test_mat4.gcno new file mode 100644 index 0000000000000000000000000000000000000000..d58d103ca57c26e8a784b0d9657f55792bd47ed0 GIT binary patch literal 83560 zcmeHw37nlpm2X-WML`jeRUweD1xSEIKom(QgiUtYWHD(v4YWxop}P|nHx^e0aDYLF zK~^^mqU<07qJTIKtBimTpS}@BVaDAzZ^UKh{r^?pzrXLRoK&BR-6ZcN_4}QBZ`D2j zQ+2A&QdRf%?fLV%Pnodm&QsPtV4uZf#*FD$7Y{65Pi?r-8h9S;85o>-%G|!0eO-f7 zW-jcWzu?RGVu>=yLtHGejrEj|^;cJ1W5&$rSbOMojLKYUS`M>PLQ-9B#wNqQ?%-73cPthY$P<$D5es z7~0#!Nxk#B=PsPxGpQSIPZ}8PU)Vi3Y2w65m3f{59@?hnDOAIQ*A8bG*clxhtJd8! z4mwIN=zX9$pgzz%(0tGW&}pDX2|h`i`0nh}x96O=0$Rqz%8|(5-wXxnD8~aXk0oy2F{-XUVnnKCh1Cr+yEPJ^MApEfLcyH>WPc#giL@?9L9&SE!l~%kI}&d-)n|Pj;j>)>Ho@ zj{3!7pRKrmQk?PV`&IDYTuGE%<`wnrk&)s#2Kkc*e+&3;jh$DIGdeg1&51`wItJo3 z&mR13t^VV^4srJ`xaPBz)6O4f_4Lor=ZqOa-m3G2;(+Wr%^{rIW)7)yZ1gYY7OrJ1 zv5h?1GfD19o+tKIcj4Ken~2*FbRg)UfYpOPH(5CO5`BMZxx&K9e@b!kn;h<7sTQ82 ze&lB<#VOX7;^?0&r8wDS4tGctT|GwqJh{ojX@6AOAMKo_6er)v;SP(UtH-FH{49q% zyoDPR?p`>br|GHqt1(_r7e;Yw=$zJrI!2by7QPAU{CqPevo&xLm!g>7D!g>7D!g>7j)LJ>b^806R3m5&9`S`r)U8gPSpMx&{{ArN6{QdKJjN=8+ zzk+@adJ*&z=-)xV0R0m5D^R0^+{t~#H+NX)=S$|!-gyJK&{-4jFKu5tCkX587#p6K z_rtQE`L!q0d4)DF`(+#FhIQE{V|pyHPquTOVu}2$YY(hFwB)nCdBv?Z@@ns^HrBPT zRU7Ngv2m;%kM^VDV_o+IYNMXoN3xCMW}WxCEW8_tCF;d`I!^MwvEq_k*7><%EKx4& z8&oapSI^>SJ(Ww|`t$YJKkM~p=TR=}@iSn2eu~$zM1Iy&x#X=s$BlgYd{$V_!=@m9 zUdysse8OYoXFZim-nS%ttfzdeZ!yFdW0k5o-0O}7|J^1s0h4bWr z0d*CgV}G*MoURs5zLvv<&BIWi{ybpeNAvLJk+dV-I{V7wo?XNp@$*FO3WLFV$`N5715{1Nmg&|g6R1^RDL z2M)`x0<8vG9n>h{yON9}i*|c%KKESIzvr~L|6A&3S_=nz=i+OoA?Bk-5128B5WayH)Q=koH;P#v|0xKE?_T8-GodUGF4 zU0BzCMtMqmy^-4cYd@hpFZpcOoq!mgBlat70cB|9_2l?v96rP zHqI~W%2&!i;%9p*mpsZh;!F4bTo>Y$C$t|zQz$uGJV#97x&0l-;c({y^AXS|LFa=m z09^>GON^Vcv79^$Cp*mHE~-1jtJt4sUv1$$`|3{_{c(IOxp7)J`9ThMaTHxWM*ZX? zIh@s>{4IyO#OTknueRpXv#-9?=+CpSw(LdmDyQFNMt{r)ETuTc0hUsn;zi_5^Y9tD2KIhidCgJ#kNwMVqFe*#gJ}%5%p8t%;7%U!o|HA=jGPD_T8kl zH;XCUwKv-^B-N4MqtLdLud{oU>Te!41@qekhd1OyIGpfoJ|pTE$BMX=Rwzl7K3g8-3Y2nv{O$mv~ZqWXyH7$(876g;n!;A z@G9!Zxnjx9*-eo}kKwbh5HFrPVs7e(Fj1Eu9u^jB<@x^GG0^utGSD!S@w;cTFHg*{ z@Uk-x{y3w5*_#J%^)I{g;E!+hAJ1jXALB3Y_@x=|7Uk{omN1Vi?)RnTTbd)C2Uyo0 zO>N}W{!(pAJ739W#J9BbmG*P;^)Ov{$ocwhVhYdxyL#eo2i*m_J7D$TkE0e&_MIE^ zH`G;lj{V85OL1DOQXKhNN^x5A9Pa)gSr1V^`Ws6QXU(VQO!4g~x_XTL$zF5)JQJ@|c&xPJrvLeTK+&*v7-<8v0y<8v0y<8!|<^z-=K zuUoj7@Ax_W!UONQZb_e;?DDx!t{^^le&TcMLN9)o;Mgng`CpvV_UFK-E$kZ1``d4U zS&=^nmVL=SmHSxdIV_g=nJjr_SK?z`Hp4d6l_PcL6hGTjx#ZFQOnmA7o^rVt)BVKS zcpXa|8{1R4wiL zr?{BIy|#smpC4?FzV2K7jSCoOcs__(e3)}NnectJ+c?ls_}w|$hK8Cw8&u=C9sGBI z?gTYTI3w`;_Rns%+E29?BP9IhBicQ(Zw&+K?BKjEy~I4m_cd%l@w!RKk!yjysU%`=7+zYRtq-M#pGpu@eO z`#|3WeGBw$&;y`{K;Hp94EjgV_dvW$YTn~KiTd|JPl5g!^aIe-pl3kOf*K{*(^xd@ z_LK9caGXQuY0d}g*)dn&TevL9?CemS2CT3wyR9h~$u^s|R@-;n2R3c4`5rOaf5w6P z_PNTtvUAQ=+LrEf*;jL)D=hU;e*CNbp<0)Jz`9(~TJIShjN$TK&)R+#_$xtIgRTKx z3%U;UIZ$1qpSk>`8k>c8`N>l7)JyTiqu1v#{x5*O1iBvdWzb^K4WPP2y<{sMxhbCG z(tgl`{|frQ5%e|CO`w}Ww}4{I*2v;_TPTmkBlkAQxE*vS=q`{IE4hBP{Zev_%i1Th zMKM)==jogAtWm=6z-@_!5A1lz&5Akw^9Q>IdyvKE^n@`i_50jiC!gFquP6L~@w6a! zWRCoNa6hc!ddBfdFrP0#R5GmjIK1BSOTW39e#$(vsHc1K z%z5+s`?}`#p4Bsqj%3EFZybWx|3`b5O0UhJ*IN{r!<@zakD9XcUdh-T%v%W1kl~8U zm5i-`AD77BIm#8AD;aHkygwWd8H;vZd|%tP=bbWlxOJ~=`}9$=ZR#dd&CYQ(j`Yr+ zXRxh7`>npyE{yZ-`$OE>&l^}Uf1qdP;QajgXYEQqj$!y>@0YmF6jLu>+{dsk8_+sx z-@$g}H?@(6J{n8xi}jR`b>%kZg?j&z*L59Dc<8`?Z%^F1p!E_w`<2cd)6)K)-@<8L zN^zRUQk>>Bhugr=kNhk-+?!gs_}hfr0CU`XpSXg!p}l?EEc3ag+Hd_R$X<@Qr5eYN zF^-oKJ$Zk!E$I2L9(u0kr}ep6^ug@hZB*&EGWg%dt@&%8vo(L#Juz{cf!++-Jdxq` zK?~>cK?~>cK?~>c!Lf#ZoEw(h9BtXc#os*M4wy~fH+VezUD5}K+4od-|GOY}`TO7h z#yI|%=t%$D9<=tB?^#!KQ~TdQch}sWnG5i~-m`3LT%{k+OCw*FJzwf>R=JV3D!XGF z*R+{0b$2X&zAw8GKkLey^_@u^Birj36y>w7Ggy5-i~OwX9$0-2f4>m1^x5Xvs9XB^ z8QYrsKlMR9b>FQv)|H3V#`#Of$GYyIOZE-zzv1oa@iR$xd^)Nk)IN;ZmIJyA&t?D8=a>qZFsTZVqS7r~EyK z+u4{;&u3Ydy(k{#`rF0mPrjYQS^l7SnZr#s`csU^;ij~3F}F^DBTsw(5s$WVYn^gj zd)qZb&>H#NN}V)h`omK1k*Xa3YK-GGptV4+1-%Z`DB=5LeQPhf4GDGG<1HA>Bf~`Hwt-d zswUJk`OKq&De5@q&o}{E{O|sw4lHXr>30US~!if1jjt; z@#nc1R3B&o=rmA2s4g*{c>LSKHP>xvpFdeR>dBJR*TQMtbGQLRKiNhOXRV88&$!U& zPd1k8Z&3>u=y=7B0rJT`?zDY`EEu znwR>sG5Y$+T?05|=soMRF@3K~=ixBP?uVG~$zBgFwy`c7<(`7;&bo4`=1Kbvwkto1 zpY^7_po$XZvt4thHtMPMRvYVDOSO&mp5=miGSIu<&n=whFt>&&&gx`<4rXF)jbQl22hAm&&lA4@&rs>J+>RIRHgI~^ zf|=d(=jQF=@-S~J-e(ZaxW+g~(tVj?QZv@6jcd)hh$Y5Q)@AFmUGcL$l}jGks`yx! z9kNZaROhog7sOc0_Eau;bQdbQtm~dra#`0MCgV~pQ7+q4x#ZCuq~x-m^0B@wpY!wY z7V6^v3_^eJa3%0pfv!p9a6V+xvR^CTS~%szQk?9n6z7S}*Bbhw(it^<88jA>|=LXO=H z)j!?%;$E7gB**s8KRxf?*N4G$cI-1GcGZh|24Y@gU2CQs#(KRR^?67!Tsc7etWTq$ zP@>$DJ%VDVVz1<~p2{uRBPeDm=1DH=sa*0ZR*7$Edj!P_#TxOmp33#?5$MZ|2l~!u zy;q2H$$Bc6y!v}`_0PKgR-A2=%Q}CfjivrAjVPD(R4#e>TW7IEKGykLQ?W$3tn;^U zSon8hu|$5>Q@P~T|Eke=S?6bGu|&D7kF8qj|ECt^vYyH%@0Jz6x`uM7C zT;o03F6*gW@@}2*vA#{CjdEGvu4>!1@gC)}p2{Wf_6Z;B6B=!l%leL0+YXKQD3|qA zE_ruK_*kFVXro-#cdptdHQu9K)>FCU-6i2;eb+`C<+9E*5ev_MvBY&_J(Wvd=CW8K zAM1?yu|#`deUGYT_v%^e%z7%9yl+eRSl_eJ#__WLj;ihLjrTYYtfz9xyH~=;`a2tK zl*{_ms%`J;S>t6rl}p~vgpc)zUA#OJG^PC|pobqXI zoEA>`xD==;t{@SUBbN(*CqBD8+fs5VsoodCm|PPWy}8I4zv^C#5*;Q*yZ5 z4E?m1DaC1@Q;O3*sT8OEQVz%89H>i-pW0KE;bXWr*l>*PUo#0?p{MboykgZID-sY-Dl{h zvtcPt=f+ap)GEN0;yN9;`wjhcM$Ps2trjlcVbeYz{@IaN@mx0a`EaU8H?V}$ zZkgXt`t2=yYhL*IU3d6_)|m^t=Px*ujC#+yyNvffqxUyO@+K0j zD8WCuAAZ-2cVDIc8~)ilyJy~D@8Fr)v5gA?JHsBPA$u8LMn5B1u}6N!dL3Tko`H4Q zsBBLBY_I*v@4xbA`LFVb)DG?ZgVeEuYDXF_b91c^61`M{j;9(v99~-l6W&7 zxVre`4RKq8wgXM51>lwcGa(D7wUjMd`M|PLQ-Qk-n66ek-j z#d-EJJ4RKi$EY9elqJ`nh0{K}6enLO#mP5vxQS7f>M`mk|HcDMv}TF{slO|pC~qhah<|zPiS}*TfZRD1vtJA6 zi6a)y6GtqZCypF!=tsR+a{5^~PaLsuo;YIRWRtmZ9uifl9{q8|!pXKv`=iaUl;YNj zuq^JdiYGor{XBc3!&|s`zr&pJ()@vqHO|KQaY1kQoRF6Fp0%HUcaXVq-0vLOnm_;d z@Q6DKbTsH#&~c!;#P##U7YpZ!FBZ-dUo4y_zMN1ihgVTQ+7L_5mQIW;dJOj)Q&HPy z*B!quTxy?#cwg^X_Bk_1TRH4=R?t-se)}Y@3v?1_Ht1wfUHtZG;XL+f;XL+f;XL+v zYONez`R%i}g^T;lPP84l!|8qOH`!TJvXg!TrKo9x#*0qn^sM zY~#3D*LOziJG?lTtf%87FYozdiF~Z!Fno}y!G9Bl*@X3Zyv|X zdc6C#|CS_`OWykaI?C0(G~PmqayP{*-cz&ayNwzz>#1Dw>N|T)E}^V@W(+5=ZS*@>MA_P{$#5;T`in^Er(<7tcyPmS~$-+ zz`}XX0Txcap3`q(tsGuO{dE78!&&pGn3cmVGWt_o$>A(}QB2L@&M^8@d@98$c9r53 z`$}<&fjJ!SVe1mtk8zQu6vvp!Qi|Ik!isT<#ku~@s$|EfsGs6>DbDkKd8uJF76|zp{?`(Jh}$scCwG` zTZp8TlXrHI*V&=94AoJ4h$_im{5B8WY>)_i8KICn~lnR!IiiQ@P|(Y!Y9(Pvp7~ra<|Cj_g3bqB0J;!Vm*``%v79^$Cp*mHE~-1jtJt4x zv=ryrgMG^AkNvRZ`m=EIgBu7B56Q0WRYBg$aaVawYwqIzfcE4G;;sc< z2l_nddeCCf4WJuAb&2cf$rTpPlPfHoCs$ZFPp$wlkym+BZA;rX%9g~pw0)!Ul-4Lr7anqJ zbeovMv;V$|xZ6Q@f$k1iJ^1b4!g=if8|o@N$NoI_Z{f67xjC|MTI*7r);x#1-_Xyq zSF+~Qvse1I(Vy%!H_iuIxcIs547AH=g$S1qqpZ&K9HR$ zce2iL#S-sf$SeC0AL}U}>snXYW0aHE^+#d~&;I|_PTWsG|B~Q&uGF3&H^&xE^HGY^ ze3s%guQ}ZFhJNH{$>CmzEP4#z+t?4axexDoo^YvMG6Cs5%PxNwq^%rw`E$)&c=p>R zasLMTMS}O*rG@j@rG@j@rG@j@<*y9=Xge%98~Sx*(PKFG?2p?2IH~LR>^He*KW$;x zU{>C5gQOMro?UC8HB<~`UH2JkBd_LOZLDiv*`~T;t#YFH*`CTJk8+^+(mfRAGT-T( zM0<@T<^i^+a>=t!#U;6{>#j}XWnK4Z>n8kcPvw&5jR_y?y5Evq)^&HKyC{u=?WtVy z=^Xg_A9p;$+h~-0FsYvink;e4`X6Un<4Pw{o~O4E;R&OA99-E$vS}U5b;B=WuHp z`Y8^S;uI@Naf&UaIK`SA?$w5Vibth5#jH}CVq7VXafl^{Tg%W-aWRK`Z3`EFhvoqE z^}T!V-EKhQICF#q>HYX`Zbx7Sn*R7_JoU_14V<&`-Dt<#!A|6Y^0 zbwTSTc>1{~H&{5$OK#0AoaV6<=gAEl82V|Aa{axjg^RX%Am-+qea9Y{vrVpjPVPoQ z?#f}C8@J}re+N$7W}r8NHcw=D?bE_}?9;+|?9;+|>~pN4pT|D8Y~kYF(Ys)K+g!cd zv$DU&89n?*?3oMlwmB}yT=D+@k#cM^&T38A#(8F4^Q}FA_}Q*G6+i3R>uHZ7ezt2r zCw|to=hB`{{H!aVtF3t+QXBVP+DEC4_2$@Uqv<(_ZQKtvb!Hp&)V@XXSXca3TYCN> zwt4>1nE=h9$bPJQobfHY^WS+Bw>4-x&;-zqpt|_)ye%B{VabhqC!;^jXDLp0mcvan z`XfI}DNc5p!%Z^!lMR>RWZ$JY`9~?vb0)F$lP~4^v(`cWp2O{I%%|r}V%eGEQLevT zjQ-@?Ih^GWikCUuWTQXDupDkm3m5awL9pq=w_H43xHRt!XY;!SnXB^7s=TxGzyI02 zWq1C(L);#qw}bWq?G37nKkryLPu`ho^ykSt7S5A*I*tD5mn`y6E3aEPPu`hk^ykSt z7S5A*ESx9rSU6AKv2dQeW6h^0?@Tx5)01~Bd-3F*eT@D*dB^exPu|(r=+BdP_G{td zcQX%$P0yLJ`z`c~^5hK}Ud&1RVuB8gvZkSkQYw$AeA)od|kwRiB0DlR$Ox z$6O1i`OJ;m!f8E9aaxxgZnmKx`B`$fo)#|J^dZ2^eAn+^G;A9GtvN66lpt@#{f<|2 zF2m&D?9TOMyJEQPpYvARdgM#@N5nGMq~~4ckyIY*iuWbHGpDsi(RS68TU!gKahBj1 zi#;|!7lY~pEdZSc>Ic;&j@#n{7OuH&jI-AM!NO5bmYlv8PV1h-4H)`)_8r!`c=jC& zjs9d~xp6LP;o?2=p_r3>cX;$8)HBIj{EzGl`g^*22YT}Jc1Do9%GXEI*FVr&E5EN> zIFGNVIIpjN5aaw1=xoqApmRZW@%y@k^Z2@j^Z2@j^Z5FChJGGjPv@8Wc8{-r)acLS z>mO_3;@!w$=yUH&UcOW@qH#AuUq88PApaeuPXw8({Cp(+{DRgx`Tg9&dHg)ZdHwuC zjPoMU#h^<-mxAiz_j3#9@pB93@pB93@$vyMv#^bFS=Sv3eKwYO7GZlTmpr-ykzCeOKGyX;o|3c3 zKeX)5e+Nq36`(6YSAnhp)g{IePaLywp0kOClU?O}!oqpt*0qLy?1v@SpM{gXmf~dJ zr8wDp4tJfQpC@ivIGu@0`;(uQ;^cQZ+~*AaCJD_6gpx>Y+UYG1jxKp8D9vx?-mC1?!4y zii^qvtWN{Q5@nR+O~n(%Bgthwm0OZG<;RKxlFNE3w9X%X%u;lQ$Xn=_C3c zYn?yiT(X|Z^?YZaa`|1=jX^B+clV=Q)>FCU-Gt1cL_XH_TUgYUa#??K;IV&0F_lYR z{Z5tUEBy^c%H{q2SP)D7TZ(ZUtfz9vqHRl1ERm1(t<+SFm-X>g+qlMiv|ZLyx#ZnC z;bVQ9MjOY=`gT>@wvG2Fm-SRGdACpaSf9{nqg>W^tlD;HyhpjLr*g@=Q^Lpk#6}zC zvc7ZGHmUI*<+7g2CGRc?AM3j|+9;RxDOKC##(R{@dMcN^Z%z1E->uO`xvcL|we8+` zk8)X0<&yVp2_NfwHrgnc^>RI;AdMcN^ zoe3Z7DIe?8hxp>YR@Gb%{Bno5`0U?T6So-j70`{KuYu~~-&b2W&M`}F+!jvxrxeF^ zVaefcGV~)qODRrytQ4m_Sc>!Pt8X^+^X#iFobqXIoEA>`xD@BvSKngj=h;_VIOX-+ zI4zv^1*JI8zWP=}KkgY=a{XC2?Jr7k+Mkr-Jb!0%o1q`~E-bnJES&Z^r8w=AN^#mR z<#4wf`e{#9irXwsOLktY{_FvXS0&e-X3hNk^gU5iF*k2JMpV~e76?tjS~Hh4RzPCjdj@~{X+It zgJ*Q`EGC?19L&wkv$}6&PGWxP1Tik|2ihNW2j}`bcZdL zrT1X}!tTLI6DLk06YOAK5H|99^G+qFcRG&w;9meb4b%@B05wX`^B6Rox$(ExZRi=c zpu_1o8G4=t1)Tu?f1JEQYmHLxH!?xED= znVZRAo+3a)hV=Bv*d6#i5*fS$*Bp3cwDIwK7>w-~9dOG|l+#*&)IBnv1|Kq`k$3I2 zrq0c^URutkZYB2p42Myd@Y|ovSwFp?e^yJk@L$(`x-njihHj-c$e48vhf-2xUrC<2P6rX_amX!b z&+1m?>_>vQ<+yIuI35k-7bAJ|61O*sM#2 z^jUOj*X-E?;XBK>?Dk%TMHeP4EyjNyuR>&Lw>})9rq|h`pxYLM@5g0b4N)>_dcc4 zu`kh&ws11&ZB`Ww&%)$@gTz6iu;w*M{Y zV$dbkGwYXvE(38Nz&sr9e()leFwgJ9>)$-I#-Xiw=3kT++!Jp)O7ZRhjICszw*>Q6 zpmCt_plv|gg7{m3+k+;6_?>9dM`diS&pi4lF5@I{;?5D@i*`yWQ_1D1#_uQj(&MsZgFF>C!g1!X09<&&A z1L!ND8$n+M-3Gb?bSLO8(0!l>LEiyA40;sw6zGSb=RiLK{ZG)3LH`Q+8R+NLGwUyc zehvB!=(p7~>%RlN4EiJJPt`N)e+I3FwOAdrM)l14nxM5nuLZphv<~R?pf`Zl1+52K zAG87JO`r`yjS|i@j2U}w^{c~I$8&WTG-YP@`~_#CZpFW$JJ#wf!MHFQ@z1@Ftj56@ z#Te8mLBBpUyfE!U_q6nLp0)Y81lMyk^mFeaEB$CsjS|i{jPpO){iWA%FA&abm0qt# zJ$J@o+#U^`)`3)+*l=TD9%+=I&wMnTH0Q|r47vyk4aC30&FMqj^45pBH7)-axQ=f~ literal 0 HcmV?d00001 From ba694f4aecabde7d99ef3e42b6b66a8d317138fb Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 19 Sep 2019 16:12:27 +0300 Subject: [PATCH 026/103] tests: add some tests for vec3 --- test/include/common.h | 11 +- test/src/test_vec3.c | 112 +------ test/src/test_vec3.h | 581 ++++++++++++++++++++++++++++++++++ test/src/tests-test_mat4.gcno | Bin 83560 -> 0 bytes test/tests.h | 152 ++++++++- 5 files changed, 749 insertions(+), 107 deletions(-) create mode 100644 test/src/test_vec3.h delete mode 100644 test/src/tests-test_mat4.gcno diff --git a/test/include/common.h b/test/include/common.h index d3d03a9..ac7059a 100644 --- a/test/include/common.h +++ b/test/include/common.h @@ -10,6 +10,7 @@ #include #include +#include #include #include @@ -102,13 +103,13 @@ typedef struct test_entry_t { } while(0); #if defined(_WIN32) -# define drand48() ((float)(rand() / (RAND_MAX + 1.0))) -# define OK_TEXT "ok:" -# define FAIL_TEXT "fail:" +# define drand48() ((float)(rand() / (RAND_MAX + 1.0))) +# define OK_TEXT "ok:" +# define FAIL_TEXT "fail:" # define FINAL_TEXT "^_^" #else -# define OK_TEXT "✔︎" -# define FAIL_TEXT "𐄂" +# define OK_TEXT "✔︎" +# define FAIL_TEXT "𐄂" # define FINAL_TEXT "🎉" #endif diff --git a/test/src/test_vec3.c b/test/src/test_vec3.c index 5db3b32..318d306 100644 --- a/test/src/test_vec3.c +++ b/test/src/test_vec3.c @@ -5,110 +5,22 @@ * Full license can be found in the LICENSE file */ -#include "test_common.h" +/* test inline mat3 */ -TEST_IMPL(vec3) { - mat3 rot1m3; - mat4 rot1; - vec3 v, v1, v2; - vec3s vs1, vs2, vs3, vs4; +#define GLM_PREFIX glm_ +#define GLM(X) (glm_ ## X) - /* test zero */ - glm_vec3_zero(v); - ASSERTIFY(test_assert_vec3_eq(GLM_VEC3_ZERO, v)) +#include "test_vec3.h" - /* test one */ - glm_vec3_one(v); - ASSERTIFY(test_assert_vec3_eq(GLM_VEC3_ONE, v)) +#undef GLM +#undef GLM_PREFIX - /* adds, subs, div, divs, mul */ - glm_vec3_add(v, GLM_VEC3_ONE, v); - ASSERT(glmc_vec3_eq_eps(v, 2)) +/* test pre-compiled mat3 */ - glm_vec3_adds(v, 10, v); - ASSERT(glmc_vec3_eq_eps(v, 12)) +#define GLM_PREFIX glmc_ +#define GLM(X) (glmc_ ## X) - glm_vec3_sub(v, GLM_VEC3_ONE, v); - ASSERT(glmc_vec3_eq_eps(v, 11)) +#include "test_vec3.h" - glm_vec3_subs(v, 1, v); - ASSERT(glmc_vec3_eq_eps(v, 10)) - - glm_vec3_broadcast(2, v1); - glm_vec3_div(v, v1, v); - ASSERT(glmc_vec3_eq_eps(v, 5)) - - glm_vec3_divs(v, 0.5, v); - ASSERT(glmc_vec3_eq_eps(v, 10)) - - glm_vec3_mul(v, v1, v); - ASSERT(glmc_vec3_eq_eps(v, 20)) - - glm_vec3_scale(v, 0.5, v); - ASSERT(glmc_vec3_eq_eps(v, 10)) - - glm_vec3_normalize_to(v, v1); - glm_vec3_scale(v1, 0.8f, v1); - glm_vec3_scale_as(v, 0.8f, v); - ASSERTIFY(test_assert_vec3_eq(v1, v)) - - /* addadd, subadd, muladd */ - glm_vec3_one(v); - - glm_vec3_addadd(GLM_VEC3_ONE, GLM_VEC3_ONE, v); - ASSERT(glmc_vec3_eq_eps(v, 3)) - - glm_vec3_subadd(GLM_VEC3_ONE, GLM_VEC3_ZERO, v); - ASSERT(glmc_vec3_eq_eps(v, 4)) - - glm_vec3_broadcast(2, v1); - glm_vec3_broadcast(3, v2); - glm_vec3_muladd(v1, v2, v); - ASSERT(glmc_vec3_eq_eps(v, 10)) - - /* rotate */ - glm_vec3_copy(GLM_YUP, v); - glm_rotate_make(rot1, glm_rad(90), GLM_XUP); - glm_vec3_rotate_m4(rot1, v, v1); - glm_mat4_pick3(rot1, rot1m3); - glm_vec3_rotate_m3(rot1m3, v, v2); - - ASSERTIFY(test_assert_vec3_eq(v1, v2)) - ASSERTIFY(test_assert_vec3_eq(v1, GLM_ZUP)) - - /* structs */ - vs1 = test_rand_vec3s(); - vs2 = test_rand_vec3s(); - - vs3 = glms_vec3_add(vs1, vs2); - vs4 = glms_vec3_maxv(vs1, vs3); - ASSERTIFY(test_assert_vec3s_eq(vs3, vs4)) - - /* swizzle */ - - /* ZYX */ - v1[0] = 1; - v1[1] = 2; - v1[2] = 3; - glm_vec3_swizzle(v1, GLM_ZYX, v1); - ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 2, 1})) - - glm_vec3_swizzle(v1, GLM_XXX, v1); - ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 3, 3})) - - v1[0] = 1; - v1[1] = 2; - v1[2] = 3; - - glm_vec3_swizzle(v1, GLM_YYY, v1); - ASSERTIFY(test_assert_vec3_eq(v1, (vec3){2, 2, 2})) - - v1[0] = 1; - v1[1] = 2; - v1[2] = 3; - - glm_vec3_swizzle(v1, GLM_ZZZ, v1); - ASSERTIFY(test_assert_vec3_eq(v1, (vec3){3, 3, 3})) - - TEST_SUCCESS -} +#undef GLM +#undef GLM_PREFIX diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h new file mode 100644 index 0000000..ff60497 --- /dev/null +++ b/test/src/test_vec3.h @@ -0,0 +1,581 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +#define TEST_GLM_SHUFFLE3(z, y, x) (((z) << 4) | ((y) << 2) | (x)) + +#ifndef CGLM_TEST_VEC3_ONCE +#define CGLM_TEST_VEC3_ONCE + +/* Macros */ + +TEST_IMPL(MACRO_GLM_VEC3_ONE_INIT) { + vec3 v = GLM_VEC3_ONE_INIT; + + ASSERT(glm_eq(v[0], 1.0f)) + ASSERT(glm_eq(v[1], 1.0f)) + ASSERT(glm_eq(v[2], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_VEC3_ZERO_INIT) { + vec3 v = GLM_VEC3_ZERO_INIT; + + ASSERT(glm_eq(v[0], 0.0f)) + ASSERT(glm_eq(v[1], 0.0f)) + ASSERT(glm_eq(v[2], 0.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_VEC3_ONE) { + vec3 v = GLM_VEC3_ONE; + + ASSERT(glm_eq(v[0], 1.0f)) + ASSERT(glm_eq(v[1], 1.0f)) + ASSERT(glm_eq(v[2], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_VEC3_ZERO) { + vec3 v = GLM_VEC3_ZERO; + + ASSERT(glm_eq(v[0], 0.0f)) + ASSERT(glm_eq(v[1], 0.0f)) + ASSERT(glm_eq(v[2], 0.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_YUP) { + vec3 v = GLM_YUP; + + ASSERT(glm_eq(v[0], 0.0f)) + ASSERT(glm_eq(v[1], 1.0f)) + ASSERT(glm_eq(v[2], 0.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_ZUP) { + vec3 v = GLM_ZUP; + + ASSERT(glm_eq(v[0], 0.0f)) + ASSERT(glm_eq(v[1], 0.0f)) + ASSERT(glm_eq(v[2], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_XUP) { + vec3 v = GLM_XUP; + + ASSERT(glm_eq(v[0], 1.0f)) + ASSERT(glm_eq(v[1], 0.0f)) + ASSERT(glm_eq(v[2], 0.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_SHUFFLE3) { + ASSERT(TEST_GLM_SHUFFLE3(1, 0, 0) == GLM_SHUFFLE3(1, 0, 0)) + ASSERT(TEST_GLM_SHUFFLE3(0, 1, 0) == GLM_SHUFFLE3(0, 1, 0)) + ASSERT(TEST_GLM_SHUFFLE3(0, 0, 1) == GLM_SHUFFLE3(0, 0, 1)) + ASSERT(TEST_GLM_SHUFFLE3(1, 0, 0) == GLM_SHUFFLE3(1, 0, 0)) + ASSERT(TEST_GLM_SHUFFLE3(1, 0, 1) == GLM_SHUFFLE3(1, 0, 1)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_XXX) { + ASSERT(TEST_GLM_SHUFFLE3(0, 0, 0) == GLM_XXX) + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_YYY) { + ASSERT(TEST_GLM_SHUFFLE3(1, 1, 1) == GLM_YYY) + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_ZZZ) { + ASSERT(TEST_GLM_SHUFFLE3(2, 2, 2) == GLM_ZZZ) + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_ZYX) { + ASSERT(TEST_GLM_SHUFFLE3(0, 1, 2) == GLM_ZYX) + TEST_SUCCESS +} + +/* Deprecated */ + +TEST_IMPL(MACRO_glm_vec3_dup) { + vec3 v1 = {13.0f, 12.0f, 11.0f}, v2; + + glm_vec3_dup(v1, v2); + + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec3_flipsign) { + vec3 v1 = {13.0f, -12.0f, 11.0f}, + v2 = {-13.0f, 12.0f, -11.0f}; + + glm_vec3_flipsign(v1); + + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec3_flipsign_to) { + vec3 v1 = {13.0f, -12.0f, 11.0f}, + v2 = {-13.0f, 12.0f, -11.0f}, + v3; + + glm_vec3_flipsign_to(v1, v3); + + ASSERTIFY(test_assert_vec3_eq(v2, v3)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec3_inv) { + vec3 v1 = {13.0f, -12.0f, 11.0f}, + v2 = {-13.0f, 12.0f, -11.0f}; + + glm_vec3_inv(v1); + + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec3_inv_to) { + vec3 v1 = {13.0f, -12.0f, 11.0f}, + v2 = {-13.0f, 12.0f, -11.0f}, + v3; + + glm_vec3_inv_to(v1, v3); + + ASSERTIFY(test_assert_vec3_eq(v2, v3)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec3_mulv) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3; + + glm_vec3_mulv(v1, v2, v3); + + ASSERT(glm_eq(v1[0] * v2[0], v3[0])) + ASSERT(glm_eq(v1[1] * v2[1], v3[1])) + ASSERT(glm_eq(v1[2] * v2[2], v3[2])) + + TEST_SUCCESS +} + +#endif /* CGLM_TEST_VEC3_ONCE */ + +/* --- */ + +TEST_IMPL(GLM_PREFIX, vec3) { + vec4 v4 = {10.0f, 9.0f, 8.0f, 7.0f}; + vec3 v3; + + GLM(vec3)(v4, v3); + + ASSERT(glm_eq(v3[0], v4[0])) + ASSERT(glm_eq(v3[1], v4[1])) + ASSERT(glm_eq(v3[2], v4[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_copy) { + vec3 v1 = {10.0f, 9.0f, 8.0f}; + vec3 v2 = {1.0f, 2.0f, 3.0f}; + + GLM(vec3_copy)(v1, v2); + + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_zero) { + vec3 v1 = {10.0f, 9.0f, 8.0f}; + vec3 v2 = {1.0f, 2.0f, 3.0f}; + + GLM(vec3_zero)(v1); + GLM(vec3_zero)(v2); + + ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO)) + ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_one) { + vec3 v1 = {10.0f, 9.0f, 8.0f}; + vec3 v2 = {1.0f, 2.0f, 3.0f}; + + GLM(vec3_one)(v1); + GLM(vec3_one)(v2); + + ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ONE)) + ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ONE)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_dot) { + vec3 a = {10.0f, 9.0f, 8.0f}; + vec3 b = {1.0f, 2.0f, 3.0f}; + float dot1, dot2; + + dot1 = GLM(vec3_dot)(a, b); + dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; + + ASSERT(glm_eq(dot1, dot2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_norm2) { + vec3 a = {10.0f, 9.0f, 8.0f}; + float n1, n2; + + n1 = GLM(vec3_norm2)(a); + n2 = a[0] * a[0] + a[1] * a[1] + a[2] * a[2]; + + ASSERT(glm_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_norm) { + vec3 a = {10.0f, 9.0f, 8.0f}; + float n1, n2; + + n1 = GLM(vec3_norm)(a); + n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]); + + ASSERT(glm_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_norm_one) { + vec3 a = {-10.0f, 9.0f, -8.0f}; + float n1, n2; + + n1 = GLM(vec3_norm_one)(a); + n2 = fabsf(a[0]) + fabsf(a[1]) + fabsf(a[2]); + + ASSERT(glm_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_norm_inf) { + vec3 a = {-10.0f, 9.0f, -8.0f}; + float n1, n2; + + n1 = GLM(vec3_norm_inf)(a); + n2 = fabsf(a[0]); + + if (fabsf(a[0]) < fabsf(a[1])) + n2 = fabsf(a[1]); + + if (fabsf(a[1]) < fabsf(a[2])) + n2 = fabsf(a[2]); + + ASSERT(glm_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_add) { + vec4 a = {-10.0f, 9.0f, -8.0f}; + vec4 b = {12.0f, 19.0f, -18.0f}; + vec4 c, d; + + c[0] = a[0] + b[0]; + c[1] = a[1] + b[1]; + c[2] = a[2] + b[2]; + + GLM(vec3_add)(a, b, d); + + ASSERTIFY(test_assert_vec3_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_adds) { + vec4 a = {-10.0f, 9.0f, -8.0f}; + vec4 c, d; + float s = 7.0f; + + c[0] = a[0] + s; + c[1] = a[1] + s; + c[2] = a[2] + s; + + GLM(vec3_adds)(a, s, d); + + ASSERTIFY(test_assert_vec3_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_sub) { + vec4 a = {-10.0f, 9.0f, -8.0f}; + vec4 b = {12.0f, 19.0f, -18.0f}; + vec4 c, d; + + c[0] = a[0] - b[0]; + c[1] = a[1] - b[1]; + c[2] = a[2] - b[2]; + + GLM(vec3_sub)(a, b, d); + + ASSERTIFY(test_assert_vec3_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_subs) { + vec4 a = {-10.0f, 9.0f, -8.0f}; + vec4 c, d; + float s = 7.0f; + + c[0] = a[0] - s; + c[1] = a[1] - s; + c[2] = a[2] - s; + + GLM(vec3_subs)(a, s, d); + + ASSERTIFY(test_assert_vec3_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_mul) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3; + + GLM(vec3_mul)(v1, v2, v3); + + ASSERT(glm_eq(v1[0] * v2[0], v3[0])) + ASSERT(glm_eq(v1[1] * v2[1], v3[1])) + ASSERT(glm_eq(v1[2] * v2[2], v3[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_scale) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2; + float s = 7.0f; + + GLM(vec3_scale)(v1, s, v2); + + ASSERT(glm_eq(v1[0] * s, v2[0])) + ASSERT(glm_eq(v1[1] * s, v2[1])) + ASSERT(glm_eq(v1[2] * s, v2[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_scale_as) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2; + float s = 7.0f; + float norm; + + GLM(vec3_scale_as)(v1, s, v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); + if (norm == 0.0f) { + ASSERT(glm_eq(v1[0], 0.0f)) + ASSERT(glm_eq(v1[1], 0.0f)) + ASSERT(glm_eq(v1[2], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(glm_eq(v1[0] * norm, v2[0])) + ASSERT(glm_eq(v1[1] * norm, v2[1])) + ASSERT(glm_eq(v1[2] * norm, v2[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_div) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3; + + GLM(vec3_div)(v1, v2, v3); + + ASSERT(glm_eq(v1[0] / v2[0], v3[0])) + ASSERT(glm_eq(v1[1] / v2[1], v3[1])) + ASSERT(glm_eq(v1[2] / v2[2], v3[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_divs) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2; + float s = 7.0f; + + GLM(vec3_divs)(v1, s, v2); + + ASSERT(glm_eq(v1[0] / s, v2[0])) + ASSERT(glm_eq(v1[1] / s, v2[1])) + ASSERT(glm_eq(v1[2] / s, v2[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_addadd) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3 = {1.0f, 2.0f, 3.0f}, + v4 = {1.0f, 2.0f, 3.0f}; + + GLM(vec3_addadd)(v1, v2, v4); + + ASSERT(glm_eq(v3[0] + v1[0] + v2[0], v4[0])) + ASSERT(glm_eq(v3[1] + v1[1] + v2[1], v4[1])) + ASSERT(glm_eq(v3[2] + v1[2] + v2[2], v4[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_subadd) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3 = {1.0f, 2.0f, 3.0f}, + v4 = {1.0f, 2.0f, 3.0f}; + + GLM(vec3_subadd)(v1, v2, v4); + + ASSERT(glm_eq(v3[0] + v1[0] - v2[0], v4[0])) + ASSERT(glm_eq(v3[1] + v1[1] - v2[1], v4[1])) + ASSERT(glm_eq(v3[2] + v1[2] - v2[2], v4[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_muladd) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3 = {1.0f, 2.0f, 3.0f}, + v4 = {1.0f, 2.0f, 3.0f}; + + GLM(vec3_muladd)(v1, v2, v4); + + ASSERT(glm_eq(v3[0] + v1[0] * v2[0], v4[0])) + ASSERT(glm_eq(v3[1] + v1[1] * v2[1], v4[1])) + ASSERT(glm_eq(v3[2] + v1[2] * v2[2], v4[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_muladds) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {1.0f, 2.0f, 3.0f}, + v3 = {1.0f, 2.0f, 3.0f}; + float s = 9.0f; + + GLM(vec3_muladds)(v1, s, v3); + + ASSERT(glm_eq(v2[0] + v1[0] * s, v3[0])) + ASSERT(glm_eq(v2[1] + v1[1] * s, v3[1])) + ASSERT(glm_eq(v2[2] + v1[2] * s, v3[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_maxadd) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3 = {1.0f, 2.0f, 3.0f}, + v4 = {1.0f, 2.0f, 3.0f}; + + GLM(vec3_maxadd)(v1, v2, v4); + + ASSERT(glm_eq(v3[0] + glm_max(v1[0], v2[0]), v4[0])) + ASSERT(glm_eq(v3[1] + glm_max(v1[1], v2[1]), v4[1])) + ASSERT(glm_eq(v3[2] + glm_max(v1[2], v2[2]), v4[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_minadd) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3 = {1.0f, 2.0f, 3.0f}, + v4 = {1.0f, 2.0f, 3.0f}; + + GLM(vec3_minadd)(v1, v2, v4); + + ASSERT(glm_eq(v3[0] + glm_min(v1[0], v2[0]), v4[0])) + ASSERT(glm_eq(v3[1] + glm_min(v1[1], v2[1]), v4[1])) + ASSERT(glm_eq(v3[2] + glm_min(v1[2], v2[2]), v4[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_negate_to) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3, v4; + + GLM(vec3_negate_to)(v1, v3); + GLM(vec3_negate_to)(v2, v4); + + ASSERT(glm_eq(-v1[0], v3[0])) + ASSERT(glm_eq(-v1[1], v3[1])) + ASSERT(glm_eq(-v1[2], v3[2])) + + ASSERT(glm_eq(-v2[0], v4[0])) + ASSERT(glm_eq(-v2[1], v4[1])) + ASSERT(glm_eq(-v2[2], v4[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_negate) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f}, + v3 = {2.0f, -3.0f, 4.0f}, + v4 = {-3.0f, 4.0f, -5.0f}; + + GLM(vec3_negate)(v1); + GLM(vec3_negate)(v2); + + ASSERT(glm_eq(-v1[0], v3[0])) + ASSERT(glm_eq(-v1[1], v3[1])) + ASSERT(glm_eq(-v1[2], v3[2])) + + ASSERT(glm_eq(-v2[0], v4[0])) + ASSERT(glm_eq(-v2[1], v4[1])) + ASSERT(glm_eq(-v2[2], v4[2])) + + TEST_SUCCESS +} + diff --git a/test/src/tests-test_mat4.gcno b/test/src/tests-test_mat4.gcno deleted file mode 100644 index d58d103ca57c26e8a784b0d9657f55792bd47ed0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 83560 zcmeHw37nlpm2X-WML`jeRUweD1xSEIKom(QgiUtYWHD(v4YWxop}P|nHx^e0aDYLF zK~^^mqU<07qJTIKtBimTpS}@BVaDAzZ^UKh{r^?pzrXLRoK&BR-6ZcN_4}QBZ`D2j zQ+2A&QdRf%?fLV%Pnodm&QsPtV4uZf#*FD$7Y{65Pi?r-8h9S;85o>-%G|!0eO-f7 zW-jcWzu?RGVu>=yLtHGejrEj|^;cJ1W5&$rSbOMojLKYUS`M>PLQ-9B#wNqQ?%-73cPthY$P<$D5es z7~0#!Nxk#B=PsPxGpQSIPZ}8PU)Vi3Y2w65m3f{59@?hnDOAIQ*A8bG*clxhtJd8! z4mwIN=zX9$pgzz%(0tGW&}pDX2|h`i`0nh}x96O=0$Rqz%8|(5-wXxnD8~aXk0oy2F{-XUVnnKCh1Cr+yEPJ^MApEfLcyH>WPc#giL@?9L9&SE!l~%kI}&d-)n|Pj;j>)>Ho@ zj{3!7pRKrmQk?PV`&IDYTuGE%<`wnrk&)s#2Kkc*e+&3;jh$DIGdeg1&51`wItJo3 z&mR13t^VV^4srJ`xaPBz)6O4f_4Lor=ZqOa-m3G2;(+Wr%^{rIW)7)yZ1gYY7OrJ1 zv5h?1GfD19o+tKIcj4Ken~2*FbRg)UfYpOPH(5CO5`BMZxx&K9e@b!kn;h<7sTQ82 ze&lB<#VOX7;^?0&r8wDS4tGctT|GwqJh{ojX@6AOAMKo_6er)v;SP(UtH-FH{49q% zyoDPR?p`>br|GHqt1(_r7e;Yw=$zJrI!2by7QPAU{CqPevo&xLm!g>7D!g>7D!g>7j)LJ>b^806R3m5&9`S`r)U8gPSpMx&{{ArN6{QdKJjN=8+ zzk+@adJ*&z=-)xV0R0m5D^R0^+{t~#H+NX)=S$|!-gyJK&{-4jFKu5tCkX587#p6K z_rtQE`L!q0d4)DF`(+#FhIQE{V|pyHPquTOVu}2$YY(hFwB)nCdBv?Z@@ns^HrBPT zRU7Ngv2m;%kM^VDV_o+IYNMXoN3xCMW}WxCEW8_tCF;d`I!^MwvEq_k*7><%EKx4& z8&oapSI^>SJ(Ww|`t$YJKkM~p=TR=}@iSn2eu~$zM1Iy&x#X=s$BlgYd{$V_!=@m9 zUdysse8OYoXFZim-nS%ttfzdeZ!yFdW0k5o-0O}7|J^1s0h4bWr z0d*CgV}G*MoURs5zLvv<&BIWi{ybpeNAvLJk+dV-I{V7wo?XNp@$*FO3WLFV$`N5715{1Nmg&|g6R1^RDL z2M)`x0<8vG9n>h{yON9}i*|c%KKESIzvr~L|6A&3S_=nz=i+OoA?Bk-5128B5WayH)Q=koH;P#v|0xKE?_T8-GodUGF4 zU0BzCMtMqmy^-4cYd@hpFZpcOoq!mgBlat70cB|9_2l?v96rP zHqI~W%2&!i;%9p*mpsZh;!F4bTo>Y$C$t|zQz$uGJV#97x&0l-;c({y^AXS|LFa=m z09^>GON^Vcv79^$Cp*mHE~-1jtJt4sUv1$$`|3{_{c(IOxp7)J`9ThMaTHxWM*ZX? zIh@s>{4IyO#OTknueRpXv#-9?=+CpSw(LdmDyQFNMt{r)ETuTc0hUsn;zi_5^Y9tD2KIhidCgJ#kNwMVqFe*#gJ}%5%p8t%;7%U!o|HA=jGPD_T8kl zH;XCUwKv-^B-N4MqtLdLud{oU>Te!41@qekhd1OyIGpfoJ|pTE$BMX=Rwzl7K3g8-3Y2nv{O$mv~ZqWXyH7$(876g;n!;A z@G9!Zxnjx9*-eo}kKwbh5HFrPVs7e(Fj1Eu9u^jB<@x^GG0^utGSD!S@w;cTFHg*{ z@Uk-x{y3w5*_#J%^)I{g;E!+hAJ1jXALB3Y_@x=|7Uk{omN1Vi?)RnTTbd)C2Uyo0 zO>N}W{!(pAJ739W#J9BbmG*P;^)Ov{$ocwhVhYdxyL#eo2i*m_J7D$TkE0e&_MIE^ zH`G;lj{V85OL1DOQXKhNN^x5A9Pa)gSr1V^`Ws6QXU(VQO!4g~x_XTL$zF5)JQJ@|c&xPJrvLeTK+&*v7-<8v0y<8v0y<8!|<^z-=K zuUoj7@Ax_W!UONQZb_e;?DDx!t{^^le&TcMLN9)o;Mgng`CpvV_UFK-E$kZ1``d4U zS&=^nmVL=SmHSxdIV_g=nJjr_SK?z`Hp4d6l_PcL6hGTjx#ZFQOnmA7o^rVt)BVKS zcpXa|8{1R4wiL zr?{BIy|#smpC4?FzV2K7jSCoOcs__(e3)}NnectJ+c?ls_}w|$hK8Cw8&u=C9sGBI z?gTYTI3w`;_Rns%+E29?BP9IhBicQ(Zw&+K?BKjEy~I4m_cd%l@w!RKk!yjysU%`=7+zYRtq-M#pGpu@eO z`#|3WeGBw$&;y`{K;Hp94EjgV_dvW$YTn~KiTd|JPl5g!^aIe-pl3kOf*K{*(^xd@ z_LK9caGXQuY0d}g*)dn&TevL9?CemS2CT3wyR9h~$u^s|R@-;n2R3c4`5rOaf5w6P z_PNTtvUAQ=+LrEf*;jL)D=hU;e*CNbp<0)Jz`9(~TJIShjN$TK&)R+#_$xtIgRTKx z3%U;UIZ$1qpSk>`8k>c8`N>l7)JyTiqu1v#{x5*O1iBvdWzb^K4WPP2y<{sMxhbCG z(tgl`{|frQ5%e|CO`w}Ww}4{I*2v;_TPTmkBlkAQxE*vS=q`{IE4hBP{Zev_%i1Th zMKM)==jogAtWm=6z-@_!5A1lz&5Akw^9Q>IdyvKE^n@`i_50jiC!gFquP6L~@w6a! zWRCoNa6hc!ddBfdFrP0#R5GmjIK1BSOTW39e#$(vsHc1K z%z5+s`?}`#p4Bsqj%3EFZybWx|3`b5O0UhJ*IN{r!<@zakD9XcUdh-T%v%W1kl~8U zm5i-`AD77BIm#8AD;aHkygwWd8H;vZd|%tP=bbWlxOJ~=`}9$=ZR#dd&CYQ(j`Yr+ zXRxh7`>npyE{yZ-`$OE>&l^}Uf1qdP;QajgXYEQqj$!y>@0YmF6jLu>+{dsk8_+sx z-@$g}H?@(6J{n8xi}jR`b>%kZg?j&z*L59Dc<8`?Z%^F1p!E_w`<2cd)6)K)-@<8L zN^zRUQk>>Bhugr=kNhk-+?!gs_}hfr0CU`XpSXg!p}l?EEc3ag+Hd_R$X<@Qr5eYN zF^-oKJ$Zk!E$I2L9(u0kr}ep6^ug@hZB*&EGWg%dt@&%8vo(L#Juz{cf!++-Jdxq` zK?~>cK?~>cK?~>c!Lf#ZoEw(h9BtXc#os*M4wy~fH+VezUD5}K+4od-|GOY}`TO7h z#yI|%=t%$D9<=tB?^#!KQ~TdQch}sWnG5i~-m`3LT%{k+OCw*FJzwf>R=JV3D!XGF z*R+{0b$2X&zAw8GKkLey^_@u^Birj36y>w7Ggy5-i~OwX9$0-2f4>m1^x5Xvs9XB^ z8QYrsKlMR9b>FQv)|H3V#`#Of$GYyIOZE-zzv1oa@iR$xd^)Nk)IN;ZmIJyA&t?D8=a>qZFsTZVqS7r~EyK z+u4{;&u3Ydy(k{#`rF0mPrjYQS^l7SnZr#s`csU^;ij~3F}F^DBTsw(5s$WVYn^gj zd)qZb&>H#NN}V)h`omK1k*Xa3YK-GGptV4+1-%Z`DB=5LeQPhf4GDGG<1HA>Bf~`Hwt-d zswUJk`OKq&De5@q&o}{E{O|sw4lHXr>30US~!if1jjt; z@#nc1R3B&o=rmA2s4g*{c>LSKHP>xvpFdeR>dBJR*TQMtbGQLRKiNhOXRV88&$!U& zPd1k8Z&3>u=y=7B0rJT`?zDY`EEu znwR>sG5Y$+T?05|=soMRF@3K~=ixBP?uVG~$zBgFwy`c7<(`7;&bo4`=1Kbvwkto1 zpY^7_po$XZvt4thHtMPMRvYVDOSO&mp5=miGSIu<&n=whFt>&&&gx`<4rXF)jbQl22hAm&&lA4@&rs>J+>RIRHgI~^ zf|=d(=jQF=@-S~J-e(ZaxW+g~(tVj?QZv@6jcd)hh$Y5Q)@AFmUGcL$l}jGks`yx! z9kNZaROhog7sOc0_Eau;bQdbQtm~dra#`0MCgV~pQ7+q4x#ZCuq~x-m^0B@wpY!wY z7V6^v3_^eJa3%0pfv!p9a6V+xvR^CTS~%szQk?9n6z7S}*Bbhw(it^<88jA>|=LXO=H z)j!?%;$E7gB**s8KRxf?*N4G$cI-1GcGZh|24Y@gU2CQs#(KRR^?67!Tsc7etWTq$ zP@>$DJ%VDVVz1<~p2{uRBPeDm=1DH=sa*0ZR*7$Edj!P_#TxOmp33#?5$MZ|2l~!u zy;q2H$$Bc6y!v}`_0PKgR-A2=%Q}CfjivrAjVPD(R4#e>TW7IEKGykLQ?W$3tn;^U zSon8hu|$5>Q@P~T|Eke=S?6bGu|&D7kF8qj|ECt^vYyH%@0Jz6x`uM7C zT;o03F6*gW@@}2*vA#{CjdEGvu4>!1@gC)}p2{Wf_6Z;B6B=!l%leL0+YXKQD3|qA zE_ruK_*kFVXro-#cdptdHQu9K)>FCU-6i2;eb+`C<+9E*5ev_MvBY&_J(Wvd=CW8K zAM1?yu|#`deUGYT_v%^e%z7%9yl+eRSl_eJ#__WLj;ihLjrTYYtfz9xyH~=;`a2tK zl*{_ms%`J;S>t6rl}p~vgpc)zUA#OJG^PC|pobqXI zoEA>`xD==;t{@SUBbN(*CqBD8+fs5VsoodCm|PPWy}8I4zv^C#5*;Q*yZ5 z4E?m1DaC1@Q;O3*sT8OEQVz%89H>i-pW0KE;bXWr*l>*PUo#0?p{MboykgZID-sY-Dl{h zvtcPt=f+ap)GEN0;yN9;`wjhcM$Ps2trjlcVbeYz{@IaN@mx0a`EaU8H?V}$ zZkgXt`t2=yYhL*IU3d6_)|m^t=Px*ujC#+yyNvffqxUyO@+K0j zD8WCuAAZ-2cVDIc8~)ilyJy~D@8Fr)v5gA?JHsBPA$u8LMn5B1u}6N!dL3Tko`H4Q zsBBLBY_I*v@4xbA`LFVb)DG?ZgVeEuYDXF_b91c^61`M{j;9(v99~-l6W&7 zxVre`4RKq8wgXM51>lwcGa(D7wUjMd`M|PLQ-Qk-n66ek-j z#d-EJJ4RKi$EY9elqJ`nh0{K}6enLO#mP5vxQS7f>M`mk|HcDMv}TF{slO|pC~qhah<|zPiS}*TfZRD1vtJA6 zi6a)y6GtqZCypF!=tsR+a{5^~PaLsuo;YIRWRtmZ9uifl9{q8|!pXKv`=iaUl;YNj zuq^JdiYGor{XBc3!&|s`zr&pJ()@vqHO|KQaY1kQoRF6Fp0%HUcaXVq-0vLOnm_;d z@Q6DKbTsH#&~c!;#P##U7YpZ!FBZ-dUo4y_zMN1ihgVTQ+7L_5mQIW;dJOj)Q&HPy z*B!quTxy?#cwg^X_Bk_1TRH4=R?t-se)}Y@3v?1_Ht1wfUHtZG;XL+f;XL+f;XL+v zYONez`R%i}g^T;lPP84l!|8qOH`!TJvXg!TrKo9x#*0qn^sM zY~#3D*LOziJG?lTtf%87FYozdiF~Z!Fno}y!G9Bl*@X3Zyv|X zdc6C#|CS_`OWykaI?C0(G~PmqayP{*-cz&ayNwzz>#1Dw>N|T)E}^V@W(+5=ZS*@>MA_P{$#5;T`in^Er(<7tcyPmS~$-+ zz`}XX0Txcap3`q(tsGuO{dE78!&&pGn3cmVGWt_o$>A(}QB2L@&M^8@d@98$c9r53 z`$}<&fjJ!SVe1mtk8zQu6vvp!Qi|Ik!isT<#ku~@s$|EfsGs6>DbDkKd8uJF76|zp{?`(Jh}$scCwG` zTZp8TlXrHI*V&=94AoJ4h$_im{5B8WY>)_i8KICn~lnR!IiiQ@P|(Y!Y9(Pvp7~ra<|Cj_g3bqB0J;!Vm*``%v79^$Cp*mHE~-1jtJt4x zv=ryrgMG^AkNvRZ`m=EIgBu7B56Q0WRYBg$aaVawYwqIzfcE4G;;sc< z2l_nddeCCf4WJuAb&2cf$rTpPlPfHoCs$ZFPp$wlkym+BZA;rX%9g~pw0)!Ul-4Lr7anqJ zbeovMv;V$|xZ6Q@f$k1iJ^1b4!g=if8|o@N$NoI_Z{f67xjC|MTI*7r);x#1-_Xyq zSF+~Qvse1I(Vy%!H_iuIxcIs547AH=g$S1qqpZ&K9HR$ zce2iL#S-sf$SeC0AL}U}>snXYW0aHE^+#d~&;I|_PTWsG|B~Q&uGF3&H^&xE^HGY^ ze3s%guQ}ZFhJNH{$>CmzEP4#z+t?4axexDoo^YvMG6Cs5%PxNwq^%rw`E$)&c=p>R zasLMTMS}O*rG@j@rG@j@rG@j@<*y9=Xge%98~Sx*(PKFG?2p?2IH~LR>^He*KW$;x zU{>C5gQOMro?UC8HB<~`UH2JkBd_LOZLDiv*`~T;t#YFH*`CTJk8+^+(mfRAGT-T( zM0<@T<^i^+a>=t!#U;6{>#j}XWnK4Z>n8kcPvw&5jR_y?y5Evq)^&HKyC{u=?WtVy z=^Xg_A9p;$+h~-0FsYvink;e4`X6Un<4Pw{o~O4E;R&OA99-E$vS}U5b;B=WuHp z`Y8^S;uI@Naf&UaIK`SA?$w5Vibth5#jH}CVq7VXafl^{Tg%W-aWRK`Z3`EFhvoqE z^}T!V-EKhQICF#q>HYX`Zbx7Sn*R7_JoU_14V<&`-Dt<#!A|6Y^0 zbwTSTc>1{~H&{5$OK#0AoaV6<=gAEl82V|Aa{axjg^RX%Am-+qea9Y{vrVpjPVPoQ z?#f}C8@J}re+N$7W}r8NHcw=D?bE_}?9;+|?9;+|>~pN4pT|D8Y~kYF(Ys)K+g!cd zv$DU&89n?*?3oMlwmB}yT=D+@k#cM^&T38A#(8F4^Q}FA_}Q*G6+i3R>uHZ7ezt2r zCw|to=hB`{{H!aVtF3t+QXBVP+DEC4_2$@Uqv<(_ZQKtvb!Hp&)V@XXSXca3TYCN> zwt4>1nE=h9$bPJQobfHY^WS+Bw>4-x&;-zqpt|_)ye%B{VabhqC!;^jXDLp0mcvan z`XfI}DNc5p!%Z^!lMR>RWZ$JY`9~?vb0)F$lP~4^v(`cWp2O{I%%|r}V%eGEQLevT zjQ-@?Ih^GWikCUuWTQXDupDkm3m5awL9pq=w_H43xHRt!XY;!SnXB^7s=TxGzyI02 zWq1C(L);#qw}bWq?G37nKkryLPu`ho^ykSt7S5A*I*tD5mn`y6E3aEPPu`hk^ykSt z7S5A*ESx9rSU6AKv2dQeW6h^0?@Tx5)01~Bd-3F*eT@D*dB^exPu|(r=+BdP_G{td zcQX%$P0yLJ`z`c~^5hK}Ud&1RVuB8gvZkSkQYw$AeA)od|kwRiB0DlR$Ox z$6O1i`OJ;m!f8E9aaxxgZnmKx`B`$fo)#|J^dZ2^eAn+^G;A9GtvN66lpt@#{f<|2 zF2m&D?9TOMyJEQPpYvARdgM#@N5nGMq~~4ckyIY*iuWbHGpDsi(RS68TU!gKahBj1 zi#;|!7lY~pEdZSc>Ic;&j@#n{7OuH&jI-AM!NO5bmYlv8PV1h-4H)`)_8r!`c=jC& zjs9d~xp6LP;o?2=p_r3>cX;$8)HBIj{EzGl`g^*22YT}Jc1Do9%GXEI*FVr&E5EN> zIFGNVIIpjN5aaw1=xoqApmRZW@%y@k^Z2@j^Z2@j^Z5FChJGGjPv@8Wc8{-r)acLS z>mO_3;@!w$=yUH&UcOW@qH#AuUq88PApaeuPXw8({Cp(+{DRgx`Tg9&dHg)ZdHwuC zjPoMU#h^<-mxAiz_j3#9@pB93@pB93@$vyMv#^bFS=Sv3eKwYO7GZlTmpr-ykzCeOKGyX;o|3c3 zKeX)5e+Nq36`(6YSAnhp)g{IePaLywp0kOClU?O}!oqpt*0qLy?1v@SpM{gXmf~dJ zr8wDp4tJfQpC@ivIGu@0`;(uQ;^cQZ+~*AaCJD_6gpx>Y+UYG1jxKp8D9vx?-mC1?!4y zii^qvtWN{Q5@nR+O~n(%Bgthwm0OZG<;RKxlFNE3w9X%X%u;lQ$Xn=_C3c zYn?yiT(X|Z^?YZaa`|1=jX^B+clV=Q)>FCU-Gt1cL_XH_TUgYUa#??K;IV&0F_lYR z{Z5tUEBy^c%H{q2SP)D7TZ(ZUtfz9vqHRl1ERm1(t<+SFm-X>g+qlMiv|ZLyx#ZnC z;bVQ9MjOY=`gT>@wvG2Fm-SRGdACpaSf9{nqg>W^tlD;HyhpjLr*g@=Q^Lpk#6}zC zvc7ZGHmUI*<+7g2CGRc?AM3j|+9;RxDOKC##(R{@dMcN^Z%z1E->uO`xvcL|we8+` zk8)X0<&yVp2_NfwHrgnc^>RI;AdMcN^ zoe3Z7DIe?8hxp>YR@Gb%{Bno5`0U?T6So-j70`{KuYu~~-&b2W&M`}F+!jvxrxeF^ zVaefcGV~)qODRrytQ4m_Sc>!Pt8X^+^X#iFobqXIoEA>`xD@BvSKngj=h;_VIOX-+ zI4zv^1*JI8zWP=}KkgY=a{XC2?Jr7k+Mkr-Jb!0%o1q`~E-bnJES&Z^r8w=AN^#mR z<#4wf`e{#9irXwsOLktY{_FvXS0&e-X3hNk^gU5iF*k2JMpV~e76?tjS~Hh4RzPCjdj@~{X+It zgJ*Q`EGC?19L&wkv$}6&PGWxP1Tik|2ihNW2j}`bcZdL zrT1X}!tTLI6DLk06YOAK5H|99^G+qFcRG&w;9meb4b%@B05wX`^B6Rox$(ExZRi=c zpu_1o8G4=t1)Tu?f1JEQYmHLxH!?xED= znVZRAo+3a)hV=Bv*d6#i5*fS$*Bp3cwDIwK7>w-~9dOG|l+#*&)IBnv1|Kq`k$3I2 zrq0c^URutkZYB2p42Myd@Y|ovSwFp?e^yJk@L$(`x-njihHj-c$e48vhf-2xUrC<2P6rX_amX!b z&+1m?>_>vQ<+yIuI35k-7bAJ|61O*sM#2 z^jUOj*X-E?;XBK>?Dk%TMHeP4EyjNyuR>&Lw>})9rq|h`pxYLM@5g0b4N)>_dcc4 zu`kh&ws11&ZB`Ww&%)$@gTz6iu;w*M{Y zV$dbkGwYXvE(38Nz&sr9e()leFwgJ9>)$-I#-Xiw=3kT++!Jp)O7ZRhjICszw*>Q6 zpmCt_plv|gg7{m3+k+;6_?>9dM`diS&pi4lF5@I{;?5D@i*`yWQ_1D1#_uQj(&MsZgFF>C!g1!X09<&&A z1L!ND8$n+M-3Gb?bSLO8(0!l>LEiyA40;sw6zGSb=RiLK{ZG)3LH`Q+8R+NLGwUyc zehvB!=(p7~>%RlN4EiJJPt`N)e+I3FwOAdrM)l14nxM5nuLZphv<~R?pf`Zl1+52K zAG87JO`r`yjS|i@j2U}w^{c~I$8&WTG-YP@`~_#CZpFW$JJ#wf!MHFQ@z1@Ftj56@ z#Te8mLBBpUyfE!U_q6nLp0)Y81lMyk^mFeaEB$CsjS|i{jPpO){iWA%FA&abm0qt# zJ$J@o+#U^`)`3)+*l=TD9%+=I&wMnTH0Q|r47vyk4aC30&FMqj^45pBH7)-axQ=f~ diff --git a/test/tests.h b/test/tests.h index a3bf582..1cded8e 100644 --- a/test/tests.h +++ b/test/tests.h @@ -127,7 +127,79 @@ TEST_DECLARE(quat) TEST_DECLARE(bezier) /* vec3 */ -TEST_DECLARE(vec3) +TEST_DECLARE(MACRO_GLM_VEC3_ONE_INIT) +TEST_DECLARE(MACRO_GLM_VEC3_ZERO_INIT) +TEST_DECLARE(MACRO_GLM_VEC3_ONE) +TEST_DECLARE(MACRO_GLM_VEC3_ZERO) +TEST_DECLARE(MACRO_GLM_YUP) +TEST_DECLARE(MACRO_GLM_ZUP) +TEST_DECLARE(MACRO_GLM_XUP) +TEST_DECLARE(MACRO_GLM_SHUFFLE3) +TEST_DECLARE(MACRO_GLM_XXX) +TEST_DECLARE(MACRO_GLM_YYY) +TEST_DECLARE(MACRO_GLM_ZZZ) +TEST_DECLARE(MACRO_GLM_ZYX) + +TEST_DECLARE(MACRO_glm_vec3_dup) +TEST_DECLARE(MACRO_glm_vec3_flipsign) +TEST_DECLARE(MACRO_glm_vec3_flipsign_to) +TEST_DECLARE(MACRO_glm_vec3_inv) +TEST_DECLARE(MACRO_glm_vec3_inv_to) +TEST_DECLARE(MACRO_glm_vec3_mulv) + +TEST_DECLARE(glm_vec3) +TEST_DECLARE(glm_vec3_copy) +TEST_DECLARE(glm_vec3_zero) +TEST_DECLARE(glm_vec3_one) +TEST_DECLARE(glm_vec3_dot) +TEST_DECLARE(glm_vec3_norm2) +TEST_DECLARE(glm_vec3_norm) +TEST_DECLARE(glm_vec3_norm_one) +TEST_DECLARE(glm_vec3_norm_inf) +TEST_DECLARE(glm_vec3_add) +TEST_DECLARE(glm_vec3_adds) +TEST_DECLARE(glm_vec3_sub) +TEST_DECLARE(glm_vec3_subs) +TEST_DECLARE(glm_vec3_mul) +TEST_DECLARE(glm_vec3_scale) +TEST_DECLARE(glm_vec3_scale_as) +TEST_DECLARE(glm_vec3_div) +TEST_DECLARE(glm_vec3_divs) +TEST_DECLARE(glm_vec3_addadd) +TEST_DECLARE(glm_vec3_subadd) +TEST_DECLARE(glm_vec3_muladd) +TEST_DECLARE(glm_vec3_muladds) +TEST_DECLARE(glm_vec3_maxadd) +TEST_DECLARE(glm_vec3_minadd) +TEST_DECLARE(glm_vec3_negate_to) +TEST_DECLARE(glm_vec3_negate) + +TEST_DECLARE(glmc_vec3) +TEST_DECLARE(glmc_vec3_copy) +TEST_DECLARE(glmc_vec3_zero) +TEST_DECLARE(glmc_vec3_one) +TEST_DECLARE(glmc_vec3_dot) +TEST_DECLARE(glmc_vec3_norm2) +TEST_DECLARE(glmc_vec3_norm) +TEST_DECLARE(glmc_vec3_norm_one) +TEST_DECLARE(glmc_vec3_norm_inf) +TEST_DECLARE(glmc_vec3_add) +TEST_DECLARE(glmc_vec3_adds) +TEST_DECLARE(glmc_vec3_sub) +TEST_DECLARE(glmc_vec3_subs) +TEST_DECLARE(glmc_vec3_mul) +TEST_DECLARE(glmc_vec3_scale) +TEST_DECLARE(glmc_vec3_scale_as) +TEST_DECLARE(glmc_vec3_div) +TEST_DECLARE(glmc_vec3_divs) +TEST_DECLARE(glmc_vec3_addadd) +TEST_DECLARE(glmc_vec3_subadd) +TEST_DECLARE(glmc_vec3_muladd) +TEST_DECLARE(glmc_vec3_muladds) +TEST_DECLARE(glmc_vec3_maxadd) +TEST_DECLARE(glmc_vec3_minadd) +TEST_DECLARE(glmc_vec3_negate_to) +TEST_DECLARE(glmc_vec3_negate) /* vec4 */ TEST_DECLARE(vec4) @@ -246,8 +318,84 @@ TEST_LIST { TEST_ENTRY(bezier) /* vec3 */ - TEST_ENTRY(vec3) + /* Macros */ + + TEST_ENTRY(MACRO_GLM_VEC3_ONE_INIT) + TEST_ENTRY(MACRO_GLM_VEC3_ZERO_INIT) + TEST_ENTRY(MACRO_GLM_VEC3_ONE) + TEST_ENTRY(MACRO_GLM_VEC3_ZERO) + TEST_ENTRY(MACRO_GLM_YUP) + TEST_ENTRY(MACRO_GLM_ZUP) + TEST_ENTRY(MACRO_GLM_XUP) + TEST_ENTRY(MACRO_GLM_SHUFFLE3) + TEST_ENTRY(MACRO_GLM_XXX) + TEST_ENTRY(MACRO_GLM_YYY) + TEST_ENTRY(MACRO_GLM_ZZZ) + TEST_ENTRY(MACRO_GLM_ZYX) + + TEST_ENTRY(MACRO_glm_vec3_dup) + TEST_ENTRY(MACRO_glm_vec3_flipsign) + TEST_ENTRY(MACRO_glm_vec3_flipsign_to) + TEST_ENTRY(MACRO_glm_vec3_inv) + TEST_ENTRY(MACRO_glm_vec3_inv_to) + TEST_ENTRY(MACRO_glm_vec3_mulv) + + TEST_ENTRY(glm_vec3) + TEST_ENTRY(glm_vec3_copy) + TEST_ENTRY(glm_vec3_zero) + TEST_ENTRY(glm_vec3_one) + TEST_ENTRY(glm_vec3_dot) + TEST_ENTRY(glm_vec3_norm2) + TEST_ENTRY(glm_vec3_norm) + TEST_ENTRY(glm_vec3_norm_one) + TEST_ENTRY(glm_vec3_norm_inf) + TEST_ENTRY(glm_vec3_add) + TEST_ENTRY(glm_vec3_adds) + TEST_ENTRY(glm_vec3_sub) + TEST_ENTRY(glm_vec3_subs) + TEST_ENTRY(glm_vec3_mul) + TEST_ENTRY(glm_vec3_scale) + TEST_ENTRY(glm_vec3_scale_as) + TEST_ENTRY(glm_vec3_div) + TEST_ENTRY(glm_vec3_divs) + TEST_ENTRY(glm_vec3_addadd) + TEST_ENTRY(glm_vec3_subadd) + TEST_ENTRY(glm_vec3_muladd) + TEST_ENTRY(glm_vec3_muladds) + TEST_ENTRY(glm_vec3_maxadd) + TEST_ENTRY(glm_vec3_minadd) + TEST_ENTRY(glm_vec3_negate_to) + TEST_ENTRY(glm_vec3_negate) + + + TEST_ENTRY(glmc_vec3) + TEST_ENTRY(glmc_vec3_copy) + TEST_ENTRY(glmc_vec3_zero) + TEST_ENTRY(glmc_vec3_one) + TEST_ENTRY(glmc_vec3_dot) + TEST_ENTRY(glmc_vec3_norm2) + TEST_ENTRY(glmc_vec3_norm) + TEST_ENTRY(glmc_vec3_norm_one) + TEST_ENTRY(glmc_vec3_norm_inf) + TEST_ENTRY(glmc_vec3_add) + TEST_ENTRY(glmc_vec3_adds) + TEST_ENTRY(glmc_vec3_sub) + TEST_ENTRY(glmc_vec3_subs) + TEST_ENTRY(glmc_vec3_mul) + TEST_ENTRY(glmc_vec3_scale) + TEST_ENTRY(glmc_vec3_scale_as) + TEST_ENTRY(glmc_vec3_div) + TEST_ENTRY(glmc_vec3_divs) + TEST_ENTRY(glmc_vec3_addadd) + TEST_ENTRY(glmc_vec3_subadd) + TEST_ENTRY(glmc_vec3_muladd) + TEST_ENTRY(glmc_vec3_muladds) + TEST_ENTRY(glmc_vec3_maxadd) + TEST_ENTRY(glmc_vec3_minadd) + TEST_ENTRY(glmc_vec3_negate_to) + TEST_ENTRY(glmc_vec3_negate) + /* vec4 */ TEST_ENTRY(vec4) }; From 495afb8a3d4bc8cf133a27e93822474484872c98 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 19 Sep 2019 16:16:41 +0300 Subject: [PATCH 027/103] Update test_vec3.h --- test/src/test_vec3.h | 40 +++++++++++++++------------------------- 1 file changed, 15 insertions(+), 25 deletions(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index ff60497..0d446f6 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -35,51 +35,41 @@ TEST_IMPL(MACRO_GLM_VEC3_ZERO_INIT) { } TEST_IMPL(MACRO_GLM_VEC3_ONE) { - vec3 v = GLM_VEC3_ONE; - - ASSERT(glm_eq(v[0], 1.0f)) - ASSERT(glm_eq(v[1], 1.0f)) - ASSERT(glm_eq(v[2], 1.0f)) + ASSERT(glm_eq(GLM_VEC3_ONE[0], 1.0f)) + ASSERT(glm_eq(GLM_VEC3_ONE[1], 1.0f)) + ASSERT(glm_eq(GLM_VEC3_ONE[2], 1.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_VEC3_ZERO) { - vec3 v = GLM_VEC3_ZERO; - - ASSERT(glm_eq(v[0], 0.0f)) - ASSERT(glm_eq(v[1], 0.0f)) - ASSERT(glm_eq(v[2], 0.0f)) + ASSERT(glm_eq(GLM_VEC3_ZERO[0], 0.0f)) + ASSERT(glm_eq(GLM_VEC3_ZERO[1], 0.0f)) + ASSERT(glm_eq(GLM_VEC3_ZERO[2], 0.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_YUP) { - vec3 v = GLM_YUP; - - ASSERT(glm_eq(v[0], 0.0f)) - ASSERT(glm_eq(v[1], 1.0f)) - ASSERT(glm_eq(v[2], 0.0f)) + ASSERT(glm_eq(GLM_YUP[0], 0.0f)) + ASSERT(glm_eq(GLM_YUP[1], 1.0f)) + ASSERT(glm_eq(GLM_YUP[2], 0.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_ZUP) { - vec3 v = GLM_ZUP; - - ASSERT(glm_eq(v[0], 0.0f)) - ASSERT(glm_eq(v[1], 0.0f)) - ASSERT(glm_eq(v[2], 1.0f)) + ASSERT(glm_eq(GLM_ZUP[0], 0.0f)) + ASSERT(glm_eq(GLM_ZUP[1], 0.0f)) + ASSERT(glm_eq(GLM_ZUP[2], 1.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_XUP) { - vec3 v = GLM_XUP; - - ASSERT(glm_eq(v[0], 1.0f)) - ASSERT(glm_eq(v[1], 0.0f)) - ASSERT(glm_eq(v[2], 0.0f)) + ASSERT(glm_eq(GLM_XUP[0], 1.0f)) + ASSERT(glm_eq(GLM_XUP[1], 0.0f)) + ASSERT(glm_eq(GLM_XUP[2], 0.0f)) TEST_SUCCESS } From 9fe5efb410e9ff723d393c3e8340e816d048f1d4 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 19 Sep 2019 16:50:22 +0300 Subject: [PATCH 028/103] tests: add more tests for vec3 --- test/src/test_vec3.h | 80 ++++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 18 +++++++++- 2 files changed, 97 insertions(+), 1 deletion(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 0d446f6..469a6b0 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -569,3 +569,83 @@ TEST_IMPL(GLM_PREFIX, vec3_negate) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec3_normalize) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {2.0f, -3.0f, 4.0f}; + float s = 1.0f; + float norm; + + GLM(vec3_normalize)(v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); + if (norm == 0.0f) { + ASSERT(glm_eq(v1[0], 0.0f)) + ASSERT(glm_eq(v1[1], 0.0f)) + ASSERT(glm_eq(v1[2], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(glm_eq(v1[0] * norm, v2[0])) + ASSERT(glm_eq(v1[1] * norm, v2[1])) + ASSERT(glm_eq(v1[2] * norm, v2[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_normalize_to) { + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2; + float s = 1.0f; + float norm; + + GLM(vec3_normalize_to)(v1, v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); + if (norm == 0.0f) { + ASSERT(glm_eq(v1[0], 0.0f)) + ASSERT(glm_eq(v1[1], 0.0f)) + ASSERT(glm_eq(v1[2], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(glm_eq(v1[0] * norm, v2[0])) + ASSERT(glm_eq(v1[1] * norm, v2[1])) + ASSERT(glm_eq(v1[2] * norm, v2[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_cross) { + /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */ + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; + + GLM(vec3_cross)(v1, v2, v3); + + v4[0] = v1[1] * v2[2] - v1[2] * v2[1]; + v4[1] = v1[2] * v2[0] - v1[0] * v2[2]; + v4[2] = v1[0] * v2[1] - v1[1] * v2[0]; + + ASSERTIFY(test_assert_vec3_eq(v3, v4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_crossn) { + /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */ + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; + + GLM(vec3_cross)(v1, v2, v3); + + v4[0] = v1[1] * v2[2] - v1[2] * v2[1]; + v4[1] = v1[2] * v2[0] - v1[0] * v2[2]; + v4[2] = v1[0] * v2[1] - v1[1] * v2[0]; + + ASSERTIFY(test_assert_vec3_eq(v3, v4)) + + TEST_SUCCESS +} + diff --git a/test/tests.h b/test/tests.h index 1cded8e..ae815ac 100644 --- a/test/tests.h +++ b/test/tests.h @@ -173,6 +173,10 @@ TEST_DECLARE(glm_vec3_maxadd) TEST_DECLARE(glm_vec3_minadd) TEST_DECLARE(glm_vec3_negate_to) TEST_DECLARE(glm_vec3_negate) +TEST_DECLARE(glm_vec3_normalize) +TEST_DECLARE(glm_vec3_normalize_to) +TEST_DECLARE(glm_vec3_cross) +TEST_DECLARE(glm_vec3_crossn) TEST_DECLARE(glmc_vec3) TEST_DECLARE(glmc_vec3_copy) @@ -200,6 +204,10 @@ TEST_DECLARE(glmc_vec3_maxadd) TEST_DECLARE(glmc_vec3_minadd) TEST_DECLARE(glmc_vec3_negate_to) TEST_DECLARE(glmc_vec3_negate) +TEST_DECLARE(glmc_vec3_normalize) +TEST_DECLARE(glmc_vec3_normalize_to) +TEST_DECLARE(glmc_vec3_cross) +TEST_DECLARE(glmc_vec3_crossn) /* vec4 */ TEST_DECLARE(vec4) @@ -367,6 +375,10 @@ TEST_LIST { TEST_ENTRY(glm_vec3_minadd) TEST_ENTRY(glm_vec3_negate_to) TEST_ENTRY(glm_vec3_negate) + TEST_ENTRY(glm_vec3_normalize) + TEST_ENTRY(glm_vec3_normalize_to) + TEST_ENTRY(glm_vec3_cross) + TEST_ENTRY(glm_vec3_crossn) TEST_ENTRY(glmc_vec3) @@ -395,7 +407,11 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_minadd) TEST_ENTRY(glmc_vec3_negate_to) TEST_ENTRY(glmc_vec3_negate) - + TEST_ENTRY(glmc_vec3_normalize) + TEST_ENTRY(glmc_vec3_normalize_to) + TEST_ENTRY(glmc_vec3_cross) + TEST_ENTRY(glmc_vec3_crossn) + /* vec4 */ TEST_ENTRY(vec4) }; From 9c57d4b2470ad60ba176407347d6db42a1ba5b42 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 20 Sep 2019 14:12:57 +0300 Subject: [PATCH 029/103] tests: add more tests for vec3 --- test/src/test_vec3.h | 148 +++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 44 +++++++++++++ 2 files changed, 192 insertions(+) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 469a6b0..8776b29 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -649,3 +649,151 @@ TEST_IMPL(GLM_PREFIX, vec3_crossn) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec3_max) { + vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; + vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; + vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f}; + + ASSERT(glm_eq(GLM(vec3_max)(v1), 2.104f)) + ASSERT(glm_eq(GLM(vec3_max)(v2), -12.35f)) + ASSERT(isinf(GLM(vec3_max)(v3))) + ASSERT(isnan(GLM(vec3_max)(v4))) + ASSERT(isnan(GLM(vec3_max)(v5))) + ASSERT(glm_eq(GLM(vec3_max)(v6), 11.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_min) { + vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; + vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; + vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f}; + + ASSERT(glm_eq(GLM(vec3_min)(v1), -4.10f)) + ASSERT(glm_eq(GLM(vec3_min)(v2), -43.502f)) + ASSERT(glm_eq(GLM(vec3_min)(v3), 0.0f)) + ASSERT(isnan(GLM(vec3_min)(v4))) + ASSERT(isnan(GLM(vec3_min)(v5))) + ASSERT(glm_eq(GLM(vec3_min)(v6), -11.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_isnan) { + vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; + vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; + vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -1.0f, 11.0f}; + + ASSERT(!GLM(vec3_isnan)(v1)) + ASSERT(!GLM(vec3_isnan)(v2)) + ASSERT(!GLM(vec3_isnan)(v3)) + ASSERT(GLM(vec3_isnan)(v4)) + ASSERT(GLM(vec3_isnan)(v5)) + ASSERT(!GLM(vec3_isnan)(v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_isinf) { + vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; + vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; + vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -1.0f, 11.0f}; + + ASSERT(!GLM(vec3_isinf)(v1)) + ASSERT(!GLM(vec3_isinf)(v2)) + ASSERT(GLM(vec3_isinf)(v3)) + ASSERT(GLM(vec3_isinf)(v4)) + ASSERT(!GLM(vec3_isinf)(v5)) + ASSERT(!GLM(vec3_isinf)(v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_isvalid) { + vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; + vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; + vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -1.0f, 11.0f}; + + ASSERT(GLM(vec3_isvalid)(v1)) + ASSERT(GLM(vec3_isvalid)(v2)) + ASSERT(!GLM(vec3_isvalid)(v3)) + ASSERT(!GLM(vec3_isvalid)(v4)) + ASSERT(!GLM(vec3_isvalid)(v5)) + ASSERT(GLM(vec3_isvalid)(v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_sign) { + vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; + vec3 v3, v4; + vec3 v5 = {1.0f, -1.0f, -1.0f}, v6 = {-1.0f, -1.0f, -1.0f}; + + GLM(vec3_sign)(v1, v3); + GLM(vec3_sign)(v2, v4); + + ASSERTIFY(test_assert_vec3_eq(v3, v5)) + ASSERTIFY(test_assert_vec3_eq(v4, v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_abs) { + vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; + vec3 v3, v4; + vec3 v5 = {2.104f, 3.012f, 4.10f}, v6 = {12.35f, 31.140f, 43.502f}; + + GLM(vec3_abs)(v1, v3); + GLM(vec3_abs)(v2, v4); + + ASSERTIFY(test_assert_vec3_eq(v3, v5)) + ASSERTIFY(test_assert_vec3_eq(v4, v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_fract) { + vec3 v1 = {2.104f, 3.012f, 4.10f}, v2 = {12.35f, 31.140f, 43.502f}, v3, v4; + vec3 v5 = {0.104f, 0.012f, 0.10f}, v6 = {0.35f, 0.140f, 0.502f}; + + GLM(vec3_fract)(v1, v3); + GLM(vec3_fract)(v2, v4); + + ASSERTIFY(test_assert_vec3_eq(v3, v5)) + ASSERTIFY(test_assert_vec3_eq(v4, v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_hadd) { + vec3 v1 = {2.0f, 3.0f, 4.0f}, v2 = {12.0f, 31.0f, 43.0f}; + float r1, r2, r3, r4; + + r1 = GLM(vec3_hadd)(v1); + r2 = GLM(vec3_hadd)(v2); + + r3 = v1[0] + v1[1] + v1[2]; + r4 = v2[0] + v2[1] + v2[2]; + + ASSERT(glm_eq(r1, r3)) + ASSERT(glm_eq(r2, r4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_sqrt) { + vec3 v1 = {2.0f, 3.0f, 4.0f}, v2 = {12.0f, 31.0f, 43.0f}, v3, v4; + + GLM(vec3_sqrt)(v1, v3); + GLM(vec3_sqrt)(v2, v4); + + ASSERT(glm_eq(sqrtf(v1[0]), v3[0])) + ASSERT(glm_eq(sqrtf(v1[1]), v3[1])) + ASSERT(glm_eq(sqrtf(v1[2]), v3[2])) + + ASSERT(glm_eq(sqrtf(v2[0]), v4[0])) + ASSERT(glm_eq(sqrtf(v2[1]), v4[1])) + ASSERT(glm_eq(sqrtf(v2[2]), v4[2])) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index ae815ac..72076de 100644 --- a/test/tests.h +++ b/test/tests.h @@ -178,6 +178,17 @@ TEST_DECLARE(glm_vec3_normalize_to) TEST_DECLARE(glm_vec3_cross) TEST_DECLARE(glm_vec3_crossn) +TEST_DECLARE(glm_vec3_max) +TEST_DECLARE(glm_vec3_min) +TEST_DECLARE(glm_vec3_isnan) +TEST_DECLARE(glm_vec3_isinf) +TEST_DECLARE(glm_vec3_isvalid) +TEST_DECLARE(glm_vec3_sign) +TEST_DECLARE(glm_vec3_abs) +TEST_DECLARE(glm_vec3_fract) +TEST_DECLARE(glm_vec3_hadd) +TEST_DECLARE(glm_vec3_sqrt) + TEST_DECLARE(glmc_vec3) TEST_DECLARE(glmc_vec3_copy) TEST_DECLARE(glmc_vec3_zero) @@ -209,6 +220,17 @@ TEST_DECLARE(glmc_vec3_normalize_to) TEST_DECLARE(glmc_vec3_cross) TEST_DECLARE(glmc_vec3_crossn) +TEST_DECLARE(glmc_vec3_max) +TEST_DECLARE(glmc_vec3_min) +TEST_DECLARE(glmc_vec3_isnan) +TEST_DECLARE(glmc_vec3_isinf) +TEST_DECLARE(glmc_vec3_isvalid) +TEST_DECLARE(glmc_vec3_sign) +TEST_DECLARE(glmc_vec3_abs) +TEST_DECLARE(glmc_vec3_fract) +TEST_DECLARE(glmc_vec3_hadd) +TEST_DECLARE(glmc_vec3_sqrt) + /* vec4 */ TEST_DECLARE(vec4) @@ -381,6 +403,17 @@ TEST_LIST { TEST_ENTRY(glm_vec3_crossn) + TEST_ENTRY(glm_vec3_max) + TEST_ENTRY(glm_vec3_min) + TEST_ENTRY(glm_vec3_isnan) + TEST_ENTRY(glm_vec3_isinf) + TEST_ENTRY(glm_vec3_isvalid) + TEST_ENTRY(glm_vec3_sign) + TEST_ENTRY(glm_vec3_abs) + TEST_ENTRY(glm_vec3_fract) + TEST_ENTRY(glm_vec3_hadd) + TEST_ENTRY(glm_vec3_sqrt) + TEST_ENTRY(glmc_vec3) TEST_ENTRY(glmc_vec3_copy) TEST_ENTRY(glmc_vec3_zero) @@ -411,6 +444,17 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_normalize_to) TEST_ENTRY(glmc_vec3_cross) TEST_ENTRY(glmc_vec3_crossn) + + TEST_ENTRY(glmc_vec3_max) + TEST_ENTRY(glmc_vec3_min) + TEST_ENTRY(glmc_vec3_isnan) + TEST_ENTRY(glmc_vec3_isinf) + TEST_ENTRY(glmc_vec3_isvalid) + TEST_ENTRY(glmc_vec3_sign) + TEST_ENTRY(glmc_vec3_abs) + TEST_ENTRY(glmc_vec3_fract) + TEST_ENTRY(glmc_vec3_hadd) + TEST_ENTRY(glmc_vec3_sqrt) /* vec4 */ TEST_ENTRY(vec4) From a062f002a0369a432c860169abed0f4e796cb8a0 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 20 Sep 2019 21:16:25 +0300 Subject: [PATCH 030/103] add codecov badge --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index fc5ed4b..c274b98 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,7 @@ [![Build status](https://ci.appveyor.com/api/projects/status/av7l3gc0yhfex8y4/branch/master?svg=true)](https://ci.appveyor.com/project/recp/cglm/branch/master) [![Documentation Status](https://readthedocs.org/projects/cglm/badge/?version=latest)](http://cglm.readthedocs.io/en/latest/?badge=latest) [![Coverage Status](https://coveralls.io/repos/github/recp/cglm/badge.svg?branch=master)](https://coveralls.io/github/recp/cglm?branch=master) +[![codecov](https://codecov.io/gh/recp/cglm/branch/master/graph/badge.svg)](https://codecov.io/gh/recp/cglm) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/6a62b37d5f214f178ebef269dc4a6bf1)](https://www.codacy.com/app/recp/cglm?utm_source=github.com&utm_medium=referral&utm_content=recp/cglm&utm_campaign=Badge_Grade) [![Backers on Open Collective](https://opencollective.com/cglm/backers/badge.svg)](#backers) [![Sponsors on Open Collective](https://opencollective.com/cglm/sponsors/badge.svg)](#sponsors) From 37cf6b32065830ff764d923ac766e30d12a8ce04 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 20 Sep 2019 22:30:32 +0300 Subject: [PATCH 031/103] tests: add more tests for vec3 --- test/src/test_vec3.h | 136 +++++++++++++++++++++++++++++++++++++++++-- test/tests.h | 32 +++++++++- 2 files changed, 160 insertions(+), 8 deletions(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 8776b29..f8bafde 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -595,7 +595,7 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize) { } TEST_IMPL(GLM_PREFIX, vec3_normalize_to) { - vec3 v1 = {2.0f, -3.0f, 4.0f}, v2; + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2; float s = 1.0f; float norm; @@ -621,7 +621,7 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize_to) { TEST_IMPL(GLM_PREFIX, vec3_cross) { /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */ - vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; GLM(vec3_cross)(v1, v2, v3); @@ -636,7 +636,7 @@ TEST_IMPL(GLM_PREFIX, vec3_cross) { TEST_IMPL(GLM_PREFIX, vec3_crossn) { /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */ - vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; GLM(vec3_cross)(v1, v2, v3); @@ -649,10 +649,134 @@ TEST_IMPL(GLM_PREFIX, vec3_crossn) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec3_broadcast) { + vec3 v1, v2, v3; + vec3 v5 = {-1.456f, -1.456f, -1.456f}; + vec3 v6 = {11.0f, 11.0f, 11.0f}; + vec3 v7 = {78.0f, 78.0f, 78.0f}; + + glm_vec3_broadcast(-1.456f, v1); + glm_vec3_broadcast(11.0f, v2); + glm_vec3_broadcast(78.0f, v3); + + ASSERTIFY(test_assert_vec3_eq(v1, v5)) + ASSERTIFY(test_assert_vec3_eq(v2, v6)) + ASSERTIFY(test_assert_vec3_eq(v3, v7)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_fill) { + vec3 v1, v2, v3; + vec3 v5 = {-1.456f, -1.456f, -1.456f}; + vec3 v6 = {11.0f, 11.0f, 11.0f}; + vec3 v7 = {78.0f, 78.0f, 78.0f}; + + glm_vec3_fill(v1, -1.456f); + glm_vec3_fill(v2, 11.0f); + glm_vec3_fill(v3, 78.0f); + + ASSERTIFY(test_assert_vec3_eq(v1, v5)) + ASSERTIFY(test_assert_vec3_eq(v2, v6)) + ASSERTIFY(test_assert_vec3_eq(v3, v7)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_eq) { + vec3 v1, v2, v3; + + glm_vec3_fill(v1, -1.456f); + glm_vec3_fill(v2, 11.0f); + glm_vec3_fill(v3, 78.1f); + + ASSERT(GLM(vec3_eq)(v1, -1.456f)) + ASSERT(GLM(vec3_eq)(v2, 11.0f)) + ASSERT(!GLM(vec3_eq)(v3, 78.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_eq_eps) { + vec3 v1, v2, v3; + + glm_vec3_fill(v1, -1.456f); + glm_vec3_fill(v2, 11.0f); + glm_vec3_fill(v3, 78.1f); + + ASSERT(GLM(vec3_eq_eps)(v1, -1.456f)) + ASSERT(GLM(vec3_eq_eps)(v2, 11.0f)) + ASSERT(!GLM(vec3_eq_eps)(v3, 78.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_eq_all) { + vec3 v1, v2, v3; + vec3 v4 = {2.104f, -3.012f, -4.10f}; + vec3 v5 = {-12.35f, -31.140f, -43.502f}; + + glm_vec3_fill(v1, -1.456f); + glm_vec3_fill(v2, 11.0f); + glm_vec3_fill(v3, 78.0f); + + ASSERT(GLM(vec3_eq_all)(v1)) + ASSERT(GLM(vec3_eq_all)(v2)) + ASSERT(GLM(vec3_eq_all)(v3)) + ASSERT(!GLM(vec3_eq_all)(v4)) + ASSERT(!GLM(vec3_eq_all)(v5)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_eqv) { + vec3 v1, v2, v3, v4, v5; + vec3 v6 = {-1.456f, -1.456f, -1.456f}; + vec3 v7 = {11.0f, 11.0f, 11.0f}; + vec3 v8 = {78.0f, 78.0f, -43.502f}; + + glm_vec3_fill(v1, -1.456f); + glm_vec3_fill(v2, 11.0f); + glm_vec3_fill(v3, 78.0f); + + test_rand_vec3(v4); + test_rand_vec3(v5); + + ASSERT(GLM(vec3_eqv)(v1, v6)) + ASSERT(GLM(vec3_eqv)(v2, v7)) + ASSERT(!GLM(vec3_eqv)(v3, v8)) + ASSERT(!GLM(vec3_eqv)(v4, v5)) + ASSERT(GLM(vec3_eqv)(v5, v5)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_eqv_eps) { + vec3 v1, v2, v3, v4, v5; + vec3 v6 = {-1.456f, -1.456f, -1.456f}; + vec3 v7 = {11.0f, 11.0f, 11.0f}; + vec3 v8 = {78.0f, 78.0f, -43.502f}; + + glm_vec3_fill(v1, -1.456f); + glm_vec3_fill(v2, 11.0f); + glm_vec3_fill(v3, 78.0f); + + test_rand_vec3(v4); + test_rand_vec3(v5); + + ASSERT(GLM(vec3_eqv_eps)(v1, v6)) + ASSERT(GLM(vec3_eqv_eps)(v2, v7)) + ASSERT(!GLM(vec3_eqv_eps)(v3, v8)) + ASSERT(!GLM(vec3_eqv_eps)(v4, v5)) + ASSERT(GLM(vec3_eqv_eps)(v5, v5)) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_max) { - vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; - vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; - vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f}; + vec3 v1 = {2.104f, -3.012f, -4.10f}, v2 = {-12.35f, -31.140f, -43.502f}; + vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; + vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f}; ASSERT(glm_eq(GLM(vec3_max)(v1), 2.104f)) ASSERT(glm_eq(GLM(vec3_max)(v2), -12.35f)) diff --git a/test/tests.h b/test/tests.h index 72076de..f7eef0e 100644 --- a/test/tests.h +++ b/test/tests.h @@ -178,6 +178,13 @@ TEST_DECLARE(glm_vec3_normalize_to) TEST_DECLARE(glm_vec3_cross) TEST_DECLARE(glm_vec3_crossn) +TEST_DECLARE(glm_vec3_broadcast) +TEST_DECLARE(glm_vec3_fill) +TEST_DECLARE(glm_vec3_eq) +TEST_DECLARE(glm_vec3_eq_eps) +TEST_DECLARE(glm_vec3_eq_all) +TEST_DECLARE(glm_vec3_eqv) +TEST_DECLARE(glm_vec3_eqv_eps) TEST_DECLARE(glm_vec3_max) TEST_DECLARE(glm_vec3_min) TEST_DECLARE(glm_vec3_isnan) @@ -220,6 +227,13 @@ TEST_DECLARE(glmc_vec3_normalize_to) TEST_DECLARE(glmc_vec3_cross) TEST_DECLARE(glmc_vec3_crossn) +TEST_DECLARE(glmc_vec3_broadcast) +TEST_DECLARE(glmc_vec3_fill) +TEST_DECLARE(glmc_vec3_eq) +TEST_DECLARE(glmc_vec3_eq_eps) +TEST_DECLARE(glmc_vec3_eq_all) +TEST_DECLARE(glmc_vec3_eqv) +TEST_DECLARE(glmc_vec3_eqv_eps) TEST_DECLARE(glmc_vec3_max) TEST_DECLARE(glmc_vec3_min) TEST_DECLARE(glmc_vec3_isnan) @@ -401,8 +415,14 @@ TEST_LIST { TEST_ENTRY(glm_vec3_normalize_to) TEST_ENTRY(glm_vec3_cross) TEST_ENTRY(glm_vec3_crossn) - + TEST_ENTRY(glm_vec3_broadcast) + TEST_ENTRY(glm_vec3_fill) + TEST_ENTRY(glm_vec3_eq) + TEST_ENTRY(glm_vec3_eq_eps) + TEST_ENTRY(glm_vec3_eq_all) + TEST_ENTRY(glm_vec3_eqv) + TEST_ENTRY(glm_vec3_eqv_eps) TEST_ENTRY(glm_vec3_max) TEST_ENTRY(glm_vec3_min) TEST_ENTRY(glm_vec3_isnan) @@ -444,7 +464,15 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_normalize_to) TEST_ENTRY(glmc_vec3_cross) TEST_ENTRY(glmc_vec3_crossn) - + + + TEST_ENTRY(glmc_vec3_broadcast) + TEST_ENTRY(glmc_vec3_fill) + TEST_ENTRY(glmc_vec3_eq) + TEST_ENTRY(glmc_vec3_eq_eps) + TEST_ENTRY(glmc_vec3_eq_all) + TEST_ENTRY(glmc_vec3_eqv) + TEST_ENTRY(glmc_vec3_eqv_eps) TEST_ENTRY(glmc_vec3_max) TEST_ENTRY(glmc_vec3_min) TEST_ENTRY(glmc_vec3_isnan) From e98311259cc6d249beb04ee6d2de03b0b5254752 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 20 Sep 2019 22:45:07 +0300 Subject: [PATCH 032/103] tests: fix some tests for vec3 --- test/src/test_vec3.h | 81 ++++++++++++++++++++++++++------------------ 1 file changed, 48 insertions(+), 33 deletions(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index f8bafde..227fa18 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -118,11 +118,14 @@ TEST_IMPL(MACRO_glm_vec3_dup) { TEST_IMPL(MACRO_glm_vec3_flipsign) { vec3 v1 = {13.0f, -12.0f, 11.0f}, - v2 = {-13.0f, 12.0f, -11.0f}; + v2 = {13.0f, -12.0f, 11.0f}, + v3 = {-13.0f, 12.0f, -11.0f}; glm_vec3_flipsign(v1); + glmc_vec3_flipsign(v2); - ASSERTIFY(test_assert_vec3_eq(v1, v2)) + ASSERTIFY(test_assert_vec3_eq(v1, v3)) + ASSERTIFY(test_assert_vec3_eq(v2, v3)) TEST_SUCCESS } @@ -130,22 +133,27 @@ TEST_IMPL(MACRO_glm_vec3_flipsign) { TEST_IMPL(MACRO_glm_vec3_flipsign_to) { vec3 v1 = {13.0f, -12.0f, 11.0f}, v2 = {-13.0f, 12.0f, -11.0f}, - v3; + v3, v4; glm_vec3_flipsign_to(v1, v3); + glmc_vec3_flipsign_to(v1, v4); ASSERTIFY(test_assert_vec3_eq(v2, v3)) + ASSERTIFY(test_assert_vec3_eq(v2, v4)) TEST_SUCCESS } TEST_IMPL(MACRO_glm_vec3_inv) { vec3 v1 = {13.0f, -12.0f, 11.0f}, - v2 = {-13.0f, 12.0f, -11.0f}; + v2 = {13.0f, -12.0f, 11.0f}, + v3 = {-13.0f, 12.0f, -11.0f}; glm_vec3_inv(v1); + glmc_vec3_inv(v2); - ASSERTIFY(test_assert_vec3_eq(v1, v2)) + ASSERTIFY(test_assert_vec3_eq(v1, v3)) + ASSERTIFY(test_assert_vec3_eq(v2, v3)) TEST_SUCCESS } @@ -153,10 +161,12 @@ TEST_IMPL(MACRO_glm_vec3_inv) { TEST_IMPL(MACRO_glm_vec3_inv_to) { vec3 v1 = {13.0f, -12.0f, 11.0f}, v2 = {-13.0f, 12.0f, -11.0f}, - v3; - + v3, v4; + glm_vec3_inv_to(v1, v3); - + glmc_vec3_inv_to(v1, v4); + + ASSERTIFY(test_assert_vec3_eq(v3, v4)) ASSERTIFY(test_assert_vec3_eq(v2, v3)) TEST_SUCCESS @@ -165,9 +175,12 @@ TEST_IMPL(MACRO_glm_vec3_inv_to) { TEST_IMPL(MACRO_glm_vec3_mulv) { vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {-3.0f, 4.0f, -5.0f}, - v3; - + v3, v4; + glm_vec3_mulv(v1, v2, v3); + glmc_vec3_mulv(v1, v2, v4); + + ASSERTIFY(test_assert_vec3_eq(v3, v4)) ASSERT(glm_eq(v1[0] * v2[0], v3[0])) ASSERT(glm_eq(v1[1] * v2[1], v3[1])) @@ -638,12 +651,14 @@ TEST_IMPL(GLM_PREFIX, vec3_crossn) { /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */ vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; - GLM(vec3_cross)(v1, v2, v3); + GLM(vec3_crossn)(v1, v2, v3); v4[0] = v1[1] * v2[2] - v1[2] * v2[1]; v4[1] = v1[2] * v2[0] - v1[0] * v2[2]; v4[2] = v1[0] * v2[1] - v1[1] * v2[0]; - + + glm_normalize(v4); + ASSERTIFY(test_assert_vec3_eq(v3, v4)) TEST_SUCCESS @@ -655,9 +670,9 @@ TEST_IMPL(GLM_PREFIX, vec3_broadcast) { vec3 v6 = {11.0f, 11.0f, 11.0f}; vec3 v7 = {78.0f, 78.0f, 78.0f}; - glm_vec3_broadcast(-1.456f, v1); - glm_vec3_broadcast(11.0f, v2); - glm_vec3_broadcast(78.0f, v3); + GLM(vec3_broadcast)(-1.456f, v1); + GLM(vec3_broadcast)(11.0f, v2); + GLM(vec3_broadcast)(78.0f, v3); ASSERTIFY(test_assert_vec3_eq(v1, v5)) ASSERTIFY(test_assert_vec3_eq(v2, v6)) @@ -672,9 +687,9 @@ TEST_IMPL(GLM_PREFIX, vec3_fill) { vec3 v6 = {11.0f, 11.0f, 11.0f}; vec3 v7 = {78.0f, 78.0f, 78.0f}; - glm_vec3_fill(v1, -1.456f); - glm_vec3_fill(v2, 11.0f); - glm_vec3_fill(v3, 78.0f); + GLM(vec3_fill)(v1, -1.456f); + GLM(vec3_fill)(v2, 11.0f); + GLM(vec3_fill)(v3, 78.0f); ASSERTIFY(test_assert_vec3_eq(v1, v5)) ASSERTIFY(test_assert_vec3_eq(v2, v6)) @@ -686,9 +701,9 @@ TEST_IMPL(GLM_PREFIX, vec3_fill) { TEST_IMPL(GLM_PREFIX, vec3_eq) { vec3 v1, v2, v3; - glm_vec3_fill(v1, -1.456f); - glm_vec3_fill(v2, 11.0f); - glm_vec3_fill(v3, 78.1f); + GLM(vec3_fill)(v1, -1.456f); + GLM(vec3_fill)(v2, 11.0f); + GLM(vec3_fill)(v3, 78.1f); ASSERT(GLM(vec3_eq)(v1, -1.456f)) ASSERT(GLM(vec3_eq)(v2, 11.0f)) @@ -700,9 +715,9 @@ TEST_IMPL(GLM_PREFIX, vec3_eq) { TEST_IMPL(GLM_PREFIX, vec3_eq_eps) { vec3 v1, v2, v3; - glm_vec3_fill(v1, -1.456f); - glm_vec3_fill(v2, 11.0f); - glm_vec3_fill(v3, 78.1f); + GLM(vec3_fill)(v1, -1.456f); + GLM(vec3_fill)(v2, 11.0f); + GLM(vec3_fill)(v3, 78.1f); ASSERT(GLM(vec3_eq_eps)(v1, -1.456f)) ASSERT(GLM(vec3_eq_eps)(v2, 11.0f)) @@ -716,9 +731,9 @@ TEST_IMPL(GLM_PREFIX, vec3_eq_all) { vec3 v4 = {2.104f, -3.012f, -4.10f}; vec3 v5 = {-12.35f, -31.140f, -43.502f}; - glm_vec3_fill(v1, -1.456f); - glm_vec3_fill(v2, 11.0f); - glm_vec3_fill(v3, 78.0f); + GLM(vec3_fill)(v1, -1.456f); + GLM(vec3_fill)(v2, 11.0f); + GLM(vec3_fill)(v3, 78.0f); ASSERT(GLM(vec3_eq_all)(v1)) ASSERT(GLM(vec3_eq_all)(v2)) @@ -735,9 +750,9 @@ TEST_IMPL(GLM_PREFIX, vec3_eqv) { vec3 v7 = {11.0f, 11.0f, 11.0f}; vec3 v8 = {78.0f, 78.0f, -43.502f}; - glm_vec3_fill(v1, -1.456f); - glm_vec3_fill(v2, 11.0f); - glm_vec3_fill(v3, 78.0f); + GLM(vec3_fill)(v1, -1.456f); + GLM(vec3_fill)(v2, 11.0f); + GLM(vec3_fill)(v3, 78.0f); test_rand_vec3(v4); test_rand_vec3(v5); @@ -757,9 +772,9 @@ TEST_IMPL(GLM_PREFIX, vec3_eqv_eps) { vec3 v7 = {11.0f, 11.0f, 11.0f}; vec3 v8 = {78.0f, 78.0f, -43.502f}; - glm_vec3_fill(v1, -1.456f); - glm_vec3_fill(v2, 11.0f); - glm_vec3_fill(v3, 78.0f); + GLM(vec3_fill)(v1, -1.456f); + GLM(vec3_fill)(v2, 11.0f); + GLM(vec3_fill)(v3, 78.0f); test_rand_vec3(v4); test_rand_vec3(v5); From d0671b3e7a223cf75c0db33c4d496226378b49b5 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 21 Sep 2019 14:01:20 +0300 Subject: [PATCH 033/103] tests: add missing test for mat4 --- test/src/test_mat4.h | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/test/src/test_mat4.h b/test/src/test_mat4.h index e6aceff..db95167 100644 --- a/test/src/test_mat4.h +++ b/test/src/test_mat4.h @@ -380,15 +380,23 @@ TEST_IMPL(GLM_PREFIX, mat4_inv) { TEST_IMPL(GLM_PREFIX, mat4_inv_precise) { mat4 m1, m2, m3; + mat4 m4, m5, m6; int i; for (i = 0; i < 100000; i++) { test_rand_mat4(m1); test_rand_mat4(m2); - + glm_mat4_inv_precise(m1, m2); glm_mat4_inv_precise(m2, m3); ASSERTIFY(test_assert_mat4_eq(m1, m3)) + + test_rand_mat4(m4); + test_rand_mat4(m5); + + glmc_mat4_inv_precise(m4, m5); + glmc_mat4_inv_precise(m5, m6); + ASSERTIFY(test_assert_mat4_eq(m4, m6)) } TEST_SUCCESS From d7b37ba245a87275c1197303ac5e1ad1927fa940 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 22 Sep 2019 10:52:02 +0300 Subject: [PATCH 034/103] tests: add some test for project/unproject --- test/src/test_project.c | 34 +++++++-------- test/src/test_project.h | 92 +++++++++++++++++++++++++++++++++++++++++ test/tests.h | 16 ++++++- 3 files changed, 120 insertions(+), 22 deletions(-) create mode 100644 test/src/test_project.h diff --git a/test/src/test_project.c b/test/src/test_project.c index d590423..b55b1d8 100644 --- a/test/src/test_project.c +++ b/test/src/test_project.c @@ -5,28 +5,22 @@ * Full license can be found in the LICENSE file */ -#include "test_common.h" +/* test inline project */ -TEST_IMPL(project) { - mat4 model, view, proj, mvp; - vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f}; - vec3 pos = {13.0f, 45.0f, 0.74f}; - vec3 projected, unprojected; +#define GLM_PREFIX glm_ +#define GLM(X) (glm_ ## X) - glm_translate_make(model, (vec3){0.0f, 0.0f, -10.0f}); - glm_lookat((vec3){0.0f, 0.0f, 0.0f}, pos, GLM_YUP, view); +#include "test_project.h" - glm_perspective_default(0.5f, proj); - glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp); +#undef GLM +#undef GLM_PREFIX - glmc_project(pos, mvp, viewport, projected); - glmc_unproject(projected, mvp, viewport, unprojected); +/* test pre-compiled project */ - /* unprojected of projected vector must be same as original one */ - /* we used 0.01 because of projection floating point errors */ - ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01); - ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01); - ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01); - - TEST_SUCCESS -} +#define GLM_PREFIX glmc_ +#define GLM(X) (glmc_ ## X) + +#include "test_project.h" + +#undef GLM +#undef GLM_PREFIX diff --git a/test/src/test_project.h b/test/src/test_project.h new file mode 100644 index 0000000..3add32b --- /dev/null +++ b/test/src/test_project.h @@ -0,0 +1,92 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +TEST_IMPL(GLM_PREFIX, unprojecti) { + mat4 model, view, proj, mvp; + vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f}; + vec3 pos = {13.0f, 45.0f, 0.74f}; + vec3 projected, unprojected; + + glm_translate_make(model, (vec3){0.0f, 0.0f, -10.0f}); + glm_lookat((vec3){0.0f, 0.0f, 0.0f}, pos, GLM_YUP, view); + + glm_perspective_default(0.5f, proj); + glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp); + + GLM(project)(pos, mvp, viewport, projected); + + glm_mat4_inv(mvp, mvp); + GLM(unprojecti)(projected, mvp, viewport, unprojected); + + /* unprojected of projected vector must be same as original one */ + /* we used 0.01 because of projection floating point errors */ + ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01) + ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01) + ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, unproject) { + mat4 model, view, proj, mvp; + vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f}; + vec3 pos = {13.0f, 45.0f, 0.74f}; + vec3 projected, unprojected; + + glm_translate_make(model, (vec3){0.0f, 0.0f, -10.0f}); + glm_lookat((vec3){0.0f, 0.0f, 0.0f}, pos, GLM_YUP, view); + + glm_perspective_default(0.5f, proj); + glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp); + + GLM(project)(pos, mvp, viewport, projected); + GLM(unproject)(projected, mvp, viewport, unprojected); + + /* unprojected of projected vector must be same as original one */ + /* we used 0.01 because of projection floating point errors */ + ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01) + ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01) + ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, project) { + mat4 model, view, proj, mvp; + vec4 viewport = {0.0f, 0.0f, 800.0f, 600.0f}; + vec3 pos = {13.0f, 45.0f, 0.74f}; + vec3 projected, unprojected; + + glm_translate_make(model, (vec3){0.0f, 0.0f, -10.0f}); + glm_lookat((vec3){0.0f, 0.0f, 0.0f}, pos, GLM_YUP, view); + + glm_perspective_default(0.5f, proj); + glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp); + + GLM(project)(pos, mvp, viewport, projected); + GLM(unproject)(projected, mvp, viewport, unprojected); + + /* unprojected of projected vector must be same as original one */ + /* we used 0.01 because of projection floating point errors */ + ASSERT(fabsf(pos[0] - unprojected[0]) < 0.01) + ASSERT(fabsf(pos[1] - unprojected[1]) < 0.01) + ASSERT(fabsf(pos[2] - unprojected[2]) < 0.01) + + /* test with no projection */ + glm_mat4_identity(mvp); + + GLM(project)(pos, mvp, viewport, projected); + GLM(unproject)(projected, mvp, viewport, unprojected); + + ASSERT(glm_eq(pos[0], unprojected[0])) + ASSERT(glm_eq(pos[1], unprojected[1])) + ASSERT(glm_eq(pos[2], unprojected[2])) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index f7eef0e..23c5925 100644 --- a/test/tests.h +++ b/test/tests.h @@ -112,7 +112,13 @@ TEST_DECLARE(camera_lookat) TEST_DECLARE(camera_decomp) /* project */ -TEST_DECLARE(project) +TEST_DECLARE(glm_unprojecti) +TEST_DECLARE(glm_unproject) +TEST_DECLARE(glm_project) + +TEST_DECLARE(glmc_unprojecti) +TEST_DECLARE(glmc_unproject) +TEST_DECLARE(glmc_project) /* utils */ TEST_DECLARE(clamp) @@ -347,7 +353,13 @@ TEST_LIST { TEST_ENTRY(camera_decomp) /* project */ - TEST_ENTRY(project) + TEST_ENTRY(glm_unprojecti) + TEST_ENTRY(glm_unproject) + TEST_ENTRY(glm_project) + + TEST_ENTRY(glmc_unprojecti) + TEST_ENTRY(glmc_unproject) + TEST_ENTRY(glmc_project) /* utils */ TEST_ENTRY(clamp) From 51ffe0958976f940c297d82984c56e6bbf417ee3 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 22 Sep 2019 22:27:05 +0300 Subject: [PATCH 035/103] tests: use test_eq insteaf og glm_eq --- test/src/test_bezier.c | 8 +- test/src/test_common.c | 12 +-- test/src/test_common.h | 6 ++ test/src/test_mat3.h | 48 ++++----- test/src/test_mat4.h | 58 +++++------ test/src/test_project.h | 6 +- test/src/test_quat.c | 4 +- test/src/test_vec3.h | 214 ++++++++++++++++++++-------------------- 8 files changed, 181 insertions(+), 175 deletions(-) diff --git a/test/src/test_bezier.c b/test/src/test_bezier.c index 8c22e65..3089dd5 100644 --- a/test/src/test_bezier.c +++ b/test/src/test_bezier.c @@ -49,7 +49,7 @@ TEST_IMPL(bezier) { Bs = glm_bezier(s, p0, c0, c1, p1); Bs_plain = test_bezier_plain(s, p0, c0, c1, p1); - ASSERT(glm_eq(Bs, Bs_plain)); + ASSERT(test_eq(Bs, Bs_plain)); ASSERTIFY(test_assert_eqf(smc, Bs_plain)) ASSERTIFY(test_assert_eqf(Bs, smc)) @@ -58,9 +58,9 @@ TEST_IMPL(bezier) { Bs = glm_hermite(s, p0, c0, c1, p1); Bs_plain = test_hermite_plain(s, p0, c0, c1, p1); - ASSERT(glm_eq(Bs, Bs_plain)); - ASSERT(glm_eq(smc, Bs_plain)); - ASSERT(glm_eq(Bs, smc)); + ASSERT(test_eq(Bs, Bs_plain)); + ASSERT(test_eq(smc, Bs_plain)); + ASSERT(test_eq(Bs, smc)); TEST_SUCCESS } diff --git a/test/src/test_common.c b/test/src/test_common.c index 7c808be..5741a37 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -159,9 +159,9 @@ test_assert_mat3_eq_identity(mat3 m3) { for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { if (i == j) { - ASSERT(glm_eq(m3[i][j], 1.0f)) + ASSERT(test_eq(m3[i][j], 1.0f)) } else { - ASSERT(glm_eq(m3[i][j], 0.0f)) + ASSERT(test_eq(m3[i][j], 0.0f)) } } } @@ -175,7 +175,7 @@ test_assert_mat3_eq_zero(mat3 m3) { for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { - ASSERT(glm_eq(m3[i][j], 0.0f)) + ASSERT(test_eq(m3[i][j], 0.0f)) } } @@ -189,9 +189,9 @@ test_assert_mat4_eq_identity(mat4 m4) { for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { if (i == j) { - ASSERT(glm_eq(m4[i][j], 1.0f)) + ASSERT(test_eq(m4[i][j], 1.0f)) } else { - ASSERT(glm_eq(m4[i][j], 0.0f)) + ASSERT(test_eq(m4[i][j], 0.0f)) } } } @@ -205,7 +205,7 @@ test_assert_mat4_eq_zero(mat4 m4) { for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { - ASSERT(glm_eq(m4[i][j], 0.0f)) + ASSERT(test_eq(m4[i][j], 0.0f)) } } diff --git a/test/src/test_common.h b/test/src/test_common.h index 2ebe227..a3dee7b 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -82,4 +82,10 @@ test_rand(void); void test_rand_quat(versor q); +CGLM_INLINE +bool +test_eq(float a, float b) { + return fabsf(a - b) <= 1e-6; +} + #endif /* test_common_h */ diff --git a/test/src/test_mat3.h b/test/src/test_mat3.h index 0659a2e..87947df 100644 --- a/test/src/test_mat3.h +++ b/test/src/test_mat3.h @@ -107,7 +107,7 @@ TEST_IMPL(GLM_PREFIX, mat3_mulv) { GLM(mat3_mulv)(mat, v, res); for (i = 0; i < 3; i++) { - ASSERT(glm_eq(res[i], + ASSERT(test_eq(res[i], v[0] * mat[0][i] + v[1] * mat[1][i] + v[2] * mat[2][i])) @@ -122,7 +122,7 @@ TEST_IMPL(GLM_PREFIX, mat3_trace) { trace = GLM(mat3_trace)(mat); - ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) + ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) TEST_SUCCESS } @@ -148,7 +148,7 @@ TEST_IMPL(GLM_PREFIX, mat3_quat) { GLM(mat4_pick3)(m2, m3); - ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) ASSERTIFY(test_assert_vec4_eq(q1, q2)) ASSERTIFY(test_assert_mat3_eq(m1, m3)) @@ -192,7 +192,7 @@ TEST_IMPL(GLM_PREFIX, mat3_scale) { for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { for (k = 0; k < 3; k++) - ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + ASSERT(test_eq(m1[i][j], m2[i][j] * scale)) } } @@ -215,7 +215,7 @@ TEST_IMPL(GLM_PREFIX, mat3_det) { det1 = a * (e * i - h * f) - d * (b * i - c * h) + g * (b * f - c * e); det2 = GLM(mat3_det)(mat); - ASSERT(glm_eq(det1, det2)) + ASSERT(test_eq(det1, det2)) TEST_SUCCESS } @@ -257,31 +257,31 @@ TEST_IMPL(GLM_PREFIX, mat3_swap_row) { GLM(mat3_swap_row)(m1, 0, 1); - ASSERT(glm_eq(m1[0][0], m2[0][1])) - ASSERT(glm_eq(m1[0][1], m2[0][0])) - ASSERT(glm_eq(m1[0][2], m2[0][2])) + ASSERT(test_eq(m1[0][0], m2[0][1])) + ASSERT(test_eq(m1[0][1], m2[0][0])) + ASSERT(test_eq(m1[0][2], m2[0][2])) - ASSERT(glm_eq(m1[1][0], m2[1][1])) - ASSERT(glm_eq(m1[1][1], m2[1][0])) - ASSERT(glm_eq(m1[1][2], m2[1][2])) + ASSERT(test_eq(m1[1][0], m2[1][1])) + ASSERT(test_eq(m1[1][1], m2[1][0])) + ASSERT(test_eq(m1[1][2], m2[1][2])) - ASSERT(glm_eq(m1[2][0], m2[2][1])) - ASSERT(glm_eq(m1[2][1], m2[2][0])) - ASSERT(glm_eq(m1[2][2], m2[2][2])) + ASSERT(test_eq(m1[2][0], m2[2][1])) + ASSERT(test_eq(m1[2][1], m2[2][0])) + ASSERT(test_eq(m1[2][2], m2[2][2])) GLM(mat3_swap_row)(m1, 1, 2); - ASSERT(glm_eq(m1[0][0], m2[0][1])) - ASSERT(glm_eq(m1[0][1], m2[0][2])) - ASSERT(glm_eq(m1[0][2], m2[0][0])) + ASSERT(test_eq(m1[0][0], m2[0][1])) + ASSERT(test_eq(m1[0][1], m2[0][2])) + ASSERT(test_eq(m1[0][2], m2[0][0])) - ASSERT(glm_eq(m1[1][0], m2[1][1])) - ASSERT(glm_eq(m1[1][1], m2[1][2])) - ASSERT(glm_eq(m1[1][2], m2[1][0])) + ASSERT(test_eq(m1[1][0], m2[1][1])) + ASSERT(test_eq(m1[1][1], m2[1][2])) + ASSERT(test_eq(m1[1][2], m2[1][0])) - ASSERT(glm_eq(m1[2][0], m2[2][1])) - ASSERT(glm_eq(m1[2][1], m2[2][2])) - ASSERT(glm_eq(m1[2][2], m2[2][0])) + ASSERT(test_eq(m1[2][0], m2[2][1])) + ASSERT(test_eq(m1[2][1], m2[2][2])) + ASSERT(test_eq(m1[2][2], m2[2][0])) TEST_SUCCESS } @@ -303,7 +303,7 @@ TEST_IMPL(GLM_PREFIX, mat3_rmc) { r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2]; - ASSERT(glm_eq(r1, r2)) + ASSERT(test_eq(r1, r2)) TEST_SUCCESS } diff --git a/test/src/test_mat4.h b/test/src/test_mat4.h index db95167..9463714 100644 --- a/test/src/test_mat4.h +++ b/test/src/test_mat4.h @@ -117,10 +117,10 @@ TEST_IMPL(GLM_PREFIX, mat4_ins3) { } } - ASSERT(glm_eq(m1[3][0], 0.0f)) - ASSERT(glm_eq(m1[3][1], 0.0f)) - ASSERT(glm_eq(m1[3][2], 0.0f)) - ASSERT(glm_eq(m1[3][3], 1.0f)) + ASSERT(test_eq(m1[3][0], 0.0f)) + ASSERT(test_eq(m1[3][1], 0.0f)) + ASSERT(test_eq(m1[3][2], 0.0f)) + ASSERT(test_eq(m1[3][3], 1.0f)) TEST_SUCCESS } @@ -184,7 +184,7 @@ TEST_IMPL(GLM_PREFIX, mat4_mulv) { GLM(mat4_mulv)(mat, v, res); for (i = 0; i < 4; i++) { - ASSERT(glm_eq(res[i], + ASSERT(test_eq(res[i], v[0] * mat[0][i] + v[1] * mat[1][i] + v[2] * mat[2][i] @@ -206,7 +206,7 @@ TEST_IMPL(GLM_PREFIX, mat4_mulv3) { GLM(mat4_mulv3)(mat, v, last, res); for (i = 0; i < 3; i++) { - ASSERT(glm_eq(res[i], + ASSERT(test_eq(res[i], v[0] * mat[0][i] + v[1] * mat[1][i] + v[2] * mat[2][i] @@ -222,7 +222,7 @@ TEST_IMPL(GLM_PREFIX, mat4_trace) { trace = GLM(mat4_trace)(mat); - ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3])) + ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2] + mat[3][3])) TEST_SUCCESS } @@ -233,7 +233,7 @@ TEST_IMPL(GLM_PREFIX, mat4_trace3) { trace = GLM(mat4_trace3)(mat); - ASSERT(glm_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) + ASSERT(test_eq(trace, mat[0][0] + mat[1][1] + mat[2][2])) TEST_SUCCESS } @@ -256,7 +256,7 @@ TEST_IMPL(GLM_PREFIX, mat4_quat) { GLM(vec3_normalize)(axis1); GLM(vec3_normalize)(axis2); - ASSERT(glm_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) ASSERTIFY(test_assert_vec4_eq(q1, q2)) ASSERTIFY(test_assert_mat4_eq(m1, m2)) @@ -300,7 +300,7 @@ TEST_IMPL(GLM_PREFIX, mat4_scale_p) { for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { for (k = 0; k < 4; k++) - ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + ASSERT(test_eq(m1[i][j], m2[i][j] * scale)) } } @@ -319,7 +319,7 @@ TEST_IMPL(GLM_PREFIX, mat4_scale) { for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { for (k = 0; k < 4; k++) - ASSERT(glm_eq(m1[i][j], m2[i][j] * scale)) + ASSERT(test_eq(m1[i][j], m2[i][j] * scale)) } } @@ -356,7 +356,7 @@ TEST_IMPL(GLM_PREFIX, mat4_det) { det2 = GLM(mat4_det(mat)); - ASSERT(glm_eq(det1, det2)) + ASSERT(test_eq(det1, det2)) TEST_SUCCESS } @@ -441,22 +441,22 @@ TEST_IMPL(GLM_PREFIX, mat4_swap_row) { GLM(mat4_swap_row)(m1, 0, 1); GLM(mat4_swap_row)(m1, 2, 3); - ASSERT(glm_eq(m1[0][0], m2[0][1])) - ASSERT(glm_eq(m1[0][1], m2[0][0])) - ASSERT(glm_eq(m1[0][2], m2[0][3])) - ASSERT(glm_eq(m1[0][3], m2[0][2])) - ASSERT(glm_eq(m1[1][0], m2[1][1])) - ASSERT(glm_eq(m1[1][1], m2[1][0])) - ASSERT(glm_eq(m1[1][2], m2[1][3])) - ASSERT(glm_eq(m1[1][3], m2[1][2])) - ASSERT(glm_eq(m1[2][0], m2[2][1])) - ASSERT(glm_eq(m1[2][1], m2[2][0])) - ASSERT(glm_eq(m1[2][2], m2[2][3])) - ASSERT(glm_eq(m1[2][3], m2[2][2])) - ASSERT(glm_eq(m1[3][0], m2[3][1])) - ASSERT(glm_eq(m1[3][1], m2[3][0])) - ASSERT(glm_eq(m1[3][2], m2[3][3])) - ASSERT(glm_eq(m1[3][3], m2[3][2])) + ASSERT(test_eq(m1[0][0], m2[0][1])) + ASSERT(test_eq(m1[0][1], m2[0][0])) + ASSERT(test_eq(m1[0][2], m2[0][3])) + ASSERT(test_eq(m1[0][3], m2[0][2])) + ASSERT(test_eq(m1[1][0], m2[1][1])) + ASSERT(test_eq(m1[1][1], m2[1][0])) + ASSERT(test_eq(m1[1][2], m2[1][3])) + ASSERT(test_eq(m1[1][3], m2[1][2])) + ASSERT(test_eq(m1[2][0], m2[2][1])) + ASSERT(test_eq(m1[2][1], m2[2][0])) + ASSERT(test_eq(m1[2][2], m2[2][3])) + ASSERT(test_eq(m1[2][3], m2[2][2])) + ASSERT(test_eq(m1[3][0], m2[3][1])) + ASSERT(test_eq(m1[3][1], m2[3][0])) + ASSERT(test_eq(m1[3][2], m2[3][3])) + ASSERT(test_eq(m1[3][3], m2[3][2])) TEST_SUCCESS } @@ -479,7 +479,7 @@ TEST_IMPL(GLM_PREFIX, mat4_rmc) { r2 = v[0] * v1[0] + v[1] * v1[1] + v[2] * v1[2] + v[3] * v1[3]; - ASSERT(glm_eq(r1, r2)) + ASSERT(test_eq(r1, r2)) TEST_SUCCESS } diff --git a/test/src/test_project.h b/test/src/test_project.h index 3add32b..41bdecd 100644 --- a/test/src/test_project.h +++ b/test/src/test_project.h @@ -84,9 +84,9 @@ TEST_IMPL(GLM_PREFIX, project) { GLM(project)(pos, mvp, viewport, projected); GLM(unproject)(projected, mvp, viewport, unprojected); - ASSERT(glm_eq(pos[0], unprojected[0])) - ASSERT(glm_eq(pos[1], unprojected[1])) - ASSERT(glm_eq(pos[2], unprojected[2])) + ASSERT(test_eq(pos[0], unprojected[0])) + ASSERT(test_eq(pos[1], unprojected[1])) + ASSERT(test_eq(pos[2], unprojected[2])) TEST_SUCCESS } diff --git a/test/src/test_quat.c b/test/src/test_quat.c index 44725ee..98bd8a1 100644 --- a/test/src/test_quat.c +++ b/test/src/test_quat.c @@ -24,7 +24,7 @@ TEST_IMPL(quat) { /* 0. test identiy quat */ glm_quat_identity(q4); - ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f))) + ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f))) glm_quat_mat4(q4, rot1); ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f)) @@ -121,7 +121,7 @@ TEST_IMPL(quat) { /* 9. test imag, real */ /* 9.1 real */ - ASSERT(glm_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f))) + ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f))) /* 9.1 imag */ glm_quat_imag(q4, imag); diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 227fa18..3c4edfa 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -17,9 +17,9 @@ TEST_IMPL(MACRO_GLM_VEC3_ONE_INIT) { vec3 v = GLM_VEC3_ONE_INIT; - ASSERT(glm_eq(v[0], 1.0f)) - ASSERT(glm_eq(v[1], 1.0f)) - ASSERT(glm_eq(v[2], 1.0f)) + ASSERT(test_eq(v[0], 1.0f)) + ASSERT(test_eq(v[1], 1.0f)) + ASSERT(test_eq(v[2], 1.0f)) TEST_SUCCESS } @@ -27,49 +27,49 @@ TEST_IMPL(MACRO_GLM_VEC3_ONE_INIT) { TEST_IMPL(MACRO_GLM_VEC3_ZERO_INIT) { vec3 v = GLM_VEC3_ZERO_INIT; - ASSERT(glm_eq(v[0], 0.0f)) - ASSERT(glm_eq(v[1], 0.0f)) - ASSERT(glm_eq(v[2], 0.0f)) + ASSERT(test_eq(v[0], 0.0f)) + ASSERT(test_eq(v[1], 0.0f)) + ASSERT(test_eq(v[2], 0.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_VEC3_ONE) { - ASSERT(glm_eq(GLM_VEC3_ONE[0], 1.0f)) - ASSERT(glm_eq(GLM_VEC3_ONE[1], 1.0f)) - ASSERT(glm_eq(GLM_VEC3_ONE[2], 1.0f)) + ASSERT(test_eq(GLM_VEC3_ONE[0], 1.0f)) + ASSERT(test_eq(GLM_VEC3_ONE[1], 1.0f)) + ASSERT(test_eq(GLM_VEC3_ONE[2], 1.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_VEC3_ZERO) { - ASSERT(glm_eq(GLM_VEC3_ZERO[0], 0.0f)) - ASSERT(glm_eq(GLM_VEC3_ZERO[1], 0.0f)) - ASSERT(glm_eq(GLM_VEC3_ZERO[2], 0.0f)) + ASSERT(test_eq(GLM_VEC3_ZERO[0], 0.0f)) + ASSERT(test_eq(GLM_VEC3_ZERO[1], 0.0f)) + ASSERT(test_eq(GLM_VEC3_ZERO[2], 0.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_YUP) { - ASSERT(glm_eq(GLM_YUP[0], 0.0f)) - ASSERT(glm_eq(GLM_YUP[1], 1.0f)) - ASSERT(glm_eq(GLM_YUP[2], 0.0f)) + ASSERT(test_eq(GLM_YUP[0], 0.0f)) + ASSERT(test_eq(GLM_YUP[1], 1.0f)) + ASSERT(test_eq(GLM_YUP[2], 0.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_ZUP) { - ASSERT(glm_eq(GLM_ZUP[0], 0.0f)) - ASSERT(glm_eq(GLM_ZUP[1], 0.0f)) - ASSERT(glm_eq(GLM_ZUP[2], 1.0f)) + ASSERT(test_eq(GLM_ZUP[0], 0.0f)) + ASSERT(test_eq(GLM_ZUP[1], 0.0f)) + ASSERT(test_eq(GLM_ZUP[2], 1.0f)) TEST_SUCCESS } TEST_IMPL(MACRO_GLM_XUP) { - ASSERT(glm_eq(GLM_XUP[0], 1.0f)) - ASSERT(glm_eq(GLM_XUP[1], 0.0f)) - ASSERT(glm_eq(GLM_XUP[2], 0.0f)) + ASSERT(test_eq(GLM_XUP[0], 1.0f)) + ASSERT(test_eq(GLM_XUP[1], 0.0f)) + ASSERT(test_eq(GLM_XUP[2], 0.0f)) TEST_SUCCESS } @@ -182,9 +182,9 @@ TEST_IMPL(MACRO_glm_vec3_mulv) { ASSERTIFY(test_assert_vec3_eq(v3, v4)) - ASSERT(glm_eq(v1[0] * v2[0], v3[0])) - ASSERT(glm_eq(v1[1] * v2[1], v3[1])) - ASSERT(glm_eq(v1[2] * v2[2], v3[2])) + ASSERT(test_eq(v1[0] * v2[0], v3[0])) + ASSERT(test_eq(v1[1] * v2[1], v3[1])) + ASSERT(test_eq(v1[2] * v2[2], v3[2])) TEST_SUCCESS } @@ -199,9 +199,9 @@ TEST_IMPL(GLM_PREFIX, vec3) { GLM(vec3)(v4, v3); - ASSERT(glm_eq(v3[0], v4[0])) - ASSERT(glm_eq(v3[1], v4[1])) - ASSERT(glm_eq(v3[2], v4[2])) + ASSERT(test_eq(v3[0], v4[0])) + ASSERT(test_eq(v3[1], v4[1])) + ASSERT(test_eq(v3[2], v4[2])) TEST_SUCCESS } @@ -251,7 +251,7 @@ TEST_IMPL(GLM_PREFIX, vec3_dot) { dot1 = GLM(vec3_dot)(a, b); dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; - ASSERT(glm_eq(dot1, dot2)) + ASSERT(test_eq(dot1, dot2)) TEST_SUCCESS } @@ -263,7 +263,7 @@ TEST_IMPL(GLM_PREFIX, vec3_norm2) { n1 = GLM(vec3_norm2)(a); n2 = a[0] * a[0] + a[1] * a[1] + a[2] * a[2]; - ASSERT(glm_eq(n1, n2)) + ASSERT(test_eq(n1, n2)) TEST_SUCCESS } @@ -275,7 +275,7 @@ TEST_IMPL(GLM_PREFIX, vec3_norm) { n1 = GLM(vec3_norm)(a); n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]); - ASSERT(glm_eq(n1, n2)) + ASSERT(test_eq(n1, n2)) TEST_SUCCESS } @@ -287,7 +287,7 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_one) { n1 = GLM(vec3_norm_one)(a); n2 = fabsf(a[0]) + fabsf(a[1]) + fabsf(a[2]); - ASSERT(glm_eq(n1, n2)) + ASSERT(test_eq(n1, n2)) TEST_SUCCESS } @@ -305,7 +305,7 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_inf) { if (fabsf(a[1]) < fabsf(a[2])) n2 = fabsf(a[2]); - ASSERT(glm_eq(n1, n2)) + ASSERT(test_eq(n1, n2)) TEST_SUCCESS } @@ -381,9 +381,9 @@ TEST_IMPL(GLM_PREFIX, vec3_mul) { GLM(vec3_mul)(v1, v2, v3); - ASSERT(glm_eq(v1[0] * v2[0], v3[0])) - ASSERT(glm_eq(v1[1] * v2[1], v3[1])) - ASSERT(glm_eq(v1[2] * v2[2], v3[2])) + ASSERT(test_eq(v1[0] * v2[0], v3[0])) + ASSERT(test_eq(v1[1] * v2[1], v3[1])) + ASSERT(test_eq(v1[2] * v2[2], v3[2])) TEST_SUCCESS } @@ -394,9 +394,9 @@ TEST_IMPL(GLM_PREFIX, vec3_scale) { GLM(vec3_scale)(v1, s, v2); - ASSERT(glm_eq(v1[0] * s, v2[0])) - ASSERT(glm_eq(v1[1] * s, v2[1])) - ASSERT(glm_eq(v1[2] * s, v2[2])) + ASSERT(test_eq(v1[0] * s, v2[0])) + ASSERT(test_eq(v1[1] * s, v2[1])) + ASSERT(test_eq(v1[2] * s, v2[2])) TEST_SUCCESS } @@ -410,18 +410,18 @@ TEST_IMPL(GLM_PREFIX, vec3_scale_as) { norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); if (norm == 0.0f) { - ASSERT(glm_eq(v1[0], 0.0f)) - ASSERT(glm_eq(v1[1], 0.0f)) - ASSERT(glm_eq(v1[2], 0.0f)) + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) TEST_SUCCESS } norm = s / norm; - ASSERT(glm_eq(v1[0] * norm, v2[0])) - ASSERT(glm_eq(v1[1] * norm, v2[1])) - ASSERT(glm_eq(v1[2] * norm, v2[2])) + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) TEST_SUCCESS } @@ -433,9 +433,9 @@ TEST_IMPL(GLM_PREFIX, vec3_div) { GLM(vec3_div)(v1, v2, v3); - ASSERT(glm_eq(v1[0] / v2[0], v3[0])) - ASSERT(glm_eq(v1[1] / v2[1], v3[1])) - ASSERT(glm_eq(v1[2] / v2[2], v3[2])) + ASSERT(test_eq(v1[0] / v2[0], v3[0])) + ASSERT(test_eq(v1[1] / v2[1], v3[1])) + ASSERT(test_eq(v1[2] / v2[2], v3[2])) TEST_SUCCESS } @@ -446,9 +446,9 @@ TEST_IMPL(GLM_PREFIX, vec3_divs) { GLM(vec3_divs)(v1, s, v2); - ASSERT(glm_eq(v1[0] / s, v2[0])) - ASSERT(glm_eq(v1[1] / s, v2[1])) - ASSERT(glm_eq(v1[2] / s, v2[2])) + ASSERT(test_eq(v1[0] / s, v2[0])) + ASSERT(test_eq(v1[1] / s, v2[1])) + ASSERT(test_eq(v1[2] / s, v2[2])) TEST_SUCCESS } @@ -461,9 +461,9 @@ TEST_IMPL(GLM_PREFIX, vec3_addadd) { GLM(vec3_addadd)(v1, v2, v4); - ASSERT(glm_eq(v3[0] + v1[0] + v2[0], v4[0])) - ASSERT(glm_eq(v3[1] + v1[1] + v2[1], v4[1])) - ASSERT(glm_eq(v3[2] + v1[2] + v2[2], v4[2])) + ASSERT(test_eq(v3[0] + v1[0] + v2[0], v4[0])) + ASSERT(test_eq(v3[1] + v1[1] + v2[1], v4[1])) + ASSERT(test_eq(v3[2] + v1[2] + v2[2], v4[2])) TEST_SUCCESS } @@ -476,9 +476,9 @@ TEST_IMPL(GLM_PREFIX, vec3_subadd) { GLM(vec3_subadd)(v1, v2, v4); - ASSERT(glm_eq(v3[0] + v1[0] - v2[0], v4[0])) - ASSERT(glm_eq(v3[1] + v1[1] - v2[1], v4[1])) - ASSERT(glm_eq(v3[2] + v1[2] - v2[2], v4[2])) + ASSERT(test_eq(v3[0] + v1[0] - v2[0], v4[0])) + ASSERT(test_eq(v3[1] + v1[1] - v2[1], v4[1])) + ASSERT(test_eq(v3[2] + v1[2] - v2[2], v4[2])) TEST_SUCCESS } @@ -491,9 +491,9 @@ TEST_IMPL(GLM_PREFIX, vec3_muladd) { GLM(vec3_muladd)(v1, v2, v4); - ASSERT(glm_eq(v3[0] + v1[0] * v2[0], v4[0])) - ASSERT(glm_eq(v3[1] + v1[1] * v2[1], v4[1])) - ASSERT(glm_eq(v3[2] + v1[2] * v2[2], v4[2])) + ASSERT(test_eq(v3[0] + v1[0] * v2[0], v4[0])) + ASSERT(test_eq(v3[1] + v1[1] * v2[1], v4[1])) + ASSERT(test_eq(v3[2] + v1[2] * v2[2], v4[2])) TEST_SUCCESS } @@ -506,9 +506,9 @@ TEST_IMPL(GLM_PREFIX, vec3_muladds) { GLM(vec3_muladds)(v1, s, v3); - ASSERT(glm_eq(v2[0] + v1[0] * s, v3[0])) - ASSERT(glm_eq(v2[1] + v1[1] * s, v3[1])) - ASSERT(glm_eq(v2[2] + v1[2] * s, v3[2])) + ASSERT(test_eq(v2[0] + v1[0] * s, v3[0])) + ASSERT(test_eq(v2[1] + v1[1] * s, v3[1])) + ASSERT(test_eq(v2[2] + v1[2] * s, v3[2])) TEST_SUCCESS } @@ -521,9 +521,9 @@ TEST_IMPL(GLM_PREFIX, vec3_maxadd) { GLM(vec3_maxadd)(v1, v2, v4); - ASSERT(glm_eq(v3[0] + glm_max(v1[0], v2[0]), v4[0])) - ASSERT(glm_eq(v3[1] + glm_max(v1[1], v2[1]), v4[1])) - ASSERT(glm_eq(v3[2] + glm_max(v1[2], v2[2]), v4[2])) + ASSERT(test_eq(v3[0] + glm_max(v1[0], v2[0]), v4[0])) + ASSERT(test_eq(v3[1] + glm_max(v1[1], v2[1]), v4[1])) + ASSERT(test_eq(v3[2] + glm_max(v1[2], v2[2]), v4[2])) TEST_SUCCESS } @@ -536,9 +536,9 @@ TEST_IMPL(GLM_PREFIX, vec3_minadd) { GLM(vec3_minadd)(v1, v2, v4); - ASSERT(glm_eq(v3[0] + glm_min(v1[0], v2[0]), v4[0])) - ASSERT(glm_eq(v3[1] + glm_min(v1[1], v2[1]), v4[1])) - ASSERT(glm_eq(v3[2] + glm_min(v1[2], v2[2]), v4[2])) + ASSERT(test_eq(v3[0] + glm_min(v1[0], v2[0]), v4[0])) + ASSERT(test_eq(v3[1] + glm_min(v1[1], v2[1]), v4[1])) + ASSERT(test_eq(v3[2] + glm_min(v1[2], v2[2]), v4[2])) TEST_SUCCESS } @@ -551,13 +551,13 @@ TEST_IMPL(GLM_PREFIX, vec3_negate_to) { GLM(vec3_negate_to)(v1, v3); GLM(vec3_negate_to)(v2, v4); - ASSERT(glm_eq(-v1[0], v3[0])) - ASSERT(glm_eq(-v1[1], v3[1])) - ASSERT(glm_eq(-v1[2], v3[2])) + ASSERT(test_eq(-v1[0], v3[0])) + ASSERT(test_eq(-v1[1], v3[1])) + ASSERT(test_eq(-v1[2], v3[2])) - ASSERT(glm_eq(-v2[0], v4[0])) - ASSERT(glm_eq(-v2[1], v4[1])) - ASSERT(glm_eq(-v2[2], v4[2])) + ASSERT(test_eq(-v2[0], v4[0])) + ASSERT(test_eq(-v2[1], v4[1])) + ASSERT(test_eq(-v2[2], v4[2])) TEST_SUCCESS } @@ -571,13 +571,13 @@ TEST_IMPL(GLM_PREFIX, vec3_negate) { GLM(vec3_negate)(v1); GLM(vec3_negate)(v2); - ASSERT(glm_eq(-v1[0], v3[0])) - ASSERT(glm_eq(-v1[1], v3[1])) - ASSERT(glm_eq(-v1[2], v3[2])) + ASSERT(test_eq(-v1[0], v3[0])) + ASSERT(test_eq(-v1[1], v3[1])) + ASSERT(test_eq(-v1[2], v3[2])) - ASSERT(glm_eq(-v2[0], v4[0])) - ASSERT(glm_eq(-v2[1], v4[1])) - ASSERT(glm_eq(-v2[2], v4[2])) + ASSERT(test_eq(-v2[0], v4[0])) + ASSERT(test_eq(-v2[1], v4[1])) + ASSERT(test_eq(-v2[2], v4[2])) TEST_SUCCESS } @@ -591,18 +591,18 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize) { norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); if (norm == 0.0f) { - ASSERT(glm_eq(v1[0], 0.0f)) - ASSERT(glm_eq(v1[1], 0.0f)) - ASSERT(glm_eq(v1[2], 0.0f)) + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) TEST_SUCCESS } norm = s / norm; - ASSERT(glm_eq(v1[0] * norm, v2[0])) - ASSERT(glm_eq(v1[1] * norm, v2[1])) - ASSERT(glm_eq(v1[2] * norm, v2[2])) + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) TEST_SUCCESS } @@ -616,18 +616,18 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize_to) { norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); if (norm == 0.0f) { - ASSERT(glm_eq(v1[0], 0.0f)) - ASSERT(glm_eq(v1[1], 0.0f)) - ASSERT(glm_eq(v1[2], 0.0f)) + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) TEST_SUCCESS } norm = s / norm; - ASSERT(glm_eq(v1[0] * norm, v2[0])) - ASSERT(glm_eq(v1[1] * norm, v2[1])) - ASSERT(glm_eq(v1[2] * norm, v2[2])) + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) TEST_SUCCESS } @@ -793,12 +793,12 @@ TEST_IMPL(GLM_PREFIX, vec3_max) { vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f}; - ASSERT(glm_eq(GLM(vec3_max)(v1), 2.104f)) - ASSERT(glm_eq(GLM(vec3_max)(v2), -12.35f)) + ASSERT(test_eq(GLM(vec3_max)(v1), 2.104f)) + ASSERT(test_eq(GLM(vec3_max)(v2), -12.35f)) ASSERT(isinf(GLM(vec3_max)(v3))) ASSERT(isnan(GLM(vec3_max)(v4))) ASSERT(isnan(GLM(vec3_max)(v5))) - ASSERT(glm_eq(GLM(vec3_max)(v6), 11.0f)) + ASSERT(test_eq(GLM(vec3_max)(v6), 11.0f)) TEST_SUCCESS } @@ -808,12 +808,12 @@ TEST_IMPL(GLM_PREFIX, vec3_min) { vec3 v3 = {INFINITY, 0.0f, 0.0f}, v4 = {NAN, INFINITY, 2.0f}; vec3 v5 = {NAN, -1.0f, -1.0f}, v6 = {-1.0f, -11.0f, 11.0f}; - ASSERT(glm_eq(GLM(vec3_min)(v1), -4.10f)) - ASSERT(glm_eq(GLM(vec3_min)(v2), -43.502f)) - ASSERT(glm_eq(GLM(vec3_min)(v3), 0.0f)) + ASSERT(test_eq(GLM(vec3_min)(v1), -4.10f)) + ASSERT(test_eq(GLM(vec3_min)(v2), -43.502f)) + ASSERT(test_eq(GLM(vec3_min)(v3), 0.0f)) ASSERT(isnan(GLM(vec3_min)(v4))) ASSERT(isnan(GLM(vec3_min)(v5))) - ASSERT(glm_eq(GLM(vec3_min)(v6), -11.0f)) + ASSERT(test_eq(GLM(vec3_min)(v6), -11.0f)) TEST_SUCCESS } @@ -914,8 +914,8 @@ TEST_IMPL(GLM_PREFIX, vec3_hadd) { r3 = v1[0] + v1[1] + v1[2]; r4 = v2[0] + v2[1] + v2[2]; - ASSERT(glm_eq(r1, r3)) - ASSERT(glm_eq(r2, r4)) + ASSERT(test_eq(r1, r3)) + ASSERT(test_eq(r2, r4)) TEST_SUCCESS } @@ -926,13 +926,13 @@ TEST_IMPL(GLM_PREFIX, vec3_sqrt) { GLM(vec3_sqrt)(v1, v3); GLM(vec3_sqrt)(v2, v4); - ASSERT(glm_eq(sqrtf(v1[0]), v3[0])) - ASSERT(glm_eq(sqrtf(v1[1]), v3[1])) - ASSERT(glm_eq(sqrtf(v1[2]), v3[2])) + ASSERT(test_eq(sqrtf(v1[0]), v3[0])) + ASSERT(test_eq(sqrtf(v1[1]), v3[1])) + ASSERT(test_eq(sqrtf(v1[2]), v3[2])) - ASSERT(glm_eq(sqrtf(v2[0]), v4[0])) - ASSERT(glm_eq(sqrtf(v2[1]), v4[1])) - ASSERT(glm_eq(sqrtf(v2[2]), v4[2])) + ASSERT(test_eq(sqrtf(v2[0]), v4[0])) + ASSERT(test_eq(sqrtf(v2[1]), v4[1])) + ASSERT(test_eq(sqrtf(v2[2]), v4[2])) TEST_SUCCESS } From bffe103c3751d22fa715cacf262da0d870c89e92 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 22 Sep 2019 22:27:28 +0300 Subject: [PATCH 036/103] tests: add more tests for vec3 (rotations) --- test/src/test_vec3.h | 202 +++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 13 ++- 2 files changed, 214 insertions(+), 1 deletion(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 3c4edfa..40a4978 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -664,6 +664,208 @@ TEST_IMPL(GLM_PREFIX, vec3_crossn) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec3_rotate) { + vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f}; + + /* rotate X around Y = -Z */ + GLM(vec3_rotate)(v1, GLM_PI_2, GLM_YUP); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + + /* rotate -Z around X = Y */ + GLM(vec3_rotate)(v1, GLM_PI_2, GLM_XUP); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate Y around Z = -X */ + GLM(vec3_rotate)(v1, GLM_PI_2, GLM_ZUP); + + ASSERT(test_eq(v1[0], -1.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate)(v2, GLM_PI_2, GLM_YUP); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], -1.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate)(v2, GLM_PI_2, GLM_YUP); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], -1.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate)(v2, GLM_PI_2, GLM_YUP); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + /* rotate v2 around X by 90deg */ + GLM(vec3_rotate)(v2, GLM_PI_2, GLM_XUP); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], -1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + /* rotate v2 around Z by 90deg */ + GLM(vec3_rotate)(v2, GLM_PI_2, GLM_ZUP); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], -1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_rotate_m4) { + vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f}; + mat4 x, y, z; + + glm_rotate_make(x, GLM_PI_2, GLM_XUP); + glm_rotate_make(y, GLM_PI_2, GLM_YUP); + glm_rotate_make(z, GLM_PI_2, GLM_ZUP); + + /* rotate X around Y = -Z */ + GLM(vec3_rotate_m4)(y, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + + /* rotate -Z around X = Y */ + GLM(vec3_rotate_m4)(x, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate Y around X = -X */ + GLM(vec3_rotate_m4)(z, v1, v1); + + ASSERT(test_eq(v1[0], -1.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate_m4)(y, v2, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], -1.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate_m4)(y, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], -1.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate_m4)(y, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + /* rotate v2 around X by 90deg */ + GLM(vec3_rotate_m4)(x, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], -1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + /* rotate v2 around Z by 90deg */ + GLM(vec3_rotate_m4)(z, v2, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], -1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + TEST_SUCCESS +} + + +TEST_IMPL(GLM_PREFIX, vec3_rotate_m3) { + vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f}; + mat4 x0, y0, z0; + mat3 x, y, z; + + glm_rotate_make(x0, GLM_PI_2, GLM_XUP); + glm_rotate_make(y0, GLM_PI_2, GLM_YUP); + glm_rotate_make(z0, GLM_PI_2, GLM_ZUP); + + glm_mat4_pick3(x0, x); + glm_mat4_pick3(y0, y); + glm_mat4_pick3(z0, z); + + /* rotate X around Y = -Z */ + GLM(vec3_rotate_m3)(y, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + + /* rotate -Z around X = Y */ + GLM(vec3_rotate_m3)(x, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate Y around Z = -X */ + GLM(vec3_rotate_m3)(z, v1, v1); + + ASSERT(test_eq(v1[0], -1.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate_m3)(y, v2, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], -1.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate_m3)(y, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], -1.0f)) + + /* rotate v2 around Y by 90deg */ + GLM(vec3_rotate_m3)(y, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + /* rotate v2 around X by 90deg */ + GLM(vec3_rotate_m3)(x, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], -1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + /* rotate v2 around Z by 90deg */ + GLM(vec3_rotate_m3)(z, v2, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], -1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_broadcast) { vec3 v1, v2, v3; vec3 v5 = {-1.456f, -1.456f, -1.456f}; diff --git a/test/tests.h b/test/tests.h index 23c5925..b933a5e 100644 --- a/test/tests.h +++ b/test/tests.h @@ -183,6 +183,9 @@ TEST_DECLARE(glm_vec3_normalize) TEST_DECLARE(glm_vec3_normalize_to) TEST_DECLARE(glm_vec3_cross) TEST_DECLARE(glm_vec3_crossn) +TEST_DECLARE(glm_vec3_rotate) +TEST_DECLARE(glm_vec3_rotate_m4) +TEST_DECLARE(glm_vec3_rotate_m3) TEST_DECLARE(glm_vec3_broadcast) TEST_DECLARE(glm_vec3_fill) @@ -232,6 +235,9 @@ TEST_DECLARE(glmc_vec3_normalize) TEST_DECLARE(glmc_vec3_normalize_to) TEST_DECLARE(glmc_vec3_cross) TEST_DECLARE(glmc_vec3_crossn) +TEST_DECLARE(glmc_vec3_rotate) +TEST_DECLARE(glmc_vec3_rotate_m4) +TEST_DECLARE(glmc_vec3_rotate_m3) TEST_DECLARE(glmc_vec3_broadcast) TEST_DECLARE(glmc_vec3_fill) @@ -427,6 +433,9 @@ TEST_LIST { TEST_ENTRY(glm_vec3_normalize_to) TEST_ENTRY(glm_vec3_cross) TEST_ENTRY(glm_vec3_crossn) + TEST_ENTRY(glm_vec3_rotate) + TEST_ENTRY(glm_vec3_rotate_m4) + TEST_ENTRY(glm_vec3_rotate_m3) TEST_ENTRY(glm_vec3_broadcast) TEST_ENTRY(glm_vec3_fill) @@ -476,7 +485,9 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_normalize_to) TEST_ENTRY(glmc_vec3_cross) TEST_ENTRY(glmc_vec3_crossn) - + TEST_ENTRY(glmc_vec3_rotate) + TEST_ENTRY(glmc_vec3_rotate_m4) + TEST_ENTRY(glmc_vec3_rotate_m3) TEST_ENTRY(glmc_vec3_broadcast) TEST_ENTRY(glmc_vec3_fill) From 7b25cbb9cb0fc0717a0e7161e92bbbe400e3cbb6 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 22 Sep 2019 23:25:33 +0300 Subject: [PATCH 037/103] vec: fix min/max for compiled vec3 --- src/vec3.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/vec3.c b/src/vec3.c index 4ce7112..a09a2ef 100644 --- a/src/vec3.c +++ b/src/vec3.c @@ -239,13 +239,13 @@ glmc_vec3_distance2(vec3 a, vec3 b) { CGLM_EXPORT void glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest) { - glm_vec3_minv(a, b, dest); + glm_vec3_maxv(a, b, dest); } CGLM_EXPORT void glmc_vec3_minv(vec3 a, vec3 b, vec3 dest) { - glm_vec3_maxv(a, b, dest); + glm_vec3_minv(a, b, dest); } CGLM_EXPORT From 378e26140e5c9761fe20214bbf9bcd2f19d6017f Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 22 Sep 2019 23:25:54 +0300 Subject: [PATCH 038/103] tests: add more tests for vec3 --- test/src/test_vec3.h | 146 +++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 20 ++++++ 2 files changed, 166 insertions(+) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 40a4978..411c172 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -664,6 +664,30 @@ TEST_IMPL(GLM_PREFIX, vec3_crossn) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec3_angle) { + vec3 v1 = {1.0f, 0.0f, 0.0f}, + v2 = {1.0f, 0.0f, 1.0f}, + v3 = {0.0f, 1.0f, 0.0f}; + float a; + + a = GLM(vec3_angle)(v1, v1); + ASSERT(!isinf(a)) + ASSERT(!isnan(a)) + ASSERT(test_eq(a, 0.0f)) + + a = GLM(vec3_angle)(v1, v2); + ASSERT(!isinf(a)) + ASSERT(!isnan(a)) + ASSERT(test_eq(a, GLM_PI_4)) + + a = GLM(vec3_angle)(v1, v3); + ASSERT(!isinf(a)) + ASSERT(!isnan(a)) + ASSERT(test_eq(a, GLM_PI_2)) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_rotate) { vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f}; @@ -866,6 +890,128 @@ TEST_IMPL(GLM_PREFIX, vec3_rotate_m3) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec3_proj) { + vec3 v1 = {3.0f, 4.0f, 0.0f}, + v2 = {10.0f, 0.0f, 0.0f}, + v3 = {0.0f, 10.0f, 0.0f}, + v4 = {3.0f, 0.0f, 0.0f}, + v5 = {0.0f, 4.0f, 0.0f}, + v6; + + GLM(vec3_proj)(v1, v2, v6); + ASSERTIFY(test_assert_vec3_eq(v4, v6)) + + GLM(vec3_proj)(v1, v3, v6); + ASSERTIFY(test_assert_vec3_eq(v5, v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_center) { + vec3 v1 = {30.0f, 0.0f, 0.0f}, + v2 = {0.0f, 0.0f, 0.0f}, + v3 = {15.0f, 0.0f, 0.0f}, + v4 = {3.0f, 10.0f, 120.0f}, + v5 = {0.46f, 4.0f, 14.0f}, + v6; + + GLM(vec3_center)(v1, v2, v6); + ASSERTIFY(test_assert_vec3_eq(v3, v6)) + + GLM(vec3_center)(v4, v5, v6); + ASSERT(test_eq((v4[0] + v5[0]) * 0.5f, v6[0])) + ASSERT(test_eq((v4[1] + v5[1]) * 0.5f, v6[1])) + ASSERT(test_eq((v4[2] + v5[2]) * 0.5f, v6[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_distance2) { + vec3 v1 = {30.0f, 0.0f, 0.0f}, + v2 = {0.0f, 0.0f, 0.0f}, + v3 = {3.0f, 10.0f, 120.0f}, + v4 = {0.46f, 4.0f, 14.0f}; + float d; + + d = GLM(vec3_distance2)(v1, v2); + ASSERT(test_eq(d, 30.0f)) + + d = GLM(vec3_distance2)(v3, v4); + ASSERT(test_eq(powf(v3[0] - v4[0], 2.0f) + + powf(v3[1] - v4[1], 2.0f) + + powf(v3[2] - v4[2], 2.0f), d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_distance) { + vec3 v1 = {30.0f, 0.0f, 0.0f}, + v2 = {0.0f, 0.0f, 0.0f}, + v3 = {3.0f, 10.0f, 120.0f}, + v4 = {0.46f, 4.0f, 14.0f}; + float d; + + d = GLM(vec3_distance)(v1, v2); + ASSERT(test_eq(d, 30.0f)) + + d = GLM(vec3_distance)(v3, v4); + ASSERT(test_eq(sqrtf(powf(v3[0] - v4[0], 2.0f) + + powf(v3[1] - v4[1], 2.0f) + + powf(v3[2] - v4[2], 2.0f)), d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_maxv) { + vec3 v1, v2, v3; + vec3 v5 = {-1.456f, -1.456f, 241.456f}; + vec3 v6 = {11.0f, 11.0f, 11.0f}; + vec3 v7 = {78.0f, -78.0f, 7.0f}; + + GLM(vec3_maxv)(v5, v6, v1); + GLM(vec3_maxv)(v5, v7, v2); + GLM(vec3_maxv)(v6, v7, v3); + + ASSERT(test_eq(v1[0], 11.0f)) + ASSERT(test_eq(v1[1], 11.0f)) + ASSERT(test_eq(v1[2], 241.456f)) + + ASSERT(test_eq(v2[0], 78.0f)) + ASSERT(test_eq(v2[1], -1.456f)) + ASSERT(test_eq(v2[2], 241.456f)) + + ASSERT(test_eq(v3[0], 78.0f)) + ASSERT(test_eq(v3[1], 11.0f)) + ASSERT(test_eq(v3[2], 11.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_minv) { + vec3 v1, v2, v3; + vec3 v5 = {-1.456f, -1.456f, 241.456f}; + vec3 v6 = {11.0f, 11.0f, 11.0f}; + vec3 v7 = {78.0f, -78.0f, 7.0f}; + + GLM(vec3_minv)(v5, v6, v1); + GLM(vec3_minv)(v5, v7, v2); + GLM(vec3_minv)(v6, v7, v3); + + ASSERT(test_eq(v1[0], -1.456f)) + ASSERT(test_eq(v1[1], -1.456f)) + ASSERT(test_eq(v1[2], 11.0f)) + + ASSERT(test_eq(v2[0], -1.456f)) + ASSERT(test_eq(v2[1], -78.0f)) + ASSERT(test_eq(v2[2], 7.0f)) + + ASSERT(test_eq(v3[0], 11.0f)) + ASSERT(test_eq(v3[1], -78.0f)) + ASSERT(test_eq(v3[2], 7.0f)) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_broadcast) { vec3 v1, v2, v3; vec3 v5 = {-1.456f, -1.456f, -1.456f}; diff --git a/test/tests.h b/test/tests.h index b933a5e..2c62f16 100644 --- a/test/tests.h +++ b/test/tests.h @@ -183,9 +183,14 @@ TEST_DECLARE(glm_vec3_normalize) TEST_DECLARE(glm_vec3_normalize_to) TEST_DECLARE(glm_vec3_cross) TEST_DECLARE(glm_vec3_crossn) +TEST_DECLARE(glm_vec3_angle) TEST_DECLARE(glm_vec3_rotate) TEST_DECLARE(glm_vec3_rotate_m4) TEST_DECLARE(glm_vec3_rotate_m3) +TEST_DECLARE(glm_vec3_proj) +TEST_DECLARE(glm_vec3_center) +TEST_DECLARE(glm_vec3_maxv) +TEST_DECLARE(glm_vec3_minv) TEST_DECLARE(glm_vec3_broadcast) TEST_DECLARE(glm_vec3_fill) @@ -235,9 +240,14 @@ TEST_DECLARE(glmc_vec3_normalize) TEST_DECLARE(glmc_vec3_normalize_to) TEST_DECLARE(glmc_vec3_cross) TEST_DECLARE(glmc_vec3_crossn) +TEST_DECLARE(glmc_vec3_angle) TEST_DECLARE(glmc_vec3_rotate) TEST_DECLARE(glmc_vec3_rotate_m4) TEST_DECLARE(glmc_vec3_rotate_m3) +TEST_DECLARE(glmc_vec3_proj) +TEST_DECLARE(glmc_vec3_center) +TEST_DECLARE(glmc_vec3_maxv) +TEST_DECLARE(glmc_vec3_minv) TEST_DECLARE(glmc_vec3_broadcast) TEST_DECLARE(glmc_vec3_fill) @@ -433,9 +443,14 @@ TEST_LIST { TEST_ENTRY(glm_vec3_normalize_to) TEST_ENTRY(glm_vec3_cross) TEST_ENTRY(glm_vec3_crossn) + TEST_ENTRY(glm_vec3_angle) TEST_ENTRY(glm_vec3_rotate) TEST_ENTRY(glm_vec3_rotate_m4) TEST_ENTRY(glm_vec3_rotate_m3) + TEST_ENTRY(glm_vec3_proj) + TEST_ENTRY(glm_vec3_center) + TEST_ENTRY(glm_vec3_maxv) + TEST_ENTRY(glm_vec3_minv) TEST_ENTRY(glm_vec3_broadcast) TEST_ENTRY(glm_vec3_fill) @@ -485,9 +500,14 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_normalize_to) TEST_ENTRY(glmc_vec3_cross) TEST_ENTRY(glmc_vec3_crossn) + TEST_ENTRY(glmc_vec3_angle) TEST_ENTRY(glmc_vec3_rotate) TEST_ENTRY(glmc_vec3_rotate_m4) TEST_ENTRY(glmc_vec3_rotate_m3) + TEST_ENTRY(glmc_vec3_proj) + TEST_ENTRY(glmc_vec3_center) + TEST_ENTRY(glmc_vec3_maxv) + TEST_ENTRY(glmc_vec3_minv) TEST_ENTRY(glmc_vec3_broadcast) TEST_ENTRY(glmc_vec3_fill) From 3a48e4cd84302af2771676a4999426bb0950c74d Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 22 Sep 2019 23:32:57 +0300 Subject: [PATCH 039/103] tests: add more tests for vec3 --- test/src/test_vec3.h | 2 +- test/tests.h | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 411c172..3a65866 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -934,7 +934,7 @@ TEST_IMPL(GLM_PREFIX, vec3_distance2) { float d; d = GLM(vec3_distance2)(v1, v2); - ASSERT(test_eq(d, 30.0f)) + ASSERT(test_eq(d, 30.0f * 30.0f)) d = GLM(vec3_distance2)(v3, v4); ASSERT(test_eq(powf(v3[0] - v4[0], 2.0f) diff --git a/test/tests.h b/test/tests.h index 2c62f16..d85de1c 100644 --- a/test/tests.h +++ b/test/tests.h @@ -189,6 +189,8 @@ TEST_DECLARE(glm_vec3_rotate_m4) TEST_DECLARE(glm_vec3_rotate_m3) TEST_DECLARE(glm_vec3_proj) TEST_DECLARE(glm_vec3_center) +TEST_DECLARE(glm_vec3_distance2) +TEST_DECLARE(glm_vec3_distance) TEST_DECLARE(glm_vec3_maxv) TEST_DECLARE(glm_vec3_minv) @@ -246,6 +248,8 @@ TEST_DECLARE(glmc_vec3_rotate_m4) TEST_DECLARE(glmc_vec3_rotate_m3) TEST_DECLARE(glmc_vec3_proj) TEST_DECLARE(glmc_vec3_center) +TEST_DECLARE(glmc_vec3_distance2) +TEST_DECLARE(glmc_vec3_distance) TEST_DECLARE(glmc_vec3_maxv) TEST_DECLARE(glmc_vec3_minv) @@ -449,6 +453,8 @@ TEST_LIST { TEST_ENTRY(glm_vec3_rotate_m3) TEST_ENTRY(glm_vec3_proj) TEST_ENTRY(glm_vec3_center) + TEST_ENTRY(glmc_vec3_distance2) + TEST_ENTRY(glmc_vec3_distance) TEST_ENTRY(glm_vec3_maxv) TEST_ENTRY(glm_vec3_minv) @@ -506,6 +512,8 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_rotate_m3) TEST_ENTRY(glmc_vec3_proj) TEST_ENTRY(glmc_vec3_center) + TEST_ENTRY(glmc_vec3_distance2) + TEST_ENTRY(glmc_vec3_distance) TEST_ENTRY(glmc_vec3_maxv) TEST_ENTRY(glmc_vec3_minv) From 37c2650b0a3f4482105d279409c0aaa2febb3285 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 23 Sep 2019 12:03:06 +0300 Subject: [PATCH 040/103] tests: add more tests for vec3 --- test/src/test_vec3.h | 147 +++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 16 +++++ 2 files changed, 163 insertions(+) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 3a65866..310f0a5 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -1012,6 +1012,153 @@ TEST_IMPL(GLM_PREFIX, vec3_minv) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec3_ortho) { + vec3 v1, v2, v3; + vec3 v5, v6, v7; + float a; + + test_rand_vec3(v1); + test_rand_vec3(v2); + test_rand_vec3(v3); + + GLM(vec3_ortho)(v1, v5); + GLM(vec3_ortho)(v2, v6); + GLM(vec3_ortho)(v3, v7); + + a = glm_vec3_angle(v1, v5); + ASSERT(!isinf(a)) + ASSERT(!isnan(a)) + ASSERT(test_eq(a, GLM_PI_2)) + + a = glm_vec3_angle(v2, v6); + ASSERT(!isinf(a)) + ASSERT(!isnan(a)) + ASSERT(test_eq(a, GLM_PI_2)) + + a = glm_vec3_angle(v3, v7); + ASSERT(!isinf(a)) + ASSERT(!isnan(a)) + ASSERT(test_eq(a, GLM_PI_2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_clamp) { + vec3 v1 = {-1.456f, -11.456f, 31.456f}; + vec3 v2 = {0.110f, 111.0f, 11.0f}; + vec3 v3 = {78.0f, 32.0f, -78.0f}; + + GLM(vec3_clamp)(v1, -1.03f, 30.0f); + GLM(vec3_clamp)(v2, 0.11f, 111.0f); + GLM(vec3_clamp)(v3, -88.0f, 70.0f); + + ASSERT(test_eq(v1[0], -1.03f)) + ASSERT(test_eq(v1[1], -1.03f)) + ASSERT(test_eq(v1[2], 30.0f)) + + ASSERT(test_eq(v2[0], 0.11f)) + ASSERT(test_eq(v2[1], 111.0f)) + ASSERT(test_eq(v2[2], 11.0f)) + + ASSERT(test_eq(v3[0], 70.0f)) + ASSERT(test_eq(v3[1], 32.0f)) + ASSERT(test_eq(v3[2], -78.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_lerp) { + vec3 v1 = {-100.0f, -200.0f, -10.0f}; + vec3 v2 = {100.0f, 200.0f, 10.0f}; + vec3 v3; + + GLM(vec3_lerp)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + + GLM(vec3_lerp)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.03f)) + ASSERT(test_eq(v3[2], 5.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_lerpc) { + vec3 v1 = {-100.0f, -200.0f, -10.0f}; + vec3 v2 = {100.0f, 200.0f, 10.0f}; + vec3 v3; + + GLM(vec3_lerpc)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + + GLM(vec3_lerpc)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.03f)) + ASSERT(test_eq(v3[2], 5.0f)) + + GLM(vec3_lerpc)(v1, v2, -1.75f, v3); + ASSERT(test_eq(v3[0], -100.0f)) + ASSERT(test_eq(v3[1], -200.0f)) + ASSERT(test_eq(v3[2], -10.0f)) + + GLM(vec3_lerpc)(v1, v2, 1.75f, v3); + ASSERT(test_eq(v3[0], 100.0f)) + ASSERT(test_eq(v3[1], 200.0f)) + ASSERT(test_eq(v3[2], 10.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_mix) { + vec3 v1 = {-100.0f, -200.0f, -10.0f}; + vec3 v2 = {100.0f, 200.0f, 10.0f}; + vec3 v3; + + GLM(vec3_mix)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + + GLM(vec3_mix)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.0f)) + ASSERT(test_eq(v3[2], 5.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_mixc) { + vec3 v1 = {-100.0f, -200.0f, -10.0f}; + vec3 v2 = {100.0f, 200.0f, 10.0f}; + vec3 v3; + + GLM(vec3_mixc)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + + GLM(vec3_mixc)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.0f)) + ASSERT(test_eq(v3[2], 5.0f)) + + GLM(vec3_mixc)(v1, v2, -1.75f, v3); + ASSERT(test_eq(v3[0], -100.0f)) + ASSERT(test_eq(v3[1], -200.0f)) + ASSERT(test_eq(v3[2], -10.0f)) + + GLM(vec3_mixc)(v1, v2, 1.75f, v3); + ASSERT(test_eq(v3[0], 100.0f)) + ASSERT(test_eq(v3[1], 200.0f)) + ASSERT(test_eq(v3[2], 10.0f)) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_broadcast) { vec3 v1, v2, v3; vec3 v5 = {-1.456f, -1.456f, -1.456f}; diff --git a/test/tests.h b/test/tests.h index d85de1c..5e6fc79 100644 --- a/test/tests.h +++ b/test/tests.h @@ -193,6 +193,10 @@ TEST_DECLARE(glm_vec3_distance2) TEST_DECLARE(glm_vec3_distance) TEST_DECLARE(glm_vec3_maxv) TEST_DECLARE(glm_vec3_minv) +TEST_DECLARE(glm_vec3_ortho) +TEST_DECLARE(glm_vec3_clamp) +TEST_DECLARE(glm_vec3_mix) +TEST_DECLARE(glm_vec3_mixc) TEST_DECLARE(glm_vec3_broadcast) TEST_DECLARE(glm_vec3_fill) @@ -252,6 +256,10 @@ TEST_DECLARE(glmc_vec3_distance2) TEST_DECLARE(glmc_vec3_distance) TEST_DECLARE(glmc_vec3_maxv) TEST_DECLARE(glmc_vec3_minv) +TEST_DECLARE(glmc_vec3_ortho) +TEST_DECLARE(glmc_vec3_clamp) +TEST_DECLARE(glmc_vec3_mix) +TEST_DECLARE(glmc_vec3_mixc) TEST_DECLARE(glmc_vec3_broadcast) TEST_DECLARE(glmc_vec3_fill) @@ -457,6 +465,10 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_distance) TEST_ENTRY(glm_vec3_maxv) TEST_ENTRY(glm_vec3_minv) + TEST_ENTRY(glm_vec3_ortho) + TEST_ENTRY(glm_vec3_clamp) + TEST_ENTRY(glm_vec3_mix) + TEST_ENTRY(glm_vec3_mixc) TEST_ENTRY(glm_vec3_broadcast) TEST_ENTRY(glm_vec3_fill) @@ -516,6 +528,10 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_distance) TEST_ENTRY(glmc_vec3_maxv) TEST_ENTRY(glmc_vec3_minv) + TEST_ENTRY(glmc_vec3_ortho) + TEST_ENTRY(glmc_vec3_clamp) + TEST_ENTRY(glmc_vec3_mix) + TEST_ENTRY(glmc_vec3_mixc) TEST_ENTRY(glmc_vec3_broadcast) TEST_ENTRY(glmc_vec3_fill) From 7c10840a85333a6403b565a3c0ca94476467c548 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 23 Sep 2019 22:39:53 +0300 Subject: [PATCH 041/103] tests: add more tests for vec3 --- include/cglm/vec3.h | 42 +++---- test/src/test_common.h | 6 + test/src/test_vec3.h | 269 +++++++++++++++++++++++++++++++++++++++++ test/tests.h | 39 +++++- 4 files changed, 332 insertions(+), 24 deletions(-) diff --git a/include/cglm/vec3.h b/include/cglm/vec3.h index 2bb6231..0340e96 100644 --- a/include/cglm/vec3.h +++ b/include/cglm/vec3.h @@ -996,6 +996,27 @@ glm_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest) { glm_vec3_smoothinterp(from, to, glm_clamp_zo(t), dest); } +/*! + * @brief swizzle vector components + * + * you can use existin masks e.g. GLM_XXX, GLM_ZYX + * + * @param[in] v source + * @param[in] mask mask + * @param[out] dest destination + */ +CGLM_INLINE +void +glm_vec3_swizzle(vec3 v, int mask, vec3 dest) { + vec3 t; + + t[0] = v[(mask & (3 << 0))]; + t[1] = v[(mask & (3 << 2)) >> 2]; + t[2] = v[(mask & (3 << 4)) >> 4]; + + glm_vec3_copy(t, dest); +} + /*! * @brief vec3 cross product * @@ -1054,25 +1075,4 @@ glm_normalize_to(vec3 v, vec3 dest) { glm_vec3_normalize_to(v, dest); } -/*! - * @brief swizzle vector components - * - * you can use existin masks e.g. GLM_XXX, GLM_ZYX - * - * @param[in] v source - * @param[in] mask mask - * @param[out] dest destination - */ -CGLM_INLINE -void -glm_vec3_swizzle(vec3 v, int mask, vec3 dest) { - vec3 t; - - t[0] = v[(mask & (3 << 0))]; - t[1] = v[(mask & (3 << 2)) >> 2]; - t[2] = v[(mask & (3 << 4)) >> 4]; - - glm_vec3_copy(t, dest); -} - #endif /* cglm_vec3_h */ diff --git a/test/src/test_common.h b/test/src/test_common.h index a3dee7b..a5c4bb6 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -88,4 +88,10 @@ test_eq(float a, float b) { return fabsf(a - b) <= 1e-6; } +CGLM_INLINE +bool +test_eq_th(float a, float b, float th) { + return fabsf(a - b) <= th; +} + #endif /* test_common_h */ diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 310f0a5..9715515 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -256,6 +256,22 @@ TEST_IMPL(GLM_PREFIX, vec3_dot) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, dot) { + /* SAME AS VEC3_DOT */ + + vec3 a = {10.0f, 9.0f, 8.0f}; + vec3 b = {1.0f, 2.0f, 3.0f}; + float dot1, dot2; + + dot1 = GLM(vec3_dot)(a, b); + dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; + + ASSERT(test_eq(dot1, dot2)) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_norm2) { vec3 a = {10.0f, 9.0f, 8.0f}; float n1, n2; @@ -632,6 +648,60 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize_to) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, normalize) { + /* SAME AS VEC3_NORMALIZE */ + + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {2.0f, -3.0f, 4.0f}; + float s = 1.0f; + float norm; + + GLM(vec3_normalize)(v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); + if (norm == 0.0f) { + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, normalize_to) { + /* SAME AS VEC3_NORMALIZE_TO */ + + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2; + float s = 1.0f; + float norm; + + GLM(vec3_normalize_to)(v1, v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); + if (norm == 0.0f) { + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_cross) { /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */ vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; @@ -664,6 +734,23 @@ TEST_IMPL(GLM_PREFIX, vec3_crossn) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, cross) { + /* SAME AS VEC3_CROSS */ + + /* (u2.v3 - u3.v2, u3.v1 - u1.v3, u1.v2 - u2.v1) */ + vec3 v1 = {2.0f, -3.0f, 4.0f}, v2 = {12.0f, -31.0f, 43.0f}, v3, v4; + + GLM(vec3_cross)(v1, v2, v3); + + v4[0] = v1[1] * v2[2] - v1[2] * v2[1]; + v4[1] = v1[2] * v2[0] - v1[0] * v2[2]; + v4[2] = v1[0] * v2[1] - v1[1] * v2[0]; + + ASSERTIFY(test_assert_vec3_eq(v3, v4)) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_angle) { vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 0.0f, 1.0f}, @@ -1159,6 +1246,188 @@ TEST_IMPL(GLM_PREFIX, vec3_mixc) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec3_step_uni) { + vec3 v1 = {-100.0f, -200.0f, -10.0f}; + vec3 v2; + + GLM(vec3_step_uni)(-2.5f, v1, v2); + ASSERT(test_eq(v2[0], 0.0f)) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(test_eq(v2[2], 0.0f)) + + GLM(vec3_step_uni)(-10.0f, v1, v2); + ASSERT(test_eq(v2[0], 0.0f)) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + GLM(vec3_step_uni)(-1000.0f, v1, v2); + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_step) { + vec3 v1 = {-100.0f, -200.0f, -10.0f}; + vec3 s1 = {-100.0f, 0.0f, 10.0f}; + vec3 s2 = {100.0f, -220.0f, -10.0f}; + vec3 s3 = {100.0f, 200.0f, 10.0f}; + vec3 v2; + + GLM(vec3_step)(s1, v1, v2); + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(test_eq(v2[2], 0.0f)) + + GLM(vec3_step)(s2, v1, v2); + ASSERT(test_eq(v2[0], 0.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + GLM(vec3_step)(s3, v1, v2); + ASSERT(test_eq(v2[0], 0.0f)) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(test_eq(v2[2], 0.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_smoothstep_uni) { + vec3 v1 = {-100.0f, -200.0f, -10.0f}; + vec3 v2; + + GLM(vec3_smoothstep_uni)(-200.0f, -100.0f, v1, v2); + ASSERT(test_eq_th(v2[0], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + + GLM(vec3_smoothstep_uni)(-250.0f, -200.0f, v1, v2); + ASSERT(test_eq_th(v2[0], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[1], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + + GLM(vec3_smoothstep_uni)(-200.0f, 200, v1, v2); + ASSERT(v2[0] > 0.0f && v2[0] < 0.25f) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(v2[2] > 0.0f && v2[2] < 0.5f) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_smoothstep) { + vec3 v1 = {-100.0f, -200.0f, -10.0f}; + vec3 e1_0 = {-100.0f, 0.0f, -11.0f}; + vec3 e1_1 = {50.0f, 10.0f, 20.0f}; + vec3 e2_0 = {-180.0f, -300.0f, -93.0f}; + vec3 e2_1 = {100.0f, 120.0f, -10.0f}; + vec3 e3_0 = {-12.0f, 100.0f, 0.0f}; + vec3 e3_1 = {100.0f, 200.0f, 10.0f}; + vec3 v2; + + GLM(vec3_smoothstep)(e1_0, e1_1, v1, v2); + ASSERT(test_eq_th(v2[0], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) + ASSERT(v2[2] > 0.0f && v2[2] < 0.1f) + + GLM(vec3_smoothstep)(e2_0, e2_1, v1, v2); + ASSERT(v2[0] > 0.0f && v2[0] < 0.25f) + ASSERT(v2[1] > 0.0f && v2[1] < 0.15f) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + + GLM(vec3_smoothstep)(e3_0, e3_1, v1, v2); + ASSERT(test_eq_th(v2[0], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[2], 0.0f, 1e-5)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_smoothinterp) { + vec3 e1_0 = {-100.0f, 0.0f, -11.0f}; + vec3 e1_1 = {50.0f, 10.0f, 20.0f}; + vec3 e2_0 = {80.0f, -220.0f, -19.0f}; + vec3 e2_1 = {100.0f, -200.0f, -10.0f}; + vec3 e3_0 = {-12.0f, 100.0f, 0.0f}; + vec3 e3_1 = {100.0f, 200.0f, 10.0f}; + vec3 v2; + + GLM(vec3_smoothinterp)(e1_0, e1_1, 0.5, v2); + ASSERT(v2[0] >= e1_0[0] && v2[0] <= e1_1[0]) + ASSERT(v2[1] >= e1_0[1] && v2[1] <= e1_1[1]) + ASSERT(v2[2] >= e1_0[2] && v2[2] <= e1_1[2]) + + GLM(vec3_smoothinterp)(e2_0, e2_1, 0.5, v2); + ASSERT(v2[0] >= e2_0[0] && v2[0] <= e2_1[0]) + ASSERT(v2[1] >= e2_0[1] && v2[1] <= e2_1[1]) + ASSERT(v2[2] >= e2_0[2] && v2[2] <= e2_1[2]) + + GLM(vec3_smoothinterp)(e3_0, e3_1, 1.0, v2); + ASSERT(v2[0] >= e3_0[0] && v2[0] <= e3_1[0]) + ASSERT(v2[1] >= e3_0[1] && v2[1] <= e3_1[1]) + ASSERT(v2[2] >= e3_0[2] && v2[2] <= e3_1[2]) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_smoothinterpc) { + vec3 e1_0 = {-100.0f, 0.0f, -11.0f}; + vec3 e1_1 = {50.0f, 10.0f, 20.0f}; + vec3 e2_0 = {80.0f, -220.0f, -19.0f}; + vec3 e2_1 = {100.0f, -200.0f, -10.0f}; + vec3 e3_0 = {-12.0f, 100.0f, 0.0f}; + vec3 e3_1 = {100.0f, 200.0f, 10.0f}; + vec3 v2; + + GLM(vec3_smoothinterpc)(e1_0, e1_1, -0.5, v2); + ASSERT(v2[0] >= e1_0[0] && v2[0] <= e1_1[0]) + ASSERT(v2[1] >= e1_0[1] && v2[1] <= e1_1[1]) + ASSERT(v2[2] >= e1_0[2] && v2[2] <= e1_1[2]) + + GLM(vec3_smoothinterpc)(e2_0, e2_1, 0.5, v2); + ASSERT(v2[0] >= e2_0[0] && v2[0] <= e2_1[0]) + ASSERT(v2[1] >= e2_0[1] && v2[1] <= e2_1[1]) + ASSERT(v2[2] >= e2_0[2] && v2[2] <= e2_1[2]) + + GLM(vec3_smoothinterpc)(e3_0, e3_1, 2.0, v2); + ASSERT(v2[0] >= e3_0[0] && v2[0] <= e3_1[0]) + ASSERT(v2[1] >= e3_0[1] && v2[1] <= e3_1[1]) + ASSERT(v2[2] >= e3_0[2] && v2[2] <= e3_1[2]) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec3_swizzle) { + vec3 v; + + /* ZYX */ + v[0] = 1; + v[1] = 2; + v[2] = 3; + + glm_vec3_swizzle(v, GLM_ZYX, v); + ASSERTIFY(test_assert_vec3_eq(v, (vec3){3, 2, 1})) + + glm_vec3_swizzle(v, GLM_XXX, v); + ASSERTIFY(test_assert_vec3_eq(v, (vec3){3, 3, 3})) + + v[0] = 1; + v[1] = 2; + v[2] = 3; + + glm_vec3_swizzle(v, GLM_YYY, v); + ASSERTIFY(test_assert_vec3_eq(v, (vec3){2, 2, 2})) + + v[0] = 1; + v[1] = 2; + v[2] = 3; + + glm_vec3_swizzle(v, GLM_ZZZ, v); + ASSERTIFY(test_assert_vec3_eq(v, (vec3){3, 3, 3})) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec3_broadcast) { vec3 v1, v2, v3; vec3 v5 = {-1.456f, -1.456f, -1.456f}; diff --git a/test/tests.h b/test/tests.h index 5e6fc79..903f6fb 100644 --- a/test/tests.h +++ b/test/tests.h @@ -158,6 +158,7 @@ TEST_DECLARE(glm_vec3_copy) TEST_DECLARE(glm_vec3_zero) TEST_DECLARE(glm_vec3_one) TEST_DECLARE(glm_vec3_dot) +TEST_DECLARE(glm_dot) TEST_DECLARE(glm_vec3_norm2) TEST_DECLARE(glm_vec3_norm) TEST_DECLARE(glm_vec3_norm_one) @@ -181,8 +182,11 @@ TEST_DECLARE(glm_vec3_negate_to) TEST_DECLARE(glm_vec3_negate) TEST_DECLARE(glm_vec3_normalize) TEST_DECLARE(glm_vec3_normalize_to) +TEST_DECLARE(glm_normalize) +TEST_DECLARE(glm_normalize_to) TEST_DECLARE(glm_vec3_cross) TEST_DECLARE(glm_vec3_crossn) +TEST_DECLARE(glm_cross) TEST_DECLARE(glm_vec3_angle) TEST_DECLARE(glm_vec3_rotate) TEST_DECLARE(glm_vec3_rotate_m4) @@ -197,7 +201,13 @@ TEST_DECLARE(glm_vec3_ortho) TEST_DECLARE(glm_vec3_clamp) TEST_DECLARE(glm_vec3_mix) TEST_DECLARE(glm_vec3_mixc) - +TEST_DECLARE(glm_vec3_step_uni) +TEST_DECLARE(glm_vec3_step) +TEST_DECLARE(glm_vec3_smoothstep_uni) +TEST_DECLARE(glm_vec3_smoothstep) +TEST_DECLARE(glm_vec3_smoothinterp) +TEST_DECLARE(glm_vec3_smoothinterpc) +TEST_DECLARE(glm_vec3_swizzle) TEST_DECLARE(glm_vec3_broadcast) TEST_DECLARE(glm_vec3_fill) TEST_DECLARE(glm_vec3_eq) @@ -260,6 +270,13 @@ TEST_DECLARE(glmc_vec3_ortho) TEST_DECLARE(glmc_vec3_clamp) TEST_DECLARE(glmc_vec3_mix) TEST_DECLARE(glmc_vec3_mixc) +TEST_DECLARE(glmc_vec3_step_uni) +TEST_DECLARE(glmc_vec3_step) +TEST_DECLARE(glmc_vec3_smoothstep_uni) +TEST_DECLARE(glmc_vec3_smoothstep) +TEST_DECLARE(glmc_vec3_smoothinterp) +TEST_DECLARE(glmc_vec3_smoothinterpc) +TEST_DECLARE(glmc_vec3_swizzle) TEST_DECLARE(glmc_vec3_broadcast) TEST_DECLARE(glmc_vec3_fill) @@ -430,6 +447,7 @@ TEST_LIST { TEST_ENTRY(glm_vec3_zero) TEST_ENTRY(glm_vec3_one) TEST_ENTRY(glm_vec3_dot) + TEST_ENTRY(glm_dot) TEST_ENTRY(glm_vec3_norm2) TEST_ENTRY(glm_vec3_norm) TEST_ENTRY(glm_vec3_norm_one) @@ -453,8 +471,11 @@ TEST_LIST { TEST_ENTRY(glm_vec3_negate) TEST_ENTRY(glm_vec3_normalize) TEST_ENTRY(glm_vec3_normalize_to) + TEST_ENTRY(glm_normalize) + TEST_ENTRY(glm_normalize_to) TEST_ENTRY(glm_vec3_cross) TEST_ENTRY(glm_vec3_crossn) + TEST_ENTRY(glm_cross) TEST_ENTRY(glm_vec3_angle) TEST_ENTRY(glm_vec3_rotate) TEST_ENTRY(glm_vec3_rotate_m4) @@ -469,7 +490,13 @@ TEST_LIST { TEST_ENTRY(glm_vec3_clamp) TEST_ENTRY(glm_vec3_mix) TEST_ENTRY(glm_vec3_mixc) - + TEST_ENTRY(glm_vec3_step_uni) + TEST_ENTRY(glm_vec3_step) + TEST_ENTRY(glm_vec3_smoothstep_uni) + TEST_ENTRY(glm_vec3_smoothstep) + TEST_ENTRY(glm_vec3_smoothinterp) + TEST_ENTRY(glm_vec3_smoothinterpc) + TEST_ENTRY(glm_vec3_swizzle) TEST_ENTRY(glm_vec3_broadcast) TEST_ENTRY(glm_vec3_fill) TEST_ENTRY(glm_vec3_eq) @@ -532,7 +559,13 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_clamp) TEST_ENTRY(glmc_vec3_mix) TEST_ENTRY(glmc_vec3_mixc) - + TEST_ENTRY(glmc_vec3_step_uni) + TEST_ENTRY(glmc_vec3_step) + TEST_ENTRY(glmc_vec3_smoothstep_uni) + TEST_ENTRY(glmc_vec3_smoothstep) + TEST_ENTRY(glmc_vec3_smoothinterp) + TEST_ENTRY(glmc_vec3_smoothinterpc) + TEST_ENTRY(glmc_vec3_swizzle) TEST_ENTRY(glmc_vec3_broadcast) TEST_ENTRY(glmc_vec3_fill) TEST_ENTRY(glmc_vec3_eq) From f2073b2277edc384659680dcddd622b7654acebf Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 23 Sep 2019 22:46:45 +0300 Subject: [PATCH 042/103] tests: add more tests for vec3 --- test/src/test_vec3.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 9715515..636af5f 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -620,6 +620,10 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize) { ASSERT(test_eq(v1[1] * norm, v2[1])) ASSERT(test_eq(v1[2] * norm, v2[2])) + glm_vec3_zero(v1); + GLM(vec3_normalize)(v1); + ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO)) + TEST_SUCCESS } @@ -645,6 +649,10 @@ TEST_IMPL(GLM_PREFIX, vec3_normalize_to) { ASSERT(test_eq(v1[1] * norm, v2[1])) ASSERT(test_eq(v1[2] * norm, v2[2])) + glm_vec3_zero(v1); + GLM(vec3_normalize_to)(v1, v2); + ASSERTIFY(test_assert_vec3_eq(v2, GLM_VEC3_ZERO)) + TEST_SUCCESS } @@ -672,6 +680,10 @@ TEST_IMPL(GLM_PREFIX, normalize) { ASSERT(test_eq(v1[1] * norm, v2[1])) ASSERT(test_eq(v1[2] * norm, v2[2])) + glm_vec3_zero(v1); + GLM(vec3_normalize)(v1); + ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO)) + TEST_SUCCESS } @@ -699,6 +711,10 @@ TEST_IMPL(GLM_PREFIX, normalize_to) { ASSERT(test_eq(v1[1] * norm, v2[1])) ASSERT(test_eq(v1[2] * norm, v2[2])) + glm_vec3_zero(v1); + GLM(vec3_normalize_to)(v1, v2); + ASSERTIFY(test_assert_vec3_eq(v2, GLM_VEC3_ZERO)) + TEST_SUCCESS } From ce09e543ef6cd3a436f46c1ef6b52df16ccb054a Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Tue, 24 Sep 2019 16:33:42 +0300 Subject: [PATCH 043/103] tests: add some tests for vec4 --- test/src/test_vec3.h | 4 +- test/src/test_vec4.c | 230 +-------------- test/src/test_vec4.h | 660 +++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 159 ++++++++++- 4 files changed, 829 insertions(+), 224 deletions(-) create mode 100644 test/src/test_vec4.h diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 636af5f..a60ddf7 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -315,10 +315,10 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_inf) { n1 = GLM(vec3_norm_inf)(a); n2 = fabsf(a[0]); - if (fabsf(a[0]) < fabsf(a[1])) + if (n2 < fabsf(a[1])) n2 = fabsf(a[1]); - if (fabsf(a[1]) < fabsf(a[2])) + if (n2 < fabsf(a[2])) n2 = fabsf(a[2]); ASSERT(test_eq(n1, n2)) diff --git a/test/src/test_vec4.c b/test/src/test_vec4.c index 160f1e7..5e0b019 100644 --- a/test/src/test_vec4.c +++ b/test/src/test_vec4.c @@ -5,228 +5,22 @@ * Full license can be found in the LICENSE file */ -#include "test_common.h" +/* test inline mat3 */ -CGLM_INLINE -float -test_vec4_dot(vec4 a, vec4 b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; -} +#define GLM_PREFIX glm_ +#define GLM(X) (glm_ ## X) -CGLM_INLINE -void -test_vec4_normalize_to(vec4 vec, vec4 dest) { - float norm; +#include "test_vec4.h" - norm = glm_vec4_norm(vec); +#undef GLM +#undef GLM_PREFIX - if (norm == 0.0f) { - dest[0] = dest[1] = dest[2] = dest[3] = 0.0f; - return; - } +/* test pre-compiled mat3 */ - glm_vec4_scale(vec, 1.0f / norm, dest); -} +#define GLM_PREFIX glmc_ +#define GLM(X) (glmc_ ## X) -float -test_vec4_norm2(vec4 vec) { - return test_vec4_dot(vec, vec); -} +#include "test_vec4.h" -float -test_vec4_norm(vec4 vec) { - return sqrtf(test_vec4_dot(vec, vec)); -} - -void -test_vec4_maxv(vec4 v1, vec4 v2, vec4 dest) { - dest[0] = glm_max(v1[0], v2[0]); - dest[1] = glm_max(v1[1], v2[1]); - dest[2] = glm_max(v1[2], v2[2]); - dest[3] = glm_max(v1[3], v2[3]); -} - -void -test_vec4_minv(vec4 v1, vec4 v2, vec4 dest) { - dest[0] = glm_min(v1[0], v2[0]); - dest[1] = glm_min(v1[1], v2[1]); - dest[2] = glm_min(v1[2], v2[2]); - dest[3] = glm_min(v1[3], v2[3]); -} - -void -test_vec4_clamp(vec4 v, float minVal, float maxVal) { - v[0] = glm_clamp(v[0], minVal, maxVal); - v[1] = glm_clamp(v[1], minVal, maxVal); - v[2] = glm_clamp(v[2], minVal, maxVal); - v[3] = glm_clamp(v[3], minVal, maxVal); -} - -TEST_IMPL(vec4) { - vec4 v, v1, v2, v3, v4, one, zero; - vec4s vs1, vs2, vs3, vs4; - int i; - float d1, d2; - - glm_vec4_one(one); - glm_vec4_zero(zero); - - for (i = 0; i < 1000; i++) { - /* 1. test SSE/SIMD dot product */ - test_rand_vec4(v); - d1 = glm_vec4_dot(v, v); - d2 = test_vec4_dot(v, v); - - ASSERT(fabsf(d1 - d2) <= 0.000009) - - /* 2. test SIMD normalize */ - test_vec4_normalize_to(v, v1); - glm_vec4_normalize_to(v, v2); - glm_vec4_normalize(v); - - /* all must be same */ - test_assert_vec4_eq(v1, v2); - test_assert_vec4_eq(v, v2); - - /* 3. test SIMD norm */ - test_rand_vec4(v); - test_assert_eqf(test_vec4_norm(v), glm_vec4_norm(v)); - - /* 3. test SIMD norm2 */ - test_rand_vec4(v); - test_assert_eqf(test_vec4_norm2(v), glm_vec4_norm2(v)); - - /* 4. test SSE/SIMD distance */ - test_rand_vec4(v1); - test_rand_vec4(v2); - d1 = glm_vec4_distance(v1, v2); - d2 = sqrtf(powf(v1[0] - v2[0], 2.0f) - + powf(v1[1] - v2[1], 2.0f) - + powf(v1[2] - v2[2], 2.0f) - + powf(v1[3] - v2[3], 2.0f)); - ASSERT(fabsf(d1 - d2) <= 0.000009) - } - - /* test zero */ - glm_vec4_zero(v); - ASSERTIFY(test_assert_vec4_eq(zero, v)) - - /* test one */ - glm_vec4_one(v); - ASSERTIFY(test_assert_vec4_eq(one, v)) - - /* adds, subs, div, divs, mul */ - glm_vec4_add(v, one, v); - ASSERT(glmc_vec4_eq_eps(v, 2)) - - glm_vec4_adds(v, 10, v); - ASSERT(glmc_vec4_eq_eps(v, 12)) - - glm_vec4_sub(v, one, v); - ASSERT(glmc_vec4_eq_eps(v, 11)) - - glm_vec4_subs(v, 1, v); - ASSERT(glmc_vec4_eq_eps(v, 10)) - - glm_vec4_broadcast(2, v1); - glm_vec4_div(v, v1, v); - ASSERT(glmc_vec4_eq_eps(v, 5)) - - glm_vec4_divs(v, 0.5f, v); - ASSERT(glmc_vec4_eq_eps(v, 10)) - - glm_vec4_mul(v, v1, v); - ASSERT(glmc_vec4_eq_eps(v, 20)) - - glm_vec4_scale(v, 0.5f, v); - ASSERT(glmc_vec4_eq_eps(v, 10)) - - glm_vec4_normalize_to(v, v1); - glm_vec4_scale(v1, 0.8f, v1); - glm_vec4_scale_as(v, 0.8f, v); - ASSERTIFY(test_assert_vec4_eq(v1, v)) - - /* addadd, subadd, muladd */ - glm_vec4_one(v); - - glm_vec4_addadd(one, one, v); - ASSERT(glmc_vec4_eq_eps(v, 3)) - - glm_vec4_subadd(one, zero, v); - ASSERT(glmc_vec4_eq_eps(v, 4)) - - glm_vec4_broadcast(2, v1); - glm_vec4_broadcast(3, v2); - glm_vec4_muladd(v1, v2, v); - ASSERT(glmc_vec4_eq_eps(v, 10)) - - /* min, max */ - test_rand_vec4(v1); - test_rand_vec4(v2); - - glm_vec4_maxv(v1, v2, v3); - test_vec4_maxv(v1, v2, v4); - ASSERTIFY(test_assert_vec4_eq(v3, v4)) - - glm_vec4_minv(v1, v2, v3); - test_vec4_minv(v1, v2, v4); - ASSERTIFY(test_assert_vec4_eq(v3, v4)) - - /* clamp */ - glm_vec4_clamp(v3, 0.1f, 0.8f); - test_vec4_clamp(v4, 0.1f, 0.8f); - ASSERTIFY(test_assert_vec4_eq(v3, v4)) - - ASSERT(v3[0] >= 0.0999 && v3[0] <= 0.80001) /* rounding erros */ - ASSERT(v3[1] >= 0.0999 && v3[1] <= 0.80001) - ASSERT(v3[2] >= 0.0999 && v3[2] <= 0.80001) - ASSERT(v3[3] >= 0.0999 && v3[3] <= 0.80001) - - /* swizzle */ - - /* ZYX */ - v1[0] = 1; - v1[1] = 2; - v1[2] = 3; - v1[3] = 4; - - glm_vec4_swizzle(v1, GLM_WZYX, v1); - ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1})) - - glm_vec4_swizzle(v1, GLM_XXXX, v1); - ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4})) - - v1[0] = 1; - v1[1] = 2; - v1[2] = 3; - v1[3] = 4; - - glm_vec4_swizzle(v1, GLM_YYYY, v1); - ASSERTIFY(test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2})) - - v1[0] = 1; - v1[1] = 2; - v1[2] = 3; - v1[3] = 4; - - glm_vec4_swizzle(v1, GLM_ZZZZ, v1); - ASSERTIFY(test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3})) - - v1[0] = 1; - v1[1] = 2; - v1[2] = 3; - v1[3] = 4; - - glm_vec4_swizzle(v1, GLM_WWWW, v1); - ASSERTIFY(test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4})) - - /* structs */ - vs1 = test_rand_vec4s(); - vs2 = test_rand_vec4s(); - - vs3 = glms_vec4_add(vs1, vs2); - vs4 = glms_vec4_maxv(vs1, vs3); - ASSERTIFY(test_assert_vec4s_eq(vs3, vs4)) - - TEST_SUCCESS -} +#undef GLM +#undef GLM_PREFIX diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h new file mode 100644 index 0000000..6fdf50b --- /dev/null +++ b/test/src/test_vec4.h @@ -0,0 +1,660 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +#define TEST_GLM_SHUFFLE4(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2)|(w)) + +#ifndef CGLM_TEST_VEC4_ONCE +#define CGLM_TEST_VEC4_ONCE + +/* Macros */ + +TEST_IMPL(MACRO_GLM_VEC4_ONE_INIT) { + vec4 v = GLM_VEC4_ONE_INIT; + + ASSERT(test_eq(v[0], 1.0f)) + ASSERT(test_eq(v[1], 1.0f)) + ASSERT(test_eq(v[2], 1.0f)) + ASSERT(test_eq(v[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_VEC4_ZERO_INIT) { + vec4 v = GLM_VEC4_ZERO_INIT; + + ASSERT(test_eq(v[0], 0.0f)) + ASSERT(test_eq(v[1], 0.0f)) + ASSERT(test_eq(v[2], 0.0f)) + ASSERT(test_eq(v[3], 0.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_VEC4_ONE) { + ASSERT(test_eq(GLM_VEC4_ONE[0], 1.0f)) + ASSERT(test_eq(GLM_VEC4_ONE[1], 1.0f)) + ASSERT(test_eq(GLM_VEC4_ONE[2], 1.0f)) + ASSERT(test_eq(GLM_VEC4_ONE[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_VEC4_ZERO) { + ASSERT(test_eq(GLM_VEC4_ZERO[0], 0.0f)) + ASSERT(test_eq(GLM_VEC4_ZERO[1], 0.0f)) + ASSERT(test_eq(GLM_VEC4_ZERO[2], 0.0f)) + ASSERT(test_eq(GLM_VEC4_ZERO[3], 0.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_XXXX) { + ASSERT(TEST_GLM_SHUFFLE4(0, 0, 0, 0) == GLM_XXXX) + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_YYYY) { + ASSERT(TEST_GLM_SHUFFLE4(1, 1, 1, 1) == GLM_YYYY) + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_ZZZZ) { + ASSERT(TEST_GLM_SHUFFLE4(2, 2, 2, 2) == GLM_ZZZZ) + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_WZYX) { + ASSERT(TEST_GLM_SHUFFLE4(0, 1, 2, 3) == GLM_WZYX) + TEST_SUCCESS +} + +/* Deprecated */ + +TEST_IMPL(MACRO_glm_vec4_dup) { + vec4 v1 = {13.0f, 12.0f, 11.0f, 56.0f}, v2; + + glm_vec4_dup(v1, v2); + + ASSERTIFY(test_assert_vec4_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec4_flipsign) { + vec4 v1 = {13.0f, -12.0f, 11.0f, 56.0f}, + v2 = {13.0f, -12.0f, 11.0f, 56.0f}, + v3 = {-13.0f, 12.0f, -11.0f, -56.0f}; + + glm_vec4_flipsign(v1); + glmc_vec4_flipsign(v2); + + ASSERTIFY(test_assert_vec4_eq(v1, v3)) + ASSERTIFY(test_assert_vec4_eq(v2, v3)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec4_flipsign_to) { + vec4 v1 = {13.0f, -12.0f, 11.0f, 56.0f}, + v2 = {-13.0f, 12.0f, -11.0f, -56.0f}, + v3, v4; + + glm_vec4_flipsign_to(v1, v3); + glmc_vec4_flipsign_to(v1, v4); + + ASSERTIFY(test_assert_vec4_eq(v2, v3)) + ASSERTIFY(test_assert_vec4_eq(v2, v4)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec4_inv) { + vec4 v1 = {13.0f, -12.0f, 11.0f, 56.0f}, + v2 = {13.0f, -12.0f, 11.0f, 56.0f}, + v3 = {-13.0f, 12.0f, -11.0f, -56.0f}; + + glm_vec4_inv(v1); + glmc_vec4_inv(v2); + + ASSERTIFY(test_assert_vec4_eq(v1, v3)) + ASSERTIFY(test_assert_vec4_eq(v2, v3)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec4_inv_to) { + vec4 v1 = {13.0f, -12.0f, 11.0f, 56.0f}, + v2 = {-13.0f, 12.0f, -11.0f, -56.0f}, + v3, v4; + + glm_vec4_inv_to(v1, v3); + glmc_vec4_inv_to(v1, v4); + + ASSERTIFY(test_assert_vec4_eq(v3, v4)) + ASSERTIFY(test_assert_vec4_eq(v2, v3)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_glm_vec4_mulv) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 56.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 56.0f}, + v3, v4; + + glm_vec4_mulv(v1, v2, v3); + glmc_vec4_mulv(v1, v2, v4); + + ASSERTIFY(test_assert_vec4_eq(v3, v4)) + + ASSERT(test_eq(v1[0] * v2[0], v3[0])) + ASSERT(test_eq(v1[1] * v2[1], v3[1])) + ASSERT(test_eq(v1[2] * v2[2], v3[2])) + ASSERT(test_eq(v1[3] * v2[3], v3[3])) + + TEST_SUCCESS +} + +#endif /* CGLM_TEST_VEC4_ONCE */ + +/* --- */ + +TEST_IMPL(GLM_PREFIX, vec4) { + vec4 v1 = {10.0f, 9.0f, 8.0f}; + vec4 v2 = {10.0f, 9.0f, 8.0f, 7.0f}; + vec4 v3; + + GLM(vec4)(v1, 7.0f, v3); + + ASSERTIFY(test_assert_vec4_eq(v2, v3)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_copy3) { + vec4 v4 = {10.0f, 9.0f, 8.0f, 7.0f}; + vec3 v3; + + GLM(vec4_copy3)(v4, v3); + + ASSERTIFY(test_assert_vec3_eq(v3, v4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_copy) { + vec4 v1 = {10.0f, 9.0f, 8.0f, 78.0f}; + vec4 v2 = {1.0f, 2.0f, 3.0f, 4.0f}; + + GLM(vec4_copy)(v1, v2); + + ASSERTIFY(test_assert_vec4_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_ucopy) { + vec4 v1 = {10.0f, 9.0f, 8.0f, 78.0f}; + vec4 v2 = {1.0f, 2.0f, 3.0f, 4.0f}; + + GLM(vec4_ucopy)(v1, v2); + + ASSERTIFY(test_assert_vec4_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_zero) { + vec4 v1 = {10.0f, 9.0f, 8.0f, 78.0f}; + vec4 v2 = {1.0f, 2.0f, 3.0f, 4.0f}; + + GLM(vec4_zero)(v1); + GLM(vec4_zero)(v2); + + ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO)) + ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_one) { + vec4 v1 = {10.0f, 9.0f, 8.0f, 78.0f}; + vec4 v2 = {1.0f, 2.0f, 3.0f, 4.0f}; + + GLM(vec4_one)(v1); + GLM(vec4_one)(v2); + + ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC4_ONE)) + ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC4_ONE)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_dot) { + vec4 a = {10.0f, 9.0f, 8.0f, 78.0f}; + vec4 b = {1.0f, 2.0f, 3.0f, 4.0f}; + float dot1, dot2; + + dot1 = GLM(vec4_dot)(a, b); + dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; + + ASSERT(test_eq(dot1, dot2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_norm2) { + vec4 a = {10.0f, 9.0f, 8.0f, 78.0f}; + float n1, n2; + + n1 = GLM(vec4_norm2)(a); + n2 = a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]; + + ASSERT(test_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_norm) { + vec3 a = {10.0f, 9.0f, 8.0f}; + float n1, n2; + + n1 = GLM(vec3_norm)(a); + n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]); + + ASSERT(test_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_norm_one) { + vec4 a = {-10.0f, 9.0f, -8.0f, 78.0f}; + float n1, n2; + + n1 = GLM(vec4_norm_one)(a); + n2 = fabsf(a[0]) + fabsf(a[1]) + fabsf(a[2]) + fabsf(a[3]); + + ASSERT(test_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_norm_inf) { + vec4 a = {-10.0f, 9.0f, -8.0f, 78.0f}; + float n1, n2; + + n1 = GLM(vec4_norm_inf)(a); + n2 = fabsf(a[0]); + + if (n2 < fabsf(a[1])) + n2 = fabsf(a[1]); + + if (n2 < fabsf(a[2])) + n2 = fabsf(a[2]); + + if (n2 < fabsf(a[3])) + n2 = fabsf(a[3]); + + ASSERT(test_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_add) { + vec4 a = {-10.0f, 9.0f, -8.0f, 56.0f}; + vec4 b = {12.0f, 19.0f, -18.0f, 1.0f}; + vec4 c, d; + + c[0] = a[0] + b[0]; + c[1] = a[1] + b[1]; + c[2] = a[2] + b[2]; + c[3] = a[3] + b[3]; + + GLM(vec4_add)(a, b, d); + + ASSERTIFY(test_assert_vec4_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_adds) { + vec4 a = {-10.0f, 9.0f, -8.0f, 56.0f}; + vec4 c, d; + float s = 7.0f; + + c[0] = a[0] + s; + c[1] = a[1] + s; + c[2] = a[2] + s; + c[3] = a[3] + s; + + GLM(vec4_adds)(a, s, d); + + ASSERTIFY(test_assert_vec4_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_sub) { + vec4 a = {-10.0f, 9.0f, -8.0f, 56.0f}; + vec4 b = {12.0f, 19.0f, -18.0f, 1.0f}; + vec4 c, d; + + c[0] = a[0] - b[0]; + c[1] = a[1] - b[1]; + c[2] = a[2] - b[2]; + c[3] = a[3] - b[3]; + + GLM(vec4_sub)(a, b, d); + + ASSERTIFY(test_assert_vec4_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_subs) { + vec4 a = {-10.0f, 9.0f, -8.0f, 74.0f}; + vec4 c, d; + float s = 7.0f; + + c[0] = a[0] - s; + c[1] = a[1] - s; + c[2] = a[2] - s; + c[3] = a[3] - s; + + GLM(vec4_subs)(a, s, d); + + ASSERTIFY(test_assert_vec4_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_mul) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 56.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 46.0f}, + v3; + + GLM(vec4_mul)(v1, v2, v3); + + ASSERT(test_eq(v1[0] * v2[0], v3[0])) + ASSERT(test_eq(v1[1] * v2[1], v3[1])) + ASSERT(test_eq(v1[2] * v2[2], v3[2])) + ASSERT(test_eq(v1[3] * v2[3], v3[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_scale) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2; + float s = 7.0f; + + GLM(vec4_scale)(v1, s, v2); + + ASSERT(test_eq(v1[0] * s, v2[0])) + ASSERT(test_eq(v1[1] * s, v2[1])) + ASSERT(test_eq(v1[2] * s, v2[2])) + ASSERT(test_eq(v1[3] * s, v2[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_scale_as) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2; + float s = 7.0f; + float norm; + + GLM(vec4_scale_as)(v1, s, v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]); + if (norm == 0.0f) { + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + ASSERT(test_eq(v1[3], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) + ASSERT(test_eq(v1[3] * norm, v2[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_div) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 40.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 2.0f}, + v3; + + GLM(vec4_div)(v1, v2, v3); + + ASSERT(test_eq(v1[0] / v2[0], v3[0])) + ASSERT(test_eq(v1[1] / v2[1], v3[1])) + ASSERT(test_eq(v1[2] / v2[2], v3[2])) + ASSERT(test_eq(v1[3] / v2[3], v3[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_divs) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 40.0f}, v2; + float s = 7.0f; + + GLM(vec4_divs)(v1, s, v2); + + ASSERT(test_eq(v1[0] / s, v2[0])) + ASSERT(test_eq(v1[1] / s, v2[1])) + ASSERT(test_eq(v1[2] / s, v2[2])) + ASSERT(test_eq(v1[3] / s, v2[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_addadd) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 20.0f}, + v3 = {1.0f, 2.0f, 3.0f, 130.0f}, + v4 = {1.0f, 2.0f, 3.0f, 130.0f}; + + GLM(vec4_addadd)(v1, v2, v4); + + ASSERT(test_eq(v3[0] + v1[0] + v2[0], v4[0])) + ASSERT(test_eq(v3[1] + v1[1] + v2[1], v4[1])) + ASSERT(test_eq(v3[2] + v1[2] + v2[2], v4[2])) + ASSERT(test_eq(v3[3] + v1[3] + v2[3], v4[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_subadd) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 20.0f}, + v3 = {1.0f, 2.0f, 3.0f, 130.0f}, + v4 = {1.0f, 2.0f, 3.0f, 130.0f}; + + GLM(vec4_subadd)(v1, v2, v4); + + ASSERT(test_eq(v3[0] + v1[0] - v2[0], v4[0])) + ASSERT(test_eq(v3[1] + v1[1] - v2[1], v4[1])) + ASSERT(test_eq(v3[2] + v1[2] - v2[2], v4[2])) + ASSERT(test_eq(v3[3] + v1[3] - v2[3], v4[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_muladd) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 20.0f}, + v3 = {1.0f, 2.0f, 3.0f, 130.0f}, + v4 = {1.0f, 2.0f, 3.0f, 130.0f}; + + GLM(vec4_muladd)(v1, v2, v4); + + ASSERT(test_eq(v3[0] + v1[0] * v2[0], v4[0])) + ASSERT(test_eq(v3[1] + v1[1] * v2[1], v4[1])) + ASSERT(test_eq(v3[2] + v1[2] * v2[2], v4[2])) + ASSERT(test_eq(v3[3] + v1[3] * v2[3], v4[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_muladds) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 20.0f}, + v3 = {-3.0f, 4.0f, -5.0f, 20.0f}; + float s = 9.0f; + + GLM(vec4_muladds)(v1, s, v3); + + ASSERT(test_eq(v2[0] + v1[0] * s, v3[0])) + ASSERT(test_eq(v2[1] + v1[1] * s, v3[1])) + ASSERT(test_eq(v2[2] + v1[2] * s, v3[2])) + ASSERT(test_eq(v2[3] + v1[3] * s, v3[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_maxadd) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 20.0f}, + v3 = {1.0f, 2.0f, 3.0f, 130.0f}, + v4 = {1.0f, 2.0f, 3.0f, 130.0f}; + + GLM(vec4_maxadd)(v1, v2, v4); + + ASSERT(test_eq(v3[0] + glm_max(v1[0], v2[0]), v4[0])) + ASSERT(test_eq(v3[1] + glm_max(v1[1], v2[1]), v4[1])) + ASSERT(test_eq(v3[2] + glm_max(v1[2], v2[2]), v4[2])) + ASSERT(test_eq(v3[3] + glm_max(v1[3], v2[3]), v4[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_minadd) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 4.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 20.0f}, + v3 = {1.0f, 2.0f, 3.0f, 130.0f}, + v4 = {1.0f, 2.0f, 3.0f, 130.0f}; + + GLM(vec4_minadd)(v1, v2, v4); + + ASSERT(test_eq(v3[0] + glm_min(v1[0], v2[0]), v4[0])) + ASSERT(test_eq(v3[1] + glm_min(v1[1], v2[1]), v4[1])) + ASSERT(test_eq(v3[2] + glm_min(v1[2], v2[2]), v4[2])) + ASSERT(test_eq(v3[3] + glm_min(v1[3], v2[3]), v4[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_negate_to) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 60.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 34.0f}, + v3, v4; + + GLM(vec4_negate_to)(v1, v3); + GLM(vec4_negate_to)(v2, v4); + + ASSERT(test_eq(-v1[0], v3[0])) + ASSERT(test_eq(-v1[1], v3[1])) + ASSERT(test_eq(-v1[2], v3[2])) + ASSERT(test_eq(-v1[3], v3[3])) + + ASSERT(test_eq(-v2[0], v4[0])) + ASSERT(test_eq(-v2[1], v4[1])) + ASSERT(test_eq(-v2[2], v4[2])) + ASSERT(test_eq(-v2[3], v4[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_negate) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 60.0f}, + v2 = {-3.0f, 4.0f, -5.0f, 34.0f}, + v3 = {2.0f, -3.0f, 4.0f, 60.0f}, + v4 = {-3.0f, 4.0f, -5.0f, 34.0f}; + + GLM(vec4_negate)(v1); + GLM(vec4_negate)(v2); + + ASSERT(test_eq(-v1[0], v3[0])) + ASSERT(test_eq(-v1[1], v3[1])) + ASSERT(test_eq(-v1[2], v3[2])) + ASSERT(test_eq(-v1[3], v3[3])) + + ASSERT(test_eq(-v2[0], v4[0])) + ASSERT(test_eq(-v2[1], v4[1])) + ASSERT(test_eq(-v2[2], v4[2])) + ASSERT(test_eq(-v2[3], v4[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_normalize) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2 = {2.0f, -3.0f, 4.0f, 5.0f}; + float s = 1.0f; + float norm; + + GLM(vec4_normalize)(v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]); + if (norm == 0.0f) { + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + ASSERT(test_eq(v1[3], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) + ASSERT(test_eq(v1[3] * norm, v2[3])) + + glm_vec4_zero(v1); + GLM(vec4_normalize)(v1); + ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_normalize_to) { + vec4 v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2; + float s = 1.0f; + float norm; + + GLM(vec4_normalize_to)(v1, v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]); + if (norm == 0.0f) { + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + ASSERT(test_eq(v1[3], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) + ASSERT(test_eq(v1[3] * norm, v2[3])) + + glm_vec4_zero(v1); + GLM(vec4_normalize_to)(v1, v2); + ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ZERO)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 903f6fb..debd638 100644 --- a/test/tests.h +++ b/test/tests.h @@ -277,7 +277,6 @@ TEST_DECLARE(glmc_vec3_smoothstep) TEST_DECLARE(glmc_vec3_smoothinterp) TEST_DECLARE(glmc_vec3_smoothinterpc) TEST_DECLARE(glmc_vec3_swizzle) - TEST_DECLARE(glmc_vec3_broadcast) TEST_DECLARE(glmc_vec3_fill) TEST_DECLARE(glmc_vec3_eq) @@ -297,7 +296,84 @@ TEST_DECLARE(glmc_vec3_hadd) TEST_DECLARE(glmc_vec3_sqrt) /* vec4 */ -TEST_DECLARE(vec4) + +TEST_DECLARE(MACRO_GLM_VEC4_ONE_INIT) +TEST_DECLARE(MACRO_GLM_VEC4_ZERO_INIT) +TEST_DECLARE(MACRO_GLM_VEC4_ONE) +TEST_DECLARE(MACRO_GLM_VEC4_ZERO) +TEST_DECLARE(MACRO_GLM_XXXX) +TEST_DECLARE(MACRO_GLM_YYYY) +TEST_DECLARE(MACRO_GLM_ZZZZ) +TEST_DECLARE(MACRO_GLM_WZYX) +TEST_DECLARE(MACRO_glm_vec4_dup) +TEST_DECLARE(MACRO_glm_vec4_flipsign) +TEST_DECLARE(MACRO_glm_vec4_flipsign_to) +TEST_DECLARE(MACRO_glm_vec4_inv) +TEST_DECLARE(MACRO_glm_vec4_inv_to) +TEST_DECLARE(MACRO_glm_vec4_mulv) + +TEST_DECLARE(glm_vec4) +TEST_DECLARE(glm_vec4_copy3) +TEST_DECLARE(glm_vec4_copy) +TEST_DECLARE(glm_vec4_ucopy) +TEST_DECLARE(glm_vec4_zero) +TEST_DECLARE(glm_vec4_one) +TEST_DECLARE(glm_vec4_dot) +TEST_DECLARE(glm_vec4_norm2) +TEST_DECLARE(glm_vec4_norm) +TEST_DECLARE(glm_vec4_norm_one) +TEST_DECLARE(glm_vec4_norm_inf) +TEST_DECLARE(glm_vec4_add) +TEST_DECLARE(glm_vec4_adds) +TEST_DECLARE(glm_vec4_sub) +TEST_DECLARE(glm_vec4_subs) +TEST_DECLARE(glm_vec4_mul) +TEST_DECLARE(glm_vec4_scale) +TEST_DECLARE(glm_vec4_scale_as) +TEST_DECLARE(glm_vec4_div) +TEST_DECLARE(glm_vec4_divs) +TEST_DECLARE(glm_vec4_addadd) +TEST_DECLARE(glm_vec4_subadd) +TEST_DECLARE(glm_vec4_muladd) +TEST_DECLARE(glm_vec4_muladds) +TEST_DECLARE(glm_vec4_maxadd) +TEST_DECLARE(glm_vec4_minadd) +TEST_DECLARE(glm_vec4_negate_to) +TEST_DECLARE(glm_vec4_negate) +TEST_DECLARE(glm_vec4_normalize) +TEST_DECLARE(glm_vec4_normalize_to) + +TEST_DECLARE(glmc_vec4) +TEST_DECLARE(glmc_vec4_copy3) +TEST_DECLARE(glmc_vec4_copy) +TEST_DECLARE(glmc_vec4_ucopy) +TEST_DECLARE(glmc_vec4_zero) +TEST_DECLARE(glmc_vec4_one) +TEST_DECLARE(glmc_vec4_dot) +TEST_DECLARE(glmc_vec4_norm2) +TEST_DECLARE(glmc_vec4_norm) +TEST_DECLARE(glmc_vec4_norm_one) +TEST_DECLARE(glmc_vec4_norm_inf) +TEST_DECLARE(glmc_vec4_add) +TEST_DECLARE(glmc_vec4_adds) +TEST_DECLARE(glmc_vec4_sub) +TEST_DECLARE(glmc_vec4_subs) +TEST_DECLARE(glmc_vec4_mul) +TEST_DECLARE(glmc_vec4_scale) +TEST_DECLARE(glmc_vec4_scale_as) +TEST_DECLARE(glmc_vec4_div) +TEST_DECLARE(glmc_vec4_divs) +TEST_DECLARE(glmc_vec4_addadd) +TEST_DECLARE(glmc_vec4_subadd) +TEST_DECLARE(glmc_vec4_muladd) +TEST_DECLARE(glmc_vec4_muladds) +TEST_DECLARE(glmc_vec4_maxadd) +TEST_DECLARE(glmc_vec4_minadd) +TEST_DECLARE(glmc_vec4_negate_to) +TEST_DECLARE(glmc_vec4_negate) +TEST_DECLARE(glmc_vec4_normalize) +TEST_DECLARE(glmc_vec4_normalize_to) + /*****************************************************************************/ @@ -434,7 +510,6 @@ TEST_LIST { TEST_ENTRY(MACRO_GLM_YYY) TEST_ENTRY(MACRO_GLM_ZZZ) TEST_ENTRY(MACRO_GLM_ZYX) - TEST_ENTRY(MACRO_glm_vec3_dup) TEST_ENTRY(MACRO_glm_vec3_flipsign) TEST_ENTRY(MACRO_glm_vec3_flipsign_to) @@ -585,7 +660,83 @@ TEST_LIST { TEST_ENTRY(glmc_vec3_sqrt) /* vec4 */ - TEST_ENTRY(vec4) + + TEST_ENTRY(MACRO_GLM_VEC4_ONE_INIT) + TEST_ENTRY(MACRO_GLM_VEC4_ZERO_INIT) + TEST_ENTRY(MACRO_GLM_VEC4_ONE) + TEST_ENTRY(MACRO_GLM_VEC4_ZERO) + TEST_ENTRY(MACRO_GLM_XXXX) + TEST_ENTRY(MACRO_GLM_YYYY) + TEST_ENTRY(MACRO_GLM_ZZZZ) + TEST_ENTRY(MACRO_GLM_WZYX) + TEST_ENTRY(MACRO_glm_vec4_dup) + TEST_ENTRY(MACRO_glm_vec4_flipsign) + TEST_ENTRY(MACRO_glm_vec4_flipsign_to) + TEST_ENTRY(MACRO_glm_vec4_inv) + TEST_ENTRY(MACRO_glm_vec4_inv_to) + TEST_ENTRY(MACRO_glm_vec4_mulv) + + TEST_ENTRY(glm_vec4) + TEST_ENTRY(glm_vec4_copy3) + TEST_ENTRY(glm_vec4_copy) + TEST_ENTRY(glm_vec4_ucopy) + TEST_ENTRY(glm_vec4_zero) + TEST_ENTRY(glm_vec4_one) + TEST_ENTRY(glm_vec4_dot) + TEST_ENTRY(glm_vec4_norm2) + TEST_ENTRY(glm_vec4_norm) + TEST_ENTRY(glm_vec4_norm_one) + TEST_ENTRY(glm_vec4_norm_inf) + TEST_ENTRY(glm_vec4_add) + TEST_ENTRY(glm_vec4_adds) + TEST_ENTRY(glm_vec4_sub) + TEST_ENTRY(glm_vec4_subs) + TEST_ENTRY(glm_vec4_mul) + TEST_ENTRY(glm_vec4_scale) + TEST_ENTRY(glm_vec4_scale_as) + TEST_ENTRY(glm_vec4_div) + TEST_ENTRY(glm_vec4_divs) + TEST_ENTRY(glm_vec4_addadd) + TEST_ENTRY(glm_vec4_subadd) + TEST_ENTRY(glm_vec4_muladd) + TEST_ENTRY(glm_vec4_muladds) + TEST_ENTRY(glm_vec4_maxadd) + TEST_ENTRY(glm_vec4_minadd) + TEST_ENTRY(glm_vec4_negate_to) + TEST_ENTRY(glm_vec4_negate) + TEST_ENTRY(glm_vec4_normalize) + TEST_ENTRY(glm_vec4_normalize_to) + + TEST_ENTRY(glmc_vec4) + TEST_ENTRY(glmc_vec4_copy3) + TEST_ENTRY(glmc_vec4_copy) + TEST_ENTRY(glmc_vec4_ucopy) + TEST_ENTRY(glmc_vec4_zero) + TEST_ENTRY(glmc_vec4_one) + TEST_ENTRY(glmc_vec4_dot) + TEST_ENTRY(glmc_vec4_norm2) + TEST_ENTRY(glmc_vec4_norm) + TEST_ENTRY(glmc_vec4_norm_one) + TEST_ENTRY(glmc_vec4_norm_inf) + TEST_ENTRY(glmc_vec4_add) + TEST_ENTRY(glmc_vec4_adds) + TEST_ENTRY(glmc_vec4_sub) + TEST_ENTRY(glmc_vec4_subs) + TEST_ENTRY(glmc_vec4_mul) + TEST_ENTRY(glmc_vec4_scale) + TEST_ENTRY(glmc_vec4_scale_as) + TEST_ENTRY(glmc_vec4_div) + TEST_ENTRY(glmc_vec4_divs) + TEST_ENTRY(glmc_vec4_addadd) + TEST_ENTRY(glmc_vec4_subadd) + TEST_ENTRY(glmc_vec4_muladd) + TEST_ENTRY(glmc_vec4_muladds) + TEST_ENTRY(glmc_vec4_maxadd) + TEST_ENTRY(glmc_vec4_minadd) + TEST_ENTRY(glmc_vec4_negate_to) + TEST_ENTRY(glmc_vec4_negate) + TEST_ENTRY(glmc_vec4_normalize) + TEST_ENTRY(glmc_vec4_normalize_to) }; #endif /* tests_h */ From dcf5b5c1c4870fc9e7b499ea1ad9b2732e426e21 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Tue, 24 Sep 2019 17:01:56 +0300 Subject: [PATCH 044/103] vec: fix min/max for compiled vec3 --- src/vec4.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/vec4.c b/src/vec4.c index f08cd94..60c3a25 100644 --- a/src/vec4.c +++ b/src/vec4.c @@ -203,13 +203,13 @@ glmc_vec4_distance2(vec4 a, vec4 b) { CGLM_EXPORT void glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest) { - glm_vec4_minv(a, b, dest); + glm_vec4_maxv(a, b, dest); } CGLM_EXPORT void glmc_vec4_minv(vec4 a, vec4 b, vec4 dest) { - glm_vec4_maxv(a, b, dest); + glm_vec4_minv(a, b, dest); } CGLM_EXPORT From 36024367bc45efb93d20b2ba9cddbb3d32660542 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Tue, 24 Sep 2019 17:02:47 +0300 Subject: [PATCH 045/103] tests: add more tests for vec4 --- test/src/test_vec3.h | 20 +++---- test/src/test_vec4.h | 131 +++++++++++++++++++++++++++++++++++++++++-- test/tests.h | 20 +++++++ 3 files changed, 156 insertions(+), 15 deletions(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index a60ddf7..a1c1221 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -1011,11 +1011,11 @@ TEST_IMPL(GLM_PREFIX, vec3_proj) { } TEST_IMPL(GLM_PREFIX, vec3_center) { - vec3 v1 = {30.0f, 0.0f, 0.0f}, + vec3 v1 = {30.0f, 0.0f, 0.0f}, v2 = {0.0f, 0.0f, 0.0f}, - v3 = {15.0f, 0.0f, 0.0f}, - v4 = {3.0f, 10.0f, 120.0f}, - v5 = {0.46f, 4.0f, 14.0f}, + v3 = {15.0f, 0.0f, 0.0f}, + v4 = {3.0f, 10.0f, 120.0f}, + v5 = {0.46f, 4.0f, 14.0f}, v6; GLM(vec3_center)(v1, v2, v6); @@ -1030,10 +1030,10 @@ TEST_IMPL(GLM_PREFIX, vec3_center) { } TEST_IMPL(GLM_PREFIX, vec3_distance2) { - vec3 v1 = {30.0f, 0.0f, 0.0f}, + vec3 v1 = {30.0f, 0.0f, 0.0f}, v2 = {0.0f, 0.0f, 0.0f}, - v3 = {3.0f, 10.0f, 120.0f}, - v4 = {0.46f, 4.0f, 14.0f}; + v3 = {3.0f, 10.0f, 120.0f}, + v4 = {0.46f, 4.0f, 14.0f}; float d; d = GLM(vec3_distance2)(v1, v2); @@ -1048,10 +1048,10 @@ TEST_IMPL(GLM_PREFIX, vec3_distance2) { } TEST_IMPL(GLM_PREFIX, vec3_distance) { - vec3 v1 = {30.0f, 0.0f, 0.0f}, + vec3 v1 = {30.0f, 0.0f, 0.0f}, v2 = {0.0f, 0.0f, 0.0f}, - v3 = {3.0f, 10.0f, 120.0f}, - v4 = {0.46f, 4.0f, 14.0f}; + v3 = {3.0f, 10.0f, 120.0f}, + v4 = {0.46f, 4.0f, 14.0f}; float d; d = GLM(vec3_distance)(v1, v2); diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index 6fdf50b..6cb8a07 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -229,8 +229,8 @@ TEST_IMPL(GLM_PREFIX, vec4_one) { GLM(vec4_one)(v1); GLM(vec4_one)(v2); - ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC4_ONE)) - ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC4_ONE)) + ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE)) + ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE)) TEST_SUCCESS } @@ -261,11 +261,11 @@ TEST_IMPL(GLM_PREFIX, vec4_norm2) { } TEST_IMPL(GLM_PREFIX, vec4_norm) { - vec3 a = {10.0f, 9.0f, 8.0f}; + vec4 a = {10.0f, 9.0f, 8.0f, 78.0f}; float n1, n2; - n1 = GLM(vec3_norm)(a); - n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]); + n1 = GLM(vec4_norm)(a); + n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]); ASSERT(test_eq(n1, n2)) @@ -658,3 +658,124 @@ TEST_IMPL(GLM_PREFIX, vec4_normalize_to) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, vec4_distance2) { + vec4 v1 = {30.0f, 0.0f, 0.0f, 0.0f}, + v2 = {0.0f, 0.0f, 0.0f, 0.0f}, + v3 = {3.0f, 10.0f, 120.0f, 140.0f}, + v4 = {0.46f, 4.0f, 14.0f, 10.0f}; + float d; + + d = GLM(vec4_distance2)(v1, v2); + ASSERT(test_eq(d, 30.0f * 30.0f)) + + d = GLM(vec4_distance2)(v3, v4); + ASSERT(test_eq(powf(v3[0] - v4[0], 2.0f) + + powf(v3[1] - v4[1], 2.0f) + + powf(v3[2] - v4[2], 2.0f) + + powf(v3[3] - v4[3], 2.0f), d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_distance) { + vec4 v1 = {30.0f, 0.0f, 0.0f, 0.0f}, + v2 = {0.0f, 0.0f, 0.0f, 0.0f}, + v3 = {3.0f, 10.0f, 120.0f, 140.0f}, + v4 = {0.46f, 4.0f, 14.0f, 10.0f}; + float d; + + d = GLM(vec4_distance)(v1, v2); + ASSERT(test_eq(d, 30.0f)) + + d = GLM(vec4_distance)(v3, v4); + ASSERT(test_eq(sqrtf(powf(v3[0] - v4[0], 2.0f) + + powf(v3[1] - v4[1], 2.0f) + + powf(v3[2] - v4[2], 2.0f) + + powf(v3[3] - v4[3], 2.0f)), d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_maxv) { + vec4 v1, v2, v3; + vec4 v5 = {-1.456f, -1.456f, 241.456f, 10.0f}; + vec4 v6 = {11.0f, 11.0f, 11.0f, 90.0f}; + vec4 v7 = {78.0f, -78.0f, 7.0f, 5.0f}; + + GLM(vec4_maxv)(v5, v6, v1); + GLM(vec4_maxv)(v5, v7, v2); + GLM(vec4_maxv)(v6, v7, v3); + + ASSERT(test_eq(v1[0], 11.0f)) + ASSERT(test_eq(v1[1], 11.0f)) + ASSERT(test_eq(v1[2], 241.456f)) + ASSERT(test_eq(v1[3], 90.0f)) + + ASSERT(test_eq(v2[0], 78.0f)) + ASSERT(test_eq(v2[1], -1.456f)) + ASSERT(test_eq(v2[2], 241.456f)) + ASSERT(test_eq(v2[3], 10.0f)) + + ASSERT(test_eq(v3[0], 78.0f)) + ASSERT(test_eq(v3[1], 11.0f)) + ASSERT(test_eq(v3[2], 11.0f)) + ASSERT(test_eq(v3[3], 90.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_minv) { + vec4 v1, v2, v3; + vec4 v5 = {-1.456f, -1.456f, 241.456f, 10.0f}; + vec4 v6 = {11.0f, 11.0f, 11.0f, 90.0f}; + vec4 v7 = {78.0f, -78.0f, 7.0f, 5.0f}; + + GLM(vec4_minv)(v5, v6, v1); + GLM(vec4_minv)(v5, v7, v2); + GLM(vec4_minv)(v6, v7, v3); + + ASSERT(test_eq(v1[0], -1.456f)) + ASSERT(test_eq(v1[1], -1.456f)) + ASSERT(test_eq(v1[2], 11.0f)) + ASSERT(test_eq(v1[3], 10.0f)) + + ASSERT(test_eq(v2[0], -1.456f)) + ASSERT(test_eq(v2[1], -78.0f)) + ASSERT(test_eq(v2[2], 7.0f)) + ASSERT(test_eq(v2[3], 5.0f)) + + ASSERT(test_eq(v3[0], 11.0f)) + ASSERT(test_eq(v3[1], -78.0f)) + ASSERT(test_eq(v3[2], 7.0f)) + ASSERT(test_eq(v3[3], 5.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_clamp) { + vec4 v1 = {-1.456f, -11.456f, 31.456f, 67.04f}; + vec4 v2 = {0.110f, 111.0f, 11.0f, 90.0f}; + vec4 v3 = {78.0f, 32.0f, -78.0f, 3.0f}; + + GLM(vec4_clamp)(v1, -1.03f, 30.0f); + GLM(vec4_clamp)(v2, 0.11f, 111.0f); + GLM(vec4_clamp)(v3, -88.0f, 70.0f); + + ASSERT(test_eq(v1[0], -1.03f)) + ASSERT(test_eq(v1[1], -1.03f)) + ASSERT(test_eq(v1[2], 30.0f)) + ASSERT(test_eq(v1[3], 30.0f)) + + ASSERT(test_eq(v2[0], 0.11f)) + ASSERT(test_eq(v2[1], 111.0f)) + ASSERT(test_eq(v2[2], 11.0f)) + ASSERT(test_eq(v2[3], 90.0f)) + + ASSERT(test_eq(v3[0], 70.0f)) + ASSERT(test_eq(v3[1], 32.0f)) + ASSERT(test_eq(v3[2], -78.0f)) + ASSERT(test_eq(v3[3], 3.0f)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index debd638..9797085 100644 --- a/test/tests.h +++ b/test/tests.h @@ -342,6 +342,11 @@ TEST_DECLARE(glm_vec4_negate_to) TEST_DECLARE(glm_vec4_negate) TEST_DECLARE(glm_vec4_normalize) TEST_DECLARE(glm_vec4_normalize_to) +TEST_DECLARE(glm_vec4_distance2) +TEST_DECLARE(glm_vec4_distance) +TEST_DECLARE(glm_vec4_maxv) +TEST_DECLARE(glm_vec4_minv) +TEST_DECLARE(glm_vec4_clamp) TEST_DECLARE(glmc_vec4) TEST_DECLARE(glmc_vec4_copy3) @@ -373,6 +378,11 @@ TEST_DECLARE(glmc_vec4_negate_to) TEST_DECLARE(glmc_vec4_negate) TEST_DECLARE(glmc_vec4_normalize) TEST_DECLARE(glmc_vec4_normalize_to) +TEST_DECLARE(glmc_vec4_distance2) +TEST_DECLARE(glmc_vec4_distance) +TEST_DECLARE(glmc_vec4_maxv) +TEST_DECLARE(glmc_vec4_minv) +TEST_DECLARE(glmc_vec4_clamp) /*****************************************************************************/ @@ -706,6 +716,11 @@ TEST_LIST { TEST_ENTRY(glm_vec4_negate) TEST_ENTRY(glm_vec4_normalize) TEST_ENTRY(glm_vec4_normalize_to) + TEST_ENTRY(glm_vec4_distance2) + TEST_ENTRY(glm_vec4_distance) + TEST_ENTRY(glm_vec4_maxv) + TEST_ENTRY(glm_vec4_minv) + TEST_ENTRY(glm_vec4_clamp) TEST_ENTRY(glmc_vec4) TEST_ENTRY(glmc_vec4_copy3) @@ -737,6 +752,11 @@ TEST_LIST { TEST_ENTRY(glmc_vec4_negate) TEST_ENTRY(glmc_vec4_normalize) TEST_ENTRY(glmc_vec4_normalize_to) + TEST_ENTRY(glmc_vec4_distance2) + TEST_ENTRY(glmc_vec4_distance) + TEST_ENTRY(glmc_vec4_maxv) + TEST_ENTRY(glmc_vec4_minv) + TEST_ENTRY(glmc_vec4_clamp) }; #endif /* tests_h */ From 1700187f65a588254ae4d34133894cb45fbcc239 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Tue, 24 Sep 2019 19:10:44 +0300 Subject: [PATCH 046/103] tests: add more tests for vec4 --- test/src/test_vec3.h | 4 +- test/src/test_vec4.h | 613 +++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 113 +++++++- 3 files changed, 727 insertions(+), 3 deletions(-) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index a1c1221..9b99525 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -1182,7 +1182,7 @@ TEST_IMPL(GLM_PREFIX, vec3_lerp) { GLM(vec3_lerp)(v1, v2, 0.75f, v3); ASSERT(test_eq(v3[0], 50.0f)) - ASSERT(test_eq(v3[1], 100.03f)) + ASSERT(test_eq(v3[1], 100.0f)) ASSERT(test_eq(v3[2], 5.0f)) TEST_SUCCESS @@ -1200,7 +1200,7 @@ TEST_IMPL(GLM_PREFIX, vec3_lerpc) { GLM(vec3_lerpc)(v1, v2, 0.75f, v3); ASSERT(test_eq(v3[0], 50.0f)) - ASSERT(test_eq(v3[1], 100.03f)) + ASSERT(test_eq(v3[1], 100.0f)) ASSERT(test_eq(v3[2], 5.0f)) GLM(vec3_lerpc)(v1, v2, -1.75f, v3); diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index 6cb8a07..1ad49e0 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -779,3 +779,616 @@ TEST_IMPL(GLM_PREFIX, vec4_clamp) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, vec4_lerp) { + vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + vec4 v2 = {100.0f, 200.0f, 10.0f, 10.0f}; + vec4 v3; + + GLM(vec4_lerp)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + ASSERT(test_eq(v3[3], 0.0f)) + + GLM(vec4_lerp)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.0f)) + ASSERT(test_eq(v3[2], 5.0f)) + ASSERT(test_eq(v3[3], 5.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_lerpc) { + vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + vec4 v2 = {100.0f, 200.0f, 10.0f, 10.0f}; + vec4 v3; + + GLM(vec4_lerpc)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + ASSERT(test_eq(v3[3], 0.0f)) + + GLM(vec4_lerpc)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.0f)) + ASSERT(test_eq(v3[2], 5.0f)) + ASSERT(test_eq(v3[3], 5.0f)) + + GLM(vec4_lerpc)(v1, v2, -1.75f, v3); + ASSERT(test_eq(v3[0], -100.0f)) + ASSERT(test_eq(v3[1], -200.0f)) + ASSERT(test_eq(v3[2], -10.0f)) + ASSERT(test_eq(v3[3], -10.0f)) + + GLM(vec4_lerpc)(v1, v2, 1.75f, v3); + ASSERT(test_eq(v3[0], 100.0f)) + ASSERT(test_eq(v3[1], 200.0f)) + ASSERT(test_eq(v3[2], 10.0f)) + ASSERT(test_eq(v3[3], 10.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_mix) { + vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + vec4 v2 = {100.0f, 200.0f, 10.0f, 10.0f}; + vec4 v3; + + GLM(vec4_mix)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + ASSERT(test_eq(v3[3], 0.0f)) + + GLM(vec4_mix)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.0f)) + ASSERT(test_eq(v3[2], 5.0f)) + ASSERT(test_eq(v3[3], 5.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_mixc) { + vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + vec4 v2 = {100.0f, 200.0f, 10.0f, 10.0f}; + vec4 v3; + + GLM(vec4_mixc)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + ASSERT(test_eq(v3[3], 0.0f)) + + GLM(vec4_mixc)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.0f)) + ASSERT(test_eq(v3[2], 5.0f)) + ASSERT(test_eq(v3[3], 5.0f)) + + GLM(vec4_mixc)(v1, v2, -1.75f, v3); + ASSERT(test_eq(v3[0], -100.0f)) + ASSERT(test_eq(v3[1], -200.0f)) + ASSERT(test_eq(v3[2], -10.0f)) + ASSERT(test_eq(v3[3], -10.0f)) + + GLM(vec4_mixc)(v1, v2, 1.75f, v3); + ASSERT(test_eq(v3[0], 100.0f)) + ASSERT(test_eq(v3[1], 200.0f)) + ASSERT(test_eq(v3[2], 10.0f)) + ASSERT(test_eq(v3[3], 10.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_step_uni) { + vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + vec4 v2; + + GLM(vec4_step_uni)(-2.5f, v1, v2); + ASSERT(test_eq(v2[0], 0.0f)) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(test_eq(v2[2], 0.0f)) + ASSERT(test_eq(v2[3], 0.0f)) + + GLM(vec4_step_uni)(-10.0f, v1, v2); + ASSERT(test_eq(v2[0], 0.0f)) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + GLM(vec4_step_uni)(-1000.0f, v1, v2); + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_step) { + vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + vec4 s1 = {-100.0f, 0.0f, 10.0f, 10.0f}; + vec4 s2 = {100.0f, -220.0f, -10.0f, -10.0f}; + vec4 s3 = {100.0f, 200.0f, 10.0f, 10.0f}; + vec4 v2; + + GLM(vec4_step)(s1, v1, v2); + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(test_eq(v2[2], 0.0f)) + ASSERT(test_eq(v2[3], 0.0f)) + + GLM(vec4_step)(s2, v1, v2); + ASSERT(test_eq(v2[0], 0.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + GLM(vec4_step)(s3, v1, v2); + ASSERT(test_eq(v2[0], 0.0f)) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(test_eq(v2[2], 0.0f)) + ASSERT(test_eq(v2[3], 0.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_smoothstep_uni) { + vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + vec4 v2; + + GLM(vec4_smoothstep_uni)(-200.0f, -100.0f, v1, v2); + ASSERT(test_eq_th(v2[0], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[3], 1.0f, 1e-5)) + + GLM(vec4_smoothstep_uni)(-250.0f, -200.0f, v1, v2); + ASSERT(test_eq_th(v2[0], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[1], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[3], 1.0f, 1e-5)) + + GLM(vec4_smoothstep_uni)(-200.0f, 200, v1, v2); + ASSERT(v2[0] > 0.0f && v2[0] < 0.25f) + ASSERT(test_eq(v2[1], 0.0f)) + ASSERT(v2[2] > 0.0f && v2[2] < 0.5f) + ASSERT(v2[3] > 0.0f && v2[3] < 0.5f) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_smoothstep) { + vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + vec4 e1_0 = {-100.0f, 0.0f, -11.0f, -11.0f}; + vec4 e1_1 = {50.0f, 10.0f, 20.0f, 20.0f}; + vec4 e2_0 = {-180.0f, -300.0f, -93.0f, -93.0f}; + vec4 e2_1 = {100.0f, 120.0f, -10.0f, -10.0f}; + vec4 e3_0 = {-12.0f, 100.0f, 0.0f, 0.0f}; + vec4 e3_1 = {100.0f, 200.0f, 10.0f, 10.0f}; + vec4 v2; + + GLM(vec4_smoothstep)(e1_0, e1_1, v1, v2); + ASSERT(test_eq_th(v2[0], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) + ASSERT(v2[2] > 0.0f && v2[2] < 0.1f) + ASSERT(v2[3] > 0.0f && v2[3] < 0.1f) + + GLM(vec4_smoothstep)(e2_0, e2_1, v1, v2); + ASSERT(v2[0] > 0.0f && v2[0] < 0.25f) + ASSERT(v2[1] > 0.0f && v2[1] < 0.15f) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[3], 1.0f, 1e-5)) + + GLM(vec4_smoothstep)(e3_0, e3_1, v1, v2); + ASSERT(test_eq_th(v2[0], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[2], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[3], 0.0f, 1e-5)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_smoothinterp) { + vec4 e1_0 = {-100.0f, 0.0f, -11.0f, -11.0f}; + vec4 e1_1 = {50.0f, 10.0f, 20.0f, 20.0f}; + vec4 e2_0 = {80.0f, -220.0f, -19.0f, -19.0f}; + vec4 e2_1 = {100.0f, -200.0f, -10.0f, -10.0f}; + vec4 e3_0 = {-12.0f, 100.0f, 0.0f, 0.0f}; + vec4 e3_1 = {100.0f, 200.0f, 10.0f, 10.0f}; + vec4 v2; + + GLM(vec4_smoothinterp)(e1_0, e1_1, 0.5, v2); + ASSERT(v2[0] >= e1_0[0] && v2[0] <= e1_1[0]) + ASSERT(v2[1] >= e1_0[1] && v2[1] <= e1_1[1]) + ASSERT(v2[2] >= e1_0[2] && v2[2] <= e1_1[2]) + ASSERT(v2[3] >= e1_0[3] && v2[3] <= e1_1[3]) + + GLM(vec4_smoothinterp)(e2_0, e2_1, 0.5, v2); + ASSERT(v2[0] >= e2_0[0] && v2[0] <= e2_1[0]) + ASSERT(v2[1] >= e2_0[1] && v2[1] <= e2_1[1]) + ASSERT(v2[2] >= e2_0[2] && v2[2] <= e2_1[2]) + ASSERT(v2[3] >= e2_0[3] && v2[3] <= e2_1[3]) + + GLM(vec4_smoothinterp)(e3_0, e3_1, 1.0, v2); + ASSERT(v2[0] >= e3_0[0] && v2[0] <= e3_1[0]) + ASSERT(v2[1] >= e3_0[1] && v2[1] <= e3_1[1]) + ASSERT(v2[2] >= e3_0[2] && v2[2] <= e3_1[2]) + ASSERT(v2[3] >= e3_0[3] && v2[3] <= e3_1[3]) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_smoothinterpc) { + vec4 e1_0 = {-100.0f, 0.0f, -11.0f, -11.0f}; + vec4 e1_1 = {50.0f, 10.0f, 20.0f, 20.0f}; + vec4 e2_0 = {80.0f, -220.0f, -19.0f, -19.0f}; + vec4 e2_1 = {100.0f, -200.0f, -10.0f, -10.0f}; + vec4 e3_0 = {-12.0f, 100.0f, 0.0f, 0.0f}; + vec4 e3_1 = {100.0f, 200.0f, 10.0f, 10.0f}; + vec4 v2; + + GLM(vec4_smoothinterpc)(e1_0, e1_1, -0.5, v2); + ASSERT(v2[0] >= e1_0[0] && v2[0] <= e1_1[0]) + ASSERT(v2[1] >= e1_0[1] && v2[1] <= e1_1[1]) + ASSERT(v2[2] >= e1_0[2] && v2[2] <= e1_1[2]) + ASSERT(v2[3] >= e1_0[3] && v2[3] <= e1_1[3]) + + GLM(vec4_smoothinterpc)(e2_0, e2_1, 0.5, v2); + ASSERT(v2[0] >= e2_0[0] && v2[0] <= e2_1[0]) + ASSERT(v2[1] >= e2_0[1] && v2[1] <= e2_1[1]) + ASSERT(v2[2] >= e2_0[2] && v2[2] <= e2_1[2]) + ASSERT(v2[3] >= e2_0[3] && v2[3] <= e2_1[3]) + + GLM(vec4_smoothinterpc)(e3_0, e3_1, 2.0, v2); + ASSERT(v2[0] >= e3_0[0] && v2[0] <= e3_1[0]) + ASSERT(v2[1] >= e3_0[1] && v2[1] <= e3_1[1]) + ASSERT(v2[2] >= e3_0[2] && v2[2] <= e3_1[2]) + ASSERT(v2[3] >= e3_0[3] && v2[3] <= e3_1[3]) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_swizzle) { + vec4 v; + + /* ZYX */ + v[0] = 1; + v[1] = 2; + v[2] = 3; + v[3] = 4; + + glm_vec4_swizzle(v, GLM_WZYX, v); + ASSERTIFY(test_assert_vec4_eq(v, (vec4){4, 3, 2, 1})) + + glm_vec4_swizzle(v, GLM_XXXX, v); + ASSERTIFY(test_assert_vec4_eq(v, (vec4){4, 4, 4, 4})) + + v[0] = 1; + v[1] = 2; + v[2] = 3; + v[3] = 4; + + glm_vec4_swizzle(v, GLM_YYYY, v); + ASSERTIFY(test_assert_vec4_eq(v, (vec4){2, 2, 2, 2})) + + v[0] = 1; + v[1] = 2; + v[2] = 3; + v[3] = 4; + + glm_vec4_swizzle(v, GLM_ZZZZ, v); + ASSERTIFY(test_assert_vec4_eq(v, (vec4){3, 3, 3, 3})) + + v[0] = 1; + v[1] = 2; + v[2] = 3; + v[3] = 4; + + glm_vec4_swizzle(v, GLM_WWWW, v); + ASSERTIFY(test_assert_vec4_eq(v, (vec4){4, 4, 4, 4})) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_broadcast) { + vec4 v1, v2, v3; + vec4 v5 = {-1.456f, -1.456f, -1.456f, -1.456f}; + vec4 v6 = {11.0f, 11.0f, 11.0f, 11.0f}; + vec4 v7 = {78.0f, 78.0f, 78.0f, 78.0f}; + + GLM(vec4_broadcast)(-1.456f, v1); + GLM(vec4_broadcast)(11.0f, v2); + GLM(vec4_broadcast)(78.0f, v3); + + ASSERTIFY(test_assert_vec4_eq(v1, v5)) + ASSERTIFY(test_assert_vec4_eq(v2, v6)) + ASSERTIFY(test_assert_vec4_eq(v3, v7)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_fill) { + vec4 v1, v2, v3; + vec4 v5 = {-1.456f, -1.456f, -1.456f, -1.456f}; + vec4 v6 = {11.0f, 11.0f, 11.0f, 11.0f}; + vec4 v7 = {78.0f, 78.0f, 78.0f, 78.0f}; + + GLM(vec4_fill)(v1, -1.456f); + GLM(vec4_fill)(v2, 11.0f); + GLM(vec4_fill)(v3, 78.0f); + + ASSERTIFY(test_assert_vec4_eq(v1, v5)) + ASSERTIFY(test_assert_vec4_eq(v2, v6)) + ASSERTIFY(test_assert_vec4_eq(v3, v7)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_eq) { + vec4 v1, v2, v3; + + GLM(vec4_fill)(v1, -1.456f); + GLM(vec4_fill)(v2, 11.0f); + GLM(vec4_fill)(v3, 78.1f); + + ASSERT(GLM(vec4_eq)(v1, -1.456f)) + ASSERT(GLM(vec4_eq)(v2, 11.0f)) + ASSERT(!GLM(vec4_eq)(v3, 78.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_eq_eps) { + vec4 v1, v2, v3; + + GLM(vec4_fill)(v1, -1.456f); + GLM(vec4_fill)(v2, 11.0f); + GLM(vec4_fill)(v3, 78.1f); + + ASSERT(GLM(vec4_eq_eps)(v1, -1.456f)) + ASSERT(GLM(vec4_eq_eps)(v2, 11.0f)) + ASSERT(!GLM(vec4_eq_eps)(v3, 78.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_eq_all) { + vec4 v1, v2, v3; + vec4 v4 = {2.104f, -3.012f, -4.10f, -4.10f}; + vec4 v5 = {-12.35f, -31.140f, -43.502f, -43.502f}; + + GLM(vec4_fill)(v1, -1.456f); + GLM(vec4_fill)(v2, 11.0f); + GLM(vec4_fill)(v3, 78.0f); + + ASSERT(GLM(vec4_eq_all)(v1)) + ASSERT(GLM(vec4_eq_all)(v2)) + ASSERT(GLM(vec4_eq_all)(v3)) + ASSERT(!GLM(vec4_eq_all)(v4)) + ASSERT(!GLM(vec4_eq_all)(v5)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_eqv) { + vec4 v1, v2, v3, v4, v5; + vec4 v6 = {-1.456f, -1.456f, -1.456f, -1.456f}; + vec4 v7 = {11.0f, 11.0f, 11.0f, 11.0f}; + vec4 v8 = {78.0f, 78.0f, -43.502f, -43.502f}; + + GLM(vec4_fill)(v1, -1.456f); + GLM(vec4_fill)(v2, 11.0f); + GLM(vec4_fill)(v3, 78.0f); + + test_rand_vec4(v4); + test_rand_vec4(v5); + + ASSERT(GLM(vec4_eqv)(v1, v6)) + ASSERT(GLM(vec4_eqv)(v2, v7)) + ASSERT(!GLM(vec4_eqv)(v3, v8)) + ASSERT(!GLM(vec4_eqv)(v4, v5)) + ASSERT(GLM(vec4_eqv)(v5, v5)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_eqv_eps) { + vec4 v1, v2, v3, v4, v5; + vec4 v6 = {-1.456f, -1.456f, -1.456f, -1.456f}; + vec4 v7 = {11.0f, 11.0f, 11.0f, 11.0f}; + vec4 v8 = {78.0f, 78.0f, -43.502f, -43.502f}; + + GLM(vec4_fill)(v1, -1.456f); + GLM(vec4_fill)(v2, 11.0f); + GLM(vec4_fill)(v3, 78.0f); + + test_rand_vec4(v4); + test_rand_vec4(v5); + + ASSERT(GLM(vec4_eqv_eps)(v1, v6)) + ASSERT(GLM(vec4_eqv_eps)(v2, v7)) + ASSERT(!GLM(vec4_eqv_eps)(v3, v8)) + ASSERT(!GLM(vec4_eqv_eps)(v4, v5)) + ASSERT(GLM(vec4_eqv_eps)(v5, v5)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_max) { + vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; + vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; + vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; + vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; + vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; + vec4 v6 = {-1.0f, -11.0f, 11.0f, 11.0f}; + + ASSERT(test_eq(GLM(vec4_max)(v1), 2.104f)) + ASSERT(test_eq(GLM(vec4_max)(v2), -12.35f)) + ASSERT(isinf(GLM(vec4_max)(v3))) + ASSERT(isnan(GLM(vec4_max)(v4))) + ASSERT(isnan(GLM(vec4_max)(v5))) + ASSERT(test_eq(GLM(vec4_max)(v6), 11.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_min) { + vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; + vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; + vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; + vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; + vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; + vec4 v6 = {-1.0f, -11.0f, 11.0f, 11.0f}; + + ASSERT(test_eq(GLM(vec4_min)(v1), -4.10f)) + ASSERT(test_eq(GLM(vec4_min)(v2), -43.502f)) + ASSERT(test_eq(GLM(vec4_min)(v3), 0.0f)) + ASSERT(isnan(GLM(vec4_min)(v4))) + ASSERT(isnan(GLM(vec4_min)(v5))) + ASSERT(test_eq(GLM(vec4_min)(v6), -11.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_isnan) { + vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; + vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; + vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; + vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; + vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; + vec4 v6 = {-1.0f, -1.0f, 11.0f, 11.0f}; + + ASSERT(!GLM(vec4_isnan)(v1)) + ASSERT(!GLM(vec4_isnan)(v2)) + ASSERT(!GLM(vec4_isnan)(v3)) + ASSERT(GLM(vec4_isnan)(v4)) + ASSERT(GLM(vec4_isnan)(v5)) + ASSERT(!GLM(vec4_isnan)(v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_isinf) { + vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; + vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; + vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; + vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; + vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; + vec4 v6 = {-1.0f, -1.0f, 11.0f, 11.0f}; + + ASSERT(!GLM(vec4_isinf)(v1)) + ASSERT(!GLM(vec4_isinf)(v2)) + ASSERT(GLM(vec4_isinf)(v3)) + ASSERT(GLM(vec4_isinf)(v4)) + ASSERT(!GLM(vec4_isinf)(v5)) + ASSERT(!GLM(vec4_isinf)(v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_isvalid) { + vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; + vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; + vec4 v3 = {INFINITY, 0.0f, 0.0f, 0.0f}; + vec4 v4 = {NAN, INFINITY, 2.0f, 2.0f}; + vec4 v5 = {NAN, -1.0f, -1.0f, -1.0f}; + vec4 v6 = {-1.0f, -1.0f, 11.0f, 11.0f}; + + ASSERT(GLM(vec4_isvalid)(v1)) + ASSERT(GLM(vec4_isvalid)(v2)) + ASSERT(!GLM(vec4_isvalid)(v3)) + ASSERT(!GLM(vec4_isvalid)(v4)) + ASSERT(!GLM(vec4_isvalid)(v5)) + ASSERT(GLM(vec4_isvalid)(v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_sign) { + vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; + vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; + vec4 v3, v4; + vec4 v5 = {1.0f, -1.0f, -1.0f, -1.0f}; + vec4 v6 = {-1.0f, -1.0f, -1.0f, -1.0f}; + + GLM(vec4_sign)(v1, v3); + GLM(vec4_sign)(v2, v4); + + ASSERTIFY(test_assert_vec4_eq(v3, v5)) + ASSERTIFY(test_assert_vec4_eq(v4, v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_abs) { + vec4 v1 = {2.104f, -3.012f, -4.10f, -4.10f}; + vec4 v2 = {-12.35f, -31.140f, -43.502f, -43.502f}; + vec4 v3, v4; + vec4 v5 = {2.104f, 3.012f, 4.10f, 4.10f}; + vec4 v6 = {12.35f, 31.140f, 43.502f, 43.502f}; + + GLM(vec4_abs)(v1, v3); + GLM(vec4_abs)(v2, v4); + + ASSERTIFY(test_assert_vec4_eq(v3, v5)) + ASSERTIFY(test_assert_vec4_eq(v4, v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_fract) { + vec4 v1 = {2.104f, 3.012f, 4.10f, 4.10f}; + vec4 v2 = {12.35f, 31.140f, 43.502f, 43.502f}; + vec4 v3, v4; + vec4 v5 = {0.104f, 0.012f, 0.10f, 0.10f}; + vec4 v6 = {0.35f, 0.140f, 0.502f, 0.502f}; + + GLM(vec4_fract)(v1, v3); + GLM(vec4_fract)(v2, v4); + + ASSERTIFY(test_assert_vec4_eq(v3, v5)) + ASSERTIFY(test_assert_vec4_eq(v4, v6)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_hadd) { + vec4 v1 = {2.0f, 3.0f, 4.0f, 4.0f}, v2 = {12.0f, 31.0f, 43.0f, 43.0f}; + float r1, r2, r3, r4; + + r1 = GLM(vec4_hadd)(v1); + r2 = GLM(vec4_hadd)(v2); + + r3 = v1[0] + v1[1] + v1[2] + v1[3]; + r4 = v2[0] + v2[1] + v2[2] + v2[3]; + + ASSERT(test_eq(r1, r3)) + ASSERT(test_eq(r2, r4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, vec4_sqrt) { + vec4 v1 = {2.0f, 3.0f, 4.0f, 4.0f}, v2 = {12.0f, 31.0f, 43.0f, 43.0f}; + vec4 v3, v4; + + GLM(vec4_sqrt)(v1, v3); + GLM(vec4_sqrt)(v2, v4); + + ASSERT(test_eq(sqrtf(v1[0]), v3[0])) + ASSERT(test_eq(sqrtf(v1[1]), v3[1])) + ASSERT(test_eq(sqrtf(v1[2]), v3[2])) + ASSERT(test_eq(sqrtf(v1[3]), v3[3])) + + ASSERT(test_eq(sqrtf(v2[0]), v4[0])) + ASSERT(test_eq(sqrtf(v2[1]), v4[1])) + ASSERT(test_eq(sqrtf(v2[2]), v4[2])) + ASSERT(test_eq(sqrtf(v2[3]), v4[3])) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 9797085..b2aa95d 100644 --- a/test/tests.h +++ b/test/tests.h @@ -347,6 +347,34 @@ TEST_DECLARE(glm_vec4_distance) TEST_DECLARE(glm_vec4_maxv) TEST_DECLARE(glm_vec4_minv) TEST_DECLARE(glm_vec4_clamp) +TEST_DECLARE(glm_vec4_lerp) +TEST_DECLARE(glm_vec4_lerpc) +TEST_DECLARE(glm_vec4_mix) +TEST_DECLARE(glm_vec4_mixc) +TEST_DECLARE(glm_vec4_step_uni) +TEST_DECLARE(glm_vec4_step) +TEST_DECLARE(glm_vec4_smoothstep_uni) +TEST_DECLARE(glm_vec4_smoothstep) +TEST_DECLARE(glm_vec4_smoothinterp) +TEST_DECLARE(glm_vec4_smoothinterpc) +TEST_DECLARE(glm_vec4_swizzle) +TEST_DECLARE(glm_vec4_broadcast) +TEST_DECLARE(glm_vec4_fill) +TEST_DECLARE(glm_vec4_eq) +TEST_DECLARE(glm_vec4_eq_eps) +TEST_DECLARE(glm_vec4_eq_all) +TEST_DECLARE(glm_vec4_eqv) +TEST_DECLARE(glm_vec4_eqv_eps) +TEST_DECLARE(glm_vec4_max) +TEST_DECLARE(glm_vec4_min) +TEST_DECLARE(glm_vec4_isnan) +TEST_DECLARE(glm_vec4_isinf) +TEST_DECLARE(glm_vec4_isvalid) +TEST_DECLARE(glm_vec4_sign) +TEST_DECLARE(glm_vec4_abs) +TEST_DECLARE(glm_vec4_fract) +TEST_DECLARE(glm_vec4_hadd) +TEST_DECLARE(glm_vec4_sqrt) TEST_DECLARE(glmc_vec4) TEST_DECLARE(glmc_vec4_copy3) @@ -383,7 +411,34 @@ TEST_DECLARE(glmc_vec4_distance) TEST_DECLARE(glmc_vec4_maxv) TEST_DECLARE(glmc_vec4_minv) TEST_DECLARE(glmc_vec4_clamp) - +TEST_DECLARE(glmc_vec4_lerp) +TEST_DECLARE(glmc_vec4_lerpc) +TEST_DECLARE(glmc_vec4_mix) +TEST_DECLARE(glmc_vec4_mixc) +TEST_DECLARE(glmc_vec4_step_uni) +TEST_DECLARE(glmc_vec4_step) +TEST_DECLARE(glmc_vec4_smoothstep_uni) +TEST_DECLARE(glmc_vec4_smoothstep) +TEST_DECLARE(glmc_vec4_smoothinterp) +TEST_DECLARE(glmc_vec4_smoothinterpc) +TEST_DECLARE(glmc_vec4_swizzle) +TEST_DECLARE(glmc_vec4_broadcast) +TEST_DECLARE(glmc_vec4_fill) +TEST_DECLARE(glmc_vec4_eq) +TEST_DECLARE(glmc_vec4_eq_eps) +TEST_DECLARE(glmc_vec4_eq_all) +TEST_DECLARE(glmc_vec4_eqv) +TEST_DECLARE(glmc_vec4_eqv_eps) +TEST_DECLARE(glmc_vec4_max) +TEST_DECLARE(glmc_vec4_min) +TEST_DECLARE(glmc_vec4_isnan) +TEST_DECLARE(glmc_vec4_isinf) +TEST_DECLARE(glmc_vec4_isvalid) +TEST_DECLARE(glmc_vec4_sign) +TEST_DECLARE(glmc_vec4_abs) +TEST_DECLARE(glmc_vec4_fract) +TEST_DECLARE(glmc_vec4_hadd) +TEST_DECLARE(glmc_vec4_sqrt) /*****************************************************************************/ @@ -721,6 +776,34 @@ TEST_LIST { TEST_ENTRY(glm_vec4_maxv) TEST_ENTRY(glm_vec4_minv) TEST_ENTRY(glm_vec4_clamp) + TEST_ENTRY(glm_vec4_lerp) + TEST_ENTRY(glm_vec4_lerpc) + TEST_ENTRY(glm_vec4_mix) + TEST_ENTRY(glm_vec4_mixc) + TEST_ENTRY(glm_vec4_step_uni) + TEST_ENTRY(glm_vec4_step) + TEST_ENTRY(glm_vec4_smoothstep_uni) + TEST_ENTRY(glm_vec4_smoothstep) + TEST_ENTRY(glm_vec4_smoothinterp) + TEST_ENTRY(glm_vec4_smoothinterpc) + TEST_ENTRY(glm_vec4_swizzle) + TEST_ENTRY(glm_vec4_broadcast) + TEST_ENTRY(glm_vec4_fill) + TEST_ENTRY(glm_vec4_eq) + TEST_ENTRY(glm_vec4_eq_eps) + TEST_ENTRY(glm_vec4_eq_all) + TEST_ENTRY(glm_vec4_eqv) + TEST_ENTRY(glm_vec4_eqv_eps) + TEST_ENTRY(glm_vec4_max) + TEST_ENTRY(glm_vec4_min) + TEST_ENTRY(glm_vec4_isnan) + TEST_ENTRY(glm_vec4_isinf) + TEST_ENTRY(glm_vec4_isvalid) + TEST_ENTRY(glm_vec4_sign) + TEST_ENTRY(glm_vec4_abs) + TEST_ENTRY(glm_vec4_fract) + TEST_ENTRY(glm_vec4_hadd) + TEST_ENTRY(glm_vec4_sqrt) TEST_ENTRY(glmc_vec4) TEST_ENTRY(glmc_vec4_copy3) @@ -757,6 +840,34 @@ TEST_LIST { TEST_ENTRY(glmc_vec4_maxv) TEST_ENTRY(glmc_vec4_minv) TEST_ENTRY(glmc_vec4_clamp) + TEST_ENTRY(glmc_vec4_lerp) + TEST_ENTRY(glmc_vec4_lerpc) + TEST_ENTRY(glmc_vec4_mix) + TEST_ENTRY(glmc_vec4_mixc) + TEST_ENTRY(glmc_vec4_step_uni) + TEST_ENTRY(glmc_vec4_step) + TEST_ENTRY(glmc_vec4_smoothstep_uni) + TEST_ENTRY(glmc_vec4_smoothstep) + TEST_ENTRY(glmc_vec4_smoothinterp) + TEST_ENTRY(glmc_vec4_smoothinterpc) + TEST_ENTRY(glmc_vec4_swizzle) + TEST_ENTRY(glmc_vec4_broadcast) + TEST_ENTRY(glmc_vec4_fill) + TEST_ENTRY(glmc_vec4_eq) + TEST_ENTRY(glmc_vec4_eq_eps) + TEST_ENTRY(glmc_vec4_eq_all) + TEST_ENTRY(glmc_vec4_eqv) + TEST_ENTRY(glmc_vec4_eqv_eps) + TEST_ENTRY(glmc_vec4_max) + TEST_ENTRY(glmc_vec4_min) + TEST_ENTRY(glmc_vec4_isnan) + TEST_ENTRY(glmc_vec4_isinf) + TEST_ENTRY(glmc_vec4_isvalid) + TEST_ENTRY(glmc_vec4_sign) + TEST_ENTRY(glmc_vec4_abs) + TEST_ENTRY(glmc_vec4_fract) + TEST_ENTRY(glmc_vec4_hadd) + TEST_ENTRY(glmc_vec4_sqrt) }; #endif /* tests_h */ From 56cbacd9f6dc1f2020ea02d9660bfb65e87a3ac1 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Tue, 24 Sep 2019 21:45:43 +0300 Subject: [PATCH 047/103] tests: add missing test for vec4 --- test/src/test_vec4.h | 26 ++++++++++++++++++++++++++ test/tests.h | 4 ++++ 2 files changed, 30 insertions(+) diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index 1ad49e0..6fa9763 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -1053,6 +1053,32 @@ TEST_IMPL(GLM_PREFIX, vec4_smoothinterpc) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, vec4_cubic) { + vec4 v1 = {125.0f, 25.0f, 5.0f, 1.0f}; + vec4 v2 = {216.0f, 36.0f, 6.0f, 1.0f}; + vec4 v3, v4; + + ASSERT(test_eq(v1[0], v1[2] * v1[2] * v1[2])) + ASSERT(test_eq(v1[1], v1[2] * v1[2])) + ASSERT(test_eq(v1[3], 1.0f)) + + ASSERT(test_eq(v2[0], v2[2] * v2[2] * v2[2])) + ASSERT(test_eq(v2[1], v2[2] * v2[2])) + ASSERT(test_eq(v2[3], 1.0f)) + + GLM(vec4_cubic)(test_rand(), v3); + ASSERT(test_eq(v3[0], v3[2] * v3[2] * v3[2])) + ASSERT(test_eq(v3[1], v3[2] * v3[2])) + ASSERT(test_eq(v3[3], 1.0f)) + + GLM(vec4_cubic)(test_rand(), v4); + ASSERT(test_eq(v4[0], v4[2] * v4[2] * v4[2])) + ASSERT(test_eq(v4[1], v4[2] * v4[2])) + ASSERT(test_eq(v4[3], 1.0f)) + + TEST_SUCCESS +} + TEST_IMPL(GLM_PREFIX, vec4_swizzle) { vec4 v; diff --git a/test/tests.h b/test/tests.h index b2aa95d..1076a13 100644 --- a/test/tests.h +++ b/test/tests.h @@ -357,6 +357,7 @@ TEST_DECLARE(glm_vec4_smoothstep_uni) TEST_DECLARE(glm_vec4_smoothstep) TEST_DECLARE(glm_vec4_smoothinterp) TEST_DECLARE(glm_vec4_smoothinterpc) +TEST_DECLARE(glm_vec4_cubic) TEST_DECLARE(glm_vec4_swizzle) TEST_DECLARE(glm_vec4_broadcast) TEST_DECLARE(glm_vec4_fill) @@ -421,6 +422,7 @@ TEST_DECLARE(glmc_vec4_smoothstep_uni) TEST_DECLARE(glmc_vec4_smoothstep) TEST_DECLARE(glmc_vec4_smoothinterp) TEST_DECLARE(glmc_vec4_smoothinterpc) +TEST_DECLARE(glmc_vec4_cubic) TEST_DECLARE(glmc_vec4_swizzle) TEST_DECLARE(glmc_vec4_broadcast) TEST_DECLARE(glmc_vec4_fill) @@ -786,6 +788,7 @@ TEST_LIST { TEST_ENTRY(glm_vec4_smoothstep) TEST_ENTRY(glm_vec4_smoothinterp) TEST_ENTRY(glm_vec4_smoothinterpc) + TEST_ENTRY(glm_vec4_cubic) TEST_ENTRY(glm_vec4_swizzle) TEST_ENTRY(glm_vec4_broadcast) TEST_ENTRY(glm_vec4_fill) @@ -850,6 +853,7 @@ TEST_LIST { TEST_ENTRY(glmc_vec4_smoothstep) TEST_ENTRY(glmc_vec4_smoothinterp) TEST_ENTRY(glmc_vec4_smoothinterpc) + TEST_ENTRY(glmc_vec4_cubic) TEST_ENTRY(glmc_vec4_swizzle) TEST_ENTRY(glmc_vec4_broadcast) TEST_ENTRY(glmc_vec4_fill) From 2ea93083615f655057b7c3d7106c58179e1a9b5b Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 25 Sep 2019 07:41:29 +0300 Subject: [PATCH 048/103] quat: fix glmc_quat_normalize() --- src/quat.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/quat.c b/src/quat.c index bd8c13b..efe9458 100644 --- a/src/quat.c +++ b/src/quat.c @@ -59,7 +59,7 @@ glmc_quat_normalize_to(versor q, versor dest) { CGLM_EXPORT void glmc_quat_normalize(versor q) { - glm_quat_norm(q); + glm_quat_normalize(q); } CGLM_EXPORT From b2084fbacf64ba5be2fccc9da9cfdc80c34f7a6f Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 25 Sep 2019 07:42:29 +0300 Subject: [PATCH 049/103] tests: add some tests for quat --- test/runner.c | 4 + test/src/test_common.c | 11 ++ test/src/test_common.h | 3 + test/src/test_quat.c | 20 ++++ test/src/test_quat.h | 233 +++++++++++++++++++++++++++++++++++++++++ test/tests.h | 50 ++++++++- 6 files changed, 320 insertions(+), 1 deletion(-) create mode 100644 test/src/test_quat.h diff --git a/test/runner.c b/test/runner.c index 7d4d858..80c4e8f 100644 --- a/test/runner.c +++ b/test/runner.c @@ -71,6 +71,10 @@ main(int argc, const char * argv[]) { fprintf(stderr, "\n" RESET); passed++; } + + struct timespec t; + t.tv_nsec = 100000000 * 0.5; +// nanosleep(&t, NULL); } if (failed == 0) { diff --git a/test/src/test_common.c b/test/src/test_common.c index 5741a37..ce1acc8 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -272,3 +272,14 @@ test_assert_quat_eq(versor v1, versor v2) { TEST_SUCCESS } +test_status_t +test_assert_quat_eq_identity(versor q) { + versor p = GLM_QUAT_IDENTITY_INIT; + + ASSERT(fabsf(q[0] - p[0]) <= 0.000009); /* rounding errors */ + ASSERT(fabsf(q[1] - p[1]) <= 0.000009); + ASSERT(fabsf(q[2] - p[2]) <= 0.000009); + ASSERT(fabsf(q[3] - p[3]) <= 0.000009); + + TEST_SUCCESS +} diff --git a/test/src/test_common.h b/test/src/test_common.h index a5c4bb6..8443ec3 100644 --- a/test/src/test_common.h +++ b/test/src/test_common.h @@ -61,6 +61,9 @@ test_assert_vec4s_eq(vec4s v1, vec4s v2); test_status_t test_assert_quat_eq(versor v1, versor v2); +test_status_t +test_assert_quat_eq_identity(versor q) ; + test_status_t test_assert_quat_eq_abs(versor v1, versor v2); diff --git a/test/src/test_quat.c b/test/src/test_quat.c index 98bd8a1..9e2a908 100644 --- a/test/src/test_quat.c +++ b/test/src/test_quat.c @@ -7,6 +7,26 @@ #include "test_common.h" +/* test inline quat */ + +#define GLM_PREFIX glm_ +#define GLM(X) (glm_ ## X) + +#include "test_quat.h" + +#undef GLM +#undef GLM_PREFIX + +/* test pre-compiled quat */ + +#define GLM_PREFIX glmc_ +#define GLM(X) (glmc_ ## X) + +#include "test_quat.h" + +#undef GLM +#undef GLM_PREFIX + CGLM_INLINE void test_quat_mul_raw(versor p, versor q, versor dest) { diff --git a/test/src/test_quat.h b/test/src/test_quat.h new file mode 100644 index 0000000..2788329 --- /dev/null +++ b/test/src/test_quat.h @@ -0,0 +1,233 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +#ifndef CGLM_TEST_QUAT_ONCE +#define CGLM_TEST_QUAT_ONCE + +/* Macros */ + +TEST_IMPL(MACRO_GLM_QUAT_IDENTITY_INIT) { + versor v = GLM_QUAT_IDENTITY_INIT; + + ASSERT(test_eq(v[0], 0.0f)) + ASSERT(test_eq(v[1], 0.0f)) + ASSERT(test_eq(v[2], 0.0f)) + ASSERT(test_eq(v[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(MACRO_GLM_QUAT_IDENTITY) { + ASSERT(test_eq(GLM_QUAT_IDENTITY[0], 0.0f)) + ASSERT(test_eq(GLM_QUAT_IDENTITY[1], 0.0f)) + ASSERT(test_eq(GLM_QUAT_IDENTITY[2], 0.0f)) + ASSERT(test_eq(GLM_QUAT_IDENTITY[3], 1.0f)) + + TEST_SUCCESS +} + +#endif /* CGLM_TEST_QUAT_ONCE */ + +TEST_IMPL(GLM_PREFIX, quat_identity) { + versor a = GLM_QUAT_IDENTITY_INIT; + versor b = GLM_QUAT_IDENTITY_INIT; + versor c; + mat4 r; + + GLM(quat_identity)(c); + + ASSERTIFY(test_assert_quat_eq_identity(a)) + ASSERTIFY(test_assert_quat_eq_identity(b)) + ASSERTIFY(test_assert_quat_eq_identity(c)) + + glm_quat_identity(c); + ASSERT(test_eq(glm_quat_real(c), cosf(glm_rad(0.0f) * 0.5f))) + + glm_quat_mat4(c, r); + ASSERTIFY(test_assert_mat4_eq2(r, GLM_MAT4_IDENTITY, 0.000009f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_identity_array) { + int i, count; + versor quats[4] = { + {1.0f, 2.0f, 3.0f, 4.0f}, + {1.0f, 2.0f, 3.0f, 4.0f}, + {1.0f, 2.0f, 3.0f, 4.0f}, + {1.0f, 2.0f, 3.0f, 4.0f}, + }; + + count = 4; + + GLM(quat_identity_array)(quats, count); + + for (i = 0; i < count; i++) { + ASSERTIFY(test_assert_quat_eq_identity(quats[i])) + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_init) { + versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}; + versor q2 = {1.0f, 2.0f, 3.0f, 4.0f}; + versor q3 = {1.0f, 2.0f, 3.0f, 4.0f}; + + GLM(quat_init)(q1, 10.0f, 11.0f, 12.0f, 13.0f); + GLM(quat_init)(q2, 100.0f, 110.0f, 120.0f, 130.0f); + GLM(quat_init)(q3, 1000.0f, 1100.0f, 1200.0f, 1300.0f); + + ASSERT(q1[0] == 10.0f) + ASSERT(q1[1] == 11.0f) + ASSERT(q1[2] == 12.0f) + ASSERT(q1[3] == 13.0f) + + ASSERT(q2[0] == 100.0f) + ASSERT(q2[1] == 110.0f) + ASSERT(q2[2] == 120.0f) + ASSERT(q2[3] == 130.0f) + + ASSERT(q3[0] == 1000.0f) + ASSERT(q3[1] == 1100.0f) + ASSERT(q3[2] == 1200.0f) + ASSERT(q3[3] == 1300.0f) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quatv) { + versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}; + vec3 v1, v2; + float a1; + + test_rand_vec3(v1); + GLM(quatv)(q1, glm_rad(60.0f), v1); + + glm_quat_axis(q1, v2); + a1 = glm_quat_angle(q1); + + ASSERT(test_eq(a1, glm_rad(60.0f))) + + glm_vec3_normalize(v1); + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat) { + versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}; + vec3 v1, v2; + float a1; + + test_rand_vec3(v1); + GLM(quat)(q1, glm_rad(60.0f), v1[0], v1[1], v1[2]); + + glm_quat_axis(q1, v2); + a1 = glm_quat_angle(q1); + + ASSERT(test_eq(a1, glm_rad(60.0f))) + + glm_vec3_normalize(v1); + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_copy) { + versor v1 = {10.0f, 9.0f, 8.0f, 78.0f}; + versor v2 = {1.0f, 2.0f, 3.0f, 4.0f}; + + GLM(quat_copy)(v1, v2); + + ASSERTIFY(test_assert_vec4_eq(v1, v2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_norm) { + versor a = {10.0f, 9.0f, 8.0f, 78.0f}; + float n1, n2; + + n1 = GLM(quat_norm)(a); + n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]); + + ASSERT(test_eq(n1, n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_normalize_to) { + versor v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2; + float s = 1.0f; + float norm; + + GLM(quat_normalize_to)(v1, v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]); + if (norm <= 0.0f) { + ASSERTIFY(test_assert_quat_eq_identity(v1)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) + ASSERT(test_eq(v1[3] * norm, v2[3])) + + glm_vec4_zero(v1); + GLM(quat_normalize_to)(v1, v2); + ASSERTIFY(test_assert_quat_eq_identity(v2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_normalize) { + versor v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2 = {2.0f, -3.0f, 4.0f, 5.0f}; + float s = 1.0f; + float norm; + + GLM(quat_normalize)(v2); + + norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]); + if (norm <= 0.0f) { + ASSERTIFY(test_assert_quat_eq_identity(v1)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(test_eq(v1[0] * norm, v2[0])) + ASSERT(test_eq(v1[1] * norm, v2[1])) + ASSERT(test_eq(v1[2] * norm, v2[2])) + ASSERT(test_eq(v1[3] * norm, v2[3])) + + glm_vec4_zero(v1); + GLM(quat_normalize)(v1); + ASSERTIFY(test_assert_quat_eq_identity(v1)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_dot) { + versor a = {10.0f, 9.0f, 8.0f, 78.0f}; + versor b = {1.0f, 2.0f, 3.0f, 4.0f}; + float dot1, dot2; + + dot1 = GLM(quat_dot)(a, b); + dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; + + ASSERT(test_eq(dot1, dot2)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 1076a13..386a425 100644 --- a/test/tests.h +++ b/test/tests.h @@ -128,6 +128,30 @@ TEST_DECLARE(euler) /* quat */ TEST_DECLARE(quat) +TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY_INIT) +TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY) + +TEST_DECLARE(glm_quat_identity) +TEST_DECLARE(glm_quat_identity_array) +TEST_DECLARE(glm_quat_init) +TEST_DECLARE(glm_quatv) +TEST_DECLARE(glm_quat) +TEST_DECLARE(glm_quat_copy) +TEST_DECLARE(glm_quat_norm) +TEST_DECLARE(glm_quat_normalize_to) +TEST_DECLARE(glm_quat_normalize) +TEST_DECLARE(glm_quat_dot) + +TEST_DECLARE(glmc_quat_identity) +TEST_DECLARE(glmc_quat_identity_array) +TEST_DECLARE(glmc_quat_init) +TEST_DECLARE(glmc_quatv) +TEST_DECLARE(glmc_quat) +TEST_DECLARE(glmc_quat_copy) +TEST_DECLARE(glmc_quat_norm) +TEST_DECLARE(glmc_quat_normalize_to) +TEST_DECLARE(glmc_quat_normalize) +TEST_DECLARE(glmc_quat_dot) /* bezier */ TEST_DECLARE(bezier) @@ -557,7 +581,31 @@ TEST_LIST { /* quat */ TEST_ENTRY(quat) - + TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY_INIT) + TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY) + + TEST_ENTRY(glm_quat_identity) + TEST_ENTRY(glm_quat_identity_array) + TEST_ENTRY(glm_quat_init) + TEST_ENTRY(glm_quatv) + TEST_ENTRY(glm_quat) + TEST_ENTRY(glm_quat_copy) + TEST_ENTRY(glm_quat_norm) + TEST_ENTRY(glm_quat_normalize_to) + TEST_ENTRY(glm_quat_normalize) + TEST_ENTRY(glm_quat_dot) + + TEST_ENTRY(glmc_quat_identity) + TEST_ENTRY(glmc_quat_identity_array) + TEST_ENTRY(glmc_quat_init) + TEST_ENTRY(glmc_quatv) + TEST_ENTRY(glmc_quat) + TEST_ENTRY(glmc_quat_copy) + TEST_ENTRY(glmc_quat_norm) + TEST_ENTRY(glmc_quat_normalize_to) + TEST_ENTRY(glmc_quat_normalize) + TEST_ENTRY(glmc_quat_dot) + /* bezier */ TEST_ENTRY(bezier) From fb23d1998e3d7e5b1a2a823fa76c0c0d67ba176b Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 25 Sep 2019 12:43:01 +0300 Subject: [PATCH 050/103] tests: add more tests for quat --- test/src/test_quat.h | 193 +++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 40 +++++++++ 2 files changed, 233 insertions(+) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 2788329..e818188 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -231,3 +231,196 @@ TEST_IMPL(GLM_PREFIX, quat_dot) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, quat_conjugate) { + versor a = {10.0f, 9.0f, 8.0f, 78.0f}; + versor b = {1.0f, 2.0f, 3.0f, 4.0f}; + versor d, e; + + GLM(quat_conjugate)(a, d); + GLM(quat_conjugate)(b, e); + + ASSERT(test_eq(d[0], -a[0])) + ASSERT(test_eq(d[1], -a[1])) + ASSERT(test_eq(d[2], -a[2])) + ASSERT(test_eq(d[3], a[3])) + + ASSERT(test_eq(e[0], -b[0])) + ASSERT(test_eq(e[1], -b[1])) + ASSERT(test_eq(e[2], -b[2])) + ASSERT(test_eq(e[3], b[3])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_inv) { + versor a = {10.0f, 9.0f, 8.0f, 78.0f}; + versor b = {1.0f, 2.0f, 3.0f, 4.0f}; + versor d, e; + float n1, n2; + + n1 = 1.0f / glm_vec4_norm2(a); + n2 = 1.0f / glm_vec4_norm2(b); + + GLM(quat_inv)(a, d); + GLM(quat_inv)(b, e); + + ASSERT(test_eq(d[0], -a[0] * n1)) + ASSERT(test_eq(d[1], -a[1] * n1)) + ASSERT(test_eq(d[2], -a[2] * n1)) + ASSERT(test_eq(d[3], a[3] * n1)) + + ASSERT(test_eq(e[0], -b[0] * n2)) + ASSERT(test_eq(e[1], -b[1] * n2)) + ASSERT(test_eq(e[2], -b[2] * n2)) + ASSERT(test_eq(e[3], b[3] * n2)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_add) { + versor a = {-10.0f, 9.0f, -8.0f, 56.0f}; + versor b = {12.0f, 19.0f, -18.0f, 1.0f}; + versor c, d; + + c[0] = a[0] + b[0]; + c[1] = a[1] + b[1]; + c[2] = a[2] + b[2]; + c[3] = a[3] + b[3]; + + GLM(quat_add)(a, b, d); + + ASSERTIFY(test_assert_quat_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_sub) { + vec4 a = {-10.0f, 9.0f, -8.0f, 56.0f}; + vec4 b = {12.0f, 19.0f, -18.0f, 1.0f}; + vec4 c, d; + + c[0] = a[0] - b[0]; + c[1] = a[1] - b[1]; + c[2] = a[2] - b[2]; + c[3] = a[3] - b[3]; + + GLM(quat_sub)(a, b, d); + + ASSERTIFY(test_assert_quat_eq(c, d)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_real) { + versor a = {10.0f, 9.0f, 8.0f, 78.0f}; + versor b = {1.0f, 2.0f, 3.0f, 4.0f}; + + ASSERT(test_eq(GLM(quat_real)(a), 78.0f)) + ASSERT(test_eq(GLM(quat_real)(b), 4.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_imag) { + versor a = {10.0f, 9.0f, 8.0f, 78.0f}; + versor b = {1.0f, 2.0f, 3.0f, 4.0f}; + vec3 d, e; + + GLM(quat_imag)(a, d); + GLM(quat_imag)(b, e); + + ASSERT(test_eq(d[0], a[0])) + ASSERT(test_eq(d[1], a[1])) + ASSERT(test_eq(d[2], a[2])) + + ASSERT(test_eq(e[0], b[0])) + ASSERT(test_eq(e[1], b[1])) + ASSERT(test_eq(e[2], b[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_imagn) { + versor a = {10.0f, 9.0f, 8.0f, 78.0f}; + versor b = {1.0f, 2.0f, 3.0f, 4.0f}; + vec3 d, e; + + GLM(quat_imag)(a, d); + GLM(quat_imag)(b, e); + + glm_vec3_normalize(a); + glm_vec3_normalize(b); + glm_vec3_normalize(d); + glm_vec3_normalize(e); + + ASSERT(test_eq(d[0], a[0])) + ASSERT(test_eq(d[1], a[1])) + ASSERT(test_eq(d[2], a[2])) + + ASSERT(test_eq(e[0], b[0])) + ASSERT(test_eq(e[1], b[1])) + ASSERT(test_eq(e[2], b[2])) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_imaglen) { + versor a = {10.0f, 9.0f, 8.0f, 78.0f}; + versor b = {1.0f, 2.0f, 3.0f, 4.0f}; + + ASSERT(test_eq(GLM(quat_imaglen)(a), glm_vec3_norm(a))); + ASSERT(test_eq(GLM(quat_imaglen)(b), glm_vec3_norm(b))); + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_angle) { + versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}, q2, q3; + vec3 v1; + float a1, a2, a3; + + test_rand_vec3(v1); + GLM(quatv)(q1, glm_rad(60.140f), v1); + GLM(quatv)(q2, glm_rad(160.04f), v1); + GLM(quatv)(q3, glm_rad(20.350f), v1); + + a1 = GLM(quat_angle)(q1); + a2 = GLM(quat_angle)(q2); + a3 = GLM(quat_angle)(q3); + + ASSERT(test_eq(a1, glm_rad(60.140f))) + ASSERT(test_eq(a2, glm_rad(160.04f))) + ASSERT(test_eq(a3, glm_rad(20.350f))) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_axis) { + versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}, q2, q3; + vec3 v1, v2; + + test_rand_vec3(v1); + GLM(quatv)(q1, glm_rad(60.0f), v1); + + glm_quat_axis(q1, v2); + glm_vec3_normalize(v1); + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + test_rand_vec3(v1); + GLM(quatv)(q2, glm_rad(60.0f), v1); + + glm_quat_axis(q2, v2); + glm_vec3_normalize(v1); + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + test_rand_vec3(v1); + GLM(quatv)(q3, glm_rad(60.0f), v1); + + glm_quat_axis(q3, v2); + glm_vec3_normalize(v1); + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + TEST_SUCCESS +} + diff --git a/test/tests.h b/test/tests.h index 386a425..642bb82 100644 --- a/test/tests.h +++ b/test/tests.h @@ -141,6 +141,16 @@ TEST_DECLARE(glm_quat_norm) TEST_DECLARE(glm_quat_normalize_to) TEST_DECLARE(glm_quat_normalize) TEST_DECLARE(glm_quat_dot) +TEST_DECLARE(glm_quat_conjugate) +TEST_DECLARE(glm_quat_inv) +TEST_DECLARE(glm_quat_add) +TEST_DECLARE(glm_quat_sub) +TEST_DECLARE(glm_quat_real) +TEST_DECLARE(glm_quat_imag) +TEST_DECLARE(glm_quat_imagn) +TEST_DECLARE(glm_quat_imaglen) +TEST_DECLARE(glm_quat_angle) +TEST_DECLARE(glm_quat_axis) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -152,6 +162,16 @@ TEST_DECLARE(glmc_quat_norm) TEST_DECLARE(glmc_quat_normalize_to) TEST_DECLARE(glmc_quat_normalize) TEST_DECLARE(glmc_quat_dot) +TEST_DECLARE(glmc_quat_conjugate) +TEST_DECLARE(glmc_quat_inv) +TEST_DECLARE(glmc_quat_add) +TEST_DECLARE(glmc_quat_sub) +TEST_DECLARE(glmc_quat_real) +TEST_DECLARE(glmc_quat_imag) +TEST_DECLARE(glmc_quat_imagn) +TEST_DECLARE(glmc_quat_imaglen) +TEST_DECLARE(glmc_quat_angle) +TEST_DECLARE(glmc_quat_axis) /* bezier */ TEST_DECLARE(bezier) @@ -594,6 +614,16 @@ TEST_LIST { TEST_ENTRY(glm_quat_normalize_to) TEST_ENTRY(glm_quat_normalize) TEST_ENTRY(glm_quat_dot) + TEST_ENTRY(glm_quat_conjugate) + TEST_ENTRY(glm_quat_inv) + TEST_ENTRY(glm_quat_add) + TEST_ENTRY(glm_quat_sub) + TEST_ENTRY(glm_quat_real) + TEST_ENTRY(glm_quat_imag) + TEST_ENTRY(glm_quat_imagn) + TEST_ENTRY(glm_quat_imaglen) + TEST_ENTRY(glm_quat_angle) + TEST_ENTRY(glm_quat_axis) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -605,6 +635,16 @@ TEST_LIST { TEST_ENTRY(glmc_quat_normalize_to) TEST_ENTRY(glmc_quat_normalize) TEST_ENTRY(glmc_quat_dot) + TEST_ENTRY(glmc_quat_conjugate) + TEST_ENTRY(glmc_quat_inv) + TEST_ENTRY(glmc_quat_add) + TEST_ENTRY(glmc_quat_sub) + TEST_ENTRY(glmc_quat_real) + TEST_ENTRY(glmc_quat_imag) + TEST_ENTRY(glmc_quat_imagn) + TEST_ENTRY(glmc_quat_imaglen) + TEST_ENTRY(glmc_quat_angle) + TEST_ENTRY(glmc_quat_axis) /* bezier */ TEST_ENTRY(bezier) From 5b0e161502b972ba78eac7a3458e3694e8678f18 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 25 Sep 2019 13:47:26 +0300 Subject: [PATCH 051/103] tests: add some tests for quat --- test/src/test_quat.h | 235 ++++++++++++++++++++++++++++++++++++++++++- test/tests.h | 20 ++++ 2 files changed, 253 insertions(+), 2 deletions(-) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index e818188..5302664 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -346,8 +346,8 @@ TEST_IMPL(GLM_PREFIX, quat_imagn) { versor b = {1.0f, 2.0f, 3.0f, 4.0f}; vec3 d, e; - GLM(quat_imag)(a, d); - GLM(quat_imag)(b, e); + GLM(quat_imagn)(a, d); + GLM(quat_imagn)(b, e); glm_vec3_normalize(a); glm_vec3_normalize(b); @@ -424,3 +424,234 @@ TEST_IMPL(GLM_PREFIX, quat_axis) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, quat_mul) { + versor q1 = {2.0f, 3.0f, 4.0f, 5.0f}; + versor q2 = {6.0f, 7.0f, 8.0f, 9.0f}; + versor q3; + versor q4; + vec3 v1 = {1.5f, 2.5f, 3.5f}; + + GLM(quat_mul)(q1, q2, q3); + + ASSERT(test_eq(q3[0], q1[3] * q2[0] + q1[0] * q2[3] + q1[1] * q2[2] - q1[2] * q2[1])) + ASSERT(test_eq(q3[1], q1[3] * q2[1] - q1[0] * q2[2] + q1[1] * q2[3] + q1[2] * q2[0])) + ASSERT(test_eq(q3[2], q1[3] * q2[2] + q1[0] * q2[1] - q1[1] * q2[0] + q1[2] * q2[3])) + ASSERT(test_eq(q3[3], q1[3] * q2[3] - q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2])) + + glm_quatv(q1, glm_rad(30.0f), v1); + glm_quatv(q2, glm_rad(20.0f), v1); + glm_quatv(q3, glm_rad(50.0f), v1); + + GLM(quat_mul)(q1, q2, q4); + + ASSERTIFY(test_assert_quat_eq(q3, q4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_mat4) { + mat4 m1, m2; + versor q1, q2, q3; + vec3 axis1; + vec3 axis2 = {1.9f, 2.3f, 4.5f}; + int i; + + GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat_mat4)(q1, m1); + GLM(mat4_quat)(m1, q2); + + GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(mat4_quat)(m1, q3); + + GLM(quat_axis)(q3, axis1); + + GLM(vec3_normalize)(axis1); + GLM(vec3_normalize)(axis2); + + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) + ASSERTIFY(test_assert_vec4_eq(q1, q2)) + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + ASSERTIFY(test_assert_vec4_eq(q1, q3)) + + /* 1. test quat to mat and mat to quat */ + for (i = 0; i < 1000; i++) { + test_rand_quat(q1); + + GLM(quat_mat4)(q1, m1); + GLM(mat4_quat)(m1, q2); + GLM(quat_mat4)(q2, m2); + + /* 2. test first quat and generated one equality */ + ASSERTIFY(test_assert_quat_eq_abs(q1, q2)); + + /* 3. test first rot and second rotation */ + /* almost equal */ + ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f)); + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_mat4t) { + mat4 m1, m2; + versor q1, q2, q3; + vec3 axis1; + vec3 axis2 = {1.9f, 2.3f, 4.5f}; + int i; + + GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + + GLM(quat_mat4t)(q1, m1); + glm_mat4_transpose(m1); + + GLM(mat4_quat)(m1, q2); + + GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(mat4_quat)(m1, q3); + + GLM(quat_axis)(q3, axis1); + + GLM(vec3_normalize)(axis1); + GLM(vec3_normalize)(axis2); + + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) + ASSERTIFY(test_assert_vec4_eq(q1, q2)) + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + ASSERTIFY(test_assert_vec4_eq(q1, q3)) + + /* 1. test quat to mat and mat to quat */ + for (i = 0; i < 1000; i++) { + test_rand_quat(q1); + + GLM(quat_mat4t)(q1, m1); + glm_mat4_transpose(m1); + + GLM(mat4_quat)(m1, q2); + + GLM(quat_mat4t)(q2, m2); + glm_mat4_transpose(m2); + + /* 2. test first quat and generated one equality */ + ASSERTIFY(test_assert_quat_eq_abs(q1, q2)); + + /* 3. test first rot and second rotation */ + /* almost equal */ + ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f)); + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_mat3) { + mat4 m1, m2; + mat3 m3; + versor q1, q2, q3; + vec3 axis1; + vec3 axis2 = {1.9f, 2.3f, 4.5f}; + int i; + + GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat_mat3)(q1, m3); + glm_mat4_identity(m1); + glm_mat4_ins3(m3, m1); + + GLM(mat4_quat)(m1, q2); + + GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(mat4_quat)(m1, q3); + + GLM(quat_axis)(q3, axis1); + + GLM(vec3_normalize)(axis1); + GLM(vec3_normalize)(axis2); + + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) + ASSERTIFY(test_assert_vec4_eq(q1, q2)) + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + ASSERTIFY(test_assert_vec4_eq(q1, q3)) + + /* 1. test quat to mat and mat to quat */ + for (i = 0; i < 1000; i++) { + test_rand_quat(q1); + + GLM(quat_mat3)(q1, m3); + glm_mat4_identity(m1); + glm_mat4_ins3(m3, m1); + + GLM(mat4_quat)(m1, q2); + + GLM(quat_mat3)(q2, m3); + glm_mat4_identity(m2); + glm_mat4_ins3(m3, m2); + + /* 2. test first quat and generated one equality */ + ASSERTIFY(test_assert_quat_eq_abs(q1, q2)); + + /* 3. test first rot and second rotation */ + /* almost equal */ + ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f)); + } + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_mat3t) { + mat4 m1, m2; + mat3 m3; + versor q1, q2, q3; + vec3 axis1; + vec3 axis2 = {1.9f, 2.3f, 4.5f}; + int i; + + GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + + GLM(quat_mat3t)(q1, m3); + glm_mat3_transpose(m3); + glm_mat4_identity(m1); + glm_mat4_ins3(m3, m1); + + GLM(mat4_quat)(m1, q2); + + GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(mat4_quat)(m1, q3); + + GLM(quat_axis)(q3, axis1); + + GLM(vec3_normalize)(axis1); + GLM(vec3_normalize)(axis2); + + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) + ASSERTIFY(test_assert_vec4_eq(q1, q2)) + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + ASSERTIFY(test_assert_vec4_eq(q1, q3)) + + /* 1. test quat to mat and mat to quat */ + for (i = 0; i < 1000; i++) { + test_rand_quat(q1); + + GLM(quat_mat3t)(q1, m3); + glm_mat3_transpose(m3); + glm_mat4_identity(m1); + glm_mat4_ins3(m3, m1); + + GLM(mat4_quat)(m1, q2); + + GLM(quat_mat3t)(q2, m3); + glm_mat3_transpose(m3); + glm_mat4_identity(m2); + glm_mat4_ins3(m3, m2); + + /* 2. test first quat and generated one equality */ + ASSERTIFY(test_assert_quat_eq_abs(q1, q2)); + + /* 3. test first rot and second rotation */ + /* almost equal */ + ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f)); + } + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 642bb82..ebc48f6 100644 --- a/test/tests.h +++ b/test/tests.h @@ -151,6 +151,11 @@ TEST_DECLARE(glm_quat_imagn) TEST_DECLARE(glm_quat_imaglen) TEST_DECLARE(glm_quat_angle) TEST_DECLARE(glm_quat_axis) +TEST_DECLARE(glm_quat_mul) +TEST_DECLARE(glm_quat_mat4) +TEST_DECLARE(glm_quat_mat4t) +TEST_DECLARE(glm_quat_mat3) +TEST_DECLARE(glm_quat_mat3t) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -172,6 +177,11 @@ TEST_DECLARE(glmc_quat_imagn) TEST_DECLARE(glmc_quat_imaglen) TEST_DECLARE(glmc_quat_angle) TEST_DECLARE(glmc_quat_axis) +TEST_DECLARE(glmc_quat_mul) +TEST_DECLARE(glmc_quat_mat4) +TEST_DECLARE(glmc_quat_mat4t) +TEST_DECLARE(glmc_quat_mat3) +TEST_DECLARE(glmc_quat_mat3t) /* bezier */ TEST_DECLARE(bezier) @@ -624,6 +634,11 @@ TEST_LIST { TEST_ENTRY(glm_quat_imaglen) TEST_ENTRY(glm_quat_angle) TEST_ENTRY(glm_quat_axis) + TEST_ENTRY(glm_quat_mul) + TEST_ENTRY(glm_quat_mat4) + TEST_ENTRY(glm_quat_mat4t) + TEST_ENTRY(glm_quat_mat3) + TEST_ENTRY(glm_quat_mat3t) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -645,6 +660,11 @@ TEST_LIST { TEST_ENTRY(glmc_quat_imaglen) TEST_ENTRY(glmc_quat_angle) TEST_ENTRY(glmc_quat_axis) + TEST_ENTRY(glmc_quat_mul) + TEST_ENTRY(glmc_quat_mat4) + TEST_ENTRY(glmc_quat_mat4t) + TEST_ENTRY(glmc_quat_mat3) + TEST_ENTRY(glmc_quat_mat3t) /* bezier */ TEST_ENTRY(bezier) From ca9b8ceac33218863db7ebf2086fea62d18b164e Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 25 Sep 2019 14:03:58 +0300 Subject: [PATCH 052/103] tests: add some tests for quat --- test/src/test_quat.h | 52 ++++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 8 +++++++ 2 files changed, 60 insertions(+) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 5302664..90e4bb6 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -655,3 +655,55 @@ TEST_IMPL(GLM_PREFIX, quat_mat3t) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, quat_lerp) { + versor v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + versor v2 = {100.0f, 200.0f, 10.0f, 10.0f}; + versor v3; + + GLM(vec4_lerp)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + ASSERT(test_eq(v3[3], 0.0f)) + + GLM(vec4_lerp)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.0f)) + ASSERT(test_eq(v3[2], 5.0f)) + ASSERT(test_eq(v3[3], 5.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_lerpc) { + versor v1 = {-100.0f, -200.0f, -10.0f, -10.0f}; + versor v2 = {100.0f, 200.0f, 10.0f, 10.0f}; + versor v3; + + GLM(vec4_lerpc)(v1, v2, 0.5f, v3); + ASSERT(test_eq(v3[0], 0.0f)) + ASSERT(test_eq(v3[1], 0.0f)) + ASSERT(test_eq(v3[2], 0.0f)) + ASSERT(test_eq(v3[3], 0.0f)) + + GLM(vec4_lerpc)(v1, v2, 0.75f, v3); + ASSERT(test_eq(v3[0], 50.0f)) + ASSERT(test_eq(v3[1], 100.0f)) + ASSERT(test_eq(v3[2], 5.0f)) + ASSERT(test_eq(v3[3], 5.0f)) + + GLM(vec4_lerpc)(v1, v2, -1.75f, v3); + ASSERT(test_eq(v3[0], -100.0f)) + ASSERT(test_eq(v3[1], -200.0f)) + ASSERT(test_eq(v3[2], -10.0f)) + ASSERT(test_eq(v3[3], -10.0f)) + + GLM(vec4_lerpc)(v1, v2, 1.75f, v3); + ASSERT(test_eq(v3[0], 100.0f)) + ASSERT(test_eq(v3[1], 200.0f)) + ASSERT(test_eq(v3[2], 10.0f)) + ASSERT(test_eq(v3[3], 10.0f)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index ebc48f6..570e6a6 100644 --- a/test/tests.h +++ b/test/tests.h @@ -156,6 +156,8 @@ TEST_DECLARE(glm_quat_mat4) TEST_DECLARE(glm_quat_mat4t) TEST_DECLARE(glm_quat_mat3) TEST_DECLARE(glm_quat_mat3t) +TEST_DECLARE(glm_quat_lerp) +TEST_DECLARE(glm_quat_lerpc) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -182,6 +184,8 @@ TEST_DECLARE(glmc_quat_mat4) TEST_DECLARE(glmc_quat_mat4t) TEST_DECLARE(glmc_quat_mat3) TEST_DECLARE(glmc_quat_mat3t) +TEST_DECLARE(glmc_quat_lerp) +TEST_DECLARE(glmc_quat_lerpc) /* bezier */ TEST_DECLARE(bezier) @@ -639,6 +643,8 @@ TEST_LIST { TEST_ENTRY(glm_quat_mat4t) TEST_ENTRY(glm_quat_mat3) TEST_ENTRY(glm_quat_mat3t) + TEST_ENTRY(glm_quat_lerp) + TEST_ENTRY(glm_quat_lerpc) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -665,6 +671,8 @@ TEST_LIST { TEST_ENTRY(glmc_quat_mat4t) TEST_ENTRY(glmc_quat_mat3) TEST_ENTRY(glmc_quat_mat3t) + TEST_ENTRY(glmc_quat_lerp) + TEST_ENTRY(glmc_quat_lerpc) /* bezier */ TEST_ENTRY(bezier) From 212cf3b22d0a953d225c14c9dece644a5554c509 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 26 Sep 2019 19:29:45 +0300 Subject: [PATCH 053/103] Update test_quat.h --- test/src/test_quat.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 90e4bb6..d1a9dea 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -661,13 +661,13 @@ TEST_IMPL(GLM_PREFIX, quat_lerp) { versor v2 = {100.0f, 200.0f, 10.0f, 10.0f}; versor v3; - GLM(vec4_lerp)(v1, v2, 0.5f, v3); + GLM(quat_lerp)(v1, v2, 0.5f, v3); ASSERT(test_eq(v3[0], 0.0f)) ASSERT(test_eq(v3[1], 0.0f)) ASSERT(test_eq(v3[2], 0.0f)) ASSERT(test_eq(v3[3], 0.0f)) - GLM(vec4_lerp)(v1, v2, 0.75f, v3); + GLM(quat_lerp)(v1, v2, 0.75f, v3); ASSERT(test_eq(v3[0], 50.0f)) ASSERT(test_eq(v3[1], 100.0f)) ASSERT(test_eq(v3[2], 5.0f)) @@ -681,25 +681,25 @@ TEST_IMPL(GLM_PREFIX, quat_lerpc) { versor v2 = {100.0f, 200.0f, 10.0f, 10.0f}; versor v3; - GLM(vec4_lerpc)(v1, v2, 0.5f, v3); + GLM(quat_lerpc)(v1, v2, 0.5f, v3); ASSERT(test_eq(v3[0], 0.0f)) ASSERT(test_eq(v3[1], 0.0f)) ASSERT(test_eq(v3[2], 0.0f)) ASSERT(test_eq(v3[3], 0.0f)) - GLM(vec4_lerpc)(v1, v2, 0.75f, v3); + GLM(quat_lerpc)(v1, v2, 0.75f, v3); ASSERT(test_eq(v3[0], 50.0f)) ASSERT(test_eq(v3[1], 100.0f)) ASSERT(test_eq(v3[2], 5.0f)) ASSERT(test_eq(v3[3], 5.0f)) - GLM(vec4_lerpc)(v1, v2, -1.75f, v3); + GLM(quat_lerpc)(v1, v2, -1.75f, v3); ASSERT(test_eq(v3[0], -100.0f)) ASSERT(test_eq(v3[1], -200.0f)) ASSERT(test_eq(v3[2], -10.0f)) ASSERT(test_eq(v3[3], -10.0f)) - GLM(vec4_lerpc)(v1, v2, 1.75f, v3); + GLM(quat_lerpc)(v1, v2, 1.75f, v3); ASSERT(test_eq(v3[0], 100.0f)) ASSERT(test_eq(v3[1], 200.0f)) ASSERT(test_eq(v3[2], 10.0f)) From 841257a2089e33a312f3b73f77b5949f70065bae Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 26 Sep 2019 19:57:00 +0300 Subject: [PATCH 054/103] tests: add test for quat_slerp --- test/src/test_quat.h | 32 ++++++++++++++++++++++++++++++++ test/tests.h | 4 ++++ 2 files changed, 36 insertions(+) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index d1a9dea..2c14163 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -707,3 +707,35 @@ TEST_IMPL(GLM_PREFIX, quat_lerpc) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, quat_slerp) { + versor q1, q2, q3, q4; + vec3 v1 = {10.0f, 0.0f, 0.0f}, v2; + + glm_quatv(q1, glm_rad(30.0f), v1); + glm_quatv(q2, glm_rad(90.0f), v1); + + q1[0] = 10.0f; + GLM(quat_slerp)(q1, q2, 1.0f, q3); + ASSERTIFY(test_assert_quat_eq(q1, q3)); + + glm_quatv(q1, glm_rad(30.001), v1); + glm_quatv(q2, glm_rad(30.002), v1); + GLM(quat_slerp)(q1, q2, 0.7f, q3); + glm_quat_lerp(q1, q2, 0.7f, q4); + ASSERTIFY(test_assert_quat_eq(q3, q4)); + + glm_quatv(q1, glm_rad(30.0f), v1); + glm_quatv(q2, glm_rad(90.0f), v1); + GLM(quat_slerp)(q1, q2, 0.5f, q3); + + glm_quat_axis(q3, v2); + glm_vec3_normalize(v1); + glm_vec3_normalize(v2); + + ASSERT(glm_quat_angle(q3) > glm_rad(30.0f)); + ASSERT(glm_quat_angle(q3) < glm_rad(90.0f)); + ASSERTIFY(test_assert_vec3_eq(v1, v2)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 570e6a6..1d152f4 100644 --- a/test/tests.h +++ b/test/tests.h @@ -158,6 +158,7 @@ TEST_DECLARE(glm_quat_mat3) TEST_DECLARE(glm_quat_mat3t) TEST_DECLARE(glm_quat_lerp) TEST_DECLARE(glm_quat_lerpc) +TEST_DECLARE(glm_quat_slerp) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -186,6 +187,7 @@ TEST_DECLARE(glmc_quat_mat3) TEST_DECLARE(glmc_quat_mat3t) TEST_DECLARE(glmc_quat_lerp) TEST_DECLARE(glmc_quat_lerpc) +TEST_DECLARE(glmc_quat_slerp) /* bezier */ TEST_DECLARE(bezier) @@ -645,6 +647,7 @@ TEST_LIST { TEST_ENTRY(glm_quat_mat3t) TEST_ENTRY(glm_quat_lerp) TEST_ENTRY(glm_quat_lerpc) + TEST_ENTRY(glm_quat_slerp) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -673,6 +676,7 @@ TEST_LIST { TEST_ENTRY(glmc_quat_mat3t) TEST_ENTRY(glmc_quat_lerp) TEST_ENTRY(glmc_quat_lerpc) + TEST_ENTRY(glmc_quat_slerp) /* bezier */ TEST_ENTRY(bezier) From 7cdeada70129c08f40ca89b523e71b4428b55029 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 27 Sep 2019 17:53:51 +0300 Subject: [PATCH 055/103] tests: add test for glm_quat_look --- test/src/test_quat.h | 23 +++++++++++++++++++++++ test/tests.h | 4 ++++ 2 files changed, 27 insertions(+) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 2c14163..0001f44 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -739,3 +739,26 @@ TEST_IMPL(GLM_PREFIX, quat_slerp) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, quat_look) { + versor q1; + vec3 v1 = {0.0f, 1.0f, 0.0f}; + mat4 m1, m2; + + glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f); + GLM(quat_look)(v1, q1, m1); + + glm_look(v1, (vec3){-1.0f, 0.0f, 0.0f}, GLM_YUP, m2); + ASSERTIFY(test_assert_mat4_eq(m1, m2)); + + glm_quat(q1, glm_rad(180.0f), 0.0f, 1.0f, 0.0f); + GLM(quat_look)(v1, q1, m1); + + glm_look(v1, (vec3){0.0f, 0.0f, 1.0f}, GLM_YUP, m2); + + glm_mat4_print(m1, stderr); + glm_mat4_print(m2, stderr); + ASSERTIFY(test_assert_mat4_eq(m1, m2)); + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 1d152f4..2193b84 100644 --- a/test/tests.h +++ b/test/tests.h @@ -159,6 +159,7 @@ TEST_DECLARE(glm_quat_mat3t) TEST_DECLARE(glm_quat_lerp) TEST_DECLARE(glm_quat_lerpc) TEST_DECLARE(glm_quat_slerp) +TEST_DECLARE(glm_quat_look) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -188,6 +189,7 @@ TEST_DECLARE(glmc_quat_mat3t) TEST_DECLARE(glmc_quat_lerp) TEST_DECLARE(glmc_quat_lerpc) TEST_DECLARE(glmc_quat_slerp) +TEST_DECLARE(glmc_quat_look) /* bezier */ TEST_DECLARE(bezier) @@ -648,6 +650,7 @@ TEST_LIST { TEST_ENTRY(glm_quat_lerp) TEST_ENTRY(glm_quat_lerpc) TEST_ENTRY(glm_quat_slerp) + TEST_ENTRY(glm_quat_look) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -677,6 +680,7 @@ TEST_LIST { TEST_ENTRY(glmc_quat_lerp) TEST_ENTRY(glmc_quat_lerpc) TEST_ENTRY(glmc_quat_slerp) + TEST_ENTRY(glmc_quat_look) /* bezier */ TEST_ENTRY(bezier) From 381e66349a2bac432def418874017e53eace122c Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Mon, 14 Oct 2019 19:08:34 +0300 Subject: [PATCH 056/103] win,test: fix test build for windows and suppress warnings --- include/cglm/bezier.h | 6 +-- test/include/common.h | 7 +++- test/runner.c | 4 -- test/src/test_mat3.h | 8 ++-- test/src/test_mat4.h | 10 ++--- test/src/test_quat.h | 36 +++++++++--------- test/src/test_vec3.h | 70 +++++++++++++++++------------------ test/src/test_vec4.h | 46 +++++++++++------------ win/cglm-test.vcxproj | 6 +++ win/cglm-test.vcxproj.filters | 18 +++++++++ 10 files changed, 116 insertions(+), 95 deletions(-) diff --git a/include/cglm/bezier.h b/include/cglm/bezier.h index 5dac859..2bbe09f 100644 --- a/include/cglm/bezier.h +++ b/include/cglm/bezier.h @@ -22,9 +22,9 @@ #define GLM_BEZIER_MAT ((mat4)GLM_BEZIER_MAT_INIT) #define GLM_HERMITE_MAT ((mat4)GLM_HERMITE_MAT_INIT) -#define CGLM_DECASTEL_EPS 1e-9 -#define CGLM_DECASTEL_MAX 1000 -#define CGLM_DECASTEL_SMALL 1e-20 +#define CGLM_DECASTEL_EPS 1e-9f +#define CGLM_DECASTEL_MAX 1000.0f +#define CGLM_DECASTEL_SMALL 1e-20f /*! * @brief cubic bezier interpolation diff --git a/test/include/common.h b/test/include/common.h index ac7059a..3c32b9f 100644 --- a/test/include/common.h +++ b/test/include/common.h @@ -52,6 +52,9 @@ typedef struct test_entry_t { #define TEST_ENTRY(FUN) { #FUN, test_ ## FUN, 0, 0 }, #define TEST_LIST static test_entry_t tests[] = +/* __VA_ARGS__ workaround for MSVC: https://stackoverflow.com/a/5134656 */ +#define EXPAND(x) x + #define TEST_OK 1 #define TEST_SUCCESS return (test_status_t){NULL, TEST_OK}; @@ -63,9 +66,9 @@ typedef struct test_entry_t { #define TEST_IMPL_ARG3(arg1, arg2, arg3, ...) arg3 #define TEST_IMPL_CHOOSER(...) \ - TEST_IMPL_ARG3(__VA_ARGS__, TEST_IMPL_ARG2, TEST_IMPL_ARG1) + EXPAND(TEST_IMPL_ARG3(__VA_ARGS__, TEST_IMPL_ARG2, TEST_IMPL_ARG1)) -#define TEST_IMPL(...) TEST_IMPL_CHOOSER(__VA_ARGS__)(__VA_ARGS__) +#define TEST_IMPL(...) EXPAND(TEST_IMPL_CHOOSER(__VA_ARGS__)(__VA_ARGS__)) #define ASSERT_EXT(expr, msg) \ if (!(expr)) { \ diff --git a/test/runner.c b/test/runner.c index 80c4e8f..7d4d858 100644 --- a/test/runner.c +++ b/test/runner.c @@ -71,10 +71,6 @@ main(int argc, const char * argv[]) { fprintf(stderr, "\n" RESET); passed++; } - - struct timespec t; - t.tv_nsec = 100000000 * 0.5; -// nanosleep(&t, NULL); } if (failed == 0) { diff --git a/test/src/test_mat3.h b/test/src/test_mat3.h index 87947df..8e2bc5e 100644 --- a/test/src/test_mat3.h +++ b/test/src/test_mat3.h @@ -134,11 +134,11 @@ TEST_IMPL(GLM_PREFIX, mat3_quat) { vec3 axis1; vec3 axis2 = {1.9f, 2.3f, 4.5f}; - GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f); GLM(quat_mat3)(q1, m1); GLM(mat3_quat)(m1, q2); - GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(rotate_make)(m2, GLM_PI_4f, axis2); GLM(mat3_quat)(m1, q3); GLM(quat_axis)(q3, axis1); @@ -148,7 +148,7 @@ TEST_IMPL(GLM_PREFIX, mat3_quat) { GLM(mat4_pick3)(m2, m3); - ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) ASSERTIFY(test_assert_vec4_eq(q1, q2)) ASSERTIFY(test_assert_mat3_eq(m1, m3)) @@ -187,7 +187,7 @@ TEST_IMPL(GLM_PREFIX, mat3_scale) { scale = rand() % 100; - GLM(mat3_scale)(m1, scale); + GLM(mat3_scale)(m1, (float)scale); for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { diff --git a/test/src/test_mat4.h b/test/src/test_mat4.h index 9463714..8f24bac 100644 --- a/test/src/test_mat4.h +++ b/test/src/test_mat4.h @@ -244,11 +244,11 @@ TEST_IMPL(GLM_PREFIX, mat4_quat) { vec3 axis1; vec3 axis2 = {1.9f, 2.3f, 4.5f}; - GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f); GLM(quat_mat4)(q1, m1); GLM(mat4_quat)(m1, q2); - GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(rotate_make)(m2, GLM_PI_4f, axis2); GLM(mat4_quat)(m1, q3); GLM(quat_axis)(q3, axis1); @@ -256,7 +256,7 @@ TEST_IMPL(GLM_PREFIX, mat4_quat) { GLM(vec3_normalize)(axis1); GLM(vec3_normalize)(axis2); - ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) ASSERTIFY(test_assert_vec4_eq(q1, q2)) ASSERTIFY(test_assert_mat4_eq(m1, m2)) @@ -295,7 +295,7 @@ TEST_IMPL(GLM_PREFIX, mat4_scale_p) { scale = rand() % 100; - GLM(mat4_scale_p)(m1, scale); + GLM(mat4_scale_p)(m1, (float)scale); for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { @@ -314,7 +314,7 @@ TEST_IMPL(GLM_PREFIX, mat4_scale) { scale = rand() % 100; - GLM(mat4_scale)(m1, scale); + GLM(mat4_scale)(m1, (float)scale); for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 0001f44..b16732a 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -456,11 +456,11 @@ TEST_IMPL(GLM_PREFIX, quat_mat4) { vec3 axis2 = {1.9f, 2.3f, 4.5f}; int i; - GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f); GLM(quat_mat4)(q1, m1); GLM(mat4_quat)(m1, q2); - GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(rotate_make)(m2, GLM_PI_4f, axis2); GLM(mat4_quat)(m1, q3); GLM(quat_axis)(q3, axis1); @@ -468,7 +468,7 @@ TEST_IMPL(GLM_PREFIX, quat_mat4) { GLM(vec3_normalize)(axis1); GLM(vec3_normalize)(axis2); - ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) ASSERTIFY(test_assert_vec4_eq(q1, q2)) ASSERTIFY(test_assert_mat4_eq(m1, m2)) @@ -500,14 +500,14 @@ TEST_IMPL(GLM_PREFIX, quat_mat4t) { vec3 axis2 = {1.9f, 2.3f, 4.5f}; int i; - GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f); GLM(quat_mat4t)(q1, m1); glm_mat4_transpose(m1); GLM(mat4_quat)(m1, q2); - GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(rotate_make)(m2, GLM_PI_4f, axis2); GLM(mat4_quat)(m1, q3); GLM(quat_axis)(q3, axis1); @@ -515,7 +515,7 @@ TEST_IMPL(GLM_PREFIX, quat_mat4t) { GLM(vec3_normalize)(axis1); GLM(vec3_normalize)(axis2); - ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) ASSERTIFY(test_assert_vec4_eq(q1, q2)) ASSERTIFY(test_assert_mat4_eq(m1, m2)) @@ -552,14 +552,14 @@ TEST_IMPL(GLM_PREFIX, quat_mat3) { vec3 axis2 = {1.9f, 2.3f, 4.5f}; int i; - GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f); GLM(quat_mat3)(q1, m3); glm_mat4_identity(m1); glm_mat4_ins3(m3, m1); GLM(mat4_quat)(m1, q2); - GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(rotate_make)(m2, GLM_PI_4f, axis2); GLM(mat4_quat)(m1, q3); GLM(quat_axis)(q3, axis1); @@ -567,7 +567,7 @@ TEST_IMPL(GLM_PREFIX, quat_mat3) { GLM(vec3_normalize)(axis1); GLM(vec3_normalize)(axis2); - ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) ASSERTIFY(test_assert_vec4_eq(q1, q2)) ASSERTIFY(test_assert_mat4_eq(m1, m2)) @@ -606,7 +606,7 @@ TEST_IMPL(GLM_PREFIX, quat_mat3t) { vec3 axis2 = {1.9f, 2.3f, 4.5f}; int i; - GLM(quat)(q1, GLM_PI_4, 1.9f, 2.3f, 4.5f); + GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f); GLM(quat_mat3t)(q1, m3); glm_mat3_transpose(m3); @@ -615,7 +615,7 @@ TEST_IMPL(GLM_PREFIX, quat_mat3t) { GLM(mat4_quat)(m1, q2); - GLM(rotate_make)(m2, GLM_PI_4, axis2); + GLM(rotate_make)(m2, GLM_PI_4f, axis2); GLM(mat4_quat)(m1, q3); GLM(quat_axis)(q3, axis1); @@ -623,7 +623,7 @@ TEST_IMPL(GLM_PREFIX, quat_mat3t) { GLM(vec3_normalize)(axis1); GLM(vec3_normalize)(axis2); - ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4)) + ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f)) ASSERTIFY(test_assert_vec3_eq(axis1, axis2)) ASSERTIFY(test_assert_vec4_eq(q1, q2)) ASSERTIFY(test_assert_mat4_eq(m1, m2)) @@ -719,8 +719,8 @@ TEST_IMPL(GLM_PREFIX, quat_slerp) { GLM(quat_slerp)(q1, q2, 1.0f, q3); ASSERTIFY(test_assert_quat_eq(q1, q3)); - glm_quatv(q1, glm_rad(30.001), v1); - glm_quatv(q2, glm_rad(30.002), v1); + glm_quatv(q1, glm_rad(30.001f), v1); + glm_quatv(q2, glm_rad(30.002f), v1); GLM(quat_slerp)(q1, q2, 0.7f, q3); glm_quat_lerp(q1, q2, 0.7f, q4); ASSERTIFY(test_assert_quat_eq(q3, q4)); @@ -751,14 +751,12 @@ TEST_IMPL(GLM_PREFIX, quat_look) { glm_look(v1, (vec3){-1.0f, 0.0f, 0.0f}, GLM_YUP, m2); ASSERTIFY(test_assert_mat4_eq(m1, m2)); - glm_quat(q1, glm_rad(180.0f), 0.0f, 1.0f, 0.0f); + glm_quat(q1, glm_rad(180.0f), 1.0f, 0.0f, 0.0f); GLM(quat_look)(v1, q1, m1); - + glm_look(v1, (vec3){0.0f, 0.0f, 1.0f}, GLM_YUP, m2); - glm_mat4_print(m1, stderr); - glm_mat4_print(m2, stderr); ASSERTIFY(test_assert_mat4_eq(m1, m2)); - + TEST_SUCCESS } diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 9b99525..4583950 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -781,12 +781,12 @@ TEST_IMPL(GLM_PREFIX, vec3_angle) { a = GLM(vec3_angle)(v1, v2); ASSERT(!isinf(a)) ASSERT(!isnan(a)) - ASSERT(test_eq(a, GLM_PI_4)) + ASSERT(test_eq(a, GLM_PI_4f)) a = GLM(vec3_angle)(v1, v3); ASSERT(!isinf(a)) ASSERT(!isnan(a)) - ASSERT(test_eq(a, GLM_PI_2)) + ASSERT(test_eq(a, GLM_PI_2f)) TEST_SUCCESS } @@ -795,56 +795,56 @@ TEST_IMPL(GLM_PREFIX, vec3_rotate) { vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f}; /* rotate X around Y = -Z */ - GLM(vec3_rotate)(v1, GLM_PI_2, GLM_YUP); + GLM(vec3_rotate)(v1, GLM_PI_2f, GLM_YUP); ASSERT(test_eq(v1[0], 0.0f)) ASSERT(test_eq(v1[1], 0.0f)) ASSERT(test_eq(v1[2], -1.0f)) /* rotate -Z around X = Y */ - GLM(vec3_rotate)(v1, GLM_PI_2, GLM_XUP); + GLM(vec3_rotate)(v1, GLM_PI_2f, GLM_XUP); ASSERT(test_eq(v1[0], 0.0f)) ASSERT(test_eq(v1[1], 1.0f)) ASSERT(test_eq(v1[2], 0.0f)) /* rotate Y around Z = -X */ - GLM(vec3_rotate)(v1, GLM_PI_2, GLM_ZUP); + GLM(vec3_rotate)(v1, GLM_PI_2f, GLM_ZUP); ASSERT(test_eq(v1[0], -1.0f)) ASSERT(test_eq(v1[1], 0.0f)) ASSERT(test_eq(v1[2], 0.0f)) /* rotate v2 around Y by 90deg */ - GLM(vec3_rotate)(v2, GLM_PI_2, GLM_YUP); + GLM(vec3_rotate)(v2, GLM_PI_2f, GLM_YUP); ASSERT(test_eq(v2[0], 1.0f)) ASSERT(test_eq(v2[1], 1.0f)) ASSERT(test_eq(v2[2], -1.0f)) /* rotate v2 around Y by 90deg */ - GLM(vec3_rotate)(v2, GLM_PI_2, GLM_YUP); + GLM(vec3_rotate)(v2, GLM_PI_2f, GLM_YUP); ASSERT(test_eq(v2[0], -1.0f)) ASSERT(test_eq(v2[1], 1.0f)) ASSERT(test_eq(v2[2], -1.0f)) /* rotate v2 around Y by 90deg */ - GLM(vec3_rotate)(v2, GLM_PI_2, GLM_YUP); + GLM(vec3_rotate)(v2, GLM_PI_2f, GLM_YUP); ASSERT(test_eq(v2[0], -1.0f)) ASSERT(test_eq(v2[1], 1.0f)) ASSERT(test_eq(v2[2], 1.0f)) /* rotate v2 around X by 90deg */ - GLM(vec3_rotate)(v2, GLM_PI_2, GLM_XUP); + GLM(vec3_rotate)(v2, GLM_PI_2f, GLM_XUP); ASSERT(test_eq(v2[0], -1.0f)) ASSERT(test_eq(v2[1], -1.0f)) ASSERT(test_eq(v2[2], 1.0f)) /* rotate v2 around Z by 90deg */ - GLM(vec3_rotate)(v2, GLM_PI_2, GLM_ZUP); + GLM(vec3_rotate)(v2, GLM_PI_2f, GLM_ZUP); ASSERT(test_eq(v2[0], 1.0f)) ASSERT(test_eq(v2[1], -1.0f)) @@ -857,9 +857,9 @@ TEST_IMPL(GLM_PREFIX, vec3_rotate_m4) { vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f}; mat4 x, y, z; - glm_rotate_make(x, GLM_PI_2, GLM_XUP); - glm_rotate_make(y, GLM_PI_2, GLM_YUP); - glm_rotate_make(z, GLM_PI_2, GLM_ZUP); + glm_rotate_make(x, GLM_PI_2f, GLM_XUP); + glm_rotate_make(y, GLM_PI_2f, GLM_YUP); + glm_rotate_make(z, GLM_PI_2f, GLM_ZUP); /* rotate X around Y = -Z */ GLM(vec3_rotate_m4)(y, v1, v1); @@ -926,9 +926,9 @@ TEST_IMPL(GLM_PREFIX, vec3_rotate_m3) { mat4 x0, y0, z0; mat3 x, y, z; - glm_rotate_make(x0, GLM_PI_2, GLM_XUP); - glm_rotate_make(y0, GLM_PI_2, GLM_YUP); - glm_rotate_make(z0, GLM_PI_2, GLM_ZUP); + glm_rotate_make(x0, GLM_PI_2f, GLM_XUP); + glm_rotate_make(y0, GLM_PI_2f, GLM_YUP); + glm_rotate_make(z0, GLM_PI_2f, GLM_ZUP); glm_mat4_pick3(x0, x); glm_mat4_pick3(y0, y); @@ -1131,17 +1131,17 @@ TEST_IMPL(GLM_PREFIX, vec3_ortho) { a = glm_vec3_angle(v1, v5); ASSERT(!isinf(a)) ASSERT(!isnan(a)) - ASSERT(test_eq(a, GLM_PI_2)) + ASSERT(test_eq(a, GLM_PI_2f)) a = glm_vec3_angle(v2, v6); ASSERT(!isinf(a)) ASSERT(!isnan(a)) - ASSERT(test_eq(a, GLM_PI_2)) + ASSERT(test_eq(a, GLM_PI_2f)) a = glm_vec3_angle(v3, v7); ASSERT(!isinf(a)) ASSERT(!isnan(a)) - ASSERT(test_eq(a, GLM_PI_2)) + ASSERT(test_eq(a, GLM_PI_2f)) TEST_SUCCESS } @@ -1314,14 +1314,14 @@ TEST_IMPL(GLM_PREFIX, vec3_smoothstep_uni) { vec3 v2; GLM(vec3_smoothstep_uni)(-200.0f, -100.0f, v1, v2); - ASSERT(test_eq_th(v2[0], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[0], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5f)) GLM(vec3_smoothstep_uni)(-250.0f, -200.0f, v1, v2); - ASSERT(test_eq_th(v2[0], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[1], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[0], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[1], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5f)) GLM(vec3_smoothstep_uni)(-200.0f, 200, v1, v2); ASSERT(v2[0] > 0.0f && v2[0] < 0.25f) @@ -1342,19 +1342,19 @@ TEST_IMPL(GLM_PREFIX, vec3_smoothstep) { vec3 v2; GLM(vec3_smoothstep)(e1_0, e1_1, v1, v2); - ASSERT(test_eq_th(v2[0], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[0], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5f)) ASSERT(v2[2] > 0.0f && v2[2] < 0.1f) GLM(vec3_smoothstep)(e2_0, e2_1, v1, v2); ASSERT(v2[0] > 0.0f && v2[0] < 0.25f) ASSERT(v2[1] > 0.0f && v2[1] < 0.15f) - ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5f)) GLM(vec3_smoothstep)(e3_0, e3_1, v1, v2); - ASSERT(test_eq_th(v2[0], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[2], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[0], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[2], 0.0f, 1e-5f)) TEST_SUCCESS } @@ -1368,7 +1368,7 @@ TEST_IMPL(GLM_PREFIX, vec3_smoothinterp) { vec3 e3_1 = {100.0f, 200.0f, 10.0f}; vec3 v2; - GLM(vec3_smoothinterp)(e1_0, e1_1, 0.5, v2); + GLM(vec3_smoothinterp)(e1_0, e1_1, 0.5f, v2); ASSERT(v2[0] >= e1_0[0] && v2[0] <= e1_1[0]) ASSERT(v2[1] >= e1_0[1] && v2[1] <= e1_1[1]) ASSERT(v2[2] >= e1_0[2] && v2[2] <= e1_1[2]) @@ -1395,17 +1395,17 @@ TEST_IMPL(GLM_PREFIX, vec3_smoothinterpc) { vec3 e3_1 = {100.0f, 200.0f, 10.0f}; vec3 v2; - GLM(vec3_smoothinterpc)(e1_0, e1_1, -0.5, v2); + GLM(vec3_smoothinterpc)(e1_0, e1_1, -0.5f, v2); ASSERT(v2[0] >= e1_0[0] && v2[0] <= e1_1[0]) ASSERT(v2[1] >= e1_0[1] && v2[1] <= e1_1[1]) ASSERT(v2[2] >= e1_0[2] && v2[2] <= e1_1[2]) - GLM(vec3_smoothinterpc)(e2_0, e2_1, 0.5, v2); + GLM(vec3_smoothinterpc)(e2_0, e2_1, 0.5f, v2); ASSERT(v2[0] >= e2_0[0] && v2[0] <= e2_1[0]) ASSERT(v2[1] >= e2_0[1] && v2[1] <= e2_1[1]) ASSERT(v2[2] >= e2_0[2] && v2[2] <= e2_1[2]) - GLM(vec3_smoothinterpc)(e3_0, e3_1, 2.0, v2); + GLM(vec3_smoothinterpc)(e3_0, e3_1, 2.0f, v2); ASSERT(v2[0] >= e3_0[0] && v2[0] <= e3_1[0]) ASSERT(v2[1] >= e3_0[1] && v2[1] <= e3_1[1]) ASSERT(v2[2] >= e3_0[2] && v2[2] <= e3_1[2]) diff --git a/test/src/test_vec4.h b/test/src/test_vec4.h index 6fa9763..5e20c63 100644 --- a/test/src/test_vec4.h +++ b/test/src/test_vec4.h @@ -942,18 +942,18 @@ TEST_IMPL(GLM_PREFIX, vec4_smoothstep_uni) { vec4 v2; GLM(vec4_smoothstep_uni)(-200.0f, -100.0f, v1, v2); - ASSERT(test_eq_th(v2[0], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[3], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[0], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[3], 1.0f, 1e-5f)) GLM(vec4_smoothstep_uni)(-250.0f, -200.0f, v1, v2); - ASSERT(test_eq_th(v2[0], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[1], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[3], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[0], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[1], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[3], 1.0f, 1e-5f)) - GLM(vec4_smoothstep_uni)(-200.0f, 200, v1, v2); + GLM(vec4_smoothstep_uni)(-200.0f, 200.0f, v1, v2); ASSERT(v2[0] > 0.0f && v2[0] < 0.25f) ASSERT(test_eq(v2[1], 0.0f)) ASSERT(v2[2] > 0.0f && v2[2] < 0.5f) @@ -973,22 +973,22 @@ TEST_IMPL(GLM_PREFIX, vec4_smoothstep) { vec4 v2; GLM(vec4_smoothstep)(e1_0, e1_1, v1, v2); - ASSERT(test_eq_th(v2[0], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[0], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5f)) ASSERT(v2[2] > 0.0f && v2[2] < 0.1f) ASSERT(v2[3] > 0.0f && v2[3] < 0.1f) GLM(vec4_smoothstep)(e2_0, e2_1, v1, v2); ASSERT(v2[0] > 0.0f && v2[0] < 0.25f) ASSERT(v2[1] > 0.0f && v2[1] < 0.15f) - ASSERT(test_eq_th(v2[2], 1.0f, 1e-5)) - ASSERT(test_eq_th(v2[3], 1.0f, 1e-5)) + ASSERT(test_eq_th(v2[2], 1.0f, 1e-5f)) + ASSERT(test_eq_th(v2[3], 1.0f, 1e-5f)) GLM(vec4_smoothstep)(e3_0, e3_1, v1, v2); - ASSERT(test_eq_th(v2[0], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[1], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[2], 0.0f, 1e-5)) - ASSERT(test_eq_th(v2[3], 0.0f, 1e-5)) + ASSERT(test_eq_th(v2[0], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[1], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[2], 0.0f, 1e-5f)) + ASSERT(test_eq_th(v2[3], 0.0f, 1e-5f)) TEST_SUCCESS } @@ -1002,19 +1002,19 @@ TEST_IMPL(GLM_PREFIX, vec4_smoothinterp) { vec4 e3_1 = {100.0f, 200.0f, 10.0f, 10.0f}; vec4 v2; - GLM(vec4_smoothinterp)(e1_0, e1_1, 0.5, v2); + GLM(vec4_smoothinterp)(e1_0, e1_1, 0.5f, v2); ASSERT(v2[0] >= e1_0[0] && v2[0] <= e1_1[0]) ASSERT(v2[1] >= e1_0[1] && v2[1] <= e1_1[1]) ASSERT(v2[2] >= e1_0[2] && v2[2] <= e1_1[2]) ASSERT(v2[3] >= e1_0[3] && v2[3] <= e1_1[3]) - GLM(vec4_smoothinterp)(e2_0, e2_1, 0.5, v2); + GLM(vec4_smoothinterp)(e2_0, e2_1, 0.5f, v2); ASSERT(v2[0] >= e2_0[0] && v2[0] <= e2_1[0]) ASSERT(v2[1] >= e2_0[1] && v2[1] <= e2_1[1]) ASSERT(v2[2] >= e2_0[2] && v2[2] <= e2_1[2]) ASSERT(v2[3] >= e2_0[3] && v2[3] <= e2_1[3]) - GLM(vec4_smoothinterp)(e3_0, e3_1, 1.0, v2); + GLM(vec4_smoothinterp)(e3_0, e3_1, 1.0f, v2); ASSERT(v2[0] >= e3_0[0] && v2[0] <= e3_1[0]) ASSERT(v2[1] >= e3_0[1] && v2[1] <= e3_1[1]) ASSERT(v2[2] >= e3_0[2] && v2[2] <= e3_1[2]) @@ -1032,19 +1032,19 @@ TEST_IMPL(GLM_PREFIX, vec4_smoothinterpc) { vec4 e3_1 = {100.0f, 200.0f, 10.0f, 10.0f}; vec4 v2; - GLM(vec4_smoothinterpc)(e1_0, e1_1, -0.5, v2); + GLM(vec4_smoothinterpc)(e1_0, e1_1, -0.5f, v2); ASSERT(v2[0] >= e1_0[0] && v2[0] <= e1_1[0]) ASSERT(v2[1] >= e1_0[1] && v2[1] <= e1_1[1]) ASSERT(v2[2] >= e1_0[2] && v2[2] <= e1_1[2]) ASSERT(v2[3] >= e1_0[3] && v2[3] <= e1_1[3]) - GLM(vec4_smoothinterpc)(e2_0, e2_1, 0.5, v2); + GLM(vec4_smoothinterpc)(e2_0, e2_1, 0.5f, v2); ASSERT(v2[0] >= e2_0[0] && v2[0] <= e2_1[0]) ASSERT(v2[1] >= e2_0[1] && v2[1] <= e2_1[1]) ASSERT(v2[2] >= e2_0[2] && v2[2] <= e2_1[2]) ASSERT(v2[3] >= e2_0[3] && v2[3] <= e2_1[3]) - GLM(vec4_smoothinterpc)(e3_0, e3_1, 2.0, v2); + GLM(vec4_smoothinterpc)(e3_0, e3_1, 2.0f, v2); ASSERT(v2[0] >= e3_0[0] && v2[0] <= e3_1[0]) ASSERT(v2[1] >= e3_0[1] && v2[1] <= e3_1[1]) ASSERT(v2[2] >= e3_0[2] && v2[2] <= e3_1[2]) diff --git a/win/cglm-test.vcxproj b/win/cglm-test.vcxproj index c833e6c..d6927da 100644 --- a/win/cglm-test.vcxproj +++ b/win/cglm-test.vcxproj @@ -36,6 +36,12 @@ + + + + + + diff --git a/win/cglm-test.vcxproj.filters b/win/cglm-test.vcxproj.filters index c68818e..f5ec13b 100644 --- a/win/cglm-test.vcxproj.filters +++ b/win/cglm-test.vcxproj.filters @@ -61,5 +61,23 @@ include + + src + + + src + + + src + + + src + + + src + + + src + \ No newline at end of file From 52df54e30627732cd39c9da9df823eb90dc8445f Mon Sep 17 00:00:00 2001 From: onagurna <56755546+onagurna@users.noreply.github.com> Date: Mon, 21 Oct 2019 23:46:23 +0300 Subject: [PATCH 057/103] fix typo in README (#106) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index c274b98..495ec6e 100644 --- a/README.md +++ b/README.md @@ -33,7 +33,7 @@ https://github.com/g-truc/glm #### Note for new comers (Important): - `vec4` and `mat4` variables must be aligned. (There will be unaligned versions later) - **in** and **[in, out]** parameters must be initialized (please). But **[out]** parameters not, initializing out param is also redundant -- All functions are inline if you don't want to use pre-compiled versions with glmc_ prefix, you can ignore build process. Just incliude headers. +- All functions are inline if you don't want to use pre-compiled versions with glmc_ prefix, you can ignore build process. Just include headers. - if your debugger takes you to cglm headers then make sure you are not trying to copy vec4 to vec3 or alig issues... - Welcome! From 2336256808167fe79ee584ae719a7e6326ecfe4a Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 7 Nov 2019 22:32:15 +0300 Subject: [PATCH 058/103] Helpers for apple's simd library (#107) * helper to convert cglm matrix to Apple's simd type --- include/cglm/applesimd.h | 79 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 include/cglm/applesimd.h diff --git a/include/cglm/applesimd.h b/include/cglm/applesimd.h new file mode 100644 index 0000000..2827f0d --- /dev/null +++ b/include/cglm/applesimd.h @@ -0,0 +1,79 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#ifndef cglm_applesimd_h +#define cglm_applesimd_h +#if defined(__APPLE__) \ + && defined(SIMD_COMPILER_HAS_REQUIRED_FEATURES) \ + && defined(SIMD_BASE) \ + && defined(SIMD_TYPES) \ + && defined(SIMD_VECTOR_TYPES) + +#include "common.h" + +CGLM_INLINE +simd_float4x4 +glm_mat4_applesimd(mat4 m) { + simd_float4x4 t; + + t.columns[0][0] = m[0][0]; + t.columns[0][1] = m[0][1]; + t.columns[0][2] = m[0][2]; + t.columns[0][3] = m[0][3]; + + t.columns[1][0] = m[1][0]; + t.columns[1][1] = m[1][1]; + t.columns[1][2] = m[1][2]; + t.columns[1][3] = m[1][3]; + + t.columns[2][0] = m[2][0]; + t.columns[2][1] = m[2][1]; + t.columns[2][2] = m[2][2]; + t.columns[2][3] = m[2][3]; + + t.columns[3][0] = m[3][0]; + t.columns[3][1] = m[3][1]; + t.columns[3][2] = m[3][2]; + t.columns[3][3] = m[3][3]; + + return t; +} + +CGLM_INLINE +simd_float3x3 +glm_mat3_applesimd(mat3 m) { + simd_float3x3 t; + + t.columns[0][0] = m[0][0]; + t.columns[0][1] = m[0][1]; + t.columns[0][2] = m[0][2]; + + t.columns[1][0] = m[1][0]; + t.columns[1][1] = m[1][1]; + t.columns[1][2] = m[1][2]; + + t.columns[2][0] = m[2][0]; + t.columns[2][1] = m[2][1]; + t.columns[2][2] = m[2][2]; + + return t; +} + +CGLM_INLINE +simd_float4 +glm_vec4_applesimd(vec4 v) { + return (simd_float4){v[0], v[1], v[2], v[3]}; +} + +CGLM_INLINE +simd_float3 +glm_vec3_applesimd(vec3 v) { + return (simd_float3){v[0], v[1], v[2]}; +} + +#endif +#endif /* cglm_applesimd_h */ From b893c7908629e38f2b62127a5d940ced487bfbce Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 7 Nov 2019 22:41:41 +0300 Subject: [PATCH 059/103] Update Makefile.am --- Makefile.am | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/Makefile.am b/Makefile.am index d0a8c3a..3468df0 100644 --- a/Makefile.am +++ b/Makefile.am @@ -30,14 +30,16 @@ test_tests_CFLAGS = $(checkCFLAGS) cglmdir=$(includedir)/cglm cglm_HEADERS = include/cglm/version.h \ + include/cglm/common.h \ + include/cglm/types.h \ + include/cglm/types-struct.h \ include/cglm/cglm.h \ include/cglm/call.h \ + include/cglm/struct.h \ include/cglm/cam.h \ include/cglm/io.h \ include/cglm/mat4.h \ include/cglm/mat3.h \ - include/cglm/types.h \ - include/cglm/common.h \ include/cglm/affine.h \ include/cglm/vec3.h \ include/cglm/vec3-ext.h \ @@ -56,9 +58,9 @@ cglm_HEADERS = include/cglm/version.h \ include/cglm/ease.h \ include/cglm/curve.h \ include/cglm/bezier.h \ - include/cglm/types-struct.h \ - include/cglm/struct.h - + include/cglm/bezier.h \ + include/cglm/applesimd.h + cglm_calldir=$(includedir)/cglm/call cglm_call_HEADERS = include/cglm/call/mat4.h \ include/cglm/call/mat3.h \ From c253769fcdb8b99cf6125d03c9e3cf4365856208 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 7 Nov 2019 22:43:47 +0300 Subject: [PATCH 060/103] Update applesimd.h --- include/cglm/applesimd.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/include/cglm/applesimd.h b/include/cglm/applesimd.h index 2827f0d..3608bb3 100644 --- a/include/cglm/applesimd.h +++ b/include/cglm/applesimd.h @@ -15,6 +15,10 @@ #include "common.h" +/*! +* @brief converts mat4 to Apple's simd type simd_float4x4 +* @return simd_float4x4 +*/ CGLM_INLINE simd_float4x4 glm_mat4_applesimd(mat4 m) { @@ -43,6 +47,10 @@ glm_mat4_applesimd(mat4 m) { return t; } +/*! +* @brief converts mat3 to Apple's simd type simd_float3x3 +* @return simd_float3x3 +*/ CGLM_INLINE simd_float3x3 glm_mat3_applesimd(mat3 m) { @@ -63,12 +71,20 @@ glm_mat3_applesimd(mat3 m) { return t; } +/*! +* @brief converts vec4 to Apple's simd type simd_float4 +* @return simd_float4 +*/ CGLM_INLINE simd_float4 glm_vec4_applesimd(vec4 v) { return (simd_float4){v[0], v[1], v[2], v[3]}; } +/*! +* @brief converts vec3 to Apple's simd type simd_float3 +* @return v +*/ CGLM_INLINE simd_float3 glm_vec3_applesimd(vec3 v) { From 464b2178ce639e40adfeeb8018a5726cdd7c3e83 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 8 Nov 2019 17:14:24 +0300 Subject: [PATCH 061/103] Update README.md --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 495ec6e..c8a5f53 100644 --- a/README.md +++ b/README.md @@ -88,6 +88,7 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi - easing functions - curves - curve interpolation helpers (S*M*C, deCasteljau...) +- helpers to convert cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides - and others...
From 9987e1374b93dcad4e8e61b83a5286accb12d1dc Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 17 Nov 2019 10:22:01 +0300 Subject: [PATCH 062/103] build: remove duplicate entry in makefile close #108 --- Makefile.am | 1 - 1 file changed, 1 deletion(-) diff --git a/Makefile.am b/Makefile.am index 3468df0..fc76e3f 100644 --- a/Makefile.am +++ b/Makefile.am @@ -58,7 +58,6 @@ cglm_HEADERS = include/cglm/version.h \ include/cglm/ease.h \ include/cglm/curve.h \ include/cglm/bezier.h \ - include/cglm/bezier.h \ include/cglm/applesimd.h cglm_calldir=$(includedir)/cglm/call From f3ea5b4f3e3bb343f665523e410ab1e4ed457ff0 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Mon, 18 Nov 2019 05:03:19 -0500 Subject: [PATCH 063/103] Change empty prototypes to (void) Because () means an arbitrary number of arguments in C, which is not intended here. --- include/cglm/struct/mat3.h | 8 ++++---- include/cglm/struct/mat4.h | 8 ++++---- include/cglm/struct/quat.h | 4 ++-- include/cglm/struct/vec3.h | 8 ++++---- include/cglm/struct/vec4.h | 4 ++-- 5 files changed, 16 insertions(+), 16 deletions(-) diff --git a/include/cglm/struct/mat3.h b/include/cglm/struct/mat3.h index 5c474e6..da53989 100644 --- a/include/cglm/struct/mat3.h +++ b/include/cglm/struct/mat3.h @@ -14,9 +14,9 @@ Functions: CGLM_INLINE mat3s glms_mat3_copy(mat3s mat); - CGLM_INLINE mat3s glms_mat3_identity(); + CGLM_INLINE mat3s glms_mat3_identity(void); CGLM_INLINE void glms_mat3_identity_array(mat3s * __restrict mat, size_t count); - CGLM_INLINE mat3s glms_mat3_zero(); + CGLM_INLINE mat3s glms_mat3_zero(void); CGLM_INLINE mat3s glms_mat3_mul(mat3s m1, mat3s m2); CGLM_INLINE ma3s glms_mat3_transpose(mat3s m); CGLM_INLINE vec3s glms_mat3_mulv(mat3s m, vec3s v); @@ -79,7 +79,7 @@ glms_mat3_copy(mat3s mat) { */ CGLM_INLINE mat3s -glms_mat3_identity() { +glms_mat3_identity(void) { mat3s r; glm_mat3_identity(r.raw); return r; @@ -111,7 +111,7 @@ glms_mat3_identity_array(mat3s * __restrict mat, size_t count) { */ CGLM_INLINE mat3s -glms_mat3_zero() { +glms_mat3_zero(void) { mat3s r; glm_mat3_zero(r.raw); return r; diff --git a/include/cglm/struct/mat4.h b/include/cglm/struct/mat4.h index ef72e31..14fa614 100644 --- a/include/cglm/struct/mat4.h +++ b/include/cglm/struct/mat4.h @@ -20,9 +20,9 @@ Functions: CGLM_INLINE mat4s glms_mat4_ucopy(mat4s mat); CGLM_INLINE mat4s glms_mat4_copy(mat4s mat); - CGLM_INLINE mat4s glms_mat4_identity(); + CGLM_INLINE mat4s glms_mat4_identity(void); CGLM_INLINE void glms_mat4_identity_array(mat4s * __restrict mat, size_t count); - CGLM_INLINE mat4s glms_mat4_zero(); + CGLM_INLINE mat4s glms_mat4_zero(void); CGLM_INLINE mat3s glms_mat4_pick3(mat4s mat); CGLM_INLINE mat3s glms_mat4_pick3t(mat4s mat); CGLM_INLINE mat4s glms_mat4_ins3(mat3s mat); @@ -114,7 +114,7 @@ glms_mat4_copy(mat4s mat) { */ CGLM_INLINE mat4s -glms_mat4_identity() { +glms_mat4_identity(void) { mat4s r; glm_mat4_identity(r.raw); return r; @@ -146,7 +146,7 @@ glms_mat4_identity_array(mat4s * __restrict mat, size_t count) { */ CGLM_INLINE mat4s -glms_mat4_zero() { +glms_mat4_zero(void) { mat4s r; glm_mat4_zero(r.raw); return r; diff --git a/include/cglm/struct/quat.h b/include/cglm/struct/quat.h index 3b0c8ee..9807632 100644 --- a/include/cglm/struct/quat.h +++ b/include/cglm/struct/quat.h @@ -11,7 +11,7 @@ GLMS_QUAT_IDENTITY Functions: - CGLM_INLINE versors glms_quat_identity() + CGLM_INLINE versors glms_quat_identity(void) CGLM_INLINE void glms_quat_identity_array(versor *q, size_t count) CGLM_INLINE versors glms_quat_init(float x, float y, float z, float w) CGLM_INLINE versors glms_quatv(float angle, vec3s axis) @@ -72,7 +72,7 @@ */ CGLM_INLINE versors -glms_quat_identity() { +glms_quat_identity(void) { versors dest; glm_quat_identity(dest.raw); return dest; diff --git a/include/cglm/struct/vec3.h b/include/cglm/struct/vec3.h index 0cd2f5c..3fbec1b 100644 --- a/include/cglm/struct/vec3.h +++ b/include/cglm/struct/vec3.h @@ -19,8 +19,8 @@ CGLM_INLINE vec3s glms_vec3(vec4s v4); CGLM_INLINE void glms_vec3_pack(vec3s dst[], vec3 src[], size_t len); CGLM_INLINE void glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len); - CGLM_INLINE vec3s glms_vec3_zero(); - CGLM_INLINE vec3s glms_vec3_one(); + CGLM_INLINE vec3s glms_vec3_zero(void); + CGLM_INLINE vec3s glms_vec3_one(void); CGLM_INLINE float glms_vec3_dot(vec3s a, vec3s b); CGLM_INLINE float glms_vec3_norm2(vec3s v); CGLM_INLINE float glms_vec3_norm(vec3s v); @@ -151,7 +151,7 @@ glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) { */ CGLM_INLINE vec3s -glms_vec3_zero() { +glms_vec3_zero(void) { vec3s r; glm_vec3_zero(r.raw); return r; @@ -164,7 +164,7 @@ glms_vec3_zero() { */ CGLM_INLINE vec3s -glms_vec3_one() { +glms_vec3_one(void) { vec3s r; glm_vec3_one(r.raw); return r; diff --git a/include/cglm/struct/vec4.h b/include/cglm/struct/vec4.h index 7137cfa..7bccf67 100644 --- a/include/cglm/struct/vec4.h +++ b/include/cglm/struct/vec4.h @@ -180,7 +180,7 @@ glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) { */ CGLM_INLINE vec4s -glms_vec4_zero() { +glms_vec4_zero(void) { vec4s r; glm_vec4_zero(r.raw); return r; @@ -193,7 +193,7 @@ glms_vec4_zero() { */ CGLM_INLINE vec4s -glms_vec4_one() { +glms_vec4_one(void) { vec4s r; glm_vec4_one(r.raw); return r; From c83f25343fbd54a38f1a5c34e537ea6122fef825 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Mon, 18 Nov 2019 05:06:46 -0500 Subject: [PATCH 064/103] Error out on invalid empty prototypes This way, a function prototype like `glms_mat3_identity()` will not compile, instead you have to change it to the proper `glms_mat3_identity(void)`. --- Makefile.am | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Makefile.am b/Makefile.am index fc76e3f..f6b3073 100644 --- a/Makefile.am +++ b/Makefile.am @@ -12,7 +12,8 @@ AM_CFLAGS = -Wall \ -O3 \ -Wstrict-aliasing=2 \ -fstrict-aliasing \ - -pedantic + -pedantic \ + -Werror=strict-prototypes lib_LTLIBRARIES = libcglm.la libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0 From 4b9b7aeb20e89c5ff9e34a35fa4c6dcbe31783a9 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sun, 11 Aug 2019 12:01:58 +0200 Subject: [PATCH 065/103] Add a vec2s struct type for consistency There's a vec2 type, so there should probably be a struct version of it too. Even if no functions use it right now, if a library user (like me) needs a 2-element vector, they don't need to roll their own. --- include/cglm/types-struct.h | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/include/cglm/types-struct.h b/include/cglm/types-struct.h index 4901f01..f064a43 100644 --- a/include/cglm/types-struct.h +++ b/include/cglm/types-struct.h @@ -10,6 +10,16 @@ #include "types.h" +typedef union vec2s { +#ifndef CGLM_NO_ANONYMOUS_STRUCT + struct { + float x; + float y; + }; +#endif + vec2 raw; +} vec2s; + typedef union vec3s { #ifndef CGLM_NO_ANONYMOUS_STRUCT struct { From f9abf2a7dfd543f433eed20636cb76d6d7327d7e Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sat, 23 Nov 2019 18:03:34 -0500 Subject: [PATCH 066/103] Don't add default autoconf flags to build By default, it adds something like `-O2 -g` to the cflags. That conflicts with the flags in Makefile.am, which specifies -O3. This commit removes the default flags so we only get what we actually specify. --- configure.ac | 3 +++ 1 file changed, 3 insertions(+) diff --git a/configure.ac b/configure.ac index 45dc219..473a396 100644 --- a/configure.ac +++ b/configure.ac @@ -10,6 +10,9 @@ AC_PREREQ([2.69]) AC_INIT([cglm], [0.6.1], [info@recp.me]) AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests]) +# Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am. +: ${CFLAGS=""} + AC_CONFIG_MACRO_DIR([m4]) AC_CONFIG_SRCDIR([src/]) AC_CONFIG_HEADERS([config.h]) From 267348af03852cea2f48407a833c061462820dc7 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sat, 23 Nov 2019 18:05:44 -0500 Subject: [PATCH 067/103] Build tests with the same flags as the library In particular, with the same warning flags. That means it now warns about a few things during compilation that the following commits are gonna fix. --- Makefile.am | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Makefile.am b/Makefile.am index f6b3073..5ecb08a 100644 --- a/Makefile.am +++ b/Makefile.am @@ -21,7 +21,8 @@ libcglm_la_LDFLAGS = -no-undefined -version-info 0:1:0 checkLDFLAGS = -L./.libs \ -lm \ -lcglm -checkCFLAGS = -I./include +checkCFLAGS = $(AM_CFLAGS) \ + -I./include check_PROGRAMS = test/tests TESTS = $(check_PROGRAMS) From 390a5035a864a5c4522b05c833937f02c36b7b2c Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sat, 23 Nov 2019 18:09:08 -0500 Subject: [PATCH 068/103] Use gnu11 instead of gnu99 to get rid of warnings CGLM uses anonymous structs, which is a C11 feature. When trying to build the tests in C99 mode, you get warnings to that effect. Switching to C11 fixes this. --- Makefile.am | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile.am b/Makefile.am index 5ecb08a..d775a52 100644 --- a/Makefile.am +++ b/Makefile.am @@ -8,7 +8,7 @@ ACLOCAL_AMFLAGS = -I m4 AM_CFLAGS = -Wall \ - -std=gnu99 \ + -std=gnu11 \ -O3 \ -Wstrict-aliasing=2 \ -fstrict-aliasing \ From 11dae5126bb5c4523ca9b04f80564b80d16948d3 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sat, 23 Nov 2019 21:14:33 -0500 Subject: [PATCH 069/103] Add braces around matrix struct intializers They're missing and trigger warnings in the tests. --- include/cglm/struct/mat3.h | 12 ++++++------ include/cglm/struct/mat4.h | 16 ++++++++-------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/include/cglm/struct/mat3.h b/include/cglm/struct/mat3.h index da53989..c5c6a2a 100644 --- a/include/cglm/struct/mat3.h +++ b/include/cglm/struct/mat3.h @@ -38,12 +38,12 @@ #include "../mat3.h" #include "vec3.h" -#define GLMS_MAT3_IDENTITY_INIT {1.0f, 0.0f, 0.0f, \ - 0.0f, 1.0f, 0.0f, \ - 0.0f, 0.0f, 1.0f} -#define GLMS_MAT3_ZERO_INIT {0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f} +#define GLMS_MAT3_IDENTITY_INIT {{1.0f, 0.0f, 0.0f, \ + 0.0f, 1.0f, 0.0f, \ + 0.0f, 0.0f, 1.0f}} +#define GLMS_MAT3_ZERO_INIT {{0.0f, 0.0f, 0.0f, \ + 0.0f, 0.0f, 0.0f, \ + 0.0f, 0.0f, 0.0f}} /* for C only */ #define GLMS_MAT3_IDENTITY ((mat3s)GLMS_MAT3_IDENTITY_INIT) diff --git a/include/cglm/struct/mat4.h b/include/cglm/struct/mat4.h index 14fa614..d27d4ec 100644 --- a/include/cglm/struct/mat4.h +++ b/include/cglm/struct/mat4.h @@ -53,15 +53,15 @@ #include "vec4.h" #include "vec3.h" -#define GLMS_MAT4_IDENTITY_INIT {1.0f, 0.0f, 0.0f, 0.0f, \ - 0.0f, 1.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 1.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, 1.0f} +#define GLMS_MAT4_IDENTITY_INIT {{1.0f, 0.0f, 0.0f, 0.0f, \ + 0.0f, 1.0f, 0.0f, 0.0f, \ + 0.0f, 0.0f, 1.0f, 0.0f, \ + 0.0f, 0.0f, 0.0f, 1.0f}} -#define GLMS_MAT4_ZERO_INIT {0.0f, 0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, 0.0f} +#define GLMS_MAT4_ZERO_INIT {{0.0f, 0.0f, 0.0f, 0.0f, \ + 0.0f, 0.0f, 0.0f, 0.0f, \ + 0.0f, 0.0f, 0.0f, 0.0f, \ + 0.0f, 0.0f, 0.0f, 0.0f}} /* for C only */ #define GLMS_MAT4_IDENTITY ((mat4s)GLMS_MAT4_IDENTITY_INIT) From c8211b3a62840dc2bab4a10b3a6899e4e11cdb1e Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sun, 24 Nov 2019 13:33:38 -0500 Subject: [PATCH 070/103] Re-order struct type contents array-first So that initializers will prefer the array entry, rather than trying to initialize the anonymous struct. --- include/cglm/types-struct.h | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/include/cglm/types-struct.h b/include/cglm/types-struct.h index f064a43..9304847 100644 --- a/include/cglm/types-struct.h +++ b/include/cglm/types-struct.h @@ -11,16 +11,17 @@ #include "types.h" typedef union vec2s { + vec2 raw; #ifndef CGLM_NO_ANONYMOUS_STRUCT struct { float x; float y; }; #endif - vec2 raw; } vec2s; typedef union vec3s { + vec3 raw; #ifndef CGLM_NO_ANONYMOUS_STRUCT struct { float x; @@ -28,10 +29,10 @@ typedef union vec3s { float z; }; #endif - vec3 raw; } vec3s; typedef union ivec3s { + ivec3 raw; #ifndef CGLM_NO_ANONYMOUS_STRUCT struct { int x; @@ -39,10 +40,10 @@ typedef union ivec3s { int z; }; #endif - ivec3 raw; } ivec3s; typedef union CGLM_ALIGN_IF(16) vec4s { + vec4 raw; #ifndef CGLM_NO_ANONYMOUS_STRUCT struct { float x; @@ -51,10 +52,10 @@ typedef union CGLM_ALIGN_IF(16) vec4s { float w; }; #endif - vec4 raw; } vec4s; typedef union CGLM_ALIGN_IF(16) versors { + vec4 raw; #ifndef CGLM_NO_ANONYMOUS_STRUCT struct { float x; @@ -68,10 +69,11 @@ typedef union CGLM_ALIGN_IF(16) versors { float real; }; #endif - vec4 raw; } versors; typedef union mat3s { + mat3 raw; + vec3s col[3]; #ifndef CGLM_NO_ANONYMOUS_STRUCT struct { float m00, m01, m02; @@ -79,11 +81,11 @@ typedef union mat3s { float m20, m21, m22; }; #endif - vec3s col[3]; - mat3 raw; } mat3s; typedef union CGLM_ALIGN_MAT mat4s { + mat4 raw; + vec4s col[4]; #ifndef CGLM_NO_ANONYMOUS_STRUCT struct { float m00, m01, m02, m03; @@ -92,8 +94,6 @@ typedef union CGLM_ALIGN_MAT mat4s { float m30, m31, m32, m33; }; #endif - vec4s col[4]; - mat4 raw; } mat4s; #endif /* cglm_types_struct_h */ From 8ad273475f8c2a0e6e68bcef3bd7cd8ac95a7339 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sun, 24 Nov 2019 13:35:42 -0500 Subject: [PATCH 071/103] Make GLMS_ initializers use the GLM_ versions So that we don't write them twice. More consistent this way. --- include/cglm/struct/mat3.h | 8 ++------ include/cglm/struct/mat4.h | 11 ++--------- include/cglm/struct/quat.h | 2 +- include/cglm/struct/vec3.h | 10 +++++----- include/cglm/struct/vec4.h | 18 +++++++++--------- 5 files changed, 19 insertions(+), 30 deletions(-) diff --git a/include/cglm/struct/mat3.h b/include/cglm/struct/mat3.h index c5c6a2a..53a7273 100644 --- a/include/cglm/struct/mat3.h +++ b/include/cglm/struct/mat3.h @@ -38,12 +38,8 @@ #include "../mat3.h" #include "vec3.h" -#define GLMS_MAT3_IDENTITY_INIT {{1.0f, 0.0f, 0.0f, \ - 0.0f, 1.0f, 0.0f, \ - 0.0f, 0.0f, 1.0f}} -#define GLMS_MAT3_ZERO_INIT {{0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f}} +#define GLMS_MAT3_IDENTITY_INIT {GLM_MAT3_IDENTITY_INIT} +#define GLMS_MAT3_ZERO_INIT {GLM_MAT3_ZERO_INIT} /* for C only */ #define GLMS_MAT3_IDENTITY ((mat3s)GLMS_MAT3_IDENTITY_INIT) diff --git a/include/cglm/struct/mat4.h b/include/cglm/struct/mat4.h index d27d4ec..28f80a3 100644 --- a/include/cglm/struct/mat4.h +++ b/include/cglm/struct/mat4.h @@ -53,15 +53,8 @@ #include "vec4.h" #include "vec3.h" -#define GLMS_MAT4_IDENTITY_INIT {{1.0f, 0.0f, 0.0f, 0.0f, \ - 0.0f, 1.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 1.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, 1.0f}} - -#define GLMS_MAT4_ZERO_INIT {{0.0f, 0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, 0.0f, \ - 0.0f, 0.0f, 0.0f, 0.0f}} +#define GLMS_MAT4_IDENTITY_INIT {GLM_MAT4_IDENTITY_INIT} +#define GLMS_MAT4_ZERO_INIT {GLM_MAT4_ZERO_INIT} /* for C only */ #define GLMS_MAT4_IDENTITY ((mat4s)GLMS_MAT4_IDENTITY_INIT) diff --git a/include/cglm/struct/quat.h b/include/cglm/struct/quat.h index 9807632..2938478 100644 --- a/include/cglm/struct/quat.h +++ b/include/cglm/struct/quat.h @@ -62,7 +62,7 @@ * ---------------------------------------------------------------------------- */ -#define GLMS_QUAT_IDENTITY_INIT GLM_QUAT_IDENTITY_INIT +#define GLMS_QUAT_IDENTITY_INIT {GLM_QUAT_IDENTITY_INIT} #define GLMS_QUAT_IDENTITY ((versors)GLMS_QUAT_IDENTITY_INIT) /*! diff --git a/include/cglm/struct/vec3.h b/include/cglm/struct/vec3.h index 3fbec1b..7fa5b06 100644 --- a/include/cglm/struct/vec3.h +++ b/include/cglm/struct/vec3.h @@ -86,15 +86,15 @@ #include "../vec3.h" #include "vec3-ext.h" -#define GLMS_VEC3_ONE_INIT {1.0f, 1.0f, 1.0f} -#define GLMS_VEC3_ZERO_INIT {0.0f, 0.0f, 0.0f} +#define GLMS_VEC3_ONE_INIT {GLM_VEC3_ONE_INIT} +#define GLMS_VEC3_ZERO_INIT {GLM_VEC3_ZERO_INIT} #define GLMS_VEC3_ONE ((vec3s)GLMS_VEC3_ONE_INIT) #define GLMS_VEC3_ZERO ((vec3s)GLMS_VEC3_ZERO_INIT) -#define GLMS_YUP ((vec3s){0.0f, 1.0f, 0.0f}) -#define GLMS_ZUP ((vec3s){0.0f, 0.0f, 1.0f}) -#define GLMS_XUP ((vec3s){1.0f, 0.0f, 0.0f}) +#define GLMS_YUP ((vec3s){{0.0f, 1.0f, 0.0f}}) +#define GLMS_ZUP ((vec3s){{0.0f, 0.0f, 1.0f}}) +#define GLMS_XUP ((vec3s){{1.0f, 0.0f, 0.0f}}) /*! * @brief init vec3 using vec4 diff --git a/include/cglm/struct/vec4.h b/include/cglm/struct/vec4.h index 7bccf67..4469cb2 100644 --- a/include/cglm/struct/vec4.h +++ b/include/cglm/struct/vec4.h @@ -7,12 +7,12 @@ /* Macros: - GLM_VEC4_ONE_INIT - GLM_VEC4_BLACK_INIT - GLM_VEC4_ZERO_INIT - GLM_VEC4_ONE - GLM_VEC4_BLACK - GLM_VEC4_ZERO + GLMS_VEC4_ONE_INIT + GLMS_VEC4_BLACK_INIT + GLMS_VEC4_ZERO_INIT + GLMS_VEC4_ONE + GLMS_VEC4_BLACK + GLMS_VEC4_ZERO Functions: CGLM_INLINE vec4s glms_vec4(vec3s v3, float last); @@ -72,9 +72,9 @@ #include "../vec4.h" #include "vec4-ext.h" -#define GLMS_VEC4_ONE_INIT {1.0f, 1.0f, 1.0f, 1.0f} -#define GLMS_VEC4_BLACK_INIT {0.0f, 0.0f, 0.0f, 1.0f} -#define GLMS_VEC4_ZERO_INIT {0.0f, 0.0f, 0.0f, 0.0f} +#define GLMS_VEC4_ONE_INIT {GLM_VEC4_ONE_INIT} +#define GLMS_VEC4_BLACK_INIT {GLM_VEC4_BLACK_INIT} +#define GLMS_VEC4_ZERO_INIT {GLM_VEC4_ZERO_INIT} #define GLMS_VEC4_ONE ((vec4s)GLM_VEC4_ONE_INIT) #define GLMS_VEC4_BLACK ((vec4s)GLM_VEC4_BLACK_INIT) From b9aa14d25e11299550be2b312b1c6f6bbd8de368 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sun, 24 Nov 2019 13:37:52 -0500 Subject: [PATCH 072/103] Add a test for struct type initializers To make sure that they all work properly and none of them trigger warnings. --- Makefile.am | 3 +- test/src/test_struct.c | 71 ++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 25 +++++++++++++++ 3 files changed, 98 insertions(+), 1 deletion(-) create mode 100644 test/src/test_struct.c diff --git a/Makefile.am b/Makefile.am index d775a52..4a022fb 100644 --- a/Makefile.am +++ b/Makefile.am @@ -151,7 +151,8 @@ test_tests_SOURCES=\ test/src/test_vec3.c \ test/src/test_mat3.c \ test/src/test_affine.c \ - test/src/test_bezier.c + test/src/test_bezier.c \ + test/src/test_struct.c pkgconfig_DATA=cglm.pc diff --git a/test/src/test_struct.c b/test/src/test_struct.c new file mode 100644 index 0000000..3423ace --- /dev/null +++ b/test/src/test_struct.c @@ -0,0 +1,71 @@ +#include "test_common.h" + +TEST_IMPL(mat3s_identity_init) { + mat3s mat3_identity = GLMS_MAT3_IDENTITY_INIT; + mat3 mat3_identity_a = GLM_MAT3_IDENTITY_INIT; + test_assert_mat3_eq(mat3_identity.raw, mat3_identity_a); + TEST_SUCCESS +} + +TEST_IMPL(mat3s_zero_init) { + mat3s mat3_zero = GLMS_MAT3_ZERO_INIT; + mat3 mat3_zero_a = GLM_MAT3_ZERO_INIT; + test_assert_mat3_eq(mat3_zero.raw, mat3_zero_a); + TEST_SUCCESS +} + +TEST_IMPL(mat4s_identity_init) { + mat4s mat4_identity = GLMS_MAT4_IDENTITY_INIT; + mat4 mat4_identity_a = GLM_MAT4_IDENTITY_INIT; + test_assert_mat4_eq(mat4_identity.raw, mat4_identity_a); + TEST_SUCCESS +} + +TEST_IMPL(mat4s_zero_init) { + mat4s mat4_zero = GLMS_MAT4_ZERO_INIT; + mat4 mat4_zero_a = GLM_MAT4_ZERO_INIT; + test_assert_mat4_eq(mat4_zero.raw, mat4_zero_a); + TEST_SUCCESS +} + +TEST_IMPL(quats_zero_init) { + versors quat_zero = GLMS_QUAT_IDENTITY_INIT; + versor quat_zero_a = GLM_QUAT_IDENTITY_INIT; + test_assert_quat_eq(quat_zero.raw, quat_zero_a); + TEST_SUCCESS +} + +TEST_IMPL(vec3s_one_init) { + vec3s vec3_one = GLMS_VEC3_ONE_INIT; + vec3 vec3_one_a = GLM_VEC3_ONE_INIT; + test_assert_vec3_eq(vec3_one.raw, vec3_one_a); + TEST_SUCCESS +} + +TEST_IMPL(vec3s_zero_init) { + vec3s vec3_zero = GLMS_VEC3_ZERO_INIT; + vec3 vec3_zero_a = GLM_VEC3_ZERO_INIT; + test_assert_vec3_eq(vec3_zero.raw, vec3_zero_a); + TEST_SUCCESS +} + +TEST_IMPL(vec4s_black_init) { + vec4s vec4_black = GLMS_VEC4_BLACK_INIT; + vec4 vec4_black_a = GLM_VEC4_BLACK_INIT; + test_assert_vec4_eq(vec4_black.raw, vec4_black_a); + TEST_SUCCESS +} + +TEST_IMPL(vec4s_one_init) { + vec4s vec4_one = GLMS_VEC4_ONE_INIT; + vec4 vec4_one_a = GLM_VEC4_ONE_INIT; + test_assert_vec4_eq(vec4_one.raw, vec4_one_a); + TEST_SUCCESS +} + +TEST_IMPL(vec4s_zero_init) { + vec4s vec4_zero = GLMS_VEC4_ZERO_INIT; + vec4 vec4_zero_a = GLM_VEC4_ZERO_INIT; + test_assert_vec4_eq(vec4_zero.raw, vec4_zero_a); + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 2193b84..3ace6bf 100644 --- a/test/tests.h +++ b/test/tests.h @@ -504,6 +504,19 @@ TEST_DECLARE(glmc_vec4_fract) TEST_DECLARE(glmc_vec4_hadd) TEST_DECLARE(glmc_vec4_sqrt) +/* structs */ + +TEST_DECLARE(mat3s_identity_init) +TEST_DECLARE(mat3s_zero_init) +TEST_DECLARE(mat4s_identity_init) +TEST_DECLARE(mat4s_zero_init) +TEST_DECLARE(quats_zero_init) +TEST_DECLARE(vec3s_one_init) +TEST_DECLARE(vec3s_zero_init) +TEST_DECLARE(vec4s_black_init) +TEST_DECLARE(vec4s_one_init) +TEST_DECLARE(vec4s_zero_init) + /*****************************************************************************/ TEST_LIST { @@ -996,6 +1009,18 @@ TEST_LIST { TEST_ENTRY(glmc_vec4_fract) TEST_ENTRY(glmc_vec4_hadd) TEST_ENTRY(glmc_vec4_sqrt) + + /* structs */ + TEST_ENTRY(mat3s_identity_init) + TEST_ENTRY(mat3s_zero_init) + TEST_ENTRY(mat4s_identity_init) + TEST_ENTRY(mat4s_zero_init) + TEST_ENTRY(quats_zero_init) + TEST_ENTRY(vec3s_one_init) + TEST_ENTRY(vec3s_zero_init) + TEST_ENTRY(vec4s_black_init) + TEST_ENTRY(vec4s_one_init) + TEST_ENTRY(vec4s_zero_init) }; #endif /* tests_h */ From d89c01b39f2ebac99dce82b75992f2adc5745446 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sun, 24 Nov 2019 16:00:06 -0500 Subject: [PATCH 073/103] Intuit if we should use anonymous structs Rather than making the user #define something explicitly, we can guess based on the compiler type and C standard. --- include/cglm/types-struct.h | 40 ++++++++++++++++++++++++++++++------- 1 file changed, 33 insertions(+), 7 deletions(-) diff --git a/include/cglm/types-struct.h b/include/cglm/types-struct.h index 9304847..cfb7f76 100644 --- a/include/cglm/types-struct.h +++ b/include/cglm/types-struct.h @@ -10,9 +10,35 @@ #include "types.h" +/* + * Anonymous structs are available since C11, but we'd like to be compatible + * with C99 and C89 too. So let's figure out if we should be using them or not. + * It's simply a convenience feature, you can e.g. build the library with + * anonymous structs and your application without them and they'll still be + * compatible, cglm doesn't use the anonymous structs internally. + */ +#ifndef CGLM_USE_ANONYMOUS_STRUCT + /* If the user doesn't explicitly specify if they want anonymous structs or + * not, then we'll try to intuit an appropriate choice. */ +# if defined(CGLM_NO_ANONYMOUS_STRUCT) + /* The user has defined CGLM_NO_ANONYMOUS_STRUCT. This used to be the + * only #define governing the use of anonymous structs, so for backward + * compatibility, we still honor that choice and disable them. */ +# define CGLM_USE_ANONYMOUS_STRUCT 0 +# elif __STDC_VERSION__ >= 20112L || defined(_MSVC_VER) + /* We're compiling for C11 or this is the MSVC compiler. In either + * case, anonymous structs are available, so use them. */ +# define CGLM_USE_ANONYMOUS_STRUCT 1 +# else + /* Otherwise, we're presumably building for C99 or C89 and can't rely + * on anonymous structs being available. Turn them off. */ +# define CGLM_USE_ANONYMOUS_STRUCT 0 +# endif +#endif + typedef union vec2s { vec2 raw; -#ifndef CGLM_NO_ANONYMOUS_STRUCT +#if CGLM_USE_ANONYMOUS_STRUCT struct { float x; float y; @@ -22,7 +48,7 @@ typedef union vec2s { typedef union vec3s { vec3 raw; -#ifndef CGLM_NO_ANONYMOUS_STRUCT +#if CGLM_USE_ANONYMOUS_STRUCT struct { float x; float y; @@ -33,7 +59,7 @@ typedef union vec3s { typedef union ivec3s { ivec3 raw; -#ifndef CGLM_NO_ANONYMOUS_STRUCT +#if CGLM_USE_ANONYMOUS_STRUCT struct { int x; int y; @@ -44,7 +70,7 @@ typedef union ivec3s { typedef union CGLM_ALIGN_IF(16) vec4s { vec4 raw; -#ifndef CGLM_NO_ANONYMOUS_STRUCT +#if CGLM_USE_ANONYMOUS_STRUCT struct { float x; float y; @@ -56,7 +82,7 @@ typedef union CGLM_ALIGN_IF(16) vec4s { typedef union CGLM_ALIGN_IF(16) versors { vec4 raw; -#ifndef CGLM_NO_ANONYMOUS_STRUCT +#if CGLM_USE_ANONYMOUS_STRUCT struct { float x; float y; @@ -74,7 +100,7 @@ typedef union CGLM_ALIGN_IF(16) versors { typedef union mat3s { mat3 raw; vec3s col[3]; -#ifndef CGLM_NO_ANONYMOUS_STRUCT +#if CGLM_USE_ANONYMOUS_STRUCT struct { float m00, m01, m02; float m10, m11, m12; @@ -86,7 +112,7 @@ typedef union mat3s { typedef union CGLM_ALIGN_MAT mat4s { mat4 raw; vec4s col[4]; -#ifndef CGLM_NO_ANONYMOUS_STRUCT +#if CGLM_USE_ANONYMOUS_STRUCT struct { float m00, m01, m02, m03; float m10, m11, m12, m13; From 1d19948f30f546617ca448a1f9f4fe968b4b5616 Mon Sep 17 00:00:00 2001 From: Carsten Hartenfels Date: Sun, 24 Nov 2019 17:28:01 -0500 Subject: [PATCH 074/103] Document struct API and anonymous struct handling --- README.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/README.md b/README.md index c8a5f53..5243140 100644 --- a/README.md +++ b/README.md @@ -131,6 +131,21 @@ glm_mul(T, R, modelMat); glm_inv_tr(modelMat); ``` +### Struct API + +The struct API works as follows, note the `s` suffix on types, the `glms_` prefix on functions and the `GLMS_` prefix on constants: + +```C +#include + +mat4s mat = GLMS_MAT4_IDENTITY_INIT; +mat4s inv = glms_mat4_inv(mat); +``` + +Struct functions generally take their parameters as *values* and *return* their results, rather than taking pointers and writing to out parameters. That means your parameters can usually be `const`, if you're into that. + +The types used are actually unions that allow access to the same data multiple ways. One of those ways involves anonymous structures, available since C11. MSVC also supports it for earlier C versions out of the box and GCC/Clang do if you enable `-fms-extensions`. To explicitly enable these anonymous structures, `#define CGLM_USE_ANONYMOUS_STRUCT` to `1`, to disable them, to `0`. For backward compatibility, you can also `#define CGLM_NO_ANONYMOUS_STRUCT` (value is irrelevant) to disable them. If you don't specify explicitly, cglm will do a best guess based on your compiler and the C version you're using. + ## Build ### Unix (Autotools) From 0330be853c3f3e3383dcba014d7ee8cd4b874646 Mon Sep 17 00:00:00 2001 From: Jay Dolan Date: Sun, 5 Jan 2020 14:20:06 -0500 Subject: [PATCH 075/103] Fix spelling error in name of glms_rotate_x. --- include/cglm/struct/affine.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/cglm/struct/affine.h b/include/cglm/struct/affine.h index 36dbe0f..b8c6f6d 100644 --- a/include/cglm/struct/affine.h +++ b/include/cglm/struct/affine.h @@ -16,7 +16,7 @@ CGLM_INLINE mat4s glms_scale_make(vec3s v); CGLM_INLINE mat4s glms_scale(mat4s m, vec3s v); CGLM_INLINE mat4s glms_scale_uni(mat4s m, float s); - CGLM_INLINE mat4s glmx_rotate_x(mat4s m, float angle); + CGLM_INLINE mat4s glms_rotate_x(mat4s m, float angle); CGLM_INLINE mat4s glms_rotate_y(mat4s m, float angle); CGLM_INLINE mat4s glms_rotate_z(mat4s m, float angle); CGLM_INLINE mat4s glms_rotate_make(float angle, vec3s axis); @@ -169,7 +169,7 @@ glms_scale_uni(mat4s m, float s) { */ CGLM_INLINE mat4s -glmx_rotate_x(mat4s m, float angle) { +glms_rotate_x(mat4s m, float angle) { mat4s r; glm_rotate_x(m.raw, angle, r.raw); return r; From c3b5bb869a4a2ba39815b731a46133810771bec3 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 15 Jan 2020 09:56:19 +0300 Subject: [PATCH 076/103] arm: fix type castings for ARM Neon --- include/cglm/simd/arm.h | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/include/cglm/simd/arm.h b/include/cglm/simd/arm.h index d0e5072..64b2dad 100644 --- a/include/cglm/simd/arm.h +++ b/include/cglm/simd/arm.h @@ -34,17 +34,19 @@ glmm_hadd(float32x4_t v) { static inline float glmm_hmin(float32x4_t v) { - v = vpmin_f32(vget_low_f32(v), vget_high_f32(v)); - v = vpmin_f32(v, v); - return vget_lane_f32(v, 0); + float32x2_t t; + t = vpmin_f32(vget_low_f32(v), vget_high_f32(v)); + t = vpmin_f32(t, t); + return vget_lane_f32(t, 0); } static inline float glmm_hmax(float32x4_t v) { - v = vpmax_f32(vget_low_f32(v), vget_high_f32(v)); - v = vpmax_f32(v, v); - return vget_lane_f32(v, 0); + float32x2_t t; + t = vpmax_f32(vget_low_f32(v), vget_high_f32(v)); + t = vpmax_f32(t, t); + return vget_lane_f32(t, 0); } static inline From af7f8a54364c1cbd14f674fec101133ad29cc830 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 15 Jan 2020 09:56:54 +0300 Subject: [PATCH 077/103] vec4: fix parameter name for NEON --- include/cglm/vec4-ext.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/cglm/vec4-ext.h b/include/cglm/vec4-ext.h index 583376b..6baa70f 100644 --- a/include/cglm/vec4-ext.h +++ b/include/cglm/vec4-ext.h @@ -252,7 +252,7 @@ glm_vec4_abs(vec4 v, vec4 dest) { #if defined( __SSE__ ) || defined( __SSE2__ ) glmm_store(dest, glmm_abs(glmm_load(v))); #elif defined(CGLM_NEON_FP) - vst1q_f32(dest, vabsq_f32(vld1q_f32(a))); + vst1q_f32(dest, vabsq_f32(vld1q_f32(v))); #else dest[0] = fabsf(v[0]); dest[1] = fabsf(v[1]); From f53fd45026f94c0755ef70b7dd1fd4c9639e26cd Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Wed, 15 Jan 2020 16:44:51 +0300 Subject: [PATCH 078/103] Update test_struct.c --- test/src/test_struct.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/src/test_struct.c b/test/src/test_struct.c index 3423ace..9c1126f 100644 --- a/test/src/test_struct.c +++ b/test/src/test_struct.c @@ -1,3 +1,10 @@ +/* +* Copyright (c), Recep Aslantas. +* +* MIT License (MIT), http://opensource.org/licenses/MIT +* Full license can be found in the LICENSE file +*/ + #include "test_common.h" TEST_IMPL(mat3s_identity_init) { From 6abe3f05ab2d2f60d13aeca9a31fa9a4bd4395fe Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 17 Jan 2020 15:17:02 +0300 Subject: [PATCH 079/103] tests: fix quat_look test --- test/src/test_quat.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index b16732a..2d4625c 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -754,7 +754,7 @@ TEST_IMPL(GLM_PREFIX, quat_look) { glm_quat(q1, glm_rad(180.0f), 1.0f, 0.0f, 0.0f); GLM(quat_look)(v1, q1, m1); - glm_look(v1, (vec3){0.0f, 0.0f, 1.0f}, GLM_YUP, m2); + glm_look(v1, (vec3){0.0f, 0.0f, 1.0f}, (vec3){0.0f, -1.0f, 0.0f}, m2); ASSERTIFY(test_assert_mat4_eq(m1, m2)); From 82a195f26af2ab0cf5d99a27a60178cca36625a2 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 17 Jan 2020 23:26:40 +0300 Subject: [PATCH 080/103] now owrkin on v0.6.2 --- configure.ac | 2 +- docs/source/conf.py | 4 ++-- include/cglm/version.h | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/configure.ac b/configure.ac index 473a396..fa94470 100644 --- a/configure.ac +++ b/configure.ac @@ -7,7 +7,7 @@ #***************************************************************************** AC_PREREQ([2.69]) -AC_INIT([cglm], [0.6.1], [info@recp.me]) +AC_INIT([cglm], [0.6.2], [info@recp.me]) AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests]) # Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am. diff --git a/docs/source/conf.py b/docs/source/conf.py index d56ecfd..5c67a3f 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -62,9 +62,9 @@ author = u'Recep Aslantas' # built documents. # # The short X.Y version. -version = u'0.6.1' +version = u'0.6.2' # The full version, including alpha/beta/rc tags. -release = u'0.6.1' +release = u'0.6.2' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/include/cglm/version.h b/include/cglm/version.h index 7926667..10c2542 100644 --- a/include/cglm/version.h +++ b/include/cglm/version.h @@ -10,6 +10,6 @@ #define CGLM_VERSION_MAJOR 0 #define CGLM_VERSION_MINOR 6 -#define CGLM_VERSION_PATCH 1 +#define CGLM_VERSION_PATCH 2 #endif /* cglm_version_h */ From 9af0ebd1427adf0609722f799f2e042bfccf9be2 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 17 Jan 2020 23:27:20 +0300 Subject: [PATCH 081/103] win: fix glms_quat_imagn if use struct option is disabled --- include/cglm/struct/quat.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/cglm/struct/quat.h b/include/cglm/struct/quat.h index 2938478..5940af5 100644 --- a/include/cglm/struct/quat.h +++ b/include/cglm/struct/quat.h @@ -251,7 +251,7 @@ CGLM_INLINE vec3s glms_quat_imagn(versors q) { vec3s dest; - glm_normalize_to(q.imag.raw, dest.raw); + glm_normalize_to(q.raw, dest.raw); return dest; } From cf8dc82783c458096c27521fa5ef144f27f8e13e Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 17 Jan 2020 23:29:36 +0300 Subject: [PATCH 082/103] fix tests on windows (msvc) --- test/runner.c | 2 ++ test/src/test_common.c | 11 ----------- win/cglm-test.vcxproj | 1 + win/cglm-test.vcxproj.filters | 3 +++ 4 files changed, 6 insertions(+), 11 deletions(-) diff --git a/test/runner.c b/test/runner.c index 7d4d858..9a5fd81 100644 --- a/test/runner.c +++ b/test/runner.c @@ -25,6 +25,8 @@ main(int argc, const char * argv[]) { fprintf(stderr, CYAN "\nWelcome to cglm tests\n\n" RESET); + srand((unsigned int)time(NULL)); + for (i = 0; i < count; i++) { int32_t len; diff --git a/test/src/test_common.c b/test/src/test_common.c index ce1acc8..2f177fd 100644 --- a/test/src/test_common.c +++ b/test/src/test_common.c @@ -9,8 +9,6 @@ void test_rand_mat4(mat4 dest) { glm_mat4_copy(GLM_MAT4_IDENTITY, dest); - - srand((unsigned int)time(NULL)); /* random position */ dest[3][0] = drand48(); @@ -28,8 +26,6 @@ void test_rand_mat3(mat3 dest) { mat4 m4; - srand((unsigned int)time(NULL)); - /* random rotatation around random axis with random angle */ glm_rotate_make(m4, drand48(), (vec3){drand48(), drand48(), drand48()}); glm_mat4_pick3(m4, dest); @@ -37,8 +33,6 @@ test_rand_mat3(mat3 dest) { void test_rand_vec3(vec3 dest) { - srand((unsigned int)time(NULL)); - dest[0] = drand48(); dest[1] = drand48(); dest[2] = drand48(); @@ -53,8 +47,6 @@ test_rand_vec3s() { void test_rand_vec4(vec4 dest) { - srand((unsigned int)time(NULL)); - dest[0] = drand48(); dest[1] = drand48(); dest[2] = drand48(); @@ -70,14 +62,11 @@ test_rand_vec4s() { float test_rand(void) { - srand((unsigned int)time(NULL)); return drand48(); } void test_rand_quat(versor q) { - srand((unsigned int)time(NULL)); - glm_quat(q, drand48(), drand48(), drand48(), drand48()); glm_quat_normalize(q); } diff --git a/win/cglm-test.vcxproj b/win/cglm-test.vcxproj index d6927da..19dc3d9 100644 --- a/win/cglm-test.vcxproj +++ b/win/cglm-test.vcxproj @@ -30,6 +30,7 @@ + diff --git a/win/cglm-test.vcxproj.filters b/win/cglm-test.vcxproj.filters index f5ec13b..8797a05 100644 --- a/win/cglm-test.vcxproj.filters +++ b/win/cglm-test.vcxproj.filters @@ -50,6 +50,9 @@ src + + src + From f8784ffe8af842c10afe7eb02a03754efefaebe0 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 17 Jan 2020 23:55:35 +0300 Subject: [PATCH 083/103] win: enable anonymous structs for Visual Studio 2015 and later --- include/cglm/types-struct.h | 36 ++++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/include/cglm/types-struct.h b/include/cglm/types-struct.h index cfb7f76..6af55ed 100644 --- a/include/cglm/types-struct.h +++ b/include/cglm/types-struct.h @@ -18,22 +18,26 @@ * compatible, cglm doesn't use the anonymous structs internally. */ #ifndef CGLM_USE_ANONYMOUS_STRUCT - /* If the user doesn't explicitly specify if they want anonymous structs or - * not, then we'll try to intuit an appropriate choice. */ -# if defined(CGLM_NO_ANONYMOUS_STRUCT) - /* The user has defined CGLM_NO_ANONYMOUS_STRUCT. This used to be the - * only #define governing the use of anonymous structs, so for backward - * compatibility, we still honor that choice and disable them. */ -# define CGLM_USE_ANONYMOUS_STRUCT 0 -# elif __STDC_VERSION__ >= 20112L || defined(_MSVC_VER) - /* We're compiling for C11 or this is the MSVC compiler. In either - * case, anonymous structs are available, so use them. */ -# define CGLM_USE_ANONYMOUS_STRUCT 1 -# else - /* Otherwise, we're presumably building for C99 or C89 and can't rely - * on anonymous structs being available. Turn them off. */ -# define CGLM_USE_ANONYMOUS_STRUCT 0 -# endif + /* If the user doesn't explicitly specify if they want anonymous structs or + * not, then we'll try to intuit an appropriate choice. */ +# if defined(CGLM_NO_ANONYMOUS_STRUCT) + /* The user has defined CGLM_NO_ANONYMOUS_STRUCT. This used to be the + * only #define governing the use of anonymous structs, so for backward + * compatibility, we still honor that choice and disable them. */ +# define CGLM_USE_ANONYMOUS_STRUCT 0 +# elif __STDC_VERSION__ >= 20112L || defined(_MSVC_VER) + /* We're compiling for C11 or this is the MSVC compiler. In either + * case, anonymous structs are available, so use them. */ +# define CGLM_USE_ANONYMOUS_STRUCT 1 +# elif defined(_MSC_VER) && (_MSC_VER >= 1900) /* Visual Studio 2015 */ + /* We can support anonymous structs + * since Visual Studio 2015 or 2017 (1910) maybe? */ +# define CGLM_USE_ANONYMOUS_STRUCT 1 +# else + /* Otherwise, we're presumably building for C99 or C89 and can't rely + * on anonymous structs being available. Turn them off. */ +# define CGLM_USE_ANONYMOUS_STRUCT 0 +# endif #endif typedef union vec2s { From 65de029acbc8ac0ce3b4e453c6e1dc956848911f Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 19 Jan 2020 20:37:49 +0300 Subject: [PATCH 084/103] now working on v0.6.3 --- configure.ac | 2 +- docs/source/conf.py | 4 ++-- include/cglm/version.h | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/configure.ac b/configure.ac index fa94470..520e92a 100644 --- a/configure.ac +++ b/configure.ac @@ -7,7 +7,7 @@ #***************************************************************************** AC_PREREQ([2.69]) -AC_INIT([cglm], [0.6.2], [info@recp.me]) +AC_INIT([cglm], [0.6.3], [info@recp.me]) AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests]) # Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am. diff --git a/docs/source/conf.py b/docs/source/conf.py index 5c67a3f..6fe943d 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -62,9 +62,9 @@ author = u'Recep Aslantas' # built documents. # # The short X.Y version. -version = u'0.6.2' +version = u'0.6.3' # The full version, including alpha/beta/rc tags. -release = u'0.6.2' +release = u'0.6.3' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/include/cglm/version.h b/include/cglm/version.h index 10c2542..e3cd788 100644 --- a/include/cglm/version.h +++ b/include/cglm/version.h @@ -10,6 +10,6 @@ #define CGLM_VERSION_MAJOR 0 #define CGLM_VERSION_MINOR 6 -#define CGLM_VERSION_PATCH 2 +#define CGLM_VERSION_PATCH 3 #endif /* cglm_version_h */ From 406d09e08555501a60902608060d2fa61e075f21 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 19 Jan 2020 21:48:55 +0300 Subject: [PATCH 085/103] make plane zero if norm is zero after normalization --- include/cglm/plane.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/include/cglm/plane.h b/include/cglm/plane.h index 7a5291d..15ae580 100644 --- a/include/cglm/plane.h +++ b/include/cglm/plane.h @@ -30,7 +30,14 @@ CGLM_INLINE void glm_plane_normalize(vec4 plane) { - glm_vec4_scale(plane, 1.0f / glm_vec3_norm(plane), plane); + float norm; + + if ((norm = glm_vec3_norm(plane)) == 0.0f) { + glm_vec4_zero(plane); + return; + } + + glm_vec4_scale(plane, 1.0f / norm, plane); } #endif /* cglm_plane_h */ From c630293c7d5f5046650ad41e3ef5ba55dcef1e80 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 19 Jan 2020 22:12:25 +0300 Subject: [PATCH 086/103] merge test sources into one C source --- Makefile.am | 7 +- test/src/test_mat3.c | 26 ---- test/src/test_mat3.h | 2 + test/src/test_mat4.c | 26 ---- test/src/test_mat4.h | 3 + test/src/test_project.c | 26 ---- test/src/test_quat.c | 224 ---------------------------------- test/src/test_vec3.c | 26 ---- test/src/test_vec4.c | 26 ---- test/src/tests.c | 43 +++++++ test/tests.h | 2 - win/cglm-test.vcxproj | 7 +- win/cglm-test.vcxproj.filters | 21 +--- 13 files changed, 53 insertions(+), 386 deletions(-) delete mode 100644 test/src/test_mat3.c delete mode 100644 test/src/test_mat4.c delete mode 100644 test/src/test_project.c delete mode 100644 test/src/test_quat.c delete mode 100644 test/src/test_vec3.c delete mode 100644 test/src/test_vec4.c create mode 100644 test/src/tests.c diff --git a/Makefile.am b/Makefile.am index 4a022fb..bced060 100644 --- a/Makefile.am +++ b/Makefile.am @@ -141,15 +141,10 @@ libcglm_la_SOURCES=\ test_tests_SOURCES=\ test/runner.c \ test/src/test_common.c \ - test/src/test_mat4.c \ + test/src/tests.c \ test/src/test_cam.c \ - test/src/test_project.c \ test/src/test_clamp.c \ test/src/test_euler.c \ - test/src/test_quat.c \ - test/src/test_vec4.c \ - test/src/test_vec3.c \ - test/src/test_mat3.c \ test/src/test_affine.c \ test/src/test_bezier.c \ test/src/test_struct.c diff --git a/test/src/test_mat3.c b/test/src/test_mat3.c deleted file mode 100644 index 0c9cf98..0000000 --- a/test/src/test_mat3.c +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * - * MIT License (MIT), http://opensource.org/licenses/MIT - * Full license can be found in the LICENSE file - */ - -/* test inline mat3 */ - -#define GLM_PREFIX glm_ -#define GLM(X) (glm_ ## X) - -#include "test_mat3.h" - -#undef GLM -#undef GLM_PREFIX - -/* test pre-compiled mat3 */ - -#define GLM_PREFIX glmc_ -#define GLM(X) (glmc_ ## X) - -#include "test_mat3.h" - -#undef GLM -#undef GLM_PREFIX diff --git a/test/src/test_mat3.h b/test/src/test_mat3.h index 8e2bc5e..76b1786 100644 --- a/test/src/test_mat3.h +++ b/test/src/test_mat3.h @@ -307,3 +307,5 @@ TEST_IMPL(GLM_PREFIX, mat3_rmc) { TEST_SUCCESS } + +#undef A_MATRIX diff --git a/test/src/test_mat4.c b/test/src/test_mat4.c deleted file mode 100644 index b12daf9..0000000 --- a/test/src/test_mat4.c +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * - * MIT License (MIT), http://opensource.org/licenses/MIT - * Full license can be found in the LICENSE file - */ - -/* test inline mat4 */ - -#define GLM_PREFIX glm_ -#define GLM(X) (glm_ ## X) - -#include "test_mat4.h" - -#undef GLM -#undef GLM_PREFIX - -/* test pre-compiled mat4 */ - -#define GLM_PREFIX glmc_ -#define GLM(X) (glmc_ ## X) - -#include "test_mat4.h" - -#undef GLM -#undef GLM_PREFIX diff --git a/test/src/test_mat4.h b/test/src/test_mat4.h index 8f24bac..d42e457 100644 --- a/test/src/test_mat4.h +++ b/test/src/test_mat4.h @@ -483,3 +483,6 @@ TEST_IMPL(GLM_PREFIX, mat4_rmc) { TEST_SUCCESS } + +#undef A_MATRIX +#undef A_MATRIX3 diff --git a/test/src/test_project.c b/test/src/test_project.c deleted file mode 100644 index b55b1d8..0000000 --- a/test/src/test_project.c +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * - * MIT License (MIT), http://opensource.org/licenses/MIT - * Full license can be found in the LICENSE file - */ - -/* test inline project */ - -#define GLM_PREFIX glm_ -#define GLM(X) (glm_ ## X) - -#include "test_project.h" - -#undef GLM -#undef GLM_PREFIX - -/* test pre-compiled project */ - -#define GLM_PREFIX glmc_ -#define GLM(X) (glmc_ ## X) - -#include "test_project.h" - -#undef GLM -#undef GLM_PREFIX diff --git a/test/src/test_quat.c b/test/src/test_quat.c deleted file mode 100644 index 9e2a908..0000000 --- a/test/src/test_quat.c +++ /dev/null @@ -1,224 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * - * MIT License (MIT), http://opensource.org/licenses/MIT - * Full license can be found in the LICENSE file - */ - -#include "test_common.h" - -/* test inline quat */ - -#define GLM_PREFIX glm_ -#define GLM(X) (glm_ ## X) - -#include "test_quat.h" - -#undef GLM -#undef GLM_PREFIX - -/* test pre-compiled quat */ - -#define GLM_PREFIX glmc_ -#define GLM(X) (glmc_ ## X) - -#include "test_quat.h" - -#undef GLM -#undef GLM_PREFIX - -CGLM_INLINE -void -test_quat_mul_raw(versor p, versor q, versor dest) { - dest[0] = p[3] * q[0] + p[0] * q[3] + p[1] * q[2] - p[2] * q[1]; - dest[1] = p[3] * q[1] - p[0] * q[2] + p[1] * q[3] + p[2] * q[0]; - dest[2] = p[3] * q[2] + p[0] * q[1] - p[1] * q[0] + p[2] * q[3]; - dest[3] = p[3] * q[3] - p[0] * q[0] - p[1] * q[1] - p[2] * q[2]; -} - -TEST_IMPL(quat) { - mat4 inRot, outRot, view1, view2, rot1, rot2; - versor inQuat, outQuat, q3, q4, q5; - vec3 eye, axis, imag, v1, v2; - int i; - - /* 0. test identiy quat */ - glm_quat_identity(q4); - ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(0.0f) * 0.5f))) - - glm_quat_mat4(q4, rot1); - ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f)) - - /* 1. test quat to mat and mat to quat */ - for (i = 0; i < 1000; i++) { - test_rand_quat(inQuat); - - glmc_quat_mat4(inQuat, inRot); - glmc_mat4_quat(inRot, outQuat); - glmc_quat_mat4(outQuat, outRot); - - /* 2. test first quat and generated one equality */ - ASSERTIFY(test_assert_quat_eq_abs(inQuat, outQuat)); - - /* 3. test first rot and second rotation */ - /* almost equal */ - ASSERTIFY(test_assert_mat4_eq2(inRot, outRot, 0.000009f)); - - /* 4. test SSE mul and raw mul */ -#if defined( __SSE__ ) || defined( __SSE2__ ) - test_quat_mul_raw(inQuat, outQuat, q3); - glm_quat_mul_sse2(inQuat, outQuat, q4); - ASSERTIFY(test_assert_quat_eq(q3, q4)); -#endif - } - - /* 5. test lookat */ - test_rand_vec3(eye); - glm_quatv(q3, glm_rad(-90.0f), GLM_YUP); - - /* now X axis must be forward axis, Z must be right axis */ - glm_look(eye, GLM_XUP, GLM_YUP, view1); - - /* create view matrix with quaternion */ - glm_quat_look(eye, q3, view2); - - ASSERTIFY(test_assert_mat4_eq2(view1, view2, 0.000009f)); - - /* 6. test quaternion rotation matrix result */ - test_rand_quat(q3); - glm_quat_mat4(q3, rot1); - - /* 6.1 test axis and angle of quat */ - glm_quat_axis(q3, axis); - glm_rotate_make(rot2, glm_quat_angle(q3), axis); - - ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f)); - - /* 7. test quaternion multiplication (hamilton product), - final rotation = first rotation + second = quat1 * quat2 - */ - test_rand_quat(q3); - test_rand_quat(q4); - - glm_quat_mul(q3, q4, q5); - - glm_quat_axis(q3, axis); - glm_rotate_make(rot1, glm_quat_angle(q3), axis); - - glm_quat_axis(q4, axis); - glm_rotate(rot1, glm_quat_angle(q4), axis); - - /* rot2 is combine of two rotation now test with quaternion result */ - glm_quat_mat4(q5, rot2); - - /* result must be same (almost) */ - ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f)) - - /* 8. test quaternion for look rotation */ - - /* 8.1 same direction */ - /* look at from 0, 0, 1 to zero, direction = 0, 0, -1 */ - glm_quat_for((vec3){0, 0, -1}, (vec3){0, 0, -1}, GLM_YUP, q3); - - /* result must be identity */ - glm_quat_identity(q4); - ASSERTIFY(test_assert_quat_eq(q3, q4)) - - /* look at from 0, 0, 1 to zero, direction = 0, 0, -1 */ - glm_quat_forp(GLM_ZUP, GLM_VEC3_ZERO, (vec3){0, 0, -1}, GLM_YUP, q3); - - /* result must be identity */ - glm_quat_identity(q4); - ASSERTIFY(test_assert_quat_eq(q3, q4)) - - /* 8.2 perpendicular */ - glm_quat_for(GLM_XUP, (vec3){0, 0, -1}, GLM_YUP, q3); - - /* result must be -90 */ - glm_quatv(q4, glm_rad(-90.0f), GLM_YUP); - ASSERTIFY(test_assert_quat_eq(q3, q4)) - - /* 9. test imag, real */ - - /* 9.1 real */ - ASSERT(test_eq(glm_quat_real(q4), cosf(glm_rad(-90.0f) * 0.5f))) - - /* 9.1 imag */ - glm_quat_imag(q4, imag); - - /* axis = Y_UP * sinf(angle * 0.5), YUP = 0, 1, 0 */ - axis[0] = 0.0f; - axis[1] = sinf(glm_rad(-90.0f) * 0.5f) * 1.0f; - axis[2] = 0.0f; - - ASSERT(glm_vec3_eqv_eps(imag, axis)); - - /* 9.2 axis */ - glm_quat_axis(q4, axis); - imag[0] = 0.0f; - imag[1] = -1.0f; - imag[2] = 0.0f; - - ASSERTIFY(test_assert_vec3_eq(imag, axis)); - - /* 10. test rotate vector using quat */ - /* (0,0,-1) around (1,0,0) must give (0,1,0) */ - v1[0] = 0.0f; v1[1] = 0.0f; v1[2] = -1.0f; - v2[0] = 0.0f; v2[1] = 0.0f; v2[2] = -1.0f; - - glm_vec3_rotate(v1, glm_rad(90.0f), (vec3){1.0f, 0.0f, 0.0f}); - glm_quatv(q3, glm_rad(90.0f), (vec3){1.0f, 0.0f, 0.0f}); - - glm_vec4_scale(q3, 1.5, q3); - glm_quat_rotatev(q3, v2, v2); - - /* result must be : (0,1,0) */ - ASSERT(fabsf(v1[0]) <= 0.00009f - && fabsf(v1[1] - 1.0f) <= 0.00009f - && fabsf(v1[2]) <= 0.00009f) - - ASSERTIFY(test_assert_vec3_eq(v1, v2)) - - /* 11. test rotate transform */ - glm_translate_make(rot1, (vec3){-10.0, 45.0f, 8.0f}); - glm_rotate(rot1, glm_rad(-90), GLM_ZUP); - - glm_quatv(q3, glm_rad(-90.0f), GLM_ZUP); - glm_translate_make(rot2, (vec3){-10.0, 45.0f, 8.0f}); - glm_quat_rotate(rot2, q3, rot2); - - /* result must be same (almost) */ - ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f)) - - glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP); - glm_translate(rot1, (vec3){-10.0, 45.0f, 8.0f}); - - glm_quatv(q3, glm_rad(-90.0f), GLM_ZUP); - glm_mat4_identity(rot2); - glm_quat_rotate(rot2, q3, rot2); - glm_translate(rot2, (vec3){-10.0, 45.0f, 8.0f}); - - /* result must be same (almost) */ - ASSERTIFY(test_assert_mat4_eq2(rot1, rot2, 0.000009f)) - - /* reverse */ - glm_rotate_make(rot1, glm_rad(-90), GLM_ZUP); - glm_quatv(q3, glm_rad(90.0f), GLM_ZUP); - glm_quat_rotate(rot1, q3, rot1); - - /* result must be identity */ - ASSERTIFY(test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009f)) - - test_rand_quat(q3); - - /* 12. inverse of quat, multiplication must be IDENTITY */ - glm_quat_inv(q3, q4); - glm_quat_mul(q3, q4, q5); - - glm_quat_identity(q3); - ASSERTIFY(test_assert_quat_eq(q3, q5)) - - /* TODO: add tests for slerp, lerp */ - - TEST_SUCCESS -} diff --git a/test/src/test_vec3.c b/test/src/test_vec3.c deleted file mode 100644 index 318d306..0000000 --- a/test/src/test_vec3.c +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * - * MIT License (MIT), http://opensource.org/licenses/MIT - * Full license can be found in the LICENSE file - */ - -/* test inline mat3 */ - -#define GLM_PREFIX glm_ -#define GLM(X) (glm_ ## X) - -#include "test_vec3.h" - -#undef GLM -#undef GLM_PREFIX - -/* test pre-compiled mat3 */ - -#define GLM_PREFIX glmc_ -#define GLM(X) (glmc_ ## X) - -#include "test_vec3.h" - -#undef GLM -#undef GLM_PREFIX diff --git a/test/src/test_vec4.c b/test/src/test_vec4.c deleted file mode 100644 index 5e0b019..0000000 --- a/test/src/test_vec4.c +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * - * MIT License (MIT), http://opensource.org/licenses/MIT - * Full license can be found in the LICENSE file - */ - -/* test inline mat3 */ - -#define GLM_PREFIX glm_ -#define GLM(X) (glm_ ## X) - -#include "test_vec4.h" - -#undef GLM -#undef GLM_PREFIX - -/* test pre-compiled mat3 */ - -#define GLM_PREFIX glmc_ -#define GLM(X) (glmc_ ## X) - -#include "test_vec4.h" - -#undef GLM -#undef GLM_PREFIX diff --git a/test/src/tests.c b/test/src/tests.c new file mode 100644 index 0000000..f7ac304 --- /dev/null +++ b/test/src/tests.c @@ -0,0 +1,43 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +/* test inline */ +/*---------------------------------------------------------------------------*/ + + +#define GLM_PREFIX glm_ +#define GLM(X) (glm_ ## X) + +#include "test_vec3.h" +#include "test_vec4.h" +#include "test_mat3.h" +#include "test_mat4.h" +#include "test_quat.h" +#include "test_project.h" +#include "test_plane.h" + +#undef GLM +#undef GLM_PREFIX + +/* test pre-compiled */ +/*---------------------------------------------------------------------------*/ + +#define GLM_PREFIX glmc_ +#define GLM(X) (glmc_ ## X) + +#include "test_vec3.h" +#include "test_vec4.h" +#include "test_mat3.h" +#include "test_mat4.h" +#include "test_quat.h" +#include "test_project.h" +#include "test_plane.h" + +#undef GLM +#undef GLM_PREFIX + +/*---------------------------------------------------------------------------*/ diff --git a/test/tests.h b/test/tests.h index 3ace6bf..0be27f2 100644 --- a/test/tests.h +++ b/test/tests.h @@ -127,7 +127,6 @@ TEST_DECLARE(clamp) TEST_DECLARE(euler) /* quat */ -TEST_DECLARE(quat) TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY_INIT) TEST_DECLARE(MACRO_GLM_QUAT_IDENTITY) @@ -631,7 +630,6 @@ TEST_LIST { TEST_ENTRY(euler) /* quat */ - TEST_ENTRY(quat) TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY_INIT) TEST_ENTRY(MACRO_GLM_QUAT_IDENTITY) diff --git a/win/cglm-test.vcxproj b/win/cglm-test.vcxproj index 19dc3d9..27a7998 100644 --- a/win/cglm-test.vcxproj +++ b/win/cglm-test.vcxproj @@ -20,19 +20,14 @@ + - - - - - - diff --git a/win/cglm-test.vcxproj.filters b/win/cglm-test.vcxproj.filters index 8797a05..b84e421 100644 --- a/win/cglm-test.vcxproj.filters +++ b/win/cglm-test.vcxproj.filters @@ -32,27 +32,12 @@ src - - src - - - src - - - src - - - src - - - src - - - src - src + + src + From b9f9548b067b7ac839f04c020e3213c0c8b79a5f Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 19 Jan 2020 22:15:19 +0300 Subject: [PATCH 087/103] test: test for plane --- test/src/test_plane.h | 39 +++++++++++++++++++++++++++++++++++++++ test/tests.h | 8 ++++++++ 2 files changed, 47 insertions(+) create mode 100644 test/src/test_plane.h diff --git a/test/src/test_plane.h b/test/src/test_plane.h new file mode 100644 index 0000000..896c8b5 --- /dev/null +++ b/test/src/test_plane.h @@ -0,0 +1,39 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +TEST_IMPL(GLM_PREFIX, plane_normalize) { + vec4 p1 = {2.0f, -3.0f, 4.0f, 5.0f}, p2 = {2.0f, -3.0f, 4.0f, 5.0f}; + float s = 1.0f; + float norm; + + GLM(plane_normalize)(p2); + + norm = sqrtf(p1[0] * p1[0] + p1[1] * p1[1] + p1[2] * p1[2]); + if (norm == 0.0f) { + ASSERT(test_eq(p1[0], 0.0f)) + ASSERT(test_eq(p1[1], 0.0f)) + ASSERT(test_eq(p1[2], 0.0f)) + ASSERT(test_eq(p1[3], 0.0f)) + + TEST_SUCCESS + } + + norm = s / norm; + + ASSERT(test_eq(p1[0] * norm, p2[0])) + ASSERT(test_eq(p1[1] * norm, p2[1])) + ASSERT(test_eq(p1[2] * norm, p2[2])) + ASSERT(test_eq(p1[3] * norm, p2[3])) + + glm_vec4_zero(p1); + GLM(plane_normalize)(p1); + ASSERTIFY(test_assert_vec4_eq(p1, GLM_VEC4_ZERO)) + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 0be27f2..b57fcd4 100644 --- a/test/tests.h +++ b/test/tests.h @@ -120,6 +120,10 @@ TEST_DECLARE(glmc_unprojecti) TEST_DECLARE(glmc_unproject) TEST_DECLARE(glmc_project) +/* plane */ +TEST_DECLARE(glm_plane_normalize) +TEST_DECLARE(glmc_plane_normalize) + /* utils */ TEST_DECLARE(clamp) @@ -623,6 +627,10 @@ TEST_LIST { TEST_ENTRY(glmc_unproject) TEST_ENTRY(glmc_project) + /* plane */ + TEST_ENTRY(glm_plane_normalize) + TEST_ENTRY(glmc_plane_normalize) + /* utils */ TEST_ENTRY(clamp) From 349dc274f43b49942d55080a7b853b902fffe29a Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 20 Feb 2020 15:19:20 +0300 Subject: [PATCH 088/103] add forward vector as macro (vec3, RH) * this will be used for where Vec3.Forward is needed --- include/cglm/vec3.h | 7 ++++--- test/src/test_vec3.h | 8 ++++++++ test/tests.h | 2 ++ 3 files changed, 14 insertions(+), 3 deletions(-) diff --git a/include/cglm/vec3.h b/include/cglm/vec3.h index 0340e96..7abeaf5 100644 --- a/include/cglm/vec3.h +++ b/include/cglm/vec3.h @@ -111,9 +111,10 @@ #define GLM_VEC3_ONE ((vec3)GLM_VEC3_ONE_INIT) #define GLM_VEC3_ZERO ((vec3)GLM_VEC3_ZERO_INIT) -#define GLM_YUP ((vec3){0.0f, 1.0f, 0.0f}) -#define GLM_ZUP ((vec3){0.0f, 0.0f, 1.0f}) -#define GLM_XUP ((vec3){1.0f, 0.0f, 0.0f}) +#define GLM_YUP ((vec3){0.0f, 1.0f, 0.0f}) +#define GLM_ZUP ((vec3){0.0f, 0.0f, 1.0f}) +#define GLM_XUP ((vec3){1.0f, 0.0f, 0.0f}) +#define GLM_FORWARD ((vec3){0.0f, 0.0f, -1.0f}) #define GLM_XXX GLM_SHUFFLE3(0, 0, 0) #define GLM_YYY GLM_SHUFFLE3(1, 1, 1) diff --git a/test/src/test_vec3.h b/test/src/test_vec3.h index 4583950..0b6dc4d 100644 --- a/test/src/test_vec3.h +++ b/test/src/test_vec3.h @@ -74,6 +74,14 @@ TEST_IMPL(MACRO_GLM_XUP) { TEST_SUCCESS } +TEST_IMPL(MACRO_GLM_FORWARD_RH) { + ASSERT(test_eq(GLM_FORWARD[0], 0.0f)) + ASSERT(test_eq(GLM_FORWARD[1], 0.0f)) + ASSERT(test_eq(GLM_FORWARD[2], -1.0f)) + + TEST_SUCCESS +} + TEST_IMPL(MACRO_GLM_SHUFFLE3) { ASSERT(TEST_GLM_SHUFFLE3(1, 0, 0) == GLM_SHUFFLE3(1, 0, 0)) ASSERT(TEST_GLM_SHUFFLE3(0, 1, 0) == GLM_SHUFFLE3(0, 1, 0)) diff --git a/test/tests.h b/test/tests.h index b57fcd4..ec6da23 100644 --- a/test/tests.h +++ b/test/tests.h @@ -205,6 +205,7 @@ TEST_DECLARE(MACRO_GLM_VEC3_ZERO) TEST_DECLARE(MACRO_GLM_YUP) TEST_DECLARE(MACRO_GLM_ZUP) TEST_DECLARE(MACRO_GLM_XUP) +TEST_DECLARE(MACRO_GLM_FORWARD_RH) TEST_DECLARE(MACRO_GLM_SHUFFLE3) TEST_DECLARE(MACRO_GLM_XXX) TEST_DECLARE(MACRO_GLM_YYY) @@ -715,6 +716,7 @@ TEST_LIST { TEST_ENTRY(MACRO_GLM_YUP) TEST_ENTRY(MACRO_GLM_ZUP) TEST_ENTRY(MACRO_GLM_XUP) + TEST_ENTRY(MACRO_GLM_FORWARD_RH) TEST_ENTRY(MACRO_GLM_SHUFFLE3) TEST_ENTRY(MACRO_GLM_XXX) TEST_ENTRY(MACRO_GLM_YYY) From 5ee9bb88dfc8ac2c5eef4a968a9adbc5fdf409f0 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 20 Feb 2020 17:29:32 +0300 Subject: [PATCH 089/103] add notes for versor/quaternion type to describe memory layout --- include/cglm/types.h | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/include/cglm/types.h b/include/cglm/types.h index 169d70b..f2bc7c1 100644 --- a/include/cglm/types.h +++ b/include/cglm/types.h @@ -36,10 +36,15 @@ typedef float vec2[2]; typedef float vec3[3]; typedef int ivec3[3]; typedef CGLM_ALIGN_IF(16) float vec4[4]; -typedef vec4 versor; +typedef vec4 versor; /* |x, y, z, w| -> w is the last */ typedef vec3 mat3[3]; typedef CGLM_ALIGN_MAT vec4 mat4[4]; +/* + Important: cglm stores quaternion as [x, y, z, w] in memory since v0.4.0 + it was [w, x, y, z] before v0.4.0 ( v0.3.5 and earlier ). w is real part. +*/ + #define GLM_E 2.71828182845904523536028747135266250 /* e */ #define GLM_LOG2E 1.44269504088896340735992468100189214 /* log2(e) */ #define GLM_LOG10E 0.434294481903251827651128918916605082 /* log10(e) */ From 2278eba93cefa4e59d1f7857ebd2c64a75e56673 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Thu, 20 Feb 2020 23:37:35 +0300 Subject: [PATCH 090/103] quat: fix quat_for and quat_forp implementations --- include/cglm/call/quat.h | 4 ++-- include/cglm/cam.h | 5 +---- include/cglm/quat.h | 31 ++++++++++---------------- include/cglm/struct/quat.h | 8 +++---- src/quat.c | 8 +++---- test/src/test_quat.h | 45 ++++++++++++++++++++++++++++++++++++++ test/tests.h | 8 +++++++ 7 files changed, 75 insertions(+), 34 deletions(-) diff --git a/include/cglm/call/quat.h b/include/cglm/call/quat.h index ad5f82d..32e503c 100644 --- a/include/cglm/call/quat.h +++ b/include/cglm/call/quat.h @@ -131,11 +131,11 @@ glmc_quat_look(vec3 eye, versor ori, mat4 dest); CGLM_EXPORT void -glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest); +glmc_quat_for(vec3 dir, vec3 up, versor dest); CGLM_EXPORT void -glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest); +glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest); CGLM_EXPORT void diff --git a/include/cglm/cam.h b/include/cglm/cam.h index ad971fe..bbe7fec 100644 --- a/include/cglm/cam.h +++ b/include/cglm/cam.h @@ -319,10 +319,7 @@ glm_perspective_resize(float aspect, mat4 proj) { */ CGLM_INLINE void -glm_lookat(vec3 eye, - vec3 center, - vec3 up, - mat4 dest) { +glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) { CGLM_ALIGN(8) vec3 f, u, s; glm_vec3_sub(center, eye, f); diff --git a/include/cglm/quat.h b/include/cglm/quat.h index 573932f..42caf14 100644 --- a/include/cglm/quat.h +++ b/include/cglm/quat.h @@ -693,32 +693,23 @@ glm_quat_look(vec3 eye, versor ori, mat4 dest) { * @brief creates look rotation quaternion * * @param[in] dir direction to look - * @param[in] fwd forward vector * @param[in] up up vector * @param[out] dest destination quaternion */ CGLM_INLINE void -glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) { - CGLM_ALIGN(8) vec3 axis; - float dot, angle; +glm_quat_for(vec3 dir, vec3 up, versor dest) { + CGLM_ALIGN_MAT mat3 m; - dot = glm_vec3_dot(dir, fwd); - if (fabsf(dot + 1.0f) < 0.000001f) { - glm_quat_init(dest, up[0], up[1], up[2], GLM_PIf); - return; - } + glm_vec3_normalize_to(dir, m[2]); - if (fabsf(dot - 1.0f) < 0.000001f) { - glm_quat_identity(dest); - return; - } + /* No need to negate in LH, but we use RH here */ + glm_vec3_negate(m[2]); + + glm_vec3_crossn(up, m[2], m[0]); + glm_vec3_cross(m[2], m[0], m[1]); - angle = acosf(dot); - glm_cross(fwd, dir, axis); - glm_normalize(axis); - - glm_quatv(dest, angle, axis); + glm_mat3_quat(m, dest); } /*! @@ -733,10 +724,10 @@ glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) { */ CGLM_INLINE void -glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) { +glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) { CGLM_ALIGN(8) vec3 dir; glm_vec3_sub(to, from, dir); - glm_quat_for(dir, fwd, up, dest); + glm_quat_for(dir, up, dest); } /*! diff --git a/include/cglm/struct/quat.h b/include/cglm/struct/quat.h index 5940af5..a855bcf 100644 --- a/include/cglm/struct/quat.h +++ b/include/cglm/struct/quat.h @@ -443,9 +443,9 @@ glms_quat_look(vec3s eye, versors ori) { */ CGLM_INLINE versors -glms_quat_for(vec3s dir, vec3s fwd, vec3s up) { +glms_quat_for(vec3s dir, vec3s up) { versors dest; - glm_quat_for(dir.raw, fwd.raw, up.raw, dest.raw); + glm_quat_for(dir.raw, up.raw, dest.raw); return dest; } @@ -461,9 +461,9 @@ glms_quat_for(vec3s dir, vec3s fwd, vec3s up) { */ CGLM_INLINE versors -glms_quat_forp(vec3s from, vec3s to, vec3s fwd, vec3s up) { +glms_quat_forp(vec3s from, vec3s to, vec3s up) { versors dest; - glm_quat_forp(from.raw, to.raw, fwd.raw, up.raw, dest.raw); + glm_quat_forp(from.raw, to.raw, up.raw, dest.raw); return dest; } diff --git a/src/quat.c b/src/quat.c index efe9458..f992f7c 100644 --- a/src/quat.c +++ b/src/quat.c @@ -184,14 +184,14 @@ glmc_quat_look(vec3 eye, versor ori, mat4 dest) { CGLM_EXPORT void -glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) { - glm_quat_for(dir, fwd, up, dest); +glmc_quat_for(vec3 dir, vec3 up, versor dest) { + glm_quat_for(dir, up, dest); } CGLM_EXPORT void -glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) { - glm_quat_forp(from, to, fwd, up, dest); +glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) { + glm_quat_forp(from, to, up, dest); } CGLM_EXPORT diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 2d4625c..0bfd70c 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -760,3 +760,48 @@ TEST_IMPL(GLM_PREFIX, quat_look) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, quat_for) { + versor q1, q2; + + glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f); + GLM(quat_for)((vec3){-1.0f, 0.0f, 0.0f}, (vec3){0.0f, 1.0f, 0.0f}, q2); + ASSERTIFY(test_assert_quat_eq(q1, q2)); + + glm_quat(q2, glm_rad(90.0f), 1.0f, 0.0f, 0.0f); + GLM(quat_for)((vec3){0.0f, 1.0f, 0.0f}, (vec3){0.0f, 0.0f, 1.0f}, q1); + ASSERTIFY(test_assert_quat_eq(q1, q2)); + + glm_quat(q2, glm_rad(180.0f), 1.0f, 0.0f, 0.0f); + GLM(quat_for)((vec3){0.0f, 0.0f, 1.0f}, (vec3){0.0f, -1.0f, 0.0f}, q1); + ASSERTIFY(test_assert_quat_eq(q1, q2)); + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_forp) { + versor q1, q2; + + glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f); + GLM(quat_forp)((vec3){2.0f, 0.0f, 0.0f}, + (vec3){1.0f, 0.0f, 0.0f}, + (vec3){0.0f, 1.0f, 0.0f}, + q2); + ASSERTIFY(test_assert_quat_eq(q1, q2)); + + glm_quat(q2, glm_rad(90.0f), 1.0f, 0.0f, 0.0f); + GLM(quat_forp)((vec3){0.0f, 1.0f, 0.0f}, + (vec3){0.0f, 2.0f, 0.0f}, + (vec3){0.0f, 0.0f, 1.0f}, + q1); + ASSERTIFY(test_assert_quat_eq(q1, q2)); + + glm_quat(q2, glm_rad(180.0f), 1.0f, 0.0f, 0.0f); + GLM(quat_forp)((vec3){0.0f, 1.0f, 1.0f}, + (vec3){0.0f, 1.0f, 2.0f}, + (vec3){0.0f, -1.0f, 0.0f}, + q1); + ASSERTIFY(test_assert_quat_eq(q1, q2)); + + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index ec6da23..8f132cd 100644 --- a/test/tests.h +++ b/test/tests.h @@ -163,6 +163,8 @@ TEST_DECLARE(glm_quat_lerp) TEST_DECLARE(glm_quat_lerpc) TEST_DECLARE(glm_quat_slerp) TEST_DECLARE(glm_quat_look) +TEST_DECLARE(glm_quat_for) +TEST_DECLARE(glm_quat_forp) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -193,6 +195,8 @@ TEST_DECLARE(glmc_quat_lerp) TEST_DECLARE(glmc_quat_lerpc) TEST_DECLARE(glmc_quat_slerp) TEST_DECLARE(glmc_quat_look) +TEST_DECLARE(glmc_quat_for) +TEST_DECLARE(glmc_quat_forp) /* bezier */ TEST_DECLARE(bezier) @@ -671,6 +675,8 @@ TEST_LIST { TEST_ENTRY(glm_quat_lerpc) TEST_ENTRY(glm_quat_slerp) TEST_ENTRY(glm_quat_look) + TEST_ENTRY(glm_quat_for) + TEST_ENTRY(glm_quat_forp) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -701,6 +707,8 @@ TEST_LIST { TEST_ENTRY(glmc_quat_lerpc) TEST_ENTRY(glmc_quat_slerp) TEST_ENTRY(glmc_quat_look) + TEST_ENTRY(glmc_quat_for) + TEST_ENTRY(glmc_quat_forp) /* bezier */ TEST_ENTRY(bezier) From 6aa8df8e9b1ce46f2a625522bd6c06ddee18ed09 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 21 Feb 2020 10:51:53 +0300 Subject: [PATCH 091/103] quat: add tests for quat_rotatev --- test/src/test_quat.h | 83 ++++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 4 +++ 2 files changed, 87 insertions(+) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 0bfd70c..21ead20 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -805,3 +805,86 @@ TEST_IMPL(GLM_PREFIX, quat_forp) { TEST_SUCCESS } + +TEST_IMPL(GLM_PREFIX, quat_rotatev) { + vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f}; + versor q; + + /* rotate X around Y = -Z */ + glm_quatv(q, GLM_PI_2f, GLM_YUP); + GLM(quat_rotatev)(q, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + + /* rotate -Z around X = Y */ + glm_quatv(q, GLM_PI_2f, GLM_XUP); + GLM(quat_rotatev)(q, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate Y around Z = -X */ + glm_quatv(q, GLM_PI_2f, GLM_ZUP); + GLM(quat_rotatev)(q, v1, v1); + + ASSERT(test_eq(v1[0], -1.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate v2 around Y by 90deg */ + glm_quatv(q, GLM_PI_2f, GLM_YUP); + GLM(quat_rotatev)(q, v2, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], -1.0f)) + + /* rotate v2 around Y by 90deg */ + glm_quatv(q, GLM_PI_2f, GLM_YUP); + GLM(quat_rotatev)(q, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], -1.0f)) + + /* rotate v2 around Y by 90deg */ + glm_quatv(q, GLM_PI_2f, GLM_YUP); + GLM(quat_rotatev)(q, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], 1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + /* rotate v2 around X by 90deg */ + glm_quatv(q, GLM_PI_2f, GLM_XUP); + GLM(quat_rotatev)(q, v2, v2); + + ASSERT(test_eq(v2[0], -1.0f)) + ASSERT(test_eq(v2[1], -1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + /* rotate v2 around Z by 90deg */ + glm_quatv(q, GLM_PI_2f, GLM_ZUP); + GLM(quat_rotatev)(q, v2, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], -1.0f)) + ASSERT(test_eq(v2[2], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_rotate) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_rotate_at) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, quat_rotate_atm) { + TEST_SUCCESS +} diff --git a/test/tests.h b/test/tests.h index 8f132cd..2e9d8a3 100644 --- a/test/tests.h +++ b/test/tests.h @@ -165,6 +165,7 @@ TEST_DECLARE(glm_quat_slerp) TEST_DECLARE(glm_quat_look) TEST_DECLARE(glm_quat_for) TEST_DECLARE(glm_quat_forp) +TEST_DECLARE(glm_quat_rotatev) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -197,6 +198,7 @@ TEST_DECLARE(glmc_quat_slerp) TEST_DECLARE(glmc_quat_look) TEST_DECLARE(glmc_quat_for) TEST_DECLARE(glmc_quat_forp) +TEST_DECLARE(glmc_quat_rotatev) /* bezier */ TEST_DECLARE(bezier) @@ -677,6 +679,7 @@ TEST_LIST { TEST_ENTRY(glm_quat_look) TEST_ENTRY(glm_quat_for) TEST_ENTRY(glm_quat_forp) + TEST_ENTRY(glm_quat_rotatev) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -709,6 +712,7 @@ TEST_LIST { TEST_ENTRY(glmc_quat_look) TEST_ENTRY(glmc_quat_for) TEST_ENTRY(glmc_quat_forp) + TEST_ENTRY(glmc_quat_rotatev) /* bezier */ TEST_ENTRY(bezier) From e7a0906bc2454d7c2128c897645fc92e111b5f8c Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 21 Feb 2020 11:48:25 +0300 Subject: [PATCH 092/103] quat: add tests for quat_rotate --- test/src/test_quat.h | 43 +++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 4 ++++ 2 files changed, 47 insertions(+) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 21ead20..8037b7d 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -878,6 +878,49 @@ TEST_IMPL(GLM_PREFIX, quat_rotatev) { } TEST_IMPL(GLM_PREFIX, quat_rotate) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2; + versor q1; + vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; + + /* rotate X around Y = -Z */ + glm_quatv(q1, GLM_PI_2f, GLM_YUP); + GLM(quat_rotate)(m1, q1, m1); + glm_rotate_make(m2, GLM_PI_2f, GLM_YUP); + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + + glm_mat4_identity(m1); + glm_mat4_identity(m2); + + /* rotate -Z around X = Y */ + glm_quatv(q1, GLM_PI_2f, GLM_XUP); + GLM(quat_rotate)(m1, q1, m1); + glm_rotate(m2, GLM_PI_2f, GLM_XUP); + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + glm_mat4_identity(m1); + glm_mat4_identity(m2); + + /* rotate Y around X = +Z */ + glm_quatv(q1, GLM_PI_2f, GLM_XUP); + GLM(quat_rotate)(m1, q1, m1); + glm_rotate(m2, GLM_PI_2f, GLM_XUP); + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + TEST_SUCCESS } diff --git a/test/tests.h b/test/tests.h index 2e9d8a3..f7d957b 100644 --- a/test/tests.h +++ b/test/tests.h @@ -166,6 +166,7 @@ TEST_DECLARE(glm_quat_look) TEST_DECLARE(glm_quat_for) TEST_DECLARE(glm_quat_forp) TEST_DECLARE(glm_quat_rotatev) +TEST_DECLARE(glm_quat_rotate) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -199,6 +200,7 @@ TEST_DECLARE(glmc_quat_look) TEST_DECLARE(glmc_quat_for) TEST_DECLARE(glmc_quat_forp) TEST_DECLARE(glmc_quat_rotatev) +TEST_DECLARE(glmc_quat_rotate) /* bezier */ TEST_DECLARE(bezier) @@ -680,6 +682,7 @@ TEST_LIST { TEST_ENTRY(glm_quat_for) TEST_ENTRY(glm_quat_forp) TEST_ENTRY(glm_quat_rotatev) + TEST_ENTRY(glm_quat_rotate) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -713,6 +716,7 @@ TEST_LIST { TEST_ENTRY(glmc_quat_for) TEST_ENTRY(glmc_quat_forp) TEST_ENTRY(glmc_quat_rotatev) + TEST_ENTRY(glmc_quat_rotate) /* bezier */ TEST_ENTRY(bezier) From 8ac1347f8a9693519217482df4505d0875622a96 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 21 Feb 2020 12:55:52 +0300 Subject: [PATCH 093/103] remove unused params from docs --- docs/source/quat.rst | 8 +++----- include/cglm/quat.h | 1 - include/cglm/struct/quat.h | 2 -- 3 files changed, 3 insertions(+), 8 deletions(-) diff --git a/docs/source/quat.rst b/docs/source/quat.rst index caac1bf..cc991da 100644 --- a/docs/source/quat.rst +++ b/docs/source/quat.rst @@ -324,26 +324,24 @@ Functions documentation | *[in]* **ori** orientation in world space as quaternion | *[out]* **dest** result matrix -.. c:function:: void glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest) +.. c:function:: void glm_quat_for(vec3 dir, vec3 up, versor dest) | creates look rotation quaternion Parameters: | *[in]* **dir** direction to look - | *[in]* **fwd** forward vector | *[in]* **up** up vector | *[out]* **dest** result matrix -.. c:function:: void glm_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest) +.. c:function:: void glm_quat_forp(vec3 from, vec3 to, vec3 up, versor dest) - | creates look rotation quaternion using source and destination positions p suffix stands for position + | creates look rotation quaternion using source and destination positions p suffix stands for position | this is similar to glm_quat_for except this computes direction for glm_quat_for for you. Parameters: | *[in]* **from** source point | *[in]* **to** destination point - | *[in]* **fwd** forward vector | *[in]* **up** up vector | *[out]* **dest** result matrix diff --git a/include/cglm/quat.h b/include/cglm/quat.h index 42caf14..b2e32e4 100644 --- a/include/cglm/quat.h +++ b/include/cglm/quat.h @@ -718,7 +718,6 @@ glm_quat_for(vec3 dir, vec3 up, versor dest) { * * @param[in] from source point * @param[in] to destination point - * @param[in] fwd forward vector * @param[in] up up vector * @param[out] dest destination quaternion */ diff --git a/include/cglm/struct/quat.h b/include/cglm/struct/quat.h index a855bcf..8b3774a 100644 --- a/include/cglm/struct/quat.h +++ b/include/cglm/struct/quat.h @@ -437,7 +437,6 @@ glms_quat_look(vec3s eye, versors ori) { * @brief creates look rotation quaternion * * @param[in] dir direction to look - * @param[in] fwd forward vector * @param[in] up up vector * @returns destination quaternion */ @@ -455,7 +454,6 @@ glms_quat_for(vec3s dir, vec3s up) { * * @param[in] from source point * @param[in] to destination point - * @param[in] fwd forward vector * @param[in] up up vector * @returns destination quaternion */ From de85a4eb2bf458de9fd0ae760140e28267057372 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 21 Feb 2020 14:28:41 +0300 Subject: [PATCH 094/103] quat: add tests for quat_rotate_at[m] --- test/src/test_quat.h | 70 ++++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 8 +++++ 2 files changed, 78 insertions(+) diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 8037b7d..15c81e3 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -925,9 +925,79 @@ TEST_IMPL(GLM_PREFIX, quat_rotate) { } TEST_IMPL(GLM_PREFIX, quat_rotate_at) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2; + versor q1; + vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; + + glm_quatv(q1, GLM_PI_2f, GLM_YUP); + GLM(quat_rotate_at)(m1, q1, (vec3){0.5f, 0.0f, 0.0f}); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.5f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -0.5f)) + + glm_mat4_identity(m1); + glm_mat4_identity(m2); + + glm_quatv(q1, GLM_PI_2f, GLM_ZUP); + GLM(quat_rotate_at)(m1, q1, (vec3){0.0f, 0.0f, 0.0f}); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.5f)) + ASSERT(test_eq(v1[2], -0.5f)) + + glm_mat4_identity(m1); + glm_mat4_identity(m2); + + v1[0] = 1.0f; + v1[1] = 1.0f; + v1[2] = 1.0f; + + glm_quatv(q1, GLM_PI_2f, GLM_XUP); + GLM(quat_rotate_at)(m1, q1, GLM_VEC3_ZERO); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 1.0f)) + ASSERT(test_eq(v1[1], -1.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, quat_rotate_atm) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2; + versor q1; + vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; + + glm_quatv(q1, GLM_PI_2f, GLM_YUP); + GLM(quat_rotate_atm)(m1, q1, (vec3){0.5f, 0.0f, 0.0f}); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.5f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -0.5f)) + + glm_quatv(q1, GLM_PI_2f, GLM_ZUP); + GLM(quat_rotate_atm)(m1, q1, (vec3){0.0f, 0.0f, 0.0f}); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.5f)) + ASSERT(test_eq(v1[2], -0.5f)) + + v1[0] = 1.0f; + v1[1] = 1.0f; + v1[2] = 1.0f; + + glm_quatv(q1, GLM_PI_2f, GLM_XUP); + GLM(quat_rotate_atm)(m1, q1, GLM_VEC3_ZERO); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 1.0f)) + ASSERT(test_eq(v1[1], -1.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + TEST_SUCCESS } diff --git a/test/tests.h b/test/tests.h index f7d957b..eb3362b 100644 --- a/test/tests.h +++ b/test/tests.h @@ -167,6 +167,8 @@ TEST_DECLARE(glm_quat_for) TEST_DECLARE(glm_quat_forp) TEST_DECLARE(glm_quat_rotatev) TEST_DECLARE(glm_quat_rotate) +TEST_DECLARE(glm_quat_rotate_at) +TEST_DECLARE(glm_quat_rotate_atm) TEST_DECLARE(glmc_quat_identity) TEST_DECLARE(glmc_quat_identity_array) @@ -201,6 +203,8 @@ TEST_DECLARE(glmc_quat_for) TEST_DECLARE(glmc_quat_forp) TEST_DECLARE(glmc_quat_rotatev) TEST_DECLARE(glmc_quat_rotate) +TEST_DECLARE(glmc_quat_rotate_at) +TEST_DECLARE(glmc_quat_rotate_atm) /* bezier */ TEST_DECLARE(bezier) @@ -683,6 +687,8 @@ TEST_LIST { TEST_ENTRY(glm_quat_forp) TEST_ENTRY(glm_quat_rotatev) TEST_ENTRY(glm_quat_rotate) + TEST_ENTRY(glm_quat_rotate_at) + TEST_ENTRY(glm_quat_rotate_atm) TEST_ENTRY(glmc_quat_identity) TEST_ENTRY(glmc_quat_identity_array) @@ -717,6 +723,8 @@ TEST_LIST { TEST_ENTRY(glmc_quat_forp) TEST_ENTRY(glmc_quat_rotatev) TEST_ENTRY(glmc_quat_rotate) + TEST_ENTRY(glmc_quat_rotate_at) + TEST_ENTRY(glmc_quat_rotate_atm) /* bezier */ TEST_ENTRY(bezier) From 81ae182972b568247fb51ef8b544c1fe8f45c83f Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 21 Feb 2020 15:52:34 +0300 Subject: [PATCH 095/103] tests: add tests for affine translations --- test/src/test_affine.h | 166 +++++++++++++++++++++++++++++++++++++++++ test/src/tests.c | 2 + test/tests.h | 30 ++++++++ 3 files changed, 198 insertions(+) create mode 100644 test/src/test_affine.h diff --git a/test/src/test_affine.h b/test/src/test_affine.h new file mode 100644 index 0000000..f69db2b --- /dev/null +++ b/test/src/test_affine.h @@ -0,0 +1,166 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +TEST_IMPL(GLM_PREFIX, translate) { + mat4 t1, t2, t3, t4, t5; + mat4 m1; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(translate)(m1, (vec3){13.0f, 11.0f, 7.0f}); + glm_mat4_mulv(m1, v1, v2); + + ASSERT(test_eq(v2[0], 14.0f)) + ASSERT(test_eq(v2[1], 13.0f)) + ASSERT(test_eq(v2[2], 10.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(translate)(m1, (vec3){1.0f, -1.0f, -5.0f}); + glm_mat4_mulv(m1, v2, v2); + + ASSERT(test_eq(v2[0], 15.0f)) + ASSERT(test_eq(v2[1], 12.0f)) + ASSERT(test_eq(v2[2], 5.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, translate_to) { + mat4 t1, t2, t3, t4, t5; + mat4 m1, m2; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(translate_to)(m1, (vec3){13.0f, 11.0f, 7.0f}, m2); + glm_mat4_mulv(m2, v1, v2); + + ASSERT(test_eq(v2[0], 14.0f)) + ASSERT(test_eq(v2[1], 13.0f)) + ASSERT(test_eq(v2[2], 10.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(translate_to)(m1, (vec3){1.0f, -1.0f, -5.0f}, m2); + glm_mat4_mulv(m2, v2, v2); + + ASSERT(test_eq(v2[0], 15.0f)) + ASSERT(test_eq(v2[1], 12.0f)) + ASSERT(test_eq(v2[2], 5.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, translate_x) { + mat4 t1, t2, t3, t4, t5; + mat4 m1; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(translate_x)(m1, 13.0f); + glm_mat4_mulv(m1, v1, v2); + + ASSERT(test_eq(v2[0], 14.0f)) + ASSERT(test_eq(v2[1], 2.0f)) + ASSERT(test_eq(v2[2], 3.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(translate_x)(m1, -1.0f); + glm_mat4_mulv(m1, v2, v2); + + ASSERT(test_eq(v2[0], 13.0f)) + ASSERT(test_eq(v2[1], 2.0f)) + ASSERT(test_eq(v2[2], 3.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, translate_y) { + mat4 t1, t2, t3, t4, t5; + mat4 m1; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(translate_y)(m1, 11.0f); + glm_mat4_mulv(m1, v1, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 13.0f)) + ASSERT(test_eq(v2[2], 3.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(translate_y)(m1, -1.0f); + glm_mat4_mulv(m1, v2, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 12.0f)) + ASSERT(test_eq(v2[2], 3.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, translate_z) { + mat4 t1, t2, t3, t4, t5; + mat4 m1; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(translate_z)(m1, 7.0f); + glm_mat4_mulv(m1, v1, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 2.0f)) + ASSERT(test_eq(v2[2], 10.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(translate_z)(m1, -5.0f); + glm_mat4_mulv(m1, v2, v2); + + ASSERT(test_eq(v2[0], 1.0f)) + ASSERT(test_eq(v2[1], 2.0f)) + ASSERT(test_eq(v2[2], 5.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, translate_make) { + mat4 t1, t2, t3, t4, t5; + mat4 m1, m2; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(translate_make)(m1, (vec3){13.0f, 11.0f, 7.0f}); + glm_mat4_mulv(m1, v1, v2); + + ASSERT(test_eq(v2[0], 14.0f)) + ASSERT(test_eq(v2[1], 13.0f)) + ASSERT(test_eq(v2[2], 10.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(translate_make)(m1, (vec3){1.0f, -1.0f, -5.0f}); + glm_mat4_mulv(m1, v2, v2); + + ASSERT(test_eq(v2[0], 15.0f)) + ASSERT(test_eq(v2[1], 12.0f)) + ASSERT(test_eq(v2[2], 5.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + TEST_SUCCESS +} + +} diff --git a/test/src/tests.c b/test/src/tests.c index f7ac304..857dea1 100644 --- a/test/src/tests.c +++ b/test/src/tests.c @@ -19,6 +19,7 @@ #include "test_quat.h" #include "test_project.h" #include "test_plane.h" +#include "test_affine.h" #undef GLM #undef GLM_PREFIX @@ -36,6 +37,7 @@ #include "test_quat.h" #include "test_project.h" #include "test_plane.h" +#include "test_affine.h" #undef GLM #undef GLM_PREFIX diff --git a/test/tests.h b/test/tests.h index eb3362b..0add347 100644 --- a/test/tests.h +++ b/test/tests.h @@ -16,6 +16,21 @@ * 2. use TEST_ENTRY() to add test to list */ +/* affine */ +TEST_DECLARE(glm_translate) +TEST_DECLARE(glm_translate_to) +TEST_DECLARE(glm_translate_x) +TEST_DECLARE(glm_translate_y) +TEST_DECLARE(glm_translate_z) +TEST_DECLARE(glm_translate_make) + +TEST_DECLARE(glmc_translate) +TEST_DECLARE(glmc_translate_to) +TEST_DECLARE(glmc_translate_x) +TEST_DECLARE(glmc_translate_y) +TEST_DECLARE(glmc_translate_z) +TEST_DECLARE(glmc_translate_make) + /* mat4 */ TEST_DECLARE(glm_mat4_ucopy) TEST_DECLARE(glm_mat4_copy) @@ -536,6 +551,21 @@ TEST_DECLARE(vec4s_zero_init) /*****************************************************************************/ TEST_LIST { + /* affine */ + TEST_ENTRY(glm_translate) + TEST_ENTRY(glm_translate_to) + TEST_ENTRY(glm_translate_x) + TEST_ENTRY(glm_translate_y) + TEST_ENTRY(glm_translate_z) + TEST_ENTRY(glm_translate_make) + + TEST_ENTRY(glmc_translate) + TEST_ENTRY(glmc_translate_to) + TEST_ENTRY(glmc_translate_x) + TEST_ENTRY(glmc_translate_y) + TEST_ENTRY(glmc_translate_z) + TEST_ENTRY(glmc_translate_make) + /* mat4 */ TEST_ENTRY(glm_mat4_ucopy) TEST_ENTRY(glm_mat4_copy) From a1f7afe055e2f623d575eb8c4fa0f5f79501743c Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 21 Feb 2020 15:56:15 +0300 Subject: [PATCH 096/103] Update test_affine.h --- test/src/test_affine.h | 58 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/test/src/test_affine.h b/test/src/test_affine.h index f69db2b..7a846db 100644 --- a/test/src/test_affine.h +++ b/test/src/test_affine.h @@ -163,4 +163,62 @@ TEST_IMPL(GLM_PREFIX, translate_make) { TEST_SUCCESS } +TEST_IMPL(GLM_PREFIX, scale_to) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, scale_make) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, scale) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, scale_uni) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, rotate_x) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, rotate_y) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, rotate_z) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, rotate_make) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, rotate) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, rotate_at) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, rotate_atm) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, decompose_scalev) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, uniscaled) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, decompose_rs) { + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, decompose) { + TEST_SUCCESS } From 6b32b5dc35e6d1cf24c6f5b49c50918c7406994f Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 21 Feb 2020 16:57:09 +0300 Subject: [PATCH 097/103] tests: add tests for affine scales --- test/src/test_affine.h | 86 ++++++++++++++++++++++++++++++++++++++++++ test/tests.h | 16 ++++++++ 2 files changed, 102 insertions(+) diff --git a/test/src/test_affine.h b/test/src/test_affine.h index 7a846db..d01777f 100644 --- a/test/src/test_affine.h +++ b/test/src/test_affine.h @@ -164,18 +164,104 @@ TEST_IMPL(GLM_PREFIX, translate_make) { } TEST_IMPL(GLM_PREFIX, scale_to) { + mat4 t1, t2, t3, t4, t5; + mat4 m1, m2; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(scale_to)(m1, (vec3){13.0f, 11.0f, 7.0f}, m2); + glm_mat4_mulv(m2, v1, v2); + + ASSERT(test_eq(v2[0], 13.0f)) + ASSERT(test_eq(v2[1], 22.0f)) + ASSERT(test_eq(v2[2], 21.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(scale_to)(m1, (vec3){1.0f, -1.0f, -5.0f}, m2); + glm_mat4_mulv(m2, v2, v2); + + ASSERT(test_eq(v2[0], 13.0f)) + ASSERT(test_eq(v2[1], -22.0f)) + ASSERT(test_eq(v2[2], -105.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, scale_make) { + mat4 t1, t2, t3, t4, t5; + mat4 m1; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + GLM(scale_make)(m1, (vec3){13.0f, 11.0f, 7.0f}); + glm_mat4_mulv(m1, v1, v2); + + ASSERT(test_eq(v2[0], 13.0f)) + ASSERT(test_eq(v2[1], 22.0f)) + ASSERT(test_eq(v2[2], 21.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + GLM(scale_make)(m1, (vec3){1.0f, -1.0f, -5.0f}); + glm_mat4_mulv(m1, v2, v2); + + ASSERT(test_eq(v2[0], 13.0f)) + ASSERT(test_eq(v2[1], -22.0f)) + ASSERT(test_eq(v2[2], -105.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, scale) { + mat4 t1, t2, t3, t4, t5; + mat4 m1; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(scale)(m1, (vec3){13.0f, 11.0f, 7.0f}); + glm_mat4_mulv(m1, v1, v2); + + ASSERT(test_eq(v2[0], 13.0f)) + ASSERT(test_eq(v2[1], 22.0f)) + ASSERT(test_eq(v2[2], 21.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(scale)(m1, (vec3){1.0f, -1.0f, -5.0f}); + glm_mat4_mulv(m1, v2, v2); + + ASSERT(test_eq(v2[0], 13.0f)) + ASSERT(test_eq(v2[1], -22.0f)) + ASSERT(test_eq(v2[2], -105.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, scale_uni) { + mat4 t1, t2, t3, t4, t5; + mat4 m1; + vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; + + glm_mat4_identity(m1); + GLM(scale_uni)(m1, 13.0f); + glm_mat4_mulv(m1, v1, v2); + + ASSERT(test_eq(v2[0], 13.0f)) + ASSERT(test_eq(v2[1], 26.0f)) + ASSERT(test_eq(v2[2], 39.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + + glm_mat4_identity(m1); + GLM(scale_uni)(m1, -5.0f); + glm_mat4_mulv(m1, v2, v2); + + ASSERT(test_eq(v2[0], -65.0f)) + ASSERT(test_eq(v2[1], -130.0f)) + ASSERT(test_eq(v2[2], -195.0f)) + ASSERT(test_eq(v2[3], 1.0f)) + TEST_SUCCESS } diff --git a/test/tests.h b/test/tests.h index 0add347..dd7b2a0 100644 --- a/test/tests.h +++ b/test/tests.h @@ -23,6 +23,10 @@ TEST_DECLARE(glm_translate_x) TEST_DECLARE(glm_translate_y) TEST_DECLARE(glm_translate_z) TEST_DECLARE(glm_translate_make) +TEST_DECLARE(glm_scale_to) +TEST_DECLARE(glm_scale_make) +TEST_DECLARE(glm_scale) +TEST_DECLARE(glm_scale_uni) TEST_DECLARE(glmc_translate) TEST_DECLARE(glmc_translate_to) @@ -30,6 +34,10 @@ TEST_DECLARE(glmc_translate_x) TEST_DECLARE(glmc_translate_y) TEST_DECLARE(glmc_translate_z) TEST_DECLARE(glmc_translate_make) +TEST_DECLARE(glmc_scale_to) +TEST_DECLARE(glmc_scale_make) +TEST_DECLARE(glmc_scale) +TEST_DECLARE(glmc_scale_uni) /* mat4 */ TEST_DECLARE(glm_mat4_ucopy) @@ -558,6 +566,10 @@ TEST_LIST { TEST_ENTRY(glm_translate_y) TEST_ENTRY(glm_translate_z) TEST_ENTRY(glm_translate_make) + TEST_ENTRY(glm_scale_to) + TEST_ENTRY(glm_scale_make) + TEST_ENTRY(glm_scale) + TEST_ENTRY(glm_scale_uni) TEST_ENTRY(glmc_translate) TEST_ENTRY(glmc_translate_to) @@ -565,6 +577,10 @@ TEST_LIST { TEST_ENTRY(glmc_translate_y) TEST_ENTRY(glmc_translate_z) TEST_ENTRY(glmc_translate_make) + TEST_ENTRY(glmc_scale_to) + TEST_ENTRY(glmc_scale_make) + TEST_ENTRY(glmc_scale) + TEST_ENTRY(glmc_scale_uni) /* mat4 */ TEST_ENTRY(glm_mat4_ucopy) From 59952691956fc41b459b8567603d5454a34755d4 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Fri, 21 Feb 2020 17:52:50 +0300 Subject: [PATCH 098/103] tests: add tests for some affine rotations --- test/src/test_affine.h | 111 +++++++++++++++++++++++++++++++++++++++++ test/tests.h | 16 ++++++ 2 files changed, 127 insertions(+) diff --git a/test/src/test_affine.h b/test/src/test_affine.h index d01777f..e97a9b1 100644 --- a/test/src/test_affine.h +++ b/test/src/test_affine.h @@ -266,18 +266,129 @@ TEST_IMPL(GLM_PREFIX, scale_uni) { } TEST_IMPL(GLM_PREFIX, rotate_x) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + vec4 v1 = {0.0f, 1.0f, 0.0f, 1.0f}, v2 = {0.0f, 1.0f, 0.0f, 1.0f}; + + GLM(rotate_x)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + + glm_vec3_copy(v2, v1); + + GLM(rotate_x)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], -1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + glm_vec3_copy(v2, v1); + + GLM(rotate_x)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, rotate_y) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}, v2 = {1.0f, 0.0f, 0.0f, 1.0f}; + + GLM(rotate_y)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + + glm_vec3_copy(v2, v1); + + GLM(rotate_y)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], -1.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + glm_vec3_copy(v2, v1); + + GLM(rotate_y)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, rotate_z) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + vec4 v1 = {0.0f, 1.0f, 0.0f, 1.0f}, v2 = {0.0f, 1.0f, 0.0f, 1.0f}; + + GLM(rotate_z)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], -1.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + glm_vec3_copy(v2, v1); + + GLM(rotate_z)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], -1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + glm_vec3_copy(v2, v1); + + GLM(rotate_z)(m1, GLM_PI_2f, m1); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 1.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, rotate_make) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; + + /* rotate X around Y = -Z */ + GLM(rotate_make)(m1, GLM_PI_2f, GLM_YUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + + /* rotate -Z around X = Y */ + GLM(rotate_make)(m1, GLM_PI_2f, GLM_XUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + /* rotate Y around X = +Z */ + GLM(rotate_make)(m1, GLM_PI_2f, GLM_XUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + TEST_SUCCESS } diff --git a/test/tests.h b/test/tests.h index dd7b2a0..07ec651 100644 --- a/test/tests.h +++ b/test/tests.h @@ -27,6 +27,10 @@ TEST_DECLARE(glm_scale_to) TEST_DECLARE(glm_scale_make) TEST_DECLARE(glm_scale) TEST_DECLARE(glm_scale_uni) +TEST_DECLARE(glm_rotate_x) +TEST_DECLARE(glm_rotate_y) +TEST_DECLARE(glm_rotate_z) +TEST_DECLARE(glm_rotate_make) TEST_DECLARE(glmc_translate) TEST_DECLARE(glmc_translate_to) @@ -38,6 +42,10 @@ TEST_DECLARE(glmc_scale_to) TEST_DECLARE(glmc_scale_make) TEST_DECLARE(glmc_scale) TEST_DECLARE(glmc_scale_uni) +TEST_DECLARE(glmc_rotate_x) +TEST_DECLARE(glmc_rotate_y) +TEST_DECLARE(glmc_rotate_z) +TEST_DECLARE(glmc_rotate_make) /* mat4 */ TEST_DECLARE(glm_mat4_ucopy) @@ -570,6 +578,10 @@ TEST_LIST { TEST_ENTRY(glm_scale_make) TEST_ENTRY(glm_scale) TEST_ENTRY(glm_scale_uni) + TEST_ENTRY(glm_rotate_x) + TEST_ENTRY(glm_rotate_y) + TEST_ENTRY(glm_rotate_z) + TEST_ENTRY(glm_rotate_make) TEST_ENTRY(glmc_translate) TEST_ENTRY(glmc_translate_to) @@ -581,6 +593,10 @@ TEST_LIST { TEST_ENTRY(glmc_scale_make) TEST_ENTRY(glmc_scale) TEST_ENTRY(glmc_scale_uni) + TEST_ENTRY(glmc_rotate_x) + TEST_ENTRY(glmc_rotate_y) + TEST_ENTRY(glmc_rotate_z) + TEST_ENTRY(glmc_rotate_make) /* mat4 */ TEST_ENTRY(glm_mat4_ucopy) From 3fca734c30943fa634777cda1a0aee780c10d23d Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 22 Feb 2020 00:48:41 +0300 Subject: [PATCH 099/103] tests: remove unused variables --- test/src/test_affine.h | 12 +----------- test/src/test_quat.h | 2 +- 2 files changed, 2 insertions(+), 12 deletions(-) diff --git a/test/src/test_affine.h b/test/src/test_affine.h index e97a9b1..16434fd 100644 --- a/test/src/test_affine.h +++ b/test/src/test_affine.h @@ -8,7 +8,6 @@ #include "test_common.h" TEST_IMPL(GLM_PREFIX, translate) { - mat4 t1, t2, t3, t4, t5; mat4 m1; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; @@ -34,7 +33,6 @@ TEST_IMPL(GLM_PREFIX, translate) { } TEST_IMPL(GLM_PREFIX, translate_to) { - mat4 t1, t2, t3, t4, t5; mat4 m1, m2; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; @@ -60,7 +58,6 @@ TEST_IMPL(GLM_PREFIX, translate_to) { } TEST_IMPL(GLM_PREFIX, translate_x) { - mat4 t1, t2, t3, t4, t5; mat4 m1; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; @@ -86,7 +83,6 @@ TEST_IMPL(GLM_PREFIX, translate_x) { } TEST_IMPL(GLM_PREFIX, translate_y) { - mat4 t1, t2, t3, t4, t5; mat4 m1; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; @@ -112,7 +108,6 @@ TEST_IMPL(GLM_PREFIX, translate_y) { } TEST_IMPL(GLM_PREFIX, translate_z) { - mat4 t1, t2, t3, t4, t5; mat4 m1; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; @@ -138,8 +133,7 @@ TEST_IMPL(GLM_PREFIX, translate_z) { } TEST_IMPL(GLM_PREFIX, translate_make) { - mat4 t1, t2, t3, t4, t5; - mat4 m1, m2; + mat4 m1; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; glm_mat4_identity(m1); @@ -164,7 +158,6 @@ TEST_IMPL(GLM_PREFIX, translate_make) { } TEST_IMPL(GLM_PREFIX, scale_to) { - mat4 t1, t2, t3, t4, t5; mat4 m1, m2; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; @@ -190,7 +183,6 @@ TEST_IMPL(GLM_PREFIX, scale_to) { } TEST_IMPL(GLM_PREFIX, scale_make) { - mat4 t1, t2, t3, t4, t5; mat4 m1; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; @@ -214,7 +206,6 @@ TEST_IMPL(GLM_PREFIX, scale_make) { } TEST_IMPL(GLM_PREFIX, scale) { - mat4 t1, t2, t3, t4, t5; mat4 m1; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; @@ -240,7 +231,6 @@ TEST_IMPL(GLM_PREFIX, scale) { } TEST_IMPL(GLM_PREFIX, scale_uni) { - mat4 t1, t2, t3, t4, t5; mat4 m1; vec4 v1 = {1.0f, 2.0f, 3.0f, 1.0f}, v2; diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 15c81e3..1d93582 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -967,7 +967,7 @@ TEST_IMPL(GLM_PREFIX, quat_rotate_at) { } TEST_IMPL(GLM_PREFIX, quat_rotate_atm) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2; + mat4 m1 = GLM_MAT4_IDENTITY_INIT; versor q1; vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; From 0822d46cd9a133900484558786957b2f438bd82c Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 22 Feb 2020 00:58:04 +0300 Subject: [PATCH 100/103] tests: tests for remaining rotations --- test/src/test_affine.h | 98 ++++++++++++++++++++++++++++++++++++++++++ test/src/test_quat.h | 4 +- test/tests.h | 12 ++++++ 3 files changed, 111 insertions(+), 3 deletions(-) diff --git a/test/src/test_affine.h b/test/src/test_affine.h index 16434fd..0f38c75 100644 --- a/test/src/test_affine.h +++ b/test/src/test_affine.h @@ -383,14 +383,112 @@ TEST_IMPL(GLM_PREFIX, rotate_make) { } TEST_IMPL(GLM_PREFIX, rotate) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2 = GLM_MAT4_IDENTITY_INIT; + vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; + + /* 360 deg */ + glm_rotate(m1, GLM_PI_2f, GLM_YUP); + glm_rotate(m1, GLM_PI_2f, GLM_YUP); + glm_rotate(m1, GLM_PI_2f, GLM_YUP); + glm_rotate(m1, GLM_PI_2f, GLM_YUP); + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + + /* rotate X around Y = -Z */ + GLM(rotate)(m1, GLM_PI_2f, GLM_YUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -1.0f)) + + glm_mat4_identity(m1); + + /* rotate -Z around X = Y */ + GLM(rotate)(m1, GLM_PI_2f, GLM_XUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 1.0f)) + ASSERT(test_eq(v1[2], 0.0f)) + + glm_mat4_identity(m1); + + /* rotate Y around X = +Z */ + GLM(rotate)(m1, GLM_PI_2f, GLM_XUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, rotate_at) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; + + GLM(rotate_at)(m1, (vec3){0.5f, 0.0f, 0.0f}, GLM_PI_2f, GLM_YUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.5f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -0.5f)) + + glm_mat4_identity(m1); + + GLM(rotate_at)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_ZUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.5f)) + ASSERT(test_eq(v1[2], -0.5f)) + + glm_mat4_identity(m1); + + v1[0] = 1.0f; + v1[1] = 1.0f; + v1[2] = 1.0f; + + GLM(rotate_at)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_XUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 1.0f)) + ASSERT(test_eq(v1[1], -1.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, rotate_atm) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; + + GLM(rotate_atm)(m1, (vec3){0.5f, 0.0f, 0.0f}, GLM_PI_2f, GLM_YUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.5f)) + ASSERT(test_eq(v1[1], 0.0f)) + ASSERT(test_eq(v1[2], -0.5f)) + + GLM(rotate_atm)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_ZUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 0.0f)) + ASSERT(test_eq(v1[1], 0.5f)) + ASSERT(test_eq(v1[2], -0.5f)) + + v1[0] = 1.0f; + v1[1] = 1.0f; + v1[2] = 1.0f; + + GLM(rotate_atm)(m1, GLM_VEC3_ZERO, GLM_PI_2f, GLM_XUP); + glm_mat4_mulv(m1, v1, v1); + + ASSERT(test_eq(v1[0], 1.0f)) + ASSERT(test_eq(v1[1], -1.0f)) + ASSERT(test_eq(v1[2], 1.0f)) + TEST_SUCCESS } diff --git a/test/src/test_quat.h b/test/src/test_quat.h index 1d93582..0ef7ca7 100644 --- a/test/src/test_quat.h +++ b/test/src/test_quat.h @@ -925,7 +925,7 @@ TEST_IMPL(GLM_PREFIX, quat_rotate) { } TEST_IMPL(GLM_PREFIX, quat_rotate_at) { - mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2; + mat4 m1 = GLM_MAT4_IDENTITY_INIT; versor q1; vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f}; @@ -938,7 +938,6 @@ TEST_IMPL(GLM_PREFIX, quat_rotate_at) { ASSERT(test_eq(v1[2], -0.5f)) glm_mat4_identity(m1); - glm_mat4_identity(m2); glm_quatv(q1, GLM_PI_2f, GLM_ZUP); GLM(quat_rotate_at)(m1, q1, (vec3){0.0f, 0.0f, 0.0f}); @@ -949,7 +948,6 @@ TEST_IMPL(GLM_PREFIX, quat_rotate_at) { ASSERT(test_eq(v1[2], -0.5f)) glm_mat4_identity(m1); - glm_mat4_identity(m2); v1[0] = 1.0f; v1[1] = 1.0f; diff --git a/test/tests.h b/test/tests.h index 07ec651..263c531 100644 --- a/test/tests.h +++ b/test/tests.h @@ -31,6 +31,9 @@ TEST_DECLARE(glm_rotate_x) TEST_DECLARE(glm_rotate_y) TEST_DECLARE(glm_rotate_z) TEST_DECLARE(glm_rotate_make) +TEST_DECLARE(glm_rotate) +TEST_DECLARE(glm_rotate_at) +TEST_DECLARE(glm_rotate_atm) TEST_DECLARE(glmc_translate) TEST_DECLARE(glmc_translate_to) @@ -46,6 +49,9 @@ TEST_DECLARE(glmc_rotate_x) TEST_DECLARE(glmc_rotate_y) TEST_DECLARE(glmc_rotate_z) TEST_DECLARE(glmc_rotate_make) +TEST_DECLARE(glmc_rotate) +TEST_DECLARE(glmc_rotate_at) +TEST_DECLARE(glmc_rotate_atm) /* mat4 */ TEST_DECLARE(glm_mat4_ucopy) @@ -582,6 +588,9 @@ TEST_LIST { TEST_ENTRY(glm_rotate_y) TEST_ENTRY(glm_rotate_z) TEST_ENTRY(glm_rotate_make) + TEST_ENTRY(glm_rotate) + TEST_ENTRY(glm_rotate_at) + TEST_ENTRY(glm_rotate_atm) TEST_ENTRY(glmc_translate) TEST_ENTRY(glmc_translate_to) @@ -597,6 +606,9 @@ TEST_LIST { TEST_ENTRY(glmc_rotate_y) TEST_ENTRY(glmc_rotate_z) TEST_ENTRY(glmc_rotate_make) + TEST_ENTRY(glmc_rotate) + TEST_ENTRY(glmc_rotate_at) + TEST_ENTRY(glmc_rotate_atm) /* mat4 */ TEST_ENTRY(glm_mat4_ucopy) From 0c8dc070d5f8440e8cfdeed63bbb6a873a96c2b7 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 22 Feb 2020 10:29:16 +0300 Subject: [PATCH 101/103] tests: tests for affine transforms (continue) --- Makefile.am | 1 - test/src/test_affine.c | 114 ------------------------------- test/src/test_affine.h | 125 ++++++++++++++++++++++++++++++++++ test/tests.h | 19 +++++- win/cglm-test.vcxproj | 1 - win/cglm-test.vcxproj.filters | 3 - 6 files changed, 141 insertions(+), 122 deletions(-) delete mode 100644 test/src/test_affine.c diff --git a/Makefile.am b/Makefile.am index bced060..f755b65 100644 --- a/Makefile.am +++ b/Makefile.am @@ -145,7 +145,6 @@ test_tests_SOURCES=\ test/src/test_cam.c \ test/src/test_clamp.c \ test/src/test_euler.c \ - test/src/test_affine.c \ test/src/test_bezier.c \ test/src/test_struct.c diff --git a/test/src/test_affine.c b/test/src/test_affine.c deleted file mode 100644 index 4f51aea..0000000 --- a/test/src/test_affine.c +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright (c), Recep Aslantas. - * - * MIT License (MIT), http://opensource.org/licenses/MIT - * Full license can be found in the LICENSE file - */ - -#include "test_common.h" - -TEST_IMPL(affine) { - mat4 t1, t2, t3, t4, t5; - - /* test translate is postmultiplied */ - glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); - glm_translate_make(t2, (vec3){34, 57, 36}); - - glmc_mat4_mul(t1, t2, t3); /* R * T */ - - glm_translate(t1, (vec3){34, 57, 36}); - ASSERTIFY(test_assert_mat4_eq(t1, t3)) - - /* test rotate is postmultiplied */ - glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); - glm_translate_make(t2, (vec3){34, 57, 36}); - - glmc_mat4_mul(t2, t1, t3); /* T * R */ - - glm_rotate(t2, GLM_PI_4f, GLM_YUP); - ASSERTIFY(test_assert_mat4_eq(t2, t3)) - - /* test scale is postmultiplied */ - glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); - glm_translate_make(t2, (vec3){34, 57, 36}); - glm_scale_make(t4, (vec3){3, 5, 6}); - - glmc_mat4_mul(t2, t1, t3); /* T * R */ - glmc_mat4_mul(t3, t4, t5); /* T * R * S */ - - glm_scale(t3, (vec3){3, 5, 6}); - ASSERTIFY(test_assert_mat4_eq(t3, t5)) - - /* test translate_x */ - glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); - glm_translate_make(t2, (vec3){34, 0, 0}); - - glmc_mat4_mul(t1, t2, t3); /* R * T */ - glm_translate_x(t1, 34); - ASSERTIFY(test_assert_mat4_eq(t1, t3)) - - /* test translate_y */ - glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); - glm_translate_make(t2, (vec3){0, 57, 0}); - - glmc_mat4_mul(t1, t2, t3); /* R * T */ - glm_translate_y(t1, 57); - ASSERTIFY(test_assert_mat4_eq(t1, t3)) - - /* test translate_z */ - glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); - glm_translate_make(t2, (vec3){0, 0, 36}); - - glmc_mat4_mul(t1, t2, t3); /* R * T */ - glm_translate_z(t1, 36); - ASSERTIFY(test_assert_mat4_eq(t1, t3)) - - /* test rotate_x */ - glmc_rotate_make(t1, GLM_PI_4f, (vec3){1, 0, 0}); - glm_translate_make(t2, (vec3){34, 57, 36}); - - glmc_mat4_mul(t2, t1, t3); /* T * R */ - - glm_rotate_x(t2, GLM_PI_4f, t2); - ASSERTIFY(test_assert_mat4_eq(t2, t3)) - - /* test rotate_y */ - glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 1, 0}); - glm_translate_make(t2, (vec3){34, 57, 36}); - - glmc_mat4_mul(t2, t1, t3); /* T * R */ - - glm_rotate_y(t2, GLM_PI_4f, t2); - ASSERTIFY(test_assert_mat4_eq(t2, t3)) - - /* test rotate_z */ - glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1}); - glm_translate_make(t2, (vec3){34, 57, 36}); - - glmc_mat4_mul(t2, t1, t3); /* T * R */ - - glm_rotate_z(t2, GLM_PI_4f, t2); - ASSERTIFY(test_assert_mat4_eq(t2, t3)) - - /* test rotate */ - glmc_rotate_make(t1, GLM_PI_4f, (vec3){0, 0, 1}); - glm_translate_make(t2, (vec3){34, 57, 36}); - - glmc_mat4_mul(t2, t1, t3); /* T * R */ - glmc_rotate(t2, GLM_PI_4f, (vec3){0, 0, 1}); - - ASSERTIFY(test_assert_mat4_eq(t3, t2)) - - /* test scale_uni */ - glmc_rotate_make(t1, GLM_PI_4f, GLM_YUP); - glm_translate_make(t2, (vec3){34, 57, 36}); - glm_scale_make(t4, (vec3){3, 3, 3}); - - glmc_mat4_mul(t2, t1, t3); /* T * R */ - glmc_mat4_mul(t3, t4, t5); /* T * R * S */ - - glm_scale_uni(t3, 3); - ASSERTIFY(test_assert_mat4_eq(t3, t5)) - - TEST_SUCCESS -} diff --git a/test/src/test_affine.h b/test/src/test_affine.h index 0f38c75..0487716 100644 --- a/test/src/test_affine.h +++ b/test/src/test_affine.h @@ -493,17 +493,142 @@ TEST_IMPL(GLM_PREFIX, rotate_atm) { } TEST_IMPL(GLM_PREFIX, decompose_scalev) { + mat4 m1; + vec3 s1; + + GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f}); + GLM(decompose_scalev)(m1, s1); + + ASSERT(test_eq(s1[0], 7.0f)) + ASSERT(test_eq(s1[1], 8.0f)) + ASSERT(test_eq(s1[2], 9.0f)) + + GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f}); + GLM(decompose_scalev)(m1, s1); + + ASSERT(test_eq(s1[0], 49.0f)) + ASSERT(test_eq(s1[1], 64.0f)) + ASSERT(test_eq(s1[2], 81.0f)) + + glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f}); + ASSERT(test_eq(s1[0], 49.0f)) + ASSERT(test_eq(s1[1], 64.0f)) + ASSERT(test_eq(s1[2], 81.0f)) + + glm_translate(m1, (vec3){4.0f, 5.0f, 6.0f}); + ASSERT(test_eq(s1[0], 49.0f)) + ASSERT(test_eq(s1[1], 64.0f)) + ASSERT(test_eq(s1[2], 81.0f)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, uniscaled) { + mat4 m1; + + GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f}); + ASSERT(!GLM(uniscaled)(m1)) + + GLM(scale_make)(m1, (vec3){7.0f, 7.0f, 7.0f}); + ASSERT(GLM(uniscaled)(m1)) + + glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f}); + ASSERT(GLM(uniscaled)(m1)) + + glm_translate(m1, (vec3){4.0f, 5.0f, 6.0f}); + ASSERT(GLM(uniscaled)(m1)) + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, decompose_rs) { + mat4 m1, m2, r; + vec3 s1; + + GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f}); + GLM(decompose_rs)(m1, r, s1); + + ASSERT(test_eq(s1[0], 7.0f)) + ASSERT(test_eq(s1[1], 8.0f)) + ASSERT(test_eq(s1[2], 9.0f)) + ASSERTIFY(test_assert_mat4_eq_identity(r)); + + GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f}); + GLM(decompose_rs)(m1, r, s1); + + ASSERT(test_eq(s1[0], 49.0f)) + ASSERT(test_eq(s1[1], 64.0f)) + ASSERT(test_eq(s1[2], 81.0f)) + ASSERTIFY(test_assert_mat4_eq_identity(r)); + + glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f}); + ASSERT(test_eq(s1[0], 49.0f)) + ASSERT(test_eq(s1[1], 64.0f)) + ASSERT(test_eq(s1[2], 81.0f)) + GLM(decompose_rs)(m1, r, s1); + + glm_mat4_identity(m2); + glm_mat4_mul(m2, r, m2); + glm_scale(m2, s1); + + ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001)); + TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, decompose) { + mat4 m1, m2, r; + vec4 t; + vec3 s; + + GLM(scale_make)(m1, (vec3){7.0f, 8.0f, 9.0f}); + GLM(decompose)(m1, t, r, s); + + ASSERT(test_eq(s[0], 7.0f)) + ASSERT(test_eq(s[1], 8.0f)) + ASSERT(test_eq(s[2], 9.0f)) + ASSERTIFY(test_assert_mat4_eq_identity(r)); + + GLM(scale)(m1, (vec3){7.0f, 8.0f, 9.0f}); + GLM(decompose)(m1, t, r, s); + + ASSERT(test_eq(s[0], 49.0f)) + ASSERT(test_eq(s[1], 64.0f)) + ASSERT(test_eq(s[2], 81.0f)) + ASSERTIFY(test_assert_mat4_eq_identity(r)); + + glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f}); + ASSERT(test_eq(s[0], 49.0f)) + ASSERT(test_eq(s[1], 64.0f)) + ASSERT(test_eq(s[2], 81.0f)) + GLM(decompose)(m1, t, r, s); + + glm_mat4_identity(m2); + glm_mat4_mul(m2, r, m2); + glm_scale(m2, s); + + ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001)); + + glm_mat4_identity(m1); + glm_translate(m1, (vec3){56.0f, 13.0f, 90.0f}); + glm_rotate(m1, GLM_PI_4f, (vec3){23.0f, 45.0f, 66.0f}); + glm_scale(m1, (vec3){12.0f, 34.0f, 23.0f}); + + GLM(decompose)(m1, t, r, s); + + ASSERT(test_eq(t[0], 56.0f)) + ASSERT(test_eq(t[1], 13.0f)) + ASSERT(test_eq(t[2], 90.0f)) + + ASSERT(test_eq(s[0], 12.0f)) + ASSERT(test_eq(s[1], 34.0f)) + ASSERT(test_eq(s[2], 23.0f)) + + glm_mat4_identity(m2); + glm_translate(m2, t); + glm_mat4_mul(m2, r, m2); + glm_scale(m2, s); + ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.00001)); + TEST_SUCCESS } diff --git a/test/tests.h b/test/tests.h index 263c531..37475a8 100644 --- a/test/tests.h +++ b/test/tests.h @@ -34,6 +34,10 @@ TEST_DECLARE(glm_rotate_make) TEST_DECLARE(glm_rotate) TEST_DECLARE(glm_rotate_at) TEST_DECLARE(glm_rotate_atm) +TEST_DECLARE(glm_decompose_scalev) +TEST_DECLARE(glm_uniscaled) +TEST_DECLARE(glm_decompose_rs) +TEST_DECLARE(glm_decompose) TEST_DECLARE(glmc_translate) TEST_DECLARE(glmc_translate_to) @@ -52,6 +56,10 @@ TEST_DECLARE(glmc_rotate_make) TEST_DECLARE(glmc_rotate) TEST_DECLARE(glmc_rotate_at) TEST_DECLARE(glmc_rotate_atm) +TEST_DECLARE(glmc_decompose_scalev) +TEST_DECLARE(glmc_uniscaled) +TEST_DECLARE(glmc_decompose_rs) +TEST_DECLARE(glmc_decompose) /* mat4 */ TEST_DECLARE(glm_mat4_ucopy) @@ -107,8 +115,6 @@ TEST_DECLARE(glmc_mat4_swap_col) TEST_DECLARE(glmc_mat4_swap_row) TEST_DECLARE(glmc_mat4_rmc) -TEST_DECLARE(affine) - /* mat3 */ TEST_DECLARE(glm_mat3_copy) TEST_DECLARE(glm_mat3_identity) @@ -591,6 +597,10 @@ TEST_LIST { TEST_ENTRY(glm_rotate) TEST_ENTRY(glm_rotate_at) TEST_ENTRY(glm_rotate_atm) + TEST_ENTRY(glm_decompose_scalev) + TEST_ENTRY(glm_uniscaled) + TEST_ENTRY(glm_decompose_rs) + TEST_ENTRY(glm_decompose) TEST_ENTRY(glmc_translate) TEST_ENTRY(glmc_translate_to) @@ -609,6 +619,10 @@ TEST_LIST { TEST_ENTRY(glmc_rotate) TEST_ENTRY(glmc_rotate_at) TEST_ENTRY(glmc_rotate_atm) + TEST_ENTRY(glmc_decompose_scalev) + TEST_ENTRY(glmc_uniscaled) + TEST_ENTRY(glmc_decompose_rs) + TEST_ENTRY(glmc_decompose) /* mat4 */ TEST_ENTRY(glm_mat4_ucopy) @@ -664,7 +678,6 @@ TEST_LIST { TEST_ENTRY(glmc_mat4_swap_row) TEST_ENTRY(glmc_mat4_rmc) - TEST_ENTRY(affine) /* mat3 */ TEST_ENTRY(glm_mat3_copy) diff --git a/win/cglm-test.vcxproj b/win/cglm-test.vcxproj index 27a7998..f7ccc91 100644 --- a/win/cglm-test.vcxproj +++ b/win/cglm-test.vcxproj @@ -21,7 +21,6 @@ - diff --git a/win/cglm-test.vcxproj.filters b/win/cglm-test.vcxproj.filters index b84e421..66691ff 100644 --- a/win/cglm-test.vcxproj.filters +++ b/win/cglm-test.vcxproj.filters @@ -14,9 +14,6 @@ src - - src - src From 7b0f62f1ebd8b07145b240a100a656bd91c60376 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sat, 22 Feb 2020 10:54:47 +0300 Subject: [PATCH 102/103] tests: add some tests for affine matrices --- test/src/test_affine_mat.h | 87 ++++++++++++++++++++++++++++++++++++++ test/src/tests.c | 2 + test/tests.h | 18 ++++++++ 3 files changed, 107 insertions(+) create mode 100644 test/src/test_affine_mat.h diff --git a/test/src/test_affine_mat.h b/test/src/test_affine_mat.h new file mode 100644 index 0000000..545839b --- /dev/null +++ b/test/src/test_affine_mat.h @@ -0,0 +1,87 @@ +/* + * Copyright (c), Recep Aslantas. + * + * MIT License (MIT), http://opensource.org/licenses/MIT + * Full license can be found in the LICENSE file + */ + +#include "test_common.h" + +TEST_IMPL(GLM_PREFIX, mul) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + mat4 m4 = GLM_MAT4_ZERO_INIT; + int i, j, k; + + test_rand_mat4(m1); + test_rand_mat4(m2); + + GLM(mul)(m1, m2, m3); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + /* column-major */ + m4[i][j] += m1[k][j] * m2[i][k]; + } + } + + ASSERTIFY(test_assert_mat4_eq(m3, m4)) + + /* test pre compiled */ + GLM(mul)(m1, m2, m3); + ASSERTIFY(test_assert_mat4_eq(m3, m4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, mul_rot) { + mat4 m1 = GLM_MAT4_IDENTITY_INIT; + mat4 m2 = GLM_MAT4_IDENTITY_INIT; + mat4 m3; + mat4 m4 = GLM_MAT4_ZERO_INIT; + int i, j, k; + + glm_rotate(m1, drand48(), (vec3){drand48(), drand48(), drand48()}); + glm_rotate(m2, drand48(), (vec3){drand48(), drand48(), drand48()}); + + GLM(mul)(m1, m2, m3); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) + /* column-major */ + m4[i][j] += m1[k][j] * m2[i][k]; + } + } + + ASSERTIFY(test_assert_mat4_eq(m3, m4)) + + /* test pre compiled */ + GLM(mul)(m1, m2, m3); + ASSERTIFY(test_assert_mat4_eq(m3, m4)) + + TEST_SUCCESS +} + +TEST_IMPL(GLM_PREFIX, inv_tr) { + mat4 m1, m2, m3; + int i; + + for (i = 0; i < 10000; i++) { + test_rand_mat4(m1); + + glm_mat4_copy(m1, m2); + + /* test inverse precise */ + GLM(inv_tr)(m1); + GLM(inv_tr)(m1); + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + + /* test inverse precise */ + GLM(mat4_inv)(m1, m2); + GLM(inv_tr)(m2); + ASSERTIFY(test_assert_mat4_eq(m1, m2)) + } + + TEST_SUCCESS +} diff --git a/test/src/tests.c b/test/src/tests.c index 857dea1..ee7c488 100644 --- a/test/src/tests.c +++ b/test/src/tests.c @@ -20,6 +20,7 @@ #include "test_project.h" #include "test_plane.h" #include "test_affine.h" +#include "test_affine_mat.h" #undef GLM #undef GLM_PREFIX @@ -38,6 +39,7 @@ #include "test_project.h" #include "test_plane.h" #include "test_affine.h" +#include "test_affine_mat.h" #undef GLM #undef GLM_PREFIX diff --git a/test/tests.h b/test/tests.h index 37475a8..e4933e9 100644 --- a/test/tests.h +++ b/test/tests.h @@ -16,6 +16,15 @@ * 2. use TEST_ENTRY() to add test to list */ +/* affine mat */ +TEST_DECLARE(glm_mul) +TEST_DECLARE(glm_mul) +TEST_DECLARE(glm_inv_tr) + +TEST_DECLARE(glmc_mul) +TEST_DECLARE(glmc_mul_rot) +TEST_DECLARE(glmc_inv_tr) + /* affine */ TEST_DECLARE(glm_translate) TEST_DECLARE(glm_translate_to) @@ -579,6 +588,15 @@ TEST_DECLARE(vec4s_zero_init) /*****************************************************************************/ TEST_LIST { + /* affine mat */ + TEST_ENTRY(glm_mul) + TEST_ENTRY(glm_mul) + TEST_ENTRY(glm_inv_tr) + + TEST_ENTRY(glmc_mul) + TEST_ENTRY(glmc_mul_rot) + TEST_ENTRY(glmc_inv_tr) + /* affine */ TEST_ENTRY(glm_translate) TEST_ENTRY(glm_translate_to) From 4a7c153d2d35019373c7849707dcb00a10120589 Mon Sep 17 00:00:00 2001 From: Recep Aslantas Date: Sun, 23 Feb 2020 11:19:30 +0300 Subject: [PATCH 103/103] tests: fix test for mul_rot --- test/src/test_affine_mat.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/src/test_affine_mat.h b/test/src/test_affine_mat.h index 545839b..1c1127f 100644 --- a/test/src/test_affine_mat.h +++ b/test/src/test_affine_mat.h @@ -45,7 +45,7 @@ TEST_IMPL(GLM_PREFIX, mul_rot) { glm_rotate(m1, drand48(), (vec3){drand48(), drand48(), drand48()}); glm_rotate(m2, drand48(), (vec3){drand48(), drand48(), drand48()}); - GLM(mul)(m1, m2, m3); + GLM(mul_rot)(m1, m2, m3); for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { for (k = 0; k < 4; k++) @@ -57,14 +57,14 @@ TEST_IMPL(GLM_PREFIX, mul_rot) { ASSERTIFY(test_assert_mat4_eq(m3, m4)) /* test pre compiled */ - GLM(mul)(m1, m2, m3); + GLM(mul_rot)(m1, m2, m3); ASSERTIFY(test_assert_mat4_eq(m3, m4)) TEST_SUCCESS } TEST_IMPL(GLM_PREFIX, inv_tr) { - mat4 m1, m2, m3; + mat4 m1, m2; int i; for (i = 0; i < 10000; i++) {