/// <summary>
/// 加载AB资源
/// </summary>
/// <param name="assetName">资源名称</param>
/// <param name="listener">回调</param>
/// <param name="isKeepInMemory">是否常驻内存</param>
/// <param name="isAsync">是否异步</param>
private void LoadForAB(string assetName, ILoadListener listener, bool isKeepInMemory, bool isAsync)
{
if (!mABInfoDic.ContainsKey(assetName))
{
if (listener != null)
{
listener.LoadFailure(assetName);
}
Debug.LogError("这个资源不存在AB里面 资源名称：" + assetName);
return;
}
for (int i = 0; i < mLoadIn.Count; i++)
{
if (mLoadIn[i].AssetName == assetName)
{
Log.Error("正在加载这个资源 资源名称：" + assetName);
return;
}
}
for (int i = 0; i < mLoadWait.Count; i++)
{
if (mLoadWait.ToArray()[i].AssetName == assetName)
{
Log.Error("这个资源已经等待加载了 资源名称：" + assetName);
return;
}
}
ABInfo abInfo = GetABInfo(assetName);
ABReq req = new ABReq(abInfo.AssetName, abInfo.ABName, listener, isKeepInMemory, isAsync);
mLoadWait.Enqueue(req);
}
/// <summary>
/// 加载Resource资源
/// </summary>
/// <typeparam name="T">资源类型</typeparam>
/// <param name="assetName">资源名称</param>
/// <param name="listener">回调</param>
/// <param name="isKeepInMemory">是否常驻内存</param>
/// <param name="isAsync">是否异步</param>
private void LoadForRes <T>(string assetName, ILoadListener listener, bool isKeepInMemory, bool isAsync)
{
if (!mResTxtDic.ContainsKey(assetName))
{
if (listener != null)
{
listener.LoadFailure(assetName);
}
Log.Error("这个资源不存在Resources里面 资源名称：" + assetName);
return;
}
for (int i = 0; i < mLoadIn.Count; i++)
{
if (mLoadIn[i].AssetName == assetName)
{
Log.Error("正在加载这个资源 资源名称：" + assetName);
return;
}
}
for (int i = 0; i < mLoadWait.Count; i++)
{
if (mLoadWait.ToArray()[i].AssetName == assetName)
{
Log.Error("这个资源已经等待加载了 资源名称：" + assetName);
return;
}
}
ResReq req = new ResReq(assetName, listener, typeof(T), isKeepInMemory, isAsync);
mLoadWait.Enqueue(req);
}
/// <summary>
/// 加载资源
/// </summary>
/// <typeparam name="T">资源类型</typeparam>
/// <param name="assetName">资源名称</param>
/// <param name="listener">资源加载完成后的回调</param>
/// <param name="isKeepInMemory">是否常驻内存</param>
/// <param name="isAsync">是否异步</param>
public void Load <T>(string assetName, ILoadListener listener, bool isKeepInMemory = false, bool isAsync = true)
{
//如果资源缓存里面已经存在这个资源那么直接返回
if (mAssetPackDic.ContainsKey(assetName) && mAssetPackDic[assetName] != null)
{
if (listener != null)
{
listener.LoadFinish(mAssetPackDic[assetName].Asset);
}
return;
}
//如果是Resources里的资源，调用LoadForRes
if (mResTxtDic.ContainsKey(assetName))
{
LoadForRes <T>(assetName, listener, isKeepInMemory, isAsync);
}
else if (mABInfoDic.ContainsKey(assetName))
{
LoadForAB(assetName, listener, isKeepInMemory, isAsync);
}
else
{
if (listener != null)
{
listener.LoadFailure(assetName);
}
Log.Error("你要加载的资源不存在 资源名称：" + assetName);
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="loadListener">加载完成的回调</param>
/// <param name="assetName">资源名称</param>
/// <param name="type">资源类型</param>
/// <param name="isKeepInMemory">是否常驻内存</param>
public ResReq(string assetName, ILoadListener loadListener, Type type,
bool isKeepInMemory, bool isAsync = true)
{
base.AssetName = assetName;
//this.LoadListener.Add(loadListener);
base.AssetType = type;
base.IsKeepInMemory = isKeepInMemory;
base.IsAsync = isAsync;
this.LoadListener = loadListener;
mFullPath = ResMgr.Instance.GetResFullName(assetName);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="abName"></param>
/// <param name="isKeepInMemory"></param>
/// <param name="isAsync"></param>
public ABReq(string assetName, string abName, ILoadListener listener, bool isKeepInMemory, bool isAsync = true)
{
if (File.Exists(AppMgr.Instance.externalResPath + "/" + abName))
{
base.mFullPath = AppMgr.Instance.externalResPath + "/" + abName;
}
else
{
base.mFullPath = AppMgr.Instance.interiorResPath + "/" + abName;
}
this.LoadListener = listener;
base.AssetName = assetName;
base.IsKeepInMemory = isKeepInMemory;
base.IsAsync = isAsync;
}
/// <summary>
/// AB异步加载
/// </summary>
/// <param name="assetBundle"></param>
/// <param name="p1"></param>
/// <param name="loadListener"></param>
/// <param name="p2"></param>
/// <returns></returns>
IEnumerator LoadABAsync(AssetBundle assetBundle, string assetName, ILoadListener loadListener, bool isKeepInMemory)
{
AssetBundleRequest abreq = assetBundle.LoadAssetAsync(GetABInfo(assetName).FullName);
yield return(abreq);
yield return(1);
AssetPack asset = new AssetPack(assetName, abreq.asset, isKeepInMemory);
if (mAssetPackDic.ContainsKey(asset.AssetName))
{
mAssetPackDic[asset.AssetName] = asset;
}
else
{
mAssetPackDic.Add(asset.AssetName, asset);
}
loadListener.LoadFinish(abreq.asset);
AddAssetToStackTop(asset.AssetName);
assetBundle.Unload(false);
}
public LoadPresenter(ILoadView loadView, ILoadListener loadListener)
{
this.loadView = loadView;
LoadListener = loadListener;
}
/// <summary>
/// 加载资源
/// </summary>
/// <param name="assetName">资源名称</param>
/// <param name="listener">资源加载完成后的回调</param>
/// <param name="isKeepInMemory">是否常驻内存</param>
/// <param name="isAsync">是否异步</param>
public void Load(string assetName, ILoadListener listener, bool isKeepInMemory = false, bool isAsync = true)
{
Load <GameObject>(assetName, listener, isKeepInMemory, isAsync);
}
