зеркало из https://github.com/mozilla/gecko-dev.git
1198 строки
33 KiB
Plaintext
1198 строки
33 KiB
Plaintext
/* -*- 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;
|
|
};
|
|
|
|
[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 {
|
|
[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;
|
|
|
|
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();
|
|
};
|
|
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
|
|
"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",
|
|
|
|
// 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",
|
|
|
|
// "depth24unorm-stencil8" feature
|
|
//"depth24unorm-stencil8",
|
|
|
|
// "depth32float-stencil8" feature
|
|
//"depth32float-stencil8",
|
|
};
|
|
|
|
[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;
|
|
required GPUSize32 bytesPerRow;
|
|
GPUSize32 rowsPerImage = 0;
|
|
};
|
|
|
|
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;
|