From fd3f63e47479f06a62a7bda9d22083bd2a0be558 Mon Sep 17 00:00:00 2001 From: Ellpeck Date: Tue, 6 Aug 2019 14:20:11 +0200 Subject: [PATCH] mlem part 1 --- .gitignore | 5 + MLEM.sln | 16 ++++ MLEM/Extensions/ColorExtensions.cs | 16 ++++ MLEM/Extensions/NumberExtensions.cs | 16 ++++ MLEM/Extensions/RandomExtensions.cs | 16 ++++ MLEM/Extensions/SpriteBatchExtensions.cs | 28 ++++++ MLEM/Extensions/SpriteFontExtensions.cs | 22 +++++ MLEM/MLEM.csproj | 19 ++++ MLEM/Noise/Perlin.cs | 112 +++++++++++++++++++++++ 9 files changed, 250 insertions(+) create mode 100644 .gitignore create mode 100644 MLEM.sln create mode 100644 MLEM/Extensions/ColorExtensions.cs create mode 100644 MLEM/Extensions/NumberExtensions.cs create mode 100644 MLEM/Extensions/RandomExtensions.cs create mode 100644 MLEM/Extensions/SpriteBatchExtensions.cs create mode 100644 MLEM/Extensions/SpriteFontExtensions.cs create mode 100644 MLEM/MLEM.csproj create mode 100644 MLEM/Noise/Perlin.cs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..38b37f3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.idea +bin +obj +packages +*.user \ No newline at end of file diff --git a/MLEM.sln b/MLEM.sln new file mode 100644 index 0000000..f5a23d0 --- /dev/null +++ b/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 diff --git a/MLEM/Extensions/ColorExtensions.cs b/MLEM/Extensions/ColorExtensions.cs new file mode 100644 index 0000000..2f85987 --- /dev/null +++ b/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)); + } + + } +} \ No newline at end of file diff --git a/MLEM/Extensions/NumberExtensions.cs b/MLEM/Extensions/NumberExtensions.cs new file mode 100644 index 0000000..f85ae51 --- /dev/null +++ b/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); + } + + + } +} \ No newline at end of file diff --git a/MLEM/Extensions/RandomExtensions.cs b/MLEM/Extensions/RandomExtensions.cs new file mode 100644 index 0000000..bc581e3 --- /dev/null +++ b/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(this Random random, params T[] entries) { + return entries[random.Next(entries.Length)]; + } + + public static T GetRandomEntry(this Random random, IList entries) { + return entries[random.Next(entries.Count)]; + } + + } +} \ No newline at end of file diff --git a/MLEM/Extensions/SpriteBatchExtensions.cs b/MLEM/Extensions/SpriteBatchExtensions.cs new file mode 100644 index 0000000..602dc0a --- /dev/null +++ b/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); + } + + } +} \ No newline at end of file diff --git a/MLEM/Extensions/SpriteFontExtensions.cs b/MLEM/Extensions/SpriteFontExtensions.cs new file mode 100644 index 0000000..b5afbb4 --- /dev/null +++ b/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 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(); + } + + } +} \ No newline at end of file diff --git a/MLEM/MLEM.csproj b/MLEM/MLEM.csproj new file mode 100644 index 0000000..fc0fbeb --- /dev/null +++ b/MLEM/MLEM.csproj @@ -0,0 +1,19 @@ + + + netstandard2.0 + + + + Ellpeck + (M)LEM (L)ibrary by (E)llpeck for (M)onoGame + monogame ellpeck mlem utility extensions + https://github.com/Ellpeck/MLEM + https://github.com/Ellpeck/MLEM + https://github.com/Ellpeck/MLEM/blob/master/LICENSE + 1.0.0 + + + + + + \ No newline at end of file diff --git a/MLEM/Noise/Perlin.cs b/MLEM/Noise/Perlin.cs new file mode 100644 index 0000000..54e3ab5 --- /dev/null +++ b/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); + } + + } +} \ No newline at end of file