Unity 编辑器开发实战【Editor Window】- Filter 物体筛选工具

    Unity开发工作中，在Hierarchy窗口搜索栏可以通过物体名称或组件名称对场景中的物体进行搜索，但是并不能满足我们一些其它的搜索要求，例如搜索指定Tag标签的物体，或者指定Layer层级的物体，或者指定Active状态的物体，或者更为复杂的一些搜索，比如我们想找到场景中所有隐藏的、且挂有Camera组件的、且标签为MainCamera的物体，这些都无法实现。

    今天分享一个作者为了解决上述搜索需求而开发的Filter物体筛选器：

​

    其中Target是指需要进行筛选的所有物体，All是指对场景中的所有物体进行筛选，也可以指定一个根级，对这个根物体的所有子物体进行筛选：

    确定好要进行筛选的物体后，下面来创建筛选条件：

1.Name 通过物体名称的关键字进行筛选

2.Component 通过组件进行筛选 -物体是否挂有指定组件

3.Layer 通过物体的Layer层级进行筛选

4.Tag 通过物体的Tag标签进行筛选

5.Active 通过物体的活跃状态进行筛选

    以上是单个条件的筛选方式，我们也可以创建复合条件，即多个条件对物体进行筛选，比如文章开始提到的，我们要找到场景中所有隐藏的、且挂有Camera组件的、且标签为MainCamera的物体，需要创建3个条件：1.Active活跃状态为false条件、2.Component组件为Camera条件、3.Tag标签为MainCamera条件

    最终点击Select按钮可以选中全部我们筛选出的符合条件的物体，以下是实现代码：

  1. using UnityEngine;
  2. using UnityEditor;
  3. using UnityEngine.SceneManagement;
  4.  
  5. using System;
  6. using System.Reflection;
  7. using System.Collections.Generic;
  8.  
  9. namespace SK.Framework
  10. {
  11.     /// 
  12.     /// 过滤类型
  13.     /// 
  14.     public enum FilterMode
  15.     {
  16.         Name, //根据名字筛选
  17.         Component, //根据组件筛选
  18.         Layer, //根据层级筛选
  19.         Tag, //根据标签筛选
  20.         Active, //根据是否活跃筛选
  21.         Missing, //丢失筛选
  22.     }
  23.     public enum MissingMode
  24.     {
  25.         Material, //材质丢失
  26.         Mesh, //网格丢失
  27.         Script //脚本丢失
  28.     }
  29.     [SerializeField]
  30.     public class FilterCondition
  31.     {
  32.         public FilterMode filterMode;
  33.         public MissingMode missingMode;
  34.         public string stringValue;
  35.         public int intValue;
  36.         public bool boolValue;
  37.         public Type typeValue;
  38.  
  39.         public FilterCondition(FilterMode filterMode, string stringValue)
  40.         {
  41.             this.filterMode = filterMode;
  42.             this.stringValue = stringValue;
  43.         }
  44.         public FilterCondition(FilterMode filterMode, int intValue)
  45.         {
  46.             this.filterMode = filterMode;
  47.             this.intValue = intValue;
  48.         }
  49.         public FilterCondition(FilterMode filterMode, bool boolValue)
  50.         {
  51.             this.filterMode = filterMode;
  52.             this.boolValue = boolValue;
  53.         }
  54.         public FilterCondition(FilterMode filterMode, Type typeValue)
  55.         {
  56.             this.filterMode = filterMode;
  57.             this.typeValue = typeValue;
  58.         }
  59.         public FilterCondition(FilterMode filterMode, MissingMode missingMode)
  60.         {
  61.             this.filterMode = filterMode;
  62.             this.missingMode = missingMode;
  63.         }
  64.         /// 
  65.         /// 判断物体是否符合条件
  66.         /// 
  67.         /// 物体
  68.         /// 符合条件返回true,否则返回false
  69.         public bool IsMatch(GameObject target)
  70.         {
  71.             switch (filterMode)
  72.             {
  73.                 case FilterMode.Name: return target.name.ToLower().Contains(stringValue.ToLower());
  74.                 case FilterMode.Component: return target.GetComponent(typeValue) != null;
  75.                 case FilterMode.Layer: return target.layer == intValue;
  76.                 case FilterMode.Tag: return target.CompareTag(stringValue);
  77.                 case FilterMode.Active: return target.activeSelf == boolValue;
  78.                 case FilterMode.Missing:
  79.                     switch (missingMode)
  80.                     {
  81.                         case MissingMode.Material:
  82.                             var mr = target.GetComponent();
  83.                             if (mr == null) return false;
  84.                             Material[] materials = mr.sharedMaterials;
  85.                             bool flag = false;
  86.                             for (int i = 0; i < materials.Length; i++)
  87.                             {
  88.                                 if(materials[i] == null)
  89.                                 {
  90.                                     flag = true;
  91.                                     break;
  92.                                 }
  93.                             }
  94.                             return flag;
  95.                         case MissingMode.Mesh:
  96.                             var mf = target.GetComponent();
  97.                             if (mf == null) return false;
  98.                             return  mf.sharedMesh == null;
  99.                         case MissingMode.Script:
  100.                             Component[] components = target.GetComponents();
  101.                             bool retV = false; 
  102.                             for (int i = 0; i < components.Length; i++)
  103.                             {
  104.                                 if(components[i] == null)
  105.                                 {
  106.                                     retV = true;
  107.                                     break;
  108.                                 }
  109.                             }
  110.                             return retV;
  111.                         default:
  112.                             return false;
  113.                     }
  114.                 default: return false;
  115.             }
  116.         }
  117.     }
  118.  
  119.     public sealed class Filter : EditorWindow
  120.     {
  121.         [MenuItem("SKFramework/Tools/Filter")]
  122.         private static void Open()
  123.         {
  124.             var window = GetWindow();
  125.             window.titleContent = new GUIContent("Filter");
  126.             window.Show();
  127.         }
  128.         //筛选的目标
  129.         private enum FilterTarget
  130.         {
  131.             All, //在所有物体中筛选
  132.             Specified, //在指定根级物体内筛选
  133.         }
  134.         private FilterTarget filterTarget = FilterTarget.All;
  135.         //存储所有筛选条件
  136.         private readonly List filterConditions = new List();
  137.         //指定的筛选根级
  138.         private Transform specifiedTarget;
  139.         //存储所有组件类型
  140.         private List components;
  141.         //存储所有组件名称
  142.         private List<string> componentsNames;
  143.         private readonly List selectedObjects = new List();
  144.         private Vector2 scroll = Vector2.zero;
  145.  
  146.         private void OnEnable()
  147.         {
  148.             components = new List();
  149.             componentsNames = new List<string>();
  150.             Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
  151.             for (int i = 0; i < assemblies.Length; i++)
  152.             {
  153.                 var types = assemblies[i].GetTypes();
  154.                 for (int j = 0; j < types.Length; j++)
  155.                 {
  156.                     if (types[j].IsSubclassOf(typeof(Component)))
  157.                     {
  158.                         components.Add(types[j]);
  159.                         componentsNames.Add(types[j].Name);
  160.                     }
  161.                 }
  162.             }
  163.         }
  164.         private void OnGUI()
  165.         {
  166.             OnTargetGUI();
  167.             scroll = EditorGUILayout.BeginScrollView(scroll);
  168.             OnConditionGUI();
  169.             OnIsMatchedGameObjectsGUI();
  170.             EditorGUILayout.EndScrollView();
  171.             OnFilterGUI();
  172.         }
  173.         private void OnTargetGUI()
  174.         {
  175.             filterTarget = (FilterTarget)EditorGUILayout.EnumPopup("Target", filterTarget);
  176.             switch (filterTarget)
  177.             {
  178.                 case FilterTarget.Specified:
  179.                     specifiedTarget = EditorGUILayout.ObjectField("Root", specifiedTarget, typeof(Transform), true) as Transform;
  180.                     break;
  181.             }
  182.             EditorGUILayout.Space();
  183.         }
  184.         private void OnConditionGUI()
  185.         {
  186.             if (GUILayout.Button("Create New Condition", "DropDownButton"))
  187.             {
  188.                 GenericMenu gm = new GenericMenu();
  189.                 gm.AddItem(new GUIContent("Name"), false, () => filterConditions.Add(new FilterCondition(FilterMode.Name, "GameObject")));
  190.                 gm.AddItem(new GUIContent("Component"), false, () => filterConditions.Add(new FilterCondition(FilterMode.Component, typeof(Transform))));
  191.                 gm.AddItem(new GUIContent("Layer"), false, () => filterConditions.Add(new FilterCondition(FilterMode.Layer, 0)));
  192.                 gm.AddItem(new GUIContent("Tag"), false, () => filterConditions.Add(new FilterCondition(FilterMode.Tag, "Untagged")));
  193.                 gm.AddItem(new GUIContent("Active"), false, () => filterConditions.Add(new FilterCondition(FilterMode.Active, true)));
  194.                 gm.AddItem(new GUIContent("Missing / Material"), false, () => filterConditions.Add(new FilterCondition(FilterMode.Missing, MissingMode.Material)));
  195.                 gm.AddItem(new GUIContent("Missing / Mesh"), false, () => filterConditions.Add(new FilterCondition(FilterMode.Missing, MissingMode.Mesh)));
  196.                 gm.AddItem(new GUIContent("Missing / Script"), false, () => filterConditions.Add(new FilterCondition(FilterMode.Missing, MissingMode.Script)));
  197.                 gm.ShowAsContext();
  198.             }
  199.             EditorGUILayout.Space();
  200.             if(filterConditions.Count > 0)
  201.             {
  202.                 GUILayout.BeginVertical("Badge");
  203.                 for (int i = 0; i < filterConditions.Count; i++)
  204.                 {
  205.                     var condition = filterConditions[i];
  206.                     GUILayout.BeginHorizontal();
  207.                     if(filterConditions.Count > 1)
  208.                         GUILayout.Label($"{i + 1}.", GUILayout.Width(30f));
  209.                     switch (condition.filterMode)
  210.                     {
  211.                         case FilterMode.Name:
  212.                             GUILayout.Label("Name", GUILayout.Width(80f));
  213.                             condition.stringValue = EditorGUILayout.TextField(condition.stringValue);
  214.                             break;
  215.                         case FilterMode.Component:
  216.                             var index = componentsNames.FindIndex(m => m == condition.typeValue.Name);
  217.                             GUILayout.Label("Component", GUILayout.Width(80f));
  218.                             var newIndex = EditorGUILayout.Popup(index, componentsNames.ToArray());
  219.                             if (index != newIndex) condition.typeValue = components[newIndex];
  220.                             break;
  221.                         case FilterMode.Layer:
  222.                             GUILayout.Label("Layer", GUILayout.Width(80f));
  223.                             condition.intValue = EditorGUILayout.LayerField(condition.intValue);
  224.                             break;
  225.                         case FilterMode.Tag:
  226.                             GUILayout.Label("Tag", GUILayout.Width(80f));
  227.                             condition.stringValue = EditorGUILayout.TagField(condition.stringValue);
  228.                             break;
  229.                         case FilterMode.Active:
  230.                             GUILayout.Label("Active", GUILayout.Width(80f));
  231.                             condition.boolValue = EditorGUILayout.Toggle(condition.boolValue);
  232.                             break;
  233.                         case FilterMode.Missing:
  234.                             GUILayout.Label("Missing", GUILayout.Width(80f));
  235.                             condition.missingMode = (MissingMode)EditorGUILayout.EnumPopup(condition.missingMode);
  236.                             break;
  237.                         default:
  238.                             break;
  239.                     }
  240.                     if (GUILayout.Button("×", "MiniButton", GUILayout.Width(20f)))
  241.                     {
  242.                         filterConditions.RemoveAt(i);
  243.                         return;
  244.                     }
  245.                     GUILayout.EndHorizontal();
  246.                 }
  247.                 GUILayout.EndVertical();
  248.             }
  249.             EditorGUILayout.Space();
  250.         }
  251.         private void OnIsMatchedGameObjectsGUI()
  252.         {
  253.             for (int i = 0; i < selectedObjects.Count; i++)
  254.             {
  255.                 GameObject obj = selectedObjects[i];
  256.                 if(obj == null)
  257.                 {
  258.                     selectedObjects.RemoveAt(i);
  259.                     i--;
  260.                     continue;
  261.                 }
  262.                 GUILayout.BeginHorizontal("IN Title");
  263.                 GUILayout.Label(obj.name);
  264.                 GUILayout.EndHorizontal();
  265.                 if (Event.current.type == EventType.MouseDown && GUILayoutUtility.GetLastRect().Contains(Event.current.mousePosition))
  266.                 {
  267.                     EditorGUIUtility.PingObject(obj);
  268.                 }
  269.             }
  270.             GUILayout.FlexibleSpace();
  271.         }
  272.         private void OnFilterGUI()
  273.         {
  274.             GUILayout.BeginHorizontal();
  275.             if (GUILayout.Button("Filter", "ButtonLeft"))
  276.             {
  277.                 selectedObjects.Clear();
  278.                 List targetGameObjects = new List();
  279.                 switch (filterTarget)
  280.                 {
  281.                     case FilterTarget.All:
  282.                         GameObject[] rootGameObjects = SceneManager.GetActiveScene().GetRootGameObjects();
  283.                         for (int i = 0; i < rootGameObjects.Length; i++)
  284.                         {
  285.                             var root = rootGameObjects[i];
  286.                             var allChildren = root.GetComponentsInChildren(true);
  287.                             for (int j = 0; j < allChildren.Length; j++)
  288.                             {
  289.                                 EditorUtility.DisplayProgressBar("Filter", allChildren[j].name, (float)i / rootGameObjects.Length);
  290.                                 targetGameObjects.Add(allChildren[j].gameObject);
  291.                             }
  292.                         }
  293.                         EditorUtility.ClearProgressBar();
  294.                         break;
  295.                     case FilterTarget.Specified:
  296.                         Transform[] children = specifiedTarget.GetComponentsInChildren(true);
  297.                         for (int i = 0; i < children.Length; i++)
  298.                         {
  299.                             EditorUtility.DisplayProgressBar("Filter", children[i].name, (float)i / children.Length);
  300.                             targetGameObjects.Add(children[i].gameObject);
  301.                         }
  302.                         EditorUtility.ClearProgressBar();
  303.                         break;
  304.                     default:
  305.                         break;
  306.                 }
  307.  
  308.                 for (int i = 0; i < targetGameObjects.Count; i++)
  309.                 {
  310.                     GameObject target = targetGameObjects[i];
  311.                     bool isMatch = true;
  312.                     for (int j = 0; j < filterConditions.Count; j++)
  313.                     {
  314.                         if (!filterConditions[j].IsMatch(target))
  315.                         {
  316.                             isMatch = false;
  317.                             break;
  318.                         }
  319.                     }
  320.                     EditorUtility.DisplayProgressBar("Filter", $"{target.name} -> Is Matched : {isMatch}", (float)i / targetGameObjects.Count);
  321.                     if (isMatch)
  322.                     {
  323.                         selectedObjects.Add(target);
  324.                     }
  325.                 }
  326.                 EditorUtility.ClearProgressBar();
  327.             }
  328.             if (GUILayout.Button("Select", "ButtonMid"))
  329.             {
  330.                 Selection.objects = selectedObjects.ToArray();
  331.             }
  332.             if (GUILayout.Button("Clear", "ButtonRight"))
  333.             {
  334.                 selectedObjects.Clear();
  335.             }
  336.             GUILayout.EndHorizontal();
  337.         }
  338.     }
  339. }
当代野生程序猿
微信公众号
Unity开发日志分享，欢迎关注/留言/私信。
注：本文转载自blog.csdn.net的CoderZ1010的文章"https://blog.csdn.net/qq_42139931/article/details/119643874"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！