274 lines
15 KiB
C#
274 lines
15 KiB
C#
using Barotrauma.Extensions;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using Voronoi2;
|
|
|
|
namespace Barotrauma
|
|
{
|
|
static partial class CaveGenerator
|
|
{
|
|
public static List<VertexPositionColor> GenerateWallVertices(List<Vector2[]> triangles, Color color, float zCoord)
|
|
{
|
|
var vertices = new List<VertexPositionColor>();
|
|
for (int i = 0; i < triangles.Count; i++)
|
|
{
|
|
foreach (Vector2 vertex in triangles[i])
|
|
{
|
|
vertices.Add(new VertexPositionColor(new Vector3(vertex, zCoord), color));
|
|
}
|
|
}
|
|
return vertices;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates texture coordinates for the vertices based on their positions
|
|
/// </summary>
|
|
public static VertexPositionColorTexture[] ConvertToTextured(VertexPositionColor[] verts, float textureSize)
|
|
{
|
|
VertexPositionColorTexture[] texturedVerts = new VertexPositionColorTexture[verts.Length];
|
|
for (int i = 0; i < verts.Length; i++)
|
|
{
|
|
VertexPositionColor vertex = verts[i];
|
|
texturedVerts[i] = new VertexPositionColorTexture(vertex.Position, vertex.Color, textureCoordinate: Vector2.Zero);
|
|
}
|
|
GenerateTextureCoordinates(texturedVerts, textureSize);
|
|
return texturedVerts;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates texture coordinates for the vertices based on their positions
|
|
/// </summary>
|
|
public static void GenerateTextureCoordinates(VertexPositionColorTexture[] verts, float textureSize)
|
|
{
|
|
for (int i = 0; i < verts.Length; i++)
|
|
{
|
|
VertexPositionColorTexture vertex = verts[i];
|
|
Vector2 uvCoords = new Vector2(vertex.Position.X, vertex.Position.Y) / textureSize;
|
|
verts[i] = new VertexPositionColorTexture(verts[i].Position, verts[i].Color, uvCoords);
|
|
}
|
|
}
|
|
|
|
public static List<VertexPositionColorTexture> GenerateWallEdgeVertices(
|
|
List<VoronoiCell> cells,
|
|
float expandOutwards, float expandInwards,
|
|
Color outerColor, Color innerColor,
|
|
Level level, float zCoord, bool preventExpandThroughCell = false)
|
|
{
|
|
float outWardThickness = expandOutwards;
|
|
|
|
List<VertexPositionColorTexture> vertices = new List<VertexPositionColorTexture>();
|
|
foreach (VoronoiCell cell in cells)
|
|
{
|
|
Vector2 minVert = cell.Edges[0].Point1;
|
|
Vector2 maxVert = cell.Edges[0].Point1;
|
|
float circumference = 0.0f;
|
|
foreach (GraphEdge edge in cell.Edges)
|
|
{
|
|
circumference += Vector2.Distance(edge.Point1, edge.Point2);
|
|
minVert = new Vector2(
|
|
Math.Min(minVert.X, edge.Point1.X),
|
|
Math.Min(minVert.Y, edge.Point1.Y));
|
|
maxVert = new Vector2(
|
|
Math.Max(maxVert.X, edge.Point1.X),
|
|
Math.Max(maxVert.Y, edge.Point1.Y));
|
|
}
|
|
Vector2 center = (minVert + maxVert) / 2;
|
|
foreach (GraphEdge edge in cell.Edges)
|
|
{
|
|
if (!edge.IsSolid) { continue; }
|
|
|
|
//the left-side edge on this same cell
|
|
GraphEdge myLeftEdge = cell.Edges.Find(e => e != edge && (edge.Point1.NearlyEquals(e.Point1) || edge.Point1.NearlyEquals(e.Point2)));
|
|
//the left-side edge on either this cell, or the adjacent one if this is attached to another cell
|
|
GraphEdge leftEdge = myLeftEdge;
|
|
var leftAdjacentCell = leftEdge?.AdjacentCell(cell);
|
|
if (leftAdjacentCell != null)
|
|
{
|
|
var adjEdge = leftAdjacentCell.Edges.Find(e => e != leftEdge && e.IsSolid && (edge.Point1.NearlyEquals(e.Point1) || edge.Point1.NearlyEquals(e.Point2)));
|
|
if (adjEdge != null) { leftEdge = adjEdge; }
|
|
}
|
|
|
|
//the right-side edge on this same cell
|
|
GraphEdge myRightEdge = cell.Edges.Find(e => e != edge && (edge.Point2.NearlyEquals(e.Point1) || edge.Point2.NearlyEquals(e.Point2)));
|
|
//the right-side edge on either this cell, or the adjacent one if this is attached to another cell
|
|
GraphEdge rightEdge = myRightEdge;
|
|
var rightAdjacentCell = rightEdge?.AdjacentCell(cell);
|
|
if (rightAdjacentCell != null)
|
|
{
|
|
var adjEdge = rightAdjacentCell.Edges.Find(e => e != rightEdge && e.IsSolid && (edge.Point2.NearlyEquals(e.Point1) || edge.Point2.NearlyEquals(e.Point2)));
|
|
if (adjEdge != null) { rightEdge = adjEdge; }
|
|
}
|
|
|
|
Vector2 leftNormal = Vector2.Zero, rightNormal = Vector2.Zero;
|
|
|
|
float inwardThickness1 = Math.Min(expandInwards, edge.Length);
|
|
float inwardThickness2 = inwardThickness1;
|
|
if (leftEdge != null && !leftEdge.IsSolid)
|
|
{
|
|
//the left-side edge is non-solid (an edge between two cells, not an actual solid wall edge)
|
|
// -> expand in the direction of that edge
|
|
leftNormal = edge.Point1.NearlyEquals(leftEdge.Point1) ?
|
|
Vector2.Normalize(leftEdge.Point2 - leftEdge.Point1) :
|
|
Vector2.Normalize(leftEdge.Point1 - leftEdge.Point2);
|
|
//maximum expansion is half of the size of the edge (otherwise the expansions from different sides of the edge could overlap or even extend "through" the cell)
|
|
inwardThickness1 = Math.Min(inwardThickness1, leftEdge.Length / 2);
|
|
}
|
|
else if (leftEdge != null)
|
|
{
|
|
//use the average of this edge's and the adjacent edge's normals
|
|
leftNormal = -Vector2.Normalize(edge.GetNormal(cell) + leftEdge.GetNormal(leftAdjacentCell ?? cell));
|
|
if (!MathUtils.IsValid(leftNormal)) { leftNormal = -edge.GetNormal(cell); }
|
|
//maximum expansion is the length of the adjacent edge (more expansion causes the textures to distort)
|
|
inwardThickness1 = Math.Min(Math.Min(inwardThickness1, leftEdge.Length), myLeftEdge.Length);
|
|
}
|
|
else
|
|
{
|
|
leftNormal = Vector2.Normalize(cell.Center - edge.Point1);
|
|
}
|
|
inwardThickness1 = Math.Min(Vector2.Distance(edge.Point1, cell.Center), inwardThickness1);
|
|
|
|
if (!MathUtils.IsValid(leftNormal))
|
|
{
|
|
#if DEBUG
|
|
DebugConsole.ThrowError("Invalid left normal");
|
|
#endif
|
|
GameAnalyticsManager.AddErrorEventOnce("CaveGenerator.GenerateWallShapes:InvalidLeftNormal:" + level.Seed,
|
|
GameAnalyticsManager.ErrorSeverity.Warning,
|
|
"Invalid left normal (leftedge: " + leftEdge + ", rightedge: " + rightEdge + ", normal: " + leftNormal + ", seed: " + level.Seed + ")");
|
|
|
|
if (cell.Body != null)
|
|
{
|
|
if (GameMain.World.BodyList.Contains(cell.Body)) { GameMain.World.Remove(cell.Body); }
|
|
cell.Body = null;
|
|
}
|
|
leftNormal = Vector2.UnitX;
|
|
break;
|
|
}
|
|
|
|
if (rightEdge != null && !rightEdge.IsSolid)
|
|
{
|
|
rightNormal = edge.Point2.NearlyEquals(rightEdge.Point1) ?
|
|
Vector2.Normalize(rightEdge.Point2 - rightEdge.Point1) :
|
|
Vector2.Normalize(rightEdge.Point1 - rightEdge.Point2);
|
|
inwardThickness2 = Math.Min(inwardThickness2, rightEdge.Length / 2);
|
|
}
|
|
else if (rightEdge != null)
|
|
{
|
|
rightNormal = -Vector2.Normalize(edge.GetNormal(cell) + rightEdge.GetNormal(rightAdjacentCell ?? cell));
|
|
if (!MathUtils.IsValid(rightNormal)) { rightNormal = -edge.GetNormal(cell); }
|
|
inwardThickness2 = Math.Min(Math.Min(inwardThickness2, rightEdge.Length), myRightEdge.Length);
|
|
}
|
|
else
|
|
{
|
|
rightNormal = Vector2.Normalize(cell.Center - edge.Point2);
|
|
}
|
|
inwardThickness2 = Math.Min(Vector2.Distance(edge.Point2, cell.Center), inwardThickness2);
|
|
|
|
if (!MathUtils.IsValid(rightNormal))
|
|
{
|
|
#if DEBUG
|
|
DebugConsole.ThrowError("Invalid right normal");
|
|
#endif
|
|
GameAnalyticsManager.AddErrorEventOnce("CaveGenerator.GenerateWallShapes:InvalidRightNormal:" + level.Seed,
|
|
GameAnalyticsManager.ErrorSeverity.Warning,
|
|
"Invalid right normal (leftedge: " + leftEdge + ", rightedge: " + rightEdge + ", normal: " + rightNormal + ", seed: " + level.Seed + ")");
|
|
|
|
if (cell.Body != null)
|
|
{
|
|
if (GameMain.World.BodyList.Contains(cell.Body)) { GameMain.World.Remove(cell.Body); }
|
|
cell.Body = null;
|
|
}
|
|
rightNormal = Vector2.UnitX;
|
|
break;
|
|
}
|
|
|
|
float point1UV = MathUtils.WrapAngleTwoPi(MathUtils.VectorToAngle(edge.Point1 - center));
|
|
float point2UV = MathUtils.WrapAngleTwoPi(MathUtils.VectorToAngle(edge.Point2 - center));
|
|
//handle wrapping around 0/360
|
|
if (point1UV - point2UV > MathHelper.Pi)
|
|
{
|
|
point1UV -= MathHelper.TwoPi;
|
|
}
|
|
int textureRepeatCount = (int)Math.Max(circumference / 2 / level.GenerationParams.WallEdgeTextureWidth, 1);
|
|
point1UV = point1UV / MathHelper.TwoPi * textureRepeatCount;
|
|
point2UV = point2UV / MathHelper.TwoPi * textureRepeatCount;
|
|
|
|
//if calculating the UVs based on polar coordinates would result in stretching (using less than 10% of the texture for a wall the size of the texture)
|
|
//just calculate the UVs based on the length of the wall
|
|
//(this will mean the textures don't align at point2, but it doesn't seem that noticeable)
|
|
if ((point2UV - point1UV) * level.GenerationParams.WallEdgeTextureWidth < edge.Length * 0.1f)
|
|
{
|
|
point2UV = point1UV + edge.Length / 2 / level.GenerationParams.WallEdgeTextureWidth;
|
|
}
|
|
|
|
//"extruding" inwards, need to make sure we don't make the edge poke through the cell from the other side
|
|
if (preventExpandThroughCell)
|
|
{
|
|
foreach (GraphEdge otherEdge in cell.Edges)
|
|
{
|
|
if (otherEdge == edge || Vector2.Dot(otherEdge.GetNormal(cell), edge.GetNormal(cell)) > 0) { continue; }
|
|
if (otherEdge != leftEdge)
|
|
{
|
|
inwardThickness1 = ClampThickness(otherEdge, edge.Point1, leftNormal, inwardThickness1);
|
|
}
|
|
if (otherEdge != rightEdge)
|
|
{
|
|
inwardThickness2 = ClampThickness(otherEdge, edge.Point2, rightNormal, inwardThickness2);
|
|
}
|
|
}
|
|
|
|
static float ClampThickness(GraphEdge otherEdge, Vector2 thisPoint, Vector2 thisEdgeNormal, float currThickness)
|
|
{
|
|
if (MathUtils.GetLineIntersection(
|
|
thisPoint, thisPoint + thisEdgeNormal * currThickness,
|
|
otherEdge.Point1, otherEdge.Point2, areLinesInfinite: false, out Vector2 intersection1))
|
|
{
|
|
return Math.Min(currThickness, Vector2.Distance(thisPoint, intersection1));
|
|
}
|
|
return currThickness;
|
|
}
|
|
}
|
|
|
|
//there needs to be some minimum amount of inward thickness,
|
|
//if the edge texture doesn't extend inside at all you can see through between the edge texture and the solid part of the cell
|
|
inwardThickness1 = Math.Max(inwardThickness1, Math.Min(100.0f, expandInwards));
|
|
inwardThickness2 = Math.Max(inwardThickness2, Math.Min(100.0f, expandInwards));
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
Vector2[] verts = new Vector2[3];
|
|
VertexPositionColorTexture[] vertPos = new VertexPositionColorTexture[3];
|
|
|
|
if (i == 0)
|
|
{
|
|
verts[0] = edge.Point1 - leftNormal * outWardThickness;
|
|
verts[1] = edge.Point2 - rightNormal * outWardThickness;
|
|
verts[2] = edge.Point1 + leftNormal * inwardThickness1;
|
|
|
|
vertPos[0] = new VertexPositionColorTexture(new Vector3(verts[0], zCoord), outerColor, new Vector2(point1UV, 0.0f));
|
|
vertPos[1] = new VertexPositionColorTexture(new Vector3(verts[1], zCoord), outerColor, new Vector2(point2UV, 0.0f));
|
|
vertPos[2] = new VertexPositionColorTexture(new Vector3(verts[2], zCoord), innerColor, new Vector2(point1UV, 1.0f));
|
|
}
|
|
else
|
|
{
|
|
|
|
verts[0] = edge.Point1 + leftNormal * inwardThickness1;
|
|
verts[1] = edge.Point2 - rightNormal * outWardThickness;
|
|
verts[2] = edge.Point2 + rightNormal * inwardThickness2;
|
|
|
|
vertPos[0] = new VertexPositionColorTexture(new Vector3(verts[0], zCoord), innerColor, new Vector2(point1UV, 1.0f));
|
|
vertPos[1] = new VertexPositionColorTexture(new Vector3(verts[1], zCoord), outerColor, new Vector2(point2UV, 0.0f));
|
|
vertPos[2] = new VertexPositionColorTexture(new Vector3(verts[2], zCoord), innerColor, new Vector2(point2UV, 1.0f));
|
|
}
|
|
vertices.AddRange(vertPos);
|
|
}
|
|
}
|
|
}
|
|
|
|
return vertices;
|
|
}
|
|
}
|
|
}
|