Unity5系列资源管理AssetBundle——加载

上次我们进行了AssetBundle打包，现在我们还把打包的资源加载到我们的游戏中。
在加载之前，我们需要把打包好的Bundle包裹放到服务器上，如果没有，也可以使用XAMPP搭建本地服务器。

加载的AssetBundle文件是放在内存中的，所以如果没有很好的管理，会使游戏性能大打折扣，因此，我们在这里最好使用缓存策略。

我们的AssetBundle：

using System;
using UnityEngine;

namespace MrCAssetFramework
{
public sealed class MrCAssetBundle
{
internal AssetBundle m_AssetBundle;
internal string      m_AssetBundleName;
internal MrCAssetBundle(AssetBundle assetBundle,string name)
{
this.m_AssetBundle = assetBundle;
this.m_AssetBundleName = name;
this.m_ReferencedCount = 1;
}

#region ReferenceCountManage
//yinyongjishujizhi
private int m_ReferencedCount;
public void Retain()
{
this.m_ReferencedCount++;
}
public void Release(){
this.m_ReferencedCount--;
//当引用计数为0时,卸载资源
if (this.m_ReferencedCount == 0)
{
this.m_AssetBundle.Unload (true);
MrCAssetCache.FreeBundle(this.m_AssetBundleName);
}
}

public int RetainCount()
{
return this.m_ReferencedCount;
}
#endregion

}
}

AssetBundle管理：

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

namespace MrCAssetFramework
{
public class MrCAssetManager:MonoBehaviour
{

#region Singleton
private static GameObject       s_go_MrCAssetManager = null;
private static MrCAssetManager  s_MrCAssetManager = null;

public static MrCAssetManager DefaultAssetManager{
get{
if (s_MrCAssetManager == null) {
s_go_MrCAssetManager = new GameObject ("LOAssetManager");
s_MrCAssetManager = s_go_MrCAssetManager.AddComponent<MrCAssetManager> ();
}

return s_MrCAssetManager;
}
}

#endregion

public  static string URI{ set; get;}
public static string ManifestName{ set; get;}
//无返回值泛型委托..
public static Action<bool> InitBlock;

public AssetBundleManifest manifest{ set; get;}

　　　　　///<summary>
/// To get the asset..
/// </summary>

/// <returns>The asset..</returns>
public T GetAsset<T>(string assetbundlename,string assetname) where T:UnityEngine.Object
{
MrCAssetBundle lab = MrCAssetCache.GetBundleCache(assetbundlename);

if (lab == null) {
return null;
}
else
{
return lab.m_AssetBundle.LoadAsset<T>(assetname);
}
}

IEnumerator LoadManifestBundle()
{
//缓存中已经存在请求的bundle，中止..
if (MrCAssetCache.InCache(MrCAssetManager.ManifestName)) {
yield break;
}

// 通过网络下载AssetBundle
WWW www = IsLoadAssetBundleAtInternal(MrCAssetManager.ManifestName);
yield return www;

this.manifest = this.GetAsset<AssetBundleManifest>(MrCAssetManager.ManifestName,"AssetBundleManifest");
MrCAssetManager.InitBlock (this.manifest != null);
}
void Start()
{
StartCoroutine ("LoadManifestBundle");
}

#region 加载包裹系列函数

　　　　　///<summary>
/// 检查是否已经从网络下载
/// </summary>

protected WWW IsLoadAssetBundleAtInternal (string assetBundleName)
{
//已经存在了呀
MrCAssetBundle bundle = MrCAssetCache.GetBundleCache(assetBundleName);
if (bundle != null)
{
//保留数加一次
bundle.Retain ();
return null;
}

//如果WWW缓存策略中包含有对应的关键字,则返回true
if (MrCAssetCache.InCache (assetBundleName)) {
return null;
}

//创建下载链接
WWW www = new WWW(MrCAssetManager.URI + assetBundleName);
// 按版本号，按需要通过网络下载AssetBundle，一般在正式游戏版本中，不使用上面的，因为它会每次打开游戏重新下载
//WWW www = WWW.LoadFromCacheOrDownload(LOAssetManager.URI + assetBundleName, nowVersion);

//加入缓存策略
MrCAssetCache.SetWWWCache(assetBundleName,www);

return www;
}

IEnumerator LoadDependencies(string assetBundleName)
{
if (this.manifest == null) {
yield return null;
}
// 获取依赖包裹
string[] dependencies = this.manifest.GetAllDependencies(assetBundleName);

Debug.Log(dependencies.Length);

if (dependencies.Length == 0)
{
yield return null;
}

// 记录并且加载所有的依赖包裹
MrCAssetCache.SetDependCache(assetBundleName, dependencies);

for (int i = 0; i < dependencies.Length; i++)
{
yield return IsLoadAssetBundleAtInternal (dependencies [i]);
}
}

136　　　　  /// <summary>
/// 加载资源包
/// </summary>

IEnumerator LoadAssetBundle(string assetBundleName)
{
if (MrCAssetCache.InCache(assetBundleName)) {
yield break;
}
// 通过网络下载AssetBundle
WWW www = IsLoadAssetBundleAtInternal(assetBundleName);
yield return www;

// 通过网络加载失败，下载依赖包裹
yield return StartCoroutine(LoadDependencies(assetBundleName));
}

　　　　 ///<summary>
/// 异步加载资源
/// </summary>

public IEnumerator LoadAssetAsync (string assetBundleName, string assetName, System.Type type)
{
//开始加载包裹
yield return StartCoroutine(LoadAssetBundle (assetBundleName));
}

　　　　 ///<summary>
/// 异步加载场景
/// </summary>

public IEnumerator LoadLevelAsync (string assetBundleName, string levelName, bool isAdditive)
{
//加载资源包
yield return StartCoroutine(LoadAssetBundle (assetBundleName));

}
#endregion

#region Update

void Update()
{
MrCAssetCache.Update();
}
#endregion
}
}

缓存管理:

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

namespace MrCAssetFramework
{
internal sealed class MrCAssetCache
{
#region 包裹缓存机制
//创建缓存字典
private static Dictionary<string, MrCAssetBundle> assetBundleCache;
//缓存字典属性
private static Dictionary<string, MrCAssetBundle> BundleCache
{
get{
if (assetBundleCache == null) {
assetBundleCache = new Dictionary<string, MrCAssetBundle> ();
}

return assetBundleCache;
}
}

//创建缓存WWW对象
private static Dictionary<string, WWW> wwwCache;
//创建缓存WWW对象属性
private static Dictionary<string, WWW> WwwCache{
get{
if (wwwCache == null) {
wwwCache = new Dictionary<string, WWW> ();
}

return wwwCache;
}
}
//创建依赖缓存对象
private static Dictionary<string, string[]> dependCache;
//创建依赖缓存属性
private static Dictionary<string, string[]> DependCache
{
get{
if (dependCache == null) {
dependCache = new Dictionary<string, string[]> ();
}
return dependCache;
}
}

private static Dictionary<string, string> errorCache;
private static Dictionary<string,string> ErrorCache{
get{
if (errorCache == null) {
errorCache = new Dictionary<string, string> ();
}
return errorCache;
}
}

　　　　 ///<summary>
/// Instantiate the cache.
/// </summary>

/// <returns><c>true</c>, if cache was ined, <c>false</c> otherwise.</returns>
/// <param name="assetbundlename">Assetbundlename.</param>
internal static bool InCache(string assetbundlename)
{
return MrCAssetCache.BundleCache.ContainsKey(assetbundlename);
}
#endregion

#region 卸载系列函数

　　　　 ///<summary>
/// 卸载资源包和依赖包
/// </summary>

/// <param name="assetBundleName">Asset bundle name.</param>
public static void UnloadAssetBundle(string assetBundleName)
{
UnloadAssetBundleInternal (assetBundleName);
UnloadDependencies (assetBundleName);
}
internal static void UnloadDependencies(string assetBundleName)
{
string[] dependencies = null;
//获取所有的依赖包名称
if (!MrCAssetCache.DependCache.TryGetValue(assetBundleName, out dependencies) )
return;

//卸载依赖包
foreach(var dependency in dependencies)
{
UnloadAssetBundleInternal(dependency);
}
//删除依赖缓存策略
MrCAssetCache.DependCache.Remove(assetBundleName);
}

internal static void UnloadAssetBundleInternal(string assetBundleName)
{
MrCAssetBundle bundle;
MrCAssetCache.BundleCache.TryGetValue(assetBundleName,out bundle);

if (bundle == null)
{
return;
}
bundle.Release ();
}
#endregion

#region GetFunction
internal static WWW GetWWWCache(string key)
{
WWW www;

MrCAssetCache.WwwCache.TryGetValue(key,out www);

return www;
}
internal static void SetWWWCache(string key,WWW value)
{
MrCAssetCache.WwwCache.Add(key,value);
}

internal static MrCAssetBundle GetBundleCache(string key)
{
MrCAssetBundle ab;

MrCAssetCache.BundleCache.TryGetValue(key,out ab);

return ab;
}
internal static void SetBundleCache(string key,MrCAssetBundle value)
{
MrCAssetCache.BundleCache.Add(key,value);
}

internal static string[] GetDependCache(string key)
{
string[] depends;

MrCAssetCache.DependCache.TryGetValue(key,out depends);

return depends;
}
internal static void SetDependCache(string key,string[] value)
{
MrCAssetCache.DependCache.Add(key,value);
}

internal static string GetErrorCache(string key)
{
string error;

MrCAssetCache.ErrorCache.TryGetValue(key,out error);

return error;
}
internal static void SetErrorCache(string key,string value)
{
MrCAssetCache.ErrorCache.Add(key,value);
}
#endregion

internal static void FreeBundle(string key)
{
MrCAssetCache.BundleCache.Remove(key);
}

#region Update

internal static void Update()
{
// Collect all the finished WWWs.
var keysToRemove = new List<string>();
foreach (var keyValue in MrCAssetCache.WwwCache)
{
WWW download = keyValue.Value;
string m_bundleName = keyValue.Key;

// 下载失败
if (download.error != null)
{
MrCAssetCache.ErrorCache.Add(m_bundleName, download.error);

keysToRemove.Add(m_bundleName);

continue;
}

// 下载成功
if(download.isDone)
{

MrCAssetCache.BundleCache.Add(m_bundleName, new MrCAssetBundle(download.assetBundle,m_bundleName));

keysToRemove.Add(m_bundleName);
}
}

// 删除下载成功的WWW对象
foreach( var key in keysToRemove)
{
WWW download = MrCAssetCache.WwwCache[key];

MrCAssetCache.WwwCache.Remove(key);

download.Dispose();
}
}

#endregion
}
}

加载包裹中的场景：
新建一个场景，创建TestScript脚本，放到摄像机上。

using UnityEngine;
using System.Collections;
//引入框架
using MrCAssetFramework;

public class TestScript : MonoBehaviour {

/// <summary>
/// 加载场景资源函数
/// </summary>
protected IEnumerator Load (string assetBundleName, string level)
{
IEnumerator b = da.LoadLevelAsync(assetBundleName, level, false);
yield return StartCoroutine(b);
Application.LoadLevel(level);
}

MrCAssetManager da;
void Start ()
{
//指定统一资源标志符
MrCAssetManager.URI = "http://....../UnityFiles/AssetBundlesForBlog/";
//主配置文件
MrCAssetManager.ManifestName = "Others";
//加载成功后的操作代理
MrCAssetManager.InitBlock = ((bool bundleObj) => {
if (bundleObj) {
//协程操作加载的AssetBundle包裹
StartCoroutine (Load ("scenes/loaderscene.unity3d", "LoaderScene"));
}
});
//开始我们的一切
da = MrCAssetManager.DefaultAssetManager;
}
}

加载包裹中的游戏对象等资源到场景中：
在上面的测试脚本中，修改部分代码。

　　 /// <summary>
/// 加载游戏对象资源函数
/// </summary>
protected IEnumerator LoadObj(string assetBundleName, string obj)
{
IEnumerator b = da.LoadAssetAsync(assetBundleName, obj, typeof(GameObject));
yield return StartCoroutine(b);
GameObject go = da.GetAsset<GameObject>(assetBundleName, obj);
GameObject.Instantiate(go);
}
//-------------------------------------------------------------------------------
//加载成功后的操作代理
MrCAssetManager.InitBlock = ((bool bundleObj) => {
if (bundleObj) {
//协程操作加载的游戏对象包裹
StartCoroutine(LoadObj("prefabs/cube.prefab", "MyCube"));
}
});