public void Reset()
{
AssetFinish = null;
PrimitiveAssetFinish = null;
ObjectItem = null;
paramList = null;
}
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);
}
public void Reset()
{
m_DealFinish = null;
m_DealResObjFinish = null;
m_Params = null;
m_ResObj = null;
}
public void Reset()
{
m_ObjDealFinish = null;
m_ResObj = null;
m_ResDealFinish = null;
m_Param1 = m_Param2 = m_Param3 = null;
}
/// <summary>
/// 针对ObjectManager异步加载的接口
/// </summary>
/// <param name="path"></param>
/// <param name="resObj"></param>
/// <param name="dealfinish"></param>
/// <param name="priority"></param>
public void AsyncLoadResouce(string path, TResouceObj resObj, OnAsyncFinish dealfinish, LoadResPriority priority)
{
TResouceItem item = GetCacheResouceItem(resObj.Crc);
if (item != null)
{
resObj.ResItem = item;
dealfinish?.Invoke(path, resObj);
}
//判断是否在加载中
TAsyncLoadResParam para = null;
if (!mLoadingAssetDic.TryGetValue(resObj.Crc, out para) || para == null)
{
para = mAsyncLoadResParamPool.Allocate();
para.Crc = resObj.Crc;
para.Path = path;
para.Priority = priority;
mLoadingAssetDic.Add(resObj.Crc, para);
mLoadingAssetList[(int)priority].Add(para);
}
//往回调列表里面加回调
TAsyncCallBack callBack = mAsyncCallBackPool.Allocate();
callBack.DealFinish = dealfinish;
callBack.ResObj = resObj;
para.CallbackList.Add(callBack);
}
public void Reset()
{
OnObjFinish = null;
OnFinish = null;
Params.Clear();
ResObj = null;
}
public void Reset()
{
m_DealObjFinish = null;
m_DealFinish = null;
m_ResObj = null;
m_Param1 = null;
m_Param2 = null;
m_Param3 = null;
}
public void Reset()
{
DealObjFinish = null;
DealFinish = null;
Param1 = null;
Param2 = null;
Param3 = null;
}
//重置
public void Reset()
{
m_Crc = 0;
m_CloneObj = null;
m_bClear = false;
m_Guid = 0;
m_Already = false;
m_SetSceneParent = false;
m_DealFinish = null;
m_Params = null;
m_offlineData = null;
}
public void Reset()
{
Crc = 0;
CloneObj = null;
isClear = true;
Guid = 0;
PrimitiveAssetItem = null;
isAlreadyRelease = false;
IsSetSceneParent = false;
outerCallBack = null;
paramList = null;
OfflineData = null;
}
/// <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>
/// 异步加载
/// </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);
}
public void AsyncLoadResource(string path, OnAsyncFinish cb, LoadResPriority priority, bool isSprite = false,
uint crc = 0,
params object[] paramList)
{
if (crc == 0)
{
crc = CRC32.GetCRC32(path);
}
AssetItem item = GetCacheAssetItem(crc);
if (item != null)
{
cb?.Invoke(path, item.AssetObject, paramList);
return;
}
AsyncLoadAssetParam asyncLoadAssetParam = null;
if (!asyncLoadAssetParamDic.TryGetValue(crc, out asyncLoadAssetParam))
{
asyncLoadAssetParam = asyncLoadResParamPackPool.Spawn();
asyncLoadAssetParam.Crc = crc;
asyncLoadAssetParam.Path = path;
asyncLoadAssetParam.isSprite = isSprite;
asyncLoadAssetParam.Priority = priority;
asyncLoadAssetParamDic.Add(crc, asyncLoadAssetParam);
loadingAssetLists[(int)priority].Add(asyncLoadAssetParam);
}
AsyncCallBackPack callBackPack = asyncCallBackPackPool.Spawn();
callBackPack.AssetFinish = cb;
callBackPack.paramList = paramList;
asyncLoadAssetParam.CallBackPacks.Add(callBackPack);
}
public void AsyncLoadResource(string path, OnAsyncFinish cb, LoadResPriority priority, bool isSprite = false,
params object[] paramList
)
{
AsyncLoadResource(path, cb, priority, isSprite, 0, paramList);
}
/// <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);
}
public long AsyncInstantiateObject(string path, OnAsyncFinish outerCallBack, LoadResPriority priority,
bool isSetSceneTrans = false, bool isClear = true, params object[] paramList)
{
if (string.IsNullOrEmpty(path))
{
return(0);
}
uint crc = CRC32.GetCRC32(path);
ObjectItem objectItem = GetCacheObjectItemFromPoolDic(crc);
if (objectItem != null)
{
if (isSetSceneTrans)
{
objectItem.CloneObj.transform.SetParent(SceneTrans, false);
}
outerCallBack?.Invoke(path, objectItem.CloneObj, paramList);
return(objectItem.Guid);
}
objectItem = objectItemNativePool.Spawn();
if (objectItem == null)
{
Debug.LogError("null");
}
long guid = ResourceManager.Instance.CreateGuid();
objectItem.Crc = crc;
objectItem.IsSetSceneParent = isSetSceneTrans;
objectItem.isClear = isClear;
objectItem.outerCallBack = outerCallBack;
objectItem.paramList = paramList;
//调用ResourceManager异步加载接口
ResourceManager.Instance.AsyncLoadResource(path, objectItem, (_path, item, plist) =>
{
if (item == null)
{
return;
}
if (item.PrimitiveAssetItem.AssetObject == null)
{
#if UNITY_EDITOR
Debug.LogError("异步资源加载为空" + _path);
#endif
}
else
{
//实例化
item.CloneObj = Object.Instantiate(item.PrimitiveAssetItem.AssetObject) as GameObject;
objectItem.OfflineData = item.CloneObj.GetComponent <OfflineData.OfflineData>();
}
//加载完成移除
if (asyncLoadingObjectDic.ContainsKey(item.Guid))
{
asyncLoadingObjectDic.Remove(item.Guid);
}
if (item.CloneObj != null && item.IsSetSceneParent)
{
item.CloneObj.transform.SetParent(SceneTrans);
}
if (item.outerCallBack != null)
{
if (item.CloneObj != null)
{
int _guid = item.CloneObj.GetInstanceID();
if (!ObjectItemsInstanceTempDic.ContainsKey(_guid))
{
ObjectItemsInstanceTempDic.Add(_guid, item);
}
}
item.outerCallBack?.Invoke(_path, item.CloneObj, plist);
}
}, priority);
return(guid);
}
