AssetBundle基础

AB包是什么

1. AssetBundle(简称AB包)是一个资源压缩包，包含模型、贴图、预制体、声音、甚至整个场景，可以在游戏运行的时候被加载;

AB包作用

1.

生成AB包资源文件

1.Unity编辑器开发，自定义打包工具

2.官方提供好的打包工具:Asset Bundle Browser

3.AssetBundleBrowser参数相关
4.AB包生成的文件

C# 不能被打包 所以要lua

打包的脚本 是关联的数据而不是C#代码

打包不同平台要重新打包

AB包资源加载/卸载

    public Image img;
    // Start is called before the first frame update
    void Start()
    {
        //加载AB包
        AssetBundle ab = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "model");

public Image img;
    // Start is called before the first frame update
    void Start()
    {
        //加载AB包
        AssetBundle ab = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "model");
        //加载AB包中的资源
        //只使用名字加载 会出现 同名不同类型资源 分不清】
        //建议大家用 泛型加载 或 Type指定类型
        //GameObject obj = ab.LoadAsset<GameObject>("Cube");
        GameObject obj = ab.LoadAsset("Cube", typeof(GameObject)) as GameObject;
        Instantiate(obj);

        //卸载所有加载的AB包 参数为true 会把通过ab包加载的资源也删除
        //AssetBundle.UnloadAllAssetBundles(false);

        //卸载单个资源，参数同上
        ab.Unload(true);

        //AB包 不能重复加载 否则报错

        //加载一个圆
        GameObject obj2 = ab.LoadAsset("Sphere", typeof(GameObject)) as GameObject;
        Instantiate(obj2);

        //异步加载 -> 协程
        StartCoroutine(LoadABRes("ABName", "resName"));

    }
    IEnumerator LoadABRes(string ABName, string resName)
    {
        //加载AB包
        AssetBundleCreateRequest abcr = AssetBundle.LoadFromFileAsync(Application.streamingAssetsPath + "/" + ABName);
        yield return abcr;
        //加载资源
        AssetBundleRequest abq = abcr.assetBundle.LoadAssetAsync(resName,typeof(Sprite));
        yield return abq;

        //要创建对象来测试
        //img.sprite = abq.asset as Sprite;
    }

AB包依赖

        //关于AB包的依赖-- 一个资源身上用到别的AB包的资源，这个时候只加载自己的AB包
        //通过它创建对象 会出现资源丢失
        //这种时候 需要把依赖包 一起加在了 才能正常

        //加载AB包
        AssetBundle ab = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "model");
        //加载依赖包
        //AssetBundle ab2 = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "head");

关于主包

        //关于AB包的依赖-- 一个资源身上用到别的AB包的资源，这个时候只加载自己的AB包
        //通过它创建对象 会出现资源丢失
        //这种时候 需要把依赖包 一起加在了 才能正常

        //加载AB包
        AssetBundle ab = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "model");
        //加载依赖包
        //AssetBundle ab2 = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "head");

        //依赖包的关键知识点一 利用主包 获取依赖信息
        //加载主包
        AssetBundle abMain = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "PC");
        //加载主包中的固定文件
        AssetBundleManifest abManifest = abMain.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        //从固定文件中获得以来信息
        string[] strs = abManifest.GetAllDependencies("model");
        //得到 依赖包的名字
        for (int i = 0; i < strs.Length; i++)
        {
            AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + strs[i]);
        }

缺点

这个方法有小缺点
只能找到这个"包"依赖了哪些包，包中的所有资源都会参与寻找
而不是找到某个特定"资源"依赖了哪些包

AB包资源管理器同步加载

加载

ABManager

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 知识点
/// 1.AB包相关的API
/// 2.单例模式
/// 3.委托-> Lambda表达式
/// 4.协程
/// 5.字典
/// </summary>
public class ABManager : SingletonAutoMono<ABManager>
{
    //AB包管理器 目的是
    //让外部更方便的进行资源加载

    //主包
    private AssetBundle mainAB = null;
    //依赖包获取用的配置文件
    private AssetBundleManifest manifest = null;

    //AB包不能重复加载 重复加载会报错
    //用字典 存储 加载过的AB包
    private Dictionary<string,AssetBundle> abDic = new Dictionary<string,AssetBundle>();
    /// <summary>
    /// 这个AB包存放路径 方便修改
    /// </summary>
    private string PathUrl
    {
        get
        {
            return Application.streamingAssetsPath + "/";
        }
    }
    //同步加载

    private string MainABName
    {
        get
        {
#if UNITY_IOS
            return "IOS";
#elif UNITY_ANDROID
            return "Android";
#else
            return "PC";
#endif

        }
    }
    public Object LoadRes(string abName, string resName)
    {
        //加载AB包
        if(mainAB == null)
        {
            mainAB = AssetBundle.LoadFromFile(PathUrl + MainABName);
            manifest = mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }
        //我们获取依赖包相关信息
        AssetBundle ab = null;
        string[] strs = manifest.GetAllDependencies(abName);
        for(int i = 0; i < strs.Length; i++)
        {
            //判断包是否加载过
            if (!abDic.ContainsKey(strs[i]))
            {
                ab = AssetBundle.LoadFromFile(PathUrl + strs[i]);
                abDic.Add(strs[i], ab);
            }
        }
        //加载资源来源包
        //如果没有加载过 再加载
        if (!abDic.ContainsKey(abName))
        {
            ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDic.Add(abName, ab);
        }
        //加载资源 判断资源是不是GameObject
        //如果是 直接实例化返回给外部
        Object obj = abDic[abName].LoadAsset(resName);
        if(obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }
}

为了重载，且重载过程中有重复代码，因此修改，添加LoadAB用来加载资源包

    /// <summary>
    /// 加载AB包
    /// </summary>
    /// <param name="abName"></param>
    public void LoadAB(string abName)
    {
        //加载AB包
        if (mainAB == null)
        {
            mainAB = AssetBundle.LoadFromFile(PathUrl + MainABName);
            manifest = mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }
        //我们获取依赖包相关信息
        AssetBundle ab = null;
        string[] strs = manifest.GetAllDependencies(abName);
        for (int i = 0; i < strs.Length; i++)
        {
            //判断包是否加载过
            if (!abDic.ContainsKey(strs[i]))
            {
                ab = AssetBundle.LoadFromFile(PathUrl + strs[i]);
                abDic.Add(strs[i], ab);
            }
        }
        //加载资源来源包
        //如果没有加载过 再加载
        if (!abDic.ContainsKey(abName))
        {
            ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDic.Add(abName, ab);
        }
    }

修改过后

 public Object LoadRes(string abName, string resName)
    {
        //加载AB包
        LoadAB(abName);
        //加载资源 判断资源是不是GameObject
        //如果是 直接实例化返回给外部
        Object obj = abDic[abName].LoadAsset(resName);
        if(obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }

    //同步加载根据type指定类型
    public Object LoadRes(string abName, string resName,System.Type type)
    {
        //加载AB包
        LoadAB(abName);
        //加载资源 判断资源是不是GameObject
        //如果是 直接实例化返回给外部
        //这样支持指定类型，因为lua不支持泛型，所以要这样重载
        Object obj = abDic[abName].LoadAsset(resName,type);
        if (obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }

    //同步加载根据泛型指定类型
    public T LoadRes<T>(string abName, string resName) where T : Object
    {
        //加载AB包
        LoadAB(abName);
        //加载资源 判断资源是不是GameObject
        //如果是 直接实例化返回给外部
        T obj = abDic[abName].LoadAsset<T>(resName);
        if (obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }

单个包卸载

    public void UnLoad(string abName)
    {
        if (abDic.ContainsKey(abName))
        {
            abDic[abName].Unload(false);
            abDic.Remove(abName);
        }
    }

所有包卸载

    //所有包卸载
    public void ClearAB()
    {
        AssetBundle.UnloadAllAssetBundles(false);
        abDic.Clear();
        mainAB = null;
        manifest = null;
    }

AB包资源管理器异步加载

    //异步加载方法
    //这里的异步加载 AB包并没有使用异步加载
    //只是从AB包中 加载资源时 使用异步
    //异步加载没办法马上得到资源使用，因此用委托
    public void LoadResAsync(string abName,string resName, UnityAction<Object> callBack)
    {
        StartCoroutine(ReallyLoadResAsync(abName, resName, callBack));
    }

    //根据名字异步加载资源
    private IEnumerator ReallyLoadResAsync(string abName, string resName, UnityAction<Object> callBack)
    {
        //加载AB包
        LoadAB(abName);
        //加载资源 判断资源是不是GameObject
        //如果是 直接实例化返回给外部
        AssetBundleRequest abr = abDic[abName].LoadAssetAsync(resName);
        yield return abr;

        //异步加载结束后 通过委托 传递给外部 外部来使用
        if (abr.asset is GameObject)
            callBack(Instantiate(abr.asset));
        else
            callBack(abr.asset);
    }

    public void LoadResAsync(string abName, string resName, System.Type type,UnityAction<Object> callBack)
    {
        StartCoroutine(ReallyLoadResAsync(abName, resName, type, callBack));
    }
    //根据Type异步加载资源
    private IEnumerator ReallyLoadResAsync(string abName, string resName, System.Type type, UnityAction<Object> callBack)
    {
        //加载AB包
        LoadAB(abName);
        //加载资源 判断资源是不是GameObject
        //如果是 直接实例化返回给外部
        AssetBundleRequest abr = abDic[abName].LoadAssetAsync(resName,type);
        yield return abr;

        //异步加载结束后 通过委托 传递给外部 外部来使用
        if (abr.asset is GameObject)
            callBack(Instantiate(abr.asset));
        else
            callBack(abr.asset);
    }

    public void LoadResAsync<T>(string abName, string resName, UnityAction<T> callBack) where T : Object
    {
        StartCoroutine(ReallyLoadResAsync<T>(abName, resName, callBack));
    }
    //根据泛型异步加载
    private IEnumerator ReallyLoadResAsync<T>(string abName, string resName, UnityAction<T> callBack) where T : Object
    {
        //加载AB包
        LoadAB(abName);
        //加载资源 判断资源是不是GameObject
        //如果是 直接实例化返回给外部
        AssetBundleRequest abr = abDic[abName].LoadAssetAsync<T>(resName);
        yield return abr;

        //异步加载结束后 通过委托 传递给外部 外部来使用
        if (abr.asset is GameObject)
            callBack(Instantiate(abr.asset) as T);
        else
            callBack(abr.asset as T);
    }