Unity editor tools

Unity Editor Tools

Editor Scripting Overview

Editor scripts extend the Unity Editor with custom inspectors, windows, tools, and workflows. All editor code must either live in an Editor/ folder or be wrapped in #if UNITY_EDITOR / #endif -- this ensures editor code is stripped from runtime builds.

Unity 6.3 supports two GUI frameworks for editor extensions:

Framework	Status	Entry Point
UI Toolkit	Recommended	CreateInspectorGUI() / CreateGUI() returning VisualElement
IMGUI	Legacy, fully functional	OnInspectorGUI() / OnGUI()

Key base classes: Editor, EditorWindow, PropertyDrawer, DecoratorDrawer, ScriptableWizard.

---

Custom Inspector (Editor)

Derive from Editor, apply [CustomEditor(typeof(TargetType))]. See references/custom-inspectors.md for full guide.

UI Toolkit (Recommended)

[CustomEditor(typeof(MyPlayer))]
public class MyPlayerEditor : Editor
{
    public override VisualElement CreateInspectorGUI()
    {
        VisualElement root = new VisualElement();
        var visualTree = Resources.Load("MyPlayerEditor") as VisualTreeAsset;
        visualTree.CloneTree(root);
        return root;
    }
}

When CreateInspectorGUI() is overridden, OnInspectorGUI() is ignored.

IMGUI with SerializedObject Pattern

[CustomEditor(typeof(LookAtPoint))]
[CanEditMultipleObjects]
public class LookAtPointEditor : Editor
{
    SerializedProperty lookAtPoint;

    void OnEnable() { lookAtPoint = serializedObject.FindProperty("lookAtPoint"); }

    public override void OnInspectorGUI()
    {
        serializedObject.Update();
        EditorGUILayout.PropertyField(lookAtPoint);
        serializedObject.ApplyModifiedProperties();
    }
}

Key Members

Member	Description
target / targets	Inspected object(s)
serializedObject	SerializedObject for the target(s)
DrawDefaultInspector()	Renders built-in default inspector
OnSceneGUI()	Draw interactive Handles in Scene View

Scene View Integration

public void OnSceneGUI()
{
    var t = (LookAtPoint)target;
    EditorGUI.BeginChangeCheck();
    Vector3 pos = Handles.PositionHandle(t.lookAtPoint, Quaternion.identity);
    if (EditorGUI.EndChangeCheck())
    {
        Undo.RecordObject(target, "Move look-at point");
        t.lookAtPoint = pos;
    }
}

---

PropertyDrawer and PropertyAttribute

Customize how serialized fields appear in the Inspector. See references/property-drawers.md for full guide.

1. Define attribute (runtime code, outside Editor folder):

public class MyRangeAttribute : PropertyAttribute
{
    public readonly float min, max;
    public MyRangeAttribute(float min, float max) { this.min = min; this.max = max; }
}

2. Implement drawer (Editor folder):

[CustomPropertyDrawer(typeof(MyRangeAttribute))]
public class MyRangeDrawer : PropertyDrawer
{
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        MyRangeAttribute range = (MyRangeAttribute)attribute;
        if (property.propertyType == SerializedPropertyType.Float)
            EditorGUI.Slider(position, property, range.min, range.max, label);
        else if (property.propertyType == SerializedPropertyType.Integer)
            EditorGUI.IntSlider(position, property, (int)range.min, (int)range.max, label);
    }
}

Critical rules: Must be in Editor/ folder. Use EditorGUI (not EditorGUILayout). Use EditorGUI.BeginProperty()/EndProperty() for prefab overrides. Cannot mix UI Toolkit and IMGUI in one drawer.

---

EditorWindow

Custom dockable editor windows. See references/editor-windows.md for full guide.

Lifecycle: OnEnable -> CreateGUI -> Update -> OnGUI -> OnDisable

public class MyToolWindow : EditorWindow
{
    [MenuItem("Tools/My Tool Window")]
    public static void ShowWindow()
    {
        var window = GetWindow<MyToolWindow>();
        window.titleContent = new GUIContent("My Tool");
        window.minSize = new Vector2(300, 200);
    }

    public void CreateGUI()
    {
        rootVisualElement.Add(new Label("Hello from UI Toolkit!"));
        rootVisualElement.Add(new Button(() => Debug.Log("Clicked!")) { text = "Click Me" });
    }
}

Static Method	Description
GetWindow<T>()	Get existing or create new
CreateWindow<T>()	Always create new instance
HasOpenInstances<T>()	Check if open

Display Mode	Behavior
Show()	Standard dockable
ShowUtility()	Floating, not dockable
ShowModal()	Modal dialog
ShowAsDropDown()	Dropdown popup

---

MenuItem

The [MenuItem] attribute converts static methods into menu commands.

[MenuItem("Menu/Path/Item Name", isValidateFunction, priority)]

Prefix	Placement
"Tools/..."	Custom tools menu
"Assets/..."	Assets menu + Project context menu
"GameObject/..."	GameObject menu + Hierarchy context menu
"CONTEXT/ComponentType/..."	Component context menu

Shortcut modifiers: % = Cmd/Ctrl, # = Shift, & = Alt, ^ = Ctrl (all), _ = no modifier.

// Validation function controls when menu item is enabled
[MenuItem("Tools/Reset Position", true)]
static bool ValidateResetPosition() => Selection.activeTransform != null;

[MenuItem("Tools/Reset Position", false)]
static void ResetPosition()
{
    Undo.RecordObject(Selection.activeTransform, "Reset Position");
    Selection.activeTransform.position = Vector3.zero;
}

GameObject creation (use priority 10):

[MenuItem("GameObject/Custom/My Object", false, 10)]
static void CreateMyObject(MenuCommand menuCommand)
{
    var go = new GameObject("My Object");
    GameObjectUtility.SetParentAndAlign(go, menuCommand.context as GameObject);
    Undo.RegisterCreatedObjectUndo(go, "Create My Object");
    Selection.activeObject = go;
}

---

Gizmos and Handles

Gizmos -- Visual Debugging in Scene/Game View

All drawing inside OnDrawGizmos() (always) or OnDrawGizmosSelected() (when selected):

void OnDrawGizmos()
{
    Gizmos.color = Color.yellow;
    Gizmos.DrawWireSphere(transform.position, radius);
}

void OnDrawGizmosSelected()
{
    Gizmos.color = Color.red;
    Gizmos.DrawSphere(transform.position, radius);
}

Methods: DrawLine, DrawRay, DrawSphere, DrawWireSphere, DrawCube, DrawWireCube, DrawMesh, DrawWireMesh, DrawFrustum, DrawIcon. Properties: color, matrix.

Handles -- Interactive 3D Controls (Editor Only)

Used inside OnSceneGUI() on custom Editors:

[CustomEditor(typeof(CircleLayout))]
public class CircleLayoutEditor : Editor
{
    public void OnSceneGUI()
    {
        var t = (CircleLayout)target;
        Handles.color = new Color(1f, 0.8f, 0.4f, 1f);
        Handles.DrawWireDisc(t.transform.position, t.transform.up, t.radius);
        Handles.Label(t.transform.position, $"Radius: {t.radius:F1}");

        EditorGUI.BeginChangeCheck();
        float newRadius = Handles.RadiusHandle(Quaternion.identity, t.transform.position, t.radius);
        if (EditorGUI.EndChangeCheck())
        {
            Undo.RecordObject(t, "Change Radius");
            t.radius = newRadius;
        }
    }
}

Methods: PositionHandle, RotationHandle, ScaleHandle, FreeMoveHandle, RadiusHandle, DrawLine, DrawWireDisc, Label, BeginGUI/EndGUI. Properties: color, matrix.

---

SerializedObject Pattern

The standard way to edit properties in editor scripts. Provides automatic Undo, multi-object editing, and prefab override tracking.

Three-step pattern:

serializedObject.Update();                                          // 1. Sync from target
EditorGUILayout.PropertyField(serializedObject.FindProperty("myField")); // 2. Draw/modify
serializedObject.ApplyModifiedProperties();                         // 3. Apply with undo

Member	Description
Update()	Refresh from target
ApplyModifiedProperties()	Commit changes with undo
FindProperty(string)	Get SerializedProperty by name
GetIterator()	Iterate all properties
targetObject / targetObjects	Inspected object(s)
hasModifiedProperties	True when unapplied changes exist

For multi-object editing: add [CanEditMultipleObjects] and always use SerializedProperty instead of target.

---

AssetDatabase

Programmatic asset access in editor scripts.

// Create
var data = ScriptableObject.CreateInstance<MyData>();
AssetDatabase.CreateAsset(data, "Assets/Data/MyData.asset");
AssetDatabase.SaveAssets();

// Load
var loaded = AssetDatabase.LoadAssetAtPath<MyData>("Assets/Data/MyData.asset");

// Find by type
string[] guids = AssetDatabase.FindAssets("t:MyData");
foreach (string guid in guids)
{
    string path = AssetDatabase.GUIDToAssetPath(guid);
    var asset = AssetDatabase.LoadAssetAtPath<MyData>(path);
}

// Other operations
AssetDatabase.GetAssetPath(myObject);
AssetDatabase.DeleteAsset("Assets/Data/OldData.asset");
AssetDatabase.Refresh();

Key methods: CreateAsset, LoadAssetAtPath<T>, FindAssets, GetAssetPath, AssetPathToGUID/GUIDToAssetPath, SaveAssets, Refresh, DeleteAsset, CopyAsset, MoveAsset, RenameAsset, ImportAsset.

---

Common Patterns

// Editor-only guard
#if UNITY_EDITOR
using UnityEditor;
// editor code
#endif

// Change detection
EditorGUI.BeginChangeCheck();
// ... controls ...
if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(target, "Change"); }

// ScriptableObject creation menu
[CreateAssetMenu(fileName = "NewConfig", menuName = "Game/Config Data", order = 1)]
public class ConfigData : ScriptableObject { public float moveSpeed = 5f; }

// Default inspector + extras
[CustomEditor(typeof(MyComponent))]
public class MyComponentEditor : Editor
{
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector();
        if (GUILayout.Button("Do Something")) { ((MyComponent)target).DoSomething(); }
    }
}

---

Anti-Patterns

Anti-Pattern	Problem	Fix
Editing target without Undo	No undo, no dirty flag	Use SerializedObject or Undo.RecordObject()
target with [CanEditMultipleObjects]	Only modifies first object	Use SerializedProperty
Editor code outside Editor/ without #if UNITY_EDITOR	Build failures	Use Editor/ folder or preprocessor guard
EditorGUILayout in PropertyDrawer	Not supported	Use EditorGUI with Rect
Missing serializedObject.Update()	Stale data	Always call before reading
Missing ApplyModifiedProperties()	Changes lost	Always call after modifications
Mixing UI Toolkit + IMGUI in one PropertyDrawer	Not supported	Choose one framework
Missing Undo.RegisterCreatedObjectUndo()	Cannot undo creation	Always register new objects
Missing GameObjectUtility.SetParentAndAlign()	Wrong hierarchy parenting	Use in GameObject menu items
Heavy work in OnInspectorGUI()/OnGUI()	Lag (called many times/frame)	Cache in OnEnable()

---

Key API Quick Reference

Editor:        [CustomEditor(typeof(T))], [CanEditMultipleObjects]
               CreateInspectorGUI(), OnInspectorGUI(), OnSceneGUI()
               DrawDefaultInspector(), target, targets, serializedObject

EditorWindow:  GetWindow<T>(), CreateWindow<T>(), CreateGUI(), OnGUI()
               rootVisualElement, titleContent, Show/ShowUtility/ShowModal

PropertyDrawer: [CustomPropertyDrawer(typeof(T))]
               CreatePropertyGUI(), OnGUI(rect,prop,label), GetPropertyHeight()
               attribute, fieldInfo, preferredLabel

SerializedObject: Update(), ApplyModifiedProperties(), FindProperty()
MenuItem:      [MenuItem("Path", validate, priority)], % # & ^ _ shortcuts
Gizmos:        DrawLine/Sphere/WireSphere/Cube/WireCube/Ray/Mesh/Icon, color, matrix
Handles:       PositionHandle/RotationHandle/ScaleHandle/FreeMoveHandle/RadiusHandle
               DrawLine/DrawWireDisc/Label, BeginGUI/EndGUI, color, matrix
AssetDatabase: CreateAsset, LoadAssetAtPath<T>, FindAssets, SaveAssets, Refresh

---

Related Skills

• unity-foundations -- Project structure, assembly definitions, Editor folders
• unity-scripting -- MonoBehaviour lifecycle, SerializeField, ScriptableObject
• unity-ui -- UI Toolkit fundamentals, VisualElement, UXML, USS

---

Additional Resources

• Custom Editor Windows (Manual)
• Custom Editors (Manual)
• Property Drawers (Manual)
• Editor API
• EditorWindow API
• PropertyDrawer API
• AssetDatabase API
• SerializedObject API
• MenuItem API
• Gizmos API
• Handles API