1

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/CustomPackRule.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+using YooAsset.Editor;
+
+[DisplayName("打包特效纹理（自定义）")]
+public class PackEffectTexture : IPackRule
+{
+    private const string PackDirectory = "Assets/Effect/Textures/";
+
+    PackRuleResult IPackRule.GetPackRuleResult(PackRuleData data)
+    {
+        string assetPath = data.AssetPath;
+        if (assetPath.StartsWith(PackDirectory) == false)
+            throw new Exception($"Only support folder : {PackDirectory}");
+    
+        string assetName = Path.GetFileName(assetPath).ToLower();
+        string firstChar = assetName.Substring(0, 1);
+        string bundleName = $"{PackDirectory}effect_texture_{firstChar}";
+        var packRuleResult = new PackRuleResult(bundleName, DefaultPackRule.AssetBundleFileExtension);
+        return packRuleResult;
+    }
+}
+
+[DisplayName("打包视频（自定义）")]
+public class PackVideo : IPackRule
+{
+    public PackRuleResult GetPackRuleResult(PackRuleData data)
+    {
+        string bundleName = RemoveExtension(data.AssetPath);
+        string fileExtension = Path.GetExtension(data.AssetPath);
+        fileExtension = fileExtension.Remove(0, 1);
+        PackRuleResult result = new PackRuleResult(bundleName, fileExtension);
+        return result;
+    }
+
+    private 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"
+    }
+}

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/PackageComparator/PackageComparatorWindow.cs

@@ -0,0 +1,138 @@
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+    public class PackageComparatorWindow : EditorWindow
+    {
+        static PackageComparatorWindow _thisInstance;
+        
+        [MenuItem("Tools/补丁包比对工具", false, 102)]
+        static void ShowWindow()
+        {
+            if (_thisInstance == null)
+            {
+                _thisInstance = EditorWindow.GetWindow(typeof(PackageComparatorWindow), false, "补丁包比对工具", true) as PackageComparatorWindow;
+                _thisInstance.minSize = new Vector2(800, 600);
+            }
+            _thisInstance.Show();
+        }
+
+        private string _manifestPath1 = string.Empty;
+        private string _manifestPath2 = string.Empty;
+        private readonly List<PackageBundle> _changeList = new List<PackageBundle>();
+        private readonly List<PackageBundle> _newList = new List<PackageBundle>();
+        private Vector2 _scrollPos1;
+        private Vector2 _scrollPos2;
+
+        private void OnGUI()
+        {
+            GUILayout.Space(10);
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("选择补丁包1", GUILayout.MaxWidth(150)))
+            {
+                string resultPath = EditorUtility.OpenFilePanel("Find", "Assets/", "bytes");
+                if (string.IsNullOrEmpty(resultPath))
+                    return;
+                _manifestPath1 = resultPath;
+            }
+            EditorGUILayout.LabelField(_manifestPath1);
+            EditorGUILayout.EndHorizontal();
+
+            GUILayout.Space(10);
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("选择补丁包2", GUILayout.MaxWidth(150)))
+            {
+                string resultPath = EditorUtility.OpenFilePanel("Find", "Assets/", "bytes");
+                if (string.IsNullOrEmpty(resultPath))
+                    return;
+                _manifestPath2 = resultPath;
+            }
+            EditorGUILayout.LabelField(_manifestPath2);
+            EditorGUILayout.EndHorizontal();
+
+            if (string.IsNullOrEmpty(_manifestPath1) == false && string.IsNullOrEmpty(_manifestPath2) == false)
+            {
+                if (GUILayout.Button("比对差异", GUILayout.MaxWidth(150)))
+                {
+                    ComparePackage(_changeList, _newList);
+                }
+            }
+
+            EditorGUILayout.Space();
+            using (new EditorGUI.DisabledScope(false))
+            {
+                int totalCount = _changeList.Count;
+                EditorGUILayout.Foldout(true, $"差异列表 ( {totalCount} )");
+
+                EditorGUI.indentLevel = 1;
+                _scrollPos1 = EditorGUILayout.BeginScrollView(_scrollPos1);
+                {
+                    foreach (var bundle in _changeList)
+                    {
+                        EditorGUILayout.LabelField($"{bundle.BundleName} | {(bundle.FileSize / 1024)}K");
+                    }
+                }
+                EditorGUILayout.EndScrollView();
+                EditorGUI.indentLevel = 0;
+            }
+
+            EditorGUILayout.Space();
+            using (new EditorGUI.DisabledScope(false))
+            {
+                int totalCount = _newList.Count;
+                EditorGUILayout.Foldout(true, $"新增列表 ( {totalCount} )");
+
+                EditorGUI.indentLevel = 1;
+                _scrollPos2 = EditorGUILayout.BeginScrollView(_scrollPos2);
+                {
+                    foreach (var bundle in _newList)
+                    {
+                        EditorGUILayout.LabelField($"{bundle.BundleName}");
+                    }
+                }
+                EditorGUILayout.EndScrollView();
+                EditorGUI.indentLevel = 0;
+            }
+        }
+
+        private void ComparePackage(List<PackageBundle> changeList, List<PackageBundle> newList)
+        {
+            changeList.Clear();
+            newList.Clear();
+
+            // 加载补丁清单1
+            byte[] bytesData1 = FileUtility.ReadAllBytes(_manifestPath1);
+            PackageManifest manifest1 = ManifestTools.DeserializeFromBinary(bytesData1);
+
+            // 加载补丁清单1
+            byte[] bytesData2 = FileUtility.ReadAllBytes(_manifestPath2);
+            PackageManifest manifest2 = ManifestTools.DeserializeFromBinary(bytesData2);
+
+            // 拷贝文件列表
+            foreach (var bundle2 in manifest2.BundleList)
+            {
+                if (manifest1.TryGetPackageBundleByBundleName(bundle2.BundleName, out PackageBundle bundle1))
+                {
+                    if (bundle2.FileHash != bundle1.FileHash)
+                    {
+                        changeList.Add(bundle2);
+                    }
+                }
+                else
+                {
+                    newList.Add(bundle2);
+                }
+            }
+
+            // 按字母重新排序
+            changeList.Sort((x, y) => string.Compare(x.BundleName, y.BundleName));
+            newList.Sort((x, y) => string.Compare(x.BundleName, y.BundleName));
+
+            Debug.Log("资源包差异比对完成！");
+        }
+    }
+}

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/PackageImporter/PackageImporterWindow.cs

@@ -0,0 +1,91 @@
+using System.IO;
+using UnityEngine;
+using UnityEditor;
+
+namespace YooAsset.Editor
+{
+    public class PackageImporterWindow : EditorWindow
+    {
+        static PackageImporterWindow _thisInstance;
+
+        [MenuItem("Tools/补丁包导入工具", false, 101)]
+        static void ShowWindow()
+        {
+            if (_thisInstance == null)
+            {
+                _thisInstance = EditorWindow.GetWindow(typeof(PackageImporterWindow), false, "补丁包导入工具", true) as PackageImporterWindow;
+                _thisInstance.minSize = new Vector2(800, 600);
+            }
+            _thisInstance.Show();
+        }
+
+        private string _manifestPath = string.Empty;
+        private string _packageName = "DefaultPackage";
+
+        private void OnGUI()
+        {
+            GUILayout.Space(10);
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("选择补丁包", GUILayout.MaxWidth(150)))
+            {
+                string resultPath = EditorUtility.OpenFilePanel("Find", "Assets/", "bytes");
+                if (string.IsNullOrEmpty(resultPath))
+                    return;
+                _manifestPath = resultPath;
+            }
+            EditorGUILayout.LabelField(_manifestPath);
+            EditorGUILayout.EndHorizontal();
+
+            if (string.IsNullOrEmpty(_manifestPath) == false)
+            {
+                if (GUILayout.Button("导入补丁包（全部文件）", GUILayout.MaxWidth(150)))
+                {
+                    string streamingAssetsRoot = AssetBundleBuilderHelper.GetStreamingAssetsRoot();
+                    EditorTools.ClearFolder(streamingAssetsRoot);
+                    CopyPackageFiles(_manifestPath);
+                }
+            }
+        }
+
+        private void CopyPackageFiles(string manifestFilePath)
+        {
+            string manifestFileName = Path.GetFileNameWithoutExtension(manifestFilePath);
+            string outputDirectory = Path.GetDirectoryName(manifestFilePath);
+
+            // 加载补丁清单
+            byte[] bytesData = FileUtility.ReadAllBytes(manifestFilePath);
+            PackageManifest manifest = ManifestTools.DeserializeFromBinary(bytesData);
+
+            // 拷贝核心文件
+            {
+                string sourcePath = $"{outputDirectory}/{manifestFileName}.bytes";
+                string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsRoot()}/{_packageName}/{manifestFileName}.bytes";
+                EditorTools.CopyFile(sourcePath, destPath, true);
+            }
+            {
+                string sourcePath = $"{outputDirectory}/{manifestFileName}.hash";
+                string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsRoot()}/{_packageName}/{manifestFileName}.hash";
+                EditorTools.CopyFile(sourcePath, destPath, true);
+            }
+            {
+                string fileName = YooAssetSettingsData.GetPackageVersionFileName(manifest.PackageName);
+                string sourcePath = $"{outputDirectory}/{fileName}";
+                string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsRoot()}/{_packageName}/{fileName}";
+                EditorTools.CopyFile(sourcePath, destPath, true);
+            }
+
+            // 拷贝文件列表
+            int fileCount = 0;
+            foreach (var packageBundle in manifest.BundleList)
+            {
+                fileCount++;
+                string sourcePath = $"{outputDirectory}/{packageBundle.FileName}";
+                string destPath = $"{AssetBundleBuilderHelper.GetStreamingAssetsRoot()}/{_packageName}/{packageBundle.FileName}";
+                EditorTools.CopyFile(sourcePath, destPath, true);
+            }
+
+            Debug.Log($"补丁包拷贝完成，一共拷贝了{fileCount}个资源文件");
+            AssetDatabase.Refresh();
+        }
+    }
+}

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/ShaderVariantCollector/ShaderVariantCollectionHelper.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEditor;
+using YooAsset.Editor;
+
+public static class ShaderVariantCollectionHelper
+{
+    public static void ClearCurrentShaderVariantCollection()
+    {
+        EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "ClearCurrentShaderVariantCollection");
+    }
+    public static void SaveCurrentShaderVariantCollection(string savePath)
+    {
+        EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "SaveCurrentShaderVariantCollection", savePath);
+    }
+    public static int GetCurrentShaderVariantCollectionShaderCount()
+    {
+        return (int)EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetCurrentShaderVariantCollectionShaderCount");
+    }
+    public static int GetCurrentShaderVariantCollectionVariantCount()
+    {
+        return (int)EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetCurrentShaderVariantCollectionVariantCount");
+    }
+
+    /// <summary>
+    /// 获取着色器的变种总数量
+    /// </summary>
+    public static string GetShaderVariantCount(string assetPath)
+    {
+        Shader shader = AssetDatabase.LoadAssetAtPath<Shader>(assetPath);
+        var variantCount = EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetVariantCount", shader, true);
+        return variantCount.ToString();
+    }
+}

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/ShaderVariantCollector/ShaderVariantCollectionManifest.cs

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

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/ShaderVariantCollector/ShaderVariantCollector.cs

@@ -0,0 +1,256 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.IO;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using YooAsset.Editor;
+using Debug = UnityEngine.Debug;
+
+public static class ShaderVariantCollector
+{
+    private enum ESteps
+    {
+        None,
+        Prepare,
+        CollectAllMaterial,
+        CollectVariants,
+        CollectSleeping,
+        WaitingDone,
+    }
+
+    private const float WaitMilliseconds = 1000f;
+    private const float SleepMilliseconds = 100f;
+    private static string _savePath;
+    private static string _packageName;
+    private static int _processMaxNum;
+    private static Action _completedCallback;
+
+    private static ESteps _steps = ESteps.None;
+    private static Stopwatch _elapsedTime;
+    private static List<string> _allMaterials;
+    private static List<GameObject> _allSpheres = new List<GameObject>(1000);
+
+
+    /// <summary>
+    /// 开始收集
+    /// </summary>
+    public static void Run(string savePath, string packageName, int processMaxNum, Action completedCallback)
+    {
+        if (_steps != ESteps.None)
+            return;
+
+        if (Path.HasExtension(savePath) == false)
+            savePath = $"{savePath}.shadervariants";
+        if (Path.GetExtension(savePath) != ".shadervariants")
+            throw new System.Exception("Shader variant file extension is invalid.");
+        if (string.IsNullOrEmpty(packageName))
+            throw new System.Exception("Package name is null or empty !");
+
+        // 注意：先删除再保存，否则ShaderVariantCollection内容将无法及时刷新
+        AssetDatabase.DeleteAsset(savePath);
+        EditorTools.CreateFileDirectory(savePath);
+        _savePath = savePath;
+        _packageName = packageName;
+        _processMaxNum = processMaxNum;
+        _completedCallback = completedCallback;
+
+        // 聚焦到游戏窗口
+        EditorTools.FocusUnityGameWindow();
+
+        // 创建临时测试场景
+        CreateTempScene();
+
+        _steps = ESteps.Prepare;
+        EditorApplication.update += EditorUpdate;
+    }
+
+    private static void EditorUpdate()
+    {
+        if (_steps == ESteps.None)
+            return;
+
+        if (_steps == ESteps.Prepare)
+        {
+            ShaderVariantCollectionHelper.ClearCurrentShaderVariantCollection();
+            _steps = ESteps.CollectAllMaterial;
+            return; //等待一帧
+        }
+
+        if (_steps == ESteps.CollectAllMaterial)
+        {
+            _allMaterials = GetAllMaterials();
+            _steps = ESteps.CollectVariants;
+            return; //等待一帧
+        }
+
+        if (_steps == ESteps.CollectVariants)
+        {
+            int count = Mathf.Min(_processMaxNum, _allMaterials.Count);
+            List<string> range = _allMaterials.GetRange(0, count);
+            _allMaterials.RemoveRange(0, count);
+            CollectVariants(range);
+
+            if (_allMaterials.Count > 0)
+            {
+                _elapsedTime = Stopwatch.StartNew();
+                _steps = ESteps.CollectSleeping;
+            }
+            else
+            {
+                _elapsedTime = Stopwatch.StartNew();
+                _steps = ESteps.WaitingDone;
+            }
+        }
+
+        if (_steps == ESteps.CollectSleeping)
+        {
+            if (_elapsedTime.ElapsedMilliseconds > SleepMilliseconds)
+            {
+                DestroyAllSpheres();
+                _elapsedTime.Stop();
+                _steps = ESteps.CollectVariants;
+            }
+        }
+
+        if (_steps == ESteps.WaitingDone)
+        {
+            // 注意：一定要延迟保存才会起效
+            if (_elapsedTime.ElapsedMilliseconds > WaitMilliseconds)
+            {
+                _elapsedTime.Stop();
+                _steps = ESteps.None;
+
+                // 保存结果并创建清单
+                ShaderVariantCollectionHelper.SaveCurrentShaderVariantCollection(_savePath);
+                CreateManifest();
+
+                Debug.Log($"搜集SVC完毕！");
+                EditorApplication.update -= EditorUpdate;
+                _completedCallback?.Invoke();
+            }
+        }
+    }
+    private static void CreateTempScene()
+    {
+        EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
+    }
+    private static List<string> GetAllMaterials()
+    {
+        int progressValue = 0;
+        List<string> allAssets = new List<string>(1000);
+
+        // 获取所有打包的资源
+        CollectResult collectResult = AssetBundleCollectorSettingData.Setting.GetPackageAssets(EBuildMode.DryRunBuild, _packageName);
+        foreach (var assetInfo in collectResult.CollectAssets)
+        {
+            string[] depends = AssetDatabase.GetDependencies(assetInfo.AssetInfo.AssetPath, true);
+            foreach (var dependAsset in depends)
+            {
+                if (allAssets.Contains(dependAsset) == false)
+                    allAssets.Add(dependAsset);
+            }
+            EditorTools.DisplayProgressBar("获取所有打包资源", ++progressValue, collectResult.CollectAssets.Count);
+        }
+        EditorTools.ClearProgressBar();
+
+        // 搜集所有材质球
+        progressValue = 0;
+        List<string> allMaterial = new List<string>(1000);
+        foreach (var assetPath in allAssets)
+        {
+            System.Type assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
+            if (assetType == typeof(UnityEngine.Material))
+            {
+                allMaterial.Add(assetPath);
+            }
+            EditorTools.DisplayProgressBar("搜集所有材质球", ++progressValue, allAssets.Count);
+        }
+        EditorTools.ClearProgressBar();
+
+        // 返回结果
+        return allMaterial;
+    }
+    private static void CollectVariants(List<string> materials)
+    {
+        Camera camera = Camera.main;
+        if (camera == null)
+            throw new System.Exception("Not found main camera.");
+
+        // 设置主相机
+        float aspect = camera.aspect;
+        int totalMaterials = materials.Count;
+        float height = Mathf.Sqrt(totalMaterials / aspect) + 1;
+        float width = Mathf.Sqrt(totalMaterials / aspect) * aspect + 1;
+        float halfHeight = Mathf.CeilToInt(height / 2f);
+        float halfWidth = Mathf.CeilToInt(width / 2f);
+        camera.orthographic = true;
+        camera.orthographicSize = halfHeight;
+        camera.transform.position = new Vector3(0f, 0f, -10f);
+
+        // 创建测试球体
+        int xMax = (int)(width - 1);
+        int x = 0, y = 0;
+        int progressValue = 0;
+        for (int i = 0; i < materials.Count; i++)
+        {
+            var material = materials[i];
+            var position = new Vector3(x - halfWidth + 1f, y - halfHeight + 1f, 0f);
+            var go = CreateSphere(material, position, i);
+            if (go != null)
+                _allSpheres.Add(go);
+            if (x == xMax)
+            {
+                x = 0;
+                y++;
+            }
+            else
+            {
+                x++;
+            }
+            EditorTools.DisplayProgressBar("照射所有材质球", ++progressValue, materials.Count);
+        }
+        EditorTools.ClearProgressBar();
+    }
+    private static GameObject CreateSphere(string assetPath, Vector3 position, int index)
+    {
+        var material = AssetDatabase.LoadAssetAtPath<Material>(assetPath);
+        var shader = material.shader;
+        if (shader == null)
+            return null;
+
+        var go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
+        go.GetComponent<Renderer>().sharedMaterial = material;
+        go.transform.position = position;
+        go.name = $"Sphere_{index} | {material.name}";
+        return go;
+    }
+    private static void DestroyAllSpheres()
+    {
+        foreach (var go in _allSpheres)
+        {
+            GameObject.DestroyImmediate(go);
+        }
+        _allSpheres.Clear();
+
+        // 尝试释放编辑器加载的资源
+        EditorUtility.UnloadUnusedAssetsImmediate(true);
+    }
+    private static void CreateManifest()
+    {
+        AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
+
+        ShaderVariantCollection svc = AssetDatabase.LoadAssetAtPath<ShaderVariantCollection>(_savePath);
+        if (svc != null)
+        {
+            var wrapper = ShaderVariantCollectionManifest.Extract(svc);
+            string jsonData = JsonUtility.ToJson(wrapper, true);
+            string savePath = _savePath.Replace(".shadervariants", ".json");
+            File.WriteAllText(savePath, jsonData);
+        }
+
+        AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
+    }
+}

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/ShaderVariantCollector/ShaderVariantCollectorSetting.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+using UnityEditor;
+
+public class ShaderVariantCollectorSetting : ScriptableObject
+{
+    private const string DefaultSavePath = "Assets/MyShaderVariants.shadervariants";
+
+    public static string GeFileSavePath(string packageName)
+    {
+        string key = $"{Application.productName}_{packageName}_GeFileSavePath";
+        return EditorPrefs.GetString(key, DefaultSavePath);
+    }
+    public static void SetFileSavePath(string packageName, string savePath)
+    {
+        string key = $"{Application.productName}_{packageName}_GeFileSavePath";
+        EditorPrefs.SetString(key, savePath);
+    }
+
+    public static int GeProcessCapacity(string packageName)
+    {
+        string key = $"{Application.productName}_{packageName}_GeProcessCapacity";
+        return EditorPrefs.GetInt(key, 1000);
+    }
+    public static void SetProcessCapacity(string packageName, int capacity)
+    {
+        string key = $"{Application.productName}_{packageName}_GeProcessCapacity";
+        EditorPrefs.SetInt(key, capacity);
+    }
+}

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/ShaderVariantCollector/ShaderVariantCollectorWindow.cs

@@ -0,0 +1,150 @@
+#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;
+using YooAsset.Editor;
+
+public class ShaderVariantCollectorWindow : EditorWindow
+{
+    [MenuItem("Tools/着色器变种收集器", false, 100)]
+    public static void OpenWindow()
+    {
+        ShaderVariantCollectorWindow window = GetWindow<ShaderVariantCollectorWindow>("着色器变种收集工具", true);
+        window.minSize = new Vector2(800, 600);
+    }
+
+    private Button _collectButton;
+    private TextField _collectOutputField;
+    private Label _currentShaderCountField;
+    private Label _currentVariantCountField;
+    private SliderInt _processCapacitySlider;
+    private PopupField<string> _packageField;
+
+    private List<string> _packageNames;
+    private string _currentPackageName;
+
+    public void CreateGUI()
+    {
+        try
+        {
+            VisualElement root = this.rootVisualElement;
+
+            // 加载布局文件
+            var visualAsset = UxmlLoader.LoadWindowUXML<ShaderVariantCollectorWindow>();
+            if (visualAsset == null)
+                return;
+
+            visualAsset.CloneTree(root);
+
+            // 包裹名称列表
+            _packageNames = GetBuildPackageNames();
+            _currentPackageName = _packageNames[0];
+
+            // 文件输出目录
+            _collectOutputField = root.Q<TextField>("CollectOutput");
+            _collectOutputField.SetValueWithoutNotify(ShaderVariantCollectorSetting.GeFileSavePath(_currentPackageName));
+            _collectOutputField.RegisterValueChangedCallback(evt =>
+            {
+                ShaderVariantCollectorSetting.SetFileSavePath(_currentPackageName, _collectOutputField.value);
+            });
+
+            // 收集的包裹
+            var packageContainer = root.Q("PackageContainer");
+            if (_packageNames.Count > 0)
+            {
+                int defaultIndex = GetDefaultPackageIndex(_currentPackageName);
+                _packageField = new PopupField<string>(_packageNames, defaultIndex);
+                _packageField.label = "Package";
+                _packageField.style.width = 350;
+                _packageField.RegisterValueChangedCallback(evt =>
+                {
+                    _currentPackageName = _packageField.value;
+                });
+                packageContainer.Add(_packageField);
+            }
+            else
+            {
+                _packageField = new PopupField<string>();
+                _packageField.label = "Package";
+                _packageField.style.width = 350;
+                packageContainer.Add(_packageField);
+            }
+
+            // 容器值
+            _processCapacitySlider = root.Q<SliderInt>("ProcessCapacity");
+            _processCapacitySlider.SetValueWithoutNotify(ShaderVariantCollectorSetting.GeProcessCapacity(_currentPackageName));
+#if !UNITY_2020_3_OR_NEWER
+            _processCapacitySlider.label = $"Capacity ({_processCapacitySlider.value})";
+            _processCapacitySlider.RegisterValueChangedCallback(evt =>
+            {
+                ShaderVariantCollectorSetting.SetProcessCapacity(_currentPackageName, _processCapacitySlider.value);
+                _processCapacitySlider.label = $"Capacity ({_processCapacitySlider.value})";
+            });
+#else
+            _processCapacitySlider.RegisterValueChangedCallback(evt =>
+            {
+                ShaderVariantCollectorSetting.SetProcessCapacity(_currentPackageName, _processCapacitySlider.value);
+            });
+#endif
+
+            _currentShaderCountField = root.Q<Label>("CurrentShaderCount");
+            _currentVariantCountField = root.Q<Label>("CurrentVariantCount");
+
+            // 变种收集按钮
+            _collectButton = root.Q<Button>("CollectButton");
+            _collectButton.clicked += CollectButton_clicked;
+        }
+        catch (Exception e)
+        {
+            Debug.LogError(e.ToString());
+        }
+    }
+    private void Update()
+    {
+        if (_currentShaderCountField != null)
+        {
+            int currentShaderCount = ShaderVariantCollectionHelper.GetCurrentShaderVariantCollectionShaderCount();
+            _currentShaderCountField.text = $"Current Shader Count : {currentShaderCount}";
+        }
+
+        if (_currentVariantCountField != null)
+        {
+            int currentVariantCount = ShaderVariantCollectionHelper.GetCurrentShaderVariantCollectionVariantCount();
+            _currentVariantCountField.text = $"Current Variant Count : {currentVariantCount}";
+        }
+    }
+
+    private void CollectButton_clicked()
+    {
+        string savePath = ShaderVariantCollectorSetting.GeFileSavePath(_currentPackageName);
+        int processCapacity = _processCapacitySlider.value;
+        ShaderVariantCollector.Run(savePath, _currentPackageName, processCapacity, null);
+    }
+
+    // 构建包裹相关
+    private int GetDefaultPackageIndex(string packageName)
+    {
+        for (int index = 0; index < _packageNames.Count; index++)
+        {
+            if (_packageNames[index] == packageName)
+            {
+                return index;
+            }
+        }
+        return 0;
+    }
+    private List<string> GetBuildPackageNames()
+    {
+        List<string> result = new List<string>();
+        foreach (var package in AssetBundleCollectorSettingData.Setting.Packages)
+        {
+            result.Add(package.PackageName);
+        }
+        return result;
+    }
+}
+#endif

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Editor/ShaderVariantCollector/ShaderVariantCollectorWindow.uxml

@@ -0,0 +1,11 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" editor-extension-mode="False">
+    <uie:Toolbar name="Toolbar" style="display: flex; flex-direction: row-reverse;" />
+    <ui:VisualElement name="CollectContainer">
+        <ui:TextField picking-mode="Ignore" label="文件保存路径" name="CollectOutput" style="height: 22px;" />
+        <ui:VisualElement name="PackageContainer" style="height: 24px;" />
+        <ui:Label text="Current Shader Count" display-tooltip-when-elided="true" name="CurrentShaderCount" style="height: 20px; padding-left: 4px;" />
+        <ui:Label text="Current Variant Count" display-tooltip-when-elided="true" name="CurrentVariantCount" style="height: 20px; padding-left: 4px;" />
+        <ui:SliderInt picking-mode="Ignore" label="Capacity" value="9999" high-value="1000" name="ProcessCapacity" low-value="10" show-input-field="true" />
+        <ui:Button text="开始搜集" display-tooltip-when-elided="true" name="CollectButton" style="height: 50px; background-color: rgb(40, 106, 42); margin-top: 10px;" />
+    </ui:VisualElement>
+</ui:UXML>

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Runtime/AssetOperationHandleExtension.cs

@@ -0,0 +1,16 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using YooAsset;
+
+public static class AssetOperationHandleExtension
+{
+    /// <summary>
+    /// 等待异步执行完毕
+    /// </summary>
+    public static AssetHandle WaitForAsyncOperationComplete(this AssetHandle thisHandle)
+    {
+        thisHandle.WaitForAsyncComplete();
+        return thisHandle;
+    }
+}

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Runtime/GameObjectAssetReference.cs

@@ -0,0 +1,73 @@
+using UnityEngine;
+using YooAsset;
+
+#if UNITY_EDITOR
+[UnityEditor.CustomEditor(typeof(GameObjectAssetReference), true)]
+public class GameObjectAssetReferenceInspector : UnityEditor.Editor
+{
+    private bool _init = false;
+    private GameObject _cacheObject;
+
+    public override void OnInspectorGUI()
+    {
+        GameObjectAssetReference mono = (GameObjectAssetReference)target;
+
+        if (_init == false)
+        {
+            _init = true;
+            if (string.IsNullOrEmpty(mono.AssetGUID) == false)
+            {
+                string assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(mono.AssetGUID);
+                if (string.IsNullOrEmpty(assetPath) == false)
+                {
+                    _cacheObject = UnityEditor.AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+                }
+            }
+        }
+
+        GameObject go = (GameObject)UnityEditor.EditorGUILayout.ObjectField(_cacheObject, typeof(GameObject), false);
+        if (go != _cacheObject)
+        {
+            _cacheObject = go;
+            string assetPath = UnityEditor.AssetDatabase.GetAssetPath(go);
+            mono.AssetGUID = UnityEditor.AssetDatabase.AssetPathToGUID(assetPath);
+            UnityEditor.EditorUtility.SetDirty(target);
+        }
+
+        UnityEditor.EditorGUILayout.LabelField("Asset GUID", mono.AssetGUID);
+    }
+}
+#endif
+
+
+public class GameObjectAssetReference : MonoBehaviour
+{
+    [HideInInspector]
+    public string AssetGUID = "";
+
+    private AssetHandle _handle;
+
+    public void Start()
+    {
+        var package = YooAssets.GetPackage("DefaultPackage");
+        var assetInfo = package.GetAssetInfoByGUID(AssetGUID);
+        _handle = package.LoadAssetAsync(assetInfo);
+        _handle.Completed += Handle_Completed;
+    }
+    public void OnDestroy()
+    {
+        if (_handle != null)
+        {
+            _handle.Release();
+            _handle = null;
+        }
+    }
+
+    private void Handle_Completed(AssetHandle handle)
+    {
+        if (handle.Status == EOperationStatus.Succeed)
+        {
+            handle.InstantiateSync(this.transform);
+        }
+    }
+}

Assets/Samples/YooAsset/2.1.1/Extension Sample/Scripts/Runtime/LoadAssetsByTagOperation.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using YooAsset;
+
+public class LoadAssetsByTagOperation<TObject> : GameAsyncOperation where TObject : UnityEngine.Object
+{
+    private enum ESteps
+    {
+        None,
+        LoadAssets,
+        CheckResult,
+        Done,
+    }
+
+    private readonly string _tag;
+    private ESteps _steps = ESteps.None;
+    private List<AssetHandle> _handles;
+
+    /// <summary>
+    /// 资源对象集合
+    /// </summary>
+    public List<TObject> AssetObjects { private set; get; }
+
+
+    public LoadAssetsByTagOperation(string tag)
+    {
+        _tag = tag;
+    }
+    protected override void OnStart()
+    {
+        _steps = ESteps.LoadAssets;
+    }
+    protected override void OnUpdate()
+    {
+        if (_steps == ESteps.None || _steps == ESteps.Done)
+            return;
+
+        if (_steps == ESteps.LoadAssets)
+        {
+            AssetInfo[] assetInfos = YooAssets.GetAssetInfos(_tag);
+            _handles = new List<AssetHandle>(assetInfos.Length);
+            foreach (var assetInfo in assetInfos)
+            {
+                var handle = YooAssets.LoadAssetAsync(assetInfo);
+                _handles.Add(handle);
+            }
+            _steps = ESteps.CheckResult;
+        }
+
+        if (_steps == ESteps.CheckResult)
+        {
+            int index = 0;
+            foreach (var handle in _handles)
+            {			
+                if (handle.IsDone == false)
+                {
+                    Progress = (float)index / _handles.Count;
+                    return;
+                }
+                index++;
+            }
+
+            AssetObjects = new List<TObject>(_handles.Count);
+            foreach (var handle in _handles)
+            {
+                if (handle.Status == EOperationStatus.Succeed)
+                {
+                    var assetObject = handle.AssetObject as TObject;
+                    if (assetObject != null)
+                    {
+                        AssetObjects.Add(assetObject);
+                    }
+                    else
+                    {
+                        string error = $"资源类型转换失败：{handle.AssetObject.name}";
+                        Debug.LogError($"{error}");
+                        AssetObjects.Clear();
+                        SetFinish(false, error);
+                        return;
+                    }
+                }
+                else
+                {
+                    Debug.LogError($"{handle.LastError}");
+                    AssetObjects.Clear();
+                    SetFinish(false, handle.LastError);
+                    return;
+                }
+            }
+
+            SetFinish(true);
+        }
+    }
+    protected override void OnAbort()
+    {
+    }
+    private void SetFinish(bool succeed, string error = "")
+    {
+        Error = error;
+        Status = succeed ? EOperationStatus.Succeed : EOperationStatus.Failed;
+        _steps = ESteps.Done;
+    }
+
+    /// <summary>
+    /// 释放资源句柄
+    /// </summary>
+    public void ReleaseHandle()
+    {
+        foreach (var handle in _handles)
+        {
+            handle.Release();
+        }
+        _handles.Clear();
+    }
+}