WebGPU

this.[[adapter]]に対して新しいアダプター情報を返す。

[[adapter]], 型 adapter, 読み取り専用

このGPUAdapterが参照するアダプター。

GPUAdapter には以下のメソッドがあります：

requestDevice(descriptor)

デバイスをアダプターから要求します。

これは一度限りの操作です: デバイスが正常に返された場合、アダプターは"consumed"になります。

呼び出し対象: GPUAdapter this。

引数:

GPUAdapter.requestDevice(descriptor) メソッドの引数。
パラメーター	型	ヌル許容	省略可	説明
`descriptor`	`GPUDeviceDescriptor`	✘	✔	要求する`GPUDevice`の説明。

戻り値: Promise<GPUDevice>

コンテンツタイムラインのステップ:

変数 contentTimeline を現在のコンテンツタイムラインにします。
変数 promise を新しい promiseにします。
変数 adapter を this.[[adapter]] にします。
this のデバイスタイムラインに対して、initialization stepsを実行します。
promise を返します。

デバイスタイムラインの initialization steps：

次のいずれかの要件が満たされない場合：
- descriptor の集合にある値のセットのうち、descriptor.requiredFeatures は、adapter.[[features]] にあるものの部分集合でなければなりません。
その場合、次の手順をcontentTimeline上で実行して返します：
コンテンツタイムラインのステップ：
1. RejectしてpromiseをTypeErrorで終了させます。
注: これはブラウザがその機能名をまったく認識していない場合（GPUFeatureName の定義内）に生成されるエラーと同じです。これにより、ブラウザが機能をサポートしていない場合の動作と、特定のアダプターがその機能をサポートしていない場合の動作が収束します。
以下の手順のすべての要件が満たされる必要があります。
1. adapter.[[state]] は "consumed" であってはなりません。
2. descriptor.requiredLimits の各 [key, value] について、value が undefined でない場合：
  1. key はサポートされているリミットのメンバー名でなければなりません。
  2. value は adapter.[[limits]][key] よりも良すぎてはなりません。
  3. key のクラスがアラインメントである場合、value は 2 の累乗で 2³² 未満でなければなりません。
  注: key が認識されない場合（たとえ value が undefined であっても）、ユーザーエージェントは開発者に見える警告を出すことを検討すべきです。
もしいずれかが満たされない場合は、次の手順をcontentTimeline上で実行して返します：
コンテンツタイムラインのステップ：
1. RejectしてpromiseをOperationErrorで終了させます。
もし adapter.[[state]] が "expired" であるか、ユーザーエージェントが要求を満たせない場合：
1. 変数 device を新しいデバイスにします。
2. デバイスを失わせる (Lose the device)(device, "unknown").
3. Assert して adapter.[[state]] が "expired" であることを確認します。
  
  注: これが発生した場合、ユーザーエージェントはほとんどまたはすべてのケースで開発者に見える警告を出すことを検討するべきです。アプリケーションは requestAdapter() から始めて再初期化ロジックを実行するべきです。
それ以外の場合：
1. 変数 device を、adapter から descriptor を用いて新しいデバイスを作成する操作の結果にします。
2. Expire を adapter に対して実行します。
続きの手順をcontentTimeline上で実行します。

コンテンツタイムラインのステップ：

変数 gpuDevice を新しい GPUDevice インスタンスにします。
gpuDevice.[[device]] を device に設定します。
device.[[content device]] を gpuDevice に設定します。
gpuDevice.label を descriptor.label に設定します。
Resolve して promise を gpuDevice で解決します。

注: アダプターが要求を満たせなかったためにデバイスが既に失われている場合、device.lost は promise が解決する前に既に解決されていることに注意してください。

デフォルト機能・制限値でGPUDeviceを要求する例：

const gpuAdapter = await navigator.gpu.requestAdapter();
const gpuDevice = await gpuAdapter.requestDevice();

4.3.1. `GPUDeviceDescriptor`

GPUDeviceDescriptor はデバイス要求内容を記述します。

dictionary GPUDeviceDescriptor
         : GPUObjectDescriptorBase {
    sequence<GPUFeatureName> requiredFeatures = [];
    record<DOMString, (GPUSize64 or undefined)> requiredLimits = {};
    GPUQueueDescriptor defaultQueue = {};
};

GPUDeviceDescriptor には以下のメンバーがあります：

requiredFeatures, 型 sequence<GPUFeatureName>、デフォルト[]

デバイス要求で必要な機能を指定します。アダプターがこれら機能を提供できない場合、要求は失敗します。

API呼び出しの検証では、指定した機能セットのみが利用可能であり、それ以外は利用不可です。

requiredLimits, 型 record<DOMString, (GPUSize64 or undefined)>、デフォルト{}

デバイス要求で必要な制限値を指定します。アダプターがこれら制限値を提供できない場合、要求は失敗します。

値がundefinedでない各キーはsupported limitsメンバー名でなければなりません。

生成されたデバイスのAPI呼び出しは、そのデバイスの厳密な制限値に従って検証されます（アダプターの制限値ではない。§ 3.6.2 制限参照）。

defaultQueue, 型 GPUQueueDescriptor、デフォルト{}

デフォルトGPUQueueの記述内容。

サポートされていれば"texture-compression-astc"機能付きGPUDeviceを要求する例：

const gpuAdapter = await navigator.gpu.requestAdapter();

const requiredFeatures = [];
if (gpuAdapter.features.has('texture-compression-astc')) {
    requiredFeatures.push('texture-compression-astc')
}

const gpuDevice = await gpuAdapter.requestDevice({
    requiredFeatures
});

より高いmaxColorAttachmentBytesPerSample制限付きGPUDeviceを要求する例：

const gpuAdapter = await navigator.gpu.requestAdapter();

if (gpuAdapter.limits.maxColorAttachmentBytesPerSample < 64) {
    // 希望の制限値が未サポートの場合、より高い制限値を必要としないコードパスへフォールバックするか、
    // デバイスが最低要件を満たしていないことをユーザーに通知するなどの対応を取る。
}

// max color attachments bytes per sampleのより高い制限値を要求。
const gpuDevice = await gpuAdapter.requestDevice({
    requiredLimits: { maxColorAttachmentBytesPerSample: 64 },
});

4.3.1.1. `GPUFeatureName`

各GPUFeatureNameは、利用可能であればWebGPUの追加利用を許可する機能セットを識別します。

enum GPUFeatureName {
    "core-features-and-limits",
    "depth-clip-control",
    "depth32float-stencil8",
    "texture-compression-bc",
    "texture-compression-bc-sliced-3d",
    "texture-compression-etc2",
    "texture-compression-astc",
    "texture-compression-astc-sliced-3d",
    "timestamp-query",
    "indirect-first-instance",
    "shader-f16",
    "rg11b10ufloat-renderable",
    "bgra8unorm-storage",
    "float32-filterable",
    "float32-blendable",
    "clip-distances",
    "dual-source-blending",
    "subgroups",
    "texture-formats-tier1",
    "texture-formats-tier2",
    "primitive-index",
    "texture-component-swizzle",
};

4.4. `GPUDevice`

GPUDevice はデバイスをカプセル化し、その機能を公開します。

GPUDeviceは WebGPUインターフェースを生成するトップレベルインターフェースです。

GPUDeviceを取得するには、requestDevice()を使用します。

[Exposed=(Window, Worker), SecureContext]
interface GPUDevice : EventTarget {
    [SameObject] readonly attribute GPUSupportedFeatures features;
    [SameObject] readonly attribute GPUSupportedLimits limits;
    [SameObject] readonly attribute GPUAdapterInfo adapterInfo;

    [SameObject] readonly attribute GPUQueue queue;

    undefined destroy();

    GPUBuffer createBuffer(GPUBufferDescriptor descriptor);
    GPUTexture createTexture(GPUTextureDescriptor descriptor);
    GPUSampler createSampler(optional GPUSamplerDescriptor descriptor = {});
    GPUExternalTexture importExternalTexture(GPUExternalTextureDescriptor descriptor);

    GPUBindGroupLayout createBindGroupLayout(GPUBindGroupLayoutDescriptor descriptor);
    GPUPipelineLayout createPipelineLayout(GPUPipelineLayoutDescriptor descriptor);
    GPUBindGroup createBindGroup(GPUBindGroupDescriptor descriptor);

    GPUShaderModule createShaderModule(GPUShaderModuleDescriptor descriptor);
    GPUComputePipeline createComputePipeline(GPUComputePipelineDescriptor descriptor);
    GPURenderPipeline createRenderPipeline(GPURenderPipelineDescriptor descriptor);
    Promise<GPUComputePipeline> createComputePipelineAsync(GPUComputePipelineDescriptor descriptor);
    Promise<GPURenderPipeline> createRenderPipelineAsync(GPURenderPipelineDescriptor descriptor);

    GPUCommandEncoder createCommandEncoder(optional GPUCommandEncoderDescriptor descriptor = {});
    GPURenderBundleEncoder createRenderBundleEncoder(GPURenderBundleEncoderDescriptor descriptor);

    GPUQuerySet createQuerySet(GPUQuerySetDescriptor descriptor);
};
GPUDevice includes GPUObjectBase;

GPUDeviceは以下の不変プロパティを持ちます：

features, 型 GPUSupportedFeatures, 読み取り専用

このデバイスがサポートするGPUFeatureName 値のセット（[[device]].[[features]]）。

limits, 型 GPUSupportedLimits, 読み取り専用

このデバイスがサポートする制限値（[[device]].[[limits]]）。

queue, 型 GPUQueue, 読み取り専用

このデバイスの主キューGPUQueue。

adapterInfo, 型 GPUAdapterInfo, 読み取り専用

このGPUDeviceを生成した物理アダプターの情報。

同じGPUDeviceに対しては、 GPUAdapterInfoの値は常に一定です。

毎回同じオブジェクトが返されます。初回生成方法：

呼び出し元: GPUDevice this.

戻り値: GPUAdapterInfo

this.[[device]].[[adapter]]に対して新しいアダプター情報を返す。

[[device]] はGPUDeviceが参照するdeviceです。

GPUDeviceは以下のメソッドを持ちます：

destroy()

デバイスを破棄し、以降の操作を禁止します。未完了の非同期操作は失敗します。

注意: デバイスは何度破棄しても有効です。

呼び出し元: GPUDevice this.

このデバイスのすべてのGPUBufferをunmap()する。
以降の手順をthisのデバイスタイムラインで発行する。

Lose the device(this.[[device]], "destroyed").

注意: このデバイスに対して以降の操作が一切キューされないため、実装は未完了の非同期操作やリソース割り当て（アンマップ直後のメモリ含む）を即座に中断・解放できます。

GPUDeviceの許可バッファ用途：

常に許可： MAP_READ, MAP_WRITE, COPY_SRC, COPY_DST, INDEX, VERTEX, UNIFORM, STORAGE, INDIRECT, QUERY_RESOLVE

GPUDeviceの許可テクスチャ用途：

常に許可： COPY_SRC, COPY_DST, TEXTURE_BINDING, STORAGE_BINDING, RENDER_ATTACHMENT

4.5. 例

より堅牢なGPUAdapter およびGPUDevice要求のエラーハンドリング例：

let gpuDevice = null;

async function initializeWebGPU() {
    // ユーザーエージェントがWebGPUをサポートしているか確認
    if (!('gpu' in navigator)) {
        console.error("ユーザーエージェントがWebGPUをサポートしていません。");
        return false;
    }

    // アダプター要求
    const gpuAdapter = await navigator.gpu.requestAdapter();

    // 適切なアダプターが見つからない場合、requestAdapterはnullで解決されることがある
    if (!gpuAdapter) {
        console.error('WebGPUアダプターが見つかりません。');
        return false;
    }

    // デバイス要求
    // オプション辞書に無効な値が渡された場合、promiseはrejectされる。
    // 必ずアダプターのfeaturesやlimitsを事前に確認してからrequestDevice()を呼ぶこと。
    gpuDevice = await gpuAdapter.requestDevice();

    // requestDeviceはnullを返さないが、何らかの理由で有効なデバイス要求が満たせない場合
    // 既に失われたデバイスとしてresolveされることがあり得る。
    // また、デバイスは作成後も様々な理由（ブラウザのリソース管理、ドライバ更新等）で
    // いつでも失われる可能性があるため、常にロストデバイスを適切に扱うこと。
    gpuDevice.lost.then((info) => {
        console.error(`WebGPUデバイスが失われました: ${info.message}`);

        gpuDevice = null;

        // デバイスロストの多くは一時的なものなので、アプリケーションは
        // 以前のデバイスが失われたら新規取得を試みるべき（意図的なdestroy理由以外）。
        // 前のデバイスで作成したWebGPUリソース（バッファ、テクスチャ等）は
        // 新しいデバイスで再作成する必要がある。
        if (info.reason != 'destroyed') {
            initializeWebGPU();
        }
    });

    onWebGPUInitialized();

    return true;
}

function onWebGPUInitialized() {
    // ここからWebGPUリソース作成処理を開始
}

initializeWebGPU();

5. バッファ

5.1. `GPUBuffer`

GPUBuffer はGPU操作で利用できるメモリブロックを表します。データは線形レイアウトで格納されており、割り当て領域の各バイトは GPUBufferの先頭からのオフセットで参照可能ですが、操作ごとにアライメント制約があります。一部のGPUBufferはマップ可能であり、対応するメモリブロックはArrayBuffer （マッピング）経由でアクセスできます。

GPUBufferは createBuffer()で作成します。バッファはmappedAtCreationを指定可能です。

[Exposed=(Window, Worker), SecureContext]
interface GPUBuffer {
    readonly attribute GPUSize64Out size;
    readonly attribute GPUFlagsConstant usage;

    readonly attribute GPUBufferMapState mapState;

    Promise<undefined> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size);
    ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size);
    undefined unmap();

    undefined destroy();
};
GPUBuffer includes GPUObjectBase;

enum GPUBufferMapState {
    "unmapped",
    "pending",
    "mapped",
};

GPUBufferは以下の不変プロパティを持ちます：

size, 型 GPUSize64Out, 読み取り専用: GPUBuffer の割り当てサイズ（バイト単位）。
usage, 型 GPUFlagsConstant, 読み取り専用: このGPUBufferで許可されている用途。

GPUBufferは以下のコンテンツタイムラインプロパティを持ちます：

mapState, 型 GPUBufferMapState, 読み取り専用

バッファの現在のGPUBufferMapState：

"unmapped": バッファがthis.getMappedRange()で利用できるようにマップされていません。
"pending": バッファのマッピング要求が保留中です。 mapAsync()で検証失敗または成功する可能性があります。
"mapped": バッファがマップされており、this.getMappedRange() が利用できます。

getter手順：

コンテンツタイムライン手順：

this.[[mapping]] がnullでなければ、 "mapped"を返す。
this.[[pending_map]] がnullでなければ、 "pending"を返す。
"unmapped"を返す。

[[pending_map]], 型 Promise<void> または null（初期値null）

現在保留中のPromise （mapAsync()呼び出し）を返します。

保留中のマップは常に1つしかありません。既に要求中の場合、mapAsync()は即座に拒否します。

[[mapping]], 型 active buffer mapping または null（初期値null）

バッファが現在getMappedRange()で利用可能な場合のみ設定されます。それ以外の場合はnullです（[[pending_map]]があっても）。

active buffer mappingは以下のフィールドを持つ構造体です：

data, 型 Data Block: このGPUBufferのマッピングデータ。このデータはArrayBufferビューを通じてアクセスされ、getMappedRange()で返され、viewsに格納されます。
mode, 型 GPUMapModeFlags: 対応するmapAsync() またはcreateBuffer()呼び出しで指定されたGPUMapModeFlags。
range, 型タプル [unsigned long long, unsigned long long]: マップされたGPUBufferの範囲。
views, 型 list<ArrayBuffer>: アプリケーションにArrayBufferとして返されたビュー。 unmap()呼び出し時に切り離すため管理されます。

active buffer mappingを初期化するには、 mode modeとrange rangeで以下のコンテンツタイムライン手順を実行：

sizeをrange[1] - range[0]とする。
dataを? CreateByteDataBlock(size)で作成。
注意:
この操作はRangeErrorを投げることがあります。一貫性・予測可能性のため：
- その時点でnew ArrayBuffer()が成功するサイズは、この割り当ても成功すべき。
- その時点でnew ArrayBuffer()がRangeErrorを 決定的に投げるサイズは、この割り当ても同様にすべき。
以下を持つactive buffer mappingを返す：
- dataはdata。
- modeはmode。
- rangeはrange。
- viewsは[]。

GPUBufferは以下のデバイスタイムラインプロパティを持ちます：

[[internal state]]

バッファの現在の内部状態：

「available」: このバッファはキュー操作で使用できます（ただしinvalidでない場合に限ります）。
「unavailable」: このバッファはマップされているため、キュー操作で使用できません。
「destroyed」: このバッファはdestroy()されたため、いかなる操作にも使用できません。

5.1.1. `GPUBufferDescriptor`

dictionary GPUBufferDescriptor
         : GPUObjectDescriptorBase {
    required GPUSize64 size;
    required GPUBufferUsageFlags usage;
    boolean mappedAtCreation = false;
};

GPUBufferDescriptor には以下のメンバーがあります：

size, 型 GPUSize64

バッファのサイズ（バイト単位）。

usage, 型 GPUBufferUsageFlags

バッファで許可される用途。

mappedAtCreation, 型 boolean（デフォルトfalse）

trueの場合、バッファは作成時にすでにマップされた状態となり、getMappedRange()が即座に呼び出し可能となります。mappedAtCreation をtrueにしても、usage にMAP_READ やMAP_WRITE を含めなくても有効です。これはバッファの初期データを設定するために利用できます。

バッファ作成が最終的に失敗した場合でも、アンマップされるまではマップ範囲に書き込み／読み出しできるように見えることが保証されます。

5.1.2. バッファ用途

typedef [EnforceRange] unsigned long GPUBufferUsageFlags;
[Exposed=(Window, Worker), SecureContext]
namespace GPUBufferUsage {
    const GPUFlagsConstant MAP_READ      = 0x0001;
    const GPUFlagsConstant MAP_WRITE     = 0x0002;
    const GPUFlagsConstant COPY_SRC      = 0x0004;
    const GPUFlagsConstant COPY_DST      = 0x0008;
    const GPUFlagsConstant INDEX         = 0x0010;
    const GPUFlagsConstant VERTEX        = 0x0020;
    const GPUFlagsConstant UNIFORM       = 0x0040;
    const GPUFlagsConstant STORAGE       = 0x0080;
    const GPUFlagsConstant INDIRECT      = 0x0100;
    const GPUFlagsConstant QUERY_RESOLVE = 0x0200;
};

GPUBufferUsage フラグはGPUBufferが作成後にどのように利用できるかを決定します：

MAP_READ

バッファは読み出し用にマップ可能です。（例：mapAsync() で GPUMapMode.READを指定）

COPY_DSTとだけ組み合わせ可能です。

MAP_WRITE

バッファは書き込み用にマップ可能です。（例：mapAsync() で GPUMapMode.WRITEを指定）

COPY_SRCとだけ組み合わせ可能です。

COPY_SRC

バッファはコピー操作のソースとして利用可能です。（例：copyBufferToBuffer()や copyBufferToTexture()呼び出しのsource引数）

COPY_DST

バッファはコピーや書き込み操作の宛先として利用可能です。（例：copyBufferToBuffer()や copyTextureToBuffer()呼び出しのdestination引数、あるいはwriteBuffer()ターゲット）

INDEX

バッファはインデックスバッファとして利用可能です。（例：setIndexBuffer()への渡し）

VERTEX

バッファは頂点バッファとして利用可能です。（例：setVertexBuffer()への渡し）

UNIFORM

バッファはユニフォームバッファとして利用可能です。（例：GPUBufferBindingLayout のバインドグループエントリで buffer.type が "uniform"の場合）

STORAGE

バッファはストレージバッファとして利用可能です。（例：GPUBufferBindingLayout のバインドグループエントリで buffer.type が "storage" または"read-only-storage"の場合）

INDIRECT

バッファは間接コマンド引数の保存に利用可能です。（例：indirectBuffer引数としてdrawIndirect() や dispatchWorkgroupsIndirect() 呼び出しで利用）

QUERY_RESOLVE

バッファはクエリ結果の取得に利用可能です。（例：destination引数としてresolveQuerySet()呼び出しで使用）

5.1.3. バッファ作成

createBuffer(descriptor)

GPUBufferを作成します。

呼び出し元: GPUDevice this.

引数:

GPUDevice.createBuffer(descriptor)メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUBufferDescriptor`	✘	✘	作成する`GPUBuffer`の記述。

戻り値: GPUBuffer

bを!新しいWebGPUオブジェクトの作成(this, GPUBuffer, descriptor)とする。
b.sizeにdescriptor.sizeを設定する。
b.usageにdescriptor.usageを設定する。
もしdescriptor.mappedAtCreationがtrueなら：
1. descriptor.sizeが4の倍数でない場合、 RangeErrorを投げる。
2. b.[[mapping]]に ?active buffer mappingの初期化 (mode WRITE, range [0, descriptor.size]) を設定する。
initialization stepsをthisのデバイスタイムラインで発行する。
bを返す。

デバイスタイムライン initialization steps:

以下の要件が満たされない場合、検証エラー生成、無効化 b、return。
- thisは失われていてはならない。
- descriptor.usage は0であってはならない。
- descriptor.usage はthisの許可バッファ用途の部分集合でなければならない。
- descriptor.usage にMAP_READが含まれる場合：
  - descriptor.usage にはCOPY_DST以外のフラグが含まれていてはならない。
- descriptor.usage にMAP_WRITEが含まれる場合：
  - descriptor.usage にはCOPY_SRC以外のフラグが含まれていてはならない。
- descriptor.size は this.[[device]].[[limits]].maxBufferSize以下でなければならない。

注意: バッファ作成が失敗し、descriptor.mappedAtCreation がfalseの場合、 mapAsync()呼び出しは拒否されるため、マッピング用に割り当てられたリソースは破棄または再利用される可能性があります。

もしdescriptor.mappedAtCreationがtrueなら：
1. b.[[internal state]] を"unavailable"に設定する。
それ以外：
1. b.[[internal state]] を"available"に設定する。
bのデバイス割り当てを各バイト0で作成する。

割り当てが副作用なしに失敗した場合、メモリエラー生成、無効化 b、return。

書き込み可能な128バイトのユニフォームバッファを作成する例：

const buffer = gpuDevice.createBuffer({
    size: 128,
    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
});

5.1.4. バッファ破棄

アプリケーションがGPUBufferを不要と判断した場合、destroy()を呼び出すことでガベージコレクション前にアクセスを失うことができます。バッファの破棄はマッピングも解除し、マッピング用に割り当てられたメモリも解放します。

注意: これにより、ユーザーエージェントは、そのバッファを使ったすべての操作が完了した時点でGPUメモリを回収できます。

GPUBufferは以下のメソッドを持ちます：

destroy()

GPUBufferを破棄します。

注意: バッファは何度破棄しても有効です。

呼び出し元: GPUBuffer this.

戻り値: undefined

this.unmap()を呼び出す。
以降の手順をthis.[[device]]のデバイスタイムラインで発行する。

デバイスタイムライン手順：

this.[[internal state]] を "destroyed"に設定する。

注意: このバッファを使った以降の操作は一切キューできなくなるため、実装はリソース割り当て（アンマップ直後のメモリも含む）を即座に解放可能です。

5.2. バッファのマッピング

アプリケーションはGPUBufferをマッピングするよう要求でき、これによりArrayBufferでGPUBufferの一部割り当て領域にアクセス可能となります。GPUBufferのマッピング要求はmapAsync()で非同期に行われ、ユーザーエージェントがGPUの利用完了を確認してからアプリケーションが内容にアクセスできるようにします。マップ中のGPUBufferはGPUで利用できず、unmap()でアンマップしないと、Queueタイムラインで作業登録できません。

一度GPUBufferがマップされると、アプリケーションはgetMappedRange()で範囲アクセスを同期的に要求できます。返されたArrayBufferはunmap()（直接またはGPUBuffer.destroy()やGPUDevice.destroy()経由）でのみdetach可能です。transferはできません。他の操作がそれを試みるとTypeErrorが投げられます。

typedef [EnforceRange] unsigned long GPUMapModeFlags;
[Exposed=(Window, Worker), SecureContext]
namespace GPUMapMode {
    const GPUFlagsConstant READ  = 0x0001;
    const GPUFlagsConstant WRITE = 0x0002;
};

GPUMapMode フラグはGPUBufferがmapAsync()でどのようにマップされるかを決定します：

READ

このフラグはMAP_READ用途で作成されたバッファにのみ有効です。

バッファがマップされると、getMappedRange()呼び出しはバッファの現行値を含むArrayBufferを返します。返されたArrayBufferの変更はunmap()呼び出し後に破棄されます。

WRITE

このフラグはMAP_WRITE用途で作成されたバッファにのみ有効です。

バッファがマップされると、getMappedRange()呼び出しはバッファの現行値を含むArrayBufferを返します。返されたArrayBufferの変更はGPUBufferにunmap()呼び出し後に保存されます。

注意: MAP_WRITE用途のバッファはCOPY_SRC用途のみと組み合わせ可能なため、書き込み用マッピングではGPUで生成された値は返されません。返されるArrayBufferはデフォルト初期化（ゼロ）または前回マッピング時にウェブページで書き込まれたデータのみを含みます。

GPUBufferは以下のメソッドを持ちます：

mapAsync(mode, offset, size)

指定された範囲のGPUBufferをマップし、Promise が解決されるとGPUBufferの内容をgetMappedRange()でアクセスできるようになります。

返されたPromiseの解決はマップが完了したことのみを示し、現行標準タイムライン上で見える他の操作の完了は保証しません。特に、他のPromise （onSubmittedWorkDone()や他のmapAsync()）が解決されていることは意味しません。

Promise （onSubmittedWorkDone()）の解決は、その呼び出し前に同じキューで排他的に使われたGPUBufferのmapAsync() が完了していることを意味します。

呼び出し元: GPUBuffer this.

引数:

GPUBuffer.mapAsync(mode, offset, size)メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`mode`	`GPUMapModeFlags`	✘	✘	バッファを読み取り／書き込みどちらでマップするか。
`offset`	`GPUSize64`	✘	✔	マップ範囲の開始バイトオフセット。
`size`	`GPUSize64`	✘	✔	マップする範囲のバイト数。

戻り値: Promise<undefined>

contentTimelineを現在のコンテンツタイムラインとする。
this.mapState が"unmapped"でない場合：
1. this.[[device]]のデバイスタイムラインでearly-reject stepsを発行する。
2. PromiseをOperationErrorで拒否して返す。
pを新しいPromiseとする。
this.[[pending_map]]にpを設定する。
this.[[device]]のデバイスタイムラインでvalidation stepsを発行する。
pを返す。

デバイスタイムライン early-reject steps:

検証エラーを生成する。
Return。

デバイスタイムライン validation steps:

sizeがundefinedの場合：
1. rangeSizeにmax(0, this.size - offset)を設定。
それ以外の場合：
1. rangeSizeにsizeを設定。
以下の条件が満たされない場合：
- thisは有効でなければならない。
1. deviceLostをtrueに設定。
2. contentTimelineでmap failure stepsを発行。
3. Return。
以下の条件が満たされない場合：
- this.[[internal state]] が"available"である。
- offsetが8の倍数である。
- rangeSizeが4の倍数である。
- offset + rangeSize ≤ this.size
- modeはGPUMapModeで定義されたビットのみを含む。
- modeはREADまたはWRITEのうち1つだけを含む。
- modeがREADを含む場合、this.usageはMAP_READを含む必要がある。
- modeがWRITEを含む場合、this.usageはMAP_WRITEを含む必要がある。
それ以外の場合：
1. deviceLostをfalseに設定。
2. contentTimelineでmap failure stepsを発行。
3. 検証エラーを生成する。
4. Return。
this.[[internal state]] を"unavailable"に設定。

注: バッファがマップされている間は、unmap()まで内容は変更されません。
次のいずれかのイベントが発生した時点（先に発生した方、またはすでに発生していれば）：
- デバイスタイムラインが未特定のキュータイムラインの完了を認識：
  - 現在キュー済みのthis利用操作の完了後
  - 現在キュー済みの全操作の完了までに（thisの利用有無に関わらず）
- this.[[device]] が失われた場合。
その後、this.[[device]]のデバイスタイムラインで後続の手順を発行する。

デバイスタイムライン手順:

this.[[device]] が失われた場合はdeviceLostをtrue、それ以外はfalseに設定。

注: デバイス喪失は前ブロックとこの間でも起こり得ます。
deviceLostがtrueの場合：
1. contentTimelineでmap failure stepsを発行。
それ以外の場合：
1. internalStateAtCompletionをthis.[[internal state]]とする。
  
  注: この時点でunmap()呼び出しでバッファが再び"available"になった場合、[[pending_map]]はpと異なるため、以下のマッピングは成功しません。
2. dataForMappedRegionにthisのoffsetからrangeSizeバイト分の内容を設定。
3. contentTimelineでmap success stepsを発行。

コンテンツタイムライン map success steps:

this.[[pending_map]] がpと異なる場合：

注: unmap()によりマップがキャンセルされています。
1. Assert pは拒否されている。
2. Return。
Assert pはpendingである。
Assert internalStateAtCompletionは"unavailable"。
mappingをactive buffer mappingの初期化 (mode mode, range [offset, offset + rangeSize])で生成する。

この割り当てに失敗した場合：
1. this.[[pending_map]] をnullにし、RangeErrorでpを拒否。
2. Return。
mapping.dataの内容をdataForMappedRegionに設定する。
this.[[mapping]]にmappingを設定する。
this.[[pending_map]]をnullにし、pをresolveする。

コンテンツタイムライン map failure steps:

this.[[pending_map]] がpと異なる場合：

注: unmap()によりマップがキャンセルされています。
1. Assert pはすでに拒否されている。
2. Return。
Assert pはまだpendingである。
this.[[pending_map]] をnullに設定する。
deviceLostがtrueの場合：
1. pをAbortErrorで拒否。
  
  注: unmap()でキャンセルされた場合も同じエラータイプです。
それ以外の場合：
1. pをOperationErrorで拒否。

getMappedRange(offset, size)

指定したマップ範囲のArrayBufferを返します。内容はGPUBufferのものです。

呼び出し元: GPUBuffer this.

引数:

GPUBuffer.getMappedRange(offset, size)メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`offset`	`GPUSize64`	✘	✔	バッファ内容取得開始のバイトオフセット。
`size`	`GPUSize64`	✘	✔	返す`ArrayBuffer`のバイトサイズ。

戻り値: ArrayBuffer

sizeが指定されていなければ：
1. rangeSizeをmax(0, this.size - offset)とする。
指定されていればrangeSizeはsize。
以下の条件が満たされない場合、OperationErrorを投げて終了：
- this.[[mapping]] がnullでない。
- offsetは8の倍数。
- rangeSizeは4の倍数。
- offset ≥ this.[[mapping]].range[0]。
- offset + rangeSize ≤ this.[[mapping]].range[1]。
- [offset, offset + rangeSize)がthis.[[mapping]].viewsの他範囲と重複しない。
注: GPUBuffer が mappedAtCreation の場合、無効でも常にgetMappedRangeは有効です。現行標準タイムラインが無効性を認識できないためです。
dataをthis.[[mapping]].dataとする。
viewを! ArrayBufferの生成（サイズrangeSize、ポインタはdataの(offset - [[mapping]].range[0]）バイト先を参照）とする。

注: dataはmapAsync()やcreateBuffer()ですでに割り当てられているため、ここでRangeErrorは投げられません。
view.[[ArrayBufferDetachKey]]に"WebGPUBufferMapping"を設定する。

注: TypeErrorは、unmap()以外でDetachArrayBufferしようとした場合に投げられる。
viewをthis.[[mapping]].viewsに追加する。
viewを返す。

注: getMappedRange()でmapの状態確認なしに成功した場合、ユーザーエージェントは開発者向け警告を表示検討すべきです。mapAsync()の成功、mapStateが"mapped"、または後のonSubmittedWorkDone()成功を待つことで状態確認できる。

unmap()

マップされた範囲のアンマップを行い、内容をGPUで再び利用可能にします。

呼び出し元: GPUBuffer this.

戻り値: undefined

this.[[pending_map]] がnullでない場合：
1. this.[[pending_map]] をAbortErrorで拒否する。
2. this.[[pending_map]]をnullに設定
this.[[mapping]] がnullの場合：
1. Return。
各ArrayBuffer abについて、this.[[mapping]].views内：
1. DetachArrayBuffer(ab,"WebGPUBufferMapping")を実行
bufferUpdateをnullとする。
this.[[mapping]].modeがWRITEを含む場合：
1. bufferUpdate = { data: this.[[mapping]].data, offset: this.[[mapping]].range[0] }とする。
注: WRITEモードでない場合、アンマップ時にアプリケーションによるローカル変更は破棄され、後のマッピング内容には影響しない。
this.[[mapping]]をnullに設定
以降の手順をthis.[[device]]のデバイスタイムラインで発行

デバイスタイムライン手順：

以下の条件が満たされない場合はreturn：
- thisはthis.[[device]]で有効に利用可能である必要がある。
Assert this.[[internal state]] は"unavailable"。
bufferUpdateがnullでなければ：
1. this.[[device]].queueのキュータイムラインで以下発行：
  キュータイムライン手順：
  1. thisのbufferUpdate.offsetからbufferUpdate.dataで内容更新
this.[[internal state]]を"available"に設定

6. テクスチャとテクスチャビュー

6.1. `GPUTexture`

テクスチャは、1d・ 2d・ 3d のデータ配列で構成され、各要素が複数の値を持つことで色などを表現できます。テクスチャは、作成時のGPUTextureUsage に応じて様々な方法で読み書きが可能です。例えば、レンダー/コンピュートパイプラインのシェーダからサンプリング・読み書きでき、レンダーパスの出力として書き込むこともできます。内部的には、テクスチャは線形アクセスではなく多次元アクセスに最適化されたGPUメモリレイアウトで格納されていることが多いです。

1つのテクスチャは、1つ以上のテクスチャサブリソースから構成されます。各サブリソースはミップマップレベルで一意に識別され、 2dテクスチャの場合のみ、配列レイヤーおよびアスペクトでも識別されます。

テクスチャサブリソースはサブリソースであり、それぞれが1つの利用スコープ内で異なる内部用途に利用できます。

ミップマップレベル内の各サブリソースは、 1つ下のレベルのリソースと比べて各空間次元で約半分のサイズです（論理ミップレベル別テクスチャ範囲参照）。レベル0のサブリソースがテクスチャ本体の寸法となります。より小さいレベルは通常、同じ画像の低解像度版の格納に用いられます。 GPUSamplerやWGSLは、詳細度レベルの選択や補間を明示的または自動で行う仕組みを提供します。

"2d" テクスチャは配列レイヤーの配列になる場合があります。各レイヤー内のサブリソースは他レイヤーの同じリソースと同サイズです。 2d以外のテクスチャでは全てのサブリソースの配列レイヤーインデックスは0です。

各サブリソースはアスペクトを持ちます。カラーテクスチャはcolorのみです。深度・ステンシルフォーマットのテクスチャは複数アスペクト（depth・ stencil）を持つ場合があり、 depthStencilAttachmentや "depth"バインディングなどで特殊な用途に使われます。

"3d" テクスチャは複数のスライス（各z値ごとの2次元画像）を持ちます。スライスはサブリソースとは異なります。

[Exposed=(Window, Worker), SecureContext]
interface GPUTexture {
    GPUTextureView createView(optional GPUTextureViewDescriptor descriptor = {});

    undefined destroy();

    readonly attribute GPUIntegerCoordinateOut width;
    readonly attribute GPUIntegerCoordinateOut height;
    readonly attribute GPUIntegerCoordinateOut depthOrArrayLayers;
    readonly attribute GPUIntegerCoordinateOut mipLevelCount;
    readonly attribute GPUSize32Out sampleCount;
    readonly attribute GPUTextureDimension dimension;
    readonly attribute GPUTextureFormat format;
    readonly attribute GPUFlagsConstant usage;
    readonly attribute (GPUTextureViewDimension or undefined) textureBindingViewDimension;
};
GPUTexture includes GPUObjectBase;

GPUTexture には以下の不変プロパティがあります：

width, 型 GPUIntegerCoordinateOut, 読み取り専用: このGPUTextureの幅。
height, 型 GPUIntegerCoordinateOut, 読み取り専用: このGPUTextureの高さ。
depthOrArrayLayers, 型 GPUIntegerCoordinateOut, 読み取り専用: このGPUTextureの深度またはレイヤー数。
mipLevelCount, 型 GPUIntegerCoordinateOut, 読み取り専用: このGPUTextureのミップレベル数。
sampleCount, 型 GPUSize32Out, 読み取り専用: このGPUTextureのサンプル数。
dimension, 型 GPUTextureDimension, 読み取り専用: 各GPUTextureサブリソースごとのテクセルの次元。
format, 型 GPUTextureFormat, 読み取り専用: このGPUTextureのフォーマット。
usage, 型 GPUFlagsConstant, 読み取り専用: このGPUTextureで許可される用途。
[[viewFormats]], 型 sequence<GPUTextureFormat>: このGPUTextureに対して GPUTextureViewDescriptor.format として利用可能なGPUTextureFormatの集合。
textureBindingViewDimension, 型 (GPUTextureViewDimension or undefined)、読み取り専用: "core-features-and-limits" を持たないデバイスでは、このテクスチャから作成されたビューは、その dimension としてこれを持っていなければなりません。

"core-features-and-limits" を持つデバイスでは、これは undefined であり、そのような制限はありません。

GPUTexture には以下のデバイスタイムラインプロパティがあります：

[[destroyed]], 型 boolean, 初期値false: テクスチャが破棄された場合、いかなる操作にも利用できなくなり、基盤となるメモリも解放可能となります。

compute render extent(baseSize, mipLevel)

引数:

GPUExtent3D baseSize
GPUSize32 mipLevel

戻り値: GPUExtent3DDict

デバイスタイムライン手順：

extentを新しいGPUExtent3DDict オブジェクトとする。
extent.width にmax(1, baseSize.width ≫ mipLevel)を設定。
extent.height にmax(1, baseSize.height ≫ mipLevel)を設定。
extent.depthOrArrayLayers に1を設定。
extentを返す。

論理ミップレベル別テクスチャ範囲とは、特定のミップレベルにおけるテクスチャのテクセル単位のサイズです。次の手順で算出されます：

Logical miplevel-specific texture extent(descriptor, mipLevel)

引数:

GPUTextureDescriptor descriptor
GPUSize32 mipLevel

戻り値: GPUExtent3DDict

extentを新しいGPUExtent3DDictオブジェクトとする。
descriptor.dimension が次の場合：
"1d"
- extent.width にmax(1, descriptor.size.width ≫ mipLevel)を設定。
- extent.height に1を設定。
- extent.depthOrArrayLayers に1を設定。
"2d"
- extent.width にmax(1, descriptor.size.width ≫ mipLevel)を設定。
- extent.height にmax(1, descriptor.size.height ≫ mipLevel)を設定。
- extent.depthOrArrayLayers にdescriptor.size.depthOrArrayLayersを設定。
"3d"
- extent.width にmax(1, descriptor.size.width ≫ mipLevel)を設定。
- extent.height にmax(1, descriptor.size.height ≫ mipLevel)を設定。
- extent.depthOrArrayLayers にmax(1, descriptor.size.depthOrArrayLayers ≫ mipLevel)を設定。
extentを返す。

物理ミップレベル別テクスチャ範囲とは、特定のミップレベルにおけるテクスチャのテクセル単位のサイズ（テクセルブロックを完全に構成するための余分なパディングを含む）です。次の手順で算出されます：

Physical miplevel-specific texture extent(descriptor, mipLevel)

引数:

GPUTextureDescriptor descriptor
GPUSize32 mipLevel

戻り値: GPUExtent3DDict

extentを新しいGPUExtent3DDictオブジェクトとする。
logicalExtentに論理ミップレベル別テクスチャ範囲(descriptor, mipLevel)を設定。
descriptor.dimension が次の場合：
"1d"
- extent.width にlogicalExtent.widthをdescriptorのテクセルブロック幅の倍数に切り上げて設定。
- extent.height に1を設定。
- extent.depthOrArrayLayers に1を設定。
"2d"
- extent.width にlogicalExtent.widthをdescriptorのテクセルブロック幅の倍数に切り上げて設定。
- extent.height にlogicalExtent.heightをdescriptorのテクセルブロック高さの倍数に切り上げて設定。
- extent.depthOrArrayLayers にlogicalExtent.depthOrArrayLayersを設定。
"3d"
- extent.width にlogicalExtent.widthをdescriptorのテクセルブロック幅の倍数に切り上げて設定。
- extent.height にlogicalExtent.heightをdescriptorのテクセルブロック高さの倍数に切り上げて設定。
- extent.depthOrArrayLayers にlogicalExtent.depthOrArrayLayersを設定。
extentを返す。

6.1.1. `GPUTextureDescriptor`

dictionary GPUTextureDescriptor
         : GPUObjectDescriptorBase {
    required GPUExtent3D size;
    GPUIntegerCoordinate mipLevelCount = 1;
    GPUSize32 sampleCount = 1;
    GPUTextureDimension dimension = "2d";
    required GPUTextureFormat format;
    required GPUTextureUsageFlags usage;
    sequence<GPUTextureFormat> viewFormats = [];
    GPUTextureViewDimension textureBindingViewDimension;
};

GPUTextureDescriptor には以下のメンバーがあります：

size, 型 GPUExtent3D

テクスチャの幅、高さ、および深さまたはレイヤー数。

mipLevelCount, 型 GPUIntegerCoordinate, 既定値 1

テクスチャが含むミップレベルの数。

sampleCount, 型 GPUSize32, 既定値 1

テクスチャのサンプル数。sampleCount > 1 はマルチサンプルされたテクスチャを示します。

dimension, 型 GPUTextureDimension, 既定値 "2d"

テクスチャが一次元か、二次元レイヤーの配列か、三次元かを示します。

format, 型 GPUTextureFormat

テクスチャのフォーマット。

usage, 型 GPUTextureUsageFlags

テクスチャで許可される使用方法。

viewFormats, 型 sequence<GPUTextureFormat>, 既定値 []

このテクスチャで format 値が createView() を呼び出す際に許可されるかを指定します（テクスチャ自身の実際の format に加えて）。

NOTE:

このリストにフォーマットを追加するとパフォーマンスに大きな影響を与える可能性があるため、不必要にフォーマットを追加しないことが望ましい。

実際のパフォーマンスへの影響はターゲットシステムに大きく依存するため、開発者はさまざまなシステムでテストして特定のアプリケーションへの影響を確認する必要があります。例えば、あるシステムでは任意のテクスチャの format または viewFormats エントリに "rgba8unorm-srgb" が含まれている場合、それは "rgba8unorm" を含まないテクスチャよりも性能が劣ることがあります。他の形式やシステムでも類似の注意点が存在します。

このリストのフォーマットは、テクスチャのフォーマットと texture view format compatible でなければなりません。

2つの GPUTextureFormat format と viewFormat は、ある device において、テクスチャビューのフォーマット互換であるのは、次の場合である：

format が viewFormat と等しい場合、または
format と viewFormat が srgb フォーマット（-srgb サフィックスを持つかどうか）の違いのみの場合、かつ device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含む場合。

textureBindingViewDimension, 型 GPUTextureViewDimension

"core-features-and-limits" を持たないデバイスでは、このテクスチャから作成されたビューは dimension としてこれを持たなければなりません。指定されなかった場合は、デフォルト値が選択されます。

"core-features-and-limits" を持つデバイスでは、これは無視され、そのような制限はありません。

enum GPUTextureDimension {
    "1d",
    "2d",
    "3d",
};

"1d": 一次元（幅のみ）のテクスチャ。"1d" テクスチャはミップマップ不可・マルチサンプル不可・圧縮／深度／ステンシル不可・レンダーターゲット不可です。
"2d": 幅・高さを持ち、レイヤーも持てるテクスチャ。
"3d": 幅・高さ・深度を持つテクスチャ。"3d" テクスチャはマルチサンプル不可・フォーマットは3d対応（プレーンカラーフォーマットや一部パック／圧縮フォーマット）のみ。

6.1.2. テクスチャ用途

typedef [EnforceRange] unsigned long GPUTextureUsageFlags;
[Exposed=(Window, Worker), SecureContext]
namespace GPUTextureUsage {
    const GPUFlagsConstant COPY_SRC          = 0x01;
    const GPUFlagsConstant COPY_DST          = 0x02;
    const GPUFlagsConstant TEXTURE_BINDING   = 0x04;
    const GPUFlagsConstant STORAGE_BINDING   = 0x08;
    const GPUFlagsConstant RENDER_ATTACHMENT = 0x10;
};

GPUTextureUsage のフラグは、GPUTexture の作成後の用途を決定します：

COPY_SRC: コピー操作のソースとして利用可能（例：source引数としてcopyTextureToTexture() やcopyTextureToBuffer()）。
COPY_DST: コピー・書き込み操作のデスティネーションとして利用可能（例：destination引数としてcopyTextureToTexture() やcopyBufferToTexture()、writeTexture()のターゲット）。
TEXTURE_BINDING: シェーダでサンプル用テクスチャとしてバインド可能（例：GPUTextureBindingLayoutのバインドグループエントリ）。
STORAGE_BINDING: シェーダでストレージテクスチャとしてバインド可能（例：GPUStorageTextureBindingLayoutのバインドグループエントリ）。
RENDER_ATTACHMENT: レンダーパスのカラー／深度・ステンシルアタッチメントとして利用可能（例：GPURenderPassColorAttachment.viewや GPURenderPassDepthStencilAttachment.view）。

maximum mipLevel count(dimension, size)

引数:

GPUTextureDimension dimension
GPUTextureDimension size

最大次元値mを計算：
- dimensionの場合：
  
  "1d"
  
  1を返す。
  
  "2d"
  
  m = max(size.width, size.height)。
  
  "3d"
  
  m = max(max(size.width, size.height), size.depthOrArrayLayers)。
floor(log₂(m)) + 1 を返す。

6.1.3. テクスチャの作成

createTexture(descriptor)

GPUTextureを作成します。

呼び出し元: GPUDevice this.

引数:

GPUDevice.createTexture(descriptor)メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUTextureDescriptor`	✘	✘	作成する`GPUTexture`の説明。

戻り値: GPUTexture

? GPUExtent3D の形状を検証する(descriptor.size)。
? テクスチャフォーマットに必要な機能を検証する: descriptor.format と this.[[device]] を用いる。
? テクスチャフォーマットに必要な機能を検証する: descriptor.viewFormats の各要素と this.[[device]] を用いる。
変数 t に ! 新しい WebGPU オブジェクトを作成する(this, GPUTexture, descriptor) を代入する。
t.width に descriptor.size.width を設定する。
t.height に descriptor.size.height を設定する。
t.depthOrArrayLayers に descriptor.size.depthOrArrayLayers を設定する。
t.mipLevelCount に descriptor.mipLevelCount を設定する。
t.sampleCount に descriptor.sampleCount を設定する。
t.dimension に descriptor.dimension を設定する。
t.format に descriptor.format を設定する。
t.usage に descriptor.usage を設定する。
もし t.[[device]].[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
1. もし descriptor.textureBindingViewDimension が指定されている場合：
  1. t.textureBindingViewDimension に descriptor.textureBindingViewDimension を設定する。
  それ以外の場合、descriptor.dimension が次のいずれかである場合：
  "1d"
  
  t.textureBindingViewDimension に "1d" を設定する。
  
  "2d"
  配列レイヤー数が 1 である場合：
  
  t.textureBindingViewDimension に "2d" を設定する。
  
  それ以外の場合：
  
  t.textureBindingViewDimension に "2d-array" を設定する。
  "3d"
  
  t.textureBindingViewDimension に "3d" を設定する。
デバイスタイムラインで this の 初期化手順 を実行する。
t を返す。

デバイスタイムライン initialization steps:

以下の条件が満たされない場合検証エラーの生成、tの無効化、return。
- GPUTextureDescriptorの検証(this, descriptor) がtrueを返す。
t.[[viewFormats]] にdescriptor.viewFormatsを設定。
各ブロックがゼロのビット表現と等価な等価テクセル表現になるよう、tのデバイス割り当てを作成。

割り当てが副作用なしに失敗した場合、メモリ不足エラー生成、tの無効化、return。

GPUTextureDescriptorの検証(this, descriptor):

引数:

GPUDevice this
GPUTextureDescriptor descriptor

デバイスタイムライン手順：

limitsをthis.[[limits]]とする。
以下すべて満たせばtrue、そうでなければfalseを返す：
- thisが失われていないこと。
- descriptor.usage は0でないこと。
- descriptor.usage はthisの許可されたテクスチャ用途ビットのみを含むこと。
- descriptor.size.width, descriptor.size.height, descriptor.size.depthOrArrayLayersがゼロ超であること。
- descriptor.mipLevelCount がゼロ超であること。
- descriptor.sampleCount が1または4であること。
- descriptor.dimensionが：
  "1d"
  descriptor.size.widthがlimits.maxTextureDimension1D 以下。
  
  descriptor.size.heightが1。
  
  descriptor.size.depthOrArrayLayers が1。
  
  descriptor.sampleCount が1。
  
  descriptor.format が圧縮フォーマットまたは深度・ステンシルフォーマットでない。
  "2d"
  descriptor.size.widthがlimits.maxTextureDimension2D 以下。
  
  descriptor.size.heightがlimits.maxTextureDimension2D 以下。
  
  descriptor.size.depthOrArrayLayers がlimits.maxTextureArrayLayers 以下。
  "3d"
  descriptor.size.widthがlimits.maxTextureDimension3D 以下。
  
  descriptor.size.heightがlimits.maxTextureDimension3D 以下。
  
  descriptor.size.depthOrArrayLayers がlimits.maxTextureDimension3D 以下。
  
  descriptor.sampleCount が1。
  
  descriptor.format は § 26.1 テクスチャフォーマットの機能に従い、 "3d" テクスチャをサポートしていなければならない。
- もし this.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  1. もし descriptor.textureBindingViewDimension が "2d" の場合、 this.size.depthOrArrayLayers は 1 でなければならない。
  2. もし descriptor.textureBindingViewDimension が "cube" の場合、 this.size.depthOrArrayLayers は 6 でなければならない。
  Note: この検証はユーザーが textureBindingViewDimension を指定した場合のみ適用される。値が指定されなかった場合，テクスチャの textureBindingViewDimension は createTexture() で説明されている通りに設定される。そのアルゴリズムでは無効な値を生成できないため，上記の検証は不要である。
- descriptor.size.width はテクセルブロック幅の倍数でなければならない。
- descriptor.size.height はテクセルブロック高さの倍数でなければならない。
- もし descriptor.sampleCount > 1 の場合：
  - descriptor.mipLevelCount は 1 でなければならない。
  - descriptor.size.depthOrArrayLayers は 1 でなければならない。
  - descriptor.usage は STORAGE_BINDING ビットを含んではならない。
  - descriptor.usage は RENDER_ATTACHMENT ビットを含んでいなければならない。
  - descriptor.format は § 26.1 テクスチャフォーマットの機能に従い，マルチサンプリングをサポートしていなければならない。
- descriptor.mipLevelCount は maximum mipLevel count(descriptor.dimension, descriptor.size) 以下でなければならない。
- もし descriptor.usage が RENDER_ATTACHMENT ビットを含む場合：
  - descriptor.format はレンダラブルフォーマットでなければならない。
  - descriptor.dimension は "2d" または "3d" のいずれかでなければならない。
- もし descriptor.usage が STORAGE_BINDING ビットを含む場合：
  - descriptor.format は § 26.1.1 プレーン色情報フォーマットの表で少なくとも1つのアクセスモードに対して STORAGE_BINDING 機能を持つものでなければならない。
- descriptor.viewFormats の各 viewFormat について， descriptor.format と viewFormat はデバイス this 上でテクスチャビューのフォーマット互換性を満たしていなければならない。
  
  NOTE:
  実装は，もし viewFormat が指定された usage ビットと互換性がない場合，その viewFormat は利用できなくなるため，開発者に警告を表示してもよい。

16x16、RGBA、2D、配列レイヤー1・ミップレベル1のテクスチャ生成例：

const texture = gpuDevice.createTexture({
    size: { width: 16, height: 16 },
    format: 'rgba8unorm',
    usage: GPUTextureUsage.TEXTURE_BINDING,
});

6.1.4. テクスチャの破棄

アプリケーションがGPUTexture を不要になった場合、ガベージコレクション前にdestroy()を呼び出してアクセスを失わせることができます。

注: これにより、ユーザーエージェントはGPUTexture に関連付けられたGPUメモリをそれまでに提出されたすべての操作が完了次第、回収できるようになります。

GPUTexture には次のメソッドがあります：

destroy()

GPUTextureを破棄します。

呼び出し元: GPUTexture this.

戻り値: undefined

以降の手順をデバイスタイムラインで発行する。

デバイスタイムライン手順：

this.[[destroyed]] をtrueに設定する。

6.2. `GPUTextureView`

GPUTextureView は、特定のGPUTextureが持つテクスチャサブリソースの部分集合へのビューです。

[Exposed=(Window, Worker), SecureContext]
interface GPUTextureView {
};
GPUTextureView includes GPUObjectBase;

GPUTextureView には以下の不変プロパティがあります：

[[texture]], readonly

このビューが参照するGPUTexture。

[[descriptor]], readonly

このテクスチャビューを記述するGPUTextureViewDescriptor。

GPUTextureViewDescriptorのすべてのオプションフィールドが定義済みです。

[[renderExtent]], readonly

レンダー可能ビューの場合、描画時の有効なGPUExtent3DDict。

注: この範囲はbaseMipLevelに依存します。

テクスチャビューviewのサブリソース集合は、 [[descriptor]] descを用いて、 view.[[texture]] のサブリソースのうち、各サブリソースsが以下を満たすものです：

sのミップマップレベルが desc.baseMipLevel 以上、 desc.baseMipLevel + desc.mipLevelCount 未満。
sの配列レイヤーが desc.baseArrayLayer 以上、 desc.baseArrayLayer + desc.arrayLayerCount 未満。
sのアスペクトが desc.aspect のアスペクト集合に含まれる。

2つのGPUTextureView オブジェクトは、そのサブリソース集合が交差する場合に限りテクスチャビュー・エイリアスとなります。

6.2.1. テクスチャビューの作成

dictionary GPUTextureViewDescriptor
         : GPUObjectDescriptorBase {
    GPUTextureFormat format;
    GPUTextureViewDimension dimension;
    GPUTextureUsageFlags usage = 0;
    GPUTextureAspect aspect = "all";
    GPUIntegerCoordinate baseMipLevel = 0;
    GPUIntegerCoordinate mipLevelCount;
    GPUIntegerCoordinate baseArrayLayer = 0;
    GPUIntegerCoordinate arrayLayerCount;

    // Requires "texture-component-swizzle" feature.
    DOMString swizzle = "rgba";
};

GPUTextureViewDescriptor には以下のメンバーがあります：

format, 型 GPUTextureFormat

テクスチャビューのフォーマット。テクスチャ自体のformatか、または作成時に指定したviewFormatsのいずれかでなければなりません。

dimension, 型 GPUTextureViewDimension

テクスチャをどの次元でビューするか。

usage, 型 GPUTextureUsageFlags（デフォルト値0）

テクスチャビューの許可用途。テクスチャのusageフラグの部分集合でなければなりません。0の場合、テクスチャの全usageフラグをデフォルトとします。

注: ビューのformat がテクスチャの全usageに対応しない場合、デフォルトは失敗し、明示的にusage を指定する必要があります。

aspect, 型 GPUTextureAspect（デフォルト値"all"）

テクスチャビューからアクセス可能なaspect。

baseMipLevel, 型 GPUIntegerCoordinate（デフォルト値0）

テクスチャビューからアクセス可能な最初（最詳細）のミップマップレベル。

mipLevelCount, 型 GPUIntegerCoordinate

baseMipLevel から始まるミップマップレベル数。

baseArrayLayer, 型 GPUIntegerCoordinate（デフォルト値0）

テクスチャビューからアクセス可能な最初の配列レイヤーのインデックス。

arrayLayerCount, 型 GPUIntegerCoordinate

baseArrayLayer から始まるアクセス可能な配列レイヤー数。

swizzle, 型は DOMString で、既定値は "rgba"

長さ4の文字列で、各文字はそれぞれテクスチャビューの赤/緑/青/アルファの各チャンネルに対応する。

シェーダからアクセスされた場合、赤/緑/青/アルファ各チャンネルは、それぞれ swizzle[0]、swizzle[1]、swizzle[2]、 swizzle[3] に指定された成分に対応する値で置き換えられる：

"r": テクスチャの赤チャンネルの値を使用する。
"g": テクスチャの緑チャンネルの値を使用する。
"b": テクスチャの青チャンネルの値を使用する。
"a": テクスチャのアルファチャンネルの値を使用する。
"0": 値を 0 に固定する。
"1": 値を 1 に固定する。

"texture-component-swizzle" 機能が有効である必要がある。

enum GPUTextureViewDimension {
    "1d",
    "2d",
    "2d-array",
    "cube",
    "cube-array",
    "3d",
};

"1d"

テクスチャを一次元画像としてビューします。

対応WGSL型：

texture_1d
texture_storage_1d

"2d"

テクスチャを単一の二次元画像としてビューします。

対応WGSL型：

texture_2d
texture_storage_2d
texture_multisampled_2d
texture_depth_2d
texture_depth_multisampled_2d

"2d-array"

テクスチャビューを二次元画像の配列としてビューします。

対応WGSL型：

texture_2d_array
texture_storage_2d_array
texture_depth_2d_array

"cube"

テクスチャをキューブマップとしてビューします。

ビューは6つの配列レイヤーを持ち、それぞれキューブの面（[+X, -X, +Y, -Y, +Z, -Z]）と以下の向きに対応します：

キューブマップ面。+U/+V軸は個々の面のテクスチャ座標、すなわち各面のテクセルコピーメモリレイアウトを示します。

注: 内側からビューした場合、+Xが右、+Yが上、+Zが前の左手座標系になります。

サンプリングはキューブマップの面をまたいでシームレスに行われます。

対応WGSL型：

texture_cube
texture_depth_cube

"cube-array"

テクスチャは、n 個のキューブマップから成るパック配列として見なされます。各キューブマップは6つの配列レイヤーを持ち、それぞれが1つの "cube" ビューのように振る舞います。合計で 6n の配列レイヤーとなります。

対応するWGSL型：

texture_cube_array
texture_depth_cube_array

"3d"

テクスチャを三次元画像としてビューします。

対応WGSL型：

texture_3d
texture_storage_3d

各GPUTextureAspect値はアスペクトの集合に対応します。アスペクト集合は以下の各値ごとに定義されています。

enum GPUTextureAspect {
    "all",
    "stencil-only",
    "depth-only",
};

"all"

テクスチャフォーマットの利用可能な全アスペクトがテクスチャビューからアクセス可能になります。カラーフォーマットの場合colorアスペクトが、複合深度ステンシルフォーマットの場合はdepthとstencil両方が、単一アスペクトの深度・ステンシルフォーマットはそのアスペクトのみアクセス可能です。

アスペクト集合は[color, depth, stencil]です。

"stencil-only"

深度・ステンシルフォーマットのstencilアスペクトのみがテクスチャビューからアクセス可能です。

アスペクト集合は[stencil]です。

"depth-only"

深度・ステンシルフォーマットのdepthアスペクトのみがテクスチャビューからアクセス可能です。

アスペクト集合は[depth]です。

createView(descriptor)

GPUTextureView を作成します。

注意:

デフォルトでは、createView() は、テクスチャ全体を表現できる次元を持つビューを作成します。たとえば、createView() を呼び出す際に dimension を指定せず、かつ複数レイヤーの "2d" テクスチャの場合、"2d-array" の GPUTextureView が作成されます（たとえ arrayLayerCount に 1 を指定していても）。

レイヤー数が開発時に不明なソースから作成されたテクスチャの場合、シェーダとの互換性を確保するために、createView() の呼び出し時に明示的な dimension を指定することが推奨されます。

呼び出し対象: GPUTexture this。

引数:

GPUTexture.createView(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUTextureViewDescriptor`	✘	✔	作成する `GPUTextureView` の説明。

戻り値: 型は GPUTextureView の view。

Content timeline の手順:

? Validate texture format required features を descriptor.format および this.[[device]] で実行。
? Validate swizzle string を descriptor.swizzle で実行。
view を ! create a new WebGPU object(this, GPUTextureView, descriptor) に設定する。
Device timeline の this で initialization steps を実行。
view を返す。

Device timeline の initialization steps:

descriptor を resolving GPUTextureViewDescriptor defaults の結果に設定（this, descriptor を使う）。
以下のいずれかの条件を満たさない場合 generate a validation error を発生させ、invalidate view を実行し、リターン。
- this が valid to use with this.[[device]] であること。
- descriptor.aspect が this.format に含まれていること。
- もし descriptor.aspect が "all" の場合:
  - descriptor.format が this.format または this.[[viewFormats]] のいずれかと等しいこと。
  それ以外の場合:
  - descriptor.format が resolving GPUTextureAspect( this.format, descriptor.aspect) に等しいこと。
- descriptor.swizzle が "rgba" でない場合、 "texture-component-swizzle" が enabled for this.[[device]] であること。
- descriptor.usage が this.usage のサブセットであること。
- もし descriptor.usage に RENDER_ATTACHMENT ビットが含まれる場合:
  - descriptor.format が renderable format であること。
- もし descriptor.usage に STORAGE_BINDING ビットが含まれる場合:
  - descriptor.format が § 26.1.1 Plain color formats のテーブルで STORAGE_BINDING の capability がどれか1つでもあること。
- descriptor.mipLevelCount は > 0 であること。
- descriptor.baseMipLevel + descriptor.mipLevelCount が this.mipLevelCount 以下であること。
- descriptor.arrayLayerCount は > 0 であること。
- descriptor.baseArrayLayer + descriptor.arrayLayerCount が array layer count of this 以下であること。
- もし this.sampleCount > 1 の場合、 descriptor.dimension は "2d" であること。
- もし descriptor.dimension が以下のいずれかの場合:
  "1d"
  this.dimension は "1d" であること。
  
  descriptor.arrayLayerCount は 1 であること。
  "2d"
  this.dimension は "2d" であること。
  
  descriptor.arrayLayerCount は 1 であること。
  "2d-array"
  this.dimension は "2d" であること。
  "cube"
  this.dimension は "2d" であること。
  
  descriptor.arrayLayerCount は 6 であること。
  
  this.width は this.height と等しいこと。
  "cube-array"
  this.dimension は "2d" であること。
  
  descriptor.arrayLayerCount が 6 の倍数であること。
  
  this.width は this.height と等しいこと。
  
  [[device]].[[features]] は必ず "core-features-and-limits" "core-features-and-limits" を含まなければなりません。
  "3d"
  this.dimension は "3d" であること。
  
  descriptor.arrayLayerCount は 1 であること。
view を新たな GPUTextureView オブジェクトとして作成する。
view.[[texture]] を this に設定する。
view.[[descriptor]] を descriptor に設定する。
もし descriptor.usage が RENDER_ATTACHMENT を含む場合:
1. renderExtent を compute render extent([this.width, this.height, this.depthOrArrayLayers], descriptor.baseMipLevel) で設定。
2. view.[[renderExtent]] を renderExtent に設定する。

GPUTextureViewDescriptor のデフォルト解決を GPUTextureView texture と GPUTextureViewDescriptor descriptor に対して行うとき、次の device timeline の手順を実行します：

resolved を descriptor のコピーとして作成する。
もし resolved.format が提供されていない場合：
1. format を resolving GPUTextureAspect( format, descriptor.aspect) の結果とする。
2. もし format が null の場合：
  - resolved.format に texture.format を設定する。
  それ以外の場合：
  - resolved.format に format を設定する。
もし resolved.mipLevelCount が提供されていない場合、 resolved.mipLevelCount に texture.mipLevelCount − resolved.baseMipLevel を設定する。
もし resolved.dimension が提供されていないかつ texture.dimension が以下の場合：
"1d"

resolved.dimension に "1d" を設定する。

"2d"
array layer count が texture で 1 の場合：
- resolved.dimension に "2d" を設定する。
それ以外の場合：
- resolved.dimension に "2d-array" を設定する。
"3d"

resolved.dimension に "3d" を設定する。
もし resolved.arrayLayerCount が提供されていないかつ resolved.dimension が以下の場合：

"1d", "2d", または "3d"

resolved.arrayLayerCount に 1 を設定する。

"cube"

resolved.arrayLayerCount に 6 を設定する。

"2d-array" または "cube-array"

resolved.arrayLayerCount に array layer count of texture − resolved.baseArrayLayer を設定する。
もし resolved.usage が 0 なら、 resolved.usage に texture.usage を設定する。
resolved を返す。

array layer count の決定を GPUTexture texture に対して行うには、次の手順を実行します：

もし texture.dimension が以下の場合：

"1d" または "3d"

1 を返す。

"2d"

texture.depthOrArrayLayers を返す。

スウィズル文字列の検証を DOMString swizzle に対して行うには、以下の content timeline の手順を実行する：

swizzle が [ECMAScript] の正規表現 ^[rgba01]{4}$ に一致しない場合：
1. TypeError を投げる。

6.3. テクスチャフォーマット

フォーマット名は、コンポーネントの順序、各コンポーネントのビット数、コンポーネントのデータ型を指定します。

r, g, b, a = 赤、緑、青、アルファ
unorm = 符号なし正規化
snorm = 符号付き正規化
uint = 符号なし整数
sint = 符号付き整数
float = 浮動小数点

フォーマットに-srgbサフィックスが付いている場合、シェーダ内で色値の読み書き時にsRGB変換（ガンマ⇔リニア）が適用されます。圧縮テクスチャフォーマットはfeaturesによって提供されます。命名規則は本規約に従い、テクスチャ名をプレフィックスとして使用します（例：etc2-rgba8unorm）。

テクセルブロックは、画素ベースのGPUTextureFormatテクスチャでは単一のアドレス可能な要素、ブロックベース圧縮GPUTextureFormatテクスチャでは単一の圧縮ブロックです。

テクセルブロック幅およびテクセルブロック高さは、1つのテクセルブロックの寸法を指定します。

画素ベースのGPUTextureFormatの場合、テクセルブロック幅・テクセルブロック高さは常に1です。
ブロックベース圧縮GPUTextureFormatの場合、テクセルブロック幅は1つのテクセルブロックの各行のテクセル数、テクセルブロック高さは1つのテクセルブロックのテクセル行数です。全フォーマットの値は§ 26.1 テクスチャフォーマットの機能参照。

テクセルブロックコピーフットプリントは、あるGPUTextureFormatのアスペクトについて、テクセルコピー時に1つのテクセルブロックが占有するバイト数です（該当する場合）。

注: テクセルブロックメモリコストは、GPUTextureFormatの1つのテクセルブロックを格納するのに必要なバイト数です。全てのフォーマットで厳密には定義されていません。 この値は参考情報であり、規定値ではありません。

enum GPUTextureFormat {
    // 8-bit formats
    "r8unorm",
    "r8snorm",
    "r8uint",
    "r8sint",

    // 16-bit formats
    "r16unorm",
    "r16snorm",
    "r16uint",
    "r16sint",
    "r16float",
    "rg8unorm",
    "rg8snorm",
    "rg8uint",
    "rg8sint",

    // 32-bit formats
    "r32uint",
    "r32sint",
    "r32float",
    "rg16unorm",
    "rg16snorm",
    "rg16uint",
    "rg16sint",
    "rg16float",
    "rgba8unorm",
    "rgba8unorm-srgb",
    "rgba8snorm",
    "rgba8uint",
    "rgba8sint",
    "bgra8unorm",
    "bgra8unorm-srgb",
    // Packed 32-bit formats
    "rgb9e5ufloat",
    "rgb10a2uint",
    "rgb10a2unorm",
    "rg11b10ufloat",

    // 64-bit formats
    "rg32uint",
    "rg32sint",
    "rg32float",
    "rgba16unorm",
    "rgba16snorm",
    "rgba16uint",
    "rgba16sint",
    "rgba16float",

    // 128-bit formats
    "rgba32uint",
    "rgba32sint",
    "rgba32float",

    // Depth/stencil formats
    "stencil8",
    "depth16unorm",
    "depth24plus",
    "depth24plus-stencil8",
    "depth32float",

    // "depth32float-stencil8" feature
    "depth32float-stencil8",

    // BC compressed formats usable if "texture-compression-bc" is both
    // supported by the device/user agent and enabled in requestDevice.
    "bc1-rgba-unorm",
    "bc1-rgba-unorm-srgb",
    "bc2-rgba-unorm",
    "bc2-rgba-unorm-srgb",
    "bc3-rgba-unorm",
    "bc3-rgba-unorm-srgb",
    "bc4-r-unorm",
    "bc4-r-snorm",
    "bc5-rg-unorm",
    "bc5-rg-snorm",
    "bc6h-rgb-ufloat",
    "bc6h-rgb-float",
    "bc7-rgba-unorm",
    "bc7-rgba-unorm-srgb",

    // ETC2 compressed formats usable if "texture-compression-etc2" is both
    // supported by the device/user agent and enabled in requestDevice.
    "etc2-rgb8unorm",
    "etc2-rgb8unorm-srgb",
    "etc2-rgb8a1unorm",
    "etc2-rgb8a1unorm-srgb",
    "etc2-rgba8unorm",
    "etc2-rgba8unorm-srgb",
    "eac-r11unorm",
    "eac-r11snorm",
    "eac-rg11unorm",
    "eac-rg11snorm",

    // ASTC compressed formats usable if "texture-compression-astc" is both
    // supported by the device/user agent and enabled in requestDevice.
    "astc-4x4-unorm",
    "astc-4x4-unorm-srgb",
    "astc-5x4-unorm",
    "astc-5x4-unorm-srgb",
    "astc-5x5-unorm",
    "astc-5x5-unorm-srgb",
    "astc-6x5-unorm",
    "astc-6x5-unorm-srgb",
    "astc-6x6-unorm",
    "astc-6x6-unorm-srgb",
    "astc-8x5-unorm",
    "astc-8x5-unorm-srgb",
    "astc-8x6-unorm",
    "astc-8x6-unorm-srgb",
    "astc-8x8-unorm",
    "astc-8x8-unorm-srgb",
    "astc-10x5-unorm",
    "astc-10x5-unorm-srgb",
    "astc-10x6-unorm",
    "astc-10x6-unorm-srgb",
    "astc-10x8-unorm",
    "astc-10x8-unorm-srgb",
    "astc-10x10-unorm",
    "astc-10x10-unorm-srgb",
    "astc-12x10-unorm",
    "astc-12x10-unorm-srgb",
    "astc-12x12-unorm",
    "astc-12x12-unorm-srgb",
};

"depth24plus" および"depth24plus-stencil8" フォーマットのdepth成分は、24ビットdepth値または"depth32float" 値として実装される場合があります。

stencil8 フォーマットは実際の"stencil8"、または"depth24stencil8"（depthアスペクトは非表示・アクセス不可）として実装される場合があります。

注:

depth32floatチャンネルの精度はすべての値において24ビットdepthチャンネルより高いですが、表現可能な値集合は完全なスーパーセットではないことに注意してください。

24ビットdepthの場合、1ULPは1 / (2²⁴ − 1)で一定です。
depth32floatの場合、1ULPは最大1 / (2²⁴)で値によって異なります。

フォーマットがレンダー可能であるとは、カラー・レンダー可能フォーマットまたは深度・ステンシルフォーマットの場合です。 § 26.1.1 プレーンカラーフォーマットでRENDER_ATTACHMENT 機能を持つものはカラー・レンダー可能フォーマットです。他はカラー・レンダー可能フォーマットではありません。深度・ステンシルフォーマットはすべてレンダー可能です。

レンダー可能フォーマットは、レンダーパイプラインのブレンディングで使用可能な場合ブレンド可能にもなります。 § 26.1 テクスチャフォーマットの機能参照。

フォーマットがフィルタ可能であるとは、 GPUTextureSampleType "float" （"unfilterable-float"のみでない）をサポートし、 "filtering" GPUSamplerで利用可能な場合です。 § 26.1 テクスチャフォーマットの機能参照。

GPUTextureAspectの解決(format, aspect)

引数:

GPUTextureFormat format
GPUTextureAspect aspect

戻り値: GPUTextureFormat またはnull

aspectが：

"all"

formatを返す。

"depth-only"
"stencil-only"

formatがdepth-stencil-formatの場合： formatのアスペクト専用フォーマット（§ 26.1.2 深度ステンシルフォーマット）または aspectが存在しなければnullを返す。
nullを返す。

一部のテクスチャフォーマットの使用にはGPUDeviceでfeatureを有効化する必要があります。新フォーマットは仕様に追加される場合があるため、enum値が実装で未知な場合もあります。実装間の挙動を揃えるため、featureが有効でない場合にフォーマットを使おうとすると例外が投げられます（未対応フォーマット時と同じ挙動）。

§ 26.1 テクスチャフォーマットの機能で、どのGPUTextureFormatがfeature必須か確認できます。

To テクスチャフォーマットの必要な機能を検証するを GPUTextureFormat format に対して
論理 device device を用いて、以下の content timeline の手順を実行する：

formatがfeature必須で、device.[[features]] がfeatureを含まない場合：
1. TypeErrorを投げる。

6.4. `GPUExternalTexture`

GPUExternalTexture は外部動画フレームをラップするサンプル可能な2Dテクスチャです。不変のスナップショットであり、その内容はWebGPU内外（動画フレームの進行など）で変化しません。

GPUExternalTexture は externalTexture バインドグループレイアウトエントリメンバーでバインド可能です。このメンバーは複数のバインディングスロットを使用します（詳細はそちら参照）。

注:

GPUExternalTexture はインポート元のコピーなしで実装できる場合もありますが、実装依存です。基盤表現の所有権は排他または他オーナー（動画デコーダ等）との共有の場合もあり、アプリケーションからは不可視です。

外部テクスチャの基盤表現は（正確なサンプリング挙動以外）観測不可ですが、一般的には次が含まれます：

最大3個の2Dプレーン（例：RGBA、Y+UV、Y+U+V）
座標変換用メタデータ（クロップ・回転）
指定の出力色空間への変換メタデータ（行列、ガンマ、3D LUT）

実装内部の構成は時期・システム・UA・メディアソース・同一動画内フレーム間でも一貫しない場合があります。多様な表現に対応するため、各外部テクスチャで以下を保守的にバインディングします：

最大3プレーン用サンプルテクスチャバインディング
3D LUT用サンプルテクスチャバインディング
3D LUT用サンプラーバインディング
メタデータ用ユニフォームバッファバインディング

[Exposed=(Window, Worker), SecureContext]
interface GPUExternalTexture {
};
GPUExternalTexture includes GPUObjectBase;

GPUExternalTexture には以下の不変プロパティがあります：

[[descriptor]], 型 GPUExternalTextureDescriptor, 読み取り専用: このテクスチャ作成時のディスクリプタ。

GPUExternalTexture には以下の不変プロパティがあります：

[[expired]], 型boolean、初期値false

オブジェクトが期限切れ（利用不可）かどうか。

注: [[destroyed]]スロットと似ているが、こちらはtrueからfalseに戻る場合もある。

6.4.1. 外部テクスチャのインポート

外部テクスチャは外部動画オブジェクトからimportExternalTexture() を用いて作成します。

HTMLVideoElement から作成された外部テクスチャは、他のリソースのように手動やガベージコレクションではなく、インポート後にタスク内で自動的に期限切れ（破棄）となります。外部テクスチャが期限切れになると、その[[expired]] スロットがtrueに変わります。

VideoFrame から作成された外部テクスチャは、元のVideoFrame がclose（明示的にclose()呼び出し、または他の手段）された時のみ期限切れ（破棄）となります。

注:decode() でも述べられている通り、著者はデコーダの停止を防ぐため、出力VideoFrame にclose() を推奨します。インポート後のVideoFrame がcloseされずに破棄された場合、インポート済みGPUExternalTexture オブジェクトが生きている限り、VideoFrameも生き続けます。両方とも破棄されるまでVideoFrameはガベージコレクトされません。ガベージコレクションは予測できないため、これでもビデオデコーダが停止する可能性があります。

GPUExternalTexture が期限切れになると、importExternalTexture() を再度呼び出す必要があります。ただし、ユーザーエージェントは期限切れを解除し、同じGPUExternalTexture を返す場合があります（新しいものを生成しない）。これは、アプリケーションの実行が動画フレームレート（例：requestVideoFrameCallback()使用）と一致しない限り、一般的に起こります。同じオブジェクトが再び返された場合、比較は等しくなり、以前のオブジェクトを参照しているGPUBindGroupやGPURenderBundleなどは引き続き使用可能です。

dictionary GPUExternalTextureDescriptor
         : GPUObjectDescriptorBase {
    required (HTMLVideoElement or VideoFrame) source;
    PredefinedColorSpace colorSpace = "srgb";
};

GPUExternalTextureDescriptor 辞書には以下のメンバーがあります：

source, 型 (HTMLVideoElement or VideoFrame): 外部テクスチャをインポートする動画ソース。ソースサイズは外部ソース寸法表に従って決定されます。
colorSpace, 型 PredefinedColorSpace（デフォルト値"srgb"）: source の画像内容を読み込み時に変換する色空間。

importExternalTexture(descriptor)

指定した画像ソースをラップしたGPUExternalTextureを作成します。

呼び出し元: GPUDevice this.

引数:

GPUDevice.importExternalTexture(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUExternalTextureDescriptor`	✘	✘	外部画像ソースオブジェクト（および作成オプション）を指定。

戻り値: GPUExternalTexture

sourceをdescriptor.sourceとする。
現在のsource画像内容が、同じdescriptor（label除く）で以前に呼び出された importExternalTexture() と同じであり、UAが再利用を選択した場合：
1. previousResultを以前返されたGPUExternalTextureとする。
2. previousResult.[[expired]] をfalseにし、基盤リソースの所有権を更新する。
3. resultをpreviousResultとする。
注: これにより、アプリケーションが重複インポートを検出し、依存オブジェクト（GPUBindGroupなど）を再生成せずに済みます。実装は、1つのフレームが複数GPUExternalTextureでラップされるケースにも対応する必要があります（インポートメタデータcolorSpaceは同一フレームでも変更可能）。

それ以外の場合：
1. sourceがorigin-cleanでない場合、 SecurityErrorを投げてreturn。
2. usabilityを? 画像引数の利用性の確認(source)とする。
3. usabilityがgoodでない場合：
  1. 検証エラー生成。
  2. 無効化された GPUExternalTextureを返す。
4. dataを、現在のsource画像内容をdescriptor.colorSpace へ非プリマルチアルファで変換した結果とする。
  
  この変換で[0, 1]範囲外の値になる場合があります。クランプが必要ならサンプリング後に行えます。
  
  注: コピーのように記述されていますが、実際は読み取り専用の基盤データと変換用メタデータへの参照として実装可能です。
5. resultをdataをラップした新しいGPUExternalTextureオブジェクトとする。
sourceがHTMLVideoElementの場合、自動期限切れタスクをキュー（device this、次の手順）：
1. result.[[expired]] をtrueにし、基盤リソースの所有権を解放する。
注: HTMLVideoElement はテクスチャをサンプリングする同じタスクでインポートすること（通常requestVideoFrameCallbackやrequestAnimationFrame()を使う）。そうしないと、アプリケーションが使い終わる前にこれらの手順でテクスチャが破棄される可能性があります。
sourceがVideoFrameの場合、 sourceがcloseされた時、次の手順を実行：
1. result.[[expired]] をtrueにする。
result.label にdescriptor.labelを設定。
resultを返す。

ページアニメーションフレームレートでvideo要素外部テクスチャを用いて描画する例：

const videoElement = document.createElement('video');
// ... videoElementのセットアップ、ready待ち ...

function frame() {
    requestAnimationFrame(frame);

    // 毎アニメーションフレームで必ず再インポート。importは期限切れの可能性が高い。
    // ブラウザは過去フレームをキャッシュ・再利用する場合があり、その際
    // 同じGPUExternalTextureオブジェクトを再び返すことがある。
    // この場合、古いバインドグループも有効。
    const externalTexture = gpuDevice.importExternalTexture({
        source: videoElement
    });

    // ... externalTextureで描画 ...
}
requestAnimationFrame(frame);

requestVideoFrameCallbackが使える場合、動画のフレームレートでvideo要素外部テクスチャを用いて描画する例：

const videoElement = document.createElement('video');
// ... videoElementのセットアップ ...

function frame() {
    videoElement.requestVideoFrameCallback(frame);

    // フレーム進行が確実なため、毎回再インポート
    const externalTexture = gpuDevice.importExternalTexture({
        source: videoElement
    });

    // ... externalTextureで描画 ...
}
videoElement.requestVideoFrameCallback(frame);

6.5. 外部テクスチャバインディングのサンプリング

externalTexture バインディングポイントは、GPUExternalTexture オブジェクト（動画など動的画像ソース）をバインドできます。また、GPUTexture やGPUTextureViewにも対応しています。

注: GPUTexture やGPUTextureView をexternalTextureバインディングにバインドした場合、 RGBA単一プレーン・クロップ/回転/色変換なしのGPUExternalTexture と同じ扱いになります。

外部テクスチャはWGSLではtexture_externalで表され、textureLoadやtextureSampleBaseClampToEdgeで読み取れます。

textureSampleBaseClampToEdgeに渡すsamplerは基盤テクスチャのサンプリングに使われます。

バインディングリソース型がGPUExternalTextureの場合、結果はcolorSpaceで指定された色空間となります。実装依存で、サンプラー（およびフィルタリング）が基底値から指定色空間への変換の前後どちらで適用されるかは異なります。

注: 内部表現がRGBAプレーンの場合、サンプリングは通常の2Dテクスチャと同様です。複数プレーン（例：Y+UV）の場合、サンプラーは各基盤テクスチャを個別にサンプリングし、YUV→指定色空間変換前に適用されます。

7. サンプラー

7.1. `GPUSampler`

GPUSampler はシェーダでテクスチャリソースデータを解釈するための変換・フィルタ情報を符号化します。

GPUSampler はcreateSampler() で作成されます。

[Exposed=(Window, Worker), SecureContext]
interface GPUSampler {
};
GPUSampler includes GPUObjectBase;

GPUSampler には以下の不変プロパティがあります：

[[descriptor]], 型 GPUSamplerDescriptor、読み取り専用: このGPUSampler の作成時に使用したGPUSamplerDescriptor。
[[isComparison]], 型 boolean、読み取り専用: このGPUSampler が比較サンプラーとして利用されるかどうか。
[[isFiltering]], 型 boolean、読み取り専用: このGPUSampler がテクスチャの複数サンプルを重み付けするかどうか。

7.1.1. `GPUSamplerDescriptor`

GPUSamplerDescriptor はGPUSampler の作成時オプションを指定します。

dictionary GPUSamplerDescriptor
         : GPUObjectDescriptorBase {
    GPUAddressMode addressModeU = "clamp-to-edge";
    GPUAddressMode addressModeV = "clamp-to-edge";
    GPUAddressMode addressModeW = "clamp-to-edge";
    GPUFilterMode magFilter = "nearest";
    GPUFilterMode minFilter = "nearest";
    GPUMipmapFilterMode mipmapFilter = "nearest";
    float lodMinClamp = 0;
    float lodMaxClamp = 32;
    GPUCompareFunction compare;
    [Clamp] unsigned short maxAnisotropy = 1;
};

addressModeU, 型 GPUAddressMode（デフォルト値"clamp-to-edge"）

addressModeV, 型 GPUAddressMode（デフォルト値"clamp-to-edge"）

addressModeW, 型 GPUAddressMode（デフォルト値"clamp-to-edge"）

テクスチャの幅・高さ・深度座標それぞれのアドレスモード指定。

magFilter, 型 GPUFilterMode（デフォルト値"nearest"）

サンプリング領域が1テクセル以下のときのサンプリング動作。

minFilter, 型 GPUFilterMode（デフォルト値"nearest"）

サンプリング領域が1テクセルより大きいときのサンプリング動作。

mipmapFilter, 型 GPUMipmapFilterMode（デフォルト値"nearest"）

ミップマップレベル間のサンプリング動作。

lodMinClamp, 型 float（デフォルト値0）

lodMaxClamp, 型 float（デフォルト値32）

テクスチャサンプリング時に内部的に使われる最小・最大レベルオブディテール。

compare, 型 GPUCompareFunction

指定した場合、サンプラーは指定GPUCompareFunctionで比較サンプラーになります。

注: 比較サンプラーはフィルタリング使用可能ですが、結果は実装依存・通常のフィルタリングルールと異なる場合があります。

maxAnisotropy, 型 unsigned short（デフォルト値1）

サンプラーで使われる最大異方性値クランプ指定。maxAnisotropy > 1かつ実装が対応している場合、異方性フィルタリング有効。

異方性フィルタリングは斜め視点テクスチャの画質向上。maxAnisotropy 値が高いほどフィルタリング時の最大異方性比。

注:

多くの実装はmaxAnisotropy を1～16の範囲でサポート。指定値はプラットフォーム最大値にクランプされます。

フィルタリングの具体的挙動は実装依存。

レベルオブディテール（LOD）はテクスチャサンプリング時に選択されるミップレベルを示します。シェーダのtextureSampleLevel等で明示指定、またはテクスチャ座標の微分から暗黙決定されます。

注: 暗黙LOD計算例はScale Factor Operation, LOD Operation and Image Level Selection（Vulkan 1.3仕様）参照。

GPUAddressMode はサンプリングテクセルがテクスチャ範囲外のときのサンプラー動作指定。

enum GPUAddressMode {
    "clamp-to-edge",
    "repeat",
    "mirror-repeat",
};

"clamp-to-edge": テクスチャ座標は0.0～1.0の範囲にクランプ。
"repeat": テクスチャ座標はテクスチャの反対側へラップ。
"mirror-repeat": テクスチャ座標は反対側へラップしつつ、座標の整数部が奇数のときテクスチャを反転。

GPUFilterMode およびGPUMipmapFilterMode はサンプリング領域が1テクセルちょうどでない場合のサンプラー動作指定。

注: 各種フィルターモードでどのテクセルがサンプルされるかの例はTexel Filtering（Vulkan 1.3仕様）参照。

enum GPUFilterMode {
    "nearest",
    "linear",
};

enum GPUMipmapFilterMode {
    "nearest",
    "linear",
};

"nearest": テクスチャ座標に最も近いテクセルの値を返す。
"linear": 各次元で2テクセル選び、その値を線形補間して返す。

GPUCompareFunction は比較サンプラーの挙動指定。シェーダで比較サンプラー使用時、depth_refと取得テクセル値を比較し、その判定結果（合格1.0f／不合格0.0f）を生成。

比較後、テクスチャフィルタリング有効ならフィルタリングが行われ、判定結果同士が混合され[0, 1]範囲の値となる。フィルタリングは通常通り動作すべきだが、精度低下や混合なしの可能性もある。

enum GPUCompareFunction {
    "never",
    "less",
    "equal",
    "less-equal",
    "greater",
    "not-equal",
    "greater-equal",
    "always",
};

"never": 比較判定は常に不合格。
"less": 与えられた値がサンプル値より小さい場合に合格。
"equal": 与えられた値がサンプル値と等しい場合に合格。
"less-equal": 与えられた値がサンプル値以下の場合に合格。
"greater": 与えられた値がサンプル値より大きい場合に合格。
"not-equal": 与えられた値がサンプル値と異なる場合に合格。
"greater-equal": 与えられた値がサンプル値以上の場合に合格。
"always": 比較判定は常に合格。

7.1.2. サンプラーの作成

createSampler(descriptor)

GPUSamplerを作成します。

呼び出し元: GPUDevice this.

引数:

GPUDevice.createSampler(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUSamplerDescriptor`	✘	✔	作成する`GPUSampler`の説明。

戻り値: GPUSampler

sを! 新しいWebGPUオブジェクトの生成(this, GPUSampler, descriptor)とする。
thisのデバイスタイムラインでinitialization stepsを発行。
sを返す。

デバイスタイムライン initialization steps:

以下の条件が満たされない場合検証エラー生成、sの無効化、return。
- thisが失われていないこと。
- descriptor.lodMinClamp ≥ 0。
- descriptor.lodMaxClamp ≥ descriptor.lodMinClamp。
- descriptor.maxAnisotropy ≥ 1。
  
  注: 多くの実装はmaxAnisotropy を1～16の範囲でサポート。指定値はプラットフォーム最大値にクランプされます。
- descriptor.maxAnisotropy > 1の場合：
  - descriptor.magFilter, descriptor.minFilter, descriptor.mipmapFilter がすべて "linear"であること。
s.[[descriptor]] にdescriptorを設定。
s.[[isComparison]] を、s.[[descriptor]]のcompare 属性がnullまたは未定義ならfalse、それ以外ならtrueに設定。
s.[[isFiltering]] を、minFilter、 magFilter、 mipmapFilter のいずれも "linear"でなければfalse、いずれかが"linear"ならtrueに設定。

テクスチャ座標繰り返し＆三線形フィルタのGPUSampler生成例：

const sampler = gpuDevice.createSampler({
    addressModeU: 'repeat',
    addressModeV: 'repeat',
    magFilter: 'linear',
    minFilter: 'linear',
    mipmapFilter: 'linear',
});

8. リソースバインディング

8.1. `GPUBindGroupLayout`

GPUBindGroupLayout は、GPUBindGroup でバインドされたリソース群と、シェーダステージでのアクセス性とのインターフェースを定義します。

[Exposed=(Window, Worker), SecureContext]
interface GPUBindGroupLayout {
};
GPUBindGroupLayout includes GPUObjectBase;

GPUBindGroupLayout には以下の不変プロパティがあります：

[[descriptor]], 型 GPUBindGroupLayoutDescriptor、読み取り専用

8.1.1. バインドグループレイアウトの作成

GPUBindGroupLayout はGPUDevice.createBindGroupLayout()で作成します。

dictionary GPUBindGroupLayoutDescriptor
         : GPUObjectDescriptorBase {
    required sequence<GPUBindGroupLayoutEntry> entries;
};

GPUBindGroupLayoutDescriptor 辞書には以下のメンバーがあります：

entries, 型 sequence<GPUBindGroupLayoutEntry>: バインドグループのシェーダリソースバインディングを記述するエントリのリスト。

GPUBindGroupLayoutEntry は、GPUBindGroupLayoutに含める1つのシェーダリソースバインディングを記述します。

dictionary GPUBindGroupLayoutEntry {
    required GPUIndex32 binding;
    required GPUShaderStageFlags visibility;

    GPUBufferBindingLayout buffer;
    GPUSamplerBindingLayout sampler;
    GPUTextureBindingLayout texture;
    GPUStorageTextureBindingLayout storageTexture;
    GPUExternalTextureBindingLayout externalTexture;
};

GPUBindGroupLayoutEntry 辞書には以下のメンバーがあります：

binding, 型 GPUIndex32

リソースバインディングを一意に識別するためのIDです。これは GPUBindGroupLayout 内のリソースに対応し、 GPUBindGroupEntry.binding や @binding 属性（GPUShaderModule 内）と対応します。

visibility, 型 GPUShaderStageFlags

GPUShaderStage のメンバーをビットセットで指定します。各ビットがセットされていると、そのGPUBindGroupLayoutEntry のリソースが対応するシェーダーステージからアクセス可能であることを意味します。

buffer, 型 GPUBufferBindingLayout

sampler, 型 GPUSamplerBindingLayout

texture, 型 GPUTextureBindingLayout

storageTexture, 型 GPUStorageTextureBindingLayout

externalTexture, 型 GPUExternalTextureBindingLayout

これらのメンバーのうちちょうど1つだけを設定し、バインディングタイプを示します。メンバーの内容はその型固有のオプションを指定します。

対応するリソースが createBindGroup() で設定される場合、このバインディングには対応するバインディングリソース型が必要です。

typedef [EnforceRange] unsigned long GPUShaderStageFlags;
[Exposed=(Window, Worker), SecureContext]
namespace GPUShaderStage {
    const GPUFlagsConstant VERTEX   = 0x1;
    const GPUFlagsConstant FRAGMENT = 0x2;
    const GPUFlagsConstant COMPUTE  = 0x4;
};

GPUShaderStage には以下のフラグが含まれ、これにより該当GPUBindGroupEntry がこのGPUBindGroupLayoutEntry に対してどのシェーダーステージから可視かを示します：

VERTEX: バインドグループエントリは頂点シェーダーからアクセス可能。
FRAGMENT: バインドグループエントリはフラグメントシェーダーからアクセス可能。
COMPUTE: バインドグループエントリは計算シェーダーからアクセス可能。

GPUBindGroupLayoutEntry の binding メンバーは、どの GPUBindGroupLayoutEntry のメンバーが定義されているかによって決定されます： buffer、 sampler、 texture、 storageTexture、または externalTexture です。いずれか一つのみが GPUBindGroupLayoutEntry ごとに定義できます。各メンバーは対応する GPUBindingResource 型を持ち、各バインディングタイプは本表で示す内部使用方法と関連付けられています。

バインディングメンバー	リソース型	バインディング型	バインディング用途
`buffer`	`GPUBufferBinding` （または `GPUBuffer` 略記として）	`"uniform"`	constant
		`"storage"`	storage
		`"read-only-storage"`	storage-read
`sampler`	`GPUSampler`	`"filtering"`	constant
		`"non-filtering"`
		`"comparison"`
`texture`	`GPUTextureView` （または `GPUTexture` 略記として）	`"float"`	constant
		`"unfilterable-float"`
		`"depth"`
		`"sint"`
		`"uint"`
`storageTexture`	`GPUTextureView` （または `GPUTexture` 略記として）	`"write-only"`	storage
		`"read-write"`	storage
		`"read-only"`	storage-read
`externalTexture`	`GPUExternalTexture` または `GPUTextureView` （または `GPUTexture` 略記として）		constant

list型のGPUBindGroupLayoutEntry 値entriesがバインディングスロット制限超過となるのは、supported limitslimitsにおいて、制限値を超えてスロット数が使用された場合です。各エントリは複数の制限に対して複数スロットを使用する場合があります。

デバイスタイムライン手順：

entries内の各entryについて、次の場合：

entry.buffer?.type が"uniform" かつ entry.buffer?.hasDynamicOffset がtrueの場合

maxDynamicUniformBuffersPerPipelineLayout スロットを1個使用したとみなす。

entry.buffer?.type が"storage" かつ entry.buffer?.hasDynamicOffset がtrueの場合

maxDynamicStorageBuffersPerPipelineLayout スロットを1個使用したとみなす。
各シェーダーステージstage（ « VERTEX, FRAGMENT, COMPUTE »）について：
1. entries 内の各 entry について、 entry.visibility が stage を含む場合、以下を行う：
  
  entry.buffer?.type が "uniform" の場合
  
  1つの maxUniformBuffersPerShaderStage スロットが使用されたとみなす。
  
  entry.buffer?.type が "storage" または "read-only-storage" の場合
  
  stage が次の場合：
  
  VERTEX
  
  1つの maxStorageBuffersInVertexStage スロットが使用されたとみなす。
  
  FRAGMENT
  
  1つの maxStorageBuffersInFragmentStage スロットが使用されたとみなす。
  
  COMPUTE
  
  1つの maxStorageBuffersPerShaderStage スロットが使用されたとみなす。
  
  entry.sampler が提供されている場合
  
  1つの maxSamplersPerShaderStage スロットが使用されたとみなす。
  
  entry.texture が提供されている場合
  
  1つの maxSampledTexturesPerShaderStage スロットが使用されたとみなす。
  
  entry.storageTexture が提供されている場合
  
  stage が次の場合：
  
  VERTEX
  
  1つの maxStorageTexturesInVertexStage スロットが使用されたとみなす。
  
  FRAGMENT
  
  1つの maxStorageTexturesInFragmentStage スロットが使用されたとみなす。
  
  COMPUTE
  
  1つの maxStorageTexturesPerShaderStage スロットが使用されたとみなす。
  
  entry.externalTexture が提供されている場合
  
  4つの maxSampledTexturesPerShaderStage スロット、 1つの maxSamplersPerShaderStage スロット、および 1つの maxUniformBuffersPerShaderStage スロットが使用されたとみなす。
  
  注: この挙動の説明は GPUExternalTexture を参照してください。

enum GPUBufferBindingType {
    "uniform",
    "storage",
    "read-only-storage",
};

dictionary GPUBufferBindingLayout {
    GPUBufferBindingType type = "uniform";
    boolean hasDynamicOffset = false;
    GPUSize64 minBindingSize = 0;
};

GPUBufferBindingLayout 辞書には以下のメンバーがあります：

type, 型 GPUBufferBindingType（デフォルト値"uniform"）

このバインディングにバインドされるバッファに要求される型を示します。

hasDynamicOffset, 型 boolean（デフォルト値false）

このバインディングが動的オフセットを要求するかどうかを示します。

minBindingSize, 型 GPUSize64（デフォルト値0）

このバインドポイントで使用されるバッファバインディングの最小sizeを示します。

バインディングは常にこのサイズに対してcreateBindGroup()内で検証されます。

この値が0でない場合、パイプライン作成時にさらに、変数の最小バッファバインディングサイズ以上であることが検証されます。

この値が0の場合、パイプライン作成時には無視され、代わりに描画/ディスパッチコマンドがGPUBindGroup内の各バインディングが変数の最小バッファバインディングサイズを満たすか検証します。

注: 実行時検証は、sampleTypeやformatのような他の早期検証項目にも理論上可能ですが、現状ではパイプライン作成時のみ検証されます。ただし実行時検証はコスト・複雑性の増加につながるため、最も利便性に影響するminBindingSizeにのみ導入されています。

enum GPUSamplerBindingType {
    "filtering",
    "non-filtering",
    "comparison",
};

dictionary GPUSamplerBindingLayout {
    GPUSamplerBindingType type = "filtering";
};

GPUSamplerBindingLayout 辞書には以下のメンバーがあります：

type, 型 GPUSamplerBindingType（デフォルト値"filtering"）: このバインディングにバインドされるサンプラーに要求される型を示します。

enum GPUTextureSampleType {
    "float",
    "unfilterable-float",
    "depth",
    "sint",
    "uint",
};

dictionary GPUTextureBindingLayout {
    GPUTextureSampleType sampleType = "float";
    GPUTextureViewDimension viewDimension = "2d";
    boolean multisampled = false;
};

GPUTextureBindingLayout 辞書には以下のメンバーがあります：

sampleType, 型 GPUTextureSampleType（デフォルト値"float"）: このバインディングにバインドされるテクスチャビューに要求される型を示します。
viewDimension, 型 GPUTextureViewDimension（デフォルト値"2d"）: このバインディングにバインドされるテクスチャビューに要求されるdimensionを示します。
multisampled, 型 boolean（デフォルト値false）: このバインディングにバインドされるテクスチャビューがマルチサンプルである必要があるかどうかを示します。

enum GPUStorageTextureAccess {
    "write-only",
    "read-only",
    "read-write",
};

dictionary GPUStorageTextureBindingLayout {
    GPUStorageTextureAccess access = "write-only";
    required GPUTextureFormat format;
    GPUTextureViewDimension viewDimension = "2d";
};

GPUStorageTextureBindingLayout 辞書には以下のメンバーがあります：

access, 型 GPUStorageTextureAccess（デフォルト値"write-only"）: このバインディングのアクセスモード（読み取り・書き込み可能性）を示します。
format, 型 GPUTextureFormat: このバインディングにバインドされるテクスチャビューの要求format。
viewDimension, 型 GPUTextureViewDimension（デフォルト値"2d"）: このバインディングにバインドされるテクスチャビューに要求されるdimensionを示します。

dictionary GPUExternalTextureBindingLayout {
};

GPUBindGroupLayout オブジェクトは以下のデバイスタイムラインプロパティを持ちます：

[[entryMap]]、型は ordered map<GPUSize32, GPUBindGroupLayoutEntry>、読み取り専用: バインディングインデックスを GPUBindGroupLayoutEntry に対応付けるマップです。この GPUBindGroupLayout が記述する内容を表します。
[[dynamicOffsetCount]]、型は GPUSize32、読み取り専用: この GPUBindGroupLayout に含まれる動的オフセットを持つバッファバインディングの数です。
[[exclusivePipeline]]、型は GPUPipelineBase? 、読み取り専用: この GPUBindGroupLayout がデフォルトパイプラインレイアウトの一部として生成された場合、その元となったパイプラインを示します。null でない場合、この GPUBindGroupは指定された GPUPipelineBase でのみ利用できます。

createBindGroupLayout(descriptor)

GPUBindGroupLayout を作成します。

呼び出し元: GPUDevice this。

引数:

GPUDevice.createBindGroupLayout(descriptor) メソッドの引数
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUBindGroupLayoutDescriptor`	✘	✘	作成する `GPUBindGroupLayout` の記述。

戻り値: GPUBindGroupLayout

Content timeline の手順:

各 GPUBindGroupLayoutEntry entry について descriptor.entries 内で繰り返す:
1. もし entry.storageTexture が設定済みであれば:
  1. ? Validate texture format required features を entry.storageTexture.format および this.[[device]] で実行する。
layout を ! create a new WebGPU object(this, GPUBindGroupLayout, descriptor) とする。
this の Device timeline で initialization steps を実施する。
layout を返す。

Device timeline の initialization steps:

下記のいずれか条件が満たされない場合は generate a validation error を発生させ、 invalidate layout を実行しリターンする。
- this が lost であってはならない。
- limits を this.[[device]].[[limits]] とする。
- descriptor 内の各エントリの binding は一意でなければならない。
- descriptor 内の各エントリの binding は limits.maxBindingsPerBindGroup 未満でなければならない。
- descriptor.entries が limits のバインディングスロット上限を超えてはならない。
- 各 GPUBindGroupLayoutEntry entry について descriptor.entries 内で繰り返す:
  - entry.buffer、 entry.sampler、 entry.texture、 entry.storageTexture、 entry.externalTexture のうち、ちょうど1つのみが設定済みでなければならない。
  - entry.visibility は GPUShaderStage で定義されたビットのみを含むこと。
  - もし entry.visibility に VERTEX が含まれている場合:
    - もし entry.buffer が設定済みであれば、 entry.buffer.type は "uniform" または "read-only-storage" でなければならない。
    - もし entry.storageTexture が設定済みであれば、 entry.storageTexture.access は "read-only" でなければならない。
  - もし entry.texture?.multisampled が true であれば:
    - entry.texture.viewDimension は "2d" でなければならない。
    - entry.texture.sampleType は "float" 以外でなければならない。
  - もし entry.storageTexture が設定済みであれば:
    - entry.storageTexture.viewDimension は "cube" または "cube-array" であってはならない。
    - entry.storageTexture.format は § 26.1.1 Plain color formats テーブルにより、指定した entry.storageTexture.access でストレージ用途をサポートできるフォーマットでなければならない。
layout.[[descriptor]] を descriptor に設定する。
layout.[[dynamicOffsetCount]] を descriptor 内の buffer が設定済みかつ buffer.hasDynamicOffset が true であるエントリ数に設定する。
layout.[[exclusivePipeline]] を null に設定する。
各 GPUBindGroupLayoutEntry entry について descriptor.entries 内で繰り返す:
1. entry を layout.[[entryMap]] に entry.binding をキーとして挿入する。

8.1.2. 互換性

2つのGPUBindGroupLayoutオブジェクトaとbは、以下すべての条件が満たされたときのみグループ同等とみなされます。

a.[[exclusivePipeline]] == b.[[exclusivePipeline]]
任意のバインディング番号bindingについて、次のいずれかを満たす：
- a.[[entryMap]] とb.[[entryMap]] の両方に存在しない。
- a.[[entryMap]][binding] == b.[[entryMap]][binding]

バインドグループレイアウトがグループ同等なら、すべての現行標準内容で相互に利用可能です。

8.2. `GPUBindGroup`

GPUBindGroupは、グループ内でまとめてバインドするリソース集合と、それらがシェーダーステージでどのように利用されるかを定義します。

[Exposed=(Window, Worker), SecureContext]
interface GPUBindGroup {
};
GPUBindGroup includes GPUObjectBase;

GPUBindGroupは以下のデバイスタイムラインプロパティを持ちます：

[[layout]], 型 GPUBindGroupLayout、読み取り専用: このGPUBindGroupに関連付けられているGPUBindGroupLayout。
[[entries]], 型 sequence<GPUBindGroupEntry>、読み取り専用: このGPUBindGroupが記述するGPUBindGroupEntryの集合。
[[usedResources]], 型 usage scope、読み取り専用: このバインドグループが使用するバッファ・テクスチャサブリソースの集合。利用される内部用途フラグのリストも関連付けられます。

バウンドバッファ範囲（GPUBindGroup bindGroup、list<GPUBufferDynamicOffset> dynamicOffsets を与えた場合）は次のように算出されます：

result を新しい set<(GPUBindGroupLayoutEntry, GPUBufferBinding)> とする。
dynamicOffsetIndex を 0 にする。
bindGroup.[[entries]] の各 GPUBindGroupEntry bindGroupEntry について、 bindGroupEntry.binding でソートし順に処理する：
1. bindGroupLayoutEntry を bindGroup.[[layout]].[[entryMap]][bindGroupEntry.binding] とする。
2. もし bindGroupLayoutEntry.buffer が設定されていなければ、次へ。
3. bound を get as buffer binding(bindGroupEntry.resource) とする。
4. もし bindGroupLayoutEntry.buffer.hasDynamicOffset なら：
  1. bound.offset に dynamicOffsets[dynamicOffsetIndex] を加算する。
  2. dynamicOffsetIndex を 1 増やす。
5. (bindGroupLayoutEntry, bound) を result に追加する。
result を返す。

8.2.1. バインドグループの作成

GPUBindGroupはGPUDevice.createBindGroup()で作成します。

dictionary GPUBindGroupDescriptor
         : GPUObjectDescriptorBase {
    required GPUBindGroupLayout layout;
    required sequence<GPUBindGroupEntry> entries;
};

GPUBindGroupDescriptor 辞書には以下のメンバーがあります：

layout, 型 GPUBindGroupLayout: このバインドグループのエントリが準拠するGPUBindGroupLayout。
entries, 型 sequence<GPUBindGroupEntry>: layoutで記述される各バインディングに対し、シェーダーで公開するリソースを記述するエントリのリスト。

typedef (GPUSampler or
         GPUTexture or
         GPUTextureView or
         GPUBuffer or
         GPUBufferBinding or
         GPUExternalTexture) GPUBindingResource;

dictionary GPUBindGroupEntry {
    required GPUIndex32 binding;
    required GPUBindingResource resource;
};

GPUBindGroupEntry はGPUBindGroup内でバインドする1つのリソースを記述し、以下のメンバーを持ちます：

binding, 型 GPUIndex32: このGPUBindGroup内でリソースバインディングを一意に識別するID。 GPUBindGroupLayoutEntry.binding および、GPUShaderModuleの@binding属性に対応。
resource, 型 GPUBindingResource: バインドするリソース。GPUSampler、 GPUTexture、 GPUTextureView、 GPUBuffer、 GPUBufferBinding、またはGPUExternalTexture。

GPUBindGroupEntry は以下のデバイスタイムラインプロパティを持ちます：

[[prevalidatedSize]], 型 boolean: このバインディングエントリが作成時にバッファサイズ検証済みかどうか。

dictionary GPUBufferBinding {
    required GPUBuffer buffer;
    GPUSize64 offset = 0;
    GPUSize64 size;
};

GPUBufferBinding はバッファおよびオプションの範囲をリソースとしてバインドするために記述し、以下のメンバーを持ちます：

buffer, 型 GPUBuffer: バインドするGPUBuffer。
offset, 型 GPUSize64（デフォルト値0）: bufferの先頭から、バッファバインディングでシェーダーに公開する範囲の先頭までのバイトオフセット。
size, 型 GPUSize64: バッファバインディングのバイトサイズ。指定されていない場合は、 offsetからbufferの末尾までの範囲。

createBindGroup(descriptor)

GPUBindGroupを作成します。

呼び出し元: GPUDevice this.

引数:

GPUDevice.createBindGroup(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUBindGroupDescriptor`	✘	✘	作成する`GPUBindGroup`の説明。

戻り値: GPUBindGroup

bindGroupを! 新しいWebGPUオブジェクトの生成(this, GPUBindGroup, descriptor)とする。
thisのデバイスタイムラインでinitialization stepsを発行。
bindGroupを返す。

デバイスタイムライン initialization steps:

limitsをthis.[[device]].[[limits]]とする。
以下の条件が満たされない場合検証エラー生成、bindGroupの無効化、return。
- descriptor.layout がthisで有効利用可能であること。
- descriptor.layout のentries数が descriptor.entries数と完全一致すること。
descriptor.entries内の各GPUBindGroupEntrybindingDescriptorについて：
- resourceをbindingDescriptor.resourceとする。
- descriptor.layout.entries内に bindingDescriptor.bindingと等しい GPUBindGroupLayoutEntrylayoutBindingが正確に1つ存在すること。
- 定義されたbinding memberが:
  sampler
  resourceがGPUSamplerである。
  
  resourceがthisで有効利用可能であること。
  
  layoutBinding.sampler.type が:
  
  "filtering"
  
  resource.[[isComparison]] がfalse。
  
  "non-filtering"
  
  resource.[[isFiltering]] がfalseかつresource.[[isComparison]] がfalse。
  
  "comparison"
  
  resource.[[isComparison]] がtrue。
  texture
  resource は GPUTexture または GPUTextureView のいずれかです。
  
  resource は valid to use with this です。
  
  textureView を get as texture view(resource) とします。
  
  texture を textureView.[[texture]] にします。
  
  layoutBinding.texture.viewDimension が textureView の dimension と等しいこと。
  
  layoutBinding.texture.sampleType が compatible であり、 textureView の format と互換です。
  
  textureView.[[descriptor]].usage が TEXTURE_BINDING を含むこと。
  
  もし layoutBinding.texture.multisampled が true なら texture の sampleCount は 1 より大きく、そうでなければ texture の sampleCount は 1 であること。
  
  もし texture.textureBindingViewDimension が undefined でない場合：
  
  Assert this.[[device]].[[features]] が含んでいない "core-features-and-limits"。
  
  texture.textureBindingViewDimension が textureView.dimension と等しいこと。
  storageTexture
  resourceがGPUTexture またはGPUTextureViewである。
  
  resourceがthisで有効利用可能であること。
  
  storageTextureViewをget as texture view(resource)とする。
  
  textureをstorageTextureView.[[texture]]とする。
  
  layoutBinding.storageTexture.viewDimension がstorageTextureViewのdimensionと等しい。
  
  layoutBinding.storageTexture.format がstorageTextureView.[[descriptor]].formatと等しい。
  
  storageTextureView.[[descriptor]].usage がSTORAGE_BINDINGを含む。
  
  storageTextureView.[[descriptor]].mipLevelCount は1であること。
  
  storageTextureView.[[descriptor]].swizzle は "rgba" でなければならない。
  buffer
  resourceがGPUBuffer またはGPUBufferBindingである。
  
  bufferBindingをget as buffer binding(resource)とする。
  
  bufferBinding.buffer がthisで有効利用可能であること。
  
  bufferBinding.offsetと bufferBinding.size で指定されるバインド範囲がバッファ内にありサイズが0でないこと。
  
  effective buffer binding size(bufferBinding) ≥ layoutBinding.buffer.minBindingSize。
  
  layoutBinding.buffer.typeが
  
  "uniform"
  
  bufferBinding.buffer.usage がUNIFORMを含む。
  
  effective buffer binding size(bufferBinding) ≤ limits.maxUniformBufferBindingSize。
  
  bufferBinding.offset がlimits.minUniformBufferOffsetAlignmentの倍数。
  
  "storage" または "read-only-storage"
  
  bufferBinding.buffer.usage がSTORAGEを含む。
  
  effective buffer binding size(bufferBinding) ≤ limits.maxStorageBufferBindingSize。
  
  effective buffer binding size(bufferBinding)が4の倍数。
  
  bufferBinding.offset がlimits.minStorageBufferOffsetAlignmentの倍数。
  externalTexture
  resourceがGPUExternalTexture、 GPUTexture、またはGPUTextureViewである。
  
  resourceがthisで有効利用可能であること。
  
  resourceが:
  
  GPUTexture またはGPUTextureView
  
  viewをget as texture view(resource)とする。
  
  view.[[descriptor]].usage がTEXTURE_BINDINGを含む。
  
  view.[[descriptor]].dimension が"2d"であること。
  
  view.[[descriptor]].mipLevelCount が1であること。
  
  view.[[descriptor]].format が"rgba8unorm"、 "bgra8unorm"、または "rgba16float"であること。
  
  view.[[texture]].sampleCount が1であること。
- もし this.[[device]].[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  - 各 GPUBindGroupEntry bindGroupEntry について descriptor.entries 内で繰り返す：
    
    もし bindGroupEntry.resource が GPUTextureView の場合：
    
    textureView を bindGroupEntry.resource にする。
    
    descriptor を textureView.[[descriptor]] にする。
    
    descriptor.baseArrayLayer は 0 でなければならない。
    
    descriptor.arrayLayerCount は textureView.[[texture]].depthOrArrayLayers と等しくなければならない。
bindGroup.[[layout]] を descriptor.layout に設定する。
bindGroup.[[entries]] を descriptor.entries に設定する。
bindGroup.[[usedResources]] を {} に設定する。
各 GPUBindGroupEntry bindingDescriptor について descriptor.entries 内で繰り返す：
1. internalUsage を layoutBinding のバインディング使用法とする。
2. resource が参照する全てのサブリソースは [[usedResources]] に internalUsage として追加される。
3. bindingDescriptor.[[prevalidatedSize]] を以下に設定する。バインディングメンバーが layoutBinding で buffer であり、かつ layoutBinding.buffer.minBindingSize が 0 の場合は false、それ以外は true。

テクスチャビューとして取得(resource)

引数:

GPUBindingResource resource

戻り値: GPUTextureView

アサート resource は GPUTexture または GPUTextureView のいずれかである。
もし resource が次のいずれかの場合：
GPUTexture
1. resource.createView() を返す。
GPUTextureView
1. resource を返す。

バッファバインディングとして取得(resource)

引数:

GPUBindingResource resource

戻り値: GPUBufferBinding

アサート resource は GPUBuffer または GPUBufferBinding のいずれかである。
もし resource が次のいずれかの場合：
GPUBuffer
1. bufferBinding を新しい GPUBufferBinding とする。
2. bufferBinding.buffer に resource を設定する。
3. bufferBinding を返す。
GPUBufferBinding
1. resource を返す。

有効バッファバインディングサイズ(binding)

引数:

GPUBufferBinding binding

戻り値: GPUSize64

もし binding.size が指定されていない場合：
1. max(0, binding.buffer.size - binding.offset) を返す。
binding.size を返す。

2つの GPUBufferBinding オブジェクト a ／ b は、次のすべてが成り立つ場合にバッファバインディングのエイリアスだとみなされます：

a.buffer == b.buffer
a.offset および a.size で形成される範囲が、 b.offset および b.size で形成される範囲と重なっている。なお size が未指定の場合、その範囲はバッファの末尾までとなる。

注: この判定を行う時、すでにダイナミックオフセットは範囲へ適用済みです。

8.3. `GPUPipelineLayout`

GPUPipelineLayout は、setBindGroup()でコマンドエンコード中にセットされたすべてのGPUBindGroupのリソースと、 GPURenderCommandsMixin.setPipeline またはGPUComputePassEncoder.setPipelineでセットされたパイプラインのシェーダーとの間のマッピングを定義します。

リソースの完全なバインディングアドレスは次の三つ組みとして定義できます：

リソースが可視となるシェーダーステージマスク
バインドグループインデックス
バインディング番号

アドレスの各要素はパイプラインのバインディング空間ともみなせます。1つのGPUBindGroup （対応するGPUBindGroupLayout付き）は、固定のバインドグループインデックスに対する空間をカバーします。含まれるバインディングは、そのバインドグループインデックスでシェーダーが利用するリソースのスーパーセットである必要があります。

[Exposed=(Window, Worker), SecureContext]
interface GPUPipelineLayout {
};
GPUPipelineLayout includes GPUObjectBase;

GPUPipelineLayout は以下のデバイスタイムラインプロパティを持ちます：

[[bindGroupLayouts]], 型 list<GPUBindGroupLayout>、読み取り専用: 作成時にGPUPipelineLayoutDescriptor.bindGroupLayoutsで指定されたGPUBindGroupLayoutオブジェクト群。

注: 同じGPUPipelineLayout を複数のGPURenderPipeline やGPUComputePipeline パイプライン間で使用すると、これらのパイプライン間で切り替えが発生してもユーザーエージェントが内部でリソースを再バインドする必要がないことが保証されます。

GPUComputePipeline オブジェクトXがGPUPipelineLayout.bindGroupLayouts A, B, Cで作成されたとします。GPUComputePipeline オブジェクトYはA, D, Cで作成されたとします。コマンドエンコードシーケンスが次の2つのディスパッチであると仮定します：

setBindGroup(0, ...)
setBindGroup(1, ...)
setBindGroup(2, ...)
setPipeline(X)
dispatchWorkgroups()
setBindGroup(1, ...)
setPipeline(Y)
dispatchWorkgroups()

この場合、ユーザーエージェントは2回目のdispatchのためにグループスロット2を再バインドする必要があります。これは、GPUPipelineLayout.bindGroupLayouts のインデックス2のGPUBindGroupLayoutや、スロット2のGPUBindGroupが変化しなくても発生します。

注: GPUPipelineLayout の推奨される利用方法は、最も一般的かつ変更頻度の低いバインドグループをレイアウトの「下部」、すなわちバインドグループスロット番号が0や1など低い位置に配置することです。描画呼び出し間で頻繁に変更する必要があるバインドグループほどインデックスを高くします。この一般的なガイドラインにより、ユーザーエージェントは描画呼び出し間の状態変更を最小化し、結果としてCPUオーバーヘッドも低減できます。

8.3.1. パイプラインレイアウトの作成

GPUPipelineLayout はGPUDevice.createPipelineLayout()で作成されます。

dictionary GPUPipelineLayoutDescriptor
         : GPUObjectDescriptorBase {
    required sequence<GPUBindGroupLayout?> bindGroupLayouts;
};

GPUPipelineLayoutDescriptor 辞書はパイプラインが用いるすべてのGPUBindGroupLayoutを定義し、次のメンバーを持ちます：

bindGroupLayouts, 型 sequence<GPUBindGroupLayout?>: パイプラインが利用するオプションのGPUBindGroupLayoutのリスト。各要素はGPUShaderModuleの@group属性に対応し、N番目の要素が@group(N)に対応します。

createPipelineLayout(descriptor)

GPUPipelineLayout を作成します。

呼び出し元: GPUDevice this。

引数:

GPUDevice.createPipelineLayout(descriptor) メソッドの引数
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUPipelineLayoutDescriptor`	✘	✘	作成する `GPUPipelineLayout` の説明。

戻り値: GPUPipelineLayout

Content timeline の手順:

pl に ! create a new WebGPU object(this, GPUPipelineLayout, descriptor) を設定する。
this の Device timeline で initialization steps を実施する。
pl を返す。

Device timeline の initialization steps:

limits を this.[[device]].[[limits]] とする。
bindGroupLayouts を list（null の GPUBindGroupLayout 閉じたサイズ = limits.maxBindGroups のリスト）にする。
各 bindGroupLayout（インデックス i）を descriptor.bindGroupLayouts で繰り返す：
1. もし bindGroupLayout が null でなく、かつ bindGroupLayout.[[descriptor]].entries が空でない場合:
  1. bindGroupLayouts[i] に bindGroupLayout を設定する。
allEntries を、bindGroupLayouts 内の null でない bgl の [[descriptor]].entries をすべて連結した結果とする。
下記条件をいずれか満たさない場合は generate a validation error を発生させ、 invalidate pl を実行し、リターンする。
- bindGroupLayouts 内の null でない各 GPUBindGroupLayout は valid to use with this であり、かつ [[exclusivePipeline]] が null でなければならない。
- descriptor.bindGroupLayouts のサイズは limits.maxBindGroups 以下であること。
- allEntries が limits のバインディングスロット上限を超えないこと。
pl.[[bindGroupLayouts]] に bindGroupLayouts を設定する。

注意: 2つの GPUPipelineLayout オブジェクトは、内部の [[bindGroupLayouts]] シーケンスに含まれる GPUBindGroupLayout オブジェクトが group-equivalent である場合、いかなる用途でも等価とみなされます。

8.4. 例

ユニフォームバッファ、テクスチャ、サンプラーのバインディングを記述するGPUBindGroupLayoutを作成します。そして、GPUBindGroupと GPUPipelineLayout を、このGPUBindGroupLayoutを用いて作成します。

const bindGroupLayout = gpuDevice.createBindGroupLayout({
    entries: [{
        binding: 0,
        visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
        buffer: {}
    }, {
        binding: 1,
        visibility: GPUShaderStage.FRAGMENT,
        texture: {}
    }, {
        binding: 2,
        visibility: GPUShaderStage.FRAGMENT,
        sampler: {}
    }]
});

const bindGroup = gpuDevice.createBindGroup({
    layout: bindGroupLayout,
    entries: [{
        binding: 0,
        resource: { buffer: buffer },
    }, {
        binding: 1,
        resource: texture
    }, {
        binding: 2,
        resource: sampler
    }]
});

const pipelineLayout = gpuDevice.createPipelineLayout({
    bindGroupLayouts: [bindGroupLayout]
});

9. シェーダーモジュール

9.1. `GPUShaderModule`

[Exposed=(Window, Worker), SecureContext]
interface GPUShaderModule {
    Promise<GPUCompilationInfo> getCompilationInfo();
};
GPUShaderModule includes GPUObjectBase;

GPUShaderModule は内部シェーダーモジュールオブジェクトへの参照です。

9.1.1. シェーダーモジュールの生成

dictionary GPUShaderModuleDescriptor
         : GPUObjectDescriptorBase {
    required USVString code;
    sequence<GPUShaderModuleCompilationHint> compilationHints = [];
};

code, 型 USVString

シェーダーモジュールの WGSL ソースコード。

compilationHints, 型 sequence<GPUShaderModuleCompilationHint>、デフォルト値 []

GPUShaderModuleCompilationHint のリストです。

アプリケーションが提供するヒントには、最終的にエントリーポイントから作成されるパイプラインのエントリーポイント情報を含めるべきです。

実装は、GPUShaderModuleCompilationHint に含まれる情報を使用して、createShaderModule() 内で可能な限り多くのコンパイルを行うべきです。

型チェック以外では、これらのヒントは一切検証されません。

注:

compilationHints に情報を指定しても、性能以外に観測可能な効果はありません。作成されないパイプラインに対してヒントを与えると性能が低下する場合もあります。

1つのシェーダーモジュールは複数のエントリーポイントを持つことができ、複数のパイプラインが単一のシェーダーモジュールから作成されるため、実装側は createShaderModule() で一度にできるだけ多くのコンパイルを行うことで、複数回 createComputePipeline() や createRenderPipeline() を呼び出すよりも高い性能を得られる場合があります。

ヒントは明示的に名前が指定されたエントリーポイントにのみ適用されます。 GPUProgrammableStage.entryPoint とは異なり、デフォルト値はありません（モジュールにエントリーポイントが1つだけであっても）。

注: ヒントは観測可能な方法で検証されませんが、ユーザーエージェントは（未知のエントリーポイント名や非互換なパイプラインレイアウトなどの）識別可能なエラーを開発者向けに表示してもかまいません（例: ブラウザの開発者コンソールなど）。

createShaderModule(descriptor)

GPUShaderModule を生成します。

呼び出し元: GPUDevice this。

引数:

GPUDevice.createShaderModule(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUShaderModuleDescriptor`	✘	✘	`GPUShaderModule` の説明

戻り値: GPUShaderModule

sm を ! 新しい WebGPU オブジェクトを作成する(this, GPUShaderModule, descriptor)。
initialization steps をデバイスタイムライン上で実行する。
sm を返す。

デバイスタイムライン initialization steps:

error を、WGSL ソース descriptor.code でシェーダーモジュール生成時に発生したエラー、またはエラーがなければ null とする。
以下の要件が満たされない場合、バリデーションエラーを生成し、sm を無効化し、終了する。
- this は失われていない状態でなければならない。
- error はシェーダー生成プログラムエラーであってはならない。
- descriptor.code にある各 enable 拡張について、対応する GPUFeatureName が有効化されていなければならない（機能索引参照）。
注: 分類されていないエラーはシェーダーモジュールの生成時には発生しません。実装が生成時にそのようなエラーを検出した場合、シェーダーモジュールは有効であるかのように振る舞い、パイプライン生成までエラーの提示を遅延させる必要があります。

注:

ユーザーエージェントは、ここで発生するバリデーションエラーの message テキストに詳細なコンパイラエラーメッセージやシェーダーテキストを含めるべきではありません: これらの詳細は getCompilationInfo() で取得できます。ユーザーエージェントは、開発者向けに人間が読める形式のエラー詳細を表示するべきです（例: ブラウザの開発者コンソールの警告、シェーダー全文表示可能など）。

シェーダーのコンパイルエラーは現行標準のアプリケーションではまれなため、ユーザーエージェントはエラー処理 (GPUエラースコープや uncapturederror イベントハンドラ) に関係なく、開発者向けに表示しても良いです。そうしない場合は、ユーザーが人間向けの詳細を必ず取得できる方法（例: チェックボックスでエラー表示、GPUCompilationInfo オブジェクトをコンソールに表示時に詳細表示など）を用意し、文書化すべきです。

WGSL コードから GPUShaderModule を作成する:

// ビューポート全体を赤で塗りつぶす単純なバーテックス・フラグメントシェーダーペア。
const shaderSource = `
    var<private> pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(
        vec2(-1.0, -1.0), vec2(-1.0, 3.0), vec2(3.0, -1.0));

    @vertex
    fn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> @builtin(position) vec4<f32> {
        return vec4(pos[vertexIndex], 1.0, 1.0);
    }

    @fragment
    fn fragmentMain() -> @location(0) vec4<f32> {
        return vec4(1.0, 0.0, 0.0, 1.0);
    }
`;

const shaderModule = gpuDevice.createShaderModule({
    code: shaderSource,
});

9.1.1.1. シェーダーモジュールのコンパイルヒント

シェーダーモジュールのコンパイルヒントは、任意の追加情報であり、特定の GPUShaderModule エントリーポイントが将来的にどのように使用される予定かを示します。一部の実装では、この情報によってシェーダーモジュールを早期にコンパイルでき、性能向上につながる場合があります。

dictionary GPUShaderModuleCompilationHint {
    required USVString entryPoint;
    (GPUPipelineLayout or GPUAutoLayoutMode) layout;
};

layout, 型 (GPUPipelineLayout or GPUAutoLayoutMode): GPUPipelineLayout は、GPUShaderModule が今後 createComputePipeline() や createRenderPipeline() の呼び出し時に使用される場合に参照されます。 "auto" に設定した場合は、このヒントに関連付けられたエントリーポイント用のデフォルトのパイプラインレイアウトが使用されます。

注:

可能であれば、著者は createShaderModule() と createComputePipeline() / createRenderPipeline() の両方に同じ情報を渡すべきです。

アプリケーションが createShaderModule() の呼び出し時にヒント情報を提供できない場合は、通常 createShaderModule() の呼び出しを遅らせるのではなく、 compilationHints 配列や GPUShaderModuleCompilationHint の個々のメンバーから未知の情報を省略するべきです。省略した場合、コンパイルは createComputePipeline() / createRenderPipeline() 時に遅延して行われる可能性があります。

著者が createShaderModule() に渡すヒント情報が、後で同じモジュールに対して createComputePipeline() / createRenderPipeline() に渡す情報と一致しない可能性がある場合は、 createShaderModule() にはその情報を渡さないようにすべきです。不一致の情報を createShaderModule() に渡すと、不要なコンパイルが発生する場合があります。

9.1.2. シェーダーモジュールのコンパイル情報

enum GPUCompilationMessageType {
    "error",
    "warning",
    "info",
};

[Exposed=(Window, Worker), Serializable, SecureContext]
interface GPUCompilationMessage {
    readonly attribute DOMString message;
    readonly attribute GPUCompilationMessageType type;
    readonly attribute unsigned long long lineNum;
    readonly attribute unsigned long long linePos;
    readonly attribute unsigned long long offset;
    readonly attribute unsigned long long length;
};

[Exposed=(Window, Worker), Serializable, SecureContext]
interface GPUCompilationInfo {
    readonly attribute FrozenArray<GPUCompilationMessage> messages;
};

GPUCompilationMessage は、GPUShaderModule コンパイラによって生成される情報、警告、またはエラーメッセージです。これらのメッセージはデベロッパーがシェーダーのcode の問題を診断しやすいように、人間が読める形で提供されます。各メッセージはシェーダーソースの1つの箇所または範囲に対応している場合もあれば、特定のコード部分に紐付かない場合もあります。

GPUCompilationMessage には以下の属性があります:

message, 型 DOMString, 読み取り専用

このコンパイルメッセージの人間が読めるローカライズ可能なテキスト。

注: message は言語および方向情報のベストプラクティスに従うべきです。これには、今後登場する文字列の言語・方向メタデータに関する標準を活用することも含みます。

編集上の注: 本書執筆時点では、レガシーAPIと互換性・一貫性を持つ言語/方向の推奨事項はありませんが、今後登場した際は正式に採用してください。

type, 型 GPUCompilationMessageType, 読み取り専用

メッセージの重大度レベル。

type が "error" の場合、シェーダー生成エラーに対応します。

lineNum, 型 unsigned long long, 読み取り専用

この message が対応するシェーダー code の行番号。値は1始まりで、1はシェーダー code の最初の行を示します。行区切りは改行です。

message が部分文字列に対応する場合は、その部分文字列が始まる行を指します。メッセージがシェーダー code の特定の位置に対応しない場合は、値は 0 です。

linePos, 型 unsigned long long, 読み取り専用

シェーダー lineNum 行の先頭から、message が対応する位置/部分文字列のUTF-16コード単位数。値は1始まりで、linePos が 1 の場合はその行の最初のコードユニットです。

message が部分文字列に対応する場合は、その部分文字列の最初のUTF-16コードユニットを指します。メッセージがシェーダー code の特定の位置に対応しない場合は、値は 0 です。

offset, 型 unsigned long long, 読み取り専用

シェーダー code の先頭から、message が対応する位置/部分文字列までのUTF-16コード単位数。同じ位置は lineNum および linePos でも参照されます。メッセージがシェーダー code の特定の位置に対応しない場合は、値は 0 です。

length, 型 unsigned long long, 読み取り専用

message が対応する部分文字列のUTF-16コード単位数。メッセージが部分文字列に対応しない場合は length は0です。

注: GPUCompilationMessage.lineNum および GPUCompilationMessage.linePos は、主な用途が多くのテキストエディタの行・列番号と照合できる人間向けメッセージの印刷であるため、1始まりです。

注: GPUCompilationMessage.offset および GPUCompilationMessage.length は、シェーダー code の部分文字列取得に substr() へ渡すのに適しています。 message が対応する部分文字列を抽出できます。

getCompilationInfo()

GPUShaderModule のコンパイル時に生成されたメッセージを返します。

メッセージの位置、順序、および内容は実装依存です。特に、メッセージがlineNumで順序付けされるとは限りません。

呼び出し元: GPUShaderModule this

戻り値: Promise<GPUCompilationInfo>

現在のコンテンツタイムラインを contentTimeline とする。
promise を新しい Promiseとして生成する。
synchronization steps をデバイスタイムライン上で実行する。
promise を返す。

デバイスタイムライン synchronization steps:

this のシェーダーモジュール生成が（成功・失敗問わず）完了したときに event が発生する。
タイムラインイベントを監視 event を this.[[device]] で発生させ、以降の手順は contentTimeline で処理する。

コンテンツタイムラインの手順:

新しい GPUCompilationInfo を info とする。
シェーダーモジュール生成時に this で生成されたエラー・警告・情報メッセージのリストを messages とする。デバイスが失われた場合は空リスト []。
messages の各 message について:
1. 新しい GPUCompilationMessage を m とする。
2. m.message に message のテキストを設定する。
3. message がシェーダー生成エラーの場合:
  
  m.type に "error" を設定する
  
  警告の場合:
  
  m.type に "warning" を設定する
  
  その他:
  
  m.type に "info" を設定する
4. message がシェーダー code 内の特定の部分文字列や位置に対応する場合:
  1. m.lineNum に、メッセージが参照する最初の行番号（1始まり）を設定する。
  2. m.linePos に、その行の最初のUTF-16コードユニット番号（1始まり）を設定する。メッセージが行全体を参照する場合は 1。
  3. m.offset に、シェーダー開始から部分文字列/位置までのUTF-16コード単位数を設定する。
  4. m.length に、メッセージが参照する部分文字列のUTF-16コード単位数、または位置の場合は0を設定する。
  その他:
  1. m.lineNum に 0 を設定する。
  2. m.linePos に 0 を設定する。
  3. m.offset に 0 を設定する。
  4. m.length に 0 を設定する。
5. info.messages に m を追加する。
promise を info で解決する。

10. パイプライン

パイプラインは、GPUComputePipeline や GPURenderPipeline のいずれであっても、バインディングや頂点バッファなどの入力データを処理して、出力レンダーターゲットの色などの出力を生成する、GPUハードウェア・ドライバー・ユーザーエージェントの組み合わせによる機能全体を表します。

構造的には、パイプラインはプログラム可能なステージ（シェーダー）と、ブレンドモードなどの固定機能ステートの連なりで構成されます。

注: 内部的には、ターゲットプラットフォームによっては、ドライバーが一部の固定機能ステートをシェーダーコードに変換し、ユーザーが提供したシェーダーとリンクする場合があります。このリンク処理が、オブジェクトを一体として生成する理由のひとつです。

この組み合わせ状態は1つのオブジェクト（GPUComputePipeline または GPURenderPipeline）として作成され、1つのコマンド（GPUComputePassEncoder.setPipeline() または GPURenderCommandsMixin.setPipeline() で切り替えます。

パイプラインの生成方法は2つあります:

即時パイプライン生成

createComputePipeline() および createRenderPipeline() は、パスエンコーダで即座に使用可能なパイプラインオブジェクトを返します。

これが失敗すると、パイプラインオブジェクトは無効となり、呼び出しはバリデーションエラーまたは内部エラーを生成します。

注: ハンドルオブジェクトは即座に返されますが、実際のパイプライン生成は同期的ではありません。パイプライン生成に時間がかかる場合、生成呼び出しからパイプラインが最初に使用される submit() 実行までの間のデバイスタイムラインのどこかで待ちが発生する可能性があります。このタイミングは規定されていませんが、主に次のいずれかです: 生成時、setPipeline()でパイプラインが初めて使われる時、対応する finish()（GPUCommandEncoder または GPURenderBundleEncoder）時、または submit() で GPUCommandBuffer が実行された時です。

非同期パイプライン生成

createComputePipelineAsync() および createRenderPipelineAsync() は、パイプライン生成が完了するとパイプラインオブジェクトに解決されるPromiseを返します。

失敗した場合、Promiseは GPUPipelineError で reject されます。

GPUPipelineErrorはパイプライン生成失敗を表します。

[Exposed=(Window, Worker), SecureContext, Serializable]
interface GPUPipelineError : DOMException {
    constructor(optional DOMString message = "", GPUPipelineErrorInit options);
    readonly attribute GPUPipelineErrorReason reason;
};

dictionary GPUPipelineErrorInit {
    required GPUPipelineErrorReason reason;
};

enum GPUPipelineErrorReason {
    "validation",
    "internal",
};

GPUPipelineError のコンストラクタ:

constructor()

引数:

GPUPipelineError.constructor() メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`message`	`DOMString`	✘	✔	基底 `DOMException` のエラーメッセージ
`options`	`GPUPipelineErrorInit`	✘	✘	`GPUPipelineError` 固有のオプション

this.name を "GPUPipelineError" に設定する。
this.message を message に設定する。
this.reason を options.reason に設定する。

GPUPipelineError には以下の属性があります:

reason, 型 GPUPipelineErrorReason, 読み取り専用

パイプライン生成時に遭遇したエラー種別を GPUPipelineErrorReason として公開する読み取り専用スロット属性です:

"validation": バリデーションエラー
"internal": 内部エラー

GPUPipelineError オブジェクトはシリアライズ可能オブジェクトです。

valueおよびserializedに対するシリアライズ手順は以下の通りです:

DOMException のシリアライズ手順を value と serialized に対して実行する。

valueおよびserializedに対するデシリアライズ手順は以下の通りです:

DOMException のデシリアライズ手順を value と serialized に対して実行する。

10.1. ベースパイプライン

enum GPUAutoLayoutMode {
    "auto",
};

dictionary GPUPipelineDescriptorBase
         : GPUObjectDescriptorBase {
    required (GPUPipelineLayout or GPUAutoLayoutMode) layout;
};

layout, 型 (GPUPipelineLayout or GPUAutoLayoutMode)

このパイプラインの GPUPipelineLayout または "auto" を指定するとパイプラインレイアウトが自動生成されます。

注: "auto" を使用した場合、そのパイプラインは他のパイプラインと GPUBindGroup を共有できません。

interface mixin GPUPipelineBase {
    [NewObject] GPUBindGroupLayout getBindGroupLayout(unsigned long index);
};

GPUPipelineBase には以下のデバイスタイムラインプロパティがあります:

[[layout]], 型 GPUPipelineLayout: thisで使用できるリソースのレイアウト定義。

GPUPipelineBase には以下のメソッドがあります:

getBindGroupLayout(index)

GPUPipelineBase の GPUBindGroupLayout に互換性のある GPUBindGroupLayout を index で取得します。

呼び出し元: GPUPipelineBase this

引数:

GPUPipelineBase.getBindGroupLayout(index) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`index`	`unsigned long`	✘	✘	パイプラインレイアウトの `[[bindGroupLayouts]]` シーケンスのインデックス。

戻り値: GPUBindGroupLayout

新しい GPUBindGroupLayout オブジェクトを layout とする。
this のデバイスタイムライン上で initialization steps を実行する。
layout を返す。

デバイスタイムライン initialization steps:

limits を this.[[device]].[[limits]] とする。
以下のいずれかの条件が満たされない場合バリデーションエラーを生成し、layoutを無効化して終了する。
- this は有効であること。
- index < limits.maxBindGroups であること。
layout を this.[[layout]].[[bindGroupLayouts]][index] のコピーとして初期化する。

注: GPUBindGroupLayout は常に値渡しで使われ、参照渡しにはなりません。つまり、同じ内部オブジェクトを新しいWebGPUインターフェースで返すのと同じです。毎回新しい GPUBindGroupLayout WebGPUインターフェースが返されるので、コンテンツタイムラインとデバイスタイムライン間の往復を避けることができます。

10.1.1. デフォルトパイプラインレイアウト

GPUPipelineBase オブジェクトが layout に "auto" を設定して作成された場合、デフォルトレイアウトが生成されて使用されます。

注: デフォルトレイアウトは簡単なパイプライン向けの便宜で提供されていますが、ほとんどの場合は明示的なレイアウトの利用が推奨されます。デフォルトレイアウトで作成したバインドグループは他のパイプラインと共有できず、シェーダーを変更するとデフォルトレイアウトの構造も変化し、予期しないバインドグループ生成エラーが発生することがあります。

デフォルトパイプラインレイアウトを GPUPipelineBase pipeline に対して生成するには、以下のデバイスタイムライン手順を実行する:

groupCount を 0 にする。
groupDescs を device.[[limits]].maxBindGroups 個の新しい GPUBindGroupLayoutDescriptor オブジェクトの配列とする。
groupDescs の各 groupDesc について:
1. groupDesc.entries を空のシーケンスにする。
pipeline を生成したディスクリプタ内の各 GPUProgrammableStage stageDesc について:
1. shaderStage を stageDesc が pipeline で使用されるシェーダーステージの GPUShaderStageFlags とする。
2. entryPoint を get the entry point(shaderStage, stageDesc) とする。Assert entryPoint は null ではない。
3. entryPoint が静的に使用する各 resource resource について:
  1. group を resource の "group" 修飾子とする。
  2. binding を resource の "binding" 修飾子とする。
  3. entry を新しい GPUBindGroupLayoutEntry とする。
  4. entry.binding に bindingを設定する。
  5. entry.visibility に shaderStage を設定する。
  6. resource がサンプラーバインディングの場合:
    1. samplerLayout を新しい GPUSamplerBindingLayout とする。
    2. entry.sampler に samplerLayout を設定する。
  7. resource が比較サンプラーバインディングの場合:
    1. samplerLayout を新しい GPUSamplerBindingLayout とする。
    2. samplerLayout.type に "comparison" を設定する。
    3. entry.sampler に samplerLayout を設定する。
  8. resource がバッファバインディングの場合:
    1. bufferLayout を新しい GPUBufferBindingLayout とする。
    2. bufferLayout.minBindingSize に resource の最小バッファバインディングサイズを設定する。
    3. resource が読み取り専用ストレージバッファの場合:
      1. bufferLayout.type に "read-only-storage" を設定する。
    4. resource がストレージバッファの場合:
      1. bufferLayout.type に "storage" を設定する。
    5. entry.buffer に bufferLayout を設定する。
  9. resource がサンプリングテクスチャバインディングの場合:
    1. textureLayout を新しい GPUTextureBindingLayout とする。
    2. resource が深度テクスチャバインディングの場合:
      - textureLayout.sampleType に "depth" を設定する。
      そうでない場合、resource のサンプル型が:
      
      f32 かつ stageDesc から resource へのサンプラー付きテクスチャ組み込み関数呼び出しが静的に使用されている場合
      
      textureLayout.sampleType に "float" を設定する。
      
      f32 その他の場合
      
      textureLayout.sampleType に "unfilterable-float" を設定する。
      
      i32
      
      textureLayout.sampleType に "sint" を設定する。
      
      u32
      
      textureLayout.sampleType に "uint" を設定する。
    3. textureLayout.viewDimension に resource の次元を設定する。
    4. resource がマルチサンプルテクスチャの場合:
      1. textureLayout.multisampled に true を設定する。
    5. entry.texture に textureLayout を設定する。
  10. resource がストレージテクスチャバインディングの場合:
    1. storageTextureLayout を新しい GPUStorageTextureBindingLayout とする。
    2. storageTextureLayout.format に resource のフォーマットを設定する。
    3. storageTextureLayout.viewDimension に resource の次元を設定する。
    4. アクセスモードが:
      
      read
      
      textureLayout.access に "read-only" を設定する。
      
      write
      
      textureLayout.access に "write-only" を設定する。
      
      read_write
      
      textureLayout.access に "read-write" を設定する。
    5. entry.storageTexture に storageTextureLayout を設定する。
  11. groupCount を max(groupCount, group + 1) にする。
  12. groupDescs[group] に binding が binding と等しい entry previousEntry がある場合:
    1. entry の visibility が previousEntry と異なる場合:
      1. entry.visibility でセットされたビットを previousEntry.visibility に追加する。
    2. resource がバッファバインディングで、entry の buffer.minBindingSize が previousEntry より大きい場合:
      1. previousEntry.buffer.minBindingSize に entry.buffer.minBindingSize を設定する。
    3. resource がサンプリングテクスチャバインディングで、entry の texture.sampleType が previousEntry と異なり、かつ両方とも sampleType が "float" または "unfilterable-float" の場合:
      1. previousEntry.texture.sampleType に "float" を設定する。
    4. その他のプロパティが entry と previousEntry の間で異なる場合:
      1. null を返す（パイプライン生成は失敗する）。
    5. resource がストレージテクスチャバインディングで、 entry.storageTexture.access が "read-write"、 previousEntry.storageTexture.access が "write-only"、かつ previousEntry.storageTexture.format が § 26.1.1 プレーンカラー形式テーブルに従って STORAGE_BINDING と "read-write" に互換性がある場合:
      1. previousEntry.storageTexture.access を "read-write" に設定する。
      それ以外の場合：
      1. entry を groupDescs[group] に追加する。
groupLayouts を新しいリストとする。
i を 0 から groupCount - 1 まで順に:
1. groupDesc を groupDescs[i] とする。
2. bindGroupLayout を device.createBindGroupLayout()(groupDesc) の結果とする。
3. bindGroupLayout.[[exclusivePipeline]] に pipeline を設定する。
4. bindGroupLayout を groupLayouts に追加する。
desc を新しい GPUPipelineLayoutDescriptor とする。
desc.bindGroupLayouts に groupLayouts を設定する。
device.createPipelineLayout()(desc) を返す。

10.1.2. `GPUProgrammableStage`

GPUProgrammableStage は、ユーザーが提供した GPUShaderModule 内でパイプラインのプログラム可能ステージの1つを制御するエントリーポイントを記述します。エントリーポイント名はWGSL識別子比較で定義された規則に従います。

dictionary GPUProgrammableStage {
    required GPUShaderModule module;
    USVString entryPoint;
    record<USVString, GPUPipelineConstantValue> constants = {};
};

typedef double GPUPipelineConstantValue; // WGSLのbool, f32, i32, u32, および有効ならf16を表す場合がある。

GPUProgrammableStage には以下のメンバーがあります:

module, 型 GPUShaderModule

このプログラム可能ステージが実行するコードを含む GPUShaderModule です。

entryPoint, 型 USVString

module 内でこのステージが処理を行う関数名。

注: entryPoint は必須ではないため、GPUProgrammableStage を受け取るメソッドは "get the entry point"アルゴリズムを使ってどのエントリーポイントを指しているか決定しなければなりません。

constants, 型 record<USVString, GPUPipelineConstantValue>, デフォルト値 {}

シェーダーモジュール module 内のパイプラインオーバーライド可能定数の値を指定します。

各パイプラインオーバーライド可能定数は、 1つのパイプラインオーバーライド定数識別子文字列で一意に識別されます。宣言でIDが指定されている場合はパイプライン定数ID、そうでなければ定数の識別子名です。

各キーバリューペアのキーは、識別子文字列と一致しなければならず、比較はWGSL識別子比較の規則に従います。パイプライン実行時、その定数は指定された値を持ちます。

値は GPUPipelineConstantValue（double）として指定されます。 WGSL型へ変換され、定数の型が bool / i32 / u32 / f32 / f16 のいずれかになります。変換に失敗した場合はバリデーションエラーが生成されます。

WGSLで定義されたパイプラインオーバーライド可能定数:

@id(0)      override has_point_light: bool = true;  // アルゴリズム制御用。
@id(1200)   override specular_param: f32 = 2.3;     // 数値制御。
@id(1300)   override gain: f32;                     // 必ずオーバーライドされる必要あり。
            override width: f32 = 0.0;              // APIレベルで指定
                                                    //   名前 "width" を使う。
            override depth: f32;                    // APIレベルで指定
                                                    //   名前 "depth"。
                                                    //   必ずオーバーライドされる必要あり。
            override height = 2 * depth;            // デフォルト値
                                                    // （APIレベルでセットされてなければ）、
                                                    // 他のオーバーライド可能定数に依存。

対応するJavaScriptコード、必須オーバーライドのみ提供:

{
    // ...
    constants: {
        1300: 2.0,  // "gain"
        depth: -1,  // "depth"
    }
}

全ての定数をオーバーライドする場合のJavaScriptコード:

{
    // ...
    constants: {
        0: false,   // "has_point_light"
        1200: 3.0,  // "specular_param"
        1300: 2.0,  // "gain"
        width: 20,  // "width"
        depth: -1,  // "depth"
        height: 15, // "height"
    }
}

get the entry point(GPUShaderStage stage, GPUProgrammableStage descriptor) のデバイスタイムライン手順:

descriptor.entryPoint が指定されている場合:
1. descriptor.module に、名前が descriptor.entryPoint と一致し、シェーダーステージが stage と一致するエントリーポイントが含まれているなら、そのエントリーポイントを返す。
  
  そうでなければ null を返す。
そうでない場合:
1. descriptor.module 内で、シェーダーステージが stage と一致するエントリーポイントがちょうど1つだけある場合、そのエントリーポイントを返す。
  
  そうでなければ null を返す。

GPUProgrammableStageの検証(stage, descriptor, layout, device)

引数:

GPUShaderStage stage
GPUProgrammableStage descriptor
GPUPipelineLayout layout
GPUDevice device

以下の手順のすべての要件が満たされていなければならない。どれかが満たされない場合はfalseを返し、すべて満たされていればtrueを返す。

descriptor.module は device に対して valid to use with でなければならない。
entryPoint を get the entry point(stage, descriptor) とする。
entryPoint は null であってはならない。
entryPoint により静的に使用される各 binding について：
- validating shader binding(binding, layout) は true を返さなければならない。
任意のシェーダーステージの関数（entryPoint から辿れる）へのテクスチャ組み込み関数の各呼び出し call について：
1. textureBinding を call で使われるテクスチャバインディングとする。
2. もし textureBinding が sampled texture または depth texture 型であり、 call が sampler 型（sampler_comparisonを除く）のサンプラーバインディング samplerBinding を使う場合：
  1. texture を textureBinding に対応する GPUBindGroupLayoutEntry とする。
  2. sampler を samplerBinding に対応する GPUBindGroupLayoutEntry とする。
  3. もし sampler.type が "filtering" なら、texture.sampleType は "float" でなければならない。
  注意: "comparison" サンプラーは "depth" テクスチャでのみ使用できます。なぜなら WGSL texture_depth_* バインディングにバインドできる唯一のテクスチャ型だからです。
3. もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  1. call が textureLoad の呼び出しであれば、 textureBinding は depth texture 型であってはならない。
  2. call がサンプラーバインディング samplerBinding を使い、かつ textureBinding が depth texture 型なら、 samplerBinding は sampler_comparison 型でなければならない。
descriptor.constants に含まれる各 key → value について：
1. key は、シェーダーモジュール descriptor.module に定義されているある pipeline-overridable 定数の pipeline-overridable constant identifier string と WGSL識別子比較により一致しなければならない。その定数が T 型とする。 ※この定数は entryPoint によって静的に使用されている必要はない。
2. IDL値 value を to WGSL type T へ変換する際に TypeError が投げられてはならない。
entryPoint により pipeline-overridable constant identifier string key が静的に使用されている場合：
- もし key で特定される pipeline-overridable 定数がデフォルト値を持たないならば、 descriptor.constants は key を含んでいなければならない。
パイプライン生成によってプログラムエラーが [WGSL]規格のルールで発生してはならない。
もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
1. sum を 0 にする。
2. 任意のシェーダーステージの関数（entryPoint から辿れる）でテクスチャ組み込み関数呼び出し時に使われる一意なテクスチャ／外部テクスチャバインディング textureBinding 毎に：
  1. samplerBindings を、任意のテクスチャ組み込み関数呼び出しで textureBinding と一緒に使われる全てのサンプラーバインディングの集合とする。
  2. numPairs を max(1, samplerBindings の要素数) とする。
  3. もし textureBinding が外部テクスチャバインディングであれば：
    1. numPairs を 1 + 3 * numPairs とする。
  4. sum を sum + numPairs にする。
3. sum は device.limits.maxSampledTexturesPerShaderStage 以下でなければならない。
4. sum は device.limits.maxSamplersPerShaderStage 以下でなければならない。

シェーダーバインディングの検証(variable, layout)

引数:

シェーダーバインディング宣言 variable、シェーダーモジュールから反映されたモジュールスコープ変数宣言
GPUPipelineLayout layout

bindGroup をバインドグループインデックス、bindIndex をバインディングインデックスとして、シェーダーバインディング宣言 variable から求める。

下記すべての条件が満たされる場合 true を返す：

layout.[[bindGroupLayouts]][bindGroup] に GPUBindGroupLayoutEntry entry が含まれ、かつ entry.binding == bindIndex である。
entry に対して定義されている binding member が以下の場合：
buffer

もし entry.buffer.type が以下の場合：

"uniform"

variable はアドレス空間 uniform で宣言されている。

"storage"

variable はアドレス空間 storage かつアクセスモード read_write で宣言されている。

"read-only-storage"

variable はアドレス空間 storage かつアクセスモード read で宣言されている。

もし entry.buffer.minBindingSize が 0 でない場合、その値はシェーダー中の対応バッファバインディング変数に対する最小バッファバインディングサイズ以上でなければならない。

sampler

もし entry.sampler.type が以下の場合：

"filtering" または "non-filtering"

variable の型は sampler です。

"comparison"

variable の型は sampler_comparison です。

texture

entry.texture.multisampled が true の場合に限り、variable の型は texture_multisampled_2d<T> または texture_depth_multisampled_2d<T> である。
entry.texture.sampleType が以下の場合：
"float", "unfilterable-float", "sint" または "uint"
variable は次のいずれかの型を持つ：

texture_1d<T>

texture_2d<T>

texture_2d_array<T>

texture_cube<T>

texture_cube_array<T>

texture_3d<T>

texture_multisampled_2d<T>
もし entry.texture.sampleType が以下の場合：

"float" または "unfilterable-float"

サンプリング型 T は f32 です。

"sint"

サンプリング型 T は i32 です。

"uint"

サンプリング型 T は u32 です。

"depth"
variable は次のいずれかの型を持つ：

texture_2d<T>

texture_2d_array<T>

texture_cube<T>

texture_cube_array<T>

texture_multisampled_2d<T>

texture_depth_2d

texture_depth_2d_array

texture_depth_cube

texture_depth_cube_array

texture_depth_multisampled_2d

ここで、サンプリング型 T は f32 です。
entry.texture.viewDimension が以下の場合：

"1d"

variable の型は texture_1d<T> です。

"2d"

variable の型は texture_2d<T> または texture_multisampled_2d<T> です。

"2d-array"

variable の型は texture_2d_array<T> です。

"cube"

variable の型は texture_cube<T> です。

"cube-array"

variable の型は texture_cube_array<T> です。

"3d"

variable の型は texture_3d<T> です。

storageTexture

entry.storageTexture.viewDimension が以下の場合：

"1d"

variable の型は texture_storage_1d<T, A> です。

"2d"

variable の型は texture_storage_2d<T, A> です。

"2d-array"

variable の型は texture_storage_2d_array<T, A> です。

"3d"

variable の型は texture_storage_3d<T, A> です。

entry.storageTexture.access が以下の場合：

"write-only"

アクセスモード A は write です。

"read-only"

アクセスモード A は read です。

"read-write"

アクセスモード A は read_write または write です。

テクセルフォーマット T は entry.storageTexture.format に等しい。

最小バッファバインディングサイズは、バッファバインディング変数 var に対して、以下の手順で算出されます：

T を store型（格納型）とする。
もし T がランタイムサイズ配列、またはランタイムサイズ配列を含む場合、その array<E> を array<E, 1> に置き換える。

注: これにより常に1要素分のメモリが確保され、配列インデックスを配列長にクランプすることで、メモリ内アクセスが保証されます。
SizeOf(T) を返す。

注: この下限を強制することで、バッファ変数による読み書きはバッファの境界領域内のメモリだけにアクセスすることが保証されます。

リソースバインディング、パイプラインオーバーライド可能定数、シェーダーステージ入力、またはシェーダーステージ出力は、エントリーポイントのシェーダーステージのインターフェースに存在する場合、静的に使用されるとみなされます。

10.2. `GPUComputePipeline`

GPUComputePipeline は、コンピュートシェーダーステージを制御し、パイプラインの一種であり、 GPUComputePassEncoder で使用できます。

コンピュートの入力・出力はすべてバインディングに格納され、指定された GPUPipelineLayout に従います。出力は buffer バインディング（型が "storage"）や storageTexture バインディング（型が "write-only" または "read-write"）に対応します。

コンピュートパイプラインのステージ:

コンピュートシェーダー

[Exposed=(Window, Worker), SecureContext]
interface GPUComputePipeline {
};
GPUComputePipeline includes GPUObjectBase;
GPUComputePipeline includes GPUPipelineBase;

10.2.1. コンピュートパイプラインの生成

GPUComputePipelineDescriptor はコンピュートパイプラインを記述します。詳細は § 23.1 計算処理を参照してください。

dictionary GPUComputePipelineDescriptor
         : GPUPipelineDescriptorBase {
    required GPUProgrammableStage compute;
};

GPUComputePipelineDescriptor には以下のメンバーがあります:

compute, 型 GPUProgrammableStage: パイプラインのコンピュートシェーダーのエントリーポイントを記述します。

createComputePipeline(descriptor)

即時パイプライン生成で GPUComputePipeline を作成します。

呼び出し元: GPUDevice this.

引数:

GPUDevice.createComputePipeline(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUComputePipelineDescriptor`	✘	✘	作成する `GPUComputePipeline` の説明。

戻り値: GPUComputePipeline

pipeline を ! 新しいWebGPUオブジェクトの作成(this, GPUComputePipeline, descriptor) とする。
initialization steps をデバイスタイムライン上で実行する。
pipeline を返す。

デバイスタイムライン initialization steps:

layout を descriptor.layout が "auto" ならデフォルトパイプラインレイアウトの新規生成結果、そうでなければ descriptor.layout とする。
以下のすべての要件が満たされていなければならない。どれかが満たされない場合はバリデーションエラーを生成し、pipelineを無効化して終了する。
1. layout は thisに対して有効でなければならない。
2. GPUProgrammableStageの検証(COMPUTE, descriptor.compute, layout, this) が成功しなければならない。
3. entryPoint を get the entry point(COMPUTE, descriptor.compute) とする。
  
  Assert entryPoint は nullであってはならない。
4. workgroupStorageUsed を entryPoint がworkgroupアドレス空間を持ち静的に使用されるすべての型 T について、 roundUp(16, SizeOf(T)) の合計とする。
  
  workgroupStorageUsed は device.limits.maxComputeWorkgroupStorageSize 以下でなければならない。
5. entryPoint は device.limits.maxComputeInvocationsPerWorkgroup 以下のinvocation数でなければならない。
6. entryPoint の workgroup_size属性の各成分は、 [device.limits.maxComputeWorkgroupSizeX, device.limits.maxComputeWorkgroupSizeY, device.limits.maxComputeWorkgroupSizeZ] の対応する成分以下でなければならない。
パイプライン生成の実装によりパイプライン生成未分類エラーが発生した場合は、内部エラーを生成し、pipelineを無効化して終了する。

注: 実装がシェーダーモジュール生成時に未分類エラーを検出した場合でも、エラーはここで通知されます。
pipeline.[[layout]] に layout を設定する。

createComputePipelineAsync(descriptor)

非同期パイプライン生成で GPUComputePipeline を作成します。返される Promise は、作成されたパイプラインが追加の待機なしで使用可能になったときに解決されます。

パイプライン生成が失敗した場合、返される Promise は GPUPipelineError で reject されます。（GPUError はデバイスにdispatchされません。）

注: このメソッドは、可能な限り利用するのが推奨されます。パイプラインのコンパイルによるキュータイムラインのブロックを防ぐためです。

呼び出し元: GPUDevice this.

引数:

GPUDevice.createComputePipelineAsync(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUComputePipelineDescriptor`	✘	✘	作成する `GPUComputePipeline` の説明。

戻り値: Promise<GPUComputePipeline>

現在のコンテンツタイムラインを contentTimeline とする。
promise を新しいPromiseとして生成する。
initialization steps をデバイスタイムライン上で実行する。
promise を返す。

デバイスタイムライン initialization steps:

pipeline を新しい GPUComputePipeline とし、this.createComputePipeline() を descriptor で呼び出した場合と同様に生成し、ただしエラーはdeviceにdispatchするのではなくerrorとして捕捉する。
pipelineのパイプライン生成（成功・失敗問わず）完了時に event が発生する。
タイムラインイベントを監視 event を this.[[device]] で発生させ、以降の手順はデバイスタイムライン上で処理する。

デバイスタイムラインの手順:

pipeline が有効または this が失われている場合:
1. 以下の手順を contentTimeline 上で実行:
  コンテンツタイムラインの手順:
  1. promise を pipeline で解決する。
2. 終了。
注: 失われたデバイスからはエラーは生成されません。 § 22 エラーとデバッグ参照。
pipeline が無効かつ error が内部エラーの場合は、以下の手順を contentTimeline 上で実行して終了。
コンテンツタイムラインの手順:
1. promise を GPUPipelineError の reason として "internal" で reject する。
pipeline が無効かつ error がバリデーションエラーの場合は、以下の手順を contentTimeline 上で実行して終了。
コンテンツタイムラインの手順:
1. promise を GPUPipelineError の reason として "validation" で reject する。

単純な GPUComputePipeline の作成例:

const computePipeline = gpuDevice.createComputePipeline({
    layout: pipelineLayout,
    compute: {
        module: computeShaderModule,
        entryPoint: 'computeMain',
    }
});

10.3. `GPURenderPipeline`

GPURenderPipeline はパイプラインの一種であり、バーテックス・フラグメントシェーダーステージを制御します。 GPURenderPassEncoder や GPURenderBundleEncoder で使用できます。

レンダーパイプラインの入力:

指定された GPUPipelineLayout に従うバインディング
GPUVertexState で記述される頂点・インデックスバッファ
GPUColorTargetState で記述されるカラ―アタッチメント
任意で、GPUDepthStencilState で記述されるデプスステンシルアタッチメント

レンダーパイプラインの出力:

buffer バインディング（type が "storage"）
storageTexture バインディング（access が "write-only" または "read-write"）
GPUColorTargetState で記述されるカラ―アタッチメント
任意で、GPUDepthStencilState で記述されるデプスステンシルアタッチメント

レンダーパイプラインは以下のレンダーステージから構成されます:

頂点フェッチ（GPUVertexState.buffers で制御）
バーテックスシェーダー（GPUVertexState で制御）
プリミティブアセンブリ（GPUPrimitiveState で制御）
ラスタライズ（GPUPrimitiveState、 GPUDepthStencilState、 GPUMultisampleState で制御）
フラグメントシェーダー（GPUFragmentState で制御）
ステンシルテスト・操作（GPUDepthStencilState で制御）
デプステスト・書き込み（GPUDepthStencilState で制御）
出力マージ（GPUFragmentState.targets で制御）

[Exposed=(Window, Worker), SecureContext]
interface GPURenderPipeline {
};
GPURenderPipeline includes GPUObjectBase;
GPURenderPipeline includes GPUPipelineBase;

GPURenderPipeline には以下のデバイスタイムラインプロパティがあります:

[[descriptor]], 型 GPURenderPipelineDescriptor, 読み取り専用

このパイプラインを記述する GPURenderPipelineDescriptor。

GPURenderPipelineDescriptor のすべてのオプションフィールドが定義されています。

[[writesDepth]], 型 boolean, 読み取り専用

パイプラインがデプス/ステンシルアタッチメントのデプス成分に書き込む場合はtrue

[[writesStencil]], 型 boolean, 読み取り専用

パイプラインがデプス/ステンシルアタッチメントのステンシル成分に書き込む場合はtrue

10.3.1. レンダーパイプラインの生成

GPURenderPipelineDescriptor は、各レンダーステージを構成することでレンダーパイプラインを記述します。詳細は§ 23.2 レンダリングを参照してください。

dictionary GPURenderPipelineDescriptor
         : GPUPipelineDescriptorBase {
    required GPUVertexState vertex;
    GPUPrimitiveState primitive = {};
    GPUDepthStencilState depthStencil;
    GPUMultisampleState multisample = {};
    GPUFragmentState fragment;
};

GPURenderPipelineDescriptor には以下のメンバーがあります:

vertex, 型 GPUVertexState: パイプラインのバーテックスシェーダーのエントリーポイントと、その入力バッファレイアウトを記述します。
primitive, 型 GPUPrimitiveState、デフォルト値 {}: パイプラインのプリミティブ関連プロパティを記述します。
depthStencil, 型 GPUDepthStencilState: オプションのデプスステンシルプロパティ（テスト・操作・バイアス）を記述します。
multisample, 型 GPUMultisampleState、デフォルト値 {}: パイプラインのマルチサンプリングプロパティを記述します。
fragment, 型 GPUFragmentState: パイプラインのフラグメントシェーダーのエントリーポイントと、その出力カラ―を記述します。指定されていない場合は、§ 23.2.8 カラー出力なしモードとなります。

createRenderPipeline(descriptor)

即時パイプライン生成で GPURenderPipeline を作成します。

呼び出し元: GPUDevice this.

引数:

GPUDevice.createRenderPipeline(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPURenderPipelineDescriptor`	✘	✘	作成する `GPURenderPipeline` の説明。

戻り値: GPURenderPipeline

もし descriptor.fragment が指定されている場合：
1. 各 non-null colorState について、 descriptor.fragment.targets の要素ごとに：
  1. ? Validate texture format required features を colorState.format と this.[[device]] で実行する。
もし descriptor.depthStencil が指定されている場合：
1. ? Validate texture format required features を descriptor.depthStencil.format と this.[[device]] で実行する。
pipeline を ! create a new WebGPU object(this, GPURenderPipeline, descriptor) に設定する。
this の Device timeline で initialization steps を実施する。
pipeline を返す。

デバイスタイムライン initialization steps:

layout を descriptor.layout が "auto" ならデフォルトパイプラインレイアウトの新規生成結果、そうでなければ descriptor.layout とする。
以下すべての要件が満たされていなければならない。どれかが満たされない場合はバリデーションエラーを生成し、pipelineを無効化して終了する。
1. layout は thisに対して有効でなければならない。
2. GPURenderPipelineDescriptorの検証(descriptor, layout, this) が成功しなければならない。
3. vertexBufferCount を descriptor.vertex.buffers の最後の非nullエントリのインデックス＋１（なければ０）とする。
4. layout.[[bindGroupLayouts]].size＋vertexBufferCount は this.[[device]].[[limits]].maxBindGroupsPlusVertexBuffers 以下でなければならない。
パイプライン生成の実装によりパイプライン生成未分類エラーが発生した場合は、内部エラーを生成し、pipelineを無効化して終了する。

注: 実装がシェーダーモジュール生成時に未分類エラーを検出した場合でも、エラーはここで通知されます。
pipeline.[[descriptor]] に descriptor を設定する。
pipeline.[[writesDepth]] に false を設定する。
pipeline.[[writesStencil]] に false を設定する。
depthStencil を descriptor.depthStencil とする。
depthStencil が null でない場合:
1. depthStencil.depthWriteEnabled が指定されている場合:
  1. pipeline.[[writesDepth]] に depthStencil.depthWriteEnabled を設定する。
2. depthStencil.stencilWriteMask が 0 でない場合:
  1. stencilFront を depthStencil.stencilFront とする。
  2. stencilBack を depthStencil.stencilBack とする。
  3. cullMode を descriptor.primitive.cullMode とする。
  4. cullMode が "front" でない場合、 stencilFront.passOp、 stencilFront.depthFailOp、 stencilFront.failOp のいずれかが "keep" でない場合:
    1. pipeline.[[writesStencil]] に true を設定する。
  5. cullMode が "back" でない場合、 stencilBack.passOp、 stencilBack.depthFailOp、 stencilBack.failOp のいずれかが "keep" でない場合:
    1. pipeline.[[writesStencil]] に true を設定する。
pipeline.[[layout]] に layout を設定する。

createRenderPipelineAsync(descriptor)

非同期パイプライン生成で GPURenderPipeline を作成します。返される Promise は、作成されたパイプラインが追加の待機なしで使用可能になったときに解決されます。

パイプライン生成が失敗した場合、返される Promise は GPUPipelineError で reject されます。（GPUError はデバイスにdispatchされません。）

注: このメソッドは、可能な限り利用するのが推奨されます。パイプラインのコンパイルによるキュータイムラインのブロックを防ぐためです。

呼び出し元: GPUDevice this.

引数:

GPUDevice.createRenderPipelineAsync(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPURenderPipelineDescriptor`	✘	✘	作成する `GPURenderPipeline` の説明。

戻り値: Promise<GPURenderPipeline>

現在のコンテンツタイムラインを contentTimeline とする。
promise を新しいPromiseとして生成する。
initialization steps をデバイスタイムライン上で実行する。
promise を返す。

デバイスタイムライン 初期化ステップ：

pipeline を新しい GPURenderPipeline とし、this.createRenderPipeline() を descriptor で呼び出した場合と同様に生成し、ただしエラーはdeviceにdispatchするのではなくerrorとして捕捉する。
pipelineのパイプライン生成（成功・失敗問わず）完了時に event が発生する。
タイムラインイベントを監視 event を this.[[device]] で発生させ、以降の手順はデバイスタイムライン上で処理する。

デバイスタイムラインの手順:

pipeline が有効または this が失われている場合:
1. 以下の手順を contentTimeline 上で実行:
  コンテンツタイムラインの手順:
  1. promise を pipeline で解決する。
2. 終了。
注: 失われたデバイスからはエラーは生成されません。 § 22 エラーとデバッグ参照。
pipeline が無効かつ error が内部エラーの場合は、以下の手順を contentTimeline 上で実行して終了。
コンテンツタイムラインの手順:
1. promise を GPUPipelineError の reason として "internal" で reject する。
pipeline が無効であり、 error がバリデーションエラーの場合、以下の手順を contentTimeline 上で実行して終了する。
コンテンツタイムラインの手順:
1. promise を GPUPipelineError の reason として "validation" で reject する。

GPURenderPipelineDescriptor の検証(descriptor, layout, device)

引数:

GPURenderPipelineDescriptor descriptor
GPUPipelineLayout layout
GPUDevice device

Device timeline の手順：

以下すべての条件が満たされた場合、true を返す：
- validating GPUVertexState(device, descriptor.vertex, layout) が成功すること。
- もし descriptor.fragment が指定されている場合：
  - validating GPUFragmentState(device, descriptor.fragment, layout) が成功すること。
  - もし sample_mask 組み込みが descriptor.fragment のシェーダーステージ出力の場合：
    - descriptor.multisample.alphaToCoverageEnabled が false であること。
  - もし frag_depth 組み込みが descriptor.fragment のシェーダーステージ出力の場合：
    - descriptor.depthStencil が指定されており、かつ descriptor.depthStencil.format が depth アスペクトを持つこと。
  - もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
    
    sample_mask 組み込みは descriptor.fragment のシェーダーステージ入力またはシェーダーステージ出力であってはならない。
    
    sample_index 組み込みは descriptor.fragment のシェーダーステージ入力であってはならない。
- validating GPUPrimitiveState(descriptor.primitive, device) が成功すること。
- もし descriptor.depthStencil が指定されている場合：
  - validating GPUDepthStencilState(device, descriptor.depthStencil, descriptor.primitive.topology) が成功すること。
- validating GPUMultisampleState(descriptor.multisample) が成功すること。
- もし descriptor.multisample.alphaToCoverageEnabled が true の場合：
  1. descriptor.fragment が指定されていること。
  2. descriptor.fragment.targets[0] が存在しかつ non-null であること。
  3. descriptor.fragment.targets[0].format が GPUTextureFormat であり、ブレンド対応かつアルファチャンネルを持っていること。
- 以下のいずれか少なくとも1つのアタッチメントが存在すること：
  - descriptor.fragment.targets に non-null の値が含まれる
  - または descriptor.depthStencil が指定されている
- validating inter-stage interfaces(device, descriptor) が true を返すこと。

Compatibility Mode シェーダーバインディングの検証(variable)

引数:

シェーダーバインディング宣言 variable（シェーダーモジュールから反映されたモジュールスコープ変数宣言）

戻り値: boolean

Device timeline の手順：

variable の interpolation が linear の場合、false を返す。
variable の interpolation が flat かつ interpolation sampling が either でない場合、false を返す。
variable の interpolation sampling が sample の場合、false を返す。
true を返す。

ステージ間インターフェースの検証(device, descriptor)

引数:

GPUDevice device
GPURenderPipelineDescriptor descriptor

戻り値: boolean

Device timeline の手順：

maxVertexShaderOutputVariables を device.limits.maxInterStageShaderVariables に設定する。
maxVertexShaderOutputLocation を device.limits.maxInterStageShaderVariables - 1 に設定する。
もし descriptor.primitive.topology が "point-list" の場合：
1. maxVertexShaderOutputVariables を 1 減らす。
もし clip_distances が descriptor.vertex の出力で宣言されている場合：
1. clipDistancesSize を clip_distances の配列サイズとする。
2. maxVertexShaderOutputVariables を ceil(clipDistancesSize / 4) 減らす。
3. maxVertexShaderOutputLocation を ceil(clipDistancesSize / 4) 減らす。
以下のいずれかが満たされない場合はfalse を返す：
- descriptor.vertex のユーザー定義出力の数が maxVertexShaderOutputVariables 以下であること。
- descriptor.vertex の各ユーザー定義出力の location が maxVertexShaderOutputLocation 以下であること。
もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
1. descriptor.vertex の各ユーザー定義 output について
  1. Compatibility Mode シェーダーバインディングの検証(output) が失敗した場合、false を返す。
もし descriptor.fragment が指定されている場合：
1. maxFragmentShaderInputVariables を device.limits.maxInterStageShaderVariables に設定する。
2. descriptor.fragment の入力として使われる Inter-Stage Builtins ごとに:
  1. maxFragmentShaderInputVariables を 1 減らす。
3. 以下のいずれかが満たされない場合、false を返す：
  - descriptor.fragment の各ユーザー定義入力に対し、 descriptor.vertex のユーザー定義出力で、その location、型、interpolation が一致するものがあること。
    
    注意: 頂点のみパイプラインでも頂点ステージでユーザー定義出力を持つことができ、その値は破棄される。
  - descriptor.fragment のユーザー定義入力の数が maxFragmentShaderInputVariables 以下であること。
4. アサート: descriptor.fragment の各ユーザー定義入力の location が device.limits.maxInterStageShaderVariables より小さい（これは上記ルールの帰結）
5. もし device.[[features]] が含まれていない場合、"core-features-and-limits":
  1. descriptor.fragment の各ユーザー定義 input について
    1. Compatibility Mode シェーダーバインディングの検証(input) が失敗したら、false を返す。
true を返す。

以下の組み込み値は、インターステージ組み込み値であり、フラグメントシェーダーで使用される場合、maxInterStageShaderVariablesの上限にカウントされる：

front_facing
sample_index
sample_mask
primitive_index
subgroup_invocation_id
subgroup_size

単純な GPURenderPipeline の作成例:

const renderPipeline = gpuDevice.createRenderPipeline({
    layout: pipelineLayout,
    vertex: {
        module: shaderModule,
        entryPoint: 'vertexMain'
    },
    fragment: {
        module: shaderModule,
        entryPoint: 'fragmentMain',
        targets: [{
            format: 'bgra8unorm',
        }],
    }
});

10.3.2. プリミティブ状態

dictionary GPUPrimitiveState {
    GPUPrimitiveTopology topology = "triangle-list";
    GPUIndexFormat stripIndexFormat;
    GPUFrontFace frontFace = "ccw";
    GPUCullMode cullMode = "none";

    // Requires "depth-clip-control" feature.
    boolean unclippedDepth = false;
};

GPUPrimitiveState には以下のメンバーがあり、GPURenderPipeline が頂点入力からプリミティブを構築しラスタライズする方法を記述します:

topology, 型 GPUPrimitiveTopology、デフォルト値 "triangle-list"

頂点入力から構築するプリミティブの種類。

stripIndexFormat, 型 GPUIndexFormat

ストリップトポロジー ("line-strip" または "triangle-strip") のパイプラインに対して、インデックスバッファのフォーマットとプリミティブリスタート値 ("uint16"/0xFFFF または "uint32"/0xFFFFFFFF) を決定します。非ストリップトポロジーのパイプラインでは指定できません。

注: 一部の実装では、プリミティブリスタート値の知識がパイプライン状態オブジェクトのコンパイルに必要です。

ストリップトポロジーのパイプラインをインデックス付きドローコール (drawIndexed() または drawIndexedIndirect()) で使う場合、これを設定する必要があり、ドローコールで使うインデックスバッファのフォーマット (setIndexBuffer() で設定) と一致しなければなりません。

詳細は § 23.2.3 プリミティブアセンブリを参照してください。

frontFace, 型 GPUFrontFace、デフォルト値 "ccw"

どのポリゴンが表面とみなされるかを定義します。

cullMode, 型 GPUCullMode、デフォルト値 "none"

どのポリゴン方向をカリングするか（除去するか）を定義します。

unclippedDepth, 型 boolean、デフォルト値 false

true の場合、深度クリッピングが無効化されます。

"depth-clip-control" 機能が有効化されている必要があります。

GPUPrimitiveState の検証(descriptor, device) 引数:

GPUPrimitiveState descriptor
GPUDevice device

Device timeline の手順：

以下すべての条件を満たせば、true を返す：
- もし descriptor.topology が "line-strip" または "triangle-strip" でない場合：
  - descriptor.stripIndexFormat は指定されていてはならない。
- もし descriptor.unclippedDepth が true なら：
  - "depth-clip-control" が device に対して有効化されている必要がある。

enum GPUPrimitiveTopology {
    "point-list",
    "line-list",
    "line-strip",
    "triangle-list",
    "triangle-strip",
};

GPUPrimitiveTopology は、GPURenderPipeline で描画コールを行う際に使用されるプリミティブタイプを定義します。詳細は § 23.2.5 ラスタライズを参照してください:

"point-list": 各頂点が点プリミティブを定義します。
"line-list": 連続する2頂点ごとに線プリミティブを定義します。
"line-strip": 2頂点目以降の各頂点が前の頂点との間に線プリミティブを定義します。
"triangle-list": 連続する3頂点ごとに三角形プリミティブを定義します。
"triangle-strip": 3頂点目以降の各頂点が前の2頂点との間に三角形プリミティブを定義します。

enum GPUFrontFace {
    "ccw",
    "cw",
};

GPUFrontFace は、GPURenderPipeline によってどのポリゴンが表面とみなされるかを定義します。詳細は § 23.2.5.4 ポリゴンラスタライズを参照してください:

"ccw": フレームバッファ座標が反時計回りに並ぶ頂点を持つポリゴンが表面とみなされます。
"cw": フレームバッファ座標が時計回りに並ぶ頂点を持つポリゴンが表面とみなされます。

enum GPUCullMode {
    "none",
    "front",
    "back",
};

GPUPrimitiveTopology は、GPURenderPipeline で描画コールを行う際にどのポリゴンがカリングされるかを定義します。詳細は § 23.2.5.4 ポリゴンラスタライズを参照してください:

"none": ポリゴンは一切破棄されません。
"front": 表面ポリゴンが破棄されます。
"back": 裏面ポリゴンが破棄されます。

注: GPUFrontFace および GPUCullMode は、"point-list"、 "line-list"、 "line-strip" トポロジーには影響しません。

10.3.3. マルチサンプル状態

dictionary GPUMultisampleState {
    GPUSize32 count = 1;
    GPUSampleMask mask = 0xFFFFFFFF;
    boolean alphaToCoverageEnabled = false;
};

GPUMultisampleState には以下のメンバーがあり、GPURenderPipeline がレンダーパスのマルチサンプル付きアタッチメントとどのように相互作用するかを記述します。

count、型 GPUSize32、デフォルト値は 1: ピクセルあたりのサンプル数。この GPURenderPipeline は、colorAttachments や depthStencilAttachment などのアタッチメントテクスチャの sampleCount が一致する場合のみ互換性を持ちます。
mask、型 GPUSampleMask、デフォルト値は 0xFFFFFFFF: どのサンプルに書き込むかを決定するマスク。
alphaToCoverageEnabled 、型 boolean、デフォルトは false: true の場合、フラグメントのアルファチャンネルを使用してサンプルカバレッジマスクを生成することを示します。

GPUMultisampleState の検証(descriptor) 引数:

GPUMultisampleState descriptor

Device timeline の手順：

次のすべての条件を満たす時、true を返す：
- descriptor.count は 1 または 4 のいずれかでなければならない。
- もし descriptor.alphaToCoverageEnabled が true の場合：
  - descriptor.count は 1 より大きい。

10.3.4. フラグメント状態

dictionary GPUFragmentState
         : GPUProgrammableStage {
    required sequence<GPUColorTargetState?> targets;
};

targets, 型 sequence<GPUColorTargetState?>: このパイプラインが書き込むカラ―ターゲットのフォーマットや動作を定義するGPUColorTargetStateのリスト。

GPUFragmentState の検証(device, descriptor, layout)

引数:

GPUDevice device
GPUFragmentState descriptor
GPUPipelineLayout layout

Device timeline の手順：

以下の要件がすべて満たされた場合 true を返す：
- GPUProgrammableStage の検証( FRAGMENT, descriptor, layout, device ) が成功すること。
- descriptor.targets.size は device.[[limits]].maxColorAttachments 以下でなければならない。
- 各シェーダーステージ出力 output について：
  - output の location は device.[[limits]].maxColorAttachments より小さくなければならない。
- entryPoint を get the entry point( FRAGMENT, descriptor ) とする。
- usesDualSourceBlending を false にする。
- 各 index について descriptor.targets 内の non-null 値 colorState を調べる：
  - colorState.format は § 26.1.1 Plain color formats で RENDER_ATTACHMENT 機能を持つものとしてリストされている必要がある。
  - colorState.writeMask は 16 未満でなければならない。
  - もし colorState.blend が指定されているなら：
    - colorState.format はブレンド可能でなければならない。
    - colorState.blend.color は有効な GPUBlendComponent でなければならない。
    - colorState.blend.alpha も有効な GPUBlendComponent でなければならない。
    - もし colorState.blend.color.srcFactor または colorState.blend.color.dstFactor または colorState.blend.alpha.srcFactor または colorState.blend.alpha.dstFactor が対応するブレンドユニットの2番目の入力（"src1", "one-minus-src1", "src1-alpha", "one-minus-src1-alpha" のいずれか）を使う場合：
      
      usesDualSourceBlending を true に設定。
  - 各シェーダーステージ出力 output で、 location が index であるものについて：
    - colorState.format の各コンポーネントごとに、output に対応するコンポーネントがなければならない（RGBAならvec4、RGBならvec3またはvec4、RGならvec2,vec3,vec4）。
    - もし GPUTextureSampleType （§ 26.1 Texture Format Capabilities）が：
      
      "float" および/または "unfilterable-float"
      
      output は浮動小数点スカラ型でなければならない。
      
      "sint"
      
      output は符号付き整数スカラ型でなければならない。
      
      "uint"
      
      output は符号なし整数スカラ型でなければならない。
    - もし colorState.blend が指定されていてかつ colorState.blend.color.srcFactor または .dstFactor が source alpha （"src-alpha", "one-minus-src-alpha", "src-alpha-saturated", "src1-alpha" , "one-minus-src1-alpha" ）なら：
      
      output はアルファチャンネルを持つ（すなわち vec4 である）こと。
  - もし colorState.writeMask が 0 でない場合：
    - entryPoint はシェーダーステージ出力を持ち、 location が index に等しく、 blend_src が省略（あるいは0）であること。
- もし usesDualSourceBlending が true なら：
  - descriptor.targets.size は 1 でなければならない。
  - entryPoint のシェーダーステージ出力のうち location を持つものは全て同一struct内で定義され、 dual source blendingを利用しなければならない。
- GPUFragmentStateのカラ―アタッチメント1サンプルあたりバイト数の検証( device, descriptor.targets ) が成功すること。
- もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  - 全ての non-null GPUColorTargetState colorState について descriptor.targets 中で次のメンバー値がすべて等しい必要がある：
    
    colorState.blend.color
    
    colorState.blend.alpha
    
    colorState.writeMask
  - シェーダーステージの関数の各 function について：
    
    function は dpdxFine、 dpdyFine、 fwidthFine を使用してはならない。

GPUFragmentStateのカラ―アタッチメント1サンプルあたりバイト数の検証(device, targets)

引数:

GPUDevice device
sequence<GPUColorTargetState?> targets

Device timeline の手順：

formats を空の list<GPUTextureFormat?> とする
各 target in targets について：
1. もし target が undefined なら continue。
2. Append target.format を formats に追加。
カラ―アタッチメント1サンプルあたりバイト数の算出(formats) が device.[[limits]].maxColorAttachmentBytesPerSample 以下でなければならない。

注意: フラグメントシェーダはパイプラインが使用する以上の値を出力することもあります。その場合、値は無視されます。

GPUBlendComponent component が論理 device device で以下の場合有効な GPUBlendComponent です：

もし component.operation が "min" または "max" なら：
- component.srcFactor および component.dstFactor の両方が "one" でなければならない。
もし component.srcFactor または component.dstFactor が GPUBlendFactor テーブルに従い機能を必要とし、かつ device.[[features]] がその機能を含まない場合：
- TypeErrorをスローする。

10.3.5. カラ―ターゲット状態

dictionary GPUColorTargetState {
    required GPUTextureFormat format;

    GPUBlendState blend;
    GPUColorWriteFlags writeMask = 0xF;  // GPUColorWrite.ALL
};

format, 型 GPUTextureFormat: このカラ―ターゲットの GPUTextureFormat。パイプラインは、対応するカラ―アタッチメントにこのフォーマットの GPUTextureView を使う GPURenderPassEncoder とだけ互換性があります。
blend, 型 GPUBlendState: このカラ―ターゲットのブレンディングの挙動。未定義の場合、ブレンディングは無効化されます。
writeMask, 型 GPUColorWriteFlags、デフォルト値 0xF: このカラ―ターゲットへの描画時に、どのチャンネルに書き込むかを制御するビットマスク。

dictionary GPUBlendState {
    required GPUBlendComponent color;
    required GPUBlendComponent alpha;
};

color, 型 GPUBlendComponent: 対応するレンダーターゲットのカラーチャンネルのブレンディング挙動を定義します。
alpha, 型 GPUBlendComponent: 対応するレンダーターゲットのアルファチャンネルのブレンディング挙動を定義します。

typedef [EnforceRange] unsigned long GPUColorWriteFlags;
[Exposed=(Window, Worker), SecureContext]
namespace GPUColorWrite {
    const GPUFlagsConstant RED   = 0x1;
    const GPUFlagsConstant GREEN = 0x2;
    const GPUFlagsConstant BLUE  = 0x4;
    const GPUFlagsConstant ALPHA = 0x8;
    const GPUFlagsConstant ALL   = 0xF;
};

10.3.5.1. ブレンド状態

dictionary GPUBlendComponent {
    GPUBlendOperation operation = "add";
    GPUBlendFactor srcFactor = "one";
    GPUBlendFactor dstFactor = "zero";
};

GPUBlendComponent には以下のメンバーがあり、フラグメントのカラーおよびアルファ成分のブレンド方法を記述します:

operation, 型 GPUBlendOperation、デフォルト値 "add": ターゲットアタッチメント成分に書き込まれる値の計算に使われる GPUBlendOperation を定義します。
srcFactor, 型 GPUBlendFactor、デフォルト値 "one": フラグメントシェーダーからの値に対して行う GPUBlendFactor の操作を定義します。
dstFactor, 型 GPUBlendFactor、デフォルト値 "zero": ターゲットアタッチメントからの値に対して行う GPUBlendFactor の操作を定義します。

以下の表は、あるフラグメント位置でのカラー成分を記述するための記法を示します：

`RGBA_src`	カラ―アタッチメントに対してフラグメントシェーダーが出力したカラー。シェーダーがアルファチャンネルを返さない場合、src-alpha ブレンドファクターは使用できません。
`RGBA_src1`	カラ―アタッチメントに対して、"@blend_src" 属性が `1` のフラグメントシェーダーのカラー出力。シェーダーがアルファチャンネルを返さない場合、src1-alpha ブレンドファクターは使用できません。
`RGBA_dst`	カラ―アタッチメントに現在入っているカラー。グリーン/ブルー/アルファチャンネルがない場合は、デフォルトで `0, 0, 1` となります。
`RGBA_const`	現在の `[[blendConstant]]`。
`RGBA_srcFactor`	`srcFactor` で定義されたソースブレンドファクター成分。
`RGBA_dstFactor`	`dstFactor` で定義されたデスティネーションブレンドファクター成分。

enum GPUBlendFactor {
    "zero",
    "one",
    "src",
    "one-minus-src",
    "src-alpha",
    "one-minus-src-alpha",
    "dst",
    "one-minus-dst",
    "dst-alpha",
    "one-minus-dst-alpha",
    "src-alpha-saturated",
    "constant",
    "one-minus-constant",
    "src1",
    "one-minus-src1",
    "src1-alpha",
    "one-minus-src1-alpha",
};

GPUBlendFactor はソースまたはデスティネーションのブレンドファクターがどのように計算されるかを定義します：

GPUBlendFactor	ブレンドファクター RGBA 成分	機能
`"zero"`	`(0, 0, 0, 0)`
`"one"`	`(1, 1, 1, 1)`
`"src"`	`(R_src, G_src, B_src, A_src)`
`"one-minus-src"`	`(1 - R_src, 1 - G_src, 1 - B_src, 1 - A_src)`
`"src-alpha"`	`(A_src, A_src, A_src, A_src)`
`"one-minus-src-alpha"`	`(1 - A_src, 1 - A_src, 1 - A_src, 1 - A_src)`
`"dst"`	`(R_dst, G_dst, B_dst, A_dst)`
`"one-minus-dst"`	`(1 - R_dst, 1 - G_dst, 1 - B_dst, 1 - A_dst)`
`"dst-alpha"`	`(A_dst, A_dst, A_dst, A_dst)`
`"one-minus-dst-alpha"`	`(1 - A_dst, 1 - A_dst, 1 - A_dst, 1 - A_dst)`
`"src-alpha-saturated"`	`(min(A_src, 1 - A_dst), min(A_src, 1 - A_dst), min(A_src, 1 - A_dst), 1)`
`"constant"`	`(R_const, G_const, B_const, A_const)`
`"one-minus-constant"`	`(1 - R_const, 1 - G_const, 1 - B_const, 1 - A_const)`
`"src1"`	`(R_src1, G_src1, B_src1, A_src1)`	`dual-source-blending`
`"one-minus-src1"`	`(1 - R_src1, 1 - G_src1, 1 - B_src1, 1 - A_src1)`
`"src1-alpha"`	`(A_src1, A_src1, A_src1, A_src1)`
`"one-minus-src1-alpha"`	`(1 - A_src1, 1 - A_src1, 1 - A_src1, 1 - A_src1)`

enum GPUBlendOperation {
    "add",
    "subtract",
    "reverse-subtract",
    "min",
    "max",
};

GPUBlendOperation はソースとデスティネーションのブレンドファクターを組み合わせるアルゴリズムを定義します：

GPUBlendOperation	RGBA成分
`"add"`	`RGBA_src × RGBA_srcFactor + RGBA_dst × RGBA_dstFactor`
`"subtract"`	`RGBA_src × RGBA_srcFactor - RGBA_dst × RGBA_dstFactor`
`"reverse-subtract"`	`RGBA_dst × RGBA_dstFactor - RGBA_src × RGBA_srcFactor`
`"min"`	`min(RGBA_src, RGBA_dst)`
`"max"`	`max(RGBA_src, RGBA_dst)`

10.3.6. デプス・ステンシル状態

dictionary GPUDepthStencilState {
    required GPUTextureFormat format;

    boolean depthWriteEnabled;
    GPUCompareFunction depthCompare;

    GPUStencilFaceState stencilFront = {};
    GPUStencilFaceState stencilBack = {};

    GPUStencilValue stencilReadMask = 0xFFFFFFFF;
    GPUStencilValue stencilWriteMask = 0xFFFFFFFF;

    GPUDepthBias depthBias = 0;
    float depthBiasSlopeScale = 0;
    float depthBiasClamp = 0;
};

GPUDepthStencilState には以下のメンバーがあり、GPURenderPipeline がレンダーパスのdepthStencilAttachment にどのような影響を与えるかを記述します:

format, 型 GPUTextureFormat: このGPURenderPipeline が互換性を持つdepthStencilAttachment のformat。
depthWriteEnabled, 型 boolean: このGPURenderPipeline がdepthStencilAttachment の深度値を書き換えることができるかを示します。
depthCompare, 型 GPUCompareFunction: フラグメントの深度値をdepthStencilAttachment の深度値と比較するための演算方法。
stencilFront, 型 GPUStencilFaceState、デフォルト値 {}: 表面プリミティブに対してステンシル比較・操作をどのように行うかを定義します。
stencilBack, 型 GPUStencilFaceState、デフォルト値 {}: 裏面プリミティブに対してステンシル比較・操作をどのように行うかを定義します。
stencilReadMask, 型 GPUStencilValue、デフォルト値 0xFFFFFFFF: ステンシル比較テストを行う際に、どのdepthStencilAttachment のステンシル値ビットを読み取るかを制御するビットマスク。
stencilWriteMask, 型 GPUStencilValue、デフォルト値 0xFFFFFFFF: ステンシル操作を行う際に、どのdepthStencilAttachment のステンシル値ビットに書き込むかを制御するビットマスク。
depthBias, 型 GPUDepthBias、デフォルト値 0: 各三角形フラグメントに加算される定数深度バイアス。詳細はバイアス付きフラグメント深度参照。
depthBiasSlopeScale, 型 float、デフォルト値 0: 三角形フラグメントの傾きに応じてスケールされる深度バイアス。詳細はバイアス付きフラグメント深度参照。
depthBiasClamp, 型 float、デフォルト値 0: 三角形フラグメントの最大深度バイアス。詳細はバイアス付きフラグメント深度参照。

注: depthBias、 depthBiasSlopeScale、および depthBiasClamp は"point-list"、 "line-list"、 "line-strip" プリミティブには効果がなく、0でなければなりません。

バイアス付きフラグメント深度は、depthStencilAttachment attachmentに対して GPUDepthStencilState stateを使って描画する際、以下のキュータイムラインの手順で計算されます：

format を attachment.view.format とする。
r を format における0より大きい最小の正の表現可能値（32ビットfloatに変換）とする。
maxDepthSlope をフラグメントの深度値の水平・垂直方向の最大傾きとする。
format がunormフォーマットの場合:
1. bias を (float)state.depthBias * r + state.depthBiasSlopeScale * maxDepthSlope とする。
それ以外でformatがfloatフォーマットの場合:
1. bias を (float)state.depthBias * 2^(exp(max depth in primitive) - r) + state.depthBiasSlopeScale * maxDepthSlope とする。
state.depthBiasClamp > 0 の場合:
1. bias を min(state.depthBiasClamp, bias) とする。
それ以外で,state.depthBiasClamp < 0 の場合:
1. bias を max(state.depthBiasClamp, bias) とする。
state.depthBias ≠ 0 または state.depthBiasSlopeScale ≠ 0 の場合:
1. フラグメントの深度値に fragment depth value + bias を設定する。

GPUDepthStencilState の検証(device, descriptor, topology)

引数:

GPUDevice device
GPUDepthStencilState descriptor
GPUPrimitiveTopology topology

Device timeline の手順：

次のすべての条件が満たされる場合に限り、true を返す：
- descriptor.format は depth-or-stencil format である。
- もし descriptor.depthWriteEnabled が true であるか、 descriptor.depthCompare が指定されていてかつ "always" でない場合：
  - descriptor.format は depth コンポーネントを持たなければならない。
- もし descriptor.stencilFront または descriptor.stencilBack がデフォルト値でない場合：
  - descriptor.format は stencil コンポーネントを持たなければならない。
- もし descriptor.format が depth コンポーネントを持つ場合：
  - descriptor.depthWriteEnabled は指定されている必要がある。
  - 以下のいずれかの場合には descriptor.depthCompare が指定されていなければならない：
    - descriptor.depthWriteEnabled が true である場合
    - descriptor.stencilFront.depthFailOp が "keep" でない場合
    - descriptor.stencilBack.depthFailOp が "keep" でない場合
- もし topology が "point-list", "line-list", または "line-strip" の場合：
  - descriptor.depthBias は 0 でなければならない。
  - descriptor.depthBiasSlopeScale は 0 でなければならない。
  - descriptor.depthBiasClamp は 0 でなければならない。
- もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  - descriptor.depthBiasClamp は 0 でなければなりません。

dictionary GPUStencilFaceState {
    GPUCompareFunction compare = "always";
    GPUStencilOperation failOp = "keep";
    GPUStencilOperation depthFailOp = "keep";
    GPUStencilOperation passOp = "keep";
};

GPUStencilFaceState には以下のメンバーがあり、ステンシル比較と操作の方法を記述します:

compare, 型 GPUCompareFunction、デフォルト値 "always": フラグメントのdepthStencilAttachmentのステンシル値に対して [[stencilReference]] の値をテストする際に使用されるGPUCompareFunction。
failOp, 型 GPUStencilOperation、デフォルト値 "keep": compare で記述されるフラグメントステンシル比較テストに失敗した場合に実行されるGPUStencilOperation。
depthFailOp, 型 GPUStencilOperation、デフォルト値 "keep": depthCompare で記述されるフラグメント深度比較に失敗した場合に実行されるGPUStencilOperation。
passOp, 型 GPUStencilOperation、デフォルト値 "keep": compare で記述されるフラグメントステンシル比較テストに成功した場合に実行されるGPUStencilOperation。

enum GPUStencilOperation {
    "keep",
    "zero",
    "replace",
    "invert",
    "increment-clamp",
    "decrement-clamp",
    "increment-wrap",
    "decrement-wrap",
};

GPUStencilOperation では以下の操作を定義します:

"keep": 現在のステンシル値を保持します。
"zero": ステンシル値を 0 に設定します。
"replace": ステンシル値を [[stencilReference]] に設定します。
"invert": 現在のステンシル値をビット反転します。
"increment-clamp": 現在のステンシル値をインクリメントし、depthStencilAttachmentのステンシルアスペクトの最大表現値までクランプします。
"decrement-clamp": 現在のステンシル値をデクリメントし、0までクランプします。
"increment-wrap": 現在のステンシル値をインクリメントし、値が最大表現値を超えた場合はゼロにラップします（depthStencilAttachmentのステンシルアスペクト）。
"decrement-wrap": 現在のステンシル値をデクリメントし、値が0未満になった場合は depthStencilAttachmentのステンシルアスペクトの最大表現値にラップします。

10.3.7. バーテックス状態

enum GPUIndexFormat {
    "uint16",
    "uint32",
};

インデックスフォーマットは、バッファ内のインデックス値のデータ型を決定し、ストリッププリミティブトポロジー ("line-strip" または "triangle-strip") で使用される場合は、プリミティブリスタート値も指定します。プリミティブリスタート値は、どのインデックス値が新しいプリミティブの開始を示すか（以前のインデックス頂点でストリップを継続するのではなく）を示します。

GPUPrimitiveState でストリッププリミティブトポロジーを指定する場合、インデックス付き描画に使う場合は stripIndexFormat を必ず指定し、パイプライン生成時に使用されるプリミティブリスタート値が分かるようにします。 GPUPrimitiveState でリストトポロジーを指定する場合は、インデックス付き描画時にsetIndexBuffer() で渡したインデックスフォーマットを使います。

インデックスフォーマット	バイトサイズ	プリミティブリスタート値
`"uint16"`	2	0xFFFF
`"uint32"`	4	0xFFFFFFFF

10.3.7.1. バーテックスフォーマット

GPUVertexFormat はバーテックス属性のデータがバーテックスバッファからどのように解釈・シェーダーへ公開されるかを示します。フォーマット名は成分の順序、各成分のビット数、および成分のバーテックスデータ型を指定します。

各バーテックスデータ型は、ビット数に関係なく、同じ基本型のWGSLスカラー型にマッピングできます：

バーテックスフォーマット接頭辞	バーテックスデータ型	対応するWGSL型
`uint`	符号なし整数	`u32`
`sint`	符号付き整数	`i32`
`unorm`	符号なし正規化	`f16`, `f32`
`snorm`	符号付き正規化
`float`	浮動小数点

複数成分フォーマットでは "x" の後の数字が成分数を示します。バーテックスフォーマットとシェーダー型の成分数が一致しない場合は、成分が切り捨てられるかデフォルト値で埋められます。

フォーマットが "unorm8x2" のバーテックス属性と、バイト値 [0x7F, 0xFF] を持つ場合、シェーダーでは以下の型でアクセスできます：

シェーダー型	シェーダー値
`f16`	`0.5h`
`f32`	`0.5f`
`vec2<f16>`	`vec2(0.5h, 1.0h)`
`vec2<f32>`	`vec2(0.5f, 1.0f)`
`vec3<f16>`	`vec2(0.5h, 1.0h, 0.0h)`
`vec3<f32>`	`vec2(0.5f, 1.0f, 0.0f)`
`vec4<f16>`	`vec2(0.5h, 1.0h, 0.0h, 1.0h)`
`vec4<f32>`	`vec2(0.5f, 1.0f, 0.0f, 1.0f)`

バーテックスフォーマットがシェーダーでどのように公開されるかは § 23.2.2 バーテックス処理を参照してください。

enum GPUVertexFormat {
    "uint8",
    "uint8x2",
    "uint8x4",
    "sint8",
    "sint8x2",
    "sint8x4",
    "unorm8",
    "unorm8x2",
    "unorm8x4",
    "snorm8",
    "snorm8x2",
    "snorm8x4",
    "uint16",
    "uint16x2",
    "uint16x4",
    "sint16",
    "sint16x2",
    "sint16x4",
    "unorm16",
    "unorm16x2",
    "unorm16x4",
    "snorm16",
    "snorm16x2",
    "snorm16x4",
    "float16",
    "float16x2",
    "float16x4",
    "float32",
    "float32x2",
    "float32x3",
    "float32x4",
    "uint32",
    "uint32x2",
    "uint32x3",
    "uint32x4",
    "sint32",
    "sint32x2",
    "sint32x3",
    "sint32x4",
    "unorm10-10-10-2",
    "unorm8x4-bgra",
};

バーテックスフォーマット	データ型	成分数	バイトサイズ	WGSL型例
`"uint8"`	符号なし整数	1	1	`u32`
`"uint8x2"`	符号なし整数	2	2	`vec2<u32>`
`"uint8x4"`	符号なし整数	4	4	`vec4<u32>`
`"sint8"`	符号付き整数	1	1	`i32`
`"sint8x2"`	符号付き整数	2	2	`vec2<i32>`
`"sint8x4"`	符号付き整数	4	4	`vec4<i32>`
`"unorm8"`	符号なし正規化	1	1	`f32`
`"unorm8x2"`	符号なし正規化	2	2	`vec2<f32>`
`"unorm8x4"`	符号なし正規化	4	4	`vec4<f32>`
`"snorm8"`	符号付き正規化	1	1	`f32`
`"snorm8x2"`	符号付き正規化	2	2	`vec2<f32>`
`"snorm8x4"`	符号付き正規化	4	4	`vec4<f32>`
`"uint16"`	符号なし整数	1	2	`u32`
`"uint16x2"`	符号なし整数	2	4	`vec2<u32>`
`"uint16x4"`	符号なし整数	4	8	`vec4<u32>`
`"sint16"`	符号付き整数	1	2	`i32`
`"sint16x2"`	符号付き整数	2	4	`vec2<i32>`
`"sint16x4"`	符号付き整数	4	8	`vec4<i32>`
`"unorm16"`	符号なし正規化	1	2	`f32`
`"unorm16x2"`	符号なし正規化	2	4	`vec2<f32>`
`"unorm16x4"`	符号なし正規化	4	8	`vec4<f32>`
`"snorm16"`	符号付き正規化	1	2	`f32`
`"snorm16x2"`	符号付き正規化	2	4	`vec2<f32>`
`"snorm16x4"`	符号付き正規化	4	8	`vec4<f32>`
`"float16"`	浮動小数点	1	2	`f32`
`"float16x2"`	浮動小数点	2	4	`vec2<f16>`
`"float16x4"`	浮動小数点	4	8	`vec4<f16>`
`"float32"`	浮動小数点	1	4	`f32`
`"float32x2"`	浮動小数点	2	8	`vec2<f32>`
`"float32x3"`	浮動小数点	3	12	`vec3<f32>`
`"float32x4"`	浮動小数点	4	16	`vec4<f32>`
`"uint32"`	符号なし整数	1	4	`u32`
`"uint32x2"`	符号なし整数	2	8	`vec2<u32>`
`"uint32x3"`	符号なし整数	3	12	`vec3<u32>`
`"uint32x4"`	符号なし整数	4	16	`vec4<u32>`
`"sint32"`	符号付き整数	1	4	`i32`
`"sint32x2"`	符号付き整数	2	8	`vec2<i32>`
`"sint32x3"`	符号付き整数	3	12	`vec3<i32>`
`"sint32x4"`	符号付き整数	4	16	`vec4<i32>`
`"unorm10-10-10-2"`	符号なし正規化	4	4	`vec4<f32>`
`"unorm8x4-bgra"`	符号なし正規化	4	4	`vec4<f32>`

enum GPUVertexStepMode {
    "vertex",
    "instance",
};

ステップモードは、現在のバーテックスまたはインスタンスインデックスに基づいて、バーテックスバッファデータのアドレス計算方法を設定します:

"vertex": 各バーテックスごとにarrayStride でアドレスが進み、インスタンスごとにリセットされます。
"instance": 各インスタンスごとにarrayStride でアドレスが進みます。

dictionary GPUVertexState
         : GPUProgrammableStage {
    sequence<GPUVertexBufferLayout?> buffers = [];
};

buffers, 型 sequence<GPUVertexBufferLayout?>、デフォルト値 []: このパイプラインで使用するバーテックスバッファのバーテックス属性データのレイアウトを定義する GPUVertexBufferLayout のリスト。

バーテックスバッファは概念的にはバッファメモリへの構造体の配列としてのビューです。 arrayStride は、その配列の要素間のバイト単位のストライドです。バーテックスバッファの各要素は、メモリレイアウトが attributes で定義された構造体のようなもので、それぞれが構造体のメンバーとなります。

各GPUVertexAttribute は format と offset (バイト単位) を構造体内の位置として記述します。

各属性はバーテックスシェーダーで個別の入力として表れ、それぞれ数値のlocationにバインドされます。このlocationはshaderLocation で指定され、GPUVertexState 内で一意でなければなりません。

dictionary GPUVertexBufferLayout {
    required GPUSize64 arrayStride;
    GPUVertexStepMode stepMode = "vertex";
    required sequence<GPUVertexAttribute> attributes;
};

arrayStride, 型 GPUSize64: この配列の要素間のバイト単位のストライド。
stepMode, 型 GPUVertexStepMode、デフォルト値 "vertex": この配列の各要素が頂点ごとのデータかインスタンスごとのデータか。
attributes, 型 sequence<GPUVertexAttribute>: 各要素内のバーテックス属性のレイアウトを定義する配列。

dictionary GPUVertexAttribute {
    required GPUVertexFormat format;
    required GPUSize64 offset;

    required GPUIndex32 shaderLocation;
};

format, 型 GPUVertexFormat: この属性のGPUVertexFormat。
offset, 型 GPUSize64: その属性のデータが要素の先頭から何バイト目か。
shaderLocation, 型 GPUIndex32: この属性に関連付けられる数値のlocationで、vertex.module で宣言する "@location" 属性に対応します。

GPUVertexBufferLayout の検証(device, descriptor)

引数:

GPUDevice device
GPUVertexBufferLayout descriptor

Device timeline の手順：

以下すべての条件を満たした場合に限り、true を返す：
- descriptor.arrayStride ≤ device.[[device]].[[limits]].maxVertexBufferArrayStride。
- descriptor.arrayStride は4の倍数でなければならない。
- descriptor.attributes のリスト内の各属性 attrib について：
  - もし descriptor.arrayStride がゼロの場合：
    - attrib.offset + byteSize(attrib.format) ≤ device.[[device]].[[limits]].maxVertexBufferArrayStride。
    それ以外の場合：
    - attrib.offset + byteSize(attrib.format) ≤ descriptor.arrayStride。
  - attrib.offset は 4 と byteSize(attrib.format) の小さい方の倍数でなければならない。
  - attrib.shaderLocation は device.[[device]].[[limits]].maxVertexAttributes より小さくなければならない。

GPUVertexState の検証(device, descriptor, layout)

引数:

GPUDevice device
GPUVertexState descriptor
GPUPipelineLayout layout

Device timeline の手順：

entryPoint を get the entry point(VERTEX, descriptor) とする。
アサート entryPoint が null でない。
以下の手順の要件がすべて満たされる必要がある。
1. GPUProgrammableStage の検証(VERTEX, descriptor, layout, device) が成功しなければならない。
2. descriptor.buffers.size が device.[[device]].[[limits]].maxVertexBuffers 以下でなければならない。
3. descriptor.buffers の各 vertexBuffer レイアウト記述は GPUVertexBufferLayout の検証(device, vertexBuffer) に合格しなければならない。
4. totalEffectiveVertexAttributes を descriptor.buffers 内の全ての vertexBuffer の attributes.size の合計とする。
5. もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  1. もし vertex_index 組み込みが descriptor.vertex のシェーダーステージ入力の場合：
    
    totalEffectiveVertexAttributes に 1 を加算する。
  2. もし instance_index 組み込みが descriptor.vertex のシェーダーステージ入力の場合：
    
    totalEffectiveVertexAttributes に 1 を加算する。
6. totalEffectiveVertexAttributes は device.[[device]].[[limits]].maxVertexAttributes 以下でなければならない。
7. entryPoint により静的に使用される各頂点属性宣言（location location、型 T）について、 descriptor.buffers[i]? .attributes[j].shaderLocation == location となる組 (i, j) がちょうど1つ存在しなければならない。
  
  その GPUVertexAttribute を attrib とする。
8. T は attrib.format の vertex data type と互換でなければならない：
  
  "unorm", "snorm", "float"
  
  T は f32 または vecN<f32>。
  
  "uint"
  
  T は u32 または vecN<u32>。
  
  "sint"
  
  T は i32 または vecN<i32>。

11. コピー

11.1. バッファコピー

バッファコピー操作は生のバイト単位で行われます。

WebGPUは「バッファ化」された GPUCommandEncoder コマンドを提供します:

copyBufferToBuffer()
clearBuffer()

および「即時」 GPUQueue 操作:

writeBuffer() （ArrayBufferからGPUBufferへの書き込み）

11.2. テクセルコピー

テクセルコピー操作はバイトではなくテクスチャ/「画像」データを操作します。

WebGPU は「バッファ化された」 GPUCommandEncoder コマンドを提供します：

copyTextureToTexture()
copyBufferToTexture()
copyTextureToBuffer()

および「即時」の GPUQueue 操作：

writeTexture(), ArrayBuffer から ArrayBuffer から GPUTexture への書き込み用
copyExternalImageToTexture(), Web プラットフォームの画像ソースからテクスチャへのコピー用

テクセルコピーでは、宛先のテクセルブロックに書き込まれるバイトは、ソースの値と同等の同等のテクセル表現を持ちます。

テクセルコピーは、ソース内の有効で有限かつ非サブノーマルな数値が宛先で同じ数値になることのみを保証します。具体的には、テクセルブロックはそれらの値のみを保持するようにデコードされ再エンコードされる場合があります。複数のバイト表現が可能な場合、表現の選択は実装依存です。

任意の浮動小数点のゼロ値は -0.0 または +0.0 のいずれかで表現される可能性があります。
任意の浮動小数点のサブノーマル値は保持されるか -0.0 または +0.0 に置き換えられる可能性があります。
任意の浮動小数点の NaN または Infinity の値は、不定値に置き換えられる可能性があります。
パック形式や snorm 形式は、表現される値が上記の規則に従う限りビット表現を変更する場合があります。例えば：
- snorm 形式は -1.0 を -127 または -128 として表現することがあり得ます。
- 例えば "rgb9e5ufloat" のようなフォーマットは、いくつかの値に対して複数のビット表現を持つことがあります。

注： RENDER_ATTACHMENT または STORAGE_BINDING をサポートするフォーマットでは、これは WGSL シェーダーを使用してテクスチャに書き込むことに類似していると考えられ、実装としてそのように行われる場合があります。一般に、WGSL の浮動小数点挙動が観測されることがあります。

以下の定義がこれらのメソッドで使われます：

11.2.1. `GPUTexelCopyBufferLayout`

"GPUTexelCopyBufferLayout" はバイト配列（GPUBuffer または AllowSharedBufferSource）の中のテクセルのレイアウトを "テクセルコピー"操作で記述します。

dictionary GPUTexelCopyBufferLayout {
    GPUSize64 offset = 0;
    GPUSize32 bytesPerRow;
    GPUSize32 rowsPerImage;
};

テクセル画像は1つ以上のテクセルブロックの行から構成され、ここではテクセルブロック行と呼びます。各テクセルブロック行は同じ数のテクセルブロックを含み、 1つのテクセル画像内のすべてのテクセルブロックは同じGPUTextureFormatです。

GPUTexelCopyBufferLayout は、線形メモリ内のテクセル画像のレイアウトです。テクスチャとGPUBuffer間でデータをコピーする場合や、 GPUQueueからテクスチャに書き込む場合に使用されます。

2d テクスチャの場合、データは 1つまたは複数連続したテクセルイメージとアレイレイヤー間でコピーされます。
3d テクスチャの場合、データは 1つまたは複数連続したテクセルイメージと深さ方向のスライス間でコピーされます。

バイト配列とテクスチャ間のコピー操作は常にテクセルブロック単位で行われます。テクセルブロックの一部だけを更新することはできません。

テクセルブロックは、各テクセルブロック行内にリニアメモリレイアウトで詰めて格納され、テクセルコピー時は各テクセルブロックが直ちに前のテクセルブロックの後ろに続き、パディングはありません。これは特定アスペクトの depth-or-stencil format テクスチャへのコピー・コピー元にも当てはまります。ステンシル値はバイト配列上に隙間なく詰められます。デプス値は（"depth16unorm" や "depth32float" のような）適切な型の配列として詰められます。

offset、型は GPUSize64、デフォルトは 0

テクセルデータソース（たとえば GPUTexelCopyBufferInfo.buffer など）の先頭から、その中のテクセルデータ開始までのバイト単位のオフセット。

bytesPerRow、型は GPUSize32

各テクセルブロック行の先頭から次のテクセルブロック行までのバイト単位のストライド。

複数のテクセルブロック行（すなわちコピーの高さまたは深さが1ブロックを超える場合）に必要です。

rowsPerImage、型は GPUSize32

1つのテクセルイメージ（テクスチャの）あたりのテクセルブロック行の数。 rowsPerImage × bytesPerRow がデータの各テクセルイメージ先頭から次のテクセルイメージ先頭までのストライド（バイト単位）となります。

複数のテクセルイメージ（コピー先・元の深さが1を超える場合）に必要です。

11.2.2. `GPUTexelCopyBufferInfo`

"GPUTexelCopyBufferInfo" は「info」（GPUBufferと GPUTexelCopyBufferLayout）を "テクセルコピー"操作のバッファのソースまたはデスティネーションとして記述します。 copySizeと合わせて、GPUBuffer内のテクセル領域のフットプリントを記述します。

dictionary GPUTexelCopyBufferInfo
         : GPUTexelCopyBufferLayout {
    required GPUBuffer buffer;
};

buffer, 型 GPUBuffer: コピーされるテクセルデータを保持する、またはコピー後のテクセルデータが格納されるバッファ（メソッドにより異なる）。

GPUTexelCopyBufferInfo の検証

引数:

GPUTexelCopyBufferInfo imageCopyBuffer

戻り値: boolean

デバイスタイムラインの手順:

次のすべての条件が満たされた場合に限り、true を返す：
- imageCopyBuffer.buffer は有効な GPUBuffer でなければならない。
- imageCopyBuffer.bytesPerRow は256の倍数でなければならない。

11.2.3. `GPUTexelCopyTextureInfo`

"GPUTexelCopyTextureInfo" は「info」（GPUTextureなど）を "テクセルコピー"操作のテクスチャのソースまたはデスティネーションとして記述します。 copySizeと合わせて、テクスチャのサブ領域（同じミップマップレベル上の1つ以上の連続したテクスチャサブリソース）を記述します。

dictionary GPUTexelCopyTextureInfo {
    required GPUTexture texture;
    GPUIntegerCoordinate mipLevel = 0;
    GPUOrigin3D origin = {};
    GPUTextureAspect aspect = "all";
};

texture, 型 GPUTexture: コピー元またはコピー先のテクスチャ。
mipLevel, 型 GPUIntegerCoordinate、デフォルト値 0: コピー元またはコピー先のtextureのミップマップレベル。
origin, 型 GPUOrigin3D、デフォルト値 {}: コピーの原点（コピー元またはコピー先のテクスチャサブ領域の最小コーナー）。 copySizeと合わせてコピーサブ領域全体を定義します。
aspect, 型 GPUTextureAspect、デフォルト値 "all": コピー元またはコピー先のtextureのどのアスペクトをコピーするかを定義します。

テクスチャコピーサブリージョンは、depth sliceまたはarray layer index の GPUTexelCopyTextureInfo copyTextureについて、以下の手順で決定されます：

texture を copyTexture.texture とします。
texture.dimension が次のいずれかの場合：
1d
1. アサート index は 0
2. depthSliceOrLayer を texture とする
2d

depthSliceOrLayer を texture のarray layer index とする

3d

depthSliceOrLayer を texture のdepth slice index とする
textureMip を depthSliceOrLayer のmip level copyTexture.mipLevel とする。
textureMip のaspect copyTexture.aspect を返す。

テクセルブロックのバイトオフセットは、GPUTexelCopyBufferLayout bufferLayout で記述されるデータが、テクセルブロック x, y および depth slice または array layer z の GPUTexture texture であるとき、以下の手順で求めます：

blockBytes を texture.format のテクセルブロックコピーフットプリントとする。
imageOffset を (z × bufferLayout.rowsPerImage × bufferLayout.bytesPerRow) + bufferLayout.offset とする。
rowOffset を (y × bufferLayout.bytesPerRow) + imageOffset とする。
blockOffset を (x × blockBytes) + rowOffset とする。
blockOffset を返す。

GPUTexelCopyTextureInfo の検証(texelCopyTextureInfo, copySize)

引数:

GPUTexelCopyTextureInfo texelCopyTextureInfo
GPUExtent3D copySize

戻り値: boolean

デバイスタイムラインの手順：

blockWidth を texelCopyTextureInfo.texture.format のテクセルブロック幅とする。
blockHeight を texelCopyTextureInfo.texture.format のテクセルブロック高さとする。
次のすべてが成り立つ場合に限り true を返す：
- テクスチャコピー範囲の検証(texelCopyTextureInfo, copySize) が true を返す。
- texelCopyTextureInfo.texture は有効な GPUTexture でなければならない。
- texelCopyTextureInfo.mipLevel は texelCopyTextureInfo.texture.mipLevelCount より小さくなければならない。
- texelCopyTextureInfo.origin.x は blockWidth の倍数でなければならない。
- texelCopyTextureInfo.origin.y は blockHeight の倍数でなければならない。
- 次のいずれかの場合に、texelCopyTextureInfo の物理サブリソースサイズが copySize に一致する：
  - texelCopyTextureInfo.texture.format がデプスステンシルフォーマットである。
  - texelCopyTextureInfo.texture.sampleCount > 1.

テクスチャ・バッファコピーの検証(texelCopyTextureInfo, bufferLayout, dataLength, copySize, textureUsage, aligned)

引数:

GPUTexelCopyTextureInfo texelCopyTextureInfo
GPUTexelCopyBufferLayout bufferLayout
GPUSize64Out dataLength
GPUExtent3D copySize
GPUTextureUsage textureUsage
boolean aligned

戻り値: boolean

デバイスタイムラインの手順：

texture を texelCopyTextureInfo.texture とする。
aspectSpecificFormat ＝ texture.format とする。
offsetAlignment ＝ texture.format のテクセルブロックコピーフットプリント。
次のすべてが満たされる場合のみ true を返す：
1. GPUTexelCopyTextureInfo の検証(texelCopyTextureInfo, copySize) が true を返す。
2. texture.sampleCount は 1 である。
3. texture.usage が textureUsage を含む。
4. もし texture.format がデプスまたはステンシルフォーマットの場合：
  1. texelCopyTextureInfo.aspect は texture.format の単一のアスペクトを参照しなければならない。
  2. もし textureUsage が次のいずれか：
    
    COPY_SRC
    
    そのアスペクトは § 26.1.2 Depth-stencil formats に従い、有効な texel copy ソースであること。
    
    COPY_DST
    
    そのアスペクトは § 26.1.2 Depth-stencil formats に従い、有効な texel copy 書き込み先であること。
  3. aspectSpecificFormat をアスペクト固有のフォーマットに § 26.1.2 Depth-stencil formatsに従い設定する。
  4. offsetAlignment を4に設定する。
5. もし aligned が true なら：
  1. bufferLayout.offset は offsetAlignment の倍数であること。
6. リニアテクスチャデータの検証(bufferLayout, dataLength, aspectSpecificFormat, copySize) が成功すること。

11.2.4. `GPUCopyExternalImageDestInfo`

WebGPUのテクスチャは生の数値データを保持しており、色を説明するセマンティックなメタデータはタグ付けされていません。ただし、copyExternalImageToTexture() は色情報を持つソースからコピーを行います。

「GPUCopyExternalImageDestInfo」は、「copyExternalImageToTexture()」操作の「dest」すなわち「宛先」に関する「info」を表します。これはGPUTexelCopyTextureInfo であり、さらに色空間／エンコーディングおよびアルファプリマルチプライ情報のメタデータがタグ付けされているため、コピー時にセマンティックな色データが保持されます。このメタデータはコピー操作の意味論のみに影響し、宛先となるテクスチャオブジェクト自体の状態や意味論には影響しません。

dictionary GPUCopyExternalImageDestInfo
         : GPUTexelCopyTextureInfo {
    PredefinedColorSpace colorSpace = "srgb";
    boolean premultipliedAlpha = false;
};

colorSpace、型は PredefinedColorSpace、デフォルトは "srgb"

宛先テクスチャへデータをエンコードする際に使われる色空間とエンコーディングを記述します。

この変換により、フォーマットが表現できる場合は [0, 1] の範囲外の値がターゲットテクスチャに書き込まれる場合があります。そうでない場合、結果はターゲットテクスチャフォーマットの範囲にクランプされます。

注： colorSpace がソース画像と一致している場合、変換は不要かもしれません。§ 3.11.2 色空間変換の省略を参照してください。

premultipliedAlpha、型は boolean、デフォルトは false

テクスチャに書き込まれるデータのRGBチャンネルが、アルファチャンネルでプリマルチプライされるかどうかを記述します。

このオプションが true かつ source もプリマルチプライされている場合、対応するアルファ値を超えていてもソースのRGB値は保持されなければなりません。

注： premultipliedAlpha がソース画像と一致している場合、変換は不要かもしれません。§ 3.11.2 色空間変換の省略を参照してください。

11.2.5. `GPUCopyExternalImageSourceInfo`

「GPUCopyExternalImageSourceInfo」は、「copyExternalImageToTexture()」操作の「source」すなわち「ソース」に関する「info」を表します。

typedef (ImageBitmap or
         ImageData or
         HTMLImageElement or
         HTMLVideoElement or
         VideoFrame or
         HTMLCanvasElement or
         OffscreenCanvas) GPUCopyExternalImageSource;

dictionary GPUCopyExternalImageSourceInfo {
    required GPUCopyExternalImageSource source;
    GPUOrigin2D origin = {};
    boolean flipY = false;
};

GPUCopyExternalImageSourceInfo には以下のメンバーがあります:

source, 型 GPUCopyExternalImageSource

テクセルコピーのソース。コピー元データはcopyExternalImageToTexture() 発行時点でキャプチャされます。ソースサイズは外部ソース寸法の表に従って決まります。

origin, 型 GPUOrigin2D、デフォルト値 {}

コピーの原点（コピー元サブ領域の最小（左上）コーナー）。 copySizeと合わせてコピーサブ領域全体を定義します。

flipY, 型 boolean、デフォルト値 false

ソース画像が垂直方向に反転されるか否かを記述します。

このオプションがtrueの場合、コピーは上下逆転されます（ソース領域の最下行がコピー先領域の最初の行になる等）。 origin オプションは依然としてソース画像の左上基準で、下方向に増加します。

外部ソースをテクスチャの作成やコピー時に使う場合、外部ソース寸法はソースタイプごとに以下の表で定義されます:

外部ソース型	寸法
`ImageBitmap`	`ImageBitmap.width`, `ImageBitmap.height`
`HTMLImageElement`	`HTMLImageElement.naturalWidth`, `HTMLImageElement.naturalHeight`
`HTMLVideoElement`	フレームの本来の幅, フレームの本来の高さ
`VideoFrame`	`VideoFrame.displayWidth`, `VideoFrame.displayHeight`
`ImageData`	`ImageData.width`, `ImageData.height`
`HTMLCanvasElement` または `OffscreenCanvas` （`CanvasRenderingContext2D` または `GPUCanvasContext`使用時）	`HTMLCanvasElement.width`, `HTMLCanvasElement.height`
`HTMLCanvasElement` または `OffscreenCanvas` （`WebGLRenderingContextBase`使用時）	`WebGLRenderingContextBase.drawingBufferWidth`, `WebGLRenderingContextBase.drawingBufferHeight`
`HTMLCanvasElement` または `OffscreenCanvas` （`ImageBitmapRenderingContext`使用時）	`ImageBitmapRenderingContext`の内部出力ビットマップ `ImageBitmap.width`, `ImageBitmap.height`

11.2.6. サブルーチン

GPUTexelCopyTextureInfo物理サブリソースサイズ

引数:

GPUTexelCopyTextureInfo texelCopyTextureInfo

戻り値: GPUExtent3D

texelCopyTextureInfoのGPUTexelCopyTextureInfo物理サブリソースサイズは以下のように算出されます:

そのwidth、height、depthOrArrayLayersはそれぞれ、 texelCopyTextureInfo.texture のサブリソースの物理ミップレベル固有テクスチャ範囲の幅、高さ、深さ（ミップマップレベル texelCopyTextureInfo.mipLevel）。

リニアテクスチャデータの検証(layout, byteSize, format, copyExtent)

引数:

GPUTexelCopyBufferLayout layout: リニアテクスチャデータのレイアウト。
GPUSize64 byteSize: リニアデータの総サイズ（バイト単位）。
GPUTextureFormat format: テクスチャのフォーマット。
GPUExtent3D copyExtent: コピーするテクスチャの範囲。

Device timeline の手順:

次を定義する:
- widthInBlocks は copyExtent.width を format のテクセルブロック幅で割った値とする。整数であることをアサートする。
- heightInBlocks は copyExtent.height を format のテクセルブロック高さで割った値とする。整数であることをアサートする。
- bytesInLastRow は widthInBlocks × format のテクセルブロックコピーのフットプリントとする。
次の入力バリデーション要件が満たされていない場合は失敗とする:
- heightInBlocks > 1 の場合、 layout.bytesPerRow を必ず指定する必要がある。
- copyExtent.depthOrArrayLayers > 1 の場合、 layout.bytesPerRow および layout.rowsPerImage を必ず指定する必要がある。
- 指定されている場合、layout.bytesPerRow は bytesInLastRow 以上でなければならない。
- 指定されている場合、layout.rowsPerImage は heightInBlocks 以上でなければならない。
次を定義する:
- bytesPerRow は layout.bytesPerRow ?? 0。
- rowsPerImage は layout.rowsPerImage ?? 0。
注: これらのデフォルト値は常に0倍となるため効果がありません。
requiredBytesInCopy を 0 とする。
copyExtent.depthOrArrayLayers > 0 の場合:
1. requiredBytesInCopy に bytesPerRow × rowsPerImage × (copyExtent.depthOrArrayLayers − 1) を加算する。
2. heightInBlocks > 0 の場合:
  1. requiredBytesInCopy に bytesPerRow × (heightInBlocks − 1) + bytesInLastRow を加算する。
次の条件が満たされていなければ失敗とする:
- レイアウトがリニアデータ内に収まること： layout.offset + requiredBytesInCopy ≤ byteSize。

テクスチャコピー範囲の検証

引数:

GPUTexelCopyTextureInfo texelCopyTextureInfo: コピーされるテクスチャサブリソースおよびコピー開始位置。
GPUExtent3D copySize: テクスチャのサイズ。

Device timeline の手順:

blockWidth を texelCopyTextureInfo.texture.format のテクセルブロック幅とする。
blockHeight を texelCopyTextureInfo.texture.format のテクセルブロック高さとする。
subresourceSize を texelCopyTextureInfo の物理サブリソースサイズとする。
以下のすべての条件が満たされているかどうかを返す:
- (texelCopyTextureInfo.origin.x + copySize.width) ≤ subresourceSize.width
- (texelCopyTextureInfo.origin.y + copySize.height) ≤ subresourceSize.height
- (texelCopyTextureInfo.origin.z + copySize.depthOrArrayLayers) ≤ subresourceSize.depthOrArrayLayers
- copySize.width は blockWidth の倍数でなければならない。
- copySize.height は blockHeight の倍数でなければならない。
注: テクスチャコピー範囲は圧縮フォーマットの場合物理的（切り上げ済み）のサイズと比較されるため、テクスチャ内に完全には収まっていないブロックにもコピーが可能です。

2つの GPUTextureFormat format1 と format2 はコピー互換である、もし:

format1 が format2 と等しいか、
format1 と format2 の違いが srgb フォーマット（-srgb サフィックスの有無）だけの場合。

テクスチャコピー用サブリソース集合(texelCopyTextureInfo, copySize) は texture = texelCopyTextureInfo.texture のサブリソースのうち、各サブリソース s が次を満たすものとする：

s のミップマップレベルが texelCopyTextureInfo.mipLevel と等しい。
s のアスペクトが texelCopyTextureInfo.aspect のアスペクト集合内にある。
もし texture.dimension が "2d" なら:
- s のアレイレイヤーは texelCopyTextureInfo.origin.z 以上かつ texelCopyTextureInfo.origin.z + copySize.depthOrArrayLayers 未満である。

12. コマンドバッファ

コマンドバッファは、GPUコマンド（キュータイムラインのステップブロック）の事前記録リストであり、 GPUQueueに送信して実行できます。各GPUコマンドは、キュータイムライン上で実行される作業（状態設定、描画、リソースコピーなど）を表します。

GPUCommandBuffer は一度しか送信できず、送信時に無効化されます。複数回送信で描画コマンドを再利用したい場合は、GPURenderBundleを利用してください。

12.1. `GPUCommandBuffer`

[Exposed=(Window, Worker), SecureContext]
interface GPUCommandBuffer {
};
GPUCommandBuffer includes GPUObjectBase;

GPUCommandBuffer には以下のデバイスタイムラインプロパティがあります:

[[command_list]]、型はリスト<GPUコマンド>、読み取り専用: このコマンドバッファがサブミットされたときにリストの GPUコマンドをキュータイムライン上で実行します。
[[renderState]]、型は RenderState、初期値は null: 現在実行中のレンダーパスコマンドで使用される状態。
[[used_bind_groups]]、型はセット<GPUBindGroup>、読み取り専用: このコマンドバッファで使用されるすべての GPUBindGroup のセット。

12.1.1. コマンドバッファ生成

dictionary GPUCommandBufferDescriptor
         : GPUObjectDescriptorBase {
};

13. コマンドエンコード

13.1. `GPUCommandsMixin`

GPUCommandsMixin は、コマンドをエンコードするすべてのインターフェイスに共通する状態を定義します。メソッドはありません。

interface mixin GPUCommandsMixin {
};

GPUCommandsMixin には以下のデバイスタイムラインプロパティがあります:

[[state]]、型はエンコーダー状態、初期値は "open": エンコーダーの現在の状態。
[[commands]]、型はリスト<GPUコマンド>、初期値は []: これらのコマンドを含む GPUCommandBuffer がサブミットされたときにリストの GPUコマンドをキュータイムライン上で実行します。
[[used_bind_groups]]、型はセット<GPUBindGroup>、初期値は空: コマンドエンコード中に setBindGroup() でセットされたすべての GPUBindGroup のセット。

エンコーダ状態は以下のいずれかです:

"open"

エンコーダは新しいコマンドのエンコードに利用可能です。

"locked"

エンコーダは子エンコーダによってロックされているため利用できません: これはGPUCommandEncoder であり、GPURenderPassEncoder またはGPUComputePassEncoder がアクティブな場合です。パスが終了すると、エンコーダは再び"open"になります。

この状態でコマンドを発行すると、エンコーダを無効化します。

"ended"

エンコーダは終了しており、新しいコマンドはエンコードできません。

この状態でコマンドを発行すると、検証エラーを生成します。

エンコーダ状態の検証：GPUCommandsMixin encoderについて以下のデバイスタイムライン手順を実行:

もしencoder.[[state]] が以下のいずれかの場合:

"open"

true を返す。

"locked"

エンコーダを無効化し、falseを返す。

"ended"

検証エラーを生成し、falseを返す。

コマンドのエンキュー：GPUCommandsMixin encoder がGPUコマンドcommandのステップを発行する場合、以下のデバイスタイムライン手順を実行:

Append command を encoder.[[commands]]に追加。
commandがGPUCommandBufferの一部として実行される場合:
1. commandのステップを実行する。

13.2. `GPUCommandEncoder`

[Exposed=(Window, Worker), SecureContext]
interface GPUCommandEncoder {
    GPURenderPassEncoder beginRenderPass(GPURenderPassDescriptor descriptor);
    GPUComputePassEncoder beginComputePass(optional GPUComputePassDescriptor descriptor = {});

    undefined copyBufferToBuffer(
        GPUBuffer source,
        GPUBuffer destination,
        optional GPUSize64 size);
    undefined copyBufferToBuffer(
        GPUBuffer source,
        GPUSize64 sourceOffset,
        GPUBuffer destination,
        GPUSize64 destinationOffset,
        optional GPUSize64 size);

    undefined copyBufferToTexture(
        GPUTexelCopyBufferInfo source,
        GPUTexelCopyTextureInfo destination,
        GPUExtent3D copySize);

    undefined copyTextureToBuffer(
        GPUTexelCopyTextureInfo source,
        GPUTexelCopyBufferInfo destination,
        GPUExtent3D copySize);

    undefined copyTextureToTexture(
        GPUTexelCopyTextureInfo source,
        GPUTexelCopyTextureInfo destination,
        GPUExtent3D copySize);

    undefined clearBuffer(
        GPUBuffer buffer,
        optional GPUSize64 offset = 0,
        optional GPUSize64 size);

    undefined resolveQuerySet(
        GPUQuerySet querySet,
        GPUSize32 firstQuery,
        GPUSize32 queryCount,
        GPUBuffer destination,
        GPUSize64 destinationOffset);

    GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
};
GPUCommandEncoder includes GPUObjectBase;
GPUCommandEncoder includes GPUCommandsMixin;
GPUCommandEncoder includes GPUDebugCommandsMixin;

13.2.1. コマンドエンコーダ生成

dictionary GPUCommandEncoderDescriptor
         : GPUObjectDescriptorBase {
};

createCommandEncoder(descriptor)

GPUCommandEncoder を生成します。

呼び出し対象: GPUDevice this.

引数:

GPUDevice.createCommandEncoder(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPUCommandEncoderDescriptor`	✘	✔	作成する`GPUCommandEncoder` の記述。

戻り値: GPUCommandEncoder

コンテンツタイムライン手順:

e を ! 新しいWebGPUオブジェクトを生成(this, GPUCommandEncoder, descriptor)とする。
thisのデバイスタイムラインで初期化手順を実行する。
eを返す。

デバイスタイムライン 初期化手順:

以下のいずれかの条件が満たされない場合、検証エラーを生成し、 eを無効化して返す。
- thisがlostであってはならない。

GPUCommandEncoder を生成し、バッファのクリアコマンドをエンコードし、エンコーダをfinishしてGPUCommandBuffer を取得し、GPUQueueに送信する例。

const commandEncoder = gpuDevice.createCommandEncoder();
commandEncoder.clearBuffer(buffer);
const commandBuffer = commandEncoder.finish();
gpuDevice.queue.submit([commandBuffer]);

13.3. パスエンコード

beginRenderPass(descriptor)

descriptorで記述されたレンダーパスのエンコードを開始します。

呼び出し対象: GPUCommandEncoder this。

引数:

GPUCommandEncoder.beginRenderPass(descriptor) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`descriptor`	`GPURenderPassDescriptor`	✘	✘	生成する`GPURenderPassEncoder` の記述。

戻り値: GPURenderPassEncoder

コンテンツタイムライン手順:

descriptor.colorAttachments の各 non-null な colorAttachment について：
1. もし colorAttachment.clearValue が指定されている場合：
  1. ? GPUColor shapeの検証(colorAttachment.clearValue) を実行する。
pass を新しい GPURenderPassEncoder オブジェクトとする。
this の Device timeline で initialization steps を実行する。
pass を返す。

デバイスタイムラインの initialization steps:

エンコーダ状態の検証を this に対して実行する。もし false を返した場合、invalidate を pass に対して行いreturnする。
this.[[state]] を "locked" に設定する。
attachmentRegions を [リスト] （[テクスチャサブリソース, depthSlice?] のペア、初期値空）として初期化する。各ペアは描画先になるテクスチャ領域を示し、"3d" テクスチャの場合のみ1つのdepth sliceを含む。
descriptor.colorAttachments の各 non-null colorAttachment について：
1. colorAttachment.view, colorAttachment.depthSlice ?? null のペアを attachmentRegions に追加する。
2. もし colorAttachment.resolveTarget が null でない場合：
  1. [colorAttachment.resolveTarget, undefined] を attachmentRegions に追加する。
次の要件のいずれかを満たさなければ、invalidate を pass に対して実行し、returnする。
- descriptor はデバイス this.[[device]] のもと、 Valid Usage のルールを満たしていること。
- attachmentRegions に含まれるテクスチャ領域の集合が互いに重複しない（pairwise disjoint）。すなわち、2つの領域が重なってはならない。
usage scope へ追加を attachmentRegions中の各テクスチャサブリソースについて、usage attachmentで pass.[[usage scope]] に実施する。
depthStencilAttachment を descriptor.depthStencilAttachment とする。
もし depthStencilAttachment が null でない場合：
1. depthStencilView を depthStencilAttachment.view とする。
2. usage scope へ追加を depth サブリソース（もしあれば）について pass.[[usage scope]] でusage attachment-read （depthStencilAttachment.depthReadOnly が true の場合）、それ以外は attachment で実行する。
3. usage scope へ追加を stencil サブリソース（もしあれば）について pass.[[usage scope]] でusage attachment-read （depthStencilAttachment.stencilReadOnly が true の場合）、それ以外はattachmentで実行する。
4. pass.[[depthReadOnly]] を depthStencilAttachment.depthReadOnly に設定する。
5. pass.[[stencilReadOnly]] を depthStencilAttachment.stencilReadOnly に設定する。
pass.[[layout]] をderive render targets layout from pass(descriptor) に設定する。
もし descriptor.timestampWrites が指定されている場合：
1. timestampWrites を descriptor.timestampWrites とする。
2. もし timestampWrites.beginningOfPassWriteIndex が指定されているなら append で以下の手順で GPUコマンドを this.[[commands]] に追加：
  1. パスコマンド実行前に、現在のキュータイムスタンプを timestampWrites.beginningOfPassWriteIndex の timestampWrites.querySet の該当インデックスに書き込む。
3. もし timestampWrites.endOfPassWriteIndex が指定されているなら pass.[[endTimestampWrite]] に以下の手順による GPUコマンドを設定：
  1. パスコマンド実行後に、現在のキュータイムスタンプを timestampWrites.endOfPassWriteIndex のtimestampWrites.querySet の該当インデックスに書き込む。
pass.[[drawCount]] を 0 に設定する。
pass.[[maxDrawCount]] を descriptor.maxDrawCount に設定する。
pass.[[maxDrawCount]] を descriptor.maxDrawCount に設定する。
コマンドをエンキューする: this に対し、後続手順を Queueタイムラインで実行するように登録する。

キュータイムライン手順:

現在実行中の GPUCommandBuffer の [[renderState]] を新しい RenderState にする。
[[renderState]].[[colorAttachments]] に descriptor.colorAttachments を設定する。
[[renderState]].[[depthStencilAttachment]] に descriptor.depthStencilAttachment を設定する。
descriptor.colorAttachments の各 non-null colorAttachment について：
1. colorView を colorAttachment.view とする。
2. もし colorView.[[descriptor]].dimension が：
  
  "3d"
  
  colorSubregion を colorAttachment.depthSlice にする。
  
  その他
  
  colorSubregion を colorView にする。
3. もし colorAttachment.loadOp が：
  
  "load"
  
  colorSubregion に関連付けられたフレームバッファメモリに colorSubregion の内容をロードする。
  
  "clear"
  
  colorSubregion に関連付けられたフレームバッファメモリ内のすべてのテクセルを、colorAttachment.clearValue で初期化する。
もし depthStencilAttachment が null でない場合：
1. もし depthStencilAttachment.depthLoadOp が：
  
  provided でない場合
  
  アサート：depthStencilAttachment.depthReadOnly が true であり、depthStencilView の depth サブリソースの内容を depthStencilView に関連付けられたフレームバッファメモリへロードする。
  
  "load"
  
  depthStencilView の depth サブリソースの内容を depthStencilView に関連付けられたフレームバッファメモリへロードする。
  
  "clear"
  
  depthStencilView の depth サブリソースに関連付けられたフレームバッファメモリ内のすべてのテクセルを depthStencilAttachment.depthClearValue で初期化する。
2. もし depthStencilAttachment.stencilLoadOp が：
  
  provided でない場合
  
  アサート：depthStencilAttachment.stencilReadOnly が true であり、depthStencilView の stencil サブリソースの内容を depthStencilView に関連付けられたフレームバッファメモリへロードする。
  
  "load"
  
  depthStencilView の stencil サブリソースの内容を depthStencilView に関連付けられたフレームバッファメモリへロードする。
  
  "clear"
  
  depthStencilView の stencil サブリソースに関連付けられたフレームバッファメモリ内のすべてのテクセルを depthStencilAttachment.stencilClearValue で初期化する。
注: read-only depth-stencil アタッチメントは暗黙的に "load" 操作として扱われます。read-onlyアタッチメントに対しloadOpの指定が禁止される（バリデーションで検出される）のは GPURenderPassDepthStencilAttachment Valid Usage内で行われます。

beginComputePass(descriptor)

descriptorで記述されたコンピュートパスのエンコードを開始します。

呼び出し元: GPUCommandEncoder this.

引数:

GPUCommandEncoder.beginComputePass(descriptor) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`descriptor`	`GPUComputePassDescriptor`	✘	✔

戻り値: GPUComputePassEncoder

Content timeline 手順:

pass を新しい GPUComputePassEncoder オブジェクトとする。
this の Device timeline で initialization steps を実施する。
pass を返す。

Device timeline initialization steps:

エンコーダ状態の検証を this に対して行う。もし false を返した場合、invalidate を pass に対して行い、returnする。
this.[[state]] を "locked" に設定する。
次のいずれかの要件が満たされない場合、invalidate を pass に対して行い、returnする。
- もし descriptor.timestampWrites が指定されている場合：
  - timestampWritesの検証(this.[[device]], descriptor.timestampWrites) が true を返すこと。
もし descriptor.timestampWrites が指定されている場合：
1. timestampWrites を descriptor.timestampWrites に設定する。
2. もし timestampWrites.beginningOfPassWriteIndex が指定されているなら、 append で以下の手順による GPUコマンドを this.[[commands]] に追加：
  1. このパスのコマンドの実行開始前に、現在のキュータイムスタンプを timestampWrites.beginningOfPassWriteIndex 番号の timestampWrites.querySet に書き込む。
3. もし timestampWrites.endOfPassWriteIndex が指定されているなら、 pass.[[endTimestampWrite]] に以下の手順を持つ GPUコマンドを設定：
  1. このパスのコマンドの実行終了後に、現在のキュータイムスタンプを timestampWrites.endOfPassWriteIndex 番号の timestampWrites.querySet に書き込む。

13.4. バッファコピーコマンド

copyBufferToBuffer() は2つのオーバーロードがあります：

copyBufferToBuffer(source, destination, size)

省略記法であり、 copyBufferToBuffer(source, 0, destination, 0, size)と同等です。

copyBufferToBuffer(source, sourceOffset, destination, destinationOffset, size)

GPUCommandEncoder に、ある GPUBuffer のサブ領域から別の GPUBuffer のサブ領域へデータをコピーするコマンドをエンコードします。

呼び出し元: GPUCommandEncoder this。

引数:

GPUCommandEncoder.copyBufferToBuffer(source, sourceOffset, destination, destinationOffset, size) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`source`	`GPUBuffer`	✘	✘	コピー元の `GPUBuffer`。
`sourceOffset`	`GPUSize64`	✘	✘	`source` 内でコピー開始バイトオフセット。
`destination`	`GPUBuffer`	✘	✘	コピー先の `GPUBuffer`。
`destinationOffset`	`GPUSize64`	✘	✘	`destination` 内でコピー後のデータ配置バイトオフセット。
`size`	`GPUSize64`	✘	✔	コピーするバイト数。

戻り値: undefined

Content timeline 手順:

続く手順を this.[[device]] のDevice timelineに発行する。

Device timeline 手順:

エンコーダ状態の検証を this に対して実施。false を返した場合は return。
もし size が undefined なら source.size − sourceOffset とする。
下記条件に一つでも満たされないものがあれば invalidate を this に対し行い、return：
- source は valid to use with this であること。
- destination は valid to use with this であること。
- source.usage が COPY_SRC を含む。
- destination.usage が COPY_DST を含む。
- size は4の倍数。
- sourceOffset は4の倍数。
- destinationOffset は4の倍数。
- source.size ≥ (sourceOffset + size)。
- destination.size ≥ (destinationOffset + size)。
- source と destination が同じ GPUBuffer でないこと。
Enqueue a command を this で実行し、以降の手順をQueue timelineで実施。

Queue timeline 手順:

source の sourceOffset から size バイトを destination の destinationOffset からコピーする。

clearBuffer(buffer, offset, size)

GPUCommandEncoder に対し、GPUBuffer のサブリージョンをゼロで埋めるコマンドをエンコードします。

呼び出し元: GPUCommandEncoder this。

引数:

GPUCommandEncoder.clearBuffer(buffer, offset, size) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`buffer`	`GPUBuffer`	✘	✘	クリア対象の `GPUBuffer`。
`offset`	`GPUSize64`	✘	✔	`buffer` 内でクリア範囲が始まるバイトオフセット。
`size`	`GPUSize64`	✘	✔	クリアするサブリージョンのバイト数。省略時は buffer のサイズから `offset` を引いたものが既定値。

戻り値: undefined

Content timeline 手順:

後続手順を this.[[device]] のDevice timelineで発行する。

Device timeline 手順:

エンコーダ状態の検証を this に対し実行し、falseのとき return。
size が未指定の場合、size を max(0, buffer.size - offset) に設定する。
次のいずれか満たさない場合、invalidate を this に対し実行し、return：
- buffer が valid to use with this であること。
- buffer.usage が COPY_DST を含むこと。
- size は4の倍数である。
- offset は4の倍数である。
- buffer.size ≥ (offset + size)。
Enqueue a command を this で発行し、以降の手順を Queue timeline で実施する。

Queue timeline 手順:

buffer の offset から size バイト分を 0 でクリアする。

13.5. テクセルコピーコマンド

copyBufferToTexture(source, destination, copySize)

GPUCommandEncoder に、GPUBuffer のサブ領域から1つまたは複数の連続したテクスチャサブリソースのサブ領域へデータをコピーするコマンドをエンコードします。

呼び出し対象: GPUCommandEncoder this。

引数:

GPUCommandEncoder.copyBufferToTexture(source, destination, copySize) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`source`	`GPUTexelCopyBufferInfo`	✘	✘	`copySize`と組み合わせて、コピー元バッファの領域を定義します。
`destination`	`GPUTexelCopyTextureInfo`	✘	✘	`copySize`と組み合わせて、コピー先テクスチャサブリソースの領域を定義します。
`copySize`	`GPUExtent3D`	✘	✘

戻り値: undefined

コンテンツタイムライン手順:

? GPUOrigin3D の形状を検証する(destination.origin)。
? GPUExtent3D の形状を検証する(copySize)。
以降の手順は this.[[device]] の Device timeline 上で実行する：

デバイスタイムライン手順:

エンコーダ状態の検証をthisに対して実行。falseなら返す。
aligned = trueとする。
dataLength = source.buffer.sizeとする。
次の条件を満たしていなければ、thisを無効化して返す。
- GPUTexelCopyBufferInfoの検証(source) がtrueを返すこと。
- source.buffer.usageに COPY_SRCが含まれること。
- テクスチャバッファコピーの検証(destination, source, dataLength, copySize, COPY_DST, aligned) がtrueを返すこと。
thisにコマンドのエンキューを行い、以降の手順をキュータイムラインで実行。

Queue timeline の手順：

blockWidth を destination.texture のテクセルブロック幅とする。
blockHeight を destination.texture のテクセルブロック高さとする。
dstOrigin を destination.origin とする。
dstBlockOriginX を (dstOrigin.x ÷ blockWidth) とする。
dstBlockOriginY を (dstOrigin.y ÷ blockHeight) とする。
blockColumns を (copySize.width ÷ blockWidth) とする。
blockRows を (copySize.height ÷ blockHeight) とする。
アサート：dstBlockOriginX、 dstBlockOriginY、blockColumns、blockRowsは整数である。
各 z について [0, copySize.depthOrArrayLayers − 1] の範囲で：
1. dstSubregion を texture copy sub-region (z + dstOrigin.z) of destination とする。
2. 各 y について [0, blockRows − 1] の範囲で：
  1. 各 x について [0, blockColumns − 1] の範囲で：
    1. blockOffset をテクセルブロックのバイトオフセット（source の (x, y, z) に対し、 destination.texture 用）とする。
    2. dstSubregion の (dstBlockOriginX + x, dstBlockOriginY + y) テクセルブロックを、 source.buffer の blockOffset 位置から取得される同等テクセル表現に設定する。

copyTextureToBuffer(source, destination, copySize)

GPUCommandEncoder に、1つまたは複数の連続したテクスチャサブリソースのサブ領域からGPUBuffer のサブ領域へデータをコピーするコマンドをエンコードします。

呼び出し元: GPUCommandEncoder this。

引数:

GPUCommandEncoder.copyTextureToBuffer(source, destination, copySize) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`source`	`GPUTexelCopyTextureInfo`	✘	✘	`copySize` と組み合わせて、元となるテクスチャサブリソースの範囲を定義します。
`destination`	`GPUTexelCopyBufferInfo`	✘	✘	`copySize` と組み合わせて、コピー先バッファの範囲を定義します。
`copySize`	`GPUExtent3D`	✘	✘

戻り値: undefined

Content timeline 手順:

? GPUOrigin3D shapeの検証(source.origin) を行う。
? GPUExtent3D shapeの検証(copySize) を行う。
続く手順を this.[[device]] のDevice timelineに発行します。

Device timeline 手順:

エンコーダ状態の検証をthisに対して行い、false なら return。
aligned を true にする。
dataLength を destination.buffer.size とする。
下記のいずれか満たされなければ invalidate を this で実施し return。
- GPUTexelCopyBufferInfoの検証(destination) がtrueを返すこと。
- destination.buffer.usage が COPY_DST を含むこと。
- テクスチャ・バッファコピーの検証 (source, destination, dataLength, copySize, COPY_SRC, aligned) が true を返すこと。
- もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  - source.texture.format は圧縮フォーマットではないこと。
Enqueue a command をthisで実施し、以降はQueue timeline上で手順を行う。

Queue timeline手順:

blockWidth をsource.texture のテクセルブロック幅とする。
blockHeight をsource.texture のテクセルブロック高さとする。
srcOrigin を source.origin とする。
srcBlockOriginX を (srcOrigin.x ÷ blockWidth) とする。
srcBlockOriginY を (srcOrigin.y ÷ blockHeight) とする。
blockColumns を (copySize.width ÷ blockWidth) とする。
blockRows を (copySize.height ÷ blockHeight) とする。
アサート： srcBlockOriginX、srcBlockOriginY、blockColumns、blockRows は整数であること。
z を [0, copySize.depthOrArrayLayers − 1] の範囲で繰り返す：
1. srcSubregion を texture copy sub-region (z + srcOrigin.z) of source とする。
2. y を [0, blockRows − 1] の範囲で繰り返す：
  1. x を [0, blockColumns − 1] の範囲で繰り返す：
    1. blockOffset をテクセルブロックのバイトオフセット（destination、(x, y, z)、source.texture 用）とする。
    2. destination.buffer の blockOffset に、同等テクセル表現として srcSubregion の (srcBlockOriginX + x, srcBlockOriginY + y) テクセルブロックを格納する。

copyTextureToTexture(source, destination, copySize)

GPUCommandEncoder に、1つまたは複数の連続したテクスチャサブリソースのサブ領域から、他の1つまたは複数の連続したテクスチャサブリソースのサブ領域へデータをコピーするコマンドをエンコードします。

呼び出し対象: GPUCommandEncoder this。

引数:

GPUCommandEncoder.copyTextureToTexture(source, destination, copySize) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`source`	`GPUTexelCopyTextureInfo`	✘	✘	`copySize`と組み合わせて、コピー元テクスチャサブリソースの領域を定義します。
`destination`	`GPUTexelCopyTextureInfo`	✘	✘	`copySize`と組み合わせて、コピー先テクスチャサブリソースの領域を定義します。
`copySize`	`GPUExtent3D`	✘	✘

戻り値: undefined

Content timeline の手順：

? GPUOrigin3D の形状を検証する(source.origin)。
? GPUOrigin3D の形状を検証する(destination.origin)。
? GPUExtent3D の形状を検証する(copySize)。
続く手順を this.[[device]] の Device timeline で実施する：

デバイスタイムライン手順：

エンコーダ状態の検証を this に対して行う。false なら return。
以下のいずれかの条件を満たさない場合、invalidate を this に対し実行し return：
- srcTexture を source.texture とする。
- dstTexture を destination.texture とする。
- GPUTexelCopyTextureInfo の検証(source, copySize) が true を返すこと。
- srcTexture.usage が COPY_SRC を含む。
- GPUTexelCopyTextureInfo の検証(destination, copySize) が true を返すこと。
- dstTexture.usage が COPY_DST を含む。
- srcTexture.sampleCount と dstTexture.sampleCount が等しいこと。
- srcTexture.format と dstTexture.format はコピー互換でなければならない。
- もし srcTexture.format がデプスステンシルフォーマットなら：
  - source.aspect および destination.aspect は srcTexture.format および dstTexture.format の全アスペクトを両方とも参照しなければならない。
- テクスチャコピーのためのサブリソース集合(source, copySize) とテクスチャコピーのためのサブリソース集合(destination, copySize) は互いに重複しない。
- もし device.[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  - source.texture.format および destination.texture.format は圧縮フォーマットであってはならない。
  - source.texture.sampleCount と destination.texture.sampleCount はともに 1 でなければならない。
コマンドをエンキューし、以降はQueue timelineで手順を実施する。

Queue timeline 手順：

blockWidth を source.texture のテクセルブロック幅とする。
blockHeight を source.texture のテクセルブロック高さとする。
srcOrigin を source.origin とする。
srcBlockOriginX を (srcOrigin.x ÷ blockWidth) とする。
srcBlockOriginY を (srcOrigin.y ÷ blockHeight) とする。
dstOrigin を destination.origin とする。
dstBlockOriginX を (dstOrigin.x ÷ blockWidth) とする。
dstBlockOriginY を (dstOrigin.y ÷ blockHeight) とする。
blockColumns を (copySize.width ÷ blockWidth) とする。
blockRows を (copySize.height ÷ blockHeight) とする。
アサート：srcBlockOriginX、srcBlockOriginY、dstBlockOriginX、dstBlockOriginY、blockColumns、blockRows は整数である。
各 z について [0, copySize.depthOrArrayLayers − 1] の範囲で：
1. srcSubregion を texture copy sub-region(z + srcOrigin.z) of source とする。
2. dstSubregion を texture copy sub-region(z + dstOrigin.z) of destination とする。
3. 各 y について [0, blockRows − 1] の範囲で：
  1. 各 x について [0, blockColumns − 1] の範囲で：
    1. dstSubregion の (dstBlockOriginX + x, dstBlockOriginY + y) テクセルブロックを、srcSubregion の (srcBlockOriginX + x, srcBlockOriginY + y) テクセルブロックの同等テクセル表現に設定する。

13.6. クエリ

resolveQuerySet(querySet, firstQuery, queryCount, destination, destinationOffset)

GPUQuerySet のクエリ結果を、GPUBuffer の範囲に出力します。

呼び出し元: GPUCommandEncoder this。

引数:

GPUCommandEncoder.resolveQuerySet(querySet, firstQuery, queryCount, destination, destinationOffset) メソッドの引数。
パラメータ	型	Nullable	Optional
`querySet`	`GPUQuerySet`	✘	✘
`firstQuery`	`GPUSize32`	✘	✘
`queryCount`	`GPUSize32`	✘	✘
`destination`	`GPUBuffer`	✘	✘
`destinationOffset`	`GPUSize64`	✘	✘

戻り値: undefined

Content timeline 手順:

続く手順を this.[[device]] の Device timeline で実施する。

Device timeline 手順:

エンコーダ状態の検証を this に対して行う。 false なら return。
以下のいずれか満たさない場合、invalidate を this に対して行い、return。
- querySet が valid to use with this であること。
- destination が valid to use with this であること。
- destination.usage が QUERY_RESOLVE を含むこと。
- firstQuery < querySet のクエリ数。
- (firstQuery + queryCount) ≤ querySet のクエリ数。
- destinationOffset は256の倍数である。
- destinationOffset + 8 × queryCount ≤ destination.size。
コマンドをエンキューし、以降の手順は Queue timeline で行う。

Queue timeline 手順:

queryIndex を firstQuery にする。
offset を destinationOffset にする。
queryIndex < firstQuery + queryCount の間は：
1. destination の offset から8バイトに querySet の queryIndex 番目の値を書き込む。
2. queryIndex を queryIndex + 1 にする。
3. offset を offset + 8 にする。

13.7. ファイナライズ

GPUCommandBuffer に、GPUCommandEncoder で記録されたコマンドを含めるには、 finish() を呼び出します。 finish() が呼び出されると、そのコマンドエンコーダはこれ以上使用できなくなります。

finish(descriptor)

コマンド列の記録を完了し、対応する GPUCommandBuffer を返します。

呼び出し元: GPUCommandEncoder this。

引数:

GPUCommandEncoder.finish(descriptor) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`descriptor`	`GPUCommandBufferDescriptor`	✘	✔

戻り値: GPUCommandBuffer

Content timeline の手順:

commandBuffer を新しい GPUCommandBuffer とする。
this.[[device]] の Device timeline で finish steps を実施する。
commandBuffer を返す。

Device timeline finish steps:

下記要件をすべて満たす場合 validationSucceeded を true、満たさない場合 false とする。
- this が valid であること。
- this.[[state]] が "open" であること。
- this.[[debug_group_stack]] が空であること。
this.[[state]] を "ended" に設定する。
もし validationSucceeded が false なら：
1. バリデーションエラー生成を実行する。
2. invalidated GPUCommandBuffer を返す。
commandBuffer.[[command_list]] を this.[[commands]] に設定する。
commandBuffer.[[used_bind_groups]] を this.[[used_bind_groups]] に設定する。

14. プログラマブルパス

interface mixin GPUBindingCommandsMixin {
    undefined setBindGroup(GPUIndex32 index, GPUBindGroup? bindGroup,
        optional sequence<GPUBufferDynamicOffset> dynamicOffsets = []);

    undefined setBindGroup(GPUIndex32 index, GPUBindGroup? bindGroup,
        [AllowShared] Uint32Array dynamicOffsetsData,
        GPUSize64 dynamicOffsetsDataStart,
        GPUSize32 dynamicOffsetsDataLength);
};

GPUBindingCommandsMixin は同じオブジェクト上に GPUObjectBase と GPUCommandsMixin のメンバーが存在することを前提としています。これらのミックスインも含むインターフェイスのみがGPUBindingCommandsMixinをincludeできます。

GPUBindingCommandsMixin には以下のデバイスタイムラインプロパティがあります:

[[bind_groups]]、型は順序付きマップ<GPUIndex32, GPUBindGroup>、初期値は空: 各インデックスに対する現在の GPUBindGroup。
[[dynamic_offsets]]、型は順序付きマップ<GPUIndex32, リスト<GPUBufferDynamicOffset>>, 初期値は空: 各 [[bind_groups]] エントリに対する現在のダイナミックオフセット。

14.1. バインドグループ

setBindGroup() には2つのオーバーロードがあります：

setBindGroup(index, bindGroup, dynamicOffsets)

指定されたインデックスの現在の GPUBindGroup を設定します。

呼び出し対象: GPUBindingCommandsMixin の this.

引数:

index, 型は GPUIndex32, 非null、必須: バインドグループを設定するインデックス。
bindGroup, 型は GPUBindGroup, nullable、必須: その後のレンダーまたはコンピュートコマンドで使用するバインドグループ。
dynamicOffsets, 型は sequence<GPUBufferDynamicOffset>, 非null、デフォルトは []: bindGroup の各エントリで buffer.hasDynamicOffset とマークされた各エントリに対する、バイト単位のバッファオフセットを格納する配列です。順序は GPUBindGroupLayoutEntry.binding によります。詳細は注を参照してください。

戻り値: undefined

次の手順を this の Device timeline 上で発行します。[[device]]。

Device timeline の手順:

エンコーダーの状態を検証するを this に対して実行します。false が返ったら終了します。
dynamicOffsetCount を、もし bindGroup が null なら 0、そうでなければ bindGroup.[[layout]].[[dynamicOffsetCount]] とします。
以下の要件のいずれかが満たされない場合、invalidate を this に対して行い、戻ります。
- index は < this.[[device]].[[limits]].maxBindGroups でなければなりません。
- dynamicOffsets.size は dynamicOffsetCount と等しくなければなりません。
もし bindGroup が null の場合:
1. 削除 this.[[bind_groups]][index]。
2. 削除 this.[[dynamic_offsets]][index]。
それ以外の場合:
1. 以下の要件のいずれかが満たされない場合、invalidate を this に対して行い、戻ります。
  - bindGroup はこのエンコーダーで使用可能でなければなりません。
  - 各動的バインディングごとに反復処理 (bufferBinding, bufferLayout, dynamicOffsetIndex) を bindGroup に対して行ったとき:
    - bufferBinding.offset + dynamicOffsets[dynamicOffsetIndex] + bufferLayout.minBindingSize は ≤ bufferBinding.buffer.size でなければなりません。
    - もし bufferLayout.type が "uniform" の場合:
      
      dynamicOffset は minUniformBufferOffsetAlignment の倍数でなければなりません。
    - もし bufferLayout.type が "storage" または "read-only-storage" の場合:
      
      dynamicOffset は minStorageBufferOffsetAlignment の倍数でなければなりません。
2. this.[[bind_groups]][index] を bindGroup に設定します。
3. this.[[dynamic_offsets]][index] を dynamicOffsets のコピーに設定します。
4. Append により bindGroup を this.[[used_bind_groups]] に追加します。
5. もし this が GPURenderCommandsMixin の場合:
  1. this.[[bind_groups]] 内の各 bindGroup について、 merge により bindGroup.[[usedResources]] を this.[[usage scope]] に統合します。

setBindGroup(index, bindGroup, dynamicOffsetsData, dynamicOffsetsDataStart, dynamicOffsetsDataLength)

指定されたインデックスの現在の GPUBindGroup を設定します。動的オフセットを Uint32Array の一部として指定します。

呼び出し対象: GPUBindingCommandsMixin の this。

引数:

GPUBindingCommandsMixin.setBindGroup(index, bindGroup, dynamicOffsetsData, dynamicOffsetsDataStart, dynamicOffsetsDataLength) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`index`	`GPUIndex32`	✘	✘	バインドグループを設定するインデックス。
`bindGroup`	`GPUBindGroup?`	✔	✘	後続のレンダーまたはコンピュートコマンドで使用するバインドグループ。
`dynamicOffsetsData`	`Uint32Array`	✘	✘	`bindGroup` 内で `buffer`.`hasDynamicOffset` としてマークされた各エントリのバッファオフセット（バイト単位）が格納された配列。 `GPUBindGroupLayoutEntry`.`binding` の順で並んでいます。詳細については注記を参照してください。
`dynamicOffsetsDataStart`	`GPUSize64`	✘	✘	`dynamicOffsetsData` 内の、バッファオフセットデータが始まる要素のオフセット。
`dynamicOffsetsDataLength`	`GPUSize32`	✘	✘	`dynamicOffsetsData` から読み取るバッファオフセットの数。

戻り値: undefined

以下の要件のいずれかが満たされない場合、RangeError を投げて終了します。
- dynamicOffsetsDataStart は ≥ 0 でなければなりません。
- dynamicOffsetsDataStart + dynamicOffsetsDataLength は dynamicOffsetsData.length 以下でなければなりません。
dynamicOffsets を、list として、 dynamicOffsetsDataStart から始まる dynamicOffsetsDataLength 個の要素について、コピーされた dynamicOffsetsData の範囲を含むものとします。
次に this.setBindGroup(index, bindGroup, dynamicOffsets) を呼び出します。

注:

動的オフセットは GPUBindGroupLayoutEntry.binding 順に適用されます。

つまり、もし dynamic bindings が GPUBindGroupLayoutEntry の各要素で、 GPUBindGroupLayout 内で buffer?.hasDynamicOffset が true に設定され、かつ GPUBindGroupLayoutEntry.binding でソートされているなら、setBindGroup() に渡された dynamic offset[i] は dynamic bindings[i] に対応します。

次の呼び出しで作成された GPUBindGroupLayout を例とします。

// Note the bindings are listed out-of-order in this array, but it
// doesn't matter because they will be sorted by binding index.
let layout = gpuDevice.createBindGroupLayout({
    entries: [{
        binding: 1,
        buffer: {},
    }, {
        binding: 2,
        buffer: { dynamicOffset: true },
    }, {
        binding: 0,
        buffer: { dynamicOffset: true },
    }]
});

次の呼び出しで作成された GPUBindGroup によって使用されます:

// Like above, the array order doesn't matter here.
// It doesn't even need to match the order used in the layout.
let bindGroup = gpuDevice.createBindGroup({
    layout: layout,
    entries: [{
        binding: 1,
        resource: { buffer: bufferA, offset: 256 },
    }, {
        binding: 2,
        resource: { buffer: bufferB, offset: 512 },
    }, {
        binding: 0,
        resource: { buffer: bufferC },
    }]
});

そして次の呼び出しでバインドされます:

pass.setBindGroup(0, bindGroup, [1024, 2048]);

次のバッファオフセットが適用されます:

Binding	Buffer	Offset
0	bufferC	1024 (動的)
1	bufferA	256 (静的)
2	bufferB	2560 (静的 + 動的)

指定された GPUBindGroup bindGroup 内の各動的バインディングオフセットに対して、各動的オフセットごとに実行する steps のリストを指定し、次のデバイスタイムラインのステップを実行します：

dynamicOffsetIndex を 0 にします。
layout を bindGroup.[[layout]] とします。
bindGroup.[[entries]] 内の各 GPUBindGroupEntry entry を、entry.binding の増加順に処理します:
1. bindingDescriptor を layout.[[entryMap]][entry.binding] とします。
2. もし bindingDescriptor.buffer?.hasDynamicOffset が true なら:
  1. bufferBinding を get as buffer binding(entry.resource) とします。
  2. bufferLayout を bindingDescriptor.buffer とします。
  3. steps を bufferBinding, bufferLayout, および dynamicOffsetIndex で呼び出します。
  4. dynamicOffsetIndex を dynamicOffsetIndex + 1 にします。

エンコーダーのバインドグループを検証する(encoder, pipeline)

引数:

GPUBindingCommandsMixin encoder: バインドグループが検証されるエンコーダー。
GPUPipelineBase pipeline: エンコーダーのバインドグループが互換性があるか検証するパイプライン。

Device timeline の手順:

以下の条件のいずれかが満たされない場合、false を返します:
- bindGroupLayouts を pipeline.[[layout]].[[bindGroupLayouts]] とします。
- pipeline は null であってはなりません。
- パイプラインで使用されるすべてのバインドグループは設定され、パイプラインレイアウトと互換でなければなりません。判定は次の通りです:
  
  bindGroupLayouts 内の各 (GPUIndex32 index, GPUBindGroupLayout bindGroupLayout) について:
  - もし bindGroupLayout が null なら、continue します。
  - bindGroup を encoder.[[bind_groups]][index] とします。
  - dynamicOffsets を encoder.[[dynamic_offsets]][index] とします。
  - bindGroup は null であってはなりません。
  - bindGroup.[[layout]] は group-equivalent で bindGroupLayout と一致していなければなりません。
  - dynamicOffsetIndex を 0 にします。
  - bindGroup.[[entries]] 内の各 GPUBindGroupEntry bindGroupEntry を、bindGroupEntry.binding でソートした順に処理します:
    - bindGroupLayoutEntry を bindGroup.[[layout]].[[entryMap]][bindGroupEntry.binding] とします。
    - もし bindGroupLayoutEntry.buffer が提供されていない場合、continue します。
    - bound を get as buffer binding(bindGroupEntry.resource) とします。
    - もし bindGroupLayoutEntry.buffer.hasDynamicOffset なら:
      
      bound.offset に dynamicOffsets[dynamicOffsetIndex] を加算します。
      
      dynamicOffsetIndex を 1 増やします。
    - もし bindGroupEntry.[[prevalidatedSize]] が false の場合:
      
      effective buffer binding size(bound) は、minimum buffer binding size （パイプラインのシェーダー内で bindGroupEntry に対応するバインディング変数）以上でなければなりません。
- エンコーダーのバインドグループが書き込み可能なリソースとエイリアスしているか(encoder, pipeline) は false でなければなりません。
- もし encoder.[[device]].[[features]] が "core-features-and-limits" "core-features-and-limits" を含まない場合：
  - 同じ GPUTexture を参照するすべてのバインディングは互換性のある GPUTextureView を持たなければなりません。判定は次の通りです:
    
    bindGroupLayouts 内の各 (GPUIndex32 index1, GPUBindGroupLayout bindGroupLayout1) について:
    
    もし bindGroupLayout1 が null なら、continue します。
    
    bindGroup1 を encoder.[[bind_groups]][index1] とします。
    
    bindGroup1.[[entries]] 内の各 GPUBindGroupEntry bindGroupEntry1 について:
    
    もし bindGroupEntry1.resource が GPUTextureView でないなら、continue します。
    
    descriptor1 を bindGroupEntry1.resource.[[descriptor]] とします。
    
    bindGroupLayouts 内の各 (GPUIndex32 index2, GPUBindGroupLayout bindGroupLayout2) について:
    
    もし bindGroupLayout2 が null なら、continue します。
    
    bindGroup2 を encoder.[[bind_groups]][index2] とします。
    
    bindGroup2.[[entries]] 内の各 GPUBindGroupEntry bindGroupEntry2 について:
    
    もし bindGroupEntry2.resource が GPUTextureView でないなら、continue します。
    
    もし bindGroupEntry1.resource.[[texture]] が bindGroupEntry2.resource.[[texture]] と等しくない場合、continue します。
    
    descriptor2 を bindGroupEntry2.resource.[[descriptor]] とします。
    
    descriptor2.baseMipLevel は descriptor1.baseMipLevel と等しくなければなりません。
    
    descriptor2.mipLevelCount は descriptor1.mipLevelCount と等しくなければなりません。
    
    descriptor2.aspect は descriptor1.aspect と等しくなければなりません。
    
    descriptor2.swizzle は descriptor1.swizzle と等しくなければなりません。

それ以外の場合は true を返します。

エンコーダーのバインドグループが書き込み可能なリソースとエイリアスしているか(encoder, pipeline) — 任意の書き込み可能なバッファバインディング範囲が同じバッファの他のバインディング範囲と重複する場合、あるいは任意の書き込み可能なテクスチャバインディングが他のテクスチャバインディングと（同じまたは異なる）GPUTextureView オブジェクトを用いてテクスチャサブリソースで重複する場合に true になります。

注: このアルゴリズムは usage scope storage exception の使用を制限します。

引数:

GPUBindingCommandsMixin encoder: バインドグループが検証されるエンコーダー。
GPUPipelineBase pipeline: エンコーダーのバインドグループが互換性があるか検証するパイプライン。

Device timeline の手順:

各 stage について [VERTEX, FRAGMENT, COMPUTE] について次を行います:
1. bufferBindings を (GPUBufferBinding, boolean) ペアのリストとします。後者はそのリソースが書き込みとして使われたかを示します。
2. textureViews を (GPUTextureView, boolean) ペアのリストとします。後者はそのリソースが書き込みとして使われたかを示します。
3. pipeline.[[layout]].[[bindGroupLayouts]] の各 (GPUIndex32 bindGroupIndex, GPUBindGroupLayout bindGroupLayout) について次を行います:
  1. bindGroup を encoder.[[bind_groups]][bindGroupIndex] とします。
  2. bindGroupLayoutEntries を bindGroupLayout.[[descriptor]].entries とします。
  3. bufferRanges を、動的オフセットとして encoder.[[dynamic_offsets]][bindGroupIndex] を用いた bindGroup のバインドされたバッファ範囲とします。
  4. bufferRanges 内の各 (GPUBindGroupLayoutEntry bindGroupLayoutEntry, GPUBufferBinding resource) について、その bindGroupLayoutEntry.visibility が stage を含む場合に次を行います:
    1. resourceWritable を (bindGroupLayoutEntry.buffer.type == "storage") とします。
    2. bufferBindings 内の各 (GPUBufferBinding pastResource, boolean pastResourceWritable) について次を行います:
      1. もし (resourceWritable または pastResourceWritable) が true で、かつ pastResource と resource が buffer-binding-aliasing であるなら、true を返します。
    3. Append (resource, resourceWritable) を bufferBindings に追加します。
  5. bindGroupLayoutEntries 内の各 GPUBindGroupLayoutEntry bindGroupLayoutEntry と対応する GPUTextureView の resource について、その bindGroupLayoutEntry.visibility が stage を含む場合に次を行います:
    1. もし bindGroupLayoutEntry.storageTexture が提供されていないなら、continue します。
    2. resourceWritable を bindGroupLayoutEntry.storageTexture.access が書き込み可能なアクセスモードかどうかで決めます。
    3. textureViews 内の各 (GPUTextureView pastResource, boolean pastResourceWritable) について次を行います:
      1. もし (resourceWritable または pastResourceWritable) が true で、かつ pastResource と resource が texture-view-aliasing であるなら、true を返します。
    4. Append (resource, resourceWritable) を textureViews に追加します。
false を返します。

注: 実装はこのアルゴリズムを最適化することが強く推奨されます。

15. デバッグマーカー

GPUDebugCommandsMixinは、コマンドグループにデバッグラベルを適用したり、コマンド列に単一ラベルを挿入したりするためのメソッドを提供します。

デバッググループは入れ子にして、ラベル付きコマンドの階層を作ることができ、バランスが取れていなければなりません。

オブジェクトラベルと同様、これらのラベルには必須の動作はありませんが、エラーメッセージやブラウザ開発者ツールに表示されたり、ネイティブAPIバックエンドに渡されたりする場合があります。

interface mixin GPUDebugCommandsMixin {
    undefined pushDebugGroup(USVString groupLabel);
    undefined popDebugGroup();
    undefined insertDebugMarker(USVString markerLabel);
};

GPUDebugCommandsMixin は同じオブジェクト上に GPUObjectBase と GPUCommandsMixin のメンバーが存在することを前提としています。これらのミックスインも含むインターフェイスのみがGPUDebugCommandsMixinをincludeできます。

GPUDebugCommandsMixin には以下のデバイスタイムラインプロパティがあります:

[[debug_group_stack]], 型 stack<USVString>: アクティブなデバッググループラベルのスタック。

GPUDebugCommandsMixin には以下のメソッドがあります:

pushDebugGroup(groupLabel)

後続のコマンドを含むラベル付きデバッググループを開始します。

Called on: GPUDebugCommandsMixin の this。

Arguments:

メソッド GPUDebugCommandsMixin.pushDebugGroup(groupLabel) の引数。
Parameter	Type	Nullable	Optional	Description
`groupLabel`	`USVString`	✘	✘	コマンドグループのラベル。

Returns: undefined

Content timeline の手順:

次の手順を this.[[device]] の Device timeline 上で発行します。

Device timeline の手順:

Validate the encoder state を this に対して実行します。false が返った場合は戻ります。
Push groupLabel を this.[[debug_group_stack]] に追加します。

popDebugGroup()

pushDebugGroup() によって直近に開始されたラベル付きデバッググループを終了します。

Called on: GPUDebugCommandsMixin の this。

Returns: undefined

Content timeline の手順:

次の手順を this.[[device]] の Device timeline 上で発行します。

Device timeline の手順:

Validate the encoder state を this に対して実行します。false が返った場合は戻ります。
以下の要件のいずれかが満たされない場合、invalidate を this に対して行い、戻ります。
- this.[[debug_group_stack]] は空であってはなりません。
Pop を用いて this.[[debug_group_stack]] からエントリを取り出します。

insertDebugMarker(markerLabel)

コマンドの流れのある点をラベルでマークします。

Called on: GPUDebugCommandsMixin の this。

Arguments:

メソッド GPUDebugCommandsMixin.insertDebugMarker(markerLabel) の引数。
Parameter	Type	Nullable	Optional	Description
`markerLabel`	`USVString`	✘	✘	挿入するラベル。

Returns: undefined

Content timeline の手順:

次の手順を this.[[device]] の Device timeline 上で発行します。

Device timeline の手順:

Validate the encoder state を this に対して実行します。false が返った場合は戻ります。

16. コンピュートパス

16.1. `GPUComputePassEncoder`

[Exposed=(Window, Worker), SecureContext]
interface GPUComputePassEncoder {
    undefined setPipeline(GPUComputePipeline pipeline);
    undefined dispatchWorkgroups(GPUSize32 workgroupCountX, optional GPUSize32 workgroupCountY = 1, optional GPUSize32 workgroupCountZ = 1);
    undefined dispatchWorkgroupsIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);

    undefined end();
};
GPUComputePassEncoder includes GPUObjectBase;
GPUComputePassEncoder includes GPUCommandsMixin;
GPUComputePassEncoder includes GPUDebugCommandsMixin;
GPUComputePassEncoder includes GPUBindingCommandsMixin;

GPUComputePassEncoder には以下のデバイスタイムラインプロパティがあります:

[[command_encoder]], 型 GPUCommandEncoder, 読み取り専用: このコンピュートパスエンコーダを生成したGPUCommandEncoder。
[[endTimestampWrite]], 型 GPU command?, 読み取り専用, デフォルトはnull: パス終了時にタイムスタンプを書き込むGPUコマンド（ある場合）。
[[pipeline]], 型 GPUComputePipeline, 初期値はnull: 現在のGPUComputePipeline。

16.1.1. コンピュートパスエンコーダ生成

dictionary GPUComputePassTimestampWrites {
    required GPUQuerySet querySet;
    GPUSize32 beginningOfPassWriteIndex;
    GPUSize32 endOfPassWriteIndex;
};

querySet、型：GPUQuerySet: クエリ結果が書き込まれる GPUQuerySet。型は "timestamp" です。
beginningOfPassWriteIndex、型：GPUSize32: 指定された場合、コンピュートパスの開始時のタイムスタンプが書き込まれる querySet 内のクエリインデックスを示します。
endOfPassWriteIndex、型：GPUSize32: 指定された場合、コンピュートパスの終了時のタイムスタンプが書き込まれる querySet 内のクエリインデックスを示します。

注：タイムスタンプクエリーの値はナノ秒単位で書き込まれますが、その値がどのように決定されるかは実装依存です。詳細は § 20.4 タイムスタンプクエリーを参照してください。

dictionary GPUComputePassDescriptor
         : GPUObjectDescriptorBase {
    GPUComputePassTimestampWrites timestampWrites;
};

timestampWrites, 型 GPUComputePassTimestampWrites: このパスでどのタイムスタンプ値を書き込み、どこに書き込むかを定義します。

16.1.2. ディスパッチ

setPipeline(pipeline)

現在の GPUComputePipeline を設定します。

呼び出し元: GPUComputePassEncoder の this。

引数:

GPUComputePassEncoder.setPipeline(pipeline) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`pipeline`	`GPUComputePipeline`	✘	✘	以降のディスパッチコマンドに使用するコンピュートパイプライン。

戻り値: undefined

コンテントタイムラインの手順:

次の手順を this.[[device]] のDevice timelineに発行します。

Device timeline の手順:

Encoderの状態を検証(this) を実行します。false なら終了。
次の条件のいずれかが満たされない場合は、invalidate を this に対して行い、終了します。
- pipeline は this で使用可能でなければなりません。
this.[[pipeline]] を pipeline に設定します。

dispatchWorkgroups(workgroupCountX, workgroupCountY, workgroupCountZ)

現在のGPUComputePipelineで行うべき処理をディスパッチします。詳細仕様については§ 23.1 コンピューティングを参照してください。

呼び出し元: GPUComputePassEncoder の this。

引数:

GPUComputePassEncoder.dispatchWorkgroups(workgroupCountX, workgroupCountY, workgroupCountZ) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`workgroupCountX`	`GPUSize32`	✘	✘	ディスパッチするワークグループのX方向のグリッド数。
`workgroupCountY`	`GPUSize32`	✘	✔	ディスパッチするワークグループのY方向のグリッド数。
`workgroupCountZ`	`GPUSize32`	✘	✔	ディスパッチするワークグループのZ方向のグリッド数。

注:

x、y、z の値（dispatchWorkgroups() および dispatchWorkgroupsIndirect() へ渡す）は、それぞれの次元の ワークグループ数 であって、各次元のシェーダ呼び出し回数 ではありません。これは現代のネイティブGPU APIの動作と一致しますが、OpenCLの動作とは異なります。

例えば、GPUShaderModule でエントリポイントを @workgroup_size(4, 4) と定義し、 computePass.dispatchWorkgroups(8, 8); とディスパッチした場合、エントリポイントは合計で1024回呼び出されます。つまり 4x4 のワークグループを、X軸/Y軸でそれぞれ8回ディスパッチします。（4*4*8*8=1024）

戻り値: undefined

コンテントタイムラインの手順:

次の手順を this.[[device]] のDevice timelineに発行します。

Device timeline の手順:

Encoderの状態を検証(this) を実行します。false なら終了。
usageScope を空のusage scopeとします。
this.[[bind_groups]] の各 bindGroup について、 merge で bindGroup.[[usedResources]] を this.[[usage scope]] に統合します。
次の条件のいずれかが満たされない場合は、invalidate を this に対して行い、終了します。
- usageScope はusage scope validationを満たす必要があります。
- Validate encoder bind groups(this, this.[[pipeline]]) が true であること。
- workgroupCountX、workgroupCountY、workgroupCountZ のすべてが、 this.device.limits.maxComputeWorkgroupsPerDimension 以下であること。
bindingState を、this の現状態のスナップショットとします。
Enqueue a command を this に発行し、以降の手順をQueue timeline上で行います。

Queue timeline の手順:

[workgroupCountX, workgroupCountY, workgroupCountZ] のサイズのワークグループグリッドを bindingState.[[pipeline]] で実行し、 bindingState.[[bind_groups]] を使用します。

dispatchWorkgroupsIndirect(indirectBuffer, indirectOffset)

現在の GPUComputePipeline で GPUBufferから読み取ったパラメータを用いてディスパッチします。詳細な仕様は§ 23.1 コンピューティングを参照してください。

バッファ内にエンコードされる indirect dispatch parameters は、 3つの32ビット符号なし整数値（合計12バイト）の緊密なブロックであり、 dispatchWorkgroups() の引数と同じ順番で格納してください。例:

let dispatchIndirectParameters = new Uint32Array(3);
dispatchIndirectParameters[0] = workgroupCountX;
dispatchIndirectParameters[1] = workgroupCountY;
dispatchIndirectParameters[2] = workgroupCountZ;

呼び出し元: GPUComputePassEncoder の this。

引数:

GPUComputePassEncoder.dispatchWorkgroupsIndirect(indirectBuffer, indirectOffset) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`indirectBuffer`	`GPUBuffer`	✘	✘	indirect dispatch parameters を含むバッファ。
`indirectOffset`	`GPUSize64`	✘	✘	`indirectBuffer` の何バイト目からディスパッチデータが開始するかのオフセット。

戻り値: undefined

コンテントタイムラインの手順:

次の手順を this.[[device]] のDevice timelineに発行します。

Device timeline の手順:

Encoderの状態を検証(this) を実行します。false なら終了。
usageScope を空のusage scopeとします。
this.[[bind_groups]] の各 bindGroup について、 merge で bindGroup.[[usedResources]] を this.[[usage scope]] に統合します。
Add により indirectBuffer を usageScope に input 用途で追加します。
次の条件のいずれかが満たされない場合は、invalidate を this に対して行い、終了します。
- usageScope はusage scope validationを満たす必要があります。
- Validate encoder bind groups(this, this.[[pipeline]]) が true であること。
- indirectBuffer は this で使用可能であること。
- indirectBuffer.usage が INDIRECT を含むこと。
- indirectOffset + sizeof(indirect dispatch parameters) が indirectBuffer.size 以下であること。
- indirectOffset は 4 の倍数であること。
bindingState を、this の現状態のスナップショットとします。
Enqueue a command を this に発行し、以降の手順をQueue timeline上で行います。

Queue timeline の手順:

indirectBuffer の indirectOffset バイト位置から符号なし32bit整数として workgroupCountX を読み出します。
indirectBuffer の (indirectOffset + 4) バイト位置から workgroupCountY を読み出します。
indirectBuffer の (indirectOffset + 8) バイト位置から workgroupCountZ を読み出します。
もし workgroupCountX または workgroupCountY または workgroupCountZ のいずれかが this.device.limits.maxComputeWorkgroupsPerDimension を超えていたら、処理を終了する。
[workgroupCountX, workgroupCountY, workgroupCountZ] のサイズのワークグループグリッドを bindingState.[[pipeline]] で実行し、 bindingState.[[bind_groups]] を使用します。

16.1.3. ファイナライズ

ユーザーがパスのコマンド記録を完了したら end() を呼び出すことでコンピュートパスエンコーダを終了できます。end() が呼び出されると、コンピュートパスエンコーダはそれ以降使用できません。

end()

コンピュートパスコマンドのシーケンスの記録を完了します。

呼び出し元: GPUComputePassEncoder の this。

戻り値: undefined

次の手順を this.[[device]] の Device timeline で発行します。

Device timeline の手順:

parentEncoder を this.[[command_encoder]] とします。
次の要件のいずれかが満たされない場合、検証エラーを生成して終了します。
- this.[[state]] は "open" でなければなりません。
- parentEncoder.[[state]] は "locked" でなければなりません。
this.[[state]] を "ended" に設定します。
parentEncoder.[[state]] を "open" に設定します。
Extend を用い、parentEncoder.[[used_bind_groups]] に this.[[used_bind_groups]] を追加します。
次の要件のいずれかが満たされない場合、parentEncoder を無効化して終了します。
- this が valid でなければなりません。
- this.[[debug_group_stack]] は空でなければなりません。
Extend を用い、 parentEncoder.[[commands]] に this.[[commands]] を追加します。
もし this.[[endTimestampWrite]] が null でない場合:
1. Extend を用い、 parentEncoder.[[commands]] に this.[[endTimestampWrite]] を追加します。

17. レンダーパス

17.1. `GPURenderPassEncoder`

[Exposed=(Window, Worker), SecureContext]
interface GPURenderPassEncoder {
    undefined setViewport(float x, float y,
        float width, float height,
        float minDepth, float maxDepth);

    undefined setScissorRect(GPUIntegerCoordinate x, GPUIntegerCoordinate y,
                        GPUIntegerCoordinate width, GPUIntegerCoordinate height);

    undefined setBlendConstant(GPUColor color);
    undefined setStencilReference(GPUStencilValue reference);

    undefined beginOcclusionQuery(GPUSize32 queryIndex);
    undefined endOcclusionQuery();

    undefined executeBundles(sequence<GPURenderBundle> bundles);
    undefined end();
};
GPURenderPassEncoder includes GPUObjectBase;
GPURenderPassEncoder includes GPUCommandsMixin;
GPURenderPassEncoder includes GPUDebugCommandsMixin;
GPURenderPassEncoder includes GPUBindingCommandsMixin;
GPURenderPassEncoder includes GPURenderCommandsMixin;

GPURenderPassEncoder には以下のデバイスタイムラインプロパティがあります:

[[command_encoder]]、型は GPUCommandEncoder、読み取り専用

このレンダーパスエンコーダーを生成した GPUCommandEncoder です。

[[attachment_size]]、読み取り専用

次のエクステントに設定されます:

width, height = パスのレンダーアタッチメントの寸法

[[occlusion_query_set]]、型は GPUQuerySet、読み取り専用

このパスのオクルージョンクエリ結果を格納する GPUQuerySet であり、パス作成時に GPURenderPassDescriptor.occlusionQuerySet で初期化されます。

[[endTimestampWrite]]、型は GPU command?、読み取り専用、デフォルトは null

パス終了時にタイムスタンプを書き込む GPU command（もしあれば）。

[[maxDrawCount]]、型は GPUSize64、読み取り専用

このパスで許可される最大ドロー回数です。

[[occlusion_query_active]]、型は boolean

パスの [[occlusion_query_set]] への書き込みが行われているかどうか。

エンコードされたレンダーパスコマンドを GPUCommandBuffer の一部として実行するとき、内部で RenderState オブジェクトが描画に必要な現在の状態を追跡するために使用されます。

RenderState は次の queue timeline プロパティを持ちます:

[[occlusionQueryIndex]]、型は GPUSize32

[[occlusion_query_set]] 内でオクルージョンクエリ結果を保存するインデックスです。

[[viewport]]

現在のビューポートの矩形とデプス範囲。初期値は次の通りです:

x, y = 0.0, 0.0
width, height = パスのレンダーターゲットの寸法
minDepth, maxDepth = 0.0, 1.0

[[scissorRect]]

現在のシザー矩形。初期値は次の通りです:

x, y = 0, 0
width, height = パスのレンダーターゲットの寸法

[[blendConstant]]、型は GPUColor

現在のブレンド定数値。初期値は [0, 0, 0, 0] です。

[[stencilReference]]、型は GPUStencilValue

現在のステンシルリファレンス値。初期値は 0 です。

[[colorAttachments]]、型は sequence<GPURenderPassColorAttachment?>

このレンダーパスのカラ―アタッチメントとその状態です。

[[depthStencilAttachment]]、型は GPURenderPassDepthStencilAttachment?

このレンダーパスのデプス/ステンシルアタッチメントとその状態です。

レンダーパスにはframebuffer memoryもあり、各アタッチメントに対応するテクセルデータを格納し、ドローコマンドで書き込まれたり、ブレンドやデプス／ステンシルテストで読み取られたりする。

注: GPUハードウェアによっては、framebuffer memoryがアタッチメントテクスチャで割り当てられたメモリである場合や、タイルベースアーキテクチャのようにテクスチャデータがコピーされる別領域のメモリである場合もある。

17.1.1. レンダーパスエンコーダ生成

dictionary GPURenderPassTimestampWrites {
    required GPUQuerySet querySet;
    GPUSize32 beginningOfPassWriteIndex;
    GPUSize32 endOfPassWriteIndex;
};

querySet、型：GPUQuerySet: クエリ結果が書き込まれる GPUQuerySet です。型は "timestamp" です。
beginningOfPassWriteIndex、型：GPUSize32: 指定された場合、レンダーパス開始時のタイムスタンプが書き込まれる querySet のクエリインデックスを示します。
endOfPassWriteIndex、型：GPUSize32: 指定された場合、レンダーパス終了時のタイムスタンプが書き込まれる querySet のクエリインデックスを示します。

注：タイムスタンプクエリの値はナノ秒単位で書き込まれますが、その値がどのように決定されるかは実装依存です。詳細は § 20.4 タイムスタンプクエリを参照してください。

dictionary GPURenderPassDescriptor
         : GPUObjectDescriptorBase {
    required sequence<GPURenderPassColorAttachment?> colorAttachments;
    GPURenderPassDepthStencilAttachment depthStencilAttachment;
    GPUQuerySet occlusionQuerySet;
    GPURenderPassTimestampWrites timestampWrites;
    GPUSize64 maxDrawCount = 50000000;
};

colorAttachments, 型 sequence<GPURenderPassColorAttachment?>

このシーケンス内のGPURenderPassColorAttachment値の集合が、このレンダーパスの実行時に出力されるカラーアタッチメントを定義します。

使用互換性のため、どのカラーアタッチメントも他のアタッチメントやパス内で使われるリソースとエイリアスしてはなりません。

depthStencilAttachment, 型 GPURenderPassDepthStencilAttachment

実行時に出力・テストされるデプス／ステンシルアタッチメントを定義するGPURenderPassDepthStencilAttachment値。

使用互換性のため、どの書き込み可能なデプス／ステンシルアタッチメントも他のアタッチメントやパス内で使われるリソースとエイリアスしてはなりません。

occlusionQuerySet, 型 GPUQuerySet

このパスのオクルージョンクエリ結果の格納先を定義するGPUQuerySet値。

timestampWrites, 型 GPURenderPassTimestampWrites

このパスでどのタイムスタンプ値を書き込み、どこに書き込むかを定義します。

maxDrawCount, 型 GPUSize64、デフォルト値は50000000

このレンダーパスで実行される最大ドロー呼び出し数。一部の実装ではレンダーパス前に投入される処理のサイズ決定に使われます。デフォルト値のままで問題ありませんが、より多くのドロー呼び出しが行われることが分かっている場合は調整してください。

有効な使用方法

GPUDevice deviceとGPURenderPassDescriptor thisが与えられた場合、以下の検証ルールが適用されます:

this.colorAttachments.size は device.[[limits]].maxColorAttachments 以下でなければなりません。
this.colorAttachments 内の null でない各 colorAttachment について:
1. colorAttachment.view は device で使用可能でなければなりません。
2. もし colorAttachment.resolveTarget が提供されている場合:
  1. colorAttachment.resolveTarget は device で使用可能でなければなりません。
3. colorAttachment は GPURenderPassColorAttachment Valid Usage のルールを満たさなければなりません。
もし this.depthStencilAttachment が提供されている場合:
1. this.depthStencilAttachment.view は device で使用可能でなければなりません。
2. this.depthStencilAttachment は GPURenderPassDepthStencilAttachment Valid Usage のルールを満たさなければなりません。
少なくとも1つのアタッチメントが存在しなければなりません。例えば:
- this.colorAttachments 内に null でない値がある、もしくは
- this.depthStencilAttachment が存在する。
GPURenderPassDescriptorのcolor attachment bytes per sampleの検証(device, this.colorAttachments) に成功すること。
null でない this.colorAttachments の各メンバーおよび this.depthStencilAttachment が存在する場合はその .view について、すべての sampleCount が等しくなければなりません。
null でない this.colorAttachments の各メンバーおよび this.depthStencilAttachment が存在する場合はその .view の [[renderExtent]] も一致しなければなりません。
もし this.occlusionQuerySet が提供されている場合:
1. this.occlusionQuerySet は device で使用可能でなければなりません。
2. this.occlusionQuerySet.type は occlusion でなければなりません。
もし this.timestampWrites が提供されている場合:
- timestampWritesの検証(device, this.timestampWrites) の結果は true でなければなりません。

GPURenderPassDescriptor のカラーアタッチメントのサンプルごとのバイト数の検証(device, colorAttachments)

引数:

GPUDevice device
sequence<GPURenderPassColorAttachment?> colorAttachments

デバイスタイムラインの手順:

formats を空のリスト<GPUTextureFormat?> とします。
colorAttachments 内の各 colorAttachment について:
1. もし colorAttachment が undefined なら、continue。
2. Append で colorAttachment.view.[[descriptor]].format を formats に追加する。
カラーアタッチメントのサンプルごとのバイト数の計算(formats) の結果は device.[[limits]].maxColorAttachmentBytesPerSample 以下でなければなりません。

17.1.1.1. カラ―アタッチメント

dictionary GPURenderPassColorAttachment {
    required (GPUTexture or GPUTextureView) view;
    GPUIntegerCoordinate depthSlice;
    (GPUTexture or GPUTextureView) resolveTarget;

    GPUColor clearValue;
    required GPULoadOp loadOp;
    required GPUStoreOp storeOp;
};

view, 型：(GPUTexture または GPUTextureView)

このカラ―アタッチメントの出力先となるテクスチャサブリソースを記述します。サブリソースは、 get as texture view(view) の結果で決まります。

depthSlice, 型：GPUIntegerCoordinate

このカラ―アタッチメントの出力先となる "3d" view のデプススライスインデックスを指定します。

resolveTarget, 型： (GPUTexture または GPUTextureView)

もし view がマルチサンプルの場合、このカラ―アタッチメントの結果を受け取るテクスチャサブリソースを記述します。サブリソースは get as texture view(resolveTarget) により決定されます。

clearValue, 型：GPUColor

レンダーパスを実行する前に view をクリアする値を示します。指定されていない場合、デフォルトは {r: 0, g: 0, b: 0, a: 0} です。 loadOp が "clear" 以外の場合は無視されます。

clearValue の各成分は全て double 値です。これらはレンダーアタッチメントと一致するテクスチャフォーマットのテクセル値へ変換されます。変換に失敗した場合はバリデーションエラーとなります。

loadOp, 型：GPULoadOp

レンダーパス実行前に view に対して行うロード操作を示します。

注:クリアを優先することが推奨されています。詳細は "clear" を参照してください。

storeOp, 型：GPUStoreOp

レンダーパス実行後に view に対して行うストア操作です。

GPURenderPassColorAttachment 有効使用条件

GPURenderPassColorAttachment this が与えられたとき：

renderViewDescriptor を this.view.[[descriptor]] とします。
renderTexture を this.view.[[texture]] とします。
以下のすべての要件を満たす必要があります。
1. renderViewDescriptor.format はカラー描画可能フォーマットでなければなりません。
2. this.view は描画可能テクスチャビューでなければなりません。
3. もし renderViewDescriptor.dimension が "3d" の場合：
  1. this.depthSlice は指定され、ロジカルmiplevel別テクスチャエクステントの depthOrArrayLayers より小さくなければなりません（このサブリソースは mipmap level renderViewDescriptor.baseMipLevelで）。
  それ以外の場合：
  1. this.depthSlice は指定されていてはなりません。
4. もし this.loadOp が "clear" の場合：
  1. IDL値の this.clearValue をテクセル値へ変換した結果が renderViewDescriptor.format に対して TypeError を投げてはなりません。
    
    注: 値がフォーマットの範囲外でも、WGSLのプリミティブ型（f32, i32, u32）の範囲内であればエラーにはなりません。
5. もし this.resolveTarget が指定されている場合：
  1. resolveViewDescriptor を this.resolveTarget.[[descriptor]] とする。
  2. resolveTexture を this.resolveTarget.[[texture]] とする。
  3. renderTexture.sampleCount は1より大きくなければなりません。
  4. resolveTexture.sampleCount は1でなければなりません。
  5. this.resolveTarget は3Dでない描画可能テクスチャビューでなければなりません。
  6. this.resolveTarget.[[renderExtent]] と this.view.[[renderExtent]] が一致しなければなりません。
  7. resolveViewDescriptor.format は renderViewDescriptor.format と等しくなければなりません。
  8. resolveTexture.format は renderTexture.format と等しくなければなりません。
  9. resolveViewDescriptor.format は§ 26.1.1 プレーンカラーフォーマットに従い、リゾルブ対応フォーマットでなければなりません。

GPUTextureView view は、もし次のデバイスタイムライン手順のすべてを満たす場合描画可能テクスチャビューです：

descriptor を view.[[descriptor]] とする。
descriptor.usage は RENDER_ATTACHMENT を含む必要があります。
descriptor.dimension は "2d" または "2d-array" または "3d" でなければなりません。
descriptor.mipLevelCount は1でなければなりません。
descriptor.arrayLayerCount は1でなければなりません。
descriptor.aspect は view.[[texture]] のすべてのアスペクトを参照していなければなりません。
descriptor.swizzle は"rgba"でなければなりません。

カラーアタッチメントのサンプルごとのバイト数の計算(formats)

引数:

sequence<GPUTextureFormat?> formats

戻り値: GPUSize32

total を 0 とする。
formats 内の非nullの各 format について
1. Assert: format がカラー描画可能フォーマットである。
2. renderTargetPixelByteCost を format の render target pixel byte costとする。
3. renderTargetComponentAlignment を format の render target component alignmentとする。
4. total を renderTargetComponentAlignment の最小の倍数（total以上）に切り上げる。
5. renderTargetPixelByteCost を total に加算する。
total を返す。

17.1.1.2. デプス／ステンシルアタッチメント

dictionary GPURenderPassDepthStencilAttachment {
    required (GPUTexture or GPUTextureView) view;

    float depthClearValue;
    GPULoadOp depthLoadOp;
    GPUStoreOp depthStoreOp;
    boolean depthReadOnly = false;

    GPUStencilValue stencilClearValue = 0;
    GPULoadOp stencilLoadOp;
    GPUStoreOp stencilStoreOp;
    boolean stencilReadOnly = false;
};

view, 型 (GPUTexture または GPUTextureView)

このデプス／ステンシルアタッチメントで出力・読み取りされるテクスチャサブリソースを記述します。サブリソースはget as texture view(view)呼び出しで決定されます。

depthClearValue, 型 float

レンダーパス実行前にviewのデプス成分をクリアする値を示します。 depthLoadOp が"clear"でない場合は無視されます。 0.0以上1.0以下でなければなりません。

depthLoadOp, 型 GPULoadOp

レンダーパス実行前にviewのデプス成分に対して行うロード操作を示します。

注: クリアを推奨します。詳細は "clear" を参照してください。

depthStoreOp, 型 GPUStoreOp

レンダーパス実行後にviewのデプス成分に対して行うストア操作。

depthReadOnly, 型 boolean, デフォルトはfalse

viewのデプス成分が読み取り専用であることを示します。

stencilClearValue, 型 GPUStencilValue, デフォルトは 0

レンダーパス実行前にviewのステンシル成分をクリアする値を示します。 stencilLoadOp が"clear"でない場合は無視されます。

値はviewのステンシルアスペクトの型に変換され、1テクセル分のステンシルアスペクトビット数分のLSBを利用します。

stencilLoadOp, 型 GPULoadOp

レンダーパス実行前にviewのステンシル成分に対して行うロード操作を示します。

注: クリアを推奨します。詳細は "clear" を参照してください。

stencilStoreOp, 型 GPUStoreOp

レンダーパス実行後にviewのステンシル成分に対して行うストア操作。

stencilReadOnly, 型 boolean, デフォルトはfalse

viewのステンシル成分が読み取り専用であることを示します。

GPURenderPassDepthStencilAttachment 有効使用条件

GPURenderPassDepthStencilAttachment の this に対して、次のバリデーションルールが適用されます：

this.view はデプスまたはステンシルフォーマットを持っていなければなりません。
this.view は描画可能テクスチャビューでなければなりません。
format を this.view.[[descriptor]].format とする。
もし this.depthLoadOp が "clear" の場合、 this.depthClearValue は指定され、0.0以上1.0以下でなければなりません。
もし format がデプスアスペクトを持ち、かつ this.depthReadOnly が false の場合：
- this.depthLoadOp は指定されていなければなりません。
- this.depthStoreOp は指定されていなければなりません。
それ以外の場合：
- this.depthLoadOp は指定されていてはなりません。
- this.depthStoreOp は指定されていてはなりません。
もし format がステンシルアスペクトを持ち、かつ this.stencilReadOnly が false の場合：
- this.stencilLoadOp は指定されていなければなりません。
- this.stencilStoreOp は指定されていなければなりません。
それ以外の場合：
- this.stencilLoadOp は指定されていてはなりません。
- this.stencilStoreOp は指定されていてはなりません。

17.1.1.3. ロード／ストア操作

enum GPULoadOp {
    "load",
    "clear",
};

"load"

このアタッチメントの既存の値をレンダーパスにロードします。

"clear"

このアタッチメントのクリア値をレンダーパスにロードします。

注: 一部のGPUハードウェア（主にモバイル）では、"clear" の方がはるかに高速です。これは、メインメモリからタイルローカルメモリへのデータロードを回避できるためです。他のGPUハードウェアでは大きな違いはありません。そのため、初期値が重要でない場合（例：レンダーターゲットをスカイボックスでクリアする場合）は "clear" を"load" よりも推奨します。

enum GPUStoreOp {
    "store",
    "discard",
};

"store"

レンダーパスの実行結果をこのアタッチメントに保存します。

"discard"

レンダーパスの実行結果をこのアタッチメントで破棄します。

注: 破棄されたアタッチメントはゼロクリアされたかのように扱われますが、実装はレンダーパス終了時に明示的なクリアを行う必要はありません。パス終了時に明示的なクリアを行わない実装は、アタッチメントの内容を読み込む（サンプリング、コピー、次のレンダーパスへ"load"でアタッチ、キャンバス表示や読み出し (get a copy of the image contents of a context) など）前に遅延クリアを行わなければなりません。

17.1.1.4. レンダーパスレイアウト

GPURenderPassLayout はGPURenderBundleのレンダーターゲットのレイアウトを宣言します。また、内部的には GPURenderPassEncoder のレイアウトや GPURenderPipeline のレイアウトにも使われます。この型は、レンダーパス・レンダーバンドル・レンダーパイプライン間の互換性判定に使われます。

dictionary GPURenderPassLayout
         : GPUObjectDescriptorBase {
    required sequence<GPUTextureFormat?> colorFormats;
    GPUTextureFormat depthStencilFormat;
    GPUSize32 sampleCount = 1;
};

colorFormats, 型 sequence<GPUTextureFormat?>: このパスまたはバンドルのカラ―アタッチメントのGPUTextureFormatのリスト。
depthStencilFormat, 型 GPUTextureFormat: このパスまたはバンドルのデプス／ステンシルアタッチメントのGPUTextureFormat。
sampleCount, 型 GPUSize32, デフォルトは1: このパスまたはバンドルのアタッチメントのピクセルごとのサンプル数。

2つのGPURenderPassLayout 値は等しいのは:

それぞれのdepthStencilFormat とsampleCount が等しいこと、かつ
それぞれのcolorFormats が末尾のnullを無視して等しいこと。

パスからレンダーターゲットレイアウトを導出

引数:

GPURenderPassDescriptor descriptor

戻り値: GPURenderPassLayout

デバイスタイムライン手順:

layout を新しい GPURenderPassLayout オブジェクトとします。
descriptor.colorAttachments の各 colorAttachment について：
1. もし colorAttachment が null でなければ：
  1. layout.sampleCount を colorAttachment.view.[[texture]].sampleCount に設定します。
  2. colorAttachment.view.[[descriptor]].format を layout.colorFormats に追加します。
  それ以外の場合：
  1. null を layout.colorFormats に追加します。
depthStencilAttachment を descriptor.depthStencilAttachment とします。
もし depthStencilAttachment が null でなければ：
1. view を depthStencilAttachment.view とします。
2. layout.sampleCount を view.[[texture]].sampleCount に設定します。
3. layout.depthStencilFormat を view.[[descriptor]].format に設定します。
layout を返します。

パイプラインからレンダーターゲットレイアウトを導出する

引数:

GPURenderPipelineDescriptor descriptor

戻り値: GPURenderPassLayout

デバイスタイムラインの手順:

layout を新しい GPURenderPassLayout オブジェクトとします。
layout.sampleCount を descriptor.multisample.count に設定します。
もし descriptor.depthStencil が指定されていれば:
1. layout.depthStencilFormat を descriptor.depthStencil.format に設定します。
もし descriptor.fragment が指定されていれば:
1. descriptor.fragment.targets の各 colorTarget について:
  1. colorTarget が null でなければ colorTarget.format を layout.colorFormats に追加し、null なら null を追加する。
layout を返します。

17.1.2. ファイナライズ

レンダーパスのコマンド記録が完了したら、end() を呼び出すことでレンダーパスエンコーダを終了できます。end() が呼び出された後は、このレンダーパスエンコーダは使用できません。

end()

レンダーパスコマンドシーケンスの記録を完了します。

呼び出し対象: GPURenderPassEncoder this。

戻り値: undefined

次の手順を this.[[device]] のDevice timelineで発行します。

Device timeline の手順:

parentEncoder を this.[[command_encoder]] とします。
以下の要件のいずれかを満たさない場合、バリデーションエラーを生成し終了します。
- this.[[state]] は "open" でなければなりません。
- parentEncoder.[[state]] は "locked" でなければなりません。
this.[[state]] を "ended" に設定します。
parentEncoder.[[state]] を "open" に設定します。
Extend で parentEncoder.[[used_bind_groups]] に this.[[used_bind_groups]] を追加します。
次のいずれかを満たさない場合、invalidateを parentEncoder に行い終了します。
- this は valid でなければなりません。
- this.[[usage scope]] は usage scope validation を満たさなければなりません。
- this.[[debug_group_stack]] は空でなければなりません。
- this.[[occlusion_query_active]] は false でなければなりません。
- this.[[drawCount]] は this.[[maxDrawCount]] 以下であること。
Extend で parentEncoder.[[commands]] に this.[[commands]] を追加します。
もし this.[[endTimestampWrite]] が null でない場合：
1. Extend で parentEncoder.[[commands]] に this.[[endTimestampWrite]] を追加します。
レンダーコマンドをエンキューするを this に対し行い、以降の手順を Queue timeline で renderState とともに実行します。

Queue timeline の手順:

renderState.[[colorAttachments]] 内の non-null な各 colorAttachment について：
1. colorView を colorAttachment.view とします。
2. もし colorView.[[descriptor]].dimension が：
  
  "3d"
  
  colorSubregion を colorAttachment.depthSlice of colorView とする。
  
  その他
  
  colorSubregion を colorView とする。
3. もし colorAttachment.resolveTarget が null でなければ：
  1. colorSubregion の各テクセルの複数サンプルを 1 サンプルにリゾルブし colorAttachment.resolveTargetにコピーします。
4. colorAttachment.storeOp が：
  
  "store"
  
  colorSubregion に関連付けられたフレームバッファメモリの内容を colorSubregion に保存します。
  
  "discard"
  
  colorSubregion の各テクセルをゼロにします。
depthStencilAttachment を renderState.[[depthStencilAttachment]] とする。
depthStencilAttachment が null でなければ：
1. depthStencilAttachment.depthStoreOp が：
  
  指定されていない場合
  
  Assert： depthStencilAttachment.depthReadOnly が true であり、depthStencilView の depth サブリソースを変更しません。
  
  "store"
  
  depth のサブリソースに関連付けられたフレームバッファメモリの内容を depthStencilView に保存します。
  
  "discard"
  
  depthStencilView の depth サブリソースの全テクセルをゼロに設定します。
2. depthStencilAttachment.stencilStoreOp が：
  
  指定されていない場合
  
  Assert： depthStencilAttachment.stencilReadOnly が true であり、depthStencilView の stencil サブリソースを変更しません。
  
  "store"
  
  stencil のサブリソースに関連付けられたフレームバッファメモリの内容を depthStencilView に保存します。
  
  "discard"
  
  depthStencilView の stencil サブリソースの全テクセルをゼロに設定します。
renderState を null に設定します。

注: 破棄されたアタッチメントはゼロクリアされたかのように動作しますが、実装はレンダーパス終了時にクリアを行う必要はありません。詳細は "discard" の注を参照してください。

注: Read-only depth-stencil アタッチメントは暗黙的に "store" 操作として扱われますが、内容がレンダーパス中に変更されないため実装はアタッチメントの更新を行う必要がありません。read-only アタッチメントに store op を指定してはいけないというバリデーションは GPURenderPassDepthStencilAttachment 有効使用条件内で検証されます。

17.2. `GPURenderCommandsMixin`

GPURenderCommandsMixin はGPURenderPassEncoder とGPURenderBundleEncoder に共通のレンダリングコマンドを定義します。

interface mixin GPURenderCommandsMixin {
    undefined setPipeline(GPURenderPipeline pipeline);

    undefined setIndexBuffer(GPUBuffer buffer, GPUIndexFormat indexFormat, optional GPUSize64 offset = 0, optional GPUSize64 size);
    undefined setVertexBuffer(GPUIndex32 slot, GPUBuffer? buffer, optional GPUSize64 offset = 0, optional GPUSize64 size);

    undefined draw(GPUSize32 vertexCount, optional GPUSize32 instanceCount = 1,
        optional GPUSize32 firstVertex = 0, optional GPUSize32 firstInstance = 0);
    undefined drawIndexed(GPUSize32 indexCount, optional GPUSize32 instanceCount = 1,
        optional GPUSize32 firstIndex = 0,
        optional GPUSignedOffset32 baseVertex = 0,
        optional GPUSize32 firstInstance = 0);

    undefined drawIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
    undefined drawIndexedIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
};

GPURenderCommandsMixin は、同じオブジェクト上に GPUObjectBase、 GPUCommandsMixin、 GPUBindingCommandsMixin のメンバーが存在することを前提としています。これらのミックスインも含むインターフェイスのみがGPURenderCommandsMixinをincludeできます。

GPURenderCommandsMixin には以下のデバイスタイムラインプロパティがあります:

[[layout]]、型は GPURenderPassLayout、読み取り専用: このレンダーパスのレイアウト。
[[depthReadOnly]]、型は boolean、読み取り専用: trueなら、デプス成分が変更されないことを示します。
[[stencilReadOnly]]、型は boolean、読み取り専用: trueなら、ステンシル成分が変更されないことを示します。
[[usage scope]]、型はusage scope、初期値は空: このレンダーパスまたはバンドルに対するusage scope。
[[pipeline]]、型は GPURenderPipeline、初期値はnull: 現在のGPURenderPipeline。
[[index_buffer]]、型は GPUBuffer、初期値はnull: インデックスデータの読み出しに使われる現在のバッファ。
[[index_format]]、型は GPUIndexFormat: [[index_buffer]] 内のインデックスデータのフォーマット。
[[index_buffer_offset]]、型は GPUSize64: 現在設定されている[[index_buffer]]のバイトオフセット。
[[index_buffer_size]]、型は GPUSize64: 現在設定されている[[index_buffer]]のサイズ（バイト単位）、初期値は0。
[[vertex_buffers]]、型は ordered map<slot, GPUBuffer>、初期値は空: 各スロット用に頂点データ読み出しのために使われる現在のGPUBuffer。
[[vertex_buffer_sizes]]、型は ordered map<slot, GPUSize64>、初期値は空: 各スロットで現在設定されているGPUBufferのサイズ（バイト単位）。
[[drawCount]]、型は GPUSize64: このエンコーダーに記録されたドローコマンドの数。

GPURenderCommandsMixin encoder に対してレンダーコマンドをエンキューする（GPU Command command と RenderState renderState を伴う）の device timeline 手順は次の通り：

Append で encoder.[[commands]] に command を追加する。
command を GPUCommandBuffer commandBuffer の一部として実行する際：
1. commandBuffer.[[renderState]] を renderState として command の手順を発行する。

17.2.1. 描画

setPipeline(pipeline)

現在使用する GPURenderPipeline を設定します。

呼び出し対象: GPURenderCommandsMixin this.

引数:

メソッド GPURenderCommandsMixin.setPipeline(pipeline) の引数。
パラメーター	型	Nullable	Optional	説明
`pipeline`	`GPURenderPipeline`	✘	✘	その後の描画コマンドで使用するレンダーパイプライン。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で発行します。対象は this の [[device]] です。

Device timeline の手順:

エンコーダー状態を検証します（対象は this）。false を返した場合は終了します。
pipelineTargetsLayout を derive render targets layout from pipeline(pipeline.[[descriptor]]) とします。
次のいずれかの条件が満たされない場合は、invalidate を this に対して行い、終了します。
- pipeline が valid to use with this であること。
- this.[[layout]] が equals pipelineTargetsLayout であること。
- もし pipeline.[[writesDepth]] が真なら、 this.[[depthReadOnly]] は false でなければなりません。
- もし pipeline.[[writesStencil]] が真なら、 this.[[stencilReadOnly]] は false でなければなりません。
this.[[pipeline]] を pipeline に設定します。

setIndexBuffer(buffer, indexFormat, offset, size)

現在のインデックスバッファを設定します。

呼び出し対象: GPURenderCommandsMixin this.

引数:

メソッド GPURenderCommandsMixin.setIndexBuffer(buffer, indexFormat, offset, size) の引数。
パラメーター	型	Nullable	Optional	説明
`buffer`	`GPUBuffer`	✘	✘	その後の描画コマンドで使用するインデックスデータを含むバッファ。
`indexFormat`	`GPUIndexFormat`	✘	✘	`buffer` に含まれるインデックスデータのフォーマット。
`offset`	`GPUSize64`	✘	✔	インデックスデータが始まる `buffer` 内のバイト単位のオフセット。既定値は `0` です。
`size`	`GPUSize64`	✘	✔	`buffer` 内のインデックスデータのバイト数。既定値はバッファのサイズからオフセットを引いた値です。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で発行します（対象は this.[[device]]）。

Device timeline の手順:

エンコーダー状態を検証します（対象は this）。false を返した場合は終了します。
size が与えられていない場合、size を max(0, buffer.size - offset) に設定します。
次のいずれかの条件が満たされない場合は、invalidate を this に対して行い、終了します。
- buffer が valid to use with this であること。
- buffer.usage に INDEX が含まれていること。
- offset が indexFormat のバイトサイズの倍数であること。
- offset + size ≤ buffer.size であること。
Add buffer を [[usage scope]] に使用法 input で追加します。
this.[[index_buffer]] を buffer に設定します。
this.[[index_format]] を indexFormat に設定します。
this.[[index_buffer_offset]] を offset に設定します。
this.[[index_buffer_size]] を size に設定します。

setVertexBuffer(slot, buffer, offset, size)

指定したスロットに対する現在の頂点バッファを設定します。

呼び出し対象: GPURenderCommandsMixin this.

引数:

メソッド GPURenderCommandsMixin.setVertexBuffer(slot, buffer, offset, size) の引数。
パラメーター	型	Nullable	Optional	説明
`slot`	`GPUIndex32`	✘	✘	頂点バッファを設定するスロット。
`buffer`	`GPUBuffer?`	✔	✘	その後の描画コマンドで使用する頂点データを含むバッファ。
`offset`	`GPUSize64`	✘	✔	`buffer` 内で頂点データが始まるバイト単位のオフセット。既定値は `0` です。
`size`	`GPUSize64`	✘	✔	`buffer` 内の頂点データのバイト数。既定値はバッファのサイズからオフセットを引いた値です。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で発行します（対象は this.[[device]]）。

Device timeline の手順:

エンコーダー状態を検証します（対象は this）。false を返した場合は終了します。
bufferSize を、buffer が null の場合は 0、そうでなければ buffer.size に設定します。
size が与えられていない場合、size を max(0, bufferSize - offset) に設定します。
次の要件のいずれかが満たされない場合は、invalidate を this に対して行い、終了します。
- slot は this.[[device]].[[limits]].maxVertexBuffers より小さい必要があります。
- offset は 4 の倍数である必要があります。
- offset + size が ≤ bufferSize である必要があります。
もし buffer が null の場合:
1. Remove this.[[vertex_buffers]][slot]。
2. Remove this.[[vertex_buffer_sizes]][slot]。
それ以外の場合:
1. 次の要件のいずれかが満たされない場合は、invalidate を this に対して行い、終了します。
  - buffer が valid to use with this であること。
  - buffer.usage に VERTEX が含まれていること。
2. Add buffer を [[usage scope]] に使用法 input で追加します。
3. this.[[vertex_buffers]][slot] を buffer に設定します。
4. this.[[vertex_buffer_sizes]][slot] を size に設定します。

draw(vertexCount, instanceCount, firstVertex, firstInstance)

プリミティブを描画します。詳細な仕様は § 23.2 Rendering を参照してください。

呼び出し対象: GPURenderCommandsMixin this.

引数:

メソッド GPURenderCommandsMixin.draw(vertexCount, instanceCount, firstVertex, firstInstance) の引数。
パラメーター	型	Nullable	Optional	説明
`vertexCount`	`GPUSize32`	✘	✘	描画する頂点の数。
`instanceCount`	`GPUSize32`	✘	✔	描画するインスタンスの数。
`firstVertex`	`GPUSize32`	✘	✔	頂点バッファ内の描画開始頂点へのオフセット（頂点単位）。
`firstInstance`	`GPUSize32`	✘	✔	描画を開始する最初のインスタンス。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で発行します（対象は this.[[device]]）。

Device timeline の手順:

エンコーダー状態を検証します（対象は this）。false を返した場合は終了します。
以下の手順群の要件がすべて満たされている必要があります。もし満たされない場合は、invalidate を this に対して行い、終了します。
1. この this で valid to draw である必要があります。
2. buffers を this.[[pipeline]].[[descriptor]].vertex.buffers とします。
3. 各 GPUIndex32 の slot について、0 から buffers.size（非包含）まで繰り返します：
  1. もし buffers[slot] が null なら、continue します。
  2. bufferSize を this.[[vertex_buffer_sizes]][slot] とします。
  3. stride を buffers[slot].arrayStride とします。
  4. attributes を buffers[slot].attributes とします。
  5. lastStride を、attributes の各 attribute に対して (attribute.offset + byteSize(attribute.format)) の最大値、または attributes が empty の場合は 0 とします。
  6. strideCount を buffers[slot].stepMode に基づいて計算します：
    
    "vertex"
    
    firstVertex + vertexCount
    
    "instance"
    
    firstInstance + instanceCount
  7. もし strideCount ≠ 0 なら：
    1. (strideCount − 1) × stride + lastStride が bufferSize 以下でなければなりません。
this.[[drawCount]] を 1 増やします。
bindingState を this の現在の状態のスナップショットとして取得します。
レンダーコマンドをキューに追加します。実行時に renderState と共に Queue timeline 上で後続の手順を発行します。

Queue timeline の手順:

instanceCount 個のインスタンスを、インスタンス firstInstance から開始して描画します。各プリミティブは vertexCount 頂点からなり、頂点は firstVertex から始まります。状態は bindingState と renderState を使用します。

drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance)

インデックス付きのプリミティブを描画します。詳細な仕様は § 23.2 Rendering を参照してください。

呼び出し対象: GPURenderCommandsMixin this.

引数:

メソッド GPURenderCommandsMixin.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance) の引数。
パラメーター	型	Nullable	Optional	説明
`indexCount`	`GPUSize32`	✘	✘	描画するインデックスの数。
`instanceCount`	`GPUSize32`	✘	✔	描画するインスタンスの数。
`firstIndex`	`GPUSize32`	✘	✔	インデックスバッファ内で描画を開始するオフセット（インデックス単位）。
`baseVertex`	`GPUSignedOffset32`	✘	✔	各インデックス値に加算され、頂点バッファのインデックスに使用される値。
`firstInstance`	`GPUSize32`	✘	✔	描画を開始する最初のインスタンス。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で発行します（対象は this.[[device]]）。

Device timeline の手順:

エンコーダー状態を検証します（対象は this）。false を返した場合は終了します。
次のいずれかの条件が満たされない場合は、invalidate を this に対して行い、終了します。
- この this で valid to draw indexed であること。
- firstIndex + indexCount ≤ this.[[index_buffer_size]] ÷ this.[[index_format]] のバイトサイズであること。
- buffers を this.[[pipeline]].[[descriptor]].vertex.buffers とします。
- 各 GPUIndex32 の slot について、0 から buffers.size（非包含）まで繰り返します：
  - もし buffers[slot] が null なら、continue します。
  - bufferSize を this.[[vertex_buffer_sizes]][slot] とします。
  - stride を buffers[slot].arrayStride とします。
  - lastStride を buffers[slot].attributes の各 attribute に対して attribute.offset + byteSize(attribute.format) の最大値として定義します。
  - strideCount を firstInstance + instanceCount とします。
  - もし buffers[slot].stepMode が "instance" であり、かつ strideCount ≠ 0 なら：
    - (strideCount − 1) × stride + lastStride ≤ bufferSize を保証します。
this.[[drawCount]] を 1 増やします。
bindingState を this の現在の状態のスナップショットとして取得します。
レンダーコマンドをキューに追加します。実行時に renderState と共に Queue timeline 上で後続の手順を発行します。

Queue timeline の手順:

instanceCount 個のインスタンスを、インスタンス firstInstance から開始して描画します。各プリミティブは indexCount 個のインデックスで構成され、インデックスは firstIndex から始まり、頂点は baseVertex に対応します。状態は bindingState と renderState を使用します。

注: WebGPU アプリケーションは、GPUVertexStepMode "vertex" を持つ任意のバインドされた頂点バッファの範囲外のインデックスを決して使用すべきではありません。 WebGPU 実装はこれを扱う方法が異なるため、さまざまな動作が許容されます。描画コール全体が破棄される場合もあれば、WGSL の invalid memory reference によりその属性へのアクセスが記述される場合もあります。

drawIndirect(indirectBuffer, indirectOffset)

GPUBuffer から読み取ったパラメーターを使用してプリミティブを描画します。詳細な仕様は § 23.2 Rendering を参照してください。

バッファにエンコードされる indirect draw parameters は、引数の順序と同じ順序で格納された、緊密に詰められた 32 ビット符号なし整数 4 個（計 16 バイト）でなければなりません。例えば：

let drawIndirectParameters = new Uint32Array(4);
drawIndirectParameters[0] = vertexCount;
drawIndirectParameters[1] = instanceCount;
drawIndirectParameters[2] = firstVertex;
drawIndirectParameters[3] = firstInstance;

firstInstance に対応する値は、"indirect-first-instance" feature が有効でない限り 0 でなければなりません。もしその feature が有効でなく、firstInstance が 0 でない場合、drawIndirect() の呼び出しは no-op として扱われます。

呼び出し対象: GPURenderCommandsMixin this.

引数:

メソッド GPURenderCommandsMixin.drawIndirect(indirectBuffer, indirectOffset) の引数。
パラメーター	型	Nullable	Optional	説明
`indirectBuffer`	`GPUBuffer`	✘	✘	indirect draw parameters を含むバッファ。
`indirectOffset`	`GPUSize64`	✘	✘	`indirectBuffer` 内で描画データが始まるバイト単位のオフセット。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で発行します（対象は this.[[device]]）。

Device timeline の手順:

エンコーダー状態を検証します（対象は this）。false を返した場合は終了します。
次のいずれかの条件が満たされない場合は、invalidate を this に対して行い、終了します。
- この this で valid to draw であること。
- indirectBuffer が valid to use with this であること。
- indirectBuffer.usage に INDIRECT が含まれていること。
- indirectOffset + sizeof(indirect draw parameters) ≤ indirectBuffer.size であること。
- indirectOffset が 4 の倍数であること。
Add indirectBuffer を [[usage scope]] に使用法 input で追加します。
this.[[drawCount]] を 1 増やします。
bindingState を this の現在の状態のスナップショットとして取得します。
レンダーコマンドをキューに追加します。実行時に renderState と共に Queue timeline 上で後続の手順を発行します。

Queue timeline の手順:

vertexCount を indirectBuffer から indirectOffset バイト位置で読み取った符号なし 32-bit 整数とします。
instanceCount を indirectBuffer から (indirectOffset + 4) バイト位置で読み取った符号なし 32-bit 整数とします。
firstVertex を indirectBuffer から (indirectOffset + 8) バイト位置で読み取った符号なし 32-bit 整数とします。
firstInstance を indirectBuffer から (indirectOffset + 12) バイト位置で読み取った符号なし 32-bit 整数とします。
instanceCount 個のインスタンスを、インスタンス firstInstance から開始して描画します。各プリミティブは vertexCount 頂点からなり、頂点は firstVertex から始まります。状態は bindingState と renderState を使用します。

drawIndexedIndirect(indirectBuffer, indirectOffset)

GPUBuffer から読み取ったパラメーターを使用してインデックス付きプリミティブを描画します。詳細な仕様は § 23.2 Rendering を参照してください。

バッファにエンコードされる indirect drawIndexed parameters は、引数の順序と同じ順序で格納された、緊密に詰められた 32 ビット値 5 個（計 20 バイト）でなければなりません。baseVertex に対応する値は符号付き 32 ビット整数で、他はすべて符号なし 32 ビット整数です。例えば：

let drawIndexedIndirectParameters = new Uint32Array(5);
let drawIndexedIndirectParametersSigned = new Int32Array(drawIndexedIndirectParameters.buffer);
drawIndexedIndirectParameters[0] = indexCount;
drawIndexedIndirectParameters[1] = instanceCount;
drawIndexedIndirectParameters[2] = firstIndex;
// baseVertex is a signed value.
drawIndexedIndirectParametersSigned[3] = baseVertex;
drawIndexedIndirectParameters[4] = firstInstance;

firstInstance に対応する値は、"indirect-first-instance" feature が有効でない限り 0 でなければなりません。もしその feature が有効でなく、firstInstance が 0 でない場合、drawIndexedIndirect() の呼び出しは no-op として扱われます。

呼び出し対象: GPURenderCommandsMixin this.

引数:

メソッド GPURenderCommandsMixin.drawIndexedIndirect(indirectBuffer, indirectOffset) の引数。
パラメーター	型	Nullable	Optional	説明
`indirectBuffer`	`GPUBuffer`	✘	✘	indirect drawIndexed parameters を含むバッファ。
`indirectOffset`	`GPUSize64`	✘	✘	`indirectBuffer` 内で描画データが始まるバイト単位のオフセット。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で発行します（対象は this.[[device]]）。

Device timeline の手順:

エンコーダー状態を検証します（対象は this）。false を返した場合は終了します。
次のいずれかの条件が満たされない場合は、invalidate を this に対して行い、終了します。
- この this で valid to draw indexed であること。
- indirectBuffer が valid to use with this であること。
- indirectBuffer.usage に INDIRECT が含まれていること。
- indirectOffset + sizeof(indirect drawIndexed parameters) ≤ indirectBuffer.size であること。
- indirectOffset が 4 の倍数であること。
Add indirectBuffer を [[usage scope]] に使用法 input で追加します。
this.[[drawCount]] を 1 増やします。
bindingState を this の現在の状態のスナップショットとして取得します。
レンダーコマンドをキューに追加します。実行時に renderState と共に Queue timeline 上で後続の手順を発行します。

Queue timeline の手順:

indexCount を indirectBuffer から indirectOffset バイト位置で読み取った符号なし 32-bit 整数とします。
instanceCount を indirectBuffer から (indirectOffset + 4) バイト位置で読み取った符号なし 32-bit 整数とします。
firstIndex を indirectBuffer から (indirectOffset + 8) バイト位置で読み取った符号なし 32-bit 整数とします。
baseVertex を indirectBuffer から (indirectOffset + 12) バイト位置で読み取った符号付き 32-bit 整数とします。
firstInstance を indirectBuffer から (indirectOffset + 16) バイト位置で読み取った符号なし 32-bit 整数とします。
instanceCount 個のインスタンスを、インスタンス firstInstance から開始して描画します。各プリミティブは indexCount 個のインデックスで構成され、インデックスは firstIndex から始まり、頂点は baseVertex に対応します。状態は bindingState と renderState を使用します。

To determine if it’s valid to draw with GPURenderCommandsMixin encoder, run the following device timeline steps:

次のいずれかの条件を満たさない場合は、false を返します：
- Validate encoder bind groups(encoder, encoder.[[pipeline]]) は true でなければなりません。
- pipelineDescriptor を encoder.[[pipeline]].[[descriptor]] とします。
- 各 GPUIndex32 slot について、0 から pipelineDescriptor.vertex.buffers.size まで次を確認します：
  - もし pipelineDescriptor.vertex.buffers[slot] が null でない場合、encoder.[[vertex_buffers]] は slot を含んでいる必要があります。
- maxBindGroupsPlusVertexBuffers を検証します：
  1. bindGroupSpaceUsed を ( encoder.[[bind_groups]] 内の最大キー ) + 1 とします。
  2. vertexBufferSpaceUsed を ( encoder.[[vertex_buffers]] 内の最大キー ) + 1 とします。
  3. bindGroupSpaceUsed + vertexBufferSpaceUsed は ≤ encoder.[[device]].[[limits]].maxBindGroupsPlusVertexBuffers でなければなりません。
それ以外の場合は、true を返します。

To determine if it’s valid to draw indexed with GPURenderCommandsMixin encoder, run the following device timeline steps:

次のいずれかの条件を満たさない場合は、false を返します：
- valid to draw が encoder で成立している必要があります。
- encoder.[[index_buffer]] は null であってはなりません。
- topology を encoder.[[pipeline]].[[descriptor]].primitive.topology とします。
- もし topology が "line-strip" または "triangle-strip" の場合：
  - encoder.[[index_format]] は encoder.[[pipeline]].[[descriptor]].primitive.stripIndexFormat と等しくなければなりません。
それ以外の場合は、true を返します。

17.2.2. ラスタライズ状態

GPURenderPassEncoder には、描画コマンドがこのエンコーダで使用されるアタッチメントにラスタライズされる方法に影響するいくつかのメソッドがあります。

setViewport(x, y, width, height, minDepth, maxDepth)

ラスタライズ段階で使用されるビューポートを設定し、正規化デバイス座標からビューポート座標へ線形に写像します。

呼び出し対象: GPURenderPassEncoder this.

引数:

メソッド GPURenderPassEncoder.setViewport(x, y, width, height, minDepth, maxDepth) の引数。
パラメーター	型	Nullable	Optional	説明
`x`	`float`	✘	✘	ビューポートの最小 X 値（ピクセル単位）。
`y`	`float`	✘	✘	ビューポートの最小 Y 値（ピクセル単位）。
`width`	`float`	✘	✘	ビューポートの幅（ピクセル単位）。
`height`	`float`	✘	✘	ビューポートの高さ（ピクセル単位）。
`minDepth`	`float`	✘	✘	ビューポートの最小深度値。
`maxDepth`	`float`	✘	✘	ビューポートの最大深度値。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で、this.[[device]] に対して発行します。

Device timeline の手順:

Validate the encoder state を this に対して実行します。false を返した場合は終了します。
maxViewportRange を this.limits.maxTextureDimension2D × 2 とします。
次のいずれかの条件が満たされない場合、invalidate を this に対して行い、終了します。
- x ≥ −maxViewportRange
- y ≥ −maxViewportRange
- 0 ≤ width ≤ this.limits.maxTextureDimension2D
- 0 ≤ height ≤ this.limits.maxTextureDimension2D
- x + width ≤ maxViewportRange − 1
- y + height ≤ maxViewportRange − 1
- 0.0 ≤ minDepth ≤ 1.0
- 0.0 ≤ maxDepth ≤ 1.0
- minDepth ≤ maxDepth
Enqueue a render command を this に対して行い、実行時に renderState とともに Queue timeline 上で後続の手順を発行するようにします。

Queue timeline の手順:

x, y, width, height を、整数丸めよりも粗くない一様な精度に丸めます。
renderState.[[viewport]] を範囲 x, y, width, height, minDepth, maxDepth に設定します。

setScissorRect(x, y, width, height)

ラスタライズ段階で使用されるシザーレクタングルを設定します。ビューポート座標に変換された後、シザーレクタングルの外側にある断片は破棄されます。

呼び出し対象: GPURenderPassEncoder this.

引数:

メソッド GPURenderPassEncoder.setScissorRect(x, y, width, height) の引数。
パラメーター	型	Nullable	Optional	説明
`x`	`GPUIntegerCoordinate`	✘	✘	シザーレクタングルの最小 X 値（ピクセル単位）。
`y`	`GPUIntegerCoordinate`	✘	✘	シザーレクタングルの最小 Y 値（ピクセル単位）。
`width`	`GPUIntegerCoordinate`	✘	✘	シザーレクタングルの幅（ピクセル単位）。
`height`	`GPUIntegerCoordinate`	✘	✘	シザーレクタングルの高さ（ピクセル単位）。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で、this.[[device]] に対して発行します。

Device timeline の手順:

Validate the encoder state を this に対して実行します。false を返した場合は終了します。
次のいずれかの条件が満たされない場合、invalidate を this に対して行い、終了します。
- x + width ≤ this.[[attachment_size]].width.
- y + height ≤ this.[[attachment_size]].height.
Enqueue a render command を this に対して行い、実行時に renderState とともに Queue timeline 上で後続の手順を発行するようにします。

Queue timeline の手順:

renderState.[[scissorRect]] を範囲 x, y, width, height に設定します。

setBlendConstant(color)

"constant" および "one-minus-constant" の GPUBlendFactor として使用される定数のブレンド色とアルファ値を設定します。

呼び出し対象: GPURenderPassEncoder this.

引数:

メソッド GPURenderPassEncoder.setBlendConstant(color) の引数。
パラメーター	型	Nullable	Optional	説明
`color`	`GPUColor`	✘	✘	ブレンドに使用する色。

戻り値: undefined

Content timeline の手順:

? validate GPUColor shape(color) を実行します。
後続の手順を Device timeline 上で、this.[[device]] に対して発行します。

Device timeline の手順:

Validate the encoder state を this に対して実行します。false を返した場合は終了します。
Enqueue a render command を this に対して行い、実行時に renderState とともに Queue timeline 上で後続の手順を発行するようにします。

Queue timeline の手順:

renderState.[[blendConstant]] を color に設定します。

setStencilReference(reference)

[[stencilReference]] を、"replace" のようなステンシルテストで使用される値に設定します（GPUStencilOperation）。

呼び出し対象: GPURenderPassEncoder this.

引数:

メソッド GPURenderPassEncoder.setStencilReference(reference) の引数。
パラメーター	型	Nullable	Optional	説明
`reference`	`GPUStencilValue`	✘	✘	新しいステンシル参照値。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で、this.[[device]] に対して発行します。

Device timeline の手順:

Validate the encoder state を this に対して実行します。false を返した場合は終了します。
Enqueue a render command を this に対して行い、実行時に renderState とともに Queue timeline 上で後続の手順を発行するようにします。

Queue timeline の手順:

renderState.[[stencilReference]] を reference に設定します。

17.2.3. クエリ

beginOcclusionQuery(queryIndex)

呼び出し対象: GPURenderPassEncoder this.

引数:

GPURenderPassEncoder.beginOcclusionQuery(queryIndex) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`queryIndex`	`GPUSize32`	✘	✘	クエリセット内でのクエリのインデックス。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で this.[[device]] に対して発行する。

Device timeline の手順:

エンコーダー状態を検証を this に対して実行する。false を返した場合は終了。
次のいずれかの条件を満たさない場合は invalidate を this に対して行い、終了する。
- this.[[occlusion_query_set]] が null でないこと。
- queryIndex が this.[[occlusion_query_set]].count より小さいこと。
- 同じ queryIndex のクエリがこのパス内で以前に書き込まれていないこと。
- this.[[occlusion_query_active]] が false であること。
this.[[occlusion_query_active]] を true に設定する。
レンダーコマンドをキューに追加し、実行時に renderState とともにQueue timeline 上で後続の手順を発行する。

Queue timeline の手順:

renderState.[[occlusionQueryIndex]] を queryIndex に設定する。

endOcclusionQuery()

呼び出し対象: GPURenderPassEncoder this.

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で this.[[device]] に対して発行する。

Device timeline の手順:

エンコーダー状態を検証を this に対して実行する。false を返した場合は終了。
次のいずれかの条件を満たさない場合は invalidate を this に対して行い、終了する。
- this.[[occlusion_query_active]] が true であること。
this.[[occlusion_query_active]] を false に設定する。
レンダーコマンドをキューに追加し、実行時に renderState とともにQueue timeline 上で後続の手順を発行する。

Queue timeline の手順:

passingFragments を、対応する beginOcclusionQuery() コマンドが実行されてから、いずれかのフラグメントサンプルがすべての per-fragment テストに合格した場合は非ゼロ、それ以外はゼロとする。

注: ドローコールが1つもなければ、passingFragments はゼロです。
passingFragments を this.[[occlusion_query_set]] の renderState.[[occlusionQueryIndex]] 番号に書き込む。

17.2.4. バンドル

executeBundles(bundles)

指定された GPURenderBundle に事前に記録されたコマンドを、このレンダーパスの一部として実行します。

GPURenderBundle を実行するとき、レンダーパスのパイプライン、バインドグループ、および頂点・インデックスバッファは継承されません。1つの GPURenderBundle の実行後、レンダーパスのパイプライン・バインドグループ・頂点/インデックスバッファの状態はクリア（初期値・空の値）されます。

注: 状態は「復元」されるのではなく「クリア」されます。これは、GPURenderBundle の実行数が 0 個であっても発生します。

呼び出し対象: GPURenderPassEncoder this.

引数:

メソッド GPURenderPassEncoder.executeBundles(bundles) の引数。
パラメーター	型	Nullable	Optional	説明
`bundles`	`sequence<GPURenderBundle>`	✘	✘	実行するレンダーバンドルのリスト。

戻り値: undefined

Content timeline の手順:

後続の手順を Device timeline 上で this.[[device]] に対して発行します。

Device timeline の手順:

エンコーダー状態を検証を this に対して実行。false を返した場合は終了。
次のいずれかの条件を満たさない場合、invalidate を this に対して行い終了します。
- bundles の各 bundle について：
  - bundle は valid to use with this でなければなりません。
  - this.[[layout]] は bundle.[[layout]] と等しい必要があります。
  - もし this.[[depthReadOnly]] が true の場合、bundle.[[depthReadOnly]] も true でなければなりません。
  - もし this.[[stencilReadOnly]] が true の場合、bundle.[[stencilReadOnly]] も true でなければなりません。
bundles の各 bundle について：
1. this.[[drawCount]] を bundle.[[drawCount]] 分増加させます。
2. Merge bundle.[[usage scope]] を this.[[usage scope]] にマージします。
3. Extend this.[[used_bind_groups]] に bundle.[[used_bind_groups]] を拡張します。
4. レンダーコマンドをキューに追加し、実行時に renderState とともに Queue timeline 上で次の手順を実行します:
  Queue timeline の手順:
  1. bundle.[[command_list]] の各コマンドを renderState とともに実行します。
    
    注: renderState はレンダーバンドルの実行によっては変更できません。バインディング状態はバンドルのエンコード時にキャプチャされているので、バンドル実行時には使用されません。
レンダーパスのバインディング状態をリセットします（this）。

レンダーパスのバインディング状態をリセットするには、GPURenderPassEncoder encoder に対して下記の device timeline 手順を実行します：

クリア encoder.[[bind_groups]].
encoder.[[pipeline]] を null に設定します。
encoder.[[index_buffer]] を null に設定します。
クリア encoder.[[vertex_buffers]].

18. バンドル

バンドルは部分的かつ制限されたパスで、一度エンコードすると通常のコマンドバッファのように使用後に失効することなく、今後のパスエンコーダの一部として複数回実行できます。これにより、繰り返し変更なく発行されるコマンドのエンコードおよびサブミッションのオーバーヘッドを減らすことができます。

18.1. `GPURenderBundle`

[Exposed=(Window, Worker), SecureContext]
interface GPURenderBundle {
};
GPURenderBundle includes GPUObjectBase;

[[command_list]], of type list<GPU command>: この GPURenderBundle を実行するときに GPURenderPassEncoder に送信されるリスト（GPU コマンド）です。
[[used_bind_groups]], of type set<GPUBindGroup>, readonly: このレンダーバンドルで使用されたすべての GPUBindGroup のセット。
[[usage scope]], of type usage scope, initially empty: このレンダーバンドルの使用範囲（usage scope）であり、後で executeBundles() 内で GPURenderPassEncoder の [[usage scope]] にマージされるために保存されています。
[[layout]], of type GPURenderPassLayout: このレンダーバンドルのレイアウト。
[[depthReadOnly]], of type boolean: true の場合、このレンダーバンドルの実行によって深度成分が変更されないことを示します。
[[stencilReadOnly]], of type boolean: true の場合、このレンダーバンドルの実行によってステンシル成分が変更されないことを示します。
[[drawCount]], of type GPUSize64: この GPURenderBundle に含まれているドローコマンドの数です。

18.1.1. レンダーバンドルの作成

dictionary GPURenderBundleDescriptor
         : GPUObjectDescriptorBase {
};

[Exposed=(Window, Worker), SecureContext]
interface GPURenderBundleEncoder {
    GPURenderBundle finish(optional GPURenderBundleDescriptor descriptor = {});
};
GPURenderBundleEncoder includes GPUObjectBase;
GPURenderBundleEncoder includes GPUCommandsMixin;
GPURenderBundleEncoder includes GPUDebugCommandsMixin;
GPURenderBundleEncoder includes GPUBindingCommandsMixin;
GPURenderBundleEncoder includes GPURenderCommandsMixin;

createRenderBundleEncoder(descriptor)

GPURenderBundleEncoder を作成します。

呼び出し対象: GPUDevice this.

引数:

GPUDevice.createRenderBundleEncoder(descriptor) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`descriptor`	`GPURenderBundleEncoderDescriptor`	✘	✘	作成する `GPURenderBundleEncoder` の説明。

戻り値: GPURenderBundleEncoder

Content timeline の手順:

? 各非null要素に対してテクスチャフォーマットに必要な機能の検証を descriptor.colorFormats に対し、this.[[device]] で実施する。
もし descriptor.depthStencilFormat が指定されている場合：
1. ? テクスチャフォーマットの必要な機能を検証を descriptor.depthStencilFormat に対して、this.[[device]] で実行する。
e を ! create a new WebGPU object(this, GPURenderBundleEncoder, descriptor) とします。
下記 Device timeline の 初期化手順 を this で実行します。
e を返します。

Device timeline 初期化手順：

以下の条件が満たされない場合、バリデーションエラーを生成し、invalidate を e に対して実行し、終了する。
- this は lost であってはならない。
- descriptor.colorFormats.size は this.[[limits]].maxColorAttachments 以下でなければならない。
- 各非 null の colorFormat について descriptor.colorFormats の要素：
  - colorFormat は color renderable format でなければならない。
- Calculating color attachment bytes per sample(descriptor.colorFormats) が this.[[limits]].maxColorAttachmentBytesPerSample 以下でなければならない。
- もし descriptor.depthStencilFormat が指定されている場合：
  - descriptor.depthStencilFormat は depth-or-stencil format でなければならない。
- 以下のいずれかのアタッチメントが少なくとも1つ存在しなければならない：
  - descriptor.colorFormats に null でない値が存在する、または
  - descriptor.depthStencilFormat が指定されている。
e.[[layout]] に descriptor に含まれる GPURenderPassLayout インターフェースのコピーを設定します。
e.[[depthReadOnly]] に descriptor.depthReadOnly を設定します。
e.[[stencilReadOnly]] に descriptor.stencilReadOnly を設定します。
e.[[state]] に "open" を設定します。
e.[[drawCount]] に 0 を設定します。

18.1.2. エンコーディング

dictionary GPURenderBundleEncoderDescriptor
         : GPURenderPassLayout {
    boolean depthReadOnly = false;
    boolean stencilReadOnly = false;
};

depthReadOnly, 型: boolean、デフォルト値は false

true の場合、このレンダーバンドルは、実行されるレンダーパスの GPURenderPassDepthStencilAttachment の depth 成分を変更しないことを示します。

read-only depth-stencil を参照してください。

stencilReadOnly, 型: boolean、デフォルト値は false

true の場合、このレンダーバンドルは、実行されるレンダーパスの GPURenderPassDepthStencilAttachment の stencil 成分を変更しないことを示します。

read-only depth-stencil を参照してください。

18.1.3. ファイナライズ

finish(descriptor)

レンダーバンドルコマンド列の記録を完了します。

呼び出し対象: GPURenderBundleEncoder this.

引数:

GPURenderBundleEncoder.finish(descriptor) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`descriptor`	`GPURenderBundleDescriptor`	✘	✔

戻り値: GPURenderBundle

Content timeline の手順:

renderBundle を新しい GPURenderBundle とします。
this.[[device]] の Device timeline 上で finish steps を発行します。
renderBundle を返します。

Device timeline finish steps:

下記すべての要件を満たす場合は validationSucceeded を true、満たさない場合は false とします。
- this は valid でなければなりません。
- this.[[usage scope]] は usage scope validation を満たしていなければなりません。
- this.[[state]] は "open" でなければなりません。
- this.[[debug_group_stack]] は空でなければなりません。
this.[[state]] を "ended" に設定します。
validationSucceeded が false の場合：
1. バリデーションエラーを発生させます。
2. 無効化されたinvalidated GPURenderBundle を返します。
renderBundle.[[command_list]] を this.[[commands]] に設定します。
renderBundle.[[used_bind_groups]] を this.[[used_bind_groups]] に設定します。
renderBundle.[[usage scope]] を this.[[usage scope]] に設定します。
renderBundle.[[drawCount]] を this.[[drawCount]] に設定します。

19. キュー

19.1. `GPUQueueDescriptor`

GPUQueueDescriptor はキューリクエストを記述します。

dictionary GPUQueueDescriptor
         : GPUObjectDescriptorBase {
};

19.2. `GPUQueue`

[Exposed=(Window, Worker), SecureContext]
interface GPUQueue {
    undefined submit(sequence<GPUCommandBuffer> commandBuffers);

    Promise<undefined> onSubmittedWorkDone();

    undefined writeBuffer(
        GPUBuffer buffer,
        GPUSize64 bufferOffset,
        AllowSharedBufferSource data,
        optional GPUSize64 dataOffset = 0,
        optional GPUSize64 size);

    undefined writeTexture(
        GPUTexelCopyTextureInfo destination,
        AllowSharedBufferSource data,
        GPUTexelCopyBufferLayout dataLayout,
        GPUExtent3D size);

    undefined copyExternalImageToTexture(
        GPUCopyExternalImageSourceInfo source,
        GPUCopyExternalImageDestInfo destination,
        GPUExtent3D copySize);
};
GPUQueue includes GPUObjectBase;

GPUQueue には以下のメソッドがあります：

writeBuffer(buffer, bufferOffset, data, dataOffset, size)

指定したデータを GPUBuffer に書き込む操作を発行します。

呼び出し対象: GPUQueue this.

引数:

GPUQueue.writeBuffer(buffer, bufferOffset, data, dataOffset, size) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`buffer`	`GPUBuffer`	✘	✘	書き込み先のバッファ。
`bufferOffset`	`GPUSize64`	✘	✘	`buffer` の書き込み開始位置（バイト単位のオフセット）。
`data`	`AllowSharedBufferSource`	✘	✘	`buffer` に書き込むデータ。
`dataOffset`	`GPUSize64`	✘	✔	`data` の書き込み開始位置。`data` が `TypedArray` の場合は要素単位、それ以外はバイト単位。
`size`	`GPUSize64`	✘	✔	`data` から `buffer` に書き込む内容のサイズ。`data` が `TypedArray` の場合は要素単位、それ以外はバイト単位。

返り値: undefined

コンテンツタイムラインのステップ:

data が ArrayBuffer または DataView の場合、要素型は "byte"。それ以外の場合、data は TypedArray であり、要素型は TypedArray の型とする。
dataSize を data の要素数とする。
size が指定されていない場合、 contentsSize を dataSize − dataOffset とする。指定されている場合は contentsSize を size とする。
次の条件のいずれかを満たさない場合、 OperationError を投げて return。
- contentsSize ≥ 0。
- dataOffset + contentsSize ≤ dataSize。
- contentsSize（バイト換算）は4バイトの倍数であること。
dataContents を buffer source のコピーとして data から取得する。
contents を dataContents の dataOffset から contentsSize 要素分とする。
後続のステップを this のデバイスタイムラインで実行する。

デバイスタイムラインのステップ:

次の条件のいずれかを満たさない場合、バリデーションエラー生成して return。
- buffer は this と一緒に使用可能である。
- buffer.[[internal state]] は "available" である。
- buffer.usage に COPY_DST が含まれていること。
- bufferOffset（バイト換算）は4バイトの倍数。
- bufferOffset + contentsSize（バイト換算）は buffer.size バイト以下。
後続のステップを this のキュータイムラインで実行する。

キュータイムラインのステップ:

contents を buffer の bufferOffset から書き込む。

writeTexture(destination, data, dataLayout, size)

提供されたデータを GPUTexture に書き込む操作を発行します。

呼び出し対象: GPUQueue this.

引数:

GPUQueue.writeTexture(destination, data, dataLayout, size) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`destination`	`GPUTexelCopyTextureInfo`	✘	✘	書き込み先となるテクスチャサブリソースおよび原点。
`data`	`AllowSharedBufferSource`	✘	✘	`destination` に書き込むデータ。
`dataLayout`	`GPUTexelCopyBufferLayout`	✘	✘	`data` 内のコンテンツのレイアウト。
`size`	`GPUExtent3D`	✘	✘	`data` から `destination` へ書き込むコンテンツの範囲。

戻り値: undefined

Content timeline の手順:

? validate GPUOrigin3D shape(destination.origin) を実行します。
? validate GPUExtent3D shape(size) を実行します。
dataBytes を buffer source に保持されているバイト列のコピーとして取得します。

注: これは data の全てをデバイスタイムラインにコピーするものとして記述されていますが、実際には data は必要以上に大きい場合があります。実装では必要なバイトだけをコピーして最適化すべきです。
この後の手順を Device timeline 上で this に対して発行します。

Device timeline の手順:

aligned を false とします。
dataLength を dataBytes の長さとします。
次のいずれかの条件が満たされない場合はバリデーションエラーを生成し、終了します。
- destination.texture.[[destroyed]] は false でなければなりません。
- validating texture buffer copy(destination, dataLayout, dataLength, size, COPY_DST, aligned) が true を返さなければなりません。
注: GPUCommandEncoder.copyBufferToTexture() とは異なり、 dataLayout.bytesPerRow や dataLayout.offset にアラインメント要件はありません。
この後の手順を Queue timeline 上で this に対して発行します。

Queue timeline の手順:

blockWidth を destination.texture のテクセルブロック幅とします。
blockHeight を destination.texture のテクセルブロック高さとします。
dstOrigin を destination.origin とします。
dstBlockOriginX を (dstOrigin.x ÷ blockWidth) とします。
dstBlockOriginY を (dstOrigin.y ÷ blockHeight) とします。
blockColumns を (copySize.width ÷ blockWidth) とします。
blockRows を (copySize.height ÷ blockHeight) とします。
アサート：dstBlockOriginX、dstBlockOriginY、blockColumns、blockRows が整数であること。
[0, copySize.depthOrArrayLayers − 1] の範囲の各 z について:
1. dstSubregion を texture copy sub-region (z + dstOrigin.z) of destination とする。
2. [0, blockRows − 1] の範囲の各 y について:
  1. [0, blockColumns − 1] の範囲の各 x について:
    1. blockOffset を texel block byte offset (dataLayout, (x, y, z), destination.texture) とする。
    2. dstSubregion の (dstBlockOriginX + x, dstBlockOriginY + y) のテクセルブロックを、dataBytes の blockOffset 位置で記述される等価テクセル表現に設定します。

copyExternalImageToTexture(source, destination, copySize)

プラットフォーム画像／キャンバスの内容を宛先テクスチャにコピーします。

この操作は GPUCopyExternalImageDestInfo のパラメータに従って色空間エンコードを行います。

-srgb テクスチャへのコピーは、対応する非 -srgb フォーマットへのコピーとは、同じテクスチャバイトになり、デコード値は異なります。コピー操作後、宛先テクスチャのサンプリング結果は、フォーマットが -srgb かどうかで異なります（他が同じ場合）。

注:

"webgl"/"webgl2" コンテキストキャンバスからコピーする場合、 WebGL 描画バッファはフレーム提示サイクルの一部タイミング（画像が表示のため合成器に移動された後）に存在しないことがあります。これを避けるには、以下のいずれかを行います：

WebGLレンダリング操作と同じタスク内で copyExternalImageToTexture() を発行し、コピーがWebGLキャンバス提示前に行われるようにする。
それができない場合は、preserveDrawingBuffer オプションを WebGLContextAttributes で true に設定することで、提示後も描画バッファにフレーム内容のコピーが残ります。ただし、この追加コピーにはパフォーマンスコストが発生する可能性があります。

呼び出し対象: GPUQueue this.

引数:

GPUQueue.copyExternalImageToTexture(source, destination, copySize) メソッドの引数。
パラメータ	型	Nullable	Optional	説明
`source`	`GPUCopyExternalImageSourceInfo`	✘	✘	コピー元画像および `destination` への原点情報。
`destination`	`GPUCopyExternalImageDestInfo`	✘	✘	書き込み先のテクスチャサブリソース、原点、エンコードメタデータ。
`copySize`	`GPUExtent3D`	✘	✘	`source` から `destination` に書き込む内容の範囲。

返り値: undefined

コンテンツタイムラインのステップ:

? GPUOrigin2D の形状を検証(source.origin).
? GPUOrigin3D の形状を検証(destination.origin).
? GPUExtent3D の形状を検証(copySize)。
sourceImage を source.source
sourceImage がオリジン・クリーンでない場合、SecurityError を throw して return。
次のいずれかの要件を満たさない場合、OperationError を throw して return。
- source.origin.x + copySize.width は sourceImage の幅以下でなければならない。
- source.origin.y + copySize.height は sourceImage の高さ以下でなければならない。
- copySize.depthOrArrayLayers は 1 以下である必要がある。
usability を ? 画像引数の usability をチェック(source)とする。
後続のステップを this のデバイスタイムラインで実行する。

Device timeline の手順:

texture を destination.texture とする。
次のいずれかの要件を満たさない場合は、バリデーションエラーを生成し、終了する。
- usability は good でなければならない。
- texture.[[destroyed]] は false でなければならない。
- texture は valid to use with this でなければならない。
- validating GPUTexelCopyTextureInfo(destination, copySize) は true を返さなければならない。
- texture.usage には RENDER_ATTACHMENT および COPY_DST の両方が含まれていなければならない。
- texture.dimension は "2d" でなければならない。
- texture.sampleCount は 1 でなければならない。
- texture.format は plain color format であり、 RENDER_ATTACHMENT をサポートし、 unorm/unorm-srgb または float/ufloat フォーマットでなければならない（snorm・uint・sint ではない）。
もし copySize.depthOrArrayLayers が 0 より大きければ、この後の手順を Queue timeline 上で this に対して発行する。

Queue timeline の手順:

アサート： destination.texture の texel block width が 1、 texel block height が 1、そして copySize.depthOrArrayLayers が 1 であること。
srcOrigin を source.origin とする。
dstOrigin を destination.origin とする。
dstSubregion を texture copy sub-region (dstOrigin.z) of destination とする。
[0, copySize.height − 1] の各 y について:
1. srcY を次のように決定する。 source.flipY が false の場合は y、そうでなければ (copySize.height − 1 − y)。
2. [0, copySize.width − 1] の各 x について:
  1. srcColor を source.source の (srcOrigin.x + x, srcOrigin.y + srcY) のカラーマネージドカラー値とする。
  2. dstColor を、 destination.colorSpace や destination.premultipliedAlpha に必要なカラ―エンコーディングを srcColor に適用した時の RGBA 数値とする。
  3. もし texture.format が -srgb フォーマットの場合：
    1. dstColor に sRGB 非線形→線形変換を適用した結果を設定する。
    注: この変換は、次のステップで -srgb フォーマットに書き込む際に行われる sRGB 線形→非線形変換を相殺するためのもので、 sRGB 相当の入力画像の精度を損なわず、元画像の「線形」色値がテクスチャから読み取れるようにするためのものです（これが -srgb フォーマットを使う一般的な目的）。
  4. dstSubregion の (dstOrigin.x + x, dstOrigin.y + y) のテクセルブロックを dstColor の等価テクセル表現に設定する。

submit(commandBuffers)

このキュー上でGPUによるコマンドバッファの実行をスケジュールします。

提出されたコマンドバッファは再利用できません。

呼び出し対象: GPUQueue this.

引数:

GPUQueue.submit(commandBuffers) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`commandBuffers`	`sequence<GPUCommandBuffer>`	✘	✘

戻り値: undefined

Content timeline の手順:

この後の手順を Device timeline 上で this に対して発行する：

Device timeline の手順:

以下の要件が満たされていない場合、バリデーションエラーを生成し、 invalidate を commandBuffers の各 GPUCommandBuffer に対して行い終了する。
- commandBuffers 内の全ての GPUCommandBuffer は一意でなければならない。
- commandBuffers の各 commandBuffer について:
  - commandBuffer は valid to use with this でなければならない。
  - commandBuffer.[[used_bind_groups]] の各 bindGroup について:
    - GPUBindingResource 型の各リソースについて、その型が：
      
      GPUBuffer b
      
      b.[[internal state]] は "available" でなければならない。
      
      GPUTexture t
      
      t.[[destroyed]] は false でなければならない。
      
      GPUExternalTexture et
      
      et.[[expired]] は false でなければならない。
      
      GPUQuerySet qs
      
      qs.[[destroyed]] は false でなければならない。
  注: オクルージョンクエリについては、occlusionQuerySet は beginRenderPass() で利用されるだけでなく、 beginOcclusionQuery() も利用されなければ「使用」したことにはなりません。
commandBuffers の各 commandBuffer について:
1. Invalidate commandBuffer。
この後の手順を Queue timeline 上で this に対して発行する：

Queue timeline の手順:

commandBuffers の各 commandBuffer について:
1. commandBuffer.[[command_list]] 内の各コマンドを実行する。

onSubmittedWorkDone()

このキューが現時点までに提出されたすべての処理を終了したときに resolve される Promise を返します。

この Promise の resolve は、当該呼び出し以前に mapAsync() を呼び出し、その後このキューでのみ利用された GPUBuffer の mapAsync の完了も意味します。

呼び出し対象: GPUQueue this.

戻り値: Promise<undefined>

contentTimeline を現在のコンテントタイムラインとする。
promise を新しい promise とする。
synchronization steps をデバイスタイムライン上の this に対して発行する。
promise を返す。

デバイスタイムライン synchronization steps:

現在キューに登録されている全ての操作が完了した時に event が発生するものとする。
タイムラインイベントをリッスン event を this.[[device]] 上で行い、その後の手順は contentTimeline 上でハンドルされる。

コンテントタイムライン手順：

promise を resolve する。

20. クエリ

20.1. `GPUQuerySet`

[Exposed=(Window, Worker), SecureContext]
interface GPUQuerySet {
    undefined destroy();

    readonly attribute GPUQueryType type;
    readonly attribute GPUSize32Out count;
};
GPUQuerySet includes GPUObjectBase;

GPUQuerySet には以下の不変プロパティがあります：

type, 型 GPUQueryType, readonly: この GPUQuerySet が管理するクエリの種類。
count, 型 GPUSize32Out, readonly: この GPUQuerySet が管理するクエリ数。

GPUQuerySet には以下のデバイスタイムラインプロパティがあります：

[[destroyed]], 型 boolean, 初期値 false: クエリセットが破棄されると、いかなる操作にも使用できなくなり、基礎となるメモリが解放される可能性があります。

20.1.1. クエリセットの作成

GPUQuerySetDescriptor は GPUQuerySet の作成時に使用するオプションを指定します。

dictionary GPUQuerySetDescriptor
         : GPUObjectDescriptorBase {
    required GPUQueryType type;
    required GPUSize32 count;
};

type, 型 GPUQueryType: GPUQuerySet が管理するクエリの型です。
count, 型 GPUSize32: GPUQuerySet が管理するクエリの数です。

createQuerySet(descriptor)

GPUQuerySet を生成します。

呼び出し対象: GPUDevice this.

引数:

GPUDevice.createQuerySet(descriptor) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`descriptor`	`GPUQuerySetDescriptor`	✘	✘	作成する `GPUQuerySet` の説明。

戻り値: GPUQuerySet

Content timeline 手順：

もし descriptor.type が "timestamp" であり、かつ "timestamp-query" がこのデバイスで有効　でなければ：
1. TypeError をスローします。
q を ! create a new WebGPU object(this, GPUQuerySet, descriptor) とします。
q.type に descriptor.type を設定します。
q.count に descriptor.count を設定します。
Device timeline 上で initialization steps を発行します。
q を返します。

Device timeline initialization steps:

次のいずれかの要件が満たされない場合、バリデーションエラーを生成し、 invalidate を q に対して行い、終了します。
- this は lost であってはなりません。
- descriptor.count は 4096 以下でなければなりません。
q 用のデバイスアロケーションを作成し、クエリセット内の各エントリはゼロで初期化します。

もしアロケーションが副作用無しに失敗した場合は out-of-memory エラーを生成し、invalidate を q に対して行い、終了します。

32個のオクルージョンクエリ結果を保持する GPUQuerySet の作成例。

const querySet = gpuDevice.createQuerySet({
    type: 'occlusion',
    count: 32
});

20.1.2. クエリセットの破棄

アプリケーションが GPUQuerySet を不要と判断した場合、destroy() を呼び出すことでガベージコレクション前にアクセスを失うことができます。

GPUQuerySet には以下のメソッドがあります：

destroy()

GPUQuerySet を破棄します。

呼び出し対象: GPUQuerySet this.

戻り値: undefined

コンテントタイムライン手順:

この後の手順を device timeline で発行する。

Device timeline 手順:

this.[[destroyed]] を true に設定します。

20.2. クエリタイプ

enum GPUQueryType {
    "occlusion",
    "timestamp",
};

20.3. オクルージョンクエリ

オクルージョンクエリはレンダーパスでのみ利用でき、シザー、サンプルマスク、アルファ・トゥ・カバレージ、ステンシル、深度テストなどを含む一連の描画コマンドに対して、すべてのフラグメントテストを通過したフラグメントサンプル数を問い合わせます。クエリの結果が非ゼロの場合、少なくともひとつのサンプルがテストを通過しレンダーパイプラインの出力マージ段階に到達したことを示し、0の場合はサンプルがテストを通過しなかったことを示します。

レンダーパスを開始する際、GPURenderPassDescriptor.occlusionQuerySet を設定することで、パス内でオクルージョンクエリが使用可能となります。オクルージョンクエリは beginOcclusionQuery() と endOcclusionQuery() をペアで呼び出すことで開始・終了され、ネストはできません。クエリ結果は GPUBuffer に 64ビット符号なし整数として GPUCommandEncoder.resolveQuerySet() で解決されます。

20.4. タイムスタンプクエリ

タイムスタンプクエリは、以下の方法で GPUQuerySet にタイムスタンプを書き込むことができます：

GPUComputePassDescriptor.timestampWrites
GPURenderPassDescriptor.timestampWrites

そしてタイムスタンプ値（ナノ秒単位で 64ビット符号なし整数）を GPUBuffer に GPUCommandEncoder.resolveQuerySet() で解決します。

タイムスタンプ値は実装依存です。アプリケーションは任意のタイムスタンプ結果を扱えるようにし、予期しないタイムスタンプによってアプリケーションが異常終了しないように実装すべきです。

注：物理デバイスがタイムスタンプカウンタを時折リセットすることがあり、その結果、タイムスタンプ間の差分が負になるなど予期しない値が生じる場合があります。これらのケースは稀であり、そのようなデータポイントは安全に破棄できます。

タイムスタンプクエリは高分解能タイマー（§ 2.1.7.2 デバイス/キュータイムラインのタイミング参照）を利用して実装されます。セキュリティ・プライバシーの懸念を軽減するため、その精度は低減されなければなりません:

キュータイムラインのステップを実行して、現在のキュータイムスタンプを取得します：

fineTimestamp を現在のキュータイムラインの現在のタイムスタンプ値（ナノ秒単位、実装依存の過去のある時点基準）とする。
fineTimestamp に coarsen time を呼び出し、crossOriginIsolatedCapability は false に設定して結果を返す。

注：クロスオリジン分離はデバイスタイムラインやキュータイムラインには決して適用されません。そのため、crossOriginIsolatedCapability が true になることはありません。

timestampWrites の検証(device, timestampWrites)

引数:

GPUDevice device
(GPUComputePassTimestampWrites または GPURenderPassTimestampWrites) timestampWrites

デバイスタイムラインのステップ:

以下の要件が満たされていれば true を返し、そうでなければ false を返す：
- "timestamp-query" が device で有効化されていること。
- timestampWrites.querySet は device で valid to use with であること。
- timestampWrites.querySet.type が "timestamp" であること。
- timestampWrites の書き込みインデックスメンバー（beginningOfPassWriteIndex、endOfPassWriteIndex）について：
  - 少なくとも一つは指定されていること。
  - 指定されているものについて：
    - そのいずれも値が重複してはならない。
    - それぞれ timestampWrites.querySet.count より小さいこと。

21. キャンバス描画

21.1. `HTMLCanvasElement.getContext()`

GPUCanvasContext オブジェクトは getContext() メソッドを HTMLCanvasElement インスタンスに対して呼び出し、文字列リテラル 'webgpu' を contextType 引数として渡すことで作成されます。

オフスクリーンの HTMLCanvasElement から GPUCanvasContext を取得する例：

const canvas = document.createElement('canvas');
const context = canvas.getContext('webgpu');

WebGLや2Dコンテキストの作成とは異なり、 HTMLCanvasElement.getContext() や OffscreenCanvas.getContext() の第二引数（コンテキスト作成属性辞書 options）は無視されます。代わりに GPUCanvasContext.configure() を使い、キャンバスの構成を置き換えずに変更できます。

HTMLCanvasElement または OffscreenCanvas canvas で 'webgpu' コンテキストを作成するには、以下のコンテンツタイムラインのステップを実行します：

context を新しい GPUCanvasContext とする。
context.canvas に canvas を設定する。
context の描画バッファを置き換える。
context を返す。

注: WebGPUキャンバスコンテキスト取得時に無視される options 引数が与えられた場合、実装は開発者向け警告を表示すべきです。

21.2. GPUCanvasContext

[Exposed=(Window, Worker), SecureContext]
interface GPUCanvasContext {
    readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas;

    undefined configure(GPUCanvasConfiguration configuration);
    undefined unconfigure();

    GPUCanvasConfiguration? getConfiguration();
    GPUTexture getCurrentTexture();
};

GPUCanvasContext には以下のコンテンツタイムラインプロパティがあります：

canvas, 型: (HTMLCanvasElement or OffscreenCanvas), 読み取り専用

このコンテキストが作成されたキャンバス。

[[configuration]], 型 GPUCanvasConfiguration?, 初期値 null

このコンテキストが現在設定されているオプション。

設定されていないか、unconfigured された場合は null。

[[textureDescriptor]], 型 GPUTextureDescriptor?, 初期値 null

現在設定されているテクスチャディスクリプタ（[[configuration]] とキャンバスから派生）。

設定されていないか、unconfigured された場合は null。

[[drawingBuffer]]、画像。初期値はキャンバスと同じサイズの透過黒画像

ドローイングバッファはキャンバスの作業用イメージデータです。これは [[currentTexture]] （getCurrentTexture() で返される）を介して書き込み可能として公開されます。

ドローイングバッファは画像内容のコピー取得の際（キャンバスが表示または読み取られるとき）に使われます。たとえ [[configuration]].alphaMode が "opaque" であっても、透過になる場合があります。 alphaMode は "画像内容のコピー取得" アルゴリズムの結果のみに影響します。

ドローイングバッファは [[currentTexture]] より寿命が長く、キャンバスが表示された後でも以前の内容を保持します。 Replace the drawing buffer の際のみ完全にクリアされます。

ドローイングバッファが読み取られる場合は、直前にサブミットされた全ての作業（例：queue submission）の書き込みが [[currentTexture]] を通して完了していることを実装で保障しなければなりません。

[[currentTexture]], 型 GPUTexture?, 初期値 null

現在フレーム描画用の GPUTexture です。基となる [[drawingBuffer]] への書き込みビューとして公開されます。 getCurrentTexture() により null なら初期化され、常にこのスロットを返します。

可視キャンバスの定常状態では、currentTexture でドローイングバッファへの変更は WebGPUキャンバスの描画更新で提示されます。それ以前またはその時に、このテクスチャも破棄され、[[currentTexture]] は null となります。これにより、次に getCurrentTexture() すれば新たに作られます。

Destroying してもドローイングバッファ内容には影響なく、書き込みアクセスのみ即時終了します。同じフレーム内で getCurrentTexture() を呼ぶと同じ破棄済みテクスチャを返し続けます。

Expire the current texture は currentTexture を null にします。これは configure() や、キャンバスのリサイズ、提示、transferToImageBitmap() などで呼ばれます。

[[lastPresentedImage]], 型 (readonly image)?, 初期値 null

このキャンバスで最後に "WebGPU キャンバスの描画更新" で提示された画像です。デバイスが失われたり破棄された場合、この画像はキャンバスを白紙化しないためのフォールバック用に、 "画像内容のコピー取得" で用いられることがあります。

注: このプロパティはフォールバックを実装する場合のみ必要で、実装は任意です。

GPUCanvasContext には以下のメソッドがあります：

configure(configuration)

このキャンバスのコンテキストを設定します。この際 Replace the drawing buffer でドローイングバッファは透過黒で初期化されます。

getConfiguration() の feature detection 例も参照してください。

呼び出し対象: GPUCanvasContext this.

引数:

GPUCanvasContext.configure(configuration) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`configuration`	`GPUCanvasConfiguration`	✘	✘	コンテキストの望ましい設定内容。

戻り値: undefined

device を configuration.device とする。
? テクスチャフォーマット必要機能の検証を configuration.format と device.[[device]] で行う。
? テクスチャフォーマット必要機能の検証を configuration.viewFormats の各要素と device.[[device]] で行う。
もしサポートされているコンテキストフォーマットが含まない configuration.format なら、 TypeError をスローする。
descriptor をキャンバスと設定のための GPUTextureDescriptor(this.canvas, configuration) とする。
this.[[configuration]] を configuration に設定する。

注: これは実装定義の GPUCanvasConfiguration で定義されたメンバのみを公開する。これらのメンバの仕様については機能検出の注記を参照のこと。
this.[[textureDescriptor]] を descriptor に設定する。
描画バッファの置き換えをthisに対して行う。
後続の手順を device のデバイスタイムラインで実施する。

Device timeline の手順：

次の要件が満たされない場合バリデーションエラー生成し終了する。
- validating GPUTextureDescriptor(device, descriptor) はtrueを返さなければならない。
注: この早期バリデーションは次の configure() 呼び出しまで有効ですが、 size の検証はキャンバスリサイズ時にのみ変化します。

unconfigure()

コンテキスト設定を解除し、設定中に生成されたテクスチャを破棄します。

呼び出し対象: GPUCanvasContext this.

戻り値: undefined

this.[[configuration]] に null をセット。
this.[[textureDescriptor]] に null をセット。
Replace the drawing buffer を this に対して行う。

getConfiguration()

現在のコンテキスト設定を返します。未設定の場合は null です。

注: このメソッドは主に GPUCanvasConfiguration のメンバーやサブメンバーの feature detection 用です。対応メンバーの場合は、もともと与えられた値を返します。

呼び出し対象: GPUCanvasContext this.

戻り値: GPUCanvasConfiguration または null

configuration を this.[[configuration]] のコピーとする。
configuration を返す。

getCurrentTexture()

次の合成描画で GPUTexture を取得します。これは GPUCanvasContext によりドキュメントへコンポジットされます。

注:

アプリケーションは getCurrentTexture() を同じタスク内でレンダリングとあわせて呼び出すべきです。そうしないとレンダリングが終わる前にテクスチャがこの手順で破棄される場合があります。

失効タスク（expiry task、下記定義）は実装任意です。仮に実装されても、タスクソースの優先順位までは定義されておらず、次のタスクで早々に来る場合もあれば全タスクソースが空になるまで遅延する場合もありえます（automatic expiry task source を参照）。可視キャンバスの描画提示（WebGPUキャンバスの描画更新）および "Expire the current texture" を呼ぶ他の経路では必ず失効します。

呼び出し対象: GPUCanvasContext this.

戻り値: GPUTexture

もし this.[[configuration]] が null なら、 InvalidStateError を throw し、return。
アサート this.[[textureDescriptor]] が null でないこと。
device を this.[[configuration]].device とする。
もし this.[[currentTexture]] が null なら：
1. Replace the drawing buffer を this に対して行う。
2. this.[[currentTexture]] を device.createTexture() に this.[[textureDescriptor]] を渡して呼び出した結果とし（ただし underlying storage は this.[[drawingBuffer]] を指す）、
  
  注: テクスチャの作成に失敗した（例：バリデーションエラーや out-of-memory）場合はエラー生成し、invalidated な GPUTexture を返します。ここでのバリデーションの多くは configure() のものと被りますが必ず二重チェックしてください。
オプションで 自動失効タスクをキュー追加。device device と以下の手順を使用：
1. Expire the current texture を this に対して行う。
  
  注: これは WebGPUキャンバスの描画更新ですでに起きていれば何も起きません。
this.[[currentTexture]] を返す。

注: "Expire the current texture" が走るまで、destroyやバリデーション失敗、アロケーション失敗があっても全て getCurrentTexture() は同じ GPUTexture を返します。

コンテキストの画像内容のコピーを取得するためには：

引数:

context: GPUCanvasContext

返り値: 画像内容

コンテンツタイムラインのステップ:

snapshot を context.canvas と同じサイズの透明な黒画像にする。
configuration を context.[[configuration]] とする。
configuration が null の場合:
1. snapshot を返す。
注: null は、contextが未設定または unconfigured の場合に configuration となる。これは、canvasにcontextがない場合の挙動と同じである。
提出されたすべての作業項目（例: queue submission）が画像（context.[[currentTexture]] を通じて）への書き込みを完了していることを保証する。
configuration.device が有効である場合:
1. snapshot を context.[[drawingBuffer]] のコピーにする。
それ以外の場合、context.[[lastPresentedImage]] が null でなければ:
1. 任意で snapshot を context.[[lastPresentedImage]] のコピーにする。
  
  注: これは任意である。[[lastPresentedImage]] は、デバイスロスの原因によっては存在しない場合がある。実装はその画像にアクセス可能であっても、スキップしてもよい。
alphaMode を configuration.alphaMode とする。
alphaMode が "opaque" の場合:
1. snapshot のアルファチャンネルを 1.0 でクリアする。
  
  注: [[currentTexture]] が破棄されている場合（例えば "Expire the current texture" の時）、アルファチャンネルは観測できなくなり、実装はインプレースでクリアしてもよい。
2. snapshot に不透明のタグを付ける。
それ以外の場合:
1. snapshot に alphaMode のタグを付ける。
snapshot に colorSpace および toneMapping を configuration の値でタグ付けする。
snapshot を返す。

描画バッファを置き換えるには、GPUCanvasContext contextに対して次のコンテンツタイムラインのステップを実行する：

現在のテクスチャの期限切れ処理を context に対して実行する。
configuration を context.[[configuration]] とする。
context.[[drawingBuffer]] に context.canvas と同じサイズの透過黒画像を設定する。
- configuration が null の場合、drawing buffer は色空間 "srgb" とタグ付けされる。この場合、drawing buffer は設定されるまで空白のまま。
- そうでなければ、drawing buffer は指定の configuration.format を持ち、指定の configuration.colorSpace と configuration.toneMapping でタグ付けされる。
注: configuration.alphaMode は "コンテキストの画像内容のコピーを取得する" までは無視される。

注:
新しく置き換えられた drawing buffer 画像は透過黒でクリアされたかのように振る舞うが、"discard"後のように、必要になった時のみ lazy にクリアしてもよい。

注: drawing buffer が既にクリア済みで正しい設定であれば、これは多くの場合何も起こらない（no-op）。

現在のテクスチャの期限切れ処理は、GPUCanvasContext context に対して以下のコンテンツタイムラインのステップを実行する：

context.[[currentTexture]] が null でない場合：
1. context.[[currentTexture]].destroy() を呼び出す（context.[[drawingBuffer]] は破棄しない）ことで画像への書き込みアクセスを終了する。
2. context.[[currentTexture]] を null に設定する。

21.3. HTML仕様フック

以下のアルゴリズムはHTML仕様のアルゴリズムへ「フック」し、指定されたタイミングで実行されなければなりません。

HTMLCanvasElement または OffscreenCanvas 上で GPUCanvasContext context の "bitmap" が読み取られる場合、以下のコンテンツタイムラインステップを実行する：

context の画像内容のコピーを返す。

注:

この処理は様々な場面で発生します：

HTMLCanvasElement の描画が更新されるとき。
- キャンバスが placeholder canvas element（OffscreenCanvas）の場合も含む。
transferToImageBitmap() が bitmap から ImageBitmap を生成する場合。（transferToImageBitmap from WebGPU も参照）
WebGPUキャンバス内容が他のWeb API（ drawImage()、 texImage2D()、texSubImage2D()、 toDataURL()、 toBlob() など）で読み取られる場合。

alphaMode が "opaque" の場合、アルファチャンネルをクリアする必要があります。実装がアルファチャンネルを無視して画像を読み取る／表示できる場合、このステップを省略しても構いません。

アプリケーションがキャンバスを相互運用のみに使い、表示を目的としない場合は、必要がなければ "opaque" を避けて下さい。

WebGPUキャンバスの描画の更新（HTMLCanvasElement または OffscreenCanvas placeholder canvas elementを持つもの）で、キャンバスの画像内容取得の前に、イベントループ処理モデルの以下のサブステップで発生します：

「そのDocumentの描画またはUIの更新」
「その専用ワーカーの描画の更新」

注: ServiceWorker や SharedWorker には「描画の更新」ステップはありません。これらはユーザー可視のキャンバスを描画できないためです。 requestAnimationFrame() は ServiceWorkerGlobalScope や SharedWorkerGlobalScope にはありません。また OffscreenCanvasは transferControlToOffscreen() で生成されたものはこれらのワーカーに送信できません。

以下のコンテンツタイムラインステップを実行する：

現在のテクスチャの期限切れ処理を context に対して実行する。

注: これは getCurrentTexture() でキューされたタスクで既に実行されていれば、効果はありません。
context.[[lastPresentedImage]] に context.[[drawingBuffer]] を設定する。

注: これはコピーではなく参照です。current texture の期限切れ後は drawing buffer の内容は in-place で変化しません。

注: new OffscreenCanvas() で生成された単体の OffscreenCanvas にはこの処理は発生しません。

WebGPUからのtransferToImageBitmap:

transferToImageBitmap() が GPUCanvasContext context を持つキャンバスで呼ばれ、キャンバスのbitmapから ImageBitmap が作成された後に、以下のコンテンツタイムラインステップを実行する：

描画バッファを置き換えるを context に対して実行する。

注: これにより transferToImageBitmap() は画像内容を ImageBitmap へ「移動」する（必要に応じてアルファクリアも）、コピーは行われません。

キャンバスサイズの更新アルゴリズム。

21.4. GPUCanvasConfiguration

サポートされるコンテキストフォーマットは、集合である GPUTextureFormat の次の値です： «"bgra8unorm"、 "rgba8unorm"、 "rgba16float"»。これらのフォーマットは、 GPUCanvasConfiguration.format として指定された場合、指定された GPUCanvasConfiguration.device に関わらず、サポートされなければなりません。

注：キャンバスの構成では、srgb フォーマット（例："bgra8unorm-srgb"）は使用できません。代わりに非srgb相当（"bgra8unorm"）を使い、 srgbフォーマットをviewFormatsで指定し、 createView() によりsrgbフォーマットのビューを作成してください。

enum GPUCanvasAlphaMode {
    "opaque",
    "premultiplied",
};

enum GPUCanvasToneMappingMode {
    "standard",
    "extended",
};

dictionary GPUCanvasToneMapping {
  GPUCanvasToneMappingMode mode = "standard";
};

dictionary GPUCanvasConfiguration {
    required GPUDevice device;
    required GPUTextureFormat format;
    GPUTextureUsageFlags usage = 0x10;  // GPUTextureUsage.RENDER_ATTACHMENT
    sequence<GPUTextureFormat> viewFormats = [];
    PredefinedColorSpace colorSpace = "srgb";
    GPUCanvasToneMapping toneMapping = {};
    GPUCanvasAlphaMode alphaMode = "opaque";
};

GPUCanvasConfiguration には以下のメンバーがあります：

device, 型: GPUDevice: GPUDevice は、getCurrentTexture() により返されるテクスチャが互換性を持つデバイスです。
format, 型: GPUTextureFormat: getCurrentTexture() により返されるテクスチャのフォーマット。 Supported context formats のいずれかでなければなりません。
usage, 型: GPUTextureUsageFlags、デフォルトは 0x10: getCurrentTexture() により返されるテクスチャのusage。 RENDER_ATTACHMENT がデフォルトですが、usage を明示的に設定した場合は自動付与されません。RENDER_ATTACHMENT をレンダーパスのカラ―ターゲットとして使いたい場合は必ず usage に含めてください。
viewFormats, 型: sequence<GPUTextureFormat>、デフォルトは []: getCurrentTexture() から生成されるビューが利用可能なフォーマットのリストです。
colorSpace, 型: PredefinedColorSpace、デフォルトは "srgb": getCurrentTexture() に書き込まれる値をどの色空間で表示するかを指定します。
toneMapping, 型: GPUCanvasToneMapping、デフォルトは {}: getCurrentTexture() のコンテンツをどのように表示するかを決定するトーンマッピングです。

注:
これは必須機能ですが、user agent が未実装の場合はデフォルト GPUCanvasToneMapping のみサポートとなるかもしれません。その場合、このメンバーは GPUCanvasConfiguration の実装から 除外すべき で、feature detection （getConfiguration()）で判別可能にすべきです。
特にHDR機能がある実装（dynamic-range が high を返す場合）では重要です。

このメンバーが存在し high な dynamic range を expose する場合、canvas はHDRとして描画されるべきであり、HDRディスプレイのSDR範囲にクランプすべきではありません。
alphaMode, 型: GPUCanvasAlphaMode、デフォルトは "opaque": getCurrentTexture() から読み込んだり、表示したり、画像ソースとして使ったときにアルファ値がどのように影響するかを指定します。

特定の GPUCanvasContext と GPUDevice を使って、このコンテキストに推奨フォーマットで設定する例：

const canvas = document.createElement('canvas');
const context = canvas.getContext('webgpu');

context.configure({
    device: gpuDevice,
    format: navigator.gpu.getPreferredCanvasFormat(),
});

キャンバスと設定のためのGPUTextureDescriptor( (HTMLCanvasElement または OffscreenCanvas) canvas, GPUCanvasConfiguration configuration) は、次のメンバーを持つ GPUTextureDescriptor です:

size: [canvas.width, canvas.height, 1]
format: configuration.format
usage: configuration.usage
viewFormats: configuration.viewFormats

その他のプロパティはデフォルト値となります。

canvas.width は HTMLCanvasElement.width または OffscreenCanvas.width を指します。 canvas.height は HTMLCanvasElement.height または OffscreenCanvas.height を指します。

21.4.1. キャンバスの色空間

表示時、キャンバス内の色値は画面の色空間へ変換されます。

toneMapping は、画面の色空間における [0, 1] 範囲外の値の扱いを決定します。

21.4.2. キャンバスコンテキストのサイズ指定

全てのキャンバス設定は configure() で指定されますが、解像度（サイズ）はキャンバスの width と height で指定されます。

注: WebGLや2dキャンバスと同様に、WebGPUキャンバスのサイズ変更は描画バッファの内容を失います。 WebGPUでは、これは描画バッファを置き換えることで行われます。

HTMLCanvasElement または OffscreenCanvas canvas が GPUCanvasContext context を持ち、その width または height 属性が設定されたとき、キャンバスサイズの更新を以下のコンテンツタイムラインの手順で行います：

描画バッファを置き換えるを context に対して実行する。
configuration を context.[[configuration]] とする。
configuration が null でない場合：
1. context.[[textureDescriptor]] にキャンバスと設定用のGPUTextureDescriptor(canvas, configuration) を設定する。

注: この処理により、GPUTextureDescriptor がデバイスの maxTextureDimension2D を超える場合があります。その場合、 getCurrentTexture() 内でバリデーションが失敗します。

注: このアルゴリズムは、値が変化しなくても canvas の width または height 属性が設定されるたびに実行されます。

21.5. `GPUCanvasToneMappingMode`

このenumは、色値が画面にどのように表示されるかを指定します。

"standard"

画面の標準ダイナミックレンジ内の色値は変更されず、それ以外の色値は画面の標準ダイナミックレンジに射影されます。

注: この射影は、画面の色空間で色値を [0, 1] 範囲にクランプすることでよく実現されます。

例えば、値 (1.035, -0.175, -0.140) が 'srgb' キャンバスに書き込まれた場合：

これがsRGB画面に表示される場合、まずsRGBへ変換（キャンバスもsRGBなので変換なし）、次にディスプレイ空間へ射影されます。成分ごとにクランプすると、sRGB値 (1.0, 0.0, 0.0) となります。

Display P3画面の場合、Display P3色空間に (0.948, 0.106, 0.01) へ変換され、クランプは不要です。

"extended"

画面の拡張ダイナミックレンジ内の色値は変更されず、それ以外の色値は画面の拡張ダイナミックレンジに射影されます。

注: この射影は、画面の色空間で色値を画面が表示可能な値の範囲にクランプすることでよく実現されます（1より大きい値も含む場合があります）。

例えば、値 (2.5, -0.15, -0.15) が 'srgb' キャンバスに書き込まれた場合：

sRGB画面で [0, 4] 範囲を表示できる場合、まずsRGBへ変換（キャンバスもsRGBなので変換なし）、次にディスプレイ空間へ射影されます。成分ごとにクランプすると、sRGB値 (2.5, 0.0, 0.0) となります。

Display P3画面で [0, 2] 範囲を表示できる場合、Display P3色空間に (2.3, 0.545, 0.386) へ変換され、ディスプレイ空間へ射影されます。成分ごとにクランプすると、Display P3値 (2.0, 0.545, 0.386) となります。

21.6. `GPUCanvasAlphaMode`

このenumは、キャンバス内容を読み出す際・画面表示や画像ソースとして利用（drawImage, toDataURLなど）する際の解釈方法を選択します。

以下では、src はキャンバステクスチャ内の値、dst はキャンバスが合成される画像（例：HTMLページ描画や2Dキャンバス）です。

"opaque"

RGBを不透明として読み出し、アルファ値を無視します。内容がすでに不透明でない場合は、"コンテキストの画像内容のコピーを取得する"でアルファチャンネルが 1.0 にクリアされます。

"premultiplied"

RGBAをプリマルチプライドとして読み出します：色値は自身のアルファ値で乗算されています。 100%赤・50%アルファなら [0.5, 0, 0, 0.5] となります。

キャンバステクスチャがガマット外のプリマルチプライドRGBA値を含む場合、読み出し時の挙動は次の通りです：

画像ソースとして利用

値は保持され、色空間変換に記載の通り扱われます。

画面表示

合成結果は未定義です。

注: 色空間変換で合成前にガマット内値になる場合でも、合成の中間フォーマットが規定されていないため未定義となります。

22. エラーとデバッグ

WebGPUの通常動作中、エラーは dispatch error を通じて発生します。

デバイスが失われた後は、可能な限りエラーは表示されなくなります。この時点以降、実装はバリデーションやエラー追跡を行う必要はありません：

デバイス上のオブジェクトの有効性は観測できなくなります。
popErrorScope() および uncapturederror はエラーの報告を停止します。（デバイス損失自体によるエラーは生成されません。代わりに、GPUDevice.lost の promise が解決され、デバイスが失われたことを示します。）
content timeline にメッセージを返す全ての操作は、通常の手順を省略します。ほとんどの操作は成功したように見えますが、mapAsync() だけは例外で、デバイス損失後は正しいマッピングデータを提供できないためエラーが発生します。

他の種類の操作（メッセージを返さないもの）が実行されるかどうかは観測できません。

22.1. 重大なエラー

enum GPUDeviceLostReason {
    "unknown",
    "destroyed",
};

[Exposed=(Window, Worker), SecureContext]
interface GPUDeviceLostInfo {
    readonly attribute GPUDeviceLostReason reason;
    readonly attribute DOMString message;
};

partial interface GPUDevice {
    readonly attribute Promise<GPUDeviceLostInfo> lost;
};

GPUDevice には、次の属性が追加されています：

lost, 型は Promise<GPUDeviceLostInfo>, readonly

デバイス作成時に生成される promise を保持するスロット裏付け属性です。デバイスの存続期間中は pending 状態となり、デバイスが失われた時に解決されます。

初期化時、新しい promise に設定されます。

22.2. `GPUError`

[Exposed=(Window, Worker), SecureContext]
interface GPUError {
    readonly attribute DOMString message;
};

GPUError は、 popErrorScope() や uncapturederror イベントから発生する全てのエラーの基底インターフェースです。

エラーは、それぞれのアルゴリズムで明示的に条件とサブタイプを指定している操作に対してのみ生成されなければなりません。

失われたデバイスからはエラーは生成されません。 § 22 エラーとデバッグを参照してください。

注: GPUError は、今後の現行標準のバージョンで新しいサブタイプが追加される可能性があります。アプリケーションはこの可能性を考慮し、可能な場合はエラーの message のみを使用し、必要に応じて instanceof で特定してください。エラーをシリアライズする必要がある場合（例：JSONやデバッグレポートなど）は、error.constructor.name を使用してください。

GPUError には、以下の不変プロパティがあります：

message, 型は DOMString、readonly

発生したエラーの情報を提供する、人間が読めるローカライズ可能なテキストメッセージです。

注: このメッセージは、通常アプリケーション開発者がアプリケーションをデバッグし、デバッグレポート用の情報を取得するために意図されています。エンドユーザーに表示するものではありません。

注: ユーザーエージェントは、"out-of-memory" などの空きメモリ量やその他メモリ枯渇時の条件など、機械処理可能な詳細情報をこのメッセージに含めるべきではありません。

注: message は、言語と方向情報のベストプラクティスに従うべきです。これは、将来的に文字列の言語・方向メタデータの報告に関する標準が登場した場合、それを活用することを含みます。

編集上の注記: この文書執筆時点では、レガシーAPIとの互換性・一貫性を保つ言語／方向推奨事項はありませんが、今後標準化され次第正式に採用してください。

[Exposed=(Window, Worker), SecureContext]
interface GPUValidationError
        : GPUError {
    constructor(DOMString message);
};

GPUValidationError は GPUError のサブタイプであり、操作がすべてのバリデーション要件を満たさなかったことを示します。バリデーションエラーは常にアプリケーションエラーに該当し、同じ [[features]] と [[limits]] を使用した場合、全てのデバイスで同じように失敗することが期待されます。

バリデーションエラーを生成するために GPUDevice device で以下の手順を実行します：

Device timeline の手順：

error を、新たな GPUValidationError （適切なエラーメッセージ付き）として生成する。
Dispatch error により error を device に通知する。

[Exposed=(Window, Worker), SecureContext]
interface GPUOutOfMemoryError
        : GPUError {
    constructor(DOMString message);
};

GPUOutOfMemoryError は GPUError のサブタイプであり、操作の実行に必要なメモリが不足していたことを示します。要求メモリサイズを減らす（例：より小さいテクスチャサイズを使う）か、他のリソースで使用中のメモリを先に解放すれば、再試行時に成功する場合があります。

メモリ不足エラーを生成するために GPUDevice device で以下の手順を実行します：

Device timeline の手順：

error を、新たな GPUOutOfMemoryError （適切なエラーメッセージ付き）として生成する。
Dispatch error により error を device に通知する。

[Exposed=(Window, Worker), SecureContext]
interface GPUInternalError
        : GPUError {
    constructor(DOMString message);
};

GPUInternalError は GPUError のサブタイプであり、すべてのバリデーション要件を満たしているにもかかわらず、システムや実装固有の理由で操作が失敗したことを示します。例えば、その操作が supported limits では容易に表現できない実装の制限を超えている場合などです。この操作は他のデバイスや環境では成功する場合もあります。

内部エラーを生成するために GPUDevice device で以下の手順を実行します：

Device timeline の手順：

error を、新たな GPUInternalError （適切なエラーメッセージ付き）として生成する。
Dispatch error により error を device に通知する。

22.3. エラースコープ

GPUエラースコープは、 GPUError が GPUエラースコープが現在のときに生成されたものを捕捉します。エラースコープは、WebGPU呼び出しのセット内で発生したエラーを分離するために用いられ、主にデバッグや操作の耐障害性向上のために使われます。

GPUエラースコープは、以下のデバイスタイムラインプロパティを持ちます：

[[errors]], 型は list<GPUError>, 初期値 []: GPUエラースコープが現在のときに観測された GPUError を保持します。
[[filter]], 型は GPUErrorFilter: この GPUエラースコープが観測する GPUError の種類を決定します。

enum GPUErrorFilter {
    "validation",
    "out-of-memory",
    "internal",
};

partial interface GPUDevice {
    undefined pushErrorScope(GPUErrorFilter filter);
    Promise<GPUError?> popErrorScope();
};

GPUErrorFilter は pushErrorScope() 呼び出し時に捕捉するべきエラーの種類を定義します：

"validation": このエラースコープは GPUValidationError を捕捉します。
"out-of-memory": このエラースコープは GPUOutOfMemoryError を捕捉します。
"internal": このエラースコープは GPUInternalError を捕捉します。

GPUDevice には、次のデバイスタイムライン属性があります：

[[errorScopeStack]]、型 stack<GPU error scope>: スタックで、 GPU エラースコープを GPUDevice に push したものです。

current error scope を GPUError error と GPUDevice device について判定するには、次を device timeline で実行します：

Device timeline 手順：

もし error が次のいずれかのインスタンスであれば：

GPUValidationError

type を "validation" とする。

GPUOutOfMemoryError

type を "out-of-memory" とする。

GPUInternalError

type を "internal" とする。
scope を device.[[errorScopeStack]] の最後のアイテムとする。
scope が undefined でない間：
1. もし scope.[[filter]] が type なら scope を返す。
2. scope を device.[[errorScopeStack]] の直前のアイテムにする。
undefined を返す。

dispatch an error で GPUError error を GPUDevice device に通知するには、次の device timeline 手順を実行する：

Device timeline 手順：

注: lost なデバイスからはエラーは発生しません。このアルゴリズムが device が lost になっている間に呼ばれても、アプリケーションからは観測できません。 § 22 エラーとデバッグ参照。

scope を current error scope（error と device 用）とする。
もし scope が undefined でなければ：
1. Append で error を scope.[[errors]] に追加する。
2. return。
それ以外は、次の手順を content timeline で実行：

Content timeline 手順：

ユーザーエージェントが選択する場合は、次の手順で GPUDevice 用globalタスクを device にキュー：
1. GPUUncapturedErrorEvent を "uncapturederror" イベント名で device 上に発火し、error を error に設定する。

注: このイベント後は、 user agent は 開発者にエラー内容を通知するべき です（例えばブラウザ開発者ツールのコンソールに警告表示）。ただしイベントの defaultPrevented が true なら警告は表示しないでください。すなわち preventDefault() の呼び出しは警告を抑制します。

注: ユーザーエージェントは、GPUUncapturedErrorEvent を GPUDevice ごとに発生させる数を制限する場合もあります。これは過度なエラーハンドリングやログ出力でパフォーマンスが下がるのを避けるためです。

pushErrorScope(filter)

新しい GPU エラースコープを [[errorScopeStack]] に push します（this用）。

呼び出し対象: GPUDevice this.

引数:

GPUDevice.pushErrorScope(filter) メソッドの引数。
パラメーター	型	Nullable	Optional	説明
`filter`	`GPUErrorFilter`	✘	✘	このエラースコープが観測するエラーの種類

戻り値: undefined

この後の手順を Device timeline 上で this に発行。

Device timeline 手順：

scope を新しい GPU エラースコープにする。
scope.[[filter]] を filter に設定する。
Push で scope を this.[[errorScopeStack]] へ push する。

popErrorScope()

GPU エラースコープを [[errorScopeStack]] から pop し、そのエラースコープで観測された何らかの GPUError または観測されなければ null を resolve するPromiseを返します。

Promise解決順序の保証はありません。

呼び出し対象: GPUDevice this.

戻り値: Promise<GPUError?>