异步/同步快捷获取目标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文件夹下的路径(注意末尾没有\)。
免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删