UnityEditor：通过反射实现的Class过滤器编辑器

最新推荐文章于 2024-05-24 17:36:09 发布
最新推荐文章于 2024-05-24 17:36:09 发布
阅读量1.9k 收藏 8
点赞数 1
分类专栏： Unity3D实用小工具 文章标签： unity 编辑器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ComplicatedCc/article/details/72900384
版权
之前因为策划有在Game运行模式时动态修改脚本，在退出后脚本参数保存的需求，用于在场景中动态地调整参数。研究了一下之前老外实现的一个插件PlayModePersist，也就是一个在运行模式下进行保存数据的插件。
PlayModePersist 这款插件不知道什么原因已经从Appstore下架了。有需要的同学可以自行下载。
通过阅读这款插件的源码，学到了两个比较有趣的实现：
1. 通过反射获取所有应用类，做成编辑器以供筛选。
2. 运行模式下，实时保存数据。

今天这篇文章就是学习第一个的方法。

首先，它完成后大概是这个样子的：


普通查找

模糊查找



关于编辑器的学习总结，由于本人很赖之前虽然一直想总结下，但是其实别人已经总结的很好啦，就一直搁置了。。。
想要学习的同学可以参考下面文章

上代码，注释了主要的功能模块 

using System;
using UnityEngine;
using UnityEditor;
using System.Reflection;
using System.Collections.Generic;
using System.Text.RegularExpressions;
 
public class FilterTestWindow : EditorWindow
{
    private const string mDefaultKey = "Filter_Test";
    private static List<FilterTestObject> mDefaultTypeList;
    private static List<string> mSelectedTypeList;
 
    string mSearchPath = "";        //检索字段
    Vector2 scrollPos;              //滚动条位置
    bool isShowOnlyEnabled = false; //仅显示选中的类
 
    [MenuItem("Window/Filter Test Settings")]
    static void Init()
    {
        if (mSelectedTypeList == null)
            LoadDefaults();
        FilterTestWindow window = (FilterTestWindow)EditorWindow.GetWindow(typeof(FilterTestWindow), true, "Filter Test");
        window.minSize = new Vector2(325, 300);   //限制最小尺寸
        //window.maxSize = new Vector2(325, 800); //限制最大尺寸
    }
 
    //通过EditorPrefs的key 收集选中类型信息
    static void LoadDefaults()
    {
        mSelectedTypeList = new List<string>();
        string rawDefaults = EditorPrefs.GetString(mDefaultKey);
        string[] classParts = rawDefaults.Split(new string[] { "|" }, StringSplitOptions.RemoveEmptyEntries);
 
        foreach (string classPart in classParts)
        {
            mSelectedTypeList.Add(classPart.Trim());
        }
    }
 
    public void OnEnable()
    {
        if (mDefaultTypeList == null)
        {
            mDefaultTypeList = new List<FilterTestObject>();
            Assembly asm = typeof(Component).Assembly;
            Dictionary<string, bool> tempTypeList = new Dictionary<string, bool>();
            string tempTypeName;
            string tempNamespace;
            string[] words;
 
            //加入选中类型  分离命名空间和类名
            foreach (string defaultTypeName in mSelectedTypeList)
            {
                words = defaultTypeName.Split('.');
                if (words.Length == 1)
                {
                    tempNamespace = "";
                    tempTypeName = defaultTypeName;
                }
                else
                {
                    tempNamespace = words[0];
                    tempTypeName = words[1];
                }
                mDefaultTypeList.Add(new FilterTestObject(tempNamespace, tempTypeName, true));
                tempTypeList.Add(tempTypeName, true);
            }
 
            //加入UnityEngine默认类型
            foreach (Type type in asm.GetTypes())
            {
                if (typeof(Component).IsAssignableFrom(type))
                {
                    if (type != typeof(Component) && type != typeof(Behaviour) && type != typeof(MonoBehaviour))
                    {
                        if (!tempTypeList.ContainsKey(type.Name))
                        {
                            mDefaultTypeList.Add(new FilterTestObject("UnityEngine", type.Name, false));
                            tempTypeList.Add(type.Name, false);
                        }
                    }
                }
            }
 
            //加入所有自定义类型
            Assembly[] currDomainAssemblies = AppDomain.CurrentDomain.GetAssemblies();
            string asmPath;
 
            foreach (Assembly currDomainAsm in currDomainAssemblies)
            {
                asmPath = currDomainAsm.CodeBase;
                if (asmPath.EndsWith("Assembly-UnityScript.dll") || asmPath.EndsWith("Assembly-CSharp.dll"))
                {
                    foreach (System.Type type in currDomainAsm.GetTypes())
                    {
                        if (typeof(MonoBehaviour).IsAssignableFrom(type))
                        {
                            if (!tempTypeList.ContainsKey(type.Name))
                            {
                                mDefaultTypeList.Add(new FilterTestObject("", type.Name, false));
                                tempTypeList.Add(type.Name, false);
                            }
                        }
                    }
                }
            }
 
            //按字母顺序排列
            SortList();
        }
    }
 
    private static void SortList()
    {
        FilterTestComparer comparer = new FilterTestComparer();
 
        mDefaultTypeList.Sort(comparer);
    }
 
    //绘制窗口
    public void OnGUI()
    {
        GUILayout.Label("Filter Test Window", EditorStyles.boldLabel);
        EditorGUILayout.Space();
        mSearchPath = EditorGUILayout.TextField(new GUIContent("Filter"), mSearchPath, GUILayout.Width(300.0f));
        EditorGUILayout.Space();
 
        //开始滚动条布局
        scrollPos = EditorGUILayout.BeginScrollView(scrollPos, false, false, GUILayout.Width(300), GUILayout.Height(position.height - 140));
        int listCount = 0;
 
        //加入简易正则筛选测试
        bool bRegexMode = false;
        Regex regex = null;
        string regexStr = "";
        if (mSearchPath.StartsWith("*"))
        {
            bRegexMode = true;
            regexStr = "\\w" + mSearchPath.Substring(1, mSearchPath.Length - 1).ToLower();
            regex = new Regex(regexStr);
        }
 
        foreach (FilterTestObject testObj in mDefaultTypeList)
        {
            //正则测试条件
            if (mSearchPath == "" || bRegexMode && regex.Match(testObj.TypeName.ToLower()).Success|| testObj.TypeName.ToLower().StartsWith(mSearchPath.ToLower()))
            //if (mSearchPath == "" || autoPersistObj.TypeName.ToLower().StartsWith(mSearchPath.ToLower()))
            {
                if (!isShowOnlyEnabled || testObj.IsSelected)
                {
                    GUILayout.BeginHorizontal(GUILayout.Width(250));
                    GUILayout.Label(testObj.TypeName, GUILayout.Width(200));
 
                    if (!testObj.IsSelected)
                    {
                        if (GUILayout.Button("Add"))
                        {
                            AddDefault(testObj.GetFullClassName());
                            testObj.IsSelected = true;
                            if (EditorApplication.isPlaying || EditorApplication.isPaused)
                            {
                                //Do Something...For Extension
                            }
                        }
                    }
                    else
                    {
                        if (GUILayout.Button("Remove"))
                        {
                            RemoveDefault(testObj.GetFullClassName());
                            testObj.IsSelected = false;
                            if (EditorApplication.isPlaying || EditorApplication.isPaused)
                            {
                                //Do Something...For Extension
                            }
                        }
                    }
                    GUILayout.EndHorizontal();
                    listCount++;
                }
            }
        }
 
        //筛选提示
        if (listCount == 0)
        {
            if (isShowOnlyEnabled && mSearchPath == "")
            {
                GUILayout.Label("No Components Are Selected");
            }
            else
            {
                GUILayout.Label("Please Broaden Your Search");
            }
        }
        EditorGUILayout.EndScrollView();
        EditorGUILayout.Space();
 
        EditorGUILayout.BeginHorizontal();
        GUILayout.Label("Show Only Enabled");  //仅显示选中类
        isShowOnlyEnabled = EditorGUILayout.Toggle(isShowOnlyEnabled, GUILayout.ExpandWidth(true));
        EditorGUILayout.EndHorizontal();
        EditorGUILayout.Space();
 
        EditorGUILayout.BeginHorizontal();
        if (mSelectedTypeList.Count > 0)
        {
            EditorGUILayout.Space();
            if (GUILayout.Button("Remove All"))//移除所有选中
            {
                foreach (FilterTestObject obj in mDefaultTypeList)
                {
                    if (obj.IsSelected)
                    {
                        RemoveDefault(obj.GetFullClassName());
                        obj.IsSelected = false;
                    }
                }
            }
        }
        EditorGUILayout.Space();
        if (GUILayout.Button("Print"))        //简易拓展功能 打印所有选中类型
        {
            foreach (FilterTestObject obj in mDefaultTypeList)
            {
                if (obj.IsSelected)
                {
                    Debug.Log(obj.GetFullClassName());
                }
            }
        }
        EditorGUILayout.Space();
        EditorGUILayout.EndHorizontal();
        EditorGUILayout.Space();
    }
 
    public static void AddDefault(string className)
    {
        if (!mSelectedTypeList.Contains(className))
        {
            mSelectedTypeList.Add(className);
            SaveDefaults();
        }
    }
 
    public static void RemoveDefault(string className)
    {
        if (mSelectedTypeList.Contains(className))
        {
            mSelectedTypeList.Remove(className);
            SaveDefaults();
        }
    }
 
    //保存信息到EditorPrefs
    private static void SaveDefaults()
    {
        string defaultStr = string.Join("|", mSelectedTypeList.ToArray());
        EditorPrefs.SetString(mDefaultKey, defaultStr);
    }
}
 
public class FilterTestObject
{
    private string typeName;
    private string namespaceStr;
 
    private bool isSelected;
    public bool IsSelected
    {
        get { return isSelected; }
        set { isSelected = value; }
    }
 
    public FilterTestObject(string namespaceStr, string typeName, bool bSelected)
    {
        this.typeName = typeName;
        this.namespaceStr = namespaceStr;
        this.isSelected = bSelected;
    }
    public string TypeName
    {
        get { return typeName; }
    }
 
    public string GetFullClassName()
    {
        if (namespaceStr.Length > 0) return namespaceStr + "." + typeName;
        else return typeName;
    }
}
 
public class FilterTestComparer : IComparer<FilterTestObject>
{
    public int Compare(FilterTestObject x, FilterTestObject y)
    {
        if (x == null) return (y == null ? 0 : -1);
        if (y == null) return 1;
        return x.TypeName.CompareTo(y.TypeName);
    }
}

将以上脚本放在Editor文件夹下即可使用。



测试中用的是比较简单的正则做的模糊查找（其实只是蛋疼添加的功能），还有加入、移除按钮后的特殊处理大家可以自行扩展。

插件中的作用是，将选中类型注册到需要保存类型的List中，在结束运行模式后筛选的类型数据将会实时通过PropertyInfo、FieldInfo进行保存


在运行模式下保存数据的功能将在下篇文章补上 :)

已更新：

 Unity3D 如何在退出运行模式后保存修改数据


ComplicatedCc
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用C#反射机制从UnityEditor扒东西
songchao_xx的博客
11-26 1474
UnityEditor内置的一些编辑窗口有一些不方便的地方，想改有没有开放的接口，想起ulua用反射机导出了UnityEngine，受了启发，写点东西扒一下UnityEditor.dll。 首先需要ILSpy，在这个工具面前，Unity的c#的代码基本是裸体，想看哪里看哪里~ 下载地址 http://ilspy.net/ 找到并打开UnityEditor.dll，选中要导出的文件，sav
Unity3D 如何在退出运行模式后保存修改数据
热门推荐
ComplicatedCc的博客
06-08 1万+
本文介绍了Unity如何在退出运行模式后，保存对组件参数的数据修改。
C# - AOP - 过滤器
最新发布
标准都是留给不爱的人，爱的本质是自由意志的沉沦
05-24 493
总之,AOP是一种新的编程思想,通过将横切功能与核心功能分离,提高了代码的可重用性和可维护性。它为程序员提供了一种更加灵活和高效的编程方式。这些过滤器可以在控制器类或全局范围内应用,并且可以组合使用以满足不同的需求。例如,你可以结合使用。连接点是程序执行过程中能够应用通知的一个点,如方法调用、异常抛出等。代理是AOP的实现方式之一,通过代理对象来实现对目标对象的功能增强。织入是把切面应用到目标对象并创建一个新的代理对象的过程。来实现更复杂的请求处理逻辑。连接点(Joinpoint)织入(Weaving)
UnityEditor编辑器扩展代码实现Project搜索的实现功能和切换Component等
大话程序员
02-23 882
UnityEditor扩展Find Type，查找类和替换类（Mono）
C#反射——掀起Unity Editor面纱
variyous的博客
06-06 606
很棒的Spy手法，对于深入使用Unity的强大API有重要意义。
Unity编辑器拓展之六：利用反射打开Unity Preferences Window
静风霁
04-05 2273
如何利用反射打开Unity Preferences Window Unity Preferences Window如下图所示： 作为Unity 的参数设置窗口，这个窗口支持新增项，当然本文不介绍这个内容，本次介绍如何利用反射、以及Unity Editor代码来实现用代码打开Preferences Window以及设置选中项。 使用ILSpy工具反编译UnityEditor.dll后呢，在...
Unity编辑器——日期选择窗口插件
10-11
总之，通过Unity的EditorWindow和GUI系统，我们可以轻松创建出具有日期选择功能的编辑器窗口。这不仅提高了开发效率，还使得项目更加模块化，易于维护。对于进阶的Unity开发者来说，掌握这类自定义编辑器扩展的技巧...
富文本编辑器vue2-editor实现全屏功能
12-11
* 编辑器的全屏实现 */ import noScroll from 'no-scroll' export default class Fullscreen { constructor (quill, options = {}) { this.quill = quill this.options = options this.fullscreen = false ...
h5-editor:一个 h5 页面 ui 编辑器
05-30
H5 Editor移动端页面 UI 生成器用于将设计稿样式转化为组件化的代码有时间会持续更新维护的 :grinning_face_with_smiling_eyes:使用者设计师：通过拖拽编辑，生成UI稿前端开发：划分模块、组件、重命名 class ----&...
react-monaco-editor：摩纳哥的React编辑器
02-05
React摩纳哥编辑 React的。 例子 要在本地构建示例，请运行： yarn cd example yarn yarn start 然后在浏览器中打开http://localhost:8886 。 安装 yarn add react-monaco-editor 与Webpack一起使用 import React ...
easy-editor:基于slate框架的富文本编辑器
05-02
简易编辑器 基于slate的富文本编辑器 快速开始 npm npm install @camol/easy-editor --save 纱 yarn add @camol/easy-editor -S 例子 git clone https://github.com/kanweiwei/easy-editor.git cd easy-editor ...
Unity-Save-Play-Mode-Changes：Unity工具，允许在停止游戏时恢复在游戏模式中所做的更改
02-06
在Unity中保存播放模式更改 Unity工具，允许在播放模式中所做的更改在返回到编辑模式时恢复。 用法 将SavePlayModeChanges组件添加到您要保存的所有层次结构的根目录中。 而已！ 方法 与其他工具（例如PlayModePersist）不同，这近似于将游戏对象从播放模式复制/粘贴到编辑模式的常见技巧。 我们找不到与Unity完全相同的方法，因此它主要使用UnityEngine.JSONUtility手动序列化和反序列化游戏对象层次结构。 它比手术刀更像是一把锤子，但尽管有缺点，但它可以节省大量时间，因此我们将其发布给任何人使用和改进。 此工具是实验性的。 如果出现问题，场
unity 反射编辑器
YanSl
02-25 512
using UnityEngine; using System.Collections.Generic; using UnityEditor; using System; using System.Linq; public class ReflectionEditor : Editor {     #region 继承链     [MenuItem("Reflection/
【Unity编辑器】使用反射和Attribute实现自定义右键菜单
MrASL的博客
07-10 4441
unity中使用自定义Attribute实现右键菜单
unity中反射的使用
hacker9403的博客
10-19 9766
反射 定义 动态获取类型信息,动态创建对象,动态访问成员的过程。 作用 在编译时无法了解类型，在运行时获取类型信息，创建对象，访问成员。 流程 1.得到数据类型 2.动态创建对象 3查看类型信息（了解本身信息,成员信息） 常用类 1.取得数据类型Type  方式一：Type.GetType(“类型全名”); 适合于类型的名称已知 方式二：obj
UnityEditor 反射事件2
YanSl
03-01 344
using UnityEngine; using System.Collections; using System.Reflection; using System.Collections.Generic;public class EventGraphManager : MonoBehaviour { // 一些节点类 纯信息的节点 private static List<BaseNod
Unity（十八）：利用反射来执行Unity编辑器的源码方法
You瞧谁不起 - 道不尽世间的沧桑，诉不完人生的悲凉
01-17 1291
查看编辑器源码（工具：ILSpy） 利用反射来执行图示Clear方法 [MenuItem("CustomTools/LogText")] private static void LogText() { Debug.Log("Hello Text ~~~"); } // 利用反射来执行 LogEntries.Clear() 方法 [MenuItem("CustomTools/ClearConsole")] private static void ClearConsole() { Asse
[图文]那些不易注意到的UNITY实用小功能
在那西天取经的路上。。。
03-14 747
Unity是一款十分易用的游戏引擎，上手并不困难——恐怕也正因如此，少有人会仔细阅读帮助文档对Unity编辑器的功能做一个全面细致的了解，而一些非常实用的小功能在日常使用中很难被发现，但它们对工作效率的提升是有不小的帮助的。AlmostLogical的Devin Reimer有感于此为大家列举了10条不易注意到的Unity实用小功能，在此翻译给大家，并对一些步骤补充了示意图。 1）锁定Ins
unity3d保存文件到本地and加载本地文件
ax1274669874的博客
11-26 3586
Unity3D游戏本地存储 Unity3D游戏本地存储玩家积分。Unity提供了一个类似配置文件的类，可以非常好的实现信息数据的存储，那就是PlayerPrefs。它可以存储：int、float和string类型。 // 存进去 PlayerPrefs.SetInt("key1", 10); PlayerPrefs.SetString("key2", aaaaaa); Playe
unity editor编辑器使用协程延时
06-07
在 Unity Editor 中使用协程可以通过使用 `EditorCoroutine` 类来实现。这个类可以让您在 Unity Editor 中使用协程来延时执行某些操作。 以下是一个使用协程延时的示例： ```csharp using UnityEditor; using ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值