mirror of
https://github.com/denoland/deno.git
synced 2024-12-20 22:34:46 -05:00
1379 lines
31 KiB
TypeScript
1379 lines
31 KiB
TypeScript
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
|
|
|
// deno-lint-ignore-file no-explicit-any no-empty-interface
|
|
|
|
/// <reference no-default-lib="true" />
|
|
/// <reference lib="esnext" />
|
|
|
|
/** @category GPU */
|
|
interface GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUObjectDescriptorBase {
|
|
label?: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUSupportedLimits {
|
|
maxTextureDimension1D?: number;
|
|
maxTextureDimension2D?: number;
|
|
maxTextureDimension3D?: number;
|
|
maxTextureArrayLayers?: number;
|
|
maxBindGroups?: number;
|
|
maxBindingsPerBindGroup?: number;
|
|
maxDynamicUniformBuffersPerPipelineLayout?: number;
|
|
maxDynamicStorageBuffersPerPipelineLayout?: number;
|
|
maxSampledTexturesPerShaderStage?: number;
|
|
maxSamplersPerShaderStage?: number;
|
|
maxStorageBuffersPerShaderStage?: number;
|
|
maxStorageTexturesPerShaderStage?: number;
|
|
maxUniformBuffersPerShaderStage?: number;
|
|
maxUniformBufferBindingSize?: number;
|
|
maxStorageBufferBindingSize?: number;
|
|
minUniformBufferOffsetAlignment?: number;
|
|
minStorageBufferOffsetAlignment?: number;
|
|
maxVertexBuffers?: number;
|
|
maxBufferSize?: number;
|
|
maxVertexAttributes?: number;
|
|
maxVertexBufferArrayStride?: number;
|
|
maxInterStageShaderComponents?: number;
|
|
maxColorAttachments?: number;
|
|
maxColorAttachmentBytesPerSample?: number;
|
|
maxComputeWorkgroupStorageSize?: number;
|
|
maxComputeInvocationsPerWorkgroup?: number;
|
|
maxComputeWorkgroupSizeX?: number;
|
|
maxComputeWorkgroupSizeY?: number;
|
|
maxComputeWorkgroupSizeZ?: number;
|
|
maxComputeWorkgroupsPerDimension?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUSupportedFeatures {
|
|
forEach(
|
|
callbackfn: (
|
|
value: GPUFeatureName,
|
|
value2: GPUFeatureName,
|
|
set: Set<GPUFeatureName>,
|
|
) => void,
|
|
thisArg?: any,
|
|
): void;
|
|
has(value: GPUFeatureName): boolean;
|
|
size: number;
|
|
[Symbol.iterator](): IterableIterator<GPUFeatureName>;
|
|
entries(): IterableIterator<[GPUFeatureName, GPUFeatureName]>;
|
|
keys(): IterableIterator<GPUFeatureName>;
|
|
values(): IterableIterator<GPUFeatureName>;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUAdapterInfo {
|
|
readonly vendor: string;
|
|
readonly architecture: string;
|
|
readonly device: string;
|
|
readonly description: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPU {
|
|
requestAdapter(
|
|
options?: GPURequestAdapterOptions,
|
|
): Promise<GPUAdapter | null>;
|
|
getPreferredCanvasFormat(): GPUTextureFormat;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURequestAdapterOptions {
|
|
powerPreference?: GPUPowerPreference;
|
|
forceFallbackAdapter?: boolean;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUPowerPreference = "low-power" | "high-performance";
|
|
|
|
/** @category GPU */
|
|
declare class GPUAdapter {
|
|
readonly features: GPUSupportedFeatures;
|
|
readonly limits: GPUSupportedLimits;
|
|
readonly info: GPUAdapterInfo;
|
|
readonly isFallbackAdapter: boolean;
|
|
|
|
requestDevice(descriptor?: GPUDeviceDescriptor): Promise<GPUDevice>;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUDeviceDescriptor extends GPUObjectDescriptorBase {
|
|
requiredFeatures?: GPUFeatureName[];
|
|
requiredLimits?: Record<string, number>;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUFeatureName =
|
|
| "depth-clip-control"
|
|
| "depth32float-stencil8"
|
|
| "pipeline-statistics-query"
|
|
| "texture-compression-bc"
|
|
| "texture-compression-etc2"
|
|
| "texture-compression-astc"
|
|
| "timestamp-query"
|
|
| "indirect-first-instance"
|
|
| "shader-f16"
|
|
| "rg11b10ufloat-renderable"
|
|
| "bgra8unorm-storage"
|
|
| "float32-filterable"
|
|
// extended from spec
|
|
| "mappable-primary-buffers"
|
|
| "sampled-texture-binding-array"
|
|
| "sampled-texture-array-dynamic-indexing"
|
|
| "sampled-texture-array-non-uniform-indexing"
|
|
| "unsized-binding-array"
|
|
| "multi-draw-indirect"
|
|
| "multi-draw-indirect-count"
|
|
| "push-constants"
|
|
| "address-mode-clamp-to-border"
|
|
| "texture-adapter-specific-format-features"
|
|
| "shader-float64"
|
|
| "vertex-attribute-64bit";
|
|
|
|
/** @category GPU */
|
|
declare class GPUDevice extends EventTarget implements GPUObjectBase {
|
|
label: string;
|
|
|
|
readonly lost: Promise<GPUDeviceLostInfo>;
|
|
pushErrorScope(filter: GPUErrorFilter): undefined;
|
|
popErrorScope(): Promise<GPUError | null>;
|
|
|
|
readonly features: GPUSupportedFeatures;
|
|
readonly limits: GPUSupportedLimits;
|
|
readonly queue: GPUQueue;
|
|
|
|
destroy(): undefined;
|
|
|
|
createBuffer(descriptor: GPUBufferDescriptor): GPUBuffer;
|
|
createTexture(descriptor: GPUTextureDescriptor): GPUTexture;
|
|
createSampler(descriptor?: GPUSamplerDescriptor): GPUSampler;
|
|
|
|
createBindGroupLayout(
|
|
descriptor: GPUBindGroupLayoutDescriptor,
|
|
): GPUBindGroupLayout;
|
|
createPipelineLayout(
|
|
descriptor: GPUPipelineLayoutDescriptor,
|
|
): GPUPipelineLayout;
|
|
createBindGroup(descriptor: GPUBindGroupDescriptor): GPUBindGroup;
|
|
|
|
createShaderModule(descriptor: GPUShaderModuleDescriptor): GPUShaderModule;
|
|
createComputePipeline(
|
|
descriptor: GPUComputePipelineDescriptor,
|
|
): GPUComputePipeline;
|
|
createRenderPipeline(
|
|
descriptor: GPURenderPipelineDescriptor,
|
|
): GPURenderPipeline;
|
|
createComputePipelineAsync(
|
|
descriptor: GPUComputePipelineDescriptor,
|
|
): Promise<GPUComputePipeline>;
|
|
createRenderPipelineAsync(
|
|
descriptor: GPURenderPipelineDescriptor,
|
|
): Promise<GPURenderPipeline>;
|
|
|
|
createCommandEncoder(
|
|
descriptor?: GPUCommandEncoderDescriptor,
|
|
): GPUCommandEncoder;
|
|
createRenderBundleEncoder(
|
|
descriptor: GPURenderBundleEncoderDescriptor,
|
|
): GPURenderBundleEncoder;
|
|
|
|
createQuerySet(descriptor: GPUQuerySetDescriptor): GPUQuerySet;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUBuffer implements GPUObjectBase {
|
|
label: string;
|
|
|
|
readonly size: number;
|
|
readonly usage: GPUFlagsConstant;
|
|
readonly mapState: GPUBufferMapState;
|
|
|
|
mapAsync(
|
|
mode: GPUMapModeFlags,
|
|
offset?: number,
|
|
size?: number,
|
|
): Promise<undefined>;
|
|
getMappedRange(offset?: number, size?: number): ArrayBuffer;
|
|
unmap(): undefined;
|
|
|
|
destroy(): undefined;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUBufferMapState = "unmapped" | "pending" | "mapped";
|
|
|
|
/** @category GPU */
|
|
interface GPUBufferDescriptor extends GPUObjectDescriptorBase {
|
|
size: number;
|
|
usage: GPUBufferUsageFlags;
|
|
mappedAtCreation?: boolean;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUBufferUsageFlags = number;
|
|
|
|
/** @category GPU */
|
|
type GPUFlagsConstant = number;
|
|
|
|
/** @category GPU */
|
|
declare class GPUBufferUsage {
|
|
static MAP_READ: 0x0001;
|
|
static MAP_WRITE: 0x0002;
|
|
static COPY_SRC: 0x0004;
|
|
static COPY_DST: 0x0008;
|
|
static INDEX: 0x0010;
|
|
static VERTEX: 0x0020;
|
|
static UNIFORM: 0x0040;
|
|
static STORAGE: 0x0080;
|
|
static INDIRECT: 0x0100;
|
|
static QUERY_RESOLVE: 0x0200;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUMapModeFlags = number;
|
|
|
|
/** @category GPU */
|
|
declare class GPUMapMode {
|
|
static READ: 0x0001;
|
|
static WRITE: 0x0002;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUTexture implements GPUObjectBase {
|
|
label: string;
|
|
|
|
createView(descriptor?: GPUTextureViewDescriptor): GPUTextureView;
|
|
destroy(): undefined;
|
|
|
|
readonly width: number;
|
|
readonly height: number;
|
|
readonly depthOrArrayLayers: number;
|
|
readonly mipLevelCount: number;
|
|
readonly sampleCount: number;
|
|
readonly dimension: GPUTextureDimension;
|
|
readonly format: GPUTextureFormat;
|
|
readonly usage: GPUFlagsConstant;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUTextureDescriptor extends GPUObjectDescriptorBase {
|
|
size: GPUExtent3D;
|
|
mipLevelCount?: number;
|
|
sampleCount?: number;
|
|
dimension?: GPUTextureDimension;
|
|
format: GPUTextureFormat;
|
|
usage: GPUTextureUsageFlags;
|
|
viewFormats?: GPUTextureFormat[];
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUTextureDimension = "1d" | "2d" | "3d";
|
|
|
|
/** @category GPU */
|
|
type GPUTextureUsageFlags = number;
|
|
|
|
/** @category GPU */
|
|
declare class GPUTextureUsage {
|
|
static COPY_SRC: 0x01;
|
|
static COPY_DST: 0x02;
|
|
static TEXTURE_BINDING: 0x04;
|
|
static STORAGE_BINDING: 0x08;
|
|
static RENDER_ATTACHMENT: 0x10;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUTextureView implements GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUTextureViewDescriptor extends GPUObjectDescriptorBase {
|
|
format?: GPUTextureFormat;
|
|
dimension?: GPUTextureViewDimension;
|
|
aspect?: GPUTextureAspect;
|
|
baseMipLevel?: number;
|
|
mipLevelCount?: number;
|
|
baseArrayLayer?: number;
|
|
arrayLayerCount?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUTextureViewDimension =
|
|
| "1d"
|
|
| "2d"
|
|
| "2d-array"
|
|
| "cube"
|
|
| "cube-array"
|
|
| "3d";
|
|
|
|
/** @category GPU */
|
|
type GPUTextureAspect = "all" | "stencil-only" | "depth-only";
|
|
|
|
/** @category GPU */
|
|
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"
|
|
| "rgb10a2uint"
|
|
| "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";
|
|
|
|
/** @category GPU */
|
|
declare class GPUSampler implements GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUSamplerDescriptor extends GPUObjectDescriptorBase {
|
|
addressModeU?: GPUAddressMode;
|
|
addressModeV?: GPUAddressMode;
|
|
addressModeW?: GPUAddressMode;
|
|
magFilter?: GPUFilterMode;
|
|
minFilter?: GPUFilterMode;
|
|
mipmapFilter?: GPUMipmapFilterMode;
|
|
lodMinClamp?: number;
|
|
lodMaxClamp?: number;
|
|
compare?: GPUCompareFunction;
|
|
maxAnisotropy?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUAddressMode = "clamp-to-edge" | "repeat" | "mirror-repeat";
|
|
|
|
/** @category GPU */
|
|
type GPUFilterMode = "nearest" | "linear";
|
|
|
|
/** @category GPU */
|
|
type GPUMipmapFilterMode = "nearest" | "linear";
|
|
|
|
/** @category GPU */
|
|
type GPUCompareFunction =
|
|
| "never"
|
|
| "less"
|
|
| "equal"
|
|
| "less-equal"
|
|
| "greater"
|
|
| "not-equal"
|
|
| "greater-equal"
|
|
| "always";
|
|
|
|
/** @category GPU */
|
|
declare class GPUBindGroupLayout implements GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUBindGroupLayoutDescriptor extends GPUObjectDescriptorBase {
|
|
entries: GPUBindGroupLayoutEntry[];
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUBindGroupLayoutEntry {
|
|
binding: number;
|
|
visibility: GPUShaderStageFlags;
|
|
|
|
buffer?: GPUBufferBindingLayout;
|
|
sampler?: GPUSamplerBindingLayout;
|
|
texture?: GPUTextureBindingLayout;
|
|
storageTexture?: GPUStorageTextureBindingLayout;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUShaderStageFlags = number;
|
|
|
|
/** @category GPU */
|
|
declare class GPUShaderStage {
|
|
static VERTEX: 0x1;
|
|
static FRAGMENT: 0x2;
|
|
static COMPUTE: 0x4;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUBufferBindingLayout {
|
|
type?: GPUBufferBindingType;
|
|
hasDynamicOffset?: boolean;
|
|
minBindingSize?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUBufferBindingType = "uniform" | "storage" | "read-only-storage";
|
|
|
|
/** @category GPU */
|
|
interface GPUSamplerBindingLayout {
|
|
type?: GPUSamplerBindingType;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUSamplerBindingType =
|
|
| "filtering"
|
|
| "non-filtering"
|
|
| "comparison";
|
|
|
|
/** @category GPU */
|
|
interface GPUTextureBindingLayout {
|
|
sampleType?: GPUTextureSampleType;
|
|
viewDimension?: GPUTextureViewDimension;
|
|
multisampled?: boolean;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUTextureSampleType =
|
|
| "float"
|
|
| "unfilterable-float"
|
|
| "depth"
|
|
| "sint"
|
|
| "uint";
|
|
|
|
/** @category GPU */
|
|
type GPUStorageTextureAccess =
|
|
| "write-only"
|
|
| "read-only"
|
|
| "read-write";
|
|
|
|
/** @category GPU */
|
|
interface GPUStorageTextureBindingLayout {
|
|
access: GPUStorageTextureAccess;
|
|
format: GPUTextureFormat;
|
|
viewDimension?: GPUTextureViewDimension;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUBindGroup implements GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUBindGroupDescriptor extends GPUObjectDescriptorBase {
|
|
layout: GPUBindGroupLayout;
|
|
entries: GPUBindGroupEntry[];
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUBindingResource =
|
|
| GPUSampler
|
|
| GPUTextureView
|
|
| GPUBufferBinding;
|
|
|
|
/** @category GPU */
|
|
interface GPUBindGroupEntry {
|
|
binding: number;
|
|
resource: GPUBindingResource;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUBufferBinding {
|
|
buffer: GPUBuffer;
|
|
offset?: number;
|
|
size?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUPipelineLayout implements GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUPipelineLayoutDescriptor extends GPUObjectDescriptorBase {
|
|
bindGroupLayouts: GPUBindGroupLayout[];
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUCompilationMessageType = "error" | "warning" | "info";
|
|
|
|
/** @category GPU */
|
|
interface GPUCompilationMessage {
|
|
readonly message: string;
|
|
readonly type: GPUCompilationMessageType;
|
|
readonly lineNum: number;
|
|
readonly linePos: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUCompilationInfo {
|
|
readonly messages: ReadonlyArray<GPUCompilationMessage>;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUPipelineError extends DOMException {
|
|
constructor(message?: string, options?: GPUPipelineErrorInit);
|
|
|
|
readonly reason: GPUPipelineErrorReason;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUPipelineErrorInit {
|
|
reason: GPUPipelineErrorReason;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUPipelineErrorReason = "validation" | "internal";
|
|
|
|
/** @category GPU */
|
|
declare class GPUShaderModule implements GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUShaderModuleDescriptor extends GPUObjectDescriptorBase {
|
|
code: string;
|
|
sourceMap?: any;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUAutoLayoutMode = "auto";
|
|
|
|
/** @category GPU */
|
|
interface GPUPipelineDescriptorBase extends GPUObjectDescriptorBase {
|
|
layout: GPUPipelineLayout | GPUAutoLayoutMode;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUPipelineBase {
|
|
getBindGroupLayout(index: number): GPUBindGroupLayout;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUProgrammableStage {
|
|
module: GPUShaderModule;
|
|
entryPoint?: string;
|
|
constants?: Record<string, number>;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUComputePipeline implements GPUObjectBase, GPUPipelineBase {
|
|
label: string;
|
|
|
|
getBindGroupLayout(index: number): GPUBindGroupLayout;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUComputePipelineDescriptor extends GPUPipelineDescriptorBase {
|
|
compute: GPUProgrammableStage;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPURenderPipeline implements GPUObjectBase, GPUPipelineBase {
|
|
label: string;
|
|
|
|
getBindGroupLayout(index: number): GPUBindGroupLayout;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderPipelineDescriptor extends GPUPipelineDescriptorBase {
|
|
vertex: GPUVertexState;
|
|
primitive?: GPUPrimitiveState;
|
|
depthStencil?: GPUDepthStencilState;
|
|
multisample?: GPUMultisampleState;
|
|
fragment?: GPUFragmentState;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUPrimitiveState {
|
|
topology?: GPUPrimitiveTopology;
|
|
stripIndexFormat?: GPUIndexFormat;
|
|
frontFace?: GPUFrontFace;
|
|
cullMode?: GPUCullMode;
|
|
unclippedDepth?: boolean;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUPrimitiveTopology =
|
|
| "point-list"
|
|
| "line-list"
|
|
| "line-strip"
|
|
| "triangle-list"
|
|
| "triangle-strip";
|
|
|
|
/** @category GPU */
|
|
type GPUFrontFace = "ccw" | "cw";
|
|
|
|
/** @category GPU */
|
|
type GPUCullMode = "none" | "front" | "back";
|
|
|
|
/** @category GPU */
|
|
interface GPUMultisampleState {
|
|
count?: number;
|
|
mask?: number;
|
|
alphaToCoverageEnabled?: boolean;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUFragmentState extends GPUProgrammableStage {
|
|
targets: (GPUColorTargetState | null)[];
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUColorTargetState {
|
|
format: GPUTextureFormat;
|
|
|
|
blend?: GPUBlendState;
|
|
writeMask?: GPUColorWriteFlags;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUBlendState {
|
|
color: GPUBlendComponent;
|
|
alpha: GPUBlendComponent;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUColorWriteFlags = number;
|
|
|
|
/** @category GPU */
|
|
declare class GPUColorWrite {
|
|
static RED: 0x1;
|
|
static GREEN: 0x2;
|
|
static BLUE: 0x4;
|
|
static ALPHA: 0x8;
|
|
static ALL: 0xF;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUBlendComponent {
|
|
operation?: GPUBlendOperation;
|
|
srcFactor?: GPUBlendFactor;
|
|
dstFactor?: GPUBlendFactor;
|
|
}
|
|
|
|
/** @category GPU */
|
|
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";
|
|
|
|
/** @category GPU */
|
|
type GPUBlendOperation =
|
|
| "add"
|
|
| "subtract"
|
|
| "reverse-subtract"
|
|
| "min"
|
|
| "max";
|
|
|
|
/** @category GPU */
|
|
interface GPUDepthStencilState {
|
|
format: GPUTextureFormat;
|
|
|
|
depthWriteEnabled: boolean;
|
|
depthCompare: GPUCompareFunction;
|
|
|
|
stencilFront?: GPUStencilFaceState;
|
|
stencilBack?: GPUStencilFaceState;
|
|
|
|
stencilReadMask?: number;
|
|
stencilWriteMask?: number;
|
|
|
|
depthBias?: number;
|
|
depthBiasSlopeScale?: number;
|
|
depthBiasClamp?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUStencilFaceState {
|
|
compare?: GPUCompareFunction;
|
|
failOp?: GPUStencilOperation;
|
|
depthFailOp?: GPUStencilOperation;
|
|
passOp?: GPUStencilOperation;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUStencilOperation =
|
|
| "keep"
|
|
| "zero"
|
|
| "replace"
|
|
| "invert"
|
|
| "increment-clamp"
|
|
| "decrement-clamp"
|
|
| "increment-wrap"
|
|
| "decrement-wrap";
|
|
|
|
/** @category GPU */
|
|
type GPUIndexFormat = "uint16" | "uint32";
|
|
|
|
/** @category GPU */
|
|
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"
|
|
| "unorm10-10-10-2";
|
|
|
|
/** @category GPU */
|
|
type GPUVertexStepMode = "vertex" | "instance";
|
|
|
|
/** @category GPU */
|
|
interface GPUVertexState extends GPUProgrammableStage {
|
|
buffers?: (GPUVertexBufferLayout | null)[];
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUVertexBufferLayout {
|
|
arrayStride: number;
|
|
stepMode?: GPUVertexStepMode;
|
|
attributes: GPUVertexAttribute[];
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUVertexAttribute {
|
|
format: GPUVertexFormat;
|
|
offset: number;
|
|
|
|
shaderLocation: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUImageDataLayout {
|
|
offset?: number;
|
|
bytesPerRow?: number;
|
|
rowsPerImage?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUCommandBuffer implements GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUCommandBufferDescriptor extends GPUObjectDescriptorBase {}
|
|
|
|
/** @category GPU */
|
|
declare class GPUCommandEncoder implements GPUObjectBase {
|
|
label: string;
|
|
|
|
beginRenderPass(descriptor: GPURenderPassDescriptor): GPURenderPassEncoder;
|
|
beginComputePass(
|
|
descriptor?: GPUComputePassDescriptor,
|
|
): GPUComputePassEncoder;
|
|
|
|
copyBufferToBuffer(
|
|
source: GPUBuffer,
|
|
sourceOffset: number,
|
|
destination: GPUBuffer,
|
|
destinationOffset: number,
|
|
size: number,
|
|
): undefined;
|
|
|
|
copyBufferToTexture(
|
|
source: GPUImageCopyBuffer,
|
|
destination: GPUImageCopyTexture,
|
|
copySize: GPUExtent3D,
|
|
): undefined;
|
|
|
|
copyTextureToBuffer(
|
|
source: GPUImageCopyTexture,
|
|
destination: GPUImageCopyBuffer,
|
|
copySize: GPUExtent3D,
|
|
): undefined;
|
|
|
|
copyTextureToTexture(
|
|
source: GPUImageCopyTexture,
|
|
destination: GPUImageCopyTexture,
|
|
copySize: GPUExtent3D,
|
|
): undefined;
|
|
|
|
clearBuffer(
|
|
destination: GPUBuffer,
|
|
destinationOffset?: number,
|
|
size?: number,
|
|
): undefined;
|
|
|
|
pushDebugGroup(groupLabel: string): undefined;
|
|
popDebugGroup(): undefined;
|
|
insertDebugMarker(markerLabel: string): undefined;
|
|
|
|
writeTimestamp(querySet: GPUQuerySet, queryIndex: number): undefined;
|
|
|
|
resolveQuerySet(
|
|
querySet: GPUQuerySet,
|
|
firstQuery: number,
|
|
queryCount: number,
|
|
destination: GPUBuffer,
|
|
destinationOffset: number,
|
|
): undefined;
|
|
|
|
finish(descriptor?: GPUCommandBufferDescriptor): GPUCommandBuffer;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUCommandEncoderDescriptor extends GPUObjectDescriptorBase {}
|
|
|
|
/** @category GPU */
|
|
interface GPUImageCopyBuffer extends GPUImageDataLayout {
|
|
buffer: GPUBuffer;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUImageCopyTexture {
|
|
texture: GPUTexture;
|
|
mipLevel?: number;
|
|
origin?: GPUOrigin3D;
|
|
aspect?: GPUTextureAspect;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUProgrammablePassEncoder {
|
|
setBindGroup(
|
|
index: number,
|
|
bindGroup: GPUBindGroup,
|
|
dynamicOffsets?: number[],
|
|
): undefined;
|
|
|
|
setBindGroup(
|
|
index: number,
|
|
bindGroup: GPUBindGroup,
|
|
dynamicOffsetsData: Uint32Array,
|
|
dynamicOffsetsDataStart: number,
|
|
dynamicOffsetsDataLength: number,
|
|
): undefined;
|
|
|
|
pushDebugGroup(groupLabel: string): undefined;
|
|
popDebugGroup(): undefined;
|
|
insertDebugMarker(markerLabel: string): undefined;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUComputePassEncoder
|
|
implements GPUObjectBase, GPUProgrammablePassEncoder {
|
|
label: string;
|
|
setBindGroup(
|
|
index: number,
|
|
bindGroup: GPUBindGroup,
|
|
dynamicOffsets?: number[],
|
|
): undefined;
|
|
setBindGroup(
|
|
index: number,
|
|
bindGroup: GPUBindGroup,
|
|
dynamicOffsetsData: Uint32Array,
|
|
dynamicOffsetsDataStart: number,
|
|
dynamicOffsetsDataLength: number,
|
|
): undefined;
|
|
pushDebugGroup(groupLabel: string): undefined;
|
|
popDebugGroup(): undefined;
|
|
insertDebugMarker(markerLabel: string): undefined;
|
|
setPipeline(pipeline: GPUComputePipeline): undefined;
|
|
dispatchWorkgroups(x: number, y?: number, z?: number): undefined;
|
|
dispatchWorkgroupsIndirect(
|
|
indirectBuffer: GPUBuffer,
|
|
indirectOffset: number,
|
|
): undefined;
|
|
|
|
end(): undefined;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUComputePassTimestampWrites {
|
|
querySet: GPUQuerySet;
|
|
beginningOfPassWriteIndex?: number;
|
|
endOfPassWriteIndex?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUComputePassDescriptor extends GPUObjectDescriptorBase {
|
|
timestampWrites?: GPUComputePassTimestampWrites;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderEncoderBase {
|
|
setPipeline(pipeline: GPURenderPipeline): undefined;
|
|
|
|
setIndexBuffer(
|
|
buffer: GPUBuffer,
|
|
indexFormat: GPUIndexFormat,
|
|
offset?: number,
|
|
size?: number,
|
|
): undefined;
|
|
setVertexBuffer(
|
|
slot: number,
|
|
buffer: GPUBuffer,
|
|
offset?: number,
|
|
size?: number,
|
|
): undefined;
|
|
|
|
draw(
|
|
vertexCount: number,
|
|
instanceCount?: number,
|
|
firstVertex?: number,
|
|
firstInstance?: number,
|
|
): undefined;
|
|
drawIndexed(
|
|
indexCount: number,
|
|
instanceCount?: number,
|
|
firstIndex?: number,
|
|
baseVertex?: number,
|
|
firstInstance?: number,
|
|
): undefined;
|
|
|
|
drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): undefined;
|
|
drawIndexedIndirect(
|
|
indirectBuffer: GPUBuffer,
|
|
indirectOffset: number,
|
|
): undefined;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPURenderPassEncoder
|
|
implements GPUObjectBase, GPUProgrammablePassEncoder, GPURenderEncoderBase {
|
|
label: string;
|
|
setBindGroup(
|
|
index: number,
|
|
bindGroup: GPUBindGroup,
|
|
dynamicOffsets?: number[],
|
|
): undefined;
|
|
setBindGroup(
|
|
index: number,
|
|
bindGroup: GPUBindGroup,
|
|
dynamicOffsetsData: Uint32Array,
|
|
dynamicOffsetsDataStart: number,
|
|
dynamicOffsetsDataLength: number,
|
|
): undefined;
|
|
pushDebugGroup(groupLabel: string): undefined;
|
|
popDebugGroup(): undefined;
|
|
insertDebugMarker(markerLabel: string): undefined;
|
|
setPipeline(pipeline: GPURenderPipeline): undefined;
|
|
setIndexBuffer(
|
|
buffer: GPUBuffer,
|
|
indexFormat: GPUIndexFormat,
|
|
offset?: number,
|
|
size?: number,
|
|
): undefined;
|
|
setVertexBuffer(
|
|
slot: number,
|
|
buffer: GPUBuffer,
|
|
offset?: number,
|
|
size?: number,
|
|
): undefined;
|
|
draw(
|
|
vertexCount: number,
|
|
instanceCount?: number,
|
|
firstVertex?: number,
|
|
firstInstance?: number,
|
|
): undefined;
|
|
drawIndexed(
|
|
indexCount: number,
|
|
instanceCount?: number,
|
|
firstIndex?: number,
|
|
baseVertex?: number,
|
|
firstInstance?: number,
|
|
): undefined;
|
|
drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): undefined;
|
|
drawIndexedIndirect(
|
|
indirectBuffer: GPUBuffer,
|
|
indirectOffset: number,
|
|
): undefined;
|
|
|
|
setViewport(
|
|
x: number,
|
|
y: number,
|
|
width: number,
|
|
height: number,
|
|
minDepth: number,
|
|
maxDepth: number,
|
|
): undefined;
|
|
|
|
setScissorRect(
|
|
x: number,
|
|
y: number,
|
|
width: number,
|
|
height: number,
|
|
): undefined;
|
|
|
|
setBlendConstant(color: GPUColor): undefined;
|
|
setStencilReference(reference: number): undefined;
|
|
|
|
beginOcclusionQuery(queryIndex: number): undefined;
|
|
endOcclusionQuery(): undefined;
|
|
|
|
executeBundles(bundles: GPURenderBundle[]): undefined;
|
|
end(): undefined;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderPassTimestampWrites {
|
|
querySet: GPUQuerySet;
|
|
beginningOfPassWriteIndex?: number;
|
|
endOfPassWriteIndex?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderPassDescriptor extends GPUObjectDescriptorBase {
|
|
colorAttachments: (GPURenderPassColorAttachment | null)[];
|
|
depthStencilAttachment?: GPURenderPassDepthStencilAttachment;
|
|
occlusionQuerySet?: GPUQuerySet;
|
|
timestampWrites?: GPURenderPassTimestampWrites;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderPassColorAttachment {
|
|
view: GPUTextureView;
|
|
resolveTarget?: GPUTextureView;
|
|
|
|
clearValue?: GPUColor;
|
|
loadOp: GPULoadOp;
|
|
storeOp: GPUStoreOp;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderPassDepthStencilAttachment {
|
|
view: GPUTextureView;
|
|
|
|
depthClearValue?: number;
|
|
depthLoadOp?: GPULoadOp;
|
|
depthStoreOp?: GPUStoreOp;
|
|
depthReadOnly?: boolean;
|
|
|
|
stencilClearValue?: number;
|
|
stencilLoadOp?: GPULoadOp;
|
|
stencilStoreOp?: GPUStoreOp;
|
|
stencilReadOnly?: boolean;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPULoadOp = "load" | "clear";
|
|
|
|
/** @category GPU */
|
|
type GPUStoreOp = "store" | "discard";
|
|
|
|
/** @category GPU */
|
|
declare class GPURenderBundle implements GPUObjectBase {
|
|
label: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderBundleDescriptor extends GPUObjectDescriptorBase {}
|
|
|
|
/** @category GPU */
|
|
declare class GPURenderBundleEncoder
|
|
implements GPUObjectBase, GPUProgrammablePassEncoder, GPURenderEncoderBase {
|
|
label: string;
|
|
draw(
|
|
vertexCount: number,
|
|
instanceCount?: number,
|
|
firstVertex?: number,
|
|
firstInstance?: number,
|
|
): undefined;
|
|
drawIndexed(
|
|
indexCount: number,
|
|
instanceCount?: number,
|
|
firstIndex?: number,
|
|
baseVertex?: number,
|
|
firstInstance?: number,
|
|
): undefined;
|
|
drawIndexedIndirect(
|
|
indirectBuffer: GPUBuffer,
|
|
indirectOffset: number,
|
|
): undefined;
|
|
drawIndirect(indirectBuffer: GPUBuffer, indirectOffset: number): undefined;
|
|
insertDebugMarker(markerLabel: string): undefined;
|
|
popDebugGroup(): undefined;
|
|
pushDebugGroup(groupLabel: string): undefined;
|
|
setBindGroup(
|
|
index: number,
|
|
bindGroup: GPUBindGroup,
|
|
dynamicOffsets?: number[],
|
|
): undefined;
|
|
setBindGroup(
|
|
index: number,
|
|
bindGroup: GPUBindGroup,
|
|
dynamicOffsetsData: Uint32Array,
|
|
dynamicOffsetsDataStart: number,
|
|
dynamicOffsetsDataLength: number,
|
|
): undefined;
|
|
setIndexBuffer(
|
|
buffer: GPUBuffer,
|
|
indexFormat: GPUIndexFormat,
|
|
offset?: number,
|
|
size?: number,
|
|
): undefined;
|
|
setPipeline(pipeline: GPURenderPipeline): undefined;
|
|
setVertexBuffer(
|
|
slot: number,
|
|
buffer: GPUBuffer,
|
|
offset?: number,
|
|
size?: number,
|
|
): undefined;
|
|
|
|
finish(descriptor?: GPURenderBundleDescriptor): GPURenderBundle;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderPassLayout extends GPUObjectDescriptorBase {
|
|
colorFormats: (GPUTextureFormat | null)[];
|
|
depthStencilFormat?: GPUTextureFormat;
|
|
sampleCount?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPURenderBundleEncoderDescriptor extends GPURenderPassLayout {
|
|
depthReadOnly?: boolean;
|
|
stencilReadOnly?: boolean;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUQueue implements GPUObjectBase {
|
|
label: string;
|
|
|
|
submit(commandBuffers: GPUCommandBuffer[]): undefined;
|
|
|
|
onSubmittedWorkDone(): Promise<undefined>;
|
|
|
|
writeBuffer(
|
|
buffer: GPUBuffer,
|
|
bufferOffset: number,
|
|
data: BufferSource,
|
|
dataOffset?: number,
|
|
size?: number,
|
|
): undefined;
|
|
|
|
writeTexture(
|
|
destination: GPUImageCopyTexture,
|
|
data: BufferSource,
|
|
dataLayout: GPUImageDataLayout,
|
|
size: GPUExtent3D,
|
|
): undefined;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUQuerySet implements GPUObjectBase {
|
|
label: string;
|
|
|
|
destroy(): undefined;
|
|
|
|
readonly type: GPUQueryType;
|
|
readonly count: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUQuerySetDescriptor extends GPUObjectDescriptorBase {
|
|
type: GPUQueryType;
|
|
count: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUQueryType = "occlusion" | "timestamp";
|
|
|
|
/** @category GPU */
|
|
type GPUDeviceLostReason = "destroyed";
|
|
|
|
/** @category GPU */
|
|
interface GPUDeviceLostInfo {
|
|
readonly reason: GPUDeviceLostReason;
|
|
readonly message: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUError {
|
|
readonly message: string;
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUOutOfMemoryError extends GPUError {
|
|
constructor(message: string);
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUValidationError extends GPUError {
|
|
constructor(message: string);
|
|
}
|
|
|
|
/** @category GPU */
|
|
declare class GPUInternalError extends GPUError {
|
|
constructor(message: string);
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUErrorFilter = "out-of-memory" | "validation" | "internal";
|
|
|
|
/** @category GPU */
|
|
declare class GPUUncapturedErrorEvent extends Event {
|
|
constructor(
|
|
type: string,
|
|
gpuUncapturedErrorEventInitDict: GPUUncapturedErrorEventInit,
|
|
);
|
|
|
|
readonly error: GPUError;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUUncapturedErrorEventInit extends EventInit {
|
|
error: GPUError;
|
|
}
|
|
|
|
/** @category GPU */
|
|
interface GPUColorDict {
|
|
r: number;
|
|
g: number;
|
|
b: number;
|
|
a: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUColor = number[] | GPUColorDict;
|
|
|
|
/** @category GPU */
|
|
interface GPUOrigin3DDict {
|
|
x?: number;
|
|
y?: number;
|
|
z?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUOrigin3D = number[] | GPUOrigin3DDict;
|
|
|
|
/** @category GPU */
|
|
interface GPUExtent3DDict {
|
|
width: number;
|
|
height?: number;
|
|
depthOrArrayLayers?: number;
|
|
}
|
|
|
|
/** @category GPU */
|
|
type GPUExtent3D = number[] | GPUExtent3DDict;
|
|
|
|
/** @category GPU */
|
|
type GPUCanvasAlphaMode = "opaque" | "premultiplied";
|
|
|
|
/** @category GPU */
|
|
interface GPUCanvasConfiguration {
|
|
device: GPUDevice;
|
|
format: GPUTextureFormat;
|
|
usage?: GPUTextureUsageFlags;
|
|
viewFormats?: GPUTextureFormat[];
|
|
colorSpace?: "srgb" | "display-p3";
|
|
alphaMode?: GPUCanvasAlphaMode;
|
|
}
|
|
/** @category GPU */
|
|
interface GPUCanvasContext {
|
|
configure(configuration: GPUCanvasConfiguration): undefined;
|
|
unconfigure(): undefined;
|
|
getCurrentTexture(): GPUTexture;
|
|
}
|