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; }
/// <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()); }