【Unity小技巧】Unity探究自制对象池和官方内置对象池(ObjectPool)的使用

文章目录

  • 前言
  • 不使用对象池
  • 使用官方内置对象池
    • 应用
  • 自制对象池
  • 总结
  • 源码
  • 参考
  • 完结

前言

对象池(Object Pool)是一种软件设计模式,用于管理和重用已创建的对象。在对象池中,一组预先创建的对象被维护在一个池中,并在需要时使用和回收。对象池的作用是提供一种高效地创建和销毁对象的方式,以减少系统开销和提高性能。

发明对象池的人绝对是个天才,游戏中我们常常会遇到,频繁创建和销毁大量相同对象的场景,例如敌人子弹

如果我们不做任何处理,只是单纯的创建和销毁,可能会导致内存泄露,性能下降和卡顿等问题

Instantiate(gameobject)

Destroy(gameobject)

对象池的出现,减少了频繁,创建和销毁对象带来的成本,实现对象的循环和复用

在对象池设计理念中,我们不再单纯的创建和销毁,创建对象时,我们会将对象存入对象池中,需要使用对象时,我们从池子中获取对象,当不需要对象时,我们再将对象存入对象池中,以实现对象的循环复用,减少频繁创建销毁象带来的成本

幸运的是,从2021年3月版本后,unity官方为我门内置了对象池,接下来的教程我将以一个简单的例子,带大家熟悉了解使用官方的对象池

不使用对象池

制作一个金币预制体,挂载刚体、碰撞和Coin脚本
【Unity小技巧】Unity探究自制对象池和官方内置对象池(ObjectPool)的使用_第1张图片
新增一个空对象,用于生成金币,挂载CoinPool脚本
【Unity小技巧】Unity探究自制对象池和官方内置对象池(ObjectPool)的使用_第2张图片Coin脚本代码,金币接触地面销毁

private void OnCollisionEnter2D(Collision2D collision) // 碰撞检测
{
    Debug.Log(collision.gameObject.layer);
    if (collision.gameObject.layer == LayerMask.NameToLayer("Ground"))
    {
        //销毁
        Destroy(gameObject);
    }
}

CoinPool脚本代码

public GameObject coin; //金币预制体
public float time; //金币生成间隔时间
void Start()
{
    StartCoroutine(go());
}

IEnumerator go()
{
    while (true)
    {
        //协程每time秒执行一次
        CreateCoin();
        yield return new WaitForSeconds(time);
    }
}

//生成金币
private void CreateCoin()
{
    GameObject gb = Instantiate(coin, transform);//在当前对象处生成一个金币
    gb.transform.position = new Vector3(Random.Range(-80f, -67f), Random.Range(3f, 9f));//随机生成位置
}

效果,可以看到我们只是单纯的创建和销毁金币
【Unity小技巧】Unity探究自制对象池和官方内置对象池(ObjectPool)的使用_第3张图片

使用官方内置对象池

一、命名空间

using UnityEngine.Pool;

二、构造方法

public ObjectPool(
	Func<T> createFunc, 
	Action<T> actionOnGet = null, 
	Action<T> actionOnRelease = null, 
	Action<T> actionOnDestroy = null, 
	bool collectionCheck = true, 
	int defaultCapacity = 10, 
	int maxSize = 10000
);

参数列表解释

每个参数等号右边代表默认值,即第一个参数为必填项。

1.Func createFunc

    需填入一个带T类型返回值的方法,即自定义新建对象时的操作

2.Action actionOnGet, Action actionOnRelease, Action actionOnDestroy

   分别为出池、进池、销毁的响应事件。填入自定义方法名即可,用于拓展相应操作,比如在actionOnDestroy中通过Destroy()方法将因为池满而不能入池的对象直接删除

3.bool collectionCheck

    是否在进池前检查对象是否已经存在池中

4.int defaultCapacity, int maxSize

    初始容量,最大容量

三、属性
1.int CountAll

    所有的对象数,三个属性都为只读初始值为0,经测试,已知每调用一次createFunc委托该值就会+1

2.int CountActive

    被启用的对象数,已知每调用一次Release()方法就会-1,Get()方法+1

3.int CountInactive

    未被启用的对象数,已知每调用一次Release()方法就会+1,Get()方法-1,最大值为池的最大容量

四、常用方法
1.T Get()

    出池,返回一个池中对象。如果池为空,则先调用createFunc,再出池

2.void Relese(T element)

    进池,将对象element加入池。如果池已达到最大容量,则不入池并触发actionOnDestroy事件

3.void Clear()

    清空池

应用

使用官方内置对象池修改前面的例子
Coin脚本

using UnityEngine;
using UnityEngine.Pool;
public class Coin : MonoBehaviour
{
    public ObjectPool<GameObject> pool;
    private void OnCollisionEnter2D(Collision2D collision) // 碰撞检测
    {
        Debug.Log(collision.gameObject.layer);
        if (collision.gameObject.layer == LayerMask.NameToLayer("Ground"))
        {
            //销毁
            // Destroy(gameObject);
            pool.Release(gameObject);
        }

    }
}

CoinPool脚本

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

public class CoinPool : MonoBehaviour
{
    public GameObject coin; //金币预制体
    public float time; //金币生成间隔时间
    public ObjectPool<GameObject> pool;
    public int poolMaxSize;//对象池最大容量
    void Start()
    {
        //是否在进池前检查对象是否已经存在池中,初始容量,最大容量
        pool = new ObjectPool<GameObject>(createFunc, actionOnGet, actionOnRelease, actionOnDestroy, true, 10, poolMaxSize);
        StartCoroutine(go());
    }

    IEnumerator go()
    {
        while (true)
        {
            //协程每time秒执行一次
            CreateCoin();
            Debug.Log("总对象数:"+pool.CountAll);
            Debug.Log("启用的对象数:"+pool.CountActive);
            Debug.Log("未启用的对象数:"+pool.CountInactive);
            yield return new WaitForSeconds(time);
        }
    }

    //生成金币
    private void CreateCoin()
    {
        // GameObject gb = Instantiate(coin, transform);//在当前对象处生成一个金币
        GameObject gb = pool.Get();
        gb.transform.position = new Vector3(Random.Range(-80f, -67f), Random.Range(3f, 9f));//随机生成位置
    }

    
    // 需填入一个带T类型返回值的方法,即自定义新建对象时的操作
    public GameObject createFunc()
    {
        GameObject obj = Instantiate(coin, transform);
        obj.GetComponent<Coin>().pool = pool;//将pool和Coin的pool赋值为同一个
        return obj;
    }
    void actionOnGet(GameObject gameObject)
    {
        gameObject.SetActive(true);//显示敌人
        Debug.Log(gameObject.name + "出池");
    }
    void actionOnRelease(GameObject gameObject)
    {
        gameObject.SetActive(false);//隐藏敌人
        Debug.Log(gameObject.name + "进池");
    }

    void actionOnDestroy(GameObject gameObject)
    {
        Debug.Log("池已满," + gameObject.name + "被销毁");
        Destroy(gameObject);
    }
}

效果,可以看到我们不再是单纯的创建和销毁金币,而是开启和关闭复用前面生成的金币
【Unity小技巧】Unity探究自制对象池和官方内置对象池(ObjectPool)的使用_第4张图片

自制对象池

新增对象池脚本ObjectPool

using System.Collections.Generic;
using UnityEngine;

public class ObjectPool
{
    private static ObjectPool instance; // 单例模式
	// /**
    //  * 我们希望不同的物体可以被分开存储,在这种情况下使用字典是最合适的
    //  * 所以声明一个字典objectPool作为对象池主体,以字符串类型的物体的名字作为key
    //  * 使用队列存储物体来作为value,这里使用队列只是因为入队和出队的操作较为方便,也可以换成其他集合方式
    //  * 然后实例化这个字典以备后续使用
    //  * /
    private Dictionary<string, Queue<GameObject>> objectPool = new Dictionary<string, Queue<GameObject>>(); // 对象池字典
    private GameObject pool; // 为了不让窗口杂乱,声明一个对象池父物体,作为所有生成物体的父物体
    public static ObjectPool Instance // 单例模式
    {
        get
        {
            if (instance == null)
            {
                instance = new ObjectPool();
            }
            return instance;
        }
    }
    public GameObject GetObject(GameObject prefab) // 从对象池中获取对象
    {
        GameObject _object;
        if (!objectPool.ContainsKey(prefab.name) || objectPool[prefab.name].Count == 0) // 如果对象池中没有该对象,则实例化一个新的对象
        {
            _object = GameObject.Instantiate(prefab);
            PushObject(_object); // 将新的对象加入对象池
            if (pool == null)
                pool = new GameObject("ObjectPool"); // 如果对象池父物体不存在,则创建一个新的对象池父物体
            GameObject childPool = GameObject.Find(prefab.name + "Pool"); // 查找该对象的子对象池
            if (!childPool)
            {
                childPool = new GameObject(prefab.name + "Pool"); // 如果该对象的子对象池不存在,则创建一个新的子对象池
                childPool.transform.SetParent(pool.transform); // 将该子对象池加入对象池父物体中
            }
            _object.transform.SetParent(childPool.transform); // 将新的对象加入该对象的子对象池中
        }
        _object = objectPool[prefab.name].Dequeue(); // 从对象池中取出一个对象
        _object.SetActive(true); // 激活该对象
        return _object; // 返回该对象
    }
    public void PushObject(GameObject prefab) // 将对象加入对象池中
    {
		//获取对象的名称,因为实例化的物体名都会加上"(Clone)"的后缀,需要先去掉这个后缀才能使用名称查找
        string _name = prefab.name.Replace("(Clone)", string.Empty);
        if (!objectPool.ContainsKey(_name))
            objectPool.Add(_name, new Queue<GameObject>()); // 如果对象池中没有该对象,则创建一个新的对象池
        objectPool[_name].Enqueue(prefab); // 将对象加入对象池中
        prefab.SetActive(false); // 将对象禁用
    }
}

Coin脚本

using UnityEngine;
using UnityEngine.Pool;
public class Coin : MonoBehaviour
{
    private void OnCollisionEnter2D(Collision2D collision) // 碰撞检测
    {
        // Debug.Log(collision.gameObject.layer);
        if (collision.gameObject.layer == LayerMask.NameToLayer("Ground"))
        {
            //销毁
            // Destroy(gameObject);
            // pool.Release(gameObject);
            ObjectPool.Instance.PushObject(gameObject);
        }

    }
}

CoinPool脚本

using System.Collections;
using UnityEngine;

public class CoinPool : MonoBehaviour
{
    public GameObject coin; //金币预制体
    public float time; //金币生成间隔时间
    void Start()
    {
        StartCoroutine(go());
    }

    IEnumerator go()
    {
        while (true)
        {
            //协程每time秒执行一次
            CreateCoin();
            yield return new WaitForSeconds(time);
        }
    }

    //生成金币
    private void CreateCoin()
    {
        // GameObject gb = Instantiate(coin, transform);//在当前对象处生成一个金币
        // GameObject gb = pool.Get();
        GameObject gb = ObjectPool.Instance.GetObject(coin);
        gb.transform.position = new Vector3(Random.Range(-80f, -67f), Random.Range(3f, 9f));//随机生成位置
    }
}

效果

总结

Unity官方内置对象池和自己写对象池都有各自的优缺点,具体取决于你的需求和项目的规模。

如果你的游戏或应用程序很简单,并且对象池的需求较小,那么使用Unity官方内置的对象池是一个方便和快速的选择。Unity的对象池方法已经经过优化,并且与引擎的其他功能集成得很好,使用起来也非常简单。你可以直接使用ObjectPool类来创建和管理对象池,而无需自己编写额外的代码。

然而,当你的游戏或应用程序更复杂,并且需要更高级的对象池功能时,可能会需要自己编写对象池。自己编写对象池可以根据项目的具体需求进行定制化,以满足特定的性能要求。你可以实现自己的池管理系统、缓存策略和对象回收机制,以及其他高级功能,如对象优先级、预加载等。

总的来说,如果你的项目规模较小并且简单,使用Unity官方内置对象池是一个方便的选择。如果你的项目更加复杂或有特定的需求,编写自己的对象池可能更适合。最佳选择取决于你的项目需求、时间和资源限制,以及你对对象池功能的具体要求。

如果是我的话,我还是会选择自己写对象池脚本,因为这样可以保证一定的可控性、复用性和可扩展性。

好多钱,快去捡

源码

https://gitcode.net/unity1/objectpool
【Unity小技巧】Unity探究自制对象池和官方内置对象池(ObjectPool)的使用_第5张图片

参考

【视频】https://www.bilibili.com/video/BV1Su411E7b2

完结

赠人玫瑰,手有余香!如果文章内容对你有所帮助,请不要吝啬你的点赞评论和关注,以便我第一时间收到反馈,你的每一次支持都是我不断创作的最大动力。当然如果你发现了文章中存在错误或者有更好的解决方法,也欢迎评论私信告诉我哦!

好了,我是向宇,https://xiangyu.blog.csdn.net

一位在小公司默默奋斗的开发者,出于兴趣爱好,于是最近才开始自习unity。如果你遇到任何问题,也欢迎你评论私信找我, 虽然有些问题我可能也不一定会,但是我会查阅各方资料,争取给出最好的建议,希望可以帮助更多想学编程的人,共勉~

你可能感兴趣的:(#,unity小技巧,unity,游戏引擎,游戏)