/// <summary>
/// Determines the collinearity between a point and an edge.
/// </summary>
/// <param name="point">The point.</param>
/// <param name="edge">The edge.</param>
/// <returns>
/// The type of collinearity.
/// </returns>
internal static Collinearity GetCollinearity(Vector3 point, DcelEdge edge)
{
Vector3 v0 = edge.Origin.Position;
Vector3 v1 = edge.Twin.Origin.Position;
Vector3 segment = v1 - v0;
float segmentLengthSquared = segment.LengthSquared();
// Vector from segment to point.
Vector3 v0ToPoint = point - v0;
// Compute normal component of v0ToPoint (= v0ToPoint - "v0ToPoint projected on segment").
float v0ToPointDotSegment = Vector3.Dot(v0ToPoint, segment);
Vector3 normalFromLineToPoint = v0ToPoint - v0ToPointDotSegment / segmentLengthSquared * segment;
if (normalFromLineToPoint.LengthSquared() > Numeric.EpsilonF * (1 + segmentLengthSquared))
{
// point is not on line.
return(Collinearity.NotCollinear);
}
if (v0ToPointDotSegment < -Numeric.EpsilonF * segmentLengthSquared)
{
return(Collinearity.CollinearBefore);
}
if (v0ToPointDotSegment > (1 + Numeric.EpsilonF) * segmentLengthSquared)
{
return(Collinearity.CollinearAfter);
}
return(Collinearity.CollinearContained);
}
/// <summary>
/// Adds the given edge to the stack if its <see cref="DcelEdge.Tag"/> is not equal to the given
/// tag.
/// </summary>
/// <param name="edge">The edge. (Can be <see langword="null"/>.)</param>
/// <param name="stack">The stack.</param>
/// <param name="tag">The tag.</param>
private static void AddUntaggedEdgeToStack(DcelEdge edge, Stack <DcelEdge> stack, int tag)
{
Debug.Assert(stack != null);
if (edge != null && edge.Tag != tag)
{
stack.Push(edge);
}
}
/// <summary>
/// Builds the component lists.
/// </summary>
/// <param name="edge">The current edge.</param>
/// <remarks>
/// This method calls itself recursively.
/// </remarks>
private void BuildLists(DcelEdge edge)
{
if (edge == null)
{
return;
}
Stack <DcelEdge> todoStack = new Stack <DcelEdge>();
todoStack.Push(edge);
while (todoStack.Count > 0)
{
edge = todoStack.Pop();
if (edge.InternalTag == 1)
{
continue;
}
// Register edge.
edge.InternalTag = 1;
_edges.Add(edge);
// Register new vertices.
if (edge.Origin != null && edge.Origin.InternalTag != 1)
{
edge.Origin.InternalTag = 1;
_vertices.Add(edge.Origin);
AddUntaggedEdgeToStackInternal(edge.Origin.Edge, todoStack, 1);
}
// Register new faces.
if (edge.Face != null && edge.Face.InternalTag != 1)
{
edge.Face.InternalTag = 1;
_faces.Add(edge.Face);
AddUntaggedEdgeToStackInternal(edge.Face.Boundary, todoStack, 1);
if (edge.Face.Holes != null)
{
for (int i = 0; i < edge.Face.Holes.Count; i++)
{
AddUntaggedEdgeToStackInternal(edge.Face.Holes[i], todoStack, 1);
}
}
}
// Follow neighboring edges.
AddUntaggedEdgeToStackInternal(edge.Next, todoStack, 1);
AddUntaggedEdgeToStackInternal(edge.Previous, todoStack, 1);
AddUntaggedEdgeToStackInternal(edge.Twin, todoStack, 1);
}
// Reset tags.
ResetInternalTags();
}
/// <summary>
/// Sets the tags of the DCEL mesh component and linked components to the given tag value.
/// </summary>
/// <param name="edge">The edge. (Can be <see langword="null"/>.)</param>
/// <param name="tag">The tag.</param>
/// <remarks>
/// This method does nothing if <paramref name="edge"/> is already tagged with the given value.
/// </remarks>
private static void TagLinkedComponents(DcelEdge edge, int tag)
{
// Important: This method does not create recursive calls. This could
// lead to stack overflows very quickly!
if (edge == null || edge.Tag == tag)
{
return;
}
Stack <DcelEdge> todoStack = new Stack <DcelEdge>();
todoStack.Push(edge);
while (todoStack.Count > 0)
{
edge = todoStack.Pop();
if (edge.Tag == tag)
{
continue;
}
// Tag edge.
edge.Tag = tag;
// Tag vertex
if (edge.Origin != null)
{
edge.Origin.Tag = 1;
}
// Tag faces.
if (edge.Face != null && edge.Face.Tag != tag)
{
edge.Face.Tag = tag;
AddUntaggedEdgeToStack(edge.Face.Boundary, todoStack, tag);
if (edge.Face.Holes != null)
{
for (int i = 0; i < edge.Face.Holes.Count; i++)
{
AddUntaggedEdgeToStack(edge.Face.Holes[i], todoStack, tag);
}
}
}
// Follow connected edges.
AddUntaggedEdgeToStack(edge.Next, todoStack, 1);
AddUntaggedEdgeToStack(edge.Previous, todoStack, 1);
AddUntaggedEdgeToStack(edge.Twin, todoStack, 1);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VertexAdjacency"/> class.
/// </summary>
/// <param name="mesh">The mesh for which the adjacency information is built.</param>
/// <exception cref="NotSupportedException">
/// Too many vertices in convex hull. Max. 65534 vertices in convex hull are supported.
/// </exception>
public VertexAdjacency(DcelMesh mesh)
{
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
int numberOfVertices = mesh.Vertices.Count;
if (numberOfVertices >= ushort.MaxValue)
{
throw new NotSupportedException("Too many vertices in convex hull. Max. 65534 vertices in convex hull are supported.");
}
Debug.Assert(mesh.Vertices.All(v => v.Tag == 0), "Tags of DcelMesh should be cleared.");
// Store the index of each vertex in its tag for fast lookup.
for (int i = 0; i < numberOfVertices; i++)
{
mesh.Vertices[i].Tag = i;
}
ListIndices = new ushort[numberOfVertices + 1];
List <ushort> adjacencyLists = new List <ushort>(numberOfVertices * 4);
for (int i = 0; i < numberOfVertices; i++)
{
DcelVertex vertex = mesh.Vertices[i];
ListIndices[i] = (ushort)adjacencyLists.Count;
// Gather all adjacent vertices.
DcelEdge startEdge = vertex.Edge;
DcelEdge edge = startEdge;
do
{
DcelVertex adjacentVertex = edge.Next.Origin;
int adjacentIndex = adjacentVertex.Tag;
Debug.Assert(mesh.Vertices[adjacentIndex] == adjacentVertex, "Indices stored in DcelVertex.Tag are invalid.");
adjacencyLists.Add((ushort)adjacentIndex);
edge = edge.Twin.Next;
} while (edge != startEdge);
}
// Add one additional entry which determines the end of the last adjacency list.
ListIndices[numberOfVertices] = (ushort)adjacencyLists.Count;
// Copy adjacency lists into static array.
Lists = adjacencyLists.ToArray();
}
// Links to half-edges via Twin links if they are on the same edge (same vertices).
private static void TryLink(DcelEdge edge0, DcelEdge edge1)
{
var start0 = edge0.Origin;
var end0 = edge0.Next.Origin;
var start1 = edge1.Origin;
var end1 = edge1.Next.Origin;
Debug.Assert(edge0 != edge1 && !(start0 == start1 && end0 == end1), "Two edges are identical.");
if (start0 == end1 && end0 == start1)
{
edge0.Twin = edge1;
edge1.Twin = edge0;
}
}
// edge vertices must have the plane distance in DcelVertex.UserData. This method computes
// where the edge is split.
private static Vector3 GetCutPosition(DcelEdge edge)
{
var startVertex = edge.Origin;
var startDistance = (float)startVertex.UserData;
var endVertex = edge.Twin.Origin;
var endDistance = (float)endVertex.UserData;
// Get interpolation parameter.
var parameter = Math.Abs(startDistance) / (Math.Abs(startDistance) + Math.Abs(endDistance));
// Get position where edge is cut.
var cutPosition = startVertex.Position * (1 - parameter) + endVertex.Position * parameter;
return(cutPosition);
}
/// <summary>
/// Determines the collinearity between a point and an edge of a face.
/// </summary>
/// <param name="point">The point.</param>
/// <param name="edge">The edge.</param>
/// <param name="faceNormal">The face normal (of the face of the edge).</param>
/// <param name="inFront">
/// A value that is positive if the point is in front (outside of the face).
/// And the value is proportional to the distance of the point from the edge.
/// </param>
/// <returns>The collinearity type.</returns>
internal static Collinearity GetCollinearity(Vector3 point, DcelEdge edge, Vector3 faceNormal, out float inFront)
{
Vector3 v0 = edge.Origin.Position;
Vector3 v1 = edge.Twin.Origin.Position;
Vector3 segment = v1 - v0;
float segmentLengthSquared = segment.LengthSquared();
// See Geometric Tools for Computer Graphics, p. 736 for explanation in 2D.
// Here we do the same in 3D. Our face normal is normalized.
Debug.Assert(faceNormal.IsNumericallyNormalized);
// The needed normal is computed from the face normal.
// The normal lies in the face plane and points away from the face.
Vector3 normal = Vector3.Cross(segment, faceNormal);
float normalLengthSquared = normal.LengthSquared();
Vector3 v0ToPoint = point - v0;
float v0ToPointLengthSquared = v0ToPoint.LengthSquared();
float dot = Vector3.Dot(v0ToPoint, normal);
inFront = dot;
if (dot * dot > Numeric.EpsilonF * normalLengthSquared * v0ToPointLengthSquared)
{
if (dot > 0)
{
return(Collinearity.NotCollinearInFront); // Edge is visible from point.
}
if (dot < 0)
{
return(Collinearity.NotCollinearBehind); // Edge is not visible from point.
}
}
dot = Vector3.Dot(segment, v0ToPoint);
if (dot < -Numeric.EpsilonF * segmentLengthSquared)
{
return(Collinearity.CollinearBefore);
}
if (dot > (1 + Numeric.EpsilonF) * segmentLengthSquared)
{
return(Collinearity.CollinearAfter);
}
return(Collinearity.CollinearContained);
}
/// <summary>
/// Initializes a new instance of the <see cref="DcelVertex"/> class with a given position and
/// edge.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="edge">The edge.</param>
public DcelVertex(Vector3 position, DcelEdge edge)
{
Position = position;
Edge = edge;
}
public static DcelMesh FromTriangleMesh(TriangleMesh mesh)
{
// TODO: To optimize, check tricks of TriangleMeshShape.ComputeNeighbors.
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
if (mesh.Vertices == null || mesh.Indices == null)
{
throw new ArgumentException("Input mesh has no vertices or vertex indices.");
}
// Create vertices.
int numberOfVertices = mesh.Vertices.Count;
var vertices = new List <DcelVertex>(numberOfVertices);
foreach (var position in mesh.Vertices)
{
vertices.Add(new DcelVertex(position, null));
}
// Weld similar vertices.
for (int i = 0; i < numberOfVertices; i++)
{
for (int j = i + 1; j < numberOfVertices; j++)
{
if (Vector3.AreNumericallyEqual(vertices[i].Position, vertices[j].Position))
{
vertices[i] = vertices[j];
}
}
}
// Create edges and faces for each triangle.
// We need at least 3 edges for each triangle. We might need more edges if we have to
// connect unconnected islands of triangles.
var edges = new List <DcelEdge>(mesh.NumberOfTriangles * 3 * 2);
var faces = new List <DcelFace>(mesh.NumberOfTriangles);
for (int i = 0; i < mesh.NumberOfTriangles; i++)
{
// Get triangle indices.
var index0 = mesh.Indices[i * 3 + 0];
var index1 = mesh.Indices[i * 3 + 1];
var index2 = mesh.Indices[i * 3 + 2];
// Get DCEL vertices.
var vertex0 = vertices[index0];
var vertex1 = vertices[index1];
var vertex2 = vertices[index2];
// Create 3 edges.
var edge0 = new DcelEdge();
var edge1 = new DcelEdge();
var edge2 = new DcelEdge();
// Create 1 face.
var face = new DcelFace();
// Fill out face info.
face.Boundary = edge0;
// Fill out vertex info.
vertex0.Edge = edge0;
vertex1.Edge = edge1;
vertex2.Edge = edge2;
// Fill out edge info.
// Twin links are created later.
edge0.Face = face;
edge0.Origin = vertex0;
edge0.Next = edge1;
edge0.Previous = edge2;
edge1.Face = face;
edge1.Origin = vertex1;
edge1.Next = edge2;
edge1.Previous = edge0;
edge2.Face = face;
edge2.Origin = vertex2;
edge2.Next = edge0;
edge2.Previous = edge1;
// Add to lists.
edges.Add(edge0);
edges.Add(edge1);
edges.Add(edge2);
faces.Add(face);
}
// Connect triangles that share an edge.
for (int i = 0; i < faces.Count; i++)
{
// Get face and its 3 edges.
var faceI = faces[i];
var edgeI0 = faceI.Boundary;
var edgeI1 = edgeI0.Next;
var edgeI2 = edgeI1.Next;
Debug.Assert(edgeI2.Next == edgeI0);
for (int j = i + 1; j < faces.Count; j++)
{
// Get face and its 3 edges.
var faceJ = faces[j];
var edgeJ0 = faceJ.Boundary;
var edgeJ1 = edgeJ0.Next;
var edgeJ2 = edgeJ1.Next;
Debug.Assert(edgeJ2.Next == edgeJ0);
TryLink(edgeI0, edgeJ0);
TryLink(edgeI0, edgeJ1);
TryLink(edgeI0, edgeJ2);
TryLink(edgeI1, edgeJ0);
TryLink(edgeI1, edgeJ1);
TryLink(edgeI1, edgeJ2);
TryLink(edgeI2, edgeJ0);
TryLink(edgeI2, edgeJ1);
TryLink(edgeI2, edgeJ2);
}
}
// If the mesh is not closed, we have to add twin edges at the boundaries
foreach (var edge in edges.ToArray())
{
if (edge.Twin == null)
{
var twin = new DcelEdge();
twin.Origin = edge.Next.Origin;
twin.Twin = edge;
edge.Twin = twin;
edges.Add(twin);
}
}
// Yet, twin.Next/Previous were not set.
foreach (var edge in edges)
{
if (edge.Previous == null)
{
// The previous edge has not been set.
// Search the edges around the origin until we find the previous unconnected edge.
var origin = edge.Origin;
var originEdge = edge.Twin.Next; // Another edge with the same origin.
while (originEdge.Twin.Next != null)
{
Debug.Assert(originEdge.Origin == origin);
originEdge = originEdge.Twin.Next;
}
var previous = originEdge.Twin;
previous.Next = edge;
edge.Previous = previous;
}
}
// Check if we have one connected mesh.
if (vertices.Count > 0)
{
const int Tag = 1;
TagLinkedComponents(vertices[0], Tag);
// Check if all components were reached.
if (vertices.Any(v => v.Tag != Tag) ||
edges.Any(e => e.Tag != Tag) ||
faces.Any(f => f.Tag != Tag))
{
throw new NotSupportedException("The triangle mesh consists of several unconnected components or sub-meshes.");
}
}
var dcelMesh = new DcelMesh {
Vertex = vertices.FirstOrDefault()
};
dcelMesh.ResetTags();
return(dcelMesh);
}
/// <summary>
/// Cuts mesh with a plane.
/// </summary>
/// <param name="plane">The plane.</param>
/// <returns>
/// <see langword="true"/> if the mesh was cut; otherwise, <see langword="false"/> if the mesh
/// was not modified.
/// </returns>
/// <remarks>
/// <para>
/// The mesh is cut with the given plane. If any parts are in front of the plane, they are
/// removed. Edges and faces that go through the plane are cut. The resulting mesh is closed
/// with a new face in the cut plane.
/// </para>
/// <para>
/// If the whole mesh is in front of the plane, the whole mesh is removed (<see cref="Vertex"/>
/// is set to <see langword="null"/>). If the whole mesh is behind the plane, this method does
/// nothing.
/// </para>
/// <para>
/// <strong>Prerequisites:</strong> This operation uses <see cref="DcelVertex.UserData"/> of the
/// vertices and it assumes that the mesh is valid, convex and closed. All faces must be
/// triangles or convex polygons.
/// </para>
/// </remarks>
public bool CutConvex(Plane plane)
{
// Cuts the mesh with the given plane. The part over the plane is removed.
// Prerequisites:
// - Mesh is valid, convex and closed.
// - Faces are convex polygons.
// - Vertex user data is null.
// Notes:
// - Vertex user data is used.
// Get AABB of whole mesh.
var aabb = GetAabb();
// Create an epsilon relative to the mesh size.
float epsilon = Numeric.EpsilonF * (1 + aabb.Extent.Length);
// Store distance d to plane in all vertices. d is negative if vertex is below the plane.
float minDistance = Single.PositiveInfinity;
float maxDistance = Single.NegativeInfinity;
foreach (var vertex in Vertices)
{
float d = Vector3.Dot(vertex.Position, plane.Normal) - plane.DistanceFromOrigin;
vertex.UserData = d;
minDistance = Math.Min(d, minDistance);
maxDistance = Math.Max(d, maxDistance);
}
if (minDistance > -epsilon)
{
// All vertices are in or above the plane. - The whole mesh is cut away.
Vertex = null;
Dirty = true;
return(true);
}
if (maxDistance < epsilon)
{
// All vertices are in or under the plane. - The mesh is not cut.
return(false);
}
// Now, we know that the mesh must be cut.
// Find a first edge that starts under/in the plane and must be cut.
DcelEdge first = null;
foreach (var edge in Edges)
{
var startDistance = (float)edge.Origin.UserData;
var endDistance = (float)edge.Twin.Origin.UserData;
if (startDistance < -epsilon && // The edge starts below the plane and the start vertex is definitely not on the plane.
endDistance > -epsilon) // The edge ends in or above the plane.
{
first = edge;
break;
}
}
Debug.Assert(first != null, "The mesh is cut by the plane, but could not find an edge that is cut!?");
// The cut will be sealed with this face.
DcelFace cap = new DcelFace();
var outEdge = first; // Edge that goes out of the plane and has to be cut.
DcelVertex newVertex = new DcelVertex();
newVertex.Position = GetCutPosition(outEdge);
newVertex.Edge = first.Twin;
do
{
// Find inEdge (edge that goes into the plane and must be cut).
var inEdge = outEdge.Next;
while ((float)inEdge.Twin.Origin.UserData > -epsilon) // Loop until the edge end is definitely under the plane.
{
inEdge = inEdge.Next;
}
// The face will be cut between outEdge and inEdge.
// Two new half edges:
var newEdge = new DcelEdge(); // Edge for the cut face.
var capEdge = new DcelEdge(); // Twin edge on the cap.
// Update outEdge.
outEdge.Next = newEdge;
// Init newEdge.
newEdge.Face = outEdge.Face;
newEdge.Origin = newVertex;
newEdge.Previous = outEdge;
newEdge.Next = inEdge;
newEdge.Twin = capEdge;
// Find next newVertex on inEdge.
if (inEdge.Twin != first)
{
// Find cut on inEdge.
newVertex = new DcelVertex();
newVertex.Position = GetCutPosition(inEdge);
newVertex.Edge = inEdge;
}
else
{
// We have come full circle. The inEdge is the twin of the first outEdge.
newVertex = first.Next.Origin;
}
// Init capEdge.
capEdge.Face = cap;
capEdge.Origin = newVertex;
capEdge.Twin = newEdge;
if (cap.Boundary == null)
{
cap.Boundary = capEdge;
}
else
{
capEdge.Next = outEdge.Twin.Previous.Twin;
capEdge.Next.Previous = capEdge;
}
// Update inEdge.
inEdge.Origin = newVertex;
inEdge.Previous = newEdge;
// Make sure the cut face does not link to a removed edge.
outEdge.Face.Boundary = outEdge;
// The next outEdge is the twin of the inEdge.
outEdge = inEdge.Twin;
} while (outEdge != first);
// We still have to link the first and the last cap edge.
var firstCapEdge = cap.Boundary;
var lastCapEdge = first.Twin.Previous.Twin;
firstCapEdge.Next = lastCapEdge;
lastCapEdge.Previous = firstCapEdge;
// Make sure DcelMesh.Vertex is not one of the removed vertices.
Vertex = newVertex;
Dirty = true;
// Clear vertex user data.
foreach (var vertex in Vertices)
{
vertex.UserData = null;
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="DcelFace"/> class from a given edge.
/// </summary>
/// <param name="boundary">An edge of the outer boundary.</param>
public DcelFace(DcelEdge boundary)
{
Boundary = boundary;
}
/// <summary>
/// Creates a mesh for unit cube.
/// </summary>
/// <returns>The DCEL mesh that represent a unit cube.</returns>
/// <remarks>
/// The cube is centered at the origin and has 6 faces. The edge length is 2.
/// </remarks>
public static DcelMesh CreateCube()
{
var vertex0 = new DcelVertex(new Vector3(-1, -1, -1), null);
var vertex1 = new DcelVertex(new Vector3(1, -1, -1), null);
var vertex2 = new DcelVertex(new Vector3(-1, 1, -1), null);
var vertex3 = new DcelVertex(new Vector3(1, 1, -1), null);
var vertex4 = new DcelVertex(new Vector3(-1, -1, 1), null);
var vertex5 = new DcelVertex(new Vector3(1, -1, 1), null);
var vertex6 = new DcelVertex(new Vector3(-1, 1, 1), null);
var vertex7 = new DcelVertex(new Vector3(1, 1, 1), null);
var near = new DcelFace(); // +z face
var far = new DcelFace(); // -z face
var top = new DcelFace(); // +y face
var bottom = new DcelFace(); // -y face
var left = new DcelFace(); // -x face
var right = new DcelFace(); // +x face
var edge01 = new DcelEdge {
Origin = vertex0, Face = bottom
};
var edge10 = new DcelEdge {
Origin = vertex1, Face = far
};
var edge13 = new DcelEdge {
Origin = vertex1, Face = right
};
var edge31 = new DcelEdge {
Origin = vertex3, Face = far
};
var edge23 = new DcelEdge {
Origin = vertex2, Face = far
};
var edge32 = new DcelEdge {
Origin = vertex3, Face = top
};
var edge02 = new DcelEdge {
Origin = vertex0, Face = far
};
var edge20 = new DcelEdge {
Origin = vertex2, Face = left
};
var edge26 = new DcelEdge {
Origin = vertex2, Face = top
};
var edge62 = new DcelEdge {
Origin = vertex6, Face = left
};
var edge37 = new DcelEdge {
Origin = vertex3, Face = right
};
var edge73 = new DcelEdge {
Origin = vertex7, Face = top
};
var edge04 = new DcelEdge {
Origin = vertex0, Face = left
};
var edge40 = new DcelEdge {
Origin = vertex4, Face = bottom
};
var edge15 = new DcelEdge {
Origin = vertex1, Face = bottom
};
var edge51 = new DcelEdge {
Origin = vertex5, Face = right
};
var edge45 = new DcelEdge {
Origin = vertex4, Face = near
};
var edge54 = new DcelEdge {
Origin = vertex5, Face = bottom
};
var edge57 = new DcelEdge {
Origin = vertex5, Face = near
};
var edge75 = new DcelEdge {
Origin = vertex7, Face = right
};
var edge46 = new DcelEdge {
Origin = vertex4, Face = left
};
var edge64 = new DcelEdge {
Origin = vertex6, Face = near
};
var edge67 = new DcelEdge {
Origin = vertex6, Face = top
};
var edge76 = new DcelEdge {
Origin = vertex7, Face = near
};
vertex0.Edge = edge01;
vertex1.Edge = edge10;
vertex2.Edge = edge20;
vertex3.Edge = edge31;
vertex4.Edge = edge40;
vertex5.Edge = edge57;
vertex6.Edge = edge67;
vertex7.Edge = edge76;
near.Boundary = edge57;
far.Boundary = edge10;
left.Boundary = edge62;
right.Boundary = edge51;
top.Boundary = edge67;
bottom.Boundary = edge01;
edge01.Twin = edge10; edge10.Twin = edge01;
edge13.Twin = edge31; edge31.Twin = edge13;
edge23.Twin = edge32; edge32.Twin = edge23;
edge02.Twin = edge20; edge20.Twin = edge02;
edge26.Twin = edge62; edge62.Twin = edge26;
edge37.Twin = edge73; edge73.Twin = edge37;
edge04.Twin = edge40; edge40.Twin = edge04;
edge15.Twin = edge51; edge51.Twin = edge15;
edge45.Twin = edge54; edge54.Twin = edge45;
edge57.Twin = edge75; edge75.Twin = edge57;
edge46.Twin = edge64; edge64.Twin = edge46;
edge67.Twin = edge76; edge76.Twin = edge67;
edge10.Next = edge02; edge02.Next = edge23; edge23.Next = edge31; edge31.Next = edge10; // far
edge02.Previous = edge10; edge23.Previous = edge02; edge31.Previous = edge23; edge10.Previous = edge31;
edge45.Next = edge57; edge57.Next = edge76; edge76.Next = edge64; edge64.Next = edge45; // near
edge57.Previous = edge45; edge76.Previous = edge57; edge64.Previous = edge76; edge45.Previous = edge64;
edge62.Next = edge20; edge20.Next = edge04; edge04.Next = edge46; edge46.Next = edge62; // left
edge20.Previous = edge62; edge04.Previous = edge20; edge46.Previous = edge04; edge62.Previous = edge46;
edge51.Next = edge13; edge13.Next = edge37; edge37.Next = edge75; edge75.Next = edge51; // right
edge13.Previous = edge51; edge37.Previous = edge13; edge75.Previous = edge37; edge51.Previous = edge75;
edge67.Next = edge73; edge73.Next = edge32; edge32.Next = edge26; edge26.Next = edge67; // top
edge73.Previous = edge67; edge32.Previous = edge73; edge26.Previous = edge32; edge67.Previous = edge26;
edge01.Next = edge15; edge15.Next = edge54; edge54.Next = edge40; edge40.Next = edge01; // bottom
edge15.Previous = edge01; edge54.Previous = edge15; edge40.Previous = edge54; edge01.Previous = edge40;
return(new DcelMesh {
Vertex = vertex0
});
}
internal void MergeCoplanarFaces()
{
UpdateCache();
foreach (DcelEdge edge in _edges)
{
if (edge.InternalTag == 1)
{
// Edge has already been visited.
continue;
}
DcelEdge twin = edge.Twin;
DcelFace face0 = edge.Face;
DcelFace face1 = twin.Face;
if (face0 != null && face1 != null)
{
// Compare face normals.
Vector3 normal0 = face0.Normal;
Vector3 normal1 = face1.Normal;
float cosα = Vector3.Dot(normal0, normal1) / (normal0.Length * normal1.Length);
if (Numeric.AreEqual(cosα, 1))
{
// Faces are coplanar:
// --> Merge faces and remove edge.
// Get vertices and edges.
DcelVertex vertex0 = edge.Origin; // Start vertex of edge.
DcelVertex vertex1 = twin.Origin; // End vertex of edge.
DcelEdge vertex0Incoming = edge.Previous;
DcelEdge vertex0Outgoing = twin.Next;
DcelEdge vertex1Incoming = twin.Previous;
DcelEdge vertex1Outgoing = edge.Next;
// Update vertices.
vertex0.Edge = vertex0Outgoing;
vertex1.Edge = vertex1Outgoing;
// Update edges.
vertex0Incoming.Next = vertex0Outgoing;
vertex0Outgoing.Previous = vertex0Incoming;
vertex1Incoming.Next = vertex1Outgoing;
vertex1Outgoing.Previous = vertex1Incoming;
// Throw away face1. Make sure that all edges point to face0.
DcelEdge current = vertex0Outgoing;
do
{
current.Face = face0;
current = current.Next;
} while (current != vertex0Outgoing);
Dirty = true;
}
// Mark edges as visited.
edge.InternalTag = 1;
twin.InternalTag = 1;
}
}
ResetTags();
}
