public static GameObject InstantiateObjectSync(ObjLoadInfo objLoadInfo)
{
//从对象池拿取对象
ResObject resObject = ResManager.Instance.GetObjectFromPool(objLoadInfo.mCRC);
//对象池没有
if (resObject == null)
{
//ResManager提供加载方法
resObject = ResourceLoader.Instance.LoadResSyncForObj(objLoadInfo);
if (resObject.mObj != null)
{
if (objLoadInfo.ObjParentTrans == null)
{
resObject.mCloneObj = GameObject.Instantiate(resObject.mObj) as GameObject;
}
else
{
resObject.mCloneObj = GameObject.Instantiate(resObject.mObj, objLoadInfo.ObjParentTrans) as GameObject;
}
ResManager.Instance.CacheResObj(resObject);
}
}
else
{
resObject.mCloneObj.transform.SetParent(objLoadInfo.ObjParentTrans);
ResManager.Instance.CacheResObj(resObject);
}
return(resObject.mCloneObj);
}
/// <summary>
/// 清除某个资源在对象池中所有的对象
/// </summary>
/// <param name="crc"></param>
public void ClearPoolObject(uint crc)
{
List <ResObject> st = null;
if (!mObjectPoolDic.TryGetValue(crc, out st) || st == null)
{
return;
}
for (int i = st.Count - 1; i >= 0; i--)
{
ResObject resObj = st[i];
if (resObj.mClear)
{
st.Remove(resObj);
int tempID = resObj.mCloneObj.GetInstanceID();
GameObject.Destroy(resObj.mCloneObj);
resObj.Recycle2Cache();
mResouceObjDic.Remove(tempID);
SafeObjectPool <ResObject> .Instance.Recycle(resObj);
}
}
if (st.Count <= 0)
{
mObjectPoolDic.Remove(crc);
}
}
public void LoadObjCallBack(bool result, ResObject resObject)
{
if (result)
{
Obj.Add(resObject.mCloneObj);
}
}
/// <summary>
/// 从对象池取对象
/// </summary>
/// <param name="crc"></param>
/// <returns></returns>
public ResObject GetObjectFromPool(uint crc)
{
List <ResObject> st = null;
if (mObjectPoolDic.TryGetValue(crc, out st) && st != null && st.Count > 0)
{
ResObject resObj = st[0];
resObj.Retain();
st.RemoveAt(0);
GameObject obj = resObj.mCloneObj;
if (!System.Object.ReferenceEquals(obj, null))
{
resObj.IsRecyclePool = false;
#if UNITY_EDITOR
if (obj.name.EndsWith("(Recycle)"))
{
obj.name = obj.name.Replace("(Recycle)", "");
}
#endif
}
return(resObj);
}
return(null);
}
/// <summary>
/// 清空对象池
/// </summary>
public void ClearCache()
{
List <uint> tempList = new List <uint>();
foreach (uint key in mObjectPoolDic.Keys)
{
List <ResObject> st = mObjectPoolDic[key];
for (int i = st.Count - 1; i >= 0; i--)
{
ResObject resObj = st[i];
if (!System.Object.ReferenceEquals(resObj.mCloneObj, null) && resObj.mClear)
{
GameObject.Destroy(resObj.mCloneObj);
mResouceObjDic.Remove(resObj.mCloneObj.GetInstanceID());
resObj.Recycle2Cache();
st.Remove(resObj);
}
}
if (st.Count <= 0)
{
tempList.Add(key);
}
}
for (int i = 0; i < tempList.Count; i++)
{
uint temp = tempList[i];
if (mObjectPoolDic.ContainsKey(temp))
{
mObjectPoolDic.Remove(temp);
}
}
tempList.Clear();
}
public static ResObject Allocate(ResInfo resInfo)
{
ResObject resObject = SafeObjectPool <ResObject> .Instance.Allocate();
resObject.mClear = resInfo.DestroyCache;
resObject.mResPath = resInfo.ResPath;
resObject.IsRecyclePool = false;
return(resObject);
}
public static ResObject Allocate(ObjLoadInfo objLoadInfo)
{
ResObject resObject = SafeObjectPool <ResObject> .Instance.Allocate();
resObject.mCrc = objLoadInfo.mCRC;
resObject.mClear = objLoadInfo.mClear;
resObject.mResPath = objLoadInfo.mResPath;
resObject.IsRecyclePool = false;
return(resObject);
}
public static ResObject Copy(ResObject resObject)
{
ResObject newResObject = SafeObjectPool <ResObject> .Instance.Allocate();
newResObject.mObj = resObject.mObj;
newResObject.mClear = resObject.mClear;
newResObject.IsRecyclePool = resObject.IsRecyclePool;
newResObject.IsRecycled = resObject.IsRecycled;
newResObject.RefCount = resObject.RefCount;
newResObject.mResPath = resObject.mResPath;
return(newResObject);
}
/// <summary>
/// 异步加载Object
/// </summary>
/// <param name="objLoadInfo"></param>
public static void InstantiateObjectASync(ObjLoadInfo objLoadInfo)
{
//从对象池拿取对象
ResObject resObject = ResManager.Instance.GetObjectFromPool(objLoadInfo.mCRC);
if (resObject == null)
{
//ResourceLoader加载资源
ResourceLoader.Instance.LoadResAsyncForObj(objLoadInfo);
}
else
{
if (objLoadInfo.ObjParentTrans != null)
{
resObject.mCloneObj.transform.SetParent(objLoadInfo.ObjParentTrans);
}
objLoadInfo.loadObjCall(true, resObject);
objLoadInfo.Recycle2Cache();
}
}
public void AsyncObjCallBack(bool LoadResult, ResInfo resInfo)
{
if (!LoadResult)
{
mAsyncLoadingObjDic.Remove(resInfo.ResPath);
ResManager.Instance.RemoveLoadFailRes(resInfo.mCRC);
resInfo.Recycle2Cache();
mAsyncLoadingObjDic[resInfo.ResPath].ForEach((objLoadInfo) =>
{
objLoadInfo.loadObjCall.InvokeGracefully(LoadResult, null);
objLoadInfo.Recycle2Cache();
});
mAsyncLoadingObjDic.Remove(resInfo.ResPath);
return;
}
bool DestroyCache = false;
mAsyncLoadingObjDic[resInfo.ResPath].ForEach((objLoadInfo) =>
{
ResObject resObject = ResObject.Allocate(objLoadInfo);
resObject.mObj = resInfo.ResObject;
resObject.ABName = resInfo.ABName;
resObject.mCloneObj = GameObject.Instantiate(resObject.mObj, objLoadInfo.ObjParentTrans) as GameObject;
mObjList.AddValue(resObject.mCloneObj.GetInstanceID());
objLoadInfo.loadObjCall.InvokeGracefully(LoadResult, resObject);
ResManager.Instance.CacheResObj(resObject);
if (objLoadInfo.mClear)
{
DestroyCache = true;
}
resObject.Retain();
resInfo.Retain();
objLoadInfo.Recycle2Cache();
});
resInfo.DestroyCache = DestroyCache;
mAsyncLoadingObjDic.Remove(resInfo.ResPath);
}
public ResObject LoadResSyncForObj(ObjLoadInfo objLoadInfo)
{
ResObject resObject = ResObject.Allocate(objLoadInfo);
ResInfo resInfo = ResManager.Instance.GetRes(objLoadInfo.mCRC);
//之前就未加载
if (resInfo == null)
{
ResLoadInfo resLoadInfo = ResLoadInfo.Allocate(objLoadInfo);
resObject.mObj = LoadSync(resLoadInfo);
resLoadInfo.Recycle2Cache();
}
//之前就加载完成
else if (resInfo.State == ResState.Ready)
{
resInfo.Retain();
resObject.mObj = resInfo.ResObject;
}
else
{
AFLogger.e("同步遇到异步正在或者等待加载的资源 : " + resInfo.ResPath + ",请检查调用代码!");
}
return(resObject);
}
public void ReleaseObj(int InstanceID, int maxCacheCount = -1, bool destoryCache = false, bool recycleParent = true)
{
ResObject resObject = mResouceObjDic[InstanceID];
if (mResouceObjDic[InstanceID].IsRecycled)
{
AFLogger.e(resObject.mCloneObj.name + "对象已经回收!");
return;
}
if (mResouceObjDic[InstanceID].IsRecyclePool)
{
AFLogger.e(resObject.mCloneObj.name + "对象已经放回对象池!");
return;
}
#if UNITY_EDITOR
resObject.mCloneObj.name += "(Recycle)";
#endif
//最大缓存数量为0 : 则销毁Gameobject并回收resObject
if (maxCacheCount == 0)
{
ReleaseResouce(resObject.mResPath, destoryCache);
DestroyImmediate(resObject.mCloneObj);
resObject.Recycle2Cache();
}
//回收到对象池
else
{
List <ResObject> st = null;
if (!mObjectPoolDic.TryGetValue(resObject.mCrc, out st) || st == null)
{
st = new List <ResObject>();
mObjectPoolDic.Add(resObject.mCrc, st);
}
//回收到recycleTrs下
if (resObject.mCloneObj)
{
if (recycleParent)
{
resObject.mCloneObj.transform.SetParent(recycleTrs);
}
else
{
resObject.mCloneObj.SetActive(false);
}
}
//是否缓存到最大值,-1是无限制缓存
if (maxCacheCount < 0 || st.Count < maxCacheCount)
{
st.Add(resObject);
resObject.IsRecyclePool = true;
//ResourceManager做一个引用计数
resObject.Release();
}
else
{
ReleaseResouce(resObject.mResPath, destoryCache);
DestroyImmediate(resObject.mCloneObj);
resObject.Recycle2Cache();
}
}
mResouceObjDic.Remove(InstanceID);
}
public void CacheResObj(ResObject resObject)
{
mResouceObjDic.AddValue <int, ResObject>(resObject.mCloneObj.GetInstanceID(), resObject);
}
