FalloffLayerGenerator and NoiseMapLayerGenerator

Creating generic falloff and noise map layers because they are not necessarily only used for height maps.

Documentation for TextureUtility
More clear names for TextureUtilityMethods
Started work on visualizer for FloatMaps
Added Tags to layers so we can potentially query for tagged layers in map data

Author: Cory Leach

Runtime/Utility/TextureUtility.cs

@@ -3,13 +3,19 @@
 
 namespace Gameframe.Procgen
 {
-
     public static class TextureUtility
     {
-        public static Texture2D GetHeightMap(float[,] heightMap)
+        /// <summary>
+        /// Creates a texture from a 2 dimensional array of floats
+        /// </summary>
+        /// <param name="floatMap">2 dimensional array of floats</param>
+        /// <param name="a">left hand side of texture color lerp</param>
+        /// <param name="b">right hand side of texture color lerp</param>
+        /// <returns>Texture2D filled with colors visualizing the 2d array</returns>
+        public static Texture2D CreateFrom2dFloatMap(float[,] floatMap, Color a, Color b)
         {
-            var width = heightMap.GetLength(0);
-            var height = heightMap.GetLength(1);
+            var width = floatMap.GetLength(0);
+            var height = floatMap.GetLength(1);
 
             var texture = new Texture2D(width, height);
             var colorMap = new Color[width * height];
@@ -18,7 +24,7 @@ public static Texture2D GetHeightMap(float[,] heightMap)
             {
                 for (int x = 0; x < width; x++)
                 {
-                    colorMap[y * width + x] = Color.Lerp(Color.black, Color.white, heightMap[x, y]);
+                    colorMap[y * width + x] = Color.Lerp(a, b, floatMap[x, y]);
                 }
             }
 
@@ -29,19 +35,53 @@ public static Texture2D GetHeightMap(float[,] heightMap)
             return texture;
         }
 
-        public static Texture2D GetHeightMap(float[] heightMap, int width, int height)
+        /// <summary>
+        /// Creates a texture from a 2 dimensional array of floats
+        /// Maps float values 0->1 onto a texture be lerping pixel color from black and white
+        /// </summary>
+        /// <param name="floatMap">2 dimensional array of floats</param>]
+        /// <returns>Texture2D filled with colors visualizing the 2d array</returns>
+        public static Texture2D CreateFrom2dFloatMap(float[,] floatMap)
+        {
+            return CreateFrom2dFloatMap(floatMap, Color.black, Color.white);
+        }
+
+        /// <summary>
+        /// Create texture from a float map
+        /// Maps float values 0->1 onto a texture be lerping pixel color from black and white
+        /// </summary>
+        /// <param name="floatMap">array of floats</param>
+        /// <param name="width">width of map/texture</param>
+        /// <param name="height">height of map/texture</param>
+        /// <returns>a Texture2D filled with colors representing the map</returns>
+        public static Texture2D CreateFromFloatMap(float[] floatMap, int width, int height)
+        {
+            return CreateFromFloatMap(floatMap, width, height, Color.black, Color.white);
+        }
+
+        /// <summary>
+        /// Create texture from a float map
+        /// Maps float values 0->1 onto a texture be lerping pixel color from color 'a' to color 'b'
+        /// </summary>
+        /// <param name="floatMap">array of floats</param>
+        /// <param name="width">width of map/texture</param>
+        /// <param name="height">height of map/texture</param>
+        /// <param name="a">Color that maps to 0</param>
+        /// <param name="b">Color that maps to 1</param>
+        /// <returns>a Texture2D filled with colors representing the map</returns>
+        public static Texture2D CreateFromFloatMap(float[] floatMap, int width, int height, Color a, Color b)
         {
             var texture = new Texture2D(width, height);
             var colorMap = new Color[width * height];
 
-            if (heightMap.Length < colorMap.Length)
+            if (floatMap.Length < colorMap.Length)
             {
                 throw new Exception("Height size does not match texture size");
             }
 
-            for (int i = 0; i < heightMap.Length; i++)
+            for (var i = 0; i < floatMap.Length; i++)
             {
-                colorMap[i] = Color.Lerp(Color.black, Color.white, heightMap[i]);
+                colorMap[i] = Color.Lerp(a, b, floatMap[i]);
             }
 
             texture.filterMode = FilterMode.Point;
@@ -51,7 +91,14 @@ public static Texture2D GetHeightMap(float[] heightMap, int width, int height)
             return texture;
         }
 
-        public static Texture2D GetColorMap(Color[] colorMap, int width, int height)
+        /// <summary>
+        /// Creates a texture from an array of colors
+        /// </summary>
+        /// <param name="colorMap">Array of colors</param>
+        /// <param name="width">width of color map and texture</param>
+        /// <param name="height">height of color map and texture</param>
+        /// <returns>Texture2D filled with the color map</returns>
+        public static Texture2D CreateFromColorMap(Color[] colorMap, int width, int height)
         {
             var texture = new Texture2D(width, height);
             texture.filterMode = FilterMode.Point;
@@ -61,6 +108,11 @@ public static Texture2D GetColorMap(Color[] colorMap, int width, int height)
             return texture;
         }
 
+        /// <summary>
+        /// Writes the texture to disk in png format
+        /// </summary>
+        /// <param name="tex2d">Texture to write to disk</param>
+        /// <param name="fullPath">Full path to write file to</param>
         public static void SaveTextureAsPNG(Texture2D tex2d, string fullPath)
         {
             var bytes = tex2d.EncodeToPNG();

Runtime/Visualizers/FloatLayerVisualizer.cs

@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace Gameframe.Procgen
+{
+    public class FloatLayerVisualizer : MonoBehaviour
+    {
+        [SerializeField]
+        private WorldMapLayerGenerator _layerGenerator;
+    }
+}

Runtime/Visualizers/FloatLayerVisualizer.cs.meta

@@ -1,6 +1,22 @@
-namespace Gameframe.Procgen
+using System;
+using UnityEngine;
+
+namespace Gameframe.Procgen
 {
   public interface IWorldMapLayerData
   {
+    string Tag { get; set; }
+  }
+
+  [Serializable]
+  public abstract class WorldMapLayerData : IWorldMapLayerData
+  {
+    [SerializeField]
+    private string tag;
+    public string Tag
+    {
+      get => tag;
+      set => tag = value;
+    }
   }
 }

Runtime/WorldMap/IWorldMapLayerData.cs

@@ -0,0 +1,63 @@
+using UnityEngine;
+
+namespace Gameframe.Procgen
+{
+    [CreateAssetMenu(menuName = "Gameframe/Procgen/Layers/Falloff Map")]
+    public class FalloffLayerGenerator : WorldMapLayerGenerator
+    {
+        [SerializeField] private bool randomizeOffset = false;
+
+        [SerializeField] private float minOffsetY = 0f;
+        [SerializeField] private float minOffsetX = 0f;
+
+        [SerializeField] private float maxOffsetY = 1f;
+        [SerializeField] private float maxOffsetX = 1f;
+
+        [SerializeField] private Vector2 falloffOffset = Vector2.zero;
+
+        [SerializeField] private float falloffA = 3f;
+
+        [SerializeField] private float falloffB = 2.2f;
+
+        [SerializeField] private bool applyCurve = false;
+        [SerializeField] private AnimationCurve curve = AnimationCurve.Linear(0,0,1, 1);
+
+        private float[] Generate(int width, int height, uint seed)
+        {
+            var offset = falloffOffset;
+
+            if (randomizeOffset)
+            {
+                var rng = new RandomGeneratorStruct(seed);
+                offset.y = rng.NextFloatRange(minOffsetY, maxOffsetY);
+                offset.x = rng.NextFloatRange(minOffsetX, maxOffsetX);
+            }
+
+            var floatMap = new float[width*height];
+
+            for (var y = 0; y < height; y++)
+            {
+                for (var x = 0; x < width; x++)
+                {
+                    var i = y * width + x;
+                    floatMap[i] = Noise.GenerateFalloffPoint(x , y , width, height, falloffA, falloffB, offset);
+                    if (applyCurve)
+                    {
+                        floatMap[i] = curve.Evaluate(floatMap[i]);
+                    }
+                }
+            }
+
+            return floatMap;
+        }
+
+        protected override IWorldMapLayerData GenerateLayer(WorldMapData mapData, int layerSeed)
+        {
+            var map = Generate(mapData.width,mapData.height, (uint)layerSeed);
+            return new FloatMapLayerData
+            {
+                FloatMap = map
+            };
+        }
+    }
+}

Runtime/WorldMap/Layers/FalloffLayerGenerator.cs

@@ -0,0 +1,22 @@
+using System;
+using UnityEngine;
+
+namespace Gameframe.Procgen
+{
+    [Serializable]
+    public class FloatMapLayerData : WorldMapLayerData, IFloatMapLayerData
+    {
+        [SerializeField]
+        private float[] floatMap;
+        public float[] FloatMap
+        {
+            get => floatMap;
+            set => floatMap = value;
+        }
+    }
+
+    public interface IFloatMapLayerData
+    {
+        public float[] FloatMap { get; }
+    }
+}

Runtime/WorldMap/Layers/FalloffLayerGenerator.cs.meta

@@ -1,8 +1,8 @@
 namespace Gameframe.Procgen
 {
     [System.Serializable]
-    public class HeightMapLayerData : IWorldMapLayerData
+    public class HeightMapLayerData : WorldMapLayerData
     {
         public float[] heightMap;
     }
-}
+}

Runtime/WorldMap/Layers/FloatMapLayerData.cs

@@ -4,7 +4,7 @@
 
 namespace Gameframe.Procgen
 {
-    [CreateAssetMenu(menuName = "Gameframe/Procgen/Layers/HeightMapLayerGenerator")]
+    [CreateAssetMenu(menuName = "Gameframe/Procgen/Layers/Height Map")]
     public class HeightMapLayerGenerator : WorldMapLayerGenerator
     {
         public enum MapType
@@ -98,9 +98,9 @@ public HeightMapLayerData Generate(int width, int height, uint seed)
             };
         }
 
-        public override void AddToWorld(WorldMapData worldMapData)
+        protected override IWorldMapLayerData GenerateLayer(WorldMapData mapData, int layerSeed)
         {
-            worldMapData.layers.Add(Generate(worldMapData.width,worldMapData.height,(uint)worldMapData.seed));
+            return Generate(mapData.width,mapData.height,(uint)layerSeed);
         }
 
         private void OnValidate()