许可优化
许可优化
产品
产品
解决方案
解决方案
服务支持
服务支持
关于
关于
软件库
当前位置:服务支持 >  软件文章 >  封装Unity常用AB素材包读取函数,代码复用省时间

封装Unity常用AB素材包读取函数,代码复用省时间

阅读数 14
点赞 0
article_banner


异步/同步快捷获取目标AB素材包的函式↓

代码块


//#define UNITY_STANDALONE //BepInEx制作UnityMOD时可手动启用
#if UNITY_EDITOR || UNITY_STANDALONE
using System.IO;
using System.Collections;
using UnityEngine;
using System.Collections.Generic;
using System;
using Object = UnityEngine.Object;

namespace MetalMaxSystem.Unity
{
    /// <summary>
    /// 资源方法类,提供AssetBundle资源管理方案.当使用异步加载时,该类只能有1个正在加载资源的协程,届时用Resource.isCoroutineRunning来检查是否可以开启新协程.
    /// 协程必须在MonoBehaviour组件实例中创建和运行,所以本类必须作为组件挂载到一个GameObject上才能使用.
    /// </summary>
    public class AssetBundleLoader : MonoBehaviour
    {
        private static AssetBundleLoader _instance; //这个处理AB包的类只需单例
        private static Queue<Action> actions = new Queue<Action>();
        private static Queue<IEnumerator> coroutines = new Queue<IEnumerator>();

        //资源字典,用于存储加载的资源实例.string用于区分多个不同存储键区.
        //以下字段在协程实例才有结果存储,加不加静态修饰都无所谓,但加静态后可通过类名直接访问,少写一个Instance.
        //路径填写绝对相对都行,如果填写相对路径,则相对路径是相对于游戏运行目录(即exe所在目录)的路径.

        /// <summary>
        /// 全局存储协程实例成功加载到的素材数组.
        /// </summary>
        private static Dictionary<string, Object[]> _objectGroup = new Dictionary<string, Object[]>();
        /// <summary>
        /// 全局存储协程实例成功加载到的单个素材.
        /// </summary>
        private static Dictionary<string, Object> _object = new Dictionary<string, Object>();
        /// <summary>
        /// 全局存储协程实例成功加载到的AB包.
        /// </summary>
        private static Dictionary<string, AssetBundle> _assetBundle = new Dictionary<string, AssetBundle>();
        /// <summary>
        /// 全局存储的协程枚举器对象.
        /// </summary>
        private static Dictionary<string, IEnumerator> _iEnumerator = new Dictionary<string, IEnumerator>();
        /// <summary>
        /// 全局存储的协程实例.
        /// </summary>
        private static Dictionary<string, Coroutine> _coroutine = new Dictionary<string, Coroutine>();

        /// <summary>
        /// 临时存储当前协程实例成功加载到的素材数组,注意本字段会被覆盖.
        /// </summary>
        public static Object[] currentObjectGroup;
        /// <summary>
        /// 临时存储当前协程实例成功加载到的单个素材,注意本字段会被覆盖.
        /// </summary>
        public static Object currentObject;
        /// <summary>
        /// 临时存储当前协程实例成功加载到的AB包,注意本字段会被覆盖.
        /// </summary>
        public static AssetBundle currentAssetBundle;
        /// <summary>
        /// 临时存储的当前协程枚举器对象,注意本字段会被覆盖.
        /// </summary>
        public static IEnumerator currentIEnumerator;
        /// <summary>
        /// 临时存储的当前协程实例,注意本字段会被覆盖.
        /// </summary>
        public static Coroutine currentCoroutine;

        /// <summary>
        /// 通过静态方法创建AssetBundleLoader的单例实例.
        /// 本组件实例挂载于名为"AssetBundleLoader"的GameObject上.
        /// 本类所封装的处理AB包素材异步加载的协程依赖本组件实例运行.
        /// </summary>
        public static AssetBundleLoader Instance
        {
            get
            {
                if (_instance == null)
                {
                    var obj = GameObject.Find("AssetBundleLoader");
                    if (obj == null) obj = new GameObject("AssetBundleLoader");
                    _instance = obj.GetComponent<AssetBundleLoader>();
                    if (_instance == null) _instance = obj.AddComponent<AssetBundleLoader>();
                    DontDestroyOnLoad(obj);
                }
                return _instance;
            }
        }

        private void Update()
        {
            //即使Enqueue已加锁,Update遍历队列时若不加锁可能遇到Enqueue执行到一半时主线程的Update开始遍历队列->读取到不一致的队列状态

            lock (actions)
            {
                while (actions.Count > 0)
                {
                    actions.Dequeue()?.Invoke();
                }
            }

            lock (coroutines)
            {
                while (coroutines.Count > 0)
                {
                    StartCoroutine(coroutines.Dequeue());
                }
            }
        }

        //↓封装的回调函数(支持在子线程使用,然后由主线程回调执行)

        /// <summary>
        /// 回调函数.
        /// 对Unity引擎组件实例相关动作执行回调(回到主线程调用Action).
        /// 示例AssetBundleLoader.Instance.Invoke(() =>{涉及主线程对象的动作});
        /// </summary>
        /// <param name="action">这个匿名委托将被添加到队列,由一个专门处理回调的MonoBehaviour组件实例来跑</param>
        public void Invoke(Action action)
        {
            if (action == null) return;

            lock (actions)
            {
                actions.Enqueue(action);
            }
        }
        /// <summary>
        /// 回调函数.
        /// 对Unity引擎组件实例相关动作执行回调(回到主线程调用Action).
        /// 示例AssetBundleLoader.Call(() =>{涉及主线程对象的动作});
        /// </summary>
        /// <param name="action">这个匿名委托将被添加到队列,由一个专门处理回调的MonoBehaviour组件实例来跑</param>
        public static void Call(Action action)
        {
            if (action == null) return;
            var ensure = Instance;
            lock (actions)
            {
                actions.Enqueue(action);
            }
        }

        /// <summary>
        /// 回调函数.
        /// 对Unity引擎组件实例相关动作执行回调(回到主线程调用协程).
        /// 示例AssetBundleLoader.Instance.Invoke(MyCoroutine());
        /// </summary>
        public void Invoke(IEnumerator coroutine)
        {
            if (coroutine == null) return;

            lock (coroutines)
            {
                coroutines.Enqueue(coroutine);
            }
        }
        /// <summary>
        /// 回调函数.
        /// 对Unity引擎组件实例相关动作执行回调(回到主线程调用协程).
        /// 示例AssetBundleLoader.Call(MyCoroutine());
        /// </summary>
        public static void Call(IEnumerator coroutine)
        {
            if (coroutine == null) return;
            var ensure = Instance;
            lock (coroutines)
            {
                coroutines.Enqueue(coroutine);
            }
        }

        /// <summary>
        /// 回调函数.直接传入协程方法体.
        /// 对Unity引擎组件实例相关动作执行回调(回到主线程调用协程).
        /// 示例AssetBundleLoader.Instance.Invoke(() => {
        ///     yield return new WaitForSeconds(1);
        ///     Debug.Log("Delayed log");
        /// });
        /// </summary>
        public void Invoke(Func<IEnumerator> coroutineFunc)
        {
            if (coroutineFunc == null) return;
            Invoke(coroutineFunc());
        }
        /// <summary>
        /// 回调函数.直接传入协程方法体.
        /// 对Unity引擎组件实例相关动作执行回调(回到主线程调用协程).
        /// 示例AssetBundleLoader.Call(() => {
        ///     yield return new WaitForSeconds(1);
        ///     Debug.Log("Delayed log");
        /// });
        /// </summary>
        public static void Call(Func<IEnumerator> coroutineFunc)
        {
            if (coroutineFunc == null) return;
            var ensure = Instance;
            Call(coroutineFunc());
        }

        //↓获取协程读取资源时存储在字典的素材对象

        /// <summary>
        /// 获取字典中存储的AssetBundle实例.
        /// </summary>
        /// <param name="key"></param>
        public static AssetBundle GetAssetBundle(string key)
        {
            if (!_assetBundle.ContainsKey("ABLoader_AssetBundle" + key))
            {
                return null;
            }
            return _assetBundle["ABLoader_AssetBundle" + key];
        }

        /// <summary>
        /// 获取字典中存储的Object实例.
        /// </summary>
        /// <param name="key"></param>
        public static T GetObject<T>(string key) where T : Object
        {
            //注意:若Object是GameObject类型,则返回的Object实例可以直接转换为GameObject类型
            if (!_object.ContainsKey("ABLoader_Object" + key))
            {
                return null;
            }
            return _object["ABLoader_Object" + key] as T;
        }

        /// <summary>
        /// 获取字典中存储的Object实例数组.
        /// </summary>
        /// <param name="key"></param>
        public static T[] GetObjectGroup<T>(string key) where T : Object
        {
            if (!_objectGroup.ContainsKey("ABLoader_ObjectGroup" + key))
            {
                return null;
            }
            return _objectGroup["ABLoader_ObjectGroup" + key] as T[];
        }

        /// <summary>
        /// 获取字典中存储的IEnumerator实例.
        /// </summary>
        /// <param name="key"></param>
        public static IEnumerator GetIEnumerator(string key)
        {
            if (!_iEnumerator.ContainsKey("ABLoader_IEnumerator" + key))
            {
                return null;
            }
            return _iEnumerator["ABLoader_IEnumerator" + key];
        }

        /// <summary>
        /// 获取字典中存储的Coroutine实例.
        /// </summary>
        /// <param name="key"></param>
        public static Coroutine GetCoroutine(string key)
        {
            if (!_coroutine.ContainsKey("ABLoader_Coroutine" + key))
            {
                return null;
            }
            return _coroutine["ABLoader_Coroutine" + key];
        }

        //↑因为是单例模式,填Static也无妨,且可通过类名直接访问,少写一个Instance.

        #region 这些代码是用来加载AB包的具体方法(若协程调用失败,请用Instance方法创建组件实例来运行,协程必须依赖1个MonoBehaviour实例来运行)

        //函数在Unity中使用正常,素材也实例化成功,但进行BepInEx制作MOD时报错:①读取文件报header问题;②读取字节则内存数据无法成功解压
        //故障原因跟Unity版本有关,建议用游戏同版本Unity去转AB包素材

        /// <summary>
        /// 以文件的形式加载AssetBundle中指定名称的单个素材.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName">AB包根目录下素材的原始路径,只填名称则搜索到第一个同名元素即返回</param>
        /// <param name="assetBundle"></param>
        /// <returns></returns>
        public static T LoadFromFile<T>(string path, string resName, out AssetBundle assetBundle) where T : Object
        {
            assetBundle = AssetBundle.LoadFromFile(path);
            return assetBundle.LoadAsset<T>(resName);
        }
        /// <summary>
        /// 以byte[]形式加载AssetBundle中指定名称的单个素材.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName">AB包根目录下素材的原始路径,只填名称则搜索到第一个同名元素即返回</param>
        /// <param name="assetBundle"></param>
        public static T LoadFromMemory<T>(string path, string resName, out AssetBundle assetBundle) where T : Object
        {
            assetBundle = AssetBundle.LoadFromMemory(File.ReadAllBytes(path));
            return assetBundle.LoadAsset<T>(resName);
        }
        /// <summary>
        /// 以流的形式加载AssetBundle中指定名称的单个素材.文件流FileStream采用系统默认缓冲区大小(4KB)进行流式读取.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName">AB包根目录下素材的原始路径,只填名称则搜索到第一个同名元素即返回</param>
        /// <param name="assetBundle"></param>
        /// <param name="bufferSize">文件流缓冲区大小</param>
        /// <returns></returns>
        public static T LoadFromStream<T>(string path, string resName, out AssetBundle assetBundle, int bufferSize = 4096) where T : Object
        {
            //可自行指定FileStream缓冲区大小
            using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize))
            {
                assetBundle = AssetBundle.LoadFromStream(stream);
                return assetBundle.LoadAsset<T>(resName);
            }
        }
        /// <summary>
        /// 以文件的形式加载AssetBundle中指定类型的全部素材.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="assetBundle"></param>
        /// <returns></returns>
        public static T[] LoadFromFile<T>(string path, out AssetBundle assetBundle) where T : Object
        {
            assetBundle = AssetBundle.LoadFromFile(path);
            return assetBundle.LoadAllAssets<T>();
        }
        /// <summary>
        /// 以byte[]形式加载AssetBundle中指定类型的全部素材.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="assetBundle"></param>
        public static T[] LoadFromMemory<T>(string path, out AssetBundle assetBundle) where T : Object
        {
            assetBundle = AssetBundle.LoadFromMemory(File.ReadAllBytes(path));
            return assetBundle.LoadAllAssets<T>();
        }
        /// <summary>
        /// 以流的形式加载AssetBundle中指定类型的全部素材.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="assetBundle"></param>
        /// <param name="bufferSize">文件流缓冲区大小</param>
        public static T[] LoadFromStream<T>(string path, out AssetBundle assetBundle, int bufferSize = 4096) where T : Object
        {
            //可自行指定FileStream缓冲区大小
            using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize))
            {
                assetBundle = AssetBundle.LoadFromStream(stream);
                return assetBundle.LoadAllAssets<T>();
            }
        }

        //↓异步方法全部是实例方法,必须依赖MonoBehaviour组件实例来运行协程

        /// <summary>
        /// 异步以文件的形式加载AssetBundle中指定名称的单个素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObject<T>(key)获取加载的素材实例,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName">AB包根目录下素材的原始路径,只填名称则搜索到第一个同名元素即返回</param>
        /// <param name="key">存储键区</param>
        /// <returns></returns>
        private static IEnumerator ABLoadFromFileAsync<T>(string path, string resName, string key = "") where T : Object
        {
            //AssetBundleCreateRequest 类是 AssetBundle 的一个实例,它表示一个异步加载请求.
            //AssetBundle.LoadFromFileAsync 方法使用指定路径的文件来创建一个新的 AssetBundleCreateRequest 实例.

            AssetBundleCreateRequest request = AssetBundle.LoadFromFileAsync(path);
            yield return request;
            if (request.assetBundle == null)
            {
                Debug.LogError("AssetBundle加载失败: " + path);
                yield break;
            }
            if (key != null && key != "")
            {
                _assetBundle["ABLoader_AssetBundle" + key] = request.assetBundle;
                _object["ABLoader_Object" + key] = request.assetBundle.LoadAsset<T>(resName);
            }
            else
            {
                currentAssetBundle = request.assetBundle;
                currentObject = request.assetBundle.LoadAsset<T>(resName);
            }
            //在Unity中,协程(Coroutine)会自动管理其生命周期,协程中的IEnumerator方法执行完毕,协程就会自行结束,不需要显式地调用Stop方法.
        }
        /// <summary>
        /// 异步以byte[]形式加载AssetBundle中指定名称的单个素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObject<T>(key)获取加载的素材实例,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName">AB包根目录下素材的原始路径,只填名称则搜索到第一个同名元素即返回</param>
        /// <param name="key">存储键区</param>
        /// <returns></returns>
        private static IEnumerator ABLoadFromMemoryAsync<T>(string path, string resName, string key = "") where T : Object
        {
            AssetBundleCreateRequest request = AssetBundle.LoadFromMemoryAsync(File.ReadAllBytes(path));
            yield return request;
            if (request.assetBundle == null)
            {
                Debug.LogError("AssetBundle加载失败: " + path);
                yield break;
            }
            if (key != null && key != "")
            {
                _assetBundle["ABLoader_AssetBundle" + key] = request.assetBundle;
                _object["ABLoader_Object" + key] = request.assetBundle.LoadAsset<T>(resName);
            }
            else
            {
                currentAssetBundle = request.assetBundle;
                currentObject = request.assetBundle.LoadAsset<T>(resName);
            }
        }
        /// <summary>
        /// 异步以流的形式加载AssetBundle中指定名称的单个素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObject<T>(key)获取加载的素材实例,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName"></param>
        /// <param name="key">存储键区</param>
        /// <param name="bufferSize">文件流缓冲区大小</param>
        /// <returns></returns>
        private static IEnumerator ABLoadFromStreamAsync<T>(string path, string resName, string key = "", int bufferSize = 4096) where T : Object
        {
            //可自行指定FileStream缓冲区大小
            using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize))
            {
                AssetBundleCreateRequest request = AssetBundle.LoadFromStreamAsync(stream);
                //yield return 语句用于将控制权交还调用上下文,直到异步加载请求完成.一旦请求完成,后续将使用 LoadAsset 方法从 AssetBundle 中加载指定名称的游戏对象.
                yield return request;
                if (request.assetBundle == null)
                {
                    Debug.LogError("AssetBundle加载失败: " + path);
                    yield break;
                }
                if (key != null && key != "")
                {
                    _assetBundle["ABLoader_AssetBundle" + key] = request.assetBundle;
                    _objectGroup["ABLoader_ObjectGroup" + key] = request.assetBundle.LoadAllAssets<T>();
                }
                else
                {
                    currentAssetBundle = request.assetBundle;
                    currentObjectGroup = request.assetBundle.LoadAllAssets<T>();
                }
            }
        }
        /// <summary>
        /// 异步以文件的形式加载AssetBundle中指定名称的单个素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObject<T>(key)获取加载的素材实例,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName"></param>
        /// <param name="key">存储键区</param>
        /// <returns></returns>
        public void LoadFromFileAsync<T>(string path, string resName, string key = "") where T : Object
        {
            //启动协程并保存其引用
            if (key != null && key != "")
            {
                _iEnumerator["ABLoader_IEnumerator" + key] = ABLoadFromFileAsync<T>(path, resName, key);
                _coroutine["ABLoader_Coroutine" + key] = StartCoroutine(_iEnumerator["ABLoader_IEnumerator" + key]);
            }
            else
            {
                currentIEnumerator = ABLoadFromFileAsync<T>(path, resName, key);
                currentCoroutine = StartCoroutine(currentIEnumerator);
            }
        }
        /// <summary>
        /// 异步以byte[]形式加载AssetBundle中指定名称的单个素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObject<T>(key)获取加载的素材实例,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName"></param>
        /// <param name="key">存储键区</param>
        /// <returns></returns>
        public void LoadFromMemoryAsync<T>(string path, string resName, string key = "") where T : Object
        {
            //启动协程并保存其引用
            if (key != null && key != "")
            {
                _iEnumerator["ABLoader_IEnumerator" + key] = ABLoadFromMemoryAsync<T>(path, resName, key);
                _coroutine["ABLoader_Coroutine" + key] = StartCoroutine(_iEnumerator["ABLoader_IEnumerator" + key]);
            }
            else
            {
                currentIEnumerator = ABLoadFromMemoryAsync<T>(path, resName, key);
                currentCoroutine = StartCoroutine(currentIEnumerator);
            }
        }
        /// <summary>
        /// 异步以流的形式加载AssetBundle中指定名称的单个素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObject<T>(key)获取加载的素材实例,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="resName"></param>
        /// <param name="key">存储键区</param>
        /// <param name="bufferSize">文件流缓冲区大小</param>
        /// <returns></returns>
        public void LoadFromStreamAsync<T>(string path, string resName, string key = "", int bufferSize = 4096) where T : Object
        {
            //启动协程并保存其引用
            if (key != null && key != "")
            {
                _iEnumerator["ABLoader_IEnumerator" + key] = ABLoadFromStreamAsync<T>(path, resName, key, bufferSize);
                _coroutine["ABLoader_Coroutine" + key] = StartCoroutine(_iEnumerator["ABLoader_IEnumerator" + key]);
            }
            else
            {
                currentIEnumerator = ABLoadFromStreamAsync<T>(path, resName, key);
                currentCoroutine = StartCoroutine(currentIEnumerator);
            }
        }

        /// <summary>
        /// 异步以文件的形式加载AssetBundle中指定类型的全部素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObjectGroup<T>(key)获取加载的素材实例数组,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="key">存储键区</param>
        /// <returns></returns>
        private static IEnumerator ABLoadAllFromFileAsync<T>(string path, string key = "") where T : Object
        {
            AssetBundleCreateRequest request = AssetBundle.LoadFromFileAsync(path);
            yield return request;
            if (request.assetBundle == null)
            {
                Debug.LogError("AssetBundle加载失败: " + path);
                yield break;
            }
            if (!string.IsNullOrEmpty(key))
            {
                _assetBundle["ABLoader_AssetBundle" + key] = request.assetBundle;
                _objectGroup["ABLoader_ObjectGroup" + key] = request.assetBundle.LoadAllAssets<T>();
                Debug.Log($"成功加载{_objectGroup["ABLoader_ObjectGroup" + key].Length}个{typeof(T).Name}类型资源");
            }
            else
            {
                currentAssetBundle = request.assetBundle;
                currentObjectGroup = request.assetBundle.LoadAllAssets<T>();
                Debug.Log($"成功加载{currentObjectGroup.Length}个{typeof(T).Name}类型资源");
            }
        }
        /// <summary>
        /// 异步以文件的形式加载AssetBundle中指定类型的全部素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObjectGroup<T>(key)获取加载的素材实例数组,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="key">存储键区</param>
        /// <returns></returns>
        public void LoadAllFromFileAsync<T>(string path, string key = "") where T : Object
        {
            //启动协程并保存其引用
            if (!string.IsNullOrEmpty(key))
            {
                _iEnumerator["ABLoader_IEnumerator" + key] = ABLoadAllFromFileAsync<T>(path, key);
                _coroutine["ABLoader_Coroutine" + key] = StartCoroutine(_iEnumerator["ABLoader_IEnumerator" + key]);
            }
            else
            {
                currentIEnumerator = ABLoadAllFromFileAsync<T>(path, key);
                currentCoroutine = StartCoroutine(currentIEnumerator);
            }
        }
        /// <summary>
        /// 异步以byte[]形式加载AssetBundle中指定类型的全部素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObjectGroup<T>(key)获取加载的素材实例数组,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="key">存储键区</param>
        /// <returns></returns>
        private static IEnumerator ABLoadAllFromMemoryAsync<T>(string path, string key = "") where T : Object
        {
            //Debug.Log($"AssetBundleLoader<{typeof(T).Name}>: 进入泛型协程");
            AssetBundleCreateRequest request = AssetBundle.LoadFromMemoryAsync(File.ReadAllBytes(path));
            yield return request;
            if (request.assetBundle == null)
            {
                Debug.LogError("AssetBundle加载失败: " + path);
                yield break;
            }
            if (!string.IsNullOrEmpty(key))
            {
                _assetBundle["ABLoader_AssetBundle" + key] = request.assetBundle;
                _objectGroup["ABLoader_ObjectGroup" + key] = request.assetBundle.LoadAllAssets<T>();
                Debug.Log($"成功加载{_objectGroup["ABLoader_ObjectGroup" + key].Length}个{typeof(T).Name}类型资源");
            }
            else
            {
                currentAssetBundle = request.assetBundle;
                currentObjectGroup = request.assetBundle.LoadAllAssets<T>();
                Debug.Log($"成功加载{currentObjectGroup.Length}个{typeof(T).Name}类型资源");
            }
        }
        /// <summary>
        /// 异步以byte[]形式加载AssetBundle中指定类型的全部素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObjectGroup<T>(key)获取加载的素材实例数组,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="key">存储键区</param>
        /// <returns></returns>
        public void LoadAllFromMemoryAsync<T>(string path, string key = "") where T : Object
        {
            //启动协程并保存其引用
            if (!string.IsNullOrEmpty(key))
            {
                _iEnumerator["ABLoader_IEnumerator" + key] = ABLoadAllFromMemoryAsync<T>(path, key);
                _coroutine["ABLoader_Coroutine" + key] = StartCoroutine(_iEnumerator["ABLoader_IEnumerator" + key]);
            }
            else
            {
                currentIEnumerator = ABLoadAllFromMemoryAsync<T>(path, key);
                currentCoroutine = StartCoroutine(currentIEnumerator);
            }
        }
        /// <summary>
        /// 异步以流的形式加载AssetBundle中指定类型的全部素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObjectGroup<T>(key)获取加载的素材实例数组,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="key">存储键区</param>
        /// <param name="bufferSize">文件流缓冲区大小</param>
        /// <returns></returns>
        private static IEnumerator ABLoadAllFromStreamAsync<T>(string path, string key = "", int bufferSize = 4096) where T : Object
        {
            //可自行指定FileStream缓冲区大小
            using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize))
            {
                AssetBundleCreateRequest request = AssetBundle.LoadFromStreamAsync(stream);
                yield return request;
                if (request.assetBundle == null)
                {
                    Debug.LogError("AssetBundle加载失败: " + path);
                    yield break;
                }
                if (!string.IsNullOrEmpty(key))
                {
                    _assetBundle["ABLoader_AssetBundle" + key] = request.assetBundle;
                    _objectGroup["ABLoader_ObjectGroup" + key] = request.assetBundle.LoadAllAssets<T>();
                    Debug.Log($"成功加载{_objectGroup["ABLoader_ObjectGroup" + key].Length}个{typeof(T).Name}类型资源");
                }
                else
                {
                    currentAssetBundle = request.assetBundle;
                    currentObjectGroup = request.assetBundle.LoadAllAssets<T>();
                    Debug.Log($"成功加载{currentObjectGroup.Length}个{typeof(T).Name}类型资源");
                }
            }

        }
        /// <summary>
        /// 异步以流的形式加载AssetBundle中指定类型的全部素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
        /// 加载完成可通过GetObjectGroup<T>(key)获取加载的素材实例数组,或通过GetAssetBundle(key)获取加载的AssetBundle实例.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="key">存储键区</param>
        /// <param name="bufferSize">文件流缓冲区大小</param>
        /// <returns></returns>
        public void LoadAllFromStreamAsync<T>(string path, string key = "", int bufferSize = 4096) where T : Object
        {
            //启动协程并保存其引用
            if (!string.IsNullOrEmpty(key))
            {
                _iEnumerator["ABLoader_IEnumerator" + key] = ABLoadAllFromStreamAsync<T>(path, key);
                _coroutine["ABLoader_Coroutine" + key] = StartCoroutine(_iEnumerator["ABLoader_IEnumerator" + key]);
            }
            else
            {
                currentIEnumerator = ABLoadAllFromStreamAsync<T>(path, key);
                currentCoroutine = StartCoroutine(currentIEnumerator);
            }
        }

        /// <summary>
        /// 步进协程(异步加载资源),让没完成的协程继续往下跑.
        /// MoveNext()方法一般不是直接调用的,在Unity中协程的推进是由Unity的引擎自动管理的.
        /// 当协程挂起(yield return)等待某个操作完成时,引擎会在适当的时候自动调用MoveNext()来恢复协程的执行,故不需要(也不应该)手动调用MoveNext().
        /// 若同一函数特征的协程方法被执行多次(绑定多个协程实例)的话,无法精准操作每个实例个体的步进,会形成批量一起催促(慎用).
        /// </summary>
        public static void MoveNext(IEnumerator currentIEnumerator)
        {
            currentIEnumerator.MoveNext(); //内部检索所有绑定的Coroutine并执行,如绑多个Coroutine的话无法精准操作每个个体只能批量一起催促
        }

        #endregion
    }
}
#endif

      复制成功
     
     
     
     

以上拖Unity编辑器或BepInEx做Mod读取外部AB包。

若有粗鄙之处还请见谅。


用法:

代码块

//Unity官方内置加载法
_specialAssetBundle = AssetBundle.LoadFromMemory(File.ReadAllBytes(Application.dataPath + "/AssetBundle/SpecialAssets.ab"));

      复制成功
     
//使用本类下的方法同步/异步加载法

//需要同步的情况
private static SpecialAssets _specialAssetData;
/// <summary>
/// [编辑器环境][内部]材质、Shader、贴图等资源做成ScriptableObject文件,编辑器环境放Resources/ScriptableObject/SpecialAssets.asset,打包时自动关联所有文件,使用时智能管理.
/// Resources只需放这么一个SO文件,其余素材放别目录,用到时拖给SO即可(SO也可拖给SO),避免不一定用到的素材全放Resources致冗余,也方便素材管理.
/// </summary>
public static SpecialAssets SpecialAssetData
{
    get
    {
        if (_specialAssetData == null)
        {
            //编辑器的Resources目录下只需放1个ScriptableObject/SpecialAssets.asset
            _specialAssetData = Resources.Load<SpecialAssets>("ScriptableObject/SpecialAssets");
            if (_specialAssetData == null)
            {
                //若没有放,则用AssetBundleLoader同步加载指定地址名称的AB包内的SpecialAssets.asset
                _specialAssetData = AssetBundleLoader.LoadFromMemory<SpecialAssets>(Application.dataPath + "/AssetBundle/SpecialAssets.ab", "SpecialAssets", out _specialAssetBundle);
            }
        }
        return _specialAssetData;
    }
}

//开启一个协程异步进行资源加载
LoadAllFromMemoryAsync(Application.dataPath + "/AssetBundle/abtest");

//异步以byte[]形式加载AssetBundle中指定类型的全部素材并存储在字典.要注意所有的异步加载都会开启协程(依赖MonoBehaviour实例来运行).
//加载完成可通过GetObjectGroup<T>(key)获取加载的素材实例数组,或通过GetAssetBundle(key)获取加载的AssetBundle实例.

      复制成功
     
     
     
     

Application.dataPath:打包前(编辑器环境)是Assets文件夹下的路径,打包后是识别exe程序名称_Data文件夹下的路径(注意末尾没有\)。



免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删

相关文章
技术文档
QR Code
微信扫一扫,欢迎咨询~
customer

online

联系我们
武汉格发信息技术有限公司
湖北省武汉市经开区科技园西路6号103孵化器
电话:155-2731-8020 座机:027-59821821
邮件:tanzw@gofarlic.com
Copyright © 2023 Gofarsoft Co.,Ltd. 保留所有权利
遇到许可问题?该如何解决!?
评估许可证实际采购量? 
不清楚软件许可证使用数据? 
收到软件厂商律师函!?  
想要少购买点许可证,节省费用? 
收到软件厂商侵权通告!?  
有正版license,但许可证不够用,需要新购? 
联系方式 board-phone 155-2731-8020
close1
预留信息,一起解决您的问题
* 姓名:
* 手机:

* 公司名称:

姓名不为空

姓名不为空

姓名不为空
手机不正确

手机不正确

手机不正确
公司不为空

公司不为空

公司不为空