/ui-imgui

name: ui-imgui
description: Generates and modifies Unity IMGUI editor code such as EditorWindows, custom Inspectors, PropertyDrawers, and OnGUI scripts. Use for IMGUI or OnGUI or maintaining existing IMGUI code.

**Before proceeding:** If the user is asking about creating a **new** editor window, custom inspector, or PropertyDrawer without explicitly mentioning IMGUI/OnGUI, recommend using UI Toolkit (CreateGUI) instead, as it's the modern approach. Only proceed with IMGUI if:

• User is modifying existing IMGUI code
• User explicitly requests IMGUI/immediate mode
• The project exclusively uses IMGUI for editor tools

When activated, read the reference files:

• [references/templates.md](references/templates.md) — EditorWindow, Inspector, PropertyDrawer templates
• [references/gui-elements.md](references/gui-elements.md) — GUI elements, layout groups, styling

When to Use This Skill

**IMPORTANT:** This skill is for **legacy IMGUI code only**. Use this skill when:

• User is maintaining/updating **existing** IMGUI editor code (files with `OnGUI()`, `OnInspectorGUI()`)
• User **explicitly requests** IMGUI/immediate mode GUI
• Project exclusively uses IMGUI for all editor tools

**Do NOT use this skill for:**

• New editor windows (use UI Toolkit with `CreateGUI()` instead)
• New custom inspectors (use UI Toolkit instead)
• Requests that don't explicitly mention IMGUI or OnGUI

**Legacy IMGUI is used for:**

• **Editor windows** — `EditorWindow` classes with `OnGUI()`
• **Custom inspectors** — `Editor`, `PropertyDrawer` classes with `OnInspectorGUI()`
• **Debug overlays** — `OnGUI()` in MonoBehaviour (runtime)

IMGUI is **not** for runtime game UI — use UI Toolkit or uGUI instead.

Scope

**Generate only what is requested (for legacy IMGUI code):**

| Request | Output | Note | |---------|--------|------| | Editor window (IMGUI/OnGUI) | `EditorWindow` with `OnGUI()` | Only if explicitly IMGUI | | Custom inspector (IMGUI) | `Editor` with `OnInspectorGUI()` | Only if explicitly IMGUI | | Property drawer (IMGUI) | `PropertyDrawer` with `OnGUI()` | Only if explicitly IMGUI | | Debug overlay | `MonoBehaviour` with `OnGUI()` | Runtime debugging | | Update existing IMGUI script | Modify existing OnGUI code | Always appropriate |

**Clarify if ambiguous:**

• "inspector" → Custom Editor for a specific type, or PropertyDrawer? **Also ask:** Should this use UI Toolkit (modern) or IMGUI (legacy)?
• "editor window" → **First ask:** Should this use UI Toolkit (modern/CreateGUI) or IMGUI (legacy/OnGUI)?
• "tool window" → EditorWindow with what functionality? Which UI system?

Conventions

**Follow project patterns first.** Search existing editor scripts before applying defaults.

| Type | Convention | Good | Bad | |------|------------|------|-----| | Script names | PascalCase | `MyToolWindow.cs` | `my-tool-window.cs` | | EditorWindow | `[Name]Window.cs` | `LevelEditorWindow.cs` | `LevelEditor.cs` | | Custom Editor | `[Type]Editor.cs` | `EnemyEditor.cs` | `EnemyInspector.cs` | | PropertyDrawer | `[Type]Drawer.cs` | `RangeDrawer.cs` | `RangePropertyDrawer.cs` | | Location | `Editor` folder | `Assets/Editor/` | `Assets/Scripts/` |

**Editor folder is required** — Scripts using `UnityEditor` namespace must be in an `Editor` folder or they will fail to build.

Workflow

1. **Analyze** — Determine script type needed (EditorWindow, Editor, PropertyDrawer, etc.) 2. **Search** — Find existing editor scripts to match patterns 3. **Follow project patterns** — Match folder structure and naming 4. **Create script** — Use appropriate base class and attributes 5. **Implement OnGUI** — Build the interface with layout groups

Script Structure

EditorWindow

[MenuItem attribute] → adds to menu
ShowWindow() static method → opens window
OnGUI() → draws interface
OnEnable/OnDisable → initialization/cleanup

Custom Editor

[CustomEditor attribute] → targets component type
OnInspectorGUI() → draws inspector
OnEnable() → cache SerializedProperties
serializedObject.Update/ApplyModifiedProperties → undo support

PropertyDrawer

[CustomPropertyDrawer attribute] → targets type or attribute
OnGUI(Rect, SerializedProperty, GUIContent) → draws property
GetPropertyHeight() → custom height if needed

Key Rules

• **Cache GUIStyle objects** — never create new GUIStyle in OnGUI (causes memory allocation every frame)
• **Use SerializedProperty** — for proper undo/redo support in inspectors
• **Call ApplyModifiedProperties()** — after any serialized object changes
• **Use EditorGUILayout** — for editor scripts (auto-layout)
• **Use GUILayout** — for runtime OnGUI
• **Begin/End pairs** — always match BeginHorizontal with EndHorizontal, etc.
• **Editor folder required** — scripts fail to build if not in Editor folder

Layout Basics

**Horizontal grouping:**

EditorGUILayout.BeginHorizontal();
// elements appear side by side
EditorGUILayout.EndHorizontal();

**Vertical grouping:**

EditorGUILayout.BeginVertical("box");
// elements appear stacked, with box style
EditorGUILayout.EndVertical();

**Scroll view:**

scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
// scrollable content
EditorGUILayout.EndScrollView();

**Foldout section:**

showSection = EditorGUILayout.Foldout(showSection, "Section Name");
if (showSection)
{
    EditorGUI.indentLevel++;
    // section content
    EditorGUI.indentLevel--;
}

Common Patterns

**Button with action:**

if (GUILayout.Button("Do Something"))
{
    // action here
}

**Property field with label:**

EditorGUILayout.PropertyField(myProperty, new GUIContent("Label"));

**Object reference field:**

myObject = (MyType)EditorGUILayout.ObjectField("Label", myObject, typeof(MyType), true);

**Disabled group:**

EditorGUI.BeginDisabledGroup(condition);
// disabled elements
EditorGUI.EndDisabledGroup();

Best Practices

• Use `SerializedObject`