Unity 2023.1.0a19 C# reference source code

Author: Unity Technologies

Editor/Mono/CustomEditorAttributes.cs

@@ -40,7 +40,7 @@ internal partial class CustomEditorAttributes
 
         CustomEditorAttributes()
         {
-            Rebuild();
+            Initialize();
         }
 
         Type GetCustomEditorType(Type type, bool multiEdit)
@@ -148,7 +148,12 @@ static bool IsAppropriateEditor(MonoEditorType editor, bool isChildClass, bool i
             return isFallbackPass == editor.isFallback;
         }
 
-        void Rebuild()
+        internal static void Rebuild()
+        {
+            instance.Initialize();
+        }
+
+        void Initialize()
         {
             m_Cache.Clear();
             var types = TypeCache.GetTypesWithAttribute<CustomEditor>();

Editor/Mono/EditorGUI.cs

@@ -2992,6 +2992,14 @@ internal static GenericMenu FillPropertyContextMenu(SerializedProperty property,
 
                 Object targetObject = property.serializedObject.targetObject;
 
+                PropertyValueOriginInfo propertyOrigin = PrefabUtility.GetPropertyValueOriginInfo(property);
+
+                if (propertyOrigin.asset != null)
+                {
+                    pm.AddItem(new GUIContent("Go to " + propertyOrigin.contextMenuText + " in '" + propertyOrigin.asset.name + "'"), false,
+                        () => GoToPrefab(AssetDatabase.GetAssetPath(propertyOrigin.asset), PrefabUtility.GetGameObject(targetObject)));
+                }
+
                 bool shouldDisplayPrefabContextMenuItems = property.prefabOverride || (linkedProperty?.prefabOverride ?? false);
 
                 // Only display the custom apply/revert menu for GameObjects/Components that are not part of a Prefab instance & variant.
@@ -3261,6 +3269,16 @@ internal static GenericMenu FillPropertyContextMenu(SerializedProperty property,
             return pm;
         }
 
+        internal static void GoToPrefab(string assetPath, GameObject openedFromInstance)
+        {
+            // When this function is called from a Property Context Menu on the Overrides pop-up window, we need to make ensure that the correct GameObject
+            // (i.e. the GameObject that the property belongs to) is selected when opening Prefab Mode by explicitly setting it as the active GameObject.
+            if (EditorGUIUtility.comparisonViewMode != EditorGUIUtility.ComparisonViewMode.None)
+                Selection.activeGameObject = openedFromInstance;
+
+            PrefabStageUtility.OpenPrefab(assetPath, openedFromInstance, PrefabStage.Mode.InIsolation);
+        }
+
         internal static void DoPropertyContextMenu(SerializedProperty property, SerializedProperty linkedProperty = null, GenericMenu menu = null)
         {
             GenericMenu pm = FillPropertyContextMenu(property, linkedProperty, menu);

Editor/Mono/EditorUtility.cs

@@ -580,6 +580,27 @@ internal static void DisplayObjectContextMenu(Rect position, Object[] context, i
                         );
                     }
                 }
+
+                bool isComponentAddedInNestedPrefab = false;
+
+                Object source = PrefabUtility.GetCorrespondingObjectFromSource(targetObject);
+                while (source)
+                {
+                    if (PrefabUtility.IsAddedComponentOverride(source))
+                    {
+                        isComponentAddedInNestedPrefab = true;
+                        break;
+                    }
+
+                    source = PrefabUtility.GetCorrespondingObjectFromSource(source);
+                }    
+
+                if (isComponentAddedInNestedPrefab)
+                {
+                    pm.AddItem(new GUIContent("Go to Added Component in '" + PrefabUtility.GetPrefabAssetRootGameObject(source).name + "'"), false,
+                    () => PrefabStageUtility.OpenPrefab(AssetDatabase.GetAssetPath(source), PrefabUtility.GetGameObject(targetObject), PrefabStage.Mode.InIsolation));
+                }
+
             }
             else if (context != null && context.Length == 1 && context[0] is Material)
             {

Editor/Mono/GUI/Tools/EditorToolAttributes.cs

@@ -8,12 +8,49 @@ namespace UnityEditor.EditorTools
 {
     public abstract class ToolAttribute : Attribute
     {
+        public const int defaultPriority = 1000;
+
         string m_DisplayName;
         Type m_TargetContext, m_TargetType;
+        Type m_VariantGroup;
+        int m_ToolPriority = defaultPriority;
+        int m_VariantPriority = defaultPriority;
+
+        public string displayName
+        {
+            get => m_DisplayName;
+            set => m_DisplayName = value;
+        }
+
+        public Type targetType
+        {
+            get => m_TargetType;
+            set => m_TargetType = value;
+        }
+
+        public Type targetContext
+        {
+            get => m_TargetContext;
+            set => m_TargetContext = value;
+        }
+
+        public int toolPriority
+        {
+            get => m_ToolPriority;
+            set => m_ToolPriority = value;
+        }
 
-        public string displayName => m_DisplayName;
-        public Type targetType => m_TargetType;
-        public Type targetContext => m_TargetContext;
+        public Type variantGroup
+        {
+            get => m_VariantGroup;
+            set => m_VariantGroup = value;
+        }
+
+        public int variantPriority
+        {
+            get => m_VariantPriority;
+            set => m_VariantPriority = value;
+        }
 
         ToolAttribute() {}
 
@@ -25,6 +62,8 @@ protected ToolAttribute(string displayName, Type targetType = null, Type editorT
                 throw new ArgumentException($"{GetType().Name} ({displayName}): editorToolContext type argument must " +
                     $"be of type EditorToolContext", "editorToolContext");
             m_TargetContext = editorToolContext;
+            m_VariantGroup = variantGroup;
+            m_ToolPriority = toolPriority;
         }
     }
 
@@ -33,8 +72,21 @@ public sealed class EditorToolAttribute : ToolAttribute
     {
         public EditorToolAttribute(string displayName, Type componentToolTarget = null)
             : base(displayName, componentToolTarget) {}
+
         public EditorToolAttribute(string displayName, Type componentToolTarget, Type editorToolContext)
             : base(displayName, componentToolTarget, editorToolContext) {}
+
+        public EditorToolAttribute(
+            string displayName,
+            Type componentToolTarget,
+            Type editorToolContext,
+            int toolPriority,
+            Type variantGroup)
+            : base(displayName, componentToolTarget, editorToolContext)
+        {
+            this.toolPriority = toolPriority;
+            this.variantGroup = variantGroup;
+        }
     }
 
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]

Editor/Mono/GUI/Tools/EditorToolCache.cs

@@ -10,30 +10,41 @@
 
 namespace UnityEditor.EditorTools
 {
+    // Placeholder type for global editors to register as keys
+    struct NullTargetKey {}
+
     [Serializable]
     struct EditorTypeAssociation : ISerializationCallbackReceiver
     {
         [SerializeField]
-        string m_TargetContext, m_TargetBehaviour, m_EditorType;
+        string m_TargetContext, m_TargetBehaviour, m_EditorType, m_VariantGroup;
 
         // Context and behaviour types can be null, and should be treated as universally applicable.
         public Type targetContext { get; private set; }
         public Type targetBehaviour { get; private set; }
         public Type editor { get; private set; }
+        public Type variantGroup { get; private set; }
+        public int priority { get; private set; }
+        public int variantPriority { get; private set; }
 
-        public EditorTypeAssociation(Type editor, Type targetBehaviour, Type targetContext)
+        public EditorTypeAssociation(Type editor, Type attributeType)
         {
-            this.targetContext = targetContext;
-            this.targetBehaviour = targetBehaviour;
             this.editor = editor;
-            m_EditorType = m_TargetBehaviour = m_TargetContext = null;
+            var attrib = editor.GetCustomAttributes(attributeType, false).FirstOrDefault() as ToolAttribute;
+            targetBehaviour = attrib?.targetType ?? typeof(NullTargetKey);
+            targetContext = attrib?.targetContext;
+            variantGroup = attrib?.variantGroup;
+            priority = attrib?.toolPriority ?? ToolAttribute.defaultPriority;
+            variantPriority = attrib?.variantPriority ?? ToolAttribute.defaultPriority;
+            m_TargetContext = m_TargetBehaviour = m_EditorType = m_VariantGroup = null;
         }
 
         public void OnBeforeSerialize()
         {
             m_TargetContext = targetContext?.AssemblyQualifiedName;
             m_TargetBehaviour = targetBehaviour?.AssemblyQualifiedName;
             m_EditorType = editor?.AssemblyQualifiedName;
+            m_VariantGroup = variantGroup?.AssemblyQualifiedName;
         }
 
         public void OnAfterDeserialize()
@@ -44,7 +55,8 @@ public void OnAfterDeserialize()
                 targetBehaviour = Type.GetType(m_TargetBehaviour);
             if (!string.IsNullOrEmpty(m_EditorType))
                 editor = Type.GetType(m_EditorType);
-            m_TargetContext = m_TargetBehaviour = m_EditorType = null;
+            if (!string.IsNullOrEmpty(m_VariantGroup))
+                variantGroup = Type.GetType(m_VariantGroup);
         }
     }
 
@@ -152,11 +164,12 @@ public UnityObject InstantiateEditor()
     // target types are treated as "global" editors.
     class EditorToolCache
     {
-        // Placeholder type for global editors to register as keys
-        struct NullTargetKey {}
 
         Type m_AttributeType;
+        // Cache of the available tools as defined by EditorToolAttribute
         EditorTypeAssociation[] s_AvailableEditorTypeAssociations = null;
+        // Type association data for all loaded tools, regardless of whether they are registered with an EditorToolAttribute.
+        Dictionary<Type, EditorTypeAssociation> m_ToolMetaData = new Dictionary<Type, EditorTypeAssociation>();
         Dictionary<Type, List<EditorTypeAssociation>> s_EditorTargetCache = new Dictionary<Type, List<EditorTypeAssociation>>();
 
         // Static fields in generic classes result in multiple static field instances. In this case that's fine.
@@ -195,22 +208,21 @@ EditorTypeAssociation[] availableEditorTypeAssociations
                     s_AvailableEditorTypeAssociations = new EditorTypeAssociation[len];
 
                     for (int i = 0; i < len; i++)
-                    {
-                        var customToolAttribute = editorTools[i].GetCustomAttributes(m_AttributeType, false)
-                            .FirstOrDefault() as ToolAttribute;
-
-                        if (customToolAttribute == null)
-                            continue;
+                        s_AvailableEditorTypeAssociations[i] = new EditorTypeAssociation(editorTools[i], m_AttributeType);
 
-                        s_AvailableEditorTypeAssociations[i] = new EditorTypeAssociation(
-                            editorTools[i], customToolAttribute.targetType ?? typeof(NullTargetKey), customToolAttribute.targetContext);
-                    }
                 }
 
                 return s_AvailableEditorTypeAssociations;
             }
         }
 
+        public EditorTypeAssociation GetMetaData(Type toolType)
+        {
+            if (!m_ToolMetaData.TryGetValue(toolType, out var data))
+                m_ToolMetaData.Add(toolType, data = new EditorTypeAssociation(toolType, m_AttributeType));
+            return data;
+        }
+
         public Type GetTargetType(Type editorType)
         {
             for (int i = 0, c = availableEditorTypeAssociations.Length; i < c; i++)
@@ -305,5 +317,16 @@ public void InstantiateEditors(EditorToolContext ctx, List<ComponentEditor> edit
             foreach (var editor in editors)
                 editor.InstantiateEditor();
         }
+
+        public List<EditorTypeAssociation> GetEditorsForVariant(EditorTypeAssociation type)
+        {
+            var tools = new List<EditorTypeAssociation>();
+            foreach(var association in availableEditorTypeAssociations)
+                if (association.variantGroup == type.variantGroup
+                    && association.targetBehaviour == type.targetBehaviour
+                    && association.targetContext == type.targetContext)
+                    tools.Add(association);
+            return tools;
+        }
     }
 }