Unity简单资源加载框架（八）：使用AssetLoader类加载使用AssetLoader加载非prefab资源与自动卸载策略

已于 2022-05-11 10:39:10 修改
阅读量1.1k 收藏 5
点赞数 2
分类专栏： Unity的自我学习 文章标签： unity c# 游戏引擎
于 2022-05-09 17:34:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44149074/article/details/124671232
版权

1.AssetLoader

/****************************************************
    文件：AssetLoader.cs
	作者：赵深圳
    邮箱: 1329346609@qq.com
    日期：2022/5/9 10:39:33
	功能：资源加载器
*****************************************************/

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEditor;
using UnityEngine;
using UnityEngine.Networking;

/// <summary>
/// 资源加载器
/// </summary>
public class AssetLoader : Singleton<AssetLoader>
{
    /// <summary>
    /// 平台对应的只读路径下的资源
    /// key 模块名字
    /// value 模块下所有的资源
    /// </summary>
    public Dictionary<string, Hashtable> base2Assets;


    public AssetLoader()
    {
        base2Assets = new Dictionary<string, Hashtable>();
    }

    /// <summary>
    /// 加载模块对应的全局AssetBundle资源管理文件
    /// </summary>
    /// <param name="moduleConfig">模块名字</param>
    /// <param name="onCompelte">加载完成后的回调</param>
    public async Task<ModuleABConfig> LoadAssetBundleConfig(string moduleName)
    {
#if UNITY_EDITOR
        if (GlobalConfig.BundleMode == false)
        {
            return null;
        }
        else
        {
            return await LoadAssetBundleConfig_Runtime(moduleName);
        }
#else
         return await LoadAssetBundleConfig_Runtime(moduleName);
#endif
    }

    /// <summary>
    /// 加载本地的模块的AB配置文件
    /// </summary>
    /// <param name="moudleName">模块的名字</param>
    /// <returns></returns>
    public async Task<ModuleABConfig> LoadAssetBundleConfig_Runtime(string moudleName)
    {
        string url = Application.streamingAssetsPath + "/" + moudleName + "/" + moudleName.ToLower() + ".json";

        UnityWebRequest request = UnityWebRequest.Get(url);

        await request.SendWebRequest();

        if (string.IsNullOrEmpty(request.error))
        {
            return LitJson.JsonMapper.ToObject<ModuleABConfig>(request.downloadHandler.text);
        }
        return null;
    }

    /// <summary>
    /// 根据模块的json文件创角内存中资源管理器
    /// </summary>
    /// <param name="moduleABConfig"></param>
    /// <returns></returns>
    public Hashtable ConfigAssembly(ModuleABConfig moduleABConfig) 
    {
        //根据ab配置文件，得到所有的bundleinfo，并转换成bundlRef
        Dictionary<string, BundleRef> name2BundleRef = new Dictionary<string, BundleRef>();
        foreach (KeyValuePair<string,BundleInfo> keyValue in moduleABConfig.BundleInfoDic) 
        {
            string bundleName = keyValue.Key;
            BundleInfo bundleInfo = keyValue.Value;

            name2BundleRef[bundleName] = new BundleRef(bundleInfo);
        }

        Hashtable path2AssetRef = new Hashtable();
        //获取所有Asset资源信息
        for (int i = 0; i < moduleABConfig.AssetInfoArr.Length; i++)
        {
            AssetInfo assetInfo = moduleABConfig.AssetInfoArr[i];
            AssetRef assetRef = new AssetRef(assetInfo);
            assetRef.bundleRef = name2BundleRef[assetInfo.bundle_name];
            int count = assetInfo.dependenciesLst.Count;
            assetRef.dependencies = new BundleRef[count];

            for (int index = 0; index < count; index++)
            {
                string bundleName = assetInfo.dependenciesLst[index];
                assetRef.dependencies[index] = name2BundleRef[bundleName];
            }
            path2AssetRef.Add(assetInfo.asset_path,assetRef);
        }
        return path2AssetRef;
    }

    /// <summary>
    /// 加载游戏对象
    /// </summary>
    /// <param name="moduleName">模块名字</param>
    /// <param name="path">游戏对象的相对路径</param>
    /// <returns></returns>
    public GameObject Clone(string moduleName,string path)
    {
        //获取当前路径资源所在内存中信息
        AssetRef assetRef= LoadAssetRef<GameObject>(moduleName,path);

        if (assetRef==null||assetRef.asset==null)
        {
            return null;
        }
        //实例化资源
        GameObject gameObject = UnityEngine.Object.Instantiate(assetRef.asset) as GameObject;
        if (assetRef.children==null)
        {
            assetRef.children = new List<GameObject>();
        }
        //把当前实例化资源加入到加入到Asset的被依赖列表中
        assetRef.children.Add(gameObject);
        return gameObject;
    }

    /// <summary>
    /// 加载AssetRef对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="moduleName">模块名字</param>
    /// <param name="assetPath">资源的相对路径</param>
    /// <returns></returns>
    private AssetRef LoadAssetRef<T>(string moduleName, string assetPath) where T : UnityEngine.Object 
    {
#if UNITY_EDITOR
        if (GlobalConfig.BundleMode == false)
        {
            return LoadAssetRef_Editor<T>(moduleName, assetPath);
        }
        else 
        {
            return LoadAssetRef_Runtime<T>(moduleName,assetPath);
        }
#else
            return LoadAssetRef_Runtime<T>(moduleName,assetPath);
#endif
    }

    /// <summary>
    /// 编译器模式下加载AssetRef对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="moduleName">模块名字</param>
    /// <param name="assetPath">资源的相对路径</param>
    /// <returns></returns>
    private AssetRef LoadAssetRef_Editor<T>(string moduleName, string assetPath) where T : UnityEngine.Object 
    {
#if UNITY_EDITOR
        if (string.IsNullOrEmpty(assetPath))
        {
            return null;
        }
        AssetRef assetRef = new AssetRef(null);
        assetRef.asset = AssetDatabase.LoadAssetAtPath<T>(assetPath);
        return assetRef;
#else
         return null;
#endif
    }

    /// <summary>
    /// AB包模式下加载的AssetRef对象
    /// </summary>
    /// <typeparam name="T">要加载的资源类型</typeparam>
    /// <param name="moduleName">模块名字</param>
    /// <param name="assetPath">资源的相对路径</param>
    /// <returns></returns>
    private AssetRef LoadAssetRef_Runtime<T>(string moduleName, string assetPath) where T : UnityEngine.Object 
    {
        if (string.IsNullOrEmpty(assetPath))
        {
            return null;
        }

        Hashtable module2AssetRef;
        //得到这个模块的所有资源集合
        bool moduleExsit = base2Assets.TryGetValue(moduleName,out module2AssetRef);
        if (moduleExsit==false)
        {
            Debug.LogError("未找到资源对应模块：moduleName="+moduleName+"assetPath="+assetPath);
            return null;
        }
        //得到资源中内存对象
        AssetRef assetRef = (AssetRef)module2AssetRef[assetPath];
        if (assetPath==null)
        {
            Debug.LogError("未找到资源：moduleName=" + moduleName + "assetPath=" + assetPath);
            return null;
        }
        //如果已经加载直接返回
        if (assetRef.asset!=null)
        {
            return assetRef;
        }

        //处理AssetRef依赖的BundleRef列表
        foreach (BundleRef oneBundleRef in assetRef.dependencies)
        {
            if (oneBundleRef.bundle==null)//判断当前依赖项的bundle有没有被加载
            {
                string bundlePath = BundlePath(moduleName,oneBundleRef.bundleInfo.bundle_name);
                //加载当前依赖项的bundle
                oneBundleRef.bundle = AssetBundle.LoadFromFile(bundlePath);
            }
            if (oneBundleRef.chilren==null)
            {
                oneBundleRef.chilren = new List<AssetRef>();
            }
            //设置依赖项的被依赖资源列表，把自己加入到依赖项的被依赖的资源列表中
            oneBundleRef.chilren.Add(assetRef);
        }

        //处理assetRef属于哪个BundleRef对象
        //判断自己所属的Bundle有没有被加载
        BundleRef bundleRef = assetRef.bundleRef;
        if (bundleRef.bundle==null)
        {
            //加载自身所在的AB包
            bundleRef.bundle = AssetBundle.LoadFromFile(BundlePath(moduleName,bundleRef.bundleInfo.bundle_name));
        }

        //把自己加到自己所属的Bundle的被依赖资源列表中
        if (bundleRef.chilren==null)
        {
            bundleRef.chilren = new List<AssetRef>();
        }

        bundleRef.chilren.Add(assetRef);

        //从bundle中提取asset

        assetRef.asset = assetRef.bundleRef.bundle.LoadAsset<T>(assetRef.assetInfo.asset_path);

        if (typeof(T) == typeof(GameObject) && assetRef.assetInfo.asset_path.EndsWith(".prefab"))
        {
            assetRef.isGameObject = true;
        }
        else {
            assetRef.isGameObject = false;            
        }
        return assetRef;
    }


    /// <summary>
    /// 创建资源对象
    /// </summary>
    /// <typeparam name="T">资源类型</typeparam>
    /// <param name="moduleName">模块名字</param>
    /// <param name="assetPath">资源路径</param>
    /// <param name="gameObject">资源加载后，所挂载到的游戏对象</param>
    /// <returns></returns>
    public T CreateAsset<T>(string moduleName, string assetPath, GameObject gameObject) where T : UnityEngine.Object
    {
        if (typeof(T)==typeof(GameObject)||(!string.IsNullOrEmpty(assetPath)&&assetPath.EndsWith(".prefab")))
        {
            Debug.LogError("不可以加载GameObject类型，请直接使用AssetLoader.Instance.Clone接口，path:"+assetPath);
            return null;
        }
        if (gameObject==null)
        {
            Debug.LogError("CreateAsset必须传递一个gameObject其将要被挂载的GameObject对象！");
            return null;
        }

        AssetRef assetRef = LoadAssetRef<T>(moduleName,assetPath);
        if (assetRef==null||assetRef.asset==null)
        {
            return null;
        }

        if (assetRef.children==null)
        {
            assetRef.children = new List<GameObject>();
        }
        assetRef.children.Add(gameObject);
        return assetRef.asset as T;
    }


    public void Unload(Dictionary<string,Hashtable> module2Assets) 
    {
        foreach (string  moduleName in module2Assets.Keys)
        {
            Hashtable path2AssetRef = module2Assets[moduleName];
            if (path2AssetRef==null)
            {
                continue;
            }
            foreach (AssetRef assetRef in path2AssetRef.Values)
            {
                if (assetRef.children==null||assetRef.children.Count==0)
                {
                    continue;
                }

                for (int i = assetRef.children.Count - 1; i >= 0; i--)
                {
                    GameObject go = assetRef.children[i];
                    if (go==null)
                    {
                        assetRef.children.RemoveAt(i);
                    }
                }

                //如果当前资源没有被任何GameObject所依赖，那么就可以卸载了
                if (assetRef.children.Count==0)
                {
                    assetRef.asset = null;
                    Resources.UnloadUnusedAssets();
                    //对于assetRef所属的bundle 解除关系
                    assetRef.bundleRef.chilren.Remove(assetRef);
                    if (assetRef.bundleRef.chilren.Count==0)
                    {
                        assetRef.bundleRef.bundle.Unload(true);
                    }
                    //对于assetRef所依赖的那些bundle列表，解除关系

                    foreach (BundleRef bundleRef in assetRef.dependencies)
                    {
                        bundleRef.chilren.Remove(assetRef);
                        if (bundleRef.chilren.Count==0)
                        {
                            bundleRef.bundle.Unload(true);
                        }
                    }
                }
            }
        }
    }

    /// <summary>
    /// 工具函数，根据模块名字和bundle名字，返回其实际资源路径
    /// </summary>
    /// <param name="moduleName">模块名字</param>
    /// <param name="bundleName">bundle名字</param>
    /// <returns></returns>
    private string BundlePath(string moduleName,string bundleName) 
    {
        return Application.streamingAssetsPath + "/" + moduleName + "/" + bundleName;
    }
}

2.GameEntry

/****************************************************
    文件：GameEntry.cs
	作者：赵深圳
    邮箱: 1329346609@qq.com
    日期：2022/5/9 10:43:14
	功能：游戏启动入口
*****************************************************/

using UnityEngine;

public class GameEntry : MonoBehaviour 
{
    public static GameEntry Instance;

    private async void Awake()
    {
        InitGlobal();

        //启动模块
        ModuleConfig launchModule = new ModuleConfig
        {
            moduleName="launch",
            moduleVersion="202205091051",
            moduleUrl="127.0.0.1"
        };

        bool result= await ModuleManager.Instance.Load(launchModule);

        if (result)
        {
            Log.ZSZLog(LogCategory.Resource,"Lua 代码开始");
        }
    }

    private void InitGlobal() 
    {
        Instance = this;
        GlobalConfig.HotUpdate = false;
        GlobalConfig.BundleMode = false;
        DontDestroyOnLoad(this.gameObject);
    }

    private void Update()
    {
        AssetLoader.Instance.Unload(AssetLoader.Instance.base2Assets);
    }
}
我是赵某人
关注
专栏目录
AssetLoader：从json文件动态加载资产。 Phaser库
02-04
移相器资产加载器 一个用于从外部json文件加载资产的库。 Phaser开箱即用的工作方式，最终会导致加载状态的行和代码行仅用于将键和资产的路径加载到游戏中。 这是混乱和容易出错的。 您最终可能会得到比这还糟的东西： 使用AssetLoader，这将压缩为仅两行代码： this.game.load.json("assets", "assets.json"); new AssetLoader(this.game, this.game.cache.getJSON("assets")); 所有的调用都为您完成！ 使用AssetLoader的另一个好处是，现在，在哪里可以找到您的资产的详细信息
【Unity】Asset资源加载详解
PA_的博客
09-04 1万+
目录 一、资源加载种类 二、AssetBundle使用 三、大世界实现方案 四、大世界优化 一、资源加载种类 1.Resource.Load() Resource.Load是Unity加载Resources文件夹的加载方式，Resources文件夹会随着打包一起被打到游戏包内。 2.UnityEditor.AssetDatabase.LoadAssetAtPath()...
U3D客户端框架（资源管理篇）之资产加载器 AssetLoaderRoutine
qq_33531923的博客
01-03 461
加载assetbundle内的资源。
AssetLoader，一个使用简单，功能齐全，管理方便的Unity资源管理器。
lwg742216502的专栏
11-25 1258
Github:https://github.com/Enanyy/AssetLoader AssetLoader 一个使用简单，功能齐全，管理方便的Unity资源管理器。 主要特点有 统一接口无论是Resources资源还是Assetbundle资源都使用统一接口加载或卸载。场景的加载和卸载也使用统一接口。 异步加载所有的资源和场景加载方式都是异步加载，并提供回调和加载任...
unity3d 动态加载资源Resources.Load和AssetBundle
Peter的博客
07-31 2291
1.首先总结下unity有哪几种资源类型 unity资源的类型： -a） Unity内置的常用asset, fbx\jpg... - b） textasset: txt、binary等，对应了它的TextAsset类，可以直接读入文本或者二进制byte -c) scriptable object 它是序...
Unity开发-AES加密解密打包加载资源
最新发布
08-18
Unity项目版本：Unity2021.3 项目工程开发时间：2024-8月 1、项目采用AES标准的加密解密方式，可自定义密钥 什么类型的文件都可以加密，不限ab资源，txt，xml，bytes文件等都支持加密； 资源加密，设置不重复加密；...
Unity资源管理类加载AssetBundle
06-09
本篇文章将深入探讨Unity中如何实现一个简单的资源管理类，使用协程加载AssetBundle，并支持优先级队列。 首先，我们需要了解AssetBundle的基本概念。AssetBundle是一个包含Unity资源（如GameObject、Script、...
Unity动态加载外部3D模型的插件TriLib 2.1.6 资源下载
08-15
在具体实现上，开发者可以通过以下...3. 使用`AssetLoader.LoadModelFromFile`类加载本地模型。 4. 设置模型加载完成后执行的回调函数，以便进行进一步处理。 5. 在场景中创建模型实例，并应用必要的动画或物理效果。
Unity动态加载外部3D模型的插件TriLib 2.2.0 资源下载
08-15
在具体实现上，开发者可以通过以下步骤...3. 使用`AssetLoader.LoadModelFromFile`类加载本地模型。 4. 设置模型加载完成后执行的回调函数，以便进行进一步处理。 5. 在场景中创建模型实例，并应用必要的动画或物理效果
unity3d动态加载本地模型
07-07
unity3d中在运行状态下动态加载本地模型，fbx,obj等格式都可以加载。可以直接运行。动态加载本地模型。
AssetLoader.rar
12-11
2020年12月 这，一个简单的资源查找和加载插件 其他Editor扩展插件：https://blog.csdn.net/avi9111/article/details/111012061 ============================ Freatures: *多个文件设置Assetbundle名 *当前所有Assetbundle显示（Editor/） *根据当前设置的平台打包输出(Editor/) *选择目录拖放导入（SceneTester.cs） 只是半成品，还缺：
AssetLoader - 建立高效的游戏资源加载系统
gitblog_00044的博客
03-14 274
AssetLoader - 建立高效的游戏资源加载系统 AssetLoader 是一个用于游戏开发的资源加载库，旨在帮助开发者们构建一个高效的资源管理系统，从而提高游戏性能并降低内存占用。 什么是 AssetLoader？ AssetLoader 是一款开源库，可以帮助你在各种游戏引擎（如 Unity）中实现资源的高效加载和管理。该库不仅支持基本的异步加载机制，还提供了多种高级功能，如预加载、缓存...
Unity3D 重复的使用 AssetBundle.LoadAsset<T>() 同一资源对象，并不会导致性能问题
u012149999的博客
12-25 5688
之前查找网络上一些资料，说是重复的使用 AssetBundle.LoadAsset<T>()来获取资源对象; 虽然不会导致重复的反序列化资源，但是相比于将对象存储在字典中的管理方式，依然会慢上三倍的速度，对此一直比较疑惑，想必Unity官方的内部实现应该也不至于如此不堪，于是做了如下测试，（为了公平起见资源包中仅有一个预制体Cube，字典中也只存有一条内容，这样两种方式查询时的干扰都一...
Unity GameFramwork Asset 加载流程
wentao的专栏
06-30 1034
GameFramwork Asset 加载流程
StreamingAsset文件夹
㊰ ❀ ☀ ☁ ☂ ☃
06-30 2558
Unity中的大部分资源在发布时都被整合到工程中，我们不能访问。但有时我们需要通过路径名访问放在目标设备中的文件。这些文件被存储在目标设备的文件系统中。 在Unity工程中， 放在StreamingAssets文件夹中的任何资源都将被原样复制到目标设备上的一个特定文件夹中。在任何平台中总可以统一使用Application.streamingAssetsPath 属性来获得这一文件夹路径。.
Unity开发——资源加载之3种特殊文件夹及4种路径设置
热门推荐
青岚岁叶的博客
11-12 2万+
摘要： 本文主要讲解Unity开发过程中编辑器下的三种（Assets、Resource、StreamingAssets）特殊文件夹，以及资源存储加载时设置的4种不同路径的讲解说明。 中间简要介绍了什么是AssetBundle资源。 关于数据解析存取，以及资源管理等具体操作，可以参考我的其他文章;
[游戏开发][Unity]Assetbundle加载篇（3）所有资源Loader与ResourceManager源码
liuyongjie1992的博客
06-09 366
[游戏开发][Unity]Assetbundle加载篇（3）所有资源Loader
【Unity】AssetBundle 资源同步加载
weixin_43453797的博客
08-29 955
unity AssetBundle 资源同步加载，封装了一个管理器
AssetBundle系统之（二）加载卸载
东北砍王的栖息地
02-22 398
因为AssetBundle，必须要从指定bundle中加载资源。 如果没有打包，就不能加载。 那么在开发环境中，如果每次添加或者修改资源都需要重新打包，那就很麻烦，怎么解决？ 1.增量打包，且不同的功能拆分成不同AssetBundle，只需打修改的。而且是增量的形式，不需要那么长时间。 2.使用之前生成的自定义依赖关系表，读取资源名对应的资源路径，通过编辑器下的AssetDataBase.Load方法进行加载。 2 的优点：无需每次打包 2 的缺点：可能表现形式不一样，比如说一个面板在editor下加载完成
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值