mirror of
https://github.com/denoland/deno.git
synced 2024-12-04 17:18:23 -05:00
393abed387
Signed-off-by: Leo Kettmeir <crowlkats@toaxl.com> Co-authored-by: Kenta Moriuchi <moriken@kimamass.com> Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>
1233 lines
33 KiB
Text
1233 lines
33 KiB
Text
interface mixin GPUObjectBase {
|
||
attribute USVString label;
|
||
};
|
||
|
||
dictionary GPUObjectDescriptorBase {
|
||
USVString label = "";
|
||
};
|
||
|
||
[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 maxBindingsPerBindGroup;
|
||
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 long maxUniformBufferBindingSize;
|
||
readonly attribute unsigned long long maxStorageBufferBindingSize;
|
||
readonly attribute unsigned long minUniformBufferOffsetAlignment;
|
||
readonly attribute unsigned long minStorageBufferOffsetAlignment;
|
||
readonly attribute unsigned long maxVertexBuffers;
|
||
readonly attribute unsigned long long maxBufferSize;
|
||
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;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUSupportedFeatures {
|
||
readonly setlike<DOMString>;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUAdapterInfo {
|
||
readonly attribute DOMString vendor;
|
||
readonly attribute DOMString architecture;
|
||
readonly attribute DOMString device;
|
||
readonly attribute DOMString description;
|
||
};
|
||
|
||
interface mixin NavigatorGPU {
|
||
[SameObject, SecureContext] readonly attribute GPU gpu;
|
||
};
|
||
Navigator includes NavigatorGPU;
|
||
WorkerNavigator includes NavigatorGPU;
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPU {
|
||
Promise<GPUAdapter?> requestAdapter(optional GPURequestAdapterOptions options = {});
|
||
};
|
||
|
||
dictionary GPURequestAdapterOptions {
|
||
GPUPowerPreference powerPreference;
|
||
boolean forceFallbackAdapter = false;
|
||
};
|
||
|
||
enum GPUPowerPreference {
|
||
"low-power",
|
||
"high-performance",
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUAdapter {
|
||
[SameObject] readonly attribute GPUSupportedFeatures features;
|
||
[SameObject] readonly attribute GPUSupportedLimits limits;
|
||
readonly attribute boolean isFallbackAdapter;
|
||
|
||
Promise<GPUDevice> requestDevice(optional GPUDeviceDescriptor descriptor = {});
|
||
Promise<GPUAdapterInfo> requestAdapterInfo(optional sequence<DOMString> unmaskHints = []);
|
||
};
|
||
|
||
dictionary GPUDeviceDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
sequence<GPUFeatureName> requiredFeatures = [];
|
||
record<DOMString, GPUSize64> requiredLimits = {};
|
||
};
|
||
|
||
enum GPUFeatureName {
|
||
// api
|
||
"depth-clip-control",
|
||
// texture formats
|
||
"depth32float-stencil8",
|
||
"texture-compression-bc",
|
||
"texture-compression-etc2",
|
||
"texture-compression-astc",
|
||
// api
|
||
"timestamp-query",
|
||
"indirect-first-instance",
|
||
// shader
|
||
"shader-f16",
|
||
"rg11b10ufloat-renderable",
|
||
"bgra8unorm-storage",
|
||
|
||
// extended from spec
|
||
|
||
// texture formats
|
||
"texture-format-16-bit-norm",
|
||
"texture-compression-astc-hdr",
|
||
"texture-adapter-specific-format-features",
|
||
// api
|
||
"pipeline-statistics-query",
|
||
"timestamp-query-inside-passes",
|
||
"mappable-primary-buffers",
|
||
"texture-binding-array",
|
||
"buffer-binding-array",
|
||
"storage-resource-binding-array",
|
||
"sampled-texture-and-storage-buffer-array-non-uniform-indexing",
|
||
"uniform-buffer-and-storage-texture-array-non-uniform-indexing",
|
||
"partially-bound-binding-array",
|
||
"multi-draw-indirect",
|
||
"multi-draw-indirect-count",
|
||
"push-constants",
|
||
"address-mode-clamp-to-zero",
|
||
"address-mode-clamp-to-border",
|
||
"polygon-mode-line",
|
||
"polygon-mode-point",
|
||
"conservative-rasterization",
|
||
"vertex-writable-storage",
|
||
"clear-texture",
|
||
"spirv-shader-passthrough",
|
||
"multiview",
|
||
"vertex-attribute-64-bit",
|
||
// shader
|
||
"shader-f64",
|
||
"shader-i16",
|
||
"shader-primitive-index",
|
||
"shader-early-depth-test",
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUDevice : EventTarget {
|
||
[SameObject] readonly attribute GPUSupportedFeatures features;
|
||
[SameObject] readonly attribute GPUSupportedLimits limits;
|
||
|
||
[SameObject] readonly attribute GPUQueue queue;
|
||
|
||
undefined destroy();
|
||
|
||
GPUBuffer createBuffer(GPUBufferDescriptor descriptor);
|
||
GPUTexture createTexture(GPUTextureDescriptor descriptor);
|
||
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);
|
||
Promise<GPUComputePipeline> createComputePipelineAsync(GPUComputePipelineDescriptor descriptor);
|
||
Promise<GPURenderPipeline> createRenderPipelineAsync(GPURenderPipelineDescriptor descriptor);
|
||
|
||
GPUCommandEncoder createCommandEncoder(optional GPUCommandEncoderDescriptor descriptor = {});
|
||
GPURenderBundleEncoder createRenderBundleEncoder(GPURenderBundleEncoderDescriptor descriptor);
|
||
|
||
GPUQuerySet createQuerySet(GPUQuerySetDescriptor descriptor);
|
||
};
|
||
GPUDevice includes GPUObjectBase;
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUBuffer {
|
||
readonly attribute GPUSize64Out size;
|
||
readonly attribute GPUFlagsConstant usage;
|
||
|
||
readonly attribute GPUBufferMapState mapState;
|
||
|
||
Promise<undefined> mapAsync(GPUMapModeFlags mode, optional GPUSize64 offset = 0, optional GPUSize64 size);
|
||
ArrayBuffer getMappedRange(optional GPUSize64 offset = 0, optional GPUSize64 size);
|
||
undefined unmap();
|
||
|
||
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;
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
namespace GPUBufferUsage {
|
||
const GPUFlagsConstant MAP_READ = 0x0001;
|
||
const GPUFlagsConstant MAP_WRITE = 0x0002;
|
||
const GPUFlagsConstant COPY_SRC = 0x0004;
|
||
const GPUFlagsConstant COPY_DST = 0x0008;
|
||
const GPUFlagsConstant INDEX = 0x0010;
|
||
const GPUFlagsConstant VERTEX = 0x0020;
|
||
const GPUFlagsConstant UNIFORM = 0x0040;
|
||
const GPUFlagsConstant STORAGE = 0x0080;
|
||
const GPUFlagsConstant INDIRECT = 0x0100;
|
||
const GPUFlagsConstant QUERY_RESOLVE = 0x0200;
|
||
};
|
||
|
||
typedef [EnforceRange] unsigned long GPUMapModeFlags;
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
namespace GPUMapMode {
|
||
const GPUFlagsConstant READ = 0x0001;
|
||
const GPUFlagsConstant WRITE = 0x0002;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUTexture {
|
||
GPUTextureView createView(optional GPUTextureViewDescriptor descriptor = {});
|
||
|
||
undefined destroy();
|
||
|
||
readonly attribute GPUIntegerCoordinateOut width;
|
||
readonly attribute GPUIntegerCoordinateOut height;
|
||
readonly attribute GPUIntegerCoordinateOut depthOrArrayLayers;
|
||
readonly attribute GPUIntegerCoordinateOut mipLevelCount;
|
||
readonly attribute GPUSize32Out sampleCount;
|
||
readonly attribute GPUTextureDimension dimension;
|
||
readonly attribute GPUTextureFormat format;
|
||
readonly attribute GPUFlagsConstant 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;
|
||
sequence<GPUTextureFormat> viewFormats = [];
|
||
};
|
||
|
||
enum GPUTextureDimension {
|
||
"1d",
|
||
"2d",
|
||
"3d",
|
||
};
|
||
|
||
typedef [EnforceRange] unsigned long GPUTextureUsageFlags;
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
namespace GPUTextureUsage {
|
||
const GPUFlagsConstant COPY_SRC = 0x01;
|
||
const GPUFlagsConstant COPY_DST = 0x02;
|
||
const GPUFlagsConstant TEXTURE_BINDING = 0x04;
|
||
const GPUFlagsConstant STORAGE_BINDING = 0x08;
|
||
const GPUFlagsConstant RENDER_ATTACHMENT = 0x10;
|
||
};
|
||
|
||
[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",
|
||
"rg11b10ufloat",
|
||
|
||
// 64-bit formats
|
||
"rg32uint",
|
||
"rg32sint",
|
||
"rg32float",
|
||
"rgba16uint",
|
||
"rgba16sint",
|
||
"rgba16float",
|
||
|
||
// 128-bit formats
|
||
"rgba32uint",
|
||
"rgba32sint",
|
||
"rgba32float",
|
||
|
||
// Depth/stencil formats
|
||
"stencil8",
|
||
"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",
|
||
|
||
// ETC2 compressed formats usable if "texture-compression-etc2" is both
|
||
// supported by the device/user agent and enabled in requestDevice.
|
||
"etc2-rgb8unorm",
|
||
"etc2-rgb8unorm-srgb",
|
||
"etc2-rgb8a1unorm",
|
||
"etc2-rgb8a1unorm-srgb",
|
||
"etc2-rgba8unorm",
|
||
"etc2-rgba8unorm-srgb",
|
||
"eac-r11unorm",
|
||
"eac-r11snorm",
|
||
"eac-rg11unorm",
|
||
"eac-rg11snorm",
|
||
|
||
// ASTC compressed formats usable if "texture-compression-astc" is both
|
||
// supported by the device/user agent and enabled in requestDevice.
|
||
"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",
|
||
};
|
||
|
||
[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";
|
||
GPUMipmapFilterMode mipmapFilter = "nearest";
|
||
float lodMinClamp = 0;
|
||
float lodMaxClamp = 32;
|
||
GPUCompareFunction compare;
|
||
[Clamp] unsigned short maxAnisotropy = 1;
|
||
};
|
||
|
||
enum GPUAddressMode {
|
||
"clamp-to-edge",
|
||
"repeat",
|
||
"mirror-repeat",
|
||
};
|
||
|
||
enum GPUFilterMode {
|
||
"nearest",
|
||
"linear",
|
||
};
|
||
|
||
enum GPUMipmapFilterMode {
|
||
"nearest",
|
||
"linear",
|
||
};
|
||
|
||
enum GPUCompareFunction {
|
||
"never",
|
||
"less",
|
||
"equal",
|
||
"less-equal",
|
||
"greater",
|
||
"not-equal",
|
||
"greater-equal",
|
||
"always",
|
||
};
|
||
|
||
[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;
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
namespace GPUShaderStage {
|
||
const GPUFlagsConstant VERTEX = 0x1;
|
||
const GPUFlagsConstant FRAGMENT = 0x2;
|
||
const GPUFlagsConstant COMPUTE = 0x4;
|
||
};
|
||
|
||
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";
|
||
};
|
||
|
||
[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;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUPipelineLayout {
|
||
};
|
||
GPUPipelineLayout includes GPUObjectBase;
|
||
|
||
dictionary GPUPipelineLayoutDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
required sequence<GPUBindGroupLayout> bindGroupLayouts;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUShaderModule {
|
||
};
|
||
GPUShaderModule includes GPUObjectBase;
|
||
|
||
dictionary GPUShaderModuleDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
required USVString code;
|
||
};
|
||
|
||
enum GPUCompilationMessageType {
|
||
"error",
|
||
"warning",
|
||
"info",
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), Serializable, 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;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), Serializable, SecureContext]
|
||
interface GPUCompilationInfo {
|
||
readonly attribute FrozenArray<GPUCompilationMessage> messages;
|
||
};
|
||
|
||
enum GPUAutoLayoutMode {
|
||
"auto",
|
||
};
|
||
|
||
dictionary GPUPipelineDescriptorBase
|
||
: GPUObjectDescriptorBase {
|
||
required (GPUPipelineLayout or GPUAutoLayoutMode) layout;
|
||
};
|
||
|
||
interface mixin GPUPipelineBase {
|
||
[NewObject] GPUBindGroupLayout getBindGroupLayout(unsigned long index);
|
||
};
|
||
|
||
dictionary GPUProgrammableStage {
|
||
required GPUShaderModule module;
|
||
required USVString entryPoint;
|
||
record<USVString, GPUPipelineConstantValue> constants;
|
||
};
|
||
|
||
typedef double GPUPipelineConstantValue; // May represent WGSL’s bool, f32, i32, u32, and f16 if enabled.
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUComputePipeline {
|
||
};
|
||
GPUComputePipeline includes GPUObjectBase;
|
||
GPUComputePipeline includes GPUPipelineBase;
|
||
|
||
dictionary GPUComputePipelineDescriptor
|
||
: GPUPipelineDescriptorBase {
|
||
required GPUProgrammableStage compute;
|
||
};
|
||
|
||
[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";
|
||
|
||
// Requires "depth-clip-control" feature.
|
||
boolean unclippedDepth = 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;
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
namespace GPUColorWrite {
|
||
const GPUFlagsConstant RED = 0x1;
|
||
const GPUFlagsConstant GREEN = 0x2;
|
||
const GPUFlagsConstant BLUE = 0x4;
|
||
const GPUFlagsConstant ALPHA = 0x8;
|
||
const GPUFlagsConstant ALL = 0xF;
|
||
};
|
||
|
||
dictionary GPUBlendComponent {
|
||
GPUBlendOperation operation = "add";
|
||
GPUBlendFactor srcFactor = "one";
|
||
GPUBlendFactor dstFactor = "zero";
|
||
};
|
||
|
||
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;
|
||
|
||
required boolean depthWriteEnabled;
|
||
required GPUCompareFunction depthCompare;
|
||
|
||
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 GPUImageCopyTexture {
|
||
required GPUTexture texture;
|
||
GPUIntegerCoordinate mipLevel = 0;
|
||
GPUOrigin3D origin = {};
|
||
GPUTextureAspect aspect = "all";
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUCommandBuffer {
|
||
};
|
||
GPUCommandBuffer includes GPUObjectBase;
|
||
|
||
dictionary GPUCommandBufferDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
};
|
||
|
||
interface mixin GPUCommandsMixin {
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUCommandEncoder {
|
||
GPURenderPassEncoder beginRenderPass(GPURenderPassDescriptor descriptor);
|
||
GPUComputePassEncoder beginComputePass(optional GPUComputePassDescriptor 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 clearBuffer(
|
||
GPUBuffer buffer,
|
||
optional GPUSize64 offset = 0,
|
||
optional GPUSize64 size);
|
||
|
||
undefined writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex);
|
||
|
||
undefined resolveQuerySet(
|
||
GPUQuerySet querySet,
|
||
GPUSize32 firstQuery,
|
||
GPUSize32 queryCount,
|
||
GPUBuffer destination,
|
||
GPUSize64 destinationOffset);
|
||
|
||
GPUCommandBuffer finish(optional GPUCommandBufferDescriptor descriptor = {});
|
||
};
|
||
GPUCommandEncoder includes GPUObjectBase;
|
||
GPUCommandEncoder includes GPUCommandsMixin;
|
||
GPUCommandEncoder includes GPUDebugCommandsMixin;
|
||
|
||
dictionary GPUCommandEncoderDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
};
|
||
|
||
interface mixin GPUBindingCommandsMixin {
|
||
undefined setBindGroup(GPUIndex32 index, GPUBindGroup bindGroup,
|
||
optional sequence<GPUBufferDynamicOffset> dynamicOffsets = []);
|
||
|
||
undefined setBindGroup(GPUIndex32 index, GPUBindGroup bindGroup,
|
||
Uint32Array dynamicOffsetsData,
|
||
GPUSize64 dynamicOffsetsDataStart,
|
||
GPUSize32 dynamicOffsetsDataLength);
|
||
};
|
||
|
||
interface mixin GPUDebugCommandsMixin {
|
||
undefined pushDebugGroup(USVString groupLabel);
|
||
undefined popDebugGroup();
|
||
undefined insertDebugMarker(USVString markerLabel);
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUComputePassEncoder {
|
||
undefined setPipeline(GPUComputePipeline pipeline);
|
||
undefined dispatchWorkgroups(GPUSize32 workgroupCountX, optional GPUSize32 workgroupCountY = 1, optional GPUSize32 workgroupCountZ = 1);
|
||
undefined dispatchWorkgroupsIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
|
||
|
||
undefined end();
|
||
};
|
||
GPUComputePassEncoder includes GPUObjectBase;
|
||
GPUComputePassEncoder includes GPUCommandsMixin;
|
||
GPUComputePassEncoder includes GPUDebugCommandsMixin;
|
||
GPUComputePassEncoder includes GPUBindingCommandsMixin;
|
||
|
||
dictionary GPUComputePassTimestampWrites {
|
||
required GPUQuerySet querySet;
|
||
GPUSize32 beginningOfPassWriteIndex;
|
||
GPUSize32 endOfPassWriteIndex;
|
||
};
|
||
|
||
dictionary GPUComputePassDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
GPUComputePassTimestampWrites timestampWrites;
|
||
};
|
||
|
||
[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 executeBundles(sequence<GPURenderBundle> bundles);
|
||
undefined end();
|
||
};
|
||
GPURenderPassEncoder includes GPUObjectBase;
|
||
GPURenderPassEncoder includes GPUCommandsMixin;
|
||
GPURenderPassEncoder includes GPUDebugCommandsMixin;
|
||
GPURenderPassEncoder includes GPUBindingCommandsMixin;
|
||
GPURenderPassEncoder includes GPURenderCommandsMixin;
|
||
|
||
dictionary GPURenderPassTimestampWrites {
|
||
required GPUQuerySet querySet;
|
||
GPUSize32 beginningOfPassWriteIndex;
|
||
GPUSize32 endOfPassWriteIndex;
|
||
};
|
||
|
||
dictionary GPURenderPassDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
required sequence<GPURenderPassColorAttachment?> colorAttachments;
|
||
GPURenderPassDepthStencilAttachment depthStencilAttachment;
|
||
GPUQuerySet occlusionQuerySet;
|
||
GPURenderPassTimestampWrites timestampWrites;
|
||
};
|
||
|
||
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;
|
||
};
|
||
|
||
interface mixin GPURenderCommandsMixin {
|
||
undefined setPipeline(GPURenderPipeline pipeline);
|
||
|
||
undefined setIndexBuffer(GPUBuffer buffer, GPUIndexFormat indexFormat, optional GPUSize64 offset = 0, optional GPUSize64 size);
|
||
undefined setVertexBuffer(GPUIndex32 slot, GPUBuffer buffer, optional GPUSize64 offset = 0, optional GPUSize64 size);
|
||
|
||
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);
|
||
|
||
undefined drawIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
|
||
undefined drawIndexedIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPURenderBundle {
|
||
};
|
||
GPURenderBundle includes GPUObjectBase;
|
||
|
||
dictionary GPURenderBundleDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPURenderBundleEncoder {
|
||
GPURenderBundle finish(optional GPURenderBundleDescriptor descriptor = {});
|
||
};
|
||
GPURenderBundleEncoder includes GPUObjectBase;
|
||
GPURenderBundleEncoder includes GPUCommandsMixin;
|
||
GPURenderBundleEncoder includes GPUDebugCommandsMixin;
|
||
GPURenderBundleEncoder includes GPUBindingCommandsMixin;
|
||
GPURenderBundleEncoder includes GPURenderCommandsMixin;
|
||
|
||
dictionary GPURenderBundleEncoderDescriptor
|
||
: GPURenderPassLayout {
|
||
boolean depthReadOnly = false;
|
||
boolean stencilReadOnly = false;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUQueue {
|
||
undefined submit(sequence<GPUCommandBuffer> commandBuffers);
|
||
|
||
Promise<undefined> onSubmittedWorkDone();
|
||
|
||
undefined writeBuffer(
|
||
GPUBuffer buffer,
|
||
GPUSize64 bufferOffset,
|
||
[AllowShared] BufferSource data,
|
||
optional GPUSize64 dataOffset = 0,
|
||
optional GPUSize64 size);
|
||
|
||
undefined writeTexture(
|
||
GPUImageCopyTexture destination,
|
||
[AllowShared] BufferSource data,
|
||
GPUImageDataLayout dataLayout,
|
||
GPUExtent3D size);
|
||
};
|
||
GPUQueue includes GPUObjectBase;
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUQuerySet {
|
||
undefined destroy();
|
||
|
||
readonly attribute GPUQueryType type;
|
||
readonly attribute GPUSize32Out count;
|
||
};
|
||
GPUQuerySet includes GPUObjectBase;
|
||
|
||
dictionary GPUQuerySetDescriptor
|
||
: GPUObjectDescriptorBase {
|
||
required GPUQueryType type;
|
||
required GPUSize32 count;
|
||
};
|
||
|
||
enum GPUQueryType {
|
||
"occlusion",
|
||
"timestamp",
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUCanvasContext {
|
||
readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas;
|
||
|
||
undefined configure(GPUCanvasConfiguration configuration);
|
||
undefined unconfigure();
|
||
|
||
GPUTexture getCurrentTexture();
|
||
};
|
||
|
||
enum GPUCanvasAlphaMode {
|
||
"opaque",
|
||
"premultiplied",
|
||
};
|
||
|
||
dictionary GPUCanvasConfiguration {
|
||
required GPUDevice device;
|
||
required GPUTextureFormat format;
|
||
GPUTextureUsageFlags usage = 0x10; // GPUTextureUsage.RENDER_ATTACHMENT
|
||
sequence<GPUTextureFormat> viewFormats = [];
|
||
GPUCanvasAlphaMode alphaMode = "opaque";
|
||
};
|
||
|
||
enum GPUDeviceLostReason {
|
||
"unknown",
|
||
"destroyed",
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUDeviceLostInfo {
|
||
readonly attribute GPUDeviceLostReason reason;
|
||
readonly attribute DOMString message;
|
||
};
|
||
|
||
partial interface GPUDevice {
|
||
readonly attribute Promise<GPUDeviceLostInfo> lost;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUError {
|
||
readonly attribute DOMString message;
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUValidationError
|
||
: GPUError {
|
||
constructor(DOMString message);
|
||
};
|
||
|
||
[Exposed=(Window, DedicatedWorker), SecureContext]
|
||
interface GPUOutOfMemoryError
|
||
: GPUError {
|
||
constructor(DOMString message);
|
||
};
|
||
|
||
enum GPUErrorFilter {
|
||
"validation",
|
||
"out-of-memory",
|
||
};
|
||
|
||
partial interface GPUDevice {
|
||
undefined pushErrorScope(GPUErrorFilter filter);
|
||
Promise<GPUError?> popErrorScope();
|
||
};
|
||
|
||
partial interface GPUDevice {
|
||
[Exposed=(Window, DedicatedWorker)]
|
||
attribute EventHandler onuncapturederror;
|
||
};
|
||
|
||
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;
|
||
|
||
typedef unsigned long long GPUSize64Out;
|
||
typedef unsigned long GPUIntegerCoordinateOut;
|
||
typedef unsigned long GPUSize32Out;
|
||
|
||
typedef unsigned long GPUFlagsConstant;
|
||
|
||
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;
|