diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/webidl/WebGPU.webidl | 1231 |
1 files changed, 1231 insertions, 0 deletions
diff --git a/dom/webidl/WebGPU.webidl b/dom/webidl/WebGPU.webidl new file mode 100644 index 0000000000..39a9c5a4b3 --- /dev/null +++ b/dom/webidl/WebGPU.webidl @@ -0,0 +1,1231 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. + * + * The origin of this IDL file is + * https://gpuweb.github.io/gpuweb/ + */ + +interface mixin GPUObjectBase { + attribute USVString? label; +}; + +dictionary GPUObjectDescriptorBase { + USVString label; +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUSupportedLimits { + readonly attribute unsigned long maxTextureDimension1D; + readonly attribute unsigned long maxTextureDimension2D; + readonly attribute unsigned long maxTextureDimension3D; + readonly attribute unsigned long maxTextureArrayLayers; + readonly attribute unsigned long maxBindGroups; + readonly attribute unsigned long maxDynamicUniformBuffersPerPipelineLayout; + readonly attribute unsigned long maxDynamicStorageBuffersPerPipelineLayout; + readonly attribute unsigned long maxSampledTexturesPerShaderStage; + readonly attribute unsigned long maxSamplersPerShaderStage; + readonly attribute unsigned long maxStorageBuffersPerShaderStage; + readonly attribute unsigned long maxStorageTexturesPerShaderStage; + readonly attribute unsigned long maxUniformBuffersPerShaderStage; + readonly attribute unsigned long maxUniformBufferBindingSize; + readonly attribute unsigned long maxStorageBufferBindingSize; + readonly attribute unsigned long minUniformBufferOffsetAlignment; + readonly attribute unsigned long minStorageBufferOffsetAlignment; + readonly attribute unsigned long maxVertexBuffers; + readonly attribute unsigned long maxVertexAttributes; + readonly attribute unsigned long maxVertexBufferArrayStride; + readonly attribute unsigned long maxInterStageShaderComponents; + readonly attribute unsigned long maxComputeWorkgroupStorageSize; + readonly attribute unsigned long maxComputeInvocationsPerWorkgroup; + readonly attribute unsigned long maxComputeWorkgroupSizeX; + readonly attribute unsigned long maxComputeWorkgroupSizeY; + readonly attribute unsigned long maxComputeWorkgroupSizeZ; + readonly attribute unsigned long maxComputeWorkgroupsPerDimension; +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUSupportedFeatures { + readonly setlike<DOMString>; +}; + +// **************************************************************************** +// INITIALIZATION +// **************************************************************************** + +[ + Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext +] +interface GPU { + // May reject with DOMException + [NewObject] + Promise<GPUAdapter?> requestAdapter(optional GPURequestAdapterOptions options = {}); + GPUTextureFormat getPreferredCanvasFormat(); +}; + +// Add a "webgpu" member to Navigator/Worker that contains the global instance of a "WebGPU" +interface mixin GPUProvider { + [SameObject, Replaceable, Pref="dom.webgpu.enabled", Exposed=(Window /* ,DedicatedWorker */), SecureContext] readonly attribute GPU gpu; +}; + +dictionary GPURequestAdapterOptions { + GPUPowerPreference powerPreference; + boolean forceFallbackAdapter = false; +}; + +enum GPUPowerPreference { + "low-power", + "high-performance" +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUAdapterInfo { + readonly attribute DOMString vendor; + readonly attribute DOMString architecture; + readonly attribute DOMString device; + readonly attribute DOMString description; + + // Non-standard; see <https://bugzilla.mozilla.org/show_bug.cgi?id=1831994>. + [ChromeOnly] readonly attribute DOMString wgpuName; + [ChromeOnly] readonly attribute unsigned long wgpuVendor; + [ChromeOnly] readonly attribute unsigned long wgpuDevice; + [ChromeOnly] readonly attribute DOMString wgpuDeviceType; + [ChromeOnly] readonly attribute DOMString wgpuDriver; + [ChromeOnly] readonly attribute DOMString wgpuDriverInfo; + [ChromeOnly] readonly attribute DOMString wgpuBackend; +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUAdapter { + [SameObject] readonly attribute GPUSupportedFeatures features; + [SameObject] readonly attribute GPUSupportedLimits limits; + readonly attribute boolean isFallbackAdapter; + + [NewObject] + Promise<GPUDevice> requestDevice(optional GPUDeviceDescriptor descriptor = {}); + [NewObject] + Promise<GPUAdapterInfo> requestAdapterInfo(optional sequence<DOMString> unmaskHints = []); +}; + +dictionary GPUDeviceDescriptor { + sequence<GPUFeatureName> requiredFeatures = []; + record<DOMString, GPUSize64> requiredLimits; +}; + +enum GPUFeatureName { + "depth-clip-control", + "depth24unorm-stencil8", + "depth32float-stencil8", + "pipeline-statistics-query", + "texture-compression-bc", + "texture-compression-etc2", + "texture-compression-astc", + "timestamp-query", + "indirect-first-instance", +}; + +// Device +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUDevice: EventTarget { + [SameObject] readonly attribute GPUSupportedFeatures features; + [SameObject] readonly attribute GPUSupportedLimits limits; + + // Overriding the name to avoid collision with `class Queue` in gcc + [SameObject, BinaryName="getQueue"] readonly attribute GPUQueue queue; + + undefined destroy(); + + [NewObject, Throws] + GPUBuffer createBuffer(GPUBufferDescriptor descriptor); + [NewObject] + GPUTexture createTexture(GPUTextureDescriptor descriptor); + [NewObject] + GPUSampler createSampler(optional GPUSamplerDescriptor descriptor = {}); + + GPUBindGroupLayout createBindGroupLayout(GPUBindGroupLayoutDescriptor descriptor); + GPUPipelineLayout createPipelineLayout(GPUPipelineLayoutDescriptor descriptor); + GPUBindGroup createBindGroup(GPUBindGroupDescriptor descriptor); + + GPUShaderModule createShaderModule(GPUShaderModuleDescriptor descriptor); + GPUComputePipeline createComputePipeline(GPUComputePipelineDescriptor descriptor); + GPURenderPipeline createRenderPipeline(GPURenderPipelineDescriptor descriptor); + + [NewObject] + Promise<GPUComputePipeline> createComputePipelineAsync(GPUComputePipelineDescriptor descriptor); + [NewObject] + Promise<GPURenderPipeline> createRenderPipelineAsync(GPURenderPipelineDescriptor descriptor); + + [NewObject] + GPUCommandEncoder createCommandEncoder(optional GPUCommandEncoderDescriptor descriptor = {}); + [NewObject] + GPURenderBundleEncoder createRenderBundleEncoder(GPURenderBundleEncoderDescriptor descriptor); + //[NewObject] + //GPUQuerySet createQuerySet(GPUQuerySetDescriptor descriptor); +}; +GPUDevice includes GPUObjectBase; + +// Buffer +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUBuffer { + // TODO: s/unsigned long long/GPUSize64/: https://github.com/gpuweb/gpuweb/issues/4080 + readonly attribute unsigned long long size; + // TODO: s/unsigned long/GPUBufferUsageFlags/: https://github.com/gpuweb/gpuweb/issues/4080 + readonly attribute unsigned long usage; + + readonly attribute GPUBufferMapState mapState; + + [NewObject] + Promise<undefined> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size); + [NewObject, Throws] + ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size); + [Throws] + undefined unmap(); + + [Throws] + undefined destroy(); +}; +GPUBuffer includes GPUObjectBase; + +enum GPUBufferMapState { + "unmapped", + "pending", + "mapped" +}; + +dictionary GPUBufferDescriptor : GPUObjectDescriptorBase { + required GPUSize64 size; + required GPUBufferUsageFlags usage; + boolean mappedAtCreation = false; +}; + +typedef [EnforceRange] unsigned long GPUBufferUsageFlags; +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUBufferUsage { + const GPUBufferUsageFlags MAP_READ = 0x0001; + const GPUBufferUsageFlags MAP_WRITE = 0x0002; + const GPUBufferUsageFlags COPY_SRC = 0x0004; + const GPUBufferUsageFlags COPY_DST = 0x0008; + const GPUBufferUsageFlags INDEX = 0x0010; + const GPUBufferUsageFlags VERTEX = 0x0020; + const GPUBufferUsageFlags UNIFORM = 0x0040; + const GPUBufferUsageFlags STORAGE = 0x0080; + const GPUBufferUsageFlags INDIRECT = 0x0100; + const GPUBufferUsageFlags QUERY_RESOLVE = 0x0200; +}; + +typedef [EnforceRange] unsigned long GPUMapModeFlags; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUMapMode + { + const GPUMapModeFlags READ = 0x0001; + const GPUMapModeFlags WRITE = 0x0002; +}; + +typedef sequence<any> GPUMappedBuffer; + +// Texture + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUTexture { + [NewObject] + GPUTextureView createView(optional GPUTextureViewDescriptor descriptor = {}); + + undefined destroy(); + + // TODO: s/unsigned long/GPUIntegerCoordinate: https://github.com/gpuweb/gpuweb/issues/4080 + readonly attribute unsigned long width; + readonly attribute unsigned long height; + readonly attribute unsigned long depthOrArrayLayers; + readonly attribute unsigned long mipLevelCount; + // TODO: s/unsigned long/GPUSize32: https://github.com/gpuweb/gpuweb/issues/4080 + readonly attribute unsigned long sampleCount; + readonly attribute GPUTextureDimension dimension; + readonly attribute GPUTextureFormat format; + // TODO: s/unsigned long/GPUSize32: https://github.com/gpuweb/gpuweb/issues/4080 + readonly attribute unsigned long usage; +}; +GPUTexture includes GPUObjectBase; + +dictionary GPUTextureDescriptor : GPUObjectDescriptorBase { + required GPUExtent3D size; + GPUIntegerCoordinate mipLevelCount = 1; + GPUSize32 sampleCount = 1; + GPUTextureDimension dimension = "2d"; + required GPUTextureFormat format; + required GPUTextureUsageFlags usage; +}; + +enum GPUTextureDimension { + "1d", + "2d", + "3d", +}; + +typedef [EnforceRange] unsigned long GPUTextureUsageFlags; +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUTextureUsage { + const GPUTextureUsageFlags COPY_SRC = 0x01; + const GPUTextureUsageFlags COPY_DST = 0x02; + const GPUTextureUsageFlags TEXTURE_BINDING = 0x04; + const GPUTextureUsageFlags STORAGE_BINDING = 0x08; + const GPUTextureUsageFlags RENDER_ATTACHMENT = 0x10; +}; + +enum GPUTextureComponentType { + "float", + "sint", + "uint", + "depth-comparison" +}; + +// Texture view +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUTextureView { +}; +GPUTextureView includes GPUObjectBase; + +dictionary GPUTextureViewDescriptor : GPUObjectDescriptorBase { + GPUTextureFormat format; + GPUTextureViewDimension dimension; + GPUTextureAspect aspect = "all"; + GPUIntegerCoordinate baseMipLevel = 0; + GPUIntegerCoordinate mipLevelCount; + GPUIntegerCoordinate baseArrayLayer = 0; + GPUIntegerCoordinate arrayLayerCount; +}; + +enum GPUTextureViewDimension { + "1d", + "2d", + "2d-array", + "cube", + "cube-array", + "3d" +}; + +enum GPUTextureAspect { + "all", + "stencil-only", + "depth-only" +}; + +enum GPUTextureFormat { + // 8-bit formats + "r8unorm", + "r8snorm", + "r8uint", + "r8sint", + + // 16-bit formats + "r16uint", + "r16sint", + "r16float", + "rg8unorm", + "rg8snorm", + "rg8uint", + "rg8sint", + + // 32-bit formats + "r32uint", + "r32sint", + "r32float", + "rg16uint", + "rg16sint", + "rg16float", + "rgba8unorm", + "rgba8unorm-srgb", + "rgba8snorm", + "rgba8uint", + "rgba8sint", + "bgra8unorm", + "bgra8unorm-srgb", + + // Packed 32-bit formats + "rgb9e5ufloat", + "rgb10a2unorm", + "rg11b10float", + + // 64-bit formats + "rg32uint", + "rg32sint", + "rg32float", + "rgba16uint", + "rgba16sint", + "rgba16float", + + // 128-bit formats + "rgba32uint", + "rgba32sint", + "rgba32float", + + // Depth and stencil formats + //"stencil8", //TODO + //"depth16unorm", + "depth24plus", + "depth24plus-stencil8", + "depth32float", + + // "depth32float-stencil8" feature + "depth32float-stencil8", + + // BC compressed formats usable if "texture-compression-bc" is both + // supported by the device/user agent and enabled in requestDevice. + "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", +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUSampler { +}; +GPUSampler includes GPUObjectBase; + +dictionary GPUSamplerDescriptor : GPUObjectDescriptorBase { + GPUAddressMode addressModeU = "clamp-to-edge"; + GPUAddressMode addressModeV = "clamp-to-edge"; + GPUAddressMode addressModeW = "clamp-to-edge"; + GPUFilterMode magFilter = "nearest"; + GPUFilterMode minFilter = "nearest"; + GPUFilterMode mipmapFilter = "nearest"; + float lodMinClamp = 0; + float lodMaxClamp = 1000.0; // TODO: What should this be? + GPUCompareFunction compare; + [Clamp] unsigned short maxAnisotropy = 1; +}; + +// Sampler +enum GPUAddressMode { + "clamp-to-edge", + "repeat", + "mirror-repeat" +}; + +enum GPUFilterMode { + "nearest", + "linear", +}; + +enum GPUCompareFunction { + "never", + "less", + "equal", + "less-equal", + "greater", + "not-equal", + "greater-equal", + "always" +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUBindGroupLayout { +}; +GPUBindGroupLayout includes GPUObjectBase; + +dictionary GPUBindGroupLayoutDescriptor : GPUObjectDescriptorBase { + required sequence<GPUBindGroupLayoutEntry> entries; +}; + +dictionary GPUBindGroupLayoutEntry { + required GPUIndex32 binding; + required GPUShaderStageFlags visibility; + GPUBufferBindingLayout buffer; + GPUSamplerBindingLayout sampler; + GPUTextureBindingLayout texture; + GPUStorageTextureBindingLayout storageTexture; +}; + +typedef [EnforceRange] unsigned long GPUShaderStageFlags; +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUShaderStage { + const GPUShaderStageFlags VERTEX = 1; + const GPUShaderStageFlags FRAGMENT = 2; + const GPUShaderStageFlags COMPUTE = 4; +}; + +enum GPUBufferBindingType { + "uniform", + "storage", + "read-only-storage", +}; + +dictionary GPUBufferBindingLayout { + GPUBufferBindingType type = "uniform"; + boolean hasDynamicOffset = false; + GPUSize64 minBindingSize = 0; +}; + +enum GPUSamplerBindingType { + "filtering", + "non-filtering", + "comparison", +}; + +dictionary GPUSamplerBindingLayout { + GPUSamplerBindingType type = "filtering"; +}; + +enum GPUTextureSampleType { + "float", + "unfilterable-float", + "depth", + "sint", + "uint", +}; + +dictionary GPUTextureBindingLayout { + GPUTextureSampleType sampleType = "float"; + GPUTextureViewDimension viewDimension = "2d"; + boolean multisampled = false; +}; + +enum GPUStorageTextureAccess { + "write-only", +}; + +dictionary GPUStorageTextureBindingLayout { + GPUStorageTextureAccess access = "write-only"; + required GPUTextureFormat format; + GPUTextureViewDimension viewDimension = "2d"; +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUBindGroup { +}; +GPUBindGroup includes GPUObjectBase; + +dictionary GPUBindGroupDescriptor : GPUObjectDescriptorBase { + required GPUBindGroupLayout layout; + required sequence<GPUBindGroupEntry> entries; +}; + +typedef (GPUSampler or GPUTextureView or GPUBufferBinding) GPUBindingResource; + +dictionary GPUBindGroupEntry { + required GPUIndex32 binding; + required GPUBindingResource resource; +}; + +dictionary GPUBufferBinding { + required GPUBuffer buffer; + GPUSize64 offset = 0; + GPUSize64 size; +}; + +// PipelineLayout +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUPipelineLayout { +}; +GPUPipelineLayout includes GPUObjectBase; + +dictionary GPUPipelineLayoutDescriptor : GPUObjectDescriptorBase { + required sequence<GPUBindGroupLayout> bindGroupLayouts; +}; + +// ShaderModule +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUShaderModule { + [Throws] + Promise<GPUCompilationInfo> compilationInfo(); +}; +GPUShaderModule includes GPUObjectBase; + +dictionary GPUShaderModuleDescriptor : GPUObjectDescriptorBase { + // UTF8String is not observably different from USVString + required UTF8String code; + object sourceMap; +}; + +enum GPUCompilationMessageType { + "error", + "warning", + "info" +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUCompilationMessage { + readonly attribute DOMString message; + readonly attribute GPUCompilationMessageType type; + readonly attribute unsigned long long lineNum; + readonly attribute unsigned long long linePos; + readonly attribute unsigned long long offset; + readonly attribute unsigned long long length; +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUCompilationInfo { + [Cached, Frozen, Pure] + readonly attribute sequence<GPUCompilationMessage> messages; +}; + +enum GPUAutoLayoutMode { + "auto" +}; + +dictionary GPUPipelineDescriptorBase : GPUObjectDescriptorBase { + required (GPUPipelineLayout or GPUAutoLayoutMode) layout; +}; + +interface mixin GPUPipelineBase { + GPUBindGroupLayout getBindGroupLayout(unsigned long index); +}; + +dictionary GPUProgrammableStage { + required GPUShaderModule module; + required USVString entryPoint; +}; + +//TODO: Serializable +// https://bugzilla.mozilla.org/show_bug.cgi?id=1696219 +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUComputePipeline { +}; +GPUComputePipeline includes GPUObjectBase; +GPUComputePipeline includes GPUPipelineBase; + +// ComputePipeline +dictionary GPUComputePipelineDescriptor : GPUPipelineDescriptorBase { + required GPUProgrammableStage compute; +}; + +//TODO: Serializable +// https://bugzilla.mozilla.org/show_bug.cgi?id=1696219 +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPURenderPipeline { +}; +GPURenderPipeline includes GPUObjectBase; +GPURenderPipeline includes GPUPipelineBase; + +dictionary GPURenderPipelineDescriptor : GPUPipelineDescriptorBase { + required GPUVertexState vertex; + GPUPrimitiveState primitive = {}; + GPUDepthStencilState depthStencil; + GPUMultisampleState multisample = {}; + GPUFragmentState fragment; +}; + +dictionary GPUPrimitiveState { + GPUPrimitiveTopology topology = "triangle-list"; + GPUIndexFormat stripIndexFormat; + GPUFrontFace frontFace = "ccw"; + GPUCullMode cullMode = "none"; + // Enable depth clamping (requires "depth-clamping" feature) + boolean clampDepth = false; +}; + +enum GPUPrimitiveTopology { + "point-list", + "line-list", + "line-strip", + "triangle-list", + "triangle-strip" +}; + +enum GPUFrontFace { + "ccw", + "cw" +}; + +enum GPUCullMode { + "none", + "front", + "back" +}; + +dictionary GPUMultisampleState { + GPUSize32 count = 1; + GPUSampleMask mask = 0xFFFFFFFF; + boolean alphaToCoverageEnabled = false; +}; + +dictionary GPUFragmentState: GPUProgrammableStage { + required sequence<GPUColorTargetState> targets; +}; + +dictionary GPUColorTargetState { + required GPUTextureFormat format; + GPUBlendState blend; + GPUColorWriteFlags writeMask = 0xF; // GPUColorWrite.ALL +}; + +dictionary GPUBlendState { + required GPUBlendComponent color; + required GPUBlendComponent alpha; +}; + +typedef [EnforceRange] unsigned long GPUColorWriteFlags; +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUColorWrite { + const GPUColorWriteFlags RED = 0x1; + const GPUColorWriteFlags GREEN = 0x2; + const GPUColorWriteFlags BLUE = 0x4; + const GPUColorWriteFlags ALPHA = 0x8; + const GPUColorWriteFlags ALL = 0xF; +}; + +dictionary GPUBlendComponent { + GPUBlendFactor srcFactor = "one"; + GPUBlendFactor dstFactor = "zero"; + GPUBlendOperation operation = "add"; +}; + +enum 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", +}; + +enum GPUBlendOperation { + "add", + "subtract", + "reverse-subtract", + "min", + "max" +}; + +dictionary GPUDepthStencilState { + required GPUTextureFormat format; + + boolean depthWriteEnabled = false; + GPUCompareFunction depthCompare = "always"; + + GPUStencilFaceState stencilFront = {}; + GPUStencilFaceState stencilBack = {}; + + GPUStencilValue stencilReadMask = 0xFFFFFFFF; + GPUStencilValue stencilWriteMask = 0xFFFFFFFF; + + GPUDepthBias depthBias = 0; + float depthBiasSlopeScale = 0; + float depthBiasClamp = 0; +}; + +dictionary GPUStencilFaceState { + GPUCompareFunction compare = "always"; + GPUStencilOperation failOp = "keep"; + GPUStencilOperation depthFailOp = "keep"; + GPUStencilOperation passOp = "keep"; +}; + +enum GPUStencilOperation { + "keep", + "zero", + "replace", + "invert", + "increment-clamp", + "decrement-clamp", + "increment-wrap", + "decrement-wrap" +}; + +enum GPUIndexFormat { + "uint16", + "uint32", +}; + +enum 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", +}; + +enum GPUVertexStepMode { + "vertex", + "instance", +}; + +dictionary GPUVertexState: GPUProgrammableStage { + sequence<GPUVertexBufferLayout?> buffers = []; +}; + +dictionary GPUVertexBufferLayout { + required GPUSize64 arrayStride; + GPUVertexStepMode stepMode = "vertex"; + required sequence<GPUVertexAttribute> attributes; +}; + +dictionary GPUVertexAttribute { + required GPUVertexFormat format; + required GPUSize64 offset; + required GPUIndex32 shaderLocation; +}; + +dictionary GPUImageDataLayout { + GPUSize64 offset = 0; + GPUSize32 bytesPerRow; + GPUSize32 rowsPerImage; +}; + +dictionary GPUImageCopyBuffer : GPUImageDataLayout { + required GPUBuffer buffer; +}; + +dictionary GPUImageCopyExternalImage { + required (ImageBitmap or HTMLCanvasElement or OffscreenCanvas) source; + GPUOrigin2D origin = {}; + boolean flipY = false; +}; + +dictionary GPUImageCopyTexture { + required GPUTexture texture; + GPUIntegerCoordinate mipLevel = 0; + GPUOrigin3D origin; + GPUTextureAspect aspect = "all"; +}; + +dictionary GPUImageCopyTextureTagged : GPUImageCopyTexture { + //GPUPredefinedColorSpace colorSpace = "srgb"; //TODO + boolean premultipliedAlpha = false; +}; + +dictionary GPUImageBitmapCopyView { + //required ImageBitmap imageBitmap; //TODO + GPUOrigin2D origin; +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUCommandBuffer { +}; +GPUCommandBuffer includes GPUObjectBase; + +// Command Buffer +dictionary GPUCommandBufferDescriptor : GPUObjectDescriptorBase { +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUCommandEncoder { + [NewObject] + GPUComputePassEncoder beginComputePass(optional GPUComputePassDescriptor descriptor = {}); + [NewObject] + GPURenderPassEncoder beginRenderPass(GPURenderPassDescriptor descriptor); + + undefined copyBufferToBuffer( + GPUBuffer source, + GPUSize64 sourceOffset, + GPUBuffer destination, + GPUSize64 destinationOffset, + GPUSize64 size); + + undefined copyBufferToTexture( + GPUImageCopyBuffer source, + GPUImageCopyTexture destination, + GPUExtent3D copySize); + + undefined copyTextureToBuffer( + GPUImageCopyTexture source, + GPUImageCopyBuffer destination, + GPUExtent3D copySize); + + undefined copyTextureToTexture( + GPUImageCopyTexture source, + GPUImageCopyTexture destination, + GPUExtent3D copySize); + + /* + undefined copyImageBitmapToTexture( + GPUImageBitmapCopyView source, + GPUImageCopyTexture destination, + GPUExtent3D copySize); + */ + + undefined pushDebugGroup(USVString groupLabel); + undefined popDebugGroup(); + undefined insertDebugMarker(USVString markerLabel); + + [NewObject] + GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {}); +}; +GPUCommandEncoder includes GPUObjectBase; + +dictionary GPUCommandEncoderDescriptor : GPUObjectDescriptorBase { +}; + +interface mixin GPUProgrammablePassEncoder { + undefined setBindGroup(GPUIndex32 index, GPUBindGroup bindGroup, + optional sequence<GPUBufferDynamicOffset> dynamicOffsets = []); + + undefined pushDebugGroup(USVString groupLabel); + undefined popDebugGroup(); + undefined insertDebugMarker(USVString markerLabel); +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUComputePassEncoder { + undefined setPipeline(GPUComputePipeline pipeline); + undefined dispatchWorkgroups(GPUSize32 x, optional GPUSize32 y = 1, optional GPUSize32 z = 1); + [Pref="dom.webgpu.indirect-dispatch.enabled"] + undefined dispatchWorkgroupsIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset); + + [Throws] + undefined end(); +}; +GPUComputePassEncoder includes GPUObjectBase; +GPUComputePassEncoder includes GPUProgrammablePassEncoder; + +dictionary GPUComputePassDescriptor : GPUObjectDescriptorBase { +}; + +interface mixin GPURenderEncoderBase { + undefined setPipeline(GPURenderPipeline pipeline); + + undefined setIndexBuffer(GPUBuffer buffer, GPUIndexFormat indexFormat, optional GPUSize64 offset = 0, optional GPUSize64 size = 0); + undefined setVertexBuffer(GPUIndex32 slot, GPUBuffer buffer, optional GPUSize64 offset = 0, optional GPUSize64 size = 0); + + undefined draw(GPUSize32 vertexCount, + optional GPUSize32 instanceCount = 1, + optional GPUSize32 firstVertex = 0, + optional GPUSize32 firstInstance = 0); + undefined drawIndexed(GPUSize32 indexCount, + optional GPUSize32 instanceCount = 1, + optional GPUSize32 firstIndex = 0, + optional GPUSignedOffset32 baseVertex = 0, + optional GPUSize32 firstInstance = 0); + + [Pref="dom.webgpu.indirect-dispatch.enabled"] + undefined drawIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset); + [Pref="dom.webgpu.indirect-dispatch.enabled"] + undefined drawIndexedIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset); +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPURenderPassEncoder { + undefined setViewport(float x, float y, + float width, float height, + float minDepth, float maxDepth); + + undefined setScissorRect(GPUIntegerCoordinate x, GPUIntegerCoordinate y, + GPUIntegerCoordinate width, GPUIntegerCoordinate height); + + undefined setBlendConstant(GPUColor color); + undefined setStencilReference(GPUStencilValue reference); + + //undefined beginOcclusionQuery(GPUSize32 queryIndex); + //undefined endOcclusionQuery(); + + //undefined beginPipelineStatisticsQuery(GPUQuerySet querySet, GPUSize32 queryIndex); + //undefined endPipelineStatisticsQuery(); + + //undefined writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex); + + undefined executeBundles(sequence<GPURenderBundle> bundles); + + [Throws] + undefined end(); +}; +GPURenderPassEncoder includes GPUObjectBase; +GPURenderPassEncoder includes GPUProgrammablePassEncoder; +GPURenderPassEncoder includes GPURenderEncoderBase; + +dictionary GPURenderPassDescriptor : GPUObjectDescriptorBase { + required sequence<GPURenderPassColorAttachment> colorAttachments; + GPURenderPassDepthStencilAttachment depthStencilAttachment; + GPUQuerySet occlusionQuerySet; +}; + +dictionary GPURenderPassColorAttachment { + required GPUTextureView view; + GPUTextureView resolveTarget; + + GPUColor clearValue; + required GPULoadOp loadOp; + required GPUStoreOp storeOp; +}; + +dictionary GPURenderPassDepthStencilAttachment { + required GPUTextureView view; + + float depthClearValue; + GPULoadOp depthLoadOp; + GPUStoreOp depthStoreOp; + boolean depthReadOnly = false; + + GPUStencilValue stencilClearValue = 0; + GPULoadOp stencilLoadOp; + GPUStoreOp stencilStoreOp; + boolean stencilReadOnly = false; +}; + +enum GPULoadOp { + "load", + "clear" +}; + +enum GPUStoreOp { + "store", + "discard" +}; + +dictionary GPURenderPassLayout: GPUObjectDescriptorBase { + required sequence<GPUTextureFormat> colorFormats; + GPUTextureFormat depthStencilFormat; + GPUSize32 sampleCount = 1; +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPURenderBundle { +}; +GPURenderBundle includes GPUObjectBase; + +dictionary GPURenderBundleDescriptor : GPUObjectDescriptorBase { +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPURenderBundleEncoder { + GPURenderBundle finish(optional GPURenderBundleDescriptor descriptor = {}); +}; +GPURenderBundleEncoder includes GPUObjectBase; +GPURenderBundleEncoder includes GPUProgrammablePassEncoder; +GPURenderBundleEncoder includes GPURenderEncoderBase; + +dictionary GPURenderBundleEncoderDescriptor : GPURenderPassLayout { + boolean depthReadOnly = false; + boolean stencilReadOnly = false; +}; + +//TODO: use [AllowShared] on BufferSource +// https://bugzilla.mozilla.org/show_bug.cgi?id=1696216 +// https://github.com/heycam/webidl/issues/961 + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUQueue { + undefined submit(sequence<GPUCommandBuffer> buffers); + + //TODO: + //Promise<undefined> onSubmittedWorkDone(); + + [Throws] + undefined writeBuffer( + GPUBuffer buffer, + GPUSize64 bufferOffset, + BufferSource data, + optional GPUSize64 dataOffset = 0, + optional GPUSize64 size); + + [Throws] + undefined writeTexture( + GPUImageCopyTexture destination, + BufferSource data, + GPUImageDataLayout dataLayout, + GPUExtent3D size); + + [Throws] + undefined copyExternalImageToTexture( + GPUImageCopyExternalImage source, + GPUImageCopyTextureTagged destination, + GPUExtent3D copySize); +}; +GPUQueue includes GPUObjectBase; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUQuerySet { + undefined destroy(); +}; +GPUQuerySet includes GPUObjectBase; + +dictionary GPUQuerySetDescriptor : GPUObjectDescriptorBase { + required GPUQueryType type; + required GPUSize32 count; + sequence<GPUPipelineStatisticName> pipelineStatistics = []; +}; + +enum GPUPipelineStatisticName { + "vertex-shader-invocations", + "clipper-invocations", + "clipper-primitives-out", + "fragment-shader-invocations", + "compute-shader-invocations" +}; + +enum GPUQueryType { + "occlusion", + "pipeline-statistics", + "timestamp" +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUCanvasContext { + readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas; + + // Calling configure() a second time invalidates the previous one, + // and all of the textures it's produced. + undefined configure(GPUCanvasConfiguration descriptor); + undefined unconfigure(); + + [Throws] + GPUTexture getCurrentTexture(); +}; + +enum GPUCanvasCompositingAlphaMode { + "opaque", + "premultiplied", +}; + +dictionary GPUCanvasConfiguration { + required GPUDevice device; + required GPUTextureFormat format; + GPUTextureUsageFlags usage = 0x10; //GPUTextureUsage.OUTPUT_ATTACHMENT + //GPUPredefinedColorSpace colorSpace = "srgb"; //TODO + GPUCanvasCompositingAlphaMode compositingAlphaMode = "opaque"; +}; + +enum GPUDeviceLostReason { + "destroyed", +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUDeviceLostInfo { + readonly attribute any reason; // GPUDeviceLostReason or undefined + readonly attribute DOMString message; +}; + +partial interface GPUDevice { + [Throws] + readonly attribute Promise<GPUDeviceLostInfo> lost; + undefined pushErrorScope(GPUErrorFilter filter); + [NewObject] + Promise<GPUError?> popErrorScope(); + [Exposed=(Window /* ,DedicatedWorker */)] + attribute EventHandler onuncapturederror; +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUOutOfMemoryError { + //constructor(); +}; + +[Pref="dom.webgpu.enabled", + Exposed=(Window /* ,DedicatedWorker */), SecureContext] +interface GPUValidationError { + [Throws] + constructor(DOMString message); + readonly attribute DOMString message; +}; + +typedef (GPUOutOfMemoryError or GPUValidationError) GPUError; + +enum GPUErrorFilter { + "out-of-memory", + "validation" +}; + +typedef [EnforceRange] unsigned long GPUBufferDynamicOffset; +typedef [EnforceRange] unsigned long GPUStencilValue; +typedef [EnforceRange] unsigned long GPUSampleMask; +typedef [EnforceRange] long GPUDepthBias; + +typedef [EnforceRange] unsigned long long GPUSize64; +typedef [EnforceRange] unsigned long GPUIntegerCoordinate; +typedef [EnforceRange] unsigned long GPUIndex32; +typedef [EnforceRange] unsigned long GPUSize32; +typedef [EnforceRange] long GPUSignedOffset32; + +dictionary GPUColorDict { + required double r; + required double g; + required double b; + required double a; +}; +typedef (sequence<double> or GPUColorDict) GPUColor; + +dictionary GPUOrigin2DDict { + GPUIntegerCoordinate x = 0; + GPUIntegerCoordinate y = 0; +}; +typedef (sequence<GPUIntegerCoordinate> or GPUOrigin2DDict) GPUOrigin2D; + +dictionary GPUOrigin3DDict { + GPUIntegerCoordinate x = 0; + GPUIntegerCoordinate y = 0; + GPUIntegerCoordinate z = 0; +}; +typedef (sequence<GPUIntegerCoordinate> or GPUOrigin3DDict) GPUOrigin3D; + +dictionary GPUExtent3DDict { + required GPUIntegerCoordinate width; + GPUIntegerCoordinate height = 1; + GPUIntegerCoordinate depthOrArrayLayers = 1; +}; +typedef (sequence<GPUIntegerCoordinate> or GPUExtent3DDict) GPUExtent3D; |