mirror of
https://github.com/ClassiCube/ClassiCube.git
synced 2025-10-08 13:34:54 -04:00
111 lines
3.1 KiB
C#
111 lines
3.1 KiB
C#
// Source from http://mrl.nyu.edu/~perlin/noise/
|
|
// Optimised form as we can always treat Z as being = 0.
|
|
// Octave and combined noise based on:
|
|
// https://github.com/UnknownShadow200/ClassicalSharp/wiki/Minecraft-Classic-map-generation-algorithm
|
|
using System;
|
|
|
|
namespace ClassicalSharp.Generator {
|
|
|
|
public abstract class Noise {
|
|
|
|
public abstract double Compute( double x, double y );
|
|
}
|
|
|
|
public sealed class ImprovedNoise : Noise {
|
|
|
|
public ImprovedNoise( Random rnd ) {
|
|
// make a random initial permutation based on rnd's seed,
|
|
// shuffle using fisher-yates
|
|
|
|
for( int i = 0; i < 256; i++ )
|
|
p[i] = (byte)i;
|
|
|
|
for( int i = 0; i < 256; i++ ) {
|
|
int j = rnd.Next( i, 256 );
|
|
byte temp = p[i]; p[i] = p[j]; p[j] = temp;
|
|
}
|
|
for( int i = 0; i < 256; i++ )
|
|
p[i + 256] = p[i];
|
|
}
|
|
|
|
// TODO: need to half this maybe?
|
|
public override double Compute( double x, double y ) {
|
|
int xFloor = x >= 0 ? (int)x : (int)x - 1;
|
|
int yFloor = y >= 0 ? (int)y : (int)y - 1;
|
|
int X = xFloor & 0xFF, Y = yFloor & 0xFF;
|
|
x -= xFloor; y -= yFloor;
|
|
|
|
double u = x * x * x * (x * (x * 6 - 15) + 10); // Fade(x)
|
|
double v = y * y * y * (y * (y * 6 - 15) + 10); // Fade(y)
|
|
int A = p[X] + Y, B = p[X + 1] + Y;
|
|
|
|
double g22 = Grad( p[p[A]], x, y ), g12 = Grad( p[p[B]], x - 1, y );
|
|
double c1 = g22 + u * (g12 - g22);
|
|
double g21 = Grad( p[p[A + 1]], x, y - 1 ), g11 = Grad( p[p[B + 1]], x - 1, y - 1 );
|
|
double c2 = g21 + u * (g11 - g21);
|
|
return c1 + v * (c2 - c1);
|
|
}
|
|
|
|
static double Grad( int hash, double x, double y ) {
|
|
switch( hash & 15 ) {
|
|
case 0: return x + y;
|
|
case 1: return -x + y;
|
|
case 2: return x - y;
|
|
case 3: return -x - y;
|
|
case 4: return x;
|
|
case 5: return -x;
|
|
case 6: return x;
|
|
case 7: return -x;
|
|
case 8: return y;
|
|
case 9: return -y;
|
|
case 10: return y;
|
|
case 11: return -y;
|
|
case 12: return x + y;
|
|
case 13: return -y;
|
|
case 14: return -x + y;
|
|
case 15: return -y;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
byte[] p = new byte[512];
|
|
}
|
|
|
|
public sealed class OctaveNoise : Noise {
|
|
|
|
readonly int octaves;
|
|
readonly ImprovedNoise[] baseNoise;
|
|
public OctaveNoise( int octaves, Random rnd ) {
|
|
this.octaves = octaves;
|
|
baseNoise = new ImprovedNoise[octaves];
|
|
for( int i = 0; i < octaves; i++ )
|
|
baseNoise[i] = new ImprovedNoise( rnd );
|
|
}
|
|
|
|
public override double Compute( double x, double y ) {
|
|
double amplitude = 1, frequency = 1;
|
|
double sum = 0;
|
|
for( int i = 0; i < baseNoise.Length; i++ ) {
|
|
sum += baseNoise[i].Compute( x * frequency, y * frequency ) * amplitude;
|
|
amplitude *= 2;
|
|
frequency /= 2;
|
|
}
|
|
return sum;
|
|
}
|
|
}
|
|
|
|
public sealed class CombinedNoise : Noise {
|
|
|
|
readonly Noise noise1, noise2;
|
|
public CombinedNoise( Noise noise1, Noise noise2 ) {
|
|
this.noise1 = noise1;
|
|
this.noise2 = noise2;
|
|
}
|
|
|
|
public override double Compute( double x, double y ) {
|
|
double offset = noise2.Compute( x, y );
|
|
return noise1.Compute( x + offset, y );
|
|
}
|
|
}
|
|
}
|