Unity AssetBundle 基础操作

最新推荐文章于 2024-11-11 00:52:40 发布
最新推荐文章于 2024-11-11 00:52:40 发布
阅读量554 收藏 2
点赞数 2
分类专栏： Unity 文章标签： unity3d c# windows 单例模式 unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43925843/article/details/119817409
版权

Unity AssetBundle 基础操作

代码很简单没有难度，都有注解，随便 康一康 就会了。

菜单编辑 按钮点击 构建 AssetBundle 包集

有一点需要注意：CreateAssetBundle_ZH 脚本需要安置在Asset 下 Editor文件夹下
              不然无法正确执行

请添加图片描述

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;

/// <summary>
/// 菜单编辑 按钮点击
/// </summary>


//[CreateAssetMenu(fileName = "Data", menuName = "ScriptableObjects/SpawnManagerScriptableObject", order = 1)]
public class CreateAssetBundle_ZH : MonoBehaviour //ScriptableObject
{
    //菜单栏 Button 创建
    [MenuItem("AssetBundles/Build AssetBundles")]
    static void BuildAllAssetBundles()
    {
        //AssetBundle 存储路径
        string _AssetBundleDirectory = Application.streamingAssetsPath + "//AssetBundles";//Application.dataPath + "/Resources";

        //IO 构建
        if (!Directory.Exists(_AssetBundleDirectory))
        {
            Directory.CreateDirectory(_AssetBundleDirectory);
        }


        //构建编辑中指定的所有资产包 变量（ 构建地址、 资产包构建选项、目标构建平台）//ChunkBasedCompression
        BuildPipeline.BuildAssetBundles(_AssetBundleDirectory, BuildAssetBundleOptions.ChunkBasedCompression, BuildTarget.StandaloneWindows64);

#if UNITY_EDITOR

        //资源刷新
        AssetDatabase.Refresh();

#endif

    }
}


正确放置之后就需要对你要使用的资源进行分包处理了
比如我这个：我对当前 Cube 把它放在了 model 里面这个AB包集里   
		   AB包集名字 是自己取得 如果你没有就自己 New 一个
注意：如果你要使用的资源没有赋予 AB包集的话 是没有办法生成AssetBundle 文件的

请添加图片描述

点击菜单栏 AssetBundles按钮下的Build AssetBundles 按钮就可以生成你自己的AssetBundle文件了

请添加图片描述

AssetBundle 基础功能

AssetBundle 加载：需要注意AB 包加载需要填写对的路径以及包集名字（小写）
						  正确加载 AB 包集后可以使用 LoadAsset() 方法加载当前包集中的具体资源
						  注意拿到具体资源后需要实例化 不然你就只是拿到
						  当前 AB 包集使用完毕之后注意 卸载 不然会报错
						  因为 AB 包的特性就是无法重复加载

 AssetBundle 包集

请添加图片描述

AssetBundle.LoadAsset() 默认返回值是Object 类型

请添加图片描述

这个就是主包中固定文件里的内容：里面包含了各个 AB 包集 的依赖关系

 //主包中固定文件的标准写法
AssetBundleManifest _AssetBundleManifest = _AssetBundleMain.LoadAsset<AssetBundleManifest>("AssetBundleManifest");

请添加图片描述

AssetBundle 没有依赖项 加载

 	/// <summary>
    /// AssetBundle 没有依赖项的加载
    /// </summary>
    public void LoadAssetBundle()
    {
        //AB 包集加载  LoadFromFile方法里面的参数是 指定到文件的详细路径
        AssetBundle _AssetBundle = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/AssetBundles/"+ "model");

         //加载 AssetBundle 包体中的资源
        //使用名字加载 可能会出现同名但是资源类型不同的情况
        //注意加载 资源名称是根据填写的名字  全部都是小写
        //AssetBundle 无法重复加载 否则报空
        //两种加载方式  交易使用第二种 带指定类型的因为可以避免 加载资源时 同名不同类型的文件
        //但是也要看具体情况具体使用  随君意
        GameObject _Gam = _AssetBundle.LoadAsset<GameObject>("SphereModel") ;

        GameObject _Gam02 = _AssetBundle.LoadAsset("CubeModle", typeof(GameObject)) as GameObject;

        //实例化 
        Instantiate(_Gam);
        Instantiate(_Gam02);

        //AB 包集卸载       
        //false 只卸载AB 包集 但是不卸载资源
        //true 卸载AB 包集 同时也卸载资源
        //避免重复加载报空
        _AssetBundle.Unload(false);

    }

AssetBundle 没有依赖项 异步加载

/// <summary>
    /// 异步加载 AssetBundle
    /// </summary>
    /// <param AB包集 名字="_AssetBundleName"></param>
    /// <param AB包集中资源名字="_PrefabName"></param>
    /// <returns></returns>
    public IEnumerator  LoadAssetBundle(string _AssetBundleName,string _PrefabName)
    {
        //加载 AB集
        AssetBundleCreateRequest _AssetBundleCreateRequest = AssetBundle.LoadFromFileAsync(Application.streamingAssetsPath + "/AssetBundles/" + _AssetBundleName);
        //等待返回
        yield return _AssetBundleCreateRequest;

        //资源加载
        AssetBundleRequest _Abr = _AssetBundleCreateRequest.assetBundle.LoadAssetAsync(_PrefabName,typeof(GameObject));

        //默认类型为 Object 所以需要转换一下
        GameObject _Gam = _Abr.asset as GameObject;

        Instantiate(_Gam);

        //卸载所有当前加载的资源包 
        //false 只卸载AB 包集 但是不卸载资源
        //true 卸载AB 包集 同时也卸载资源
        //避免重复加载报空
        AssetBundle.UnloadAllAssetBundles(false);

        yield return null;
    }

AssetBundle 有依赖项 加载

/// <summary>
    /// AB包集 资源依赖
    /// </summary>
    /// <param 主包名字="_AssetBundlesPathName"></param>
    /// <param AB包子集="_AssetBundlesName"></param>
    /// <param 预制体 名字="_PrefabName"></param>
    public void LoadAssetBundleDepend(string _AssetBundlesPathName, string _AssetBundlesName, string _PrefabName)
    {
        //加载主包
        AssetBundle _AssetBundleMain = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/AssetBundles/" + _AssetBundlesPathName);


        //加载主包中的固定文件
        AssetBundleManifest _AssetBundleManifest = _AssetBundleMain.LoadAsset<AssetBundleManifest>("AssetBundleManifest");


        //从固定文件中得到依赖信息
        //得到你想要知道 当前AB包集中的所有依赖
        string[] _DependStr = _AssetBundleManifest.GetAllDependencies(_AssetBundlesName);

        //如果有依赖包的话
        if (_DependStr.Length > 0)
        {

            AssetBundle _NewAssetBundle = null;
            for (int j = 0; j < _DependStr.Length; j++)
            {
                //依赖包加载
                _NewAssetBundle = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/AssetBundles/" + _DependStr[j]);
            }

            //如果 AB 包集不为空
            if (_NewAssetBundle != null)
            {
                //AB包 子级资源加载
                AssetBundle _NewAssetBundleSubset;
                _NewAssetBundleSubset = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/AssetBundles/" + _AssetBundlesName);

                //GameObject _Gam = _NewAssetBundleSubset.LoadAsset<GameObject>(_PrefabName);
                GameObject _Gam = _NewAssetBundleSubset.LoadAsset(_PrefabName, typeof(GameObject)) as GameObject;

                Instantiate(_Gam);
            }
        }
        else
        {
            //如果没有依赖包就正常加载
            AssetBundle _NewAssetBundleSubset;
            _NewAssetBundleSubset = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/AssetBundles/" + _AssetBundlesName);

            //资源加载
            //GameObject _Gam = _NewAssetBundleSubset.LoadAsset<GameObject>(_PrefabName);
            GameObject _Gam = _NewAssetBundleSubset.LoadAsset(_PrefabName, typeof(GameObject)) as GameObject;

            Instantiate(_Gam);
        }
    }

AssetBundle 卸载


		//两种方法

        //AB 当前包集卸载       
        //false 只卸载当前AB 包集 但是不卸载资源
        //true 卸载当前AB 包集 同时也卸载资源
        //_AssetBundle 是当前加载的 AB 包集
        _AssetBundle.Unload(false);
   
        //卸载所有当前加载的资源包 
        //false 只卸载所有AB 包集 但是不卸载资源
        //true 卸载所有AB 包集 同时也卸载资源
        AssetBundle.UnloadAllAssetBundles(false);

AssetBundle 包管理器


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

/// <summary>
/// AssetBundle 包管理器
/// </summary>
public class AssetBundleManager_ZH : MonoBehaviour
{

    //单例
    public static AssetBundleManager_ZH _AssetBundleManager;

    //AssetBundle 主包
    private AssetBundle _AssetBundleMain = null;

    //依赖包配置文件
    private AssetBundleManifest _AssetBundleManifest = null;



    //AB包集字典 存储已经加载的AB包
    //key AB 包名字 value AB包
    private Dictionary<string, AssetBundle> _AssetBundleDic = new Dictionary<string, AssetBundle>();

    /// <summary>
    /// AssetBundle主包 加载路径
    /// </summary>
    public string _AssetBundlePath 
    { 
        get
        {
           return Application.streamingAssetsPath + "/AssetBundles/";
        }
        set 
        {
            _AssetBundlePath = value;
        } 
    }

    /// <summary>
    /// 主包名
    /// </summary>
    public string _AssetBundleMainName
    {
        get
        {
            return "AssetBundles";
        }
        set
        {
            _AssetBundleMainName = value;
        }
    }

   private void Awake()
    {
        _AssetBundleManager = this;
    }


    #region AssetBundle 资源同步加载

    /// <summary>
    /// 同步加载 不指定类型
    /// </summary>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <returns></returns>
    public Object LoadAssetBundleSync(string _AssetBundleName, string _ResName)
    {

        LoadAB(_AssetBundleName);

        Object _AssetBundleObject = _AssetBundleDic[_AssetBundleName].LoadAsset(_ResName);

        //实例化
        if (_AssetBundleObject as GameObject)
        {
            return Instantiate(_AssetBundleObject);
        }
        else
        {
            //加载 当前 使用资源 AB 包（_AssetBundleName）名为  _ResName 的资源
            return _AssetBundleObject;
        }
    }


    /// <summary>
    /// 同步加载 指定类型
    /// 方便加载资源时 同名不同类型的文件
    /// </summary>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <param 指定的类型="_Type"></param>
    /// <returns></returns>
    public Object LoadAssetBundleSync(string _AssetBundleName, string _ResName, System.Type _Type)
    {
        LoadAB(_AssetBundleName);

        Object _AssetBundleObject = _AssetBundleDic[_AssetBundleName].LoadAsset(_ResName, _Type);

        //实例化
        if (_AssetBundleObject as GameObject)
        {
            return Instantiate(_AssetBundleObject);
        }
        else
        {
            //加载 当前 使用资源 AB 包（_AssetBundleName）名为  _ResName 的资源
            return _AssetBundleObject;
        }
    }


    /// <summary>
    /// 同步加载 不指定类型 泛型加载
    /// 方便加载资源时 同名不同类型的文件
    /// </summary>
    /// <typeparam 返回类型="T"></typeparam>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <returns></returns>
    public T LoadAssetBundleSync<T>(string _AssetBundleName, string _ResName) where T : Object
    {
        LoadAB(_AssetBundleName);

        T _AssetBundleObject = _AssetBundleDic[_AssetBundleName].LoadAsset<T>(_ResName);

        //实例化
        if (_AssetBundleObject as GameObject)
        {
            return Instantiate(_AssetBundleObject);
        }
        else
        {
            //加载 当前 使用资源 AB 包（_AssetBundleName）名为  _ResName 的资源
            return _AssetBundleObject;
        }
    }

    #endregion



    #region AssetBundle 资源异步加载

    /// <summary>
    /// 根据名字异步加载资源
    /// </summary>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <param 委托="_CallBack"></param>
    public void LoadResAsync(string _AssetBundleName, string _ResName,UnityAction<Object> _CallBack)
    {
        StartCoroutine(ReallyLoadResAsync(_AssetBundleName, _ResName, _CallBack));
    }
    /// <summary>
    ///异步资源加载
    /// </summary>
    /// <param  需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <param 委托="_CallBack"></param>
    private IEnumerator ReallyLoadResAsync(string _AssetBundleName, string _ResName, UnityAction<Object> _CallBack)
    {
        LoadAB(_AssetBundleName);

        AssetBundleRequest _ABR  = _AssetBundleDic[_AssetBundleName].LoadAssetAsync(_ResName);


        yield return _ABR;


        //异步加载结束后 通过委托 传递资源给外部
        //实例化
        if (_ABR.asset as GameObject)
        {
            _CallBack(Instantiate(_ABR.asset));
        }
        else
        {
            //加载 当前 使用资源 AB 包（_AssetBundleName）名为  _ResName 的资源
            _CallBack(_ABR.asset);
        }
    }



    /// <summary>
    /// 异步加载 指定类型
    /// 方便加载资源时 同名不同类型的文件
    /// </summary>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <param 指定的类型="_Type"></param>
    /// <param 委托="_CallBack"></param>
    public void LoadResAsync(string _AssetBundleName, string _ResName, System.Type _Type,UnityAction<Object> _CallBack)
    {
        StartCoroutine(ReallyLoadResAsync(_AssetBundleName, _ResName, _Type, _CallBack));
    }
    /// <summary>
    /// 异步资源加载 指定类型
    /// </summary>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <param 指定的类型="_Type"></param>
    /// <param 委托="_CallBack"></param>
    private IEnumerator ReallyLoadResAsync(string _AssetBundleName, string _ResName, System.Type _Type, UnityAction<Object> _CallBack)
    {
        LoadAB(_AssetBundleName);

        AssetBundleRequest _ABR = _AssetBundleDic[_AssetBundleName].LoadAssetAsync(_ResName, _Type);


        yield return _ABR;


        //异步加载结束后 通过委托 传递资源给外部
        //实例化
        if (_ABR.asset as GameObject)
        {
            _CallBack(Instantiate(_ABR.asset));
        }
        else
        {
            //加载 当前 使用资源 AB 包（_AssetBundleName）名为  _ResName 的资源
            _CallBack(_ABR.asset);
        }
    }


    /// <summary>
    /// 异步加载 不指定类型 泛型加载
    /// 方便加载资源时 同名不同类型的文件
    /// </summary>
    /// <typeparam 返回类型="T"></typeparam>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <returns></returns>
    public void LoadResAsync<T>(string _AssetBundleName, string _ResName, UnityAction<T> _CallBack)where T:Object
    {
        StartCoroutine(ReallyLoadResAsync<T>(_AssetBundleName, _ResName, _CallBack));
    }
    /// <summary>
    /// 异步加载 不指定类型 泛型加载
    /// 方便加载资源时 同名不同类型的文件
    /// </summary>
    /// <typeparam 返回类型="T"></typeparam>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    /// <param 需要加载的资源名字="_ResName"></param>
    /// <returns></returns>
    private IEnumerator ReallyLoadResAsync<T>(string _AssetBundleName, string _ResName, UnityAction<T> _CallBack) where T : Object
    {
        LoadAB(_AssetBundleName);

        AssetBundleRequest _ABR = _AssetBundleDic[_AssetBundleName].LoadAssetAsync(_ResName);


        yield return _ABR;


        //异步加载结束后 通过委托 传递资源给外部
        //实例化
        if (_ABR.asset as GameObject)
        {
            _CallBack(Instantiate(_ABR.asset)as T);
        }
        else
        {
            //加载 当前 使用资源 AB 包（_AssetBundleName）名为  _ResName 的资源
            _CallBack(_ABR.asset as T);
        }
    }

    #endregion



    /// <summary>
    /// 主包以及依赖包加载
    /// </summary>
    /// <param 需要加载的AB 包名字="_AssetBundleName"></param>
    public void LoadAB(string _AssetBundleName)
    {
        //AssetBundle 主包加载
        if (_AssetBundleMain == null)
        {
            _AssetBundleMain = AssetBundle.LoadFromFile(_AssetBundlePath + _AssetBundleMainName);

            //依赖包加载
            _AssetBundleManifest = _AssetBundleMain.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }

        //从固定文件中得到依赖信息
        //得到你想要知道 当前AB包集中的所有依赖
        string[] _DependStr = _AssetBundleManifest.GetAllDependencies(_AssetBundleName);


        //如果有依赖包的话
        if (_DependStr.Length > 0)
        {
            //资源 AB 包
            AssetBundle _NewAssetBundleSubset;

            for (int i = 0; i < _DependStr.Length; i++)
            {
                //判断 AB 包是否加载过
                //如果没有加载过
                if (!_AssetBundleDic.ContainsKey(_DependStr[i]))
                {
                    //依赖包加载
                    _NewAssetBundleSubset = AssetBundle.LoadFromFile(_AssetBundlePath + _DependStr[i]);

                    //AB包 字典数据存储
                    _AssetBundleDic.Add(_DependStr[i], _NewAssetBundleSubset);
                }
            }

            //判断 AB 包是否加载过
            //如果没有加载过
            if (!_AssetBundleDic.ContainsKey(_AssetBundleName))
            {
                //使用资源 AB 包加载 并进行重新赋值
                _NewAssetBundleSubset = AssetBundle.LoadFromFile(_AssetBundlePath + _AssetBundleName);

                //AB包 字典数据存储
                _AssetBundleDic.Add(_AssetBundleName, _NewAssetBundleSubset);
            }
        }
    }


    /// <summary>
    /// 单个 AssetBundle 包 卸载
    /// </summary>
    /// <param name="_AssetBundleName"></param>
    public void UnLoadAssetBuindle(string _AssetBundleName)
    {
        //判断当前 AB包数据 字典是否存在 当前AB 包资源
        if (_AssetBundleDic.ContainsKey(_AssetBundleName))
        {
            //AB 包集卸载       
            //false 只卸载AB 包集 但是不卸载资源
            //true 卸载AB 包集 同时也卸载资源
            //避免重复加载报空
            _AssetBundleDic[_AssetBundleName].Unload(false);

            //移除 AB数据字典
            _AssetBundleDic.Remove(_AssetBundleName);
        }
    }

    /// <summary>
    ///  所有 AssetBundle 包 卸载
    /// </summary>
    /// <param name="_AssetBundleName"></param>
    public void UnLoadAllAssetBuindles()
    {
        //卸载所有当前加载的资源包 
        //false 只卸载AB 包集 但是不卸载资源
        //true 卸载AB 包集 同时也卸载资源
        //避免重复加载报空
        AssetBundle.UnloadAllAssetBundles(false);

        //AB数据字典 清空
        _AssetBundleDic.Clear();

        //AssetBundle 主包
        _AssetBundleMain = null;

        //依赖包配置文件
        _AssetBundleManifest = null;

        //AssetBundle主包 加载路径
        _AssetBundlePath = null;

        //主包名
        _AssetBundleMainName = null;
    }



    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Q))
        {
            //同步加载 不指定类型加载
            LoadAssetBundleSync("model", "CubeModle");
            //同步加载 指定类型加载
            LoadAssetBundleSync("model", "SphereModel",typeof(GameObject));
            //同步加载 不指定类型 泛型加载
            LoadAssetBundleSync<GameObject>("model", "CylinderModle");
        }

        if (Input.GetKeyDown(KeyCode.E))
        {
            //同步加载 不指定类型加载
            LoadResAsync("model", "CubeModle",(_Obj=> 
            {
                (_Obj as GameObject).transform.position = new Vector3((_Obj as GameObject).transform.position.x, 3, (_Obj as GameObject).transform.position.z);
            }));
            //同步加载 指定类型加载
            //同步加载 不指定类型加载
            LoadResAsync("model", "SphereModel",typeof(GameObject), (_Obj =>
            {
                (_Obj as GameObject).transform.position = new Vector3((_Obj as GameObject).transform.position.x, 3, (_Obj as GameObject).transform.position.z);
            }));
            //同步加载 不指定类型 泛型加载
            //同步加载 不指定类型加载
            LoadResAsync<GameObject>("model", "CylinderModle", (_Obj =>
            {
                _Obj .transform.position = new Vector3(_Obj.transform.position.x, 3, _Obj.transform.position.z);
            }));
        }
    }
}

搭载运行

脚本搭载

请添加图片描述

基础运行
点击两次也不会报错说明运行良好可以直接使用

请添加图片描述

请添加图片描述

暂时先这样吧，如果有时间的话就会更新，实在看不明白就留言，看到我会回复的。
路漫漫其修远兮，与君共勉。

详解u3d之AssetBundle
ellis1970的博客
01-30 722
详解u3d之AssetBundle
unity3d 加密AssetBundle包
09-22
这个`byte[]`数组就是后续解密操作的基础。 3. **解密处理：** 在获得加密文件的二进制数据后，需要对其进行解密。这里的具体解密算法取决于之前加密AssetBundle时所采用的方法。例如，如果使用AES进行加密，则...
AssetBundle中加载资源的三种方式
u012149999的博客
01-20 3041
AssetBundle中加载资源的三种方式
Unity中的AssetBundle
qq_41841073的博客
11-06 5005
Unity中的AssetBundle系统是对资源管理的一种扩展，通过将资源分布在不同的AB包中可以最大程度地减少运行时的内存压力，可以动态地加载和卸载AB包，继而有选择地加载内容。
Unity的AssetBundle使用总结
阿赵的博客
12-20 5096
Unity的AssetBundle使用总结一、AssetBundle的压缩方式对比二、AssetBundle的依赖拆分策略三、AssetBundle的卸载策略 AssetBundle作为Unity引擎的资源加载管理和热更新手段，在各大项目内普遍的使用着。AssetBundle使用方式简单，只要设置AssetBundleName，然后打包出文件，在运行过程中加载就可以使用，但很多细节上的问题，会影响...
Unity中AssetBundle的变体（Varient）使用教程
qq_41841073的博客
11-06 3529
在使用Unity的AssetBundle过程中，选中资源物体之后，发现右下角的AssetBundle面板，除了有一个命名标签外，还有一个Varient标签，这边文章主要介绍下这个标签的用法
[Unity基础]打包与读取AssetBundle
宏哥的博客
05-31 3492
原文链接：http://www.xuanyusong.com/archives/2405 1.打包prefab using UnityEngine; using System.Collections; using UnityEditor; //选择的物体放在不同的AB public class CreateAB_Respectively : MonoBehaviour {
unity3d assetbundle check editor for win.zip
02-22
Unity3D AssetBundle Check Editor for Win 是一个专为Windows用户设计的工具，旨在帮助开发者和游戏设计师更好地管理和检查Unity3D中的AssetBundle资源。AssetBundle是Unity3D引擎提供的一种强大的资源管理机制，...
Unity资源管理类加载AssetBundle
06-09
Unity引擎在游戏开发中提供了强大的资源管理功能，AssetBundle就是其中一种关键的资源打包和加载机制。AssetBundle允许开发者将游戏资源（如模型、纹理、音频等）预先打包成独立的文件，在运行时按需加载，以降低...
unity-AssetBundle使用例程
09-06
1. **AssetBundle的基本概念**： AssetBundle是Unity引擎中的一个资源容器，它可以包含各种游戏对象，如纹理、模型、音频文件、脚本等。每个AssetBundle都有一个唯一的名称，便于在运行时进行查找和加载。 2. **...
Unity5 新的AssetBundle官方例子
09-24
Unity5的AssetBundle系统是游戏开发中的一个重要工具，它允许开发者将游戏资源（如...通过这个官方示例，开发者可以学习到AssetBundle的核心概念，提高游戏性能，优化用户体验，并为未来更复杂的游戏开发打下坚实基础。
loadasset一个简单的基于Promise的资产加载器
08-12
一个简单的基于Promise的资产加载器，支持IE 11以下的跨浏览器。非常适合与async / await语法一起使用。 尽可能使用fetch，否则用XMLHTTPRequest代替。
Unity打AssetBundle包
MMMeKey博客园
09-05 2328
1、首先说一下 Unity打AssetBundle包不需要任何插件，Unity带了很完整的关于打AssetBundle的API。 2、首先创建一个Unity项目，之后创建四个文件夹（Editor 和StreamingAssets 这两个文件夹是必须的） 3、创建一个脚本 （脚本名：CreateAssetBundle），这个脚本不用继承MonoBehaviour,要引入UnityEdio...
Unity2021 AssetBundle资源打包
weixin_39805744的博客
12-13 1535
Unity2021 AssetBundle资源打包 AssetBundle是一种动态地资源加载方式。如果一次性地把资源导到游戏里，会使得游戏过大。可以把一些资源（例如：预制体、image、材质、music）与游戏主体分离，然后把这些分离的资源放到服务器上。当游戏需要该资源的时候就从服务器加载该资源，从而实现了资源的动态更新。 1. 打包的主要步骤 设置打包的对象 生成AssetBundle 上传到服务器 下载AssetBundle 加载对象 使用对象 2.设置打包对象 首先
Unity 热更新 之 一篇文章完全入门AssetBundle
最新发布
咩咩的博客
11-11 1969
本篇知识来源于unity官方手册以及siki学院的相关教程,链接如下,仅作学习分享。
Unity AssetBundle详解，加载本地包、加载网络包代码全分享
u014196765的博客
03-01 1784
在Unity中，AssetBundle（简称AB包）是一种将多个文件或资源打包到一个文件中的方式，用于优化资源的加载和管理。使用AB包，可以按需加载资源，减少应用的初始加载时间，并可以实现热更新等功能。下面是一个基本的流程，展示如何在Unity中加载AB包并显示其中的资源。
Unity中使用AssetBundle打包与加载的注意事项
虚粒世界
03-11 3349
Unity中使用AssetBundle打包与加载的注意事项
Unity资源管理——AssetBundle构建/打包
NRatel的博客
12-10 6249
1、为资源设置 assetBundleName 和assetBundleVariant。 可以在资源的 Inspector 上手动设置，也可以通过 AssetImporter 进行设置。 AssetImporter importer = AssetImporter.GetAtPath(assetPath); importer.assetBundleName = abName; im...
Unity3D 重复的使用 AssetBundle.LoadAsset<T>() 同一资源对象，并不会导致性能问题
u012149999的博客
12-25 5840
之前查找网络上一些资料，说是重复的使用 AssetBundle.LoadAsset<T>()来获取资源对象; 虽然不会导致重复的反序列化资源，但是相比于将对象存储在字典中的管理方式，依然会慢上三倍的速度，对此一直比较疑惑，想必Unity官方的内部实现应该也不至于如此不堪，于是做了如下测试，（为了公平起见资源包中仅有一个预制体Cube，字典中也只存有一条内容，这样两种方式查询时的干扰都一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Maddie_Mo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值