public static bool TriangulateVertices(Vector3[] vertices, out List <int> triangles, bool unordered = true, bool convex = false)
{
triangles = null;
int vertexCount = vertices == null ? 0 : vertices.Length;
if (vertexCount < 3)
{
return(false);
}
if (vertexCount == 3)
{
triangles = new List <int>()
{
0, 1, 2
};
return(true);
}
Vector3 normal = Projection.FindBestPlane(vertices).normal;
Vector2[] points2d = Projection.PlanarProject(vertices);
if (unordered)
{
return(Triangulation.SortAndTriangulate(points2d, out triangles, convex));
}
else
{
return(Triangulate(points2d, out triangles, convex));
}
}
/// <summary>
/// Insert a number of new points to each edge. Points are evenly spaced out along the edge.
/// </summary>
/// <param name="mesh">The source mesh.</param>
/// <param name="edges">The edges to split with points.</param>
/// <param name="count">The number of new points to insert. Must be greater than 0.</param>
/// <returns>The new edges created by inserting points.</returns>
public static List <Edge> AppendVerticesToEdge(this ProBuilderMesh mesh, IList <Edge> edges, int count)
{
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
if (edges == null)
{
throw new ArgumentNullException("edges");
}
if (count < 1 || count > 512)
{
Log.Error("New edge vertex count is less than 1 or greater than 512.");
return(null);
}
List <Vertex> vertices = new List <Vertex>(mesh.GetVertices());
Dictionary <int, int> lookup = mesh.sharedVertexLookup;
Dictionary <int, int> lookupUV = mesh.sharedTextureLookup;
List <int> indexesToDelete = new List <int>();
IEnumerable <Edge> commonEdges = EdgeUtility.GetSharedVertexHandleEdges(mesh, edges);
List <Edge> distinctEdges = commonEdges.Distinct().ToList();
Dictionary <Face, FaceRebuildData> modifiedFaces = new Dictionary <Face, FaceRebuildData>();
int originalSharedIndexesCount = lookup.Count();
int sharedIndexesCount = originalSharedIndexesCount;
foreach (Edge edge in distinctEdges)
{
Edge localEdge = EdgeUtility.GetEdgeWithSharedVertexHandles(mesh, edge);
// Generate the new vertices that will be inserted on this edge
List <Vertex> verticesToAppend = new List <Vertex>(count);
for (int i = 0; i < count; i++)
{
verticesToAppend.Add(Vertex.Mix(vertices[localEdge.a], vertices[localEdge.b], (i + 1) / ((float)count + 1)));
}
List <SimpleTuple <Face, Edge> > adjacentFaces = ElementSelection.GetNeighborFaces(mesh, localEdge);
// foreach face attached to common edge, append vertices
foreach (SimpleTuple <Face, Edge> tup in adjacentFaces)
{
Face face = tup.item1;
FaceRebuildData data;
if (!modifiedFaces.TryGetValue(face, out data))
{
data = new FaceRebuildData();
data.face = new Face(new int[0], face.submeshIndex, new AutoUnwrapSettings(face.uv), face.smoothingGroup, face.textureGroup, -1, face.manualUV);
data.vertices = new List <Vertex>(ArrayUtility.ValuesWithIndexes(vertices, face.distinctIndexesInternal));
data.sharedIndexes = new List <int>();
data.sharedIndexesUV = new List <int>();
foreach (int i in face.distinctIndexesInternal)
{
int shared;
if (lookup.TryGetValue(i, out shared))
{
data.sharedIndexes.Add(shared);
}
if (lookupUV.TryGetValue(i, out shared))
{
data.sharedIndexesUV.Add(shared);
}
}
indexesToDelete.AddRange(face.distinctIndexesInternal);
modifiedFaces.Add(face, data);
}
data.vertices.AddRange(verticesToAppend);
for (int i = 0; i < count; i++)
{
data.sharedIndexes.Add(sharedIndexesCount + i);
data.sharedIndexesUV.Add(-1);
}
}
sharedIndexesCount += count;
}
// now apply the changes
List <Face> dic_face = modifiedFaces.Keys.ToList();
List <FaceRebuildData> dic_data = modifiedFaces.Values.ToList();
List <EdgeLookup> appendedEdges = new List <EdgeLookup>();
for (int i = 0; i < dic_face.Count; i++)
{
Face face = dic_face[i];
FaceRebuildData data = dic_data[i];
Vector3 nrm = Math.Normal(mesh, face);
Vector2[] projection = Projection.PlanarProject(data.vertices.Select(x => x.position).ToArray(), null, nrm);
int vertexCount = vertices.Count;
// triangulate and set new face indexes to end of current vertex list
List <int> indexes;
if (Triangulation.SortAndTriangulate(projection, out indexes))
{
data.face.indexesInternal = indexes.ToArray();
}
else
{
continue;
}
data.face.ShiftIndexes(vertexCount);
face.CopyFrom(data.face);
for (int n = 0; n < data.vertices.Count; n++)
{
lookup.Add(vertexCount + n, data.sharedIndexes[n]);
}
if (data.sharedIndexesUV.Count == data.vertices.Count)
{
for (int n = 0; n < data.vertices.Count; n++)
{
lookupUV.Add(vertexCount + n, data.sharedIndexesUV[n]);
}
}
vertices.AddRange(data.vertices);
foreach (Edge e in face.edgesInternal)
{
EdgeLookup el = new EdgeLookup(new Edge(lookup[e.a], lookup[e.b]), e);
if (el.common.a >= originalSharedIndexesCount || el.common.b >= originalSharedIndexesCount)
{
appendedEdges.Add(el);
}
}
}
indexesToDelete = indexesToDelete.Distinct().ToList();
int delCount = indexesToDelete.Count;
var newEdges = appendedEdges.Distinct().Select(x => x.local - delCount).ToList();
mesh.SetVertices(vertices);
mesh.SetSharedVertices(lookup);
mesh.SetSharedTextures(lookupUV);
mesh.DeleteVertices(indexesToDelete);
return(newEdges);
}
