protected double GradCoherentNoise(double x, double y, int seed, MyNoiseQuality quality)
{
int x0 = MathHelper.Floor(x);
int y0 = MathHelper.Floor(y);
int x1 = x0 + 1;
int y1 = y0 + 1;
double xs = 0;
double ys = 0;
switch (quality)
{
case MyNoiseQuality.Low:
xs = x - x0;
ys = y - y0;
break;
case MyNoiseQuality.Standard:
xs = MathHelper.SCurve3(x - x0);
ys = MathHelper.SCurve3(y - y0);
break;
case MyNoiseQuality.High:
xs = MathHelper.SCurve5(x - x0);
ys = MathHelper.SCurve5(y - y0);
break;
}
return MathHelper.Lerp(MathHelper.Lerp(GradNoise(x, y, x0, y0, seed), GradNoise(x, y, x1, y0, seed), xs),
MathHelper.Lerp(GradNoise(x, y, x0, y1, seed), GradNoise(x, y, x1, y1, seed), xs), ys);
}
protected double GradCoherentNoise(double x, double y, int seed, MyNoiseQuality quality)
{
int x0 = MathHelper.Floor(x);
int y0 = MathHelper.Floor(y);
int x1 = x0 + 1;
int y1 = y0 + 1;
double xs = 0;
double ys = 0;
switch (quality)
{
case MyNoiseQuality.Low:
xs = x - x0;
ys = y - y0;
break;
case MyNoiseQuality.Standard:
xs = MathHelper.SCurve3(x - x0);
ys = MathHelper.SCurve3(y - y0);
break;
case MyNoiseQuality.High:
xs = MathHelper.SCurve5(x - x0);
ys = MathHelper.SCurve5(y - y0);
break;
}
return(MathHelper.Lerp(MathHelper.Lerp(GradNoise(x, y, x0, y0, seed), GradNoise(x, y, x1, y0, seed), xs),
MathHelper.Lerp(GradNoise(x, y, x0, y1, seed), GradNoise(x, y, x1, y1, seed), xs), ys));
}
public MyBillow(MyNoiseQuality quality = MyNoiseQuality.Standard,
int layerCount = 6,
int seed = 0,
double frequency = 1.0,
double lacunarity = 2.0,
double persistence = 0.5)
{
Quality = quality;
LayerCount = layerCount;
Seed = seed;
Frequency = frequency;
Lacunarity = lacunarity;
Persistence = persistence;
}
public MyBillow(MyNoiseQuality quality = MyNoiseQuality.Standard,
int layerCount = 6,
int seed = 0,
double frequency = 1.0,
double lacunarity = 2.0,
double persistence = 0.5)
{
Quality = quality;
LayerCount = layerCount;
Seed = seed;
Frequency = frequency;
Lacunarity = lacunarity;
Persistence = persistence;
}
public MyPerlin(MyNoiseQuality quality = MyNoiseQuality.Standard,
int octaveCount = 6,
int seed = 0,
double frequency = 1.0,
double lacunarity = 2.0,
double persistence = 0.5)
{
Quality = quality;
OctaveCount = octaveCount;
Seed = seed;
Frequency = frequency;
Lacunarity = lacunarity;
Persistence = persistence;
}
public MyPerlin(MyNoiseQuality quality = MyNoiseQuality.Standard,
int octaveCount = 6,
int seed = 0,
double frequency = 1.0,
double lacunarity = 2.0,
double persistence = 0.5)
{
Quality = quality;
OctaveCount = octaveCount;
Seed = seed;
Frequency = frequency;
Lacunarity = lacunarity;
Persistence = persistence;
}
protected double GradCoherentNoise(double x, int seed, MyNoiseQuality quality)
{
int x0 = MathHelper.Floor(x);
double xs = 0;
switch (quality)
{
case MyNoiseQuality.Low: xs = x - x0; break;
case MyNoiseQuality.Standard: xs = MathHelper.SCurve3(x - x0); break;
case MyNoiseQuality.High: xs = MathHelper.SCurve5(x - x0); break;
}
return MathHelper.Lerp(GradNoise(x, x0, seed), GradNoise(x, x0 + 1, seed), xs);
}
protected double GradCoherentNoise(double x, double y, double z, MyNoiseQuality quality)
{
int x0 = MathHelper.Floor(x);
int y0 = MathHelper.Floor(y);
int z0 = MathHelper.Floor(z);
int X = x0 & 255;
int Y = y0 & 255;
int Z = z0 & 255;
double ut = 0;
double vt = 0;
double wt = 0;
switch (quality)
{
case MyNoiseQuality.Low:
ut = x - x0;
vt = y - y0;
wt = z - z0;
break;
case MyNoiseQuality.Standard:
ut = MathHelper.SCurve3(x - x0);
vt = MathHelper.SCurve3(y - y0);
wt = MathHelper.SCurve3(z - z0);
break;
case MyNoiseQuality.High:
ut = MathHelper.SCurve5(x - x0);
vt = MathHelper.SCurve5(y - y0);
wt = MathHelper.SCurve5(z - z0);
break;
}
int A = m_perm[X] + Y;
int B = m_perm[X + 1] + Y;
int AA = m_perm[A] + Z;
int AB = m_perm[A + 1] + Z;
int BA = m_perm[B] + Z;
int BB = m_perm[B + 1] + Z;
return(MathHelper.Lerp(MathHelper.Lerp(MathHelper.Lerp(m_grad[AA], m_grad[BA], ut),
MathHelper.Lerp(m_grad[AB], m_grad[BB], ut), vt),
MathHelper.Lerp(MathHelper.Lerp(m_grad[AA + 1], m_grad[BA + 1], ut),
MathHelper.Lerp(m_grad[AB + 1], m_grad[BB + 1], ut), vt), wt));
}
public MyRidgedMultifractalFast(MyNoiseQuality quality = MyNoiseQuality.Standard,
int layerCount = 6,
int seed = 0,
double frequency = 1.0,
double gain = 2.0,
double lacunarity = 2.0,
double offset = 1.0)
{
Quality = quality;
LayerCount = layerCount;
Seed = seed;
Frequency = frequency;
Gain = gain;
Lacunarity = lacunarity;
Offset = offset;
}
public MyRidgedMultifractal(MyNoiseQuality quality = MyNoiseQuality.Standard,
int layerCount = 6,
int seed = 0,
double frequency = 1.0,
double gain = 2.0,
double lacunarity = 2.0,
double offset = 1.0)
{
Quality = quality;
LayerCount = layerCount;
Seed = seed;
Frequency = frequency;
Gain = gain;
Lacunarity = lacunarity;
Offset = offset;
}
protected double GradCoherentNoise(double x, double y, double z, MyNoiseQuality quality)
{
int x0 = MathHelper.Floor(x);
int y0 = MathHelper.Floor(y);
int z0 = MathHelper.Floor(z);
int X = x0 & 255;
int Y = y0 & 255;
int Z = z0 & 255;
double ut = 0;
double vt = 0;
double wt = 0;
switch (quality)
{
case MyNoiseQuality.Low:
ut = x - x0;
vt = y - y0;
wt = z - z0;
break;
case MyNoiseQuality.Standard:
ut = MathHelper.SCurve3(x - x0);
vt = MathHelper.SCurve3(y - y0);
wt = MathHelper.SCurve3(z - z0);
break;
case MyNoiseQuality.High:
ut = MathHelper.SCurve5(x - x0);
vt = MathHelper.SCurve5(y - y0);
wt = MathHelper.SCurve5(z - z0);
break;
}
int A = m_perm[X] + Y;
int B = m_perm[X + 1] + Y;
int AA = m_perm[A ] + Z;
int AB = m_perm[A + 1] + Z;
int BA = m_perm[B ] + Z;
int BB = m_perm[B + 1] + Z;
return MathHelper.Lerp(MathHelper.Lerp(MathHelper.Lerp(m_grad[AA] , m_grad[BA] , ut),
MathHelper.Lerp(m_grad[AB] , m_grad[BB] , ut), vt),
MathHelper.Lerp(MathHelper.Lerp(m_grad[AA + 1], m_grad[BA + 1], ut),
MathHelper.Lerp(m_grad[AB + 1], m_grad[BB + 1], ut), vt), wt);
}
protected double GradCoherentNoise(double x, MyNoiseQuality quality)
{
int x0 = MathHelper.Floor(x);
int X = x0 & 255;
double ut = 0;
switch (quality)
{
case MyNoiseQuality.Low: ut = x - x0; break;
case MyNoiseQuality.Standard: ut = MathHelper.SCurve3(x - x0); break;
case MyNoiseQuality.High: ut = MathHelper.SCurve5(x - x0); break;
}
return MathHelper.Lerp(m_grad[m_perm[X]], m_grad[m_perm[X + 1]], ut);
}
protected double GradCoherentNoise(double x, int seed, MyNoiseQuality quality)
{
int x0 = MathHelper.Floor(x);
double xs = 0;
switch (quality)
{
case MyNoiseQuality.Low: xs = x - x0; break;
case MyNoiseQuality.Standard: xs = MathHelper.SCurve3(x - x0); break;
case MyNoiseQuality.High: xs = MathHelper.SCurve5(x - x0); break;
}
return(MathHelper.Lerp(GradNoise(x, x0, seed), GradNoise(x, x0 + 1, seed), xs));
}
protected double GradCoherentNoise(double x, MyNoiseQuality quality)
{
int x0 = MathHelper.Floor(x);
int X = x0 & 255;
double ut = 0;
switch (quality)
{
case MyNoiseQuality.Low: ut = x - x0; break;
case MyNoiseQuality.Standard: ut = MathHelper.SCurve3(x - x0); break;
case MyNoiseQuality.High: ut = MathHelper.SCurve5(x - x0); break;
}
return(MathHelper.Lerp(m_grad[m_perm[X]], m_grad[m_perm[X + 1]], ut));
}
