Adding new noise options to HeightMapLayerGenerator

Author: Cory Leach

Runtime/Utility/Noise.cs

@@ -52,7 +52,18 @@ public static class Noise
       return map;
     }
 
-    private static float FalloffCurve(float value, float a = 3, float b = 2.2f)
+    public static float GenerateFalloffPoint(int x, int y, int width, int height, float a = 3f, float b = 2.2f, Vector2 offset = default)
+    {
+      x += Mathf.RoundToInt(width * offset.x);
+      y += Mathf.RoundToInt(height * offset.y);
+
+      var valueY = (y + 0.5f) / (float) height * 2 - 1;
+      var valueX = (x + 0.5f) / (float) width * 2 - 1;
+      var value = Mathf.Max(Mathf.Abs(valueX), Mathf.Abs(valueY));
+      return 1 - FalloffCurve(value, a, b);
+    }
+
+    public static float FalloffCurve(float value, float a = 3, float b = 2.2f)
     {
       return Mathf.Pow(value, a) / (Mathf.Pow(value, a) + Mathf.Pow(b - b * value, a));
     }

Runtime/WorldMap/Layers/HeightMapLayerGenerator.cs

@@ -9,17 +9,19 @@ public class HeightMapLayerGenerator : WorldMapLayerGenerator
     {
         public enum MapType
         {
-            Noise,
+            ValueNoise,
+            SimplexNoise,
+            PerlinNoise,
             Falloff,
-            NoiseWithFalloff
+            SimplexNoiseWithFalloff,
+            PerlinNoiseWithFalloff,
+            ValueNoiseWithFalloff
         }
 
         [SerializeField] private bool step = false;
 
         [SerializeField] private int stepCount = 10;
 
-        [SerializeField] private Vector2 offset = Vector2.zero;
-
         [FormerlySerializedAs("noiseScale")] [SerializeField] private float frequency = 1;
 
         [SerializeField] private int octaves = 4;
@@ -32,42 +34,61 @@ public enum MapType
 
         [SerializeField] private float falloffB = 2.2f;
 
-        [SerializeField] private MapType mapType = MapType.Noise;
+        [SerializeField] private Vector2 falloffOffset = Vector2.zero;
+
+        [SerializeField] private MapType mapType = MapType.SimplexNoise;
 
         public HeightMapLayerData Generate(int width, int height, uint seed)
         {
-            float[,] noiseMap;
-
-            switch (mapType)
+            var heightMap = new float[width*height];
+            for (var y = 0; y < height; y++)
             {
-                case MapType.Noise:
-                    noiseMap = Noise.GenerateNoiseMap(width, height, seed, offset, frequency, octaves,
-                        persistence, lacunarity);
-                    break;
-                case MapType.Falloff:
-                    noiseMap = Noise.GenerateFalloffMap(width, height, falloffA, falloffB);
-                    break;
-                case MapType.NoiseWithFalloff:
-                    var falloffMap = Noise.GenerateFalloffMap(width, height, falloffA, falloffB);
-                    noiseMap = Noise.GenerateNoiseMap(width, height, seed, offset, frequency, octaves, persistence, lacunarity, falloffMap);
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-
-            float[] heightMap = new float[width*height];
-            for (int y = 0; y < height; y++)
-            {
-                for (int x = 0; x < width; x++)
+                for (var x = 0; x < width; x++)
                 {
-                    var val = noiseMap[x, y];
+                    var i = y * width + x;
+                    switch (mapType)
+                    {
+                        case MapType.ValueNoise:
+                            heightMap[i] = ValueNoise.Fractal2D(x, y, (uint) seed, frequency, octaves, lacunarity, persistence);
+                            break;
+                        case MapType.PerlinNoise:
+                            heightMap[i] = PerlinGradientNoise.Fractal2D(x, y, (uint) seed, frequency, octaves, lacunarity, persistence);
+                            break;
+                        case MapType.SimplexNoise:
+                            heightMap[i] = SimplexGradientNoise.FractalGradient2D(x, y, (uint) seed, frequency, octaves, lacunarity, persistence).value;
+                            break;
+                        case MapType.Falloff:
+                            heightMap[i] = Noise.GenerateFalloffPoint(x , y , width, height, falloffA, falloffB, falloffOffset);
+                            break;
+                        case MapType.SimplexNoiseWithFalloff:
+                        {
+                            var falloff = Noise.GenerateFalloffPoint(x , y, width, height, falloffA, falloffB, falloffOffset);
+                            heightMap[i] = SimplexGradientNoise.FractalGradient2D(x, y, (uint) seed, frequency, octaves, lacunarity, persistence).value;
+                            heightMap[i] *= falloff;
+                        }
+                            break;
+                        case MapType.PerlinNoiseWithFalloff:
+                        {
+                            var falloff = Noise.GenerateFalloffPoint(x, y, width, height, falloffA, falloffB, falloffOffset);
+                            heightMap[i] = PerlinGradientNoise.Fractal2D(x, y, (uint) seed, frequency, octaves, lacunarity, persistence);
+                            heightMap[i] *= falloff;
+                        }
+                            break;
+                        case MapType.ValueNoiseWithFalloff:
+                        {
+                            var falloff = Noise.GenerateFalloffPoint(x, y, width, height, falloffA, falloffB, falloffOffset);
+                            heightMap[i] = ValueNoise.Fractal2D(x, y, (uint) seed, frequency, octaves, lacunarity, persistence);
+                            heightMap[i] *= falloff;
+                        }
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+                    }
 
                     if (step)
                     {
-                        val = Mathf.RoundToInt(val * stepCount) / (float)stepCount;
+                        heightMap[i] = Mathf.RoundToInt(heightMap[i] * stepCount) / (float)stepCount;
                     }
-
-                    heightMap[y * width + x] = val;
                 }
             }