Update CHANGELOG.md

下载文件验证支持多线程。

Assets/UniTask.YooAsset~/README.md

@@ -1,19 +0,0 @@
-# UniTask 扩展
-
-[仓库链接](https://github.com/Cysharp/UniTask) 
-- 请去下载对应的源码，并删除此目录最后的波浪线
-- 在 UniTask `_InternalVisibleTo.cs` 文件中增加 `[assembly: InternalsVisibleTo("UniTask.YooAsset")]` 后即可使用
-
-## 代码示例
-
-```csharp
-var handle = YooAssets.LoadAssetAsync<GameObject>("Assets/Res/Prefabs/TestImg.prefab");
-
-await handle.ToUniTask();
-
-var obj = handle.AssetObject as GameObject;
-var go  = Instantiate(obj, transform);
-
-go.transform.localPosition = Vector3.zero;
-go.transform.localScale    = Vector3.one;
-```

Assets/YooAsset/CHANGELOG.md

@@ -2,6 +2,756 @@
 
 All notable changes to this package will be documented in this file.
 
+## [1.4.7] - 2023-03-03
+
+### Fixed
+
+- 修复了在运行时资源引用链无效的问题。
+- 修复了在构建过程中发生异常后进度条未消失的问题。
+- 修复了使用SBP构建管线，如果有原生文件会导致打包失败的问题。
+
+### Changed
+
+- 支持自定义下载请求
+
+  ```c#
+  /// <summary>
+  /// 设置下载系统参数，自定义下载请求
+  /// </summary>
+  public static void SetDownloadSystemUnityWebRequest(DownloadRequestDelegate requestDelegate)
+  ```
+
+- 优化了打包时资源包引用关系计算的逻辑。
+
+- 优化了缓存系统初始化逻辑，支持分帧获取所有缓存文件。
+
+- 优化了缓存系统的存储目录结构，提高了文件夹查询速度。
+
+- 优化了在资源收集界面，点击查看Collector主资源列表卡顿问题。
+
+- 优化了资源对象加载耗时统计的逻辑，现在更加准确了。
+
+- 优化了资源加载器查询逻辑。
+
+- 优化了资源下载系统，下载文件的验证支持了多线程。
+
+- 着色器变种收集界面增加单次照射数量的控制。
+
+## [1.4.6-preview] - 2023-02-22
+
+### Changed
+
+- EVerifyLevel新增Middle级别。
+
+  ```c#
+  public enum EVerifyLevel
+  {
+      /// <summary>
+      /// 验证文件存在
+      /// </summary>
+      Low,
+      
+      /// <summary>
+      /// 验证文件大小
+      /// </summary>
+      Middle,
+  
+      /// <summary>
+      /// 验证文件大小和CRC
+      /// </summary>
+      High,
+  }
+  ```
+
+- 补丁清单的资源包列表新增引用链。
+
+  （解决复杂依赖关系下，错误卸载资源包的问题）
+
+- 缓存系统支持后缀格式存储。
+
+  （解决原生文件没有后缀格式的问题）
+
+- 收集界面增加用户自定义数据栏。
+
+## [1.4.5-preview] - 2023-02-17
+
+### Fixed
+
+- (#67)修复了报告查看界面在Unity2021.3上的兼容性问题。
+- (#66)修复了在Unity2021.3上编辑器模拟模式运行报错的问题。
+
+### Changed
+
+- 接口变更：IPackRule
+
+  ````c#
+  /// <summary>
+  /// 资源打包规则接口
+  /// </summary>
+  public interface IPackRule
+  {
+      /// <summary>
+      /// 获取打包规则结果
+      /// </summary>
+      PackRuleResult GetPackRuleResult(PackRuleData data);
+  
+      /// <summary>
+      /// 是否为原生文件打包规则
+      /// </summary>
+      bool IsRawFilePackRule();
+  }
+  ````
+
+## [1.4.4-preview] - 2023-02-14
+
+### Fixed
+
+- (#65)修复了AssetBundle构建宏逻辑错误。
+- 修复了AssetBundle加载宏逻辑错误。
+
+## [1.4.3-preview] - 2023-02-10
+
+全新的缓存系统！
+
+### Fixed
+
+- 修复了WebGL平台本地文件验证报错。
+- 修复了WEBGL平台加载原生文件失败的问题。
+- 修复了通过Handle句柄查询资源包下载进度为零的问题。
+
+### Changed
+
+- 着色器变种收集增加分批次处理功能。
+- Unity2021版本开始不再支持内置构建管线。
+
+### Removed
+
+- 太空战机DEMO移除了BetterStreamingAssets插件。
+
+## [1.4.2-preview] - 2023-01-03
+
+### Fixed
+
+- 修复了清单解析异步操作的进度条变化错误。
+- 修复了更新资源清单错误计算超时时间的问题。
+
+## [1.4.1-preview] - 2022-12-26
+
+### Fixed
+
+- 修复了开启UniqueBundleName选项后，SBP构建报错的问题。
+
+### Added
+
+- 新增了AssetsPackage.PreDownloadPackageAsync()方法
+
+  ````c#
+  /// <summary>
+  /// 预下载指定版本的包裹资源
+  /// </summary>
+  /// <param name="packageVersion">下载的包裹版本</param>
+  /// <param name="timeout">超时时间（默认值：60秒）</param>
+  public PreDownloadPackageOperation PreDownloadPackageAsync(string packageVersion, int timeout = 60)
+  ````
+
+- 新增了OperationHandleBase.GetDownloadReport()方法
+
+  ````c#
+  /// <summary>
+  /// 获取下载报告
+  /// </summary>
+  public DownloadReport GetDownloadReport();
+  ````
+
+### Changed
+
+- 优化了资源清单更新流程，支持缓存下载的清单。
+- 优化了清单文件的解析流程，支持分帧解析避免卡顿。
+- 优化了缓存文件的验证流程，支持分帧处理。
+- 初始化的时候支持覆盖安装检测，然后清理所有的缓存清单文件。
+- ClearPackageUnusedCacheFilesAsync重名为ClearUnusedCacheFilesAsync
+
+## [1.4.0-preview] - 2022-12-04
+
+### Fixed
+
+- (#46)修复了资源包初始化失败之后，再次初始化发生异常的问题。
+- 修复了在初始化失败的之后，销毁YooAssets会报异常的问题。
+
+### Changed
+
+- 优化了资源收集界面，可以选择显示中文别名。
+- **优化了补丁清单序列化方式，由文本数据修改为二进制数据。**
+- 资源操作句柄增加using支持。
+
+## [1.3.7] - 2022-11-26
+
+全新的太空战机Demo !
+
+### Fixed
+
+- (#45)修复了package列表更新触发的异常。
+
+### Added
+
+- 新增了YooAssets.Destroy()资源系统销毁方法。
+
+  ```C#
+  /// <summary>
+  /// 销毁资源系统
+  /// </summary>
+  public static void Destroy();
+  ```
+
+### Changed
+
+- 优化了资源收集规则，原生文件打包名称现在已经包含文件后缀名。
+- 优化了资源收集规则，非原生文件收集器自动移除Unity无法识别的文件。
+- 优化了调试信息窗口，列表元素的加载状态显示为文本。
+
+## [1.3.5] - 2022-11-19
+
+### Fixed
+
+- 修复了同步接口加载加密文件失败的问题。
+
+### Added
+
+- 新增了方法AssetsPackage.ClearPackageUnusedCacheFilesAsync()
+
+  ```c#
+  /// <summary>
+  /// 清理本地包裹未使用的缓存文件
+  /// </summary>
+  public ClearPackageUnusedCacheFilesOperation ClearPackageUnusedCacheFilesAsync()
+  ```
+
+- 新增了方法AssetsPackage.LoadRawFileAsync()
+
+  ```c#
+  /// <summary>
+  /// 异步加载原生文件
+  /// </summary>
+  /// <param name="location">资源的定位地址</param>
+  public RawFileOperationHandle LoadRawFileAsync(string location)
+  ```
+
+- 新增了方法AssetsPackage.LoadRawFileSync()
+
+  ```c#
+  /// <summary>
+  /// 同步加载原生文件
+  /// </summary>
+  /// <param name="location">资源的定位地址</param>
+  public RawFileOperationHandle LoadRawFileSync(string location)
+  ```
+
+### Changed
+
+- 重命名AssetsPackage.UpdateStaticVersionAsync()为AssetsPackage.UpdatePackageVersionAsync();
+- 重命名AssetsPackage.UpdateManifestAsync()为AssetsPackage.UpdatePackageManifestAsync();
+
+### Removed
+
+- 移除了方法YooAssets.ClearUnusedCacheFiles()
+- 移除了方法AssetsPackage.GetRawFileAsync()
+
+## [1.3.4] - 2022-11-04
+
+### Fixed
+
+- (#29)修复了EditorHelper中根据guid找uxml有时候会出错的问题。
+- (#37)修复了在修改GroupName和GroupDesc时，左侧Group栏显示没刷新的问题。
+- (#38)修复了工程里没有shader的话，SBP构建会报异常的问题。
+
+### Added
+
+- 新增了AssetsPackage.CheckPackageContentsAsync()方法
+
+  ```c#
+  /// <summary>
+  /// 检查本地包裹内容的完整性
+  /// </summary>
+  public CheckPackageContentsOperation CheckPackageContentsAsync()
+  ```
+
+### Changed
+
+- 优化了HostPlayMode的初始化逻辑，优先读取沙盒内的清单，如果不存在则读取内置清单。
+
+- 重写了文件的加密和解密逻辑。
+
+  ```c#
+  public interface IDecryptionServices
+  {
+      /// <summary>
+      /// 文件偏移解密方法
+      /// </summary>
+      ulong LoadFromFileOffset(DecryptFileInfo fileInfo);
+  
+      /// <summary>
+      /// 文件内存解密方法
+      /// </summary>
+      byte[] LoadFromMemory(DecryptFileInfo fileInfo);
+  
+      /// <summary>
+      /// 文件流解密方法
+      /// </summary>
+      System.IO.FileStream LoadFromStream(DecryptFileInfo fileInfo);
+  
+      /// <summary>
+      /// 文件流解密的托管缓存大小
+      /// </summary>
+      uint GetManagedReadBufferSize();
+  }
+  ```
+
+- AssetBundleBuilder界面增加了构建版本选项。
+
+### Removed
+
+- 移除了AssetsPackage.WeaklyUpdateManifestAsync()方法。
+
+## [1.3.3] - 2022-10-27
+
+### Fixed
+
+- 修复了资源回收方法无效的问题。
+
+### Added
+
+- 新增了PackageVersion构建参数。
+
+  ````c#
+  public class BuildParameters
+  {
+      /// <summary>
+      /// 构建的包裹版本
+      /// </summary>
+      public string PackageVersion;  
+  }
+  ````
+
+### Changed
+
+- AssetBundleDebugger窗口增加了包裹名称显示列。
+- AssetBundleDebugger窗口增加资源对象的加载耗时统计和显示。
+- AssetBundleDebugger窗口增加帧调试数据导出功能。
+- AssetBundleBuilder构建流程增加输出目录文件路径过长的检测。
+- 下载器返回的错误提示增加HTTP Response Code。
+- UpdateStaticVersionOperation.PackageCRC重名为UpdateStaticVersionOperation.PackageVersion。
+- AssetPackage.GetHumanReadableVersion()重名为AssetPackage.GetPackageVersion()
+
+## [1.3.2] - 2022-10-22
+
+### Fixed
+
+- 修复了AssetBundleCollector界面点击修复按钮界面没有刷新的问题。
+
+### Added
+
+- 新增了自定义证书认证方法。
+
+  ````c#
+  public static class YooAssets
+  {
+      /// <summary>
+      /// 设置下载系统参数，自定义的证书认证实例
+      /// </summary>
+      public static void SetDownloadSystemCertificateHandler(UnityEngine.Networking.CertificateHandler instance)
+  }
+  ````
+
+- 新增了下载失败后清理文件的方法。
+
+  ````c#
+  public static class YooAssets
+  {
+      /// <summary>
+      /// 设置下载系统参数，下载失败后清理文件的HTTP错误码
+      /// </summary>
+      public static void SetDownloadSystemClearFileResponseCode(List<long> codes)
+  }
+  ````
+
+- 新增了检查资源定位地址是否有效的方法。
+
+  ```c#
+  public class AssetsPackage
+  {
+      /// <summary>
+      /// 检查资源定位地址是否有效
+      /// </summary>
+      /// <param name="location">资源的定位地址</param>
+      public bool CheckLocationValid(string location)
+  }
+  ```
+
+### Removed
+
+- 移除了ILocationServices接口类和初始化字段。
+- 移除了AssetPackage.GetAssetPath(string location)方法。
+- 移除了BuildParameters.EnableAddressable字段。
+
+### Changed
+
+- AssetBundleCollector配置增加了UniqueBundleName设置，用于解决不同包裹之间Bundle名称冲突的问题。
+
+## [1.3.1] - 2022-10-18
+
+### Fixed
+
+- 修复了原生文件每次获取都重复拷贝的问题。
+- 修复了断点续传下载字节数统计不准确的问题。
+
+### Added
+
+- 所有下载相关方法增加超时判断参数。
+
+- 新增首包资源文件拷贝选项。
+
+  ```c#
+  public class BuildParameters
+  {
+      /// <summary>
+      /// 拷贝内置资源选项
+      /// </summary>
+      public ECopyBuildinFileOption CopyBuildinFileOption = ECopyBuildinFileOption.None;
+  
+      /// <summary>
+      /// 拷贝内置资源的标签
+      /// </summary>
+      public string CopyBuildinFileTags = string.Empty;  
+  }
+  ```
+
+- 新增资源包初始化查询字段。
+
+  ```c#
+  public class AssetsPackage
+  {
+      /// <summary>
+      /// 初始化状态
+      /// </summary>
+      public EOperationStatus InitializeStatus
+  }
+  ```
+
+- 增加获取人类可读的版本信息。
+
+  ````c#
+  public class AssetsPackage
+  {
+      /// <summary>
+      /// 获取人类可读的版本信息
+      /// </summary>
+      public string GetHumanReadableVersion()
+  }
+  ````
+
+- 新增资源缓存清理方法。
+
+  ```c#
+  public static class YooAssets
+  {
+      /// <summary>
+      /// 清理未使用的缓存文件
+      /// </summary>
+      public static ClearUnusedCacheFilesOperation ClearUnusedCacheFiles()  
+  }
+  ```
+
+- 异步操作类新增繁忙查询方法。
+
+  ````c#
+  public abstract class GameAsyncOperation
+  {
+      /// <summary>
+      /// 异步操作系统是否繁忙
+      /// </summary>
+      protected bool IsBusy() 
+  }
+  ````
+
+### Removed
+
+- 移除了AssetsPackage.IsInitialized()方法。
+- 移除了YooAssets.ClearAllCacheFiles()方法。
+
+### Changed
+
+- YooAssetsPackage类重名为AssetsPackage
+
+## [1.3.0-preview] - 2022-10-08
+
+该预览版本提供了分布式构建的功能，用于解决分工程或分内容构建的问题。
+
+### Added
+
+- 新增方法设置异步系统的每帧允许运行的最大时间切片。
+
+  ```c#
+  /// <summary>
+  /// 设置异步系统的每帧允许运行的最大时间切片（单位：毫秒）
+  /// </summary>
+  public static void SetOperationSystemMaxTimeSlice(long milliseconds)
+  ```
+
+- 新增方法设置缓存系统的已经缓存文件的校验等级。
+
+  ```c#
+  /// <summary>
+  /// 设置缓存系统的已经缓存文件的校验等级
+  /// </summary>
+  public static void SetCacheSystemCachedFileVerifyLevel(EVerifyLevel verifyLevel)
+  ```
+
+- 新增方法设置下载系统的断点续传功能的文件大小。
+
+  ````C#
+  /// <summary>
+  /// 启用下载系统的断点续传功能的文件大小
+  /// </summary>
+  public static void SetDownloadSystemBreakpointResumeFileSize(int fileBytes)
+  ````
+
+### Removed
+
+- 移除了资源版本号相关概念的代码。
+- 移除了TaskCopyBuildinFiles节点在构建流程里。
+- 移除了YooAssets.ClearUnusedCacheFiles()方法。
+- 移除了初始化参数 InitializeParameters.ClearCacheOnDirty
+- 移除了初始化参数 InitializeParameters.OperationSystemMaxTimeSlice
+- 移除了初始化参数 InitializeParameters.BreakpointResumeFileSize
+- 移除了初始化参数 InitializeParameters.VerifyLevel
+
+## [1.2.4] - 2022-09-22
+
+### Fixed
+
+- 修复了加密文件下载验证失败的问题。
+- 修复了可编程构建管线下模拟构建模式报错的问题。
+
+### Changed
+
+- 可编程构建管线强制使用增量构建模式。
+- 移除了对Gizmos资源的打包限制。
+- AssetBundleCollector窗口增加配置表修复功能。
+
+## [1.2.3] - 2022-09-09
+
+### Fixed
+
+- 修复了资源收集器无法识别.bank音频文件格式。
+
+### Changed
+
+- **HostPlayMode正式支持WebGL平台。**
+- AssetBundleCollector里的着色器收集选项已经移除，现在必定收集。
+- AssetBundleCollector修改了默认的打包规则类。
+- AssetBundleBuilder现在构建结果增加补丁包目录。
+- 更新了UniTask的Sample。
+- 优化了缓存系统的代码结构。
+- 使用了新的断点续传下载器。
+
+### Added
+
+- 增加清理缓存资源的异步操作类。
+
+````c#
+/// <summary>
+/// 清空未被使用的缓存文件
+/// </summary>
+public static ClearUnusedCacheFilesOperation ClearUnusedCacheFiles();
+````
+
+## [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

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilder.cs

@@ -8,135 +8,98 @@ 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.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标记，否则会进行增量打包
-
-				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.SimulateBuild)
-					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.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 float GetBuildingSeconds()
-			{
-				float seconds = _buildWatch.ElapsedMilliseconds / 1000f;
-				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 !");
+
+				if (buildParameters.BuildMode == EBuildMode.DryRunBuild)
+					throw new Exception($"{nameof(EBuildPipeline.ScriptableBuildPipeline)} not support {nameof(EBuildMode.DryRunBuild)} build mode !");
+
+				if (buildParameters.BuildMode == EBuildMode.ForceRebuild)
+					throw new Exception($"{nameof(EBuildPipeline.ScriptableBuildPipeline)} not support {nameof(EBuildMode.ForceRebuild)} build mode !");
+			}
+
 			// 构建参数
 			var buildParametersContext = new BuildParametersContext(buildParameters);
 			_buildContext.SetContextObject(buildParametersContext);
 
-			// 执行构建流程
+			// 是否显示LOG
-			List<IBuildTask> pipeline = new List<IBuildTask>
-			{
-				new TaskPrepare(), //前期准备工作
-				new TaskGetBuildMap(), //获取构建列表
-				new TaskBuilding(), //开始执行构建
-				new TaskVerifyBuildResult(), //验证构建结果
-				new TaskEncryption(), //加密资源文件
-				new TaskCreatePatchManifest(), //创建清单文件
-				new TaskCreateReport(), //创建报告文件
-				new TaskCreatePatchPackage(), //制作补丁包
-				new TaskCopyBuildinFiles(), //拷贝内置文件
-			};
-
 			if (buildParameters.BuildMode == EBuildMode.SimulateBuild)
-				BuildRunner.EnableLog = false;
+				BuildLogger.EnableLog = false;
 			else
-				BuildRunner.EnableLog = true;
+				BuildLogger.EnableLog = true;
 
-			bool succeed = BuildRunner.Run(pipeline, _buildContext);
+			// 创建构建节点
-			if (succeed)
+			List<IBuildTask> pipeline;
-				Debug.Log($"{buildParameters.BuildMode} pipeline build succeed !");
+			if (buildParameters.BuildPipeline == EBuildPipeline.BuiltinBuildPipeline)
+			{
+				pipeline = new List<IBuildTask>
+				{
+					new TaskPrepare(), //前期准备工作
+					new TaskGetBuildMap(), //获取构建列表
+					new TaskBuilding(), //开始执行构建
+					new TaskCopyRawFile(), //拷贝原生文件
+					new TaskVerifyBuildResult(), //验证构建结果
+					new TaskEncryption(), //加密资源文件
+					new TaskUpdateBuildInfo(), //更新构建信息
+					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 TaskCopyRawFile(), //拷贝原生文件
+					new TaskVerifyBuildResult_SBP(), //验证构建结果
+					new TaskEncryption(), //加密资源文件
+					new TaskUpdateBuildInfo(), //更新构建信息
+					new TaskCreatePatchManifest(), //创建清单文件
+					new TaskCreateReport(), //创建报告文件
+					new TaskCreatePatchPackage(), //制作补丁包
+					new TaskCopyBuildinFiles(), //拷贝内置文件
+				};
+			}
 			else
+			{
+				throw new NotImplementedException();
+			}
+
+			// 执行构建流程
+			var buildResult = BuildRunner.Run(pipeline, _buildContext);
+			if (buildResult.Success)
+			{
+				buildResult.OutputPackageDirectory = buildParametersContext.GetPackageOutputDirectory();
+				Debug.Log($"{buildParameters.BuildMode} pipeline build succeed !");
+			}
+			else
+			{
 				Debug.LogWarning($"{buildParameters.BuildMode} pipeline build failed !");
-			return succeed;
+				Debug.LogError($"Build task failed : {buildResult.FailedTask}");
+				Debug.LogError($"Build task error : {buildResult.FailedInfo}");
+			}
+			return buildResult;
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderHelper.cs

@@ -22,15 +22,7 @@ namespace YooAsset.Editor
 		/// </summary>
 		public static string GetStreamingAssetsFolderPath()
 		{
-			return $"{Application.dataPath}/StreamingAssets/YooAssets/";
+			return $"{Application.dataPath}/StreamingAssets/{YooAssetSettings.StreamingAssetsBuildinFolder}/";
-		}
-
-		/// <summary>
-		/// 获取构建管线的输出目录
-		/// </summary>
-		public static string MakePipelineOutputDirectory(string outputRoot, BuildTarget buildTarget)
-		{
-			return $"{outputRoot}/{buildTarget}/{YooAssetSettingsData.Setting.UnityManifestFileName}";
 		}
 
 		/// <summary>
@@ -67,79 +59,13 @@ namespace YooAsset.Editor
 			}
 		}
 
-
 		/// <summary>
-		/// 获取所有补丁包版本列表
+		/// 获取构建管线的输出目录
-		/// 注意：列表会按照版本号从小到大排序
 		/// </summary>
-		private static List<int> GetPackageVersionList(BuildTarget buildTarget, string outputRoot)
+		public static string MakePipelineOutputDirectory(string outputRoot, string buildPackage, BuildTarget buildTarget, EBuildMode buildMode)
 		{
-			List<int> versionList = new List<int>();
+			string outputDirectory = $"{outputRoot}/{buildPackage}/{buildTarget}/{YooAssetSettings.OutputFolderName}";
-
+			return outputDirectory;
-			string parentPath = $"{outputRoot}/{buildTarget}";
-			if (Directory.Exists(parentPath) == false)
-				return versionList;
-
-			// 获取所有补丁包文件夹
-			string[] allFolders = Directory.GetDirectories(parentPath);
-			for (int i = 0; i < allFolders.Length; i++)
-			{
-				string folderName = Path.GetFileNameWithoutExtension(allFolders[i]);
-				if (int.TryParse(folderName, out int version))
-					versionList.Add(version);
-			}
-
-			// 从小到大排序
-			versionList.Sort();
-			return versionList;
-		}
-
-		/// <summary>
-		/// 获取当前最大的补丁包版本号
-		/// </summary>
-		/// <returns>如果没有任何补丁版本，那么返回-1</returns>
-		public static int GetMaxPackageVersion(BuildTarget buildTarget, string outputRoot)
-		{
-			List<int> versionList = GetPackageVersionList(buildTarget, outputRoot);
-			if (versionList.Count == 0)
-				return -1;
-			return versionList[versionList.Count - 1];
-		}
-
-		/// <summary>
-		/// 是否存在任何补丁包版本
-		/// </summary>
-		public static bool HasAnyPackageVersion(BuildTarget buildTarget, string outputRoot)
-		{
-			List<int> versionList = GetPackageVersionList(buildTarget, outputRoot);
-			return versionList.Count > 0;
-		}
-
-
-		/// <summary>
-		/// 加载补丁清单文件
-		/// </summary>
-		internal static PatchManifest LoadPatchManifestFile(string fileDirectory, int resourceVersion)
-		{
-			string filePath = $"{fileDirectory}/{YooAssetSettingsData.GetPatchManifestFileName(resourceVersion)}";
-			if (File.Exists(filePath) == false)
-			{
-				throw new System.Exception($"Not found patch manifest file : {filePath}");
-			}
-
-			string jsonData = FileUtility.ReadFile(filePath);
-			return PatchManifest.Deserialize(jsonData);
-		}
-
-		/// <summary>
-		/// 获取旧的补丁清单
-		/// </summary>
-		internal static PatchManifest GetOldPatchManifest(string pipelineOutputDirectory)
-		{
-			string staticVersionFilePath = $"{pipelineOutputDirectory}/{YooAssetSettings.VersionFileName}";
-			string staticVersionContent = FileUtility.ReadFile(staticVersionFilePath);
-			int staticVersion = int.Parse(staticVersionContent);
-			return LoadPatchManifestFile(pipelineOutputDirectory, staticVersion);
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderSetting.cs

@@ -6,9 +6,9 @@ namespace YooAsset.Editor
 	public class AssetBundleBuilderSetting : ScriptableObject
 	{
 		/// <summary>
-		/// 构建版本号
+		/// 构建管线
 		/// </summary>
-		public int BuildVersion = 0;
+		public EBuildPipeline BuildPipeline = EBuildPipeline.BuiltinBuildPipeline;
 
 		/// <summary>
 		/// 构建模式
@@ -16,23 +16,33 @@ namespace YooAsset.Editor
 		public EBuildMode BuildMode = EBuildMode.ForceRebuild;
 
 		/// <summary>
-		/// 内置资源标签
+		/// 构建的包裹名称
 		/// </summary>
-		public string BuildTags = string.Empty;
+		public string BuildPackage = string.Empty;
 
 		/// <summary>
 		/// 压缩方式
 		/// </summary>
 		public ECompressOption CompressOption = ECompressOption.LZ4;
 
+		/// <summary>
+		/// 输出文件名称样式
+		/// </summary>
+		public EOutputNameStyle OutputNameStyle = EOutputNameStyle.HashName;
+
+		/// <summary>
+		/// 首包资源文件的拷贝方式
+		/// </summary>
+		public ECopyBuildinFileOption CopyBuildinFileOption = ECopyBuildinFileOption.None;
+
+		/// <summary>
+		/// 首包资源文件的标签集合
+		/// </summary>
+		public string CopyBuildinFileTags = string.Empty;
+
 		/// <summary>
 		/// 加密类名称
 		/// </summary>
 		public string EncyptionClassName = string.Empty;
-
-		/// <summary>
-		/// 附加后缀格式
-		/// </summary>
-		public bool AppendExtension = false;
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderSettingData.cs

@@ -19,12 +19,17 @@ namespace YooAsset.Editor
 			}
 		}
 
+		/// <summary>
+		/// 配置数据是否被修改
+		/// </summary>
+		public static bool IsDirty { set; get; } = false;
+
 		/// <summary>
 		/// 加载配置文件
 		/// </summary>
 		private static void LoadSettingData()
 		{
-			_setting = YooAssetEditorSettingsHelper.LoadSettingData<AssetBundleBuilderSetting>();
+			_setting = EditorHelper.LoadSettingData<AssetBundleBuilderSetting>();
 		}
 
 		/// <summary>
@@ -34,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

@@ -21,14 +21,19 @@ namespace YooAsset.Editor
 		private BuildTarget _buildTarget;
 		private List<Type> _encryptionServicesClassTypes;
 		private List<string> _encryptionServicesClassNames;
+		private List<string> _buildPackageNames;
 
+		private Button _saveButton;
 		private TextField _buildOutputField;
-		private IntegerField _buildVersionField;
+		private EnumField _buildPipelineField;
 		private EnumField _buildModeField;
-		private TextField _buildTagsField;
+		private TextField _buildVersionField;
+		private PopupField<string> _buildPackageField;
 		private PopupField<string> _encryptionField;
 		private EnumField _compressionField;
-		private Toggle _appendExtensionToggle;
+		private EnumField _outputNameStyleField;
+		private EnumField _copyBuildinFileOptionField;
+		private TextField _copyBuildinFileTagsField;
 
 		public void CreateGUI()
 		{
@@ -37,62 +42,94 @@ namespace YooAsset.Editor
 				VisualElement root = this.rootVisualElement;
 
 				// 加载布局文件
-				var visualAsset = YooAssetEditorSettingsData.Setting.AssetBundleBuilderUXML;
+				var visualAsset = EditorHelper.LoadWindowUXML<AssetBundleBuilderWindow>();
 				if (visualAsset == null)
-				{
-					Debug.LogError($"Not found {nameof(AssetBundleBuilderWindow)}.uxml in settings.");
 					return;
-				}
+
 				visualAsset.CloneTree(root);
 
+				// 配置保存按钮
+				_saveButton = root.Q<Button>("SaveButton");
+				_saveButton.clicked += SaveBtn_clicked;
+
+				// 构建平台
 				_buildTarget = EditorUserBuildSettings.activeBuildTarget;
+
+				// 包裹名称列表
+				_buildPackageNames = GetBuildPackageNames();
+
+				// 加密服务类
 				_encryptionServicesClassTypes = GetEncryptionServicesClassTypes();
-				_encryptionServicesClassNames = _encryptionServicesClassTypes.Select(t => t.FullName).ToList();
+				_encryptionServicesClassNames = _encryptionServicesClassTypes.Select(t => t.Name).ToList();
 
 				// 输出目录
 				string defaultOutputRoot = AssetBundleBuilderHelper.GetDefaultOutputRoot();
-				string pipelineOutputDirectory = AssetBundleBuilderHelper.MakePipelineOutputDirectory(defaultOutputRoot, _buildTarget);
 				_buildOutputField = root.Q<TextField>("BuildOutput");
-				_buildOutputField.SetValueWithoutNotify(pipelineOutputDirectory);
+				_buildOutputField.SetValueWithoutNotify(defaultOutputRoot);
 				_buildOutputField.SetEnabled(false);
 
-				// 构建版本
+				// 构建管线
-				_buildVersionField = root.Q<IntegerField>("BuildVersion");
+				_buildPipelineField = root.Q<EnumField>("BuildPipeline");
-				_buildVersionField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildVersion);
+				_buildPipelineField.Init(AssetBundleBuilderSettingData.Setting.BuildPipeline);
-				_buildVersionField.RegisterValueChangedCallback(evt =>
+				_buildPipelineField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildPipeline);
+				_buildPipelineField.style.width = 350;
+				_buildPipelineField.RegisterValueChangedCallback(evt =>
 				{
-					AssetBundleBuilderSettingData.Setting.BuildVersion = _buildVersionField.value;
+					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");
+				_buildVersionField = root.Q<TextField>("BuildVersion");
-				_buildTagsField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildTags);
+				_buildVersionField.SetValueWithoutNotify(GetBuildPackageVersion());
-				_buildTagsField.RegisterValueChangedCallback(evt =>
+
+				// 构建包裹
+				var buildPackageContainer = root.Q("BuildPackageContainer");
+				if (_buildPackageNames.Count > 0)
 				{
-					AssetBundleBuilderSettingData.Setting.BuildTags = _buildTagsField.value;
+					int defaultIndex = GetDefaultPackageIndex(AssetBundleBuilderSettingData.Setting.BuildPackage);
-				});
+					_buildPackageField = new PopupField<string>(_buildPackageNames, defaultIndex);
+					_buildPackageField.label = "Build Package";
+					_buildPackageField.style.width = 350;
+					_buildPackageField.RegisterValueChangedCallback(evt =>
+					{
+						AssetBundleBuilderSettingData.IsDirty = true;
+						AssetBundleBuilderSettingData.Setting.BuildPackage = _buildPackageField.value;
+					});
+					buildPackageContainer.Add(_buildPackageField);
+				}
+				else
+				{
+					_buildPackageField = new PopupField<string>();
+					_buildPackageField.label = "Build Package";
+					_buildPackageField.style.width = 350;
+					buildPackageContainer.Add(_buildPackageField);
+				}
 
 				// 加密方法
 				var encryptionContainer = root.Q("EncryptionContainer");
 				if (_encryptionServicesClassNames.Count > 0)
 				{
-					int defaultIndex = GetEncryptionDefaultIndex(AssetBundleBuilderSettingData.Setting.EncyptionClassName);
+					int defaultIndex = GetDefaultEncryptionIndex(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);
@@ -101,26 +138,51 @@ namespace YooAsset.Editor
 				{
 					_encryptionField = new PopupField<string>();
 					_encryptionField.label = "Encryption";
-					_encryptionField.style.width = 300;
+					_encryptionField.style.width = 350;
 					encryptionContainer.Add(_encryptionField);
 				}
 
-				// 压缩方式
+				// 压缩方式选项
 				_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;
+				});
+
+				// 首包文件拷贝选项
+				_copyBuildinFileOptionField = root.Q<EnumField>("CopyBuildinFileOption");
+				_copyBuildinFileOptionField.Init(AssetBundleBuilderSettingData.Setting.CopyBuildinFileOption);
+				_copyBuildinFileOptionField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.CopyBuildinFileOption);
+				_copyBuildinFileOptionField.style.width = 350;
+				_copyBuildinFileOptionField.RegisterValueChangedCallback(evt =>
+				{
+					AssetBundleBuilderSettingData.IsDirty = true;
+					AssetBundleBuilderSettingData.Setting.CopyBuildinFileOption = (ECopyBuildinFileOption)_copyBuildinFileOptionField.value;
+					RefreshWindow();
+				});
+
+				// 首包文件的资源标签
+				_copyBuildinFileTagsField = root.Q<TextField>("CopyBuildinFileTags");
+				_copyBuildinFileTagsField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.CopyBuildinFileTags);
+				_copyBuildinFileTagsField.RegisterValueChangedCallback(evt =>
+				{
+					AssetBundleBuilderSettingData.IsDirty = true;
+					AssetBundleBuilderSettingData.Setting.CopyBuildinFileTags = _copyBuildinFileTagsField.value;
 				});
 
 				// 构建按钮
@@ -136,16 +198,54 @@ 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 buildPipeline = AssetBundleBuilderSettingData.Setting.BuildPipeline;
-			_buildTagsField.SetEnabled(enableElement);
+			var buildMode = AssetBundleBuilderSettingData.Setting.BuildMode;
-			_encryptionField.SetEnabled(enableElement);
+			var copyOption = AssetBundleBuilderSettingData.Setting.CopyBuildinFileOption;
-			_compressionField.SetEnabled(enableElement);
+			bool enableElement = buildMode == EBuildMode.ForceRebuild;
-			_appendExtensionToggle.SetEnabled(enableElement);
+			bool tagsFiledVisible = copyOption == ECopyBuildinFileOption.ClearAndCopyByTags || copyOption == ECopyBuildinFileOption.OnlyCopyByTags;
+
+			if (buildPipeline == EBuildPipeline.BuiltinBuildPipeline)
+			{
+				_compressionField.SetEnabled(enableElement);
+				_outputNameStyleField.SetEnabled(enableElement);
+				_copyBuildinFileOptionField.SetEnabled(enableElement);
+				_copyBuildinFileTagsField.SetEnabled(enableElement);
+			}
+			else
+			{
+				_compressionField.SetEnabled(true);
+				_outputNameStyleField.SetEnabled(true);
+				_copyBuildinFileOptionField.SetEnabled(true);
+				_copyBuildinFileTagsField.SetEnabled(true);
+			}
+
+			_copyBuildinFileTagsField.visible = tagsFiledVisible;
+		}
+		private void SaveBtn_clicked()
+		{
+			AssetBundleBuilderSettingData.SaveFile();
 		}
 		private void BuildButton_clicked()
 		{
@@ -170,21 +270,65 @@ 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.PackageName = AssetBundleBuilderSettingData.Setting.BuildPackage;
+			buildParameters.PackageVersion = _buildVersionField.value;
 			buildParameters.VerifyBuildingResult = true;
-			buildParameters.EnableAddressable = AssetBundleCollectorSettingData.Setting.EnableAddressable;
-			buildParameters.AppendFileExtension = _appendExtensionToggle.value;
 			buildParameters.EncryptionServices = CreateEncryptionServicesInstance();
-			buildParameters.CompressOption = (ECompressOption)_compressionField.value;
+			buildParameters.CompressOption = AssetBundleBuilderSettingData.Setting.CompressOption;
+			buildParameters.OutputNameStyle = AssetBundleBuilderSettingData.Setting.OutputNameStyle;
+			buildParameters.CopyBuildinFileOption = AssetBundleBuilderSettingData.Setting.CopyBuildinFileOption;
+			buildParameters.CopyBuildinFileTags = AssetBundleBuilderSettingData.Setting.CopyBuildinFileTags;
 
-			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(buildResult.OutputPackageDirectory);
+			}
+		}
+
+		// 构建版本相关
+		private string GetBuildPackageVersion()
+		{
+			int totalMinutes = DateTime.Now.Hour * 60 + DateTime.Now.Minute;
+			return DateTime.Now.ToString("yyyy-MM-dd") + "-" + totalMinutes;
+		}
+
+		// 构建包裹相关
+		private int GetDefaultPackageIndex(string packageName)
+		{
+			for (int index = 0; index < _buildPackageNames.Count; index++)
+			{
+				if (_buildPackageNames[index] == packageName)
+				{
+					return index;
+				}
+			}
+
+			AssetBundleBuilderSettingData.IsDirty = true;
+			AssetBundleBuilderSettingData.Setting.BuildPackage = _buildPackageNames[0];
+			return 0;
+		}
+		private List<string> GetBuildPackageNames()
+		{
+			List<string> result = new List<string>();
+			foreach (var package in AssetBundleCollectorSettingData.Setting.Packages)
+			{
+				result.Add(package.PackageName);
+			}
+			return result;
 		}
 
 		// 加密类相关
-		private int GetEncryptionDefaultIndex(string className)
+		private int GetDefaultEncryptionIndex(string className)
 		{
 			for (int index = 0; index < _encryptionServicesClassNames.Count; index++)
 			{
@@ -193,6 +337,9 @@ namespace YooAsset.Editor
 					return index;
 				}
 			}
+
+			AssetBundleBuilderSettingData.IsDirty = true;
+			AssetBundleBuilderSettingData.Setting.EncyptionClassName = _encryptionServicesClassNames[0];
 			return 0;
 		}
 		private List<Type> GetEncryptionServicesClassTypes()

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderWindow.uxml

@@ -1,13 +1,18 @@
 <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:TextField picking-mode="Ignore" label="Build Version" name="BuildVersion" style="width: 350px;" />
+        <ui:VisualElement name="BuildPackageContainer" style="height: 24px;" />
         <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" />
+        <uie:EnumField label="Copy Buildin File Option" value="Center" name="CopyBuildinFileOption" />
+        <ui:TextField picking-mode="Ignore" label="Copy Buildin File Tags" name="CopyBuildinFileTags" />
         <ui:Button text="构建" display-tooltip-when-elided="true" name="Build" style="height: 50px; background-color: rgb(40, 106, 42); margin-top: 10px;" />
     </ui:VisualElement>
 </ui:UXML>

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleSimulateBuilder.cs

@@ -1,43 +1,36 @@
 using UnityEditor;
+using UnityEngine;
 
 namespace YooAsset.Editor
 {
 	public static class AssetBundleSimulateBuilder
 	{
-		private static string _manifestFilePath = string.Empty;
-
 		/// <summary>
 		/// 模拟构建
 		/// </summary>
-		public static void SimulateBuild()
+		public static string SimulateBuild(string packageName)
 		{
+			Debug.Log($"Begin to create simulate package : {packageName}");
 			string defaultOutputRoot = AssetBundleBuilderHelper.GetDefaultOutputRoot();
 			BuildParameters buildParameters = new BuildParameters();
 			buildParameters.OutputRoot = defaultOutputRoot;
 			buildParameters.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
 			buildParameters.BuildMode = EBuildMode.SimulateBuild;
-			buildParameters.BuildVersion = 999;
+			buildParameters.PackageName = packageName;
-			buildParameters.EnableAddressable = AssetBundleCollectorSettingData.Setting.EnableAddressable;
+			buildParameters.PackageVersion = "Simulate";
 
 			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);
+				string manifestFileName = YooAssetSettingsData.GetManifestBinaryFileName(buildParameters.PackageName, buildParameters.PackageVersion);
-				_manifestFilePath = $"{pipelineOutputDirectory}_{EBuildMode.SimulateBuild}/{YooAssetSettingsData.GetPatchManifestFileName(buildParameters.BuildVersion)}";
+				string manifestFilePath = $"{buildResult.OutputPackageDirectory}/{manifestFileName}";
+				return manifestFilePath;
 			}
 			else
 			{
-				_manifestFilePath = null;
+				return null;
 			}
 		}
-		
-		/// <summary>
-		/// 获取构建的补丁清单路径
-		/// </summary>
-		public static string GetPatchManifestPath()
-		{
-			return _manifestFilePath;
-		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildAssetInfo.cs

@@ -7,16 +7,19 @@ namespace YooAsset.Editor
 {
 	public class BuildAssetInfo
 	{
-		private string _mainBundleName;
-		private string _shareBundleName;
-		private readonly HashSet<string> _referenceBundleNames = new HashSet<string>();
 		private bool _isAddAssetTags = false;
-		
+		private readonly HashSet<string> _referenceBundleNames = new HashSet<string>();
+
 		/// <summary>
 		/// 收集器类型
 		/// </summary>
 		public ECollectorType CollectorType { private set; get; }
 
+		/// <summary>
+		/// 资源包完整名称
+		/// </summary>
+		public string BundleName { private set; get; }
+
 		/// <summary>
 		/// 可寻址地址
 		/// </summary>
@@ -54,29 +57,29 @@ namespace YooAsset.Editor
 		public List<BuildAssetInfo> AllDependAssetInfos { private set; get; }
 
 
-		public BuildAssetInfo(ECollectorType collectorType, string mainBundleName, string address, string assetPath, bool isRawAsset)
+		public BuildAssetInfo(ECollectorType collectorType, string bundleName, string address, string assetPath, bool isRawAsset)
 		{
-			_mainBundleName = mainBundleName;
 			CollectorType = collectorType;
+			BundleName = bundleName;
 			Address = address;
 			AssetPath = assetPath;
 			IsRawAsset = isRawAsset;
 
 			System.Type assetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(assetPath);
-			if (assetType == typeof(UnityEngine.Shader))
+			if (assetType == typeof(UnityEngine.Shader) || assetType == typeof(UnityEngine.ShaderVariantCollection))
 				IsShaderAsset = true;
 			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;
 
 			System.Type assetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(assetPath);
-			if (assetType == typeof(UnityEngine.Shader))
+			if (assetType == typeof(UnityEngine.Shader) || assetType == typeof(UnityEngine.ShaderVariantCollection))
 				IsShaderAsset = true;
 			else
 				IsShaderAsset = false;
@@ -112,7 +115,7 @@ namespace YooAsset.Editor
 				}
 			}
 		}
-		
+
 		/// <summary>
 		/// 添加资源包的分类标签
 		/// 说明：传染算法统计到的分类标签
@@ -133,24 +136,12 @@ namespace YooAsset.Editor
 		/// </summary>
 		public bool HasBundleName()
 		{
-			string bundleName = GetBundleName();
+			if (string.IsNullOrEmpty(BundleName))
-			if (string.IsNullOrEmpty(bundleName))
 				return false;
 			else
 				return true;
 		}
 
-		/// <summary>
-		/// 获取资源包名称
-		/// </summary>
-		public string GetBundleName()
-		{
-			if (CollectorType == ECollectorType.None)
-				return _shareBundleName;
-			else
-				return _mainBundleName;
-		}
-
 		/// <summary>
 		/// 添加关联的资源包名称
 		/// </summary>
@@ -164,46 +155,32 @@ namespace YooAsset.Editor
 		}
 
 		/// <summary>
-		/// 计算主资源或共享资源的完整包名
+		/// 计算共享资源包的完整包名
 		/// </summary>
-		public void CalculateFullBundleName()
+		public void CalculateShareBundleName(bool uniqueBundleName, string packageName, string shadersBundleName)
 		{
-			if (CollectorType == ECollectorType.None)
+			if (CollectorType != ECollectorType.None)
+				return;
+
+			if (IsRawAsset)
+				throw new Exception("Should never get here !");
+
+			if (IsShaderAsset)
 			{
-				if (IsRawAsset)
+				BundleName = shadersBundleName;
-					throw new Exception("Should never get here !");
-
-				if (AssetBundleCollectorSettingData.Setting.AutoCollectShaders)
-				{
-					if (IsShaderAsset)
-					{
-						string shareBundleName = $"{AssetBundleCollectorSettingData.Setting.ShadersBundleName}.{YooAssetSettingsData.Setting.AssetBundleFileVariant}";
-						_shareBundleName = EditorTools.GetRegularPath(shareBundleName).ToLower();
-						return;
-					}
-				}
-
-				if (_referenceBundleNames.Count > 1)
-				{
-					var bundleNameList = _referenceBundleNames.ToList();
-					bundleNameList.Sort();
-					string combineName = string.Join("|", bundleNameList);
-					var combineNameHash = HashUtility.StringSHA1(combineName);
-					var shareBundleName = $"share_{combineNameHash}.{YooAssetSettingsData.Setting.AssetBundleFileVariant}";
-					_shareBundleName = EditorTools.GetRegularPath(shareBundleName).ToLower();
-				}
 			}
 			else
 			{
-				if (IsRawAsset)
+				if (_referenceBundleNames.Count > 1)
 				{
-					string mainBundleName = $"{_mainBundleName}.{YooAssetSettingsData.Setting.RawFileVariant}";
+					IPackRule packRule = PackDirectory.StaticPackRule;
-					_mainBundleName = EditorTools.GetRegularPath(mainBundleName).ToLower();
+					PackRuleResult packRuleResult = packRule.GetPackRuleResult(new PackRuleData(AssetPath));
+					BundleName = packRuleResult.GetShareBundleName(packageName, uniqueBundleName);
 				}
 				else
 				{
-					string mainBundleName = $"{_mainBundleName}.{YooAssetSettingsData.Setting.AssetBundleFileVariant}";
+					// 注意：被引用次数小于1的资源不需要设置资源包名称
-					_mainBundleName = EditorTools.GetRegularPath(mainBundleName).ToLower(); ;
+					BundleName = string.Empty;
 				}
 			}
 		}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildBundleInfo.cs

@@ -8,6 +8,40 @@ namespace YooAsset.Editor
 {
 	public class BuildBundleInfo
 	{
+		public class BuildPatchInfo
+		{
+			/// <summary>
+			/// 构建内容的哈希值
+			/// </summary>
+			public string ContentHash { set; get; }
+
+			/// <summary>
+			/// 文件哈希值
+			/// </summary>
+			public string PatchFileHash { set; get; }
+
+			/// <summary>
+			/// 文件哈希值
+			/// </summary>
+			public string PatchFileCRC { set; get; }
+
+			/// <summary>
+			/// 文件哈希值
+			/// </summary>
+			public long PatchFileSize { set; get; }
+
+
+			/// <summary>
+			/// 构建输出的文件路径
+			/// </summary>
+			public string BuildOutputFilePath { set; get; }
+
+			/// <summary>
+			/// 补丁包输出文件路径
+			/// </summary>
+			public string PatchOutputFilePath { set; get; }
+		}
+
 		/// <summary>
 		/// 资源包名称
 		/// </summary>
@@ -19,6 +53,22 @@ namespace YooAsset.Editor
 		/// </summary>
 		public readonly List<BuildAssetInfo> BuildinAssets = new List<BuildAssetInfo>();
 
+		/// <summary>
+		/// 补丁文件信息
+		/// </summary>
+		public readonly BuildPatchInfo PatchInfo = new BuildPatchInfo();
+
+		/// <summary>
+		/// Bundle文件的加载方法
+		/// </summary>
+		public EBundleLoadMethod LoadMethod { set; get; }
+
+		/// <summary>
+		/// 加密生成文件的路径
+		/// 注意：如果未加密该路径为空
+		/// </summary>
+		public string EncryptedFilePath { set; get; }
+
 		/// <summary>
 		/// 是否为原生文件
 		/// </summary>
@@ -35,6 +85,20 @@ namespace YooAsset.Editor
 			}
 		}
 
+		/// <summary>
+		/// 是否为加密文件
+		/// </summary>
+		public bool IsEncryptedFile
+		{
+			get
+			{
+				if (string.IsNullOrEmpty(EncryptedFilePath))
+					return false;
+				else
+					return true;
+			}
+		}
+
 
 		public BuildBundleInfo(string bundleName)
 		{
@@ -84,14 +148,6 @@ namespace YooAsset.Editor
 			return result.ToArray();
 		}
 
-		/// <summary>
-		/// 获取文件的扩展名
-		/// </summary>
-		public string GetAppendExtension()
-		{
-			return System.IO.Path.GetExtension(BundleName);
-		}
-
 		/// <summary>
 		/// 获取构建的资源路径列表
 		/// </summary>
@@ -120,5 +176,21 @@ namespace YooAsset.Editor
 			build.assetNames = GetBuildinAssetPaths();
 			return build;
 		}
+
+		/// <summary>
+		/// 创建PatchBundle类
+		/// </summary>
+		internal PatchBundle CreatePatchBundle()
+		{
+			PatchBundle patchBundle = new PatchBundle();
+			patchBundle.BundleName = BundleName;
+			patchBundle.FileHash = PatchInfo.PatchFileHash;
+			patchBundle.FileCRC = PatchInfo.PatchFileCRC;
+			patchBundle.FileSize = PatchInfo.PatchFileSize;
+			patchBundle.IsRawFile = IsRawFile;
+			patchBundle.LoadMethod = (byte)LoadMethod;
+			patchBundle.Tags = GetBundleTags();
+			return patchBundle;
+		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildMapContext.cs

@@ -14,6 +14,21 @@ namespace YooAsset.Editor
 		/// </summary>
 		public int AssetFileCount;
 
+		/// <summary>
+		/// 是否启用可寻址资源定位
+		/// </summary>
+		public bool EnableAddressable;
+
+		/// <summary>
+		/// 资源包名唯一化
+		/// </summary>
+		public bool UniqueBundleName;
+
+		/// <summary>
+		/// 着色器统一的全名称
+		/// </summary>
+		public string ShadersBundleName;
+
 		/// <summary>
 		/// 资源包列表
 		/// </summary>
@@ -25,7 +40,7 @@ namespace YooAsset.Editor
 		/// </summary>
 		public void PackAsset(BuildAssetInfo assetInfo)
 		{
-			string bundleName = assetInfo.GetBundleName();
+			string bundleName = assetInfo.BundleName;
 			if (string.IsNullOrEmpty(bundleName))
 				throw new Exception("Should never get here !");
 
@@ -54,18 +69,6 @@ namespace YooAsset.Editor
 			return result;
 		}
 
-		/// <summary>
-		/// 获取资源包的分类标签列表
-		/// </summary>
-		public string[] GetBundleTags(string bundleName)
-		{
-			if (TryGetBundleInfo(bundleName, out BuildBundleInfo bundleInfo))
-			{
-				return bundleInfo.GetBundleTags();
-			}
-			throw new Exception($"Not found {nameof(BuildBundleInfo)} : {bundleName}");
-		}
-
 		/// <summary>
 		/// 获取AssetBundle内构建的资源路径列表
 		/// </summary>

Assets/YooAsset/Editor/AssetBundleBuilder/BuildMapCreater.cs

@@ -10,18 +10,18 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 执行资源构建上下文
 		/// </summary>
-		public static BuildMapContext CreateBuildMap(EBuildMode buildMode)
+		public static BuildMapContext CreateBuildMap(EBuildMode buildMode, string packageName)
-		{
+		{	
-			BuildMapContext context = new BuildMapContext();
 			Dictionary<string, BuildAssetInfo> buildAssetDic = new Dictionary<string, BuildAssetInfo>(1000);
 
 			// 1. 检测配置合法性
 			AssetBundleCollectorSettingData.Setting.CheckConfigError();
 
 			// 2. 获取所有收集器收集的资源
-			List<CollectAssetInfo> allCollectAssets = AssetBundleCollectorSettingData.Setting.GetAllCollectAssets(buildMode);
+			var buildResult = AssetBundleCollectorSettingData.Setting.GetPackageAssets(buildMode, packageName);
+			List<CollectAssetInfo> allCollectAssets = buildResult.CollectAssets;
 
-			// 3. 剔除未被引用的依赖资源
+			// 3. 剔除未被引用的依赖项资源
 			List<CollectAssetInfo> removeDependList = new List<CollectAssetInfo>();
 			foreach (var collectAssetInfo in allCollectAssets)
 			{
@@ -41,7 +41,8 @@ namespace YooAsset.Editor
 			{
 				if (buildAssetDic.ContainsKey(collectAssetInfo.AssetPath) == false)
 				{
-					var buildAssetInfo = new BuildAssetInfo(collectAssetInfo.CollectorType, collectAssetInfo.BundleName,
+					var buildAssetInfo = new BuildAssetInfo(
+						collectAssetInfo.CollectorType, collectAssetInfo.BundleName,
 						collectAssetInfo.Address, collectAssetInfo.AssetPath, collectAssetInfo.IsRawAsset);
 					buildAssetInfo.AddAssetTags(collectAssetInfo.AssetTags);
 					buildAssetInfo.AddBundleTags(collectAssetInfo.AssetTags);
@@ -53,28 +54,28 @@ namespace YooAsset.Editor
 				}
 			}
 
-			// 5. 录入相关依赖的资源
+			// 5. 录入所有收集资源的依赖资源
 			foreach (var collectAssetInfo in allCollectAssets)
 			{
+				string collectAssetBundleName = collectAssetInfo.BundleName;
 				foreach (var dependAssetPath in collectAssetInfo.DependAssets)
 				{
 					if (buildAssetDic.ContainsKey(dependAssetPath))
 					{
 						buildAssetDic[dependAssetPath].AddBundleTags(collectAssetInfo.AssetTags);
-						buildAssetDic[dependAssetPath].AddReferenceBundleName(collectAssetInfo.BundleName);
+						buildAssetDic[dependAssetPath].AddReferenceBundleName(collectAssetBundleName);
 					}
 					else
 					{
-						var buildAssetInfo = new BuildAssetInfo(ECollectorType.None, dependAssetPath);
+						var buildAssetInfo = new BuildAssetInfo(dependAssetPath);
 						buildAssetInfo.AddBundleTags(collectAssetInfo.AssetTags);
-						buildAssetInfo.AddReferenceBundleName(collectAssetInfo.BundleName);
+						buildAssetInfo.AddReferenceBundleName(collectAssetBundleName);
 						buildAssetDic.Add(dependAssetPath, buildAssetInfo);
 					}
 				}
 			}
-			context.AssetFileCount = buildAssetDic.Count;
 
-			// 6. 填充主动收集资源的依赖列表
+			// 6. 填充所有收集资源的依赖列表
 			foreach (var collectAssetInfo in allCollectAssets)
 			{
 				var dependAssetInfos = new List<BuildAssetInfo>(collectAssetInfo.DependAssets.Count);
@@ -88,13 +89,21 @@ namespace YooAsset.Editor
 				buildAssetDic[collectAssetInfo.AssetPath].SetAllDependAssetInfos(dependAssetInfos);
 			}
 
-			// 7. 计算完整的资源包名
+			// 7. 记录关键信息
+			BuildMapContext context = new BuildMapContext();
+			context.AssetFileCount = buildAssetDic.Count;
+			context.EnableAddressable = buildResult.Command.EnableAddressable;
+			context.UniqueBundleName = buildResult.Command.UniqueBundleName;
+			context.ShadersBundleName = buildResult.ShadersBundleName;
+
+			// 8. 计算共享的资源包名
+			var command = buildResult.Command;
 			foreach (KeyValuePair<string, BuildAssetInfo> pair in buildAssetDic)
 			{
-				pair.Value.CalculateFullBundleName();
+				pair.Value.CalculateShareBundleName(command.UniqueBundleName, command.PackageName, buildResult.ShadersBundleName);
 			}
 
-			// 8. 移除不参与构建的资源
+			// 9. 移除不参与构建的资源
 			List<BuildAssetInfo> removeBuildList = new List<BuildAssetInfo>();
 			foreach (KeyValuePair<string, BuildAssetInfo> pair in buildAssetDic)
 			{
@@ -107,7 +116,7 @@ namespace YooAsset.Editor
 				buildAssetDic.Remove(removeValue.AssetPath);
 			}
 
-			// 9. 构建资源包
+			// 10. 构建资源包
 			var allBuildinAssets = buildAssetDic.Values.ToList();
 			if (allBuildinAssets.Count == 0)
 				throw new Exception("构建的资源列表不能为空");
@@ -129,7 +138,7 @@ namespace YooAsset.Editor
 				}
 			}
 
-			BuildRunner.Log($"发现未被依赖的资源并自动移除 : {dependAssetPath}");
+			BuildLogger.Log($"发现未被依赖的资源并自动移除 : {dependAssetPath}");
 			return true;
 		}
 	}

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,44 +46,52 @@ namespace YooAsset.Editor
 		/// </summary>
 		public BuildTarget BuildTarget;
 
+		/// <summary>
+		/// 构建管线
+		/// </summary>
+		public EBuildPipeline BuildPipeline;
+
 		/// <summary>
 		/// 构建模式
 		/// </summary>
 		public EBuildMode BuildMode;
 
 		/// <summary>
-		/// 构建的版本（资源版本号）
+		/// 构建的包裹名称
 		/// </summary>
-		public int BuildVersion;
+		public string PackageName;
 
 		/// <summary>
-		/// 内置资源的标记列表
+		/// 构建的包裹版本
-		/// 注意：分号为分隔符
 		/// </summary>
-		public string BuildinTags;
+		public string PackageVersion;
 
 
 		/// <summary>
 		/// 验证构建结果
 		/// </summary>
 		public bool VerifyBuildingResult = false;
-
+		
-		/// <summary>
-		/// 启用可寻址资源定位
-		/// </summary>
-		public bool EnableAddressable = false;
-
-		/// <summary>
-		/// 追加文件扩展名
-		/// </summary>
-		public bool AppendFileExtension = false;
-
-
 		/// <summary>
 		/// 加密类
 		/// </summary>
 		public IEncryptionServices EncryptionServices = null;
 
+		/// <summary>
+		/// 补丁文件名称的样式
+		/// </summary>
+		public EOutputNameStyle OutputNameStyle = EOutputNameStyle.HashName;
+
+		/// <summary>
+		/// 拷贝内置资源选项
+		/// </summary>
+		public ECopyBuildinFileOption CopyBuildinFileOption = ECopyBuildinFileOption.None;
+
+		/// <summary>
+		/// 拷贝内置资源的标签
+		/// </summary>
+		public string CopyBuildinFileTags = string.Empty;
+
 		/// <summary>
 		/// 压缩选项
 		/// </summary>
@@ -71,14 +106,5 @@ namespace YooAsset.Editor
 		/// 忽略类型树变化
 		/// </summary>
 		public bool IgnoreTypeTreeChanges = true;
-
-
-		/// <summary>
-		/// 获取内置标记列表
-		/// </summary>
-		public List<string> GetBuildinTags()
-		{
-			return StringUtility.StringToStringList(BuildinTags, ';');
-		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildParametersContext.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class BuildParametersContext : IContextObject
+	{
+		private string _pipelineOutputDirectory = string.Empty;
+		private string _packageOutputDirectory = string.Empty;
+
+		/// <summary>
+		/// 构建参数
+		/// </summary>
+		public BuildParameters Parameters { private set; get; }
+
+
+		public BuildParametersContext(BuildParameters parameters)
+		{
+			Parameters = parameters;
+		}
+
+		/// <summary>
+		/// 获取构建管线的输出目录
+		/// </summary>
+		/// <returns></returns>
+		public string GetPipelineOutputDirectory()
+		{
+			if (string.IsNullOrEmpty(_pipelineOutputDirectory))
+			{
+				_pipelineOutputDirectory = AssetBundleBuilderHelper.MakePipelineOutputDirectory(Parameters.OutputRoot, Parameters.PackageName, Parameters.BuildTarget, Parameters.BuildMode);
+			}
+			return _pipelineOutputDirectory;
+		}
+
+		/// <summary>
+		/// 获取本次构建的补丁目录
+		/// </summary>
+		public string GetPackageOutputDirectory()
+		{
+			if (string.IsNullOrEmpty(_packageOutputDirectory))
+			{
+				_packageOutputDirectory = $"{Parameters.OutputRoot}/{Parameters.PackageName}/{Parameters.BuildTarget}/{Parameters.PackageVersion}";
+			}
+			return _packageOutputDirectory;
+		}
+
+		/// <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 !");
+
+			var targetGroup = BuildPipeline.GetBuildTargetGroup(Parameters.BuildTarget);
+			var pipelineOutputDirectory = GetPipelineOutputDirectory();
+			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;
+
+			buildParams.UseCache = true;
+			buildParams.CacheServerHost = Parameters.SBPParameters.CacheServerHost;
+			buildParams.CacheServerPort = Parameters.SBPParameters.CacheServerPort;
+			buildParams.WriteLinkXML = Parameters.SBPParameters.WriteLinkXML;
+
+			return buildParams;
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: e26f14db9addb4c49b4f0f520bf75d9d
+guid: b84510feab7cbe44a9b6d8ef0b3f559c
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.IO;
 using UnityEngine;
 
 namespace YooAsset.Editor
@@ -56,6 +57,9 @@ namespace YooAsset.Editor
 
 		public static void Serialize(string savePath, BuildReport buildReport)
 		{
+			if (File.Exists(savePath))
+				File.Delete(savePath);
+
 			string json = JsonUtility.ToJson(buildReport, true);
 			FileUtility.CreateFile(savePath, json);
 		}

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

@@ -8,40 +8,40 @@ 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 Hash;
+		public string FileName;
+
+		/// <summary>
+		/// 文件哈希值
+		/// </summary>
+		public string FileHash;
 
 		/// <summary>
 		/// 文件校验码
 		/// </summary>
-		public string CRC;
+		public string FileCRC;
 
 		/// <summary>
 		/// 文件大小（字节数）
 		/// </summary>
-		public long SizeBytes;
+		public long FileSize;
+
+		/// <summary>
+		/// 是否为原生文件
+		/// </summary>
+		public bool IsRawFile;
+
+		/// <summary>
+		/// 加载方法
+		/// </summary>
+		public EBundleLoadMethod LoadMethod;
 
 		/// <summary>
 		/// Tags
@@ -49,26 +49,9 @@ namespace YooAsset.Editor
 		public string[] Tags;
 
 		/// <summary>
-		/// Flags
+		/// 引用该资源包的ID列表
 		/// </summary>
-		public int Flags;
+		public int[] ReferenceIDs;
-
-
-		/// <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>
 		/// 获取资源分类标签的字符串
@@ -80,16 +63,5 @@ 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,20 +33,25 @@ namespace YooAsset.Editor
 		/// </summary>
 		public BuildTarget BuildTarget;
 
+		/// <summary>
+		/// 构建管线
+		/// </summary>
+		public EBuildPipeline BuildPipeline;
+
 		/// <summary>
 		/// 构建模式
 		/// </summary>
 		public EBuildMode BuildMode;
 
 		/// <summary>
-		/// 构建版本
+		/// 构建包裹名称
 		/// </summary>
-		public int BuildVersion;
+		public string BuildPackageName;
 
 		/// <summary>
-		/// 内置资源标签
+		/// 构建包裹版本
 		/// </summary>
-		public string BuildinTags;
+		public string BuildPackageVersion;
 
 		/// <summary>
 		/// 启用可寻址资源定位
@@ -49,19 +59,9 @@ namespace YooAsset.Editor
 		public bool EnableAddressable;
 
 		/// <summary>
-		/// 追加文件扩展名
+		/// 资源包名唯一化
 		/// </summary>
-		public bool AppendFileExtension;
+		public bool UniqueBundleName;
-
-		/// <summary>
-		/// 自动收集着色器
-		/// </summary>
-		public bool AutoCollectShaders;
-
-		/// <summary>
-		/// 自动收集的着色器资源包名称
-		/// </summary>
-		public string ShadersBundleName;
 
 		/// <summary>
 		/// 加密服务类名称
@@ -69,16 +69,16 @@ namespace YooAsset.Editor
 		public string EncryptionServicesClassName;
 
 		// 构建参数
+		public EOutputNameStyle OutputNameStyle;
 		public ECompressOption CompressOption;
 		public bool DisableWriteTypeTree;
 		public bool IgnoreTypeTreeChanges;
 
 		// 构建结果
 		public int AssetFileTotalCount;
+		public int MainAssetTotalCount;
 		public int AllBundleTotalCount;
 		public long AllBundleTotalSize;
-		public int BuildinBundleTotalCount;
-		public long BuildinBundleTotalSize;
 		public int EncryptedBundleTotalCount;
 		public long EncryptedBundleTotalSize;
 		public int RawBundleTotalCount;

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

@@ -0,0 +1,30 @@
+
+namespace YooAsset.Editor
+{
+	public static class BuildLogger
+	{
+		/// <summary>
+		/// 是否启用LOG
+		/// </summary>
+		public static bool EnableLog = true;
+
+		/// <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/BuildSystem/BuildLogger.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 4eff45040ac501b4fa978c46f72f2e64
+guid: 2bc82466a51f50141975e4424095aa09
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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

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

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: e39f1b67d310bb54e8b1220bcf06afc4
+guid: e0855c4b5eaa26942bd7ad177fe3c288
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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

@@ -2,65 +2,69 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Diagnostics;
 using UnityEngine;
 
 namespace YooAsset.Editor
 {
 	public class BuildRunner
 	{
-		public static bool EnableLog = true;
+		private static Stopwatch _buildWatch;
+
+		/// <summary>
+		/// 总耗时
+		/// </summary>
+		public static int TotalSeconds = 0;
 
 		/// <summary>
 		/// 执行构建流程
 		/// </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;
+			TotalSeconds = 0;
 			for (int i = 0; i < pipeline.Count; i++)
 			{
 				IBuildTask task = pipeline[i];
 				try
 				{
+					_buildWatch = Stopwatch.StartNew();
 					var taskAttribute = task.GetType().GetCustomAttribute<TaskAttribute>();
-					Log($"---------------------------------------->{taskAttribute.Desc}");
+					BuildLogger.Log($"---------------------------------------->{taskAttribute.Desc}<---------------------------------------");
 					task.Run(context);
+					_buildWatch.Stop();
+
+					// 统计耗时
+					int seconds = GetBuildSeconds();
+					TotalSeconds += seconds;
+					BuildLogger.Log($"{taskAttribute.Desc}耗时：{seconds}秒");
 				}
 				catch (Exception e)
 				{
-					Debug.LogError($"Build task {task.GetType().Name} failed !");
+					EditorTools.ClearProgressBar();
-					Debug.LogError($"Build error : {e}");
+					buildResult.FailedTask = task.GetType().Name;
-					succeed = false;
+					buildResult.FailedInfo = e.ToString();
+					buildResult.Success = false;
 					break;
 				}
 			}
 
 			// 返回运行结果
-			return succeed;
+			BuildLogger.Log($"构建过程总计耗时：{TotalSeconds}秒");
+			return buildResult;
 		}
 
-		/// <summary>
+		private static int GetBuildSeconds()
-		/// 日志输出
-		/// </summary>
-		public static void Log(string info)
 		{
-			if (EnableLog)
+			float seconds = _buildWatch.ElapsedMilliseconds / 1000f;
-			{
+			return (int)seconds;
-				UnityEngine.Debug.Log(info);
-			}
-		}
-
-		/// <summary>
-		/// 日志输出
-		/// </summary>
-		public static void Info(string info)
-		{
-			UnityEngine.Debug.Log(info);
 		}
 	}
 }

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

@@ -0,0 +1,52 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor.Build.Pipeline;
+using UnityEditor.Build.Pipeline.Interfaces;
+
+namespace UnityEditor.Build.Pipeline.Tasks
+{
+	public static class SBPBuildTasks
+	{
+		public static IList<IBuildTask> Create(string builtInShaderBundleName)
+		{
+			var buildTasks = new List<IBuildTask>();
+			
+			// Setup
+			buildTasks.Add(new SwitchToBuildPlatform());
+			buildTasks.Add(new RebuildSpriteAtlasCache());
+
+			// Player Scripts
+			buildTasks.Add(new BuildPlayerScripts());
+			buildTasks.Add(new PostScriptsCallback());
+
+			// Dependency
+			buildTasks.Add(new CalculateSceneDependencyData());
+#if UNITY_2019_3_OR_NEWER
+			buildTasks.Add(new CalculateCustomDependencyData());
+#endif
+			buildTasks.Add(new CalculateAssetDependencyData());
+			buildTasks.Add(new StripUnusedSpriteSources());
+			buildTasks.Add(new CreateBuiltInShadersBundle(builtInShaderBundleName));
+			buildTasks.Add(new PostDependencyCallback());
+
+			// Packing
+			buildTasks.Add(new GenerateBundlePacking());
+			buildTasks.Add(new UpdateBundleObjectLayout());
+			buildTasks.Add(new GenerateBundleCommands());
+			buildTasks.Add(new GenerateSubAssetPathMaps());
+			buildTasks.Add(new GenerateBundleMaps());
+			buildTasks.Add(new PostPackingCallback());
+
+			// Writing
+			buildTasks.Add(new WriteSerializedFiles());
+			buildTasks.Add(new ArchiveAndCompressBundles());
+			buildTasks.Add(new AppendBundleHash());
+			buildTasks.Add(new GenerateLinkXml());
+			buildTasks.Add(new PostWritingCallback());
+
+			return buildTasks;
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 057a358d2d0c92b47add59dac8bef783
+guid: f38422f6a64300243af6b4fbf84644ba
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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;
@@ -11,14 +10,14 @@ namespace YooAsset.Editor
 	[TaskAttribute("资源构建内容打包")]
 	public class TaskBuilding : IBuildTask
 	{
-		public class UnityManifestContext : IContextObject
+		public class BuildResultContext : IContextObject
 		{
 			public AssetBundleManifest UnityManifest;
 		}
 
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParametersContext = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
 
 			// 模拟构建模式下跳过引擎构建
@@ -26,40 +25,26 @@ namespace YooAsset.Editor
 			if (buildMode == EBuildMode.SimulateBuild)
 				return;
 
-			BuildAssetBundleOptions opt = buildParametersContext.GetPipelineBuildOptions();
+			// 开始构建
-			AssetBundleManifest unityManifest = BuildPipeline.BuildAssetBundles(buildParametersContext.PipelineOutputDirectory, buildMapContext.GetPipelineBuilds(), opt, buildParametersContext.Parameters.BuildTarget);
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
-			if (unityManifest == null)
+			BuildAssetBundleOptions buildOptions = buildParametersContext.GetPipelineBuildOptions();
+			AssetBundleManifest buildResults = BuildPipeline.BuildAssetBundles(pipelineOutputDirectory, buildMapContext.GetPipelineBuilds(), buildOptions, buildParametersContext.Parameters.BuildTarget);
+			if (buildResults == null)
+			{
 				throw new Exception("构建过程中发生错误！");
+			}
 
-			BuildRunner.Log("Unity引擎打包成功！");
-			UnityManifestContext unityManifestContext = new UnityManifestContext();
-			unityManifestContext.UnityManifest = unityManifest;
-			context.SetContextObject(unityManifestContext);
-
-			// 拷贝原生文件
 			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
 			{
-				CopyRawBundle(buildMapContext, buildParametersContext);
+				string unityOutputManifestFilePath = $"{pipelineOutputDirectory}/{YooAssetSettings.OutputFolderName}";
+				if (System.IO.File.Exists(unityOutputManifestFilePath) == false)
+					throw new Exception("构建过程中发生严重错误！请查阅上下文日志！");
 			}
-		}
 
-		/// <summary>
+			BuildLogger.Log("Unity引擎打包成功！");
-		/// 拷贝原生文件
+			BuildResultContext buildResultContext = new BuildResultContext();
-		/// </summary>
+			buildResultContext.UnityManifest = buildResults;
-		private void CopyRawBundle(BuildMapContext buildMapContext, AssetBundleBuilder.BuildParametersContext buildParametersContext)
+			context.SetContextObject(buildResultContext);
-		{
-			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

@@ -0,0 +1,49 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+
+using UnityEditor.Build.Pipeline;
+using UnityEditor.Build.Pipeline.Interfaces;
+using UnityEditor.Build.Pipeline.Tasks;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("资源构建内容打包")]
+	public class TaskBuilding_SBP : IBuildTask
+	{
+		public class BuildResultContext : 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 = SBPBuildTasks.Create(buildMapContext.ShadersBundleName);
+			ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out buildResults, taskList);
+			if (exitCode < 0)
+			{
+				throw new Exception($"构建过程中发生错误 : {exitCode}");
+			}
+
+			BuildLogger.Log("Unity引擎打包成功！");
+			BuildResultContext buildResultContext = new BuildResultContext();
+			buildResultContext.Results = buildResults;
+			context.SetContextObject(buildResultContext);
+		}
+	}
+}

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

@@ -11,58 +11,90 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			// 注意：我们只有在强制重建的时候才会拷贝
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var patchManifestContext = context.GetContextObject<PatchManifestContext>();
-			if (buildParameters.Parameters.BuildMode == EBuildMode.ForceRebuild)
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
 			{
-				// 清空流目录
+				if (buildParametersContext.Parameters.CopyBuildinFileOption != ECopyBuildinFileOption.None)
-				AssetBundleBuilderHelper.ClearStreamingAssetsFolder();
+				{
-
+					CopyBuildinFilesToStreaming(buildParametersContext, patchManifestContext);
-				// 拷贝内置文件
+				}
-				CopyBuildinFilesToStreaming(buildParameters.PipelineOutputDirectory, buildParameters.Parameters.BuildVersion);
 			}
 		}
 
-		private void CopyBuildinFilesToStreaming(string pipelineOutputDirectory, int buildVersion)
+		/// <summary>
+		/// 拷贝首包资源文件
+		/// </summary>
+		private void CopyBuildinFilesToStreaming(BuildParametersContext buildParametersContext, PatchManifestContext patchManifestContext)
 		{
+			ECopyBuildinFileOption option = buildParametersContext.Parameters.CopyBuildinFileOption;
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			string streamingAssetsDirectory = AssetBundleBuilderHelper.GetStreamingAssetsFolderPath();
+			string buildPackageName = buildParametersContext.Parameters.PackageName;
+			string buildPackageVersion = buildParametersContext.Parameters.PackageVersion;
+
 			// 加载补丁清单
-			PatchManifest patchManifest = AssetBundleBuilderHelper.LoadPatchManifestFile(pipelineOutputDirectory, buildVersion);
+			PatchManifest patchManifest = patchManifestContext.Manifest;
 
-			// 拷贝文件列表
+			// 清空流目录
-			foreach (var patchBundle in patchManifest.BundleList)
+			if (option == ECopyBuildinFileOption.ClearAndCopyAll || option == ECopyBuildinFileOption.ClearAndCopyByTags)
 			{
-				if (patchBundle.IsBuildin == false)
+				AssetBundleBuilderHelper.ClearStreamingAssetsFolder();
-					continue;
+			}
 
-				string sourcePath = $"{pipelineOutputDirectory}/{patchBundle.BundleName}";
+			// 拷贝补丁清单文件
-				string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsFolderPath()}/{patchBundle.Hash}";
+			{
+				string fileName = YooAssetSettingsData.GetManifestBinaryFileName(buildPackageName, buildPackageVersion);
+				string sourcePath = $"{packageOutputDirectory}/{fileName}";
+				string destPath = $"{streamingAssetsDirectory}/{fileName}";
 				EditorTools.CopyFile(sourcePath, destPath, true);
 			}
 
-			// 拷贝清单文件
+			// 拷贝补丁清单哈希文件
 			{
-				string sourcePath = $"{pipelineOutputDirectory}/{YooAssetSettingsData.GetPatchManifestFileName(buildVersion)}";
+				string fileName = YooAssetSettingsData.GetPackageHashFileName(buildPackageName, buildPackageVersion);
-				string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsFolderPath()}/{YooAssetSettingsData.GetPatchManifestFileName(buildVersion)}";
+				string sourcePath = $"{packageOutputDirectory}/{fileName}";
+				string destPath = $"{streamingAssetsDirectory}/{fileName}";
 				EditorTools.CopyFile(sourcePath, destPath, true);
 			}
 
-			// 拷贝清单哈希文件
+			// 拷贝补丁清单版本文件
 			{
-				string sourcePath = $"{pipelineOutputDirectory}/{YooAssetSettingsData.GetPatchManifestHashFileName(buildVersion)}";
+				string fileName = YooAssetSettingsData.GetPackageVersionFileName(buildPackageName);
-				string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsFolderPath()}/{YooAssetSettingsData.GetPatchManifestHashFileName(buildVersion)}";
+				string sourcePath = $"{packageOutputDirectory}/{fileName}";
+				string destPath = $"{streamingAssetsDirectory}/{fileName}";
 				EditorTools.CopyFile(sourcePath, destPath, true);
 			}
 
-			// 拷贝静态版本文件
+			// 拷贝文件列表（所有文件）
+			if (option == ECopyBuildinFileOption.ClearAndCopyAll || option == ECopyBuildinFileOption.OnlyCopyAll)
+			{		
+				foreach (var patchBundle in patchManifest.BundleList)
+				{
+					string sourcePath = $"{packageOutputDirectory}/{patchBundle.FileName}";
+					string destPath = $"{streamingAssetsDirectory}/{patchBundle.FileName}";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
+			}
+
+			// 拷贝文件列表（带标签的文件）
+			if (option == ECopyBuildinFileOption.ClearAndCopyByTags || option == ECopyBuildinFileOption.OnlyCopyByTags)
 			{
-				string sourcePath = $"{pipelineOutputDirectory}/{YooAssetSettings.VersionFileName}";
+				string[] tags = buildParametersContext.Parameters.CopyBuildinFileTags.Split(';');
-				string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsFolderPath()}/{YooAssetSettings.VersionFileName}";
+				foreach (var patchBundle in patchManifest.BundleList)
-				EditorTools.CopyFile(sourcePath, destPath, true);
+				{
+					if (patchBundle.HasTag(tags) == false)
+						continue;
+					string sourcePath = $"{packageOutputDirectory}/{patchBundle.FileName}";
+					string destPath = $"{streamingAssetsDirectory}/{patchBundle.FileName}";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
 			}
 
 			// 刷新目录
 			AssetDatabase.Refresh();
-			BuildRunner.Log($"内置文件拷贝完成：{AssetBundleBuilderHelper.GetStreamingAssetsFolderPath()}");
+			BuildLogger.Log($"内置文件拷贝完成：{streamingAssetsDirectory}");
 		}
 	}
 }

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

@@ -0,0 +1,44 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("拷贝原生文件")]
+	public class TaskCopyRawFile : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
+			{
+				CopyRawBundle(buildMapContext, buildParametersContext);
+			}
+		}
+
+		/// <summary>
+		/// 拷贝原生文件
+		/// </summary>
+		private void CopyRawBundle(BuildMapContext buildMapContext, BuildParametersContext buildParametersContext)
+		{
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
+			foreach (var bundleInfo in buildMapContext.BundleInfos)
+			{
+				if (bundleInfo.IsRawFile)
+				{
+					string dest = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
+					foreach (var buildAsset in bundleInfo.BuildinAssets)
+					{
+						if (buildAsset.IsRawAsset)
+							EditorTools.CopyFile(buildAsset.AssetPath, dest, true);
+					}
+				}
+			}
+		}
+	}
+}

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

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

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

@@ -1,134 +1,139 @@
 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
 {
+	public class PatchManifestContext : IContextObject
+	{
+		internal PatchManifest Manifest;
+	}
+
 	[TaskAttribute("创建补丁清单文件")]
 	public class TaskCreatePatchManifest : IBuildTask
 	{
 		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)
 		{
-			int resourceVersion = buildParameters.Parameters.BuildVersion;
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = buildParametersContext.Parameters;
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
 
 			// 创建新补丁清单
 			PatchManifest patchManifest = new PatchManifest();
-			patchManifest.EnableAddressable = buildParameters.Parameters.EnableAddressable;
+			patchManifest.FileVersion = YooAssetSettings.PatchManifestFileVersion;
-			patchManifest.ResourceVersion = buildParameters.Parameters.BuildVersion;
+			patchManifest.EnableAddressable = buildMapContext.EnableAddressable;
-			patchManifest.BuildinTags = buildParameters.Parameters.BuildinTags;
+			patchManifest.OutputNameStyle = (int)buildParameters.OutputNameStyle;
-			patchManifest.BundleList = GetAllPatchBundle(buildParameters, buildMapContext, encryptionContext);
+			patchManifest.PackageName = buildParameters.PackageName;
-			patchManifest.AssetList = GetAllPatchAsset(buildParameters, buildMapContext, patchManifest);
+			patchManifest.PackageVersion = buildParameters.PackageVersion;
+			patchManifest.BundleList = GetAllPatchBundle(context);
+			patchManifest.AssetList = GetAllPatchAsset(context, patchManifest);
 
-			// 创建补丁清单文件
+			// 更新Unity内置资源包的引用关系
-			string manifestFilePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.GetPatchManifestFileName(resourceVersion)}";
+			if (buildParameters.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
-			BuildRunner.Log($"创建补丁清单文件：{manifestFilePath}");
+			{
-			PatchManifest.Serialize(manifestFilePath, patchManifest);
+				if (buildParameters.BuildMode == EBuildMode.IncrementalBuild)
+				{
+					var buildResultContext = context.GetContextObject<TaskBuilding_SBP.BuildResultContext>();
+					UpdateBuiltInBundleReference(patchManifest, buildResultContext, buildMapContext.ShadersBundleName);
+				}
+			}
+
+			// 更新资源包之间的引用关系
+			if (buildParameters.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
+			{
+				if (buildParameters.BuildMode == EBuildMode.IncrementalBuild)
+				{
+					var buildResultContext = context.GetContextObject<TaskBuilding_SBP.BuildResultContext>();
+					UpdateScriptPipelineReference(patchManifest, buildResultContext);
+				}
+			}
+
+			// 更新资源包之间的引用关系
+			if (buildParameters.BuildPipeline == EBuildPipeline.BuiltinBuildPipeline)
+			{
+				if (buildParameters.BuildMode != EBuildMode.SimulateBuild)
+				{
+					var buildResultContext = context.GetContextObject<TaskBuilding.BuildResultContext>();
+					UpdateBuiltinPipelineReference(patchManifest, buildResultContext);
+				}
+			}
+
+			// 创建补丁清单文本文件
+			{
+				string fileName = YooAssetSettingsData.GetManifestJsonFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+				string filePath = $"{packageOutputDirectory}/{fileName}";
+				PatchManifestTools.SerializeToJson(filePath, patchManifest);
+				BuildLogger.Log($"创建补丁清单文件：{filePath}");
+			}
+
+			// 创建补丁清单二进制文件
+			string packageHash;
+			{
+				string fileName = YooAssetSettingsData.GetManifestBinaryFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+				string filePath = $"{packageOutputDirectory}/{fileName}";
+				PatchManifestTools.SerializeToBinary(filePath, patchManifest);
+				packageHash = HashUtility.FileMD5(filePath);
+				BuildLogger.Log($"创建补丁清单文件：{filePath}");
+
+				PatchManifestContext patchManifestContext = new PatchManifestContext();
+				byte[] bytesData = FileUtility.ReadAllBytes(filePath);
+				patchManifestContext.Manifest = PatchManifestTools.DeserializeFromBinary(bytesData);
+				context.SetContextObject(patchManifestContext);
+			}
 
 			// 创建补丁清单哈希文件
-			string manifestHashFilePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.GetPatchManifestHashFileName(resourceVersion)}";
+			{
-			string manifestHash = HashUtility.FileMD5(manifestFilePath);
+				string fileName = YooAssetSettingsData.GetPackageHashFileName(buildParameters.PackageName, buildParameters.PackageVersion);
-			BuildRunner.Log($"创建补丁清单哈希文件：{manifestHashFilePath}");
+				string filePath = $"{packageOutputDirectory}/{fileName}";
-			FileUtility.CreateFile(manifestHashFilePath, manifestHash);
+				FileUtility.CreateFile(filePath, packageHash);
+				BuildLogger.Log($"创建补丁清单哈希文件：{filePath}");
+			}
 
-			// 创建静态版本文件
+			// 创建补丁清单版本文件
-			string staticVersionFilePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettings.VersionFileName}";
+			{
-			string staticVersion = resourceVersion.ToString();
+				string fileName = YooAssetSettingsData.GetPackageVersionFileName(buildParameters.PackageName);
-			BuildRunner.Log($"创建静态版本文件：{staticVersionFilePath}");
+				string filePath = $"{packageOutputDirectory}/{fileName}";
-			FileUtility.CreateFile(staticVersionFilePath, staticVersion);
+				FileUtility.CreateFile(filePath, buildParameters.PackageVersion);
+				BuildLogger.Log($"创建补丁清单版本文件：{filePath}");
+			}
 		}
 
 		/// <summary>
 		/// 获取资源包列表
 		/// </summary>
-		private List<PatchBundle> GetAllPatchBundle(AssetBundleBuilder.BuildParametersContext buildParameters,
+		private List<PatchBundle> GetAllPatchBundle(BuildContext context)
-			BuildMapContext buildMapContext, TaskEncryption.EncryptionContext encryptionContext)
 		{
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+
 			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)
 			{
-				var bundleName = bundleInfo.BundleName;
+				var patchBundle = bundleInfo.CreatePatchBundle();
-				string filePath = $"{buildParameters.PipelineOutputDirectory}/{bundleName}";
-				string hash = GetFileHash(filePath, standardBuild);
-				string crc32 = GetFileCRC(filePath, standardBuild);
-				long size = GetFileSize(filePath, standardBuild);
-				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);
 			}
-
 			return result;
 		}
-		private bool IsBuildinBundle(string[] bundleTags, List<string> buildinTags)
-		{
-			// 注意：没有任何标记的Bundle文件默认为内置文件
-			if (bundleTags.Length == 0)
-				return true;
-
-			foreach (var tag in bundleTags)
-			{
-				if (buildinTags.Contains(tag))
-					return true;
-			}
-			return false;
-		}
-		private string GetFileHash(string filePath, bool standardBuild)
-		{
-			if (standardBuild)
-				return HashUtility.FileMD5(filePath);
-			else
-				return "00000000000000000000000000000000"; //32位
-		}
-		private string GetFileCRC(string filePath, bool standardBuild)
-		{
-			if (standardBuild)
-				return HashUtility.FileCRC32(filePath);
-			else
-				return "00000000"; //8位
-		}
-		private long GetFileSize(string filePath, bool standardBuild)
-		{
-			if (standardBuild)
-				return FileUtility.GetFileSize(filePath);
-			else
-				return 0;
-		}
 
 		/// <summary>
 		/// 获取资源列表
 		/// </summary>
-		private List<PatchAsset> GetAllPatchAsset(AssetBundleBuilder.BuildParametersContext buildParameters,
+		private List<PatchAsset> GetAllPatchAsset(BuildContext context, PatchManifest patchManifest)
-			BuildMapContext buildMapContext, PatchManifest patchManifest)
 		{
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+
 			List<PatchAsset> result = new List<PatchAsset>(1000);
 			foreach (var bundleInfo in buildMapContext.BundleInfos)
 			{
@@ -136,13 +141,13 @@ namespace YooAsset.Editor
 				foreach (var assetInfo in assetInfos)
 				{
 					PatchAsset patchAsset = new PatchAsset();
-					if (buildParameters.Parameters.EnableAddressable)
+					if (buildMapContext.EnableAddressable)
 						patchAsset.Address = assetInfo.Address;
 					else
 						patchAsset.Address = string.Empty;
 					patchAsset.AssetPath = assetInfo.AssetPath;
 					patchAsset.AssetTags = assetInfo.AssetTags.ToArray();
-					patchAsset.BundleID = GetAssetBundleID(assetInfo.GetBundleName(), patchManifest);
+					patchAsset.BundleID = GetAssetBundleID(assetInfo.BundleName, patchManifest);
 					patchAsset.DependIDs = GetAssetBundleDependIDs(patchAsset.BundleID, assetInfo, patchManifest);
 					result.Add(patchAsset);
 				}
@@ -156,7 +161,7 @@ namespace YooAsset.Editor
 			{
 				if (dependAssetInfo.HasBundleName())
 				{
-					int bundleID = GetAssetBundleID(dependAssetInfo.GetBundleName(), patchManifest);
+					int bundleID = GetAssetBundleID(dependAssetInfo.BundleName, patchManifest);
 					if (mainBundleID != bundleID)
 					{
 						if (result.Contains(bundleID) == false)
@@ -175,5 +180,180 @@ namespace YooAsset.Editor
 			}
 			throw new Exception($"Not found bundle name : {bundleName}");
 		}
+
+		/// <summary>
+		/// 更新Unity内置资源包的引用关系
+		/// </summary>
+		private void UpdateBuiltInBundleReference(PatchManifest patchManifest, TaskBuilding_SBP.BuildResultContext buildResultContext, string shadersBunldeName)
+		{
+			// 获取所有依赖着色器资源包的资源包列表
+			List<string> shaderBundleReferenceList = new List<string>();
+			foreach (var valuePair in buildResultContext.Results.BundleInfos)
+			{
+				if (valuePair.Value.Dependencies.Any(t => t == shadersBunldeName))
+					shaderBundleReferenceList.Add(valuePair.Key);
+			}
+
+			// 注意：没有任何资源依赖着色器
+			if (shaderBundleReferenceList.Count == 0)
+				return;
+
+			// 获取着色器资源包索引
+			Predicate<PatchBundle> predicate = new Predicate<PatchBundle>(s => s.BundleName == shadersBunldeName);
+			int shaderBundleId = patchManifest.BundleList.FindIndex(predicate);
+			if (shaderBundleId == -1)
+				throw new Exception("没有发现着色器资源包！");
+
+			// 检测依赖交集并更新依赖ID
+			foreach (var patchAsset in patchManifest.AssetList)
+			{
+				List<string> dependBundles = GetPatchAssetAllDependBundles(patchManifest, patchAsset);
+				List<string> conflictAssetPathList = dependBundles.Intersect(shaderBundleReferenceList).ToList();
+				if (conflictAssetPathList.Count > 0)
+				{
+					List<int> newDependIDs = new List<int>(patchAsset.DependIDs);
+					if (newDependIDs.Contains(shaderBundleId) == false)
+						newDependIDs.Add(shaderBundleId);
+					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;
+		}
+
+		#region 资源包引用关系相关
+		private readonly Dictionary<string, int> _cachedBundleID = new Dictionary<string, int>(10000);
+		private readonly Dictionary<string, string[]> _cachedBundleDepends = new Dictionary<string, string[]>(10000);
+
+		private void UpdateScriptPipelineReference(PatchManifest patchManifest, TaskBuilding_SBP.BuildResultContext buildResultContext)
+		{
+			int progressValue;
+			int totalCount = patchManifest.BundleList.Count;
+
+			// 缓存资源包ID
+			_cachedBundleID.Clear();
+			progressValue = 0;
+			foreach (var patchBundle in patchManifest.BundleList)
+			{
+				int bundleID = GetAssetBundleID(patchBundle.BundleName, patchManifest);
+				_cachedBundleID.Add(patchBundle.BundleName, bundleID);
+				EditorTools.DisplayProgressBar("缓存资源包索引", ++progressValue, totalCount);
+			}
+			EditorTools.ClearProgressBar();
+
+			// 缓存资源包依赖
+			_cachedBundleDepends.Clear();
+			progressValue = 0;
+			foreach (var patchBundle in patchManifest.BundleList)
+			{
+				if (patchBundle.IsRawFile)
+					continue;
+
+				if (buildResultContext.Results.BundleInfos.ContainsKey(patchBundle.BundleName) == false)
+					throw new Exception($"Not found bundle in SBP build results : {patchBundle.BundleName}");
+
+				var depends = buildResultContext.Results.BundleInfos[patchBundle.BundleName].Dependencies;
+				_cachedBundleDepends.Add(patchBundle.BundleName, depends);
+				EditorTools.DisplayProgressBar("缓存资源包依赖列表", ++progressValue, totalCount);
+			}
+			EditorTools.ClearProgressBar();
+
+			// 计算资源包引用列表
+			foreach (var patchBundle in patchManifest.BundleList)
+			{
+				patchBundle.ReferenceIDs = GetBundleRefrenceIDs(patchManifest, patchBundle);
+				EditorTools.DisplayProgressBar("计算资源包引用关系", ++progressValue, totalCount);
+			}
+			EditorTools.ClearProgressBar();
+		}
+		private void UpdateBuiltinPipelineReference(PatchManifest patchManifest, TaskBuilding.BuildResultContext buildResultContext)
+		{
+			int progressValue;
+			int totalCount = patchManifest.BundleList.Count;
+
+			// 缓存资源包ID
+			_cachedBundleID.Clear();
+			progressValue = 0;
+			foreach (var patchBundle in patchManifest.BundleList)
+			{
+				int bundleID = GetAssetBundleID(patchBundle.BundleName, patchManifest);
+				_cachedBundleID.Add(patchBundle.BundleName, bundleID);
+				EditorTools.DisplayProgressBar("缓存资源包索引", ++progressValue, totalCount);
+			}
+			EditorTools.ClearProgressBar();
+
+			// 缓存资源包依赖
+			_cachedBundleDepends.Clear();
+			progressValue = 0;
+			foreach (var patchBundle in patchManifest.BundleList)
+			{
+				var depends = buildResultContext.UnityManifest.GetDirectDependencies(patchBundle.BundleName);
+				_cachedBundleDepends.Add(patchBundle.BundleName, depends);
+				EditorTools.DisplayProgressBar("缓存资源包依赖列表", ++progressValue, totalCount);
+			}
+			EditorTools.ClearProgressBar();
+
+			// 计算资源包引用列表
+			progressValue = 0;
+			foreach (var patchBundle in patchManifest.BundleList)
+			{
+				patchBundle.ReferenceIDs = GetBundleRefrenceIDs(patchManifest, patchBundle);
+				EditorTools.DisplayProgressBar("计算资源包引用关系", ++progressValue, totalCount);
+			}
+			EditorTools.ClearProgressBar();
+		}
+		
+		private int[] GetBundleRefrenceIDs(PatchManifest patchManifest, PatchBundle targetBundle)
+		{
+			List<string> referenceList = new List<string>();
+			foreach (var patchBundle in patchManifest.BundleList)
+			{
+				string bundleName = patchBundle.BundleName;
+				if (bundleName == targetBundle.BundleName)
+					continue;
+
+				string[] dependencies = GetCachedBundleDepends(bundleName);
+				if (dependencies.Contains(targetBundle.BundleName))
+				{
+					referenceList.Add(bundleName);
+				}
+			}
+
+			List<int> result = new List<int>();
+			foreach (var bundleName in referenceList)
+			{
+				int bundleID = GetCachedBundleID(bundleName);
+				if (result.Contains(bundleID) == false)
+					result.Add(bundleID);
+			}
+			return result.ToArray();
+		}
+		private int GetCachedBundleID(string bundleName)
+		{
+			if (_cachedBundleID.TryGetValue(bundleName, out int value) == false)
+			{
+				throw new Exception($"Not found cached bundle ID : {bundleName}");
+			}
+			return value;
+		}
+		private string[] GetCachedBundleDepends(string bundleName)
+		{
+			if (_cachedBundleDepends.TryGetValue(bundleName, out string[] value) == false)
+			{
+				throw new Exception($"Not found cached bundle depends : {bundleName}");
+			}
+			return value;
+		}
+		#endregion
 	}
 }

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

@@ -8,75 +8,69 @@ 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;
 			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
 			{
-				CopyPatchFiles(buildParameters);
+				CopyPatchFiles(buildParameters, buildMapContext);
 			}
 		}
 
 		/// <summary>
 		/// 拷贝补丁文件到补丁包目录
 		/// </summary>
-		private void CopyPatchFiles(AssetBundleBuilder.BuildParametersContext buildParameters)
+		private void CopyPatchFiles(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext)
 		{
-			int resourceVersion = buildParameters.Parameters.BuildVersion;
+			var buildParameters = buildParametersContext.Parameters;
-			string packageDirectory = buildParameters.GetPackageDirectory();
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
-			BuildRunner.Log($"开始拷贝补丁文件到补丁包目录：{packageDirectory}");
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			BuildLogger.Log($"开始拷贝补丁文件到补丁包目录：{packageOutputDirectory}");
 
-			// 拷贝Report文件
+			if (buildParameters.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
 			{
-				string reportFileName = YooAssetSettingsData.GetReportFileName(buildParameters.Parameters.BuildVersion);
+				// 拷贝构建日志
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{reportFileName}";
+				{
-				string destPath = $"{packageDirectory}/{reportFileName}";
+					string sourcePath = $"{pipelineOutputDirectory}/buildlogtep.json";
-				EditorTools.CopyFile(sourcePath, destPath, true);
+					string destPath = $"{packageOutputDirectory}/buildlogtep.json";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
+
+				// 拷贝代码防裁剪配置
+				if (buildParameters.SBPParameters.WriteLinkXML)
+				{
+					string sourcePath = $"{pipelineOutputDirectory}/link.xml";
+					string destPath = $"{packageOutputDirectory}/link.xml";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
 			}
-
+			else if (buildParameters.BuildPipeline == EBuildPipeline.BuiltinBuildPipeline)
-			// 拷贝补丁清单文件
 			{
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.GetPatchManifestFileName(resourceVersion)}";
+				// 拷贝UnityManifest序列化文件
-				string destPath = $"{packageDirectory}/{YooAssetSettingsData.GetPatchManifestFileName(resourceVersion)}";
+				{
-				EditorTools.CopyFile(sourcePath, destPath, true);
+					string sourcePath = $"{pipelineOutputDirectory}/{YooAssetSettings.OutputFolderName}";
+					string destPath = $"{packageOutputDirectory}/{YooAssetSettings.OutputFolderName}";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
+
+				// 拷贝UnityManifest文本文件
+				{
+					string sourcePath = $"{pipelineOutputDirectory}/{YooAssetSettings.OutputFolderName}.manifest";
+					string destPath = $"{packageOutputDirectory}/{YooAssetSettings.OutputFolderName}.manifest";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
 			}
-
+			else
-			// 拷贝补丁清单哈希文件
 			{
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.GetPatchManifestHashFileName(resourceVersion)}";
+				throw new System.NotImplementedException();
-				string destPath = $"{packageDirectory}/{YooAssetSettingsData.GetPatchManifestHashFileName(resourceVersion)}";
-				EditorTools.CopyFile(sourcePath, destPath, true);
-			}
-
-			// 拷贝静态版本文件
-			{
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettings.VersionFileName}";
-				string destPath = $"{packageDirectory}/{YooAssetSettings.VersionFileName}";
-				EditorTools.CopyFile(sourcePath, destPath, true);
-			}
-
-			// 拷贝UnityManifest序列化文件
-			{
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.Setting.UnityManifestFileName}";
-				string destPath = $"{packageDirectory}/{YooAssetSettingsData.Setting.UnityManifestFileName}";
-				EditorTools.CopyFile(sourcePath, destPath, true);
-			}
-
-			// 拷贝UnityManifest文本文件
-			{
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.Setting.UnityManifestFileName}.manifest";
-				string destPath = $"{packageDirectory}/{YooAssetSettingsData.Setting.UnityManifestFileName}.manifest";
-				EditorTools.CopyFile(sourcePath, destPath, true);
 			}
 
 			// 拷贝所有补丁文件
 			int progressValue = 0;
-			PatchManifest patchManifest = AssetBundleBuilderHelper.LoadPatchManifestFile(buildParameters.PipelineOutputDirectory, buildParameters.Parameters.BuildVersion);
+			int patchFileTotalCount = buildMapContext.BundleInfos.Count;
-			int patchFileTotalCount = patchManifest.BundleList.Count;
+			foreach (var bundleInfo in buildMapContext.BundleInfos)
-			foreach (var patchBundle in patchManifest.BundleList)
 			{
-				string sourcePath = $"{buildParameters.PipelineOutputDirectory}/{patchBundle.BundleName}";
+				EditorTools.CopyFile(bundleInfo.PatchInfo.BuildOutputFilePath, bundleInfo.PatchInfo.PatchOutputFilePath, true);
-				string destPath = $"{packageDirectory}/{patchBundle.Hash}";
-				EditorTools.CopyFile(sourcePath, destPath, true);
 				EditorTools.DisplayProgressBar("拷贝补丁文件", ++progressValue, patchFileTotalCount);
 			}
 			EditorTools.ClearProgressBar();

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

@@ -10,54 +10,56 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
-			buildParameters.StopWatch();
+			var patchManifestContext = context.GetContextObject<PatchManifestContext>();
 
 			var buildMode = buildParameters.Parameters.BuildMode;
 			if (buildMode != EBuildMode.SimulateBuild)
 			{
-				CreateReportFile(buildParameters, buildMapContext);
+				CreateReportFile(buildParameters, buildMapContext, patchManifestContext);
-			}
-			else
-			{
-				float buildSeconds = buildParameters.GetBuildingSeconds();
-				BuildRunner.Info($"Build time consuming {buildSeconds} seconds.");
 			}
 		}
 
-		private void CreateReportFile(AssetBundleBuilder.BuildParametersContext buildParameters, BuildMapContext buildMapContext)
+		private void CreateReportFile(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext, PatchManifestContext patchManifestContext)
 		{
-			PatchManifest patchManifest = AssetBundleBuilderHelper.LoadPatchManifestFile(buildParameters.PipelineOutputDirectory, buildParameters.Parameters.BuildVersion);
+			var buildParameters = buildParametersContext.Parameters;
-			BuildReport buildReport = new BuildReport();		
+
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			PatchManifest patchManifest = patchManifestContext.Manifest;
+			BuildReport buildReport = new BuildReport();
 
 			// 概述信息
 			{
+#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 = (int)buildParameters.GetBuildingSeconds();
+				buildReport.Summary.BuildSeconds = BuildRunner.TotalSeconds;
-				buildReport.Summary.BuildTarget = buildParameters.Parameters.BuildTarget;
+				buildReport.Summary.BuildTarget = buildParameters.BuildTarget;
-				buildReport.Summary.BuildMode = buildParameters.Parameters.BuildMode;
+				buildReport.Summary.BuildPipeline = buildParameters.BuildPipeline;
-				buildReport.Summary.BuildVersion = buildParameters.Parameters.BuildVersion;
+				buildReport.Summary.BuildMode = buildParameters.BuildMode;
-				buildReport.Summary.BuildinTags = buildParameters.Parameters.BuildinTags;
+				buildReport.Summary.BuildPackageName = buildParameters.PackageName;
-				buildReport.Summary.EnableAddressable = buildParameters.Parameters.EnableAddressable;
+				buildReport.Summary.BuildPackageVersion = buildParameters.PackageVersion;
-				buildReport.Summary.AppendFileExtension = buildParameters.Parameters.AppendFileExtension;
+				buildReport.Summary.EnableAddressable = buildMapContext.EnableAddressable;
-				buildReport.Summary.AutoCollectShaders = AssetBundleCollectorSettingData.Setting.AutoCollectShaders;
+				buildReport.Summary.UniqueBundleName = buildMapContext.UniqueBundleName;
-				buildReport.Summary.ShadersBundleName = AssetBundleCollectorSettingData.Setting.ShadersBundleName;
+				buildReport.Summary.EncryptionServicesClassName = buildParameters.EncryptionServices == null ?
-				buildReport.Summary.EncryptionServicesClassName = buildParameters.Parameters.EncryptionServices == null ?
+					"null" : buildParameters.EncryptionServices.GetType().FullName;
-					"null" : buildParameters.Parameters.EncryptionServices.GetType().FullName;
 
 				// 构建参数
-				buildReport.Summary.CompressOption = buildParameters.Parameters.CompressOption;
+				buildReport.Summary.OutputNameStyle = buildParameters.OutputNameStyle;
-				buildReport.Summary.DisableWriteTypeTree = buildParameters.Parameters.DisableWriteTypeTree;
+				buildReport.Summary.CompressOption = buildParameters.CompressOption;
-				buildReport.Summary.IgnoreTypeTreeChanges = buildParameters.Parameters.IgnoreTypeTreeChanges;
+				buildReport.Summary.DisableWriteTypeTree = buildParameters.DisableWriteTypeTree;
+				buildReport.Summary.IgnoreTypeTreeChanges = buildParameters.IgnoreTypeTreeChanges;
 
 				// 构建结果
 				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);
-				buildReport.Summary.BuildinBundleTotalSize = GetBuildinBundleSize(patchManifest);
 				buildReport.Summary.EncryptedBundleTotalCount = GetEncryptedBundleCount(patchManifest);
 				buildReport.Summary.EncryptedBundleTotalSize = GetEncryptedBundleSize(patchManifest);
 				buildReport.Summary.RawBundleTotalCount = GetRawBundleCount(patchManifest);
@@ -75,7 +77,7 @@ namespace YooAsset.Editor
 				reportAssetInfo.AssetTags = patchAsset.AssetTags;
 				reportAssetInfo.AssetGUID = AssetDatabase.AssetPathToGUID(patchAsset.AssetPath);
 				reportAssetInfo.MainBundleName = mainBundle.BundleName;
-				reportAssetInfo.MainBundleSize = mainBundle.SizeBytes;
+				reportAssetInfo.MainBundleSize = mainBundle.FileSize;
 				reportAssetInfo.DependBundles = GetDependBundles(patchManifest, patchAsset);
 				reportAssetInfo.DependAssets = GetDependAssets(buildMapContext, mainBundle.BundleName, patchAsset.AssetPath);
 				buildReport.AssetInfos.Add(reportAssetInfo);
@@ -87,22 +89,22 @@ namespace YooAsset.Editor
 			{
 				ReportBundleInfo reportBundleInfo = new ReportBundleInfo();
 				reportBundleInfo.BundleName = patchBundle.BundleName;
-				reportBundleInfo.Hash = patchBundle.Hash;
+				reportBundleInfo.FileName = patchBundle.FileName;
-				reportBundleInfo.CRC = patchBundle.CRC;
+				reportBundleInfo.FileHash = patchBundle.FileHash;
-				reportBundleInfo.SizeBytes = patchBundle.SizeBytes;
+				reportBundleInfo.FileCRC = patchBundle.FileCRC;
+				reportBundleInfo.FileSize = patchBundle.FileSize;
 				reportBundleInfo.Tags = patchBundle.Tags;
-				reportBundleInfo.Flags = patchBundle.Flags;
+				reportBundleInfo.ReferenceIDs = patchBundle.ReferenceIDs;
+				reportBundleInfo.IsRawFile = patchBundle.IsRawFile;
+				reportBundleInfo.LoadMethod = (EBundleLoadMethod)patchBundle.LoadMethod;
 				buildReport.BundleInfos.Add(reportBundleInfo);
 			}
 
-			// 删除旧文件
-			string filePath = $"{buildParameters.PipelineOutputDirectory}/{YooAssetSettingsData.GetReportFileName(buildParameters.Parameters.BuildVersion)}";
-			if (File.Exists(filePath))
-				File.Delete(filePath);
-
 			// 序列化文件
+			string fileName = YooAssetSettingsData.GetReportFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+			string filePath = $"{packageOutputDirectory}/{fileName}";
 			BuildReport.Serialize(filePath, buildReport);
-			BuildRunner.Log($"资源构建报告文件创建完成：{filePath}");
+			BuildLogger.Log($"资源构建报告文件创建完成：{filePath}");
 		}
 
 		/// <summary>
@@ -152,6 +154,10 @@ namespace YooAsset.Editor
 			return result;
 		}
 
+		private int GetMainAssetCount(PatchManifest patchManifest)
+		{
+			return patchManifest.AssetList.Count;
+		}
 		private int GetAllBundleCount(PatchManifest patchManifest)
 		{
 			return patchManifest.BundleList.Count;
@@ -161,27 +167,7 @@ namespace YooAsset.Editor
 			long fileBytes = 0;
 			foreach (var patchBundle in patchManifest.BundleList)
 			{
-				fileBytes += patchBundle.SizeBytes;
+				fileBytes += patchBundle.FileSize;
-			}
-			return fileBytes;
-		}
-		private int GetBuildinBundleCount(PatchManifest patchManifest)
-		{
-			int fileCount = 0;
-			foreach (var patchBundle in patchManifest.BundleList)
-			{
-				if (patchBundle.IsBuildin)
-					fileCount++;
-			}
-			return fileCount;
-		}
-		private long GetBuildinBundleSize(PatchManifest patchManifest)
-		{
-			long fileBytes = 0;
-			foreach (var patchBundle in patchManifest.BundleList)
-			{
-				if (patchBundle.IsBuildin)
-					fileBytes += patchBundle.SizeBytes;
 			}
 			return fileBytes;
 		}
@@ -190,7 +176,7 @@ namespace YooAsset.Editor
 			int fileCount = 0;
 			foreach (var patchBundle in patchManifest.BundleList)
 			{
-				if (patchBundle.IsEncrypted)
+				if (patchBundle.LoadMethod != (byte)EBundleLoadMethod.Normal)
 					fileCount++;
 			}
 			return fileCount;
@@ -200,8 +186,8 @@ namespace YooAsset.Editor
 			long fileBytes = 0;
 			foreach (var patchBundle in patchManifest.BundleList)
 			{
-				if (patchBundle.IsEncrypted)
+				if (patchBundle.LoadMethod != (byte)EBundleLoadMethod.Normal)
-					fileBytes += patchBundle.SizeBytes;
+					fileBytes += patchBundle.FileSize;
 			}
 			return fileBytes;
 		}
@@ -221,7 +207,7 @@ namespace YooAsset.Editor
 			foreach (var patchBundle in patchManifest.BundleList)
 			{
 				if (patchBundle.IsRawFile)
-					fileBytes += patchBundle.SizeBytes;
+					fileBytes += patchBundle.FileSize;
 			}
 			return fileBytes;
 		}

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

@@ -9,85 +9,59 @@ namespace YooAsset.Editor
 	[TaskAttribute("资源包加密")]
 	public class TaskEncryption : IBuildTask
 	{
-		public class EncryptionContext : IContextObject
-		{
-			public List<string> EncryptList;
-
-			/// <summary>
-			/// 检测是否为加密文件
-			/// </summary>
-			public bool IsEncryptFile(string bundleName)
-			{
-				return EncryptList.Contains(bundleName);
-			}
-		}
-
 		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;
 			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
 			{
-				EncryptionContext encryptionContext = new EncryptionContext();
+				EncryptingBundleFiles(buildParameters, buildMapContext);
-				encryptionContext.EncryptList = EncryptFiles(buildParameters, buildMapContext);
-				context.SetContextObject(encryptionContext);
-			}
-			else
-			{
-				EncryptionContext encryptionContext = new EncryptionContext();
-				encryptionContext.EncryptList = new List<string>();
-				context.SetContextObject(encryptionContext);
 			}
 		}
 
 		/// <summary>
 		/// 加密文件
 		/// </summary>
-		private List<string> EncryptFiles(AssetBundleBuilder.BuildParametersContext buildParameters, BuildMapContext buildMapContext)
+		private void EncryptingBundleFiles(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext)
 		{
-			var encryptionServices = buildParameters.Parameters.EncryptionServices;
+			var encryptionServices = buildParametersContext.Parameters.EncryptionServices;
-
-			// 加密资源列表
-			List<string> encryptList = new List<string>();
-
-			// 如果没有设置加密类
 			if (encryptionServices == null)
-				return encryptList;
+				return;
+
+			if (encryptionServices.GetType() == typeof(EncryptionNone))
+				return;
 
 			int progressValue = 0;
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
 			foreach (var bundleInfo in buildMapContext.BundleInfos)
 			{
-				if (encryptionServices.Check(bundleInfo.BundleName))
+				EncryptFileInfo fileInfo = new EncryptFileInfo();
+				fileInfo.BundleName = bundleInfo.BundleName;
+				fileInfo.FilePath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
+
+				var encryptResult = encryptionServices.Encrypt(fileInfo);		
+				if (encryptResult.LoadMethod != EBundleLoadMethod.Normal)
 				{
+					// 注意：原生文件不支持加密
 					if (bundleInfo.IsRawFile)
 					{
 						UnityEngine.Debug.LogWarning($"Encryption not support raw file : {bundleInfo.BundleName}");
 						continue;
 					}
 
-					encryptList.Add(bundleInfo.BundleName);
+					string filePath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}.encrypt";
-
+					FileUtility.CreateFile(filePath, encryptResult.EncryptedData);
-					// 注意：通过判断文件合法性，规避重复加密一个文件
+					bundleInfo.EncryptedFilePath = filePath;
-					string filePath = $"{buildParameters.PipelineOutputDirectory}/{bundleInfo.BundleName}";
+					bundleInfo.LoadMethod = encryptResult.LoadMethod;
-					byte[] fileData = File.ReadAllBytes(filePath);
+					BuildLogger.Log($"Bundle文件加密完成：{filePath}");
-					if (EditorTools.CheckBundleFileValid(fileData))
-					{
-						byte[] bytes = encryptionServices.Encrypt(fileData);
-						File.WriteAllBytes(filePath, bytes);
-						BuildRunner.Log($"文件加密完成：{filePath}");
-					}
 				}
 
 				// 进度条
 				EditorTools.DisplayProgressBar("加密资源包", ++progressValue, buildMapContext.BundleInfos.Count);
 			}
 			EditorTools.ClearProgressBar();
-
-			if(encryptList.Count == 0)
-				UnityEngine.Debug.LogWarning($"没有发现需要加密的文件！");
-			return encryptList;
 		}
 	}
 }

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

@@ -12,10 +12,10 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParametersContext = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
-			var buildMapContext = BuildMapCreater.CreateBuildMap(buildParametersContext.Parameters.BuildMode);
+			var buildMapContext = BuildMapCreater.CreateBuildMap(buildParametersContext.Parameters.BuildMode, buildParametersContext.Parameters.PackageName);
 			context.SetContextObject(buildMapContext);
-			BuildRunner.Log("构建内容准备完毕！");
+			BuildLogger.Log("构建内容准备完毕！");
 
 			// 检测构建结果
 			CheckBuildMapContent(buildMapContext);

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

@@ -11,60 +11,59 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
-			buildParameters.BeginWatch();
+			var buildParameters = buildParametersContext.Parameters;
 
-			// 检测构建平台是否合法
+			// 检测构建参数合法性
-			if (buildParameters.Parameters.BuildTarget == BuildTarget.NoTarget)
+			if (buildParameters.BuildTarget == BuildTarget.NoTarget)
 				throw new Exception("请选择目标平台");
+			if (string.IsNullOrEmpty(buildParameters.PackageName))
+				throw new Exception("包裹名称不能为空");
+			if (string.IsNullOrEmpty(buildParameters.PackageVersion))
+				throw new Exception("包裹版本不能为空");
 
-			// 检测构建版本是否合法
+			if (buildParameters.BuildMode != EBuildMode.SimulateBuild)
-			if (buildParameters.Parameters.BuildVersion <= 0)
-				throw new Exception("请先设置版本号");
-
-			// 检测输出目录是否为空
-			if (string.IsNullOrEmpty(buildParameters.PipelineOutputDirectory))
-				throw new Exception("输出目录不能为空");
-
-			// 增量更新时候的必要检测
-			var buildMode = buildParameters.Parameters.BuildMode;
-			if (buildMode == EBuildMode.IncrementalBuild)
 			{
-				// 检测历史版本是否存在
+				// 检测当前是否正在构建资源包
-				if (AssetBundleBuilderHelper.HasAnyPackageVersion(buildParameters.Parameters.BuildTarget, buildParameters.Parameters.OutputRoot) == false)
+				if (BuildPipeline.isBuildingPlayer)
-					throw new Exception("没有发现任何历史版本，请尝试强制重建");
+					throw new Exception("当前正在构建资源包，请结束后再试");
 
-				// 检测构建版本是否合法
+				// 检测是否有未保存场景
-				int maxPackageVersion = AssetBundleBuilderHelper.GetMaxPackageVersion(buildParameters.Parameters.BuildTarget, buildParameters.Parameters.OutputRoot);
+				if (EditorTools.HasDirtyScenes())
-				if (buildParameters.Parameters.BuildVersion <= maxPackageVersion)
+					throw new Exception("检测到未保存的场景文件");
-					throw new Exception("构建版本不能小于历史版本");
 
-				// 检测补丁包是否已经存在
+				// 检测首包资源标签
-				string packageDirectory = buildParameters.GetPackageDirectory();
+				if (buildParameters.CopyBuildinFileOption == ECopyBuildinFileOption.ClearAndCopyByTags
-				if (Directory.Exists(packageDirectory))
+					|| buildParameters.CopyBuildinFileOption == ECopyBuildinFileOption.OnlyCopyByTags)
-					throw new Exception($"补丁包已经存在：{packageDirectory}");
+				{
+					if (string.IsNullOrEmpty(buildParameters.CopyBuildinFileTags))
+						throw new Exception("首包资源标签不能为空！");
+				}
 
-				// 检测内置资源分类标签是否一致
+				// 检测包裹输出目录是否存在
-				var oldPatchManifest = AssetBundleBuilderHelper.GetOldPatchManifest(buildParameters.PipelineOutputDirectory);
+				string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
-				if (buildParameters.Parameters.BuildinTags != oldPatchManifest.BuildinTags)
+				if (Directory.Exists(packageOutputDirectory))
-					throw new Exception($"增量更新时内置资源标签必须一致：{buildParameters.Parameters.BuildinTags} != {oldPatchManifest.BuildinTags}");
+					throw new Exception($"本次构建的补丁目录已经存在：{packageOutputDirectory}");
+
+				// 保存改动的资源
+				AssetDatabase.SaveAssets();
 			}
 
-			// 如果是强制重建
+			if (buildParameters.BuildMode == EBuildMode.ForceRebuild)
-			if (buildMode == EBuildMode.ForceRebuild)
 			{
 				// 删除平台总目录
-				string platformDirectory = $"{buildParameters.Parameters.OutputRoot}/{buildParameters.Parameters.BuildTarget}";
+				string platformDirectory = $"{buildParameters.OutputRoot}/{buildParameters.PackageName}/{buildParameters.BuildTarget}";
 				if (EditorTools.DeleteDirectory(platformDirectory))
 				{
-					BuildRunner.Log($"删除平台总目录：{platformDirectory}");
+					BuildLogger.Log($"删除平台总目录：{platformDirectory}");
 				}
 			}
 
 			// 如果输出目录不存在
-			if (EditorTools.CreateDirectory(buildParameters.PipelineOutputDirectory))
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
+			if (EditorTools.CreateDirectory(pipelineOutputDirectory))
 			{
-				BuildRunner.Log($"创建输出目录：{buildParameters.PipelineOutputDirectory}");
+				BuildLogger.Log($"创建输出目录：{pipelineOutputDirectory}");
 			}
 		}
 	}

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

@@ -0,0 +1,119 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("更新构建信息")]
+	public class TaskUpdateBuildInfo : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			int outputNameStyle = (int)buildParametersContext.Parameters.OutputNameStyle;
+
+			// 1.检测路径长度
+			foreach (var bundleInfo in buildMapContext.BundleInfos)
+			{
+				// NOTE：检测路径长度不要超过260字符。
+				string filePath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
+				if (filePath.Length >= 260)
+					throw new Exception($"The output bundle name is too long {filePath.Length} chars : {filePath}");
+			}
+
+			// 2.更新构建输出的文件路径
+			foreach (var bundleInfo in buildMapContext.BundleInfos)
+			{
+				if (bundleInfo.IsEncryptedFile)
+					bundleInfo.PatchInfo.BuildOutputFilePath = bundleInfo.EncryptedFilePath;
+				else
+					bundleInfo.PatchInfo.BuildOutputFilePath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
+			}
+
+			// 3.更新文件其它信息
+			foreach (var bundleInfo in buildMapContext.BundleInfos)
+			{
+				string buildOutputFilePath = bundleInfo.PatchInfo.BuildOutputFilePath;
+				bundleInfo.PatchInfo.ContentHash = GetBundleContentHash(bundleInfo, context);
+				bundleInfo.PatchInfo.PatchFileHash = GetBundleFileHash(buildOutputFilePath, buildParametersContext);
+				bundleInfo.PatchInfo.PatchFileCRC = GetBundleFileCRC(buildOutputFilePath, buildParametersContext);
+				bundleInfo.PatchInfo.PatchFileSize = GetBundleFileSize(buildOutputFilePath, buildParametersContext);
+			}
+
+			// 4.更新补丁包输出的文件路径
+			foreach (var bundleInfo in buildMapContext.BundleInfos)
+			{
+				string patchFileExtension = PatchManifestTools.GetRemoteBundleFileExtension(bundleInfo.BundleName);
+				string patchFileName = PatchManifestTools.GetRemoteBundleFileName(outputNameStyle, bundleInfo.BundleName, patchFileExtension, bundleInfo.PatchInfo.PatchFileHash);
+				bundleInfo.PatchInfo.PatchOutputFilePath = $"{packageOutputDirectory}/{patchFileName}";
+			}
+		}
+
+		private string GetBundleContentHash(BuildBundleInfo bundleInfo, BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var parameters = buildParametersContext.Parameters;
+			var buildMode = parameters.BuildMode;
+			if (buildMode == EBuildMode.DryRunBuild || buildMode == EBuildMode.SimulateBuild)
+				return "00000000000000000000000000000000"; //32位
+
+			if (bundleInfo.IsRawFile)
+			{
+				string filePath = bundleInfo.PatchInfo.BuildOutputFilePath;
+				return HashUtility.FileMD5(filePath);
+			}
+
+			if (parameters.BuildPipeline == EBuildPipeline.BuiltinBuildPipeline)
+			{
+				var buildResult = context.GetContextObject<TaskBuilding.BuildResultContext>();
+				var hash = buildResult.UnityManifest.GetAssetBundleHash(bundleInfo.BundleName);
+				if (hash.isValid)
+					return hash.ToString();
+				else
+					throw new Exception($"Not found bundle in build result : {bundleInfo.BundleName}");
+			}
+			else if (parameters.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
+			{
+				// 注意：当资源包的依赖列表发生变化的时候，ContentHash也会发生变化！
+				var buildResult = context.GetContextObject<TaskBuilding_SBP.BuildResultContext>();
+				if (buildResult.Results.BundleInfos.TryGetValue(bundleInfo.BundleName, out var value))
+					return value.Hash.ToString();
+				else
+					throw new Exception($"Not found bundle in build result : {bundleInfo.BundleName}");
+			}
+			else
+			{
+				throw new System.NotImplementedException();
+			}
+		}
+		private string GetBundleFileHash(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.DryRunBuild || buildMode == EBuildMode.SimulateBuild)
+				return "00000000000000000000000000000000"; //32位
+			else
+				return HashUtility.FileMD5(filePath);
+		}
+		private string GetBundleFileCRC(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.DryRunBuild || buildMode == EBuildMode.SimulateBuild)
+				return "00000000"; //8位
+			else
+				return HashUtility.FileCRC32(filePath);
+		}
+		private long GetBundleFileSize(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.DryRunBuild || buildMode == EBuildMode.SimulateBuild)
+				return 0;
+			else
+				return FileUtility.GetFileSize(filePath);
+		}
+	}
+}

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

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

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

@@ -13,8 +13,8 @@ namespace YooAsset.Editor
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
-			var buildParametersContext = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
-			
+
 			// 模拟构建模式下跳过验证
 			if (buildParametersContext.Parameters.BuildMode == EBuildMode.SimulateBuild)
 				return;
@@ -22,8 +22,8 @@ namespace YooAsset.Editor
 			// 验证构建结果
 			if (buildParametersContext.Parameters.VerifyBuildingResult)
 			{
-				var unityManifestContext = context.GetContextObject<TaskBuilding.UnityManifestContext>();
+				var buildResultContext = context.GetContextObject<TaskBuilding.BuildResultContext>();
-				VerifyingBuildingResult(context, unityManifestContext.UnityManifest);
+				VerifyingBuildingResult(context, buildResultContext.UnityManifest);
 			}
 		}
 
@@ -32,113 +32,76 @@ namespace YooAsset.Editor
 		/// </summary>
 		private void VerifyingBuildingResult(BuildContext context, AssetBundleManifest unityManifest)
 		{
-			var buildParameters = context.GetContextObject<AssetBundleBuilder.BuildParametersContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
 			string[] buildedBundles = unityManifest.GetAllAssetBundles();
 
 			// 1. 过滤掉原生Bundle
-			List<BuildBundleInfo> expectBundles = new List<BuildBundleInfo>(buildedBundles.Length);
+			string[] mapBundles = 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> exceptBundleList1 = buildedBundles.Except(mapBundles).ToList();
+			if (exceptBundleList1.Count > 0)
 			{
-				Debug.LogWarning($"构建过程中可能存在无效的资源，导致和预期构建的Bundle数量不一致！");
+				foreach (var exceptBundle in exceptBundleList1)
-			}
-
-			// 3. 正向验证Bundle
-			foreach (var bundleName in buildedBundles)
-			{
-				if (buildMapContext.IsContainsBundle(bundleName) == false)
 				{
-					throw new Exception($"Should never get here !");
+					Debug.LogWarning($"差异资源包: {exceptBundle}");
 				}
+				throw new System.Exception("存在差异资源包！请查看警告信息！");
 			}
 
-			// 4. 反向验证Bundle
+			// 3. 验证Bundle
+			List<string> exceptBundleList2 = mapBundles.Except(buildedBundles).ToList();
+			if (exceptBundleList2.Count > 0)
+			{
+				foreach (var exceptBundle in exceptBundleList2)
+				{
+					Debug.LogWarning($"差异资源包: {exceptBundle}");
+				}
+				throw new System.Exception("存在差异资源包！请查看警告信息！");
+			}
+
+			// 4. 验证Asset
+			/*
 			bool isPass = true;
-			foreach (var expectBundle in expectBundles)
+			var buildMode = buildParametersContext.Parameters.BuildMode;
-			{
-				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)
 			{
 				int progressValue = 0;
+				string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
 				foreach (var buildedBundle in buildedBundles)
 				{
-					string filePath = $"{buildParameters.PipelineOutputDirectory}/{buildedBundle}";
+					string filePath = $"{pipelineOutputDirectory}/{buildedBundle}";
-					string[] allBuildinAssetPaths = GetAssetBundleAllAssets(filePath);
+					string[] buildedAssetPaths = GetAssetBundleAllAssets(filePath);
-					string[] expectBuildinAssetPaths = buildMapContext.GetBuildinAssetPaths(buildedBundle);
+					string[] mapAssetPaths = buildMapContext.GetBuildinAssetPaths(buildedBundle);
-					if (expectBuildinAssetPaths.Length != allBuildinAssetPaths.Length)
+					if (mapAssetPaths.Length != buildedAssetPaths.Length)
 					{
 						Debug.LogWarning($"构建的Bundle文件内的资源对象数量和预期不匹配 : {buildedBundle}");
+						var exceptAssetList1 = mapAssetPaths.Except(buildedAssetPaths).ToList();
+						foreach (var excpetAsset in exceptAssetList1)
+						{
+							Debug.LogWarning($"构建失败的资源对象路径为 : {excpetAsset}");
+						}
+						var exceptAssetList2 = buildedAssetPaths.Except(mapAssetPaths).ToList();
+						foreach (var excpetAsset in exceptAssetList2)
+						{
+							Debug.LogWarning($"构建失败的资源对象路径为 : {excpetAsset}");
+						}
 						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();
+
 				if (isPass == false)
 				{
 					throw new Exception("构建结果验证没有通过，请参考警告日志！");
 				}
 			}
+			*/
 
-			// 卸载所有加载的Bundle
+			BuildLogger.Log("构建结果验证成功！");
-			BuildRunner.Log("构建结果验证成功！");
 		}
 
 		/// <summary>

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

@@ -0,0 +1,68 @@
+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.BuildResultContext>();
+				VerifyingBuildingResult(context, buildResultContext.Results);
+			}
+		}
+
+		/// <summary>
+		/// 验证构建结果
+		/// </summary>
+		private void VerifyingBuildingResult(BuildContext context, IBundleBuildResults buildResults)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			List<string> buildedBundles = buildResults.BundleInfos.Keys.ToList();
+
+			// 1. 过滤掉原生Bundle
+			List<string> expectBundles = buildMapContext.BundleInfos.Where(t => t.IsRawFile == false).Select(t => t.BundleName).ToList();
+
+			// 2. 验证Bundle
+			List<string> exceptBundleList1 = buildedBundles.Except(expectBundles).ToList();
+			if (exceptBundleList1.Count > 0)
+			{
+				foreach (var exceptBundle in exceptBundleList1)
+				{
+					Debug.LogWarning($"差异资源包: {exceptBundle}");
+				}
+				throw new System.Exception("存在差异资源包！请查看警告信息！");
+			}
+
+			// 3. 验证Bundle
+			List<string> exceptBundleList2 = expectBundles.Except(buildedBundles).ToList();
+			if (exceptBundleList2.Count > 0)
+			{
+				foreach (var exceptBundle in exceptBundleList2)
+				{
+					Debug.LogWarning($"差异资源包: {exceptBundle}");
+				}
+				throw new System.Exception("存在差异资源包！请查看警告信息！");
+			}
+
+			BuildLogger.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/DefaultEncryption.cs

@@ -0,0 +1,11 @@
+
+namespace YooAsset.Editor
+{
+	public class EncryptionNone : IEncryptionServices
+	{
+		public EncryptResult Encrypt(EncryptFileInfo fileInfo)
+		{
+			throw new System.NotImplementedException();
+		}
+	}
+}

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

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

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/ECopyBuildinFileOption.cs

@@ -0,0 +1,34 @@
+
+namespace YooAsset.Editor
+{
+	/// <summary>
+	/// 首包资源文件的拷贝方式
+	/// </summary>
+	public enum ECopyBuildinFileOption
+	{
+		/// <summary>
+		/// 不拷贝任何文件
+		/// </summary>
+		None = 0,
+
+		/// <summary>
+		/// 先清空已有文件，然后拷贝所有文件
+		/// </summary>
+		ClearAndCopyAll,
+
+		/// <summary>
+		/// 先清空已有文件，然后按照资源标签拷贝文件
+		/// </summary>
+		ClearAndCopyByTags,
+
+		/// <summary>
+		/// 不清空已有文件，直接拷贝所有文件
+		/// </summary>
+		OnlyCopyAll,
+
+		/// <summary>
+		/// 不清空已有文件，直接按照资源标签拷贝文件
+		/// </summary>
+		OnlyCopyByTags,
+	}
+}

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

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

Assets/YooAsset/Editor/AssetBundleBuilder/EOutputNameStyle.cs

@@ -0,0 +1,19 @@
+
+namespace YooAsset.Editor
+{
+	/// <summary>
+	/// 输出文件名称的样式
+	/// </summary>
+	public enum EOutputNameStyle
+	{
+		/// <summary>
+		/// 哈希值名称
+		/// </summary>
+		HashName = 1,
+
+		/// <summary>
+		/// 资源包名称 + 哈希值名称
+		/// </summary>
+		BundleName_HashName = 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/AssetBundleBuilder/IEncryptionServices.cs

@@ -1,18 +0,0 @@
-
-namespace YooAsset.Editor
-{
-	public interface IEncryptionServices
-	{
-		/// <summary>
-		/// 检测是否需要加密
-		/// </summary>
-		bool Check(string bundleName);
-		
-		/// <summary>
-		/// 加密方法
-		/// </summary>
-		/// <param name="fileData">要加密的文件数据</param>
-		/// <returns>返回加密后的字节数据</returns>
-		byte[] Encrypt(byte[] fileData);
-	}
-}

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollector.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor;
+using UnityEngine;
 
 namespace YooAsset.Editor
 {
@@ -14,6 +15,11 @@ namespace YooAsset.Editor
 		/// </summary>
 		public string CollectPath = string.Empty;
 
+		/// <summary>
+		/// 收集器的GUID
+		/// </summary>
+		public string CollectorGUID = string.Empty;
+
 		/// <summary>
 		/// 收集器类型
 		/// </summary>
@@ -39,6 +45,11 @@ namespace YooAsset.Editor
 		/// </summary>
 		public string AssetTags = string.Empty;
 
+		/// <summary>
+		/// 用户自定义数据
+		/// </summary>
+		public string UserData = string.Empty;
+
 
 		/// <summary>
 		/// 收集器是否有效
@@ -68,7 +79,8 @@ namespace YooAsset.Editor
 		/// </summary>
 		public void CheckConfigError()
 		{
-			if (AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(CollectPath) == null)
+			string assetGUID = AssetDatabase.AssetPathToGUID(CollectPath);
+			if (string.IsNullOrEmpty(assetGUID))
 				throw new Exception($"Invalid collect path : {CollectPath}");
 
 			if (CollectorType == ECollectorType.None)
@@ -84,24 +96,65 @@ namespace YooAsset.Editor
 				throw new Exception($"Invalid {nameof(IAddressRule)} class type : {AddressRuleName} in collector : {CollectPath}");
 		}
 
+		/// <summary>
+		/// 修复配置错误
+		/// </summary>
+		public bool FixConfigError()
+		{
+			bool isFixed = false;
+
+			if (string.IsNullOrEmpty(CollectorGUID) == false)
+			{
+				string convertAssetPath = AssetDatabase.GUIDToAssetPath(CollectorGUID);
+				if (string.IsNullOrEmpty(convertAssetPath))
+				{
+					Debug.LogWarning($"Collector GUID {CollectorGUID} is invalid and has been auto removed !");
+					CollectorGUID = string.Empty;
+					isFixed = true;
+				}
+				else
+				{
+					if (CollectPath != convertAssetPath)
+					{
+						CollectPath = convertAssetPath;
+						isFixed = true;
+						Debug.LogWarning($"Fix collect path : {CollectPath} -> {convertAssetPath}");
+					}
+				}
+			}
+
+			/*
+			string convertGUID = AssetDatabase.AssetPathToGUID(CollectPath);
+			if(string.IsNullOrEmpty(convertGUID) == false)
+			{
+				CollectorGUID = convertGUID;
+			}
+			*/
+
+			return isFixed;
+		}
+
 		/// <summary>
 		/// 获取打包收集的资源文件
 		/// </summary>
-		public List<CollectAssetInfo> GetAllCollectAssets(AssetBundleCollectorGroup group)
+		public List<CollectAssetInfo> GetAllCollectAssets(CollectCommand command, AssetBundleCollectorGroup group)
 		{
 			// 注意：模拟构建模式下只收集主资源
-			if (AssetBundleCollectorSetting.BuildMode == EBuildMode.SimulateBuild)
+			if (command.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);
+
+			// 检测是否为原生资源打包规则
+			IPackRule packRuleInstance = AssetBundleCollectorSettingData.GetPackRuleInstance(PackRuleName);
+			bool isRawFilePackRule = packRuleInstance.IsRawFilePackRule();
 
 			// 检测原生资源包的收集器类型
-			if (isRawAsset && CollectorType != ECollectorType.MainAssetCollector)
+			if (isRawFilePackRule && CollectorType != ECollectorType.MainAssetCollector)
-				throw new Exception($"The raw file must be set to {nameof(ECollectorType)}.{ECollectorType.MainAssetCollector} : {CollectPath}");
+				throw new Exception($"The raw file pack rule must be set to {nameof(ECollectorType)}.{ECollectorType.MainAssetCollector} : {CollectPath}");
 
 			if (string.IsNullOrEmpty(CollectPath))
 				throw new Exception($"The collect path is null or empty in group : {group.GroupName}");
@@ -113,11 +166,11 @@ namespace YooAsset.Editor
 				string[] findAssets = EditorTools.FindAssets(EAssetSearchType.All, collectDirectory);
 				foreach (string assetPath in findAssets)
 				{
-					if (IsValidateAsset(assetPath) && IsCollectAsset(assetPath))
+					if (IsValidateAsset(assetPath, isRawFilePackRule) && IsCollectAsset(assetPath))
 					{
 						if (result.ContainsKey(assetPath) == false)
 						{
-							var collectAssetInfo = CreateCollectAssetInfo(group, assetPath, isRawAsset);
+							var collectAssetInfo = CreateCollectAssetInfo(command, group, assetPath, isRawFilePackRule);
 							result.Add(assetPath, collectAssetInfo);
 						}
 						else
@@ -130,9 +183,9 @@ namespace YooAsset.Editor
 			else
 			{
 				string assetPath = CollectPath;
-				if (IsValidateAsset(assetPath) && IsCollectAsset(assetPath))
+				if (IsValidateAsset(assetPath, isRawFilePackRule) && IsCollectAsset(assetPath))
 				{
-					var collectAssetInfo = CreateCollectAssetInfo(group, assetPath, isRawAsset);
+					var collectAssetInfo = CreateCollectAssetInfo(command, group, assetPath, isRawFilePackRule);
 					result.Add(assetPath, collectAssetInfo);
 				}
 				else
@@ -142,7 +195,7 @@ namespace YooAsset.Editor
 			}
 
 			// 检测可寻址地址是否重复
-			if (AssetBundleCollectorSettingData.Setting.EnableAddressable)
+			if (command.EnableAddressable)
 			{
 				HashSet<string> adressTemper = new HashSet<string>();
 				foreach (var collectInfoPair in result)
@@ -162,43 +215,90 @@ namespace YooAsset.Editor
 			return result.Values.ToList();
 		}
 
-		private CollectAssetInfo CreateCollectAssetInfo(AssetBundleCollectorGroup group, string assetPath, bool isRawAsset)
+		private CollectAssetInfo CreateCollectAssetInfo(CollectCommand command, AssetBundleCollectorGroup group, string assetPath, bool isRawFilePackRule)
 		{
 			string address = GetAddress(group, assetPath);
-			string bundleName = GetBundleName(group, assetPath);
+			string bundleName = GetBundleName(command, group, assetPath);
 			List<string> assetTags = GetAssetTags(group);
-			CollectAssetInfo collectAssetInfo = new CollectAssetInfo(CollectorType, bundleName, address, assetPath, assetTags, isRawAsset);
+			CollectAssetInfo collectAssetInfo = new CollectAssetInfo(CollectorType, bundleName, address, assetPath, isRawFilePackRule, assetTags);
-			collectAssetInfo.DependAssets = GetAllDependencies(assetPath);
+
+			// 注意：模拟构建模式下不需要收集依赖资源
+			if (command.BuildMode == EBuildMode.SimulateBuild)
+				collectAssetInfo.DependAssets = new List<string>();
+			else
+				collectAssetInfo.DependAssets = GetAllDependencies(assetPath, isRawFilePackRule);
+
 			return collectAssetInfo;
 		}
-		private bool IsValidateAsset(string assetPath)
+		private bool IsValidateAsset(string assetPath, bool isRawFilePackRule)
 		{
 			if (assetPath.StartsWith("Assets/") == false && assetPath.StartsWith("Packages/") == false)
+			{
+				UnityEngine.Debug.LogError($"Invalid asset path : {assetPath}");
 				return false;
+			}
 
+			// 忽略文件夹
 			if (AssetDatabase.IsValidFolder(assetPath))
 				return false;
 
-			// 注意：忽略编辑器下的类型资源
+			// 忽略编辑器下的类型资源
 			Type type = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
 			if (type == typeof(LightingDataAsset))
 				return false;
 
-			string ext = System.IO.Path.GetExtension(assetPath);
+			// 检测原生文件是否合规
-			if (ext == "" || ext == ".dll" || ext == ".cs" || ext == ".js" || ext == ".boo" || ext == ".meta" || ext == ".cginc")
+			if (isRawFilePackRule)
+			{
+				string extension = StringUtility.RemoveFirstChar(System.IO.Path.GetExtension(assetPath));
+				if (extension == EAssetFileExtension.unity.ToString() || extension == EAssetFileExtension.prefab.ToString() ||
+					extension == EAssetFileExtension.mat.ToString() || extension == EAssetFileExtension.controller.ToString() ||
+					extension == EAssetFileExtension.fbx.ToString() || extension == EAssetFileExtension.anim.ToString() ||
+					extension == EAssetFileExtension.shader.ToString())
+				{
+					UnityEngine.Debug.LogWarning($"Raw file pack rule can not support file estension : {extension}");
+					return false;
+				}
+
+				// 注意：原生文件只支持无依赖关系的资源
+				string[] depends = AssetDatabase.GetDependencies(assetPath, true);
+				if (depends.Length != 1)
+				{
+					UnityEngine.Debug.LogWarning($"Raw file pack rule can not support estension : {extension}");
+					return false;
+				}
+			}
+			else
+			{
+				// 忽略Unity无法识别的无效文件
+				// 注意：只对非原生文件收集器处理
+				if (type == typeof(UnityEditor.DefaultAsset))
+				{
+					UnityEngine.Debug.LogWarning($"Cannot pack default asset : {assetPath}");
+					return false;
+				}
+			}
+
+			string fileExtension = System.IO.Path.GetExtension(assetPath);
+			if (IsIgnoreFile(fileExtension))
 				return false;
 
 			return true;
 		}
-		private bool IsCollectAsset(string assetPath)
+		private bool IsIgnoreFile(string fileExtension)
 		{
-			// 如果收集全路径着色器
+			foreach (var extension in DefaultFilterRule.IgnoreFileExtensions)
-			if (AssetBundleCollectorSettingData.Setting.AutoCollectShaders)
 			{
-				Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
+				if (extension == fileExtension)
-				if (assetType == typeof(UnityEngine.Shader))
 					return true;
 			}
+			return false;
+		}
+		private bool IsCollectAsset(string assetPath)
+		{
+			Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
+			if (assetType == typeof(UnityEngine.Shader) || assetType == typeof(UnityEngine.ShaderVariantCollection))
+				return true;
 
 			// 根据规则设置过滤资源文件
 			IFilterRule filterRuleInstance = AssetBundleCollectorSettingData.GetFilterRuleInstance(FilterRuleName);
@@ -210,47 +310,40 @@ namespace YooAsset.Editor
 				return string.Empty;
 
 			IAddressRule addressRuleInstance = AssetBundleCollectorSettingData.GetAddressRuleInstance(AddressRuleName);
-			string adressValue = addressRuleInstance.GetAssetAddress(new AddressRuleData(assetPath, CollectPath, group.GroupName));
+			string adressValue = addressRuleInstance.GetAssetAddress(new AddressRuleData(assetPath, CollectPath, group.GroupName, UserData));
 			return adressValue;
 		}
-		private string GetBundleName(AssetBundleCollectorGroup group, string assetPath)
+		private string GetBundleName(CollectCommand command, AssetBundleCollectorGroup group, string assetPath)
 		{
-			// 如果自动收集所有的着色器
+			System.Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
-			if (AssetBundleCollectorSettingData.Setting.AutoCollectShaders)
+			if (assetType == typeof(UnityEngine.Shader) || assetType == typeof(UnityEngine.ShaderVariantCollection))
 			{
-				System.Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
+				// 获取着色器打包规则结果
-				if (assetType == typeof(UnityEngine.Shader))
+				PackRuleResult packRuleResult = DefaultPackRule.CreateShadersPackRuleResult();
-				{
+				return packRuleResult.GetMainBundleName(command.PackageName, command.UniqueBundleName);
-					string bundleName = AssetBundleCollectorSettingData.Setting.ShadersBundleName;
-					return EditorTools.GetRegularPath(bundleName).ToLower();
-				}
 			}
-
+			else
-			// 根据规则设置获取资源包名称
 			{
+				// 获取其它资源打包规则结果
 				IPackRule packRuleInstance = AssetBundleCollectorSettingData.GetPackRuleInstance(PackRuleName);
-				string bundleName = packRuleInstance.GetBundleName(new PackRuleData(assetPath, CollectPath, group.GroupName));
+				PackRuleResult packRuleResult = packRuleInstance.GetPackRuleResult(new PackRuleData(assetPath, CollectPath, group.GroupName, UserData));
-				return EditorTools.GetRegularPath(bundleName).ToLower();
+				return packRuleResult.GetMainBundleName(command.PackageName, command.UniqueBundleName);
 			}
 		}
 		private List<string> GetAssetTags(AssetBundleCollectorGroup group)
 		{
-			List<string> tags = StringUtility.StringToStringList(group.AssetTags, ';');
+			List<string> tags = EditorTools.StringToStringList(group.AssetTags, ';');
-			List<string> temper = StringUtility.StringToStringList(AssetTags, ';');
+			List<string> temper = EditorTools.StringToStringList(AssetTags, ';');
 			tags.AddRange(temper);
 			return tags;
 		}
-		private List<string> GetAllDependencies(string mainAssetPath)
+		private List<string> GetAllDependencies(string mainAssetPath, bool isRawFilePackRule)
 		{
-			// 注意：模拟构建模式下不需要收集依赖资源
-			if(AssetBundleCollectorSetting.BuildMode == EBuildMode.SimulateBuild)
-				return new List<string>();
-
 			List<string> result = new List<string>();
 			string[] depends = AssetDatabase.GetDependencies(mainAssetPath, true);
 			foreach (string assetPath in depends)
 			{
-				if (IsValidateAsset(assetPath))
+				if (IsValidateAsset(assetPath, isRawFilePackRule))
 				{
 					// 注意：排除主资源对象
 					if (assetPath != mainAssetPath)

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorConfig.cs

@@ -10,24 +10,33 @@ namespace YooAsset.Editor
 {
 	public class AssetBundleCollectorConfig
 	{
-		public const string ConfigVersion = "1.0";
+		public const string ConfigVersion = "2.3";
 
 		public const string XmlVersion = "Version";
 		public const string XmlCommon = "Common";
 		public const string XmlEnableAddressable = "AutoAddressable";
-		public const string XmlAutoCollectShader = "AutoCollectShader";
+		public const string XmlUniqueBundleName = "UniqueBundleName";
-		public const string XmlShaderBundleName = "ShaderBundleName";
+		public const string XmlShowPackageView = "ShowPackageView";
+		public const string XmlShowEditorAlias = "ShowEditorAlias";
+
+		public const string XmlPackage = "Package";
+		public const string XmlPackageName = "PackageName";
+		public const string XmlPackageDesc = "PackageDesc";
+
 		public const string XmlGroup = "Group";
 		public const string XmlGroupName = "GroupName";
 		public const string XmlGroupDesc = "GroupDesc";
+
 		public const string XmlCollector = "Collector";
 		public const string XmlCollectPath = "CollectPath";
+		public const string XmlCollectorGUID = "CollectGUID";
 		public const string XmlCollectorType = "CollectType";
 		public const string XmlAddressRule = "AddressRule";
 		public const string XmlPackRule = "PackRule";
 		public const string XmlFilterRule = "FilterRule";
+		public const string XmlUserData = "UserData";
 		public const string XmlAssetTags = "AssetTags";
-		
+
 		/// <summary>
 		/// 导入XML配置表
 		/// </summary>
@@ -40,91 +49,121 @@ namespace YooAsset.Editor
 				throw new Exception($"Only support xml : {filePath}");
 
 			// 加载配置文件
-			XmlDocument xml = new XmlDocument();
+			XmlDocument xmlDoc = new XmlDocument();
-			xml.Load(filePath);
+			xmlDoc.Load(filePath);
-			XmlElement root = xml.DocumentElement;
+			XmlElement root = xmlDoc.DocumentElement;
 
 			// 读取配置版本
 			string configVersion = root.GetAttribute(XmlVersion);
-			if(configVersion != ConfigVersion)
+			if (configVersion != ConfigVersion)
 			{
-				throw new Exception($"The config version is invalid : {configVersion}");
+				if (UpdateXmlConfig(xmlDoc) == false)
+					throw new Exception($"The config version update failed : {configVersion} -> {ConfigVersion}");
+				else
+					Debug.Log($"The config version update succeed : {configVersion} -> {ConfigVersion}");
 			}
 
 			// 读取公共配置
 			bool enableAddressable = false;
-			bool autoCollectShaders = false;
+			bool uniqueBundleName = false;
-			string shaderBundleName = string.Empty;
+			bool showPackageView = false;
+			bool showEditorAlias = false;
 			var commonNodeList = root.GetElementsByTagName(XmlCommon);
 			if (commonNodeList.Count > 0)
 			{
 				XmlElement commonElement = commonNodeList[0] as XmlElement;
 				if (commonElement.HasAttribute(XmlEnableAddressable) == false)
 					throw new Exception($"Not found attribute {XmlEnableAddressable} in {XmlCommon}");
-				if (commonElement.HasAttribute(XmlAutoCollectShader) == false)
+				if (commonElement.HasAttribute(XmlUniqueBundleName) == false)
-					throw new Exception($"Not found attribute {XmlAutoCollectShader} in {XmlCommon}");
+					throw new Exception($"Not found attribute {XmlUniqueBundleName} in {XmlCommon}");
-				if (commonElement.HasAttribute(XmlShaderBundleName) == false)
+				if (commonElement.HasAttribute(XmlShowPackageView) == false)
-					throw new Exception($"Not found attribute {XmlShaderBundleName} in {XmlCommon}");
+					throw new Exception($"Not found attribute {XmlShowPackageView} in {XmlCommon}");
+				if (commonElement.HasAttribute(XmlShowEditorAlias) == false)
+					throw new Exception($"Not found attribute {XmlShowEditorAlias} in {XmlCommon}");
 
 				enableAddressable = commonElement.GetAttribute(XmlEnableAddressable) == "True" ? true : false;
-				autoCollectShaders = commonElement.GetAttribute(XmlAutoCollectShader) == "True" ? true : false;
+				uniqueBundleName = commonElement.GetAttribute(XmlUniqueBundleName) == "True" ? true : false;
-				shaderBundleName = commonElement.GetAttribute(XmlShaderBundleName);
+				showPackageView = commonElement.GetAttribute(XmlShowPackageView) == "True" ? true : false;
+				showEditorAlias = commonElement.GetAttribute(XmlShowEditorAlias) == "True" ? true : false;
 			}
 
-			// 读取分组配置
+			// 读取包裹配置
-			List<AssetBundleCollectorGroup> groupTemper = new List<AssetBundleCollectorGroup>();
+			List<AssetBundleCollectorPackage> packages = new List<AssetBundleCollectorPackage>();
-			var groupNodeList = root.GetElementsByTagName(XmlGroup);
+			var packageNodeList = root.GetElementsByTagName(XmlPackage);
-			foreach (var groupNode in groupNodeList)
+			foreach (var packageNode in packageNodeList)
 			{
-				XmlElement groupElement = groupNode as XmlElement;
+				XmlElement packageElement = packageNode as XmlElement;
-				if (groupElement.HasAttribute(XmlGroupName) == false)
+				if (packageElement.HasAttribute(XmlPackageName) == false)
-					throw new Exception($"Not found attribute {XmlGroupName} in {XmlGroup}");
+					throw new Exception($"Not found attribute {XmlPackageName} in {XmlPackage}");
-				if (groupElement.HasAttribute(XmlGroupDesc) == false)
+				if (packageElement.HasAttribute(XmlPackageDesc) == false)
-					throw new Exception($"Not found attribute {XmlGroupDesc} in {XmlGroup}");
+					throw new Exception($"Not found attribute {XmlPackageDesc} in {XmlPackage}");
-				if (groupElement.HasAttribute(XmlAssetTags) == false)
-					throw new Exception($"Not found attribute {XmlAssetTags} in {XmlGroup}");
 
-				AssetBundleCollectorGroup group = new AssetBundleCollectorGroup();
+				AssetBundleCollectorPackage package = new AssetBundleCollectorPackage();
-				group.GroupName = groupElement.GetAttribute(XmlGroupName);
+				package.PackageName = packageElement.GetAttribute(XmlPackageName);
-				group.GroupDesc = groupElement.GetAttribute(XmlGroupDesc);
+				package.PackageDesc = packageElement.GetAttribute(XmlPackageDesc);
-				group.AssetTags = groupElement.GetAttribute(XmlAssetTags);
+				packages.Add(package);
-				groupTemper.Add(group);
 
-				// 读取收集器配置
+				// 读取分组配置
-				var collectorNodeList = groupElement.GetElementsByTagName(XmlCollector);
+				var groupNodeList = packageElement.GetElementsByTagName(XmlGroup);
-				foreach (var collectorNode in collectorNodeList)
+				foreach (var groupNode in groupNodeList)
 				{
-					XmlElement collectorElement = collectorNode as XmlElement;
+					XmlElement groupElement = groupNode as XmlElement;
-					if (collectorElement.HasAttribute(XmlCollectPath) == false)
+					if (groupElement.HasAttribute(XmlGroupName) == false)
-						throw new Exception($"Not found attribute {XmlCollectPath} in {XmlCollector}");
+						throw new Exception($"Not found attribute {XmlGroupName} in {XmlGroup}");
-					if (collectorElement.HasAttribute(XmlCollectorType) == false)
+					if (groupElement.HasAttribute(XmlGroupDesc) == false)
-						throw new Exception($"Not found attribute {XmlCollectorType} in {XmlCollector}");
+						throw new Exception($"Not found attribute {XmlGroupDesc} in {XmlGroup}");
-					if (collectorElement.HasAttribute(XmlAddressRule) == false)
+					if (groupElement.HasAttribute(XmlAssetTags) == false)
-						throw new Exception($"Not found attribute {XmlAddressRule} in {XmlCollector}");
+						throw new Exception($"Not found attribute {XmlAssetTags} in {XmlGroup}");
-					if (collectorElement.HasAttribute(XmlPackRule) == false)
-						throw new Exception($"Not found attribute {XmlPackRule} in {XmlCollector}");
-					if (collectorElement.HasAttribute(XmlFilterRule) == false)
-						throw new Exception($"Not found attribute {XmlFilterRule} in {XmlCollector}");
-					if (collectorElement.HasAttribute(XmlAssetTags) == false)
-						throw new Exception($"Not found attribute {XmlAssetTags} in {XmlCollector}");
 
-					AssetBundleCollector collector = new AssetBundleCollector();
+					AssetBundleCollectorGroup group = new AssetBundleCollectorGroup();
-					collector.CollectPath = collectorElement.GetAttribute(XmlCollectPath);
+					group.GroupName = groupElement.GetAttribute(XmlGroupName);
-					collector.CollectorType = StringUtility.NameToEnum<ECollectorType>(collectorElement.GetAttribute(XmlCollectorType));
+					group.GroupDesc = groupElement.GetAttribute(XmlGroupDesc);
-					collector.AddressRuleName = collectorElement.GetAttribute(XmlAddressRule);
+					group.AssetTags = groupElement.GetAttribute(XmlAssetTags);
-					collector.PackRuleName = collectorElement.GetAttribute(XmlPackRule);
+					package.Groups.Add(group);
-					collector.FilterRuleName = collectorElement.GetAttribute(XmlFilterRule);
+
-					collector.AssetTags = collectorElement.GetAttribute(XmlAssetTags); ;
+					// 读取收集器配置
-					group.Collectors.Add(collector);
+					var collectorNodeList = groupElement.GetElementsByTagName(XmlCollector);
+					foreach (var collectorNode in collectorNodeList)
+					{
+						XmlElement collectorElement = collectorNode as XmlElement;
+						if (collectorElement.HasAttribute(XmlCollectPath) == false)
+							throw new Exception($"Not found attribute {XmlCollectPath} in {XmlCollector}");
+						if (collectorElement.HasAttribute(XmlCollectorGUID) == false)
+							throw new Exception($"Not found attribute {XmlCollectorGUID} in {XmlCollector}");
+						if (collectorElement.HasAttribute(XmlCollectorType) == false)
+							throw new Exception($"Not found attribute {XmlCollectorType} in {XmlCollector}");
+						if (collectorElement.HasAttribute(XmlAddressRule) == false)
+							throw new Exception($"Not found attribute {XmlAddressRule} in {XmlCollector}");
+						if (collectorElement.HasAttribute(XmlPackRule) == false)
+							throw new Exception($"Not found attribute {XmlPackRule} in {XmlCollector}");
+						if (collectorElement.HasAttribute(XmlFilterRule) == false)
+							throw new Exception($"Not found attribute {XmlFilterRule} in {XmlCollector}");
+						if (collectorElement.HasAttribute(XmlUserData) == false)
+							throw new Exception($"Not found attribute {XmlUserData} in {XmlCollector}");
+						if (collectorElement.HasAttribute(XmlAssetTags) == false)
+							throw new Exception($"Not found attribute {XmlAssetTags} in {XmlCollector}");
+
+						AssetBundleCollector collector = new AssetBundleCollector();
+						collector.CollectPath = collectorElement.GetAttribute(XmlCollectPath);
+						collector.CollectorGUID = collectorElement.GetAttribute(XmlCollectorGUID);
+						collector.CollectorType = EditorTools.NameToEnum<ECollectorType>(collectorElement.GetAttribute(XmlCollectorType));
+						collector.AddressRuleName = collectorElement.GetAttribute(XmlAddressRule);
+						collector.PackRuleName = collectorElement.GetAttribute(XmlPackRule);
+						collector.FilterRuleName = collectorElement.GetAttribute(XmlFilterRule);
+						collector.UserData = collectorElement.GetAttribute(XmlUserData);
+						collector.AssetTags = collectorElement.GetAttribute(XmlAssetTags);
+						group.Collectors.Add(collector);
+					}
 				}
 			}
 
 			// 保存配置数据
 			AssetBundleCollectorSettingData.ClearAll();
 			AssetBundleCollectorSettingData.Setting.EnableAddressable = enableAddressable;
-			AssetBundleCollectorSettingData.Setting.AutoCollectShaders = autoCollectShaders;
+			AssetBundleCollectorSettingData.Setting.UniqueBundleName = uniqueBundleName;
-			AssetBundleCollectorSettingData.Setting.ShadersBundleName = shaderBundleName;
+			AssetBundleCollectorSettingData.Setting.ShowPackageView = showPackageView;
-			AssetBundleCollectorSettingData.Setting.Groups.AddRange(groupTemper);
+			AssetBundleCollectorSettingData.Setting.ShowEditorAlias = showEditorAlias;
+			AssetBundleCollectorSettingData.Setting.Packages.AddRange(packages);
 			AssetBundleCollectorSettingData.SaveFile();
 			Debug.Log($"导入配置完毕！");
 		}
@@ -152,30 +191,42 @@ namespace YooAsset.Editor
 			// 设置公共配置
 			var commonElement = xmlDoc.CreateElement(XmlCommon);
 			commonElement.SetAttribute(XmlEnableAddressable, AssetBundleCollectorSettingData.Setting.EnableAddressable.ToString());
-			commonElement.SetAttribute(XmlAutoCollectShader, AssetBundleCollectorSettingData.Setting.AutoCollectShaders.ToString());
+			commonElement.SetAttribute(XmlUniqueBundleName, AssetBundleCollectorSettingData.Setting.UniqueBundleName.ToString());
-			commonElement.SetAttribute(XmlShaderBundleName, AssetBundleCollectorSettingData.Setting.ShadersBundleName);
+			commonElement.SetAttribute(XmlShowPackageView, AssetBundleCollectorSettingData.Setting.ShowPackageView.ToString());
+			commonElement.SetAttribute(XmlShowEditorAlias, AssetBundleCollectorSettingData.Setting.ShowEditorAlias.ToString());
 			root.AppendChild(commonElement);
 
-			// 设置分组配置
+			// 设置Package配置
-			foreach (var group in AssetBundleCollectorSettingData.Setting.Groups)
+			foreach (var package in AssetBundleCollectorSettingData.Setting.Packages)
 			{
-				var groupElement = xmlDoc.CreateElement(XmlGroup);
+				var packageElement = xmlDoc.CreateElement(XmlPackage);
-				groupElement.SetAttribute(XmlGroupName, group.GroupName);
+				packageElement.SetAttribute(XmlPackageName, package.PackageName);
-				groupElement.SetAttribute(XmlGroupDesc, group.GroupDesc);
+				packageElement.SetAttribute(XmlPackageDesc, package.PackageDesc);
-				groupElement.SetAttribute(XmlAssetTags, group.AssetTags);
+				root.AppendChild(packageElement);
-				root.AppendChild(groupElement);
 
-				// 设置收集器配置
+				// 设置分组配置
-				foreach (var collector in group.Collectors)
+				foreach (var group in package.Groups)
 				{
-					var collectorElement = xmlDoc.CreateElement(XmlCollector);
+					var groupElement = xmlDoc.CreateElement(XmlGroup);
-					collectorElement.SetAttribute(XmlCollectPath, collector.CollectPath);
+					groupElement.SetAttribute(XmlGroupName, group.GroupName);
-					collectorElement.SetAttribute(XmlCollectorType, collector.CollectorType.ToString());
+					groupElement.SetAttribute(XmlGroupDesc, group.GroupDesc);
-					collectorElement.SetAttribute(XmlAddressRule, collector.AddressRuleName);
+					groupElement.SetAttribute(XmlAssetTags, group.AssetTags);
-					collectorElement.SetAttribute(XmlPackRule, collector.PackRuleName);
+					packageElement.AppendChild(groupElement);
-					collectorElement.SetAttribute(XmlFilterRule, collector.FilterRuleName);
+
-					collectorElement.SetAttribute(XmlAssetTags, collector.AssetTags);
+					// 设置收集器配置
-					groupElement.AppendChild(collectorElement);
+					foreach (var collector in group.Collectors)
+					{
+						var collectorElement = xmlDoc.CreateElement(XmlCollector);
+						collectorElement.SetAttribute(XmlCollectPath, collector.CollectPath);
+						collectorElement.SetAttribute(XmlCollectorGUID, collector.CollectorGUID);
+						collectorElement.SetAttribute(XmlCollectorType, collector.CollectorType.ToString());
+						collectorElement.SetAttribute(XmlAddressRule, collector.AddressRuleName);
+						collectorElement.SetAttribute(XmlPackRule, collector.PackRuleName);
+						collectorElement.SetAttribute(XmlFilterRule, collector.FilterRuleName);
+						collectorElement.SetAttribute(XmlUserData, collector.UserData);
+						collectorElement.SetAttribute(XmlAssetTags, collector.AssetTags);
+						groupElement.AppendChild(collectorElement);
+					}
 				}
 			}
 
@@ -183,5 +234,120 @@ namespace YooAsset.Editor
 			xmlDoc.Save(savePath);
 			Debug.Log($"导出配置完毕！");
 		}
+
+		/// <summary>
+		/// 升级XML配置表
+		/// </summary>
+		private static bool UpdateXmlConfig(XmlDocument xmlDoc)
+		{
+			XmlElement root = xmlDoc.DocumentElement;
+			string configVersion = root.GetAttribute(XmlVersion);
+			if (configVersion == ConfigVersion)
+				return true;
+
+			// 1.0 -> 2.0
+			if (configVersion == "1.0")
+			{
+				// 添加公共元素属性
+				var commonNodeList = root.GetElementsByTagName(XmlCommon);
+				if (commonNodeList.Count > 0)
+				{
+					XmlElement commonElement = commonNodeList[0] as XmlElement;
+					if (commonElement.HasAttribute(XmlShowPackageView) == false)
+						commonElement.SetAttribute(XmlShowPackageView, "False");
+				}
+
+				// 添加包裹元素
+				var packageElement = xmlDoc.CreateElement(XmlPackage);
+				packageElement.SetAttribute(XmlPackageName, "DefaultPackage");
+				packageElement.SetAttribute(XmlPackageDesc, string.Empty);
+				root.AppendChild(packageElement);
+
+				// 获取所有分组元素
+				var groupNodeList = root.GetElementsByTagName(XmlGroup);
+				List<XmlElement> temper = new List<XmlElement>(groupNodeList.Count);
+				foreach (var groupNode in groupNodeList)
+				{
+					XmlElement groupElement = groupNode as XmlElement;
+					var collectorNodeList = groupElement.GetElementsByTagName(XmlCollector);
+					foreach (var collectorNode in collectorNodeList)
+					{
+						XmlElement collectorElement = collectorNode as XmlElement;
+						if (collectorElement.HasAttribute(XmlCollectorGUID) == false)
+							collectorElement.SetAttribute(XmlCollectorGUID, string.Empty);
+					}
+					temper.Add(groupElement);
+				}
+
+				// 将分组元素转移至包裹元素下
+				foreach (var groupElement in temper)
+				{
+					root.RemoveChild(groupElement);
+					packageElement.AppendChild(groupElement);
+				}
+
+				// 更新版本
+				root.SetAttribute(XmlVersion, "2.0");
+				return UpdateXmlConfig(xmlDoc);
+			}
+
+			// 2.0 -> 2.1
+			if (configVersion == "2.0")
+			{
+				// 添加公共元素属性
+				var commonNodeList = root.GetElementsByTagName(XmlCommon);
+				if (commonNodeList.Count > 0)
+				{
+					XmlElement commonElement = commonNodeList[0] as XmlElement;
+					if (commonElement.HasAttribute(XmlUniqueBundleName) == false)
+						commonElement.SetAttribute(XmlUniqueBundleName, "False");
+				}
+
+				// 更新版本
+				root.SetAttribute(XmlVersion, "2.1");
+				return UpdateXmlConfig(xmlDoc);
+			}
+
+			// 2.1 -> 2.2
+			if (configVersion == "2.1")
+			{
+				// 添加公共元素属性
+				var commonNodeList = root.GetElementsByTagName(XmlCommon);
+				if (commonNodeList.Count > 0)
+				{
+					XmlElement commonElement = commonNodeList[0] as XmlElement;
+					if (commonElement.HasAttribute(XmlShowEditorAlias) == false)
+						commonElement.SetAttribute(XmlShowEditorAlias, "False");
+				}
+
+				// 更新版本
+				root.SetAttribute(XmlVersion, "2.2");
+				return UpdateXmlConfig(xmlDoc);
+			}
+
+			// 2.2 -> 2.3
+			if (configVersion == "2.2")
+			{
+				// 获取所有分组元素
+				var groupNodeList = root.GetElementsByTagName(XmlGroup);
+				foreach (var groupNode in groupNodeList)
+				{
+					XmlElement groupElement = groupNode as XmlElement;
+					var collectorNodeList = groupElement.GetElementsByTagName(XmlCollector);
+					foreach (var collectorNode in collectorNodeList)
+					{
+						XmlElement collectorElement = collectorNode as XmlElement;
+						if (collectorElement.HasAttribute(XmlUserData) == false)
+							collectorElement.SetAttribute(XmlUserData, string.Empty);
+					}
+				}
+
+				// 更新版本
+				root.SetAttribute(XmlVersion, "2.3");
+				return UpdateXmlConfig(xmlDoc);
+			}
+
+			return false;
+		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorGroup.cs

@@ -25,6 +25,11 @@ namespace YooAsset.Editor
 		/// </summary>
 		public string AssetTags = string.Empty;
 
+		/// <summary>
+		/// 分组激活规则
+		/// </summary>
+		public string ActiveRuleName = nameof(EnableGroup);
+
 		/// <summary>
 		/// 分组的收集器列表
 		/// </summary>
@@ -36,23 +41,49 @@ 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();
 			}
 		}
 
+		/// <summary>
+		/// 修复配置错误
+		/// </summary>
+		public bool FixConfigError()
+		{
+			bool isFixed = false;
+			foreach (var collector in Collectors)
+			{
+				if (collector.FixConfigError())
+				{
+					isFixed = true;
+				}
+			}
+			return isFixed;
+		}
+
 		/// <summary>
 		/// 获取打包收集的资源文件
 		/// </summary>
-		public List<CollectAssetInfo> GetAllCollectAssets()
+		public List<CollectAssetInfo> GetAllCollectAssets(CollectCommand command)
 		{
 			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(command, this);
 				foreach (var assetInfo in temper)
 				{
 					if (result.ContainsKey(assetInfo.AssetPath) == false)
@@ -63,7 +94,7 @@ namespace YooAsset.Editor
 			}
 
 			// 检测可寻址地址是否重复
-			if (AssetBundleCollectorSettingData.Setting.EnableAddressable)
+			if (command.EnableAddressable)
 			{
 				HashSet<string> adressTemper = new HashSet<string>();
 				foreach (var collectInfoPair in result)

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorPackage.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[Serializable]
+	public class AssetBundleCollectorPackage
+	{
+		/// <summary>
+		/// 包裹名称
+		/// </summary>
+		public string PackageName = string.Empty;
+
+		/// <summary>
+		/// 包裹描述
+		/// </summary>
+		public string PackageDesc = string.Empty;
+
+		/// <summary>
+		/// 分组列表
+		/// </summary>
+		public List<AssetBundleCollectorGroup> Groups = new List<AssetBundleCollectorGroup>();
+
+
+		/// <summary>
+		/// 检测配置错误
+		/// </summary>
+		public void CheckConfigError()
+		{
+			foreach (var group in Groups)
+			{
+				group.CheckConfigError();
+			}
+		}
+
+		/// <summary>
+		/// 修复配置错误
+		/// </summary>
+		public bool FixConfigError()
+		{
+			bool isFixed = false;
+			foreach (var group in Groups)
+			{
+				if (group.FixConfigError())
+				{
+					isFixed = true;
+				}
+			}
+			return isFixed;
+		}
+
+		/// <summary>
+		/// 获取打包收集的资源文件
+		/// </summary>
+		public List<CollectAssetInfo> GetAllCollectAssets(CollectCommand command)
+		{
+			Dictionary<string, CollectAssetInfo> result = new Dictionary<string, CollectAssetInfo>(10000);
+
+			// 收集打包资源
+			foreach (var group in Groups)
+			{
+				var temper = group.GetAllCollectAssets(command);
+				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}");
+				}
+			}
+
+			// 检测可寻址地址是否重复
+			if (command.EnableAddressable)
+			{
+				HashSet<string> adressTemper = new HashSet<string>();
+				foreach (var collectInfoPair in result)
+				{
+					if (collectInfoPair.Value.CollectorType == ECollectorType.MainAssetCollector)
+					{
+						string address = collectInfoPair.Value.Address;
+						if (adressTemper.Contains(address) == false)
+							adressTemper.Add(address);
+						else
+							throw new Exception($"The address is existed : {address}");
+					}
+				}
+			}
+
+			// 返回列表
+			return result.Values.ToList();
+		}
+
+		/// <summary>
+		/// 获取所有的资源标签
+		/// </summary>
+		public List<string> GetAllTags()
+		{
+			HashSet<string> result = new HashSet<string>();
+			foreach (var group in Groups)
+			{
+				List<string> groupTags = EditorTools.StringToStringList(group.AssetTags, ';');
+				foreach (var tag in groupTags)
+				{
+					if (result.Contains(tag) == false)
+						result.Add(tag);
+				}
+
+				foreach (var collector in group.Collectors)
+				{
+					List<string> collectorTags = EditorTools.StringToStringList(collector.AssetTags, ';');
+					foreach (var tag in collectorTags)
+					{
+						if (result.Contains(tag) == false)
+							result.Add(tag);
+					}
+				}
+			}
+			return result.ToList();
+		}
+	}
+}

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

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

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorSetting.cs

@@ -8,7 +8,10 @@ namespace YooAsset.Editor
 {
 	public class AssetBundleCollectorSetting : ScriptableObject
 	{
-		public static EBuildMode BuildMode;
+		/// <summary>
+		/// 是否显示包裹列表视图
+		/// </summary>
+		public bool ShowPackageView = false;
 
 		/// <summary>
 		/// 是否启用可寻址资源定位
@@ -16,73 +19,111 @@ namespace YooAsset.Editor
 		public bool EnableAddressable = false;
 
 		/// <summary>
-		/// 自动收集着色器
+		/// 资源包名唯一化
 		/// </summary>
-		public bool AutoCollectShaders = true;
+		public bool UniqueBundleName = false;
 
 		/// <summary>
-		/// 自动收集的着色器资源包名称
+		/// 是否显示编辑器别名
 		/// </summary>
-		public string ShadersBundleName = "myshaders";
+		public bool ShowEditorAlias = false;
+
 
 		/// <summary>
-		/// 分组列表
+		/// 包裹列表
 		/// </summary>
-		public List<AssetBundleCollectorGroup> Groups = new List<AssetBundleCollectorGroup>();
+		public List<AssetBundleCollectorPackage> Packages = new List<AssetBundleCollectorPackage>();
 
 
+		/// <summary>
+		/// 清空所有数据
+		/// </summary>
+		public void ClearAll()
+		{
+			EnableAddressable = false;
+			Packages.Clear();
+		}
+
 		/// <summary>
 		/// 检测配置错误
 		/// </summary>
 		public void CheckConfigError()
 		{
-			foreach (var group in Groups)
+			foreach (var package in Packages)
 			{
-				group.CheckConfigError();
+				package.CheckConfigError();
 			}
 		}
 
 		/// <summary>
-		/// 获取打包收集的资源文件
+		/// 修复配置错误
 		/// </summary>
-		public List<CollectAssetInfo> GetAllCollectAssets(EBuildMode buildMode)
+		public bool FixConfigError()
 		{
-			BuildMode = buildMode;
+			bool isFixed = false;
-
+			foreach (var package in Packages)
-			Dictionary<string, CollectAssetInfo> result = new Dictionary<string, CollectAssetInfo>(10000);
-
-			// 收集打包资源
-			foreach (var group in Groups)
 			{
-				var temper = group.GetAllCollectAssets();
+				if (package.FixConfigError())
-				foreach (var assetInfo in temper)
 				{
-					if (result.ContainsKey(assetInfo.AssetPath) == false)
+					isFixed = true;
-						result.Add(assetInfo.AssetPath, assetInfo);
+				}
-					else
+			}
-						throw new Exception($"The collecting asset file is existed : {assetInfo.AssetPath} in group setting.");
+			return isFixed;
+		}
+
+		/// <summary>
+		/// 获取所有的资源标签
+		/// </summary>
+		public List<string> GetPackageAllTags(string packageName)
+		{
+			foreach (var package in Packages)
+			{
+				if (package.PackageName == packageName)
+				{
+					return package.GetAllTags();
 				}
 			}
 
-			// 检测可寻址地址是否重复
+			Debug.LogWarning($"Not found package : {packageName}");
-			if (EnableAddressable)
+			return new List<string>();
+		}
+
+		/// <summary>
+		/// 获取包裹收集的资源文件
+		/// </summary>
+		public CollectResult GetPackageAssets(EBuildMode buildMode, string packageName)
+		{
+			if (string.IsNullOrEmpty(packageName))
+				throw new Exception("Build package name is null or mepty !");
+
+			foreach (var package in Packages)
 			{
-				HashSet<string> adressTemper = new HashSet<string>();
+				if (package.PackageName == packageName)
-				foreach (var collectInfoPair in result)
 				{
-					if (collectInfoPair.Value.CollectorType == ECollectorType.MainAssetCollector)
+					CollectCommand command = new CollectCommand(buildMode, package.PackageName, EnableAddressable, UniqueBundleName);
-					{
+					CollectResult collectResult = new CollectResult(command);
-						string address = collectInfoPair.Value.Address;
+					collectResult.SetCollectAssets(package.GetAllCollectAssets(command));
-						if (adressTemper.Contains(address) == false)
+					return collectResult;
-							adressTemper.Add(address);
-						else
-							throw new Exception($"The address is existed : {address} in group setting.");
-					}
 				}
 			}
 
-			// 返回列表
+			throw new Exception($"Not found collector pacakge : {packageName}");
-			return result.Values.ToList();
+		}
+
+		/// <summary>
+		/// 获取所有包裹收集的资源文件
+		/// </summary>
+		public List<CollectResult> GetAllPackageAssets(EBuildMode buildMode)
+		{
+			List<CollectResult> collectResultList = new List<CollectResult>(1000);
+			foreach (var package in Packages)
+			{
+				CollectCommand command = new CollectCommand(buildMode, package.PackageName, EnableAddressable, UniqueBundleName);
+				CollectResult collectResult = new CollectResult(command);
+				collectResult.SetCollectAssets(package.GetAllCollectAssets(command));
+				collectResultList.Add(collectResult);
+			}
+			return collectResultList;
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorSettingData.cs

@@ -9,6 +9,9 @@ namespace YooAsset.Editor
 {
 	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>();
 
@@ -35,77 +38,12 @@ namespace YooAsset.Editor
 			}
 		}
 
-		public static List<string> GetAddressRuleNames()
-		{
-			if (_setting == null)
-				LoadSettingData();
-
-			List<string> names = new List<string>();
-			foreach (var pair in _cacheAddressRuleTypes)
-			{
-				names.Add(pair.Key);
-			}
-			return names;
-		}
-		public static List<string> GetPackRuleNames()
-		{
-			if (_setting == null)
-				LoadSettingData();
-
-			List<string> names = new List<string>();
-			foreach (var pair in _cachePackRuleTypes)
-			{
-				names.Add(pair.Key);
-			}
-			return names;
-		}
-		public static List<string> GetFilterRuleNames()
-		{
-			if (_setting == null)
-				LoadSettingData();
-
-			List<string> names = new List<string>();
-			foreach (var pair in _cacheFilterRuleTypes)
-			{
-				names.Add(pair.Key);
-			}
-			return names;
-		}
-		public static bool HasAddressRuleName(string ruleName)
-		{
-			foreach (var pair in _cacheAddressRuleTypes)
-			{
-				if (pair.Key == ruleName)
-					return true;
-			}
-			return false;
-		}
-		public static bool HasPackRuleName(string ruleName)
-		{
-			foreach (var pair in _cachePackRuleTypes)
-			{
-				if (pair.Key == ruleName)
-					return true;
-			}
-			return false;
-		}
-		public static bool HasFilterRuleName(string ruleName)
-		{
-			foreach (var pair in _cacheFilterRuleTypes)
-			{
-				if (pair.Key == ruleName)
-					return true;
-			}
-			return false;
-		}
-
-
 		/// <summary>
 		/// 加载配置文件
 		/// </summary>
 		private static void LoadSettingData()
 		{
-			_setting = YooAssetEditorSettingsHelper.LoadSettingData<AssetBundleCollectorSetting>();
+			_setting = EditorHelper.LoadSettingData<AssetBundleCollectorSetting>();
 
 			// IPackRule
 			{
@@ -122,6 +60,7 @@ namespace YooAsset.Editor
 					typeof(PackCollector),
 					typeof(PackGroup),
 					typeof(PackRawFile),
+					typeof(PackShaderVariants)
 				};
 
 				var customTypes = EditorTools.GetAssignableTypes(typeof(IPackRule));
@@ -169,7 +108,7 @@ namespace YooAsset.Editor
 				List<Type> types = new List<Type>(100)
 				{
 					typeof(AddressByFileName),
-					typeof(AddressByCollectorAndFileName),
+					typeof(AddressByFolderAndFileName),
 					typeof(AddressByGroupAndFileName)
 				};
 
@@ -182,10 +121,33 @@ 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>
-		/// 存储文件
+		/// 存储配置文件
 		/// </summary>
 		public static void SaveFile()
 		{
@@ -198,18 +160,130 @@ namespace YooAsset.Editor
 			}
 		}
 
+		/// <summary>
+		/// 修复配置文件
+		/// </summary>
+		public static void FixFile()
+		{
+			bool isFixed = Setting.FixConfigError();
+			if (isFixed)
+			{
+				IsDirty = true;
+			}
+		}
+
 		/// <summary>
 		/// 清空所有数据
 		/// </summary>
 		public static void ClearAll()
 		{
-			Setting.AutoCollectShaders = false;
+			Setting.ClearAll();
-			Setting.ShadersBundleName = string.Empty;
-			Setting.Groups.Clear();
 			SaveFile();
 		}
 
-		// 实例类相关
+		public static List<RuleDisplayName> GetActiveRuleNames()
+		{
+			if (_setting == null)
+				LoadSettingData();
+
+			List<RuleDisplayName> names = new List<RuleDisplayName>();
+			foreach (var pair in _cacheActiveRuleTypes)
+			{
+				RuleDisplayName ruleName = new RuleDisplayName();
+				ruleName.ClassName = pair.Key;
+				ruleName.DisplayName = GetRuleDisplayName(pair.Key, pair.Value);
+				names.Add(ruleName);
+			}
+			return names;
+		}
+		public static List<RuleDisplayName> GetAddressRuleNames()
+		{
+			if (_setting == null)
+				LoadSettingData();
+
+			List<RuleDisplayName> names = new List<RuleDisplayName>();
+			foreach (var pair in _cacheAddressRuleTypes)
+			{
+				RuleDisplayName ruleName = new RuleDisplayName();
+				ruleName.ClassName = pair.Key;
+				ruleName.DisplayName = GetRuleDisplayName(pair.Key, pair.Value);
+				names.Add(ruleName);
+			}
+			return names;
+		}
+		public static List<RuleDisplayName> GetPackRuleNames()
+		{
+			if (_setting == null)
+				LoadSettingData();
+
+			List<RuleDisplayName> names = new List<RuleDisplayName>();
+			foreach (var pair in _cachePackRuleTypes)
+			{
+				RuleDisplayName ruleName = new RuleDisplayName();
+				ruleName.ClassName = pair.Key;
+				ruleName.DisplayName = GetRuleDisplayName(pair.Key, pair.Value);
+				names.Add(ruleName);
+			}
+			return names;
+		}
+		public static List<RuleDisplayName> GetFilterRuleNames()
+		{
+			if (_setting == null)
+				LoadSettingData();
+
+			List<RuleDisplayName> names = new List<RuleDisplayName>();
+			foreach (var pair in _cacheFilterRuleTypes)
+			{
+				RuleDisplayName ruleName = new RuleDisplayName();
+				ruleName.ClassName = pair.Key;
+				ruleName.DisplayName = GetRuleDisplayName(pair.Key, pair.Value);
+				names.Add(ruleName);
+			}
+			return names;
+		}
+		private static string GetRuleDisplayName(string name, Type type)
+		{
+			var attribute = EditorAttribute.GetAttribute<DisplayNameAttribute>(type);
+			if (attribute != null && string.IsNullOrEmpty(attribute.DisplayName) == false)
+				return attribute.DisplayName;
+			else
+				return name;
+		}
+
+		public static bool HasActiveRuleName(string ruleName)
+		{
+			return _cacheActiveRuleTypes.Keys.Contains(ruleName);
+		}
+		public static bool HasAddressRuleName(string ruleName)
+		{
+			return _cacheAddressRuleTypes.Keys.Contains(ruleName);
+		}
+		public static bool HasPackRuleName(string ruleName)
+		{
+			return _cachePackRuleTypes.Keys.Contains(ruleName);
+		}
+		public static bool HasFilterRuleName(string ruleName)
+		{
+			return _cacheFilterRuleTypes.Keys.Contains(ruleName);
+		}
+
+		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))
@@ -262,32 +336,68 @@ namespace YooAsset.Editor
 			}
 		}
 
-		// 可寻址编辑相关
+		// 公共参数编辑相关
+		public static void ModifyPackageView(bool showPackageView)
+		{
+			Setting.ShowPackageView = showPackageView;
+			IsDirty = true;
+		}
 		public static void ModifyAddressable(bool enableAddressable)
 		{
 			Setting.EnableAddressable = enableAddressable;
 			IsDirty = true;
 		}
-
+		public static void ModifyUniqueBundleName(bool uniqueBundleName)
-		// 着色器编辑相关
-		public static void ModifyShader(bool isCollectAllShaders, string shadersBundleName)
 		{
-			Setting.AutoCollectShaders = isCollectAllShaders;
+			Setting.UniqueBundleName = uniqueBundleName;
-			Setting.ShadersBundleName = shadersBundleName;
 			IsDirty = true;
 		}
+		public static void ModifyShowEditorAlias(bool showAlias)
+		{
+			Setting.ShowEditorAlias = showAlias;
+			IsDirty = true;
+		}
+
+		// 资源包裹编辑相关
+		public static AssetBundleCollectorPackage CreatePackage(string packageName)
+		{
+			AssetBundleCollectorPackage package = new AssetBundleCollectorPackage();
+			package.PackageName = packageName;
+			Setting.Packages.Add(package);
+			IsDirty = true;
+			return package;
+		}
+		public static void RemovePackage(AssetBundleCollectorPackage package)
+		{
+			if (Setting.Packages.Remove(package))
+			{
+				IsDirty = true;
+			}
+			else
+			{
+				Debug.LogWarning($"Failed remove package : {package.PackageName}");
+			}
+		}
+		public static void ModifyPackage(AssetBundleCollectorPackage package)
+		{
+			if (package != null)
+			{
+				IsDirty = true;
+			}
+		}
 
 		// 资源分组编辑相关
-		public static void CreateGroup(string groupName)
+		public static AssetBundleCollectorGroup CreateGroup(AssetBundleCollectorPackage package, string groupName)
 		{
 			AssetBundleCollectorGroup group = new AssetBundleCollectorGroup();
 			group.GroupName = groupName;
-			Setting.Groups.Add(group);
+			package.Groups.Add(group);
 			IsDirty = true;
+			return group;
 		}
-		public static void RemoveGroup(AssetBundleCollectorGroup group)
+		public static void RemoveGroup(AssetBundleCollectorPackage package, AssetBundleCollectorGroup group)
 		{
-			if (Setting.Groups.Remove(group))
+			if (package.Groups.Remove(group))
 			{
 				IsDirty = true;
 			}
@@ -296,19 +406,17 @@ namespace YooAsset.Editor
 				Debug.LogWarning($"Failed remove group : {group.GroupName}");
 			}
 		}
-		public static void ModifyGroup(AssetBundleCollectorGroup group)
+		public static void ModifyGroup(AssetBundleCollectorPackage package, AssetBundleCollectorGroup group)
 		{
-			if (group != null)
+			if (package != null && group != null)
 			{
 				IsDirty = true;
 			}
 		}
 
 		// 资源收集器编辑相关
-		public static void CreateCollector(AssetBundleCollectorGroup group, string collectPath)
+		public static void CreateCollector(AssetBundleCollectorGroup group, AssetBundleCollector collector)
 		{
-			AssetBundleCollector collector = new AssetBundleCollector();
-			collector.CollectPath = collectPath;
 			group.Collectors.Add(collector);
 			IsDirty = true;
 		}
@@ -330,5 +438,14 @@ namespace YooAsset.Editor
 				IsDirty = true;
 			}
 		}
+
+		/// <summary>
+		/// 获取所有的资源标签
+		/// </summary>
+		public static string GetPackageAllTags(string packageName)
+		{
+			var allTags = Setting.GetPackageAllTags(packageName);
+			return string.Join(";", allTags);
+		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorWindow.cs

@@ -18,70 +18,149 @@ namespace YooAsset.Editor
 			window.minSize = new Vector2(800, 600);
 		}
 
+		private Button _saveButton;
 		private List<string> _collectorTypeList;
-		private List<string> _addressRuleList;
+		private List<RuleDisplayName> _activeRuleList;
-		private List<string> _packRuleList;
+		private List<RuleDisplayName> _addressRuleList;
-		private List<string> _filterRuleList;
+		private List<RuleDisplayName> _packRuleList;
-		private ListView _groupListView;
+		private List<RuleDisplayName> _filterRuleList;
-		private ScrollView _collectorScrollView;
+
+		private Toggle _showPackageToogle;
 		private Toggle _enableAddressableToogle;
-		private Toggle _autoCollectShaderToogle;
+		private Toggle _uniqueBundleNameToogle;
-		private TextField _shaderBundleNameTxt;
+		private Toggle _showEditorAliasToggle;
+
+		private VisualElement _packageContainer;
+		private ListView _packageListView;
+		private TextField _packageNameTxt;
+		private TextField _packageDescTxt;
+
+		private VisualElement _groupContainer;
+		private ListView _groupListView;
 		private TextField _groupNameTxt;
 		private TextField _groupDescTxt;
 		private TextField _groupAssetTagsTxt;
-		private VisualElement _groupContainer;
+
+		private VisualElement _collectorContainer;
+		private ScrollView _collectorScrollView;
+		private PopupField<RuleDisplayName> _activeRulePopupField;
+
+		private int _lastModifyPackageIndex = 0;
+		private int _lastModifyGroupIndex = 0;
+
 
 		public void CreateGUI()
 		{
 			Undo.undoRedoPerformed -= RefreshWindow;
 			Undo.undoRedoPerformed += RefreshWindow;
 
-			_collectorTypeList = new List<string>()
-			{
-				$"{nameof(ECollectorType.MainAssetCollector)}",
-				$"{nameof(ECollectorType.StaticAssetCollector)}",
-				$"{nameof(ECollectorType.DependAssetCollector)}"
-			};
-			_addressRuleList = AssetBundleCollectorSettingData.GetAddressRuleNames();
-			_packRuleList = AssetBundleCollectorSettingData.GetPackRuleNames();
-			_filterRuleList = AssetBundleCollectorSettingData.GetFilterRuleNames();
-
 			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 = YooAssetEditorSettingsData.Setting.AssetBundleCollectorUXML;
+				var visualAsset = EditorHelper.LoadWindowUXML<AssetBundleCollectorWindow>();
 				if (visualAsset == null)
-				{
-					Debug.LogError($"Not found {nameof(AssetBundleCollectorWindow)}.uxml in settings.");
 					return;
-				}
+
 				visualAsset.CloneTree(root);
 
+				// 公共设置相关
+				_showPackageToogle = root.Q<Toggle>("ShowPackages");
+				_showPackageToogle.RegisterValueChangedCallback(evt =>
+				{
+					AssetBundleCollectorSettingData.ModifyPackageView(evt.newValue);
+					RefreshWindow();
+				});
+				_enableAddressableToogle = root.Q<Toggle>("EnableAddressable");
+				_enableAddressableToogle.RegisterValueChangedCallback(evt =>
+				{
+					AssetBundleCollectorSettingData.ModifyAddressable(evt.newValue);
+					RefreshWindow();
+				});
+				_uniqueBundleNameToogle = root.Q<Toggle>("UniqueBundleName");
+				_uniqueBundleNameToogle.RegisterValueChangedCallback(evt =>
+				{
+					AssetBundleCollectorSettingData.ModifyUniqueBundleName(evt.newValue);
+					RefreshWindow();
+				});
+
+				_showEditorAliasToggle = root.Q<Toggle>("ShowEditorAlias");
+				_showEditorAliasToggle.RegisterValueChangedCallback(evt =>
+				{
+					AssetBundleCollectorSettingData.ModifyShowEditorAlias(evt.newValue);
+					RefreshWindow();
+				});
+
+				// 配置修复按钮
+				var fixBtn = root.Q<Button>("FixButton");
+				fixBtn.clicked += FixBtn_clicked;
+
 				// 导入导出按钮
 				var exportBtn = root.Q<Button>("ExportButton");
 				exportBtn.clicked += ExportBtn_clicked;
 				var importBtn = root.Q<Button>("ImportButton");
 				importBtn.clicked += ImportBtn_clicked;
 
-				// 公共设置相关
+				// 配置保存按钮
-				_enableAddressableToogle = root.Q<Toggle>("EnableAddressable");
+				_saveButton = root.Q<Button>("SaveButton");
-				_enableAddressableToogle.RegisterValueChangedCallback(evt =>
+				_saveButton.clicked += SaveBtn_clicked;
+
+				// 包裹容器
+				_packageContainer = root.Q("PackageContainer");
+
+				// 包裹列表相关
+				_packageListView = root.Q<ListView>("PackageListView");
+				_packageListView.makeItem = MakePackageListViewItem;
+				_packageListView.bindItem = BindPackageListViewItem;
+#if UNITY_2020_1_OR_NEWER
+				_packageListView.onSelectionChange += PackageListView_onSelectionChange;
+#else
+				_packageListView.onSelectionChanged += PackageListView_onSelectionChange;
+#endif
+
+				// 包裹添加删除按钮
+				var packageAddContainer = root.Q("PackageAddContainer");
 				{
-					AssetBundleCollectorSettingData.ModifyAddressable(evt.newValue);
+					var addBtn = packageAddContainer.Q<Button>("AddBtn");
+					addBtn.clicked += AddPackageBtn_clicked;
+					var removeBtn = packageAddContainer.Q<Button>("RemoveBtn");
+					removeBtn.clicked += RemovePackageBtn_clicked;
+				}
+
+				// 包裹名称
+				_packageNameTxt = root.Q<TextField>("PackageName");
+				_packageNameTxt.RegisterValueChangedCallback(evt =>
+				{
+					var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
+					if (selectPackage != null)
+					{
+						selectPackage.PackageName = evt.newValue;
+						AssetBundleCollectorSettingData.ModifyPackage(selectPackage);
+					}
 				});
-				_autoCollectShaderToogle = root.Q<Toggle>("AutoCollectShader");
+
-				_autoCollectShaderToogle.RegisterValueChangedCallback(evt =>
+				// 包裹备注
+				_packageDescTxt = root.Q<TextField>("PackageDesc");
+				_packageDescTxt.RegisterValueChangedCallback(evt =>
 				{
-					AssetBundleCollectorSettingData.ModifyShader(evt.newValue, _shaderBundleNameTxt.value);
+					var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
-					_shaderBundleNameTxt.SetEnabled(evt.newValue);
+					if (selectPackage != null)
-				});
+					{
-				_shaderBundleNameTxt = root.Q<TextField>("ShaderBundleName");
+						selectPackage.PackageDesc = evt.newValue;
-				_shaderBundleNameTxt.RegisterValueChangedCallback(evt =>
+						AssetBundleCollectorSettingData.ModifyPackage(selectPackage);
-				{
+					}
-					AssetBundleCollectorSettingData.ModifyShader(_autoCollectShaderToogle.value, evt.newValue);
 				});
 
 				// 分组列表相关
@@ -110,11 +189,13 @@ namespace YooAsset.Editor
 				_groupNameTxt = root.Q<TextField>("GroupName");
 				_groupNameTxt.RegisterValueChangedCallback(evt =>
 				{
+					var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
 					var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-					if (selectGroup != null)
+					if (selectPackage != null && selectGroup != null)
 					{
 						selectGroup.GroupName = evt.newValue;
-						AssetBundleCollectorSettingData.ModifyGroup(selectGroup);
+						AssetBundleCollectorSettingData.ModifyGroup(selectPackage, selectGroup);
+						FillGroupViewData();
 					}
 				});
 
@@ -122,11 +203,13 @@ namespace YooAsset.Editor
 				_groupDescTxt = root.Q<TextField>("GroupDesc");
 				_groupDescTxt.RegisterValueChangedCallback(evt =>
 				{
+					var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
 					var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-					if (selectGroup != null)
+					if (selectPackage != null && selectGroup != null)
 					{
 						selectGroup.GroupDesc = evt.newValue;
-						AssetBundleCollectorSettingData.ModifyGroup(selectGroup);
+						AssetBundleCollectorSettingData.ModifyGroup(selectPackage, selectGroup);
+						FillGroupViewData();
 					}
 				});
 
@@ -134,14 +217,18 @@ namespace YooAsset.Editor
 				_groupAssetTagsTxt = root.Q<TextField>("GroupAssetTags");
 				_groupAssetTagsTxt.RegisterValueChangedCallback(evt =>
 				{
+					var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
 					var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
-					if (selectGroup != null)
+					if (selectPackage != null && selectGroup != null)
 					{
 						selectGroup.AssetTags = evt.newValue;
-						AssetBundleCollectorSettingData.ModifyGroup(selectGroup);
+						AssetBundleCollectorSettingData.ModifyGroup(selectPackage, selectGroup);
 					}
 				});
 
+				// 收集列表容器
+				_collectorContainer = root.Q("CollectorContainer");
+
 				// 收集列表相关
 				_collectorScrollView = root.Q<ScrollView>("CollectorScrollView");
 				_collectorScrollView.style.height = new Length(100, LengthUnit.Percent);
@@ -154,6 +241,28 @@ namespace YooAsset.Editor
 					addBtn.clicked += AddCollectorBtn_clicked;
 				}
 
+				// 分组激活规则
+				var activeRuleContainer = root.Q("ActiveRuleContainer");
+				{
+					_activeRulePopupField = new PopupField<RuleDisplayName>("Active Rule", _activeRuleList, 0);
+					_activeRulePopupField.name = "ActiveRuleMaskField";
+					_activeRulePopupField.style.unityTextAlign = TextAnchor.MiddleLeft;
+					_activeRulePopupField.formatListItemCallback = FormatListItemCallback;
+					_activeRulePopupField.formatSelectedValueCallback = FormatSelectedValueCallback;
+					_activeRulePopupField.RegisterValueChangedCallback(evt =>
+					{
+						var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
+						var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
+						if (selectPackage != null && selectGroup != null)
+						{
+							selectGroup.ActiveRuleName = evt.newValue.ClassName;
+							AssetBundleCollectorSettingData.ModifyGroup(selectPackage, selectGroup);
+							FillGroupViewData();
+						}
+					});
+					activeRuleContainer.Add(_activeRulePopupField);
+				}
+
 				// 刷新窗体
 				RefreshWindow();
 			}
@@ -164,19 +273,45 @@ namespace YooAsset.Editor
 		}
 		public void OnDestroy()
 		{
+			// 注意：清空所有撤销操作
+			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()
 		{
+			_showPackageToogle.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.ShowPackageView);
 			_enableAddressableToogle.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.EnableAddressable);
-			_autoCollectShaderToogle.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.AutoCollectShaders);
+			_uniqueBundleNameToogle.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.UniqueBundleName);
-			_shaderBundleNameTxt.SetEnabled(AssetBundleCollectorSettingData.Setting.AutoCollectShaders);
+			_showEditorAliasToggle.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.ShowEditorAlias);
-			_shaderBundleNameTxt.SetValueWithoutNotify(AssetBundleCollectorSettingData.Setting.ShadersBundleName);
-			_groupContainer.visible = false;
 
-			FillGroupViewData();
+			_groupContainer.visible = false;
+			_collectorContainer.visible = false;
+
+			FillPackageViewData();
+		}
+		private void FixBtn_clicked()
+		{
+			AssetBundleCollectorSettingData.FixFile();
+			RefreshWindow();
 		}
 		private void ExportBtn_clicked()
 		{
@@ -195,14 +330,117 @@ namespace YooAsset.Editor
 				RefreshWindow();
 			}
 		}
+		private void SaveBtn_clicked()
+		{
+			AssetBundleCollectorSettingData.SaveFile();
+		}
+		private string FormatListItemCallback(RuleDisplayName ruleDisplayName)
+		{
+			if (_showEditorAliasToggle.value)
+				return ruleDisplayName.DisplayName;
+			else
+				return ruleDisplayName.ClassName;
+		}
+		private string FormatSelectedValueCallback(RuleDisplayName ruleDisplayName)
+		{
+			if (_showEditorAliasToggle.value)
+				return ruleDisplayName.DisplayName;
+			else
+				return ruleDisplayName.ClassName;
+		}
+
+		// 包裹列表相关
+		private void FillPackageViewData()
+		{
+			_packageListView.Clear();
+			_packageListView.ClearSelection();
+			_packageListView.itemsSource = AssetBundleCollectorSettingData.Setting.Packages;
+			_packageListView.Rebuild();
+
+			if (_lastModifyPackageIndex >= 0 && _lastModifyPackageIndex < _packageListView.itemsSource.Count)
+			{
+				_packageListView.selectedIndex = _lastModifyPackageIndex;
+			}
+
+			if (_showPackageToogle.value)
+				_packageContainer.style.display = DisplayStyle.Flex;
+			else
+				_packageContainer.style.display = DisplayStyle.None;
+		}
+		private VisualElement MakePackageListViewItem()
+		{
+			VisualElement element = new VisualElement();
+
+			{
+				var label = new Label();
+				label.name = "Label1";
+				label.style.unityTextAlign = TextAnchor.MiddleLeft;
+				label.style.flexGrow = 1f;
+				label.style.height = 20f;
+				element.Add(label);
+			}
+
+			return element;
+		}
+		private void BindPackageListViewItem(VisualElement element, int index)
+		{
+			var package = AssetBundleCollectorSettingData.Setting.Packages[index];
+
+			var textField1 = element.Q<Label>("Label1");
+			if (string.IsNullOrEmpty(package.PackageDesc))
+				textField1.text = package.PackageName;
+			else
+				textField1.text = $"{package.PackageName} ({package.PackageDesc})";
+		}
+		private void PackageListView_onSelectionChange(IEnumerable<object> objs)
+		{
+			var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
+			if (selectPackage == null)
+			{
+				_groupContainer.visible = false;
+				_collectorContainer.visible = false;
+				return;
+			}
+
+			_groupContainer.visible = true;
+			_lastModifyPackageIndex = _packageListView.selectedIndex;
+			_packageNameTxt.SetValueWithoutNotify(selectPackage.PackageName);
+			_packageDescTxt.SetValueWithoutNotify(selectPackage.PackageDesc);
+			FillGroupViewData();
+		}
+		private void AddPackageBtn_clicked()
+		{
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow AddPackage");
+			AssetBundleCollectorSettingData.CreatePackage("DefaultPackage");
+			FillPackageViewData();
+		}
+		private void RemovePackageBtn_clicked()
+		{
+			var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
+			if (selectPackage == null)
+				return;
+
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow RemovePackage");
+			AssetBundleCollectorSettingData.RemovePackage(selectPackage);
+			FillPackageViewData();
+		}
 
 		// 分组列表相关
 		private void FillGroupViewData()
 		{
+			var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
+			if (selectPackage == null)
+				return;
+
 			_groupListView.Clear();
 			_groupListView.ClearSelection();
-			_groupListView.itemsSource = AssetBundleCollectorSettingData.Setting.Groups;
+			_groupListView.itemsSource = selectPackage.Groups;
 			_groupListView.Rebuild();
+
+			if (_lastModifyGroupIndex >= 0 && _lastModifyGroupIndex < _groupListView.itemsSource.Count)
+			{
+				_groupListView.selectedIndex = _lastModifyGroupIndex;
+			}
 		}
 		private VisualElement MakeGroupListViewItem()
 		{
@@ -221,34 +459,63 @@ namespace YooAsset.Editor
 		}
 		private void BindGroupListViewItem(VisualElement element, int index)
 		{
-			var group = AssetBundleCollectorSettingData.Setting.Groups[index];
+			var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
+			if (selectPackage == null)
+				return;
+
+			var group = selectPackage.Groups[index];
 
-			// Group Name
 			var textField1 = element.Q<Label>("Label1");
 			if (string.IsNullOrEmpty(group.GroupDesc))
 				textField1.text = group.GroupName;
 			else
 				textField1.text = $"{group.GroupName} ({group.GroupDesc})";
+
+			// 激活状态
+			IActiveRule activeRule = AssetBundleCollectorSettingData.GetActiveRuleInstance(group.ActiveRuleName);
+			bool isActive = activeRule.IsActiveGroup();
+			textField1.SetEnabled(isActive);
 		}
 		private void GroupListView_onSelectionChange(IEnumerable<object> objs)
 		{
+			var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
+			if (selectGroup == null)
+			{
+				_collectorContainer.visible = false;
+				return;
+			}
+
+			_collectorContainer.visible = true;
+			_lastModifyGroupIndex = _groupListView.selectedIndex;
+			_activeRulePopupField.SetValueWithoutNotify(GetActiveRuleIndex(selectGroup.ActiveRuleName));
+			_groupNameTxt.SetValueWithoutNotify(selectGroup.GroupName);
+			_groupDescTxt.SetValueWithoutNotify(selectGroup.GroupDesc);
+			_groupAssetTagsTxt.SetValueWithoutNotify(selectGroup.AssetTags);
+
 			FillCollectorViewData();
 		}
 		private void AddGroupBtn_clicked()
 		{
-			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset AddGroup");
+			var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
-			AssetBundleCollectorSettingData.CreateGroup("Default Group");
+			if (selectPackage == null)
+				return;
+
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow AddGroup");
+			AssetBundleCollectorSettingData.CreateGroup(selectPackage, "Default Group");
 			FillGroupViewData();
 		}
 		private void RemoveGroupBtn_clicked()
 		{
+			var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
+			if (selectPackage == null)
+				return;
+
 			var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
 			if (selectGroup == null)
 				return;
 
-			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset RemoveGroup");
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow RemoveGroup");
-
+			AssetBundleCollectorSettingData.RemoveGroup(selectPackage, selectGroup);
-			AssetBundleCollectorSettingData.RemoveGroup(selectGroup);
 			FillGroupViewData();
 		}
 
@@ -257,15 +524,7 @@ namespace YooAsset.Editor
 		{
 			var selectGroup = _groupListView.selectedItem as AssetBundleCollectorGroup;
 			if (selectGroup == null)
-			{
-				_groupContainer.visible = false;
 				return;
-			}
-
-			_groupContainer.visible = true;
-			_groupNameTxt.SetValueWithoutNotify(selectGroup.GroupName);
-			_groupDescTxt.SetValueWithoutNotify(selectGroup.GroupDesc);
-			_groupAssetTagsTxt.SetValueWithoutNotify(selectGroup.AssetTags);
 
 			// 填充数据
 			_collectorScrollView.Clear();
@@ -332,26 +591,35 @@ namespace YooAsset.Editor
 			}
 			if (_enableAddressableToogle.value)
 			{
-				var popupField = new PopupField<string>(_addressRuleList, 0);
+				var popupField = new PopupField<RuleDisplayName>(_addressRuleList, 0);
 				popupField.name = "PopupField1";
 				popupField.style.unityTextAlign = TextAnchor.MiddleLeft;
-				popupField.style.width = 200;
+				popupField.style.width = 220;
 				elementBottom.Add(popupField);
 			}
 			{
-				var popupField = new PopupField<string>(_packRuleList, 0);
+				var popupField = new PopupField<RuleDisplayName>(_packRuleList, 0);
 				popupField.name = "PopupField2";
 				popupField.style.unityTextAlign = TextAnchor.MiddleLeft;
-				popupField.style.width = 150;
+				popupField.style.width = 220;
 				elementBottom.Add(popupField);
 			}
 			{
-				var popupField = new PopupField<string>(_filterRuleList, 0);
+				var popupField = new PopupField<RuleDisplayName>(_filterRuleList, 0);
 				popupField.name = "PopupField3";
 				popupField.style.unityTextAlign = TextAnchor.MiddleLeft;
 				popupField.style.width = 150;
 				elementBottom.Add(popupField);
 			}
+			{
+				var textField = new TextField();
+				textField.name = "TextField0";
+				textField.label = "UserData";
+				textField.style.width = 200;
+				elementBottom.Add(textField);
+				var label = textField.Q<Label>();
+				label.style.minWidth = 63;
+			}
 			{
 				var textField = new TextField();
 				textField.name = "TextField1";
@@ -421,6 +689,7 @@ namespace YooAsset.Editor
 			objectField1.RegisterValueChangedCallback(evt =>
 			{
 				collector.CollectPath = AssetDatabase.GetAssetPath(evt.newValue);
+				collector.CollectorGUID = AssetDatabase.AssetPathToGUID(collector.CollectPath);
 				objectField1.value.name = collector.CollectPath;
 				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
 				if (foldout.value)
@@ -434,7 +703,7 @@ namespace YooAsset.Editor
 			popupField0.index = GetCollectorTypeIndex(collector.CollectorType.ToString());
 			popupField0.RegisterValueChangedCallback(evt =>
 			{
-				collector.CollectorType = StringUtility.NameToEnum<ECollectorType>(evt.newValue);
+				collector.CollectorType = EditorTools.NameToEnum<ECollectorType>(evt.newValue);
 				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
 				if (foldout.value)
 				{
@@ -443,13 +712,15 @@ namespace YooAsset.Editor
 			});
 
 			// Address Rule
-			var popupField1 = element.Q<PopupField<string>>("PopupField1");
+			var popupField1 = element.Q<PopupField<RuleDisplayName>>("PopupField1");
 			if (popupField1 != null)
 			{
 				popupField1.index = GetAddressRuleIndex(collector.AddressRuleName);
+				popupField1.formatListItemCallback = FormatListItemCallback;
+				popupField1.formatSelectedValueCallback = FormatSelectedValueCallback;
 				popupField1.RegisterValueChangedCallback(evt =>
 				{
-					collector.AddressRuleName = evt.newValue;
+					collector.AddressRuleName = evt.newValue.ClassName;
 					AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
 					if (foldout.value)
 					{
@@ -459,11 +730,13 @@ namespace YooAsset.Editor
 			}
 
 			// Pack Rule
-			var popupField2 = element.Q<PopupField<string>>("PopupField2");
+			var popupField2 = element.Q<PopupField<RuleDisplayName>>("PopupField2");
 			popupField2.index = GetPackRuleIndex(collector.PackRuleName);
+			popupField2.formatListItemCallback = FormatListItemCallback;
+			popupField2.formatSelectedValueCallback = FormatSelectedValueCallback;
 			popupField2.RegisterValueChangedCallback(evt =>
 			{
-				collector.PackRuleName = evt.newValue;
+				collector.PackRuleName = evt.newValue.ClassName;
 				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
 				if (foldout.value)
 				{
@@ -472,11 +745,13 @@ namespace YooAsset.Editor
 			});
 
 			// Filter Rule
-			var popupField3 = element.Q<PopupField<string>>("PopupField3");
+			var popupField3 = element.Q<PopupField<RuleDisplayName>>("PopupField3");
 			popupField3.index = GetFilterRuleIndex(collector.FilterRuleName);
+			popupField3.formatListItemCallback = FormatListItemCallback;
+			popupField3.formatSelectedValueCallback = FormatSelectedValueCallback;
 			popupField3.RegisterValueChangedCallback(evt =>
 			{
-				collector.FilterRuleName = evt.newValue;
+				collector.FilterRuleName = evt.newValue.ClassName;
 				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
 				if (foldout.value)
 				{
@@ -484,6 +759,15 @@ namespace YooAsset.Editor
 				}
 			});
 
+			// UserData
+			var textFiled0 = element.Q<TextField>("TextField0");
+			textFiled0.SetValueWithoutNotify(collector.UserData);
+			textFiled0.RegisterValueChangedCallback(evt =>
+			{
+				collector.UserData = evt.newValue;
+				AssetBundleCollectorSettingData.ModifyCollector(selectGroup, collector);
+			});
+
 			// Tags
 			var textFiled1 = element.Q<TextField>("TextField1");
 			textFiled1.SetValueWithoutNotify(collector.AssetTags);
@@ -510,7 +794,8 @@ namespace YooAsset.Editor
 
 				try
 				{
-					collectAssetInfos = collector.GetAllCollectAssets(group);
+					CollectCommand command = new CollectCommand(EBuildMode.SimulateBuild, _packageNameTxt.value, _enableAddressableToogle.value, _uniqueBundleNameToogle.value);
+					collectAssetInfos = collector.GetAllCollectAssets(command, group);
 				}
 				catch (System.Exception e)
 				{
@@ -527,12 +812,7 @@ namespace YooAsset.Editor
 
 						string showInfo = collectAssetInfo.AssetPath;
 						if (_enableAddressableToogle.value)
-						{
+							showInfo = $"[{collectAssetInfo.Address}] {collectAssetInfo.AssetPath}";
-							IAddressRule instance = AssetBundleCollectorSettingData.GetAddressRuleInstance(collector.AddressRuleName);
-							AddressRuleData ruleData = new AddressRuleData(collectAssetInfo.AssetPath, collector.CollectPath, group.GroupName);
-							string addressValue = instance.GetAssetAddress(ruleData);
-							showInfo = $"[{addressValue}] {showInfo}";
-						}
 
 						var label = new Label();
 						label.text = showInfo;
@@ -550,7 +830,9 @@ namespace YooAsset.Editor
 			if (selectGroup == null)
 				return;
 
-			AssetBundleCollectorSettingData.CreateCollector(selectGroup, string.Empty);
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow AddCollector");
+			AssetBundleCollector collector = new AssetBundleCollector();
+			AssetBundleCollectorSettingData.CreateCollector(selectGroup, collector);
 			FillCollectorViewData();
 		}
 		private void RemoveCollectorBtn_clicked(AssetBundleCollector selectCollector)
@@ -560,6 +842,8 @@ namespace YooAsset.Editor
 				return;
 			if (selectCollector == null)
 				return;
+
+			Undo.RecordObject(AssetBundleCollectorSettingData.Setting, "YooAsset.AssetBundleCollectorWindow RemoveCollector");
 			AssetBundleCollectorSettingData.RemoveCollector(selectGroup, selectCollector);
 			FillCollectorViewData();
 		}
@@ -577,7 +861,7 @@ namespace YooAsset.Editor
 		{
 			for (int i = 0; i < _addressRuleList.Count; i++)
 			{
-				if (_addressRuleList[i] == ruleName)
+				if (_addressRuleList[i].ClassName == ruleName)
 					return i;
 			}
 			return 0;
@@ -586,7 +870,7 @@ namespace YooAsset.Editor
 		{
 			for (int i = 0; i < _packRuleList.Count; i++)
 			{
-				if (_packRuleList[i] == ruleName)
+				if (_packRuleList[i].ClassName == ruleName)
 					return i;
 			}
 			return 0;
@@ -595,11 +879,20 @@ namespace YooAsset.Editor
 		{
 			for (int i = 0; i < _filterRuleList.Count; i++)
 			{
-				if (_filterRuleList[i] == ruleName)
+				if (_filterRuleList[i].ClassName == ruleName)
 					return i;
 			}
 			return 0;
 		}
+		private RuleDisplayName GetActiveRuleIndex(string ruleName)
+		{
+			for (int i = 0; i < _activeRuleList.Count; i++)
+			{
+				if (_activeRuleList[i].ClassName == ruleName)
+					return _activeRuleList[i];
+			}
+			return _activeRuleList[0];
+		}
 	}
 }
 #endif

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorWindow.uxml

@@ -1,31 +1,45 @@
-<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">
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements">
     <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);" />
+        <ui:Button text="修复" display-tooltip-when-elided="true" name="FixButton" style="width: 50px; background-color: rgb(56, 147, 58);" />
     </uie:Toolbar>
+    <ui:VisualElement name="PublicContainer" style="height: 30px; background-color: rgb(67, 67, 67); flex-direction: row; border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px;">
+        <ui:Toggle label="Show Packages" name="ShowPackages" style="width: 196px; -unity-text-align: middle-left;" />
+        <ui:Toggle label="Show Editor Alias" name="ShowEditorAlias" style="width: 196px; -unity-text-align: middle-left;" />
+        <ui:Toggle label="Enable Addressable" name="EnableAddressable" style="width: 196px; -unity-text-align: middle-left;" />
+        <ui:Toggle label="Unique Bundle Name" name="UniqueBundleName" style="width: 196px; -unity-text-align: middle-left;" />
+    </ui:VisualElement>
     <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:VisualElement name="PackageContainer" 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:Label text="Packages" display-tooltip-when-elided="true" name="PackageTitle" style="background-color: rgb(89, 89, 89); -unity-text-align: upper-center; -unity-font-style: bold; border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px; font-size: 12px;" />
+            <ui:ListView focusable="true" name="PackageListView" item-height="20" virtualization-method="DynamicHeight" style="flex-grow: 1;" />
+            <ui:VisualElement name="PackageAddContainer" 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>
+        </ui:VisualElement>
+        <ui:VisualElement name="GroupContainer" 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:Label text="Groups" display-tooltip-when-elided="true" name="GroupTitle" style="background-color: rgb(89, 89, 89); -unity-text-align: upper-center; -unity-font-style: bold; border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px; font-size: 12px;" />
+            <ui:TextField picking-mode="Ignore" label="Package Name" value="filler text" name="PackageName" style="flex-direction: column;" />
+            <ui:TextField picking-mode="Ignore" label="Package Desc" value="filler text" name="PackageDesc" style="flex-direction: column;" />
             <ui:ListView focusable="true" name="GroupListView" item-height="20" virtualization-method="DynamicHeight" style="flex-grow: 1;" />
             <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>
         </ui:VisualElement>
-        <ui:VisualElement name="RightContainer" style="flex-direction: column; flex-grow: 1;">
+        <ui:VisualElement name="CollectorContainer" style="flex-grow: 1; border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px;">
-            <ui:VisualElement name="PublicContainer" style="height: 30px; background-color: rgb(67, 67, 67); flex-direction: row; border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px;">
+            <ui:Label text="Collectors" display-tooltip-when-elided="true" name="CollectorTitle" style="background-color: rgb(89, 89, 89); -unity-text-align: upper-center; -unity-font-style: bold; border-left-width: 5px; border-right-width: 5px; border-top-width: 5px; border-bottom-width: 5px; font-size: 12px;" />
-                <ui:Toggle label="Enable Addressable" name="EnableAddressable" style="width: 196px; -unity-text-align: middle-left;" />
+            <ui:VisualElement name="ActiveRuleContainer" style="height: 20px;" />
-                <ui:Toggle label="Auto Collect Shaders" name="AutoCollectShader" style="width: 196px; -unity-text-align: middle-left;" />
+            <ui:TextField picking-mode="Ignore" label="Group Name" name="GroupName" />
-                <ui:TextField picking-mode="Ignore" label="Shader Bundle Name" name="ShaderBundleName" style="flex-grow: 1; -unity-text-align: middle-left;" />
+            <ui:TextField picking-mode="Ignore" label="Group Desc" name="GroupDesc" />
-            </ui:VisualElement>
+            <ui:TextField picking-mode="Ignore" label="Group Asset Tags" name="GroupAssetTags" />
-            <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:VisualElement name="CollectorAddContainer" style="height: 20px; flex-direction: row-reverse;">
-                <ui:TextField picking-mode="Ignore" label="Group Name" name="GroupName" />
+                <ui:Button text="[ + ]" display-tooltip-when-elided="true" name="AddBtn" />
-                <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>
-                <ui:ScrollView name="CollectorScrollView" style="flex-grow: 1;" />
             </ui:VisualElement>
+            <ui:ScrollView name="CollectorScrollView" style="flex-grow: 1;" />
         </ui:VisualElement>
     </ui:VisualElement>
 </ui:UXML>

Assets/YooAsset/Editor/AssetBundleCollector/CollectAssetInfo.cs

@@ -14,7 +14,7 @@ namespace YooAsset.Editor
 		/// 资源包名称
 		/// </summary>
 		public string BundleName { private set; get; }
-
+		
 		/// <summary>
 		/// 可寻址地址
 		/// </summary>
@@ -25,30 +25,30 @@ namespace YooAsset.Editor
 		/// </summary>
 		public string AssetPath { private set; get; }
 
-		/// <summary>
-		/// 资源分类标签
-		/// </summary>
-		public List<string> AssetTags { private set; get; }
-
 		/// <summary>
 		/// 是否为原生资源
 		/// </summary>
 		public bool IsRawAsset { private set; get; }
 
+		/// <summary>
+		/// 资源分类标签
+		/// </summary>
+		public List<string> AssetTags { private set; get; }
+
 		/// <summary>
 		/// 依赖的资源列表
 		/// </summary>
 		public List<string> DependAssets = new List<string>();
 
 
-		public CollectAssetInfo(ECollectorType collectorType, string bundleName, string address, string assetPath, List<string> assetTags, bool isRawAsset)
+		public CollectAssetInfo(ECollectorType collectorType, string bundleName, string address, string assetPath, bool isRawAsset, List<string> assetTags)
 		{
 			CollectorType = collectorType;
 			BundleName = bundleName;
 			Address = address;
 			AssetPath = assetPath;
-			AssetTags = assetTags;
 			IsRawAsset = isRawAsset;
+			AssetTags = assetTags;		
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleCollector/CollectCommand.cs

@@ -0,0 +1,34 @@
+
+namespace YooAsset.Editor
+{
+	public class CollectCommand
+	{
+		/// <summary>
+		/// 构建模式
+		/// </summary>
+		public EBuildMode BuildMode { private set; get; }
+
+		/// <summary>
+		/// 包裹名称
+		/// </summary>
+		public string PackageName { private set; get; }
+
+		/// <summary>
+		/// 是否启用可寻址资源定位
+		/// </summary>
+		public bool EnableAddressable { private set; get; }
+
+		/// <summary>
+		/// 资源包名唯一化
+		/// </summary>
+		public bool UniqueBundleName { private set; get; }
+
+		public CollectCommand(EBuildMode buildMode, string packageName, bool enableAddressable, bool uniqueBundleName)
+		{
+			BuildMode = buildMode;
+			PackageName = packageName;
+			EnableAddressable = enableAddressable;
+			UniqueBundleName = uniqueBundleName;
+		}
+	}
+}

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

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

Assets/YooAsset/Editor/AssetBundleCollector/CollectResult.cs

@@ -0,0 +1,38 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	public class CollectResult
+	{
+		/// <summary>
+		/// 收集命令
+		/// </summary>
+		public CollectCommand Command { private set; get; }
+
+		/// <summary>
+		/// 着色器统一全名称
+		/// </summary>
+		public string ShadersBundleName { private set; get; }
+
+		/// <summary>
+		/// 收集的资源信息列表
+		/// </summary>
+		public List<CollectAssetInfo> CollectAssets { private set; get; }
+
+
+		public CollectResult(CollectCommand command)
+		{
+			Command = command;
+
+			// 着色器统一全名称
+			var packRuleResult = DefaultPackRule.CreateShadersPackRuleResult();
+			ShadersBundleName = packRuleResult.GetMainBundleName(command.PackageName, command.UniqueBundleName);
+		}
+
+		public void SetCollectAssets(List<CollectAssetInfo> collectAssets)
+		{
+			CollectAssets = collectAssets;
+		}
+	}
+}

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

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

Assets/YooAsset/Editor/AssetBundleCollector/DefaultActiveRule.cs

@@ -0,0 +1,21 @@
+
+namespace YooAsset.Editor
+{
+	[DisplayName("启用分组")]
+	public class EnableGroup : IActiveRule
+	{
+		public bool IsActiveGroup()
+		{
+			return true;
+		}
+	}
+
+	[DisplayName("禁用分组")]
+	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

@@ -2,9 +2,7 @@
 
 namespace YooAsset.Editor
 {
-	/// <summary>
+	[DisplayName("定位地址: 文件名")]
-	/// 以文件名为定位地址
-	/// </summary>
 	public class AddressByFileName : IAddressRule
 	{
 		string IAddressRule.GetAssetAddress(AddressRuleData data)
@@ -13,9 +11,7 @@ namespace YooAsset.Editor
 		}
 	}
 
-	/// <summary>
+	[DisplayName("定位地址: 分组名+文件名")]
-	/// 以组名+文件名为定位地址
-	/// </summary>
 	public class AddressByGroupAndFileName : IAddressRule
 	{
 		string IAddressRule.GetAssetAddress(AddressRuleData data)
@@ -25,10 +21,8 @@ namespace YooAsset.Editor
 		}
 	}
 
-	/// <summary>
+	[DisplayName("定位地址: 文件夹名+文件名")]
-	/// 以收集器名+文件名为定位地址
+	public class AddressByFolderAndFileName : IAddressRule
-	/// </summary>
-	public class AddressByCollectorAndFileName : IAddressRule
 	{
 		string IAddressRule.GetAssetAddress(AddressRuleData data)
 		{

Assets/YooAsset/Editor/AssetBundleCollector/DefaultFilterRule.cs

@@ -4,9 +4,15 @@ using System.IO;
 
 namespace YooAsset.Editor
 {
-	/// <summary>
+	public class DefaultFilterRule
-	/// 收集所有资源
+	{
-	/// </summary>
+		/// <summary>
+		/// 忽略的文件类型
+		/// </summary>
+		public static readonly string[] IgnoreFileExtensions = { "", ".so", ".dll", ".cs", ".js", ".boo", ".meta", ".cginc", ".hlsl" };
+	}
+
+	[DisplayName("收集所有资源")]
 	public class CollectAll : IFilterRule
 	{
 		public bool IsCollectAsset(FilterRuleData data)
@@ -15,9 +21,7 @@ namespace YooAsset.Editor
 		}
 	}
 
-	/// <summary>
+	[DisplayName("收集场景")]
-	/// 只收集场景
-	/// </summary>
 	public class CollectScene : IFilterRule
 	{
 		public bool IsCollectAsset(FilterRuleData data)
@@ -25,10 +29,8 @@ namespace YooAsset.Editor
 			return Path.GetExtension(data.AssetPath) == ".unity";
 		}
 	}
-	
+
-	/// <summary>
+	[DisplayName("收集预制体")]
-	/// 只收集预制体
-	/// </summary>
 	public class CollectPrefab : IFilterRule
 	{
 		public bool IsCollectAsset(FilterRuleData data)
@@ -37,17 +39,33 @@ namespace YooAsset.Editor
 		}
 	}
 
-	/// <summary>
+	[DisplayName("收集精灵类型的纹理")]
-	/// 只收集精灵类型的资源
-	/// </summary>
 	public class CollectSprite : IFilterRule
 	{
 		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;
+			}
+		}
+	}
+
+	[DisplayName("收集着色器变种集合")]
+	public class CollectShaderVariants : IFilterRule
+	{
+		public bool IsCollectAsset(FilterRuleData data)
+		{
+			return Path.GetExtension(data.AssetPath) == ".shadervariants";
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleCollector/DefaultPackRule.cs

@@ -4,33 +4,74 @@ using UnityEditor;
 
 namespace YooAsset.Editor
 {
+	public class DefaultPackRule
+	{
+		/// <summary>
+		/// AssetBundle文件的后缀名
+		/// </summary>
+		public const string AssetBundleFileExtension = "bundle";
+
+		/// <summary>
+		/// 原生文件的后缀名
+		/// </summary>
+		public const string RawFileExtension = "rawfile";
+
+		/// <summary>
+		/// Unity着色器资源包名称
+		/// </summary>
+		public const string ShadersBundleName = "unityshaders";
+
+
+		public static PackRuleResult CreateShadersPackRuleResult()
+		{
+			PackRuleResult result = new PackRuleResult(ShadersBundleName, AssetBundleFileExtension);
+			return result;
+		}
+	}
+
 	/// <summary>
 	/// 以文件路径作为资源包名
 	/// 注意：每个文件独自打资源包
-	/// 例如：收集器路径为 "Assets/UIPanel"
+	/// 例如："Assets/UIPanel/Shop/Image/backgroud.png" --> "assets_uipanel_shop_image_backgroud.bundle"
-	/// 例如："Assets/UIPanel/Shop/Image/backgroud.png" --> "assets/uipanel/shop/image/backgroud.bundle"
+	/// 例如："Assets/UIPanel/Shop/View/main.prefab" --> "assets_uipanel_shop_view_main.bundle"
-	/// 例如："Assets/UIPanel/Shop/View/main.prefab" --> "assets/uipanel/shop/view/main.bundle"
 	/// </summary>
+	[DisplayName("资源包名: 文件路径")]
 	public class PackSeparately : IPackRule
 	{
-		string IPackRule.GetBundleName(PackRuleData data)
+		PackRuleResult IPackRule.GetPackRuleResult(PackRuleData data)
 		{
-			return StringUtility.RemoveExtension(data.AssetPath);
+			string bundleName = StringUtility.RemoveExtension(data.AssetPath);
+			PackRuleResult result = new PackRuleResult(bundleName, DefaultPackRule.AssetBundleFileExtension);
+			return result;
+		}
+
+		bool IPackRule.IsRawFilePackRule()
+		{
+			return false;
 		}
 	}
 
 	/// <summary>
 	/// 以父类文件夹路径作为资源包名
 	/// 注意：文件夹下所有文件打进一个资源包
-	/// 例如：收集器路径为 "Assets/UIPanel"
+	/// 例如："Assets/UIPanel/Shop/Image/backgroud.png" --> "assets_uipanel_shop_image.bundle"
-	/// 例如："Assets/UIPanel/Shop/Image/backgroud.png" --> "assets/uipanel/shop/image.bundle"
+	/// 例如："Assets/UIPanel/Shop/View/main.prefab" --> "assets_uipanel_shop_view.bundle"
-	/// 例如："Assets/UIPanel/Shop/View/main.prefab" --> "assets/uipanel/shop/view.bundle"
 	/// </summary>
+	[DisplayName("资源包名: 父类文件夹路径")]
 	public class PackDirectory : IPackRule
 	{
-		string IPackRule.GetBundleName(PackRuleData data)
+		public static PackDirectory StaticPackRule = new PackDirectory();
+
+		PackRuleResult IPackRule.GetPackRuleResult(PackRuleData data)
 		{
-			return Path.GetDirectoryName(data.AssetPath);
+			string bundleName = Path.GetDirectoryName(data.AssetPath);
+			PackRuleResult result = new PackRuleResult(bundleName, DefaultPackRule.AssetBundleFileExtension);
+			return result;
+		}
+
+		bool IPackRule.IsRawFilePackRule()
+		{
+			return false;
 		}
 	}
 
@@ -38,12 +79,13 @@ namespace YooAsset.Editor
 	/// 以收集器路径下顶级文件夹为资源包名
 	/// 注意：文件夹下所有文件打进一个资源包
 	/// 例如：收集器路径为 "Assets/UIPanel"
-	/// 例如："Assets/UIPanel/Shop/Image/backgroud.png" --> "assets/uipanel/shop.bundle"
+	/// 例如："Assets/UIPanel/Shop/Image/backgroud.png" --> "assets_uipanel_shop.bundle"
-	/// 例如："Assets/UIPanel/Shop/View/main.prefab" --> "assets/uipanel/shop.bundle"
+	/// 例如："Assets/UIPanel/Shop/View/main.prefab" --> "assets_uipanel_shop.bundle"
 	/// </summary>
+	[DisplayName("资源包名: 收集器下顶级文件夹路径")]
 	public class PackTopDirectory : IPackRule
 	{
-		string IPackRule.GetBundleName(PackRuleData data)
+		PackRuleResult IPackRule.GetPackRuleResult(PackRuleData data)
 		{
 			string assetPath = data.AssetPath.Replace(data.CollectPath, string.Empty);
 			assetPath = assetPath.TrimStart('/');
@@ -53,24 +95,48 @@ namespace YooAsset.Editor
 				if (Path.HasExtension(splits[0]))
 					throw new Exception($"Not found root directory : {assetPath}");
 				string bundleName = $"{data.CollectPath}/{splits[0]}";
-				return bundleName;
+				PackRuleResult result = new PackRuleResult(bundleName, DefaultPackRule.AssetBundleFileExtension);
+				return result;
 			}
 			else
 			{
 				throw new Exception($"Not found root directory : {assetPath}");
 			}
 		}
+
+		bool IPackRule.IsRawFilePackRule()
+		{
+			return false;
+		}
 	}
 
 	/// <summary>
 	/// 以收集器路径作为资源包名
 	/// 注意：收集的所有文件打进一个资源包
 	/// </summary>
+	[DisplayName("资源包名: 收集器路径")]
 	public class PackCollector : IPackRule
 	{
-		string IPackRule.GetBundleName(PackRuleData data)
+		PackRuleResult IPackRule.GetPackRuleResult(PackRuleData data)
 		{
-			return StringUtility.RemoveExtension(data.CollectPath);
+			string bundleName;
+			string collectPath = data.CollectPath;
+			if (AssetDatabase.IsValidFolder(collectPath))
+			{
+				bundleName = collectPath;
+			}
+			else
+			{
+				bundleName = StringUtility.RemoveExtension(collectPath);
+			}
+
+			PackRuleResult result = new PackRuleResult(bundleName, DefaultPackRule.AssetBundleFileExtension);
+			return result;
+		}
+
+		bool IPackRule.IsRawFilePackRule()
+		{
+			return false;
 		}
 	}
 
@@ -78,37 +144,55 @@ namespace YooAsset.Editor
 	/// 以分组名称作为资源包名
 	/// 注意：收集的所有文件打进一个资源包
 	/// </summary>
+	[DisplayName("资源包名: 分组名称")]
 	public class PackGroup : IPackRule
 	{
-		string IPackRule.GetBundleName(PackRuleData data)
+		PackRuleResult IPackRule.GetPackRuleResult(PackRuleData data)
 		{
-			return data.GroupName;
+			string bundleName = data.GroupName;
+			PackRuleResult result = new PackRuleResult(bundleName, DefaultPackRule.AssetBundleFileExtension);
+			return result;
+		}
+
+		bool IPackRule.IsRawFilePackRule()
+		{
+			return false;
 		}
 	}
 
 	/// <summary>
-	/// 原生文件打包模式
+	/// 打包原生文件
-	/// 注意：原生文件打包支持：图片，音频，视频，文本
 	/// </summary>
+	[DisplayName("打包原生文件")]
 	public class PackRawFile : IPackRule
 	{
-		string IPackRule.GetBundleName(PackRuleData data)
+		PackRuleResult IPackRule.GetPackRuleResult(PackRuleData data)
 		{
-			string extension = StringUtility.RemoveFirstChar(Path.GetExtension(data.AssetPath));
+			string bundleName = data.AssetPath;
-			if (extension == EAssetFileExtension.unity.ToString() || extension == EAssetFileExtension.prefab.ToString() ||
+			PackRuleResult result = new PackRuleResult(bundleName, DefaultPackRule.RawFileExtension);
-				extension == EAssetFileExtension.mat.ToString() || extension == EAssetFileExtension.controller.ToString() ||
+			return result;
-				extension == EAssetFileExtension.fbx.ToString() || extension == EAssetFileExtension.anim.ToString() ||
+		}
-				extension == EAssetFileExtension.shader.ToString())
-			{
-				throw new Exception($"{nameof(PackRawFile)} is not support file estension : {extension}");
-			}
 
-			// 注意：原生文件只支持无依赖关系的资源
+		bool IPackRule.IsRawFilePackRule()
-			string[] depends = AssetDatabase.GetDependencies(data.AssetPath, true);
+		{
-			if (depends.Length != 1)
+			return true;
-				throw new Exception($"{nameof(PackRawFile)} is not support estension : {extension}");
+		}
+	}
 
-			return StringUtility.RemoveExtension(data.AssetPath);
+	/// <summary>
+	/// 打包着色器变种集合
+	/// </summary>
+	[DisplayName("打包着色器变种集合文件")]
+	public class PackShaderVariants : IPackRule
+	{
+		public PackRuleResult GetPackRuleResult(PackRuleData data)
+		{
+			return DefaultPackRule.CreateShadersPackRuleResult();
+		}
+
+		bool IPackRule.IsRawFilePackRule()
+		{
+			return false;
 		}
 	}
 }

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

@@ -6,12 +6,14 @@ namespace YooAsset.Editor
 		public string AssetPath;
 		public string CollectPath;
 		public string GroupName;
+		public string UserData;
 
-		public AddressRuleData(string assetPath, string collectPath, string groupName)
+		public AddressRuleData(string assetPath, string collectPath, string groupName, string userData)
 		{
 			AssetPath = assetPath;
 			CollectPath = collectPath;
 			GroupName = groupName;
+			UserData = userData;
 		}
 	}
 

Assets/YooAsset/Editor/AssetBundleCollector/IPackRule.cs

@@ -3,21 +3,64 @@ namespace YooAsset.Editor
 {
 	public struct PackRuleData
 	{
-		public string AssetPath;		
+		public string AssetPath;
 		public string CollectPath;
 		public string GroupName;
+		public string UserData;
 
 		public PackRuleData(string assetPath)
 		{
 			AssetPath = assetPath;
 			CollectPath = string.Empty;
 			GroupName = string.Empty;
+			UserData = string.Empty;
 		}
-		public PackRuleData(string assetPath, string collectPath, string groupName)
+		public PackRuleData(string assetPath, string collectPath, string groupName, string userData)
 		{
 			AssetPath = assetPath;
 			CollectPath = collectPath;
 			GroupName = groupName;
+			UserData = userData;
+		}
+	}
+
+	public struct PackRuleResult
+	{
+		private readonly string _bundleName;
+		private readonly string _bundleExtension;
+
+		public PackRuleResult(string bundleName, string bundleExtension)
+		{
+			_bundleName = bundleName;
+			_bundleExtension = bundleExtension;
+		}
+
+		/// <summary>
+		/// 获取主资源包全名称
+		/// </summary>
+		public string GetMainBundleName(string packageName, bool uniqueBundleName)
+		{
+			string fullName;
+			string bundleName = EditorTools.GetRegularPath(_bundleName).Replace('/', '_').Replace('.', '_').ToLower();
+			if (uniqueBundleName)
+				fullName = $"{packageName}_{bundleName}.{_bundleExtension}";
+			else
+				fullName = $"{bundleName}.{_bundleExtension}";
+			return fullName.ToLower();
+		}
+		
+		/// <summary>
+		/// 获取共享资源包全名称
+		/// </summary>
+		public string GetShareBundleName(string packageName, bool uniqueBundleName)
+		{
+			string fullName;
+			string bundleName = EditorTools.GetRegularPath(_bundleName).Replace('/', '_').Replace('.', '_').ToLower();
+			if (uniqueBundleName)
+				fullName = $"{packageName}_share_{bundleName}.{_bundleExtension}";
+			else
+				fullName = $"share_{bundleName}.{_bundleExtension}";
+			return fullName.ToLower();
 		}
 	}
 
@@ -27,8 +70,13 @@ namespace YooAsset.Editor
 	public interface IPackRule
 	{
 		/// <summary>
-		/// 获取资源打包所属的资源包名称
+		/// 获取打包规则结果
 		/// </summary>
-		string GetBundleName(PackRuleData data);
+		PackRuleResult GetPackRuleResult(PackRuleData data);
+
+		/// <summary>
+		/// 是否为原生文件打包规则
+		/// </summary>
+		bool IsRawFilePackRule();
 	}
 }

Assets/YooAsset/Editor/AssetBundleCollector/RuleDisplayName.cs

@@ -0,0 +1,9 @@
+
+namespace YooAsset.Editor
+{
+	public class RuleDisplayName
+	{
+		public string ClassName;
+		public string DisplayName;
+	}
+}

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

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

Assets/YooAsset/Editor/AssetBundleDebugger/AssetBundleDebuggerWindow.cs

@@ -1,146 +1,328 @@
 #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 DebuggerAssetListViewer _assetListViewer;
-        private DebuggerBundleListViewer _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>();
-        {
+
+		private Label _playerName;
+		private ToolbarMenu _viewModeMenu;
+		private SliderInt _frameSlider;
+		private DebuggerAssetListViewer _assetListViewer;
+		private DebuggerBundleListViewer _bundleListViewer;
+
+		private EViewMode _viewMode;
+		private string _searchKeyWord;
+		private DebugReport _currentReport;
+		private RemotePlayerSession _currentPlayerSession;
+		private int _rangeIndex = 0;
+
+
+		public void CreateGUI()
+		{
 			try
 			{
-                VisualElement root = rootVisualElement;
+				VisualElement root = rootVisualElement;
 
-                // 加载布局文件
+				// 加载布局文件
-                var visualAsset = YooAssetEditorSettingsData.Setting.AssetBundleDebuggerUXML;
+				var visualAsset = EditorHelper.LoadWindowUXML<AssetBundleDebuggerWindow>();
-                if (visualAsset == null)
+				if (visualAsset == null)
-                {
+					return;
-                    Debug.LogError($"Not found {nameof(AssetBundleDebuggerWindow)}.uxml in settings.");
-                    return;
-                }
-                visualAsset.CloneTree(root);
 
-                // 采样按钮
+				visualAsset.CloneTree(root);
-                var sampleBtn = root.Q<Button>("SampleButton");
-                sampleBtn.clicked += SampleBtn_onClick;
 
-                // 视口模式菜单
+				// 采样按钮
-                _viewModeMenu = root.Q<ToolbarMenu>("ViewModeMenu");
+				var sampleBtn = root.Q<Button>("SampleButton");
-                //_viewModeMenu.menu.AppendAction(EViewMode.MemoryView.ToString(), ViewModeMenuAction0, ViewModeMenuFun0);
+				sampleBtn.clicked += SampleBtn_onClick;
-                _viewModeMenu.menu.AppendAction(EViewMode.AssetView.ToString(), ViewModeMenuAction1, ViewModeMenuFun1);
-                _viewModeMenu.menu.AppendAction(EViewMode.BundleView.ToString(), ViewModeMenuAction2, ViewModeMenuFun2);
 
-                // 搜索栏
+				// 导出按钮
-                var searchField = root.Q<ToolbarSearchField>("SearchField");
+				var exportBtn = root.Q<Button>("ExportButton");
-                searchField.RegisterValueChangedCallback(OnSearchKeyWordChange);
+				exportBtn.clicked += ExportBtn_clicked;
 
-                // 加载视图
+				// 用户列表菜单
-                _assetListViewer = new DebuggerAssetListViewer();
+				_playerName = root.Q<Label>("PlayerName");
-                _assetListViewer.InitViewer();
+				_playerName.text = "Editor player";
 
-                // 加载视图
+				// 视口模式菜单
-                _bundleListViewer = new DebuggerBundleListViewer();
+				_viewModeMenu = root.Q<ToolbarMenu>("ViewModeMenu");
-                _bundleListViewer.InitViewer();
+				_viewModeMenu.menu.AppendAction(EViewMode.AssetView.ToString(), OnViewModeMenuChange, OnViewModeMenuStatusUpdate, EViewMode.AssetView);
+				_viewModeMenu.menu.AppendAction(EViewMode.BundleView.ToString(), OnViewModeMenuChange, OnViewModeMenuStatusUpdate, EViewMode.BundleView);
+				_viewModeMenu.text = EViewMode.AssetView.ToString();
 
-                // 显示视图
+				// 搜索栏
-                _viewMode = EViewMode.AssetView;
+				var searchField = root.Q<ToolbarSearchField>("SearchField");
-                _viewModeMenu.text = EViewMode.AssetView.ToString();
+				searchField.RegisterValueChangedCallback(OnSearchKeyWordChange);
-                _assetListViewer.AttachParent(root);
+
-            }
+				// 帧数相关
-            catch(Exception e)
+				{
+					_frameSlider = root.Q<SliderInt>("FrameSlider");
+					_frameSlider.label = "Frame:";
+					_frameSlider.highValue = 0;
+					_frameSlider.lowValue = 0;
+					_frameSlider.value = 0;
+					_frameSlider.RegisterValueChangedCallback(evt =>
+					{
+						OnFrameSliderChange(evt.newValue);
+					});
+
+					var frameLast = root.Q<ToolbarButton>("FrameLast");
+					frameLast.clicked += OnFrameLast_clicked;
+
+					var frameNext = root.Q<ToolbarButton>("FrameNext");
+					frameNext.clicked += OnFrameNext_clicked;
+
+					var frameClear = root.Q<ToolbarButton>("FrameClear");
+					frameClear.clicked += OnFrameClear_clicked;
+				}
+
+				// 加载视图
+				_assetListViewer = new DebuggerAssetListViewer();
+				_assetListViewer.InitViewer();
+
+				// 加载视图
+				_bundleListViewer = new DebuggerBundleListViewer();
+				_bundleListViewer.InitViewer();
+
+				// 显示视图
+				_viewMode = EViewMode.AssetView;
+				_assetListViewer.AttachParent(root);
+
+				// 远程调试
+				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());
+				Debug.LogError(e.ToString());
-            }
+			}
-        }
+		}
-        private void SampleBtn_onClick()
+		public void OnDestroy()
-        {
+		{
-            YooAssets.GetDebugReport(_debugReport);
+			// 远程调试
-            _assetListViewer.FillViewData(_debugReport, _searchKeyWord);
+			EditorConnection.instance.UnregisterConnection(OnHandleConnectionEvent);
-            _bundleListViewer.FillViewData(_debugReport, _searchKeyWord);
+			EditorConnection.instance.UnregisterDisconnection(OnHandleDisconnectionEvent);
-        }
+			EditorConnection.instance.Unregister(RemoteDebuggerDefine.kMsgSendPlayerToEditor, OnHandlePlayerMessage);
-        private void OnSearchKeyWordChange(ChangeEvent<string> e)
+			_playerSessions.Clear();
-        {
+		}
-            _searchKeyWord = e.newValue;
+
-            _assetListViewer.FillViewData(_debugReport, _searchKeyWord);
+		private void OnHandleConnectionEvent(int playerId)
-            _bundleListViewer.FillViewData(_debugReport, _searchKeyWord);
+		{
-        }
+			Debug.Log($"Game player connection : {playerId}");
-        private void ViewModeMenuAction1(DropdownMenuAction action)
+			_playerName.text = $"Connected player : {playerId}";
-        {
+		}
-            if (_viewMode != EViewMode.AssetView)
+		private void OnHandleDisconnectionEvent(int playerId)
-            {
+		{
-                _viewMode = EViewMode.AssetView;
+			Debug.Log($"Game player disconnection : {playerId}");
-                VisualElement root = this.rootVisualElement;
+			_playerName.text = $"Disconneced player : {playerId}";
-                _viewModeMenu.text = EViewMode.AssetView.ToString();
+		}
-                _assetListViewer.AttachParent(root);
+		private void OnHandlePlayerMessage(MessageEventArgs args)
-                _bundleListViewer.DetachParent();
+		{
-            }
+			var debugReport = DebugReport.Deserialize(args.data);
-        }
+			OnHandleDebugReport(args.playerId, debugReport);
-        private void ViewModeMenuAction2(DropdownMenuAction action)
+		}
-        {
+		private void OnHandleDebugReport(int playerId, DebugReport debugReport)
-            if (_viewMode != EViewMode.BundleView)
+		{
-            {
+			Debug.Log($"Handle player {playerId} debug report !");
-                _viewMode = EViewMode.BundleView;
+			_currentPlayerSession = GetOrCreatePlayerSession(playerId);
-                VisualElement root = this.rootVisualElement;
+			_currentPlayerSession.AddDebugReport(debugReport);
-                _viewModeMenu.text = EViewMode.BundleView.ToString();
+			_frameSlider.highValue = _currentPlayerSession.MaxRangeValue;
-                _assetListViewer.DetachParent();
+			_frameSlider.value = _currentPlayerSession.MaxRangeValue;
-                _bundleListViewer.AttachParent(root);
+			UpdateFrameView(_currentPlayerSession);
-            }
+		}
-        }
+		private void OnFrameSliderChange(int sliderValue)
-        private DropdownMenuAction.Status ViewModeMenuFun1(DropdownMenuAction action)
+		{
-        {
+			if (_currentPlayerSession != null)
-            if (_viewMode == EViewMode.AssetView)
+			{
-                return DropdownMenuAction.Status.Checked;
+				_rangeIndex = _currentPlayerSession.ClampRangeIndex(sliderValue); ;
-            else
+				UpdateFrameView(_currentPlayerSession, _rangeIndex);
-                return DropdownMenuAction.Status.Normal;
+			}
-        }
+		}
-        private DropdownMenuAction.Status ViewModeMenuFun2(DropdownMenuAction action)
+		private void OnFrameLast_clicked()
-        {
+		{
-            if (_viewMode == EViewMode.BundleView)
+			if (_currentPlayerSession != null)
-                return DropdownMenuAction.Status.Checked;
+			{
-            else
+				_rangeIndex = _currentPlayerSession.ClampRangeIndex(_rangeIndex - 1);
-                return DropdownMenuAction.Status.Normal;
+				_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 ExportBtn_clicked()
+		{
+			if (_currentReport == null)
+			{
+				Debug.LogWarning("Debug report is null.");
+				return;
+			}
+
+			string resultPath = EditorTools.OpenFolderPanel("Export JSON", "Assets/");
+			if (resultPath != null)
+			{
+				// 注意：排序保证生成配置的稳定性
+				foreach (var packageData in _currentReport.PackageDatas)
+				{
+					packageData.ProviderInfos.Sort();
+					foreach (var providerInfo in packageData.ProviderInfos)
+					{
+						providerInfo.DependBundleInfos.Sort();
+					}
+				}
+
+				string filePath = $"{resultPath}/{nameof(DebugReport)}_{_currentReport.FrameCount}.json";
+				string fileContent = JsonUtility.ToJson(_currentReport, true);
+				FileUtility.CreateFile(filePath, fileContent);
+			}
+		}
+		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,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="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:ToolbarButton text="导出" display-tooltip-when-elided="true" name="ExportButton" 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

@@ -24,12 +24,10 @@ namespace YooAsset.Editor
 		public void InitViewer()
 		{
 			// 加载布局文件		
-			_visualAsset = YooAssetEditorSettingsData.Setting.DebuggerAssetListViewerUXML;
+			_visualAsset = EditorHelper.LoadWindowUXML<DebuggerAssetListViewer>();
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(DebuggerAssetListViewer)}.uxml in settings.");
 				return;
-			}
+
 			_root = _visualAsset.CloneTree();
 			_root.style.flexGrow = 1f;
 
@@ -49,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>
@@ -62,15 +72,24 @@ namespace YooAsset.Editor
 		}
 		private List<DebugProviderInfo> FilterViewItems(DebugReport debugReport, string searchKeyWord)
 		{
-			var result = new List<DebugProviderInfo>(debugReport.ProviderInfos.Count);
+			List<DebugProviderInfo> result = new List<DebugProviderInfo>(1000);
-			foreach (var providerInfo in debugReport.ProviderInfos)
+			foreach (var packageData in debugReport.PackageDatas)
 			{
-				if (string.IsNullOrEmpty(searchKeyWord) == false)
+				var tempList = new List<DebugProviderInfo>(packageData.ProviderInfos.Count);
+				foreach (var providerInfo in packageData.ProviderInfos)
 				{
-					if (providerInfo.AssetPath.Contains(searchKeyWord) == false)
+					if (string.IsNullOrEmpty(searchKeyWord) == false)
-						continue;
+					{
+						if (providerInfo.AssetPath.Contains(searchKeyWord) == false)
+							continue;
+					}
+
+					providerInfo.PackageName = packageData.PackageName;
+					tempList.Add(providerInfo);
 				}
-				result.Add(providerInfo);
+
+				tempList.Sort();
+				result.AddRange(tempList);
 			}
 			return result;
 		}
@@ -92,12 +111,22 @@ namespace YooAsset.Editor
 		}
 
 
-		// 资源列表相关
+		// 顶部列表相关
 		private VisualElement MakeAssetListViewItem()
 		{
 			VisualElement element = new VisualElement();
 			element.style.flexDirection = FlexDirection.Row;
 
+			{
+				var label = new Label();
+				label.name = "Label0";
+				label.style.unityTextAlign = TextAnchor.MiddleLeft;
+				label.style.marginLeft = 3f;
+				//label.style.flexGrow = 1f;
+				label.style.width = 150;
+				element.Add(label);
+			}
+
 			{
 				var label = new Label();
 				label.name = "Label1";
@@ -134,7 +163,7 @@ namespace YooAsset.Editor
 				label.style.unityTextAlign = TextAnchor.MiddleLeft;
 				label.style.marginLeft = 3f;
 				//label.style.flexGrow = 1f;
-				label.style.width = 100;
+				label.style.width = 150;
 				element.Add(label);
 			}
 
@@ -144,6 +173,16 @@ namespace YooAsset.Editor
 				label.style.unityTextAlign = TextAnchor.MiddleLeft;
 				label.style.marginLeft = 3f;
 				//label.style.flexGrow = 1f;
+				label.style.width = 100;
+				element.Add(label);
+			}
+
+			{
+				var label = new Label();
+				label.name = "Label6";
+				label.style.unityTextAlign = TextAnchor.MiddleLeft;
+				label.style.marginLeft = 3f;
+				//label.style.flexGrow = 1f;
 				label.style.width = 120;
 				element.Add(label);
 			}
@@ -155,6 +194,10 @@ namespace YooAsset.Editor
 			var sourceData = _assetListView.itemsSource as List<DebugProviderInfo>;
 			var providerInfo = sourceData[index];
 
+			// Package Name
+			var label0 = element.Q<Label>("Label0");
+			label0.text = providerInfo.PackageName;
+
 			// Asset Path
 			var label1 = element.Q<Label>("Label1");
 			label1.text = providerInfo.AssetPath;
@@ -167,19 +210,23 @@ namespace YooAsset.Editor
 			var label3 = element.Q<Label>("Label3");
 			label3.text = providerInfo.SpawnTime;
 
-			// Ref Count
+			// Loading Time
 			var label4 = element.Q<Label>("Label4");
-			label4.text = providerInfo.RefCount.ToString();
+			label4.text = providerInfo.LoadingTime.ToString();
+
+			// Ref Count
+			var label5 = element.Q<Label>("Label5");
+			label5.text = providerInfo.RefCount.ToString();
 
 			// Status
 			StyleColor textColor;
-			if (providerInfo.Status == ProviderBase.EStatus.Fail)
+			if (providerInfo.Status == ProviderBase.EStatus.Failed.ToString())
 				textColor = new StyleColor(Color.yellow);
 			else
 				textColor = label1.style.color;
-			var label5 = element.Q<Label>("Label5");
+			var label6 = element.Q<Label>("Label6");
-			label5.text = providerInfo.Status.ToString();
+			label6.text = providerInfo.Status.ToString();
-			label5.style.color = textColor;
+			label6.style.color = textColor;
 		}
 		private void AssetListView_onSelectionChange(IEnumerable<object> objs)
 		{
@@ -190,7 +237,7 @@ namespace YooAsset.Editor
 			}
 		}
 
-		// 依赖列表相关
+		// 底部列表相关
 		private VisualElement MakeDependListViewItem()
 		{
 			VisualElement element = new VisualElement();
@@ -245,11 +292,11 @@ namespace YooAsset.Editor
 			var label4 = element.Q<Label>("Label4");
 			label4.text = bundleInfo.Status.ToString();
 		}
-		private void FillDependListView(DebugProviderInfo providerInfo)
+		private void FillDependListView(DebugProviderInfo selectedProviderInfo)
 		{
 			_dependListView.Clear();
 			_dependListView.ClearSelection();
-			_dependListView.itemsSource = providerInfo.BundleInfos;
+			_dependListView.itemsSource = selectedProviderInfo.DependBundleInfos;
 			_dependListView.Rebuild();
 		}
 	}

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

@@ -1,11 +1,13 @@
 <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" editor-extension-mode="False">
     <ui:VisualElement name="TopGroup" style="flex-grow: 1; border-left-width: 1px; border-right-width: 1px; border-top-width: 1px; border-bottom-width: 1px; border-left-color: rgb(0, 0, 0); border-right-color: rgb(0, 0, 0); border-top-color: rgb(0, 0, 0); border-bottom-color: rgb(0, 0, 0); margin-left: 0; margin-right: 0; margin-top: 2px; margin-bottom: 1px; display: flex;">
         <uie:Toolbar name="TopBar" style="height: 25px; margin-left: 1px; margin-right: 1px;">
+            <uie:ToolbarButton text="Package Name" display-tooltip-when-elided="true" name="TopBar0" style="width: 150px; -unity-text-align: middle-left; flex-grow: 0;" />
             <uie:ToolbarButton text="Asset Path" display-tooltip-when-elided="true" name="TopBar1" style="width: 280px; -unity-text-align: middle-left; flex-grow: 1;" />
             <uie:ToolbarButton text="Spawn Scene" display-tooltip-when-elided="true" name="TopBar2" style="width: 150px; -unity-text-align: middle-left; flex-grow: 0;" />
             <uie:ToolbarButton text="Spawn Time" display-tooltip-when-elided="true" name="TopBar3" style="width: 150px; -unity-text-align: middle-left; flex-grow: 0;" />
-            <uie:ToolbarButton text="Ref Count" display-tooltip-when-elided="true" name="TopBar4" style="width: 100px; -unity-text-align: middle-left; flex-grow: 0;" />
+            <uie:ToolbarButton text="Loading Time (ms)" display-tooltip-when-elided="true" name="TopBar4" style="width: 150px; -unity-text-align: middle-left; flex-grow: 0;" />
-            <uie:ToolbarButton text="Status" display-tooltip-when-elided="true" name="TopBar5" style="width: 120px; -unity-text-align: middle-left;" />
+            <uie:ToolbarButton text="Ref Count" display-tooltip-when-elided="true" name="TopBar5" style="width: 100px; -unity-text-align: middle-left; flex-grow: 0;" />
+            <uie:ToolbarButton text="Status" display-tooltip-when-elided="true" name="TopBar6" style="width: 120px; -unity-text-align: middle-left;" />
         </uie:Toolbar>
         <ui:ListView focusable="true" name="TopListView" item-height="18" virtualization-method="DynamicHeight" style="flex-grow: 1;" />
     </ui:VisualElement>

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

@@ -24,31 +24,41 @@ namespace YooAsset.Editor
 		public void InitViewer()
 		{
 			// 加载布局文件
-			_visualAsset = YooAssetEditorSettingsData.Setting.DebuggerBundleListViewerUXML;
+			_visualAsset = EditorHelper.LoadWindowUXML<DebuggerBundleListViewer>();
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(DebuggerBundleListViewer)}.uxml in settings.");
 				return;
-			}
+
 			_root = _visualAsset.CloneTree();
 			_root.style.flexGrow = 1f;
 
 			// 资源包列表
 			_bundleListView = _root.Q<ListView>("TopListView");
-			_bundleListView.makeItem = MakeAssetListViewItem;
+			_bundleListView.makeItem = MakeBundleListViewItem;
-			_bundleListView.bindItem = BindAssetListViewItem;
+			_bundleListView.bindItem = BindBundleListViewItem;
-
 #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>
 		/// 填充页面数据
 		/// </summary>
@@ -62,21 +72,33 @@ namespace YooAsset.Editor
 		}
 		private List<DebugBundleInfo> FilterViewItems(DebugReport debugReport, string searchKeyWord)
 		{
-			Dictionary<string, DebugBundleInfo> result = new Dictionary<string, DebugBundleInfo>(debugReport.ProviderInfos.Count);
+			List<DebugBundleInfo> result = new List<DebugBundleInfo>(1000);
-			foreach (var providerInfo in debugReport.ProviderInfos)
+			foreach (var pakcageData in debugReport.PackageDatas)
 			{
-				foreach (var bundleInfo in providerInfo.BundleInfos)
+				Dictionary<string, DebugBundleInfo> tempDic = new Dictionary<string, DebugBundleInfo>(1000);
+				foreach (var providerInfo in pakcageData.ProviderInfos)
 				{
-					if (string.IsNullOrEmpty(searchKeyWord) == false)
+					foreach (var bundleInfo in providerInfo.DependBundleInfos)
 					{
-						if (bundleInfo.BundleName.Contains(searchKeyWord) == false)
+						if (string.IsNullOrEmpty(searchKeyWord) == false)
-							continue;
+						{
+							if (bundleInfo.BundleName.Contains(searchKeyWord) == false)
+								continue;
+						}
+
+						if (tempDic.ContainsKey(bundleInfo.BundleName) == false)
+						{
+							bundleInfo.PackageName = pakcageData.PackageName;
+							tempDic.Add(bundleInfo.BundleName, bundleInfo);
+						}
 					}
-					if (result.ContainsKey(bundleInfo.BundleName) == false)
-						result.Add(bundleInfo.BundleName, bundleInfo);
 				}
+
+				var tempList = tempDic.Values.ToList();
+				tempList.Sort();
+				result.AddRange(tempList);
 			}
-			return result.Values.ToList();
+			return result;
 		}
 
 		/// <summary>
@@ -97,11 +119,21 @@ namespace YooAsset.Editor
 
 
 		// 顶部列表相关
-		private VisualElement MakeAssetListViewItem()
+		private VisualElement MakeBundleListViewItem()
 		{
 			VisualElement element = new VisualElement();
 			element.style.flexDirection = FlexDirection.Row;
 
+			{
+				var label = new Label();
+				label.name = "Label0";
+				label.style.unityTextAlign = TextAnchor.MiddleLeft;
+				label.style.marginLeft = 3f;
+				//label.style.flexGrow = 1f;
+				label.style.width = 150;
+				element.Add(label);
+			}
+
 			{
 				var label = new Label();
 				label.name = "Label1";
@@ -134,11 +166,15 @@ namespace YooAsset.Editor
 
 			return element;
 		}
-		private void BindAssetListViewItem(VisualElement element, int index)
+		private void BindBundleListViewItem(VisualElement element, int index)
 		{
 			var sourceData = _bundleListView.itemsSource as List<DebugBundleInfo>;
 			var bundleInfo = sourceData[index];
 
+			// Package Name
+			var label0 = element.Q<Label>("Label0");
+			label0.text = bundleInfo.PackageName;
+
 			// Bundle Name
 			var label1 = element.Q<Label>("Label1");
 			label1.text = bundleInfo.BundleName;
@@ -149,7 +185,7 @@ namespace YooAsset.Editor
 
 			// Status
 			StyleColor textColor;
-			if (bundleInfo.Status == AssetBundleLoaderBase.EStatus.Failed)
+			if (bundleInfo.Status == BundleLoaderBase.EStatus.Failed.ToString())
 				textColor = new StyleColor(Color.yellow);
 			else
 				textColor = label1.style.color;
@@ -162,7 +198,7 @@ namespace YooAsset.Editor
 			foreach (var item in objs)
 			{
 				DebugBundleInfo bundleInfo = item as DebugBundleInfo;
-				FillUsingListView(bundleInfo.BundleName);
+				FillUsingListView(bundleInfo);
 			}
 		}
 
@@ -249,17 +285,23 @@ namespace YooAsset.Editor
 			var label5 = element.Q<Label>("Label5");
 			label5.text = providerInfo.Status.ToString();
 		}
-		private void FillUsingListView(string bundleName)
+		private void FillUsingListView(DebugBundleInfo selectedBundleInfo)
-		{	
+		{
 			List<DebugProviderInfo> source = new List<DebugProviderInfo>();
-			foreach (var providerInfo in _debugReport.ProviderInfos)
+			foreach (var packageData in _debugReport.PackageDatas)
 			{
-				foreach (var bundleInfo in providerInfo.BundleInfos)
+				if (packageData.PackageName == selectedBundleInfo.PackageName)
 				{
-					if (bundleInfo.BundleName == bundleName)
+					foreach (var providerInfo in packageData.ProviderInfos)
 					{
-						source.Add(providerInfo);
+						foreach (var bundleInfo in providerInfo.DependBundleInfos)
-						continue;
+						{
+							if (bundleInfo.BundleName == selectedBundleInfo.BundleName)
+							{
+								source.Add(providerInfo);
+								continue;
+							}
+						}
 					}
 				}
 			}

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

@@ -1,6 +1,7 @@
 <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" editor-extension-mode="False">
     <ui:VisualElement name="TopGroup" style="flex-grow: 1; border-left-width: 1px; border-right-width: 1px; border-top-width: 1px; border-bottom-width: 1px; border-left-color: rgb(0, 0, 0); border-right-color: rgb(0, 0, 0); border-top-color: rgb(0, 0, 0); border-bottom-color: rgb(0, 0, 0); margin-left: 0; margin-right: 0; margin-top: 2px; margin-bottom: 1px; display: flex;">
         <uie:Toolbar name="TopBar" style="height: 25px; margin-left: 1px; margin-right: 1px;">
+            <uie:ToolbarButton text="Package Name" display-tooltip-when-elided="true" name="TopBar0" style="width: 150px; -unity-text-align: middle-left; flex-grow: 0;" />
             <uie:ToolbarButton text="Bundle Name" display-tooltip-when-elided="true" name="TopBar1" style="width: 280px; -unity-text-align: middle-left; flex-grow: 1;" />
             <uie:ToolbarButton text="Ref Count" display-tooltip-when-elided="true" name="TopBar3" style="width: 100px; -unity-text-align: middle-left;" />
             <uie:ToolbarButton text="Status" display-tooltip-when-elided="true" name="TopBar4" style="width: 120px; -unity-text-align: middle-left;" />

Assets/YooAsset/Editor/AssetBundleReporter/AssetBundleReporterWindow.cs

@@ -55,12 +55,10 @@ namespace YooAsset.Editor
 				VisualElement root = this.rootVisualElement;
 
 				// 加载布局文件
-				var visualAsset = YooAssetEditorSettingsData.Setting.AssetBundleReporterUXML;
+				var visualAsset =  EditorHelper.LoadWindowUXML<AssetBundleReporterWindow>();
 				if (visualAsset == null)
-				{
-					Debug.LogError($"Not found {nameof(AssetBundleReporterWindow)}.uxml in settings.");
 					return;
-				}
+				
 				visualAsset.CloneTree(root);
 
 				// 导入按钮
@@ -111,7 +109,7 @@ namespace YooAsset.Editor
 				return;
 
 			_reportFilePath = selectFilePath;
-			string jsonData = FileUtility.ReadFile(_reportFilePath);
+			string jsonData = FileUtility.ReadAllText(_reportFilePath);
 			_buildReport = BuildReport.Deserialize(jsonData);
 			_assetListViewer.FillViewData(_buildReport, _searchKeyWord);
 			_bundleListViewer.FillViewData(_buildReport, _reportFilePath, _searchKeyWord);

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

@@ -38,46 +38,36 @@ namespace YooAsset.Editor
 		public void InitViewer()
 		{
 			// 加载布局文件
-			_visualAsset = YooAssetEditorSettingsData.Setting.ReporterAssetListViewerUXML;
+			_visualAsset = EditorHelper.LoadWindowUXML<ReporterAssetListViewer>();
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(ReporterAssetListViewer)}.uxml in settings.");
 				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>
@@ -320,11 +310,11 @@ namespace YooAsset.Editor
 
 			// Size
 			var label2 = element.Q<Label>("Label2");
-			label2.text = EditorUtility.FormatBytes(bundleInfo.SizeBytes);
+			label2.text = EditorUtility.FormatBytes(bundleInfo.FileSize);
 
 			// Hash
 			var label3 = element.Q<Label>("Label3");
-			label3.text = bundleInfo.Hash;
+			label3.text = bundleInfo.FileHash;
 		}
 	}
 }

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

@@ -1,10 +1,10 @@
-<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" editor-extension-mode="False">
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements">
     <ui:VisualElement name="TopGroup" style="flex-grow: 1; border-left-width: 1px; border-right-width: 1px; border-top-width: 1px; border-bottom-width: 1px; border-left-color: rgb(0, 0, 0); border-right-color: rgb(0, 0, 0); border-top-color: rgb(0, 0, 0); border-bottom-color: rgb(0, 0, 0); margin-left: 0; margin-right: 0; margin-top: 2px; margin-bottom: 1px; display: flex;">
         <uie:Toolbar name="TopBar" style="height: 25px; margin-left: 1px; margin-right: 1px;">
             <uie:ToolbarButton text="Asset Path" display-tooltip-when-elided="true" name="TopBar1" style="width: 280px; -unity-text-align: middle-left; flex-grow: 1;" />
             <uie:ToolbarButton text="Main Bundle" display-tooltip-when-elided="true" name="TopBar2" style="width: 145px; -unity-text-align: middle-left; flex-grow: 1;" />
         </uie:Toolbar>
-        <ui:ListView focusable="true" name="TopListView" item-height="18" virtualization-method="DynamicHeight" style="flex-grow: 1;" />
+        <ui:ListView focusable="true" name="TopListView" item-height="18" virtualization-method="DynamicHeight" style="flex-grow: 1; flex-basis: 60px;" />
     </ui:VisualElement>
     <ui:VisualElement name="BottomGroup" style="height: 200px; border-left-width: 1px; border-right-width: 1px; border-top-width: 1px; border-bottom-width: 1px; border-left-color: rgb(0, 0, 0); border-right-color: rgb(0, 0, 0); border-top-color: rgb(0, 0, 0); border-bottom-color: rgb(0, 0, 0); margin-left: 0; margin-right: 0; margin-top: 1px; margin-bottom: 1px; display: flex;">
         <uie:Toolbar name="BottomBar" style="height: 25px; margin-left: 1px; margin-right: 1px;">

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

@@ -25,7 +25,7 @@ namespace YooAsset.Editor
 		private ToolbarButton _topBar1;
 		private ToolbarButton _topBar2;
 		private ToolbarButton _topBar3;
-		private ToolbarButton _topBar4;
+		private ToolbarButton _topBar5;
 		private ToolbarButton _bottomBar1;
 		private ListView _bundleListView;
 		private ListView _includeListView;
@@ -42,56 +42,46 @@ namespace YooAsset.Editor
 		public void InitViewer()
 		{
 			// 加载布局文件
-			_visualAsset = YooAssetEditorSettingsData.Setting.ReporterBundleListViewerUXML;
+			_visualAsset = EditorHelper.LoadWindowUXML<ReporterBundleListViewer>();
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(ReporterBundleListViewer)}.uxml in settings.");
 				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");
+			_topBar5 = _root.Q<ToolbarButton>("TopBar5");
-				_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;
+			_topBar5.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 reprotFilePath, string searchKeyWord)
+		public void FillViewData(BuildReport buildReport, string reprotFilePath, string searchKeyWord)
 		{
 			_buildReport = buildReport;
 			_reportFilePath = reprotFilePath;
@@ -132,9 +122,9 @@ namespace YooAsset.Editor
 			else if (_sortMode == ESortMode.BundleSize)
 			{
 				if (_descendingSort)
-					return result.OrderByDescending(a => a.SizeBytes).ToList();
+					return result.OrderByDescending(a => a.FileSize).ToList();
 				else
-					return result.OrderBy(a => a.SizeBytes).ToList();
+					return result.OrderBy(a => a.FileSize).ToList();
 			}
 			else if (_sortMode == ESortMode.BundleTags)
 			{
@@ -154,7 +144,7 @@ namespace YooAsset.Editor
 			_topBar1.text = $"Bundle Name ({_bundleListView.itemsSource.Count})";
 			_topBar2.text = "Size";
 			_topBar3.text = "Hash";
-			_topBar4.text = "Tags";
+			_topBar5.text = "Tags";
 
 			if (_sortMode == ESortMode.BundleName)
 			{
@@ -173,9 +163,9 @@ namespace YooAsset.Editor
 			else if (_sortMode == ESortMode.BundleTags)
 			{
 				if (_descendingSort)
-					_topBar4.text = "Tags ↓";
+					_topBar5.text = "Tags ↓";
 				else
-					_topBar4.text = "Tags ↑";
+					_topBar5.text = "Tags ↑";
 			}
 			else
 			{
@@ -241,6 +231,16 @@ namespace YooAsset.Editor
 				label.name = "Label5";
 				label.style.unityTextAlign = TextAnchor.MiddleLeft;
 				label.style.marginLeft = 3f;
+				//label.style.flexGrow = 1f;
+				label.style.width = 150;
+				element.Add(label);
+			}
+
+			{
+				var label = new Label();
+				label.name = "Label6";
+				label.style.unityTextAlign = TextAnchor.MiddleLeft;
+				label.style.marginLeft = 3f;
 				label.style.flexGrow = 1f;
 				label.style.width = 80;
 				element.Add(label);
@@ -259,15 +259,19 @@ namespace YooAsset.Editor
 
 			// Size
 			var label2 = element.Q<Label>("Label2");
-			label2.text = EditorUtility.FormatBytes(bundleInfo.SizeBytes);
+			label2.text = EditorUtility.FormatBytes(bundleInfo.FileSize);
 
 			// Hash
 			var label3 = element.Q<Label>("Label3");
-			label3.text = bundleInfo.Hash;
+			label3.text = bundleInfo.FileHash;
+
+			// LoadMethod
+			var label5 = element.Q<Label>("Label5");
+			label5.text = bundleInfo.LoadMethod.ToString();
 
 			// Tags
-			var label5 = element.Q<Label>("Label5");
+			var label6 = element.Q<Label>("Label6");
-			label5.text = bundleInfo.GetTagsString();
+			label6.text = bundleInfo.GetTagsString();
 		}
 		private void BundleListView_onSelectionChange(IEnumerable<object> objs)
 		{
@@ -281,11 +285,11 @@ namespace YooAsset.Editor
 		}
 		private void ShowAssetBundleInspector(ReportBundleInfo bundleInfo)
 		{
-			if (bundleInfo.IsRawFile())
+			if (bundleInfo.IsRawFile)
 				return;
 
 			string rootDirectory = Path.GetDirectoryName(_reportFilePath);
-			string filePath = $"{rootDirectory}/{bundleInfo.Hash}";
+			string filePath = $"{rootDirectory}/{bundleInfo.FileName}";
 			if (File.Exists(filePath))
 				Selection.activeObject = AssetBundleRecorder.GetAssetBundle(filePath);
 			else

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

@@ -1,13 +1,14 @@
-<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" editor-extension-mode="False">
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements">
     <ui:VisualElement name="Viewer" style="flex-grow: 1; display: flex;">
         <ui:VisualElement name="TopGroup" style="flex-grow: 1; border-left-width: 1px; border-right-width: 1px; border-top-width: 1px; border-bottom-width: 1px; border-left-color: rgb(0, 0, 0); border-right-color: rgb(0, 0, 0); border-top-color: rgb(0, 0, 0); border-bottom-color: rgb(0, 0, 0); margin-left: 0; margin-right: 0; margin-top: 2px; margin-bottom: 1px; display: flex;">
             <uie:Toolbar name="TopBar" style="height: 25px; margin-left: 1px; margin-right: 1px;">
                 <uie:ToolbarButton text="Bundle Name" display-tooltip-when-elided="true" name="TopBar1" style="width: 280px; -unity-text-align: middle-left; flex-grow: 1;" />
                 <uie:ToolbarButton text="Size" display-tooltip-when-elided="true" name="TopBar2" style="width: 100px; -unity-text-align: middle-left; flex-grow: 0;" />
                 <uie:ToolbarButton text="Hash" display-tooltip-when-elided="true" name="TopBar3" style="width: 280px; -unity-text-align: middle-left;" />
-                <uie:ToolbarButton text="Tags" display-tooltip-when-elided="true" name="TopBar4" style="width: 80px; -unity-text-align: middle-left; flex-grow: 1;" />
+                <uie:ToolbarButton text="LoadMethod" display-tooltip-when-elided="true" name="TopBar4" style="width: 150px; -unity-text-align: middle-left; flex-grow: 0;" />
+                <uie:ToolbarButton text="Tags" display-tooltip-when-elided="true" name="TopBar5" style="width: 80px; -unity-text-align: middle-left; flex-grow: 1;" />
             </uie:Toolbar>
-            <ui:ListView focusable="true" name="TopListView" item-height="18" virtualization-method="DynamicHeight" style="flex-grow: 1;" />
+            <ui:ListView focusable="true" name="TopListView" item-height="18" virtualization-method="DynamicHeight" style="flex-grow: 1; flex-basis: 60px;" />
         </ui:VisualElement>
         <ui:VisualElement name="BottomGroup" style="height: 200px; border-left-width: 1px; border-right-width: 1px; border-top-width: 1px; border-bottom-width: 1px; border-left-color: rgb(0, 0, 0); border-right-color: rgb(0, 0, 0); border-top-color: rgb(0, 0, 0); border-bottom-color: rgb(0, 0, 0); margin-left: 0; margin-right: 0; margin-top: 1px; margin-bottom: 1px; display: flex;">
             <uie:Toolbar name="BottomBar" style="height: 25px; margin-left: 1px; margin-right: 1px;">

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

@@ -27,7 +27,6 @@ namespace YooAsset.Editor
 		private TemplateContainer _root;
 
 		private ListView _listView;
-		private BuildReport _buildReport;
 		private readonly List<ItemWrapper> _items = new List<ItemWrapper>();
 
 
@@ -37,12 +36,10 @@ namespace YooAsset.Editor
 		public void InitViewer()
 		{
 			// 加载布局文件
-			_visualAsset = YooAssetEditorSettingsData.Setting.ReporterSummaryViewerUXML;
+			_visualAsset = EditorHelper.LoadWindowUXML<ReporterSummaryViewer>();
 			if (_visualAsset == null)
-			{
-				Debug.LogError($"Not found {nameof(ReporterSummaryViewer)}.uxml in settings.");
 				return;
-			}
+
 			_root = _visualAsset.CloneTree();
 			_root.style.flexGrow = 1f;
 
@@ -57,25 +54,25 @@ namespace YooAsset.Editor
 		/// </summary>
 		public void FillViewData(BuildReport buildReport)
 		{
-			_buildReport = buildReport;
-			
 			_items.Clear();
+
+			_items.Add(new ItemWrapper("YooAsset版本", buildReport.Summary.YooVersion));
 			_items.Add(new ItemWrapper("引擎版本", buildReport.Summary.UnityVersion));
-			_items.Add(new ItemWrapper("构建时间", buildReport.Summary.BuildTime));
+			_items.Add(new ItemWrapper("构建时间", buildReport.Summary.BuildDate));
-			_items.Add(new ItemWrapper("构建耗时", $"{buildReport.Summary.BuildSeconds}秒"));
+			_items.Add(new ItemWrapper("构建耗时", ConvertTime(buildReport.Summary.BuildSeconds)));
 			_items.Add(new ItemWrapper("构建平台", $"{buildReport.Summary.BuildTarget}"));
+			_items.Add(new ItemWrapper("构建管线", $"{buildReport.Summary.BuildPipeline}"));
 			_items.Add(new ItemWrapper("构建模式", $"{buildReport.Summary.BuildMode}"));
-			_items.Add(new ItemWrapper("构建版本", $"{buildReport.Summary.BuildVersion}"));
+			_items.Add(new ItemWrapper("包裹名称", buildReport.Summary.BuildPackageName));
-			_items.Add(new ItemWrapper("内置资源标签", $"{buildReport.Summary.BuildinTags}"));
+			_items.Add(new ItemWrapper("包裹版本", buildReport.Summary.BuildPackageVersion));
 
 			_items.Add(new ItemWrapper("启用可寻址资源定位", $"{buildReport.Summary.EnableAddressable}"));
-			_items.Add(new ItemWrapper("追加文件扩展名", $"{buildReport.Summary.AppendFileExtension}"));
+			_items.Add(new ItemWrapper("资源包名唯一化", $"{buildReport.Summary.UniqueBundleName}"));
-			_items.Add(new ItemWrapper("自动收集着色器", $"{buildReport.Summary.AutoCollectShaders}"));
-			_items.Add(new ItemWrapper("着色器资源包名称", $"{buildReport.Summary.ShadersBundleName}"));
 			_items.Add(new ItemWrapper("加密服务类名称", $"{buildReport.Summary.EncryptionServicesClassName}"));
 
 			_items.Add(new ItemWrapper(string.Empty, string.Empty));
 			_items.Add(new ItemWrapper("构建参数", string.Empty));
+			_items.Add(new ItemWrapper("OutputNameStyle", $"{buildReport.Summary.OutputNameStyle}"));
 			_items.Add(new ItemWrapper("CompressOption", $"{buildReport.Summary.CompressOption}"));
 			_items.Add(new ItemWrapper("DisableWriteTypeTree", $"{buildReport.Summary.DisableWriteTypeTree}"));
 			_items.Add(new ItemWrapper("IgnoreTypeTreeChanges", $"{buildReport.Summary.IgnoreTypeTreeChanges}"));
@@ -83,10 +80,9 @@ namespace YooAsset.Editor
 			_items.Add(new ItemWrapper(string.Empty, string.Empty));
 			_items.Add(new ItemWrapper("构建结果", string.Empty));
 			_items.Add(new ItemWrapper("构建文件总数", $"{buildReport.Summary.AssetFileTotalCount}"));
+			_items.Add(new ItemWrapper("主资源总数", $"{buildReport.Summary.MainAssetTotalCount}"));
 			_items.Add(new ItemWrapper("资源包总数", $"{buildReport.Summary.AllBundleTotalCount}"));
 			_items.Add(new ItemWrapper("资源包总大小", ConvertSize(buildReport.Summary.AllBundleTotalSize)));
-			_items.Add(new ItemWrapper("内置资源包总数", $"{buildReport.Summary.BuildinBundleTotalCount}"));
-			_items.Add(new ItemWrapper("内置资源包总大小", ConvertSize(buildReport.Summary.BuildinBundleTotalSize)));
 			_items.Add(new ItemWrapper("加密资源包总数", $"{buildReport.Summary.EncryptedBundleTotalCount}"));
 			_items.Add(new ItemWrapper("加密资源包总大小", ConvertSize(buildReport.Summary.EncryptedBundleTotalSize)));
 			_items.Add(new ItemWrapper("原生资源包总数", $"{buildReport.Summary.RawBundleTotalCount}"));
@@ -155,16 +151,23 @@ namespace YooAsset.Editor
 			label2.text = itemWrapper.Value;
 		}
 
+		private string ConvertTime(int time)
+		{
+			if (time <= 60)
+			{
+				return $"{time}秒钟";
+			}
+			else
+			{
+				int minute = time / 60;
+				return $"{minute}分钟";
+			}
+		}
 		private string ConvertSize(long size)
 		{
 			if (size == 0)
 				return "0";
-			if (size < 1024)
+			return EditorUtility.FormatBytes(size);
-				return $"{size} Bytes";
-			else if (size < 1024 * 1024)
-				return $"{(int)(size / 1024)} KB";
-			else
-				return $"{(int)(size / (1024 * 1024))} MB";
 		}
 	}
 }

Assets/YooAsset/Editor/EditorAttribute.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Reflection;
+
+namespace YooAsset.Editor
+{
+	/// <summary>
+	/// 编辑器显示名字
+	/// </summary>
+	public class DisplayNameAttribute : Attribute
+	{
+		public string DisplayName;
+
+		public DisplayNameAttribute(string name)
+		{
+			this.DisplayName = name;
+		}
+	}
+
+	public static class EditorAttribute
+	{
+		internal static T GetAttribute<T>(Type type) where T : Attribute
+		{
+			return (T)type.GetCustomAttribute(typeof(T), false);
+		}
+
+		internal static T GetAttribute<T>(MethodInfo methodInfo) where T : Attribute
+		{
+			return (T)methodInfo.GetCustomAttribute(typeof(T), false);
+		}
+
+		internal static T GetAttribute<T>(FieldInfo field) where T : Attribute
+		{
+			return (T)field.GetCustomAttribute(typeof(T), false);
+		}
+	}
+}

Assets/YooAsset/Editor/EditorAttribute.cs.meta

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

Assets/YooAsset/Editor/EditorDefine.cs

@@ -8,7 +8,14 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 停靠窗口类型集合
 		/// </summary>
-		public static readonly Type[] DockedWindowTypes = { typeof(AssetBundleBuilderWindow), typeof(AssetBundleCollectorWindow), typeof(AssetBundleDebuggerWindow), typeof(AssetBundleReporterWindow)};
+		public static readonly Type[] DockedWindowTypes = 
+		{
+			typeof(AssetBundleBuilderWindow),
+			typeof(AssetBundleCollectorWindow),
+			typeof(AssetBundleDebuggerWindow),
+			typeof(AssetBundleReporterWindow),
+			typeof(ShaderVariantCollectorWindow)
+		};
 #endif
 	}
 

Assets/YooAsset/Editor/EditorHelper.cs

@@ -0,0 +1,132 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class EditorHelper
+	{
+#if UNITY_2019_4_OR_NEWER
+		private readonly static Dictionary<System.Type, string> _uxmlDic = new Dictionary<System.Type, string>();
+
+		/*
+		static EditorHelper()
+		{
+			// 资源包收集
+			_uxmlDic.Add(typeof(AssetBundleCollectorWindow), "355c4ac5cdebddc4c8362bed6f17a79e");
+
+			// 资源包构建
+			_uxmlDic.Add(typeof(AssetBundleBuilderWindow), "28ba29adb4949284e8c48893218b0d9a");
+
+			// 资源包调试
+			_uxmlDic.Add(typeof(AssetBundleDebuggerWindow), "790db12999afd334e8fb6ba70ef0a947");
+			_uxmlDic.Add(typeof(DebuggerAssetListViewer), "31c6096c1cb29b4469096b7b4942a322");
+			_uxmlDic.Add(typeof(DebuggerBundleListViewer), "932a25ffd05c13c47994d66e9d73bc37");
+
+			// 构建报告
+			_uxmlDic.Add(typeof(AssetBundleReporterWindow), "9052b72c383e95043a0c7e7f369b1ad7");
+			_uxmlDic.Add(typeof(ReporterSummaryViewer), "f8929271050855e42a1ccc6b14993a04");
+			_uxmlDic.Add(typeof(ReporterAssetListViewer), "5f81bc15a55ee0a49a266f9d71e2372b");
+			_uxmlDic.Add(typeof(ReporterBundleListViewer), "56d6dbe0d65ce334a8996beb19612989");
+		}
+
+		/// <summary>
+		/// 加载窗口的布局文件
+		/// </summary>
+		public static UnityEngine.UIElements.VisualTreeAsset LoadWindowUXML<TWindow>() where TWindow : class
+		{
+			var windowType = typeof(TWindow);
+			if (_uxmlDic.TryGetValue(windowType, out string uxmlGUID))
+			{
+				string assetPath = AssetDatabase.GUIDToAssetPath(uxmlGUID);
+				if (string.IsNullOrEmpty(assetPath))
+					throw new System.Exception($"Invalid YooAsset uxml guid : {uxmlGUID}");
+				var visualTreeAsset = AssetDatabase.LoadAssetAtPath<UnityEngine.UIElements.VisualTreeAsset>(assetPath);
+				if (visualTreeAsset == null)
+					throw new System.Exception($"Failed to load {windowType}.uxml");
+				return visualTreeAsset;
+			}
+			else
+			{
+				throw new System.Exception($"Invalid YooAsset window type : {windowType}");
+			}
+		}
+		*/
+
+		/// <summary>
+		/// 加载窗口的布局文件
+		/// </summary>
+		public static UnityEngine.UIElements.VisualTreeAsset LoadWindowUXML<TWindow>() where TWindow : class
+		{
+			var windowType = typeof(TWindow);
+
+			// 缓存里查询并加载
+			if (_uxmlDic.TryGetValue(windowType, out string uxmlGUID))
+			{
+				string assetPath = AssetDatabase.GUIDToAssetPath(uxmlGUID);
+				if (string.IsNullOrEmpty(assetPath))
+				{
+					_uxmlDic.Clear();
+					throw new System.Exception($"Invalid UXML GUID : {uxmlGUID} ! Please close the window and open it again !");
+				}
+				var treeAsset = AssetDatabase.LoadAssetAtPath<UnityEngine.UIElements.VisualTreeAsset>(assetPath);
+				return treeAsset;
+			}
+
+			// 全局搜索并加载
+			string[] guids = AssetDatabase.FindAssets(windowType.Name);
+			if (guids.Length == 0)
+				throw new System.Exception($"Not found any assets : {windowType.Name}");
+
+			foreach (string assetGUID in guids)
+			{
+				string assetPath = AssetDatabase.GUIDToAssetPath(assetGUID);
+				var assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
+				if (assetType == typeof(UnityEngine.UIElements.VisualTreeAsset))
+				{
+					_uxmlDic.Add(windowType, assetGUID);
+					var treeAsset = AssetDatabase.LoadAssetAtPath<UnityEngine.UIElements.VisualTreeAsset>(assetPath);
+					return treeAsset;
+				}
+			}
+			throw new System.Exception($"Not found UXML file : {windowType.Name}");
+		}
+#endif
+
+		/// <summary>
+		/// 加载相关的配置文件
+		/// </summary>
+		public static TSetting LoadSettingData<TSetting>() where TSetting : ScriptableObject
+		{
+			var settingType = typeof(TSetting);
+			var guids = AssetDatabase.FindAssets($"t:{settingType.Name}");
+			if (guids.Length == 0)
+			{
+				Debug.LogWarning($"Create new {settingType.Name}.asset");
+				var setting = ScriptableObject.CreateInstance<TSetting>();
+				string filePath = $"Assets/{settingType.Name}.asset";
+				AssetDatabase.CreateAsset(setting, filePath);
+				AssetDatabase.SaveAssets();
+				AssetDatabase.Refresh();
+				return setting;
+			}
+			else
+			{
+				if (guids.Length != 1)
+				{
+					foreach (var guid in guids)
+					{
+						string path = AssetDatabase.GUIDToAssetPath(guid);
+						Debug.LogWarning($"Found multiple file : {path}");
+					}
+					throw new System.Exception($"Found multiple {settingType.Name} files !");
+				}
+
+				string filePath = AssetDatabase.GUIDToAssetPath(guids[0]);
+				var setting = AssetDatabase.LoadAssetAtPath<TSetting>(filePath);
+				return setting;
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/EditorTools.cs

@@ -7,6 +7,7 @@ using System.IO;
 using System.Text;
 using UnityEngine;
 using UnityEditor;
+using UnityEditor.SceneManagement;
 
 namespace YooAsset.Editor
 {
@@ -212,6 +213,11 @@ namespace YooAsset.Editor
 		public static void FocusUnitySceneWindow()
 		{
 			EditorWindow.FocusWindowIfItsOpen<SceneView>();
+		} 
+		public static void CloseUnityGameWindow() 
+		{ 
+			System.Type T = Assembly.Load("UnityEditor").GetType("UnityEditor.GameView"); 
+			EditorWindow.GetWindow(T, false, "GameView", true).Close(); 
 		}
 		public static void FocusUnityGameWindow()
 		{
@@ -265,6 +271,49 @@ namespace YooAsset.Editor
 		}
 		#endregion
 
+		#region SceneUtility
+		public static bool HasDirtyScenes()
+		{
+			var sceneCount = EditorSceneManager.sceneCount;
+			for (var i = 0; i < sceneCount; ++i)
+			{
+				var scene = EditorSceneManager.GetSceneAt(i);
+				if (scene.isDirty)
+					return true;
+			}
+			return false;
+		}
+		#endregion
+
+		#region StringUtility
+		public static List<string> StringToStringList(string str, char separator)
+		{
+			List<string> result = new List<string>();
+			if (!String.IsNullOrEmpty(str))
+			{
+				string[] splits = str.Split(separator);
+				foreach (string split in splits)
+				{
+					string value = split.Trim(); //移除首尾空格
+					if (!String.IsNullOrEmpty(value))
+					{
+						result.Add(value);
+					}
+				}
+			}
+			return result;
+		}
+
+		public static T NameToEnum<T>(string name)
+		{
+			if (Enum.IsDefined(typeof(T), name) == false)
+			{
+				throw new ArgumentException($"Enum {typeof(T)} is not defined name {name}");
+			}
+			return (T)Enum.Parse(typeof(T), name);
+		}
+		#endregion
+
 		#region 文件
 		/// <summary>
 		/// 创建文件所在的目录
@@ -329,14 +378,17 @@ namespace YooAsset.Editor
 		}
 
 		/// <summary>
-		/// 文件移动
+		/// 移动文件
 		/// </summary>
-		public static void FileMoveTo(string filePath, string destPath)
+		public static void MoveFile(string filePath, string destPath)
 		{
+			if (File.Exists(destPath))
+				File.Delete(destPath);
+
 			FileInfo fileInfo = new FileInfo(filePath);
 			fileInfo.MoveTo(destPath);
 		}
-
+		
 		/// <summary>
 		/// 拷贝文件夹
 		/// 注意：包括所有子目录的文件

Assets/YooAsset/Editor/ShaderVariantCollector/ShaderVariantCollectionHelper.cs

@@ -10,103 +10,31 @@ namespace YooAsset.Editor
 {
 	public static class ShaderVariantCollectionHelper
 	{
-		[Serializable]
+		public static void ClearCurrentShaderVariantCollection()
-		public class ShaderVariantWrapper
 		{
-			/// <summary>
+			EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "ClearCurrentShaderVariantCollection");
-			/// Shader asset path in editor.
+		}
-			/// </summary>
+		public static void SaveCurrentShaderVariantCollection(string savePath)
-			public string AssetPath;
+		{
-
+			EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "SaveCurrentShaderVariantCollection", savePath);
-			/// <summary>
+		}
-			/// Shader name.
+		public static int GetCurrentShaderVariantCollectionShaderCount()
-			/// </summary>
+		{
-			public string ShaderName;
+			return (int)EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetCurrentShaderVariantCollectionShaderCount");
-
+		}
-			/// <summary>
+		public static int GetCurrentShaderVariantCollectionVariantCount()
-			///  Pass type to use in this variant.
+		{
-			/// </summary>
+			return (int)EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetCurrentShaderVariantCollectionVariantCount");
-			public PassType PassType;
-
-			/// <summary>
-			/// Array of shader keywords to use in this variant.
-			/// </summary>
-			public string[] Keywords;
-
-			public ShaderVariantWrapper(string assetPath, string shaderName, PassType passType, params string[] keywords)
-			{
-				AssetPath = assetPath;
-				ShaderName = shaderName;
-				PassType = passType;
-				Keywords = keywords;
-			}
 		}
 
-		[Serializable]
+		/// <summary>
-		public class ShaderVariantCollectionWrapper
+		/// 获取着色器的变种总数量
+		/// </summary>
+		public static string GetShaderVariantCount(string assetPath)
 		{
-			/// <summary>
+			Shader shader = AssetDatabase.LoadAssetAtPath<Shader>(assetPath);
-			/// Number of shaders in this collection
+			var variantCount = EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetVariantCount", shader, true);
-			/// </summary>
+			return variantCount.ToString();
-			public int ShaderCount;
-
-			/// <summary>
-			/// Number of total varians in this collection
-			/// </summary>
-			public int VariantCount;
-
-			/// <summary>
-			/// Shader variants list.
-			/// </summary>
-			public List<ShaderVariantWrapper> ShaderVariants = new List<ShaderVariantWrapper>(1000);
-
-			public void Add(ShaderVariantWrapper variant)
-			{
-				ShaderVariants.Add(variant);
-			}
-		}
-
-
-		public static ShaderVariantCollectionWrapper Extract(ShaderVariantCollection svc)
-		{
-			var result = new ShaderVariantCollectionWrapper();
-			using (var so = new SerializedObject(svc))
-			{
-				var shaderArray = so.FindProperty("m_Shaders.Array");
-				if (shaderArray != null && shaderArray.isArray)
-				{
-					for (int i = 0; i < shaderArray.arraySize; ++i)
-					{
-						var shaderRef = shaderArray.FindPropertyRelative($"data[{i}].first");
-						var shaderVariantsArray = shaderArray.FindPropertyRelative($"data[{i}].second.variants");
-						if (shaderRef != null && shaderRef.propertyType == SerializedPropertyType.ObjectReference && shaderVariantsArray != null && shaderVariantsArray.isArray)
-						{
-							var shader = shaderRef.objectReferenceValue as Shader;
-							if (shader == null)
-							{
-								throw new Exception("Invalid shader in ShaderVariantCollection file.");
-							}
-
-							string shaderAssetPath = AssetDatabase.GetAssetPath(shader);
-							string shaderName = shader.name;
-
-							// 添加变种信息
-							for (int j = 0; j < shaderVariantsArray.arraySize; ++j)
-							{
-								var propKeywords = shaderVariantsArray.FindPropertyRelative($"Array.data[{j}].keywords");
-								var propPassType = shaderVariantsArray.FindPropertyRelative($"Array.data[{j}].passType");
-								if (propKeywords != null && propPassType != null && propKeywords.propertyType == SerializedPropertyType.String)
-								{
-									string[] keywords = propKeywords.stringValue.Split(' ');
-									PassType pathType = (PassType)propPassType.intValue;
-									result.Add(new ShaderVariantWrapper(shaderAssetPath, shaderName, pathType, keywords));
-								}
-							}
-						}
-					}
-				}
-			}
-			return result;
 		}
 	}
 }

Assets/YooAsset/Editor/ShaderVariantCollector/ShaderVariantCollectionManifest.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[Serializable]
+	public class ShaderVariantCollectionManifest
+	{
+		[Serializable]
+		public class ShaderVariantElement
+		{
+			/// <summary>
+			///  Pass type to use in this variant.
+			/// </summary>
+			public PassType PassType;
+
+			/// <summary>
+			/// Array of shader keywords to use in this variant.
+			/// </summary>
+			public string[] Keywords;
+		}
+
+		[Serializable]
+		public class ShaderVariantInfo
+		{
+			/// <summary>
+			/// Shader asset path in editor.
+			/// </summary>
+			public string AssetPath;
+
+			/// <summary>
+			/// Shader name.
+			/// </summary>
+			public string ShaderName;
+
+			/// <summary>
+			/// Shader variants elements list.
+			/// </summary>
+			public List<ShaderVariantElement> ShaderVariantElements = new List<ShaderVariantElement>(1000);
+		}
+
+
+		/// <summary>
+		/// Number of shaders in this collection
+		/// </summary>
+		public int ShaderTotalCount;
+
+		/// <summary>
+		/// Number of total varians in this collection
+		/// </summary>
+		public int VariantTotalCount;
+
+		/// <summary>
+		/// Shader variants info list.
+		/// </summary>
+		public List<ShaderVariantInfo> ShaderVariantInfos = new List<ShaderVariantInfo>(1000);
+
+		/// <summary>
+		/// 添加着色器变种信息
+		/// </summary>
+		public void AddShaderVariant(string assetPath, string shaderName, PassType passType, string[] keywords)
+		{
+			var info = GetOrCreateShaderVariantInfo(assetPath, shaderName);
+			ShaderVariantElement element = new ShaderVariantElement();
+			element.PassType = passType;
+			element.Keywords = keywords;
+			info.ShaderVariantElements.Add(element);
+		}
+		private ShaderVariantInfo GetOrCreateShaderVariantInfo(string assetPath, string shaderName)
+		{
+			var selectList = ShaderVariantInfos.Where(t => t.ShaderName == shaderName && t.AssetPath == assetPath).ToList();
+			if (selectList.Count == 0)
+			{
+				ShaderVariantInfo newInfo = new ShaderVariantInfo();
+				newInfo.AssetPath = assetPath;
+				newInfo.ShaderName = shaderName;
+				ShaderVariantInfos.Add(newInfo);
+				return newInfo;
+			}
+
+			if (selectList.Count != 1)
+				throw new Exception("Should never get here !");
+
+			return selectList[0];
+		}
+
+
+		/// <summary>
+		/// 解析SVC文件并将数据写入到清单
+		/// </summary>
+		public static ShaderVariantCollectionManifest Extract(ShaderVariantCollection svc)
+		{
+			var manifest = new ShaderVariantCollectionManifest();
+			manifest.ShaderTotalCount = ShaderVariantCollectionHelper.GetCurrentShaderVariantCollectionShaderCount();
+			manifest.VariantTotalCount = ShaderVariantCollectionHelper.GetCurrentShaderVariantCollectionVariantCount();
+
+			using (var so = new SerializedObject(svc))
+			{
+				var shaderArray = so.FindProperty("m_Shaders.Array");
+				if (shaderArray != null && shaderArray.isArray)
+				{
+					for (int i = 0; i < shaderArray.arraySize; ++i)
+					{
+						var shaderRef = shaderArray.FindPropertyRelative($"data[{i}].first");
+						var shaderVariantsArray = shaderArray.FindPropertyRelative($"data[{i}].second.variants");
+						if (shaderRef != null && shaderRef.propertyType == SerializedPropertyType.ObjectReference && shaderVariantsArray != null && shaderVariantsArray.isArray)
+						{
+							var shader = shaderRef.objectReferenceValue as Shader;
+							if (shader == null)
+							{
+								throw new Exception("Invalid shader in ShaderVariantCollection file.");
+							}
+
+							string shaderAssetPath = AssetDatabase.GetAssetPath(shader);
+							string shaderName = shader.name;
+
+							// 添加变种信息
+							for (int j = 0; j < shaderVariantsArray.arraySize; ++j)
+							{
+								var propKeywords = shaderVariantsArray.FindPropertyRelative($"Array.data[{j}].keywords");
+								var propPassType = shaderVariantsArray.FindPropertyRelative($"Array.data[{j}].passType");
+								if (propKeywords != null && propPassType != null && propKeywords.propertyType == SerializedPropertyType.String)
+								{
+									string[] keywords = propKeywords.stringValue.Split(' ');
+									PassType pathType = (PassType)propPassType.intValue;
+									manifest.AddShaderVariant(shaderAssetPath, shaderName, pathType, keywords);
+								}
+							}
+						}
+					}
+				}
+			}
+
+			return manifest;
+		}
+	}
+}

Assets/YooAsset/Editor/ShaderVariantCollector/ShaderVariantCollectionManifest.cs.meta

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