/// <summary>
/// 异步加载
/// </summary>
/// <param name="path">路径</param>
/// <param name="deaFinish">资源加载完成回调</param>
/// <param name="priority">加载优先级</param>
/// <param name="setSceneParent">是否设置Parent为SceneTrs</param>
/// <param name="param1"></param>
/// <param name="param2"></param>
/// <param name="param3"></param>
/// <param name="bClear">跳场景是否清除</param>
public long InstantiateObjectAsync(string path, OnAsyncObjFinish deaFinish, LoadResPriority priority, bool setSceneParent = false,
object param1 = null, object param2 = null, object param3 = null, bool bClear = true)
{
if (string.IsNullOrEmpty(path))
{
return(0);
}
uint crc = CRC32.GetCRC32(path);
TResouceObj resObj = GetObjectFromPool(crc);
if (resObj != null)
{
if (setSceneParent)
{
resObj.CloneObj.transform.SetParent(SceneTrs, false);
}
deaFinish?.Invoke(path, resObj.CloneObj, param1, param2, param3);
return(resObj.Guid);
}
long guid = ResourcesManager.Instance.CreatGuid();
resObj = mResouceObjPool.Allocate();
resObj.Crc = crc;
resObj.SetSceneParent = setSceneParent;
resObj.Clear = bClear;
resObj.DealFinish = deaFinish;
resObj.Param1 = param1;
resObj.Param2 = param2;
resObj.Param3 = param3;
//调用ResouceManager的异步加载接口
ResourcesManager.Instance.AsyncLoadResouce(path, resObj, OnLoadResouceObjFinish, priority);
return(guid);
}
public void TestChangeImageSpriteAsync2(string path, Image image, LoadResPriority priority,
bool isSetNativeSize = false)
{
if (image == null)
{
return;
}
ResourceManager.Instance.AsyncLoadResource(path, (s, o, list) =>
{
if (o != null)
{
Sprite sp = o as Sprite;
Image img = list[0] as Image;
bool isSetNative = (bool)list[1];
if (img.sprite != null)
{
img.sprite = null;
}
img.sprite = sp;
if (isSetNative)
{
img.SetNativeSize();
}
}
}, priority, true, image, isSetNativeSize);
}
/// <summary>
/// ->objecmanager
/// </summary>
/// <param name="path"></param>
/// <param name="objectItem"></param>
/// <param name="innerCallBack"></param>
/// <param name="priority"></param>
public void AsyncLoadResource(string path, ObjectItem objectItem, OnAsyncPrimitiveAssetFinish innerCallBack,
LoadResPriority priority, bool isSprite = false)
{
AssetItem assetItem = GetCacheAssetItem(objectItem.Crc);
if (assetItem != null)
{
objectItem.PrimitiveAssetItem = assetItem;
innerCallBack?.Invoke(path, objectItem);
return;
}
AsyncLoadAssetParam asyncLoadAssetParam = null;
if (!asyncLoadAssetParamDic.TryGetValue(objectItem.Crc, out asyncLoadAssetParam))
{
asyncLoadAssetParam = asyncLoadResParamPackPool.Spawn();
asyncLoadAssetParam.Crc = objectItem.Crc;
asyncLoadAssetParam.Path = path;
asyncLoadAssetParam.isSprite = isSprite;
asyncLoadAssetParam.Priority = priority;
asyncLoadAssetParamDic.Add(objectItem.Crc, asyncLoadAssetParam);
loadingAssetLists[(int)priority].Add(asyncLoadAssetParam);
}
AsyncCallBackPack callBackPack = asyncCallBackPackPool.Spawn();
callBackPack.PrimitiveAssetFinish = innerCallBack;
callBackPack.ObjectItem = objectItem;
asyncLoadAssetParam.CallBackPacks.Add(callBackPack);
}
public void Reset()
{
m_Crc = 0;
m_Path = "";
m_Priority = LoadResPriority.RES_SLOW;
isSprite = false;
}
/// <summary>
/// 异步获得对象
/// </summary>
/// <param name="path">对象路径</param>
/// <param name="onFinish">获得回调</param>
/// <param name="priority">加载优先级</param>
/// <param name="setCreateNode">设置创建节点</param>
/// <param name="paramValues">回调参数</param>
public long SpawnAsync(string path, OnAsyncObjFinish onFinish,
LoadResPriority priority = LoadResPriority.Res_Middle,
bool setCreateNode = false, params object[] paramValues)
{
return(ObjManager.Instance.InstantiateObjectAsyncAsset(path, GetHashCode(), onFinish, priority,
setCreateNode, paramValues));
}
//数据重置
public void Reset()
{
m_crc = 0;
m_resPath = "";
m_loadResPriority = LoadResPriority.RES_LOAD_LEVEL_LOW;
m_isSprite = false;
m_asyncCallBacks.Clear();
}
public void Reset()
{
CallbackList.Clear();
Crc = 0;
Path = "";
IsSprite = false;
Priority = LoadResPriority.RES_SLOW;
}
public void Reset()
{
m_CallBackList.Clear();
m_Crc = 0;
m_Path = string.Empty;
m_Sprite = false;
m_Priority = LoadResPriority.RES_SLOW;
}
public void Reset()
{
m_CallBackList.Clear();
m_Crc = 0;
m_Path = "";
m_Sprite = false;
m_Priority = LoadResPriority.RES_LOW;
}
public void Reset()
{
CallBackPacks.Clear();
Crc = 0;
Path = "";
isSprite = false;
Priority = LoadResPriority.RES_LOW;
}
public void Reset()
{
crc = 0;
path = "";
isSprite = false;
priority = LoadResPriority.RES_SLOW;
callBackList.Clear();
}
public void Reset()
{
CallBackList.Clear();
Crc = 0;
Path = string.Empty;
ResType = typeof(UnityEngine.Object);
Priority = LoadResPriority.Res_Slow;
LoadMode = LoadResMode.Resource;
}
public virtual void Init(ResLoadInfo resLoadInfo)
{
mResPath = resLoadInfo.mResPath;
mLoadRePriority = resLoadInfo.loadResPriority;
DestroyCache = resLoadInfo.DestroyCache;
isSprite = resLoadInfo.mIsSprite;
resItem = new ResItem();
resItem.mCrc = Crc32.GetCrc32(mResPath);
mListener = resLoadInfo.mListener;
mResState = ResState.Waiting;
}
/// <summary>
/// 异步加载资源 (仅仅是不需要实例化的资源)
/// </summary>
private void AsyncLoadResource <T>(string path, OnAsyncObjFinish onFinish, uint crc = 0, ResLoadMode mode = ResLoadMode.Null,
LoadResPriority priority = LoadResPriority.Res_Slow, params object[] paramValues)
where T : UnityEngine.Object
{
if (mode == ResLoadMode.Null)
{
mode = LoadMode(ref path);
}
if (crc == 0)
{
crc = Crc32.GetCrc32(path);
}
ResItem item = GetCacheResouceItem(crc);
if (item != null)
{
if (onFinish != null)
{
onFinish(path, item.Obj, paramValues);
}
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;
param.ResType = typeof(T);
param.LoadMode = JudgeLoadMode(mode);
_LoadingAssetDic.Add(crc, param);
_LoadingAssetList[(int)priority].Add(param);
}
//回调列表里面加回调
AsyncCallBack callBack = _AsyncCallBackPool.Spawn(true);
callBack.OnObjFinish = onFinish;
if (paramValues != null && paramValues.Length > 0)
{
foreach (object value in paramValues)
{
callBack.Params.Add(value);
}
}
param.CallBackList.Add(callBack);
}
/// <summary>
/// 异步对象加载
/// </summary>
/// <param UIName="path"></param>
/// <param UIName="fealFinish"></param>
/// <param UIName="priority"></param>
/// <param UIName="setSceneObject"></param>
/// <param UIName="param1"></param>
/// <param UIName="param2"></param>
/// <param UIName="param3"></param>
/// <param UIName="clearChangeScene"></param>
private long InstantiateObjectAsync(string path, OnAsyncObjFinish onFinish, LoadResPriority priority,
bool setCreateNode = false, params object[] paramValues)
{
if (string.IsNullOrEmpty(path))
{
return(0);
}
ResLoadMode mode = ResManager.Instance.LoadMode(ref path);
uint crc = Crc32.GetCrc32(path);
return(InstantiateObjectAsync(path, crc, mode, onFinish, priority, setCreateNode, paramValues));
}
/// <summary>
/// 异步加载资源 (仅仅是不需要实例化的资源)
/// </summary>
internal void AsyncLoadResourceAsset <T>(string path, OnAsyncObjFinish onFinish, int assetHelperHash,
LoadResPriority priority = LoadResPriority.Res_Slow, params object[] paramValues)
where T : UnityEngine.Object
{
if (!string.IsNullOrEmpty(path))
{
ResLoadMode mode = LoadMode(ref path);
uint crc = Crc32.GetCrc32(path);
AddResAsset(crc, assetHelperHash);
AsyncLoadResource <T>(path, onFinish, crc, mode, priority, paramValues);
}
else
{
Debug.LogError("路径为null");
}
}
public static ObjLoadInfo Allocate(ResFromType resType, string assetPath, Transform ObjParentTrans,
bool mclear = false, LoadResPriority loadResPriority = LoadResPriority.RES_NUM,
Action <bool, ResInfo> loadResCall = null, Action <bool, ResObject> loadObjCall = null)
{
ObjLoadInfo objLoadInfo = SafeObjectPool <ObjLoadInfo> .Instance.Allocate();
objLoadInfo.mCRC = Crc32.GetCrc32(assetPath);
objLoadInfo.mResFromType = resType;
objLoadInfo.ObjParentTrans = ObjParentTrans;
objLoadInfo.mClear = mclear;
objLoadInfo.mResPath = assetPath;
objLoadInfo.loadResPriority = loadResPriority;
objLoadInfo.loadResCall = loadResCall;
objLoadInfo.loadObjCall = loadObjCall;
return(objLoadInfo);
}
/// <summary>
/// 这里的mListen与调用loader传的参数并不相同
/// </summary>
/// <param name="resType"></param>
/// <param name="assetPath"></param>
/// <param name="isSprite"></param>
/// <param name="mListen"></param>
/// <returns></returns>
public static ResLoadInfo Allocate(ResFromType resType, string assetPath, bool isSprite,
Action <bool, ResInfo> mListen = null, Action <bool, ResInfo> mRealListener = null, bool DestroyCache = false,
LoadResPriority loadResPriority = LoadResPriority.RES_NUM)
{
ResLoadInfo resLoadInfo = SafeObjectPool <ResLoadInfo> .Instance.Allocate();
resLoadInfo.mResPath = assetPath;
resLoadInfo.mResFromType = resType;
resLoadInfo.mListener = mListen;
resLoadInfo.mIsSprite = isSprite;
resLoadInfo.DestroyCache = DestroyCache;
resLoadInfo.loadResPriority = loadResPriority;
resLoadInfo.mCRC = Crc32.GetCrc32(assetPath);
resLoadInfo.mRealListener = mRealListener;
return(resLoadInfo);
}
/// <summary>
/// 异步资源加载，外部直接调用，（仅仅加载不需要实例化的资源，例如Texture和音频之类的）
/// </summary>
public void AsyncLoadResource(string path, OnAsyncFinish dealFinish, LoadResPriority priority, bool isSprite = false, uint crc = 0, params object[] paramList)
{
if (crc == 0)
{
crc = Crc32.GetCrc32(path);
}
AssetBundleInfo abInfo = GetCacheAssetBundleInfo(crc);
if (abInfo != null)
{
dealFinish?.Invoke(path, abInfo.m_Obj, paramList);
return;
}
//判断是否在加载中
AsyncLoadResUnit unit = null;
//没有找到这个异步加载单位，或者这个异步加载单位是空
if (!m_LoadingAssetDic.TryGetValue(crc, out unit) || unit == null)
{
unit = m_AsyncLoadResParamPool.Spawn(true);
unit.m_Crc = crc;
unit.m_Path = path;
unit.m_Sprite = isSprite;
unit.m_Priority = priority;
m_LoadingAssetDic.Add(crc, unit); //添加到正在异步加载的资源dic中
m_loadingAssetList[(int)priority].Add(unit); //按照加载优先级，添加到对应的正在异步加载的资源列表中
}
//往回调列表里面添加回调
AsynCallBack callBack = m_AsynCallBackPool.Spawn(true);
callBack.m_DealFinish = dealFinish;
callBack.m_Params = paramList;
//往这个异步加载单位的回调列表中添加一个回调
//可能多个地方加载同一份资源，这样做只加载一次资源，
//加载完了后，根据回调列表一次返回这份资源
unit.m_CallBackList.Add(callBack);
}
/// <summary>
/// 针对ObjectManager的异步加载接口
/// </summary>
/// <param UIName="path"></param>
/// <param UIName="resObj"></param>
/// <param UIName="dealFinish"></param>
/// <param UIName="priority"></param>
internal void AsyncLoadResource(string path, ResLoadMode mode, ResouceObj resObj, OnAsyncFinish dealFinish,
LoadResPriority priority)
{
ResItem item = GetCacheResouceItem(resObj.Crc);
if (item != null)
{
resObj.ResItem = item;
if (dealFinish != null)
{
dealFinish(path, resObj);
}
return;
}
//判断是否在加载中
AsyncLoadResParam param = null;
if (!_LoadingAssetDic.TryGetValue(resObj.Crc, out param) || param == null)
{
param = _AsyncLoadResParamPool.Spawn(true);
param.Crc = resObj.Crc;
if (mode == ResLoadMode.Ab)
{
param.LoadMode = LoadResMode.AssetBundle;
}
else
{
param.LoadMode = LoadResMode.Resource;
}
param.Path = path;
param.Priority = priority;
_LoadingAssetDic.Add(resObj.Crc, param);
_LoadingAssetList[(int)priority].Add(param);
}
//回调列表里面加回调
AsyncCallBack callBack = _AsyncCallBackPool.Spawn(true);
callBack.OnFinish = dealFinish;
callBack.ResObj = resObj;
param.CallBackList.Add(callBack);
}
/// <summary>
/// 异步加载
/// </summary>
/// <param name="path"></param>
/// <param name="fealFinish"></param>
/// <param name="priority"></param>
/// <param name="setSceneObj"></param>
/// <param name="param1"></param>
/// <param name="param2"></param>
/// <param name="param3"></param>
/// <param name="bClear"></param>
public long InstantiateObjectAsync(string path, OnAsyncFinish dealFinish, LoadResPriority priority, bool setSceneObj = false,
bool bClear = true, params object[] paramList)
{
if (string.IsNullOrEmpty(path))
{
return(0);
}
uint crc = Crc32.GetCrc32(path);
//从缓存池获取
ResourceObj resObj = GetObjectFromPool(crc);
//从缓存中拿到了，直接返回
if (resObj != null)
{
if (setSceneObj)
{
resObj.m_CloneObj.transform.SetParent(SceneTrs, false);
}
if (dealFinish != null)
{
dealFinish(path, resObj.m_CloneObj, paramList);
}
return(resObj.m_Guid);
}
//异步加载的GUID
long guid = ResourceManager.Instance.CreateGuid();
//缓存中没有，异步加载
resObj = m_ResObjClassPool.Spawn(true); //new一个对象
resObj.m_Crc = crc;
resObj.m_SetSceneParent = setSceneObj;
resObj.m_bClear = bClear;
resObj.m_DealFinish = dealFinish;
resObj.m_Params = paramList;
//调用ResourceManager的异步加载接口
ResourceManager.Instance.AsyncLoadResource(path, resObj, OnLoadResObjFinish, priority);
return(guid);
}
/// <summary>
/// 异步对象加载
/// </summary>
public long InstantiateObjectAsync(string path, OnAsyncObjFinish dealFinish, LoadResPriority priority,
bool setSceneObject = false, object param1 = null, object param2 = null, object param3 = null,
bool bClear = true)
{
if (string.IsNullOrEmpty(path))
{
return(0);
}
uint crc = CRC32.GetCRC32(path);
ResourceObj resObj = GetObjectFromPool(crc);
if (resObj != null)
{
if (setSceneObject)
{
resObj.m_CloneObj.transform.SetParent(SceneTrs, false);
}
if (dealFinish != null)
{
dealFinish(path, resObj.m_CloneObj, param1, param2, param3);
}
return(resObj.m_Guid);
}
long guid = ResourceManager.Instance.CreateGUID();
resObj = m_ResourceObjClassPool.Spawn(true);
resObj.m_Crc = crc;
resObj.m_setSceneParent = setSceneObject;
resObj.m_bClear = bClear;
resObj.m_DealFnish = dealFinish;
resObj.m_param1 = param1;
resObj.m_param2 = param2;
resObj.m_param3 = param3;
//调用ResourceManager异步加载接口
ResourceManager.Instance.AsyncLoadResource(path, resObj, OnLoadResourceObjFinish, priority);
return(guid);
}
/// <summary>
/// 异步加载资源（仅仅是不需要实例化的资源，例如texture，音频等等）
/// </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);
}
ResourceItem item = GetCacheResourceItem(crc);
if (item != null)
{
if (dealFinish != null)
{
dealFinish(path, item.m_Obj, param1, param2, param3);
}
return;
}
//判断是否在加载中
AsynvLoadResParam para = null;
if (!m_LodingAssetDic.TryGetValue(crc, out para) || para == null)
{
para = m_AsyncLoadResParamPool.Spawn(true);
para.m_Crc = crc;
para.m_Path = path;
para.m_SpriteBoo = isSprite;
para.m_Priority = priority;
m_LodingAssetDic.Add(crc, para);
m_LoadingAssetList[(int)priority].Add(para);
}
//往回调列表里加回调
//这里加的是不针对的回调
ResMgrAsyncCallBack callBack = m_AsyncCallBackPool.Spawn(true);
callBack.m_ResDealFinish = dealFinish;
callBack.m_Param1 = param1;
callBack.m_Param2 = param2;
callBack.m_Param3 = param3;
para.m_CallBackList.Add(callBack);
}
/// <summary>
/// 异步加载资源（仅仅是不需要实例化的资源，如音频，图片等等）
/// </summary>
public void AsynLoadResource(string path, OnAsyncObjFinish dealFinish, LoadResPriority priority, object p1 = null, object p2 = null, object p3 = null, uint crc = 0)
{
if (crc == 0)
{
crc = CRC32.GetCRC32(path);
}
ResourceItem item = GetCacheResourrceItem(crc);
if (item != null)
{
if (dealFinish != null)
{
dealFinish(path, item.m_Obj, p1, p2, p3);
}
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_Priority = priority;
m_LoadingAssetDic.Add(crc, para);
m_LoadingAssetList[(int)priority].Add(para);
}
//往回调列表里面添加回调
AsyncCallBack callBack = m_AsyncCallBackPool.Spawn(true);
callBack.m_DealFinish = dealFinish;
callBack.m_Param1 = p1;
callBack.m_Param2 = p2;
callBack.m_Param3 = p3;
para.m_CallBackList.Add(callBack);
}
/// <summary>
/// 异步加载资源（仅仅是不需要实例化的资源，例如音频，图片等）
/// </summary>
/// <param name="path"></param>
/// <param name="dealFinish"></param>
/// <param name="priority"></param>
/// <param name="param1"></param>
/// <param name="param2"></param>
/// <param name="param3"></param>
/// <param name="crc"></param>
public void AsyncLoadResouce(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);
}
TResouceItem item = GetCacheResouceItem(crc);
if (item != null)
{
if (dealFinish != null)
{
dealFinish(path, item.Obj, param1, param2, param3);
}
return;
}
//判断是否在加载中
TAsyncLoadResParam para = null;
if (!mLoadingAssetDic.TryGetValue(crc, out para) || para == null)
{
para = mAsyncLoadResParamPool.Allocate();
para.Crc = crc;
para.Path = path;
para.IsSprite = isSprite;
para.Priority = priority;
mLoadingAssetDic.Add(crc, para);
mLoadingAssetList[(int)priority].Add(para);
}
//往回调列表里面加回调
TAsyncCallBack callBack = mAsyncCallBackPool.Allocate();
callBack.DealObjFinish = dealFinish;
callBack.Param1 = param1;
callBack.Param2 = param2;
callBack.Param3 = param3;
para.CallbackList.Add(callBack);
}
public void AsyncLoadResource(string path, OnLoadResFinish dealFinish, LoadResPriority priority,
object param1 = null, object param2 = null, object param3 = null, uint crc = 0)
{
if (crc == 0)
{
crc = Crc32.GetCrc32(path);
}
var item = GetCacheResourceItem(crc);
if (item != null)
{
dealFinish?.Invoke(path, item.m_Obj, param1, param2, param3);
return;
}
//判断是否在加载中
AsyncLoadResInfo para = null;
if (!m_LoadingAssetDic.TryGetValue(crc, out para) || para == null)
{
para = m_AsyncLoadResParamPool.Spawn();
para.m_Crc = crc;
para.m_Path = path;
para.m_Priority = priority;
m_LoadingAssetDic.Add(crc, para);
m_LoadingAssetList[(int)priority].Add(para);
}
//往回调列表里面加回调
var callBack = m_AsyncCallBackPool.Spawn();
callBack.m_DealFinish = dealFinish;
callBack.m_Param1 = param1;
callBack.m_Param2 = param2;
callBack.m_Param3 = param3;
para.m_CallBackList.Add(callBack);
}
/// <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>
/// <typeparam name="T"></typeparam>
/// <param name="resType"></param>
/// <param name="assetPath"></param>
/// <param name="loadFinish"></param>
/// <param name="isSprite"></param>
/// <param name="DestroyCache">当ResLoader被销毁时是否从内存中释放</param>
/// <param name="loadResPriority">加载的优先级</param>
public void LoadAsync <T>(ResFromType resType, string assetPath, System.Action <bool, ResInfo> loadFinish,
bool isSprite = false, bool DestroyCache = false, LoadResPriority loadResPriority = LoadResPriority.RES_NUM)
where T : Object
{
if (CheckNoCanLoad())
{
AFLogger.e("此Loader已经被释放,请注意!");
return;
}
ResLoadInfo resLoadInfo = ResLoadInfo.Allocate(resType, assetPath, isSprite, AsyncResCallBack, loadFinish, DestroyCache);
//添加回调函数
if (mAsyncLoadingResDic.ContainsKey(resLoadInfo.mResPath))
{
mAsyncLoadingResDic[resLoadInfo.mResPath].Add(resLoadInfo);
}
else
{
AsyncCount += 1;
mAsyncLoadingResDic.AddValue(resLoadInfo.mResPath, resLoadInfo);
ResManager.Instance.LoadAsync(resLoadInfo);
}
}
/// <summary>
/// 异步加载Prefab
/// </summary>
/// <param name="resType"></param>
/// <param name="assetPath"></param>
/// <param name="parTrans"></param>
/// <param name="loadObjFinish"></param>
/// <param name="loadResPriority"></param>
/// <param name="bClear"></param>
public void InstantiateObjectASync(ResFromType resType, string assetPath, System.Action <bool, ResObject> loadObjFinish,
Transform parTrans = null, LoadResPriority loadResPriority = LoadResPriority.RES_NUM,
bool bClear = true)
{
if (CheckNoCanLoad())
{
AFLogger.e("此Loader已经被释放,请注意!");
return;
}
ObjLoadInfo objLoadInfo = ObjLoadInfo.Allocate(resType, assetPath, parTrans, bClear, loadResPriority,
AsyncObjCallBack, loadObjFinish);
if (mAsyncLoadingObjDic.ContainsKey(assetPath))
{
mAsyncLoadingObjDic[assetPath].Add(objLoadInfo);
}
else
{
AsyncCount += 1;
mAsyncLoadingObjDic.AddValue(assetPath, objLoadInfo);
ResManager.Instance.InstantiateObjectASync(objLoadInfo);
}
}
/// <summary>
/// 针对ObjectManager的异步加载接口
/// </summary>
public void AsyncLoadResource(string path, ResourceObj resObj, OnAsyncFinish dealFinish,
LoadResPriority priority)
{
ResourceItem item = GetCacheResourrceItem(resObj.m_Crc);
if (item != null)
{
resObj.m_ResItem = item;
if (dealFinish != null)
{
dealFinish(path, resObj);
}
}
//判断是否在加载中
AsyncLoadResParam para = null;
if (!m_LoadingAssetDic.TryGetValue(resObj.m_Crc, out para) || para == null)
{
para = m_AsyncLoadResParamPool.Spawn(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.Spawn(true);
callBack.m_DealFinish = dealFinish;
callBack.m_ResObj = resObj;
para.m_CallBackList.Add(callBack);
}
