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

【Unity编辑器扩展】扩展Unity工具栏Toolbar, 一键出包/打热更简化打包流程_unity editor 自定义拓展工具

作者：Monodyee | 2024-02-19 14:52:17

赞

踩

unity editor 自定义拓展工具

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.         /// <summary>
  33.         /// Callback for toolbar OnGUI method.
  34.         /// </summary>
  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<Action> LeftToolbarGUI = new List<Action>();
  120.         public static readonly List<Action> RightToolbarGUI = new List<Action>();
  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<ResourceComponent>();
  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>("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.     /// <summary>
  18.     /// 资源生成器。
  19.     /// </summary>
  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<AppBuildEidtor>("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<AppSettings>(), "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.         /// <summary>
  723.         /// 生成或删除热更dlls防裁剪的link.xml
  724.         /// 单机模式时需把热更dlls打到包里
  725.         /// </summary>
  726.         /// <param name="v">true生成; false删除</param>
  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("<linker>");
  735.                 foreach (var dllName in HybridCLR.Editor.SettingsUtil.HotUpdateAssemblyNamesIncludePreserved)
  736.                 {
  737.                     strBuilder.AppendLineFormat("\t<assembly fullname=\"{0}\" preserve=\"all\" />", dllName);
  738.                 }
  739.                 strBuilder.AppendLine("</linker>");
  740.                 File.WriteAllText(linkFile, strBuilder.ToString());
  741.             }
  742.             else
  743.             {
  744.                 if (File.Exists(linkFile)) File.Delete(linkFile);//热更包不需要添加防裁剪
  745.             }
  746.         }
  747.         /// <summary>
  748.         /// 生成HybridCLR热更相关
  749.         /// </summary>
  750.         /// <param name="generateAotDll"></param>
  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. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/115324
推荐阅读
相关标签

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

  

闽ICP备14008679号