ambiser
/
face-api
mirror of https://github.com/vladmandic/face-api.git
9
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
face-api/src/types/webgpu.d.ts

2985 lines
93 KiB
TypeScript
Raw Normal View History

change typedefs
2023-01-29 16:08:46 +01:00
/* eslint-disable */
// explicit copy of @webgpu/types to enable typedef bundling
interface HTMLCanvasElement {
getContext(
contextId:
| "webgpu"
): GPUCanvasContext | null;
}
interface OffscreenCanvas {
getContext(
contextId:
| "webgpu"
): GPUCanvasContext | null;
}
type GPUExtent3DStrict =
| Iterable<GPUIntegerCoordinate>
| GPUExtent3DDictStrict;
// GPUExtent3DDictStrict is defined to help developers catch a common class of errors.
// This interface defines depth as an undefined, which will cause a type check failure if someone
// attempts to set depth rather than depthOrArrayLayers on a GPUExtent3D (an easy mistake to make.)
interface GPUExtent3DDictStrict
extends GPUExtent3DDict {
/** @deprecated use depthOrArrayLayers instead */
depth?: undefined;
}
// *********************************************************************************************
// Semi-auto-generated (by manual diff with autogenerated types)
// *********************************************************************************************
type GPUBindingResource =
| GPUSampler
| GPUTextureView
| GPUBufferBinding
| GPUExternalTexture;
type GPUBufferDynamicOffset =
number;
type GPUBufferUsageFlags =
number;
type GPUColor =
| Iterable<number>
| GPUColorDict;
type GPUColorWriteFlags =
number;
type GPUComputePassTimestampWrites =
Iterable<GPUComputePassTimestampWrite>;
type GPUDepthBias =
number;
type GPUExtent3D =
| Iterable<GPUIntegerCoordinate>
| GPUExtent3DDict;
type GPUFlagsConstant =
number;
type GPUIndex32 =
number;
type GPUIntegerCoordinate =
number;
type GPUMapModeFlags =
number;
type GPUOrigin2D =
| Iterable<GPUIntegerCoordinate>
| GPUOrigin2DDict;
type GPUOrigin3D =
| Iterable<GPUIntegerCoordinate>
| GPUOrigin3DDict;
type GPUPipelineConstantValue =
number;
type GPURenderPassTimestampWrites =
Iterable<GPURenderPassTimestampWrite>;
type GPUSampleMask =
number;
type GPUShaderStageFlags =
number;
type GPUSignedOffset32 =
number;
type GPUSize32 =
number;
type GPUSize64 =
number;
type GPUStencilValue =
number;
type GPUTextureUsageFlags =
number;
type GPUAddressMode =
| "clamp-to-edge"
| "repeat"
| "mirror-repeat";
type GPUAutoLayoutMode =
"auto";
type GPUBlendFactor =
| "zero"
| "one"
| "src"
| "one-minus-src"
| "src-alpha"
| "one-minus-src-alpha"
| "dst"
| "one-minus-dst"
| "dst-alpha"
| "one-minus-dst-alpha"
| "src-alpha-saturated"
| "constant"
| "one-minus-constant";
type GPUBlendOperation =
| "add"
| "subtract"
| "reverse-subtract"
| "min"
| "max";
type GPUBufferBindingType =
| "uniform"
| "storage"
| "read-only-storage";
type GPUCanvasAlphaMode =
| "opaque"
| "premultiplied";
/** @deprecated use GPUCanvasAlphaMode instead */
type GPUCanvasCompositingAlphaMode =
GPUCanvasAlphaMode;
type GPUCompareFunction =
| "never"
| "less"
| "equal"
| "less-equal"
| "greater"
| "not-equal"
| "greater-equal"
| "always";
type GPUCompilationMessageType =
| "error"
| "warning"
| "info";
type GPUComputePassTimestampLocation =
| "beginning"
| "end";
type GPUCullMode =
| "none"
| "front"
| "back";
type GPUDeviceLostReason =
"destroyed";
type GPUErrorFilter =
| "out-of-memory"
| "validation";
type GPUFeatureName =
| "depth-clip-control"
| "depth32float-stencil8"
| "texture-compression-bc"
| "texture-compression-etc2"
| "texture-compression-astc"
| "timestamp-query"
| "indirect-first-instance"
| "shader-f16"
| "bgra8unorm-storage";
type GPUFilterMode =
| "nearest"
| "linear";
type GPUFrontFace =
| "ccw"
| "cw";
type GPUIndexFormat =
| "uint16"
| "uint32";
type GPULoadOp =
| "load"
| "clear";
type GPUMipmapFilterMode =
| "nearest"
| "linear";
type GPUPowerPreference =
| "low-power"
| "high-performance";
type GPUPrimitiveTopology =
| "point-list"
| "line-list"
| "line-strip"
| "triangle-list"
| "triangle-strip";
type GPUQueryType =
| "occlusion"
| "timestamp";
type GPURenderPassTimestampLocation =
| "beginning"
| "end";
type GPUSamplerBindingType =
| "filtering"
| "non-filtering"
| "comparison";
type GPUStencilOperation =
| "keep"
| "zero"
| "replace"
| "invert"
| "increment-clamp"
| "decrement-clamp"
| "increment-wrap"
| "decrement-wrap";
type GPUStorageTextureAccess =
"write-only";
type GPUStoreOp =
| "store"
| "discard";
type GPUTextureAspect =
| "all"
| "stencil-only"
| "depth-only";
type GPUTextureDimension =
| "1d"
| "2d"
| "3d";
type GPUTextureFormat =
| "r8unorm"
| "r8snorm"
| "r8uint"
| "r8sint"
| "r16uint"
| "r16sint"
| "r16float"
| "rg8unorm"
| "rg8snorm"
| "rg8uint"
| "rg8sint"
| "r32uint"
| "r32sint"
| "r32float"
| "rg16uint"
| "rg16sint"
| "rg16float"
| "rgba8unorm"
| "rgba8unorm-srgb"
| "rgba8snorm"
| "rgba8uint"
| "rgba8sint"
| "bgra8unorm"
| "bgra8unorm-srgb"
| "rgb9e5ufloat"
| "rgb10a2unorm"
| "rg11b10ufloat"
| "rg32uint"
| "rg32sint"
| "rg32float"
| "rgba16uint"
| "rgba16sint"
| "rgba16float"
| "rgba32uint"
| "rgba32sint"
| "rgba32float"
| "stencil8"
| "depth16unorm"
| "depth24plus"
| "depth24plus-stencil8"
| "depth32float"
| "depth32float-stencil8"
| "bc1-rgba-unorm"
| "bc1-rgba-unorm-srgb"
| "bc2-rgba-unorm"
| "bc2-rgba-unorm-srgb"
| "bc3-rgba-unorm"
| "bc3-rgba-unorm-srgb"
| "bc4-r-unorm"
| "bc4-r-snorm"
| "bc5-rg-unorm"
| "bc5-rg-snorm"
| "bc6h-rgb-ufloat"
| "bc6h-rgb-float"
| "bc7-rgba-unorm"
| "bc7-rgba-unorm-srgb"
| "etc2-rgb8unorm"
| "etc2-rgb8unorm-srgb"
| "etc2-rgb8a1unorm"
| "etc2-rgb8a1unorm-srgb"
| "etc2-rgba8unorm"
| "etc2-rgba8unorm-srgb"
| "eac-r11unorm"
| "eac-r11snorm"
| "eac-rg11unorm"
| "eac-rg11snorm"
| "astc-4x4-unorm"
| "astc-4x4-unorm-srgb"
| "astc-5x4-unorm"
| "astc-5x4-unorm-srgb"
| "astc-5x5-unorm"
| "astc-5x5-unorm-srgb"
| "astc-6x5-unorm"
| "astc-6x5-unorm-srgb"
| "astc-6x6-unorm"
| "astc-6x6-unorm-srgb"
| "astc-8x5-unorm"
| "astc-8x5-unorm-srgb"
| "astc-8x6-unorm"
| "astc-8x6-unorm-srgb"
| "astc-8x8-unorm"
| "astc-8x8-unorm-srgb"
| "astc-10x5-unorm"
| "astc-10x5-unorm-srgb"
| "astc-10x6-unorm"
| "astc-10x6-unorm-srgb"
| "astc-10x8-unorm"
| "astc-10x8-unorm-srgb"
| "astc-10x10-unorm"
| "astc-10x10-unorm-srgb"
| "astc-12x10-unorm"
| "astc-12x10-unorm-srgb"
| "astc-12x12-unorm"
| "astc-12x12-unorm-srgb";
type GPUTextureSampleType =
| "float"
| "unfilterable-float"
| "depth"
| "sint"
| "uint";
type GPUTextureViewDimension =
| "1d"
| "2d"
| "2d-array"
| "cube"
| "cube-array"
| "3d";
type GPUVertexFormat =
| "uint8x2"
| "uint8x4"
| "sint8x2"
| "sint8x4"
| "unorm8x2"
| "unorm8x4"
| "snorm8x2"
| "snorm8x4"
| "uint16x2"
| "uint16x4"
| "sint16x2"
| "sint16x4"
| "unorm16x2"
| "unorm16x4"
| "snorm16x2"
| "snorm16x4"
| "float16x2"
| "float16x4"
| "float32"
| "float32x2"
| "float32x3"
| "float32x4"
| "uint32"
| "uint32x2"
| "uint32x3"
| "uint32x4"
| "sint32"
| "sint32x2"
| "sint32x3"
| "sint32x4";
type GPUVertexStepMode =
| "vertex"
| "instance";
interface GPUBindGroupDescriptor
extends GPUObjectDescriptorBase {
/**
* The {@link GPUBindGroupLayout} the entries of this bind group will conform to.
*/
layout: GPUBindGroupLayout;
/**
* A list of entries describing the resources to expose to the shader for each binding
* described by the {@link GPUBindGroupDescriptor#layout}.
*/
entries: Iterable<GPUBindGroupEntry>;
}
interface GPUBindGroupEntry {
/**
* A unique identifier for a resource binding within the {@link GPUBindGroup}, corresponding to a
* {@link GPUBindGroupLayoutEntry#binding|GPUBindGroupLayoutEntry.binding} and a @binding
* attribute in the {@link GPUShaderModule}.
*/
binding: GPUIndex32;
/**
* The resource to bind, which may be a {@link GPUSampler}, {@link GPUTextureView},
* {@link GPUExternalTexture}, or {@link GPUBufferBinding}.
*/
resource: GPUBindingResource;
}
interface GPUBindGroupLayoutDescriptor
extends GPUObjectDescriptorBase {
entries: Iterable<GPUBindGroupLayoutEntry>;
}
interface GPUBindGroupLayoutEntry {
/**
* A unique identifier for a resource binding within the {@link GPUBindGroupLayout}, corresponding
* to a {@link GPUBindGroupEntry#binding|GPUBindGroupEntry.binding} and a @binding
* attribute in the {@link GPUShaderModule}.
*/
binding: GPUIndex32;
/**
* A bitset of the members of {@link GPUShaderStage}.
* Each set bit indicates that a {@link GPUBindGroupLayoutEntry}'s resource
* will be accessible from the associated shader stage.
*/
visibility: GPUShaderStageFlags;
/**
* When not `undefined`, indicates the binding resource type for this {@link GPUBindGroupLayoutEntry}
* is {@link GPUBufferBinding}.
*/
buffer?: GPUBufferBindingLayout;
/**
* When not `undefined`, indicates the binding resource type for this {@link GPUBindGroupLayoutEntry}
* is {@link GPUSampler}.
*/
sampler?: GPUSamplerBindingLayout;
/**
* When not `undefined`, indicates the binding resource type for this {@link GPUBindGroupLayoutEntry}
* is {@link GPUTextureView}.
*/
texture?: GPUTextureBindingLayout;
/**
* When not `undefined`, indicates the binding resource type for this {@link GPUBindGroupLayoutEntry}
* is {@link GPUTextureView}.
*/
storageTexture?: GPUStorageTextureBindingLayout;
/**
* When not `undefined`, indicates the binding resource type for this {@link GPUBindGroupLayoutEntry}
* is {@link GPUExternalTexture}.
*/
externalTexture?: GPUExternalTextureBindingLayout;
}
interface GPUBlendComponent {
/**
* Defines the {@link GPUBlendOperation} used to calculate the values written to the target
* attachment components.
*/
operation?: GPUBlendOperation;
/**
* Defines the {@link GPUBlendFactor} operation to be performed on values from the fragment shader.
*/
srcFactor?: GPUBlendFactor;
/**
* Defines the {@link GPUBlendFactor} operation to be performed on values from the target attachment.
*/
dstFactor?: GPUBlendFactor;
}
interface GPUBlendState {
color: GPUBlendComponent;
alpha: GPUBlendComponent;
}
interface GPUBufferBinding {
/**
* The {@link GPUBuffer} to bind.
*/
buffer: GPUBuffer;
/**
* The offset, in bytes, from the beginning of {@link GPUBufferBinding#buffer} to the
* beginning of the range exposed to the shader by the buffer binding.
*/
offset?: GPUSize64;
/**
* The size, in bytes, of the buffer binding. If `undefined`, specifies the range starting at
* {@link GPUBufferBinding#offset} and ending at the end of {@link GPUBufferBinding#buffer}.
*/
size?: GPUSize64;
}
interface GPUBufferBindingLayout {
/**
* Indicates the type required for buffers bound to this bindings.
*/
type?: GPUBufferBindingType;
/**
* Indicates whether this binding requires a dynamic offset.
*/
hasDynamicOffset?: boolean;
/**
* Indicates the minimum buffer binding size.
* Bindings are always validated against this size in {@link GPUDevice#createBindGroup}.
* If this *is not* `0`, pipeline creation additionally [$validating shader binding|validates$]
* that this value is large enough for the bindings declared in the shader.
* If this *is* `0`, draw/dispatch commands additionally [$Validate encoder bind groups|validate$]
* that each binding in the {@link GPUBindGroup} is large enough for the bindings declared in the shader.
* Note:
* Similar execution-time validation is theoretically possible for other
* binding-related fields specified for early validation, like
* {@link GPUTextureBindingLayout#sampleType} and {@link GPUStorageTextureBindingLayout#format},
* which currently can only be validated in pipeline creation.
* However, such execution-time validation could be costly or unnecessarily complex, so it is
* available only for {@link GPUBufferBindingLayout#minBindingSize} which is expected to have the
* most ergonomic impact.
*/
minBindingSize?: GPUSize64;
}
interface GPUBufferDescriptor
extends GPUObjectDescriptorBase {
/**
* The size of the buffer in bytes.
*/
size: GPUSize64;
/**
* The allowed usages for the buffer.
*/
usage: GPUBufferUsageFlags;
/**
* If `true` creates the buffer in an already mapped state, allowing
* {@link GPUBuffer#getMappedRange} to be called immediately. It is valid to set
* {@link GPUBufferDescriptor#mappedAtCreation} to `true` even if {@link GPUBufferDescriptor#usage}
* does not contain {@link GPUBufferUsage#MAP_READ} or {@link GPUBufferUsage#MAP_WRITE}. This can be
* used to set the buffer's initial data.
* Guarantees that even if the buffer creation eventually fails, it will still appear as if the
* mapped range can be written/read to until it is unmapped.
*/
mappedAtCreation?: boolean;
}
interface GPUCanvasConfiguration {
/**
* The {@link GPUDevice} that textures returned by {@link GPUCanvasContext#getCurrentTexture} will be
* compatible with.
*/
device: GPUDevice;
/**
* The format that textures returned by {@link GPUCanvasContext#getCurrentTexture} will have.
* Must be one of the Supported context formats.
*/
format: GPUTextureFormat;
/**
* The usage that textures returned by {@link GPUCanvasContext#getCurrentTexture} will have.
* {@link GPUTextureUsage#RENDER_ATTACHMENT} is the default, but is not automatically included
* if the usage is explicitly set. Be sure to include {@link GPUTextureUsage#RENDER_ATTACHMENT}
* when setting a custom usage if you wish to use textures returned by
* {@link GPUCanvasContext#getCurrentTexture} as color targets for a render pass.
*/
usage?: GPUTextureUsageFlags;
/**
* The formats that views created from textures returned by
* {@link GPUCanvasContext#getCurrentTexture} may use.
*/
viewFormats?: Iterable<GPUTextureFormat>;
/**
* The color space that values written into textures returned by
* {@link GPUCanvasContext#getCurrentTexture} should be displayed with.
*/
colorSpace?: PredefinedColorSpace;
/**
* Determines the effect that alpha values will have on the content of textures returned by
* {@link GPUCanvasContext#getCurrentTexture} when read, displayed, or used as an image source.
*/
alphaMode?: GPUCanvasAlphaMode;
/** @deprecated use alphaMode instead (it is specified to affect the behavior of reading from the canvas) */
compositingAlphaMode?: GPUCanvasCompositingAlphaMode;
/** @deprecated use the canvas width/height instead */
size?: GPUExtent3D;
}
interface GPUColorDict {
r: number;
g: number;
b: number;
a: number;
}
interface GPUColorTargetState {
format: GPUTextureFormat;
blend?: GPUBlendState;
writeMask?: GPUColorWriteFlags;
}
type GPUCommandBufferDescriptor =
GPUObjectDescriptorBase;
type GPUCommandEncoderDescriptor =
GPUObjectDescriptorBase;
interface GPUComputePassDescriptor
extends GPUObjectDescriptorBase {
/**
* A sequence of {@link GPUComputePassTimestampWrite} values define where and when timestamp values will be written for this pass.
*/
timestampWrites?: GPUComputePassTimestampWrites;
}
interface GPUComputePassTimestampWrite {
querySet: GPUQuerySet;
queryIndex: GPUSize32;
location: GPUComputePassTimestampLocation;
}
interface GPUComputePipelineDescriptor
extends GPUPipelineDescriptorBase {
/**
* Describes the compute shader entry point of the pipeline.
*/
compute: GPUProgrammableStage;
}
interface GPUDepthStencilState {
/**
* The {@link GPUTextureViewDescriptor#format} of {@link GPURenderPassDescriptor#depthStencilAttachment}
* this {@link GPURenderPipeline} will be compatible with.
*/
format: GPUTextureFormat;
/**
* Indicates if this {@link GPURenderPipeline} can modify
* {@link GPURenderPassDescriptor#depthStencilAttachment} depth values.
*/
depthWriteEnabled?: boolean;
/**
* The comparison operation used to test fragment depths against
* {@link GPURenderPassDescriptor#depthStencilAttachment} depth values.
*/
depthCompare?: GPUCompareFunction;
/**
* Defines how stencil comparisons and operations are performed for front-facing primitives.
*/
stencilFront?: GPUStencilFaceState;
/**
* Defines how stencil comparisons and operations are performed for back-facing primitives.
*/
stencilBack?: GPUStencilFaceState;
/**
* Bitmask controlling which {@link GPURenderPassDescriptor#depthStencilAttachment} stencil value
* bits are read when performing stencil comparison tests.
*/
stencilReadMask?: GPUStencilValue;
/**
* Bitmask controlling which {@link GPURenderPassDescriptor#depthStencilAttachment} stencil value
* bits are written to when performing stencil operations.
*/
stencilWriteMask?: GPUStencilValue;
/**
* Constant depth bias added to each fragment. See [$biased fragment depth$] for details.
*/
depthBias?: GPUDepthBias;
/**
* Depth bias that scales with the fragment’s slope. See [$biased fragment depth$] for details.
*/
depthBiasSlopeScale?: number;
/**
* The maximum depth bias of a fragment. See [$biased fragment depth$] for details.
*/
depthBiasClamp?: number;
}
interface GPUDeviceDescriptor
extends GPUObjectDescriptorBase {
/**
* Specifies the features that are required by the device request.
* The request will fail if the adapter cannot provide these features.
* Exactly the specified set of features, and no more or less, will be allowed in validation
* of API calls on the resulting device.
*/
requiredFeatures?: Iterable<GPUFeatureName>;
/**
* Specifies the limits that are required by the device request.
* The request will fail if the adapter cannot provide these limits.
* Each key must be the name of a member of supported limits.
* Exactly the specified limits, and no limit/better or worse,
* will be allowed in validation of API calls on the resulting device.
* <!-- If we ever need limit types other than GPUSize32/GPUSize64, we can change the value
* type to `double` or `any` in the future and write out the type conversion explicitly (by
* reference to WebIDL spec). Or change the entire type to `any` and add back a `dictionary
* GPULimits` and define the conversion of the whole object by reference to WebIDL. -->
*/
requiredLimits?: Record<
string,
GPUSize64
>;
/**
* The descriptor for the default {@link GPUQueue}.
*/
defaultQueue?: GPUQueueDescriptor;
}
interface GPUExtent3DDict {
width: GPUIntegerCoordinate;
height?: GPUIntegerCoordinate;
depthOrArrayLayers?: GPUIntegerCoordinate;
}
interface GPUExternalTextureBindingLayout {}
interface GPUExternalTextureDescriptor
extends GPUObjectDescriptorBase {
source: HTMLVideoElement;
colorSpace?: PredefinedColorSpace;
}
interface GPUFragmentState
extends GPUProgrammableStage {
targets: Iterable<GPUColorTargetState | null>;
}
interface GPUImageCopyBuffer
extends GPUImageDataLayout {
/**
* A buffer which either contains image data to be copied or will store the image data being
* copied, depending on the method it is being passed to.
*/
buffer: GPUBuffer;
}
interface GPUImageCopyExternalImage {
/**
* The source of the image copy. The copy source data is captured at the moment that
* {@link GPUQueue#copyExternalImageToTexture} is issued.
*/
source:
| ImageBitmap
| HTMLCanvasElement
| OffscreenCanvas;
/**
* Defines the origin of the copy - the minimum (top-left) corner of the source sub-region to copy from.
* Together with `copySize`, defines the full copy sub-region.
*/
origin?: GPUOrigin2D;
/**
* Describes whether the source image is vertically flipped, or not.
* If this option is set to `true`, the copy is flipped vertically: the bottom row of the source
* region is copied into the first row of the destination region, and so on.
* The {@link GPUImageCopyExternalImage#origin} option is still relative to the top-left corner
* of the source image, increasing downward.
*/
flipY?: boolean;
}
interface GPUImageCopyTexture {
/**
* Texture to copy to/from.
*/
texture: GPUTexture;
/**
* Mip-map level of the {@link GPUImageCopyTexture#texture} to copy to/from.
*/
mipLevel?: GPUIntegerCoordinate;
/**
* Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from.
* Together with `copySize`, defines the full copy sub-region.
*/
origin?: GPUOrigin3D;
/**
* Defines which aspects of the {@link GPUImageCopyTexture#texture} to copy to/from.
*/
aspect?: GPUTextureAspect;
}
interface GPUImageCopyTextureTagged
extends GPUImageCopyTexture {
/**
* Describes the color space and encoding used to encode data into the destination texture.
* This [[#color-space-conversions|may result]] in values outside of the range [0, 1]
* being written to the target texture, if its format can represent them.
* Otherwise, the results are clamped to the target texture format's range.
* Note:
* If {@link GPUImageCopyTextureTagged#colorSpace} matches the source image,
* conversion may not be necessary. See [[#color-space-conversion-elision]].
*/
colorSpace?: PredefinedColorSpace;
/**
* Describes whether the data written into the texture should have its RGB channels
* premultiplied by the alpha channel, or not.
* If this option is set to `true` and the {@link GPUImageCopyExternalImage#source} is also
* premultiplied, the source RGB values must be preserved even if they exceed their
* corresponding alpha values.
* Note:
* If {@link GPUImageCopyTextureTagged#premultipliedAlpha} matches the source image,
* conversion may not be necessary. See [[#color-space-conversion-elision]].
*/
premultipliedAlpha?: boolean;
}
interface GPUImageDataLayout {
/**
* The offset, in bytes, from the beginning of the image data source (such as a
* {@link GPUImageCopyBuffer#buffer|GPUImageCopyBuffer.buffer}) to the start of the image data
* within that source.
*/
offset?: GPUSize64;
/**
* The stride, in bytes, between the beginning of each block row and the subsequent block row.
* Required if there are multiple block rows (i.e. the copy height or depth is more than one block).
*/
bytesPerRow?: GPUSize32;
/**
* Number of block rows per single image of the texture.
* {@link GPUImageDataLayout#rowsPerImage} &times;
* {@link GPUImageDataLayout#bytesPerRow} is the stride, in bytes, between the beginning of each image of data and the subsequent image.
* Required if there are multiple images (i.e. the copy depth is more than one).
*/
rowsPerImage?: GPUSize32;
}
interface GPUMultisampleState {
/**
* Number of samples per pixel. This {@link GPURenderPipeline} will be compatible only
* with attachment textures ({@link GPURenderPassDescriptor#colorAttachments}
* and {@link GPURenderPassDescriptor#depthStencilAttachment})
* with matching {@link GPUTextureDescriptor#sampleCount}s.
*/
count?: GPUSize32;
/**
* Mask determining which samples are written to.
*/
mask?: GPUSampleMask;
/**
* When `true` indicates that a fragment's alpha channel should be used to generate a sample
* coverage mask.
*/
alphaToCoverageEnabled?: boolean;
}
interface GPUObjectDescriptorBase {
/**
* The initial value of {@link GPUObjectBase#label|GPUObjectBase.label}.
*/
label?: string;
}
interface GPUOrigin2DDict {
x?: GPUIntegerCoordinate;
y?: GPUIntegerCoordinate;
}
interface GPUOrigin3DDict {
x?: GPUIntegerCoordinate;
y?: GPUIntegerCoordinate;
z?: GPUIntegerCoordinate;
}
interface GPUPipelineDescriptorBase
extends GPUObjectDescriptorBase {
layout:
| GPUPipelineLayout
| GPUAutoLayoutMode;
}
interface GPUPipelineLayoutDescriptor
extends GPUObjectDescriptorBase {
/**
* A list of {@link GPUBindGroupLayout}s the pipline will use. Each element corresponds to a
* @group attribute in the {@link GPUShaderModule}, with the `N`th element corresponding with
* `@group(N)`.
*/
bindGroupLayouts: Iterable<GPUBindGroupLayout>;
}
interface GPUPrimitiveState {
/**
* The type of primitive to be constructed from the vertex inputs.
*/
topology?: GPUPrimitiveTopology;
/**
* For strip topologies ({@link GPUPrimitiveTopology#"line-strip"} or
* {@link GPUPrimitiveTopology#"triangle-strip"}), defines the format of indices that may be used
* with this {@link GPURenderPipeline}. This determines the strip's primitive restart value. See
* [[#primitive-assembly]] for additional details.
* Required only if the pipeline is used with indexed draw calls.
* Not allowed with non-strip topologies.
*/
stripIndexFormat?: GPUIndexFormat;
/**
* Defines which polygons are considered front-facing.
*/
frontFace?: GPUFrontFace;
/**
* Defines which polygon orientation will be culled, if any.
*/
cullMode?: GPUCullMode;
/**
* If true, indicates that depth clipping is disabled. See [[#depth-clip-control]] for additional details.
* Requires the {@link GPUFeatureName#"depth-clip-control"} feature to be enabled.
*/
unclippedDepth?: boolean;
}
interface GPUProgrammableStage {
module: GPUShaderModule;
entryPoint: string;
constants?: Record<
string,
GPUPipelineConstantValue
>;
}
interface GPUQuerySetDescriptor
extends GPUObjectDescriptorBase {
/**
* The type of queries managed by {@link GPUQuerySet}.
*/
type: GPUQueryType;
/**
* The number of queries managed by {@link GPUQuerySet}.
*/
count: GPUSize32;
}
type GPUQueueDescriptor =
GPUObjectDescriptorBase;
type GPURenderBundleDescriptor =
GPUObjectDescriptorBase;
interface GPURenderBundleEncoderDescriptor
extends GPURenderPassLayout {
depthReadOnly?: boolean;
stencilReadOnly?: boolean;
}
interface GPURenderPassColorAttachment {
/**
* A {@link GPUTextureView} describing the texture subresource that will be output to for this
* color attachment.
*/
view: GPUTextureView;
/**
* A {@link GPUTextureView} describing the texture subresource that will receive the resolved
* output for this color attachment if {@link GPURenderPassColorAttachment#view} is
* multisampled.
*/
resolveTarget?: GPUTextureView;
/**
* Indicates the value to clear {@link GPURenderPassColorAttachment#view} to prior to executing the
* render pass. If not map/exist|provided defaults to `{r: 0, g: 0, b: 0, a: 0}`. Ignored
* if {@link GPURenderPassColorAttachment#loadOp} is not {@link GPULoadOp#"clear"}.
* The members of {@link GPURenderPassColorAttachment#clearValue} are all double values, so
* they will first be converted to the fully qualified format type of
* {@link GPURenderPassColorAttachment#view} before being set as the clear value of
* {@link GPURenderPassColorAttachment#view}.
* <div algorithm="clearValue to texture value">
* Let `colorAttachmentFormat` be
* {@link GPURenderPassColorAttachment#view}.{@link GPUTextureView#[[descriptor]]}.{@link GPUTextureViewDescriptor#format}.
* `colorAttachmentFormat` has up to four components: `r`, `g`, `b`, and `a`, each
* component containing one scalar value.
* For each `componentType` of `colorAttachmentFormat` and corresponding component scalar
* value `value` in {@link GPURenderPassColorAttachment#clearValue}:
* 1. If `componentType` is a:
* <dl class=switch>
* : floating-point type or normalized type
* Convert `value` converted to an IDL value|to an IDL value of type {{unrestricted float}} (`f32`).
* : signed integer type
* Convert `value` converted to an IDL value|to an IDL value of type {{long long}} (`i32`).
* : unsigned integer type
* Convert `value` converted to an IDL value|to an IDL value of type {{unsigned long long}} (`u32`).
*/
clearValue?: GPUColor;
loadOp: GPULoadOp;
storeOp: GPUStoreOp;
}
interface GPURenderPassDepthStencilAttachment {
/**
* A {@link GPUTextureView} describing the texture subresource that will be output to
* and read from for this depth/stencil attachment.
*/
view: GPUTextureView;
/**
* Indicates the value to clear {@link GPURenderPassDepthStencilAttachment#view}'s depth component
* to prior to executing the render pass. Ignored if {@link GPURenderPassDepthStencilAttachment#depthLoadOp}
* is not {@link GPULoadOp#"clear"}. Must be between 0.0 and 1.0, inclusive.
* <!-- unless unrestricted depth is enabled -->
*/
depthClearValue?: number;
/**
* Indicates the load operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
* depth component prior to executing the render pass.
* Note: It is recommended to prefer clearing; see {@link GPULoadOp#"clear"} for details.
*/
depthLoadOp?: GPULoadOp;
/**
* The store operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
* depth component after executing the render pass.
* Note: It is recommended to prefer a clear-value; see {@link GPULoadOp#"load"}.
*/
depthStoreOp?: GPUStoreOp;
/**
* Indicates that the depth component of {@link GPURenderPassDepthStencilAttachment#view}
* is read only.
*/
depthReadOnly?: boolean;
/**
* Indicates the value to clear {@link GPURenderPassDepthStencilAttachment#view}'s stencil component
* to prior to executing the render pass. Ignored if {@link GPURenderPassDepthStencilAttachment#stencilLoadOp}
* is not {@link GPULoadOp#"clear"}.
* The value will be converted to the type of the stencil aspect of `view` by taking the same
* number of LSBs as the number of bits in the stencil aspect of one texel block of `view`.
*/
stencilClearValue?: GPUStencilValue;
/**
* Indicates the load operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
* stencil component prior to executing the render pass.
* Note: It is recommended to prefer clearing; see {@link GPULoadOp#"clear"} for details.
*/
stencilLoadOp?: GPULoadOp;
/**
* The store operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
* stencil component after executing the render pass.
*/
stencilStoreOp?: GPUStoreOp;
/**
* Indicates that the stencil component of {@link GPURenderPassDepthStencilAttachment#view}
* is read only.
*/
stencilReadOnly?: boolean;
}
interface GPURenderPassDescriptor
extends GPUObjectDescriptorBase {
/**
* The set of {@link GPURenderPassColorAttachment} values in this sequence defines which
* color attachments will be output to when executing this render pass.
* Due to compatible usage list|usage compatibility, no color attachment
* may alias another attachment or any resource used inside the render pass.
*/
colorAttachments: Iterable<GPURenderPassColorAttachment | null>;
/**
* The {@link GPURenderPassDepthStencilAttachment} value that defines the depth/stencil
* attachment that will be output to and tested against when executing this render pass.
* Due to compatible usage list|usage compatibility, no writable depth/stencil attachment
* may alias another attachment or any resource used inside the render pass.
*/
depthStencilAttachment?: GPURenderPassDepthStencilAttachment;
/**
* The {@link GPUQuerySet} value defines where the occlusion query results will be stored for this pass.
*/
occlusionQuerySet?: GPUQuerySet;
/**
* A sequence of {@link GPURenderPassTimestampWrite} values defines where and when timestamp values will be written for this pass.
*/
timestampWrites?: GPURenderPassTimestampWrites;
/**
* The maximum number of draw calls that will be done in the render pass. Used by some
* implementations to size work injected before the render pass. Keeping the default value
* is a good default, unless it is known that more draw calls will be done.
*/
maxDrawCount?: GPUSize64;
}
interface GPURenderPassLayout
extends GPUObjectDescriptorBase {
colorFormats: Iterable<GPUTextureFormat | null>;
depthStencilFormat?: GPUTextureFormat;
sampleCount?: GPUSize32;
}
interface GPURenderPassTimestampWrite {
querySet: GPUQuerySet;
queryIndex: GPUSize32;
location: GPURenderPassTimestampLocation;
}
interface GPURenderPipelineDescriptor
extends GPUPipelineDescriptorBase {
/**
* Describes the vertex shader entry point of the pipeline and its input buffer layouts.
*/
vertex: GPUVertexState;
/**
* Describes the primitive-related properties of the pipeline.
*/
primitive?: GPUPrimitiveState;
/**
* Describes the optional depth-stencil properties, including the testing, operations, and bias.
*/
depthStencil?: GPUDepthStencilState;
/**
* Describes the multi-sampling properties of the pipeline.
*/
multisample?: GPUMultisampleState;
/**
* Describes the fragment shader entry point of the pipeline and its output colors. If
* `undefined`, the [[#no-color-output]] mode is enabled.
*/
fragment?: GPUFragmentState;
}
interface GPURequestAdapterOptions {
powerPreference?: GPUPowerPreference;
forceFallbackAdapter?: boolean;
}
interface GPUSamplerBindingLayout {
/**
* Indicates the required type of a sampler bound to this bindings.
*/
type?: GPUSamplerBindingType;
}
interface GPUSamplerDescriptor
extends GPUObjectDescriptorBase {
/**
*/
addressModeU?: GPUAddressMode;
/**
*/
addressModeV?: GPUAddressMode;
/**
* Specifies the {{GPUAddressMode|address modes}} for the texture width, height, and depth
* coordinates, respectively.
*/
addressModeW?: GPUAddressMode;
/**
* Specifies the sampling behavior when the sample footprint is smaller than or equal to one
* texel.
*/
magFilter?: GPUFilterMode;
/**
* Specifies the sampling behavior when the sample footprint is larger than one texel.
*/
minFilter?: GPUFilterMode;
/**
* Specifies behavior for sampling between mipmap levels.
*/
mipmapFilter?: GPUMipmapFilterMode;
/**
*/
lodMinClamp?: number;
/**
* Specifies the minimum and maximum levels of detail, respectively, used internally when
* sampling a texture.
*/
lodMaxClamp?: number;
/**
* When provided the sampler will be a comparison sampler with the specified
* {@link GPUCompareFunction}.
* Note: Comparison samplers may use filtering, but the sampling results will be
* implementation-dependent and may differ from the normal filtering rules.
*/
compare?: GPUCompareFunction;
/**
* Specifies the maximum anisotropy value clamp used by the sampler.
* Note: Most implementations support {@link GPUSamplerDescriptor#maxAnisotropy} values in range
* between 1 and 16, inclusive. The used value of {@link GPUSamplerDescriptor#maxAnisotropy} will
* be clamped to the maximum value that the platform supports.
*/
maxAnisotropy?: number;
}
interface GPUShaderModuleCompilationHint {
/**
* A {@link GPUPipelineLayout} that the {@link GPUShaderModule} may be used with in a future
* {@link GPUDevice#createComputePipeline()} or {@link GPUDevice#createRenderPipeline} call.
* If set to {@link GPUAutoLayoutMode#"auto"} the layout will be the [$default pipeline layout$]
* for the entry point associated with this hint will be used.
*/
layout?:
| GPUPipelineLayout
| GPUAutoLayoutMode;
}
interface GPUShaderModuleDescriptor
extends GPUObjectDescriptorBase {
/**
* The <a href="https://gpuweb.github.io/gpuweb/wgsl/">WGSL</a> source code for the shader
* module.
*/
code: string;
/**
* If defined MAY be interpreted as a source-map-v3 format.
* Source maps are optional, but serve as a standardized way to support dev-tool
* integration such as source-language debugging [[SourceMap]].
* WGSL names (identifiers) in source maps follow the rules defined in WGSL identifier
* comparison.
*/
sourceMap?: object;
/**
* If defined maps an entry point name from the shader to a {@link GPUShaderModuleCompilationHint}.
* No validation is performed with any of these {@link GPUShaderModuleCompilationHint}.
* Implementations should use any information present in the {@link GPUShaderModuleCompilationHint}
* to perform as much compilation as is possible within {@link GPUDevice#createShaderModule}.
* Entry point names follow the rules defined in WGSL identifier comparison.
* Note: Supplying information in {@link GPUShaderModuleDescriptor#hints} does not have any
* observable effect, other than performance. Because a single shader module can hold
* multiple entry points, and multiple pipelines can be created from a single shader
* module, it can be more performant for an implementation to do as much compilation as
* possible once in {@link GPUDevice#createShaderModule} rather than multiple times in
* the multiple calls to {@link GPUDevice#createComputePipeline} /
* {@link GPUDevice#createRenderPipeline}.
*/
hints?: Record<
string,
GPUShaderModuleCompilationHint
>;
}
interface GPUStencilFaceState {
/**
* The {@link GPUCompareFunction} used when testing fragments against
* {@link GPURenderPassDescriptor#depthStencilAttachment} stencil values.
*/
compare?: GPUCompareFunction;
/**
* The {@link GPUStencilOperation} performed if the fragment stencil comparison test described by
* {@link GPUStencilFaceState#compare} fails.
*/
failOp?: GPUStencilOperation;
/**
* The {@link GPUStencilOperation} performed if the fragment depth comparison described by
* {@link GPUDepthStencilState#depthCompare} fails.
*/
depthFailOp?: GPUStencilOperation;
/**
* The {@link GPUStencilOperation} performed if the fragment stencil comparison test described by
* {@link GPUStencilFaceState#compare} passes.
*/
passOp?: GPUStencilOperation;
}
interface GPUStorageTextureBindingLayout {
/**
* Indicates whether texture views bound to this binding will be bound for read-only or
* write-only access.
*/
access?: GPUStorageTextureAccess;
/**
* The required {@link GPUTextureViewDescriptor#format} of texture views bound to this binding.
*/
format: GPUTextureFormat;
/**
* Indicates the required {@link GPUTextureViewDescriptor#dimension} for texture views bound to
* this binding.
*/
viewDimension?: GPUTextureViewDimension;
}
interface GPUTextureBindingLayout {
/**
* Indicates the type required for texture views bound to this binding.
*/
sampleType?: GPUTextureSampleType;
/**
* Indicates the required {@link GPUTextureViewDescriptor#dimension} for texture views bound to
* this binding.
*/
viewDimension?: GPUTextureViewDimension;
/**
* Indicates whether or not texture views bound to this binding must be multisampled.
*/
multisampled?: boolean;
}
interface GPUTextureDescriptor
extends GPUObjectDescriptorBase {
/**
* The width, height, and depth or layer count of the texture.
*/
size: GPUExtent3DStrict;
/**
* The number of mip levels the texture will contain.
*/
mipLevelCount?: GPUIntegerCoordinate;
/**
* The sample count of the texture. A {@link GPUTextureDescriptor#sampleCount} &gt; `1` indicates
* a multisampled texture.
*/
sampleCount?: GPUSize32;
/**
* Whether the texture is one-dimensional, an array of two-dimensional layers, or three-dimensional.
*/
dimension?: GPUTextureDimension;
/**
* The format of the texture.
*/
format: GPUTextureFormat;
/**
* The allowed usages for the texture.
*/
usage: GPUTextureUsageFlags;
/**
* Specifies what view {@link GPUTextureViewDescriptor#format} values will be allowed when calling
* {@link GPUTexture#createView} on this texture (in addition to the texture's actual
* {@link GPUTextureDescriptor#format}).
* <div class=note>
* Note:
* Adding a format to this list may have a significant performance impact, so it is best
* to avoid adding formats unnecessarily.
* The actual performance impact is highly dependent on the target system; developers must
* test various systems to find out the impact on their particular application.
* For example, on some systems any texture with a {@link GPUTextureDescriptor#format} or
* {@link GPUTextureDescriptor#viewFormats} entry including
* {@link GPUTextureFormat#"rgba8unorm-srgb"} will perform less optimally than a
* {@link GPUTextureFormat#"rgba8unorm"} texture which does not.
* Similar caveats exist for other formats and pairs of formats on other systems.
* </div>
* Formats in this list must be texture view format compatible with the texture format.
* <div algorithm>
* Two {@link GPUTextureFormat}s `format` and `viewFormat` are <dfn dfn for=>texture view format compatible</dfn> if:
* - `format` equals `viewFormat`, or
* - `format` and `viewFormat` differ only in whether they are `srgb` formats (have the `-srgb` suffix).
* Issue(gpuweb/gpuweb#168): Define larger compatibility classes.
* </div>
*/
viewFormats?: Iterable<GPUTextureFormat>;
}
interface GPUTextureViewDescriptor
extends GPUObjectDescriptorBase {
/**
* The format of the texture view. Must be either the {@link GPUTextureDescriptor#format} of the
* texture or one of the {@link GPUTextureDescriptor#viewFormats} specified during its creation.
*/
format?: GPUTextureFormat;
/**
* The dimension to view the texture as.
*/
dimension?: GPUTextureViewDimension;
/**
* Which {@link GPUTextureAspect|aspect(s)} of the texture are accessible to the texture view.
*/
aspect?: GPUTextureAspect;
/**
* The first (most detailed) mipmap level accessible to the texture view.
*/
baseMipLevel?: GPUIntegerCoordinate;
/**
* How many mipmap levels, starting with {@link GPUTextureViewDescriptor#baseMipLevel}, are accessible to
* the texture view.
*/
mipLevelCount?: GPUIntegerCoordinate;
/**
* The index of the first array layer accessible to the texture view.
*/
baseArrayLayer?: GPUIntegerCoordinate;
/**
* How many array layers, starting with {@link GPUTextureViewDescriptor#baseArrayLayer}, are accessible
* to the texture view.
*/
arrayLayerCount?: GPUIntegerCoordinate;
}
interface GPUUncapturedErrorEventInit
extends EventInit {
error: GPUError;
}
interface GPUVertexAttribute {
/**
* The {@link GPUVertexFormat} of the attribute.
*/
format: GPUVertexFormat;
/**
* The offset, in bytes, from the beginning of the element to the data for the attribute.
*/
offset: GPUSize64;
/**
* The numeric location associated with this attribute, which will correspond with a
* <a href="https://gpuweb.github.io/gpuweb/wgsl/#input-output-locations">"@location" attribute</a>
* declared in the {@link GPURenderPipelineDescriptor#vertex}.{@link GPUProgrammableStage#module|module}.
*/
shaderLocation: GPUIndex32;
}
interface GPUVertexBufferLayout {
/**
* The stride, in bytes, between elements of this array.
*/
arrayStride: GPUSize64;
/**
* Whether each element of this array represents per-vertex data or per-instance data
*/
stepMode?: GPUVertexStepMode;
/**
* An array defining the layout of the vertex attributes within each element.
*/
attributes: Iterable<GPUVertexAttribute>;
}
interface GPUVertexState
extends GPUProgrammableStage {
buffers?: Iterable<GPUVertexBufferLayout | null>;
}
interface GPUBindingCommandsMixin {
/**
* Sets the current {@link GPUBindGroup} for the given index.
* @param index - The index to set the bind group at.
* @param bindGroup - Bind group to use for subsequent render or compute commands.
* <!--The overload appears to be confusing bikeshed, and it ends up expecting this to
* define the arguments for the 5-arg variant of the method, despite the "for"
* explicitly pointing at the 3-arg variant. See
* @param https - //github.com/plinss/widlparser/issues/56 and
* @param https - //github.com/tabatkins/bikeshed/issues/1740 -->
* @param dynamicOffsets - Array containing buffer offsets in bytes for each entry in
* `bindGroup` marked as {@link GPUBindGroupLayoutEntry#buffer}.{@link GPUBufferBindingLayout#hasDynamicOffset}.-->
*/
setBindGroup(
index: GPUIndex32,
bindGroup: GPUBindGroup,
dynamicOffsets?: Iterable<GPUBufferDynamicOffset>
): undefined;
/**
* Sets the current {@link GPUBindGroup} for the given index, specifying dynamic offsets as a subset
* of a {@link Uint32Array}.
* @param index - The index to set the bind group at.
* @param bindGroup - Bind group to use for subsequent render or compute commands.
* @param dynamicOffsetsData - Array containing buffer offsets in bytes for each entry in
* `bindGroup` marked as {@link GPUBindGroupLayoutEntry#buffer}.{@link GPUBufferBindingLayout#hasDynamicOffset}.
* @param dynamicOffsetsDataStart - Offset in elements into `dynamicOffsetsData` where the
* buffer offset data begins.
* @param dynamicOffsetsDataLength - Number of buffer offsets to read from `dynamicOffsetsData`.
*/
setBindGroup(
index: GPUIndex32,
bindGroup: GPUBindGroup,
dynamicOffsetsData: Uint32Array,
dynamicOffsetsDataStart: GPUSize64,
dynamicOffsetsDataLength: GPUSize32
): undefined;
}
interface GPUCommandsMixin {}
interface GPUDebugCommandsMixin {
/**
* Begins a labeled debug group containing subsequent commands.
* @param groupLabel - The label for the command group.
*/
pushDebugGroup(
groupLabel: string
): undefined;
/**
* Ends the labeled debug group most recently started by {@link GPUDebugCommandsMixin#pushDebugGroup}.
*/
popDebugGroup(): undefined;
/**
* Marks a point in a stream of commands with a label.
* @param markerLabel - The label to insert.
*/
insertDebugMarker(
markerLabel: string
): undefined;
}
interface GPUObjectBase {
/**
* Initially the empty string.
* A developer-provided label which can be used by the browser, OS, or other tools to help
* identify the underlying internal object to the developer. Examples include displaying
* the label in error/warning messages, browser developer tools, and platform debugging
* utilities. The user agent is free to choose if and how it will use this label.
* Note: {@link GPUObjectBase#label} is defined as a {@link USVString} because some user agents may
* supply it to the debug facilities of the underlying native APIs.
*/
label: string;
}
interface GPUPipelineBase {
/**
* Gets a {@link GPUBindGroupLayout} that is compatible with the {@link GPUPipelineBase}'s
* {@link GPUBindGroupLayout} at `index`.
* @param index - Index into the pipeline layout's {@link GPUPipelineLayout#[[bindGroupLayouts]]}
* sequence.
*/
getBindGroupLayout(
index: number
): GPUBindGroupLayout;
}
interface GPURenderCommandsMixin {
/**
* Sets the current {@link GPURenderPipeline}.
* @param pipeline - The render pipeline to use for subsequent drawing commands.
*/
setPipeline(
pipeline: GPURenderPipeline
): undefined;
/**
* Sets the current index buffer.
* @param buffer - Buffer containing index data to use for subsequent drawing commands.
* @param indexFormat - Format of the index data contained in `buffer`.
* @param offset - Offset in bytes into `buffer` where the index data begins. Defaults to `0`.
* @param size - Size in bytes of the index data in `buffer`.
* Defaults to the size of the buffer minus the offset.
*/
setIndexBuffer(
buffer: GPUBuffer,
indexFormat: GPUIndexFormat,
offset?: GPUSize64,
size?: GPUSize64
): undefined;
/**
* Sets the current vertex buffer for the given slot.
* @param slot - The vertex buffer slot to set the vertex buffer for.
* @param buffer - Buffer containing vertex data to use for subsequent drawing commands.
* @param offset - Offset in bytes into `buffer` where the vertex data begins. Defaults to `0`.
* @param size - Size in bytes of the vertex data in `buffer`.
* Defaults to the size of the buffer minus the offset.
*/
setVertexBuffer(
slot: GPUIndex32,
buffer: GPUBuffer,
offset?: GPUSize64,
size?: GPUSize64
): undefined;
/**
* Draws primitives.
* See [[#rendering-operations]] for the detailed specification.
* @param vertexCount - The number of vertices to draw.
* @param instanceCount - The number of instances to draw.
* @param firstVertex - Offset into the vertex buffers, in vertices, to begin drawing from.
* @param firstInstance - First instance to draw.
*/
draw(
vertexCount: GPUSize32,
instanceCount?: GPUSize32,
firstVertex?: GPUSize32,
firstInstance?: GPUSize32
): undefined;
/**
* Draws indexed primitives.
* See [[#rendering-operations]] for the detailed specification.
* @param indexCount - The number of indices to draw.
* @param instanceCount - The number of instances to draw.
* @param firstIndex - Offset into the index buffer, in indices, begin drawing from.
* @param baseVertex - Added to each index value before indexing into the vertex buffers.
* @param firstInstance - First instance to draw.
*/
drawIndexed(
indexCount: GPUSize32,
instanceCount?: GPUSize32,
firstIndex?: GPUSize32,
baseVertex?: GPUSignedOffset32,
firstInstance?: GPUSize32
): undefined;
/**
* Draws primitives using parameters read from a {@link GPUBuffer}.
* See [[#rendering-operations]] for the detailed specification.
* packed block of **four 32-bit unsigned integer values (16 bytes total)**, given in the same
* order as the arguments for {@link GPURenderEncoderBase#draw}. For example:
* @param indirectBuffer - Buffer containing the indirect draw parameters.
* @param indirectOffset - Offset in bytes into `indirectBuffer` where the drawing data begins.
*/
drawIndirect(
indirectBuffer: GPUBuffer,
indirectOffset: GPUSize64
): undefined;
/**
* Draws indexed primitives using parameters read from a {@link GPUBuffer}.
* See [[#rendering-operations]] for the detailed specification.
* tightly packed block of **five 32-bit unsigned integer values (20 bytes total)**, given in
* the same order as the arguments for {@link GPURenderEncoderBase#drawIndexed}. For example:
* @param indirectBuffer - Buffer containing the indirect drawIndexed parameters.
* @param indirectOffset - Offset in bytes into `indirectBuffer` where the drawing data begins.
*/
drawIndexedIndirect(
indirectBuffer: GPUBuffer,
indirectOffset: GPUSize64
): undefined;
}
interface NavigatorGPU {
readonly gpu: GPU;
}
interface GPU {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPU";
/**
* Requests an adapter from the user agent.
* The user agent chooses whether to return an adapter, and, if so,
* chooses according to the provided options.
* @param options - Criteria used to select the adapter.
*/
requestAdapter(
options?: GPURequestAdapterOptions
): Promise<GPUAdapter | null>;
/**
* Returns an optimal {@link GPUTextureFormat} for displaying 8-bit depth, standard dynamic range
* content on this system. Must only return {@link GPUTextureFormat#"rgba8unorm"} or
* {@link GPUTextureFormat#"bgra8unorm"}.
* The returned value can be passed as the {@link GPUCanvasConfiguration#format} to
* {@link GPUCanvasContext#configure} calls on a {@link GPUCanvasContext} to ensure the associated
* canvas is able to display its contents efficiently.
* Note: Canvases which are not displayed to the screen may or may not benefit from using this
* format.
*/
getPreferredCanvasFormat(): GPUTextureFormat;
}
declare var GPU: {
prototype: GPU;
new (): never;
};
interface GPUAdapter {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUAdapter";
/** @deprecated use requestAdapterInfo instead */
readonly name: string;
/**
* The set of values in `this`.{@link GPUAdapter#[[adapter]]}.{@link adapter#[[features]]}.
*/
readonly features: GPUSupportedFeatures;
/**
* The limits in `this`.{@link GPUAdapter#[[adapter]]}.{@link adapter#[[limits]]}.
*/
readonly limits: GPUSupportedLimits;
/**
* Returns the value of {@link GPUAdapter#[[adapter]]}.{@link adapter#[[fallback]]}.
*/
readonly isFallbackAdapter: boolean;
/**
* Requests a device from the adapter.
* @param descriptor - Description of the {@link GPUDevice} to request.
*/
requestDevice(
descriptor?: GPUDeviceDescriptor
): Promise<GPUDevice>;
/**
* Requests the {@link GPUAdapterInfo} for this {@link GPUAdapter}.
* Note: Adapter info values are returned with a Promise to give user agents an
* opportunity to perform potentially long-running checks when requesting unmasked values,
* such as asking for user consent before returning. If no `unmaskHints` are specified,
* however, no dialogs should be displayed to the user.
* @param unmaskHints - A list of {@link GPUAdapterInfo} attribute names for which unmasked
* values are desired if available.
*/
requestAdapterInfo(
unmaskHints?: Array<string>
): Promise<GPUAdapterInfo>;
}
declare var GPUAdapter: {
prototype: GPUAdapter;
new (): never;
};
interface GPUAdapterInfo {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUAdapterInfo";
/**
* The name of the vendor of the adapter, if available. Empty string otherwise.
*/
readonly vendor: string;
/**
* The name of the family or class of GPUs the adapter belongs to, if available. Empty
* string otherwise.
*/
readonly architecture: string;
/**
* A vendor-specific identifier for the adapter, if available. Empty string otherwise.
* Note: This is a value that represents the type of adapter. For example, it may be a
* [PCI device ID](https://pcisig.com/). It does not uniquely identify a given piece of
* hardware like a serial number.
*/
readonly device: string;
/**
* A human readable string describing the adapter as reported by the driver, if available.
* Empty string otherwise.
* Note: Because no formatting is applied to {@link GPUAdapterInfo#description} attempting to parse
* this value is not recommended. Applications which change their behavior based on the
* {@link GPUAdapterInfo}, such as applying workarounds for known driver issues, should rely on the
* other fields when possible.
*/
readonly description: string;
}
declare var GPUAdapterInfo: {
prototype: GPUAdapterInfo;
};
interface GPUBindGroup
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUBindGroup";
}
declare var GPUBindGroup: {
prototype: GPUBindGroup;
new (): never;
};
interface GPUBindGroupLayout
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUBindGroupLayout";
}
declare var GPUBindGroupLayout: {
prototype: GPUBindGroupLayout;
new (): never;
};
interface GPUBuffer
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUBuffer";
/**
* Maps the given range of the {@link GPUBuffer} and resolves the returned {@link Promise} when the
* {@link GPUBuffer}'s content is ready to be accessed with {@link GPUBuffer#getMappedRange}.
* @param mode - Whether the buffer should be mapped for reading or writing.
* @param offset - Offset in bytes into the buffer to the start of the range to map.
* @param size - Size in bytes of the range to map.
*/
mapAsync(
mode: GPUMapModeFlags,
offset?: GPUSize64,
size?: GPUSize64
): Promise<undefined>;
/**
* Returns a mapped range ArrayBuffer with the contents of the {@link GPUBuffer} in the given mapped range.
* @param offset - Offset in bytes into the buffer to return buffer contents from.
* @param size - Size in bytes of the {@link ArrayBuffer} to return.
*/
getMappedRange(
offset?: GPUSize64,
size?: GPUSize64
): ArrayBuffer;
/**
* Unmaps the mapped range of the {@link GPUBuffer} and makes it's contents available for use by the
* GPU again.
*/
unmap(): undefined;
/**
* Destroys the {@link GPUBuffer}.
* Note: It is valid to destroy a buffer multiple times.
* Note: Since no further operations can be enqueued using this buffer, implementations can
* free resource allocations, including mapped memory that was just unmapped.
*/
destroy(): undefined;
/**
* The length of the {@link GPUBuffer} allocation in bytes.
*/
readonly size: GPUSize64;
/**
* The allowed usages for this {@link GPUBuffer}.
*/
readonly usage: GPUBufferUsageFlags;
}
declare var GPUBuffer: {
prototype: GPUBuffer;
new (): never;
};
interface GPUCanvasContext {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUCanvasContext";
/**
* The canvas this context was created from.
*/
readonly canvas:
| HTMLCanvasElement
| OffscreenCanvas;
/**
* Configures the context for this canvas.
* This clears the drawing buffer to transparent black (in [$Replace the drawing buffer$]).
* @param configuration - Desired configuration for the context.
*/
configure(
configuration: GPUCanvasConfiguration
): undefined;
/**
* Removes the context configuration. Destroys any textures produced while configured.
*/
unconfigure(): undefined;
/** @deprecated Use {@link GPU#getPreferredCanvasFormat} instead. */
getPreferredFormat(
adapter: GPUAdapter
): GPUTextureFormat;
/**
* Get the {@link GPUTexture} that will be composited to the document by the {@link GPUCanvasContext}
* next.
* Note: The same {@link GPUTexture} object will be returned by every
* call to {@link GPUCanvasContext#getCurrentTexture} made within the same frame (i.e. between
* invocations of "[$update the rendering of the WebGPU canvas$]"), even if that {@link GPUTexture}
* is destroyed, failed validation, or failed to allocate, **unless** the current texture has
* been removed (in [$Replace the drawing buffer$]).
*/
getCurrentTexture(): GPUTexture;
}
declare var GPUCanvasContext: {
prototype: GPUCanvasContext;
new (): never;
};
interface GPUCommandBuffer
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUCommandBuffer";
}
declare var GPUCommandBuffer: {
prototype: GPUCommandBuffer;
new (): never;
};
interface GPUCommandEncoder
extends GPUObjectBase,
GPUCommandsMixin,
GPUDebugCommandsMixin {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUCommandEncoder";
/**
* Begins encoding a render pass described by `descriptor`.
* @param descriptor - Description of the {@link GPURenderPassEncoder} to create.
*/
beginRenderPass(
descriptor: GPURenderPassDescriptor
): GPURenderPassEncoder;
/**
* Begins encoding a compute pass described by `descriptor`.
* descriptor:
*/
beginComputePass(
descriptor?: GPUComputePassDescriptor
): GPUComputePassEncoder;
/**
* Encode a command into the {@link GPUCommandEncoder} that copies data from a sub-region of a
* {@link GPUBuffer} to a sub-region of another {@link GPUBuffer}.
* @param source - The {@link GPUBuffer} to copy from.
* @param sourceOffset - Offset in bytes into `source` to begin copying from.
* @param destination - The {@link GPUBuffer} to copy to.
* @param destinationOffset - Offset in bytes into `destination` to place the copied data.
* @param size - Bytes to copy.
*/
copyBufferToBuffer(
source: GPUBuffer,
sourceOffset: GPUSize64,
destination: GPUBuffer,
destinationOffset: GPUSize64,
size: GPUSize64
): undefined;
/**
* Encode a command into the {@link GPUCommandEncoder} that copies data from a sub-region of a
* {@link GPUBuffer} to a sub-region of one or multiple continuous texture subresources.
* @param source - Combined with `copySize`, defines the region of the source buffer.
* @param destination - Combined with `copySize`, defines the region of the destination texture subresource.
* `copySize`:
*/
copyBufferToTexture(
source: GPUImageCopyBuffer,
destination: GPUImageCopyTexture,
copySize: GPUExtent3DStrict
): undefined;
/**
* Encode a command into the {@link GPUCommandEncoder} that copies data from a sub-region of one or
* multiple continuous texture subresourcesto a sub-region of a {@link GPUBuffer}.
* @param source - Combined with `copySize`, defines the region of the source texture subresources.
* @param destination - Combined with `copySize`, defines the region of the destination buffer.
* `copySize`:
*/
copyTextureToBuffer(
source: GPUImageCopyTexture,
destination: GPUImageCopyBuffer,
copySize: GPUExtent3DStrict
): undefined;
/**
* Encode a command into the {@link GPUCommandEncoder} that copies data from a sub-region of one
* or multiple contiguous texture subresources to another sub-region of one or
* multiple continuous texture subresources.
* @param source - Combined with `copySize`, defines the region of the source texture subresources.
* @param destination - Combined with `copySize`, defines the region of the destination texture subresources.
* `copySize`:
*/
copyTextureToTexture(
source: GPUImageCopyTexture,
destination: GPUImageCopyTexture,
copySize: GPUExtent3DStrict
): undefined;
/**
* Encode a command into the {@link GPUCommandEncoder} that fills a sub-region of a
* {@link GPUBuffer} with zeros.
* @param buffer - The {@link GPUBuffer} to clear.
* @param offset - Offset in bytes into `buffer` where the sub-region to clear begins.
* @param size - Size in bytes of the sub-region to clear. Defaults to the size of the buffer minus `offset`.
*/
clearBuffer(
buffer: GPUBuffer,
offset?: GPUSize64,
size?: GPUSize64
): undefined;
/**
* Writes a timestamp value into a querySet when all previous commands have completed executing.
* @param querySet - The query set that will store the timestamp values.
* @param queryIndex - The index of the query in the query set.
*/
writeTimestamp(
querySet: GPUQuerySet,
queryIndex: GPUSize32
): undefined;
/**
* Resolves query results from a {@link GPUQuerySet} out into a range of a {@link GPUBuffer}.
* querySet:
* firstQuery:
* queryCount:
* destination:
* destinationOffset:
*/
resolveQuerySet(
querySet: GPUQuerySet,
firstQuery: GPUSize32,
queryCount: GPUSize32,
destination: GPUBuffer,
destinationOffset: GPUSize64
): undefined;
/**
* Completes recording of the commands sequence and returns a corresponding {@link GPUCommandBuffer}.
* descriptor:
*/
finish(
descriptor?: GPUCommandBufferDescriptor
): GPUCommandBuffer;
}
declare var GPUCommandEncoder: {
prototype: GPUCommandEncoder;
new (): never;
};
interface GPUCompilationInfo {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUCompilationInfo";
readonly messages: ReadonlyArray<GPUCompilationMessage>;
}
declare var GPUCompilationInfo: {
prototype: GPUCompilationInfo;
new (): never;
};
interface GPUCompilationMessage {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUCompilationMessage";
/**
* A human-readable string containing the message generated during the shader compilation.
*/
readonly message: string;
/**
* The severity level of the message.
* If the {@link GPUCompilationMessage#type} is "error", it corresponds to a
* shader-creation error.
*/
readonly type: GPUCompilationMessageType;
/**
* The line number in the shader {@link GPUShaderModuleDescriptor#code} the
* {@link GPUCompilationMessage#message} corresponds to. Value is one-based, such that a lineNum of
* `1` indicates the first line of the shader {@link GPUShaderModuleDescriptor#code}.
* If the {@link GPUCompilationMessage#message} corresponds to a substring this points to
* the line on which the substring begins. Must be `0` if the {@link GPUCompilationMessage#message}
* does not correspond to any specific point in the shader {@link GPUShaderModuleDescriptor#code}.
* Issue(gpuweb/gpuweb#2435): Reference WGSL spec when it [defines what a line is](https://gpuweb.github.io/gpuweb/wgsl/#comments).
*/
readonly lineNum: number;
/**
* The offset, in UTF-16 code units, from the beginning of line {@link GPUCompilationMessage#lineNum}
* of the shader {@link GPUShaderModuleDescriptor#code} to the point or beginning of the substring
* that the {@link GPUCompilationMessage#message} corresponds to. Value is one-based, such that a
* {@link GPUCompilationMessage#linePos} of `1` indicates the first code unit of the line.
* If {@link GPUCompilationMessage#message} corresponds to a substring this points to the
* first UTF-16 code unit of the substring. Must be `0` if the {@link GPUCompilationMessage#message}
* does not correspond to any specific point in the shader {@link GPUShaderModuleDescriptor#code}.
*/
readonly linePos: number;
/**
* The offset from the beginning of the shader {@link GPUShaderModuleDescriptor#code} in UTF-16
* code units to the point or beginning of the substring that {@link GPUCompilationMessage#message}
* corresponds to. Must reference the same position as {@link GPUCompilationMessage#lineNum} and
* {@link GPUCompilationMessage#linePos}. Must be `0` if the {@link GPUCompilationMessage#message}
* does not correspond to any specific point in the shader {@link GPUShaderModuleDescriptor#code}.
*/
readonly offset: number;
/**
* The number of UTF-16 code units in the substring that {@link GPUCompilationMessage#message}
* corresponds to. If the message does not correspond with a substring then
* {@link GPUCompilationMessage#length} must be 0.
*/
readonly length: number;
}
declare var GPUCompilationMessage: {
prototype: GPUCompilationMessage;
new (): never;
};
interface GPUComputePassEncoder
extends GPUObjectBase,
GPUCommandsMixin,
GPUDebugCommandsMixin,
GPUBindingCommandsMixin {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUComputePassEncoder";
/**
* Sets the current {@link GPUComputePipeline}.
* @param pipeline - The compute pipeline to use for subsequent dispatch commands.
*/
setPipeline(
pipeline: GPUComputePipeline
): undefined;
/**
* Dispatch work to be performed with the current {@link GPUComputePipeline}.
* See [[#computing-operations]] for the detailed specification.
* @param workgroupCountX - X dimension of the grid of workgroups to dispatch.
* @param workgroupCountY - Y dimension of the grid of workgroups to dispatch.
* @param workgroupCountZ - Z dimension of the grid of workgroups to dispatch.
*/
dispatchWorkgroups(
workgroupCountX: GPUSize32,
workgroupCountY?: GPUSize32,
workgroupCountZ?: GPUSize32
): undefined;
/** @deprecated Use dispatchWorkgroups instead */
dispatch(
workgroupCountX: GPUSize32,
workgroupCountY?: GPUSize32,
workgroupCountZ?: GPUSize32
): undefined;
/**
* Dispatch work to be performed with the current {@link GPUComputePipeline} using parameters read
* from a {@link GPUBuffer}.
* See [[#computing-operations]] for the detailed specification.
* packed block of **three 32-bit unsigned integer values (12 bytes total)**,
* given in the same order as the arguments for {@link GPUComputePassEncoder#dispatchWorkgroups}.
* For example:
* @param indirectBuffer - Buffer containing the indirect dispatch parameters.
* @param indirectOffset - Offset in bytes into `indirectBuffer` where the dispatch data begins.
*/
dispatchWorkgroupsIndirect(
indirectBuffer: GPUBuffer,
indirectOffset: GPUSize64
): undefined;
/** @deprecated Use dispatchWorkgroupsIndirect instead */
dispatchIndirect(
indirectBuffer: GPUBuffer,
indirectOffset: GPUSize64
): undefined;
/**
* Completes recording of the compute pass commands sequence.
*/
end(): undefined;
}
declare var GPUComputePassEncoder: {
prototype: GPUComputePassEncoder;
new (): never;
};
interface GPUComputePipeline
extends GPUObjectBase,
GPUPipelineBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUComputePipeline";
}
declare var GPUComputePipeline: {
prototype: GPUComputePipeline;
new (): never;
};
interface GPUDevice
extends EventTarget,
GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUDevice";
/**
* A set containing the {@link GPUFeatureName} values of the features
* supported by the device (i.e. the ones with which it was created).
*/
readonly features: GPUSupportedFeatures;
/**
* Exposes the limits supported by the device
* (which are exactly the ones with which it was created).
*/
readonly limits: GPUSupportedLimits;
/**
* The primary {@link GPUQueue} for this device.
*/
readonly queue: GPUQueue;
/**
* Destroys the device, preventing further operations on it.
* Outstanding asynchronous operations will fail.
* Note: It is valid to destroy a device multiple times.
* Note: Since no further operations can be enqueued on this device, implementations can abort
* outstanding asynchronous operations immediately and free resource allocations, including
* mapped memory that was just unmapped.
*/
destroy(): undefined;
/**
* Creates a {@link GPUBuffer}.
* @param descriptor - Description of the {@link GPUBuffer} to create.
*/
createBuffer(
descriptor: GPUBufferDescriptor
): GPUBuffer;
/**
* Creates a {@link GPUTexture}.
* @param descriptor - Description of the {@link GPUTexture} to create.
*/
createTexture(
descriptor: GPUTextureDescriptor
): GPUTexture;
/**
* Creates a {@link GPUSampler}.
* @param descriptor - Description of the {@link GPUSampler} to create.
*/
createSampler(
descriptor?: GPUSamplerDescriptor
): GPUSampler;
/**
* Creates a {@link GPUExternalTexture} wrapping the provided image source.
* @param descriptor - Provides the external image source object (and any creation options).
*/
importExternalTexture(
descriptor: GPUExternalTextureDescriptor
): GPUExternalTexture;
/**
* Creates a {@link GPUBindGroupLayout}.
* @param descriptor - Description of the {@link GPUBindGroupLayout} to create.
*/
createBindGroupLayout(
descriptor: GPUBindGroupLayoutDescriptor
): GPUBindGroupLayout;
/**
* Creates a {@link GPUPipelineLayout}.
* @param descriptor - Description of the {@link GPUPipelineLayout} to create.
*/
createPipelineLayout(
descriptor: GPUPipelineLayoutDescriptor
): GPUPipelineLayout;
/**
* Creates a {@link GPUBindGroup}.
* @param descriptor - Description of the {@link GPUBindGroup} to create.
*/
createBindGroup(
descriptor: GPUBindGroupDescriptor
): GPUBindGroup;
/**
* Creates a {@link GPUShaderModule}.
* @param descriptor - Description of the {@link GPUShaderModule} to create.
*/
createShaderModule(
descriptor: GPUShaderModuleDescriptor
): GPUShaderModule;
/**
* Creates a {@link GPUComputePipeline}.
* @param descriptor - Description of the {@link GPUComputePipeline} to create.
*/
createComputePipeline(
descriptor: GPUComputePipelineDescriptor
): GPUComputePipeline;
/**
* Creates a {@link GPURenderPipeline}.
* @param descriptor - Description of the {@link GPURenderPipeline} to create.
*/
createRenderPipeline(
descriptor: GPURenderPipelineDescriptor
): GPURenderPipeline;
/**
* Creates a {@link GPUComputePipeline}. The returned {@link Promise} resolves when the created pipeline
* is ready to be used without additional delay.
* If pipeline creation fails, the returned {@link Promise} rejects with an {@link OperationError}.
* Note: Use of this method is preferred whenever possible, as it prevents blocking the
* queue timeline work on pipeline compilation.
* @param descriptor - Description of the {@link GPUComputePipeline} to create.
*/
createComputePipelineAsync(
descriptor: GPUComputePipelineDescriptor
): Promise<GPUComputePipeline>;
/**
* Creates a {@link GPURenderPipeline}. The returned {@link Promise} resolves when the created pipeline
* is ready to be used without additional delay.
* If pipeline creation fails, the returned {@link Promise} rejects with an {@link OperationError}.
* Note: Use of this method is preferred whenever possible, as it prevents blocking the
* queue timeline work on pipeline compilation.
* @param descriptor - Description of the {@link GPURenderPipeline} to create.
*/
createRenderPipelineAsync(
descriptor: GPURenderPipelineDescriptor
): Promise<GPURenderPipeline>;
/**
* Creates a {@link GPUCommandEncoder}.
* @param descriptor - Description of the {@link GPUCommandEncoder} to create.
*/
createCommandEncoder(
descriptor?: GPUCommandEncoderDescriptor
): GPUCommandEncoder;
/**
* Creates a {@link GPURenderBundleEncoder}.
* @param descriptor - Description of the {@link GPURenderBundleEncoder} to create.
*/
createRenderBundleEncoder(
descriptor: GPURenderBundleEncoderDescriptor
): GPURenderBundleEncoder;
/**
* Creates a {@link GPUQuerySet}.
* @param descriptor - Description of the {@link GPUQuerySet} to create.
*/
createQuerySet(
descriptor: GPUQuerySetDescriptor
): GPUQuerySet;
/**
* A promise which is created with the device, remains pending for the lifetime of the device,
* then resolves when the device is lost.
* This attribute is backed by an immutable internal slot of the same name, initially set
* to a new promise, and always returns its value.
*/
readonly lost: Promise<GPUDeviceLostInfo>;
/**
* Pushes a new GPU error scope onto the {@link GPUDevice#[[errorScopeStack]]} for `this`.
* @param filter - Which class of errors this error scope observes.
*/
pushErrorScope(
filter: GPUErrorFilter
): undefined;
/**
* Pops a GPU error scope off the {@link GPUDevice#[[errorScopeStack]]} for `this`
* and resolves to a {@link GPUError} if one was observed by the error scope.
*/
popErrorScope(): Promise<GPUError | null>;
/**
* An event handler IDL attribute for the {@link GPUDevice#uncapturederror} event type.
*/
onuncapturederror:
| ((
this: GPUDevice,
ev: GPUUncapturedErrorEvent
) => any)
| null;
}
declare var GPUDevice: {
prototype: GPUDevice;
new (): never;
};
interface GPUDeviceLostInfo {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUDeviceLostInfo";
readonly reason:
| GPUDeviceLostReason
| undefined;
readonly message: string;
}
declare var GPUDeviceLostInfo: {
prototype: GPUDeviceLostInfo;
new (): never;
};
interface GPUError {
/**
* A human-readable message providing information about the error that occurred.
* Note: This message is generally intended for application developers to debug their
* applications and capture information for debug reports, not to be surfaced to end-users.
* Note: User agents should not include potentially machine-parsable details in this message,
* such as free system memory on "out-of-memory" errors, or other details
* about the conditions under which memory was exhausted.
*/
readonly message: string;
}
declare var GPUError: {
prototype: GPUError;
new (): never;
};
interface GPUExternalTexture
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUExternalTexture";
/**
* Returns the value of {@link GPUExternalTexture#[[destroyed]]}, which indicates
* whether the texture has [$expire stale external textures|expired$] or not.
*/
readonly expired: boolean;
}
declare var GPUExternalTexture: {
prototype: GPUExternalTexture;
new (): never;
};
interface GPUOutOfMemoryError
extends GPUError {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUOutOfMemoryError";
}
declare var GPUOutOfMemoryError: {
prototype: GPUOutOfMemoryError;
new (
message: string
): GPUOutOfMemoryError;
};
interface GPUPipelineLayout
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUPipelineLayout";
}
declare var GPUPipelineLayout: {
prototype: GPUPipelineLayout;
new (): never;
};
interface GPUQuerySet
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUQuerySet";
/**
* Destroys the {@link GPUQuerySet}.
*/
destroy(): undefined;
/**
* The type of the queries managed by this {@link GPUQuerySet}.
*/
readonly type: GPUQueryType;
/**
* The number of queries managed by this {@link GPUQuerySet}.
*/
readonly count: GPUSize32;
}
declare var GPUQuerySet: {
prototype: GPUQuerySet;
new (): never;
};
interface GPUQueue
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUQueue";
/**
* Schedules the execution of the command buffers by the GPU on this queue.
* Submitted command buffers cannot be used again.
* `commandBuffers`:
*/
submit(
commandBuffers: Iterable<GPUCommandBuffer>
): undefined;
/**
* Returns a {@link Promise} that resolves once this queue finishes processing all the work submitted
* up to this moment.
*/
onSubmittedWorkDone(): Promise<undefined>;
/**
* Issues a write operation of the provided data into a {@link GPUBuffer}.
* @param buffer - The buffer to write to.
* @param bufferOffset - Offset in bytes into `buffer` to begin writing at.
* @param data - Data to write into `buffer`.
* @param dataOffset - Offset in into `data` to begin writing from. Given in elements if
* `data` is a `TypedArray` and bytes otherwise.
* @param size - Size of content to write from `data` to `buffer`. Given in elements if
* `data` is a `TypedArray` and bytes otherwise.
*/
writeBuffer(
buffer: GPUBuffer,
bufferOffset: GPUSize64,
data:
| BufferSource
| SharedArrayBuffer,
dataOffset?: GPUSize64,
size?: GPUSize64
): undefined;
/**
* Issues a write operation of the provided data into a {@link GPUTexture}.
* @param destination - The texture subresource and origin to write to.
* @param data - Data to write into `destination`.
* @param dataLayout - Layout of the content in `data`.
* @param size - Extents of the content to write from `data` to `destination`.
*/
writeTexture(
destination: GPUImageCopyTexture,
data:
| BufferSource
| SharedArrayBuffer,
dataLayout: GPUImageDataLayout,
size: GPUExtent3DStrict
): undefined;
/**
* Issues a copy operation of the contents of a platform image/canvas
* into the destination texture.
* This operation performs [[#color-space-conversions|color encoding]] into the destination
* encoding according to the parameters of {@link GPUImageCopyTextureTagged}.
* Copying into a `-srgb` texture results in the same texture bytes, not the same decoded
* values, as copying into the corresponding non-`-srgb` format.
* Thus, after a copy operation, sampling the destination texture has
* different results depending on whether its format is `-srgb`, all else unchanged.
* Issue: If an srgb-linear color space is added, explain here how it interacts.
* @param source - source image and origin to copy to `destination`.
* @param destination - The texture subresource and origin to write to, and its encoding metadata.
* @param copySize - Extents of the content to write from `source` to `destination`.
*/
copyExternalImageToTexture(
source: GPUImageCopyExternalImage,
destination: GPUImageCopyTextureTagged,
copySize: GPUExtent3DStrict
): undefined;
}
declare var GPUQueue: {
prototype: GPUQueue;
new (): never;
};
interface GPURenderBundle
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPURenderBundle";
}
declare var GPURenderBundle: {
prototype: GPURenderBundle;
new (): never;
};
interface GPURenderBundleEncoder
extends GPUObjectBase,
GPUCommandsMixin,
GPUDebugCommandsMixin,
GPUBindingCommandsMixin,
GPURenderCommandsMixin {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPURenderBundleEncoder";
/**
* Completes recording of the render bundle commands sequence.
* descriptor:
*/
finish(
descriptor?: GPURenderBundleDescriptor
): GPURenderBundle;
}
declare var GPURenderBundleEncoder: {
prototype: GPURenderBundleEncoder;
new (): never;
};
interface GPURenderPassEncoder
extends GPUObjectBase,
GPUCommandsMixin,
GPUDebugCommandsMixin,
GPUBindingCommandsMixin,
GPURenderCommandsMixin {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPURenderPassEncoder";
/**
* Sets the viewport used during the rasterization stage to linearly map from normalized device
* coordinates to viewport coordinates.
* @param x - Minimum X value of the viewport in pixels.
* @param y - Minimum Y value of the viewport in pixels.
* @param width - Width of the viewport in pixels.
* @param height - Height of the viewport in pixels.
* @param minDepth - Minimum depth value of the viewport.
* @param maxDepth - Maximum depth value of the viewport.
*/
setViewport(
x: number,
y: number,
width: number,
height: number,
minDepth: number,
maxDepth: number
): undefined;
/**
* Sets the scissor rectangle used during the rasterization stage.
* After transformation into viewport coordinates any fragments which fall outside the scissor
* rectangle will be discarded.
* @param x - Minimum X value of the scissor rectangle in pixels.
* @param y - Minimum Y value of the scissor rectangle in pixels.
* @param width - Width of the scissor rectangle in pixels.
* @param height - Height of the scissor rectangle in pixels.
*/
setScissorRect(
x: GPUIntegerCoordinate,
y: GPUIntegerCoordinate,
width: GPUIntegerCoordinate,
height: GPUIntegerCoordinate
): undefined;
/**
* Sets the constant blend color and alpha values used with {@link GPUBlendFactor#"constant"}
* and {@link GPUBlendFactor#"one-minus-constant"} {@link GPUBlendFactor}s.
* @param color - The color to use when blending.
*/
setBlendConstant(
color: GPUColor
): undefined;
/**
* Sets the {@link GPURenderPassEncoder#[[stencil_reference]]} value used during stencil tests with
* the {@link GPUStencilOperation#"replace"} {@link GPUStencilOperation}.
* @param reference - The new stencil reference value.
*/
setStencilReference(
reference: GPUStencilValue
): undefined;
/**
* @param queryIndex - The index of the query in the query set.
*/
beginOcclusionQuery(
queryIndex: GPUSize32
): undefined;
/**
*/
endOcclusionQuery(): undefined;
/**
* Executes the commands previously recorded into the given {@link GPURenderBundle}s as part of
* this render pass.
* When a {@link GPURenderBundle} is executed, it does not inherit the render pass's pipeline, bind
* groups, or vertex and index buffers. After a {@link GPURenderBundle} has executed, the render
* pass's pipeline, bind group, and vertex/index buffer state is cleared
* (to the initial, empty values).
* Note: The state is cleared, not restored to the previous state.
* This occurs even if zero {@link GPURenderBundle|GPURenderBundles} are executed.
* @param bundles - List of render bundles to execute.
*/
executeBundles(
bundles: Iterable<GPURenderBundle>
): undefined;
/**
* Completes recording of the render pass commands sequence.
*/
end(): undefined;
}
declare var GPURenderPassEncoder: {
prototype: GPURenderPassEncoder;
new (): never;
};
interface GPURenderPipeline
extends GPUObjectBase,
GPUPipelineBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPURenderPipeline";
}
declare var GPURenderPipeline: {
prototype: GPURenderPipeline;
new (): never;
};
interface GPUSampler
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUSampler";
}
declare var GPUSampler: {
prototype: GPUSampler;
new (): never;
};
interface GPUShaderModule
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUShaderModule";
/**
* Returns any messages generated during the {@link GPUShaderModule}'s compilation.
* The locations, order, and contents of messages are implementation-defined.
* In particular, messages may not be ordered by {@link GPUCompilationMessage#lineNum}.
*/
compilationInfo(): Promise<GPUCompilationInfo>;
}
declare var GPUShaderModule: {
prototype: GPUShaderModule;
new (): never;
};
type GPUSupportedFeatures =
ReadonlySet<string>;
interface GPUSupportedLimits {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUSupportedLimits";
readonly maxTextureDimension1D: number;
readonly maxTextureDimension2D: number;
readonly maxTextureDimension3D: number;
readonly maxTextureArrayLayers: number;
readonly maxBindGroups: number;
readonly maxDynamicUniformBuffersPerPipelineLayout: number;
readonly maxDynamicStorageBuffersPerPipelineLayout: number;
readonly maxSampledTexturesPerShaderStage: number;
readonly maxSamplersPerShaderStage: number;
readonly maxStorageBuffersPerShaderStage: number;
readonly maxStorageTexturesPerShaderStage: number;
readonly maxUniformBuffersPerShaderStage: number;
readonly maxUniformBufferBindingSize: number;
readonly maxStorageBufferBindingSize: number;
readonly minUniformBufferOffsetAlignment: number;
readonly minStorageBufferOffsetAlignment: number;
readonly maxVertexBuffers: number;
readonly maxVertexAttributes: number;
readonly maxVertexBufferArrayStride: number;
readonly maxInterStageShaderComponents: number;
readonly maxInterStageShaderVariables: number;
readonly maxColorAttachments: number;
readonly maxComputeWorkgroupStorageSize: number;
readonly maxComputeInvocationsPerWorkgroup: number;
readonly maxComputeWorkgroupSizeX: number;
readonly maxComputeWorkgroupSizeY: number;
readonly maxComputeWorkgroupSizeZ: number;
readonly maxComputeWorkgroupsPerDimension: number;
}
declare var GPUSupportedLimits: {
prototype: GPUSupportedLimits;
};
interface GPUTexture
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUTexture";
/**
* Creates a {@link GPUTextureView}.
* @param descriptor - Description of the {@link GPUTextureView} to create.
*/
createView(
descriptor?: GPUTextureViewDescriptor
): GPUTextureView;
/**
* Destroys the {@link GPUTexture}.
*/
destroy(): undefined;
/**
* The width of this {@link GPUTexture}.
*/
readonly width: GPUIntegerCoordinate;
/**
* The height of this {@link GPUTexture}.
*/
readonly height: GPUIntegerCoordinate;
/**
* The depth or layer count of this {@link GPUTexture}.
*/
readonly depthOrArrayLayers: GPUIntegerCoordinate;
/**
* The number of mip levels of this {@link GPUTexture}.
*/
readonly mipLevelCount: GPUIntegerCoordinate;
/**
* The number of sample count of this {@link GPUTexture}.
*/
readonly sampleCount: GPUSize32;
/**
* The dimension of the set of texel for each of this {@link GPUTexture}'s subresources.
*/
readonly dimension: GPUTextureDimension;
/**
* The format of this {@link GPUTexture}.
*/
readonly format: GPUTextureFormat;
/**
* The allowed usages for this {@link GPUTexture}.
*/
readonly usage: GPUTextureUsageFlags;
}
declare var GPUTexture: {
prototype: GPUTexture;
new (): never;
};
interface GPUTextureView
extends GPUObjectBase {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUTextureView";
}
declare var GPUTextureView: {
prototype: GPUTextureView;
new (): never;
};
interface GPUUncapturedErrorEvent
extends Event {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUUncapturedErrorEvent";
/**
* Object representing the error that was uncaptured.
* This has the same type as errors returned by {@link GPUDevice#popErrorScope}.
* This attribute is backed by an immutable internal slot of the same name, and
* always returns its value.
* Issue(whatwg/webidl#1077): This attribute should be `[SameObject]`.
* (If GPUError [becomes an interface](https://github.com/gpuweb/gpuweb/issues/1884) then
* we can do this without resolving the WebIDL issue.)
*/
readonly error: GPUError;
}
declare var GPUUncapturedErrorEvent: {
prototype: GPUUncapturedErrorEvent;
new (
type: string,
gpuUncapturedErrorEventInitDict: GPUUncapturedErrorEventInit
): GPUUncapturedErrorEvent;
};
interface GPUValidationError
extends GPUError {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUValidationError";
}
declare var GPUValidationError: {
prototype: GPUValidationError;
new (
message: string
): GPUValidationError;
};
interface Navigator
extends NavigatorGPU {}
interface WorkerNavigator
extends NavigatorGPU {}
interface GPUBufferUsage {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUBufferUsage";
readonly MAP_READ: GPUFlagsConstant;
readonly MAP_WRITE: GPUFlagsConstant;
readonly COPY_SRC: GPUFlagsConstant;
readonly COPY_DST: GPUFlagsConstant;
readonly INDEX: GPUFlagsConstant;
readonly VERTEX: GPUFlagsConstant;
readonly UNIFORM: GPUFlagsConstant;
readonly STORAGE: GPUFlagsConstant;
readonly INDIRECT: GPUFlagsConstant;
readonly QUERY_RESOLVE: GPUFlagsConstant;
}
declare var GPUBufferUsage: {
prototype: GPUBufferUsage;
readonly MAP_READ: GPUFlagsConstant;
readonly MAP_WRITE: GPUFlagsConstant;
readonly COPY_SRC: GPUFlagsConstant;
readonly COPY_DST: GPUFlagsConstant;
readonly INDEX: GPUFlagsConstant;
readonly VERTEX: GPUFlagsConstant;
readonly UNIFORM: GPUFlagsConstant;
readonly STORAGE: GPUFlagsConstant;
readonly INDIRECT: GPUFlagsConstant;
readonly QUERY_RESOLVE: GPUFlagsConstant;
};
interface GPUColorWrite {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUColorWrite";
readonly RED: GPUFlagsConstant;
readonly GREEN: GPUFlagsConstant;
readonly BLUE: GPUFlagsConstant;
readonly ALPHA: GPUFlagsConstant;
readonly ALL: GPUFlagsConstant;
}
declare var GPUColorWrite: {
prototype: GPUColorWrite;
readonly RED: GPUFlagsConstant;
readonly GREEN: GPUFlagsConstant;
readonly BLUE: GPUFlagsConstant;
readonly ALPHA: GPUFlagsConstant;
readonly ALL: GPUFlagsConstant;
};
interface GPUMapMode {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUMapMode";
readonly READ: GPUFlagsConstant;
readonly WRITE: GPUFlagsConstant;
}
declare var GPUMapMode: {
prototype: GPUMapMode;
new (): never;
readonly READ: GPUFlagsConstant;
readonly WRITE: GPUFlagsConstant;
};
interface GPUShaderStage {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUShaderStage";
readonly VERTEX: GPUFlagsConstant;
readonly FRAGMENT: GPUFlagsConstant;
readonly COMPUTE: GPUFlagsConstant;
}
declare var GPUShaderStage: {
prototype: GPUShaderStage;
readonly VERTEX: GPUFlagsConstant;
readonly FRAGMENT: GPUFlagsConstant;
readonly COMPUTE: GPUFlagsConstant;
};
interface GPUTextureUsage {
/**
* Nominal type branding.
* https://github.com/microsoft/TypeScript/pull/33038
* @internal
*/
readonly __brand: "GPUTextureUsage";
readonly COPY_SRC: GPUFlagsConstant;
readonly COPY_DST: GPUFlagsConstant;
readonly TEXTURE_BINDING: GPUFlagsConstant;
readonly STORAGE_BINDING: GPUFlagsConstant;
readonly RENDER_ATTACHMENT: GPUFlagsConstant;
}
declare var GPUTextureUsage: {
prototype: GPUTextureUsage;
readonly COPY_SRC: GPUFlagsConstant;
readonly COPY_DST: GPUFlagsConstant;
readonly TEXTURE_BINDING: GPUFlagsConstant;
readonly STORAGE_BINDING: GPUFlagsConstant;
readonly RENDER_ATTACHMENT: GPUFlagsConstant;
};