Unity を見てみたおかげで、C++ のコルーチンが何を目的としているのか理解できました。

2026年3月20日 – C++ とゲーム開発

私はコルーチンに関する多くの講演を見てきましたが、Unity が C# でそれらをどのように使っているかを見るまで、本当に理解できたことはありませんでした。
C++ におけるコルーチンはすでに6年間存在しますが、それでも実際のプロダクションコードで触れたことはありません。これは、低レベル機能であり、プロジェクトへ組み込むには多くのカスタム plumbing が必要だからだと考えられます。さらに重要なのは、具体的な例が不足している点です。

Unity のコルーチン例

void Update()
{
    if (Input.GetKeyDown("f"))
        StartCoroutine(Fade());
}

IEnumerator Fade()
{
    Color c = renderer.material.color;
    for (float alpha = 1f; alpha >= 0; alpha -= 0.1f)
    {
        c.a = alpha;
        renderer.material.color = c;
        yield return null;   // “次のフレーム”
    }
}

C# の純粋主義者は

yield

yield

await NextFrame()

await

なぜコルーチンなのか？

上記の例は単純です。もう少し複雑なエフェクトを試してみましょう。

IEnumerator TimeWarp()
{
    // 左へジャンプ
    transform.position.x -= 1.f;
    yield return null;

    // 右へステップ
    for (int i = 0; i < 4; ++i)
    {
        transform.position.x += 0.2f;
        yield return null;
    }

    // … 手を腰に当てる …

    // 再度タイムワープ
    for (int i = 0; i < 4; ++i)
    {
        transform.Rotate(0.f, 90.f * i, 0.f);
        yield return null;
    }
}

これを C++ の通常の関数オブジェクトやラムダで書くと、汚い状態機械が出来上がります。

class TimeWarp
{
public:
    enum class State { Jump, StepRight, HandsOnHips, DoAgain };
    State _state = State::Jump;
    int _i = 0;
    Transform* _transform;

    TimeWarp(Transform& transform) : _transform(&transform) {}

    bool operator()()
    {
        switch (_state)
        {
            case State::Jump:
                _transform->position.x -= 1.f;
                _state = State::StepRight;
                break;
            case State::StepRight:
                _transform->position.x += 0.2f;
                if (++_i == 4) { _state = State::HandsOnHips; _i = 0; }
                break;
            // …
            case State::DoAgain:
                _transform->Rotate(0.f, 90.f * i, 0.f);
                if (++_i == 4) return true;   // 完了
                break;
        }
        return false;
    }
};

見た目が汚く、読みづらいです。エフェクトを個別の動作に分割したり継続をキューに入れたりすることは可能ですが、面倒です。

C++23 実装

<generator>

std::generator<std::monostate> TimeWarp(GameObject& obj)
{
    // 左へジャンプ
    obj.transform.position.x -= 1.f;
    co_yield {};

    // 右へステップ
    for (int i = 0; i < 4; ++i)
    {
        obj.transform.position.x += 0.2f;
        co_yield {};
    }

    // … 手を腰に当てる …

    // 再度タイムワープ
    for (int i = 0; i < 4; ++i)
    {
        obj.transform.Rotate(0.f, 90.f * i, 0.f);
        co_yield {};
    }
}

これは実質 Unity が使うハックと同じです。

co_yield

co_await

execution

C++ の簡易 Unity‑style コルーチンランナー

以下は毎フレームすべてのアクティブコルーチンを1回だけ走らせる最小限のエグゼキュータです。

class effects_manager
{
public:
    void add(std::generator<std::monostate> effect)
    {
        _effects.push_back(std::move(effect));
        _iterators.push_back(_effects.back().begin());
    }

    void run()
    {
        // 完了したコルーチンを除去
        int first = 0;
        for (; first != _effects.size() &&
               _iterators[first] != _effects[first].end(); ++first);

        if (first != _effects.size())
        {
            for (int i = first; ++i != _effects.size(); )
                if (_iterators[i] != _effects[i].end())
                {
                    _effects[first] = std::move(_effects[i]);
                    _iterators[first] = std::move(_iterators[i]);
                    ++first;
                }
            _effects.erase(begin(_effects) + first, end(_effects));
            _iterators.erase(begin(_iterators) + first, end(_iterators));
        }

        // すべてのコルーチンを進める
        for (int i = 0; i < _effects.size(); ++i)
            ++_iterators[i];
    }

private:
    std::vector<std::generator<std::monostate>> _effects;
    using effect_iterator =
        decltype(std::declval<std::generator<std::monostate>>().begin());
    std::vector<effect_iterator> _iterators;
};

使用例:

effects_manager effects;
effects.add(TimeWarp(object));
...
effects.run();   // 毎フレーム1回呼び出す

ボーナス：副作用ではなく描画データを返す

コルーチンから

Draw

struct Draw { Model model; Transform transform; };

std::generator<Draw> TimeWarp(const Model& model)
{
    vec3 position{-1.f, 0.f, 0.f};
    co_yield Draw{model, {.position = position}};
    for (int i = 0; i < 4; ++i) {
        position.x += 0.2f;
        co_yield Draw{model, {.position = position}};
    }
    // …
}

ランナーは

Draw

std::vector<Draw> run()
{
    std::vector<Draw> draws;
    draws.reserve(_effects.size());
    for (int i = 0; i < _effects.size(); ++i) {
        draws.push_back(*_iterators[i]);
        ++_iterators[i];
    }
    return draws;
}

TBB や他の並列ツールを使えば、ループを並列化できます。

std::vector<Draw> draws(_effects.size());
tbb::parallel_for(0zu, _effects.size(),
                  [this, &draws](size_t i)
                  {
                      draws[i] = *_iterators[i];
                      ++_iterators[i];
                  });
return draws;

結論

C++ の

<generator>