上次我们进行了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 = ;
} #region ReferenceCountManage
//yinyongjishujizhi
private int m_ReferencedCount;
public void Retain()
{
this.m_ReferencedCount++;
}
public void Release(){
this.m_ReferencedCount--;
//当引用计数为0时,卸载资源
if (this.m_ReferencedCount == )
{
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 == )
{
yield return null;
} // 记录并且加载所有的依赖包裹
MrCAssetCache.SetDependCache(assetBundleName, dependencies); for (int i = ; 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"));
}
});