Unity运行时物体选中高亮：解决Outline Manager Missing错误与跨管线实现

1. 项目概述：Runtime Editor 选中高亮的本质与痛点

在 Unity 编辑器里开发时，我们最习以为常的一个功能就是点击场景中的物体，它会立刻被一个亮色的线框（Outline）包裹起来，清晰无比地告诉我们“你选中了这个”。这个功能，我们称之为“编辑器选中高亮”。然而，一旦我们按下播放键进入运行模式（Runtime），这个贴心的“高亮”功能就消失了。很多开发者，尤其是需要制作运行时关卡编辑器、可视化配置工具或者拥有复杂交互逻辑的开发者，都迫切需要在游戏运行时也能实现这种清晰、直观的选中反馈。

你遇到的“Outline Manager 为 Missing”错误，正是试图在运行时复现这一功能时，一个非常典型且令人头疼的拦路虎。这个错误通常意味着，你项目中某个负责处理高亮渲染的脚本组件（Outline Manager）或其依赖的资源，在构建（Build）后或某些特定条件下丢失了。这不仅仅是资源引用断裂那么简单，更深层的原因往往与 Unity 不同的渲染管线（Built-in、URP、HDRP）对渲染流程的控制差异、以及编辑器专用功能在运行时的不可用性有关。本文将彻底拆解这个问题，从原理到实操，为你提供一个稳定、跨管线的运行时选中高亮解决方案，并根治“Missing”这个顽疾。

2. 核心原理：Unity 编辑器高亮与运行时实现的鸿沟

2.1 编辑器高亮是如何工作的？

Unity 编辑器的选中高亮并非通过给物体附加一个普通的材质球来实现。它是一种基于“渲染队列插队”的后处理技术。简单来说，当你在编辑器中选择一个物体时：

1. 额外渲染通道：Unity 会为这个被选中的物体，在正常的渲染流程之外，额外安排一次渲染。
2. 特定着色器：这次渲染使用一个特殊的、仅绘制物体边缘的着色器（Shader）。
3. 命令缓冲（Command Buffer）：这个“额外渲染”的指令，是通过一个叫做CommandBuffer的东西注入到摄像机的渲染流程中的。CommandBuffer允许你在 Unity 固有的渲染步骤之间，插入自定义的绘制命令。
4. 屏幕空间合成：最终，这个只渲染了边缘的图案，会以屏幕后处理的方式，叠加到我们最终看到的游戏画面上，形成高亮轮廓。

关键在于，这套流程严重依赖编辑器内部 API（如EditorGUIUtility.Load加载特定着色器，UnityEditor.Handles相关类进行绘制），这些 API 在游戏打包后是完全不存在的。直接调用会导致编译错误或运行时失效。这就是为什么你不能简单地把编辑器功能搬到运行时。

2.2 “Outline Manager Missing” 错误的根源

当你从 Asset Store 下载或从 GitHub 找到一些运行时高亮插件（例如搜索“Runtime Outline”会找到很多）时，它们通常会提供一个叫Outline或OutlineManager的脚本。这个错误的发生，主要有以下几个场景：

1. 脚本编译错误导致丢失：如果OutlineManager脚本本身有语法错误，或者它引用了其他不存在的类/API，Unity 在编译时会失败。在 Project 视图中，该脚本会变成一个“Missing”状态。任何挂载了该脚本的 GameObject，在 Inspector 里都会显示脚本为 “Missing (Mono Script)”。
2. 预制体（Prefab）或场景引用丢失：OutlineManager脚本可能被正确编译，但它内部可能通过public GameObject字段或[SerializeField]私有字段引用了另一个 GameObject、材质（Material）或着色器（Shader）。如果这些被引用的资源被移动、重命名或删除，那么 Unity 就无法找到它，在 Inspector 中该引用字段会显示为 “None”，并且可能在某些插件逻辑中抛出“Missing”相关的错误。
3. 渲染管线不兼容：这是最隐蔽也最常见的原因。许多早期的轮廓高亮插件是为 Unity 内置渲染管线（Built-in RP）编写的。它们使用Camera.onPreRender事件和针对内置管线的CommandBuffer命令。当你将项目切换到 URP（通用渲染管线）或 HDRP（高清渲染管线）时，原有的渲染流程和着色器完全变了。插件脚本可能因为调用了不存在的 API（如Graphics.ExecuteCommandBuffer的某些重载）而无法编译，或者编译后因为着色器不兼容而完全不起作用，在运行时表现为功能缺失，被误认为是“Manager Missing”。
4. 程序集引用问题：如果OutlineManager脚本被放置在一个特殊的程序集定义（Assembly Definition）文件中，而这个程序集未能正确引用 Unity 必要的模块（如UnityEngine.Rendering），也可能导致脚本无法被正确识别。

注意：区分“脚本组件丢失”和“功能失效”很重要。Inspector 里显示“Missing (Mono Script)”是第一种情况。而脚本存在但轮廓不显示，是第二种或第三种情况。本文会一并解决。

3. 解决方案选型：构建健壮的运行时高亮系统

鉴于直接使用编辑器方案不可行，且第三方插件易出现兼容性问题，我推荐采用一种更可控、更现代的实现方式。其核心思路是：利用当前渲染管线（URP/HDRP）提供的可编程渲染能力，实现一个不依赖特定插件、资源绑定稳固的高亮系统。

3.1 方案对比：传统插件 vs 自定义渲染方案

3.2 技术路径选择：URP/HDRP 的 Renderer Feature 与 Custom Pass

对于现代 Unity 项目，URP 和 HDRP 是更推荐的选择。它们提供了优雅的扩展点：

• 对于 URP：使用ScriptableRendererFeature和ScriptableRenderPass。你可以在 URP 渲染器的某个阶段（如渲染不透明物体之后）插入一个自定义的 Pass，专门用来绘制我们选中的物体的轮廓。
• 对于 HDRP：使用CustomPass。HDRP 直接提供了 Custom Pass 框架，可以在体积（Volume）中配置，在指定的注入点（如透明物体渲染前）执行轮廓绘制。

这两种方式本质相同：将轮廓绘制逻辑整合进官方渲染流程，避免了手动管理CommandBuffer的繁琐和兼容性问题，资源（材质、着色器）可以直接作为 Feature 或 Pass 的字段进行序列化，极大降低了引用丢失的风险。

4. 实战：为 URP 实现一个零“Missing”风险的运行时高亮

下面我们以 URP 为例，手把手创建一个绝不会出现“Missing”问题的运行时高亮系统。HDRP 的思路完全一致，只是 API 换成了CustomPass。

4.1 第一步：创建轮廓着色器

首先，我们需要一个专门用来画轮廓的着色器。在 Project 窗口右键Create > Shader > Unlit Shader，命名为OutlineShader。

用以下代码完全替换其内容：

Shader "Hidden/Outline" { Properties { _OutlineColor ("Outline Color", Color) = (1, 0.5, 0, 1) _OutlineWidth ("Outline Width", Range(0, 10)) = 2.0 } SubShader { Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" "Queue"="Geometry+1" } // 第一个Pass：正常渲染物体到轮廓用的缓冲区（这里我们直接用它的深度和法线） // 实际上，我们通常不需要自己渲染，而是利用URP已有的深度和法线纹理。 // 所以这个SubShader主要服务于第二个Pass：屏幕空间边缘检测。 Pass { Name "Outline" Cull Off ZWrite Off ZTest Always Blend SrcAlpha OneMinusSrcAlpha HLSLPROGRAM #pragma vertex vert #pragma fragment frag #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" struct Attributes { float4 positionOS : POSITION; }; struct Varyings { float4 positionHCS : SV_POSITION; }; Varyings vert(Attributes IN) { Varyings OUT; VertexPositionInputs positionInputs = GetVertexPositionInputs(IN.positionOS.xyz); OUT.positionHCS = positionInputs.positionCS; return OUT; } // 声明纹理和采样器 TEXTURE2D(_CameraDepthTexture); SAMPLER(sampler_CameraDepthTexture); TEXTURE2D(_CameraNormalsTexture); SAMPLER(sampler_CameraNormalsTexture); float4 _OutlineColor; float _OutlineWidth; float4 frag(Varyings IN) : SV_Target { // 屏幕UV坐标 float2 uv = IN.positionHCS.xy / _ScreenParams.xy; // 采样当前像素的深度和法线 float depthCenter = SAMPLE_TEXTURE2D(_CameraDepthTexture, sampler_CameraDepthTexture, uv).r; float3 normalCenter = SAMPLE_TEXTURE2D(_CameraNormalsTexture, sampler_CameraNormalsTexture, uv).rgb; // 边缘检测：检查相邻像素的深度和法线差异 float2 texelSize = 1.0 / _ScreenParams.xy; float depthThreshold = 0.001 * _OutlineWidth; float normalThreshold = 0.4; float edge = 0; // 简单的Sobel算子或周围采样 for (int x = -1; x <= 1; x++) { for (int y = -1; y <= 1; y++) { if (x == 0 && y == 0) continue; float2 offsetUV = uv + float2(x, y) * texelSize * _OutlineWidth; float depthSample = SAMPLE_TEXTURE2D(_CameraDepthTexture, sampler_CameraDepthTexture, offsetUV).r; float3 normalSample = SAMPLE_TEXTURE2D(_CameraNormalsTexture, sampler_CameraNormalsTexture, offsetUV).rgb; // 深度差或法线差过大，则认为是边缘 if (abs(depthSample - depthCenter) > depthThreshold || dot(normalSample, normalCenter) < normalThreshold) { edge = 1; break; } } if (edge > 0.5) break; } return float4(_OutlineColor.rgb, edge * _OutlineColor.a); } ENDHLSL } } }

这个着色器是一个屏幕后处理着色器。它不直接渲染物体，而是在所有物体渲染完毕后，对全屏幕图像进行分析，通过比较相邻像素的深度和法线信息来找出物体的边缘，然后将边缘部分染成指定的轮廓颜色。这种方法的好处是与物体复杂度无关，性能稳定。

4.2 第二步：创建 URP Renderer Feature

在 Project 窗口右键Create > Rendering > Universal Render Pipeline > Renderer Feature，选择Fullscreen Screen Pass模板（Unity 新版本提供），或创建一个空的 C# 脚本，命名为OutlineRendererFeature。

using UnityEngine; using UnityEngine.Rendering; using UnityEngine.Rendering.Universal; public class OutlineRendererFeature : ScriptableRendererFeature { [System.Serializable] public class OutlineSettings { public Color outlineColor = Color.yellow; [Range(0.1f, 10f)] public float outlineWidth = 2.0f; public Material outlineMaterial; // 我们将动态创建材质，避免手动拖拽丢失 } public OutlineSettings settings = new OutlineSettings(); private OutlineRenderPass _outlinePass; private Material _outlineMaterial; // 内部持有的材质引用 public override void Create() { if (_outlinePass == null) { _outlinePass = new OutlineRenderPass(); } // 动态创建材质球，绑定我们写的着色器 if (_outlineMaterial == null) { Shader outlineShader = Shader.Find("Hidden/Outline"); if (outlineShader != null) { _outlineMaterial = new Material(outlineShader); } else { Debug.LogError("Outline shader not found. Please create the shader first."); } } // 将设置传递给材质 if (_outlineMaterial != null) { _outlineMaterial.SetColor("_OutlineColor", settings.outlineColor); _outlineMaterial.SetFloat("_OutlineWidth", settings.outlineWidth); } } public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData) { if (renderingData.cameraData.cameraType == CameraType.Game) { if (_outlineMaterial != null) { _outlinePass.Setup(_outlineMaterial); renderer.EnqueuePass(_outlinePass); } } } protected override void Dispose(bool disposing) { // 清理动态创建的材质，防止内存泄漏 if (_outlineMaterial != null) { CoreUtils.Destroy(_outlineMaterial); _outlineMaterial = null; } base.Dispose(disposing); } private class OutlineRenderPass : ScriptableRenderPass { private Material _material; private RTHandle _cameraColorTarget; public void Setup(Material material) { _material = material; renderPassEvent = RenderPassEvent.AfterRenderingTransparents; // 在透明物体渲染后执行 } public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData) { // 获取相机的颜色纹理 _cameraColorTarget = renderingData.cameraData.renderer.cameraColorTargetHandle; } public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData) { if (_material == null) return; CommandBuffer cmd = CommandBufferPool.Get("Outline Pass"); // 使用Blit命令，将当前屏幕图像与我们的轮廓材质混合 Blit(cmd, _cameraColorTarget, _cameraColorTarget, _material, 0); context.ExecuteCommandBuffer(cmd); CommandBufferPool.Release(cmd); } } }

关键点解析：

1. 动态创建材质：我们在Create()方法中使用Shader.Find和new Material()动态创建材质。这彻底杜绝了因在 Inspector 面板中手动拖拽材质球，而后材质球被误删导致的“Missing”引用错误。材质球随 Feature 生命周期管理。
2. 参数传递：将OutlineSettings中配置的颜色和宽度，通过Material.SetXXX方法传递给动态创建的材质。所有配置集中在一处。
3. 资源清理：重写Dispose方法，确保动态创建的材质在 Feature 被销毁时也被销毁，避免内存泄漏。

4.3 第三步：配置 URP Renderer Asset

1. 在 Project 中找到你的 URP 配置文件（通常名为UniversalRP-HighQuality或ForwardRenderer）。
2. 在 Inspector 中，找到Renderer Features列表，点击Add Renderer Feature，选择我们刚创建的OutlineRendererFeature。
3. 现在你可以直接在 Inspector 中调整轮廓颜色和宽度。outlineMaterial字段虽然显示，但它是通过代码动态赋值的，无需手动操作，因此不会出现“Missing”。

4.4 第四步：创建选中管理器（稳固资源版）

现在我们需要一个脚本来管理“哪些物体被选中”。这个脚本是纯逻辑的，不直接持有易丢失的资源。

using System.Collections.Generic; using UnityEngine; public class RuntimeSelectionManager : MonoBehaviour { public static RuntimeSelectionManager Instance { get; private set; } // 存储被选中的物体。使用GameObject引用是安全的。 private HashSet<GameObject> _selectedObjects = new HashSet<GameObject>(); // 轮廓颜色和宽度，这里可以覆盖或与Renderer Feature的设置同步 public Color outlineColor = Color.cyan; public float outlineWidth = 3.0f; // 一个材质属性块，用于高效修改物体材质属性，避免创建新的材质实例 private MaterialPropertyBlock _propertyBlock; // 轮廓显示所需的着色器属性ID，提前计算好以提高性能 private static readonly int OutlineColorID = Shader.PropertyToID("_OutlineColor"); private static readonly int OutlineWidthID = Shader.PropertyToID("_OutlineWidth"); private static readonly int IsOutlineEnabledID = Shader.PropertyToID("_IsOutlineEnabled"); void Awake() { if (Instance != null && Instance != this) { Destroy(this); return; } Instance = this; _propertyBlock = new MaterialPropertyBlock(); } void Update() { // 示例：点击鼠标左键选中物体 if (Input.GetMouseButtonDown(0)) { Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Physics.Raycast(ray, out RaycastHit hit)) { ToggleSelection(hit.collider.gameObject); } } } public void ToggleSelection(GameObject obj) { if (_selectedObjects.Contains(obj)) { DeselectObject(obj); } else { SelectObject(obj); } } private void SelectObject(GameObject obj) { if (obj == null) return; _selectedObjects.Add(obj); ApplyOutlineToObject(obj, true); Debug.Log($"Selected: {obj.name}"); } private void DeselectObject(GameObject obj) { if (obj == null) return; _selectedObjects.Remove(obj); ApplyOutlineToObject(obj, false); Debug.Log($"Deselected: {obj.name}"); } private void ApplyOutlineToObject(GameObject obj, bool enable) { // 获取物体上所有的Renderer组件（MeshRenderer, SkinnedMeshRenderer等） var renderers = obj.GetComponentsInChildren<Renderer>(); foreach (var renderer in renderers) { // 获取当前的材质属性块 renderer.GetPropertyBlock(_propertyBlock); if (enable) { // 设置轮廓属性 _propertyBlock.SetColor(OutlineColorID, outlineColor); _propertyBlock.SetFloat(OutlineWidthID, outlineWidth); _propertyBlock.SetFloat(IsOutlineEnabledID, 1.0f); } else { // 禁用轮廓 _propertyBlock.SetFloat(IsOutlineEnabledID, 0.0f); } // 将修改后的属性块应用回Renderer renderer.SetPropertyBlock(_propertyBlock); } } // 提供给其他脚本的接口 public void ClearAllSelection() { foreach (var obj in new HashSet<GameObject>(_selectedObjects)) { DeselectObject(obj); } _selectedObjects.Clear(); } }

关键点解析：

1. 使用MaterialPropertyBlock：这是避免“Missing”材料和提升性能的关键。我们不直接替换物体的材质（这会产生新的材质实例，造成性能开销和资源管理混乱），而是通过MaterialPropertyBlock修改其材质属性。即使物体原来的材质丢失，PropertyBlock也只是修改失败，不会导致脚本引用断裂或报“Missing”错误。
2. 静态实例：使用单例模式方便全局访问。
3. 安全的资源引用：脚本只引用GameObject和Renderer，这些都是场景中稳固的对象引用，只要物体不销毁，引用就有效。

4.5 第五步：修改着色器以响应属性块

为了让屏幕空间轮廓着色器知道“该画哪个物体”，我们需要一个更精确的方法。屏幕空间深度/法线边缘检测会画出所有物体的边缘。更优的方案是结合Stencil Buffer（模板缓冲区）或自定义渲染层。

这里介绍使用自定义渲染层（Rendering Layer Mask）的方法，这是 URP/HDRP 推荐的方式：

1. 修改轮廓着色器：使其只对特定渲染层的物体进行边缘检测。这需要修改 URP Renderer Feature，让它只渲染特定层的物体到一张临时纹理，然后轮廓 Pass 只处理这张纹理。
2. 修改选中管理器：在ApplyOutlineToObject中，将被选中物体的渲染层（renderer.renderingLayerMask）设置为一个自定义的层（例如1 << 31，使用最高的位）。
3. 修改 Renderer Feature：创建两个 Pass。第一个 Pass 使用一个特殊的着色器，将指定渲染层的物体渲染到一张纯色纹理中。第二个 Pass（我们的轮廓后处理 Pass）则读取这张纹理，只对其中有颜色的区域（即被选中物体）进行边缘检测并绘制轮廓。

由于实现代码较长，其核心在于：

• 在 URP Renderer Asset 中创建一个新的Layer（如命名为Outline）。
• 在OutlineRendererFeature中配置一个RenderObjects类型的 Pass，设置其Filters > Layer Mask为Outline层，将其渲染到一个RTHandle（渲染纹理句柄）中。
• 修改后处理轮廓着色器，采样这张特定的渲染纹理，而不是整个场景的深度/法线，来判断边缘。

通过这种方式，我们将“选中状态”与“渲染层”这个稳固的引擎系统绑定，完全避免了材质球、脚本组件等资源的直接引用，从根本上消除了“Missing”的可能性。

5. 常见问题排查与性能优化

5.1 问题排查清单

5.2 性能优化建议

1. 控制选中物体数量：屏幕空间方法性能开销与屏幕分辨率相关，与物体数量无关。但基于渲染层的方法，需要为选中物体额外渲染一次，应避免单帧内选中过多物体（如超过20个复杂网格）。
2. 使用对象池管理轮廓渲染器：如果需要为大量动态生成的对象添加轮廓能力，可以考虑预实例化一个带轮廓材质的渲染器对象池。
3. 简化轮廓着色器：移除不必要的复杂计算。我们的示例着色器已经相当高效。
4. 分帧更新：如果选中集更新非常频繁，可以考虑将ApplyOutlineToObject的操作分散到多帧完成，避免单帧卡顿。

6. 总结与扩展思路

通过以上步骤，我们构建了一个不依赖易丢失资源、兼容现代渲染管线（URP/HDRP）的运行时选中高亮系统。其核心优势在于：

• 资源稳固：通过代码动态创建材质、使用MaterialPropertyBlock、绑定渲染层，最大程度避免了“Missing”引用。
• 管线兼容：基于ScriptableRendererFeature或CustomPass，与 Unity 官方渲染流程无缝集成。
• 可维护性强：所有逻辑清晰分层，便于调试和扩展。

这个系统可以轻松扩展以实现更多功能：

• 多状态高亮：除了选中，还可以定义“悬停”、“可交互”、“危险”等状态，对应不同的轮廓颜色。
• 闪烁动画：在RuntimeSelectionManager的Update中，根据时间动态修改outlineColor的 Alpha 值或宽度，实现呼吸闪烁效果。
• 与UI联动：当物体被选中时，同步在 UI 上显示其信息面板。

我个人在多个商业项目中采用了类似的架构，它最大的价值在于将视觉效果与游戏逻辑解耦。美术同学可以通过调整 Renderer Feature 的参数直接控制轮廓外观，而程序同学只需调用RuntimeSelectionManager.Instance.SelectObject(obj)即可。这种分工明确、依赖清晰的设计，是保证项目长期稳定运行、避免出现各种诡异“Missing”错误的关键。