【unity进阶知识7】对象池的使用，如何封装一个对象池管理器

最新推荐文章于 2024-10-06 10:53:02 发布
最新推荐文章于 2024-10-06 10:53:02 发布
阅读量301 收藏 11
点赞数 9
分类专栏： unity进阶知识 文章标签： unity 游戏引擎 游戏 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36303853/article/details/142670834
版权

文章目录


在这里插入图片描述

什么是对象池？对象池有什么用？

频繁创建和销毁对象会造成性能的开销。

创建对象的时候，系统会为这个对象开辟一片新的空间。销毁对象的时候，这个对象会变成内存垃圾，当内存垃圾达到一定程度，就会触发垃圾回收机制（及GC），清理内存垃圾，由于此时在清理垃圾，所以程序有可能就会变卡。

为了改善这个问题，我们就可以使用对象池。使用了它之后，程序的性能就能得到提升不那么容易变卡。

对象池的原理

1、当要创建对象的时候，不直接创建，而是先从对象池里面找，如果对象池里有这种类型的对象，就从对象池中取出来用。如果对象池里面没有这种类型的对象，才创建该对象。
2、当要销毁对象的时候，不直接销毁，而是把这个对象放进对象池里面存着，以便下一次创建对象时使用。

对象池的实现

1、从对象池获取对象

从对象池获取一个对象。如果对象池有，从对象池中取出来用。如果对象池没有，则实例化该对象。

/// <summary>
/// 对象池
/// </summary>
public class ObjectPool : MonoBehaviour
{
    // 这个对象池存储的游戏对象的预制体
    public GameObject prefab;

    // 对象池最多能容纳多少个游戏对象。负数表示可以容纳无数个。
    public int capacity = -1;

    // 从这个对象池中取出并正在使用的游戏对象。
    public List<GameObject> usedGameObjectList = new List<GameObject>();

    // 存在这个对象池中没有被使用的游戏对象。
    public List<GameObject> unUsedGameObjectList = new List<GameObject>();

    // 这个对象池中正在使用和没有被使用的游戏对象的总数
    public int TotalGameObjectCount => usedGameObjectList.Count + unUsedGameObjectList.Count;

    /// <summary>
    /// 从对象池获取一个对象。
    /// 如果对象池有，从对象池中取出来用。
    /// 如果对象池没有，则实例化该对象。
    /// </summary>
    /// <param name="position">位置</param>
    /// <param name="rotation">旋转</param>
    /// <param name="parent">父级</param>
    /// <returns>返回这个对象</returns>
    public GameObject Spawn(Vector3 position, Quaternion rotation, Transform parent = null)
    {
        GameObject go;

        // 如果对象池中有，则从对象池中取出来用。
        if (unUsedGameObjectList.Count > 0)
        {
            go = unUsedGameObjectList[0];
            unUsedGameObjectList.RemoveAt(0);
            usedGameObjectList.Add(go);
            go.transform.localPosition = position;
            go.transform.localRotation = rotation;
            go.transform.SetParent(parent, false);
            go.SetActive(true);
        }
        // 如果对象池中没有，则实例化该对象。
        else
        {
            go = Instantiate(prefab, position, rotation, parent);
            usedGameObjectList.Add(go);
        }

        // 如果该游戏对象身上继承MonoBehaviour的脚本中写了名叫OnSpawn的方法，则会执行它们一次。
        go.SendMessage("OnSpawn", SendMessageOptions.DontRequireReceiver);
        return go;
    }

    
}

2、回收对象

隐藏指定的游戏对象，并把它回收进对象池中。

/// <summary>
/// 回收对象
/// </summary>
/// <param name="go">要回收的对象</param>
public void Despawn(GameObject go)
{
    if (go == null) return;

    // 遍历这个对象池中所有正在使用的游戏对象
    for (int i = 0; i < usedGameObjectList.Count; i++)
    {
        if (usedGameObjectList[i] == go)
        {
            // 如果这个对象池的容量不为负数，且容纳的游戏对象已经满，则把0号的游戏对象剔除掉
            if (capacity >= 0 && usedGameObjectList.Count >= capacity)
            {
                if (unUsedGameObjectList.Count > 0)
                {
                    Destroy(unUsedGameObjectList[0]);
                    unUsedGameObjectList.RemoveAt(0);
                }
            }

            // 把游戏对象回收到对象池中
            unUsedGameObjectList.Add(go);
            usedGameObjectList.RemoveAt(i);
            go.SetActive(false);
            go.transform.SetParent(transform, false);

            // 如果该游戏对象身上继承MonoBehaviour的脚本写了名叫OnDespawn的方法，则在回收的时候，会执行一次。
            go.SendMessage("OnDespawn", SendMessageOptions.DontRequireReceiver);
            return;
        }
    }
}

3、回收所有对象

把通过这个对象池生成的所有游戏对象全部隐藏并放入对象池中

/// <summary>
/// 回收所有对象，把通过这个对象池生成的所有游戏对象全部隐藏并放入对象池中
/// </summary>
public void DespawnAll()
{
    int count = usedGameObjectList.Count;
    for (int i = 0; i < count; i++)
    {
        Despawn(usedGameObjectList[0]);
    }
}

4、预先往这个对象池中加载指定数量的游戏对象

/// <summary>
/// 预先往这个对象池中加载指定数量的游戏对象
/// </summary>
/// <param name="amount">预先生成游戏对象数量</param>
public void Preload(int amount = 1)
{
    if (prefab == null) return;
    if (amount <= 0) return;

    for (int i = 0; i < amount; i++)
    {
        GameObject go = Instantiate(prefab, Vector3.zero, Quaternion.identity);
        go.SetActive(false);
        go.transform.SetParent(transform, false);
        unUsedGameObjectList.Add(go);
        go.name = prefab.name;
    }
}

5、最终代码

using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 对象池
/// </summary>
public class ObjectPool : MonoBehaviour
{
    //这个对象池存储的游戏对象的预制体
    public GameObject prefab;

    //对象池最多能容纳多少个游戏对象。负数表示可以容纳无数个。
    public int capacity = -1;

    //从这个对象池中取出并正在使用的游戏对象
    public List<GameObject> usedGameObjectsList = new List<GameObject>();

    //存在这个对象池中并没有被使用的游戏对象
    public List<GameObject> unUsedGameObjectsList = new List<GameObject>();

    //这个对象池中正在使用和没有被使用的游戏对象的总数
    public int TotalGameObjectsCount { get => usedGameObjectsList.Count + unUsedGameObjectsList.Count; }

    /// <summary>
    /// <para>从对象池获取一个对象</para>
    /// <para>如果对象池中有，则从对象池中取出来用。</para>
    /// <para>如果对象池中没有，则实例化该对象。</para>
    /// </summary>
    /// <param name="position">生成游戏对象的位置</param>
    /// <param name="rotation">生成游戏对象的旋转</param>
    /// <param name="parent">生成的游戏对象的父物体</param>
    /// <returns>返回这个对象</returns>
    public GameObject Spawn(Vector3 position, Quaternion rotation, Transform parent = null)
    {
        GameObject go;

        if (unUsedGameObjectsList.Count > 0)
        {
            go = unUsedGameObjectsList[0];

            unUsedGameObjectsList.RemoveAt(0);

            usedGameObjectsList.Add(go);

            go.transform.localPosition = position;

            go.transform.localRotation = rotation;

            go.transform.SetParent(parent, false);

            go.SetActive(true);
        }
        else
        {
            go = Instantiate(prefab, position, rotation, parent);

            usedGameObjectsList.Add(go);
        }

        //如果该游戏对象身上继承Monobehavior的脚本中写了名叫OnSpawn的方法，则会执行它们。
        go.SendMessage("OnSpawn", SendMessageOptions.DontRequireReceiver);

        return go;
    }

    /// <summary>
    /// <para>隐藏指定的游戏对象，并把它回收进对象池中。</para>
    /// </summary>
    /// <param name="go">要放入对象池的游戏对象</param>
    public void Despawn(GameObject go)
    {
        if (go == null) return;

        //遍历这个对象池中所有正在使用的游戏对象
        for (int i = 0; i < usedGameObjectsList.Count; i++)
        {
            if (usedGameObjectsList[i] == go)
            {
                //如果这个对象池的容量不为负数，且容纳的游戏对象已经满了，则把0号的游戏对象删掉，确保之后新的游戏对象能放入到池子中。
                if (capacity >= 0 && unUsedGameObjectsList.Count >= capacity)
                {
                    if (unUsedGameObjectsList.Count > 0)
                    {
                        Destroy(unUsedGameObjectsList[0]);
                        unUsedGameObjectsList.RemoveAt(0);
                    }
                }

                //把游戏对象放入到对象池中
                unUsedGameObjectsList.Add(go);
                usedGameObjectsList.RemoveAt(i);
				
				//如果该游戏对象身上继承Monobehavior的脚本中写了名叫OnDespawn的方法，则会执行它们。
                go.SendMessage("OnDespawn", SendMessageOptions.DontRequireReceiver);
                
                go.SetActive(false);

                go.transform.SetParent(transform, false);

                return;
            }
        }
    }

    /// <summary>
    /// 把通过这个对象池生成的所有游戏对象，全部隐藏并放入对象池中
    /// </summary>
    public void DespawnAll()
    {
        int count = usedGameObjectsList.Count;

        for (int i = 1; i <= count; i++)
        {
            Despawn(usedGameObjectsList[0]);
        }

        //清空列表
        usedGameObjectsList.Clear();
    }

    /// <summary>
    /// <para>在这个对象池中预加载指定数量的游戏对象。</para>
    /// </summary>
    /// <param name="amount">要预加载的数量</param>
    public void Preload(int amount = 1)
    {
        if (prefab == null) return;

        if (amount <= 0) return;

        for (int i = 1; i <= amount; i++)
        {
            GameObject go = Instantiate(prefab, Vector3.zero, Quaternion.identity);
            go.SetActive(false);
            go.transform.SetParent(transform, false);
            unUsedGameObjectsList.Add(go);
            go.name = prefab.name;
        }
    }
}

封装对象池管理器

1、对象池管理器代码

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

/// <summary>
/// 对象池管理器
/// </summary>
public class ObjectPoolsManager : Singleton<ObjectPoolsManager>
{
    //所有对象池的父物体
    GameObject poolsParent;

    //所有对象池共同父物体的名字
    readonly string poolsParentName = "ObjectPools";

    //当前所有对象池的列表
    public List<ObjectPool> objectPoolsList = new List<ObjectPool>();

    //键：由对象池生成的并且正在使用的游戏对象
    //值：这个游戏对象所属的对象池
    public Dictionary<GameObject, ObjectPool> objectsDictionary = new Dictionary<GameObject, ObjectPool>();

    /// <summary>
    /// <para>从对象池获取一个对象</para>
    /// <para>如果对象池中有，则从对象池中取出来用。</para>
    /// <para>如果对象池中没有，则实例化该对象。</para>
    /// </summary>
    /// <param name="prefab">要生成的游戏对象的预制体</param>
    /// <param name="position">生成游戏对象的位置。如果没有设置父物体，则是世界坐标。如果设置了父物体，则是局部坐标。</param>
    /// <param name="rotation">生成游戏对象的旋转</param>
    /// <param name="parent">>生成游戏对象的父物体</param>
    /// <returns>返回游戏对象</returns>
    public GameObject Spawn(GameObject prefab, Vector3 position, Quaternion rotation, Transform parent = null)
    {
        if (prefab == null) return null;

        //生成对象池的父物体
        CreatePoolsParentIfNull();

        //通过预制体来查找它所属的对象池
        ObjectPool objectPool = FindPoolByPrefabOrCreatePool(prefab);

        //从对象池获取一个对象
        GameObject go = objectPool.Spawn(position, rotation, parent);

        //把生成的游戏对象与它所属的对象池记录到字典
        objectsDictionary.Add(go, objectPool);

        return go;
    }

    /// <summary>
    /// <para>隐藏指定的游戏对象，并把它回收进对象池中。</para>
    /// </summary>
    /// <param name="go">要放入对象池的游戏对象</param>
    /// <param name="delayTime">延迟多少秒执行</param>
    public void Despawn(GameObject go, float delayTime = 0)
    {
        if (go == null) return;

        //开启协程，延迟执行回收到对象池的逻辑。
        MonoManager.Instance.StartCoroutine(DespawnCoroutine(go, delayTime));
    }
    IEnumerator DespawnCoroutine(GameObject go, float delayTime = 0)
    {
        //等待指定秒数
        if (delayTime > 0)
            yield return CoroutineTool.WaitForSeconds(delayTime);

        //先从象池生成的正在使用的游戏对象的字典中找指定的游戏对象
        if (objectsDictionary.TryGetValue(go, out ObjectPool pool))
        {
            objectsDictionary.Remove(go);

            //把这个游戏对象放入找到的对象池
            pool.Despawn(go);
        }
        else
        {
            //获取这个游戏对象所属的对象池
            pool = FindPoolByUsedGameObject(go);
            if (pool != null)
                pool.Despawn(go);
        }
    }

    /// <summary>
    /// 把所有通过对象池生成的对象全部隐藏，并回收进对象池中。
    /// </summary>
    public void DespawnAll()
    {
        for (int i = 0; i < objectPoolsList.Count; i++)
        {
            objectPoolsList[i].DespawnAll();
        }
        objectsDictionary.Clear();
    }

    /// <summary>
    /// <para>在对象池中预加载指定数量的游戏对象。</para>
    /// </summary>
    /// <param name="prefab">游戏对象的预制体</param>
    /// <param name="amount">要预加载的数量</param>
    public void Preload(GameObject prefab, int amount = 1)
    {
        if (prefab == null) return;
        if (amount <= 0) return;

        //通过预制体来查找它所属的对象池
        ObjectPool pool = FindPoolByPrefabOrCreatePool(prefab);

        //预加载指定数量的游戏对象
        pool.Preload(amount);
    }

    /// <summary>
    /// <para>返回指定的预制体所属的对象池的容量。</para>
    /// <para>如果该对象池不存在，则会创建它，然后返回-1。</para>
    /// </summary>
    /// <param name="prefab">预制体</param>
    public int GetCapacity(GameObject prefab)
    {
        ObjectPool pool = FindPoolByPrefabOrCreatePool(prefab);

        return pool.capacity;
    }

    /// <summary>
    /// <para>设置指定的预制体所属的对象池的容量。</para>
    /// <para>如果该对象池不存在，则会创建它，然后再设置它的容量。</para>
    /// </summary>
    /// <param name="prefab">预制体</param>
    /// <param name="capacity">要设置的容量。如果设置为负数，则表示这个对象池可以容纳无数个游戏对象。</param>
    public void SetCapacity(GameObject prefab, int capacity = -1)
    {
        ObjectPool pool = FindPoolByPrefabOrCreatePool(prefab);

        pool.capacity = capacity;
    }

    /// <summary>
    ///生成对象池的父物体
    /// </summary>
    void CreatePoolsParentIfNull()
    {
        if (poolsParent == null)
        {
            //清空列表和字典，避免上一个场景的数据的影响。
            objectPoolsList.Clear();
            objectsDictionary.Clear();

            //生成一个空物体
            poolsParent = new GameObject(poolsParentName);
        }
    }

    /// <summary>
    /// <para>查找指定的预制体所属的对象池</para>
    /// </summary>
    /// <param name="prefab">预制体</param>
    ObjectPool FindPoolByPrefab(GameObject prefab)
    {
        if (prefab == null) return null;

        for (int i = 0; i < objectPoolsList.Count; i++)
        {
            if (objectPoolsList[i].prefab == prefab)
                return objectPoolsList[i];
        }
        return null;
    }

    /// <summary>
    /// <para>查找指定的游戏对象所属的对象池</para>
    /// </summary>
    /// <param name="go">要查找的游戏对象</param>
    ObjectPool FindPoolByUsedGameObject(GameObject go)
    {
        if (go == null) return null;

        for (int i = 0; i < objectPoolsList.Count; i++)
        {
            ObjectPool pool = objectPoolsList[i];

            //遍历每一个对象池正在使用的所有游戏对象
            for (int j = 0; j < pool.usedGameObjectsList.Count; j++)
            {
                if (pool.usedGameObjectsList[j] == go)
                    return pool;
            }
        }

        return null;
    }

    /// <summary>
    /// <para>通过预制体来查找它所属的对象池</para>
    /// </summary>
    /// <param name="prefab">预制体</param>
    ObjectPool FindPoolByPrefabOrCreatePool(GameObject prefab)
    {
        //生成对象池的父物体
        CreatePoolsParentIfNull();

        //查找并返回该预制体所属的对象池
        ObjectPool objectPool = FindPoolByPrefab(prefab);

        //如果该对象池不存在，则创建一个。
        if (objectPool == null)
        {
            //创建一个对象池
            objectPool = new GameObject($"ObjectPool-{prefab.name}").AddComponent<ObjectPool>();

            //设置这个对象池所管理的预制体
            objectPool.prefab = prefab;

            //把生成的对象池放到父物体中，方便管理。
            objectPool.transform.SetParent(poolsParent.transform);

            //记录这个对象池
            objectPoolsList.Add(objectPool);
        }

        return objectPool;
    }
}

2、测试调用

public class PoolTest : MonoBehaviour
{
    private void OnGUI()
    {
        if (GUI.Button(new Rect(0, 0, 150, 70), "生成游戏对象"))
        {
            GameObject prefab = ResourcesManager.Instance.Load<GameObject>("Prefabs/Cube");

            GameObject go = ObjectPoolsManager.Instance.Spawn(prefab, transform.position, Quaternion.identity, transform);

            go.GetComponent<Rigidbody>().AddForce(Vector3.forward * 1000f);//加力

            //5秒后回收
            ObjectPoolsManager.Instance.Despawn(go, 5f);
        }
    }
}

效果
在这里插入图片描述

3、生成和回收游戏对象时自动调用的方法

在预制体添加脚本，书写生成和回收游戏对象时自动调用的方法，可以在上面书写对象初始化方法，重置对象参数

public class Cube : MonoBehaviour {
    //生成游戏对象时自动调用
    void OnSpawn(){
        Debug.Log("生成游戏对象");
    }

    //回收游戏对象时自动调用
    void OnDespawn(){
        Debug.Log("回收游戏对象");
        
        //重置参数
        transform.position = Vector3.zero;
        GetComponent<Rigidbody>().velocity = Vector3.zero;
    }
}

效果
在这里插入图片描述

完结

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

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

一位在小公司默默奋斗的开发者，闲暇之余，边学习边记录分享，站在巨人的肩膀上，通过学习前辈们的经验总是会给我很多帮助和启发！如果你遇到任何问题，也欢迎你评论私信或者加群找我， 虽然有些问题我也不一定会，但是我会查阅各方资料，争取给出最好的建议，希望可以帮助更多想学编程的人，共勉~
在这里插入图片描述

向宇it
关注
专栏目录
GameFramework框架详解之 ObejctPool对象池模块
TxNet
11-26 3354
一.前言 GF框架中对象池的使用，总共有三处 1.ObjectPool对象池 2.RefrencePool引用池 3.TaskPool任务池 首先使用原理都是一样的，都是因为存在频繁的创建和销毁，为了避免GC而对对象进行缓存，需要时获取，不需要是回收。 而在GF框架中之所以分成3个Pool去做这些事情，也是为了不同的 功能而分别差异化实现的 二.TaskPool任务池 先来聊聊TaskPool吧，TaskPool其实是ITaskAgent的一个集合，负责ITaskAgent的初始化，执行，回收等操作
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
热门推荐
努力前行，总会成为自己心中的那道光
02-23 12万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
【unity进阶知识6】Resources的使用，如何封装一个Resources资源管理器
向宇
10-01 1328
同步加载Resources文件夹中指定路径的文件夹中的指定类型的所有资源，包括其中子孙文件夹中的该类型的所有资源，然后返回到一个Object[]型数组。Resources.LoadAll(string 要加载的资源的文件夹路径或文件路径,System.Type 要加载的资源的类型的Type对象)同步加载Resources文件夹中指定路径的文件夹中的指定类型的所有资源，包括其中子孙文件夹中的该类型的所有资源，然后返回到一个T[]型数组。如果有多个相同类型，且相同路径的资源，则只会返回找到的第一个资源。
【unity进阶知识3】封装一个事件管理系统
向宇
09-25 2471
框架的事件系统主要负责高效的方法调用与数据传递，实现各功能之间的解耦，通常在调用某个实例的方法时，必须先获得这个实例的引用或者新实例化一个对象，低耦合度的框架结构希望程序本身不去关注被调用的方法所依托的实例对象是否存在，通过事件系统做中转将功能的调用封装成事件，使用事件监听注册、移除和事件触发完成模块间的功能调用管理。常用在UI事件、跨模块事件上。
【unity进阶知识4】封装unity协程工具，避免 GC（垃圾回收）
向宇
09-25 828
在 Unity 中，使用 yield return null 、yield return new WaitForEndOfFrame()等会导致 GC（垃圾回收）开销。yield return null: 每次调用这个语句，Unity 会创建一个新的迭代器状态机。当你执行协程时，如果你在协程中使用 yield return null，它会生成一个新的迭代器，这样会产生额外的内存分配。
Unity进阶之C#知识补充
SunsetSunup的博客
09-24 678
C#增加的一些方法，重点是Unity跨平台的原理、C#新增语法异步方法Async和Await、模式匹配等内容
unity进阶学习笔记：消息框架
Raine_Yang的博客
05-06 2085
1 使用消息框架的目的对于小型游戏，可能不需要任何框架，而是让各个游戏脚本直接相互通信。如要实现玩家受到攻击血量减少，通过玩家控制类向血条脚本发送消息减少血量。但是这样直接通信会导致各脚本通信关系记为复杂，并且每一个脚本都和多个脚本有联系，导致维护和更新十分困难我们利用上节课讲的管理类，可以将一类脚本由一个管理类控制，如将玩家的功能放在玩家管理类下，将血条，背包等UI组件放在UI管理类下。这样要减少玩家血量，可以让玩家控制类向UI管理类发消息，然后UI管理类来改变血条。该方案对大部分小型游戏适用，但对于大型
【unity进阶知识8】unity场景Scene的使用， 如何封装一个场景管理器
最新发布
向宇
10-06 463
【unity进阶知识8】unity场景Scene的使用， 如何封装一个场景管理器
【unity数据交互】XML数据管理器知识点
秩沅
08-20 1217
XML数据管理器知识点，详细
Unity零基础到进阶 | Unity中的多线程的使用，普通创建Thread + 使用Loom插件创建
努力前行，总会成为自己心中的那道光
10-29 5万+
#Unity中多线程的使用
【Unity3D小技巧】Unity3D中使用EventTrigger对3D物体的响应
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
09-18 1029
是Unity中用于处理UI事件的一个组件。它允许我们为UI元素（如按钮、图像等）添加事件监听器，从而响应各种交互事件，如鼠标点击、悬停、拖拽等。使用可以避免手动编写复杂的事件处理代码，使UI事件的响应更加简洁和易于管理。比手写UI的Event快很多,方便很多。这篇文章不探究组件与UI事件的交互，主要对焦与与3D物体的响应。
C# 游戏引擎中的协程
m0_73087695的博客
09-23 1896
简单来讲，协程是轻量级，用户级的线程，通过“分时复用” 的方式模拟多线程操作。协程是一个“伪线程”，它其实只在一个线程上执行，但是通过执行“挂起”和“恢复”等操作，可以实现“不同时间执行不同任务”或者说“一个任务分到多个帧内完成”。协程的优点就是缺点，缺点就是优点。它没有直接操作线程繁琐，也无法发挥多核处理器的优势，所以它并非“必要的”。不过对于游戏开发而言，游戏一般只有一个“主循环”，或者说一个主要线程，所以资源和数据（也可以说“上下文”（context））主要就只在一个线程中。
C++游戏开发深度解析
jun778895的博客
09-30 1152
C++作为一种高效、灵活且功能强大的编程语言，在游戏开发领域扮演着举足轻重的角色。从独立小游戏到大型3A级游戏，C++都以其卓越的性能和广泛的适用性成为游戏开发者们的首选。本文将从C++游戏开发的基础、优势、引擎、挑战以及未来趋势等多个方面，对C++在游戏开发中的应用进行深度解析。
【Unity】Luban学习笔记
Davidorzs的博客
09-30 1115
自己学习Luban时的一些笔记，方便以后复习。
【Unity踩坑】Unity更新Google Play结算库
Tealc
09-30 666
本文介绍了如何更新Goolge Play 结算库
Unity 快速定位到目标文件夹
zhuanggenhua的博客
10-05 267
主要给习惯垂直布局用的，文件多了滚动都要滚半天。"快捷方式/定位到GameData &G""快捷方式/定位到Scripts &S""快捷方式/定位到ArtRes &A""快捷方式/定位到Plugin &P""快捷方式/定位到Setting""快捷方式/定位到预制体 &P""快捷方式/打开工程目录 &O"
【Python游戏开发】贪吃蛇游戏demo拓展
qq_40878316的博客
10-05 331
拓展上一项目。
MetaJUI v0.4 遇到的一些问题及解决办法记录
bjxingch的博客
09-30 461
MetaJUI v0.4 遇到的一些问题及解决办法记录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

向宇it

创作不易，感谢你的鼓励

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

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

打赏作者

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

抵扣说明：

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

余额充值