add cglm as 3rd-party library

29 files changed, 8779 insertions, 0 deletions

diff --git a/libs/cglm/test/src/test_affine.h b/libs/cglm/test/src/test_affine.h
new file mode 100644
index 0000000..2199a43
--- /dev/null
+++ b/libs/cglm/test/src/test_affine.h
@@ -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.00001f));
+
+  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.00001f));
+
+  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.00001f));
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_affine2d.h b/libs/cglm/test/src/test_affine2d.h
new file mode 100644
index 0000000..8828661
--- /dev/null
+++ b/libs/cglm/test/src/test_affine2d.h
@@ -0,0 +1,310 @@
+/*
+ * 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, translate2d) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d)(m1, (vec2){13.0f, 11.0f});
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 14.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d)(m1, (vec2){1.0f, -1.0f});
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 16.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate2d_to) {
+  mat3 m1, m2;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_to)(m1, (vec2){13.0f, 11.0f}, m2);
+  glm_mat3_mulv(m2, v1, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 14.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_to)(m1, (vec2){1.0f, -1.0f}, m2);
+  glm_mat3_mulv(m2, v2, v2);
+
+  ASSERT(test_eq(v2[0], 16.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate2d_x) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_x)(m1, 13.0f);
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 3.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_x)(m1, -1.0f);
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 3.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate2d_y) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_y)(m1, 11.0f);
+  glm_mat3_mulv(m1, v1, v2);
+  
+
+  ASSERT(test_eq(v2[0], 2.0f))
+  ASSERT(test_eq(v2[1], 14.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_y)(m1, -1.0f);
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 2.0f))
+  ASSERT(test_eq(v2[1], 13.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, translate2d_make) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_make)(m1, (vec2){13.0f, 11.0f});
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 15.0f))
+  ASSERT(test_eq(v2[1], 14.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(translate2d_make)(m1, (vec2){-1.0f, -5.0f});
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], 14.0f))
+  ASSERT(test_eq(v2[1], 9.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale2d_to) {
+  mat3 m1, m2;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(scale2d_to)(m1, (vec2){13.0f, 11.0f}, m2);
+  glm_mat3_mulv(m2, v1, v2);
+
+  ASSERT(test_eq(v2[0], 26.0f))
+  ASSERT(test_eq(v2[1], 33.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(scale2d_to)(m1, (vec2){-1.0f, -5.0f}, m2);
+  glm_mat3_mulv(m2, v2, v2);
+
+  ASSERT(test_eq(v2[0], -26.0f))
+  ASSERT(test_eq(v2[1], -165.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale2d_make) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  GLM(scale2d_make)(m1, (vec2){13.0f, 11.0f});
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 26.0f))
+  ASSERT(test_eq(v2[1], 33.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  GLM(scale2d_make)(m1, (vec3){-1.0f, -5.0f});
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], -26.0f))
+  ASSERT(test_eq(v2[1], -165.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale2d) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(scale2d)(m1, (vec2){13.0f, 11.0f});
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 26.0f))
+  ASSERT(test_eq(v2[1], 33.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(scale2d)(m1, (vec2){-1.0f, -5.0f});
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], -26.0f))
+  ASSERT(test_eq(v2[1], -165.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, scale2d_uni) {
+  mat3 m1;
+  vec3 v1 = {2.0f, 3.0f, 1.0f}, v2;
+
+  glm_mat3_identity(m1);
+  GLM(scale2d_uni)(m1, 13.0f);
+  glm_mat3_mulv(m1, v1, v2);
+
+  ASSERT(test_eq(v2[0], 26.0f))
+  ASSERT(test_eq(v2[1], 39.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+
+  glm_mat3_identity(m1);
+  GLM(scale2d_uni)(m1, -5.0f);
+  glm_mat3_mulv(m1, v2, v2);
+
+  ASSERT(test_eq(v2[0], -130.0f))
+  ASSERT(test_eq(v2[1], -195.0f))
+  ASSERT(test_eq(v2[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate2d_make) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
+
+  GLM(rotate2d_make)(m1, GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+  
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d_make)(m1, -GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d_make)(m1, GLM_PIf);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate2d) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT;
+  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
+
+  GLM(rotate2d)(m1, GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+  
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d)(m1, GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d)(m1, GLM_PI_2f);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 1.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, rotate2d_to) {
+  mat3 m1 = GLM_MAT3_IDENTITY_INIT, m2;
+  vec3 v1 = {0.0f, 1.0f, 1.0f}, v2 = {0.0f, 1.0f, 1.0f};
+
+  GLM(rotate2d_to)(m1, GLM_PI_2f, m1);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], -1.0f))
+  ASSERT(test_eq(v1[1],  0.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+  
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d_to)(m1, GLM_PI_2f, m2);
+  glm_mat3_mulv(m2, v1, v1);
+
+  ASSERT(test_eq(v1[0],  0.0f))
+  ASSERT(test_eq(v1[1], -1.0f))
+  ASSERT(test_eq(v1[2],  1.0f))
+
+  glm_vec3_copy(v2, v1);
+
+  GLM(rotate2d_to)(m2, GLM_PI_2f, m1);
+  glm_mat3_mulv(m1, v1, v1);
+
+  ASSERT(test_eq(v1[0], 1.0f))
+  ASSERT(test_eq(v1[1], 0.0f))
+  ASSERT(test_eq(v1[2], 1.0f))
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_affine_mat.h b/libs/cglm/test/src/test_affine_mat.h
new file mode 100644
index 0000000..e928f8e
--- /dev/null
+++ b/libs/cglm/test/src/test_affine_mat.h
@@ -0,0 +1,112 @@
+/*
+ * 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 glm_affine_mat_test_guard
+#define glm_affine_mat_test_guard
+CGLM_INLINE
+void
+glm_inv_tr_raw(mat4 mat) {
+  CGLM_ALIGN_MAT mat3 r;
+  CGLM_ALIGN(8)  vec3 t;
+
+  /* rotate */
+  glm_mat4_pick3t(mat, r);
+  glm_mat4_ins3(r, mat);
+
+  /* translate */
+  glm_mat3_mulv(r, mat[3], t);
+  glm_vec3_negate(t);
+  glm_vec3_copy(t, mat[3]);
+}
+#endif
+
+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 with raw */
+    glm_mat4_copy(m1, m2);
+    glm_inv_tr_raw(m2);
+    GLM(inv_tr)(m1);
+    ASSERTIFY(test_assert_mat4_eq(m1, m2))
+  }
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_bezier.c b/libs/cglm/test/src/test_bezier.c
new file mode 100644
index 0000000..3089dd5
--- /dev/null
+++ b/libs/cglm/test/src/test_bezier.c
@@ -0,0 +1,66 @@
+/*
+ * 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_bezier_plain(float s, float p0, float c0, float c1, float p1) {
+  float x, xx, xxx, ss, sss;
+
+  x   = 1.0f - s;
+  xx  = x * x;
+  xxx = xx * x;
+  ss  = s * s;
+  sss = ss * s;
+
+  return p0 * xxx + 3.0f * (c0 * s * xx + c1 * ss * x) + p1 * sss;
+}
+
+CGLM_INLINE
+float
+test_hermite_plain(float s, float p0, float t0, float t1, float p1) {
+  float ss, sss;
+
+  ss  = s  * s;
+  sss = ss * s;
+
+  return p0 * (2.0f * sss - 3.0f * ss + 1.0f)
+       + t0 * (sss - 2.0f * ss + s)
+       + p1 * (-2.0f * sss + 3.0f * ss)
+       + t1 * (sss - ss);
+}
+
+TEST_IMPL(bezier) {
+  float s, p0, p1, c0, c1, smc, Bs, Bs_plain;
+
+  s        = test_rand();
+  p0       = test_rand();
+  p1       = test_rand();
+  c0       = test_rand();
+  c1       = test_rand();
+
+  /* test cubic bezier */
+  smc      = glm_smc(s, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1});
+  Bs       = glm_bezier(s, p0, c0, c1, p1);
+  Bs_plain = test_bezier_plain(s, p0, c0, c1, p1);
+
+  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(test_eq(Bs,  Bs_plain));
+  ASSERT(test_eq(smc, Bs_plain));
+  ASSERT(test_eq(Bs,  smc));
+  
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_cam.c b/libs/cglm/test/src/test_cam.c
new file mode 100644
index 0000000..b5fbf2b
--- /dev/null
+++ b/libs/cglm/test/src/test_cam.c
@@ -0,0 +1,55 @@
+/*
+ * 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(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};
+
+  glm_vec3_add(eye, dir, center);
+  glm_lookat(eye, center, up, view1);
+
+  glm_look(eye, dir, up, view2);
+
+  ASSERTIFY(test_assert_mat4_eq(view1, view2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(camera_decomp) {
+  mat4  proj, proj2;
+  vec4  sizes;
+  float aspect, fovy, nearZ, farZ;
+
+  aspect  = 0.782f;
+  fovy    = glm_rad(49.984f);
+  nearZ   = 0.1f;
+  farZ    = 100.0f;
+
+  glm_perspective(fovy, aspect, nearZ, farZ, proj);
+  ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < GLM_FLT_EPSILON)
+  ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < GLM_FLT_EPSILON)
+  ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < GLM_FLT_EPSILON)
+
+  glm_persp_sizes(proj, fovy, sizes);
+
+  glm_frustum(-sizes[0] * 0.5f,
+               sizes[0] * 0.5f,
+              -sizes[1] * 0.5f,
+               sizes[1] * 0.5f,
+               nearZ,
+               farZ,
+               proj2);
+
+  ASSERTIFY(test_assert_mat4_eq(proj, proj2))
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_cam_lh_no.c b/libs/cglm/test/src/test_cam_lh_no.c
new file mode 100644
index 0000000..33a285a
--- /dev/null
+++ b/libs/cglm/test/src/test_cam_lh_no.c
@@ -0,0 +1,36 @@
+/*
+ * 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(perspective_lh_no) {
+  mat4 dst;
+  const float fovy     = glm_rad(45.0f);
+  const float aspect   = 640/480.0f;
+  const float zNearVal = 0.1f;
+  const float zFarVal  = 100.0f;
+
+  glm_perspective_lh_no(fovy, aspect, zNearVal, zFarVal, dst);
+
+  /* Sanity mk. I: longhand version */
+  ASSERT(test_eq(dst[0][0],  1.0f / (tanf(fovy / 2) * aspect)))
+  ASSERT(test_eq(dst[1][1],  1.0f / tanf(fovy / 2)))
+  ASSERT(test_eq(dst[2][2],  (zFarVal + zNearVal) / (zFarVal - zNearVal)))
+  ASSERT(test_eq(dst[2][3],  1.0f))
+  ASSERT(test_eq(dst[3][2], -2 * zFarVal * zNearVal / (zFarVal - zNearVal)))
+
+  /* Sanity mk. II */
+  /*reference test data for glm_perspective_lh_no*/
+  mat4 cmp = {0};
+  cmp[0][0] =  1.8106601f;
+  cmp[1][1] =  2.4142134f;
+  cmp[2][2] =  1.0020020f;
+  cmp[2][3] =  1.0000000f;
+  cmp[3][2] = -0.2002002f;
+
+  return test_assert_mat4_eq(dst, cmp);
+}
diff --git a/libs/cglm/test/src/test_cam_lh_zo.c b/libs/cglm/test/src/test_cam_lh_zo.c
new file mode 100644
index 0000000..f5f50af
--- /dev/null
+++ b/libs/cglm/test/src/test_cam_lh_zo.c
@@ -0,0 +1,36 @@
+/*
+ * 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(perspective_lh_zo) {
+  mat4 dst;
+  const float fovy     = glm_rad(45.0f);
+  const float aspect   = 640/480.0f;
+  const float zNearVal = 0.1f;
+  const float zFarVal  = 100.0f;
+
+  glm_perspective_lh_zo(fovy, aspect, zNearVal, zFarVal, dst);
+
+  /* Sanity mk. I: longhand version */
+  ASSERT(test_eq(dst[0][0],  1.0f / (tanf(fovy / 2) * aspect)))
+  ASSERT(test_eq(dst[1][1],  1.0f / tanf(fovy / 2)))
+  ASSERT(test_eq(dst[2][2],  zFarVal / (zFarVal - zNearVal)))
+  ASSERT(test_eq(dst[2][3],  1.0f))
+  ASSERT(test_eq(dst[3][2], -1 * zFarVal * zNearVal / (zFarVal - zNearVal)))
+
+  /* Sanity mk. II */
+  /* "Reference values" generated by GLM's glm::perspectiveLH_ZO */
+  mat4 cmp = {0};
+  cmp[0][0] =  1.8106601f;
+  cmp[1][1] =  2.4142134f;
+  cmp[2][2] =  1.0010010f;
+  cmp[2][3] =  1.0000000f;
+  cmp[3][2] = -0.1001001f;
+
+  return test_assert_mat4_eq(dst, cmp);
+}
diff --git a/libs/cglm/test/src/test_cam_rh_no.c b/libs/cglm/test/src/test_cam_rh_no.c
new file mode 100644
index 0000000..2bcadcd
--- /dev/null
+++ b/libs/cglm/test/src/test_cam_rh_no.c
@@ -0,0 +1,36 @@
+/*
+ * 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(perspective_rh_no) {
+  mat4 dst;
+  const float fovy     = glm_rad(45.0f);
+  const float aspect   = 640/480.0f;
+  const float zNearVal = 0.1f;
+  const float zFarVal  = 100.0f;
+
+  glm_perspective_rh_no(fovy, aspect, zNearVal, zFarVal, dst);
+
+  /* Sanity mk. I: longhand version */
+  ASSERT(test_eq(dst[0][0],  1.0f / (tanf(fovy / 2) * aspect)))
+  ASSERT(test_eq(dst[1][1],  1.0f / tanf(fovy / 2)))
+  ASSERT(test_eq(dst[2][2], -1.0f * (zFarVal + zNearVal) / (zFarVal - zNearVal)))
+  ASSERT(test_eq(dst[2][3], -1.0f))
+  ASSERT(test_eq(dst[3][2], -2 * zFarVal * zNearVal / (zFarVal - zNearVal)))
+
+  /* Sanity mk. II */
+  /*reference test data for glm_perspective_rh_no*/
+  mat4 cmp = {0};
+  cmp[0][0] =  1.8106601f;
+  cmp[1][1] =  2.4142134f;
+  cmp[2][2] = -1.0020020f;
+  cmp[2][3] = -1.0000000f;
+  cmp[3][2] = -0.2002002f;
+
+  return test_assert_mat4_eq(dst, cmp);
+}
diff --git a/libs/cglm/test/src/test_cam_rh_zo.c b/libs/cglm/test/src/test_cam_rh_zo.c
new file mode 100644
index 0000000..95281a7
--- /dev/null
+++ b/libs/cglm/test/src/test_cam_rh_zo.c
@@ -0,0 +1,36 @@
+/*
+ * 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(perspective_rh_zo) {
+  mat4 dst;
+  const float fovy     = glm_rad(45.0f);
+  const float aspect   = 640/480.0f;
+  const float zNearVal = 0.1f;
+  const float zFarVal  = 100.0f;
+
+  glm_perspective_rh_zo(fovy, aspect, zNearVal, zFarVal, dst);
+
+  /* Sanity mk. I: longhand version */
+  ASSERT(test_eq(dst[0][0],  1 / (tanf(fovy / 2) * aspect)))
+  ASSERT(test_eq(dst[1][1],  1 / tanf(fovy / 2)))
+  ASSERT(test_eq(dst[2][2], zFarVal / (zNearVal - zFarVal)))
+  ASSERT(test_eq(dst[2][3], -1.0f))
+  ASSERT(test_eq(dst[3][2], -1 * zFarVal * zNearVal / (zFarVal - zNearVal)))
+
+  /* Sanity mk. II */
+  /*reference test data for glm_perspective_rh_zo*/
+  mat4 cmp = {0};
+  cmp[0][0] =  1.8106601f;
+  cmp[1][1] =  2.4142134f;
+  cmp[2][2] = -1.0010010f;
+  cmp[2][3] = -1.0000000f;
+  cmp[3][2] = -0.1001001f;
+
+  return test_assert_mat4_eq(dst, cmp);
+}
diff --git a/libs/cglm/test/src/test_camera.h b/libs/cglm/test/src/test_camera.h
new file mode 100644
index 0000000..fb1075a
--- /dev/null
+++ b/libs/cglm/test/src/test_camera.h
@@ -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 "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, frustum) {
+  mat4  proj;
+  vec4  vp = {0.0f, 0.0f, 800.0f, 600.0f};
+  float left, right, top, bottom, znear, zfar;
+  
+  znear  =  0.1f;
+  zfar   =  100.0f;
+  left   = -100.0f;
+  right  =  100.0f;
+  bottom = -100.0f;
+  top    =  100.0f;
+  
+  GLM(frustum)(left, right, bottom, top, znear, zfar, proj);
+  
+  ASSERT(test_eq(proj[0][1], 0.0f))
+  ASSERT(test_eq(proj[0][2], 0.0f))
+  ASSERT(test_eq(proj[0][3], 0.0f))
+
+  ASSERT(test_eq(proj[1][0], 0.0f))
+  ASSERT(test_eq(proj[1][2], 0.0f))
+  ASSERT(test_eq(proj[1][3], 0.0f))
+
+  ASSERT(test_eq(proj[2][3], -1.0f))
+
+  ASSERT(test_eq(proj[3][0], 0.0f))
+  ASSERT(test_eq(proj[3][1], 0.0f))
+  ASSERT(test_eq(proj[3][3], 0.0f))
+
+  vec4  v1 = {1.0f, 20.0f, znear};
+  vec4  v2 = {1.0f, 20.0f, zfar};
+  vec4  v3, v4;
+
+  /* perspective test */
+  GLM(mat4_mulv)(proj, v1, v3);
+  GLM(project)(v3, proj, vp, v3);
+  
+  ASSERT(v3[0] > v1[0])
+  ASSERT(v3[1] > v1[1])
+  
+  GLM(mat4_mulv)(proj, v2, v4);
+  GLM(project)(v4, proj, vp, v4);
+  
+  ASSERT(v4[0] < v3[0])
+  ASSERT(v4[1] < v3[1])
+  
+  /* not infinity */
+  ASSERT(!GLM(vec4_isinf)(proj[0]))
+  ASSERT(!GLM(vec4_isinf)(proj[1]))
+  ASSERT(!GLM(vec4_isinf)(proj[2]))
+  ASSERT(!GLM(vec4_isinf)(proj[3]))
+  
+  /* not NaN */
+  ASSERT(!GLM(vec4_isnan)(proj[0]))
+  ASSERT(!GLM(vec4_isnan)(proj[1]))
+  ASSERT(!GLM(vec4_isnan)(proj[2]))
+  ASSERT(!GLM(vec4_isnan)(proj[3]))
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_clamp.c b/libs/cglm/test/src/test_clamp.c
new file mode 100644
index 0000000..1d1c0c2
--- /dev/null
+++ b/libs/cglm/test/src/test_clamp.c
@@ -0,0 +1,31 @@
+/*
+ * 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(clamp) {
+  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)
+  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(v3[0] == 1.0f)
+  ASSERT(v3[1] == 0.4f)
+  ASSERT(v3[2] == 1.0f)
+
+  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/libs/cglm/test/src/test_common.c b/libs/cglm/test/src/test_common.c
new file mode 100644
index 0000000..46b6e63
--- /dev/null
+++ b/libs/cglm/test/src/test_common.c
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ */
+
+#include "test_common.h"
+#include <time.h>
+
+void
+test_rand_mat4(mat4 dest) {
+  glm_mat4_copy(GLM_MAT4_IDENTITY, dest);
+
+  /* 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()}); */
+}
+
+void
+test_rand_mat3(mat3 dest) {
+  mat4 m4;
+
+  /* random rotatation around random axis with random angle */
+  glm_rotate_make(m4, drand48(), (vec3){drand48(), drand48(), drand48()});
+  glm_mat4_pick3(m4, dest);
+}
+
+void
+test_rand_mat2(mat2 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+}
+
+void
+test_rand_vec3(vec3 dest) {
+  dest[0] = drand48();
+  dest[1] = drand48();
+  dest[2] = drand48();
+}
+
+vec3s
+test_rand_vec3s(void) {
+  vec3s r;
+  test_rand_vec3(r.raw);
+  return r;
+}
+
+void
+test_rand_vec4(vec4 dest) {
+  dest[0] = drand48();
+  dest[1] = drand48();
+  dest[2] = drand48();
+  dest[3] = drand48();
+}
+
+vec4s
+test_rand_vec4s(void) {
+  vec4s r;
+  test_rand_vec4(r.raw);
+  return r;
+}
+
+float
+test_rand(void) {
+  return drand48();
+}
+
+void
+test_rand_quat(versor q) {
+  glm_quat(q, drand48(), drand48(), drand48(), drand48());
+  glm_quat_normalize(q);
+}
+
+test_status_t
+test_assert_mat4_eq(mat4 m1, mat4 m2) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat4_eqt(mat4 m1, mat4 m2) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      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;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eqt(mat2 m1, mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq(mat2 m1, mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq_identity(mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      if (i == j) {
+        ASSERT(test_eq(m2[i][j], 1.0f))
+      } else {
+        ASSERT(test_eq(m2[i][j], 0.0f))
+      }
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq_zero(mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m2[i][j], 0.0f))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat3_eq(mat3 m1, mat3 m2) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat3_eqt(mat3 m1, mat3 m2) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      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(fabsf(a - b) <= 0.000009); /* rounding errors */
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_vec2_eq(vec2 v1, vec2 v2) {
+  ASSERT(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
+  ASSERT(fabsf(v1[1] - v2[1]) <= 0.000009);
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_vec3_eq(vec3 v1, vec3 v2) {
+  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
+}
+
+test_status_t
+test_assert_vec3s_eq(vec3s v1, vec3s v2) {
+  test_assert_vec3_eq(v1.raw, v2.raw);
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_vec4_eq(vec4 v1, vec4 v2) {
+  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_vec4s_eq(vec4s v1, vec4s v2) {
+  test_assert_vec4_eq(v1.raw, v2.raw);
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_quat_eq_abs(versor v1, versor v2) {
+  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
+}
+
+test_status_t
+test_assert_quat_eq(versor v1, versor v2) {
+  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
+}
diff --git a/libs/cglm/test/src/test_common.h b/libs/cglm/test/src/test_common.h
new file mode 100644
index 0000000..9162a8d
--- /dev/null
+++ b/libs/cglm/test/src/test_common.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef test_common_h
+#define test_common_h
+
+#include "../include/common.h"
+
+void
+test_rand_mat4(mat4 dest);
+
+void
+test_rand_mat3(mat3 dest);
+
+void
+test_rand_mat2(mat2 dest);
+
+test_status_t
+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);
+
+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_mat2_eqt(mat2 m1, mat2 m2);
+
+test_status_t
+test_assert_mat2_eq(mat2 m1, mat2 m2);
+
+test_status_t
+test_assert_mat2_eq_identity(mat2 m2);
+
+test_status_t
+test_assert_mat2_eq_zero(mat2 m2);
+
+test_status_t
+test_assert_mat3_eq(mat3 m1, mat3 m2);
+
+test_status_t
+test_assert_vec2_eq(vec2 v1, vec2 v2);
+
+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);
+
+test_status_t
+test_assert_vec3s_eq(vec3s v1, vec3s v2);
+
+test_status_t
+test_assert_vec4_eq(vec4 v1, vec4 v2);
+
+test_status_t
+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);
+
+void
+test_rand_vec3(vec3 dest);
+
+vec3s
+test_rand_vec3s(void);
+
+void
+test_rand_vec4(vec4 dest);
+
+vec4s
+test_rand_vec4s(void);
+
+float
+test_rand(void);
+
+void
+test_rand_quat(versor q);
+
+CGLM_INLINE
+bool
+test_eq(float a, float b) {
+  return fabsf(a - b) <= GLM_FLT_EPSILON * 10;
+}
+
+CGLM_INLINE
+bool
+test_eq_th(float a, float b, float th) {
+  return fabsf(a - b) <= th;
+}
+
+#endif /* test_common_h */
diff --git a/libs/cglm/test/src/test_euler.c b/libs/cglm/test/src/test_euler.c
new file mode 100644
index 0000000..b71e0f0
--- /dev/null
+++ b/libs/cglm/test/src/test_euler.c
@@ -0,0 +1,45 @@
+/*
+ * 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(euler) {
+  mat4 rot1, rot2;
+  vec3 inAngles, outAngles;
+
+  inAngles[0] = glm_rad(-45.0f);  /* X angle */
+  inAngles[1] = glm_rad(88.0f);   /* Y angle */
+  inAngles[2] = glm_rad(18.0f);   /* Z angle */
+
+  glm_euler_xyz(inAngles, rot1);
+
+  /* extract angles */
+  glmc_euler_angles(rot1, outAngles);
+
+  /* angles must be equal in that range */
+  ASSERTIFY(test_assert_vec3_eq(inAngles, outAngles))
+
+  /* matrices must be equal */
+  glmc_euler_xyz(outAngles, rot2);
+  ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
+
+  /* change range */
+  inAngles[0] = glm_rad(-145.0f);  /* X angle */
+  inAngles[1] = glm_rad(818.0f);   /* Y angle */
+  inAngles[2] = glm_rad(181.0f);   /* Z angle */
+
+  glm_euler_xyz(inAngles, rot1);
+  glmc_euler_angles(rot1, outAngles);
+
+  /* angles may not be equal but matrices MUST! */
+
+  /* matrices must be equal */
+  glmc_euler_xyz(outAngles, rot2);
+  ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_ivec2.h b/libs/cglm/test/src/test_ivec2.h
new file mode 100644
index 0000000..5374688
--- /dev/null
+++ b/libs/cglm/test/src/test_ivec2.h
@@ -0,0 +1,189 @@
+/*
+ * 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, ivec2) {
+  ivec4 v4 = {2, 3, 5, 7};
+  ivec3 v3 = {11, 13, 17};
+  ivec2 v2;
+
+  GLM(ivec2)(v4, v2);
+  ASSERT(v2[0] == 2)
+  ASSERT(v2[1] == 3)
+
+  GLM(ivec2)(v3, v2);
+  ASSERT(v2[0] == 11)
+  ASSERT(v2[1] == 13)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_copy) {
+  ivec2 src = {7, 5};
+  ivec2 dst = {99, 99};
+
+  GLM(ivec2_copy)(src, dst);
+  ASSERT(dst[0] == 7)
+  ASSERT(dst[1] == 5)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_zero) {
+  ivec2 v = {2, 3};
+
+  GLM(ivec2_zero)(v);
+  ASSERT(v[0] == 0)
+  ASSERT(v[1] == 0)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_one) {
+  ivec2 v = {-2, 9};
+
+  GLM(ivec2_one)(v);
+  ASSERT(v[0] == 1)
+  ASSERT(v[1] == 1)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_add) {
+  ivec2 a = {14, 3};
+  ivec2 b = {-3, 2};
+  ivec2 v = {99, 99};
+
+  GLM(ivec2_add)(a, b, v);
+  ASSERT(v[0] == 11)
+  ASSERT(v[1] == 5)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_adds) {
+  ivec2 a = {-3, 1};
+  ivec2 v = {99, 99};
+  int s = 2;
+
+  GLM(ivec2_adds)(a, s, v);
+  ASSERT(v[0] == -1)
+  ASSERT(v[1] == 3)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_sub) {
+  ivec2 a = {-2, 9};
+  ivec2 b = {3, 2};
+  ivec2 v = {99, 99};
+
+  GLM(ivec2_sub)(a, b, v);
+  ASSERT(v[0] == -5)
+  ASSERT(v[1] == 7)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_subs) {
+  ivec2 a = {5, -2};
+  ivec2 v = {99, 99};
+  int s = -3;
+
+  GLM(ivec2_subs)(a, s, v);
+  ASSERT(v[0] == 8)
+  ASSERT(v[1] == 1)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_mul) {
+  ivec2 a = {3, 4};
+  ivec2 b = {-2, 3};
+  ivec2 v = {99, 99};
+
+  GLM(ivec2_mul)(a, b, v);
+  ASSERT(v[0] == -6)
+  ASSERT(v[1] == 12)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_scale) {
+  ivec2 a = {-9, 2};
+  ivec2 v = {99, 99};
+  int s = -2;
+
+  GLM(ivec2_scale)(a, s, v);
+  ASSERT(v[0] == 18)
+  ASSERT(v[1] == -4)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_distance2) {
+  ivec2 a = {-1, 3};
+  ivec2 b = {5, 4};
+  int v;
+
+  v = GLM(ivec2_distance2)(a, b);
+  ASSERT(v == 37)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_distance) {
+  ivec2 a = {3, 2};
+  ivec2 b = {-2, 5};
+  float v;
+
+  v = GLM(ivec2_distance)(a, b);
+  ASSERT(test_eq(v, 5.8309518948))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_maxv) {
+  ivec2 a = {9, -20};
+  ivec2 b = {8, -1};
+  ivec2 v = {99, 99};
+
+  GLM(ivec2_maxv)(a, b, v);
+  ASSERT(v[0] == 9)
+  ASSERT(v[1] == -1)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_minv) {
+  ivec2 a = {16, 0};
+  ivec2 b = {-15, 10};
+  ivec2 v = {99, 99};
+
+  GLM(ivec2_minv)(a, b, v);
+  ASSERT(v[0] == -15)
+  ASSERT(v[1] == 0)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec2_clamp) {
+  ivec2 v = {3, -1};
+
+  GLM(ivec2_clamp)(v, -2, 4);
+  ASSERT(v[0] == 3)
+  ASSERT(v[1] == -1)
+
+  v[0] = -15;
+  v[1] = 4;
+  GLM(ivec2_clamp)(v, -9, 3);
+  ASSERT(v[0] == -9)
+  ASSERT(v[1] == 3)
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_ivec3.h b/libs/cglm/test/src/test_ivec3.h
new file mode 100644
index 0000000..dfa8794
--- /dev/null
+++ b/libs/cglm/test/src/test_ivec3.h
@@ -0,0 +1,199 @@
+/*
+ * 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, ivec3) {
+  ivec4 v4 = {2, 3, 5, 7};
+  ivec3 v3 = {99, 99, 99};
+
+  GLM(ivec3)(v4, v3);
+  ASSERT(v3[0] == 2)
+  ASSERT(v3[1] == 3)
+  ASSERT(v3[2] == 5)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_copy) {
+  ivec3 src = {7, 5, 2};
+  ivec3 dst = {99, 99, 99};
+
+  GLM(ivec3_copy)(src, dst);
+  ASSERT(dst[0] == 7)
+  ASSERT(dst[1] == 5)
+  ASSERT(dst[2] == 2)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_zero) {
+  ivec3 v = {2, 3, 5};
+
+  GLM(ivec3_zero)(v);
+  ASSERT(v[0] == 0)
+  ASSERT(v[1] == 0)
+  ASSERT(v[2] == 0)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_one) {
+  ivec3 v = {-2, 9, 12};
+
+  GLM(ivec3_one)(v);
+  ASSERT(v[0] == 1)
+  ASSERT(v[1] == 1)
+  ASSERT(v[2] == 1)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_add) {
+  ivec3 a = {14, 3, 2};
+  ivec3 b = {-3, 2, 1};
+  ivec3 v = {99, 99, 99};
+
+  GLM(ivec3_add)(a, b, v);
+  ASSERT(v[0] == 11)
+  ASSERT(v[1] == 5)
+  ASSERT(v[2] == 3)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_adds) {
+  ivec3 a = {-3, 1, 4};
+  ivec3 v = {99, 99, 99};
+  int s = 2;
+
+  GLM(ivec3_adds)(a, s, v);
+  ASSERT(v[0] == -1)
+  ASSERT(v[1] == 3)
+  ASSERT(v[2] == 6)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_sub) {
+  ivec3 a = {-2, 9, 1};
+  ivec3 b = {3, 2, -1};
+  ivec3 v = {99, 99, 99};
+
+  GLM(ivec3_sub)(a, b, v);
+  ASSERT(v[0] == -5)
+  ASSERT(v[1] == 7)
+  ASSERT(v[2] == 2)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_subs) {
+  ivec3 a = {5, -2, 6};
+  ivec3 v = {99, 99, 99};
+  int s = -3;
+
+  GLM(ivec3_subs)(a, s, v);
+  ASSERT(v[0] == 8)
+  ASSERT(v[1] == 1)
+  ASSERT(v[2] == 9)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_mul) {
+  ivec3 a = {3, 4, 5};
+  ivec3 b = {-2, 3, 1};
+  ivec3 v = {99, 99, 99};
+
+  GLM(ivec3_mul)(a, b, v);
+  ASSERT(v[0] == -6)
+  ASSERT(v[1] == 12)
+  ASSERT(v[2] == 5)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_scale) {
+  ivec3 a = {-9, 2, 3};
+  ivec3 v = {99, 99, 99};
+  int s = -2;
+
+  GLM(ivec3_scale)(a, s, v);
+  ASSERT(v[0] == 18)
+  ASSERT(v[1] == -4)
+  ASSERT(v[2] == -6)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_distance2) {
+  ivec3 a = {-1, 3, 0};
+  ivec3 b = {5, 4, 2};
+  int v;
+
+  v = GLM(ivec3_distance2)(a, b);
+  ASSERT(v == 41)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_distance) {
+  ivec3 a = {3, 2, 4};
+  ivec3 b = {-2, 5, 2};
+  float v;
+
+  v = GLM(ivec3_distance)(a, b);
+  ASSERT(test_eq(v, 6.1644140029))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_maxv) {
+  ivec3 a = {9, -20, 5};
+  ivec3 b = {8, -1, 2};
+  ivec3 v = {99, 99, 99};
+
+  GLM(ivec3_maxv)(a, b, v);
+  ASSERT(v[0] == 9)
+  ASSERT(v[1] == -1)
+  ASSERT(v[2] == 5)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_minv) {
+  ivec3 a = {16, 0, 4};
+  ivec3 b = {-15, 10, 8};
+  ivec3 v = {99, 99, 99};
+
+  GLM(ivec3_minv)(a, b, v);
+  ASSERT(v[0] == -15)
+  ASSERT(v[1] == 0)
+  ASSERT(v[2] == 4)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec3_clamp) {
+  ivec3 v = {3, -1, 10};
+
+  GLM(ivec3_clamp)(v, -2, 4);
+  ASSERT(v[0] == 3)
+  ASSERT(v[1] == -1)
+  ASSERT(v[2] == 4)
+
+  v[0] = -15;
+  v[1] = 4;
+  v[2] = 1;
+  GLM(ivec3_clamp)(v, -9, 3);
+  ASSERT(v[0] == -9)
+  ASSERT(v[1] == 3)
+  ASSERT(v[2] == 1)
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_ivec4.h b/libs/cglm/test/src/test_ivec4.h
new file mode 100644
index 0000000..dd2d606
--- /dev/null
+++ b/libs/cglm/test/src/test_ivec4.h
@@ -0,0 +1,214 @@
+/*
+ * 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, ivec4) {
+  ivec3 v3 = {2, 3, 5};
+  ivec4 v4;
+
+  GLM(ivec4)(v3, 7, v4);
+  ASSERT(test_eq(v4[0], 2))
+  ASSERT(test_eq(v4[1], 3))
+  ASSERT(test_eq(v4[2], 5))
+  ASSERT(test_eq(v4[3], 7))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_copy) {
+  ivec4 src = {7, 5, 2, 11};
+  ivec4 dst = {99, 99, 99, 99};
+
+  GLM(ivec4_copy)(src, dst);
+  ASSERT(dst[0] == 7)
+  ASSERT(dst[1] == 5)
+  ASSERT(dst[2] == 2)
+  ASSERT(dst[3] == 11)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_zero) {
+  ivec4 v = {2, 3, 5, 7};
+
+  GLM(ivec4_zero)(v);
+  ASSERT(v[0] == 0)
+  ASSERT(v[1] == 0)
+  ASSERT(v[2] == 0)
+  ASSERT(v[3] == 0)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_one) {
+  ivec4 v = {-2, 9, 12, 7};
+
+  GLM(ivec4_one)(v);
+  ASSERT(v[0] == 1)
+  ASSERT(v[1] == 1)
+  ASSERT(v[2] == 1)
+  ASSERT(v[3] == 1)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_add) {
+  ivec4 a = {14, 3, 2, -4};
+  ivec4 b = {-3, 2, 1, -1};
+  ivec4 v = {99, 99, 99, 99};
+
+  GLM(ivec4_add)(a, b, v);
+  ASSERT(v[0] == 11)
+  ASSERT(v[1] == 5)
+  ASSERT(v[2] == 3)
+  ASSERT(v[3] == -5)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_adds) {
+  ivec4 a = {-3, 1, 4, 2};
+  ivec4 v = {99, 99, 99, 99};
+  int s = -2;
+
+  GLM(ivec4_adds)(a, s, v);
+  ASSERT(v[0] == -5)
+  ASSERT(v[1] == -1)
+  ASSERT(v[2] == 2)
+  ASSERT(v[3] == 0)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_sub) {
+  ivec4 a = {-2, 9, 1, 5};
+  ivec4 b = {3, 2, -1, 2};
+  ivec4 v = {99, 99, 99, 99};
+
+  GLM(ivec4_sub)(a, b, v);
+  ASSERT(v[0] == -5)
+  ASSERT(v[1] == 7)
+  ASSERT(v[2] == 2)
+  ASSERT(v[3] == 3)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_subs) {
+  ivec4 a = {5, -2, 6, 1};
+  ivec4 v = {99, 99, 99, 99};
+  int s = 2;
+
+  GLM(ivec4_subs)(a, s, v);
+  ASSERT(v[0] == 3)
+  ASSERT(v[1] == -4)
+  ASSERT(v[2] == 4)
+  ASSERT(v[3] == -1)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_mul) {
+  ivec4 a = {3, 4, 5, -3};
+  ivec4 b = {-2, 3, 1, 2};
+  ivec4 v = {99, 99, 99, 99};
+
+  GLM(ivec4_mul)(a, b, v);
+  ASSERT(v[0] == -6)
+  ASSERT(v[1] == 12)
+  ASSERT(v[2] == 5)
+  ASSERT(v[3] == -6)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_scale) {
+  ivec4 a = {-9, 2, 3, 0};
+  ivec4 v = {99, 99, 99, 99};
+  int s = -2;
+
+  GLM(ivec4_scale)(a, s, v);
+  ASSERT(v[0] == 18)
+  ASSERT(v[1] == -4)
+  ASSERT(v[2] == -6)
+  ASSERT(v[3] == 0)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_distance2) {
+  ivec4 a = {-1, 3, 0, 4};
+  ivec4 b = {5, 4, 2, 6};
+  int v;
+
+  v = GLM(ivec4_distance2)(a, b);
+  ASSERT(v == 45)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_distance) {
+  ivec4 a = {3, 2, 4, -1};
+  ivec4 b = {-2, 5, 2, 4};
+  float v;
+
+  v = GLM(ivec4_distance)(a, b);
+  ASSERT(test_eq(v, 7.9372539331))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_maxv) {
+  ivec4 a = {9, -20, 5, -3};
+  ivec4 b = {8, -1, 2, 2};
+  ivec4 v = {99, 99, 99, 99};
+
+  GLM(ivec4_maxv)(a, b, v);
+  ASSERT(v[0] == 9)
+  ASSERT(v[1] == -1)
+  ASSERT(v[2] == 5)
+  ASSERT(v[3] == 2)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_minv) {
+  ivec4 a = {16, 0, 4, 5};
+  ivec4 b = {-15, 10, 8, 2};
+  ivec4 v = {99, 99, 99, 99};
+
+  GLM(ivec4_minv)(a, b, v);
+  ASSERT(v[0] == -15)
+  ASSERT(v[1] == 0)
+  ASSERT(v[2] == 4)
+  ASSERT(v[3] == 2)
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, ivec4_clamp) {
+  ivec4 v = {3, -1, 10, -100};
+
+  GLM(ivec4_clamp)(v, -2, 4);
+  ASSERT(v[0] == 3)
+  ASSERT(v[1] == -1)
+  ASSERT(v[2] == 4)
+  ASSERT(v[3] == -2)
+
+  v[0] = -15;
+  v[1] = 4;
+  v[2] = 1;
+  v[3] = 0;
+  GLM(ivec4_clamp)(v, -9, 3);
+  ASSERT(v[0] == -9)
+  ASSERT(v[1] == 3)
+  ASSERT(v[2] == 1)
+  ASSERT(v[3] == 0)
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_mat2.h b/libs/cglm/test/src/test_mat2.h
new file mode 100644
index 0000000..9141caf
--- /dev/null
+++ b/libs/cglm/test/src/test_mat2.h
@@ -0,0 +1,286 @@
+/*
+ * 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_MATRIX2x2 {{1,2},{5,6}}
+
+#ifndef CGLM_TEST_MAT2_ONCE
+#define CGLM_TEST_MAT2_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT2_IDENTITY_INIT) {
+  mat2 m = GLM_MAT2_IDENTITY_INIT;
+  
+  ASSERT(test_eq(m[0][0], 1.0f))
+  ASSERT(test_eq(m[0][1], 0.0f))
+  ASSERT(test_eq(m[1][0], 0.0f))
+  ASSERT(test_eq(m[1][1], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_ZERO_INIT) {  
+  mat2 m = GLM_MAT2_ZERO_INIT;
+  
+  ASSERT(test_eq(m[0][0], 0.0f))
+  ASSERT(test_eq(m[0][1], 0.0f))
+  ASSERT(test_eq(m[1][0], 0.0f))
+  ASSERT(test_eq(m[1][1], 0.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_IDENTITY) {
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[0][0], 1.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[0][1], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[1][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[1][1], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_ZERO) {
+  ASSERT(test_eq(GLM_MAT2_ZERO[0][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[0][1], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[1][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[1][1], 0.0f))
+
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT2_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat2_copy) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+
+  GLM(mat2_copy)(m1, m2);
+
+  test_assert_mat2_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_identity) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+
+  GLM(mat2_identity)(m3);
+
+  ASSERTIFY(test_assert_mat2_eq_identity(m1))
+  ASSERTIFY(test_assert_mat2_eq_identity(m2))
+  ASSERTIFY(test_assert_mat2_eq_identity(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_identity_array) {
+  int i, count;
+  mat2 matrices[4] = {
+    A_MATRIX2x2,
+    A_MATRIX2x2,
+    A_MATRIX2x2,
+    A_MATRIX2x2
+  };
+
+  count = 4;
+
+  GLM(mat2_identity_array)(matrices, count);
+
+  for (i = 0; i < count; i++) {
+    ASSERTIFY(test_assert_mat2_eq_identity(matrices[i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_zero) {
+  mat2 m1 = GLM_MAT2_ZERO_INIT;
+  mat2 m2 = GLM_MAT2_ZERO_INIT;
+  mat2 m3;
+
+  GLM(mat2_zero)(m3);
+
+  ASSERTIFY(test_assert_mat2_eq_zero(m1))
+  ASSERTIFY(test_assert_mat2_eq_zero(m2))
+  ASSERTIFY(test_assert_mat2_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_mul) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+  mat2 m4 = GLM_MAT2_ZERO_INIT;
+  int  i, j, k;
+
+  /* test random matrices */
+  /* random matrices */
+  test_rand_mat2(m1);
+  test_rand_mat2(m2);
+
+  GLM(mat2_mul)(m1, m2, m3);
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      for (k = 0; k < 2; k++)
+        /* column-major */
+        m4[i][j] += m1[k][j] * m2[i][k];
+    }
+  }
+
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  /* test pre compiled */
+  GLM(mat2_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_transpose_to) {
+  mat2 mat = A_MATRIX2x2;
+  mat2 m1;
+
+  GLM(mat2_transpose_to)(mat, m1);
+
+  ASSERTIFY(test_assert_mat2_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_transpose) {
+  mat2 mat = A_MATRIX2x2;
+  mat2 m1;
+
+  GLM(mat2_copy)(mat, m1);
+  GLM(mat2_transpose)(m1);
+
+  ASSERTIFY(test_assert_mat2_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_mulv) {
+  vec2 res;
+  mat2 mat = A_MATRIX2x2;
+  vec2 v = {11.0f, 21.0f};
+  int  i;
+
+  GLM(mat2_mulv)(mat, v, res);
+
+  for (i = 0; i < 2; i++) {
+    ASSERT(test_eq(res[i], v[0] * mat[0][i] + v[1] * mat[1][i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_trace) {
+  mat2  mat = A_MATRIX2x2;
+  float trace;
+
+  trace = GLM(mat2_trace)(mat);
+
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_scale) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat2_scale)(m1, (float)scale);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_det) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_inv) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+  int  i;
+
+  m1[0][0] = 41.0f;
+  m1[0][1] = 0.0f;
+  m1[1][0] = 0.0f;
+  m1[1][1] = 70.0f;
+
+  for (i = 0; i < 10000; i++) {
+    /* test inverse precise */
+    GLM(mat2_inv)(m1, m2);
+    GLM(mat2_inv)(m2, m3);
+    
+    ASSERTIFY(test_assert_mat2_eq(m1, m3))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_swap_col) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+
+  GLM(mat2_swap_col)(m1, 0, 1);
+
+  ASSERTIFY(test_assert_vec2_eq(m1[0], m2[1]))
+  ASSERTIFY(test_assert_vec2_eq(m1[1], m2[0]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_swap_row) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+
+  GLM(mat2_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[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][0]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_rmc) {
+  mat2  mat = A_MATRIX2x2;
+  vec2  v   = {11.0f, 12.0f};
+  vec2  v1;
+  float r1, r2;
+  int   i;
+
+  r1 = GLM(mat2_rmc)(v, mat, v);
+
+  for (i = 0; i < 2; i++) {
+    v1[i] = v[0] * mat[i][0] + v[1] * mat[i][1];
+  }
+
+  r2 = v[0] * v1[0] + v[1] * v1[1];
+
+  ASSERT(test_eq(r1, r2))
+
+  TEST_SUCCESS
+}
+
+#undef A_MATRIX2x2
diff --git a/libs/cglm/test/src/test_mat3.h b/libs/cglm/test/src/test_mat3.h
new file mode 100644
index 0000000..76b1786
--- /dev/null
+++ b/libs/cglm/test/src/test_mat3.h
@@ -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
diff --git a/libs/cglm/test/src/test_mat4.h b/libs/cglm/test/src/test_mat4.h
new file mode 100644
index 0000000..d42e457
--- /dev/null
+++ b/libs/cglm/test/src/test_mat4.h
@@ -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
diff --git a/libs/cglm/test/src/test_plane.h b/libs/cglm/test/src/test_plane.h
new file mode 100644
index 0000000..896c8b5
--- /dev/null
+++ b/libs/cglm/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/libs/cglm/test/src/test_project.h b/libs/cglm/test/src/test_project.h
new file mode 100644
index 0000000..41bdecd
--- /dev/null
+++ b/libs/cglm/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(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/libs/cglm/test/src/test_quat.h b/libs/cglm/test/src/test_quat.h
new file mode 100644
index 0000000..ab85b19
--- /dev/null
+++ b/libs/cglm/test/src/test_quat.h
@@ -0,0 +1,1086 @@
+/*
+ * 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_from_vecs) {
+  versor q1, q2, q3, q4, q5, q6, q7;
+  vec3   v1 = {1.f, 0.f, 0.f}, v2 = {1.f, 0.f, 0.f};      /* parallel       */
+  vec3   v3 = {0.f, 1.f, 0.f}, v4 = {1.f, 0.f, 0.f};      /* perpendicular  */
+  vec3   v5 = {0.f, 0.f, 1.f}, v6 = {0.f, 0.f, -1.f};     /* straight       */
+  vec3   v7, v8;                                          /* random         */
+  vec3   v9 = {0.57735026f, 0.57735026f, 0.57735026f},    /* acute          */
+         v10 = {0.70710678f, 0.70710678f, 0.f};
+  vec3   v11 = {0.87287156f, 0.21821789f, 0.43643578f},   /* obtuse         */
+         v12 = {-0.87287156f, 0.21821789f, 0.43643578f};
+  vec3   v13 = GLM_VEC3_ZERO_INIT;                        /* zero           */
+
+  GLM(quat_from_vecs)(v1, v2, q1);
+  ASSERTIFY(test_assert_quat_eq_identity(q1))
+
+  GLM(quat_from_vecs)(v3, v4, q2);
+  GLM(quat_rotatev)(q2, v3, v3);
+  ASSERT(test_eq(GLM(vec3_dot)(v3, v4), 1.f))
+  ASSERT(test_eq(q2[0], 0.f))
+  ASSERT(test_eq(q2[1], 0.f))
+  ASSERT(test_eq(q2[2], -0.707106781187f))
+  ASSERT(test_eq(q2[3], 0.707106781187f))
+
+  GLM(quat_from_vecs)(v5, v6, q3);
+  GLM(quat_rotatev)(q3, v5, v5);
+  ASSERT(test_eq(GLM(vec3_dot)(v5, v6), 1.f))
+  ASSERT(test_eq(q3[0], 0.f))
+  ASSERT(test_eq(q3[1], -1.f))
+  ASSERT(test_eq(q3[2], 0.f))
+  ASSERT(test_eq(q3[3], 0.f))
+
+  test_rand_vec3(v7);
+  test_rand_vec3(v8);
+  GLM(vec3_normalize(v7));
+  GLM(vec3_normalize(v8));
+  GLM(quat_from_vecs)(v7, v8, q4);
+  GLM(quat_rotatev)(q4, v7, v7);
+  ASSERT(test_eq(GLM(vec3_dot)(v7, v8), 1.f))
+
+  GLM(quat_from_vecs)(v9, v10, q5);
+  GLM(quat_rotatev)(q5, v9, v9);
+  ASSERT(test_eq(GLM(vec3_dot)(v9, v10), 1.f))
+
+  GLM(quat_from_vecs)(v11, v12, q6);
+  GLM(quat_rotatev)(q6, v11, v11);
+  ASSERT(test_eq(GLM(vec3_dot)(v11, v12), 1.f))
+
+  GLM(quat_from_vecs)(v13, v1, q7);
+  ASSERTIFY(test_assert_quat_eq_identity(q7))
+
+  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
+}
+
+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_imagn)(a, d);
+  GLM(quat_imagn)(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
+}
+
+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_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))
+
+  /* 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_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_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))
+
+  /* 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_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_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))
+
+  /* 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_4f, 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_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))
+
+  /* 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
+}
+
+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(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(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))
+  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(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(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(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(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))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, quat_nlerp) {
+  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);
+
+  GLM(quat_nlerp)(q1, q2, 1.0f, q3);
+  glm_quat_normalize(q2);
+  ASSERTIFY(test_assert_quat_eq(q2, q3));
+
+  glm_quatv(q1, glm_rad(30.001f), v1);
+  glm_quatv(q2, glm_rad(30.002f), v1);
+  GLM(quat_nlerp)(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_nlerp)(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
+}
+
+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.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));
+
+  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
+}
+
+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), 1.0f, 0.0f, 0.0f);
+  GLM(quat_look)(v1, q1, m1);
+  
+  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));
+
+  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
+}
+
+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) {
+  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
+}
+
+TEST_IMPL(GLM_PREFIX, quat_rotate_at) {
+  mat4   m1 = GLM_MAT4_IDENTITY_INIT;
+  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_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);
+
+  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;
+  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/libs/cglm/test/src/test_ray.h b/libs/cglm/test/src/test_ray.h
new file mode 100644
index 0000000..c1b0281
--- /dev/null
+++ b/libs/cglm/test/src/test_ray.h
@@ -0,0 +1,34 @@
+/*
+ * 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, ray_triangle) {
+  /* Check whether a simple hit is recognized with the right distance */
+  vec3  origin    = { 0.0f,  0.0f,  0.0f};
+  vec3  direction = { 1.0f,  0.0f,  0.0f};
+  vec3  opposite  = {-1.0f,  0.0f,  0.0f};
+  vec3  v0        = { 5.0f, -1.0f,  1.0f};
+  vec3  v1        = { 5.0f, -1.0f, -1.0f};
+  vec3  v2        = { 5.0f,  1.0f,  0.0f};
+  float d;
+  bool  hit;
+
+  hit = GLM(ray_triangle)(origin, direction, v0, v1, v2, &d);
+  ASSERT(hit);
+  ASSERT(fabsf(d - 5.0f) <= 0.0000009);
+
+  /* Check whether a simple miss works */
+  hit = GLM(ray_triangle)(origin, opposite, v0, v1, v2, &d);
+  ASSERT(!hit);
+
+  /* Check that we can disregard distance and pass NULL pointer instead */
+  hit = GLM(ray_triangle)(origin, direction, v0, v1, v2, NULL);
+  ASSERT(hit);
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_struct.c b/libs/cglm/test/src/test_struct.c
new file mode 100644
index 0000000..ce79356
--- /dev/null
+++ b/libs/cglm/test/src/test_struct.c
@@ -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
+}
diff --git a/libs/cglm/test/src/test_vec2.h b/libs/cglm/test/src/test_vec2.h
new file mode 100644
index 0000000..9e53f72
--- /dev/null
+++ b/libs/cglm/test/src/test_vec2.h
@@ -0,0 +1,625 @@
+/*
+ * 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
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_complex_mul) {
+  vec2 v1 = { 3.0f,  5.0f },
+       v2 = { 7.0f, 11.0f },
+       v3 = { cosf(M_PI/4.0f), sinf(M_PI/4.0f) };
+
+  GLM(vec2_complex_mul)(v1, v2, v2);
+  ASSERTIFY(test_assert_vec2_eq(v2, (vec2){ -34, 68 }))
+
+  GLM(vec2_complex_mul)(v3, v3, v3);
+  ASSERTIFY(test_assert_vec2_eq(v3, (vec2){ 0.0f, 1.0f }))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_complex_div) {
+  vec2 v1 = { -34.0f,  68.0f },
+       v2 = {   3.0f,   5.0f },
+       v3 = { cosf(M_PI/4.0f),  sinf(M_PI/4.0f) },
+       v4 = { cosf(M_PI/4.0f), -sinf(M_PI/4.0f) };
+  
+  GLM(vec2_complex_div)(v1, v2, v2);
+  ASSERTIFY(test_assert_vec2_eq(v2, (vec2){ 7.0f, 11.0f }))
+
+  GLM(vec2_complex_div)(v3, v4, v4);
+  ASSERTIFY(test_assert_vec2_eq(v4, (vec2){ 0.0f, 1.0f }))
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_vec3.h b/libs/cglm/test/src/test_vec3.h
new file mode 100644
index 0000000..44a9847
--- /dev/null
+++ b/libs/cglm/test/src/test_vec3.h
@@ -0,0 +1,1731 @@
+/*
+ * 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(test_eq(v[0], 1.0f))
+  ASSERT(test_eq(v[1], 1.0f))
+  ASSERT(test_eq(v[2], 1.0f))
+  
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_VEC3_ZERO_INIT) {
+  vec3 v = GLM_VEC3_ZERO_INIT;
+  
+  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(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(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(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(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(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
+}
+
+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))
+  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},
+       v3 = {-13.0f, 12.0f, -11.0f};
+  
+  glm_vec3_flipsign(v1);
+  glmc_vec3_flipsign(v2);
+
+  ASSERTIFY(test_assert_vec3_eq(v1, v3))
+  ASSERTIFY(test_assert_vec3_eq(v2, v3))
+  
+  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, 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},
+       v3 = {-13.0f, 12.0f, -11.0f};
+  
+  glm_vec3_inv(v1);
+  glmc_vec3_inv(v2);
+
+  ASSERTIFY(test_assert_vec3_eq(v1, v3))
+  ASSERTIFY(test_assert_vec3_eq(v2, v3))
+  
+  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, 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
+}
+
+TEST_IMPL(MACRO_glm_vec3_mulv) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3, v4;
+
+  glm_vec3_mulv(v1, v2, v3);
+  glmc_vec3_mulv(v1, v2, v4);
+
+  ASSERTIFY(test_assert_vec3_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]))
+  
+  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(test_eq(v3[0], v4[0]))
+  ASSERT(test_eq(v3[1], v4[1]))
+  ASSERT(test_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(v2, 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(test_eq(dot1, dot2))
+  
+  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;
+  
+  n1 = GLM(vec3_norm2)(a);
+  n2 = a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
+
+  ASSERT(test_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(test_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(test_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 (n2 < fabsf(a[1]))
+    n2 = fabsf(a[1]);
+  
+  if (n2 < fabsf(a[2]))
+    n2 = fabsf(a[2]);
+  
+  ASSERT(test_eq(n1, n2))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_add) {
+  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];
+  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) {
+  vec3  a = {-10.0f, 9.0f, -8.0f};
+  vec3  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) {
+  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];
+  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) {
+  vec3  a = {-10.0f, 9.0f, -8.0f};
+  vec3  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(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
+}
+
+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(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
+}
+
+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(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_div) {
+  vec3 v1 = {2.0f, -3.0f, 4.0f},
+       v2 = {-3.0f, 4.0f, -5.0f},
+       v3;
+  
+  GLM(vec3_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]))
+  
+  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(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
+}
+
+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(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
+}
+
+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(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
+}
+
+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(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
+}
+
+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(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
+}
+
+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(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
+}
+
+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(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
+}
+
+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(test_eq(-v1[0], v3[0]))
+  ASSERT(test_eq(-v1[1], v3[1]))
+  ASSERT(test_eq(-v1[2], v3[2]))
+  
+  ASSERT(test_eq(-v2[0], v4[0]))
+  ASSERT(test_eq(-v2[1], v4[1]))
+  ASSERT(test_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(test_eq(-v1[0], v3[0]))
+  ASSERT(test_eq(-v1[1], v3[1]))
+  ASSERT(test_eq(-v1[2], v3[2]))
+  
+  ASSERT(test_eq(-v2[0], v4[0]))
+  ASSERT(test_eq(-v2[1], v4[1]))
+  ASSERT(test_eq(-v2[2], v4[2]))
+  
+  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(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]))
+
+  glm_vec3_zero(v1);
+  GLM(vec3_normalize)(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
+
+  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(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]))
+
+  glm_vec3_zero(v1);
+  GLM(vec3_normalize_to)(v1, v2);
+  ASSERTIFY(test_assert_vec3_eq(v2, GLM_VEC3_ZERO))
+
+  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]))
+
+  glm_vec3_zero(v1);
+  GLM(vec3_normalize)(v1);
+  ASSERTIFY(test_assert_vec3_eq(v1, GLM_VEC3_ZERO))
+
+  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]))
+
+  glm_vec3_zero(v1);
+  GLM(vec3_normalize_to)(v1, v2);
+  ASSERTIFY(test_assert_vec3_eq(v2, GLM_VEC3_ZERO))
+
+  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_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
+}
+
+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},
+       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_4f))
+
+  a = GLM(vec3_angle)(v1, v3);
+  ASSERT(!isinf(a))
+  ASSERT(!isnan(a))
+  ASSERT(test_eq(a, GLM_PI_2f))
+
+  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_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_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_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_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_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_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_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_2f, 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_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);
+
+  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_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);
+  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_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 * 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_ortho) {
+  vec3  v1, v2, v3, v4 = {1.f, 1.f, 1.f};
+  vec3  v5, v6, v7, v8;
+  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);
+  GLM(vec3_ortho)(v4, v8);
+  
+  a = glm_vec3_angle(v1, v5);
+  ASSERT(!isinf(a))
+  ASSERT(!isnan(a))
+  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_2f))
+  
+  a = glm_vec3_angle(v3, v7);
+  ASSERT(!isinf(a))
+  ASSERT(!isnan(a))
+  ASSERT(test_eq(a, GLM_PI_2f))
+
+  a = glm_vec3_angle(v4, v8);
+  ASSERT(!isinf(a))
+  ASSERT(!isnan(a))
+  ASSERT(test_eq(a, GLM_PI_2f))
+
+  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.0f))
+  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.0f))
+  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_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-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-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)
+  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-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-5f))
+  
+  GLM(vec3_smoothstep)(e3_0, e3_1, v1, v2);
+  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
+}
+
+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.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_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.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.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.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])
+
+  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};
+  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};
+
+  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(test_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(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(test_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(test_eq(r1, r3))
+  ASSERT(test_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(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(v2[0]), v4[0]))
+  ASSERT(test_eq(sqrtf(v2[1]), v4[1]))
+  ASSERT(test_eq(sqrtf(v2[2]), v4[2]))
+
+  TEST_SUCCESS
+}
diff --git a/libs/cglm/test/src/test_vec4.h b/libs/cglm/test/src/test_vec4.h
new file mode 100644
index 0000000..abb882f
--- /dev/null
+++ b/libs/cglm/test/src/test_vec4.h
@@ -0,0 +1,1420 @@
+/*
+ * 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(v2, 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_vec4_eq(v1, GLM_VEC4_ONE))
+  ASSERTIFY(test_assert_vec4_eq(v2, 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) {
+  vec4  a = {10.0f, 9.0f, 8.0f, 78.0f};
+  float n1, n2;
+  
+  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))
+
+  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
+}
+
+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
+}
+
+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-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-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.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)
+  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-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-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-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
+}
+
+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.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.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.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])
+  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.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.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.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])
+  ASSERT(v2[3] >= e3_0[3] && v2[3] <= e3_1[3])
+
+  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;
+
+  /* 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/libs/cglm/test/src/tests.c b/libs/cglm/test/src/tests.c
new file mode 100644
index 0000000..1505e32
--- /dev/null
+++ b/libs/cglm/test/src/tests.c
@@ -0,0 +1,63 @@
+/*
+ * 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_vec2.h"
+#include "test_vec3.h"
+#include "test_vec4.h"
+#include "test_ivec2.h"
+#include "test_ivec3.h"
+#include "test_ivec4.h"
+#include "test_mat2.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_affine2d.h"
+#include "test_affine_mat.h"
+#include "test_ray.h"
+#include "test_camera.h"
+
+#undef GLM
+#undef GLM_PREFIX
+
+/* test pre-compiled  */
+/*---------------------------------------------------------------------------*/
+
+#define GLM_PREFIX glmc_
+#define GLM(X) (glmc_ ## X)
+
+#include "test_vec2.h"
+#include "test_vec3.h"
+#include "test_vec4.h"
+#include "test_ivec2.h"
+#include "test_ivec3.h"
+#include "test_ivec4.h"
+#include "test_mat2.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_affine2d.h"
+#include "test_affine_mat.h"
+#include "test_ray.h"
+#include "test_camera.h"
+
+#undef GLM
+#undef GLM_PREFIX
+
+/*---------------------------------------------------------------------------*/