public void Setup()
    {
        ProBuilderMesh shape1 = ShapeFactory.Instantiate <Cube>();

        shape1.transform.position = Vector3.zero - shape1.GetComponent <MeshRenderer>().bounds.center;

        ProBuilderMesh shape2 = ShapeFactory.Instantiate <Cube>();

        shape2.transform.position = Vector3.zero - shape2.GetComponent <MeshRenderer>().bounds.center;

        shape1.AddToFaceSelection(0);
        shape1.AddToFaceSelection(1);
        shape1.AddToFaceSelection(2);
        shape1.SetMaterial(shape1.GetSelectedFaces(), BuiltinMaterials.facePickerMaterial);
        shape1.ClearSelection();
        shape1.AddToFaceSelection(3);
        shape1.AddToFaceSelection(4);
        shape1.AddToFaceSelection(5);
        shape1.SetMaterial(shape1.GetSelectedFaces(), null);
        shape1.ClearSelection();

        shape2.AddToFaceSelection(0);
        shape2.AddToFaceSelection(1);
        shape2.AddToFaceSelection(2);
        shape2.SetMaterial(shape2.GetSelectedFaces(), BuiltinMaterials.colliderMaterial);
        shape2.ClearSelection();
        shape2.AddToFaceSelection(3);
        shape2.AddToFaceSelection(4);
        shape2.AddToFaceSelection(5);
        shape2.SetMaterial(shape2.GetSelectedFaces(), BuiltinMaterials.facePickerMaterial);
        shape2.ClearSelection();

        selectables = new ProBuilderMesh[]
        {
            shape1,
            shape2
        };
    }
Exemple #2
0
        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"));
        }
        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"));
        }