Unity编辑器自动化实战：8个高频场景提升开发效率

1. 项目概述：为什么我们需要Unity Editor自动化？

如果你是一个Unity开发者，每天花在编辑器里的时间可能比写游戏逻辑本身还要多。我说的不是写代码，而是那些重复、琐碎、但又不得不做的“体力活”：批量重命名几百个资源、为一批Prefab添加相同的组件、检查场景中所有Light的强度设置是否一致、或者把某个文件夹下的所有材质球批量更换Shader。这些操作，手动点一次两次还行，但项目规模一大，动辄成百上千个对象，点鼠标点到手抽筋不说，还极易出错。

这就是ExecuteCode，或者说Unity Editor脚本化自动化的用武之地。它不是一个具体的API，而是一种思路和能力的统称——通过编写C#脚本，在Unity编辑器环境下（而非运行时）执行自定义逻辑，来替代人工的重复操作。很多人觉得写编辑器工具门槛高，是TA（技术美术）或工具程序员的专属。但我想告诉你的是，很多实用的自动化场景，核心代码可能连30行都不到。你需要的不是多高深的框架知识，而是转变一下思维：把一次手动操作，翻译成一段顺序执行的C#代码。

这篇手册的目的，就是打破这个心理门槛。我将带你实战8个高频出现的Unity Editor自动化场景，每个场景的核心逻辑都控制在30行C#代码以内。你会发现，利用UnityEditor命名空间下的EditorWindow、MenuItem、EditorUtility、Selection、AssetDatabase等类，你能瞬间将工作效率提升数倍。自动化不是为了炫技，而是为了把时间省下来，去解决真正有创造性的问题。

2. 核心思路与工具选型解析

在动手之前，我们先统一思想。Unity Editor自动化脚本，本质上是一种“批处理”或“宏”操作。它的执行环境是编辑器（Edit Mode），核心是遍历、判断、修改。

2.1 核心工具链：你只需要这几个类

对于大多数轻量级自动化任务，下面这几个UnityEditor命名空间下的类是绝对的主力，务必熟悉：

• Selection类：获取当前在Hierarchy或Project窗口选中的对象（GameObject）或资源（UnityEngine.Object）。这是你操作的起点。Selection.gameObjects、Selection.objects、Selection.activeObject是常用属性。
• AssetDatabase类：资源数据库的入口。用于查找、加载、创建、删除、移动、重命名项目中的资源（Prefab、材质、脚本等）。AssetDatabase.FindAssets、AssetDatabase.LoadAssetAtPath、AssetDatabase.RenameAsset等方法使用频率极高。
• EditorUtility类：一个工具百宝箱。包含显示对话框（DisplayDialog）、设置对象脏标记（SetDirty）、聚焦Project窗口（FocusProjectWindow）等实用静态方法。其中的DisplayProgressBar和ClearProgressBar在批量操作时给用户反馈至关重要。
• SerializedObject与SerializedProperty类：当你需要以编程方式、且符合Unity序列化规则来修改组件的属性时，这两个类是黄金搭档。它们能正确处理预制件覆盖、撤销操作，并且是访问私有序列化字段的推荐方式。
• MenuItem属性：这是将你的脚本函数挂载到Unity编辑器菜单栏的关键。例如[MenuItem(“Tools/MyTool”)]会在顶部菜单栏的“Tools”下创建一个“MyTool”的点击项。

注意：所有编辑器脚本都必须放在项目内名为Editor的文件夹（或其子文件夹）下。Unity会特殊处理这些文件夹下的脚本，它们只在编辑器中编译和执行，不会被打进游戏运行时包体。

2.2 代码结构模板：一个通用的起点

几乎所有的工具脚本都遵循一个类似的模式。下面是一个你可以复制粘贴的模板：

using UnityEditor; using UnityEngine; using System.IO; // 常用于文件操作 using System.Linq; // LINQ让集合操作更简洁 public class YourEditorTool { // 1. 定义一个菜单项 [MenuItem(“Tools/Your Tool Name”)] static void ExecuteYourTool() { // 2. 安全检查（可选，但推荐） if (!Selection.activeGameObject) { EditorUtility.DisplayDialog(“提示”, “请先在场景中选择一个GameObject”, “OK”); return; } // 3. 记录操作以支持撤销（重要！） Undo.RecordObjects(/* 要记录的对象数组 */, “Your Tool Action”); // 4. 核心逻辑：遍历、判断、修改 foreach (var go in Selection.gameObjects) { // 在这里写你的处理逻辑 // Debug.Log($“Processing: {go.name}”); } // 5. 操作后刷新（让改动立即生效） AssetDatabase.Refresh(); // 如果修改了资源 // 或 EditorApplication.RepaintHierarchyWindow(); // 如果需要重绘Hierarchy Debug.Log(“工具执行完毕！”); } }

有了这个模板和核心类库的认识，我们就可以开始实战了。记住，我们的目标是每个场景核心逻辑不超过30行。这里的“核心逻辑”通常指foreach循环内部，或者主要的问题解决算法部分，不包括基本的函数定义和安全检查。

3. 场景一：批量重命名选中对象

这是最经典的需求。在Hierarchy中选中一堆对象，希望按照特定规则（如“Object_01”，“Object_02”…）快速重命名。

核心思路：遍历Selection.gameObjects，为每一个对象按照索引和前缀修改name属性。

[MenuItem(“Tools/Automation/Batch Rename Selected %#r”)] // %#r 是快捷键 Ctrl+Shift+R static void BatchRenameSelected() { if (Selection.gameObjects.Length == 0) { EditorUtility.DisplayDialog(“No Selection”, “请先在Hierarchy中选择至少一个GameObject”, “OK”); return; } // 弹出一个输入框，让用户自定义前缀 string prefix = EditorUtility.DisplayDialog(“Batch Rename”, “输入重命名前缀：”, “OK”, “Cancel”) ? EditorUtility.DisplayDialog(“Input”, “请输入前缀：”, “OK”, “Cancel”) ? “Object_” : “Object_” : “Object_”; // 上面这行是个简化，实际中可能需要更复杂的输入窗口。这里为了行数，我们简化处理，固定前缀为“New_”。 prefix = “New_”; // 记录撤销操作 Undo.RecordObjects(Selection.gameObjects, “Batch Rename”); // 核心逻辑（<10行） int index = 1; // 按照在Hierarchy中的顺序排序，这样重命名后顺序更直观 var sortedList = Selection.gameObjects.OrderBy(go => go.transform.GetSiblingIndex()).ToArray(); foreach (GameObject go in sortedList) { go.name = $“{prefix}{index++.ToString(“D2”)}”; // D2表示两位数，如01，02 } Debug.Log($“已重命名 {Selection.gameObjects.Length} 个对象。”); }

实操要点与避坑：

1. 使用Undo.RecordObjects：这是编辑器工具的道德底线。任何修改编辑器状态的操作都必须支持撤销（Ctrl+Z），否则会给使用者带来灾难。这里我们把所有选中的游戏对象记录到一次撤销操作中。
2. 排序的重要性：直接遍历Selection.gameObjects顺序是不确定的。使用OrderBy(go => go.transform.GetSiblingIndex())可以按照它们在Hierarchy面板中的视觉顺序进行重命名，结果更符合预期。
3. 命名格式：ToString(“D2”)确保索引至少是两位数，视觉上更整齐。你可以根据需要调整“D3”等。

4. 场景二：为Prefab批量添加指定组件

假设你有一批角色Prefab，需要统一添加一个“Health”脚本组件，并设置默认血量。

核心思路：遍历选中的Prefab资源（在Project窗口），通过AssetDatabase.LoadAssetAtPath加载为GameObject，添加组件，再通过PrefabUtility.SaveAsPrefabAsset保存（注意处理预制件实例）。

[MenuItem(“Assets/Tools/Add Health Component to Prefabs”, false, 0)] // 在Assets右键菜单中 static void AddComponentToSelectedPrefabs() { // 获取Project窗口中选中的所有Prefab资源 Object[] selectedAssets = Selection.GetFiltered(typeof(GameObject), SelectionMode.Assets); if (selectedAssets.Length == 0) return; // 显示进度条，对于大量操作很友好 EditorUtility.DisplayProgressBar(“Processing”, “Adding Health Component…”, 0); try { for (int i = 0; i < selectedAssets.Length; i++) { GameObject prefabAsset = (GameObject)selectedAssets[i]; string path = AssetDatabase.GetAssetPath(prefabAsset); // 加载Prefab资源（或直接使用prefabAsset，如果它是根对象） GameObject prefabRoot = PrefabUtility.LoadPrefabContents(path); // 核心逻辑：检查并添加组件 Health healthComp = prefabRoot.GetComponent<Health>(); if (healthComp == null) { healthComp = prefabRoot.AddComponent<Health>(); } // 设置默认值 healthComp.maxHealth = 100; healthComp.currentHealth = 100; // 保存修改回Prefab PrefabUtility.SaveAsPrefabAsset(prefabRoot, path); PrefabUtility.UnloadPrefabContents(prefabRoot); // 更新进度条 EditorUtility.DisplayProgressBar(“Processing”, $"Processing {prefabAsset.name}…”, (float)i / selectedAssets.Length); } AssetDatabase.Refresh(); Debug.Log($“成功处理 {selectedAssets.Length} 个Prefab。”); } finally { // 确保进度条被清除 EditorUtility.ClearProgressBar(); } }

注意事项：

1. PrefabUtility.LoadPrefabContents与SaveAsPrefabAsset：这是Unity处理Prefab资源修改的标准流程。LoadPrefabContents会加载一个可编辑的实例，修改后SaveAsPrefabAsset写回。最后一定要UnloadPrefabContents释放。
2. 进度条：DisplayProgressBar和ClearProgressBar必须成对出现，且放在try-finally块中确保异常时也能清理。这在大批量操作时提供了至关重要的视觉反馈。
3. Selection.GetFiltered：这个方法可以更精确地过滤选中项的类型（SelectionMode.Assets确保是资源而非场景对象）。

5. 场景三：查找并替换材质球Shader

项目中有一批使用“Standard”Shader的旧材质，你想把它们全部升级到“Universal Render Pipeline/Lit”（URP）。

核心思路：使用AssetDatabase.FindAssets搜索所有材质（t:material），遍历加载，检查其shader属性，如果匹配旧Shader则替换为新Shader。

[MenuItem(“Tools/Automation/Replace Shader (Standard to URP Lit)”)] static void ReplaceShaderInMaterials() { // 搜索所有材质球 string[] materialGuids = AssetDatabase.FindAssets(“t:Material”); if (materialGuids.Length == 0) return; Shader oldShader = Shader.Find(“Standard”); Shader newShader = Shader.Find(“Universal Render Pipeline/Lit”); if (oldShader == null || newShader == null) { Debug.LogError(“Shader not found!”); return; } int replacedCount = 0; EditorUtility.DisplayProgressBar(“Replacing Shader”, “Scanning materials…”, 0); for (int i = 0; i < materialGuids.Length; i++) { string path = AssetDatabase.GUIDToAssetPath(materialGuids[i]); Material mat = AssetDatabase.LoadAssetAtPath<Material>(path); if (mat != null && mat.shader == oldShader) { // 核心逻辑：替换Shader Undo.RecordObject(mat, “Replace Shader”); mat.shader = newShader; replacedCount++; // 注意：替换Shader后，原有的纹理属性映射可能丢失，这里是个简化版。 // 复杂情况需要手动映射属性（如_MainTex -> _BaseMap）。 } EditorUtility.DisplayProgressBar(“Replacing Shader”, $"Processing {mat?.name}…”, (float)i / materialGuids.Length); } EditorUtility.ClearProgressBar(); AssetDatabase.SaveAssets(); // 保存所有资产的改动 Debug.Log($“扫描了 {materialGuids.Length} 个材质，替换了 {replacedCount} 个。”); }

实操心得：

1. 属性映射问题：这是批量替换Shader最大的坑。不同的Shader属性名不同（如_MainTexvs_BaseMap）。上述代码只换了Shader，材质球引用的纹理可能会“丢失”。一个更健壮的方案是：在替换后，用Material.GetTexturePropertyNames()获取旧属性，然后根据预设的映射字典，将纹理赋值到新属性上。这超出了30行的范畴，但却是生产环境必须考虑的。
2. AssetDatabase.SaveAssets：这个调用会将所有未保存的资源修改写入磁盘。对于批量修改操作，最后调用一次比依赖自动保存更可靠。
3. 使用GUID：AssetDatabase.FindAssets返回的是GUID（全局唯一标识符），需要通过GUIDToAssetPath转换为路径才能加载。这是Unity资源系统内部的标准做法。

6. 场景四：快速查找空引用组件

场景或Prefab中可能存在一些组件，其公开的字段（如public GameObject target;）在Inspector中显示为“None”（空引用）。手动查找犹如大海捞针。

核心思路：递归遍历场景中所有GameObject及其所有组件，对每个组件使用SerializedObject遍历其SerializedProperty，检查属性类型为ObjectReference且值为null的情况。

[MenuItem(“Tools/Automation/Find Missing References in Scene”)] static void FindMissingReferencesInScene() { var allGOs = GameObject.FindObjectsOfType<GameObject>(true); // true 包含未激活的 int missingCount = 0; StringBuilder report = new StringBuilder(“— Missing References Report —\n”); foreach (GameObject go in allGOs) { Component[] components = go.GetComponents<Component>(); foreach (Component comp in components) { if (comp == null) { // 这是一个“Missing”组件（脚本被删除但组件残留） report.AppendLine($“GameObject ‘{go.name}’ has a Missing Script.”); missingCount++; continue; } SerializedObject so = new SerializedObject(comp); SerializedProperty sp = so.GetIterator(); while (sp.NextVisible(true)) // 遍历所有可见属性 { if (sp.propertyType == SerializedPropertyType.ObjectReference) { if (sp.objectReferenceValue == null && sp.objectReferenceInstanceIDValue != 0) { // 这是一个被赋值为null的引用（InstanceID不为0表示它曾经引用过某个对象） report.AppendLine($“GameObject ‘{go.name}’ -> Component ‘{comp.GetType().Name}’ -> Property ‘{sp.name}’ is NULL.”); missingCount++; } } } } } EditorUtility.ClearProgressBar(); if (missingCount > 0) { Debug.LogWarning(report.ToString()); // 可以将report写入一个文本文件，方便查看 // File.WriteAllText(“MissingReferencesReport.txt”, report.ToString()); } else { Debug.Log(“恭喜！未在场景中发现空引用。”); } }

排查技巧：

1. sp.objectReferenceInstanceIDValue != 0：这是关键判断。一个字段从未被赋值过，和它曾被赋值但后来引用的对象被删除，在Unity内部是不同的。InstanceIDValue为0表示从未赋值，我们通常不关心；不为0但objectReferenceValue为null，则表示引用丢失，这才是需要关注的“坏”的空引用。
2. 处理Missing Script：if (comp == null)这一判断用于捕获那些脚本文件已被删除但组件壳子还留在GameObject上的情况，这也是常见的问题源。
3. 性能考虑：全场景遍历在大型场景中可能较慢。可以考虑结合Selection，只检查选中的对象或特定层级的对象。

7. 场景五：自动化构建AssetBundle清单

管理AssetBundle依赖关系头疼？我们可以写一个小工具，为指定文件夹下的资源自动分配AssetBundle标签，并生成一个简单的文本清单。

核心思路：遍历文件夹，根据资源类型和路径规则设置AssetImporter.assetBundleName和assetBundleVariant，同时将信息记录到一个Dictionary中，最后写入文本文件。

[MenuItem(“Assets/Tools/Auto Assign AB & Generate Manifest”)] static void AutoAssignAssetBundle() { string folderPath = “Assets/Resources/MyBundles”; // 假设目标文件夹 if (!AssetDatabase.IsValidFolder(folderPath)) { Debug.LogError(“Folder not found: “ + folderPath); return; } // 获取文件夹下所有资源（不包括.meta文件） string[] allAssetPaths = Directory.GetFiles(folderPath, “*.*”, SearchOption.AllDirectories) .Where(p => !p.EndsWith(“.meta”)).ToArray(); Dictionary<string, List<string>> bundleManifest = new Dictionary<string, List<string>>(); EditorUtility.DisplayProgressBar(“Assigning Bundles”, “”, 0); for (int i = 0; i < allAssetPaths.Length; i++) { string assetPath = allAssetPaths[i]; // 根据子目录名作为bundle名 string relativePath = assetPath.Replace(folderPath + “/”, “”); string bundleName = Path.GetDirectoryName(relativePath).Replace(“\\”, “/”).ToLower(); if (string.IsNullOrEmpty(bundleName)) bundleName = “misc”; AssetImporter importer = AssetImporter.GetAtPath(assetPath); if (importer != null) { Undo.RecordObject(importer, “Set AssetBundle Name”); importer.assetBundleName = bundleName; importer.assetBundleVariant = “”; // 变体名，可按需设置 importer.SaveAndReimport(); // 构建清单 if (!bundleManifest.ContainsKey(bundleName)) bundleManifest[bundleName] = new List<string>(); bundleManifest[bundleName].Add(relativePath); } EditorUtility.DisplayProgressBar(“Assigning Bundles”, assetPath, (float)i / allAssetPaths.Length); } EditorUtility.ClearProgressBar(); // 生成清单文件 string manifestPath = Path.Combine(folderPath, “_bundle_manifest.txt”); using (StreamWriter sw = new StreamWriter(manifestPath)) { foreach (var kvp in bundleManifest.OrderBy(k => k.Key)) { sw.WriteLine($“[{kvp.Key}]”); foreach (string asset in kvp.Value.OrderBy(s => s)) { sw.WriteLine($“ {asset}”); } } } AssetDatabase.Refresh(); Debug.Log($“AssetBundle标签分配完成，清单已生成：{manifestPath}”); }

常见问题：

1. 路径处理：注意Windows下路径分隔符是\，而Unity内部使用/。使用Path类和Replace进行规范化处理。
2. SaveAndReimport：修改AssetImporter的设置后，需要调用此方法使改动生效并重新导入资源。
3. 命名策略：上述例子使用子目录名作为Bundle名，这是一种简单的策略。你可以根据项目需要设计更复杂的规则，比如按资源类型（纹理、模型）、使用频率等分包。

8. 场景六：一键优化导入的纹理设置

从外部导入大量纹理（如UI切图）后，需要统一设置压缩格式、最大尺寸等，避免一个个点开设置。

核心思路：使用AssetDatabase.FindAssets找到所有纹理，获取其TextureImporter，根据规则（如路径包含“UI”则设为Sprite，2的幂次，RGBA Compressed）进行批量配置。

[MenuItem(“Tools/Automation/Optimize Selected Textures”)] static void OptimizeTextureSettings() { // 这里以优化Project窗口中选中的纹理为例 Object[] selectedTextures = Selection.GetFiltered(typeof(Texture2D), SelectionMode.Assets); if (selectedTextures.Length == 0) return; EditorUtility.DisplayProgressBar(“Optimizing Textures”, “”, 0); for (int i = 0; i < selectedTextures.Length; i++) { string path = AssetDatabase.GetAssetPath(selectedTextures[i]); TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter; if (importer == null) continue; Undo.RecordObject(importer, “Optimize Texture Settings”); // 核心逻辑：根据路径或类型应用预设 bool isUI = path.ToLower().Contains(“/ui/”); bool isNormalMap = importer.textureType == TextureImporterType.NormalMap; if (isUI) { importer.textureType = TextureImporterType.Sprite; importer.spriteImportMode = SpriteImportMode.Single; importer.mipmapEnabled = false; // UI纹理通常不需要Mipmap importer.maxTextureSize = 2048; importer.textureCompression = TextureImporterCompression.Compressed; } else if (isNormalMap) { importer.textureType = TextureImporterType.NormalMap; importer.convertToNormalmap = false; // 它本身就是法线贴图 importer.maxTextureSize = 2048; importer.textureCompression = TextureImporterCompression.Compressed; } else // 普通纹理 { importer.textureType = TextureImporterType.Default; importer.mipmapEnabled = true; importer.maxTextureSize = 4096; importer.textureCompression = TextureImporterCompression.CompressedHQ; // 高质量压缩 } // 通用设置：可读性关闭以节省内存，除非运行时需要采样 importer.isReadable = false; importer.SaveAndReimport(); EditorUtility.DisplayProgressBar(“Optimizing Textures”, path, (float)i / selectedTextures.Length); } EditorUtility.ClearProgressBar(); AssetDatabase.Refresh(); Debug.Log($“优化了 {selectedTextures.Length} 张纹理的设置。”); }

参数详解与避坑：

1. isReadable：这个属性非常重要。如果纹理不需要在运行时通过GetPixels/SetPixels读写，一定要设为false。设为true会在内存中保留一份未压缩的副本，极大增加内存占用。
2. 压缩格式选择：Compressed是平衡选择。CompressedHQ质量更高但体积稍大。对于UI，也可以考虑Uncompressed（完全不压缩）来保证绝对清晰的边缘，但需权衡包体大小。
3. SaveAndReimport的触发：修改TextureImporter后必须调用此方法，否则设置不会生效。它会导致纹理重新导入，对于大量纹理操作会有短暂卡顿，最好在项目空闲时进行。

9. 场景七：生成简单的场景对象统计报告

在场景优化或验收时，你需要快速知道场景中有多少种对象，各自的数量，以及静态批处理、光照贴图的使用情况。

核心思路：再次遍历场景中所有GameObject，按标签（Tag）、图层（Layer）、是否静态、是否有MeshRenderer等条件进行分类统计，并将结果格式化为字符串或写入CSV文件。

[MenuItem(“Tools/Automation/Generate Scene Report”)] static void GenerateSceneReport() { var allGOs = GameObject.FindObjectsOfType<GameObject>(true); Dictionary<string, int> countByTag = new Dictionary<string, int>(); Dictionary<int, int> countByLayer = new Dictionary<int, int>(); int staticCount = 0; int dynamicCount = 0; int hasMeshRenderer = 0; int hasLight = 0; foreach (GameObject go in allGOs) { // 按标签统计 string tag = go.tag; if (!countByTag.ContainsKey(tag)) countByTag[tag] = 0; countByTag[tag]++; // 按图层统计 int layer = go.layer; if (!countByLayer.ContainsKey(layer)) countByLayer[layer] = 0; countByLayer[layer]++; // 静态/动态 if (GameObjectUtility.AreStaticEditorFlagsSet(go, StaticEditorFlags.ContributeGI)) // 简化判断为是否参与GI staticCount++; else dynamicCount++; // 组件统计 if (go.GetComponent<MeshRenderer>() != null) hasMeshRenderer++; if (go.GetComponent<Light>() != null) hasLight++; } // 生成报告字符串 System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.AppendLine($“======= 场景统计报告 =======“); sb.AppendLine($“总GameObject数量: {allGOs.Length}“); sb.AppendLine($“— 按标签分布 —“); foreach (var kvp in countByTag.OrderByDescending(k => k.Value)) { sb.AppendLine($“ Tag ‘{kvp.Key}’: {kvp.Value}“); } sb.AppendLine($“— 按图层分布 —“); foreach (var kvp in countByLayer.OrderBy(k => k.Key)) { sb.AppendLine($“ Layer {kvp.Key} ({LayerMask.LayerToName(kvp.Key)}): {kvp.Value}“); } sb.AppendLine($“— 其他统计 —“); sb.AppendLine($“ 静态对象(参与GI): {staticCount}“); sb.AppendLine($“ 动态对象: {dynamicCount}“); sb.AppendLine($“ 带MeshRenderer的对象: {hasMeshRenderer}“); sb.AppendLine($“ 带Light组件的对象: {hasLight}“); Debug.Log(sb.ToString()); // 可选：将报告保存到文件 string reportPath = Application.dataPath + “/../SceneReport.txt”; System.IO.File.WriteAllText(reportPath, sb.ToString()); EditorUtility.RevealInFinder(reportPath); // 在资源管理器中打开所在文件夹 }

扩展思路： 这个报告非常基础。你可以轻松地扩展它，例如：

• 统计所有MeshRenderer使用的材质球种类和数量，找出重复材质。
• 统计所有MeshFilter的网格三角形总数，评估场景面数。
• 检查所有Light的烘焙设置是否合理。
• 将数据输出为JSON或CSV格式，便于导入Excel进行进一步分析。

10. 场景八：自定义Inspector扩展与快速操作

这不是一个独立的工具，而是一种模式。通过为常用的组件编写自定义Inspector（Editor类），可以集成一键化的复杂操作。

示例：为Rigidbody组件添加一键初始化按钮

创建一个脚本RigidbodyQuickSetupEditor.cs放在Editor文件夹下：

using UnityEditor; using UnityEngine; [CustomEditor(typeof(Rigidbody))] public class RigidbodyQuickSetupEditor : Editor { public override void OnInspectorGUI() { // 1. 首先绘制默认的Inspector DrawDefaultInspector(); // 2. 添加分隔线和我们的按钮 EditorGUILayout.Space(); EditorGUILayout.LabelField(“Quick Setup”, EditorStyles.boldLabel); Rigidbody rb = (Rigidbody)target; // 核心逻辑：一个按钮完成多项设置 if (GUILayout.Button(“Setup for Dynamic Object”)) { Undo.RecordObject(rb, “Setup Dynamic Rigidbody”); rb.mass = 1.0f; rb.drag = 0.5f; rb.angularDrag = 0.05f; rb.useGravity = true; rb.isKinematic = false; rb.interpolation = RigidbodyInterpolation.Interpolate; rb.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic; EditorUtility.SetDirty(rb); Debug.Log($“Rigidbody on {rb.gameObject.name} configured for dynamics.”); } if (GUILayout.Button(“Setup for Static/Kinematic Object”)) { Undo.RecordObject(rb, “Setup Kinematic Rigidbody”); rb.mass = 1.0f; rb.drag = 0f; rb.angularDrag = 0f; rb.useGravity = false; rb.isKinematic = true; EditorUtility.SetDirty(rb); Debug.Log($“Rigidbody on {rb.gameObject.name} configured as kinematic.”); } } }

为什么这样做：

1. 上下文感知：工具直接附着在需要操作的对象上，无需在菜单中寻找，也无需先选中对象。
2. 降低错误：按钮封装了最佳实践参数组合（如动态物体使用连续碰撞检测），避免了手动设置时遗漏或设错。
3. 提升效率：一键操作替代了点击多个下拉菜单和输入框。

你可以为任何你经常需要配置的组件（如AudioSource、Camera、自定义脚本）创建这样的快捷编辑器，将经验固化为工具。

11. 常见问题与排查技巧实录

在实际编写和运行这些自动化脚本时，你肯定会遇到一些坑。这里记录了几个最常见的问题和解决方法。

问题1：脚本编译错误，提示UnityEditor命名空间找不到

• 原因：脚本没有放在名为Editor的文件夹下。或者，脚本文件的后缀不是.cs。
• 解决：在Assets下创建一个名为Editor的文件夹，将脚本移入。确保脚本文件名以.cs结尾。

问题2：菜单项点击后没反应，也不报错

• 原因A：函数不是static的。MenuItem绑定的函数必须是静态方法。
• 原因B：函数有参数。MenuItem函数不能有参数。
• 原因C：脚本有编译错误，导致整个工具类没有被加载。
• 排查：检查Console窗口是否有编译错误。确保函数签名是static void FunctionName()。

问题3：修改了资源（如Prefab、材质），但场景或Project窗口没有实时刷新

• 原因：修改了资源对象的属性后，没有调用EditorUtility.SetDirty(object)标记对象为“脏”，或者没有调用AssetDatabase.Refresh()刷新资源数据库。
• 解决：
  • 修改场景中的对象：通常Undo.RecordObject会自动处理脏标记，但显式调用EditorUtility.SetDirty(targetObject)是良好习惯。
  • 修改资源文件（磁盘上的资产）：修改AssetImporter（如TextureImporter）或通过PrefabUtility保存后，需要调用AssetDatabase.Refresh()。AssetDatabase.SaveAssets()会在刷新后保存。

问题4：批量操作时编辑器卡死或无响应

• 原因：循环处理成百上千个对象，且每次循环都进行耗时操作（如Instantiate、复杂的物理计算），阻塞了主线程。
• 解决：
  1. 使用进度条：EditorUtility.DisplayProgressBar虽然不能防止卡顿，但至少让用户知道程序在运行。
  2. 分帧处理：对于极大量的操作，可以考虑使用EditorApplication.update事件将任务分摊到多帧执行，避免单帧卡死。但这会显著增加代码复杂度。
  3. 优化逻辑：检查循环内是否有可以提到循环外的计算，或者是否有不必要的重复加载资源（使用缓存）。

问题5：SerializedObject和SerializedProperty用起来好复杂

• 原因：不熟悉Unity的序列化系统。
• 技巧：
  • 为什么用它们：直接修改public字段的value在某些情况下（尤其是涉及预制件变体、撤销操作时）可能不会触发正确的序列化更新。SerializedObject/Property是Unity编辑器扩展的“官方”方式，能保证修改被正确序列化和撤销。
  • 常用模式：

    SerializedObject so = new SerializedObject(targetComponent); SerializedProperty sp = so.FindProperty(“m_MyPrivateFieldName”); // 查找私有序列化字段 if (sp != null) { sp.intValue = 42; sp.floatValue = 3.14f; sp.objectReferenceValue = someObject; sp.boolValue = true; sp.stringValue = “Hello”; // 如果是数组 sp.arraySize = 5; sp.GetArrayElementAtIndex(0).objectReferenceValue = element0; } so.ApplyModifiedProperties(); // 将修改应用回原对象

  • 查找属性名：属性名通常是字段名。对于私有字段，通常是m_+字段名。在Inspector中右键点击属性标签，选择“Copy Property Path”可以快速获取准确的属性路径。

掌握这8个场景，你已经能够解决Unity开发中80%的重复性编辑器操作。最关键的一步是开始动手，从模仿这些例子开始，然后针对自己项目的具体痛点进行改造。你会发现，一旦习惯了用代码思维去思考编辑器操作，很多繁琐的工作都会迎刃而解，而你所投入的这几十行代码，将会在项目的整个生命周期里持续地为你节省时间。