private Image getPlanetSurface()
{
int startx = rand.Next(0, 94544);
int starty = rand.Next(0, 94544);
Color[,] colors = new Color[800, 600];
NoiseMap mapr = Utils.getNoiseMap(startx, starty, 12, 12, 3.1, 0.9);
for (int i = 0; i < 800; i++)
{
for (int j = 0; j < 600; j++)
{
byte r = Utils.NormNoise(mapr.GetValue(i, j));
colors[i, j] = new Color(r, r, r);
}
}
GradientBuilder grad = new GradientBuilder();
Color grey = new Color(150, 150, 150);
grad.AddGradient(new Gradient(0, grey));
grad.AddGradient(new Gradient(255, Color.White));
grad.PrepareGradients();
grad.SourceImage = new Image(colors);
return(grad.Render());
}
internal override void GenerateColorMap(int height)
{
var width = 2 * height;
if (HasAtmosphere && TemperatureNoiseMap == null)
{
GenerateTemperatureMap(height);
}
else if (HeightNoiseMap == null)
{
GenerateHeightMap(height);
}
var builder = new SphereNoiseMapBuilder();
builder.SetDestSize(width, height);
builder.SetBounds(-90, 90, -180, 180);
ColorNoiseMap = new NoiseMap();
builder.SourceModule = ColorNoiseModule;
builder.DestNoiseMap = ColorNoiseMap;
builder.Build();
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var value = ColorNoiseMap.GetValue(x, y);
value = (value - MinHeight) / (MaxHeight - MinHeight);
ColorNoiseMap.SetValue(x, y, value);
}
}
}
private Image getMCNoise(int startx, int starty, float down, string rgb)
{
Color[,] colors = new Color[800, 600];
NoiseMap mapr = Utils.getNoiseMap(startx, starty, 6, 6, 2.5, 0.5);
NoiseMap mapa = Utils.getNoiseMap(startx + 300, starty + 300, 3, 3, 0.7, 0.3);
for (int i = 0; i < 800; i++)
{
for (int j = 0; j < 600; j++)
{
byte r = Utils.NormNoise(mapr.GetValue(i, j));
byte a = Utils.NormNoise(mapa.GetValue(i, j) - down);
if (rgb == "R")
{
colors[i, j] = new Color(r, 0, 0, a);
}
else if (rgb == "G")
{
colors[i, j] = new Color(0, r, 0, a);
}
else
{
colors[i, j] = new Color(0, 0, r, a);
}
}
}
return(new Image(colors));
}
private Image getPlanetSurface()
{
int startx = rand.Next(0, 94544);
int starty = rand.Next(0, 94544);
Color[,] colors = new Color[800, 600];
NoiseMap mapr = Utils.getNoiseMap(startx, starty, 6, 6, 2.7, 0.8);
for (int i = 0; i < 800; i++)
{
for (int j = 0; j < 600; j++)
{
byte r = Utils.NormNoise(mapr.GetValue(i, j));
colors[i, j] = new Color(r, r, r);
}
}
GradientBuilder grad = new GradientBuilder();
grad.AddGradient(new Gradient(0, Color.Gray));
grad.AddGradient(new Gradient(20, Color.OrangeRed));
grad.AddGradient(new Gradient(225, Color.Orange));
grad.AddGradient(new Gradient(255, Color.LightGray));
grad.PrepareGradients();
grad.SourceImage = new Image(colors);
return(grad.Render());
}
private PixelColor[,] DrawNoiseMap(IAlgorithmTarget target, PixelColor[,] source, NoiseMap noiseMap, PixelColor baseColor, PixelColor shapeColor, double cutoffValue)
{
var random = new Random();
float random1 = (float)random.NextDouble() * random.Next(-1, 1);
float random2 = (float)random.NextDouble() * random.Next(-1, 1);
float upperBounds = Math.Max(random1, random2);
float lowerBounds = Math.Min(random1, random2);
float boundsDistance = upperBounds - lowerBounds;
target.AlgorithmPixels.ForEach
(
pixel =>
{
var position = pixel.Position;
int x = (int)position.X, y = (int)position.Y;
var value = noiseMap.GetValue(x, y);
value = value.Clamp(lowerBounds, upperBounds);
var distanceFromLowerBounds = value - lowerBounds;
var offsetValue = (boundsDistance == 0.0f) ? 0.0f : distanceFromLowerBounds / boundsDistance;
//source[y, x] = ((value * 100) >= cutoffValue) ? shapeColor.Blend(baseColor, value) : baseColor;
source[y, x] = shapeColor.Blend(baseColor, offsetValue);
}
);
return(source);
}
private void GenerateTemperatureMap(int height)
{
var width = 2 * height;
var builder = new SphereNoiseMapBuilder();
builder.SetDestSize(width, height);
builder.SetBounds(-90, 90, -180, 180);
TemperatureNoiseMap = new NoiseMap();
builder.SourceModule = TemperatureNoiseModule;
builder.DestNoiseMap = TemperatureNoiseMap;
builder.Build();
var min = 10.0f;
var max = -10.0f;
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var value = TemperatureNoiseMap.GetValue(x, y);
if (value < min)
{
min = value;
}
else if (value > max)
{
max = value;
}
}
}
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var value = TemperatureNoiseMap.GetValue(x, y);
value = (value - min) / (max - min);
value = 0.75f + 0.25f * value;
value *= (float)EffectiveTemperature;
TemperatureNoiseMap.SetValue(x, y, value);
}
}
}
private void GenerateHeightMap(int height)
{
var width = 2 * height;
var builder = new SphereNoiseMapBuilder();
builder.SetDestSize(width, height);
builder.SetBounds(-90, 90, -180, 180);
HeightNoiseMap = new NoiseMap();
builder.SourceModule = HeightNoiseModule;
builder.DestNoiseMap = HeightNoiseMap;
builder.Build();
MinHeight = 10.0f;
MaxHeight = -10.0f;
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var value = HeightNoiseMap.GetValue(x, y);
if (value < MinHeight)
{
MinHeight = value;
}
else if (value > MaxHeight)
{
MaxHeight = value;
}
}
}
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var value = HeightNoiseMap.GetValue(x, y);
value = (value - MinHeight) / (MaxHeight - MinHeight);
HeightNoiseMap.SetValue(x, y, value);
}
}
}
private void GenerateTemperatureMap(int height)
{
var width = 2 * height;
if (HeightNoiseMap == null)
{
GenerateHeightMap(height);
}
var builder = new SphereNoiseMapBuilder();
builder.SetDestSize(width, height);
builder.SetBounds(-90, 90, -180, 180);
TemperatureNoiseMap = new NoiseMap();
builder.SourceModule = TemperatureNoiseModule;
builder.DestNoiseMap = TemperatureNoiseMap;
builder.Build();
MinTemperature = 1000000.0f;
MaxTemperature = 0.0f;
var solarHeat = Pow(SurfaceTemperature, 4);
var extraHeat = Pow(GeothermalTemperature, 4) + Pow(GreenhouseTemp, 4);
var coldness = 1 - (float)Random.Uniform("coldness", Pow(extraHeat / (solarHeat + extraHeat), 0.25), 1);
if (HasAtmosphere)
{
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var heat = extraHeat + solarHeat * 2 * Sin(PI * y / height);
var temperature = (float)Pow(heat, 0.25);
temperature *= 1 - coldness * HeightNoiseMap.GetValue(x, y);
if (temperature < MinTemperature)
{
MinTemperature = temperature;
}
else if (temperature > MaxTemperature)
{
MaxTemperature = temperature;
}
temperature *= 1 + 0.05f * (TemperatureNoiseMap.GetValue(x, y) - 1);
TemperatureNoiseMap.SetValue(x, y, temperature);
}
}
}
}
private Image getNoise(int startx, int starty, float down)
{
Color[,] colors = new Color[800, 600];
NoiseMap mapr = Utils.getNoiseMap(startx, starty, 3, 3, 2.5, 0.5);
NoiseMap mapg = Utils.getNoiseMap(startx + 100, starty + 100, 3, 3, 2.5, 0.5);
NoiseMap mapb = Utils.getNoiseMap(startx + 200, starty + 200, 3, 3, 2.5, 0.5);
NoiseMap mapa = Utils.getNoiseMap(startx + 700, starty + 700, 2, 2, 0.7, 0.3);
for (int i = 0; i < 800; i++)
{
for (int j = 0; j < 600; j++)
{
byte r = Utils.NormNoise(mapr.GetValue(i, j));
byte g = Utils.NormNoise(mapg.GetValue(i, j));
byte b = Utils.NormNoise(mapb.GetValue(i, j));
byte a = Utils.NormNoise(mapa.GetValue(i, j) - (down));
colors[i, j] = new Color(r, g, b, a);
}
}
return(new Image(colors));
}
private Image getPlanetSurface(int startx, int starty)
{
Color[,] colors = new Color[800, 600];
NoiseMap mapr = Utils.getNoiseMap(startx, starty, 12, 12, 2.7, 0.8);
for (int i = 0; i < 800; i++)
{
for (int j = 0; j < 600; j++)
{
byte r = Utils.NormNoise(mapr.GetValue(i, j));
colors[i, j] = new Color(r, r, r);
}
}
GradientBuilder grad = new GradientBuilder();
grad.AddGradient(new Gradient(0, Color.Blue));
grad.AddGradient(new Gradient(50, Color.Yellow));
grad.AddGradient(new Gradient(140, Color.Green));
grad.AddGradient(new Gradient(255, Color.White));
grad.PrepareGradients();
grad.SourceImage = new Image(colors);
return(grad.Render());
}
/*
* m - height map of moisture texture
* function biome(e, m) {
* if (e < 0.1) return OCEAN;
* if (e < 0.12) return BEACH;
*
* if (e > 0.8) {
* if (m < 0.1) return SCORCHED;
* if (m < 0.2) return BARE;
* if (m < 0.5) return TUNDRA;
* return SNOW;
* }
*
* if (e > 0.6) {
* if (m < 0.33) return TEMPERATE_DESERT;
* if (m < 0.66) return SHRUBLAND;
* return TAIGA;
* }
*
* if (e > 0.3) {
* if (m < 0.16) return TEMPERATE_DESERT;
* if (m < 0.50) return GRASSLAND;
* if (m < 0.83) return TEMPERATE_DECIDUOUS_FOREST;
* return TEMPERATE_RAIN_FOREST;
* }
*
* if (m < 0.16) return SUBTROPICAL_DESERT;
* if (m < 0.33) return GRASSLAND;
* if (m < 0.66) return TROPICAL_SEASONAL_FOREST;
* return TROPICAL_RAIN_FOREST;
* }
*/
void Generating()
{
//var mountain = BuildHeightMap(
// new ImprovedPerlin(),
// new SumFractal() {
// Frequency = 2,
// Lacunarity = 1,
// OctaveCount = 6,
// }, 0.1f);
var map = new NoiseMap();
try {
var rectangle = new Rectangle(0, 0, width, height);
var tree = CreateNoiseTree();
var builder = new PlaneNoiseMapBuilder()
{
DestNoiseMap = map,
};
builder.SourceModule = tree;
builder.SetDestSize(width, height);
builder.SetBounds(6.0, 10.0, 1.0, 5.0);
builder.EnableSeamless = false;
builder.Build();
var image = new SharpNoise.Utilities.Imaging.Image();
var renderer = new ImageRenderer()
{
SourceNoiseMap = map,
DestinationImage = image,
};
renderer.BuildTerrainGradient();
renderer.Render();
Texture = renderer.DestinationImage.ToGdiBitmap();
} catch (Exception ex) {
ex.ToString();
} finally {
ClearNoiseTree();
}
var resources = Path.Combine("../../../../D3DLab.Wpf.Engine.App/Resources/terrain/");
// using (var bitmap = new System.Drawing.Bitmap(Path.Combine(resources, "mask_circular_256x256.png"))) {
HeightMap = new Vector3[height * width];
var index = HeightMap.Length - 1;
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
//MakeIsland(ref e, x, y, 200f);
//var index = height * y + x;
var e = map.GetValue(x, y);
ReScale(ref e);
Redistribution(ref e);
HeightMap[index] = new Vector3(x, e * terrainParams.Correction, y);
MaxHeight = Math.Max(HeightMap[index].Y, MaxHeight);
MinHeight = Math.Min(HeightMap[index].Y, MinHeight);
index--;
}
}
//}
IsGenerated = true;
}
internal override void GenerateColorMap(int height)
{
var width = 2 * height;
var builder = new SphereNoiseMapBuilder();
ColorNoiseMap = new NoiseMap();
builder.SourceModule = ColorNoiseModule;
builder.SetDestSize(width, height);
builder.DestNoiseMap = ColorNoiseMap;
builder.SetBounds(-90, 90, -180, 180);
builder.Build();
HeightNoiseMap = new NoiseMap();
builder.SourceModule = HeightNoiseModule;
builder.SetDestSize(1, height);
builder.DestNoiseMap = HeightNoiseMap;
builder.SetBounds(-90, 90, 0, 0.000001);
builder.Build();
var min = 1000.0f;
var max = -1000.0f;
var factor = 0.3f;
var values = new float[height];
for (var y = 0; y < height; y++)
{
var value = (1 - factor) * HeightNoiseMap.GetValue(0, y) + factor * HeightNoiseMap.GetValue(0, height - y);
values[y] = value;
if (value < min)
{
min = value;
}
else if (value > max)
{
max = value;
}
}
for (var y = 0; y < height; y++)
{
var value = values[y];
value = (value - min) / (max - min);
values[y] = value;
}
min = 1000.0f;
max = -1000.0f;
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var value = ColorNoiseMap.GetValue(x, y);
if (value < min)
{
min = value;
}
else if (value > max)
{
max = value;
}
}
}
var turbulence = (float)Sqrt(0.003 * Mass / EarthMass);
var d = turbulence * 0.03f;
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
var value = ColorNoiseMap.GetValue(x, y);
value = (value - min) / (max - min);
value = (1 - 2 * d) * y / height + d + d * value;
var i = (int)(value * height);
if (i < 0)
{
i = 0;
}
if (i > height - 1)
{
i = height - 1;
}
value = values[i];
var a = (float)Sin(PI * y / height);
a *= a * a;
value *= a;
value *= turbulence;
ColorNoiseMap.SetValue(x, y, value);
}
}
}
