Unity编辑器拓展：深入理解EditorGUI与EditorGUILayout的核心差异与应用场景

1. 项目概述：为什么你需要深入理解EditorGUI

如果你在Unity里做过编辑器工具，或者想定制自己的Inspector面板，那你肯定绕不开 EditorGUI 和 EditorGUILayout 这两个类。很多刚开始接触编辑器拓展的朋友，包括几年前的我自己，都容易在这里犯迷糊：它们俩到底有什么区别？什么时候该用哪个？为什么我的控件画出来位置不对，或者根本不响应？

网上能找到的教程，要么是官方文档的简单翻译，罗列一堆API但不说为什么；要么就是某个特定功能的片段代码，缺乏系统性的梳理。结果就是，你跟着抄能做出一个功能，但一旦需求变了，或者想做得更复杂些，就不知道从何下手了。这就像只给了你一堆乐高积木，却没给你说明书，更没告诉你不同形状的积木（ EditorGUI 和 EditorGUILayout ）分别适合搭建结构的哪个部分。

这篇文章的目的，就是给你这份“说明书”。我不会仅仅重复API列表，而是会深入拆解 EditorGUI 这个类的设计哲学、核心机制，以及它和 EditorGUILayout 的本质区别。更重要的是，我会结合大量实际项目中的使用场景和踩过的坑，告诉你如何根据不同的需求，灵活、高效地使用这些控件。无论是制作一个复杂的角色装备编辑器，还是一个简单的数据配置工具，理解 EditorGUI 都是你构建稳定、易用编辑器界面的基石。无论你是刚入门编辑器拓展的开发者，还是已经用过但想体系化掌握的老手，这篇文章都能帮你把这块知识彻底理清。

2. 核心基石：Rect布局系统与即时模式GUI

要理解 EditorGUI ，必须先理解Unity编辑器GUI（以及更早的Unity旧版UI系统）所采用的 即时模式GUI 范式。这与我们常见的Web或客户端应用使用的 保留模式GUI 有根本性不同。

在保留模式GUI（如WPF、WinForms、HTML DOM）中，你声明一个按钮对象，设置它的属性（如文本、位置），然后将这个对象添加到某个容器中。系统会负责管理这个按钮对象的生命周期、渲染和事件。你通常通过事件委托（如 onClick ）来响应交互。

而即时模式GUI则完全不同。它没有持久的控件对象。每一帧，在你的 OnGUI 方法中，你都需要 重新声明并绘制 所有控件。你调用 GUI.Button(rect, “Click Me”) ，这个方法会做两件事：1. 根据当前帧的状态，在给定的 Rect 区域内绘制一个按钮；2. 返回一个布尔值，告诉你 在这一帧 这个按钮是否被点击了。绘制和交互判断是同时发生的，并且结果只在这一帧有效。下一帧，你需要再次调用这个方法来“重建”按钮并获取新的交互状态。

EditorGUI 和 GUI 类都是这种模式的体现。 EditorGUI 是专门为Unity编辑器环境定制和增强的版本。这种模式带来了一个核心概念： 手动布局 。你必须为每一个控件指定一个 Rect （矩形）来定义它的屏幕位置和大小。这就是 EditorGUI 类中几乎所有绘制方法的第一个参数都是 Rect position 的原因。

// 这是一个典型的EditorGUI调用
EditorGUI.LabelField(new Rect(10, 10, 100, 20), “Name:”);
string name = EditorGUI.TextField(new Rect(120, 10, 200, 20), currentName);

为什么Unity要采用这种看似“原始”的模式？ 对于工具开发而言，即时模式GUI有其独特的优势：

1. 状态管理简单 ：你的工具状态（数据）完全由你自己的C#类管理，GUI只是状态的“视图”。没有需要同步的控件对象状态，减少了复杂度。
2. 动态界面灵活 ：界面结构可以根据数据或条件随时变化，无需预先创建或销毁控件对象，代码表达非常直接。
3. 性能可控 ：虽然每帧都重绘，但对于不复杂的编辑器窗口，开销是可接受的。你可以通过条件逻辑轻松控制哪些部分需要重绘。
4. 与Unity编辑器深度集成 ： EditorGUI 的样式、皮肤、行为与Unity原生编辑器完全一致，保证了工具的专业性和一致性。

核心要点与踩坑点 ：

• Rect 的计算是基本功 ：你需要手动计算每个控件的位置和大小。这包括处理间距、对齐、以及控件组之间的相对位置。一开始可能会觉得繁琐，但这是精确控制布局的必经之路。
• position 参数是绘制区域 ：这个 Rect 定义的是控件 被绘制和接收输入 的区域。如果 Rect 计算错误，控件可能显示不全，或者点击无效。
• 状态存储在你自己变量里 ： EditorGUI.TextField 的返回值就是当前输入框的内容，你必须用一个变量接住它，并在下一帧将这个变量作为参数传回去，才能实现数据的持久化。这就是即时模式的数据流。

注意 ：很多新手会忘记保存 EditorGUI 控件的返回值，导致输入无法被记录。记住，在即时模式GUI中，控件的“值”不是存储在控件里，而是通过“参数传入，返回值传出”的方式，由你自己的代码来维护的。

3. EditorGUI vs. EditorGUILayout：根本区别与选用策略

这是最核心的困惑点。简单来说：

• EditorGUI ：你需要提供 Rect 。你拥有对控件位置和尺寸的 绝对控制权 。
• EditorGUILayout ：你 不需要 提供 Rect 。它会根据上下文（前后控件）自动为你计算位置，实现 自动布局 。

EditorGUILayout 可以看作是在 EditorGUI 之上构建的一层“语法糖”或布局管理器。它帮你处理了繁琐的 Rect 计算，让你可以用更声明式的方式描述界面。

// 使用EditorGUILayout的等效代码
EditorGUILayout.BeginHorizontal(); // 开始一个水平布局组
EditorGUILayout.LabelField(“Name:”, GUILayout.Width(100)); // GUILayout.Width用于指定首选宽度
string name = EditorGUILayout.TextField(currentName);
EditorGUILayout.EndHorizontal(); // 结束水平布局组

那么，到底该用哪个？ 这取决于你的具体场景：

优先使用 EditorGUILayout 的情况：

1. 快速原型 ：当你需要快速验证一个想法或搭建简单工具界面时， EditorGUILayout 能极大提升开发效率。
2. 列表或动态内容 ：当需要绘制数量不定的项时（如数组列表），使用 EditorGUILayout 可以避免复杂的 Rect 累加计算，代码更简洁。
3. 对绝对位置无要求 ：当控件只需要按顺序排列，不需要精确对齐到某个像素时。

必须使用 EditorGUI 的情况：

1. 自定义渲染或交互区域 ：当你需要在一个特定的矩形区域内进行非标准的绘制（如自定义的网格、曲线图、缩略图区域）时，你必须使用 EditorGUI ，因为你需要精确控制绘制区域。
2. 性能关键路径 ：在 OnInspectorGUI 或自定义窗口的 OnGUI 中，如果控件数量极多（如一个包含上千项的可滚动列表）， EditorGUILayout 的自动布局计算可能会成为性能瓶颈。此时，手动计算 Rect 并使用 EditorGUI 进行绘制，可以避免这部分开销。你可以使用 GUILayoutUtility.GetRect 来预计算 Rect ，但直接使用 EditorGUI 进行循环绘制通常是更高效的做法。
3. 复杂混合布局 ：当界面中既有自动布局部分，又有需要精确定位的部分时。例如，一个工具窗口的侧边栏用 EditorGUILayout ，主工作区是一个用 EditorGUI 绘制的自定义画布。
4. 需要复用Rect ：有时你需要多次在同一区域绘制不同内容（如先画背景，再画前景文字），或者根据条件在同一位置绘制不同的控件，这时持有一个 Rect 变量就非常方便。

实操心得 ： 在我的项目中，我通常采用 混合策略 。对于标准的表单、设置面板，我大量使用 EditorGUILayout ，因为它写起来快，修改布局也容易。但对于任何 自定义的、可视化的编辑区域 （如地形笔刷区域、动画时间轴、节点编辑器画布），我会毫不犹豫地使用 EditorGUI ，并手动管理 Rect 。这样既能享受自动布局的便利，又能保有对关键区域的完全控制。

一个常见的误区是认为 EditorGUI 更“低级”所以应该少用。实际上，它们是服务于不同目标的工具。理解其差异，就能在合适的场景选择合适的方法。

4. 核心控件库深度解析与实战应用

EditorGUI 提供了丰富的控件方法，用于绘制各种类型的编辑器字段。下面我们分类解析最常用和最容易出问题的控件。

4.1 基础字段控件：文本、数字与开关

这些是构建界面的砖瓦。

TextField / PasswordField / TextArea

Rect textFieldRect = new Rect(10, 30, 200, 20);
string inputText = EditorGUI.TextField(textFieldRect, “Input:”, currentText);

• TextField ：单行文本输入。注意， Rect 的高度通常为 EditorGUIUtility.singleLineHeight （约20像素），但你可以设置得更高，不过外观可能不标准。
• TextArea ：多行文本输入。你需要提供一个足够高的 Rect 。它没有像 EditorGUILayout.TextArea 那样自动扩展高度的能力，高度是固定的。
• 踩坑点 ：处理文本变化。如果你需要在文本每次改变时（而不仅仅是失去焦点时）就触发逻辑，可以比较 inputText 和之前保存的 currentText 。但更常见的做法是将逻辑放在更方便的地方（如一个“应用”按钮上），以避免每帧都进行可能昂贵的操作。

IntField / FloatField / Slider

int intValue = EditorGUI.IntField(rect, “Health:”, currentHealth);
float floatValue = EditorGUI.FloatField(rect, “Speed:”, currentSpeed);
float sliderValue = EditorGUI.Slider(rect, “Intensity:”, currentIntensity, 0f, 1f);

• IntField / FloatField ：除了直接输入，还支持鼠标拖拽调整数值。这是Unity编辑器的标准行为。
• Slider ：滑动条。注意它的 Rect 宽度决定了滑动条的长度。对于水平滑动条， Rect 的高度通常是一行高，宽度则根据你需要多长的滑动条来定。
• 实操技巧 ：对于需要频繁调整的数值参数， Slider 比直接输入 FloatField 体验更好。你可以结合使用：一个 Slider 用于快速调整，旁边再放一个 FloatField 用于精确输入。

Toggle / ToggleLeft

bool isActive = EditorGUI.Toggle(rect, “Is Active”, currentActive);
// ToggleLeft 将标签显示在开关左侧
bool isVisible = EditorGUI.ToggleLeft(rect, “Visible”, currentVisible);

• 区别 ： Toggle 绘制一个开关，标签在右侧。 ToggleLeft 标签在左侧。根据界面设计规范选择即可。
• 注意 ： Toggle 的 Rect 宽度需要足够容纳开关和标签文本。如果宽度不足，标签可能被裁剪。

4.2 选择与枚举控件：下拉菜单与单选按钮

Popup / EnumPopup

// 假设有一个字符串数组 options
int selectedIndex = EditorGUI.Popup(rect, “Option:”, currentIndex, options);
// 对于枚举，使用EnumPopup更便捷
MyEnum enumValue = (MyEnum)EditorGUI.EnumPopup(rect, “My Enum:”, currentEnumValue);

• Popup ：经典的下拉选择框。你需要自己管理选项数组和当前选中索引。
• EnumPopup ：专为枚举类型设计，自动获取枚举的所有值作为选项，非常方便。
• 常见问题 ：当枚举值很多时，下拉列表会很长。可以考虑使用 MaskField （对于 [Flags] 枚举）或者用其他交互方式（如单选按钮组）替代。

RadioButton

// 绘制一组单选按钮
Rect radioRect = new Rect(10, 60, 200, 20);
for (int i = 0; i < options.Length; i++)
{
    bool isSelected = (i == selectedIndex);
    // 每个按钮的Rect需要错开Y轴位置
    Rect btnRect = new Rect(radioRect.x, radioRect.y + i * 25, radioRect.width, 20);
    if (EditorGUI.RadioButton(btnRect, isSelected, options[i]))
    {
        selectedIndex = i; // 如果这个按钮被点击，更新选中索引
    }
}

• 注意 ： RadioButton 方法本身只负责绘制一个按钮并返回它 是否被按下 。 单选 的逻辑（即确保只有一个被选中）需要你自己用代码实现，如上例所示。这与 Toggle 不同。

4.3 对象与颜色选择：ObjectField与ColorField

ObjectField

GameObject assignedPrefab = (GameObject)EditorGUI.ObjectField(
    rect,
    “Prefab:”,
    currentPrefab,
    typeof(GameObject),
    false // allowSceneObjects: 是否允许选择场景中的对象
);

• 核心参数 ：
  • Object obj ：当前已分配的对象。
  • Type objType ：允许分配的对象类型（如 typeof(GameObject) , typeof(Material) ）。
  • bool allowSceneObjects ：如果为 true ，可以从场景或项目中选择对象；如果为 false ，只能从项目资产（Project视图）中选择。对于Prefab或资源引用，通常设为 false 。
• 踩过大坑 ： allowSceneObjects 参数至关重要。如果你设计的是一个资源配置工具，期望引用的是一个Prefab资源，但错误地将其设为 true ，用户就可能误选场景中的实例对象，导致资源引用错误或序列化问题。务必根据上下文明确设置。

ColorField / ColorFieldHDR

Color diffuseColor = EditorGUI.ColorField(rect, “Diffuse Color”, currentColor);
// 对于HDR颜色（高动态范围，常用于发光材质）
Color hdrEmissionColor = EditorGUI.ColorField(rect, new GUIContent(“Emission Color”), currentHdrColor, true, true, true);
// 后三个bool参数分别代表：showAlpha, hdr, showEyeDropper

• ColorField ：标准的颜色选择器。
• ColorFieldHDR ：用于选择HDR颜色，颜色分量可以超过1.0。在绘制自发光材质、后期处理效果参数时常用。
• 实操技巧 ：对于非图形专业的策划或美术，纯色块可能不够直观。有时我会在 ColorField 旁边额外绘制一个用该颜色填充的小图标或预览图，以提供更直观的反馈。

4.4 特殊与复合控件：层级、标签与曲线

LayerField / TagField

int selectedLayer = EditorGUI.LayerField(rect, “Layer:”, currentLayer);
string selectedTag = EditorGUI.TagField(rect, “Tag:”, currentTag);

• 这两个控件封装了Unity的层和标签系统，直接生成下拉菜单，比手动创建 Popup 方便得多。

CurveField

AnimationCurve movementCurve = EditorGUI.CurveField(rect, “Movement Curve”, currentCurve);

• 用于编辑 AnimationCurve 。这对于需要随时间变化的值（如缓动动画、难度曲线）非常有用。 Rect 需要有一定的高度和宽度，以提供良好的编辑体验。

PrefixLabel 与混合布局 这是 EditorGUI 中一个非常有用但常被忽视的功能。当你手动布局时，如何像 EditorGUILayout 那样，让标签和字段自动对齐？

Rect totalRect = new Rect(10, 10, 300, 20); // 整个控件的区域
Rect labelRect = new Rect(totalRect.x, totalRect.y, EditorGUIUtility.labelWidth, totalRect.height);
Rect fieldRect = new Rect(totalRect.x + EditorGUIUtility.labelWidth, totalRect.y, totalRect.width - EditorGUIUtility.labelWidth, totalRect.height);

EditorGUI.PrefixLabel(labelRect, new GUIContent(“Player Name:”));
string name = EditorGUI.TextField(fieldRect, currentName);

• EditorGUIUtility.labelWidth 是编辑器当前设置的标签宽度，使用它能保证你的自定义控件与Unity原生Inspector的标签对齐。
• PrefixLabel 方法会绘制一个标签，并处理好与后续字段的键盘导航焦点关系。虽然在上面的例子中我们手动计算了 labelRect 和 fieldRect ，但 PrefixLabel 的真正威力在于，它可以返回一个调整后的 Rect ，这个 Rect 就是留给后续字段的区域：

  Rect fieldRectAfterLabel = EditorGUI.PrefixLabel(totalRect, new GUIContent(“Player Name:”));
  string name = EditorGUI.TextField(fieldRectAfterLabel, currentName);
  

  这样，你只需要关心一个总 Rect ， PrefixLabel 会帮你处理好标签的绘制和剩余空间的分配。

5. 高级应用：自定义控件、重绘与性能优化

掌握了基础控件后，你可以开始构建更复杂的编辑器界面。

5.1 封装自定义控件方法

当某个控件组合（如“一个标签+一个滑块+一个数值输入框”）在工具中反复出现时，就应该将其封装成一个静态方法。

public static float SliderWithFloatField(Rect position, string label, float value, float min, float max)
{
    float labelWidth = 60;
    float sliderWidth = position.width - labelWidth - 70; // 给输入框留70像素
    float fieldWidth = 50;

    Rect labelRect = new Rect(position.x, position.y, labelWidth, position.height);
    Rect sliderRect = new Rect(position.x + labelWidth, position.y, sliderWidth, position.height);
    Rect fieldRect = new Rect(position.x + labelWidth + sliderWidth + 5, position.y, fieldWidth, position.height);

    EditorGUI.LabelField(labelRect, label);
    value = EditorGUI.Slider(sliderRect, value, min, max);
    value = EditorGUI.FloatField(fieldRect, value);
    // 可选：将输入框的值钳制在[min, max]范围内
    value = Mathf.Clamp(value, min, max);
    return value;
}

这样，在你的 OnGUI 中，只需要一行代码就能绘制这个复合控件，大大提升了代码的可读性和可维护性。

5.2 处理控件焦点与键盘事件

在即时模式GUI中，管理焦点很重要。 GUIUtility.keyboardControl 代表了当前拥有键盘焦点的控件ID。

int nameFieldID = GUIUtility.GetControlID(FocusType.Keyboard); // 获取一个唯一控件ID
Rect nameFieldRect = ...;
GUI.SetNextControlName(“PlayerNameField”); // 给控件命名（另一种方式）
string name = EditorGUI.TextField(nameFieldRect, currentName);

// 检查特定控件是否拥有焦点
if (GUIUtility.keyboardControl == nameFieldID)
{
    // 处理回车键确认
    if (Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Return)
    {
        // 执行确认逻辑
        Event.current.Use(); // 标记事件已处理
    }
}

• GUI.FocusControl(“controlName”) ：可以将焦点设置到指定名称的控件。
• EditorGUI.FocusTextInControl(“controlName”) ：专门用于将焦点设置到文本输入框并选中所有文本。
• 实操心得 ：在自定义Inspector中，当用户点击一个数组元素的删除按钮时，我经常需要将焦点移开，否则后续的键盘操作可能会作用在已经不存在的控件上，导致错误。这时我会在删除操作后调用 GUIUtility.keyboardControl = 0; 来清除焦点。

5.3 性能优化：脏矩形与条件重绘

虽然编辑器工具对性能不似游戏运行时那般苛刻，但复杂的工具窗口也可能因为重绘过多而卡顿。

• 脏矩形 ：这是一个图形学概念，指只重绘屏幕上发生变化的部分。在Unity编辑器GUI中，我们没有直接控制权，但可以通过逻辑来模拟。
• 条件重绘 ：只在必要时才执行昂贵的绘制操作。

  public override void OnInspectorGUI()
  {
      // ... 绘制其他简单控件 ...
      
      // 假设有一个昂贵的预览图生成
      if (needToUpdatePreview || previewTexture == null)
      {
          previewTexture = GenerateExpensivePreview();
          needToUpdatePreview = false;
      }
      
      // 只绘制纹理，而不是每帧都生成
      if (previewTexture != null)
      {
          Rect previewRect = GUILayoutUtility.GetRect(300, 200);
          EditorGUI.DrawPreviewTexture(previewRect, previewTexture);
      }
      
      // 提供一个按钮让用户手动更新预览
      if (GUILayout.Button(“Update Preview”))
      {
          needToUpdatePreview = true;
          Repaint(); // 请求重绘Inspector
      }
  }
  

• Repaint() ：当你修改了数据并需要界面立即更新时，调用 this.Repaint() （在 EditorWindow 中）或 serializedObject.Update() / serializedObject.ApplyModifiedProperties() 后，Inspector通常会自己重绘。但在自定义逻辑中，明确调用 Repaint() 是确保界面响应的好习惯。
• 避免在OnGUI中做昂贵计算 ： OnGUI 每帧可能调用多次。任何复杂的计算、资源加载、网络请求都不应该直接放在 OnGUI 中。应该将结果缓存起来，只在数据变化时更新。

6. 实战案例：构建一个角色属性编辑器

让我们通过一个完整的例子，将上面的知识串联起来。假设我们要为一个简单的RPG游戏制作一个角色属性编辑器窗口。

目标 ：一个窗口，可以编辑角色基础属性（生命、攻击、防御），一个技能列表（动态增减），以及一个角色头像选择。

步骤1：创建EditorWindow

using UnityEditor;
using UnityEngine;

public class CharacterEditorWindow : EditorWindow
{
    private string characterName = “New Hero”;
    private int health = 100;
    private int attack = 10;
    private int defense = 5;
    private List<string> skills = new List<string>() { “Slash”, “Block” };
    private Texture2D avatar;

    [MenuItem(“Tools/Character Editor”)]
    public static void ShowWindow()
    {
        GetWindow<CharacterEditorWindow>(“Character Editor”);
    }
}

步骤2：实现OnGUI与手动布局 我们将使用 EditorGUI 进行手动布局，以获得更精确的控制。

private Vector2 scrollPosition;
private const float lineHeight = 20;
private const float verticalSpacing = 5;

void OnGUI()
{
    // 开始一个滚动视图，以容纳可能很长的技能列表
    scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
    {
        float currentY = 10;
        float labelWidth = 80;
        float fieldWidth = position.width - labelWidth - 20; // 留出边距

        // 1. 角色名称
        Rect nameLabelRect = new Rect(10, currentY, labelWidth, lineHeight);
        Rect nameFieldRect = new Rect(10 + labelWidth, currentY, fieldWidth, lineHeight);
        EditorGUI.LabelField(nameLabelRect, “Character Name:”);
        characterName = EditorGUI.TextField(nameFieldRect, characterName);
        currentY += lineHeight + verticalSpacing;

        // 2. 基础属性（使用自定义的复合控件方法）
        Rect attrRect = new Rect(10, currentY, position.width - 20, lineHeight);
        health = DrawAttributeField(attrRect, “Health:”, health, 1, 999);
        currentY += lineHeight + verticalSpacing;
        attrRect.y = currentY;
        attack = DrawAttributeField(attrRect, “Attack:”, attack, 1, 99);
        currentY += lineHeight + verticalSpacing;
        attrRect.y = currentY;
        defense = DrawAttributeField(attrRect, “Defense:”, defense, 0, 99);
        currentY += lineHeight + verticalSpacing * 2; // 多加一些间距

        // 3. 头像选择 (ObjectField)
        Rect avatarLabelRect = new Rect(10, currentY, labelWidth, lineHeight);
        Rect avatarFieldRect = new Rect(10 + labelWidth, currentY, fieldWidth, lineHeight);
        EditorGUI.LabelField(avatarLabelRect, “Avatar:”);
        avatar = (Texture2D)EditorGUI.ObjectField(avatarFieldRect, avatar, typeof(Texture2D), false);
        currentY += lineHeight + verticalSpacing;
        // 显示头像预览
        if (avatar != null)
        {
            Rect previewRect = new Rect(10 + labelWidth, currentY, 64, 64);
            EditorGUI.DrawPreviewTexture(previewRect, avatar);
            currentY += 64 + verticalSpacing;
        }

        // 4. 技能列表（动态列表，混合使用EditorGUI和EditorGUILayout思想）
        EditorGUI.LabelField(new Rect(10, currentY, 200, lineHeight), “Skills:”, EditorStyles.boldLabel);
        currentY += lineHeight;
        
        for (int i = 0; i < skills.Count; i++)
        {
            Rect skillFieldRect = new Rect(30, currentY, fieldWidth - 60, lineHeight); // 缩进
            Rect deleteButtonRect = new Rect(30 + fieldWidth - 60, currentY, 50, lineHeight);
            
            skills[i] = EditorGUI.TextField(skillFieldRect, skills[i]);
            if (GUI.Button(deleteButtonRect, “Delete”))
            {
                skills.RemoveAt(i);
                // 删除后需要立即跳出循环，因为列表已变，避免索引错误
                // 并且请求重绘
                Repaint();
                break;
            }
            currentY += lineHeight + verticalSpacing;
        }
        
        // 添加技能按钮
        Rect addButtonRect = new Rect(30, currentY, 80, lineHeight);
        if (GUI.Button(addButtonRect, “Add Skill”))
        {
            skills.Add(“New Skill”);
        }
        currentY += lineHeight + verticalSpacing;
    }
    EditorGUILayout.EndScrollView();

    // 5. 保存按钮（固定在底部）
    Rect saveButtonRect = new Rect(position.width / 2 - 50, position.height - 40, 100, 30);
    if (GUI.Button(saveButtonRect, “Save Character”))
    {
        SaveCharacterData();
    }
}

// 辅助方法：绘制一个带滑动条和数字输入框的属性字段
private int DrawAttributeField(Rect totalRect, string label, int value, int min, int max)
{
    float labelWidth = 60;
    float sliderWidth = totalRect.width - labelWidth - 70;
    float fieldWidth = 50;

    Rect labelRect = new Rect(totalRect.x, totalRect.y, labelWidth, totalRect.height);
    Rect sliderRect = new Rect(totalRect.x + labelWidth, totalRect.y, sliderWidth, totalRect.height);
    Rect fieldRect = new Rect(totalRect.x + labelWidth + sliderWidth + 5, totalRect.y, fieldWidth, totalRect.height);

    EditorGUI.LabelField(labelRect, label);
    value = (int)EditorGUI.Slider(sliderRect, value, min, max);
    value = EditorGUI.IntField(fieldRect, value);
    value = Mathf.Clamp(value, min, max);
    return value;
}

private void SaveCharacterData()
{
    // 这里实现保存逻辑，例如创建ScriptableObject或保存为JSON
    Debug.Log($“Saving Character: {characterName}, H:{health}, A:{attack}, D:{defense}”);
}

案例解析与技巧 ：

1. 混合布局 ：我们以手动计算 Rect 为主（ EditorGUI ），但在技能列表的循环中，我们通过累加 currentY 来动态确定下一行的位置，这模仿了自动布局的思想。
2. 滚动视图 ：通过 EditorGUILayout.BeginScrollView 管理滚动，但内部使用 EditorGUI 进行绝对定位。注意，在滚动视图内使用绝对坐标时， Rect 的y坐标是相对于滚动视图内容的起始位置，而不是窗口顶部。我们的 currentY 就是从0开始累加的。
3. 动态列表的删除 ：在循环中删除列表项时，必须立即 break 跳出循环，因为列表长度已经改变，继续循环会导致索引越界。随后调用 Repaint() 立即刷新界面。
4. 固定位置元素 ：保存按钮的y坐标基于 position.height （窗口高度），使其始终固定在底部，不随滚动视图内容移动。
5. 封装与复用 ： DrawAttributeField 方法封装了标签、滑动条、输入框的绘制逻辑，使 OnGUI 主方法更清晰。

7. 常见问题排查与调试技巧

即使理解了原理，在实际开发中仍会遇到各种奇怪的问题。下面是一些常见问题的排查清单。

问题1：控件不显示或显示不全

• 检查 Rect ：确保 Rect 的 x , y , width , height 值都是合理的正数，并且 width 和 height 不能为0或负数。
• 检查绘制顺序 ：后绘制的控件会覆盖先绘制的控件。如果两个 Rect 重叠，后面的会盖住前面的。
• 检查是否在可视区域 ：如果控件在滚动视图内，确保它的 y 坐标在滚动视图的当前显示范围内。可以通过 GUIUtility.GUIToScreenPoint 或打印 Rect 值来调试位置。

问题2：控件不响应点击/输入

• Rect 区域是否正确 ：点击检测是基于 Rect 的。确保 Rect 包含了控件的所有可视部分（包括标签）。
• 事件被拦截 ：检查在控件之前或之后是否有其他全屏的、透明的控件（例如一个没有背景的 GUI.Window 或 GUI.Group ）拦截了事件。 Event.current.type 和 Event.current.Use() 可以帮助调试。
• 焦点冲突 ：如果多个输入框同时尝试获取焦点，可能会有奇怪的行为。确保你的焦点管理逻辑清晰。

问题3：输入的数据不保存

• 牢记即时模式 ：你必须将 EditorGUI 方法的返回值赋值回你的成员变量。例如 myString = EditorGUI.TextField(rect, myString); 。忘记赋值是最常见的错误。
• 检查作用域 ：确保你修改的是类的成员变量，而不是局部变量。

问题4：界面闪烁或性能差

• 避免在OnGUI中创建资源 ：不要在 OnGUI 中 new Rect(...) 、 new GUIContent(...) 或创建任何 Texture 、 Material 。应该在 OnEnable 中初始化，或缓存起来。
• 条件绘制 ：对于复杂的预览图、网格绘制等，只在数据变化时更新，而不是每帧都重新生成。
• 使用 Repaint wisely ：不要每帧都调用 Repaint() 。只在数据确实发生变化、需要界面更新时才调用。

调试技巧 ：

• 打印信息 ：在 OnGUI 中使用 Debug.Log 或 EditorGUILayout.LabelField 输出关键的 Rect 值、变量状态、事件类型等。
• 绘制调试框 ：在不确定 Rect 位置时，可以用 EditorGUI.DrawRect(rect, new Color(1,0,0,0.2f)); 绘制一个半透明的红色框来可视化 Rect 区域。
• 使用 EditorGUIUtility.editingTextField ：这个静态属性可以告诉你用户是否正在编辑任何文本输入框。在需要根据编辑状态改变行为时很有用。

掌握 EditorGUI 是一个从“能用”到“精通”Unity编辑器拓展的关键跨越。它要求你从更高的维度去思考界面的构成与交互。开始时，手动计算 Rect 可能会让你感到束缚，但一旦熟练，你会发现它带来的布局精确性和性能可控性是无可替代的。结合 EditorGUILayout 的便捷性，你就能根据工具的不同部分，灵活选择最合适的武器，打造出既专业又高效的自定义编辑器。