public Plane(Plane inPlane)
{
A = inPlane.A;
B = inPlane.B;
C = inPlane.C;
D = inPlane.D;
}
public CSGMesh(Plane[] planes, List<Polygon> polygons, List<HalfEdge> edges, List<Vector3> vertices, AABB bounds)
{
this.Planes = planes;
this.Polygons = polygons;
this.Edges = edges;
this.Vertices = vertices;
this.Bounds.Set(bounds);
}
// 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 void Intersect(AABB cuttingNodeBounds,
Plane[] cuttingNodePlanes,
Vector3 cuttingNodeTranslation,
Vector3 inputPolygonTranslation,
List<Polygon> inputPolygons,
List<Polygon> inside,
List<Polygon> aligned,
List<Polygon> revAligned,
List<Polygon> outside)
{
var categories = new PolygonSplitResult[cuttingNodePlanes.Length];
var translatedPlanes = new Plane[cuttingNodePlanes.Length];
var translation = Vector3.Subtract(cuttingNodeTranslation, inputPolygonTranslation);
// translate the planes we cut our polygons with so that they're located at the same
// relative distance from the polygons as the brushes are from each other.
for (int i = 0; i < cuttingNodePlanes.Length; i++)
translatedPlanes[i] = Plane.Translated(cuttingNodePlanes[i], translation);
var vertices = this.Vertices;
var edges = this.Edges;
var planes = this.Planes;
for (int i = inputPolygons.Count - 1; i >= 0; i--)
{
var inputPolygon = inputPolygons[i];
if (inputPolygon.FirstIndex == -1)
continue;
var bounds = inputPolygon.Bounds;
var finalResult = PolygonSplitResult.CompletelyInside;
// A quick check if the polygon lies outside the planes we're cutting our polygons with.
if (!AABB.IsOutside(cuttingNodeBounds, translation, bounds))
{
PolygonSplitResult intermediateResult;
Polygon outsidePolygon = null;
for (int otherIndex = 0; otherIndex < translatedPlanes.Length; otherIndex++)
{
var translatedCuttingPlane = translatedPlanes[otherIndex];
var side = cuttingNodePlanes[otherIndex].OnSide(bounds, translation.Negated());
if (side == PlaneSideResult.Outside)
{
finalResult = PolygonSplitResult.CompletelyOutside;
break; // nothing left to process, so we exit
} else
if (side == PlaneSideResult.Inside)
continue;
var polygon = inputPolygon;
intermediateResult = PolygonSplit(translatedCuttingPlane, inputPolygonTranslation, ref polygon, out outsidePolygon);
inputPolygon = polygon;
if (intermediateResult == PolygonSplitResult.CompletelyOutside)
{
finalResult = PolygonSplitResult.CompletelyOutside;
break; // nothing left to process, so we exit
} else
if (intermediateResult == PolygonSplitResult.Split)
{
if (outside != null)
outside.Add(outsidePolygon);
// Note: left over is still completely inside,
// or plane (opposite) aligned
} else
if (intermediateResult != PolygonSplitResult.CompletelyInside)
finalResult = intermediateResult;
}
} else
finalResult = PolygonSplitResult.CompletelyOutside;
switch (finalResult)
{
case PolygonSplitResult.CompletelyInside: inside .Add(inputPolygon); break;
case PolygonSplitResult.CompletelyOutside: outside.Add(inputPolygon); break;
// The polygon can only be visible if it's part of the last brush that shares it's surface area,
// otherwise we'd get overlapping polygons if two brushes overlap.
// When the (final) polygon is aligned with one of the cutting planes, we know it lies on the surface of
// the CSG node we're cutting the polygons with. We also know that this node is not the node this polygon belongs to
// because we've done that check earlier on. So we flag this polygon as being invisible.
case PolygonSplitResult.PlaneAligned: inputPolygon.Visible = false; aligned .Add(inputPolygon); break;
case PolygonSplitResult.PlaneOppositeAligned: inputPolygon.Visible = false; revAligned.Add(inputPolygon); break;
}
}
}
public CSGMesh Clone()
{
var newPlanes = new Plane[Planes.Length];
for (int i = 0; i < Planes.Length; i++)
{
var plane = Planes[i];
newPlanes[i] = new Plane(plane.A, plane.B, plane.C, plane.D);
}
var newPolygons = new List<Polygon>(Polygons.Count);
foreach (var polygon in Polygons)
{
var newPolygon = new Polygon();
newPolygon.FirstIndex = polygon.FirstIndex;
newPolygon.Visible = polygon.Visible;
newPolygon.Category = polygon.Category;
newPolygon.PlaneIndex = polygon.PlaneIndex;
newPolygon.Bounds.Set(polygon.Bounds);
newPolygons.Add(newPolygon);
}
var newEdges = new List<HalfEdge>(Edges.Count);
foreach (var edge in Edges)
{
var newEdge = new HalfEdge();
newEdge.NextIndex = edge.NextIndex;
newEdge.PolygonIndex = edge.PolygonIndex;
newEdge.TwinIndex = edge.TwinIndex;
newEdge.VertexIndex = edge.VertexIndex;
newEdges.Add(newEdge);
}
var newVertices = new List<Vector3>(Vertices.Count);
foreach (var vertex in Vertices)
{
var newVertex = new Vector3(vertex.X, vertex.Y, vertex.Z);
newVertices.Add(newVertex);
}
var newBounds = new AABB(Bounds);
var newMesh = new CSGMesh(
newPlanes,
newPolygons,
newEdges,
newVertices,
newBounds);
return newMesh;
}
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);
}
public bool Equals(Plane other)
{
if (Object.ReferenceEquals(this, other))
return true;
if (Object.ReferenceEquals(other, null))
return false;
return D == other.D &&
A == other.A &&
B == other.B &&
C == other.C;
}
public bool EpsilonEquals(Plane other)
{
var epsilon = 0.001f;
return D > other.D - epsilon && D < other.D + epsilon &&
A > other.A - epsilon && A < other.A + epsilon &&
B > other.B - epsilon && B < other.B + epsilon &&
C > other.C - epsilon && C < other.C + epsilon;
}
public static Plane Translated(Plane plane, float translateX, float translateY, float translateZ)
{
return new Plane(plane.A, plane.B, plane.C,
// translated offset = plane.Normal.Dotproduct(translation)
// normal = A,B,C
plane.D + (plane.A * translateX) +
(plane.B * translateY) +
(plane.C * translateZ));
}
public static Plane Translated(Plane plane, Vector3 translation)
{
return new Plane(plane.A, plane.B, plane.C,
// translated offset = plane.Normal.Dotproduct(translation)
// normal = A,B,C
plane.D + (plane.A * translation.X) +
(plane.B * translation.Y) +
(plane.C * translation.Z));
}
public static Vector3 Intersection(Plane inPlane1,
Plane inPlane2,
Plane inPlane3)
{
// intersection point with 3 planes
// {
// x = -( c2*b1*d3-c2*b3*d1+b3*c1*d2+c3*b2*d1-b1*c3*d2-c1*b2*d3)/
// (-c2*b3*a1+c3*b2*a1-b1*c3*a2-c1*b2*a3+b3*c1*a2+c2*b1*a3),
// y = ( c3*a2*d1-c3*a1*d2-c2*a3*d1+d2*c1*a3-a2*c1*d3+c2*d3*a1)/
// (-c2*b3*a1+c3*b2*a1-b1*c3*a2-c1*b2*a3+b3*c1*a2+c2*b1*a3),
// z = -(-a2*b1*d3+a2*b3*d1-a3*b2*d1+d3*b2*a1-d2*b3*a1+d2*b1*a3)/
// (-c2*b3*a1+c3*b2*a1-b1*c3*a2-c1*b2*a3+b3*c1*a2+c2*b1*a3)
// }
double bc1 = (inPlane1.B * inPlane3.C) - (inPlane3.B * inPlane1.C);
double bc2 = (inPlane2.B * inPlane1.C) - (inPlane1.B * inPlane2.C);
double bc3 = (inPlane3.B * inPlane2.C) - (inPlane2.B * inPlane3.C);
double ad1 = (inPlane1.A * inPlane3.D) - (inPlane3.A * inPlane1.D);
double ad2 = (inPlane2.A * inPlane1.D) - (inPlane1.A * inPlane2.D);
double ad3 = (inPlane3.A * inPlane2.D) - (inPlane2.A * inPlane3.D);
double x = -((inPlane1.D * bc3) + (inPlane2.D * bc1) + (inPlane3.D * bc2));
double y = -((inPlane1.C * ad3) + (inPlane2.C * ad1) + (inPlane3.C * ad2));
double z = +((inPlane1.B * ad3) + (inPlane2.B * ad1) + (inPlane3.B * ad2));
double w = -((inPlane1.A * bc3) + (inPlane2.A * bc1) + (inPlane3.A * bc2));
// better to have detectable invalid values than to have reaaaaaaally big values
if (w > -Constants.NormalEpsilon && w < Constants.NormalEpsilon)
{
return new Vector3(float.NaN,
float.NaN,
float.NaN);
}
else
return new Vector3((float)(x / w),
(float)(y / w),
(float)(z / w));
}
public StaticBrushGenerator(Plane[] planes)
{
this.Planes = planes;
}
