Update CHANGELOG.md

support to cancel download operation

.gitignore

@@ -10,8 +10,23 @@
 /[Ll]ogs/
 /[Mm]emoryCaptures/
 
+
+
+/Bundles/
+/ProjectSettings/
+/App/
+/yoo/ 
+/Assets/StreamingAssets
+/Assets/StreamingAssets.meta
+/Assets/Samples
+/Assets/Samples.meta
+/Packages
+/UserSettings
+
+
+
 # Asset meta data should only be ignored when the corresponding asset is also ignored
-!/[Aa]ssets/**/*.meta
+
 
 # Uncomment this line if you wish to ignore the asset store tools plugin
 # /[Aa]ssets/AssetStoreTools*

Assets/YooAsset/CHANGELOG.md

@@ -2,970 +2,6 @@
 
 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
-
-- 修复了YooAssets.GetAssetInfos(string Tag)方法返回了无关的资源信息的问题。
-
-### Changed
-
-- 编辑器下的模拟运行模式，不再依赖配置里的构建版本。
-- 更新资源清单结构，资源对象类增加分类标签。
-- 优化了资源工具相关配置文件的加载方式和途径，这些配置文件可以放置在任何目录下。
-- 优化了Location无效后的错误报告方式。
-- 优化了资源包的构建参数，现在始终开启DisableLoadAssetByFileName，帮助减小运行时的内存。
-- YooAssets.ProcessOperation()重命名为YooAssets.StartOperation()
-
-### Added
-
-- 新增YooAssets.IsNeedDownloadFromRemote()方法。
-
-  ````c#
-  public static bool IsNeedDownloadFromRemote(string location);
-  ````
-
-- 新增获取所有子资源对象的方法。
-
-  ````c#
-  class SubAssetsOperationHandle
-  {
-      public TObject[] GetSubAssetObjects<TObject>();
-  }
-  ````
-
-### Removed
-
-- YooAssets.GetBundleInfo()方法已经移除。
-
-## [1.0.8] - 2022-05-08
-
-### Fixed
-
-- 修复了资源收集器导出配置文件时没有导出公共设置。
-- 修复了不兼容Unity2018版本的错误。
-
-### Changed
-
-- AssetBundleGrouper窗口变更为AssetBundleCollector窗口。
-- **优化了编辑器下模拟运行的初始化速度**。
-- **优化了资源收集窗口打开时卡顿的问题**。
-- 资源收集XML配表支持版本兼容。
-- 资源报告查看窗口支持预览AssetBundle文件内容的功能。
-- 完善了对UniTask的支持。
-- YooAssets所有接口支持初始化容错检测。
-
-### Added
-
-- 异步操作类增加进度查询字段。
-
-  ```c#
-  class AsyncOperationBase
-  {
-      /// <summary>
-      /// 处理进度
-      /// </summary>
-      public float Progress { get; protected set; } 
-  }
-  ```
-
-- 增加开启异步操作的方法。
-
-  ```c#
-  /// <summary>
-  /// 开启一个异步操作
-  /// </summary>
-  /// <param name="operation">异步操作对象</param>
-  public static void ProcessOperaiton(GameAsyncOperation operation)
-  ```
-
-- 新增编辑器下模拟模式的初始化参数。
-
-  ````c#
-  /// <summary>
-  /// 用于模拟运行的资源清单路径
-  /// 注意：如果路径为空，会自动重新构建补丁清单。
-  /// </summary>
-  public string SimulatePatchManifestPath;
-  ````
-
-- 新增通用的初始化参数。
-
-  ```c#
-  /// <summary>
-  /// 资源定位地址大小写不敏感
-  /// </summary>
-  public bool LocationToLower = false;
-  ```
-
-## [1.0.7] - 2022-05-04
-
-### Fixed
-
-- 修复了异步操作系统的Task再次等待无效的问题。
-
-### Changed
-
-- YooAssets.LoadRawFileAsync()方法重新命名为YooAssets.GetRawFileAsync()
-- YooAssetSetting文件夹支持了全路径搜索定位。
-- 优化了打包的核心逻辑，对依赖资源进行自动划分，以及支持设置依赖资源收集器。
-- 初始化的时候，删除验证失败的资源文件。
-- 构建报告浏览窗口支持排序功能。
-- 着色器变种收集工具支持了配置缓存。
-
-### Added
-
-- 支持可寻址资源定位系统，包括编辑器和运行时环境。
-- 增加快速构建模式，用于EditorPlayMode完美模拟线上环境。
-- 增加了Window Dock功能，已打开的界面会自动停靠在一个窗体下。
-- 增加一个新的打包规则：PackTopDirectory。
-- 增加获取资源信息的方法。
-  ```c#
-  public static AssetInfo[] GetAssetInfos(string tag)
-  ```
-- 增加补丁下载器下载全部资源的方法。
-  ```c#
-  public static PatchDownloaderOperation CreatePatchDownloader(int downloadingMaxNumber, int failedTryAgain)
-  ```
-- 增加指定资源版本的资源更新下载方法。
-  ```c#
-  public static UpdatePackageOperation UpdatePackageAsync(int resourceVersion, int timeout = 60)
-  ```
-
-### Removed
-
-- 移除了自动释放资源的初始化参数。
-
-## [1.0.6] - 2022-04-26
-
-### Fixed
-
-- 修复工具界面显示异常在Unity2021版本下。
-
-### Changed
-
-- 操作句柄支持错误信息查询。
-- 支持UniTask异步操作库。
-- 优化类型搜索方式，改为全域搜索类型。
-- AssetBundleGrouper窗口添加和移除Grouper支持操作回退。
-
-## [1.0.5] - 2022-04-22
-
-### Fixed
-
-- 修复了非主动收集的着色器没有打进统一的着色器资源包的问题。
-- 修复了单个收集的资源对象没有设置依赖资源列表的问题。
-- 修复Task异步加载一直等待的问题。
-
-### Changed
-
-- 资源打包的过滤文件列表增加cginc格式。
-- 增加编辑器扩展的支持，第三方实现YooAsset插件。
-- 优化原生文件加载逻辑，支持离线运行模式和编辑器运行模式。
-- 优化场景卸载逻辑，在加载新的主场景的时候自动卸载已经加载的所有场景。
-- 支持演练构建模式，在不生成资源包的情况下快速构建查看结果。
-- 新增调试信息，出生场景和出生时间。
-
-## [1.0.4] - 2022-04-18
-
-### Fixed
-
-- 修复资源清单附加版本之后引发的一个流程错误。
-- 修复原生文件拷贝目录不存导致的加载失败。
-
-### Changed
-
-- 在编辑器下检测资源路径是否合法并警告。
-- 完善原生文件异步加载接口。
-
-## [1.0.3] - 2022-04-14
-
-### Fixed
-
-- 修复了AssetBundleDebugger窗口的BundleView视口下，Using列表显示不完整的问题。
-- 修复了AssetBundleDebugger窗口的BundleView视口下，Bundle列表内元素重复的问题。
-- 修复了特殊情况下依赖的资源包列表里包含主资源包的问题。
-
-### Changed
-
-- 实例化GameObject的时候，如果没有传递坐标和角度则使用默认值。
-- 优化了资源分组配置保存策略，修改为窗口关闭时保存。
-- 简化了资源版本概念，降低学习成本，统一了CDN上的目录结构。
-- 资源定位接口扩展，方便开发可寻址资产定位功能。
-
-### Added
-
-- 离线运行模式支持WEBGL平台。
-- 保留构建窗口界面的配置数据。
-
-## [1.0.2] - 2022-04-07
-
-### Fixed
-
-- 修复在资源加载完成回调内释放自身资源句柄时的异常报错。
-- 修复了资源分组在特殊情况下打包报错的问题。
-
-### Changed
-
-- StreamingAssets目录下增加了用于存放打包资源的总文件夹。
-
-## [1.0.1] - 2022-04-07
-
-### Fixed
-
-- 修复Assets目录下存在多个YooAsset同名文件夹时，工具窗口无法显示的问题。
-- 修复通过Packages导入YooAsset，工具窗口无法显示的问题。
-
-## [1.0.0] - 2022-04-05
-*Compatible with Unity 2019.4*
+## [2.0.0-preview] - 2023-10-07
 
+This is the preview version.

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilder.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Reflection;
+using System.Linq;
 using UnityEngine;
 using UnityEditor;
 
@@ -11,94 +13,43 @@ namespace YooAsset.Editor
 		private readonly BuildContext _buildContext = new BuildContext();
 
 		/// <summary>
-		/// 开始构建
+		/// 构建资源包
 		/// </summary>
-		public BuildResult Run(BuildParameters buildParameters)
+		public BuildResult Run(BuildParameters buildParameters, List<IBuildTask> buildPipeline, bool enableLog)
 		{
-			// 清空旧数据
-			_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 (buildPipeline.Count == 0)
+				throw new Exception($"Build pipeline is empty !");	
 
-				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 !");
-			}
+			// 清空旧数据
+			_buildContext.ClearAllContext();
 
 			// 构建参数
 			var buildParametersContext = new BuildParametersContext(buildParameters);
 			_buildContext.SetContextObject(buildParametersContext);
 
-			// 是否显示LOG
-			if (buildParameters.BuildMode == EBuildMode.SimulateBuild)
-				BuildLogger.EnableLog = false;
-			else
-				BuildLogger.EnableLog = true;
-
-			// 创建构建节点
-			List<IBuildTask> pipeline;
-			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();
-			}
+			// 初始化日志
+			BuildLogger.InitLogger(enableLog);
 
 			// 执行构建流程
-			var buildResult = BuildRunner.Run(pipeline, _buildContext);
+			Debug.Log($"Begin to build package : {buildParameters.PackageName} by {buildParameters.BuildPipeline}");
+			var buildResult = BuildRunner.Run(buildPipeline, _buildContext);
 			if (buildResult.Success)
 			{
 				buildResult.OutputPackageDirectory = buildParametersContext.GetPackageOutputDirectory();
-				Debug.Log($"{buildParameters.BuildMode} pipeline build succeed !");
+				BuildLogger.Log($"{buildParameters.BuildMode} pipeline build succeed !");
 			}
 			else
 			{
-				Debug.LogWarning($"{buildParameters.BuildMode} pipeline build failed !");
-				Debug.LogError($"Build task failed : {buildResult.FailedTask}");
-				Debug.LogError($"Build task error : {buildResult.FailedInfo}");
+				BuildLogger.Warning($"{buildParameters.BuildMode} pipeline build failed !");
+				BuildLogger.Error($"Build task failed : {buildResult.FailedTask}");
+				BuildLogger.Error(buildResult.ErrorInfo);
 			}
+
 			return buildResult;
 		}
 	}

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderHelper.cs

@@ -11,7 +11,7 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 获取默认的输出根路录
 		/// </summary>
-		public static string GetDefaultOutputRoot()
+		public static string GetDefaultBuildOutputRoot()
 		{
 			string projectPath = EditorTools.GetProjectPath();
 			return $"{projectPath}/Bundles";
@@ -20,52 +20,9 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 获取流文件夹路径
 		/// </summary>
-		public static string GetStreamingAssetsFolderPath()
+		public static string GetStreamingAssetsRoot()
 		{
-			return $"{Application.dataPath}/StreamingAssets/{YooAssetSettings.StreamingAssetsBuildinFolder}/";
-		}
-
-		/// <summary>
-		/// 清空流文件夹
-		/// </summary>
-		public static void ClearStreamingAssetsFolder()
-		{
-			string streamingFolderPath = GetStreamingAssetsFolderPath();
-			EditorTools.ClearFolder(streamingFolderPath);
-		}
-
-		/// <summary>
-		/// 删除流文件夹内无关的文件
-		/// 删除.manifest文件和.meta文件
-		/// </summary>
-		public static void DeleteStreamingAssetsIgnoreFiles()
-		{
-			string streamingFolderPath = GetStreamingAssetsFolderPath();
-			if (Directory.Exists(streamingFolderPath))
-			{
-				string[] files = Directory.GetFiles(streamingFolderPath, "*.manifest", SearchOption.AllDirectories);
-				foreach (var file in files)
-				{
-					FileInfo info = new FileInfo(file);
-					info.Delete();
-				}
-
-				files = Directory.GetFiles(streamingFolderPath, "*.meta", SearchOption.AllDirectories);
-				foreach (var item in files)
-				{
-					FileInfo info = new FileInfo(item);
-					info.Delete();
-				}
-			}
-		}
-
-		/// <summary>
-		/// 获取构建管线的输出目录
-		/// </summary>
-		public static string MakePipelineOutputDirectory(string outputRoot, string buildPackage, BuildTarget buildTarget, EBuildMode buildMode)
-		{
-			string outputDirectory = $"{outputRoot}/{buildPackage}/{buildTarget}/{YooAssetSettings.OutputFolderName}";
-			return outputDirectory;
+			return $"{Application.dataPath}/StreamingAssets/{YooAssetSettingsData.Setting.DefaultYooFolderName}/";
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderSetting.cs

@@ -1,48 +1,93 @@
 using System;
 using UnityEngine;
+using UnityEditor;
 
 namespace YooAsset.Editor
 {
-	public class AssetBundleBuilderSetting : ScriptableObject
+	public static class AssetBundleBuilderSetting
 	{
-		/// <summary>
-		/// 构建管线
-		/// </summary>
-		public EBuildPipeline BuildPipeline = EBuildPipeline.BuiltinBuildPipeline;
+		// EBuildPipeline
+		public static EBuildPipeline GetPackageBuildPipeline(string packageName)
+		{
+			string key = $"{Application.productName}_{packageName}_{nameof(EBuildPipeline)}";
+			return (EBuildPipeline)EditorPrefs.GetInt(key, (int)EBuildPipeline.BuiltinBuildPipeline);
+		}
+		public static void SetPackageBuildPipeline(string packageName, EBuildPipeline buildPipeline)
+		{
+			string key = $"{Application.productName}_{packageName}_{nameof(EBuildPipeline)}";
+			EditorPrefs.SetInt(key, (int)buildPipeline);
+		}
 
-		/// <summary>
-		/// 构建模式
-		/// </summary>
-		public EBuildMode BuildMode = EBuildMode.ForceRebuild;
+		// EBuildMode
+		public static EBuildMode GetPackageBuildMode(string packageName, EBuildPipeline buildPipeline)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_{nameof(EBuildMode)}";
+			return (EBuildMode)EditorPrefs.GetInt(key, (int)EBuildMode.ForceRebuild);
+		}
+		public static void SetPackageBuildMode(string packageName, EBuildPipeline buildPipeline, EBuildMode buildMode)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_{nameof(EBuildMode)}";
+			EditorPrefs.SetInt(key, (int)buildMode);
+		}
 
-		/// <summary>
-		/// 构建的包裹名称
-		/// </summary>
-		public string BuildPackage = string.Empty;
+		// ECompressOption
+		public static ECompressOption GetPackageCompressOption(string packageName, EBuildPipeline buildPipeline)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_{nameof(ECompressOption)}";
+			return (ECompressOption)EditorPrefs.GetInt(key, (int)ECompressOption.LZ4);
+		}
+		public static void SetPackageCompressOption(string packageName, EBuildPipeline buildPipeline, ECompressOption compressOption)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_{nameof(ECompressOption)}";
+			EditorPrefs.SetInt(key, (int)compressOption);
+		}
 
-		/// <summary>
-		/// 压缩方式
-		/// </summary>
-		public ECompressOption CompressOption = ECompressOption.LZ4;
+		// EFileNameStyle
+		public static EFileNameStyle GetPackageFileNameStyle(string packageName, EBuildPipeline buildPipeline)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_{nameof(EFileNameStyle)}";
+			return (EFileNameStyle)EditorPrefs.GetInt(key, (int)EFileNameStyle.HashName);
+		}
+		public static void SetPackageFileNameStyle(string packageName, EBuildPipeline buildPipeline, EFileNameStyle fileNameStyle)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_{nameof(EFileNameStyle)}";
+			EditorPrefs.SetInt(key, (int)fileNameStyle);
+		}
 
-		/// <summary>
-		/// 输出文件名称样式
-		/// </summary>
-		public EOutputNameStyle OutputNameStyle = EOutputNameStyle.HashName;
+		// EBuildinFileCopyOption
+		public static EBuildinFileCopyOption GetPackageBuildinFileCopyOption(string packageName, EBuildPipeline buildPipeline)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_{nameof(EBuildinFileCopyOption)}";
+			return (EBuildinFileCopyOption)EditorPrefs.GetInt(key, (int)EBuildinFileCopyOption.None);
+		}
+		public static void SetPackageBuildinFileCopyOption(string packageName, EBuildPipeline buildPipeline, EBuildinFileCopyOption buildinFileCopyOption)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_{nameof(EBuildinFileCopyOption)}";
+			EditorPrefs.SetInt(key, (int)buildinFileCopyOption);
+		}
 
-		/// <summary>
-		/// 首包资源文件的拷贝方式
-		/// </summary>
-		public ECopyBuildinFileOption CopyBuildinFileOption = ECopyBuildinFileOption.None;
+		// BuildFileCopyParams
+		public static string GetPackageBuildinFileCopyParams(string packageName, EBuildPipeline buildPipeline)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_BuildFileCopyParams";
+			return EditorPrefs.GetString(key, string.Empty);
+		}
+		public static void SetPackageBuildinFileCopyParams(string packageName, EBuildPipeline buildPipeline, string buildinFileCopyParams)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_BuildFileCopyParams";
+			EditorPrefs.SetString(key, buildinFileCopyParams);
+		}
 
-		/// <summary>
-		/// 首包资源文件的标签集合
-		/// </summary>
-		public string CopyBuildinFileTags = string.Empty;
-
-		/// <summary>
-		/// 加密类名称
-		/// </summary>
-		public string EncyptionClassName = string.Empty;
+		// EncyptionClassName
+		public static string GetPackageEncyptionClassName(string packageName, EBuildPipeline buildPipeline)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_EncyptionClassName";
+			return EditorPrefs.GetString(key, string.Empty);
+		}
+		public static void SetPackageEncyptionClassName(string packageName, EBuildPipeline buildPipeline, string encyptionClassName)
+		{
+			string key = $"{Application.productName}_{packageName}_{buildPipeline}_EncyptionClassName";
+			EditorPrefs.SetString(key, encyptionClassName);
+		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderSettingData.cs

@@ -1,49 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using UnityEditor;
-
-namespace YooAsset.Editor
-{
-	public class AssetBundleBuilderSettingData
-	{
-		private static AssetBundleBuilderSetting _setting = null;
-		public static AssetBundleBuilderSetting Setting
-		{
-			get
-			{
-				if (_setting == null)
-					LoadSettingData();
-				return _setting;
-			}
-		}
-
-		/// <summary>
-		/// 配置数据是否被修改
-		/// </summary>
-		public static bool IsDirty { set; get; } = false;
-
-		/// <summary>
-		/// 加载配置文件
-		/// </summary>
-		private static void LoadSettingData()
-		{
-			_setting = EditorHelper.LoadSettingData<AssetBundleBuilderSetting>();
-		}
-
-		/// <summary>
-		/// 存储文件
-		/// </summary>
-		public static void SaveFile()
-		{
-			if (Setting != null)
-			{
-				IsDirty = false;
-				EditorUtility.SetDirty(Setting);
-				AssetDatabase.SaveAssets();
-				Debug.Log($"{nameof(AssetBundleBuilderSetting)}.asset is saved!");
-			}
-		}
-	}
-}

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderTools.cs

@@ -1,215 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using UnityEditor;
-using UnityEditor.Animations;
-
-namespace YooAsset.Editor
-{
-	public static class AssetBundleBuilderTools
-	{
-		/// <summary>
-		/// 检测所有损坏的预制体文件
-		/// </summary>
-		public static void CheckCorruptionPrefab(List<string> searchDirectorys)
-		{
-			if (searchDirectorys.Count == 0)
-				throw new Exception("路径列表不能为空！");
-
-			// 获取所有资源列表
-			int checkCount = 0;
-			int invalidCount = 0;
-			string[] findAssets = EditorTools.FindAssets(EAssetSearchType.Prefab, searchDirectorys.ToArray());
-			foreach (string assetPath in findAssets)
-			{
-				UnityEngine.Object prefab = AssetDatabase.LoadAssetAtPath(assetPath, typeof(UnityEngine.Object));
-				if (prefab == null)
-				{
-					invalidCount++;
-					Debug.LogError($"发现损坏预制件：{assetPath}");
-				}
-				EditorTools.DisplayProgressBar("检测预制件文件是否损坏", ++checkCount, findAssets.Length);
-			}
-			EditorTools.ClearProgressBar();
-
-			if (invalidCount == 0)
-				Debug.Log($"没有发现损坏预制件");
-		}
-
-		/// <summary>
-		/// 检测所有动画控制器的冗余状态
-		/// </summary>
-		public static void FindRedundantAnimationState(List<string> searchDirectorys)
-		{
-			if (searchDirectorys.Count == 0)
-				throw new Exception("路径列表不能为空！");
-
-			// 获取所有资源列表
-			int checkCount = 0;
-			int findCount = 0;
-			string[] findAssets = EditorTools.FindAssets(EAssetSearchType.RuntimeAnimatorController, searchDirectorys.ToArray());
-			foreach (string assetPath in findAssets)
-			{
-				AnimatorController animator= AssetDatabase.LoadAssetAtPath<AnimatorController>(assetPath);
-				if (FindRedundantAnimationState(animator))
-				{
-					findCount++;
-					Debug.LogWarning($"发现冗余的动画控制器：{assetPath}");
-				}
-				EditorTools.DisplayProgressBar("检测冗余的动画控制器", ++checkCount, findAssets.Length);
-			}
-			EditorTools.ClearProgressBar();
-
-			if (findCount == 0)
-				Debug.Log($"没有发现冗余的动画控制器");
-			else
-				AssetDatabase.SaveAssets();
-		}
-
-		/// <summary>
-		/// 清理所有材质球的冗余属性
-		/// </summary>
-		public static void ClearMaterialUnusedProperty(List<string> searchDirectorys)
-		{
-			if (searchDirectorys.Count == 0)
-				throw new Exception("路径列表不能为空！");
-
-			// 获取所有资源列表
-			int checkCount = 0;
-			int removedCount = 0;
-			string[] findAssets = EditorTools.FindAssets(EAssetSearchType.Material, searchDirectorys.ToArray());
-			foreach (string assetPath in findAssets)
-			{
-				Material mat = AssetDatabase.LoadAssetAtPath<Material>(assetPath);
-				if (ClearMaterialUnusedProperty(mat))
-				{
-					removedCount++;
-					Debug.LogWarning($"材质球已被处理：{assetPath}");
-				}
-				EditorTools.DisplayProgressBar("清理冗余的材质球", ++checkCount, findAssets.Length);
-			}
-			EditorTools.ClearProgressBar();
-
-			if (removedCount == 0)
-				Debug.Log($"没有发现冗余的材质球");
-			else
-				AssetDatabase.SaveAssets();
-		}
-
-
-		/// <summary>
-		/// 清理无用的材质球属性
-		/// </summary>
-		private static bool ClearMaterialUnusedProperty(Material mat)
-		{
-			bool removeUnused = false;
-			SerializedObject so = new SerializedObject(mat);
-			SerializedProperty sp = so.FindProperty("m_SavedProperties");
-
-			sp.Next(true);
-			do
-			{
-				if (sp.isArray == false)
-					continue;
-
-				for (int i = sp.arraySize - 1; i >= 0; --i)
-				{
-					var p1 = sp.GetArrayElementAtIndex(i);
-					if (p1.isArray)
-					{
-						for (int ii = p1.arraySize - 1; ii >= 0; --ii)
-						{
-							var p2 = p1.GetArrayElementAtIndex(ii);
-							var val = p2.FindPropertyRelative("first");
-							if (mat.HasProperty(val.stringValue) == false)
-							{
-								Debug.Log($"Material {mat.name} remove unused property : {val.stringValue}");
-								p1.DeleteArrayElementAtIndex(ii);
-								removeUnused = true;
-							}
-						}
-					}
-					else
-					{
-						var val = p1.FindPropertyRelative("first");
-						if (mat.HasProperty(val.stringValue) == false)
-						{
-							Debug.Log($"Material {mat.name} remove unused property : {val.stringValue}");
-							sp.DeleteArrayElementAtIndex(i);
-							removeUnused = true;
-						}
-					}
-				}
-			}
-			while (sp.Next(false));
-			so.ApplyModifiedProperties();
-			return removeUnused;
-		}
-
-		/// <summary>
-		/// 查找动画控制器里冗余的动画状态机
-		/// </summary>
-		private static bool FindRedundantAnimationState(AnimatorController animatorController)
-		{
-			if (animatorController == null)
-				return false;
-
-			string assetPath = AssetDatabase.GetAssetPath(animatorController);
-
-			// 查找使用的状态机名称
-			List<string> usedStateNames = new List<string>();
-			foreach (var layer in animatorController.layers)
-			{
-				foreach (var state in layer.stateMachine.states)
-				{
-					usedStateNames.Add(state.state.name);
-				}
-			}
-
-			List<string> allLines = new List<string>();
-			List<int> stateIndexList = new List<int>();
-			using (StreamReader reader = File.OpenText(assetPath))
-			{
-				string content;
-				while (null != (content = reader.ReadLine()))
-				{
-					allLines.Add(content);
-					if (content.StartsWith("AnimatorState:"))
-					{
-						stateIndexList.Add(allLines.Count - 1);
-					}
-				}
-			}
-
-			List<string> allStateNames = new List<string>();
-			foreach (var index in stateIndexList)
-			{
-				for (int i = index; i < allLines.Count; i++)
-				{
-					string content = allLines[i];
-					content = content.Trim();
-					if (content.StartsWith("m_Name"))
-					{
-						string[] splits = content.Split(':');
-						string name = splits[1].TrimStart(' '); //移除前面的空格
-						allStateNames.Add(name);
-						break;
-					}
-				}
-			}
-
-			bool foundRedundantState = false;
-			foreach (var stateName in allStateNames)
-			{
-				if (usedStateNames.Contains(stateName) == false)
-				{
-					Debug.LogWarning($"发现冗余的动画文件:{assetPath}={stateName}");
-					foundRedundantState = true;
-				}
-			}
-			return foundRedundantState;
-		}
-	}
-}

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderWindow.cs

@@ -12,28 +12,20 @@ namespace YooAsset.Editor
 	public class AssetBundleBuilderWindow : EditorWindow
 	{
 		[MenuItem("YooAsset/AssetBundle Builder", false, 102)]
-		public static void ShowExample()
+		public static void OpenWindow()
 		{
-			AssetBundleBuilderWindow window = GetWindow<AssetBundleBuilderWindow>("资源包构建工具", true, EditorDefine.DockedWindowTypes);
+			AssetBundleBuilderWindow window = GetWindow<AssetBundleBuilderWindow>("资源包构建工具", true, WindowsDefine.DockedWindowTypes);
 			window.minSize = new Vector2(800, 600);
 		}
 
-		private BuildTarget _buildTarget;
-		private List<Type> _encryptionServicesClassTypes;
-		private List<string> _encryptionServicesClassNames;
-		private List<string> _buildPackageNames;
+		private string _buildPackage;
+		private EBuildPipeline _buildPipeline;
+
+		private Toolbar _toolbar;
+		private ToolbarMenu _packageMenu;
+		private ToolbarMenu _pipelineMenu;
+		private VisualElement _container;
 
-		private Button _saveButton;
-		private TextField _buildOutputField;
-		private EnumField _buildPipelineField;
-		private EnumField _buildModeField;
-		private TextField _buildVersionField;
-		private PopupField<string> _buildPackageField;
-		private PopupField<string> _encryptionField;
-		private EnumField _compressionField;
-		private EnumField _outputNameStyleField;
-		private EnumField _copyBuildinFileOptionField;
-		private TextField _copyBuildinFileTagsField;
 
 		public void CreateGUI()
 		{
@@ -42,280 +34,81 @@ namespace YooAsset.Editor
 				VisualElement root = this.rootVisualElement;
 
 				// 加载布局文件
-				var visualAsset = EditorHelper.LoadWindowUXML<AssetBundleBuilderWindow>();
+				var visualAsset = UxmlLoader.LoadWindowUXML<AssetBundleBuilderWindow>();
 				if (visualAsset == null)
 					return;
 
 				visualAsset.CloneTree(root);
+				_toolbar = root.Q<Toolbar>("Toolbar");
+				_container = root.Q("Container");
 
-				// 配置保存按钮
-				_saveButton = root.Q<Button>("SaveButton");
-				_saveButton.clicked += SaveBtn_clicked;
-
-				// 构建平台
-				_buildTarget = EditorUserBuildSettings.activeBuildTarget;
-
-				// 包裹名称列表
-				_buildPackageNames = GetBuildPackageNames();
-
-				// 加密服务类
-				_encryptionServicesClassTypes = GetEncryptionServicesClassTypes();
-				_encryptionServicesClassNames = _encryptionServicesClassTypes.Select(t => t.Name).ToList();
-
-				// 输出目录
-				string defaultOutputRoot = AssetBundleBuilderHelper.GetDefaultOutputRoot();
-				_buildOutputField = root.Q<TextField>("BuildOutput");
-				_buildOutputField.SetValueWithoutNotify(defaultOutputRoot);
-				_buildOutputField.SetEnabled(false);
-
-				// 构建管线
-				_buildPipelineField = root.Q<EnumField>("BuildPipeline");
-				_buildPipelineField.Init(AssetBundleBuilderSettingData.Setting.BuildPipeline);
-				_buildPipelineField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.BuildPipeline);
-				_buildPipelineField.style.width = 350;
-				_buildPipelineField.RegisterValueChangedCallback(evt =>
+				// 检测构建包裹
+				var packageNames = GetBuildPackageNames();
+				if (packageNames.Count == 0)
 				{
-					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 = 350;
-				_buildModeField.RegisterValueChangedCallback(evt =>
-				{
-					AssetBundleBuilderSettingData.IsDirty = true;
-					AssetBundleBuilderSettingData.Setting.BuildMode = (EBuildMode)_buildModeField.value;
-					RefreshWindow();
-				});
-
-				// 构建版本
-				_buildVersionField = root.Q<TextField>("BuildVersion");
-				_buildVersionField.SetValueWithoutNotify(GetBuildPackageVersion());
+					var label = new Label();
+					label.text = "没有发现可构建的资源包";
+					label.style.width = 100;
+					_toolbar.Add(label);
+					return;
+				}
 
 				// 构建包裹
-				var buildPackageContainer = root.Q("BuildPackageContainer");
-				if (_buildPackageNames.Count > 0)
 				{
-					int defaultIndex = GetDefaultPackageIndex(AssetBundleBuilderSettingData.Setting.BuildPackage);
-					_buildPackageField = new PopupField<string>(_buildPackageNames, defaultIndex);
-					_buildPackageField.label = "Build Package";
-					_buildPackageField.style.width = 350;
-					_buildPackageField.RegisterValueChangedCallback(evt =>
+					_buildPackage = packageNames[0];
+					_packageMenu = new ToolbarMenu();
+					_packageMenu.style.width = 200;
+					foreach (var packageName in packageNames)
 					{
-						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);
+						_packageMenu.menu.AppendAction(packageName, PackageMenuAction, PackageMenuFun, packageName);
+					}
+					_toolbar.Add(_packageMenu);
 				}
 
-				// 加密方法
-				var encryptionContainer = root.Q("EncryptionContainer");
-				if (_encryptionServicesClassNames.Count > 0)
+				// 构建管线
 				{
-					int defaultIndex = GetDefaultEncryptionIndex(AssetBundleBuilderSettingData.Setting.EncyptionClassName);
-					_encryptionField = new PopupField<string>(_encryptionServicesClassNames, defaultIndex);
-					_encryptionField.label = "Encryption";
-					_encryptionField.style.width = 350;
-					_encryptionField.RegisterValueChangedCallback(evt =>
-					{
-						AssetBundleBuilderSettingData.IsDirty = true;
-						AssetBundleBuilderSettingData.Setting.EncyptionClassName = _encryptionField.value;
-					});
-					encryptionContainer.Add(_encryptionField);
-				}
-				else
-				{
-					_encryptionField = new PopupField<string>();
-					_encryptionField.label = "Encryption";
-					_encryptionField.style.width = 350;
-					encryptionContainer.Add(_encryptionField);
+					_pipelineMenu = new ToolbarMenu();
+					_pipelineMenu.style.width = 200;
+					_pipelineMenu.menu.AppendAction(EBuildPipeline.BuiltinBuildPipeline.ToString(), PipelineMenuAction, PipelineMenuFun, EBuildPipeline.BuiltinBuildPipeline);
+					_pipelineMenu.menu.AppendAction(EBuildPipeline.ScriptableBuildPipeline.ToString(), PipelineMenuAction, PipelineMenuFun, EBuildPipeline.ScriptableBuildPipeline);
+					_pipelineMenu.menu.AppendAction(EBuildPipeline.RawFileBuildPipeline.ToString(), PipelineMenuAction, PipelineMenuFun, EBuildPipeline.RawFileBuildPipeline);
+					_toolbar.Add(_pipelineMenu);
 				}
 
-				// 压缩方式选项
-				_compressionField = root.Q<EnumField>("Compression");
-				_compressionField.Init(AssetBundleBuilderSettingData.Setting.CompressOption);
-				_compressionField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.CompressOption);
-				_compressionField.style.width = 350;
-				_compressionField.RegisterValueChangedCallback(evt =>
-				{
-					AssetBundleBuilderSettingData.IsDirty = true;
-					AssetBundleBuilderSettingData.Setting.CompressOption = (ECompressOption)_compressionField.value;
-				});
-
-				// 输出文件名称样式
-				_outputNameStyleField = root.Q<EnumField>("OutputNameStyle");
-				_outputNameStyleField.Init(AssetBundleBuilderSettingData.Setting.OutputNameStyle);
-				_outputNameStyleField.SetValueWithoutNotify(AssetBundleBuilderSettingData.Setting.OutputNameStyle);
-				_outputNameStyleField.style.width = 350;
-				_outputNameStyleField.RegisterValueChangedCallback(evt =>
-				{
-					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;
-				});
-
-				// 构建按钮
-				var buildButton = root.Q<Button>("Build");
-				buildButton.clicked += BuildButton_clicked; ;
-
-				RefreshWindow();
+				RefreshBuildPipelineView();
 			}
 			catch (Exception e)
 			{
 				Debug.LogError(e.ToString());
 			}
 		}
-		public void OnDestroy()
+
+		private void RefreshBuildPipelineView()
 		{
-			if (AssetBundleBuilderSettingData.IsDirty)
-				AssetBundleBuilderSettingData.SaveFile();
-		}
-		public void Update()
-		{
-			if (_saveButton != null)
+			// 清空扩展区域
+			_container.Clear();
+
+			_buildPipeline = AssetBundleBuilderSetting.GetPackageBuildPipeline(_buildPackage);
+			_packageMenu.text = _buildPackage;
+			_pipelineMenu.text = _buildPipeline.ToString();
+
+			var buildTarget = EditorUserBuildSettings.activeBuildTarget;
+			if (_buildPipeline == EBuildPipeline.BuiltinBuildPipeline)
 			{
-				if (AssetBundleBuilderSettingData.IsDirty)
-				{
-					if (_saveButton.enabledSelf == false)
-						_saveButton.SetEnabled(true);
-				}
-				else
-				{
-					if (_saveButton.enabledSelf)
-						_saveButton.SetEnabled(false);
-				}
+				var viewer = new BuiltinBuildPipelineViewer(_buildPackage, buildTarget, _container);
 			}
-		}
-
-		private void RefreshWindow()
-		{
-			var buildPipeline = AssetBundleBuilderSettingData.Setting.BuildPipeline;
-			var buildMode = AssetBundleBuilderSettingData.Setting.BuildMode;
-			var copyOption = AssetBundleBuilderSettingData.Setting.CopyBuildinFileOption;
-			bool enableElement = buildMode == EBuildMode.ForceRebuild;
-			bool tagsFiledVisible = copyOption == ECopyBuildinFileOption.ClearAndCopyByTags || copyOption == ECopyBuildinFileOption.OnlyCopyByTags;
-
-			if (buildPipeline == EBuildPipeline.BuiltinBuildPipeline)
+			else if (_buildPipeline == EBuildPipeline.ScriptableBuildPipeline)
 			{
-				_compressionField.SetEnabled(enableElement);
-				_outputNameStyleField.SetEnabled(enableElement);
-				_copyBuildinFileOptionField.SetEnabled(enableElement);
-				_copyBuildinFileTagsField.SetEnabled(enableElement);
+				var viewer = new ScriptableBuildPipelineViewer(_buildPackage, buildTarget, _container);
+			}
+			else if (_buildPipeline == EBuildPipeline.RawFileBuildPipeline)
+			{
+				var viewer = new RawfileBuildpipelineViewer(_buildPackage, buildTarget, _container);
 			}
 			else
 			{
-				_compressionField.SetEnabled(true);
-				_outputNameStyleField.SetEnabled(true);
-				_copyBuildinFileOptionField.SetEnabled(true);
-				_copyBuildinFileTagsField.SetEnabled(true);
+				throw new System.NotImplementedException(_buildPipeline.ToString());
 			}
-
-			_copyBuildinFileTagsField.visible = tagsFiledVisible;
-		}
-		private void SaveBtn_clicked()
-		{
-			AssetBundleBuilderSettingData.SaveFile();
-		}
-		private void BuildButton_clicked()
-		{
-			var buildMode = AssetBundleBuilderSettingData.Setting.BuildMode;
-			if (EditorUtility.DisplayDialog("提示", $"通过构建模式【{buildMode}】来构建！", "Yes", "No"))
-			{
-				EditorTools.ClearUnityConsole();
-				EditorApplication.delayCall += ExecuteBuild;
-			}
-			else
-			{
-				Debug.LogWarning("[Build] 打包已经取消");
-			}
-		}
-
-		/// <summary>
-		/// 执行构建
-		/// </summary>
-		private void ExecuteBuild()
-		{
-			string defaultOutputRoot = AssetBundleBuilderHelper.GetDefaultOutputRoot();
-			BuildParameters buildParameters = new BuildParameters();
-			buildParameters.OutputRoot = defaultOutputRoot;
-			buildParameters.BuildTarget = _buildTarget;
-			buildParameters.BuildPipeline = AssetBundleBuilderSettingData.Setting.BuildPipeline;
-			buildParameters.BuildMode = AssetBundleBuilderSettingData.Setting.BuildMode;
-			buildParameters.PackageName = AssetBundleBuilderSettingData.Setting.BuildPackage;
-			buildParameters.PackageVersion = _buildVersionField.value;
-			buildParameters.VerifyBuildingResult = true;
-			buildParameters.EncryptionServices = CreateEncryptionServicesInstance();
-			buildParameters.CompressOption = AssetBundleBuilderSettingData.Setting.CompressOption;
-			buildParameters.OutputNameStyle = AssetBundleBuilderSettingData.Setting.OutputNameStyle;
-			buildParameters.CopyBuildinFileOption = AssetBundleBuilderSettingData.Setting.CopyBuildinFileOption;
-			buildParameters.CopyBuildinFileTags = AssetBundleBuilderSettingData.Setting.CopyBuildinFileTags;
-
-			if (AssetBundleBuilderSettingData.Setting.BuildPipeline == EBuildPipeline.ScriptableBuildPipeline)
-			{
-				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()
 		{
@@ -327,31 +120,41 @@ namespace YooAsset.Editor
 			return result;
 		}
 
-		// 加密类相关
-		private int GetDefaultEncryptionIndex(string className)
+		private void PackageMenuAction(DropdownMenuAction action)
 		{
-			for (int index = 0; index < _encryptionServicesClassNames.Count; index++)
+			var packageName = (string)action.userData;
+			if (_buildPackage != packageName)
 			{
-				if (_encryptionServicesClassNames[index] == className)
-				{
-					return index;
-				}
+				_buildPackage = packageName;
+				RefreshBuildPipelineView();
 			}
+		}
+		private DropdownMenuAction.Status PackageMenuFun(DropdownMenuAction action)
+		{
+			var packageName = (string)action.userData;
+			if (_buildPackage == packageName)
+				return DropdownMenuAction.Status.Checked;
+			else
+				return DropdownMenuAction.Status.Normal;
+		}
 
-			AssetBundleBuilderSettingData.IsDirty = true;
-			AssetBundleBuilderSettingData.Setting.EncyptionClassName = _encryptionServicesClassNames[0];
-			return 0;
-		}
-		private List<Type> GetEncryptionServicesClassTypes()
+		private void PipelineMenuAction(DropdownMenuAction action)
 		{
-			return EditorTools.GetAssignableTypes(typeof(IEncryptionServices));
+			var pipelineType = (EBuildPipeline)action.userData;
+			if (_buildPipeline != pipelineType)
+			{
+				_buildPipeline = pipelineType;
+				AssetBundleBuilderSetting.SetPackageBuildPipeline(_buildPackage, pipelineType);
+				RefreshBuildPipelineView();
+			}
 		}
-		private IEncryptionServices CreateEncryptionServicesInstance()
+		private DropdownMenuAction.Status PipelineMenuFun(DropdownMenuAction action)
 		{
-			if (_encryptionField.index < 0)
-				return null;
-			var classType = _encryptionServicesClassTypes[_encryptionField.index];
-			return (IEncryptionServices)Activator.CreateInstance(classType);
+			var pipelineType = (EBuildPipeline)action.userData;
+			if (_buildPipeline == pipelineType)
+				return DropdownMenuAction.Status.Checked;
+			else
+				return DropdownMenuAction.Status.Normal;
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderWindow.uxml

@@ -1,18 +1,4 @@
 <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
-    <uie:Toolbar name="Toolbar" style="display: flex; flex-direction: row-reverse;">
-        <ui:Button text="Save" display-tooltip-when-elided="true" name="SaveButton" style="background-color: rgb(56, 147, 58);" />
-    </uie:Toolbar>
-    <ui:VisualElement name="BuildContainer">
-        <ui:TextField picking-mode="Ignore" label="Build Output" name="BuildOutput" />
-        <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" />
-        <uie:EnumField label="Output Name Style" value="Center" name="OutputNameStyle" />
-        <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>
+    <uie:Toolbar name="Toolbar" style="display: flex; flex-direction: row;" />
+    <ui:VisualElement name="Container" />
 </ui:UXML>

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleSimulateBuilder.cs

@@ -8,28 +8,92 @@ namespace YooAsset.Editor
 		/// <summary>
 		/// 模拟构建
 		/// </summary>
-		public static string SimulateBuild(string packageName)
+		public static string SimulateBuild(string buildPipelineName, 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.PackageName = packageName;
-			buildParameters.PackageVersion = "Simulate";
-
-			AssetBundleBuilder builder = new AssetBundleBuilder();
-			var buildResult = builder.Run(buildParameters);
-			if (buildResult.Success)
+			if (buildPipelineName == EBuildPipeline.BuiltinBuildPipeline.ToString())
 			{
-				string manifestFileName = YooAssetSettingsData.GetManifestBinaryFileName(buildParameters.PackageName, buildParameters.PackageVersion);
-				string manifestFilePath = $"{buildResult.OutputPackageDirectory}/{manifestFileName}";
-				return manifestFilePath;
+				BuiltinBuildParameters buildParameters = new BuiltinBuildParameters();
+				buildParameters.BuildOutputRoot = AssetBundleBuilderHelper.GetDefaultBuildOutputRoot();
+				buildParameters.BuildinFileRoot = AssetBundleBuilderHelper.GetStreamingAssetsRoot();
+				buildParameters.BuildPipeline = buildPipelineName;
+				buildParameters.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
+				buildParameters.BuildMode = EBuildMode.SimulateBuild;
+				buildParameters.PackageName = packageName;
+				buildParameters.PackageVersion = "Simulate";
+				buildParameters.FileNameStyle = EFileNameStyle.HashName;
+				buildParameters.BuildinFileCopyOption = EBuildinFileCopyOption.None;
+				buildParameters.BuildinFileCopyParams = string.Empty;
+
+				BuiltinBuildPipeline pipeline = new BuiltinBuildPipeline();
+				var buildResult = pipeline.Run(buildParameters, false);
+				if (buildResult.Success)
+				{
+					string manifestFileName = YooAssetSettingsData.GetManifestBinaryFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+					string manifestFilePath = $"{buildResult.OutputPackageDirectory}/{manifestFileName}";
+					return manifestFilePath;
+				}
+				else
+				{
+					return null;
+				}
+			}
+			else if (buildPipelineName == EBuildPipeline.ScriptableBuildPipeline.ToString())
+			{
+				ScriptableBuildParameters buildParameters = new ScriptableBuildParameters();
+				buildParameters.BuildOutputRoot = AssetBundleBuilderHelper.GetDefaultBuildOutputRoot();
+				buildParameters.BuildinFileRoot = AssetBundleBuilderHelper.GetStreamingAssetsRoot();
+				buildParameters.BuildPipeline = buildPipelineName;
+				buildParameters.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
+				buildParameters.BuildMode = EBuildMode.SimulateBuild;
+				buildParameters.PackageName = packageName;
+				buildParameters.PackageVersion = "Simulate";
+				buildParameters.FileNameStyle = EFileNameStyle.HashName;
+				buildParameters.BuildinFileCopyOption = EBuildinFileCopyOption.None;
+				buildParameters.BuildinFileCopyParams = string.Empty;
+
+				ScriptableBuildPipeline pipeline = new ScriptableBuildPipeline();
+				var buildResult = pipeline.Run(buildParameters, true);
+				if (buildResult.Success)
+				{
+					string manifestFileName = YooAssetSettingsData.GetManifestBinaryFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+					string manifestFilePath = $"{buildResult.OutputPackageDirectory}/{manifestFileName}";
+					return manifestFilePath;
+				}
+				else
+				{
+					return null;
+				}
+			}
+			else if (buildPipelineName == EBuildPipeline.RawFileBuildPipeline.ToString())
+			{
+				RawFileBuildParameters buildParameters = new RawFileBuildParameters();
+				buildParameters.BuildOutputRoot = AssetBundleBuilderHelper.GetDefaultBuildOutputRoot();
+				buildParameters.BuildinFileRoot = AssetBundleBuilderHelper.GetStreamingAssetsRoot();
+				buildParameters.BuildPipeline = buildPipelineName;
+				buildParameters.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
+				buildParameters.BuildMode = EBuildMode.SimulateBuild;
+				buildParameters.PackageName = packageName;
+				buildParameters.PackageVersion = "Simulate";
+				buildParameters.FileNameStyle = EFileNameStyle.HashName;
+				buildParameters.BuildinFileCopyOption = EBuildinFileCopyOption.None;
+				buildParameters.BuildinFileCopyParams = string.Empty;
+
+				RawFileBuildPipeline pipeline = new RawFileBuildPipeline();
+				var buildResult = pipeline.Run(buildParameters, true);
+				if (buildResult.Success)
+				{
+					string manifestFileName = YooAssetSettingsData.GetManifestBinaryFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+					string manifestFilePath = $"{buildResult.OutputPackageDirectory}/{manifestFileName}";
+					return manifestFilePath;
+				}
+				else
+				{
+					return null;
+				}
 			}
 			else
 			{
-				return null;
+				throw new System.NotImplementedException(buildPipelineName);
 			}
 		}
 	}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildAssetInfo.cs

@@ -31,25 +31,20 @@ namespace YooAsset.Editor
 		public string AssetPath { private set; get; }
 
 		/// <summary>
-		/// 是否为原生资源
+		/// 资源GUID
 		/// </summary>
-		public bool IsRawAsset { private set; get; }
+		public string AssetGUID { private set; get; }
 
 		/// <summary>
-		/// 是否为着色器资源
+		/// 资源类型
 		/// </summary>
-		public bool IsShaderAsset { private set; get; }
+		public System.Type AssetType { private set; get; }
 
 		/// <summary>
 		/// 资源的分类标签
 		/// </summary>
 		public readonly List<string> AssetTags = new List<string>();
 
-		/// <summary>
-		/// 资源包的分类标签
-		/// </summary>
-		public readonly List<string> BundleTags = new List<string>();
-
 		/// <summary>
 		/// 依赖的所有资源
 		/// 注意：包括零依赖资源和冗余资源（资源包名无效）
@@ -57,39 +52,31 @@ namespace YooAsset.Editor
 		public List<BuildAssetInfo> AllDependAssetInfos { private set; get; }
 
 
-		public BuildAssetInfo(ECollectorType collectorType, string bundleName, string address, string assetPath, bool isRawAsset)
+		public BuildAssetInfo(ECollectorType collectorType, string bundleName, string address, string assetPath)
 		{
 			CollectorType = collectorType;
 			BundleName = bundleName;
 			Address = address;
 			AssetPath = assetPath;
-			IsRawAsset = isRawAsset;
 
-			System.Type assetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(assetPath);
-			if (assetType == typeof(UnityEngine.Shader) || assetType == typeof(UnityEngine.ShaderVariantCollection))
-				IsShaderAsset = true;
-			else
-				IsShaderAsset = false;
+			AssetGUID = UnityEditor.AssetDatabase.AssetPathToGUID(assetPath);
+			AssetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(assetPath);
 		}
 		public BuildAssetInfo(string assetPath)
 		{
 			CollectorType = ECollectorType.None;
 			Address = string.Empty;
 			AssetPath = assetPath;
-			IsRawAsset = false;
 
-			System.Type assetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(assetPath);
-			if (assetType == typeof(UnityEngine.Shader) || assetType == typeof(UnityEngine.ShaderVariantCollection))
-				IsShaderAsset = true;
-			else
-				IsShaderAsset = false;
+			AssetGUID = UnityEditor.AssetDatabase.AssetPathToGUID(assetPath);
+			AssetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(assetPath);
 		}
 
 
 		/// <summary>
 		/// 设置所有依赖的资源
 		/// </summary>
-		public void SetAllDependAssetInfos(List<BuildAssetInfo> dependAssetInfos)
+		public void SetDependAssetInfos(List<BuildAssetInfo> dependAssetInfos)
 		{
 			if (AllDependAssetInfos != null)
 				throw new System.Exception("Should never get here !");
@@ -117,18 +104,15 @@ namespace YooAsset.Editor
 		}
 
 		/// <summary>
-		/// 添加资源包的分类标签
-		/// 说明：传染算法统计到的分类标签
+		/// 添加关联的资源包名称
 		/// </summary>
-		public void AddBundleTags(List<string> tags)
+		public void AddReferenceBundleName(string bundleName)
 		{
-			foreach (var tag in tags)
-			{
-				if (BundleTags.Contains(tag) == false)
-				{
-					BundleTags.Add(tag);
-				}
-			}
+			if (string.IsNullOrEmpty(bundleName))
+				throw new Exception("Should never get here !");
+
+			if (_referenceBundleNames.Contains(bundleName) == false)
+				_referenceBundleNames.Add(bundleName);
 		}
 
 		/// <summary>
@@ -143,46 +127,22 @@ namespace YooAsset.Editor
 		}
 
 		/// <summary>
-		/// 添加关联的资源包名称
+		/// 判断是否为冗余资源
 		/// </summary>
-		public void AddReferenceBundleName(string bundleName)
+		public bool IsRedundancyAsset()
 		{
-			if (string.IsNullOrEmpty(bundleName))
-				throw new Exception("Should never get here !");
+			if (HasBundleName())
+				return false;
 
-			if (_referenceBundleNames.Contains(bundleName) == false)
-				_referenceBundleNames.Add(bundleName);
+			return _referenceBundleNames.Count > 1;
 		}
 
 		/// <summary>
-		/// 计算共享资源包的完整包名
+		/// 获取关联资源包的数量
 		/// </summary>
-		public void CalculateShareBundleName(bool uniqueBundleName, string packageName, string shadersBundleName)
+		public int GetReferenceBundleCount()
 		{
-			if (CollectorType != ECollectorType.None)
-				return;
-
-			if (IsRawAsset)
-				throw new Exception("Should never get here !");
-
-			if (IsShaderAsset)
-			{
-				BundleName = shadersBundleName;
-			}
-			else
-			{
-				if (_referenceBundleNames.Count > 1)
-				{
-					IPackRule packRule = PackDirectory.StaticPackRule;
-					PackRuleResult packRuleResult = packRule.GetPackRuleResult(new PackRuleData(AssetPath));
-					BundleName = packRuleResult.GetShareBundleName(packageName, uniqueBundleName);
-				}
-				else
-				{
-					// 注意：被引用次数小于1的资源不需要设置资源包名称
-					BundleName = string.Empty;
-				}
-			}
+			return _referenceBundleNames.Count;
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildBundleInfo.cs

@@ -8,39 +8,60 @@ namespace YooAsset.Editor
 {
 	public class BuildBundleInfo
 	{
-		public class BuildPatchInfo
-		{
-			/// <summary>
-			/// 构建内容的哈希值
-			/// </summary>
-			public string ContentHash { set; get; }
+		#region 补丁文件的关键信息
+		/// <summary>
+		/// Unity引擎生成的哈希值（构建内容的哈希值）
+		/// </summary>
+		public string PackageUnityHash { set; get; }
 
-			/// <summary>
-			/// 文件哈希值
-			/// </summary>
-			public string PatchFileHash { set; get; }
+		/// <summary>
+		/// Unity引擎生成的CRC
+		/// </summary>
+		public uint PackageUnityCRC { set; get; }
 
-			/// <summary>
-			/// 文件哈希值
-			/// </summary>
-			public string PatchFileCRC { set; get; }
+		/// <summary>
+		/// 文件哈希值
+		/// </summary>
+		public string PackageFileHash { set; get; }
 
-			/// <summary>
-			/// 文件哈希值
-			/// </summary>
-			public long PatchFileSize { set; get; }
+		/// <summary>
+		/// 文件哈希值
+		/// </summary>
+		public string PackageFileCRC { set; get; }
+
+		/// <summary>
+		/// 文件哈希值
+		/// </summary>
+		public long PackageFileSize { set; get; }
+
+		/// <summary>
+		/// 构建输出的文件路径
+		/// </summary>
+		public string BuildOutputFilePath { set; get; }
+
+		/// <summary>
+		/// 补丁包的源文件路径
+		/// </summary>
+		public string PackageSourceFilePath { set; get; }
+
+		/// <summary>
+		/// 补丁包的目标文件路径
+		/// </summary>
+		public string PackageDestFilePath { set; get; }
+
+		/// <summary>
+		/// 加密生成文件的路径
+		/// 注意：如果未加密该路径为空
+		/// </summary>
+		public string EncryptedFilePath { set; get; }
+		#endregion
 
 
-			/// <summary>
-			/// 构建输出的文件路径
-			/// </summary>
-			public string BuildOutputFilePath { set; get; }
-
-			/// <summary>
-			/// 补丁包输出文件路径
-			/// </summary>
-			public string PatchOutputFilePath { set; get; }
-		}
+		/// <summary>
+		/// 参与构建的资源列表
+		/// 注意：不包含零依赖资源和冗余资源
+		/// </summary>
+		public readonly List<BuildAssetInfo> MainAssets = new List<BuildAssetInfo>();
 
 		/// <summary>
 		/// 资源包名称
@@ -48,56 +69,9 @@ namespace YooAsset.Editor
 		public string BundleName { private set; get; }
 
 		/// <summary>
-		/// 参与构建的资源列表
-		/// 注意：不包含零依赖资源
+		/// 加密文件
 		/// </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>
-		public bool IsRawFile
-		{
-			get
-			{
-				foreach (var asset in BuildinAssets)
-				{
-					if (asset.IsRawAsset)
-						return true;
-				}
-				return false;
-			}
-		}
-
-		/// <summary>
-		/// 是否为加密文件
-		/// </summary>
-		public bool IsEncryptedFile
-		{
-			get
-			{
-				if (string.IsNullOrEmpty(EncryptedFilePath))
-					return false;
-				else
-					return true;
-			}
-		}
+		public bool Encrypted { set; get; }
 
 
 		public BuildBundleInfo(string bundleName)
@@ -113,7 +87,7 @@ namespace YooAsset.Editor
 			if (IsContainsAsset(assetInfo.AssetPath))
 				throw new System.Exception($"Asset is existed : {assetInfo.AssetPath}");
 
-			BuildinAssets.Add(assetInfo);
+			MainAssets.Add(assetInfo);
 		}
 
 		/// <summary>
@@ -121,7 +95,7 @@ namespace YooAsset.Editor
 		/// </summary>
 		public bool IsContainsAsset(string assetPath)
 		{
-			foreach (var assetInfo in BuildinAssets)
+			foreach (var assetInfo in MainAssets)
 			{
 				if (assetInfo.AssetPath == assetPath)
 				{
@@ -131,37 +105,36 @@ namespace YooAsset.Editor
 			return false;
 		}
 
-		/// <summary>
-		/// 获取资源包的分类标签列表
-		/// </summary>
-		public string[] GetBundleTags()
-		{
-			List<string> result = new List<string>(BuildinAssets.Count);
-			foreach (var assetInfo in BuildinAssets)
-			{
-				foreach (var assetTag in assetInfo.BundleTags)
-				{
-					if (result.Contains(assetTag) == false)
-						result.Add(assetTag);
-				}
-			}
-			return result.ToArray();
-		}
-
 		/// <summary>
 		/// 获取构建的资源路径列表
 		/// </summary>
-		public string[] GetBuildinAssetPaths()
+		public string[] GetAllMainAssetPaths()
 		{
-			return BuildinAssets.Select(t => t.AssetPath).ToArray();
+			return MainAssets.Select(t => t.AssetPath).ToArray();
 		}
 
 		/// <summary>
-		/// 获取所有写入补丁清单的资源
+		/// 获取该资源包内的所有资源（包括零依赖资源和冗余资源）
 		/// </summary>
-		public BuildAssetInfo[] GetAllPatchAssetInfos()
+		public List<string> GetAllBuiltinAssetPaths()
 		{
-			return BuildinAssets.Where(t => t.CollectorType == ECollectorType.MainAssetCollector).ToArray();
+			var packAssets = GetAllMainAssetPaths();
+			List<string> result = new List<string>(packAssets);
+			foreach (var assetInfo in MainAssets)
+			{
+				if (assetInfo.AllDependAssetInfos == null)
+					continue;
+				foreach (var dependAssetInfo in assetInfo.AllDependAssetInfos)
+				{
+					// 注意：依赖资源里只添加零依赖资源和冗余资源
+					if (dependAssetInfo.HasBundleName() == false)
+					{
+						if (result.Contains(dependAssetInfo.AssetPath) == false)
+							result.Add(dependAssetInfo.AssetPath);
+					}
+				}
+			}
+			return result;
 		}
 
 		/// <summary>
@@ -173,24 +146,31 @@ namespace YooAsset.Editor
 			AssetBundleBuild build = new AssetBundleBuild();
 			build.assetBundleName = BundleName;
 			build.assetBundleVariant = string.Empty;
-			build.assetNames = GetBuildinAssetPaths();
+			build.assetNames = GetAllMainAssetPaths();
 			return build;
 		}
 
 		/// <summary>
-		/// 创建PatchBundle类
+		/// 获取所有写入补丁清单的资源
 		/// </summary>
-		internal PatchBundle CreatePatchBundle()
+		public BuildAssetInfo[] GetAllManifestAssetInfos()
 		{
-			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;
+			return MainAssets.Where(t => t.CollectorType == ECollectorType.MainAssetCollector).ToArray();
+		}
+
+		/// <summary>
+		/// 创建PackageBundle类
+		/// </summary>
+		internal PackageBundle CreatePackageBundle()
+		{
+			PackageBundle packageBundle = new PackageBundle();
+			packageBundle.BundleName = BundleName;
+			packageBundle.FileHash = PackageFileHash;
+			packageBundle.FileCRC = PackageFileCRC;
+			packageBundle.FileSize = PackageFileSize;
+			packageBundle.UnityCRC = PackageUnityCRC;
+			packageBundle.Encrypted = Encrypted;
+			return packageBundle;
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildMapContext.cs

@@ -8,6 +8,17 @@ namespace YooAsset.Editor
 {
 	public class BuildMapContext : IContextObject
 	{
+		/// <summary>
+		/// 资源包集合
+		/// </summary>
+		private readonly Dictionary<string, BuildBundleInfo> _bundleInfoDic = new Dictionary<string, BuildBundleInfo>(10000);
+
+		/// <summary>
+		/// 冗余的资源列表
+		/// </summary>
+		public readonly List<ReportRedundancyInfo> RedundancyInfos = new List<ReportRedundancyInfo>(1000);
+
+
 		/// <summary>
 		/// 参与构建的资源总数
 		/// 说明：包括主动收集的资源以及其依赖的所有资源
@@ -15,24 +26,20 @@ namespace YooAsset.Editor
 		public int AssetFileCount;
 
 		/// <summary>
-		/// 是否启用可寻址资源定位
+		/// 资源收集命令
 		/// </summary>
-		public bool EnableAddressable;
+		public CollectCommand Command { set; get; }
 
 		/// <summary>
-		/// 资源包名唯一化
+		/// 资源包信息列表
 		/// </summary>
-		public bool UniqueBundleName;
-
-		/// <summary>
-		/// 着色器统一的全名称
-		/// </summary>
-		public string ShadersBundleName;
-
-		/// <summary>
-		/// 资源包列表
-		/// </summary>
-		public readonly List<BuildBundleInfo> BundleInfos = new List<BuildBundleInfo>(1000);
+		public Dictionary<string, BuildBundleInfo>.ValueCollection Collection
+		{
+			get
+			{
+				return _bundleInfoDic.Values;
+			}
+		}
 
 
 		/// <summary>
@@ -44,7 +51,7 @@ namespace YooAsset.Editor
 			if (string.IsNullOrEmpty(bundleName))
 				throw new Exception("Should never get here !");
 
-			if (TryGetBundleInfo(bundleName, out BuildBundleInfo bundleInfo))
+			if (_bundleInfoDic.TryGetValue(bundleName, out BuildBundleInfo bundleInfo))
 			{
 				bundleInfo.PackAsset(assetInfo);
 			}
@@ -52,69 +59,53 @@ namespace YooAsset.Editor
 			{
 				BuildBundleInfo newBundleInfo = new BuildBundleInfo(bundleName);
 				newBundleInfo.PackAsset(assetInfo);
-				BundleInfos.Add(newBundleInfo);
+				_bundleInfoDic.Add(bundleName, newBundleInfo);
 			}
 		}
 
-		/// <summary>
-		/// 获取所有的打包资源
-		/// </summary>
-		public List<BuildAssetInfo> GetAllAssets()
-		{
-			List<BuildAssetInfo> result = new List<BuildAssetInfo>(BundleInfos.Count);
-			foreach (var bundleInfo in BundleInfos)
-			{
-				result.AddRange(bundleInfo.BuildinAssets);
-			}
-			return result;
-		}
-
-		/// <summary>
-		/// 获取AssetBundle内构建的资源路径列表
-		/// </summary>
-		public string[] GetBuildinAssetPaths(string bundleName)
-		{
-			if (TryGetBundleInfo(bundleName, out BuildBundleInfo bundleInfo))
-			{
-				return bundleInfo.GetBuildinAssetPaths();
-			}
-			throw new Exception($"Not found {nameof(BuildBundleInfo)} : {bundleName}");
-		}
-
-		/// <summary>
-		/// 获取构建管线里需要的数据
-		/// </summary>
-		public UnityEditor.AssetBundleBuild[] GetPipelineBuilds()
-		{
-			List<UnityEditor.AssetBundleBuild> builds = new List<UnityEditor.AssetBundleBuild>(BundleInfos.Count);
-			foreach (var bundleInfo in BundleInfos)
-			{
-				if (bundleInfo.IsRawFile == false)
-					builds.Add(bundleInfo.CreatePipelineBuild());
-			}
-			return builds.ToArray();
-		}
-
 		/// <summary>
 		/// 是否包含资源包
 		/// </summary>
 		public bool IsContainsBundle(string bundleName)
 		{
-			return TryGetBundleInfo(bundleName, out BuildBundleInfo bundleInfo);
+			return _bundleInfoDic.ContainsKey(bundleName);
 		}
 
-		public bool TryGetBundleInfo(string bundleName, out BuildBundleInfo result)
+		/// <summary>
+		/// 获取资源包信息，如果没找到返回NULL
+		/// </summary>
+		public BuildBundleInfo GetBundleInfo(string bundleName)
 		{
-			foreach (var bundleInfo in BundleInfos)
+			if (_bundleInfoDic.TryGetValue(bundleName, out BuildBundleInfo result))
 			{
-				if (bundleInfo.BundleName == bundleName)
-				{
-					result = bundleInfo;
-					return true;
-				}
+				return result;
+			}
+			throw new Exception($"Not found bundle : {bundleName}");
+		}
+
+		/// <summary>
+		/// 获取构建管线里需要的数据
+		/// </summary>
+		public UnityEditor.AssetBundleBuild[] GetPipelineBuilds()
+		{
+			List<UnityEditor.AssetBundleBuild> builds = new List<UnityEditor.AssetBundleBuild>(_bundleInfoDic.Count);
+			foreach (var bundleInfo in _bundleInfoDic.Values)
+			{
+				builds.Add(bundleInfo.CreatePipelineBuild());
+			}
+			return builds.ToArray();
+		}
+
+		/// <summary>
+		/// 创建着色器信息类
+		/// </summary>
+		public void CreateShadersBundleInfo(string shadersBundleName)
+		{
+			if (IsContainsBundle(shadersBundleName) == false)
+			{
+				var shaderBundleInfo = new BuildBundleInfo(shadersBundleName);
+				_bundleInfoDic.Add(shadersBundleName, shaderBundleInfo);
 			}
-			result = null;
-			return false;
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildMapCreater.cs

@@ -1,145 +0,0 @@
-using System;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace YooAsset.Editor
-{
-	public static class BuildMapCreater
-	{
-		/// <summary>
-		/// 执行资源构建上下文
-		/// </summary>
-		public static BuildMapContext CreateBuildMap(EBuildMode buildMode, string packageName)
-		{	
-			Dictionary<string, BuildAssetInfo> buildAssetDic = new Dictionary<string, BuildAssetInfo>(1000);
-
-			// 1. 检测配置合法性
-			AssetBundleCollectorSettingData.Setting.CheckConfigError();
-
-			// 2. 获取所有收集器收集的资源
-			var buildResult = AssetBundleCollectorSettingData.Setting.GetPackageAssets(buildMode, packageName);
-			List<CollectAssetInfo> allCollectAssets = buildResult.CollectAssets;
-
-			// 3. 剔除未被引用的依赖项资源
-			List<CollectAssetInfo> removeDependList = new List<CollectAssetInfo>();
-			foreach (var collectAssetInfo in allCollectAssets)
-			{
-				if (collectAssetInfo.CollectorType == ECollectorType.DependAssetCollector)
-				{
-					if (IsRemoveDependAsset(allCollectAssets, collectAssetInfo.AssetPath))
-						removeDependList.Add(collectAssetInfo);
-				}
-			}
-			foreach (var removeValue in removeDependList)
-			{
-				allCollectAssets.Remove(removeValue);
-			}
-
-			// 4. 录入所有收集器收集的资源
-			foreach (var collectAssetInfo in allCollectAssets)
-			{
-				if (buildAssetDic.ContainsKey(collectAssetInfo.AssetPath) == false)
-				{
-					var buildAssetInfo = new BuildAssetInfo(
-						collectAssetInfo.CollectorType, collectAssetInfo.BundleName,
-						collectAssetInfo.Address, collectAssetInfo.AssetPath, collectAssetInfo.IsRawAsset);
-					buildAssetInfo.AddAssetTags(collectAssetInfo.AssetTags);
-					buildAssetInfo.AddBundleTags(collectAssetInfo.AssetTags);
-					buildAssetDic.Add(collectAssetInfo.AssetPath, buildAssetInfo);
-				}
-				else
-				{
-					throw new Exception($"Should never get here !");
-				}
-			}
-
-			// 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(collectAssetBundleName);
-					}
-					else
-					{
-						var buildAssetInfo = new BuildAssetInfo(dependAssetPath);
-						buildAssetInfo.AddBundleTags(collectAssetInfo.AssetTags);
-						buildAssetInfo.AddReferenceBundleName(collectAssetBundleName);
-						buildAssetDic.Add(dependAssetPath, buildAssetInfo);
-					}
-				}
-			}
-
-			// 6. 填充所有收集资源的依赖列表
-			foreach (var collectAssetInfo in allCollectAssets)
-			{
-				var dependAssetInfos = new List<BuildAssetInfo>(collectAssetInfo.DependAssets.Count);
-				foreach (var dependAssetPath in collectAssetInfo.DependAssets)
-				{
-					if (buildAssetDic.TryGetValue(dependAssetPath, out BuildAssetInfo value))
-						dependAssetInfos.Add(value);
-					else
-						throw new Exception("Should never get here !");
-				}
-				buildAssetDic[collectAssetInfo.AssetPath].SetAllDependAssetInfos(dependAssetInfos);
-			}
-
-			// 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.CalculateShareBundleName(command.UniqueBundleName, command.PackageName, buildResult.ShadersBundleName);
-			}
-
-			// 9. 移除不参与构建的资源
-			List<BuildAssetInfo> removeBuildList = new List<BuildAssetInfo>();
-			foreach (KeyValuePair<string, BuildAssetInfo> pair in buildAssetDic)
-			{
-				var buildAssetInfo = pair.Value;
-				if (buildAssetInfo.HasBundleName() == false)
-					removeBuildList.Add(buildAssetInfo);
-			}
-			foreach (var removeValue in removeBuildList)
-			{
-				buildAssetDic.Remove(removeValue.AssetPath);
-			}
-
-			// 10. 构建资源包
-			var allBuildinAssets = buildAssetDic.Values.ToList();
-			if (allBuildinAssets.Count == 0)
-				throw new Exception("构建的资源列表不能为空");
-			foreach (var assetInfo in allBuildinAssets)
-			{
-				context.PackAsset(assetInfo);
-			}
-			return context;
-		}
-		private static bool IsRemoveDependAsset(List<CollectAssetInfo> allCollectAssets, string dependAssetPath)
-		{
-			foreach (var collectAssetInfo in allCollectAssets)
-			{
-				var collectorType = collectAssetInfo.CollectorType;
-				if (collectorType == ECollectorType.MainAssetCollector || collectorType == ECollectorType.StaticAssetCollector)
-				{
-					if (collectAssetInfo.DependAssets.Contains(dependAssetPath))
-						return false;
-				}
-			}
-
-			BuildLogger.Log($"发现未被依赖的资源并自动移除 : {dependAssetPath}");
-			return true;
-		}
-	}
-}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildParameters.cs

@@ -1,4 +1,6 @@
-using System.Collections;
+using System;
+using System.IO;
+using System.Collections;
 using System.Collections.Generic;
 using UnityEditor;
 
@@ -7,50 +9,28 @@ namespace YooAsset.Editor
 	/// <summary>
 	/// 构建参数
 	/// </summary>
-	public class BuildParameters
+	public abstract class BuildParameters
 	{
 		/// <summary>
-		/// SBP构建参数
+		/// 构建输出的根目录
 		/// </summary>
-		public class SBPBuildParameters
-		{
-			/// <summary>
-			/// 生成代码防裁剪配置
-			/// </summary>
-			public bool WriteLinkXML = true;
-
-			/// <summary>
-			/// 缓存服务器地址
-			/// </summary>
-			public string CacheServerHost;
-
-			/// <summary>
-			/// 缓存服务器端口
-			/// </summary>
-			public int CacheServerPort;
-		}
+		public string BuildOutputRoot;
 
 		/// <summary>
-		/// 可编程构建管线的参数
+		/// 内置文件的根目录
 		/// </summary>
-		public SBPBuildParameters SBPParameters;
-
+		public string BuildinFileRoot;
 
 		/// <summary>
-		/// 输出的根目录
+		/// 构建管线
 		/// </summary>
-		public string OutputRoot;
+		public string BuildPipeline;
 
 		/// <summary>
 		/// 构建的平台
 		/// </summary>
 		public BuildTarget BuildTarget;
 
-		/// <summary>
-		/// 构建管线
-		/// </summary>
-		public EBuildPipeline BuildPipeline;
-
 		/// <summary>
 		/// 构建模式
 		/// </summary>
@@ -71,40 +51,136 @@ namespace YooAsset.Editor
 		/// 验证构建结果
 		/// </summary>
 		public bool VerifyBuildingResult = false;
+
+		/// <summary>
+		/// 资源包名称样式
+		/// </summary>
+		public EFileNameStyle FileNameStyle;
+
+		/// <summary>
+		/// 内置文件的拷贝选项
+		/// </summary>
+		public EBuildinFileCopyOption BuildinFileCopyOption;
+
+		/// <summary>
+		/// 内置文件的拷贝参数
+		/// </summary>
+		public string BuildinFileCopyParams;
+
+		/// <summary>
+		/// 资源包加密服务类
+		/// </summary>
+		public IEncryptionServices EncryptionServices;
+		
+
+
+		private string _pipelineOutputDirectory = string.Empty;
+		private string _packageOutputDirectory = string.Empty;
+		private string _packageRootDirectory = string.Empty;
+		private string _buildinRootDirectory = string.Empty;
 		
 		/// <summary>
-		/// 加密类
+		/// 检测构建参数是否合法
 		/// </summary>
-		public IEncryptionServices EncryptionServices = null;
+		public virtual void CheckBuildParameters()
+		{
+			// 检测当前是否正在构建资源包
+			if (UnityEditor.BuildPipeline.isBuildingPlayer)
+				throw new Exception("当前正在构建资源包，请结束后再试");
+
+			// 检测构建参数合法性
+			if (BuildTarget == BuildTarget.NoTarget)
+				throw new Exception("请选择目标平台！");
+			if (string.IsNullOrEmpty(PackageName))
+				throw new Exception("包裹名称不能为空！");
+			if (string.IsNullOrEmpty(PackageVersion))
+				throw new Exception("包裹版本不能为空！");
+			if (string.IsNullOrEmpty(BuildOutputRoot))
+				throw new Exception("构建输出的根目录为空！");
+			if (string.IsNullOrEmpty(BuildinFileRoot))
+				throw new Exception("内置资源根目录为空！");
+
+			// 检测是否有未保存场景
+			if (BuildMode != EBuildMode.SimulateBuild)
+			{
+				if (EditorTools.HasDirtyScenes())
+					throw new Exception("检测到未保存的场景文件");
+			}
+
+			// 强制构建删除包裹目录
+			if (BuildMode == EBuildMode.ForceRebuild)
+			{
+				string packageRootDirectory = GetPackageRootDirectory();
+				if (EditorTools.DeleteDirectory(packageRootDirectory))
+				{
+					BuildLogger.Log($"删除包裹目录：{packageRootDirectory}");
+				}
+			}
+
+			// 检测包裹输出目录是否存在
+			if (BuildMode != EBuildMode.SimulateBuild)
+			{
+				string packageOutputDirectory = GetPackageOutputDirectory();
+				if (Directory.Exists(packageOutputDirectory))
+					throw new Exception($"本次构建的补丁目录已经存在：{packageOutputDirectory}");
+			}
+
+			// 如果输出目录不存在
+			string pipelineOutputDirectory = GetPipelineOutputDirectory();
+			if (EditorTools.CreateDirectory(pipelineOutputDirectory))
+			{
+				BuildLogger.Log($"创建输出目录：{pipelineOutputDirectory}");
+			}
+		}
+
 
 		/// <summary>
-		/// 补丁文件名称的样式
+		/// 获取构建管线的输出目录
 		/// </summary>
-		public EOutputNameStyle OutputNameStyle = EOutputNameStyle.HashName;
+		/// <returns></returns>
+		public string GetPipelineOutputDirectory()
+		{
+			if (string.IsNullOrEmpty(_pipelineOutputDirectory))
+			{
+				_pipelineOutputDirectory = $"{BuildOutputRoot}/{BuildTarget}/{PackageName}/{YooAssetSettings.OutputFolderName}";
+			}
+			return _pipelineOutputDirectory;
+		}
 
 		/// <summary>
-		/// 拷贝内置资源选项
+		/// 获取本次构建的补丁输出目录
 		/// </summary>
-		public ECopyBuildinFileOption CopyBuildinFileOption = ECopyBuildinFileOption.None;
+		public string GetPackageOutputDirectory()
+		{
+			if (string.IsNullOrEmpty(_packageOutputDirectory))
+			{
+				_packageOutputDirectory = $"{BuildOutputRoot}/{BuildTarget}/{PackageName}/{PackageVersion}";
+			}
+			return _packageOutputDirectory;
+		}
 
 		/// <summary>
-		/// 拷贝内置资源的标签
+		/// 获取本次构建的补丁根目录
 		/// </summary>
-		public string CopyBuildinFileTags = string.Empty;
+		public string GetPackageRootDirectory()
+		{
+			if (string.IsNullOrEmpty(_packageRootDirectory))
+			{
+				_packageRootDirectory = $"{BuildOutputRoot}/{BuildTarget}/{PackageName}";
+			}
+			return _packageRootDirectory;
+		}
 
 		/// <summary>
-		/// 压缩选项
+		/// 获取内置资源的根目录
 		/// </summary>
-		public ECompressOption CompressOption = ECompressOption.Uncompressed;
-
-		/// <summary>
-		/// 禁止写入类型树结构（可以降低包体和内存并提高加载效率）
-		/// </summary>
-		public bool DisableWriteTypeTree = false;
-
-		/// <summary>
-		/// 忽略类型树变化
-		/// </summary>
-		public bool IgnoreTypeTreeChanges = true;
+		public string GetBuildinRootDirectory()
+		{
+			if (string.IsNullOrEmpty(_buildinRootDirectory))
+			{
+				_buildinRootDirectory = $"{BuildinFileRoot}/{PackageName}";
+			}
+			return _buildinRootDirectory;
+		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildParametersContext.cs

@@ -1,15 +1,13 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.IO;
 using UnityEditor;
 
 namespace YooAsset.Editor
 {
 	public class BuildParametersContext : IContextObject
 	{
-		private string _pipelineOutputDirectory = string.Empty;
-		private string _packageOutputDirectory = string.Empty;
-
 		/// <summary>
 		/// 构建参数
 		/// </summary>
@@ -21,99 +19,45 @@ namespace YooAsset.Editor
 			Parameters = parameters;
 		}
 
+		/// <summary>
+		/// 检测构建参数是否合法
+		/// </summary>
+		public void CheckBuildParameters()
+		{
+			Parameters.CheckBuildParameters();
+		}
+
 		/// <summary>
 		/// 获取构建管线的输出目录
 		/// </summary>
 		/// <returns></returns>
 		public string GetPipelineOutputDirectory()
 		{
-			if (string.IsNullOrEmpty(_pipelineOutputDirectory))
-			{
-				_pipelineOutputDirectory = AssetBundleBuilderHelper.MakePipelineOutputDirectory(Parameters.OutputRoot, Parameters.PackageName, Parameters.BuildTarget, Parameters.BuildMode);
-			}
-			return _pipelineOutputDirectory;
+			return Parameters.GetPipelineOutputDirectory();
 		}
 
 		/// <summary>
-		/// 获取本次构建的补丁目录
+		/// 获取本次构建的补丁输出目录
 		/// </summary>
 		public string GetPackageOutputDirectory()
 		{
-			if (string.IsNullOrEmpty(_packageOutputDirectory))
-			{
-				_packageOutputDirectory = $"{Parameters.OutputRoot}/{Parameters.PackageName}/{Parameters.BuildTarget}/{Parameters.PackageVersion}";
-			}
-			return _packageOutputDirectory;
+			return Parameters.GetPackageOutputDirectory();
 		}
 
 		/// <summary>
-		/// 获取内置构建管线的构建选项
+		/// 获取本次构建的补丁根目录
 		/// </summary>
-		public BuildAssetBundleOptions GetPipelineBuildOptions()
+		public string GetPackageRootDirectory()
 		{
-			// 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;
+			return Parameters.GetPackageRootDirectory();
 		}
 
 		/// <summary>
-		/// 获取可编程构建管线的构建参数
+		/// 获取内置资源的根目录
 		/// </summary>
-		public UnityEditor.Build.Pipeline.BundleBuildParameters GetSBPBuildParameters()
+		public string GetBuildinRootDirectory()
 		{
-			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;
+			return Parameters.GetBuildinRootDirectory();
 		}
 	}
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 2de5a58f37a4ae64e804f150144da809
+guid: 431722e1bca52d448825f603789d7e4b
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BaseTasks/TaskCopyBuildinFiles.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace YooAsset.Editor
+{
+	public class TaskCopyBuildinFiles
+	{
+		/// <summary>
+		/// 拷贝首包资源文件
+		/// </summary>
+		internal void CopyBuildinFilesToStreaming(BuildParametersContext buildParametersContext, PackageManifest manifest)
+		{
+			EBuildinFileCopyOption copyOption = buildParametersContext.Parameters.BuildinFileCopyOption;
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			string buildinRootDirectory = buildParametersContext.GetBuildinRootDirectory();
+			string buildPackageName = buildParametersContext.Parameters.PackageName;
+			string buildPackageVersion = buildParametersContext.Parameters.PackageVersion;
+
+			// 清空内置文件的目录
+			if (copyOption == EBuildinFileCopyOption.ClearAndCopyAll || copyOption == EBuildinFileCopyOption.ClearAndCopyByTags)
+			{
+				EditorTools.ClearFolder(buildinRootDirectory);
+			}
+
+			// 拷贝补丁清单文件
+			{
+				string fileName = YooAssetSettingsData.GetManifestBinaryFileName(buildPackageName, buildPackageVersion);
+				string sourcePath = $"{packageOutputDirectory}/{fileName}";
+				string destPath = $"{buildinRootDirectory}/{fileName}";
+				EditorTools.CopyFile(sourcePath, destPath, true);
+			}
+
+			// 拷贝补丁清单哈希文件
+			{
+				string fileName = YooAssetSettingsData.GetPackageHashFileName(buildPackageName, buildPackageVersion);
+				string sourcePath = $"{packageOutputDirectory}/{fileName}";
+				string destPath = $"{buildinRootDirectory}/{fileName}";
+				EditorTools.CopyFile(sourcePath, destPath, true);
+			}
+
+			// 拷贝补丁清单版本文件
+			{
+				string fileName = YooAssetSettingsData.GetPackageVersionFileName(buildPackageName);
+				string sourcePath = $"{packageOutputDirectory}/{fileName}";
+				string destPath = $"{buildinRootDirectory}/{fileName}";
+				EditorTools.CopyFile(sourcePath, destPath, true);
+			}
+
+			// 拷贝文件列表（所有文件）
+			if (copyOption == EBuildinFileCopyOption.ClearAndCopyAll || copyOption == EBuildinFileCopyOption.OnlyCopyAll)
+			{
+				foreach (var packageBundle in manifest.BundleList)
+				{
+					string sourcePath = $"{packageOutputDirectory}/{packageBundle.FileName}";
+					string destPath = $"{buildinRootDirectory}/{packageBundle.FileName}";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
+			}
+
+			// 拷贝文件列表（带标签的文件）
+			if (copyOption == EBuildinFileCopyOption.ClearAndCopyByTags || copyOption == EBuildinFileCopyOption.OnlyCopyByTags)
+			{
+				string[] tags = buildParametersContext.Parameters.BuildinFileCopyParams.Split(';');
+				foreach (var packageBundle in manifest.BundleList)
+				{
+					if (packageBundle.HasTag(tags) == false)
+						continue;
+					string sourcePath = $"{packageOutputDirectory}/{packageBundle.FileName}";
+					string destPath = $"{buildinRootDirectory}/{packageBundle.FileName}";
+					EditorTools.CopyFile(sourcePath, destPath, true);
+				}
+			}
+
+			// 刷新目录
+			AssetDatabase.Refresh();
+			BuildLogger.Log($"内置文件拷贝完成：{buildinRootDirectory}");
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BaseTasks/TaskCreateManifest.cs

@@ -0,0 +1,213 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+
+using UnityEditor.Build.Pipeline;
+using UnityEditor.Build.Pipeline.Interfaces;
+
+namespace YooAsset.Editor
+{
+	public class ManifestContext : IContextObject
+	{
+		internal PackageManifest Manifest;
+	}
+
+	public abstract class TaskCreateManifest
+	{
+		private readonly Dictionary<string, int> _cachedBundleID = new Dictionary<string, int>(10000);
+
+		/// <summary>
+		/// 创建补丁清单文件到输出目录
+		/// </summary>
+		protected void CreateManifestFile(BuildContext context)
+		{
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = buildParametersContext.Parameters;
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+
+			// 创建新补丁清单
+			PackageManifest manifest = new PackageManifest();
+			manifest.FileVersion = YooAssetSettings.ManifestFileVersion;
+			manifest.EnableAddressable = buildMapContext.Command.EnableAddressable;
+			manifest.LocationToLower = buildMapContext.Command.LocationToLower;
+			manifest.IncludeAssetGUID = buildMapContext.Command.IncludeAssetGUID;
+			manifest.OutputNameStyle = (int)buildParameters.FileNameStyle;
+			manifest.BuildPipeline = buildParameters.BuildPipeline;
+			manifest.PackageName = buildParameters.PackageName;
+			manifest.PackageVersion = buildParameters.PackageVersion;
+			manifest.BundleList = GetAllPackageBundle(buildMapContext);
+			manifest.AssetList = GetAllPackageAsset(buildMapContext);
+
+			if (buildParameters.BuildMode != EBuildMode.SimulateBuild)
+			{
+				// 处理资源包的依赖列表
+				ProcessBundleDepends(context, manifest);
+
+				// 处理资源包的标签集合
+				ProcessBundleTags(manifest);
+			}
+
+			// 创建补丁清单文本文件
+			{
+				string fileName = YooAssetSettingsData.GetManifestJsonFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+				string filePath = $"{packageOutputDirectory}/{fileName}";
+				ManifestTools.SerializeToJson(filePath, manifest);
+				BuildLogger.Log($"创建补丁清单文件：{filePath}");
+			}
+
+			// 创建补丁清单二进制文件
+			string packageHash;
+			{
+				string fileName = YooAssetSettingsData.GetManifestBinaryFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+				string filePath = $"{packageOutputDirectory}/{fileName}";
+				ManifestTools.SerializeToBinary(filePath, manifest);
+				packageHash = HashUtility.FileMD5(filePath);
+				BuildLogger.Log($"创建补丁清单文件：{filePath}");
+
+				ManifestContext manifestContext = new ManifestContext();
+				byte[] bytesData = FileUtility.ReadAllBytes(filePath);
+				manifestContext.Manifest = ManifestTools.DeserializeFromBinary(bytesData);
+				context.SetContextObject(manifestContext);
+			}
+
+			// 创建补丁清单哈希文件
+			{
+				string fileName = YooAssetSettingsData.GetPackageHashFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+				string filePath = $"{packageOutputDirectory}/{fileName}";
+				FileUtility.WriteAllText(filePath, packageHash);
+				BuildLogger.Log($"创建补丁清单哈希文件：{filePath}");
+			}
+
+			// 创建补丁清单版本文件
+			{
+				string fileName = YooAssetSettingsData.GetPackageVersionFileName(buildParameters.PackageName);
+				string filePath = $"{packageOutputDirectory}/{fileName}";
+				FileUtility.WriteAllText(filePath, buildParameters.PackageVersion);
+				BuildLogger.Log($"创建补丁清单版本文件：{filePath}");
+			}
+		}
+
+		/// <summary>
+		/// 获取资源包的依赖集合
+		/// </summary>
+		protected abstract string[] GetBundleDepends(BuildContext context, string bundleName);
+
+		/// <summary>
+		/// 获取主资源对象列表
+		/// </summary>
+		private List<PackageAsset> GetAllPackageAsset(BuildMapContext buildMapContext)
+		{
+			List<PackageAsset> result = new List<PackageAsset>(1000);
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				var assetInfos = bundleInfo.GetAllManifestAssetInfos();
+				foreach (var assetInfo in assetInfos)
+				{
+					PackageAsset packageAsset = new PackageAsset();
+					packageAsset.Address = buildMapContext.Command.EnableAddressable ? assetInfo.Address : string.Empty;
+					packageAsset.AssetPath = assetInfo.AssetPath;
+					packageAsset.AssetGUID = buildMapContext.Command.IncludeAssetGUID ? assetInfo.AssetGUID : string.Empty;
+					packageAsset.AssetTags = assetInfo.AssetTags.ToArray();
+					packageAsset.BundleID = GetCachedBundleID(assetInfo.BundleName);
+					result.Add(packageAsset);
+				}
+			}
+			return result;
+		}
+
+		/// <summary>
+		/// 获取资源包列表
+		/// </summary>
+		private List<PackageBundle> GetAllPackageBundle(BuildMapContext buildMapContext)
+		{
+			List<PackageBundle> result = new List<PackageBundle>(1000);
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				var packageBundle = bundleInfo.CreatePackageBundle();
+				result.Add(packageBundle);
+			}
+
+			// 注意：缓存资源包索引
+			for (int index = 0; index < result.Count; index++)
+			{
+				string bundleName = result[index].BundleName;
+				_cachedBundleID.Add(bundleName, index);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		/// 处理资源包的依赖集合
+		/// </summary>
+		private void ProcessBundleDepends(BuildContext context, PackageManifest manifest)
+		{
+			// 查询引擎生成的资源包依赖关系，然后记录到清单
+			foreach (var packageBundle in manifest.BundleList)
+			{
+				int mainBundleID = GetCachedBundleID(packageBundle.BundleName);
+				var depends = GetBundleDepends(context, packageBundle.BundleName);
+				List<int> dependIDs = new List<int>(depends.Length);
+				foreach (var dependBundleName in depends)
+				{
+					int bundleID = GetCachedBundleID(dependBundleName);
+					if (bundleID != mainBundleID)
+						dependIDs.Add(bundleID);
+				}
+				packageBundle.DependIDs = dependIDs.ToArray();
+			}
+		}
+
+		/// <summary>
+		/// 处理资源包的标签集合
+		/// </summary>
+		private void ProcessBundleTags(PackageManifest manifest)
+		{
+			Dictionary<int, HashSet<string>> cacheBundleTags = new Dictionary<int, HashSet<string>>(10000);
+
+			foreach (var packageAsset in manifest.AssetList)
+			{
+				// 主资源包
+				int bundleID = packageAsset.BundleID;
+				CacheBundleTags(cacheBundleTags, bundleID, packageAsset.AssetTags);
+
+				// 依赖资源包
+				var packageBundle = manifest.BundleList[bundleID];
+				foreach (var dependBundleID in packageBundle.DependIDs)
+				{
+					CacheBundleTags(cacheBundleTags, dependBundleID, packageAsset.AssetTags);
+				}
+			}
+
+			for (int index = 0; index < manifest.BundleList.Count; index++)
+			{
+				manifest.BundleList[index].Tags = cacheBundleTags[index].ToArray();
+			}
+		}
+		private void CacheBundleTags(Dictionary<int, HashSet<string>> cacheBundleTags, int bundleID, string[] assetTags)
+		{
+			if (cacheBundleTags.ContainsKey(bundleID) == false)
+				cacheBundleTags.Add(bundleID, new HashSet<string>());
+
+			foreach (var assetTag in assetTags)
+			{
+				if (cacheBundleTags[bundleID].Contains(assetTag) == false)
+					cacheBundleTags[bundleID].Add(assetTag);
+			}
+		}
+
+		/// <summary>
+		/// 获取资源包的索引ID
+		/// </summary>
+		private int GetCachedBundleID(string bundleName)
+		{
+			if (_cachedBundleID.TryGetValue(bundleName, out int value) == false)
+			{
+				throw new Exception($"Not found cached bundle ID : {bundleName}");
+			}
+			return value;
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BaseTasks/TaskCreateReport.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class TaskCreateReport
+	{
+		protected void CreateReportFile(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext, ManifestContext manifestContext)
+		{
+			var buildParameters = buildParametersContext.Parameters;
+
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			PackageManifest manifest = manifestContext.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.BuildDate = DateTime.Now.ToString();
+				buildReport.Summary.BuildSeconds = BuildRunner.TotalSeconds;
+				buildReport.Summary.BuildTarget = buildParameters.BuildTarget;
+				buildReport.Summary.BuildPipeline = buildParameters.BuildPipeline;
+				buildReport.Summary.BuildMode = buildParameters.BuildMode;
+				buildReport.Summary.BuildPackageName = buildParameters.PackageName;
+				buildReport.Summary.BuildPackageVersion = buildParameters.PackageVersion;
+				buildReport.Summary.EnableAddressable = buildMapContext.Command.EnableAddressable;
+				buildReport.Summary.LocationToLower = buildMapContext.Command.LocationToLower;
+				buildReport.Summary.IncludeAssetGUID = buildMapContext.Command.IncludeAssetGUID;
+				buildReport.Summary.UniqueBundleName = buildMapContext.Command.UniqueBundleName;
+				buildReport.Summary.EncryptionServicesClassName = buildParameters.EncryptionServices == null ?
+					"null" : buildParameters.EncryptionServices.GetType().FullName;
+
+				// 构建参数
+				if (buildParameters.BuildPipeline == nameof(BuiltinBuildPipeline))
+				{
+					var builtinBuildParameters = buildParameters as BuiltinBuildParameters;
+					buildReport.Summary.FileNameStyle = buildParameters.FileNameStyle;
+					buildReport.Summary.CompressOption = builtinBuildParameters.CompressOption;
+					buildReport.Summary.DisableWriteTypeTree = builtinBuildParameters.DisableWriteTypeTree;
+					buildReport.Summary.IgnoreTypeTreeChanges = builtinBuildParameters.IgnoreTypeTreeChanges;
+				}
+				else if (buildParameters.BuildPipeline == nameof(ScriptableBuildPipeline))
+				{
+					var scriptableBuildParameters = buildParameters as ScriptableBuildParameters;
+					buildReport.Summary.FileNameStyle = buildParameters.FileNameStyle;
+					buildReport.Summary.CompressOption = scriptableBuildParameters.CompressOption;
+					buildReport.Summary.DisableWriteTypeTree = scriptableBuildParameters.DisableWriteTypeTree;
+					buildReport.Summary.IgnoreTypeTreeChanges = scriptableBuildParameters.IgnoreTypeTreeChanges;
+				}
+				else
+				{
+					buildReport.Summary.FileNameStyle = buildParameters.FileNameStyle;
+					buildReport.Summary.CompressOption = ECompressOption.Uncompressed;
+					buildReport.Summary.DisableWriteTypeTree = false;
+					buildReport.Summary.IgnoreTypeTreeChanges = false;
+				}
+
+				// 构建结果
+				buildReport.Summary.AssetFileTotalCount = buildMapContext.AssetFileCount;
+				buildReport.Summary.MainAssetTotalCount = GetMainAssetCount(manifest);
+				buildReport.Summary.AllBundleTotalCount = GetAllBundleCount(manifest);
+				buildReport.Summary.AllBundleTotalSize = GetAllBundleSize(manifest);
+				buildReport.Summary.EncryptedBundleTotalCount = GetEncryptedBundleCount(manifest);
+				buildReport.Summary.EncryptedBundleTotalSize = GetEncryptedBundleSize(manifest);
+			}
+
+			// 资源对象列表
+			buildReport.AssetInfos = new List<ReportAssetInfo>(manifest.AssetList.Count);
+			foreach (var packageAsset in manifest.AssetList)
+			{
+				var mainBundle = manifest.BundleList[packageAsset.BundleID];
+				ReportAssetInfo reportAssetInfo = new ReportAssetInfo();
+				reportAssetInfo.Address = packageAsset.Address;
+				reportAssetInfo.AssetPath = packageAsset.AssetPath;
+				reportAssetInfo.AssetTags = packageAsset.AssetTags;
+				reportAssetInfo.AssetGUID = AssetDatabase.AssetPathToGUID(packageAsset.AssetPath);
+				reportAssetInfo.MainBundleName = mainBundle.BundleName;
+				reportAssetInfo.MainBundleSize = mainBundle.FileSize;
+				reportAssetInfo.DependAssets = GetDependAssets(buildMapContext, mainBundle.BundleName, packageAsset.AssetPath);
+				buildReport.AssetInfos.Add(reportAssetInfo);
+			}
+
+			// 资源包列表
+			buildReport.BundleInfos = new List<ReportBundleInfo>(manifest.BundleList.Count);
+			foreach (var packageBundle in manifest.BundleList)
+			{
+				ReportBundleInfo reportBundleInfo = new ReportBundleInfo();
+				reportBundleInfo.BundleName = packageBundle.BundleName;
+				reportBundleInfo.FileName = packageBundle.FileName;
+				reportBundleInfo.FileHash = packageBundle.FileHash;
+				reportBundleInfo.FileCRC = packageBundle.FileCRC;
+				reportBundleInfo.FileSize = packageBundle.FileSize;
+				reportBundleInfo.Encrypted = packageBundle.Encrypted;
+				reportBundleInfo.Tags = packageBundle.Tags;
+				reportBundleInfo.DependBundles = GetDependBundles(manifest, packageBundle);
+				reportBundleInfo.AllBuiltinAssets = GetAllBuiltinAssets(buildMapContext, packageBundle.BundleName);
+				buildReport.BundleInfos.Add(reportBundleInfo);
+			}
+
+			// 冗余资源列表
+			buildReport.RedundancyInfos = new List<ReportRedundancyInfo>(buildMapContext.RedundancyInfos);
+
+			// 序列化文件
+			string fileName = YooAssetSettingsData.GetReportFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+			string filePath = $"{packageOutputDirectory}/{fileName}";
+			BuildReport.Serialize(filePath, buildReport);
+			BuildLogger.Log($"资源构建报告文件创建完成：{filePath}");
+		}
+
+		/// <summary>
+		/// 获取资源对象依赖的所有资源包
+		/// </summary>
+		private List<string> GetDependBundles(PackageManifest manifest, PackageBundle packageBundle)
+		{
+			List<string> dependBundles = new List<string>(packageBundle.DependIDs.Length);
+			foreach (int index in packageBundle.DependIDs)
+			{
+				string dependBundleName = manifest.BundleList[index].BundleName;
+				dependBundles.Add(dependBundleName);
+			}
+			return dependBundles;
+		}
+
+		/// <summary>
+		/// 获取资源对象依赖的其它所有资源
+		/// </summary>
+		private List<string> GetDependAssets(BuildMapContext buildMapContext, string bundleName, string assetPath)
+		{
+			List<string> result = new List<string>();
+			var bundleInfo = buildMapContext.GetBundleInfo(bundleName);
+			{
+				BuildAssetInfo findAssetInfo = null;
+				foreach (var assetInfo in bundleInfo.MainAssets)
+				{
+					if (assetInfo.AssetPath == assetPath)
+					{
+						findAssetInfo = assetInfo;
+						break;
+					}
+				}
+				if (findAssetInfo == null)
+				{
+					throw new Exception($"Not found asset {assetPath} in bunlde {bundleName}");
+				}
+				foreach (var dependAssetInfo in findAssetInfo.AllDependAssetInfos)
+				{
+					result.Add(dependAssetInfo.AssetPath);
+				}
+			}
+			return result;
+		}
+
+		/// <summary>
+		/// 获取该资源包内的所有资源
+		/// </summary>
+		private List<string> GetAllBuiltinAssets(BuildMapContext buildMapContext, string bundleName)
+		{
+			var bundleInfo = buildMapContext.GetBundleInfo(bundleName);
+			return bundleInfo.GetAllBuiltinAssetPaths();
+		}
+
+		private int GetMainAssetCount(PackageManifest manifest)
+		{
+			return manifest.AssetList.Count;
+		}
+		private int GetAllBundleCount(PackageManifest manifest)
+		{
+			return manifest.BundleList.Count;
+		}
+		private long GetAllBundleSize(PackageManifest manifest)
+		{
+			long fileBytes = 0;
+			foreach (var packageBundle in manifest.BundleList)
+			{
+				fileBytes += packageBundle.FileSize;
+			}
+			return fileBytes;
+		}
+		private int GetEncryptedBundleCount(PackageManifest manifest)
+		{
+			int fileCount = 0;
+			foreach (var packageBundle in manifest.BundleList)
+			{
+				if (packageBundle.Encrypted)
+					fileCount++;
+			}
+			return fileCount;
+		}
+		private long GetEncryptedBundleSize(PackageManifest manifest)
+		{
+			long fileBytes = 0;
+			foreach (var packageBundle in manifest.BundleList)
+			{
+				if (packageBundle.Encrypted)
+					fileBytes += packageBundle.FileSize;
+			}
+			return fileBytes;
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BaseTasks/TaskEncryption.cs

@@ -6,25 +6,12 @@ using System.Collections.Generic;
 
 namespace YooAsset.Editor
 {
-	[TaskAttribute("资源包加密")]
-	public class TaskEncryption : IBuildTask
+	public class TaskEncryption
 	{
-		void IBuildTask.Run(BuildContext context)
-		{
-			var buildParameters = context.GetContextObject<BuildParametersContext>();
-			var buildMapContext = context.GetContextObject<BuildMapContext>();
-
-			var buildMode = buildParameters.Parameters.BuildMode;
-			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
-			{
-				EncryptingBundleFiles(buildParameters, buildMapContext);
-			}
-		}
-
 		/// <summary>
 		/// 加密文件
 		/// </summary>
-		private void EncryptingBundleFiles(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext)
+		public void EncryptingBundleFiles(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext)
 		{
 			var encryptionServices = buildParametersContext.Parameters.EncryptionServices;
 			if (encryptionServices == null)
@@ -35,31 +22,28 @@ namespace YooAsset.Editor
 
 			int progressValue = 0;
 			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
-			foreach (var bundleInfo in buildMapContext.BundleInfos)
+			foreach (var bundleInfo in buildMapContext.Collection)
 			{
 				EncryptFileInfo fileInfo = new EncryptFileInfo();
 				fileInfo.BundleName = bundleInfo.BundleName;
 				fileInfo.FilePath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
 
 				var encryptResult = encryptionServices.Encrypt(fileInfo);		
-				if (encryptResult.LoadMethod != EBundleLoadMethod.Normal)
+				if (encryptResult.Encrypted)
 				{
-					// 注意：原生文件不支持加密
-					if (bundleInfo.IsRawFile)
-					{
-						UnityEngine.Debug.LogWarning($"Encryption not support raw file : {bundleInfo.BundleName}");
-						continue;
-					}
-
 					string filePath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}.encrypt";
-					FileUtility.CreateFile(filePath, encryptResult.EncryptedData);
+					FileUtility.WriteAllBytes(filePath, encryptResult.EncryptedData);
 					bundleInfo.EncryptedFilePath = filePath;
-					bundleInfo.LoadMethod = encryptResult.LoadMethod;
+					bundleInfo.Encrypted = true;
 					BuildLogger.Log($"Bundle文件加密完成：{filePath}");
 				}
+				else
+				{
+					bundleInfo.Encrypted = false;
+				}
 
 				// 进度条
-				EditorTools.DisplayProgressBar("加密资源包", ++progressValue, buildMapContext.BundleInfos.Count);
+				EditorTools.DisplayProgressBar("加密资源包", ++progressValue, buildMapContext.Collection.Count);
 			}
 			EditorTools.ClearProgressBar();
 		}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BaseTasks/TaskGetBuildMap.cs

@@ -0,0 +1,170 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class TaskGetBuildMap
+	{
+		/// <summary>
+		/// 生成资源构建上下文
+		/// </summary>
+		public BuildMapContext CreateBuildMap(BuildParameters buildParameters)
+		{
+			var buildMode = buildParameters.BuildMode;
+			var packageName = buildParameters.PackageName;
+
+			Dictionary<string, BuildAssetInfo> allBuildAssetInfos = new Dictionary<string, BuildAssetInfo>(1000);
+
+			// 1. 获取所有收集器收集的资源
+			var collectResult = AssetBundleCollectorSettingData.Setting.GetPackageAssets(buildMode, packageName);
+			List<CollectAssetInfo> allCollectAssetInfos = collectResult.CollectAssets;
+
+			// 2. 剔除未被引用的依赖项资源
+			RemoveZeroReferenceAssets(allCollectAssetInfos);
+
+			// 3. 录入所有收集器收集的资源
+			foreach (var collectAssetInfo in allCollectAssetInfos)
+			{
+				if (allBuildAssetInfos.ContainsKey(collectAssetInfo.AssetPath) == false)
+				{
+					if (collectAssetInfo.CollectorType != ECollectorType.MainAssetCollector)
+					{
+						if (collectAssetInfo.AssetTags.Count > 0)
+						{
+							collectAssetInfo.AssetTags.Clear();
+							BuildLogger.Warning($"The tags has been cleared ! {collectAssetInfo.AssetPath} ");
+						}
+					}
+
+					var buildAssetInfo = new BuildAssetInfo(collectAssetInfo.CollectorType, collectAssetInfo.BundleName, collectAssetInfo.Address, collectAssetInfo.AssetPath);
+					buildAssetInfo.AddAssetTags(collectAssetInfo.AssetTags);
+					allBuildAssetInfos.Add(collectAssetInfo.AssetPath, buildAssetInfo);
+				}
+				else
+				{
+					throw new Exception($"Should never get here !");
+				}
+			}
+
+			// 4. 录入所有收集资源的依赖资源
+			foreach (var collectAssetInfo in allCollectAssetInfos)
+			{
+				string bundleName = collectAssetInfo.BundleName;
+				foreach (var dependAssetPath in collectAssetInfo.DependAssets)
+				{
+					if (allBuildAssetInfos.ContainsKey(dependAssetPath))
+					{
+						allBuildAssetInfos[dependAssetPath].AddReferenceBundleName(bundleName);
+					}
+					else
+					{
+						var buildAssetInfo = new BuildAssetInfo(dependAssetPath);
+						buildAssetInfo.AddReferenceBundleName(bundleName);
+						allBuildAssetInfos.Add(dependAssetPath, buildAssetInfo);
+					}
+				}
+			}
+
+			// 5. 填充所有收集资源的依赖列表
+			foreach (var collectAssetInfo in allCollectAssetInfos)
+			{
+				var dependAssetInfos = new List<BuildAssetInfo>(collectAssetInfo.DependAssets.Count);
+				foreach (var dependAssetPath in collectAssetInfo.DependAssets)
+				{
+					if (allBuildAssetInfos.TryGetValue(dependAssetPath, out BuildAssetInfo value))
+						dependAssetInfos.Add(value);
+					else
+						throw new Exception("Should never get here !");
+				}
+				allBuildAssetInfos[collectAssetInfo.AssetPath].SetDependAssetInfos(dependAssetInfos);
+			}
+
+			// 6. 记录关键信息
+			BuildMapContext context = new BuildMapContext();
+			context.AssetFileCount = allBuildAssetInfos.Count;
+			context.Command = collectResult.Command;
+
+			// 7. 记录冗余资源
+			foreach (var buildAssetInfo in allBuildAssetInfos.Values)
+			{
+				if (buildAssetInfo.IsRedundancyAsset())
+				{
+					var redundancyInfo = new ReportRedundancyInfo();
+					redundancyInfo.AssetPath = buildAssetInfo.AssetPath;
+					redundancyInfo.AssetType = buildAssetInfo.AssetType.Name;
+					redundancyInfo.AssetGUID = buildAssetInfo.AssetGUID;
+					redundancyInfo.FileSize = FileUtility.GetFileSize(buildAssetInfo.AssetPath);
+					redundancyInfo.Number = buildAssetInfo.GetReferenceBundleCount();
+					context.RedundancyInfos.Add(redundancyInfo);
+				}
+			}
+
+			// 8. 移除不参与构建的资源
+			List<BuildAssetInfo> removeBuildList = new List<BuildAssetInfo>();
+			foreach (var buildAssetInfo in allBuildAssetInfos.Values)
+			{
+				if (buildAssetInfo.HasBundleName() == false)
+					removeBuildList.Add(buildAssetInfo);
+			}
+			foreach (var removeValue in removeBuildList)
+			{
+				allBuildAssetInfos.Remove(removeValue.AssetPath);
+			}
+
+			// 9. 构建资源列表
+			var allPackAssets = allBuildAssetInfos.Values.ToList();
+			if (allPackAssets.Count == 0)
+				throw new Exception("构建的资源列表不能为空");
+			foreach (var assetInfo in allPackAssets)
+			{
+				context.PackAsset(assetInfo);
+			}
+
+			return context;
+		}
+		private void RemoveZeroReferenceAssets(List<CollectAssetInfo> allCollectAssetInfos)
+		{
+			// 1. 检测是否任何存在依赖资源
+			if (allCollectAssetInfos.Exists(x => x.CollectorType == ECollectorType.DependAssetCollector) == false)
+				return;
+
+			// 2. 获取所有主资源的依赖资源集合
+			HashSet<string> allDependAsset = new HashSet<string>();
+			foreach (var collectAssetInfo in allCollectAssetInfos)
+			{
+				var collectorType = collectAssetInfo.CollectorType;
+				if (collectorType == ECollectorType.MainAssetCollector || collectorType == ECollectorType.StaticAssetCollector)
+				{
+					foreach (var dependAsset in collectAssetInfo.DependAssets)
+					{
+						if (allDependAsset.Contains(dependAsset) == false)
+							allDependAsset.Add(dependAsset);
+					}
+				}
+			}
+
+			// 3. 找出所有零引用的依赖资源集合
+			List<CollectAssetInfo> removeList = new List<CollectAssetInfo>();
+			foreach (var collectAssetInfo in allCollectAssetInfos)
+			{
+				var collectorType = collectAssetInfo.CollectorType;
+				if (collectorType == ECollectorType.DependAssetCollector)
+				{
+					if (allDependAsset.Contains(collectAssetInfo.AssetPath) == false)
+						removeList.Add(collectAssetInfo);
+				}
+			}
+
+			// 4. 移除所有零引用的依赖资源
+			foreach (var removeValue in removeList)
+			{
+				BuildLogger.Log($"发现未被依赖的资源并自动移除 : {removeValue.AssetPath}");
+				allCollectAssetInfos.Remove(removeValue);
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BaseTasks/TaskUpdateBundleInfo.cs

@@ -0,0 +1,75 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public abstract class TaskUpdateBundleInfo
+	{
+		public void UpdateBundleInfo(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.FileNameStyle;
+
+			// 1.检测文件名长度
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				// NOTE：检测文件名长度不要超过260字符。
+				string fileName = bundleInfo.BundleName;
+				if (fileName.Length >= 260)
+					throw new Exception($"The output bundle name is too long {fileName.Length} chars : {fileName}");
+			}
+
+			// 2.更新构建输出的文件路径
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				bundleInfo.BuildOutputFilePath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
+				if (bundleInfo.Encrypted)
+					bundleInfo.PackageSourceFilePath = bundleInfo.EncryptedFilePath;
+				else
+					bundleInfo.PackageSourceFilePath = bundleInfo.BuildOutputFilePath;
+			}
+
+			// 3.更新文件其它信息
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				bundleInfo.PackageUnityHash = GetUnityHash(bundleInfo, context);
+				bundleInfo.PackageUnityCRC = GetUnityCRC(bundleInfo, context);
+				bundleInfo.PackageFileHash = GetBundleFileHash(bundleInfo.PackageSourceFilePath, buildParametersContext);
+				bundleInfo.PackageFileCRC = GetBundleFileCRC(bundleInfo.PackageSourceFilePath, buildParametersContext);
+				bundleInfo.PackageFileSize = GetBundleFileSize(bundleInfo.PackageSourceFilePath, buildParametersContext);
+			}
+
+			// 4.更新补丁包输出的文件路径
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				string bundleName = bundleInfo.BundleName;
+				string fileHash = bundleInfo.PackageFileHash;
+				string fileExtension = ManifestTools.GetRemoteBundleFileExtension(bundleName);
+				string fileName = ManifestTools.GetRemoteBundleFileName(outputNameStyle, bundleName, fileExtension, fileHash);
+				bundleInfo.PackageDestFilePath = $"{packageOutputDirectory}/{fileName}";
+			}
+		}
+
+		protected abstract string GetUnityHash(BuildBundleInfo bundleInfo, BuildContext context);
+		protected abstract uint GetUnityCRC(BuildBundleInfo bundleInfo, BuildContext context);
+		protected abstract string GetBundleFileHash(string filePath, BuildParametersContext buildParametersContext);
+		protected abstract string GetBundleFileCRC(string filePath, BuildParametersContext buildParametersContext);
+		protected abstract long GetBundleFileSize(string filePath, BuildParametersContext buildParametersContext);
+
+		protected string GetFilePathTempHash(string filePath)
+		{
+			byte[] bytes = Encoding.UTF8.GetBytes(filePath);
+			return HashUtility.BytesMD5(bytes);
+
+			// 注意：在文件路径的哈希值冲突的情况下，可以使用下面的方法
+			//return $"{HashUtility.BytesMD5(bytes)}-{Guid.NewGuid():N}";
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 11bb85ea268af24479830c45b3b21962
+guid: 5c0a1b7e213a63047994bbf419867c64
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: d6268d725eec21b4aae819adc1553f0e
+guid: 950b38743cf6b74419af76ab327206ed
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskBuilding_BBP.cs

@@ -8,7 +8,7 @@ using UnityEngine;
 namespace YooAsset.Editor
 {
 	[TaskAttribute("资源构建内容打包")]
-	public class TaskBuilding : IBuildTask
+	public class TaskBuilding_BBP : IBuildTask
 	{
 		public class BuildResultContext : IContextObject
 		{
@@ -19,6 +19,7 @@ namespace YooAsset.Editor
 		{
 			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var builtinBuildParameters = buildParametersContext.Parameters as BuiltinBuildParameters;
 
 			// 模拟构建模式下跳过引擎构建
 			var buildMode = buildParametersContext.Parameters.BuildMode;
@@ -27,7 +28,7 @@ namespace YooAsset.Editor
 
 			// 开始构建
 			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
-			BuildAssetBundleOptions buildOptions = buildParametersContext.GetPipelineBuildOptions();
+			BuildAssetBundleOptions buildOptions = builtinBuildParameters.GetBundleBuildOptions();
 			AssetBundleManifest buildResults = BuildPipeline.BuildAssetBundles(pipelineOutputDirectory, buildMapContext.GetPipelineBuilds(), buildOptions, buildParametersContext.Parameters.BuildTarget);
 			if (buildResults == null)
 			{

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskBuilding_BBP.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: e9274735f1f14af4b893c21a4240b816
+guid: d10c8f8b9937fe848b2cb0cc0836280d
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskCopyBuildinFiles_BBP.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("拷贝内置文件")]
+	public class TaskCopyBuildinFiles_BBP : TaskCopyBuildinFiles, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var manifestContext = context.GetContextObject<ManifestContext>();
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+
+			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
+			{
+				if (buildParametersContext.Parameters.BuildinFileCopyOption != EBuildinFileCopyOption.None)
+				{
+					CopyBuildinFilesToStreaming(buildParametersContext, manifestContext.Manifest);
+				}
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskCopyBuildinFiles_BBP.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 24698266f028e4a47bb88f091fd64547
+guid: 80c30fb9eb35a514daadefa4a2fb4f28
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskCreateManifest_BBP.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("创建清单文件")]
+	public class TaskCreateManifest_BBP : TaskCreateManifest, IBuildTask
+	{
+		private TaskBuilding_BBP.BuildResultContext _buildResultContext = null;
+
+		void IBuildTask.Run(BuildContext context)
+		{
+			CreateManifestFile(context);
+		}
+
+		protected override string[] GetBundleDepends(BuildContext context, string bundleName)
+		{
+			if (_buildResultContext == null)
+				_buildResultContext = context.GetContextObject<TaskBuilding_BBP.BuildResultContext>();
+
+			return _buildResultContext.UnityManifest.GetAllDependencies(bundleName);
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskCreateManifest_BBP.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 9466e826c135e994c84961e4b921ca5f
+guid: db8a306d84a7b284f9acc8925cfaf812
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskCreatePackage_BBP.cs

@@ -0,0 +1,54 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("制作包裹")]
+	public class TaskCreatePackage_BBP : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode != EBuildMode.SimulateBuild && buildMode != EBuildMode.DryRunBuild)
+			{
+				CopyPackageFiles(buildParameters, buildMapContext);
+			}
+		}
+
+		/// <summary>
+		/// 拷贝补丁文件到补丁包目录
+		/// </summary>
+		private void CopyPackageFiles(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext)
+		{
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			BuildLogger.Log($"开始拷贝补丁文件到补丁包目录：{packageOutputDirectory}");
+
+			// 拷贝UnityManifest序列化文件
+			{
+				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);
+			}
+
+			// 拷贝所有补丁文件
+			int progressValue = 0;
+			int fileTotalCount = buildMapContext.Collection.Count;
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				EditorTools.CopyFile(bundleInfo.PackageSourceFilePath, bundleInfo.PackageDestFilePath, true);
+				EditorTools.DisplayProgressBar("拷贝补丁文件", ++progressValue, fileTotalCount);
+			}
+			EditorTools.ClearProgressBar();
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskCreatePackage_BBP.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: fe50795c51a46884088139b840c1557f
+guid: 509e58fe0b061a54795f60209fbbbb5a
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskCreateReport_BBP.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("创建构建报告文件")]
+	public class TaskCreateReport_BBP : TaskCreateReport, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var manifestContext = context.GetContextObject<ManifestContext>();
+
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode != EBuildMode.SimulateBuild)
+			{
+				CreateReportFile(buildParameters, buildMapContext, manifestContext);
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskCreateReport_BBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskEncryption_BBP.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("资源包加密")]
+	public class TaskEncryption_BBP : TaskEncryption, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
+			{
+				EncryptingBundleFiles(buildParameters, buildMapContext);
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskEncryption_BBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskGetBuildMap_BBP.cs

@@ -0,0 +1,20 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("获取资源构建内容")]
+	public class TaskGetBuildMap_BBP : TaskGetBuildMap, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = CreateBuildMap(buildParametersContext.Parameters);
+			context.SetContextObject(buildMapContext);
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskGetBuildMap_BBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskPrepare_BBP.cs

@@ -0,0 +1,30 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("资源构建准备工作")]
+	public class TaskPrepare_BBP : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = buildParametersContext.Parameters;
+			var builtinBuildParameters = buildParameters as BuiltinBuildParameters;
+
+			// 检测基础构建参数
+			buildParametersContext.CheckBuildParameters();
+
+			// 检测Unity版本
+#if UNITY_2021_3_OR_NEWER
+			if (buildParameters.BuildMode != EBuildMode.SimulateBuild)
+			{
+				BuildLogger.Warning("Unity2021版本开始内置构建管线不再维护，推荐使用可编程构建管线（SBP）！");
+			}
+#endif
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskPrepare_BBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskUpdateBundleInfo_BBP.cs

@@ -0,0 +1,79 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("更新资源包信息")]
+	public class TaskUpdateBundleInfo_BBP : TaskUpdateBundleInfo, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			UpdateBundleInfo(context);
+		}
+
+		protected override string GetUnityHash(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位
+			}
+			else
+			{
+				var buildResult = context.GetContextObject<TaskBuilding_BBP.BuildResultContext>();
+				var hash = buildResult.UnityManifest.GetAssetBundleHash(bundleInfo.BundleName);
+				if (hash.isValid)
+					return hash.ToString();
+				else
+					throw new Exception($"Not found bundle hash in build result : {bundleInfo.BundleName}");
+			}
+		}
+		protected override uint GetUnityCRC(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 0;
+			}
+			else
+			{
+				string filePath = bundleInfo.BuildOutputFilePath;
+				if (BuildPipeline.GetCRCForAssetBundle(filePath, out uint crc))
+					return crc;
+				else
+					throw new Exception($"Not found bundle crc in build result : {bundleInfo.BundleName}");
+			}
+		}
+		protected override string GetBundleFileHash(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.DryRunBuild || buildMode == EBuildMode.SimulateBuild)
+				return GetFilePathTempHash(filePath);
+			else
+				return HashUtility.FileMD5(filePath);
+		}
+		protected override 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);
+		}
+		protected override 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/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskUpdateBundleInfo_BBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuildTasks/TaskVerifyBuildResult_BBP.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("验证构建结果")]
+	public class TaskVerifyBuildResult_BBP : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = buildParametersContext.Parameters as BuiltinBuildParameters;
+
+			// 模拟构建模式下跳过验证
+			if (buildParameters.BuildMode == EBuildMode.SimulateBuild)
+				return;
+
+			// 验证构建结果
+			if (buildParameters.VerifyBuildingResult)
+			{
+				var buildResultContext = context.GetContextObject<TaskBuilding_BBP.BuildResultContext>();
+				VerifyingBuildingResult(context, buildResultContext.UnityManifest);
+			}
+		}
+
+		/// <summary>
+		/// 验证构建结果
+		/// </summary>
+		private void VerifyingBuildingResult(BuildContext context, AssetBundleManifest unityManifest)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			string[] unityCreateBundles = unityManifest.GetAllAssetBundles();
+
+			// 1. 过滤掉原生Bundle
+			string[] mapBundles = buildMapContext.Collection.Select(t => t.BundleName).ToArray();
+
+			// 2. 验证Bundle
+			List<string> exceptBundleList1 = unityCreateBundles.Except(mapBundles).ToList();
+			if (exceptBundleList1.Count > 0)
+			{
+				foreach (var exceptBundle in exceptBundleList1)
+				{
+					BuildLogger.Warning($"差异资源包: {exceptBundle}");
+				}
+				throw new System.Exception("存在差异资源包！请查看警告信息！");
+			}
+
+			// 3. 验证Bundle
+			List<string> exceptBundleList2 = mapBundles.Except(unityCreateBundles).ToList();
+			if (exceptBundleList2.Count > 0)
+			{
+				foreach (var exceptBundle in exceptBundleList2)
+				{
+					BuildLogger.Warning($"差异资源包: {exceptBundle}");
+				}
+				throw new System.Exception("存在差异资源包！请查看警告信息！");
+			}
+
+			BuildLogger.Log("构建结果验证成功！");
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuiltinBuildParameters.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class BuiltinBuildParameters : BuildParameters
+	{
+		/// <summary>
+		/// 压缩选项
+		/// </summary>
+		public ECompressOption CompressOption = ECompressOption.Uncompressed;
+
+		/// <summary>
+		/// 禁止写入类型树结构（可以降低包体和内存并提高加载效率）
+		/// </summary>
+		public bool DisableWriteTypeTree = false;
+
+		/// <summary>
+		/// 忽略类型树变化
+		/// </summary>
+		public bool IgnoreTypeTreeChanges = true;
+
+
+		/// <summary>
+		/// 获取内置构建管线的构建选项
+		/// </summary>
+		public BuildAssetBundleOptions GetBundleBuildOptions()
+		{
+			// 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 (BuildMode == EBuildMode.DryRunBuild)
+			{
+				opt |= BuildAssetBundleOptions.DryRunBuild;
+				return opt;
+			}
+
+			if (CompressOption == ECompressOption.Uncompressed)
+				opt |= BuildAssetBundleOptions.UncompressedAssetBundle;
+			else if (CompressOption == ECompressOption.LZ4)
+				opt |= BuildAssetBundleOptions.ChunkBasedCompression;
+
+			if (BuildMode == EBuildMode.ForceRebuild)
+				opt |= BuildAssetBundleOptions.ForceRebuildAssetBundle; //Force rebuild the asset bundles
+			if (DisableWriteTypeTree)
+				opt |= BuildAssetBundleOptions.DisableWriteTypeTree; //Do not include type information within the asset bundle (don't write type tree).
+			if (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;
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuiltinBuildParameters.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuiltinBuildPipeline.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Linq;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class BuiltinBuildPipeline : IBuildPipeline
+	{
+		public BuildResult Run(BuildParameters buildParameters, bool enableLog)
+		{
+			AssetBundleBuilder builder = new AssetBundleBuilder();
+			return builder.Run(buildParameters, GetDefaultBuildPipeline(), enableLog);
+		}
+
+		/// <summary>
+		/// 获取默认的构建流程
+		/// </summary>
+		private List<IBuildTask> GetDefaultBuildPipeline()
+		{
+			List<IBuildTask> pipeline = new List<IBuildTask>
+				{
+					new TaskPrepare_BBP(), //前期准备工作
+					new TaskGetBuildMap_BBP(), //获取构建列表
+					new TaskBuilding_BBP(), //开始执行构建
+					new TaskVerifyBuildResult_BBP(), //验证构建结果
+					new TaskUpdateBundleInfo_BBP(), //更新资源包信息
+					new TaskCreateManifest_BBP(), //创建清单文件
+					new TaskCreateReport_BBP(), //创建报告文件
+					new TaskCreatePackage_BBP(), //制作包裹
+					new TaskCopyBuildinFiles_BBP(), //拷贝内置文件
+				};
+			return pipeline;
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/BuiltinBuildPipeline/BuiltinBuildPipeline.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 10823e059e253a04083b6122027db930
+guid: 8a5f30f9c58f36946b2028bddce08c9c
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 141f7d1ebdf7cc147801aa711e29ac17
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskBuilding_RFBP.cs

@@ -5,8 +5,8 @@ using System.Collections.Generic;
 
 namespace YooAsset.Editor
 {
-	[TaskAttribute("拷贝原生文件")]
-	public class TaskCopyRawFile : IBuildTask
+	[TaskAttribute("资源构建内容打包")]
+	public class TaskBuilding_RFBP : IBuildTask
 	{
 		void IBuildTask.Run(BuildContext context)
 		{
@@ -27,16 +27,12 @@ namespace YooAsset.Editor
 		private void CopyRawBundle(BuildMapContext buildMapContext, BuildParametersContext buildParametersContext)
 		{
 			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
-			foreach (var bundleInfo in buildMapContext.BundleInfos)
+			foreach (var bundleInfo in buildMapContext.Collection)
 			{
-				if (bundleInfo.IsRawFile)
+				string dest = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
+				foreach (var assetInfo in bundleInfo.MainAssets)
 				{
-					string dest = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
-					foreach (var buildAsset in bundleInfo.BuildinAssets)
-					{
-						if (buildAsset.IsRawAsset)
-							EditorTools.CopyFile(buildAsset.AssetPath, dest, true);
-					}
+					EditorTools.CopyFile(assetInfo.AssetPath, dest, true);
 				}
 			}
 		}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskCopyBuildinFiles_RFBP.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("拷贝内置文件")]
+	public class TaskCopyBuildinFiles_RFBP : TaskCopyBuildinFiles, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = buildParametersContext.Parameters;
+			var manifestContext = context.GetContextObject<ManifestContext>();
+
+			if (buildParameters.BuildMode != EBuildMode.SimulateBuild)
+			{
+				if (buildParameters.BuildinFileCopyOption != EBuildinFileCopyOption.None)
+				{
+					CopyBuildinFilesToStreaming(buildParametersContext, manifestContext.Manifest);
+				}
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskCopyBuildinFiles_RFBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskCreateManifest_RFBP.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("创建清单文件")]
+	public class TaskCreateManifest_RFBP : TaskCreateManifest, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			CreateManifestFile(context);
+		}
+
+		protected override string[] GetBundleDepends(BuildContext context, string bundleName)
+		{
+			return new string[] { };
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskCreateManifest_RFBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskCreatePackage_RFBP.cs

@@ -0,0 +1,41 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("制作包裹")]
+	public class TaskCreatePackage_RFBP : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode != EBuildMode.SimulateBuild)
+			{
+				CopyPackageFiles(buildParameters, buildMapContext);
+			}
+		}
+
+		/// <summary>
+		/// 拷贝补丁文件到补丁包目录
+		/// </summary>
+		private void CopyPackageFiles(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext)
+		{
+			var buildParameters = buildParametersContext.Parameters;
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			BuildLogger.Log($"开始拷贝补丁文件到补丁包目录：{packageOutputDirectory}");
+
+			// 拷贝所有补丁文件
+			int progressValue = 0;
+			int fileTotalCount = buildMapContext.Collection.Count;
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				EditorTools.CopyFile(bundleInfo.PackageSourceFilePath, bundleInfo.PackageDestFilePath, true);
+				EditorTools.DisplayProgressBar("拷贝补丁文件", ++progressValue, fileTotalCount);
+			}
+			EditorTools.ClearProgressBar();
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskCreatePackage_RFBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskCreateReport_RFBP.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("创建构建报告文件")]
+	public class TaskCreateReport_RFBP : TaskCreateReport, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var manifestContext = context.GetContextObject<ManifestContext>();
+
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode != EBuildMode.SimulateBuild)
+			{
+				CreateReportFile(buildParameters, buildMapContext, manifestContext);
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskCreateReport_RFBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskGetBuildMap_RFBP.cs

@@ -0,0 +1,36 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("获取资源构建内容")]
+	public class TaskGetBuildMap_RFBP : TaskGetBuildMap, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = CreateBuildMap(buildParametersContext.Parameters);
+			context.SetContextObject(buildMapContext);
+
+			// 检测构建结果
+			CheckBuildMapContent(buildMapContext);
+		}
+
+		/// <summary>
+		/// 检测资源构建上下文
+		/// </summary>
+		private void CheckBuildMapContent(BuildMapContext buildMapContext)
+		{
+			// 注意：原生文件资源包只能包含一个原生文件
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				if (bundleInfo.MainAssets.Count != 1)
+					throw new Exception($"The bundle does not support multiple raw asset : {bundleInfo.BundleName}");
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskGetBuildMap_RFBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskPrepare_RFBP.cs

@@ -0,0 +1,27 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("资源构建准备工作")]
+	public class TaskPrepare_RFBP : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = buildParametersContext.Parameters;
+
+			// 检测基础构建参数
+			buildParametersContext.CheckBuildParameters();
+
+			// 检测不被支持的构建模式
+			if (buildParameters.BuildMode == EBuildMode.DryRunBuild)
+				throw new Exception($"{nameof(EBuildPipeline.ScriptableBuildPipeline)} not support {nameof(EBuildMode.DryRunBuild)} build mode !");
+			if (buildParameters.BuildMode == EBuildMode.IncrementalBuild)
+				throw new Exception($"{nameof(EBuildPipeline.ScriptableBuildPipeline)} not support {nameof(EBuildMode.IncrementalBuild)} build mode !");
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskPrepare_RFBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskUpdateBundleInfo_RFBP.cs

@@ -0,0 +1,61 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("更新资源包信息")]
+	public class TaskUpdateBundleInfo_RFBP : TaskUpdateBundleInfo, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			UpdateBundleInfo(context);
+		}
+
+		protected override string GetUnityHash(BuildBundleInfo bundleInfo, BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var parameters = buildParametersContext.Parameters;
+			var buildMode = parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+			{
+				return "00000000000000000000000000000000"; //32位
+			}
+			else
+			{
+				string filePath = bundleInfo.PackageSourceFilePath;
+				return HashUtility.FileMD5(filePath);
+			}
+		}
+		protected override uint GetUnityCRC(BuildBundleInfo bundleInfo, BuildContext context)
+		{
+			return 0;
+		}
+		protected override string GetBundleFileHash(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+				return GetFilePathTempHash(filePath);
+			else
+				return HashUtility.FileMD5(filePath);
+		}
+		protected override string GetBundleFileCRC(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+				return "00000000"; //8位
+			else
+				return HashUtility.FileCRC32(filePath);
+		}
+		protected override long GetBundleFileSize(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+				return 0;
+			else
+				return FileUtility.GetFileSize(filePath);
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/BuildTasks/TaskUpdateBundleInfo_RFBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/RawFileBuildParameters.cs

@@ -0,0 +1,10 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class RawFileBuildParameters : BuildParameters
+	{
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/RawFileBuildParameters.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/RawFileBuildPipeline.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Linq;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	public class RawFileBuildPipeline : IBuildPipeline
+	{
+		public BuildResult Run(BuildParameters buildParameters, bool enableLog)
+		{
+			AssetBundleBuilder builder = new AssetBundleBuilder();
+			return builder.Run(buildParameters, GetDefaultBuildPipeline(), enableLog);
+		}
+
+		/// <summary>
+		/// 获取默认的构建流程
+		/// </summary>
+		private List<IBuildTask> GetDefaultBuildPipeline()
+		{
+			List<IBuildTask> pipeline = new List<IBuildTask>
+				{
+					new TaskPrepare_RFBP(), //前期准备工作
+					new TaskGetBuildMap_RFBP(), //获取构建列表
+					new TaskBuilding_RFBP(), //开始执行构建
+					new TaskUpdateBundleInfo_RFBP(), //更新资源包信息
+					new TaskCreateManifest_RFBP(), //创建清单文件
+					new TaskCreateReport_RFBP(), //创建报告文件
+					new TaskCreatePackage_RFBP(), //制作包裹
+					new TaskCopyBuildinFiles_RFBP(), //拷贝内置文件
+				};
+			return pipeline;
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/RawFileBuildPipeline/RawFileBuildPipeline.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c8b9d8597bfdc994e9ef52f319cc96ec
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 64c9242d4708b1f47b1469897bbfe127
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -2,7 +2,6 @@
 using System.Linq;
 using System.Collections;
 using System.Collections.Generic;
-
 using UnityEditor.Build.Pipeline;
 using UnityEditor.Build.Pipeline.Interfaces;
 using UnityEditor.Build.Pipeline.Tasks;
@@ -21,6 +20,7 @@ namespace YooAsset.Editor
 		{
 			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var scriptableBuildParameters = buildParametersContext.Parameters as ScriptableBuildParameters;
 
 			// 模拟构建模式下跳过引擎构建
 			var buildMode = buildParametersContext.Parameters.BuildMode;
@@ -32,14 +32,23 @@ namespace YooAsset.Editor
 
 			// 开始构建
 			IBundleBuildResults buildResults;
-			var buildParameters = buildParametersContext.GetSBPBuildParameters();
-			var taskList = SBPBuildTasks.Create(buildMapContext.ShadersBundleName);
+			var buildParameters = scriptableBuildParameters.GetBundleBuildParameters();
+			var taskList = SBPBuildTasks.Create(buildMapContext.Command.ShadersBundleName);
 			ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out buildResults, taskList);
 			if (exitCode < 0)
 			{
 				throw new Exception($"构建过程中发生错误 : {exitCode}");
 			}
 
+			// 创建着色器信息
+			// 说明：解决因为着色器资源包导致验证失败。
+			// 例如：当项目里没有着色器，如果有依赖内置着色器就会验证失败。
+			string shadersBundleName = buildMapContext.Command.ShadersBundleName;
+			if (buildResults.BundleInfos.ContainsKey(shadersBundleName))
+			{
+				buildMapContext.CreateShadersBundleInfo(shadersBundleName);
+			}
+
 			BuildLogger.Log("Unity引擎打包成功！");
 			BuildResultContext buildResultContext = new BuildResultContext();
 			buildResultContext.Results = buildResults;

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 1af5fed7e9f83174d868c12b41c4a79e
+guid: 255306458772c8b4eb94ca288dfc77ac
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskCopyBuildinFiles_SBP.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("拷贝内置文件")]
+	public class TaskCopyBuildinFiles_SBP : TaskCopyBuildinFiles, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var manifestContext = context.GetContextObject<ManifestContext>();
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+
+			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
+			{
+				if (buildParametersContext.Parameters.BuildinFileCopyOption != EBuildinFileCopyOption.None)
+				{
+					CopyBuildinFilesToStreaming(buildParametersContext, manifestContext.Manifest);
+				}
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskCopyBuildinFiles_SBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskCreateManifest_SBP.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor.Build.Pipeline;
+using UnityEditor.Build.Pipeline.Interfaces;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("创建清单文件")]
+	public class TaskCreateManifest_SBP : TaskCreateManifest, IBuildTask
+	{
+		private TaskBuilding_SBP.BuildResultContext _buildResultContext = null;
+
+		void IBuildTask.Run(BuildContext context)
+		{
+			CreateManifestFile(context);
+		}
+
+		protected override string[] GetBundleDepends(BuildContext context, string bundleName)
+		{
+			if (_buildResultContext == null)
+				_buildResultContext = context.GetContextObject<TaskBuilding_SBP.BuildResultContext>();
+
+			if (_buildResultContext.Results.BundleInfos.ContainsKey(bundleName) == false)
+				throw new Exception($"Not found bundle in SBP build results : {bundleName}");
+			return _buildResultContext.Results.BundleInfos[bundleName].Dependencies;
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskCreateManifest_SBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskCreatePackage_SBP.cs

@@ -0,0 +1,56 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("制作包裹")]
+	public class TaskCreatePackage_SBP : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode != EBuildMode.SimulateBuild)
+			{
+				CopyPackageFiles(buildParameters, buildMapContext);
+			}
+		}
+
+		/// <summary>
+		/// 拷贝补丁文件到补丁包目录
+		/// </summary>
+		private void CopyPackageFiles(BuildParametersContext buildParametersContext, BuildMapContext buildMapContext)
+		{
+			var scriptableBuildParameters = buildParametersContext.Parameters as ScriptableBuildParameters;
+			string pipelineOutputDirectory = buildParametersContext.GetPipelineOutputDirectory();
+			string packageOutputDirectory = buildParametersContext.GetPackageOutputDirectory();
+			BuildLogger.Log($"开始拷贝补丁文件到补丁包目录：{packageOutputDirectory}");
+
+			// 拷贝构建日志
+			{
+				string sourcePath = $"{pipelineOutputDirectory}/buildlogtep.json";
+				string destPath = $"{packageOutputDirectory}/buildlogtep.json";
+				EditorTools.CopyFile(sourcePath, destPath, true);
+			}
+
+			// 拷贝代码防裁剪配置
+			if (scriptableBuildParameters.WriteLinkXML)
+			{
+				string sourcePath = $"{pipelineOutputDirectory}/link.xml";
+				string destPath = $"{packageOutputDirectory}/link.xml";
+				EditorTools.CopyFile(sourcePath, destPath, true);
+			}
+
+			// 拷贝所有补丁文件
+			int progressValue = 0;
+			int fileTotalCount = buildMapContext.Collection.Count;
+			foreach (var bundleInfo in buildMapContext.Collection)
+			{
+				EditorTools.CopyFile(bundleInfo.PackageSourceFilePath, bundleInfo.PackageDestFilePath, true);
+				EditorTools.DisplayProgressBar("拷贝补丁文件", ++progressValue, fileTotalCount);
+			}
+			EditorTools.ClearProgressBar();
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskCreatePackage_SBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskCreateReport_SBP.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("创建构建报告文件")]
+	public class TaskCreateReport_SBP : TaskCreateReport, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+			var manifestContext = context.GetContextObject<ManifestContext>();
+
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode != EBuildMode.SimulateBuild)
+			{
+				CreateReportFile(buildParameters, buildMapContext, manifestContext);
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskCreateReport_SBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskEncryption_SBP.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("资源包加密")]
+	public class TaskEncryption_SBP : TaskEncryption, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParameters = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = context.GetContextObject<BuildMapContext>();
+
+			var buildMode = buildParameters.Parameters.BuildMode;
+			if (buildMode == EBuildMode.ForceRebuild || buildMode == EBuildMode.IncrementalBuild)
+			{
+				EncryptingBundleFiles(buildParameters, buildMapContext);
+			}
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskEncryption_SBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskGetBuildMap_SBP.cs

@@ -0,0 +1,20 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("获取资源构建内容")]
+	public class TaskGetBuildMap_SBP : TaskGetBuildMap, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildMapContext = CreateBuildMap(buildParametersContext.Parameters);
+			context.SetContextObject(buildMapContext);
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskGetBuildMap_SBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskPrepare_SBP.cs

@@ -0,0 +1,27 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("资源构建准备工作")]
+	public class TaskPrepare_SBP : IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = buildParametersContext.Parameters;
+
+			// 检测基础构建参数
+			buildParametersContext.CheckBuildParameters();
+
+			// 检测不被支持的构建模式
+			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 !");
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskPrepare_SBP.cs.meta

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

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskUpdateBundleInfo_SBP.cs

@@ -0,0 +1,79 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+	[TaskAttribute("更新资源包信息")]
+	public class TaskUpdateBundleInfo_SBP : TaskUpdateBundleInfo, IBuildTask
+	{
+		void IBuildTask.Run(BuildContext context)
+		{
+			UpdateBundleInfo(context);
+		}
+
+		protected override string GetUnityHash(BuildBundleInfo bundleInfo, BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var parameters = buildParametersContext.Parameters;
+			var buildMode = parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+			{
+				return "00000000000000000000000000000000"; //32位
+			}
+			else
+			{
+				// 注意：当资源包的依赖列表发生变化的时候，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 hash in build result : {bundleInfo.BundleName}");
+			}
+		}
+		protected override uint GetUnityCRC(BuildBundleInfo bundleInfo, BuildContext context)
+		{
+			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var parameters = buildParametersContext.Parameters;
+			var buildMode = parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+			{
+				return 0;
+			}
+			else
+			{
+				var buildResult = context.GetContextObject<TaskBuilding_SBP.BuildResultContext>();
+				if (buildResult.Results.BundleInfos.TryGetValue(bundleInfo.BundleName, out var value))
+					return value.Crc;
+				else
+					throw new Exception($"Not found bundle crc in build result : {bundleInfo.BundleName}");
+			}
+		}
+		protected override string GetBundleFileHash(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+				return GetFilePathTempHash(filePath);
+			else
+				return HashUtility.FileMD5(filePath);
+		}
+		protected override string GetBundleFileCRC(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+				return "00000000"; //8位
+			else
+				return HashUtility.FileCRC32(filePath);
+		}
+		protected override long GetBundleFileSize(string filePath, BuildParametersContext buildParametersContext)
+		{
+			var buildMode = buildParametersContext.Parameters.BuildMode;
+			if (buildMode == EBuildMode.SimulateBuild)
+				return 0;
+			else
+				return FileUtility.GetFileSize(filePath);
+		}
+	}
+}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasks/TaskUpdateBundleInfo_SBP.cs.meta

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

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

@@ -3,8 +3,8 @@ using System.Linq;
 using System.IO;
 using System.Collections;
 using System.Collections.Generic;
-using UnityEditor;
 using UnityEngine;
+using UnityEditor;
 using UnityEditor.Build.Pipeline.Interfaces;
 
 namespace YooAsset.Editor
@@ -15,13 +15,14 @@ namespace YooAsset.Editor
 		void IBuildTask.Run(BuildContext context)
 		{
 			var buildParametersContext = context.GetContextObject<BuildParametersContext>();
+			var buildParameters = buildParametersContext.Parameters as ScriptableBuildParameters;
 
 			// 模拟构建模式下跳过验证
-			if (buildParametersContext.Parameters.BuildMode == EBuildMode.SimulateBuild)
+			if (buildParameters.BuildMode == EBuildMode.SimulateBuild)
 				return;
 
 			// 验证构建结果
-			if (buildParametersContext.Parameters.VerifyBuildingResult)
+			if (buildParameters.VerifyBuildingResult)
 			{
 				var buildResultContext = context.GetContextObject<TaskBuilding_SBP.BuildResultContext>();
 				VerifyingBuildingResult(context, buildResultContext.Results);
@@ -35,29 +36,29 @@ namespace YooAsset.Editor
 		{
 			var buildParameters = context.GetContextObject<BuildParametersContext>();
 			var buildMapContext = context.GetContextObject<BuildMapContext>();
-			List<string> buildedBundles = buildResults.BundleInfos.Keys.ToList();
+			List<string> unityCreateBundles = buildResults.BundleInfos.Keys.ToList();
 
 			// 1. 过滤掉原生Bundle
-			List<string> expectBundles = buildMapContext.BundleInfos.Where(t => t.IsRawFile == false).Select(t => t.BundleName).ToList();
+			List<string> expectBundles = buildMapContext.Collection.Select(t => t.BundleName).ToList();
 
 			// 2. 验证Bundle
-			List<string> exceptBundleList1 = buildedBundles.Except(expectBundles).ToList();
+			List<string> exceptBundleList1 = unityCreateBundles.Except(expectBundles).ToList();
 			if (exceptBundleList1.Count > 0)
 			{
 				foreach (var exceptBundle in exceptBundleList1)
 				{
-					Debug.LogWarning($"差异资源包: {exceptBundle}");
+					BuildLogger.Warning($"差异资源包: {exceptBundle}");
 				}
 				throw new System.Exception("存在差异资源包！请查看警告信息！");
 			}
 
 			// 3. 验证Bundle
-			List<string> exceptBundleList2 = expectBundles.Except(buildedBundles).ToList();
+			List<string> exceptBundleList2 = expectBundles.Except(unityCreateBundles).ToList();
 			if (exceptBundleList2.Count > 0)
 			{
 				foreach (var exceptBundle in exceptBundleList2)
 				{
-					Debug.LogWarning($"差异资源包: {exceptBundle}");
+					BuildLogger.Warning($"差异资源包: {exceptBundle}");
 				}
 				throw new System.Exception("存在差异资源包！请查看警告信息！");
 			}