mlem part 1

.gitignore

@@ -0,0 +1,5 @@
+.idea
+bin
+obj
+packages
+*.user

MLEM.sln

@@ -0,0 +1,16 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MLEM", "MLEM\MLEM.csproj", "{1D6AB762-43C4-4775-8924-707C7EC3F142}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1D6AB762-43C4-4775-8924-707C7EC3F142}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1D6AB762-43C4-4775-8924-707C7EC3F142}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1D6AB762-43C4-4775-8924-707C7EC3F142}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1D6AB762-43C4-4775-8924-707C7EC3F142}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

MLEM/Extensions/ColorExtensions.cs

@@ -0,0 +1,16 @@
+using System;
+using Microsoft.Xna.Framework;
+
+namespace MLEM.Extensions {
+    public static class ColorExtensions {
+
+        public static Color Invert(this Color color) {
+            return new Color(Math.Abs(255 - color.R), Math.Abs(255 - color.G), Math.Abs(255 - color.B), color.A);
+        }
+
+        public static Color FromHex(uint value) {
+            return new Color((int) (value >> 16 & 0xFF), (int) (value >> 8 & 0xFF), (int) (value >> 0 & 0xFF), (int) (value >> 24 & 0xFF));
+        }
+
+    }
+}

MLEM/Extensions/NumberExtensions.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace MLEM.Extensions {
+    public static class NumberExtensions {
+
+        public static int Floor(this float f) {
+            return (int) Math.Floor(f);
+        }
+
+        public static int Ceil(this float f) {
+            return (int) Math.Ceiling(f);
+        }
+
+
+    }
+}

MLEM/Extensions/RandomExtensions.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+
+namespace MLEM.Extensions {
+    public static class RandomExtensions {
+
+        public static T GetRandomEntry<T>(this Random random, params T[] entries) {
+            return entries[random.Next(entries.Length)];
+        }
+
+        public static T GetRandomEntry<T>(this Random random, IList<T> entries) {
+            return entries[random.Next(entries.Count)];
+        }
+
+    }
+}

MLEM/Extensions/SpriteBatchExtensions.cs

@@ -0,0 +1,28 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace MLEM.Extensions {
+    public static class SpriteBatchExtensions {
+
+        private static Texture2D blankTexture;
+
+        public static Texture2D GetBlankTexture(SpriteBatch batch) {
+            if (blankTexture == null) {
+                blankTexture = new Texture2D(batch.GraphicsDevice, 1, 1, false, SurfaceFormat.Color);
+                blankTexture.SetData(new[] {Color.White});
+            }
+            return blankTexture;
+        }
+
+        public static void DrawCenteredString(this SpriteBatch batch, SpriteFont font, string text, Vector2 position, float scale, Color color, bool horizontal = true, bool vertical = false, float addedScale = 0) {
+            var size = font.MeasureString(text);
+            var center = new Vector2(
+                horizontal ? size.X * scale / 2F : 0,
+                vertical ? size.Y * scale / 2F : 0);
+            batch.DrawString(font, text,
+                position + size * scale / 2 - center,
+                color, 0, size / 2, scale + addedScale, SpriteEffects.None, 0);
+        }
+
+    }
+}

MLEM/Extensions/SpriteFontExtensions.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace MLEM.Extensions {
+    public static class SpriteFontExtensions {
+
+        public static IEnumerable<string> SplitString(this SpriteFont font, string text, float width, float scale) {
+            var builder = new StringBuilder();
+            foreach (var word in text.Split(' ')) {
+                builder.Append(word).Append(' ');
+                if (font.MeasureString(builder).X * scale >= width) {
+                    var len = builder.Length - word.Length - 1;
+                    yield return builder.ToString(0, len);
+                    builder.Remove(0, len);
+                }
+            }
+            yield return builder.ToString();
+        }
+
+    }
+}

MLEM/MLEM.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <Authors>Ellpeck</Authors>
+        <Description>(M)LEM (L)ibrary by (E)llpeck for (M)onoGame</Description>
+        <PackageTags>monogame ellpeck mlem utility extensions</PackageTags>
+        <PackageProjectUrl>https://github.com/Ellpeck/MLEM</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/Ellpeck/MLEM</RepositoryUrl>
+        <PackageLicenseUrl>https://github.com/Ellpeck/MLEM/blob/master/LICENSE</PackageLicenseUrl>
+        <Version>1.0.0</Version>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="MonoGame.Framework.Portable" Version="3.7.0.1708" />
+    </ItemGroup>
+</Project>

MLEM/Noise/Perlin.cs

@@ -0,0 +1,112 @@
+namespace MLEM.Noise {
+    // The code in this class is based on https://gist.github.com/Flafla2/1a0b9ebef678bbce3215
+    public static class Perlin {
+
+        private static readonly int[] P;
+
+        static Perlin() {
+            var perm = new[] {
+                151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69,
+                142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219,
+                203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175,
+                74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230,
+                220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76,
+                132, 187, 208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186,
+                3, 64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59,
+                227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70,
+                221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178,
+                185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81,
+                51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115,
+                121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195,
+                78, 66, 215, 61, 156, 180
+            };
+
+            P = new int[512];
+            for (var x = 0; x < P.Length; x++) {
+                P[x] = perm[x % 256];
+            }
+        }
+
+        public static double GenerateOctaves(double x, double y, double z, int octaves, double persistence) {
+            var total = 0D;
+            var frequency = 1D;
+            var amplitude = 1D;
+            for (var i = 0; i < octaves; i++) {
+                total += Generate(x * frequency, y * frequency, z * frequency) * amplitude;
+                amplitude *= persistence;
+                frequency *= 2;
+            }
+
+            return total;
+        }
+
+        public static double Generate(double x, double y, double z) {
+            var xi = (int) x & 255; // Calculate the "unit cube" that the point asked will be located in
+            var yi = (int) y & 255; // The left bound is ( |_x_|,|_y_|,|_z_| ) and the right bound is that
+            var zi = (int) z & 255; // plus 1.  Next we calculate the location (from 0.0 to 1.0) in that cube.
+            var xf = x - (int) x; // We also fade the location to smooth the result.
+            var yf = y - (int) y;
+            var zf = z - (int) z;
+            var u = Fade(xf);
+            var v = Fade(yf);
+            var w = Fade(zf);
+
+            var a = P[xi] + yi; // This here is Perlin's hash function.  We take our x value (remember,
+            var aa = P[a] + zi; // between 0 and 255) and get a random value (from our p[] array above) between
+            var ab = P[a + 1] + zi; // 0 and 255.  We then add y to it and plug that into p[], and add z to that.
+            var b = P[xi + 1] + yi; // Then, we get another random value by adding 1 to that and putting it into p[]
+            var ba = P[b] + zi; // and add z to it.  We do the whole thing over again starting with x+1.  Later
+            var bb = P[b + 1] + zi; // we plug aa, ab, ba, and bb back into p[] along with their +1's to get another set.
+            // in the end we have 8 values between 0 and 255 - one for each vertex on the unit cube.
+            // These are all interpolated together using u, v, and w below.
+
+            double x1, x2, y1, y2;
+            x1 = Lerp(Grad(P[aa], xf, yf, zf), // This is where the "magic" happens.  We calculate a new set of p[] values and use that to get
+                Grad(P[ba], xf - 1, yf, zf), // our final gradient values.  Then, we interpolate between those gradients with the u value to get
+                u); // 4 x-values.  Next, we interpolate between the 4 x-values with v to get 2 y-values.  Finally,
+            x2 = Lerp(Grad(P[ab], xf, yf - 1, zf), // we interpolate between the y-values to get a z-value.
+                Grad(P[bb], xf - 1, yf - 1, zf),
+                u); // When calculating the p[] values, remember that above, p[a+1] expands to p[xi]+yi+1 -- so you are
+            y1 = Lerp(x1, x2, v); // essentially adding 1 to yi.  Likewise, p[ab+1] expands to p[p[xi]+yi+1]+zi+1] -- so you are adding
+            // to zi.  The other 3 parameters are your possible return values (see grad()), which are actually
+            x1 = Lerp(Grad(P[aa + 1], xf, yf, zf - 1), // the vectors from the edges of the unit cube to the point in the unit cube itself.
+                Grad(P[ba + 1], xf - 1, yf, zf - 1),
+                u);
+            x2 = Lerp(Grad(P[ab + 1], xf, yf - 1, zf - 1),
+                Grad(P[bb + 1], xf - 1, yf - 1, zf - 1),
+                u);
+            y2 = Lerp(x1, x2, v);
+
+            return (Lerp(y1, y2, w) + 1) / 2; // For convenience we bound it to 0 - 1 (theoretical min/max before is -1 - 1)
+        }
+
+        private static double Grad(int hash, double x, double y, double z) {
+            var h = hash & 15; // Take the hashed value and take the first 4 bits of it (15 == 0b1111)
+            var u = h < 8 /* 0b1000 */ ? x : y; // If the most signifigant bit (MSB) of the hash is 0 then set u = x.  Otherwise y.
+
+            double v; // In Ken Perlin's original implementation this was another conditional operator (?:).  I
+            // expanded it for readability.
+
+            if (h < 4 /* 0b0100 */) // If the first and second signifigant bits are 0 set v = y
+                v = y;
+            else if (h == 12 /* 0b1100 */ || h == 14 /* 0b1110*/) // If the first and second signifigant bits are 1 set v = x
+                v = x;
+            else // If the first and second signifigant bits are not equal (0/1, 1/0) set v = z
+                v = z;
+
+            return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v); // Use the last 2 bits to decide if u and v are positive or negative.  Then return their addition.
+        }
+
+        private static double Fade(double t) {
+            // Fade function as defined by Ken Perlin.  This eases coordinate values
+            // so that they will "ease" towards integral values.  This ends up smoothing
+            // the final output.
+            return t * t * t * (t * (t * 6 - 15) + 10); // 6t^5 - 15t^4 + 10t^3
+        }
+
+        private static double Lerp(double a, double b, double x) {
+            return a + x * (b - a);
+        }
+
+    }
+}