// Splits a polygon into two pieces, or categorizes it as outside, inside or aligned
#region PolygonSplit
// Note: This method is not optimized! Code is simplified for clarity!
// for example: Plane.Distance / Plane.OnSide should be inlined manually and shouldn't use enums, but floating point values directly!
public PolygonSplitResult PolygonSplit(Plane cuttingPlane, Vector3 translation, ref Polygon inputPolygon, out Polygon outsidePolygon)
{
HalfEdge prev = Edges[inputPolygon.FirstIndex];
HalfEdge current = Edges[prev.NextIndex];
HalfEdge next = Edges[current.NextIndex];
HalfEdge last = next;
HalfEdge enterEdge = null;
HalfEdge exitEdge = null;
var prevVertex = Vertices[prev.VertexIndex];
var prevDistance = cuttingPlane.Distance(prevVertex); // distance to previous vertex
var prevSide = Plane.OnSide(prevDistance); // side of plane of previous vertex
var currentVertex = Vertices[current.VertexIndex];
var currentDistance = cuttingPlane.Distance(currentVertex); // distance to current vertex
var currentSide = Plane.OnSide(currentDistance); // side of plane of current vertex
do
{
var nextVertex = Vertices[next.VertexIndex];
var nextDistance = cuttingPlane.Distance(nextVertex); // distance to next vertex
var nextSide = Plane.OnSide(nextDistance); // side of plane of next vertex
if (prevSide != currentSide) // check if edge crossed the plane ...
{
if (currentSide != PlaneSideResult.Intersects) // prev:inside/outside - current:inside/outside - next:??
{
if (prevSide != PlaneSideResult.Intersects) // prev:inside/outside - current:outside - next:??
{
// Calculate intersection of edge with plane split the edge into two, inserting the new vertex
var newVertex = Plane.Intersection(prevVertex, currentVertex, prevDistance, currentDistance);
var newEdge = EdgeSplit(current, newVertex);
if (prevSide == PlaneSideResult.Inside) // prev:inside - current:outside - next:??
{
//edge01 exits:
//
// outside
// 1
// *
// ......./........ intersect
// /
// 0
// inside
exitEdge = current;
}
else
if (prevSide == PlaneSideResult.Outside) // prev:outside - current:inside - next:??
{
//edge01 enters:
//
// outside
// 0
// \
// .......\........ intersect
// *
// 1
// inside
enterEdge = current;
}
prevDistance = 0;
prev = Edges[prev.NextIndex];
prevSide = PlaneSideResult.Intersects;
if (exitEdge != null &&
enterEdge != null)
{
break;
}
current = Edges[prev.NextIndex];
currentVertex = Vertices[current.VertexIndex];
next = Edges[current.NextIndex];
nextVertex = Vertices[next.VertexIndex];
}
}
else // prev:?? - current:intersects - next:??
{
if (prevSide == PlaneSideResult.Intersects || // prev:intersects - current:intersects - next:??
nextSide == PlaneSideResult.Intersects || // prev:?? - current:intersects - next:intersects
prevSide == nextSide) // prev:inside/outde - current:intersects - next:inside/outde
{
if (prevSide == PlaneSideResult.Inside || // prev:inside - current:intersects - next:intersects/inside
nextSide == PlaneSideResult.Inside) // prev:intersects/inside - current:intersects - next:inside
{
// outside
// 0 1
// --------*....... intersect
// \
// 2
// inside
//
// outside
// 1 2
// ........*------- intersect
// /
// 0
// inside
//
// outside
// 1
//........*....... intersect
// / \
// 0 2
// inside
//
prevSide = PlaneSideResult.Inside;
enterEdge = exitEdge = null;
break;
}
else
if (prevSide == PlaneSideResult.Outside || // prev:outside - current:intersects - next:intersects/outside
nextSide == PlaneSideResult.Outside) // prev:intersects/outside - current:intersects - next:outside
{
// outside
// 2
// /
//..------*....... intersect
// 0 1
// inside
//
// outside
// 0
// \
//........*------- intersect
// 1 2
// inside
//
// outside
// 0 2
// \ /
//........*....... intersect
// 1
// inside
//
prevSide = PlaneSideResult.Outside;
enterEdge = exitEdge = null;
break;
}
}
else // prev:inside/outside - current:intersects - next:inside/outside
{
if (prevSide == PlaneSideResult.Inside) // prev:inside - current:intersects - next:outside
{
//find exit edge:
//
// outside
// 2
// 1 /
// ........*....... intersect
// /
// 0
// inside
exitEdge = current;
if (enterEdge != null)
{
break;
}
}
else // prev:outside - current:intersects - next:inside
{
//find enter edge:
//
// outside
// 0
// \ 1
// ........*....... intersect
// \
// 2
// inside
enterEdge = current;
if (exitEdge != null)
{
break;
}
}
}
}
}
prev = current;
current = next;
next = Edges[next.NextIndex];
prevDistance = currentDistance;
currentDistance = nextDistance;
prevSide = currentSide;
currentSide = nextSide;
prevVertex = currentVertex;
currentVertex = nextVertex;
} while (next != last);
// We should never have only one edge crossing the plane ..
Debug.Assert((enterEdge == null) == (exitEdge == null));
// Check if we have an edge that exits and an edge that enters the plane and split the polygon into two if we do
if (enterEdge != null && exitEdge != null)
{
//enter .
// .
// =====>*----->
// .
//
//outside . inside
// .
// <-----*<=====
// .
// . exit
outsidePolygon = new Polygon();
var outsidePolygonIndex = (short)this.Polygons.Count;
this.Polygons.Add(outsidePolygon);
var outsideEdge = new HalfEdge();
var outsideEdgeIndex = (short)Edges.Count;
var insideEdge = new HalfEdge();
var insideEdgeIndex = (short)(outsideEdgeIndex + 1);
outsideEdge.TwinIndex = insideEdgeIndex;
insideEdge.TwinIndex = outsideEdgeIndex;
//insideEdge.PolygonIndex = inputPolygonIndex;// index does not change
outsideEdge.PolygonIndex = outsidePolygonIndex;
outsideEdge.VertexIndex = exitEdge.VertexIndex;
insideEdge.VertexIndex = enterEdge.VertexIndex;
outsideEdge.NextIndex = exitEdge.NextIndex;
insideEdge.NextIndex = enterEdge.NextIndex;
exitEdge.NextIndex = insideEdgeIndex;
enterEdge.NextIndex = outsideEdgeIndex;
outsidePolygon.FirstIndex = outsideEdgeIndex;
inputPolygon.FirstIndex = insideEdgeIndex;
outsidePolygon.Visible = inputPolygon.Visible;
outsidePolygon.Category = inputPolygon.Category;
outsidePolygon.PlaneIndex = inputPolygon.PlaneIndex;
Edges.Add(outsideEdge);
Edges.Add(insideEdge);
// calculate the bounds of the polygons
outsidePolygon.Bounds.Clear();
var first = Edges[outsidePolygon.FirstIndex];
var iterator = first;
do
{
outsidePolygon.Bounds.Add(Vertices[iterator.VertexIndex]);
iterator.PolygonIndex = outsidePolygonIndex;
iterator = Edges[iterator.NextIndex];
} while (iterator != first);
inputPolygon.Bounds.Clear();
first = Edges[inputPolygon.FirstIndex];
iterator = first;
do
{
inputPolygon.Bounds.Add(Vertices[iterator.VertexIndex]);
iterator = Edges[iterator.NextIndex];
} while (iterator != first);
return(PolygonSplitResult.Split);
}
else
{
outsidePolygon = null;
switch (prevSide)
{
case PlaneSideResult.Inside: return(PolygonSplitResult.CompletelyInside);
case PlaneSideResult.Outside: return(PolygonSplitResult.CompletelyOutside);
default:
case PlaneSideResult.Intersects:
{
var polygonPlane = Planes[inputPolygon.PlaneIndex];
var result = Vector3.DotProduct(polygonPlane.Normal, cuttingPlane.Normal);
if (result > 0)
{
return(PolygonSplitResult.PlaneAligned);
}
else
{
return(PolygonSplitResult.PlaneOppositeAligned);
}
}
}
}
}
public static CSGMesh CreateFromPlanes(Plane[] brushPlanes)
{
var planes = new Plane[brushPlanes.Length];
for (int i = 0; i < brushPlanes.Length; i++)
{
var plane = brushPlanes[i];
planes[i] = new Plane(plane.A, plane.B, plane.C, plane.D);
}
var pointIntersections = new List <PointIntersection>(planes.Length * planes.Length);
var intersectingPlanes = new List <short>();
var vertices = new List <Vector3>();
var edges = new List <HalfEdge>();
// Find all point intersections where 3 (or more planes) intersect
for (short planeIndex1 = 0; planeIndex1 < planes.Length - 2; planeIndex1++)
{
var plane1 = planes[planeIndex1];
for (short planeIndex2 = (short)(planeIndex1 + 1); planeIndex2 < planes.Length - 1; planeIndex2++)
{
var plane2 = planes[planeIndex2];
for (short planeIndex3 = (short)(planeIndex2 + 1); planeIndex3 < planes.Length; planeIndex3++)
{
var plane3 = planes[planeIndex3];
// Calculate the intersection
var vertex = Plane.Intersection(plane1, plane2, plane3);
// Check if the intersection is valid
if (float.IsNaN(vertex.X) || float.IsNaN(vertex.Y) || float.IsNaN(vertex.Z) ||
float.IsInfinity(vertex.X) || float.IsInfinity(vertex.Y) || float.IsInfinity(vertex.Z))
{
continue;
}
intersectingPlanes.Clear();
intersectingPlanes.Add(planeIndex1);
intersectingPlanes.Add(planeIndex2);
intersectingPlanes.Add(planeIndex3);
for (short planeIndex4 = 0; planeIndex4 < planes.Length; planeIndex4++)
{
if (planeIndex4 == planeIndex1 ||
planeIndex4 == planeIndex2 ||
planeIndex4 == planeIndex3)
{
continue;
}
var plane4 = planes[planeIndex4];
var side = plane4.OnSide(vertex);
if (side == PlaneSideResult.Intersects)
{
if (planeIndex4 < planeIndex3)
{
// Already found this vertex
goto SkipIntersection;
}
// We've found another plane which goes trough our found intersection point
intersectingPlanes.Add(planeIndex4);
}
else
if (side == PlaneSideResult.Outside)
{
// Intersection is outside of brush
goto SkipIntersection;
}
}
var vertexIndex = (short)vertices.Count;
vertices.Add(vertex);
// Add intersection point to our list
pointIntersections.Add(new PointIntersection(vertexIndex, intersectingPlanes));
SkipIntersection:
;
}
}
}
var foundPlanes = new short[2];
// Find all our intersection edges which are formed by a pair of planes
// (this could probably be done inside the previous loop)
for (int i = 0; i < pointIntersections.Count; i++)
{
var pointIntersectionA = pointIntersections[i];
for (int j = i + 1; j < pointIntersections.Count; j++)
{
var pointIntersectionB = pointIntersections[j];
var planesIndicesA = pointIntersectionA.PlaneIndices;
var planesIndicesB = pointIntersectionB.PlaneIndices;
short foundPlaneIndex = 0;
foreach (var currentPlaneIndex in planesIndicesA)
{
if (!planesIndicesB.Contains(currentPlaneIndex))
{
continue;
}
foundPlanes[foundPlaneIndex] = currentPlaneIndex;
foundPlaneIndex++;
if (foundPlaneIndex == 2)
{
break;
}
}
// If foundPlaneIndex is 0 or 1 then either this combination does not exist,
// or only goes trough one point
if (foundPlaneIndex < 2)
{
continue;
}
// Create our found intersection edge
var halfEdgeA = new HalfEdge();
var halfEdgeAIndex = (short)edges.Count;
edges.Add(halfEdgeA);
var halfEdgeB = new HalfEdge();
var halfEdgeBIndex = (short)edges.Count;
edges.Add(halfEdgeB);
halfEdgeA.TwinIndex = halfEdgeBIndex;
halfEdgeB.TwinIndex = halfEdgeAIndex;
halfEdgeA.VertexIndex = pointIntersectionA.VertexIndex;
halfEdgeB.VertexIndex = pointIntersectionB.VertexIndex;
// Add it to our points
pointIntersectionA.Edges.Add(new EdgeIntersection(
halfEdgeA,
foundPlanes[0],
foundPlanes[1]));
pointIntersectionB.Edges.Add(new EdgeIntersection(
halfEdgeB,
foundPlanes[0],
foundPlanes[1]));
}
}
var polygons = new List <Polygon>();
for (short i = 0; i < (short)planes.Length; i++)
{
var polygon = new Polygon();
polygon.PlaneIndex = i;
polygons.Add(polygon);
}
var bounds = new AABB();
var direction = new Vector3();
for (int i = pointIntersections.Count - 1; i >= 0; i--)
{
var pointIntersection = pointIntersections[i];
var pointEdges = pointIntersection.Edges;
// Make sure that we have at least 2 edges ...
// This may happen when a plane only intersects at a single edge.
if (pointEdges.Count <= 2)
{
pointIntersections.RemoveAt(i);
continue;
}
var vertexIndex = pointIntersection.VertexIndex;
var vertex = vertices[vertexIndex];
for (int j = 0; j < pointEdges.Count - 1; j++)
{
var edge1 = pointEdges[j];
for (int k = j + 1; k < pointEdges.Count; k++)
{
var edge2 = pointEdges[k];
int planeIndex1 = -1;
int planeIndex2 = -1;
// Determine if and which of our 2 planes are identical
if (edge1.PlaneIndices[0] == edge2.PlaneIndices[0])
{
planeIndex1 = 0; planeIndex2 = 0;
}
else
if (edge1.PlaneIndices[0] == edge2.PlaneIndices[1])
{
planeIndex1 = 0; planeIndex2 = 1;
}
else
if (edge1.PlaneIndices[1] == edge2.PlaneIndices[0])
{
planeIndex1 = 1; planeIndex2 = 0;
}
else
if (edge1.PlaneIndices[1] == edge2.PlaneIndices[1])
{
planeIndex1 = 1; planeIndex2 = 1;
}
else
{
continue;
}
HalfEdge ingoing;
HalfEdge outgoing;
short outgoingIndex;
var shared_plane = planes[edge1.PlaneIndices[planeIndex1]];
var edge1_plane = planes[edge1.PlaneIndices[1 - planeIndex1]];
var edge2_plane = planes[edge2.PlaneIndices[1 - planeIndex2]];
direction = Vector3.CrossProduct(shared_plane.Normal, edge1_plane.Normal);
// Determine the orientation of our two edges to determine
// which edge is in-going, and which one is out-going
if (Vector3.DotProduct(direction, edge2_plane.Normal) < 0)
{
ingoing = edge2.Edge;
outgoingIndex = edge1.Edge.TwinIndex;
outgoing = edges[outgoingIndex];
}
else
{
ingoing = edge1.Edge;
outgoingIndex = edge2.Edge.TwinIndex;
outgoing = edges[outgoingIndex];
}
// Link the out-going half-edge to the in-going half-edge
ingoing.NextIndex = outgoingIndex;
// Add reference to polygon to half-edge, and make sure our
// polygon has a reference to a half-edge
// Since a half-edge, in this case, serves as a circular
// linked list this just works.
var polygonIndex = edge1.PlaneIndices[planeIndex1];
ingoing.PolygonIndex = polygonIndex;
outgoing.PolygonIndex = polygonIndex;
var polygon = polygons[polygonIndex];
polygon.FirstIndex = outgoingIndex;
polygon.Bounds.Add(vertex);
}
}
// Add the intersection point to the area of our bounding box
bounds.Add(vertex);
}
return(new CSGMesh(planes, polygons, edges, vertices, bounds));
}