void TriangulateAdjacentToRiver(HexDirection direction, HexCell_Script cell, Vector3 center, EdgeVertices e)
{
if (cell.HasRoads)
{
TriangulateRoadAdjacentToRiver(direction, cell, center, e);
}
if (cell.HasRiverThroughEdge(direction.Next()))
{
if (cell.HasRiverThroughEdge(direction.Previous()))
{
center += HexMetrics_Script.GetSolidEdgeMiddle(direction) * (HexMetrics_Script.innerToOuter * 0.5f);
}
else if (cell.HasRiverThroughEdge(direction.Previous2()))
{
center += HexMetrics_Script.GetFirstSolidCorner(direction) * 0.25f;
}
}
else if (cell.HasRiverThroughEdge(direction.Previous()) &&
cell.HasRiverThroughEdge(direction.Next2()))
{
center += HexMetrics_Script.GetSecondSolidCorner(direction) * 0.25f;
}
EdgeVertices m = new EdgeVertices(Vector3.Lerp(center, e.v1, 0.5f),
Vector3.Lerp(center, e.v5, 0.5f));
TriangulateEdgeStrip(m, color1, cell.TerrainTypeIndex, e, color1, cell.TerrainTypeIndex);
TriangulateEdgeFan(center, m, cell.TerrainTypeIndex);
if (!cell.IsUnderwater && !cell.HasRoadThroughEdge(direction))
{
features.AddFeature(cell, (center + e.v1 + e.v5) * (1f / 3f));
}
}
void TriangulateWaterShore(HexDirection direction, HexCell_Script cell, HexCell_Script neighbor,
Vector3 center)
{
EdgeVertices e1 = new EdgeVertices(center + HexMetrics_Script.GetFirstWaterCorner(direction),
center + HexMetrics_Script.GetSecondWaterCorner(direction));
water.AddTriangle(center, e1.v1, e1.v2);
water.AddTriangle(center, e1.v2, e1.v3);
water.AddTriangle(center, e1.v3, e1.v4);
water.AddTriangle(center, e1.v4, e1.v5);
Vector3 center2 = neighbor.Position;
center2.y = center.y;
EdgeVertices e2 = new EdgeVertices(center2 + HexMetrics_Script.GetSecondSolidCorner(direction.Opposite()),
center2 + HexMetrics_Script.GetFirstSolidCorner(direction.Opposite()));
if (cell.HasRiverThroughEdge(direction))
{
TriangulateEstuary(e1, e2, cell.IncomingRiver == direction);
}
else
{
waterShore.AddQuad(e1.v1, e1.v2, e2.v1, e2.v2);
waterShore.AddQuad(e1.v2, e1.v3, e2.v2, e2.v3);
waterShore.AddQuad(e1.v3, e1.v4, e2.v3, e2.v4);
waterShore.AddQuad(e1.v4, e1.v5, e2.v4, e2.v5);
waterShore.AddQuadUV(0f, 0f, 0f, 1f);
waterShore.AddQuadUV(0f, 0f, 0f, 1f);
waterShore.AddQuadUV(0f, 0f, 0f, 1f);
waterShore.AddQuadUV(0f, 0f, 0f, 1f);
}
HexCell_Script nextNeighbor = cell.GetNeighbor(direction.Next());
if (nextNeighbor != null)
{
Vector3 v3 = nextNeighbor.Position + (nextNeighbor.IsUnderwater ?
HexMetrics_Script.GetFirstWaterCorner(direction.Previous()) :
HexMetrics_Script.GetFirstSolidCorner(direction.Previous()));
v3.y = center.y;
waterShore.AddTriangle(e1.v5, e2.v5, v3);
waterShore.AddTriangleUV(
new Vector2(0f, 0f),
new Vector2(0f, 1f),
new Vector2(0f, nextNeighbor.IsUnderwater?0f:1f));
}
}
void Triangulate(HexDirection direction, HexCell_Script cell)
{
Vector3 center = cell.Position;
EdgeVertices e = new EdgeVertices(center + HexMetrics_Script.GetFirstSolidCorner(direction),
center + HexMetrics_Script.GetSecondSolidCorner(direction));
if (cell.HasRiver)
{
if (cell.HasRiverThroughEdge(direction))
{
e.v3.y = cell.StreamBedY;
if (cell.HasRiverBeginOrEnd)
{
TriangulateWithRiverBeginOrEnd(direction, cell, center, e);
}
else
{
TriangulateWithRiver(direction, cell, center, e);
}
}
else
{
TriangulateAdjacentToRiver(direction, cell, center, e);
}
}
else
{
TriangulateWithoutRiver(direction, cell, center, e);
if (!cell.IsUnderwater && !cell.HasRoadThroughEdge(direction))
{
features.AddFeature(cell, (center + e.v1 + e.v5) * (1f / 3f));
}
}
if (direction <= HexDirection.SE)
{
TriangulateConnection(direction, cell, e);
}
if (cell.IsUnderwater)
{
TriangulateWater(direction, cell, center);
}
}
void TriangulateRoadAdjacentToRiver(HexDirection direction, HexCell_Script cell,
Vector3 center, EdgeVertices e)
{
bool hasRoadThroughEdge = cell.HasRoadThroughEdge(direction);
bool previousHasRiver = cell.HasRiverThroughEdge(direction.Previous());
bool nextHasRiver = cell.HasRiverThroughEdge(direction.Next());
Vector2 interpolators = GetRoadInterpolators(direction, cell);
Vector3 roadCenter = center;
if (cell.HasRiverBeginOrEnd)
{
roadCenter += HexMetrics_Script.GetSolidEdgeMiddle(cell.RiverBeginOrEndDirection.Opposite()) * (1f / 3f);
}
else if (cell.IncomingRiver == cell.OutgoingRiver.Opposite())
{
Vector3 corner;
if (previousHasRiver)
{
if (!hasRoadThroughEdge && !cell.HasRoadThroughEdge(direction.Next()))
{
return;
}
corner = HexMetrics_Script.GetSecondSolidCorner(direction);
}
else
{
if (!hasRoadThroughEdge && !cell.HasRoadThroughEdge(direction.Previous()))
{
return;
}
corner = HexMetrics_Script.GetFirstSolidCorner(direction);
}
roadCenter += corner * 0.5f;
if (cell.IncomingRiver == direction.Next() &&
(cell.HasRoadThroughEdge(direction.Next2()) ||
cell.HasRoadThroughEdge(direction.Opposite())))
{
features.AddBridge(roadCenter, center - corner * 0.5f);
}
center += corner * 0.25f;
}
else if (cell.IncomingRiver == cell.OutgoingRiver.Previous())
{
roadCenter -= HexMetrics_Script.GetSecondCorner(cell.IncomingRiver) * 0.2f;
}
else if (cell.IncomingRiver == cell.OutgoingRiver.Next())
{
roadCenter -= HexMetrics_Script.GetFirstCorner(cell.IncomingRiver) * 0.2f;
}
else if (previousHasRiver && nextHasRiver)
{
if (!hasRoadThroughEdge)
{
return;
}
Vector3 offset = HexMetrics_Script.GetSolidEdgeMiddle(direction) * HexMetrics_Script.innerToOuter;
roadCenter += offset * 0.7f;
center += offset * 0.5f;
}
else
{
HexDirection middle;
if (previousHasRiver)
{
middle = direction.Next();
}
else if (nextHasRiver)
{
middle = direction.Previous();
}
else
{
middle = direction;
}
if (!cell.HasRoadThroughEdge(middle) &&
!cell.HasRoadThroughEdge(middle.Previous()) &&
!cell.HasRoadThroughEdge(middle.Next()))
{
return;
}
Vector3 offset = HexMetrics_Script.GetSolidEdgeMiddle(middle);
roadCenter += offset * 0.25f;
if (direction == middle &&
cell.HasRoadThroughEdge(direction.Opposite()))
{
features.AddBridge(roadCenter, center - offset * (HexMetrics_Script.innerToOuter * 0.7f));
}
}
Vector3 mL = Vector3.Lerp(roadCenter, e.v1, interpolators.x);
Vector3 mR = Vector3.Lerp(roadCenter, e.v5, interpolators.y);
TriangulateRoad(roadCenter, mL, mR, e, hasRoadThroughEdge);
if (previousHasRiver)
{
TriangulateRoadEdge(roadCenter, center, mL);
}
if (nextHasRiver)
{
TriangulateRoadEdge(roadCenter, mR, center);
}
}
void TriangulateWithRiver(HexDirection direction, HexCell_Script cell, Vector3 center, EdgeVertices e)
{
Vector3 centerL;
Vector3 centerR;
if (cell.HasRiverThroughEdge(direction.Opposite()))
{
centerL = center + HexMetrics_Script.GetFirstSolidCorner(direction.Previous()) * 0.25f;
centerR = center + HexMetrics_Script.GetSecondSolidCorner(direction.Next()) * 0.25f;
}
else if (cell.HasRiverThroughEdge(direction.Next()))
{
centerL = center;
centerR = Vector3.Lerp(center, e.v5, 2f / 3f);
}
else if (cell.HasRiverThroughEdge(direction.Previous()))
{
centerL = Vector3.Lerp(center, e.v1, 2f / 3f);
centerR = center;
}
else if (cell.HasRiverThroughEdge(direction.Next2()))
{
centerL = center;
centerR = center + HexMetrics_Script.GetSolidEdgeMiddle(direction.Next()) * (0.5f * HexMetrics_Script.innerToOuter);
}
else
{
centerL = center + HexMetrics_Script.GetSolidEdgeMiddle(direction.Previous()) * (0.5f * HexMetrics_Script.innerToOuter);
centerR = center;
}
center = Vector3.Lerp(centerL, centerR, 0.5f);
EdgeVertices m = new EdgeVertices(Vector3.Lerp(centerL, e.v1, 0.5f),
Vector3.Lerp(centerR, e.v5, 0.5f), 1f / 6f);
m.v3.y = e.v3.y;
center.y = e.v3.y;
TriangulateEdgeStrip(m, color1, cell.TerrainTypeIndex, e, color1, cell.TerrainTypeIndex);
terrain.AddTriangle(centerL, m.v1, m.v2);
//terrain.AddTriangleColor(cell.Color);
terrain.AddQuad(centerL, center, m.v2, m.v3);
//terrain.AddQuadColor(cell.Color);
terrain.AddQuad(center, centerR, m.v3, m.v4);
//terrain.AddQuadColor(cell.Color);
terrain.AddTriangle(centerR, m.v4, m.v5);
//terrain.AddTriangleColor(cell.Color);
terrain.AddTriangleColor(color1);
terrain.AddQuadColor(color1);
terrain.AddQuadColor(color1);
terrain.AddTriangleColor(color1);
Vector3 types;
types.x = types.y = types.z = cell.TerrainTypeIndex;
terrain.AddTriangleTerrainTypes(types);
terrain.AddQuadTerrainTypes(types);
terrain.AddQuadTerrainTypes(types);
terrain.AddTriangleTerrainTypes(types);
if (!cell.IsUnderwater)
{
bool reversed = cell.IncomingRiver == direction;
TriangulateRiverQuad(centerL, centerR, m.v2, m.v4, reversed, cell.RiverSurfaceY, 0.4f);
TriangulateRiverQuad(m.v2, m.v4, e.v2, e.v4, reversed, cell.RiverSurfaceY, 0.6f);
}
}