/// <summary>
/// Samples all points in a chunk column using perlin noise
/// </summary>
/// <param name="colCoord">The coordinate of the chunk</param>
/// <returns>The filled noisemap</returns>
private float[,,] SamplePoints(ColumnCoord colCoord)
{
int size = ChunkColumn.chunkSize;
int amountOfVerticalChunks = ChunkColumn.worldHeight;
float halfSize = size * 0.5f;
float[,,] sampleNoiseMap = new float[size / horizontalNoiseScale + 1, size *amountOfVerticalChunks / verticalNoiseScale + 1, size / horizontalNoiseScale + 1];
float sampleX, sampleY, sampleZ, adjustmentVal;
// Sampling points
for (int x = 0; x < sampleNoiseMap.GetLength(0); x++)
{
for (int y = 0; y < sampleNoiseMap.GetLength(1); y++)
{
for (int z = 0; z < sampleNoiseMap.GetLength(2); z++)
{
Vector3 chunkOffset = new Vector3(colCoord.x, 0, colCoord.z) * size;
sampleX = ((float)x * horizontalNoiseScale - halfSize + chunkOffset.x) * ChunkColumn.blockSize / zoomScale;
sampleY = ((float)y * verticalNoiseScale + chunkOffset.y) * ChunkColumn.blockSize / zoomScale;
sampleZ = ((float)z * horizontalNoiseScale - halfSize + chunkOffset.z) * ChunkColumn.blockSize / zoomScale;
sampleNoiseMap[x, y, z] = CustomPerlinNoise.PerlinNoise(sampleX, sampleY, sampleZ);
adjustmentVal = (1 - Mathf.InverseLerp(solidHeight, airHeight, y * verticalNoiseScale) * (1 - Mathf.PerlinNoise(sampleX, sampleZ) * 0.2f)) * 2 - 1;
adjustmentVal *= adjustScalar;
sampleNoiseMap[x, y, z] += adjustmentVal;
}
}
}
return(sampleNoiseMap);
}
public void CreateData()
{
float scale = NoiseParameters.Scale;
float smoothingCoeficient = NoiseParameters.Smooth;
int multiplyer = NoiseParameters.Mult;
float minWeight = float.MaxValue;
float maxWeight = float.MinValue;
PerlinNoise perlin = new PerlinNoise(1);
CustomPerlinNoise customPerlin = new CustomPerlinNoise();
for (int x = 0; x < sizeX; x++)
{
for (int y = 0; y < sizeY; y++)
{
for (int z = 0; z < sizeZ; z++)
{
float weight = 0f;
double sampleX = (x + Position.x) * scale;
double sampleZ = (z + Position.z) * scale;
double sampleY;
if (NoiseParameters.Use3DNoise)
{
sampleY = (y + Position.y) * scale;
}
else
{
sampleY = 0;
}
if (NoiseParameters.ClassicNoise)
{
weight += (float)(y * smoothingCoeficient + ClassicNoise.Noise(sampleX * smoothingCoeficient, sampleY * smoothingCoeficient, sampleZ * smoothingCoeficient) * multiplyer);
}
if (NoiseParameters.PerlinNoise)
{
weight += (float)(y * smoothingCoeficient + perlin.Noise(sampleX * smoothingCoeficient, sampleY * smoothingCoeficient, sampleZ * smoothingCoeficient) * multiplyer);
}
if (NoiseParameters.SimplexNoise)
{
weight += (float)(y * smoothingCoeficient + SimplexNoise.Noise(sampleX * smoothingCoeficient, sampleY * smoothingCoeficient, sampleZ * smoothingCoeficient) * multiplyer);
}
if (NoiseParameters.DefaultPerlinNoise)
{
weight += (y + customPerlin.Noise((float)sampleX, (float)sampleZ, NoiseParameters.Octaves) * multiplyer);
}
if (weight < minWeight)
{
minWeight = weight;
}
if (weight > maxWeight)
{
maxWeight = weight;
}
data[x, y, z] = weight;
if (y == 0)
{
data[x, y, z] = -1f;
}
}
}
}
}
