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

add tests for vec2 and its call version

Browse Source
This commit is contained in:
Recep Aslantas
2020-02-24 10:06:19 +03:00
parent 8a068c3291
commit 43ae3b332a
10 changed files with 771 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
test/src/test_tests.h
View File

@@ -1,50 +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);
/* vec2 */
void
test_vec2(void **state);
#endif /* test_tests_h */

13
test/src/test_vec2.c
View File

@@ -1,13 +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_vec2(void **state) {
}

596
test/src/test_vec2.h Normal file
View File

@@ -0,0 +1,596 @@
/*
* 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_VEC2_ONCE
#define CGLM_TEST_VEC2_ONCE
/* Macros */
TEST_IMPL(MACRO_GLM_VEC2_ONE_INIT) {
vec2 v = GLM_VEC2_ONE_INIT;
ASSERT(test_eq(v[0], 1.0f))
ASSERT(test_eq(v[1], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_VEC2_ZERO_INIT) {
vec2 v = GLM_VEC2_ZERO_INIT;
ASSERT(test_eq(v[0], 0.0f))
ASSERT(test_eq(v[1], 0.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_VEC2_ONE) {
ASSERT(test_eq(GLM_VEC2_ONE[0], 1.0f))
ASSERT(test_eq(GLM_VEC2_ONE[1], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_VEC2_ZERO) {
ASSERT(test_eq(GLM_VEC2_ZERO[0], 0.0f))
ASSERT(test_eq(GLM_VEC2_ZERO[0], 0.0f))
TEST_SUCCESS
}
#endif /* CGLM_TEST_VEC2_ONCE */
TEST_IMPL(GLM_PREFIX, vec2) {
vec4 v4 = {10.0f, 9.0f, 8.0f, 7.0f};
vec3 v3 = {11.0f, 12.0f, 13.0f};
vec2 v2;
GLM(vec2)(v4, v2);
ASSERT(test_eq(v2[0], v4[0]))
ASSERT(test_eq(v2[1], v4[1]))
GLM(vec2)(v3, v2);
ASSERT(test_eq(v2[0], v3[0]))
ASSERT(test_eq(v2[1], v3[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_copy) {
vec2 v1 = {10.0f, 9.0f};
vec2 v2 = {1.0f, 2.0f};
GLM(vec2_copy)(v1, v2);
ASSERTIFY(test_assert_vec2_eq(v1, v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_zero) {
vec2 v1 = {10.0f, 9.0f};
vec2 v2 = {1.0f, 2.0f};
GLM(vec2_zero)(v1);
GLM(vec2_zero)(v2);
ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ZERO))
ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ZERO))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_one) {
vec2 v1 = {10.0f, 9.0f};
vec2 v2 = {1.0f, 2.0f};
GLM(vec2_one)(v1);
GLM(vec2_one)(v2);
ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ONE))
ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ONE))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_dot) {
vec2 a = {10.0f, 9.0f};
vec2 b = {1.0f, 2.0f};
float dot1, dot2;
dot1 = GLM(vec2_dot)(a, b);
dot2 = a[0] * b[0] + a[1] * b[1];
ASSERT(test_eq(dot1, dot2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_cross) {
vec2 a = {10.0f, 9.0f};
vec2 b = {1.0f, 2.0f};
float cprod;
cprod = a[0] * b[1] - a[1] * b[0];
ASSERT(test_eq(glm_vec2_cross(a, b), cprod))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_norm2) {
vec2 a = {10.0f, 9.0f};
float n1, n2;
n1 = GLM(vec2_norm2)(a);
n2 = a[0] * a[0] + a[1] * a[1];
ASSERT(test_eq(n1, n2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_norm) {
vec2 a = {10.0f, 9.0f};
float n1, n2;
n1 = GLM(vec2_norm)(a);
n2 = sqrtf(a[0] * a[0] + a[1] * a[1]);
ASSERT(test_eq(n1, n2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_add) {
vec2 a = {-10.0f, 9.0f};
vec2 b = {12.0f, 19.0f};
vec2 c, d;
c[0] = a[0] + b[0];
c[1] = a[1] + b[1];
GLM(vec2_add)(a, b, d);
ASSERTIFY(test_assert_vec2_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_adds) {
vec4 a = {-10.0f, 9.0f};
vec4 c, d;
float s = 7.0f;
c[0] = a[0] + s;
c[1] = a[1] + s;
GLM(vec2_adds)(a, s, d);
ASSERTIFY(test_assert_vec2_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_sub) {
vec2 a = {-10.0f, 9.0f};
vec2 b = {12.0f, 19.0f};
vec2 c, d;
c[0] = a[0] - b[0];
c[1] = a[1] - b[1];
GLM(vec2_sub)(a, b, d);
ASSERTIFY(test_assert_vec2_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_subs) {
vec2 a = {-10.0f, 9.0f};
vec2 c, d;
float s = 7.0f;
c[0] = a[0] - s;
c[1] = a[1] - s;
GLM(vec2_subs)(a, s, d);
ASSERTIFY(test_assert_vec2_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_mul) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3;
GLM(vec2_mul)(v1, v2, v3);
ASSERT(test_eq(v1[0] * v2[0], v3[0]))
ASSERT(test_eq(v1[1] * v2[1], v3[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_scale) {
vec2 v1 = {2.0f, -3.0f}, v2;
float s = 7.0f;
GLM(vec2_scale)(v1, s, v2);
ASSERT(test_eq(v1[0] * s, v2[0]))
ASSERT(test_eq(v1[1] * s, v2[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_scale_as) {
vec2 v1 = {2.0f, -3.0f}, v2;
float s = 7.0f;
float norm;
GLM(vec2_scale_as)(v1, s, v2);
norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
if (norm == 0.0f) {
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
TEST_SUCCESS
}
norm = s / norm;
ASSERT(test_eq(v1[0] * norm, v2[0]))
ASSERT(test_eq(v1[1] * norm, v2[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_div) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3;
GLM(vec2_div)(v1, v2, v3);
ASSERT(test_eq(v1[0] / v2[0], v3[0]))
ASSERT(test_eq(v1[1] / v2[1], v3[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_divs) {
vec2 v1 = {2.0f, -3.0f}, v2;
float s = 7.0f;
GLM(vec2_divs)(v1, s, v2);
ASSERT(test_eq(v1[0] / s, v2[0]))
ASSERT(test_eq(v1[1] / s, v2[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_addadd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_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]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_subadd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_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]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_muladd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_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]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_muladds) {
vec2 v1 = {2.0f, -3.0f},
v2 = {1.0f, 2.0f},
v3 = {1.0f, 2.0f};
float s = 9.0f;
GLM(vec2_muladds)(v1, s, v3);
ASSERT(test_eq(v2[0] + v1[0] * s, v3[0]))
ASSERT(test_eq(v2[1] + v1[1] * s, v3[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_maxadd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_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]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_minadd) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {1.0f, 2.0f},
v4 = {1.0f, 2.0f};
GLM(vec2_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]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_negate_to) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3, v4;
GLM(vec2_negate_to)(v1, v3);
GLM(vec2_negate_to)(v2, v4);
ASSERT(test_eq(-v1[0], v3[0]))
ASSERT(test_eq(-v1[1], v3[1]))
ASSERT(test_eq(-v2[0], v4[0]))
ASSERT(test_eq(-v2[1], v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_negate) {
vec2 v1 = {2.0f, -3.0f},
v2 = {-3.0f, 4.0f},
v3 = {2.0f, -3.0f},
v4 = {-3.0f, 4.0f};
GLM(vec2_negate)(v1);
GLM(vec2_negate)(v2);
ASSERT(test_eq(-v1[0], v3[0]))
ASSERT(test_eq(-v1[1], v3[1]))
ASSERT(test_eq(-v2[0], v4[0]))
ASSERT(test_eq(-v2[1], v4[1]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_normalize) {
vec2 v1 = {2.0f, -3.0f}, v2 = {2.0f, -3.0f};
float s = 1.0f;
float norm;
GLM(vec2_normalize)(v2);
norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
if (norm == 0.0f) {
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
TEST_SUCCESS
}
norm = s / norm;
ASSERT(test_eq(v1[0] * norm, v2[0]))
ASSERT(test_eq(v1[1] * norm, v2[1]))
glm_vec2_zero(v1);
GLM(vec2_normalize)(v1);
ASSERTIFY(test_assert_vec2_eq(v1, GLM_VEC2_ZERO))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_normalize_to) {
vec2 v1 = {2.0f, -3.0f}, v2;
float s = 1.0f;
float norm;
GLM(vec2_normalize_to)(v1, v2);
norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1]);
if (norm == 0.0f) {
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
TEST_SUCCESS
}
norm = s / norm;
ASSERT(test_eq(v1[0] * norm, v2[0]))
ASSERT(test_eq(v1[1] * norm, v2[1]))
glm_vec2_zero(v1);
GLM(vec2_normalize_to)(v1, v2);
ASSERTIFY(test_assert_vec2_eq(v2, GLM_VEC2_ZERO))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_rotate) {
vec2 v1 = {1.0f, 0.0f};
GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 1.0f))
GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
ASSERT(test_eq(v1[0], -1.0f))
ASSERT(test_eq(v1[1], 0.0f))
GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], -1.0f))
GLM(vec2_rotate)(v1, GLM_PI_2f, v1);
ASSERT(test_eq(v1[0], 1.0f))
ASSERT(test_eq(v1[1], 0.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_distance2) {
vec2 v1 = {30.0f, 0.0f},
v2 = {0.0f, 0.0f},
v3 = {3.0f, 10.0f},
v4 = {0.46f, 4.0f};
float d;
d = GLM(vec2_distance2)(v1, v2);
ASSERT(test_eq(d, 30.0f * 30.0f))
d = GLM(vec2_distance2)(v3, v4);
ASSERT(test_eq(powf(v3[0] - v4[0], 2.0f)
+ powf(v3[1] - v4[1], 2.0f), d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_distance) {
vec2 v1 = {30.0f, 0.0f},
v2 = {0.0f, 0.0f},
v3 = {3.0f, 10.0f},
v4 = {0.46f, 4.0f};
float d;
d = GLM(vec2_distance)(v1, v2);
ASSERT(test_eq(d, 30.0f))
d = GLM(vec2_distance)(v3, v4);
ASSERT(test_eq(sqrtf(powf(v3[0] - v4[0], 2.0f)
+ powf(v3[1] - v4[1], 2.0f)), d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_maxv) {
vec2 v1, v2, v3;
vec2 v5 = {-1.456f, -1.456f};
vec2 v6 = {11.0f, 11.0f};
vec2 v7 = {78.0f, -78.0f};
GLM(vec2_maxv)(v5, v6, v1);
GLM(vec2_maxv)(v5, v7, v2);
GLM(vec2_maxv)(v6, v7, v3);
ASSERT(test_eq(v1[0], 11.0f))
ASSERT(test_eq(v1[1], 11.0f))
ASSERT(test_eq(v2[0], 78.0f))
ASSERT(test_eq(v2[1], -1.456f))
ASSERT(test_eq(v3[0], 78.0f))
ASSERT(test_eq(v3[1], 11.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_minv) {
vec2 v1, v2, v3;
vec2 v5 = {-1.456f, -1.456f};
vec2 v6 = {11.0f, 11.0f};
vec2 v7 = {78.0f, -78.0f};
GLM(vec2_minv)(v5, v6, v1);
GLM(vec2_minv)(v5, v7, v2);
GLM(vec2_minv)(v6, v7, v3);
ASSERT(test_eq(v1[0], -1.456f))
ASSERT(test_eq(v1[1], -1.456f))
ASSERT(test_eq(v2[0], -1.456f))
ASSERT(test_eq(v2[1], -78.0f))
ASSERT(test_eq(v3[0], 11.0f))
ASSERT(test_eq(v3[1], -78.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_clamp) {
vec2 v1 = {-1.456f, -11.456f};
vec2 v2 = {0.110f, 111.0f};
vec2 v3 = {78.0f, 32.0f};
GLM(vec2_clamp)(v1, -1.03f, 30.0f);
GLM(vec2_clamp)(v2, 0.11f, 111.0f);
GLM(vec2_clamp)(v3, -88.0f, 70.0f);
ASSERT(test_eq(v1[0], -1.03f))
ASSERT(test_eq(v1[1], -1.03f))
ASSERT(test_eq(v2[0], 0.11f))
ASSERT(test_eq(v2[1], 111.0f))
ASSERT(test_eq(v3[0], 70.0f))
ASSERT(test_eq(v3[1], 32.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, vec2_lerp) {
vec2 v1 = {-100.0f, -200.0f};
vec2 v2 = {100.0f, 200.0f};
vec2 v3;
GLM(vec2_lerp)(v1, v2, 0.5f, v3);
ASSERT(test_eq(v3[0], 0.0f))
ASSERT(test_eq(v3[1], 0.0f))
GLM(vec2_lerp)(v1, v2, 0.75f, v3);
ASSERT(test_eq(v3[0], 50.0f))
ASSERT(test_eq(v3[1], 100.0f))
TEST_SUCCESS
}

23
test/src/test_vec3.h
View File

@@ -233,7 +233,7 @@ TEST_IMPL(GLM_PREFIX, vec3_zero) {
GLM(vec3_zero)(v2);
ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
ASSERTIFY(test_assert_vec3_eq(v2, GLM_VEC3_ZERO))
TEST_SUCCESS
}
@@ -335,9 +335,9 @@ TEST_IMPL(GLM_PREFIX, vec3_norm_inf) {
}
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;
vec3 a = {-10.0f, 9.0f, -8.0f};
vec3 b = {12.0f, 19.0f, -18.0f};
vec3 c, d;
c[0] = a[0] + b[0];
c[1] = a[1] + b[1];
@@ -351,8 +351,8 @@ TEST_IMPL(GLM_PREFIX, vec3_add) {
}
TEST_IMPL(GLM_PREFIX, vec3_adds) {
vec4 a = {-10.0f, 9.0f, -8.0f};
vec4 c, d;
vec3 a = {-10.0f, 9.0f, -8.0f};
vec3 c, d;
float s = 7.0f;
c[0] = a[0] + s;
@@ -367,9 +367,9 @@ TEST_IMPL(GLM_PREFIX, vec3_adds) {
}
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;
vec3 a = {-10.0f, 9.0f, -8.0f};
vec3 b = {12.0f, 19.0f, -18.0f};
vec3 c, d;
c[0] = a[0] - b[0];
c[1] = a[1] - b[1];
@@ -383,8 +383,8 @@ TEST_IMPL(GLM_PREFIX, vec3_sub) {
}
TEST_IMPL(GLM_PREFIX, vec3_subs) {
vec4 a = {-10.0f, 9.0f, -8.0f};
vec4 c, d;
vec3 a = {-10.0f, 9.0f, -8.0f};
vec3 c, d;
float s = 7.0f;
c[0] = a[0] - s;
@@ -928,7 +928,6 @@ TEST_IMPL(GLM_PREFIX, vec3_rotate_m4) {
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;

4
test/src/test_vec4.h
View File

@@ -217,7 +217,7 @@ TEST_IMPL(GLM_PREFIX, vec4_zero) {
GLM(vec4_zero)(v2);
ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO))
ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ZERO))
ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ZERO))
TEST_SUCCESS
}
@@ -230,7 +230,7 @@ TEST_IMPL(GLM_PREFIX, vec4_one) {
GLM(vec4_one)(v2);
ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE))
ASSERTIFY(test_assert_vec4_eq(v1, GLM_VEC4_ONE))
ASSERTIFY(test_assert_vec4_eq(v2, GLM_VEC4_ONE))
TEST_SUCCESS
}

2
test/src/tests.c
View File

@@ -12,6 +12,7 @@
#define GLM_PREFIX glm_
#define GLM(X) (glm_ ## X)
#include "test_vec2.h"
#include "test_vec3.h"
#include "test_vec4.h"
#include "test_mat3.h"
@@ -31,6 +32,7 @@
#define GLM_PREFIX glmc_
#define GLM(X) (glmc_ ## X)
#include "test_vec2.h"
#include "test_vec3.h"
#include "test_vec4.h"
#include "test_mat3.h"