/**

* @license

* Copyright 2019 The Emscripten Authors

* SPDX-License-Identifier: MIT

*/

/*

* WebGPU support.

*

* This file implements the common C header <webgpu/webgpu.h> on top of the

* browser's native JS WebGPU implementation. This allows applications targeting

* wgpu-native (https://github.com/gfx-rs/wgpu) or

* Dawn (https://dawn.googlesource.com/dawn/) to also target the Web with the

* same graphics API and fairly minimal changes - similar to OpenGL ES 2.0/3.0

* on WebGL 1.0/2.0.

*

* To test this, run the following tests:

* - test/runner.py other.test_webgpu_compiletest

* - EMTEST_BROWSERS="/path/to/chrome --user-data-dir=chromeuserdata --enable-unsafe-webgpu" \

* test/runner.py browser.test_webgpu_basic_rendering

* (requires WebGPU to be available - otherwise the test will skip itself and pass)

*/

{{{

// Helper functions for code generation

global.gpu = {

makeInitManager: function(type) {

var mgr = `WebGPU.mgr${type}`;

return `${mgr} = ${mgr} || new Manager();`;

},

makeReferenceRelease: function(type) {

return `

wgpu${type}Reference: function(id) { WebGPU.mgr${type}.reference(id) },

wgpu${type}Release: function(id) { WebGPU.mgr${type}.release(id) },`;

},

convertI32PairToI53WithSentinelAsUndefined: function(lowName, highName) {

return `((${highName} === -1 && ${lowName} === -1) ? undefined : \

convertI32PairToI53(${lowName}, ${highName}))`;

},

makeGetBool: function(struct, offset) {

// In an actual build, bool seems to be i8. But on the off-chance it's i32, on little-endian

// this will still work as long as the value of 'true' isn't zero in the lowest byte.

return `(${makeGetValue(struct, offset, 'i8')} !== 0)`;

},

makeGetU32: function(struct, offset) {

return makeGetValue(struct, offset, 'u32');

},

makeGetU64: function(struct, offset) {

var l = makeGetValue(struct, offset, 'u32');

var h = makeGetValue(`(${struct} + 4)`, offset, 'u32')

return `${h} * 0x100000000 + ${l}`

},

makeCheck: function(str) {

if (!ASSERTIONS) return '';

return `assert(${str});`;

},

makeCheckDefined: function(name) {

return this.makeCheck(`typeof ${name} != "undefined"`);

},

makeCheckDescriptor: function(descriptor) {

// Assert descriptor is non-null, then that its nextInChain is null.

// For descriptors that aren't the first in the chain (e.g

// ShaderModuleSPIRVDescriptor), there is no .nextInChain pointer, but

// instead a ChainedStruct object: .chain. So we need to check if

// .chain.nextInChain is null. As long as nextInChain and chain are always

// the first member in the struct, descriptor.nextInChain and

// descriptor.chain.nextInChain should have the same offset (0) to the

// descriptor pointer and we can check it to be null.

var OffsetOfNextInChainMember = 0;

return this.makeCheck(descriptor) + this.makeCheck(makeGetValue(descriptor, OffsetOfNextInChainMember, '*') + ' === 0');

},

// Must be in sync with webgpu.h.

COPY_STRIDE_UNDEFINED: 0xFFFFFFFF,

LIMIT_U32_UNDEFINED: 0xFFFFFFFF,

WHOLE_MAP_SIZE: 0xFFFFFFFF, // use 32-bit uint max

MIP_LEVEL_COUNT_UNDEFINED: 0xFFFFFFFF,

ARRAY_LAYER_COUNT_UNDEFINED: 0xFFFFFFFF,

AdapterType: {

Unknown: 3,

},

BackendType: {

WebGPU: 1,

},

BufferMapAsyncStatus: {

Success: 0,

Error: 1,

},

ErrorType: {

NoError: 0,

Validation: 1,

OutOfMemory: 2,

Unknown: 3,

},

PresentMode: {

Fifo: 2,

},

LoadOp: {

Undefined: 0,

Clear: 1,

Load: 2,

},

StoreOp: {

Undefined: 0,

Store: 1,

Discard: 2,

},

MapMode: {

None: 0,

Read: 1,

Write: 2

},

RequestAdapterStatus: {

Success: 0,

Unavailable: 1,

Error: 2,

},

RequestDeviceStatus: {

Success: 0,

Error: 1,

},

SType: {

SurfaceDescriptorFromCanvasHTMLSelector: 4,

ShaderModuleSPIRVDescriptor: 5,

ShaderModuleWGSLDescriptor: 6,

PrimitiveDepthClipControl: 7,

RenderPassDescriptorMaxDrawCount: 15,

},

QueueWorkDoneStatus: {

Success: 0,

Error: 1,

},

TextureFormat: {

Undefined: 0,

},

VertexStepMode: {

Vertex: 0,

Instance: 1,

VertexBufferNotUsed: 2,

},

};

null;

}}}

var LibraryWebGPU = {

$WebGPU__postset: 'WebGPU.initManagers();',

$WebGPU__deps: ['$withStackSave', '$stringToUTF8OnStack', '$convertI32PairToI53'],

$WebGPU: {

errorCallback: function(callback, type, message, userdata) {

withStackSave(() => {

var messagePtr = stringToUTF8OnStack(message);

{{{ makeDynCall('viii', 'callback') }}}(type, messagePtr, userdata);

});

},

initManagers: function() {

if (WebGPU.mgrDevice) return;

/** @constructor */

function Manager() {

this.objects = {};

this.nextId = 1;

this.create = function(object, wrapper = {}) {

var id = this.nextId++;

{{{ gpu.makeCheck("typeof this.objects[id] == 'undefined'") }}}

wrapper.refcount = 1;

wrapper.object = object;

this.objects[id] = wrapper;

return id;

};

this.get = function(id) {

if (!id) return undefined;

var o = this.objects[id];

{{{ gpu.makeCheckDefined('o') }}}

return o.object;

};

this.reference = function(id) {

var o = this.objects[id];

{{{ gpu.makeCheckDefined('o') }}}

o.refcount++;

};

this.release = function(id) {

var o = this.objects[id];

{{{ gpu.makeCheckDefined('o') }}}

{{{ gpu.makeCheck('o.refcount > 0') }}}

o.refcount--;

if (o.refcount <= 0) {

delete this.objects[id];

}

};

}

{{{ gpu.makeInitManager('Surface') }}}

{{{ gpu.makeInitManager('SwapChain') }}}

{{{ gpu.makeInitManager('Adapter') }}}

// TODO: Release() the device's default queue when the device is freed.

{{{ gpu.makeInitManager('Device') }}}

{{{ gpu.makeInitManager('Queue') }}}

{{{ gpu.makeInitManager('CommandBuffer') }}}

{{{ gpu.makeInitManager('CommandEncoder') }}}

{{{ gpu.makeInitManager('RenderPassEncoder') }}}

{{{ gpu.makeInitManager('ComputePassEncoder') }}}

{{{ gpu.makeInitManager('BindGroup') }}}

{{{ gpu.makeInitManager('Buffer') }}}

{{{ gpu.makeInitManager('Sampler') }}}

{{{ gpu.makeInitManager('Texture') }}}

{{{ gpu.makeInitManager('TextureView') }}}

{{{ gpu.makeInitManager('QuerySet') }}}

{{{ gpu.makeInitManager('BindGroupLayout') }}}

{{{ gpu.makeInitManager('PipelineLayout') }}}

{{{ gpu.makeInitManager('RenderPipeline') }}}

{{{ gpu.makeInitManager('ComputePipeline') }}}

{{{ gpu.makeInitManager('ShaderModule') }}}

{{{ gpu.makeInitManager('RenderBundleEncoder') }}}

{{{ gpu.makeInitManager('RenderBundle') }}}

},

makeColor: function(ptr) {

return {

"r": {{{ makeGetValue('ptr', 0, 'double') }}},

"g": {{{ makeGetValue('ptr', 8, 'double') }}},

"b": {{{ makeGetValue('ptr', 16, 'double') }}},

"a": {{{ makeGetValue('ptr', 24, 'double') }}},

};

},

makeExtent3D: function(ptr) {

return {

"width": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUExtent3D.width) }}},

"height": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUExtent3D.height) }}},

"depthOrArrayLayers": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUExtent3D.depthOrArrayLayers) }}},

};

},

makeOrigin3D: function(ptr) {

return {

"x": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUOrigin3D.x) }}},

"y": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUOrigin3D.y) }}},

"z": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUOrigin3D.z) }}},

};

},

makeImageCopyTexture: function(ptr) {

{{{ gpu.makeCheckDescriptor('ptr') }}}

return {

"texture": WebGPU.mgrTexture.get(

{{{ makeGetValue('ptr', C_STRUCTS.WGPUImageCopyTexture.texture, '*') }}}),

"mipLevel": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUImageCopyTexture.mipLevel) }}},

"origin": WebGPU.makeOrigin3D(ptr + {{{ C_STRUCTS.WGPUImageCopyTexture.origin }}}),

"aspect": WebGPU.TextureAspect[{{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUImageCopyTexture.aspect) }}}],

};

},

makeTextureDataLayout: function(ptr) {

{{{ gpu.makeCheckDescriptor('ptr') }}}

var bytesPerRow = {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUTextureDataLayout.bytesPerRow) }}};

var rowsPerImage = {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUTextureDataLayout.rowsPerImage) }}};

return {

"offset": {{{ gpu.makeGetU64('ptr', C_STRUCTS.WGPUTextureDataLayout.offset) }}},

"bytesPerRow": bytesPerRow === {{{ gpu.COPY_STRIDE_UNDEFINED }}} ? undefined : bytesPerRow,

"rowsPerImage": rowsPerImage === {{{ gpu.COPY_STRIDE_UNDEFINED }}} ? undefined : rowsPerImage,

};

},

makeImageCopyBuffer: function(ptr) {

{{{ gpu.makeCheckDescriptor('ptr') }}}

var layoutPtr = ptr + {{{ C_STRUCTS.WGPUImageCopyBuffer.layout }}};

var bufferCopyView = WebGPU.makeTextureDataLayout(layoutPtr);

bufferCopyView["buffer"] = WebGPU.mgrBuffer.get(

{{{ makeGetValue('ptr', C_STRUCTS.WGPUImageCopyBuffer.buffer, '*') }}});

return bufferCopyView;

},

makePipelineConstants: function(constantCount, constantsPtr) {

if (!constantCount) return;

var constants = {};

for (var i = 0; i < constantCount; ++i) {

var entryPtr = constantsPtr + {{{ C_STRUCTS.WGPUConstantEntry.__size__ }}} * i;

var key = UTF8ToString({{{ makeGetValue('entryPtr', C_STRUCTS.WGPUConstantEntry.key, '*') }}});

constants[key] = {{{ makeGetValue('entryPtr', C_STRUCTS.WGPUConstantEntry.value, 'double') }}};

}

return constants;

},

makePipelineLayout: function(layoutPtr) {

if (!layoutPtr) return 'auto';

return WebGPU.mgrPipelineLayout.get(layoutPtr);

},

makeProgrammableStageDescriptor: function(ptr) {

if (!ptr) return undefined;

{{{ gpu.makeCheckDescriptor('ptr') }}}

return {

"module": WebGPU.mgrShaderModule.get(

{{{ makeGetValue('ptr', C_STRUCTS.WGPUProgrammableStageDescriptor.module, '*') }}}),

"entryPoint": UTF8ToString(

{{{ makeGetValue('ptr', C_STRUCTS.WGPUProgrammableStageDescriptor.entryPoint, '*') }}}),

"constants": WebGPU.makePipelineConstants(

{{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUProgrammableStageDescriptor.constantCount) }}},

{{{ makeGetValue('ptr', C_STRUCTS.WGPUProgrammableStageDescriptor.constants, '*') }}}),

};

},

// Map from enum string back to enum number, for callbacks.

DeviceLostReason: {

'undefined': 0,

'destroyed': 1,

},

PreferredFormat: {

'rgba8unorm': 0x12,

'bgra8unorm': 0x17,

},

// This section is auto-generated. See system/include/webgpu/README.md for details.

AddressMode: [

'repeat',

'mirror-repeat',

'clamp-to-edge',

],

BlendFactor: [

'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',

],

BlendOperation: [

'add',

'subtract',

'reverse-subtract',

'min',

'max',

],

BufferBindingType: [

undefined,

'uniform',

'storage',

'read-only-storage',

],

CompareFunction: [

undefined,

'never',

'less',

'less-equal',

'greater',

'greater-equal',

'equal',

'not-equal',

'always',

],

CompilationInfoRequestStatus: [

'success',

'error',

'device-lost',

'unknown',

],

ComputePassTimestampLocation: [

'beginning',

'end',

],

CullMode: [

'none',

'front',

'back',

],

ErrorFilter: [

'validation',

'out-of-memory',

],

FeatureName: [

undefined,

'depth-clip-control',

'depth32float-stencil8',

'timestamp-query',

'pipeline-statistics-query',

'texture-compression-bc',

'texture-compression-etc2',

'texture-compression-astc',

'indirect-first-instance',

],

FilterMode: [

'nearest',

'linear',

],

FrontFace: [

'ccw',

'cw',

],

IndexFormat: [

undefined,

'uint16',

'uint32',

],

LoadOp: [

undefined,

'clear',

'load',

],

PipelineStatisticName: [

'vertex-shader-invocations',

'clipper-invocations',

'clipper-primitives-out',

'fragment-shader-invocations',

'compute-shader-invocations',

],

PowerPreference: [

undefined,

'low-power',

'high-performance',

],

PrimitiveTopology: [

'point-list',

'line-list',

'line-strip',

'triangle-list',

'triangle-strip',

],

QueryType: [

'occlusion',

'pipeline-statistics',

'timestamp',

],

RenderPassTimestampLocation: [

'beginning',

'end',

],

SamplerBindingType: [

undefined,

'filtering',

'non-filtering',

'comparison',

],

StencilOperation: [

'keep',

'zero',

'replace',

'invert',

'increment-clamp',

'decrement-clamp',

'increment-wrap',

'decrement-wrap',

],

StorageTextureAccess: [

undefined,

'write-only',

],

StoreOp: [

undefined,

'store',

'discard',

],

TextureAspect: [

'all',

'stencil-only',

'depth-only',

],

TextureComponentType: [

'float',

'sint',

'uint',

'depth-comparison',

],

TextureDimension: [

'1d',

'2d',

'3d',

],

TextureFormat: [

undefined,

'r8unorm',

'r8snorm',

'r8uint',

'r8sint',

'r16uint',

'r16sint',

'r16float',

'rg8unorm',

'rg8snorm',

'rg8uint',

'rg8sint',

'r32float',

'r32uint',

'r32sint',

'rg16uint',

'rg16sint',

'rg16float',

'rgba8unorm',

'rgba8unorm-srgb',

'rgba8snorm',

'rgba8uint',

'rgba8sint',

'bgra8unorm',

'bgra8unorm-srgb',

'rgb10a2unorm',

'rg11b10ufloat',

'rgb9e5ufloat',

'rg32float',

'rg32uint',

'rg32sint',

'rgba16uint',

'rgba16sint',

'rgba16float',

'rgba32float',

'rgba32uint',

'rgba32sint',

'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',

],

TextureSampleType: [

undefined,

'float',

'unfilterable-float',

'depth',

'sint',

'uint',

],

TextureViewDimension: [

undefined,

'1d',

'2d',

'2d-array',

'cube',

'cube-array',

'3d',

],

VertexFormat: [

undefined,

'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',

],

VertexStepMode: [

'vertex',

'instance',

undefined,

],

},

// *Reference/*Release

{{{ gpu.makeReferenceRelease('Surface') }}}

{{{ gpu.makeReferenceRelease('SwapChain') }}}

{{{ gpu.makeReferenceRelease('Adapter') }}}

{{{ gpu.makeReferenceRelease('Device') }}}

{{{ gpu.makeReferenceRelease('Queue') }}}

{{{ gpu.makeReferenceRelease('CommandBuffer') }}}

{{{ gpu.makeReferenceRelease('CommandEncoder') }}}

{{{ gpu.makeReferenceRelease('RenderPassEncoder') }}}

{{{ gpu.makeReferenceRelease('ComputePassEncoder') }}}

{{{ gpu.makeReferenceRelease('BindGroup') }}}

{{{ gpu.makeReferenceRelease('Buffer') }}}

{{{ gpu.makeReferenceRelease('Sampler') }}}

{{{ gpu.makeReferenceRelease('Texture') }}}

{{{ gpu.makeReferenceRelease('TextureView') }}}

{{{ gpu.makeReferenceRelease('QuerySet') }}}

{{{ gpu.makeReferenceRelease('BindGroupLayout') }}}

{{{ gpu.makeReferenceRelease('PipelineLayout') }}}

{{{ gpu.makeReferenceRelease('RenderPipeline') }}}

{{{ gpu.makeReferenceRelease('ComputePipeline') }}}

{{{ gpu.makeReferenceRelease('ShaderModule') }}}

{{{ gpu.makeReferenceRelease('RenderBundleEncoder') }}}

{{{ gpu.makeReferenceRelease('RenderBundle') }}}

// *Destroy

wgpuBufferDestroy: function(bufferId) {

var bufferWrapper = WebGPU.mgrBuffer.objects[bufferId];

{{{ gpu.makeCheckDefined('bufferWrapper') }}}

if (bufferWrapper.onUnmap) {

for (var i = 0; i < bufferWrapper.onUnmap.length; ++i) {

bufferWrapper.onUnmap[i]();

}

bufferWrapper.onUnmap = undefined;

}

WebGPU.mgrBuffer.get(bufferId)["destroy"]();

},

wgpuTextureDestroy: function(textureId) { WebGPU.mgrTexture.get(textureId)["destroy"](); },

wgpuQuerySetDestroy: function(querySetId) { WebGPU.mgrQuerySet.get(querySetId)["destroy"](); },

// wgpuDevice

wgpuDeviceEnumerateFeatures: function(deviceId, featuresOutPtr) {

var device = WebGPU.mgrDevice.get(deviceId);

if (featuresOutPtr !== 0) {

var offset = 0;

device.features.forEach(feature => {

var featureEnumValue = WebGPU.FeatureNameString2Enum[feature];

{{{ makeSetValue('featuresOutPtr', 'offset', 'featureEnumValue', 'i32') }}};

offset += 4;

});

}

return device.features.size;

},

wgpuDeviceDestroy: function(deviceId) { WebGPU.mgrDevice.get(deviceId)["destroy"](); },

wgpuDeviceGetLimits: function(deviceId, limitsOutPtr) {

var device = WebGPU.mgrDevice.objects[deviceId].object;

var limitsPtr = {{{ C_STRUCTS.WGPUSupportedLimits.limits }}};

function setLimitValueU32(name, limitOffset) {

var limitValue = device.limits[name];

{{{ makeSetValue('limitsOutPtr', 'limitsPtr + limitOffset', 'limitValue', 'i32') }}};

}

function setLimitValueU64(name, limitOffset) {

var limitValue = device.limits[name];

{{{ makeSetValue('limitsOutPtr', 'limitsPtr + limitOffset', 'limitValue', 'i64') }}};

}

setLimitValueU32('maxTextureDimension1D', {{{ C_STRUCTS.WGPULimits.maxTextureDimension1D }}});

setLimitValueU32('maxTextureDimension2D', {{{ C_STRUCTS.WGPULimits.maxTextureDimension2D }}});

setLimitValueU32('maxTextureDimension3D', {{{ C_STRUCTS.WGPULimits.maxTextureDimension3D }}});

setLimitValueU32('maxTextureArrayLayers', {{{ C_STRUCTS.WGPULimits.maxTextureArrayLayers }}});

setLimitValueU32('maxBindGroups', {{{ C_STRUCTS.WGPULimits.maxBindGroups }}});

setLimitValueU32('maxDynamicUniformBuffersPerPipelineLayout', {{{ C_STRUCTS.WGPULimits.maxDynamicUniformBuffersPerPipelineLayout }}});

setLimitValueU32('maxDynamicStorageBuffersPerPipelineLayout', {{{ C_STRUCTS.WGPULimits.maxDynamicStorageBuffersPerPipelineLayout }}});

setLimitValueU32('maxSampledTexturesPerShaderStage', {{{ C_STRUCTS.WGPULimits.maxSampledTexturesPerShaderStage }}});

setLimitValueU32('maxSamplersPerShaderStage', {{{ C_STRUCTS.WGPULimits.maxSamplersPerShaderStage }}});

setLimitValueU32('maxStorageBuffersPerShaderStage', {{{ C_STRUCTS.WGPULimits.maxStorageBuffersPerShaderStage }}});

setLimitValueU32('maxStorageTexturesPerShaderStage', {{{ C_STRUCTS.WGPULimits.maxStorageTexturesPerShaderStage }}});

setLimitValueU32('maxUniformBuffersPerShaderStage', {{{ C_STRUCTS.WGPULimits.maxUniformBuffersPerShaderStage }}});

setLimitValueU32('minUniformBufferOffsetAlignment', {{{ C_STRUCTS.WGPULimits.minUniformBufferOffsetAlignment }}});

setLimitValueU32('minStorageBufferOffsetAlignment', {{{ C_STRUCTS.WGPULimits.minStorageBufferOffsetAlignment }}});

setLimitValueU64('maxUniformBufferBindingSize', {{{ C_STRUCTS.WGPULimits.maxUniformBufferBindingSize }}});

setLimitValueU64('maxStorageBufferBindingSize', {{{ C_STRUCTS.WGPULimits.maxStorageBufferBindingSize }}});

setLimitValueU32('maxVertexBuffers', {{{ C_STRUCTS.WGPULimits.maxVertexBuffers }}});

setLimitValueU32('maxVertexAttributes', {{{ C_STRUCTS.WGPULimits.maxVertexAttributes }}});

setLimitValueU32('maxVertexBufferArrayStride', {{{ C_STRUCTS.WGPULimits.maxVertexBufferArrayStride }}});

setLimitValueU32('maxInterStageShaderComponents', {{{ C_STRUCTS.WGPULimits.maxInterStageShaderComponents }}});

setLimitValueU32('maxInterStageShaderVariables', {{{ C_STRUCTS.WGPULimits.maxInterStageShaderVariables }}});

setLimitValueU32('maxColorAttachments', {{{ C_STRUCTS.WGPULimits.maxColorAttachments }}});

setLimitValueU32('maxComputeWorkgroupStorageSize', {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupStorageSize }}});

setLimitValueU32('maxComputeInvocationsPerWorkgroup', {{{ C_STRUCTS.WGPULimits.maxComputeInvocationsPerWorkgroup }}});

setLimitValueU32('maxComputeWorkgroupSizeX', {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupSizeX }}});

setLimitValueU32('maxComputeWorkgroupSizeY', {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupSizeY }}});

setLimitValueU32('maxComputeWorkgroupSizeZ', {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupSizeZ }}});

setLimitValueU32('maxComputeWorkgroupsPerDimension', {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupsPerDimension }}});

},

wgpuDeviceGetQueue: function(deviceId) {

var queueId = WebGPU.mgrDevice.objects[deviceId].queueId;

#if ASSERTIONS

assert(queueId, 'wgpuDeviceGetQueue: queue was missing or null');

#endif

// Returns a new reference to the existing queue.

WebGPU.mgrQueue.reference(queueId);

return queueId;

},

wgpuDeviceHasFeature: function(deviceId, featureEnumValue) {

var device = WebGPU.mgrDevice.get(deviceId);

return device.features.has(WebGPU.FeatureName[featureEnumValue]);

},

wgpuDevicePushErrorScope: function(deviceId, filter) {

var device = WebGPU.mgrDevice.get(deviceId);

device["pushErrorScope"](WebGPU.ErrorFilter[filter]);

},

wgpuDevicePopErrorScope__deps: ['$callUserCallback'],

wgpuDevicePopErrorScope: function(deviceId, callback, userdata) {

var device = WebGPU.mgrDevice.get(deviceId);

{{{ runtimeKeepalivePush() }}}

device["popErrorScope"]().then((gpuError) => {

{{{ runtimeKeepalivePop() }}}

callUserCallback(() => {

if (!gpuError) {

{{{ makeDynCall('viii', 'callback') }}}(

{{{ gpu.ErrorType.NoError }}}, 0, userdata);

} else if (gpuError instanceof GPUOutOfMemoryError) {

{{{ makeDynCall('viii', 'callback') }}}(

{{{ gpu.ErrorType.OutOfMemory }}}, 0, userdata);

} else {

#if ASSERTIONS

assert(gpuError instanceof GPUValidationError);

#endif

WebGPU.errorCallback(callback, {{{ gpu.ErrorType.Validation }}}, gpuError.message, userdata);

}

});

}, (ex) => {

{{{ runtimeKeepalivePop() }}}

callUserCallback(() => {

// TODO: This can mean either the device was lost or the error scope stack was empty. Figure

// out how to synthesize the DeviceLost error type. (Could be by simply tracking the error

// scope depth, but that isn't ideal.)

WebGPU.errorCallback(callback, {{{ gpu.ErrorType.Unknown }}}, ex.message, userdata);

});

});

},

wgpuDeviceSetLabel: function(deviceId, labelPtr) {

var device = WebGPU.mgrDevice.get(deviceId);

device.label = UTF8ToString(labelPtr);

},

wgpuDeviceSetDeviceLostCallback__deps: ['$callUserCallback'],

wgpuDeviceSetDeviceLostCallback: function(deviceId, callback, userdata) {

var deviceWrapper = WebGPU.mgrDevice.objects[deviceId];

{{{ gpu.makeCheckDefined('deviceWrapper') }}}

if (!deviceWrapper.lostCallback) {

// device.lost hasn't been registered yet - register it.

deviceWrapper.object["lost"].then((info) => deviceWrapper.lostCallback(info));

}

deviceWrapper.lostCallback = (info) => {

// This will skip the callback if the runtime is no longer alive.

callUserCallback(() => WebGPU.errorCallback(callback, WebGPU.DeviceLostReason[info.reason],

info.message, userdata));

};

},

wgpuDeviceSetUncapturedErrorCallback__deps: ['$callUserCallback'],

wgpuDeviceSetUncapturedErrorCallback: function(deviceId, callback, userdata) {

var device = WebGPU.mgrDevice.get(deviceId);

device["onuncapturederror"] = function(ev) {

// This will skip the callback if the runtime is no longer alive.

callUserCallback(() => {

// WGPUErrorType type, const char* message, void* userdata

var Validation = 0x00000001;

var OutOfMemory = 0x00000002;

var type;

#if ASSERTIONS

assert(typeof GPUValidationError != 'undefined');

assert(typeof GPUOutOfMemoryError != 'undefined');

#endif

if (ev.error instanceof GPUValidationError) type = Validation;

else if (ev.error instanceof GPUOutOfMemoryError) type = OutOfMemory;

WebGPU.errorCallback(callback, type, ev.error.message, userdata);

});

};

},

// wgpuDeviceCreate*

wgpuDeviceCreateCommandEncoder: function(deviceId, descriptor) {

var desc;

if (descriptor) {

{{{ gpu.makeCheckDescriptor('descriptor') }}}

desc = {

"label": undefined,

};

var labelPtr = {{{ makeGetValue('descriptor', C_STRUCTS.WGPUCommandEncoderDescriptor.label, '*') }}};

if (labelPtr) desc["label"] = UTF8ToString(labelPtr);

}

var device = WebGPU.mgrDevice.get(deviceId);

return WebGPU.mgrCommandEncoder.create(device["createCommandEncoder"](desc));

},

wgpuDeviceCreateBuffer: function(deviceId, descriptor) {

{{{ gpu.makeCheckDescriptor('descriptor') }}}

var mappedAtCreation = {{{ gpu.makeGetBool('descriptor', C_STRUCTS.WGPUBufferDescriptor.mappedAtCreation) }}};

var desc = {

"label": undefined,

"usage": {{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUBufferDescriptor.usage) }}},

"size": {{{ gpu.makeGetU64('descriptor', C_STRUCTS.WGPUBufferDescriptor.size) }}},

"mappedAtCreation": mappedAtCreation,

};

var labelPtr = {{{ makeGetValue('descriptor', C_STRUCTS.WGPUBufferDescriptor.label, '*') }}};

if (labelPtr) desc["label"] = UTF8ToString(labelPtr);

var device = WebGPU.mgrDevice.get(deviceId);

var bufferWrapper = {};

var id = WebGPU.mgrBuffer.create(device["createBuffer"](desc), bufferWrapper);

if (mappedAtCreation) {

bufferWrapper.mapMode = {{{ gpu.MapMode.Write }}};

bufferWrapper.onUnmap = [];

}

return id;

},

wgpuDeviceCreateTexture: function(deviceId, descriptor) {

{{{ gpu.makeCheckDescriptor('descriptor') }}}

var desc = {

"label": undefined,

"size": WebGPU.makeExtent3D(descriptor + {{{ C_STRUCTS.WGPUTextureDescriptor.size }}}),

"mipLevelCount": {{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUTextureDescriptor.mipLevelCount) }}},

"sampleCount": {{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUTextureDescriptor.sampleCount) }}},

"dimension": WebGPU.TextureDimension[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUTextureDescriptor.dimension) }}}],

"format": WebGPU.TextureFormat[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUTextureDescriptor.format) }}}],

"usage": {{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUTextureDescriptor.usage) }}},

};

var labelPtr = {{{ makeGetValue('descriptor', C_STRUCTS.WGPUTextureDescriptor.label, '*') }}};

if (labelPtr) desc["label"] = UTF8ToString(labelPtr);

var viewFormatCount = {{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUTextureDescriptor.viewFormatCount) }}};

if (viewFormatCount) {

var viewFormatsPtr = {{{ makeGetValue('descriptor', C_STRUCTS.WGPUTextureDescriptor.viewFormats, '*') }}};

desc["viewFormats"] = Array.from(HEAP32.subarray(viewFormatsPtr >> 2, (viewFormatsPtr >> 2) + viewFormatCount),

function(format) { return WebGPU.TextureFormat[format]; });

}

var device = WebGPU.mgrDevice.get(deviceId);

return WebGPU.mgrTexture.create(device["createTexture"](desc));

},

wgpuDeviceCreateSampler: function(deviceId, descriptor) {

{{{ gpu.makeCheckDescriptor('descriptor') }}}

var desc = {

"label": undefined,

"addressModeU": WebGPU.AddressMode[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUSamplerDescriptor.addressModeU) }}}],

"addressModeV": WebGPU.AddressMode[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUSamplerDescriptor.addressModeV) }}}],

"addressModeW": WebGPU.AddressMode[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUSamplerDescriptor.addressModeW) }}}],

"magFilter": WebGPU.FilterMode[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUSamplerDescriptor.magFilter) }}}],

"minFilter": WebGPU.FilterMode[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUSamplerDescriptor.minFilter) }}}],

"mipmapFilter": WebGPU.FilterMode[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUSamplerDescriptor.mipmapFilter) }}}],

"lodMinClamp": {{{ makeGetValue('descriptor', C_STRUCTS.WGPUSamplerDescriptor.lodMinClamp, 'float') }}},

"lodMaxClamp": {{{ makeGetValue('descriptor', C_STRUCTS.WGPUSamplerDescriptor.lodMaxClamp, 'float') }}},

"compare": WebGPU.CompareFunction[

{{{ gpu.makeGetU32('descriptor', C_STRUCTS.WGPUSamplerDescriptor.compare) }}}],

};

var labelPtr = {{{ makeGetValue('descriptor', C_STRUCTS.WGPUSamplerDescriptor.label, '*') }}};

if (labelPtr) desc["label"] = UTF8ToString(labelPtr);

var device = WebGPU.mgrDevice.get(deviceId);

return WebGPU.mgrSampler.create(device["createSampler"](desc));

},

wgpuDeviceCreateBindGroupLayout: function(deviceId, descriptor) {

{{{ gpu.makeCheckDescriptor('descriptor') }}}

function makeBufferEntry(entryPtr) {

{{{ gpu.makeCheck('entryPtr') }}}

var typeInt =

{{{ gpu.makeGetU32('entryPtr', C_STRUCTS.WGPUBufferBindingLayout.type) }}};

if (!typeInt) return undefined;

return {

"type": WebGPU.BufferBindingType[typeInt],

"hasDynamicOffset":

{{{ gpu.makeGetBool('entryPtr', C_STRUCTS.WGPUBufferBindingLayout.hasDynamicOffset) }}},

"minBindingSize":

{{{ gpu.makeGetU64('entryPtr', C_STRUCTS.WGPUBufferBindingLayout.minBindingSize) }}},

};

}

function makeSamplerEntry(entryPtr) {

{{{ gpu.makeCheck('entryPtr') }}}

var typeInt =

{{{ gpu.makeGetU32('entryPtr', C_STRUCTS.WGPUSamplerBindingLayout.type) }}};

if (!typeInt) return undefined;

return {

"type": WebGPU.SamplerBindingType[typeInt],

};

}

function makeTextureEntry(entryPtr) {

{{{ gpu.makeCheck('entryPtr') }}}

var sampleTypeInt =

{{{ gpu.makeGetU32('entryPtr', C_STRUCTS.WGPUTextureBindingLayout.sampleType) }}};

if (!sampleTypeInt) return undefined;

return {

"sampleType": WebGPU.TextureSampleType[sampleTypeInt],

"viewDimension": WebGPU.TextureViewDimension[

{{{ gpu.makeGetU32('entryPtr', C_STRUCTS.WGPUTextureBindingLayout.viewDimension) }}}],

"multisampled":

{{{ gpu.makeGetBool('entryPtr', C_STRUCTS.WGPUTextureBindingLayout.multisampled) }}},

};

}

function makeStorageTextureEntry(entryPtr) {

{{{ gpu.makeCheck('entryPtr') }}}

var accessInt =

{{{ gpu.makeGetU32('entryPtr', C_STRUCTS.WGPUStorageTextureBindingLayout.access) }}}

if (!accessInt) return undefined;

return {

"access": WebGPU.StorageTextureAccess[accessInt],

"format": WebGPU.TextureFormat[

{{{ gpu.makeGetU32('entryPtr', C_STRUCTS.WGPUStorageTextureBindingLayout.format) }}}],

"viewDimension": WebGPU.TextureViewDimension[

{{{ gpu.makeGetU32('entryPtr', C_STRUCTS.WGPUStorageTextureBindingLayout.viewDimension) }}}],

};

}

function makeEntry(entryPtr) {

{{{ gpu.makeCheck('entryPtr') }}}