C# UnityEditor类代码示例

 public static UnityEngine.Object[] GetFiltered(System.Type type, UnityEditor.SelectionMode mode)
 {
     ArrayList list = new ArrayList();
     if ((type == typeof(Component)) || type.IsSubclassOf(typeof(Component)))
     {
         foreach (Transform transform in GetTransforms(mode))
         {
             Component component = transform.GetComponent(type);
             if (component != null)
             {
                 list.Add(component);
             }
         }
     }
     else if ((type == typeof(GameObject)) || type.IsSubclassOf(typeof(GameObject)))
     {
         foreach (Transform transform2 in GetTransforms(mode))
         {
             list.Add(transform2.gameObject);
         }
     }
     else
     {
         foreach (UnityEngine.Object obj2 in GetObjectsMode(mode))
         {
             if ((obj2 != null) && ((obj2.GetType() == type) || obj2.GetType().IsSubclassOf(type)))
             {
                 list.Add(obj2);
             }
         }
     }
     return (UnityEngine.Object[]) list.ToArray(typeof(UnityEngine.Object));
 }

 public override void Connect(UnityEditor.Graphs.AnimationStateMachine.Node toNode, UnityEditor.Graphs.Edge edge)
 {
     if (toNode is StateNode)
     {
         base.graphGUI.stateMachineGraph.activeStateMachine.AddStateMachineTransition(this.stateMachine, (toNode as StateNode).state);
         base.graphGUI.stateMachineGraph.RebuildGraph();
     }
     else if (toNode is StateMachineNode)
     {
         UnityEditor.Graphs.AnimationStateMachine.Node.GenericMenuForStateMachineNode(toNode as StateMachineNode, true, delegate (object data) {
             if (data is AnimatorState)
             {
                 base.graphGUI.stateMachineGraph.activeStateMachine.AddStateMachineTransition(this.stateMachine, data as AnimatorState);
             }
             else
             {
                 base.graphGUI.stateMachineGraph.activeStateMachine.AddStateMachineTransition(this.stateMachine, data as AnimatorStateMachine);
             }
             base.graphGUI.stateMachineGraph.RebuildGraph();
         });
     }
     else if (toNode is ExitNode)
     {
         base.graphGUI.stateMachineGraph.activeStateMachine.AddStateMachineExitTransition(this.stateMachine);
         base.graphGUI.stateMachineGraph.RebuildGraph();
     }
 }

 public override void NodeUI(UnityEditor.Graphs.GraphGUI host)
 {
     base.graphGUI = host as UnityEditor.Graphs.AnimationStateMachine.GraphGUI;
     Assert.NotNull(base.graphGUI);
     if (UnityEditor.Graphs.AnimationStateMachine.Node.IsLeftClick())
     {
         host.edgeGUI.EndSlotDragging(Enumerable.First<Slot>(base.inputSlots), true);
     }
     if (UnityEditor.Graphs.AnimationStateMachine.Node.IsDoubleClick())
     {
         if (this.stateMachine == base.graphGUI.stateMachineGraph.parentStateMachine)
         {
             base.graphGUI.tool.GoToBreadCrumbTarget(this.stateMachine);
         }
         else
         {
             base.graphGUI.tool.AddBreadCrumb(this.stateMachine);
         }
         Event.current.Use();
     }
     if (UnityEditor.Graphs.AnimationStateMachine.Node.IsRightClick() && (this.stateMachine != base.graphGUI.stateMachineGraph.parentStateMachine))
     {
         GenericMenu menu = new GenericMenu();
         menu.AddItem(new GUIContent("Make Transition"), false, new GenericMenu.MenuFunction(this.MakeTransitionCallback));
         menu.AddItem(new GUIContent("Copy"), false, new GenericMenu.MenuFunction(this.CopyStateMachineCallback));
         menu.AddItem(new GUIContent("Delete"), false, new GenericMenu.MenuFunction(this.DeleteStateMachineCallback));
         menu.ShowAsContext();
         Event.current.Use();
     }
 }

 private static List<MemoryElement> GenerateObjectTypeGroups(UnityEditor.ObjectInfo[] memory, ObjectTypeFilter filter)
 {
     List<MemoryElement> list = new List<MemoryElement>();
     MemoryElement item = null;
     foreach (UnityEditor.ObjectInfo info in memory)
     {
         if (GetObjectTypeFilter(info) == filter)
         {
             if ((item == null) || (info.className != item.name))
             {
                 item = new MemoryElement(info.className);
                 list.Add(item);
             }
             item.AddChild(new MemoryElement(info, true));
         }
     }
     list.Sort(new Comparison<MemoryElement>(MemoryElementDataManager.SortByMemorySize));
     foreach (MemoryElement element2 in list)
     {
         element2.children.Sort(new Comparison<MemoryElement>(MemoryElementDataManager.SortByMemorySize));
         if ((filter == ObjectTypeFilter.Other) && !HasValidNames(element2.children))
         {
             element2.children.Clear();
         }
     }
     return list;
 }

			/// <summary>
			/// Construct from a Unity SceneSetup
			/// </summary>
			public SceneEntry( UnityEditor.SceneManagement.SceneSetup sceneSetup )
			{
				scene = new AmsSceneReference( sceneSetup.path );

				loadInEditor = sceneSetup.isLoaded;
				loadMethod = LoadMethod.Additive;
			}

 public override void Connect(UnityEditor.Graphs.AnimationStateMachine.Node toNode, UnityEditor.Graphs.Edge edge)
 {
     if (toNode is StateNode)
     {
         base.graphGUI.stateMachineGraph.rootStateMachine.AddAnyStateTransition((toNode as StateNode).state);
         base.graphGUI.stateMachineGraph.RebuildGraph();
     }
     if (toNode is StateMachineNode)
     {
         StateMachineNode node = toNode as StateMachineNode;
         if (node.stateMachine != base.graphGUI.parentStateMachine)
         {
             UnityEditor.Graphs.AnimationStateMachine.Node.GenericMenuForStateMachineNode(toNode as StateMachineNode, true, delegate (object data) {
                 if (data is AnimatorState)
                 {
                     base.graphGUI.stateMachineGraph.rootStateMachine.AddAnyStateTransition(data as AnimatorState);
                 }
                 else if (data is AnimatorStateMachine)
                 {
                     base.graphGUI.stateMachineGraph.rootStateMachine.AddAnyStateTransition(data as AnimatorStateMachine);
                 }
                 base.graphGUI.stateMachineGraph.RebuildGraph();
             });
         }
     }
     if (toNode is EntryNode)
     {
         base.graphGUI.stateMachineGraph.rootStateMachine.AddAnyStateTransition(base.graphGUI.activeStateMachine);
     }
 }

 public override void NodeUI(UnityEditor.Graphs.GraphGUI host)
 {
     if (UnityEditor.Graphs.AnimationStateMachine.Node.IsLeftClick())
     {
         host.edgeGUI.EndSlotDragging(Enumerable.First<Slot>(base.inputSlots), true);
     }
 }

 private static void SaveToIndex(UnityEditor.MenuCommand mc, int index) {
   PositionSwapper ps = mc.context as PositionSwapper;
   while (ps.Positions.Length <= index) {
     UnityEditor.ArrayUtility.Add<Vector3>(ref ps.Positions, Vector3.zero);
   }
   ps.Positions[index] = ps.transform.localPosition;
 }

 public static void SetAttribute( UnityEditor.PropertyDrawer drawer, PropertyAttribute attribute )
 {
     FieldInfo fi = TargetType.GetField( "m_Attribute", BindingFlags.NonPublic | BindingFlags.Instance );
     if( fi == null ){
         Debug.Log( "Error, FieldInfo not found" );
         return;
     }
     fi.SetValue( drawer, attribute );
 }

        public override void OnGUI(Rect position, UnityEditor.SerializedProperty property, GUIContent label)
        {
            string fieldName;
            bool notifyPropertyChanged;
            {
                var attr = this.attribute as InspectorDisplayAttribute;
                fieldName = (attr == null) ? "value" : attr.FieldName;
                notifyPropertyChanged = (attr == null) ? true : attr.NotifyPropertyChanged;
            }

            if (notifyPropertyChanged)
            {
                EditorGUI.BeginChangeCheck();
            }
            var targetSerializedProperty = property.FindPropertyRelative(fieldName);
            if (targetSerializedProperty == null)
            {
                UnityEditor.EditorGUI.LabelField(position, label, new GUIContent() { text = "InspectorDisplay can't find target:" + fieldName });
                if (notifyPropertyChanged)
                {
                    EditorGUI.EndChangeCheck();
                }
                return;
            }
            else
            {
                EmitPropertyField(position, targetSerializedProperty, label);
            }

            if (notifyPropertyChanged)
            {
                if (EditorGUI.EndChangeCheck())
                {
                    var propInfo = fieldInfo.FieldType.GetProperty(fieldName, BindingFlags.IgnoreCase | BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

                    property.serializedObject.ApplyModifiedProperties(); // deserialize to field

                    var paths = property.propertyPath.Split('.'); // X.Y.Z...
                    var attachedComponent = property.serializedObject.targetObject;

                    var targetProp = (paths.Length == 1)
                        ? fieldInfo.GetValue(attachedComponent)
                        : GetValueRecursive(attachedComponent, 0, paths);
                    var modifiedValue = propInfo.GetValue(targetProp, null); // retrieve new value

                    var methodInfo = fieldInfo.FieldType.GetMethod("SetValueAndForceNotify", BindingFlags.IgnoreCase | BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                    if (methodInfo != null)
                    {
                        methodInfo.Invoke(targetProp, new object[] { modifiedValue });
                    }
                }
                else
                {
                    property.serializedObject.ApplyModifiedProperties();
                }
            }
        }

		////////////////////////////////////////
		///////////GUI AND EDITOR STUFF/////////
		////////////////////////////////////////
		#if UNITY_EDITOR

		protected override UnityEditor.GenericMenu OnContextMenu(UnityEditor.GenericMenu menu){

			menu.AddItem( new GUIContent("Breakpoint"), isBreakpoint, ()=> { isBreakpoint = !isBreakpoint; } );
			menu.AddItem (new GUIContent ("Convert to SubTree"), false, ()=> { MakeNestedSubTree(this); });
            if (outConnections.Count > 0){
				menu.AddItem (new GUIContent ("Delete Branch"), false, ()=> { DeleteBranch(this); } );
				menu.AddItem(new GUIContent("Duplicate Branch"), false, ()=> { DuplicateBranch(this, graph); });
			}
			return menu;
		}		

 public static Type GetInspectedType( UnityEditor.CustomEditor editor )
 {
     if( m_InspectedType == null )
         m_InspectedType = TargetType.GetField( "m_InspectedType", BindingFlags.NonPublic | BindingFlags.Instance );
     if( m_InspectedType == null ){
         Debug.Log( "FieldInfo Not Found" );
         return null;
     }
     return m_InspectedType.GetValue( editor ) as Type;
 }

    // AnimatorController内のステートを取得する
    private List<UnityEditor.Animations.AnimatorState> FindAnimationClips(
		UnityEditor.Animations.AnimatorController animatorController)
    {
        var stateList = new List<UnityEditor.Animations.AnimatorState> ();
        foreach (var layer in animatorController.layers) {
            foreach (var state in layer.stateMachine.states) {
                stateList.Add (state.state);
            }
        }
        return stateList;
    }

 ////////////////////////////////////////
 ///////////GUI AND EDITOR STUFF/////////
 ////////////////////////////////////////
 protected override UnityEditor.GenericMenu OnContextMenu(UnityEditor.GenericMenu menu)
 {
     menu.AddItem( new GUIContent("Breakpoint"), isBreakpoint, ()=> { isBreakpoint = !isBreakpoint; } );
     menu.AddItem (new GUIContent ("Convert to SubTree"), false, ()=> { MakeNestedSubTree(this); });
     if (outConnections.Count > 0){
         menu.AddItem (new GUIContent ("Delete Branch"), false, ()=> { DeleteBranch(this); } );
         menu.AddItem(new GUIContent("Duplicate Branch"), false, ()=> { DuplicateBranch(this, graph); });
     }
     menu = EditorUtils.GetTypeSelectionMenu(typeof(BTComposite), (t)=>{ ReplaceWith(t); }, menu, "Replace");
     return menu;
 }

 public static void SetSerializedObject( UnityEditor.Editor editor, UnityEditor.SerializedObject obj )
 {
     if( m_SerializedObjectFieldInfo == null )
         m_SerializedObjectFieldInfo = TargetType.GetField( "m_SerializedObject",
                                                            BindingFlags.NonPublic | BindingFlags.Instance );
     if( m_SerializedObjectFieldInfo == null ){
         Debug.Log( "FieldInfo Not Found" );
         return;
     }
     m_SerializedObjectFieldInfo.SetValue( editor, obj );
 }