Merge pull request #441 from MarcinKonowalczyk/perlin

Implement Perlin noise

test/src/test_noise.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
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(GLM_PREFIX, perlin_vec4) {
+  vec4 p1[] = {
+    {0.1f, 0.2f, 0.3f, 0.4f},
+    {0.2f, 0.3f, 0.4f, 0.5f},
+    {0.3f, 0.4f, 0.5f, 0.6f},
+    {0.4f, 0.5f, 0.6f, 0.7f},
+    {0.5f, 0.6f, 0.7f, 0.8f},
+    {0.6f, 0.7f, 0.8f, 0.9f},
+    {0.7f, 0.8f, 0.9f, 1.0f},
+    {0.8f, 0.9f, 1.0f, 1.1f},
+    {0.9f, 1.0f, 1.1f, 1.2f},
+    {1.0f, 1.1f, 1.2f, 1.3f},
+  };
+
+  /* expected values calculated by glm::perlin */
+  float e[] = {
+    -0.5091819763183594f,
+    -0.4375732541084290f,
+    -0.3212279379367828f,
+    -0.2279999703168869f,
+    -0.1577337533235550f,
+    -0.0445968918502331f,
+    0.1069696992635727f,
+    0.2067739963531494f,
+    0.2106968611478806f,
+    0.1397782564163208f
+  };
+  
+  for (int i = 0; i < 10; i++) {
+    ASSERT(test_eq(GLM(perlin_vec4)(p1[i]), e[i]));
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, perlin_vec3) {
+  vec3 p1[] = {
+    {0.1f, 0.2f, 0.3f},
+    {0.2f, 0.3f, 0.4f},
+    {0.3f, 0.4f, 0.5f},
+    {0.4f, 0.5f, 0.6f},
+    {0.5f, 0.6f, 0.7f},
+    {0.6f, 0.7f, 0.8f},
+    {0.7f, 0.8f, 0.9f},
+    {0.8f, 0.9f, 1.0f},
+    {0.9f, 1.0f, 1.1f},
+    {1.0f, 1.1f, 1.2f},
+  };
+
+  /* expected values calculated by glm::perlin */
+  float e[] = {
+    -0.2909241318702698f,
+    -0.4667602181434631f,
+    -0.4679279625415802f,
+    -0.2616460621356964f,
+    0.0562822706997395f,
+    0.3178773224353790f,
+    0.3981811404228210f,
+    0.3011017739772797f,
+    0.1263920217752457f,
+    -0.0602480024099350f
+  };
+  
+  for (int i = 0; i < 10; i++) {
+    ASSERT(test_eq(GLM(perlin_vec3)(p1[i]), e[i]));
+  }
+
+  TEST_SUCCESS
+}
+
+
+TEST_IMPL(GLM_PREFIX, perlin_vec2) {
+  vec2 p1[] = {
+    {0.1f, 0.2f},
+    {0.2f, 0.3f},
+    {0.3f, 0.4f},
+    {0.4f, 0.5f},
+    {0.5f, 0.6f},
+    {0.6f, 0.7f},
+    {0.7f, 0.8f},
+    {0.8f, 0.9f},
+    {0.9f, 1.0f},
+    {1.0f, 1.1f},
+  };
+
+  /* expected values calculated by glm::perlin */
+  float e[] = {
+    0.2841092348098755f,
+    0.2328013032674789f,
+    -0.0017980185803026f,
+    -0.3300299644470215f,
+    -0.5998955368995667f,
+    -0.6914522647857666f,
+    -0.5896517634391785f,
+    -0.3778679668903351f,
+    -0.1557840555906296f,
+    0.0453133136034012f
+  };
+  
+  for (int i = 0; i < 10; i++) {
+    ASSERT(test_eq(GLM(perlin_vec2)(p1[i]), e[i]));
+  }
+
+  TEST_SUCCESS
+}
+
+
+
+

test/src/test_vec2.h

@@ -688,6 +688,70 @@ TEST_IMPL(GLM_PREFIX, vec2_abs) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(GLM_PREFIX, vec2_fract) {
+  vec2 v1 = {2.104f, 3.012f}, v2 = {12.35f, 31.140f}, v3, v4;
+  vec2 v5 = {0.104f, 0.012f}, v6 = {0.35f, 0.140f};
+
+  GLM(vec2_fract)(v1, v3);
+  GLM(vec2_fract)(v2, v4);
+
+  ASSERTIFY(test_assert_vec2_eq(v3, v5))
+  ASSERTIFY(test_assert_vec2_eq(v4, v6))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_floor) {
+  vec2 v1 = {2.104f, 3.012f}, v2 = {12.35f, 31.140f}, v3, v4;
+  vec2 v5 = {2.0f, 3.0f}, v6 = {12.0f, 31.0f};
+
+  GLM(vec2_floor)(v1, v3);
+  GLM(vec2_floor)(v2, v4);
+
+  ASSERTIFY(test_assert_vec2_eq(v3, v5))
+  ASSERTIFY(test_assert_vec2_eq(v4, v6))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_mods) {
+  vec2 v1 = {2.104f, 3.012f}, v2 = {12.35f, 31.140f}, v3, v4;
+  vec2 v5 = {0.104f, 0.012f}, v6 = {0.35f, 0.140f};
+
+  /* Mod 1 - leaves just the fractional part */
+  GLM(vec2_mods)(v1, 1.0f, v3);
+  GLM(vec2_mods)(v2, 1.0f, v4);
+
+  ASSERTIFY(test_assert_vec2_eq(v3, v5))
+  ASSERTIFY(test_assert_vec2_eq(v4, v6))
+
+  /* Mod 2 - parity + fractional part */
+  GLM(vec2_mods)(v1, 2.0f, v3);
+  GLM(vec2_mods)(v2, 2.0f, v4);
+
+  vec2 v7 = {0.104f, 1.012f}, v8 = {0.35f, 1.140f};
+
+  ASSERTIFY(test_assert_vec2_eq(v3, v7))
+  ASSERTIFY(test_assert_vec2_eq(v4, v8))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_swizzle) {
+  vec2 v;
+
+  v[0] = 1;
+  v[1] = 2;
+  
+  GLM(vec2_swizzle)(v, GLM_SHUFFLE2(1, 0), v);
+  ASSERTIFY(test_assert_vec2_eq(v, (vec2){2, 1}))
+  
+  GLM(vec2_swizzle)(v, GLM_SHUFFLE2(0, 0), v);
+  ASSERTIFY(test_assert_vec2_eq(v, (vec2){1, 1}))
+  
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, vec2_lerp) {
   vec2 v1 = {-100.0f, -200.0f};
   vec2 v2 = {100.0f, 200.0f};
@@ -704,6 +768,66 @@ TEST_IMPL(GLM_PREFIX, vec2_lerp) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(GLM_PREFIX, vec2_steps) {
+  vec2 v1 = {-100.0f, -200.0f};
+  vec2 v2;
+
+  GLM(vec2_steps)(-2.5f, v1, v2);
+  ASSERT(test_eq(v2[0], 0.0f))
+  ASSERT(test_eq(v2[1], 0.0f))
+  
+  GLM(vec2_steps)(-150.0f, v1, v2);
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 0.0f))
+  
+  GLM(vec2_steps)(-300.0f, v1, v2);
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_stepr) {
+  vec2 v1 = {-2.5f, -150.0f};
+  vec2 v2;
+
+  GLM(vec2_stepr)(v1, -200.0f, v2);
+  ASSERT(test_eq(v2[0], 0.0f))
+  ASSERT(test_eq(v2[1], 0.0f))
+  
+  GLM(vec2_stepr)(v1, -150.0f, v2);
+  ASSERT(test_eq(v2[0], 0.0f))
+  ASSERT(test_eq(v2[1], 1.0f))
+  
+  GLM(vec2_stepr)(v1, 0.0f, v2);
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec2_step) {
+  vec2 v1 = {-100.0f, -200.0f};
+  vec2 s1 = {-100.0f, 0.0f};
+  vec2 s2 = {100.0f, -220.0f};
+  vec2 s3 = {100.0f, 200.0f};
+  vec2 v2;
+
+  GLM(vec2_step)(s1, v1, v2);
+  ASSERT(test_eq(v2[0], 1.0f))
+  ASSERT(test_eq(v2[1], 0.0f))
+  
+  GLM(vec2_step)(s2, v1, v2);
+  ASSERT(test_eq(v2[0], 0.0f))
+  ASSERT(test_eq(v2[1], 1.0f))
+  
+  GLM(vec2_step)(s3, v1, v2);
+  ASSERT(test_eq(v2[0], 0.0f))
+  ASSERT(test_eq(v2[1], 0.0f))
+
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, vec2_complex_mul) {
   vec2 v1 = { 3.0f,  5.0f },
        v2 = { 7.0f, 11.0f },

test/src/test_vec3.h

@@ -1393,21 +1393,43 @@ TEST_IMPL(GLM_PREFIX, vec3_mixc) {
   TEST_SUCCESS
 }
 
-TEST_IMPL(GLM_PREFIX, vec3_step_uni) {
+TEST_IMPL(GLM_PREFIX, vec3_steps) {
   vec3 v1 = {-100.0f, -200.0f, -10.0f};
   vec3 v2;
 
-  GLM(vec3_step_uni)(-2.5f, v1, v2);
+  GLM(vec3_steps)(-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);
+  GLM(vec3_steps)(-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);
+  GLM(vec3_steps)(-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_stepr) {
+  vec3 v1 = {-2.5f, -10.0f, -1000.0f};
+  vec3 v2;
+
+  GLM(vec3_stepr)(v1, -100.0f, v2);
+  ASSERT(test_eq(v2[0], 0.0f))
+  ASSERT(test_eq(v2[1], 0.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+  
+  GLM(vec3_stepr)(v1, -5.0f, v2);
+  ASSERT(test_eq(v2[0], 0.0f))
+  ASSERT(test_eq(v2[1], 1.0f))
+  ASSERT(test_eq(v2[2], 1.0f))
+  
+  GLM(vec3_stepr)(v1, -1.0f, v2);
   ASSERT(test_eq(v2[0], 1.0f))
   ASSERT(test_eq(v2[1], 1.0f))
   ASSERT(test_eq(v2[2], 1.0f))
@@ -1552,24 +1574,24 @@ TEST_IMPL(GLM_PREFIX, vec3_swizzle) {
   v[1] = 2;
   v[2] = 3;
 
-  glm_vec3_swizzle(v, GLM_ZYX, v);
+  GLM(vec3_swizzle)(v, GLM_ZYX, v);
   ASSERTIFY(test_assert_vec3_eq(v, (vec3){3, 2, 1}))
 
-  glm_vec3_swizzle(v, GLM_XXX, v);
+  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);
+  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);
+  GLM(vec3_swizzle)(v, GLM_ZZZ, v);
   ASSERTIFY(test_assert_vec3_eq(v, (vec3){3, 3, 3}))
 
   TEST_SUCCESS
@@ -1826,6 +1848,42 @@ TEST_IMPL(GLM_PREFIX, vec3_fract) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(GLM_PREFIX, vec3_floor) {
+  vec3  v1 = {2.104f, 3.012f, 4.10f}, v2 = {12.35f, 31.140f, 43.502f}, v3, v4;
+  vec3  v5 = {2.0f, 3.0f, 4.0f}, v6 = {12.0f, 31.0f, 43.0f};
+
+  GLM(vec3_floor)(v1, v3);
+  GLM(vec3_floor)(v2, v4);
+
+  ASSERTIFY(test_assert_vec3_eq(v3, v5))
+  ASSERTIFY(test_assert_vec3_eq(v4, v6))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec3_mods) {
+  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};
+
+  /* Mod 1 - leaves just the fractional part */
+  GLM(vec3_mods)(v1, 1.0f, v3);
+  GLM(vec3_mods)(v2, 1.0f, v4);
+
+  ASSERTIFY(test_assert_vec3_eq(v3, v5))
+  ASSERTIFY(test_assert_vec3_eq(v4, v6))
+
+  /* Mod 2 - parity + fractional part */
+  GLM(vec3_mods)(v1, 2.0f, v3);
+  GLM(vec3_mods)(v2, 2.0f, v4);
+
+  vec3 v7 = {0.104f, 1.012f, 0.10f}, v8 = {0.35f, 1.140f, 1.502f};
+
+  ASSERTIFY(test_assert_vec3_eq(v3, v7))
+  ASSERTIFY(test_assert_vec3_eq(v4, v8))
+
+  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;

test/src/test_vec4.h

@@ -980,23 +980,60 @@ TEST_IMPL(GLM_PREFIX, vec4_mixc) {
   TEST_SUCCESS
 }
 
-TEST_IMPL(GLM_PREFIX, vec4_step_uni) {
+TEST_IMPL(GLM_PREFIX, vec4_steps) {
   vec4 v1 = {-100.0f, -200.0f, -10.0f, -10.0f};
   vec4 v2;
 
-  GLM(vec4_step_uni)(-2.5f, v1, v2);
+  GLM(vec4_steps)(-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);
+  GLM(vec4_steps)(-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);
+  GLM(vec4_steps)(-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_stepr) {
+  vec4 v1 = {-2.5f, -100.0f, -200.0f, -300.0f};
+  vec4 v2;
+
+  GLM(vec4_stepr)(v1, -1000.0f, 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_stepr)(v1, -250.0f, 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], 1.0f))
+  
+  GLM(vec4_stepr)(v1, -150.0f, 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_stepr)(v1, -10.0f, 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_stepr)(v1, 0.0f, v2);
   ASSERT(test_eq(v2[0], 1.0f))
   ASSERT(test_eq(v2[1], 1.0f))
   ASSERT(test_eq(v2[2], 1.0f))
@@ -1184,10 +1221,10 @@ TEST_IMPL(GLM_PREFIX, vec4_swizzle) {
   v[2] = 3;
   v[3] = 4;
   
-  glm_vec4_swizzle(v, GLM_WZYX, v);
+  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);
+  GLM(vec4_swizzle)(v, GLM_XXXX, v);
   ASSERTIFY(test_assert_vec4_eq(v, (vec4){4, 4, 4, 4}))
   
   v[0] = 1;
@@ -1195,7 +1232,7 @@ TEST_IMPL(GLM_PREFIX, vec4_swizzle) {
   v[2] = 3;
   v[3] = 4;
   
-  glm_vec4_swizzle(v, GLM_YYYY, v);
+  GLM(vec4_swizzle)(v, GLM_YYYY, v);
   ASSERTIFY(test_assert_vec4_eq(v, (vec4){2, 2, 2, 2}))
   
   v[0] = 1;
@@ -1203,7 +1240,7 @@ TEST_IMPL(GLM_PREFIX, vec4_swizzle) {
   v[2] = 3;
   v[3] = 4;
   
-  glm_vec4_swizzle(v, GLM_ZZZZ, v);
+  GLM(vec4_swizzle)(v, GLM_ZZZZ, v);
   ASSERTIFY(test_assert_vec4_eq(v, (vec4){3, 3, 3, 3}))
   
   v[0] = 1;
@@ -1211,7 +1248,7 @@ TEST_IMPL(GLM_PREFIX, vec4_swizzle) {
   v[2] = 3;
   v[3] = 4;
   
-  glm_vec4_swizzle(v, GLM_WWWW, v);
+  GLM(vec4_swizzle)(v, GLM_WWWW, v);
   ASSERTIFY(test_assert_vec4_eq(v, (vec4){4, 4, 4, 4}))
 
   TEST_SUCCESS
@@ -1490,6 +1527,47 @@ TEST_IMPL(GLM_PREFIX, vec4_fract) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(GLM_PREFIX, vec4_floor) {
+  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.0f, 3.0f, 4.0f, 4.0f};
+  vec4 v6 = {12.0f, 31.0f, 43.0f, 43.0f};
+
+  GLM(vec4_floor)(v1, v3);
+  GLM(vec4_floor)(v2, v4);
+
+  ASSERTIFY(test_assert_vec4_eq(v3, v5))
+  ASSERTIFY(test_assert_vec4_eq(v4, v6))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, vec4_mods) {
+  vec4 v1 = {2.104f, 3.012f, 4.10f, 5.78f}, v2 = {12.35f, 31.140f, 43.502f, 198.999f};
+  vec4 v3, v4;
+  vec4 v5 = {0.104f, 0.012f, 0.10f, 0.78f}, v6 = {0.35f, 0.140f, 0.502f, 0.999f};
+
+  /* Mod 1 - leaves just the fractional part */
+  GLM(vec4_mods)(v1, 1.0f, v3);
+  GLM(vec4_mods)(v2, 1.0f, v4);
+
+  ASSERTIFY(test_assert_vec4_eq(v3, v5))
+  ASSERTIFY(test_assert_vec4_eq(v4, v6))
+
+  /* Mod 2 - parity + fractional part */
+  GLM(vec4_mods)(v1, 2.0f, v3);
+  GLM(vec4_mods)(v2, 2.0f, v4);
+
+  vec4 v7 = {0.104f, 1.012f, 0.10f, 1.78f}, v8 = {0.35f, 1.140f, 1.502f, 0.999f};
+
+  ASSERTIFY(test_assert_vec4_eq(v3, v7))
+  ASSERTIFY(test_assert_vec4_eq(v4, v8))
+
+  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;

test/src/tests.c

@@ -30,6 +30,7 @@
 #include "test_quat.h"
 #include "test_project.h"
 #include "test_plane.h"
+#include "test_noise.h"
 #include "test_affine.h"
 #include "test_affine2d.h"
 #include "test_affine_mat.h"
@@ -70,6 +71,7 @@
 #include "test_quat.h"
 #include "test_project.h"
 #include "test_plane.h"
+#include "test_noise.h"
 #include "test_affine.h"
 #include "test_affine2d.h"
 #include "test_affine_mat.h"