1
0
Fork 0
mirror of https://github.com/Ellpeck/MLEM.git synced 2024-12-24 01:09:23 +01:00

mlem part 1

This commit is contained in:
Ellpeck 2019-08-06 14:20:11 +02:00
commit fd3f63e474
9 changed files with 250 additions and 0 deletions

5
.gitignore vendored Normal file
View file

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

16
MLEM.sln Normal file
View file

@ -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

View file

@ -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));
}
}
}

View file

@ -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);
}
}
}

View file

@ -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)];
}
}
}

View file

@ -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);
}
}
}

View file

@ -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();
}
}
}

19
MLEM/MLEM.csproj Normal file
View file

@ -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>

112
MLEM/Noise/Perlin.cs Normal file
View file

@ -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);
}
}
}