Fixed Simplex 2D. Added Simplex 3D gradient arrays and methods

Author: Cory Leach

Runtime/Utility/SimplexGradientNoise.cs

@@ -4,12 +4,12 @@ namespace Gameframe.Procgen
 {
     public static class NoiseGradients
     {
-        public const int GradientsMask1D = 1;
-        public static readonly float[] Gradients1D = new[] {1f, -1f};
+        private const int GradientsMask1D = 1;
+        private static readonly float[] Gradients1D = new[] {1f, -1f};
 
-        public const int GradientsMask2D = 7;
+        private const int GradientsMask2D = 7;
 
-        public static readonly Vector2[] Gradients2D =
+        private static readonly Vector2[] Gradients2D =
         {
             new Vector2(1f, 0f),
             new Vector2(-1f, 0f),
@@ -21,9 +21,10 @@ public static class NoiseGradients
             new Vector2(-1f, -1f).normalized
         };
 
-        public const int GradientsMask3D = 15;
+        private const int GradientsMask3D = 15;
+        private const int SimplexGradientsMask3D = 31;
 
-        public static readonly Vector3[] Gradients3D =
+        private static readonly Vector3[] Gradients3D =
         {
             new Vector3( 1f, 1f, 0f),
             new Vector3(-1f, 1f, 0f),
@@ -44,6 +45,43 @@ public static class NoiseGradients
             new Vector3( 0f,-1f,-1f)
         };
 
+        private static readonly Vector3[] SimplexGradients3D = {
+            new Vector3( 1f, 1f, 0f).normalized,
+            new Vector3(-1f, 1f, 0f).normalized,
+            new Vector3( 1f,-1f, 0f).normalized,
+            new Vector3(-1f,-1f, 0f).normalized,
+            new Vector3( 1f, 0f, 1f).normalized,
+            new Vector3(-1f, 0f, 1f).normalized,
+            new Vector3( 1f, 0f,-1f).normalized,
+            new Vector3(-1f, 0f,-1f).normalized,
+            new Vector3( 0f, 1f, 1f).normalized,
+            new Vector3( 0f,-1f, 1f).normalized,
+            new Vector3( 0f, 1f,-1f).normalized,
+            new Vector3( 0f,-1f,-1f).normalized,
+
+            new Vector3( 1f, 1f, 0f).normalized,
+            new Vector3(-1f, 1f, 0f).normalized,
+            new Vector3( 1f,-1f, 0f).normalized,
+            new Vector3(-1f,-1f, 0f).normalized,
+            new Vector3( 1f, 0f, 1f).normalized,
+            new Vector3(-1f, 0f, 1f).normalized,
+            new Vector3( 1f, 0f,-1f).normalized,
+            new Vector3(-1f, 0f,-1f).normalized,
+            new Vector3( 0f, 1f, 1f).normalized,
+            new Vector3( 0f,-1f, 1f).normalized,
+            new Vector3( 0f, 1f,-1f).normalized,
+            new Vector3( 0f,-1f,-1f).normalized,
+
+            new Vector3( 1f, 1f, 1f).normalized,
+            new Vector3(-1f, 1f, 1f).normalized,
+            new Vector3( 1f,-1f, 1f).normalized,
+            new Vector3(-1f,-1f, 1f).normalized,
+            new Vector3( 1f, 1f,-1f).normalized,
+            new Vector3(-1f, 1f,-1f).normalized,
+            new Vector3( 1f,-1f,-1f).normalized,
+            new Vector3(-1f,-1f,-1f).normalized
+        };
+
         private static float HashToGradient1D(uint value)
         {
             return Gradients1D[value & GradientsMask1D];
@@ -54,7 +92,7 @@ public static float HashToGradient1D(int x, uint seed)
             return HashToGradient1D(Hash1D(x, seed));
         }
 
-        public static Vector2 HashToGradient2D(uint value)
+        private static Vector2 HashToGradient2D(uint value)
         {
             return Gradients2D[value & GradientsMask2D];
         }
@@ -69,11 +107,21 @@ private static Vector3 HashToGradient3D(uint value)
             return Gradients3D[value & GradientsMask3D];
         }
 
+        private static Vector3 HashToSimplexGradient3D(uint value)
+        {
+            return SimplexGradients3D[value & SimplexGradientsMask3D];
+        }
+
         public static Vector3 HashToGradient3D(int x, int y, int z, uint seed)
         {
             return HashToGradient3D(Hash3D(x, y, z, seed));
         }
 
+        public static Vector3 HashToSimplexGradient3D(int x, int y, int z, uint seed)
+        {
+            return HashToSimplexGradient3D(Hash3D(x, y, z, seed));
+        }
+
         public static uint Hash1D(int value, uint seed)
         {
             return SquirrelEiserloh.Get1dNoiseUint(value, seed);
@@ -276,39 +324,37 @@ public static NoiseSample SampleGradient2D(float x, float y, uint seed, float fr
             }
 
             sample.derivative *= frequency;
-            //sample.value *= (SimplexScale2D / 43.71107f);
-            //sample.value = (sample.value + 1) * 0.5f;
 
-            //sample.value *= SimplexScale2D; //32.99077
-            //Debug.Log($"Scale2D : {SimplexScale2D}");
+            sample.value *= SimplexScale2D;
+            sample.value += 1;
+            sample.value *= 0.5f;
 
             return sample;
         }
 
-        private static NoiseSample _Gradient2DPart(float x, float y, int ix, int iy, uint seed)
+        private static NoiseSample _Gradient2DPart(float pointX, float pointY, int ix, int iy, uint seed)
         {
             var unskew = (ix + iy) * SquaresToTriangles;
 
-            var x2 = x - ix + unskew;
-            var y2 = y - iy + unskew;
+            var x2 = pointX - ix + unskew;
+            var y2 = pointY - iy + unskew;
             var f = 0.5f - x2 * x2 - y2 * y2;
-            var f2 = f * f;
-            var f3 = f * f2;
-
 
             if (f > 0)
             {
+                var f2 = f * f;
+                var f3 = f * f2;
                 var g = NoiseGradients.HashToGradient2D(ix, iy, seed);
-                var v = NoiseGradients.Dot2D(g, x, y);
+                var v = NoiseGradients.Dot2D(g, x2, y2);
                 var v6f2 = -6f * v * f2;
 
                 return new NoiseSample
                 {
                     value = f3 * v,
                     derivative = new Vector3
                     {
-                        x = g.x * f3 + v6f2 * x,
-                        y = g.y * f3 + v6f2 * y,
+                        x = g.x * f3 + v6f2 * pointX,
+                        y = g.y * f3 + v6f2 * pointY,
                     }
                 };
             }