Fractal 3D simplex.

Author: Cory Leach

Runtime/Utility/SimplexGradientNoise.cs

@@ -1,3 +1,4 @@
+using System;
 using UnityEngine;
 
 namespace Gameframe.Procgen
@@ -11,7 +12,7 @@ public static class SimplexGradientNoise
         private static readonly float SimplexScale1D = 64f / 27f;
 
         #region 1D
-        public static NoiseSample SampleValue1D(float pointX, uint seed, float frequency)
+        public static NoiseSample Value1D(float pointX, uint seed, float frequency)
         {
             pointX *= frequency;
 
@@ -44,7 +45,7 @@ private static NoiseSample _Value1DPart(float pointX, int ix, uint seed)
                 }
             };
         }
-        public static NoiseSample SampleGradient1D(float pointX, uint seed, float frequency)
+        public static NoiseSample Gradient1D(float pointX, uint seed, float frequency)
         {
             pointX *= frequency;
 
@@ -86,7 +87,7 @@ private static float Hash1D(int value, uint seed)
         #endregion
 
         #region 2D
-        public static NoiseSample SampleValue2D(float x, float y, uint seed, float frequency)
+        public static NoiseSample Value2D(float x, float y, uint seed, float frequency)
         {
             x *= frequency;
             y *= frequency;
@@ -115,7 +116,7 @@ public static NoiseSample SampleValue2D(float x, float y, uint seed, float frequ
 
             return sample * 8;
         }
-        public static NoiseSample SampleGradient2D(float x, float y, uint seed, float frequency)
+        public static NoiseSample Gradient2D(float x, float y, uint seed, float frequency)
         {
             x *= frequency;
             y *= frequency;
@@ -212,7 +213,7 @@ private static float Hash2D(int x, int y, uint seed)
         #endregion
 
         #region 3D
-        public static NoiseSample SampleValue3D(float x, float y, float z, uint seed, float frequency)
+        public static NoiseSample Value3D(float x, float y, float z, uint seed, float frequency)
         {
             x *= frequency;
             y *= frequency;
@@ -280,7 +281,7 @@ public static NoiseSample SampleValue3D(float x, float y, float z, uint seed, fl
 
             return sample * 8;
         }
-        public static NoiseSample SampleGradient3D(float x, float y, float z, uint seed, float frequency)
+        public static NoiseSample Gradient3D(float x, float y, float z, uint seed, float frequency)
         {
             x *= frequency;
             y *= frequency;
@@ -351,6 +352,28 @@ public static NoiseSample SampleGradient3D(float x, float y, float z, uint seed,
 
             return sample;
         }
+        public static NoiseSample FractalGradient3D(float x, float y, float z, uint seed, float frequency, int octaves, float lacunarity = 2f, float persistence = 0.5f)
+        {
+            return _SampleFractal3D(Gradient3D, x, y, z, seed, frequency, octaves, lacunarity, persistence);
+        }
+        public static NoiseSample FractalValue3D(float x, float y, float z, uint seed, float frequency, int octaves, float lacunarity = 2f, float persistence = 0.5f)
+        {
+            return _SampleFractal3D(Value3D, x, y, z, seed, frequency, octaves, lacunarity, persistence);
+        }
+        private static NoiseSample _SampleFractal3D(Func<float, float, float, uint, float, NoiseSample> action, float x, float y, float z, uint seed, float frequency, int octaves, float lacunarity = 2f, float persistence = 0.5f)
+        {
+            var sum = action(x, y, z, seed, frequency);
+            var amplitude = 1f;
+            var range = 1f;
+            for (var i = 1; i < octaves; i++)
+            {
+                frequency *= lacunarity;
+                amplitude *= persistence;
+                range += amplitude;
+                sum += action(x, y, z, seed, frequency) * amplitude;
+            }
+            return sum * (1 / range);
+        }
         private static NoiseSample _Value3DPart(float x, float y, float z, int ix, int iy, int iz, uint seed)
         {
             var unskew = (ix + iy + iz) * (1f / 6f);

Runtime/Visualizers/NoiseVisualizer2D.cs

@@ -144,22 +144,22 @@ private void Generate()
                                 lacunarity, persistence).value;
                             break;
                         case Dimension.SimplexValue1D:
-                            v = SimplexGradientNoise.SampleValue1D(point.x, seed, frequency).value;
+                            v = SimplexGradientNoise.Value1D(point.x, seed, frequency).value;
                             break;
                         case Dimension.SimplexValue2D:
-                            v = SimplexGradientNoise.SampleValue2D(point.x, point.y, seed, frequency).value;
+                            v = SimplexGradientNoise.Value2D(point.x, point.y, seed, frequency).value;
                             break;
                         case Dimension.SimplexValue3D:
-                            v = SimplexGradientNoise.SampleValue3D(point.x, point.y, point.z, seed, frequency).value;
+                            v = SimplexGradientNoise.Value3D(point.x, point.y, point.z, seed, frequency).value;
                             break;
                         case Dimension.SimplexGradient1D:
-                            v = SimplexGradientNoise.SampleGradient1D(point.x, seed, frequency).value;
+                            v = SimplexGradientNoise.Gradient1D(point.x, seed, frequency).value;
                             break;
                         case Dimension.SimplexGradient2D:
-                            v = SimplexGradientNoise.SampleGradient2D(point.x, point.y, seed, frequency).value;
+                            v = SimplexGradientNoise.Gradient2D(point.x, point.y, seed, frequency).value;
                             break;
                         case Dimension.SimplexGradient3D:
-                            v = SimplexGradientNoise.SampleGradient3D(point.x, point.y, point.z, seed, frequency).value;
+                            v = SimplexGradientNoise.FractalGradient3D(point.x, point.y, point.z, seed, frequency, octaves, lacunarity, persistence).value;
                             break;
                         default:
                             throw new ArgumentOutOfRangeException();
@@ -172,7 +172,7 @@ private void Generate()
                 }
             }
 
-            Debug.Log($"Min: {minValue} Max: {maxValue}");
+            //Debug.Log($"Min: {minValue} Max: {maxValue}");
 
             _texture.Apply();
 

Runtime/Visualizers/SurfaceMeshVisualizer.cs

@@ -184,22 +184,22 @@ private NoiseSample Noise(Vector3 point)
                     sample = PerlinGradientNoise.FractalSample3D(point.x, point.y, point.z, seed, frequency, octaves, lacunarity, persistence);
                     break;
                 case Dimension.SimplexValue1D:
-                    sample = SimplexGradientNoise.SampleValue1D(point.x, seed, frequency);
+                    sample = SimplexGradientNoise.Value1D(point.x, seed, frequency);
                     break;
                 case Dimension.SimplexValue2D:
-                    sample = SimplexGradientNoise.SampleValue2D(point.x, point.y, seed, frequency);
+                    sample = SimplexGradientNoise.Value2D(point.x, point.y, seed, frequency);
                     break;
                 case Dimension.SimplexValue3D:
-                    sample = SimplexGradientNoise.SampleValue3D(point.x, point.y, point.z, seed, frequency);
+                    sample = SimplexGradientNoise.Value3D(point.x, point.y, point.z, seed, frequency);
                     break;
                 case Dimension.SimplexGradient1D:
-                    sample = SimplexGradientNoise.SampleGradient1D(point.x, seed, frequency);
+                    sample = SimplexGradientNoise.Gradient1D(point.x, seed, frequency);
                     break;
                 case Dimension.SimplexGradient2D:
-                    sample = SimplexGradientNoise.SampleGradient2D(point.x, point.y, seed, frequency);
+                    sample = SimplexGradientNoise.Gradient2D(point.x, point.y, seed, frequency);
                     break;
                 case Dimension.SimplexGradient3D:
-                    sample = SimplexGradientNoise.SampleGradient3D(point.x, point.y, point.z, seed, frequency);
+                    sample = SimplexGradientNoise.Gradient3D(point.x, point.y, point.z, seed, frequency);
                     break;
             }
             return sample;