Unity编辑器扩展之Scene视图扩展

内容将会持续更新，有错误的地方欢迎指正，谢谢!
 

一、通过Gizmo绘制辅助元素

Gizmo 是 Unity 中一种用于在编辑器中可视化调试和编辑的工具。

它们允许开发者在 Scene 视图中绘制各种几何形状或其他可视化元素，这些元素只在编辑器中可见，不会在游戏运行时显示。

之前已经写过相关文章：
https://blog.csdn.net/caiprogram123/article/details/135448539#GizmosDrawLine_176

二、通过Handles绘制辅助元素

在 Unity 编辑器中，Handles 类提供了一组用于在场景视图中绘制图形和元素的工具。

它主要用于在编辑模式下为开发者提供可视化辅助，帮助开发和调试过程。

Handles 可以用来绘制各种辅助图形，如点、线、矩形、圆形、立方体等。

例如，可以用 Handles.DrawLine 来显示两个点之间的连线，或者用 Handles.DrawWireCube 绘制一个立方体的轮廓。

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(Transform))]
public class HandlesExample : Editor
{
    private void OnSceneGUI()
    {
    	// 绘制红色实心圆盘
        Handles.color = Color.red;
        Handles.DrawSolidDisc(new Vector3(0, 0, 0), Vector3.up, 0.5f); 

		// 绘制绿色线段
        Handles.color = Color.green;
        Handles.DrawLine(Vector3.zero, new Vector3(1, 1, 0)); 
		
		// 绘制蓝色矩形
        Handles.color = Color.blue;
        Handles.DrawSolidRectangleWithOutline(new Rect(1, 0, 1, 1), Color.blue, Color.black); 

		// 绘制圆环
        Handles.color = Color.cyan;
        Handles.DrawWireDisc(new Vector3(3, 0, 0), Vector3.up, 0.5f); 

		//绘制三维坐标
        Handles.color = Color.red;
        Handles.ArrowHandleCap(0, new Vector3(4, 0, 0), Quaternion.LookRotation(Vector3.right), 1.0f, EventType.Repaint); 
        Handles.color = Color.green;
        Handles.ArrowHandleCap(0, new Vector3(4, 0, 0), Quaternion.LookRotation(Vector3.up), 1.0f, EventType.Repaint); 
        Handles.color = Color.blue;
        Handles.ArrowHandleCap(0, new Vector3(4, 0, 0), Quaternion.LookRotation(Vector3.forward), 1.0f, EventType.Repaint); 

		// 绘制立方体轮廓
        Handles.color = Color.magenta;
        Handles.DrawWireCube(new Vector3(6, 0, 0), new Vector3(1, 1, 1)); 

		// 绘制文本标签
        Handles.color = Color.white;
        Handles.Label(Vector3.zero, "Hello, Handles!"); 
    }
}

以下案例中展示了一些常见的元素的绘制，比如：线段、立方体、圆环、矩形、圆盘、坐标箭头、标签等元素

三、常驻辅助UI 之场景视图菜单系统

1、场景视图菜单系统

场景视图菜单系统实现了一个自定义的菜单系统，可以在 Unity 编辑器的场景视图中动态添加、管理和显示菜单项。

通过这个系统，开发者可以利用 SceneViewMenuAttribute 特性标记静态方法，这些方法会被自动收集，并作为菜单项添加到场景视图中。

特性：

• 自动收集和添加菜单项

  在编辑器启动时，通过扫描所有程序集的静态方法，找到使用 SceneViewMenuAttribute 特性标记的方法，并将这些方法注册为菜单项。

• 场景视图中的菜单绘制

  使用 SceneView.duringSceneGui 事件，每次场景视图刷新时，自动绘制菜单。
  菜单支持多级结构，一级菜单显示在场景视图中，当选择某个一级菜单时，会显示其对应的二级菜单。

• 菜单项的管理

  菜单项使用 Dictionary 进行存储，每个一级菜单项对应一个子菜单项列表。
  可以通过简单的字符串定义菜单的层级关系，并为每个菜单项绑定一个 Action，以便在点击菜单项时执行相应的逻辑。

• 菜单状态控制

  每个菜单项有一个 isToggle 属性，表示当前菜单项是否被选中。选中的菜单项会以不同的颜色显示，便于用户区分当前激活的菜单。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using UnityEditor;
using UnityEngine;

/// <summary>
/// 场景视图中绘制行为菜单
/// </summary>
public static class SceneViewMenuDrawer
{
    private static Dictionary<ActionMenuItem, WindowActionItemList> MenuItems = new();

	 /// <summary>
	 /// 初始化场景视图菜单
	 /// </summary>
    [InitializeOnLoadMethod]
    private static void InitializeSceneMenuItems()
    {
        AppDomain.CurrentDomain.GetAssemblies()
        .SelectMany(assembly => assembly.GetTypes())
        .SelectMany(type => type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
        .Where(method => method.GetCustomAttributes(typeof(SceneViewMenuAttribute), false).Length > 0).ToList()
        .ForEach(method => {
            var attribute = method.GetCustomAttribute<SceneViewMenuAttribute>();
            var action = (Action)Delegate.CreateDelegate(typeof(Action), method);
            Add(attribute.MenuName, action);
        });
    }
    
    /// <summary>
    /// 绘制菜单
    /// </summary>
    [InitializeOnLoadMethod]
    private static void DrawActionMenus()
    {
        SceneView.duringSceneGui += (SceneView sceneView) =>
        {
            Handles.BeginGUI();

            EditorGUILayout.BeginHorizontal();

            DrawActionMenuFirstLevel();

            DrawActionMenuSecondLevel();

            GUILayout.FlexibleSpace();

            EditorGUILayout.EndHorizontal();

            Handles.EndGUI();
        };
    }

    /// <summary>
    /// 绘制一级菜单
    /// </summary>
    private static void DrawActionMenuFirstLevel()
    {
        GUIStyle style = new GUIStyle("Button") { wordWrap = true, contentOffset = new Vector2(0, -6), };

        EditorGUILayout.BeginVertical();
        foreach (var item in MenuItems)
        {
            GUIContent content = new GUIContent(item.Key.actionName);

            GUI.color = item.Key.isToggle ? Color.white : new Color(0.6f, 0.6f, 0.6f);

            if (GUILayout.Button(content, style, GUILayout.Width(22), GUILayout.Height(style.CalcHeight(content, 22))))
            {
                SelectToggleChanged(item.Key);

                if (item.Value.Count == 0)
                    item.Key.action?.Invoke();
            }

            GUI.color = Color.white;
        }
        EditorGUILayout.EndVertical();
    }

    /// <summary>
    /// 绘制二级菜单
    /// </summary>
    private static void DrawActionMenuSecondLevel()
    {
        foreach (var item in MenuItems)
        {
            if (item.Key.isToggle)
                item.Value.DrawActionItems();
        }
    }

    /// <summary>
    /// 选择改变
    /// </summary>
    /// <param name="actionMenu"></param>
    public static void SelectToggleChanged(ActionMenuItem actionMenu)
    {
        foreach (var item in MenuItems)
        {
            item.Key.isToggle = item.Value.Count == 0 ? false : (item.Key == actionMenu ? !item.Key.isToggle : false);
        }
    }

    /// <summary>
    /// 添加菜单
    /// </summary>
    /// <param name="menu"></param>
    /// <param name="action"></param>
    public static void Add(string menu, Action action = null)
    {
        Match match = Regex.Match(menu, @"^(.*)/(.*)$|^(.*)$");
        if (match.Success)
        {
            List<Group> groups = match.Groups.Where(item => !string.IsNullOrEmpty(item.Value)).ToList();

            ActionMenuItem item = MenuItems.Keys.FirstOrDefault(item => item.actionName == groups[1].Value);

            if (item == null)
            {
                item = new ActionMenuItem(groups[1].Value, action);
                MenuItems[item] = new WindowActionItemList();
            }

            if (groups.Count > 2)
            {
                if (!MenuItems[item].IsContainActionItem(groups[2].Value))
                {
                    MenuItems[item].Add(new ActionMenuItem(groups[2].Value, action));
                }
            }
        }
    }

    /// <summary>
    /// 行为菜单项
    /// </summary>
    public class ActionMenuItem
    {
        public bool isToggle { get; set; }
        public string actionName { get; set; }
        public Action action { get; set; }

        public ActionMenuItem(string name, Action action)
        {
            this.actionName = name;
            this.action = action;
        }
    }
}

/// <summary>
/// 行为菜单列表
/// </summary>
public class WindowActionItemList : List<SceneViewMenuDrawer.ActionMenuItem>
{
	/// <summary>
	/// 绘制行为菜单项
	/// </summary>
    public void DrawActionItems()
    {
        if (Count == 0) return;

        EditorGUILayout.BeginVertical(new GUIStyle("Label") { normal = new GUIStyle("TextField").normal }, GUILayout.Height(24 * Count + 5 * Count));

        GUI.color = new Color(0, 1, 0, 0.8f);

        foreach (var component in this)
        {
            EditorGUILayout.Space(2.5F);

            if (GUILayout.Button(component.actionName, GUILayout.Width(120), GUILayout.Height(24)))
            {
                component.action?.Invoke();
            }
            EditorGUILayout.Space(2.5F);
        }

        GUI.color = Color.white;

        EditorGUILayout.EndVertical();
    }
	
	/// <summary>
	/// 是否包含行为菜单
	/// </summary>
	/// <param name="itemName"></param>
	/// <returns></returns>
    public bool IsContainActionItem(string itemName)
    {
        return this.FirstOrDefault(itme => itme.actionName == itemName) != null;
    }
}

这个系统通过自动化和结构化的方式，简化了在 Unity 场景视图中添加和管理自定义菜单的过程。

开发者只需要在方法上添加 SceneViewMenuAttribute 特性，就能轻松将功能集成到场景视图的菜单中，大大提高了开发效率。

2、自定义场景菜单特性SceneViewMenuAttribute

添加一个属性特性SceneViewMenuAttribute ，用于标记需要被添加到场景菜单中的静态方法，其中MenuName为菜单路径。

当静态方法被该特性标记时，并传入菜单路径，会在场景中创建该菜单，当点击该菜单时会执行这个静态方法。

using System;
using UnityEngine;

/// <summary>
/// 自定义场景菜单特性
/// </summary>
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class SceneViewMenuAttribute : PropertyAttribute
{
    public string MenuName { get; }

    public SceneViewMenuAttribute(string menuName)
    {
        MenuName = menuName;
    }
}

3、添加菜单到场景中

可以通过SceneViewMenuDrawer.Add()直接向场景中添加菜单，同时也可以在静态方法上添加特性SceneViewMenu来实现向场景中添加菜单，与特性MenuItem的用法类似。

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;
using SceneViewMenu.Editor;
using SceneViewMenu.Runtime;

/// <summary>
/// 场景菜单测试
/// </summary>
public class SceneViewMenuTest
{
    [InitializeOnLoadMethod]
    static void SceneExtension()
    {
        SceneViewMenuDrawer.Add("一级菜单", () => Debug.Log("一级菜单"));
        SceneViewMenuDrawer.Add("一级菜单1/设备树生成窗口", () => Debug.Log("设备树生成窗口"));
        SceneViewMenuDrawer.Add("一级菜单1/设备树信息同步窗口", () => Debug.Log("设备树信息同步窗口"));
        //SceneViewMenuDrawer.Add("一级菜单1/路径生成窗口", () => Debug.Log("路径生成窗口"));
        SceneViewMenuDrawer.Add("一级菜单1/组件存储重置窗口", () => Debug.Log("组件存储重置窗口"));
        //SceneViewMenuDrawer.Add("一级菜单2/测试读取数据");
        SceneViewMenuDrawer.Add("一级菜单2/测试Icon获取", () => Debug.Log("测试Icon获取"));
        SceneViewMenuDrawer.Add("一级菜单3/右键菜单功能", () => Debug.Log("右键菜单功能"));
        //SceneViewMenuDrawer.Add("一级菜单4/一级菜单5/只能显示二级菜单", () => Debug.Log("只能显示二级菜单"));
    }

    [SceneViewMenu("一级菜单1/路径生成窗口")]
    static void Test1()
    {
        Debug.Log("路径生成窗口");
    }

    [SceneViewMenu("一级菜单2/测试读取数据")]
    static void Test2()
    {
        Debug.Log("测试读取数据");
    }

    [SceneViewMenu("一级菜单4/一级菜单5/只能显示二级菜单")]
    static void Test3()
    {
        Debug.Log("只能显示二级菜单");
    }
}
#endif

通过Add和特性往场景中添加菜单：

• 一级菜单
• 一级菜单1/设备树生成窗口
• 一级菜单1/设备树信息同步窗口
• 一级菜单1/路径生成窗口
• 一级菜单1/组件存储重置窗口
• 一级菜单2/测试读取数据
• 一级菜单2/测试Icon获取
• 一级菜单3/右键菜单功能
• 一级菜单4/一级菜单5/只能显示二级菜单

四、项目地址

以下是项目地址，已经整理成了Package包，有需要的小伙伴门可以自取:

https://gitcode.com/CTLittleNewbie/com.fxb.sceneviewmenuext_v1.0.0/overview