AssetBundle加载

资源导出

导出AssetBundle资源逻辑

AssetBundle的加载

资源路径示例：Assets/GResources/Prefabs/0 3.prefab

public class AssetBundleManager : MonoBehaviour
{
    private AssetBundleManifest manifest;
    private string mAssetBundlePath { get { return string.Format("{0}/{1}", Application.streamingAssetsPath, platform); } }
    /// <summary>
    /// 已加载的Assetbundle
    /// </summary>
    Dictionary<string, AssetBundle> All_Assetbundle = new Dictionary<string, AssetBundle>();
    /// <summary>
    /// 正在加载的AssetBundle
    /// </summary>
    List<string> AllCurrentAssetBundle = new List<string>();

#if UNITY_STANDALONE_WIN
    private static string platform = "Windows";
#elif UNITY_ANDROID
    private static string platform = "Android";
#elif UNITY_IOS || UNITY_IPHONE
    private static string platform = "IOS";
#else
    private static string platform = "Windows";
#endif

    private void GetManifest()
    {
        string assetbundlepath = $"{mAssetBundlePath}/{platform}";
        AssetBundle assetBundle = AssetBundle.LoadFromFile(assetbundlepath);
        if (assetBundle != null)
        {
            manifest = assetBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }
    }

    #region 异步加载资源

    /// <summary>
    /// 加载资源
    /// </summary>
    /// <param name="varPath"></param>
    /// <param name="Callback"></param>
    public void LoadAssets(string varPath, LoadAssetBundleCallback Callback)
    {
        StartCoroutine(LoadAsyncAssets(varPath, Callback));
    }
    IEnumerator LoadAsyncAssets(string varPath, LoadAssetBundleCallback Callback)
    {
        yield return null;
        string filename = Path.GetFileNameWithoutExtension(varPath);
        string assetbundlename = GetAssetBundleName(varPath);
        AssetBundle assetBundle = null;
        yield return StartCoroutine(LoadAsyncAssetBundle(assetbundlename, (varassetbundle) =>
        {
            assetBundle = varassetbundle;
        }));
        if (assetBundle != null)
        {
            if (assetBundle.Contains(filename))
            {
                UnityEngine.Object assets = assetBundle.LoadAsset(filename);
                Callback.Invoke(varPath, assets, "");
            }
            else
            {
                Callback.Invoke(varPath, null, "资源不存在");
            }
        }
        else
        {
            Callback.Invoke(varPath, null, "资源不存在");
        }
    }

    #endregion

    #region 异步加载场景

    /// <summary>
    /// 加载场景
    /// </summary>
    /// <param name="varPath"></param>
    /// <param name="Callback"></param>
    public void LoadScene(string varPath, LoadAssetBundleCallback Callback)
    {
        StartCoroutine(LoadAsyncScene(varPath, Callback));
    }
    IEnumerator LoadAsyncScene(string varPath, LoadAssetBundleCallback Callback)
    {
        yield return null;
        string filename = Path.GetFileNameWithoutExtension(varPath);
        string assetbundlename = GetAssetBundleName(varPath);
        AssetBundle assetBundle = null;
        yield return StartCoroutine(LoadAsyncAssetBundle(assetbundlename, (varassetbundle) =>
        {
            assetBundle = varassetbundle;
        }));
        if (assetBundle != null)
        {
            Callback.Invoke(varPath, null, "");
        }
        else
        {
            Callback.Invoke(varPath, null, "资源不存在");
        }
    }


    #endregion

    #region 加载逻辑
    
    /// <summary>
    /// 异步加载AssetBundle
    /// </summary>
    /// <param name="varAssetBundleName"></param>
    /// <param name="assetBundleFinish"></param>
    /// <returns></returns>
    IEnumerator LoadAsyncAssetBundle(string varAssetBundleName, LoadAssetBundleFinish assetBundleFinish)
    {
        //确保Key值统一标准
        varAssetBundleName = varAssetBundleName.Replace("\\", "/");

        if (All_Assetbundle.ContainsKey(varAssetBundleName))
        {
            //获取AssetBundle
            AssetBundle assetBundle = All_Assetbundle[varAssetBundleName];
            //完成回调
            assetBundleFinish?.Invoke(assetBundle);
        }
        else if (AllCurrentAssetBundle.Contains(varAssetBundleName))
        {
            while (AllCurrentAssetBundle.Contains(varAssetBundleName))
            {
                yield return null;
            }
            //获取AssetBundle
            AssetBundle assetBundle = All_Assetbundle[varAssetBundleName];
            //完成回调
            assetBundleFinish?.Invoke(assetBundle);
        }
        else
        {
            //添加加载标记
            string assetbundlepath = $"{mAssetBundlePath}/{varAssetBundleName}";

            AllCurrentAssetBundle.Add(varAssetBundleName);
            AssetBundle tempAssetBundle = null;
            AssetBundleCreateRequest tempAssetbundleQuest = AssetBundle.LoadFromFileAsync(assetbundlepath);
            while (!tempAssetbundleQuest.isDone)
            {
                yield return null;
            }
            tempAssetBundle = tempAssetbundleQuest.assetBundle;
            All_Assetbundle.Add(varAssetBundleName, tempAssetBundle);
            //加载依赖
            yield return StartCoroutine(LoadAsyncAssetBundleManifest(tempAssetBundle, varAssetBundleName));
            //完成回调
            assetBundleFinish?.Invoke(tempAssetBundle);
            //移除加载标记
            AllCurrentAssetBundle.Remove(varAssetBundleName);
        }
    }
    /// <summary>
    /// 加载AssetBundle的依赖
    /// </summary>
    /// <param name="assetBundle"></param>
    /// <param name="filename"></param>
    /// <returns></returns>
    IEnumerator LoadAsyncAssetBundleManifest(AssetBundle assetBundle, string filename)
    {
        if (manifest == null)
        {
            GetManifest();
        }
        if (manifest != null)
        {
            string[] Dependencies = manifest.GetDirectDependencies(filename);
            if (Dependencies != null)
            {
                for (int i = 0; i < Dependencies.Length; i++)
                {
                    yield return StartCoroutine(LoadAsyncAssetBundle(Dependencies[i], null));
                }
            }
        }
    }
    /// <summary>
    /// 获取assetbundle名称
    /// </summary>
    /// <param name="varAssetbunlePath"></param>
    /// <returns></returns>
    private string GetAssetBundleName(string varPath)
    {
        string tempPath = Path.GetDirectoryName(varPath).ToLower();
        tempPath = tempPath.Replace("\\", "/");
        string assbundlename = "";
        int index = tempPath.IndexOf("assets/");
        if (index >= 0)
        {
            assbundlename = tempPath.Remove(0, index + 7);

            return $"{assbundlename}.{AssetBundleExtension.Variant}";
        }
        else
        {
            return $"{varPath}.{AssetBundleExtension.Variant}";
        }
    }

    #endregion
}

AssetBundle加载回调

/// <summary>
/// 加载AssetBundle回调
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="varPath"></param>
/// <param name="varObject"></param>
public delegate void LoadAssetBundleCallback(string varPath, UnityEngine.Object varObject, string error);
/// <summary>
/// 加载AssetBundle完成
/// </summary>
/// <param name="asset"></param>
public delegate void LoadAssetBundleFinish(AssetBundle asset);

AssetBundle拓展文件

public class AssetBundleExtension
{
	public const string Variant = "bundle";
}