public static float GetCanyonNoise(Vector2 position, NoiseParameters noiseParameters, FastNoise noise, CanyonParameters canyonParameters, int seed = 0)
{
//Noise Height, Value bettween CayonParameters's limits, Results
float n = 1.0f - GetFractalErosionNoise(position, noiseParameters, noise, seed);
float n2 = MathFunc.Clamp01(MathFunc.Lerp(0f, 1f, MathFunc.InverseLerp(canyonParameters.minCanyonHeight, canyonParameters.canyonPlateauHeight, n)));
float h = 0f;
float t = (canyonParameters.canyonPlateauHeight - canyonParameters.minCanyonHeight);
if (n <= canyonParameters.canyonPlateauHeight)
{
if (n >= canyonParameters.minCanyonHeight)
{
h = canyonParameters.GetValueAtHeight(n2);
return(h);
}
else
{
return(canyonParameters.minCanyonHeight - n * -3f);
}
}
else
{
//h = (n*(canyonParameters.canyonPlateauHeight-canyonParameters.minCanyonHeight)/2f)+1f;
//h = (n-t)*0.2f+t;
float x = 1f;
//h = (n)*x+(t*(x*2)+0);
h = 1 + (n - canyonParameters.canyonPlateauHeight) * 0.2f;
return(h);
}
}
public override INoiseGenerator Create(NoiseParameters noiseParameters)
{
return(new Noise.RidgedMultiFractal(
new SimplexNoise(),
noiseParameters.Octaves,
noiseParameters.Lacunarity,
noiseParameters.H,
noiseParameters.Offset,
noiseParameters.Gain));
}
public override INoiseGenerator Create(NoiseParameters noiseParameters)
{
return new Noise.RidgedMultiFractal(
new SimplexNoise(),
noiseParameters.Octaves,
noiseParameters.Lacunarity,
noiseParameters.H,
noiseParameters.Offset,
noiseParameters.Gain);
}
public static List <NoiseParameters> ReadAllNoiseParameters()
{
List <NoiseParameters> allNoiseParameters = new List <NoiseParameters>();
foreach (string file in Directory.GetFiles(NoiseParameterLocation, "*.json"))
{
string jsonContent = File.ReadAllText(file);
NoiseParameters parameter = JsonConvert.DeserializeObject <NoiseParameters>(jsonContent);
allNoiseParameters.Add(parameter);
}
return(allNoiseParameters);
}
public void TryGeneratingSavedNoiseParameters(TerrainInfo info, bool overrideSerialisedParam)
{
SerializationManager.InitializeManager();
SerializedNoiseParameters = SerializationManager.ReadAllNoiseParameters();
AllNoiseParameterNames = new string[SerializedNoiseParameters.Count];
for (int i = 0; i < SerializedNoiseParameters.Count; i++)
{
AllNoiseParameterNames[i] = SerializedNoiseParameters[i].NoiseParameterName;
}
if (overrideSerialisedParam)
{
SerializedNoiseParameter = SerializedNoiseParameters[CurrentSelectedIndexNoise];
var cp = SerializedNoiseParameters[CurrentSelectedIndexNoise];
SetCorrectNoiseParams(cp, ref info);
}
}
public static float GetFractalRidgedNoise(Vector2 position, NoiseParameters noiseParameters, FastNoise noise, int seed = 0)
{
float sum = 0f;
float freq = 1.0f, amp = 1.0f;
for (int i = 0; i < noiseParameters.octaves; i++)
{
float n = GetNoise(position * freq, noise, seed + i);
n = ((1f - MathFunc.Abs(n)) * 2f - 1);
//n = MathFunc.PingPong(n,0.5f)*2f;
sum += amp * n;
freq *= noiseParameters.lacunarity;
amp *= noiseParameters.gain;
}
return(sum);
}
private void SetCorrectNoiseParams(NoiseParameters noiseParam, ref TerrainInfo info)
{
info.ErosionType = noiseParam.ErosionType;
info.RuntimeErosion = noiseParam.RuntimeErosion;
info.NoiseScale = noiseParam.NoiseScale;
info.BaseFrequency = noiseParam.BaseFrequency;
info.Persistance = noiseParam.Persistance;
info.Lacunarity = noiseParam.Lacunarity;
info.NumberOfOctaves = noiseParam.NumberOfOctaves;
info.GlobalNoiseAddition = noiseParam.GlobalNoiseAddition;
info.Seed = noiseParam.Seed;
info.UserOffset = noiseParam.UserOffset;
info.CustomFunction = noiseParam.CustomFunction;
info.CustomExponent = noiseParam.CustomExponent;
info.TerrainTextureType = noiseParam.TerrainTextureType;
}
public static float GetFractalErosionNoise(Vector2 position, NoiseParameters noiseParameters, FastNoise noise, int seed = 0)
{
float sum = 0f;
float freq = 1.0f, amp = 1.0f;
Vector2 dsum = new Vector2(0, 0);
for (int i = 0; i < noiseParameters.octaves; i++)
{
Vector3 n = GetDerivativePerlinNoise(position * freq, noise, seed + i);
dsum += new Vector2(n.y, n.z);
sum += amp * n.x / (1 + Vector2.Dot(dsum, dsum));
freq *= noiseParameters.lacunarity;
amp *= noiseParameters.gain;
}
return(sum);
}
/*
* public NoiseParameters moistureNoise;
* public NativeArray<float> moistureNoiseValues;*/
public GenerateMapJob(int boundsCenterX, int boundsCenterY, int size, NoiseParameters nos, NativeArray <float> nvLists)
{
bX = boundsCenterX;
bY = boundsCenterY;
sz = size;
/*
* sd = nos.seed;
* amp = nos.amplitude;
* freq = nos.frequency;
* pers = nos.persistence;
* lac = nos.lacunarity;
* oct = nos.octaves;*/
noise = nos;
noiseValueList = nvLists;
}
public void GenerateNoise(NoiseParameters p, NativeArray <float> nosValues)
{
float amp = p.amplitude;
float freq = p.frequency;
int oct = p.octaves;
float lac = p.lacunarity;
float pers = p.persistence;
int sd = p.seed;
float max = 0f;
float min = float.MaxValue;
int index = 0;
for (int i = bX - sz / 2; i < bX + sz / 2; i++)
{
for (int j = bY - sz / 2; j < bY + sz / 2; j++)
{
float tempA = amp;
float tempF = freq;
nosValues[index] = 0f;
for (int k = 0; k < oct; k++)
{
nosValues[index] += Mathf.PerlinNoise(((i + sd) / ((float)sz * freq)), (j + sd) / ((float)sz * freq)) * amp;
freq *= lac;
amp *= pers;
}
amp = tempA;
freq = tempF;
if (nosValues[index] > max)
{
max = nosValues[index];
}
if (nosValues[index] < min)
{
min = nosValues[index];
}
index++;
}
}
index = 0;
for (int i = 0; i < sz; i++)
{
for (int j = 0; j < sz; j++)
{
nosValues[index] = Mathf.InverseLerp(max, min, nosValues[index]);
}
}
}
public void GenerateObjects(TerrainObject objectInfo)
{
cleanUpObjects();
int width = heightMap.GetLength(0);
int height = heightMap.GetLength(1);
NoiseParameters noiseParameters = objectInfo.noise;
float[,] noiseMap = Noise.GenerateNoiseMap(width, height, Random.Range(0, int.MaxValue),
noiseParameters.noiseScale, noiseParameters.octaves, noiseParameters.persistance, noiseParameters.lacunarity, Vector2.zero);
float startHeight = heightCurve.Evaluate(objectInfo.startHeight) * heightMultiplier;
float endHeight = heightCurve.Evaluate(objectInfo.endHeight) * heightMultiplier;
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++)
{
float y = heightCurve.Evaluate(heightMap[i, j]) * heightMultiplier;
if (y >= startHeight && y <= endHeight && noiseMap[i, j] > objectInfo.noiseThreshold)
{
Vector3 pos = new Vector3((width - 1) / -2f + i, y, (height - 1) / 2f - j) * uniformScale;
pos += new Vector3(Random.Range(-1f, 1f), 0, Random.Range(-1f, 1f)) * 0.2f;
pos += transform.position;
IslandObject obj = Instantiate(objectInfo.prefab, pos, Quaternion.identity);
obj.transform.SetParent(objectContainer, true);
obj.Generate();
// Align the rotation of the object to the normal of the terrain at that point
if (objectInfo.alignToNormal)
{
Ray ray = new Ray(pos + Vector3.up * 10, Vector3.down);
RaycastHit hitInfo;
bool hit = mesh.meshCollider.Raycast(ray, out hitInfo, Mathf.Infinity);
if (hit)
{
obj.transform.up = hitInfo.normal;
}
}
}
}
}
}
public static float GetFractalNoise(Vector2 p, NoiseParameters noiseParameters, FastNoise noise, int seed = 0)
{
noise.SetSeed(seed);
float sum = 0f;
float amp = 1.0f;
for (int i = 0; i < noiseParameters.octaves; i++)
{
noise.SetSeed(seed + i);
float n = noise.GetPerlin(p.x, p.y);
sum += n * amp;
p *= noiseParameters.lacunarity;
amp *= noiseParameters.gain;
}
return(sum);
}
public static float GetFractalAlpsNoise(Vector2 position, NoiseParameters noiseParameters, FastNoise noise, int seed = 0)
{
float warp = 1.5f;
float sum = 0f;
float freq = 1.0f, amp = 1.0f;
Vector2 dsum = new Vector2(0, 0);
for (int i = 0; i < noiseParameters.octaves; i++)
{
Vector3 n = GetDerivativePerlinNoise(position * freq, noise, seed + i);
sum += amp * (1 - MathFunc.Abs(n.x));
dsum += amp * new Vector2(n.y, n.z) * -n.x;
freq *= noiseParameters.lacunarity;
amp *= noiseParameters.gain * MathFunc.Clamp01(sum);
}
return(sum);
}
public static void SaveNoiseParameters(string name, NoiseParameters parameters)
{
if (name.Length == 0)
{
Debug.LogError(string.Format("Name cannot be empty."));
return;
}
string path = string.Format("{0}{1}.json", NoiseParameterLocation, name);
string jsonObject = JsonConvert.SerializeObject(parameters, Formatting.None, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
MaxDepth = 1
});
// User can overwrite his file
using (StreamWriter file = new StreamWriter(path)) {
file.Write(jsonObject);
}
}
/// <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);
}
public static float[,] GenerateMap(int inSize, Vector2DInt inOffset, NoiseParameters inParameters)
{
float[,] noiseMap = new float[inSize, inSize];
for (int y = 0; y < inSize; y++)
{
for (int x = 0; x < inSize; x++)
{
float sampleX = (x + (inOffset.x * inSize)) * inParameters.frequency;
float sampleY = (y + (inOffset.y * inSize)) * inParameters.frequency;
for (int i = 0; i < inParameters.octaves; i++)
{
float octaveModifier = Mathf.Pow(2, i);
noiseMap[x, y] += (1 / octaveModifier) * Mathf.PerlinNoise(sampleX * octaveModifier, sampleY * octaveModifier);
}
noiseMap[x, y] -= 0.5f;
}
}
return(noiseMap);
}
public static float GetFractalErosionRidgedNoise(Vector2 position, NoiseParameters noiseParameters, FastNoise noise, int seed = 0)
{
float sum = 0f;
float freq = 1.0f, amp = 1.0f;
Vector2 dsum = new Vector2(0, 0);
for (int i = 0; i < noiseParameters.octaves; i++)
{
Vector3 n = GetDerivativePerlinNoise(position * freq, noise, seed + i);
n.x = ((1f - MathFunc.Abs(n.x)) * 2f - 1);
n.y = ((1f - MathFunc.Abs(n.y)) * 2f - 1);
n.z = ((1f - MathFunc.Abs(n.z)) * 2f - 1);
//n.x = 1f-MathFunc.PingPong(n.x,0.5f)*2f;
//n.y = 1f-MathFunc.PingPong(n.y,0.5f)*2f;
//n.z = 1f-MathFunc.PingPong(n.z,0.5f)*2f;
//n.x = MathFunc.Pow(n.x,2);
dsum += new Vector2(n.y, n.z);
sum += amp * n.x / (1 + Vector2.Dot(dsum, dsum));
freq *= noiseParameters.lacunarity;
amp *= noiseParameters.gain;
}
return(sum);
}
public abstract INoiseGenerator Create(NoiseParameters noiseParameters);
public static float[,] GenerateNoiseMap(NoiseParameters noiseParameters, int size)
{
int seed = noiseParameters.seed;
float scale = noiseParameters.scale;
int octaves = noiseParameters.octaves;
float persistance = noiseParameters.persistance;
float lacunarity = noiseParameters.lacunarity;
float[,] noiseMap = new float[size, size];
System.Random prng = new System.Random(seed);
Vector2[] octaveOffsets = new Vector2[octaves];
for (int i = 0; i < octaves; i++)
{
float offsetX = prng.Next(-100000, 100000);
float offsetY = prng.Next(-100000, 100000);
octaveOffsets[i] = new Vector2(offsetX, offsetY);
}
if (scale <= 0)
{
scale = 0.0001f;
}
float maxNoiseHeight = float.MinValue;
float minNoiseHeight = float.MaxValue;
float halfWidth = size / 2f;
float halfHeight = size / 2f;
for (int y = 0; y < size; y++)
{
for (int x = 0; x < size; x++)
{
float amplitude = 1;
float frequency = 1;
float noiseHeight = 0;
for (int i = 0; i < octaves; i++)
{
float sampleX = (x - halfWidth) / scale * frequency + octaveOffsets[i].x;
float sampleY = (y - halfHeight) / scale * frequency + octaveOffsets[i].y;
float perlinValue = Mathf.PerlinNoise(sampleX, sampleY) * 2 - 1;
noiseHeight += perlinValue * amplitude;
amplitude *= persistance;
frequency *= lacunarity;
}
if (noiseHeight > maxNoiseHeight)
{
maxNoiseHeight = noiseHeight;
}
else if (noiseHeight < minNoiseHeight)
{
minNoiseHeight = noiseHeight;
}
noiseMap[x, y] = noiseHeight;
}
}
for (int y = 0; y < size; y++)
{
for (int x = 0; x < size; x++)
{
noiseMap[x, y] = Mathf.InverseLerp(minNoiseHeight, maxNoiseHeight, noiseMap[x, y]);
}
}
return(noiseMap);
}
public static float GetFractalInverseErosionNoise(Vector2 position, NoiseParameters noiseParameters, FastNoise noise, int seed = 0)
{
return(1f - GetFractalErosionNoise(position, noiseParameters, noise, seed) - 1f);
}
/// <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;
}
public abstract INoiseGenerator Create(NoiseParameters noiseParameters);
/// <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;
}
private JobHandle GenerateNewChunk(chunkCenter c, int size, List <NativeArray <float> > noiseLists, NoiseParameters nosP)
{
NativeArray <float> NoiseValues = new NativeArray <float>(size * size, Allocator.TempJob);
GenerateMapJob job = new GenerateMapJob
(
c.boundsCenterX,
c.boundsCenterY,
size,
nosP,
NoiseValues
);
noiseLists.Add(NoiseValues);
Debug.Log("Generating new chunk noise values at " + c.boundsCenterX.ToString() + ", " + c.boundsCenterY.ToString());
return(job.Schedule());
}
