1
2

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

Three.js vs AI自作ゲームエンジン【Three.jsは過去の遺物?】

1
Posted at

はじめに:AI時代に「汎用3Dライブラリ」は本当に必要なのか?

これまで Web で 3D アプリやゲームを作るなら 「Three.js 一択」 というのが常識でした。
理由はシンプルで、人間が WebGPU / WGSL シェーダー / WebAssembly SIMD / 独自の描画パイプライン をゼロから手書きするには、開発コストも保守コストも高すぎたからです。

しかし、2026年の今、その前提は崩れ始めています。

もし AI に「その Web アプリ専用に極限まで最適化した自作ゲームエンジン(外部ライブラリ 0)」を Rust(WebAssembly SIMD128)+生 WebGPU(WGSL)で書かせたら、最新の Three.js(WebGPURenderer + TSL) にどれだけの差がつくのか?

机上の空論ではなく、完全に同一の 3D Web アプリを「AI自作エンジン」と「Three.js v0.187.0」の両方で実装し、PC・Android・iPhone の実機 3 台でガチ計測してみました。

AETHER FLOCK リアルタイム同時比較

まずは、実際にブラウザ上で動くデモをご覧ください(1クリックで自動ベンチマークも実行できます)。


先に結論(TL;DR):実機 3 台の計測結果

iPhone(Apple GPU)・Pixel 10a(ARM Mali-G715)・Windows PC(AMD Radeon RDNA-2)の 実機 3 デバイスすべてで、全 3 シナリオにおいて AI 自作エンジンが Three.js(WebGPURenderer)を上回りました。

実機 3 デバイス性能比較:実効 FPS & 実測 GPU パス時間

インパクトの大きい数値を抜粋すると以下の通りです。

  • iPhone(iOS Safari / Apple GPU): 4,000体描画で 60.0 FPS vs 19.7 FPS(実効 FPS 3.04倍)、16,384羽ボイド物理で GPU時間 3.17倍高速
  • Pixel 10a(Android / Mali-G715): 4,000体描画で 59.9 FPS vs 31.3 FPS(CPU 49.3倍・GPU時間 7.18倍高速)
  • Windows PC(AMD Radeon RDNA-2): 4,000体描画で CPU時間 0.41 ms vs 33.34 ms(82.12倍高速)、JS ヒープ 48% 削減
  • エンジン部ペイロード容量: 59 KB(gzip 17 KB) vs 3,839 KB(gzip 759 KB)= 65.1倍軽量(Rust Wasm バイナリは 10.8 KB、依存ライブラリ 0)

CPU ボトルネック & バンドルサイズ比較

「じゃあ Three.js は過去の遺物なのか?」
結論から言えば 「過去の遺物ではない。ただし『何も考えずに選ぶデフォルト』ではなくなった」 というのが実測から見えたリアルな答えです。記事後半で「Three.js が依然として最強な領域」も含めて冷静に整理します。


「ズルなし」を徹底した公平な検証ルール

ベンチマーク記事でありがちな 「Three.js 側だけ雑に書いて自作を勝たせる(藁人形ベンチマーク)」は一切やっていません。

  1. Three.js 側も最新 WebGPU & 本気最適化
    • 最新の Three.js v0.187.0(THREE.WebGPURenderer + three/tsl)を使用(UI から従来の WebGLRenderer への切替も可能)。
    • Hybrid シナリオの Three.js 側も、素朴な O(N²) ループや new THREE.Vector3() の乱発は避け、自作エンジンと完全同一の 3D 空間ハッシュグリッドを TypedArray で実装し、InstancedMesh.instanceMatrix.array へ直接書き込む最適化実装にしています。
  2. 見た目・ジオメトリ・物理・描画数を 100% 一致
    • 折り紙バード(12三角形・36頂点・翼の羽ばたきアニメーション付き)、クリスタル(16三角形・48頂点)、神殿モニュメント、初期配置シード、カメラ行列、6面フラスタムカリング、4x MSAA、ACES Filmic トーンマッピングまですべて共通モジュールから生成。
    • 画面上の描画オブジェクト数は毎フレーム 1体単位で完全一致 しています。
  3. 外部ライブラリは Three.js 以外「完全ゼロ」
    • 自作エンジン側はもちろん、UI・グラフ描画・カメラ制御・Cloudflare Worker に至るまで外部ライブラリは一切不使用。
    • Rust の WebAssembly コアも #![no_std] で 依存クレート 0(rustc 直コンパイルで 10.8 KB)。
  4. 競合なしの「横画面フルスクリーン単独計測」+自動収集
    • 同時分割表示では GPU/CPU が競合するため、「自動ベンチマーク」実行時は 自動で横画面フルスクリーンに切り替え、自作エンジン → Three.js の順に単独で計測 します。
    • WebGPU の timestamp-query により、VSync(60Hz)に隠れた 真のハードウェア GPU 処理時間(ms) も同時計測しています。

検証した 3 つのゲームエンジン負荷シナリオ

Three.js 公式 Examples の代表的な性能ベンチマーク系サンプルをベースに、ゲームエンジンで実際にボトルネックになる 3 軸を用意しました。

シナリオ 参考にした Three.js Example 自作エンジン(No Three.js) Three.js v0.187.0
1. Hybrid CPU+GPU
(16,384羽)
webgl_instancing_dynamic
webgpu_compute_birds
#![no_std] Rust Wasm SIMD128 空間ハッシュ計数ソート+4並列近傍探索&カリング+32B圧縮バッファ+Raw WebGPU 同一空間ハッシュ JS(TypedArray最適化)+ THREE.InstancedMesh(64B mat4)+ WebGPURenderer
2. GPU Compute
(8,192羽)
webgpu_compute_birds 生 WGSL コンピュート(var<workgroup> 64スレッド共有メモリタイリング・1パス融合)+事前記録 GPURenderBundle 公式 WebGPURenderer + TSL (three/tsl) Fn() ピンポンコンピュート+ MeshStandardNodeMaterial
3. Draw Calls / Scene Graph
(4,000体)
webgpu_performance_renderbundle
webgl_instancing_performance
Rust Wasm SIMD128(4並列 sin/cos)+事前記録 GPURenderBundle で 4,000 回の個別 draw を一括再生 標準 THREE.Scene + 4,000 個の独立した THREE.Mesh(ジオメトリ・マテリアル共有)

実機 3 デバイスの詳細ベンチマークデータ

Cloudflare D1 に自動収集された実機 3 台の生データです(全機種 60Hz ディスプレイ環境)。

1. iPhone(iOS Safari / Apple GPU · WebGPU · 589×375 @ DPR 2)

シナリオ エンジン 平均 FPS P99 Frame CPU 時間 GPU 時間 倍率(自作基準)
Hybrid (16,384羽) AI自作エンジン 53.2 21.0 ms 9.85 ms 7.40 ms FPS 1.84x / CPU 2.02x / GPU 3.17x
Three.js WebGPU 28.9 40.0 ms 19.91 ms 23.48 ms
GPU Compute (8,192羽) AI自作エンジン 60.0 21.0 ms 0.28 ms 10.04 ms FPS 1.12x / CPU 7.25x / GPU 1.96x
Three.js WebGPU 53.8 26.0 ms 2.02 ms 19.69 ms
Scene Graph (4,000体) AI自作エンジン 60.0 17.0 ms 0.61 ms 4.59 ms FPS 3.04x / CPU 44.7x / GPU 2.12x
Three.js WebGPU 19.7 57.0 ms 27.20 ms 9.75 ms

2. Pixel 10a(Android Chrome 157 / ARM Mali-G715 · 8コア · 866×411 @ DPR 2)

  • 起動・シェーダー構築時間: 自作 236.6 ms vs Three.js 877.5 ms(3.71x 高速)
シナリオ エンジン 平均 FPS P99 Frame CPU 時間 GPU 時間 倍率(自作基準)
Hybrid (16,384羽) AI自作エンジン 59.5 16.8 ms 11.33 ms 6.89 ms FPS 1.18x / CPU 1.67x / GPU 2.97x
Three.js WebGPU 50.5 33.5 ms 18.91 ms 20.45 ms
GPU Compute (8,192羽) AI自作エンジン 59.9 16.8 ms 0.27 ms 5.26 ms VSync上限 / CPU 4.96x / GPU 2.48x
Three.js WebGPU 59.9 16.8 ms 1.32 ms 13.03 ms
Scene Graph (4,000体) AI自作エンジン 59.9 16.8 ms 0.62 ms 2.96 ms FPS 1.91x / CPU 49.3x / GPU 7.18x
Three.js WebGPU 31.3 66.8 ms 30.32 ms 21.26 ms

3. Windows PC(Chrome 158 / AMD Radeon RDNA-2 · 12コア / 16GB · 1920×1080 @ DPR 1)

  • 起動・シェーダー構築時間: 自作 194.7 ms vs Three.js 504.1 ms(2.59x 高速)
  • JS ヒープ使用量(Scene Graph 4,000体): 自作 30.8 MB vs Three.js 59.6 MB(48% 削減)
シナリオ エンジン 平均 FPS P99 Frame CPU 時間 GPU 時間 倍率(自作基準)
Hybrid (16,384羽) AI自作エンジン 59.9 17.1 ms 11.09 ms 8.37 ms FPS 1.46x / CPU 2.13x / GPU 1.83x
Three.js WebGPU 41.0 50.1 ms 23.60 ms 15.31 ms
GPU Compute (8,192羽) AI自作エンジン 59.9 17.1 ms 0.22 ms 6.75 ms VSync上限 / CPU 3.71x / GPU 1.46x
Three.js WebGPU 59.9 16.9 ms 0.83 ms 9.83 ms
Scene Graph (4,000体) AI自作エンジン 59.9 17.3 ms 0.41 ms 3.84 ms FPS 2.03x / CPU 82.1x / GPU 1.38x
Three.js WebGPU 29.5 50.1 ms 33.34 ms 5.29 ms

データを読むポイント:VSync 60Hz の裏にある「GPU余裕度」の差

GPU Compute(8,192羽)では Pixel 10a・Windows PC ともに 60 FPS に張り付いているため「同じに見える」かもしれません。
しかし WebGPU の timestamp-query で実測した GPU 処理時間 を見ると、自作エンジンの方が 1.46〜2.48倍も余裕がある ことがわかります。

  • Pixel 10a: 自作 5.26 ms vs Three.js 13.03 ms(16.6ms 予算の 31% vs 78%)
  • iPhone: 自作 10.04 ms(60 FPS 維持)vs Three.js 19.69 ms(予算超過で 53.8 FPS に低下)

モバイル端末ではこの差がそのまま 「120Hz 対応できるか」「30分遊んで発熱・サーマルスロットリングしないか」「さらに複雑なエフェクトやシャドウを足せるか」 に直結します。


なぜここまで速いのか? AI自作エンジンの 5 大最適化テクニック

「ライブラリを使わないだけで、なぜ CPU だけでなく GPU 時間まで 2〜7 倍速くなる のか?」
実際のソースコードとあわせて 5 つの決定的な要因を解説します。

最適化 1:#![no_std] Rust → Wasm SIMD128(10.8 KB)での SoA 計数ソート & 4並列近傍探索

JavaScript で大量エンティティを扱うと、JIT が頑張っても SIMD 命令を直接叩けず、キャッシュ局所性や GC 停止がネックになります。
自作エンジンでは、依存クレート 0 の #![no_std] Rust で 16 バイト整列の Structure of Arrays (SoA) 静的メモリを定義し、毎フレーム空間ハッシュで計数ソート(空間的に近い個体同士をメモリ上で隣接配置)したうえで、Wasm SIMD128 (f32x4) で 4 個体同時に距離計算とフラスタムカリングを回しています。

// wasm/src/lib.rs(抜粋):4個体の近傍距離判定・積算を Wasm SIMD128 で一括実行
while j + 4 <= j_end {
    let jx = v128_load(spx_ptr.add(j) as *const v128);
    let jy = v128_load(spy_ptr.add(j) as *const v128);
    let jz = v128_load(spz_ptr.add(j) as *const v128);

    let dx = f32x4_sub(xv, jx);
    let dy = f32x4_sub(yv, jy);
    let dz = f32x4_sub(zv, jz);

    let d2 = f32x4_add(
        f32x4_add(f32x4_mul(dx, dx), f32x4_mul(dy, dy)),
        f32x4_mul(dz, dz),
    );

    let in_range = v128_and(f32x4_gt(d2, eps_v), f32x4_lt(d2, rad_sq_v));
    if v128_any_true(in_range) {
        // 範囲内に1羽でもいれば 4レーン同時マスク積算(分岐なし)
        v_cnt   = f32x4_add(v_cnt,   v128_and(one_v, in_range));
        v_ali_x = f32x4_add(v_ali_x, v128_and(v128_load(svx_ptr.add(j) as *const v128), in_range));
        // ...
    }
    j += 4;
}

さらに Wasm の線形メモリ上の出力バッファをそのまま device.queue.writeBuffer() に渡すため、JS 側でのコピーもオブジェクト生成も完全ゼロ(Zero-GC) です。


最適化 2:64B の mat4 を捨て、32B 圧縮インスタンスを頂点シェーダーで基底展開

Three.js の InstancedMesh は汎用性のため、1 インスタンスあたり 4×4 行列(64 バイト) を毎フレーム CPU で組み立てて GPU へ転送します(16,384羽なら約 1 MB / フレーム+追加属性)。

しかし「飛行する鳥」の姿勢は、速度ベクトル vel と羽ばたき位相 phase さえあれば一意に決まります。自作エンジンでは 1 個体わずか 32 バイト(vec4(pos, phase) + vec4(vel, seed)) だけ転送し、WGSL 頂点シェーダー内で正規直交基底を即座に再構築しています。

// src/custom-engine/shaders.js(抜粋):64B行列転送を廃止し、GPU側で姿勢基底を再構築
struct BirdInstance {
  posPhase : vec4<f32>, // xyz = 位置, w = 羽ばたき位相
  velColor : vec4<f32>, // xyz = 速度, w = カラーシード
};

let spd = max(length(vel), 0.001);
let fwd = vel / spd;
let worldUp = select(vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(1.0, 0.0, 0.0), abs(fwd.y) > 0.96);
let right = normalize(cross(worldUp, fwd));
let up = cross(fwd, right);
let worldPos = center + (right * lp.x + up * lp.y + fwd * lp.z) * scale;

これだけで CPU の行列生成コスト・PCIe/統合メモリ転送帯域・頂点フェッチ帯域をまとめて半分に圧縮できます。


最適化 3:var<workgroup> 64スレッド共有メモリタイリングによる VRAM 帯域 1/64 化

ここが iPhone や Pixel 10a で GPU 時間が 2〜3 倍速くなった最大の理由 です。

Three.js の TSL コンピュート(公式 webgpu_compute_birds と同型)では、各スレッドがループ内でグローバルの Storage Buffer を直接読みにいきます。一方、生 WGSL を書ける自作エンジンでは、64 スレッドのワークグループが協調してオンチップの超高速メモリ var<workgroup> に 64 羽分の座標・速度を一括ロードして共有します。

// src/custom-engine/shaders.js(抜粋):ワークグループ共有メモリタイリング
var<workgroup> tilePos : array<vec3<f32>, 64>;
var<workgroup> tileVel : array<vec3<f32>, 64>;

for (var t = 0u; t < tiles; t++) {
  let peerIdx = (sim.peerOffset + t * 64u + lid.x) % count;
  let b = srcBirds[peerIdx];
  tilePos[lid.x] = b.posPhase.xyz;
  tileVel[lid.x] = b.velColor.xyz;
  workgroupBarrier(); // 64スレッドで共有完了を同期

  if (valid) {
    for (var k = 0u; k < 64u; k++) {
      // グローバルVRAMではなく高速な共有メモリから読み出す(帯域1/64!)
      let diff = pos - tilePos[k];
      let d2 = dot(diff, diff);
      // ...
    }
  }
  workgroupBarrier();
}

さらに速度更新・位置更新・障害物回避・位相更新を 1回のコンピュートパスに融合(Kernel Fusion) することで、メモリ読み書き回数とディスパッチ同期コストを最小化しています。


最適化 4:GPURenderBundle によるドローコール負荷 1/82 化

実際のゲームでは、すべての物体を 1 つの InstancedMesh にまとめられるわけではありません。数千の独立したオブジェクトを描画する Scene Graph シナリオ(4,000体) で、汎用シーングラフの構造的な差が露骨に出ました。

  • Three.js: 毎フレーム JS で THREE.Scene を走査 → 4,000 個の Object3D.updateMatrixWorld() → カリング → 描画リスト構築 → 4,000 回の描画コマンド発行(Windows で 33.34 ms、iPhone で 27.20 ms → 19.7〜31.3 FPS まで急落)。
  • 自作エンジン: Rust Wasm SIMD128 の 4並列 sin/cos で 4,000 体すべての変換を一括計算(0.1ms 未満)し、WebGPU の GPURenderBundle に事前記録した 4,000 回の個別 draw 命令を毎フレーム たった 1 行 pass.executeBundles([this._crystalBundle]) で再生します。
// 初期化時に 4,000 回の個別 draw 命令を RenderBundle へ事前録画
for (let i = 0; i < count; i++) {
  enc.draw(this.crystalVertCount, 1, 0, i);
}
this._crystalBundle = enc.finish();

// 毎フレームは 1 コールで再生するだけ(CPU 0.41 ms・Three.js の 82.1倍高速!)
pass.executeBundles([this._arenaBundle, this._crystalBundle, this._backdropBundle]);

最適化 5:Early-Z(Sky-Last 描画)& 汎用抽象化ゼロによる 65倍の軽量化

  • Early-Z 前後描画: 不透明な神殿・鳥・クリスタルを先に描き、最後に空(clipPos.z = 1.0, depthCompare: 'less-equal')を描くことで、ハードウェアの Early-Z テストにより背景のフラグメントシェーダー実行を大幅にスキップ。
  • ペイロード 59 KB vs 3,839 KB(65.1倍軽量): Three.js の WebGPU+TSL 版は、あらゆるマテリアル・ライト・ノードグラフを動的生成できる汎用コンパイラ一式をブラウザへ配信するため、非圧縮で約 3.8 MB(gzip 759 KB) になります。専用エンジンはそのアプリに必要なシェーダーとパイプラインしか持たないため、非圧縮 59 KB(gzip 17 KB) で済み、起動時間も 2.6〜3.7倍 速くなります。

本題:Three.js は「過去の遺物」になるのか?

ここまで圧倒的な数字が出ると「もう全部 AI に自作させればいいのでは?」と思いたくなりますが、エンジニアとして冷静に境界線を引く必要があります。

結論:Three.js は過去の遺物ではありません。ただし、AI によって「使い分けの損益分岐点」が劇的に動きました。

観点 AI 自作ゲームエンジン(Wasm + WebGPU) Three.js(v0.187+)
フレーム性能・CPU/GPU効率 圧倒的優位(特化最適化・共有メモリ・RenderBundle) 汎用抽象化のオーバーヘッドあり
初回ロード・バンドルサイズ 圧倒的優位(数KB〜数十KB・即起動) 重い(WebGL2版 667KB / WebGPU版 3.8MB)
glTF / PBR / 複雑なアセット管理 自作コスト・デバッグ負荷が高い 圧倒的優位(標準ローダー・物理ベース描画が即動く)
ポストプロセス・シャドウ・多様な表現 機能追加ごとにシェーダー設計が必要 圧倒的優位(豊富なサンプル・エコシステム)
複数人チームでの長期保守 独自設計のドキュメント・テスト整備が必須 優位(世界中の知見・採用しやすさ)
向いている用途 高密度シミュレーション、広告/LP用超軽量3D、性能限界に挑むWebゲーム、データ可視化 製品ビューア、メタバース/建築ビジュアライゼーション、多彩な3Dアセットを使う業務・制作案件

AI が変えた本質

かつて「専用エンジンを Rust Wasm SIMD + Raw WebGPU で書く」ことは、AAA ゲームスタジオやごく一部のグラフィックス専門家にしか許されない贅沢 でした。
しかし AI コーディングエージェントの登場によって、「特定の Web アプリ専用に最適化された 50 KB の極小エンジンを、ゼロから書いてデバッグし、実機ベンチマークまで回す」コストが劇的に下がりました。

  • 複雑な glTF シーンや多種多様な表現を素早く組み立てたいなら、これからも Three.js は最強の標準ツール です。
  • 一方で「数万オブジェクトをスマホでも 60 FPS 張り付きで動かしたい」「初回ロードを 100 KB 未満に抑えたい」「WebGPU Compute や RenderBundle の性能を 100% 絞り出したい」という場面では、AI に専用マイクロエンジンを書かせる という選択肢が、もはや現実的かつ圧倒的に強力な武器になっています。

あなたの端末(RTX / Apple Silicon / スマホ)でも計測してみてください!

今回作成したベンチマークアプリは GitHub Pages で公開しており、ボタンを押すだけで横画面フルスクリーンへ自動切替 → 全3シナリオを単独計測 → 結果を一覧表示できます。

(※ 計測完了時、User-Agent・GPU名・画面解像度・各シナリオの FPS/CPU/GPU 時間が Cloudflare D1 へ自動送信され、モーダル内の「収集済みデバイス計測ログ」で他デバイスと比較できます。個人を特定する IP アドレス等は保存していません)

RTX 4090 / 5090 や Apple Silicon(M3 / M4)、120Hz 対応スマホなどで回すとどうなるか、ぜひ 「自動ベンチマーク」 を試して、結果や感想をコメント・X などで教えてもらえると嬉しいです!

1
2
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
1
2

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?