public virtual void notifyConstructDone()
{
if (mGameFramework == null)
{
mGameFramework = GameFramework.instance;
mCommandSystem = mGameFramework.getSystem <CommandSystem>();
mAudioManager = mGameFramework.getSystem <AudioManager>();
mGameSceneManager = mGameFramework.getSystem <GameSceneManager>();
mCharacterManager = mGameFramework.getSystem <CharacterManager>();
mLayoutManager = mGameFramework.getSystem <GameLayoutManager>();
mKeyFrameManager = mGameFramework.getSystem <KeyFrameManager>();
mGlobalTouchSystem = mGameFramework.getSystem <GlobalTouchSystem>();
mShaderManager = mGameFramework.getSystem <ShaderManager>();
mSQLite = mGameFramework.getSystem <SQLite>();
mDataBase = mGameFramework.getSystem <DataBase>();
mCameraManager = mGameFramework.getSystem <CameraManager>();
mResourceManager = mGameFramework.getSystem <ResourceManager>();
mLayoutSubPrefabManager = mGameFramework.getSystem <LayoutSubPrefabManager>();
mApplicationConfig = mGameFramework.getSystem <ApplicationConfig>();
mFrameConfig = mGameFramework.getSystem <FrameConfig>();
mObjectManager = mGameFramework.getSystem <ObjectManager>();
mInputManager = mGameFramework.getSystem <InputManager>();
mSceneSystem = mGameFramework.getSystem <SceneSystem>();
mClassObjectPool = mGameFramework.getSystem <ClassObjectPool>();
mSQLiteSound = mSQLite.getTable <SQLiteSound>();
}
}
public void Init(Transform recycleTr, Transform sceneTr)
{
RecycleObjectsTr = recycleTr;
SceneTr = sceneTr;
m_resGoClassPool = Instance.GetClassObjectPool <ResourceGameObject>(1000);
}
public LRUCache(int capacity)
{
dLinkList = new DLinkList <T>();
findDic = new Dictionary <uint, DLinkNode <T> >();
nodePool = GetOrCreateClassPool(capacity);
}
public DoubleLinkedList()
{
m_Count = 0;
m_Head = new DoubleLinkedNode <T>();
m_Tail = new DoubleLinkedNode <T>();
m_Head.m_Next = m_Tail;
m_Tail.m_Previous = m_Head;
m_Pool = GameManager.Instance.m_ObjectMgr.CreateOrGetClassPool <DoubleLinkedNode <T> >();
}
/// <summary>
/// 从对象池中取T对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="maxcount"></param>
/// <returns></returns>
public T NewClassObjectFromPool <T>(int maxcount) where T : class, new()
{
ClassObjectPool <T> pool = GetOrCreateClassPool <T>(maxcount);
if (pool == null)
{
return(null);
}
return(pool.Spwan(true));
}
/// <summary>
/// 创建类对象池，创建完成后外面可以保存 ClassObjectPool<T> ，然后调用 Spawn 和 Recycle 来创建和回收对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="maxCount"></param>
/// <returns></returns>
public ClassObjectPool <T> GetOrCreateClassPool <T>(int maxCount) where T : class, new()
{
Type type = typeof(T);
object outObj = null;
if (!classPoolDic.TryGetValue(type, out outObj) || outObj == null)
{
ClassObjectPool <T> newPool = new ClassObjectPool <T>(maxCount);
classPoolDic.Add(type, newPool);
}
return(outObj as ClassObjectPool <T>);
}
//获得或者创建一个对象池
//当有对象池的时候则直接取，没有的时候按count的数量创建
public ClassObjectPool <T> GetOrCreteObject <T>(int count = 1) where T : class, new()
{
Type type = typeof(T);
object out_obj = null;
if (!obj_dic.TryGetValue(type, out out_obj))
{
ClassObjectPool <T> new_pool = new ClassObjectPool <T>(count);
obj_dic.Add(type, new_pool);
out_obj = new_pool;
}
return(out_obj as ClassObjectPool <T>);
}
/// <summary>
/// 创建类对象池， 取对象之前要先调用
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="maxCount">最大数量为-1不限量</param>
/// <param name="isPreLoad">是否预加载, 最大数量大于0有效</param>
public ClassObjectPool <T> CreateOrGetClassPool <T>(int maxCount = -1, bool isPreLoad = true) where T : class, new()
{
Type type = typeof(T);
object pool = null;
m_ClassPoolDic.TryGetValue(type, out pool);
if (pool is null)
{
pool = new ClassObjectPool <T>(maxCount, isPreLoad);
m_ClassPoolDic.Add(type, pool);
}
return(pool as ClassObjectPool <T>);
}
public ResourcePrioritizedCache()
{
m_Cache = new ResourceCache();
m_LoadingResList = new Stack <AsyncLoadProcess> [(int)LoadPriority.VaildNum];
for (int i = 0; i < m_LoadingResList.Length; i++)
{
m_LoadingResList[i] = new Stack <AsyncLoadProcess>();
}
m_LoadingResDict = new Dictionary <string, AsyncLoadProcess>();
m_ProcessPool = GameManager.Instance.m_ObjectMgr.CreateOrGetClassPool <AsyncLoadProcess>();
m_PreloadEndCall = _PreloadOk;
RegisterTick();
}
Dictionary <Type, object> m_ClassPoolDic = new Dictionary <Type, object>();//按类型存储的池字典
/// <summary>
/// 获得或创建一个类对象池,创建后外界可以调用ClassObjectPool<T>,然后调用spwn和recycle来创建和回收类对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="maxcount"></param>
/// <returns></returns>
public ClassObjectPool <T> GetOrCreateClassPool <T>(int maxcount) where T : class, new()
{
Type type = typeof(T);
object pool = null;
if (!m_ClassPoolDic.TryGetValue(type, out pool) || pool == null)
{
pool = new ClassObjectPool <T>(maxcount);
m_ClassPoolDic.Add(type, pool);
}
return(pool as ClassObjectPool <T>);
}
/// <summary>
/// 从对象池中取T对象
/// </summary>
/// <typeparam UIName="T"></typeparam>
/// <param UIName="maxcount"></param>
/// <returns></returns>
internal T NewClassObjectFromPool <T>(int maxcount) where T : class, new()
{
ClassObjectPool <T> pool = GetOrCreateClassPool <T>(maxcount);
if (pool == null)
{
return(null);
}
else
{
return(pool.Spawn(true));
}
}
/// <summary>
/// 创建类对象池,创建完成后外面可以保持ClassObjectPool<T>,然后调用Spawn和Recycle来创建对象和回收对象
/// </summary>
/// <typeparam UIName="T"></typeparam>
/// <param UIName="maxcount"></param>
/// <returns></returns>
internal ClassObjectPool <T> GetOrCreateClassPool <T>(int maxcount) where T : class, new()
{
Type type = typeof(T);
object outOjb = null;
if (!_ClassPoolDic.TryGetValue(type, out outOjb) || outOjb == null)
{
ClassObjectPool <T> newPool = new ClassObjectPool <T>(maxcount);
_ClassPoolDic.Add(type, newPool);
return(newPool);
}
return(outOjb as ClassObjectPool <T>);
}
public ClassObjectPool <DLinkNode <T> > GetOrCreateClassPool(int maxcount)
{
var type = typeof(DLinkNode <T>);
object outObj = null;
if (classPoolDic.TryGetValue(type, out outObj) || outObj == null)
{
var pool = new ClassObjectPool <DLinkNode <T> >(maxcount);
classPoolDic.Add(type, pool);
return(pool);
}
return(outObj as ClassObjectPool <DLinkNode <T> >);
}
/// <summary>
/// 创建类对象池,创建完以后可以外面保存WooolObjectPool<T>,然后调用Spawn和Recycle来创建和回收类对象
/// </summary>
/// <typeparam name="T">只要是类</typeparam>
/// <param name="iMaxCount">最大个数</param>
/// <returns></returns>
public static ClassObjectPool <T> GetOrCreateClassPool <T>(int iMaxCount) where T : class, new()
{
System.Type theType = typeof(T);
object outObj = null;
if (!m_dClassPool.TryGetValue(theType, out outObj) || outObj == null)
{
ClassObjectPool <T> newPool = new ClassObjectPool <T>(iMaxCount);
m_dClassPool.Add(theType, newPool);
return(newPool);
}
return(outObj as ClassObjectPool <T>);
}
public ClassObjectPool <T> GetOrCreateClassPool <T>(int maxCount) where T : class, new()
{
Type currentType = typeof(T);
ClassObjectPool <T> pool;
if (classPoolDic.ContainsKey(currentType))
{
pool = classPoolDic[currentType] as ClassObjectPool <T>;
}
else
{
pool = new ClassObjectPool <T>(maxCount);
classPoolDic.Add(currentType, pool);
}
return(pool);
}
public ClassObjectPool <T> GetClassObjectPool <T>(int count) where T : class, new()
{
Type _type = typeof(T);
object tObj = null;
if (!m_typeObjectDic.ContainsKey(_type))
{
tObj = new ClassObjectPool <T>(count);
m_typeObjectDic.Add(_type, tObj);
}
else
{
m_typeObjectDic.TryGetValue(_type, out tObj);
}
return(tObj as ClassObjectPool <T>);
}
public T Spawn <T>(bool createWhenPoolEmpty = true) where T : class, new()
{
object poolObj = null;
Type type = typeof(T);
m_ClassPoolDic.TryGetValue(type, out poolObj);
if (poolObj is null)
{
Debug.LogError("需要先创建类池，才能从池中获取对象！");
return(null);
}
else
{
ClassObjectPool <T> pool = poolObj as ClassObjectPool <T>;
return(pool.Spawn(createWhenPoolEmpty));
}
}
public bool Recycle <T>(T obj) where T : class, new()
{
object poolObj = null;
Type type = typeof(T);
m_ClassPoolDic.TryGetValue(type, out poolObj);
if (poolObj is null)
{
Debug.LogError("类池不存在无需回收！");
return(false);
}
else
{
ClassObjectPool <T> pool = poolObj as ClassObjectPool <T>;
return(pool.Recycle(obj));
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="recyclePool">回收节点</param>
/// <param name="scene">场景默认节点</param>
public void Init(Transform recyclePool, Transform scene)
{
m_ResourceObjClassPool = GetOrCreateClassPool <ResourceObj>(1000);
RecyclePoolTrs = recyclePool;
SceneTrs = scene;
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="recycleTrs">回收节点</param>
/// <param name="sceenTrs">场景节点</param>
public void Init(Transform recycleTrs, Transform sceenTrs)
{
m_ResourceObjClassPool = ObjectManger.Instance.GetOrCreateClassPool <ResourceObj>(1000);//初始化池对象
this.RecyclePoolTrs = recycleTrs;
this.SceenTrs = sceenTrs;
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="recycleTrs">回收节点</param>
/// <param name="sceneTrs">场景默认节点</param>
public void Init(Transform recycleTrs, Transform sceneTrs)
{
m_ResourceObjClassPool = ObjectManager.Instance.GetOrCreateClassPool <ResourceObj>(1000);
RecyclePoolTrs = recycleTrs;
SceneTrs = sceneTrs;
}
public void Init(Transform unSpawnParent, Transform sceneParentNode)
{
m_ResObjPool = GetOrCreateClassPool <ResourceObject>(1000);
m_UnSpawnParentNode = unSpawnParent;
m_SceneParentNode = sceneParentNode;
}
//初始化游戏物体的节点
public void InitRecyclePool(Transform recyclePool, Transform sceneTrs)
{
m_ResourceObjectPool = GetOrCreteObject <ResourceObject>(1000);
RecyclePoolTrs = recyclePool;
SceneTrs = sceneTrs;
}
public void Init(Transform recyleRoot, Transform sceneRoot)
{
this.recyleRoot = recyleRoot;
this.sceneRoot = sceneRoot;
resObjPool = new ClassObjectPool <ResObj>(Constants.MaxResObj);
}
