public void NoiseIsPeriodicWithUserPeriod()
{
Random random = new Random(1234567);
for (int i = 0; i < 100; i++)
{
var v = random.NextVector4D(-1000, 1000);
var randomPeriod = random.NextVector4D(2, 444);
var px = (int)randomPeriod.X;
var py = (int)randomPeriod.Y;
var pz = (int)randomPeriod.Z;
var pw = (int)randomPeriod.W;
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, px), PerlinNoise.Compute(v.X - px, px)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, px), PerlinNoise.Compute(v.X + px, px)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, px, py), PerlinNoise.Compute(v.X - px, v.Y - py, px, py)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, px, py), PerlinNoise.Compute(v.X + px, v.Y + py, px, py)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, v.Z, px, py, pz), PerlinNoise.Compute(v.X - px, v.Y - py, v.Z - pz, px, py, pz)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, v.Z, px, py, pz), PerlinNoise.Compute(v.X + px, v.Y + py, v.Z + pz, px, py, pz)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, v.Z, v.W, px, py, pz, pw), PerlinNoise.Compute(v.X - px, v.Y - py, v.Z - pz, v.W - pw, px, py, pz, pw)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, v.Z, v.W, px, py, pz, pw), PerlinNoise.Compute(v.X + px, v.Y + py, v.Z + pz, v.W + pw, px, py, pz, pw)));
}
}
public void NoiseAtIntegerPositionsIs0()
{
// Test some arbitrary integer points.
for (float x = 0; x < 255; x += 17f)
{
Assert.AreEqual(0, PerlinNoise.Compute(x)); // Zero at integer positions
Assert.AreEqual(0, PerlinNoise.Compute(x, 14)); // Zero at integer positions
for (float y = 0; y < 255; y += 15f)
{
Assert.AreEqual(0, PerlinNoise.Compute(x, y)); // Zero at integer positions
Assert.AreEqual(0, PerlinNoise.Compute(x, y, 16, 18)); // Zero at integer positions
for (float z = 0; z < 255; z += 17f)
{
Assert.AreEqual(0, PerlinNoise.Compute(x, y, z)); // Zero at integer positions
Assert.AreEqual(0, PerlinNoise.Compute(x, y, z, 7, 99, 2055)); // Zero at integer positions
for (float w = 0; w < 255; w += 35f)
{
Assert.AreEqual(0, PerlinNoise.Compute(x, y, z, w)); // Zero at integer positions
Assert.AreEqual(0, PerlinNoise.Compute(x, y, z, w, 100, 14, 4, 234)); // Zero at integer positions
}
}
}
}
}
public void Process(Map map, MapInfo info)
{
var noise = new PerlinNoise(info.MapId);
for (int i = 0; i < map.HeightMap.Width; i++)
{
for (int j = 0; j < map.HeightMap.Height; j++)
{
foreach (var layer in info.Settings.Layout.TerrainLayers.Where(l => l.IsDetail == Detail))
{
if (info.IsCancellationRequested)
{
return;
}
noise.Amplitude = layer.Elevation;
noise.Frequency = layer.Jaggedness;
noise.Persistence = layer.Ruggedness;
noise.Octaves = layer.LevelOfDetail;
float normalizedHeight = noise.Compute(i, j, info.MapId);
float height = normalizedHeight * layer.Height;
map.HeightMap[i, j] += (byte)height;
}
}
}
}
public void NoiseRange4D()
{
double min = double.MaxValue;
double max = double.MinValue;
var random = new Random(15485863);
for (int i = 0; i < 1000000; i++)
{
var v = random.NextVector4(0, 255);
var n = PerlinNoise.Compute(v.X, v.Y, v.Z, v.W);
min = Math.Min(min, n);
max = Math.Max(max, n);
}
Assert.IsTrue(min < 0 && min >= -1);
Assert.IsTrue(max > 0 && max <= 1);
}
public static Texture2D GetNoiseTexture(IGraphicsService graphicsService, int size, int numberOfOscillations)
{
if (graphicsService == null)
{
throw new ArgumentNullException("graphicsService");
}
if (size < 1)
{
throw new ArgumentOutOfRangeException("size", "size must be greater than 0.");
}
if (numberOfOscillations < 1)
{
throw new ArgumentOutOfRangeException("numberOfOscillations", "numberOfOscillations must be greater than 0.");
}
var data = new Color[size * size];
double f = numberOfOscillations / (double)size;
for (int y = 0; y < size; y++)
{
for (int x = 0; x < size; x++)
{
double nx = PerlinNoise.Compute(f * x, f * y, 0.0 / 4.0 * size, numberOfOscillations, numberOfOscillations, numberOfOscillations);
double ny = PerlinNoise.Compute(f * x, f * y, 1.0 / 4.0 * size, numberOfOscillations, numberOfOscillations, numberOfOscillations);
double nz = PerlinNoise.Compute(f * x, f * y, 2.0 / 4.0 * size, numberOfOscillations, numberOfOscillations, numberOfOscillations);
double nw = PerlinNoise.Compute(f * x, f * y, 3.0 / 4.0 * size, numberOfOscillations, numberOfOscillations, numberOfOscillations);
data[y * size + x] = new Color(
(byte)((nx / 2 + 0.5) * 255),
(byte)((ny / 2 + 0.5) * 255),
(byte)((nz / 2 + 0.5) * 255),
(byte)((nw / 2 + 0.5) * 255));
}
}
var texture = new Texture2D(graphicsService.GraphicsDevice, size, size, false, SurfaceFormat.Color);
texture.SetData(data);
return(texture);
}
public void NoiseIsPeriodicWith256()
{
Random random = new Random(1234567);
for (int i = 0; i < 100; i++)
{
var v = random.NextVector4D(-1000, 1000);
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X), PerlinNoise.Compute(v.X - 256)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X), PerlinNoise.Compute(v.X + 256)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y), PerlinNoise.Compute(v.X - 256, v.Y - 256)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y), PerlinNoise.Compute(v.X + 256, v.Y + 256)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, v.Z), PerlinNoise.Compute(v.X - 256, v.Y - 256, v.Z - 256)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, v.Z), PerlinNoise.Compute(v.X + 256, v.Y + 256, v.Z + 256)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, v.Z, v.W), PerlinNoise.Compute(v.X - 256, v.Y - 256, v.Z - 256, v.W - 256)));
Assert.IsTrue(Numeric.AreEqual(PerlinNoise.Compute(v.X, v.Y, v.Z, v.W), PerlinNoise.Compute(v.X + 256, v.Y + 256, v.Z + 256, v.W + 256)));
}
}
private void SetTexture(int x, int y, PerlinNoise noise, Texture baseTexture, IEnumerable <TextureData> overlayTextures)
{
SetTexture(x, y, baseTexture);
SetTexture(x, y + 1, baseTexture);
SetTexture(x + 1, y, baseTexture);
SetTexture(x + 1, y + 1, baseTexture);
map.Tiles[x, y].BaseTexture = baseTexture.GetTileIndex(x, y);
foreach (var t in overlayTextures)
{
noise.Frequency = t.Granularity;
if (noise.Compute(x, y, info.MapId) > 0.5)
{
SetTexture(x, y, t.Texture);
SetTexture(x, y + 1, t.Texture);
SetTexture(x + 1, y, t.Texture);
SetTexture(x + 1, y + 1, t.Texture);
map.Tiles[x, y].BaseTexture = t.Texture.GetTileIndex(x, y);
}
}
}
