public ZoneRatio GetInfluence(Vector2 worldPosition)
{
_influenceTime.Start();
var lookupResult = new float[(int)_zoneMaxType + 1];
foreach (var zone in _zones)
{
if (zone.Type != ZoneType.Empty)
{
var idwSimplestWeighting = IDWSimplestWeighting(zone.Center, worldPosition);
lookupResult[(int)zone.Type] += idwSimplestWeighting;
}
}
var result = new ZoneRatio(
lookupResult.Select((v, i) => new ZoneValue((ZoneType)i, v)).Where(v => v.Value > 0).ToArray(),
_zoneTypesCount);
//foreach (var zone in _zones.OrderBy(z => Vector3.SqrMagnitude(z.Center - worldPosition)).Take(10))
//result[zone.Type] += IDWSimplestWeighting(zone.Center, worldPosition);
//var result = new ZoneRatio(_zoneMaxType);
//result.Normalize();
_influenceTime.Stop();
_influenceCounter++;
return(result);
}
protected override BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
{
if (Vector3.Angle(Vector3.up, normal) > 65)
return BlockType.Rock;
return base.GenerateBlock(worldPosition, turbulence, normal, influence);
}
public ZoneContent Generate()
{
var zoneBounds = _zone.Bounds;
var zoneInfluences = new ZoneRatio[zoneBounds.Size.X + 1, zoneBounds.Size.Z + 1];
var zoneHeightmap = new float[zoneBounds.Size.X + 1, zoneBounds.Size.Z + 1];
var zoneNormalmap = new Vector3[zoneBounds.Size.X, zoneBounds.Size.Z];
var zoneBlocks = new BlockType[zoneBounds.Size.X, zoneBounds.Size.Z];
Blocks = _zone.GetBlocks2().ToArray();
foreach (var blockPos in Blocks)
{
var localPos = blockPos - zoneBounds.Min;
//Build heightmap
CalculateVertex(blockPos, zoneInfluences, zoneHeightmap);
CalculateVertex(blockPos + Vector2i.Right, zoneInfluences, zoneHeightmap);
CalculateVertex(blockPos + Vector2i.Forward, zoneInfluences, zoneHeightmap);
CalculateVertex(blockPos + Vector2i.One, zoneInfluences, zoneHeightmap);
zoneNormalmap[localPos.X, localPos.Z] = CalculateNormal(localPos, zoneHeightmap);
//Build block
ZoneRatio blockInfluence;
var turbulenceX = (Mathf.PerlinNoise(blockPos.X * 0.1f, blockPos.Z * 0.1f) - 0.5f) * 10;
var turbulenceZ = (Mathf.PerlinNoise(blockPos.Z * 0.1f, blockPos.X * 0.1f) - 0.5f) * 10;
var localTurbulated = localPos + new Vector2i(turbulenceX, turbulenceZ);
if (localTurbulated.X >= 0 && localTurbulated.X < zoneBounds.Size.X + 1 &&
localTurbulated.Z >= 0 && localTurbulated.Z < zoneBounds.Size.Z + 1)
{
if (!zoneInfluences[localTurbulated.X, localTurbulated.Z].IsEmpty)
{
blockInfluence = zoneInfluences[localTurbulated.X, localTurbulated.Z];
}
else
{
var worldTurbulated = blockPos + new Vector2i(turbulenceX, turbulenceZ);
blockInfluence =
zoneInfluences[localPos.X, localPos.Z] =
Land.GetInfluence((Vector2)worldTurbulated);
}
}
else
{
var worldTurbulated = blockPos + new Vector2i(turbulenceX, turbulenceZ);
blockInfluence = Land.GetInfluence((Vector2)worldTurbulated);
}
zoneBlocks[localPos.X, localPos.Z] = GenerateBlock(blockPos, new Vector2i(turbulenceX, turbulenceZ),
zoneNormalmap[localPos.X, localPos.Z], blockInfluence);
}
var props = DecorateZone(zoneInfluences, zoneHeightmap, zoneNormalmap, zoneBlocks);
return(new ZoneContent(_zone, zoneInfluences, zoneHeightmap, zoneNormalmap, zoneBlocks, props));
}
public ZoneContent Generate()
{
var zoneBounds = _zone.Bounds;
var zoneInfluences = new ZoneRatio[zoneBounds.Size.X + 1, zoneBounds.Size.Z + 1];
var zoneHeightmap = new float[zoneBounds.Size.X + 1, zoneBounds.Size.Z + 1];
var zoneNormalmap = new Vector3[zoneBounds.Size.X, zoneBounds.Size.Z];
var zoneBlocks = new BlockType[zoneBounds.Size.X, zoneBounds.Size.Z];
Blocks = _zone.GetBlocks2().ToArray();
foreach (var blockPos in Blocks)
{
var localPos = blockPos - zoneBounds.Min;
//Build heightmap
CalculateVertex(blockPos, zoneInfluences, zoneHeightmap);
CalculateVertex(blockPos + Vector2i.Right, zoneInfluences, zoneHeightmap);
CalculateVertex(blockPos + Vector2i.Forward, zoneInfluences, zoneHeightmap);
CalculateVertex(blockPos + Vector2i.One, zoneInfluences, zoneHeightmap);
zoneNormalmap[localPos.X, localPos.Z] = CalculateNormal(localPos, zoneHeightmap);
//Build block
ZoneRatio blockInfluence;
var turbulenceX = (Mathf.PerlinNoise(blockPos.X * 0.1f, blockPos.Z * 0.1f) - 0.5f) * 10;
var turbulenceZ = (Mathf.PerlinNoise(blockPos.Z * 0.1f, blockPos.X * 0.1f) - 0.5f) * 10;
var localTurbulated = localPos + new Vector2i(turbulenceX, turbulenceZ);
if (localTurbulated.X >= 0 && localTurbulated.X < zoneBounds.Size.X + 1
&& localTurbulated.Z >= 0 && localTurbulated.Z < zoneBounds.Size.Z + 1)
{
if (!zoneInfluences[localTurbulated.X, localTurbulated.Z].IsEmpty)
{
blockInfluence = zoneInfluences[localTurbulated.X, localTurbulated.Z];
}
else
{
var worldTurbulated = blockPos + new Vector2i(turbulenceX, turbulenceZ);
blockInfluence =
zoneInfluences[localPos.X, localPos.Z] =
Land.GetInfluence((Vector2)worldTurbulated);}
}
else
{
var worldTurbulated = blockPos + new Vector2i(turbulenceX, turbulenceZ);
blockInfluence = Land.GetInfluence((Vector2)worldTurbulated);
}
zoneBlocks[localPos.X, localPos.Z] = GenerateBlock(blockPos, new Vector2i(turbulenceX, turbulenceZ),
zoneNormalmap[localPos.X, localPos.Z], blockInfluence);
}
var props = DecorateZone(zoneInfluences, zoneHeightmap, zoneNormalmap, zoneBlocks);
return new ZoneContent(_zone, zoneInfluences, zoneHeightmap, zoneNormalmap, zoneBlocks, props);
}
private Color Lerp(ZoneRatio ratio)
{
var result = Color.black;
for (var i = 0; i < _zoneTypes.Length; i++)
{
var zoneType = _zoneTypes[i];
result += _zoneInfluenceColors[(int)zoneType] * ratio[zoneType];
}
return result;
}
private Color Lerp(ZoneRatio ratio)
{
var result = Color.black;
for (var i = 0; i < _zoneTypes.Length; i++)
{
var zoneType = _zoneTypes[i];
result += _zoneInfluenceColors[(int)zoneType] * ratio[zoneType];
}
return(result);
}
protected override BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
{
var mountInfluence = influence[ZoneType.Mountains];
if (mountInfluence > 0.85f && Vector3.Angle(Vector3.up, normal) < 45)
return BlockType.Snow;
if (mountInfluence < 0.6f && Vector3.Angle(Vector3.up, normal) < 45)
return BlockType.Grass;
return base.GenerateBlock(worldPosition, turbulence, normal, influence);
}
public ZoneRatio GetBilinearInterpolationInfluence(Vector2 position, Vector2 min, Vector2 max, ZoneRatio q11, ZoneRatio q12, ZoneRatio q21, ZoneRatio q22)
{
_bilinearTime.Start();
var x = position.x;
var y = position.y;
var x1 = min.x;
var x2 = max.x;
var y1 = min.y;
var y2 = max.y;
var result = (1 / (x2 - x1) * (y2 - y1)) *
(q11 * (x2 - x) * (y2 - y) + q21 * (x - x1) * (y2 - y) + q12 * (x2 - x) * (y - y1) + q22 * (x - x1) * (y - y1));
result.Normalize();
_bilinearTime.Stop();
_bilinearCounter++;
return result;
}
public static IZoneNoiseSettings Lerp(ZoneSettings[] zones, ZoneRatio ratio)
{
var outScale1 = 0f;
var outScale2 = 0f;
var outScale3 = 0f;
var height = 0f;
for (int i = 0; i < zones.Length; i++)
{
var zoneNoiseSettings = zones[i];
var zoneRatio = ratio[zoneNoiseSettings.Type];
height += zoneNoiseSettings.Height*zoneRatio;
outScale1 += zoneNoiseSettings.OutScale1*zoneRatio;
outScale2 += zoneNoiseSettings.OutScale2*zoneRatio;
outScale3 += zoneNoiseSettings.OutScale3*zoneRatio;
}
var result = new ZoneSettings2(Color.black, height, outScale1, outScale2, outScale3);
return result;
}
protected override Vector3[] DecorateZone(ZoneRatio[,] zoneInfluences, float[,] zoneHeightmap, Vector3[,] zoneNormalmap, BlockType[,] zoneBlocks)
{
var trees = new List<Vector3>();
var bounds = _zone.Bounds;
for (int i = 0; i < 100; i++)
{
var position = new Vector3(Random.Range(bounds.Min.X, bounds.Max.X), 0, Random.Range(bounds.Min.Z, bounds.Max.Z));
var blockPos = (Vector2i) position;
var localBlockPos = blockPos - bounds.Min;
//Check zone bounds
if (bounds.Contains(blockPos) && !zoneInfluences[localBlockPos.X, localBlockPos.Z].IsEmpty
&& zoneInfluences[localBlockPos.X, localBlockPos.Z][ZoneType.Forest] > 0.5f)
{
//Check slopiness
if (Vector3.Angle(Vector3.up, zoneNormalmap[localBlockPos.X, localBlockPos.Z]) < 20)
trees.Add(new Vector3(position.x, zoneHeightmap[localBlockPos.X, localBlockPos.Z], position.z));
}
}
return trees.ToArray();
}
public ZoneContent(ZoneLayout zone, ZoneRatio[,] influences, float[,] heightMap, Vector3[,] normalMap, BlockType[,] blocks, Vector3[] objects)
{
Zone = zone;
Influences = influences;
HeightMap = heightMap;
NormalMap = normalMap;
Blocks = blocks;
Objects = objects;
}
private void CalculateVertex(Vector2i vertPos, ZoneRatio[,] zoneInfluences, float[,] zoneHeightmap)
{
var localPos = vertPos - _zone.Bounds.Min;
if (zoneInfluences[localPos.X, localPos.Z].IsEmpty)
{
zoneInfluences[localPos.X, localPos.Z] = Land.GetInfluence((Vector2) vertPos);
var settings = Land.GetZoneNoiseSettings(zoneInfluences[localPos.X, localPos.Z]);
var yValue = GenerateBaseHeight(vertPos.X, vertPos.Z, settings);
zoneHeightmap[localPos.X, localPos.Z] = yValue;
}
}
/// <summary>
///
/// </summary>
/// <param name="worldPosition"></param>
/// <param name="turbulence"></param>
/// <param name="normal"></param>
/// <param name="influence"></param>
/// <returns></returns>
protected virtual BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
{
var zoneValue = influence[0];
return _landSettings[zoneValue.Zone].DefaultBlock;
}
protected virtual Vector3[] DecorateZone(ZoneRatio[,] zoneInfluences, float[,] zoneHeightmap, Vector3[,] zoneNormalmap, BlockType[,] zoneBlocks)
{
return new Vector3[0];
}
public IZoneNoiseSettings GetZoneNoiseSettings(ZoneRatio influence)
{
return ZoneSettings.Lerp(_zoneSettings, influence);
}
public ZoneRatio GetInfluence(Vector2 worldPosition)
{
_influenceTime.Start();
var lookupResult = new float[(int) _zoneMaxType + 1];
foreach (var zone in _zones)
{
if (zone.Type != ZoneType.Empty)
{
var idwSimplestWeighting = IDWSimplestWeighting(zone.Center, worldPosition);
lookupResult[(int) zone.Type] += idwSimplestWeighting;
}
}
var result = new ZoneRatio(
lookupResult.Select((v, i) => new ZoneValue((ZoneType)i, v)).Where(v => v.Value > 0).ToArray(),
_zoneTypesCount);
//foreach (var zone in _zones.OrderBy(z => Vector3.SqrMagnitude(z.Center - worldPosition)).Take(10))
//result[zone.Type] += IDWSimplestWeighting(zone.Center, worldPosition);
//var result = new ZoneRatio(_zoneMaxType);
//result.Normalize();
_influenceTime.Stop();
_influenceCounter++;
return result;
}
/// <summary>
///
/// </summary>
/// <param name="worldPosition"></param>
/// <param name="turbulence"></param>
/// <param name="normal"></param>
/// <param name="influence"></param>
/// <returns></returns>
protected virtual BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
{
var zoneValue = influence[0];
return(_landSettings[zoneValue.Zone].DefaultBlock);
}
public IZoneNoiseSettings GetZoneNoiseSettings(ZoneRatio influence)
{
return(ZoneSettings.Lerp(_zoneSettings, influence));
}
protected override BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
{
return(GetDiagonalLines(worldPosition));
}
public ZoneRatio GetBilinearInterpolationInfluence(Vector2 position, Vector2 min, Vector2 max, ZoneRatio q11, ZoneRatio q12, ZoneRatio q21, ZoneRatio q22)
{
_bilinearTime.Start();
var x = position.x;
var y = position.y;
var x1 = min.x;
var x2 = max.x;
var y1 = min.y;
var y2 = max.y;
var result = (1 / (x2 - x1) * (y2 - y1)) *
(q11 * (x2 - x) * (y2 - y) + q21 * (x - x1) * (y2 - y) + q12 * (x2 - x) * (y - y1) + q22 * (x - x1) * (y - y1));
result.Normalize();
_bilinearTime.Stop();
_bilinearCounter++;
return(result);
}
protected override BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
{
return GetDiagonalLines(worldPosition);
}
protected override BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
{
if (Vector3.Angle(Vector3.up, normal) < 5)
{
return(BlockType.Water);
}
return(base.GenerateBlock(worldPosition, turbulence, normal, influence));
}
protected override BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
{
var mountInfluence = influence[ZoneType.Mountains];
if (mountInfluence > 0.85f && Vector3.Angle(Vector3.up, normal) < 45)
{
return(BlockType.Snow);
}
if (mountInfluence < 0.6f && Vector3.Angle(Vector3.up, normal) < 45)
{
return(BlockType.Grass);
}
return(base.GenerateBlock(worldPosition, turbulence, normal, influence));
}
