/// <summary>
/// Create a new face given a set of unordered vertices (or ordered, if unordered param is set to false).
/// </summary>
/// <param name="vertices"></param>
/// <param name="unordered"></param>
/// <returns></returns>
internal static FaceRebuildData FaceWithVertices(List <Vertex> vertices, bool unordered = true)
{
List <int> triangles;
if (Triangulation.TriangulateVertices(vertices, out triangles, unordered))
{
FaceRebuildData data = new FaceRebuildData();
data.vertices = vertices;
data.face = new Face(triangles);
return(data);
}
return(null);
}
/// <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);
Edge edgeLookUp = new Edge(lookup[localEdge.a], lookup[localEdge.b]);
Edge e = new Edge();
// 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);
//Ordering vertices in the new face
List <Vertex> orderedVertices = new List <Vertex>();
List <int> orderedSharedIndexes = new List <int>();
List <int> orderedSharedUVIndexes = new List <int>();
List <Edge> peripheralEdges = WingedEdge.SortEdgesByAdjacency(face);
for (int i = 0; i < peripheralEdges.Count; i++)
{
e.a = peripheralEdges[i].a;
e.b = peripheralEdges[i].b;
orderedVertices.Add(vertices[e.a]);
int shared;
if (lookup.TryGetValue(e.a, out shared))
{
orderedSharedIndexes.Add(shared);
}
if (lookupUV.TryGetValue(i, out shared))
{
data.sharedIndexesUV.Add(shared);
}
if (edgeLookUp.a == lookup[e.a] && edgeLookUp.b == lookup[e.b])
{
for (int j = 0; j < count; j++)
{
orderedVertices.Add(verticesToAppend[j]);
orderedSharedIndexes.Add(sharedIndexesCount + j);
orderedSharedUVIndexes.Add(-1);
}
}
else if (edgeLookUp.a == lookup[e.b] && edgeLookUp.b == lookup[e.a])
{
for (int j = count - 1; j >= 0; j--)
{
orderedVertices.Add(verticesToAppend[j]);
orderedSharedIndexes.Add(sharedIndexesCount + j);
orderedSharedUVIndexes.Add(-1);
}
}
}
data.vertices = orderedVertices;
data.sharedIndexes = orderedSharedIndexes;
data.sharedIndexesUV = orderedSharedUVIndexes;
}
else
{
//Get ordered vertices in the existing face and add new ones
List <Vertex> orderedVertices = data.vertices;
List <int> orderedSharedIndexes = data.sharedIndexes;
List <int> orderedSharedUVIndexes = data.sharedIndexesUV;
for (int i = 0; i < orderedVertices.Count; i++)
{
Vertex edgeStart = orderedVertices[i];
int edgeStartIndex = vertices.IndexOf(edgeStart);
Vertex edgeEnd = orderedVertices[(i + 1) % orderedVertices.Count];
int edgeEndIndex = vertices.IndexOf(edgeEnd);
if (edgeStartIndex == -1 || edgeEndIndex == -1)
{
continue;
}
if (lookup[edgeStartIndex] == lookup[localEdge.a] &&
lookup[edgeEndIndex] == lookup[localEdge.b])
{
orderedVertices.InsertRange(i + 1, verticesToAppend);
for (int j = 0; j < count; j++)
{
orderedSharedIndexes.Insert(i + j + 1, sharedIndexesCount + j);
orderedSharedUVIndexes.Add(-1);
}
}
else if (lookup[edgeStartIndex] == lookup[localEdge.b] &&
lookup[edgeEndIndex] == lookup[localEdge.a])
{
verticesToAppend.Reverse();
orderedVertices.InsertRange(i + 1, verticesToAppend);
for (int j = count - 1; j >= 0; j--)
{
orderedSharedIndexes.Insert(i + 1, sharedIndexesCount + j);
orderedSharedUVIndexes.Add(-1);
}
}
}
data.vertices = orderedVertices;
data.sharedIndexes = orderedSharedIndexes;
data.sharedIndexesUV = orderedSharedUVIndexes;
}
}
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];
int vertexCount = vertices.Count;
// triangulate and set new face indexes to end of current vertex list
List <int> triangles;
if (Triangulation.TriangulateVertices(data.vertices, out triangles, false))
{
data.face = new Face(triangles);
}
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);
}
/// <summary>
/// Add a set of points to a face and retriangulate. Points are added to the nearest edge.
/// </summary>
/// <param name="mesh">The source mesh.</param>
/// <param name="face">The face to append points to.</param>
/// <param name="points">Points to added to the face.</param>
/// <returns>The face created by appending the points.</returns>
public static Face AppendVerticesToFace(this ProBuilderMesh mesh, Face face, Vector3[] points)
{
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
if (face == null)
{
throw new ArgumentNullException("face");
}
if (points == null)
{
throw new ArgumentNullException("points");
}
List <Vertex> vertices = mesh.GetVertices().ToList();
List <Face> faces = new List <Face>(mesh.facesInternal);
Dictionary <int, int> lookup = mesh.sharedVertexLookup;
Dictionary <int, int> lookupUV = null;
if (mesh.sharedTextures != null)
{
lookupUV = new Dictionary <int, int>();
SharedVertex.GetSharedVertexLookup(mesh.sharedTextures, lookupUV);
}
List <Edge> wound = WingedEdge.SortEdgesByAdjacency(face);
List <Vertex> n_vertices = new List <Vertex>();
List <int> n_shared = new List <int>();
List <int> n_sharedUV = lookupUV != null ? new List <int>() : null;
for (int i = 0; i < wound.Count; i++)
{
n_vertices.Add(vertices[wound[i].a]);
n_shared.Add(lookup[wound[i].a]);
if (lookupUV != null)
{
int uv;
if (lookupUV.TryGetValue(wound[i].a, out uv))
{
n_sharedUV.Add(uv);
}
else
{
n_sharedUV.Add(-1);
}
}
}
// now insert the new points on the nearest edge
for (int i = 0; i < points.Length; i++)
{
int index = -1;
float best = Mathf.Infinity;
Vector3 p = points[i];
int vc = n_vertices.Count;
for (int n = 0; n < vc; n++)
{
Vector3 v = n_vertices[n].position;
Vector3 w = n_vertices[(n + 1) % vc].position;
float dist = Math.DistancePointLineSegment(p, v, w);
if (dist < best)
{
best = dist;
index = n;
}
}
Vertex left = n_vertices[index], right = n_vertices[(index + 1) % vc];
float x = (p - left.position).sqrMagnitude;
float y = (p - right.position).sqrMagnitude;
Vertex insert = Vertex.Mix(left, right, x / (x + y));
n_vertices.Insert((index + 1) % vc, insert);
n_shared.Insert((index + 1) % vc, -1);
if (n_sharedUV != null)
{
n_sharedUV.Insert((index + 1) % vc, -1);
}
}
List <int> triangles;
try
{
Triangulation.TriangulateVertices(n_vertices, out triangles, false);
}
catch
{
Debug.Log("Failed triangulating face after appending vertices.");
return(null);
}
FaceRebuildData data = new FaceRebuildData();
data.face = new Face(triangles.ToArray(), face.submeshIndex, new AutoUnwrapSettings(face.uv),
face.smoothingGroup, face.textureGroup, -1, face.manualUV);
data.vertices = n_vertices;
data.sharedIndexes = n_shared;
data.sharedIndexesUV = n_sharedUV;
FaceRebuildData.Apply(new List <FaceRebuildData>()
{
data
},
vertices,
faces,
lookup,
lookupUV);
var newFace = data.face;
mesh.SetVertices(vertices);
mesh.faces = faces;
mesh.SetSharedVertices(lookup);
mesh.SetSharedTextures(lookupUV);
// check old normal and make sure this new face is pointing the same direction
Vector3 oldNrm = Math.Normal(mesh, face);
Vector3 newNrm = Math.Normal(mesh, newFace);
if (Vector3.Dot(oldNrm, newNrm) < 0)
{
newFace.Reverse();
}
mesh.DeleteFace(face);
return(newFace);
}
/// <summary>
/// Rebuild a mesh from an ordered set of points.
/// </summary>
/// <param name="mesh">The target mesh. The mesh values will be cleared and repopulated with the shape extruded from points.</param>
/// <param name="points">A path of points to triangulate and extrude.</param>
/// <param name="extrude">The distance to extrude.</param>
/// <param name="flipNormals">If true the faces will be inverted at creation.</param>
/// <param name="holePoints">Holes in the polygon. If null this will be ignored.</param>
/// <returns>An ActionResult with the status of the operation.</returns>
public static ActionResult CreateShapeFromPolygon(this ProBuilderMesh mesh, IList <Vector3> points,
float extrude, bool flipNormals, IList <IList <Vector3> > holePoints)
{
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
if (points == null || points.Count < 3)
{
ClearAndRefreshMesh(mesh);
return(new ActionResult(ActionResult.Status.NoChange, "Too Few Points"));
}
Vector3[] vertices = points.ToArray();
Vector3[][] holeVertices = null;
if (holePoints != null && holePoints.Count > 0)
{
holeVertices = new Vector3[holePoints.Count][];
for (int i = 0; i < holePoints.Count; i++)
{
if (holePoints[i] == null || holePoints[i].Count < 3)
{
ClearAndRefreshMesh(mesh);
return(new ActionResult(ActionResult.Status.NoChange, "Too Few Points in hole " + i));
}
holeVertices[i] = holePoints[i].ToArray();
}
}
List <int> triangles;
Log.PushLogLevel(LogLevel.Error);
if (Triangulation.TriangulateVertices(vertices, out triangles, holeVertices))
{
Vector3[] combinedVertices = null;
if (holeVertices != null)
{
combinedVertices = new Vector3[vertices.Length + holeVertices.Sum(arr => arr.Length)];
Array.Copy(vertices, combinedVertices, vertices.Length);
int destinationIndex = vertices.Length;
foreach (var hole in holeVertices)
{
Array.ConstrainedCopy(hole, 0, combinedVertices, destinationIndex, hole.Length);
destinationIndex += hole.Length;
}
}
else
{
combinedVertices = vertices;
}
int[] indexes = triangles.ToArray();
if (Math.PolygonArea(combinedVertices, indexes) < Mathf.Epsilon)
{
ClearAndRefreshMesh(mesh);
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Failure, "Polygon Area < Epsilon"));
}
mesh.Clear();
mesh.positionsInternal = combinedVertices;
var newFace = new Face(indexes);
mesh.facesInternal = new[] { newFace };
mesh.sharedVerticesInternal = SharedVertex.GetSharedVerticesWithPositions(combinedVertices);
mesh.InvalidateCaches();
// check that all points are represented in the triangulation
if (newFace.distinctIndexesInternal.Length != combinedVertices.Length)
{
ClearAndRefreshMesh(mesh);
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Failure, "Triangulation missing points"));
}
Vector3 nrm = Math.Normal(mesh, mesh.facesInternal[0]);
nrm = mesh.gameObject.transform.TransformDirection(nrm);
if ((flipNormals
? Vector3.Dot(mesh.gameObject.transform.up, nrm) > 0f
: Vector3.Dot(mesh.gameObject.transform.up, nrm) < 0f))
{
mesh.facesInternal[0].Reverse();
}
if (extrude != 0.0f)
{
mesh.DuplicateAndFlip(mesh.facesInternal);
mesh.Extrude(new Face[] { (flipNormals ? mesh.facesInternal[1] : mesh.facesInternal[0]) },
ExtrudeMethod.IndividualFaces, extrude);
if ((extrude < 0f && !flipNormals) || (extrude > 0f && flipNormals))
{
foreach (var face in mesh.facesInternal)
{
face.Reverse();
}
}
}
mesh.ToMesh();
mesh.Refresh();
}
else
{
// clear mesh instead of showing an invalid one
ClearAndRefreshMesh(mesh);
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Failure, "Failed Triangulating Points"));
}
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Success, "Create Polygon Shape"));
}
/// <summary>
/// Rebuild a mesh from an ordered set of points.
/// </summary>
/// <param name="mesh">The target mesh. The mesh values will be cleared and repopulated with the shape extruded from points.</param>
/// <param name="points">A path of points to triangulate and extrude.</param>
/// <param name="extrude">The distance to extrude.</param>
/// <param name="flipNormals">If true the faces will be inverted at creation.</param>
/// <returns>An ActionResult with the status of the operation.</returns>
public static ActionResult CreateShapeFromPolygon(this ProBuilderMesh mesh, IList <Vector3> points, float extrude, bool flipNormals)
{
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
if (points == null || points.Count < 3)
{
mesh.Clear();
mesh.ToMesh();
mesh.Refresh();
return(new ActionResult(ActionResult.Status.NoChange, "Too Few Points"));
}
Vector3[] vertices = points.ToArray();
List <int> triangles;
Log.PushLogLevel(LogLevel.Error);
if (Triangulation.TriangulateVertices(vertices, out triangles, false))
{
int[] indexes = triangles.ToArray();
if (Math.PolygonArea(vertices, indexes) < Mathf.Epsilon)
{
mesh.Clear();
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Failure, "Polygon Area < Epsilon"));
}
mesh.Clear();
mesh.positionsInternal = vertices;
mesh.facesInternal = new[] { new Face(indexes) };
mesh.sharedVerticesInternal = SharedVertex.GetSharedVerticesWithPositions(vertices);
mesh.InvalidateCaches();
Vector3 nrm = Math.Normal(mesh, mesh.facesInternal[0]);
if (Vector3.Dot(Vector3.up, nrm) > 0f)
{
mesh.facesInternal[0].Reverse();
}
mesh.DuplicateAndFlip(mesh.facesInternal);
mesh.Extrude(new Face[] { mesh.facesInternal[1] }, ExtrudeMethod.IndividualFaces, extrude);
if ((extrude < 0f && !flipNormals) || (extrude > 0f && flipNormals))
{
foreach (var face in mesh.facesInternal)
{
face.Reverse();
}
}
mesh.ToMesh();
mesh.Refresh();
}
else
{
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Failure, "Failed Triangulating Points"));
}
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Success, "Create Polygon Shape"));
}
/// <summary>
/// Split a common index on a face into two vertices and slide each vertex backwards along it's feeding edge by distance.
/// This method does not perform any input validation, so make sure edgeAndCommonIndex is distinct and all winged edges belong
/// to the same face.
///<pre>
/// `appendedVertices` is common index and a list of the new face indexes it was split into.
///
/// _ _ _ _ _ _ _
/// | /
/// | -> |
/// | |
/// </pre>
/// </summary>
/// <param name="vertices"></param>
/// <param name="edgeAndCommonIndex"></param>
/// <param name="distance"></param>
/// <param name="appendedVertices"></param>
/// <returns></returns>
internal static FaceRebuildData ExplodeVertex(
IList <Vertex> vertices,
IList <SimpleTuple <WingedEdge, int> > edgeAndCommonIndex,
float distance,
out Dictionary <int, List <int> > appendedVertices)
{
Face face = edgeAndCommonIndex.FirstOrDefault().item1.face;
List <Edge> perimeter = WingedEdge.SortEdgesByAdjacency(face);
appendedVertices = new Dictionary <int, List <int> >();
Vector3 oldNormal = Math.Normal(vertices, face.indexesInternal);
// store local and common index of split points
Dictionary <int, int> toSplit = new Dictionary <int, int>();
foreach (SimpleTuple <WingedEdge, int> v in edgeAndCommonIndex)
{
if (v.item2 == v.item1.edge.common.a)
{
toSplit.Add(v.item1.edge.local.a, v.item2);
}
else
{
toSplit.Add(v.item1.edge.local.b, v.item2);
}
}
int pc = perimeter.Count;
List <Vertex> n_vertices = new List <Vertex>();
for (int i = 0; i < pc; i++)
{
int index = perimeter[i].b;
// split this index into two
if (toSplit.ContainsKey(index))
{
// a --- b --- c
Vertex a = vertices[perimeter[i].a];
Vertex b = vertices[perimeter[i].b];
Vertex c = vertices[perimeter[(i + 1) % pc].b];
Vertex leading_dir = a - b;
Vertex following_dir = c - b;
leading_dir.Normalize();
following_dir.Normalize();
Vertex leading_insert = vertices[index] + leading_dir * distance;
Vertex following_insert = vertices[index] + following_dir * distance;
appendedVertices.AddOrAppend(toSplit[index], n_vertices.Count);
n_vertices.Add(leading_insert);
appendedVertices.AddOrAppend(toSplit[index], n_vertices.Count);
n_vertices.Add(following_insert);
}
else
{
n_vertices.Add(vertices[index]);
}
}
List <int> triangles;
if (Triangulation.TriangulateVertices(n_vertices, out triangles, false))
{
FaceRebuildData data = new FaceRebuildData();
data.vertices = n_vertices;
data.face = new Face(face);
Vector3 newNormal = Math.Normal(n_vertices, triangles);
if (Vector3.Dot(oldNormal, newNormal) < 0f)
{
triangles.Reverse();
}
data.face.indexesInternal = triangles.ToArray();
return(data);
}
return(null);
}
/// <summary>
/// Rebuild a mesh from an ordered set of points.
/// </summary>
/// <param name="mesh">The target mesh. The mesh values will be cleared and repopulated with the shape extruded from points.</param>
/// <param name="points">A path of points to triangulate and extrude.</param>
/// <param name="extrude">The distance to extrude.</param>
/// <param name="flipNormals">If true the faces will be inverted at creation.</param>
/// <param name="cameraLookAt">If the normal of the polygon of the first face is facing in the same direction of the camera lookat it will be inverted at creation, so it is facing the camera.</param>
/// <returns>An ActionResult with the status of the operation.</returns>
public static ActionResult CreateShapeFromPolygon(this ProBuilderMesh mesh, IList <Vector3> points, float extrude, bool flipNormals, Vector3 cameraLookAt)
{
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
if (points == null || points.Count < 3)
{
ClearAndRefreshMesh(mesh);
return(new ActionResult(ActionResult.Status.NoChange, "Too Few Points"));
}
Vector3[] vertices = points.ToArray();
List <int> triangles;
Log.PushLogLevel(LogLevel.Error);
if (Triangulation.TriangulateVertices(vertices, out triangles, false))
{
int[] indexes = triangles.ToArray();
if (Math.PolygonArea(vertices, indexes) < Mathf.Epsilon)
{
ClearAndRefreshMesh(mesh);
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Failure, "Polygon Area < Epsilon"));
}
mesh.Clear();
mesh.positionsInternal = vertices;
var newFace = new Face(indexes);
mesh.facesInternal = new[] { newFace };
mesh.sharedVerticesInternal = SharedVertex.GetSharedVerticesWithPositions(vertices);
mesh.InvalidateCaches();
// check that all points are represented in the triangulation
if (newFace.distinctIndexesInternal.Length != vertices.Length)
{
ClearAndRefreshMesh(mesh);
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Failure, "Triangulation missing points"));
}
Vector3 nrm = Math.Normal(mesh, mesh.facesInternal[0]);
cameraLookAt.Normalize();
if ((flipNormals ? Vector3.Dot(cameraLookAt, nrm) < 0f : Vector3.Dot(cameraLookAt, nrm) > 0f))
{
mesh.facesInternal[0].Reverse();
}
if (extrude != 0.0f)
{
mesh.DuplicateAndFlip(mesh.facesInternal);
mesh.Extrude(new Face[] { (flipNormals ? mesh.facesInternal[1] : mesh.facesInternal[0]) }, ExtrudeMethod.IndividualFaces, extrude);
if ((extrude < 0f && !flipNormals) || (extrude > 0f && flipNormals))
{
foreach (var face in mesh.facesInternal)
{
face.Reverse();
}
}
}
mesh.ToMesh();
mesh.Refresh();
}
else
{
// clear mesh instead of showing an invalid one
ClearAndRefreshMesh(mesh);
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Failure, "Failed Triangulating Points"));
}
Log.PopLogLevel();
return(new ActionResult(ActionResult.Status.Success, "Create Polygon Shape"));
}
