AssetBundle框架管理

最新推荐文章于 2024-04-15 16:41:53 发布
最新推荐文章于 2024-04-15 16:41:53 发布
阅读量445 收藏 1
点赞数 1
分类专栏： # Asset Bundle 文章标签： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hycai_007/article/details/121502527
版权

AssetBundleMgr AB包使用管理类

其中关联的基类 MonoSingletonBase ：请看 单例模式 https://blog.csdn.net/hycai_007/article/details/121510063

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

public class AssetBundleMgr : MonoSingletonBase<AssetBundleMgr>
{
    /// <summary>
    /// AB包的主包对象
    /// </summary>
    private AssetBundle obj_mainABPack = null;
    /// <summary>
    /// AB包主包的相关依赖信息对象
    /// </summary>
    private AssetBundleManifest obj_mainManifest = null;

    /// <summary>
    /// AB包不能重复加载，重复加载会报错
    /// 用字典的方式来储存，已经加载过的AB包
    /// </summary>
    /// <typeparam name="string"> AB包路径 </typeparam>
    /// <typeparam name="AssetBundle"> AB包对象 </typeparam>
    /// <returns></returns>
    private Dictionary<string, AssetBundle> dict_ABObj = new Dictionary<string, AssetBundle>();

    /// <summary>
    /// AB包存放路径
    /// </summary>
    /// <value></value>
    private string sPathUrl 
    {
        get {
            return Application.streamingAssetsPath + "/";
        }
    }

    /// <summary>
    /// 存放AB包的主文件夹，主包名 
    /// </summary>
    /// <value></value>
    private string sMainABName {
        get {
            #if UNITY_IOS
                return "IOS";
            #elif UNITY_ANDROID
                return "Android";
            #else
                return "PC";
            #endif
        }   
    }

    private AssetBundle LoadPack(string sABName)
    {
        return AssetBundle.LoadFromFile(sPathUrl + sABName);
    }

#region 同时加载AB包与资源
    /// <summary>
    /// 加载某个AB包
    /// </summary>
    /// <param name="sABName"></param>
    public void LoadABPack(string sABName)
    {
        if (obj_mainABPack == null)
        {
            obj_mainABPack = LoadPack(sMainABName);
            obj_mainManifest = obj_mainABPack.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }

        // 加载sABName的所有依赖包
        AssetBundle obj_relyOnAB = null;
        string[] arr_sManifest = obj_mainManifest.GetAllDependencies(sABName);
        for (int i = 0; i < arr_sManifest.Length; i++)
        {
            // 未加载过的才进行加载，已加载的AB包，不能重复加载
            if(!dict_ABObj.ContainsKey(arr_sManifest[i]))
            {
                obj_relyOnAB = LoadPack(arr_sManifest[i]);
                dict_ABObj.Add(arr_sManifest[i], obj_relyOnAB);
            }
        }

        AssetBundle obj_curLoadAB = null;
        if(!dict_ABObj.ContainsKey(sABName))
        {
            obj_curLoadAB = LoadPack(sABName);
            dict_ABObj.Add(sABName, obj_curLoadAB);
        }
    }

    /// <summary>
    /// 同步加载AB包中的资源
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <returns>返回资源对象，GameObject则是实例后的对象，资源一类的则直接返回，注：错误时返回null</returns>
    public Object LoadABPackRes(string sABName, string sResName)
    {
         LoadABPack(sABName);

        if(dict_ABObj.ContainsKey(sABName))
        {
            Object uObj_cur = dict_ABObj[sABName].LoadAsset(sResName);
            if(uObj_cur is GameObject)
            {
                return Instantiate(uObj_cur);
            }
            else
            {
                return uObj_cur;
            }
        }

        return null;
    }

    
    /// <summary>
    /// 同步加载AB包中的资源, 重载增加转换的参数类型
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="eToType">加载后的资源转换成的资源类型</param>
    /// <returns>返回资源对象，GameObject则是实例后的对象，资源一类的则直接返回，注：错误时返回null</returns>
    public Object LoadABPackRes(string sABName, string sResName, System.Type eToType)
    {
        LoadABPack(sABName);

        if(dict_ABObj.ContainsKey(sABName))
        {
            Object uObj_cur = dict_ABObj[sABName].LoadAsset(sResName, eToType);
            if(uObj_cur is GameObject)
            {
                return Instantiate(uObj_cur);
            }
            else
            {
                return uObj_cur;
            }
        }

        return null;
    }

    /// <summary>
    /// 同步加载AB包中的资源，重载的泛型方法
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <returns>返回资源对象，GameObject则是实例后的对象，资源一类的则直接返回，注：错误时返回null</returns>
    public T LoadABPackRes<T>(string sABName, string sResName) where T: Object 
    {
        LoadABPack(sABName);

        if(dict_ABObj.ContainsKey(sABName))
        {
            T obj_cur = dict_ABObj[sABName].LoadAsset<T>(sResName);
            if(obj_cur is GameObject)
            {
                return Instantiate(obj_cur);
            }
            else
            {
                return obj_cur;
            }
        }

        return null;
    }

#endregion

#region 同步加载AB包，异步加载资源
    /// <summary>
    /// 同步加载AB包，异步加载资源
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    public void LoadResAsync(string sABName, string sResName, UnityAction<Object> fun_callback)
    {
        LoadABPack(sABName);
        StartCoroutine(IE_LoadResAsync(sABName, sResName, fun_callback));
    }
    /// <summary>
    /// 异步操作：同步加载AB包，异步加载资源
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    /// <returns></returns>
    private IEnumerator IE_LoadResAsync(string sABName, string sResName, UnityAction<Object> fun_callback)
    {
        if(dict_ABObj.ContainsKey(sABName))
        {
            AssetBundleRequest uObj_cur = dict_ABObj[sABName].LoadAssetAsync(sResName);
            yield return uObj_cur;
            if(uObj_cur.asset is GameObject)
            {
                fun_callback(Instantiate(uObj_cur.asset));
            }
            else
            {
                fun_callback(uObj_cur.asset);
            }
        }
        else
        {
            Debug.LogError("异步加载资源失败，未找到AB包");   
        }
    }

    
    /// <summary>
    /// 同步加载AB包，异步加载资源
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    public void LoadResAsync(string sABName, string sResName, System.Type eToType, UnityAction<Object> fun_callback)
    {
        LoadABPack(sABName);
        StartCoroutine(IE_LoadResAsync(sABName, sResName, eToType, fun_callback));
    }
    /// <summary>
    /// 异步操作：同步加载AB包，异步加载资源
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    /// <returns></returns>
    private IEnumerator IE_LoadResAsync(string sABName, string sResName, System.Type eToType, UnityAction<Object> fun_callback)
    {
        if(dict_ABObj.ContainsKey(sABName))
        {
            AssetBundleRequest uObj_cur = dict_ABObj[sABName].LoadAssetAsync(sResName, eToType);
            yield return uObj_cur;
            if(uObj_cur.asset is GameObject)
            {
                fun_callback(Instantiate(uObj_cur.asset));
            }
            else
            {
                fun_callback(uObj_cur.asset);
            }
        }
        else
        {
            Debug.LogError("异步加载资源失败，未找到AB包");   
        }
    }

    /// <summary>
    /// 同步加载AB包，异步加载资源
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    public void LoadResAsync<T>(string sABName, string sResName, UnityAction<T> fun_callback) where T: Object
    {
        LoadABPack(sABName);
        StartCoroutine(IE_LoadResAsync<T>(sABName, sResName, fun_callback));
    }
    /// <summary>
    /// 异步操作：同步加载AB包，异步加载资源
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    /// <returns></returns>
    private IEnumerator IE_LoadResAsync<T>(string sABName, string sResName, UnityAction<T> fun_callback) where T: Object
    {
        if(dict_ABObj.ContainsKey(sABName))
        {
            AssetBundleRequest uObj_cur = dict_ABObj[sABName].LoadAssetAsync<T>(sResName);
            yield return uObj_cur;
            if(uObj_cur.asset is GameObject)
            {
                fun_callback(Instantiate(uObj_cur.asset) as T);
            }
            else
            {
                fun_callback(uObj_cur.asset as T);
            }
        }
        else
        {
            Debug.LogError("异步加载资源失败，未找到AB包");   
        }
    }
#endregion

#region 异步加载AB包，异步加载资源
    /// <summary>
    /// 异步加载AB包（外部调用接口）
    /// </summary>
    /// <param name="sABName">AB名称</param>
    public void AsyncLoadABPack(string sABName)
    {
        StartCoroutine(IE_AsyncLoadABPack(sABName));
    }

    /// <summary>
    /// 异步加载AB包（类内部调用用接口）
    /// </summary>
    /// <param name="sABName">AB名称</param>
    /// <returns></returns>
    private IEnumerator IE_AsyncLoadABPack(string sABName)
    {
        if (obj_mainABPack == null)
        {
            obj_mainABPack = LoadPack(sMainABName);
            obj_mainManifest = obj_mainABPack.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
            yield return obj_mainManifest;
        }

        // 加载sABName的所有依赖包
        AssetBundle obj_relyOnAB = null;
        string[] arr_sManifest = obj_mainManifest.GetAllDependencies(sABName);
        for (int i = 0; i < arr_sManifest.Length; i++)
        {
            // 未加载过的才进行加载，已加载的AB包，不能重复加载
            if(!dict_ABObj.ContainsKey(arr_sManifest[i]))
            {
                obj_relyOnAB = LoadPack(arr_sManifest[i]);
                dict_ABObj.Add(arr_sManifest[i], obj_relyOnAB);
                yield return obj_relyOnAB;
            }
        }

        AssetBundle obj_curLoadAB = null;
        if(!dict_ABObj.ContainsKey(sABName))
        {
            {
                obj_curLoadAB = LoadPack(sABName);
                dict_ABObj.Add(sABName, obj_curLoadAB);
            }
        }
    }

    /// <summary>
    /// 异步加载AB包与资源，只返回Object，类型外部自己传参（外部调用接口）
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    public void AsyncLoadABPackAndRes(string sABName, string sResName, UnityAction<Object> fun_callback)
    {
        StartCoroutine(IE_AsyncLoadABPackAndRes(sABName, sResName, fun_callback));
    }

    /// <summary>
    /// 异步加载AB包与资源（类内部调用接口）
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    /// <returns></returns>
    private IEnumerator IE_AsyncLoadABPackAndRes(string sABName, string sResName, UnityAction<Object> fun_callback)
    {
        yield return StartCoroutine(IE_AsyncLoadABPack(sABName));
        StartCoroutine(IE_LoadResAsync(sABName, sResName, fun_callback));
    }

    /// <summary>
    /// 异步加载AB包与资源，传资源转换类型（类内部调用接口）
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="eToType">资源转换类型</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    public void AsyncLoadABPackAndRes(string sABName, string sResName, System.Type eToType, UnityAction<Object> fun_callback)
    {
        StartCoroutine(IE_AsyncLoadABPackAndRes(sABName, sResName, eToType, fun_callback));
    }

    /// <summary>
    /// 异步加载AB包与资源（类内部调用接口）
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    /// <returns></returns>
    private IEnumerator IE_AsyncLoadABPackAndRes(string sABName, string sResName, System.Type eToType, UnityAction<Object> fun_callback)
    {
        yield return StartCoroutine(IE_AsyncLoadABPack(sABName));
        StartCoroutine(IE_LoadResAsync(sABName, sResName, eToType, fun_callback));
    }

    /// <summary>
    /// 异步加载AB包与资源，重载使用泛型数据（外部调用接口）
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    /// <typeparam name="T">泛型</typeparam>
    public void AsyncLoadABPackAndRes<T>(string sABName, string sResName, UnityAction<T> fun_callback) where T: Object
    {
        StartCoroutine(IE_AsyncLoadABPackAndRes<T>(sABName, sResName, fun_callback));
    }
    
    /// <summary>
    /// 异步加载AB包与资源，重载使用泛型数据（类内部调用接口）
    /// </summary>
    /// <param name="sABName">AB包的包名</param>
    /// <param name="sResName">AB包的资源名</param>
    /// <param name="fun_callback">异步加载完成后的回调方法</param>
    /// <typeparam name="T">泛型</typeparam>
    /// <returns></returns>
    private IEnumerator IE_AsyncLoadABPackAndRes<T>(string sABName, string sResName, UnityAction<T> fun_callback) where T: Object
    {
        yield return StartCoroutine(IE_AsyncLoadABPack(sABName));
        StartCoroutine(IE_LoadResAsync<T>(sABName, sResName, fun_callback));
    }

#endregion

#region AB包资源卸载
    /// <summary>
    /// 单个AB包卸载
    /// </summary>
    /// <param name="sABName"></param>
    public void UnLoadABPack(string sABName)
    {
        if(dict_ABObj.ContainsKey(sABName))
        {
            dict_ABObj[sABName].Unload(false);
            dict_ABObj.Remove(sABName);
        }
    }

    /// <summary>
    /// 卸载所有的AB包
    /// </summary>
    public void ClearAllABPack()
    {
        AssetBundle.UnloadAllAssetBundles(false);
        obj_mainABPack = null;
        obj_mainManifest = null;

    }
#endregion
}

AssetBundle AB包使用案例

GameObject uObj_cur_01 = AssetBundleMgr.GetInstance().LoadABPackRes("mode/base_mode.ab", "mb") as GameObject;
GameObject uObj_cur_02 = AssetBundleMgr.GetInstance().LoadABPackRes("mode/base_mode.ab", "mb", typeof(GameObject)) as GameObject;
GameObject uObj_cur_03 = AssetBundleMgr.GetInstance().LoadABPackRes<GameObject>("mode/base_mode.ab", "mb");

AssetBundleMgr.GetInstance().LoadResAsync("mode/base_mode.ab", "mb", (uObj_cur) => {
    GameObject uObj_temp = uObj_cur as GameObject;
    Debug.Log(uObj_temp.name);
});
AssetBundleMgr.GetInstance().LoadResAsync("mode/base_mode.ab", "mb", typeof(GameObject), (uObj_cur) => {
    GameObject uObj_temp = uObj_cur as GameObject;
    Debug.Log(uObj_temp.name);
});
AssetBundleMgr.GetInstance().LoadResAsync<GameObject>("mode/base_mode.ab", "mb", (uObj_cur) => {
    GameObject uObj_temp = uObj_cur;
    Debug.Log(uObj_temp.name);
});

UnityAction<Object> fun_temp = new UnityAction<Object>(Handle);
AssetBundleMgr.GetInstance().AsyncLoadABPackAndRes("mode/base_mode.ab", "mb", fun_temp);
AssetBundleMgr.GetInstance().AsyncLoadABPackAndRes("mode/base_mode.ab", "mb", typeof(GameObject), (uObj_cur) => {
    GameObject uObj_temp = uObj_cur as GameObject;
    Debug.Log(uObj_temp.name);
});
AssetBundleMgr.GetInstance().AsyncLoadABPackAndRes<GameObject>("mode/base_mode.ab", "mb", (uObj_cur) => {
    GameObject uObj_temp = uObj_cur;
    Debug.Log(uObj_temp.name);
});
hycai_007
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AssetBundle包框架
hennysky的博客
11-07 597
为啥有AB包? 因为资源需要更新, 避免更新一次打包一次 动态修改. AB包注意啥? 依赖关系 找依赖关系应该找到对应的平台!!! 打包策略是分场景打包 若文件被文件夹包含打包出来的就是文件夹的名字 否则是场景文件夹名称 当我AB包从硬盘加载完成之后 是不是就该加载到内存 并实例化了? 带有缓存的ab加载机制 脚本不允许出现在打包目录的 dll 第一步 先删除之前的包 ...
上线使用的AssetBundle框架
04-04
1.AssetBundle框架设计原理,以及核心设计理念。 2.Untiy编辑器界面全自动化创建AssetBundle与打包理念与代码实现。 3. 关于单一AssetBundle包的综合加载与管理以及相应测试实现。 4.AssetBundle整体管理。 本模块...
AssetBundle框架主流程之MultiABMgr
weixin_41995872的博客
04-11 670
using System.Collections; using System.Collections.Generic; using UnityEngine; public class MultiABMgr { private SingleABLoader _CurrentSingleABLoader; private Dictionary<string, Sing...
unity AssetBundle 框架
11-18
支持AssetBundle自动打包，检测更新，版本管理，资源加载管理器等完成流程
AssetBundle详解
最新发布
XF199710126818的博客
04-15 2046
AssetBundle相关知识整理
极简教程3：Assetbundle的依赖分析与分组打包
千樽江月的博客
03-26 1380
如果你不能用最简单的语言来描述，那你就是没有真正领悟。——爱因斯坦 一、依赖关系概述 我们首先通过三张图来了解一下什么是资源依赖。 图一： 在这张图中，模型A使用了一个材质B，而材质B中又包含了一个贴图C。那么他们的实际依赖关系便是：模型A——》材质B——》贴图C。 换言之，如果我们想在游戏中使用模型A，那么我们必须提前加载材质B。但是如果我们想要使用材质B，那么我们又必须提前加载贴图C。 ...
AssetBundle资源管理
Gyp郭小帅的博客
05-06 259
一、手动起名字打包 1.写插件 2.起名字 3.打包 using System.IO; using UnityEditor;//引入编辑器的命名空间 using UnityEngine; public class BuildAB : Editor //继承编辑器的类 { private static string needBuildAssetsPath = Application.dataPath + "/needBulid"; [MenuItem("MyMenu/BuildAB-W
[Unity]AssetBundle资源管理以及边玩边下解决方案
QF887777的博客
10-06 325
这个事情我一开尝试过去规划前期的资源按目录规划，但是发现由于开发团队人员流动性大，加上除了程序之外其其他人包括美术都很难理解这些东西，所以后来改变思路，就是手动的拆分资源，就是是靠团队去跑游戏，在跑游戏的过程中，记录下所有资源加载过的信息，包括模型、场景、UI等预设，都会调用前期的资源加载统一的接口，生成一份加载过的列表，再根据这份列表信息，去拆分安装包。在打安装包的时候，就是Editor环境下，打完所有资源后，去遍历这个列表，在安装包内留下这份列表的资源以及每个资源的子子孙孙的引用。
AssetBundle框架设计_框架篇视频课程
06-17
 2： 详述AssetBundle框架设计原理图,以及核心设计理念。 3： Untiy编辑器界面全自动化创建AssetBundle与打包理念与代码实现。 4： 关于单一AssetBundle包的综合加载与管理以及相应测试实现。 5： AssetBundle...
AssetBundleFramework-master AssetBundle框架代码
08-18
AssetBundle框架是Unity引擎中一个重要的资源管理工具，它允许开发者高效地管理和加载游戏或应用程序中的资源。AssetBundle框架的核心概念在于将游戏资产（如模型、纹理、音频、动画等）打包成独立的文件，以便在...
AssetBundle简易框架（打包加载）
11-14
AssetBundle是Unity引擎中一种强大的资源...以上就是AssetBundle简易框架的核心内容，通过这个框架，开发者可以构建出高效、灵活的资源管理系统，实现游戏或应用的资源动态加载和更新，从而提升用户体验并优化性能。
Unity AssetBundle Manager 热更新必备工具
08-10
AssetBundle允许从本地或者远程服务器加载Assets资源，利用AssetBundles技术，Assets资源可以放在远程服务器上，这种技术增加了项目灵活性并且减少项目初始包的大小。 本文介绍AssetBundles并且讨论一步一步的介绍怎么样使用它，怎样将资源打包到AssetBundle中，如何使用以及如何处理资源的引用计数，所有这些我们都可以使用AssetBundle Manader来简化AssetBundle构建、测试和发布环节。最后会介绍一个使用AB和Variants实际项目的例子。
AssetBundleManager：此脚本可轻松使用AssetBundle
02-06
AssetBundleManager 初期设定 使用を追加します使用AssetBundleManagerを使用するクラスに。 using KM2; AssetBundleManagerの初期化 AssetBundleManagerを使用する前には必ず初始化メソッドをコールし，初期化を行う必要があります。 AssetBundleManifestとAssetBundleが同じ分段に存在する场合 初始化メソッドの引数に，AssetBundleManifest（AssetBundleビルド时に生成されるプラットフォーム名が付いたファイル）のパスを指定します。 引数にManifestのパスのみを指定
AssetBundle Manager
04-06
AssetBundle Manager Example Scenes.unitypackage
Unity资源管理（AssetBundle加载和卸载）及内存管理（内存的申请和释放）
GarFe的博客
03-29 4866
Instantiate的过程是一个对Assets进行Clone（复制）和引用相结合的过程，Clone的过程需要申请内存存放自己的数据，而引用的过程只需要直接一个简单的指针指向一个已经Load的资源即可。另外需要注意，系统在加载新场景时，所有的内存对象都会被自动销毁，这包括了Resources.Load加载的Assets, 静态绑定的Assets，AssetBundle.Load加载的资源和Instantiate实例化的对象。释放AssetBundle文件本身的内存镜像，但不销毁加载的Asset对象。
AssetBundleMgr
qq_33808037的博客
12-29 271
备注： 当前没有AB包内存清理部分，后续会完善。 加载方式目前比较单一，不包含依赖加载。 using System; using System.Collections.Generic; using System.IO; using UnityEngine; namespace Common { public class AssetBundleMgr { pr...
[游戏开发][Unity]Assetbundle打包与资源加载框架
liuyongjie1992的博客
02-22 2938
[Unity]Assetbundle打包与资源加载框架
资源加载框架之-AssetBundle打包管理
weixin_41316824的博客
10-11 1294
导出的xml文件里里可以直观的看出 Assets/Resources/UI/Prefab/Win/Hero/Win_Hero 文件依赖了imageAB包。容易产生冗余AB包；文件夹或文件等AB包名设置混乱，难以管理。不会生成冗余的AB包，文件AB包名设置简单方便，容易管理。对于新手理解又一定难度。上手简单，方便操作。
U3D客户端框架（资源管理篇）之资源热更新管理器 ResourceManager
qq_33531923的博客
01-07 935
游戏或者软件内的 美术/脚本代码等资源 发生变化时，无需下载客户端重新进行安装，而是在应用程序启动的情况下，通过比对本地资源与CDN资源的MD5码，如果本地资源与CDN中的资源有差异，则优先使用CDN中的资源，以增量的方式进行下载更新这些变化了的 美术/脚本代码等资源。根据经验判断，每次强制用户换包将会造成 5%-15%+ 的用户流失，所以热更新对于商业价值来说是必要的。一个合格的产品采用热更新的方式更新资源是必要的。
unity assetbundle 之 (进阶)简单的实现 assetbundle 框架
06-28
### 回答1： ...综上所述，一个简单的assetbundle框架的实现包括资源打包、加载、动态加载、资源卸载以及异常处理等步骤。这样的实现可以提高游戏的性能和加载速度，减少内存占用，并且便于资源的管理和更新。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值