From e72376534f393e52b06371c0729eabadf4e5ff89 Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Wed, 21 Jan 2026 20:52:46 +0100 Subject: [PATCH] Add GPUComputePassEncoder --- baselines/dom.generated.d.ts | 61 +++++++++++++++++++ baselines/serviceworker.generated.d.ts | 61 +++++++++++++++++++ baselines/sharedworker.generated.d.ts | 61 +++++++++++++++++++ baselines/ts5.5/dom.generated.d.ts | 56 +++++++++++++++++ baselines/ts5.5/dom.iterable.generated.d.ts | 5 ++ baselines/ts5.5/serviceworker.generated.d.ts | 56 +++++++++++++++++ .../serviceworker.iterable.generated.d.ts | 5 ++ baselines/ts5.5/sharedworker.generated.d.ts | 56 +++++++++++++++++ .../sharedworker.iterable.generated.d.ts | 5 ++ baselines/ts5.5/webworker.generated.d.ts | 56 +++++++++++++++++ .../ts5.5/webworker.iterable.generated.d.ts | 5 ++ baselines/ts5.6/dom.generated.d.ts | 56 +++++++++++++++++ baselines/ts5.6/dom.iterable.generated.d.ts | 5 ++ baselines/ts5.6/serviceworker.generated.d.ts | 56 +++++++++++++++++ .../serviceworker.iterable.generated.d.ts | 5 ++ baselines/ts5.6/sharedworker.generated.d.ts | 56 +++++++++++++++++ .../sharedworker.iterable.generated.d.ts | 5 ++ baselines/ts5.6/webworker.generated.d.ts | 56 +++++++++++++++++ .../ts5.6/webworker.iterable.generated.d.ts | 5 ++ baselines/ts5.9/dom.generated.d.ts | 56 +++++++++++++++++ baselines/ts5.9/dom.iterable.generated.d.ts | 5 ++ baselines/ts5.9/serviceworker.generated.d.ts | 56 +++++++++++++++++ .../serviceworker.iterable.generated.d.ts | 5 ++ baselines/ts5.9/sharedworker.generated.d.ts | 56 +++++++++++++++++ .../sharedworker.iterable.generated.d.ts | 5 ++ baselines/ts5.9/webworker.generated.d.ts | 56 +++++++++++++++++ .../ts5.9/webworker.iterable.generated.d.ts | 5 ++ baselines/webworker.generated.d.ts | 61 +++++++++++++++++++ inputfiles/overridingTypes.jsonc | 3 - 29 files changed, 976 insertions(+), 3 deletions(-) diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts index 3756807d2..033837e3f 100644 --- a/baselines/dom.generated.d.ts +++ b/baselines/dom.generated.d.ts @@ -14782,6 +14782,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -14922,6 +14928,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -14936,6 +14980,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -43190,10 +43243,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; @@ -43597,6 +43653,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/serviceworker.generated.d.ts b/baselines/serviceworker.generated.d.ts index 6e959bcd8..eb9b53930 100644 --- a/baselines/serviceworker.generated.d.ts +++ b/baselines/serviceworker.generated.d.ts @@ -4225,6 +4225,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -4365,6 +4371,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -4379,6 +4423,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -12389,10 +12442,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; @@ -12585,6 +12641,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/sharedworker.generated.d.ts b/baselines/sharedworker.generated.d.ts index 0ac59c7d7..b9547b36b 100644 --- a/baselines/sharedworker.generated.d.ts +++ b/baselines/sharedworker.generated.d.ts @@ -3908,6 +3908,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -4048,6 +4054,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -4062,6 +4106,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -12059,10 +12112,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; @@ -12237,6 +12293,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.5/dom.generated.d.ts b/baselines/ts5.5/dom.generated.d.ts index 016a99385..474ebe42f 100644 --- a/baselines/ts5.5/dom.generated.d.ts +++ b/baselines/ts5.5/dom.generated.d.ts @@ -14768,6 +14768,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -14908,6 +14914,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -14922,6 +14966,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -43164,10 +43217,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.5/dom.iterable.generated.d.ts b/baselines/ts5.5/dom.iterable.generated.d.ts index 0e6eaeaf9..9521fba0f 100644 --- a/baselines/ts5.5/dom.iterable.generated.d.ts +++ b/baselines/ts5.5/dom.iterable.generated.d.ts @@ -138,6 +138,11 @@ interface FormData { values(): IterableIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.5/serviceworker.generated.d.ts b/baselines/ts5.5/serviceworker.generated.d.ts index cf76d296b..e4f05f1c4 100644 --- a/baselines/ts5.5/serviceworker.generated.d.ts +++ b/baselines/ts5.5/serviceworker.generated.d.ts @@ -4222,6 +4222,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -4362,6 +4368,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -4376,6 +4420,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -12386,10 +12439,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.5/serviceworker.iterable.generated.d.ts b/baselines/ts5.5/serviceworker.iterable.generated.d.ts index 573cdb1bb..aa4088608 100644 --- a/baselines/ts5.5/serviceworker.iterable.generated.d.ts +++ b/baselines/ts5.5/serviceworker.iterable.generated.d.ts @@ -78,6 +78,11 @@ interface FormData { values(): IterableIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.5/sharedworker.generated.d.ts b/baselines/ts5.5/sharedworker.generated.d.ts index 0e2cfa3e3..273b905e2 100644 --- a/baselines/ts5.5/sharedworker.generated.d.ts +++ b/baselines/ts5.5/sharedworker.generated.d.ts @@ -3905,6 +3905,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -4045,6 +4051,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -4059,6 +4103,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -12056,10 +12109,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.5/sharedworker.iterable.generated.d.ts b/baselines/ts5.5/sharedworker.iterable.generated.d.ts index 948f8f4dd..1d0996f55 100644 --- a/baselines/ts5.5/sharedworker.iterable.generated.d.ts +++ b/baselines/ts5.5/sharedworker.iterable.generated.d.ts @@ -63,6 +63,11 @@ interface FormData { values(): IterableIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.5/webworker.generated.d.ts b/baselines/ts5.5/webworker.generated.d.ts index 76eec280a..59f766e32 100644 --- a/baselines/ts5.5/webworker.generated.d.ts +++ b/baselines/ts5.5/webworker.generated.d.ts @@ -4924,6 +4924,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -5064,6 +5070,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -5078,6 +5122,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -14063,10 +14116,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.5/webworker.iterable.generated.d.ts b/baselines/ts5.5/webworker.iterable.generated.d.ts index 5063dd610..79560e139 100644 --- a/baselines/ts5.5/webworker.iterable.generated.d.ts +++ b/baselines/ts5.5/webworker.iterable.generated.d.ts @@ -78,6 +78,11 @@ interface FormData { values(): IterableIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.6/dom.generated.d.ts b/baselines/ts5.6/dom.generated.d.ts index 3212298b1..e69051106 100644 --- a/baselines/ts5.6/dom.generated.d.ts +++ b/baselines/ts5.6/dom.generated.d.ts @@ -14779,6 +14779,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -14919,6 +14925,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -14933,6 +14977,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -43187,10 +43240,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.6/dom.iterable.generated.d.ts b/baselines/ts5.6/dom.iterable.generated.d.ts index 3ca23f70a..e36a9a458 100644 --- a/baselines/ts5.6/dom.iterable.generated.d.ts +++ b/baselines/ts5.6/dom.iterable.generated.d.ts @@ -142,6 +142,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.6/serviceworker.generated.d.ts b/baselines/ts5.6/serviceworker.generated.d.ts index cf76d296b..e4f05f1c4 100644 --- a/baselines/ts5.6/serviceworker.generated.d.ts +++ b/baselines/ts5.6/serviceworker.generated.d.ts @@ -4222,6 +4222,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -4362,6 +4368,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -4376,6 +4420,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -12386,10 +12439,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.6/serviceworker.iterable.generated.d.ts b/baselines/ts5.6/serviceworker.iterable.generated.d.ts index d111b8b5d..f25c31455 100644 --- a/baselines/ts5.6/serviceworker.iterable.generated.d.ts +++ b/baselines/ts5.6/serviceworker.iterable.generated.d.ts @@ -82,6 +82,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.6/sharedworker.generated.d.ts b/baselines/ts5.6/sharedworker.generated.d.ts index 0e2cfa3e3..273b905e2 100644 --- a/baselines/ts5.6/sharedworker.generated.d.ts +++ b/baselines/ts5.6/sharedworker.generated.d.ts @@ -3905,6 +3905,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -4045,6 +4051,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -4059,6 +4103,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -12056,10 +12109,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.6/sharedworker.iterable.generated.d.ts b/baselines/ts5.6/sharedworker.iterable.generated.d.ts index c06815f97..2fcedf8a5 100644 --- a/baselines/ts5.6/sharedworker.iterable.generated.d.ts +++ b/baselines/ts5.6/sharedworker.iterable.generated.d.ts @@ -67,6 +67,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.6/webworker.generated.d.ts b/baselines/ts5.6/webworker.generated.d.ts index 76eec280a..59f766e32 100644 --- a/baselines/ts5.6/webworker.generated.d.ts +++ b/baselines/ts5.6/webworker.generated.d.ts @@ -4924,6 +4924,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -5064,6 +5070,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -5078,6 +5122,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -14063,10 +14116,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.6/webworker.iterable.generated.d.ts b/baselines/ts5.6/webworker.iterable.generated.d.ts index ba65a889e..0ef808c21 100644 --- a/baselines/ts5.6/webworker.iterable.generated.d.ts +++ b/baselines/ts5.6/webworker.iterable.generated.d.ts @@ -82,6 +82,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.9/dom.generated.d.ts b/baselines/ts5.9/dom.generated.d.ts index d541df617..dc7a433cb 100644 --- a/baselines/ts5.9/dom.generated.d.ts +++ b/baselines/ts5.9/dom.generated.d.ts @@ -14779,6 +14779,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -14919,6 +14925,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -14933,6 +14977,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -43187,10 +43240,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.9/dom.iterable.generated.d.ts b/baselines/ts5.9/dom.iterable.generated.d.ts index f6497ce8e..a278ed3a2 100644 --- a/baselines/ts5.9/dom.iterable.generated.d.ts +++ b/baselines/ts5.9/dom.iterable.generated.d.ts @@ -142,6 +142,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.9/serviceworker.generated.d.ts b/baselines/ts5.9/serviceworker.generated.d.ts index fff405c29..2d847b9d0 100644 --- a/baselines/ts5.9/serviceworker.generated.d.ts +++ b/baselines/ts5.9/serviceworker.generated.d.ts @@ -4222,6 +4222,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -4362,6 +4368,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -4376,6 +4420,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -12386,10 +12439,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.9/serviceworker.iterable.generated.d.ts b/baselines/ts5.9/serviceworker.iterable.generated.d.ts index eca777792..c3e259ca5 100644 --- a/baselines/ts5.9/serviceworker.iterable.generated.d.ts +++ b/baselines/ts5.9/serviceworker.iterable.generated.d.ts @@ -82,6 +82,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.9/sharedworker.generated.d.ts b/baselines/ts5.9/sharedworker.generated.d.ts index 0941550b9..bd907c1a7 100644 --- a/baselines/ts5.9/sharedworker.generated.d.ts +++ b/baselines/ts5.9/sharedworker.generated.d.ts @@ -3905,6 +3905,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -4045,6 +4051,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -4059,6 +4103,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -12056,10 +12109,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.9/sharedworker.iterable.generated.d.ts b/baselines/ts5.9/sharedworker.iterable.generated.d.ts index 8f69c531f..97150aab8 100644 --- a/baselines/ts5.9/sharedworker.iterable.generated.d.ts +++ b/baselines/ts5.9/sharedworker.iterable.generated.d.ts @@ -67,6 +67,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/ts5.9/webworker.generated.d.ts b/baselines/ts5.9/webworker.generated.d.ts index 8819da2f4..e4dae4d2f 100644 --- a/baselines/ts5.9/webworker.generated.d.ts +++ b/baselines/ts5.9/webworker.generated.d.ts @@ -4924,6 +4924,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -5064,6 +5070,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -5078,6 +5122,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -14063,10 +14116,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; diff --git a/baselines/ts5.9/webworker.iterable.generated.d.ts b/baselines/ts5.9/webworker.iterable.generated.d.ts index 0d086c8cd..23622823a 100644 --- a/baselines/ts5.9/webworker.iterable.generated.d.ts +++ b/baselines/ts5.9/webworker.iterable.generated.d.ts @@ -82,6 +82,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts index dbcfb69f7..eb2e6bc0b 100644 --- a/baselines/webworker.generated.d.ts +++ b/baselines/webworker.generated.d.ts @@ -4927,6 +4927,12 @@ declare var GPUBindGroupLayout: { new(): GPUBindGroupLayout; }; +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsetsData: Uint32Array, dynamicOffsetsDataStart: GPUSize64, dynamicOffsetsDataLength: GPUSize32): void; +} + /** * The **`GPUBuffer`** interface of the WebGPU API represents a block of memory that can be used to store raw data to use in GPU operations. * Available only in secure contexts. @@ -5067,6 +5073,44 @@ declare var GPUCompilationMessage: { new(): GPUCompilationMessage; }; +/** + * The **`GPUComputePassEncoder`** interface of the WebGPU API encodes commands related to controlling the compute shader stage, as issued by a GPUComputePipeline. It forms part of the overall encoding activity of a GPUCommandEncoder. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder) + */ +interface GPUComputePassEncoder extends GPUBindingCommandsMixin, GPUDebugCommandsMixin, GPUObjectBase { + /** + * The **`dispatchWorkgroups()`** method of the GPUComputePassEncoder interface dispatches a specific grid of workgroups to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups) + */ + dispatchWorkgroups(workgroupCountX: GPUSize32, workgroupCountY?: GPUSize32, workgroupCountZ?: GPUSize32): void; + /** + * The **`dispatchWorkgroupsIndirect()`** method of the GPUComputePassEncoder interface dispatches a grid of workgroups, defined by the parameters of a GPUBuffer, to perform the work being done by the current GPUComputePipeline (i.e., set via GPUComputePassEncoder.setPipeline()). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect) + */ + dispatchWorkgroupsIndirect(indirectBuffer: GPUBuffer, indirectOffset: GPUSize64): void; + /** + * The **`end()`** method of the GPUComputePassEncoder interface completes recording of the current compute pass command sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/end) + */ + end(): void; + /** + * The **`setPipeline()`** method of the GPUComputePassEncoder interface sets the GPUComputePipeline to use for this compute pass. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setPipeline) + */ + setPipeline(pipeline: GPUComputePipeline): void; +} + +declare var GPUComputePassEncoder: { + prototype: GPUComputePassEncoder; + new(): GPUComputePassEncoder; +}; + /** * The **`GPUComputePipeline`** interface of the WebGPU API represents a pipeline that controls the compute shader stage and can be used in a GPUComputePassEncoder. * Available only in secure contexts. @@ -5081,6 +5125,15 @@ declare var GPUComputePipeline: { new(): GPUComputePipeline; }; +interface GPUDebugCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/insertDebugMarker) */ + insertDebugMarker(markerLabel: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/popDebugGroup) */ + popDebugGroup(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUCommandEncoder/pushDebugGroup) */ + pushDebugGroup(groupLabel: string): void; +} + /** * The **`GPUDeviceLostInfo`** interface of the WebGPU API represents the object returned when the GPUDevice.lost Promise resolves. This provides information as to why a device has been lost. * Available only in secure contexts. @@ -14066,10 +14119,13 @@ type GLsizei = number; type GLsizeiptr = number; type GLuint = number; type GLuint64 = number; +type GPUBufferDynamicOffset = number; type GPUFlagsConstant = number; +type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUSize32 = number; type GPUSize32Out = number; type GPUSize64 = number; type GPUSize64Out = number; @@ -14281,6 +14337,11 @@ interface FormData { values(): FormDataIterator; } +interface GPUBindingCommandsMixin { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUComputePassEncoder/setBindGroup) */ + setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: GPUBufferDynamicOffset[]): void; +} + interface GPUSupportedFeatures extends ReadonlySet { } diff --git a/inputfiles/overridingTypes.jsonc b/inputfiles/overridingTypes.jsonc index af19ecfad..ced1626d7 100644 --- a/inputfiles/overridingTypes.jsonc +++ b/inputfiles/overridingTypes.jsonc @@ -2886,9 +2886,6 @@ "GPUCommandEncoder": { "exposed": "" }, - "GPUComputePassEncoder": { - "exposed": "" - }, "GPUDevice": { "exposed": "" },