AssetBundle加载管理器

最新推荐文章于 2023-01-03 18:56:43 发布

DESIDERIO

最新推荐文章于 2023-01-03 18:56:43 发布

阅读量180

点赞数

分类专栏： # 热更新文章标签： Unity AssetBundle 异步加载资源管理游戏开发

本文链接：https://blog.youkuaiyun.com/ZuoXuanZuo/article/details/120695522

版权

热更新专栏收录该内容

2 篇文章

订阅专栏

这篇博客介绍了在 Unity 游戏开发中如何使用 ABLoaderManager 类进行 AssetBundle 管理，包括加载主包及其依赖、同步和异步加载资源、卸载 AssetBundle 的实现细节。通过该类，开发者可以高效地管理和加载游戏资源，提高游戏性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class ABLoaderManager : SingletonAutoMono<ABLoaderManager> {
    private AssetBundle _mainAB = null;//主包
    private AssetBundleManifest _manifets = null;
    private Dictionary<string, AssetBundle> _abDic = new Dictionary<string, AssetBundle>();
    AssetBundle _ab = null;
    private string PathUrl {//Ab包存放路径
        get {
            return Application.streamingAssetsPath + "/";
        }
    }

    private string MainABName {//获取主包名
        get {
#if UNITY_IOS
            return "IOS";
#elif UNITY_ANDROID
            return "Android";
#else
            return "PC";
#endif
        }
    }

    #region 获取主包以及依赖，加载资源对应包
    /// <summary>
    /// 加载主包及依赖
    /// </summary>
    /// <param name="abName">需要依赖的包名</param>
    private void LoadABDepedencies(string abName) {
        //第一步--------------加载所需依赖包---------------------
        //加载主包
        if (_mainAB == null) {
            _mainAB = AssetBundle.LoadFromFile(PathUrl + MainABName);
            _manifets = _mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }
        //获取依赖包
        string[] deps = _manifets.GetAllDependencies(abName);
        for (int i = 0; i < deps.Length; i++) {
            if (!_abDic.ContainsKey(deps[i])) {
                _ab = AssetBundle.LoadFromFile(PathUrl + deps[i]);
                _abDic.Add(deps[i], _ab);
            }
        }
    }

    private void LoadAB(string abName) {
        if (!_abDic.ContainsKey(abName)) {
            LoadABDepedencies(abName);
            _ab = AssetBundle.LoadFromFile(PathUrl + abName);
            _abDic.Add(abName, _ab);
        }
    }

    private void LoadABAsync(string abName, UnityAction afterLoading) {
        if (!_abDic.ContainsKey(abName)) {
            LoadABDepedencies(abName);
            StartCoroutine(RealLoadABAsync(abName, afterLoading));
        } else {
            afterLoading();
        }
    }
    private IEnumerator RealLoadABAsync(string abName, UnityAction callBack) {
        AssetBundleCreateRequest abcr = AssetBundle.LoadFromFileAsync(PathUrl + abName);
        yield return abcr;
        _abDic.Add(abName, abcr.assetBundle);
        callBack();
    }
    #endregion

    #region 同步加载
    public Object LoadRes(string abName, string resName) {
        LoadAB(abName);
        return _abDic[abName].LoadAsset(resName);
    }

    public Object LoadRes(string abName, string resName, System.Type type) {
        LoadAB(abName);
        return _abDic[abName].LoadAsset(resName, type);
    }

    public T LoadRes<T>(string abName, string resName) where T : Object {
        LoadAB(abName);
        return _abDic[abName].LoadAsset<T>(resName);
    }
    #endregion

    #region 异步加载
    //加载依赖包不异步
    public void LoadResAsync(string abName, string resName, UnityAction<Object> callBack) {
        LoadABAsync(abName, () => {
            StartCoroutine(RealLoadResAsync(abName, resName, callBack));
        });
    }

    private IEnumerator RealLoadResAsync(string abName, string resName, UnityAction<Object> callBack) {
        AssetBundleRequest abr = _abDic[abName].LoadAssetAsync(resName);
        yield return abr;
        callBack(abr.asset);
    }

    public void LoadResAsync(string abName, string resName, System.Type type, UnityAction<Object> callBack) {
        LoadABAsync(abName, () => {
            StartCoroutine(RealLoadResAsync(abName, resName, type, callBack));
        });
    }

    private IEnumerator RealLoadResAsync(string abName, string resName, System.Type type, UnityAction<Object> callBack) {
        AssetBundleRequest abr = _abDic[abName].LoadAssetAsync(resName, type);
        yield return abr;
        callBack(abr.asset);
    }

    public void LoadResAsync<T>(string abName, string resName, UnityAction<T> callBack) where T : Object {
        LoadABAsync(abName, () => {
            StartCoroutine(RealLoadResAsync<T>(abName, resName, callBack));
        });
    }

    private IEnumerator RealLoadResAsync<T>(string abName, string resName, UnityAction<T> callBack) where T : Object {
        AssetBundleRequest abr = _abDic[abName].LoadAssetAsync<T>(resName);
        yield return abr;
        callBack(abr.asset as T);
    }
    #endregion

    #region 卸载AB包
    //单个
    public void UnloadAB(string abName, bool clearLoadedObject) {
        if (_abDic.ContainsKey(abName)) {
            _abDic[abName].Unload(clearLoadedObject);
            _abDic.Remove(abName);
        }
    }
    //全部
    public void UnloadAllAB(bool clearLoadedObject) {
        AssetBundle.UnloadAllAssetBundles(clearLoadedObject);
        _abDic.Clear();
    }
    #endregion
}