Unity 工具类 之 简单的对象池管理类 ObjectPoolManager 实现

Unity 工具类 之 简单的对象池管理类 ObjectPoolManager 实现

 

目录

Unity 工具类 之 简单的对象池管理类 ObjectPoolManager 实现

一、简单介绍

二、实现原理

三、注意事项

四、效果预览

五、实现步骤

六、关键代码

七、参考工程

八、参考资料


 

一、简单介绍

Unity 工具类,自己整理的一些游戏开发可能用到的模块,单独独立使用,方便游戏开发。

简单的对象池管理类,对象池管理是一种广泛通用的内存优化手段。在首次建立对象时,便将其存储在池子中,需要再次使用时,不是每次都实例化一个新的对象,而是查找回收池中是否存在闲置的对象,将其重新激活利用。连续的生成和销毁游戏物体也是耗性能的。

 

二、实现原理

1、单例类,保证整个场景中只有一个类管理对象池;

2、把需要的对象以对象池形式管理起来,需要的时候 拿出来显示即可,不需要的时候隐藏以来即可;

3、ObjectPoolManager.Instance.WarmPool 孵化一些预制的对象池对象;

4、ObjectPoolManager.Instance.SpawnObject 取出未使用的对象池中的对象;

5、ObjectPoolManager.Instance.ReleaseObject 释放使用完的对象到对象池中;

 

三、注意事项

1、当对象池中的孵化的对象,不够用,会重新孵化新的;

2、注意游戏对象池的对象,在游戏结束切换场景后,有必要的话可以全部释放并销毁掉,视情况而定;

 

四、效果预览

 

五、实现步骤

1、打开Unity,新建一个工程,如下图

 

2、新建脚本,单例用于保证场景中只一个管理类,池对象的属性类管理对象的使用情况,对象池管理对象群的使用情况,对象池管理类管理所有对象池使用情况,如下图

 

3、新建测试对象池管理的脚本,和一个Move 移动和释放池对象的脚本,以及两个Cube 和 Sphere 预制体,并绑定 Move 脚本,如下图

 

4、运行场景,效果如下图

 

六、关键代码

1、TestScript

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

public class TestScript : MonoBehaviour
{
    public GameObject cube;
    public GameObject sphere;

    // Start is called before the first frame update
    void Start()
    {
        ObjectPoolManager.Instance.WarmPool(cube,5);
        ObjectPoolManager.Instance.WarmPool(sphere, 5);
    }

    // Update is called once per frame
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.C)) {
            ObjectPoolManager.Instance.SpawnObject(cube);
        }

        if (Input.GetKeyDown(KeyCode.S))
        {
            ObjectPoolManager.Instance.SpawnObject(sphere);
        }
    }
}

 

2、Move

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

public class Move : MonoBehaviour
{
    // Start is called before the first frame update
    void OnEnable()
    {
        Invoke("Release", 3);
    }

    // Update is called once per frame
    void Update()
    {

        this.transform.Translate(transform.right * Time.deltaTime * 10);
    }
    void Release()
    {
        ObjectPoolManager.Instance.ReleaseObject(this.gameObject);
    }
}

 

3、ObjectPoolManager

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

public class ObjectPoolManager : MonoSingleton<ObjectPoolManager>
{
    // 是否打印对象池对象使用情况(默认不打印)
    private bool isLogUsedPoolObject = false;

    // 预制体(对象池对象)生成对象池的字典
    private Dictionary<GameObject, ObjectPool<GameObject>> prefabPoolDictinary;

    // 正在使用的对象的字典
    private Dictionary<GameObject, ObjectPool<GameObject>> usedPoolObjectbDictinary;

    // 对象池是否更新使用的标志
    private bool dirty = false;

    protected override void Awake() {
        base.Awake();

        // 初始化字典
        prefabPoolDictinary = new Dictionary<GameObject, ObjectPool<GameObject>>();
        usedPoolObjectbDictinary = new Dictionary<GameObject, ObjectPool<GameObject>>();
    }

    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        if (isLogUsedPoolObject == true && dirty == true)
        {
            PrintUsedPoolObjectStatue();
            dirty = false;
        }
    }

    /// <summary>
    /// 是否打印对象池对象使用情况(默认不打印)
    /// </summary>
    /// <param name="isLogUsedPoolObject"></param>
    public void SetIsLogUsedPoolObject(bool isLogUsedPoolObject) {
        this.isLogUsedPoolObject = isLogUsedPoolObject;
    }

    /// <summary>
    /// 孵化器孵化指定个数对象池对象
    /// </summary>
    /// <param name="prefab">预制体</param>
    /// <param name="count">要预生成对象池对象</param>
    public void WarmPool(GameObject prefab, int count) {
        if (prefabPoolDictinary.ContainsKey(prefab)) {
            Debug.Log("Pool for prefab " + prefab.name + " has already been created");
        }

        ObjectPool<GameObject> pool = new ObjectPool<GameObject>(()=> {
            return InstantiatePrefab(prefab);

        }, count);

        // 添加到字典中
        prefabPoolDictinary[prefab] = pool;

        // 更新使用数据标志
        dirty = true;

    }

    /// <summary>
    /// 从对象池拿出指定对象使用
    /// </summary>
    /// <param name="prefab">要使用的对象</param>
    /// <returns>对象池返回的可用对象</returns>
    public GameObject SpawnObject(GameObject prefab) {
        return SpawnObject(prefab,Vector3.zero,Quaternion.identity);
    }


    public GameObject SpawnObject(GameObject prefab, Vector3 position, Quaternion rotation)
    {
        // 如果该预制体没有孵化,则先进行孵化 1 个
        if (prefabPoolDictinary.ContainsKey(prefab) == false) {
            WarmPool(prefab, 1);
        }

        // 从对象池中获取对象
        ObjectPool<GameObject> pool = prefabPoolDictinary[prefab];         
        GameObject clone = pool.GetObjectPoolContainerItem();

        // 设置对象的位置旋转,显示物体
        clone.transform.position = position;
        clone.transform.rotation = rotation;
        clone.SetActive(true);

        // 把拿出来的对象添加到已使用的字典中
        usedPoolObjectbDictinary.Add(clone, pool);

        // 更新使用数据标志
        dirty = true;

        return clone;
    }

    /// <summary>
    /// 释放使用的对象池对象
    /// </summary>
    /// <param name="clone">对象</param>
    public void ReleaseObject(GameObject clone) {
        clone.SetActive(false);

        // 已使用的字典中
        if (usedPoolObjectbDictinary.ContainsKey(clone))
        {
            usedPoolObjectbDictinary[clone].ReleaseItem(clone);
            usedPoolObjectbDictinary.Remove(clone);

            // 更新使用数据标志
            dirty = true;
        }
        else {

            Debug.Log("No pool contains the object: " + clone.name);

        }
    }

    /// <summary>
    /// 打印吃对象使用情况
    /// </summary>
    private void PrintUsedPoolObjectStatue() {

        foreach (KeyValuePair<GameObject, ObjectPool<GameObject>> keyVal in prefabPoolDictinary)
        {
            Debug.Log(string.Format("Object Pool for Prefab: {0} In Use: {1} Total {2}", keyVal.Key.name, keyVal.Value.CountUsedItems, keyVal.Value.Count));
        }
    }

    /// <summary>
    /// 生成函数,父物体为被物体
    /// </summary>
    /// <param name="prefab">预制体</param>
    /// <returns></returns>
    private GameObject InstantiatePrefab(GameObject prefab)
    {
        var go = Instantiate(prefab) as GameObject;
        go.transform.parent = this.transform;
        go.SetActive(false);
        return go;
    }
}

4、ObjectPool

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

/// <summary>
/// 对象池
/// </summary>
public class ObjectPool <T>
{
    // 对象池中的对象列表
    private List<ObjectPoolContainer<T>> listObjects;

    // 对象池中使用了的对象字典
    private Dictionary<T, ObjectPoolContainer<T>> usedObjectDictionary;

    // 回调事件
    private Func<T> factoryFuc;

    // 对象列表索引
    private int lastObjectIndex =0;

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="factoryFunc">工厂回调函数</param>
    /// <param name="initialSize">初始化个数</param>
    public ObjectPool(Func<T> factoryFunc, int initialSize)
    {

        this.factoryFuc = factoryFunc;

        listObjects = new List<ObjectPoolContainer<T>>();
        usedObjectDictionary = new Dictionary<T, ObjectPoolContainer<T>>();

        Warm(initialSize);
    }

    /// <summary>
    /// 孵化器,生成对象池实例
    /// </summary>
    /// <param name="capacity">实例个数</param>
    private void Warm(int capacity)
    {
        for (int i =0; i < capacity; i++)
        {
            CreateContainer();
        }
    }

    /// <summary>
    /// 生成对象池实例
    /// </summary>
    /// <returns></returns>
    private ObjectPoolContainer<T> CreateContainer()
    {
        ObjectPoolContainer<T> container = new ObjectPoolContainer<T>();

        // 生成实例
        container.Item = factoryFuc.Invoke();

        // 实例添加到对象池列表中
        listObjects.Add(container);

        return container;
    }

    /// <summary>
    /// 从对象列中获取可用的对象
    /// </summary>
    /// <returns>返回可用的对象</returns>
    public T GetObjectPoolContainerItem() {
        ObjectPoolContainer<T> container = null;

        for (int i = 0; i < listObjects.Count; i++)
        {
            // 对象列表索引递增,并且防止越界
            lastObjectIndex++;
            lastObjectIndex %= listObjects.Count;

            // 如果列表中的对象正在使用,则进行下一循环,否则返回该对象,并退出循环
            if (listObjects[lastObjectIndex].Used)
            {
                continue;
            }
            else {

                container = listObjects[lastObjectIndex];
                break;
            }
        }

        // 如果没有可用的对象,重新生成一个对象
        if (container == null) {
            container = CreateContainer();
        }

        // 标记当前对象已经被使用,并添加到使用列表中 
        container.Consume();
        usedObjectDictionary.Add(container.Item,container);
        return container.Item;
    }

    /// <summary>
    /// 释放正在使用的对象
    /// </summary>
    /// <param name="item">要释放的对象</param>
    /// <returns>true:释放成功/false: 释放失败</returns>
    public bool ReleaseItem(object item) {
        return ReleaseItem((T)item);
    }

    /// <summary>
    /// 从已使用字典中,释放正在使用的对象
    /// </summary>
    /// <param name="item">释放对象</param>
    /// <returns>true:释放成功/false: 释放失败</returns>
    public bool ReleaseItem(T item) {

        // 判断是否存在已使用对象字典中
        if (usedObjectDictionary.ContainsKey(item))
        {

            // 存在,即释放该对象,并从已使用字典中移除
            ObjectPoolContainer<T> container = usedObjectDictionary[item];
            container.Release();
            usedObjectDictionary.Remove(item);

            return true;
        }
        else {
            Debug.Log("This object pool does not contain the item provided: " + item);

            return false;
        }
    }

    /// <summary>
    /// 获取对象池对象列表中的个数
    /// </summary>
    public int Count {
        get {
            return listObjects.Count;
        }
    }

    /// <summary>
    /// 获取对象池已经使用的对象个数
    /// </summary>
    public int CountUsedItems {
        get {
            return usedObjectDictionary.Count;
        }
    }
}

 

5、ObjectPoolContainer

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

/// <summary>
/// 对象池中的对象使用情况
/// </summary>
/// <typeparam name="T"></typeparam>
public class ObjectPoolContainer<T>
{
    // 获取实例
    private T item;

    public T Item { get => item; set => item = value; }

    
    // 是否使用
    public bool Used { get; private set; }

    /// <summary>
    /// 使用该对象池的对象
    /// </summary>
    public void Consume() {
        Used = true;
    }

    /// <summary>
    /// 释放对象池中的对象
    /// </summary>
    public void Release() {

        Used = false;
    }
}

6、MonoSingleton

using UnityEngine;

public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T instance = null;

    private static readonly object locker = new object();

    private static bool bAppQuitting;

    public static T Instance
    {
        get
        {
            if (bAppQuitting)
            {
                instance = null;
                return instance;
            }

            lock (locker)
            {
                if (instance == null)
                {
                    // 保证场景中只有一个 单例
                    T[] managers = Object.FindObjectsOfType(typeof(T)) as T[];
                    if (managers.Length != 0)
                    {
                        if (managers.Length == 1)
                        {
                            instance = managers[0];
                            instance.gameObject.name = typeof(T).Name;
                            return instance;
                        }
                        else
                        {
                            Debug.LogError("Class " + typeof(T).Name + " exists multiple times in violation of singleton pattern. Destroying all copies");
                            foreach (T manager in managers)
                            {
                                Destroy(manager.gameObject);
                            }
                        }
                    }


                    var singleton = new GameObject();
                    instance = singleton.AddComponent<T>();
                    singleton.name = "(singleton)" + typeof(T);
                    singleton.hideFlags = HideFlags.None;
                    DontDestroyOnLoad(singleton);

                }
                instance.hideFlags = HideFlags.None;
                return instance;
            }
        }
    }

    protected virtual void Awake()
    {
        bAppQuitting = false;
    }

    protected virtual void OnDestroy()
    {
        bAppQuitting = true;
    }
}

 

七、参考工程

点击下载工程

 

八、参考资料

参考的 Github 工程:https://github.com/thefuntastic/unity-object-pool

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

仙魁XAN

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值