public static float[] NoiseToArray(float spread, int layerCount, float persistance, float lacunarity, int seed, Vector2[] positions, Vector2 positionOffset, float[] heights)
{
float amplitude = 1;
float frequency = 1;
for (int i = 0; i < layerCount; i++)
{
for (int j = 0; j < positions.Length; j++)
{
Vector2 coord = (positions[j] + positionOffset) / spread * frequency + Vector2.one * (seed + i);
if (i == 0)
{
heights[j] = 0;
}
heights[j] += Mathf.PerlinNoise(coord.x, coord.y) * amplitude;
}
amplitude *= persistance;
frequency *= lacunarity;
}
//Set the noise range from 0 to 1
heights.InverseLerp(0, NoiseInfo.GetMaxHeight(layerCount, persistance));
return(heights);
}
public static float[,] NoiseToArray(float spread, int layerCount, float persistance, float lacunarity, int seed, float[,] heights, Vector2 offsetPosition)
{
Vector2Int size = new Vector2Int(heights.GetLength(0), heights.GetLength(1));
float amplitude = 1;
float frequency = 1;
for (int i = 0; i < layerCount; i++)
{
for (int x = 0; x < size.x; x++)
{
for (int y = 0; y < size.y; y++)
{
float coordX = (x + offsetPosition.x) / spread * frequency + seed + i;
float coordY = (y + offsetPosition.y) / spread * frequency + seed + i;
if (i == 0)
{
heights[x, y] = 0;
}
heights[x, y] += Mathf.PerlinNoise(coordX, coordY) * amplitude;
}
}
amplitude *= persistance;
frequency *= lacunarity;
}
//Set the noise range from 0 to 1
heights.InverseLerp(0, NoiseInfo.GetMaxHeight(layerCount, persistance));
return(heights);
}
float[] GetNoiseData()
{
Vector3 point00 = transform.TransformPoint(new Vector3(-0.5f, -0.5f));
Vector3 point10 = transform.TransformPoint(new Vector3(0.5f, -0.5f));
Vector3 point01 = transform.TransformPoint(new Vector3(-0.5f, 0.5f));
Vector3 point11 = transform.TransformPoint(new Vector3(0.5f, 0.5f));
Vector3[] posArray = { point00, point01, point10, point11 };
ComputeBuffer positionBuffer = new ComputeBuffer(posArray.Length, 12);
positionBuffer.SetData(posArray);
noiseShader.SetBuffer(_SecondKernel, "worldPositions", positionBuffer);
noiseShader.Dispatch(_SecondKernel, posArray.Length, 1, 1);
noiseShader.SetTexture(_SecondKernel, "Result", texture);
noiseShader.Dispatch(_Kernel, resolution / 8, resolution / 8, 1);
positionBuffer.Dispose();
//TerrainData terrainData = terrain.terrainData;
//terrainData.SetDetailResolution(resolution, 16);
float[] terrainHeightsInput = new float[resolution * resolution];
float[] terrainHeightsOutput = new float[resolution * resolution];
NoiseInfo[] noiseInputs = new NoiseInfo[noiseSettings.Count];
//Copy noise values from noiseSettings to noiseInputs
for (int i = 0; i < noiseInputs.Length; i++)
{
noiseInputs[i].noiseType = (int)noiseSettings[i].noiseType;
noiseInputs[i].weight = noiseSettings[i].weight;
noiseInputs[i].frequency = noiseSettings[i].frequency;
noiseInputs[i].lacunarity = noiseSettings[i].lacunarity;
noiseInputs[i].persistence = noiseSettings[i].persistence;
noiseInputs[i].octaves = noiseSettings[i].octaves;
noiseInputs[i].amplitude = noiseSettings[i].damping ? noiseSettings[i].strength / noiseSettings[i].frequency : noiseSettings[i].strength;
}
ComputeBuffer buffer = new ComputeBuffer(terrainHeightsInput.Length, sizeof(float));
ComputeBuffer noiseInfoBuffer = new ComputeBuffer(noiseInputs.Length, (sizeof(float) * 5) + sizeof(int) * 2);
//Set noise information into buffer
noiseInfoBuffer.SetData(noiseInputs);
noiseShader.SetBuffer(_SecondKernel, "noiseInfoBuffer", noiseInfoBuffer);
noiseShader.SetBuffer(_SecondKernel, "SecondResult", buffer);
noiseShader.Dispatch(_SecondKernel, resolution / 8, resolution / 8, 1);
buffer.GetData(terrainHeightsOutput);
buffer.Dispose();
noiseInfoBuffer.Dispose();
return(terrainHeightsOutput);
}
public static float[] NoiseToArray(NoiseInfo noiseData, Vector2[] positions, Vector2 positionOffset, int seed)
{
return(NoiseToArray(noiseData.spread, noiseData.LayerCount, noiseData.persistance, noiseData.lacunarity, seed, positions, positionOffset, new float[positions.Length]));
}
public static float[,] NoiseToArray(NoiseInfo noiseData, Vector2 position, Vector2Int size, int seed)
{
return(NoiseToArray(noiseData.spread, noiseData.LayerCount, noiseData.persistance, noiseData.lacunarity, seed, size, position));
}
public float[][] GenerateNoise(NoiseSettings settings, Vector2 resolution, Vector2 scale, Vector3 offset)
{
int resolutionX = (int)resolution.x;
int resolutionY = (int)resolution.y;
/* if (texture.width != resolutionY || texture.height != resolutionX)
* {
* CreateTexture(resolution);
* }*/
CreateTexture(resolution);
curSettings = settings;
Vector3 point00 = transform.TransformPoint(new Vector3(-0.5f * scale.x, -0.5f * scale.y) + offset);
Vector3 point10 = transform.TransformPoint(new Vector3(0.5f * scale.x, -0.5f * scale.y) + offset);
Vector3 point01 = transform.TransformPoint(new Vector3(-0.5f * scale.x, 0.5f * scale.y) + offset);
Vector3 point11 = transform.TransformPoint(new Vector3(0.5f * scale.x, 0.5f * scale.y) + offset);
Vector3[] posArray = { point00, point01, point10, point11 };
ComputeBuffer positionBuffer = new ComputeBuffer(posArray.Length, 12);
positionBuffer.SetData(posArray);
shader.SetBuffer(_SecondKernel, "worldPositions", positionBuffer);
shader.Dispatch(_SecondKernel, posArray.Length, 1, 1);
shader.SetTexture(_SecondKernel, "Result", texture);
shader.Dispatch(_Kernel, resolutionX / 8, resolutionY / 8, 1);
TerrainData terrainData = terrain.terrainData;
//terrainData.SetDetailResolution(resolution, 16);
float[] terrainHeightsInput = new float[resolutionX * resolutionY];
float[] terrainHeightsOutput = new float[resolutionX * resolutionY];
NoiseInfo[] noiseInputs = new NoiseInfo[1];
//Copy noise values from noiseSettings to noiseInputs
for (int i = 0; i < noiseInputs.Length; i++)
{
noiseInputs[i].noiseType = (int)settings.noiseType;
noiseInputs[i].weight = settings.weight;
noiseInputs[i].frequency = settings.frequency;
noiseInputs[i].lacunarity = settings.lacunarity;
noiseInputs[i].persistence = settings.persistence;
noiseInputs[i].octaves = settings.octaves;
noiseInputs[i].amplitude = settings.damping ? settings.strength / settings.frequency : settings.strength;
}
ComputeBuffer buffer = new ComputeBuffer(terrainHeightsInput.Length, sizeof(float));
ComputeBuffer noiseInfoBuffer = new ComputeBuffer(noiseInputs.Length, (sizeof(float) * 5) + sizeof(int) * 2);
//Set noise information into buffer
noiseInfoBuffer.SetData(noiseInputs);
shader.SetBuffer(_SecondKernel, "noiseInfoBuffer", noiseInfoBuffer);
shader.SetBuffer(_SecondKernel, "SecondResult", buffer);
shader.Dispatch(_SecondKernel, resolutionX / 8, resolutionY / 8, 1);
buffer.GetData(terrainHeightsOutput);
//output2 = SectionOfArray( terrainHeightsOutput, 0, 256);
float[][] tempOutput = new float[resolutionX][];
//output2 = SectionOfArray(terrainHeightsOutput, 0, 2048);
scale = new Vector2(terrainHeightsOutput[0], terrainHeightsOutput[0]);
float sum = 0;
foreach (float n in terrainHeightsOutput)
{
sum += Mathf.Abs(n);
if (n > scale.y)
{
scale.y = n;
}
if (n < scale.x)
{
scale.x = n;
}
}
sum /= terrainHeightsOutput.Length;
this.sum = sum;
for (int x = 0; x < resolutionX; x++)
{
tempOutput[x] = new float[resolutionY];
for (int y = 0; y < resolutionY; y++)
{
tempOutput[x][y] = ((terrainHeightsOutput[(x) + resolutionX * y])); //* settings.strength;// * noiseSettings.amplitude;
}
}
noiseInfoBuffer.Dispose();
buffer.Dispose();
positionBuffer.Dispose();
return(tempOutput);
}
void GenerateAndApplyToTerrain()
{
Debug.Log("Generating and Applying to terrain");
//Vector3 vectransform = new Vector3(noiseScale.x * noiseOffset.x, noiseScale.y * noiseOffset.y, noiseScale.z* noiseOffset.z);
Vector3 point00 = transform.TransformPoint(new Vector3(-0.5f * noiseScale.x, -0.5f * noiseScale.y) + noiseOffset);
Vector3 point10 = transform.TransformPoint(new Vector3(0.5f * noiseScale.x, -0.5f * noiseScale.y) + noiseOffset);
Vector3 point01 = transform.TransformPoint(new Vector3(-0.5f * noiseScale.x, 0.5f * noiseScale.y) + noiseOffset);
Vector3 point11 = transform.TransformPoint(new Vector3(0.5f * noiseScale.x, 0.5f * noiseScale.y) + noiseOffset);
Vector3[] posArray = { point00, point01, point10, point11 };
ComputeBuffer positionBuffer = new ComputeBuffer(posArray.Length, 12);
positionBuffer.SetData(posArray);
shader.SetBuffer(_SecondKernel, "worldPositions", positionBuffer);
shader.Dispatch(_SecondKernel, posArray.Length, 1, 1);
shader.SetTexture(_SecondKernel, "Result", texture);
shader.Dispatch(_Kernel, resolution / 8, resolution / 8, 1);
TerrainData terrainData = terrain.terrainData;
//terrainData.SetDetailResolution(resolution, 16);
float[] terrainHeightsInput = new float[resolution * resolution];
float[] terrainHeightsOutput = new float[resolution * resolution];
NoiseInfo[] noiseInputs = new NoiseInfo[noiseSettings.Count];
//Copy noise values from noiseSettings to noiseInputs
for (int i = 0; i < noiseInputs.Length; i++)
{
noiseInputs[i].noiseType = (int)noiseSettings[i].noiseType;
noiseInputs[i].weight = noiseSettings[i].weight;
noiseInputs[i].frequency = noiseSettings[i].frequency;
noiseInputs[i].lacunarity = noiseSettings[i].lacunarity;
noiseInputs[i].persistence = noiseSettings[i].persistence;
noiseInputs[i].octaves = noiseSettings[i].octaves;
noiseInputs[i].amplitude = noiseSettings[i].damping ? noiseSettings[i].strength / noiseSettings[i].frequency : noiseSettings[i].strength;
}
ComputeBuffer buffer = new ComputeBuffer(terrainHeightsInput.Length, sizeof(float));
ComputeBuffer noiseInfoBuffer = new ComputeBuffer(noiseInputs.Length, (sizeof(float) * 5) + sizeof(int) * 2);
//Set noise information into buffer
noiseInfoBuffer.SetData(noiseInputs);
shader.SetBuffer(_SecondKernel, "noiseInfoBuffer", noiseInfoBuffer);
shader.SetBuffer(_SecondKernel, "SecondResult", buffer);
shader.Dispatch(_SecondKernel, resolution / 8, resolution / 8, 1);
buffer.GetData(terrainHeightsOutput);
output1 = SectionOfArray(terrainHeightsOutput, 0, 256);
pointMaterial.SetBuffer("buf_points", buffer);
if (applyToTerrain)
{
float[,] noiseHeightData = new float[resolution, resolution];
float[,,] splatmapData = new float[resolution, resolution, terrainData.alphamapLayers];
for (int x = 0; x < resolution; x++)
{
for (int y = 0; y < resolution; y++)
{
noiseHeightData[x, y] = ((terrainHeightsOutput[(y) + resolution * x])) * noiseAmplitude;// * noiseSettings.amplitude;
}
}
//Debug.Log(noiseHeightData[5, 5]);
terrainData.SetHeights(0, 0, noiseHeightData);
//GameObject _terrain = Terrain.CreateTerrainGameObject(terrainData);
terrain.ApplyDelayedHeightmapModification();
if (applySplatMap)
{
ApplySplatMap(terrainData);
applySplatMap = false;
}
}
noiseInfoBuffer.Dispose();
buffer.Dispose();
positionBuffer.Dispose();
// Clean up
}
