@vladmandic/face-api

Version:

FaceAPI: AI-powered Face Detection & Rotation Tracking, Face Description & Recognition, Age & Gender & Emotion Prediction for Browser and NodeJS using TensorFlow/JS

vladmandic.github.io/face-api/demo/webcam.html

vladmandic/face-api

1,555 lines (1,448 loc) • 95.4 kB

TypeScript

/* 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. *  */ 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} × * {@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. *  */ 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} > `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. *  * @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: GP