/// <summary>
/// 取消异步加载资源
/// </summary>
/// <returns>true为完全取消了，false表示可能还有其他相同操作的异步在进行，并没有取消</returns>
public bool CancleLoad(ResourceObj resObj)
{
AsyncLoadResParam para = null;
if (m_LoadingAssetDic.TryGetValue(resObj.m_Crc, out para) && m_LoadingAssetList[(int)para.m_Priority].Contains(para))
{
for (int i = para.m_CallBackList.Count - 1; i >= 0; i--)
{
AsyncCallBack tempCallBack = para.m_CallBackList[i];
if (tempCallBack != null && resObj == tempCallBack.m_ResObj)
{
tempCallBack.Reset();
m_AsyncCallBackPool.Recycle(tempCallBack);
para.m_CallBackList.Remove(tempCallBack);
}
}
if (para.m_CallBackList.Count <= 0)
{
m_LoadingAssetList[(int)para.m_Priority].Remove(para);
para.Reset();
m_AsyncLoadResParamPool.Recycle(para);
m_LoadingAssetDic.Remove(resObj.m_Crc);
return(true);
}
}
return(false);
}
public void AsyncLoadResource(string path, ResourceObj resObj, OnAsyncFinish dealfinish, LoadResPriority priority)
{
ResourceItem item = GetCacheResourceItem(resObj.m_Crc);
if (item != null)
{
resObj.m_ResItem = item;
if (dealfinish != null)
{
dealfinish(path, resObj, resObj.m_Param1, resObj.m_Param2, resObj.m_Param3);
}
return;
}
//判断是否在加载中
AsyncLoadResParam para = null;
if (!m_LoadingAssetDic.TryGetValue(resObj.m_Crc, out para) || para == null)
{
para = m_AsyncLoadResParamPool.Spwan(true);
para.m_Crc = resObj.m_Crc;
para.m_Path = path;
para.m_Priority = priority;
m_LoadingAssetDic.Add(resObj.m_Crc, para);
m_LoadingAssetList[(int)priority].Add(para);
}
//往回调列表里面加回调
AsyncCallBack callBack = m_AsyncCallBackPool.Spwan(true);
callBack.m_DealFinish = dealfinish;
callBack.m_ResObj = resObj;
para.m_CallBackList.Add(callBack);
}
/// <summary>
/// 用于ObjectManager异步加载接口
/// </summary>
public void AsyncLoadResObj(string path, ResourceObject resObj, OnAsyncResFinshCallBack resLoadCallBack)
{
ResourceItem item = GetCacheResourceItem(resObj.m_Crc);
if (item != null)
{
resObj.m_ResItem = item;
resLoadCallBack?.Invoke(path, resObj, resObj.m_Param1, resObj.m_Param2, resObj.m_Param3);
resLoadCallBack = null;
return;
}
//判断当前要加载的资源是否已存在加载列表中，不存在，则加入加载列表
AsyncLoadResParam param = null;
if (!m_LoadingAssetDict.TryGetValue(resObj.m_Crc, out param) || param == null)
{
param = m_AsyncLoadResPool.Spawn();
param.m_Crc = resObj.m_Crc;
param.m_Path = path;
param.m_Priority = resObj.m_LoadPriority;
m_LoadingAssetDict.Add(resObj.m_Crc, param);
m_LoadAsyncResList[(int)resObj.m_LoadPriority].Add(param);
}
//回调列表里添加回调
AsyncCallBack asyncCallBack = m_AsyncCallBackPool.Spawn();
asyncCallBack.resObj = resObj;
asyncCallBack.resFinshCallBack = resLoadCallBack;
param.callBackList.Add(asyncCallBack);
}
public void CancelAsynLoading(ResourceObject resObj)
{
if (resObj == null)
{
return;
}
AsyncLoadResParam param = null;
//如果还未加载才可以取消
if (m_AsyncLoadDic.TryGetValue(resObj.m_Crc, out param) && m_AsyncLoadingList[(int)param.m_Priority].Contains(param))
{
List <AsyncCallback> callbackList = param.m_AsyncCallbackList;
for (int i = callbackList.Count - 1; i >= 0; i--)
{
AsyncCallback temp = callbackList[i];
if (temp != null && temp.m_ResObj == resObj)
{
callbackList.RemoveAt(i);
m_AsyncCallbackPool.Recycle(temp);
}
}
if (callbackList.Count <= 0)
{
m_AsyncLoadingList[(int)param.m_Priority].Remove(param);
m_AsyncLoadResParamPool.Recycle(param);
m_AsyncLoadDic.Remove(resObj.m_Crc);
}
}
}
public bool CancelAsyncLoad(ResourceObject resObj)
{
AsyncLoadResParam asyncParam = null;
//首先获取是否存在该异步加载资源
if (m_LoadingAssetDict.TryGetValue(resObj.m_Crc, out asyncParam) && m_LoadAsyncResList[(int)resObj.m_LoadPriority].Contains(asyncParam))
{
for (int i = asyncParam.callBackList.Count - 1; i >= 0; i--)
{
AsyncCallBack tempCallBack = asyncParam.callBackList[i];
//这个判断是，当有多个物体A,B都需要加载同样的资源时，如果A取消了，但是B不能取消
if (tempCallBack != null && tempCallBack.resObj == resObj)
{
tempCallBack.Reset();
m_AsyncCallBackPool.UnSpawn(tempCallBack);
asyncParam.callBackList.RemoveAt(i);
}
}
//在上层遍历完，如果异步回调列表空了，则代表不再需要异步加载该资源了，因此直接清空回收
if (asyncParam.callBackList.Count <= 0)
{
asyncParam.Reset();
m_LoadAsyncResList[(int)resObj.m_LoadPriority].Remove(asyncParam);
m_LoadingAssetDict.Remove(resObj.m_Crc);
m_AsyncLoadResPool.UnSpawn(asyncParam);
return(true);
}
}
return(false);
}
//异步资源加载-----------------------------------------------------------------------------------
/// <summary>
/// 异步加载资源
/// </summary>
/// <param name="path">资源路径</param>
/// <param name="finishCallBack">完成后回调</param>
/// <param name="loadPriority">加载优先级</param>
/// <param name="param1">回调参数1</param>
/// <param name="param2">回调参数2</param>
/// <param name="param3">回调参数3</param>
public void AsyncLoadResource(string path, OnAsyncFinishCallBack finishCallBack, LoadPriority loadPriority, bool isSprite = false,
object param1 = null, object param2 = null, object param3 = null)
{
uint crc = CRC32.GetCRC32(path);
ResourceItem item = GetCacheResourceItem(crc);
if (item != null)
{
finishCallBack?.Invoke(path, item.m_Obj, param1, param2, param3);
return;
}
//判断当前要加载的资源是否已存在加载列表中，不存在，则加入加载列表
AsyncLoadResParam param = null;
if (!m_LoadingAssetDict.TryGetValue(crc, out param) || param == null)
{
param = m_AsyncLoadResPool.Spawn();
param.m_Crc = crc;
param.m_Path = path;
param.m_Priority = loadPriority;
param.m_IsSprite = isSprite;
m_LoadAsyncResList[(int)loadPriority].Add(param);
m_LoadingAssetDict.Add(crc, param);
}
//回调列表里添加回调
AsyncCallBack asyncCallBack = m_AsyncCallBackPool.Spawn();
asyncCallBack.finishCallBack = finishCallBack;
asyncCallBack.param1 = param1;
asyncCallBack.param2 = param2;
asyncCallBack.param3 = param3;
param.callBackList.Add(asyncCallBack);
}
/// <summary>
/// 异步加载资源(普通的)
/// </summary>
/// <param name="path"></param>
/// <param name="callback"></param>
/// <param name="priority"></param>
/// <param name="param1"></param>
/// <param name="param2"></param>
/// <param name="param3"></param>
public void AsyncLoadResource(string path, AsyncObjFinishCallback callback, bool isSprite = false, object param1 = null, object param2 = null, object param3 = null, ResLoadPriority priority = ResLoadPriority.RES_NORMAL)
{
if (m_StartCoroutine == null)
{
Debug.LogError("ResourceManager.AsyncLoadResource 协程未启动,无法使用异步加载");
return;
}
WashOut();
uint crc = Crc32.GetCrc32(path);
ResourceItem item = GetCacheResourceItem(crc);
//如果资源已经加载
if (item != null)
{
if (callback != null)
{
callback(path, item.m_Obj, param1, param2, param3);
}
return;
}
//判断是否正在加载
AsyncLoadResParam asyncParam = null;
if (!m_AsyncLoadDic.TryGetValue(crc, out asyncParam))
{
//添加到正在加载
asyncParam = m_AsyncLoadResParamPool.Spawn(true);
asyncParam.m_Crc = crc;
asyncParam.m_Path = path;
asyncParam.m_Priority = priority;
asyncParam.m_IsSprite = isSprite;
m_AsyncLoadDic.Add(crc, asyncParam);
m_AsyncLoadingList[(int)priority].Add(asyncParam);
}
//缓存回调信息
AsyncCallback asyncCallback = m_AsyncCallbackPool.Spawn(true);
asyncCallback.m_Callback = callback;
asyncCallback.param1 = param1;
asyncCallback.param2 = param2;
asyncCallback.param3 = param3;
asyncParam.m_AsyncCallbackList.Add(asyncCallback);
//异步加载在AsyncLoadCoroutine 里执行
}
/// <summary>
/// 异步加载资源（仅仅是不需要实例化的资源，例如音频，图片等等）
/// </summary>
public void AsyncLoadResource(string path, OnAsyncObjFinish dealFinish, LoadResPriority priority, bool isSprite = false, object param1 = null, object param2 = null, object param3 = null, uint crc = 0)
{
if (crc == 0)
{
crc = Crc32.GetCrc32(path);
}
ResouceItem item = GetCacheResouceItem(crc);
if (item != null)
{
if (dealFinish != null)
{
dealFinish(path, item.m_Obj, param1, param2, param3);
}
return;
}
//判断是否在加载中
AsyncLoadResParam para = null;
if (!m_LoadingAssetDic.TryGetValue(crc, out para) || para == null)
{
para = m_AsyncLoadResParamPool.Spawn(true);
para.m_Crc = crc;
para.m_Path = path;
para.m_Sprite = isSprite;
para.m_Priority = priority;
m_LoadingAssetDic.Add(crc, para);
m_LoadingAssetList[(int)priority].Add(para);
}
//往回调列表里面加回调
AsyncCallBack callBack = m_AsyncCallBackPool.Spawn(true);
callBack.m_DealObjFinish = dealFinish;
callBack.m_Param1 = param1;
callBack.m_Param2 = param2;
callBack.m_Param3 = param3;
para.m_CallBackList.Add(callBack);
}
/// <summary>
/// 异步加载(实例化)
/// </summary>
/// <param name="path"></param>
/// <param name="resObj"></param>
/// <param name="callback"></param>
/// <param name="priority"></param>
public void AsyncLoadResource(string path, ResourceObject resObj, AsyncResObjFinishCallback callback, ResLoadPriority priority)
{
if (m_StartCoroutine == null)
{
Debug.LogError("ResourceManager.AsyncLoadResource 协程未启动,无法使用异步加载");
return;
}
WashOut();
ResourceItem item = GetCacheResourceItem(resObj.m_Crc);
//如果资源已经加载
if (item != null)
{
resObj.m_ResItem = item;
if (callback != null)
{
callback(path, resObj, resObj.param1, resObj.param2, resObj.param3);
}
return;
}
//判断是否正在加载
AsyncLoadResParam asyncParam = null;
if (!m_AsyncLoadDic.TryGetValue(resObj.m_Crc, out asyncParam))
{
//添加到正在加载
asyncParam = m_AsyncLoadResParamPool.Spawn(true);
asyncParam.m_Crc = resObj.m_Crc;
asyncParam.m_Path = path;
asyncParam.m_Priority = priority;
m_AsyncLoadDic.Add(resObj.m_Crc, asyncParam);
m_AsyncLoadingList[(int)priority].Add(asyncParam);
}
//缓存回调信息
AsyncCallback asyncCallback = m_AsyncCallbackPool.Spawn(true);
asyncCallback.m_ResCallback = callback;
asyncCallback.m_ResObj = resObj;
asyncParam.m_AsyncCallbackList.Add(asyncCallback);
//异步加载在AsyncLoadCoroutine 里执行
}
/// <summary>
/// 异步加载资源,仅仅是不需要实例化的资源，例如音频，图片等等
/// </summary>
public void AsyncLoadResource(string path, OnAsyncObjFinish dealFinish, LoadResPriority priority, uint crc = 0, object param1 = null, object param2 = null, object param3 = null)
{
if (crc == 0)
{
crc = CRC32.GetCRC32(path);
}
ResourceItem item = GetCancheResourceItem(crc);
if (item != null)
{
if (dealFinish != null)
{
dealFinish(path, item._obj, param1, param2, param3);
}
return;
}
//判断是否在加载中
AsyncLoadResParam param = null;
if (!_loadingAssetDic.TryGetValue(crc, out param) || param == null)
{
param = _asyncLoadResParamPool.Spawn(true);
param.crc = crc;
param.path = path;
param.priority = priority;
_loadingAssetDic.Add(crc, param);
_loadingAssetList[(int)priority].Add(param);
}
//往回调列表里面加回调
AsyncCallBack callBack = _asyncCallBackPool.Spawn(true);
callBack.dealFinish = dealFinish;
callBack.param1 = param1;
callBack.param2 = param2;
callBack.param3 = param3;
param.callBackList.Add(callBack);
}
/// <summary>
/// 异步加载
/// ?一直在运行
/// </summary>
/// <returns></returns>
IEnumerator AsyncLoadCor()
{
long lastYiledTime = System.DateTime.Now.Ticks;
List <AsyncCallBack> callBacks = null;
bool hadYiled = false;
while (true)
{
//上一次yield的时间
for (int i = 0; i < (int)LoadResPriority.RES_NUM; i++)
{
List <AsyncLoadResParam> loadingList = m_LoadingAssetList[i];
if (loadingList.Count <= 0)
{
continue;
}
AsyncLoadResParam loadingItem = loadingList[0];
loadingList.RemoveAt(0);
callBacks = loadingItem.m_CallBackList;
Object obj = null;
ResourceItem item = null;
#if UNITY_EDITOR
if (!m_LoadFromAssetBundle)
{
obj = LoadAssetByEditor <Object>(loadingItem.m_Path);
//模拟异步加载
yield return(new WaitForSeconds(0.5f));
item = AssetBundleManager.Instance.FindResourceItem(loadingItem.m_Crc);
}
#endif
if (obj == null)
{
item = AssetBundleManager.Instance.LoadResourceAssetBundle(loadingItem.m_Crc);
if (item != null && item.m_AssetBundle)
{
AssetBundleRequest abRequest = null;
if (loadingItem.m_Sprite)
{
abRequest = item.m_AssetBundle.LoadAssetAsync <Sprite>(item.m_AssetName);
}
else
{
abRequest = item.m_AssetBundle.LoadAssetAsync(item.m_AssetName);
}
yield return(abRequest);
if (abRequest.isDone)
{
obj = abRequest.asset;
}
lastYiledTime = System.DateTime.Now.Ticks;
}
}
CacheResource(loadingItem.m_Path, ref item, loadingItem.m_Crc, obj, callBacks.Count);
for (int j = 0; j < callBacks.Count; j++)
{
AsyncCallBack callBack = callBacks[j];
if (callBack != null && callBack.m_DealFinish != null && callBack.m_ResObj != null)
{
ResourceObj tempResObj = callBack.m_ResObj;
tempResObj.m_ResItem = item;
callBack.m_DealFinish(loadingItem.m_Path, tempResObj, tempResObj.m_Param1, tempResObj.m_Param2, tempResObj.m_Param3);
callBack.m_DealFinish = null;
tempResObj = null;
}
if (callBack != null && callBack.m_DealObjFinish != null)
{
callBack.m_DealObjFinish(loadingItem.m_Path, obj, callBack.m_Param1, callBack.m_Param2, callBack.m_Param3);
callBack.m_DealObjFinish = null;
}
callBack.Reset();
m_AsyncCallBackPool.Recycle(callBack);
}
obj = null;
callBacks.Clear();
m_LoadingAssetDic.Remove(loadingItem.m_Crc);
loadingItem.Reset();
m_AsyncLoadResParamPool.Recycle(loadingItem);
if (System.DateTime.Now.Ticks - lastYiledTime > MAXLOADRESTIME)
{
yield return(null);
lastYiledTime = System.DateTime.Now.Ticks;
hadYiled = true;
}
}
if (hadYiled || System.DateTime.Now.Ticks - lastYiledTime > MAXLOADRESTIME)
{
lastYiledTime = System.DateTime.Now.Ticks;
yield return(null);
}
}
}
/// <summary>
/// 异步加载资源
/// 顺序：每次加载待加载列表的第一个资源，按优先级高低依次加载
/// </summary>
IEnumerator LoadAssetAsync()
{
List <AsyncCallBack> callBackList = null;
long lastYiledTime = System.DateTime.Now.Ticks; //上一次yield时间
while (true)
{
for (int i = 0; i < (int)LoadPriority.RES_NUM; i++)
{
if (m_LoadAsyncResList[(int)LoadPriority.RES_HIGHT].Count > 0)
{
i = (int)LoadPriority.RES_HIGHT;
}
else if (m_LoadAsyncResList[(int)LoadPriority.RES_MIDDLE].Count > 0)
{
i = (int)LoadPriority.RES_MIDDLE;
}
List <AsyncLoadResParam> loadingList = m_LoadAsyncResList[i];
if (loadingList.Count <= 0)
{
continue;
}
AsyncLoadResParam loadingItem = loadingList[0];
loadingList.RemoveAt(0);
callBackList = loadingItem.callBackList;
Object obj = null;
ResourceItem item = null;
#if UNITY_EDITOR
if (!isLoadFromAssetBundle)
{
if (loadingItem.m_IsSprite)
{
obj = LoadAssetByEditor <Sprite>(loadingItem.m_Path);
}
else
{
obj = LoadAssetByEditor <Object>(loadingItem.m_Path);
}
//模拟异步加载
yield return(new WaitForSeconds(0.5f));
item = AssetBundleManager.Instance.GetResourceItem(loadingItem.m_Crc);
if (item == null)
{
item = new ResourceItem();
item.m_Crc = loadingItem.m_Crc;
}
}
#endif
if (obj == null)
{
item = AssetBundleManager.Instance.LoadResourceAssetBundle(loadingItem.m_Crc);
if (item != null && item.m_AssetBundle != null)
{
AssetBundleRequest abRequest = null;
if (loadingItem.m_IsSprite)
{
abRequest = item.m_AssetBundle.LoadAssetAsync <Sprite>(item.m_AssetName); //由于Object不能转成Spite类型
}
else
{
abRequest = item.m_AssetBundle.LoadAssetAsync <Object>(item.m_AssetName);
}
yield return(abRequest);
if (abRequest != null && abRequest.isDone)
{
obj = abRequest.asset;
}
}
}
//缓存资源项
CacheResourceItem(loadingItem.m_Path, ref item, item.m_Crc, obj, callBackList.Count);
//遍历执行所有回调
foreach (AsyncCallBack callBack in callBackList)
{
if (callBack != null)
{
if (callBack.resFinshCallBack != null && callBack.resObj != null)
{
ResourceObject tempObj = callBack.resObj;
tempObj.m_ResItem = item;
callBack.resFinshCallBack(loadingItem.m_Path, tempObj, tempObj.m_Param1, tempObj.m_Param2, tempObj.m_Param3);
callBack.resFinshCallBack = null;
tempObj = null;
}
if (callBack.finishCallBack != null)
{
callBack.finishCallBack(loadingItem.m_Path, obj, callBack.param1, callBack.param2, callBack.param3);
callBack.finishCallBack = null;
}
}
callBack.Reset();
m_AsyncCallBackPool.UnSpawn(callBack);
}
//清空资源
obj = null;
callBackList.Clear();
m_LoadingAssetDict.Remove(loadingItem.m_Crc);
loadingItem.Reset();
m_AsyncLoadResPool.UnSpawn(loadingItem);
if (System.DateTime.Now.Ticks - lastYiledTime > ConstConfig.MAX_LOADRESTIME)
{
yield return(null);
lastYiledTime = System.DateTime.Now.Ticks;
}
}
if (System.DateTime.Now.Ticks - lastYiledTime > ConstConfig.MAX_LOADRESTIME)
{
yield return(null);
lastYiledTime = System.DateTime.Now.Ticks;
}
}
}
/// <summary>
/// 异步加载
/// </summary>
IEnumerator AsyncLoader()
{
List <AsyncCallBack> callBackList = null;
//上一次yield的时间
long lastYiledTime = System.DateTime.Now.Ticks;
while (true)
{
bool haveYield = false;
for (int i = 0; i < (int)LoadResPriority.RES_NUM; i++)
{
List <AsyncLoadResParam> loadingList = _loadingAssetList[i];
if (loadingList.Count <= 0)
{
continue;
}
AsyncLoadResParam loadingItem = loadingList[0];
loadingList.RemoveAt(0);
callBackList = loadingItem.callBackList;
Object obj = null;
ResourceItem item = null;
#if UNITY_EDITOR
if (!_loadFromAssetBundle)
{
obj = LoadAssetByEditor <Object>(loadingItem.path);
//模拟异步加载
yield return(new WaitForSeconds(0.5f));
item = ABMgr.Ins.FingResourceItem(loadingItem.crc);
}
#endif
if (obj == null)
{
item = ABMgr.Ins.LoadResAssetBundle(loadingItem.crc);
if (item != null && item._assetBundle != null)
{
AssetBundleRequest abRequest = null;
if (loadingItem.isSprite)
{
abRequest = item._assetBundle.LoadAssetAsync <Sprite>(item._assetName);
}
else
{
abRequest = item._assetBundle.LoadAssetAsync(item._assetName);
}
yield return(abRequest);
if (abRequest.isDone)
{
obj = abRequest.asset;
}
lastYiledTime = System.DateTime.Now.Ticks;
}
}
CacheResource(loadingItem.path, ref item, loadingItem.crc, obj, callBackList.Count);
for (int j = 0; j < callBackList.Count; j++)
{
AsyncCallBack callBack = callBackList[i];
if (callBack != null && callBack.dealFinish != null)
{
callBack.dealFinish(loadingItem.path, obj, callBack.param1, callBack.param2, callBack.param3);
callBack.dealFinish = null;
}
callBack.Reset();
_asyncCallBackPool.Recycle(callBack);
}
obj = null;
callBackList.Clear();
_loadingAssetDic.Remove(loadingItem.crc);
loadingItem.Reset();
_asyncLoadResParamPool.Recycle(loadingItem);
if (System.DateTime.Now.Ticks - lastYiledTime > MAX_LOAD_RES_TIME)
{
yield return(null);
lastYiledTime = System.DateTime.Now.Ticks;
haveYield = true;
}
}
if (!haveYield || System.DateTime.Now.Ticks - lastYiledTime > MAX_LOAD_RES_TIME)
{
lastYiledTime = System.DateTime.Now.Ticks;
yield return(null);
}
}
}
IEnumerator AsyncLoadCoroutine()
{
List <AsyncCallback> callbackList = null;
long lastYieldTime = System.DateTime.Now.Ticks;
while (true)
{
for (int i = 0; i < (int)ResLoadPriority.RES_COUNT; i++)
{
if (m_AsyncLoadingList[(int)ResLoadPriority.RES_HIGHT].Count > 0)
{
i = (int)ResLoadPriority.RES_HIGHT;
}
else if (m_AsyncLoadingList[(int)ResLoadPriority.RES_NORMAL].Count > 0)
{
i = (int)ResLoadPriority.RES_NORMAL;
}
List <AsyncLoadResParam> paramList = m_AsyncLoadingList[i];
if (paramList.Count <= 0)
{
continue;
}
AsyncLoadResParam curParam = paramList[0];
paramList.RemoveAt(0);
callbackList = curParam.m_AsyncCallbackList;
ResourceItem item = null;
Object obj = null;
#if UNITY_EDITOR
if (!m_LoadFormAssetBundle)
{
if (curParam.m_IsSprite)
{
obj = LoadResourceByEditor <Sprite>(curParam.m_Path);
}
else
{
obj = LoadResourceByEditor <Object>(curParam.m_Path);
}
//模拟异步加载
yield return(new WaitForSeconds(0.5f));
item = AssetBundleManager.Instance.FindResourceItemByCrc(curParam.m_Crc);
//直接在编译器下读取 从AssetBundleManager中是取不到的
if (item == null)
{
item = new ResourceItem();
item.m_Crc = curParam.m_Crc;
}
}
#endif
if (obj == null)
{
item = AssetBundleManager.Instance.LoadResourceItem(curParam.m_Crc);
if (item != null && item.m_AssetBundle != null)
{
//执行异步加载
AssetBundleRequest request;
if (curParam.m_IsSprite)
{
request = item.m_AssetBundle.LoadAssetAsync <Sprite>(item.m_AssetName);
}
else
{
request = item.m_AssetBundle.LoadAssetAsync(item.m_AssetName);
}
yield return(request);
//加载完成
if (request.isDone)
{
obj = request.asset;
lastYieldTime = System.DateTime.Now.Ticks;
}
}
}
//缓存资源,可能有多个请求加载资源,所以计数需要+callbackList.Count
CacheResource(curParam.m_Path, ref item, obj, callbackList.Count);
for (int j = 0; j < callbackList.Count; j++)
{
AsyncCallback callback = callbackList[j];
//实例化
if (callback != null && callback.m_ResObj != null && callback.m_ResCallback != null)
{
callback.m_ResObj.m_ResItem = item;
callback.m_ResCallback(curParam.m_Path, callback.m_ResObj, callback.m_ResObj.param1, callback.m_ResObj.param2, callback.m_ResObj.param3);
callback.m_ResCallback = null;
}
//资源加载
if (callback != null && callback.m_Callback != null)
{
callback.m_Callback(curParam.m_Path, obj, callback.param1, callback.param2, callback.param3);
callback.m_Callback = null;
}
m_AsyncCallbackPool.Recycle(callback);
}
//清空变量
obj = null;
m_AsyncLoadDic.Remove(curParam.m_Crc);//从正在加载列表移除
callbackList.Clear();
m_AsyncLoadResParamPool.Recycle(curParam);
if (System.DateTime.Now.Ticks - lastYieldTime > MAXLOADRESETIME)
{
yield return(null);
lastYieldTime = System.DateTime.Now.Ticks;
}
}
if (System.DateTime.Now.Ticks - lastYieldTime > MAXLOADRESETIME)
{
lastYieldTime = System.DateTime.Now.Ticks;
yield return(null);
}
}
}
