Unityでオブジェクトプールを実装する方法と最適化ポイント

1. はじめに

ゲーム開発では、多くのオブジェクトをリアルタイムで生成・破棄する場面がたくさんあります。例えば、シューティングゲームの弾丸や、敵キャラのスポーン（出現）などがその代表例です。しかし、こうしたオブジェクトを頻繁に生成・削除すると、CPU負荷が増大し、フレームレートが低下することがあります。これは、オブジェクトの生成（Instantiate）や破棄（Destroy）の処理が重く、ゲームのパフォーマンスを大きく損なう可能性があるからです。

そんな問題を解決するのが、**「オブジェクトプール（Object Pool）」**という技術です。オブジェクトプールとは、あらかじめ一定数のオブジェクトを作成し、使い回すことで、余分な処理を減らす手法です。これにより、ゲームの処理が軽くなり、よりスムーズな動作が実現できます。

オブジェクトプールのメリット

• パフォーマンス向上：頻繁なオブジェクト生成・破棄を減らし、CPU負荷を軽減する
• メモリの最適化：オブジェクトの再利用により、不要なメモリ消費を抑える
• ゲームの安定性：メモリリークやパフォーマンス低下を防ぎ、安定した動作を維持する

この記事では、Unityでオブジェクトプールを実装する方法を解説し、最適な設定や応用例について詳しく紹介します。オブジェクトプールを活用すれば、ゲームのパフォーマンスを大幅に向上させることができるので、ぜひ最後までチェックしてください！

2. オブジェクトプールの基本

オブジェクトを生成・破棄するデメリット

Unityでは、Instantiate を使ってオブジェクトを生成し、Destroy を使って削除できます。しかし、頻繁にオブジェクトを生成・破棄すると、次のような問題が発生します。

1. CPU負荷が増大する
   • Instantiate は新しいメモリ領域を確保するため、処理が重くなりがち。
   • Destroy はガベージコレクション（GC）を発生させ、ゲームの動作が一時的にカクつく原因になる。
2. メモリの断片化が発生する
   • 使われなくなったメモリ領域が断片化すると、メモリ効率が低下し、最終的にはクラッシュの原因になる。
3. フレームレートの低下につながる
   • 一度に大量のオブジェクトを生成・破棄すると、フレームレートが大きく落ちてゲームの動作が不安定になる。

こうした問題を解決するために、オブジェクトプールを活用します。

オブジェクトプールの仕組み

オブジェクトプールは、あらかじめ一定数のオブジェクトを作成し、使いまわす仕組みです。具体的には、次のような流れになります。

1. 事前にオブジェクトを複数生成し、非アクティブ状態（SetActive(false)）にする
2. オブジェクトが必要になったら、非アクティブなオブジェクトを再利用し、アクティブにする
3. オブジェクトが不要になったら、非アクティブ状態に戻してプールに戻す
4. プール内に利用可能なオブジェクトがなくなった場合、新しく作成するか、最大数に達している場合は再利用を待つ

オブジェクトプールの利点

オブジェクトプールを使うことで、次のようなメリットがあります。

✅ パフォーマンスの向上
　一度作成したオブジェクトを再利用するため、頻繁なInstantiate や Destroy のコストを削減できる。

✅ メモリ使用量の最適化
　使いまわすことで不要なオブジェクトの生成を抑え、メモリの無駄遣いを防ぐ。

✅ ゲームの安定性向上
　メモリリークや処理負荷を減らし、スムーズな動作を維持できる。

この仕組みを活用すれば、弾丸の管理、敵キャラのスポーン、エフェクトの管理 など、多くの場面でパフォーマンスを最適化できます。

次のステップでは、Unityでオブジェクトプールを実装する方法を実際のコードとともに解説していきます！

3. Unityでのオブジェクトプールの実装

それでは、Unityで実際にオブジェクトプールを作成していきましょう！今回は、弾丸（Bullet）をオブジェクトプールで管理する 例を使って解説します。

ステップ1：オブジェクトプール用のスクリプトを作成する

まず、オブジェクトプールを管理するスクリプトを作成します。

スクリプトの作成手順

1. プロジェクトウィンドウを右クリック
2. 「Create」→「C# Script」 を選択
3. スクリプトの名前を「ObjectPool」とする
4. スクリプトを開いて、以下のコードを入力する

using System.Collections.Generic;
using UnityEngine;

public class ObjectPool : MonoBehaviour
{
    [SerializeField] private GameObject prefab;  // プールするオブジェクトのプレハブ
    [SerializeField] private int poolSize = 10;  // プールの初期サイズ

    private Queue<GameObject> pool = new Queue<GameObject>(); // オブジェクトを管理するキュー

    void Start()
    {
        // プールの初期化
        for (int i = 0; i < poolSize; i++)
        {
            GameObject obj = Instantiate(prefab);
            obj.SetActive(false);
            pool.Enqueue(obj);
        }
    }

    // オブジェクトを取得するメソッド
    public GameObject GetObject()
    {
        if (pool.Count > 0)
        {
            GameObject obj = pool.Dequeue();
            obj.SetActive(true);
            return obj;
        }
        else
        {
            // プール内にオブジェクトがない場合、新しく生成
            GameObject obj = Instantiate(prefab);
            return obj;
        }
    }

    // オブジェクトをプールに戻すメソッド
    public void ReturnObject(GameObject obj)
    {
        obj.SetActive(false);
        pool.Enqueue(obj);
    }
}

ステップ2：オブジェクトプールを設定する

次に、シーンにオブジェクトプールを設定します。

1. ヒエラルキー（Hierarchy）ウィンドウで「空のオブジェクト」を作成
   • 右クリック →「Create Empty」
   • 名前を「ObjectPoolManager」に変更
2. ObjectPoolManager に ObjectPool スクリプトをアタッチ
   • プロジェクトウィンドウから ObjectPool スクリプトをドラッグ＆ドロップ してアタッチ
3. Inspectorでプレハブを設定
   • Prefab に 管理したいオブジェクト（例：Bulletプレハブ） をセット
   • Pool Size を適切な数（例：10）に設定

ステップ3：オブジェクトをプールから取得して使用する

オブジェクトプールからオブジェクトを取得して使うためのスクリプトを作成します。
ここでは、プレイヤーが弾丸を発射する BulletShooter スクリプトを作成します。

スクリプトの作成手順

1. 「Create」→「C# Script」 を選択
2. スクリプトの名前を「BulletShooter」にする
3. 以下のコードを入力する

using UnityEngine;

public class BulletShooter : MonoBehaviour
{
    [SerializeField] private ObjectPool objectPool; // ObjectPoolスクリプトを参照
    [SerializeField] private Transform firePoint;   // 弾の発射位置
    [SerializeField] private float bulletSpeed = 10f;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space)) // スペースキーで発射
        {
            GameObject bullet = objectPool.GetObject();
            bullet.transform.position = firePoint.position;
            bullet.transform.rotation = firePoint.rotation;
            bullet.GetComponent<Rigidbody>().velocity = firePoint.forward * bulletSpeed;
        }
    }
}

ステップ4：オブジェクトをプールに戻す

取得したオブジェクトをそのままにすると、無限に増えてしまいます。
一定時間後にプールに戻す処理を Bullet スクリプトに実装しましょう。

スクリプトの作成手順

1. 「Create」→「C# Script」 を選択
2. スクリプトの名前を「Bullet」にする
3. 以下のコードを入力する

using UnityEngine;

public class Bullet : MonoBehaviour
{
    private ObjectPool objectPool;

    void Start()
    {
        objectPool = FindObjectOfType<ObjectPool>(); // ObjectPoolを見つける
        Invoke("ReturnToPool", 3f); // 3秒後にプールへ戻す
    }

    void ReturnToPool()
    {
        objectPool.ReturnObject(gameObject);
    }
}

オブジェクトプールの動作確認

1. ヒエラルキーで「空のオブジェクト（ObjectPoolManager）」を選択
2. ObjectPool に Bullet のプレハブを設定
3. BulletShooter をプレイヤーのオブジェクトにアタッチ
4. シーン内の適切な位置に firePoint を設定
5. ゲームを実行し、スペースキーを押すと弾が発射されるか確認！

このステップで、Unityのオブジェクトプールを使った 弾丸の管理 を実装しました。オブジェクトプールを使うことで、不要なオブジェクトの生成・破棄を減らし、ゲームのパフォーマンスを向上 させることができます。

4. オブジェクトプールの最適化ポイント

オブジェクトプールを実装しただけでは、最適なパフォーマンスが得られないことがあります。ここでは、より効率的にオブジェクトプールを活用するための最適化ポイント を紹介します。

1. プールサイズの適切な決定

オブジェクトプールのサイズ（初期生成するオブジェクトの数）は、ゲームの負荷や使用頻度に応じて最適な数を決める必要があります。

適切なサイズを決める方法

✅ ゲームのピーク時に必要な最大数を把握する

• 例えば、シューティングゲームで一度に10発の弾丸が画面上に存在するなら、少なくとも 10個以上の弾丸をプール しておくのが理想的。

✅ プールサイズを大きくしすぎない

• 必要以上に大きなプールを作ると、メモリ消費が増えてしまう。

✅ 動的にサイズを調整する

• 必要に応じて プールのサイズを拡張する のも有効な手段。
• 例えば、GetObject() の中でオブジェクトが足りなかった場合、新規作成し、プールに戻されたら再利用する。

2. 非アクティブなオブジェクトの管理

オブジェクトプールでは、使用済みオブジェクトを**非アクティブ（SetActive(false)）**にして再利用します。しかし、単に非アクティブにするだけでは、いくつかの問題が発生する可能性があります。

注意点と最適化方法

✅ オブジェクトのリセット処理を行う

• 例えば、弾丸オブジェクトなら位置・速度・回転をリセットしてから再利用する。

public class Bullet : MonoBehaviour
{
    private ObjectPool objectPool;
    private Rigidbody rb;

    void Start()
    {
        objectPool = FindObjectOfType<ObjectPool>();
        rb = GetComponent<Rigidbody>();
    }

    void OnEnable()
    {
        Invoke("ReturnToPool", 3f); // 3秒後にプールへ戻す
    }

    void ReturnToPool()
    {
        rb.velocity = Vector3.zero;  // 速度をリセット
        rb.angularVelocity = Vector3.zero; // 回転をリセット
        objectPool.ReturnObject(gameObject);
    }
}

✅ オブジェクトが画面外に出たら戻す

• OnTriggerExit() を使って、カメラの範囲外に出たらプールに戻す。

void OnTriggerExit(Collider other)
{
    if (other.CompareTag("Boundary"))
    {
        objectPool.ReturnObject(gameObject);
    }
}

3. メモリ使用量の監視と最適化

オブジェクトプールを利用すると、オブジェクトの破棄 (Destroy()) が減るため、メモリ管理が重要になります。

✅ プールが肥大化しないように監視

• 一定時間使用されていないオブジェクトを削除することで、メモリを節約する。
• Invoke() や Coroutine を使って、一定時間ごとに不要なオブジェクトを整理する。

IEnumerator CleanupPool()
{
    while (true)
    {
        yield return new WaitForSeconds(10f); // 10秒ごとにチェック

        if (pool.Count > maxPoolSize) // 最大サイズを超えていたら削除
        {
            GameObject obj = pool.Dequeue();
            Destroy(obj);
        }
    }
}

4. 使われていないオブジェクトの破棄

プールに余ったオブジェクトが多くなりすぎた場合、不要なオブジェクトを破棄してメモリを節約 するのが有効です。

✅ 特定の時間、使用されなかったオブジェクトを破棄

• LastUsedTime 変数を追加し、一定時間使われていなかったら削除。

private class PoolObject
{
    public GameObject gameObject;
    public float lastUsedTime;
}

private List<PoolObject> pool = new List<PoolObject>();

void Update()
{
    float currentTime = Time.time;
    for (int i = pool.Count - 1; i >= 0; i--)
    {
        if (!pool[i].gameObject.activeInHierarchy && (currentTime - pool[i].lastUsedTime > 30f))
        {
            Destroy(pool[i].gameObject);
            pool.RemoveAt(i);
        }
    }
}

5. さまざまなオブジェクトタイプに対応する

オブジェクトプールは弾丸や敵キャラだけでなく、パーティクルやアイテム など、さまざまなオブジェクトに応用できます。

✅ 異なるオブジェクトを管理するジェネリックなオブジェクトプールを作成

using System.Collections.Generic;
using UnityEngine;

public class GenericObjectPool<T> where T : MonoBehaviour
{
    private List<T> pool = new List<T>();
    private T prefab;

    public GenericObjectPool(T prefab, int initialSize)
    {
        this.prefab = prefab;
        for (int i = 0; i < initialSize; i++)
        {
            T obj = Object.Instantiate(prefab);
            obj.gameObject.SetActive(false);
            pool.Add(obj);
        }
    }

    public T GetObject()
    {
        foreach (var obj in pool)
        {
            if (!obj.gameObject.activeInHierarchy)
            {
                obj.gameObject.SetActive(true);
                return obj;
            }
        }

        // すべて使用中なら新規作成
        T newObj = Object.Instantiate(prefab);
        pool.Add(newObj);
        return newObj;
    }

    public void ReturnObject(T obj)
    {
        obj.gameObject.SetActive(false);
    }
}

• これを使えば、弾丸、敵、エフェクトなど、異なる種類のオブジェクトを共通のプールで管理可能 になります！

おすすめのアセット

「オブジェクトプールの実装を手軽にしたい場合は、アセットを活用するのもおすすめです。Unityアセットストアには、オブジェクトプールを簡単に管理できるツールが揃っています。特におすすめなのが以下の3つのアセットです！」

① PoolManager – シンプル & 効率的なオブジェクトプール管理

✅ 特徴

• 簡単なインターフェースで、わずか数ステップでオブジェクトプールを設定可能
• 最適なメモリ管理機能 を搭載し、大規模ゲームにも対応
• 複雑な設定なしで、初心者でもすぐに導入できる！

🎯 おすすめの用途
✔ シューティングゲームの弾丸管理
✔ エフェクト（パーティクル）の再利用
✔ 敵キャラやアイテムのスポーン管理

🛒 購入する理由: すぐに使える高性能プールマネージャーが欲しいならコレ！
→ PoolManagerを今すぐチェック！

② Lean Pool – 軽量 & ハイパフォーマンスなオブジェクトプール

✅ 特徴

• 圧倒的に軽量で、動作が高速！
• シンプルなAPI で、スクリプトへの統合が簡単
• オープンソースで拡張性が高く、カスタマイズしやすい

🎯 おすすめの用途
✔ モバイルゲームの最適化（低メモリ環境に最適！）
✔ 複数の異なるオブジェクトの管理（弾丸 + 敵キャラ + エフェクトなど）
✔ VR・ARゲームでオブジェクトを効率よく管理

🛒 購入する理由: 軽量でハイパフォーマンスなオブジェクトプールならコレ！
→Lean Poolを今すぐチェック！

③ Advanced Pooling System – プロ向けの強力なオブジェクトプール

✅ 特徴

• 複雑なオブジェクト管理もラクラク！（階層管理や自動削除機能あり）
• 複数のプールを一括管理可能！（シーンごとに異なるプール設定もOK）
• プロジェクトの規模に関係なく安定動作！

🎯 おすすめの用途
✔ 大規模プロジェクト（MMOやオープンワールドなど）
✔ リアルタイムマルチプレイヤーゲームのオブジェクト管理
✔ 多数のエフェクトやNPCを扱うゲーム

🛒 購入する理由: 本格的なオブジェクト管理をしたいならコレ！
→Advanced Pooling Systemを今すぐチェック！

あなたにピッタリのオブジェクトプールアセットは？

💡 どれを選べばいいか迷っているなら…

• とにかく簡単に導入したいなら → PoolManager
• 軽量でパフォーマンスを重視するなら → Lean Pool
• プロジェクトが大規模なら → Advanced Pooling System

💰 ゲームの開発スピードをアップさせたいなら、これらのアセットを今すぐチェック！
👉 Unityアセットストアで購入する

Unity初心者必見！Asset Storeで手に入るゲーム制作が楽になるおすすめアセット

Unity Asset Storeで手に入るゲーム制作が楽になるおすすめアセットを厳選紹介！ゲーム制作を効率化し、クオリティをアップさせる便利なツールやテンプレートなどを紹介！

cbagames.jp

まとめ

オブジェクトプールを最適化することで、無駄なオブジェクトの生成・破棄を減らし、パフォーマンスを大幅に向上 させることができます。特に、次のポイントを意識するとよいでしょう。

🔹 プールサイズの最適化：必要な数を決め、動的調整を導入する
🔹 オブジェクトのリセット処理：不要なデータが残らないようにする
🔹 メモリの監視：不要なオブジェクトを削除し、パフォーマンスを維持
🔹 汎用的なプールの活用：さまざまなオブジェクトに適用する

この最適化テクニックを活用すれば、より軽快で快適なゲームプレイを実現できます！次のステップでは、実際のゲームでの応用例を詳しく解説していきます。

5. 実用例: 弾丸や敵キャラの管理

オブジェクトプールは、弾丸や敵キャラの管理 に特に効果を発揮します。ここでは、具体的な応用例として「弾丸の管理」と「敵キャラのスポーン」の2つのケースを紹介します。

1. 弾丸のオブジェクトプール

シューティングゲームでは、プレイヤーが弾を発射するたびに Instantiate で生成し、Destroy で削除すると、CPU負荷が増大し、ゲームのパフォーマンスが低下します。そこで、弾丸をオブジェクトプールで管理 すると、負荷を大幅に削減できます。

実装手順

① 弾丸のプレハブを用意

1. ヒエラルキー（Hierarchy）で「3D Object」→「Sphere」を作成（または適切な弾丸のモデルを使用）。
2. 「Bullet」という名前に変更。
3. Bullet に Rigidbody を追加し、Use Gravity をオフ にする。
4. 「Bullet」プレハブを作成（プロジェクトウィンドウにドラッグ）。

② BulletPool スクリプトを作成

1. プロジェクトウィンドウを右クリック → 「Create」→「C# Script」 を選択。
2. 「BulletPool」という名前 にして、以下のコードを入力。

using System.Collections.Generic;
using UnityEngine;

public class BulletPool : MonoBehaviour
{
    [SerializeField] private GameObject bulletPrefab;
    [SerializeField] private int poolSize = 20;

    private Queue<GameObject> pool = new Queue<GameObject>();

    void Start()
    {
        // 初期の弾丸をプールに格納
        for (int i = 0; i < poolSize; i++)
        {
            GameObject bullet = Instantiate(bulletPrefab);
            bullet.SetActive(false);
            pool.Enqueue(bullet);
        }
    }

    // 弾丸を取得
    public GameObject GetBullet()
    {
        if (pool.Count > 0)
        {
            GameObject bullet = pool.Dequeue();
            bullet.SetActive(true);
            return bullet;
        }
        else
        {
            GameObject newBullet = Instantiate(bulletPrefab);
            return newBullet;
        }
    }

    // 弾丸をプールに戻す
    public void ReturnBullet(GameObject bullet)
    {
        bullet.SetActive(false);
        pool.Enqueue(bullet);
    }
}

③ BulletShooter スクリプトを作成

プレイヤーが弾を撃つスクリプトを作成。

using UnityEngine;

public class BulletShooter : MonoBehaviour
{
    [SerializeField] private BulletPool bulletPool;
    [SerializeField] private Transform firePoint;
    [SerializeField] private float bulletSpeed = 15f;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space)) // スペースキーで弾発射
        {
            GameObject bullet = bulletPool.GetBullet();
            bullet.transform.position = firePoint.position;
            bullet.transform.rotation = firePoint.rotation;
            bullet.GetComponent<Rigidbody>().velocity = firePoint.forward * bulletSpeed;
        }
    }
}

④ Bullet スクリプトを作成

一定時間後に弾丸をプールに戻す。

using UnityEngine;

public class Bullet : MonoBehaviour
{
    private BulletPool bulletPool;

    void Start()
    {
        bulletPool = FindObjectOfType<BulletPool>();
    }

    void OnEnable()
    {
        Invoke("ReturnToPool", 3f); // 3秒後にプールに戻す
    }

    void ReturnToPool()
    {
        bulletPool.ReturnBullet(gameObject);
    }
}

動作確認

• ゲームを実行し、スペースキーを押すと弾が発射され、3秒後にプールへ戻る ことを確認。

2. 敵キャラのオブジェクトプール

敵キャラも、Instantiate で大量に生成すると 負荷が増え、ゲームが重くなる ため、オブジェクトプールで管理すると良い。

実装手順

① 敵キャラのプレハブを用意

1. ヒエラルキーで「3D Object」→「Capsule」を作成し、「Enemy」 に名前を変更。
2. 敵キャラの移動用スクリプト EnemyAI を作成（簡単な移動のみ）。

using UnityEngine;

public class EnemyAI : MonoBehaviour
{
    void Update()
    {
        transform.Translate(Vector3.forward * Time.deltaTime * 2f);
    }
}

3. 「Enemy」プレハブを作成（プロジェクトウィンドウにドラッグ）。

② EnemyPool スクリプトを作成

1. 「Create」→「C# Script」 で EnemyPool を作成し、以下を入力。

using System.Collections.Generic;
using UnityEngine;

public class EnemyPool : MonoBehaviour
{
    [SerializeField] private GameObject enemyPrefab;
    [SerializeField] private int poolSize = 10;

    private Queue<GameObject> pool = new Queue<GameObject>();

    void Start()
    {
        for (int i = 0; i < poolSize; i++)
        {
            GameObject enemy = Instantiate(enemyPrefab);
            enemy.SetActive(false);
            pool.Enqueue(enemy);
        }
    }

    public GameObject GetEnemy(Vector3 position)
    {
        if (pool.Count > 0)
        {
            GameObject enemy = pool.Dequeue();
            enemy.transform.position = position;
            enemy.SetActive(true);
            return enemy;
        }
        else
        {
            GameObject newEnemy = Instantiate(enemyPrefab);
            newEnemy.transform.position = position;
            return newEnemy;
        }
    }

    public void ReturnEnemy(GameObject enemy)
    {
        enemy.SetActive(false);
        pool.Enqueue(enemy);
    }
}

③ EnemySpawner スクリプトを作成

一定間隔で敵をスポーンさせる。

using UnityEngine;

public class EnemySpawner : MonoBehaviour
{
    [SerializeField] private EnemyPool enemyPool;
    [SerializeField] private Transform spawnPoint;
    [SerializeField] private float spawnInterval = 5f;

    void Start()
    {
        InvokeRepeating("SpawnEnemy", 0f, spawnInterval);
    }

    void SpawnEnemy()
    {
        enemyPool.GetEnemy(spawnPoint.position);
    }
}

動作確認

• ゲームを実行すると、一定間隔で敵がスポーンし、プールで管理される ことを確認。

まとめ

オブジェクトプールを活用すれば、弾丸や敵キャラの生成・破棄の負荷を減らし、パフォーマンスを向上 させることができます。

オブジェクトプールを活用すべきケース

✅ 弾丸：頻繁に生成・破棄されるため、プールが有効
✅ 敵キャラ：大量にスポーンする場合、オブジェクトプールで負荷を軽減
✅ エフェクト（パーティクル）：短時間で消えるオブジェクトはプールで管理すると最適
✅ アイテムや障害物：一定数のオブジェクトを管理するのに便利

このように、オブジェクトプールを適切に使うことで、ゲームのパフォーマンスを向上させることができます！次のステップでは、オブジェクトプールを使う際のよくあるミスと解決策 を紹介します。

6. よくあるミスと解決策

オブジェクトプールを実装すると、オブジェクトが消えない、再利用されない、メモリが無駄に消費される など、いくつかの問題に直面することがあります。ここでは、よくあるミスとその解決策を紹介します。

ミス①：オブジェクトがプールに戻らない

原因

• ReturnObject()（オブジェクトをプールに戻す処理）が正しく呼ばれていない。
• SetActive(false) していないため、オブジェクトが消えない。

解決策

• ReturnObject() を必ずオブジェクトのライフサイクルの最後に呼ぶ。
• Invoke() を使って、一定時間後にプールへ戻す。

void OnEnable()
{
    Invoke("ReturnToPool", 3f); // 3秒後にプールへ戻す
}

void ReturnToPool()
{
    objectPool.ReturnObject(gameObject);
}

ミス②：オブジェクトがプールされずに増え続ける

原因

• GetObject() の中で、新しいオブジェクトを無制限に Instantiate() している。
• ReturnObject() が正しく動作しておらず、オブジェクトがリサイクルされていない。

解決策

✅ プール内のオブジェクト数を制限する

• poolSize を設定し、それ以上新しく生成しないようにする。

if (pool.Count > 0)
{
    GameObject obj = pool.Dequeue();
    obj.SetActive(true);
    return obj;
}
else if (pool.Count < maxPoolSize) // 生成数を制限
{
    GameObject obj = Instantiate(prefab);
    return obj;
}
return null; // 制限を超えたら新規生成しない

ミス③：非アクティブになったオブジェクトがリセットされない

原因

• SetActive(false) にするだけで、速度や位置がリセットされていない。
• Rigidbody や ParticleSystem の状態が前回のままになっている。

解決策

✅ オブジェクトのリセット処理を実装する

• OnDisable() でオブジェクトの位置や速度をリセットする。

void OnDisable()
{
    transform.position = Vector3.zero;
    transform.rotation = Quaternion.identity;
    Rigidbody rb = GetComponent<Rigidbody>();
    if (rb != null)
    {
        rb.velocity = Vector3.zero;
        rb.angularVelocity = Vector3.zero;
    }
}

ミス④：オブジェクトがシーン上に残り続ける

原因

• pool.Enqueue() せずに SetActive(false) しているだけ。
• ReturnObject() が適切に呼ばれていない。

解決策

✅ プールに戻す処理を ReturnObject() 内で確実に行う

public void ReturnObject(GameObject obj)
{
    obj.SetActive(false);
    if (!pool.Contains(obj)) // 重複登録を防ぐ
    {
        pool.Enqueue(obj);
    }
}

ミス⑤：オブジェクトが即座に非アクティブになる

原因

• GetObject() した直後に ReturnObject() を呼んでしまっている。
• Invoke() の時間が短すぎて、すぐにプールへ戻ってしまう。

解決策

✅ 適切な時間を設定する

• 弾丸や敵キャラは、画面外に出る or 一定時間後に戻るようにする。

void OnTriggerExit(Collider other)
{
    if (other.CompareTag("Boundary")) // 画面外に出たら
    {
        objectPool.ReturnObject(gameObject);
    }
}

✅ Invokeの時間を長めに設定

void OnEnable()
{
    Invoke("ReturnToPool", 5f); // 5秒後に戻す（調整可能）
}

ミス⑥：オブジェクトのアクティブ状態が正しく管理されていない

原因

• GetObject() で SetActive(true) を忘れている。
• ReturnObject() で SetActive(false) を忘れている。

解決策

✅ オブジェクトのアクティブ状態を必ず変更する

public GameObject GetObject()
{
    if (pool.Count > 0)
    {
        GameObject obj = pool.Dequeue();
        obj.SetActive(true); // ここを忘れない！
        return obj;
    }
    else
    {
        GameObject obj = Instantiate(prefab);
        return obj;
    }
}

public void ReturnObject(GameObject obj)
{
    obj.SetActive(false); // ここも忘れない！
    pool.Enqueue(obj);
}

ミス⑦：プールが肥大化し、メモリを圧迫する

原因

• GetObject() で無制限にオブジェクトを生成している。
• 使われていないオブジェクトが増え続ける。

解決策

✅ 一定時間使われなかったオブジェクトを削除

• 一定時間プール内に存在したオブジェクトを削除 する。

IEnumerator CleanupPool()
{
    while (true)
    {
        yield return new WaitForSeconds(10f); // 10秒ごとにチェック
        if (pool.Count > poolSize)
        {
            GameObject obj = pool.Dequeue();
            Destroy(obj);
        }
    }
}

✅ メモリリークを防ぐために、不要なオブジェクトを削除

• 長時間使われていないオブジェクトを削除 する。

private class PoolObject
{
    public GameObject gameObject;
    public float lastUsedTime;
}

private List<PoolObject> pool = new List<PoolObject>();

void Update()
{
    float currentTime = Time.time;
    for (int i = pool.Count - 1; i >= 0; i--)
    {
        if (!pool[i].gameObject.activeInHierarchy && (currentTime - pool[i].lastUsedTime > 30f))
        {
            Destroy(pool[i].gameObject);
            pool.RemoveAt(i);
        }
    }
}

まとめ

オブジェクトプールを適切に実装するには、次の点に注意しましょう。

✅ オブジェクトが正しくプールに戻るようにする（ReturnObject() を確実に呼ぶ）
✅ プールのサイズを適切に管理する（無駄なオブジェクトを増やさない）
✅ オブジェクトの状態をリセットする（velocity や position をリセット）
✅ メモリリークを防ぐ（不要なオブジェクトを削除）
✅ 画面外のオブジェクトは自動でプールに戻す

オブジェクトプールを適切に使えば、CPU負荷の軽減・メモリ効率の向上・ゲームの安定化 に大きく貢献します。次のステップでは、この記事のまとめを行います！

7. まとめ

オブジェクトプールは、ゲームのパフォーマンスを向上させ、不要な処理負荷を減らすために非常に有効なテクニック です。特に、弾丸や敵キャラ、エフェクトの管理 など、頻繁に生成・破棄されるオブジェクトを扱う場合に最適です。

✅ この記事で学んだこと

1. オブジェクトプールの基本
   • 頻繁な Instantiate() / Destroy() は CPU負荷が増大し、フレームレート低下の原因 となる。
   • オブジェクトプールを使えば、事前にオブジェクトを用意して再利用できる ため、パフォーマンスが向上する。
2. Unityでのオブジェクトプールの実装
   • Queue<GameObject> を利用してオブジェクトを管理する方法を学んだ。
   • プールからオブジェクトを取得し、不要になったら戻す処理 を実装。
3. オブジェクトプールの最適化ポイント
   • プールサイズを適切に設定する（過剰な生成を防ぐ）
   • 非アクティブオブジェクトのリセット処理を行う（position や velocity の初期化）
   • 一定時間使われなかったオブジェクトを削除 してメモリを節約
4. 実用例（弾丸・敵キャラの管理）
   • 弾丸のオブジェクトプールで発射と再利用を効率化
   • 敵キャラのスポーンをプールで管理し、無駄な Instantiate() を削減
5. よくあるミスと解決策
   • オブジェクトがプールに戻らない → ReturnObject() を確実に呼ぶ
   • オブジェクトが増え続ける → プールサイズを制限し、未使用オブジェクトを削除
   • 非アクティブになったオブジェクトがリセットされない → velocity や position をリセット

✅ オブジェクトプールを活用するメリット

✔ パフォーマンス向上：不要な Instantiate() / Destroy() を減らし、フレームレートを安定させる
✔ メモリ効率の向上：オブジェクトの再利用により、無駄なメモリ使用を防ぐ
✔ ゲームの安定性向上：ガベージコレクション（GC）発生を抑え、スムーズな動作を維持

✅ 今後の応用

オブジェクトプールは、弾丸や敵キャラの管理だけでなく、さまざまなオブジェクトに応用可能 です。

🔹 エフェクトの管理（パーティクル・爆発など）
🔹 アイテムや障害物のスポーン管理
🔹 NPCのスポーン管理
🔹 UI要素（ポップアップウィンドウ、メッセージボックス）の管理

ゲームの最適化を進めるために、オブジェクトプールを積極的に活用してみてください！

よくある質問（FAQ）

【徹底解説】Unityのガベージコレクション(GC)を最適化してゲームの処理落ちを防ぐ方法

Unityゲームのカクつきやフレーム落ちの原因となるGC（ガベージコレクション）を最適化する方法を解説！オブジェクトプールの活用やメモリ管理の工夫を取り入れて、スムーズなゲームプレイを実現しよう。初心者でもできる最適化テクニックを紹介！

cbagames.jp

関連記事:

【Unity入門】2Dシューティングゲームを簡単に作る手順を解説【Unity初心者向け】2Dブロック崩しゲームの作り方を解説！Unityのスクリプト設計を改善！SOLID原則で整理する方法【Unity】2Dタワーディフェンスゲームの作り方②！武器配置と弾の発射を実装【Unity】ツムツム風パズルゲームを作ろう！初心者向け完全ガイドUnityのシリアライズ完全ガイド！データの保存・読み込みを自由自在に【実践】UnityでJSONデータ管理！セーブ＆ロードを最適化する方法【Unity C#】カスタムイベントの作り方！EventとActionを使いこなそうUnity初心者が最初に作るべきゲーム5選！楽しく学べるステップバイステップガイド【Unity】2Dタワーディフェンスゲームの作り方④！敵のスポーンとオブジェクトプール実装