/// <summary>
/// Obtient une valeur de bruit combinée des bruits passés en paramètres, selon une certaine formule magique :p
/// </summary>
/// <param name="reparitionNoise"></param>
/// <param name="noiseHigh"></param>
/// <param name="noiseLow"></param>
/// <returns></returns>
public static float GetMultiNoiseValue(NoiseBase repartitionNoise, NoiseBase noiseHigh, NoiseBase noiseLow,
float x, float y, float z)
{
if (repartitionNoise is WhiteNoise)
{
return(repartitionNoise.GetValue(x, y, z));
}
else
{
if (s_cache.ContainsKey(new Vector3(x, y, z)))
{
return(s_cache[new Vector3(x, y, z)]);
}
}
// Noise modélisant les endroits où sont placés les continents.
float continentNoise = s_continentNoise.GetValue(x, y, z);
// Noise modélisant les endroits où sont placées les montagnes.
float mountainsRepNoise = s_mountainsRepNoise.GetValue(x, y, z);
// Noise modélisant les montagnes.
float mountainsNoise = s_mountainsNoise.GetValue(x, y, z);
// Noise modélisant les détails de la surface au sol.
float ridgesNoise = s_ridgesNoise.GetValue(x, y, z);
float bumpNoise = s_bumpNoise.GetValue(x, y, z);
// Noise permettant la répartition des reliefs ridges / bump.
float reliefRepartitionNoise = s_reliefRepartitionNoise.GetValue(x, y, z);
// Noise modélisant la taille des plages.
float beachNoise = s_beachHeightNoise.GetValue(x, y, z);
float adjustedContinentNoise = continentNoise - 0.3f; // 0.3f
// 0.02 pour des côtes, 0.1 pour des plages
float beachValue = Math.Min(0.050f, Math.Max((beachNoise + 0.5f) / 500.0f, 0.020f));
// "Coupe" les continents lorsqu'ils dépassent la taille de la plage.
float continentValue = Math.Min(adjustedContinentNoise, beachValue);
float continent = continentValue * 1000;
// Mountains
float interpMin = 0.0f;
float interpMax = 0.5f;
float interpValue = Math.Min(interpMax, Math.Max(interpMin, adjustedContinentNoise));
float mountainsModulation = lerp(interpMin, interpMax, interpValue) * Math.Max(0, mountainsRepNoise);
// Crée des montagnes seulement là où le bruit de répartition est élevé.
float mountains = mountainsModulation * mountainsNoise * 2400;
mountains = MountainShapeFunc(40, 80, 1, mountains);
// Ridges
float ridges = Math.Max(0f, ridgesNoise) * 75; // 250
float bumps = Math.Max(0f, bumpNoise) * 50; // 125
float relief = lerp(bumps, ridges, Math.Max(0, Math.Min(1, reliefRepartitionNoise))) * 5;
// Valeur finale du bruit.
float value = continent + relief + mountains; // + relief + mountains; // +relief
s_cache[new Vector3(x, y, z)] = value * World.Planet.AltitudeScale;
return(value * World.Planet.AltitudeScale);
}
/// <summary>
/// Génère une heighmap à partir d'un bruit Ridged Multifratcal.
/// Version parrallélisée.
/// </summary>
/// <param name="size"></param>
/// <returns></returns>
public static unsafe float[,] GenerateMultiNoiseSleep(int size, NoiseParameters repartitionNoiseParams,
NoiseParameters noiseHighParams,
NoiseParameters noiseLowParams)
{
Random rand = new Random();
float[,] heightmap = new float[size, size];
// Création des bruits.
NoiseBase repartitionNoise = repartitionNoiseParams.CreateNoise();
NoiseBase noiseHigh = noiseHighParams.CreateNoise();
NoiseBase noiseLow = noiseLowParams.CreateNoise();
// Donne une liste de tâches à effectuer pour chaque core.
int taskSize = size;
int taskStart = 0;
int taskEnd = taskSize;
for (int x = taskStart; x < taskEnd; x++)
{
for (int y = 0; y < size; y++)
{
float sx = LinearInterp(repartitionNoiseParams.NoiseStart.X, repartitionNoiseParams.NoiseEnd.X, x / (float)(size - 1));
float sy = LinearInterp(repartitionNoiseParams.NoiseStart.Y, repartitionNoiseParams.NoiseEnd.Y, y / (float)(size - 1));
// Obtention des valeurs des bruits.
float repartition = repartitionNoise.GetValue(sx, sy, 0);
float valueHigh = noiseHigh.GetValue(sx, sy, 0);
float valueLow = noiseLow.GetValue(sx, sy, 0);
// Interpolation linéaire entre value low et value high de coefficient donné par le bruit de
// répartition.
float value = (float)Math.Log(Math.Max(0.8, 1 + valueLow)) * 5 + valueHigh * 25 + repartition * 3;
heightmap[x, y] = value;
}
}
return(heightmap);
}
/// <summary>
/// Génère une heighmap à partir d'un bruit Ridged Multifratcal.
/// </summary>
/// <param name="size"></param>
/// <returns></returns>
public static float[,] Generate(int size, NoiseParameters parameters)
{
NoiseBase noise = parameters.CreateNoise();
Random rand = new Random();
float[,] heightmap = new float[size, size];
for (int x = 0; x < size; x++)
{
for (int y = 0; y < size; y++)
{
float value = (float)noise.GetValue(
LinearInterp(parameters.NoiseStart.X, parameters.NoiseEnd.X, x / (float)(size - 1)),
LinearInterp(parameters.NoiseStart.Y, parameters.NoiseEnd.Y, y / (float)(size - 1)),
0.0f);
heightmap[x, y] = value;
}
}
return(heightmap);
}
/// <summary>
/// Obtient une valeur de bruit combinée des bruits passés en paramètres, selon une certaine formule magique :p
/// </summary>
/// <param name="reparitionNoise"></param>
/// <param name="noiseHigh"></param>
/// <param name="noiseLow"></param>
/// <returns></returns>
public static float GetMultiNoiseValue(NoiseBase repartitionNoise, NoiseBase noiseHigh, NoiseBase noiseLow,
float x, float y, float z)
{
if (repartitionNoise is WhiteNoise)
return repartitionNoise.GetValue(x, y, z);
else
{
if (s_cache.ContainsKey(new Vector3(x, y, z)))
return s_cache[new Vector3(x, y, z)];
}
// Noise modélisant les endroits où sont placés les continents.
float continentNoise = s_continentNoise.GetValue(x, y, z);
// Noise modélisant les endroits où sont placées les montagnes.
float mountainsRepNoise = s_mountainsRepNoise.GetValue(x, y, z);
// Noise modélisant les montagnes.
float mountainsNoise = s_mountainsNoise.GetValue(x, y, z);
// Noise modélisant les détails de la surface au sol.
float ridgesNoise = s_ridgesNoise.GetValue(x, y, z);
float bumpNoise = s_bumpNoise.GetValue(x, y, z);
// Noise permettant la répartition des reliefs ridges / bump.
float reliefRepartitionNoise = s_reliefRepartitionNoise.GetValue(x, y, z);
// Noise modélisant la taille des plages.
float beachNoise = s_beachHeightNoise.GetValue(x, y, z);
float adjustedContinentNoise = continentNoise - 0.3f; // 0.3f
// 0.02 pour des côtes, 0.1 pour des plages
float beachValue = Math.Min(0.050f, Math.Max((beachNoise + 0.5f) / 500.0f, 0.020f));
// "Coupe" les continents lorsqu'ils dépassent la taille de la plage.
float continentValue = Math.Min(adjustedContinentNoise, beachValue);
float continent = continentValue * 1000;
// Mountains
float interpMin = 0.0f;
float interpMax = 0.5f;
float interpValue = Math.Min(interpMax, Math.Max(interpMin, adjustedContinentNoise));
float mountainsModulation = lerp(interpMin, interpMax, interpValue) * Math.Max(0, mountainsRepNoise);
// Crée des montagnes seulement là où le bruit de répartition est élevé.
float mountains = mountainsModulation * mountainsNoise * 2400;
mountains = MountainShapeFunc(40, 80, 1, mountains);
// Ridges
float ridges = Math.Max(0f, ridgesNoise) * 75; // 250
float bumps = Math.Max(0f, bumpNoise) * 50; // 125
float relief = lerp(bumps, ridges, Math.Max(0, Math.Min(1, reliefRepartitionNoise))) * 5;
// Valeur finale du bruit.
float value = continent + relief + mountains; // + relief + mountains; // +relief
s_cache[new Vector3(x, y, z)] = value * World.Planet.AltitudeScale;
return value * World.Planet.AltitudeScale;
}
