Wave function collapse methods

Author: Cory Leach

Runtime/Utility/IRandomNumberGenerator.cs

@@ -16,8 +16,11 @@ public interface IRandomNumberGenerator
         float NextFloatZeroToOne();
         float NextFloatNegOneToOne();
         float NextFloatRange(float min, float max);
+        double NextDoubleZeroToOne();
+        double NextDoubleNegOneToOne();
+        double NextDoubleRange(double min, double max);
         bool RollChance(float probabilityOfReturningTrue);
         Vector2 NextDirection2D();
         Vector3 NextDirection3D();
     }
-}
+}

Runtime/Utility/Noise.cs

@@ -54,11 +54,11 @@ public static class Noise
 
     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 x2 = x + Mathf.RoundToInt(width * offset.x);
+      var y2 = 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 valueY = (y2 + 0.5f) / (float) height * 2 - 1;
+      var valueX = (x2 + 0.5f) / (float) width * 2 - 1;
       var value = Mathf.Max(Mathf.Abs(valueX), Mathf.Abs(valueY));
       return 1 - FalloffCurve(value, a, b);
     }

Runtime/Utility/RandomGenerator.cs

@@ -4,7 +4,9 @@
 namespace Gameframe.Procgen
 {
     /// <summary>
-    /// Noise based random number generator (Struct version)
+    /// Noise based random number generator Struct version
+    /// If this will be passed as a method arg use class version to avoid generating duplicate values
+    ///
     /// Allows for fast random-access within a sequence of generated numbers
     /// Based on GDC 2017 talk and code by Squirrel Eiserloh
     /// </summary>
@@ -125,6 +127,36 @@ public float NextFloatRange(float min, float max)
             return min + (max - min) * v;
         }
 
+        /// <summary>
+        /// Next random double in the range 0 to 1
+        /// </summary>
+        /// <returns>Next random double in the range 0 to 1 (inclusive, inclusive)</returns>
+        public double NextDoubleZeroToOne()
+        {
+            return SquirrelEiserloh.Get1dNoiseZeroToOne_Double(position++, seed);
+        }
+
+        /// <summary>
+        /// Next random double in the range -1 to 1
+        /// </summary>
+        /// <returns>Next random double in the range -1 to 1 (inclusive, inclusive)</returns>
+        public double NextDoubleNegOneToOne()
+        {
+            return SquirrelEiserloh.Get1dNoiseNegOneToOne_Double(position++, seed);
+        }
+
+        /// <summary>
+        /// Next random double in the range min to max
+        /// </summary>
+        /// <param name="min">min return value</param>
+        /// <param name="max">max return value</param>
+        /// <returns>Next random double in the range min to max (inclusive, inclusive)</returns>
+        public double NextDoubleRange(double min, double max)
+        {
+            var v= SquirrelEiserloh.Get1dNoiseZeroToOne_Double(position++, seed);
+            return min + (max - min) * v;
+        }
+
         /// <summary>
         /// Next random integer in the range min to max
         /// </summary>
@@ -285,6 +317,21 @@ public int Position
         /// <returns>Next random float in the range min to max (inclusive, inclusive)</returns>
         public float NextFloatRange(float min, float max) => _randomGeneratorStruct.NextFloatRange(min,max);
 
+        public double NextDoubleZeroToOne()
+        {
+            return _randomGeneratorStruct.NextDoubleZeroToOne();
+        }
+
+        public double NextDoubleNegOneToOne()
+        {
+            return _randomGeneratorStruct.NextDoubleNegOneToOne();
+        }
+
+        public double NextDoubleRange(double min, double max)
+        {
+            return _randomGeneratorStruct.NextDoubleRange(min, max);
+        }
+
         /// <summary>
         /// Next random integer in the range min to max
         /// </summary>

Runtime/Utility/SquirrelEiserloh.cs

@@ -153,7 +153,18 @@ public static uint Get4dNoiseUint(int indexX, int indexY, int indexZ, int indexT
         /// <returns>random float between 0 and 1</returns>
         public static float Get1dNoiseZeroToOne(int index, uint seed)
         {
-            return (float) (ONE_OVER_MAX_UINT * SquirrelNoise5(index, seed));
+            return (float) Get1dNoiseZeroToOne_Double(index, seed);
+        }
+
+        /// <summary>
+        /// Get random value between 0 and 1 from a 1d noise map
+        /// </summary>
+        /// <param name="index">index of X position in noise map</param>
+        /// <param name="seed">random seed</param>
+        /// <returns>random double between 0 and 1</returns>
+        public static double Get1dNoiseZeroToOne_Double(int index, uint seed)
+        {
+            return (ONE_OVER_MAX_UINT * SquirrelNoise5(index, seed));
         }
 
         /// <summary>
@@ -207,7 +218,18 @@ public static float Get4dNoiseZeroToOne(int indexX, int indexY, int indexZ, int
         /// <returns>random float between -1 and 1</returns>
         public static float Get1dNoiseNegOneToOne(int index, uint seed)
         {
-            return (float) (ONE_OVER_MAX_INT * unchecked((int) SquirrelNoise5(index, seed)));
+            return (float)Get1dNoiseNegOneToOne_Double(index, seed);
+        }
+
+        /// <summary>
+        /// Get random value between 0 and 1 from a 1d noise map
+        /// </summary>
+        /// <param name="index">index of position in noise map</param>
+        /// <param name="seed">random seed</param>
+        /// <returns>random double between -1 and 1</returns>
+        public static double Get1dNoiseNegOneToOne_Double(int index, uint seed)
+        {
+            return (ONE_OVER_MAX_INT * unchecked((int) SquirrelNoise5(index, seed)));
         }
 
         /// <summary>

Runtime/Utility/TextureModel.cs

@@ -0,0 +1,153 @@
+// Originally by Maxim Gumin
+// Adapted from https://github.com/mxgmn/WaveFunctionCollapse
+// Copyright (C) 2023 Cory Leach, The MIT License (MIT)
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Gameframe.Procgen
+{
+    public class TextureModel : WaveCollapseModel
+    {
+        readonly List<byte[]> _patterns;
+        readonly List<Color> _colors;
+
+        public TextureModel(Texture2D sourceTexture, int N, int width, int height, bool periodicInput, bool periodic, int symmetry, bool ground, Heuristic heuristic) : base(width, height, N, periodic, heuristic)
+        {
+            var bitmap = sourceTexture.GetPixels();
+            var sourceWidth = sourceTexture.width;
+            var sourceHeight = sourceTexture.height;
+
+            var sample = new byte[bitmap.Length];
+            _colors = new List<Color>();
+            for (var i = 0; i < sample.Length; i++)
+            {
+                var color = bitmap[i];
+                var k = 0;
+                for (; k < _colors.Count; k++)
+                {
+                    if (_colors[k] == color)
+                    {
+                        break;
+                    }
+                }
+
+                if (k == _colors.Count)
+                {
+                    _colors.Add(color);
+                }
+
+                sample[i] = (byte) k;
+            }
+
+            _patterns = new();
+            Dictionary<long, int> patternIndices = new();
+            List<double> weightList = new();
+
+            var colorsCount = _colors.Count;
+            var xMax = periodicInput ? sourceWidth : sourceWidth - N + 1;
+            var yMax = periodicInput ? sourceHeight : sourceHeight - N + 1;
+
+            for (var y = 0; y < yMax; y++)
+            for (var x = 0; x < xMax; x++)
+            {
+                byte[][] ps = new byte[8][];
+
+                ps[0] = Pattern((dx, dy) => sample[(x + dx) % sourceWidth + (y + dy) % sourceHeight * sourceWidth], N);
+                ps[1] = Reflect(ps[0], N);
+                ps[2] = Rotate(ps[0], N);
+                ps[3] = Reflect(ps[2], N);
+                ps[4] = Rotate(ps[2], N);
+                ps[5] = Reflect(ps[4], N);
+                ps[6] = Rotate(ps[4], N);
+                ps[7] = Reflect(ps[6], N);
+
+                for (var k = 0; k < symmetry; k++)
+                {
+                    var p = ps[k];
+                    var h = Hash(p, colorsCount);
+                    if (patternIndices.TryGetValue(h, out int index))
+                    {
+                        weightList[index] = weightList[index] + 1;
+                    }
+                    else
+                    {
+                        patternIndices.Add(h, weightList.Count);
+                        weightList.Add(1.0);
+                        _patterns.Add(p);
+                    }
+                }
+            }
+
+            weights = weightList.ToArray();
+            T = weights.Length;
+            this.ground = ground;
+
+            propagator = new int[4][][];
+            for (int d = 0; d < 4; d++)
+            {
+                propagator[d] = new int[T][];
+                for (var t = 0; t < T; t++)
+                {
+                    List<int> list = new();
+                    for (var t2 = 0; t2 < T; t2++)
+                    {
+                        if (Agrees(_patterns[t], _patterns[t2], dx[d], dy[d], N))
+                        {
+                            list.Add(t2);
+                        }
+                    }
+
+                    propagator[d][t] = new int[list.Count];
+                    for (var c = 0; c < list.Count; c++)
+                    {
+                        propagator[d][t][c] = list[c];
+                    }
+                }
+            }
+        }
+
+        private static byte[] Reflect(byte[] p, int N) => Pattern((x, y) => p[N - 1 - x + y * N], N);
+
+        private static byte[] Rotate(byte[] p, int N) => Pattern((x, y) => p[N - 1 - y + x * N], N);
+
+        private static long Hash(byte[] p, int C)
+        {
+            long result = 0, power = 1;
+            for (var i = 0; i < p.Length; i++)
+            {
+                result += p[p.Length - 1 - i] * power;
+                power *= C;
+            }
+
+            return result;
+        }
+
+        private static bool Agrees(byte[] p1, byte[] p2, int dx, int dy, int N)
+        {
+            int xMin = dx < 0 ? 0 : dx, xMax = dx < 0 ? dx + N : N, yMin = dy < 0 ? 0 : dy, yMax = dy < 0 ? dy + N : N;
+            for (var y = yMin; y < yMax; y++)
+            for (var x = xMin; x < xMax; x++)
+            {
+                if (p1[x + N * y] != p2[x - dx + N * (y - dy)])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static byte[] Pattern(Func<int, int, byte> f, int N)
+        {
+            var result = new byte[N * N];
+            for (var y = 0; y < N; y++)
+            for (var x = 0; x < N; x++)
+            {
+                result[x + y * N] = f(x, y);
+            }
+            return result;
+        }
+    }
+}

Runtime/Utility/TextureModel.cs.meta

@@ -0,0 +1,38 @@
+namespace Gameframe.Procgen
+{
+    public static class WaveCollapseExtensions
+    {
+        public static int Random(this double[] weights, double r)
+        {
+            double sum = 0;
+            for (var i = 0; i < weights.Length; i++)
+            {
+                sum += weights[i];
+            }
+
+            var threshold = r * sum;
+
+            double partialSum = 0;
+            for (var i = 0; i < weights.Length; i++)
+            {
+                partialSum += weights[i];
+                if (partialSum >= threshold)
+                {
+                    return i;
+                }
+            }
+
+            return 0;
+        }
+
+        public static long ToPower(this int a, int n)
+        {
+            long product = 1;
+            for (var i = 0; i < n; i++)
+            {
+                product *= a;
+            }
+            return product;
+        }
+    }
+}