// Reacreate a unity mesh with vertices, triangles, and normals.
// TODO: IT NOW ASSUMES A FACE IS A TRIANGLE
// TODO: FAN TRIANGULATION? Can we assume that all generated faces will be simple convex??
public Mesh GetMesh()
{
Mesh meshRes = new Mesh();
List <int> meshTriangles = new List <int>();
List <Vector3> meshVertices = new List <Vector3>();
List <Vector3> meshNormals = new List <Vector3>();
// Foreach face. Walk it and save the vertex and normal data toghether with triangle indices.
int triIdx = 0;
foreach (HEFace face in faces)
{
// Each face has a normal and an index into halfEdges
// Get the face halfedges
List <short> faceHalfEdges = HalfEdge.FaceHalfEdges(face, halfEdges);
if (faceHalfEdges.Count != 3)
{
Debug.Assert(faceHalfEdges.Count == 3);
}
foreach (short i in faceHalfEdges)
{
meshVertices.Add(vertices[halfEdges[i].verIndex].v);
meshNormals.Add(face.normal);
meshTriangles.Add(triIdx);
triIdx++;
}
}
meshRes.vertices = meshVertices.ToArray();
meshRes.triangles = meshTriangles.ToArray();
meshRes.normals = meshNormals.ToArray();
return(meshRes);
}
public void Triangulate()
{
// Update each face to contain three vertices. Adds new faces when necessary.
int origFaceCount = faces.Count;
for (int i = 0; i < origFaceCount; i++)
{
List <short> faceEdges = HalfEdge.FaceHalfEdges(faces[i], halfEdges);
if (faceEdges.Count == 3)
{
// Already a triangle
continue;
}
// There are two cases, 4 or 5 vertices, for 4 vertices we can just do it over the diagonal
if (faceEdges.Count == 4)
{
List <short> onPlaneIdx = GetConfigEdges(faces[i], PlaneConfig.On);
SplitFace(faces[i], halfEdges[onPlaneIdx[0]], halfEdges[halfEdges[halfEdges[onPlaneIdx[0]].nextIndex].nextIndex]);
}
else if (faceEdges.Count == 5)
{
// Algorithm;
// Get the two vertices on the plane
List <short> onPlaneIdx = GetConfigEdges(faces[i], PlaneConfig.On);
List <short> leftPlaneIdx = GetConfigEdges(faces[i], PlaneConfig.Left);
List <short> rightPlaneIdx = GetConfigEdges(faces[i], PlaneConfig.Right);
// Either there are two on the left side or on the right side. (Always 2 On)
// This will be the left place idx face. We need to create two new half-edges between the on edges
// Lets say we have l1-l2-o1-r1-o2 then the right triangle is o1-r1-o2
// Should make a function that takes a face and two vertices (half edges rather) and splits it in two
List <short> onEdgesIndices = GetConfigEdges(faces[i], PlaneConfig.On);
SplitFace(faces[i], halfEdges[onEdgesIndices[0]], halfEdges[onEdgesIndices[1]]);
// TODO: Make a verify function that verifies the half-edge data structure...
// Check that the new faces are atleast the right size..
List <short> f1 = HalfEdge.FaceHalfEdges(faces[i], halfEdges);
List <short> f2 = HalfEdge.FaceHalfEdges(faces[faces.Count - 1], halfEdges);
// One of the new faces have 4 vertices, so we need to triangulate it / split into two
if (f1.Count == 4)
{
SplitFace(faces[i], halfEdges[faces[i].heIndex], halfEdges[halfEdges[halfEdges[faces[i].heIndex].nextIndex].nextIndex]);
}
else
{
int idx = faces.Count - 1;
SplitFace(faces[idx], halfEdges[faces[idx].heIndex], halfEdges[halfEdges[halfEdges[faces[idx].heIndex].nextIndex].nextIndex]);
}
}
else
{
// Don't go here...
// shouldn't be possible
}
}
}
// Return indices of HalfEdges with vertices that have the given config
List <short> GetConfigEdges(HEFace face, PlaneConfig config)
{
List <short> he = HalfEdge.FaceHalfEdges(face, halfEdges);
List <short> res = new List <short>();
foreach (short s in he)
{
if (vertices[halfEdges[s].verIndex].config == config)
{
res.Add(s);
}
}
return(res);
}
private string PrintFaceConfig(HEFace face)
{
List <short> he = HalfEdge.FaceHalfEdges(face, halfEdges);
string res = "";
string res1 = "face idx: ";
foreach (short s in he)
{
res += " " + vertices[halfEdges[s].verIndex].config.ToString() + "(" + s + "," + halfEdges[s].nextIndex + ")" + " ";
res1 += s + ": " + halfEdges[s].faceIndex + ". ";
}
res1 += ". with face pointing at = " + faces[halfEdges[he[0]].faceIndex].heIndex;
return(res + "\n" + res1);
}
private List <short> GetOnVertices(HEFace face)
{
List <short> res = new List <short>();
List <short> he = HalfEdge.FaceHalfEdges(face, halfEdges);
foreach (short s in he)
{
if (vertices[halfEdges[s].verIndex].config == PlaneConfig.On)
{
res.Add(halfEdges[s].verIndex);
}
}
return(res);
}
private PlaneConfig GetFaceConfig(HEFace face)
{
// If any vertex is left / right the whole face is it
List <short> heIdx = HalfEdge.FaceHalfEdges(face, halfEdges);
foreach (short s in heIdx)
{
if (vertices[halfEdges[s].verIndex].config == PlaneConfig.Left)
{
return(PlaneConfig.Left);
}
else if (vertices[halfEdges[s].verIndex].config == PlaneConfig.Right)
{
return(PlaneConfig.Right);
}
}
return(PlaneConfig.On);
}