summaryrefslogtreecommitdiff
path: root/ext/webgpu/01_webgpu.js
diff options
context:
space:
mode:
Diffstat (limited to 'ext/webgpu/01_webgpu.js')
-rw-r--r--ext/webgpu/01_webgpu.js7087
1 files changed, 7087 insertions, 0 deletions
diff --git a/ext/webgpu/01_webgpu.js b/ext/webgpu/01_webgpu.js
new file mode 100644
index 000000000..264eaa443
--- /dev/null
+++ b/ext/webgpu/01_webgpu.js
@@ -0,0 +1,7087 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+// @ts-check
+/// <reference path="../../core/lib.deno_core.d.ts" />
+/// <reference path="../web/internal.d.ts" />
+/// <reference path="../web/lib.deno_web.d.ts" />
+/// <reference path="./lib.deno_webgpu.d.ts" />
+
+import { core, primordials } from "ext:core/mod.js";
+const ops = core.ops;
+import * as webidl from "ext:deno_webidl/00_webidl.js";
+import { EventTarget } from "ext:deno_web/02_event.js";
+import DOMException from "ext:deno_web/01_dom_exception.js";
+import { createFilteredInspectProxy } from "ext:deno_console/01_console.js";
+const {
+ ArrayBuffer,
+ ArrayBufferIsView,
+ ArrayIsArray,
+ ArrayPrototypeFilter,
+ ArrayPrototypeMap,
+ ArrayPrototypePop,
+ ArrayPrototypePush,
+ ObjectHasOwn,
+ ArrayPrototypeIncludes,
+ ArrayBufferPrototypeGetByteLength,
+ Error,
+ MathMax,
+ ObjectDefineProperty,
+ ObjectPrototypeIsPrototypeOf,
+ Promise,
+ PromisePrototypeCatch,
+ PromisePrototypeThen,
+ PromiseReject,
+ PromiseResolve,
+ SafeArrayIterator,
+ SafePromiseAll,
+ SafeSet,
+ TypedArrayPrototypeGetSymbolToStringTag,
+ TypedArrayPrototypeGetBuffer,
+ DataViewPrototypeGetBuffer,
+ SafeWeakRef,
+ SetPrototypeHas,
+ Symbol,
+ SymbolFor,
+ SymbolIterator,
+ TypeError,
+ Uint32Array,
+ Uint32ArrayPrototype,
+ Uint8Array,
+} = primordials;
+
+const _rid = Symbol("[[rid]]");
+const _size = Symbol("[[size]]");
+const _usage = Symbol("[[usage]]");
+const _state = Symbol("[[state]]");
+const _mappingRange = Symbol("[[mapping_range]]");
+const _mappedRanges = Symbol("[[mapped_ranges]]");
+const _mapMode = Symbol("[[map_mode]]");
+const _adapter = Symbol("[[adapter]]");
+const _cleanup = Symbol("[[cleanup]]");
+const _vendor = Symbol("[[vendor]]");
+const _architecture = Symbol("[[architecture]]");
+const _description = Symbol("[[description]]");
+const _limits = Symbol("[[limits]]");
+const _reason = Symbol("[[reason]]");
+const _message = Symbol("[[message]]");
+const _label = Symbol("[[label]]");
+const _device = Symbol("[[device]]");
+const _queue = Symbol("[[queue]]");
+const _views = Symbol("[[views]]");
+const _texture = Symbol("[[texture]]");
+const _encoders = Symbol("[[encoders]]");
+const _encoder = Symbol("[[encoder]]");
+const _descriptor = Symbol("[[descriptor]]");
+const _width = Symbol("[[width]]");
+const _height = Symbol("[[height]]");
+const _depthOrArrayLayers = Symbol("[[depthOrArrayLayers]]");
+const _mipLevelCount = Symbol("[[mipLevelCount]]");
+const _sampleCount = Symbol("[[sampleCount]]");
+const _dimension = Symbol("[[dimension]]");
+const _format = Symbol("[[format]]");
+const _type = Symbol("[[type]]");
+const _count = Symbol("[[count]]");
+
+/**
+ * @param {any} self
+ * @param {string} prefix
+ * @param {string} context
+ * @returns {InnerGPUDevice & {rid: number}}
+ */
+function assertDevice(self, prefix, context) {
+ const device = self[_device];
+ const deviceRid = device?.rid;
+ if (deviceRid === undefined) {
+ throw new DOMException(
+ `${prefix}: ${context} references an invalid or destroyed device.`,
+ "OperationError",
+ );
+ }
+ return device;
+}
+
+/**
+ * @param {InnerGPUDevice} self
+ * @param {any} resource
+ * @param {{prefix: string, resourceContext: string, selfContext: string}} opts
+ * @returns {InnerGPUDevice & {rid: number}}
+ */
+function assertDeviceMatch(
+ self,
+ resource,
+ { prefix, resourceContext, selfContext },
+) {
+ const resourceDevice = assertDevice(resource, prefix, resourceContext);
+ if (resourceDevice.rid !== self.rid) {
+ throw new DOMException(
+ `${prefix}: ${resourceContext} belongs to a diffent device than ${selfContext}.`,
+ "OperationError",
+ );
+ }
+ return { ...resourceDevice, rid: resourceDevice.rid };
+}
+
+/**
+ * @param {any} self
+ * @param {string} prefix
+ * @param {string} context
+ * @returns {number}
+ */
+function assertResource(self, prefix, context) {
+ const rid = self[_rid];
+ if (rid === undefined) {
+ throw new DOMException(
+ `${prefix}: ${context} an invalid or destroyed resource.`,
+ "OperationError",
+ );
+ }
+ return rid;
+}
+
+/**
+ * @param {number[] | GPUExtent3DDict} data
+ * @returns {GPUExtent3DDict}
+ */
+function normalizeGPUExtent3D(data) {
+ if (ArrayIsArray(data)) {
+ return {
+ width: data[0],
+ height: data[1] ?? 1,
+ depthOrArrayLayers: data[2] ?? 1,
+ };
+ } else {
+ return {
+ width: data.width,
+ height: data.height ?? 1,
+ depthOrArrayLayers: data.depthOrArrayLayers ?? 1,
+ };
+ }
+}
+
+/**
+ * @param {number[] | GPUOrigin3DDict} data
+ * @returns {GPUOrigin3DDict}
+ */
+function normalizeGPUOrigin3D(data) {
+ if (ArrayIsArray(data)) {
+ return {
+ x: data[0],
+ y: data[1],
+ z: data[2],
+ };
+ } else {
+ return data;
+ }
+}
+
+/**
+ * @param {number[] | GPUColor} data
+ * @returns {GPUColor}
+ */
+function normalizeGPUColor(data) {
+ if (ArrayIsArray(data)) {
+ return {
+ r: data[0],
+ g: data[1],
+ b: data[2],
+ a: data[3],
+ };
+ } else {
+ return data;
+ }
+}
+
+const illegalConstructorKey = Symbol("illegalConstructorKey");
+class GPUError extends Error {
+ constructor(key = null) {
+ super();
+ if (key !== illegalConstructorKey) {
+ webidl.illegalConstructor();
+ }
+ }
+
+ [_message];
+ get message() {
+ webidl.assertBranded(this, GPUErrorPrototype);
+ return this[_message];
+ }
+}
+const GPUErrorPrototype = GPUError.prototype;
+
+class GPUValidationError extends GPUError {
+ name = "GPUValidationError";
+ /** @param {string} message */
+ constructor(message) {
+ const prefix = "Failed to construct 'GPUValidationError'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ message = webidl.converters.DOMString(message, prefix, "Argument 1");
+ super(illegalConstructorKey);
+ this[webidl.brand] = webidl.brand;
+ this[_message] = message;
+ }
+}
+const GPUValidationErrorPrototype = GPUValidationError.prototype;
+
+class GPUOutOfMemoryError extends GPUError {
+ name = "GPUOutOfMemoryError";
+ constructor(message) {
+ const prefix = "Failed to construct 'GPUOutOfMemoryError'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ message = webidl.converters.DOMString(message, prefix, "Argument 1");
+ super(illegalConstructorKey);
+ this[webidl.brand] = webidl.brand;
+ this[_message] = message;
+ }
+}
+const GPUOutOfMemoryErrorPrototype = GPUOutOfMemoryError.prototype;
+
+class GPU {
+ [webidl.brand] = webidl.brand;
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {GPURequestAdapterOptions} options
+ */
+ async requestAdapter(options = {}) {
+ webidl.assertBranded(this, GPUPrototype);
+ options = webidl.converters.GPURequestAdapterOptions(
+ options,
+ "Failed to execute 'requestAdapter' on 'GPU'",
+ "Argument 1",
+ );
+
+ const { err, ...data } = await core.opAsync(
+ "op_webgpu_request_adapter",
+ options.powerPreference,
+ options.forceFallbackAdapter,
+ );
+
+ if (err) {
+ return null;
+ } else {
+ return createGPUAdapter(data);
+ }
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return `${this.constructor.name} ${inspect({}, inspectOptions)}`;
+ }
+}
+const GPUPrototype = GPU.prototype;
+
+/**
+ * @typedef InnerGPUAdapter
+ * @property {number} rid
+ * @property {GPUSupportedFeatures} features
+ * @property {GPUSupportedLimits} limits
+ * @property {boolean} isFallbackAdapter
+ */
+
+/**
+ * @param {InnerGPUAdapter} inner
+ * @returns {GPUAdapter}
+ */
+function createGPUAdapter(inner) {
+ /** @type {GPUAdapter} */
+ const adapter = webidl.createBranded(GPUAdapter);
+ adapter[_adapter] = {
+ ...inner,
+ features: createGPUSupportedFeatures(inner.features),
+ limits: createGPUSupportedLimits(inner.limits),
+ };
+ return adapter;
+}
+
+class GPUAdapter {
+ /** @type {InnerGPUAdapter} */
+ [_adapter];
+
+ /** @returns {GPUSupportedFeatures} */
+ get features() {
+ webidl.assertBranded(this, GPUAdapterPrototype);
+ return this[_adapter].features;
+ }
+ /** @returns {GPUSupportedLimits} */
+ get limits() {
+ webidl.assertBranded(this, GPUAdapterPrototype);
+ return this[_adapter].limits;
+ }
+ /** @returns {boolean} */
+ get isFallbackAdapter() {
+ webidl.assertBranded(this, GPUAdapterPrototype);
+ return this[_adapter].isFallbackAdapter;
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {GPUDeviceDescriptor} descriptor
+ * @returns {Promise<GPUDevice>}
+ */
+ async requestDevice(descriptor = {}) {
+ webidl.assertBranded(this, GPUAdapterPrototype);
+ const prefix = "Failed to execute 'requestDevice' on 'GPUAdapter'";
+ descriptor = webidl.converters.GPUDeviceDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const requiredFeatures = descriptor.requiredFeatures ?? [];
+ for (let i = 0; i < requiredFeatures.length; ++i) {
+ const feature = requiredFeatures[i];
+ if (
+ !SetPrototypeHas(this[_adapter].features[webidl.setlikeInner], feature)
+ ) {
+ throw new TypeError(
+ `${prefix}: requiredFeatures must be a subset of the adapter features.`,
+ );
+ }
+ }
+
+ const { rid, features, limits } = await core.opAsync(
+ "op_webgpu_request_device",
+ this[_adapter].rid,
+ descriptor.label,
+ requiredFeatures,
+ descriptor.requiredLimits,
+ );
+
+ const inner = new InnerGPUDevice({
+ rid,
+ adapter: this,
+ features: createGPUSupportedFeatures(features),
+ limits: createGPUSupportedLimits(limits),
+ });
+ return createGPUDevice(
+ descriptor.label,
+ inner,
+ createGPUQueue(descriptor.label, inner),
+ );
+ }
+
+ /**
+ * @param {string[]} unmaskHints
+ * @returns {Promise<GPUAdapterInfo>}
+ */
+ async requestAdapterInfo(unmaskHints = []) {
+ webidl.assertBranded(this, GPUAdapterPrototype);
+ const prefix = "Failed to execute 'requestAdapterInfo' on 'GPUAdapter'";
+ unmaskHints = webidl.converters["sequence<DOMString>"](
+ unmaskHints,
+ prefix,
+ "Argument 1",
+ );
+
+ const {
+ vendor,
+ architecture,
+ device,
+ description,
+ } = await core.opAsync(
+ "op_webgpu_request_adapter_info",
+ this[_adapter].rid,
+ );
+
+ const adapterInfo = webidl.createBranded(GPUAdapterInfo);
+ adapterInfo[_vendor] = ArrayPrototypeIncludes(unmaskHints, "vendor")
+ ? vendor
+ : "";
+ adapterInfo[_architecture] =
+ ArrayPrototypeIncludes(unmaskHints, "architecture") ? architecture : "";
+ adapterInfo[_device] = ArrayPrototypeIncludes(unmaskHints, "device")
+ ? device
+ : "";
+ adapterInfo[_description] =
+ ArrayPrototypeIncludes(unmaskHints, "description") ? description : "";
+ return adapterInfo;
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUAdapterPrototype, this),
+ keys: [
+ "features",
+ "limits",
+ "isFallbackAdapter",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+const GPUAdapterPrototype = GPUAdapter.prototype;
+
+class GPUAdapterInfo {
+ /** @type {string} */
+ [_vendor];
+ /** @returns {string} */
+ get vendor() {
+ webidl.assertBranded(this, GPUAdapterInfoPrototype);
+ return this[_vendor];
+ }
+
+ /** @type {string} */
+ [_architecture];
+ /** @returns {string} */
+ get architecture() {
+ webidl.assertBranded(this, GPUAdapterInfoPrototype);
+ return this[_architecture];
+ }
+
+ /** @type {string} */
+ [_device];
+ /** @returns {string} */
+ get device() {
+ webidl.assertBranded(this, GPUAdapterInfoPrototype);
+ return this[_device];
+ }
+
+ /** @type {string} */
+ [_description];
+ /** @returns {string} */
+ get description() {
+ webidl.assertBranded(this, GPUAdapterInfoPrototype);
+ return this[_description];
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUAdapterInfoPrototype, this),
+ keys: [
+ "vendor",
+ "architecture",
+ "device",
+ "description",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+const GPUAdapterInfoPrototype = GPUAdapterInfo.prototype;
+
+function createGPUSupportedLimits(limits) {
+ /** @type {GPUSupportedLimits} */
+ const adapterFeatures = webidl.createBranded(GPUSupportedLimits);
+ adapterFeatures[_limits] = limits;
+ return adapterFeatures;
+}
+
+/**
+ * @typedef InnerAdapterLimits
+ * @property {number} maxTextureDimension1D
+ * @property {number} maxTextureDimension2D
+ * @property {number} maxTextureDimension3D
+ * @property {number} maxTextureArrayLayers
+ * @property {number} maxBindGroups
+ * @property {number} maxDynamicUniformBuffersPerPipelineLayout
+ * @property {number} maxDynamicStorageBuffersPerPipelineLayout
+ * @property {number} maxSampledTexturesPerShaderStage
+ * @property {number} maxSamplersPerShaderStage
+ * @property {number} maxStorageBuffersPerShaderStage
+ * @property {number} maxStorageTexturesPerShaderStage
+ * @property {number} maxUniformBuffersPerShaderStage
+ * @property {number} maxUniformBufferBindingSize
+ * @property {number} maxStorageBufferBindingSize
+ * @property {number} minUniformBufferOffsetAlignment
+ * @property {number} minStorageBufferOffsetAlignment
+ * @property {number} maxVertexBuffers
+ * @property {number} maxVertexAttributes
+ * @property {number} maxVertexBufferArrayStride
+ * @property {number} maxInterStageShaderComponents
+ * @property {number} maxComputeWorkgroupStorageSize
+ * @property {number} maxComputeInvocationsPerWorkgroup
+ * @property {number} maxComputeWorkgroupSizeX
+ * @property {number} maxComputeWorkgroupSizeY
+ * @property {number} maxComputeWorkgroupSizeZ
+ * @property {number} maxComputeWorkgroupsPerDimension
+ */
+
+class GPUSupportedLimits {
+ /** @type {InnerAdapterLimits} */
+ [_limits];
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ get maxTextureDimension1D() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxTextureDimension1D;
+ }
+ get maxTextureDimension2D() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxTextureDimension2D;
+ }
+ get maxTextureDimension3D() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxTextureDimension3D;
+ }
+ get maxTextureArrayLayers() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxTextureArrayLayers;
+ }
+ get maxBindGroups() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxBindGroups;
+ }
+ get maxBindingsPerBindGroup() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxBindingsPerBindGroup;
+ }
+ get maxBufferSize() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxBufferSize;
+ }
+ get maxDynamicUniformBuffersPerPipelineLayout() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxDynamicUniformBuffersPerPipelineLayout;
+ }
+ get maxDynamicStorageBuffersPerPipelineLayout() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxDynamicStorageBuffersPerPipelineLayout;
+ }
+ get maxSampledTexturesPerShaderStage() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxSampledTexturesPerShaderStage;
+ }
+ get maxSamplersPerShaderStage() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxSamplersPerShaderStage;
+ }
+ get maxStorageBuffersPerShaderStage() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxStorageBuffersPerShaderStage;
+ }
+ get maxStorageTexturesPerShaderStage() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxStorageTexturesPerShaderStage;
+ }
+ get maxUniformBuffersPerShaderStage() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxUniformBuffersPerShaderStage;
+ }
+ get maxUniformBufferBindingSize() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxUniformBufferBindingSize;
+ }
+ get maxStorageBufferBindingSize() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxStorageBufferBindingSize;
+ }
+ get minUniformBufferOffsetAlignment() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].minUniformBufferOffsetAlignment;
+ }
+ get minStorageBufferOffsetAlignment() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].minStorageBufferOffsetAlignment;
+ }
+ get maxVertexBuffers() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxVertexBuffers;
+ }
+ get maxVertexAttributes() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxVertexAttributes;
+ }
+ get maxVertexBufferArrayStride() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxVertexBufferArrayStride;
+ }
+ get maxInterStageShaderComponents() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxInterStageShaderComponents;
+ }
+ get maxComputeWorkgroupStorageSize() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxComputeWorkgroupStorageSize;
+ }
+ get maxComputeInvocationsPerWorkgroup() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxComputeInvocationsPerWorkgroup;
+ }
+ get maxComputeWorkgroupSizeX() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxComputeWorkgroupSizeX;
+ }
+ get maxComputeWorkgroupSizeY() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxComputeWorkgroupSizeY;
+ }
+ get maxComputeWorkgroupSizeZ() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxComputeWorkgroupSizeZ;
+ }
+ get maxComputeWorkgroupsPerDimension() {
+ webidl.assertBranded(this, GPUSupportedLimitsPrototype);
+ return this[_limits].maxComputeWorkgroupsPerDimension;
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPUSupportedLimitsPrototype,
+ this,
+ ),
+ keys: [
+ "maxTextureDimension1D",
+ "maxTextureDimension2D",
+ "maxTextureDimension3D",
+ "maxTextureArrayLayers",
+ "maxBindGroups",
+ "maxBindingsPerBindGroup",
+ "maxBufferSize",
+ "maxDynamicUniformBuffersPerPipelineLayout",
+ "maxDynamicStorageBuffersPerPipelineLayout",
+ "maxSampledTexturesPerShaderStage",
+ "maxSamplersPerShaderStage",
+ "maxStorageBuffersPerShaderStage",
+ "maxStorageTexturesPerShaderStage",
+ "maxUniformBuffersPerShaderStage",
+ "maxUniformBufferBindingSize",
+ "maxStorageBufferBindingSize",
+ "minUniformBufferOffsetAlignment",
+ "minStorageBufferOffsetAlignment",
+ "maxVertexBuffers",
+ "maxVertexAttributes",
+ "maxVertexBufferArrayStride",
+ "maxInterStageShaderComponents",
+ "maxComputeWorkgroupStorageSize",
+ "maxComputeInvocationsPerWorkgroup",
+ "maxComputeWorkgroupSizeX",
+ "maxComputeWorkgroupSizeY",
+ "maxComputeWorkgroupSizeZ",
+ "maxComputeWorkgroupsPerDimension",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+const GPUSupportedLimitsPrototype = GPUSupportedLimits.prototype;
+
+function createGPUSupportedFeatures(features) {
+ /** @type {GPUSupportedFeatures} */
+ const supportedFeatures = webidl.createBranded(GPUSupportedFeatures);
+ supportedFeatures[webidl.setlikeInner] = new SafeSet(features);
+ webidl.setlike(
+ supportedFeatures,
+ GPUSupportedFeaturesPrototype,
+ true,
+ );
+ return supportedFeatures;
+}
+
+class GPUSupportedFeatures {
+ constructor() {
+ webidl.illegalConstructor();
+ }
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ if (ObjectPrototypeIsPrototypeOf(GPUSupportedFeaturesPrototype, this)) {
+ return `${this.constructor.name} ${
+ // deno-lint-ignore prefer-primordials
+ inspect([...this], inspectOptions)}`;
+ } else {
+ return `${this.constructor.name} ${inspect({}, inspectOptions)}`;
+ }
+ }
+}
+
+const GPUSupportedFeaturesPrototype = GPUSupportedFeatures.prototype;
+
+/**
+ * @param {string | undefined} reason
+ * @param {string} message
+ * @returns {GPUDeviceLostInfo}
+ */
+function createGPUDeviceLostInfo(reason, message) {
+ /** @type {GPUDeviceLostInfo} */
+ const deviceLostInfo = webidl.createBranded(GPUDeviceLostInfo);
+ deviceLostInfo[_reason] = reason ?? "unknown";
+ deviceLostInfo[_message] = message;
+ return deviceLostInfo;
+}
+
+class GPUDeviceLostInfo {
+ /** @type {string} */
+ [_reason];
+ /** @type {string} */
+ [_message];
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ get reason() {
+ webidl.assertBranded(this, GPUDeviceLostInfoPrototype);
+ return this[_reason];
+ }
+ get message() {
+ webidl.assertBranded(this, GPUDeviceLostInfoPrototype);
+ return this[_message];
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPUDeviceLostInfoPrototype,
+ this,
+ ),
+ keys: [
+ "reason",
+ "message",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+
+const GPUDeviceLostInfoPrototype = GPUDeviceLostInfo.prototype;
+
+/**
+ * @param {string} name
+ * @param {any} type
+ */
+function GPUObjectBaseMixin(name, type) {
+ type.prototype[_label] = null;
+ ObjectDefineProperty(type.prototype, "label", {
+ /**
+ * @return {string | null}
+ */
+ get() {
+ webidl.assertBranded(this, type.prototype);
+ return this[_label];
+ },
+ /**
+ * @param {string | null} label
+ */
+ set(label) {
+ webidl.assertBranded(this, type.prototype);
+ label = webidl.converters["UVString?"](
+ label,
+ `Failed to set 'label' on '${name}'`,
+ "Argument 1",
+ );
+ this[_label] = label;
+ },
+ });
+}
+
+/**
+ * @typedef ErrorScope
+ * @property {string} filter
+ * @property {Promise<void>[]} operations
+ */
+
+/**
+ * @typedef InnerGPUDeviceOptions
+ * @property {GPUAdapter} adapter
+ * @property {number | undefined} rid
+ * @property {GPUSupportedFeatures} features
+ * @property {GPUSupportedLimits} limits
+ */
+
+class InnerGPUDevice {
+ /** @type {GPUAdapter} */
+ adapter;
+ /** @type {number | undefined} */
+ rid;
+ /** @type {GPUSupportedFeatures} */
+ features;
+ /** @type {GPUSupportedLimits} */
+ limits;
+ /** @type {SafeWeakRef<any>[]} */
+ resources;
+ /** @type {boolean} */
+ isLost;
+ /** @type {Promise<GPUDeviceLostInfo>} */
+ lost;
+ /** @type {(info: GPUDeviceLostInfo) => void} */
+ resolveLost;
+ /** @type {ErrorScope[]} */
+ errorScopeStack;
+
+ /**
+ * @param {InnerGPUDeviceOptions} options
+ */
+ constructor(options) {
+ this.adapter = options.adapter;
+ this.rid = options.rid;
+ this.features = options.features;
+ this.limits = options.limits;
+ this.resources = [];
+ this.isLost = false;
+ this.resolveLost = () => {};
+ this.lost = new Promise((resolve) => {
+ this.resolveLost = resolve;
+ });
+ this.errorScopeStack = [];
+ }
+
+ /** @param {any} resource */
+ trackResource(resource) {
+ ArrayPrototypePush(this.resources, new SafeWeakRef(resource));
+ }
+
+ /** @param {{ type: string, value: string | null } | undefined} err */
+ pushError(err) {
+ this.pushErrorPromise(PromiseResolve(err));
+ }
+
+ /** @param {Promise<{ type: string, value: string | null } | undefined>} promise */
+ pushErrorPromise(promise) {
+ const operation = PromisePrototypeThen(promise, (err) => {
+ if (err) {
+ switch (err.type) {
+ case "lost":
+ this.isLost = true;
+ this.resolveLost(
+ createGPUDeviceLostInfo(undefined, "device was lost"),
+ );
+ break;
+ case "validation":
+ return PromiseReject(
+ new GPUValidationError(err.value ?? "validation error"),
+ );
+ case "out-of-memory":
+ return PromiseReject(new GPUOutOfMemoryError());
+ }
+ }
+ });
+
+ const validationStack = ArrayPrototypeFilter(
+ this.errorScopeStack,
+ ({ filter }) => filter == "validation",
+ );
+ const validationScope = validationStack[validationStack.length - 1];
+ const validationFilteredPromise = PromisePrototypeCatch(
+ operation,
+ (err) => {
+ if (ObjectPrototypeIsPrototypeOf(GPUValidationErrorPrototype, err)) {
+ return PromiseReject(err);
+ }
+ return PromiseResolve();
+ },
+ );
+ if (validationScope) {
+ ArrayPrototypePush(
+ validationScope.operations,
+ validationFilteredPromise,
+ );
+ } else {
+ PromisePrototypeCatch(validationFilteredPromise, () => {
+ // TODO(lucacasonato): emit an UncapturedErrorEvent
+ });
+ }
+ // prevent uncaptured promise rejections
+ PromisePrototypeCatch(validationFilteredPromise, (_err) => {});
+
+ const oomStack = ArrayPrototypeFilter(
+ this.errorScopeStack,
+ ({ filter }) => filter == "out-of-memory",
+ );
+ const oomScope = oomStack[oomStack.length - 1];
+ const oomFilteredPromise = PromisePrototypeCatch(operation, (err) => {
+ if (ObjectPrototypeIsPrototypeOf(GPUOutOfMemoryErrorPrototype, err)) {
+ return PromiseReject(err);
+ }
+ return PromiseResolve();
+ });
+ if (oomScope) {
+ ArrayPrototypePush(oomScope.operations, oomFilteredPromise);
+ } else {
+ PromisePrototypeCatch(oomFilteredPromise, () => {
+ // TODO(lucacasonato): emit an UncapturedErrorEvent
+ });
+ }
+ // prevent uncaptured promise rejections
+ PromisePrototypeCatch(oomFilteredPromise, (_err) => {});
+ }
+}
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} inner
+ * @param {GPUQueue} queue
+ * @returns {GPUDevice}
+ */
+function createGPUDevice(label, inner, queue) {
+ /** @type {GPUDevice} */
+ const device = webidl.createBranded(GPUDevice);
+ device[_label] = label;
+ device[_device] = inner;
+ device[_queue] = queue;
+ return device;
+}
+
+class GPUDevice extends EventTarget {
+ /** @type {InnerGPUDevice} */
+ [_device];
+
+ /** @type {GPUQueue} */
+ [_queue];
+
+ [_cleanup]() {
+ const device = this[_device];
+ const resources = device.resources;
+ while (resources.length > 0) {
+ const resource = ArrayPrototypePop(resources)?.deref();
+ if (resource) {
+ resource[_cleanup]();
+ }
+ }
+ const rid = device.rid;
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ device.rid = undefined;
+ }
+ }
+
+ get features() {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ return this[_device].features;
+ }
+ get limits() {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ return this[_device].limits;
+ }
+ get queue() {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ return this[_queue];
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ super();
+ }
+
+ destroy() {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ this[_cleanup]();
+ }
+
+ /**
+ * @param {GPUBufferDescriptor} descriptor
+ * @returns {GPUBuffer}
+ */
+ createBuffer(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createBuffer' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPUBufferDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_create_buffer(
+ device.rid,
+ descriptor.label,
+ descriptor.size,
+ descriptor.usage,
+ descriptor.mappedAtCreation,
+ );
+ device.pushError(err);
+ /** @type {CreateGPUBufferOptions} */
+ let options;
+ if (descriptor.mappedAtCreation) {
+ options = {
+ mapping: new ArrayBuffer(descriptor.size),
+ mappingRange: [0, descriptor.size],
+ mappedRanges: [],
+ state: "mapped at creation",
+ };
+ } else {
+ options = {
+ mapping: null,
+ mappedRanges: null,
+ mappingRange: null,
+ state: "unmapped",
+ };
+ }
+ const buffer = createGPUBuffer(
+ descriptor.label,
+ device,
+ rid,
+ descriptor.size,
+ descriptor.usage,
+ options,
+ );
+ device.trackResource(buffer);
+ return buffer;
+ }
+
+ /**
+ * @param {GPUTextureDescriptor} descriptor
+ * @returns {GPUTexture}
+ */
+ createTexture(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createTexture' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPUTextureDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_create_texture({
+ deviceRid: device.rid,
+ ...descriptor,
+ size: normalizeGPUExtent3D(descriptor.size),
+ });
+ device.pushError(err);
+
+ const texture = createGPUTexture(
+ descriptor,
+ device,
+ rid,
+ );
+ device.trackResource(texture);
+ return texture;
+ }
+
+ /**
+ * @param {GPUSamplerDescriptor} descriptor
+ * @returns {GPUSampler}
+ */
+ createSampler(descriptor = {}) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createSampler' on 'GPUDevice'";
+ descriptor = webidl.converters.GPUSamplerDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_create_sampler({
+ deviceRid: device.rid,
+ ...descriptor,
+ });
+ device.pushError(err);
+
+ const sampler = createGPUSampler(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(sampler);
+ return sampler;
+ }
+
+ /**
+ * @param {GPUBindGroupLayoutDescriptor} descriptor
+ * @returns {GPUBindGroupLayout}
+ */
+ createBindGroupLayout(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createBindGroupLayout' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPUBindGroupLayoutDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ for (let i = 0; i < descriptor.entries.length; ++i) {
+ const entry = descriptor.entries[i];
+
+ let j = 0;
+ // deno-lint-ignore prefer-primordials
+ if (entry.buffer) j++;
+ if (entry.sampler) j++;
+ if (entry.texture) j++;
+ if (entry.storageTexture) j++;
+
+ if (j !== 1) {
+ throw new Error(); // TODO(@crowlKats): correct error
+ }
+ }
+
+ const { rid, err } = ops.op_webgpu_create_bind_group_layout(
+ device.rid,
+ descriptor.label,
+ descriptor.entries,
+ );
+ device.pushError(err);
+
+ const bindGroupLayout = createGPUBindGroupLayout(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(bindGroupLayout);
+ return bindGroupLayout;
+ }
+
+ /**
+ * @param {GPUPipelineLayoutDescriptor} descriptor
+ * @returns {GPUPipelineLayout}
+ */
+ createPipelineLayout(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createPipelineLayout' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPUPipelineLayoutDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const bindGroupLayouts = ArrayPrototypeMap(
+ descriptor.bindGroupLayouts,
+ (layout, i) => {
+ const context = `bind group layout ${i + 1}`;
+ const rid = assertResource(layout, prefix, context);
+ assertDeviceMatch(device, layout, {
+ prefix,
+ selfContext: "this",
+ resourceContext: context,
+ });
+ return rid;
+ },
+ );
+ const { rid, err } = ops.op_webgpu_create_pipeline_layout(
+ device.rid,
+ descriptor.label,
+ bindGroupLayouts,
+ );
+ device.pushError(err);
+
+ const pipelineLayout = createGPUPipelineLayout(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(pipelineLayout);
+ return pipelineLayout;
+ }
+
+ /**
+ * @param {GPUBindGroupDescriptor} descriptor
+ * @returns {GPUBindGroup}
+ */
+ createBindGroup(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createBindGroup' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPUBindGroupDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const layout = assertResource(descriptor.layout, prefix, "layout");
+ assertDeviceMatch(device, descriptor.layout, {
+ prefix,
+ resourceContext: "layout",
+ selfContext: "this",
+ });
+ const entries = ArrayPrototypeMap(descriptor.entries, (entry, i) => {
+ const context = `entry ${i + 1}`;
+ const resource = entry.resource;
+ if (ObjectPrototypeIsPrototypeOf(GPUSamplerPrototype, resource)) {
+ const rid = assertResource(resource, prefix, context);
+ assertDeviceMatch(device, resource, {
+ prefix,
+ resourceContext: context,
+ selfContext: "this",
+ });
+ return {
+ binding: entry.binding,
+ kind: "GPUSampler",
+ resource: rid,
+ };
+ } else if (
+ ObjectPrototypeIsPrototypeOf(GPUTextureViewPrototype, resource)
+ ) {
+ const rid = assertResource(resource, prefix, context);
+ assertResource(resource[_texture], prefix, context);
+ assertDeviceMatch(device, resource[_texture], {
+ prefix,
+ resourceContext: context,
+ selfContext: "this",
+ });
+ return {
+ binding: entry.binding,
+ kind: "GPUTextureView",
+ resource: rid,
+ };
+ } else {
+ // deno-lint-ignore prefer-primordials
+ const rid = assertResource(resource.buffer, prefix, context);
+ // deno-lint-ignore prefer-primordials
+ assertDeviceMatch(device, resource.buffer, {
+ prefix,
+ resourceContext: context,
+ selfContext: "this",
+ });
+ return {
+ binding: entry.binding,
+ kind: "GPUBufferBinding",
+ resource: rid,
+ offset: entry.resource.offset,
+ size: entry.resource.size,
+ };
+ }
+ });
+
+ const { rid, err } = ops.op_webgpu_create_bind_group(
+ device.rid,
+ descriptor.label,
+ layout,
+ entries,
+ );
+ device.pushError(err);
+
+ const bindGroup = createGPUBindGroup(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(bindGroup);
+ return bindGroup;
+ }
+
+ /**
+ * @param {GPUShaderModuleDescriptor} descriptor
+ */
+ createShaderModule(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createShaderModule' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPUShaderModuleDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_create_shader_module(
+ device.rid,
+ descriptor.label,
+ descriptor.code,
+ );
+ device.pushError(err);
+
+ const shaderModule = createGPUShaderModule(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(shaderModule);
+ return shaderModule;
+ }
+
+ /**
+ * @param {GPUComputePipelineDescriptor} descriptor
+ * @returns {GPUComputePipeline}
+ */
+ createComputePipeline(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createComputePipeline' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPUComputePipelineDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ let layout = descriptor.layout;
+ if (typeof descriptor.layout !== "string") {
+ const context = "layout";
+ layout = assertResource(descriptor.layout, prefix, context);
+ assertDeviceMatch(device, descriptor.layout, {
+ prefix,
+ resourceContext: context,
+ selfContext: "this",
+ });
+ }
+ const module = assertResource(
+ descriptor.compute.module,
+ prefix,
+ "compute shader module",
+ );
+ assertDeviceMatch(device, descriptor.compute.module, {
+ prefix,
+ resourceContext: "compute shader module",
+ selfContext: "this",
+ });
+
+ const { rid, err } = ops.op_webgpu_create_compute_pipeline(
+ device.rid,
+ descriptor.label,
+ layout,
+ {
+ module,
+ entryPoint: descriptor.compute.entryPoint,
+ constants: descriptor.compute.constants,
+ },
+ );
+ device.pushError(err);
+
+ const computePipeline = createGPUComputePipeline(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(computePipeline);
+ return computePipeline;
+ }
+
+ /**
+ * @param {GPURenderPipelineDescriptor} descriptor
+ * @returns {GPURenderPipeline}
+ */
+ createRenderPipeline(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createRenderPipeline' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPURenderPipelineDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ let layout = descriptor.layout;
+ if (typeof descriptor.layout !== "string") {
+ const context = "layout";
+ layout = assertResource(descriptor.layout, prefix, context);
+ assertDeviceMatch(device, descriptor.layout, {
+ prefix,
+ resourceContext: context,
+ selfContext: "this",
+ });
+ }
+ const module = assertResource(
+ descriptor.vertex.module,
+ prefix,
+ "vertex shader module",
+ );
+ assertDeviceMatch(device, descriptor.vertex.module, {
+ prefix,
+ resourceContext: "vertex shader module",
+ selfContext: "this",
+ });
+ let fragment = undefined;
+ if (descriptor.fragment) {
+ const module = assertResource(
+ descriptor.fragment.module,
+ prefix,
+ "fragment shader module",
+ );
+ assertDeviceMatch(device, descriptor.fragment.module, {
+ prefix,
+ resourceContext: "fragment shader module",
+ selfContext: "this",
+ });
+ fragment = {
+ module,
+ entryPoint: descriptor.fragment.entryPoint,
+ targets: descriptor.fragment.targets,
+ };
+ }
+
+ const { rid, err } = ops.op_webgpu_create_render_pipeline({
+ deviceRid: device.rid,
+ label: descriptor.label,
+ layout,
+ vertex: {
+ module,
+ entryPoint: descriptor.vertex.entryPoint,
+ buffers: descriptor.vertex.buffers,
+ },
+ primitive: descriptor.primitive,
+ depthStencil: descriptor.depthStencil,
+ multisample: descriptor.multisample,
+ fragment,
+ });
+ device.pushError(err);
+
+ const renderPipeline = createGPURenderPipeline(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(renderPipeline);
+ return renderPipeline;
+ }
+
+ createComputePipelineAsync(descriptor) {
+ // TODO(lucacasonato): this should be real async
+ return PromiseResolve(this.createComputePipeline(descriptor));
+ }
+
+ createRenderPipelineAsync(descriptor) {
+ // TODO(lucacasonato): this should be real async
+ return PromiseResolve(this.createRenderPipeline(descriptor));
+ }
+
+ /**
+ * @param {GPUCommandEncoderDescriptor} descriptor
+ * @returns {GPUCommandEncoder}
+ */
+ createCommandEncoder(descriptor = {}) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createCommandEncoder' on 'GPUDevice'";
+ descriptor = webidl.converters.GPUCommandEncoderDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_create_command_encoder(
+ device.rid,
+ descriptor.label,
+ );
+ device.pushError(err);
+
+ const commandEncoder = createGPUCommandEncoder(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(commandEncoder);
+ return commandEncoder;
+ }
+
+ /**
+ * @param {GPURenderBundleEncoderDescriptor} descriptor
+ * @returns {GPURenderBundleEncoder}
+ */
+ createRenderBundleEncoder(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix =
+ "Failed to execute 'createRenderBundleEncoder' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, { prefix });
+ descriptor = webidl.converters.GPURenderBundleEncoderDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_create_render_bundle_encoder({
+ deviceRid: device.rid,
+ ...descriptor,
+ });
+ device.pushError(err);
+
+ const renderBundleEncoder = createGPURenderBundleEncoder(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(renderBundleEncoder);
+ return renderBundleEncoder;
+ }
+
+ /**
+ * @param {GPUQuerySetDescriptor} descriptor
+ * @returns {GPUQuerySet}
+ */
+ createQuerySet(descriptor) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'createQuerySet' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPUQuerySetDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_create_query_set({
+ deviceRid: device.rid,
+ ...descriptor,
+ });
+ device.pushError(err);
+
+ const querySet = createGPUQuerySet(
+ descriptor.label,
+ device,
+ rid,
+ descriptor,
+ );
+ device.trackResource(querySet);
+ return querySet;
+ }
+
+ get lost() {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const device = this[_device];
+ if (!device) {
+ return PromiseResolve(true);
+ }
+ if (device.rid === undefined) {
+ return PromiseResolve(true);
+ }
+ return device.lost;
+ }
+
+ /**
+ * @param {GPUErrorFilter} filter
+ */
+ pushErrorScope(filter) {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'pushErrorScope' on 'GPUDevice'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ filter = webidl.converters.GPUErrorFilter(filter, prefix, "Argument 1");
+ const device = assertDevice(this, prefix, "this");
+ ArrayPrototypePush(device.errorScopeStack, { filter, operations: [] });
+ }
+
+ /**
+ * @returns {Promise<GPUError | null>}
+ */
+ // deno-lint-ignore require-await
+ async popErrorScope() {
+ webidl.assertBranded(this, GPUDevicePrototype);
+ const prefix = "Failed to execute 'popErrorScope' on 'GPUDevice'";
+ const device = assertDevice(this, prefix, "this");
+ if (device.isLost) {
+ throw new DOMException("Device has been lost.", "OperationError");
+ }
+ const scope = ArrayPrototypePop(device.errorScopeStack);
+ if (!scope) {
+ throw new DOMException(
+ "There are no error scopes on the error scope stack.",
+ "OperationError",
+ );
+ }
+ const operations = SafePromiseAll(scope.operations);
+ return PromisePrototypeThen(
+ operations,
+ () => PromiseResolve(null),
+ (err) => PromiseResolve(err),
+ );
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUDevicePrototype, this),
+ keys: [
+ "features",
+ "label",
+ "limits",
+ "lost",
+ "queue",
+ // TODO(lucacasonato): emit an UncapturedErrorEvent
+ // "onuncapturederror"
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUDevice", GPUDevice);
+const GPUDevicePrototype = GPUDevice.prototype;
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @returns {GPUQueue}
+ */
+function createGPUQueue(label, device) {
+ /** @type {GPUQueue} */
+ const queue = webidl.createBranded(GPUQueue);
+ queue[_label] = label;
+ queue[_device] = device;
+ return queue;
+}
+
+class GPUQueue {
+ /** @type {InnerGPUDevice} */
+ [_device];
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {GPUCommandBuffer[]} commandBuffers
+ */
+ submit(commandBuffers) {
+ webidl.assertBranded(this, GPUQueuePrototype);
+ const prefix = "Failed to execute 'submit' on 'GPUQueue'";
+ webidl.requiredArguments(arguments.length, 1, {
+ prefix,
+ });
+ commandBuffers = webidl.converters["sequence<GPUCommandBuffer>"](
+ commandBuffers,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const commandBufferRids = ArrayPrototypeMap(
+ commandBuffers,
+ (buffer, i) => {
+ const context = `command buffer ${i + 1}`;
+ const rid = assertResource(buffer, prefix, context);
+ assertDeviceMatch(device, buffer, {
+ prefix,
+ selfContext: "this",
+ resourceContext: context,
+ });
+ return rid;
+ },
+ );
+ const { err } = ops.op_webgpu_queue_submit(device.rid, commandBufferRids);
+ for (let i = 0; i < commandBuffers.length; ++i) {
+ commandBuffers[i][_rid] = undefined;
+ }
+ device.pushError(err);
+ }
+
+ onSubmittedWorkDone() {
+ webidl.assertBranded(this, GPUQueuePrototype);
+ return PromiseResolve();
+ }
+
+ /**
+ * @param {GPUBuffer} buffer
+ * @param {number} bufferOffset
+ * @param {BufferSource} data
+ * @param {number} [dataOffset]
+ * @param {number} [size]
+ */
+ writeBuffer(buffer, bufferOffset, data, dataOffset = 0, size) {
+ webidl.assertBranded(this, GPUQueuePrototype);
+ const prefix = "Failed to execute 'writeBuffer' on 'GPUQueue'";
+ webidl.requiredArguments(arguments.length, 3, prefix);
+ buffer = webidl.converters["GPUBuffer"](buffer, prefix, "Argument 1");
+ bufferOffset = webidl.converters["GPUSize64"](
+ bufferOffset,
+ prefix,
+ "Argument 2",
+ );
+ data = webidl.converters.BufferSource(data, prefix, "Argument 3");
+ dataOffset = webidl.converters["GPUSize64"](
+ dataOffset,
+ prefix,
+ "Argument 4",
+ );
+ size = size === undefined
+ ? undefined
+ : webidl.converters.GPUSize64(size, prefix, "Argument 5");
+ const device = assertDevice(this, prefix, "this");
+ const bufferRid = assertResource(buffer, prefix, "Argument 1");
+ assertDeviceMatch(device, buffer, {
+ prefix,
+ selfContext: "this",
+ resourceContext: "Argument 1",
+ });
+ /** @type {ArrayBufferLike} */
+ let abLike = data;
+ if (ArrayBufferIsView(data)) {
+ if (TypedArrayPrototypeGetSymbolToStringTag(data) !== undefined) {
+ // TypedArray
+ abLike = TypedArrayPrototypeGetBuffer(
+ /** @type {Uint8Array} */ (data),
+ );
+ } else {
+ // DataView
+ abLike = DataViewPrototypeGetBuffer(/** @type {DataView} */ (data));
+ }
+ }
+ const { err } = ops.op_webgpu_write_buffer(
+ device.rid,
+ bufferRid,
+ bufferOffset,
+ dataOffset,
+ size,
+ new Uint8Array(abLike),
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {GPUImageCopyTexture} destination
+ * @param {BufferSource} data
+ * @param {GPUImageDataLayout} dataLayout
+ * @param {GPUExtent3D} size
+ */
+ writeTexture(destination, data, dataLayout, size) {
+ webidl.assertBranded(this, GPUQueuePrototype);
+ const prefix = "Failed to execute 'writeTexture' on 'GPUQueue'";
+ webidl.requiredArguments(arguments.length, 4, prefix);
+ destination = webidl.converters.GPUImageCopyTexture(
+ destination,
+ prefix,
+ "Argument 1",
+ );
+ data = webidl.converters.BufferSource(data, prefix, "Argument 2");
+ dataLayout = webidl.converters.GPUImageDataLayout(
+ dataLayout,
+ prefix,
+ "Argument 3",
+ );
+ size = webidl.converters.GPUExtent3D(size, prefix, "Argument 4");
+ const device = assertDevice(this, prefix, "this");
+ const textureRid = assertResource(destination.texture, prefix, "texture");
+ assertDeviceMatch(device, destination.texture, {
+ prefix,
+ selfContext: "this",
+ resourceContext: "texture",
+ });
+
+ /** @type {ArrayBufferLike} */
+ let abLike = data;
+ if (ArrayBufferIsView(data)) {
+ if (TypedArrayPrototypeGetSymbolToStringTag(data) !== undefined) {
+ // TypedArray
+ abLike = TypedArrayPrototypeGetBuffer(
+ /** @type {Uint8Array} */ (data),
+ );
+ } else {
+ // DataView
+ abLike = DataViewPrototypeGetBuffer(/** @type {DataView} */ (data));
+ }
+ }
+
+ const { err } = ops.op_webgpu_write_texture(
+ device.rid,
+ {
+ texture: textureRid,
+ mipLevel: destination.mipLevel,
+ origin: destination.origin
+ ? normalizeGPUOrigin3D(destination.origin)
+ : undefined,
+ aspect: destination.aspect,
+ },
+ dataLayout,
+ normalizeGPUExtent3D(size),
+ new Uint8Array(abLike),
+ );
+ device.pushError(err);
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUQueuePrototype, this),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUQueue", GPUQueue);
+const GPUQueuePrototype = GPUQueue.prototype;
+
+/**
+ * @typedef CreateGPUBufferOptions
+ * @property {ArrayBuffer | null} mapping
+ * @property {number[] | null} mappingRange
+ * @property {[ArrayBuffer, number, number][] | null} mappedRanges
+ * @property {"mapped" | "mapped at creation" | "mapped pending" | "unmapped" | "destroy" } state
+ */
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @param {number} size
+ * @param {number} usage
+ * @param {CreateGPUBufferOptions} options
+ * @returns {GPUBuffer}
+ */
+function createGPUBuffer(label, device, rid, size, usage, options) {
+ /** @type {GPUBuffer} */
+ const buffer = webidl.createBranded(GPUBuffer);
+ buffer[_label] = label;
+ buffer[_device] = device;
+ buffer[_rid] = rid;
+ buffer[_size] = size;
+ buffer[_usage] = usage;
+ buffer[_mappingRange] = options.mappingRange;
+ buffer[_mappedRanges] = options.mappedRanges;
+ buffer[_state] = options.state;
+ return buffer;
+}
+
+class GPUBuffer {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number} */
+ [_rid];
+ /** @type {number} */
+ [_size];
+ /** @type {number} */
+ [_usage];
+ /** @type {"mapped" | "mapped at creation" | "pending" | "unmapped" | "destroy"} */
+ [_state];
+ /** @type {[number, number] | null} */
+ [_mappingRange];
+ /** @type {[ArrayBuffer, number, number][] | null} */
+ [_mappedRanges];
+ /** @type {number} */
+ [_mapMode];
+
+ [_cleanup]() {
+ const mappedRanges = this[_mappedRanges];
+ if (mappedRanges) {
+ while (mappedRanges.length > 0) {
+ const mappedRange = ArrayPrototypePop(mappedRanges);
+ if (mappedRange !== undefined) {
+ core.close(mappedRange[1]);
+ }
+ }
+ }
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ this[_state] = "destroy";
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ get size() {
+ webidl.assertBranded(this, GPUBufferPrototype);
+ return this[_size];
+ }
+
+ get usage() {
+ webidl.assertBranded(this, GPUBufferPrototype);
+ return this[_usage];
+ }
+
+ get mapState() {
+ webidl.assertBranded(this, GPUBufferPrototype);
+ const state = this[_state];
+ if (state === "mapped at creation") {
+ return "mapped";
+ } else {
+ return state;
+ }
+ }
+
+ /**
+ * @param {number} mode
+ * @param {number} offset
+ * @param {number} [size]
+ */
+ async mapAsync(mode, offset = 0, size) {
+ webidl.assertBranded(this, GPUBufferPrototype);
+ const prefix = "Failed to execute 'mapAsync' on 'GPUBuffer'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ mode = webidl.converters.GPUMapModeFlags(mode, prefix, "Argument 1");
+ offset = webidl.converters.GPUSize64(offset, prefix, "Argument 2");
+ size = size === undefined
+ ? undefined
+ : webidl.converters.GPUSize64(size, prefix, "Argument 3");
+ const device = assertDevice(this, prefix, "this");
+ const bufferRid = assertResource(this, prefix, "this");
+ /** @type {number} */
+ let rangeSize;
+ if (size === undefined) {
+ rangeSize = MathMax(0, this[_size] - offset);
+ } else {
+ rangeSize = this[_size];
+ }
+ if ((offset % 8) !== 0) {
+ throw new DOMException(
+ `${prefix}: offset must be a multiple of 8.`,
+ "OperationError",
+ );
+ }
+ if ((rangeSize % 4) !== 0) {
+ throw new DOMException(
+ `${prefix}: rangeSize must be a multiple of 4.`,
+ "OperationError",
+ );
+ }
+ if ((offset + rangeSize) > this[_size]) {
+ throw new DOMException(
+ `${prefix}: offset + rangeSize must be less than or equal to buffer size.`,
+ "OperationError",
+ );
+ }
+ if (this[_state] !== "unmapped") {
+ throw new DOMException(
+ `${prefix}: GPUBuffer is not currently unmapped.`,
+ "OperationError",
+ );
+ }
+ const readMode = (mode & 0x0001) === 0x0001;
+ const writeMode = (mode & 0x0002) === 0x0002;
+ if ((readMode && writeMode) || (!readMode && !writeMode)) {
+ throw new DOMException(
+ `${prefix}: exactly one of READ or WRITE map mode must be set.`,
+ "OperationError",
+ );
+ }
+ if (readMode && !((this[_usage] && 0x0001) === 0x0001)) {
+ throw new DOMException(
+ `${prefix}: READ map mode not valid because buffer does not have MAP_READ usage.`,
+ "OperationError",
+ );
+ }
+ if (writeMode && !((this[_usage] && 0x0002) === 0x0002)) {
+ throw new DOMException(
+ `${prefix}: WRITE map mode not valid because buffer does not have MAP_WRITE usage.`,
+ "OperationError",
+ );
+ }
+
+ this[_mapMode] = mode;
+ this[_state] = "pending";
+ const promise = PromisePrototypeThen(
+ core.opAsync(
+ "op_webgpu_buffer_get_map_async",
+ bufferRid,
+ device.rid,
+ mode,
+ offset,
+ rangeSize,
+ ),
+ ({ err }) => err,
+ );
+ device.pushErrorPromise(promise);
+ const err = await promise;
+ if (err) {
+ throw new DOMException("validation error occured", "OperationError");
+ }
+ this[_state] = "mapped";
+ this[_mappingRange] = [offset, offset + rangeSize];
+ /** @type {[ArrayBuffer, number, number][] | null} */
+ this[_mappedRanges] = [];
+ }
+
+ /**
+ * @param {number} offset
+ * @param {number} size
+ */
+ getMappedRange(offset = 0, size) {
+ webidl.assertBranded(this, GPUBufferPrototype);
+ const prefix = "Failed to execute 'getMappedRange' on 'GPUBuffer'";
+ offset = webidl.converters.GPUSize64(offset, prefix, "Argument 1");
+ if (size !== undefined) {
+ size = webidl.converters.GPUSize64(size, prefix, "Argument 2");
+ }
+ assertDevice(this, prefix, "this");
+ const bufferRid = assertResource(this, prefix, "this");
+ /** @type {number} */
+ let rangeSize;
+ if (size === undefined) {
+ rangeSize = MathMax(0, this[_size] - offset);
+ } else {
+ rangeSize = size;
+ }
+
+ const mappedRanges = this[_mappedRanges];
+ if (!mappedRanges) {
+ throw new DOMException(`${prefix}: invalid state.`, "OperationError");
+ }
+ for (let i = 0; i < mappedRanges.length; ++i) {
+ const { 0: buffer, 1: _rid, 2: start } = mappedRanges[i];
+ // TODO(lucacasonato): is this logic correct?
+ const end = start + ArrayBufferPrototypeGetByteLength(buffer);
+ if (
+ (start >= offset && start < (offset + rangeSize)) ||
+ (end >= offset && end < (offset + rangeSize))
+ ) {
+ throw new DOMException(
+ `${prefix}: requested buffer overlaps with another mapped range.`,
+ "OperationError",
+ );
+ }
+ }
+
+ const buffer = new ArrayBuffer(rangeSize);
+ const { rid } = ops.op_webgpu_buffer_get_mapped_range(
+ bufferRid,
+ offset,
+ size,
+ new Uint8Array(buffer),
+ );
+
+ ArrayPrototypePush(mappedRanges, [buffer, rid, offset]);
+
+ return buffer;
+ }
+
+ unmap() {
+ webidl.assertBranded(this, GPUBufferPrototype);
+ const prefix = "Failed to execute 'unmap' on 'GPUBuffer'";
+ const device = assertDevice(this, prefix, "this");
+ const bufferRid = assertResource(this, prefix, "this");
+ if (this[_state] === "unmapped" || this[_state] === "destroyed") {
+ throw new DOMException(
+ `${prefix}: buffer is not ready to be unmapped.`,
+ "OperationError",
+ );
+ }
+ if (this[_state] === "pending") {
+ // TODO(lucacasonato): this is not spec compliant.
+ throw new DOMException(
+ `${prefix}: can not unmap while mapping. This is a Deno limitation.`,
+ "OperationError",
+ );
+ } else if (
+ this[_state] === "mapped" || this[_state] === "mapped at creation"
+ ) {
+ /** @type {boolean} */
+ let write = false;
+ if (this[_state] === "mapped at creation") {
+ write = true;
+ } else if (this[_state] === "mapped") {
+ const mapMode = this[_mapMode];
+ if (mapMode === undefined) {
+ throw new DOMException(
+ `${prefix}: invalid state.`,
+ "OperationError",
+ );
+ }
+ if ((mapMode & 0x0002) === 0x0002) {
+ write = true;
+ }
+ }
+
+ const mappedRanges = this[_mappedRanges];
+ if (!mappedRanges) {
+ throw new DOMException(`${prefix}: invalid state.`, "OperationError");
+ }
+ for (let i = 0; i < mappedRanges.length; ++i) {
+ const { 0: buffer, 1: mappedRid } = mappedRanges[i];
+ const { err } = ops.op_webgpu_buffer_unmap(
+ bufferRid,
+ mappedRid,
+ ...new SafeArrayIterator(write ? [new Uint8Array(buffer)] : []),
+ );
+ device.pushError(err);
+ if (err) return;
+ }
+ this[_mappingRange] = null;
+ this[_mappedRanges] = null;
+ }
+
+ this[_state] = "unmapped";
+ }
+
+ destroy() {
+ webidl.assertBranded(this, GPUBufferPrototype);
+ this[_cleanup]();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUBufferPrototype, this),
+ keys: [
+ "label",
+ "mapState",
+ "size",
+ "usage",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUBuffer", GPUBuffer);
+const GPUBufferPrototype = GPUBuffer.prototype;
+
+class GPUBufferUsage {
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ static get MAP_READ() {
+ return 0x0001;
+ }
+ static get MAP_WRITE() {
+ return 0x0002;
+ }
+ static get COPY_SRC() {
+ return 0x0004;
+ }
+ static get COPY_DST() {
+ return 0x0008;
+ }
+ static get INDEX() {
+ return 0x0010;
+ }
+ static get VERTEX() {
+ return 0x0020;
+ }
+ static get UNIFORM() {
+ return 0x0040;
+ }
+ static get STORAGE() {
+ return 0x0080;
+ }
+ static get INDIRECT() {
+ return 0x0100;
+ }
+ static get QUERY_RESOLVE() {
+ return 0x0200;
+ }
+}
+
+class GPUMapMode {
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ static get READ() {
+ return 0x0001;
+ }
+ static get WRITE() {
+ return 0x0002;
+ }
+}
+
+/**
+ * @param {GPUTextureDescriptor} descriptor
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUTexture}
+ */
+function createGPUTexture(descriptor, device, rid) {
+ /** @type {GPUTexture} */
+ const texture = webidl.createBranded(GPUTexture);
+ texture[_label] = descriptor.label;
+ texture[_device] = device;
+ texture[_rid] = rid;
+ texture[_views] = [];
+ texture[_width] = descriptor.size.width;
+ texture[_height] = descriptor.size.height;
+ texture[_depthOrArrayLayers] = descriptor.size.depthOrArrayLayers;
+ texture[_mipLevelCount] = descriptor.mipLevelCount;
+ texture[_sampleCount] = descriptor.sampleCount;
+ texture[_dimension] = descriptor.dimension;
+ texture[_format] = descriptor.format;
+ texture[_usage] = descriptor.usage;
+ return texture;
+}
+
+class GPUTexture {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+ /** @type {SafeWeakRef<GPUTextureView>[]} */
+ [_views];
+
+ /** @type {number} */
+ [_width];
+ /** @type {number} */
+ [_height];
+ /** @type {number} */
+ [_depthOrArrayLayers];
+ /** @type {number} */
+ [_mipLevelCount];
+ /** @type {number} */
+ [_sampleCount];
+ /** @type {GPUTextureDimension} */
+ [_dimension];
+ /** @type {GPUTextureFormat} */
+ [_format];
+ /** @type {number} */
+ [_usage];
+
+ [_cleanup]() {
+ const views = this[_views];
+ while (views.length > 0) {
+ const view = ArrayPrototypePop(views)?.deref();
+ if (view) {
+ view[_cleanup]();
+ }
+ }
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {GPUTextureViewDescriptor} descriptor
+ */
+ createView(descriptor = {}) {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ const prefix = "Failed to execute 'createView' on 'GPUTexture'";
+ webidl.requiredArguments(arguments.length, 0, prefix);
+ descriptor = webidl.converters.GPUTextureViewDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const textureRid = assertResource(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_create_texture_view({
+ textureRid,
+ ...descriptor,
+ });
+ device.pushError(err);
+
+ const textureView = createGPUTextureView(
+ descriptor.label,
+ this,
+ rid,
+ );
+ ArrayPrototypePush(this[_views], new SafeWeakRef(textureView));
+ return textureView;
+ }
+
+ destroy() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ this[_cleanup]();
+ }
+
+ get width() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ return this[_width];
+ }
+
+ get height() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ return this[_height];
+ }
+
+ get depthOrArrayLayers() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ return this[_depthOrArrayLayers];
+ }
+
+ get mipLevelCount() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ return this[_mipLevelCount];
+ }
+
+ get sampleCount() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ return this[_sampleCount];
+ }
+
+ get dimension() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ return this[_dimension];
+ }
+
+ get format() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ return this[_format];
+ }
+
+ get usage() {
+ webidl.assertBranded(this, GPUTexturePrototype);
+ return this[_usage];
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUTexturePrototype, this),
+ keys: [
+ "label",
+ "width",
+ "height",
+ "depthOrArrayLayers",
+ "mipLevelCount",
+ "sampleCount",
+ "dimension",
+ "format",
+ "usage",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUTexture", GPUTexture);
+const GPUTexturePrototype = GPUTexture.prototype;
+
+class GPUTextureUsage {
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ static get COPY_SRC() {
+ return 0x01;
+ }
+ static get COPY_DST() {
+ return 0x02;
+ }
+ static get TEXTURE_BINDING() {
+ return 0x04;
+ }
+ static get STORAGE_BINDING() {
+ return 0x08;
+ }
+ static get RENDER_ATTACHMENT() {
+ return 0x10;
+ }
+}
+
+/**
+ * @param {string | null} label
+ * @param {GPUTexture} texture
+ * @param {number} rid
+ * @returns {GPUTextureView}
+ */
+function createGPUTextureView(label, texture, rid) {
+ /** @type {GPUTextureView} */
+ const textureView = webidl.createBranded(GPUTextureView);
+ textureView[_label] = label;
+ textureView[_texture] = texture;
+ textureView[_rid] = rid;
+ return textureView;
+}
+class GPUTextureView {
+ /** @type {GPUTexture} */
+ [_texture];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUTextureViewPrototype, this),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUTextureView", GPUTextureView);
+const GPUTextureViewPrototype = GPUTextureView.prototype;
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUSampler}
+ */
+function createGPUSampler(label, device, rid) {
+ /** @type {GPUSampler} */
+ const sampler = webidl.createBranded(GPUSampler);
+ sampler[_label] = label;
+ sampler[_device] = device;
+ sampler[_rid] = rid;
+ return sampler;
+}
+class GPUSampler {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect) {
+ return `${this.constructor.name} ${
+ inspect({
+ label: this.label,
+ })
+ }`;
+ }
+}
+GPUObjectBaseMixin("GPUSampler", GPUSampler);
+const GPUSamplerPrototype = GPUSampler.prototype;
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUBindGroupLayout}
+ */
+function createGPUBindGroupLayout(label, device, rid) {
+ /** @type {GPUBindGroupLayout} */
+ const bindGroupLayout = webidl.createBranded(GPUBindGroupLayout);
+ bindGroupLayout[_label] = label;
+ bindGroupLayout[_device] = device;
+ bindGroupLayout[_rid] = rid;
+ return bindGroupLayout;
+}
+class GPUBindGroupLayout {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPUBindGroupLayoutPrototype,
+ this,
+ ),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUBindGroupLayout", GPUBindGroupLayout);
+const GPUBindGroupLayoutPrototype = GPUBindGroupLayout.prototype;
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUPipelineLayout}
+ */
+function createGPUPipelineLayout(label, device, rid) {
+ /** @type {GPUPipelineLayout} */
+ const pipelineLayout = webidl.createBranded(GPUPipelineLayout);
+ pipelineLayout[_label] = label;
+ pipelineLayout[_device] = device;
+ pipelineLayout[_rid] = rid;
+ return pipelineLayout;
+}
+class GPUPipelineLayout {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPUPipelineLayoutPrototype,
+ this,
+ ),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUPipelineLayout", GPUPipelineLayout);
+const GPUPipelineLayoutPrototype = GPUPipelineLayout.prototype;
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUBindGroup}
+ */
+function createGPUBindGroup(label, device, rid) {
+ /** @type {GPUBindGroup} */
+ const bindGroup = webidl.createBranded(GPUBindGroup);
+ bindGroup[_label] = label;
+ bindGroup[_device] = device;
+ bindGroup[_rid] = rid;
+ return bindGroup;
+}
+class GPUBindGroup {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUBindGroupPrototype, this),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUBindGroup", GPUBindGroup);
+const GPUBindGroupPrototype = GPUBindGroup.prototype;
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUShaderModule}
+ */
+function createGPUShaderModule(label, device, rid) {
+ /** @type {GPUShaderModule} */
+ const bindGroup = webidl.createBranded(GPUShaderModule);
+ bindGroup[_label] = label;
+ bindGroup[_device] = device;
+ bindGroup[_rid] = rid;
+ return bindGroup;
+}
+class GPUShaderModule {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUShaderModulePrototype, this),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUShaderModule", GPUShaderModule);
+const GPUShaderModulePrototype = GPUShaderModule.prototype;
+class GPUShaderStage {
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ static get VERTEX() {
+ return 0x1;
+ }
+
+ static get FRAGMENT() {
+ return 0x2;
+ }
+
+ static get COMPUTE() {
+ return 0x4;
+ }
+}
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUComputePipeline}
+ */
+function createGPUComputePipeline(label, device, rid) {
+ /** @type {GPUComputePipeline} */
+ const pipeline = webidl.createBranded(GPUComputePipeline);
+ pipeline[_label] = label;
+ pipeline[_device] = device;
+ pipeline[_rid] = rid;
+ return pipeline;
+}
+class GPUComputePipeline {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {number} index
+ * @returns {GPUBindGroupLayout}
+ */
+ getBindGroupLayout(index) {
+ webidl.assertBranded(this, GPUComputePipelinePrototype);
+ const prefix =
+ "Failed to execute 'getBindGroupLayout' on 'GPUComputePipeline'";
+ webidl.requiredArguments(arguments.length, 1, { prefix });
+ index = webidl.converters["unsigned long"](index, prefix, "Argument 1");
+ const device = assertDevice(this, prefix, "this");
+ const computePipelineRid = assertResource(this, prefix, "this");
+ const { rid, label, err } = ops
+ .op_webgpu_compute_pipeline_get_bind_group_layout(
+ computePipelineRid,
+ index,
+ );
+ device.pushError(err);
+
+ const bindGroupLayout = createGPUBindGroupLayout(
+ label,
+ device,
+ rid,
+ );
+ device.trackResource(bindGroupLayout);
+ return bindGroupLayout;
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPUComputePipelinePrototype,
+ this,
+ ),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUComputePipeline", GPUComputePipeline);
+const GPUComputePipelinePrototype = GPUComputePipeline.prototype;
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPURenderPipeline}
+ */
+function createGPURenderPipeline(label, device, rid) {
+ /** @type {GPURenderPipeline} */
+ const pipeline = webidl.createBranded(GPURenderPipeline);
+ pipeline[_label] = label;
+ pipeline[_device] = device;
+ pipeline[_rid] = rid;
+ return pipeline;
+}
+class GPURenderPipeline {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {number} index
+ */
+ getBindGroupLayout(index) {
+ webidl.assertBranded(this, GPURenderPipelinePrototype);
+ const prefix =
+ "Failed to execute 'getBindGroupLayout' on 'GPURenderPipeline'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ index = webidl.converters["unsigned long"](index, prefix, "Argument 1");
+ const device = assertDevice(this, prefix, "this");
+ const renderPipelineRid = assertResource(this, prefix, "this");
+ const { rid, label, err } = ops
+ .op_webgpu_render_pipeline_get_bind_group_layout(
+ renderPipelineRid,
+ index,
+ );
+ device.pushError(err);
+
+ const bindGroupLayout = createGPUBindGroupLayout(
+ label,
+ device,
+ rid,
+ );
+ device.trackResource(bindGroupLayout);
+ return bindGroupLayout;
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPURenderPipelinePrototype,
+ this,
+ ),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPURenderPipeline", GPURenderPipeline);
+const GPURenderPipelinePrototype = GPURenderPipeline.prototype;
+
+class GPUColorWrite {
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ static get RED() {
+ return 0x1;
+ }
+ static get GREEN() {
+ return 0x2;
+ }
+ static get BLUE() {
+ return 0x4;
+ }
+ static get ALPHA() {
+ return 0x8;
+ }
+ static get ALL() {
+ return 0xF;
+ }
+}
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUCommandEncoder}
+ */
+function createGPUCommandEncoder(label, device, rid) {
+ /** @type {GPUCommandEncoder} */
+ const encoder = webidl.createBranded(GPUCommandEncoder);
+ encoder[_label] = label;
+ encoder[_device] = device;
+ encoder[_rid] = rid;
+ encoder[_encoders] = [];
+ return encoder;
+}
+class GPUCommandEncoder {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+ /** @type {SafeWeakRef<GPURenderPassEncoder | GPUComputePassEncoder>[]} */
+ [_encoders];
+
+ [_cleanup]() {
+ const encoders = this[_encoders];
+ while (encoders.length > 0) {
+ const encoder = ArrayPrototypePop(encoders)?.deref();
+ if (encoder) {
+ encoder[_cleanup]();
+ }
+ }
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {GPURenderPassDescriptor} descriptor
+ * @return {GPURenderPassEncoder}
+ */
+ beginRenderPass(descriptor) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix = "Failed to execute 'beginRenderPass' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ descriptor = webidl.converters.GPURenderPassDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+
+ if (this[_rid] === undefined) {
+ throw new DOMException(
+ "Failed to execute 'beginRenderPass' on 'GPUCommandEncoder': already consumed",
+ "OperationError",
+ );
+ }
+
+ let depthStencilAttachment;
+ if (descriptor.depthStencilAttachment) {
+ if (
+ descriptor.depthStencilAttachment.depthLoadOp === "clear" &&
+ !(ObjectHasOwn(descriptor.depthStencilAttachment, "depthClearValue"))
+ ) {
+ throw webidl.makeException(
+ TypeError,
+ '`depthClearValue` must be specified when `depthLoadOp` is "clear"',
+ prefix,
+ "Argument 1",
+ );
+ }
+
+ const view = assertResource(
+ descriptor.depthStencilAttachment.view,
+ prefix,
+ "texture view for depth stencil attachment",
+ );
+ assertDeviceMatch(
+ device,
+ descriptor.depthStencilAttachment.view[_texture],
+ {
+ prefix,
+ resourceContext: "texture view for depth stencil attachment",
+ selfContext: "this",
+ },
+ );
+
+ depthStencilAttachment = {
+ ...descriptor.depthStencilAttachment,
+ view,
+ };
+ }
+ const colorAttachments = ArrayPrototypeMap(
+ descriptor.colorAttachments,
+ (colorAttachment, i) => {
+ const context = `color attachment ${i + 1}`;
+ const view = assertResource(
+ colorAttachment.view,
+ prefix,
+ `texture view for ${context}`,
+ );
+ assertResource(
+ colorAttachment.view[_texture],
+ prefix,
+ `texture backing texture view for ${context}`,
+ );
+ assertDeviceMatch(
+ device,
+ colorAttachment.view[_texture],
+ {
+ prefix,
+ resourceContext: `texture view for ${context}`,
+ selfContext: "this",
+ },
+ );
+ let resolveTarget;
+ if (colorAttachment.resolveTarget) {
+ resolveTarget = assertResource(
+ colorAttachment.resolveTarget,
+ prefix,
+ `resolve target texture view for ${context}`,
+ );
+ assertResource(
+ colorAttachment.resolveTarget[_texture],
+ prefix,
+ `texture backing resolve target texture view for ${context}`,
+ );
+ assertDeviceMatch(
+ device,
+ colorAttachment.resolveTarget[_texture],
+ {
+ prefix,
+ resourceContext: `resolve target texture view for ${context}`,
+ selfContext: "this",
+ },
+ );
+ }
+ return {
+ view: view,
+ resolveTarget,
+ storeOp: colorAttachment.storeOp,
+ loadOp: colorAttachment.loadOp,
+ clearValue: normalizeGPUColor(colorAttachment.clearValue),
+ };
+ },
+ );
+
+ let occlusionQuerySet;
+
+ if (descriptor.occlusionQuerySet) {
+ occlusionQuerySet = assertResource(
+ descriptor.occlusionQuerySet,
+ prefix,
+ "occlusionQuerySet",
+ );
+ }
+
+ let timestampWrites = null;
+ if (descriptor.timestampWrites) {
+ const querySet = assertResource(
+ descriptor.timestampWrites.querySet,
+ prefix,
+ "querySet",
+ );
+
+ timestampWrites = {
+ querySet,
+ beginningOfPassWriteIndex:
+ descriptor.timestampWrites.beginningOfPassWriteIndex,
+ endOfPassWriteIndex: descriptor.timestampWrites.endOfPassWriteIndex,
+ };
+ }
+
+ const { rid } = ops.op_webgpu_command_encoder_begin_render_pass(
+ commandEncoderRid,
+ descriptor.label,
+ colorAttachments,
+ depthStencilAttachment,
+ occlusionQuerySet,
+ timestampWrites,
+ );
+
+ const renderPassEncoder = createGPURenderPassEncoder(
+ descriptor.label,
+ this,
+ rid,
+ );
+ ArrayPrototypePush(this[_encoders], new SafeWeakRef(renderPassEncoder));
+ return renderPassEncoder;
+ }
+
+ /**
+ * @param {GPUComputePassDescriptor} descriptor
+ */
+ beginComputePass(descriptor = {}) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix =
+ "Failed to execute 'beginComputePass' on 'GPUCommandEncoder'";
+ descriptor = webidl.converters.GPUComputePassDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+
+ assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+
+ let timestampWrites = null;
+ if (descriptor.timestampWrites) {
+ const querySet = assertResource(
+ descriptor.timestampWrites.querySet,
+ prefix,
+ "querySet",
+ );
+
+ timestampWrites = {
+ querySet,
+ beginningOfPassWriteIndex:
+ descriptor.timestampWrites.beginningOfPassWriteIndex,
+ endOfPassWriteIndex: descriptor.timestampWrites.endOfPassWriteIndex,
+ };
+ }
+
+ const { rid } = ops.op_webgpu_command_encoder_begin_compute_pass(
+ commandEncoderRid,
+ descriptor.label,
+ timestampWrites,
+ );
+
+ const computePassEncoder = createGPUComputePassEncoder(
+ descriptor.label,
+ this,
+ rid,
+ );
+ ArrayPrototypePush(this[_encoders], new SafeWeakRef(computePassEncoder));
+ return computePassEncoder;
+ }
+
+ /**
+ * @param {GPUBuffer} source
+ * @param {number} sourceOffset
+ * @param {GPUBuffer} destination
+ * @param {number} destinationOffset
+ * @param {number} size
+ */
+ copyBufferToBuffer(
+ source,
+ sourceOffset,
+ destination,
+ destinationOffset,
+ size,
+ ) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix =
+ "Failed to execute 'copyBufferToBuffer' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 5, prefix);
+ source = webidl.converters.GPUBuffer(source, prefix, "Argument 1");
+ sourceOffset = webidl.converters.GPUSize64(
+ sourceOffset,
+ prefix,
+ "Argument 2",
+ );
+ destination = webidl.converters.GPUBuffer(
+ destination,
+ prefix,
+ "Argument 3",
+ );
+ destinationOffset = webidl.converters.GPUSize64(
+ destinationOffset,
+ prefix,
+ "Argument 4",
+ );
+ size = webidl.converters.GPUSize64(size, prefix, "Argument 5");
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const sourceRid = assertResource(source, prefix, "Argument 1");
+ assertDeviceMatch(device, source, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ const destinationRid = assertResource(destination, prefix, "Argument 3");
+ assertDeviceMatch(device, destination, {
+ prefix,
+ resourceContext: "Argument 3",
+ selfContext: "this",
+ });
+
+ const { err } = ops.op_webgpu_command_encoder_copy_buffer_to_buffer(
+ commandEncoderRid,
+ sourceRid,
+ sourceOffset,
+ destinationRid,
+ destinationOffset,
+ size,
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {GPUImageCopyBuffer} source
+ * @param {GPUImageCopyTexture} destination
+ * @param {GPUExtent3D} copySize
+ */
+ copyBufferToTexture(source, destination, copySize) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix =
+ "Failed to execute 'copyBufferToTexture' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 3, prefix);
+ source = webidl.converters.GPUImageCopyBuffer(source, prefix, "Argument 1");
+ destination = webidl.converters.GPUImageCopyTexture(
+ destination,
+ prefix,
+ "Argument 2",
+ );
+ copySize = webidl.converters.GPUExtent3D(copySize, prefix, "Argument 3");
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const sourceBufferRid = assertResource(
+ // deno-lint-ignore prefer-primordials
+ source.buffer,
+ prefix,
+ "source in Argument 1",
+ );
+ // deno-lint-ignore prefer-primordials
+ assertDeviceMatch(device, source.buffer, {
+ prefix,
+ resourceContext: "source in Argument 1",
+ selfContext: "this",
+ });
+ const destinationTextureRid = assertResource(
+ destination.texture,
+ prefix,
+ "texture in Argument 2",
+ );
+ assertDeviceMatch(device, destination.texture, {
+ prefix,
+ resourceContext: "texture in Argument 2",
+ selfContext: "this",
+ });
+
+ const { err } = ops.op_webgpu_command_encoder_copy_buffer_to_texture(
+ commandEncoderRid,
+ {
+ ...source,
+ buffer: sourceBufferRid,
+ },
+ {
+ texture: destinationTextureRid,
+ mipLevel: destination.mipLevel,
+ origin: destination.origin
+ ? normalizeGPUOrigin3D(destination.origin)
+ : undefined,
+ aspect: destination.aspect,
+ },
+ normalizeGPUExtent3D(copySize),
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {GPUImageCopyTexture} source
+ * @param {GPUImageCopyBuffer} destination
+ * @param {GPUExtent3D} copySize
+ */
+ copyTextureToBuffer(source, destination, copySize) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix =
+ "Failed to execute 'copyTextureToBuffer' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 3, prefix);
+ source = webidl.converters.GPUImageCopyTexture(
+ source,
+ prefix,
+ "Argument 1",
+ );
+ destination = webidl.converters.GPUImageCopyBuffer(
+ destination,
+ prefix,
+ "Argument 2",
+ );
+ copySize = webidl.converters.GPUExtent3D(copySize, prefix, "Argument 3");
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const sourceTextureRid = assertResource(
+ source.texture,
+ prefix,
+ "texture in Argument 1",
+ );
+ assertDeviceMatch(device, source.texture, {
+ prefix,
+ resourceContext: "texture in Argument 1",
+ selfContext: "this",
+ });
+ const destinationBufferRid = assertResource(
+ // deno-lint-ignore prefer-primordials
+ destination.buffer,
+ prefix,
+ "buffer in Argument 2",
+ );
+ // deno-lint-ignore prefer-primordials
+ assertDeviceMatch(device, destination.buffer, {
+ prefix,
+ resourceContext: "buffer in Argument 2",
+ selfContext: "this",
+ });
+ const { err } = ops.op_webgpu_command_encoder_copy_texture_to_buffer(
+ commandEncoderRid,
+ {
+ texture: sourceTextureRid,
+ mipLevel: source.mipLevel,
+ origin: source.origin ? normalizeGPUOrigin3D(source.origin) : undefined,
+ aspect: source.aspect,
+ },
+ {
+ ...destination,
+ buffer: destinationBufferRid,
+ },
+ normalizeGPUExtent3D(copySize),
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {GPUImageCopyTexture} source
+ * @param {GPUImageCopyTexture} destination
+ * @param {GPUExtent3D} copySize
+ */
+ copyTextureToTexture(source, destination, copySize) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix =
+ "Failed to execute 'copyTextureToTexture' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 3, prefix);
+ source = webidl.converters.GPUImageCopyTexture(
+ source,
+ prefix,
+ "Argument 1",
+ );
+ destination = webidl.converters.GPUImageCopyTexture(
+ destination,
+ prefix,
+ "Argument 2",
+ );
+ copySize = webidl.converters.GPUExtent3D(copySize, prefix, "Argument 3");
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const sourceTextureRid = assertResource(
+ source.texture,
+ prefix,
+ "texture in Argument 1",
+ );
+ assertDeviceMatch(device, source.texture, {
+ prefix,
+ resourceContext: "texture in Argument 1",
+ selfContext: "this",
+ });
+ const destinationTextureRid = assertResource(
+ destination.texture,
+ prefix,
+ "texture in Argument 2",
+ );
+ assertDeviceMatch(device, destination.texture, {
+ prefix,
+ resourceContext: "texture in Argument 2",
+ selfContext: "this",
+ });
+ const { err } = ops.op_webgpu_command_encoder_copy_texture_to_texture(
+ commandEncoderRid,
+ {
+ texture: sourceTextureRid,
+ mipLevel: source.mipLevel,
+ origin: source.origin ? normalizeGPUOrigin3D(source.origin) : undefined,
+ aspect: source.aspect,
+ },
+ {
+ texture: destinationTextureRid,
+ mipLevel: destination.mipLevel,
+ origin: destination.origin
+ ? normalizeGPUOrigin3D(destination.origin)
+ : undefined,
+ aspect: source.aspect,
+ },
+ normalizeGPUExtent3D(copySize),
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {GPUBuffer} buffer
+ * @param {GPUSize64} offset
+ * @param {GPUSize64} size
+ */
+ clearBuffer(buffer, offset = 0, size = undefined) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix = "Failed to execute 'clearBuffer' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 3, prefix);
+ buffer = webidl.converters.GPUBuffer(buffer, prefix, "Argument 1");
+ offset = webidl.converters.GPUSize64(offset, prefix, "Argument 2");
+ size = webidl.converters.GPUSize64(size, prefix, "Argument 3");
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const bufferRid = assertResource(buffer, prefix, "Argument 1");
+ const { err } = ops.op_webgpu_command_encoder_clear_buffer(
+ commandEncoderRid,
+ bufferRid,
+ offset,
+ size,
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {string} groupLabel
+ */
+ pushDebugGroup(groupLabel) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix = "Failed to execute 'pushDebugGroup' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ groupLabel = webidl.converters.USVString(groupLabel, prefix, "Argument 1");
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const { err } = ops.op_webgpu_command_encoder_push_debug_group(
+ commandEncoderRid,
+ groupLabel,
+ );
+ device.pushError(err);
+ }
+
+ popDebugGroup() {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix = "Failed to execute 'popDebugGroup' on 'GPUCommandEncoder'";
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const { err } = ops.op_webgpu_command_encoder_pop_debug_group(
+ commandEncoderRid,
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {string} markerLabel
+ */
+ insertDebugMarker(markerLabel) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix =
+ "Failed to execute 'insertDebugMarker' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ markerLabel = webidl.converters.USVString(
+ markerLabel,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const { err } = ops.op_webgpu_command_encoder_insert_debug_marker(
+ commandEncoderRid,
+ markerLabel,
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {GPUQuerySet} querySet
+ * @param {number} queryIndex
+ */
+ writeTimestamp(querySet, queryIndex) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix = "Failed to execute 'writeTimestamp' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ querySet = webidl.converters.GPUQuerySet(querySet, prefix, "Argument 1");
+ queryIndex = webidl.converters.GPUSize32(queryIndex, prefix, "Argument 2");
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const querySetRid = assertResource(querySet, prefix, "Argument 1");
+ assertDeviceMatch(device, querySet, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ const { err } = ops.op_webgpu_command_encoder_write_timestamp(
+ commandEncoderRid,
+ querySetRid,
+ queryIndex,
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {GPUQuerySet} querySet
+ * @param {number} firstQuery
+ * @param {number} queryCount
+ * @param {GPUBuffer} destination
+ * @param {number} destinationOffset
+ */
+ resolveQuerySet(
+ querySet,
+ firstQuery,
+ queryCount,
+ destination,
+ destinationOffset,
+ ) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix = "Failed to execute 'resolveQuerySet' on 'GPUCommandEncoder'";
+ webidl.requiredArguments(arguments.length, 5, { prefix });
+ querySet = webidl.converters.GPUQuerySet(querySet, prefix, "Argument 1");
+ firstQuery = webidl.converters.GPUSize32(firstQuery, prefix, "Argument 2");
+ queryCount = webidl.converters.GPUSize32(queryCount, prefix, "Argument 3");
+ destination = webidl.converters.GPUBuffer(
+ destination,
+ prefix,
+ "Argument 4",
+ );
+ destinationOffset = webidl.converters.GPUSize64(
+ destinationOffset,
+ prefix,
+ "Argument 5",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const querySetRid = assertResource(querySet, prefix, "Argument 1");
+ assertDeviceMatch(device, querySet, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ const destinationRid = assertResource(destination, prefix, "Argument 3");
+ assertDeviceMatch(device, destination, {
+ prefix,
+ resourceContext: "Argument 3",
+ selfContext: "this",
+ });
+ const { err } = ops.op_webgpu_command_encoder_resolve_query_set(
+ commandEncoderRid,
+ querySetRid,
+ firstQuery,
+ queryCount,
+ destinationRid,
+ destinationOffset,
+ );
+ device.pushError(err);
+ }
+
+ /**
+ * @param {GPUCommandBufferDescriptor} descriptor
+ * @returns {GPUCommandBuffer}
+ */
+ finish(descriptor = {}) {
+ webidl.assertBranded(this, GPUCommandEncoderPrototype);
+ const prefix = "Failed to execute 'finish' on 'GPUCommandEncoder'";
+ descriptor = webidl.converters.GPUCommandBufferDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const commandEncoderRid = assertResource(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_command_encoder_finish(
+ commandEncoderRid,
+ descriptor.label,
+ );
+ device.pushError(err);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+
+ const commandBuffer = createGPUCommandBuffer(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(commandBuffer);
+ return commandBuffer;
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPUCommandEncoderPrototype,
+ this,
+ ),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUCommandEncoder", GPUCommandEncoder);
+const GPUCommandEncoderPrototype = GPUCommandEncoder.prototype;
+
+/**
+ * @param {string | null} label
+ * @param {GPUCommandEncoder} encoder
+ * @param {number} rid
+ * @returns {GPURenderPassEncoder}
+ */
+function createGPURenderPassEncoder(label, encoder, rid) {
+ /** @type {GPURenderPassEncoder} */
+ const passEncoder = webidl.createBranded(GPURenderPassEncoder);
+ passEncoder[_label] = label;
+ passEncoder[_encoder] = encoder;
+ passEncoder[_rid] = rid;
+ return passEncoder;
+}
+
+class GPURenderPassEncoder {
+ /** @type {GPUCommandEncoder} */
+ [_encoder];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} width
+ * @param {number} height
+ * @param {number} minDepth
+ * @param {number} maxDepth
+ */
+ setViewport(x, y, width, height, minDepth, maxDepth) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix = "Failed to execute 'setViewport' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 6, { prefix });
+ x = webidl.converters.float(x, prefix, "Argument 1");
+ y = webidl.converters.float(y, prefix, "Argument 2");
+ width = webidl.converters.float(width, prefix, "Argument 3");
+ height = webidl.converters.float(height, prefix, "Argument 4");
+ minDepth = webidl.converters.float(minDepth, prefix, "Argument 5");
+ maxDepth = webidl.converters.float(maxDepth, prefix, "Argument 6");
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_set_viewport({
+ renderPassRid,
+ x,
+ y,
+ width,
+ height,
+ minDepth,
+ maxDepth,
+ });
+ }
+
+ /**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} width
+ * @param {number} height
+ */
+ setScissorRect(x, y, width, height) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setScissorRect' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 4, prefix);
+ x = webidl.converters.GPUIntegerCoordinate(x, prefix, "Argument 1");
+ y = webidl.converters.GPUIntegerCoordinate(y, prefix, "Argument 2");
+ width = webidl.converters.GPUIntegerCoordinate(width, prefix, "Argument 3");
+ height = webidl.converters.GPUIntegerCoordinate(
+ height,
+ prefix,
+ "Argument 4",
+ );
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_set_scissor_rect(
+ renderPassRid,
+ x,
+ y,
+ width,
+ height,
+ );
+ }
+
+ /**
+ * @param {GPUColor} color
+ */
+ setBlendConstant(color) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setBlendConstant' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ color = webidl.converters.GPUColor(color, prefix, "Argument 1");
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_set_blend_constant(
+ renderPassRid,
+ normalizeGPUColor(color),
+ );
+ }
+
+ /**
+ * @param {number} reference
+ */
+ setStencilReference(reference) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setStencilReference' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ reference = webidl.converters.GPUStencilValue(
+ reference,
+ prefix,
+ "Argument 1",
+ );
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_set_stencil_reference(
+ renderPassRid,
+ reference,
+ );
+ }
+
+ /**
+ * @param {number} queryIndex
+ */
+ beginOcclusionQuery(queryIndex) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'beginOcclusionQuery' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ queryIndex = webidl.converters.GPUSize32(queryIndex, prefix, "Argument 1");
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_begin_occlusion_query(
+ renderPassRid,
+ queryIndex,
+ );
+ }
+
+ endOcclusionQuery() {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'endOcclusionQuery' on 'GPUComputePassEncoder'";
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_end_occlusion_query(renderPassRid);
+ }
+
+ /**
+ * @param {GPURenderBundle[]} bundles
+ */
+ executeBundles(bundles) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'executeBundles' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ bundles = webidl.converters["sequence<GPURenderBundle>"](
+ bundles,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ const bundleRids = ArrayPrototypeMap(bundles, (bundle, i) => {
+ const context = `bundle ${i + 1}`;
+ const rid = assertResource(bundle, prefix, context);
+ assertDeviceMatch(device, bundle, {
+ prefix,
+ resourceContext: context,
+ selfContext: "this",
+ });
+ return rid;
+ });
+ ops.op_webgpu_render_pass_execute_bundles(renderPassRid, bundleRids);
+ }
+
+ end() {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix = "Failed to execute 'end' on 'GPURenderPassEncoder'";
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ const commandEncoderRid = assertResource(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ const renderPassRid = assertResource(this, prefix, "this");
+ const { err } = ops.op_webgpu_render_pass_end(
+ commandEncoderRid,
+ renderPassRid,
+ );
+ device.pushError(err);
+ this[_rid] = undefined;
+ }
+
+ // TODO(lucacasonato): has an overload
+ setBindGroup(
+ index,
+ bindGroup,
+ dynamicOffsetsData,
+ dynamicOffsetsDataStart,
+ dynamicOffsetsDataLength,
+ ) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix = "Failed to execute 'setBindGroup' on 'GPURenderPassEncoder'";
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ const bindGroupRid = assertResource(bindGroup, prefix, "Argument 2");
+ assertDeviceMatch(device, bindGroup, {
+ prefix,
+ resourceContext: "Argument 2",
+ selfContext: "this",
+ });
+ if (
+ !(ObjectPrototypeIsPrototypeOf(
+ Uint32ArrayPrototype,
+ dynamicOffsetsData,
+ ))
+ ) {
+ dynamicOffsetsData = new Uint32Array(dynamicOffsetsData ?? []);
+ dynamicOffsetsDataStart = 0;
+ dynamicOffsetsDataLength = dynamicOffsetsData.length;
+ }
+ ops.op_webgpu_render_pass_set_bind_group(
+ renderPassRid,
+ index,
+ bindGroupRid,
+ dynamicOffsetsData,
+ dynamicOffsetsDataStart,
+ dynamicOffsetsDataLength,
+ );
+ }
+
+ /**
+ * @param {string} groupLabel
+ */
+ pushDebugGroup(groupLabel) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'pushDebugGroup' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ groupLabel = webidl.converters.USVString(groupLabel, prefix, "Argument 1");
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_push_debug_group(renderPassRid, groupLabel);
+ }
+
+ popDebugGroup() {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'popDebugGroup' on 'GPURenderPassEncoder'";
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_pop_debug_group(renderPassRid);
+ }
+
+ /**
+ * @param {string} markerLabel
+ */
+ insertDebugMarker(markerLabel) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'insertDebugMarker' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ markerLabel = webidl.converters.USVString(
+ markerLabel,
+ prefix,
+ "Argument 1",
+ );
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_insert_debug_marker(renderPassRid, markerLabel);
+ }
+
+ /**
+ * @param {GPURenderPipeline} pipeline
+ */
+ setPipeline(pipeline) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix = "Failed to execute 'setPipeline' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ pipeline = webidl.converters.GPURenderPipeline(
+ pipeline,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ const pipelineRid = assertResource(pipeline, prefix, "Argument 1");
+ assertDeviceMatch(device, pipeline, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_pass_set_pipeline(renderPassRid, pipelineRid);
+ }
+
+ /**
+ * @param {GPUBuffer} buffer
+ * @param {GPUIndexFormat} indexFormat
+ * @param {number} offset
+ * @param {number} size
+ */
+ setIndexBuffer(buffer, indexFormat, offset = 0, size) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setIndexBuffer' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ buffer = webidl.converters.GPUBuffer(buffer, prefix, "Argument 1");
+ indexFormat = webidl.converters.GPUIndexFormat(
+ indexFormat,
+ prefix,
+ "Argument 2",
+ );
+ offset = webidl.converters.GPUSize64(offset, prefix, "Argument 3");
+ if (size !== undefined) {
+ size = webidl.converters.GPUSize64(size, prefix, "Argument 4");
+ }
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ const bufferRid = assertResource(buffer, prefix, "Argument 1");
+ assertDeviceMatch(device, buffer, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_pass_set_index_buffer(
+ renderPassRid,
+ bufferRid,
+ indexFormat,
+ offset,
+ size,
+ );
+ }
+
+ /**
+ * @param {number} slot
+ * @param {GPUBuffer} buffer
+ * @param {number} offset
+ * @param {number} size
+ */
+ setVertexBuffer(slot, buffer, offset = 0, size) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setVertexBuffer' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ slot = webidl.converters.GPUSize32(slot, prefix, "Argument 1");
+ buffer = webidl.converters.GPUBuffer(buffer, prefix, "Argument 2");
+ offset = webidl.converters.GPUSize64(offset, prefix, "Argument 3");
+ if (size !== undefined) {
+ size = webidl.converters.GPUSize64(size, prefix, "Argument 4");
+ }
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ const bufferRid = assertResource(buffer, prefix, "Argument 2");
+ assertDeviceMatch(device, buffer, {
+ prefix,
+ resourceContext: "Argument 2",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_pass_set_vertex_buffer(
+ renderPassRid,
+ slot,
+ bufferRid,
+ offset,
+ size,
+ );
+ }
+
+ /**
+ * @param {number} vertexCount
+ * @param {number} instanceCount
+ * @param {number} firstVertex
+ * @param {number} firstInstance
+ */
+ draw(vertexCount, instanceCount = 1, firstVertex = 0, firstInstance = 0) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix = "Failed to execute 'draw' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ vertexCount = webidl.converters.GPUSize32(
+ vertexCount,
+ prefix,
+ "Argument 1",
+ );
+ instanceCount = webidl.converters.GPUSize32(
+ instanceCount,
+ prefix,
+ "Argument 2",
+ );
+ firstVertex = webidl.converters.GPUSize32(
+ firstVertex,
+ prefix,
+ "Argument 3",
+ );
+ firstInstance = webidl.converters.GPUSize32(
+ firstInstance,
+ prefix,
+ "Argument 4",
+ );
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_draw(
+ renderPassRid,
+ vertexCount,
+ instanceCount,
+ firstVertex,
+ firstInstance,
+ );
+ }
+
+ /**
+ * @param {number} indexCount
+ * @param {number} instanceCount
+ * @param {number} firstIndex
+ * @param {number} baseVertex
+ * @param {number} firstInstance
+ */
+ drawIndexed(
+ indexCount,
+ instanceCount = 1,
+ firstIndex = 0,
+ baseVertex = 0,
+ firstInstance = 0,
+ ) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix = "Failed to execute 'drawIndexed' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ indexCount = webidl.converters.GPUSize32(indexCount, prefix, "Argument 1");
+ instanceCount = webidl.converters.GPUSize32(
+ instanceCount,
+ prefix,
+ "Argument 2",
+ );
+ firstIndex = webidl.converters.GPUSize32(firstIndex, prefix, "Argument 3");
+ baseVertex = webidl.converters.GPUSignedOffset32(
+ baseVertex,
+ prefix,
+ "Argument 4",
+ );
+ firstInstance = webidl.converters.GPUSize32(
+ firstInstance,
+ prefix,
+ "Argument 5",
+ );
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_pass_draw_indexed(
+ renderPassRid,
+ indexCount,
+ instanceCount,
+ firstIndex,
+ baseVertex,
+ firstInstance,
+ );
+ }
+
+ /**
+ * @param {GPUBuffer} indirectBuffer
+ * @param {number} indirectOffset
+ */
+ drawIndirect(indirectBuffer, indirectOffset) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix = "Failed to execute 'drawIndirect' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ indirectBuffer = webidl.converters.GPUBuffer(
+ indirectBuffer,
+ prefix,
+ "Argument 1",
+ );
+ indirectOffset = webidl.converters.GPUSize64(
+ indirectOffset,
+ prefix,
+ "Argument 2",
+ );
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ const indirectBufferRid = assertResource(
+ indirectBuffer,
+ prefix,
+ "Argument 1",
+ );
+ assertDeviceMatch(device, indirectBuffer, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_pass_draw_indirect(
+ renderPassRid,
+ indirectBufferRid,
+ indirectOffset,
+ );
+ }
+
+ /**
+ * @param {GPUBuffer} indirectBuffer
+ * @param {number} indirectOffset
+ */
+ drawIndexedIndirect(indirectBuffer, indirectOffset) {
+ webidl.assertBranded(this, GPURenderPassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'drawIndexedIndirect' on 'GPURenderPassEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ indirectBuffer = webidl.converters.GPUBuffer(
+ indirectBuffer,
+ prefix,
+ "Argument 1",
+ );
+ indirectOffset = webidl.converters.GPUSize64(
+ indirectOffset,
+ prefix,
+ "Argument 2",
+ );
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const renderPassRid = assertResource(this, prefix, "this");
+ const indirectBufferRid = assertResource(
+ indirectBuffer,
+ prefix,
+ "Argument 1",
+ );
+ assertDeviceMatch(device, indirectBuffer, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_pass_draw_indexed_indirect(
+ renderPassRid,
+ indirectBufferRid,
+ indirectOffset,
+ );
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPURenderPassEncoderPrototype,
+ this,
+ ),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPURenderPassEncoder", GPURenderPassEncoder);
+const GPURenderPassEncoderPrototype = GPURenderPassEncoder.prototype;
+
+/**
+ * @param {string | null} label
+ * @param {GPUCommandEncoder} encoder
+ * @param {number} rid
+ * @returns {GPUComputePassEncoder}
+ */
+function createGPUComputePassEncoder(label, encoder, rid) {
+ /** @type {GPUComputePassEncoder} */
+ const computePassEncoder = webidl.createBranded(GPUComputePassEncoder);
+ computePassEncoder[_label] = label;
+ computePassEncoder[_encoder] = encoder;
+ computePassEncoder[_rid] = rid;
+ return computePassEncoder;
+}
+
+class GPUComputePassEncoder {
+ /** @type {GPUCommandEncoder} */
+ [_encoder];
+
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {GPUComputePipeline} pipeline
+ */
+ setPipeline(pipeline) {
+ webidl.assertBranded(this, GPUComputePassEncoderPrototype);
+ const prefix = "Failed to execute 'setPipeline' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ pipeline = webidl.converters.GPUComputePipeline(
+ pipeline,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const computePassRid = assertResource(this, prefix, "this");
+ const pipelineRid = assertResource(pipeline, prefix, "Argument 1");
+ assertDeviceMatch(device, pipeline, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_compute_pass_set_pipeline(computePassRid, pipelineRid);
+ }
+
+ /**
+ * @param {number} workgroupCountX
+ * @param {number} workgroupCountY
+ * @param {number} workgroupCountZ
+ */
+ dispatchWorkgroups(
+ workgroupCountX,
+ workgroupCountY = 1,
+ workgroupCountZ = 1,
+ ) {
+ webidl.assertBranded(this, GPUComputePassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'dispatchWorkgroups' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ workgroupCountX = webidl.converters.GPUSize32(
+ workgroupCountX,
+ prefix,
+ "Argument 1",
+ );
+ workgroupCountY = webidl.converters.GPUSize32(
+ workgroupCountY,
+ prefix,
+ "Argument 2",
+ );
+ workgroupCountZ = webidl.converters.GPUSize32(
+ workgroupCountZ,
+ prefix,
+ "Argument 3",
+ );
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const computePassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_compute_pass_dispatch_workgroups(
+ computePassRid,
+ workgroupCountX,
+ workgroupCountY,
+ workgroupCountZ,
+ );
+ }
+
+ /**
+ * @param {GPUBuffer} indirectBuffer
+ * @param {number} indirectOffset
+ */
+ dispatchWorkgroupsIndirect(indirectBuffer, indirectOffset) {
+ webidl.assertBranded(this, GPUComputePassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'dispatchWorkgroupsIndirect' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ indirectBuffer = webidl.converters.GPUBuffer(
+ indirectBuffer,
+ prefix,
+ "Argument 1",
+ );
+ indirectOffset = webidl.converters.GPUSize64(
+ indirectOffset,
+ prefix,
+ "Argument 2",
+ );
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const computePassRid = assertResource(this, prefix, "this");
+ const indirectBufferRid = assertResource(
+ indirectBuffer,
+ prefix,
+ "Argument 1",
+ );
+ assertDeviceMatch(device, indirectBuffer, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_compute_pass_dispatch_workgroups_indirect(
+ computePassRid,
+ indirectBufferRid,
+ indirectOffset,
+ );
+ }
+
+ end() {
+ webidl.assertBranded(this, GPUComputePassEncoderPrototype);
+ const prefix = "Failed to execute 'end' on 'GPUComputePassEncoder'";
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ const commandEncoderRid = assertResource(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ const computePassRid = assertResource(this, prefix, "this");
+ const { err } = ops.op_webgpu_compute_pass_end(
+ commandEncoderRid,
+ computePassRid,
+ );
+ device.pushError(err);
+ this[_rid] = undefined;
+ }
+
+ // TODO(lucacasonato): has an overload
+ setBindGroup(
+ index,
+ bindGroup,
+ dynamicOffsetsData,
+ dynamicOffsetsDataStart,
+ dynamicOffsetsDataLength,
+ ) {
+ webidl.assertBranded(this, GPUComputePassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setBindGroup' on 'GPUComputePassEncoder'";
+ const device = assertDevice(
+ this[_encoder],
+ prefix,
+ "encoder referenced by this",
+ );
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const computePassRid = assertResource(this, prefix, "this");
+ const bindGroupRid = assertResource(bindGroup, prefix, "Argument 2");
+ assertDeviceMatch(device, bindGroup, {
+ prefix,
+ resourceContext: "Argument 2",
+ selfContext: "this",
+ });
+ if (
+ !(ObjectPrototypeIsPrototypeOf(
+ Uint32ArrayPrototype,
+ dynamicOffsetsData,
+ ))
+ ) {
+ dynamicOffsetsData = new Uint32Array(dynamicOffsetsData ?? []);
+ dynamicOffsetsDataStart = 0;
+ dynamicOffsetsDataLength = dynamicOffsetsData.length;
+ }
+ ops.op_webgpu_compute_pass_set_bind_group(
+ computePassRid,
+ index,
+ bindGroupRid,
+ dynamicOffsetsData,
+ dynamicOffsetsDataStart,
+ dynamicOffsetsDataLength,
+ );
+ }
+
+ /**
+ * @param {string} groupLabel
+ */
+ pushDebugGroup(groupLabel) {
+ webidl.assertBranded(this, GPUComputePassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'pushDebugGroup' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ groupLabel = webidl.converters.USVString(groupLabel, prefix, "Argument 1");
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const computePassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_compute_pass_push_debug_group(computePassRid, groupLabel);
+ }
+
+ popDebugGroup() {
+ webidl.assertBranded(this, GPUComputePassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'popDebugGroup' on 'GPUComputePassEncoder'";
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const computePassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_compute_pass_pop_debug_group(computePassRid);
+ }
+
+ /**
+ * @param {string} markerLabel
+ */
+ insertDebugMarker(markerLabel) {
+ webidl.assertBranded(this, GPUComputePassEncoderPrototype);
+ const prefix =
+ "Failed to execute 'insertDebugMarker' on 'GPUComputePassEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ markerLabel = webidl.converters.USVString(
+ markerLabel,
+ prefix,
+ "Argument 1",
+ );
+ assertDevice(this[_encoder], prefix, "encoder referenced by this");
+ assertResource(this[_encoder], prefix, "encoder referenced by this");
+ const computePassRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_compute_pass_insert_debug_marker(
+ computePassRid,
+ markerLabel,
+ );
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPUComputePassEncoderPrototype,
+ this,
+ ),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUComputePassEncoder", GPUComputePassEncoder);
+const GPUComputePassEncoderPrototype = GPUComputePassEncoder.prototype;
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUCommandBuffer}
+ */
+function createGPUCommandBuffer(label, device, rid) {
+ /** @type {GPUCommandBuffer} */
+ const commandBuffer = webidl.createBranded(GPUCommandBuffer);
+ commandBuffer[_label] = label;
+ commandBuffer[_device] = device;
+ commandBuffer[_rid] = rid;
+ return commandBuffer;
+}
+
+class GPUCommandBuffer {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUCommandBufferPrototype, this),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUCommandBuffer", GPUCommandBuffer);
+const GPUCommandBufferPrototype = GPUCommandBuffer.prototype;
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPURenderBundleEncoder}
+ */
+function createGPURenderBundleEncoder(label, device, rid) {
+ /** @type {GPURenderBundleEncoder} */
+ const bundleEncoder = webidl.createBranded(GPURenderBundleEncoder);
+ bundleEncoder[_label] = label;
+ bundleEncoder[_device] = device;
+ bundleEncoder[_rid] = rid;
+ return bundleEncoder;
+}
+
+class GPURenderBundleEncoder {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ /**
+ * @param {GPURenderBundleDescriptor} descriptor
+ */
+ finish(descriptor = {}) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix = "Failed to execute 'finish' on 'GPURenderBundleEncoder'";
+ descriptor = webidl.converters.GPURenderBundleDescriptor(
+ descriptor,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ const { rid, err } = ops.op_webgpu_render_bundle_encoder_finish(
+ renderBundleEncoderRid,
+ descriptor.label,
+ );
+ device.pushError(err);
+ this[_rid] = undefined;
+
+ const renderBundle = createGPURenderBundle(
+ descriptor.label,
+ device,
+ rid,
+ );
+ device.trackResource(renderBundle);
+ return renderBundle;
+ }
+
+ // TODO(lucacasonato): has an overload
+ setBindGroup(
+ index,
+ bindGroup,
+ dynamicOffsetsData,
+ dynamicOffsetsDataStart,
+ dynamicOffsetsDataLength,
+ ) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setBindGroup' on 'GPURenderBundleEncoder'";
+ const device = assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ const bindGroupRid = assertResource(bindGroup, prefix, "Argument 2");
+ assertDeviceMatch(device, bindGroup, {
+ prefix,
+ resourceContext: "Argument 2",
+ selfContext: "this",
+ });
+ if (
+ !(ObjectPrototypeIsPrototypeOf(
+ Uint32ArrayPrototype,
+ dynamicOffsetsData,
+ ))
+ ) {
+ dynamicOffsetsData = new Uint32Array(dynamicOffsetsData ?? []);
+ dynamicOffsetsDataStart = 0;
+ dynamicOffsetsDataLength = dynamicOffsetsData.length;
+ }
+ ops.op_webgpu_render_bundle_encoder_set_bind_group(
+ renderBundleEncoderRid,
+ index,
+ bindGroupRid,
+ dynamicOffsetsData,
+ dynamicOffsetsDataStart,
+ dynamicOffsetsDataLength,
+ );
+ }
+
+ /**
+ * @param {string} groupLabel
+ */
+ pushDebugGroup(groupLabel) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'pushDebugGroup' on 'GPURenderBundleEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ groupLabel = webidl.converters.USVString(groupLabel, prefix, "Argument 1");
+ assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_bundle_encoder_push_debug_group(
+ renderBundleEncoderRid,
+ groupLabel,
+ );
+ }
+
+ popDebugGroup() {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'popDebugGroup' on 'GPURenderBundleEncoder'";
+ assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_bundle_encoder_pop_debug_group(
+ renderBundleEncoderRid,
+ );
+ }
+
+ /**
+ * @param {string} markerLabel
+ */
+ insertDebugMarker(markerLabel) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'insertDebugMarker' on 'GPURenderBundleEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ markerLabel = webidl.converters.USVString(
+ markerLabel,
+ prefix,
+ "Argument 1",
+ );
+ assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_bundle_encoder_insert_debug_marker(
+ renderBundleEncoderRid,
+ markerLabel,
+ );
+ }
+
+ /**
+ * @param {GPURenderPipeline} pipeline
+ */
+ setPipeline(pipeline) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setPipeline' on 'GPURenderBundleEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ pipeline = webidl.converters.GPURenderPipeline(
+ pipeline,
+ prefix,
+ "Argument 1",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ const pipelineRid = assertResource(pipeline, prefix, "Argument 1");
+ assertDeviceMatch(device, pipeline, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_bundle_encoder_set_pipeline(
+ renderBundleEncoderRid,
+ pipelineRid,
+ );
+ }
+
+ /**
+ * @param {GPUBuffer} buffer
+ * @param {GPUIndexFormat} indexFormat
+ * @param {number} offset
+ * @param {number} size
+ */
+ setIndexBuffer(buffer, indexFormat, offset = 0, size = 0) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setIndexBuffer' on 'GPURenderBundleEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ buffer = webidl.converters.GPUBuffer(buffer, prefix, "Argument 1");
+ indexFormat = webidl.converters.GPUIndexFormat(
+ indexFormat,
+ prefix,
+ "Argument 2",
+ );
+ offset = webidl.converters.GPUSize64(offset, prefix, "Argument 3");
+ size = webidl.converters.GPUSize64(size, prefix, "Argument 4");
+ const device = assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ const bufferRid = assertResource(buffer, prefix, "Argument 1");
+ assertDeviceMatch(device, buffer, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_bundle_encoder_set_index_buffer(
+ renderBundleEncoderRid,
+ bufferRid,
+ indexFormat,
+ offset,
+ size,
+ );
+ }
+
+ /**
+ * @param {number} slot
+ * @param {GPUBuffer} buffer
+ * @param {number} offset
+ * @param {number} size
+ */
+ setVertexBuffer(slot, buffer, offset = 0, size) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'setVertexBuffer' on 'GPURenderBundleEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ slot = webidl.converters.GPUSize32(slot, prefix, "Argument 1");
+ buffer = webidl.converters.GPUBuffer(buffer, prefix, "Argument 2");
+ offset = webidl.converters.GPUSize64(offset, prefix, "Argument 3");
+ if (size !== undefined) {
+ size = webidl.converters.GPUSize64(size, prefix, "Argument 4");
+ }
+ const device = assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ const bufferRid = assertResource(buffer, prefix, "Argument 2");
+ assertDeviceMatch(device, buffer, {
+ prefix,
+ resourceContext: "Argument 2",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_bundle_encoder_set_vertex_buffer(
+ renderBundleEncoderRid,
+ slot,
+ bufferRid,
+ offset,
+ size,
+ );
+ }
+
+ /**
+ * @param {number} vertexCount
+ * @param {number} instanceCount
+ * @param {number} firstVertex
+ * @param {number} firstInstance
+ */
+ draw(vertexCount, instanceCount = 1, firstVertex = 0, firstInstance = 0) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix = "Failed to execute 'draw' on 'GPURenderBundleEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ vertexCount = webidl.converters.GPUSize32(
+ vertexCount,
+ prefix,
+ "Argument 1",
+ );
+ instanceCount = webidl.converters.GPUSize32(
+ instanceCount,
+ prefix,
+ "Argument 2",
+ );
+ firstVertex = webidl.converters.GPUSize32(
+ firstVertex,
+ prefix,
+ "Argument 3",
+ );
+ firstInstance = webidl.converters.GPUSize32(
+ firstInstance,
+ prefix,
+ "Argument 4",
+ );
+ assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_bundle_encoder_draw(
+ renderBundleEncoderRid,
+ vertexCount,
+ instanceCount,
+ firstVertex,
+ firstInstance,
+ );
+ }
+
+ /**
+ * @param {number} indexCount
+ * @param {number} instanceCount
+ * @param {number} firstIndex
+ * @param {number} baseVertex
+ * @param {number} firstInstance
+ */
+ drawIndexed(
+ indexCount,
+ instanceCount = 1,
+ firstIndex = 0,
+ baseVertex = 0,
+ firstInstance = 0,
+ ) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'drawIndexed' on 'GPURenderBundleEncoder'";
+ webidl.requiredArguments(arguments.length, 1, prefix);
+ indexCount = webidl.converters.GPUSize32(indexCount, prefix, "Argument 1");
+ instanceCount = webidl.converters.GPUSize32(
+ instanceCount,
+ prefix,
+ "Argument 2",
+ );
+ firstIndex = webidl.converters.GPUSize32(firstIndex, prefix, "Argument 3");
+ baseVertex = webidl.converters.GPUSignedOffset32(
+ baseVertex,
+ prefix,
+ "Argument 4",
+ );
+ firstInstance = webidl.converters.GPUSize32(
+ firstInstance,
+ prefix,
+ "Argument 5",
+ );
+ assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ ops.op_webgpu_render_bundle_encoder_draw_indexed(
+ renderBundleEncoderRid,
+ indexCount,
+ instanceCount,
+ firstIndex,
+ baseVertex,
+ firstInstance,
+ );
+ }
+
+ /**
+ * @param {GPUBuffer} indirectBuffer
+ * @param {number} indirectOffset
+ */
+ drawIndirect(indirectBuffer, indirectOffset) {
+ webidl.assertBranded(this, GPURenderBundleEncoderPrototype);
+ const prefix =
+ "Failed to execute 'drawIndirect' on 'GPURenderBundleEncoder'";
+ webidl.requiredArguments(arguments.length, 2, prefix);
+ indirectBuffer = webidl.converters.GPUBuffer(
+ indirectBuffer,
+ prefix,
+ "Argument 1",
+ );
+ indirectOffset = webidl.converters.GPUSize64(
+ indirectOffset,
+ prefix,
+ "Argument 2",
+ );
+ const device = assertDevice(this, prefix, "this");
+ const renderBundleEncoderRid = assertResource(this, prefix, "this");
+ const indirectBufferRid = assertResource(
+ indirectBuffer,
+ prefix,
+ "Argument 1",
+ );
+ assertDeviceMatch(device, indirectBuffer, {
+ prefix,
+ resourceContext: "Argument 1",
+ selfContext: "this",
+ });
+ ops.op_webgpu_render_bundle_encoder_draw_indirect(
+ renderBundleEncoderRid,
+ indirectBufferRid,
+ indirectOffset,
+ );
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(
+ GPURenderBundleEncoderPrototype,
+ this,
+ ),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPURenderBundleEncoder", GPURenderBundleEncoder);
+const GPURenderBundleEncoderPrototype = GPURenderBundleEncoder.prototype;
+
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPURenderBundle}
+ */
+function createGPURenderBundle(label, device, rid) {
+ /** @type {GPURenderBundle} */
+ const bundle = webidl.createBranded(GPURenderBundle);
+ bundle[_label] = label;
+ bundle[_device] = device;
+ bundle[_rid] = rid;
+ return bundle;
+}
+
+class GPURenderBundle {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPURenderBundlePrototype, this),
+ keys: [
+ "label",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPURenderBundle", GPURenderBundle);
+const GPURenderBundlePrototype = GPURenderBundle.prototype;
+/**
+ * @param {string | null} label
+ * @param {InnerGPUDevice} device
+ * @param {number} rid
+ * @returns {GPUQuerySet}
+ */
+function createGPUQuerySet(label, device, rid, descriptor) {
+ /** @type {GPUQuerySet} */
+ const queue = webidl.createBranded(GPUQuerySet);
+ queue[_label] = label;
+ queue[_device] = device;
+ queue[_rid] = rid;
+ queue[_descriptor] = descriptor;
+ return queue;
+}
+
+class GPUQuerySet {
+ /** @type {InnerGPUDevice} */
+ [_device];
+ /** @type {number | undefined} */
+ [_rid];
+ /** @type {GPUQuerySetDescriptor} */
+ [_descriptor];
+ /** @type {GPUQueryType} */
+ [_type];
+ /** @type {number} */
+ [_count];
+
+ [_cleanup]() {
+ const rid = this[_rid];
+ if (rid !== undefined) {
+ core.close(rid);
+ /** @type {number | undefined} */
+ this[_rid] = undefined;
+ }
+ }
+
+ constructor() {
+ webidl.illegalConstructor();
+ }
+
+ destroy() {
+ webidl.assertBranded(this, GPUQuerySetPrototype);
+ this[_cleanup]();
+ }
+
+ get type() {
+ webidl.assertBranded(this, GPUQuerySetPrototype);
+ return this[_type]();
+ }
+
+ get count() {
+ webidl.assertBranded(this, GPUQuerySetPrototype);
+ return this[_count]();
+ }
+
+ [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
+ return inspect(
+ createFilteredInspectProxy({
+ object: this,
+ evaluate: ObjectPrototypeIsPrototypeOf(GPUQuerySetPrototype, this),
+ keys: [
+ "label",
+ "type",
+ "count",
+ ],
+ }),
+ inspectOptions,
+ );
+ }
+}
+GPUObjectBaseMixin("GPUQuerySet", GPUQuerySet);
+const GPUQuerySetPrototype = GPUQuerySet.prototype;
+
+// Converters
+
+// This needs to be initialized after all of the base classes are implemented,
+// otherwise their converters might not be available yet.
+// DICTIONARY: GPUObjectDescriptorBase
+const dictMembersGPUObjectDescriptorBase = [
+ { key: "label", converter: webidl.converters["USVString"], defaultValue: "" },
+];
+webidl.converters["GPUObjectDescriptorBase"] = webidl
+ .createDictionaryConverter(
+ "GPUObjectDescriptorBase",
+ dictMembersGPUObjectDescriptorBase,
+ );
+
+// INTERFACE: GPUSupportedLimits
+webidl.converters.GPUSupportedLimits = webidl.createInterfaceConverter(
+ "GPUSupportedLimits",
+ GPUSupportedLimits.prototype,
+);
+
+// INTERFACE: GPUSupportedFeatures
+webidl.converters.GPUSupportedFeatures = webidl.createInterfaceConverter(
+ "GPUSupportedFeatures",
+ GPUSupportedFeatures.prototype,
+);
+
+// INTERFACE: GPU
+webidl.converters.GPU = webidl.createInterfaceConverter("GPU", GPU.prototype);
+
+// ENUM: GPUPowerPreference
+webidl.converters["GPUPowerPreference"] = webidl.createEnumConverter(
+ "GPUPowerPreference",
+ [
+ "low-power",
+ "high-performance",
+ ],
+);
+
+// DICTIONARY: GPURequestAdapterOptions
+const dictMembersGPURequestAdapterOptions = [
+ {
+ key: "powerPreference",
+ converter: webidl.converters["GPUPowerPreference"],
+ },
+ {
+ key: "forceFallbackAdapter",
+ converter: webidl.converters.boolean,
+ defaultValue: false,
+ },
+];
+webidl.converters["GPURequestAdapterOptions"] = webidl
+ .createDictionaryConverter(
+ "GPURequestAdapterOptions",
+ dictMembersGPURequestAdapterOptions,
+ );
+
+// INTERFACE: GPUAdapter
+webidl.converters.GPUAdapter = webidl.createInterfaceConverter(
+ "GPUAdapter",
+ GPUAdapter.prototype,
+);
+
+// ENUM: GPUFeatureName
+webidl.converters["GPUFeatureName"] = webidl.createEnumConverter(
+ "GPUFeatureName",
+ [
+ // api
+ "depth-clip-control",
+ "timestamp-query",
+ "indirect-first-instance",
+ // shader
+ "shader-f16",
+ // texture formats
+ "depth32float-stencil8",
+ "texture-compression-bc",
+ "texture-compression-etc2",
+ "texture-compression-astc",
+ "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",
+ ],
+);
+
+// TYPEDEF: GPUSize32
+webidl.converters["GPUSize32"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// TYPEDEF: GPUSize64
+webidl.converters["GPUSize64"] = (V, opts) =>
+ webidl.converters["unsigned long long"](V, { ...opts, enforceRange: true });
+
+// DICTIONARY: GPUDeviceDescriptor
+const dictMembersGPUDeviceDescriptor = [
+ {
+ key: "requiredFeatures",
+ converter: webidl.createSequenceConverter(
+ webidl.converters["GPUFeatureName"],
+ ),
+ get defaultValue() {
+ return [];
+ },
+ },
+ {
+ key: "requiredLimits",
+ converter: webidl.createRecordConverter(
+ webidl.converters["DOMString"],
+ webidl.converters["GPUSize64"],
+ ),
+ },
+];
+webidl.converters["GPUDeviceDescriptor"] = webidl.createDictionaryConverter(
+ "GPUDeviceDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUDeviceDescriptor,
+);
+
+// INTERFACE: GPUDevice
+webidl.converters.GPUDevice = webidl.createInterfaceConverter(
+ "GPUDevice",
+ GPUDevice.prototype,
+);
+
+// INTERFACE: GPUBuffer
+webidl.converters.GPUBuffer = webidl.createInterfaceConverter(
+ "GPUBuffer",
+ GPUBuffer.prototype,
+);
+
+// TYPEDEF: GPUBufferUsageFlags
+webidl.converters["GPUBufferUsageFlags"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// DICTIONARY: GPUBufferDescriptor
+const dictMembersGPUBufferDescriptor = [
+ { key: "size", converter: webidl.converters["GPUSize64"], required: true },
+ {
+ key: "usage",
+ converter: webidl.converters["GPUBufferUsageFlags"],
+ required: true,
+ },
+ {
+ key: "mappedAtCreation",
+ converter: webidl.converters["boolean"],
+ defaultValue: false,
+ },
+];
+webidl.converters["GPUBufferDescriptor"] = webidl.createDictionaryConverter(
+ "GPUBufferDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUBufferDescriptor,
+);
+
+// INTERFACE: GPUBufferUsage
+webidl.converters.GPUBufferUsage = webidl.createInterfaceConverter(
+ "GPUBufferUsage",
+ GPUBufferUsage.prototype,
+);
+
+// TYPEDEF: GPUMapModeFlags
+webidl.converters["GPUMapModeFlags"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// INTERFACE: GPUMapMode
+webidl.converters.GPUMapMode = webidl.createInterfaceConverter(
+ "GPUMapMode",
+ GPUMapMode.prototype,
+);
+
+// INTERFACE: GPUTexture
+webidl.converters.GPUTexture = webidl.createInterfaceConverter(
+ "GPUTexture",
+ GPUTexture.prototype,
+);
+
+// TYPEDEF: GPUIntegerCoordinate
+webidl.converters["GPUIntegerCoordinate"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+webidl.converters["sequence<GPUIntegerCoordinate>"] = webidl
+ .createSequenceConverter(webidl.converters["GPUIntegerCoordinate"]);
+
+// DICTIONARY: GPUExtent3DDict
+const dictMembersGPUExtent3DDict = [
+ {
+ key: "width",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ required: true,
+ },
+ {
+ key: "height",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 1,
+ },
+ {
+ key: "depthOrArrayLayers",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 1,
+ },
+];
+webidl.converters["GPUExtent3DDict"] = webidl.createDictionaryConverter(
+ "GPUExtent3DDict",
+ dictMembersGPUExtent3DDict,
+);
+
+// TYPEDEF: GPUExtent3D
+webidl.converters["GPUExtent3D"] = (V, opts) => {
+ // Union for (sequence<GPUIntegerCoordinate> or GPUExtent3DDict)
+ if (V === null || V === undefined) {
+ return webidl.converters["GPUExtent3DDict"](V, opts);
+ }
+ if (typeof V === "object") {
+ const method = V[SymbolIterator];
+ if (method !== undefined) {
+ return webidl.converters["sequence<GPUIntegerCoordinate>"](V, opts);
+ }
+ return webidl.converters["GPUExtent3DDict"](V, opts);
+ }
+ throw webidl.makeException(
+ TypeError,
+ "can not be converted to sequence<GPUIntegerCoordinate> or GPUExtent3DDict.",
+ opts,
+ );
+};
+
+// ENUM: GPUTextureDimension
+webidl.converters["GPUTextureDimension"] = webidl.createEnumConverter(
+ "GPUTextureDimension",
+ [
+ "1d",
+ "2d",
+ "3d",
+ ],
+);
+
+// ENUM: GPUTextureFormat
+webidl.converters["GPUTextureFormat"] = webidl.createEnumConverter(
+ "GPUTextureFormat",
+ [
+ "r8unorm",
+ "r8snorm",
+ "r8uint",
+ "r8sint",
+ "r16uint",
+ "r16sint",
+ "r16float",
+ "rg8unorm",
+ "rg8snorm",
+ "rg8uint",
+ "rg8sint",
+ "r32uint",
+ "r32sint",
+ "r32float",
+ "rg16uint",
+ "rg16sint",
+ "rg16float",
+ "rgba8unorm",
+ "rgba8unorm-srgb",
+ "rgba8snorm",
+ "rgba8uint",
+ "rgba8sint",
+ "bgra8unorm",
+ "bgra8unorm-srgb",
+ "rgb9e5ufloat",
+ "rgb10a2unorm",
+ "rg11b10ufloat",
+ "rg32uint",
+ "rg32sint",
+ "rg32float",
+ "rgba16uint",
+ "rgba16sint",
+ "rgba16float",
+ "rgba32uint",
+ "rgba32sint",
+ "rgba32float",
+ "stencil8",
+ "depth16unorm",
+ "depth24plus",
+ "depth24plus-stencil8",
+ "depth32float",
+ "depth32float-stencil8",
+ "bc1-rgba-unorm",
+ "bc1-rgba-unorm-srgb",
+ "bc2-rgba-unorm",
+ "bc2-rgba-unorm-srgb",
+ "bc3-rgba-unorm",
+ "bc3-rgba-unorm-srgb",
+ "bc4-r-unorm",
+ "bc4-r-snorm",
+ "bc5-rg-unorm",
+ "bc5-rg-snorm",
+ "bc6h-rgb-ufloat",
+ "bc6h-rgb-float",
+ "bc7-rgba-unorm",
+ "bc7-rgba-unorm-srgb",
+ "etc2-rgb8unorm",
+ "etc2-rgb8unorm-srgb",
+ "etc2-rgb8a1unorm",
+ "etc2-rgb8a1unorm-srgb",
+ "etc2-rgba8unorm",
+ "etc2-rgba8unorm-srgb",
+ "eac-r11unorm",
+ "eac-r11snorm",
+ "eac-rg11unorm",
+ "eac-rg11snorm",
+ "astc-4x4-unorm",
+ "astc-4x4-unorm-srgb",
+ "astc-5x4-unorm",
+ "astc-5x4-unorm-srgb",
+ "astc-5x5-unorm",
+ "astc-5x5-unorm-srgb",
+ "astc-6x5-unorm",
+ "astc-6x5-unorm-srgb",
+ "astc-6x6-unorm",
+ "astc-6x6-unorm-srgb",
+ "astc-8x5-unorm",
+ "astc-8x5-unorm-srgb",
+ "astc-8x6-unorm",
+ "astc-8x6-unorm-srgb",
+ "astc-8x8-unorm",
+ "astc-8x8-unorm-srgb",
+ "astc-10x5-unorm",
+ "astc-10x5-unorm-srgb",
+ "astc-10x6-unorm",
+ "astc-10x6-unorm-srgb",
+ "astc-10x8-unorm",
+ "astc-10x8-unorm-srgb",
+ "astc-10x10-unorm",
+ "astc-10x10-unorm-srgb",
+ "astc-12x10-unorm",
+ "astc-12x10-unorm-srgb",
+ "astc-12x12-unorm",
+ "astc-12x12-unorm-srgb",
+ ],
+);
+
+// TYPEDEF: GPUTextureUsageFlags
+webidl.converters["GPUTextureUsageFlags"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// DICTIONARY: GPUTextureDescriptor
+const dictMembersGPUTextureDescriptor = [
+ {
+ key: "size",
+ converter: webidl.converters["GPUExtent3D"],
+ required: true,
+ },
+ {
+ key: "mipLevelCount",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 1,
+ },
+ {
+ key: "sampleCount",
+ converter: webidl.converters["GPUSize32"],
+ defaultValue: 1,
+ },
+ {
+ key: "dimension",
+ converter: webidl.converters["GPUTextureDimension"],
+ defaultValue: "2d",
+ },
+ {
+ key: "format",
+ converter: webidl.converters["GPUTextureFormat"],
+ required: true,
+ },
+ {
+ key: "usage",
+ converter: webidl.converters["GPUTextureUsageFlags"],
+ required: true,
+ },
+ {
+ key: "viewFormats",
+ converter: webidl.createSequenceConverter(
+ webidl.converters["GPUTextureFormat"],
+ ),
+ get defaultValue() {
+ return [];
+ },
+ },
+];
+webidl.converters["GPUTextureDescriptor"] = webidl.createDictionaryConverter(
+ "GPUTextureDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUTextureDescriptor,
+);
+
+// INTERFACE: GPUTextureUsage
+webidl.converters.GPUTextureUsage = webidl.createInterfaceConverter(
+ "GPUTextureUsage",
+ GPUTextureUsage.prototype,
+);
+
+// INTERFACE: GPUTextureView
+webidl.converters.GPUTextureView = webidl.createInterfaceConverter(
+ "GPUTextureView",
+ GPUTextureView.prototype,
+);
+
+// ENUM: GPUTextureViewDimension
+webidl.converters["GPUTextureViewDimension"] = webidl.createEnumConverter(
+ "GPUTextureViewDimension",
+ [
+ "1d",
+ "2d",
+ "2d-array",
+ "cube",
+ "cube-array",
+ "3d",
+ ],
+);
+
+// ENUM: GPUTextureAspect
+webidl.converters["GPUTextureAspect"] = webidl.createEnumConverter(
+ "GPUTextureAspect",
+ [
+ "all",
+ "stencil-only",
+ "depth-only",
+ ],
+);
+
+// DICTIONARY: GPUTextureViewDescriptor
+const dictMembersGPUTextureViewDescriptor = [
+ { key: "format", converter: webidl.converters["GPUTextureFormat"] },
+ {
+ key: "dimension",
+ converter: webidl.converters["GPUTextureViewDimension"],
+ },
+ {
+ key: "aspect",
+ converter: webidl.converters["GPUTextureAspect"],
+ defaultValue: "all",
+ },
+ {
+ key: "baseMipLevel",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 0,
+ },
+ {
+ key: "mipLevelCount",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ },
+ {
+ key: "baseArrayLayer",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 0,
+ },
+ {
+ key: "arrayLayerCount",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ },
+];
+webidl.converters["GPUTextureViewDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUTextureViewDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUTextureViewDescriptor,
+ );
+
+// INTERFACE: GPUSampler
+webidl.converters.GPUSampler = webidl.createInterfaceConverter(
+ "GPUSampler",
+ GPUSampler.prototype,
+);
+
+// ENUM: GPUAddressMode
+webidl.converters["GPUAddressMode"] = webidl.createEnumConverter(
+ "GPUAddressMode",
+ [
+ "clamp-to-edge",
+ "repeat",
+ "mirror-repeat",
+ ],
+);
+
+// ENUM: GPUFilterMode
+webidl.converters["GPUFilterMode"] = webidl.createEnumConverter(
+ "GPUFilterMode",
+ [
+ "nearest",
+ "linear",
+ ],
+);
+
+// ENUM: GPUMipmapFilterMode
+webidl.converters["GPUMipmapFilterMode"] = webidl.createEnumConverter(
+ "GPUMipmapFilterMode",
+ [
+ "nearest",
+ "linear",
+ ],
+);
+
+// ENUM: GPUCompareFunction
+webidl.converters["GPUCompareFunction"] = webidl.createEnumConverter(
+ "GPUCompareFunction",
+ [
+ "never",
+ "less",
+ "equal",
+ "less-equal",
+ "greater",
+ "not-equal",
+ "greater-equal",
+ "always",
+ ],
+);
+
+// DICTIONARY: GPUSamplerDescriptor
+const dictMembersGPUSamplerDescriptor = [
+ {
+ key: "addressModeU",
+ converter: webidl.converters["GPUAddressMode"],
+ defaultValue: "clamp-to-edge",
+ },
+ {
+ key: "addressModeV",
+ converter: webidl.converters["GPUAddressMode"],
+ defaultValue: "clamp-to-edge",
+ },
+ {
+ key: "addressModeW",
+ converter: webidl.converters["GPUAddressMode"],
+ defaultValue: "clamp-to-edge",
+ },
+ {
+ key: "magFilter",
+ converter: webidl.converters["GPUFilterMode"],
+ defaultValue: "nearest",
+ },
+ {
+ key: "minFilter",
+ converter: webidl.converters["GPUFilterMode"],
+ defaultValue: "nearest",
+ },
+ {
+ key: "mipmapFilter",
+ converter: webidl.converters["GPUMipmapFilterMode"],
+ defaultValue: "nearest",
+ },
+ {
+ key: "lodMinClamp",
+ converter: webidl.converters["float"],
+ defaultValue: 0,
+ },
+ {
+ key: "lodMaxClamp",
+ converter: webidl.converters["float"],
+ defaultValue: 0xffffffff,
+ },
+ { key: "compare", converter: webidl.converters["GPUCompareFunction"] },
+ {
+ key: "maxAnisotropy",
+ converter: (V, opts) =>
+ webidl.converters["unsigned short"](V, { ...opts, clamp: true }),
+ defaultValue: 1,
+ },
+];
+webidl.converters["GPUSamplerDescriptor"] = webidl.createDictionaryConverter(
+ "GPUSamplerDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUSamplerDescriptor,
+);
+
+// INTERFACE: GPUBindGroupLayout
+webidl.converters.GPUBindGroupLayout = webidl.createInterfaceConverter(
+ "GPUBindGroupLayout",
+ GPUBindGroupLayout.prototype,
+);
+
+// TYPEDEF: GPUIndex32
+webidl.converters["GPUIndex32"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// TYPEDEF: GPUShaderStageFlags
+webidl.converters["GPUShaderStageFlags"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// ENUM: GPUBufferBindingType
+webidl.converters["GPUBufferBindingType"] = webidl.createEnumConverter(
+ "GPUBufferBindingType",
+ [
+ "uniform",
+ "storage",
+ "read-only-storage",
+ ],
+);
+
+// DICTIONARY: GPUBufferBindingLayout
+const dictMembersGPUBufferBindingLayout = [
+ {
+ key: "type",
+ converter: webidl.converters["GPUBufferBindingType"],
+ defaultValue: "uniform",
+ },
+ {
+ key: "hasDynamicOffset",
+ converter: webidl.converters["boolean"],
+ defaultValue: false,
+ },
+ {
+ key: "minBindingSize",
+ converter: webidl.converters["GPUSize64"],
+ defaultValue: 0,
+ },
+];
+webidl.converters["GPUBufferBindingLayout"] = webidl
+ .createDictionaryConverter(
+ "GPUBufferBindingLayout",
+ dictMembersGPUBufferBindingLayout,
+ );
+
+// ENUM: GPUSamplerBindingType
+webidl.converters["GPUSamplerBindingType"] = webidl.createEnumConverter(
+ "GPUSamplerBindingType",
+ [
+ "filtering",
+ "non-filtering",
+ "comparison",
+ ],
+);
+
+// DICTIONARY: GPUSamplerBindingLayout
+const dictMembersGPUSamplerBindingLayout = [
+ {
+ key: "type",
+ converter: webidl.converters["GPUSamplerBindingType"],
+ defaultValue: "filtering",
+ },
+];
+webidl.converters["GPUSamplerBindingLayout"] = webidl
+ .createDictionaryConverter(
+ "GPUSamplerBindingLayout",
+ dictMembersGPUSamplerBindingLayout,
+ );
+
+// ENUM: GPUTextureSampleType
+webidl.converters["GPUTextureSampleType"] = webidl.createEnumConverter(
+ "GPUTextureSampleType",
+ [
+ "float",
+ "unfilterable-float",
+ "depth",
+ "sint",
+ "uint",
+ ],
+);
+
+// DICTIONARY: GPUTextureBindingLayout
+const dictMembersGPUTextureBindingLayout = [
+ {
+ key: "sampleType",
+ converter: webidl.converters["GPUTextureSampleType"],
+ defaultValue: "float",
+ },
+ {
+ key: "viewDimension",
+ converter: webidl.converters["GPUTextureViewDimension"],
+ defaultValue: "2d",
+ },
+ {
+ key: "multisampled",
+ converter: webidl.converters["boolean"],
+ defaultValue: false,
+ },
+];
+webidl.converters["GPUTextureBindingLayout"] = webidl
+ .createDictionaryConverter(
+ "GPUTextureBindingLayout",
+ dictMembersGPUTextureBindingLayout,
+ );
+
+// ENUM: GPUStorageTextureAccess
+webidl.converters["GPUStorageTextureAccess"] = webidl.createEnumConverter(
+ "GPUStorageTextureAccess",
+ [
+ "write-only",
+ ],
+);
+
+// DICTIONARY: GPUStorageTextureBindingLayout
+const dictMembersGPUStorageTextureBindingLayout = [
+ {
+ key: "access",
+ converter: webidl.converters["GPUStorageTextureAccess"],
+ defaultValue: "write-only",
+ },
+ {
+ key: "format",
+ converter: webidl.converters["GPUTextureFormat"],
+ required: true,
+ },
+ {
+ key: "viewDimension",
+ converter: webidl.converters["GPUTextureViewDimension"],
+ defaultValue: "2d",
+ },
+];
+webidl.converters["GPUStorageTextureBindingLayout"] = webidl
+ .createDictionaryConverter(
+ "GPUStorageTextureBindingLayout",
+ dictMembersGPUStorageTextureBindingLayout,
+ );
+
+// DICTIONARY: GPUBindGroupLayoutEntry
+const dictMembersGPUBindGroupLayoutEntry = [
+ {
+ key: "binding",
+ converter: webidl.converters["GPUIndex32"],
+ required: true,
+ },
+ {
+ key: "visibility",
+ converter: webidl.converters["GPUShaderStageFlags"],
+ required: true,
+ },
+ { key: "buffer", converter: webidl.converters["GPUBufferBindingLayout"] },
+ { key: "sampler", converter: webidl.converters["GPUSamplerBindingLayout"] },
+ { key: "texture", converter: webidl.converters["GPUTextureBindingLayout"] },
+ {
+ key: "storageTexture",
+ converter: webidl.converters["GPUStorageTextureBindingLayout"],
+ },
+];
+webidl.converters["GPUBindGroupLayoutEntry"] = webidl
+ .createDictionaryConverter(
+ "GPUBindGroupLayoutEntry",
+ dictMembersGPUBindGroupLayoutEntry,
+ );
+
+// DICTIONARY: GPUBindGroupLayoutDescriptor
+const dictMembersGPUBindGroupLayoutDescriptor = [
+ {
+ key: "entries",
+ converter: webidl.createSequenceConverter(
+ webidl.converters["GPUBindGroupLayoutEntry"],
+ ),
+ required: true,
+ },
+];
+webidl.converters["GPUBindGroupLayoutDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUBindGroupLayoutDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUBindGroupLayoutDescriptor,
+ );
+
+// INTERFACE: GPUShaderStage
+webidl.converters.GPUShaderStage = webidl.createInterfaceConverter(
+ "GPUShaderStage",
+ GPUShaderStage.prototype,
+);
+
+// INTERFACE: GPUBindGroup
+webidl.converters.GPUBindGroup = webidl.createInterfaceConverter(
+ "GPUBindGroup",
+ GPUBindGroup.prototype,
+);
+
+// DICTIONARY: GPUBufferBinding
+const dictMembersGPUBufferBinding = [
+ {
+ key: "buffer",
+ converter: webidl.converters["GPUBuffer"],
+ required: true,
+ },
+ {
+ key: "offset",
+ converter: webidl.converters["GPUSize64"],
+ defaultValue: 0,
+ },
+ { key: "size", converter: webidl.converters["GPUSize64"] },
+];
+webidl.converters["GPUBufferBinding"] = webidl.createDictionaryConverter(
+ "GPUBufferBinding",
+ dictMembersGPUBufferBinding,
+);
+
+// TYPEDEF: GPUBindingResource
+webidl.converters["GPUBindingResource"] =
+ webidl.converters.any /** put union here! **/;
+
+// DICTIONARY: GPUBindGroupEntry
+const dictMembersGPUBindGroupEntry = [
+ {
+ key: "binding",
+ converter: webidl.converters["GPUIndex32"],
+ required: true,
+ },
+ {
+ key: "resource",
+ converter: webidl.converters["GPUBindingResource"],
+ required: true,
+ },
+];
+webidl.converters["GPUBindGroupEntry"] = webidl.createDictionaryConverter(
+ "GPUBindGroupEntry",
+ dictMembersGPUBindGroupEntry,
+);
+
+// DICTIONARY: GPUBindGroupDescriptor
+const dictMembersGPUBindGroupDescriptor = [
+ {
+ key: "layout",
+ converter: webidl.converters["GPUBindGroupLayout"],
+ required: true,
+ },
+ {
+ key: "entries",
+ converter: webidl.createSequenceConverter(
+ webidl.converters["GPUBindGroupEntry"],
+ ),
+ required: true,
+ },
+];
+webidl.converters["GPUBindGroupDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUBindGroupDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUBindGroupDescriptor,
+ );
+
+// INTERFACE: GPUPipelineLayout
+webidl.converters.GPUPipelineLayout = webidl.createInterfaceConverter(
+ "GPUPipelineLayout",
+ GPUPipelineLayout.prototype,
+);
+
+// DICTIONARY: GPUPipelineLayoutDescriptor
+const dictMembersGPUPipelineLayoutDescriptor = [
+ {
+ key: "bindGroupLayouts",
+ converter: webidl.createSequenceConverter(
+ webidl.converters["GPUBindGroupLayout"],
+ ),
+ required: true,
+ },
+];
+webidl.converters["GPUPipelineLayoutDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUPipelineLayoutDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUPipelineLayoutDescriptor,
+ );
+
+// INTERFACE: GPUShaderModule
+webidl.converters.GPUShaderModule = webidl.createInterfaceConverter(
+ "GPUShaderModule",
+ GPUShaderModule.prototype,
+);
+
+// DICTIONARY: GPUShaderModuleDescriptor
+const dictMembersGPUShaderModuleDescriptor = [
+ {
+ key: "code",
+ converter: webidl.converters["DOMString"],
+ required: true,
+ },
+];
+webidl.converters["GPUShaderModuleDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUShaderModuleDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUShaderModuleDescriptor,
+ );
+
+// // ENUM: GPUCompilationMessageType
+// webidl.converters["GPUCompilationMessageType"] = webidl.createEnumConverter(
+// "GPUCompilationMessageType",
+// [
+// "error",
+// "warning",
+// "info",
+// ],
+// );
+
+// // INTERFACE: GPUCompilationMessage
+// webidl.converters.GPUCompilationMessage = webidl.createInterfaceConverter(
+// "GPUCompilationMessage",
+// GPUCompilationMessage.prototype,
+// );
+
+// // INTERFACE: GPUCompilationInfo
+// webidl.converters.GPUCompilationInfo = webidl.createInterfaceConverter(
+// "GPUCompilationInfo",
+// GPUCompilationInfo.prototype,
+// );
+
+webidl.converters["GPUAutoLayoutMode"] = webidl.createEnumConverter(
+ "GPUAutoLayoutMode",
+ [
+ "auto",
+ ],
+);
+
+webidl.converters["GPUPipelineLayout or GPUAutoLayoutMode"] = (V, opts) => {
+ if (typeof V === "object") {
+ return webidl.converters["GPUPipelineLayout"](V, opts);
+ }
+ return webidl.converters["GPUAutoLayoutMode"](V, opts);
+};
+
+// DICTIONARY: GPUPipelineDescriptorBase
+const dictMembersGPUPipelineDescriptorBase = [
+ {
+ key: "layout",
+ converter: webidl.converters["GPUPipelineLayout or GPUAutoLayoutMode"],
+ required: true,
+ },
+];
+webidl.converters["GPUPipelineDescriptorBase"] = webidl
+ .createDictionaryConverter(
+ "GPUPipelineDescriptorBase",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUPipelineDescriptorBase,
+ );
+
+// TYPEDEF: GPUPipelineConstantValue
+webidl.converters.GPUPipelineConstantValue = webidl.converters.double;
+
+webidl.converters["record<USVString, GPUPipelineConstantValue>"] = webidl
+ .createRecordConverter(
+ webidl.converters.USVString,
+ webidl.converters.GPUPipelineConstantValue,
+ );
+
+// DICTIONARY: GPUProgrammableStage
+const dictMembersGPUProgrammableStage = [
+ {
+ key: "module",
+ converter: webidl.converters["GPUShaderModule"],
+ required: true,
+ },
+ {
+ key: "entryPoint",
+ converter: webidl.converters["USVString"],
+ required: true,
+ },
+ {
+ key: "constants",
+ converter: webidl.converters["record<USVString, GPUPipelineConstantValue>"],
+ },
+];
+webidl.converters["GPUProgrammableStage"] = webidl.createDictionaryConverter(
+ "GPUProgrammableStage",
+ dictMembersGPUProgrammableStage,
+);
+
+// INTERFACE: GPUComputePipeline
+webidl.converters.GPUComputePipeline = webidl.createInterfaceConverter(
+ "GPUComputePipeline",
+ GPUComputePipeline.prototype,
+);
+
+// DICTIONARY: GPUComputePipelineDescriptor
+const dictMembersGPUComputePipelineDescriptor = [
+ {
+ key: "compute",
+ converter: webidl.converters["GPUProgrammableStage"],
+ required: true,
+ },
+];
+webidl.converters["GPUComputePipelineDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUComputePipelineDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUPipelineDescriptorBase,
+ dictMembersGPUComputePipelineDescriptor,
+ );
+
+// INTERFACE: GPURenderPipeline
+webidl.converters.GPURenderPipeline = webidl.createInterfaceConverter(
+ "GPURenderPipeline",
+ GPURenderPipeline.prototype,
+);
+
+// ENUM: GPUVertexStepMode
+webidl.converters["GPUVertexStepMode"] = webidl.createEnumConverter(
+ "GPUVertexStepMode",
+ [
+ "vertex",
+ "instance",
+ ],
+);
+
+// ENUM: GPUVertexFormat
+webidl.converters["GPUVertexFormat"] = webidl.createEnumConverter(
+ "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",
+ ],
+);
+
+// DICTIONARY: GPUVertexAttribute
+const dictMembersGPUVertexAttribute = [
+ {
+ key: "format",
+ converter: webidl.converters["GPUVertexFormat"],
+ required: true,
+ },
+ {
+ key: "offset",
+ converter: webidl.converters["GPUSize64"],
+ required: true,
+ },
+ {
+ key: "shaderLocation",
+ converter: webidl.converters["GPUIndex32"],
+ required: true,
+ },
+];
+webidl.converters["GPUVertexAttribute"] = webidl.createDictionaryConverter(
+ "GPUVertexAttribute",
+ dictMembersGPUVertexAttribute,
+);
+
+// DICTIONARY: GPUVertexBufferLayout
+const dictMembersGPUVertexBufferLayout = [
+ {
+ key: "arrayStride",
+ converter: webidl.converters["GPUSize64"],
+ required: true,
+ },
+ {
+ key: "stepMode",
+ converter: webidl.converters["GPUVertexStepMode"],
+ defaultValue: "vertex",
+ },
+ {
+ key: "attributes",
+ converter: webidl.createSequenceConverter(
+ webidl.converters["GPUVertexAttribute"],
+ ),
+ required: true,
+ },
+];
+webidl.converters["GPUVertexBufferLayout"] = webidl.createDictionaryConverter(
+ "GPUVertexBufferLayout",
+ dictMembersGPUVertexBufferLayout,
+);
+
+// DICTIONARY: GPUVertexState
+const dictMembersGPUVertexState = [
+ {
+ key: "buffers",
+ converter: webidl.createSequenceConverter(
+ webidl.createNullableConverter(
+ webidl.converters["GPUVertexBufferLayout"],
+ ),
+ ),
+ get defaultValue() {
+ return [];
+ },
+ },
+];
+webidl.converters["GPUVertexState"] = webidl.createDictionaryConverter(
+ "GPUVertexState",
+ dictMembersGPUProgrammableStage,
+ dictMembersGPUVertexState,
+);
+
+// ENUM: GPUPrimitiveTopology
+webidl.converters["GPUPrimitiveTopology"] = webidl.createEnumConverter(
+ "GPUPrimitiveTopology",
+ [
+ "point-list",
+ "line-list",
+ "line-strip",
+ "triangle-list",
+ "triangle-strip",
+ ],
+);
+
+// ENUM: GPUIndexFormat
+webidl.converters["GPUIndexFormat"] = webidl.createEnumConverter(
+ "GPUIndexFormat",
+ [
+ "uint16",
+ "uint32",
+ ],
+);
+
+// ENUM: GPUFrontFace
+webidl.converters["GPUFrontFace"] = webidl.createEnumConverter(
+ "GPUFrontFace",
+ [
+ "ccw",
+ "cw",
+ ],
+);
+
+// ENUM: GPUCullMode
+webidl.converters["GPUCullMode"] = webidl.createEnumConverter("GPUCullMode", [
+ "none",
+ "front",
+ "back",
+]);
+
+// DICTIONARY: GPUPrimitiveState
+const dictMembersGPUPrimitiveState = [
+ {
+ key: "topology",
+ converter: webidl.converters["GPUPrimitiveTopology"],
+ defaultValue: "triangle-list",
+ },
+ { key: "stripIndexFormat", converter: webidl.converters["GPUIndexFormat"] },
+ {
+ key: "frontFace",
+ converter: webidl.converters["GPUFrontFace"],
+ defaultValue: "ccw",
+ },
+ {
+ key: "cullMode",
+ converter: webidl.converters["GPUCullMode"],
+ defaultValue: "none",
+ },
+ {
+ key: "unclippedDepth",
+ converter: webidl.converters["boolean"],
+ defaultValue: false,
+ },
+];
+webidl.converters["GPUPrimitiveState"] = webidl.createDictionaryConverter(
+ "GPUPrimitiveState",
+ dictMembersGPUPrimitiveState,
+);
+
+// ENUM: GPUStencilOperation
+webidl.converters["GPUStencilOperation"] = webidl.createEnumConverter(
+ "GPUStencilOperation",
+ [
+ "keep",
+ "zero",
+ "replace",
+ "invert",
+ "increment-clamp",
+ "decrement-clamp",
+ "increment-wrap",
+ "decrement-wrap",
+ ],
+);
+
+// DICTIONARY: GPUStencilFaceState
+const dictMembersGPUStencilFaceState = [
+ {
+ key: "compare",
+ converter: webidl.converters["GPUCompareFunction"],
+ defaultValue: "always",
+ },
+ {
+ key: "failOp",
+ converter: webidl.converters["GPUStencilOperation"],
+ defaultValue: "keep",
+ },
+ {
+ key: "depthFailOp",
+ converter: webidl.converters["GPUStencilOperation"],
+ defaultValue: "keep",
+ },
+ {
+ key: "passOp",
+ converter: webidl.converters["GPUStencilOperation"],
+ defaultValue: "keep",
+ },
+];
+webidl.converters["GPUStencilFaceState"] = webidl.createDictionaryConverter(
+ "GPUStencilFaceState",
+ dictMembersGPUStencilFaceState,
+);
+
+// TYPEDEF: GPUStencilValue
+webidl.converters["GPUStencilValue"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// TYPEDEF: GPUDepthBias
+webidl.converters["GPUDepthBias"] = (V, opts) =>
+ webidl.converters["long"](V, { ...opts, enforceRange: true });
+
+// DICTIONARY: GPUDepthStencilState
+const dictMembersGPUDepthStencilState = [
+ {
+ key: "format",
+ converter: webidl.converters["GPUTextureFormat"],
+ required: true,
+ },
+ {
+ key: "depthWriteEnabled",
+ converter: webidl.converters["boolean"],
+ required: true,
+ },
+ {
+ key: "depthCompare",
+ converter: webidl.converters["GPUCompareFunction"],
+ required: true,
+ },
+ {
+ key: "stencilFront",
+ converter: webidl.converters["GPUStencilFaceState"],
+ get defaultValue() {
+ return {};
+ },
+ },
+ {
+ key: "stencilBack",
+ converter: webidl.converters["GPUStencilFaceState"],
+ get defaultValue() {
+ return {};
+ },
+ },
+ {
+ key: "stencilReadMask",
+ converter: webidl.converters["GPUStencilValue"],
+ defaultValue: 0xFFFFFFFF,
+ },
+ {
+ key: "stencilWriteMask",
+ converter: webidl.converters["GPUStencilValue"],
+ defaultValue: 0xFFFFFFFF,
+ },
+ {
+ key: "depthBias",
+ converter: webidl.converters["GPUDepthBias"],
+ defaultValue: 0,
+ },
+ {
+ key: "depthBiasSlopeScale",
+ converter: webidl.converters["float"],
+ defaultValue: 0,
+ },
+ {
+ key: "depthBiasClamp",
+ converter: webidl.converters["float"],
+ defaultValue: 0,
+ },
+];
+webidl.converters["GPUDepthStencilState"] = webidl.createDictionaryConverter(
+ "GPUDepthStencilState",
+ dictMembersGPUDepthStencilState,
+);
+
+// TYPEDEF: GPUSampleMask
+webidl.converters["GPUSampleMask"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// DICTIONARY: GPUMultisampleState
+const dictMembersGPUMultisampleState = [
+ {
+ key: "count",
+ converter: webidl.converters["GPUSize32"],
+ defaultValue: 1,
+ },
+ {
+ key: "mask",
+ converter: webidl.converters["GPUSampleMask"],
+ defaultValue: 0xFFFFFFFF,
+ },
+ {
+ key: "alphaToCoverageEnabled",
+ converter: webidl.converters["boolean"],
+ defaultValue: false,
+ },
+];
+webidl.converters["GPUMultisampleState"] = webidl.createDictionaryConverter(
+ "GPUMultisampleState",
+ dictMembersGPUMultisampleState,
+);
+
+// ENUM: GPUBlendFactor
+webidl.converters["GPUBlendFactor"] = webidl.createEnumConverter(
+ "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
+webidl.converters["GPUBlendOperation"] = webidl.createEnumConverter(
+ "GPUBlendOperation",
+ [
+ "add",
+ "subtract",
+ "reverse-subtract",
+ "min",
+ "max",
+ ],
+);
+
+// DICTIONARY: GPUBlendComponent
+const dictMembersGPUBlendComponent = [
+ {
+ key: "srcFactor",
+ converter: webidl.converters["GPUBlendFactor"],
+ defaultValue: "one",
+ },
+ {
+ key: "dstFactor",
+ converter: webidl.converters["GPUBlendFactor"],
+ defaultValue: "zero",
+ },
+ {
+ key: "operation",
+ converter: webidl.converters["GPUBlendOperation"],
+ defaultValue: "add",
+ },
+];
+webidl.converters["GPUBlendComponent"] = webidl.createDictionaryConverter(
+ "GPUBlendComponent",
+ dictMembersGPUBlendComponent,
+);
+
+// DICTIONARY: GPUBlendState
+const dictMembersGPUBlendState = [
+ {
+ key: "color",
+ converter: webidl.converters["GPUBlendComponent"],
+ required: true,
+ },
+ {
+ key: "alpha",
+ converter: webidl.converters["GPUBlendComponent"],
+ required: true,
+ },
+];
+webidl.converters["GPUBlendState"] = webidl.createDictionaryConverter(
+ "GPUBlendState",
+ dictMembersGPUBlendState,
+);
+
+// TYPEDEF: GPUColorWriteFlags
+webidl.converters["GPUColorWriteFlags"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// DICTIONARY: GPUColorTargetState
+const dictMembersGPUColorTargetState = [
+ {
+ key: "format",
+ converter: webidl.converters["GPUTextureFormat"],
+ required: true,
+ },
+ { key: "blend", converter: webidl.converters["GPUBlendState"] },
+ {
+ key: "writeMask",
+ converter: webidl.converters["GPUColorWriteFlags"],
+ defaultValue: 0xF,
+ },
+];
+webidl.converters["GPUColorTargetState"] = webidl.createDictionaryConverter(
+ "GPUColorTargetState",
+ dictMembersGPUColorTargetState,
+);
+
+// DICTIONARY: GPUFragmentState
+const dictMembersGPUFragmentState = [
+ {
+ key: "targets",
+ converter: webidl.createSequenceConverter(
+ webidl.createNullableConverter(
+ webidl.converters["GPUColorTargetState"],
+ ),
+ ),
+ required: true,
+ },
+];
+webidl.converters["GPUFragmentState"] = webidl.createDictionaryConverter(
+ "GPUFragmentState",
+ dictMembersGPUProgrammableStage,
+ dictMembersGPUFragmentState,
+);
+
+// DICTIONARY: GPURenderPipelineDescriptor
+const dictMembersGPURenderPipelineDescriptor = [
+ {
+ key: "vertex",
+ converter: webidl.converters["GPUVertexState"],
+ required: true,
+ },
+ {
+ key: "primitive",
+ converter: webidl.converters["GPUPrimitiveState"],
+ get defaultValue() {
+ return {};
+ },
+ },
+ {
+ key: "depthStencil",
+ converter: webidl.converters["GPUDepthStencilState"],
+ },
+ {
+ key: "multisample",
+ converter: webidl.converters["GPUMultisampleState"],
+ get defaultValue() {
+ return {};
+ },
+ },
+ { key: "fragment", converter: webidl.converters["GPUFragmentState"] },
+];
+webidl.converters["GPURenderPipelineDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPURenderPipelineDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUPipelineDescriptorBase,
+ dictMembersGPURenderPipelineDescriptor,
+ );
+
+// INTERFACE: GPUColorWrite
+webidl.converters.GPUColorWrite = webidl.createInterfaceConverter(
+ "GPUColorWrite",
+ GPUColorWrite.prototype,
+);
+
+// INTERFACE: GPUCommandBuffer
+webidl.converters.GPUCommandBuffer = webidl.createInterfaceConverter(
+ "GPUCommandBuffer",
+ GPUCommandBuffer.prototype,
+);
+webidl.converters["sequence<GPUCommandBuffer>"] = webidl
+ .createSequenceConverter(webidl.converters["GPUCommandBuffer"]);
+
+// DICTIONARY: GPUCommandBufferDescriptor
+const dictMembersGPUCommandBufferDescriptor = [];
+webidl.converters["GPUCommandBufferDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUCommandBufferDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUCommandBufferDescriptor,
+ );
+
+// INTERFACE: GPUCommandEncoder
+webidl.converters.GPUCommandEncoder = webidl.createInterfaceConverter(
+ "GPUCommandEncoder",
+ GPUCommandEncoder.prototype,
+);
+
+// DICTIONARY: GPUCommandEncoderDescriptor
+const dictMembersGPUCommandEncoderDescriptor = [];
+webidl.converters["GPUCommandEncoderDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUCommandEncoderDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUCommandEncoderDescriptor,
+ );
+
+// DICTIONARY: GPUImageDataLayout
+const dictMembersGPUImageDataLayout = [
+ {
+ key: "offset",
+ converter: webidl.converters["GPUSize64"],
+ defaultValue: 0,
+ },
+ { key: "bytesPerRow", converter: webidl.converters["GPUSize32"] },
+ { key: "rowsPerImage", converter: webidl.converters["GPUSize32"] },
+];
+webidl.converters["GPUImageDataLayout"] = webidl.createDictionaryConverter(
+ "GPUImageDataLayout",
+ dictMembersGPUImageDataLayout,
+);
+
+// DICTIONARY: GPUImageCopyBuffer
+const dictMembersGPUImageCopyBuffer = [
+ {
+ key: "buffer",
+ converter: webidl.converters["GPUBuffer"],
+ required: true,
+ },
+];
+webidl.converters["GPUImageCopyBuffer"] = webidl.createDictionaryConverter(
+ "GPUImageCopyBuffer",
+ dictMembersGPUImageDataLayout,
+ dictMembersGPUImageCopyBuffer,
+);
+
+// DICTIONARY: GPUOrigin3DDict
+const dictMembersGPUOrigin3DDict = [
+ {
+ key: "x",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 0,
+ },
+ {
+ key: "y",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 0,
+ },
+ {
+ key: "z",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 0,
+ },
+];
+webidl.converters["GPUOrigin3DDict"] = webidl.createDictionaryConverter(
+ "GPUOrigin3DDict",
+ dictMembersGPUOrigin3DDict,
+);
+
+// TYPEDEF: GPUOrigin3D
+webidl.converters["GPUOrigin3D"] = (V, opts) => {
+ // Union for (sequence<GPUIntegerCoordinate> or GPUOrigin3DDict)
+ if (V === null || V === undefined) {
+ return webidl.converters["GPUOrigin3DDict"](V, opts);
+ }
+ if (typeof V === "object") {
+ const method = V[SymbolIterator];
+ if (method !== undefined) {
+ return webidl.converters["sequence<GPUIntegerCoordinate>"](V, opts);
+ }
+ return webidl.converters["GPUOrigin3DDict"](V, opts);
+ }
+ throw webidl.makeException(
+ TypeError,
+ "can not be converted to sequence<GPUIntegerCoordinate> or GPUOrigin3DDict.",
+ opts,
+ );
+};
+
+// DICTIONARY: GPUImageCopyTexture
+const dictMembersGPUImageCopyTexture = [
+ {
+ key: "texture",
+ converter: webidl.converters["GPUTexture"],
+ required: true,
+ },
+ {
+ key: "mipLevel",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 0,
+ },
+ {
+ key: "origin",
+ converter: webidl.converters["GPUOrigin3D"],
+ get defaultValue() {
+ return {};
+ },
+ },
+ {
+ key: "aspect",
+ converter: webidl.converters["GPUTextureAspect"],
+ defaultValue: "all",
+ },
+];
+webidl.converters["GPUImageCopyTexture"] = webidl.createDictionaryConverter(
+ "GPUImageCopyTexture",
+ dictMembersGPUImageCopyTexture,
+);
+
+// DICTIONARY: GPUOrigin2DDict
+const dictMembersGPUOrigin2DDict = [
+ {
+ key: "x",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 0,
+ },
+ {
+ key: "y",
+ converter: webidl.converters["GPUIntegerCoordinate"],
+ defaultValue: 0,
+ },
+];
+webidl.converters["GPUOrigin2DDict"] = webidl.createDictionaryConverter(
+ "GPUOrigin2DDict",
+ dictMembersGPUOrigin2DDict,
+);
+
+// TYPEDEF: GPUOrigin2D
+webidl.converters["GPUOrigin2D"] = (V, opts) => {
+ // Union for (sequence<GPUIntegerCoordinate> or GPUOrigin2DDict)
+ if (V === null || V === undefined) {
+ return webidl.converters["GPUOrigin2DDict"](V, opts);
+ }
+ if (typeof V === "object") {
+ const method = V[SymbolIterator];
+ if (method !== undefined) {
+ return webidl.converters["sequence<GPUIntegerCoordinate>"](V, opts);
+ }
+ return webidl.converters["GPUOrigin2DDict"](V, opts);
+ }
+ throw webidl.makeException(
+ TypeError,
+ "can not be converted to sequence<GPUIntegerCoordinate> or GPUOrigin2DDict.",
+ opts,
+ );
+};
+
+// INTERFACE: GPUComputePassEncoder
+webidl.converters.GPUComputePassEncoder = webidl.createInterfaceConverter(
+ "GPUComputePassEncoder",
+ GPUComputePassEncoder.prototype,
+);
+
+// DICTIONARY: GPUComputePassTimestampWrites
+webidl.converters["GPUComputePassTimestampWrites"] = webidl
+ .createDictionaryConverter(
+ "GPUComputePassTimestampWrites",
+ [
+ {
+ key: "querySet",
+ converter: webidl.converters["GPUQuerySet"],
+ required: true,
+ },
+ {
+ key: "beginningOfPassWriteIndex",
+ converter: webidl.converters["GPUSize32"],
+ },
+ {
+ key: "endOfPassWriteIndex",
+ converter: webidl.converters["GPUSize32"],
+ },
+ ],
+ );
+
+// DICTIONARY: GPUComputePassDescriptor
+const dictMembersGPUComputePassDescriptor = [
+ {
+ key: "timestampWrites",
+ converter: webidl.converters["GPUComputePassTimestampWrites"],
+ },
+];
+webidl.converters["GPUComputePassDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPUComputePassDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUComputePassDescriptor,
+ );
+
+// INTERFACE: GPURenderPassEncoder
+webidl.converters.GPURenderPassEncoder = webidl.createInterfaceConverter(
+ "GPURenderPassEncoder",
+ GPURenderPassEncoder.prototype,
+);
+
+// ENUM: GPULoadOp
+webidl.converters["GPULoadOp"] = webidl.createEnumConverter("GPULoadOp", [
+ "load",
+ "clear",
+]);
+
+// DICTIONARY: GPUColorDict
+const dictMembersGPUColorDict = [
+ { key: "r", converter: webidl.converters["double"], required: true },
+ { key: "g", converter: webidl.converters["double"], required: true },
+ { key: "b", converter: webidl.converters["double"], required: true },
+ { key: "a", converter: webidl.converters["double"], required: true },
+];
+webidl.converters["GPUColorDict"] = webidl.createDictionaryConverter(
+ "GPUColorDict",
+ dictMembersGPUColorDict,
+);
+
+// TYPEDEF: GPUColor
+webidl.converters["GPUColor"] = (V, opts) => {
+ // Union for (sequence<double> or GPUColorDict)
+ if (V === null || V === undefined) {
+ return webidl.converters["GPUColorDict"](V, opts);
+ }
+ if (typeof V === "object") {
+ const method = V[SymbolIterator];
+ if (method !== undefined) {
+ return webidl.converters["sequence<double>"](V, opts);
+ }
+ return webidl.converters["GPUColorDict"](V, opts);
+ }
+ throw webidl.makeException(
+ TypeError,
+ "can not be converted to sequence<double> or GPUColorDict.",
+ opts,
+ );
+};
+
+// ENUM: GPUStoreOp
+webidl.converters["GPUStoreOp"] = webidl.createEnumConverter("GPUStoreOp", [
+ "store",
+ "discard",
+]);
+
+// DICTIONARY: GPURenderPassColorAttachment
+const dictMembersGPURenderPassColorAttachment = [
+ {
+ key: "view",
+ converter: webidl.converters["GPUTextureView"],
+ required: true,
+ },
+ { key: "resolveTarget", converter: webidl.converters["GPUTextureView"] },
+ {
+ key: "clearValue",
+ converter: webidl.converters["GPUColor"],
+ },
+ {
+ key: "loadOp",
+ converter: webidl.converters["GPULoadOp"],
+ required: true,
+ },
+ {
+ key: "storeOp",
+ converter: webidl.converters["GPUStoreOp"],
+ required: true,
+ },
+];
+webidl.converters["GPURenderPassColorAttachment"] = webidl
+ .createDictionaryConverter(
+ "GPURenderPassColorAttachment",
+ dictMembersGPURenderPassColorAttachment,
+ );
+
+// DICTIONARY: GPURenderPassDepthStencilAttachment
+const dictMembersGPURenderPassDepthStencilAttachment = [
+ {
+ key: "view",
+ converter: webidl.converters["GPUTextureView"],
+ required: true,
+ },
+ {
+ key: "depthClearValue",
+ converter: webidl.converters["float"],
+ },
+ {
+ key: "depthLoadOp",
+ converter: webidl.converters["GPULoadOp"],
+ },
+ {
+ key: "depthStoreOp",
+ converter: webidl.converters["GPUStoreOp"],
+ },
+ {
+ key: "depthReadOnly",
+ converter: webidl.converters["boolean"],
+ defaultValue: false,
+ },
+ {
+ key: "stencilClearValue",
+ converter: webidl.converters["GPUStencilValue"],
+ defaultValue: 0,
+ },
+ {
+ key: "stencilLoadOp",
+ converter: webidl.converters["GPULoadOp"],
+ },
+ {
+ key: "stencilStoreOp",
+ converter: webidl.converters["GPUStoreOp"],
+ },
+ {
+ key: "stencilReadOnly",
+ converter: webidl.converters["boolean"],
+ defaultValue: false,
+ },
+];
+webidl.converters["GPURenderPassDepthStencilAttachment"] = webidl
+ .createDictionaryConverter(
+ "GPURenderPassDepthStencilAttachment",
+ dictMembersGPURenderPassDepthStencilAttachment,
+ );
+
+// INTERFACE: GPUQuerySet
+webidl.converters.GPUQuerySet = webidl.createInterfaceConverter(
+ "GPUQuerySet",
+ GPUQuerySet.prototype,
+);
+
+// DICTIONARY: GPURenderPassTimestampWrites
+webidl.converters["GPURenderPassTimestampWrites"] = webidl
+ .createDictionaryConverter(
+ "GPURenderPassTimestampWrites",
+ [
+ {
+ key: "querySet",
+ converter: webidl.converters["GPUQuerySet"],
+ required: true,
+ },
+ {
+ key: "beginningOfPassWriteIndex",
+ converter: webidl.converters["GPUSize32"],
+ },
+ {
+ key: "endOfPassWriteIndex",
+ converter: webidl.converters["GPUSize32"],
+ },
+ ],
+ );
+
+// DICTIONARY: GPURenderPassDescriptor
+const dictMembersGPURenderPassDescriptor = [
+ {
+ key: "colorAttachments",
+ converter: webidl.createSequenceConverter(
+ webidl.createNullableConverter(
+ webidl.converters["GPURenderPassColorAttachment"],
+ ),
+ ),
+ required: true,
+ },
+ {
+ key: "depthStencilAttachment",
+ converter: webidl.converters["GPURenderPassDepthStencilAttachment"],
+ },
+ {
+ key: "occlusionQuerySet",
+ converter: webidl.converters["GPUQuerySet"],
+ },
+ {
+ key: "timestampWrites",
+ converter: webidl.converters["GPURenderPassTimestampWrites"],
+ },
+];
+webidl.converters["GPURenderPassDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPURenderPassDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPURenderPassDescriptor,
+ );
+
+// INTERFACE: GPURenderBundle
+webidl.converters.GPURenderBundle = webidl.createInterfaceConverter(
+ "GPURenderBundle",
+ GPURenderBundle.prototype,
+);
+webidl.converters["sequence<GPURenderBundle>"] = webidl
+ .createSequenceConverter(webidl.converters["GPURenderBundle"]);
+
+// DICTIONARY: GPURenderBundleDescriptor
+const dictMembersGPURenderBundleDescriptor = [];
+webidl.converters["GPURenderBundleDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPURenderBundleDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPURenderBundleDescriptor,
+ );
+
+// INTERFACE: GPURenderBundleEncoder
+webidl.converters.GPURenderBundleEncoder = webidl.createInterfaceConverter(
+ "GPURenderBundleEncoder",
+ GPURenderBundleEncoder.prototype,
+);
+
+// DICTIONARY: GPURenderPassLayout
+const dictMembersGPURenderPassLayout = [
+ {
+ key: "colorFormats",
+ converter: webidl.createSequenceConverter(
+ webidl.createNullableConverter(webidl.converters["GPUTextureFormat"]),
+ ),
+ required: true,
+ },
+ {
+ key: "depthStencilFormat",
+ converter: webidl.converters["GPUTextureFormat"],
+ },
+ {
+ key: "sampleCount",
+ converter: webidl.converters["GPUSize32"],
+ defaultValue: 1,
+ },
+];
+webidl.converters["GPURenderPassLayout"] = webidl
+ .createDictionaryConverter(
+ "GPURenderPassLayout",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPURenderPassLayout,
+ );
+
+// DICTIONARY: GPURenderBundleEncoderDescriptor
+const dictMembersGPURenderBundleEncoderDescriptor = [
+ {
+ key: "depthReadOnly",
+ converter: webidl.converters.boolean,
+ defaultValue: false,
+ },
+ {
+ key: "stencilReadOnly",
+ converter: webidl.converters.boolean,
+ defaultValue: false,
+ },
+];
+webidl.converters["GPURenderBundleEncoderDescriptor"] = webidl
+ .createDictionaryConverter(
+ "GPURenderBundleEncoderDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPURenderPassLayout,
+ dictMembersGPURenderBundleEncoderDescriptor,
+ );
+
+// INTERFACE: GPUQueue
+webidl.converters.GPUQueue = webidl.createInterfaceConverter(
+ "GPUQueue",
+ GPUQueue.prototype,
+);
+
+// ENUM: GPUQueryType
+webidl.converters["GPUQueryType"] = webidl.createEnumConverter(
+ "GPUQueryType",
+ [
+ "occlusion",
+ "timestamp",
+ ],
+);
+
+// DICTIONARY: GPUQuerySetDescriptor
+const dictMembersGPUQuerySetDescriptor = [
+ {
+ key: "type",
+ converter: webidl.converters["GPUQueryType"],
+ required: true,
+ },
+ { key: "count", converter: webidl.converters["GPUSize32"], required: true },
+ {
+ key: "pipelineStatistics",
+ converter: webidl.createSequenceConverter(
+ webidl.converters["GPUPipelineStatisticName"],
+ ),
+ get defaultValue() {
+ return [];
+ },
+ },
+];
+webidl.converters["GPUQuerySetDescriptor"] = webidl.createDictionaryConverter(
+ "GPUQuerySetDescriptor",
+ dictMembersGPUObjectDescriptorBase,
+ dictMembersGPUQuerySetDescriptor,
+);
+
+// ENUM: GPUDeviceLostReason
+webidl.converters["GPUDeviceLostReason"] = webidl.createEnumConverter(
+ "GPUDeviceLostReason",
+ [
+ "destroyed",
+ ],
+);
+
+// // INTERFACE: GPUDeviceLostInfo
+// webidl.converters.GPUDeviceLostInfo = webidl.createInterfaceConverter(
+// "GPUDeviceLostInfo",
+// GPUDeviceLostInfo.prototype,
+// );
+
+// ENUM: GPUErrorFilter
+webidl.converters["GPUErrorFilter"] = webidl.createEnumConverter(
+ "GPUErrorFilter",
+ [
+ "out-of-memory",
+ "validation",
+ ],
+);
+
+// INTERFACE: GPUOutOfMemoryError
+webidl.converters.GPUOutOfMemoryError = webidl.createInterfaceConverter(
+ "GPUOutOfMemoryError",
+ GPUOutOfMemoryError.prototype,
+);
+
+// INTERFACE: GPUValidationError
+webidl.converters.GPUValidationError = webidl.createInterfaceConverter(
+ "GPUValidationError",
+ GPUValidationError.prototype,
+);
+
+// TYPEDEF: GPUError
+webidl.converters["GPUError"] = webidl.converters.any /** put union here! **/;
+
+// // INTERFACE: GPUUncapturedErrorEvent
+// webidl.converters.GPUUncapturedErrorEvent = webidl.createInterfaceConverter(
+// "GPUUncapturedErrorEvent",
+// GPUUncapturedErrorEvent.prototype,
+// );
+
+// DICTIONARY: GPUUncapturedErrorEventInit
+const dictMembersGPUUncapturedErrorEventInit = [
+ { key: "error", converter: webidl.converters["GPUError"], required: true },
+];
+webidl.converters["GPUUncapturedErrorEventInit"] = webidl
+ .createDictionaryConverter(
+ "GPUUncapturedErrorEventInit",
+ // dictMembersEventInit,
+ dictMembersGPUUncapturedErrorEventInit,
+ );
+
+// TYPEDEF: GPUBufferDynamicOffset
+webidl.converters["GPUBufferDynamicOffset"] = (V, opts) =>
+ webidl.converters["unsigned long"](V, { ...opts, enforceRange: true });
+
+// TYPEDEF: GPUSignedOffset32
+webidl.converters["GPUSignedOffset32"] = (V, opts) =>
+ webidl.converters["long"](V, { ...opts, enforceRange: true });
+
+// TYPEDEF: GPUFlagsConstant
+webidl.converters["GPUFlagsConstant"] = webidl.converters["unsigned long"];
+
+const gpu = webidl.createBranded(GPU);
+export {
+ _device,
+ assertDevice,
+ createGPUTexture,
+ GPU,
+ gpu,
+ GPUAdapter,
+ GPUAdapterInfo,
+ GPUBindGroup,
+ GPUBindGroupLayout,
+ GPUBuffer,
+ GPUBufferUsage,
+ GPUColorWrite,
+ GPUCommandBuffer,
+ GPUCommandEncoder,
+ GPUComputePassEncoder,
+ GPUComputePipeline,
+ GPUDevice,
+ GPUDeviceLostInfo,
+ GPUError,
+ GPUMapMode,
+ GPUOutOfMemoryError,
+ GPUPipelineLayout,
+ GPUQuerySet,
+ GPUQueue,
+ GPURenderBundle,
+ GPURenderBundleEncoder,
+ GPURenderPassEncoder,
+ GPURenderPipeline,
+ GPUSampler,
+ GPUShaderModule,
+ GPUShaderStage,
+ GPUSupportedFeatures,
+ GPUSupportedLimits,
+ GPUTexture,
+ GPUTextureUsage,
+ GPUTextureView,
+ GPUValidationError,
+};
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 01:27:14 +0000