typegpu

TypeGPU

単一のスキーマ（d.*）で、GPU の型、CPU バッファーのレイアウト、TypeScript の型を同時に定義できます。手動でのアラインメント、型マッピング、キャストは不要です。ビルドプラグイン unplugin-typegpu は、'use gpu' が付いた TypeScript を実行時の WGSL トランスパイル用に変換し、CPU/GPU の境界を越えた型推論とポリモーフィズムを可能にします。

このスキルは TypeGPU 0.12 を対象としています。ユーザーのプロジェクトがそれより古いリリースを使用している場合は、ここにある例や推奨パターンを利用する前に、API が利用可能か確認してください。

---

リファレンスファイルを読むタイミング

ほぼすべてのシェーダーや GPU 関数を書く前に読んでください — 特につまずきやすいルールを次の 2 つで説明しています。

• references/types.md — 抽象型の解決、d.f32() が必要な場合と不要な場合、ベクトルコンストラクターのオーバーロード、tgpu.fn シグネチャ用のサンプラー／テクスチャスキーマ、CPU 側の TgpuBuffer／TgpuTexture TypeScript 型。読まないと型エラーが発生します。
• references/shaders.md — ループ（std.range、tgpu.unroll）、三項演算子／論理演算子のセマンティクス、tgpu.comptime、外側スコープのキャプチャルール、3 つすべてのシェーダーステージの組み込み機能リファレンス、console.log。複雑なシェーダーロジックを書く場合は読んでください。
• references/std.md — std 関数の完全な一覧（数学、比較／ブールベクトル、行列ビルダー、テクスチャ、アトミック、パッキング、サブグループ、環境プローブ）。数学関数やユーティリティ関数を独自に実装する前に参照してください。

タスクで次の項目を具体的に扱う場合に読んでください：

• references/pipelines.md — 頂点バッファー／レイアウト、attribs の接続、MRT、全画面三角形、深度／ステンシル、ブレンドモード、fragDepth 出力、3D モデルの読み込み（@loaders.gl）、resolve API
• references/matrices.md — wgpu-matrix の統合、列優先レイアウト、カメラのユニフォーム、common.writeSoA、高速パスでの CPU 書き込み。3D を扱う場合（ビュー／射影行列、アニメーションするトランスフォーム、モデルの読み込み）は読んでください。
• references/textures.md — テクスチャの作成、ビュー、サンプラー、ストレージテクスチャ、ミップマップ、マルチサンプリング
• references/noise.md — @typegpu/noise（乱数、分布、Perlin 2D/3D）
• references/sdf.md — @typegpu/sdf（2D/3D プリミティブ、演算子、レイマーチング、AA マスキング）
• references/encoders.md — 型付きコマンドエンコーダー、複数パイプラインのレンダー／コンピュートパス、レンダーバンドル、バッチ送信、raw-WebGPU エンコーダーとの相互運用（不安定な API、動作は安定）
• references/timing.md — タイムスタンプクエリによる GPU タイミング計測：withPerformanceCallback と共有クエリセットの比較、available ガード、パスごとの計測時間が重複する理由
• references/react.md — @typegpu/react フック（useRoot、useFrame、useUniform、...）、React Native のワークレットレンダーループ
• references/setup.md — TypeGPU CLI、インストール、unplugin-typegpu ビルドプラグイン、tsover 演算子オーバーロード、トラブルシューティング
• references/advanced.md — バッファーの再解釈、間接描画／ディスパッチ、ArrayBuffer IO、縮小化、警告の抑制、root.unwrap

---

セットアップ

import { tgpu, d, std, common } from 'typegpu';

const root = await tgpu.init();                 // request a GPU device
const root = tgpu.initFromDevice({ device });   // or wrap an existing GPUDevice

const context = root.configureContext({ canvas, alphaMode: 'premultiplied' });

アプリの起動時にルートを 1 つ作成します。異なるルートのリソース同士は相互にやり取りできません。破棄するには、root.destroy() を呼び出します。これにより、ルート経由で作成されたすべてのリソースに加え、そのルートが initFromDevice ではなく tgpu.init から作成された場合はデバイス自体も破棄されます。

---

データスキーマ（d.*）

スキーマはメモリレイアウトを定義し、TypeScript の型を推論します。同じスキーマをバッファー、シェーダーシグネチャ、バインドグループエントリーに使用します。

スカラー

d.f32    d.i32    d.u32    d.f16   // f16 needs the 'shader-f16' device feature (references/setup.md)
// d.bool is NOT host-shareable - use d.u32 in buffers

ベクトルと行列

d.vec2f  d.vec3f  d.vec4f     // f32
d.vec2i  d.vec3i  d.vec4i     // i32
d.vec2u  d.vec3u  d.vec4u     // u32
d.vec2h  d.vec3h  d.vec4h     // f16
d.vec2b  d.vec3b  d.vec4b     // bool - shader-side only (not host-shareable)

d.mat2x2f   d.mat3x3f   d.mat4x4f

インスタンス型：d.vec3f() -> d.v3f、d.mat4x4f() -> d.m4x4f。

ベクトルコンストラクターは豊富なオーバーロードに対応しています — スカラー、小さなベクトル、スウィズルを任意に組み合わせ、正しいコンポーネント数になるように構成できます（d.vec4f(rgb, 1)、d.vec3f(v.xy, newZ)）。コンポーネントを手動で分解するより、これらを優先してください。オーバーロードの完全な一覧は references/types.md にあります。

複合型

const Particle = d.struct({
  position: d.vec2f,
  velocity: d.vec2f,
  color:    d.vec4f,
});

const ParticleArray = d.arrayOf(Particle, 1000); // fixed-size

実行時サイズのスキーマ。 d.arrayOf(Element) を要素数なしで呼び出すと、(n: number) => WgslArray<Element> という関数が返されます。この二面性が重要です。バインドグループレイアウトには（サイズ未指定の）関数そのものを渡し、バッファを作成するときは要素数を指定して（サイズ指定の）関数を呼び出します。

// Plain array - arrayOf without count is already a factory:
const layout = tgpu.bindGroupLayout({
  data: { storage: d.arrayOf(d.f32), access: 'mutable' },  // unsized for layout
});
const buf = root.createBuffer(d.arrayOf(d.f32, 1024)).$usage('storage'); // sized for buffer

// Struct with a runtime-sized last field - wrap in a factory function:
const RuntimeStruct = (n: number) =>
  d.struct({
    counter: d.atomic(d.u32),
    items:   d.arrayOf(d.f32, n),  // last field gets the runtime size
  });

const layout2 = tgpu.bindGroupLayout({
  runtimeData: { storage: RuntimeStruct, access: 'mutable' }, // unsized (the function)
});
const buf2 = root.createBuffer(RuntimeStruct(1024)).$usage('storage'); // sized (called)

サイズは CPU 側で把握しておく必要があるため、サイズ未指定のスキーマをそのまま createBuffer に渡すことはできません。

---

GPU 関数

TypeGPU は、'use gpu' を付けた TypeScript を WGSL にコンパイルします。

通常のコールバック（多相）

明示的なシグネチャはありません。ヘルパー関数の計算や柔軟なユーティリティに最適です。

const rotate = (v: d.v2f, angle: number) => {
  'use gpu';
  const c = std.cos(angle);
  const s = std.sin(angle);
  return d.vec2f(c * v.x - s * v.y, s * v.x + c * v.y);
};

number 型のパラメーターや d.v2f | d.v3f のようなユニオンは多相です。TypeGPU は、呼び出し箇所で使われる型の組み合わせごとに WGSL のオーバーロードを生成します。外側のスコープからキャプチャされた値はWGSL リテラルとしてインライン化されます。実行時に変化する値には、バッファーまたはユニフォームを使用してください。

tgpu.fn（明示的な型）

WGSL のシグネチャを固定します。ライブラリーコードや、固定の WGSL インターフェイスが必要な場合に使用します。

const rotate = tgpu.fn([d.vec2f, d.f32], d.vec2f)((v, angle) => {
  'use gpu';
  // ...
});

シェーダーのエントリーポイント

// Compute
const myCompute = tgpu.computeFn({
  workgroupSize: [64],
  in: { gid: d.builtin.globalInvocationId },
})((input) => { 'use gpu'; /* input.gid: d.v3u */ });

// Vertex
const myVertex = tgpu.vertexFn({
  in:  { position: d.vec3f, uv: d.vec2f },
  out: { position: d.builtin.position, fragUv: d.vec2f },
})((input) => {
  'use gpu';
  return { position: d.vec4f(input.position, 1), fragUv: input.uv };
});

// Fragment
const myFragment = tgpu.fragmentFn({
  in: { fragUv: d.vec2f },
  out: d.vec4f,
})((input) => { 'use gpu'; return d.vec4f(input.fragUv, 0, 1); });

頂点の in には、組み込み変数 d.builtin.vertexIndex、d.builtin.instanceIndex を含められます。

シェーダー構文全般、分岐の枝刈り、std ライブラリー、型推論、慣用的なパターン（ベクトル演算、構造体コンストラクター、レジスター負荷）については、references/shaders.md を参照してください。複雑なシェーダーに取り組む前に読んでください。値と参照の扱いについても説明しており、ResolutionError の最も一般的な原因です。

---

バッファー

作成

// Schema only:
const buf = root.createBuffer(d.arrayOf(Particle, 1000)).$usage('storage');

// With typed initial value (only when non-zero — all buffers are zero-initialized by default):
const uBuf = root.createBuffer(Config, { time: 1, scale: 2.0 }).$usage('uniform');

// With an initializer callback - buffer is still mapped (cheapest CPU path):
const buf = root.createBuffer(Schema, (mappedBuffer) => {
  mappedBuffer.write([10, 20], { startOffset: firstChunk.offset });
  mappedBuffer.write([30, 40], { startOffset: secondChunk.offset });
});

// Wrap an existing GPUBuffer (you own its lifecycle and flags):
const buf = root.createBuffer(d.u32, existingGPUBuffer);
buf.write(12);

使用フラグ

リテラル	シェーダーでのアクセス
'uniform'	var<uniform>
'storage'	var<storage, read>（または access: 'mutable' で read_write）
'vertex'	頂点入力。tgpu.vertexLayout と組み合わせます
'index'	インデックスバッファー（d.u16 または d.u32 の配列のみ）
'indirect'	間接ディスパッチ／描画

すべてのバッファーには、COPY_SRC | COPY_DST が自動的に設定されます。$addFlags(GPUBufferUsage.X) を使うと、$usage でカバーされていないフラグを追加できます。

書き込み

.write(value) はアラインメントを処理します。入力形式は 4 種類あります（遅い順）。

形式	例（vec3f）	備考
型付きインスタンス	d.vec3f(1, 2, 3)	ラッパーを割り当てます。セットアップやプロトタイプには問題ありません
通常の JS 配列／タプル	[1, 2, 3]	割り当ては行われず、パディングは自動で追加されます
TypedArray	new Float32Array([1, 2, 3])	バイト列をそのままコピーします。WGSL のパディングを含める必要があります
ArrayBuffer	rawBytes	最大スループットで、バイト列をそのままコピーします

セットアップ時に通常の配列または Float32Array をキャッシュし、再利用してください。パディング規則（vec3f は 16 バイト、mat3x3f は列ごとにパディング）と高速パスの詳しいガイダンスについては、references/matrices.md を参照してください。

スライスへの書き込み — d.memoryLayoutOf を使ってバイトオフセットを取得し、サブ領域を更新します。

const layout = d.memoryLayoutOf(schema, (a) => a[3]);
buffer.write([4, 5, 6], { startOffset: layout.offset });

.patch(data) — 残りの部分に触れずに、特定の構造体フィールドまたは配列インデックスを更新します。

planetBuffer.patch({
  mass: 123.1,
  colors: { 2: [1, 0, 0], 4: d.vec3f(0, 0, 1) },
});

common.writeSoA(buffer, { field: Float32Array, ... }) — パディングを正しく処理しながら、フィールドごとに分かれたパック済み配列を GPU の AoS レイアウトに振り分けます。CPU 側のデータがフィールドごとに分かれている場合の、パーティクルシステム、シミュレーション、モデル読み込みに適した慣用的な方法です。例については references/matrices.md、モデル読み込みのパターンについては references/pipelines.md を参照してください。

GPU 側でのコピー： destBuffer.copyFrom(srcBuffer)（スキーマは一致している必要があります）。ゼロクリア： buffer.clear()。クリーンアップ： buffer.destroy()。copyFrom と clear はどちらもコマンドエンコーダーを省略可能な引数として受け取ります。詳細については references/encoders.md を参照してください。

読み取り

const data = await buffer.read(); // returns a typed JS value matching the schema

短縮形の「固定」リソース

手動のバインドグループは不要です。シェーダー内で参照されると、バッファーは常にバインドされます。

const particlesMutable = root.createMutable(d.arrayOf(Particle, 1000));  // var<storage, read_write>
const configUniform    = root.createUniform(Config);                     // var<uniform>
const bufReadonly      = root.createReadonly(d.arrayOf(d.f32, N));       // var<storage, read>

シェーダー内では particles.$、config.$ を使ってアクセスします。通常は固定リソースを優先してください。フレームごとにリソースを切り替える必要がある場合、@group インデックスを管理する場合、または複数のパイプラインでレイアウトを共有する場合は、手動のバインドグループに切り替えてください。

手動で作成したバッファーは、buffer.as('uniform' | 'readonly' | 'mutable')（対応する $usage が必要）を使うと、同じ種類のバインディングに変換できます。TgpuBuffer を保持しているものの、シェーダー内で .$ アクセスが必要な場合に使用します。

---

バインドグループレイアウト（手動バインディング）

const layout = tgpu.bindGroupLayout({
  config:    { uniform: ConfigSchema },
  particles: { storage: d.arrayOf(Particle), access: 'mutable' },
  mySampler: { sampler: 'filtering' },   // 'filtering' | 'non-filtering' | 'comparison'
  myTexture: { texture: d.texture2d(d.f32) },
});

// Inside shaders: layout.$.config, layout.$.particles, ...

const bindGroup = root.createBindGroup(layout, {
  config:    configBuffer,
  particles: particleBuffer,
  mySampler: tgpuSampler,
  myTexture: textureOrView,
});

pipeline.with(bindGroup).dispatchWorkgroups(N);

createUniform／createMutable／createReadonly によるバッファーバインディングは、エントリーとして直接使用できます（バッファーへのアンラップは不要です）。

明示的な @group インデックス（グループインデックスをハードコードした raw WGSL と統合する場合にのみ必要です）：layout.$idx(0)。

---

コンピュートパイプライン

// Standard - you control workgroup sizing
const pipeline = root.createComputePipeline({ compute: myComputeFn });
pipeline.with(bindGroup).dispatchWorkgroups(Math.ceil(N / 64));

// Guarded - TypeGPU handles workgroup sizing and bounds checking automatically.
// The callback's parameter count sets the dimensionality (0D to 3D):
const p0 = root.createGuardedComputePipeline(() => { 'use gpu'; /* runs once */ });
const p1 = root.createGuardedComputePipeline((x: number) => { 'use gpu'; });
const p2 = root.createGuardedComputePipeline((x: number, y: number) => { 'use gpu'; });
const p3 = root.createGuardedComputePipeline((x: number, y: number, z: number) => { 'use gpu'; });

// dispatchThreads matches the callback's arity - pass thread counts, not workgroup counts.
// TypeGPU picks workgroup sizes internally and injects a bounds guard so threads
// outside the requested range are no-ops.
p2.with(bindGroup).dispatchThreads(width, height);

// WGSL builtins like globalInvocationId are NOT available - use the callback parameters instead.

---

WebGPU の座標規則

WebGPU は OpenGL／WebGL ではなく、DirectX／Metal に準拠しています。そのため、チュートリアルをそのまま移植すると、見つけにくいバグが発生します。

• NDC の z は [0, 1] であり、[-1, 1] ではありません。コピー＆ペーストした gluPerspective は近クリップ面を切り取ります。wgpu-matrix の mat4.perspective（すでに [0, 1] を対象としています）を使うか、深度精度を高めるには mat4.perspectiveReverseZ を使ってください。
• フレームバッファーの (0, 0) は左上で、+y は下向きです。これは OpenGL と逆です。フラグメントシェーダー内の d.builtin.position.xy は、この原点を基準とするピクセル座標です。
• テクスチャの UV (0, 0) は左上です。v を事前に反転しないでください。createImageBitmap はすでにこの向きに対応しています。
• 行列は列優先です：d.mat4x4f(c0, c1, c2, c3) は列を受け取ります。シェーダー内では mat.columns[c][r] を使ってください。通常の mat[i] は拒否されます。合成順序は projection * view * model * position です。references/matrices.md を参照してください。

---

レンダーパイプライン

const pipeline = root.createRenderPipeline({
  vertex:   myVertex,
  fragment: myFragment,
  targets:  { format: presentationFormat }, // single target - shorthand
  primitive?:    GPUPrimitiveState,
  depthStencil?: GPUDepthStencilState,
  multisample?:  GPUMultisampleState,
});

pipeline
  .with(bindGroup)
  .withColorAttachment({
    view: context,
    // loadOp/storeOp/clearValue have defaults
  })
  .withDepthStencilAttachment({ /* ... */ })
  .withIndexBuffer(indexBuffer)  // enables .drawIndexed()
  .draw(vertexCount, instanceCount /* optional */);

シェルを使わないインラインの頂点／フラグメントラムダも、シンプルなケースでは使用できます。

複数レンダーターゲット（MRT）

フラグメントの out、パイプラインの targets、withColorAttachment には名前付きレコードを使ってください。TypeScript がキーの一致を強制します。キーはそのまま WGSL の構造体フィールド名になります。$ プレフィックスは付きません。組み込み値（fragDepth）は out に含めますが、targets や withColorAttachment には含めません。

ターゲットごとのブレンド／writeMask 設定を含む MRT の完全な例と、fragDepth に関する注意点については、references/pipelines.md を参照してください。

バインドグループとビューのキャッシュ

root.createBindGroup(...) と texture.createView(...) は、呼び出すたびに新しい GPU オブジェクトを割り当てます。プロトタイプには問題ありませんが、それ以外ではセットアップ時に一度（ラップするリソースの近くで）作成し、ハンドルを const に保存して再利用してください。フレームごとの割り当て自体が遅いわけではありませんが、GC の負荷を高め、カクつきの原因になります。ビューやバインドグループが正当にフレームごとに変わる場合は、切り替えて使う少数のセットをキャッシュしてください。

頂点バッファーレイアウト、attribs のスプレッドトリック、common.fullScreenTriangle ヘルパーについては、references/pipelines.md を参照してください。

作業のバッチ処理

draw()／dispatchWorkgroups() は、それぞれ独立した単一パイプラインのパスを記録して送信します。複数のパイプラインを1つのパスで実行（アタッチメントを共有）する場合や、複数のパスを1回の送信にまとめる場合は、型付きコマンドエンコーダーを使ってください。root['~unstable'].createCommandEncoder() → beginRenderPass／beginComputePass → pipeline.with(pass).draw(...) → pass.end() → encoder.submit()。レンダーバンドルと raw-WebGPU エンコーダーの相互運用についても、references/encoders.md を参照してください。

パイプラインは初回使用時に遅延初期化されます。pipeline.initSync()／await pipeline.initAsync() を使うと、そのコストをローディング画面に移せます（references/pipelines.md を参照してください）。

---

GPU スコープ変数

tgpu.workgroupVar(schema) — ワークグループ内のすべてのスレッド間で共有されます（コンピュートのみ）。tgpu.privateVar(schema) — スレッドごとに独立します。tgpu.const(schema, value) — WGSL リテラルとして埋め込まれるコンパイル時定数です。すべて .$ からアクセスできます。完全な例は references/shaders.md を参照してください。

---

スロット

tgpu.slot<T>() は型付きのプレースホルダーです。ルートスコープ（パイプラインの作成前）または関数スコープで .with(slot, value) を使って値を設定します。パイプラインでは .with() にスロットを渡せません。GPU 値、関数、コールバックなど、あらゆる型を指定できます。スロットは、設定可能で再利用可能なシェーダーを構築するための標準的な方法です。

const distFnSlot = tgpu.slot<(pos: d.v3f) => number>();

const rayMarcher = tgpu.computeFn({
  workgroupSize: [64],
  in: { gid: d.builtin.globalInvocationId },
})(({ gid }) => {
  'use gpu';
  const dist = distFnSlot.$(d.vec3f(gid)); // call the injected function
});

root
  .with(distFnSlot, (pos) => {
    'use gpu';
    return std.length(pos - d.vec3f(0, 0, -5)) - 1.0; // sphere SDF
  })
  .createComputePipeline({ compute: rayMarcher });

デフォルト値を持つスカラー／ベクトルスロット：

const colorSlot = tgpu.slot(d.vec4f(1, 0, 0, 1));
root.with(colorSlot, d.vec4f(0, 1, 0, 1)).createRenderPipeline({ ... });

---

アクセサー

tgpu.accessor(schema, initial?) はスキーマを認識します。値には、バッファーバインディング、定数、リテラル、またはそのいずれかを返す 'use gpu' 関数を指定できます。シェーダーは値の取得元を意識しません。問題なく使用できる場合は、スロットよりアクセサーを優先してください。

const colorAccess = tgpu.accessor(d.vec3f);

// Fill with a uniform buffer:
root.with(colorAccess, colorUniform).createComputePipeline(...)

// Fill with a literal (inlined):
root.with(colorAccess, d.vec3f(1, 0, 0)).createComputePipeline(...)

// Fill with a GPU function:
root.with(colorAccess, () => { 'use gpu'; return computeColor(); }).createComputePipeline(...)

書き込みアクセスには、tgpu.mutableAccessor(schema, initial?) を使用します。

---

型ユーティリティ

d.InferInput<typeof Schema> — .write() で受け付ける CPU 側の型です。d.InferGPU<typeof Schema> — 'use gpu' 関数内での型です。d.AnyData（'typegpu/data' からもインポートできます）— ジェネリックに使用する最も広いスキーマ制約です。バッファー／テクスチャーの TypeScript 型（TgpuBuffer、TgpuUniform、TgpuTexture、使用フラグ）については、references/types.md を参照してください。

---

よくある落とし穴

1. 数値リテラル：1.0 は削除され、abstractInt になる場合があります。d.f32(1) を使用してください。types.md を参照してください。
2. 外側スコープのキャプチャーは定数です：実行時に変更できません。createUniform／createMutable を使用してください。shaders.md を参照してください。
3. TypedArray／ArrayBuffer のアラインメント：バイト列はそのままコピーされます。vec3f の要素は 16 バイト（12 バイト＋4 バイトのパディング）です。通常の配列ではパディングが処理されますが、TypedArray にはパディングを含める必要があります。
4. 整数除算：プリミティブに対する a / b は f32 になります。整数として扱うには d.i32()／d.u32() を使用してください。types.md を参照してください。
5. 未初期化変数：let x; は無効です。型を推論できるよう、必ず初期化してください：let x = d.f32(0)。
6. 三項演算子：実行時の三項演算子は WGSL の select にコンパイルされます。両方の分岐が常に評価されるため、副作用のないスカラー／ベクトル値（構造体／配列／行列は不可）である必要があります。これらには if／else を使用してください。コンパイル時に条件が確定している場合、使われない分岐は完全に削除されます。shaders.md を参照してください。
7. フラグメント出力は常に 4 成分です（整数形式では d.vec4i／d.vec4u）。チャンネル数が少ない形式でも同様です。targets: { format: 'r8unorm' } または 'rg16float' を指定したパイプラインでも、out: d.vec4f と return d.vec4f(...) が必要です。WebGPU が未使用のチャンネルを破棄します。

---

関連パッケージ

• @typegpu/noise — 実際の PRNG（randf）、確率分布（一様分布、正規分布、半球分布など）、Perlin ノイズ（perlin2d／perlin3d）を提供します。勾配キャッシュを事前計算すると、任意で約 10 倍高速化できます。独自実装のハッシュよりこちらを優先してください。references/noise.md を参照してください。

• @typegpu/sdf — 2D／3D の符号付き距離プリミティブ（sdDisk、sdBox2d、sdRoundedBox2d、sdBezier、sdSphere、sdBox3d、sdCapsule、sdPlane など）と演算子（opUnion、opSmoothUnion、opSmoothDifference、opExtrudeX/Y/Z）を提供します。すべての関数は型が固定された tgpu.fn で、'use gpu' から直接呼び出せます。レイマーチング、UI マスキング、アンチエイリアス付きベクター描画に使用できます。references/sdf.md を参照してください。

• @typegpu/react — React および React Native で TypeGPU を使うためのフック（useRoot、useFrame、useUniform など）を提供します。react-native-worklets を使った UI スレッド上のレンダーループも利用できます。references/react.md を参照してください。

• TypeGPU CLI — npx typegpu@latest で新しいプロジェクトをひな形から作成できます。--enhance を指定すると、既存のプロジェクトに TypeGPU を導入できます。references/setup.md を参照してください。

• wgpu-matrix — TypeGPU 標準の数学ライブラリです。TypeGPU のベクトル／行列を wgpu-matrix の呼び出しで dst として渡すことで、割り当てを避けられます。統合パターンの詳細については、references/matrices.md を参照してください。