private static void CreateImage(NoiseConfig config, HeightmapLayer layer, WaterLayer waterLayer)
{
var bmp = new Bitmap(config.Size, config.Size);
var maxDepth = waterLayer.Waterline - layer.MinHeight;
var maxHeight = layer.MaxHeight - waterLayer.Waterline;
for (var x = 0; x < config.Size; x++)
{
for (var y = 0; y < config.Size; y++)
{
if (waterLayer.GetCell(x, y))
{
var depth = waterLayer.Waterline - layer.GetCell(x, y);
var g = 255 - (byte)(255 * (depth / maxDepth));
var b = 255 - (byte)(100 * (depth / maxDepth));
bmp.SetPixel(x, y, Color.FromArgb(0, g, b));
}
else
{
var height = layer.GetCell(x, y) - waterLayer.Waterline;
var b = (byte)(50 * height / maxHeight);
var r = (byte)(255 * height / maxHeight);
var g = 175 - (byte)(50 * height / maxHeight);
bmp.SetPixel(x, y, Color.FromArgb(r, g, b));
}
}
}
var codec = GetEncoder(ImageFormat.Jpeg);
var filename = "test.jpg";
bmp.Save(filename, codec, GetEncoderParameters());
}
public HeightmapLayer generateLayer(int weight)
{
Random.InitState(seed);
float[,] matrix = new float[xSize, ySize];
float x0 = Random.value * 1000;
float y0 = Random.value * 1000;
for (int y = 0; y < ySize; y += frequency)
{
for (int x = 0; x < xSize; x += frequency)
{
float noise = Mathf.PerlinNoise(
(x0 + x * samplingScale),
(y0 + y * samplingScale)
);
for (int yy = 0; yy < frequency; yy++)
{
for (int xx = 0; xx < frequency; xx++)
{
matrix [x + xx, y + yy] = noise;
}
}
}
}
HeightmapLayer l = new HeightmapLayer(xSize, ySize, matrix, weight);
return(l);
}
static void Main(string[] args)
{
//var dsConfig = new DiamondSquareConfig(12, 0.67f);
var pnConfig1 = new NoiseConfig(2000, 0.7);
var generator1 = new Noise(pnConfig1);
var h1 = generator1.GenerateAsync();
var pnConfig2 = new NoiseConfig(2000, 0.25);
var generator2 = new Noise(pnConfig2);
var h2 = generator2.GenerateAsync();
var hlayer1 = new HeightmapLayer(h1.Result);
var hlayer2 = new HeightmapLayer(h2.Result);
var hlayerCells = HeightmapLayer.Overlay(hlayer1, hlayer2, new OverlayFloatSum());
var hlayer = new HeightmapLayer(
HeightmapLayer.NormalizeHeights(
new HeightmapLayer(hlayerCells)));
var stopWatch = new Stopwatch();
stopWatch.Start();
var m = new Map();
m.AddLayer <HeightmapLayer, float>(hlayer);
var waterLine = WaterLayer.GetWaterlineFromPercentage(hlayer, 0.35f);
var waterLayer = new WaterLayer(hlayer, waterLine);
m.AddLayer <WaterLayer, bool>(waterLayer);
CreateImage(pnConfig1, hlayer, waterLayer);
stopWatch.Stop();
Debug.WriteLine(stopWatch.Elapsed);
}
public void TestGetCell()
{
var heights = _heightsTask.GetAwaiter().GetResult();
var layer = new HeightmapLayer(heights);
Assert.Equal(heights[0, 1], layer.GetCell(0, 1));
}
public void addLayer(HeightmapLayer newLayer, float lowerLimit, float upperLimit)
{
float newWeightRatio;
float oldWeight;
float newValue;
if (totalWeight == 0)
{
oldWeight = 0;
newWeightRatio = newLayer.weight;
}
else
{
oldWeight = 1;
newWeightRatio = (float)newLayer.weight / (float)totalWeight;
}
for (int y = 0; y < ySize; y++)
{
for (int x = 0; x < xSize; x++)
{
newValue = (grid [x, y] + newLayer.layer[x, y] * newWeightRatio) / (oldWeight + newWeightRatio);
if (newValue >= lowerLimit & newValue <= upperLimit)
{
grid [x, y] = newValue;
}
}
}
totalWeight += newLayer.weight;
}
public void TestMaxHeight()
{
var heights = _heightsTask.GetAwaiter().GetResult();
var layer = new HeightmapLayer(heights);
var maxHeight = layer.Select(h => h.Data).Concat(new[] { float.MinValue }).Max();
Assert.Equal(maxHeight, layer.MaxHeight);
}
public HeightmapLayer generateLayer(int weight)
{
Random.InitState(seed);
float x0 = Random.value * 10000;
float y0 = Random.value * 10000;
float[,] matrix = new float[xSize, ySize];
Vector2[] points = new Vector2[numPoints];
float[] values = new float[numPoints];
for (int i = 0; i < numPoints; i++)
{
points [i] = new Vector2(Random.Range(0, xSize - 1), Random.Range(0, ySize - 1));
float v = Mathf.PerlinNoise(x0 + points [i].x / 128f * samplingScale, y0 + points [i].y / 128f * samplingScale);
v = Mathf.Min(v, 1f);
v = Mathf.Max(v, 0f);
values [i] = v;
}
bool checkAcross;
for (int y = 0; y < ySize; y++)
{
for (int x = 0; x < xSize; x++)
{
checkAcross = true;
float minD = xSize * ySize;
float edgeDistance = Mathf.Min(x, xSize - x);
int closest = -1;
for (int i = 0; i < numPoints; i++)
{
float d = wraparoundDistance(points [i], new Vector2(x, y), xSize, checkAcross);
if (d <= minD)
{
closest = i;
minD = d;
}
if (d < edgeDistance)
{
checkAcross = false;
}
}
matrix [x, y] = values [closest];
}
}
HeightmapLayer l = new HeightmapLayer(xSize, ySize, matrix, weight);
return(l);
}
public void TestOverlay()
{
var pnConfig1 = new NoiseConfig(100, 0.7);
var generator1 = new Noise(pnConfig1);
var h1 = generator1.GenerateAsync();
var pnConfig2 = new NoiseConfig(100, 0.25);
var generator2 = new Noise(pnConfig2);
var h2 = generator2.GenerateAsync();
var hlayer1 = new HeightmapLayer(h1.Result);
var hlayer2 = new HeightmapLayer(h2.Result);
var hlayerCells = HeightmapLayer.Overlay(hlayer1, hlayer2, new OverlayFloatSum());
var hlayer = new HeightmapLayer(hlayerCells);
Assert.Equal(h1.Result[50, 50] + hlayer2.GetCell(50, 50), hlayer.GetCell(50, 50));
}
public HeightmapLayer generateLayer(int weight)
{
float[,] matrix = new float[xSize, ySize];
Random.InitState(seed);
for (int y = 0; y < ySize; y += frequency)
{
for (int x = 0; x < xSize; x += frequency)
{
float noise = Random.value;
for (int yy = 0; yy < frequency; yy++)
{
for (int xx = 0; xx < frequency; xx++)
{
matrix [x + xx, y + yy] = noise;
}
}
}
}
HeightmapLayer l = new HeightmapLayer(xSize, ySize, matrix, weight);
return(l);
}
public void addLayer(HeightmapLayer newLayer)
{
float newWeightRatio;
float oldWeight;
if (totalWeight == 0)
{
oldWeight = 0;
newWeightRatio = newLayer.weight;
}
else
{
oldWeight = 1;
newWeightRatio = (float)newLayer.weight / (float)totalWeight;
}
for (int y = 0; y < ySize; y++)
{
for (int x = 0; x < xSize; x++)
{
grid [x, y] = (grid [x, y] + newLayer.layer[x, y] * newWeightRatio) / (oldWeight + newWeightRatio);
}
}
totalWeight += newLayer.weight;
}
