Merge branch 'master' into vec2_mat2

test/src/test_bezier.c

@@ -51,8 +51,8 @@ test_bezier(void **state) {
   Bs_plain = test_bezier_plain(s, p0, c0, c1, p1);
 
   assert_true(glm_eq(Bs,  Bs_plain));
-  assert_true(glm_eq(smc, Bs_plain));
-  assert_true(glm_eq(Bs,  smc));
+  test_assert_eqf(smc, Bs_plain);
+  test_assert_eqf(Bs,  smc);
 
   /* test cubic hermite */
   smc      = glm_smc(s, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1});

test/src/test_common.c

@@ -5,6 +5,7 @@
 
 #include "test_common.h"
 #include <stdlib.h>
+#include <math.h>
 
 #define m 4
 #define n 4
@@ -47,6 +48,13 @@ test_rand_vec3(vec3 dest) {
   dest[2] = drand48();
 }
 
+vec3s
+test_rand_vec3s() {
+  vec3s r;
+  test_rand_vec3(r.raw);
+  return r;
+}
+
 void
 test_rand_vec4(vec4 dest) {
   srand((unsigned int)time(NULL));
@@ -57,6 +65,13 @@ test_rand_vec4(vec4 dest) {
   dest[3] = drand48();
 }
 
+vec4s
+test_rand_vec4s() {
+  vec4s r;
+  test_rand_vec4(r.raw);
+  return r;
+}
+
 float
 test_rand(void) {
   srand((unsigned int)time(NULL));
@@ -125,6 +140,11 @@ test_assert_vec3_eq(vec3 v1, vec3 v2) {
   assert_true(fabsf(v1[2] - v2[2]) <= 0.000009);
 }
 
+void
+test_assert_vec3s_eq(vec3s v1, vec3s v2) {
+  test_assert_vec3_eq(v1.raw, v2.raw);
+}
+
 void
 test_assert_vec4_eq(vec4 v1, vec4 v2) {
   assert_true(fabsf(v1[0] - v2[0]) <= 0.000009); /* rounding errors */
@@ -133,6 +153,11 @@ test_assert_vec4_eq(vec4 v1, vec4 v2) {
   assert_true(fabsf(v1[3] - v2[3]) <= 0.000009);
 }
 
+void
+test_assert_vec4s_eq(vec4s v1, vec4s v2) {
+  test_assert_vec4_eq(v1.raw, v2.raw);
+}
+
 void
 test_assert_quat_eq_abs(versor v1, versor v2) {
   assert_true(fabsf(fabsf(v1[0]) - fabsf(v2[0])) <= 0.0009); /* rounding errors */

test/src/test_common.h

@@ -20,6 +20,7 @@
 #include <stdbool.h>
 
 #include <cglm/cglm.h>
+#include <cglm/struct.h>
 #include <cglm/call.h>
 
 void
@@ -46,9 +47,15 @@ test_assert_vec2_eq(vec2 v1, vec2 v2);
 void
 test_assert_vec3_eq(vec3 v1, vec3 v2);
 
+void
+test_assert_vec3s_eq(vec3s v1, vec3s v2);
+
 void
 test_assert_vec4_eq(vec4 v1, vec4 v2);
 
+void
+test_assert_vec4s_eq(vec4s v1, vec4s v2);
+
 void
 test_assert_quat_eq(versor v1, versor v2);
 
@@ -58,8 +65,14 @@ 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) ;
+test_rand_vec4(vec4 dest);
+
+vec4s
+test_rand_vec4s(void);
 
 float
 test_rand(void);

test/src/test_quat.c

@@ -44,9 +44,11 @@ test_quat(void **state) {
     test_assert_mat4_eq2(inRot, outRot, 0.000009); /* almost equal */
 
     /* 4. test SSE mul and raw mul */
+#if defined( __SSE__ ) || defined( __SSE2__ )
     test_quat_mul_raw(inQuat, outQuat, q3);
     glm_quat_mul_sse2(inQuat, outQuat, q4);
     test_assert_quat_eq(q3, q4);
+#endif
   }
 
   /* 5. test lookat */

test/src/test_vec3.c

@@ -12,6 +12,7 @@ test_vec3(void **state) {
   mat3 rot1m3;
   mat4 rot1;
   vec3 v, v1, v2;
+  vec3s vs1, vs2, vs3, vs4;
 
   /* test zero */
   glm_vec3_zero(v);
@@ -75,4 +76,38 @@ test_vec3(void **state) {
 
   test_assert_vec3_eq(v1, v2);
   test_assert_vec3_eq(v1, GLM_ZUP);
+
+  /* structs */
+  vs1 = test_rand_vec3s();
+  vs2 = test_rand_vec3s();
+
+  vs3 = glms_vec3_add(vs1, vs2);
+  vs4 = glms_vec3_maxv(vs1, vs3);
+  test_assert_vec3s_eq(vs3, vs4);
+
+  /* swizzle */
+
+  /* ZYX */
+  v1[0] = 1;
+  v1[1] = 2;
+  v1[2] = 3;
+  glm_vec3_swizzle(v1, GLM_ZYX, v1);
+  test_assert_vec3_eq(v1, (vec3){3, 2, 1});
+
+  glm_vec3_swizzle(v1, GLM_XXX, v1);
+  test_assert_vec3_eq(v1, (vec3){3, 3, 3});
+
+  v1[0] = 1;
+  v1[1] = 2;
+  v1[2] = 3;
+
+  glm_vec3_swizzle(v1, GLM_YYY, v1);
+  test_assert_vec3_eq(v1, (vec3){2, 2, 2});
+
+  v1[0] = 1;
+  v1[1] = 2;
+  v1[2] = 3;
+
+  glm_vec3_swizzle(v1, GLM_ZZZ, v1);
+  test_assert_vec3_eq(v1, (vec3){3, 3, 3});
 }

test/src/test_vec4.c

@@ -65,10 +65,10 @@ test_vec4_clamp(vec4 v, float minVal, float maxVal) {
 void
 test_vec4(void **state) {
   vec4  v, v1, v2, v3, v4;
+  vec4s vs1, vs2, vs3, vs4;
   int   i;
   float d1, d2;
 
-
   for (i = 0; i < 1000; i++) {
     /* 1. test SSE/SIMD dot product */
     test_rand_vec4(v);
@@ -93,6 +93,13 @@ test_vec4(void **state) {
     /* 3. test SIMD norm2 */
     test_rand_vec4(v);
     test_assert_eqf(test_vec4_norm2(v), glm_vec4_norm2(v));
+
+    /* 4. test SSE/SIMD distance */
+    test_rand_vec4(v1);
+    test_rand_vec4(v2);
+    d1 = glm_vec4_distance(v1, v2);
+    d2 = sqrtf(powf(v1[0]-v2[0], 2.0f) + pow(v1[1]-v2[1], 2.0f) + pow(v1[2]-v2[2], 2.0f) + pow(v1[3]-v2[3], 2.0f));
+    assert_true(fabsf(d1 - d2) <= 0.000009);
   }
 
   /* test zero */
@@ -175,4 +182,50 @@ test_vec4(void **state) {
   assert_true(v3[1] >= 0.0999 && v3[1] <= 0.80001);
   assert_true(v3[2] >= 0.0999 && v3[2] <= 0.80001);
   assert_true(v3[3] >= 0.0999 && v3[3] <= 0.80001);
+
+  /* swizzle */
+
+  /* ZYX */
+  v1[0] = 1;
+  v1[1] = 2;
+  v1[2] = 3;
+  v1[3] = 4;
+
+  glm_vec4_swizzle(v1, GLM_WZYX, v1);
+  test_assert_vec4_eq(v1, (vec4){4, 3, 2, 1});
+
+  glm_vec4_swizzle(v1, GLM_XXXX, v1);
+  test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4});
+
+  v1[0] = 1;
+  v1[1] = 2;
+  v1[2] = 3;
+  v1[3] = 4;
+
+  glm_vec4_swizzle(v1, GLM_YYYY, v1);
+  test_assert_vec4_eq(v1, (vec4){2, 2, 2, 2});
+
+  v1[0] = 1;
+  v1[1] = 2;
+  v1[2] = 3;
+  v1[3] = 4;
+
+  glm_vec4_swizzle(v1, GLM_ZZZZ, v1);
+  test_assert_vec4_eq(v1, (vec4){3, 3, 3, 3});
+
+  v1[0] = 1;
+  v1[1] = 2;
+  v1[2] = 3;
+  v1[3] = 4;
+
+  glm_vec4_swizzle(v1, GLM_WWWW, v1);
+  test_assert_vec4_eq(v1, (vec4){4, 4, 4, 4});
+
+  /* structs */
+  vs1 = test_rand_vec4s();
+  vs2 = test_rand_vec4s();
+
+  vs3 = glms_vec4_add(vs1, vs2);
+  vs4 = glms_vec4_maxv(vs1, vs3);
+  test_assert_vec4s_eq(vs3, vs4);
 }