/// <summary> /// Convert a selection of faces from n-gons to triangles. /// <br /> /// If a face is successfully converted to triangles, each new triangle is created as a separate face and the original face is deleted. /// </summary> /// <param name="mesh">The target mesh.</param> /// <param name="faces">The faces to convert from quads to triangles.</param> /// <returns>Any new triangle faces created by breaking faces into individual triangles.</returns> public static Face[] ToTriangles(this ProBuilderMesh mesh, IList <Face> faces) { if (mesh == null) { throw new System.ArgumentNullException("mesh"); } if (faces == null) { throw new System.ArgumentNullException("faces"); } List <Vertex> vertices = new List <Vertex>(mesh.GetVertices()); Dictionary <int, int> lookup = mesh.sharedVertexLookup; List <FaceRebuildData> rebuild = new List <FaceRebuildData>(); foreach (Face face in faces) { List <FaceRebuildData> res = BreakFaceIntoTris(face, vertices, lookup); rebuild.AddRange(res); } FaceRebuildData.Apply(rebuild, mesh, vertices, null); mesh.DeleteFaces(faces); mesh.ToMesh(); return(rebuild.Select(x => x.face).ToArray()); }
/// <summary> /// Split any shared vertices so that this face may be moved independently of the main object. /// </summary> /// <param name="mesh">The source mesh.</param> /// <param name="faces">The faces to split from the mesh.</param> /// <param name="deleteSourceFaces">Whether or not to delete the faces on the source geometry which were detached.</param> /// <returns>The faces created forming the detached face group.</returns> public static List <Face> DetachFaces(this ProBuilderMesh mesh, IEnumerable <Face> faces, bool deleteSourceFaces) { if (mesh == null) { throw new System.ArgumentNullException("mesh"); } if (faces == null) { throw new System.ArgumentNullException("faces"); } List <Vertex> vertices = new List <Vertex>(mesh.GetVertices()); int sharedIndexOffset = mesh.sharedVerticesInternal.Length; var lookup = mesh.sharedVertexLookup; List <FaceRebuildData> detached = new List <FaceRebuildData>(); foreach (Face face in faces) { FaceRebuildData data = new FaceRebuildData(); data.vertices = new List <Vertex>(); data.sharedIndexes = new List <int>(); data.face = new Face(face); Dictionary <int, int> match = new Dictionary <int, int>(); int[] indexes = new int[face.indexesInternal.Length]; for (int i = 0; i < face.indexesInternal.Length; i++) { int local; if (match.TryGetValue(face.indexesInternal[i], out local)) { indexes[i] = local; } else { local = data.vertices.Count; indexes[i] = local; match.Add(face.indexesInternal[i], local); data.vertices.Add(vertices[face.indexesInternal[i]]); data.sharedIndexes.Add(lookup[face.indexesInternal[i]] + sharedIndexOffset); } } data.face.indexesInternal = indexes.ToArray(); detached.Add(data); } FaceRebuildData.Apply(detached, mesh, vertices); if (deleteSourceFaces) { mesh.DeleteFaces(faces); } mesh.ToMesh(); return(detached.Select(x => x.face).ToList()); }
public override void Delete() { MeshSelection selection = GetSelection(); selection = selection.ToFaces(false, true); foreach (KeyValuePair <GameObject, IList <int> > kvp in selection.SelectedFaces) { ProBuilderMesh mesh = kvp.Key.GetComponent <ProBuilderMesh>(); mesh.DeleteFaces(kvp.Value); mesh.ToMesh(); mesh.Refresh(); } }
public static void _Do(ProBuilderMesh proBuilderMesh) { while (true) { bool removedAFace = false; for (int i = 0; i < proBuilderMesh.faceCount; i++) { Face face = proBuilderMesh.faces[i]; for (int i2 = i + 1; i2 < proBuilderMesh.faceCount; i2++) { Face face2 = proBuilderMesh.faces[i2]; bool isSharedFace = true; for (int i3 = 0; i3 < face.indexes.Count; i3++) { int index = face.indexes[i3]; bool isSharedIndex = false; for (int i4 = 0; i4 < face2.indexes.Count; i4++) { int index2 = face2.indexes[i4]; if (proBuilderMesh.positions[index] == proBuilderMesh.positions[index2]) { isSharedIndex = true; break; } } if (!isSharedIndex) { isSharedFace = false; break; } } if (isSharedFace) { proBuilderMesh.DeleteFaces(new int[2] { i, i2 }); removedAFace = true; } } } if (!removedAFace) { break; } } proBuilderMesh.ToMesh(); proBuilderMesh.Refresh(); }
/// <summary> /// Apply a bevel to a set of edges. /// </summary> /// <param name="mesh">Target mesh.</param> /// <param name="edges">A set of edges to apply bevelling to.</param> /// <param name="amount">A value from 0 (bevel not at all) to 1 (bevel entire face).</param> /// <returns>The new faces created to form the bevel.</returns> public static List <Face> BevelEdges(ProBuilderMesh mesh, IList <Edge> edges, float amount) { if (mesh == null) { throw new ArgumentNullException("mesh"); } Dictionary <int, int> lookup = mesh.sharedVertexLookup; List <Vertex> vertices = new List <Vertex>(mesh.GetVertices()); List <EdgeLookup> m_edges = EdgeLookup.GetEdgeLookup(edges, lookup).Distinct().ToList(); List <WingedEdge> wings = WingedEdge.GetWingedEdges(mesh); List <FaceRebuildData> appendFaces = new List <FaceRebuildData>(); Dictionary <Face, List <int> > ignore = new Dictionary <Face, List <int> >(); HashSet <int> slide = new HashSet <int>(); int beveled = 0; Dictionary <int, List <SimpleTuple <FaceRebuildData, List <int> > > > holes = new Dictionary <int, List <SimpleTuple <FaceRebuildData, List <int> > > >(); // test every edge that will be moved along to make sure the bevel distance is appropriate. if it's not, adjust the max bevel amount // to suit. Dictionary <int, List <WingedEdge> > spokes = WingedEdge.GetSpokes(wings); HashSet <int> tested_common = new HashSet <int>(); foreach (EdgeLookup e in m_edges) { if (tested_common.Add(e.common.a)) { foreach (WingedEdge w in spokes[e.common.a]) { Edge le = w.edge.local; amount = Mathf.Min(Vector3.Distance(vertices[le.a].position, vertices[le.b].position) - .001f, amount); } } if (tested_common.Add(e.common.b)) { foreach (WingedEdge w in spokes[e.common.b]) { Edge le = w.edge.local; amount = Mathf.Min(Vector3.Distance(vertices[le.a].position, vertices[le.b].position) - .001f, amount); } } } if (amount < .001f) { Log.Info("Bevel Distance > Available Surface"); return(null); } // iterate selected edges and move each leading edge back along it's direction // storing information about adjacent faces in the process foreach (EdgeLookup lup in m_edges) { WingedEdge we = wings.FirstOrDefault(x => x.edge.Equals(lup)); if (we == null || we.opposite == null) { continue; } beveled++; ignore.AddOrAppend(we.face, we.edge.common.a); ignore.AddOrAppend(we.face, we.edge.common.b); ignore.AddOrAppend(we.opposite.face, we.edge.common.a); ignore.AddOrAppend(we.opposite.face, we.edge.common.b); // after initial slides go back and split indirect triangles at the intersecting index into two vertices slide.Add(we.edge.common.a); slide.Add(we.edge.common.b); SlideEdge(vertices, we, amount); SlideEdge(vertices, we.opposite, amount); appendFaces.AddRange(GetBridgeFaces(vertices, we, we.opposite, holes)); } if (beveled < 1) { Log.Info("Cannot Bevel Open Edges"); return(null); } // grab the "createdFaces" array now so that the selection returned is just the bridged faces // then add holes later var createdFaces = new List <Face>(appendFaces.Select(x => x.face)); Dictionary <Face, List <SimpleTuple <WingedEdge, int> > > sorted = new Dictionary <Face, List <SimpleTuple <WingedEdge, int> > >(); // sort the adjacent but affected faces into winged edge groups where each group contains a set of // unique winged edges pointing to the same face foreach (int c in slide) { IEnumerable <WingedEdge> matches = wings.Where(x => x.edge.common.Contains(c) && !(ignore.ContainsKey(x.face) && ignore[x.face].Contains(c))); HashSet <Face> used = new HashSet <Face>(); foreach (WingedEdge match in matches) { if (!used.Add(match.face)) { continue; } sorted.AddOrAppend(match.face, new SimpleTuple <WingedEdge, int>(match, c)); } } // now go through those sorted faces and apply the vertex exploding, keeping track of any holes created foreach (KeyValuePair <Face, List <SimpleTuple <WingedEdge, int> > > kvp in sorted) { // common index & list of vertices it was split into Dictionary <int, List <int> > appended; FaceRebuildData f = VertexEditing.ExplodeVertex(vertices, kvp.Value, amount, out appended); if (f == null) { continue; } appendFaces.Add(f); foreach (var apv in appended) { // organize holes by new face so that later we can compare the winding of the new face to the hole face // holes are sorted by key: common index value: face, vertex list holes.AddOrAppend(apv.Key, new SimpleTuple <FaceRebuildData, List <int> >(f, apv.Value)); } } FaceRebuildData.Apply(appendFaces, mesh, vertices); int removed = mesh.DeleteFaces(sorted.Keys).Length; mesh.sharedTextures = new SharedVertex[0]; mesh.sharedVertices = SharedVertex.GetSharedVerticesWithPositions(mesh.positionsInternal); // @todo don't rebuild indexes, keep 'em cached SharedVertex[] sharedIndexes = mesh.sharedVerticesInternal; lookup = mesh.sharedVertexLookup; List <HashSet <int> > holesCommonIndexes = new List <HashSet <int> >(); // offset the indexes of holes and cull any potential holes that are less than 3 indexes (not a hole :) foreach (KeyValuePair <int, List <SimpleTuple <FaceRebuildData, List <int> > > > hole in holes) { // less than 3 indexes in hole path; ain't a hole if (hole.Value.Sum(x => x.item2.Count) < 3) { continue; } HashSet <int> holeCommon = new HashSet <int>(); foreach (SimpleTuple <FaceRebuildData, List <int> > path in hole.Value) { int offset = path.item1.Offset() - removed; for (int i = 0; i < path.item2.Count; i++) { holeCommon.Add(lookup[path.item2[i] + offset]); } } holesCommonIndexes.Add(holeCommon); } List <WingedEdge> modified = WingedEdge.GetWingedEdges(mesh, appendFaces.Select(x => x.face)); // now go through the holes and create faces for them vertices = new List <Vertex>(mesh.GetVertices()); List <FaceRebuildData> holeFaces = new List <FaceRebuildData>(); foreach (HashSet <int> h in holesCommonIndexes) { // even if a set of hole indexes made it past the initial culling, the distinct part // may have reduced the index count if (h.Count < 3) { continue; } // skip sorting the path if it's just a triangle if (h.Count < 4) { List <Vertex> v = new List <Vertex>(mesh.GetVertices(h.Select(x => sharedIndexes[x][0]).ToList())); holeFaces.Add(AppendElements.FaceWithVertices(v)); } // if this hole has > 3 indexes, it needs a tent pole triangulation, which requires sorting into the perimeter order else { List <int> holePath = WingedEdge.SortCommonIndexesByAdjacency(modified, h); List <Vertex> v = new List <Vertex>(mesh.GetVertices(holePath.Select(x => sharedIndexes[x][0]).ToList())); holeFaces.AddRange(AppendElements.TentCapWithVertices(v)); } } FaceRebuildData.Apply(holeFaces, mesh, vertices); mesh.sharedVertices = SharedVertex.GetSharedVerticesWithPositions(mesh.positionsInternal); // go through new faces and conform hole normals // get a hash of just the adjacent and bridge faces // HashSet<pb_Face> adjacent = new HashSet<pb_Face>(appendFaces.Select(x => x.face)); // and also just the filled holes HashSet <Face> newHoles = new HashSet <Face>(holeFaces.Select(x => x.face)); // now append filled holes to the full list of added faces appendFaces.AddRange(holeFaces); List <WingedEdge> allNewFaceEdges = WingedEdge.GetWingedEdges(mesh, appendFaces.Select(x => x.face)); for (int i = 0; i < allNewFaceEdges.Count && newHoles.Count > 0; i++) { WingedEdge wing = allNewFaceEdges[i]; if (newHoles.Contains(wing.face)) { newHoles.Remove(wing.face); // find first edge whose opposite face isn't a filled hole* then // conform normal by that. // *or is a filled hole but has already been conformed using (var it = new WingedEdgeEnumerator(wing)) { while (it.MoveNext()) { var w = it.Current; if (!newHoles.Contains(w.opposite.face)) { w.face.submeshIndex = w.opposite.face.submeshIndex; w.face.uv = new AutoUnwrapSettings(w.opposite.face.uv); SurfaceTopology.ConformOppositeNormal(w.opposite); break; } } } } } mesh.ToMesh(); return(createdFaces); }
static ActionResult DuplicateFacesToObject() { int duplicatedFaceCount = 0; List <GameObject> duplicated = new List <GameObject>(); foreach (ProBuilderMesh mesh in MeshSelection.topInternal) { if (mesh.selectedFaceCount < 1) { continue; } var primary = mesh.selectedFaceIndexes; duplicatedFaceCount += primary.Count; List <int> inverse = new List <int>(); for (int i = 0; i < mesh.facesInternal.Length; i++) { if (!primary.Contains(i)) { inverse.Add(i); } } ProBuilderMesh copy = Object.Instantiate(mesh.gameObject, mesh.transform.parent).GetComponent <ProBuilderMesh>(); EditorUtility.SynchronizeWithMeshFilter(copy); if (copy.transform.childCount > 0) { for (int i = copy.transform.childCount - 1; i > -1; i--) { Object.DestroyImmediate(copy.transform.GetChild(i).gameObject); } foreach (var child in mesh.transform.GetComponentsInChildren <ProBuilderMesh>()) { EditorUtility.SynchronizeWithMeshFilter(child); } } Undo.RegisterCreatedObjectUndo(copy.gameObject, "Duplicate Selection"); copy.DeleteFaces(inverse); copy.Rebuild(); copy.Optimize(); mesh.ClearSelection(); copy.ClearSelection(); copy.SetSelectedFaces(copy.faces); copy.gameObject.name = GameObjectUtility.GetUniqueNameForSibling(mesh.transform.parent, mesh.gameObject.name); duplicated.Add(copy.gameObject); } MeshSelection.SetSelection(duplicated); ProBuilderEditor.Refresh(); if (duplicatedFaceCount > 0) { return(new ActionResult(ActionResult.Status.Success, "Duplicate " + duplicatedFaceCount + " faces to new Object")); } return(new ActionResult(ActionResult.Status.Failure, "No Faces Selected")); }
/// <summary> /// Inserts edges connecting a list of indices. /// /// This is the equivalent of the [Connect Edges](../manual/Edge_Connect.html) action. /// </summary> /// <param name="mesh">The target mesh.</param> /// <param name="indexes">A list of indices (corresponding to the <see cref="ProBuilderMesh.positions"/> array) to connect to the new edges.</param> /// <returns>A new array containing the indices of the newly connected positions. This method rebuilds the `indexes` array because it might modify the ordering of the original array.</returns> public static int[] Connect(this ProBuilderMesh mesh, IList <int> indexes) { if (mesh == null) { throw new ArgumentNullException("mesh"); } if (indexes == null) { throw new ArgumentNullException("indexes"); } int sharedIndexOffset = mesh.sharedVerticesInternal.Length; Dictionary <int, int> lookup = mesh.sharedVertexLookup; HashSet <int> distinct = new HashSet <int>(indexes.Select(x => lookup[x])); HashSet <int> affected = new HashSet <int>(); foreach (int i in distinct) { affected.UnionWith(mesh.sharedVerticesInternal[i].arrayInternal); } Dictionary <Face, List <int> > splits = new Dictionary <Face, List <int> >(); List <Vertex> vertices = new List <Vertex>(mesh.GetVertices()); foreach (Face face in mesh.facesInternal) { int[] f = face.distinctIndexesInternal; for (int i = 0; i < f.Length; i++) { if (affected.Contains(f[i])) { splits.AddOrAppend(face, f[i]); } } } List <ConnectFaceRebuildData> appendFaces = new List <ConnectFaceRebuildData>(); List <Face> successfulSplits = new List <Face>(); HashSet <int> usedTextureGroups = new HashSet <int>(mesh.facesInternal.Select(x => x.textureGroup)); int newTextureGroupIndex = 1; foreach (KeyValuePair <Face, List <int> > split in splits) { Face face = split.Key; List <ConnectFaceRebuildData> res = split.Value.Count == 2 ? ConnectIndexesPerFace(face, split.Value[0], split.Value[1], vertices, lookup) : ConnectIndexesPerFace(face, split.Value, vertices, lookup, sharedIndexOffset++); if (res == null) { continue; } if (face.textureGroup < 0) { while (usedTextureGroups.Contains(newTextureGroupIndex)) { newTextureGroupIndex++; } usedTextureGroups.Add(newTextureGroupIndex); } foreach (ConnectFaceRebuildData c in res) { c.faceRebuildData.face.textureGroup = face.textureGroup < 0 ? newTextureGroupIndex : face.textureGroup; c.faceRebuildData.face.uv = new AutoUnwrapSettings(face.uv); c.faceRebuildData.face.smoothingGroup = face.smoothingGroup; c.faceRebuildData.face.manualUV = face.manualUV; c.faceRebuildData.face.submeshIndex = face.submeshIndex; } successfulSplits.Add(face); appendFaces.AddRange(res); } FaceRebuildData.Apply(appendFaces.Select(x => x.faceRebuildData), mesh, vertices, null); int removedVertexCount = mesh.DeleteFaces(successfulSplits).Length; lookup = mesh.sharedVertexLookup; HashSet <int> newVertexIndexes = new HashSet <int>(); for (int i = 0; i < appendFaces.Count; i++) { for (int n = 0; n < appendFaces[i].newVertexIndexes.Count; n++) { newVertexIndexes.Add(lookup[appendFaces[i].newVertexIndexes[n] + (appendFaces[i].faceRebuildData.Offset() - removedVertexCount)]); } } mesh.ToMesh(); return(newVertexIndexes.Select(x => mesh.sharedVerticesInternal[x][0]).ToArray()); }
/// <summary> /// Inserts new edges connecting the passed edges, optionally restricting new edge insertion to faces in faceMask. /// </summary> /// <param name="mesh"></param> /// <param name="edges"></param> /// <param name="addedFaces"></param> /// <param name="connections"></param> /// <param name="returnFaces"></param> /// <param name="returnEdges"></param> /// <param name="faceMask"></param> /// <returns></returns> internal static ActionResult Connect( this ProBuilderMesh mesh, IEnumerable <Edge> edges, out Face[] addedFaces, out Edge[] connections, bool returnFaces = false, bool returnEdges = false, HashSet <Face> faceMask = null) { Dictionary <int, int> lookup = mesh.sharedVertexLookup; Dictionary <int, int> lookupUV = mesh.sharedTextureLookup; HashSet <EdgeLookup> distinctEdges = new HashSet <EdgeLookup>(EdgeLookup.GetEdgeLookup(edges, lookup)); List <WingedEdge> wings = WingedEdge.GetWingedEdges(mesh); // map each edge to a face so that we have a list of all touched faces with their to-be-subdivided edges Dictionary <Face, List <WingedEdge> > touched = new Dictionary <Face, List <WingedEdge> >(); foreach (WingedEdge wing in wings) { if (distinctEdges.Contains(wing.edge)) { List <WingedEdge> faceEdges; if (touched.TryGetValue(wing.face, out faceEdges)) { faceEdges.Add(wing); } else { touched.Add(wing.face, new List <WingedEdge>() { wing }); } } } Dictionary <Face, List <WingedEdge> > affected = new Dictionary <Face, List <WingedEdge> >(); // weed out edges that won't actually connect to other edges (if you don't play ya' can't stay) foreach (KeyValuePair <Face, List <WingedEdge> > kvp in touched) { if (kvp.Value.Count <= 1) { WingedEdge opp = kvp.Value[0].opposite; if (opp == null) { continue; } List <WingedEdge> opp_list; if (!touched.TryGetValue(opp.face, out opp_list)) { continue; } if (opp_list.Count <= 1) { continue; } } affected.Add(kvp.Key, kvp.Value); } List <Vertex> vertices = new List <Vertex>(mesh.GetVertices()); List <ConnectFaceRebuildData> results = new List <ConnectFaceRebuildData>(); // just the faces that where connected with > 1 edge List <Face> connectedFaces = new List <Face>(); HashSet <int> usedTextureGroups = new HashSet <int>(mesh.facesInternal.Select(x => x.textureGroup)); int newTextureGroupIndex = 1; // do the splits foreach (KeyValuePair <Face, List <WingedEdge> > split in affected) { Face face = split.Key; List <WingedEdge> targetEdges = split.Value; int inserts = targetEdges.Count; Vector3 nrm = Math.Normal(vertices, face.indexesInternal); if (inserts == 1 || (faceMask != null && !faceMask.Contains(face))) { ConnectFaceRebuildData c; if (InsertVertices(face, targetEdges, vertices, out c)) { Vector3 fn = Math.Normal(c.faceRebuildData.vertices, c.faceRebuildData.face.indexesInternal); if (Vector3.Dot(nrm, fn) < 0) { c.faceRebuildData.face.Reverse(); } results.Add(c); } } else if (inserts > 1) { List <ConnectFaceRebuildData> res = inserts == 2 ? ConnectEdgesInFace(face, targetEdges[0], targetEdges[1], vertices) : ConnectEdgesInFace(face, targetEdges, vertices); if (face.textureGroup < 0) { while (usedTextureGroups.Contains(newTextureGroupIndex)) { newTextureGroupIndex++; } usedTextureGroups.Add(newTextureGroupIndex); } if (res == null) { connections = null; addedFaces = null; return(new ActionResult(ActionResult.Status.Failure, "Unable to connect faces")); } else { foreach (ConnectFaceRebuildData c in res) { connectedFaces.Add(c.faceRebuildData.face); Vector3 fn = Math.Normal(c.faceRebuildData.vertices, c.faceRebuildData.face.indexesInternal); if (Vector3.Dot(nrm, fn) < 0) { c.faceRebuildData.face.Reverse(); } c.faceRebuildData.face.textureGroup = face.textureGroup < 0 ? newTextureGroupIndex : face.textureGroup; c.faceRebuildData.face.uv = new AutoUnwrapSettings(face.uv); c.faceRebuildData.face.submeshIndex = face.submeshIndex; c.faceRebuildData.face.smoothingGroup = face.smoothingGroup; c.faceRebuildData.face.manualUV = face.manualUV; } results.AddRange(res); } } } FaceRebuildData.Apply(results.Select(x => x.faceRebuildData), mesh, vertices, null); mesh.sharedTextures = new SharedVertex[0]; int removedVertexCount = mesh.DeleteFaces(affected.Keys).Length; mesh.sharedVertices = SharedVertex.GetSharedVerticesWithPositions(mesh.positionsInternal); mesh.ToMesh(); // figure out where the new edges where inserted if (returnEdges) { // offset the newVertexIndexes by whatever the FaceRebuildData did so we can search for the new edges by index var appended = new HashSet <int>(); for (int n = 0; n < results.Count; n++) { for (int i = 0; i < results[n].newVertexIndexes.Count; i++) { appended.Add((results[n].newVertexIndexes[i] + results[n].faceRebuildData.Offset()) - removedVertexCount); } } Dictionary <int, int> lup = mesh.sharedVertexLookup; IEnumerable <Edge> newEdges = results.SelectMany(x => x.faceRebuildData.face.edgesInternal).Where(x => appended.Contains(x.a) && appended.Contains(x.b)); IEnumerable <EdgeLookup> distNewEdges = EdgeLookup.GetEdgeLookup(newEdges, lup); connections = distNewEdges.Distinct().Select(x => x.local).ToArray(); } else { connections = null; } if (returnFaces) { addedFaces = connectedFaces.ToArray(); } else { addedFaces = null; } return(new ActionResult(ActionResult.Status.Success, string.Format("Connected {0} Edges", results.Count / 2))); }
static ActionResult DetachFacesToObject() { int detachedFaceCount = 0; List <GameObject> detached = new List <GameObject>(); foreach (ProBuilderMesh mesh in MeshSelection.topInternal) { if (mesh.selectedFaceCount < 1 || mesh.selectedFaceCount == mesh.facesInternal.Length) { continue; } var primary = mesh.selectedFaceIndexes; detachedFaceCount += primary.Count; List <int> inverse = new List <int>(); for (int i = 0; i < mesh.facesInternal.Length; i++) { if (!primary.Contains(i)) { inverse.Add(i); } } ProBuilderMesh copy = Object.Instantiate(mesh.gameObject, mesh.transform.parent).GetComponent <ProBuilderMesh>(); EditorUtility.SynchronizeWithMeshFilter(copy); #if !UNITY_2018_3_OR_NEWER // if is prefab, break connection and destroy children if (EditorUtility.IsPrefabInstance(copy.gameObject) || EditorUtility.IsPrefabAsset(copy.gameObject)) { PrefabUtility.DisconnectPrefabInstance(copy.gameObject); } #endif if (copy.transform.childCount > 0) { for (int i = copy.transform.childCount - 1; i > -1; i--) { Object.DestroyImmediate(copy.transform.GetChild(i).gameObject); } foreach (var child in mesh.transform.GetComponentsInChildren <ProBuilderMesh>()) { EditorUtility.SynchronizeWithMeshFilter(child); } } Undo.RegisterCreatedObjectUndo(copy.gameObject, "Detach Selection"); mesh.DeleteFaces(primary); copy.DeleteFaces(inverse); mesh.Rebuild(); copy.Rebuild(); mesh.Optimize(); copy.Optimize(); mesh.ClearSelection(); copy.ClearSelection(); copy.SetSelectedFaces(copy.faces); copy.gameObject.name = GameObjectUtility.GetUniqueNameForSibling(mesh.transform.parent, mesh.gameObject.name);; detached.Add(copy.gameObject); } MeshSelection.SetSelection(detached); ProBuilderEditor.Refresh(); if (detachedFaceCount > 0) { return(new ActionResult(ActionResult.Status.Success, "Detach " + detachedFaceCount + " faces to new Object")); } return(new ActionResult(ActionResult.Status.Failure, "No Faces Selected")); }