public static float GetHeightAtPoint(Vector2 point, VoronoiNoiseSettings noiseSettings)
{
System.Random rnd = new System.Random(noiseSettings.seed.GetHashCode());
float amplitude = 1;
float frequency = 1;
float noiseHeight = 0;
Vector2[] octaveOffsets = new Vector2[noiseSettings.numOctaves];
for (int i = 0; i < noiseSettings.numOctaves; ++i)
{
float offsetX = rnd.Next(-100000, 100000) + noiseSettings.offset.x + point.x;
float offsetY = rnd.Next(-100000, 100000) - noiseSettings.offset.y - point.y;
octaveOffsets[i] = new Vector2(offsetX, offsetY);
amplitude *= noiseSettings.persistance;
}
for (int i = 0; i < noiseSettings.numOctaves; ++i)
{
float sampleX = (point.x + octaveOffsets[i].x) / noiseSettings.scale * frequency;
float sampleY = (point.y + octaveOffsets[i].y) / noiseSettings.scale * frequency;
float perlinValue = Mathf.PerlinNoise(sampleX, sampleY) * 2 - 1;
noiseHeight += perlinValue * amplitude;
amplitude *= noiseSettings.persistance;
frequency *= noiseSettings.lacunarity;
}
return(noiseHeight);
}
public static float[,] GenerateNoiseMap(int mapWidth, int mapHeight, VoronoiNoiseSettings noiseSettings, Vector2 sampleCenter)
{
System.Random rnd = new System.Random(noiseSettings.seed.GetHashCode());
float maxPossibleHeight = 0;
float amplitude = 1;
float frequency = 1;
Vector2[] octaveOffsets = new Vector2[noiseSettings.numOctaves];
for (int i = 0; i < noiseSettings.numOctaves; ++i)
{
float offsetX = rnd.Next(-100000, 100000) + noiseSettings.offset.x + sampleCenter.x;
float offsetY = rnd.Next(-100000, 100000) - noiseSettings.offset.y - sampleCenter.y;
octaveOffsets[i] = new Vector2(offsetX, offsetY);
maxPossibleHeight += amplitude;
amplitude *= noiseSettings.persistance;
}
float maxLocalNoiseHeight = float.MinValue;
float minLocalNoiseHeight = float.MaxValue;
float halfWidth = mapWidth * .5f;
float halfHeight = mapHeight * .5f;
float[,] noiseMap = new float[mapWidth + 1, mapHeight + 1];
for (int y = 0; y < mapHeight + 1; ++y)
{
for (int x = 0; x < mapWidth + 1; ++x)
{
amplitude = 1;
frequency = 1;
float noiseHeight = 0;
for (int i = 0; i < noiseSettings.numOctaves; ++i)
{
float sampleX = (x - halfWidth + octaveOffsets[i].x) / noiseSettings.scale * frequency;
float sampleY = (y - halfHeight + octaveOffsets[i].y) / noiseSettings.scale * frequency;
float perlinValue = Mathf.PerlinNoise(sampleX, sampleY) * 2 - 1;
noiseHeight += perlinValue * amplitude;
amplitude *= noiseSettings.persistance;
frequency *= noiseSettings.lacunarity;
}
if (noiseHeight > maxLocalNoiseHeight)
{
maxLocalNoiseHeight = noiseHeight;
}
if (noiseHeight < minLocalNoiseHeight)
{
minLocalNoiseHeight = noiseHeight;
}
noiseMap[x, y] = noiseHeight;
if (noiseSettings.normalizeMode == NormalizeMode.Global)
{
float normalizedHeight = (noiseMap[x, y] + maxPossibleHeight) / (2f * maxPossibleHeight);
noiseMap[x, y] = normalizedHeight;
//float normalizedHeight = (noiseMap[x, y] + 1) / (maxPossibleHeight / 0.9f);
//noiseMap[x, y] = Mathf.Clamp(normalizedHeight, 0, int.MaxValue);
}
}
}
if (noiseSettings.normalizeMode == NormalizeMode.Local)
{
for (int y = 0; y < mapHeight + 1; ++y)
{
for (int x = 0; x < mapWidth + 1; ++x)
{
noiseMap[x, y] = Mathf.InverseLerp(minLocalNoiseHeight, maxLocalNoiseHeight, noiseMap[x, y]);
}
}
}
return(noiseMap);
}
public static HeightMap GenerateHeightMap(int width, int height,
VoronoiHeightMapSettings heightMapSettings, VoronoiNoiseSettings noiseSettings, Vector2 sampleCenter)
{
float[,] values = VoronoiNoise.GenerateNoiseMap(width, height, noiseSettings, sampleCenter);
AnimationCurve heightCurve_threadSafe = new AnimationCurve(heightMapSettings.heightCurve.keys);
float minValue = float.MaxValue;
float maxValue = float.MinValue;
for (int i = 0; i < width; ++i)
{
for (int j = 0; j < height; ++j)
{
values[i, j] *= heightCurve_threadSafe.Evaluate(values[i, j]) * heightMapSettings.heightMultiplier;
if (values[i, j] > maxValue)
{
maxValue = values[i, j];
}
if (values[i, j] < minValue)
{
minValue = values[i, j];
}
}
}
return(new HeightMap(values, minValue, maxValue));
}
