• 【Unity编辑器扩展】GF_HybridCLR自定义Toolbar, 一键出包/打热更扩展工具

    GF_HybridCLR是基于GameFramework + HybridCLR的一款工具链完善，工作流简洁的游戏框架。拥有标准高效的开发工作流，开箱即用，适用于快速研发。

    出包时经常遇到忘记刷新配置表、忘记重新打AB包等等，接入HybridCLR每次打热更包也需要重新编译热更dll，新发App时需要生成桥接函数等。各种琐碎的打包准备工作，一旦忘记操作就容易出故障。基于工作中遇到的痛点，迫切需要写一个傻瓜式一键打包/打热更的工具。

    为了这个一键打包工具入口突出，就把它放在Unity编辑器的Toolbar栏，如图：

     点击Toolbar栏Build App/Hotfix后打开一键打包/打热更工具：

    一，扩展Unity编辑器的菜单栏(Toolbar):

    Toolbar扩展方法可参考github开源项目: GitHub - marijnz/unity-toolbar-extender: Extend the Unity Toolbar with your own Editor UI code.

     实现原理，通过反射获取UnityEditor的Toolbar类，扩展GUI出回调。

    Toolbar扩展插件源代码:

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Reflection;
    4. using UnityEditor;
    5. using UnityEngine;
    6. #if UNITY_2019_1_OR_NEWER
    7. using UnityEngine.UIElements;
    8. #else
    9. using UnityEngine.Experimental.UIElements;
    10. #endif
    11.  
    12. namespace UnityToolbarExtender
    13. {
    14.     public static class ToolbarCallback
    15.     {
    16.         static Type m_toolbarType = typeof(Editor).Assembly.GetType("UnityEditor.Toolbar");
    17.         static Type m_guiViewType = typeof(Editor).Assembly.GetType("UnityEditor.GUIView");
    18. #if UNITY_2020_1_OR_NEWER
    19.         static Type m_iWindowBackendType = typeof(Editor).Assembly.GetType("UnityEditor.IWindowBackend");
    20.         static PropertyInfo m_windowBackend = m_guiViewType.GetProperty("windowBackend",
    21.             BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
    22.         static PropertyInfo m_viewVisualTree = m_iWindowBackendType.GetProperty("visualTree",
    23.             BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
    24. #else
    25. 		static PropertyInfo m_viewVisualTree = m_guiViewType.GetProperty("visualTree",
    26. 			BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
    27. #endif
    28.         static FieldInfo m_imguiContainerOnGui = typeof(IMGUIContainer).GetField("m_OnGUIHandler",
    29.             BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
    30.         static ScriptableObject m_currentToolbar;
    31.  
    32.         /// 
    33.         /// Callback for toolbar OnGUI method.
    34.         /// 
    35.         public static Action OnToolbarGUI;
    36.         public static Action OnToolbarGUILeft;
    37.         public static Action OnToolbarGUIRight;
    38.  
    39.         static ToolbarCallback()
    40.         {
    41.             EditorApplication.update -= OnUpdate;
    42.             EditorApplication.update += OnUpdate;
    43.         }
    44.  
    45.         static void OnUpdate()
    46.         {
    47.             // Relying on the fact that toolbar is ScriptableObject and gets deleted when layout changes
    48.             if (m_currentToolbar == null)
    49.             {
    50.                 // Find toolbar
    51.                 var toolbars = Resources.FindObjectsOfTypeAll(m_toolbarType);
    52.                 m_currentToolbar = toolbars.Length > 0 ? (ScriptableObject)toolbars[0] : null;
    53.                 if (m_currentToolbar != null)
    54.                 {
    55. #if UNITY_2021_1_OR_NEWER
    56.                     var root = m_currentToolbar.GetType().GetField("m_Root", BindingFlags.NonPublic | BindingFlags.Instance);
    57.                     var rawRoot = root.GetValue(m_currentToolbar);
    58.                     var mRoot = rawRoot as VisualElement;
    59.                     RegisterCallback("ToolbarZoneLeftAlign", OnToolbarGUILeft);
    60.                     RegisterCallback("ToolbarZoneRightAlign", OnToolbarGUIRight);
    61.  
    62.                     void RegisterCallback(string root, Action cb)
    63.                     {
    64.                         var toolbarZone = mRoot.Q(root);
    65.  
    66.                         var parent = new VisualElement()
    67.                         {
    68.                             style = {
    69.                                 flexGrow = 1,
    70.                                 flexDirection = FlexDirection.Row,
    71.                             }
    72.                         };
    73.                         var container = new IMGUIContainer();
    74.                         container.style.flexGrow = 1;
    75.                         container.onGUIHandler += () => {
    76.                             cb?.Invoke();
    77.                         };
    78.                         parent.Add(container);
    79.                         toolbarZone.Add(parent);
    80.                     }
    81. #else
    82. #if UNITY_2020_1_OR_NEWER
    83. 					var windowBackend = m_windowBackend.GetValue(m_currentToolbar);
    84.  
    85. 					// Get it's visual tree
    86. 					var visualTree = (VisualElement) m_viewVisualTree.GetValue(windowBackend, null);
    87. #else
    88. 					// Get it's visual tree
    89. 					var visualTree = (VisualElement) m_viewVisualTree.GetValue(m_currentToolbar, null);
    90. #endif
    91.  
    92. 					// Get first child which 'happens' to be toolbar IMGUIContainer
    93. 					var container = (IMGUIContainer) visualTree[0];
    94.  
    95. 					// (Re)attach handler
    96. 					var handler = (Action) m_imguiContainerOnGui.GetValue(container);
    97. 					handler -= OnGUI;
    98. 					handler += OnGUI;
    99. 					m_imguiContainerOnGui.SetValue(container, handler);
    100. 					
    101. #endif
    102.                 }
    103.             }
    104.         }
    105.  
    106.         static void OnGUI()
    107.         {
    108.             var handler = OnToolbarGUI;
    109.             if (handler != null) handler();
    110.         }
    111.     }
    112.  
    113.     [InitializeOnLoad]
    114.     public static class UnityEditorToolbar
    115.     {
    116.         static int m_toolCount;
    117.         static GUIStyle m_commandStyle = null;
    118.  
    119.         public static readonly List LeftToolbarGUI = new List();
    120.         public static readonly List RightToolbarGUI = new List();
    121.  
    122.         static UnityEditorToolbar()
    123.         {
    124.             Type toolbarType = typeof(Editor).Assembly.GetType("UnityEditor.Toolbar");
    125.  
    126. #if UNITY_2019_1_OR_NEWER
    127.             string fieldName = "k_ToolCount";
    128. #else
    129. 			string fieldName = "s_ShownToolIcons";
    130. #endif
    131.  
    132.             FieldInfo toolIcons = toolbarType.GetField(fieldName,
    133.                 BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
    134.  
    135. #if UNITY_2019_3_OR_NEWER
    136.             m_toolCount = toolIcons != null ? ((int)toolIcons.GetValue(null)) : 8;
    137. #elif UNITY_2019_1_OR_NEWER
    138. 			m_toolCount = toolIcons != null ? ((int) toolIcons.GetValue(null)) : 7;
    139. #elif UNITY_2018_1_OR_NEWER
    140. 			m_toolCount = toolIcons != null ? ((Array) toolIcons.GetValue(null)).Length : 6;
    141. #else
    142. 			m_toolCount = toolIcons != null ? ((Array) toolIcons.GetValue(null)).Length : 5;
    143. #endif
    144.  
    145.             ToolbarCallback.OnToolbarGUI = OnGUI;
    146.             ToolbarCallback.OnToolbarGUILeft = GUILeft;
    147.             ToolbarCallback.OnToolbarGUIRight = GUIRight;
    148.         }
    149.  
    150. #if UNITY_2019_3_OR_NEWER
    151.         public const float space = 8;
    152. #else
    153. 		public const float space = 10;
    154. #endif
    155.         public const float largeSpace = 20;
    156.         public const float buttonWidth = 32;
    157.         public const float dropdownWidth = 80;
    158. #if UNITY_2019_1_OR_NEWER
    159.         public const float playPauseStopWidth = 140;
    160. #else
    161. 		public const float playPauseStopWidth = 100;
    162. #endif
    163.  
    164.         static void OnGUI()
    165.         {
    166.             // Create two containers, left and right
    167.             // Screen is whole toolbar
    168.  
    169.             if (m_commandStyle == null)
    170.             {
    171.                 m_commandStyle = new GUIStyle("CommandLeft");
    172.             }
    173.  
    174.             var screenWidth = EditorGUIUtility.currentViewWidth;
    175.  
    176.             // Following calculations match code reflected from Toolbar.OldOnGUI()
    177.             float playButtonsPosition = Mathf.RoundToInt((screenWidth - playPauseStopWidth) / 2);
    178.  
    179.             Rect leftRect = new Rect(0, 0, screenWidth, Screen.height);
    180.             leftRect.xMin += space; // Spacing left
    181.             leftRect.xMin += buttonWidth * m_toolCount; // Tool buttons
    182. #if UNITY_2019_3_OR_NEWER
    183.             leftRect.xMin += space; // Spacing between tools and pivot
    184. #else
    185. 			leftRect.xMin += largeSpace; // Spacing between tools and pivot
    186. #endif
    187.             leftRect.xMin += 64 * 2; // Pivot buttons
    188.             leftRect.xMax = playButtonsPosition;
    189.  
    190.             Rect rightRect = new Rect(0, 0, screenWidth, Screen.height);
    191.             rightRect.xMin = playButtonsPosition;
    192.             rightRect.xMin += m_commandStyle.fixedWidth * 3; // Play buttons
    193.             rightRect.xMax = screenWidth;
    194.             rightRect.xMax -= space; // Spacing right
    195.             rightRect.xMax -= dropdownWidth; // Layout
    196.             rightRect.xMax -= space; // Spacing between layout and layers
    197.             rightRect.xMax -= dropdownWidth; // Layers
    198. #if UNITY_2019_3_OR_NEWER
    199.             rightRect.xMax -= space; // Spacing between layers and account
    200. #else
    201. 			rightRect.xMax -= largeSpace; // Spacing between layers and account
    202. #endif
    203.             rightRect.xMax -= dropdownWidth; // Account
    204.             rightRect.xMax -= space; // Spacing between account and cloud
    205.             rightRect.xMax -= buttonWidth; // Cloud
    206.             rightRect.xMax -= space; // Spacing between cloud and collab
    207.             rightRect.xMax -= 78; // Colab
    208.  
    209.             // Add spacing around existing controls
    210.             leftRect.xMin += space;
    211.             leftRect.xMax -= space;
    212.             rightRect.xMin += space;
    213.             rightRect.xMax -= space;
    214.  
    215.             // Add top and bottom margins
    216. #if UNITY_2019_3_OR_NEWER
    217.             leftRect.y = 4;
    218.             leftRect.height = 22;
    219.             rightRect.y = 4;
    220.             rightRect.height = 22;
    221. #else
    222. 			leftRect.y = 5;
    223. 			leftRect.height = 24;
    224. 			rightRect.y = 5;
    225. 			rightRect.height = 24;
    226. #endif
    227.  
    228.             if (leftRect.width > 0)
    229.             {
    230.                 GUILayout.BeginArea(leftRect);
    231.                 GUILayout.BeginHorizontal();
    232.                 foreach (var handler in LeftToolbarGUI)
    233.                 {
    234.                     handler();
    235.                 }
    236.  
    237.                 GUILayout.EndHorizontal();
    238.                 GUILayout.EndArea();
    239.             }
    240.  
    241.             if (rightRect.width > 0)
    242.             {
    243.                 GUILayout.BeginArea(rightRect);
    244.                 GUILayout.BeginHorizontal();
    245.                 foreach (var handler in RightToolbarGUI)
    246.                 {
    247.                     handler();
    248.                 }
    249.  
    250.                 GUILayout.EndHorizontal();
    251.                 GUILayout.EndArea();
    252.             }
    253.         }
    254.  
    255.         public static void GUILeft()
    256.         {
    257.             GUILayout.BeginHorizontal();
    258.             foreach (var handler in LeftToolbarGUI)
    259.             {
    260.                 handler();
    261.             }
    262.             GUILayout.EndHorizontal();
    263.         }
    264.  
    265.         public static void GUIRight()
    266.         {
    267.             GUILayout.BeginHorizontal();
    268.             foreach (var handler in RightToolbarGUI)
    269.             {
    270.                 handler();
    271.             }
    272.             GUILayout.EndHorizontal();
    273.         }
    274.     }
    275. }

    使用方法: 

    定义一个静态类添加[UnityEditor.InitializeOnLoad]，使其自动执行构造函数。

    在Toolbar右侧绘制GUI: UnityEditorToolbar.RightToolbarGUI.Add(OnRightToolbarGUI);
    在Toolbar左侧绘制GUI: UnityEditorToolbar.LeftToolbarGUI.Add(OnLeftToolbarGUI);

    1. using UnityEngine;
    2. using UnityEditor;
    3. using UnityToolbarExtender;
    4. using UnityGameFramework.Editor.ResourceTools;
    5. [UnityEditor.InitializeOnLoad]
    6. public static class EditorToolbarExtension
    7. {
    8.     private static GUIContent buildBtContent;
    9.  
    10.     static EditorToolbarExtension()
    11.     {
    12.         buildBtContent = EditorGUIUtility.TrTextContentWithIcon("Build App/Hotfix","打新包/打热更", "UnityLogo");
    13.         UnityEditorToolbar.RightToolbarGUI.Add(OnRightToolbarGUI);
    14.         UnityEditorToolbar.LeftToolbarGUI.Add(OnLeftToolbarGUI);
    15.     }
    16.  
    17.     private static void OnLeftToolbarGUI()
    18.     {
    19.         //在Toolbar左侧绘制UI
    20.     }
    21.  
    22.     private static void OnRightToolbarGUI()
    23.     {
    24. //在Toolbar右侧绘制UI
    25.         if (GUILayout.Button(buildBtContent,EditorStyles.toolbarButton, GUILayout.MaxWidth(125), GUILayout.Height(EditorGUIUtility.singleLineHeight)))
    26.         {
    27.             AppBuildEidtor.Open();
    28.             GUIUtility.ExitGUI();
    29.         }
    30.         GUILayout.FlexibleSpace();
    31.     }
    32. }

    二，打包工具功能设计： 

     先明确工具要解决的问题：

    1. 工具界面可配置打资源和打App的相关设置，切配置持久化保存。

    2. 可一键打热更资源，一键出包，简化流程。

    具体功能设计：

    1. 打单机包或增量热更包：

    单机包或增量热更包出包时都需要把AB资源打进包里，点击Build App按钮逻辑流程为：若是热更包则生成热更(hotfix)Dll => 自动处理AB包重复依赖资源 =>  打AB包 => 把AB包复制到SteamingAssets目录 => 若是热更包则执行HybridCLR预处理命令(生成link.xml，桥接函数等) => 把AOT泛型补充dll自动复制到Resources目录 => Build出包；

    Build出包需要根据目标平台留出一些打包常用的参数设置入口，例如app版本号、Version Code, 打aab(谷歌商店包)，开发者模式，安卓密钥等。

    2. 打全热更包：

    ①全热更包是进入游戏后再从热更地址下载资源，所以出包时不用打AB包。点击Build App按钮逻辑流程为：HybridCLR预处理命令(生成link.xml，桥接函数等) => 把AOT泛型补充dll自动复制到Resources目录 => Build出包；

    ②打热更资源和dll，对于热更包(增量热更/全热更)，每次更新只需要点击Build Resources按钮打出热更资源，然后把热更资源上传到资源服务器即可。点击Build Resources按钮逻辑流程为：一生成热更dll => 自动处理AB包重复依赖资源 =>  打AB包；把打出的AB包提交到热更新资源服务器即可。

    3. 其它功能：

    打资源/出包常用配置项可在界面中配置并持久化保存配置数据；

    Resource Mode: 可选择资源模式，单机模式 / 全热更模式 / 部分热更模式(即，需要某部分资源时再热更)

    除了上述部分，还需要在各个功能模块区域显示对应的一键跳转按钮，如：

    Resource Editor按钮: 打开AB包编辑器

    Hotfix Settings按钮：打开HybridCLR Settings界面，配置C#代码热更相关(一般只需要配置一次)

    Player Settings按钮：打开Player Setting界面，设置出包参数。

    三，具体功能实现：

    由于GF框架内置的打AB包工具已经有了打资源的相关配置和功能按钮，索性直接基于GF的Resource Builder工具做修改。

    1. Resource Editor按钮， 打开GF的Resource Editor(AB包编辑器)：

    UnityGameFramework.Editor.ResourceTools.ResourceEditor类有个打开窗口的静态私有方法“Open”， 只需要通过反射调用即可：

    1. private void OpenResourcesEditor()
    2.         {
    3.             var resEditorClass = Utility.Assembly.GetType("UnityGameFramework.Editor.ResourceTools.ResourceEditor");
    4.             resEditorClass?.GetMethod("Open", BindingFlags.Static | BindingFlags.NonPublic)?.Invoke(null, null);
    5.         }

    2. Resource Mode资源模式切换(单机/全热更/需要时热更)：

    ResourceComponent留出了SetResourceMode()方法，但运行时调用却报错，原来ResourceComponent在Start回调里根据Resource Mode做一次初始化，不允许初始化之后再修改，即使修改了ResourceMode也是无效的。为了保持低耦合不能改GF源码，只能特殊处理，在其它MonoBehavior脚本的Awake方法中通过反射修改ResourceComponent的私有变量m_ResourceMode，Awake方法早于ResourceComponent的Start，这样设置就能生效了。

    1. private void Awake()
    2.     {
    3.         var resCom = GameEntry.GetComponent();
    4.         if (resCom != null)
    5.         {
    6.             var resTp = resCom.GetType();
    7.             var m_ResourceMode = resTp.GetField("m_ResourceMode", BindingFlags.Instance | BindingFlags.NonPublic);
    8.             m_ResourceMode.SetValue(resCom, AppSettings.Instance.ResourceMode);
    9.             Log.Info("------------Set ResourceMode:{0}", AppSettings.Instance.ResourceMode);
    10.         }
    11.     }

    其中AppSettings是一个运行时的ScriptableObject，用于保存一些运行时配置，如是否开启debug模式，ResourceMode类型等。

    AppSettings配置文件实现：

    1. using GameFramework.Resource;
    2. using UnityEngine;
    3.  
    4. [CreateAssetMenu(fileName = "AppSettings", menuName = "ScriptableObject/AppSettings")]
    5. public class AppSettings : ScriptableObject
    6. {
    7.     private static AppSettings mInstance = null;
    8.     public static AppSettings Instance
    9.     {
    10.         get
    11.         {
    12.             if (mInstance == null)
    13.             {
    14.                 mInstance = Resources.Load("AppSettings");
    15.             }
    16.             return mInstance;
    17.         }
    18.     }
    19.     [Tooltip("debug模式,默认显示debug窗口")]
    20.     public bool DebugMode = false;
    21.     [Tooltip("资源模式: 单机/全热更/需要时热更")]
    22.     public ResourceMode ResourceMode = ResourceMode.Package;
    23. }

    AppSettings是全局配置，因此使用单例模式。当打包工具界面打开时，检测Resource目录是否存在AppSettings配置文件，若无则自动创建。工具界面ResourceMode设置实时同步保存到AppSettings， 游戏运行时获取并应用AppSettings中的配置。

    Hotfix Settings(热更相关设置):

    打热更资源时根据这些配置自动生成version.json文件，其中信息包含热更包hash code， 资源大小、资源版本号、热更下载地址、App是否有新版本、是否强制更新App、当前版本资源适用于哪些App版本等。游戏启动时会先从服务器请求version.json信息检测是否需要更新。

    热更基本流程

     Update Prefix Uri: 热更资源下载地址；

    Applicable Verison：当前版本资源适用哪些App版本,多版本用‘|’分割；

    App Update Url：App下载跳转链接；

    Force Update：是否强制更新App；

    App Update Description：App更新说明，显示在新版本提示对话框；

    Hotfix Settings跳转按钮，跳转到HybridCLR设置界面：

    SettingsService.OpenProjectSettings("Project/HybridCLR Settings");

    跳转到Player Settings界面：

    SettingsService.OpenProjectSettings("Project/Player");

    Build App Settings(出包相关设置)：

    Build App Buindle: 打谷歌商店aab文件；

    Development Build: 开发者模式打包；

    Debug Mode: 调试模式，true:默认显示GF Debug窗口；

    Use Custom Keystore: 使用自定义keystore打安卓包；

    选择keystore文件：

    1. if (GUILayout.Button("Select Keystore", GUILayout.Width(160f)))
    2.                         {
    3.                             var keystoreDir = string.IsNullOrWhiteSpace(AppBuildSettings.Instance.AndroidKeystoreName) ? Directory.GetParent(Application.dataPath).FullName : Path.GetDirectoryName(AppBuildSettings.Instance.AndroidKeyAliasName);
    4.                             var openPath = Directory.Exists(keystoreDir) ? keystoreDir : Directory.GetParent(Application.dataPath).FullName;
    5.                             string path = EditorUtility.OpenFilePanel("Select Keystore", openPath, "keystore,jks,ks");
    6.                             AppBuildSettings.Instance.AndroidKeystoreName = PlayerSettings.Android.keystoreName = path;
    7.                             GUIUtility.ExitGUI();
    8.                         }

    一键打热更资源实现：

    直接调用GF框架自带的ResourceBuilderController的BuildResources()方法即可；

    一键出包：

    Unity的Build Settings界面已经有了现成的出包功能，可以直接通过反射调用。

     从Unity开源代码中可以找到具体实现：https://github.com/Unity-Technologies/UnityCsReference

     在BuildPlayerWindow.cs可以看到，Build按钮调用了CallBuildMethods静态方法，但是此方法每次Build都会弹出Build路径选择界面，这绝对是不能接受的。而且我们还需要根据版本号、是否为debug版等信息命名包文件。

    查看BuildPlayerWindowBuildMethods.cs源码可以发现，BuildPlayerWindow.RegisterGetBuildPlayerOptionsHandler()函数可以注册打包配置获取参数，这样就可以修打包配置，自动设置打包路径。

    自定义打包配置：

    1. private void Awake()
    2. {
    3.     BuildPlayerWindow.RegisterGetBuildPlayerOptionsHandler(CustomBuildOptions);
    4. }
    5.  
    6. private BuildPlayerOptions CustomBuildOptions(BuildPlayerOptions options)
    7.         {
    8.             var buildTarget = GetSelectedBuildTarget();
    9.             BuildTargetGroup buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
    10.             int subtarget = (int)Utility.Assembly.GetType("UnityEditor.EditorUserBuildSettings").GetMethod("GetSelectedSubtargetFor", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { buildTarget });
    11.  
    12.             string buildLocation = GetBuildLocation(buildTargetGroup, buildTarget, subtarget, options.options);
    13.             bool isDir = !Path.HasExtension(buildLocation);
    14.             if (string.IsNullOrWhiteSpace(buildLocation) || (isDir && !Directory.Exists(buildLocation)))
    15.                 throw new BuildMethodException("Build location for buildTarget " + buildTarget + " is not valid.");
    16.  
    17.             //Check if Lz4 is supported for the current buildtargetgroup and enable it if need be
    18.             if ((bool)Utility.Assembly.GetType("UnityEditor.PostprocessBuildPlayer").GetMethod("SupportsLz4Compression", BindingFlags.Static | BindingFlags.Public).Invoke(null, new object[] { buildTargetGroup, buildTarget }))
    19.             {
    20.                 //internal enum Compression
    21.                 //{
    22.                 //    None = 0,
    23.                 //    Lz4 = 2,
    24.                 //    Lz4HC = 3,
    25.                 //}
    26.                 var compression = (int)Utility.Assembly.GetType("UnityEditor.EditorUserBuildSettings").GetMethod("GetCompressionType", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { buildTargetGroup });
    27.                 if (compression < 0)
    28.                     compression = (int)Utility.Assembly.GetType("UnityEditor.PostprocessBuildPlayer").GetMethod("GetDefaultCompression", BindingFlags.Static | BindingFlags.Public).Invoke(null, new object[] { buildTargetGroup, buildTarget });
    29.                 if (compression == 2)//Lz4
    30.                     options.options |= BuildOptions.CompressWithLz4;
    31.                 else if (compression == 3)//Lz4HC
    32.                     options.options |= BuildOptions.CompressWithLz4HC;
    33.             }
    34.  
    35.             bool developmentBuild = EditorUserBuildSettings.development;
    36.             if (developmentBuild)
    37.                 options.options |= BuildOptions.Development;
    38.             if (EditorUserBuildSettings.allowDebugging && developmentBuild)
    39.                 options.options |= BuildOptions.AllowDebugging;
    40.             if (EditorUserBuildSettings.symlinkSources)
    41.                 options.options |= BuildOptions.SymlinkSources;
    42.             if (EditorUserBuildSettings.connectProfiler && (developmentBuild || buildTarget == BuildTarget.WSAPlayer))
    43.                 options.options |= BuildOptions.ConnectWithProfiler;
    44.             if (EditorUserBuildSettings.buildWithDeepProfilingSupport && developmentBuild)
    45.                 options.options |= BuildOptions.EnableDeepProfilingSupport;
    46.             if (EditorUserBuildSettings.buildScriptsOnly)
    47.                 options.options |= BuildOptions.BuildScriptsOnly;
    48.  
    49.             string connectID = Utility.Assembly.GetType("UnityEditor.Profiling.ProfilerUserSettings").GetProperty("customConnectionID", BindingFlags.Static | BindingFlags.Public).GetValue(null, null) as string;
    50.             if (!string.IsNullOrEmpty(connectID) && developmentBuild)
    51.                 options.options |= BuildOptions.CustomConnectionID;
    52.  
    53.             var checkFunc = typeof(UnityEditor.BuildPlayerWindow.DefaultBuildMethods).GetMethod("IsInstallInBuildFolderOption", BindingFlags.Static | BindingFlags.NonPublic);
    54.  
    55.             if ((bool)checkFunc.Invoke(null, null))
    56.             {
    57.                 options.options |= BuildOptions.InstallInBuildFolder;
    58.             }
    59.  
    60.             options.target = buildTarget;
    61.             options.subtarget = subtarget;
    62.             options.targetGroup = buildTargetGroup;
    63.             options.locationPathName = buildLocation;
    64.             options.assetBundleManifestPath = Utility.Assembly.GetType("UnityEditor.PostprocessBuildPlayer").GetMethod("GetStreamingAssetsBundleManifestPath", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null) as string;
    65.  
    66.             // Build a list of scenes that are enabled
    67.             ArrayList scenesList = new ArrayList();
    68.             EditorBuildSettingsScene[] editorScenes = EditorBuildSettings.scenes;
    69.             foreach (EditorBuildSettingsScene scene in editorScenes)
    70.             {
    71.                 if (scene.enabled)
    72.                 {
    73.                     scenesList.Add(scene.path);
    74.                     break;// GF框架只需要把启动场景打进包里,其它场景动态加载
    75.                 }
    76.             }
    77.  
    78.             options.scenes = scenesList.ToArray(typeof(string)) as string[];
    79.             return options;
    80.         }

     获取不同平台的包文件名，例如Android平台可以打出apk或aab，也可以导出安卓工程，不同设置包文件格式不同，Build出的可能是一个文件，也有可能是一个文件夹。这些Unity内部已经有函数做了处理，要用反射调用Unity内部函数：

    1. //获取Build Location
    2. private static string GetBuildLocation(BuildTargetGroup targetGroup, BuildTarget target, int subtarget, BuildOptions options)
    3.         {
    4.             string defaultFolder = UtilityBuiltin.ResPath.GetCombinePath(Directory.GetParent(Application.dataPath).FullName, AppBuildSettings.Instance.AppBuildDir, target.ToString());
    5.             string defaultName = Utility.Text.Format("{0}_{1}{2}_v{3}", Application.productName, AppSettings.Instance.DebugMode ? "debug" : "release", EditorUserBuildSettings.development ? "Dev" : string.Empty, Application.version);
    6.  
    7.             string extension = Utility.Assembly.GetType("UnityEditor.PostprocessBuildPlayer").GetMethod("GetExtensionForBuildTarget", new Type[] { typeof(BuildTargetGroup), typeof(BuildTarget), typeof(int), typeof(BuildOptions) }).Invoke(null, new object[] { targetGroup, target, subtarget, options }) as string;
    8.             string buildPath = defaultFolder;
    9.             if (!string.IsNullOrEmpty(extension))
    10.             {
    11.                 string appFileName = Utility.Text.Format("{0}.{1}", defaultName, extension);
    12.                 buildPath = UtilityBuiltin.ResPath.GetCombinePath(defaultFolder, appFileName);
    13.             }
    14.             return buildPath;
    15.         }

    然后就可以通过反射调用UnityEditor.BuildPlayerWindow.CallBuildMethods()方法：

    1. private void CallBuildMethods()
    2.         {
    3. #if !DISABLE_HYBRIDCLR
    4.             HybridCLR.Editor.Commands.PrebuildCommand.GenerateAll();
    5. #endif
    6.             var buildWin = Utility.Assembly.GetType("UnityEditor.BuildPlayerWindow");
    7.             if (buildWin != null)
    8.             {
    9.                 var buildFunc = buildWin.GetMethod("CallBuildMethods", System.Reflection.BindingFlags.Static | BindingFlags.NonPublic);
    10.                 buildFunc?.Invoke(null, new object[] { false, BuildOptions.ShowBuiltPlayer });
    11.             }
    12.         }
    13.  
    14.  
    15.  
    16. private void BuildApp()
    17.         {
    18.             if ((m_Controller.OutputPackageSelected || m_Controller.OutputPackedSelected))
    19.             {
    20.                 if (m_Controller.BuildResources())
    21.                 {
    22.                     AssetDatabase.Refresh();
    23.                     CallBuildMethods();
    24.                 }
    25.             }
    26.             else if (m_Controller.OutputFullSelected)
    27.             {
    28.                 DeleteStreamingAssets();
    29.                 CallBuildMethods();
    30.             }
    31.         }

    工具完整代码：

    1. using GameFramework;
    2. using System;
    3. using System.IO;
    4. using System.Reflection;
    5. using UnityEditor;
    6. using UnityEngine;
    7. using GameFramework.Resource;
    8. using Unity.VisualScripting;
    9. using HybridCLR.Editor.Commands;
    10. using System.Text;
    11. using System.Linq;
    12. using static UnityEditor.BuildPlayerWindow;
    13. using System.Collections;
    14.  
    15. namespace UnityGameFramework.Editor.ResourceTools
    16. {
    17.     /// 
    18.     /// 资源生成器。
    19.     /// 
    20.     public class AppBuildEidtor : EditorWindow
    21.     {
    22.         private readonly string[] keystoreExtNames = { ".keystore", ".jks", ".ks" };
    23.         private ResourceBuilderController m_Controller = null;
    24.         private bool m_OrderBuildResources = false;
    25.         private int m_CompressionHelperTypeNameIndex = 0;
    26.         private int m_BuildEventHandlerTypeNameIndex = 0;
    27.         private GUIContent hotfixUrlContent;
    28.         private GUIContent applicableVerContent;
    29.         private GUIContent forceUpdateAppContent;
    30.         private GUIContent appUpdateUrlContent;
    31.         private GUIContent appUpdateDescContent;
    32.         private GUIContent revealFolderContent;
    33.         private GUIContent buildResBtContent;
    34.         private GUIContent buildAppBtContent;
    35.         private GUIContent saveBtContent;
    36.         private GUIContent playerSettingBtContent;
    37.         private GUIContent hybridclrSettingBtContent;
    38.         private Vector2 scrollPosition;
    39.         private GUIStyle dropDownBtStyle;
    40.  
    41.         public static void Open()
    42.         {
    43.             AppBuildEidtor window = GetWindow("App Builder", true);
    44. #if UNITY_2019_3_OR_NEWER
    45.             window.minSize = new Vector2(800f, 800f);
    46. #else
    47.             window.minSize = new Vector2(800f, 750f);
    48. #endif
    49.         }
    50.         private void Awake()
    51.         {
    52.             BuildPlayerWindow.RegisterGetBuildPlayerOptionsHandler(CustomBuildOptions);
    53.         }
    54.  
    55.         private void OnEnable()
    56.         {
    57.             hotfixUrlContent = new GUIContent("Update Prefix Uri", "热更新资源服务器地址");
    58.             applicableVerContent = new GUIContent("Applicable Version", "资源适用的客户端版本号,多版本用'|'分割");
    59.             forceUpdateAppContent = new GUIContent("Force Update", "是否强制更新App");
    60.             appUpdateUrlContent = new GUIContent("App Update Url", "App更新下载地址");
    61.             appUpdateDescContent = new GUIContent("App Update Description:", "App更新公告,用于显示在对话框(支持TextMeshPro富文本)");
    62.             revealFolderContent = new GUIContent("Reveal Folder", "打包完成后打开资源输出目录");
    63.             buildResBtContent = EditorGUIUtility.TrTextContentWithIcon("Build Resources", "打AB包/热更", "CloudConnect@2x");
    64.             buildAppBtContent = EditorGUIUtility.TrTextContentWithIcon("Build App", "打新包,首次打热更包请使用Full Build", "UnityLogo");
    65.  
    66.             playerSettingBtContent = EditorGUIUtility.TrTextContentWithIcon("Player Settings", "打开Player Settings界面", "Settings");
    67.             hybridclrSettingBtContent = EditorGUIUtility.TrTextContentWithIcon("Hotfix Settings", "打开HybridCLR Settings界面", "Settings");
    68.             saveBtContent = EditorGUIUtility.TrTextContentWithIcon("Save", "保存设置", "SaveAs@2x");
    69.  
    70.             string tgStyleName = "DropDownToggleButton";
    71.             dropDownBtStyle = GUI.skin.FindStyle(tgStyleName) ?? EditorGUIUtility.GetBuiltinSkin(EditorSkin.Inspector).FindStyle(tgStyleName);
    72.  
    73.  
    74.             if (AppSettings.Instance == null)
    75.             {
    76.                 AssetDatabase.CreateAsset(CreateInstance(), "Assets/Resources/AppSettings.asset");
    77.             }
    78.             RefreshHybridCLREnable();
    79.  
    80.             m_Controller = new ResourceBuilderController();
    81.             m_Controller.OnLoadingResource += OnLoadingResource;
    82.             m_Controller.OnLoadingAsset += OnLoadingAsset;
    83.             m_Controller.OnLoadCompleted += OnLoadCompleted;
    84.             m_Controller.OnAnalyzingAsset += OnAnalyzingAsset;
    85.             m_Controller.OnAnalyzeCompleted += OnAnalyzeCompleted;
    86.             m_Controller.ProcessingAssetBundle += OnProcessingAssetBundle;
    87.             m_Controller.ProcessingBinary += OnProcessingBinary;
    88.             m_Controller.ProcessResourceComplete += OnProcessResourceComplete;
    89.             m_Controller.BuildResourceError += OnBuildResourceError;
    90.             m_OrderBuildResources = false;
    91.  
    92.             if (m_Controller.Load())
    93.             {
    94.                 Debug.Log("Load configuration success.");
    95.  
    96.                 m_CompressionHelperTypeNameIndex = 0;
    97.                 string[] compressionHelperTypeNames = m_Controller.GetCompressionHelperTypeNames();
    98.                 for (int i = 0; i < compressionHelperTypeNames.Length; i++)
    99.                 {
    100.                     if (m_Controller.CompressionHelperTypeName == compressionHelperTypeNames[i])
    101.                     {
    102.                         m_CompressionHelperTypeNameIndex = i;
    103.                         break;
    104.                     }
    105.                 }
    106.  
    107.                 m_Controller.RefreshCompressionHelper();
    108.  
    109.                 m_BuildEventHandlerTypeNameIndex = 0;
    110.                 string[] buildEventHandlerTypeNames = m_Controller.GetBuildEventHandlerTypeNames();
    111.                 for (int i = 0; i < buildEventHandlerTypeNames.Length; i++)
    112.                 {
    113.                     if (m_Controller.BuildEventHandlerTypeName == buildEventHandlerTypeNames[i])
    114.                     {
    115.                         m_BuildEventHandlerTypeNameIndex = i;
    116.                         break;
    117.                     }
    118.                 }
    119.  
    120.                 m_Controller.RefreshBuildEventHandler();
    121.             }
    122.             else
    123.             {
    124.                 Debug.LogWarning("Load configuration failure.");
    125.             }
    126.  
    127.             if (string.IsNullOrWhiteSpace(m_Controller.OutputDirectory) || !Directory.Exists(m_Controller.OutputDirectory))
    128.             {
    129.                 m_Controller.OutputDirectory = ConstEditor.AssetBundleOutputPath;
    130.             }
    131.         }
    132.  
    133.         private void Update()
    134.         {
    135.             if (m_OrderBuildResources)
    136.             {
    137.                 m_OrderBuildResources = false;
    138.                 BuildResources();
    139.             }
    140.         }
    141.  
    142.         private void OnGUI()
    143.         {
    144.             EditorGUILayout.BeginVertical(GUILayout.Width(position.width), GUILayout.Height(position.height));
    145.             scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
    146.             {
    147.                 GUILayout.Space(5f);
    148.                 EditorGUILayout.LabelField("Environment Information", EditorStyles.boldLabel);
    149.                 EditorGUILayout.BeginVertical("box");
    150.                 {
    151.                     EditorGUILayout.BeginHorizontal();
    152.                     {
    153.                         EditorGUILayout.LabelField("Product Name", GUILayout.Width(160f));
    154.                         EditorGUILayout.LabelField(m_Controller.ProductName);
    155.                     }
    156.                     EditorGUILayout.EndHorizontal();
    157.                     EditorGUILayout.BeginHorizontal();
    158.                     {
    159.                         EditorGUILayout.LabelField("Company Name", GUILayout.Width(160f));
    160.                         EditorGUILayout.LabelField(m_Controller.CompanyName);
    161.                     }
    162.                     EditorGUILayout.EndHorizontal();
    163.                     EditorGUILayout.BeginHorizontal();
    164.                     {
    165.                         EditorGUILayout.LabelField("Game Identifier", GUILayout.Width(160f));
    166.                         EditorGUILayout.LabelField(m_Controller.GameIdentifier);
    167.                     }
    168.                     EditorGUILayout.EndHorizontal();
    169.                     EditorGUILayout.BeginHorizontal();
    170.                     {
    171.                         EditorGUILayout.LabelField("Game Framework Version", GUILayout.Width(160f));
    172.                         EditorGUILayout.LabelField(m_Controller.GameFrameworkVersion);
    173.                     }
    174.                     EditorGUILayout.EndHorizontal();
    175.                     EditorGUILayout.BeginHorizontal();
    176.                     {
    177.                         EditorGUILayout.LabelField("Unity Version", GUILayout.Width(160f));
    178.                         EditorGUILayout.LabelField(m_Controller.UnityVersion);
    179.                     }
    180.                     EditorGUILayout.EndHorizontal();
    181.                     EditorGUILayout.BeginHorizontal();
    182.                     {
    183.                         EditorGUILayout.LabelField("Applicable Game Version", GUILayout.Width(160f));
    184.                         EditorGUILayout.LabelField(m_Controller.ApplicableGameVersion);
    185.                     }
    186.                     EditorGUILayout.EndHorizontal();
    187.                 }
    188.                 EditorGUILayout.EndVertical();
    189.                 GUILayout.Space(5f);
    190.                 EditorGUILayout.BeginHorizontal();
    191.                 {
    192.                     EditorGUILayout.BeginVertical();
    193.                     {
    194.                         EditorGUILayout.LabelField("Platforms", EditorStyles.boldLabel);
    195.                         EditorGUILayout.BeginHorizontal("box");
    196.                         {
    197.                             EditorGUILayout.BeginVertical();
    198.                             {
    199.                                 DrawPlatform(Platform.Windows, "Windows");
    200.                                 DrawPlatform(Platform.Windows64, "Windows x64");
    201.                                 DrawPlatform(Platform.MacOS, "macOS");
    202.                             }
    203.                             EditorGUILayout.EndVertical();
    204.                             EditorGUILayout.BeginVertical();
    205.                             {
    206.                                 DrawPlatform(Platform.Linux, "Linux");
    207.                                 DrawPlatform(Platform.IOS, "iOS");
    208.                                 DrawPlatform(Platform.Android, "Android");
    209.                             }
    210.                             EditorGUILayout.EndVertical();
    211.                             EditorGUILayout.BeginVertical();
    212.                             {
    213.                                 DrawPlatform(Platform.WindowsStore, "Windows Store");
    214.                                 DrawPlatform(Platform.WebGL, "WebGL");
    215.                             }
    216.                             EditorGUILayout.EndVertical();
    217.                         }
    218.                         EditorGUILayout.EndHorizontal();
    219.                     }
    220.                     EditorGUILayout.EndVertical();
    221.                 }
    222.                 EditorGUILayout.EndHorizontal();
    223.                 GUILayout.Space(5f);
    224.                 EditorGUILayout.LabelField("Compression", EditorStyles.boldLabel);
    225.                 EditorGUILayout.BeginVertical("box");
    226.                 {
    227.                     EditorGUILayout.BeginHorizontal();
    228.                     {
    229.                         EditorGUILayout.LabelField("AssetBundle Compression", GUILayout.Width(160f));
    230.                         m_Controller.AssetBundleCompression = (AssetBundleCompressionType)EditorGUILayout.EnumPopup(m_Controller.AssetBundleCompression);
    231.                     }
    232.                     EditorGUILayout.EndHorizontal();
    233.                     EditorGUILayout.BeginHorizontal();
    234.                     {
    235.                         EditorGUILayout.LabelField("Compression Helper", GUILayout.Width(160f));
    236.                         string[] names = m_Controller.GetCompressionHelperTypeNames();
    237.                         int selectedIndex = EditorGUILayout.Popup(m_CompressionHelperTypeNameIndex, names);
    238.                         if (selectedIndex != m_CompressionHelperTypeNameIndex)
    239.                         {
    240.                             m_CompressionHelperTypeNameIndex = selectedIndex;
    241.                             m_Controller.CompressionHelperTypeName = selectedIndex <= 0 ? string.Empty : names[selectedIndex];
    242.                             if (m_Controller.RefreshCompressionHelper())
    243.                             {
    244.                                 Debug.Log("Set compression helper success.");
    245.                             }
    246.                             else
    247.                             {
    248.                                 Debug.LogWarning("Set compression helper failure.");
    249.                             }
    250.                         }
    251.                     }
    252.                     EditorGUILayout.EndHorizontal();
    253.                     EditorGUILayout.BeginHorizontal();
    254.                     {
    255.                         EditorGUILayout.LabelField("Additional Compression", GUILayout.Width(160f));
    256.                         m_Controller.AdditionalCompressionSelected = EditorGUILayout.ToggleLeft("Additional Compression for Output Full Resources with Compression Helper", m_Controller.AdditionalCompressionSelected);
    257.                     }
    258.                     EditorGUILayout.EndHorizontal();
    259.                 }
    260.                 EditorGUILayout.EndVertical();
    261.                 GUILayout.Space(5f);
    262.                 EditorGUILayout.BeginHorizontal();
    263.                 {
    264.                     EditorGUILayout.LabelField("Build Resources Settings", EditorStyles.boldLabel);
    265.                     if (GUILayout.Button("Resources Editor", GUILayout.Width(160f)))
    266.                     {
    267.                         OpenResourcesEditor();
    268.                         GUIUtility.ExitGUI();
    269.                     }
    270.                 }
    271.                 EditorGUILayout.EndHorizontal();
    272.                 EditorGUILayout.BeginVertical("box");
    273.                 {
    274.                     EditorGUILayout.BeginHorizontal();
    275.                     {
    276.                         EditorGUILayout.LabelField("Force Rebuild AssetBundle", GUILayout.Width(160f));
    277.                         m_Controller.ForceRebuildAssetBundleSelected = EditorGUILayout.Toggle(m_Controller.ForceRebuildAssetBundleSelected);
    278.                     }
    279.                     EditorGUILayout.EndHorizontal();
    280.                     EditorGUILayout.BeginHorizontal();
    281.                     {
    282.                         EditorGUILayout.LabelField("Build Event Handler", GUILayout.Width(160f));
    283.                         string[] names = m_Controller.GetBuildEventHandlerTypeNames();
    284.                         int selectedIndex = EditorGUILayout.Popup(m_BuildEventHandlerTypeNameIndex, names);
    285.                         if (selectedIndex != m_BuildEventHandlerTypeNameIndex)
    286.                         {
    287.                             m_BuildEventHandlerTypeNameIndex = selectedIndex;
    288.                             m_Controller.BuildEventHandlerTypeName = selectedIndex <= 0 ? string.Empty : names[selectedIndex];
    289.                             if (m_Controller.RefreshBuildEventHandler())
    290.                             {
    291.                                 Debug.Log("Set build event handler success.");
    292.                             }
    293.                             else
    294.                             {
    295.                                 Debug.LogWarning("Set build event handler failure.");
    296.                             }
    297.                         }
    298.                     }
    299.                     EditorGUILayout.EndHorizontal();
    300.                     EditorGUILayout.BeginHorizontal();
    301.                     {
    302.                         EditorGUILayout.LabelField("Internal Resource Version", GUILayout.Width(160f));
    303.                         m_Controller.InternalResourceVersion = EditorGUILayout.IntField(m_Controller.InternalResourceVersion);
    304.                     }
    305.                     EditorGUILayout.EndHorizontal();
    306.                     EditorGUILayout.BeginHorizontal();
    307.                     {
    308.                         EditorGUILayout.LabelField("Resource Version", GUILayout.Width(160f));
    309.                         GUILayout.Label(Utility.Text.Format("{0} ({1})", m_Controller.ApplicableGameVersion, m_Controller.InternalResourceVersion.ToString()));
    310.                     }
    311.                     EditorGUILayout.EndHorizontal();
    312.                     EditorGUILayout.BeginHorizontal();
    313.                     {
    314.                         EditorGUILayout.LabelField("Output Directory", GUILayout.Width(160f));
    315.                         m_Controller.OutputDirectory = EditorGUILayout.TextField(m_Controller.OutputDirectory);
    316.                         if (GUILayout.Button("Browse...", GUILayout.Width(80f)))
    317.                         {
    318.                             BrowseOutputDirectory();
    319.                         }
    320.                     }
    321.                     EditorGUILayout.EndHorizontal();
    322.  
    323.                     EditorGUILayout.BeginHorizontal();
    324.                     {
    325.                         EditorGUILayout.LabelField("Output Resources Path", GUILayout.Width(160f));
    326.                         GUILayout.Label(GetResourceOupoutPathByMode(AppSettings.Instance.ResourceMode));
    327.                         EditorGUILayout.LabelField("Resource Mode:", GUILayout.Width(100f));
    328.                         EditorGUI.BeginChangeCheck();
    329.                         {
    330.                             AppSettings.Instance.ResourceMode = (ResourceMode)EditorGUILayout.EnumPopup(AppSettings.Instance.ResourceMode, GUILayout.Width(160f));
    331.                         }
    332.                         if (EditorGUI.EndChangeCheck())
    333.                         {
    334.                             RefreshHybridCLREnable();
    335.                         }
    336.                         if (AppSettings.Instance.ResourceMode != ResourceMode.Unspecified)
    337.                         {
    338.                             SetResourceMode(AppSettings.Instance.ResourceMode);
    339.                         }
    340.                         AppBuildSettings.Instance.RevealFolder = EditorGUILayout.ToggleLeft(revealFolderContent, AppBuildSettings.Instance.RevealFolder, GUILayout.Width(105f));
    341.                     }
    342.                     EditorGUILayout.EndHorizontal();
    343.                     if (AppSettings.Instance.ResourceMode == ResourceMode.Unspecified)
    344.                     {
    345.                         EditorGUILayout.HelpBox("ResourceMode is invalid.", MessageType.Error);
    346.                     }
    347.                     EditorGUILayout.BeginHorizontal();
    348.                     {
    349.                         EditorGUILayout.LabelField("Working Path", GUILayout.Width(160f));
    350.                         GUILayout.Label(m_Controller.WorkingPath);
    351.                     }
    352.                     EditorGUILayout.EndHorizontal();
    353.                     EditorGUILayout.BeginHorizontal();
    354.                     {
    355.                         EditorGUILayout.LabelField("Build Report Path", GUILayout.Width(160f));
    356.                         GUILayout.Label(m_Controller.BuildReportPath);
    357.                     }
    358.                     EditorGUILayout.EndHorizontal();
    359.                 }
    360.  
    361.                 EditorGUILayout.EndVertical();
    362.                 string buildMessage = string.Empty;
    363.                 MessageType buildMessageType = MessageType.None;
    364.                 GetBuildMessage(out buildMessage, out buildMessageType);
    365.                 EditorGUILayout.HelpBox(buildMessage, buildMessageType);
    366.                 if (m_Controller.OutputFullSelected || m_Controller.OutputPackedSelected)
    367.                 {
    368.                     DrawHotfixConfigPanel();
    369.                 }
    370.                 DrawAppBuildSettingsPanel();
    371.                 EditorGUILayout.EndScrollView();
    372.  
    373.                 EditorGUILayout.BeginHorizontal();
    374.                 {
    375.                     EditorGUI.BeginDisabledGroup(m_Controller.Platforms == Platform.Undefined || string.IsNullOrEmpty(m_Controller.CompressionHelperTypeName) || !m_Controller.IsValidOutputDirectory || AppSettings.Instance.ResourceMode == ResourceMode.Unspecified);
    376.                     {
    377.                         if (GUILayout.Button(buildResBtContent, GUILayout.Height(35)))
    378.                         {
    379.                             BuildHotfix();
    380.  
    381.                         }
    382.                         DrawBuildAppButton();
    383.                     }
    384.                     EditorGUI.EndDisabledGroup();
    385.                     if (GUILayout.Button(saveBtContent, GUILayout.Width(140), GUILayout.Height(35)))
    386.                     {
    387.                         SaveConfiguration();
    388.                     }
    389.                 }
    390.                 EditorGUILayout.EndHorizontal();
    391.                 GUILayout.Space(2f);
    392.             }
    393.             EditorGUILayout.EndVertical();
    394.         }
    395.  
    396.         private void DrawBuildAppButton()
    397.         {
    398.             Rect buildRect = GUILayoutUtility.GetRect(buildAppBtContent, dropDownBtStyle,
    399.                         GUILayout.Height(35));
    400.             Rect buildRectPopupButton = buildRect;
    401.             buildRectPopupButton.x += buildRect.width - 35;
    402.             buildRectPopupButton.width = 35;
    403.  
    404.             if (EditorGUI.DropdownButton(buildRectPopupButton, GUIContent.none, FocusType.Passive,
    405.                 GUIStyle.none))
    406.             {
    407.                 GenericMenu menu = new GenericMenu();
    408.                 menu.AddItem(new GUIContent("Full Build(Generate AOT Dll)", "Build时生成AOT Dlls"), false,
    409.                     () =>
    410.                     {
    411.                         BuildApp(true);
    412.                     });
    413.                 menu.DropDown(buildRect);
    414.             }
    415.             else if (GUI.Button(buildRect, buildAppBtContent, dropDownBtStyle))
    416.             {
    417.                 BuildApp(false);
    418.                 GUIUtility.ExitGUI();
    419.             }
    420.         }
    421.  
    422.         private void RefreshHybridCLREnable()
    423.         {
    424.             if (AppSettings.Instance.ResourceMode != ResourceMode.Unspecified)
    425.             {
    426.                 if (AppSettings.Instance.ResourceMode == ResourceMode.Package)
    427.                 {
    428. #if !DISABLE_HYBRIDCLR
    429.                     MyGameTools.DisableHybridCLR();
    430. #endif
    431.                 }
    432.                 else
    433.                 {
    434. #if DISABLE_HYBRIDCLR
    435.                     MyGameTools.EnableHybridCLR();
    436. #endif
    437.                 }
    438.             }
    439.         }
    440.         private string GetResourceOupoutPathByMode(ResourceMode mode)
    441.         {
    442.             string result = null;
    443.             switch (mode)
    444.             {
    445.                 case ResourceMode.Package:
    446.                     result = m_Controller.OutputPackagePath;
    447.                     break;
    448.                 case ResourceMode.Updatable:
    449.                     result = m_Controller.OutputFullPath;
    450.                     break;
    451.                 case ResourceMode.UpdatableWhilePlaying:
    452.                     result = m_Controller.OutputPackedPath;
    453.                     break;
    454.             }
    455.             return result;
    456.         }
    457.         private void SetResourceMode(ResourceMode mode)
    458.         {
    459.             m_Controller.OutputPackageSelected = false;
    460.             m_Controller.OutputFullSelected = false;
    461.             m_Controller.OutputPackedSelected = false;
    462.             switch (mode)
    463.             {
    464.                 case ResourceMode.Package:
    465.                     m_Controller.OutputPackageSelected = true;
    466.                     break;
    467.                 case ResourceMode.Updatable:
    468.                     m_Controller.OutputFullSelected = true;
    469.                     break;
    470.                 case ResourceMode.UpdatableWhilePlaying:
    471.                     m_Controller.OutputPackedSelected = true;
    472.                     break;
    473.             }
    474.         }
    475.         private void OpenResourcesEditor()
    476.         {
    477.             var resEditorClass = Utility.Assembly.GetType("UnityGameFramework.Editor.ResourceTools.ResourceEditor");
    478.             resEditorClass?.GetMethod("Open", BindingFlags.Static | BindingFlags.NonPublic)?.Invoke(null, null);
    479.         }
    480.         private void DrawAppBuildSettingsPanel()
    481.         {
    482.             GUILayout.Space(5f);
    483.             EditorGUILayout.BeginHorizontal();
    484.             {
    485.                 EditorGUILayout.LabelField("Build App Settings:", EditorStyles.boldLabel, GUILayout.Width(160));
    486. #if UNITY_ANDROID
    487.                 AppBuildSettings.Instance.BuildForGooglePlay = EditorUserBuildSettings.buildAppBundle = EditorGUILayout.ToggleLeft("Build App Bundle(GP)", AppBuildSettings.Instance.BuildForGooglePlay);
    488. #endif
    489.                 AppBuildSettings.Instance.DevelopmentBuild = EditorUserBuildSettings.development = EditorGUILayout.ToggleLeft("Development Build", AppBuildSettings.Instance.DevelopmentBuild);
    490.                 AppSettings.Instance.DebugMode = EditorGUILayout.ToggleLeft("Debug Mode", AppSettings.Instance.DebugMode);
    491.                 if (GUILayout.Button(playerSettingBtContent))
    492.                 {
    493.                     SettingsService.OpenProjectSettings("Project/Player");
    494.                     GUIUtility.ExitGUI();
    495.                 }
    496.             }
    497.             EditorGUILayout.EndHorizontal();
    498.             EditorGUILayout.BeginVertical("box");
    499.             {
    500.                 EditorGUILayout.BeginHorizontal();
    501.                 {
    502.                     EditorGUILayout.LabelField("Version", GUILayout.Width(160f));
    503.                     PlayerSettings.bundleVersion = EditorGUILayout.TextField(PlayerSettings.bundleVersion);
    504.                 }
    505.                 EditorGUILayout.EndHorizontal();
    506. #if UNITY_ANDROID
    507.                 EditorGUILayout.BeginHorizontal();
    508.                 {
    509.                     EditorGUILayout.LabelField("Version Code", GUILayout.Width(160f));
    510.                     PlayerSettings.Android.bundleVersionCode = EditorGUILayout.IntField(PlayerSettings.Android.bundleVersionCode);
    511.                 }
    512.                 EditorGUILayout.EndHorizontal();
    513.                 EditorGUILayout.BeginHorizontal();
    514.                 {
    515.                     EditorGUILayout.LabelField("App Build Path", GUILayout.Width(160f));
    516.                     AppBuildSettings.Instance.AppBuildDir = EditorGUILayout.TextField(AppBuildSettings.Instance.AppBuildDir);
    517.                     if (GUILayout.Button("Select Path", GUILayout.Width(160f)))
    518.                     {
    519.                         string projectRoot = Directory.GetParent(Application.dataPath).FullName;
    520.                         var appBuildDir = string.IsNullOrWhiteSpace(AppBuildSettings.Instance.AppBuildDir) ? projectRoot : AppBuildSettings.Instance.AppBuildDir;
    521.                         var openPath = Directory.Exists(appBuildDir) ? appBuildDir : projectRoot;
    522.                         string path = EditorUtility.OpenFolderPanel("Select App Build Path", openPath, "");
    523.                         if (!string.IsNullOrWhiteSpace(path))
    524.                         {
    525.                             AppBuildSettings.Instance.AppBuildDir = Path.GetRelativePath(projectRoot, path);
    526.                         }
    527.                         GUIUtility.ExitGUI();
    528.                     }
    529.                     EditorGUILayout.EndHorizontal();
    530.                 }
    531.                 EditorGUILayout.BeginHorizontal();
    532.                 {
    533.                     PlayerSettings.Android.useCustomKeystore = EditorGUILayout.ToggleLeft("Use Custom Keystore", PlayerSettings.Android.useCustomKeystore, GUILayout.Width(160f));
    534.                     EditorGUI.BeginDisabledGroup(!PlayerSettings.Android.useCustomKeystore);
    535.                     {
    536.                         AppBuildSettings.Instance.AndroidKeystoreName = PlayerSettings.Android.keystoreName = EditorGUILayout.TextField(AppBuildSettings.Instance.AndroidKeystoreName);
    537.                         if (GUILayout.Button("Select Keystore", GUILayout.Width(160f)))
    538.                         {
    539.                             string projectRoot = Directory.GetParent(Application.dataPath).FullName;
    540.                             var keystoreDir = string.IsNullOrWhiteSpace(AppBuildSettings.Instance.AndroidKeystoreName) ? projectRoot : Path.GetDirectoryName(AppBuildSettings.Instance.AndroidKeyAliasName);
    541.                             var openPath = Directory.Exists(keystoreDir) ? keystoreDir : projectRoot;
    542.                             string path = EditorUtility.OpenFilePanel("Select Keystore", openPath, "keystore,jks,ks");
    543.                             if (!string.IsNullOrWhiteSpace(path))
    544.                             {
    545.                                 AppBuildSettings.Instance.AndroidKeystoreName = PlayerSettings.Android.keystoreName = Path.GetRelativePath(projectRoot, path);
    546.                             }
    547.  
    548.                             GUIUtility.ExitGUI();
    549.                         }
    550.                     }
    551.                     EditorGUI.EndDisabledGroup();
    552.                 }
    553.                 EditorGUILayout.EndHorizontal();
    554.                 if (PlayerSettings.Android.useCustomKeystore)
    555.                 {
    556.                     EditorGUILayout.BeginHorizontal();
    557.                     {
    558.                         EditorGUILayout.LabelField("Keystore Password", GUILayout.Width(160f));
    559.                         AppBuildSettings.Instance.KeystorePass = PlayerSettings.keystorePass = EditorGUILayout.TextField(AppBuildSettings.Instance.KeystorePass);
    560.                     }
    561.                     EditorGUILayout.EndHorizontal();
    562.                     EditorGUILayout.BeginHorizontal();
    563.                     {
    564.                         EditorGUILayout.LabelField("KeyAliasName", GUILayout.Width(160f));
    565.                         AppBuildSettings.Instance.AndroidKeyAliasName = PlayerSettings.Android.keyaliasName = EditorGUILayout.TextField(AppBuildSettings.Instance.AndroidKeyAliasName);
    566.                     }
    567.                     EditorGUILayout.EndHorizontal();
    568.                     EditorGUILayout.BeginHorizontal();
    569.                     {
    570.                         EditorGUILayout.LabelField("Alias Password", GUILayout.Width(160f));
    571.                         AppBuildSettings.Instance.KeyAliasPass = PlayerSettings.keyaliasPass = EditorGUILayout.TextField(AppBuildSettings.Instance.KeyAliasPass);
    572.                     }
    573.                     EditorGUILayout.EndHorizontal();
    574.                 }
    575.  
    576. #elif UNITY_IOS
    577.                 EditorGUILayout.BeginHorizontal();
    578.                 {
    579.                     EditorGUILayout.LabelField("Build Number", GUILayout.Width(160f));
    580.                     PlayerSettings.iOS.buildNumber = EditorGUILayout.TextField(PlayerSettings.iOS.buildNumber);
    581.                 }
    582.                 EditorGUILayout.EndHorizontal();
    583. #endif
    584.             }
    585.             EditorGUILayout.EndVertical();
    586.         }
    587.         private void DrawHotfixConfigPanel()
    588.         {
    589.             GUILayout.Space(5f);
    590.             EditorGUILayout.BeginHorizontal();
    591.             {
    592.                 EditorGUILayout.LabelField("Hotfix Settings:", EditorStyles.boldLabel);
    593.                 if (GUILayout.Button(hybridclrSettingBtContent, GUILayout.Width(160f)))
    594.                 {
    595.                     SettingsService.OpenProjectSettings("Project/HybridCLR Settings");
    596.                     GUIUtility.ExitGUI();
    597.                 }
    598.             }
    599.             EditorGUILayout.EndHorizontal();
    600.             EditorGUILayout.BeginVertical("box");
    601.             {
    602.                 EditorGUILayout.BeginHorizontal();
    603.                 {
    604.                     EditorGUILayout.LabelField(hotfixUrlContent, GUILayout.Width(160f));
    605.                     AppBuildSettings.Instance.UpdatePrefixUri = EditorGUILayout.TextField(AppBuildSettings.Instance.UpdatePrefixUri);
    606.                 }
    607.                 EditorGUILayout.EndHorizontal();
    608.  
    609.                 EditorGUILayout.BeginHorizontal();
    610.                 {
    611.                     EditorGUILayout.LabelField(applicableVerContent, GUILayout.Width(160f));
    612.                     AppBuildSettings.Instance.ApplicableGameVersion = EditorGUILayout.TextField(AppBuildSettings.Instance.ApplicableGameVersion);
    613.                 }
    614.                 EditorGUILayout.EndHorizontal();
    615.  
    616.                 EditorGUILayout.BeginHorizontal();
    617.                 {
    618.                     EditorGUILayout.LabelField(appUpdateUrlContent, GUILayout.Width(160f));
    619.                     AppBuildSettings.Instance.AppUpdateUrl = EditorGUILayout.TextField(AppBuildSettings.Instance.AppUpdateUrl);
    620.                     AppBuildSettings.Instance.ForceUpdateApp = EditorGUILayout.ToggleLeft(forceUpdateAppContent, AppBuildSettings.Instance.ForceUpdateApp, GUILayout.Width(100f));
    621.                 }
    622.                 EditorGUILayout.EndHorizontal();
    623.                 EditorGUILayout.Space(5);
    624.                 EditorGUILayout.LabelField(appUpdateDescContent, GUILayout.Width(160f));
    625.                 AppBuildSettings.Instance.AppUpdateDesc = EditorGUILayout.TextArea(AppBuildSettings.Instance.AppUpdateDesc, GUILayout.Height(50));
    626.             }
    627.             EditorGUILayout.EndVertical();
    628.         }
    629.  
    630.         private void BuildHotfix()
    631.         {
    632. #if !DISABLE_HYBRIDCLR
    633.             MyGameTools.CompileTargetDll();
    634. #endif
    635.             m_OrderBuildResources = true;
    636.         }
    637.         private void BuildApp(bool generateAot)
    638.         {
    639. #if UNITY_ANDROID
    640.             if (AppBuildSettings.Instance.AndroidUseKeystore && !CheckKeystoreAvailable(AppBuildSettings.Instance.AndroidKeystoreName))
    641.             {
    642.                 EditorUtility.DisplayDialog("Build Error!", Utility.Text.Format("Keystore文件不存在或格式错误:{0}", AppBuildSettings.Instance.AndroidKeystoreName), "GOT IT");
    643.                 return;
    644.             }
    645. #endif
    646.  
    647.             if (m_Controller.OutputPackageSelected)
    648.             {
    649.                 if (m_Controller.BuildResources())
    650.                 {
    651.                     DeleteAotDlls();//单机模式删除Resource下的AOT dlls
    652.                     //AssetDatabase.Refresh();
    653.                     CallBuildMethods(generateAot);
    654.                 }
    655.             }
    656.             else if (m_Controller.OutputPackedSelected)
    657.             {
    658. #if !DISABLE_HYBRIDCLR
    659.                 MyGameTools.CompileTargetDll(false);
    660. #endif
    661.                 if (m_Controller.BuildResources())
    662.                 {
    663.                     //AssetDatabase.Refresh();
    664.                     CallBuildMethods(generateAot);
    665.                 }
    666.             }
    667.             else if (m_Controller.OutputFullSelected)
    668.             {
    669.                 DeleteStreamingAssets();
    670.                 CallBuildMethods(generateAot);
    671.             }
    672.         }
    673.  
    674.  
    675.         private bool CheckKeystoreAvailable(string keystore)
    676.         {
    677.             if (string.IsNullOrWhiteSpace(keystore)) return false;
    678.             var ext = Path.GetExtension(keystore).ToLower();
    679.             if (File.Exists(keystore) && keystoreExtNames.Contains(ext))
    680.             {
    681.                 return true;
    682.             }
    683.             return false;
    684.         }
    685.         private void DeleteAotDlls()
    686.         {
    687.             string aotSaveDir = UtilityBuiltin.ResPath.GetCombinePath(Application.dataPath, "Resources", ConstBuiltin.AOT_DLL_DIR);
    688.             if (Directory.Exists(aotSaveDir))
    689.             {
    690.                 Directory.Delete(aotSaveDir, true);
    691.             }
    692.         }
    693.         private void DeleteStreamingAssets()
    694.         {
    695.             string streamingAssetsPath = Path.Combine(Application.dataPath, "StreamingAssets");
    696.             if (Directory.Exists(streamingAssetsPath))
    697.             {
    698.                 Directory.Delete(streamingAssetsPath, true);
    699.             }
    700.             string streamMetaFile = streamingAssetsPath + ".meta";
    701.             if (File.Exists(streamMetaFile))
    702.             {
    703.                 File.Delete(streamMetaFile);
    704.             }
    705.         }
    706.         private void CallBuildMethods(bool generateAotDll = false)
    707.         {
    708. #if !DISABLE_HYBRIDCLR
    709.             GenerateHotfixCodeStripConfig(false);
    710.             HybridCLRGenerateAll(generateAotDll);
    711. #else
    712.             GenerateHotfixCodeStripConfig(true);
    713. #endif
    714.             AssetDatabase.Refresh();
    715.             var buildWin = Utility.Assembly.GetType("UnityEditor.BuildPlayerWindow");
    716.             if (buildWin != null)
    717.             {
    718.                 var buildFunc = buildWin.GetMethod("CallBuildMethods", System.Reflection.BindingFlags.Static | BindingFlags.NonPublic);
    719.                 buildFunc?.Invoke(null, new object[] { false, BuildOptions.ShowBuiltPlayer });
    720.             }
    721.         }
    722.         /// 
    723.         /// 生成或删除热更dlls防裁剪的link.xml
    724.         /// 单机模式时需把热更dlls打到包里
    725.         /// 
    726.         /// true生成; false删除
    727.         private void GenerateHotfixCodeStripConfig(bool v)
    728.         {
    729.             var linkDir = Path.GetDirectoryName(ConstEditor.HotfixAssembly);
    730.             var linkFile = UtilityBuiltin.ResPath.GetCombinePath(linkDir, "link.xml");
    731.             if (v)
    732.             {
    733.                 var strBuilder = new StringBuilder();
    734.                 strBuilder.AppendLine("");
    735.                 foreach (var dllName in HybridCLR.Editor.SettingsUtil.HotUpdateAssemblyNamesIncludePreserved)
    736.                 {
    737.                     strBuilder.AppendLineFormat("\t", dllName);
    738.                 }
    739.                 strBuilder.AppendLine("");
    740.                 File.WriteAllText(linkFile, strBuilder.ToString());
    741.             }
    742.             else
    743.             {
    744.                 if (File.Exists(linkFile)) File.Delete(linkFile);//热更包不需要添加防裁剪
    745.             }
    746.         }
    747.         /// 
    748.         /// 生成HybridCLR热更相关
    749.         /// 
    750.         /// 
    751.         private void HybridCLRGenerateAll(bool generateAotDll)
    752.         {
    753.             BuildTarget target = EditorUserBuildSettings.activeBuildTarget;
    754.             MyGameTools.CompileTargetDll(false);
    755.             // 生成裁剪后的aot dll
    756.             if (generateAotDll)
    757.             {
    758.                 StripAOTDllCommand.GenerateStripedAOTDlls(target, EditorUserBuildSettings.selectedBuildTargetGroup);
    759.                 MyGameTools.CopyAotDllsToProject(target);
    760.             }
    761.             LinkGeneratorCommand.GenerateLinkXml(target);
    762.             Il2CppDefGeneratorCommand.GenerateIl2CppDef();
    763.             // 这几个生成依赖HotUpdateDlls
    764.  
    765.             // 桥接函数生成依赖于AOT dll，必须保证已经build过，生成AOT dll
    766.             MethodBridgeGeneratorCommand.GenerateMethodBridge(target);
    767.             ReversePInvokeWrapperGeneratorCommand.GenerateReversePInvokeWrapper(target);
    768.             AOTReferenceGeneratorCommand.GenerateAOTGenericReference(target);
    769.         }
    770.         private void BrowseOutputDirectory()
    771.         {
    772.             string directory = EditorUtility.OpenFolderPanel("Select Output Directory", m_Controller.OutputDirectory, string.Empty);
    773.             if (!string.IsNullOrEmpty(directory))
    774.             {
    775.                 m_Controller.OutputDirectory = directory;
    776.             }
    777.         }
    778.  
    779.         private void GetBuildMessage(out string message, out MessageType messageType)
    780.         {
    781.             message = string.Empty;
    782.             messageType = MessageType.Error;
    783.             if (m_Controller.Platforms == Platform.Undefined)
    784.             {
    785.                 if (!string.IsNullOrEmpty(message))
    786.                 {
    787.                     message += Environment.NewLine;
    788.                 }
    789.  
    790.                 message += "Platform is invalid.";
    791.             }
    792.  
    793.             if (string.IsNullOrEmpty(m_Controller.CompressionHelperTypeName))
    794.             {
    795.                 if (!string.IsNullOrEmpty(message))
    796.                 {
    797.                     message += Environment.NewLine;
    798.                 }
    799.  
    800.                 message += "Compression helper is invalid.";
    801.             }
    802.  
    803.             if (!m_Controller.IsValidOutputDirectory)
    804.             {
    805.                 if (!string.IsNullOrEmpty(message))
    806.                 {
    807.                     message += Environment.NewLine;
    808.                 }
    809.  
    810.                 message += "Output directory is invalid.";
    811.             }
    812.  
    813.             if (!string.IsNullOrEmpty(message))
    814.             {
    815.                 return;
    816.             }
    817.  
    818.             messageType = MessageType.Info;
    819.             if (Directory.Exists(m_Controller.OutputPackagePath))
    820.             {
    821.                 message += Utility.Text.Format("{0} will be overwritten.", m_Controller.OutputPackagePath);
    822.                 messageType = MessageType.Warning;
    823.             }
    824.  
    825.             if (Directory.Exists(m_Controller.OutputFullPath))
    826.             {
    827.                 if (message.Length > 0)
    828.                 {
    829.                     message += " ";
    830.                 }
    831.  
    832.                 message += Utility.Text.Format("{0} will be overwritten.", m_Controller.OutputFullPath);
    833.                 messageType = MessageType.Warning;
    834.             }
    835.  
    836.             if (Directory.Exists(m_Controller.OutputPackedPath))
    837.             {
    838.                 if (message.Length > 0)
    839.                 {
    840.                     message += " ";
    841.                 }
    842.  
    843.                 message += Utility.Text.Format("{0} will be overwritten.", m_Controller.OutputPackedPath);
    844.                 messageType = MessageType.Warning;
    845.             }
    846.  
    847.             if (messageType == MessageType.Warning)
    848.             {
    849.                 return;
    850.             }
    851.  
    852.             message = "Ready to build.";
    853.         }
    854.  
    855.         private void BuildResources()
    856.         {
    857.             if (m_Controller.BuildResources())
    858.             {
    859.                 Debug.Log("Build resources success.");
    860.                 SaveConfiguration();
    861.             }
    862.             else
    863.             {
    864.                 Debug.LogWarning("Build resources failure.");
    865.             }
    866.         }
    867.  
    868.         private void SaveConfiguration()
    869.         {
    870.             EditorUtility.SetDirty(AppSettings.Instance);
    871.             AppBuildSettings.Save();
    872.             if (m_Controller.Save())
    873.             {
    874.                 Debug.Log("Save configuration success.");
    875.             }
    876.             else
    877.             {
    878.                 Debug.LogWarning("Save configuration failure.");
    879.             }
    880.         }
    881.  
    882.         private void DrawPlatform(Platform platform, string platformName)
    883.         {
    884.             m_Controller.SelectPlatform(platform, EditorGUILayout.ToggleLeft(platformName, m_Controller.IsPlatformSelected(platform)));
    885.         }
    886.  
    887.         private void OnLoadingResource(int index, int count)
    888.         {
    889.             EditorUtility.DisplayProgressBar("Loading Resources", Utility.Text.Format("Loading resources, {0}/{1} loaded.", index.ToString(), count.ToString()), (float)index / count);
    890.         }
    891.  
    892.         private void OnLoadingAsset(int index, int count)
    893.         {
    894.             EditorUtility.DisplayProgressBar("Loading Assets", Utility.Text.Format("Loading assets, {0}/{1} loaded.", index.ToString(), count.ToString()), (float)index / count);
    895.         }
    896.  
    897.         private void OnLoadCompleted()
    898.         {
    899.             EditorUtility.ClearProgressBar();
    900.         }
    901.  
    902.         private void OnAnalyzingAsset(int index, int count)
    903.         {
    904.             EditorUtility.DisplayProgressBar("Analyzing Assets", Utility.Text.Format("Analyzing assets, {0}/{1} analyzed.", index.ToString(), count.ToString()), (float)index / count);
    905.         }
    906.  
    907.         private void OnAnalyzeCompleted()
    908.         {
    909.             EditorUtility.ClearProgressBar();
    910.         }
    911.  
    912.         private bool OnProcessingAssetBundle(string assetBundleName, float progress)
    913.         {
    914.             if (EditorUtility.DisplayCancelableProgressBar("Processing AssetBundle", Utility.Text.Format("Processing '{0}'...", assetBundleName), progress))
    915.             {
    916.                 EditorUtility.ClearProgressBar();
    917.                 return true;
    918.             }
    919.             else
    920.             {
    921.                 Repaint();
    922.                 return false;
    923.             }
    924.         }
    925.  
    926.         private bool OnProcessingBinary(string binaryName, float progress)
    927.         {
    928.             if (EditorUtility.DisplayCancelableProgressBar("Processing Binary", Utility.Text.Format("Processing '{0}'...", binaryName), progress))
    929.             {
    930.                 EditorUtility.ClearProgressBar();
    931.                 return true;
    932.             }
    933.             else
    934.             {
    935.                 Repaint();
    936.                 return false;
    937.             }
    938.         }
    939.  
    940.         private void OnProcessResourceComplete(Platform platform)
    941.         {
    942.             EditorUtility.ClearProgressBar();
    943.             Debug.Log(Utility.Text.Format("Build resources for '{0}' complete.", platform.ToString()));
    944.  
    945.             if (AppBuildSettings.Instance.RevealFolder)
    946.             {
    947.                 EditorUtility.RevealInFinder(UtilityBuiltin.ResPath.GetCombinePath(GetResourceOupoutPathByMode(AppSettings.Instance.ResourceMode), platform.ToString()));
    948.             }
    949.         }
    950.  
    951.         private void OnBuildResourceError(string errorMessage)
    952.         {
    953.             EditorUtility.ClearProgressBar();
    954.             Debug.LogWarning(Utility.Text.Format("Build resources error with error message '{0}'.", errorMessage));
    955.         }
    956.         private BuildTarget GetSelectedBuildTarget()
    957.         {
    958.             var buildTarget = (BuildTarget)Utility.Assembly.GetType("UnityEditor.EditorUserBuildSettingsUtils").GetMethod("CalculateSelectedBuildTarget", BindingFlags.Static | BindingFlags.Public).Invoke(null, null);
    959.             return buildTarget;
    960.         }
    961.         private BuildPlayerOptions CustomBuildOptions(BuildPlayerOptions options)
    962.         {
    963.             var buildTarget = GetSelectedBuildTarget();
    964.             BuildTargetGroup buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
    965.             int subtarget = (int)Utility.Assembly.GetType("UnityEditor.EditorUserBuildSettings").GetMethod("GetSelectedSubtargetFor", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { buildTarget });
    966.  
    967.             string buildLocation = GetBuildLocation(buildTargetGroup, buildTarget, subtarget, options.options);
    968.             bool isDir = !Path.HasExtension(buildLocation);
    969.             if (string.IsNullOrWhiteSpace(buildLocation) || (isDir && !Directory.Exists(buildLocation)))
    970.                 throw new BuildMethodException("Build location for buildTarget " + buildTarget + " is not valid.");
    971.  
    972.             //Check if Lz4 is supported for the current buildtargetgroup and enable it if need be
    973.             if ((bool)Utility.Assembly.GetType("UnityEditor.PostprocessBuildPlayer").GetMethod("SupportsLz4Compression", BindingFlags.Static | BindingFlags.Public).Invoke(null, new object[] { buildTargetGroup, buildTarget }))
    974.             {
    975.                 //internal enum Compression
    976.                 //{
    977.                 //    None = 0,
    978.                 //    Lz4 = 2,
    979.                 //    Lz4HC = 3,
    980.                 //}
    981.                 var compression = (int)Utility.Assembly.GetType("UnityEditor.EditorUserBuildSettings").GetMethod("GetCompressionType", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { buildTargetGroup });
    982.                 if (compression < 0)
    983.                     compression = (int)Utility.Assembly.GetType("UnityEditor.PostprocessBuildPlayer").GetMethod("GetDefaultCompression", BindingFlags.Static | BindingFlags.Public).Invoke(null, new object[] { buildTargetGroup, buildTarget });
    984.                 if (compression == 2)//Lz4
    985.                     options.options |= BuildOptions.CompressWithLz4;
    986.                 else if (compression == 3)//Lz4HC
    987.                     options.options |= BuildOptions.CompressWithLz4HC;
    988.             }
    989.  
    990.             bool developmentBuild = EditorUserBuildSettings.development;
    991.             if (developmentBuild)
    992.                 options.options |= BuildOptions.Development;
    993.             if (EditorUserBuildSettings.allowDebugging && developmentBuild)
    994.                 options.options |= BuildOptions.AllowDebugging;
    995.             if (EditorUserBuildSettings.symlinkSources)
    996.                 options.options |= BuildOptions.SymlinkSources;
    997.             if (EditorUserBuildSettings.connectProfiler && (developmentBuild || buildTarget == BuildTarget.WSAPlayer))
    998.                 options.options |= BuildOptions.ConnectWithProfiler;
    999.             if (EditorUserBuildSettings.buildWithDeepProfilingSupport && developmentBuild)
    1000.                 options.options |= BuildOptions.EnableDeepProfilingSupport;
    1001.             if (EditorUserBuildSettings.buildScriptsOnly)
    1002.                 options.options |= BuildOptions.BuildScriptsOnly;
    1003.  
    1004.             string connectID = Utility.Assembly.GetType("UnityEditor.Profiling.ProfilerUserSettings").GetProperty("customConnectionID", BindingFlags.Static | BindingFlags.Public).GetValue(null, null) as string;
    1005.             if (!string.IsNullOrEmpty(connectID) && developmentBuild)
    1006.                 options.options |= BuildOptions.CustomConnectionID;
    1007.  
    1008.             var checkFunc = typeof(UnityEditor.BuildPlayerWindow.DefaultBuildMethods).GetMethod("IsInstallInBuildFolderOption", BindingFlags.Static | BindingFlags.NonPublic);
    1009.  
    1010.             if ((bool)checkFunc.Invoke(null, null))
    1011.             {
    1012.                 options.options |= BuildOptions.InstallInBuildFolder;
    1013.             }
    1014.  
    1015.             options.target = buildTarget;
    1016.             options.subtarget = subtarget;
    1017.             options.targetGroup = buildTargetGroup;
    1018.             options.locationPathName = buildLocation;
    1019.             options.assetBundleManifestPath = Utility.Assembly.GetType("UnityEditor.PostprocessBuildPlayer").GetMethod("GetStreamingAssetsBundleManifestPath", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null) as string;
    1020.  
    1021.             // Build a list of scenes that are enabled
    1022.             ArrayList scenesList = new ArrayList();
    1023.             EditorBuildSettingsScene[] editorScenes = EditorBuildSettings.scenes;
    1024.             foreach (EditorBuildSettingsScene scene in editorScenes)
    1025.             {
    1026.                 if (scene.enabled)
    1027.                 {
    1028.                     scenesList.Add(scene.path);
    1029.                     break;// GF框架只需要把启动场景打进包里,其它场景动态加载
    1030.                 }
    1031.             }
    1032.  
    1033.             options.scenes = scenesList.ToArray(typeof(string)) as string[];
    1034.             return options;
    1035.         }
    1036.  
    1037.         private static string GetBuildLocation(BuildTargetGroup targetGroup, BuildTarget target, int subtarget, BuildOptions options)
    1038.         {
    1039.             string defaultFolder = UtilityBuiltin.ResPath.GetCombinePath(Directory.GetParent(Application.dataPath).FullName, AppBuildSettings.Instance.AppBuildDir, target.ToString());
    1040.             string defaultName = Utility.Text.Format("{0}_{1}{2}_v{3}", Application.productName, AppSettings.Instance.DebugMode ? "debug" : "release", EditorUserBuildSettings.development ? "Dev" : string.Empty, Application.version);
    1041.  
    1042.             string extension = Utility.Assembly.GetType("UnityEditor.PostprocessBuildPlayer").GetMethod("GetExtensionForBuildTarget", new Type[] { typeof(BuildTargetGroup), typeof(BuildTarget), typeof(int), typeof(BuildOptions) }).Invoke(null, new object[] { targetGroup, target, subtarget, options }) as string;
    1043.             string buildPath = defaultFolder;
    1044.             if (!string.IsNullOrEmpty(extension))
    1045.             {
    1046.                 string appFileName = Utility.Text.Format("{0}.{1}", defaultName, extension);
    1047.                 buildPath = UtilityBuiltin.ResPath.GetCombinePath(defaultFolder, appFileName);
    1048.             }
    1049.             return buildPath;
    1050.         }
    1051.     }
    1052. }

  • 相关阅读:
    jumpserver迁移后windowserver资产无法登陆问题排查
    Python中aiohttp和aiofiles模块的安装
    https下载图片
    面试官：讲讲MySql索引失效的几种情况
    pytorch学习（六）——优化器
    2022 CCPC 华为云计算挑战赛 A：95计费法
    Docker基础
    白平衡简介
    【图像分割】图像分割质量分数，如 TP、FP、TN、FN、Accuracy、Sensitivity、Precision、MCC、Dice、Jaccard
    37岁更要坚定，竞争从阿里的Java高并发操作手册开始
  • 原文地址：https://blog.csdn.net/final5788/article/details/128152601