devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Unity编辑器扩展】UI变量代码自动生成工具(编辑器扩展干货/大幅提高效率)_unity 编辑器工具

作者：凡人多烦事01 | 2024-02-19 14:44:46

赞

踩

unity 编辑器工具

 工具主要功能：通过扩展编辑器菜单，在不写一行代码的情况下，快速方便灵活的配置生成UI变量、一键添加按钮事件, 大幅提高工作效率。

 工具使用演示：

模式一：通过SerializedField方式自动生成UI变量代码，并在Inspector面板自动填充UI变量

模式二：通过GetComponent初始化变量 

 

 移除变量:

一键快速添加Button按钮事件(支持批量处理)：

 

2022.9.1更新：

新增了变量绑定模式设置：

模式一：先点Generate Script自动生成[SerializeField]变量，然后点击Bind Properties将组件赋值给[SerializeField]变量;  优点是可以在Inspector面板上显示出每一个变量值，缺点是由于某种bug，直接生成完[SerialzedField]变量代码后，即使做了等待脚本编译和资源导入全部完成后再对[SerializeField]变量赋值，依然会出现"Type mismatch"的情况。所以只能把生成代码和绑定变量拆成两个按钮步骤才能正常。

模式二：不用SerializeField，直接生成通过GetComponent从已绑定GameObject上获取组件的代码。优点是步骤简单，面板显示简洁，不需要保存多个序列化对象。缺点是在界面逻辑实例化时会有调用GetComponent的微微微微微小的开销。

1. 在Prefab UI界面中右键点击节点，指定变量为private/protected/public，然后弹出可选择的变量类型菜单。

 2. 添加绑定后，数据在Inspector面板显示，方便修改变量相关类型等；支持添加变量和数组变量；默认变量名为节点名，变量名重复时自动修改变量名，可自行编辑变量名；支持数组添加/移除；拖动数组元素可调整索引；

 3. 选择变量类型。根据绑定节点筛选出交集组件，展示在下拉列表里以便选择变量类型

 4. 在Hierarchy面板直观显示已绑定的组件信息：

 5. 绑定完UI变量后点击生成代码按钮一键生成对应UIForm的partial类绑定脚本；如果当前UIForm逻辑脚本类没有添加partial修饰符，程序会自动提示添加。UI绑定代码独立生成partial脚本是为了避免与UIForm界面逻辑脚本冲突，比如VS中存在为保存的代码，这时直接操作UIForm类会为保存部分丢失的可能。

功能代码实现：

1. 定义SerializeFieldData类用于记录变量数据，在UI逻辑的基类添加_fields用于存放变量数据列表

  1. [Serializable]
  2. public class SerializeFieldData
  3. {
  4.     public string VarName;      //变量名
  5.     public GameObject[] Targets;//关联的GameObject
  6.     public string VarType;      //变量类型FullName,带有名字空间
  7.     public bool Foldout;    //列表展开
  8.     public string VarPrefix;//变量private/protect/public
  9.     public string VarSampleType;//变量类型不带名字空间
  10.     public SerializeFieldData(string varName, GameObject[] targets = null)
  11.     {
  12.         VarName = varName;
  13.         Targets = targets ?? new GameObject[1];
  14.         Foldout = true;
  15.     }
  16.     public T GetComponent<T>(int idx) where T : Component
  17.     {
  18.         return Targets[idx].GetComponent<T>();
  19.     }
  20.     public T[] GetComponents<T>() where T : Component
  21.     {
  22.         T[] result = new T[Targets.Length];
  23.         for (int i = 0; i < Targets.Length; i++)
  24.         {
  25.             result[i] = Targets[i].GetComponent<T>();
  26.         }
  27.         return result;
  28.     }
  29. }
  30.  
  31. public class UIFormBase : UIFormLogic
  32. {
  33.     [HideInInspector][SerializeField] SerializeFieldData[] _fields = new SerializeFieldData[0];
  34. ...
  35. }

2. 自定义UIFormEditor类，扩展编辑器：

[CustomEditor(typeof(UIFormBase), true)] 传入true使编辑器扩展对所有继承自UIFormBase的类都能拥有编辑器扩展部分出的功能。

  1. [CustomEditor(typeof(UIFormBase), true)]
  2. public class UIFormBaseEditor : Editor
  3. {
  4. ...
  5. }

通过注册 EditorApplication.hierarchyWindowItemOnGUI = delegate (int id, Rect rect){...}，可以自定义Hierarchy面板的UI显示。如，在已经添加到变量的节点后面用绿色文字显示出变量信息

  1. private static GUIStyle normalStyle;
  2.     private static GUIStyle selectedStyle;
  3.     [InitializeOnLoadMethod]
  4.     static void InitEditor()
  5.     {
  6.  
  7.         normalStyle = new GUIStyle();
  8.         normalStyle.normal.textColor = Color.white;
  9.  
  10.         selectedStyle = new GUIStyle();
  11.         selectedStyle.normal.textColor = Color.green;
  12.         Selection.selectionChanged = () =>
  13.         {
  14.             addToFieldToggle = false;
  15.             removeToFieldToggle = false;
  16.         };
  17.  
  18.         EditorApplication.hierarchyWindowItemOnGUI = delegate (int id, Rect rect)
  19.         {
  20.             OpenSelectComponentMenuListener(rect);
  21.             var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
  22.             if (prefabStage == null)
  23.             {
  24.                 return;
  25.             }
  26.             var uiForm = prefabStage.prefabContentsRoot.GetComponent<UIFormBase>();
  27.             if (uiForm == null)
  28.             {
  29.                 return;
  30.             }
  31.             var curDrawNode = EditorUtility.InstanceIDToObject(id) as GameObject;
  32.             if (curDrawNode == null)
  33.             {
  34.                 return;
  35.             }
  36.             var fields = uiForm.GetFieldsProperties();
  37.             SerializeFieldData drawItem = null;
  38.             foreach (var item in fields)
  39.             {
  40.                 if (item == null) continue;
  41.                 if (ArrayUtility.Contains(item.Targets, curDrawNode))
  42.                 {
  43.                     drawItem = item;
  44.                     break;
  45.                 }
  46.             }
  47.             if (drawItem != null)
  48.             {
  49.                 rect.x = rect.xMax - Mathf.Min(300, rect.size.x * 0.35f);
  50.                 GUI.Label(rect, string.Format("{0} {1} {2}", drawItem.VarPrefix, drawItem.VarSampleType, drawItem.VarName), selectedStyle);
  51.             }
  52.  
  53.         };
  54.     }

3. 自定义右键菜单：

通过[MenuItem("GameObject/Add UIForm Variable/private", false, priority = 0)]，设置路径为GameObject/就出现在Hierarchy的右键菜单里。

  1. static int varPrefixIndex = -1;
  2.     static bool mShowSelectTypeMenu;//是否显示变量类型选择菜单
  3.     [MenuItem("GameObject/Add UIForm Variable/private", false, priority = 0)]
  4.     private static void AddPrivateVariable2UIForm()
  5.     {
  6.         varPrefixIndex = 0;
  7.         mShowSelectTypeMenu = true;
  8.     }

4. 变量类型选择菜单框：

在EditorApplication.hierarchyWindowItemOnGUI回调中调用了OpenSelectComponentMenuListener(rect)方法，然后获取选中节点的所有组件的交集，显示在菜单中：

  1. private static void OpenSelectComponentMenuListener(Rect rect)
  2.     {
  3.         if (mShowSelectTypeMenu)
  4.         {
  5.             int idx = -1;
  6.             var strArr = GetPopupContents(GetTargetsFromSelectedNodes(Selection.gameObjects));
  7.             var contents = new GUIContent[strArr.Length];
  8.             for (int i = 0; i < strArr.Length; i++)
  9.             {
  10.                 contents[i] = new GUIContent(strArr[i]);
  11.             }
  12.             rect.width = 200;
  13.             rect.height = MathF.Max(100, contents.Length * rect.height);
  14.             EditorUtility.DisplayCustomMenu(rect, contents, idx, (userData, contents, selected) =>
  15.             {
  16.                 AddToFields(varPrefixArr[varPrefixIndex], contents[selected]);
  17.             }, null);
  18.             mShowSelectTypeMenu = false;
  19.         }
  20.     }

5. 根据选择的变量信息创建SerializeFieldData并存入UI基类的_fields变量列表；

通过PrefabStageUtility.GetCurrentPrefabStage().prefabContentsRoot可以拿到已打开Prefab的根节点。

  1. private static void AddToFields(string varPrefix, string varType)
  2.     {
  3.         if (addToFieldToggle)
  4.         {
  5.             return;
  6.         }
  7.         if (Selection.count <= 0) return;
  8.         var uiForm = GetPrefabRootComponent<UIFormBase>();
  9.         if (uiForm == null)
  10.         {
  11.             Debug.LogWarning("UIForm Script is not exist.");
  12.             return;
  13.         }
  14.         var targets = GetTargetsFromSelectedNodes(Selection.gameObjects);
  15.  
  16.         var fieldsProperties = uiForm.GetFieldsProperties();
  17.         if (fieldsProperties == null) fieldsProperties = new SerializeFieldData[0];
  18.         Undo.RecordObject(uiForm, uiForm.name);
  19.         SerializeFieldData field = new SerializeFieldData(GenerateFieldName(fieldsProperties, targets), targets);
  20.         field.VarType = varType;
  21.         field.VarSampleType = GetSampleType(field.VarType).Name;
  22.         field.VarPrefix = varPrefix;
  23.  
  24.         ArrayUtility.Add(ref fieldsProperties, field);
  25.         uiForm.ModifyFieldsProperties(fieldsProperties);
  26.         EditorUtility.SetDirty(uiForm);
  27.         addToFieldToggle = true;
  28.         removeToFieldToggle = false;
  29.     }

6. Inspector面板扩展：

先了解一些比较常用的编辑器扩展API:

1.垂直布局： EditorGUILayout.BeginVertical()；EditorGUILayout.EndVertical(); 需成对存在；

2.水平布局：EditorGUILayout.BeginHorizontal(); EditorGUILayout.EndHorizontal();需成对存在；

3.代码编译中：EditorApplication.isCompiling

4.资源导入中：EditorApplication.isUpdating

5.警示框：EditorGUILayout.HelpBox("Wiatting for compiling or updating...", MessageType.Warning);

 6.UI禁止交互; 

EditorGUI.BeginDisabledGroup(EditorApplication.isCompiling || EditorApplication.isUpdating);

EditorGUI.EndDisabledGroup();

成对存在，可控制被包裹的UI是否可交互。如上，当编译和导入资源过程让UI不可交互；

7.可折叠按钮：

  1. boolValue = EditorGUILayout.BeginFoldoutHeaderGroup(boolValue, “Title”);
  2.  
  3. if(boolValue){
  4.     可折叠的UI放到这里
  5. }

 8. 下拉菜单

①EditorGUILayout.Popup：intValue为当前选择的菜单项索引

intValue = EditorGUILayout.Popup(intValue, varPrefixArr, GUILayout.MaxWidth(fieldPrefixWidth));

 ②EditorGUILayout.DropdownButton: 下拉按钮，优点是可以在下拉按钮点击后再加载下拉数据并显示，减少不必要性能消耗。点击下拉按钮后再创建GenericMenu(下拉列表)：

  1. if (EditorGUILayout.DropdownButton(new GUIContent(varPrefixProperty.stringValue), FocusType.Passive, GUILayout.MaxWidth(fieldPrefixWidth)))
  2.             {
  3.                 GenericMenu popMenu = new GenericMenu();
  4.                 foreach (var varPrefix in varPrefixArr)
  5.                 {
  6.                     popMenu.AddItem(new GUIContent(varPrefix), varPrefix.CompareTo(varPrefixProperty.stringValue) == 0, selectObj =>
  7.                     {
  8.                         varPrefixProperty.stringValue = selectObj.ToString();
  9.                         serializedObject.ApplyModifiedProperties();
  10.                     }, varPrefix);
  11.                 }
  12.                 popMenu.ShowAsContext();
  13.             }

9. 可编辑文本框：

stringValue = GUILayout.TextField(stringValue, GUILayout.MinWidth(fieldItemWidth));

10. 按钮：

  1. if (GUILayout.Button("+", GUILayout.Width(smallButtonWidth)))
  2. {
  3.     //按钮被点击
  4. }

 11. 对齐：GUILayout.FlexibleSpace();GUILayout.Space(10);

GUILayout.FlexibleSpace(); 动态间距大小；GUILayout.Space(10)固定间距，空出10个像素

让Label右对齐：

  1. EditorGUILayout.BeginHorizontal();
  2. GUILayout.FlexibleSpace();
  3. EditorGUILayout.LabelField("Label");
  4. EditorGUILayout.EndHorizontal();

 让Label左对齐：

  1. EditorGUILayout.BeginHorizontal();
  2. EditorGUILayout.LabelField("Label");
  3. GUILayout.FlexibleSpace();
  4. EditorGUILayout.EndHorizontal();

让Label居中对齐：

  1. EditorGUILayout.BeginHorizontal();
  2. GUILayout.FlexibleSpace();
  3. EditorGUILayout.LabelField("Label");
  4. GUILayout.FlexibleSpace();
  5. EditorGUILayout.EndHorizontal();
  1. public override void OnInspectorGUI()
  2.     {
  3.         CheckAndInitFields();
  4.         serializedObject.Update();
  5.         EditorGUILayout.BeginVertical();
  6.  
  7.         bool disableAct = EditorApplication.isCompiling || EditorApplication.isUpdating || EditorApplication.isPlaying;
  8.         if (disableAct)
  9.         {
  10.             EditorGUILayout.HelpBox("Wiatting for compiling or updating...", MessageType.Warning);
  11.         }
  12.         EditorGUILayout.BeginHorizontal();
  13.         EditorGUI.BeginDisabledGroup(disableAct);
  14.  
  15.         if (GUILayout.Button("1. Generate Script")) //生成脚本
  16.         {
  17.             GenerateUIFormVariables(uiForm, serializedObject);
  18.         }
  19.  
  20.         if (useSerializeMode && GUILayout.Button("2. Bind Properties")) //绑定变量
  21.         {
  22.             SerializeFieldProperties(serializedObject, uiForm.GetFieldsProperties());
  23.         }
  24.         if (GUILayout.Button("Open Script"))
  25.         {
  26.             var monoScript = MonoScript.FromMonoBehaviour(uiForm);
  27.             string scriptFile = AssetDatabase.GetAssetPath(monoScript);
  28.             InternalEditorUtility.OpenFileAtLineExternal(scriptFile, 0);
  29.         }
  30.         if (GUILayout.Button("Open Bind Script"))
  31.         {
  32.             var uiFormClassName = uiForm.GetType().Name;
  33.             string scriptFile = UtilityBuiltin.ResPath.GetCombinePath(ConstEditor.UISerializeFieldDir, Utility.Text.Format("{0}.Variables.cs", uiFormClassName));
  34.             InternalEditorUtility.OpenFileAtLineExternal(scriptFile, 0);
  35.         }
  36.         if (GUILayout.Button("Clear", GUILayout.MaxWidth(55)))
  37.         {
  38.             mFields.ClearArray();
  39.         }
  40.         EditorGUILayout.EndHorizontal();
  41.         EditorGUILayout.BeginHorizontal();
  42.         EditorGUI.BeginChangeCheck();
  43.  
  44.         useSerializeMode = EditorGUILayout.ToggleLeft("SerializeMode", useSerializeMode, GUILayout.MaxWidth(115));
  45.         if (EditorGUI.EndChangeCheck())
  46.         {
  47.             UnityEditor.EditorPrefs.SetBool("SerializeMode", useSerializeMode);
  48.         }
  49.         GUILayout.FlexibleSpace();
  50.         if (GUILayout.Button(EditorGUIUtility.TrIconContent("_Help", "使用说明"), GUIStyle.none))
  51.         {
  52.             EditorUtility.DisplayDialog("使用说明", "1.打开UI界面预制体.\n2.右键节点'[Add/Remove] UI Variable'添加/移除变量.\n3.在Inspector面板点击Generate Script生成代码.", "OK");
  53.             GUIUtility.ExitGUI();
  54.         }
  55.         EditorGUILayout.EndHorizontal();
  56.         for (int i = 0; i < mFields.arraySize; i++)
  57.         {
  58.             EditorGUILayout.BeginHorizontal();
  59.             GUILayout.Label(i.ToString(), GUILayout.Width(30f));
  60.             var item = mFields.GetArrayElementAtIndex(i);
  61.             var varNameProperty = item.FindPropertyRelative("VarName");
  62.             var varTypeProperty = item.FindPropertyRelative("VarType");
  63.             var targetsProperty = item.FindPropertyRelative("Targets");
  64.             var unfoldProperty = item.FindPropertyRelative("Foldout");
  65.             var varPrefixProperty = item.FindPropertyRelative("VarPrefix");
  66.             var varSampleType = item.FindPropertyRelative("VarSampleType");
  67.  
  68.             int targetsCount = targetsProperty != null ? targetsProperty.arraySize : 0;
  69.             string targetsTitle = $"Size {targetsCount}";
  70.  
  71.             unfoldProperty.boolValue = EditorGUILayout.BeginFoldoutHeaderGroup(unfoldProperty.boolValue, targetsTitle);
  72.             if (EditorGUILayout.DropdownButton(new GUIContent(varPrefixProperty.stringValue), FocusType.Passive, GUILayout.MaxWidth(fieldPrefixWidth)))
  73.             {
  74.                 GenericMenu popMenu = new GenericMenu();
  75.                 foreach (var varPrefix in varPrefixArr)
  76.                 {
  77.                     popMenu.AddItem(new GUIContent(varPrefix), varPrefix.CompareTo(varPrefixProperty.stringValue) == 0, selectObj =>
  78.                     {
  79.                         varPrefixProperty.stringValue = selectObj.ToString();
  80.                         serializedObject.ApplyModifiedProperties();
  81.                     }, varPrefix);
  82.                 }
  83.                 popMenu.ShowAsContext();
  84.             }
  85.             if (EditorGUILayout.DropdownButton(new GUIContent(varTypeProperty.stringValue), FocusType.Passive, GUILayout.MaxWidth(fieldTypeWidth)))
  86.             {
  87.                 GenericMenu popMenu = new GenericMenu();
  88.                 var popContens = GetPopupContents(targetsProperty);
  89.                 foreach (var tpName in popContens)
  90.                 {
  91.                     popMenu.AddItem(new GUIContent(tpName), tpName.CompareTo(varTypeProperty.stringValue) == 0, selectObj =>
  92.                     {
  93.                         varTypeProperty.stringValue = selectObj.ToString();
  94.                         varSampleType.stringValue = GetSampleType(varTypeProperty.stringValue).Name;
  95.                         serializedObject.ApplyModifiedProperties();
  96.                     }, tpName);
  97.                 }
  98.                 popMenu.ShowAsContext();
  99.             }
  100.  
  101.             varNameProperty.stringValue = GUILayout.TextField(varNameProperty.stringValue, GUILayout.MinWidth(fieldItemWidth));
  102.  
  103.             if (GUILayout.Button("+", GUILayout.Width(smallButtonWidth)))
  104.             {
  105.                 InsertField(i + 1);
  106.             }
  107.             if (GUILayout.Button("-", GUILayout.Width(smallButtonWidth)))
  108.             {
  109.                 RemoveField(i);
  110.             }
  111.             EditorGUILayout.EndHorizontal();
  112.             if (i < mFields.arraySize && mFields.GetArrayElementAtIndex(i).FindPropertyRelative("Foldout").boolValue)
  113.             {
  114.                 item = mFields.GetArrayElementAtIndex(i);
  115.                 targetsProperty = item.FindPropertyRelative("Targets");
  116.  
  117.                 mCurFieldIdx = i;
  118.                 if (mReorderableList[i] == null)
  119.                 {
  120.                     mReorderableList[i] = new ReorderableList(serializedObject, targetsProperty, true, false, true, true);
  121.                     mReorderableList[i].drawElementCallback = DrawTargets;
  122.                 }
  123.                 else
  124.                 {
  125.                     mReorderableList[i].serializedProperty = targetsProperty;
  126.                 }
  127.                 mReorderableList[i].DoLayoutList();
  128.             }
  129.             EditorGUILayout.EndFoldoutHeaderGroup();
  130.         }
  131.  
  132.         if (serializedObject.hasModifiedProperties)
  133.         {
  134.             serializedObject.ApplyModifiedProperties();
  135.             serializedObject.Update();
  136.         }
  137.  
  138.         EditorGUI.EndDisabledGroup();
  139.         EditorGUILayout.EndVertical();
  140.         base.OnInspectorGUI();
  141.     }

12. 获取GameObject上挂的脚本文件所在目录：

  1. var monoScript = MonoScript.FromMonoBehaviour(monoBehaviorInstance);
  2. string scriptPath = AssetDatabase.GetAssetPath(monoScript);//.cs脚本文件路径

13. 显示对话框：

EditorUtility.DisplayDialog("标题", "内容", "确定按钮"，“取消按钮”);

14. 打开文件夹：EditorUtility.RevealInFinder(path);

选择文件：EditorUtility.OpenFilePanel()

选择文件夹：EditorUtility.OpenFolderPanel()

15. 可调数组顺序/可增删的列表ReorderableList用法：

  1. mReorderableList[i] = new ReorderableList(serializedObject, arrayProperty, true, false, true, true);
  2. mReorderableList[i].drawElementCallback = DrawTargets;
  3.  
  4. private void DrawTargets(Rect rect, int index, bool isActive, bool isFocused)
  5.     {
  6.         EditorGUI.BeginDisabledGroup(EditorApplication.isCompiling || EditorApplication.isUpdating || EditorApplication.isPlaying);
  7.         var field = mFields.GetArrayElementAtIndex(mCurFieldIdx);
  8.         var targetsProperty = field.FindPropertyRelative("Targets");
  9.         var targetProperty = targetsProperty.GetArrayElementAtIndex(index);
  10.         var curRect = new Rect(rect.x, rect.y, 20, EditorGUIUtility.singleLineHeight);
  11.         EditorGUI.LabelField(curRect, index.ToString());
  12.         curRect.x += 20;
  13.         curRect.width = rect.width - 20;
  14.         EditorGUI.ObjectField(curRect, targetProperty, GUIContent.none);
  15.         EditorGUI.EndDisabledGroup();
  16.     }

16. EditorPrefs，作用同PlayerPrefs，可用于保存编辑器设置等。如：EditorPrefs.SetBool("SerializeMode", useSerializeMode);

17. 通过调用编辑器API在代码里打开脚本文件:

InternalEditorUtility.OpenFileAtLineExternal(scriptFile, 0); 甚至可以指定打开并定位到代码的几行几列。

18. 支持撤销操作Undo.RecordObject(uiForm, uiForm.name); 例如移除UI变量时提前调用Undo.RecordObject记录对象状态，然后用户撤销操作时会自动回退到这一状态：

  1. private void RemoveField(int idx)
  2.     {
  3.         Undo.RecordObject(uiForm, uiForm.name);//记录移除数组元素前的对象状态
  4.         mFields.DeleteArrayElementAtIndex(idx);
  5.         ArrayUtility.RemoveAt(ref mReorderableList, idx);
  6.     }

 19. 使用Unity编辑器内置图标。Unity编辑器有很多内置图标，并且是可以用获取到共用的。获取编辑器内置图标API: EditorGUIUtility.TrIconContent(), EditorGUIUtility.IconContent(); 只需传入图标名即可。

如显示一个帮助按钮, IconContent和TrIconContent的区别就是，TrIconContent("_Help", "使用说明")当鼠标悬停在图标上会有显示提示； 

  1. if (GUILayout.Button(EditorGUIUtility.TrIconContent("_Help", "使用说明"), GUIStyle.none))
  2.         {
  3.             EditorUtility.DisplayDialog("使用说明", "1.打开UI界面预制体.\n2.右键节点'[Add/Remove] UI Variable'添加/移除变量.\n3.在Inspector面板点击Generate Script生成代码.", "OK");
  4.             GUIUtility.ExitGUI();
  5.         }

如何知道Unity所有内置图标名称呢？可以写个编辑器通过Resources.FindObjectsOfTypeAll<Texture2D>()获取全部图标，并显示出每个图标和对应图标名，一目了然。

当然也有人已经整理列出了图标及名称，但是由于Unity版本不同图标样式也会有区别，白嫖地址：GitHub - halak/unity-editor-icons

20. 一键清理prefab丢失脚本Missing Scrips, GameObjectUtility.RemoveMonoBehavioursWithMissingScript(pfb);

  1. [MenuItem("Game Framework/GameTools/Clear Missing Scripts【清除Prefab丢失脚本】")]
  2.     public static void ClearMissingScripts()
  3.     {
  4.         var pfbArr = AssetDatabase.FindAssets("t:Prefab");
  5.         foreach (var item in pfbArr)
  6.         {
  7.             var pfbFileName = AssetDatabase.GUIDToAssetPath(item);
  8.             var pfb = AssetDatabase.LoadAssetAtPath<GameObject>(pfbFileName);
  9.             GameObjectUtility.RemoveMonoBehavioursWithMissingScript(pfb);
  10.         }
  11.     }

自动生成UI变量核心代码：

  1. #if UNITY_EDITOR
  2. using UnityEditor.SceneManagement;
  3. using System.Linq;
  4. using UnityEditor;
  5. using System.Collections.Generic;
  6. using UnityEngine;
  7. using UnityEditorInternal;
  8. using System;
  9. using GameFramework;
  10. using System.Text.RegularExpressions;
  11. using System.Text;
  12. using System.IO;
  13.  
  14.  
  15. [CustomEditor(typeof(UIFormBase), true)]
  16. public class UIFormBaseEditor : Editor
  17. {
  18.     readonly static string[] varPrefixArr = { "private", "protected", "public" };
  19.     const string arrFlag = "Arr";
  20.     const float fieldItemWidth = 100;
  21.     const float fieldPrefixWidth = 100;
  22.     const float fieldTypeWidth = 240;
  23.     const float smallButtonWidth = 25;
  24.     SerializedProperty mFields;
  25.     static bool addToFieldToggle;
  26.     static bool removeToFieldToggle;
  27.     ReorderableList[] mReorderableList;
  28.     UIFormBase uiForm;
  29.     int mCurFieldIdx;
  30.  
  31.     bool useSerializeMode = false;
  32.     static int varPrefixIndex = -1;
  33.     static bool mShowSelectTypeMenu;
  34.  
  35.     #region #右键菜单
  36.     private static GUIStyle normalStyle;
  37.     private static GUIStyle selectedStyle;
  38.     [InitializeOnLoadMethod]
  39.     static void InitEditor()
  40.     {
  41.  
  42.         normalStyle = new GUIStyle();
  43.         normalStyle.normal.textColor = Color.white;
  44.  
  45.         selectedStyle = new GUIStyle();
  46.         selectedStyle.normal.textColor = Color.green;
  47.         Selection.selectionChanged = () =>
  48.         {
  49.             addToFieldToggle = false;
  50.             removeToFieldToggle = false;
  51.         };
  52.  
  53.         EditorApplication.hierarchyWindowItemOnGUI = delegate (int id, Rect rect)
  54.         {
  55.             OpenSelectComponentMenuListener(rect);
  56.             var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
  57.             if (prefabStage == null)
  58.             {
  59.                 return;
  60.             }
  61.             var uiForm = prefabStage.prefabContentsRoot.GetComponent<UIFormBase>();
  62.             if (uiForm == null)
  63.             {
  64.                 return;
  65.             }
  66.             var curDrawNode = EditorUtility.InstanceIDToObject(id) as GameObject;
  67.             if (curDrawNode == null)
  68.             {
  69.                 return;
  70.             }
  71.             var fields = uiForm.GetFieldsProperties();
  72.             SerializeFieldData drawItem = null;
  73.             foreach (var item in fields)
  74.             {
  75.                 if (item == null) continue;
  76.                 if (ArrayUtility.Contains(item.Targets, curDrawNode))
  77.                 {
  78.                     drawItem = item;
  79.                     break;
  80.                 }
  81.             }
  82.             if (drawItem != null)
  83.             {
  84.                 rect.x = rect.xMax - Mathf.Min(300, rect.size.x * 0.35f);
  85.                 GUI.Label(rect, string.Format("{0} {1} {2}", drawItem.VarPrefix, drawItem.VarSampleType, drawItem.VarName), selectedStyle);
  86.             }
  87.  
  88.         };
  89.     }
  90.     [MenuItem("GameObject/UIForm Fields Tool/Add private", false, priority = 2)]
  91.     private static void AddPrivateVariable2UIForm()
  92.     {
  93.         varPrefixIndex = 0;
  94.         mShowSelectTypeMenu = true;
  95.     }
  96.     [MenuItem("GameObject/UIForm Fields Tool/Add protected", false, priority = 3)]
  97.     private static void AddProtectedVariable2UIForm()
  98.     {
  99.         varPrefixIndex = 1;
  100.         mShowSelectTypeMenu = true;
  101.     }
  102.     [MenuItem("GameObject/UIForm Fields Tool/Add public", false, priority = 4)]
  103.     private static void AddPublicVariable2UIForm()
  104.     {
  105.         varPrefixIndex = 2;
  106.         mShowSelectTypeMenu = true;
  107.     }
  108.  
  109.     [MenuItem("GameObject/UIForm Fields Tool/Remove", false, priority = 5)]
  110.     private static void RemoveUIFormVariable()
  111.     {
  112.         if (removeToFieldToggle)
  113.         {
  114.             return;
  115.         }
  116.         if (Selection.count <= 0) return;
  117.  
  118.         var uiForm = GetPrefabRootComponent<UIFormBase>();
  119.         if (uiForm == null)
  120.         {
  121.             Debug.LogWarning("UIForm Script is not exist.");
  122.             return;
  123.         }
  124.         var fieldsProperties = uiForm.GetFieldsProperties();
  125.         if (fieldsProperties == null) return;
  126.         Undo.RecordObject(uiForm, uiForm.name);
  127.         for (int i = 0; i < Selection.gameObjects.Length; i++)
  128.         {
  129.             var itm = Selection.gameObjects[i];
  130.             if (itm == null) continue;
  131.  
  132.             for (int j = fieldsProperties.Length - 1; j >= 0; j--)
  133.             {
  134.                 var fields = fieldsProperties[j];
  135.                 if (fields == null || fields.Targets == null || fields.Targets.Length <= 0) continue;
  136.                 for (int k = fields.Targets.Length - 1; k >= 0; k--)
  137.                 {
  138.                     if (fields.Targets[k] == itm)
  139.                     {
  140.                         if (fields.Targets.Length <= 1)
  141.                         {
  142.                             ArrayUtility.RemoveAt(ref fieldsProperties, j);
  143.                         }
  144.                         else
  145.                         {
  146.                             ArrayUtility.RemoveAt(ref fields.Targets, k);
  147.                         }
  148.                     }
  149.                 }
  150.             }
  151.         }
  152.         uiForm.ModifyFieldsProperties(fieldsProperties);
  153.         EditorUtility.SetDirty(uiForm);
  154.         removeToFieldToggle = true;
  155.         addToFieldToggle = false;
  156.     }
  157.     /// <summary>
  158.     /// 不带名字空间的类型名
  159.     /// </summary>
  160.     /// <returns></returns>
  161.     private static Type GetSampleType(string fullName)
  162.     {
  163.         Type result = null;
  164.         var assemblyArr = AppDomain.CurrentDomain.GetAssemblies();
  165.         foreach (var item in assemblyArr)
  166.         {
  167.             foreach (var tp in item.GetTypes())
  168.             {
  169.                 if (tp.FullName.CompareTo(fullName) == 0)
  170.                 {
  171.                     result = tp;
  172.                     break;
  173.                 }
  174.             }
  175.             if (result != null) break;
  176.         }
  177.  
  178.         return result;
  179.     }
  180.     private static T GetPrefabRootComponent<T>() where T : Component
  181.     {
  182.         var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
  183.         if (prefabStage == null)
  184.         {
  185.             Debug.LogWarning("GetCurrentPrefabStage is null.");
  186.             return null;
  187.         }
  188.         return prefabStage.prefabContentsRoot.GetComponent<T>();
  189.     }
  190.     private static void AddToFields(string varPrefix, string varType)
  191.     {
  192.         if (addToFieldToggle)
  193.         {
  194.             return;
  195.         }
  196.         if (Selection.count <= 0) return;
  197.         var uiForm = GetPrefabRootComponent<UIFormBase>();
  198.         if (uiForm == null)
  199.         {
  200.             Debug.LogWarning("UIForm Script is not exist.");
  201.             return;
  202.         }
  203.         var targets = GetTargetsFromSelectedNodes(Selection.gameObjects);
  204.  
  205.         var fieldsProperties = uiForm.GetFieldsProperties();
  206.         if (fieldsProperties == null) fieldsProperties = new SerializeFieldData[0];
  207.         Undo.RecordObject(uiForm, uiForm.name);
  208.         SerializeFieldData field = new SerializeFieldData(GenerateFieldName(fieldsProperties, targets), targets);
  209.         field.VarType = varType;
  210.         field.VarSampleType = GetSampleType(field.VarType).Name;
  211.         field.VarPrefix = varPrefix;
  212.  
  213.         ArrayUtility.Add(ref fieldsProperties, field);
  214.         uiForm.ModifyFieldsProperties(fieldsProperties);
  215.         EditorUtility.SetDirty(uiForm);
  216.         addToFieldToggle = true;
  217.         removeToFieldToggle = false;
  218.     }
  219.     private static GameObject[] GetTargetsFromSelectedNodes(GameObject[] selectedList)
  220.     {
  221.         GameObject[] targets = new GameObject[selectedList.Length];
  222.         for (int i = 0; i < selectedList.Length; i++)
  223.         {
  224.             targets[i] = selectedList[i];
  225.         }
  226.         targets = targets.OrderBy(go => go.transform.GetSiblingIndex()).ToArray();
  227.         return targets;
  228.     }
  229.     #endregion
  230.  
  231.     private void OnEnable()
  232.     {
  233.         useSerializeMode = EditorPrefs.GetBool("SerializeMode", true);
  234.         varPrefixIndex = 0;
  235.         mShowSelectTypeMenu = false;
  236.         uiForm = (target as UIFormBase);
  237.         if (uiForm.GetFieldsProperties() == null)
  238.         {
  239.             uiForm.ModifyFieldsProperties(new SerializeFieldData[0]);
  240.         }
  241.         mFields = serializedObject.FindProperty("_fields");
  242.         mReorderableList = new ReorderableList[mFields.arraySize];
  243.     }
  244.  
  245.  
  246.     private static void OpenSelectComponentMenuListener(Rect rect)
  247.     {
  248.         if (mShowSelectTypeMenu)
  249.         {
  250.             int idx = -1;
  251.             var strArr = GetPopupContents(GetTargetsFromSelectedNodes(Selection.gameObjects));
  252.             var contents = new GUIContent[strArr.Length];
  253.             for (int i = 0; i < strArr.Length; i++)
  254.             {
  255.                 contents[i] = new GUIContent(strArr[i]);
  256.             }
  257.             rect.width = 200;
  258.             rect.height = MathF.Max(100, contents.Length * rect.height);
  259.             EditorUtility.DisplayCustomMenu(rect, contents, idx, (userData, contents, selected) =>
  260.             {
  261.                 AddToFields(varPrefixArr[varPrefixIndex], contents[selected]);
  262.             }, null);
  263.             mShowSelectTypeMenu = false;
  264.         }
  265.     }
  266.  
  267.     public override void OnInspectorGUI()
  268.     {
  269.         CheckAndInitFields();
  270.         serializedObject.Update();
  271.         EditorGUILayout.BeginVertical();
  272.  
  273.         bool disableAct = EditorApplication.isCompiling || EditorApplication.isUpdating || EditorApplication.isPlaying;
  274.         if (disableAct)
  275.         {
  276.             EditorGUILayout.HelpBox("Wiatting for compiling or updating...", MessageType.Warning);
  277.         }
  278.         EditorGUILayout.BeginHorizontal();
  279.         EditorGUI.BeginDisabledGroup(disableAct);
  280.  
  281.         if (GUILayout.Button("1. Generate Script")) //生成脚本
  282.         {
  283.             GenerateUIFormVariables(uiForm, serializedObject);
  284.         }
  285.  
  286.         if (useSerializeMode && GUILayout.Button("2. Bind Properties")) //绑定变量
  287.         {
  288.             SerializeFieldProperties(serializedObject, uiForm.GetFieldsProperties());
  289.         }
  290.         if (GUILayout.Button("Open Script"))
  291.         {
  292.             var monoScript = MonoScript.FromMonoBehaviour(uiForm);
  293.             string scriptFile = AssetDatabase.GetAssetPath(monoScript);
  294.             InternalEditorUtility.OpenFileAtLineExternal(scriptFile, 0);
  295.         }
  296.         if (GUILayout.Button("Open Bind Script"))
  297.         {
  298.             var uiFormClassName = uiForm.GetType().Name;
  299.             string scriptFile = UtilityBuiltin.ResPath.GetCombinePath(ConstEditor.UISerializeFieldDir, Utility.Text.Format("{0}.Variables.cs", uiFormClassName));
  300.             InternalEditorUtility.OpenFileAtLineExternal(scriptFile, 0);
  301.         }
  302.         if (GUILayout.Button("Clear", GUILayout.MaxWidth(55)))
  303.         {
  304.             mFields.ClearArray();
  305.         }
  306.         EditorGUILayout.EndHorizontal();
  307.         EditorGUILayout.BeginHorizontal();
  308.         EditorGUI.BeginChangeCheck();
  309.  
  310.         useSerializeMode = EditorGUILayout.ToggleLeft("SerializeMode", useSerializeMode, GUILayout.MaxWidth(115));
  311.         if (EditorGUI.EndChangeCheck())
  312.         {
  313.             UnityEditor.EditorPrefs.SetBool("SerializeMode", useSerializeMode);
  314.         }
  315.         GUILayout.FlexibleSpace();
  316.         if (GUILayout.Button(EditorGUIUtility.TrIconContent("_Help", "使用说明"), GUIStyle.none))
  317.         {
  318.             EditorUtility.DisplayDialog("使用说明", "1.打开UI界面预制体.\n2.右键节点'[Add/Remove] UI Variable'添加/移除变量.\n3.在Inspector面板点击Generate Script生成代码.", "OK");
  319.             GUIUtility.ExitGUI();
  320.         }
  321.         EditorGUILayout.EndHorizontal();
  322.         for (int i = 0; i < mFields.arraySize; i++)
  323.         {
  324.             EditorGUILayout.BeginHorizontal();
  325.             GUILayout.Label(i.ToString(), GUILayout.Width(30f));
  326.             var item = mFields.GetArrayElementAtIndex(i);
  327.             var varNameProperty = item.FindPropertyRelative("VarName");
  328.             var varTypeProperty = item.FindPropertyRelative("VarType");
  329.             var targetsProperty = item.FindPropertyRelative("Targets");
  330.             var unfoldProperty = item.FindPropertyRelative("Foldout");
  331.             var varPrefixProperty = item.FindPropertyRelative("VarPrefix");
  332.             var varSampleType = item.FindPropertyRelative("VarSampleType");
  333.  
  334.             int targetsCount = targetsProperty != null ? targetsProperty.arraySize : 0;
  335.             string targetsTitle = $"Size {targetsCount}";
  336.  
  337.             unfoldProperty.boolValue = EditorGUILayout.BeginFoldoutHeaderGroup(unfoldProperty.boolValue, targetsTitle);
  338.             if (EditorGUILayout.DropdownButton(new GUIContent(varPrefixProperty.stringValue), FocusType.Passive, GUILayout.MaxWidth(fieldPrefixWidth)))
  339.             {
  340.                 GenericMenu popMenu = new GenericMenu();
  341.                 foreach (var varPrefix in varPrefixArr)
  342.                 {
  343.                     popMenu.AddItem(new GUIContent(varPrefix), varPrefix.CompareTo(varPrefixProperty.stringValue) == 0, selectObj =>
  344.                     {
  345.                         varPrefixProperty.stringValue = selectObj.ToString();
  346.                         serializedObject.ApplyModifiedProperties();
  347.                     }, varPrefix);
  348.                 }
  349.                 popMenu.ShowAsContext();
  350.             }
  351.             if (EditorGUILayout.DropdownButton(new GUIContent(varTypeProperty.stringValue), FocusType.Passive, GUILayout.MaxWidth(fieldTypeWidth)))
  352.             {
  353.                 GenericMenu popMenu = new GenericMenu();
  354.                 var popContens = GetPopupContents(targetsProperty);
  355.                 foreach (var tpName in popContens)
  356.                 {
  357.                     popMenu.AddItem(new GUIContent(tpName), tpName.CompareTo(varTypeProperty.stringValue) == 0, selectObj =>
  358.                     {
  359.                         varTypeProperty.stringValue = selectObj.ToString();
  360.                         varSampleType.stringValue = GetSampleType(varTypeProperty.stringValue).Name;
  361.                         serializedObject.ApplyModifiedProperties();
  362.                     }, tpName);
  363.                 }
  364.                 popMenu.ShowAsContext();
  365.             }
  366.  
  367.             varNameProperty.stringValue = GUILayout.TextField(varNameProperty.stringValue, GUILayout.MinWidth(fieldItemWidth));
  368.  
  369.             if (GUILayout.Button("+", GUILayout.Width(smallButtonWidth)))
  370.             {
  371.                 InsertField(i + 1);
  372.             }
  373.             if (GUILayout.Button("-", GUILayout.Width(smallButtonWidth)))
  374.             {
  375.                 RemoveField(i);
  376.             }
  377.             EditorGUILayout.EndHorizontal();
  378.             if (i < mFields.arraySize && mFields.GetArrayElementAtIndex(i).FindPropertyRelative("Foldout").boolValue)
  379.             {
  380.                 item = mFields.GetArrayElementAtIndex(i);
  381.                 targetsProperty = item.FindPropertyRelative("Targets");
  382.  
  383.                 mCurFieldIdx = i;
  384.                 if (mReorderableList[i] == null)
  385.                 {
  386.                     mReorderableList[i] = new ReorderableList(serializedObject, targetsProperty, true, false, true, true);
  387.                     mReorderableList[i].drawElementCallback = DrawTargets;
  388.                 }
  389.                 else
  390.                 {
  391.                     mReorderableList[i].serializedProperty = targetsProperty;
  392.                 }
  393.                 mReorderableList[i].DoLayoutList();
  394.             }
  395.             EditorGUILayout.EndFoldoutHeaderGroup();
  396.         }
  397.  
  398.         if (serializedObject.hasModifiedProperties)
  399.         {
  400.             serializedObject.ApplyModifiedProperties();
  401.             serializedObject.Update();
  402.         }
  403.  
  404.         EditorGUI.EndDisabledGroup();
  405.         EditorGUILayout.EndVertical();
  406.         base.OnInspectorGUI();
  407.     }
  408.     /// <summary>
  409.     /// 生成UI脚本.cs
  410.     /// </summary>
  411.     /// <param name="uiForm"></param>
  412.     /// <param name="uiFormSerializer"></param>
  413.     private void GenerateUIFormVariables(UIFormBase uiForm, SerializedObject uiFormSerializer)
  414.     {
  415.         if (uiForm == null) return;
  416.  
  417.         var monoScript = MonoScript.FromMonoBehaviour(uiForm);
  418.         var uiFormClassName = monoScript.GetClass().Name;
  419.         string scriptFile = UtilityBuiltin.ResPath.GetCombinePath(ConstEditor.UISerializeFieldDir, Utility.Text.Format("{0}.Variables.cs", uiFormClassName));
  420.         var fields = uiForm.GetFieldsProperties();
  421.         if (fields == null || fields.Length <= 0)
  422.         {
  423.             if (File.Exists(scriptFile))
  424.             {
  425.                 File.Delete(scriptFile);
  426.             }
  427.             var metaFile = scriptFile + ".meta";
  428.             if (File.Exists(metaFile))
  429.             {
  430.                 File.Delete(metaFile);
  431.             }
  432.             AssetDatabase.Refresh();
  433.             return;
  434.         }
  435.         var matchResult = Regex.Match(monoScript.text, Utility.Text.Format("partial[\\s]+class[\\s]+{0}", uiFormClassName));
  436.         string scriptPath = AssetDatabase.GetAssetPath(monoScript);
  437.         if (!matchResult.Success)
  438.         {
  439.             EditorUtility.DisplayDialog("生成UI变量失败!", Utility.Text.Format("请先手动为{0}类添加'partial'修饰符!\n{1}", uiFormClassName, scriptPath), "OK");
  440.             return;
  441.         }
  442.         List<string> nameSpaceList = new List<string> { "UnityEngine" };//默认自带的名字空间
  443.         List<string> fieldList = new List<string>();
  444.         foreach (var field in fields)
  445.         {
  446.             if (string.IsNullOrWhiteSpace(field.VarType) || string.IsNullOrWhiteSpace(field.VarName))
  447.             {
  448.                 continue;
  449.             }
  450.             var varType = GetSampleType(field.VarType);
  451.             if (varType == null)
  452.             {
  453.                 continue;
  454.             }
  455.             if (!string.IsNullOrEmpty(varType.Namespace) && !nameSpaceList.Contains(varType.Namespace))
  456.             {
  457.                 nameSpaceList.Add(varType.Namespace);
  458.             }
  459.             bool isArray = field.Targets.Length > 1;
  460.  
  461.             var varPrefix = field.VarPrefix;// varPrefixArr[field.VarPrefixSelectedIdx];
  462.             string serializeFieldPrefix = useSerializeMode ? "[SerializeField] " : "";
  463.             string fieldLine;
  464.             if (isArray)
  465.             {
  466.                 fieldLine = Utility.Text.Format("{0}{1} {2}[] {3} = null;", serializeFieldPrefix, varPrefix, varType.Name, field.VarName);
  467.             }
  468.             else
  469.             {
  470.                 fieldLine = Utility.Text.Format("{0}{1} {2} {3} = null;", serializeFieldPrefix, varPrefix, varType.Name, field.VarName);
  471.             }
  472.             fieldList.Add(fieldLine);
  473.         }
  474.         StringBuilder stringBuilder = new StringBuilder();
  475.         stringBuilder.AppendLine("//---------------------------------");
  476.         stringBuilder.AppendLine("//此文件由工具自动生成,请勿手动修改");
  477.         stringBuilder.AppendLine($"//更新自:{CloudProjectSettings.userName}");
  478.         stringBuilder.AppendLine($"//更新时间:{DateTime.Now}");
  479.         stringBuilder.AppendLine("//---------------------------------");
  480.         foreach (var item in nameSpaceList)
  481.         {
  482.             stringBuilder.AppendLine(Utility.Text.Format("using {0};", item));
  483.         }
  484.         string uiFormClassNameSpace = monoScript.GetClass().Namespace;
  485.         bool hasNameSpace = !string.IsNullOrWhiteSpace(uiFormClassNameSpace);
  486.         if (hasNameSpace)
  487.         {
  488.             stringBuilder.AppendLine(Utility.Text.Format("namespace {0}", uiFormClassNameSpace));
  489.             stringBuilder.AppendLine("{");
  490.         }
  491.         stringBuilder.AppendLine(Utility.Text.Format("public partial class {0}", uiFormClassName));
  492.         stringBuilder.AppendLine("{");
  493.         if (useSerializeMode)
  494.         {
  495.             stringBuilder.AppendLine("\t[Space(10)]");
  496.             stringBuilder.AppendLine("\t[Header(\"Auto Genertate Properties:\")]");
  497.         }
  498.         foreach (var item in fieldList)
  499.         {
  500.             stringBuilder.AppendLine("\t" + item);
  501.         }
  502.         //不使用Serialize模式时直接生成获取组件的代码
  503.         if (!useSerializeMode)
  504.         {
  505.             GeneratePropertiesUseGetComponent(stringBuilder, fields);
  506.         }
  507.         stringBuilder.AppendLine("}");
  508.         if (hasNameSpace) stringBuilder.AppendLine("}");
  509.  
  510.         File.WriteAllText(scriptFile, stringBuilder.ToString());
  511.         AssetDatabase.Refresh();
  512.         //SerializeFieldProperties(uiFormSerializer, fields);
  513.     }
  514.     private void GeneratePropertiesUseGetComponent(StringBuilder stringBuilder, SerializeFieldData[] fields)
  515.     {
  516.         stringBuilder.AppendLine("\tprotected override void InitUIProperties()");
  517.         stringBuilder.AppendLine("\t{");
  518.         stringBuilder.AppendLine("\t\tvar fields = this.GetFieldsProperties();");
  519.         for (int i = 0; i < fields.Length; i++)
  520.         {
  521.             var field = fields[i];
  522.             bool isArray = field.Targets.Length > 1;
  523.             bool isGameObject = field.VarType.CompareTo(typeof(GameObject).FullName) == 0;
  524.             if (isArray)
  525.             {
  526.                 if (isGameObject)
  527.                     stringBuilder.AppendLine(Utility.Text.Format("\t\t{0} = fields[{1}].Targets;", field.VarName, i));
  528.                 else
  529.                     stringBuilder.AppendLine(Utility.Text.Format("\t\t{0} = fields[{1}].GetComponents<{2}>();", field.VarName, i, field.VarSampleType));
  530.             }
  531.             else
  532.             {
  533.                 if (isGameObject)
  534.                     stringBuilder.AppendLine(Utility.Text.Format("\t\t{0} = fields[{1}].Targets[0];", field.VarName, i));
  535.                 else
  536.                     stringBuilder.AppendLine(Utility.Text.Format("\t\t{0} = fields[{1}].GetComponent<{2}>(0);", field.VarName, i, field.VarSampleType));
  537.             }
  538.         }
  539.         stringBuilder.AppendLine("\t}");
  540.     }
  541.     private void SerializeFieldProperties(SerializedObject serializedObject, SerializeFieldData[] fields)
  542.     {
  543.         if (serializedObject == null)
  544.         {
  545.             Debug.LogError("生成UI SerializedField失败, serializedObject为null");
  546.             return;
  547.         }
  548.  
  549.         foreach (var item in fields)
  550.         {
  551.             string varName = item.VarName;
  552.             string varType = item.VarType;
  553.             bool isGameObject = varType.CompareTo(typeof(GameObject).FullName) == 0;
  554.             var property = serializedObject.FindProperty(varName);
  555.             if (property == null) continue;
  556.             if (item.Targets.Length <= 1)
  557.             {
  558.                 property.objectReferenceValue = isGameObject ? item.Targets[0] : item.Targets[0]?.GetComponent(GetSampleType(varType));
  559.             }
  560.             else if (property.isArray)
  561.             {
  562.                 property.ClearArray();
  563.                 for (int i = 0; i < item.Targets.Length; i++)
  564.                 {
  565.                     if (i >= property.arraySize)
  566.                     {
  567.                         property.InsertArrayElementAtIndex(i);
  568.                     }
  569.                     property.GetArrayElementAtIndex(i).objectReferenceValue = isGameObject ? item.Targets[i] : item.Targets[i]?.GetComponent(GetSampleType(varType));
  570.                 }
  571.                 //for (int i = property.arraySize - 1; i >= item.Targets.Length; i--)
  572.                 //{
  573.                 //    property.DeleteArrayElementAtIndex(i);
  574.                 //}
  575.             }
  576.         }
  577.         serializedObject.ApplyModifiedProperties();
  578.     }
  579.  
  580.     private void CheckAndInitFields()
  581.     {
  582.         if (uiForm.GetFieldsProperties() == null)
  583.         {
  584.             uiForm.ModifyFieldsProperties(new SerializeFieldData[0]);
  585.         }
  586.         if (mFields == null) mFields = serializedObject.FindProperty("_fields");
  587.  
  588.         if (mFields.arraySize != mReorderableList.Length)
  589.         {
  590.             if (mFields.arraySize > mReorderableList.Length)
  591.             {
  592.                 for (int i = mReorderableList.Length; i < mFields.arraySize; i++)
  593.                 {
  594.                     ArrayUtility.Insert(ref mReorderableList, mReorderableList.Length, null);
  595.                 }
  596.             }
  597.             else
  598.             {
  599.                 for (int i = mFields.arraySize; i < mReorderableList.Length; i++)
  600.                 {
  601.                     ArrayUtility.RemoveAt(ref mReorderableList, mReorderableList.Length - 1);
  602.                 }
  603.             }
  604.         }
  605.     }
  606.  
  607.     private void InsertField(int idx)
  608.     {
  609.         Undo.RecordObject(uiForm, uiForm.name);
  610.         mFields.InsertArrayElementAtIndex(idx);
  611.         ArrayUtility.Insert(ref mReorderableList, idx, null);
  612.         var lastField = mFields.GetArrayElementAtIndex(idx);
  613.         if (lastField != null)
  614.         {
  615.             var lastVarName = lastField.FindPropertyRelative("VarName");
  616.             if (!string.IsNullOrEmpty(lastVarName.stringValue))
  617.             {
  618.                 lastVarName.stringValue += idx.ToString();
  619.             }
  620.         }
  621.     }
  622.     private void RemoveField(int idx)
  623.     {
  624.         Undo.RecordObject(uiForm, uiForm.name);
  625.         mFields.DeleteArrayElementAtIndex(idx);
  626.         ArrayUtility.RemoveAt(ref mReorderableList, idx);
  627.     }
  628.     private void DrawTargets(Rect rect, int index, bool isActive, bool isFocused)
  629.     {
  630.         EditorGUI.BeginDisabledGroup(EditorApplication.isCompiling || EditorApplication.isUpdating || EditorApplication.isPlaying);
  631.         var field = mFields.GetArrayElementAtIndex(mCurFieldIdx);
  632.         var targetsProperty = field.FindPropertyRelative("Targets");
  633.         var targetProperty = targetsProperty.GetArrayElementAtIndex(index);
  634.         var curRect = new Rect(rect.x, rect.y, 20, EditorGUIUtility.singleLineHeight);
  635.         EditorGUI.LabelField(curRect, index.ToString());
  636.         curRect.x += 20;
  637.         curRect.width = rect.width - 20;
  638.         EditorGUI.ObjectField(curRect, targetProperty, GUIContent.none);
  639.         EditorGUI.EndDisabledGroup();
  640.     }
  641.     private static string[] GetPopupContents(GameObject[] targets)
  642.     {
  643.         if (targets == null || targets.Length <= 0)
  644.         {
  645.             return new string[0];
  646.         }
  647.         var typeNames = GetIntersectionComponents(targets);
  648.         if (typeNames == null || typeNames.Length <= 0)
  649.         {
  650.             return new string[0];
  651.         }
  652.         ArrayUtility.Insert(ref typeNames, 0, typeof(GameObject).FullName);
  653.         return typeNames;
  654.     }
  655.     private static string[] GetPopupContents(SerializedProperty targets)
  656.     {
  657.         var goArr = new GameObject[targets.arraySize];
  658.         for (int i = 0; i < targets.arraySize; i++)
  659.         {
  660.             var pp = targets.GetArrayElementAtIndex(i);
  661.             goArr[i] = (pp != null && pp.objectReferenceValue != null) ? (pp.objectReferenceValue as GameObject) : null;
  662.         }
  663.         return GetPopupContents(goArr);
  664.     }
  665.     private static string[] GetIntersectionComponents(GameObject[] targets)
  666.     {
  667.         var firstItm = targets[0];
  668.         if (firstItm == null)
  669.         {
  670.             return new string[0];
  671.         }
  672.         var coms = firstItm.GetComponents(typeof(Component));
  673.         coms = coms.Distinct().ToArray();//去重
  674.  
  675.         for (int i = coms.Length - 1; i >= 1; i--)
  676.         {
  677.             var comType = coms[i].GetType().FullName;
  678.             bool allContains = true;
  679.             for (int j = 1; j < targets.Length; j++)
  680.             {
  681.                 var target = targets[j];
  682.                 if (target == null) return new string[0];
  683.                 var tComs = target.GetComponents(typeof(Component));
  684.                 bool containsType = false;
  685.                 for (int k = 0; k < tComs.Length; k++)
  686.                 {
  687.                     if (tComs[k].GetType().FullName.CompareTo(comType) == 0)
  688.                     {
  689.                         containsType = true;
  690.                         break;
  691.                     }
  692.                 }
  693.                 allContains &= containsType;
  694.                 if (!allContains) break;
  695.             }
  696.             if (!allContains)
  697.             {
  698.                 ArrayUtility.RemoveAt(ref coms, i);
  699.             }
  700.         }
  701.         string[] typesArr = new string[coms.Length];
  702.         for (int i = 0; i < coms.Length; i++)
  703.         {
  704.             typesArr[i] = coms[i].GetType().FullName;
  705.         }
  706.         return typesArr;
  707.     }
  708.  
  709.     /// <summary>
  710.     /// 生成一个与变量列表里不重名的变量名
  711.     /// </summary>
  712.     /// <param name="fields"></param>
  713.     /// <param name="name"></param>
  714.     /// <returns></returns>
  715.     private static string GenerateFieldName(SerializeFieldData[] fields, GameObject[] targets)
  716.     {
  717.         var go = targets[0];
  718.         string varName = Regex.Replace(go.name, "[^\\w]", string.Empty);
  719.         if (fields == null || fields.Length <= 0)
  720.         {
  721.             return FirstCharToLower(targets.Length > 1 ? varName + arrFlag : varName);
  722.         }
  723.         bool contains = false;
  724.  
  725.         foreach (SerializeFieldData item in fields)
  726.         {
  727.             if (item != null && item.VarName.CompareTo(varName) == 0)
  728.             {
  729.                 contains = true;
  730.             }
  731.         }
  732.         if (targets.Length > 1)
  733.         {
  734.             varName += arrFlag;
  735.         }
  736.         if (contains)
  737.         {
  738.             varName += go.GetInstanceID();
  739.         }
  740.  
  741.         return FirstCharToLower(varName);
  742.     }
  743.     private static string FirstCharToLower(string str)
  744.     {
  745.         if (string.IsNullOrEmpty(str))
  746.         {
  747.             return string.Empty;
  748.         }
  749.         return str.Substring(0, 1).ToLower() + str.Substring(1);
  750.     }
  751. }
  752. #endif

工具源码：GitHub - sunsvip/GF_HybridCLR

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/115287
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号