ZK_Framework/Assets/Scripts/Hotfix/Game/Resource/ResourceManager.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Cysharp.Threading.Tasks;
using UnityEngine;
using UnityEngine.SceneManagement;
using YooAsset;
using Object = UnityEngine.Object;

namespace Game
{
    public enum LoadType
    {
        Editor,
        Single,
        Online
    }

    public enum SceneType
    {
        Init,
        Touch,
    }

    public class ResourceManager : ManagerBase, IResourceManager
    {
        private List<string> _packageName = new List<string>();
        private ResourcePackage _defaultPackage;
        private Dictionary<string, AssetHandle> _assetHandles = new Dictionary<string, AssetHandle>();
        private Dictionary<string, SceneHandle> _sceneHandles = new Dictionary<string, SceneHandle>();
        private Dictionary<string, GameObject> _gameObjects = new Dictionary<string, GameObject>();

        private Transform objectParent;
        private Transform uiParent;

        private Transform ui_Low;
        private Transform ui_Mid;
        private Transform ui_High;
        private Transform go_GameObject;

        private EPlayMode playMode;
        private bool isLoadFinish;

        protected override void OnInit()
        {
            base.OnInit();
            YooAssets.Initialize();

            // 
            ui_Low = GameObject.Find("Global/UICanvas/Low").transform;
            ui_Mid = GameObject.Find("Global/UICanvas/Mid").transform;
            ui_High = GameObject.Find("Global/UICanvas/High").transform;
            go_GameObject = GameObject.Find("Global/GameObject").transform;

            isLoadFinish = false;
            EventManager.Instance.Subscribe(UpdaterDoneEventArgs.EventId, UpdaterDoneEvent);
        }

        private void UpdaterDoneEvent(object sender, GameEventArgs e)
        {
            var args = e as UpdaterDoneEventArgs;
            isLoadFinish = true;
        }

        protected override void OnUpdate(float dateTime)
        {
            base.OnUpdate(dateTime);
        }

        public void LoadPackage(string packageName)
        {
            if (_packageName.Contains(packageName)) return;
            YooAssets.CreatePackage(packageName);
            _packageName.Add(packageName);
        }

        public void UnloadPackage(string packageName)
        {
            var resourcePackage = YooAssets.GetPackage(packageName);
            if (resourcePackage != null)
            {
                resourcePackage.UnloadUnusedAssets();
                YooAssets.DestroyPackage(packageName);
                _packageName.Remove(packageName);
            }
        }

//        ResourceUpdatePackageHandle handle;

        public void InitLoadModeSync(EPlayMode playMode)
        {
//            this.playMode = playMode;
//            handle = new ResourceUpdatePackageHandle(playMode, "DefaultPackage", EDefaultBuildPipeline.BuiltinBuildPipeline.ToString());
//            await handle.InitPackageAsync();
//
//            while (!this.isLoadFinish)
//            {
//                await UniTask.Yield();
//            }

            _defaultPackage = YooAssets.GetPackage("DefaultPackage");
            YooAssets.SetDefaultPackage(_defaultPackage);
        }

        public AssetHandle LoadAssetSync(string name)
        {
            if (_assetHandles.TryGetValue(name, out var assetHandle))
            {
                return assetHandle;
            }

            var loadAssetSync = YooAssets.LoadAssetSync(name);
            _assetHandles.Add(name, loadAssetSync);
            return loadAssetSync;
        }

        public GameObject LoadGameObjectSync(string name)
        {
            var loadAssetSync = LoadAssetSync(name);
            var assetObject = loadAssetSync.AssetObject as GameObject;
            if (this.objectParent == null)
                this.objectParent = go_GameObject;

            var gameObject = Object.Instantiate(assetObject, this.objectParent);
            return gameObject;
        }

        public GameObject LoadUIGameObjectSync(string name, UILayer uiLayer)
        {
            var loadAssetSync = LoadAssetSync(name);
            var assetObject = loadAssetSync.AssetObject as GameObject;
//            if (this.uiParent == null)
//                this.uiParent = GameObject.Find("Global/UICanvas").transform;

            switch (uiLayer)
            {
                case UILayer.Low:
                    this.uiParent = ui_Low;
                    break;
                case UILayer.Mid:
                    this.uiParent = ui_Mid;
                    break;
                case UILayer.High:
                    this.uiParent = ui_High;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(uiLayer), uiLayer, null);
            }

            var gameObject = Object.Instantiate(assetObject, uiParent);
            return gameObject;
        }

        public async UniTask LoadSceneAsync(string location, LoadSceneMode loadSceneMode = LoadSceneMode.Single,
            bool suspendLoad = false, Action<float> schedule = null)
        {
            // if (_assetHandles.TryGetValue(name, out var assetHandle))
            // {
            //     return assetHandle;
            // }

            var loadSceneAsync = YooAssets.LoadSceneAsync(location, loadSceneMode, suspendLoad);
            _sceneHandles.Add(location, loadSceneAsync);
//            await loadSceneAsync.Task;

            while (!loadSceneAsync.IsDone)
            {
                Debug.Log("进度：" + loadSceneAsync.Progress);
                schedule?.Invoke(loadSceneAsync.Progress);
                await UniTask.Yield();
            }

//            await loadSceneAsync.Task;
            Debug.Log($"{location}场景加载成功！");
        }

        public async void UnloadSceneAsync(SceneType sceneType)
        {
            var name = sceneType.ToString();
            if (_sceneHandles.TryGetValue(name, out var handle))
            {
                await handle.UnloadAsync().Task;
                Debug.Log($"{name}场景卸载成功！");
            }
        }

        public async UniTask<Object> LoadAssetAsync(string name)
        {
            if (_assetHandles.TryGetValue(name, out var assetHandle))
            {
                return assetHandle.AssetObject;
            }

            var loadAssetSync = YooAssets.LoadAssetAsync(name);
            await loadAssetSync.Task;
            _assetHandles.Add(name, loadAssetSync);
            return loadAssetSync.AssetObject;
        }

        public async UniTask<GameObject> LoadGameObjectAsync(string name)
        {
            var loadAssetSync = await LoadAssetAsync(name);
            var assetObject = loadAssetSync as GameObject;
            var gameObject = Object.Instantiate(assetObject);

            return gameObject;
        }

        public void Release(string name)
        {
            if (_assetHandles.TryGetValue(name, out var assetHandle))
            {
                assetHandle.Release();
            }
        }

        protected override void OnDispose()
        {
            base.OnDispose();
            while (_packageName.Count > 0)
            {
                var packageName = _packageName[0];
                UnloadPackage(packageName);
                _packageName.Remove(packageName);
            }

            EventManager.Instance.Unsubscribe(UpdaterDoneEventArgs.EventId, UpdaterDoneEvent);

            // foreach (var handle in _sceneHandles.Values)
            // {
            //     UnloadSceneAsync(handle.SceneName);
            // }

            _sceneHandles = null;
            _packageName = null;
            _gameObjects = null;
            _assetHandles = null;
        }
    }

    public interface IResourceManager
    {
        AssetHandle LoadAssetSync(string name);
        GameObject LoadGameObjectSync(string path);
        GameObject LoadUIGameObjectSync(string path, UILayer uiLayer);

        UniTask LoadSceneAsync(string location, LoadSceneMode loadSceneMode = LoadSceneMode.Single, bool suspendLoad = false, Action<float> schedule = null);
    }
}