From 6a5da4954f03e6e806e48b137179739c5df36f54 Mon Sep 17 00:00:00 2001 From: Kagami Sascha Rosylight Date: Sat, 7 Feb 2026 19:07:36 +0100 Subject: [PATCH] Add GPUQueue --- baselines/dom.generated.d.ts | 110 ++++++++++++++++++ baselines/serviceworker.generated.d.ts | 110 ++++++++++++++++++ baselines/sharedworker.generated.d.ts | 110 ++++++++++++++++++ baselines/ts5.5/dom.generated.d.ts | 89 ++++++++++++++ baselines/ts5.5/dom.iterable.generated.d.ts | 21 ++++ baselines/ts5.5/serviceworker.generated.d.ts | 89 ++++++++++++++ .../serviceworker.iterable.generated.d.ts | 21 ++++ baselines/ts5.5/sharedworker.generated.d.ts | 89 ++++++++++++++ .../sharedworker.iterable.generated.d.ts | 21 ++++ baselines/ts5.5/webworker.generated.d.ts | 89 ++++++++++++++ .../ts5.5/webworker.iterable.generated.d.ts | 21 ++++ baselines/ts5.6/dom.generated.d.ts | 89 ++++++++++++++ baselines/ts5.6/dom.iterable.generated.d.ts | 21 ++++ baselines/ts5.6/serviceworker.generated.d.ts | 89 ++++++++++++++ .../serviceworker.iterable.generated.d.ts | 21 ++++ baselines/ts5.6/sharedworker.generated.d.ts | 89 ++++++++++++++ .../sharedworker.iterable.generated.d.ts | 21 ++++ baselines/ts5.6/webworker.generated.d.ts | 89 ++++++++++++++ .../ts5.6/webworker.iterable.generated.d.ts | 21 ++++ baselines/ts5.9/dom.generated.d.ts | 89 ++++++++++++++ baselines/ts5.9/dom.iterable.generated.d.ts | 21 ++++ baselines/ts5.9/serviceworker.generated.d.ts | 89 ++++++++++++++ .../serviceworker.iterable.generated.d.ts | 21 ++++ baselines/ts5.9/sharedworker.generated.d.ts | 89 ++++++++++++++ .../sharedworker.iterable.generated.d.ts | 21 ++++ baselines/ts5.9/webworker.generated.d.ts | 89 ++++++++++++++ .../ts5.9/webworker.iterable.generated.d.ts | 21 ++++ baselines/webworker.generated.d.ts | 110 ++++++++++++++++++ inputfiles/overridingTypes.jsonc | 3 - 29 files changed, 1760 insertions(+), 3 deletions(-) diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts index 0ed90a2f1..150fdf8fd 100644 --- a/baselines/dom.generated.d.ts +++ b/baselines/dom.generated.d.ts @@ -812,10 +812,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -823,6 +851,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -15219,6 +15260,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -43412,11 +43497,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -43829,6 +43918,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/serviceworker.generated.d.ts b/baselines/serviceworker.generated.d.ts index 59633e1b2..22bdc8a39 100644 --- a/baselines/serviceworker.generated.d.ts +++ b/baselines/serviceworker.generated.d.ts @@ -279,10 +279,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -290,6 +318,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -4662,6 +4703,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -12609,11 +12694,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -12815,6 +12904,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/sharedworker.generated.d.ts b/baselines/sharedworker.generated.d.ts index eea62952b..b4e918c84 100644 --- a/baselines/sharedworker.generated.d.ts +++ b/baselines/sharedworker.generated.d.ts @@ -223,10 +223,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -234,6 +262,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -4345,6 +4386,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -12279,11 +12364,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -12467,6 +12556,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.5/dom.generated.d.ts b/baselines/ts5.5/dom.generated.d.ts index 839509552..2f0dab3e6 100644 --- a/baselines/ts5.5/dom.generated.d.ts +++ b/baselines/ts5.5/dom.generated.d.ts @@ -809,10 +809,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -820,6 +848,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -15205,6 +15246,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -43386,11 +43471,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.5/dom.iterable.generated.d.ts b/baselines/ts5.5/dom.iterable.generated.d.ts index cb1cca394..32cf0d367 100644 --- a/baselines/ts5.5/dom.iterable.generated.d.ts +++ b/baselines/ts5.5/dom.iterable.generated.d.ts @@ -143,6 +143,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.5/serviceworker.generated.d.ts b/baselines/ts5.5/serviceworker.generated.d.ts index 882daeb07..6ad76b2e4 100644 --- a/baselines/ts5.5/serviceworker.generated.d.ts +++ b/baselines/ts5.5/serviceworker.generated.d.ts @@ -276,10 +276,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -287,6 +315,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -4659,6 +4700,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -12606,11 +12691,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.5/serviceworker.iterable.generated.d.ts b/baselines/ts5.5/serviceworker.iterable.generated.d.ts index 3007c166f..718d40757 100644 --- a/baselines/ts5.5/serviceworker.iterable.generated.d.ts +++ b/baselines/ts5.5/serviceworker.iterable.generated.d.ts @@ -83,6 +83,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.5/sharedworker.generated.d.ts b/baselines/ts5.5/sharedworker.generated.d.ts index 55c2f2377..fd491fc86 100644 --- a/baselines/ts5.5/sharedworker.generated.d.ts +++ b/baselines/ts5.5/sharedworker.generated.d.ts @@ -220,10 +220,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -231,6 +259,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -4342,6 +4383,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -12276,11 +12361,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.5/sharedworker.iterable.generated.d.ts b/baselines/ts5.5/sharedworker.iterable.generated.d.ts index 7709e16db..b823c4769 100644 --- a/baselines/ts5.5/sharedworker.iterable.generated.d.ts +++ b/baselines/ts5.5/sharedworker.iterable.generated.d.ts @@ -68,6 +68,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.5/webworker.generated.d.ts b/baselines/ts5.5/webworker.generated.d.ts index 848bf7b7f..8e9a1623b 100644 --- a/baselines/ts5.5/webworker.generated.d.ts +++ b/baselines/ts5.5/webworker.generated.d.ts @@ -366,10 +366,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -377,6 +405,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -5361,6 +5402,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -14283,11 +14368,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | VideoFrame | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.5/webworker.iterable.generated.d.ts b/baselines/ts5.5/webworker.iterable.generated.d.ts index 2387eec5a..1f369747e 100644 --- a/baselines/ts5.5/webworker.iterable.generated.d.ts +++ b/baselines/ts5.5/webworker.iterable.generated.d.ts @@ -83,6 +83,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.6/dom.generated.d.ts b/baselines/ts5.6/dom.generated.d.ts index 3784af749..426c9fb42 100644 --- a/baselines/ts5.6/dom.generated.d.ts +++ b/baselines/ts5.6/dom.generated.d.ts @@ -809,10 +809,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -820,6 +848,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -15216,6 +15257,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -43409,11 +43494,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.6/dom.iterable.generated.d.ts b/baselines/ts5.6/dom.iterable.generated.d.ts index 0b340ab13..9812f1477 100644 --- a/baselines/ts5.6/dom.iterable.generated.d.ts +++ b/baselines/ts5.6/dom.iterable.generated.d.ts @@ -147,6 +147,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.6/serviceworker.generated.d.ts b/baselines/ts5.6/serviceworker.generated.d.ts index 882daeb07..6ad76b2e4 100644 --- a/baselines/ts5.6/serviceworker.generated.d.ts +++ b/baselines/ts5.6/serviceworker.generated.d.ts @@ -276,10 +276,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -287,6 +315,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -4659,6 +4700,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -12606,11 +12691,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.6/serviceworker.iterable.generated.d.ts b/baselines/ts5.6/serviceworker.iterable.generated.d.ts index 049d91a34..340dded66 100644 --- a/baselines/ts5.6/serviceworker.iterable.generated.d.ts +++ b/baselines/ts5.6/serviceworker.iterable.generated.d.ts @@ -87,6 +87,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.6/sharedworker.generated.d.ts b/baselines/ts5.6/sharedworker.generated.d.ts index 55c2f2377..fd491fc86 100644 --- a/baselines/ts5.6/sharedworker.generated.d.ts +++ b/baselines/ts5.6/sharedworker.generated.d.ts @@ -220,10 +220,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -231,6 +259,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -4342,6 +4383,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -12276,11 +12361,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.6/sharedworker.iterable.generated.d.ts b/baselines/ts5.6/sharedworker.iterable.generated.d.ts index ca1bb81ae..d4a62d41a 100644 --- a/baselines/ts5.6/sharedworker.iterable.generated.d.ts +++ b/baselines/ts5.6/sharedworker.iterable.generated.d.ts @@ -72,6 +72,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.6/webworker.generated.d.ts b/baselines/ts5.6/webworker.generated.d.ts index 848bf7b7f..8e9a1623b 100644 --- a/baselines/ts5.6/webworker.generated.d.ts +++ b/baselines/ts5.6/webworker.generated.d.ts @@ -366,10 +366,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -377,6 +405,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -5361,6 +5402,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -14283,11 +14368,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | VideoFrame | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.6/webworker.iterable.generated.d.ts b/baselines/ts5.6/webworker.iterable.generated.d.ts index 52d20c59e..04c00be09 100644 --- a/baselines/ts5.6/webworker.iterable.generated.d.ts +++ b/baselines/ts5.6/webworker.iterable.generated.d.ts @@ -87,6 +87,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.9/dom.generated.d.ts b/baselines/ts5.9/dom.generated.d.ts index 62299ad9b..f8c3ade35 100644 --- a/baselines/ts5.9/dom.generated.d.ts +++ b/baselines/ts5.9/dom.generated.d.ts @@ -809,10 +809,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -820,6 +848,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -15216,6 +15257,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -43409,11 +43494,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.9/dom.iterable.generated.d.ts b/baselines/ts5.9/dom.iterable.generated.d.ts index ad8fdffb0..e18e69624 100644 --- a/baselines/ts5.9/dom.iterable.generated.d.ts +++ b/baselines/ts5.9/dom.iterable.generated.d.ts @@ -147,6 +147,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.9/serviceworker.generated.d.ts b/baselines/ts5.9/serviceworker.generated.d.ts index 85eed0ceb..63822768c 100644 --- a/baselines/ts5.9/serviceworker.generated.d.ts +++ b/baselines/ts5.9/serviceworker.generated.d.ts @@ -276,10 +276,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -287,6 +315,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -4659,6 +4700,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -12606,11 +12691,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.9/serviceworker.iterable.generated.d.ts b/baselines/ts5.9/serviceworker.iterable.generated.d.ts index 46653a53a..250783983 100644 --- a/baselines/ts5.9/serviceworker.iterable.generated.d.ts +++ b/baselines/ts5.9/serviceworker.iterable.generated.d.ts @@ -87,6 +87,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.9/sharedworker.generated.d.ts b/baselines/ts5.9/sharedworker.generated.d.ts index 8fdabbc82..c21684b83 100644 --- a/baselines/ts5.9/sharedworker.generated.d.ts +++ b/baselines/ts5.9/sharedworker.generated.d.ts @@ -220,10 +220,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -231,6 +259,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -4342,6 +4383,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -12276,11 +12361,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.9/sharedworker.iterable.generated.d.ts b/baselines/ts5.9/sharedworker.iterable.generated.d.ts index aa9c3477c..ecc45398a 100644 --- a/baselines/ts5.9/sharedworker.iterable.generated.d.ts +++ b/baselines/ts5.9/sharedworker.iterable.generated.d.ts @@ -72,6 +72,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/ts5.9/webworker.generated.d.ts b/baselines/ts5.9/webworker.generated.d.ts index 3d34450d6..119b9eec2 100644 --- a/baselines/ts5.9/webworker.generated.d.ts +++ b/baselines/ts5.9/webworker.generated.d.ts @@ -366,10 +366,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -377,6 +405,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -5361,6 +5402,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -14283,11 +14368,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | VideoFrame | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; diff --git a/baselines/ts5.9/webworker.iterable.generated.d.ts b/baselines/ts5.9/webworker.iterable.generated.d.ts index 96f561e4b..70f8eebd3 100644 --- a/baselines/ts5.9/webworker.iterable.generated.d.ts +++ b/baselines/ts5.9/webworker.iterable.generated.d.ts @@ -87,6 +87,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts index a0654baa4..2916b4d66 100644 --- a/baselines/webworker.generated.d.ts +++ b/baselines/webworker.generated.d.ts @@ -369,10 +369,38 @@ interface GPUColorDict { r: number; } +interface GPUCopyExternalImageDestInfo extends GPUTexelCopyTextureInfo { + colorSpace?: PredefinedColorSpace; + premultipliedAlpha?: boolean; +} + +interface GPUCopyExternalImageSourceInfo { + flipY?: boolean; + origin?: GPUOrigin2D; + source: GPUCopyExternalImageSource; +} + +interface GPUExtent3DDict { + depthOrArrayLayers?: GPUIntegerCoordinate; + height?: GPUIntegerCoordinate; + width: GPUIntegerCoordinate; +} + interface GPUObjectDescriptorBase { label?: string; } +interface GPUOrigin2DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; +} + +interface GPUOrigin3DDict { + x?: GPUIntegerCoordinate; + y?: GPUIntegerCoordinate; + z?: GPUIntegerCoordinate; +} + interface GPUPipelineErrorInit { reason: GPUPipelineErrorReason; } @@ -380,6 +408,19 @@ interface GPUPipelineErrorInit { interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase { } +interface GPUTexelCopyBufferLayout { + bytesPerRow?: GPUSize32; + offset?: GPUSize64; + rowsPerImage?: GPUSize32; +} + +interface GPUTexelCopyTextureInfo { + aspect?: GPUTextureAspect; + mipLevel?: GPUIntegerCoordinate; + origin?: GPUOrigin3D; + texture: GPUTexture; +} + interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase { arrayLayerCount?: GPUIntegerCoordinate; aspect?: GPUTextureAspect; @@ -5364,6 +5405,50 @@ declare var GPUQuerySet: { new(): GPUQuerySet; }; +/** + * The **`GPUQueue`** interface of the WebGPU API controls execution of encoded commands on the GPU. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue) + */ +interface GPUQueue extends GPUObjectBase { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: GPUExtent3D): void; + /** + * The **`onSubmittedWorkDone()`** method of the GPUQueue interface returns a Promise that resolves when all the work submitted to the GPU via this GPUQueue at the point the method is called has been processed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/onSubmittedWorkDone) + */ + onSubmittedWorkDone(): Promise; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: GPUCommandBuffer[]): void; + /** + * The **`writeBuffer()`** method of the GPUQueue interface writes a provided data source into a given GPUBuffer. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeBuffer) + */ + writeBuffer(buffer: GPUBuffer, bufferOffset: GPUSize64, data: AllowSharedBufferSource, dataOffset?: GPUSize64, size?: GPUSize64): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: GPUExtent3D): void; +} + +declare var GPUQueue: { + prototype: GPUQueue; + new(): GPUQueue; +}; + /** * The **`GPURenderBundle`** interface of the WebGPU API represents a container for pre-recorded bundles of commands. * Available only in secure contexts. @@ -14286,11 +14371,15 @@ type GLuint = number; type GLuint64 = number; type GPUBufferDynamicOffset = number; type GPUColor = number[] | GPUColorDict; +type GPUCopyExternalImageSource = ImageBitmap | ImageData | VideoFrame | OffscreenCanvas; +type GPUExtent3D = GPUIntegerCoordinate[] | GPUExtent3DDict; type GPUFlagsConstant = number; type GPUIndex32 = number; type GPUIntegerCoordinate = number; type GPUIntegerCoordinateOut = number; type GPUMapModeFlags = number; +type GPUOrigin2D = GPUIntegerCoordinate[] | GPUOrigin2DDict; +type GPUOrigin3D = GPUIntegerCoordinate[] | GPUOrigin3DDict; type GPUSignedOffset32 = number; type GPUSize32 = number; type GPUSize32Out = number; @@ -14511,6 +14600,27 @@ interface GPUBindingCommandsMixin { setBindGroup(index: GPUIndex32, bindGroup: GPUBindGroup | null, dynamicOffsets?: Iterable): void; } +interface GPUQueue { + /** + * The **`copyExternalImageToTexture()`** method of the GPUQueue interface copies a snapshot taken from a source image, video, or canvas into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/copyExternalImageToTexture) + */ + copyExternalImageToTexture(source: GPUCopyExternalImageSourceInfo, destination: GPUCopyExternalImageDestInfo, copySize: Iterable): void; + /** + * The **`submit()`** method of the GPUQueue interface schedules the execution of command buffers represented by one or more GPUCommandBuffer objects by the GPU. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/submit) + */ + submit(commandBuffers: Iterable): void; + /** + * The **`writeTexture()`** method of the GPUQueue interface writes a provided data source into a given GPUTexture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GPUQueue/writeTexture) + */ + writeTexture(destination: GPUTexelCopyTextureInfo, data: AllowSharedBufferSource, dataLayout: GPUTexelCopyBufferLayout, size: Iterable): void; +} + interface GPURenderPassEncoder { /** * The **`executeBundles()`** method of the GPURenderPassEncoder interface executes commands previously recorded into the referenced GPURenderBundles, as part of this render pass. diff --git a/inputfiles/overridingTypes.jsonc b/inputfiles/overridingTypes.jsonc index ca10adb50..e746dbf3f 100644 --- a/inputfiles/overridingTypes.jsonc +++ b/inputfiles/overridingTypes.jsonc @@ -2886,9 +2886,6 @@ "GPUDevice": { "exposed": "" }, - "GPUQueue": { - "exposed": "" - }, "TrustedHTML": { "exposed": "" },