379 lines
14 KiB
C#
379 lines
14 KiB
C#
#if UNITY_EDITOR
|
|
using MonKey.Editor.Internal;
|
|
using MonKey.Extensions;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using UnityEditor;
|
|
#if UNITY_2022_1_OR_NEWER
|
|
using UnityEditor.SceneManagement;
|
|
#else
|
|
|
|
#endif
|
|
|
|
using UnityEngine;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace MonKey.Editor.Commands
|
|
{
|
|
public static class PrefabUtilities
|
|
{
|
|
[Command("Select Prefab Root", QuickName = "SPR",
|
|
Help = "Selects the prefab roots of the selected objects",
|
|
DefaultValidation = DefaultValidation.AT_LEAST_ONE_GAME_OBJECT,
|
|
Category = "Prefab")]
|
|
public static void SelectPrefabRoots()
|
|
{
|
|
List<Object> roots = new List<Object>();
|
|
|
|
foreach (GameObject o in Selection.gameObjects)
|
|
{
|
|
roots.Add(PrefabUtility.GetOutermostPrefabInstanceRoot(o));
|
|
}
|
|
|
|
Selection.objects = roots.ToArray();
|
|
}
|
|
|
|
[Command("New Prefab", QuickName = "NPR",
|
|
Help = "Create a prefab out of the selected objects in a folder you can specify",
|
|
ValidationMethodName = "ValidateCreatePrefabs",
|
|
Category = "Prefab")]
|
|
public static void CreatePrefabs()
|
|
{
|
|
CreatePrefabs(Selection.gameObjects);
|
|
}
|
|
|
|
[CommandValidation("You must select at least one GameObject")]
|
|
public static bool ValidateCreatePrefabs()
|
|
{
|
|
return (Selection.activeGameObject != null);
|
|
}
|
|
|
|
[Command("New Prefab Variants", "Creates prefab variants of the selected prefab", Category = "Assets",
|
|
QuickName = "PV")]
|
|
public static void CreatePrefabVariant(int duplicateAmount = 1)
|
|
{
|
|
foreach (var gameObject in Selection.gameObjects)
|
|
{
|
|
GameObject obj = (GameObject)PrefabUtility.InstantiatePrefab(gameObject);
|
|
string path = AssetDatabase.GetAssetPath(gameObject);
|
|
|
|
for (int i = 0; i < duplicateAmount; i++)
|
|
{
|
|
string newPath = AssetDatabase.GenerateUniqueAssetPath(path);
|
|
PrefabUtility.SaveAsPrefabAsset(obj, newPath);
|
|
}
|
|
|
|
Object.DestroyImmediate(obj);
|
|
}
|
|
}
|
|
|
|
private static void CreatePrefabs(GameObject[] gameObjects)
|
|
{
|
|
if (gameObjects == null || gameObjects.Length == 0)
|
|
return;
|
|
|
|
// Ask user for the asset path to store prefabs
|
|
string savePath = EditorUtility.SaveFilePanelInProject("Prefab Creation", "Prefab",
|
|
"prefab", "Select the prefab's folder", "Assets");
|
|
|
|
if (savePath.Length <= 0)
|
|
return;
|
|
if (!savePath.Contains(".prefab"))
|
|
savePath += ".prefab";
|
|
|
|
int i = 0;
|
|
foreach (GameObject go in gameObjects)
|
|
{
|
|
if (EditorUtility.DisplayCancelableProgressBar("Prefab creation", "In Progress!" +
|
|
go.name,
|
|
(i + .5f) / Selection.gameObjects.Length))
|
|
break;
|
|
i++;
|
|
|
|
string savePathArranged = savePath.Insert(savePath.IndexOf(".",
|
|
StringComparison.Ordinal), "-" + go.name);
|
|
PrefabUtility.SaveAsPrefabAssetAndConnect(go, savePathArranged, InteractionMode.AutomatedAction);
|
|
}
|
|
|
|
EditorUtility.ClearProgressBar();
|
|
}
|
|
|
|
public static GameObject[] CreatePrefabDefaultObjects()
|
|
{
|
|
return Selection.gameObjects;
|
|
}
|
|
|
|
[Command("Apply Prefab", Help = "Applies the changes on the selected prefabs",
|
|
QuickName = "AP",
|
|
Category = "Prefab")]
|
|
public static void ApplyPrefabs()
|
|
{
|
|
int i = 0;
|
|
List<GameObject> parentApplied = new List<GameObject>();
|
|
foreach (GameObject go in Selection.gameObjects.Where(_ => _.scene.IsValid()
|
|
&& _.hideFlags == HideFlags.None))
|
|
{
|
|
if (EditorUtility.DisplayCancelableProgressBar("Applying Prefabs", "Processing..." + go.name,
|
|
(i + .5f) / Selection.gameObjects.Length))
|
|
break;
|
|
i++;
|
|
GameObject applied = ApplySinglePrefab(parentApplied, go);
|
|
|
|
if (applied != null)
|
|
parentApplied.Add(applied);
|
|
}
|
|
|
|
EditorUtility.ClearProgressBar();
|
|
}
|
|
|
|
[CommandValidation("Select Some Prefabs First")]
|
|
private static bool ValidateApplyPrefabs()
|
|
{
|
|
return Selection.activeGameObject != null;
|
|
}
|
|
|
|
internal static Object GetPrefabParentPlatformIndependant(GameObject child)
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GameObject prefabParent = PrefabUtility.GetCorrespondingObjectFromSource(child);
|
|
|
|
#elif UNITY_2018_2_OR_NEWER
|
|
Type pUtilityType = typeof(PrefabUtility);
|
|
MethodInfo info = pUtilityType.GetMethod("GetCorrespondingObjectFromSource");
|
|
//stupid ass reflection because of some method signature change in the last Unity
|
|
GameObject prefabParent = info.Invoke(null,new object[]{child}) as GameObject;
|
|
#else
|
|
GameObject prefabParent = PrefabUtility.GetPrefabParent(child) as GameObject;
|
|
#endif
|
|
|
|
return prefabParent;
|
|
}
|
|
|
|
|
|
[Command("Select Instances", "Selects all instances of the specified prefab", QuickName = "SI",
|
|
AlwaysShow = true, Order = -5, MenuItemLink = "SelectPrefabInstances",
|
|
MenuItemLinkTypeOwner = "MonkeyMenuItems",
|
|
Category = "Prefab")]
|
|
public static void SelectInstancesOfPrefab(
|
|
[CommandParameter(Help = "The prefab to find the instances of on the opened scenes",
|
|
ForceAutoCompleteUsage = true,
|
|
DefaultValueNameOverride = "Prefab Selected",
|
|
AutoCompleteMethodName = "PrefabAutoComplete")]
|
|
string prefabName = "")
|
|
{
|
|
GameObject prefab;
|
|
if (prefabName == "")
|
|
prefab = Selection.objects.First(_ => _ is GameObject) as GameObject;
|
|
else
|
|
prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabName);
|
|
|
|
if (prefab == null)
|
|
{
|
|
Debug.LogWarning("Monkey Error: the prefab was not recognized");
|
|
return;
|
|
}
|
|
|
|
EditorUtility.DisplayProgressBar("Finding Prefab Instances...",
|
|
"Please Wait while Monkey is looking for the prefab instances!", 0);
|
|
List<Transform> transs = TransformExt.GetAllTransformedOrderUpToDown();
|
|
int i = 0;
|
|
|
|
List<GameObject> selectedInstances = new List<GameObject>();
|
|
|
|
foreach (Transform transform in transs)
|
|
{
|
|
if (EditorUtility.DisplayCancelableProgressBar("Finding Prefab Instances...",
|
|
"Please Wait while Monkey is looking for the prefab instances!",
|
|
((float)i / transs.Count) * .5f + .5f))
|
|
break;
|
|
|
|
if (prefab.IsPrefab())
|
|
{
|
|
#if UNITY_2018_3_OR_NEWER
|
|
GameObject prefabRoot = PrefabUtility.GetNearestPrefabInstanceRoot(transform.gameObject);
|
|
#else
|
|
GameObject prefabRoot = PrefabUtility.FindPrefabRoot(transform.gameObject);
|
|
#endif
|
|
// Update the prefab of the game object
|
|
Object prefabParent = prefabRoot ? GetPrefabParentPlatformIndependant(prefabRoot) : null;
|
|
|
|
if (prefabParent == prefab && !selectedInstances.Contains(prefabRoot))
|
|
selectedInstances.Add(prefabRoot);
|
|
}
|
|
else
|
|
{
|
|
//then it's a model
|
|
MeshFilter filter = transform.gameObject.GetComponent<MeshFilter>();
|
|
if (filter)
|
|
{
|
|
MeshFilter[] filters = prefab.GetComponentsInChildren<MeshFilter>();
|
|
if (filters.Any(_ => _.sharedMesh == filter.sharedMesh))
|
|
selectedInstances.Add(filter.gameObject);
|
|
}
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
Selection.objects = selectedInstances.Convert(_ => _ as Object).ToArray();
|
|
EditorUtility.ClearProgressBar();
|
|
}
|
|
|
|
public static AssetNameAutoComplete PrefabAutoComplete()
|
|
{
|
|
return new AssetNameAutoComplete() { CustomType = "GameObject" };
|
|
}
|
|
|
|
public static GameObject ApplySinglePrefab(List<GameObject> excludedPrefabs, GameObject gameObject,
|
|
bool forceActive = false, bool resetTransform = false)
|
|
{
|
|
GameObject prefabRoot = PrefabUtility.GetOutermostPrefabInstanceRoot(gameObject);
|
|
// Update the prefab of the game object
|
|
GameObject prefabParent = (GameObject)GetPrefabParentPlatformIndependant(prefabRoot);
|
|
|
|
if (excludedPrefabs.Contains(prefabParent))
|
|
return null;
|
|
|
|
|
|
if (prefabParent != null)
|
|
{
|
|
bool isActive = gameObject.activeSelf;
|
|
Transform t = prefabRoot.transform;
|
|
Vector3 localPosition = t.localPosition;
|
|
Quaternion localRotation = t.localRotation;
|
|
|
|
if (forceActive)
|
|
gameObject.SetActive(true);
|
|
|
|
if (resetTransform)
|
|
{
|
|
t.localPosition = Vector3.zero;
|
|
t.localRotation = Quaternion.identity;
|
|
}
|
|
|
|
PrefabUtility.SavePrefabAsset(prefabRoot);
|
|
|
|
if (forceActive)
|
|
gameObject.SetActive(isActive);
|
|
|
|
if (resetTransform)
|
|
{
|
|
t.localPosition = localPosition;
|
|
t.localRotation = localRotation;
|
|
}
|
|
|
|
return prefabParent;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
[Command("Revert Prefab Instances",
|
|
"Reverts all the changes made to the prefab instance to the base prefab",
|
|
QuickName = "RPI",
|
|
DefaultValidation = DefaultValidation.AT_LEAST_ONE_GAME_OBJECT,
|
|
Category = "Prefab")]
|
|
public static void RevertToPrefabInstances()
|
|
{
|
|
foreach (GameObject o in Selection.gameObjects)
|
|
{
|
|
if (PrefabUtility.GetPrefabInstanceStatus(o) != PrefabInstanceStatus.NotAPrefab)
|
|
PrefabUtility.RevertObjectOverride(o, InteractionMode.AutomatedAction);
|
|
}
|
|
}
|
|
|
|
#if UNITY_2018_3_OR_NEWER || UNITY_2019
|
|
|
|
[Command("Open Prefab", "Opens a prefab", AlwaysShow = true, Category = "Prefab", QuickName = "OP",
|
|
DefaultValidation = DefaultValidation.IN_EDIT_MODE)]
|
|
private static void OpenPrefab([CommandParameter(AutoCompleteMethodName = "PrefabNameAutoComplete",
|
|
ForceAutoCompleteUsage = true, Help = "The name of the prefab to open",
|
|
OverrideName = "Prefab Name", PreventDefaultValueUsage = true)]
|
|
string prefabPath)
|
|
{
|
|
Type utils = typeof(UnityEditor.SceneManagement.PrefabStageUtility);
|
|
var methods = utils.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
|
|
|
|
if (methods.Length == 0)
|
|
Debug.Log("The Open Prefab Method wasn't found: Unity may have changed its API, " +
|
|
"please contact the MonKey support");
|
|
|
|
foreach (var info in methods)
|
|
{
|
|
if (info.Name == "OpenPrefab" && info.GetParameters().Length == 1)
|
|
{
|
|
info.Invoke(null, new object[] { prefabPath });
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static AssetNameAutoComplete PrefabNameAutoComplete()
|
|
{
|
|
return new AssetNameAutoComplete()
|
|
{
|
|
CustomType = "GameObject",
|
|
IncludeDirectories = false,
|
|
PopulateOnInit = true,
|
|
};
|
|
}
|
|
|
|
[Command("Remove Component Of Type From Prefabs In Folder",
|
|
Help =
|
|
"Removes all the component of the given type on all the prefabs present in a given folder, recursively")]
|
|
public static void RemoveComponentsFromPrefabsInFolder(
|
|
[CommandParameter(AutoCompleteMethodName = "FolderAutoComplete", Help = "The name of the folder",
|
|
ForceAutoCompleteUsage = true)]
|
|
string folderName,
|
|
[CommandParameter(Help = "The Type of Component", AutoCompleteMethodName = "ComponentTypeAuto")]
|
|
Type componentType)
|
|
{
|
|
SelectionUtilities.FindFolder(folderName);
|
|
string folderPath = AssetDatabase.GetAssetPath(Selection.activeObject);
|
|
string[] folders = AssetDatabase.GetSubFolders(folderName);
|
|
|
|
List<string> foldersList = new List<string>(folders);
|
|
|
|
foldersList.Add(folderName);
|
|
|
|
string[] prefabPaths = AssetDatabase.FindAssets("t:GameObject", foldersList.ToArray());
|
|
foreach (var path in prefabPaths)
|
|
{
|
|
var go = AssetDatabase.LoadAssetAtPath<GameObject>(AssetDatabase.GUIDToAssetPath(path));
|
|
if (!go)
|
|
return;
|
|
|
|
var instance = (GameObject)PrefabUtility.InstantiatePrefab(go);
|
|
|
|
var comps = instance.GetComponentsInChildren(componentType);
|
|
var originalComps = go.GetComponentsInChildren(componentType);
|
|
for (var index = 0; index < comps.Length; index++)
|
|
{
|
|
var component = comps[index];
|
|
var prefabComponent = originalComps[index];
|
|
Object.DestroyImmediate(component);
|
|
PrefabUtility.ApplyRemovedComponent(instance, prefabComponent, InteractionMode.AutomatedAction);
|
|
}
|
|
|
|
Object.DestroyImmediate(instance);
|
|
}
|
|
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
|
|
public static AssetNameAutoComplete FolderAutoComplete()
|
|
{
|
|
return new AssetNameAutoComplete() { DirectoryMode = true };
|
|
}
|
|
|
|
public static TypeAutoComplete ComponentTypeAuto()
|
|
{
|
|
return new TypeAutoComplete(false, true, true, false, false);
|
|
}
|
|
|
|
#endif
|
|
}
|
|
}
|
|
#endif |