Add erosion option

LibNoise/BrownianMotionNoise.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace LibNoise
+{
+    /// <summary>
+    /// Implementation of Brownian Motion Noise
+    /// </summary>
+    public class BrownianMotionNoise
+    {
+        // static Random random = new Random(DateTime.Now.Millisecond + DateTime.Now.Second + DateTime.Now.Minute + DateTime.Now.Hour);
+
+        /// <summary>
+        /// Create noise tiled left-to-right
+        /// </summary>
+        /// <param name="noise"></param>
+        /// <param name="buffer"></param>
+        public static void TileNoiseLeftRight(float[,] noise, int buffer)
+        {
+            int width = noise.GetLength(0);
+            int height = noise.GetLength(1);
+
+            for (int x = 0; x < buffer; x++)
+            {
+                for (int y = 0; y < height; y++)
+                {
+                    noise[(width - 1) - x, y] = noise[x, y];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Merge noise layer into white noise, by the provided percent
+        /// </summary>
+        /// <param name="noise"></param>
+        /// <param name="percent"></param>
+        /// <param name="seed"></param>
+        public static void AddNoise(float[,] noise, double percent, int seed)
+        {
+            int width = noise.GetLength(0);
+            int height = noise.GetLength(1);
+
+            MergeNoise(noise, GenerateWhiteNoise(width, height, seed), percent);
+        }
+
+        /// <summary>
+        /// Merge noise layers together, by the provided percent
+        /// </summary>
+        /// <param name="noise"></param>
+        /// <param name="mergeValues"></param>
+        /// <param name="percent"></param>
+        public static void MergeNoise(float[,] noise, float[,] mergeValues, double percent)
+        {
+            int width = noise.GetLength(0);
+            int height = noise.GetLength(1);
+
+            Parallel.For(0, width, i =>
+            {
+                for (int j = 0; j < height; j++)
+                {
+                    noise[i, j] += mergeValues[i, j] * Convert.ToSingle(percent / 100.0);
+                    if (noise[i, j] > 1) noise[i, j] = 1;
+                }
+            });
+        }
+
+        /// <summary>
+        /// Interpolate noise value
+        /// </summary>
+        /// <param name="x0"></param>
+        /// <param name="x1"></param>
+        /// <param name="alpha"></param>
+        /// <returns></returns>
+        public static float Interpolate(float x0, float x1, float alpha)
+        {
+            return x0 * (1 - alpha) + alpha * x1;
+        }
+
+        /// <summary>
+        /// Generate a white noise base set
+        /// </summary>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        /// <param name="seed"></param>
+        /// <returns></returns>
+        public static float[,] GenerateWhiteNoise(int width, int height, int seed)
+        {
+            Random random = new Random(seed);
+            float[,] noise = new float[width, height];
+
+            Parallel.For(0, width, i =>
+            {
+                for (int j = 0; j < height; j++)
+                {
+                    noise[i, j] = (float)random.NextDouble() % 1;
+                }
+            });
+
+            return noise;
+        }
+
+        /// <summary>
+        /// Create smoothed noise from a base noise layer (usually white noise), with the provided octave
+        /// </summary>
+        /// <param name="baseNoise"></param>
+        /// <param name="octave"></param>
+        /// <returns></returns>
+        public static float[,] GenerateSmoothNoise(float[,] baseNoise, int octave)
+        {
+            int width = baseNoise.GetLength(0);
+            int height = baseNoise.GetLength(1);
+
+            float[,] smoothNoise = new float[width, height];
+
+            int samplePeriod = 1 << octave; // calculates 2 ^ k
+            float sampleFrequency = 1.0f / samplePeriod;
+
+            for (int i = 0; i < width; i++)
+            {
+                // calculate the horizontal sampling indices
+                int sample_i0 = (i / samplePeriod) * samplePeriod;
+                int sample_i1 = (sample_i0 + samplePeriod) % width; // wrap around
+                float horizontal_blend = (i - sample_i0) * sampleFrequency;
+
+                for (int j = 0; j < height; j++)
+                {
+                    // calculate the vertical sampling indices
+                    int sample_j0 = (j / samplePeriod) * samplePeriod;
+                    int sample_j1 = (sample_j0 + samplePeriod) % height; // wrap around
+                    float vertical_blend = (j - sample_j0) * sampleFrequency;
+
+                    // blend the top two corners
+                    float top = Interpolate(baseNoise[sample_i0, sample_j0],
+                        baseNoise[sample_i1, sample_j0], horizontal_blend);
+
+                    // blend the bottom two corners
+                    float bottom = Interpolate(baseNoise[sample_i0, sample_j1],
+                        baseNoise[sample_i1, sample_j1], horizontal_blend);
+
+                    // final blend
+                    smoothNoise[i, j] = Interpolate(top, bottom, vertical_blend);
+                }
+            }
+
+            return smoothNoise;
+        }
+
+        /// <summary>
+        /// Generate Perlin noise
+        /// </summary>
+        /// <param name="baseNoise"></param>
+        /// <param name="octaveCount"></param>
+        /// <returns></returns>
+        public static float[,] GeneratePerlinNoise(float[,] baseNoise, int octaveCount)
+        {
+            int width = baseNoise.GetLength(0);
+            int height = baseNoise.GetLength(1);
+
+            List<float[,]> smoothNoise = new List<float[,]>(octaveCount);
+
+            float persistance = 0.7f;
+
+            // generate smooth noise
+            for (int i = 0; i < octaveCount; i++)
+            {
+                smoothNoise.Add(GenerateSmoothNoise(baseNoise, i));
+            }
+
+            float[,] bmNoise = new float[width, height];
+
+            float amplitude = 1.0f;
+            float totalAmplitude = 0.0f;
+
+            // blend noise together
+            for (int octave = octaveCount - 1; octave >= 0; octave--)
+            {
+                amplitude *= persistance;
+                totalAmplitude += amplitude;
+
+                for (int i = 0; i < width; i++)
+                {
+                    for (int j = 0; j < height; j++)
+                    {
+                        bmNoise[i, j] += smoothNoise[octave][i, j] * amplitude;
+                    }
+                }
+            }
+
+            // normalisation
+            Parallel.For(0, width, i =>
+            {
+                for (int j = 0; j < height; j++)
+                {
+                    bmNoise[i, j] /= totalAmplitude;
+                }
+            });
+
+            return bmNoise;
+        }
+
+        /// <summary>
+        /// Create a noise layer of brownian motion noise, with the provided width, height, octave and seed
+        /// </summary>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        /// <param name="octaveCount"></param>
+        /// <param name="seed"></param>
+        /// <returns></returns>
+        public static float[,] GenerateBrownianMotionNoise(int width, int height, int octaveCount, int seed)
+        {
+            float[,] baseNoise = GenerateWhiteNoise(width, height, seed);
+
+            return GeneratePerlinNoise(baseNoise, octaveCount);
+        }
+    }
+}