/// <summary>
/// 删除单个包并递归处理包的依赖关系
/// </summary>
/// <param name="bundleName"></param>
public void DisposeBundle(string bundleName)
{
if (loadHelper.ContainsKey(bundleName))
{
// 遍历包的所有依赖包
IABRelationManager loader = loadHelper[bundleName];
List <string> dependencies = loader.GetDependences();
for (int i = 0; i < dependencies.Count; i++)
{
if (loadHelper.ContainsKey(dependencies[i])) // 当前依赖包存在内存
// 删除和当前包的被依赖关系
{
IABRelationManager currentRelationMgr = loadHelper[dependencies[i]];
if (currentRelationMgr.RemoveReference(bundleName)) // 当前依赖包的被依赖关系为空（函数内部删除当前依赖包）
// 删除当前依赖包的的依赖包（递归）
{
DisposeBundle(currentRelationMgr.BundleName);
}
}
}
// 当前包的被依赖关系为空时，删除当前包
if (loader.GetReference().Count <= 0)
{
loader.Dispose();
loadHelper.Remove(bundleName);
}
}
}
public UnityEngine.Object[] GetMultiResources(string bundleName, string resName)
{
//表示是否已经缓存了
if (loadObj.ContainsKey(bundleName))
{
AssetResObj tmpRes = loadObj[bundleName];
List <Object> tmpObj = tmpRes.GetResObj(resName);
if (tmpObj != null)
{
return(tmpObj.ToArray());
}
}
//表示已经加载过bundle
if (loadHelper.ContainsKey(bundleName))
{
IABRelationManager loader = loadHelper[bundleName];
Object[] tmpObj = loader.GetMultiResource(resName);
//放入缓存
AssetObj tmpAssetObj = new AssetObj(tmpObj);
if (loadObj.ContainsKey(bundleName))
{
loadObj[bundleName].AddResObj(resName, tmpAssetObj);
}
else
{
AssetResObj tmpRes = new AssetResObj(resName, tmpAssetObj);
loadObj.Add(bundleName, tmpRes);
}
return(tmpObj);
}
return(null);
}
void LoadObjectFromBundle(string bundleName, string resName, LoadObjectCallBack callback)
{
if (loadedHelper.ContainsKey(bundleName))
{
IABRelationManager relation = loadedHelper[bundleName];
Object tempObj = relation.GetSingleResource(resName);
//缓存 tempObj
AssetObj assetObj = new AssetObj(tempObj);
if (!loadObjs.ContainsKey(bundleName))
{
AssetResObj tmpRes = new AssetResObj(resName, assetObj);
loadObjs.Add(bundleName, tmpRes);
}
else
{
AssetResObj resObj = loadObjs[bundleName];
resObj.AddResObj(resName, assetObj);
}
if (null != callback)
{
callback(tempObj);
}
}
else
{
if (null != callback)
{
callback(null);
}
}
}
//表示已经加载过bundle
public Object GetSingleResource(string bundleName, string resName)
{
if (loadObj.ContainsKey(bundleName))
{
AssetResObj tmpRes = loadObj[bundleName];
List <Object> tmpObj = tmpRes.GetResObj(resName);
if (tmpObj != null)
{
return(tmpObj[0]);
}
}
if (loadHelper.ContainsKey(bundleName))
{
IABRelationManager loader = loadHelper[bundleName];
Object tmpObj = loader.GetSingleResource(resName);
AssetObj tmpAssetObj = new AssetObj(tmpObj);
//缓存里面是否已经有了这个包
if (loadObj.ContainsKey(bundleName))
{
AssetResObj tmpRes = loadObj[bundleName];
tmpRes.AddResObj(resName, tmpAssetObj);
}
else
{
//没有加载过这个包
AssetResObj tmpRes = new AssetResObj(resName, tmpAssetObj);
loadObj.Add(bundleName, tmpRes);
}
return(tmpObj);
}
else
{
return(null);
}
}
public void DisposeBundleAndObjs(string bundlePath)
{
if (mABRelationDict.ContainsKey(bundlePath))
{
IABRelationManager iABRelationManager = mABRelationDict[bundlePath];
List <string> dependenceList = iABRelationManager.GetDependences();
for (int i = 0; i < dependenceList.Count; i++)
{
if (mABRelationDict.ContainsKey(dependenceList[i]))
{
IABRelationManager dependence = mABRelationDict[dependenceList[i]];
if (dependence.RemoveReference(bundlePath))
{
DisposeBundle(dependence.BundlePath);
}
}
}
if (iABRelationManager.GetReferences().Count <= 0)
{
iABRelationManager.Dispose();
mABRelationDict.Remove(bundlePath);
DisposeResObjs(bundlePath);
}
}
}
public UnityEngine.Object[] GetResources(string bundlePath, string resName)
{
//表示是否缓存了该物体
if (mAssetObjsDict.ContainsKey(bundlePath))
{
AssetBundleObjs abObjs = mAssetObjsDict[bundlePath];
List <UnityEngine.Object> objs = abObjs.GetResObj(resName);
if (objs != null)
{
return(objs.ToArray());
}
}
//表示已经加载过bundle
if (mABRelationDict.ContainsKey(bundlePath))
{
IABRelationManager iABRelation = mABRelationDict[bundlePath];
UnityEngine.Object[] objs = iABRelation.GetResources(resName);
AssetObj assetObj = new AssetObj(objs);
if (mAssetObjsDict.ContainsKey(bundlePath))
{
AssetBundleObjs assetBundleObjs = mAssetObjsDict[bundlePath];
mAssetObjsDict.Add(bundlePath, assetBundleObjs);
}
else
{
AssetBundleObjs assetBundleObjs = new AssetBundleObjs(resName, assetObj);
mAssetObjsDict.Add(bundlePath, assetBundleObjs);
}
return(objs);
}
return(null);
}
/// <summary>
/// 循环的 处理 依赖关系
/// </summary>
/// <param name="bundleName"></param>
public void DisposeBundle(string bundleName)
{
if (loadHelper.ContainsKey(bundleName))
{
IABRelationManager loader = loadHelper[bundleName];
List <string> depences = loader.GetDepedence();
for (int i = 0; i < depences.Count; i++)
{
if (loadHelper.ContainsKey(depences[i]))
{
IABRelationManager depedence = loadHelper[depences[i]];
if (depedence.RemoveReference(bundleName))
{
DisposeBundle(depedence.GetBundleName());
}
}
}
if (loader.GetRefference().Count <= 0)
{
loader.Dispose();
loadHelper.Remove(bundleName);
}
}
}
// 加载依赖关系的包 和 LoadAssetBundle 形成递归
private IEnumerator LoadAssetBundleDepedencies(string bundleName, string refName, LoadProgress loadProgress)
{
if (!loadHelper.ContainsKey(bundleName)) // 不存在包
// 创建依赖关系管理
{
IABRelationManager relationMgr = new IABRelationManager();
relationMgr.Initialize(bundleName, loadProgress);
if (refName != null)
{
relationMgr.AddReference(refName);
}
// 保存
loadHelper.Add(bundleName, relationMgr);
// 加载包
yield return(LoadAssetBundle(bundleName));
}
else // 存在包
// 添加依赖关系
{
if (refName != null)
{
IABRelationManager loader = loadHelper[bundleName];
loader.AddReference(refName);
}
}
}
public IEnumerator LoadAssetBundleDependences(string bundlName, string refName, LoaderProgrecess progress)
{
if (!loadHelper.ContainsKey(bundlName))
{
IABRelationManager loader = new IABRelationManager();
loader.Initial(bundlName, progress);
if (refName != null)
{
loader.AddRefference(refName);
}
loadHelper.Add(bundlName, loader);
yield return(LoadAssetBundles(bundlName));
}
else
{
if (refName != null)
{
IABRelationManager loader = loadHelper[bundlName];
loader.AddRefference(bundlName);
}
}
}
public void DebugAssetBundle(string bundlePath)
{
if (mABRelationDict.ContainsKey(bundlePath))
{
IABRelationManager loader = mABRelationDict[bundlePath];
loader.DebuggerAsset();
}
}
public void DebugAssetBundle(string bundleName)
{
if (loadHelperDic.ContainsKey(bundleName))
{
IABRelationManager loader = loadHelperDic[bundleName];
loader.DebuggerAsset();
}
}
public bool IsLoadingFinish(string bundleName)
{
if (loadHelper.ContainsKey(bundleName))
{
IABRelationManager loader = loadHelper[bundleName];
return(loader.IsBundleLoadFinish());
}
else
{
return(false);
}
}
public void DisposeAllBundle()
{
List <string> keys = new List <string>();
keys.AddRange(loadHelper.Keys);
for (int i = 0; i < loadHelper.Count; i++)
{
IABRelationManager loader = loadHelper[keys[i]];
loader.Dispose();
}
loadHelper.Clear();
}
/// <summary>
/// 卸载所有Bundle包
/// </summary>
public void DisposeAllBundle()
{
List <string> keys = new List <string>();
keys.AddRange(mABRelationDict.Keys);
for (int i = 0; i < mABRelationDict.Count; i++)
{
IABRelationManager iABRelationManager = mABRelationDict[keys[i]];
iABRelationManager.Dispose();
}
mABRelationDict.Clear();
}
/// <summary>
/// 是否加载完毕
/// </summary>
/// <param name="bundleName"></param>
/// <returns></returns>
public bool IsLoadingFinish(string bundleName)
{
if (loadHelperDic.ContainsKey(bundleName))
{
IABRelationManager loader = loadHelperDic[bundleName];
return(loader.IsBundleLoadFinish());
}
else
{
Debug.Log("IABRelation no contain bundle == " + bundleName);
return(false);
}
}
public void LoadAssetBundle(string bundlePath, LoaderProgress progress, LoadAssetBundleCallBack callBack)
{
if (!mABRelationDict.ContainsKey(bundlePath))
{
IABRelationManager iABRelation = new IABRelationManager();
iABRelation.Initial(bundlePath, progress);
mABRelationDict.Add(bundlePath, iABRelation);
callBack.Invoke(mSceneName, bundlePath);
}
else
{
Debug.Log("已经包含BundlePath:" + bundlePath);
}
}
public void LoadAssetBundle(string bundleName, LoaderProgrecess progress, LoadAssetBundleCallBack callBack)
{
if (!loadHelper.ContainsKey(bundleName))
{
IABRelationManager loader = new IABRelationManager();
loader.Initial(bundleName, progress);
loadHelper.Add(bundleName, loader);
callBack(scenceName, bundleName);
}
else
{
}
}
//对外的接口
public void LoadAssetBundle(string bundleName, LoaderProgrecess progreces, LoadAssetBundleCallBack callBack)
{
if (!loadHelper.ContainsKey(bundleName))
{
IABRelationManager loader = new IABRelationManager();
loader.Initial(bundleName, progreces);
loadHelper.Add(bundleName, loader);
callBack(sceneName, bundleName);
}
else
{
Debug.Log("IABManager have contain bundle name==" + bundleName);
}
}
IEnumerator LoadAssetBundleDependences(string bundleName, string refName)
{
yield return(null);
if (!loadedHelper.ContainsKey(bundleName))
{
yield return(LoadAssetBundle(bundleName));
}
if (null != refName)
{
IABRelationManager loader = loadedHelper[bundleName];
loader.AddRefference(refName);
}
}
/// <summary>
/// 加载assetbundle必须先加载manifest，然后加载依赖项
/// </summary>
/// <param name="bundlePath"></param>
/// <returns></returns>
public IEnumerator LoadAssetBundles(string bundlePath)
{
while (!IABManifestLoader.Instance.IsLoadFinish())
{
yield return(null);
}
IABRelationManager iABRelationManager = mABRelationDict[bundlePath];
string[] dependences = GetDependences(bundlePath);
iABRelationManager.AddDependences(dependences);
for (int i = 0; i < dependences.Length; i++)
{
yield return(LoadAssetBundleDependences(dependences[i], bundlePath, iABRelationManager.GetLoaderProgress()));
}
yield return(iABRelationManager.LoadAssetBundle());
}
/// <summary>
/// 加载 assetbundle 必须先加载manifest
/// </summary>
/// <param name="bundleName"></param>
/// <returns></returns>
public IEnumerator LoadAssetBundles(string bundleName)
{
while (!IABManifestLoader.Instance.IsLoadFinish())
{
yield return(null);
}
IABRelationManager loader = loadHelper[bundleName];
string[] dependences = GetDependence(bundleName);
loader.SetDependence(dependences);
for (int i = 0; i < dependences.Length; i++)
{
yield return(LoadAssetBundleDependences(dependences[i], bundleName, loader.GetProgrecess()));
}
yield return(loader.LoadAssetBundle());
}
/// <summary>
/// 加载多个资源（一般用于切割多张的精灵图片）
/// </summary>
/// <param name="bundleName">包名</param>
/// <param name="resName">资源名</param>
/// <returns></returns>
public Object[] GetMultiResources(string bundleName, string resName)
{
// 是否已经缓存了这个包
if (loadObjs.ContainsKey(bundleName))
{
// 缓存包中有指定资源，直接返回
AssetResObj tmpRes = loadObjs[bundleName];
List <Object> tmpObjs = tmpRes.GetResObj(resName);
if (tmpObjs != null)
{
return(tmpObjs.ToArray());
}
}
// 是否已经加载过bundle
if (loadHelper.ContainsKey(bundleName))
{
// 从包中加载出obj
IABRelationManager loader = loadHelper[bundleName];
Object[] tmpObjs = loader.GetMultiResources(resName);
AssetObj tmpAssetObj = new AssetObj(tmpObjs);
// 是否已经缓存了这个包
if (loadObjs.ContainsKey(bundleName))
{
// 添加缓存资源
AssetResObj tmpRes = loadObjs[bundleName];
tmpRes.AddResObj(resName, tmpAssetObj);
}
else
{
// 添加缓存包和资源
AssetResObj tmpRes = new AssetResObj(resName, tmpAssetObj);
loadObjs.Add(bundleName, tmpRes);
}
return(tmpObjs);
}
else
{
return(null);
}
}
/// <summary>
/// 初始化 -- 创建包的资源加载器（未实际加载）
/// </summary>
/// <param name="bundleName">ab标签</param>
/// <param name="progress">加载时每帧回调</param>
/// <param name="callback">回调</param>
public void Init(string bundleName, LoadProgrecess progress, LoadAssetBundleCallBack callback)
{
//如果没加载过
if (!loadHelper.ContainsKey(bundleName))
{
IABRelationManager loader = new IABRelationManager();
//加载
loader.Initial(bundleName, null, progress);
//添加到loadHelper
loadHelper.Add(bundleName, loader);
//提供给上层 启动 IEnumerator LoadAssetBundles(string BundleName) 返回当前场景名 ab标签名
callback(scenceName, bundleName);
}
else
{
Debug.Log("IABManager has contain bundle name == " + bundleName);
}
}
/// <summary>
/// 获取单个资源
/// </summary>
/// <param name="bundleName"></param>
/// <param name="resName"></param>
/// <returns></returns>
public UnityEngine.Object GetSingleResources(string bundleName, string resName)
{
if (loadObjDic.ContainsKey(bundleName))
{
AssetResObj tmpRes = loadObjDic[bundleName];
List <UnityEngine.Object> tmpObj = tmpRes.GetResObj(resName);
if (tmpObj != null)
{
return(tmpObj[0]);
}
}
//表示已经加载过bundle
if (loadHelperDic.ContainsKey(bundleName))
{
IABRelationManager loader = loadHelperDic[bundleName];
UnityEngine.Object tmpObj = loader.GetSingleResources(resName);
AssetObj tmpAssetObj = new AssetObj(tmpObj);
if (loadObjDic.ContainsKey(bundleName))
{
AssetResObj tmpRes = loadObjDic[bundleName];
tmpRes.AddResObj(resName, tmpAssetObj);
}
else
{
//没有加载过这个包
AssetResObj tmpRes = new AssetResObj(bundleName, tmpAssetObj);
tmpRes.AddResObj(resName, tmpAssetObj);
loadObjDic.Add(bundleName, tmpRes);
}
return(tmpObj);
}
else
{
Debug.LogError(resName + "load error");
return(null);
}
}
/// <summary>
/// 加载包及依赖包 需先加载manifest
/// </summary>
/// <param name="bundleName">ab标签</param>
/// <returns></returns>
public IEnumerator LoadAssetBundles(string bundleName)
{
while (!IABManifestLoader.Instance.IsLoadFinish())
{
yield return(null);
}
if (!loadHelperDic.ContainsKey(bundleName))
{
Debug.Log(bundleName + "is null");
yield break;
}
IABRelationManager loader = loadHelperDic[bundleName];
string[] depences = GetDependences(bundleName);
for (int i = 0; i < depences.Length; i++)
{
//加载依赖包
yield return(LoadAssetBundleDependences(depences[i], bundleName, loader.GetProgress()));
}
yield return(loader.LoadAssetBundle());
}
// 加载assetbundle必须先加载manifest
public IEnumerator LoadAssetBundle(string bundleName)
{
// 等待manifest加载完
while (!IABManifestLoader.Instance.IsLoadFinish)
{
yield return(null);
}
// 获取这个包的依赖关系
IABRelationManager relationMgr = loadHelper[bundleName];
string[] dependencies = GetDependencies(bundleName);
relationMgr.SetDependences(dependencies);
// 加载所有依赖的包
for (int i = 0; i < dependencies.Length; i++)
{
yield return(LoadAssetBundleDepedencies(dependencies[i], bundleName, relationMgr.GetPorgress()));
}
// 加载包
yield return(relationMgr.LoadAssetBundle());
}
private IEnumerator LoadAssetBundleDependences(string bundleName, string refName, LoadProgrecess progress)
{
if (!loadHelperDic.ContainsKey(bundleName))
{
IABRelationManager loader = new IABRelationManager();
//初始化IABRelationManager 创建bundleName包的加载对象 progress加载的回调
loader.Initial(bundleName, null, progress);
if (refName != null)
{
loader.AddRefference(refName);
}
loadHelperDic.Add(bundleName, loader);
yield return(LoadAssetBundles(bundleName));
}
else
{
if (refName != null)
{
IABRelationManager loader = loadHelperDic[bundleName];
loader.AddRefference(bundleName);
}
}
}
public Object[] GetMultResources(string bundleName, string resName)
{
if (loadObjs.ContainsKey(bundleName))
{
AssetResObjs tmpRes = loadObjs[bundleName];
List <Object> tmpObj = tmpRes.GetResObj(resName);
if (tmpObj != null)
{
return(tmpObj.ToArray());
}
else
{
}
}
if (loadHelper.ContainsKey(bundleName))
{
IABRelationManager loader = loadHelper[bundleName];
Object[] tmpObj = loader.GetMutiResources(resName);
AssetResObj tempAssetObj = new AssetResObj(tmpObj);
if (loadObjs.ContainsKey(bundleName))
{
AssetResObjs tmpRes = loadObjs[bundleName];
tmpRes.AddResObj(resName, tempAssetObj);
}
else
{
AssetResObjs tmpRes = new AssetResObjs(resName, tempAssetObj);
loadObjs.Add(bundleName, tmpRes);
}
return(tmpObj);
}
else
{
return(null);
}
}
public IEnumerator LoadAssetBundleDependences(string bundlePath, string refName, LoaderProgress progress)
{
if (!mABRelationDict.ContainsKey(bundlePath))
{
IABRelationManager iABRelation = new IABRelationManager();
iABRelation.Initial(bundlePath, progress);
//记录被依赖对象
if (refName != null)
{
iABRelation.AddReference(refName);
}
mABRelationDict.Add(bundlePath, iABRelation);
yield return(LoadAssetBundles(bundlePath));
}
else
{
if (refName != null)
{
IABRelationManager iABRelationManager = mABRelationDict[bundlePath];
iABRelationManager.AddReference(bundlePath);
}
}
}
public IEnumerator LoadAssetBundle(string bundleName, LoadAssetBundleCallback callback = null)
{
if (IABManifestLoader.Instance.IsFinishedLoad)
{
yield return(null);
}
//管理AB加载完成后的回调函数
if (null != callback)
{
if (loadBundleCallback.ContainsKey(bundleName))
{
LoadAssetBundleCallbackManager callbackManager = loadBundleCallback[bundleName];
callbackManager.AddCallback(callback);
}
else
{
LoadAssetBundleCallbackManager callbackManager = new LoadAssetBundleCallbackManager(bundleName);
callbackManager.AddCallback(callback);
loadBundleCallback.Add(bundleName, callbackManager);
}
}
if (preLoadHelper.ContainsKey(bundleName))
{
yield return(null);
}
else
{
IABRelationManager relation = new IABRelationManager();
relation.Initial(bundleName);
preLoadHelper.Add(bundleName, relation);
string bundlePath = GetBundlePath(bundleName);
WWW www = new WWW(bundlePath);
yield return(www);
if (!string.IsNullOrEmpty(www.error))
{
Debug.LogError(www.error);
preLoadHelper.Remove(bundleName);
}
else
{
AssetBundle ab = www.assetBundle;
string[] dependences = IABManifestLoader.Instance.assetBundleManifest.GetAllDependencies(ab.name);
IABRelationManager tmpRelation = preLoadHelper[ab.name];
tmpRelation.SetAssetBundle(ab);
tmpRelation.SetDependences(dependences);
if (!loadedHelper.ContainsKey(ab.name))
{
loadedHelper.Add(ab.name, relation);
preLoadHelper.Remove(bundleName);
}
for (int i = 0, iMax = dependences.Length; i < iMax; ++i)
{
if (!loadedHelper.ContainsKey(dependences[i]))
{
yield return(LoadAssetBundleDependences(dependences[i], ab.name));
}
}
if (loadBundleCallback.ContainsKey(ab.name))
{
loadBundleCallback[ab.name].Callback(ab.name);
}
}
www.Dispose();
}
}