Update CHANGELOG.md

资源补丁清单增加文件版本信息

.gitignore

@@ -58,4 +58,7 @@ sysinfo.txt
 # Crashlytics generated file
 crashlytics-build.properties
 
-*.vsconfig
+*.vsconfig
+
+Sandbox/
+Bundles/

Assets/YooAsset/CHANGELOG.md

@@ -2,6 +2,289 @@
 
 All notable changes to this package will be documented in this file.
 
+## [1.2.2] - 2022-07-31
+
+### Fixed
+
+- 修复了加载多个相同的子场景而无法全部卸载的问题。
+
+### Changed
+
+- ShaderVariantCollecor支持在CI上调用运行。
+
+- 资源补丁清单增加文件版本校验功能。
+
+- AssetBundleBuilder现在构建结果可以查询构建失败信息。
+
+- AssetBundleBuilder现在资源包文件名称样式提供选择功能。
+
+  ````c#
+  class BuildParameters
+  {
+      /// <summary>
+      /// 补丁文件名称的样式
+      /// </summary>
+      public EOutputNameStyle OutputNameStyle;
+  }
+  ````
+
+### Added
+
+- 增加获取资源信息新方法。
+
+  ````c#
+  /// <summary>
+  /// 获取资源信息
+  /// </summary>
+  /// <param name="location">资源的定位地址</param>
+  public static AssetInfo GetAssetInfo(string location);
+  ````
+
+## [1.2.1] - 2022-07-23
+
+### Fixed
+
+- (#25)修复了资源文件不存在返回的handle无法完成的问题。
+- (#26)修复多个场景打进一个AB包时，卸载子场景时抛出异常。
+
+### Changed
+
+- 构建报告里增加主资源总数的统计。
+- 资源构建系统里修改了内置构建管线的构建结果验证逻辑，移除了对中文路径的检测。
+- 资源构建系统里移除了对增量更新初次无法构建的限制。
+- 优化了缓存验证逻辑，不期望删除断点续传的资源文件。
+- 资源构建系统里SBP构建参数增加了缓存服务器的地址和端口。
+
+## [1.2.0] - 2022-07-18
+
+### Fixed
+
+- 修复了ShaderVariantCollection刷新不及时问题。
+
+### Changed
+
+- 资源收集忽略了Gizmos资源文件。
+- 解密服务接口增加解密文件信息参数。
+- 资源收集窗体增加配置保存按钮。
+- 资源构建窗体增加配置保存按钮。
+
+### Added
+
+- 资源构建模块增加了可编程构建管线(SBP)的支持，开发者可以在内置构建管线和可编程构建管线之间自由选择，零修改成本。
+
+## [1.1.1] - 2022-07-07
+
+### Fixed
+
+- 修复了AssetBundleDebugger窗口，View下拉页签切换无效的问题。
+- 修复了在Unity2020.3版本下UniTask在真机上的一个IL2CPP相关的错误。
+
+### Changed
+
+- 优化了AssetBundleDebugger窗口，增加了帧数显示以及回放功能。
+- 优化了AssetBundleBuilder的代码结构。
+- 增强了YooAssets.GetRawFileAsync()方法的容错。
+
+### Added
+
+- 新增了OperationHandleBase.GetAssetInfo()方法。
+
+  ````c#
+  /// <summary>
+  /// 获取资源信息
+  /// </summary>
+  public AssetInfo GetAssetInfo();
+  ````
+
+- 新增了AssetOperationHandle.GetAssetObjet<TAsset>()方法。
+
+  ````c#
+  /// <summary>
+  /// 获取资源对象
+  /// </summary>
+  /// <typeparam name="TAsset">资源类型</typeparam>
+  public TAsset GetAssetObjet<TAsset>()；
+  ````
+
+- 新增了弱联网情况下加载补丁清单方法。
+
+  ````c#
+  /// <summary>
+  /// 弱联网情况下加载补丁清单
+  /// 注意：当指定版本内容验证失败后会返回失败。
+  /// </summary>
+  /// <param name="resourceVersion">指定的资源版本</param>
+  public static UpdateManifestOperation WeaklyUpdateManifestAsync(int resourceVersion)；
+  ````
+
+### Removed
+
+- 离线运行模式（OfflinePlayMode）下移除了资内置资源解压相关逻辑。
+- 移除了初始化参数：AutoReleaseGameObjectHandle及相关代码逻辑。
+
+## [1.1.0] - 2022-06-23
+
+### Fixed
+
+- 修复了AssetBundleCollector窗口，在切换EnableAddressable时未及时刷新界面的问题。
+- 修复了AssetBundleCollector窗口，资源过滤器CollectSprite无效的问题。
+- 修复了AssetBundleCollector窗口，无法正常预览StaticAssetCollector的资源列表的问题。
+- 修复了在离线模式下原生文件每次都从包内加载的问题。
+
+### Changed
+
+- 变更了共享资源打包机制。
+- AssetBundleCollector窗口增加了分组禁用功能。
+- AssetBundleDebugger窗口增加了真机远程调试功能。
+- AssetBundleBuilder窗口在构建成功后自动显示构建文件夹。
+- DownloaderOperation.OnDownloadFileFailedCallback委托变更为OnDownloadErrorCallback委托。
+
+### Added
+
+- 新增UpdateManifestOperation.FoundNewManifest字段。
+- 新增DownloaderOperation.OnStartDownloadFileCallback委托。
+- 新增AssetInfo.Address字段。
+- 新增YooAssets.IsInitialized字段。
+- 新增YooAssets初始化参数。
+
+  ````c#
+  /// <summary>
+  /// 下载文件校验等级
+  /// </summary>
+  public EVerifyLevel VerifyLevel = EVerifyLevel.High;
+  ````
+
+- 新增YooAssets获取资源完成路径的方法。
+
+  ````c#
+  /// <summary>
+  /// 获取资源路径
+  /// </summary>
+  /// <param name="location">资源的定位地址</param>
+  /// <returns>如果location地址无效，则返回空字符串</returns>
+  public static string GetAssetPath(string location);
+  ````
+
+- 新增YooAssets初始化参数。
+
+  ```c#
+  /// <summary>
+  /// 自动释放游戏对象所属资源句柄
+  /// 说明：通过资源句柄实例化的游戏对象在销毁之后，会自动释放所属资源句柄。
+  /// </summary>
+  public bool AutoReleaseGameObjectHandle = false;
+  ```
+
+## [1.0.10] - 2022-05-22
+
+### Fixed
+
+- 修复了资源收集配置存在多个的时候，导致后续无法打开窗口的问题。
+- 修复了在编辑器模拟模式下加载精灵图片失败的问题。
+- 修复了在Unity2019版本无法识别配置文件的问题。
+
+### Changed
+
+- 资源构建增加内置资源文件（首包资源文件）拷贝的选项。
+- 补丁下载器增加暂停方法和恢复方法。
+- 在资源收集界面，对Collector的增加和删除支持撤销和恢复操作。
+
+## [1.0.9] - 2022-05-14
+
+### Fixed
+
+- 修复了YooAssets.GetAssetInfos(string Tag)方法返回了无关的资源信息的问题。
+
+### Changed
+
+- 编辑器下的模拟运行模式，不再依赖配置里的构建版本。
+- 更新资源清单结构，资源对象类增加分类标签。
+- 优化了资源工具相关配置文件的加载方式和途径，这些配置文件可以放置在任何目录下。
+- 优化了Location无效后的错误报告方式。
+- 优化了资源包的构建参数，现在始终开启DisableLoadAssetByFileName，帮助减小运行时的内存。
+- YooAssets.ProcessOperation()重命名为YooAssets.StartOperation()
+
+### Added
+
+- 新增YooAssets.IsNeedDownloadFromRemote()方法。
+
+  ````c#
+  public static bool IsNeedDownloadFromRemote(string location);
+  ````
+
+- 新增获取所有子资源对象的方法。
+
+  ````c#
+  class SubAssetsOperationHandle
+  {
+      public TObject[] GetSubAssetObjects<TObject>();
+  }
+  ````
+
+### Removed
+
+- YooAssets.GetBundleInfo()方法已经移除。
+
+## [1.0.8] - 2022-05-08
+
+### Fixed
+
+- 修复了资源收集器导出配置文件时没有导出公共设置。
+- 修复了不兼容Unity2018版本的错误。
+
+### Changed
+
+- AssetBundleGrouper窗口变更为AssetBundleCollector窗口。
+- **优化了编辑器下模拟运行的初始化速度**。
+- **优化了资源收集窗口打开时卡顿的问题**。
+- 资源收集XML配表支持版本兼容。
+- 资源报告查看窗口支持预览AssetBundle文件内容的功能。
+- 完善了对UniTask的支持。
+- YooAssets所有接口支持初始化容错检测。
+
+### Added
+
+- 异步操作类增加进度查询字段。
+
+  ```c#
+  class AsyncOperationBase
+  {
+      /// <summary>
+      /// 处理进度
+      /// </summary>
+      public float Progress { get; protected set; } 
+  }
+  ```
+
+- 增加开启异步操作的方法。
+
+  ```c#
+  /// <summary>
+  /// 开启一个异步操作
+  /// </summary>
+  /// <param name="operation">异步操作对象</param>
+  public static void ProcessOperaiton(GameAsyncOperation operation)
+  ```
+
+- 新增编辑器下模拟模式的初始化参数。
+
+  ````c#
+  /// <summary>
+  /// 用于模拟运行的资源清单路径
+  /// 注意：如果路径为空，会自动重新构建补丁清单。
+  /// </summary>
+  public string SimulatePatchManifestPath;
+  ````
+
+- 新增通用的初始化参数。
+
+  ```c#
+  /// <summary>
+  /// 资源定位地址大小写不敏感
+  /// </summary>
+  public bool LocationToLower = false;
+  ```
+
 ## [1.0.7] - 2022-05-04
 
 ### Fixed

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilder.cs

@@ -8,141 +8,87 @@ namespace YooAsset.Editor
 {
 	public class AssetBundleBuilder
 	{
-		public class BuildParametersContext : IContextObject
-		{
-			private readonly System.Diagnostics.Stopwatch _buildWatch = new System.Diagnostics.Stopwatch();
-
-			/// <summary>
-			/// 构建参数
-			/// </summary>
-			public BuildParameters Parameters { private set; get; }
-
-			/// <summary>
-			/// 构建管线的输出目录
-			/// </summary>
-			public string PipelineOutputDirectory { private set; get; }
-
-
-			public BuildParametersContext(BuildParameters parameters)
-			{
-				Parameters = parameters;
-
-				PipelineOutputDirectory = AssetBundleBuilderHelper.MakePipelineOutputDirectory(parameters.OutputRoot, parameters.BuildTarget);
-				if (parameters.BuildMode == EBuildMode.DryRunBuild)
-					PipelineOutputDirectory += $"_{EBuildMode.DryRunBuild}";
-				else if(parameters.BuildMode == EBuildMode.FastRunBuild)
-					PipelineOutputDirectory += $"_{EBuildMode.FastRunBuild}";
-			}
-
-			/// <summary>
-			/// 获取本次构建的补丁目录
-			/// </summary>
-			public string GetPackageDirectory()
-			{
-				return $"{Parameters.OutputRoot}/{Parameters.BuildTarget}/{Parameters.BuildVersion}";
-			}
-
-			/// <summary>
-			/// 获取构建选项
-			/// </summary>
-			public BuildAssetBundleOptions GetPipelineBuildOptions()
-			{
-				// For the new build system, unity always need BuildAssetBundleOptions.CollectDependencies and BuildAssetBundleOptions.DeterministicAssetBundle
-				// 除非设置ForceRebuildAssetBundle标记，否则会进行增量打包
-
-				BuildAssetBundleOptions opt = BuildAssetBundleOptions.None;
-				opt |= BuildAssetBundleOptions.StrictMode; //Do not allow the build to succeed if any errors are reporting during it.
-
-				if (Parameters.BuildMode == EBuildMode.FastRunBuild)
-				{
-					throw new Exception("Should never get here !");
-				}
-
-				if (Parameters.BuildMode == EBuildMode.DryRunBuild)
-				{
-					opt |= BuildAssetBundleOptions.DryRunBuild;
-					return opt;
-				}
-
-				if (Parameters.CompressOption == ECompressOption.Uncompressed)
-					opt |= BuildAssetBundleOptions.UncompressedAssetBundle;
-				else if (Parameters.CompressOption == ECompressOption.LZ4)
-					opt |= BuildAssetBundleOptions.ChunkBasedCompression;
-
-				if (Parameters.BuildMode == EBuildMode.ForceRebuild)
-					opt |= BuildAssetBundleOptions.ForceRebuildAssetBundle; //Force rebuild the asset bundles
-				if (Parameters.AppendHash)
-					opt |= BuildAssetBundleOptions.AppendHashToAssetBundleName; //Append the hash to the assetBundle name
-				if (Parameters.DisableWriteTypeTree)
-					opt |= BuildAssetBundleOptions.DisableWriteTypeTree; //Do not include type information within the asset bundle (don't write type tree).
-				if (Parameters.IgnoreTypeTreeChanges)
-					opt |= BuildAssetBundleOptions.IgnoreTypeTreeChanges; //Ignore the type tree changes when doing the incremental build check.
-				if (Parameters.DisableLoadAssetByFileName)
-				{
-					opt |= BuildAssetBundleOptions.DisableLoadAssetByFileName; //Disables Asset Bundle LoadAsset by file name.
-					opt |= BuildAssetBundleOptions.DisableLoadAssetByFileNameWithExtension; //Disables Asset Bundle LoadAsset by file name with extension.
-				}
-
-				return opt;
-			}
-
-			/// <summary>
-			/// 获取构建的耗时（单位：秒）
-			/// </summary>
-			public int GetBuildingSeconds()
-			{
-				int seconds = (int)(_buildWatch.ElapsedMilliseconds / 1000);
-				return seconds;
-			}
-			public void BeginWatch()
-			{
-				_buildWatch.Start();
-			}
-			public void StopWatch()
-			{
-				_buildWatch.Stop();
-			}
-		}
-
 		private readonly BuildContext _buildContext = new BuildContext();
 
 		/// <summary>
 		/// 开始构建
 		/// </summary>
-		public bool Run(BuildParameters buildParameters)
+		public BuildResult Run(BuildParameters buildParameters)
 		{
 			// 清空旧数据
 			_buildContext.ClearAllContext();
 
+			// 检测构建参数是否为空
+			if (buildParameters == null)
+			{
+				throw new Exception($"{nameof(buildParameters)} is null !");
+			}
+			if (buildParameters.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
+			{
+				if (buildParameters.SBPParameters == null)
+					throw new Exception($"{nameof(BuildParameters.SBPParameters)} is null !");
+			}
+
 			// 构建参数
 			var buildParametersContext = new BuildParametersContext(buildParameters);
 			_buildContext.SetContextObject(buildParametersContext);
 
-			// 执行构建流程
+			// 是否显示LOG
-			List<IBuildTask> pipeline = new List<IBuildTask>
+			if (buildParameters.BuildMode == EBuildMode.SimulateBuild)
-			{
-				new TaskPrepare(), //前期准备工作
-				new TaskGetBuildMap(), //获取构建列表
-				new TaskBuilding(), //开始执行构建
-				new TaskVerifyBuildResult(), //验证构建结果
-				new TaskEncryption(), //加密资源文件
-				new TaskCreatePatchManifest(), //创建清单文件
-				new TaskCreateReport(), //创建报告文件
-				new TaskCreatePatchPackage(), //制作补丁包
-				new TaskCopyBuildinFiles(), //拷贝内置文件
-			};
-
-			if (buildParameters.BuildMode == EBuildMode.FastRunBuild)
 				BuildRunner.EnableLog = false;
 			else
 				BuildRunner.EnableLog = true;
 
-			bool succeed = BuildRunner.Run(pipeline, _buildContext);
+			// 创建构建节点
-			if (succeed)
+			List<IBuildTask> pipeline;
-				Debug.Log($"{buildParameters.BuildMode}模式构建成功！");
+			if (buildParameters.BuildPipeline == EBuildPipeline.BuiltinBuildPipeline)
+			{
+				pipeline = new List<IBuildTask>
+				{
+					new TaskPrepare(), //前期准备工作
+					new TaskGetBuildMap(), //获取构建列表
+					new TaskBuilding(), //开始执行构建
+					new TaskVerifyBuildResult(), //验证构建结果
+					new TaskEncryption(), //加密资源文件
+					new TaskCreatePatchManifest(), //创建清单文件
+					new TaskCreateReport(), //创建报告文件
+					new TaskCreatePatchPackage(), //制作补丁包
+					new TaskCopyBuildinFiles(), //拷贝内置文件
+				};
+			}
+			else if (buildParameters.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
+			{
+				pipeline = new List<IBuildTask>
+				{
+					new TaskPrepare(), //前期准备工作
+					new TaskGetBuildMap(), //获取构建列表
+					new TaskBuilding_SBP(), //开始执行构建
+					new TaskVerifyBuildResult_SBP(), //验证构建结果
+					new TaskEncryption(), //加密资源文件
+					new TaskCreatePatchManifest(), //创建清单文件
+					new TaskCreateReport(), //创建报告文件
+					new TaskCreatePatchPackage(), //制作补丁包
+					new TaskCopyBuildinFiles(), //拷贝内置文件
+				};
+			}
 			else
-				Debug.LogWarning($"{buildParameters.BuildMode}模式构建失败！");
+			{
-			return succeed;
+				throw new NotImplementedException();
+			}
+
+			// 执行构建流程
+			var buildResult = BuildRunner.Run(pipeline, _buildContext);
+			if (buildResult.Success)
+			{
+				Debug.Log($"{buildParameters.BuildMode} pipeline build succeed !");
+			}
+			else
+			{
+				Debug.LogWarning($"{buildParameters.BuildMode} pipeline build failed !");
+				Debug.LogError($"Build task failed : {buildResult.FailedTask}");
+				Debug.LogError($"Build task error : {buildResult.FailedInfo}");
+			}
+			return buildResult;
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderHelper.cs

@@ -30,7 +30,7 @@ namespace YooAsset.Editor
 		/// </summary>
 		public static string MakePipelineOutputDirectory(string outputRoot, BuildTarget buildTarget)
 		{
-			return $"{outputRoot}/{buildTarget}/{YooAssetSettingsData.Setting.UnityManifestFileName}";
+			return $"{outputRoot}/{buildTarget}/{YooAssetSettings.OutputFolderName}";
 		}
 
 		/// <summary>

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderSetting.cs

@@ -10,13 +10,18 @@ namespace YooAsset.Editor
 		/// </summary>
 		public int BuildVersion = 0;
 
+		/// <summary>
+		/// 构建管线
+		/// </summary>
+		public EBuildPipeline BuildPipeline = EBuildPipeline.BuiltinBuildPipeline;
+
 		/// <summary>
 		/// 构建模式
 		/// </summary>
 		public EBuildMode BuildMode = EBuildMode.ForceRebuild;
 
 		/// <summary>
-		/// 内置资源标签
+		/// 内置资源标签（首包资源标签）
 		/// </summary>
 		public string BuildTags = string.Empty;
 
@@ -25,14 +30,14 @@ namespace YooAsset.Editor
 		/// </summary>
 		public ECompressOption CompressOption = ECompressOption.LZ4;
 
+		/// <summary>
+		/// 输出文件名称样式
+		/// </summary>
+		public EOutputNameStyle OutputNameStyle = EOutputNameStyle.HashName;
+
 		/// <summary>
 		/// 加密类名称
 		/// </summary>
 		public string EncyptionClassName = string.Empty;
-
-		/// <summary>
-		/// 附加后缀格式
-		/// </summary>
-		public bool AppendExtension = false;
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderSettingData.cs

@@ -19,27 +19,17 @@ namespace YooAsset.Editor
 			}
 		}
 
+		/// <summary>
+		/// 配置数据是否被修改
+		/// </summary>
+		public static bool IsDirty { set; get; } = false;
+
 		/// <summary>
 		/// 加载配置文件
 		/// </summary>
 		private static void LoadSettingData()
 		{
-			// 加载配置文件
+			_setting = EditorHelper.LoadSettingData<AssetBundleBuilderSetting>();
-			string settingFilePath = $"{EditorTools.GetYooAssetSettingPath()}/{nameof(AssetBundleBuilderSetting)}.asset";
-			_setting = AssetDatabase.LoadAssetAtPath<AssetBundleBuilderSetting>(settingFilePath);
-			if (_setting == null)
-			{
-				Debug.LogWarning($"Create new {nameof(AssetBundleBuilderSetting)}.asset : {settingFilePath}");
-				_setting = ScriptableObject.CreateInstance<AssetBundleBuilderSetting>();
-				EditorTools.CreateFileDirectory(settingFilePath);
-				AssetDatabase.CreateAsset(Setting, settingFilePath);
-				AssetDatabase.SaveAssets();
-				AssetDatabase.Refresh();
-			}
-			else
-			{
-				Debug.Log($"Load {nameof(AssetBundleBuilderSetting)}.asset ok");
-			}
 		}
 
 		/// <summary>
@@ -49,6 +39,7 @@ namespace YooAsset.Editor
 		{
 			if (Setting != null)
 			{
+				IsDirty = false;
 				EditorUtility.SetDirty(Setting);
 				AssetDatabase.SaveAssets();
 				Debug.Log($"{nameof(AssetBundleBuilderSetting)}.asset is saved!");

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderWindow.cs

@@ -22,32 +22,37 @@ namespace YooAsset.Editor
 		private List<Type> _encryptionServicesClassTypes;
 		private List<string> _encryptionServicesClassNames;
 
+		private Button _saveButton;
 		private TextField _buildOutputField;
 		private IntegerField _buildVersionField;
+		private EnumField _buildPipelineField;
 		private EnumField _buildModeField;
-		private TextField _buildTagsField;
+		private TextField _buildinTagsField;
 		private PopupField<string> _encryptionField;
 		private EnumField _compressionField;
-		private Toggle _appendExtensionToggle;
+		private EnumField _outputNameStyleField;
 
 		public void CreateGUI()
 		{
-			VisualElement root = this.rootVisualElement;
-
-			// 加载布局文件
-			string rootPath = EditorTools.GetYooAssetSourcePath();
-			string uxml = $"{rootPath}/Editor/AssetBundleBuilder/{nameof(AssetBundleBuilderWindow)}.uxml";
-			var visualAsset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxml);
-			if (visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(AssetBundleBuilderWindow)}.uxml : {uxml}");
-				return;
-			}
-			visualAsset.CloneTree(root);
-
 			try
 			{
+				VisualElement root = this.rootVisualElement;
+
+				// 加载布局文件
+				var visualAsset = EditorHelper.LoadWindowUXML<AssetBundleBuilderWindow>();
+				if (visualAsset == null)
+					return;
+
+				visualAsset.CloneTree(root);
+
+				// 配置保存按钮
+				_saveButton = root.Q<Button>("SaveButton");
+				_saveButton.clicked += SaveBtn_clicked;
+
+				// 构建平台
 				_buildTarget = EditorUserBuildSettings.activeBuildTarget;
+
+				// 加密服务类
 				_encryptionServicesClassTypes = GetEncryptionServicesClassTypes();
 				_encryptionServicesClassNames = _encryptionServicesClassTypes.Select(t => t.FullName).ToList();
 
@@ -63,26 +68,41 @@ namespace YooAsset.Editor
 				_buildVersionField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildVersion);
 				_buildVersionField.RegisterValueChangedCallback(evt =>
 				{
+					AssetBundleBuilderSettingData.IsDirty = true;
 					AssetBundleBuilderSettingData.Setting.BuildVersion = _buildVersionField.value;
 				});
 
+				// 构建管线
+				_buildPipelineField = root.Q<EnumField>("BuildPipeline");
+				_buildPipelineField.Init(AssetBundleBuilderSettingData.Setting.BuildPipeline);
+				_buildPipelineField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildPipeline);
+				_buildPipelineField.style.width = 350;
+				_buildPipelineField.RegisterValueChangedCallback(evt =>
+				{
+					AssetBundleBuilderSettingData.IsDirty = true;
+					AssetBundleBuilderSettingData.Setting.BuildPipeline = (EBuildPipeline)_buildPipelineField.value;
+					RefreshWindow();
+				});
+
 				// 构建模式
 				_buildModeField = root.Q<EnumField>("BuildMode");
 				_buildModeField.Init(AssetBundleBuilderSettingData.Setting.BuildMode);
 				_buildModeField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildMode);
-				_buildModeField.style.width = 300;
+				_buildModeField.style.width = 350;
 				_buildModeField.RegisterValueChangedCallback(evt =>
 				{
+					AssetBundleBuilderSettingData.IsDirty = true;
 					AssetBundleBuilderSettingData.Setting.BuildMode = (EBuildMode)_buildModeField.value;
 					RefreshWindow();
 				});
 
 				// 内置资源标签
-				_buildTagsField = root.Q<TextField>("BuildinTags");
+				_buildinTagsField = root.Q<TextField>("BuildinTags");
-				_buildTagsField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildTags);
+				_buildinTagsField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildTags);
-				_buildTagsField.RegisterValueChangedCallback(evt =>
+				_buildinTagsField.RegisterValueChangedCallback(evt =>
 				{
-					AssetBundleBuilderSettingData.Setting.BuildTags = _buildTagsField.value;
+					AssetBundleBuilderSettingData.IsDirty = true;
+					AssetBundleBuilderSettingData.Setting.BuildTags = _buildinTagsField.value;
 				});
 
 				// 加密方法
@@ -92,9 +112,10 @@ namespace YooAsset.Editor
 					int defaultIndex = GetEncryptionDefaultIndex(AssetBundleBuilderSettingData.Setting.EncyptionClassName);
 					_encryptionField = new PopupField<string>(_encryptionServicesClassNames, defaultIndex);
 					_encryptionField.label = "Encryption";
-					_encryptionField.style.width = 300;
+					_encryptionField.style.width = 350;
 					_encryptionField.RegisterValueChangedCallback(evt =>
 					{
+						AssetBundleBuilderSettingData.IsDirty = true;
 						AssetBundleBuilderSettingData.Setting.EncyptionClassName = _encryptionField.value;
 					});
 					encryptionContainer.Add(_encryptionField);
@@ -103,7 +124,7 @@ namespace YooAsset.Editor
 				{
 					_encryptionField = new PopupField<string>();
 					_encryptionField.label = "Encryption";
-					_encryptionField.style.width = 300;
+					_encryptionField.style.width = 350;
 					encryptionContainer.Add(_encryptionField);
 				}
 
@@ -111,18 +132,22 @@ namespace YooAsset.Editor
 				_compressionField = root.Q<EnumField>("Compression");
 				_compressionField.Init(AssetBundleBuilderSettingData.Setting.CompressOption);
 				_compressionField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.CompressOption);
-				_compressionField.style.width = 300;	
+				_compressionField.style.width = 350;
 				_compressionField.RegisterValueChangedCallback(evt =>
 				{
+					AssetBundleBuilderSettingData.IsDirty = true;
 					AssetBundleBuilderSettingData.Setting.CompressOption = (ECompressOption)_compressionField.value;
 				});
 
-				// 附加后缀格式
+				// 输出文件名称样式
-				_appendExtensionToggle = root.Q<Toggle>("AppendExtension");
+				_outputNameStyleField = root.Q<EnumField>("OutputNameStyle");
-				_appendExtensionToggle.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.AppendExtension);
+				_outputNameStyleField.Init(AssetBundleBuilderSettingData.Setting.OutputNameStyle);
-				_appendExtensionToggle.RegisterValueChangedCallback(evt =>
+				_outputNameStyleField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.OutputNameStyle);
+				_outputNameStyleField.style.width = 350;
+				_outputNameStyleField.RegisterValueChangedCallback(evt =>
 				{
-					AssetBundleBuilderSettingData.Setting.AppendExtension = _appendExtensionToggle.value;
+					AssetBundleBuilderSettingData.IsDirty = true;
+					AssetBundleBuilderSettingData.Setting.OutputNameStyle = (EOutputNameStyle)_outputNameStyleField.value;
 				});
 
 				// 构建按钮
@@ -138,16 +163,38 @@ namespace YooAsset.Editor
 		}
 		public void OnDestroy()
 		{
-			AssetBundleBuilderSettingData.SaveFile();
+			if(AssetBundleBuilderSettingData.IsDirty)
+				AssetBundleBuilderSettingData.SaveFile();
+		}
+		public void Update()
+		{
+			if(_saveButton != null)
+			{
+				if(AssetBundleBuilderSettingData.IsDirty)
+				{
+					if (_saveButton.enabledSelf == false)
+						_saveButton.SetEnabled(true);
+				}
+				else
+				{
+					if(_saveButton.enabledSelf)
+						_saveButton.SetEnabled(false);
+				}
+			}
 		}
 
 		private void RefreshWindow()
 		{
-			bool enableElement = AssetBundleBuilderSettingData.Setting.BuildMode == EBuildMode.ForceRebuild;
+			var buildMode = AssetBundleBuilderSettingData.Setting.BuildMode;
-			_buildTagsField.SetEnabled(enableElement);
+			bool enableElement = buildMode == EBuildMode.ForceRebuild;
+			_buildinTagsField.SetEnabled(enableElement);
 			_encryptionField.SetEnabled(enableElement);
 			_compressionField.SetEnabled(enableElement);
-			_appendExtensionToggle.SetEnabled(enableElement);
+			_outputNameStyleField.SetEnabled(enableElement);
+		}
+		private void SaveBtn_clicked()
+		{
+			AssetBundleBuilderSettingData.SaveFile();
 		}
 		private void BuildButton_clicked()
 		{
@@ -172,17 +219,29 @@ namespace YooAsset.Editor
 			BuildParameters buildParameters = new BuildParameters();
 			buildParameters.OutputRoot = defaultOutputRoot;
 			buildParameters.BuildTarget = _buildTarget;
-			buildParameters.BuildMode = (EBuildMode)_buildModeField.value;
+			buildParameters.BuildPipeline = AssetBundleBuilderSettingData.Setting.BuildPipeline;
-			buildParameters.BuildVersion = _buildVersionField.value;
+			buildParameters.BuildMode = AssetBundleBuilderSettingData.Setting.BuildMode;
-			buildParameters.BuildinTags = _buildTagsField.value;
+			buildParameters.BuildVersion = AssetBundleBuilderSettingData.Setting.BuildVersion;
+			buildParameters.BuildinTags = AssetBundleBuilderSettingData.Setting.BuildTags;
 			buildParameters.VerifyBuildingResult = true;
-			buildParameters.EnableAddressable = AssetBundleGrouperSettingData.Setting.EnableAddressable;
+			buildParameters.EnableAddressable = AssetBundleCollectorSettingData.Setting.EnableAddressable;
-			buildParameters.AppendFileExtension = _appendExtensionToggle.value;
+			buildParameters.CopyBuildinTagFiles = AssetBundleBuilderSettingData.Setting.BuildMode == EBuildMode.ForceRebuild;
 			buildParameters.EncryptionServices = CreateEncryptionServicesInstance();
-			buildParameters.CompressOption = (ECompressOption)_compressionField.value;
+			buildParameters.CompressOption = AssetBundleBuilderSettingData.Setting.CompressOption;
+			buildParameters.OutputNameStyle = AssetBundleBuilderSettingData.Setting.OutputNameStyle;
 
-			AssetBundleBuilder builder = new AssetBundleBuilder();
+			if (AssetBundleBuilderSettingData.Setting.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
-			builder.Run(buildParameters);
+			{
+				buildParameters.SBPParameters = new BuildParameters.SBPBuildParameters();
+				buildParameters.SBPParameters.WriteLinkXML = true;
+			}
+			
+			var builder = new AssetBundleBuilder();
+			var buildResult = builder.Run(buildParameters);
+			if (buildResult.Success)
+			{
+				EditorUtility.RevealInFinder($"{buildParameters.OutputRoot}/{buildParameters.BuildTarget}/{buildParameters.BuildVersion}");
+			}
 		}
 
 		// 加密类相关
@@ -199,9 +258,7 @@ namespace YooAsset.Editor
 		}
 		private List<Type> GetEncryptionServicesClassTypes()
 		{
-			TypeCache.TypeCollection collection = TypeCache.GetTypesDerivedFrom<IEncryptionServices>();
+			return EditorTools.GetAssignableTypes(typeof(IEncryptionServices));
-			List<Type> classTypes = collection.ToList();
-			return classTypes;
 		}
 		private IEncryptionServices CreateEncryptionServicesInstance()
 		{

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderWindow.uxml

@@ -1,12 +1,15 @@
 <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
-    <uie:Toolbar name="Toolbar" style="display: flex;" />
+    <uie:Toolbar name="Toolbar" style="display: flex; flex-direction: row-reverse;">
+        <ui:Button text="Save" display-tooltip-when-elided="true" name="SaveButton" style="background-color: rgb(56, 147, 58);" />
+    </uie:Toolbar>
     <ui:VisualElement name="BuildContainer">
         <ui:TextField picking-mode="Ignore" label="Build Output" name="BuildOutput" />
         <uie:IntegerField label="Build Version" value="0" name="BuildVersion" />
+        <uie:EnumField label="Build Pipeline" name="BuildPipeline" />
         <uie:EnumField label="Build Mode" name="BuildMode" />
         <ui:VisualElement name="EncryptionContainer" style="height: 24px;" />
         <uie:EnumField label="Compression" value="Center" name="Compression" />
-        <ui:Toggle label="Append Extension" name="AppendExtension" style="height: 15px;" />
+        <uie:EnumField label="Output Name Style" value="Center" name="OutputNameStyle" />
         <ui:TextField picking-mode="Ignore" label="Buildin Tags" name="BuildinTags" />
         <ui:Button text="构建" display-tooltip-when-elided="true" name="Build" style="height: 50px; background-color: rgb(40, 106, 42); margin-top: 10px;" />
     </ui:VisualElement>

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleSimulateBuilder.cs

@@ -1,32 +1,30 @@
-using System;
+using UnityEditor;
-using UnityEditor;
 
 namespace YooAsset.Editor
 {
-	public static class AssetBundleRuntimeBuilder
+	public static class AssetBundleSimulateBuilder
 	{
 		private static string _manifestFilePath = string.Empty;
 
 		/// <summary>
-		/// 快速模式构建
+		/// 模拟构建
 		/// </summary>
-		public static void FastBuild()
+		public static void SimulateBuild()
 		{
 			string defaultOutputRoot = AssetBundleBuilderHelper.GetDefaultOutputRoot();
 			BuildParameters buildParameters = new BuildParameters();
 			buildParameters.OutputRoot = defaultOutputRoot;
 			buildParameters.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
-			buildParameters.BuildMode = EBuildMode.FastRunBuild;
+			buildParameters.BuildMode = EBuildMode.SimulateBuild;
-			buildParameters.BuildVersion = AssetBundleBuilderSettingData.Setting.BuildVersion;
+			buildParameters.BuildVersion = 999;
-			buildParameters.BuildinTags = AssetBundleBuilderSettingData.Setting.BuildTags;
+			buildParameters.EnableAddressable = AssetBundleCollectorSettingData.Setting.EnableAddressable;
-			buildParameters.EnableAddressable = AssetBundleGrouperSettingData.Setting.EnableAddressable;
 
 			AssetBundleBuilder builder = new AssetBundleBuilder();
-			bool buildResult = builder.Run(buildParameters);
+			var buildResult = builder.Run(buildParameters);
-			if (buildResult)
+			if (buildResult.Success)
 			{
 				string pipelineOutputDirectory = AssetBundleBuilderHelper.MakePipelineOutputDirectory(buildParameters.OutputRoot, buildParameters.BuildTarget);
-				_manifestFilePath = $"{pipelineOutputDirectory}_{EBuildMode.FastRunBuild}/{YooAssetSettingsData.GetPatchManifestFileName(buildParameters.BuildVersion)}";
+				_manifestFilePath = $"{pipelineOutputDirectory}_{EBuildMode.SimulateBuild}/{YooAssetSettingsData.GetPatchManifestFileName(buildParameters.BuildVersion)}";
 			}
 			else
 			{
@@ -35,9 +33,9 @@ namespace YooAsset.Editor
 		}
 		
 		/// <summary>
-		/// 获取构建的补丁清单文件路径
+		/// 获取构建的补丁清单路径
 		/// </summary>
-		public static string GetPatchManifestFilePath()
+		public static string GetPatchManifestPath()
 		{
 			return _manifestFilePath;
 		}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildAssetInfo.cs

@@ -9,6 +9,7 @@ namespace YooAsset.Editor
 	{
 		private string _mainBundleName;
 		private string _shareBundleName;
+		private bool _isAddAssetTags = false;
 		private readonly HashSet<string> _referenceBundleNames = new HashSet<string>();
 
 		/// <summary>
@@ -37,10 +38,15 @@ namespace YooAsset.Editor
 		public bool IsShaderAsset { private set; get; }
 
 		/// <summary>
-		/// 资源分类标签列表
+		/// 资源的分类标签
 		/// </summary>
 		public readonly List<string> AssetTags = new List<string>();
 
+		/// <summary>
+		/// 资源包的分类标签
+		/// </summary>
+		public readonly List<string> BundleTags = new List<string>();
+
 		/// <summary>
 		/// 依赖的所有资源
 		/// 注意：包括零依赖资源和冗余资源（资源包名无效）
@@ -62,9 +68,9 @@ namespace YooAsset.Editor
 			else
 				IsShaderAsset = false;
 		}
-		public BuildAssetInfo(ECollectorType collectorType, string assetPath)
+		public BuildAssetInfo(string assetPath)
 		{
-			CollectorType = collectorType;
+			CollectorType = ECollectorType.None;
 			Address = string.Empty;
 			AssetPath = assetPath;
 			IsRawAsset = false;
@@ -89,10 +95,15 @@ namespace YooAsset.Editor
 		}
 
 		/// <summary>
-		/// 添加资源分类标签
+		/// 添加资源的分类标签
+		/// 说明：原始定义的资源分类标签
 		/// </summary>
 		public void AddAssetTags(List<string> tags)
 		{
+			if (_isAddAssetTags)
+				throw new Exception("Should never get here !");
+			_isAddAssetTags = true;
+
 			foreach (var tag in tags)
 			{
 				if (AssetTags.Contains(tag) == false)
@@ -102,6 +113,21 @@ namespace YooAsset.Editor
 			}
 		}
 
+		/// <summary>
+		/// 添加资源包的分类标签
+		/// 说明：传染算法统计到的分类标签
+		/// </summary>
+		public void AddBundleTags(List<string> tags)
+		{
+			foreach (var tag in tags)
+			{
+				if (BundleTags.Contains(tag) == false)
+				{
+					BundleTags.Add(tag);
+				}
+			}
+		}
+
 		/// <summary>
 		/// 资源包名是否存在
 		/// </summary>
@@ -147,11 +173,11 @@ namespace YooAsset.Editor
 				if (IsRawAsset)
 					throw new Exception("Should never get here !");
 
-				if (AssetBundleGrouperSettingData.Setting.AutoCollectShaders)
+				if (AssetBundleCollectorSettingData.Setting.AutoCollectShaders)
 				{
 					if (IsShaderAsset)
 					{
-						string shareBundleName = $"{AssetBundleGrouperSettingData.Setting.ShadersBundleName}.{YooAssetSettingsData.Setting.AssetBundleFileVariant}";
+						string shareBundleName = $"{AssetBundleCollectorSettingData.Setting.ShadersBundleName}.{YooAssetSettingsData.Setting.AssetBundleFileVariant}";
 						_shareBundleName = EditorTools.GetRegularPath(shareBundleName).ToLower();
 						return;
 					}
@@ -159,11 +185,9 @@ namespace YooAsset.Editor
 
 				if (_referenceBundleNames.Count > 1)
 				{
-					var bundleNameList = _referenceBundleNames.ToList();
+					IPackRule packRule = PackDirectory.StaticPackRule;
-					bundleNameList.Sort();
+					var bundleName = packRule.GetBundleName(new PackRuleData(AssetPath));
-					string combineName = string.Join("|", bundleNameList);
+					var shareBundleName = $"share_{bundleName}.{YooAssetSettingsData.Setting.AssetBundleFileVariant}";
-					var combineNameHash = HashUtility.StringSHA1(combineName);
-					var shareBundleName = $"share_{combineNameHash}.{YooAssetSettingsData.Setting.AssetBundleFileVariant}";
 					_shareBundleName = EditorTools.GetRegularPath(shareBundleName).ToLower();
 				}
 			}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildBundleInfo.cs

@@ -68,14 +68,14 @@ namespace YooAsset.Editor
 		}
 
 		/// <summary>
-		/// 获取资源标签列表
+		/// 获取资源包的分类标签列表
 		/// </summary>
-		public string[] GetAssetTags()
+		public string[] GetBundleTags()
 		{
 			List<string> result = new List<string>(BuildinAssets.Count);
 			foreach (var assetInfo in BuildinAssets)
 			{
-				foreach (var assetTag in assetInfo.AssetTags)
+				foreach (var assetTag in assetInfo.BundleTags)
 				{
 					if (result.Contains(assetTag) == false)
 						result.Add(assetTag);

Assets/YooAsset/Editor/AssetBundleBuilder/BuildMapContext.cs

@@ -55,13 +55,13 @@ namespace YooAsset.Editor
 		}
 
 		/// <summary>
-		/// 获取AssetBundle内包含的标记列表
+		/// 获取资源包的分类标签列表
 		/// </summary>
-		public string[] GetAssetTags(string bundleName)
+		public string[] GetBundleTags(string bundleName)
 		{
 			if (TryGetBundleInfo(bundleName, out BuildBundleInfo bundleInfo))
 			{
-				return bundleInfo.GetAssetTags();
+				return bundleInfo.GetBundleTags();
 			}
 			throw new Exception($"Not found {nameof(BuildBundleInfo)} : {bundleName}");
 		}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildMapCreater.cs

@@ -10,16 +10,16 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 执行资源构建上下文
 		/// </summary>
-		public static BuildMapContext CreateBuildMap()
+		public static BuildMapContext CreateBuildMap(EBuildMode buildMode)
 		{
 			BuildMapContext context = new BuildMapContext();
 			Dictionary<string, BuildAssetInfo> buildAssetDic = new Dictionary<string, BuildAssetInfo>(1000);
 
 			// 1. 检测配置合法性
-			AssetBundleGrouperSettingData.Setting.CheckConfigError();
+			AssetBundleCollectorSettingData.Setting.CheckConfigError();
 
-			// 2. 获取所有主动收集的资源
+			// 2. 获取所有收集器收集的资源
-			List<CollectAssetInfo> allCollectAssets = AssetBundleGrouperSettingData.Setting.GetAllCollectAssets();
+			List<CollectAssetInfo> allCollectAssets = AssetBundleCollectorSettingData.Setting.GetAllCollectAssets(buildMode);
 
 			// 3. 剔除未被引用的依赖资源
 			List<CollectAssetInfo> removeDependList = new List<CollectAssetInfo>();
@@ -36,13 +36,15 @@ namespace YooAsset.Editor
 				allCollectAssets.Remove(removeValue);
 			}
 
-			// 4. 录入主动收集的资源
+			// 4. 录入所有收集器收集的资源
 			foreach (var collectAssetInfo in allCollectAssets)
 			{
 				if (buildAssetDic.ContainsKey(collectAssetInfo.AssetPath) == false)
 				{
-					var buildAssetInfo = new BuildAssetInfo(collectAssetInfo.CollectorType, collectAssetInfo.BundleName, collectAssetInfo.Address, collectAssetInfo.AssetPath, collectAssetInfo.IsRawAsset);
+					var buildAssetInfo = new BuildAssetInfo(collectAssetInfo.CollectorType, collectAssetInfo.BundleName,
+						collectAssetInfo.Address, collectAssetInfo.AssetPath, collectAssetInfo.IsRawAsset);
 					buildAssetInfo.AddAssetTags(collectAssetInfo.AssetTags);
+					buildAssetInfo.AddBundleTags(collectAssetInfo.AssetTags);
 					buildAssetDic.Add(collectAssetInfo.AssetPath, buildAssetInfo);
 				}
 				else
@@ -58,13 +60,13 @@ namespace YooAsset.Editor
 				{
 					if (buildAssetDic.ContainsKey(dependAssetPath))
 					{
-						buildAssetDic[dependAssetPath].AddAssetTags(collectAssetInfo.AssetTags);
+						buildAssetDic[dependAssetPath].AddBundleTags(collectAssetInfo.AssetTags);
 						buildAssetDic[dependAssetPath].AddReferenceBundleName(collectAssetInfo.BundleName);
 					}
 					else
 					{
-						var buildAssetInfo = new BuildAssetInfo(ECollectorType.None, dependAssetPath);
+						var buildAssetInfo = new BuildAssetInfo(dependAssetPath);
-						buildAssetInfo.AddAssetTags(collectAssetInfo.AssetTags);
+						buildAssetInfo.AddBundleTags(collectAssetInfo.AssetTags);
 						buildAssetInfo.AddReferenceBundleName(collectAssetInfo.BundleName);
 						buildAssetDic.Add(dependAssetPath, buildAssetInfo);
 					}
@@ -92,7 +94,7 @@ namespace YooAsset.Editor
 				pair.Value.CalculateFullBundleName();
 			}
 
-			// 8. 移除未参与构建的资源
+			// 8. 移除不参与构建的资源
 			List<BuildAssetInfo> removeBuildList = new List<BuildAssetInfo>();
 			foreach (KeyValuePair<string, BuildAssetInfo> pair in buildAssetDic)
 			{

Assets/YooAsset/Editor/AssetBundleBuilder/BuildParameters.cs

@@ -9,6 +9,33 @@ namespace YooAsset.Editor
 	/// </summary>
 	public class BuildParameters
 	{
+		/// <summary>
+		/// SBP构建参数
+		/// </summary>
+		public class SBPBuildParameters
+		{
+			/// <summary>
+			/// 生成代码防裁剪配置
+			/// </summary>
+			public bool WriteLinkXML = true;
+
+			/// <summary>
+			/// 缓存服务器地址
+			/// </summary>
+			public string CacheServerHost;
+
+			/// <summary>
+			/// 缓存服务器端口
+			/// </summary>
+			public int CacheServerPort;
+		}
+
+		/// <summary>
+		/// 可编程构建管线的参数
+		/// </summary>
+		public SBPBuildParameters SBPParameters;
+
+
 		/// <summary>
 		/// 输出的根目录
 		/// </summary>
@@ -19,6 +46,11 @@ namespace YooAsset.Editor
 		/// </summary>
 		public BuildTarget BuildTarget;
 
+		/// <summary>
+		/// 构建管线
+		/// </summary>
+		public EBuildPipeline BuildPipeline;
+
 		/// <summary>
 		/// 构建模式
 		/// </summary>
@@ -30,7 +62,7 @@ namespace YooAsset.Editor
 		public int BuildVersion;
 
 		/// <summary>
-		/// 内置资源的标记列表
+		/// 内置资源标签集合（首包资源标签）
 		/// 注意：分号为分隔符
 		/// </summary>
 		public string BuildinTags;
@@ -45,17 +77,11 @@ namespace YooAsset.Editor
 		/// 启用可寻址资源定位
 		/// </summary>
 		public bool EnableAddressable = false;
-
+		
 		/// <summary>
-		/// 启用自动分包机制
+		/// 拷贝内置资源文件到StreamingAssets目录（首包资源文件）
-		/// 说明：自动分包机制可以实现资源零冗余
 		/// </summary>
-		public bool EnableAutoCollect = true;
+		public bool CopyBuildinTagFiles = false;
-
-		/// <summary>
-		/// 追加文件扩展名
-		/// </summary>
-		public bool AppendFileExtension = false;
 
 
 		/// <summary>
@@ -63,16 +89,16 @@ namespace YooAsset.Editor
 		/// </summary>
 		public IEncryptionServices EncryptionServices = null;
 
+		/// <summary>
+		/// 补丁文件名称的样式
+		/// </summary>
+		public EOutputNameStyle OutputNameStyle = EOutputNameStyle.HashName;
+
 		/// <summary>
 		/// 压缩选项
 		/// </summary>
 		public ECompressOption CompressOption = ECompressOption.Uncompressed;
 
-		/// <summary>
-		/// 文件名附加上哈希值
-		/// </summary>
-		public bool AppendHash = false;
-
 		/// <summary>
 		/// 禁止写入类型树结构（可以降低包体和内存并提高加载效率）
 		/// </summary>
@@ -83,18 +109,15 @@ namespace YooAsset.Editor
 		/// </summary>
 		public bool IgnoreTypeTreeChanges = true;
 
-		/// <summary>
-		/// 禁用名称查找资源（可以降内存并提高加载效率）
-		/// </summary>
-		public bool DisableLoadAssetByFileName = false;
-
 
 		/// <summary>
-		/// 获取内置标记列表
+		/// 获取内置资源标签列表（首包资源标签）
 		/// </summary>
 		public List<string> GetBuildinTags()
 		{
 			return StringUtility.StringToStringList(BuildinTags, ';');
 		}
 	}
+
+
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildParametersContext.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class BuildParametersContext : IContextObject
+	{
+		private readonly System.Diagnostics.Stopwatch _buildWatch = new System.Diagnostics.Stopwatch();
+
+		/// <summary>
+		/// 构建参数
+		/// </summary>
+		public BuildParameters Parameters { private set; get; }
+
+		/// <summary>
+		/// 构建管线的输出目录
+		/// </summary>
+		public string PipelineOutputDirectory { private set; get; }
+
+
+		public BuildParametersContext(BuildParameters parameters)
+		{
+			Parameters = parameters;
+
+			PipelineOutputDirectory = AssetBundleBuilderHelper.MakePipelineOutputDirectory(parameters.OutputRoot, parameters.BuildTarget);
+			if (parameters.BuildMode == EBuildMode.DryRunBuild)
+				PipelineOutputDirectory += $"_{EBuildMode.DryRunBuild}";
+			else if (parameters.BuildMode == EBuildMode.SimulateBuild)
+				PipelineOutputDirectory += $"_{EBuildMode.SimulateBuild}";
+		}
+
+		/// <summary>
+		/// 获取本次构建的补丁目录
+		/// </summary>
+		public string GetPackageDirectory()
+		{
+			return $"{Parameters.OutputRoot}/{Parameters.BuildTarget}/{Parameters.BuildVersion}";
+		}
+
+		/// <summary>
+		/// 获取内置构建管线的构建选项
+		/// </summary>
+		public BuildAssetBundleOptions GetPipelineBuildOptions()
+		{
+			// For the new build system, unity always need BuildAssetBundleOptions.CollectDependencies and BuildAssetBundleOptions.DeterministicAssetBundle
+			// 除非设置ForceRebuildAssetBundle标记，否则会进行增量打包
+
+			if (Parameters.BuildMode == EBuildMode.SimulateBuild)
+				throw new Exception("Should never get here !");
+
+			BuildAssetBundleOptions opt = BuildAssetBundleOptions.None;
+			opt |= BuildAssetBundleOptions.StrictMode; //Do not allow the build to succeed if any errors are reporting during it.
+
+			if (Parameters.BuildMode == EBuildMode.DryRunBuild)
+			{
+				opt |= BuildAssetBundleOptions.DryRunBuild;
+				return opt;
+			}
+
+			if (Parameters.CompressOption == ECompressOption.Uncompressed)
+				opt |= BuildAssetBundleOptions.UncompressedAssetBundle;
+			else if (Parameters.CompressOption == ECompressOption.LZ4)
+				opt |= BuildAssetBundleOptions.ChunkBasedCompression;
+
+			if (Parameters.BuildMode == EBuildMode.ForceRebuild)
+				opt |= BuildAssetBundleOptions.ForceRebuildAssetBundle; //Force rebuild the asset bundles
+			if (Parameters.DisableWriteTypeTree)
+				opt |= BuildAssetBundleOptions.DisableWriteTypeTree; //Do not include type information within the asset bundle (don't write type tree).
+			if (Parameters.IgnoreTypeTreeChanges)
+				opt |= BuildAssetBundleOptions.IgnoreTypeTreeChanges; //Ignore the type tree changes when doing the incremental build check.
+
+			opt |= BuildAssetBundleOptions.DisableLoadAssetByFileName; //Disables Asset Bundle LoadAsset by file name.
+			opt |= BuildAssetBundleOptions.DisableLoadAssetByFileNameWithExtension; //Disables Asset Bundle LoadAsset by file name with extension.			
+
+			return opt;
+		}
+
+		/// <summary>
+		/// 获取可编程构建管线的构建参数
+		/// </summary>
+		public UnityEditor.Build.Pipeline.BundleBuildParameters GetSBPBuildParameters()
+		{
+			if (Parameters.BuildMode == EBuildMode.SimulateBuild)
+				throw new Exception("Should never get here !");
+
+			if (Parameters.BuildMode == EBuildMode.DryRunBuild)
+				throw new Exception($"SBP not support {nameof(EBuildMode.DryRunBuild)} build mode !");
+
+			var targetGroup = BuildPipeline.GetBuildTargetGroup(Parameters.BuildTarget);
+			var buildParams = new UnityEditor.Build.Pipeline.BundleBuildParameters(Parameters.BuildTarget, targetGroup, PipelineOutputDirectory);
+
+			if (Parameters.CompressOption == ECompressOption.Uncompressed)
+				buildParams.BundleCompression = UnityEngine.BuildCompression.Uncompressed;
+			else if (Parameters.CompressOption == ECompressOption.LZMA)
+				buildParams.BundleCompression = UnityEngine.BuildCompression.LZMA;
+			else if (Parameters.CompressOption == ECompressOption.LZ4)
+				buildParams.BundleCompression = UnityEngine.BuildCompression.LZ4;
+			else
+				throw new System.NotImplementedException(Parameters.CompressOption.ToString());
+
+			if (Parameters.DisableWriteTypeTree)
+				buildParams.ContentBuildFlags |= UnityEditor.Build.Content.ContentBuildFlags.DisableWriteTypeTree;
+
+			if(Parameters.BuildMode == EBuildMode.ForceRebuild)
+			{
+				buildParams.UseCache = false;
+			}
+			else
+			{
+				buildParams.UseCache = true;
+				buildParams.CacheServerHost = Parameters.SBPParameters.CacheServerHost;
+				buildParams.CacheServerPort = Parameters.SBPParameters.CacheServerPort;
+			}
+			buildParams.WriteLinkXML = Parameters.SBPParameters.WriteLinkXML;
+
+			return buildParams;
+		}
+
+		/// <summary>
+		/// 获取构建的耗时（单位：秒）
+		/// </summary>
+		public float GetBuildingSeconds()
+		{
+			float seconds = _buildWatch.ElapsedMilliseconds / 1000f;
+			return seconds;
+		}
+		public void BeginWatch()
+		{
+			_buildWatch.Start();
+		}
+		public void StopWatch()
+		{
+			_buildWatch.Stop();
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildParametersContext.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b84510feab7cbe44a9b6d8ef0b3f559c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildReport/ReportAssetInfo.cs

@@ -22,6 +22,11 @@ namespace YooAsset.Editor
 		/// 说明：Meta文件记录的GUID
 		/// </summary>
 		public string AssetGUID;
+
+		/// <summary>
+		/// 资源的分类标签
+		/// </summary>
+		public string[] AssetTags;
 		
 		/// <summary>
 		/// 所属资源包名称

Assets/YooAsset/Editor/AssetBundleBuilder/BuildReport/ReportBundleInfo.cs

@@ -8,11 +8,31 @@ namespace YooAsset.Editor
 	[Serializable]
 	public class ReportBundleInfo
 	{
+		public class FlagsData
+		{
+			public bool IsEncrypted { private set; get; }
+			public bool IsBuildin { private set; get; }
+			public bool IsRawFile { private set; get; }
+			public FlagsData(bool isEncrypted, bool isBuildin, bool isRawFile)
+			{
+				IsEncrypted = isEncrypted;
+				IsBuildin = isBuildin;
+				IsRawFile = isRawFile;
+			}
+		}
+
+		private FlagsData _flagData;
+
 		/// <summary>
 		/// 资源包名称
 		/// </summary>
 		public string BundleName;
 
+		/// <summary>
+		/// 文件名称
+		/// </summary>
+		public string FileName;
+
 		/// <summary>
 		/// 哈希值
 		/// </summary>
@@ -38,6 +58,26 @@ namespace YooAsset.Editor
 		/// </summary>
 		public int Flags;
 
+
+		/// <summary>
+		/// 获取标志位的解析数据
+		/// </summary>
+		public FlagsData GetFlagData()
+		{
+			if (_flagData == null)
+			{
+				BitMask32 value = Flags;
+				bool isEncrypted = value.Test(0);
+				bool isBuildin = value.Test(1);
+				bool isRawFile = value.Test(2);
+				_flagData = new FlagsData(isEncrypted, isBuildin, isRawFile);
+			}
+			return _flagData;
+		}
+
+		/// <summary>
+		/// 获取资源分类标签的字符串
+		/// </summary>
 		public string GetTagsString()
 		{
 			if (Tags != null)
@@ -45,5 +85,16 @@ namespace YooAsset.Editor
 			else
 				return string.Empty;
 		}
+
+		/// <summary>
+		/// 是否为原生文件
+		/// </summary>
+		public bool IsRawFile()
+		{
+			if (System.IO.Path.GetExtension(BundleName) == $".{YooAssetSettingsData.Setting.RawFileVariant}")
+				return true;
+			else
+				return false;
+		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildReport/ReportSummary.cs

@@ -8,6 +8,11 @@ namespace YooAsset.Editor
 	[Serializable]
 	public class ReportSummary
 	{
+		/// <summary>
+		/// YooAsset版本
+		/// </summary>
+		public string YooVersion;
+
 		/// <summary>
 		/// 引擎版本
 		/// </summary>
@@ -16,7 +21,7 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 构建时间
 		/// </summary>
-		public string BuildTime;
+		public string BuildDate;
 		
 		/// <summary>
 		/// 构建耗时（单位：秒）
@@ -28,6 +33,11 @@ namespace YooAsset.Editor
 		/// </summary>
 		public BuildTarget BuildTarget;
 
+		/// <summary>
+		/// 构建管线
+		/// </summary>
+		public EBuildPipeline BuildPipeline;
+
 		/// <summary>
 		/// 构建模式
 		/// </summary>
@@ -49,14 +59,9 @@ namespace YooAsset.Editor
 		public bool EnableAddressable;
 
 		/// <summary>
-		/// 启用自动分包机制
+		/// 拷贝内置资源文件
 		/// </summary>
-		public bool EnableAutoCollect;
+		public bool CopyBuildinTagFiles;
-
-		/// <summary>
-		/// 追加文件扩展名
-		/// </summary>
-		public bool AppendFileExtension;
 
 		/// <summary>
 		/// 自动收集着色器
@@ -74,14 +79,14 @@ namespace YooAsset.Editor
 		public string EncryptionServicesClassName;
 
 		// 构建参数
+		public EOutputNameStyle OutputNameStyle;
 		public ECompressOption CompressOption;
-		public bool AppendHash;
 		public bool DisableWriteTypeTree;
 		public bool IgnoreTypeTreeChanges;
-		public bool DisableLoadAssetByFileName;
 
 		// 构建结果
 		public int AssetFileTotalCount;
+		public int MainAssetTotalCount;
 		public int AllBundleTotalCount;
 		public long AllBundleTotalSize;
 		public int BuildinBundleTotalCount;

Assets/YooAsset/Editor/AssetBundleBuilder/BuildSystem/BuildResult.cs

@@ -0,0 +1,24 @@
+
+namespace YooAsset.Editor
+{
+    /// <summary>
+    /// 构建结果
+    /// </summary>
+    public class BuildResult
+    {
+        /// <summary>
+        /// 构建是否成功
+        /// </summary>
+        public bool Success;
+
+        /// <summary>
+        /// 构建失败的任务
+        /// </summary>
+        public string FailedTask;
+
+        /// <summary>
+        /// 构建失败的信息
+        /// </summary>
+        public string FailedInfo;
+    }
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildSystem/BuildResult.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e0855c4b5eaa26942bd7ad177fe3c288
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildSystem/BuildRunner.cs

@@ -14,45 +14,54 @@ namespace YooAsset.Editor
 		/// 执行构建流程
 		/// </summary>
 		/// <returns>如果成功返回TRUE，否则返回FALSE</returns>
-		public static bool Run(List<IBuildTask> pipeline, BuildContext context)
+		public static BuildResult Run(List<IBuildTask> pipeline, BuildContext context)
 		{
 			if (pipeline == null)
 				throw new ArgumentNullException("pipeline");
 			if (context == null)
 				throw new ArgumentNullException("context");
 
-			bool succeed = true;
+			BuildResult buildResult = new BuildResult();
+			buildResult.Success = true;
 			for (int i = 0; i < pipeline.Count; i++)
 			{
 				IBuildTask task = pipeline[i];
 				try
 				{
 					var taskAttribute = task.GetType().GetCustomAttribute<TaskAttribute>();
-					Log($"---------------------------------------->{taskAttribute.Desc}");
+					Log($"---------------------------------------->{taskAttribute.Desc}<---------------------------------------");
 					task.Run(context);
 				}
 				catch (Exception e)
 				{
-					Debug.LogError($"Build task {task.GetType().Name} failed !");
+					buildResult.FailedTask = task.GetType().Name;
-					Debug.LogError($"Build error : {e}");
+					buildResult.FailedInfo = e.ToString();
-					succeed = false;
+					buildResult.Success = false;
 					break;
 				}
 			}
 
 			// 返回运行结果
-			return succeed;
+			return buildResult;
 		}
 
 		/// <summary>
-		/// 普通日志输出
+		/// 日志输出
 		/// </summary>
 		public static void Log(string info)
 		{
 			if (EnableLog)
 			{
 				UnityEngine.Debug.Log(info);
-			}	
+			}
+		}
+
+		/// <summary>
+		/// 日志输出
+		/// </summary>
+		public static void Info(string info)
+		{
+			UnityEngine.Debug.Log(info);
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskBuilding.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Linq;
-using System.IO;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEditor;
@@ -18,12 +17,12 @@ namespace YooAsset.Editor
 
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParametersContext = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
 
-			// 快速构建模式下跳过引擎构建
+			// 模拟构建模式下跳过引擎构建
 			var buildMode = buildParametersContext.Parameters.BuildMode;
-			if (buildMode == EBuildMode.FastRunBuild)
+			if (buildMode == EBuildMode.SimulateBuild)
 				return;
 
 			BuildAssetBundleOptions opt = buildParametersContext.GetPipelineBuildOptions();
@@ -46,7 +45,7 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 拷贝原生文件
 		/// </summary>
-		private void CopyRawBundle(BuildMapContext buildMapContext, AssetBundleBuilder.BuildParametersContext buildParametersContext)
+		private void CopyRawBundle(BuildMapContext buildMapContext, BuildParametersContext buildParametersContext)
 		{
 			foreach (var bundleInfo in buildMapContext.BundleInfos)
 			{

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskBuilding_SBP.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+using UnityEditor.Build.Pipeline;
+using UnityEditor.Build.Pipeline.Interfaces;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("资源构建内容打包")]
+	public class TaskBuilding_SBP : IBuildTask
+	{
+		public class SBPBuildResultContext : IContextObject
+		{
+			public IBundleBuildResults Results;
+		}
+
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+
+			// 模拟构建模式下跳过引擎构建
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+				return;
+
+			// 构建内容
+			var buildContent = new BundleBuildContent(buildMapContext.GetPipelineBuilds());
+
+			// 开始构建
+			IBundleBuildResults buildResults;
+			var buildParameters = buildParametersContext.GetSBPBuildParameters();
+			var taskList = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleBuiltInShaderExtraction);
+			ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out buildResults, taskList);
+			if (exitCode < 0)
+			{
+				throw new Exception($"构建过程中发生错误 : {exitCode}");
+			}
+
+			BuildRunner.Log("Unity引擎打包成功！");
+			SBPBuildResultContext buildResultContext = new SBPBuildResultContext();
+			buildResultContext.Results = buildResults;
+			context.SetContextObject(buildResultContext);
+
+			// 添加Unity内置资源包信息
+			if (buildResults.BundleInfos.Keys.Any(t => t == YooAssetSettings.UnityBuiltInShadersBundleName))
+			{
+				BuildBundleInfo builtInBundleInfo = new BuildBundleInfo(YooAssetSettings.UnityBuiltInShadersBundleName);
+				buildMapContext.BundleInfos.Add(builtInBundleInfo);
+			}
+
+			// 拷贝原生文件
+			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
+			{
+				CopyRawBundle(buildMapContext, buildParametersContext);
+			}
+		}
+
+		/// <summary>
+		/// 拷贝原生文件
+		/// </summary>
+		private void CopyRawBundle(BuildMapContext buildMapContext, BuildParametersContext buildParametersContext)
+		{
+			foreach (var bundleInfo in buildMapContext.BundleInfos)
+			{
+				if (bundleInfo.IsRawFile)
+				{
+					string dest = $"{buildParametersContext.PipelineOutputDirectory}/{bundleInfo.BundleName}";
+					foreach (var buildAsset in bundleInfo.BuildinAssets)
+					{
+						if (buildAsset.IsRawAsset)
+							EditorTools.CopyFile(buildAsset.AssetPath, dest, true);
+					}
+				}
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskBuilding_SBP.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1af5fed7e9f83174d868c12b41c4a79e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskCopyBuildinFiles.cs

@@ -12,8 +12,8 @@ namespace YooAsset.Editor
 		void IBuildTask.Run(BuildContext context)
 		{
 			// 注意：我们只有在强制重建的时候才会拷贝
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
-			if (buildParameters.Parameters.BuildMode == EBuildMode.ForceRebuild)
+			if (buildParameters.Parameters.CopyBuildinTagFiles)
 			{
 				// 清空流目录
 				AssetBundleBuilderHelper.ClearStreamingAssetsFolder();
@@ -35,7 +35,7 @@ namespace YooAsset.Editor
 					continue;
 
 				string sourcePath = $"{pipelineOutputDirectory}/{patchBundle.BundleName}";
-				string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsFolderPath()}/{patchBundle.Hash}";
+				string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsFolderPath()}/{patchBundle.FileName}";
 				EditorTools.CopyFile(sourcePath, destPath, true);
 			}
 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskCreatePatchManifest.cs

@@ -1,8 +1,11 @@
 using System;
-using System.IO;
+using System.Linq;
 using System.Collections;
 using System.Collections.Generic;
 
+using UnityEditor.Build.Pipeline;
+using UnityEditor.Build.Pipeline.Interfaces;
+
 namespace YooAsset.Editor
 {
 	[TaskAttribute("创建补丁清单文件")]
@@ -10,28 +13,36 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			CreatePatchManifestFile(context);
-			var encryptionContext = context.GetContextObject<TaskEncryption.EncryptionContext>();
-			var buildMapContext = context.GetContextObject<BuildMapContext>();
-			CreatePatchManifestFile(buildParameters, buildMapContext, encryptionContext);
 		}
 
 		/// <summary>
 		/// 创建补丁清单文件到输出目录
 		/// </summary>
-		private void CreatePatchManifestFile(AssetBundleBuilder.BuildParametersContext buildParameters,
+		private void CreatePatchManifestFile(BuildContext context)
-			BuildMapContext buildMapContext, TaskEncryption.EncryptionContext encryptionContext)
 		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var encryptionContext = context.GetContextObject<TaskEncryption.EncryptionContext>();
 			int resourceVersion = buildParameters.Parameters.BuildVersion;
 
 			// 创建新补丁清单
 			PatchManifest patchManifest = new PatchManifest();
-			patchManifest.EnableAddressable = buildParameters.Parameters.EnableAddressable;
+			patchManifest.FileVersion = YooAssetSettings.PatchManifestFileVersion;
 			patchManifest.ResourceVersion = buildParameters.Parameters.BuildVersion;
+			patchManifest.EnableAddressable = buildParameters.Parameters.EnableAddressable;
+			patchManifest.OutputNameStyle = (int)buildParameters.Parameters.OutputNameStyle;
 			patchManifest.BuildinTags = buildParameters.Parameters.BuildinTags;
 			patchManifest.BundleList = GetAllPatchBundle(buildParameters, buildMapContext, encryptionContext);
 			patchManifest.AssetList = GetAllPatchAsset(buildParameters, buildMapContext, patchManifest);
 
+			// 更新Unity内置资源包的引用关系
+			if (buildParameters.Parameters.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
+			{
+				var buildResultContext = context.GetContextObject<TaskBuilding_SBP.SBPBuildResultContext>();
+				UpdateBuiltInBundleReference(patchManifest, buildResultContext.Results);
+			}
+
 			// 创建补丁清单文件
 			string manifestFilePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.GetPatchManifestFileName(resourceVersion)}";
 			BuildRunner.Log($"创建补丁清单文件：{manifestFilePath}");
@@ -53,14 +64,12 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 获取资源包列表
 		/// </summary>
-		private List<PatchBundle> GetAllPatchBundle(AssetBundleBuilder.BuildParametersContext buildParameters,
+		private List<PatchBundle> GetAllPatchBundle(BuildParametersContext buildParameters, BuildMapContext buildMapContext,
-			BuildMapContext buildMapContext, TaskEncryption.EncryptionContext encryptionContext)
+			TaskEncryption.EncryptionContext encryptionContext)
 		{
 			List<PatchBundle> result = new List<PatchBundle>(1000);
 
-			// 内置标记列表
 			List<string> buildinTags = buildParameters.Parameters.GetBuildinTags();
-
 			var buildMode = buildParameters.Parameters.BuildMode;
 			bool standardBuild = buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild;
 			foreach (var bundleInfo in buildMapContext.BundleInfos)
@@ -70,17 +79,11 @@ namespace YooAsset.Editor
 				string hash = GetFileHash(filePath, standardBuild);
 				string crc32 = GetFileCRC(filePath, standardBuild);
 				long size = GetFileSize(filePath, standardBuild);
-				string[] tags = buildMapContext.GetAssetTags(bundleName);
+				string[] tags = buildMapContext.GetBundleTags(bundleName);
 				bool isEncrypted = encryptionContext.IsEncryptFile(bundleName);
 				bool isBuildin = IsBuildinBundle(tags, buildinTags);
 				bool isRawFile = bundleInfo.IsRawFile;
 
-				// 附加文件扩展名
-				if (buildParameters.Parameters.AppendFileExtension)
-				{
-					hash += bundleInfo.GetAppendExtension();
-				}
-
 				PatchBundle patchBundle = new PatchBundle(bundleName, hash, crc32, size, tags);
 				patchBundle.SetFlagsValue(isEncrypted, isBuildin, isRawFile);
 				result.Add(patchBundle);
@@ -90,7 +93,7 @@ namespace YooAsset.Editor
 		}
 		private bool IsBuildinBundle(string[] bundleTags, List<string> buildinTags)
 		{
-			// 注意：没有任何标记的Bundle文件默认为内置文件
+			// 注意：没有任何分类标签的Bundle文件默认为内置文件
 			if (bundleTags.Length == 0)
 				return true;
 
@@ -126,8 +129,7 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 获取资源列表
 		/// </summary>
-		private List<PatchAsset> GetAllPatchAsset(AssetBundleBuilder.BuildParametersContext buildParameters,
+		private List<PatchAsset> GetAllPatchAsset(BuildParametersContext buildParameters, BuildMapContext buildMapContext, PatchManifest patchManifest)
-			BuildMapContext buildMapContext, PatchManifest patchManifest)
 		{
 			List<PatchAsset> result = new List<PatchAsset>(1000);
 			foreach (var bundleInfo in buildMapContext.BundleInfos)
@@ -141,6 +143,7 @@ namespace YooAsset.Editor
 					else
 						patchAsset.Address = string.Empty;
 					patchAsset.AssetPath = assetInfo.AssetPath;
+					patchAsset.AssetTags = assetInfo.AssetTags.ToArray();
 					patchAsset.BundleID = GetAssetBundleID(assetInfo.GetBundleName(), patchManifest);
 					patchAsset.DependIDs = GetAssetBundleDependIDs(patchAsset.BundleID, assetInfo, patchManifest);
 					result.Add(patchAsset);
@@ -174,5 +177,45 @@ namespace YooAsset.Editor
 			}
 			throw new Exception($"Not found bundle name : {bundleName}");
 		}
+
+		/// <summary>
+		/// 更新Unity内置资源包的引用关系
+		/// </summary>
+		private void UpdateBuiltInBundleReference(PatchManifest patchManifest, IBundleBuildResults buildResults)
+		{
+			// 获取所有依赖内置资源包的资源包列表
+			List<string> builtInBundleReferenceList = new List<string>();
+			foreach (var valuePair in buildResults.BundleInfos)
+			{
+				if (valuePair.Value.Dependencies.Any(t => t == YooAssetSettings.UnityBuiltInShadersBundleName))
+					builtInBundleReferenceList.Add(valuePair.Key);
+			}
+
+			// 检测依赖交集并更新依赖ID
+			int builtInBundleId = patchManifest.BundleList.Count - 1;
+			foreach (var patchAsset in patchManifest.AssetList)
+			{
+				List<string> dependBundles = GetPatchAssetAllDependBundles(patchManifest, patchAsset);
+				List<string> conflictAssetPathList = dependBundles.Intersect(builtInBundleReferenceList).ToList();
+				if (conflictAssetPathList.Count > 0)
+				{
+					List<int> newDependIDs = new List<int>(patchAsset.DependIDs);
+					newDependIDs.Add(builtInBundleId);
+					patchAsset.DependIDs = newDependIDs.ToArray();
+				}
+			}
+		}
+		private List<string> GetPatchAssetAllDependBundles(PatchManifest patchManifest, PatchAsset patchAsset)
+		{
+			List<string> result = new List<string>();
+			string mainBundle = patchManifest.BundleList[patchAsset.BundleID].BundleName;
+			result.Add(mainBundle);
+			foreach (var dependID in patchAsset.DependIDs)
+			{
+				string dependBundle = patchManifest.BundleList[dependID].BundleName;
+				result.Add(dependBundle);
+			}
+			return result;
+		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskCreatePatchPackage.cs

@@ -8,7 +8,7 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
 			var buildMode = buildParameters.Parameters.BuildMode;
 			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
 			{
@@ -19,7 +19,7 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 拷贝补丁文件到补丁包目录
 		/// </summary>
-		private void CopyPatchFiles(AssetBundleBuilder.BuildParametersContext buildParameters)
+		private void CopyPatchFiles(BuildParametersContext buildParameters)
 		{
 			int resourceVersion = buildParameters.Parameters.BuildVersion;
 			string packageDirectory = buildParameters.GetPackageDirectory();
@@ -54,18 +54,38 @@ namespace YooAsset.Editor
 				EditorTools.CopyFile(sourcePath, destPath, true);
 			}
 
-			// 拷贝UnityManifest序列化文件
+			if (buildParameters.Parameters.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
 			{
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.Setting.UnityManifestFileName}";
+				// 拷贝构建日志
-				string destPath = $"{packageDirectory}/{YooAssetSettingsData.Setting.UnityManifestFileName}";
+				{
-				EditorTools.CopyFile(sourcePath, destPath, true);
+					string sourcePath = $"{buildParameters.PipelineOutputDirectory}/buildlogtep.json";
-			}
+					string destPath = $"{packageDirectory}/buildlogtep.json";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
 
-			// 拷贝UnityManifest文本文件
+				// 拷贝代码防裁剪配置
+				if (buildParameters.Parameters.SBPParameters.WriteLinkXML)
+				{
+					string sourcePath = $"{buildParameters.PipelineOutputDirectory}/link.xml";
+					string destPath = $"{packageDirectory}/link.xml";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
+			}
+			else
 			{
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.Setting.UnityManifestFileName}.manifest";
+				// 拷贝UnityManifest序列化文件
-				string destPath = $"{packageDirectory}/{YooAssetSettingsData.Setting.UnityManifestFileName}.manifest";
+				{
-				EditorTools.CopyFile(sourcePath, destPath, true);
+					string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettings.OutputFolderName}";
+					string destPath = $"{packageDirectory}/{YooAssetSettings.OutputFolderName}";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
+
+				// 拷贝UnityManifest文本文件
+				{
+					string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettings.OutputFolderName}.manifest";
+					string destPath = $"{packageDirectory}/{YooAssetSettings.OutputFolderName}.manifest";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
 			}
 
 			// 拷贝所有补丁文件
@@ -75,7 +95,7 @@ namespace YooAsset.Editor
 			foreach (var patchBundle in patchManifest.BundleList)
 			{
 				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{patchBundle.BundleName}";
-				string destPath = $"{packageDirectory}/{patchBundle.Hash}";
+				string destPath = $"{packageDirectory}/{patchBundle.FileName}";
 				EditorTools.CopyFile(sourcePath, destPath, true);
 				EditorTools.DisplayProgressBar("拷贝补丁文件", ++progressValue, patchFileTotalCount);
 			}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskCreateReport.cs

@@ -10,43 +10,58 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
-			CreateReportFile(buildParameters, buildMapContext);
+			buildParameters.StopWatch();
+
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode != EBuildMode.SimulateBuild)
+			{
+				CreateReportFile(buildParameters, buildMapContext);
+			}
+			else
+			{
+				float buildSeconds = buildParameters.GetBuildingSeconds();
+				BuildRunner.Info($"Build time consuming {buildSeconds} seconds.");
+			}
 		}
 
-		private void CreateReportFile(AssetBundleBuilder.BuildParametersContext buildParameters, BuildMapContext buildMapContext)
+		private void CreateReportFile(BuildParametersContext buildParameters, BuildMapContext buildMapContext)
 		{
 			PatchManifest patchManifest = AssetBundleBuilderHelper.LoadPatchManifestFile(buildParameters.PipelineOutputDirectory, buildParameters.Parameters.BuildVersion);
 			BuildReport buildReport = new BuildReport();
-			buildParameters.StopWatch();
 
 			// 概述信息
 			{
+#if UNITY_2019_4_OR_NEWER
+				UnityEditor.PackageManager.PackageInfo packageInfo = UnityEditor.PackageManager.PackageInfo.FindForAssembly(typeof(BuildReport).Assembly);
+				if (packageInfo != null)
+					buildReport.Summary.YooVersion = packageInfo.version;
+#endif
 				buildReport.Summary.UnityVersion = UnityEngine.Application.unityVersion;
-				buildReport.Summary.BuildTime = DateTime.Now.ToString();
+				buildReport.Summary.BuildDate = DateTime.Now.ToString();
-				buildReport.Summary.BuildSeconds = buildParameters.GetBuildingSeconds();
+				buildReport.Summary.BuildSeconds = (int)buildParameters.GetBuildingSeconds();
 				buildReport.Summary.BuildTarget = buildParameters.Parameters.BuildTarget;
+				buildReport.Summary.BuildPipeline = buildParameters.Parameters.BuildPipeline;
 				buildReport.Summary.BuildMode = buildParameters.Parameters.BuildMode;
 				buildReport.Summary.BuildVersion = buildParameters.Parameters.BuildVersion;
 				buildReport.Summary.BuildinTags = buildParameters.Parameters.BuildinTags;
 				buildReport.Summary.EnableAddressable = buildParameters.Parameters.EnableAddressable;
-				buildReport.Summary.EnableAutoCollect = buildParameters.Parameters.EnableAutoCollect;
+				buildReport.Summary.CopyBuildinTagFiles = buildParameters.Parameters.CopyBuildinTagFiles;
-				buildReport.Summary.AppendFileExtension = buildParameters.Parameters.AppendFileExtension;
+				buildReport.Summary.AutoCollectShaders = AssetBundleCollectorSettingData.Setting.AutoCollectShaders;
-				buildReport.Summary.AutoCollectShaders = AssetBundleGrouperSettingData.Setting.AutoCollectShaders;
+				buildReport.Summary.ShadersBundleName = AssetBundleCollectorSettingData.Setting.ShadersBundleName;
-				buildReport.Summary.ShadersBundleName = AssetBundleGrouperSettingData.Setting.ShadersBundleName;
 				buildReport.Summary.EncryptionServicesClassName = buildParameters.Parameters.EncryptionServices == null ?
 					"null" : buildParameters.Parameters.EncryptionServices.GetType().FullName;
 
 				// 构建参数
+				buildReport.Summary.OutputNameStyle = buildParameters.Parameters.OutputNameStyle;
 				buildReport.Summary.CompressOption = buildParameters.Parameters.CompressOption;
-				buildReport.Summary.AppendHash = buildParameters.Parameters.AppendHash;
 				buildReport.Summary.DisableWriteTypeTree = buildParameters.Parameters.DisableWriteTypeTree;
 				buildReport.Summary.IgnoreTypeTreeChanges = buildParameters.Parameters.IgnoreTypeTreeChanges;
-				buildReport.Summary.DisableLoadAssetByFileName = buildParameters.Parameters.DisableLoadAssetByFileName;
 
 				// 构建结果
 				buildReport.Summary.AssetFileTotalCount = buildMapContext.AssetFileCount;
+				buildReport.Summary.MainAssetTotalCount = GetMainAssetCount(patchManifest);
 				buildReport.Summary.AllBundleTotalCount = GetAllBundleCount(patchManifest);
 				buildReport.Summary.AllBundleTotalSize = GetAllBundleSize(patchManifest);
 				buildReport.Summary.BuildinBundleTotalCount = GetBuildinBundleCount(patchManifest);
@@ -65,6 +80,7 @@ namespace YooAsset.Editor
 				ReportAssetInfo reportAssetInfo = new ReportAssetInfo();
 				reportAssetInfo.Address = patchAsset.Address;
 				reportAssetInfo.AssetPath = patchAsset.AssetPath;
+				reportAssetInfo.AssetTags = patchAsset.AssetTags;
 				reportAssetInfo.AssetGUID = AssetDatabase.AssetPathToGUID(patchAsset.AssetPath);
 				reportAssetInfo.MainBundleName = mainBundle.BundleName;
 				reportAssetInfo.MainBundleSize = mainBundle.SizeBytes;
@@ -79,6 +95,7 @@ namespace YooAsset.Editor
 			{
 				ReportBundleInfo reportBundleInfo = new ReportBundleInfo();
 				reportBundleInfo.BundleName = patchBundle.BundleName;
+				reportBundleInfo.FileName = patchBundle.FileName;
 				reportBundleInfo.Hash = patchBundle.Hash;
 				reportBundleInfo.CRC = patchBundle.CRC;
 				reportBundleInfo.SizeBytes = patchBundle.SizeBytes;
@@ -144,6 +161,10 @@ namespace YooAsset.Editor
 			return result;
 		}
 
+		private int GetMainAssetCount(PatchManifest patchManifest)
+		{
+			return patchManifest.AssetList.Count;
+		}
 		private int GetAllBundleCount(PatchManifest patchManifest)
 		{
 			return patchManifest.BundleList.Count;

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskEncryption.cs

@@ -24,7 +24,7 @@ namespace YooAsset.Editor
 
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
 
 			var buildMode = buildParameters.Parameters.BuildMode;
@@ -45,7 +45,7 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 加密文件
 		/// </summary>
-		private List<string> EncryptFiles(AssetBundleBuilder.BuildParametersContext buildParameters, BuildMapContext buildMapContext)
+		private List<string> EncryptFiles(BuildParametersContext buildParameters, BuildMapContext buildMapContext)
 		{
 			var encryptionServices = buildParameters.Parameters.EncryptionServices;
 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskGetBuildMap.cs

@@ -12,7 +12,8 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildMapContext = BuildMapCreater.CreateBuildMap();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = BuildMapCreater.CreateBuildMap(buildParametersContext.Parameters.BuildMode);
 			context.SetContextObject(buildMapContext);
 			BuildRunner.Log("构建内容准备完毕！");
 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskPrepare.cs

@@ -11,7 +11,7 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
 			buildParameters.BeginWatch();
 
 			// 检测构建平台是否合法
@@ -26,28 +26,39 @@ namespace YooAsset.Editor
 			if (string.IsNullOrEmpty(buildParameters.PipelineOutputDirectory))
 				throw new Exception("输出目录不能为空");
 
+			// 检测当前是否正在构建资源包
+			if (BuildPipeline.isBuildingPlayer)
+				throw new Exception("当前正在构建资源包，请结束后再试");
+
+			// 检测是否有未保存场景
+			if (EditorTools.HasDirtyScenes())
+				throw new Exception("检测到未保存的场景文件");
+
+			// 保存改动的资源
+			AssetDatabase.SaveAssets();
+
 			// 增量更新时候的必要检测
 			var buildMode = buildParameters.Parameters.BuildMode;
 			if (buildMode == EBuildMode.IncrementalBuild)
 			{
 				// 检测历史版本是否存在
-				if (AssetBundleBuilderHelper.HasAnyPackageVersion(buildParameters.Parameters.BuildTarget, buildParameters.Parameters.OutputRoot) == false)
+				if (AssetBundleBuilderHelper.HasAnyPackageVersion(buildParameters.Parameters.BuildTarget, buildParameters.Parameters.OutputRoot))
-					throw new Exception("没有发现任何历史版本，请尝试强制重建");
+				{
+					// 检测构建版本是否合法
+					int maxPackageVersion = AssetBundleBuilderHelper.GetMaxPackageVersion(buildParameters.Parameters.BuildTarget, buildParameters.Parameters.OutputRoot);
+					if (buildParameters.Parameters.BuildVersion <= maxPackageVersion)
+						throw new Exception("构建版本不能小于历史版本");
 
-				// 检测构建版本是否合法
+					// 检测补丁包是否已经存在
-				int maxPackageVersion = AssetBundleBuilderHelper.GetMaxPackageVersion(buildParameters.Parameters.BuildTarget, buildParameters.Parameters.OutputRoot);
+					string packageDirectory = buildParameters.GetPackageDirectory();
-				if (buildParameters.Parameters.BuildVersion <= maxPackageVersion)
+					if (Directory.Exists(packageDirectory))
-					throw new Exception("构建版本不能小于历史版本");
+						throw new Exception($"补丁包已经存在：{packageDirectory}");
 
-				// 检测补丁包是否已经存在
+					// 检测内置资源分类标签是否一致
-				string packageDirectory = buildParameters.GetPackageDirectory();
+					var oldPatchManifest = AssetBundleBuilderHelper.GetOldPatchManifest(buildParameters.PipelineOutputDirectory);
-				if (Directory.Exists(packageDirectory))
+					if (buildParameters.Parameters.BuildinTags != oldPatchManifest.BuildinTags)
-					throw new Exception($"补丁包已经存在：{packageDirectory}");
+						throw new Exception($"增量更新时内置资源标签必须一致：{buildParameters.Parameters.BuildinTags} != {oldPatchManifest.BuildinTags}");
-
+				}
-				// 检测内置资源分类标签是否一致
-				var oldPatchManifest = AssetBundleBuilderHelper.GetOldPatchManifest(buildParameters.PipelineOutputDirectory);
-				if (buildParameters.Parameters.BuildinTags != oldPatchManifest.BuildinTags)
-					throw new Exception($"增量更新时内置资源标签必须一致：{buildParameters.Parameters.BuildinTags} != {oldPatchManifest.BuildinTags}");
 			}
 
 			// 如果是强制重建

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskVerifyBuildResult.cs

@@ -13,10 +13,10 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParametersContext = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
 			
-			// 快速构建模式下跳过验证
+			// 模拟构建模式下跳过验证
-			if (buildParametersContext.Parameters.BuildMode == EBuildMode.FastRunBuild)
+			if (buildParametersContext.Parameters.BuildMode == EBuildMode.SimulateBuild)
 				return;
 
 			// 验证构建结果
@@ -32,58 +32,26 @@ namespace YooAsset.Editor
 		/// </summary>
 		private void VerifyingBuildingResult(BuildContext context, AssetBundleManifest unityManifest)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
 			string[] buildedBundles = unityManifest.GetAllAssetBundles();
 
 			// 1. 过滤掉原生Bundle
-			List<BuildBundleInfo> expectBundles = new List<BuildBundleInfo>(buildedBundles.Length);
+			string[] expectBundles = buildMapContext.BundleInfos.Where(t => t.IsRawFile == false).Select(t => t.BundleName).ToArray();
-			foreach(var bundleInfo in buildMapContext.BundleInfos)
-			{
-				if (bundleInfo.IsRawFile == false)
-					expectBundles.Add(bundleInfo);
-			}
 
-			// 2. 验证数量		
+			// 2. 验证Bundle
-			if (buildedBundles.Length != expectBundles.Count)
+			List<string> intersectBundleList = buildedBundles.Except(expectBundles).ToList();
+			if (intersectBundleList.Count > 0)
 			{
-				Debug.LogWarning($"构建过程中可能存在无效的资源，导致和预期构建的Bundle数量不一致！");
+				foreach (var intersectBundle in intersectBundleList)
-			}
-
-			// 3. 正向验证Bundle
-			foreach (var bundleName in buildedBundles)
-			{
-				if (buildMapContext.IsContainsBundle(bundleName) == false)
 				{
-					throw new Exception($"Should never get here !");
+					Debug.LogWarning($"差异资源包: {intersectBundle}");
 				}
+				throw new System.Exception("存在差异资源包！请查看警告信息！");
 			}
 
-			// 4. 反向验证Bundle
+			// 3. 验证Asset
 			bool isPass = true;
-			foreach (var expectBundle in expectBundles)
-			{
-				bool isMatch = false;
-				foreach (var buildedBundle in buildedBundles)
-				{
-					if (buildedBundle == expectBundle.BundleName)
-					{
-						isMatch = true;
-						break;
-					}
-				}
-				if (isMatch == false)
-				{
-					isPass = false;
-					Debug.LogWarning($"没有找到预期构建的Bundle文件 : {expectBundle.BundleName}");
-				}
-			}
-			if(isPass == false)
-			{
-				throw new Exception("构建结果验证没有通过，请参考警告日志！");
-			}
-
-			// 5. 验证Asset
 			var buildMode = buildParameters.Parameters.BuildMode;
 			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
 			{
@@ -96,38 +64,14 @@ namespace YooAsset.Editor
 					if (expectBuildinAssetPaths.Length != allBuildinAssetPaths.Length)
 					{
 						Debug.LogWarning($"构建的Bundle文件内的资源对象数量和预期不匹配 : {buildedBundle}");
+						var intersectAssetList = expectBuildinAssetPaths.Except(allBuildinAssetPaths).ToList();
+						foreach (var intersectAssset in intersectAssetList)
+						{
+							Debug.LogWarning($"构建失败的资源对象路径为 : {intersectAssset}");
+						}
 						isPass = false;
 						continue;
 					}
-
-					foreach (var buildinAssetPath in allBuildinAssetPaths)
-					{
-						var guid = AssetDatabase.AssetPathToGUID(buildinAssetPath);
-						if (string.IsNullOrEmpty(guid))
-						{
-							Debug.LogWarning($"无效的资源路径，请检查路径是否带有特殊符号或中文：{buildinAssetPath}");
-							isPass = false;
-							continue;
-						}
-
-						bool isMatch = false;
-						foreach (var exceptBuildAssetPath in expectBuildinAssetPaths)
-						{
-							var guidExcept = AssetDatabase.AssetPathToGUID(exceptBuildAssetPath);
-							if (guid == guidExcept)
-							{
-								isMatch = true;
-								break;
-							}
-						}
-						if (isMatch == false)
-						{
-							Debug.LogWarning($"在构建的Bundle文件里发现了没有匹配的资源对象：{buildinAssetPath}");
-							isPass = false;
-							continue;
-						}
-					}
-
 					EditorTools.DisplayProgressBar("验证构建结果", ++progressValue, buildedBundles.Length);
 				}
 				EditorTools.ClearProgressBar();
@@ -137,7 +81,6 @@ namespace YooAsset.Editor
 				}
 			}
 
-			// 卸载所有加载的Bundle
 			BuildRunner.Log("构建结果验证成功！");
 		}
 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskVerifyBuildResult_SBP.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEditor.Build.Pipeline.Interfaces;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("验证构建结果")]
+	public class TaskVerifyBuildResult_SBP : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+
+			// 模拟构建模式下跳过验证
+			if (buildParametersContext.Parameters.BuildMode == EBuildMode.SimulateBuild)
+				return;
+
+			// 验证构建结果
+			if (buildParametersContext.Parameters.VerifyBuildingResult)
+			{
+				var buildResultContext = context.GetContextObject<TaskBuilding_SBP.SBPBuildResultContext>();
+				VerifyingBuildingResult(context, buildResultContext.Results);
+			}
+		}
+
+		/// <summary>
+		/// 验证构建结果
+		/// </summary>
+		private void VerifyingBuildingResult(BuildContext context, IBundleBuildResults buildResults)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+
+			// 1. 移除特定Bundle
+			List<string> buildedBundles = buildResults.BundleInfos.Keys.ToList();
+			buildedBundles.Remove(YooAssetSettings.UnityBuiltInShadersBundleName);
+
+			// 2. 过滤掉原生Bundle
+			List<string> expectBundles = buildMapContext.BundleInfos.Where(t => t.IsRawFile == false).Select(t => t.BundleName).ToList();
+
+			// 3. 验证Bundle
+			List<string> intersectBundleList = buildedBundles.Except(expectBundles).ToList();
+			if (intersectBundleList.Count > 0)
+			{
+				foreach (var intersectBundle in intersectBundleList)
+				{
+					Debug.LogWarning($"差异资源包: {intersectBundle}");
+				}
+				throw new System.Exception("存在差异资源包！请查看警告信息！");
+			}
+
+			BuildRunner.Log("构建结果验证成功！");
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildTasks/TaskVerifyBuildResult_SBP.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 16aa7c2c37209a043b4f33d7854047c6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleBuilder/EBuildMode.cs

@@ -16,14 +16,14 @@ namespace YooAsset.Editor
 		/// </summary>
 		IncrementalBuild,
 
-		/// <summary>
-		/// 快速构建模式
-		/// </summary>
-		FastRunBuild,
-
 		/// <summary>
 		/// 演练构建模式
 		/// </summary>
 		DryRunBuild,
+
+		/// <summary>
+		/// 模拟构建模式
+		/// </summary>
+		SimulateBuild,
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/EBuildPipeline.cs

@@ -0,0 +1,19 @@
+
+namespace YooAsset.Editor
+{
+	/// <summary>
+	/// 构建管线类型
+	/// </summary>
+	public enum EBuildPipeline
+	{
+		/// <summary>
+		/// 传统内置构建管线
+		/// </summary>
+		BuiltinBuildPipeline,
+		
+		/// <summary>
+		/// 可编程构建管线
+		/// </summary>
+		ScriptableBuildPipeline,
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/EBuildPipeline.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e53e56a0f6b01dd4c933249d2bda8d78
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleBuilder/EOutputNameStyle.cs

@@ -0,0 +1,29 @@
+
+namespace YooAsset.Editor
+{
+	/// <summary>
+	/// 输出文件名称的样式
+	/// </summary>
+	public enum EOutputNameStyle
+	{
+		/// <summary>
+		/// 000000000000000f000000000000000
+		/// </summary>
+		HashName = 1,
+
+		/// <summary>
+		/// 000000000000000f000000000000000.bundle
+		/// </summary>
+		HashName_Extension = 2,
+
+		/// <summary>
+		/// bundle_name_000000000000000f000000000000000
+		/// </summary>
+		BundleName_HashName = 3,
+
+		/// <summary>
+		/// bundle_name_000000000000000f000000000000000.bundle
+		/// </summary>
+		BundleName_HashName_Extension = 4,
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/EOutputNameStyle.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 84c5eff5dedf53343897e83f6b10eea6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollector.cs

@@ -51,13 +51,13 @@ namespace YooAsset.Editor
 			if (CollectorType == ECollectorType.None)
 				return false;
 
-			if (AssetBundleGrouperSettingData.HasAddressRuleName(AddressRuleName) == false)
+			if (AssetBundleCollectorSettingData.HasAddressRuleName(AddressRuleName) == false)
 				return false;
 
-			if (AssetBundleGrouperSettingData.HasPackRuleName(PackRuleName) == false)
+			if (AssetBundleCollectorSettingData.HasPackRuleName(PackRuleName) == false)
 				return false;
 
-			if (AssetBundleGrouperSettingData.HasFilterRuleName(FilterRuleName) == false)
+			if (AssetBundleCollectorSettingData.HasFilterRuleName(FilterRuleName) == false)
 				return false;
 
 			return true;
@@ -74,21 +74,28 @@ namespace YooAsset.Editor
 			if (CollectorType == ECollectorType.None)
 				throw new Exception($"{nameof(ECollectorType)}.{ECollectorType.None} is invalid in collector : {CollectPath}");
 
-			if (AssetBundleGrouperSettingData.HasPackRuleName(PackRuleName) == false)
+			if (AssetBundleCollectorSettingData.HasPackRuleName(PackRuleName) == false)
 				throw new Exception($"Invalid {nameof(IPackRule)} class type : {PackRuleName} in collector : {CollectPath}");
 
-			if (AssetBundleGrouperSettingData.HasFilterRuleName(FilterRuleName) == false)
+			if (AssetBundleCollectorSettingData.HasFilterRuleName(FilterRuleName) == false)
 				throw new Exception($"Invalid {nameof(IFilterRule)} class type : {FilterRuleName} in collector : {CollectPath}");
 
-			if (AssetBundleGrouperSettingData.HasAddressRuleName(AddressRuleName) == false)
+			if (AssetBundleCollectorSettingData.HasAddressRuleName(AddressRuleName) == false)
 				throw new Exception($"Invalid {nameof(IAddressRule)} class type : {AddressRuleName} in collector : {CollectPath}");
 		}
 
 		/// <summary>
 		/// 获取打包收集的资源文件
 		/// </summary>
-		public List<CollectAssetInfo> GetAllCollectAssets(AssetBundleGrouper grouper)
+		public List<CollectAssetInfo> GetAllCollectAssets(EBuildMode buildMode, AssetBundleCollectorGroup group)
 		{
+			// 注意：模拟构建模式下只收集主资源
+			if (buildMode == EBuildMode.SimulateBuild)
+			{
+				if (CollectorType != ECollectorType.MainAssetCollector)
+					return new List<CollectAssetInfo>();
+			}
+
 			Dictionary<string, CollectAssetInfo> result = new Dictionary<string, CollectAssetInfo>(1000);
 			bool isRawAsset = PackRuleName == nameof(PackRawFile);
 
@@ -97,7 +104,7 @@ namespace YooAsset.Editor
 				throw new Exception($"The raw file must be set to {nameof(ECollectorType)}.{ECollectorType.MainAssetCollector} : {CollectPath}");
 
 			if (string.IsNullOrEmpty(CollectPath))
-				throw new Exception($"The collect path is null or empty in grouper : {grouper.GrouperName}");
+				throw new Exception($"The collect path is null or empty in group : {group.GroupName}");
 
 			// 收集打包资源
 			if (AssetDatabase.IsValidFolder(CollectPath))
@@ -110,7 +117,7 @@ namespace YooAsset.Editor
 					{
 						if (result.ContainsKey(assetPath) == false)
 						{
-							var collectAssetInfo = CreateCollectAssetInfo(grouper, assetPath, isRawAsset);
+							var collectAssetInfo = CreateCollectAssetInfo(buildMode, group, assetPath, isRawAsset);
 							result.Add(assetPath, collectAssetInfo);
 						}
 						else
@@ -125,7 +132,7 @@ namespace YooAsset.Editor
 				string assetPath = CollectPath;
 				if (IsValidateAsset(assetPath) && IsCollectAsset(assetPath))
 				{
-					var collectAssetInfo = CreateCollectAssetInfo(grouper, assetPath, isRawAsset);
+					var collectAssetInfo = CreateCollectAssetInfo(buildMode, group, assetPath, isRawAsset);
 					result.Add(assetPath, collectAssetInfo);
 				}
 				else
@@ -135,7 +142,7 @@ namespace YooAsset.Editor
 			}
 
 			// 检测可寻址地址是否重复
-			if (AssetBundleGrouperSettingData.Setting.EnableAddressable)
+			if (AssetBundleCollectorSettingData.Setting.EnableAddressable)
 			{
 				HashSet<string> adressTemper = new HashSet<string>();
 				foreach (var collectInfoPair in result)
@@ -155,28 +162,50 @@ namespace YooAsset.Editor
 			return result.Values.ToList();
 		}
 
-		private CollectAssetInfo CreateCollectAssetInfo(AssetBundleGrouper grouper, string assetPath, bool isRawAsset)
+		private CollectAssetInfo CreateCollectAssetInfo(EBuildMode buildMode, AssetBundleCollectorGroup group, string assetPath, bool isRawAsset)
 		{
-			string address = GetAddress(grouper, assetPath);
+			string address = GetAddress(group, assetPath);
-			string bundleName = GetBundleName(grouper, assetPath);
+			string bundleName = GetBundleName(group, assetPath);
-			List<string> assetTags = GetAssetTags(grouper);
+			List<string> assetTags = GetAssetTags(group);
 			CollectAssetInfo collectAssetInfo = new CollectAssetInfo(CollectorType, bundleName, address, assetPath, assetTags, isRawAsset);
-			collectAssetInfo.DependAssets = GetAllDependencies(assetPath);
+
+			// 注意：模拟构建模式下不需要收集依赖资源
+			if (buildMode == EBuildMode.SimulateBuild)
+				collectAssetInfo.DependAssets = new List<string>();
+			else
+				collectAssetInfo.DependAssets = GetAllDependencies(assetPath);
+
 			return collectAssetInfo;
 		}
 		private bool IsValidateAsset(string assetPath)
 		{
 			if (assetPath.StartsWith("Assets/") == false && assetPath.StartsWith("Packages/") == false)
+			{
+				UnityEngine.Debug.LogError($"Invalid asset path : {assetPath}");
 				return false;
+			}
+			if (assetPath.Contains("/Gizmos/"))
+			{
+				UnityEngine.Debug.LogWarning($"Cannot pack gizmos asset : {assetPath}");
+				return false;
+			}
 
+			// 忽略文件夹
 			if (AssetDatabase.IsValidFolder(assetPath))
 				return false;
 
-			// 注意：忽略编辑器下的类型资源
+			// 忽略编辑器下的类型资源
 			Type type = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
 			if (type == typeof(LightingDataAsset))
 				return false;
 
+			// 忽略Unity无法识别的无效文件
+			if (type == typeof(UnityEditor.DefaultAsset))
+			{
+				UnityEngine.Debug.LogWarning($"Cannot pack default asset : {assetPath}");
+				return false;
+			}
+
 			string ext = System.IO.Path.GetExtension(assetPath);
 			if (ext == "" || ext == ".dll" || ext == ".cs" || ext == ".js" || ext == ".boo" || ext == ".meta" || ext == ".cginc")
 				return false;
@@ -186,7 +215,7 @@ namespace YooAsset.Editor
 		private bool IsCollectAsset(string assetPath)
 		{
 			// 如果收集全路径着色器
-			if (AssetBundleGrouperSettingData.Setting.AutoCollectShaders)
+			if (AssetBundleCollectorSettingData.Setting.AutoCollectShaders)
 			{
 				Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
 				if (assetType == typeof(UnityEngine.Shader))
@@ -194,41 +223,41 @@ namespace YooAsset.Editor
 			}
 
 			// 根据规则设置过滤资源文件
-			IFilterRule filterRuleInstance = AssetBundleGrouperSettingData.GetFilterRuleInstance(FilterRuleName);
+			IFilterRule filterRuleInstance = AssetBundleCollectorSettingData.GetFilterRuleInstance(FilterRuleName);
 			return filterRuleInstance.IsCollectAsset(new FilterRuleData(assetPath));
 		}
-		private string GetAddress(AssetBundleGrouper grouper, string assetPath)
+		private string GetAddress(AssetBundleCollectorGroup group, string assetPath)
 		{
 			if (CollectorType != ECollectorType.MainAssetCollector)
 				return string.Empty;
 
-			IAddressRule addressRuleInstance = AssetBundleGrouperSettingData.GetAddressRuleInstance(AddressRuleName);
+			IAddressRule addressRuleInstance = AssetBundleCollectorSettingData.GetAddressRuleInstance(AddressRuleName);
-			string adressValue = addressRuleInstance.GetAssetAddress(new AddressRuleData(assetPath, CollectPath, grouper.GrouperName));
+			string adressValue = addressRuleInstance.GetAssetAddress(new AddressRuleData(assetPath, CollectPath, group.GroupName));
 			return adressValue;
 		}
-		private string GetBundleName(AssetBundleGrouper grouper, string assetPath)
+		private string GetBundleName(AssetBundleCollectorGroup group, string assetPath)
 		{
 			// 如果自动收集所有的着色器
-			if (AssetBundleGrouperSettingData.Setting.AutoCollectShaders)
+			if (AssetBundleCollectorSettingData.Setting.AutoCollectShaders)
 			{
 				System.Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
 				if (assetType == typeof(UnityEngine.Shader))
 				{
-					string bundleName = AssetBundleGrouperSettingData.Setting.ShadersBundleName;
+					string bundleName = AssetBundleCollectorSettingData.Setting.ShadersBundleName;
 					return EditorTools.GetRegularPath(bundleName).ToLower();
 				}
 			}
 
 			// 根据规则设置获取资源包名称
 			{
-				IPackRule packRuleInstance = AssetBundleGrouperSettingData.GetPackRuleInstance(PackRuleName);
+				IPackRule packRuleInstance = AssetBundleCollectorSettingData.GetPackRuleInstance(PackRuleName);
-				string bundleName = packRuleInstance.GetBundleName(new PackRuleData(assetPath, CollectPath, grouper.GrouperName));
+				string bundleName = packRuleInstance.GetBundleName(new PackRuleData(assetPath, CollectPath, group.GroupName));
 				return EditorTools.GetRegularPath(bundleName).ToLower();
 			}
 		}
-		private List<string> GetAssetTags(AssetBundleGrouper grouper)
+		private List<string> GetAssetTags(AssetBundleCollectorGroup group)
 		{
-			List<string> tags = StringUtility.StringToStringList(grouper.AssetTags, ';');
+			List<string> tags = StringUtility.StringToStringList(group.AssetTags, ';');
 			List<string> temper = StringUtility.StringToStringList(AssetTags, ';');
 			tags.AddRange(temper);
 			return tags;

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorConfig.cs

@@ -8,14 +8,18 @@ using UnityEngine;
 
 namespace YooAsset.Editor
 {
-	public class AssetBundleGrouperConfig
+	public class AssetBundleCollectorConfig
 	{
-		public const string XmlShader = "Shader";
+		public const string ConfigVersion = "1.0";
+
+		public const string XmlVersion = "Version";
+		public const string XmlCommon = "Common";
+		public const string XmlEnableAddressable = "AutoAddressable";
 		public const string XmlAutoCollectShader = "AutoCollectShader";
 		public const string XmlShaderBundleName = "ShaderBundleName";
-		public const string XmlGrouper = "Grouper";
+		public const string XmlGroup = "Group";
-		public const string XmlGrouperName = "GrouperName";
+		public const string XmlGroupName = "GroupName";
-		public const string XmlGrouperDesc = "GrouperDesc";
+		public const string XmlGroupDesc = "GroupDesc";
 		public const string XmlCollector = "Collector";
 		public const string XmlCollectPath = "CollectPath";
 		public const string XmlCollectorType = "CollectType";
@@ -40,43 +44,54 @@ namespace YooAsset.Editor
 			xml.Load(filePath);
 			XmlElement root = xml.DocumentElement;
 
-			// 读取着色器配置
+			// 读取配置版本
+			string configVersion = root.GetAttribute(XmlVersion);
+			if(configVersion != ConfigVersion)
+			{
+				throw new Exception($"The config version is invalid : {configVersion}");
+			}
+
+			// 读取公共配置
+			bool enableAddressable = false;
 			bool autoCollectShaders = false;
 			string shaderBundleName = string.Empty;
-			var shaderNodeList = root.GetElementsByTagName(XmlShader);
+			var commonNodeList = root.GetElementsByTagName(XmlCommon);
-			if (shaderNodeList.Count > 0)
+			if (commonNodeList.Count > 0)
 			{
-				XmlElement shaderElement = shaderNodeList[0] as XmlElement;
+				XmlElement commonElement = commonNodeList[0] as XmlElement;
-				if (shaderElement.HasAttribute(XmlAutoCollectShader) == false)
+				if (commonElement.HasAttribute(XmlEnableAddressable) == false)
-					throw new Exception($"Not found attribute {XmlAutoCollectShader} in {XmlShader}");
+					throw new Exception($"Not found attribute {XmlEnableAddressable} in {XmlCommon}");
-				if (shaderElement.HasAttribute(XmlShaderBundleName) == false)
+				if (commonElement.HasAttribute(XmlAutoCollectShader) == false)
-					throw new Exception($"Not found attribute {XmlShaderBundleName} in {XmlShader}");
+					throw new Exception($"Not found attribute {XmlAutoCollectShader} in {XmlCommon}");
+				if (commonElement.HasAttribute(XmlShaderBundleName) == false)
+					throw new Exception($"Not found attribute {XmlShaderBundleName} in {XmlCommon}");
 
-				autoCollectShaders = shaderElement.GetAttribute(XmlAutoCollectShader) == "True" ? true : false;
+				enableAddressable = commonElement.GetAttribute(XmlEnableAddressable) == "True" ? true : false;
-				shaderBundleName = shaderElement.GetAttribute(XmlShaderBundleName);
+				autoCollectShaders = commonElement.GetAttribute(XmlAutoCollectShader) == "True" ? true : false;
+				shaderBundleName = commonElement.GetAttribute(XmlShaderBundleName);
 			}
 
 			// 读取分组配置
-			List<AssetBundleGrouper> grouperTemper = new List<AssetBundleGrouper>();
+			List<AssetBundleCollectorGroup> groupTemper = new List<AssetBundleCollectorGroup>();
-			var grouperNodeList = root.GetElementsByTagName(XmlGrouper);
+			var groupNodeList = root.GetElementsByTagName(XmlGroup);
-			foreach (var grouperNode in grouperNodeList)
+			foreach (var groupNode in groupNodeList)
 			{
-				XmlElement grouperElement = grouperNode as XmlElement;
+				XmlElement groupElement = groupNode as XmlElement;
-				if (grouperElement.HasAttribute(XmlGrouperName) == false)
+				if (groupElement.HasAttribute(XmlGroupName) == false)
-					throw new Exception($"Not found attribute {XmlGrouperName} in {XmlGrouper}");
+					throw new Exception($"Not found attribute {XmlGroupName} in {XmlGroup}");
-				if (grouperElement.HasAttribute(XmlGrouperDesc) == false)
+				if (groupElement.HasAttribute(XmlGroupDesc) == false)
-					throw new Exception($"Not found attribute {XmlGrouperDesc} in {XmlGrouper}");
+					throw new Exception($"Not found attribute {XmlGroupDesc} in {XmlGroup}");
-				if (grouperElement.HasAttribute(XmlAssetTags) == false)
+				if (groupElement.HasAttribute(XmlAssetTags) == false)
-					throw new Exception($"Not found attribute {XmlAssetTags} in {XmlGrouper}");
+					throw new Exception($"Not found attribute {XmlAssetTags} in {XmlGroup}");
 
-				AssetBundleGrouper grouper = new AssetBundleGrouper();
+				AssetBundleCollectorGroup group = new AssetBundleCollectorGroup();
-				grouper.GrouperName = grouperElement.GetAttribute(XmlGrouperName);
+				group.GroupName = groupElement.GetAttribute(XmlGroupName);
-				grouper.GrouperDesc = grouperElement.GetAttribute(XmlGrouperDesc);
+				group.GroupDesc = groupElement.GetAttribute(XmlGroupDesc);
-				grouper.AssetTags = grouperElement.GetAttribute(XmlAssetTags);
+				group.AssetTags = groupElement.GetAttribute(XmlAssetTags);
-				grouperTemper.Add(grouper);
+				groupTemper.Add(group);
 
 				// 读取收集器配置
-				var collectorNodeList = grouperElement.GetElementsByTagName(XmlCollector);
+				var collectorNodeList = groupElement.GetElementsByTagName(XmlCollector);
 				foreach (var collectorNode in collectorNodeList)
 				{
 					XmlElement collectorElement = collectorNode as XmlElement;
@@ -100,16 +115,17 @@ namespace YooAsset.Editor
 					collector.PackRuleName = collectorElement.GetAttribute(XmlPackRule);
 					collector.FilterRuleName = collectorElement.GetAttribute(XmlFilterRule);
 					collector.AssetTags = collectorElement.GetAttribute(XmlAssetTags); ;
-					grouper.Collectors.Add(collector);
+					group.Collectors.Add(collector);
 				}
 			}
 
 			// 保存配置数据
-			AssetBundleGrouperSettingData.ClearAll();
+			AssetBundleCollectorSettingData.ClearAll();
-			AssetBundleGrouperSettingData.Setting.AutoCollectShaders = autoCollectShaders;
+			AssetBundleCollectorSettingData.Setting.EnableAddressable = enableAddressable;
-			AssetBundleGrouperSettingData.Setting.ShadersBundleName = shaderBundleName;
+			AssetBundleCollectorSettingData.Setting.AutoCollectShaders = autoCollectShaders;
-			AssetBundleGrouperSettingData.Setting.Groupers.AddRange(grouperTemper);
+			AssetBundleCollectorSettingData.Setting.ShadersBundleName = shaderBundleName;
-			AssetBundleGrouperSettingData.SaveFile();
+			AssetBundleCollectorSettingData.Setting.Groups.AddRange(groupTemper);
+			AssetBundleCollectorSettingData.SaveFile();
 			Debug.Log($"导入配置完毕！");
 		}
 
@@ -130,22 +146,27 @@ namespace YooAsset.Editor
 			xmlDoc.LoadXml(sb.ToString());
 			XmlElement root = xmlDoc.DocumentElement;
 
-			// 设置着色器配置
+			// 设置配置版本
-			var shaderElement = xmlDoc.CreateElement(XmlShader);
+			root.SetAttribute(XmlVersion, ConfigVersion);
-			shaderElement.SetAttribute(XmlAutoCollectShader, AssetBundleGrouperSettingData.Setting.AutoCollectShaders.ToString());
+
-			shaderElement.SetAttribute(XmlShaderBundleName, AssetBundleGrouperSettingData.Setting.ShadersBundleName);
+			// 设置公共配置
+			var commonElement = xmlDoc.CreateElement(XmlCommon);
+			commonElement.SetAttribute(XmlEnableAddressable, AssetBundleCollectorSettingData.Setting.EnableAddressable.ToString());
+			commonElement.SetAttribute(XmlAutoCollectShader, AssetBundleCollectorSettingData.Setting.AutoCollectShaders.ToString());
+			commonElement.SetAttribute(XmlShaderBundleName, AssetBundleCollectorSettingData.Setting.ShadersBundleName);
+			root.AppendChild(commonElement);
 
 			// 设置分组配置
-			foreach (var grouper in AssetBundleGrouperSettingData.Setting.Groupers)
+			foreach (var group in AssetBundleCollectorSettingData.Setting.Groups)
 			{
-				var grouperElement = xmlDoc.CreateElement(XmlGrouper);
+				var groupElement = xmlDoc.CreateElement(XmlGroup);
-				grouperElement.SetAttribute(XmlGrouperName, grouper.GrouperName);
+				groupElement.SetAttribute(XmlGroupName, group.GroupName);
-				grouperElement.SetAttribute(XmlGrouperDesc, grouper.GrouperDesc);
+				groupElement.SetAttribute(XmlGroupDesc, group.GroupDesc);
-				grouperElement.SetAttribute(XmlAssetTags, grouper.AssetTags);
+				groupElement.SetAttribute(XmlAssetTags, group.AssetTags);
-				root.AppendChild(grouperElement);
+				root.AppendChild(groupElement);
 
 				// 设置收集器配置
-				foreach (var collector in grouper.Collectors)
+				foreach (var collector in group.Collectors)
 				{
 					var collectorElement = xmlDoc.CreateElement(XmlCollector);
 					collectorElement.SetAttribute(XmlCollectPath, collector.CollectPath);
@@ -154,7 +175,7 @@ namespace YooAsset.Editor
 					collectorElement.SetAttribute(XmlPackRule, collector.PackRuleName);
 					collectorElement.SetAttribute(XmlFilterRule, collector.FilterRuleName);
 					collectorElement.SetAttribute(XmlAssetTags, collector.AssetTags);
-					grouperElement.AppendChild(collectorElement);
+					groupElement.AppendChild(collectorElement);
 				}
 			}
 

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorGroup.cs

@@ -8,23 +8,28 @@ using UnityEditor;
 namespace YooAsset.Editor
 {
 	[Serializable]
-	public class AssetBundleGrouper
+	public class AssetBundleCollectorGroup
 	{
 		/// <summary>
 		/// 分组名称
 		/// </summary>
-		public string GrouperName = string.Empty;
+		public string GroupName = string.Empty;
 
 		/// <summary>
 		/// 分组描述
 		/// </summary>
-		public string GrouperDesc = string.Empty;
+		public string GroupDesc = string.Empty;
 
 		/// <summary>
 		/// 资源分类标签
 		/// </summary>
 		public string AssetTags = string.Empty;
 
+		/// <summary>
+		/// 分组激活规则
+		/// </summary>
+		public string ActiveRuleName = nameof(EnableGroup);
+
 		/// <summary>
 		/// 分组的收集器列表
 		/// </summary>
@@ -36,6 +41,9 @@ namespace YooAsset.Editor
 		/// </summary>
 		public void CheckConfigError()
 		{
+			if (AssetBundleCollectorSettingData.HasActiveRuleName(ActiveRuleName) == false)
+				throw new Exception($"Invalid {nameof(IActiveRule)} class type : {ActiveRuleName} in group : {GroupName}");
+
 			foreach (var collector in Collectors)
 			{
 				collector.CheckConfigError();
@@ -45,25 +53,32 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 获取打包收集的资源文件
 		/// </summary>
-		public List<CollectAssetInfo> GetAllCollectAssets()
+		public List<CollectAssetInfo> GetAllCollectAssets(EBuildMode buildMode)
 		{
 			Dictionary<string, CollectAssetInfo> result = new Dictionary<string, CollectAssetInfo>(10000);
 
+			// 检测分组是否激活
+			IActiveRule activeRule = AssetBundleCollectorSettingData.GetActiveRuleInstance(ActiveRuleName);
+			if (activeRule.IsActiveGroup() == false)
+			{
+				return new List<CollectAssetInfo>();
+			}
+
 			// 收集打包资源
 			foreach (var collector in Collectors)
 			{
-				var temper = collector.GetAllCollectAssets(this);
+				var temper = collector.GetAllCollectAssets(buildMode, this);
 				foreach (var assetInfo in temper)
 				{
 					if (result.ContainsKey(assetInfo.AssetPath) == false)
 						result.Add(assetInfo.AssetPath, assetInfo);
 					else
-						throw new Exception($"The collecting asset file is existed : {assetInfo.AssetPath} in grouper : {GrouperName}");
+						throw new Exception($"The collecting asset file is existed : {assetInfo.AssetPath} in group : {GroupName}");
 				}
 			}
 
 			// 检测可寻址地址是否重复
-			if (AssetBundleGrouperSettingData.Setting.EnableAddressable)
+			if (AssetBundleCollectorSettingData.Setting.EnableAddressable)
 			{
 				HashSet<string> adressTemper = new HashSet<string>();
 				foreach (var collectInfoPair in result)
@@ -74,7 +89,7 @@ namespace YooAsset.Editor
 						if (adressTemper.Contains(address) == false)
 							adressTemper.Add(address);
 						else
-							throw new Exception($"The address is existed : {address} in grouper : {GrouperName}");
+							throw new Exception($"The address is existed : {address} in group : {GroupName}");
 					}
 				}
 			}

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorSetting.cs

@@ -6,7 +6,7 @@ using UnityEngine;
 
 namespace YooAsset.Editor
 {
-	public class AssetBundleGrouperSetting : ScriptableObject
+	public class AssetBundleCollectorSetting : ScriptableObject
 	{
 		/// <summary>
 		/// 是否启用可寻址资源定位
@@ -26,7 +26,7 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 分组列表
 		/// </summary>
-		public List<AssetBundleGrouper> Groupers = new List<AssetBundleGrouper>();
+		public List<AssetBundleCollectorGroup> Groups = new List<AssetBundleCollectorGroup>();
 
 
 		/// <summary>
@@ -34,29 +34,29 @@ namespace YooAsset.Editor
 		/// </summary>
 		public void CheckConfigError()
 		{
-			foreach (var grouper in Groupers)
+			foreach (var group in Groups)
 			{
-				grouper.CheckConfigError();
+				group.CheckConfigError();
 			}
 		}
 
 		/// <summary>
 		/// 获取打包收集的资源文件
 		/// </summary>
-		public List<CollectAssetInfo> GetAllCollectAssets()
+		public List<CollectAssetInfo> GetAllCollectAssets(EBuildMode buildMode)
 		{
 			Dictionary<string, CollectAssetInfo> result = new Dictionary<string, CollectAssetInfo>(10000);
 
 			// 收集打包资源
-			foreach (var grouper in Groupers)
+			foreach (var group in Groups)
 			{
-				var temper = grouper.GetAllCollectAssets();
+				var temper = group.GetAllCollectAssets(buildMode);
 				foreach (var assetInfo in temper)
 				{
 					if (result.ContainsKey(assetInfo.AssetPath) == false)
 						result.Add(assetInfo.AssetPath, assetInfo);
 					else
-						throw new Exception($"The collecting asset file is existed : {assetInfo.AssetPath} in grouper setting.");
+						throw new Exception($"The collecting asset file is existed : {assetInfo.AssetPath} in group setting.");
 				}
 			}
 
@@ -72,7 +72,7 @@ namespace YooAsset.Editor
 						if (adressTemper.Contains(address) == false)
 							adressTemper.Add(address);
 						else
-							throw new Exception($"The address is existed : {address} in grouper setting.");
+							throw new Exception($"The address is existed : {address} in group setting.");
 					}
 				}
 			}

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorSettingData.cs

@@ -7,8 +7,11 @@ using UnityEditor;
 
 namespace YooAsset.Editor
 {
-	public class AssetBundleGrouperSettingData
+	public class AssetBundleCollectorSettingData
 	{
+		private static readonly Dictionary<string, System.Type> _cacheActiveRuleTypes = new Dictionary<string, Type>();
+		private static readonly Dictionary<string, IActiveRule> _cacheActiveRuleInstance = new Dictionary<string, IActiveRule>();
+
 		private static readonly Dictionary<string, System.Type> _cacheAddressRuleTypes = new Dictionary<string, System.Type>();
 		private static readonly Dictionary<string, IAddressRule> _cacheAddressRuleInstance = new Dictionary<string, IAddressRule>();
 
@@ -24,8 +27,8 @@ namespace YooAsset.Editor
 		public static bool IsDirty { private set; get; } = false;
 
 
-		private static AssetBundleGrouperSetting _setting = null;
+		private static AssetBundleCollectorSetting _setting = null;
-		public static AssetBundleGrouperSetting Setting
+		public static AssetBundleCollectorSetting Setting
 		{
 			get
 			{
@@ -35,6 +38,18 @@ namespace YooAsset.Editor
 			}
 		}
 
+		public static List<string> GetActiveRuleNames()
+		{
+			if (_setting == null)
+				LoadSettingData();
+
+			List<string> names = new List<string>();
+			foreach (var pair in _cacheActiveRuleTypes)
+			{
+				names.Add(pair.Key);
+			}
+			return names;
+		}
 		public static List<string> GetAddressRuleNames()
 		{
 			if (_setting == null)
@@ -71,6 +86,15 @@ namespace YooAsset.Editor
 			}
 			return names;
 		}
+		public static bool HasActiveRuleName(string ruleName)
+		{
+			foreach (var pair in _cacheActiveRuleTypes)
+			{
+				if (pair.Key == ruleName)
+					return true;
+			}
+			return false;
+		}
 		public static bool HasAddressRuleName(string ruleName)
 		{
 			foreach (var pair in _cacheAddressRuleTypes)
@@ -105,22 +129,7 @@ namespace YooAsset.Editor
 		/// </summary>
 		private static void LoadSettingData()
 		{
-			// 加载配置文件
+			_setting = EditorHelper.LoadSettingData<AssetBundleCollectorSetting>();
-			string settingFilePath = $"{EditorTools.GetYooAssetSettingPath()}/{nameof(AssetBundleGrouperSetting)}.asset";
-			_setting = AssetDatabase.LoadAssetAtPath<AssetBundleGrouperSetting>(settingFilePath);
-			if (_setting == null)
-			{
-				Debug.LogWarning($"Create new {nameof(AssetBundleGrouperSetting)}.asset : {settingFilePath}");
-				_setting = ScriptableObject.CreateInstance<AssetBundleGrouperSetting>();
-				EditorTools.CreateFileDirectory(settingFilePath);
-				AssetDatabase.CreateAsset(Setting, settingFilePath);
-				AssetDatabase.SaveAssets();
-				AssetDatabase.Refresh();
-			}
-			else
-			{
-				Debug.Log($"Load {nameof(AssetBundleGrouperSetting)}.asset ok");
-			}
 
 			// IPackRule
 			{
@@ -135,12 +144,11 @@ namespace YooAsset.Editor
 					typeof(PackDirectory),
 					typeof(PackTopDirectory),
 					typeof(PackCollector),
-					typeof(PackGrouper),
+					typeof(PackGroup),
 					typeof(PackRawFile),
 				};
 
-				TypeCache.TypeCollection collection = TypeCache.GetTypesDerivedFrom<IPackRule>();
+				var customTypes = EditorTools.GetAssignableTypes(typeof(IPackRule));
-				var customTypes = collection.ToList();
 				types.AddRange(customTypes);
 				for (int i = 0; i < types.Count; i++)
 				{
@@ -165,8 +173,7 @@ namespace YooAsset.Editor
 					typeof(CollectSprite)
 				};
 
-				TypeCache.TypeCollection collection = TypeCache.GetTypesDerivedFrom<IFilterRule>();
+				var customTypes = EditorTools.GetAssignableTypes(typeof(IFilterRule));
-				var customTypes = collection.ToList();
 				types.AddRange(customTypes);
 				for (int i = 0; i < types.Count; i++)
 				{
@@ -187,11 +194,10 @@ namespace YooAsset.Editor
 				{
 					typeof(AddressByFileName),
 					typeof(AddressByCollectorAndFileName),
-					typeof(AddressByGrouperAndFileName)
+					typeof(AddressByGroupAndFileName)
 				};
 
-				TypeCache.TypeCollection collection = TypeCache.GetTypesDerivedFrom<IAddressRule>();
+				var customTypes = EditorTools.GetAssignableTypes(typeof(IAddressRule));
-				var customTypes = collection.ToList();
 				types.AddRange(customTypes);
 				for (int i = 0; i < types.Count; i++)
 				{
@@ -200,6 +206,29 @@ namespace YooAsset.Editor
 						_cacheAddressRuleTypes.Add(type.Name, type);
 				}
 			}
+
+			// IActiveRule
+			{
+				// 清空缓存集合
+				_cacheActiveRuleTypes.Clear();
+				_cacheActiveRuleInstance.Clear();
+
+				// 获取所有类型
+				List<Type> types = new List<Type>(100)
+				{
+					typeof(EnableGroup),
+					typeof(DisableGroup),
+				};
+
+				var customTypes = EditorTools.GetAssignableTypes(typeof(IActiveRule));
+				types.AddRange(customTypes);
+				for (int i = 0; i < types.Count; i++)
+				{
+					Type type = types[i];
+					if (_cacheActiveRuleTypes.ContainsKey(type.Name) == false)
+						_cacheActiveRuleTypes.Add(type.Name, type);
+				}
+			}
 		}
 
 		/// <summary>
@@ -212,7 +241,7 @@ namespace YooAsset.Editor
 				IsDirty = false;
 				EditorUtility.SetDirty(Setting);
 				AssetDatabase.SaveAssets();
-				Debug.Log($"{nameof(AssetBundleGrouperSetting)}.asset is saved!");
+				Debug.Log($"{nameof(AssetBundleCollectorSetting)}.asset is saved!");
 			}
 		}
 
@@ -223,11 +252,28 @@ namespace YooAsset.Editor
 		{
 			Setting.AutoCollectShaders = false;
 			Setting.ShadersBundleName = string.Empty;
-			Setting.Groupers.Clear();
+			Setting.Groups.Clear();
 			SaveFile();
 		}
 
 		// 实例类相关
+		public static IActiveRule GetActiveRuleInstance(string ruleName)
+		{
+			if (_cacheActiveRuleInstance.TryGetValue(ruleName, out IActiveRule instance))
+				return instance;
+
+			// 如果不存在创建类的实例
+			if (_cacheActiveRuleTypes.TryGetValue(ruleName, out Type type))
+			{
+				instance = (IActiveRule)Activator.CreateInstance(type);
+				_cacheActiveRuleInstance.Add(ruleName, instance);
+				return instance;
+			}
+			else
+			{
+				throw new Exception($"{nameof(IActiveRule)}类型无效：{ruleName}");
+			}
+		}
 		public static IAddressRule GetAddressRuleInstance(string ruleName)
 		{
 			if (_cacheAddressRuleInstance.TryGetValue(ruleName, out IAddressRule instance))
@@ -296,43 +342,43 @@ namespace YooAsset.Editor
 		}
 
 		// 资源分组编辑相关
-		public static void CreateGrouper(string grouperName)
+		public static void CreateGroup(string groupName)
 		{
-			AssetBundleGrouper grouper = new AssetBundleGrouper();
+			AssetBundleCollectorGroup group = new AssetBundleCollectorGroup();
-			grouper.GrouperName = grouperName;
+			group.GroupName = groupName;
-			Setting.Groupers.Add(grouper);
+			Setting.Groups.Add(group);
 			IsDirty = true;
 		}
-		public static void RemoveGrouper(AssetBundleGrouper grouper)
+		public static void RemoveGroup(AssetBundleCollectorGroup group)
 		{
-			if (Setting.Groupers.Remove(grouper))
+			if (Setting.Groups.Remove(group))
 			{
 				IsDirty = true;
 			}
 			else
 			{
-				Debug.LogWarning($"Failed remove grouper : {grouper.GrouperName}");
+				Debug.LogWarning($"Failed remove group : {group.GroupName}");
 			}
 		}
-		public static void ModifyGrouper(AssetBundleGrouper grouper)
+		public static void ModifyGroup(AssetBundleCollectorGroup group)
 		{
-			if (grouper != null)
+			if (group != null)
 			{
 				IsDirty = true;
 			}
 		}
 
 		// 资源收集器编辑相关
-		public static void CreateCollector(AssetBundleGrouper grouper, string collectPath)
+		public static void CreateCollector(AssetBundleCollectorGroup group, string collectPath)
 		{
 			AssetBundleCollector collector = new AssetBundleCollector();
 			collector.CollectPath = collectPath;
-			grouper.Collectors.Add(collector);
+			group.Collectors.Add(collector);
 			IsDirty = true;
 		}
-		public static void RemoveCollector(AssetBundleGrouper grouper, AssetBundleCollector collector)
+		public static void RemoveCollector(AssetBundleCollectorGroup group, AssetBundleCollector collector)
 		{
-			if (grouper.Collectors.Remove(collector))
+			if (group.Collectors.Remove(collector))
 			{
 				IsDirty = true;
 			}
@@ -341,9 +387,9 @@ namespace YooAsset.Editor
 				Debug.LogWarning($"Failed remove collector : {collector.CollectPath}");
 			}
 		}
-		public static void ModifyCollector(AssetBundleGrouper grouper, AssetBundleCollector collector)
+		public static void ModifyCollector(AssetBundleCollectorGroup group, AssetBundleCollector collector)
 		{
-			if (grouper != null && collector != null)
+			if (group != null && collector != null)
 			{
 				IsDirty = true;
 			}

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorWindow.cs

@@ -9,138 +9,145 @@ using UnityEngine.UIElements;
 
 namespace YooAsset.Editor
 {
-	public class AssetBundleGrouperWindow : EditorWindow
+	public class AssetBundleCollectorWindow : EditorWindow
 	{
-		[MenuItem("YooAsset/AssetBundle Grouper", false, 101)]
+		[MenuItem("YooAsset/AssetBundle Collector", false, 101)]
 		public static void ShowExample()
 		{
-			AssetBundleGrouperWindow window = GetWindow<AssetBundleGrouperWindow>("资源包分组工具", true, EditorDefine.DockedWindowTypes);
+			AssetBundleCollectorWindow window = GetWindow<AssetBundleCollectorWindow>("资源包收集工具", true, EditorDefine.DockedWindowTypes);
 			window.minSize = new Vector2(800, 600);
 		}
 
+		private Button _saveButton;
 		private List<string> _collectorTypeList;
+		private List<string> _activeRuleList;
 		private List<string> _addressRuleList;
 		private List<string> _packRuleList;
 		private List<string> _filterRuleList;
-		private ListView _grouperListView;
+		private ListView _groupListView;
 		private ScrollView _collectorScrollView;
+		private PopupField<string> _activeRulePopupField;
 		private Toggle _enableAddressableToogle;
 		private Toggle _autoCollectShaderToogle;
 		private TextField _shaderBundleNameTxt;
-		private TextField _grouperNameTxt;
+		private TextField _groupNameTxt;
-		private TextField _grouperDescTxt;
+		private TextField _groupDescTxt;
-		private TextField _grouperAssetTagsTxt;
+		private TextField _groupAssetTagsTxt;
-		private VisualElement _grouperContainer;
+		private VisualElement _groupContainer;
+		private string _lastModifyGroup = string.Empty;
+
 
 		public void CreateGUI()
 		{
 			Undo.undoRedoPerformed -= RefreshWindow;
 			Undo.undoRedoPerformed += RefreshWindow;
 
-			VisualElement root = this.rootVisualElement;
-
-			_collectorTypeList = new List<string>()
-			{
-				$"{nameof(ECollectorType.MainAssetCollector)}",
-				$"{nameof(ECollectorType.StaticAssetCollector)}",
-				$"{nameof(ECollectorType.DependAssetCollector)}"
-			};
-			_addressRuleList = AssetBundleGrouperSettingData.GetAddressRuleNames();
-			_packRuleList = AssetBundleGrouperSettingData.GetPackRuleNames();
-			_filterRuleList = AssetBundleGrouperSettingData.GetFilterRuleNames();
-
-			// 加载布局文件
-			string rootPath = EditorTools.GetYooAssetSourcePath();
-			string uxml = $"{rootPath}/Editor/AssetBundleGrouper/{nameof(AssetBundleGrouperWindow)}.uxml";
-			var visualAsset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxml);
-			if (visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(AssetBundleGrouperWindow)}.uxml : {uxml}");
-				return;
-			}
-			visualAsset.CloneTree(root);
-
 			try
 			{
+				_collectorTypeList = new List<string>()
+				{
+					$"{nameof(ECollectorType.MainAssetCollector)}",
+					$"{nameof(ECollectorType.StaticAssetCollector)}",
+					$"{nameof(ECollectorType.DependAssetCollector)}"
+				};
+				_activeRuleList = AssetBundleCollectorSettingData.GetActiveRuleNames();
+				_addressRuleList = AssetBundleCollectorSettingData.GetAddressRuleNames();
+				_packRuleList = AssetBundleCollectorSettingData.GetPackRuleNames();
+				_filterRuleList = AssetBundleCollectorSettingData.GetFilterRuleNames();
+
+				VisualElement root = this.rootVisualElement;
+
+				// 加载布局文件
+				var visualAsset = EditorHelper.LoadWindowUXML<AssetBundleCollectorWindow>();
+				if (visualAsset == null)
+					return;
+
+				visualAsset.CloneTree(root);
+
 				// 导入导出按钮
 				var exportBtn = root.Q<Button>("ExportButton");
 				exportBtn.clicked += ExportBtn_clicked;
 				var importBtn = root.Q<Button>("ImportButton");
 				importBtn.clicked += ImportBtn_clicked;
 
+				// 配置保存按钮
+				_saveButton = root.Q<Button>("SaveButton");
+				_saveButton.clicked += SaveBtn_clicked;
+
 				// 公共设置相关
 				_enableAddressableToogle = root.Q<Toggle>("EnableAddressable");
 				_enableAddressableToogle.RegisterValueChangedCallback(evt =>
 				{
-					AssetBundleGrouperSettingData.ModifyAddressable(evt.newValue);
+					AssetBundleCollectorSettingData.ModifyAddressable(evt.newValue);
+					RefreshWindow();
 				});
 				_autoCollectShaderToogle = root.Q<Toggle>("AutoCollectShader");
 				_autoCollectShaderToogle.RegisterValueChangedCallback(evt =>
 				{
-					AssetBundleGrouperSettingData.ModifyShader(evt.newValue, _shaderBundleNameTxt.value);
+					AssetBundleCollectorSettingData.ModifyShader(evt.newValue, _shaderBundleNameTxt.value);
 					_shaderBundleNameTxt.SetEnabled(evt.newValue);
 				});
 				_shaderBundleNameTxt = root.Q<TextField>("ShaderBundleName");
 				_shaderBundleNameTxt.RegisterValueChangedCallback(evt =>
 				{
-					AssetBundleGrouperSettingData.ModifyShader(_autoCollectShaderToogle.value, evt.newValue);
+					AssetBundleCollectorSettingData.ModifyShader(_autoCollectShaderToogle.value, evt.newValue);
 				});
 
 				// 分组列表相关
-				_grouperListView = root.Q<ListView>("GrouperListView");
+				_groupListView = root.Q<ListView>("GroupListView");
-				_grouperListView.makeItem = MakeGrouperListViewItem;
+				_groupListView.makeItem = MakeGroupListViewItem;
-				_grouperListView.bindItem = BindGrouperListViewItem;
+				_groupListView.bindItem = BindGroupListViewItem;
 #if UNITY_2020_1_OR_NEWER
-				_grouperListView.onSelectionChange += GrouperListView_onSelectionChange;
+				_groupListView.onSelectionChange += GroupListView_onSelectionChange;
 #else
-				_grouperListView.onSelectionChanged += GrouperListView_onSelectionChange;
+				_groupListView.onSelectionChanged += GroupListView_onSelectionChange;
 #endif
 
 				// 分组添加删除按钮
-				var grouperAddContainer = root.Q("GrouperAddContainer");
+				var groupAddContainer = root.Q("GroupAddContainer");
 				{
-					var addBtn = grouperAddContainer.Q<Button>("AddBtn");
+					var addBtn = groupAddContainer.Q<Button>("AddBtn");
-					addBtn.clicked += AddGrouperBtn_clicked;
+					addBtn.clicked += AddGroupBtn_clicked;
-					var removeBtn = grouperAddContainer.Q<Button>("RemoveBtn");
+					var removeBtn = groupAddContainer.Q<Button>("RemoveBtn");
-					removeBtn.clicked += RemoveGrouperBtn_clicked;
+					removeBtn.clicked += RemoveGroupBtn_clicked;
 				}
 
 				// 分组容器
-				_grouperContainer = root.Q("GrouperContainer");
+				_groupContainer = root.Q("GroupContainer");
 
 				// 分组名称
-				_grouperNameTxt = root.Q<TextField>("GrouperName");
+				_groupNameTxt = root.Q<TextField>("GroupName");
-				_grouperNameTxt.RegisterValueChangedCallback(evt =>
+				_groupNameTxt.RegisterValueChangedCallback(evt =>
 				{
-					var selectGrouper = _grouperListView.selectedItem as AssetBundleGrouper;
+					var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-					if (selectGrouper != null)
+					if (selectGroup != null)
 					{
-						selectGrouper.GrouperName = evt.newValue;
+						selectGroup.GroupName = evt.newValue;
-						AssetBundleGrouperSettingData.ModifyGrouper(selectGrouper);
+						AssetBundleCollectorSettingData.ModifyGroup(selectGroup);
 					}
 				});
 
 				// 分组备注
-				_grouperDescTxt = root.Q<TextField>("GrouperDesc");
+				_groupDescTxt = root.Q<TextField>("GroupDesc");
-				_grouperDescTxt.RegisterValueChangedCallback(evt =>
+				_groupDescTxt.RegisterValueChangedCallback(evt =>
 				{
-					var selectGrouper = _grouperListView.selectedItem as AssetBundleGrouper;
+					var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-					if (selectGrouper != null)
+					if (selectGroup != null)
 					{
-						selectGrouper.GrouperDesc = evt.newValue;
+						selectGroup.GroupDesc = evt.newValue;
-						AssetBundleGrouperSettingData.ModifyGrouper(selectGrouper);
+						AssetBundleCollectorSettingData.ModifyGroup(selectGroup);
 					}
 				});
 
 				// 分组的资源标签
-				_grouperAssetTagsTxt = root.Q<TextField>("GrouperAssetTags");
+				_groupAssetTagsTxt = root.Q<TextField>("GroupAssetTags");
-				_grouperAssetTagsTxt.RegisterValueChangedCallback(evt =>
+				_groupAssetTagsTxt.RegisterValueChangedCallback(evt =>
 				{
-					var selectGrouper = _grouperListView.selectedItem as AssetBundleGrouper;
+					var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-					if (selectGrouper != null)
+					if (selectGroup != null)
 					{
-						selectGrouper.AssetTags = evt.newValue;
+						selectGroup.AssetTags = evt.newValue;
-						AssetBundleGrouperSettingData.ModifyGrouper(selectGrouper);
+						AssetBundleCollectorSettingData.ModifyGroup(selectGroup);
 					}
 				});
 
@@ -156,6 +163,25 @@ namespace YooAsset.Editor
 					addBtn.clicked += AddCollectorBtn_clicked;
 				}
 
+				// 分组激活规则
+				var activeRuleContainer = root.Q("ActiveRuleContainer");
+				{
+					_activeRulePopupField = new PopupField<string>("Active Rule", _activeRuleList, 0);
+					_activeRulePopupField.name = "ActiveRuleMaskField";
+					_activeRulePopupField.style.unityTextAlign = TextAnchor.MiddleLeft;
+					activeRuleContainer.Add(_activeRulePopupField);
+					_activeRulePopupField.RegisterValueChangedCallback(evt =>
+					{
+						var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
+						if (selectGroup != null)
+						{
+							selectGroup.ActiveRuleName = evt.newValue;
+							AssetBundleCollectorSettingData.ModifyGroup(selectGroup);
+							FillGroupViewData();
+						}
+					});
+				}
+
 				// 刷新窗体
 				RefreshWindow();
 			}
@@ -166,26 +192,45 @@ namespace YooAsset.Editor
 		}
 		public void OnDestroy()
 		{
-			if (AssetBundleGrouperSettingData.IsDirty)
+			// 注意：清空所有撤销操作
-				AssetBundleGrouperSettingData.SaveFile();
+			Undo.ClearAll();
+
+			if (AssetBundleCollectorSettingData.IsDirty)
+				AssetBundleCollectorSettingData.SaveFile();
+		}
+		public void Update()
+		{
+			if (_saveButton != null)
+			{
+				if (AssetBundleCollectorSettingData.IsDirty)
+				{
+					if (_saveButton.enabledSelf == false)
+						_saveButton.SetEnabled(true);
+				}
+				else
+				{
+					if (_saveButton.enabledSelf)
+						_saveButton.SetEnabled(false);
+				}
+			}
 		}
 
 		private void RefreshWindow()
 		{
-			_enableAddressableToogle.SetValueWithoutNotify(AssetBundleGrouperSettingData.Setting.EnableAddressable);
+			_enableAddressableToogle.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.EnableAddressable);
-			_autoCollectShaderToogle.SetValueWithoutNotify(AssetBundleGrouperSettingData.Setting.AutoCollectShaders);
+			_autoCollectShaderToogle.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.AutoCollectShaders);
-			_shaderBundleNameTxt.SetEnabled(AssetBundleGrouperSettingData.Setting.AutoCollectShaders);
+			_shaderBundleNameTxt.SetEnabled(AssetBundleCollectorSettingData.Setting.AutoCollectShaders);
-			_shaderBundleNameTxt.SetValueWithoutNotify(AssetBundleGrouperSettingData.Setting.ShadersBundleName);
+			_shaderBundleNameTxt.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.ShadersBundleName);
-			_grouperContainer.visible = false;
+			_groupContainer.visible = false;
 
-			FillGrouperViewData();
+			FillGroupViewData();
 		}
 		private void ExportBtn_clicked()
 		{
 			string resultPath = EditorTools.OpenFolderPanel("Export XML", "Assets/");
 			if (resultPath != null)
 			{
-				AssetBundleGrouperConfig.ExportXmlConfig($"{resultPath}/{nameof(AssetBundleGrouperConfig)}.xml");
+				AssetBundleCollectorConfig.ExportXmlConfig($"{resultPath}/{nameof(AssetBundleCollectorConfig)}.xml");
 			}
 		}
 		private void ImportBtn_clicked()
@@ -193,20 +238,34 @@ namespace YooAsset.Editor
 			string resultPath = EditorTools.OpenFilePath("Import XML", "Assets/", "xml");
 			if (resultPath != null)
 			{
-				AssetBundleGrouperConfig.ImportXmlConfig(resultPath);
+				AssetBundleCollectorConfig.ImportXmlConfig(resultPath);
 				RefreshWindow();
 			}
 		}
+		private void SaveBtn_clicked()
+		{
+			AssetBundleCollectorSettingData.SaveFile();
+		}
 
 		// 分组列表相关
-		private void FillGrouperViewData()
+		private void FillGroupViewData()
 		{
-			_grouperListView.Clear();
+			_groupListView.Clear();
-			_grouperListView.ClearSelection();
+			_groupListView.ClearSelection();
-			_grouperListView.itemsSource = AssetBundleGrouperSettingData.Setting.Groupers;
+			_groupListView.itemsSource = AssetBundleCollectorSettingData.Setting.Groups;
-			_grouperListView.Rebuild();
+			_groupListView.Rebuild();
+
+			for (int index = 0; index < AssetBundleCollectorSettingData.Setting.Groups.Count; index++)
+			{
+				var group = AssetBundleCollectorSettingData.Setting.Groups[index];
+				if (group.GroupName == _lastModifyGroup)
+				{
+					_groupListView.selectedIndex = index;
+					break;
+				}
+			}
 		}
-		private VisualElement MakeGrouperListViewItem()
+		private VisualElement MakeGroupListViewItem()
 		{
 			VisualElement element = new VisualElement();
 
@@ -221,57 +280,63 @@ namespace YooAsset.Editor
 
 			return element;
 		}
-		private void BindGrouperListViewItem(VisualElement element, int index)
+		private void BindGroupListViewItem(VisualElement element, int index)
 		{
-			var grouper = AssetBundleGrouperSettingData.Setting.Groupers[index];
+			var group = AssetBundleCollectorSettingData.Setting.Groups[index];
 
-			// Grouper Name
+			// Group Name
 			var textField1 = element.Q<Label>("Label1");
-			if (string.IsNullOrEmpty(grouper.GrouperDesc))
+			if (string.IsNullOrEmpty(group.GroupDesc))
-				textField1.text = grouper.GrouperName;
+				textField1.text = group.GroupName;
 			else
-				textField1.text = $"{grouper.GrouperName} ({grouper.GrouperDesc})";
+				textField1.text = $"{group.GroupName} ({group.GroupDesc})";
+
+			// 激活状态
+			IActiveRule activeRule = AssetBundleCollectorSettingData.GetActiveRuleInstance(group.ActiveRuleName);
+			bool isActive = activeRule.IsActiveGroup();
+			textField1.SetEnabled(isActive);
 		}
-		private void GrouperListView_onSelectionChange(IEnumerable<object> objs)
+		private void GroupListView_onSelectionChange(IEnumerable<object> objs)
 		{
 			FillCollectorViewData();
 		}
-		private void AddGrouperBtn_clicked()
+		private void AddGroupBtn_clicked()
 		{
-			Undo.RecordObject(AssetBundleGrouperSettingData.Setting, "YooAsset AddGrouper");
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow AddGroup");
-			AssetBundleGrouperSettingData.CreateGrouper("Default Grouper");
+			AssetBundleCollectorSettingData.CreateGroup("Default Group");
-			FillGrouperViewData();
+			FillGroupViewData();
 		}
-		private void RemoveGrouperBtn_clicked()
+		private void RemoveGroupBtn_clicked()
 		{
-			var selectGrouper = _grouperListView.selectedItem as AssetBundleGrouper;
+			var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-			if (selectGrouper == null)
+			if (selectGroup == null)
 				return;
 
-			Undo.RecordObject(AssetBundleGrouperSettingData.Setting, "YooAsset RemoveGrouper");
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow RemoveGroup");
-
+			AssetBundleCollectorSettingData.RemoveGroup(selectGroup);
-			AssetBundleGrouperSettingData.RemoveGrouper(selectGrouper);
+			FillGroupViewData();
-			FillGrouperViewData();
 		}
 
 		// 收集列表相关
 		private void FillCollectorViewData()
 		{
-			var selectGrouper = _grouperListView.selectedItem as AssetBundleGrouper;
+			var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-			if (selectGrouper == null)
+			if (selectGroup == null)
 			{
-				_grouperContainer.visible = false;
+				_groupContainer.visible = false;
 				return;
 			}
 
-			_grouperContainer.visible = true;
+			_lastModifyGroup = selectGroup.GroupName;
-			_grouperNameTxt.SetValueWithoutNotify(selectGrouper.GrouperName);
+			_groupContainer.visible = true;
-			_grouperDescTxt.SetValueWithoutNotify(selectGrouper.GrouperDesc);
+			_activeRulePopupField.SetValueWithoutNotify(selectGroup.ActiveRuleName);
-			_grouperAssetTagsTxt.SetValueWithoutNotify(selectGrouper.AssetTags);
+			_groupNameTxt.SetValueWithoutNotify(selectGroup.GroupName);
+			_groupDescTxt.SetValueWithoutNotify(selectGroup.GroupDesc);
+			_groupAssetTagsTxt.SetValueWithoutNotify(selectGroup.AssetTags);
 
 			// 填充数据
 			_collectorScrollView.Clear();
-			for (int i = 0; i < selectGrouper.Collectors.Count; i++)
+			for (int i = 0; i < selectGroup.Collectors.Count; i++)
 			{
 				VisualElement element = MakeCollectorListViewItem();
 				BindCollectorListViewItem(element, i);
@@ -391,18 +456,24 @@ namespace YooAsset.Editor
 		}
 		private void BindCollectorListViewItem(VisualElement element, int index)
 		{
-			var selectGrouper = _grouperListView.selectedItem as AssetBundleGrouper;
+			var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-			if (selectGrouper == null)
+			if (selectGroup == null)
 				return;
 
-			var collector = selectGrouper.Collectors[index];
+			var collector = selectGroup.Collectors[index];
 			var collectObject = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(collector.CollectPath);
 			if (collectObject != null)
 				collectObject.name = collector.CollectPath;
 
 			// Foldout
 			var foldout = element.Q<Foldout>("Foldout1");
-			RefreshFoldout(foldout, selectGrouper, collector);
+			foldout.RegisterValueChangedCallback(evt =>
+			{
+				if (evt.newValue)
+					RefreshFoldout(foldout, selectGroup, collector);
+				else
+					foldout.Clear();
+			});
 
 			// Remove Button
 			var removeBtn = element.Q<Button>("Button1");
@@ -418,8 +489,11 @@ namespace YooAsset.Editor
 			{
 				collector.CollectPath = AssetDatabase.GetAssetPath(evt.newValue);
 				objectField1.value.name = collector.CollectPath;
-				AssetBundleGrouperSettingData.ModifyCollector(selectGrouper, collector);
+				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
-				RefreshFoldout(foldout, selectGrouper, collector);
+				if (foldout.value)
+				{
+					RefreshFoldout(foldout, selectGroup, collector);
+				}
 			});
 
 			// Collector Type
@@ -428,8 +502,11 @@ namespace YooAsset.Editor
 			popupField0.RegisterValueChangedCallback(evt =>
 			{
 				collector.CollectorType = StringUtility.NameToEnum<ECollectorType>(evt.newValue);
-				AssetBundleGrouperSettingData.ModifyCollector(selectGrouper, collector);
+				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
-				RefreshFoldout(foldout, selectGrouper, collector);
+				if (foldout.value)
+				{
+					RefreshFoldout(foldout, selectGroup, collector);
+				}
 			});
 
 			// Address Rule
@@ -440,8 +517,11 @@ namespace YooAsset.Editor
 				popupField1.RegisterValueChangedCallback(evt =>
 				{
 					collector.AddressRuleName = evt.newValue;
-					AssetBundleGrouperSettingData.ModifyCollector(selectGrouper, collector);
+					AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
-					RefreshFoldout(foldout, selectGrouper, collector);
+					if (foldout.value)
+					{
+						RefreshFoldout(foldout, selectGroup, collector);
+					}
 				});
 			}
 
@@ -451,8 +531,11 @@ namespace YooAsset.Editor
 			popupField2.RegisterValueChangedCallback(evt =>
 			{
 				collector.PackRuleName = evt.newValue;
-				AssetBundleGrouperSettingData.ModifyCollector(selectGrouper, collector);
+				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
-				RefreshFoldout(foldout, selectGrouper, collector);
+				if (foldout.value)
+				{
+					RefreshFoldout(foldout, selectGroup, collector);
+				}
 			});
 
 			// Filter Rule
@@ -461,8 +544,11 @@ namespace YooAsset.Editor
 			popupField3.RegisterValueChangedCallback(evt =>
 			{
 				collector.FilterRuleName = evt.newValue;
-				AssetBundleGrouperSettingData.ModifyCollector(selectGrouper, collector);
+				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
-				RefreshFoldout(foldout, selectGrouper, collector);
+				if (foldout.value)
+				{
+					RefreshFoldout(foldout, selectGroup, collector);
+				}
 			});
 
 			// Tags
@@ -471,17 +557,17 @@ namespace YooAsset.Editor
 			textFiled1.RegisterValueChangedCallback(evt =>
 			{
 				collector.AssetTags = evt.newValue;
-				AssetBundleGrouperSettingData.ModifyCollector(selectGrouper, collector);
+				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
 			});
 		}
-		private void RefreshFoldout(Foldout foldout, AssetBundleGrouper grouper, AssetBundleCollector collector)
+		private void RefreshFoldout(Foldout foldout, AssetBundleCollectorGroup group, AssetBundleCollector collector)
 		{
 			// 清空旧元素
 			foldout.Clear();
 
 			if (collector.IsValid() == false)
 			{
-				Debug.LogWarning($"The collector is invalid : {collector.CollectPath} in grouper : {grouper.GrouperName}");
+				Debug.LogWarning($"The collector is invalid : {collector.CollectPath} in group : {group.GroupName}");
 				return;
 			}
 
@@ -491,7 +577,7 @@ namespace YooAsset.Editor
 
 				try
 				{
-					collectAssetInfos = collector.GetAllCollectAssets(grouper);
+					collectAssetInfos = collector.GetAllCollectAssets(EBuildMode.DryRunBuild, group);
 				}
 				catch (System.Exception e)
 				{
@@ -509,8 +595,8 @@ namespace YooAsset.Editor
 						string showInfo = collectAssetInfo.AssetPath;
 						if (_enableAddressableToogle.value)
 						{
-							IAddressRule instance = AssetBundleGrouperSettingData.GetAddressRuleInstance(collector.AddressRuleName);
+							IAddressRule instance = AssetBundleCollectorSettingData.GetAddressRuleInstance(collector.AddressRuleName);
-							AddressRuleData ruleData = new AddressRuleData(collectAssetInfo.AssetPath, collector.CollectPath, grouper.GrouperName);
+							AddressRuleData ruleData = new AddressRuleData(collectAssetInfo.AssetPath, collector.CollectPath, group.GroupName);
 							string addressValue = instance.GetAssetAddress(ruleData);
 							showInfo = $"[{addressValue}] {showInfo}";
 						}
@@ -527,21 +613,24 @@ namespace YooAsset.Editor
 		}
 		private void AddCollectorBtn_clicked()
 		{
-			var selectGrouper = _grouperListView.selectedItem as AssetBundleGrouper;
+			var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-			if (selectGrouper == null)
+			if (selectGroup == null)
 				return;
 
-			AssetBundleGrouperSettingData.CreateCollector(selectGrouper, string.Empty);
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow AddCollector");
+			AssetBundleCollectorSettingData.CreateCollector(selectGroup, string.Empty);
 			FillCollectorViewData();
 		}
 		private void RemoveCollectorBtn_clicked(AssetBundleCollector selectCollector)
 		{
-			var selectGrouper = _grouperListView.selectedItem as AssetBundleGrouper;
+			var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-			if (selectGrouper == null)
+			if (selectGroup == null)
 				return;
 			if (selectCollector == null)
 				return;
-			AssetBundleGrouperSettingData.RemoveCollector(selectGrouper, selectCollector);
+
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow RemoveCollector");
+			AssetBundleCollectorSettingData.RemoveCollector(selectGroup, selectCollector);
 			FillCollectorViewData();
 		}
 

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorWindow.uxml

@@ -1,12 +1,13 @@
 <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
     <uie:Toolbar name="Toolbar" style="display: flex; flex-direction: row-reverse;">
+        <ui:Button text="Save" display-tooltip-when-elided="true" name="SaveButton" style="width: 50px; background-color: rgb(56, 147, 58);" />
         <ui:Button text="导出" display-tooltip-when-elided="true" name="ExportButton" style="width: 50px; background-color: rgb(56, 147, 58);" />
         <ui:Button text="导入" display-tooltip-when-elided="true" name="ImportButton" style="width: 50px; background-color: rgb(56, 147, 58);" />
     </uie:Toolbar>
     <ui:VisualElement name="ContentContainer" style="flex-grow: 1; flex-direction: row;">
         <ui:VisualElement name="LeftContainer" style="width: 200px; flex-grow: 0; background-color: rgb(67, 67, 67); border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px;">
-            <ui:ListView focusable="true" name="GrouperListView" item-height="20" virtualization-method="DynamicHeight" style="flex-grow: 1;" />
+            <ui:ListView focusable="true" name="GroupListView" item-height="20" virtualization-method="DynamicHeight" style="flex-grow: 1;" />
-            <ui:VisualElement name="GrouperAddContainer" style="height: 20px; flex-direction: row; justify-content: center;">
+            <ui:VisualElement name="GroupAddContainer" style="height: 20px; flex-direction: row; justify-content: center;">
                 <ui:Button text=" - " display-tooltip-when-elided="true" name="RemoveBtn" />
                 <ui:Button text=" + " display-tooltip-when-elided="true" name="AddBtn" />
             </ui:VisualElement>
@@ -17,10 +18,11 @@
                 <ui:Toggle label="Auto Collect Shaders" name="AutoCollectShader" style="width: 196px; -unity-text-align: middle-left;" />
                 <ui:TextField picking-mode="Ignore" label="Shader Bundle Name" name="ShaderBundleName" style="flex-grow: 1; -unity-text-align: middle-left;" />
             </ui:VisualElement>
-            <ui:VisualElement name="GrouperContainer" style="flex-grow: 1; border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px;">
+            <ui:VisualElement name="GroupContainer" style="flex-grow: 1; border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px;">
-                <ui:TextField picking-mode="Ignore" label="Grouper Name" name="GrouperName" />
+                <ui:VisualElement name="ActiveRuleContainer" style="height: 20px;" />
-                <ui:TextField picking-mode="Ignore" label="Grouper Desc" name="GrouperDesc" />
+                <ui:TextField picking-mode="Ignore" label="Group Name" name="GroupName" />
-                <ui:TextField picking-mode="Ignore" label="Grouper Asset Tags" name="GrouperAssetTags" />
+                <ui:TextField picking-mode="Ignore" label="Group Desc" name="GroupDesc" />
+                <ui:TextField picking-mode="Ignore" label="Group Asset Tags" name="GroupAssetTags" />
                 <ui:VisualElement name="CollectorAddContainer" style="height: 20px; flex-direction: row-reverse;">
                     <ui:Button text="[ + ]" display-tooltip-when-elided="true" name="AddBtn" />
                 </ui:VisualElement>

Assets/YooAsset/Editor/AssetBundleCollector/DefaultActiveRule.cs

@@ -0,0 +1,25 @@
+
+namespace YooAsset.Editor
+{
+	/// <summary>
+	/// 启用分组
+	/// </summary>
+	public class EnableGroup : IActiveRule
+	{
+		public bool IsActiveGroup()
+		{
+			return true;
+		}
+	}
+
+	/// <summary>
+	/// 禁用分组
+	/// </summary>
+	public class DisableGroup : IActiveRule
+	{
+		public bool IsActiveGroup()
+		{
+			return false;
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleCollector/DefaultActiveRule.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2cfd65b3b7663b247b2df16077f4ef17
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleCollector/DefaultAddressRule.cs

@@ -16,12 +16,12 @@ namespace YooAsset.Editor
 	/// <summary>
 	/// 以组名+文件名为定位地址
 	/// </summary>
-	public class AddressByGrouperAndFileName : IAddressRule
+	public class AddressByGroupAndFileName : IAddressRule
 	{
 		string IAddressRule.GetAssetAddress(AddressRuleData data)
 		{
 			string fileName = Path.GetFileNameWithoutExtension(data.AssetPath);
-			return $"{data.GrouperName}_{fileName}";
+			return $"{data.GroupName}_{fileName}";
 		}
 	}
 

Assets/YooAsset/Editor/AssetBundleCollector/DefaultFilterRule.cs

@@ -44,10 +44,19 @@ namespace YooAsset.Editor
 	{
 		public bool IsCollectAsset(FilterRuleData data)
 		{
-			if (AssetDatabase.GetMainAssetTypeAtPath(data.AssetPath) == typeof(Sprite))
+			var mainAssetType = AssetDatabase.GetMainAssetTypeAtPath(data.AssetPath);
-				return true;
+			if(mainAssetType == typeof(Texture2D))
+			{
+				var texImporter = AssetImporter.GetAtPath(data.AssetPath) as TextureImporter;
+				if (texImporter != null && texImporter.textureType == TextureImporterType.Sprite)
+					return true;
+				else
+					return false;
+			}
 			else
+			{
 				return false;
+			}
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleCollector/DefaultPackRule.cs

@@ -28,6 +28,8 @@ namespace YooAsset.Editor
 	/// </summary>
 	public class PackDirectory : IPackRule
 	{
+		public static PackDirectory StaticPackRule = new PackDirectory();
+
 		string IPackRule.GetBundleName(PackRuleData data)
 		{
 			return Path.GetDirectoryName(data.AssetPath);
@@ -78,11 +80,11 @@ namespace YooAsset.Editor
 	/// 以分组名称作为资源包名
 	/// 注意：收集的所有文件打进一个资源包
 	/// </summary>
-	public class PackGrouper : IPackRule
+	public class PackGroup : IPackRule
 	{
 		string IPackRule.GetBundleName(PackRuleData data)
 		{
-			return data.GrouperName;
+			return data.GroupName;
 		}
 	}
 

Assets/YooAsset/Editor/AssetBundleCollector/IActiveRule.cs

@@ -0,0 +1,14 @@
+
+namespace YooAsset.Editor
+{
+	/// <summary>
+	/// 资源分组激活规则接口
+	/// </summary>
+	public interface IActiveRule
+	{
+		/// <summary>
+		/// 是否激活分组
+		/// </summary>
+		bool IsActiveGroup();
+	}
+}

Assets/YooAsset/Editor/AssetBundleCollector/IActiveRule.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aed5a1a6733b7d44ca4f6149ed5a2bb8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleCollector/IAddressRule.cs

@@ -5,13 +5,13 @@ namespace YooAsset.Editor
 	{
 		public string AssetPath;
 		public string CollectPath;
-		public string GrouperName;
+		public string GroupName;
 
-		public AddressRuleData(string assetPath, string collectPath, string grouperName)
+		public AddressRuleData(string assetPath, string collectPath, string groupName)
 		{
 			AssetPath = assetPath;
 			CollectPath = collectPath;
-			GrouperName = grouperName;
+			GroupName = groupName;
 		}
 	}
 

Assets/YooAsset/Editor/AssetBundleCollector/IPackRule.cs

@@ -5,19 +5,19 @@ namespace YooAsset.Editor
 	{
 		public string AssetPath;		
 		public string CollectPath;
-		public string GrouperName;
+		public string GroupName;
 
 		public PackRuleData(string assetPath)
 		{
 			AssetPath = assetPath;
 			CollectPath = string.Empty;
-			GrouperName = string.Empty;
+			GroupName = string.Empty;
 		}
-		public PackRuleData(string assetPath, string collectPath, string grouperName)
+		public PackRuleData(string assetPath, string collectPath, string groupName)
 		{
 			AssetPath = assetPath;
 			CollectPath = collectPath;
-			GrouperName = grouperName;
+			GroupName = groupName;
 		}
 	}
 

Assets/YooAsset/Editor/AssetBundleDebugger/AssetBundleDebuggerWindow.cs

@@ -1,140 +1,298 @@
 #if UNITY_2019_4_OR_NEWER
+using System;
+using System.Collections.Generic;
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.UIElements;
 using UnityEditor.UIElements;
+using UnityEditor.Networking.PlayerConnection;
+using UnityEngine.Networking.PlayerConnection;
 
 namespace YooAsset.Editor
 {
-    public class AssetBundleDebuggerWindow : EditorWindow
+	public class AssetBundleDebuggerWindow : EditorWindow
-    {
+	{
-        [MenuItem("YooAsset/AssetBundle Debugger", false, 104)]
+		[MenuItem("YooAsset/AssetBundle Debugger", false, 104)]
-        public static void ShowExample()
+		public static void ShowExample()
-        {
+		{
-            AssetBundleDebuggerWindow wnd = GetWindow<AssetBundleDebuggerWindow>("资源包调试工具", true, EditorDefine.DockedWindowTypes);
+			AssetBundleDebuggerWindow wnd = GetWindow<AssetBundleDebuggerWindow>("资源包调试工具", true, EditorDefine.DockedWindowTypes);
-            wnd.minSize = new Vector2(800, 600);
+			wnd.minSize = new Vector2(800, 600);
-        }
+		}
 
-        /// <summary>
+		/// <summary>
-        /// 视图模式
+		/// 视图模式
-        /// </summary>
+		/// </summary>
-        private enum EViewMode
+		private enum EViewMode
-        {
+		{
-            /// <summary>
+			/// <summary>
-            /// 内存视图
+			/// 内存视图
-            /// </summary>
+			/// </summary>
-            MemoryView,
+			MemoryView,
 
-            /// <summary>
+			/// <summary>
-            /// 资源对象视图
+			/// 资源对象视图
-            /// </summary>
+			/// </summary>
-            AssetView,
+			AssetView,
 
-            /// <summary>
+			/// <summary>
-            /// 资源包视图
+			/// 资源包视图
-            /// </summary>
+			/// </summary>
-            BundleView,
+			BundleView,
-        }
+		}
-
-        private ToolbarMenu _viewModeMenu;
-        private AssetListDebuggerViewer _assetListViewer;
-        private BundleListDebuggerViewer _bundleListViewer;
-        
-        private EViewMode _viewMode;
-        private readonly DebugReport _debugReport = new DebugReport();
-        private string _searchKeyWord;
 
 
-        public void CreateGUI()
+		private readonly Dictionary<int, RemotePlayerSession> _playerSessions = new Dictionary<int, RemotePlayerSession>();
-        {
-            VisualElement root = rootVisualElement;
 
-            // 加载布局文件
+		private Label _playerName;
-            string rootPath = EditorTools.GetYooAssetSourcePath();
+		private ToolbarMenu _viewModeMenu;
-            string uxml = $"{rootPath}/Editor/AssetBundleDebugger/{nameof(AssetBundleDebuggerWindow)}.uxml";
+		private SliderInt _frameSlider;
-            var visualAsset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxml);
+		private DebuggerAssetListViewer _assetListViewer;
-            if (visualAsset == null)
+		private DebuggerBundleListViewer _bundleListViewer;
-            {
-                Debug.LogError($"Not found {nameof(AssetBundleDebuggerWindow)}.uxml : {uxml}");
-                return;
-            }
-            visualAsset.CloneTree(root);
 
-            // 采样按钮
+		private EViewMode _viewMode;
-			var sampleBtn = root.Q<Button>("SampleButton");
+		private string _searchKeyWord;
-            sampleBtn.clicked += SampleBtn_onClick;
+		private DebugReport _currentReport;
+		private RemotePlayerSession _currentPlayerSession;
+		private int _rangeIndex = 0;
 
-            // 视口模式菜单
-            _viewModeMenu = root.Q<ToolbarMenu>("ViewModeMenu");
-            //_viewModeMenu.menu.AppendAction(EViewMode.MemoryView.ToString(), ViewModeMenuAction0, ViewModeMenuFun0);
-            _viewModeMenu.menu.AppendAction(EViewMode.AssetView.ToString(), ViewModeMenuAction1, ViewModeMenuFun1);
-            _viewModeMenu.menu.AppendAction(EViewMode.BundleView.ToString(), ViewModeMenuAction2, ViewModeMenuFun2);
 
-            // 搜索栏
+		public void CreateGUI()
-            var searchField = root.Q<ToolbarSearchField>("SearchField");
+		{
-            searchField.RegisterValueChangedCallback(OnSearchKeyWordChange);
+			try
+			{
+				VisualElement root = rootVisualElement;
 
-            // 加载视图
+				// 加载布局文件
-            _assetListViewer = new AssetListDebuggerViewer();
+				var visualAsset = EditorHelper.LoadWindowUXML<AssetBundleDebuggerWindow>();
-            _assetListViewer.InitViewer();
+				if (visualAsset == null)
+					return;
 
-            // 加载视图
+				visualAsset.CloneTree(root);
-            _bundleListViewer = new BundleListDebuggerViewer();
-            _bundleListViewer.InitViewer();
 
-            // 显示视图
+				// 采样按钮
-            _viewMode = EViewMode.AssetView;
+				var sampleBtn = root.Q<Button>("SampleButton");
-            _viewModeMenu.text = EViewMode.AssetView.ToString();
+				sampleBtn.clicked += SampleBtn_onClick;
-            _assetListViewer.AttachParent(root);
+
-        }
+				// 用户列表菜单
-        private void SampleBtn_onClick()
+				_playerName = root.Q<Label>("PlayerName");
-        {
+				_playerName.text = "Editor player";
-            YooAssets.GetDebugReport(_debugReport);
+
-            _assetListViewer.FillViewData(_debugReport, _searchKeyWord);
+				// 视口模式菜单
-            _bundleListViewer.FillViewData(_debugReport, _searchKeyWord);
+				_viewModeMenu = root.Q<ToolbarMenu>("ViewModeMenu");
-        }
+				_viewModeMenu.menu.AppendAction(EViewMode.AssetView.ToString(), OnViewModeMenuChange, OnViewModeMenuStatusUpdate, EViewMode.AssetView);
-        private void OnSearchKeyWordChange(ChangeEvent<string> e)
+				_viewModeMenu.menu.AppendAction(EViewMode.BundleView.ToString(), OnViewModeMenuChange, OnViewModeMenuStatusUpdate, EViewMode.BundleView);
-        {
+				_viewModeMenu.text = EViewMode.AssetView.ToString();
-            _searchKeyWord = e.newValue;
+
-            _assetListViewer.FillViewData(_debugReport, _searchKeyWord);
+				// 搜索栏
-            _bundleListViewer.FillViewData(_debugReport, _searchKeyWord);
+				var searchField = root.Q<ToolbarSearchField>("SearchField");
-        }
+				searchField.RegisterValueChangedCallback(OnSearchKeyWordChange);
-        private void ViewModeMenuAction1(DropdownMenuAction action)
+
-        {
+				// 帧数相关
-            if (_viewMode != EViewMode.AssetView)
+				{
-            {
+					_frameSlider = root.Q<SliderInt>("FrameSlider");
-                _viewMode = EViewMode.AssetView;
+					_frameSlider.label = "Frame:";
-                VisualElement root = this.rootVisualElement;
+					_frameSlider.highValue = 0;
-                _viewModeMenu.text = EViewMode.AssetView.ToString();
+					_frameSlider.lowValue = 0;
-                _assetListViewer.AttachParent(root);
+					_frameSlider.value = 0;
-                _bundleListViewer.DetachParent();
+					_frameSlider.RegisterValueChangedCallback(evt =>
-            }
+					{
-        }
+						OnFrameSliderChange(evt.newValue);
-        private void ViewModeMenuAction2(DropdownMenuAction action)
+					});
-        {
+
-            if (_viewMode != EViewMode.BundleView)
+					var frameLast = root.Q<ToolbarButton>("FrameLast");
-            {
+					frameLast.clicked += OnFrameLast_clicked;
-                _viewMode = EViewMode.BundleView;
+
-                VisualElement root = this.rootVisualElement;
+					var frameNext = root.Q<ToolbarButton>("FrameNext");
-                _viewModeMenu.text = EViewMode.BundleView.ToString();
+					frameNext.clicked += OnFrameNext_clicked;
-                _assetListViewer.DetachParent();
+
-                _bundleListViewer.AttachParent(root);
+					var frameClear = root.Q<ToolbarButton>("FrameClear");
-            }
+					frameClear.clicked += OnFrameClear_clicked;
-        }
+				}
-        private DropdownMenuAction.Status ViewModeMenuFun1(DropdownMenuAction action)
+
-        {
+				// 加载视图
-            if (_viewMode == EViewMode.AssetView)
+				_assetListViewer = new DebuggerAssetListViewer();
-                return DropdownMenuAction.Status.Checked;
+				_assetListViewer.InitViewer();
-            else
+
-                return DropdownMenuAction.Status.Normal;
+				// 加载视图
-        }
+				_bundleListViewer = new DebuggerBundleListViewer();
-        private DropdownMenuAction.Status ViewModeMenuFun2(DropdownMenuAction action)
+				_bundleListViewer.InitViewer();
-        {
+
-            if (_viewMode == EViewMode.BundleView)
+				// 显示视图
-                return DropdownMenuAction.Status.Checked;
+				_viewMode = EViewMode.AssetView;
-            else
+				_assetListViewer.AttachParent(root);
-                return DropdownMenuAction.Status.Normal;
+
-        }
+				// 远程调试
-    }
+				EditorConnection.instance.Initialize();
+				EditorConnection.instance.RegisterConnection(OnHandleConnectionEvent);
+				EditorConnection.instance.RegisterDisconnection(OnHandleDisconnectionEvent);
+				EditorConnection.instance.Register(RemoteDebuggerDefine.kMsgSendPlayerToEditor, OnHandlePlayerMessage);
+				RemoteDebuggerInRuntime.EditorHandleDebugReportCallback = OnHandleDebugReport;
+			}
+			catch (Exception e)
+			{
+				Debug.LogError(e.ToString());
+			}
+		}
+		public void OnDestroy()
+		{
+			// 远程调试
+			EditorConnection.instance.UnregisterConnection(OnHandleConnectionEvent);
+			EditorConnection.instance.UnregisterDisconnection(OnHandleDisconnectionEvent);
+			EditorConnection.instance.Unregister(RemoteDebuggerDefine.kMsgSendPlayerToEditor, OnHandlePlayerMessage);
+			_playerSessions.Clear();
+		}
+
+		private void OnHandleConnectionEvent(int playerId)
+		{
+			Debug.Log($"Game player connection : {playerId}");
+			_playerName.text = $"Connected player : {playerId}";
+		}
+		private void OnHandleDisconnectionEvent(int playerId)
+		{
+			Debug.Log($"Game player disconnection : {playerId}");
+			_playerName.text = $"Disconneced player : {playerId}";
+		}
+		private void OnHandlePlayerMessage(MessageEventArgs args)
+		{
+			var debugReport = DebugReport.Deserialize(args.data);
+			OnHandleDebugReport(args.playerId, debugReport);
+		}
+		private void OnHandleDebugReport(int playerId, DebugReport debugReport)
+		{
+			Debug.Log($"Handle player {playerId} debug report !");
+			_currentPlayerSession = GetOrCreatePlayerSession(playerId);
+			_currentPlayerSession.AddDebugReport(debugReport);
+			_frameSlider.highValue = _currentPlayerSession.MaxRangeValue;
+			_frameSlider.value = _currentPlayerSession.MaxRangeValue;
+			UpdateFrameView(_currentPlayerSession);
+		}
+		private void OnFrameSliderChange(int sliderValue)
+		{
+			if (_currentPlayerSession != null)
+			{
+				_rangeIndex = _currentPlayerSession.ClampRangeIndex(sliderValue); ;
+				UpdateFrameView(_currentPlayerSession, _rangeIndex);
+			}
+		}
+		private void OnFrameLast_clicked()
+		{
+			if (_currentPlayerSession != null)
+			{
+				_rangeIndex = _currentPlayerSession.ClampRangeIndex(_rangeIndex - 1);
+				_frameSlider.value = _rangeIndex;
+				UpdateFrameView(_currentPlayerSession, _rangeIndex);
+			}
+		}
+		private void OnFrameNext_clicked()
+		{
+			if (_currentPlayerSession != null)
+			{
+				_rangeIndex = _currentPlayerSession.ClampRangeIndex(_rangeIndex + 1);
+				_frameSlider.value = _rangeIndex;
+				UpdateFrameView(_currentPlayerSession, _rangeIndex);
+			}
+		}
+		private void OnFrameClear_clicked()
+		{
+			if (_currentPlayerSession != null)
+			{
+				_frameSlider.label = $"Frame:";
+				_frameSlider.value = 0;
+				_frameSlider.lowValue = 0;
+				_frameSlider.highValue = 0;
+				_currentPlayerSession.ClearDebugReport();
+				_assetListViewer.ClearView();
+				_bundleListViewer.ClearView();
+			}
+		}
+
+		private RemotePlayerSession GetOrCreatePlayerSession(int playerId)
+		{
+			if (_playerSessions.TryGetValue(playerId, out RemotePlayerSession session))
+			{
+				return session;
+			}
+			else
+			{
+				RemotePlayerSession newSession = new RemotePlayerSession(playerId);
+				_playerSessions.Add(playerId, newSession);
+				return newSession;
+			}
+		}
+		private void UpdateFrameView(RemotePlayerSession playerSession)
+		{
+			if (playerSession != null)
+			{
+				UpdateFrameView(playerSession, playerSession.MaxRangeValue);
+			}
+		}
+		private void UpdateFrameView(RemotePlayerSession playerSession, int rangeIndex)
+		{
+			if (playerSession == null)
+				return;
+
+			var debugReport = playerSession.GetDebugReport(rangeIndex);
+			if (debugReport != null)
+			{
+				_currentReport = debugReport;
+				_frameSlider.label = $"Frame: {debugReport.FrameCount}";
+				_assetListViewer.FillViewData(debugReport, _searchKeyWord);
+				_bundleListViewer.FillViewData(debugReport, _searchKeyWord);
+			}
+		}
+
+		private void SampleBtn_onClick()
+		{
+			// 发送采集数据的命令
+			RemoteCommand command = new RemoteCommand();
+			command.CommandType = (int)ERemoteCommand.SampleOnce;
+			command.CommandParam = string.Empty;
+			byte[] data = RemoteCommand.Serialize(command);
+			EditorConnection.instance.Send(RemoteDebuggerDefine.kMsgSendEditorToPlayer, data);
+			RemoteDebuggerInRuntime.EditorRequestDebugReport();
+		}
+		private void OnSearchKeyWordChange(ChangeEvent<string> e)
+		{
+			_searchKeyWord = e.newValue;
+			if (_currentReport != null)
+			{
+				_assetListViewer.FillViewData(_currentReport, _searchKeyWord);
+				_bundleListViewer.FillViewData(_currentReport, _searchKeyWord);
+			}
+		}
+		private void OnViewModeMenuChange(DropdownMenuAction action)
+		{
+			var viewMode = (EViewMode)action.userData;
+			if (_viewMode != viewMode)
+			{
+				_viewMode = viewMode;
+				VisualElement root = this.rootVisualElement;
+				_viewModeMenu.text = viewMode.ToString();
+
+				if (viewMode == EViewMode.AssetView)
+				{
+					_assetListViewer.AttachParent(root);
+					_bundleListViewer.DetachParent();
+				}
+				else if (viewMode == EViewMode.BundleView)
+				{
+					_assetListViewer.DetachParent();
+					_bundleListViewer.AttachParent(root);
+				}
+				else
+				{
+					throw new NotImplementedException(viewMode.ToString());
+				}
+			}
+		}
+		private DropdownMenuAction.Status OnViewModeMenuStatusUpdate(DropdownMenuAction action)
+		{
+			var viewMode = (EViewMode)action.userData;
+			if (_viewMode == viewMode)
+				return DropdownMenuAction.Status.Checked;
+			else
+				return DropdownMenuAction.Status.Normal;
+		}
+	}
 }
 #endif

Assets/YooAsset/Editor/AssetBundleDebugger/AssetBundleDebuggerWindow.uxml

@@ -1,7 +1,14 @@
 <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
-    <uie:Toolbar name="Toolbar" style="display: flex;">
+    <uie:Toolbar name="TopToolbar" style="display: flex;">
+        <ui:Label text="Player" display-tooltip-when-elided="true" name="PlayerName" style="width: 200px; -unity-text-align: middle-left; padding-left: 5px;" />
         <uie:ToolbarMenu display-tooltip-when-elided="true" name="ViewModeMenu" text="ViewMode" style="width: 100px; flex-grow: 0;" />
         <uie:ToolbarSearchField focusable="true" name="SearchField" style="flex-grow: 1;" />
         <uie:ToolbarButton text="刷新" display-tooltip-when-elided="true" name="SampleButton" style="width: 70px; background-color: rgb(15, 118, 31); -unity-text-align: middle-center; border-top-left-radius: 2px; border-bottom-left-radius: 2px; border-top-right-radius: 2px; border-bottom-right-radius: 2px; border-left-width: 1px; border-right-width: 1px;" />
     </uie:Toolbar>
+    <uie:Toolbar name="FrameToolbar">
+        <ui:SliderInt picking-mode="Ignore" label="Frame:" value="42" high-value="100" name="FrameSlider" style="flex-grow: 1;" />
+        <uie:ToolbarButton text=" &lt;&lt; " display-tooltip-when-elided="true" name="FrameLast" />
+        <uie:ToolbarButton text=" &gt;&gt; " display-tooltip-when-elided="true" name="FrameNext" />
+        <uie:ToolbarButton text="Clear" display-tooltip-when-elided="true" name="FrameClear" />
+    </uie:Toolbar>
 </ui:UXML>

Assets/YooAsset/Editor/AssetBundleDebugger/RemotePlayerSession.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace YooAsset.Editor
+{
+	internal class RemotePlayerSession
+	{
+		private readonly List<DebugReport> _reportList = new List<DebugReport>();
+
+		/// <summary>
+		/// 用户ID
+		/// </summary>
+		public int PlayerId { private set; get; }
+
+		/// <summary>
+		/// 保存的报告最大数量
+		/// </summary>
+		public int MaxReportCount { private set; get; }
+
+		public int MinRangeValue
+		{
+			get
+			{
+				return 0;
+			}
+		}
+		public int MaxRangeValue
+		{
+			get
+			{
+				int index = _reportList.Count - 1;
+				if (index < 0)
+					index = 0;
+				return index;
+			}
+		}
+
+
+		public RemotePlayerSession(int playerId, int maxReportCount = 1000)
+		{
+			PlayerId = playerId;
+			MaxReportCount = maxReportCount;
+		}
+
+		/// <summary>
+		/// 清理缓存数据
+		/// </summary>
+		public void ClearDebugReport()
+		{
+			_reportList.Clear();
+		}
+
+		/// <summary>
+		/// 添加一个调试报告
+		/// </summary>
+		public void AddDebugReport(DebugReport report)
+		{
+			if (report == null)
+				Debug.LogWarning("Invalid debug report data !");
+
+			if (_reportList.Count >= MaxReportCount)
+				_reportList.RemoveAt(0);
+			_reportList.Add(report);
+		}
+
+		/// <summary>
+		/// 获取调试报告
+		/// </summary>
+		public DebugReport GetDebugReport(int rangeIndex)
+		{
+			if (_reportList.Count == 0)
+				return null;
+			if (rangeIndex < 0 || rangeIndex >= _reportList.Count)
+				return null;
+			return _reportList[rangeIndex];
+		}
+
+		/// <summary>
+		/// 规范索引值
+		/// </summary>
+		public int ClampRangeIndex(int rangeIndex)
+		{
+			if (rangeIndex < 0)
+				return 0;
+
+			if (rangeIndex > MaxRangeValue)
+				return MaxRangeValue;
+
+			return rangeIndex;
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleDebugger/RemotePlayerSession.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 89b4ea90b9f7e474d9e80077656ef6c4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleDebugger/VisualViewers/DebuggerAssetListViewer.cs

@@ -9,7 +9,7 @@ using UnityEngine.UIElements;
 
 namespace YooAsset.Editor
 {
-	internal class AssetListDebuggerViewer
+	internal class DebuggerAssetListViewer
 	{
 		private VisualTreeAsset _visualAsset;
 		private TemplateContainer _root;
@@ -23,15 +23,11 @@ namespace YooAsset.Editor
 		/// </summary>
 		public void InitViewer()
 		{
-			// 加载布局文件
+			// 加载布局文件		
-			string rootPath = EditorTools.GetYooAssetSourcePath();
+			_visualAsset = EditorHelper.LoadWindowUXML<DebuggerAssetListViewer>();
-			string uxml = $"{rootPath}/Editor/AssetBundleDebugger/VisualViewers/{nameof(AssetListDebuggerViewer)}.uxml";
-			_visualAsset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxml);
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(AssetListDebuggerViewer)}.uxml : {uxml}");
 				return;
-			}
+			
 			_root = _visualAsset.CloneTree();
 			_root.style.flexGrow = 1f;
 
@@ -51,6 +47,18 @@ namespace YooAsset.Editor
 			_dependListView.bindItem = BindDependListViewItem;
 		}
 
+		/// <summary>
+		/// 清空页面
+		/// </summary>
+		public void ClearView()
+		{
+			_debugReport = null;
+			_assetListView.Clear();
+			_assetListView.ClearSelection();
+			_assetListView.itemsSource.Clear();
+			_assetListView.Rebuild();
+		}
+
 		/// <summary>
 		/// 填充页面数据
 		/// </summary>
@@ -175,7 +183,7 @@ namespace YooAsset.Editor
 
 			// Status
 			StyleColor textColor;
-			if (providerInfo.Status == ProviderBase.EStatus.Fail)
+			if (providerInfo.Status == (int)ProviderBase.EStatus.Fail)
 				textColor = new StyleColor(Color.yellow);
 			else
 				textColor = label1.style.color;

Assets/YooAsset/Editor/AssetBundleDebugger/VisualViewers/DebuggerBundleListViewer.cs

@@ -9,7 +9,7 @@ using UnityEngine.UIElements;
 
 namespace YooAsset.Editor
 {
-	internal class BundleListDebuggerViewer
+	internal class DebuggerBundleListViewer
 	{
 		private VisualTreeAsset _visualAsset;
 		private TemplateContainer _root;
@@ -24,14 +24,10 @@ namespace YooAsset.Editor
 		public void InitViewer()
 		{
 			// 加载布局文件
-			string rootPath = EditorTools.GetYooAssetSourcePath();
+			_visualAsset = EditorHelper.LoadWindowUXML<DebuggerBundleListViewer>();
-			string uxml = $"{rootPath}/Editor/AssetBundleDebugger/VisualViewers/{nameof(BundleListDebuggerViewer)}.uxml";
-			_visualAsset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxml);
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(BundleListDebuggerViewer)}.uxml : {uxml}");
 				return;
-			}
+			
 			_root = _visualAsset.CloneTree();
 			_root.style.flexGrow = 1f;
 
@@ -39,17 +35,29 @@ namespace YooAsset.Editor
 			_bundleListView = _root.Q<ListView>("TopListView");
 			_bundleListView.makeItem = MakeAssetListViewItem;
 			_bundleListView.bindItem = BindAssetListViewItem;
-
 #if UNITY_2020_1_OR_NEWER
 			_bundleListView.onSelectionChange += BundleListView_onSelectionChange;
 #else
 			_bundleListView.onSelectionChanged += BundleListView_onSelectionChange;
 #endif
+
 			// 使用列表
 			_usingListView = _root.Q<ListView>("BottomListView");
 			_usingListView.makeItem = MakeIncludeListViewItem;
 			_usingListView.bindItem = BindIncludeListViewItem;
 		}
+		
+		/// <summary>
+		/// 清空页面
+		/// </summary>
+		public void ClearView()
+		{
+			_debugReport = null;
+			_bundleListView.Clear();
+			_bundleListView.ClearSelection();
+			_bundleListView.itemsSource.Clear();
+			_bundleListView.Rebuild();
+		}
 
 		/// <summary>
 		/// 填充页面数据
@@ -151,7 +159,7 @@ namespace YooAsset.Editor
 
 			// Status
 			StyleColor textColor;
-			if (bundleInfo.Status == AssetBundleLoaderBase.EStatus.Failed)
+			if (bundleInfo.Status == (int)AssetBundleLoaderBase.EStatus.Failed)
 				textColor = new StyleColor(Color.yellow);
 			else
 				textColor = label1.style.color;

Assets/YooAsset/Editor/AssetBundleReporter/AssetBundleInspector.cs

@@ -0,0 +1,46 @@
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace YooAsset.Editor
+{
+	public class AssetBundleInspector
+	{
+		[CustomEditor(typeof(AssetBundle))]
+		internal class AssetBundleEditor : UnityEditor.Editor
+		{
+			internal bool pathFoldout = false;
+			internal bool advancedFoldout = false;
+			public override void OnInspectorGUI()
+			{
+				AssetBundle bundle = target as AssetBundle;
+
+				using (new EditorGUI.DisabledScope(true))
+				{
+					var leftStyle = new GUIStyle(GUI.skin.GetStyle("Label"));
+					leftStyle.alignment = TextAnchor.UpperLeft;
+					GUILayout.Label(new GUIContent("Name: " + bundle.name), leftStyle);
+
+					var assetNames = bundle.GetAllAssetNames();
+					pathFoldout = EditorGUILayout.Foldout(pathFoldout, "Source Asset Paths");
+					if (pathFoldout)
+					{
+						EditorGUI.indentLevel++;
+						foreach (var asset in assetNames)
+							EditorGUILayout.LabelField(asset);
+						EditorGUI.indentLevel--;
+					}
+
+					advancedFoldout = EditorGUILayout.Foldout(advancedFoldout, "Advanced Data");
+				}
+
+				if (advancedFoldout)
+				{
+					EditorGUI.indentLevel++;
+					base.OnInspectorGUI();
+					EditorGUI.indentLevel--;
+				}
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleReporter/AssetBundleInspector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b8016a4c13444bf45830d714ab2aa430
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleReporter/AssetBundleRecorder.cs

@@ -0,0 +1,65 @@
+using System.IO;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace YooAsset.Editor
+{
+	public static class AssetBundleRecorder
+	{
+		private static readonly Dictionary<string, AssetBundle> _loadedAssetBundles = new Dictionary<string, AssetBundle>(1000);
+
+		/// <summary>
+		/// 获取AssetBundle对象，如果没有被缓存就重新加载。
+		/// </summary>
+		public static AssetBundle GetAssetBundle(string filePath)
+		{
+			// 如果文件不存在
+			if (File.Exists(filePath) == false)
+			{
+				Debug.LogWarning($"Not found asset bundle file : {filePath}");
+				return null;
+			}
+
+			// 验证文件有效性（可能文件被加密）
+			byte[] fileData = File.ReadAllBytes(filePath);
+			if (EditorTools.CheckBundleFileValid(fileData) == false)
+			{
+				Debug.LogWarning($"The asset bundle file is invalid and may be encrypted : {filePath}");
+				return null;
+			}
+
+			if (_loadedAssetBundles.TryGetValue(filePath, out AssetBundle bundle))
+			{
+				return bundle;
+			}
+			else
+			{
+				AssetBundle newBundle = AssetBundle.LoadFromFile(filePath);
+				if(newBundle != null)
+				{
+					string[] assetNames = newBundle.GetAllAssetNames();
+					foreach (string name in assetNames)
+					{
+						newBundle.LoadAsset(name);
+					}
+					_loadedAssetBundles.Add(filePath, newBundle);			
+				}
+				return newBundle;
+			}
+		}
+
+		/// <summary>
+		/// 卸载所有已经加载的AssetBundle文件
+		/// </summary>
+		public static void UnloadAll()
+		{
+			foreach(var valuePair in _loadedAssetBundles)
+			{
+				if (valuePair.Value != null)
+					valuePair.Value.Unload(true);
+			}
+			_loadedAssetBundles.Clear();
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleReporter/AssetBundleRecorder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9b2b5e436ee882d41bf53082bf7b23a0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleReporter/AssetBundleReporterWindow.cs

@@ -1,4 +1,5 @@
 #if UNITY_2019_4_OR_NEWER
+using System;
 using UnityEditor;
 using UnityEngine;
 using UnityEditor.UIElements;
@@ -37,60 +38,68 @@ namespace YooAsset.Editor
 		}
 
 		private ToolbarMenu _viewModeMenu;
-		private SummaryReporterViewer _summaryViewer;
+		private ReporterSummaryViewer _summaryViewer;
-		private AssetListReporterViewer _assetListViewer;
+		private ReporterAssetListViewer _assetListViewer;
-		private BundleListReporterViewer _bundleListViewer;
+		private ReporterBundleListViewer _bundleListViewer;
 
 		private EViewMode _viewMode;
-		private string _searchKeyWord;
 		private BuildReport _buildReport;
+		private string _reportFilePath;
+		private string _searchKeyWord;
 
 
 		public void CreateGUI()
 		{
-			VisualElement root = this.rootVisualElement;
+			try
-
-			// 加载布局文件
-			string rootPath = EditorTools.GetYooAssetSourcePath();
-			string uxml = $"{rootPath}/Editor/AssetBundleReporter/{nameof(AssetBundleReporterWindow)}.uxml";
-			var visualAsset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxml);
-			if (visualAsset == null)
 			{
-				Debug.LogError($"Not found {nameof(AssetBundleReporterWindow)}.uxml : {uxml}");
+				VisualElement root = this.rootVisualElement;
-				return;
+
+				// 加载布局文件
+				var visualAsset =  EditorHelper.LoadWindowUXML<AssetBundleReporterWindow>();
+				if (visualAsset == null)
+					return;
+				
+				visualAsset.CloneTree(root);
+
+				// 导入按钮
+				var importBtn = root.Q<Button>("ImportButton");
+				importBtn.clicked += ImportBtn_onClick;
+
+				// 视图模式菜单
+				_viewModeMenu = root.Q<ToolbarMenu>("ViewModeMenu");
+				_viewModeMenu.menu.AppendAction(EViewMode.Summary.ToString(), ViewModeMenuAction0, ViewModeMenuFun0);
+				_viewModeMenu.menu.AppendAction(EViewMode.AssetView.ToString(), ViewModeMenuAction1, ViewModeMenuFun1);
+				_viewModeMenu.menu.AppendAction(EViewMode.BundleView.ToString(), ViewModeMenuAction2, ViewModeMenuFun2);
+
+				// 搜索栏
+				var searchField = root.Q<ToolbarSearchField>("SearchField");
+				searchField.RegisterValueChangedCallback(OnSearchKeyWordChange);
+
+				// 加载视图
+				_summaryViewer = new ReporterSummaryViewer();
+				_summaryViewer.InitViewer();
+
+				// 加载视图
+				_assetListViewer = new ReporterAssetListViewer();
+				_assetListViewer.InitViewer();
+
+				// 加载视图
+				_bundleListViewer = new ReporterBundleListViewer();
+				_bundleListViewer.InitViewer();
+
+				// 显示视图
+				_viewMode = EViewMode.Summary;
+				_viewModeMenu.text = EViewMode.Summary.ToString();
+				_summaryViewer.AttachParent(root);
 			}
-			visualAsset.CloneTree(root);
+			catch (Exception e)
-
+			{
-			// 导入按钮
+				Debug.LogError(e.ToString());
-			var importBtn = root.Q<Button>("ImportButton");
+			}
-			importBtn.clicked += ImportBtn_onClick;
+		}
-
+		public void OnDestroy()
-			// 视图模式菜单
+		{
-			_viewModeMenu = root.Q<ToolbarMenu>("ViewModeMenu");
+			AssetBundleRecorder.UnloadAll();
-			_viewModeMenu.menu.AppendAction(EViewMode.Summary.ToString(), ViewModeMenuAction0, ViewModeMenuFun0);
-			_viewModeMenu.menu.AppendAction(EViewMode.AssetView.ToString(), ViewModeMenuAction1, ViewModeMenuFun1);
-			_viewModeMenu.menu.AppendAction(EViewMode.BundleView.ToString(), ViewModeMenuAction2, ViewModeMenuFun2);
-
-			// 搜索栏
-			var searchField = root.Q<ToolbarSearchField>("SearchField");
-			searchField.RegisterValueChangedCallback(OnSearchKeyWordChange);
-
-			// 加载视图
-			_summaryViewer = new SummaryReporterViewer();
-			_summaryViewer.InitViewer();
-
-			// 加载视图
-			_assetListViewer = new AssetListReporterViewer();
-			_assetListViewer.InitViewer();
-
-			// 加载视图
-			_bundleListViewer = new BundleListReporterViewer();
-			_bundleListViewer.InitViewer();
-
-			// 显示视图
-			_viewMode = EViewMode.Summary;
-			_viewModeMenu.text = EViewMode.Summary.ToString();
-			_summaryViewer.AttachParent(root);
 		}
 
 		private void ImportBtn_onClick()
@@ -99,19 +108,20 @@ namespace YooAsset.Editor
 			if (string.IsNullOrEmpty(selectFilePath))
 				return;
 
-			string jsonData = FileUtility.ReadFile(selectFilePath);
+			_reportFilePath = selectFilePath;
+			string jsonData = FileUtility.ReadFile(_reportFilePath);
 			_buildReport = BuildReport.Deserialize(jsonData);
 			_assetListViewer.FillViewData(_buildReport, _searchKeyWord);
-			_bundleListViewer.FillViewData(_buildReport, _searchKeyWord);
+			_bundleListViewer.FillViewData(_buildReport, _reportFilePath, _searchKeyWord);
 			_summaryViewer.FillViewData(_buildReport);
 		}
 		private void OnSearchKeyWordChange(ChangeEvent<string> e)
 		{
 			_searchKeyWord = e.newValue;
-			if(_buildReport != null)
+			if (_buildReport != null)
 			{
 				_assetListViewer.FillViewData(_buildReport, _searchKeyWord);
-				_bundleListViewer.FillViewData(_buildReport, _searchKeyWord);
+				_bundleListViewer.FillViewData(_buildReport, _reportFilePath, _searchKeyWord);
 			}
 		}
 		private void ViewModeMenuAction0(DropdownMenuAction action)

Assets/YooAsset/Editor/AssetBundleReporter/VisualViewers/ReporterAssetListViewer.cs

@@ -9,7 +9,7 @@ using UnityEngine.UIElements;
 
 namespace YooAsset.Editor
 {
-	internal class AssetListReporterViewer
+	internal class ReporterAssetListViewer
 	{
 		private enum ESortMode
 		{
@@ -38,48 +38,36 @@ namespace YooAsset.Editor
 		public void InitViewer()
 		{
 			// 加载布局文件
-			string rootPath = EditorTools.GetYooAssetSourcePath();
+			_visualAsset = EditorHelper.LoadWindowUXML<ReporterAssetListViewer>();
-			string uxml = $"{rootPath}/Editor/AssetBundleReporter/VisualViewers/{nameof(AssetListReporterViewer)}.uxml";
-			_visualAsset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxml);
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(AssetListReporterViewer)}.uxml : {uxml}");
 				return;
-			}
 
-			try
+			_root = _visualAsset.CloneTree();
-			{
+			_root.style.flexGrow = 1f;
-				_root = _visualAsset.CloneTree();
-				_root.style.flexGrow = 1f;
 
-				// 顶部按钮栏
+			// 顶部按钮栏
-				_topBar1 = _root.Q<ToolbarButton>("TopBar1");
+			_topBar1 = _root.Q<ToolbarButton>("TopBar1");
-				_topBar2 = _root.Q<ToolbarButton>("TopBar2");
+			_topBar2 = _root.Q<ToolbarButton>("TopBar2");
-				_topBar1.clicked += TopBar1_clicked;
+			_topBar1.clicked += TopBar1_clicked;
-				_topBar2.clicked += TopBar2_clicked;
+			_topBar2.clicked += TopBar2_clicked;
 
-				// 底部按钮栏
+			// 底部按钮栏
-				_bottomBar1 = _root.Q<ToolbarButton>("BottomBar1");
+			_bottomBar1 = _root.Q<ToolbarButton>("BottomBar1");
 
-				// 资源列表
+			// 资源列表
-				_assetListView = _root.Q<ListView>("TopListView");
+			_assetListView = _root.Q<ListView>("TopListView");
-				_assetListView.makeItem = MakeAssetListViewItem;
+			_assetListView.makeItem = MakeAssetListViewItem;
-				_assetListView.bindItem = BindAssetListViewItem;
+			_assetListView.bindItem = BindAssetListViewItem;
 #if UNITY_2020_1_OR_NEWER
-				_assetListView.onSelectionChange += AssetListView_onSelectionChange;
+			_assetListView.onSelectionChange += AssetListView_onSelectionChange;
 #else
-				_assetListView.onSelectionChanged += AssetListView_onSelectionChange;
+			_assetListView.onSelectionChanged += AssetListView_onSelectionChange;
 #endif
 
-				// 依赖列表
+			// 依赖列表
-				_dependListView = _root.Q<ListView>("BottomListView");
+			_dependListView = _root.Q<ListView>("BottomListView");
-				_dependListView.makeItem = MakeDependListViewItem;
+			_dependListView.makeItem = MakeDependListViewItem;
-				_dependListView.bindItem = BindDependListViewItem;
+			_dependListView.bindItem = BindDependListViewItem;
-			}
-			catch (Exception e)
-			{
-				Debug.LogError(e.ToString());
-			}
 		}
 
 		/// <summary>
@@ -322,7 +310,7 @@ namespace YooAsset.Editor
 
 			// Size
 			var label2 = element.Q<Label>("Label2");
-			label2.text = (bundleInfo.SizeBytes / 1024f).ToString("f1") + " KB";
+			label2.text = EditorUtility.FormatBytes(bundleInfo.SizeBytes);
 
 			// Hash
 			var label3 = element.Q<Label>("Label3");

Assets/YooAsset/Editor/AssetBundleReporter/VisualViewers/ReporterBundleListViewer.cs

@@ -10,7 +10,7 @@ using UnityEngine.UIElements;
 
 namespace YooAsset.Editor
 {
-	internal class BundleListReporterViewer
+	internal class ReporterBundleListViewer
 	{
 		private enum ESortMode
 		{
@@ -31,71 +31,60 @@ namespace YooAsset.Editor
 		private ListView _includeListView;
 
 		private BuildReport _buildReport;
+		private string _reportFilePath;
 		private string _searchKeyWord;
 		private ESortMode _sortMode = ESortMode.BundleName;
 		private bool _descendingSort = false;
 
-
 		/// <summary>
 		/// 初始化页面
 		/// </summary>
 		public void InitViewer()
 		{
 			// 加载布局文件
-			string rootPath = EditorTools.GetYooAssetSourcePath();
+			_visualAsset = EditorHelper.LoadWindowUXML<ReporterBundleListViewer>();
-			string uxml = $"{rootPath}/Editor/AssetBundleReporter/VisualViewers/{nameof(BundleListReporterViewer)}.uxml";
-			_visualAsset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxml);
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(BundleListReporterViewer)}.uxml : {uxml}");
 				return;
-			}
 
-			try
+			_root = _visualAsset.CloneTree();
-			{
+			_root.style.flexGrow = 1f;
-				_root = _visualAsset.CloneTree();
-				_root.style.flexGrow = 1f;
 
-				// 顶部按钮栏
+			// 顶部按钮栏
-				_topBar1 = _root.Q<ToolbarButton>("TopBar1");
+			_topBar1 = _root.Q<ToolbarButton>("TopBar1");
-				_topBar2 = _root.Q<ToolbarButton>("TopBar2");
+			_topBar2 = _root.Q<ToolbarButton>("TopBar2");
-				_topBar3 = _root.Q<ToolbarButton>("TopBar3");
+			_topBar3 = _root.Q<ToolbarButton>("TopBar3");
-				_topBar4 = _root.Q<ToolbarButton>("TopBar4");
+			_topBar4 = _root.Q<ToolbarButton>("TopBar4");
-				_topBar1.clicked += TopBar1_clicked;
+			_topBar1.clicked += TopBar1_clicked;
-				_topBar2.clicked += TopBar2_clicked;
+			_topBar2.clicked += TopBar2_clicked;
-				_topBar3.clicked += TopBar3_clicked;
+			_topBar3.clicked += TopBar3_clicked;
-				_topBar4.clicked += TopBar4_clicked;
+			_topBar4.clicked += TopBar4_clicked;
 
-				// 底部按钮栏
+			// 底部按钮栏
-				_bottomBar1 = _root.Q<ToolbarButton>("BottomBar1");
+			_bottomBar1 = _root.Q<ToolbarButton>("BottomBar1");
 
-				// 资源包列表
+			// 资源包列表
-				_bundleListView = _root.Q<ListView>("TopListView");
+			_bundleListView = _root.Q<ListView>("TopListView");
-				_bundleListView.makeItem = MakeBundleListViewItem;
+			_bundleListView.makeItem = MakeBundleListViewItem;
-				_bundleListView.bindItem = BindBundleListViewItem;
+			_bundleListView.bindItem = BindBundleListViewItem;
 #if UNITY_2020_1_OR_NEWER
-				_bundleListView.onSelectionChange += BundleListView_onSelectionChange;
+			_bundleListView.onSelectionChange += BundleListView_onSelectionChange;
 #else
-				_bundleListView.onSelectionChanged += BundleListView_onSelectionChange;
+			_bundleListView.onSelectionChanged += BundleListView_onSelectionChange;
 #endif
 
-				// 包含列表
+			// 包含列表
-				_includeListView = _root.Q<ListView>("BottomListView");
+			_includeListView = _root.Q<ListView>("BottomListView");
-				_includeListView.makeItem = MakeIncludeListViewItem;
+			_includeListView.makeItem = MakeIncludeListViewItem;
-				_includeListView.bindItem = BindIncludeListViewItem;
+			_includeListView.bindItem = BindIncludeListViewItem;
-			}
-			catch (Exception e)
-			{
-				Debug.LogError(e.ToString());
-			}
 		}
 
 		/// <summary>
 		/// 填充页面数据
 		/// </summary>
-		public void FillViewData(BuildReport buildReport, string searchKeyWord)
+		public void FillViewData(BuildReport buildReport, string reprotFilePath, string searchKeyWord)
 		{
 			_buildReport = buildReport;
+			_reportFilePath = reprotFilePath;
 			_searchKeyWord = searchKeyWord;
 			RefreshView();
 		}
@@ -139,7 +128,7 @@ namespace YooAsset.Editor
 			}
 			else if (_sortMode == ESortMode.BundleTags)
 			{
-				if(_descendingSort)
+				if (_descendingSort)
 					return result.OrderByDescending(a => a.GetTagsString()).ToList();
 				else
 					return result.OrderBy(a => a.GetTagsString()).ToList();
@@ -171,7 +160,7 @@ namespace YooAsset.Editor
 				else
 					_topBar2.text = "Size ↑";
 			}
-			else if(_sortMode == ESortMode.BundleTags)
+			else if (_sortMode == ESortMode.BundleTags)
 			{
 				if (_descendingSort)
 					_topBar4.text = "Tags ↓";
@@ -260,7 +249,7 @@ namespace YooAsset.Editor
 
 			// Size
 			var label2 = element.Q<Label>("Label2");
-			label2.text = (bundleInfo.SizeBytes / 1024f).ToString("f1") + " KB";
+			label2.text = EditorUtility.FormatBytes(bundleInfo.SizeBytes);
 
 			// Hash
 			var label3 = element.Q<Label>("Label3");
@@ -276,8 +265,22 @@ namespace YooAsset.Editor
 			{
 				ReportBundleInfo bundleInfo = item as ReportBundleInfo;
 				FillIncludeListView(bundleInfo);
+				ShowAssetBundleInspector(bundleInfo);
+				break;
 			}
 		}
+		private void ShowAssetBundleInspector(ReportBundleInfo bundleInfo)
+		{
+			if (bundleInfo.IsRawFile())
+				return;
+
+			string rootDirectory = Path.GetDirectoryName(_reportFilePath);
+			string filePath = $"{rootDirectory}/{bundleInfo.FileName}";
+			if (File.Exists(filePath))
+				Selection.activeObject = AssetBundleRecorder.GetAssetBundle(filePath);
+			else
+				Selection.activeObject = null;
+		}
 		private void TopBar1_clicked()
 		{
 			if (_sortMode != ESortMode.BundleName)