External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-12-31 04:37:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into vec2_mat2

Browse Source
This commit is contained in:
Recep Aslantas
2020-02-23 13:10:36 +03:00
parent b46a4ccee5 4a7c153d2d
commit 8a068c3291
75 changed files with 8194 additions and 1305 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
test/include/common.h Normal file
View File

@@ -0,0 +1,119 @@
/*
* 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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <cglm/cglm.h>
#include <cglm/struct.h>
#include <cglm/call.h>
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[] =
/* __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};
#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(...) \
EXPAND(TEST_IMPL_ARG3(__VA_ARGS__, TEST_IMPL_ARG2, TEST_IMPL_ARG1))
#define TEST_IMPL(...) EXPAND(TEST_IMPL_CHOOSER(__VA_ARGS__)(__VA_ARGS__))
#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 ASSERTIFY(expr) do { \
test_status_t ts; \
ts = expr; \
if (ts.status != TEST_OK) { \
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);
#if defined(_WIN32)
# 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 */

1
test/lib/cmocka

Submodule test/lib/cmocka deleted from 5f61d2f188

98
test/runner.c Normal file
View File

@@ -0,0 +1,98 @@
/*
* 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 <stdlib.h>
#include <time.h>
#include <string.h>
int
main(int argc, const char * argv[]) {
test_entry_t *entry;
test_status_t st;
int32_t i, count, passed, failed, maxlen;
double start, end, elapsed, total;
passed = failed = maxlen = 0;
total = 0.0;
count = sizeof(tests) / sizeof(tests[0]);
fprintf(stderr, CYAN "\nWelcome to cglm tests\n\n" RESET);
srand((unsigned int)time(NULL));
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,
BOLDRED " " FAIL_TEXT BOLDWHITE " %s " RESET, entry->name);
if (st.msg) {
fprintf(stderr,
YELLOW "- %s" RESET,
st.msg);
}
fprintf(stderr, "\n");
failed++;
} else {
fprintf(stderr, GREEN " " OK_TEXT RESET " %-*s ", maxlen, entry->name);
if (elapsed > 0.01)
fprintf(stderr, YELLOW "%.2fs", elapsed);
else
fprintf(stderr, "0");
fprintf(stderr, "\n" RESET);
passed++;
}
}
if (failed == 0) {
fprintf(stderr,
BOLDGREEN "\n All tests are passed " FINAL_TEXT "\n" RESET);
}
fprintf(stderr,
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",
failed,
failed > 1 ? "are" : "is");
return failed;
}

113
test/src/test_affine.c
View File

@@ -1,113 +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"
void
test_affine(void **state) {
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});
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);
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});
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);
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);
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);
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);
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);
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);
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});
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);
test_assert_mat4_eq(t3, t5);
}

634
test/src/test_affine.h Normal file
View File

@@ -0,0 +1,634 @@
/*
* 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 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 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 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 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 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 m1;
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
}
TEST_IMPL(GLM_PREFIX, scale_to) {
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 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 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 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
}
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
}
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
}
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
}

87
test/src/test_affine_mat.h Normal file
View File

@@ -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_rot)(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_rot)(m1, m2, m3);
ASSERTIFY(test_assert_mat4_eq(m3, m4))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, inv_tr) {
mat4 m1, m2;
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
}

17
test/src/test_bezier.c
View File

@@ -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(test_eq(Bs, Bs_plain));
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});
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(test_eq(Bs, Bs_plain));
ASSERT(test_eq(smc, Bs_plain));
ASSERT(test_eq(Bs, smc));
TEST_SUCCESS
}

37
test/src/test_cam.c
View File

@@ -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);
ASSERTIFY(test_assert_mat4_eq(view1, view2))
TEST_SUCCESS
}
void
test_camera_decomp(void **state) {
TEST_IMPL(camera_decomp) {
mat4 proj, proj2;
vec4 sizes;
float aspect, fovy, nearVal, farVal;
@@ -36,19 +35,21 @@ 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);
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);
test_assert_mat4_eq(proj, proj2);
ASSERTIFY(test_assert_mat4_eq(proj, proj2))
TEST_SUCCESS
}

29
test/src/test_clamp.c
View File

@@ -7,24 +7,25 @@
#include "test_common.h"
void
test_clamp(void **state) {
vec3 v3 = {15.07, 0.4, 17.3};
vec4 v4 = {5.07, 2.3, 1.3, 1.4};
TEST_IMPL(clamp) {
vec3 v3 = {15.07f, 0.4f, 17.3f};
vec4 v4 = {5.07f, 2.3f, 1.3f, 1.4f};
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
}

220
test/src/test_common.c
View File

@@ -4,26 +4,20 @@
*/
#include "test_common.h"
#include <stdlib.h>
#include <math.h>
#define m 4
#define n 4
#include <time.h>
void
test_rand_mat4(mat4 dest) {
glm_mat4_copy(GLM_MAT4_IDENTITY, dest);
srand((unsigned int)time(NULL));
/* random position */
dest[3][0] = drand48();
dest[3][1] = drand48();
dest[3][2] = drand48();
/* random rotatation around random axis with random angle */
glm_rotate(dest, drand48(), (vec3){drand48(), drand48(), drand48()});
/* random scale */
/* glm_scale(dest, (vec3){drand48(), drand48(), drand48()}); */
}
@@ -32,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);
@@ -41,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();
@@ -57,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();
@@ -74,103 +62,221 @@ 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);
}
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_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;
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_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_mat3_eq_identity(mat3 m3) {
int i, j;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
if (i == j) {
ASSERT(test_eq(m3[i][j], 1.0f))
} else {
ASSERT(test_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(test_eq(m3[i][j], 0.0f))
}
}
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(test_eq(m4[i][j], 1.0f))
} else {
ASSERT(test_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(test_eq(m4[i][j], 0.0f))
}
}
TEST_SUCCESS
}
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_vec2_eq(vec2 v1, vec2 v2) {
assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
assert_true(fabsf(v1[1] - v2[1]) <= 0.000009);
ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
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
}
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
}

70
test/src/test_common.h
View File

@@ -8,20 +8,7 @@
#ifndef test_common_h
#define test_common_h
#include <stdarg.h>
#include <stdint.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <time.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>
#include <stdbool.h>
#include <cglm/cglm.h>
#include <cglm/struct.h>
#include <cglm/call.h>
#include "../include/common.h"
void
test_rand_mat4(mat4 dest);
@@ -29,37 +16,58 @@ 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_eqt(mat4 m1, mat4 m2);
test_status_t
test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps);
void
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);
void
test_status_t
test_assert_vec2_eq(vec2 v1, vec2 v2);
void
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);
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_identity(versor q) ;
test_status_t
test_assert_quat_eq_abs(versor v1, versor v2);
void
@@ -80,4 +88,16 @@ test_rand(void);
void
test_rand_quat(versor q);
CGLM_INLINE
bool
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 */

15
test/src/test_euler.c
View File

@@ -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);
ASSERTIFY(test_assert_vec3_eq(inAngles, outAngles))
/* matrices must be equal */
glmc_euler_xyz(outAngles, rot2);
test_assert_mat4_eq(rot1, rot2);
ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
/* 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);
ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
TEST_SUCCESS
}

51
test/src/test_main.c
View File

@@ -1,51 +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),
/* vec2 */
cmocka_unit_test(test_vec2)
};
return cmocka_run_group_tests(tests, NULL, NULL);
}

58
test/src/test_mat3.c
View File

@@ -1,58 +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"
#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 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));
}
}
/* test random matrices */
/* random matrices */
test_rand_mat3(m1);
test_rand_mat3(m2);
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];
}
}
test_assert_mat3_eq(m3, m4);
for (i = 0; i < 100000; i++) {
test_rand_mat3(m3);
test_rand_mat3(m4);
/* test inverse precise */
glmc_mat3_inv(m3, m4);
glmc_mat3_inv(m4, m5);
test_assert_mat3_eq(m3, m5);
}
}

311
test/src/test_mat3.h Normal file
View File

@@ -0,0 +1,311 @@
/*
* 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(test_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(test_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_4f, 1.9f, 2.3f, 4.5f);
GLM(quat_mat3)(q1, m1);
GLM(mat3_quat)(m1, q2);
GLM(rotate_make)(m2, GLM_PI_4f, 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(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))
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, (float)scale);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 3; k++)
ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat3_det) {
mat3 mat;
float a, b, c,
d, e, f,
g, h, i;
float det1, det2;
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(test_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 */
GLM(mat3_inv)(m1, m2);
GLM(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(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(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(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(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(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(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
}
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(test_eq(r1, r2))
TEST_SUCCESS
}
#undef A_MATRIX

94
test/src/test_mat4.c
View File

@@ -1,94 +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"
#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 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));
}
}
/* 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 */
m4[i][j] += m1[k][j] * m2[i][k];
}
}
test_assert_mat4_eq(m3, m4);
/* test pre compiled */
glmc_mat4_mul(m1, m2, m3);
test_assert_mat4_eq(m3, m4);
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);
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);
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);
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);
test_assert_mat4_eq2(m3, m5, 0.0009f);
}
/* print */
glm_mat4_print(m3, stderr);
glm_mat4_print(m4, stderr);
/* test determinant */
assert_int_equal(glm_mat4_det(m1), glmc_mat4_det(m1));
#if defined( __SSE2__ )
assert_int_equal(glmc_mat4_det(m1), glm_mat4_det_sse2(m1));
#endif
}

488
test/src/test_mat4.h Normal file
View File

@@ -0,0 +1,488 @@
/*
* 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(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
}
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(test_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(test_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(test_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(test_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_4f, 1.9f, 2.3f, 4.5f);
GLM(quat_mat4)(q1, m1);
GLM(mat4_quat)(m1, q2);
GLM(rotate_make)(m2, GLM_PI_4f, 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_4f))
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, (float)scale);
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++)
ASSERT(test_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, (float)scale);
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++)
ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, mat4_det) {
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(mat);
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(test_eq(det1, det2))
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;
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
}
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(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
}
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(test_eq(r1, r2))
TEST_SUCCESS
}
#undef A_MATRIX
#undef A_MATRIX3

39
test/src/test_plane.h Normal file
View File

@@ -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
}

31
test/src/test_project.c
View File

@@ -1,31 +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"
void
test_project(void **state) {
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);
glmc_project(pos, mvp, viewport, projected);
glmc_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_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);
}

92
test/src/test_project.h Normal file
View File

@@ -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(test_eq(pos[0], unprojected[0]))
ASSERT(test_eq(pos[1], unprojected[1]))
ASSERT(test_eq(pos[2], unprojected[2]))
TEST_SUCCESS
}

201
test/src/test_quat.c
View File

@@ -1,201 +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"
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];
}
void
test_quat(void **state) {
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_true(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);
/* 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 */
test_assert_quat_eq_abs(inQuat, outQuat);
/* 3. test first rot and second rotation */
test_assert_mat4_eq2(inRot, outRot, 0.000009); /* almost equal */
/* 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);
#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);
test_assert_mat4_eq2(view1, view2, 0.000009);
/* 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);
test_assert_mat4_eq2(rot1, rot2, 0.000009);
/* 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) */
test_assert_mat4_eq2(rot1, rot2, 0.000009);
/* 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);
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);
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);
test_assert_quat_eq(q3, q4);
/* 9. test imag, real */
/* 9.1 real */
assert_true(glm_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_true(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;
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_true(fabsf(v1[0]) <= 0.00009f
&& fabsf(v1[1] - 1.0f) <= 0.00009f
&& fabsf(v1[2]) <= 0.00009f);
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) */
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});
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) */
test_assert_mat4_eq2(rot1, rot2, 0.000009);
/* 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 */
test_assert_mat4_eq2(rot1, GLM_MAT4_IDENTITY, 0.000009);
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);
test_assert_quat_eq(q3, q5);
/* TODO: add tests for slerp, lerp */
}

1001
test/src/test_quat.h Normal file
View File

File diff suppressed because it is too large Load Diff

78
test/src/test_struct.c Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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) {
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
}

113
test/src/test_vec3.c
View File

@@ -1,113 +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"
void
test_vec3(void **state) {
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);
/* test one */
glm_vec3_one(v);
test_assert_vec3_eq(GLM_VEC3_ONE, v);
/* adds, subs, div, divs, mul */
glm_vec3_add(v, GLM_VEC3_ONE, v);
assert_true(glmc_vec3_eq_eps(v, 2));
glm_vec3_adds(v, 10, v);
assert_true(glmc_vec3_eq_eps(v, 12));
glm_vec3_sub(v, GLM_VEC3_ONE, v);
assert_true(glmc_vec3_eq_eps(v, 11));
glm_vec3_subs(v, 1, v);
assert_true(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));
glm_vec3_divs(v, 0.5, v);
assert_true(glmc_vec3_eq_eps(v, 10));
glm_vec3_mul(v, v1, v);
assert_true(glmc_vec3_eq_eps(v, 20));
glm_vec3_scale(v, 0.5, v);
assert_true(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);
/* 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));
glm_vec3_subadd(GLM_VEC3_ONE, GLM_VEC3_ZERO, v);
assert_true(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));
/* 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);
test_assert_vec3_eq(v1, v2);
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);
test_assert_vec3s_eq(vs3, vs4);
/* swizzle */
/* ZYX */
v1[0] = 1;
v1[1] = 2;
v1[2] = 3;
glm_vec3_swizzle(v1, GLM_ZYX, v1);
test_assert_vec3_eq(v1, (vec3){3, 2, 1});
glm_vec3_swizzle(v1, GLM_XXX, v1);
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);
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);
test_assert_vec3_eq(v1, (vec3){3, 3, 3});
}

1726
test/src/test_vec3.h Normal file
View File

File diff suppressed because it is too large Load Diff

231
test/src/test_vec4.c
View File

@@ -1,231 +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"
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];
}
CGLM_INLINE
void
test_vec4_normalize_to(vec4 vec, vec4 dest) {
float norm;
norm = glm_vec4_norm(vec);
if (norm == 0.0f) {
dest[0] = dest[1] = dest[2] = dest[3] = 0.0f;
return;
}
glm_vec4_scale(vec, 1.0f / norm, dest);
}
float
test_vec4_norm2(vec4 vec) {
return test_vec4_dot(vec, vec);
}
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);
}
void
test_vec4(void **state) {
vec4 v, v1, v2, v3, v4;
vec4s vs1, vs2, vs3, vs4;
int i;
float d1, d2;
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_true(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) + 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);
}
/* test zero */
glm_vec4_zero(v);
test_assert_vec4_eq(GLM_VEC4_ZERO, v);
/* test one */
glm_vec4_one(v);
test_assert_vec4_eq(GLM_VEC4_ONE, v);
/* adds, subs, div, divs, mul */
glm_vec4_add(v, GLM_VEC4_ONE, v);
assert_true(glmc_vec4_eq_eps(v, 2));
glm_vec4_adds(v, 10, v);
assert_true(glmc_vec4_eq_eps(v, 12));
glm_vec4_sub(v, GLM_VEC4_ONE, v);
assert_true(glmc_vec4_eq_eps(v, 11));
glm_vec4_subs(v, 1, v);
assert_true(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));
glm_vec4_divs(v, 0.5, v);
assert_true(glmc_vec4_eq_eps(v, 10));
glm_vec4_mul(v, v1, v);
assert_true(glmc_vec4_eq_eps(v, 20));
glm_vec4_scale(v, 0.5, v);
assert_true(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);
/* 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));
glm_vec4_subadd(GLM_VEC4_ONE, GLM_VEC4_ZERO, v);
assert_true(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));
/* min, max */
test_rand_vec4(v1);
test_rand_vec4(v2);
glm_vec4_maxv(v1, v2, v3);
test_vec4_maxv(v1, v2, v4);
test_assert_vec4_eq(v3, v4);
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);
/* clamp */
glm_vec4_clamp(v3, 0.1, 0.8);
test_vec4_clamp(v4, 0.1, 0.8);
test_assert_vec4_eq(v3, v4);
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);
/* swizzle */
/* ZYX */
v1[0] = 1;
v1[1] = 2;
v1[2] = 3;
v1[3] = 4;
glm_vec4_swizzle(v1, GLM_WZYX, v1);
test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1});
glm_vec4_swizzle(v1, GLM_XXXX, v1);
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);
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);
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);
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);
test_assert_vec4s_eq(vs3, vs4);
}

1420
test/src/test_vec4.h Normal file
View File

File diff suppressed because it is too large Load Diff

47
test/src/tests.c Normal file
View File

@@ -0,0 +1,47 @@
/*
* 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"
#include "test_affine.h"
#include "test_affine_mat.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"
#include "test_affine.h"
#include "test_affine_mat.h"
#undef GLM
#undef GLM_PREFIX
/*---------------------------------------------------------------------------*/

1163
test/tests.h Normal file
View File

File diff suppressed because it is too large Load Diff