Unity编辑器扩展-引用查询

已于 2023-02-16 14:38:57 修改
阅读量424 收藏 5
点赞数 2
分类专栏： Unity 文章标签： unity 编辑器
于 2023-02-16 14:16:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a604263644/article/details/129060697
版权

不知道大伙有没有遇到这种情况，很久以前做的项目，公司突然提需求需要改改逻辑或者什么东西，你已经忘了哪个脚本里用了这个东西。
等你理完逻辑，可能几个小时或者半天就过去了~
我就经常遇到这种需求…所以后面就整了这个扩展工具（适用于直接拖拽的引用，Transfrom.Find(“xxx”)找不到）
对着你要查询的component右键，查询引用=》就会列出哪里用了这个脚本，及调用了这个脚本里的各种函数等。
截图如下
查询设置截图
查询结果截图（方法名，关联的对象，方法参数）
在这里插入图片描述
代码如下

using Newtonsoft.Json;
using Sirenix.OdinInspector;
using Sirenix.OdinInspector.Editor;
using Sirenix.Utilities;
using Sirenix.Utilities.Editor;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using UnityEditor;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

namespace YjjTool
{
    public class Yjj_ReferenceWindows : OdinMenuEditorWindow
    {
        public static Yjj_ReferenceWindows Instance
        {
            get { var window = GetWindow<Yjj_ReferenceWindows>(); window.Show(); return window; }
        }

        [Header("查询的脚本")]
        public Component script;
        [LabelText("全局查询")]
        public bool globleSearch = false;
        [Header("查询的父节点"), HideIf("globleSearch")]
        public List<Transform> searchRoots = new List<Transform>();
        [LabelText("查找组件的transfrom和Gameobject")]
        public bool transAndGameobj = true;
        [LabelText("查找组件的父节点引用")]
        public bool findParent = false;
        [LabelText("查找事件对该脚本的引用")]
        public bool findEventReference = true;
        [LabelText("查找事件参数"),ShowIf("findEventReference")]
        public bool findEventArgs = true;
        [LabelText("查找字段对该脚本的引用")]
        public bool findObjectReference = true;

        [MenuItem("Yjj/查找场景中的引用")]
        private static void Open()
        {
            GetWindow<Yjj_ReferenceWindows>().Show();
        }
        private Dictionary<string, EventReferenceInfo> dic = new Dictionary<string, EventReferenceInfo>();
        private ObjReferenceInfo obj;
        private Transform scriptTrans;
        private GameObject scriptGO;
        private Transform parentTrans;
        private GameObject parentGO;
        private ObjReferenceInfo parentReference;


        [Button]
        public  void Search()
        {
            //Debug.Log(typeof(CenterEvent).IsSubclassOf(typeof(UnityEventBase)));
            var removes = searchRoots.Where(x => x == null).ToArray();
            foreach (var remove in removes)
            {
                searchRoots.Remove(remove);
            }
            if (searchRoots.Count == 0 && !globleSearch)
            {
                if (EditorUtility.DisplayDialog("空查询", "当前没有添加查询的父节点,是否需要开启全局查询", "开启", "取消"))
                {
                    globleSearch = true;
                }
                else
                {
                    return;
                }
            }
            if (script == null) return;
            if (transAndGameobj)
            {
                scriptTrans = script.transform;
                scriptGO = script.gameObject;
            }
            dic.Clear();
            List<Task> tasks = new List<Task>();
            if (findObjectReference)
            {
                obj = new ObjReferenceInfo
                {
                    objName = script.GetType().Name,
                    goName = script.gameObject.name
                };
            }
            if (findParent)
            {
                parentReference = new ObjReferenceInfo();
                parentTrans = script.transform.parent;
                if (parentTrans != null)
                {
                    parentGO = parentTrans.gameObject;
                    parentReference.objName = parentGO.name;
                }
            }
            var transforms = new List<Transform>();
            if (globleSearch)
            {
                for (int i = 0; i < SceneManager.sceneCount; i++)
                {
                    transforms = Resources.FindObjectsOfTypeAll<Transform>()
                     .Where(x => !EditorUtility.IsPersistent(x.root.gameObject) && !(x.gameObject.hideFlags == HideFlags.HideAndDontSave || x.gameObject.hideFlags == HideFlags.NotEditable) && x.gameObject.scene.isLoaded)
                     .ToList();
                }
            }
            else
            {
                foreach (Transform t in searchRoots)
                {
                    if (t == null) continue;
                    transforms.AddRange(t.GetComponentsInChildren<Transform>());
                }
            }

            int length = transforms.Count;
            for (int i = 0; i < length; i++)
            {
                var arr = transforms[i].GetComponents<Component>();
                EditorUtility.DisplayProgressBar("搜索进度", $"{i + 1}/{length}", (i + 1f) / length);
                for (int k = 0; k < arr.Length; k++)
                {
                    var c = arr[k];
                    if(c == null)
                    {
                        continue;
                    }
                    var goName = script.gameObject.name;
                    tasks.Add(Task.Run(() =>
                    {
                        try
                        {
                            Find(c, goName);
                        }
                        catch(Exception e)
                        {
                            Debug.LogException(e);
                        }
                    }));
                }
            }
            Task.WaitAll(tasks.ToArray());
            EditorUtility.ClearProgressBar();
            if (MenuTree == null)
            {
                ForceMenuTreeRebuild();
            }
            MenuTree.MenuItems.Clear();
            MenuTree.Add("查询设置", this);
            int menuIndex = 0;
            foreach (var key in dic.Keys)
            {
                dic.TryGetValue(key, out var data);
                MenuTree.Add(key, data);
                menuIndex++;
            }
            if (findParent && parentReference.list.Count > 0)
            {
                MenuTree.Add("父节点引用", parentReference);
                menuIndex++;
            }
            if (findObjectReference && obj.list.Count > 0)
            {
                MenuTree.Add("组件引用", obj);
                menuIndex++;
            }
            MenuTree.MenuItems[menuIndex].Select();
            GC.Collect();
        }
        private EventReferenceInfo GetInfo(string str,string goName)
        {
            if (dic.TryGetValue(str, out var info))
            {

            }
            else
            {
                info = new EventReferenceInfo
                {
                    eventName = str,
                    goName = goName,
                };
                dic.Add(str, info);
            }
            return info;
        }
        private void Find(Component com, string goName)
        {
            var tp = com.GetType();
            var fileds = tp.GetFields();
            foreach (var field in fileds)
            {
                var value = field.GetValue(com);
                #region 查找事件
                if (findEventReference)
                {
                    var baseType = typeof(UnityEventBase);
                    if (field.FieldType.IsSubclassOf(baseType))
                    {
                        UnityEventBase ue = field.GetValue(com) as UnityEventBase;
                        int length = ue.GetPersistentEventCount();
                        List<string> objs = new List<string>();
                        if (length > 0 && findEventArgs)
                        {
                            //持久化事件
                            var fieldInfo = baseType.GetField("m_PersistentCalls", BindingFlags.NonPublic | BindingFlags.Instance);
                            var m_PersistentCalls = fieldInfo.GetValue(ue);
                            fieldInfo = fieldInfo.FieldType.GetField("m_Calls", BindingFlags.NonPublic | BindingFlags.Instance);
                            var calls = fieldInfo.GetValue(m_PersistentCalls);
                            var list = calls as IEnumerable<object>;
                            foreach (var item in list)
                            {
                                var itemType = item.GetType();
                                var mode = itemType.GetField("m_Mode", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(item).ToString();
                                var argumentsType = itemType.GetField("m_Arguments", BindingFlags.NonPublic | BindingFlags.Instance);
                                var arguments = argumentsType.GetValue(item);
                                //foreach(var f in arguments.GetType().GetFields( BindingFlags.NonPublic | BindingFlags.Instance))
                                //{
                                //    Debug.Log(f);
                                //}
                                FieldInfo resultInfo = null;
                                if (mode == "String")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_StringArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                }
                                else if (mode == "Bool")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_BoolArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                }
                                else if (mode == "Float")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_FloatArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                }
                                else if (mode == "Int")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_IntArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                }
                                else if (mode == "Object")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_ObjectArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                    var result = resultInfo.GetValue(arguments);
                                    string temp = null;
                                    if (result == null)
                                    {
                                        temp = "Null";
                                    }
                                    else
                                    {
                                        temp = resultInfo.FieldType.ToString();
                                    }
                                    objs.Add(temp);
                                    continue;
                                }
                                objs.Add(resultInfo == null ? null : resultInfo.GetValue(arguments).ToString());
                            }
                        }
                        for (int i = 0; i < length; i++)
                        {
                            var target = ue.GetPersistentTarget(i);
                            if (target == script)
                            {
                                var method = ue.GetPersistentMethodName(i);
                                var info = GetInfo(method, goName);
                                //var methedinfo = UnityEventBase.GetValidMethodInfo(target, method, Type.EmptyTypes);
                                info.Add(field, com, objs.Count > i ? objs[i] : null);
                            }
                            else if (transAndGameobj && (target == scriptTrans || target == scriptGO))
                            {
                                 var method = ue.GetPersistentMethodName(i);
                                 var info = GetInfo(method, goName);
                                 info.Add(field, com, objs.Count > i ? objs[i] : null);
                            }
                        }
                    }
                }
                #endregion
                //查找字段
                if (findObjectReference)
                {

                    var st = script.GetType();
                    #region 查找该组件的transform和gameobject
                    if (transAndGameobj)
                    {
                        if(st != typeof(RectTransform) && value == (object)scriptTrans)
                        {
                            obj.Add(field, com);
                        }
                        if (value == (object)scriptGO)
                        {
                            obj.Add(field, com);
                        }
                        if (typeof(System.Collections.IList).IsAssignableFrom(field.FieldType))
                        {
                            var arr = field.FieldType.GenericTypeArguments;
                            if (arr.Length == 1 && (arr[0] == typeof(Transform) || arr[0] == typeof(GameObject)))
                            {
                                var list = value as IList;
                                foreach (var l in list)
                                {
                                    if (l == (object)scriptTrans || (object)scriptGO == l)
                                    {
                                        obj.Add(field, com);
                                    }
                                }
                            }
                        }

                    }
                    #endregion
                    if ((object)value == script)
                    {
                        obj.Add(field, com);
                    }
                    #region 查找list属性是否包含该类型
                    if (typeof(IList).IsAssignableFrom(field.FieldType))
                    {
                        var arr = field.FieldType.GenericTypeArguments;
                        if (arr.Length == 1 && (arr[0] == st))
                        {
                            var list = value as IList;
                            foreach (var l in list)
                            {
                                if (l == (object)script)
                                {
                                    obj.Add(field, com);
                                }
                            }
                        }
                    }
                    #endregion
                }
                #region 查找父物体
                if (findParent && parentTrans != null)
                {
                    if (value == (object)parentTrans || value == (object)parentGO)
                    {
                        parentReference.Add(field, com);
                    }
                    if (typeof(System.Collections.IList).IsAssignableFrom(field.FieldType))
                    {
                        var arr = field.FieldType.GenericTypeArguments;
                        if (arr.Length == 1 && (arr[0] == typeof(Transform) || arr[0] == typeof(GameObject)))
                        {
                            var list = value as IList;
                            foreach (var l in list)
                            {
                                if (l == (object)parentTrans || (object)parentGO == l)
                                {
                                    parentReference.Add(field, com);
                                }
                            }
                        }
                    }
                }
            }
            #endregion
            var propers = tp.GetProperties();
            foreach (PropertyInfo property in propers)
            {
                #region 查找事件

                if (findEventReference)
                {
                    var baseType = typeof(UnityEventBase);
                    if (property.PropertyType.IsSubclassOf(baseType))
                    {
                        UnityEventBase ue = property.GetValue(com) as UnityEventBase;
                        int length = ue.GetPersistentEventCount();
                        List<string> objs = new List<string>();
                        if (length > 0 && findEventArgs)
                        {
                            //持久化事件
                            var fieldInfo = baseType.GetField("m_PersistentCalls", BindingFlags.NonPublic | BindingFlags.Instance);
                            var m_PersistentCalls = fieldInfo.GetValue(ue);
                            fieldInfo = fieldInfo.FieldType.GetField("m_Calls", BindingFlags.NonPublic | BindingFlags.Instance);
                            var calls = fieldInfo.GetValue(m_PersistentCalls);
                            var list = calls as IEnumerable<object>;
                            foreach(var item in list)
                            {
                                var itemType = item.GetType();
                                var mode = itemType.GetField("m_Mode", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(item).ToString();
                                var argumentsType = itemType.GetField("m_Arguments", BindingFlags.NonPublic | BindingFlags.Instance);
                                var arguments = argumentsType.GetValue(item);
                                //foreach(var f in arguments.GetType().GetFields( BindingFlags.NonPublic | BindingFlags.Instance))
                                //{
                                //    Debug.Log(f);
                                //}
                                FieldInfo resultInfo = null;
                                if (mode == "String")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_StringArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                }
                                else if (mode == "Bool")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_BoolArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                }
                                else if (mode == "Float")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_FloatArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                }
                                else if (mode == "Int")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_IntArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                }
                                else if (mode == "Object")
                                {
                                    resultInfo = argumentsType.FieldType.GetField("m_ObjectArgument", BindingFlags.NonPublic | BindingFlags.Instance);
                                    var result = resultInfo.GetValue(arguments);
                                    string temp = null;
                                    if(result == null)
                                    {
                                        temp = "Null";
                                    }
                                    else
                                    {
                                        temp = resultInfo.FieldType.ToString();
                                    }
                                    objs.Add(temp);
                                    continue;
                                }
                                objs.Add(resultInfo == null?null:resultInfo.GetValue(arguments).ToString());
                            }
                        }

                        for (int i = 0; i < length; i++)
                        {
                            var target = ue.GetPersistentTarget(i);
                            if (target == script)
                            {
                                var method = ue.GetPersistentMethodName(i);
                                EventReferenceInfo info = GetInfo(method, goName);
                                info.Add(property, com, objs.Count > i ? objs[i] : null);
                            }else if (transAndGameobj && (target == scriptTrans || target == scriptGO))
                            {
                                var method = ue.GetPersistentMethodName(i);
                                var info = GetInfo(method, goName);
                                info.Add(property, com, objs.Count > i ? objs[i] : null);
                            }
                        }
 
                    }
                }
                #endregion
            }
        }

        protected override OdinMenuTree BuildMenuTree()
        {
            if(MenuTree == null)
            {
                var tree = new OdinMenuTree();
                tree.Add("查询设置", this);
                return tree;
            }
            else
            {
                return MenuTree;
            }
        }
        #region 数据
        public class EventReferenceInfo
        {
            [HideInInspector]
            public string eventName;
            [HideInInspector]
            public string goName;

            [Title("@eventName", TitleAlignment = TitleAlignments.Centered, HorizontalLine = true, Bold = true, Subtitle = "@goName"), HideLabel]
            [TableList(AlwaysExpanded = true, CellPadding = 5, HideToolbar = true, ShowIndexLabels = false, IsReadOnly = true)]
            public List<ReferenceDetail> list = new List<ReferenceDetail>();

            //[LabelText("引用情况"), HorizontalGroup("use")]
            //public List<string> useInfos = new List<string>();
            //[LabelText("有引用该方法的物体"), HorizontalGroup("use")]
            //public List<Component> gos = new List<Component>();

            public void Add(MemberInfo field, Component com,string args,string details = null)
            {
                var attribute = field.GetCustomAttributes(typeof(LabelTextAttribute), true);
                if (attribute.Length > 0)
                {
                    list.Add(new ReferenceDetail(field.Name, com,args, (attribute[0] as LabelTextAttribute).Text));
                }
                else
                {
                    list.Add(new ReferenceDetail(field.Name, com,args,null));
                }
            }
        }
        public class ObjReferenceInfo
        {
            [HideInInspector]
            public string objName;
            [HideInInspector]
            public string goName;
            [Title("@objName",TitleAlignment = TitleAlignments.Centered,HorizontalLine = true,Bold =true,Subtitle ="@goName")]
            [HideLabel]
            [TableList(AlwaysExpanded = true,CellPadding = 5,HideToolbar =true,ShowIndexLabels =false,IsReadOnly =true)]
            public List<ReferenceDetail> list = new List<ReferenceDetail>();
            public void Add(FieldInfo field, Component com)
            {
                var attribute = field.GetCustomAttributes(typeof(LabelTextAttribute), true);
                if (attribute.Length > 0)
                {
                    //  obj.useInfos.Add((attribute[0] as LabelTextAttribute).Text);
                   list.Add(new ReferenceDetail( field.Name, com, (attribute[0] as LabelTextAttribute).Text));
                }
                else
                {
                    //  obj.useInfos.Add(field.Name);
                    list.Add(new ReferenceDetail(field.Name, com));
                }
            }
        }
        [System.Serializable]
        public class ReferenceDetail
        {
            [VerticalGroup("属性名"),HideLabel, ShowIf("@string.IsNullOrEmpty(descript)")]
            public string fieldName;

            [VerticalGroup("属性名"),HideLabel,HideIf("@string.IsNullOrEmpty(descript)")]
            public string descript;

            public Component component;

            [ShowIf("@args!=null")]
            public string args = null;

            [Button("打开脚本"),TableColumnWidth(200,resizable:false),ButtonGroup("操作")]
            private async void Open()
            {
                var type = component.GetType();
                var str = AssetDatabase.FindAssets($"{type.Name}")[0];
                var path = AssetDatabase.GUIDToAssetPath(str);
                var target = AssetDatabase.LoadAssetAtPath<MonoScript>(path);
                var resultPath = PathUtility.GetFullPath(path);
                int i = 0;
                await Task.Run(() =>
                {
                    using (StreamReader sr = new StreamReader(resultPath))
                    {
                        string line;
                        var targetInfo = fieldName;
                        while ((line = sr.ReadLine()) != null)
                        {
                            if (Regex.IsMatch(line, $"\\b{targetInfo}\\b"))
                            {
                                break;
                            }
                            i++;
                        }
                    }
                });
                AssetDatabase.OpenAsset(target, i + 1);
            }
            [Button("打开面板"),ButtonGroup("操作")]
            private void Modefine()
            {
                var window = OdinEditorWindow.InspectObject(component);
                //var rect = window.position;
                //window.position = new Rect(rect.position, new Vector2(rect.width, 1600));
                window.position = GUIHelper.GetEditorWindowRect().AlignCenter(450,680);
            }
            public ReferenceDetail(string f,Component c,string dec = "")
            {
                fieldName = f;component = c;descript = dec;
            }
            public ReferenceDetail(string f, Component c,string obj,string dec = null)
            {
                
                fieldName = f; component = c;args = obj; descript = dec;
            }
        }
        #endregion
        [MenuItem("CONTEXT/Component/查找引用", priority = 1000)]
        private static void FindObj(MenuCommand command)
        {
            var window = Instance;
            window.script = (Component)command.context;
            window.Search();
        }

    }
}

需要odin插件，应该复制粘贴就能使用了，记得点赞哦！

BugerM
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity查找资源引用
12-06
查找资源引用（依赖）
Unity-Find-Script-References 查找脚本的引用
yinfourever的专栏
08-17 5539
背景： 有时候我们需要找出项目中所有的引用到某个脚本的地方（比如Prefabs/Scene GameObjects等）。当项目比较大时，手工寻找还是非常费时费力的事情。本文尝试通过插件自动搜索。 分析： 基本的思路是：首先筛选出项目中全部Prefab，加载每个Prefab并判断是否有挂载目标脚本，然后载入每个场景，判断场景中每个物体是否有挂载目标脚本，最后列出结果。 实现：
Unity 查找资源引用
StrayInWorld的博客
06-18 2990
Unity 查找资源引用
Unity Editor中查看某个资源的引用情况
w0100746363的专栏
12-04 1806
内容如题，即在Unity中查找某个资源被引用的情况，如图片或者字体之类在哪些场景或预设中被引用了，可以一一列出来。代码如下： public class ArtFindSet { public bool _onlyShowNoUsed; } public class ArtAssetsEx : EditorWindow { #region Init static ArtAssetsEx Instance; static List<string> _filePr
Unity 查找选定对象的引用
04-03
选定对象，查找所有的引用地方，目前可查找场景内对象身上的唯一引用和List内的引用，包含选定对象的所有脚本，和GameObject。
MissingReferencesUnity：一个Unity编辑器扩展，用于查找缺少的对象引用
02-04
MissingReferencesUnity：一个Unity编辑器扩展，用于查找缺少的对象引用
GameAndUnity-TechLib：游戏，Unity技术项目引用目录
02-22
（编辑器扩展，工作流改善） （基于Playable的简单强大的动画解决方案） （快速关卡原型制定解决方案） （基于C＃双端共享代码的分布式网络游戏开发框架） （简单强大的资源管理插件） （简单强大的UI解决方案...
Unity-3D-Asteroids：一个简单的Asteroids克隆。 在3D中
01-28
预制件使用和引用（编辑器与代码） 快速原型设计与稳健性 场景/资产结构 分析/测试/调试 选择IDE 源代码管理（Git + GitHub + ） Git：提交，同步，推/拉，叉，分支（合并/变基），还原 GitHub：存储库，问题，...
NodeCanvas 3.1.8.rar
04-21
● 具有所有预期专业功能的时尚而直观的可视化节点编辑器。 （全部撤销/重做、放大/缩小、迷你地图、多选、复制、复制/粘贴、JSON 导入/导出、群组、注释等） ● 图形、GameObject 和全局黑板变量，以创建可重复使用...
unity-utils:在我的项目中使用的一组单个脚本工具
03-06
我在gamedev的多年中...仅用于编辑器。 SingletonScriptableObject.cs-自引用ScriptableObject，可用于全局游戏设置等。 Closest.cs-用于查找组件数组最接近实例的扩展。 例如， Clock closestClock = listOfClocks.
unity脚本引用查找插件
08-08
一个可以查看整个场景中有哪些物体绑定了被查找脚本的插件，非常实用。
Unity中查找资源
是让你心动的博客呀~~
04-21 530
Unity中查找资源引用
Unity Editor扩展——查找UI预设中用到的所有图集
qq_38721111的博客
02-16 563
Unity Editor扩展——查找UI预设中用到的所有图集。 NGUI
UnityEditor编辑器扩展代码实现Project搜索的实现功能和切换Component等
大话程序员
02-23 863
UnityEditor扩展Find Type，查找类和替换类（Mono）
Unity Editor扩展——查找所有用到某个图集的预设
qq_38721111的博客
02-16 184
Unity Editor扩展——查找所有用到某个图集的预设。 Ngui
unity 编辑器Tool 查找某个场景下引用的所有脚本
qq_39231744的博客
08-28 1124
#if UNITY_EDITOR using System.Collections.Generic; using UnityEditor; using UnityEngine; /// <summary> /// 显示某个场景里所有相关的脚本 /// 点击其中一个脚本获得挂载这个脚本的物体或预制体 /// </summary> public class FindReference : EditorWindow { SceneAsset selectScene; Lis
【UnityEditor扩展】通过代码查找所有预制的两种方法
大话程序员
04-07 1040
方法一： public static List<GameObject> GetAllPrefabByAssetDatabase(params string[] path) { List<GameObject> _prefabList = new List<GameObject>(); string[] _guids = AssetDatabase.FindAssets("t:Prefab", path);
unity资源引用查找工具
knightpriest的专栏
10-22 224
最近学习unity open project项目，发现里边用了大量的scriptableObject，但是发现用这个很难查找。 记录一下找到的查找引用的工具 https://github.com/blueberryzzz/ReferenceFinderhttps://github.com/blueberryzzz/ReferenceFinder ...
Unity自定义工具之引用查找
SmillCool的博客
09-14 2316
unity 引用查找 预制体/场景
linqpad7 安装Unity相关扩展
最新发布
05-28
6. 如果你需要使用 Unity 编辑器中的类型和方法，例如 "EditorGUI" 和 "EditorGUILayout"，你需要安装 "UnityEditor" 扩展。安装方法与安装 "UnityEngine" 类似。 注意：在安装 Unity 相关扩展之前，确保你已经安装...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值