Unity AB包

加载AB包

• 同步加载

//加载AB包
        //加载AB资源
        //同步加载
        AssetBundle ab = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "model");
        // Image image = ab.LoadAsset<Image>("image");//泛型加载<Image>
        GameObject cube = ab.LoadAsset("Cube", typeof(GameObject)) as GameObject;//由于Lua不支持泛型，故用此种
        Instantiate(cube);//实例化

• 异步加载

   StartCoroutine(LoadAB("img", "返回"));
 IEnumerator LoadAB(string ABName, string resName)
    {
        AssetBundleCreateRequest ab = AssetBundle.LoadFromFileAsync(Application.streamingAssetsPath + "/" + ABName);
        yield return ab;
        AssetBundleRequest abq = ab.assetBundle.LoadAssetAsync(resName, typeof(Sprite));
        yield return abq;
        img.sprite = abq.asset as Sprite;
    }

卸载AB包

 AssetBundle.UnloadAllAssetBundles(false);//只卸载加载的AB包，false场景中的资源不卸载，true场景资源也卸载

  //卸载单个AB包
        ab.Unload(false);

AB包依赖

一个资源身上用到了别的AB包资源，需要把依赖包一起加载。

• 手动添加依赖资源包

AssetBundle ab = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "ui");
AssetBundle ab2 = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "image");
GameObject cube = ab2.LoadAsset("image", typeof(GameObject)) as GameObject;
 Instantiate(cube);//实例化

• 利用主包获取依赖加载

//加载AB包
        AssetBundle ab = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "image");
        //加载主包
        AssetBundle abMain = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "Win");
        //加载主包中的固定文件
        AssetBundleManifest abManifest = abMain.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        //从固定文件中得到依赖信息
        string[] strs = abManifest.GetAllDependencies("image");
        //得到了依赖包名字,并加载
        for (int i = 0; i < strs.Length; i++)
        {
            AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + strs[i]);
        }
        GameObject cube = ab.LoadAsset("image", typeof(GameObject)) as GameObject;
        Instantiate(cube);//实例化

AB包资源管理器

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
/// <summary>
/// AB包管理器
/// </summary>
public class ABManager : SingletonAutoMono<ABManager>//继承单例
{
    //创建字典存储加载过的AB包
    private Dictionary<string, AssetBundle> abDir = new Dictionary<string, AssetBundle>();
    //声名主包
    private AssetBundle mainAB = null;
    //声名依赖包
    private AssetBundleManifest manifest = null;
    /// <summary>
    /// AB包存放路径，方便修改
    /// </summary>
    private string PathUrl
    {
        get
        {
            return Application.streamingAssetsPath + "/";
        }
    }
    /// <summary>
    /// 主包名，根据平台修改
    /// </summary>
    private string MainABName
    {
        get
        {
#if UNITY_IOS
        return "ios";
#elif UNITY_ANDROID
        return "Android";
#else
            return "Win";
#endif
        }
    }
    /// <summary>
    /// 加载AB包
    /// </summary>
    /// <param name="abName">AB包路径</param>
    public void LoabAB(string abName)
    {
        //加载AB包
        if (mainAB == null)
        {
            mainAB = AssetBundle.LoadFromFile(PathUrl + MainABName);
            manifest = mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }
        AssetBundle ab = null;
        //获取依赖包信息
        string[] strs = manifest.GetDirectDependencies(abName);
        for (int i = 0; i < strs.Length; i++)
        {
            //判断包是否加载过
            if (!abDir.ContainsKey(strs[i]))
            {
                ab = AssetBundle.LoadFromFile(PathUrl + strs[i]);
                abDir.Add(strs[i], ab);
            }
        }
        //加载资源来源包,如果没有加载过则加载
        if (!abDir.ContainsKey(abName))
        {
            ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDir.Add(abName, ab);
        }
    }
    /// <summary>
    /// 同步加载,不指定类型:Object obj = ABManager.GetInstance().LoadRes("image", "image");
    /// </summary>
    /// <param name="abName">包路径</param>
    /// <param name="resName">加载的资源名</param>
    public Object LoadRes(string abName, string resName)
    {
        //加载AB包
        LoabAB(abName);
        //加载资源,在加载时直接实例化
        Object obj = abDir[abName].LoadAsset(resName);
        if (obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }
    /// <summary>
    /// 同步加载,根据type指定类型(Lua使用，因为不支持泛型):GameObject obj = ABManager.GetInstance().LoadRes("image", "image", typeof(GameObject)) as GameObject;
    /// </summary>
    /// <param name="abName">包路径</param>
    /// <param name="resName">加载的资源名</param>
    /// <param name="type">资源类型</param>
    public Object LoadRes(string abName, string resName, System.Type type)
    {
        //加载AB包
        LoabAB(abName);
        //加载资源,在加载时直接实例化
        Object obj = abDir[abName].LoadAsset(resName, type);
        if (obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }
    /// <summary>
    /// 同步加载,根据泛型指定类型:GameObject obj = ABManager.GetInstance().LoadRes<GameObject>("image", "image");
    /// </summary>
    /// <typeparam name="T">泛型类型</typeparam>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <returns></returns>
    public T LoadRes<T>(string abName, string resName) where T : Object
    {
        //加载AB包
        LoabAB(abName);
        //加载资源,在加载时直接实例化
        T obj = abDir[abName].LoadAsset<T>(resName);
        if (obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }
    //AB包并没有异步加载，知识加载资源使用异步
    /// <summary>
    /// 根据名字异步加载资源: ABManager.GetInstance().LoadResAsync("image", "image", (obj) => { (obj as GameObject).transform.position = Vector3.zero; });
    /// </summary>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <param name="callBack"></param>
    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包
        LoabAB(abName);
        //加载资源,在加载时直接实例化
        AssetBundleRequest abr = abDir[abName].LoadAssetAsync(resName);
        yield return abr;
        //异步加载结束后通过委托传递给外部使用
        if (abr.asset is GameObject)
            callBack(Instantiate(abr.asset));
        else
            callBack(abr.asset);
    }
    /// <summary>
    ///  根据Type异步加载资源: ABManager.GetInstance().LoadResAsync("image", "image", typeof(GameObject),(obj) => { (obj as GameObject).transform.position = Vector3.zero; });
    /// </summary>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <param name="type"></param>
    /// <param name="callBack"></param>
    public void LoadResAsync(string abName, string resName, System.Type type, UnityAction<Object> callBack)
    {
        StartCoroutine(ReallyLoadResAsync(abName, resName, callBack));
    }
    private IEnumerator ReallyLoadResAsync(string abName, string resName, System.Type type, UnityAction<Object> callBack)
    {
        //加载AB包
        LoabAB(abName);
        //加载资源,在加载时直接实例化
        AssetBundleRequest abr = abDir[abName].LoadAssetAsync(resName, type);
        yield return abr;
        //异步加载结束后通过委托传递给外部使用
        if (abr.asset is GameObject)
            callBack(Instantiate(abr.asset));
        else
            callBack(abr.asset);
    }
    /// <summary>
    /// 根据泛型异步加载: ABManager.GetInstance().LoadResAsync<GameObject>("image", "image", (obj) => { (obj as GameObject).transform.position = Vector3.zero; });
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <param name="callBack"></param>
    public void LoadResAsync<T>(string abName, string resName, UnityAction<Object> callBack) where T : Object
    {
        StartCoroutine(ReallyLoadResAsync(abName, resName, callBack));
    }
    private IEnumerator ReallyLoadResAsync<T>(string abName, string resName, UnityAction<T> callBack) where T : Object
    {
        //加载AB包
        LoabAB(abName);
        //加载资源,在加载时直接实例化
        AssetBundleRequest abr = abDir[abName].LoadAssetAsync<T>(resName);
        yield return abr;
        //异步加载结束后通过委托传递给外部使用
        if (abr.asset is GameObject)
            callBack(Instantiate(abr.asset) as T);
        else
            callBack(abr.asset as T);
    }
    /// <summary>
    /// 单个包卸载
    /// </summary>
    /// <param name="abName">需要卸载的包名</param>
    public void UnLoad(string abName)
    {
        if (abDir.ContainsKey(abName))
        {
            abDir[abName].Unload(false);
            abDir.Remove(abName);
        }
    }
    /// <summary>
    /// 所有包卸载
    /// </summary>
    public void ClearAB()
    {
        AssetBundle.UnloadAllAssetBundles(false);
        abDir.Clear();
        mainAB = null;
        manifest = null;
    }
}