From 0483835f3102f88663b4cb26eac25daa627f55bc Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Thu, 12 Feb 2026 20:34:11 +0100 Subject: [PATCH] Add GPUDevice.createComputePipeline[Async] --- baselines/dom.generated.d.ts | 28 ++++++++++++++++++++ baselines/serviceworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/sharedworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.5/dom.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.5/serviceworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.5/sharedworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.5/webworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.6/dom.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.6/serviceworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.6/sharedworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.6/webworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.9/dom.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.9/serviceworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.9/sharedworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/ts5.9/webworker.generated.d.ts | 28 ++++++++++++++++++++ baselines/webworker.generated.d.ts | 28 ++++++++++++++++++++ inputfiles/overridingTypes.jsonc | 2 -- 17 files changed, 448 insertions(+), 2 deletions(-) diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts index 80c6ca312..d2c8b09a3 100644 --- a/baselines/dom.generated.d.ts +++ b/baselines/dom.generated.d.ts @@ -864,6 +864,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -901,10 +905,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -15377,6 +15391,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -43836,6 +43862,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -43949,6 +43976,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FullscreenNavigationUI = "auto" | "hide" | "show"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/serviceworker.generated.d.ts b/baselines/serviceworker.generated.d.ts index bb123304f..57e1235a9 100644 --- a/baselines/serviceworker.generated.d.ts +++ b/baselines/serviceworker.generated.d.ts @@ -331,6 +331,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -367,10 +371,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -4819,6 +4833,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -13026,6 +13052,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -13081,6 +13108,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FrameType = "auxiliary" | "nested" | "none" | "top-level"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/sharedworker.generated.d.ts b/baselines/sharedworker.generated.d.ts index 8286b9118..0577b40da 100644 --- a/baselines/sharedworker.generated.d.ts +++ b/baselines/sharedworker.generated.d.ts @@ -275,6 +275,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -311,10 +315,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -4502,6 +4516,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -12702,6 +12728,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -12753,6 +12780,7 @@ type FileSystemHandleKind = "directory" | "file"; type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.5/dom.generated.d.ts b/baselines/ts5.5/dom.generated.d.ts index d0458bd0d..72692a3ef 100644 --- a/baselines/ts5.5/dom.generated.d.ts +++ b/baselines/ts5.5/dom.generated.d.ts @@ -861,6 +861,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -898,10 +902,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -15363,6 +15377,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -43810,6 +43836,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -43923,6 +43950,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FullscreenNavigationUI = "auto" | "hide" | "show"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.5/serviceworker.generated.d.ts b/baselines/ts5.5/serviceworker.generated.d.ts index 187196a6d..6b1a0feec 100644 --- a/baselines/ts5.5/serviceworker.generated.d.ts +++ b/baselines/ts5.5/serviceworker.generated.d.ts @@ -328,6 +328,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -364,10 +368,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -4816,6 +4830,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -13023,6 +13049,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -13078,6 +13105,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FrameType = "auxiliary" | "nested" | "none" | "top-level"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.5/sharedworker.generated.d.ts b/baselines/ts5.5/sharedworker.generated.d.ts index 50ae44897..6b2ce639a 100644 --- a/baselines/ts5.5/sharedworker.generated.d.ts +++ b/baselines/ts5.5/sharedworker.generated.d.ts @@ -272,6 +272,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -308,10 +312,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -4499,6 +4513,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -12699,6 +12725,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -12750,6 +12777,7 @@ type FileSystemHandleKind = "directory" | "file"; type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.5/webworker.generated.d.ts b/baselines/ts5.5/webworker.generated.d.ts index e210aa1f8..122544e41 100644 --- a/baselines/ts5.5/webworker.generated.d.ts +++ b/baselines/ts5.5/webworker.generated.d.ts @@ -418,6 +418,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -455,10 +459,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -5519,6 +5533,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -14701,6 +14727,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -14765,6 +14792,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FrameType = "auxiliary" | "nested" | "none" | "top-level"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.6/dom.generated.d.ts b/baselines/ts5.6/dom.generated.d.ts index 73bc42253..cbca16caa 100644 --- a/baselines/ts5.6/dom.generated.d.ts +++ b/baselines/ts5.6/dom.generated.d.ts @@ -861,6 +861,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -898,10 +902,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -15374,6 +15388,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -43833,6 +43859,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -43946,6 +43973,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FullscreenNavigationUI = "auto" | "hide" | "show"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.6/serviceworker.generated.d.ts b/baselines/ts5.6/serviceworker.generated.d.ts index 187196a6d..6b1a0feec 100644 --- a/baselines/ts5.6/serviceworker.generated.d.ts +++ b/baselines/ts5.6/serviceworker.generated.d.ts @@ -328,6 +328,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -364,10 +368,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -4816,6 +4830,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -13023,6 +13049,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -13078,6 +13105,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FrameType = "auxiliary" | "nested" | "none" | "top-level"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.6/sharedworker.generated.d.ts b/baselines/ts5.6/sharedworker.generated.d.ts index 50ae44897..6b2ce639a 100644 --- a/baselines/ts5.6/sharedworker.generated.d.ts +++ b/baselines/ts5.6/sharedworker.generated.d.ts @@ -272,6 +272,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -308,10 +312,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -4499,6 +4513,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -12699,6 +12725,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -12750,6 +12777,7 @@ type FileSystemHandleKind = "directory" | "file"; type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.6/webworker.generated.d.ts b/baselines/ts5.6/webworker.generated.d.ts index e210aa1f8..122544e41 100644 --- a/baselines/ts5.6/webworker.generated.d.ts +++ b/baselines/ts5.6/webworker.generated.d.ts @@ -418,6 +418,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -455,10 +459,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -5519,6 +5533,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -14701,6 +14727,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -14765,6 +14792,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FrameType = "auxiliary" | "nested" | "none" | "top-level"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.9/dom.generated.d.ts b/baselines/ts5.9/dom.generated.d.ts index 62fabb204..791598e5b 100644 --- a/baselines/ts5.9/dom.generated.d.ts +++ b/baselines/ts5.9/dom.generated.d.ts @@ -861,6 +861,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -898,10 +902,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -15374,6 +15388,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -43833,6 +43859,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -43946,6 +43973,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FullscreenNavigationUI = "auto" | "hide" | "show"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.9/serviceworker.generated.d.ts b/baselines/ts5.9/serviceworker.generated.d.ts index c8dc85794..e6b078525 100644 --- a/baselines/ts5.9/serviceworker.generated.d.ts +++ b/baselines/ts5.9/serviceworker.generated.d.ts @@ -328,6 +328,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -364,10 +368,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -4816,6 +4830,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -13023,6 +13049,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -13078,6 +13105,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FrameType = "auxiliary" | "nested" | "none" | "top-level"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.9/sharedworker.generated.d.ts b/baselines/ts5.9/sharedworker.generated.d.ts index 3a266df7d..eee1515d8 100644 --- a/baselines/ts5.9/sharedworker.generated.d.ts +++ b/baselines/ts5.9/sharedworker.generated.d.ts @@ -272,6 +272,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -308,10 +312,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -4499,6 +4513,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -12699,6 +12725,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -12750,6 +12777,7 @@ type FileSystemHandleKind = "directory" | "file"; type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/ts5.9/webworker.generated.d.ts b/baselines/ts5.9/webworker.generated.d.ts index 1f158c83d..f2f7f5751 100644 --- a/baselines/ts5.9/webworker.generated.d.ts +++ b/baselines/ts5.9/webworker.generated.d.ts @@ -418,6 +418,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -455,10 +459,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -5519,6 +5533,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -14701,6 +14727,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -14765,6 +14792,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FrameType = "auxiliary" | "nested" | "none" | "top-level"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts index 6e10e3c62..ec5c66035 100644 --- a/baselines/webworker.generated.d.ts +++ b/baselines/webworker.generated.d.ts @@ -421,6 +421,10 @@ interface GPUComputePassTimestampWrites { querySet: GPUQuerySet; } +interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase { + compute: GPUProgrammableStage; +} + interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { colorSpace?: PredefinedColorSpace; premultipliedAlpha?: boolean; @@ -458,10 +462,20 @@ interface GPUOrigin3DDict { z?: GPUIntegerCoordinate; } +interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase { + layout: GPUPipelineLayout | GPUAutoLayoutMode; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } +interface GPUProgrammableStage { + constants?: Record; + entryPoint?: string; + module: GPUShaderModule; +} + interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } @@ -5522,6 +5536,18 @@ interface GPUDevice extends EventTarget, GPUObjectBase { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createCommandEncoder) */ createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder; + /** + * The **`createComputePipeline()`** method of the GPUDevice interface creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipeline) + */ + createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline; + /** + * The **`createComputePipelineAsync()`** method of the GPUDevice interface returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUDevice/createComputePipelineAsync) + */ + createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise; /** * The **`createRenderBundleEncoder()`** method of the GPUDevice interface creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required. * @@ -14704,6 +14730,7 @@ type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; +type GPUPipelineConstantValue = number; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -14768,6 +14795,7 @@ type FontDisplay = "auto" | "block" | "fallback" | "optional" | "swap"; type FontFaceLoadStatus = "error" | "loaded" | "loading" | "unloaded"; type FontFaceSetLoadStatus = "loaded" | "loading"; type FrameType = "auxiliary" | "nested" | "none" | "top-level"; +type GPUAutoLayoutMode = "auto"; type GPUBufferMapState = "mapped" | "pending" | "unmapped"; type GPUCanvasAlphaMode = "opaque" | "premultiplied"; type GPUCanvasToneMappingMode = "extended" | "standard"; diff --git a/inputfiles/overridingTypes.jsonc b/inputfiles/overridingTypes.jsonc index f2949b65f..eae2b5d9a 100644 --- a/inputfiles/overridingTypes.jsonc +++ b/inputfiles/overridingTypes.jsonc @@ -2881,8 +2881,6 @@ "methods": { "method": { "createBindGroupLayout": { "exposed": "" }, - "createComputePipeline": { "exposed": "" }, - "createComputePipelineAsync": { "exposed": "" }, "createPipelineLayout": { "exposed": "" }, "createQuerySet": { "exposed": "" }, "createRenderPipeline": { "exposed": "" },