UnityでGPUを活用するCompute Shaderの基礎と実装例

1. はじめに

Unityでのゲーム開発では、ほとんどの処理をCPU（中央処理装置）が担当します。しかし、膨大な計算が必要な物理シミュレーションや高度なグラフィックス処理を行う場合、CPUだけではパフォーマンスが不足することがあります。そこで登場するのが Compute Shader（コンピュートシェーダー） です。

Compute Shaderとは？

Compute Shaderは、GPU（グラフィック処理装置）を使って並列計算を行うためのプログラムです。通常、GPUは3Dレンダリングのために使われますが、Compute Shaderを活用することで、画像処理、物理シミュレーション、AI処理などの汎用計算（GPGPU: General-Purpose computing on Graphics Processing Units）が可能になります。

CPU vs GPU：どこが違うの？

CPUとGPUは、それぞれ異なる役割を持っています。

例えば、100万個のオブジェクトの位置を毎フレーム更新する場合、CPUで逐次処理すると膨大な時間がかかります。しかし、GPUの並列処理を活用すれば、各オブジェクトの計算を同時に処理できるため、大幅にパフォーマンスを向上させることができます。

Compute Shaderを使うメリット

Compute Shaderを活用することで、以下のようなメリットがあります。

1. 計算速度の向上
   • 数百～数千のスレッドで並列処理ができるため、大量のデータを高速に処理できる。
2. CPU負荷の軽減
   • CPUで処理していた重い計算をGPUに任せることで、CPUのリソースを他の処理に回せる。
3. リアルタイム処理の向上
   • 物理シミュレーションやポストプロセスエフェクトなど、リアルタイムでの処理が求められる場面で有利。

Compute Shaderが活躍する場面

Compute Shaderは、以下のような処理で特に活躍します。

✅ ポストプロセスエフェクト
画像のブラー処理やエッジ検出、ノイズフィルターなどのエフェクトを高速化できます。

✅ 物理シミュレーション
流体シミュレーションやパーティクルシステムの計算をGPUに任せることで、大量のオブジェクトをリアルタイムに処理できます。

✅ AI（機械学習）やパスファインディング
ゲーム内のNPCの経路探索やAIの推論処理をGPUで並列処理できます。

✅ データ処理（数値計算・統計処理）
大量のデータを解析する場合、GPUの計算能力を活かすことで処理速度を大幅に向上できます。

Compute Shaderは、Unityにおいて高パフォーマンスなゲームやリアルタイムシミュレーションを作るための強力なツールです。次のセクションでは、Compute Shaderの基本概念とUnityでの実装方法を詳しく解説していきます！

2. Compute Shaderの基本

前のセクションでは、Compute Shaderを使うメリットについて紹介しました。ここでは、Compute Shaderの基本的な仕組みや、Unityで使用するための準備について解説します。

Compute Shaderの仕組み

Compute Shaderは、GPUを使って並列処理を行うためのシェーダープログラムです。通常のシェーダー（頂点シェーダーやフラグメントシェーダー）はレンダリング（描画）のために使われますが、Compute Shaderは「汎用計算」に特化しています。

Compute Shaderの動作の流れ

1. C#スクリプトでデータを準備
   • 計算に必要なデータをGPUに送る（ComputeBufferを利用）
2. Compute Shaderを実行
   • Dispatch() を呼び出してGPUで並列計算を開始
3. 計算結果を取得
   • 計算が終わったデータをCPUに戻す or 直接GPU上で利用（テクスチャやバッファを通じて）

GPUの並列処理とワークグループ

Compute Shaderは、複数のスレッド（並列処理単位）で計算を実行します。スレッドは「ワークグループ」と呼ばれる単位にまとめられ、各グループ内で並列処理が行われます。

ワークグループの概念

ワークグループのサイズは (x, y, z) の3次元で指定でき、それぞれ以下のように意味を持ちます。

• x: 横方向のスレッド数
• y: 縦方向のスレッド数（2Dテクスチャ処理などに使用）
• z: 奥行き方向のスレッド数（3Dデータ処理などに使用）

例えば、(8, 8, 1) のワークグループを設定すると、1つのグループ内に 8 × 8 = 64 個のスレッドが作られます。そして、複数のワークグループを指定することで、全体のスレッド数を大きくすることができます。

UnityでCompute Shaderを利用する準備

UnityでCompute Shaderを使うには、以下の準備が必要です。

1. Compute Shaderの作成

1. プロジェクトウィンドウを右クリック
   • 「Create」→「Shader」→「Compute Shader」を選択
2. 作成されたCompute Shaderの名前を「MyComputeShader」に変更

これで、MyComputeShader.compute というファイルが作成されます。

2. Compute Shaderの基本構造

作成されたCompute Shaderを開くと、以下のようなコードが記述されています。

#pragma kernel CSMain

[numthreads(8, 8, 1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    // ここに並列計算の処理を書く
}

このコードのポイントを解説します。

• #pragma kernel CSMain
  • CSMain という関数（カーネル関数）を実行することを指定
• [numthreads(8, 8, 1)]
  • 1つのワークグループのスレッド数を (8, 8, 1) に設定
• uint3 id : SV_DispatchThreadID
  • 各スレッドのID（どのスレッドがどのデータを処理するか）を取得

「Compute Shaderを理解するには、GPUの並列処理やコードの記述が必要になります。ただ、より視覚的にシェーダーを設計したい場合は、『Amplify Shader Editor』のようなツールを活用すると、ノードベースで直感的にシェーダーを作成できます。」

ここまでで、Compute Shaderの基本概念と、Unityでの準備方法を解説しました。次のセクションでは、実際にCompute ShaderをC#スクリプトと連携して実行する方法 を解説していきます！

3. Compute Shaderの実装

前のセクションでは、Compute Shaderの基本概念とUnityでの準備方法を解説しました。ここからは、実際にCompute Shaderを実装し、C#スクリプトと連携する方法 を詳しく説明していきます。

ステップ1: Compute Shaderを作成

まず、Unityで新しいCompute Shaderを作成し、シンプルな計算処理を実装してみましょう。

① Compute Shaderを作成する

1. プロジェクトウィンドウを右クリック
   • 「Create」→「Shader」→「Compute Shader」を選択
2. 名前を「SimpleComputeShader」に変更
3. 作成された SimpleComputeShader.compute を開く

② Compute Shaderの基本コード

次のようにコードを記述します。

#pragma kernel CSMain

[numthreads(8, 1, 1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    // スレッドIDに基づいて数値を計算する
    uint index = id.x;
}

このコードでは、各スレッドが id.x を取得し、それぞれのスレッドが異なるインデックスを持つことを確認できます。

ステップ2: C#スクリプトと連携

Compute Shaderは単体では動作せず、C#スクリプトから呼び出して実行する必要があります。

① C#スクリプトを作成

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

using UnityEngine;

public class ComputeShaderController : MonoBehaviour
{
    public ComputeShader computeShader; // Compute ShaderをInspectorから設定
    private ComputeBuffer resultBuffer; // 計算結果を格納するバッファ

    private void Start()
    {
        // 計算結果を格納するバッファを作成（100個の整数）
        resultBuffer = new ComputeBuffer(100, sizeof(int));
        
        // Compute Shaderのカーネル（処理単位）を取得
        int kernelHandle = computeShader.FindKernel("CSMain");

        // バッファをCompute Shaderにセット
        computeShader.SetBuffer(kernelHandle, "Result", resultBuffer);

        // Compute Shaderを実行（ワークグループ数: 100 / 8 = 13）
        computeShader.Dispatch(kernelHandle, 13, 1, 1);

        // バッファの内容を取得
        int[] results = new int[100];
        resultBuffer.GetData(results);

        // 結果をコンソールに表示
        for (int i = 0; i < results.Length; i++)
        {
            Debug.Log("Result[" + i + "] = " + results[i]);
        }

        // バッファを解放
        resultBuffer.Release();
    }
}

「C#スクリプトを使ってCompute Shaderを制御する方法を紹介しましたが、シェーダーの記述自体をもっと簡単にしたいなら、Amplify Shader Editorのようなノードベースのエディタを活用すると、スクリプトを書かずにシェーダーを設計することもできます。」

ステップ3: Compute Shaderでデータを処理

C#スクリプトとCompute Shaderを正しく連携させるために、Compute Shaderのコードを修正します。

① Compute Shaderにバッファを追加

先ほどの SimpleComputeShader.compute を開き、次のように編集します。

#pragma kernel CSMain

RWStructuredBuffer<int> Result; // 結果を格納するバッファ

[numthreads(8, 1, 1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    uint index = id.x;
    Result[index] = index * 2; // スレッドIDを2倍した値を格納
}

このコードでは、各スレッドが id.x を取得し、それを2倍にして Result バッファに格納します。

ステップ4: 結果を確認

1. Unityで新しい空のGameObjectを作成
2. 「ComputeShaderController」スクリプトをアタッチ
3. Compute ShaderをInspectorで設定
4. 実行してコンソールを確認
   • 結果が Result[0] = 0, Result[1] = 2, Result[2] = 4, ... のように表示される

まとめ

• Compute Shaderを作成 し、並列処理の基本を学んだ
• C#スクリプトと連携 してデータをやり取りする方法を実装した
• 実際の計算結果を確認 することで、Compute Shaderの動作を理解した

次のセクションでは、Compute Shaderを活用した実用的な処理（画像処理・パーティクルシミュレーションなど） について詳しく解説していきます！

4. 実用的なCompute Shaderの例

ここまでで、Compute Shaderの基本的な使い方とC#スクリプトとの連携方法を学びました。ここからは、実際に役立つCompute Shaderの応用例 を紹介します。

例1: シンプルな並列計算（数値の2倍）

まず、Compute Shaderの基本的な並列処理をもう少し具体的な例で確認してみましょう。
ここでは、100万個の数値をCompute Shaderで2倍にする処理 を実装します。

① Compute Shaderのコード

MultiplyNumbers.compute を作成し、以下のコードを記述します。

#pragma kernel CSMain

RWStructuredBuffer<int> DataBuffer; // データを格納するバッファ

[numthreads(256, 1, 1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    uint index = id.x;
    DataBuffer[index] *= 2; // 各数値を2倍にする
}

② C#スクリプト

次に、MultiplyNumbersController.cs を作成し、以下のコードを記述します。

using UnityEngine;

public class MultiplyNumbersController : MonoBehaviour
{
    public ComputeShader computeShader;
    private ComputeBuffer buffer;
    private int[] data;

    void Start()
    {
        int dataSize = 1000000; // 100万個のデータ
        data = new int[dataSize];

        // 初期値を設定（1, 2, 3, ...）
        for (int i = 0; i < dataSize; i++)
            data[i] = i + 1;

        // ComputeBufferを作成
        buffer = new ComputeBuffer(dataSize, sizeof(int));
        buffer.SetData(data);

        int kernel = computeShader.FindKernel("CSMain");
        computeShader.SetBuffer(kernel, "DataBuffer", buffer);

        // ワークグループを設定（100万 / 256 = 3906.25 → 切り上げて3907）
        computeShader.Dispatch(kernel, 3907, 1, 1);

        // 結果を取得
        buffer.GetData(data);
        buffer.Release();

        // 先頭の10個のデータをコンソールに表示
        for (int i = 0; i < 10; i++)
        {
            Debug.Log($"data[{i}] = {data[i]}");
        }
    }
}

💡 ポイント:

• numthreads(256, 1, 1) を指定し、一度に 256個のスレッド で処理
• Dispatch(3907, 1, 1) で 合計100万個のデータを処理
• 結果が2倍になっているか確認（例: data[0] = 2, data[1] = 4, …）

例2: 2D画像のブラー処理

次に、Compute Shaderを使って画像にブラー（ぼかし）処理を適用してみます。
通常のCPUベースの処理と比べ、GPUの並列処理で高速に実行できます。

① Compute Shaderのコード

BlurShader.compute を作成し、以下のコードを記述します。

#pragma kernel CSMain

Texture2D<float4> InputTexture;
RWTexture2D<float4> OutputTexture;

[numthreads(8, 8, 1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    int2 pixel = int2(id.xy);
    float4 color = float4(0, 0, 0, 0);
    int kernelSize = 5;
    int halfKernel = kernelSize / 2;
    float count = 0;

    for (int y = -halfKernel; y <= halfKernel; y++)
    {
        for (int x = -halfKernel; x <= halfKernel; x++)
        {
            color += InputTexture[pixel + int2(x, y)];
            count++;
        }
    }

    OutputTexture[pixel] = color / count; // 平均化してブラーを適用
}

② C#スクリプト

BlurEffect.cs を作成し、以下のコードを記述します。

using UnityEngine;

public class BlurEffect : MonoBehaviour
{
    public ComputeShader computeShader;
    public Texture2D sourceTexture;
    private RenderTexture outputTexture;

    void Start()
    {
        outputTexture = new RenderTexture(sourceTexture.width, sourceTexture.height, 0);
        outputTexture.enableRandomWrite = true;
        outputTexture.Create();

        int kernel = computeShader.FindKernel("CSMain");
        computeShader.SetTexture(kernel, "InputTexture", sourceTexture);
        computeShader.SetTexture(kernel, "OutputTexture", outputTexture);

        computeShader.Dispatch(kernel, sourceTexture.width / 8, sourceTexture.height / 8, 1);
    }

    void OnGUI()
    {
        GUI.DrawTexture(new Rect(10, 10, 256, 256), sourceTexture);
        GUI.DrawTexture(new Rect(276, 10, 256, 256), outputTexture);
    }
}

💡 ポイント:

• numthreads(8, 8, 1) で 8×8 ピクセルずつ並列処理
• カーネルサイズ5×5のブラー を適用
• OnGUI() を使って 元の画像とブラー後の画像を表示

例3: パーティクルの物理シミュレーション

最後に、Compute Shaderを使って数千のパーティクルをリアルタイムでシミュレーションする例を紹介します。

① Compute Shaderのコード

ParticlePhysics.compute を作成し、以下のコードを記述します。

#pragma kernel CSMain

RWStructuredBuffer<float3> Positions;
RWStructuredBuffer<float3> Velocities;
float deltaTime;

[numthreads(256, 1, 1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    uint index = id.x;
    Velocities[index] += float3(0, -9.81, 0) * deltaTime; // 重力を適用
    Positions[index] += Velocities[index] * deltaTime; // 速度に基づいて位置を更新
}

② C#スクリプト

ParticleSimulator.cs を作成し、以下のコードを記述します。

using UnityEngine;

public class ParticleSimulator : MonoBehaviour
{
    public ComputeShader computeShader;
    private ComputeBuffer positionBuffer, velocityBuffer;
    private Vector3[] positions, velocities;

    void Start()
    {
        int particleCount = 10000;
        positions = new Vector3[particleCount];
        velocities = new Vector3[particleCount];

        positionBuffer = new ComputeBuffer(particleCount, sizeof(float) * 3);
        velocityBuffer = new ComputeBuffer(particleCount, sizeof(float) * 3);

        positionBuffer.SetData(positions);
        velocityBuffer.SetData(velocities);

        int kernel = computeShader.FindKernel("CSMain");
        computeShader.SetBuffer(kernel, "Positions", positionBuffer);
        computeShader.SetBuffer(kernel, "Velocities", velocityBuffer);
    }

    void Update()
    {
        int kernel = computeShader.FindKernel("CSMain");
        computeShader.SetFloat("deltaTime", Time.deltaTime);
        computeShader.Dispatch(kernel, 40, 1, 1);
    }

    void OnDestroy()
    {
        positionBuffer.Release();
        velocityBuffer.Release();
    }
}

💡 ポイント:

• 10,000個のパーティクルをリアルタイムで処理
• Compute Shaderを毎フレーム実行し、重力を適用
• 大規模なパーティクルをGPUで効率的に処理可能

これらの例を通じて、Compute Shaderを実際の開発に応用する方法が理解できたと思います。次のセクションでは、Compute Shaderの最適化 や パフォーマンス向上のテクニック について解説します！

5. Compute Shaderの応用と最適化

ここまでで、Compute Shaderの基本と実装例を紹介しました。しかし、実際のゲーム開発やリアルタイム処理では、単にCompute Shaderを使うだけではなく、より高速に、より効率的に処理を行う最適化 が求められます。

このセクションでは、Compute Shaderの応用技術と最適化のテクニック について解説していきます。

1. Compute Shaderの応用例

Compute Shaderは、単なる数値計算だけでなく、さまざまな場面で活用できます。

✅ 物理シミュレーション

• 流体シミュレーション:
  Compute Shaderを活用すると、大量の粒子を高速に処理し、リアルな水や煙の挙動をシミュレート可能。
• 剛体シミュレーション:
  ボクセルベースの物理処理や、布やロープの動きの計算にも利用可能。

✅ 画像処理

• ポストプロセスエフェクト:
  画像のブラー（ぼかし）、エッジ検出、ノイズフィルターなどをリアルタイムに適用。
• データ解析:
  画像の色情報を解析し、特定の色を検出するなどの処理に活用。

✅ AI・機械学習

• パスファインディング:
  NPCの移動経路をGPUで並列処理し、ゲーム内のナビゲーションを高速化。
• ニューラルネットワークの計算:
  AIの学習や推論プロセスをGPUで並列実行し、パフォーマンスを向上。

2. Compute Shaderの最適化テクニック

Compute Shaderを使うときに、処理速度を向上させるための重要なポイントを解説します。

① ワークグループのサイズを適切に設定する

Compute Shaderでは、numthreads(x, y, z) でスレッドの数を設定できます。
これは、GPUの並列処理ユニット（WarpやWavefront）に最適な値を設定することで、無駄なく処理を並列化する ことができます。

例えば、NVIDIAのGPUではWarpサイズが32、AMDのGPUではWavefrontサイズが64 なので、
numthreads(32, 1, 1) や numthreads(8, 8, 1) など、Warp/Wavefrontサイズの倍数 にするのが理想的です。

[numthreads(32, 1, 1)] // NVIDIA向け最適化
void CSMain (uint3 id : SV_DispatchThreadID)
{
    ...
}

② メモリアクセスの最適化

GPUではメモリアクセスがボトルネックになることが多いので、以下の対策を取ると高速化できます。

✅ 共有メモリ（Shared Memory）を活用

ワークグループ内で頻繁にアクセスするデータは共有メモリに保存 することで、メモリアクセスを減らすことができます。

groupshared float sharedData[32]; // 共有メモリを使用

✅ 連続したメモリアクセスを行う

メモリアクセスがランダムになると、キャッシュ効率が悪くなり、速度が落ちる可能性があります。
可能な限り連続したメモリアクセスを行う ようにデータ構造を設計すると高速化できます。

uint index = id.x + id.y * width; // 連続アクセスを意識
outputBuffer[index] = inputBuffer[index] * 2;

③ データ転送を最適化

Compute Shaderでは、CPUとGPU間のデータ転送が遅い ため、できるだけGPU内で処理を完結させるのがポイント。

✅ バッファのデータ転送を減らす

Compute Bufferを頻繁に GetData() してCPUに戻すのは非効率です。
可能な限りGPU内で処理を完了 し、最終的な結果だけをCPUに戻すのが理想的です。

// 結果をCPUに渡すのは最後の処理だけ
buffer.GetData(data);

3. Compute Shaderのデバッグ方法

Compute Shaderのデバッグは、通常のC#スクリプトとは異なり、リアルタイムで値を確認しにくい という課題があります。
以下の方法でデバッグすると、バグを見つけやすくなります。

① コンソールにデータを出力

Compute Shaderのデータをデバッグするには、一度バッファを GetData() でCPUに取り出し、Debug.Log() で確認する。

int[] results = new int[100];
buffer.GetData(results);
for (int i = 0; i < 10; i++)
{
    Debug.Log("Result[" + i + "] = " + results[i]);
}

② GPUデバッガ（RenderDoc）を活用

RenderDocやNVIDIA NsightなどのGPUデバッガを使用 すると、Compute Shaderのメモリアクセスやスレッドの動作を詳細に解析できます。

③ 可視化してデバッグ

結果をテクスチャに出力して、Unityのシーン上に表示することで、どのようにデータが処理されているかを視覚的に確認する。

computeShader.SetTexture(kernel, "OutputTexture", renderTexture);

4. Compute Shaderのパフォーマンス計測

Compute Shaderの最適化を進めるには、処理時間を測定してボトルネックを特定 することが重要です。

① GPUプロファイラを使用

UnityのFrame Debugger や Profiler を使用すると、GPUの負荷を詳細に分析できます。

② System.Diagnostics.Stopwatch を使う

C#側で簡単な計測を行う場合、Stopwatch を利用して Dispatch() の実行時間を計測できます。

var stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
computeShader.Dispatch(kernel, 128, 1, 1);
stopwatch.Stop();
Debug.Log("Compute Shader Execution Time: " + stopwatch.ElapsedMilliseconds + " ms");

まとめ

• Compute Shaderは物理シミュレーションや画像処理、AIなど幅広く活用可能
• ワークグループサイズやメモリアクセスを最適化すると高速化できる
• CPU-GPU間のデータ転送を減らすとパフォーマンスが向上
• デバッグには Debug.Log() や RenderDoc などのツールを活用
• プロファイラや Stopwatch を使ってボトルネックを特定しよう

6. まとめ

この記事では、UnityでGPUを活用するCompute Shaderの基礎と実装方法 について詳しく解説しました。Compute Shaderを使うことで、CPUでは処理が重くなりがちな計算をGPUの並列処理 を活かして高速に実行できることがわかりましたね。

✅ Compute Shaderの重要ポイント

• CPU vs GPUの違い
  • CPUは逐次処理、GPUは並列処理が得意
  • 大量のデータ処理やシミュレーションに向いている
• Compute Shaderの基本的な使い方
  • Compute Shader を作成し、C#スクリプトで連携 して実行
  • numthreads(x, y, z) で並列処理のスレッド数を指定
  • Dispatch(x, y, z) でワークグループごとに実行
• 実用的なCompute Shaderの例
  • 数値計算: 100万個のデータを2倍にする
  • 画像処理: ブラー（ぼかし）やエッジ検出
  • 物理シミュレーション: 重力を考慮したパーティクルの動き
• 最適化テクニック
  • ワークグループサイズをGPUのアーキテクチャに合わせる
  • 共有メモリ を活用してメモリアクセスを最適化
  • CPU-GPU間のデータ転送を最小化 してパフォーマンス向上

次に学ぶべきこと

Compute Shaderの基本を理解したら、次のステップとしてより高度なテクニック に挑戦してみましょう。

🔹 高度なCompute Shaderの活用例

• 流体シミュレーション: 水や煙のリアルな動きを作る
• ボクセルベースの破壊表現: GPUで物理破壊を処理
• 光のシミュレーション: レイトレーシングをCompute Shaderで実装

🔹 おすすめ学習リソース

• Unity公式ドキュメント: Compute Shader Documentation
• GPU最適化の基礎: NVIDIAやAMDのCompute Shader解説記事
• Shader Playground: ShaderやCompute Shaderを試せるWebサービス

Compute ShaderでUnityのパフォーマンスを最大化しよう！

UnityのCompute Shaderを活用すれば、ゲームのパフォーマンスを向上 させるだけでなく、高度なリアルタイム処理 も実現できます。特に、物理シミュレーションや画像処理 に興味がある人は、どんどんCompute Shaderを試してみてください！

これからも、UnityでのGPUプログラミングを深く学び、最適化のテクニックを磨いていきましょう！🔥🔥🔥

よくある質問（FAQ）

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

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

cbagames.jp

関連記事:

【完全解説】Unityの非同期処理！Coroutineとasync/awaitの違いと使い方【実践】Unityでスレッド処理を活用する方法！Job SystemとBurst Compilerで高速化Unityのスクリプト設計を改善！SOLID原則で整理する方法【実践】UnityでJSONデータ管理！セーブ＆ロードを最適化する方法UnityのShader Graphでできること！初心者でも簡単に作れるシェーダー入門Unityのシリアライズ完全ガイド！データの保存・読み込みを自由自在に【Unity C#】カスタムイベントの作り方！EventとActionを使いこなそうUnityのオブジェクト指向設計！継承・ポリモーフィズム・インターフェースを徹底解説【Unity】2Dタワーディフェンスゲームの作り方②！武器配置と弾の発射を実装Unityでオブジェクトプールを実装する方法と最適化ポイント