Update CHANGELOG.md

修复HostPlayMode初始化卡死问题。

.gitignore

@@ -20,7 +20,6 @@
 /Assets/StreamingAssets.meta
 /Assets/Samples
 /Assets/Samples.meta
-/Packages
 /UserSettings
 
 

Assets/YooAsset/CHANGELOG.md

@@ -2,75 +2,235 @@
 
 All notable changes to this package will be documented in this file.
 
-## [2.0.3-preview] - 2023-10-27
+## [2.2.4-preview] - 2024-08-15
 
 ### Fixed
 
-- (#180) Fixed an issue with invalid encryption task in the build pipeline.
+- 修复了HostPlayMode初始化卡死的问题。
-- (#185) Fixed subscene unload error when the scene is not loaded.
+
-- (#190) Fixed webgl platform compile error.
+## [2.2.3-preview] - 2024-08-13
+
+### Fixed
+
+- (#311) 修复了断点续传下载器极小概率报错 : “416 Range Not Satisfiable”
 
 ### Improvements
 
-- The asset load method add the priority parameter.
+- 原生文件构建管线支持原生文件加密。
-- The async operation class add the priority field.
+
+- HostPlayMode模式下内置文件系统初始化参数可以为空。
+
+- 场景加载增加了LocalPhysicsMode参数来控制物理运行模式。
+
+- 默认的内置文件系统和缓存文件系统增加解密方法。
+
+  ```csharp
+  /// <summary>
+  /// 创建默认的内置文件系统参数
+  /// </summary>
+  /// <param name="decryptionServices">加密文件解密服务类</param>
+  /// <param name="verifyLevel">缓存文件的校验等级</param>
+  /// <param name="rootDirectory">内置文件的根路径</param>
+  public static FileSystemParameters CreateDefaultBuildinFileSystemParameters(IDecryptionServices decryptionServices, EFileVerifyLevel verifyLevel, string rootDirectory);
+  
+  /// <summary>
+  /// 创建默认的缓存文件系统参数
+  /// </summary>
+  /// <param name="remoteServices">远端资源地址查询服务类</param>
+  /// <param name="decryptionServices">加密文件解密服务类</param>
+  /// <param name="verifyLevel">缓存文件的校验等级</param>
+  /// <param name="rootDirectory">文件系统的根目录</param>
+  public static FileSystemParameters CreateDefaultCacheFileSystemParameters(IRemoteServices remoteServices, IDecryptionServices decryptionServices, EFileVerifyLevel verifyLevel, string rootDirectory);
+  ```
+
+## [2.2.2-preview] - 2024-07-31
+
+### Fixed
+
+- (#321) 修复了在Unity2022里编辑器下离线模式运行失败的问题。
+- (#325) 修复了在Unity2019里编译报错问题。
+
+## [2.2.1-preview] - 2024-07-10
+
+统一了所有PlayMode的初始化逻辑，EditorSimulateMode和OfflinePlayMode初始化不再主动加载资源清单！
 
 ### Added
 
-- The InitializeParameters calss add new parameter : AutoDestroyAssetProvider
+- 新增了IFileSystem.ReadFileData方法，支持原生文件自定义获取文本和二进制数据。
 
-  ```c#
+### Improvements
+
+- 优化了DefaultWebFileSystem和DefaultBuildFileSystem文件系统的内部初始化逻辑。
+
+## [2.2.0-preview] - 2024-07-07
+
+重构了运行时代码，新增了文件系统接口（IFileSystem）方便开发者扩展特殊需求。
+
+新增微信小游戏文件系统示例代码，详细见Extension Sample/Runtime/WechatFileSystem
+
+### Added
+
+- 新增了ResourcePackage.DestroyAsync方法
+
+- 新增了FileSystemParameters类帮助初始化文件系统
+
+  内置了编辑器文件系统参数，内置文件系统参数，缓存文件系统参数，Web文件系统参数。
+
+  ```csharp
+  public class FileSystemParameters
+  {
       /// <summary>
-  /// 自动销毁不再使用的资源提供者
+      /// 文件系统类
       /// </summary>
-  public bool AutoDestroyAssetProvider = false;
+      public string FileSystemClass { private set; get; }
+      
+      /// <summary>
+      /// 文件系统的根目录
+      /// </summary>
+      public string RootDirectory { private set; get; }   
+      
+      /// <summary>
+      /// 添加自定义参数
+      /// </summary>
+      public void AddParameter(string name, object value)    
+  }
   ```
 
-- Resource package add TryUnloadUnusedAsset function.
+### Changed
 
-  ```c#
+- 重构了InitializeParameters初始化参数
-  /// <summary>
+- 重命名YooAssets.DestroyPackage方法为RemovePackage
-  /// 尝试卸载指定资源的资源包（包括依赖资源）
+- 重命名ResourcePackage.UpdatePackageVersionAsync方法为RequestPackageVersionAsync
-  /// </summary>
+- 重命名ResourcePackage.UnloadUnusedAssets方法为UnloadUnusedAssetsAsync
-  public void TryUnloadUnusedAsset(AssetInfo assetInfo)
+- 重命名ResourcePackage.ForceUnloadAllAssets方法为UnloadAllAssetsAsync
-  ```
+- 重命名ResourcePackage.ClearUnusedCacheFilesAsync方法为ClearUnusedBundleFilesAsync
+- 重命名ResourcePackage.ClearAllCacheFilesAsync方法为ClearAllBundleFilesAsync
 
 ### Removed
 
-- The InitializeParameters calss remove the parameter : LoadingMaxTimeSlice 
+- 移除了YooAssets.Destroy方法
+- 移除了YooAssets.SetDownloadSystemClearFileResponseCode方法
+- 移除了YooAssets.SetCacheSystemDisableCacheOnWebGL方法
+- 移除了ResourcePackage.GetPackageBuildinRootDirectory方法
+- 移除了ResourcePackage.GetPackageSandboxRootDirectory方法
+- 移除了ResourcePackage.ClearPackageSandbox方法
+- 移除了IBuildinQueryServices接口
+- 移除了IDeliveryLoadServices接口
+- 移除了IDeliveryQueryServices接口
 
-## [2.0.2-preview] - 2023-10-17
+
+## [2.1.2] - 2024-05-16
+
+SBP库依赖版本升级至2.1.3
 
 ### Fixed
 
-- Fixed the mistaken code in the build window.
+- (#236) 修复了资源配置界面AutoCollectShader复选框没有刷新的问题。
-- Fixed an issue where auto collect shaders was not effective for dependent resources.
+- (#244) 修复了导入器在安卓平台导入本地下载的资源失败的问题。
-
+- (#268) 修复了挂起场景未解除状态前无法卸载的问题。
-### Improvements
+- (#269) 优化场景挂起流程，支持中途取消挂起操作。
-
+- (#276) 修复了HostPlayMode模式下，如果内置清单是最新版本，每次运行都会触发拷贝行为。
-- Add error code for exception output during package building.
+- (#289) 修复了Unity2019版本脚本IWebRequester编译报错。
-
+- (#295) 解决了在安卓移动平台，华为和三星真机上有极小概率加载资源包失败 : Unable to open archive file
-## [2.0.1-preview] - 2023-10-11
-
-### Fixed
-
-- (#175) Fixed a bug where the url path of mac platform contains spaces, which would cause the request error.
-- (#177) Fixed the inability to load main asset object after loading the sub asset.
-- (#178) Fixed the error when initializing resource package that prompted not initialized.
-- (#179) Fixed issue with SBP build pipeline packaging reporting errors.
 
 ### Added
 
-- Resource downloader add combine function.
+- 新增GetAllCacheFileInfosOperation()获取缓存文件信息的方法。
+
+- 新增LoadSceneSync()同步加载场景的方法。
+
+- 新增IIgnoreRule接口，资源收集流程可以自定义。
+
+- 新增IWechatQueryServices接口，用于微信平台本地文件查询。
+
+  后续将会通过虚拟文件系统来支持！
+
+### Changed
+
+- 调整了UnloadSceneOperation代码里场景的卸载顺序。
+
+### Improvements
+
+- 优化了资源清单的解析过程。
+- 移除资源包名里的空格字符。
+- 支持华为鸿蒙系统。
+
+## [2.1.1] - 2024-01-17
+
+### Fixed
+
+- (#224)  修复了编辑器模式打包时 SimulateBuild 报错的问题。
+- (#223)  修复了资源构建界面读取配置导致的报错问题。
+
+### Added
+
+- 支持共享资源打包规则，可以定制化独立的构建规则。
 
   ```c#
+  public class BuildParameters
+  {
      /// <summary>
-  /// 合并其它下载器
+      /// 是否启用共享资源打包
       /// </summary>
-  /// <param name="downloader">合并的下载器</param>
+      public bool EnableSharePackRule = false; 
-  public void Combine(DownloaderOperation downloader);
+  }
   ```
 
-## [2.0.0-preview] - 2023-10-07
+- 微信小游戏平台，资源下载器支持底层缓存查询。
+
+## [2.1.0] - 2023-12-27
+
+升级了 Scriptable build pipeline (SBP) 的版本，来解决图集引用的精灵图片冗余问题。
+
+### Fixed
+
+- (#195) 修复了在EditorPlayMode模式下，AssetHandle.GetDownloadStatus()发生异常的问题。
+- (#201) 修复了断点续传失效的问题。
+- (#202) 修复了打包参数FileNameStyle设置为BundleName后，IQueryServices会一直返回true的问题。
+- (#205) 修复了HybridCLR插件里创建资源下载器触发的异常。
+- (#210) 修复了DownloaderOperation在未开始下载前，内部的PackageName为空的问题。
+- (#220) 修复了资源收集界面关闭后，撤回操作还会生效的问题。
+- 修复了下载器合并后重新计算下载字节数不正确的问题。
+
+### Improvements
+
+- (#198) 资源收集界面禁用的分组不再检测合法性。
+- (#203) 资源构建类容许自定义打包的输出目录。
+- 资源构建报告增加未依赖的资源信息列表。
+
+### Changed
+
+- IBuildinQueryServices和IDeliveryQueryServices查询方法变更。
+
+  ```c#
+      public interface IBuildinQueryServices
+      {
+          /// <summary>
+          /// 查询是否为应用程序内置的资源文件
+          /// </summary>
+          /// <param name="packageName">包裹名称</param>
+          /// <param name="fileName">文件名称（包含文件的后缀格式）</param>
+          /// <param name="fileCRC">文件哈希值</param>
+          /// <returns>返回查询结果</returns>
+          bool Query(string packageName, string fileName, string fileCRC);
+      }
+  
+     	public interface IDeliveryQueryServices
+      {
+          /// <summary>
+          /// 查询是否为开发者分发的资源文件
+          /// </summary>
+          /// <param name="packageName">包裹名称</param>
+          /// <param name="fileName">文件名称（包含文件的后缀格式）</param>
+          /// <param name="fileCRC">文件哈希值</param>
+          /// <returns>返回查询结果</returns>
+          bool Query(string packageName, string fileName, string fileCRC);
+      }
+  ```
+
+  
+
+### Removed
+
+- (#212)  移除了构建报告里的资源冗余信息列表。
 
-This is the preview version.

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleBuilderHelper.cs

@@ -9,7 +9,7 @@ namespace YooAsset.Editor
     public static class AssetBundleBuilderHelper
     {
         /// <summary>
-		/// 获取默认的输出根路录
+        /// 获取默认的输出根目录
         /// </summary>
         public static string GetDefaultBuildOutputRoot()
         {

Assets/YooAsset/Editor/AssetBundleBuilder/AssetBundleSimulateBuilder.cs

@@ -8,8 +8,11 @@ namespace YooAsset.Editor
         /// <summary>
         /// 模拟构建
         /// </summary>
-		public static string SimulateBuild(string buildPipelineName, string packageName)
+        public static SimulateBuildResult SimulateBuild(string buildPipelineName, string packageName)
         {
+            string packageVersion = "Simulate";
+            BuildResult buildResult;
+
             if (buildPipelineName == EBuildPipeline.BuiltinBuildPipeline.ToString())
             {
                 BuiltinBuildParameters buildParameters = new BuiltinBuildParameters();
@@ -19,23 +22,13 @@ namespace YooAsset.Editor
                 buildParameters.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
                 buildParameters.BuildMode = EBuildMode.SimulateBuild;
                 buildParameters.PackageName = packageName;
-				buildParameters.PackageVersion = "Simulate";
+                buildParameters.PackageVersion = packageVersion;
                 buildParameters.FileNameStyle = EFileNameStyle.HashName;
                 buildParameters.BuildinFileCopyOption = EBuildinFileCopyOption.None;
                 buildParameters.BuildinFileCopyParams = string.Empty;
 
                 BuiltinBuildPipeline pipeline = new BuiltinBuildPipeline();
-				var buildResult = pipeline.Run(buildParameters, false);
+                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())
             {
@@ -46,23 +39,13 @@ namespace YooAsset.Editor
                 buildParameters.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
                 buildParameters.BuildMode = EBuildMode.SimulateBuild;
                 buildParameters.PackageName = packageName;
-				buildParameters.PackageVersion = "Simulate";
+                buildParameters.PackageVersion = packageVersion;
                 buildParameters.FileNameStyle = EFileNameStyle.HashName;
                 buildParameters.BuildinFileCopyOption = EBuildinFileCopyOption.None;
                 buildParameters.BuildinFileCopyParams = string.Empty;
 
                 ScriptableBuildPipeline pipeline = new ScriptableBuildPipeline();
-				var buildResult = pipeline.Run(buildParameters, true);
+                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())
             {
@@ -73,28 +56,30 @@ namespace YooAsset.Editor
                 buildParameters.BuildTarget = EditorUserBuildSettings.activeBuildTarget;
                 buildParameters.BuildMode = EBuildMode.SimulateBuild;
                 buildParameters.PackageName = packageName;
-				buildParameters.PackageVersion = "Simulate";
+                buildParameters.PackageVersion = packageVersion;
                 buildParameters.FileNameStyle = EFileNameStyle.HashName;
                 buildParameters.BuildinFileCopyOption = EBuildinFileCopyOption.None;
                 buildParameters.BuildinFileCopyParams = string.Empty;
 
                 RawFileBuildPipeline pipeline = new RawFileBuildPipeline();
-				var buildResult = pipeline.Run(buildParameters, true);
+                buildResult = pipeline.Run(buildParameters, true);
+            }
+            else
+            {
+                throw new System.NotImplementedException(buildPipelineName);
+            }
+
+            // 返回结果
             if (buildResult.Success)
             {
-					string manifestFileName = YooAssetSettingsData.GetManifestBinaryFileName(buildParameters.PackageName, buildParameters.PackageVersion);
+                SimulateBuildResult reulst = new SimulateBuildResult();
-					string manifestFilePath = $"{buildResult.OutputPackageDirectory}/{manifestFileName}";
+                reulst.PackageRootDirectory = buildResult.OutputPackageDirectory;
-					return manifestFilePath;
+                return reulst;
             }
             else
             {
                 return null;
             }
         }
-			else
-			{
-				throw new System.NotImplementedException(buildPipelineName);
-			}
-		}
     }
 }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildAssetInfo.cs

@@ -26,19 +26,9 @@ namespace YooAsset.Editor
         public string Address { private set; get; }
 
         /// <summary>
-		/// 资源路径
+        /// 资源信息
         /// </summary>
-		public string AssetPath { private set; get; }
+        public AssetInfo AssetInfo { private set; get; }
-
-		/// <summary>
-		/// 资源GUID
-		/// </summary>
-		public string AssetGUID { private set; get; }
-
-		/// <summary>
-		/// 资源类型
-		/// </summary>
-		public System.Type AssetType { private set; get; }
 
         /// <summary>
         /// 资源的分类标签
@@ -52,25 +42,19 @@ namespace YooAsset.Editor
         public List<BuildAssetInfo> AllDependAssetInfos { private set; get; }
 
 
-		public BuildAssetInfo(ECollectorType collectorType, string bundleName, string address, string assetPath)
+        public BuildAssetInfo(ECollectorType collectorType, string bundleName, string address, AssetInfo assetInfo)
         {
             CollectorType = collectorType;
             BundleName = bundleName;
             Address = address;
-			AssetPath = assetPath;
+            AssetInfo = assetInfo;
-
-			AssetGUID = UnityEditor.AssetDatabase.AssetPathToGUID(assetPath);
-			AssetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(assetPath);
         }
-		public BuildAssetInfo(string assetPath)
+        public BuildAssetInfo(AssetInfo assetInfo)
         {
             CollectorType = ECollectorType.None;
             BundleName = string.Empty;
             Address = string.Empty;
-			AssetPath = assetPath;
+            AssetInfo = assetInfo;
-
-			AssetGUID = UnityEditor.AssetDatabase.AssetPathToGUID(assetPath);
-			AssetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(assetPath);
         }
 
 
@@ -86,13 +70,14 @@ namespace YooAsset.Editor
         }
 
         /// <summary>
-		/// 设置为统一的着色器包名
+        /// 设置资源包名称
         /// </summary>
-		public void SetShaderBundleName(string packageName, bool uniqueBundleName)
+        public void SetBundleName(string bundleName)
         {
-			// 获取着色器打包规则结果
+            if (HasBundleName())
-			PackRuleResult shaderPackRuleResult = DefaultPackRule.CreateShadersPackRuleResult();
+                throw new System.Exception("Should never get here !");
-			BundleName = shaderPackRuleResult.GetBundleName(packageName, uniqueBundleName);		
+
+            BundleName = bundleName;
         }
 
         /// <summary>
@@ -137,17 +122,6 @@ namespace YooAsset.Editor
                 return true;
         }
 
-		/// <summary>
-		/// 判断是否为冗余资源
-		/// </summary>
-		public bool IsRedundancyAsset()
-		{
-			if (HasBundleName())
-				return false;
-
-			return _referenceBundleNames.Count > 1;
-		}
-
         /// <summary>
         /// 获取关联资源包的数量
         /// </summary>

Assets/YooAsset/Editor/AssetBundleBuilder/BuildBundleInfo.cs

@@ -82,12 +82,12 @@ namespace YooAsset.Editor
         /// <summary>
         /// 添加一个打包资源
         /// </summary>
-		public void PackAsset(BuildAssetInfo assetInfo)
+        public void PackAsset(BuildAssetInfo buildAsset)
         {
-			if (IsContainsAsset(assetInfo.AssetPath))
+            if (IsContainsAsset(buildAsset.AssetInfo.AssetPath))
-				throw new System.Exception($"Should never get here ! Asset is existed : {assetInfo.AssetPath}");
+                throw new System.Exception($"Should never get here ! Asset is existed : {buildAsset.AssetInfo.AssetPath}");
 
-			MainAssets.Add(assetInfo);
+            MainAssets.Add(buildAsset);
         }
 
         /// <summary>
@@ -95,9 +95,9 @@ namespace YooAsset.Editor
         /// </summary>
         public bool IsContainsAsset(string assetPath)
         {
-			foreach (var assetInfo in MainAssets)
+            foreach (var buildAsset in MainAssets)
             {
-				if (assetInfo.AssetPath == assetPath)
+                if (buildAsset.AssetInfo.AssetPath == assetPath)
                 {
                     return true;
                 }
@@ -110,7 +110,7 @@ namespace YooAsset.Editor
         /// </summary>
         public string[] GetAllMainAssetPaths()
         {
-			return MainAssets.Select(t => t.AssetPath).ToArray();
+            return MainAssets.Select(t => t.AssetInfo.AssetPath).ToArray();
         }
 
         /// <summary>
@@ -120,17 +120,17 @@ namespace YooAsset.Editor
         {
             var packAssets = GetAllMainAssetPaths();
             List<string> result = new List<string>(packAssets);
-			foreach (var assetInfo in MainAssets)
+            foreach (var buildAsset in MainAssets)
             {
-				if (assetInfo.AllDependAssetInfos == null)
+                if (buildAsset.AllDependAssetInfos == null)
                     continue;
-				foreach (var dependAssetInfo in assetInfo.AllDependAssetInfos)
+                foreach (var dependAssetInfo in buildAsset.AllDependAssetInfos)
                 {
                     // 注意：依赖资源里只添加零依赖资源和冗余资源
                     if (dependAssetInfo.HasBundleName() == false)
                     {
-						if (result.Contains(dependAssetInfo.AssetPath) == false)
+                        if (result.Contains(dependAssetInfo.AssetInfo.AssetPath) == false)
-							result.Add(dependAssetInfo.AssetPath);
+                            result.Add(dependAssetInfo.AssetInfo.AssetPath);
                     }
                 }
             }
@@ -142,7 +142,7 @@ namespace YooAsset.Editor
         /// </summary>
         public UnityEditor.AssetBundleBuild CreatePipelineBuild()
         {
-			// 注意：我们不在支持AssetBundle的变种机制
+            // 注意：我们不再支持AssetBundle的变种机制
             AssetBundleBuild build = new AssetBundleBuild();
             build.assetBundleName = BundleName;
             build.assetBundleVariant = string.Empty;

Assets/YooAsset/Editor/AssetBundleBuilder/BuildMapContext.cs

@@ -14,10 +14,9 @@ namespace YooAsset.Editor
         private readonly Dictionary<string, BuildBundleInfo> _bundleInfoDic = new Dictionary<string, BuildBundleInfo>(10000);
 
         /// <summary>
-		/// 冗余的资源列表
+        /// 未被依赖的资源列表
         /// </summary>
-		public readonly List<ReportRedundancyInfo> RedundancyInfos = new List<ReportRedundancyInfo>(1000);
+        public readonly List<ReportIndependAsset> IndependAssets = new List<ReportIndependAsset>(1000);
-
         
         /// <summary>
         /// 参与构建的资源总数

Assets/YooAsset/Editor/AssetBundleBuilder/BuildParameters.cs

@@ -47,6 +47,11 @@ namespace YooAsset.Editor
         public string PackageVersion;
 
 
+        /// <summary>
+        /// 是否启用共享资源打包
+        /// </summary>
+        public bool EnableSharePackRule = false;
+
         /// <summary>
         /// 验证构建结果
         /// </summary>
@@ -161,7 +166,7 @@ namespace YooAsset.Editor
         /// 获取构建管线的输出目录
         /// </summary>
         /// <returns></returns>
-		public string GetPipelineOutputDirectory()
+        public virtual string GetPipelineOutputDirectory()
         {
             if (string.IsNullOrEmpty(_pipelineOutputDirectory))
             {
@@ -173,7 +178,7 @@ namespace YooAsset.Editor
         /// <summary>
         /// 获取本次构建的补丁输出目录
         /// </summary>
-		public string GetPackageOutputDirectory()
+        public virtual string GetPackageOutputDirectory()
         {
             if (string.IsNullOrEmpty(_packageOutputDirectory))
             {
@@ -185,7 +190,7 @@ namespace YooAsset.Editor
         /// <summary>
         /// 获取本次构建的补丁根目录
         /// </summary>
-		public string GetPackageRootDirectory()
+        public virtual string GetPackageRootDirectory()
         {
             if (string.IsNullOrEmpty(_packageRootDirectory))
             {
@@ -197,7 +202,7 @@ namespace YooAsset.Editor
         /// <summary>
         /// 获取内置资源的根目录
         /// </summary>
-		public string GetBuildinRootDirectory()
+        public virtual string GetBuildinRootDirectory()
         {
             if (string.IsNullOrEmpty(_buildinRootDirectory))
             {

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

@@ -105,8 +105,8 @@ namespace YooAsset.Editor
                 {
                     PackageAsset packageAsset = new PackageAsset();
                     packageAsset.Address = buildMapContext.Command.EnableAddressable ? assetInfo.Address : string.Empty;
-					packageAsset.AssetPath = assetInfo.AssetPath;
+                    packageAsset.AssetPath = assetInfo.AssetInfo.AssetPath;
-					packageAsset.AssetGUID = buildMapContext.Command.IncludeAssetGUID ? assetInfo.AssetGUID : string.Empty;
+                    packageAsset.AssetGUID = buildMapContext.Command.IncludeAssetGUID ? assetInfo.AssetInfo.AssetGUID : string.Empty;
                     packageAsset.AssetTags = assetInfo.AssetTags.ToArray();
                     packageAsset.BundleID = GetCachedBundleID(assetInfo.BundleName);
                     result.Add(packageAsset);
@@ -180,9 +180,9 @@ namespace YooAsset.Editor
             for (int index = 0; index < manifest.BundleList.Count; index++)
             {
                 var packageBundle = manifest.BundleList[index];
-				if (_cacheBundleTags.ContainsKey(index))
+                if (_cacheBundleTags.TryGetValue(index, out var value))
                 {
-					packageBundle.Tags = _cacheBundleTags[index].ToArray();
+                    packageBundle.Tags = value.ToArray();
                 }
                 else
                 {

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

@@ -31,16 +31,18 @@ namespace YooAsset.Editor
                 buildReport.Summary.BuildMode = buildParameters.BuildMode;
                 buildReport.Summary.BuildPackageName = buildParameters.PackageName;
                 buildReport.Summary.BuildPackageVersion = buildParameters.PackageVersion;
+
+                // 收集器配置
                 buildReport.Summary.UniqueBundleName = buildMapContext.Command.UniqueBundleName;
                 buildReport.Summary.EnableAddressable = buildMapContext.Command.EnableAddressable;
                 buildReport.Summary.LocationToLower = buildMapContext.Command.LocationToLower;
                 buildReport.Summary.IncludeAssetGUID = buildMapContext.Command.IncludeAssetGUID;
-				buildReport.Summary.IgnoreDefaultType = buildMapContext.Command.IgnoreDefaultType;
+                buildReport.Summary.IgnoreRuleName = buildMapContext.Command.IgnoreRule.GetType().FullName;
                 buildReport.Summary.AutoCollectShaders = buildMapContext.Command.AutoCollectShaders;
-				buildReport.Summary.EncryptionClassName = buildParameters.EncryptionServices == null ?
-					"null" : buildParameters.EncryptionServices.GetType().FullName;
 
                 // 构建参数
+                buildReport.Summary.EnableSharePackRule = buildParameters.EnableSharePackRule;
+                buildReport.Summary.EncryptionClassName = buildParameters.EncryptionServices == null ? "null" : buildParameters.EncryptionServices.GetType().FullName;
                 if (buildParameters.BuildPipeline == nameof(BuiltinBuildPipeline))
                 {
                     var builtinBuildParameters = buildParameters as BuiltinBuildParameters;
@@ -107,8 +109,8 @@ namespace YooAsset.Editor
                 buildReport.BundleInfos.Add(reportBundleInfo);
             }
 
-			// 冗余资源列表
+            // 其它资源列表
-			buildReport.RedundancyInfos = new List<ReportRedundancyInfo>(buildMapContext.RedundancyInfos);
+            buildReport.IndependAssets = new List<ReportIndependAsset>(buildMapContext.IndependAssets);
 
             // 序列化文件
             string fileName = YooAssetSettingsData.GetReportFileName(buildParameters.PackageName, buildParameters.PackageVersion);
@@ -140,11 +142,11 @@ namespace YooAsset.Editor
             var bundleInfo = buildMapContext.GetBundleInfo(bundleName);
             {
                 BuildAssetInfo findAssetInfo = null;
-				foreach (var assetInfo in bundleInfo.MainAssets)
+                foreach (var buildAsset in bundleInfo.MainAssets)
                 {
-					if (assetInfo.AssetPath == assetPath)
+                    if (buildAsset.AssetInfo.AssetPath == assetPath)
                     {
-						findAssetInfo = assetInfo;
+                        findAssetInfo = buildAsset;
                         break;
                     }
                 }
@@ -154,7 +156,7 @@ namespace YooAsset.Editor
                 }
                 foreach (var dependAssetInfo in findAssetInfo.AllDependAssetInfos)
                 {
-					result.Add(dependAssetInfo.AssetPath);
+                    result.Add(dependAssetInfo.AssetInfo.AssetPath);
                 }
             }
             return result;

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

@@ -26,7 +26,7 @@ namespace YooAsset.Editor
             {
                 EncryptFileInfo fileInfo = new EncryptFileInfo();
                 fileInfo.BundleName = bundleInfo.BundleName;
-				fileInfo.FilePath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
+                fileInfo.FileLoadPath = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
                 var encryptResult = encryptionServices.Encrypt(fileInfo);
                 if (encryptResult.Encrypted)
                 {

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

@@ -14,6 +14,7 @@ namespace YooAsset.Editor
         /// </summary>
         public BuildMapContext CreateBuildMap(BuildParameters buildParameters)
         {
+            BuildMapContext context = new BuildMapContext();
             var buildMode = buildParameters.BuildMode;
             var packageName = buildParameters.PackageName;
 
@@ -21,103 +22,107 @@ namespace YooAsset.Editor
 
             // 1. 获取所有收集器收集的资源
             var collectResult = AssetBundleCollectorSettingData.Setting.GetPackageAssets(buildMode, packageName);
-			List<CollectAssetInfo> allCollectAssetInfos = collectResult.CollectAssets;
+            List<CollectAssetInfo> allCollectAssets = collectResult.CollectAssets;
 
             // 2. 剔除未被引用的依赖项资源
-			RemoveZeroReferenceAssets(allCollectAssetInfos);
+            RemoveZeroReferenceAssets(context, allCollectAssets);
 
             // 3. 录入所有收集器主动收集的资源
-			foreach (var collectAssetInfo in allCollectAssetInfos)
+            foreach (var collectAssetInfo in allCollectAssets)
             {
-				if (allBuildAssetInfos.ContainsKey(collectAssetInfo.AssetPath) == false)
+                if (allBuildAssetInfos.ContainsKey(collectAssetInfo.AssetInfo.AssetPath))
                 {
+                    throw new Exception($"Should never get here !");
+                }
+
                 if (collectAssetInfo.CollectorType != ECollectorType.MainAssetCollector)
                 {
                     if (collectAssetInfo.AssetTags.Count > 0)
                     {
                         collectAssetInfo.AssetTags.Clear();
-							string warning = BuildLogger.GetErrorMessage(ErrorCode.RemoveInvalidTags, $"Remove asset tags that don't work, see the asset collector type : {collectAssetInfo.AssetPath}");
+                        string warning = BuildLogger.GetErrorMessage(ErrorCode.RemoveInvalidTags, $"Remove asset tags that don't work, see the asset collector type : {collectAssetInfo.AssetInfo.AssetPath}");
                         BuildLogger.Warning(warning);
                     }
                 }
 
-					var buildAssetInfo = new BuildAssetInfo(collectAssetInfo.CollectorType, collectAssetInfo.BundleName, collectAssetInfo.Address, collectAssetInfo.AssetPath);
+                var buildAssetInfo = new BuildAssetInfo(collectAssetInfo.CollectorType, collectAssetInfo.BundleName, collectAssetInfo.Address, collectAssetInfo.AssetInfo);
                 buildAssetInfo.AddAssetTags(collectAssetInfo.AssetTags);
-					allBuildAssetInfos.Add(collectAssetInfo.AssetPath, buildAssetInfo);
+                allBuildAssetInfos.Add(collectAssetInfo.AssetInfo.AssetPath, buildAssetInfo);
-				}
-				else
-				{
-					throw new Exception($"Should never get here !");
-				}
             }
 
             // 4. 录入所有收集资源依赖的其它资源
-			foreach (var collectAssetInfo in allCollectAssetInfos)
+            foreach (var collectAssetInfo in allCollectAssets)
             {
                 string bundleName = collectAssetInfo.BundleName;
-				foreach (var dependAssetPath in collectAssetInfo.DependAssets)
+                foreach (var dependAsset in collectAssetInfo.DependAssets)
                 {
-					if (allBuildAssetInfos.ContainsKey(dependAssetPath))
+                    if (allBuildAssetInfos.TryGetValue(dependAsset.AssetPath, out var value))
                     {
-						allBuildAssetInfos[dependAssetPath].AddReferenceBundleName(bundleName);
+                        value.AddReferenceBundleName(bundleName);
                     }
                     else
                     {
-						var buildAssetInfo = new BuildAssetInfo(dependAssetPath);
+                        var buildAssetInfo = new BuildAssetInfo(dependAsset);
                         buildAssetInfo.AddReferenceBundleName(bundleName);
-						allBuildAssetInfos.Add(dependAssetPath, buildAssetInfo);
+                        allBuildAssetInfos.Add(dependAsset.AssetPath, buildAssetInfo);
                     }
                 }
             }
 
             // 5. 填充所有收集资源的依赖列表
-			foreach (var collectAssetInfo in allCollectAssetInfos)
+            foreach (var collectAssetInfo in allCollectAssets)
             {
                 var dependAssetInfos = new List<BuildAssetInfo>(collectAssetInfo.DependAssets.Count);
-				foreach (var dependAssetPath in collectAssetInfo.DependAssets)
+                foreach (var dependAsset in collectAssetInfo.DependAssets)
                 {
-					if (allBuildAssetInfos.TryGetValue(dependAssetPath, out BuildAssetInfo value))
+                    if (allBuildAssetInfos.TryGetValue(dependAsset.AssetPath, out BuildAssetInfo value))
                         dependAssetInfos.Add(value);
                     else
                         throw new Exception("Should never get here !");
                 }
-				allBuildAssetInfos[collectAssetInfo.AssetPath].SetDependAssetInfos(dependAssetInfos);
+                allBuildAssetInfos[collectAssetInfo.AssetInfo.AssetPath].SetDependAssetInfos(dependAssetInfos);
             }
 
             // 6. 自动收集所有依赖的着色器
             if (collectResult.Command.AutoCollectShaders)
             {
+                // 获取着色器打包规则结果
+                PackRuleResult shaderPackRuleResult = DefaultPackRule.CreateShadersPackRuleResult();
+                string shaderBundleName = shaderPackRuleResult.GetBundleName(collectResult.Command.PackageName, collectResult.Command.UniqueBundleName);
                 foreach (var buildAssetInfo in allBuildAssetInfos.Values)
                 {
                     if (buildAssetInfo.CollectorType == ECollectorType.None)
                     {
-						if (buildAssetInfo.AssetType == typeof(UnityEngine.Shader) || buildAssetInfo.AssetType == typeof(UnityEngine.ShaderVariantCollection))
+                        if (buildAssetInfo.AssetInfo.IsShaderAsset())
                         {
-							buildAssetInfo.SetShaderBundleName(collectResult.Command.PackageName, collectResult.Command.UniqueBundleName);
+                            buildAssetInfo.SetBundleName(shaderBundleName);
                         }
                     }
                 }
             }
 
-			// 7. 记录关键信息
+            // 7. 计算共享资源的包名
-			BuildMapContext context = new BuildMapContext();
+            if (buildParameters.EnableSharePackRule)
-			context.AssetFileCount = allBuildAssetInfos.Count;
+            {
-			context.Command = collectResult.Command;
+                PreProcessPackShareBundle(buildParameters, collectResult.Command, allBuildAssetInfos);
-
-			// 8. 记录冗余资源
                 foreach (var buildAssetInfo in allBuildAssetInfos.Values)
                 {
-				if (buildAssetInfo.IsRedundancyAsset())
+                    if (buildAssetInfo.HasBundleName() == false)
                     {
-					var redundancyInfo = new ReportRedundancyInfo();
+                        PackRuleResult packRuleResult = GetShareBundleName(buildAssetInfo);
-					redundancyInfo.AssetPath = buildAssetInfo.AssetPath;
+                        if (packRuleResult.IsValid())
-					redundancyInfo.AssetType = buildAssetInfo.AssetType.Name;
+                        {
-					redundancyInfo.AssetGUID = buildAssetInfo.AssetGUID;
+                            string shareBundleName = packRuleResult.GetShareBundleName(collectResult.Command.PackageName, collectResult.Command.UniqueBundleName);
-					redundancyInfo.FileSize = FileUtility.GetFileSize(buildAssetInfo.AssetPath);
+                            buildAssetInfo.SetBundleName(shareBundleName);
-					redundancyInfo.Number = buildAssetInfo.GetReferenceBundleCount();
-					context.RedundancyInfos.Add(redundancyInfo);
                         }
                     }
+                }
+                PostProcessPackShareBundle();
+            }
+
+            // 8. 记录关键信息
+            context.AssetFileCount = allBuildAssetInfos.Count;
+            context.Command = collectResult.Command;
 
             // 9. 移除不参与构建的资源
             List<BuildAssetInfo> removeBuildList = new List<BuildAssetInfo>();
@@ -128,7 +133,7 @@ namespace YooAsset.Editor
             }
             foreach (var removeValue in removeBuildList)
             {
-				allBuildAssetInfos.Remove(removeValue.AssetPath);
+                allBuildAssetInfos.Remove(removeValue.AssetInfo.AssetPath);
             }
 
             // 10. 构建资源列表
@@ -145,35 +150,35 @@ namespace YooAsset.Editor
 
             return context;
         }
-		private void RemoveZeroReferenceAssets(List<CollectAssetInfo> allCollectAssetInfos)
+        private void RemoveZeroReferenceAssets(BuildMapContext context, List<CollectAssetInfo> allCollectAssets)
         {
-			// 1. 检测是否任何存在依赖资源
+            // 1. 检测依赖资源收集器是否存在
-			if (allCollectAssetInfos.Exists(x => x.CollectorType == ECollectorType.DependAssetCollector) == false)
+            if (allCollectAssets.Exists(x => x.CollectorType == ECollectorType.DependAssetCollector) == false)
                 return;
 
             // 2. 获取所有主资源的依赖资源集合
             HashSet<string> allDependAsset = new HashSet<string>();
-			foreach (var collectAssetInfo in allCollectAssetInfos)
+            foreach (var collectAsset in allCollectAssets)
             {
-				var collectorType = collectAssetInfo.CollectorType;
+                var collectorType = collectAsset.CollectorType;
                 if (collectorType == ECollectorType.MainAssetCollector || collectorType == ECollectorType.StaticAssetCollector)
                 {
-					foreach (var dependAsset in collectAssetInfo.DependAssets)
+                    foreach (var dependAsset in collectAsset.DependAssets)
                     {
-						if (allDependAsset.Contains(dependAsset) == false)
+                        if (allDependAsset.Contains(dependAsset.AssetPath) == false)
-							allDependAsset.Add(dependAsset);
+                            allDependAsset.Add(dependAsset.AssetPath);
                     }
                 }
             }
 
             // 3. 找出所有零引用的依赖资源集合
             List<CollectAssetInfo> removeList = new List<CollectAssetInfo>();
-			foreach (var collectAssetInfo in allCollectAssetInfos)
+            foreach (var collectAssetInfo in allCollectAssets)
             {
                 var collectorType = collectAssetInfo.CollectorType;
                 if (collectorType == ECollectorType.DependAssetCollector)
                 {
-					if (allDependAsset.Contains(collectAssetInfo.AssetPath) == false)
+                    if (allDependAsset.Contains(collectAssetInfo.AssetInfo.AssetPath) == false)
                         removeList.Add(collectAssetInfo);
                 }
             }
@@ -181,10 +186,44 @@ namespace YooAsset.Editor
             // 4. 移除所有零引用的依赖资源
             foreach (var removeValue in removeList)
             {
-				string warning = BuildLogger.GetErrorMessage(ErrorCode.FoundUndependedAsset, $"Found undepended asset and remove it : {removeValue.AssetPath}");
+                string warning = BuildLogger.GetErrorMessage(ErrorCode.FoundUndependedAsset, $"Found undepended asset and remove it : {removeValue.AssetInfo.AssetPath}");
                 BuildLogger.Warning(warning);
-				allCollectAssetInfos.Remove(removeValue);
+
+                var independAsset = new ReportIndependAsset();
+                independAsset.AssetPath = removeValue.AssetInfo.AssetPath;
+                independAsset.AssetGUID = removeValue.AssetInfo.AssetGUID;
+                independAsset.AssetType = removeValue.AssetInfo.AssetType.ToString();
+                independAsset.FileSize = FileUtility.GetFileSize(removeValue.AssetInfo.AssetPath);
+                context.IndependAssets.Add(independAsset);
+
+                allCollectAssets.Remove(removeValue);
             }
         }
+
+        #region 共享资源打包规则
+        /// <summary>
+        /// 共享资源打包前置处理
+        /// </summary>
+        protected virtual void PreProcessPackShareBundle(BuildParameters buildParameters, CollectCommand command, Dictionary<string, BuildAssetInfo> allBuildAssetInfos)
+        {
+        }
+
+        /// <summary>
+        /// 共享资源打包后置处理
+        /// </summary>
+        protected virtual void PostProcessPackShareBundle()
+        {
+        }
+
+        /// <summary>
+        /// 获取共享资源包名称
+        /// </summary>
+        protected virtual PackRuleResult GetShareBundleName(BuildAssetInfo buildAssetInfo)
+        {
+            string bundleName = Path.GetDirectoryName(buildAssetInfo.AssetInfo.AssetPath);
+            PackRuleResult result = new PackRuleResult(bundleName, DefaultPackRule.AssetBundleFileExtension);
+            return result;
+        }
+        #endregion
     }
 }

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

@@ -44,9 +44,9 @@ namespace YooAsset.Editor
             {
                 bundleInfo.PackageUnityHash = GetUnityHash(bundleInfo, context);
                 bundleInfo.PackageUnityCRC = GetUnityCRC(bundleInfo, context);
-				bundleInfo.PackageFileHash = GetBundleFileHash(bundleInfo.PackageSourceFilePath, buildParametersContext);
+                bundleInfo.PackageFileHash = GetBundleFileHash(bundleInfo, buildParametersContext);
-				bundleInfo.PackageFileCRC = GetBundleFileCRC(bundleInfo.PackageSourceFilePath, buildParametersContext);
+                bundleInfo.PackageFileCRC = GetBundleFileCRC(bundleInfo, buildParametersContext);
-				bundleInfo.PackageFileSize = GetBundleFileSize(bundleInfo.PackageSourceFilePath, buildParametersContext);
+                bundleInfo.PackageFileSize = GetBundleFileSize(bundleInfo, buildParametersContext);
             }
 
             // 4.更新补丁包输出的文件路径
@@ -62,9 +62,9 @@ namespace YooAsset.Editor
 
         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 GetBundleFileHash(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext);
-		protected abstract string GetBundleFileCRC(string filePath, BuildParametersContext buildParametersContext);
+        protected abstract string GetBundleFileCRC(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext);
-		protected abstract long GetBundleFileSize(string filePath, BuildParametersContext buildParametersContext);
+        protected abstract long GetBundleFileSize(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext);
 
         protected string GetFilePathTempHash(string filePath)
         {
@@ -74,5 +74,23 @@ namespace YooAsset.Editor
             // 注意：在文件路径的哈希值冲突的情况下，可以使用下面的方法
             //return $"{HashUtility.BytesMD5(bytes)}-{Guid.NewGuid():N}";
         }
+        protected long GetBundleTempSize(BuildBundleInfo bundleInfo)
+        {
+            long tempSize = 0;
+
+            var assetPaths = bundleInfo.GetAllMainAssetPaths();
+            foreach (var assetPath in assetPaths)
+            {
+                long size = FileUtility.GetFileSize(assetPath);
+                tempSize += size;
+            }
+
+            if (tempSize == 0)
+            {
+                string message = BuildLogger.GetErrorMessage(ErrorCode.BundleTempSizeIsZero, $"Bundle temp size is zero, check bundle main asset list : {bundleInfo.BundleName}");
+                throw new Exception(message);
+            }
+            return tempSize;
+        }
     }
 }

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

@@ -1,9 +1,4 @@
-using System;
+
-using System.Linq;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-
 namespace YooAsset.Editor
 {
     public class TaskEncryption_BBP : TaskEncryption, IBuildTask

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

@@ -60,27 +60,30 @@ namespace YooAsset.Editor
                 }
             }
         }
-		protected override string GetBundleFileHash(string filePath, BuildParametersContext buildParametersContext)
+        protected override string GetBundleFileHash(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             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)
+        protected override string GetBundleFileCRC(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             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)
+        protected override long GetBundleFileSize(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             var buildMode = buildParametersContext.Parameters.BuildMode;
             if (buildMode == EBuildMode.DryRunBuild || buildMode == EBuildMode.SimulateBuild)
-				return 0;
+                return GetBundleTempSize(bundleInfo);
             else
                 return FileUtility.GetFileSize(filePath);
         }

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

@@ -7,10 +7,17 @@ namespace YooAsset.Editor
     public class BuiltinBuildPipeline : IBuildPipeline
     {
         public BuildResult Run(BuildParameters buildParameters, bool enableLog)
+        {
+            if (buildParameters is BuiltinBuildParameters)
             {
                 AssetBundleBuilder builder = new AssetBundleBuilder();
                 return builder.Run(buildParameters, GetDefaultBuildPipeline(), enableLog);
             }
+            else
+            {
+                throw new Exception($"Invalid build parameter type : {buildParameters.GetType().Name}");
+            }
+        }
 
         /// <summary>
         /// 获取默认的构建流程

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

@@ -29,9 +29,9 @@ namespace YooAsset.Editor
             foreach (var bundleInfo in buildMapContext.Collection)
             {
                 string dest = $"{pipelineOutputDirectory}/{bundleInfo.BundleName}";
-				foreach (var assetInfo in bundleInfo.MainAssets)
+                foreach (var buildAsset in bundleInfo.MainAssets)
                 {
-					EditorTools.CopyFile(assetInfo.AssetPath, dest, true);
+                    EditorTools.CopyFile(buildAsset.AssetInfo.AssetPath, dest, true);
                 }
             }
         }

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

@@ -14,7 +14,7 @@ namespace YooAsset.Editor
 
         protected override string[] GetBundleDepends(BuildContext context, string bundleName)
         {
-			return new string[] { };
+            return Array.Empty<string>();
         }
     }
 }

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

@@ -0,0 +1,18 @@
+
+namespace YooAsset.Editor
+{
+    public class TaskEncryption_RFBP : 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/RawFileBuildPipeline/BuildTasks/TaskEncryption_RFBP.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a72c4edf1a81c9942a9d43e9d2a77b53
+guid: b3e156139dcc25f4c9440ec3d6cb96d2
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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

@@ -16,6 +16,13 @@ namespace YooAsset.Editor
             // 检测基础构建参数
             buildParametersContext.CheckBuildParameters();
 
+            // 检测不被支持的参数
+            if (buildParameters.EnableSharePackRule)
+            {
+                string message = BuildLogger.GetErrorMessage(ErrorCode.BuildPipelineNotSupportSharePackRule, $"{nameof(EBuildPipeline.RawFileBuildPipeline)} not support share pack rule !");
+                throw new Exception(message);
+            }
+
             // 检测不被支持的构建模式
             if (buildParameters.BuildMode == EBuildMode.DryRunBuild)
             {

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

@@ -32,27 +32,30 @@ namespace YooAsset.Editor
         {
             return 0;
         }
-		protected override string GetBundleFileHash(string filePath, BuildParametersContext buildParametersContext)
+        protected override string GetBundleFileHash(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             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)
+        protected override string GetBundleFileCRC(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             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)
+        protected override long GetBundleFileSize(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             var buildMode = buildParametersContext.Parameters.BuildMode;
             if (buildMode == EBuildMode.SimulateBuild)
-				return 0;
+                return GetBundleTempSize(bundleInfo);
             else
                 return FileUtility.GetFileSize(filePath);
         }

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

@@ -10,10 +10,17 @@ namespace YooAsset.Editor
     public class RawFileBuildPipeline : IBuildPipeline
     {
         public BuildResult Run(BuildParameters buildParameters, bool enableLog)
+        {
+            if (buildParameters is RawFileBuildParameters)
             {
                 AssetBundleBuilder builder = new AssetBundleBuilder();
                 return builder.Run(buildParameters, GetDefaultBuildPipeline(), enableLog);
             }
+            else
+            {
+                throw new Exception($"Invalid build parameter type : {buildParameters.GetType().Name}");
+            }
+        }
 
         /// <summary>
         /// 获取默认的构建流程
@@ -25,6 +32,7 @@ namespace YooAsset.Editor
                     new TaskPrepare_RFBP(),
                     new TaskGetBuildMap_RFBP(),
                     new TaskBuilding_RFBP(),
+                    new TaskEncryption_RFBP(),
                     new TaskUpdateBundleInfo_RFBP(),
                     new TaskCreateManifest_RFBP(),
                     new TaskCreateReport_RFBP(),

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

@@ -1,9 +1,4 @@
-using System;
+
-using System.Linq;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-
 namespace YooAsset.Editor
 {
     public class TaskEncryption_SBP : TaskEncryption, IBuildTask

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

@@ -60,27 +60,30 @@ namespace YooAsset.Editor
                 }
             }
         }
-		protected override string GetBundleFileHash(string filePath, BuildParametersContext buildParametersContext)
+        protected override string GetBundleFileHash(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             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)
+        protected override string GetBundleFileCRC(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             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)
+        protected override long GetBundleFileSize(BuildBundleInfo bundleInfo, BuildParametersContext buildParametersContext)
         {
+            string filePath = bundleInfo.PackageSourceFilePath;
             var buildMode = buildParametersContext.Parameters.BuildMode;
             if (buildMode == EBuildMode.SimulateBuild)
-				return 0;
+                return GetBundleTempSize(bundleInfo);
             else
                 return FileUtility.GetFileSize(filePath);
         }

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/BuildTasksEx.cs

@@ -1,67 +0,0 @@
-using System.Collections.Generic;
-using UnityEditor.Build.Content;
-using UnityEngine.U2D;
-using UnityEditor.Build.Pipeline.Injector;
-using UnityEditor.Build.Pipeline.Interfaces;
-using UnityEngine;
-
-namespace UnityEditor.Build.Pipeline.Tasks
-{
-	/// <summary>
-	/// Ref https://zhuanlan.zhihu.com/p/586918159
-	/// </summary>
-	public class RemoveSpriteAtlasRedundancy : IBuildTask
-	{
-		public int Version => 1;
-
-		[InjectContext]
-		IBundleWriteData writeDataParam;
-
-		public ReturnCode Run()
-		{
-#if UNITY_2020_3_OR_NEWER
-			BundleWriteData writeData = (BundleWriteData)writeDataParam;
-
-			// 图集引用的精灵图片集合
-			HashSet<GUID> spriteGuids = new HashSet<GUID>();
-			foreach (var pair in writeData.FileToObjects)
-			{
-				foreach (ObjectIdentifier objectIdentifier in pair.Value)
-				{
-					var assetPath = AssetDatabase.GUIDToAssetPath(objectIdentifier.guid);
-					var assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
-					if (assetType == typeof(SpriteAtlas))
-					{
-						var spritePaths = AssetDatabase.GetDependencies(assetPath, false);
-						foreach (string spritePath in spritePaths)
-						{
-							GUID spriteGuild = AssetDatabase.GUIDFromAssetPath(spritePath);
-							spriteGuids.Add(spriteGuild);
-						}
-					}
-				}
-			}
-
-			// 移除图集引用的精力图片对象
-			foreach (var pair in writeData.FileToObjects)
-			{
-				List<ObjectIdentifier> objectIdentifiers = pair.Value;
-				for (int i = objectIdentifiers.Count - 1; i >= 0; i--)
-				{
-					ObjectIdentifier objectIdentifier = objectIdentifiers[i];
-					if (spriteGuids.Contains(objectIdentifier.guid))
-					{
-						if (objectIdentifier.localIdentifierInFile == 2800000)
-						{
-							// 删除图集散图的冗余纹理
-							objectIdentifiers.RemoveAt(i);
-						}
-					}
-				}
-			}
-#endif
-
-			return ReturnCode.Success;
-		}
-	}
-}

Assets/YooAsset/Editor/AssetBundleBuilder/BuildPipeline/ScriptableBuildPipeline/SBPBuildTasks.cs

@@ -28,12 +28,17 @@ namespace UnityEditor.Build.Pipeline.Tasks
 #endif
             buildTasks.Add(new CalculateAssetDependencyData());
             buildTasks.Add(new StripUnusedSpriteSources());
+
+#if TUANJIE_1_0_OR_NEWER
             buildTasks.Add(new CreateBuiltInShadersBundle(builtInShaderBundleName));
+#else
+            buildTasks.Add(new CreateBuiltInBundle(builtInShaderBundleName));
+#endif
+
             buildTasks.Add(new PostDependencyCallback());
 
             // Packing
             buildTasks.Add(new GenerateBundlePacking());
-			buildTasks.Add(new RemoveSpriteAtlasRedundancy()); // Fix for SpriteAtlas Redundancy
             buildTasks.Add(new UpdateBundleObjectLayout());
             buildTasks.Add(new GenerateBundleCommands());
             buildTasks.Add(new GenerateSubAssetPathMaps());

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

@@ -7,10 +7,17 @@ namespace YooAsset.Editor
     public class ScriptableBuildPipeline : IBuildPipeline
     {
         public BuildResult Run(BuildParameters buildParameters, bool enableLog)
+        {
+            if (buildParameters is ScriptableBuildParameters)
             {
                 AssetBundleBuilder builder = new AssetBundleBuilder();
                 return builder.Run(buildParameters, GetDefaultBuildPipeline(), enableLog);
             }
+            else
+            {
+                throw new Exception($"Invalid build parameter type : {buildParameters.GetType().Name}");
+            }
+        }
 
         /// <summary>
         /// 获取默认的构建流程

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

@@ -14,6 +14,7 @@ namespace YooAsset.Editor
         PackageOutputDirectoryExists = 115,
         RecommendScriptBuildPipeline = 130,
         BuildPipelineNotSupportBuildMode = 140,
+        BuildPipelineNotSupportSharePackRule = 141,
 
         // TaskGetBuildMap
         RemoveInvalidTags = 200,
@@ -29,6 +30,7 @@ namespace YooAsset.Editor
         CharactersOverTheLimit = 400,
         NotFoundUnityBundleHash = 401,
         NotFoundUnityBundleCRC = 402,
+        BundleTempSizeIsZero = 403,
 
         // TaskVerifyBuildResult
         UnintendedBuildBundle = 500,

Assets/YooAsset/Editor/AssetBundleBuilder/IBuildPipeline.cs

@@ -3,6 +3,6 @@ namespace YooAsset.Editor
 {
     public interface IBuildPipeline
     {
-		public BuildResult Run(BuildParameters buildParameters, bool enableLog);
+        BuildResult Run(BuildParameters buildParameters, bool enableLog);
     }
 }

Assets/YooAsset/Editor/AssetBundleBuilder/VisualViewers/BuildPipelineViewerBase.cs

@@ -65,6 +65,8 @@ namespace YooAsset.Editor
                 var buildMode = AssetBundleBuilderSetting.GetPackageBuildMode(PackageName, BuildPipeline);
                 var buildModeList = GetSupportBuildModes();
                 int defaultIndex = buildModeList.FindIndex(x => x.Equals(buildMode));
+                if (defaultIndex < 0)
+                    defaultIndex = (int)(EBuildMode)buildModeList[0];
                 _buildModeField = new PopupField<Enum>(buildModeList, defaultIndex);
                 _buildModeField.label = "Build Mode";
                 _buildModeField.style.width = StyleWidth;
@@ -83,6 +85,8 @@ namespace YooAsset.Editor
                 {
                     var encyptionClassName = AssetBundleBuilderSetting.GetPackageEncyptionClassName(PackageName, BuildPipeline);
                     int defaultIndex = encryptionClassTypes.FindIndex(x => x.FullName.Equals(encyptionClassName));
+                    if (defaultIndex < 0)
+                        defaultIndex = 0;
                     _encryptionField = new PopupField<Type>(encryptionClassTypes, defaultIndex);
                     _encryptionField.label = "Encryption";
                     _encryptionField.style.width = StyleWidth;

Assets/YooAsset/Editor/AssetBundleBuilder/VisualViewers/BuiltinBuildPipelineViewer.cs

@@ -1,4 +1,4 @@
-#if UNITY_2019_4_OR_NEWER
+#if UNITY_2019_4_OR_NEWER
 using System;
 using System.IO;
 using System.Linq;
@@ -18,7 +18,7 @@ namespace YooAsset.Editor
         }
 
         /// <summary>
-		/// ִ<>й<EFBFBD><D0B9><EFBFBD>
+        /// 执行构建
         /// </summary>
         protected override void ExecuteBuild()
         {
@@ -36,6 +36,7 @@ namespace YooAsset.Editor
             buildParameters.BuildMode = buildMode;
             buildParameters.PackageName = PackageName;
             buildParameters.PackageVersion = GetPackageVersion();
+            buildParameters.EnableSharePackRule = true;
             buildParameters.VerifyBuildingResult = true;
             buildParameters.FileNameStyle = fileNameStyle;
             buildParameters.BuildinFileCopyOption = buildinFileCopyOption;

Assets/YooAsset/Editor/AssetBundleBuilder/VisualViewers/RawfileBuildpipelineViewer.cs

@@ -1,4 +1,4 @@
-#if UNITY_2019_4_OR_NEWER
+#if UNITY_2019_4_OR_NEWER
 using System;
 using System.IO;
 using System.Linq;
@@ -20,7 +20,7 @@ namespace YooAsset.Editor
         }
 
         /// <summary>
-		/// ִ<>й<EFBFBD><D0B9><EFBFBD>
+        /// 执行构建
         /// </summary>
         protected override void ExecuteBuild()
         {

Assets/YooAsset/Editor/AssetBundleBuilder/VisualViewers/ScriptableBuildPipelineViewer.cs

@@ -36,6 +36,7 @@ namespace YooAsset.Editor
             buildParameters.BuildMode = buildMode;
             buildParameters.PackageName = PackageName;
             buildParameters.PackageVersion = GetPackageVersion();
+            buildParameters.EnableSharePackRule = true;
             buildParameters.VerifyBuildingResult = true;
             buildParameters.FileNameStyle = fileNameStyle;
             buildParameters.BuildinFileCopyOption = buildinFileCopyOption;

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollector.cs

@@ -148,18 +148,29 @@ namespace YooAsset.Editor
 
             Dictionary<string, CollectAssetInfo> result = new Dictionary<string, CollectAssetInfo>(1000);
 
-			// 收集打包资源
+            // 收集打包资源路径
+            List<string> findAssets =new List<string>();
             if (AssetDatabase.IsValidFolder(CollectPath))
             {
                 string collectDirectory = CollectPath;
-				string[] findAssets = EditorTools.FindAssets(EAssetSearchType.All, collectDirectory);
+                string[] findResult = EditorTools.FindAssets(EAssetSearchType.All, collectDirectory);
+                findAssets.AddRange(findResult);
+            }
+            else
+            {
+                string assetPath = CollectPath;
+                findAssets.Add(assetPath);
+            }
+
+            // 收集打包资源信息
             foreach (string assetPath in findAssets)
             {
-					if (IsValidateAsset(command, assetPath) && IsCollectAsset(group, assetPath))
+                var assetInfo = new AssetInfo(assetPath);
+                if (command.IgnoreRule.IsIgnore(assetInfo) == false && IsCollectAsset(group, assetInfo))
                 {
                     if (result.ContainsKey(assetPath) == false)
                     {
-							var collectAssetInfo = CreateCollectAssetInfo(command, group, assetPath);
+                        var collectAssetInfo = CreateCollectAssetInfo(command, group, assetInfo);
                         result.Add(assetPath, collectAssetInfo);
                     }
                     else
@@ -168,20 +179,6 @@ namespace YooAsset.Editor
                     }
                 }
             }
-			}
-			else
-			{
-				string assetPath = CollectPath;
-				if (IsValidateAsset(command, assetPath) && IsCollectAsset(group, assetPath))
-				{
-					var collectAssetInfo = CreateCollectAssetInfo(command, group, assetPath);
-					result.Add(assetPath, collectAssetInfo);
-				}
-				else
-				{
-					throw new Exception($"The collecting single asset file is invalid : {assetPath} in collector : {CollectPath}");
-				}
-			}
 
             // 检测可寻址地址是否重复
             if (command.EnableAddressable)
@@ -192,7 +189,7 @@ namespace YooAsset.Editor
                     if (collectInfoPair.Value.CollectorType == ECollectorType.MainAssetCollector)
                     {
                         string address = collectInfoPair.Value.Address;
-						string assetPath = collectInfoPair.Value.AssetPath;
+                        string assetPath = collectInfoPair.Value.AssetInfo.AssetPath;
                         if (string.IsNullOrEmpty(address))
                             continue;
 
@@ -211,61 +208,33 @@ namespace YooAsset.Editor
             return result.Values.ToList();
         }
 
-		private CollectAssetInfo CreateCollectAssetInfo(CollectCommand command, AssetBundleCollectorGroup group, string assetPath)
+
+        /// <summary>
+        /// 创建资源收集类
+        /// </summary>
+        private CollectAssetInfo CreateCollectAssetInfo(CollectCommand command, AssetBundleCollectorGroup group, AssetInfo assetInfo)
         {
-			string address = GetAddress(command, group, assetPath);
+            string address = GetAddress(command, group, assetInfo);
-			string bundleName = GetBundleName(command, group, assetPath);
+            string bundleName = GetBundleName(command, group, assetInfo);
             List<string> assetTags = GetAssetTags(group);
-			CollectAssetInfo collectAssetInfo = new CollectAssetInfo(CollectorType, bundleName, address, assetPath, assetTags);
+            CollectAssetInfo collectAssetInfo = new CollectAssetInfo(CollectorType, bundleName, address, assetInfo, assetTags);
 
             // 注意：模拟构建模式下不需要收集依赖资源
             if (command.BuildMode == EBuildMode.SimulateBuild)
-				collectAssetInfo.DependAssets = new List<string>();
+                collectAssetInfo.DependAssets = new List<AssetInfo>();
             else
-				collectAssetInfo.DependAssets = GetAllDependencies(command, assetPath);
+                collectAssetInfo.DependAssets = GetAllDependencies(command, assetInfo.AssetPath);
 
             return collectAssetInfo;
         }
-		private bool IsValidateAsset(CollectCommand command, string assetPath)
-		{
-			if (assetPath.StartsWith("Assets/") == false && assetPath.StartsWith("Packages/") == false)
-			{
-				UnityEngine.Debug.LogError($"Invalid asset path : {assetPath}");
-				return false;
-			}
 
-			// 忽略文件夹
+        private bool IsCollectAsset(AssetBundleCollectorGroup group, AssetInfo assetInfo)
-			if (AssetDatabase.IsValidFolder(assetPath))
-				return false;
-
-			// 忽略编辑器下的类型资源
-			Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
-			if (assetType == typeof(LightingDataAsset))
-				return false;
-
-			// 忽略Unity引擎无法识别的文件
-			if (command.IgnoreDefaultType)
-			{
-				if (assetType == typeof(UnityEditor.DefaultAsset))
-				{
-					UnityEngine.Debug.LogWarning($"Cannot pack default asset : {assetPath}");
-					return false;
-				}
-			}
-
-			string fileExtension = System.IO.Path.GetExtension(assetPath);
-			if (DefaultFilterRule.IsIgnoreFile(fileExtension))
-				return false;
-
-			return true;
-		}
-		private bool IsCollectAsset(AssetBundleCollectorGroup group, string assetPath)
         {
             // 根据规则设置过滤资源文件
             IFilterRule filterRuleInstance = AssetBundleCollectorSettingData.GetFilterRuleInstance(FilterRuleName);
-			return filterRuleInstance.IsCollectAsset(new FilterRuleData(assetPath, CollectPath, group.GroupName, UserData));
+            return filterRuleInstance.IsCollectAsset(new FilterRuleData(assetInfo.AssetPath, CollectPath, group.GroupName, UserData));
         }
-		private string GetAddress(CollectCommand command, AssetBundleCollectorGroup group, string assetPath)
+        private string GetAddress(CollectCommand command, AssetBundleCollectorGroup group, AssetInfo assetInfo)
         {
             if (command.EnableAddressable == false)
                 return string.Empty;
@@ -274,15 +243,14 @@ namespace YooAsset.Editor
                 return string.Empty;
 
             IAddressRule addressRuleInstance = AssetBundleCollectorSettingData.GetAddressRuleInstance(AddressRuleName);
-			string adressValue = addressRuleInstance.GetAssetAddress(new AddressRuleData(assetPath, CollectPath, group.GroupName, UserData));
+            string adressValue = addressRuleInstance.GetAssetAddress(new AddressRuleData(assetInfo.AssetPath, CollectPath, group.GroupName, UserData));
             return adressValue;
         }
-		private string GetBundleName(CollectCommand command, AssetBundleCollectorGroup group, string assetPath)
+        private string GetBundleName(CollectCommand command, AssetBundleCollectorGroup group, AssetInfo assetInfo)
         {
             if (command.AutoCollectShaders)
             {
-				System.Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
+                if (assetInfo.IsShaderAsset())
-				if (assetType == typeof(UnityEngine.Shader) || assetType == typeof(UnityEngine.ShaderVariantCollection))
                 {
                     // 获取着色器打包规则结果
                     PackRuleResult shaderPackRuleResult = DefaultPackRule.CreateShadersPackRuleResult();
@@ -292,7 +260,7 @@ namespace YooAsset.Editor
 
             // 获取其它资源打包规则结果
             IPackRule packRuleInstance = AssetBundleCollectorSettingData.GetPackRuleInstance(PackRuleName);
-			PackRuleResult defaultPackRuleResult = packRuleInstance.GetPackRuleResult(new PackRuleData(assetPath, CollectPath, group.GroupName, UserData));
+            PackRuleResult defaultPackRuleResult = packRuleInstance.GetPackRuleResult(new PackRuleData(assetInfo.AssetPath, CollectPath, group.GroupName, UserData));
             return defaultPackRuleResult.GetBundleName(command.PackageName, command.UniqueBundleName);
         }
         private List<string> GetAssetTags(AssetBundleCollectorGroup group)
@@ -302,18 +270,19 @@ namespace YooAsset.Editor
             tags.AddRange(temper);
             return tags;
         }
-		private List<string> GetAllDependencies(CollectCommand command, string mainAssetPath)
+        private List<AssetInfo> GetAllDependencies(CollectCommand command, string mainAssetPath)
         {
             string[] depends = AssetDatabase.GetDependencies(mainAssetPath, true);
-			List<string> result = new List<string>(depends.Length);
+            List<AssetInfo> result = new List<AssetInfo>(depends.Length);
             foreach (string assetPath in depends)
             {
                 // 注意：排除主资源对象
                 if (assetPath == mainAssetPath)
                     continue;
 
-				if (IsValidateAsset(command, assetPath))
+                AssetInfo assetInfo = new AssetInfo(assetPath);
-					result.Add(assetPath);
+                if (command.IgnoreRule.IsIgnore(assetInfo) == false)
+                    result.Add(assetInfo);
             }
             return result;
         }

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorConfig.cs

@@ -10,7 +10,7 @@ namespace YooAsset.Editor
 {
     public class AssetBundleCollectorConfig
     {
-		public const string ConfigVersion = "v2.0.0";
+        public const string ConfigVersion = "v2.1";
 
         public const string XmlVersion = "Version";
         public const string XmlCommon = "Common";
@@ -25,7 +25,7 @@ namespace YooAsset.Editor
         public const string XmlEnableAddressable = "AutoAddressable";
         public const string XmlLocationToLower = "LocationToLower";
         public const string XmlIncludeAssetGUID = "IncludeAssetGUID";
-		public const string XmlIgnoreDefaultType = "IgnoreDefaultType";
+        public const string XmlIgnoreRuleName = "IgnoreRuleName";
 
         public const string XmlGroup = "Group";
         public const string XmlGroupActiveRule = "GroupActiveRule";
@@ -101,7 +101,7 @@ namespace YooAsset.Editor
                 package.EnableAddressable = packageElement.GetAttribute(XmlEnableAddressable) == "True" ? true : false;
                 package.LocationToLower = packageElement.GetAttribute(XmlLocationToLower) == "True" ? true : false;
                 package.IncludeAssetGUID = packageElement.GetAttribute(XmlIncludeAssetGUID) == "True" ? true : false;
-				package.IgnoreDefaultType = packageElement.GetAttribute(XmlIgnoreDefaultType) == "True" ? true : false;
+                package.IgnoreRuleName = packageElement.GetAttribute(XmlIgnoreRuleName);
                 packages.Add(package);
 
                 // 读取分组配置
@@ -213,7 +213,7 @@ namespace YooAsset.Editor
                 packageElement.SetAttribute(XmlEnableAddressable, package.EnableAddressable.ToString());
                 packageElement.SetAttribute(XmlLocationToLower, package.LocationToLower.ToString());
                 packageElement.SetAttribute(XmlIncludeAssetGUID, package.IncludeAssetGUID.ToString());
-				packageElement.SetAttribute(XmlIgnoreDefaultType, package.IgnoreDefaultType.ToString());
+                packageElement.SetAttribute(XmlIgnoreRuleName, package.IgnoreRuleName);
                 root.AppendChild(packageElement);
 
                 // 设置分组配置
@@ -258,6 +258,23 @@ namespace YooAsset.Editor
             if (configVersion == ConfigVersion)
                 return true;
 
+            // v2.0.0 -> v2.1
+            if (configVersion == "v2.0.0")
+            {
+                // 读取包裹配置
+                var packageNodeList = root.GetElementsByTagName(XmlPackage);
+                foreach (var packageNode in packageNodeList)
+                {
+                    XmlElement packageElement = packageNode as XmlElement;
+                    if (packageElement.HasAttribute(XmlIgnoreRuleName) == false)
+                        packageElement.SetAttribute(XmlIgnoreRuleName, nameof(NormalIgnoreRule));
+                }
+
+                // 更新版本
+                root.SetAttribute(XmlVersion, "v2.1");
+                return UpdateXmlConfig(xmlDoc);
+            }
+
             return false;
         }
     }

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorGroup.cs

@@ -44,6 +44,11 @@ namespace YooAsset.Editor
             if (AssetBundleCollectorSettingData.HasActiveRuleName(ActiveRuleName) == false)
                 throw new Exception($"Invalid {nameof(IActiveRule)} class type : {ActiveRuleName} in group : {GroupName}");
 
+            // 检测分组是否激活
+            IActiveRule activeRule = AssetBundleCollectorSettingData.GetActiveRuleInstance(ActiveRuleName);
+            if (activeRule.IsActiveGroup() == false)
+                return;
+
             foreach (var collector in Collectors)
             {
                 collector.CheckConfigError();
@@ -84,12 +89,12 @@ namespace YooAsset.Editor
             foreach (var collector in Collectors)
             {
                 var temper = collector.GetAllCollectAssets(command, this);
-				foreach (var assetInfo in temper)
+                foreach (var collectAsset in temper)
                 {
-					if (result.ContainsKey(assetInfo.AssetPath) == false)
+                    if (result.ContainsKey(collectAsset.AssetInfo.AssetPath) == false)
-						result.Add(assetInfo.AssetPath, assetInfo);
+                        result.Add(collectAsset.AssetInfo.AssetPath, collectAsset);
                     else
-						throw new Exception($"The collecting asset file is existed : {assetInfo.AssetPath} in group : {GroupName}");
+                        throw new Exception($"The collecting asset file is existed : {collectAsset.AssetInfo.AssetPath} in group : {GroupName}");
                 }
             }
 
@@ -97,12 +102,12 @@ namespace YooAsset.Editor
             if (command.EnableAddressable)
             {
                 var addressTemper = new Dictionary<string, string>();
-				foreach (var collectInfoPair in result)
+                foreach (var collectAssetPair in result)
                 {
-					if (collectInfoPair.Value.CollectorType == ECollectorType.MainAssetCollector)
+                    if (collectAssetPair.Value.CollectorType == ECollectorType.MainAssetCollector)
                     {
-						string address = collectInfoPair.Value.Address;
+                        string address = collectAssetPair.Value.Address;
-						string assetPath = collectInfoPair.Value.AssetPath;
+                        string assetPath = collectAssetPair.Value.AssetInfo.AssetPath;
                         if (string.IsNullOrEmpty(address))
                             continue;
 

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorPackage.cs

@@ -35,16 +35,16 @@ namespace YooAsset.Editor
         /// </summary>
         public bool IncludeAssetGUID = false;
 
-		/// <summary>
-		/// 忽略Unity引擎无法识别的文件
-		/// </summary>
-		public bool IgnoreDefaultType = true;
-
         /// <summary>
         /// 自动收集所有着色器（所有着色器存储在一个资源包内）
         /// </summary>
         public bool AutoCollectShaders = true;
 
+        /// <summary>
+        /// 资源忽略规则名
+        /// </summary>
+        public string IgnoreRuleName = nameof(NormalIgnoreRule);
+
         /// <summary>
         /// 分组列表
         /// </summary>
@@ -56,6 +56,16 @@ namespace YooAsset.Editor
         /// </summary>
         public void CheckConfigError()
         {
+            if (string.IsNullOrEmpty(IgnoreRuleName))
+            {
+                throw new Exception($"{nameof(IgnoreRuleName)} is null or empty !");
+            }
+            else
+            {
+                if (AssetBundleCollectorSettingData.HasIgnoreRuleName(IgnoreRuleName) == false)
+                    throw new Exception($"Invalid {nameof(IIgnoreRule)} class type : {IgnoreRuleName} in package : {PackageName}");
+            }
+
             foreach (var group in Groups)
             {
                 group.CheckConfigError();
@@ -68,6 +78,14 @@ namespace YooAsset.Editor
         public bool FixConfigError()
         {
             bool isFixed = false;
+
+            if (string.IsNullOrEmpty(IgnoreRuleName))
+            {
+                Debug.LogWarning($"Set the {nameof(IgnoreRuleName)} to {nameof(NormalIgnoreRule)}");
+                IgnoreRuleName = nameof(NormalIgnoreRule);
+                isFixed = true;
+            }
+
             foreach (var group in Groups)
             {
                 if (group.FixConfigError())
@@ -75,6 +93,7 @@ namespace YooAsset.Editor
                     isFixed = true;
                 }
             }
+
             return isFixed;
         }
 
@@ -89,12 +108,12 @@ namespace YooAsset.Editor
             foreach (var group in Groups)
             {
                 var temper = group.GetAllCollectAssets(command);
-				foreach (var assetInfo in temper)
+                foreach (var collectAsset in temper)
                 {
-					if (result.ContainsKey(assetInfo.AssetPath) == false)
+                    if (result.ContainsKey(collectAsset.AssetInfo.AssetPath) == false)
-						result.Add(assetInfo.AssetPath, assetInfo);
+                        result.Add(collectAsset.AssetInfo.AssetPath, collectAsset);
                     else
-						throw new Exception($"The collecting asset file is existed : {assetInfo.AssetPath}");
+                        throw new Exception($"The collecting asset file is existed : {collectAsset.AssetInfo.AssetPath}");
                 }
             }
 
@@ -107,7 +126,7 @@ namespace YooAsset.Editor
                     if (collectInfoPair.Value.CollectorType == ECollectorType.MainAssetCollector)
                     {
                         string address = collectInfoPair.Value.Address;
-						string assetPath = collectInfoPair.Value.AssetPath;
+                        string assetPath = collectInfoPair.Value.AssetInfo.AssetPath;
                         if (string.IsNullOrEmpty(address))
                             continue;
 

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorSetting.cs

@@ -24,7 +24,6 @@ namespace YooAsset.Editor
         /// </summary>
         public bool UniqueBundleName = false;
 
-
         /// <summary>
         /// 包裹列表
         /// </summary>
@@ -100,13 +99,13 @@ namespace YooAsset.Editor
             package.CheckConfigError();
 
             // 创建资源收集命令
+            IIgnoreRule ignoreRule = AssetBundleCollectorSettingData.GetIgnoreRuleInstance(package.IgnoreRuleName);
             CollectCommand command = new CollectCommand(buildMode, packageName,
                  package.EnableAddressable,
                  package.LocationToLower,
                  package.IncludeAssetGUID,
-				 package.IgnoreDefaultType,
                  package.AutoCollectShaders,
-				 UniqueBundleName);
+                 UniqueBundleName, ignoreRule);
 
             // 获取收集的资源集合
             CollectResult collectResult = new CollectResult(command);

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorSettingData.cs

@@ -21,6 +21,9 @@ namespace YooAsset.Editor
         private static readonly Dictionary<string, System.Type> _cacheFilterRuleTypes = new Dictionary<string, System.Type>();
         private static readonly Dictionary<string, IFilterRule> _cacheFilterRuleInstance = new Dictionary<string, IFilterRule>();
 
+        private static readonly Dictionary<string, System.Type> _cacheIgnoreRuleTypes = new Dictionary<string, System.Type>();
+        private static readonly Dictionary<string, IIgnoreRule> _cacheIgnoreRuleInstance = new Dictionary<string, IIgnoreRule>();
+
         /// <summary>
         /// 配置数据是否被修改
         /// </summary>
@@ -129,6 +132,29 @@ namespace YooAsset.Editor
                         _cacheActiveRuleTypes.Add(type.Name, type);
                 }
             }
+
+            // IIgnoreRule
+            {
+                // 清空缓存集合
+                _cacheIgnoreRuleTypes.Clear();
+                _cacheIgnoreRuleInstance.Clear();
+
+                // 获取所有类型
+                List<Type> types = new List<Type>(100)
+                {
+                    typeof(NormalIgnoreRule),
+                    typeof(RawFileIgnoreRule),
+                };
+
+                var customTypes = EditorTools.GetAssignableTypes(typeof(IIgnoreRule));
+                types.AddRange(customTypes);
+                for (int i = 0; i < types.Count; i++)
+                {
+                    Type type = types[i];
+                    if (_cacheIgnoreRuleTypes.ContainsKey(type.Name) == false)
+                        _cacheIgnoreRuleTypes.Add(type.Name, type);
+                }
+            }
         }
 
         private static AssetBundleCollectorSetting _setting = null;
@@ -165,6 +191,7 @@ namespace YooAsset.Editor
             if (isFixed)
             {
                 IsDirty = true;
+                Debug.Log("Fix package config error done !");
             }
         }
 
@@ -225,6 +252,18 @@ namespace YooAsset.Editor
             }
             return names;
         }
+        public static List<RuleDisplayName> GetIgnoreRuleNames()
+        {
+            List<RuleDisplayName> names = new List<RuleDisplayName>();
+            foreach (var pair in _cacheIgnoreRuleTypes)
+            {
+                RuleDisplayName ruleName = new RuleDisplayName();
+                ruleName.ClassName = pair.Key;
+                ruleName.DisplayName = GetRuleDisplayName(pair.Key, pair.Value);
+                names.Add(ruleName);
+            }
+            return names;
+        }
         private static string GetRuleDisplayName(string name, Type type)
         {
             var attribute = DisplayNameAttributeHelper.GetAttribute<DisplayNameAttribute>(type);
@@ -236,19 +275,23 @@ namespace YooAsset.Editor
 
         public static bool HasActiveRuleName(string ruleName)
         {
-			return _cacheActiveRuleTypes.Keys.Contains(ruleName);
+            return _cacheActiveRuleTypes.ContainsKey(ruleName);
         }
         public static bool HasAddressRuleName(string ruleName)
         {
-			return _cacheAddressRuleTypes.Keys.Contains(ruleName);
+            return _cacheAddressRuleTypes.ContainsKey(ruleName);
         }
         public static bool HasPackRuleName(string ruleName)
         {
-			return _cachePackRuleTypes.Keys.Contains(ruleName);
+            return _cachePackRuleTypes.ContainsKey(ruleName);
         }
         public static bool HasFilterRuleName(string ruleName)
         {
-			return _cacheFilterRuleTypes.Keys.Contains(ruleName);
+            return _cacheFilterRuleTypes.ContainsKey(ruleName);
+        }
+        public static bool HasIgnoreRuleName(string ruleName)
+        {
+            return _cacheIgnoreRuleTypes.ContainsKey(ruleName);
         }
 
         public static IActiveRule GetActiveRuleInstance(string ruleName)
@@ -319,6 +362,23 @@ namespace YooAsset.Editor
                 throw new Exception($"{nameof(IFilterRule)} is invalid：{ruleName}");
             }
         }
+        public static IIgnoreRule GetIgnoreRuleInstance(string ruleName)
+        {
+            if (_cacheIgnoreRuleInstance.TryGetValue(ruleName, out IIgnoreRule instance))
+                return instance;
+
+            // 如果不存在创建类的实例
+            if (_cacheIgnoreRuleTypes.TryGetValue(ruleName, out Type type))
+            {
+                instance = (IIgnoreRule)Activator.CreateInstance(type);
+                _cacheIgnoreRuleInstance.Add(ruleName, instance);
+                return instance;
+            }
+            else
+            {
+                throw new Exception($"{nameof(IIgnoreRule)} is invalid：{ruleName}");
+            }
+        }
 
         // 公共参数编辑相关
         public static void ModifyShowPackageView(bool showPackageView)

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorWindow.cs

@@ -24,6 +24,7 @@ namespace YooAsset.Editor
         private List<RuleDisplayName> _addressRuleList;
         private List<RuleDisplayName> _packRuleList;
         private List<RuleDisplayName> _filterRuleList;
+        private List<RuleDisplayName> _ignoreRuleList;
 
         private VisualElement _helpBoxContainer;
 
@@ -39,8 +40,8 @@ namespace YooAsset.Editor
         private Toggle _enableAddressableToogle;
         private Toggle _locationToLowerToogle;
         private Toggle _includeAssetGUIDToogle;
-		private Toggle _ignoreDefaultTypeToogle;
         private Toggle _autoCollectShadersToogle;
+        private PopupField<RuleDisplayName> _ignoreRulePopupField;
         
         private VisualElement _packageContainer;
         private ListView _packageListView;
@@ -65,9 +66,6 @@ namespace YooAsset.Editor
 
         public void CreateGUI()
         {
-			Undo.undoRedoPerformed -= RefreshWindow;
-			Undo.undoRedoPerformed += RefreshWindow;
-
             try
             {
                 _collectorTypeList = new List<string>()
@@ -80,6 +78,7 @@ namespace YooAsset.Editor
                 _addressRuleList = AssetBundleCollectorSettingData.GetAddressRuleNames();
                 _packRuleList = AssetBundleCollectorSettingData.GetPackRuleNames();
                 _filterRuleList = AssetBundleCollectorSettingData.GetFilterRuleNames();
+                _ignoreRuleList = AssetBundleCollectorSettingData.GetIgnoreRuleNames();
 
                 VisualElement root = this.rootVisualElement;
 
@@ -154,17 +153,6 @@ namespace YooAsset.Editor
                         RefreshWindow();
                     }
                 });
-				_ignoreDefaultTypeToogle = root.Q<Toggle>("IgnoreDefaultType");
-				_ignoreDefaultTypeToogle.RegisterValueChangedCallback(evt =>
-				{
-					var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
-					if (selectPackage != null)
-					{
-						selectPackage.IgnoreDefaultType = evt.newValue;
-						AssetBundleCollectorSettingData.ModifyPackage(selectPackage);
-						RefreshWindow();
-					}
-				});
                 _autoCollectShadersToogle = root.Q<Toggle>("AutoCollectShaders");
                 _autoCollectShadersToogle.RegisterValueChangedCallback(evt =>
                 {
@@ -176,6 +164,25 @@ namespace YooAsset.Editor
                         RefreshWindow();
                     }
                 });
+                {
+                    _ignoreRulePopupField = new PopupField<RuleDisplayName>(_ignoreRuleList, 0);
+                    _ignoreRulePopupField.label = "File Ignore Rule";
+                    _ignoreRulePopupField.name = "IgnoreRulePopupField";
+                    _ignoreRulePopupField.style.unityTextAlign = TextAnchor.MiddleLeft;
+                    _ignoreRulePopupField.style.width = 300;
+                    _ignoreRulePopupField.formatListItemCallback = FormatListItemCallback;
+                    _ignoreRulePopupField.formatSelectedValueCallback = FormatSelectedValueCallback;
+                    _ignoreRulePopupField.RegisterValueChangedCallback(evt => 
+                    {
+                        var selectPackage = _packageListView.selectedItem as AssetBundleCollectorPackage;
+                        if(selectPackage != null)
+                        {
+                            selectPackage.IgnoreRuleName = evt.newValue.ClassName;
+                            AssetBundleCollectorSettingData.ModifyPackage(selectPackage);
+                        }
+                    });
+                    _setting2Container.Add(_ignoreRulePopupField);
+                }
 
                 // 配置修复按钮
                 var fixBtn = root.Q<Button>("FixButton");
@@ -347,6 +354,15 @@ namespace YooAsset.Editor
                 Debug.LogError(e.ToString());
             }
         }
+        public void OnEnable()
+        {
+            Undo.undoRedoPerformed += RefreshWindow;
+        }
+        public void OnDisable()
+        {
+            if (Undo.undoRedoPerformed != null)
+                Undo.undoRedoPerformed -= RefreshWindow;
+        }
         public void OnDestroy()
         {
             // 注意：清空所有撤销操作
@@ -469,7 +485,8 @@ namespace YooAsset.Editor
                 _enableAddressableToogle.SetValueWithoutNotify(selectPackage.EnableAddressable);
                 _locationToLowerToogle.SetValueWithoutNotify(selectPackage.LocationToLower);
                 _includeAssetGUIDToogle.SetValueWithoutNotify(selectPackage.IncludeAssetGUID);
-				_ignoreDefaultTypeToogle.SetValueWithoutNotify(selectPackage.IgnoreDefaultType);
+                _autoCollectShadersToogle.SetValueWithoutNotify(selectPackage.AutoCollectShaders);
+                _ignoreRulePopupField.SetValueWithoutNotify(GetIgnoreRuleIndex(selectPackage.IgnoreRuleName));
             }
             else
             {
@@ -963,7 +980,7 @@ namespace YooAsset.Editor
 
             if (collector.IsValid() == false)
             {
-				Debug.LogWarning($"The collector is invalid : {collector.CollectPath} in group : {group.GroupName}");
+                collector.CheckConfigError();
                 return;
             }
 
@@ -973,14 +990,15 @@ namespace YooAsset.Editor
 
                 try
                 {
+                    IIgnoreRule ignoreRule = AssetBundleCollectorSettingData.GetIgnoreRuleInstance(_ignoreRulePopupField.value.ClassName);
                     CollectCommand command = new CollectCommand(EBuildMode.SimulateBuild,
                         _packageNameTxt.value,
                         _enableAddressableToogle.value,
                         _locationToLowerToogle.value,
                         _includeAssetGUIDToogle.value,
-						_ignoreDefaultTypeToogle.value,
                         _autoCollectShadersToogle.value,
-						_uniqueBundleNameToogle.value);
+                        _uniqueBundleNameToogle.value,
+                        ignoreRule);
                     collector.CheckConfigError();
                     collectAssetInfos = collector.GetAllCollectAssets(command, group);
                 }
@@ -991,15 +1009,15 @@ namespace YooAsset.Editor
 
                 if (collectAssetInfos != null)
                 {
-					foreach (var collectAssetInfo in collectAssetInfos)
+                    foreach (var collectAsset in collectAssetInfos)
                     {
                         VisualElement elementRow = new VisualElement();
                         elementRow.style.flexDirection = FlexDirection.Row;
                         foldout.Add(elementRow);
 
-						string showInfo = collectAssetInfo.AssetPath;
+                        string showInfo = collectAsset.AssetInfo.AssetPath;
                         if (_enableAddressableToogle.value)
-							showInfo = $"[{collectAssetInfo.Address}] {collectAssetInfo.AssetPath}";
+                            showInfo = $"[{collectAsset.Address}] {collectAsset.AssetInfo.AssetPath}";
 
                         var label = new Label();
                         label.text = showInfo;
@@ -1071,6 +1089,15 @@ namespace YooAsset.Editor
             }
             return 0;
         }
+        private RuleDisplayName GetIgnoreRuleIndex(string ruleName)
+        {
+            for (int i = 0; i < _ignoreRuleList.Count; i++)
+            {
+                if (_ignoreRuleList[i].ClassName == ruleName)
+                    return _ignoreRuleList[i];
+            }
+            return _ignoreRuleList[0];
+        }
         private RuleDisplayName GetActiveRuleIndex(string ruleName)
         {
             for (int i = 0; i < _activeRuleList.Count; i++)

Assets/YooAsset/Editor/AssetBundleCollector/AssetBundleCollectorWindow.uxml

@@ -21,7 +21,6 @@
                 <ui:Toggle label="Enable Addressable" name="EnableAddressable" style="width: 196px; -unity-text-align: middle-left;" />
                 <ui:Toggle label="Location To Lower" name="LocationToLower" style="width: 196px; -unity-text-align: middle-left;" />
                 <ui:Toggle label="Include Asset GUID" name="IncludeAssetGUID" style="width: 196px; -unity-text-align: middle-left;" />
-                <ui:Toggle label="Ignore Default Type" name="IgnoreDefaultType" style="width: 196px; -unity-text-align: middle-left;" />
                 <ui:Toggle label="Auto Collect Shaders" name="AutoCollectShaders" value="true" style="width: 196px; -unity-text-align: middle-left;" />
             </ui:VisualElement>
         </ui:VisualElement>

Assets/YooAsset/Editor/AssetBundleCollector/CollectAssetInfo.cs

@@ -21,9 +21,9 @@ namespace YooAsset.Editor
         public string Address { private set; get; }
 
         /// <summary>
-		/// 资源路径
+        /// 资源信息
         /// </summary>
-		public string AssetPath { private set; get; }
+        public AssetInfo AssetInfo { private set; get; }
 
         /// <summary>
         /// 资源分类标签
@@ -33,15 +33,15 @@ namespace YooAsset.Editor
         /// <summary>
         /// 依赖的资源列表
         /// </summary>
-		public List<string> DependAssets = new List<string>();
+        public List<AssetInfo> DependAssets = new List<AssetInfo>();
 
 
-		public CollectAssetInfo(ECollectorType collectorType, string bundleName, string address, string assetPath, List<string> assetTags)
+        public CollectAssetInfo(ECollectorType collectorType, string bundleName, string address, AssetInfo assetInfo, List<string> assetTags)
         {
             CollectorType = collectorType;
             BundleName = bundleName;
             Address = address;
-			AssetPath = assetPath;
+            AssetInfo = assetInfo;
             AssetTags = assetTags;
         }
     }

Assets/YooAsset/Editor/AssetBundleCollector/CollectCommand.cs

@@ -13,11 +13,6 @@ namespace YooAsset.Editor
         /// </summary>
         public string PackageName { private set; get; }
 
-		/// <summary>
-		/// 忽略Unity引擎无法识别的文件
-		/// </summary>
-		public bool IgnoreDefaultType { private set; get; }
-
         /// <summary>
         /// 启用可寻址资源定位
         /// </summary>
@@ -48,17 +43,24 @@ namespace YooAsset.Editor
         /// </summary>
         public string ShadersBundleName { private set; get; }
 
+        /// <summary>
+        /// 忽略规则实例
+        /// </summary>
+        public IIgnoreRule IgnoreRule { private set; get; }
 
-		public CollectCommand(EBuildMode buildMode, string packageName, bool enableAddressable, bool locationToLower, bool includeAssetGUID, bool ignoreDefaultType, bool autoCollectShaders, bool uniqueBundleName)
+
+        public CollectCommand(EBuildMode buildMode, string packageName,
+            bool enableAddressable, bool locationToLower, bool includeAssetGUID, 
+            bool autoCollectShaders, bool uniqueBundleName, IIgnoreRule ignoreRule)
         {
             BuildMode = buildMode;
             PackageName = packageName;
             EnableAddressable = enableAddressable;
             LocationToLower = locationToLower;
             IncludeAssetGUID = includeAssetGUID;
-			IgnoreDefaultType = ignoreDefaultType;
             AutoCollectShaders = autoCollectShaders;
             UniqueBundleName = uniqueBundleName;
+            IgnoreRule = ignoreRule;
 
             // 着色器统一全名称
             var packRuleResult = DefaultPackRule.CreateShadersPackRuleResult();

Assets/YooAsset/Editor/AssetBundleCollector/CollectRules/IIgnoreRule.cs

@@ -0,0 +1,11 @@
+
+namespace YooAsset.Editor
+{
+    /// <summary>
+    /// 资源忽略规则接口
+    /// </summary>
+    public interface  IIgnoreRule
+    {
+        bool IsIgnore(AssetInfo assetInfo);
+    }
+}

Assets/YooAsset/Editor/AssetBundleCollector/CollectRules/IIgnoreRule.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: f01d5c82be95c8f4b93aeefc0454ae5c
+guid: bd55753dbb880fa449bf4e37b33d8ba7
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/YooAsset/Editor/AssetBundleCollector/CollectRules/IPackRule.cs

@@ -28,19 +28,41 @@ namespace YooAsset.Editor
             _bundleExtension = bundleExtension;
         }
 
+        /// <summary>
+        /// 结果是否有效
+        /// </summary>
+        public bool IsValid()
+        {
+            return string.IsNullOrEmpty(_bundleName) == false && string.IsNullOrEmpty(_bundleExtension) == false;
+        }
+
         /// <summary>
         /// 获取资源包全名称
         /// </summary>
         public string GetBundleName(string packageName, bool uniqueBundleName)
         {
             string fullName;
-			string bundleName = EditorTools.GetRegularPath(_bundleName).Replace('/', '_').Replace('.', '_').ToLower();
+            string bundleName = EditorTools.GetRegularPath(_bundleName).Replace('/', '_').Replace('.', '_').Replace(" ", "_").ToLower();
             if (uniqueBundleName)
                 fullName = $"{packageName}_{bundleName}.{_bundleExtension}";
             else
                 fullName = $"{bundleName}.{_bundleExtension}";
             return fullName.ToLower();
         }
+
+        /// <summary>
+        /// 获取共享资源包全名称
+        /// </summary>
+        public string GetShareBundleName(string packageName, bool uniqueBundleName)
+        {
+            string fullName;
+            string bundleName = EditorTools.GetRegularPath(_bundleName).Replace('/', '_').Replace('.', '_').Replace(" ", "_").ToLower();
+            if (uniqueBundleName)
+                fullName = $"{packageName}_share_{bundleName}.{_bundleExtension}";
+            else
+                fullName = $"share_{bundleName}.{_bundleExtension}";
+            return fullName.ToLower();
+        }
     }
 
     /// <summary>

Assets/YooAsset/Editor/AssetBundleCollector/DefaultRules/DefaultFilterRule.cs

@@ -6,22 +6,6 @@ using UnityEditor;
 
 namespace YooAsset.Editor
 {
-	public class DefaultFilterRule
-	{
-		/// <summary>
-		/// 忽略的文件类型
-		/// </summary>
-		private readonly static HashSet<string> _ignoreFileExtensions = new HashSet<string>() { "", ".so", ".dll", ".cs", ".js", ".boo", ".meta", ".cginc", ".hlsl" };
-
-		/// <summary>
-		/// 查询是否为忽略文件
-		/// </summary>
-		public static bool IsIgnoreFile(string fileExtension)
-		{
-			return _ignoreFileExtensions.Contains(fileExtension);
-		}
-	}
-
     [DisplayName("收集所有资源")]
     public class CollectAll : IFilterRule
     {
@@ -36,7 +20,8 @@ namespace YooAsset.Editor
     {
         public bool IsCollectAsset(FilterRuleData data)
         {
-			return Path.GetExtension(data.AssetPath) == ".unity";
+            string extension = Path.GetExtension(data.AssetPath);
+            return extension == ".unity" || extension == ".scene";
         }
     }
 
@@ -70,6 +55,15 @@ namespace YooAsset.Editor
         }
     }
 
+    [DisplayName("收集着色器")]
+    public class CollectShader : IFilterRule
+    {
+        public bool IsCollectAsset(FilterRuleData data)
+        {
+            return Path.GetExtension(data.AssetPath) == ".shader";
+        }
+    }
+
     [DisplayName("收集着色器变种集合")]
     public class CollectShaderVariants : IFilterRule
     {

Assets/YooAsset/Editor/AssetBundleCollector/DefaultRules/DefaultIgnoreRule.cs

@@ -0,0 +1,82 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+    public class DefaultIgnoreRule
+    {
+        /// <summary>
+        /// 忽略的文件类型
+        /// </summary>
+        public readonly static HashSet<string> IgnoreFileExtensions = new HashSet<string>() { "", ".so", ".dll", ".cs", ".js", ".boo", ".meta", ".cginc", ".hlsl" };
+    }
+
+    /// <summary>
+    /// 适配常规的资源构建管线
+    /// </summary>
+    public class NormalIgnoreRule : IIgnoreRule
+    {
+        /// <summary>
+        /// 查询是否为忽略文件
+        /// </summary>
+        public bool IsIgnore(AssetInfo assetInfo)
+        {
+            if (assetInfo.AssetPath.StartsWith("Assets/") == false && assetInfo.AssetPath.StartsWith("Packages/") == false)
+            {
+                UnityEngine.Debug.LogError($"Invalid asset path : {assetInfo.AssetPath}");
+                return true;
+            }
+
+            // 忽略文件夹
+            if (AssetDatabase.IsValidFolder(assetInfo.AssetPath))
+                return true;
+
+            // 忽略编辑器下的类型资源
+            if (assetInfo.AssetType == typeof(LightingDataAsset))
+                return true;
+            if (assetInfo.AssetType == typeof(LightmapParameters))
+                return true;
+
+            // 忽略Unity引擎无法识别的文件
+            if (assetInfo.AssetType == typeof(UnityEditor.DefaultAsset))
+            {
+                UnityEngine.Debug.LogWarning($"Cannot pack default asset : {assetInfo.AssetPath}");
+                return true;
+            }
+
+            return DefaultIgnoreRule.IgnoreFileExtensions.Contains(assetInfo.FileExtension);
+        }
+    }
+
+    /// <summary>
+    /// 适配原生文件构建管线
+    /// </summary>
+    public class RawFileIgnoreRule : IIgnoreRule
+    {
+        /// <summary>
+        /// 查询是否为忽略文件
+        /// </summary>
+        public bool IsIgnore(AssetInfo assetInfo)
+        {
+            if (assetInfo.AssetPath.StartsWith("Assets/") == false && assetInfo.AssetPath.StartsWith("Packages/") == false)
+            {
+                UnityEngine.Debug.LogError($"Invalid asset path : {assetInfo.AssetPath}");
+                return true;
+            }
+
+            // 忽略文件夹
+            if (AssetDatabase.IsValidFolder(assetInfo.AssetPath))
+                return true;
+
+            // 忽略编辑器下的类型资源
+            if (assetInfo.AssetType == typeof(LightingDataAsset))
+                return true;
+            if (assetInfo.AssetType == typeof(LightmapParameters))
+                return true;
+
+            return DefaultIgnoreRule.IgnoreFileExtensions.Contains(assetInfo.FileExtension);
+        }
+    }
+}

Assets/YooAsset/Editor/AssetBundleCollector/DefaultRules/DefaultIgnoreRule.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: e4a97c06e069c1146a881fcb359f9b4b
+guid: b9c1900577194bb4ab49ce4332ccc4bc
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/YooAsset/Editor/AssetBundleCollector/DefaultRules/DefaultPackRule.cs

@@ -147,6 +147,18 @@ namespace YooAsset.Editor
         }
     }
 
+    /// <summary>
+    /// 打包着色器
+    /// </summary>
+    [DisplayName("打包着色器文件")]
+    public class PackShader : IPackRule
+    {
+        public PackRuleResult GetPackRuleResult(PackRuleData data)
+        {
+            return DefaultPackRule.CreateShadersPackRuleResult();
+        }
+    }
+
     /// <summary>
     /// 打包着色器变种集合
     /// </summary>

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

@@ -189,7 +189,7 @@ namespace YooAsset.Editor
 
             // Status
             StyleColor textColor;
-			if (bundleInfo.Status == BundleLoaderBase.EStatus.Failed.ToString())
+            if (bundleInfo.Status == EOperationStatus.Failed)
                 textColor = new StyleColor(Color.yellow);
             else
                 textColor = label1.style.color;

Assets/YooAsset/Editor/AssetBundleReporter/AssetBundleRecorder.cs

@@ -36,7 +36,7 @@ namespace YooAsset.Editor
             else
             {
                 AssetBundle newBundle = AssetBundle.LoadFromFile(filePath);
-				if(newBundle != null)
+                if (newBundle != null)
                 {
                     string[] assetNames = newBundle.GetAllAssetNames();
                     foreach (string name in assetNames)
@@ -54,7 +54,7 @@ namespace YooAsset.Editor
         /// </summary>
         public static void UnloadAll()
         {
-			foreach(var valuePair in _loadedAssetBundles)
+            foreach (var valuePair in _loadedAssetBundles)
             {
                 if (valuePair.Value != null)
                     valuePair.Value.Unload(true);

Assets/YooAsset/Editor/AssetBundleReporter/AssetBundleReporterWindow.cs

@@ -35,18 +35,12 @@ namespace YooAsset.Editor
             /// 资源包视图
             /// </summary>
             BundleView,
-
-			/// <summary>
-			/// 冗余资源试图
-			/// </summary>
-			Redundancy,
         }
 
         private ToolbarMenu _viewModeMenu;
         private ReporterSummaryViewer _summaryViewer;
         private ReporterAssetListViewer _assetListViewer;
         private ReporterBundleListViewer _bundleListViewer;
-		private ReporterRedundancyListViewer _redundancyListViewer;
 
         private EViewMode _viewMode;
         private BuildReport _buildReport;
@@ -76,7 +70,6 @@ namespace YooAsset.Editor
                 _viewModeMenu.menu.AppendAction(EViewMode.Summary.ToString(), ViewModeMenuAction0, ViewModeMenuFun0);
                 _viewModeMenu.menu.AppendAction(EViewMode.AssetView.ToString(), ViewModeMenuAction1, ViewModeMenuFun1);
                 _viewModeMenu.menu.AppendAction(EViewMode.BundleView.ToString(), ViewModeMenuAction2, ViewModeMenuFun2);
-				_viewModeMenu.menu.AppendAction(EViewMode.Redundancy.ToString(), ViewModeMenuAction3, ViewModeMenuFun3);
 
                 // 搜索栏
                 var searchField = root.Q<ToolbarSearchField>("SearchField");
@@ -94,10 +87,6 @@ namespace YooAsset.Editor
                 _bundleListViewer = new ReporterBundleListViewer();
                 _bundleListViewer.InitViewer();
 
-				// 加载试图
-				_redundancyListViewer = new ReporterRedundancyListViewer();
-				_redundancyListViewer.InitViewer();
-
                 // 显示视图
                 _viewMode = EViewMode.Summary;
                 _viewModeMenu.text = EViewMode.Summary.ToString();
@@ -125,7 +114,6 @@ namespace YooAsset.Editor
             _summaryViewer.FillViewData(_buildReport);
             _assetListViewer.FillViewData(_buildReport, _searchKeyWord);
             _bundleListViewer.FillViewData(_buildReport, _reportFilePath, _searchKeyWord);
-			_redundancyListViewer.FillViewData(_buildReport, _searchKeyWord);
         }
         private void OnSearchKeyWordChange(ChangeEvent<string> e)
         {
@@ -146,7 +134,6 @@ namespace YooAsset.Editor
                 _summaryViewer.AttachParent(root);
                 _assetListViewer.DetachParent();
                 _bundleListViewer.DetachParent();
-				_redundancyListViewer.DetachParent();
             }
         }
         private void ViewModeMenuAction1(DropdownMenuAction action)
@@ -159,7 +146,6 @@ namespace YooAsset.Editor
                 _summaryViewer.DetachParent();
                 _assetListViewer.AttachParent(root);
                 _bundleListViewer.DetachParent();
-				_redundancyListViewer.DetachParent();
             }
         }
         private void ViewModeMenuAction2(DropdownMenuAction action)
@@ -172,20 +158,6 @@ namespace YooAsset.Editor
                 _summaryViewer.DetachParent();
                 _assetListViewer.DetachParent();
                 _bundleListViewer.AttachParent(root);
-				_redundancyListViewer.DetachParent();
-			}
-		}
-		private void ViewModeMenuAction3(DropdownMenuAction action)
-		{
-			if (_viewMode != EViewMode.Redundancy)
-			{
-				_viewMode = EViewMode.Redundancy;
-				VisualElement root = this.rootVisualElement;
-				_viewModeMenu.text = EViewMode.Redundancy.ToString();
-				_summaryViewer.DetachParent();
-				_assetListViewer.DetachParent();
-				_bundleListViewer.DetachParent();
-				_redundancyListViewer.AttachParent(root);
             }
         }
         private DropdownMenuAction.Status ViewModeMenuFun0(DropdownMenuAction action)
@@ -209,13 +181,6 @@ namespace YooAsset.Editor
             else
                 return DropdownMenuAction.Status.Normal;
         }
-		private DropdownMenuAction.Status ViewModeMenuFun3(DropdownMenuAction action)
-		{
-			if (_viewMode == EViewMode.Redundancy)
-				return DropdownMenuAction.Status.Checked;
-			else
-				return DropdownMenuAction.Status.Normal;
-		}
     }
 }
 #endif

Assets/YooAsset/Editor/AssetBundleReporter/BuildReport.cs

@@ -28,10 +28,9 @@ namespace YooAsset.Editor
         public List<ReportBundleInfo> BundleInfos = new List<ReportBundleInfo>();
 
         /// <summary>
-		/// 冗余的资源列表
+        /// 未被依赖的资源列表
         /// </summary>
-		public List<ReportRedundancyInfo> RedundancyInfos = new List<ReportRedundancyInfo>();
+        public List<ReportIndependAsset> IndependAssets = new List<ReportIndependAsset>();
-		
 
         /// <summary>
         /// 获取资源包信息类

Assets/YooAsset/Editor/AssetBundleReporter/ReportIndependAsset.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+    [Serializable]
+    public class ReportIndependAsset
+    {
+        /// <summary>
+        /// 资源路径
+        /// </summary>
+        public string AssetPath;
+
+        /// <summary>
+        /// 资源GUID
+        /// </summary>
+        public string AssetGUID;
+
+        /// <summary>
+        /// 资源类型
+        /// </summary>
+        public string AssetType;
+
+        /// <summary>
+        /// 资源文件大小
+        /// </summary>
+        public long FileSize;
+    }
+}

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 7fbb7b27f54d3b0439a951348fd9d785
+guid: 6f187b12ce298c0429119fcf194f2621
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/YooAsset/Editor/AssetBundleReporter/ReportRedundancyInfo.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace YooAsset.Editor
-{
-	[Serializable]
-	public class ReportRedundancyInfo
-	{
-		/// <summary>
-		/// 资源路径
-		/// </summary>
-		public string AssetPath;
-
-		/// <summary>
-		/// 资源类型
-		/// </summary>
-		public string AssetType;
-
-		/// <summary>
-		/// 资源GUID
-		/// 说明：Meta文件记录的GUID
-		/// </summary>
-		public string AssetGUID;
-
-		/// <summary>
-		/// 资源文件大小
-		/// </summary>
-		public long FileSize;
-
-		/// <summary>
-		/// 冗余的资源包数量
-		/// </summary>
-		public int Number;
-	}
-}

Assets/YooAsset/Editor/AssetBundleReporter/ReportSummary.cs

@@ -58,10 +58,11 @@ namespace YooAsset.Editor
         public bool EnableAddressable;
         public bool LocationToLower;
         public bool IncludeAssetGUID;
-		public bool IgnoreDefaultType;
         public bool AutoCollectShaders;
+        public string IgnoreRuleName;
 
         // 构建参数
+        public bool EnableSharePackRule;
         public string EncryptionClassName;
         public EFileNameStyle FileNameStyle;
         public ECompressOption CompressOption;

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

@@ -1,317 +0,0 @@
-#if UNITY_2019_4_OR_NEWER
-using System;
-using System.Linq;
-using System.Collections.Generic;
-using UnityEditor;
-using UnityEngine;
-using UnityEditor.UIElements;
-using UnityEngine.UIElements;
-
-namespace YooAsset.Editor
-{
-	internal class ReporterRedundancyListViewer
-	{
-		private enum ESortMode
-		{
-			AssetPath,
-			AssetType,
-			FileSize,
-			Number,
-		}
-
-		private VisualTreeAsset _visualAsset;
-		private TemplateContainer _root;
-
-		private ToolbarButton _topBar1;
-		private ToolbarButton _topBar2;
-		private ToolbarButton _topBar3;
-		private ToolbarButton _topBar4;
-		private ListView _assetListView;
-
-		private BuildReport _buildReport;
-		private string _searchKeyWord;
-		private ESortMode _sortMode = ESortMode.AssetPath;
-		private bool _descendingSort = false;
-
-
-		/// <summary>
-		/// 初始化页面
-		/// </summary>
-		public void InitViewer()
-		{
-			// 加载布局文件
-			_visualAsset = UxmlLoader.LoadWindowUXML<ReporterRedundancyListViewer>();
-			if (_visualAsset == null)
-				return;
-
-			_root = _visualAsset.CloneTree();
-			_root.style.flexGrow = 1f;
-
-			// 顶部按钮栏
-			_topBar1 = _root.Q<ToolbarButton>("TopBar1");
-			_topBar2 = _root.Q<ToolbarButton>("TopBar2");
-			_topBar3 = _root.Q<ToolbarButton>("TopBar3");
-			_topBar4 = _root.Q<ToolbarButton>("TopBar4");
-			_topBar1.clicked += TopBar1_clicked;
-			_topBar2.clicked += TopBar2_clicked;
-			_topBar3.clicked += TopBar3_clicked;
-			_topBar4.clicked += TopBar4_clicked;
-
-			// 资源列表
-			_assetListView = _root.Q<ListView>("TopListView");
-			_assetListView.makeItem = MakeAssetListViewItem;
-			_assetListView.bindItem = BindAssetListViewItem;
-		}
-
-		/// <summary>
-		/// 填充页面数据
-		/// </summary>
-		public void FillViewData(BuildReport buildReport, string searchKeyWord)
-		{
-			_buildReport = buildReport;
-			_searchKeyWord = searchKeyWord;
-			RefreshView();
-		}
-		private void RefreshView()
-		{
-			_assetListView.Clear();
-			_assetListView.ClearSelection();
-			_assetListView.itemsSource = FilterAndSortViewItems();
-			_assetListView.Rebuild();
-			RefreshSortingSymbol();
-		}
-		private List<ReportRedundancyInfo> FilterAndSortViewItems()
-		{
-			List<ReportRedundancyInfo> result = new List<ReportRedundancyInfo>(_buildReport.RedundancyInfos.Count);
-
-			// 过滤列表
-			foreach (var redundancyInfo in _buildReport.RedundancyInfos)
-			{
-				if (string.IsNullOrEmpty(_searchKeyWord) == false)
-				{
-					if (redundancyInfo.AssetPath.Contains(_searchKeyWord) == false)
-						continue;
-				}
-				result.Add(redundancyInfo);
-			}
-
-			// 排序列表
-			if (_sortMode == ESortMode.AssetPath)
-			{
-				if (_descendingSort)
-					return result.OrderByDescending(a => a.AssetPath).ToList();
-				else
-					return result.OrderBy(a => a.AssetPath).ToList();
-			}
-			else if(_sortMode == ESortMode.AssetType)
-			{
-				if (_descendingSort)
-					return result.OrderByDescending(a => a.AssetType).ToList();
-				else
-					return result.OrderBy(a => a.AssetType).ToList();
-			}
-			else if (_sortMode == ESortMode.FileSize)
-			{
-				if (_descendingSort)
-					return result.OrderByDescending(a => a.FileSize).ToList();
-				else
-					return result.OrderBy(a => a.FileSize).ToList();
-			}
-			else if (_sortMode == ESortMode.Number)
-			{
-				if (_descendingSort)
-					return result.OrderByDescending(a => a.Number).ToList();
-				else
-					return result.OrderBy(a => a.Number).ToList();
-			}
-			else
-			{
-				throw new System.NotImplementedException();
-			}
-		}
-		private void RefreshSortingSymbol()
-		{
-			_topBar1.text = $"Asset Path ({_assetListView.itemsSource.Count})";
-			_topBar2.text = "Asset Type";
-			_topBar3.text = "File Size";
-			_topBar4.text = "Redundancy Num";
-
-			if (_sortMode == ESortMode.AssetPath)
-			{
-				if (_descendingSort)
-					_topBar1.text = $"Asset Path ({_assetListView.itemsSource.Count}) ↓";
-				else
-					_topBar1.text = $"Asset Path ({_assetListView.itemsSource.Count}) ↑";
-			}
-			else if(_sortMode == ESortMode.AssetType)
-			{
-				if (_descendingSort)
-					_topBar2.text = "Asset Type ↓";
-				else
-					_topBar2.text = "Asset Type ↑";
-			}
-			else if (_sortMode == ESortMode.FileSize)
-			{
-				if (_descendingSort)
-					_topBar3.text = "File Size ↓";
-				else
-					_topBar3.text = "File Size ↑";
-			}
-			else if (_sortMode == ESortMode.Number)
-			{
-				if (_descendingSort)
-					_topBar4.text = "Redundancy Num ↓";
-				else
-					_topBar4.text = "Redundancy Num ↑";
-			}
-			else
-			{
-				throw new System.NotImplementedException();
-			}
-		}
-
-		/// <summary>
-		/// 挂接到父类页面上
-		/// </summary>
-		public void AttachParent(VisualElement parent)
-		{
-			parent.Add(_root);
-		}
-
-		/// <summary>
-		/// 从父类页面脱离开
-		/// </summary>
-		public void DetachParent()
-		{
-			_root.RemoveFromHierarchy();
-		}
-
-
-		// 资源列表相关
-		private VisualElement MakeAssetListViewItem()
-		{
-			VisualElement element = new VisualElement();
-			element.style.flexDirection = FlexDirection.Row;
-
-			{
-				var label = new Label();
-				label.name = "Label1";
-				label.style.unityTextAlign = TextAnchor.MiddleLeft;
-				label.style.marginLeft = 3f;
-				label.style.flexGrow = 1f;
-				label.style.width = 280;
-				element.Add(label);
-			}
-
-			{
-				var label = new Label();
-				label.name = "Label2";
-				label.style.unityTextAlign = TextAnchor.MiddleLeft;
-				label.style.marginLeft = 3f;
-				label.style.flexGrow = 0;
-				label.style.width = 125;
-				element.Add(label);
-			}
-
-			{
-				var label = new Label();
-				label.name = "Label3";
-				label.style.unityTextAlign = TextAnchor.MiddleLeft;
-				label.style.marginLeft = 3f;
-				label.style.flexGrow = 0;
-				label.style.width = 125;
-				element.Add(label);
-			}
-
-			{
-				var label = new Label();
-				label.name = "Label4";
-				label.style.unityTextAlign = TextAnchor.MiddleLeft;
-				label.style.marginLeft = 3f;
-				label.style.flexGrow = 0;
-				label.style.width = 125;
-				element.Add(label);
-			}
-
-			return element;
-		}
-		private void BindAssetListViewItem(VisualElement element, int index)
-		{
-			var sourceData = _assetListView.itemsSource as List<ReportRedundancyInfo>;
-			var redundancyInfo = sourceData[index];
-
-			// Asset Path
-			var label1 = element.Q<Label>("Label1");
-			label1.text = redundancyInfo.AssetPath;
-
-			// Asset Type
-			var label2 = element.Q<Label>("Label2");
-			label2.text = redundancyInfo.AssetType;
-
-			// File Size
-			var label3 = element.Q<Label>("Label3");
-			label3.text = EditorUtility.FormatBytes(redundancyInfo.FileSize);
-
-			// Number
-			var label4 = element.Q<Label>("Label4");
-			label4.text = redundancyInfo.Number.ToString();
-		}
-		private void TopBar1_clicked()
-		{
-			if (_sortMode != ESortMode.AssetPath)
-			{
-				_sortMode = ESortMode.AssetPath;
-				_descendingSort = false;
-				RefreshView();
-			}
-			else
-			{
-				_descendingSort = !_descendingSort;
-				RefreshView();
-			}
-		}
-		private void TopBar2_clicked()
-		{
-			if (_sortMode != ESortMode.AssetType)
-			{
-				_sortMode = ESortMode.AssetType;
-				_descendingSort = false;
-				RefreshView();
-			}
-			else
-			{
-				_descendingSort = !_descendingSort;
-				RefreshView();
-			}
-		}
-		private void TopBar3_clicked()
-		{
-			if (_sortMode != ESortMode.FileSize)
-			{
-				_sortMode = ESortMode.FileSize;
-				_descendingSort = false;
-				RefreshView();
-			}
-			else
-			{
-				_descendingSort = !_descendingSort;
-				RefreshView();
-			}
-		}
-		private void TopBar4_clicked()
-		{
-			if (_sortMode != ESortMode.Number)
-			{
-				_sortMode = ESortMode.Number;
-				_descendingSort = false;
-				RefreshView();
-			}
-			else
-			{
-				_descendingSort = !_descendingSort;
-				RefreshView();
-			}
-		}
-	}
-}
-#endif

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

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

Assets/YooAsset/Editor/AssetBundleReporter/VisualViewers/ReporterRedundancyListViewer.uxml.meta

@@ -1,10 +0,0 @@
-fileFormatVersion: 2
-guid: a5296d9c037ce3944b5c197cbdd78a8b
-ScriptedImporter:
-  internalIDToNameTable: []
-  externalObjects: {}
-  serializedVersion: 2
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
-  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}

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

@@ -67,16 +67,17 @@ namespace YooAsset.Editor
             _items.Add(new ItemWrapper("Package Version", buildReport.Summary.BuildPackageVersion));
 
             _items.Add(new ItemWrapper(string.Empty, string.Empty));
-			_items.Add(new ItemWrapper("Settings", string.Empty));
+            _items.Add(new ItemWrapper("Collect Settings", string.Empty));
             _items.Add(new ItemWrapper("Unique Bundle Name", $"{buildReport.Summary.UniqueBundleName}"));
             _items.Add(new ItemWrapper("Enable Addressable", $"{buildReport.Summary.EnableAddressable}"));
             _items.Add(new ItemWrapper("Location To Lower", $"{buildReport.Summary.LocationToLower}"));
             _items.Add(new ItemWrapper("Include Asset GUID", $"{buildReport.Summary.IncludeAssetGUID}"));
-			_items.Add(new ItemWrapper("Ignore Default Type", $"{buildReport.Summary.IgnoreDefaultType}"));
             _items.Add(new ItemWrapper("Auto Collect Shaders", $"{buildReport.Summary.AutoCollectShaders}"));
+            _items.Add(new ItemWrapper("Ignore Rule Name", $"{buildReport.Summary.IgnoreRuleName}"));
 
             _items.Add(new ItemWrapper(string.Empty, string.Empty));
             _items.Add(new ItemWrapper("Build Params", string.Empty));
+            _items.Add(new ItemWrapper("Enable Share Pack Rule", $"{buildReport.Summary.EnableSharePackRule}"));
             _items.Add(new ItemWrapper("Encryption Class Name", buildReport.Summary.EncryptionClassName));
             _items.Add(new ItemWrapper("FileNameStyle", $"{buildReport.Summary.FileNameStyle}"));
             _items.Add(new ItemWrapper("CompressOption", $"{buildReport.Summary.CompressOption}"));

Assets/YooAsset/Editor/Common.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 96a75a20111d6124696665e7aac3564c
+guid: 4cb0b75b2f649c64bb1d8203f2fbfeea
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/YooAsset/Editor/Common/AssetInfo.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset.Editor
+{
+    [Serializable]
+    public class AssetInfo
+    {
+        private string _fileExtension = null;
+
+        /// <summary>
+        /// 资源路径
+        /// </summary>
+        public string AssetPath;
+
+        /// <summary>
+        /// 资源GUID
+        /// </summary>
+        public string AssetGUID;
+
+        /// <summary>
+        /// 资源类型
+        /// </summary>
+        public System.Type AssetType;
+
+        /// <summary>
+        /// 文件格式
+        /// </summary>
+        public string FileExtension
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(_fileExtension))
+                    _fileExtension = System.IO.Path.GetExtension(AssetPath);
+                return _fileExtension;
+            }
+        }
+
+        public AssetInfo(string assetPath)
+        {
+            AssetPath = assetPath;
+            AssetGUID = UnityEditor.AssetDatabase.AssetPathToGUID(AssetPath);
+            AssetType = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(AssetPath);
+
+            // 注意：如果资源文件损坏或者实例化关联脚本丢失，获取的资源类型会无效！
+            if (AssetType == null)
+            {
+                throw new Exception($"Found invalid asset : {AssetPath}");
+            }
+        }
+
+        /// <summary>
+        /// 是否为着色器资源
+        /// </summary>
+        public bool IsShaderAsset()
+        {
+            if (AssetType == typeof(UnityEngine.Shader) || AssetType == typeof(UnityEngine.ShaderVariantCollection))
+                return true;
+            else
+                return false;
+        }
+    }
+}

Assets/YooAsset/Editor/Common/AssetInfo.cs.meta

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

Assets/YooAsset/Editor/EditorTools.cs

@@ -560,6 +560,21 @@ namespace YooAsset.Editor
             return path.Replace('\\', '/').Replace("\\", "/"); //替换为Linux路径格式
         }
     
+        /// <summary>
+        /// 移除路径里的后缀名
+        /// </summary>
+        public static string RemoveExtension(string str)
+        {
+            if (string.IsNullOrEmpty(str))
+                return str;
+
+            int index = str.LastIndexOf('.');
+            if (index == -1)
+                return str;
+            else
+                return str.Remove(index); //"assets/config/test.unity3d" --> "assets/config/test"
+        }
+
         /// <summary>
         /// 获取项目工程路径
         /// </summary>

Assets/YooAsset/Runtime/CacheSystem/CacheFileInfo.cs

@@ -1,36 +0,0 @@
-using System;
-using System.IO;
-
-namespace YooAsset
-{
-	internal class CacheFileInfo
-	{
-		private static readonly BufferWriter SharedBuffer = new BufferWriter(1024);
-
-		/// <summary>
-		/// 写入资源包信息
-		/// </summary>
-		public static void WriteInfoToFile(string filePath, string dataFileCRC, long dataFileSize)
-		{
-			using (FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Read))
-			{
-				SharedBuffer.Clear();
-				SharedBuffer.WriteUTF8(dataFileCRC);
-				SharedBuffer.WriteInt64(dataFileSize);
-				SharedBuffer.WriteToStream(fs);
-				fs.Flush();
-			}
-		}
-
-		/// <summary>
-		/// 读取资源包信息
-		/// </summary>
-		public static void ReadInfoFromFile(string filePath, out string dataFileCRC, out long dataFileSize)
-		{
-			byte[] binaryData = FileUtility.ReadAllBytes(filePath);
-			BufferReader buffer = new BufferReader(binaryData);
-			dataFileCRC = buffer.ReadUTF8();
-			dataFileSize = buffer.ReadInt64();
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/CacheHelper.cs

@@ -1,103 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-
-namespace YooAsset
-{
-	internal static class CacheHelper
-	{
-		/// <summary>
-		/// 禁用Unity缓存系统在WebGL平台
-		/// </summary>
-		public static bool DisableUnityCacheOnWebGL = false;
-
-		/// <summary>
-		/// 验证缓存文件（子线程内操作）
-		/// </summary>
-		public static EVerifyResult VerifyingCacheFile(VerifyCacheFileElement element, EVerifyLevel verifyLevel)
-		{
-			try
-			{
-				if (verifyLevel == EVerifyLevel.Low)
-				{
-					if (File.Exists(element.InfoFilePath) == false)
-						return EVerifyResult.InfoFileNotExisted;
-					if (File.Exists(element.DataFilePath) == false)
-						return EVerifyResult.DataFileNotExisted;
-					return EVerifyResult.Succeed;
-				}
-				else
-				{
-					if (File.Exists(element.InfoFilePath) == false)
-						return EVerifyResult.InfoFileNotExisted;
-
-					// 解析信息文件获取验证数据
-					CacheFileInfo.ReadInfoFromFile(element.InfoFilePath, out element.DataFileCRC, out element.DataFileSize);
-				}
-			}
-			catch (Exception)
-			{
-				return EVerifyResult.Exception;
-			}
-
-			return VerifyingInternal(element.DataFilePath, element.DataFileSize, element.DataFileCRC, verifyLevel);
-		}
-
-		/// <summary>
-		/// 验证下载文件（子线程内操作）
-		/// </summary>
-		public static EVerifyResult VerifyingTempFile(VerifyTempFileElement element)
-		{
-			return VerifyingInternal(element.TempDataFilePath, element.FileSize, element.FileCRC, EVerifyLevel.High);
-		}
-
-		/// <summary>
-		/// 验证记录文件（主线程内操作）
-		/// </summary>
-		public static EVerifyResult VerifyingRecordFile(CacheManager cache, string cacheGUID)
-		{
-			var wrapper = cache.TryGetWrapper(cacheGUID);
-			if (wrapper == null)
-				return EVerifyResult.CacheNotFound;
-
-			EVerifyResult result = VerifyingInternal(wrapper.DataFilePath, wrapper.DataFileSize, wrapper.DataFileCRC, EVerifyLevel.High);
-			return result;
-		}
-
-		private static EVerifyResult VerifyingInternal(string filePath, long fileSize, string fileCRC, EVerifyLevel verifyLevel)
-		{
-			try
-			{
-				if (File.Exists(filePath) == false)
-					return EVerifyResult.DataFileNotExisted;
-
-				// 先验证文件大小
-				long size = FileUtility.GetFileSize(filePath);
-				if (size < fileSize)
-					return EVerifyResult.FileNotComplete;
-				else if (size > fileSize)
-					return EVerifyResult.FileOverflow;
-
-				// 再验证文件CRC
-				if (verifyLevel == EVerifyLevel.High)
-				{
-					string crc = HashUtility.FileCRC32(filePath);
-					if (crc == fileCRC)
-						return EVerifyResult.Succeed;
-					else
-						return EVerifyResult.FileCrcError;
-				}
-				else
-				{
-					return EVerifyResult.Succeed;
-				}
-			}
-			catch (Exception)
-			{
-				return EVerifyResult.Exception;
-			}
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/CacheHelper.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/CacheManager.cs

@@ -1,136 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace YooAsset
-{
-	internal class CacheManager
-	{
-		internal class RecordWrapper
-		{
-			public string InfoFilePath { private set; get; }
-			public string DataFilePath { private set; get; }
-			public string DataFileCRC { private set; get; }
-			public long DataFileSize { private set; get; }
-
-			public RecordWrapper(string infoFilePath, string dataFilePath, string dataFileCRC, long dataFileSize)
-			{
-				InfoFilePath = infoFilePath;
-				DataFilePath = dataFilePath;
-				DataFileCRC = dataFileCRC;
-				DataFileSize = dataFileSize;
-			}
-		}
-
-		private readonly Dictionary<string, RecordWrapper> _wrappers = new Dictionary<string, RecordWrapper>();
-
-		/// <summary>
-		/// 所属包裹
-		/// </summary>
-		public readonly string PackageName;
-
-		/// <summary>
-		/// 验证级别
-		/// </summary>
-		public readonly EVerifyLevel BootVerifyLevel;
-
-
-		public CacheManager(string packageName, EVerifyLevel bootVerifyLevel)
-		{
-			PackageName = packageName;
-			BootVerifyLevel = bootVerifyLevel;
-		}
-
-		/// <summary>
-		/// 清空所有数据
-		/// </summary>
-		public void ClearAll()
-		{
-			_wrappers.Clear();
-		}
-
-		/// <summary>
-		/// 查询缓存记录
-		/// </summary>
-		public bool IsCached(string cacheGUID)
-		{
-			return _wrappers.ContainsKey(cacheGUID);
-		}
-
-		/// <summary>
-		/// 记录验证结果
-		/// </summary>
-		public void Record(string cacheGUID, RecordWrapper wrapper)
-		{
-			if (_wrappers.ContainsKey(cacheGUID) == false)
-			{
-				_wrappers.Add(cacheGUID, wrapper);
-			}
-			else
-			{
-				throw new Exception("Should never get here !");
-			}
-		}
-
-		/// <summary>
-		/// 丢弃验证结果并删除缓存文件
-		/// </summary>
-		public void Discard(string cacheGUID)
-		{
-			var wrapper = TryGetWrapper(cacheGUID);
-			if (wrapper != null)
-			{
-				try
-				{
-					string dataFilePath = wrapper.DataFilePath;
-					FileInfo fileInfo = new FileInfo(dataFilePath);
-					if (fileInfo.Exists)
-						fileInfo.Directory.Delete(true);
-				}
-				catch (Exception e)
-				{
-					YooLogger.Error($"Failed to delete cache file ! {e.Message}");
-				}
-			}
-
-			if (_wrappers.ContainsKey(cacheGUID))
-			{
-				_wrappers.Remove(cacheGUID);
-			}
-		}
-
-		/// <summary>
-		/// 获取记录对象
-		/// </summary>
-		public RecordWrapper TryGetWrapper(string cacheGUID)
-		{
-			if (_wrappers.TryGetValue(cacheGUID, out RecordWrapper value))
-				return value;
-			else
-				return null;
-		}
-
-		/// <summary>
-		/// 获取缓存文件总数
-		/// </summary>
-		public int GetAllCachedFilesCount()
-		{
-			return _wrappers.Count;
-		}
-
-		/// <summary>
-		/// 获取缓存GUID集合
-		/// </summary>
-		public List<string> GetAllCachedGUIDs()
-		{
-			List<string> keys = new List<string>(_wrappers.Keys.Count);
-			var keyCollection = _wrappers.Keys;
-			foreach (var key in keyCollection)
-			{
-				keys.Add(key);
-			}
-			return keys;
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/CacheManager.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/EVerifyLevel.cs

@@ -1,24 +0,0 @@
-
-namespace YooAsset
-{
-	/// <summary>
-	/// 下载文件校验等级
-	/// </summary>
-	public enum EVerifyLevel
-	{
-		/// <summary>
-		/// 验证文件存在
-		/// </summary>
-		Low,
-
-		/// <summary>
-		/// 验证文件大小
-		/// </summary>
-		Middle,
-
-		/// <summary>
-		/// 验证文件大小和CRC
-		/// </summary>
-		High,
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/EVerifyLevel.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/EVerifyResult.cs

@@ -1,54 +0,0 @@
-
-namespace YooAsset
-{
-	/// <summary>
-	/// 下载文件校验结果
-	/// </summary>
-	internal enum EVerifyResult
-	{
-		/// <summary>
-		/// 验证异常
-		/// </summary>
-		Exception = -7,
-
-		/// <summary>
-		/// 未找到缓存信息
-		/// </summary>
-		CacheNotFound = -6,
-
-		/// <summary>
-		/// 信息文件不存在
-		/// </summary>
-		InfoFileNotExisted = -5,
-
-		/// <summary>
-		/// 数据文件不存在
-		/// </summary>
-		DataFileNotExisted = -4,
-
-		/// <summary>
-		/// 文件内容不足（小于正常大小）
-		/// </summary>
-		FileNotComplete = -3,
-		
-		/// <summary>
-		/// 文件内容溢出（超过正常大小）
-		/// </summary>
-		FileOverflow = -2,
-		
-		/// <summary>
-		/// 文件内容不匹配
-		/// </summary>
-		FileCrcError = -1,
-
-		/// <summary>
-		/// 默认状态（校验未完成）
-		/// </summary>
-		None = 0,
-
-		/// <summary>
-		/// 验证成功
-		/// </summary>
-		Succeed = 1,
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/EVerifyResult.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/Operation/ClearAllCacheFilesOperation.cs

@@ -1,71 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-
-namespace YooAsset
-{
-	/// <summary>
-	/// 清理本地包裹所有的缓存文件
-	/// </summary>
-	public sealed class ClearAllCacheFilesOperation : AsyncOperationBase
-	{
-		private enum ESteps
-		{
-			None,
-			GetAllCacheFiles,
-			ClearAllCacheFiles,
-			Done,
-		}
-
-		private readonly CacheManager _cache;
-		private List<string> _allCacheGUIDs;
-		private int _fileTotalCount = 0;
-		private ESteps _steps = ESteps.None;
-		
-		internal ClearAllCacheFilesOperation(CacheManager cache)
-		{
-			_cache = cache;
-		}
-		internal override void InternalOnStart()
-		{
-			_steps = ESteps.GetAllCacheFiles;
-		}
-		internal override void InternalOnUpdate()
-		{
-			if (_steps == ESteps.None || _steps == ESteps.Done)
-				return;
-
-			if (_steps == ESteps.GetAllCacheFiles)
-			{
-				_allCacheGUIDs = _cache.GetAllCachedGUIDs();
-				_fileTotalCount = _allCacheGUIDs.Count;
-				YooLogger.Log($"Found all cache file count : {_fileTotalCount}");
-				_steps = ESteps.ClearAllCacheFiles;
-			}
-
-			if (_steps == ESteps.ClearAllCacheFiles)
-			{
-				for (int i = _allCacheGUIDs.Count - 1; i >= 0; i--)
-				{
-					string cacheGUID = _allCacheGUIDs[i];
-					_cache.Discard(cacheGUID);
-					_allCacheGUIDs.RemoveAt(i);
-
-					if (OperationSystem.IsBusy)
-						break;
-				}
-
-				if (_fileTotalCount == 0)
-					Progress = 1.0f;
-				else
-					Progress = 1.0f - (_allCacheGUIDs.Count / _fileTotalCount);
-
-				if (_allCacheGUIDs.Count == 0)
-				{
-					_steps = ESteps.Done;
-					Status = EOperationStatus.Succeed;
-				}
-			}
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/Operation/ClearAllCacheFilesOperation.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/Operation/ClearUnusedCacheFilesOperation.cs

@@ -1,87 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-
-namespace YooAsset
-{
-	/// <summary>
-	/// 清理本地包裹未使用的缓存文件
-	/// </summary>
-	public sealed class ClearUnusedCacheFilesOperation : AsyncOperationBase
-	{
-		private enum ESteps
-		{
-			None,
-			GetUnusedCacheFiles,
-			ClearUnusedCacheFiles,
-			Done,
-		}
-
-		private readonly ResourcePackage _package;
-		private readonly CacheManager _cache;
-		private List<string> _unusedCacheGUIDs;
-		private int _unusedFileTotalCount = 0;
-		private ESteps _steps = ESteps.None;
-
-		internal ClearUnusedCacheFilesOperation(ResourcePackage package, CacheManager cache)
-		{
-			_package = package;
-			_cache = cache;
-		}
-		internal override void InternalOnStart()
-		{
-			_steps = ESteps.GetUnusedCacheFiles;
-		}
-		internal override void InternalOnUpdate()
-		{
-			if (_steps == ESteps.None || _steps == ESteps.Done)
-				return;
-
-			if (_steps == ESteps.GetUnusedCacheFiles)
-			{
-				_unusedCacheGUIDs = GetUnusedCacheGUIDs();
-				_unusedFileTotalCount = _unusedCacheGUIDs.Count;
-				YooLogger.Log($"Found unused cache file count : {_unusedFileTotalCount}");
-				_steps = ESteps.ClearUnusedCacheFiles;
-			}
-
-			if (_steps == ESteps.ClearUnusedCacheFiles)
-			{
-				for (int i = _unusedCacheGUIDs.Count - 1; i >= 0; i--)
-				{
-					string cacheGUID = _unusedCacheGUIDs[i];
-					_cache.Discard(cacheGUID);
-					_unusedCacheGUIDs.RemoveAt(i);
-
-					if (OperationSystem.IsBusy)
-						break;
-				}
-
-				if (_unusedFileTotalCount == 0)
-					Progress = 1.0f;
-				else
-					Progress = 1.0f - (_unusedCacheGUIDs.Count / _unusedFileTotalCount);
-
-				if (_unusedCacheGUIDs.Count == 0)
-				{
-					_steps = ESteps.Done;
-					Status = EOperationStatus.Succeed;
-				}
-			}
-		}
-
-		private List<string> GetUnusedCacheGUIDs()
-		{
-			var allCacheGUIDs = _cache.GetAllCachedGUIDs();
-			List<string> result = new List<string>(allCacheGUIDs.Count);
-			foreach (var cacheGUID in allCacheGUIDs)
-			{
-				if (_package.IsIncludeBundleFile(cacheGUID) == false)
-				{
-					result.Add(cacheGUID);
-				}
-			}
-			return result;
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/Operation/ClearUnusedCacheFilesOperation.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/Operation/Internal/FindCacheFilesOperation.cs

@@ -1,126 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace YooAsset
-{
-	internal sealed class FindCacheFilesOperation : AsyncOperationBase
-	{
-		private enum ESteps
-		{
-			None,
-			Prepare,
-			UpdateCacheFiles,
-			Done,
-		}
-
-		private readonly PersistentManager _persistent;
-		private readonly CacheManager _cache;
-		private IEnumerator<DirectoryInfo> _filesEnumerator = null;
-		private float _verifyStartTime;
-		private ESteps _steps = ESteps.None;
-
-		/// <summary>
-		/// 需要验证的元素
-		/// </summary>
-		public readonly List<VerifyCacheFileElement> VerifyElements = new List<VerifyCacheFileElement>(5000);
-
-		public FindCacheFilesOperation(PersistentManager persistent, CacheManager cache)
-		{
-			_persistent = persistent;
-			_cache = cache;
-		}
-		internal override void InternalOnStart()
-		{
-			_steps = ESteps.Prepare;
-			_verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
-		}
-		internal override void InternalOnUpdate()
-		{
-			if (_steps == ESteps.None || _steps == ESteps.Done)
-				return;
-
-			if (_steps == ESteps.Prepare)
-			{
-				string rootPath = _persistent.SandboxCacheFilesRoot;
-				DirectoryInfo rootDirectory = new DirectoryInfo(rootPath);
-				if (rootDirectory.Exists)
-				{
-					var directorieInfos = rootDirectory.EnumerateDirectories();
-					_filesEnumerator = directorieInfos.GetEnumerator();
-				}
-				_steps = ESteps.UpdateCacheFiles;
-			}
-
-			if (_steps == ESteps.UpdateCacheFiles)
-			{
-				if (UpdateCacheFiles())
-					return;
-
-				// 注意：总是返回成功
-				_steps = ESteps.Done;
-				Status = EOperationStatus.Succeed;
-				float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
-				YooLogger.Log($"Find cache files elapsed time {costTime:f1} seconds");
-			}
-		}
-
-		private bool UpdateCacheFiles()
-		{
-			if (_filesEnumerator == null)
-				return false;
-
-			bool isFindItem;
-			while (true)
-			{
-				isFindItem = _filesEnumerator.MoveNext();
-				if (isFindItem == false)
-					break;
-
-				var rootFoder = _filesEnumerator.Current;
-				var childDirectories = rootFoder.GetDirectories();
-				foreach (var chidDirectory in childDirectories)
-				{
-					string cacheGUID = chidDirectory.Name;
-					if (_cache.IsCached(cacheGUID))
-						continue;
-
-					// 创建验证元素类
-					string fileRootPath = chidDirectory.FullName;
-					string dataFilePath = $"{fileRootPath}/{ YooAssetSettings.CacheBundleDataFileName}";
-					string infoFilePath = $"{fileRootPath}/{ YooAssetSettings.CacheBundleInfoFileName}";
-					if (_persistent.AppendFileExtension)
-					{
-						string fileExtension = FindFileExtension(chidDirectory);
-						if (string.IsNullOrEmpty(fileExtension) == false)
-							dataFilePath += fileExtension;
-					}
-					VerifyCacheFileElement element = new VerifyCacheFileElement(_cache.PackageName, cacheGUID, fileRootPath, dataFilePath, infoFilePath);
-					VerifyElements.Add(element);
-				}
-
-				if (OperationSystem.IsBusy)
-					break;
-			}
-
-			return isFindItem;
-		}
-		private string FindFileExtension(DirectoryInfo directoryInfo)
-		{
-			string dataFileExtension = string.Empty;
-			var fileInfos = directoryInfo.GetFiles();
-			foreach (var fileInfo in fileInfos)
-			{
-				if (fileInfo.Extension == ".temp")
-					continue;
-				if (fileInfo.Name.StartsWith(YooAssetSettings.CacheBundleDataFileName))
-				{
-					dataFileExtension = fileInfo.Extension;
-					break;
-				}
-			}
-			return dataFileExtension;
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/Operation/Internal/FindCacheFilesOperation.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/Operation/Internal/VerifyCacheFilesOperation.cs

@@ -1,254 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-
-namespace YooAsset
-{
-	internal abstract class VerifyCacheFilesOperation : AsyncOperationBase
-	{
-		public static VerifyCacheFilesOperation CreateOperation(CacheManager cache, List<VerifyCacheFileElement> elements)
-		{
-#if UNITY_WEBGL
-			var operation = new VerifyCacheFilesWithoutThreadOperation(cache, elements);
-#else
-			var operation = new VerifyCacheFilesWithThreadOperation(cache, elements);
-#endif
-			return operation;
-		}
-	}
-
-	/// <summary>
-	/// 本地缓存文件验证（线程版）
-	/// </summary>
-	internal class VerifyCacheFilesWithThreadOperation : VerifyCacheFilesOperation
-	{
-		private enum ESteps
-		{
-			None,
-			InitVerify,
-			UpdateVerify,
-			Done,
-		}
-
-		private readonly ThreadSyncContext _syncContext = new ThreadSyncContext();
-		private readonly CacheManager _cache;
-		private List<VerifyCacheFileElement> _waitingList;
-		private List<VerifyCacheFileElement> _verifyingList;
-		private int _verifyMaxNum;
-		private int _verifyTotalCount;
-		private float _verifyStartTime;
-		private int _succeedCount;
-		private int _failedCount;
-		private ESteps _steps = ESteps.None;
-
-		public VerifyCacheFilesWithThreadOperation(CacheManager cache, List<VerifyCacheFileElement> elements)
-		{
-			_cache = cache;
-			_waitingList = elements;
-		}
-		internal override void InternalOnStart()
-		{
-			_steps = ESteps.InitVerify;
-			_verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
-		}
-		internal override void InternalOnUpdate()
-		{
-			if (_steps == ESteps.None || _steps == ESteps.Done)
-				return;
-
-			if (_steps == ESteps.InitVerify)
-			{
-				int fileCount = _waitingList.Count;
-
-				// 设置同时验证的最大数
-				ThreadPool.GetMaxThreads(out int workerThreads, out int ioThreads);
-				YooLogger.Log($"Work threads : {workerThreads}, IO threads : {ioThreads}");
-				_verifyMaxNum = Math.Min(workerThreads, ioThreads);
-				_verifyTotalCount = fileCount;
-				if (_verifyMaxNum < 1)
-					_verifyMaxNum = 1;
-
-				_verifyingList = new List<VerifyCacheFileElement>(_verifyMaxNum);
-				_steps = ESteps.UpdateVerify;
-			}
-
-			if (_steps == ESteps.UpdateVerify)
-			{
-				_syncContext.Update();
-
-				Progress = GetProgress();
-				if (_waitingList.Count == 0 && _verifyingList.Count == 0)
-				{
-					_steps = ESteps.Done;
-					Status = EOperationStatus.Succeed;
-					float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
-					YooLogger.Log($"Verify cache files elapsed time {costTime:f1} seconds");
-				}
-
-				for (int i = _waitingList.Count - 1; i >= 0; i--)
-				{
-					if (OperationSystem.IsBusy)
-						break;
-
-					if (_verifyingList.Count >= _verifyMaxNum)
-						break;
-
-					var element = _waitingList[i];
-					if (BeginVerifyFileWithThread(element))
-					{
-						_waitingList.RemoveAt(i);
-						_verifyingList.Add(element);
-					}
-					else
-					{
-						YooLogger.Warning("The thread pool is failed queued.");
-						break;
-					}
-				}
-			}
-		}
-
-		private float GetProgress()
-		{
-			if (_verifyTotalCount == 0)
-				return 1f;
-			return (float)(_succeedCount + _failedCount) / _verifyTotalCount;
-		}
-		private bool BeginVerifyFileWithThread(VerifyCacheFileElement element)
-		{
-			return ThreadPool.QueueUserWorkItem(new WaitCallback(VerifyInThread), element);
-		}
-		private void VerifyInThread(object obj)
-		{
-			VerifyCacheFileElement element = (VerifyCacheFileElement)obj;
-			element.Result = CacheHelper.VerifyingCacheFile(element, _cache.BootVerifyLevel);
-			_syncContext.Post(VerifyCallback, element);
-		}
-		private void VerifyCallback(object obj)
-		{
-			VerifyCacheFileElement element = (VerifyCacheFileElement)obj;
-			_verifyingList.Remove(element);
-
-			if (element.Result == EVerifyResult.Succeed)
-			{
-				_succeedCount++;
-				var wrapper = new CacheManager.RecordWrapper(element.InfoFilePath, element.DataFilePath, element.DataFileCRC, element.DataFileSize);
-				_cache.Record(element.CacheGUID, wrapper);
-			}
-			else
-			{
-				_failedCount++;
-
-				YooLogger.Warning($"Failed verify file and delete files : {element.FileRootPath}");
-				element.DeleteFiles();
-			}
-		}
-	}
-
-	/// <summary>
-	/// 本地缓存文件验证（非线程版）
-	/// </summary>
-	internal class VerifyCacheFilesWithoutThreadOperation : VerifyCacheFilesOperation
-	{
-		private enum ESteps
-		{
-			None,
-			InitVerify,
-			UpdateVerify,
-			Done,
-		}
-
-		private readonly CacheManager _cache;
-		private List<VerifyCacheFileElement> _waitingList;
-		private List<VerifyCacheFileElement> _verifyingList;
-		private int _verifyMaxNum;
-		private int _verifyTotalCount;
-		private float _verifyStartTime;
-		private int _succeedCount;
-		private int _failedCount;
-		private ESteps _steps = ESteps.None;
-		
-		public VerifyCacheFilesWithoutThreadOperation(CacheManager cache, List<VerifyCacheFileElement> elements)
-		{
-			_cache = cache;
-			_waitingList = elements;
-		}
-		internal override void InternalOnStart()
-		{
-			_steps = ESteps.InitVerify;
-			_verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
-		}
-		internal override void InternalOnUpdate()
-		{
-			if (_steps == ESteps.None || _steps == ESteps.Done)
-				return;
-
-			if (_steps == ESteps.InitVerify)
-			{
-				int fileCount = _waitingList.Count;
-
-				// 设置同时验证的最大数
-				_verifyMaxNum = fileCount;
-				_verifyTotalCount = fileCount;
-
-				_verifyingList = new List<VerifyCacheFileElement>(_verifyMaxNum);
-				_steps = ESteps.UpdateVerify;
-			}
-
-			if (_steps == ESteps.UpdateVerify)
-			{
-				Progress = GetProgress();
-				if (_waitingList.Count == 0 && _verifyingList.Count == 0)
-				{
-					_steps = ESteps.Done;
-					Status = EOperationStatus.Succeed;
-					float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
-					YooLogger.Log($"Package verify elapsed time {costTime:f1} seconds");
-				}
-
-				for (int i = _waitingList.Count - 1; i >= 0; i--)
-				{
-					if (OperationSystem.IsBusy)
-						break;
-
-					if (_verifyingList.Count >= _verifyMaxNum)
-						break;
-
-					var element = _waitingList[i];
-					BeginVerifyFileWithoutThread(element);
-					_waitingList.RemoveAt(i);
-					_verifyingList.Add(element);
-				}
-
-				// 主线程内验证，可以清空列表
-				_verifyingList.Clear();
-			}
-		}
-
-		private float GetProgress()
-		{
-			if (_verifyTotalCount == 0)
-				return 1f;
-			return (float)(_succeedCount + _failedCount) / _verifyTotalCount;
-		}
-		private void BeginVerifyFileWithoutThread(VerifyCacheFileElement element)
-		{
-			element.Result = CacheHelper.VerifyingCacheFile(element, _cache.BootVerifyLevel);
-			if (element.Result == EVerifyResult.Succeed)
-			{
-				_succeedCount++;
-				var wrapper = new CacheManager.RecordWrapper(element.InfoFilePath, element.DataFilePath, element.DataFileCRC, element.DataFileSize);
-				_cache.Record(element.CacheGUID, wrapper);
-			}
-			else
-			{
-				_failedCount++;
-
-				YooLogger.Warning($"Failed verify file and delete files : {element.FileRootPath}");
-				element.DeleteFiles();
-			}
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/Operation/Internal/VerifyTempFileOperation.cs

@@ -1,141 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-
-namespace YooAsset
-{
-	internal abstract class VerifyTempFileOperation : AsyncOperationBase
-	{
-		public EVerifyResult VerifyResult { protected set; get; }
-
-		public static VerifyTempFileOperation CreateOperation(VerifyTempFileElement element)
-		{
-#if UNITY_WEBGL
-			var operation = new VerifyTempFileWithoutThreadOperation(element);
-#else
-			var operation = new VerifyTempFileWithThreadOperation(element);
-#endif
-			return operation;
-		}
-	}
-
-	/// <summary>
-	/// 下载文件验证（线程版）
-	/// </summary>
-	internal class VerifyTempFileWithThreadOperation : VerifyTempFileOperation
-	{
-		private enum ESteps
-		{
-			None,
-			VerifyFile,
-			Waiting,
-			Done,
-		}
-
-		private readonly VerifyTempFileElement _element;
-		private ESteps _steps = ESteps.None;
-
-		public VerifyTempFileWithThreadOperation(VerifyTempFileElement element)
-		{
-			_element = element;
-		}
-		internal override void InternalOnStart()
-		{
-			_steps = ESteps.VerifyFile;
-		}
-		internal override void InternalOnUpdate()
-		{
-			if (_steps == ESteps.None || _steps == ESteps.Done)
-				return;
-
-			if (_steps == ESteps.VerifyFile)
-			{
-				if (BeginVerifyFileWithThread(_element))
-				{
-					_steps = ESteps.Waiting;
-				}
-			}
-
-			if (_steps == ESteps.Waiting)
-			{
-				int result = _element.Result;
-				if (result == 0)
-					return;
-
-				VerifyResult = (EVerifyResult)result;
-				if (VerifyResult == EVerifyResult.Succeed)
-				{
-					_steps = ESteps.Done;
-					Status = EOperationStatus.Succeed;
-				}
-				else
-				{
-					_steps = ESteps.Done;
-					Status = EOperationStatus.Failed;
-					Error = $"Failed verify file : {_element.TempDataFilePath} ! ErrorCode : {VerifyResult}";
-				}
-			}
-		}
-
-		private bool BeginVerifyFileWithThread(VerifyTempFileElement element)
-		{
-			return ThreadPool.QueueUserWorkItem(new WaitCallback(VerifyInThread), element);
-		}
-		private void VerifyInThread(object obj)
-		{
-			VerifyTempFileElement element = (VerifyTempFileElement)obj;
-			int result = (int)CacheHelper.VerifyingTempFile(element);
-			element.Result = result;
-		}
-	}
-
-	/// <summary>
-	/// 下载文件验证（非线程版）
-	/// </summary>
-	internal class VerifyTempFileWithoutThreadOperation : VerifyTempFileOperation
-	{
-		private enum ESteps
-		{
-			None,
-			VerifyFile,
-			Done,
-		}
-
-		private readonly VerifyTempFileElement _element;
-		private ESteps _steps = ESteps.None;
-
-		public VerifyTempFileWithoutThreadOperation(VerifyTempFileElement element)
-		{
-			_element = element;
-		}
-		internal override void InternalOnStart()
-		{
-			_steps = ESteps.VerifyFile;
-		}
-		internal override void InternalOnUpdate()
-		{
-			if (_steps == ESteps.None || _steps == ESteps.Done)
-				return;
-
-			if (_steps == ESteps.VerifyFile)
-			{
-				_element.Result = (int)CacheHelper.VerifyingTempFile(_element);
-
-				VerifyResult = (EVerifyResult)_element.Result;
-				if (VerifyResult == EVerifyResult.Succeed)
-				{
-					_steps = ESteps.Done;
-					Status = EOperationStatus.Succeed;
-				}
-				else
-				{
-					_steps = ESteps.Done;
-					Status = EOperationStatus.Failed;
-					Error = $"Failed verify file : {_element.TempDataFilePath} ! ErrorCode : {VerifyResult}";
-				}
-			}
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/Operation/PackageCachingOperation.cs

@@ -1,74 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace YooAsset
-{
-	internal class PackageCachingOperation : AsyncOperationBase
-	{
-		private enum ESteps
-		{
-			None,
-			FindCacheFiles,
-			VerifyCacheFiles,
-			Done,
-		}
-
-		private readonly PersistentManager _persistent;
-		private readonly CacheManager _cache;
-		private FindCacheFilesOperation _findCacheFilesOp;
-		private VerifyCacheFilesOperation _verifyCacheFilesOp;
-		private ESteps _steps = ESteps.None;
-
-		public PackageCachingOperation(PersistentManager persistent, CacheManager cache)
-		{
-			_persistent = persistent;
-			_cache = cache;
-		}
-		internal override void InternalOnStart()
-		{
-			_steps = ESteps.FindCacheFiles;
-		}
-		internal override void InternalOnUpdate()
-		{
-			if (_steps == ESteps.None || _steps == ESteps.Done)
-				return;
-
-			if (_steps == ESteps.FindCacheFiles)
-			{
-				if (_findCacheFilesOp == null)
-				{
-					_findCacheFilesOp = new FindCacheFilesOperation(_persistent, _cache);
-					OperationSystem.StartOperation(_cache.PackageName, _findCacheFilesOp);
-				}
-
-				Progress = _findCacheFilesOp.Progress;
-				if (_findCacheFilesOp.IsDone == false)
-					return;
-
-				_steps = ESteps.VerifyCacheFiles;
-			}
-
-			if (_steps == ESteps.VerifyCacheFiles)
-			{
-				if (_verifyCacheFilesOp == null)
-				{
-					_verifyCacheFilesOp = VerifyCacheFilesOperation.CreateOperation(_cache, _findCacheFilesOp.VerifyElements);
-					OperationSystem.StartOperation(_cache.PackageName, _verifyCacheFilesOp);
-				}
-
-				Progress = _verifyCacheFilesOp.Progress;
-				if (_verifyCacheFilesOp.IsDone == false)
-					return;
-
-				// 注意：总是返回成功
-				_steps = ESteps.Done;
-				Status = EOperationStatus.Succeed;
-
-				int totalCount = _cache.GetAllCachedFilesCount();
-				YooLogger.Log($"Package '{_cache.PackageName}' cached files count : {totalCount}");
-			}
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/Operation/PackageCachingOperation.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/PersistentHelper.cs

@@ -1,28 +0,0 @@
-
-namespace YooAsset
-{
-	internal static class PersistentHelper
-	{
-		/// <summary>
-		/// 获取WWW加载本地资源的路径
-		/// </summary>
-		public static string ConvertToWWWPath(string path)
-		{
-#if UNITY_EDITOR
-			return StringUtility.Format("file:///{0}", path);
-#elif UNITY_WEBGL
-			return path;
-#elif UNITY_IPHONE
-			return StringUtility.Format("file://{0}", path);
-#elif UNITY_ANDROID
-			return path;
-#elif UNITY_STANDALONE_OSX
-			return new System.Uri(path).ToString();
-#elif UNITY_STANDALONE
-			return StringUtility.Format("file:///{0}", path);
-#else
-			return path;
-#endif
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/PersistentHelper.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/PersistentManager.cs

@@ -1,211 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace YooAsset
-{
-	internal class PersistentManager
-	{
-		private readonly Dictionary<string, string> _cachedDataFilePaths = new Dictionary<string, string>(10000);
-		private readonly Dictionary<string, string> _cachedInfoFilePaths = new Dictionary<string, string>(10000);
-		private readonly Dictionary<string, string> _tempDataFilePaths = new Dictionary<string, string>(10000);
-		private readonly Dictionary<string, string> _buildinFilePaths = new Dictionary<string, string>(10000);
-
-		/// <summary>
-		/// 所属包裹
-		/// </summary>
-		public readonly string PackageName;
-
-		public string BuildinRoot { private set; get; }
-		public string BuildinPackageRoot { private set; get; }
-
-		public string SandboxRoot { private set; get; }
-		public string SandboxPackageRoot { private set; get; }
-		public string SandboxCacheFilesRoot { private set; get; }
-		public string SandboxManifestFilesRoot { private set; get; }
-		public string SandboxAppFootPrintFilePath { private set; get; }
-
-		public bool AppendFileExtension { private set; get; }
-
-
-		public PersistentManager(string packageName)
-		{
-			PackageName = packageName;
-		}
-
-		/// <summary>
-		/// 初始化
-		/// </summary>
-		public void Initialize(string buildinRoot, string sandboxRoot, bool appendFileExtension)
-		{
-			if (string.IsNullOrEmpty(buildinRoot))
-				BuildinRoot = CreateDefaultBuildinRoot();
-			else
-				BuildinRoot = buildinRoot;
-
-			if (string.IsNullOrEmpty(sandboxRoot))
-				SandboxRoot = CreateDefaultSandboxRoot();
-			else
-				SandboxRoot = sandboxRoot;
-
-			BuildinPackageRoot = PathUtility.Combine(BuildinRoot, PackageName);
-			SandboxPackageRoot = PathUtility.Combine(SandboxRoot, PackageName);
-			SandboxCacheFilesRoot = PathUtility.Combine(SandboxPackageRoot, YooAssetSettings.CacheFilesFolderName);
-			SandboxManifestFilesRoot = PathUtility.Combine(SandboxPackageRoot, YooAssetSettings.ManifestFolderName);
-			SandboxAppFootPrintFilePath = PathUtility.Combine(SandboxPackageRoot, YooAssetSettings.AppFootPrintFileName);
-			AppendFileExtension = appendFileExtension;
-		}
-		private static string CreateDefaultBuildinRoot()
-		{
-			return PathUtility.Combine(UnityEngine.Application.streamingAssetsPath, YooAssetSettingsData.Setting.DefaultYooFolderName);
-		}
-		private static string CreateDefaultSandboxRoot()
-		{
-#if UNITY_EDITOR
-			// 注意：为了方便调试查看，编辑器下把存储目录放到项目里。
-			string projectPath = Path.GetDirectoryName(UnityEngine.Application.dataPath);
-			projectPath = PathUtility.RegularPath(projectPath);
-			return PathUtility.Combine(projectPath, YooAssetSettingsData.Setting.DefaultYooFolderName);
-#elif UNITY_STANDALONE
-			return PathUtility.Combine(UnityEngine.Application.dataPath, YooAssetSettingsData.Setting.DefaultYooFolderName);
-#else
-			return PathUtility.Combine(UnityEngine.Application.persistentDataPath, YooAssetSettingsData.Setting.DefaultYooFolderName);	
-#endif
-		}
-
-		public string GetCachedDataFilePath(PackageBundle bundle)
-		{
-			if (_cachedDataFilePaths.TryGetValue(bundle.CacheGUID, out string filePath) == false)
-			{
-				string folderName = bundle.FileHash.Substring(0, 2);
-				filePath = PathUtility.Combine(SandboxCacheFilesRoot, folderName, bundle.CacheGUID, YooAssetSettings.CacheBundleDataFileName);
-				if (AppendFileExtension)
-					filePath += bundle.FileExtension;
-				_cachedDataFilePaths.Add(bundle.CacheGUID, filePath);
-			}
-			return filePath;
-		}
-		public string GetCachedInfoFilePath(PackageBundle bundle)
-		{
-			if (_cachedInfoFilePaths.TryGetValue(bundle.CacheGUID, out string filePath) == false)
-			{
-				string folderName = bundle.FileHash.Substring(0, 2);
-				filePath = PathUtility.Combine(SandboxCacheFilesRoot, folderName, bundle.CacheGUID, YooAssetSettings.CacheBundleInfoFileName);
-				_cachedInfoFilePaths.Add(bundle.CacheGUID, filePath);
-			}
-			return filePath;
-		}
-		public string GetTempDataFilePath(PackageBundle bundle)
-		{
-			if (_tempDataFilePaths.TryGetValue(bundle.CacheGUID, out string filePath) == false)
-			{
-				string cachedDataFilePath = GetCachedDataFilePath(bundle);
-				filePath = $"{cachedDataFilePath}.temp";
-				_tempDataFilePaths.Add(bundle.CacheGUID, filePath);
-			}
-			return filePath;
-		}
-		public string GetBuildinFilePath(PackageBundle bundle)
-		{
-			if (_buildinFilePaths.TryGetValue(bundle.CacheGUID, out string filePath) == false)
-			{
-				filePath = PathUtility.Combine(BuildinPackageRoot, bundle.FileName);
-				_buildinFilePaths.Add(bundle.CacheGUID, filePath);
-			}
-			return filePath;
-		}
-
-		/// <summary>
-		/// 删除沙盒里的包裹目录
-		/// </summary>
-		public void DeleteSandboxPackageFolder()
-		{
-			if (Directory.Exists(SandboxPackageRoot))
-				Directory.Delete(SandboxPackageRoot, true);
-		}
-
-		/// <summary>
-		/// 删除沙盒内的缓存文件夹
-		/// </summary>
-		public void DeleteSandboxCacheFilesFolder()
-		{
-			if (Directory.Exists(SandboxCacheFilesRoot))
-				Directory.Delete(SandboxCacheFilesRoot, true);
-		}
-
-		/// <summary>
-		/// 删除沙盒内的清单文件夹
-		/// </summary>
-		public void DeleteSandboxManifestFilesFolder()
-		{
-			if (Directory.Exists(SandboxManifestFilesRoot))
-				Directory.Delete(SandboxManifestFilesRoot, true);
-		}
-
-
-		/// <summary>
-		/// 获取沙盒内包裹的清单文件的路径
-		/// </summary>
-		public string GetSandboxPackageManifestFilePath(string packageVersion)
-		{
-			string fileName = YooAssetSettingsData.GetManifestBinaryFileName(PackageName, packageVersion);
-			return PathUtility.Combine(SandboxManifestFilesRoot, fileName);
-		}
-
-		/// <summary>
-		/// 获取沙盒内包裹的哈希文件的路径
-		/// </summary>
-		public string GetSandboxPackageHashFilePath(string packageVersion)
-		{
-			string fileName = YooAssetSettingsData.GetPackageHashFileName(PackageName, packageVersion);
-			return PathUtility.Combine(SandboxManifestFilesRoot, fileName);
-		}
-
-		/// <summary>
-		/// 获取沙盒内包裹的版本文件的路径
-		/// </summary>
-		public string GetSandboxPackageVersionFilePath()
-		{
-			string fileName = YooAssetSettingsData.GetPackageVersionFileName(PackageName);
-			return PathUtility.Combine(SandboxManifestFilesRoot, fileName);
-		}
-
-		/// <summary>
-		/// 保存沙盒内默认的包裹版本
-		/// </summary>
-		public void SaveSandboxPackageVersionFile(string version)
-		{
-			string filePath = GetSandboxPackageVersionFilePath();
-			FileUtility.WriteAllText(filePath, version);
-		}
-
-
-		/// <summary>
-		/// 获取APP内包裹的清单文件的路径
-		/// </summary>
-		public string GetBuildinPackageManifestFilePath(string packageVersion)
-		{
-			string fileName = YooAssetSettingsData.GetManifestBinaryFileName(PackageName, packageVersion);
-			return PathUtility.Combine(BuildinPackageRoot, fileName);
-		}
-
-		/// <summary>
-		/// 获取APP内包裹的哈希文件的路径
-		/// </summary>
-		public string GetBuildinPackageHashFilePath(string packageVersion)
-		{
-			string fileName = YooAssetSettingsData.GetPackageHashFileName(PackageName, packageVersion);
-			return PathUtility.Combine(BuildinPackageRoot, fileName);
-		}
-
-		/// <summary>
-		/// 获取APP内包裹的版本文件的路径
-		/// </summary>
-		public string GetBuildinPackageVersionFilePath()
-		{
-			string fileName = YooAssetSettingsData.GetPackageVersionFileName(PackageName);
-			return PathUtility.Combine(BuildinPackageRoot, fileName);
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/PersistentManager.cs.meta

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

Assets/YooAsset/Runtime/CacheSystem/VerifyElement.cs

@@ -1,60 +0,0 @@
-using System.IO;
-
-namespace YooAsset
-{
-	/// <summary>
-	/// 缓存文件验证元素
-	/// </summary>
-	internal class VerifyCacheFileElement
-	{
-		public string PackageName { private set; get; }
-		public string CacheGUID { private set; get; }
-		public string FileRootPath { private set; get; }
-		public string DataFilePath { private set; get; }
-		public string InfoFilePath { private set; get; }
-
-		public EVerifyResult Result;
-		public string DataFileCRC;
-		public long DataFileSize;
-
-		public VerifyCacheFileElement(string packageName, string cacheGUID, string fileRootPath, string dataFilePath, string infoFilePath)
-		{
-			PackageName = packageName;
-			CacheGUID = cacheGUID;
-			FileRootPath = fileRootPath;
-			DataFilePath = dataFilePath;
-			InfoFilePath = infoFilePath;
-		}
-
-		public void DeleteFiles()
-		{
-			try
-			{
-				Directory.Delete(FileRootPath, true);
-			}
-			catch(System.Exception e)
-			{
-				YooLogger.Warning($"Failed delete cache bundle folder : {e}");
-			}
-		}
-	}
-
-	/// <summary>
-	/// 下载文件验证元素
-	/// </summary>
-	internal class VerifyTempFileElement
-	{
-		public string TempDataFilePath { private set; get; }
-		public string FileCRC { private set; get; }
-		public long FileSize { private set; get; }
-
-		public int Result = 0; // 注意：原子操作对象
-
-		public VerifyTempFileElement(string tempDataFilePath, string fileCRC, long fileSize)
-		{
-			TempDataFilePath = tempDataFilePath;
-			FileCRC = fileCRC;
-			FileSize = fileSize;
-		}
-	}
-}

Assets/YooAsset/Runtime/CacheSystem/VerifyElement.cs.meta

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

Assets/YooAsset/Runtime/DiagnosticSystem/DebugBundleInfo.cs

@@ -25,7 +25,7 @@ namespace YooAsset
         /// <summary>
         /// 加载状态
         /// </summary>
-		public string Status;
+        public EOperationStatus Status;
 
         public int CompareTo(DebugBundleInfo other)
         {

Assets/YooAsset/Runtime/DiagnosticSystem/RemoteDebuggerDefine.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Text;
-using UnityEngine;
 
 namespace YooAsset
 {

Assets/YooAsset/Runtime/DiagnosticSystem/RemoteDebuggerInRuntime.cs

@@ -18,7 +18,7 @@ namespace YooAsset
         /// </summary>
         public static void EditorRequestDebugReport()
         {
-			if(UnityEditor.EditorApplication.isPlaying)
+            if (UnityEditor.EditorApplication.isPlaying)
             {
                 var report = YooAssets.GetDebugReport();
                 EditorHandleDebugReportCallback?.Invoke(0, report);

Assets/YooAsset/Runtime/DownloadSystem/DownloadHelper.cs

@@ -1,41 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using System.Threading;
-using UnityEngine.Networking;
-
-namespace YooAsset
-{
-	/// <summary>
-	/// 自定义下载器的请求委托
-	/// </summary>
-	public delegate UnityWebRequest DownloadRequestDelegate(string url);
-
-
-	internal static class DownloadHelper
-	{
-		/// <summary>
-		/// 下载失败后清理文件的HTTP错误码
-		/// </summary>
-		public static List<long> ClearFileResponseCodes { set; get; }
-
-		/// <summary>
-		/// 自定义下载器的请求委托
-		/// </summary>
-		public static DownloadRequestDelegate RequestDelegate = null;
-
-		/// <summary>
-		/// 创建一个新的网络请求
-		/// </summary>
-		public static UnityWebRequest NewRequest(string requestURL)
-		{
-			UnityWebRequest webRequest;
-			if (RequestDelegate != null)
-				webRequest = RequestDelegate.Invoke(requestURL);
-			else
-				webRequest = new UnityWebRequest(requestURL, UnityWebRequest.kHttpVerbGET);
-			return webRequest;
-		}
-	}
-}

Assets/YooAsset/Runtime/DownloadSystem/DownloadHelper.cs.meta

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

Assets/YooAsset/Runtime/DownloadSystem/DownloadManager.cs

@@ -1,150 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine.Networking;
-
-namespace YooAsset
-{
-	/// <summary>
-	/// 1. 保证每一时刻资源文件只存在一个下载器
-	/// 2. 保证下载器下载完成后立刻验证并缓存
-	/// 3. 保证资源文件不会被重复下载
-	/// </summary>
-	internal class DownloadManager
-	{
-		private readonly Dictionary<string, DownloaderBase> _downloaders = new Dictionary<string, DownloaderBase>(1000);
-		private readonly List<string> _removeList = new List<string>(1000);
-
-		private uint _breakpointResumeFileSize;
-
-		/// <summary>
-		/// 所属包裹
-		/// </summary>
-		public readonly string PackageName;
-
-
-		public DownloadManager(string packageName)
-		{
-			PackageName = packageName;
-		}
-
-		/// <summary>
-		/// 初始化
-		/// </summary>
-		public void Initialize(uint breakpointResumeFileSize)
-		{
-			_breakpointResumeFileSize = breakpointResumeFileSize;
-		}
-
-		/// <summary>
-		/// 更新下载器
-		/// </summary>
-		public void Update()
-		{
-			// 更新下载器
-			_removeList.Clear();
-			foreach (var valuePair in _downloaders)
-			{
-				var downloader = valuePair.Value;
-				downloader.Update();
-				if (downloader.IsDone())
-				{
-					_removeList.Add(valuePair.Key);
-				}
-			}
-
-			// 移除下载器
-			foreach (var key in _removeList)
-			{
-				_downloaders.Remove(key);
-			}
-		}
-
-		/// <summary>
-		/// 销毁所有下载器
-		/// </summary>
-		public void DestroyAll()
-		{
-			foreach (var valuePair in _downloaders)
-			{
-				var downloader = valuePair.Value;
-				downloader.Abort();
-			}
-
-			_downloaders.Clear();
-			_removeList.Clear();
-		}
-
-		/// <summary>
-		/// 创建下载器
-		/// 注意：只有第一次请求的参数才有效
-		/// </summary>
-		public DownloaderBase CreateDownload(BundleInfo bundleInfo, int failedTryAgain, int timeout = 60)
-		{
-			// 查询存在的下载器
-			if (_downloaders.TryGetValue(bundleInfo.CachedDataFilePath, out var downloader))
-			{
-				downloader.Reference();
-				return downloader;
-			}
-
-			// 如果资源已经缓存
-			if (bundleInfo.IsCached())
-			{
-				var completedDownloader = new CompletedDownloader(bundleInfo);
-				return completedDownloader;
-			}
-
-			// 创建新的下载器	
-			DownloaderBase newDownloader = null;
-			YooLogger.Log($"Beginning to download bundle : {bundleInfo.Bundle.BundleName} URL : {bundleInfo.RemoteMainURL}");
-#if UNITY_WEBGL
-			if (bundleInfo.Bundle.Buildpipeline == EDefaultBuildPipeline.RawFileBuildPipeline.ToString())
-			{
-				FileUtility.CreateFileDirectory(bundleInfo.CachedDataFilePath);
-				System.Type requesterType = typeof(FileGeneralRequest);
-				newDownloader = new FileDownloader(bundleInfo, requesterType, failedTryAgain, timeout);
-			}
-			else
-			{
-				System.Type requesterType = typeof(AssetBundleWebRequest);
-				newDownloader = new WebDownloader(bundleInfo, requesterType, failedTryAgain, timeout);
-			}
-#else
-			FileUtility.CreateFileDirectory(bundleInfo.CachedDataFilePath);
-			bool resumeDownload = bundleInfo.Bundle.FileSize >= _breakpointResumeFileSize;
-			if (resumeDownload)
-			{
-				System.Type requesterType = typeof(FileResumeRequest);
-				newDownloader = new FileDownloader(bundleInfo, requesterType, failedTryAgain, timeout);
-			}
-			else
-			{
-				System.Type requesterType = typeof(FileGeneralRequest);
-				newDownloader = new FileDownloader(bundleInfo, requesterType, failedTryAgain, timeout);
-			}
-#endif
-
-			// 返回新创建的下载器
-			_downloaders.Add(bundleInfo.CachedDataFilePath, newDownloader);
-			newDownloader.Reference();
-			return newDownloader;
-		}
-
-		/// <summary>
-		/// 停止不再使用的下载器
-		/// </summary>
-		public void AbortUnusedDownloader()
-		{
-			foreach (var valuePair in _downloaders)
-			{
-				var downloader = valuePair.Value;
-				if (downloader.RefCount <= 0)
-				{
-					downloader.Abort();
-				}
-			}
-		}
-	}
-}

Assets/YooAsset/Runtime/DownloadSystem/DownloadManager.cs.meta

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

Assets/YooAsset/Runtime/DownloadSystem/DownloadParam.cs

@@ -0,0 +1,30 @@
+
+namespace YooAsset
+{
+    internal class DownloadParam
+    {
+        public readonly int FailedTryAgain;
+        public readonly int Timeout;
+
+        /// <summary>
+        /// 导入的本地文件路径
+        /// </summary>
+        public string ImportFilePath { set; get; }
+
+        /// <summary>
+        /// 主资源地址
+        /// </summary>
+        public string MainURL { set; get; }
+
+        /// <summary>
+        /// 备用资源地址
+        /// </summary>
+        public string FallbackURL { set; get; }
+
+        public DownloadParam(int failedTryAgain, int timeout)
+        {
+            FailedTryAgain = failedTryAgain;
+            Timeout = timeout;
+        }
+    }
+}