Complex nested object pool (5) -- unified management and expansion of object pool

【 Unified management of object pool 】

Unified management of object pool , Initialization is required 、 Lending to 、 Recovery object 、 Add object pool 、 Reduce the object pool 、 How to empty the object pool , Relatively simple .

【 Code implementation 】

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;

namespace Cache
{
    public class ObjectPoolManager
    {
        private static ObjectPoolManager _instance;
        public static ObjectPoolManager Instance
        {
            get
            {
                if (_instance == null)
                    _instance = new ObjectPoolManager();
                return _instance;
            }
        }

        public Dictionary<string, ObjectPoolBase> pools = new Dictionary<string, ObjectPoolBase>();
        private Dictionary<int, string> lentInstance2Object = new Dictionary<int, string>();

        private ObjectPoolAsset objectPoolAsset;

        private string assetPath = "Assets/Resources/ObjectPoolAsset.asset";
#if UNITY_EDITOR
        public void Awake()
        {
            objectPoolAsset = Resources.Load<ObjectPoolAsset>(assetPath);
            if (objectPoolAsset == null)
            {
                objectPoolAsset = ScriptableObject.CreateInstance<ObjectPoolAsset>();
                AssetDatabase.CreateAsset(objectPoolAsset, assetPath);
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
        }
#endif
        public void InitPool()
        {
#if !UNITY_EDITOR
        objectPoolAsset = Resources.Load<ObjectPoolAsset>(assetPath);// No Editor How to load the configuration in the case of , This can be written by yourself as needed 
#endif
            foreach (PoolInfo poolInfo in objectPoolAsset.poolInfos)
            {
                AddPool(poolInfo);
            }
        }

        public GameObject LendObjectOut(string poolName, string objectName, Transform parent = null, object[] extradata = null)
        {
            GameObject go = null;
            if(!pools.ContainsKey(poolName))
            {
                Debug.LogWarning(" The object pool does not exist ：" + poolName);
                return null;
            }
            go = pools[poolName].LendObjectOut(objectName, parent, extradata);  
            if(go)
            {
                lentInstance2Object[go.GetInstanceID()] = poolName;
            }
            return go;
        }

        public bool RecycleObject(GameObject go)
        {
            if (go == null)
                return false;

            if (!lentInstance2Object.ContainsKey(go.GetInstanceID()))// Indicates that it is not borrowed from the object pool 
                return false;
            
            return pools[lentInstance2Object[go.GetInstanceID()]].RecycleObject(go);
        }

        public bool AddPool(PoolInfo poolInfo)
        {
            if (pools.ContainsKey(poolInfo.poolName))
            {
                Debug.LogWarning(" The object pool is already included ：" + poolInfo.poolName);
                return false;
            }
            switch (poolInfo.poolType)
            {
                case PoolType.Single:
                    pools.Add(poolInfo.poolName, new SingleObjectPool(poolInfo.capacity, poolInfo.poolName, poolInfo.expansionStrategy));
                    break;
                case PoolType.Multi:
                    pools.Add(poolInfo.poolName, new MultiObjectPool(poolInfo));
                    break;
                case PoolType.ObjectType:
                    pools.Add(poolInfo.poolName, new ObjectTypePool(poolInfo));
                    break;
                case PoolType.StageType:
                    pools.Add(poolInfo.poolName, new StageObjectPool(poolInfo));
                    break;
                case PoolType.NONE:
                    Debug.LogWarning(" Invalid object pool type ：" + poolInfo.poolName);
                    break;
            }
            return true;    
        }

        public bool RemovePool(string poolName)
        {
            if (!pools.ContainsKey(poolName))
            {
                Debug.LogWarning(" The object pool does not exist ：" + poolName);
                return false;
            }

            ObjectPoolBase pool = pools[poolName];
            pools.Remove(poolName);
            pool.Dispose();
            return true;
        }

        public void ClearPool()
        {
            foreach (var item in pools.Values)
            {
                item.Dispose();
            }
            pools.Clear();
            lentInstance2Object.Clear();
        }

    }
}

【 expand 】

1. Extended editor ： Be sure to edit at will ObjectPoolAsset.asset when , Will not result in InitPool() Times wrong , There is no control in the current code .

2. Reduce memory ： rely on lentInstance2Object To find out which pool the object belongs to , Because of the multi-layer nesting , Will lead to repetition , You can add a class to the object to read , You don't have to lentInstance2Object.

3. All use ObjectPoolBase To realize the free combination of different types of object pools

4. Use based on AA Loading method to load objects

5. Add the method of asynchronous loading