mirror of
https://github.com/odin-lang/Odin.git
synced 2025-12-30 09:54:45 +00:00
2917 lines
93 KiB
JavaScript
2917 lines
93 KiB
JavaScript
(function() {
|
|
|
|
/**
|
|
* Assumptions:
|
|
* - Ability to allocate memory, set the context to allocate with using the global `wgpu.g_context`
|
|
* - Exports a function table (for callbacks), added with `-extra-linker-flags:"--export-table"`
|
|
*/
|
|
class WebGPUInterface {
|
|
|
|
/**
|
|
* @param {WasmMemoryInterface} mem
|
|
*/
|
|
constructor(mem) {
|
|
this.mem = mem;
|
|
|
|
this.enums = {
|
|
FeatureName: [undefined, "depth-clip-control", "depth32float-stencil8", "timestamp-query", "texture-compression-bc", "texture-compression-etc2", "texture-compression-astc", "indirect-first-instance", "shader-f16", "rg11b10ufloat-renderable", "bgra8unorm-storage", "float32-filterable", ],
|
|
StoreOp: [undefined, "store", "discard", ],
|
|
LoadOp: [undefined, "clear", "load", ],
|
|
BufferBindingType: [undefined, "uniform", "storage", "read-only-storage", ],
|
|
SamplerBindingType: [undefined, "filtering", "non-filtering", "comparison", ],
|
|
TextureSampleType: [undefined, "float", "unfilterable-float", "depth", "sint", "uint", ],
|
|
TextureViewDimension: [undefined, "1d", "2d", "2d-array", "cube", "cube-array", "3d", ],
|
|
StorageTextureAccess: [undefined, "write-only", "read-only", "read-write", ],
|
|
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", "rgb10a2uint", "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", ],
|
|
QueryType: ["occlusion", "timestamp", ],
|
|
VertexStepMode: ["vertex", "instance", "vertex-buffer-not-used", ],
|
|
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", ],
|
|
PrimitiveTopology: ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip", ],
|
|
IndexFormat: [undefined, "uint16", "uint32", ],
|
|
FrontFace: ["ccw", "cw", ],
|
|
CullMode: ["none", "front", "back", ],
|
|
AddressMode: ["repeat", "mirror-repeat", "clamp-to-edge", ],
|
|
FilterMode: ["nearest", "linear", ],
|
|
MipmapFilterMode: ["nearest", "linear", ],
|
|
CompareFunction: [undefined, "never", "less", "less-equal", "greater", "greater-equal", "equal", "not-equal", "always", ],
|
|
TextureDimension: ["1d", "2d", "3d", ],
|
|
ErrorType: ["no-error", "validation", "out-of-memory", "internal", "unknown", "device-lost", ],
|
|
WGSLFeatureName: [undefined, "readonly_and_readwrite_storage_textures", "packed_4x8_integer_dot_product", "unrestricted_pointer_parameters", "pointer_composite_access", ],
|
|
PowerPreference: [undefined, "low-power", "high-performance", ],
|
|
CompositeAlphaMode: ["auto", "opaque", "premultiplied", "unpremultiplied", "inherit", ],
|
|
StencilOperation: ["keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap", ],
|
|
BlendOperation: ["add", "subtract", "reverse-subtract", "min", "max", ],
|
|
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", ],
|
|
PresentMode: ["fifo", "fifo-relaxed", "immediate", "mailbox", ],
|
|
TextureAspect: ["all", "stencil-only", "depth-only"],
|
|
};
|
|
|
|
/** @type {WebGPUObjectManager<{}>} */
|
|
this.instances = new WebGPUObjectManager("Instance", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUAdapter>} */
|
|
this.adapters = new WebGPUObjectManager("Adapter", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUBindGroup>} */
|
|
this.bindGroups = new WebGPUObjectManager("BindGroup", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUBindGroupLayout>} */
|
|
this.bindGroupLayouts = new WebGPUObjectManager("BindGroupLayout", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<{ buffer: GPUBuffer, mapping: ?{ range: ArrayBuffer, ptr: number, size: number } }>} */
|
|
this.buffers = new WebGPUObjectManager("Buffer", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUDevice>} */
|
|
this.devices = new WebGPUObjectManager("Device", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUCommandBuffer>} */
|
|
this.commandBuffers = new WebGPUObjectManager("CommandBuffer", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUCommandEncoder>} */
|
|
this.commandEncoders = new WebGPUObjectManager("CommandEncoder", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUComputePassEncoder>} */
|
|
this.computePassEncoders = new WebGPUObjectManager("ComputePassEncoder", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPURenderPassEncoder>} */
|
|
this.renderPassEncoders = new WebGPUObjectManager("RenderPassEncoder", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUQuerySet>} */
|
|
this.querySets = new WebGPUObjectManager("QuerySet", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUComputePipeline>} */
|
|
this.computePipelines = new WebGPUObjectManager("ComputePipeline", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUPipelineLayout>} */
|
|
this.pipelineLayouts = new WebGPUObjectManager("PipelineLayout", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUQueue>} */
|
|
this.queues = new WebGPUObjectManager("Queue", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPURenderBundle>} */
|
|
this.renderBundles = new WebGPUObjectManager("RenderBundle", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPURenderBundleEncoder>} */
|
|
this.renderBundleEncoders = new WebGPUObjectManager("RenderBundleEncoder", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPURenderPipeline>} */
|
|
this.renderPipelines = new WebGPUObjectManager("RenderPipeline", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUSampler>} */
|
|
this.samplers = new WebGPUObjectManager("Sampler", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUShaderModule>} */
|
|
this.shaderModules = new WebGPUObjectManager("ShaderModule", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<HTMLCanvasElement>} */
|
|
this.surfaces = new WebGPUObjectManager("Surface", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUTexture>} */
|
|
this.textures = new WebGPUObjectManager("Texture", this.mem);
|
|
|
|
/** @type {WebGPUObjectManager<GPUTextureView>} */
|
|
this.textureViews = new WebGPUObjectManager("TextureView", this.mem);
|
|
}
|
|
|
|
/**
|
|
* @param {number|BigInt} src
|
|
* @returns {number|BigInt}
|
|
*/
|
|
uint(src) {
|
|
if (this.mem.intSize == 8) {
|
|
return BigInt(src);
|
|
} else if (this.mem.intSize == 4) {
|
|
return src;
|
|
} else {
|
|
throw new Error("unreachable");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number|BigInt} src
|
|
* @returns {number}
|
|
*/
|
|
unwrapBigInt(src) {
|
|
if (typeof src == "number") {
|
|
return src;
|
|
}
|
|
|
|
const MAX_SAFE_INTEGER = 9007199254740991n;
|
|
if (typeof src != "bigint") {
|
|
throw new TypeError(`unwrapBigInt got invalid param of type ${typeof src}`);
|
|
}
|
|
|
|
if (src > MAX_SAFE_INTEGER) {
|
|
throw new Error(`unwrapBigInt precision would be lost converting ${src}`);
|
|
}
|
|
|
|
return Number(src);
|
|
}
|
|
|
|
/**
|
|
* @param {boolean} condition
|
|
* @param {string} message
|
|
*/
|
|
assert(condition, message = "assertion failure") {
|
|
if (!condition) {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @template T
|
|
*
|
|
* @param {number} count
|
|
* @param {number} start
|
|
* @param {function(number): T} decoder
|
|
* @param {number} stride
|
|
* @returns {Array<T>}
|
|
*/
|
|
array(count, start, decoder, stride) {
|
|
if (count == 0) {
|
|
return [];
|
|
}
|
|
this.assert(start != 0);
|
|
|
|
const out = [];
|
|
for (let i = 0; i < count; i += 1) {
|
|
out.push(decoder.call(this, start));
|
|
start += stride;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @param {number} ptr
|
|
* @returns {`GPU${name}`}
|
|
*/
|
|
enumeration(name, ptr) {
|
|
const int = this.mem.loadI32(ptr);
|
|
this.assert(this.enums[name], `Unknown enumeration "${name}"`);
|
|
return this.enums[name][int];
|
|
}
|
|
|
|
/**
|
|
* @param {GPUSupportedFeatures} features
|
|
* @param {number} ptr
|
|
* @returns {BigInt|number}
|
|
*/
|
|
genericEnumerateFeatures(features, ptr) {
|
|
const availableFeatures = [];
|
|
this.enums.FeatureName.forEach((feature, value) => {
|
|
if (!feature) {
|
|
return;
|
|
}
|
|
|
|
if (features.has(feature)) {
|
|
availableFeatures.push(value);
|
|
}
|
|
});
|
|
|
|
if (ptr != 0) {
|
|
for (let i = 0; i < availableFeatures.length; i += 1) {
|
|
this.mem.storeI32(ptr + (i * 4), availableFeatures[i]);
|
|
}
|
|
}
|
|
|
|
return this.uint(availableFeatures.length);
|
|
}
|
|
|
|
/**
|
|
* @param {GPUSupportedLimits} limits
|
|
* @param {number} ptr
|
|
*/
|
|
genericGetLimits(limits, supportedLimitsPtr) {
|
|
this.assert(supportedLimitsPtr != 0);
|
|
const limitsPtr = supportedLimitsPtr + 8;
|
|
|
|
this.mem.storeU32(limitsPtr + 0, limits.maxTextureDimension1D);
|
|
this.mem.storeU32(limitsPtr + 4, limits.maxTextureDimension2D);
|
|
this.mem.storeU32(limitsPtr + 8, limits.maxTextureDimension3D);
|
|
this.mem.storeU32(limitsPtr + 12, limits.maxTextureArrayLayers);
|
|
this.mem.storeU32(limitsPtr + 16, limits.maxBindGroups);
|
|
this.mem.storeU32(limitsPtr + 20, limits.maxBindGroupsPlusVertexBuffers);
|
|
this.mem.storeU32(limitsPtr + 24, limits.maxBindingsPerBindGroup);
|
|
this.mem.storeU32(limitsPtr + 28, limits.maxDynamicUniformBuffersPerPipelineLayout);
|
|
this.mem.storeU32(limitsPtr + 32, limits.maxDynamicStorageBuffersPerPipelineLayout);
|
|
this.mem.storeU32(limitsPtr + 36, limits.maxSampledTexturesPerShaderStage);
|
|
this.mem.storeU32(limitsPtr + 40, limits.maxSamplersPerShaderStage);
|
|
this.mem.storeU32(limitsPtr + 44, limits.maxStorageBuffersPerShaderStage);
|
|
this.mem.storeU32(limitsPtr + 48, limits.maxStorageTexturesPerShaderStage);
|
|
this.mem.storeU32(limitsPtr + 52, limits.maxUniformBuffersPerShaderStage);
|
|
this.mem.storeU64(limitsPtr + 56, limits.maxUniformBufferBindingSize);
|
|
this.mem.storeU64(limitsPtr + 64, limits.maxStorageBufferBindingSize);
|
|
this.mem.storeU32(limitsPtr + 72, limits.minUniformBufferOffsetAlignment);
|
|
this.mem.storeU32(limitsPtr + 76, limits.minStorageBufferOffsetAlignment);
|
|
this.mem.storeU32(limitsPtr + 80, limits.maxVertexBuffers);
|
|
this.mem.storeU64(limitsPtr + 88, limits.maxBufferSize);
|
|
this.mem.storeU32(limitsPtr + 96, limits.maxVertexAttributes);
|
|
this.mem.storeU32(limitsPtr + 100, limits.maxVertexBufferArrayStride);
|
|
this.mem.storeU32(limitsPtr + 104, limits.maxInterStageShaderComponents);
|
|
this.mem.storeU32(limitsPtr + 108, limits.maxInterStageShaderVariables);
|
|
this.mem.storeU32(limitsPtr + 112, limits.maxColorAttachments);
|
|
this.mem.storeU32(limitsPtr + 116, limits.maxColorAttachmentBytesPerSample);
|
|
this.mem.storeU32(limitsPtr + 120, limits.maxComputeWorkgroupStorageSize);
|
|
this.mem.storeU32(limitsPtr + 124, limits.maxComputeInvocationsPerWorkgroup);
|
|
this.mem.storeU32(limitsPtr + 128, limits.maxComputeWorkgroupSizeX);
|
|
this.mem.storeU32(limitsPtr + 132, limits.maxComputeWorkgroupSizeY);
|
|
this.mem.storeU32(limitsPtr + 136, limits.maxComputeWorkgroupSizeZ);
|
|
this.mem.storeU32(limitsPtr + 140, limits.maxComputeWorkgroupsPerDimension);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {GPUFeatureName}
|
|
*/
|
|
FeatureNamePtr(ptr) {
|
|
return this.FeatureName(this.mem.loadI32(ptr));
|
|
}
|
|
|
|
/**
|
|
* @param {number} featureInt
|
|
* @returns {GPUFeatureName}
|
|
*/
|
|
FeatureName(featureInt) {
|
|
return this.enums.FeatureName[featureInt];
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {GPUSupportedLimits}
|
|
*/
|
|
RequiredLimitsPtr(ptr) {
|
|
const start = this.mem.loadPtr(ptr);
|
|
if (start == 0) {
|
|
return undefined;
|
|
}
|
|
|
|
return this.Limits(start + 8);
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @return {GPUSupportedLimits}
|
|
*/
|
|
Limits(start) {
|
|
const limitU32 = (ptr) => {
|
|
const value = this.mem.loadU32(ptr);
|
|
if (value == 0xFFFFFFFF) { // LIMIT_32_UNDEFINED.
|
|
return undefined;
|
|
}
|
|
return value;
|
|
};
|
|
|
|
const limitU64 = (ptr) => {
|
|
const part1 = this.mem.loadU32(ptr);
|
|
const part2 = this.mem.loadU32(ptr + 4);
|
|
if (part1 != 0xFFFFFFFF || part2 != 0xFFFFFFFF) { // LIMIT_64_UNDEFINED.
|
|
return this.mem.loadU64(ptr);
|
|
}
|
|
return undefined;
|
|
};
|
|
|
|
return {
|
|
maxTextureDimension1D: limitU32(start + 0),
|
|
maxTextureDimension2D: limitU32(start + 4),
|
|
maxTextureDimension3D: limitU32(start + 8),
|
|
maxTextureArrayLayers: limitU32(start + 12),
|
|
maxBindGroups: limitU32(start + 16),
|
|
maxBindGroupsPlusVertexBuffers: limitU32(start + 20),
|
|
maxBindingsPerBindGroup: limitU32(start + 24),
|
|
maxDynamicUniformBuffersPerPipelineLayout: limitU32(start + 28),
|
|
maxDynamicStorageBuffersPerPipelineLayout: limitU32(start + 32),
|
|
maxSampledTexturesPerShaderStage: limitU32(start + 36),
|
|
maxSamplersPerShaderStage: limitU32(start + 40),
|
|
maxStorageBuffersPerShaderStage: limitU32(start + 44),
|
|
maxStorageTexturesPerShaderStage: limitU32(start + 48),
|
|
maxUniformBuffersPerShaderStage: limitU32(start + 52),
|
|
maxUniformBufferBindingSize: limitU64(start + 56),
|
|
maxStorageBufferBindingSize: limitU64(start + 64),
|
|
minUniformBufferOffsetAlignment: limitU32(start + 72),
|
|
minStorageBufferOffsetAlignment: limitU32(start + 76),
|
|
maxVertexBuffers: limitU32(start + 80),
|
|
maxBufferSize: limitU64(start + 88),
|
|
maxVertexAttributes: limitU32(start + 96),
|
|
maxVertexBufferArrayStride: limitU32(start + 100),
|
|
maxInterStageShaderComponents: limitU32(start + 104),
|
|
maxInterStageShaderVariables: limitU32(start + 108),
|
|
maxColorAttachments: limitU32(start + 112),
|
|
maxColorAttachmentBytesPerSample: limitU32(start + 116),
|
|
maxComputeWorkgroupStorageSize: limitU32(start + 120),
|
|
maxComputeInvocationsPerWorkgroup: limitU32(start + 124),
|
|
maxComputeWorkgroupSizeX: limitU32(start + 128),
|
|
maxComputeWorkgroupSizeY: limitU32(start + 132),
|
|
maxComputeWorkgroupSizeZ: limitU32(start + 136),
|
|
maxComputeWorkgroupsPerDimension: limitU32(start + 140),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUQueueDescriptor}
|
|
*/
|
|
QueueDescriptor(start) {
|
|
return {
|
|
label: this.mem.loadCstring(start + 4),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {GPUComputePassTimestampWrites}
|
|
*/
|
|
ComputePassTimestampWritesPtr(ptr) {
|
|
const start = this.mem.loadPtr(ptr);
|
|
if (start == 0) {
|
|
return undefined;
|
|
}
|
|
|
|
return {
|
|
querySet: this.querySets.get(this.mem.loadPtr(start + 0)),
|
|
beginningOfPassWriteIndex: this.mem.loadU32(start + 4),
|
|
endOfPassWriteIndex: this.mem.loadU32(start + 8),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPURenderPassColorAttachment}
|
|
*/
|
|
RenderPassColorAttachment(start) {
|
|
const viewIdx = this.mem.loadPtr(start + 4);
|
|
const resolveTargetIdx = this.mem.loadPtr(start + 8);
|
|
|
|
return {
|
|
view: viewIdx > 0 ? this.textureViews.get(viewIdx) : undefined,
|
|
resolveTarget: resolveTargetIdx > 0 ? this.textureViews.get(resolveTargetIdx) : undefined,
|
|
loadOp: this.enumeration("LoadOp", start + 12),
|
|
storeOp: this.enumeration("StoreOp", start + 16),
|
|
clearValue: this.Color(start + 24),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUColor}
|
|
*/
|
|
Color(start) {
|
|
return {
|
|
r: this.mem.loadF64(start + 0),
|
|
g: this.mem.loadF64(start + 8),
|
|
b: this.mem.loadF64(start + 16),
|
|
a: this.mem.loadF64(start + 24),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {GPURenderPassDepthStencilAttachment}
|
|
*/
|
|
RenderPassDepthStencilAttachmentPtr(ptr) {
|
|
const start = this.mem.loadPtr(ptr);
|
|
if (start == 0) {
|
|
return undefined;
|
|
}
|
|
|
|
return {
|
|
view: this.textureViews.get(this.mem.loadPtr(start + 0)),
|
|
depthLoadOp: this.enumeration("LoadOp", start + 4),
|
|
depthStoreOp: this.enumeration("StoreOp", start + 8),
|
|
depthClearValue: this.mem.loadF32(start + 12),
|
|
depthReadOnly: this.mem.loadB32(start + 16),
|
|
stencilLoadOp: this.enumeration("LoadOp", start + 20),
|
|
stencilStoreOp: this.enumeration("StoreOp", start + 24),
|
|
stencilClearValue: this.mem.loadF32(start + 28),
|
|
stencilReadOnly: this.mem.loadB32(start + 32),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {undefined|GPUQuerySet}
|
|
*/
|
|
QuerySet(ptr) {
|
|
ptr = this.mem.loadPtr(ptr);
|
|
if (ptr == 0) {
|
|
return undefined;
|
|
}
|
|
|
|
return this.querySets.get(ptr);
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {GPURenderPassTimestampWrites}
|
|
*/
|
|
RenderPassTimestampWritesPtr(ptr) {
|
|
return this.ComputePassTimestampWritesPtr(ptr);
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUImageDataLayout}
|
|
*/
|
|
TextureDataLayout(start) {
|
|
return {
|
|
offset: this.mem.loadU64(start + 8),
|
|
bytesPerRow: this.mem.loadU32(start + 16),
|
|
rowsPerImage: this.mem.loadU32(start + 20),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUImageCopyBuffer}
|
|
*/
|
|
ImageCopyBuffer(start) {
|
|
return {
|
|
...this.TextureDataLayout(start + 8),
|
|
buffer: this.buffers.get(this.mem.loadPtr(start + 32)).buffer,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUImageCopyTexture}
|
|
*/
|
|
ImageCopyTexture(start) {
|
|
return {
|
|
texture: this.textures.get(this.mem.loadPtr(start + 4)),
|
|
mipLevel: this.mem.loadU32(start + 8),
|
|
origin: this.Origin3D(start + 12),
|
|
aspect: this.enumeration("TextureAspect", start + 24),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUOrigin3D}
|
|
*/
|
|
Origin3D(start) {
|
|
return {
|
|
x: this.mem.loadU32(start + 0),
|
|
y: this.mem.loadU32(start + 4),
|
|
z: this.mem.loadU32(start + 8),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUExtent3D}
|
|
*/
|
|
Extent3D(start) {
|
|
return {
|
|
width: this.mem.loadU32(start + 0),
|
|
height: this.mem.loadU32(start + 4),
|
|
depthOrArrayLayers: this.mem.loadU32(start + 8),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUBindGroupEntry}
|
|
*/
|
|
BindGroupEntry(start) {
|
|
const buffer = this.mem.loadPtr(start + 8);
|
|
const sampler = this.mem.loadPtr(start + 32);
|
|
const textureView = this.mem.loadPtr(start + 36);
|
|
|
|
/** @type {GPUBindingResource} */
|
|
let resource;
|
|
if (buffer > 0) {
|
|
resource = {
|
|
buffer: this.buffers.get(buffer).buffer,
|
|
offset: this.mem.loadU64(start + 16),
|
|
size: this.mem.loadU64(start + 24),
|
|
}
|
|
} else if (sampler > 0) {
|
|
resource = this.samplers.get(sampler);
|
|
} else if (textureView > 0) {
|
|
resource = this.textureViews.get(textureView);
|
|
}
|
|
|
|
return {
|
|
binding: this.mem.loadU32(start + 4),
|
|
resource: resource,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUBindGroupLayoutEntry}
|
|
*/
|
|
BindGroupLayoutEntry(start) {
|
|
const entry = {
|
|
binding: this.mem.loadU32(start + 4),
|
|
visibility: this.mem.loadU32(start + 8),
|
|
buffer: this.BufferBindingLayout(start + 16),
|
|
sampler: this.SamplerBindingLayout(start + 40),
|
|
texture: this.TextureBindingLayout(start + 48),
|
|
storageTexture: this.StorageTextureBindingLayout(start + 64),
|
|
};
|
|
if (!entry.buffer.type) {
|
|
entry.buffer = undefined;
|
|
}
|
|
if (!entry.sampler.type) {
|
|
entry.sampler = undefined;
|
|
}
|
|
if (!entry.texture.sampleType) {
|
|
entry.texture = undefined;
|
|
}
|
|
if (!entry.storageTexture.access) {
|
|
entry.storageTexture = undefined;
|
|
}
|
|
return entry;
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUBufferBindingLayout}
|
|
*/
|
|
BufferBindingLayout(start) {
|
|
return {
|
|
type: this.enumeration("BufferBindingType", start + 4),
|
|
hasDynamicOffset: this.mem.loadB32(start + 8),
|
|
minBindingSize: this.mem.loadU64(start + 16),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUSamplerBindingLayout}
|
|
*/
|
|
SamplerBindingLayout(start) {
|
|
return {
|
|
type: this.enumeration("SamplerBindingType", start + 4),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUTextureBindingLayout}
|
|
*/
|
|
TextureBindingLayout(start) {
|
|
return {
|
|
sampleType: this.enumeration("TextureSampleType", start + 4),
|
|
viewDimension: this.enumeration("TextureViewDimension", start + 8),
|
|
multisampled: this.mem.loadB32(start + 12),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUStorageTextureBindingLayout}
|
|
*/
|
|
StorageTextureBindingLayout(start) {
|
|
return {
|
|
access: this.enumeration("StorageTextureAccess", start + 4),
|
|
format: this.enumeration("TextureFormat", start + 8),
|
|
viewDimension: this.enumeration("TextureViewDimension", start + 12),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUProgrammableStage}
|
|
*/
|
|
ProgrammableStageDescriptor(start) {
|
|
const constantsArray = this.array(
|
|
this.mem.loadUint(start + 8 + this.mem.intSize),
|
|
this.mem.loadPtr(start + 8 + this.mem.intSize*2),
|
|
this.ConstantEntry,
|
|
16,
|
|
);
|
|
return {
|
|
module: this.shaderModules.get(this.mem.loadPtr(start + 4)),
|
|
entryPoint: this.mem.loadCstring(start + 8),
|
|
constants: constantsArray.reduce((prev, curr) => {
|
|
prev[curr.key] = curr.value;
|
|
return prev;
|
|
}, {}),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {{ key: string, value: number }}
|
|
*/
|
|
ConstantEntry(start) {
|
|
return {
|
|
key: this.mem.loadCstring(start + 4),
|
|
value: this.mem.loadF64(start + 8),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUComputePipelineDescriptor}
|
|
*/
|
|
ComputePipelineDescriptor(start) {
|
|
const layoutIdx = this.mem.loadPtr(start + 8)
|
|
return {
|
|
label: this.mem.loadCstring(start + 4),
|
|
layout: layoutIdx > 0 ? this.pipelineLayouts.get(layoutIdx) : undefined,
|
|
compute: this.ProgrammableStageDescriptor(start + 8 + this.mem.intSize),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUVertexState}
|
|
*/
|
|
VertexState(start) {
|
|
let off = 8 + this.mem.intSize;
|
|
const constantsArray = this.array(
|
|
this.mem.loadUint(start + off),
|
|
this.mem.loadPtr(start + off + this.mem.intSize),
|
|
this.ConstantEntry,
|
|
16,
|
|
);
|
|
|
|
off += this.mem.intSize * 2;
|
|
|
|
return {
|
|
module: this.shaderModules.get(this.mem.loadPtr(start + 4)),
|
|
entryPoint: this.mem.loadCstring(start + 8),
|
|
constants: constantsArray.reduce((prev, curr) => {
|
|
prev[curr.key] = curr.value;
|
|
return prev;
|
|
}, {}),
|
|
buffers: this.array(
|
|
this.mem.loadUint(start + off),
|
|
this.mem.loadPtr(start + off + this.mem.intSize),
|
|
this.VertexBufferLayout,
|
|
this.mem.intSize == 8 ? 32 : 24,
|
|
),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {?GPUVertexBufferLayout}
|
|
*/
|
|
VertexBufferLayout(start) {
|
|
const stepMode = this.enumeration("VertexStepMode", start + 8);
|
|
if (stepMode == "vertex-buffer-not-used") {
|
|
return null;
|
|
}
|
|
return {
|
|
arrayStride: this.mem.loadU64(start + 0),
|
|
stepMode: stepMode,
|
|
attributes: this.array(
|
|
this.mem.loadUint(start + 8 + this.mem.intSize),
|
|
this.mem.loadPtr(start + 8 + this.mem.intSize*2),
|
|
this.VertexAttribute,
|
|
24,
|
|
),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUVertexAttribute}
|
|
*/
|
|
VertexAttribute(start) {
|
|
return {
|
|
format: this.enumeration("VertexFormat", start + 0),
|
|
offset: this.mem.loadU64(start + 8),
|
|
shaderLocation: this.mem.loadU32(start + 16),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUPrimitiveState}
|
|
*/
|
|
PrimitiveState(start) {
|
|
let unclippedDepth = undefined;
|
|
const nextInChain = this.mem.loadPtr(start);
|
|
if (nextInChain != 0) {
|
|
const nextInChainType = this.mem.loadI32(nextInChain + 4);
|
|
// PrimitiveDepthClipControl = 0x00000007,
|
|
if (nextInChainType == 7) {
|
|
unclippedDepth = this.mem.loadB32(nextInChain + 8);
|
|
}
|
|
}
|
|
|
|
return {
|
|
topology: this.enumeration("PrimitiveTopology", start + 4),
|
|
stripIndexFormat: this.enumeration("IndexFormat", start + 8),
|
|
frontFace: this.enumeration("FrontFace", start + 12),
|
|
cullMode: this.enumeration("CullMode", start + 16),
|
|
unclippedDepth: unclippedDepth,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPURenderPipelineDescriptor}
|
|
*/
|
|
RenderPipelineDescriptor(start) {
|
|
const layoutIdx = this.mem.loadPtr(start + 8);
|
|
const offs = this.mem.intSize == 8 ? [64, 84, 88, 104] : [40, 60, 64, 80];
|
|
return {
|
|
label: this.mem.loadCstring(start + 4),
|
|
layout: layoutIdx > 0 ? this.pipelineLayouts.get(layoutIdx) : undefined,
|
|
vertex: this.VertexState(start + 8 + this.mem.intSize),
|
|
primitive: this.PrimitiveState(start + offs[0]),
|
|
depthStencil: this.DepthStencilStatePtr(start + offs[1]),
|
|
multisample: this.MultisampleState(start + offs[2]),
|
|
fragment: this.FragmentStatePtr(start + offs[3]),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUShaderModuleCompilationHint}
|
|
*/
|
|
ShaderModuleCompilationHint(start) {
|
|
return {
|
|
entryPoint: this.mem.loadCstring(start + 4),
|
|
layout: this.pipelineLayouts.get(this.mem.loadPtr(start + 8)),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {?GPUDepthStencilState}
|
|
*/
|
|
DepthStencilStatePtr(ptr) {
|
|
const start = this.mem.loadPtr(ptr);
|
|
if (start == 0) {
|
|
return undefined;
|
|
}
|
|
|
|
return {
|
|
format: this.enumeration("TextureFormat", start + 4),
|
|
depthWriteEnabled: this.mem.loadB32(start + 8),
|
|
depthCompare: this.enumeration("CompareFunction", start + 12),
|
|
stencilFront: this.StencilFaceState(start + 16),
|
|
stencilBack: this.StencilFaceState(start + 32),
|
|
stencilReadMask: this.mem.loadU32(start + 48),
|
|
stencilWriteMask: this.mem.loadU32(start + 52),
|
|
depthBias: this.mem.loadI32(start + 56),
|
|
depthBiasSlopeScale: this.mem.loadF32(start + 60),
|
|
depthBiasClamp: this.mem.loadF32(start + 64),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUStencilFaceState}
|
|
*/
|
|
StencilFaceState(start) {
|
|
return {
|
|
compare: this.enumeration("CompareFunction", start + 0),
|
|
failOp: this.enumeration("StencilOperation", start + 4),
|
|
depthFailOp: this.enumeration("StencilOperation", start + 8),
|
|
passOp: this.enumeration("StencilOperation", start + 12),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUMultisampleState}
|
|
*/
|
|
MultisampleState(start) {
|
|
return {
|
|
count: this.mem.loadU32(start + 4),
|
|
mask: this.mem.loadU32(start + 8),
|
|
alphaToCoverageEnabled: this.mem.loadB32(start + 12),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {?GPUFragmentState}
|
|
*/
|
|
FragmentStatePtr(ptr) {
|
|
const start = this.mem.loadPtr(ptr);
|
|
if (start == 0) {
|
|
return undefined;
|
|
}
|
|
|
|
let off = 8 + this.mem.intSize;
|
|
|
|
const constantsArray = this.array(
|
|
this.mem.loadUint(start + off),
|
|
this.mem.loadPtr(start + off + this.mem.intSize),
|
|
this.ConstantEntry,
|
|
16,
|
|
);
|
|
|
|
off += this.mem.intSize * 2;
|
|
|
|
return {
|
|
module: this.shaderModules.get(this.mem.loadPtr(start + 4)),
|
|
entryPoint: this.mem.loadCstring(start + 8),
|
|
constants: constantsArray.reduce((prev, curr) => {
|
|
prev[curr.key] = curr.value;
|
|
return prev;
|
|
}, {}),
|
|
targets: this.array(
|
|
this.mem.loadUint(start + off),
|
|
this.mem.loadPtr(start + off + this.mem.intSize),
|
|
this.ColorTargetState,
|
|
16,
|
|
),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {GPUColorTargetState}
|
|
*/
|
|
ColorTargetState(start) {
|
|
return {
|
|
format: this.enumeration("TextureFormat", start + 4),
|
|
blend: this.BlendStatePtr(start + 8),
|
|
writeMask: this.mem.loadU32(start + 12),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} ptr
|
|
* @returns {?GPUBlendState}
|
|
*/
|
|
BlendStatePtr(ptr) {
|
|
const start = this.mem.loadPtr(ptr);
|
|
if (start == 0) {
|
|
return undefined;
|
|
}
|
|
|
|
return {
|
|
color: this.BlendComponent(start + 0),
|
|
alpha: this.BlendComponent(start + 12),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {number} start
|
|
* @returns {?GPUBlendComponent}
|
|
*/
|
|
BlendComponent(start) {
|
|
return {
|
|
operation: this.enumeration("BlendOperation", start + 0),
|
|
srcFactor: this.enumeration("BlendFactor", start + 4),
|
|
dstFactor: this.enumeration("BlendFactor", start + 8),
|
|
};
|
|
}
|
|
|
|
getInterface() {
|
|
return {
|
|
/**
|
|
* @param {0|number} descriptorPtr
|
|
* @returns {number}
|
|
*/
|
|
wgpuCreateInstance: (descriptorPtr) => {
|
|
if (!navigator.gpu) {
|
|
console.error("WebGPU is not supported by this browser");
|
|
return 0;
|
|
}
|
|
|
|
return this.instances.create({});
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} procNamePtr
|
|
* @returns {number}
|
|
*/
|
|
wgpuGetProcAddress: (deviceIdx, procNamePtr) => {
|
|
console.error(`unimplemented: wgpuGetProcAddress`);
|
|
return 0;
|
|
},
|
|
|
|
/* ---------------------- Adapter ---------------------- */
|
|
|
|
/**
|
|
* @param {number} adapterIdx
|
|
* @param {number} featuresPtr
|
|
* @returns {number|BigInt}
|
|
*/
|
|
wgpuAdapterEnumerateFeatures: (adapterIdx, featuresPtr) => {
|
|
const adapter = this.adapters.get(adapterIdx);
|
|
return this.genericEnumerateFeatures(adapter.features, featuresPtr);
|
|
},
|
|
|
|
/**
|
|
* @param {number} adapterIdx
|
|
* @param {number} supportedLimitsPtr
|
|
* @returns {boolean}
|
|
*/
|
|
wgpuAdapterGetLimits: (adapterIdx, supportedLimitsPtr) => {
|
|
const adapter = this.adapters.get(adapterIdx);
|
|
return this.genericGetLimits(adapter.limits, supportedLimitsPtr);
|
|
},
|
|
|
|
/**
|
|
* @param {number} adapterIdx
|
|
* @param {number} propertiesPtr
|
|
*/
|
|
wgpuAdapterGetProperties: (adapterIdx, propertiesPtr) => {
|
|
this.assert(propertiesPtr != 0);
|
|
// Unknown adapter.
|
|
this.mem.storeI32(propertiesPtr + 28, 3);
|
|
// WebGPU backend.
|
|
this.mem.storeI32(propertiesPtr + 32, 2);
|
|
},
|
|
|
|
/**
|
|
* @param {number} adapterIdx
|
|
* @param {number} featureInt
|
|
* @returns {boolean}
|
|
*/
|
|
wgpuAdapterHasFeature: (adapterIdx, featureInt) => {
|
|
const adapter = this.adapters.get(adapterIdx);
|
|
return adapter.features.has(this.enums.FeatureName[featureInt]);
|
|
},
|
|
|
|
/**
|
|
* @param {number} adapterIdx
|
|
* @param {number} callbackPtr
|
|
* @param {0|number} userdata
|
|
*/
|
|
wgpuAdapterRequestAdapterInfo: async (adapterIdx, callbackPtr, userdata) => {
|
|
const adapter = this.adapters.get(adapterIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
|
|
const info = await adapter.requestAdapterInfo();
|
|
|
|
const addr = this.mem.exports.wgpu_alloc(16);
|
|
|
|
const vendorLength = new TextEncoder().encode(info.vendor).length;
|
|
const vendorAddr = this.mem.exports.wgpu_alloc(vendorLength);
|
|
this.mem.storeString(vendorAddr, info.vendor);
|
|
this.mem.storeI32(addr + 0, vendorAddr);
|
|
|
|
const architectureLength = new TextEncoder().encode(info.architecture).length;
|
|
const architectureAddr = this.mem.exports.wgpu_alloc(architectureLength);
|
|
this.mem.storeString(architectureAddr, info.architecture);
|
|
this.mem.storeI32(addr + 4, architectureAddr);
|
|
|
|
|
|
const deviceLength = new TextEncoder().encode(info.device).length;
|
|
const deviceAddr = this.mem.exports.wgpu_alloc(deviceLength);
|
|
this.mem.storeString(deviceAddr, info.device);
|
|
this.mem.storeI32(addr + 8, deviceAddr);
|
|
|
|
|
|
const descriptionLength = new TextEncoder().encode(info.description).length;
|
|
const descriptionAddr = this.mem.exports.wgpu_alloc(descriptionLength);
|
|
this.mem.storeString(descriptionAddr, info.description);
|
|
this.mem.storeI32(addr + 12, descriptionAddr);
|
|
|
|
callback(addr, userdata);
|
|
|
|
this.mem.exports.wgpu_free(descriptionAddr);
|
|
this.mem.exports.wgpu_free(deviceAddr);
|
|
this.mem.exports.wgpu_free(architectureAddr);
|
|
this.mem.exports.wgpu_free(vendorAddr);
|
|
this.mem.exports.wgpu_free(addr);
|
|
},
|
|
|
|
/**
|
|
* @param {number} adapterIdx
|
|
* @param {0|number} descriptorPtr
|
|
* @param {number} callbackPtr
|
|
* @param {0|number} userdata
|
|
*/
|
|
wgpuAdapterRequestDevice: async (adapterIdx, descriptorPtr, callbackPtr, userdata) => {
|
|
const adapter = this.adapters.get(adapterIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
|
|
/** @type {GPUDeviceDescriptor} */
|
|
let descriptor;
|
|
if (descriptorPtr != 0) {
|
|
descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
requiredFeatures: this.array(
|
|
this.mem.loadUint(descriptorPtr + 8),
|
|
this.mem.loadPtr(descriptorPtr + 8 + this.mem.intSize),
|
|
this.FeatureNamePtr,
|
|
4,
|
|
),
|
|
requiredLimits: this.RequiredLimitsPtr(descriptorPtr + 8 + this.mem.intSize + 4),
|
|
defaultQueue: this.QueueDescriptor( descriptorPtr + 8 + this.mem.intSize + 4 + 4),
|
|
};
|
|
}
|
|
|
|
let deviceIdx;
|
|
try {
|
|
const device = await adapter.requestDevice(descriptor);
|
|
deviceIdx = this.devices.create(device);
|
|
// NOTE: don't callback here, any errors that happen later will then be caught by the catch here.
|
|
} catch (e) {
|
|
console.warn(e);
|
|
callback(1, null, null, userdata);
|
|
}
|
|
|
|
callback(0, deviceIdx, null, userdata);
|
|
},
|
|
|
|
...this.adapters.interface(),
|
|
|
|
/* ---------------------- BindGroup ---------------------- */
|
|
|
|
...this.bindGroups.interface(true),
|
|
|
|
/* ---------------------- BindGroupLayout ---------------------- */
|
|
|
|
...this.bindGroupLayouts.interface(true),
|
|
|
|
/* ---------------------- Buffer ---------------------- */
|
|
|
|
/** @param {number} bufferIdx */
|
|
wgpuBufferDestroy: (bufferIdx) => {
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
buffer.buffer.destroy();
|
|
},
|
|
|
|
/**
|
|
* @param {number} bufferIdx
|
|
* @param {number|BigInt} offset
|
|
* @param {number|BigInt} size
|
|
* @returns {number}
|
|
*/
|
|
wgpuBufferGetMappedRange: (bufferIdx, offset, size) => {
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
offset = this.unwrapBigInt(offset);
|
|
size = this.unwrapBigInt(size);
|
|
|
|
this.assert(!buffer.mapping, "buffer already mapped");
|
|
|
|
const range = buffer.buffer.getMappedRange(offset, size);
|
|
|
|
const ptr = this.mem.exports.wgpu_alloc(range.byteLength);
|
|
|
|
buffer.mapping = { range: range, ptr: ptr, size: range.byteLength };
|
|
return ptr;
|
|
},
|
|
|
|
/**
|
|
* @param {number} bufferIdx
|
|
* @returns {BigInt}
|
|
*/
|
|
wgpuBufferGetSize: (bufferIdx) => {
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
return BigInt(buffer.buffer.size);
|
|
},
|
|
|
|
/**
|
|
* @param {number} bufferIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuBufferGetUsage: (bufferIdx) => {
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
return buffer.buffer.usage;
|
|
},
|
|
|
|
/**
|
|
* @param {number} bufferIdx
|
|
* @param {number} mode
|
|
* @param {number|BigInt} offset
|
|
* @param {number|BigInt} size
|
|
* @param {number} callbackPtr
|
|
* @param {0|number} userdata
|
|
*/
|
|
wgpuBufferMapAsync: async (bufferIdx, mode, offset, size, callbackPtr, userdata) => {
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
offset = this.unwrapBigInt(offset);
|
|
size = this.unwrapBigInt(size);
|
|
|
|
if (buffer.buffer.mapState == "pending") {
|
|
callback(this.enums.BufferMapAsyncStatus.MappingAlreadyPending, userdata);
|
|
} else {
|
|
let result;
|
|
try {
|
|
await buffer.buffer.mapAsync(mode, offset, size);
|
|
result = 0; // Success.
|
|
} catch(e) {
|
|
console.warn(e);
|
|
result = 2; // Unknown error.
|
|
|
|
if (e instanceof DomException) {
|
|
if (e.name == "OperationError") {
|
|
result = 1; // Validation error.
|
|
}
|
|
}
|
|
}
|
|
|
|
callback(result, userdata);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @param {number} bufferIdx
|
|
* @param {number} labelPtr
|
|
*/
|
|
wgpuBufferSetLabel: (bufferIdx, labelPtr) => {
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
buffer.buffer.label = this.mem.loadCstring(labelPtr);
|
|
},
|
|
|
|
/**
|
|
* @param {number} bufferIdx
|
|
*/
|
|
wgpuBufferUnmap: (bufferIdx) => {
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
this.assert(buffer.mapping, "buffer not mapped");
|
|
|
|
const mapping = new Uint8Array(this.mem.memory.buffer, buffer.mapping.ptr, buffer.mapping.size);
|
|
(new Uint8Array(buffer.mapping.range)).set(mapping);
|
|
|
|
buffer.buffer.unmap();
|
|
|
|
this.mem.exports.wgpu_free(buffer.mapping.ptr);
|
|
buffer.mapping = null;
|
|
},
|
|
|
|
...this.buffers.interface(),
|
|
|
|
/* ---------------------- CommandBuffer ---------------------- */
|
|
|
|
...this.commandBuffers.interface(true),
|
|
|
|
/* ---------------------- CommandEncoder ---------------------- */
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {0|number} descriptorPtr
|
|
* @return {number} The compute pass encoder
|
|
*/
|
|
wgpuCommandEncoderBeginComputePass: (commandEncoderIdx, descriptorPtr) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
|
|
/** @type {?GPUComputePassDescriptor} */
|
|
let descriptor;
|
|
if (descriptorPtr != 0) {
|
|
descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
timestampWrites: this.ComputePassTimestampWritesPtr(descriptorPtr + 8),
|
|
};
|
|
}
|
|
|
|
const computePassEncoder = commandEncoder.beginComputePass(descriptor);
|
|
return this.computePassEncoders.create(computePassEncoder);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} descriptorPtr
|
|
* @return {number} The render pass encoder
|
|
*/
|
|
wgpuCommandEncoderBeginRenderPass: (commandEncoderIdx, descriptorPtr) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
let maxDrawCount = undefined;
|
|
const nextInChain = this.mem.loadPtr(descriptorPtr);
|
|
if (nextInChain != 0) {
|
|
const nextInChainType = this.mem.loadI32(nextInChain + 4);
|
|
// RenderPassDescriptorMaxDrawCount = 0x0000000F,
|
|
if (nextInChainType == 0x0000000F) {
|
|
maxDrawCount = this.mem.loadU64(nextInChain + 8);
|
|
}
|
|
}
|
|
|
|
/** @type {GPURenderPassDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
colorAttachments: this.array(
|
|
this.mem.loadUint(descriptorPtr + 8),
|
|
this.mem.loadPtr(descriptorPtr + 8 + this.mem.intSize),
|
|
this.RenderPassColorAttachment,
|
|
56,
|
|
),
|
|
depthStencilAttachment: this.RenderPassDepthStencilAttachmentPtr(descriptorPtr + 8 + this.mem.intSize + 4),
|
|
occlusionQuerySet: this.QuerySet(descriptorPtr + 8 + this.mem.intSize + 4 + 4),
|
|
timestampWrites: this.RenderPassTimestampWritesPtr(descriptorPtr + 8 + this.mem.intSize + 4 + 4),
|
|
maxDrawCount: maxDrawCount,
|
|
};
|
|
|
|
const renderPassEncoder = commandEncoder.beginRenderPass(descriptor);
|
|
return this.renderPassEncoders.create(renderPassEncoder);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} bufferIdx
|
|
* @param {BigInt} offset
|
|
* @param {BigInt} size
|
|
*/
|
|
wgpuCommandEncoderClearBuffer: (commandEncoderIdx, bufferIdx, offset, size) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
offset = this.unwrapBigInt(offset);
|
|
size = this.unwrapBigInt(size);
|
|
commandEncoder.clearBuffer(buffer.buffer, offset, size);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} sourceIdx
|
|
* @param {BigInt} sourceOffset
|
|
* @param {number} destinationIdx
|
|
* @param {BigInt} destinationOffset
|
|
* @param {BigInt} size
|
|
*/
|
|
wgpuCommandEncoderCopyBufferToBuffer: (commandEncoderIdx, sourceIdx, sourceOffset, destinationIdx, destinationOffset, size) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
const source = this.buffers.get(sourceIdx);
|
|
const destination = this.buffers.get(destinationIdx);
|
|
sourceOffset = this.unwrapBigInt(sourceOffset);
|
|
destinationOffset = this.unwrapBigInt(destinationOffset);
|
|
size = this.unwrapBigInt(size);
|
|
commandEncoder.copyBufferToBuffer(source.buffer, sourceOffset, destination.buffer, destinationOffset, size);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} sourcePtr
|
|
* @param {number} destinationPtr
|
|
* @param {number} copySizePtr
|
|
*/
|
|
wgpuCommandEncoderCopyBufferToTexture: (commandEncoderIdx, sourcePtr, destinationPtr, copySizePtr) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
commandEncoder.copyBufferToTexture(
|
|
this.ImageCopyBuffer(sourcePtr),
|
|
this.ImageCopyTexture(destinationPtr),
|
|
this.Extent3D(copySizePtr),
|
|
);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} sourcePtr
|
|
* @param {number} destinationPtr
|
|
* @param {number} copySizePtr
|
|
*/
|
|
wgpuCommandEncoderCopyTextureToBuffer: (commandEncoderIdx, sourcePtr, destinationPtr, copySizePtr) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
commandEncoder.copyTextureToBuffer(
|
|
this.ImageCopyTexture(sourcePtr),
|
|
this.ImageCopyBuffer(destinationPtr),
|
|
this.Extent3D(copySizePtr),
|
|
);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} sourcePtr
|
|
* @param {number} destinationPtr
|
|
* @param {number} copySizePtr
|
|
*/
|
|
wgpuCommandEncoderCopyTextureToTexture: (commandEncoderIdx, sourcePtr, destinationPtr, copySizePtr) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
commandEncoder.copyTextureToTexture(
|
|
this.ImageCopyTexture(sourcePtr),
|
|
this.ImageCopyTexture(destinationPtr),
|
|
this.Extent3D(copySizePtr),
|
|
);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {0|number} descriptorPtr
|
|
* @returns {number} The command buffer.
|
|
*/
|
|
wgpuCommandEncoderFinish: (commandEncoderIdx, descriptorPtr) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
|
|
/** @type {undefined|GPUCommandBufferDescriptor} */
|
|
let descriptor;
|
|
if (descriptorPtr != 0) {
|
|
descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
};
|
|
}
|
|
|
|
const commandBuffer = commandEncoder.finish(descriptor);
|
|
return this.commandBuffers.create(commandBuffer);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} markerLabelPtr
|
|
*/
|
|
wgpuCommandEncoderInsertDebugMarker: (commandEncoderIdx, markerLabelPtr) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
commandEncoder.insertDebugMarker(this.mem.loadCstring(markerLabelPtr));
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
*/
|
|
wgpuCommandEncoderPopDebugGroup: (commandEncoderIdx) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
commandEncoder.popDebugGroup();
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} markerLabelPtr
|
|
*/
|
|
wgpuCommandEncoderPushDebugGroup: (commandEncoderIdx, groupLabelPtr) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
commandEncoder.pushDebugGroup(this.mem.loadCstring(groupLabelPtr));
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} querySetIdx
|
|
* @param {number} firstQuery
|
|
* @param {number} queryCount
|
|
* @param {number} destinationIdx
|
|
* @param {BigInt} destinationOffset
|
|
*/
|
|
wgpuCommandEncoderResolveQuerySet: (commandEncoderIdx, querySetIdx, firstQuery, queryCount, destinationIdx, destinationOffset) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
const querySet = this.querySets.get(querySetIdx);
|
|
const destination = this.buffers.get(destinationIdx);
|
|
destinationOffset = this.unwrapBigInt(destinationOffset);
|
|
commandEncoder.resolveQuerySet(querySet, firstQuery, queryCount, destination.buffer, destinationOffset);
|
|
},
|
|
|
|
/**
|
|
* @param {number} commandEncoderIdx
|
|
* @param {number} querySetIdx
|
|
* @param {number} queryIndex
|
|
*/
|
|
wgpuCommandEncoderWriteTimestamp: (commandEncoderIdx, querySetIdx, queryIndex) => {
|
|
const commandEncoder = this.commandEncoders.get(commandEncoderIdx);
|
|
const querySet = this.querySets.get(querySetIdx);
|
|
commandEncoder.writeTimestamp(querySet, queryIndex);
|
|
},
|
|
|
|
...this.commandEncoders.interface(true),
|
|
|
|
/* ---------------------- ComputePassEncoder ---------------------- */
|
|
|
|
|
|
/**
|
|
* @param {number} computePassEncoderIdx
|
|
* @param {number} workgroupCountX
|
|
* @param {number} workgroupCountY
|
|
* @param {number} workgroupCountZ
|
|
*/
|
|
wgpuComputePassEncoderDispachWorkgroups: (computePassEncoderIdx, workgroupCountX, workgroupCountY, workgroupCountZ) => {
|
|
const computePassEncoder = this.computePassEncoders.get(computePassEncoderIdx);
|
|
computePassEncoder.dispatchWorkgroups(workgroupCountX, workgroupCountY, workgroupCountZ);
|
|
},
|
|
|
|
/**
|
|
* @param {number} computePassEncoderIdx
|
|
* @param {number} indirectBufferIdx
|
|
* @param {BigInt} indirectOffset
|
|
*/
|
|
wgpuComputePassEncoderDispachWorkgroupsIndirect: (computePassEncoderIdx, indirectBufferIdx, indirectOffset) => {
|
|
const computePassEncoder = this.computePassEncoders.get(computePassEncoderIdx);
|
|
const indirectBuffer = this.buffers.get(indirectBufferIdx);
|
|
indirectOffset = this.unwrapBigInt(indirectOffset);
|
|
computePassEncoder.dispatchWorkgroupsIndirect(indirectBuffer.buffer, indirectOffset);
|
|
},
|
|
|
|
/**
|
|
* @param {number} computePassEncoderIdx
|
|
*/
|
|
wgpuComputePassEncoderEnd: (computePassEncoderIdx) => {
|
|
const computePassEncoder = this.computePassEncoders.get(computePassEncoderIdx);
|
|
computePassEncoder.end();
|
|
},
|
|
|
|
/**
|
|
* @param {number} computePassEncoderIdx
|
|
* @param {number} markerLabelPtr
|
|
*/
|
|
wgpuComputePassEncoderInsertDebugMarker: (computePassEncoderIdx, markerLabelPtr) => {
|
|
const computePassEncoder = this.computePassEncoders.get(computePassEncoderIdx);
|
|
computePassEncoder.insertDebugMarker(this.mem.loadCstring(markerLabelPtr));
|
|
},
|
|
|
|
/**
|
|
* @param {number} computePassEncoderIdx
|
|
*/
|
|
wgpuComputePassEncoderPopDebugGroup: (computePassEncoderIdx) => {
|
|
const computePassEncoder = this.computePassEncoders.get(computePassEncoderIdx);
|
|
computePassEncoder.popDebugGroup();
|
|
},
|
|
|
|
/**
|
|
* @param {number} computePassEncoderIdx
|
|
* @param {number} markerLabelPtr
|
|
*/
|
|
wgpuComputePassEncoderPushDebugGroup: (computePassEncoderIdx, groupLabelPtr) => {
|
|
const computePassEncoder = this.computePassEncoders.get(computePassEncoderIdx);
|
|
computePassEncoder.pushDebugGroup(this.mem.loadCstring(groupLabelPtr));
|
|
},
|
|
|
|
/**
|
|
* @param {number} computePassEncoderIdx
|
|
* @param {number} groupIndex
|
|
* @param {0|number} groupIdx
|
|
* @param {number|BigInt} dynamicOffsetCount
|
|
* @param {number} dynamicOffsetsPtr
|
|
*/
|
|
wgpuComputePassEncoderSetBindGroup: (computePassEncoderIdx, groupIndex, groupIdx, dynamicOffsetCount, dynamicOffsetsPtr) => {
|
|
const computePassEncoder = this.computePassEncoders.get(computePassEncoderIdx);
|
|
dynamicOffsetCount = this.unwrapBigInt(dynamicOffsetCount);
|
|
|
|
let bindGroup;
|
|
if (groupIdx != 0) {
|
|
bindGroup = this.bindGroups.get(groupIdx);
|
|
}
|
|
|
|
const dynamicOffsets = [];
|
|
for (let i = 0; i < dynamicOffsetCount; i += 1) {
|
|
dynamicOffsets.push(this.mem.loadU32(dynamicOffsetsPtr));
|
|
dynamicOffsetsPtr += 4;
|
|
}
|
|
|
|
computePassEncoder.setBindGroup(groupIndex, bindGroup, dynamicOffsets);
|
|
},
|
|
|
|
/**
|
|
* @param {number} computePassEncoderIdx
|
|
* @param {number} pipelineIdx
|
|
*/
|
|
wgpuComputePassEncoderSetPipeline: (computePassEncoderIdx, pipelineIdx) => {
|
|
const computePassEncoder = this.computePassEncoders.get(computePassEncoderIdx);
|
|
const pipeline = this.computePipelines.get(pipelineIdx);
|
|
computePassEncoder.setPipeline(pipeline);
|
|
},
|
|
|
|
...this.computePassEncoders.interface(true),
|
|
|
|
/* ---------------------- ComputePipeline ---------------------- */
|
|
|
|
/**
|
|
* @param {number} computePipelineIdx
|
|
* @param {number} groupIndex
|
|
* @returns {number}
|
|
*/
|
|
wgpuComputePipelineGetBindGroupLayout: (computePipelineIdx, groupIndex) => {
|
|
const computePipeline = this.computePipelines.get(computePipelineIdx);
|
|
const bindGroupLayout = computePipeline.getBindGroupLayout(groupIndex);
|
|
return this.bindGroupLayouts.create(bindGroupLayout);
|
|
},
|
|
|
|
...this.computePipelines.interface(true),
|
|
|
|
/* ---------------------- Device ---------------------- */
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The bind group.
|
|
*/
|
|
wgpuDeviceCreateBindGroup: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
/** @type {GPUBindGroupDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
layout: this.bindGroupLayouts.get(this.mem.loadPtr(descriptorPtr + 8)),
|
|
entries: this.array(
|
|
this.mem.loadUint(descriptorPtr + 8 + this.mem.intSize),
|
|
this.mem.loadPtr(descriptorPtr + 8 + this.mem.intSize * 2),
|
|
this.BindGroupEntry,
|
|
40,
|
|
),
|
|
};
|
|
|
|
const bindGroup = device.createBindGroup(descriptor);
|
|
return this.bindGroups.create(bindGroup);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The bind group layout.
|
|
*/
|
|
wgpuDeviceCreateBindGroupLayout: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
/** @type {GPUBindGroupLayoutDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
entries: this.array(
|
|
this.mem.loadUint(descriptorPtr + 8),
|
|
this.mem.loadPtr(descriptorPtr + 8 + this.mem.intSize),
|
|
this.BindGroupLayoutEntry,
|
|
80,
|
|
),
|
|
};
|
|
|
|
const bindGroupLayout = device.createBindGroupLayout(descriptor);
|
|
return this.bindGroupLayouts.create(bindGroupLayout);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The buffer.
|
|
*/
|
|
wgpuDeviceCreateBuffer: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
/** @type {GPUBufferDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
usage: this.mem.loadU32(descriptorPtr + 8),
|
|
size: this.mem.loadU64(descriptorPtr + 16),
|
|
mappedAtCreation: this.mem.loadB32(descriptorPtr + 24),
|
|
};
|
|
|
|
const buffer = device.createBuffer(descriptor);
|
|
return this.buffers.create({buffer: buffer, mapping: null});
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {0|number} descriptorPtr
|
|
* @returns {number} The command encoder.
|
|
*/
|
|
wgpuDeviceCreateCommandEncoder: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
|
|
/** @type {GPUCommandEncoderDescriptor} */
|
|
let descriptor;
|
|
if (descriptor != 0) {
|
|
descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
};
|
|
}
|
|
|
|
const commandEncoder = device.createCommandEncoder(descriptor);
|
|
return this.commandEncoders.create(commandEncoder);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The compute pipeline.
|
|
*/
|
|
wgpuDeviceCreateComputePipeline: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
const computePipeline = device.createComputePipeline(this.ComputePipelineDescriptor(descriptorPtr));
|
|
return this.computePipelines.create(computePipeline);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @param {number} callbackPtr
|
|
* @param {number} userdata
|
|
*/
|
|
wgpuDeviceCreateComputePipelineAsync: async (deviceIdx, descriptorPtr, callbackPtr, userdata) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
let result;
|
|
let resultIdx;
|
|
try {
|
|
const computePipeline = await device.createComputePipelineAsync(this.ComputePipelineDescriptor(descriptorPtr));
|
|
resultIdx = this.computePipelines.create(computePipeline);
|
|
result = 0; /* Success */
|
|
// NOTE: don't callback here, any errors that happen later will then be caught by the catch here.
|
|
} catch (e) {
|
|
console.warn(e);
|
|
result = 5; /* Unknown error */
|
|
}
|
|
|
|
callback(result, resultIdx, null, userdata);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The pipeline layout.
|
|
*/
|
|
wgpuDeviceCreatePipelineLayout: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
/** @type {GPUPipelineLayoutDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
bindGroupLayouts: this.array(
|
|
this.mem.loadUint(descriptorPtr + 8),
|
|
this.mem.loadPtr(descriptorPtr + 8 + this.mem.intSize),
|
|
(ptr) => this.bindGroupLayouts.get(this.mem.loadPtr(ptr)),
|
|
4,
|
|
),
|
|
};
|
|
|
|
const pipelineLayout = device.createPipelineLayout(descriptor);
|
|
return this.pipelineLayouts.create(pipelineLayout);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The query set.
|
|
*/
|
|
wgpuDeviceCreateQuerySet: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
/** @type {GPUQuerySetDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
type: this.QueryType(descriptorPtr + 8),
|
|
count: this.mem.loadU32(descriptorPtr + 12),
|
|
};
|
|
|
|
const querySet = device.createQuerySet(descriptor);
|
|
return this.querySets.create(querySet);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The query set.
|
|
*/
|
|
wgpuDeviceCreateRenderBundleEncoder: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
/** @type {GPURenderBundleEncoderDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
colorFormats: this.array(
|
|
this.mem.loadUint(descriptorPtr + 8),
|
|
this.mem.loadPtr(descriptorPtr + 8 + this.mem.intSize),
|
|
this.TextureFormat,
|
|
4,
|
|
),
|
|
depthStencilFormat: this.enumeration("TextureFormat", descriptorPtr + 8 + this.mem.intSize + 4),
|
|
sampleCount: this.mem.loadU32(descriptorPtr + 8 + this.mem.intSize + 8),
|
|
depthReadOnly: this.mem.loadB32(descriptorPtr + 8 + this.mem.intSize + 12),
|
|
stencilReadOnly: this.mem.loadB32(descriptorPtr + 8 + this.mem.intSize + 16),
|
|
};
|
|
|
|
const renderBundleEncoder = device.createRenderBundleEncoder(descriptor);
|
|
return this.renderBundleEncoders.create(renderBundleEncoder);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The render pipeline.
|
|
*/
|
|
wgpuDeviceCreateRenderPipeline: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
const descriptor = this.RenderPipelineDescriptor(descriptorPtr);
|
|
const renderPipeline = device.createRenderPipeline(descriptor);
|
|
return this.renderPipelines.create(renderPipeline);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @param {number} callbackPtr
|
|
* @param {number} userdata
|
|
*/
|
|
wgpuDeviceCreateRenderPipelineAsync: async (deviceIdx, descriptorPtr, callbackPtr, userdata) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
let result;
|
|
let resultIdx;
|
|
try {
|
|
const renderPipeline = await device.createRenderPipelineAsync(this.RenderPipelineDescriptor(descriptorPtr));
|
|
resultIdx = this.renderPipelines.create(renderPipeline);
|
|
result = 0; /* Success */
|
|
// NOTE: don't callback here, any errors that happen later will then be caught by the catch here.
|
|
} catch (e) {
|
|
console.warn(e);
|
|
result = 5; /* Unknown error */
|
|
}
|
|
|
|
callback(result, resultIdx, null, userdata);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {0|number} descriptorPtr
|
|
* @returns {number} The sampler.
|
|
*/
|
|
wgpuDeviceCreateSampler: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
|
|
/** @type {?GPUSamplerDescriptor} */
|
|
let descriptor;
|
|
if (descriptorPtr != 0) {
|
|
descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
addressModeU: this.enumeration("AddressMode", descriptorPtr + 8),
|
|
addressModeV: this.enumeration("AddressMode", descriptorPtr + 12),
|
|
addressModeW: this.enumeration("AddressMode", descriptorPtr + 16),
|
|
magFilter: this.enumeration("FilterMode", descriptorPtr + 20),
|
|
minFilter: this.enumeration("FilterMode", descriptorPtr + 24),
|
|
mipMapFilter: this.enumeration("MipmapFilterMode", descriptorPtr + 28),
|
|
lodMinClamp: this.mem.loadF32(descriptorPtr + 32),
|
|
lodMaxClamp: this.mem.loadF32(descriptorPtr + 36),
|
|
compare: this.enumeration("CompareFunction", descriptorPtr + 40),
|
|
maxAnisotropy: this.mem.loadU16(descriptorPtr + 44),
|
|
};
|
|
}
|
|
|
|
const sampler = device.createSampler(descriptor);
|
|
return this.samplers.create(sampler);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The shader module.
|
|
*/
|
|
wgpuDeviceCreateShaderModule: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
const nextInChain = this.mem.loadPtr(descriptorPtr);
|
|
const nextInChainType = this.mem.loadI32(nextInChain + 4);
|
|
|
|
// ShaderModuleWGSLDescriptor = 0x00000006,
|
|
if (nextInChainType != 6) {
|
|
throw new TypeError(`Descriptor type should be 'ShaderModuleWGSLDescriptor', got ${nextInChainType}`);
|
|
}
|
|
|
|
/** @type {GPUShaderModuleDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
code: this.mem.loadCstring(nextInChain + 8),
|
|
compilationHints: this.array(
|
|
this.mem.loadUint(descriptorPtr + 8),
|
|
this.mem.loadPtr(descriptorPtr + 8 + this.mem.intSize),
|
|
this.ShaderModuleCompilationHint,
|
|
12,
|
|
),
|
|
};
|
|
|
|
const shaderModule = device.createShaderModule(descriptor);
|
|
return this.shaderModules.create(shaderModule);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} descriptorPtr
|
|
* @returns {number} The texture.
|
|
*/
|
|
wgpuDeviceCreateTexture: (deviceIdx, descriptorPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
/** @type {GPUTextureDescriptor} */
|
|
const descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
usage: this.mem.loadU32(descriptorPtr + 8),
|
|
dimension: this.enumeration("TextureDimension", descriptorPtr + 12),
|
|
size: this.Extent3D(descriptorPtr + 16),
|
|
format: this.enumeration("TextureFormat", descriptorPtr + 28),
|
|
mipLevelCount: this.mem.loadU32(descriptorPtr + 32),
|
|
sampleCount: this.mem.loadU32(descriptorPtr + 36),
|
|
viewFormats: this.array(
|
|
this.mem.loadUint(descriptorPtr + 40),
|
|
this.mem.loadPtr(descriptorPtr + 40 + this.mem.intSize),
|
|
(ptr) => this.enumeration("TextureFormat", ptr),
|
|
4,
|
|
),
|
|
};
|
|
|
|
const texture = device.createTexture(descriptor);
|
|
return this.textures.create(texture);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
*/
|
|
wgpuDeviceDestroy: (deviceIdx) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
device.destroy();
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} featuresPtr
|
|
* @returns {number|BigInt}
|
|
*/
|
|
wgpuDeviceEnumerateFeatures: (deviceIdx, featuresPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
return this.genericEnumerateFeatures(device.features, featuresPtr);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} limitsPtr
|
|
* @returns {boolean}
|
|
*/
|
|
wgpuDeviceGetLimits: (deviceIdx, limitsPtr) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
return this.genericGetLimits(device.limits, limitsPtr);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuDeviceGetQueue: (deviceIdx) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
return this.queues.create(device.queue);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} featureInt
|
|
* @returns {boolean}
|
|
*/
|
|
wgpuDeviceHasFeature: (deviceIdx, featureInt) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
return device.features.has(this.enums.FeatureName[featureInt]);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} callbackPtr
|
|
* @param {number} userdata
|
|
*/
|
|
wgpuDevicePopErrorScope: async (deviceIdx, callbackPtr, userdata) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
const error = await device.popErrorScope();
|
|
if (!error) {
|
|
callback(0, null, userdata);
|
|
return;
|
|
}
|
|
console.warn(error);
|
|
let status = 4;
|
|
if (error instanceof GPUValidationError) {
|
|
status = 1;
|
|
} else if (error instanceof GPUOutOfMemoryError) {
|
|
status = 2;
|
|
} else if (error instanceof GPUInternalError) {
|
|
status = 3;
|
|
}
|
|
callback(status, null, userdata);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} filterInt
|
|
*/
|
|
wgpuDevicePushErrorScope: (deviceIdx, filterInt) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
device.pushErrorScope(this.enums.ErrorFilter[filterInt]);
|
|
},
|
|
|
|
/**
|
|
* @param {number} deviceIdx
|
|
* @param {number} callbackPtr
|
|
* @param {number} userdata
|
|
*/
|
|
wgpuDeviceSetUncapturedErrorCallback: (deviceIdx, callbackPtr, userdata) => {
|
|
const device = this.devices.get(deviceIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
|
|
device.onuncapturederror = (ev) => {
|
|
console.warn(ev.error);
|
|
let status = 4;
|
|
if (error instanceof GPUValidationError) {
|
|
status = 1;
|
|
} else if (error instanceof GPUOutOfMemoryError) {
|
|
status = 2;
|
|
} else if (error instanceof GPUInternalError) {
|
|
status = 3;
|
|
}
|
|
callback(status, null, userdata);
|
|
};
|
|
},
|
|
|
|
...this.devices.interface(true),
|
|
|
|
/* ---------------------- Instance ---------------------- */
|
|
|
|
/**
|
|
* @param {number} instanceIdx
|
|
* @param {number} descriptorPtr
|
|
*/
|
|
wgpuInstanceCreateSurface: (instanceIdx, descriptorPtr) => {
|
|
this.assert(instanceIdx > 0);
|
|
this.assert(descriptorPtr != 0);
|
|
|
|
const nextInChain = this.mem.loadPtr(descriptorPtr);
|
|
const nextInChainType = this.mem.loadI32(nextInChain + 4);
|
|
|
|
// SurfaceDescriptorFromCanvasHTMLSelector = 0x00000004,
|
|
if (nextInChainType != 4) {
|
|
throw new TypeError(`Descriptor type should be 'SurfaceDescriptorFromCanvasHTMLSelector', got ${nextInChainType}`);
|
|
}
|
|
|
|
const selector = this.mem.loadCstring(nextInChain + 8);
|
|
const surface = document.querySelector(selector);
|
|
if (!surface) {
|
|
throw new Error(`Selector '${selector}' did not match any element`);
|
|
}
|
|
if (!(surface instanceof HTMLCanvasElement)) {
|
|
throw new Error('Selector matches an element that is not a canvas');
|
|
}
|
|
|
|
return this.surfaces.create(surface);
|
|
},
|
|
|
|
/**
|
|
* @param {number} instanceIdx
|
|
* @param {number} featureInt
|
|
* @returns {boolean}
|
|
*/
|
|
wgpuInstanceHasWGSLLanguageFeature: (instanceIdx, featureInt) => {
|
|
return navigator.gpu.wgslLanguageFeatures.has(this.enums.WGSLFeatureName[featureInt]);
|
|
},
|
|
|
|
/**
|
|
* @param {number} instanceIdx
|
|
*/
|
|
wgpuInstanceProcessEvents: (instanceIdx) => {
|
|
console.warn("unimplemented: wgpuInstanceProcessEvents");
|
|
},
|
|
|
|
/**
|
|
* @param {number} instanceIdx
|
|
* @param {0|number} optionsPtr
|
|
* @param {number} callbackPtr
|
|
* @param {number} userdata
|
|
*/
|
|
wgpuInstanceRequestAdapter: async (instanceIdx, optionsPtr, callbackPtr, userdata) => {
|
|
this.assert(instanceIdx > 0);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
|
|
/** @type {GPURequestAdapterOptions} */
|
|
let options;
|
|
if (optionsPtr != 0) {
|
|
options = {
|
|
powerPreference: this.enumeration("PowerPreference", optionsPtr + 8),
|
|
forceFallbackAdapter: this.mem.loadB32(optionsPtr + 16),
|
|
};
|
|
}
|
|
|
|
let adapterIdx;
|
|
try {
|
|
const adapter = await navigator.gpu.requestAdapter(options);
|
|
adapterIdx = this.adapters.create(adapter);
|
|
// NOTE: don't callback here, any errors that happen later will then be caught by the catch here.
|
|
} catch(e) {
|
|
console.warn(e);
|
|
callback(2, null, null, userdata);
|
|
}
|
|
|
|
callback(0, adapterIdx, null, userdata);
|
|
},
|
|
|
|
...this.instances.interface(false),
|
|
|
|
/* ---------------------- PipelineLayout ---------------------- */
|
|
|
|
...this.pipelineLayouts.interface(true),
|
|
|
|
/* ---------------------- QuerySet ---------------------- */
|
|
|
|
/**
|
|
* @param {number} querySetIdx
|
|
*/
|
|
wgpuQuerySetDestroy: (querySetIdx) => {
|
|
const querySet = this.querySets.get(querySetIdx);
|
|
querySet.destroy();
|
|
},
|
|
|
|
/**
|
|
* @param {number} querySetIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuQuerySetGetCount: (querySetIdx) => {
|
|
const querySet = this.querySets.get(querySetIdx);
|
|
return querySet.count;
|
|
},
|
|
|
|
/**
|
|
* @param {number} querySetIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuQuerySetGetType: (querySetIdx) => {
|
|
const querySet = this.querySets.get(querySetIdx);
|
|
return this.enums.QueryType.indexOf(querySet.type);
|
|
},
|
|
|
|
...this.querySets.interface(true),
|
|
|
|
/* ---------------------- Queue ---------------------- */
|
|
|
|
/**
|
|
* @param {number} queueIdx
|
|
* @param {number} callbackPtr
|
|
* @param {number} userdata
|
|
*/
|
|
wgpuQueueOnSubmittedWorkDone: async (queueIdx, callbackPtr, userdata) => {
|
|
const queue = this.queues.get(queueIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
let result;
|
|
try {
|
|
await queue.onSubmittedWorkDone();
|
|
result = 0;
|
|
} catch(e) {
|
|
console.warn(e);
|
|
result = 1;
|
|
}
|
|
callback(result, userdata);
|
|
},
|
|
|
|
/**
|
|
* @param {number} queueIdx
|
|
* @param {BigInt|number} commandCount
|
|
* @param {number} commandsPtr
|
|
*/
|
|
wgpuQueueSubmit: (queueIdx, commandCount, commandsPtr) => {
|
|
const queue = this.queues.get(queueIdx);
|
|
const commands = this.array(
|
|
this.unwrapBigInt(commandCount),
|
|
commandsPtr,
|
|
(ptr) => this.commandBuffers.get(this.mem.loadPtr(ptr)),
|
|
4,
|
|
);
|
|
queue.submit(commands);
|
|
},
|
|
|
|
/**
|
|
* @param {number} queueIdx
|
|
* @param {number} bufferIdx
|
|
* @param {BigInt} bufferOffset
|
|
* @param {number} dataPtr
|
|
* @param {number|BigInt} size
|
|
*/
|
|
wgpuQueueWriteBuffer: (queueIdx, bufferIdx, bufferOffset, dataPtr, size) => {
|
|
const queue = this.queues.get(queueIdx);
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
bufferOffset = this.unwrapBigInt(bufferOffset);
|
|
size = this.unwrapBigInt(size);
|
|
queue.writeBuffer(buffer.buffer, bufferOffset, this.mem.loadBytes(dataPtr, size), 0, size);
|
|
},
|
|
|
|
/**
|
|
* @param {number} queueIdx
|
|
* @param {number} destinationPtr
|
|
* @param {number} dataPtr
|
|
* @param {number|BigInt} dataSize
|
|
* @param {number} dataLayoutPtr
|
|
* @param {number} writeSizePtr
|
|
*/
|
|
wgpuQueueWriteTexture: (queueIdx, destinationPtr, dataPtr, dataSize, dataLayoutPtr, writeSizePtr) => {
|
|
const queue = this.queues.get(queueIdx);
|
|
const destination = this.ImageCopyTexture(destinationPtr);
|
|
dataSize = this.unwrapBigInt(dataSize);
|
|
const dataLayout = this.TextureDataLayout(dataLayoutPtr);
|
|
const writeSize = this.Extent3D(writeSizePtr);
|
|
queue.writeTexture(destination, this.mem.loadBytes(dataPtr, dataSize), dataLayout, writeSize);
|
|
},
|
|
|
|
...this.queues.interface(true),
|
|
|
|
/* ---------------------- RenderBundle ---------------------- */
|
|
|
|
...this.renderBundles.interface(true),
|
|
|
|
/* ---------------------- RenderBundleEncoder ---------------------- */
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} vertexCount
|
|
* @param {number} instanceCount
|
|
* @param {number} firstVertex
|
|
* @param {number} firstInstance
|
|
*/
|
|
wgpuRenderBundleEncoderDraw: (renderBundleEncoderIdx, vertexCount, instanceCount, firstVertex, firstInstance) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
renderBundleEncoder.draw(vertexCount, instanceCount, firstVertex, firstInstance);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} indexCount
|
|
* @param {number} instanceCount
|
|
* @param {number} firstIndex
|
|
* @param {number} baseVertex
|
|
* @param {number} firstInstance
|
|
*/
|
|
wgpuRenderBundleEncoderDrawIndexed: (renderBundleEncoderIdx, indexCount, instanceCount, firstIndex, baseVertex, firstInstance) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
renderBundleEncoder.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} indirectBufferIdx
|
|
* @param {BigInt} indirectOffset
|
|
*/
|
|
wgpuRenderBundleEncoderDrawIndexedIndirect: (renderBundleEncoderIdx, indirectBufferIdx, indirectOffset) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
indirectOffset = this.unwrapBigInt(indirectOffset);
|
|
const buffer = this.buffers.get(indirectBufferIdx);
|
|
renderBundleEncoder.drawIndexedIndirect(buffer.buffer, indirectOffset);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} indirectBufferIdx
|
|
* @param {BigInt} indirectOffset
|
|
*/
|
|
wgpuRenderBundleEncoderDrawIndirect: (renderBundleEncoderIdx, indirectBufferIdx, indirectOffset) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
indirectOffset = this.unwrapBigInt(indirectOffset);
|
|
const buffer = this.buffers.get(indirectBufferIdx);
|
|
renderBundleEncoder.drawIndirect(buffer.buffer, indirectOffset);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {0|number} descriptorPtr
|
|
* @returns {number}
|
|
*/
|
|
wgpuRenderBundleEncoderFinish: (renderBundleEncoderIdx, descriptorPtr) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
|
|
/** @type {?GPURenderBundleDescriptor} */
|
|
let descriptor;
|
|
if (descriptorPtr != 0) {
|
|
descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
};
|
|
}
|
|
|
|
const renderBundle = renderBundleEncoder.finish(descriptor);
|
|
return this.renderBundles.create(renderBundle);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} markerLabelPtr
|
|
*/
|
|
wgpuRenderBundleEncoderInsertDebugMarker: (renderBundleEncoderIdx, markerLabelPtr) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
this.assert(markerLabelPtr != 0);
|
|
const markerLabel = this.mem.loadCstring(markerLabelPtr);
|
|
renderBundleEncoder.insertDebugMarker(markerLabel);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
*/
|
|
wgpuRenderBundleEncoderPopDebugGroup: (renderBundleEncoderIdx) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
renderBundleEncoder.popDebugGroup();
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} groupLabelPtr
|
|
*/
|
|
wgpuRenderBundleEncoderPushDebugGroup: (renderBundleEncoderIdx, groupLabelPtr) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
this.assert(groupLabelPtr!= 0);
|
|
const groupLabel = this.mem.loadCstring(groupLabelPtr);
|
|
renderBundleEncoder.pushDebugGroup(groupLabel);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} groupIndex
|
|
* @param {0|number} groupIdx
|
|
* @param {number|BigInt} dynamicOffsetCount
|
|
* @param {number} dynamicOffsetsPtr
|
|
*/
|
|
wgpuRenderBundleEncoderSetBindGroup: (renderBundleEncoderIdx, groupIndex, groupIdx, dynamicOffsetCount, dynamicOffsetsPtr) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
|
|
let group;
|
|
if (groupIdx > 0) {
|
|
group = this.bindGroups.get(groupIdx);
|
|
}
|
|
|
|
dynamicOffsetCount = this.unwrapBigInt(dynamicOffsetCount);
|
|
const dynamicOffsets = this.array(dynamicOffsetCount, dynamicOffsetsPtr, this.mem.loadU32, 4);
|
|
|
|
renderBundleEncoder.setBindGroup(groupIndex, group, dynamicOffsets);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} bufferIdx
|
|
* @param {number} formatInt
|
|
* @param {BigInt} offset
|
|
* @param {BigInt} size
|
|
*/
|
|
wgpuRenderBundleEncoderSetIndexBuffer: (renderBundleEncoderIdx, bufferIdx, formatInt, offset, size) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
const format = this.enums.IndexFormat[formatInt];
|
|
offset = this.unwrapBigInt(offset);
|
|
size = this.unwrapBigInt(size);
|
|
renderBundleEncoder.setIndexBuffer(buffer.buffer, format, offset, size);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} pipelineIdx
|
|
*/
|
|
wgpuRenderBundleEncoderSetPipeline: (renderBundleEncoderIdx, pipelineIdx) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
const pipeline = this.renderPipelines.get(pipelineIdx);
|
|
renderBundleEncoder.setPipeline(pipeline);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderBundleEncoderIdx
|
|
* @param {number} slot
|
|
* @param {0|number} bufferIdx
|
|
* @param {BigInt} offset
|
|
* @param {BigInt} size
|
|
*/
|
|
wgpuRenderBundleEncoderSetVertexBuffer: (renderBundleEncoderIdx, slot, bufferIdx, offset, size) => {
|
|
const renderBundleEncoder = this.renderBundleEncoders.get(renderBundleEncoderIdx);
|
|
|
|
let buffer;
|
|
if (bufferIdx > 0) {
|
|
buffer = this.buffers.get(bufferIdx).buffer;
|
|
}
|
|
|
|
offset = this.unwrapBigInt(offset);
|
|
size = this.unwrapBigInt(size);
|
|
renderBundleEncoder.setVertexBuffer(slot, buffer, offset, size);
|
|
},
|
|
|
|
...this.renderBundleEncoders.interface(true),
|
|
|
|
/* ---------------------- RenderPassEncoder ---------------------- */
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} queryIndex
|
|
*/
|
|
wgpuRenderPassEncoderBeginOcclusionQuery: (renderPassEncoderIdx, queryIndex) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.beginOcclusionQuery(queryIndex);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} vertexCount
|
|
* @param {number} instanceCount
|
|
* @param {number} firstVertex
|
|
* @param {number} firstInstance
|
|
*/
|
|
wgpuRenderPassEncoderDraw: (renderPassEncoderIdx, vertexCount, instanceCount, firstVertex, firstInstance) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.draw(vertexCount, instanceCount, firstVertex, firstInstance);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} indexCount
|
|
* @param {number} instanceCount
|
|
* @param {number} firstIndex
|
|
* @param {number} baseVertex
|
|
* @param {number} firstInstance
|
|
*/
|
|
wgpuRenderPassEncoderDrawIndexed: (renderPassEncoderIdx, indexCount, instanceCount, firstIndex, baseVertex, firstInstance) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} indirectBufferIdx
|
|
* @param {BigInt} indirectOffset
|
|
*/
|
|
wgpuRenderPassEncoderDrawIndexedIndirect: (renderPassEncoderIdx, indirectBufferIdx, indirectOffset) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
const buffer = this.buffers.get(indirectBufferIdx);
|
|
indirectOffset = this.unwrapBigInt(indirectOffset);
|
|
renderPassEncoder.drawIndexedIndirect(buffer.buffer, indirectOffset);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} indirectBufferIdx
|
|
* @param {BigInt} indirectOffset
|
|
*/
|
|
wgpuRenderPassEncoderDrawIndirect: (renderPassEncoderIdx, indirectBufferIdx, indirectOffset) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
const buffer = this.buffers.get(indirectBufferIdx);
|
|
indirectOffset = this.unwrapBigInt(indirectOffset);
|
|
renderPassEncoder.drawIndirect(buffer.buffer, indirectOffset);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
*/
|
|
wgpuRenderPassEncoderEnd: (renderPassEncoderIdx) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.end();
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
*/
|
|
wgpuRenderPassEncoderEndOcclusionQuery: (renderPassEncoderIdx) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.endOcclusionQuery();
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number|BigInt} bundleCount
|
|
* @param {number} bundlesPtr
|
|
*/
|
|
wgpuRenderPassEncoderExecuteBundles: (renderPassEncoderIdx, bundleCount, bundlesPtr) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
bundleCount = this.unwrapBigInt(bundleCount);
|
|
const bundles = this.array(
|
|
bundleCount,
|
|
bundlesPtr,
|
|
(ptr) => this.renderBundles.get(this.mem.loadPtr(ptr)),
|
|
4,
|
|
);
|
|
renderPassEncoder.executeBundles(bundles);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} markerLabelPtr
|
|
*/
|
|
wgpuRenderPassEncoderInsertDebugMarker: (renderPassEncoderIdx, markerLabelPtr) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
const markerLabel = this.mem.loadCstring(markerLabelPtr);
|
|
renderPassEncoder.insertDebugMarker(markerLabel);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
*/
|
|
wgpuRenderPassEncoderPopDebugGroup: (renderPassEncoderIdx) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.popDebugGroup();
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} groupLabelPtr
|
|
*/
|
|
wgpuRenderPassEncoderPushDebugGroup: (renderPassEncoderIdx, groupLabelPtr) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
const groupLabel = this.mem.loadCstring(groupLabelPtr);
|
|
renderPassEncoder.pushDebugGroup(groupLabel);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} groupIndex
|
|
* @param {0|number} groupIdx
|
|
* @param {number|BigInt} dynamicOffsetCount
|
|
* @param {number} dynamicOffsetsPtr
|
|
*/
|
|
wgpuRenderPassEncoderSetBindGroup: (renderPassEncoderIdx, groupIndex, groupIdx, dynamicOffsetCount, dynamicOffsetsPtr) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
|
|
let group;
|
|
if (groupIdx > 0) {
|
|
group = this.bindGroups.get(groupIdx);
|
|
}
|
|
|
|
dynamicOffsetCount = this.unwrapBigInt(dynamicOffsetCount);
|
|
const dynamicOffsets = this.array(dynamicOffsetCount, dynamicOffsetsPtr, this.mem.loadU32, 4);
|
|
|
|
renderPassEncoder.setBindGroup(groupIndex, group, dynamicOffsets);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} bufferIdx
|
|
* @param {number} formatInt
|
|
* @param {BigInt} offset
|
|
* @param {BigInt} size
|
|
*/
|
|
wgpuRenderPassEncoderSetIndexBuffer: (renderPassEncoderIdx, bufferIdx, formatInt, offset, size) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
const buffer = this.buffers.get(bufferIdx);
|
|
const format = this.enums.IndexFormat[formatInt];
|
|
offset = this.unwrapBigInt(offset);
|
|
size = this.unwrapBigInt(size);
|
|
renderPassEncoder.setIndexBuffer(buffer.buffer, format, offset, size);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} pipelineIdx
|
|
*/
|
|
wgpuRenderPassEncoderSetPipeline: (renderPassEncoderIdx, pipelineIdx) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
const pipeline = this.renderPipelines.get(pipelineIdx);
|
|
renderPassEncoder.setPipeline(pipeline);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {number} width
|
|
* @param {number} height
|
|
*/
|
|
wgpuRenderPassEncoderSetScissorRect: (renderPassEncoderIdx, x, y, width, height) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.setScissorRect(x, y, width, height);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} reference
|
|
*/
|
|
wgpuRenderPassEncoderSetStencilReference: (renderPassEncoderIdx, reference) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.setStencilReference(reference);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} slot
|
|
* @param {0|number} bufferIdx
|
|
* @param {BigInt} offset
|
|
* @param {BigInt} size
|
|
*/
|
|
wgpuRenderPassEncoderSetVertexBuffer: (renderPassEncoderIdx, slot, bufferIdx, offset, size) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
|
|
let buffer;
|
|
if (bufferIdx > 0) {
|
|
buffer = this.buffers.get(bufferIdx).buffer;
|
|
}
|
|
|
|
offset = this.unwrapBigInt(offset);
|
|
size = this.unwrapBigInt(size);
|
|
renderPassEncoder.setVertexBuffer(slot, buffer, offset, size);
|
|
},
|
|
|
|
/**
|
|
* @param {number} renderPassEncoderIdx
|
|
* @param {number} x
|
|
* @param {number} y
|
|
* @param {number} width
|
|
* @param {number} height
|
|
* @param {number} minDepth
|
|
* @param {number} maxDepth
|
|
*/
|
|
wgpuRenderPassEncoderSetViewport: (renderPassEncoderIdx, x, y, width, height, minDepth, maxDepth) => {
|
|
const renderPassEncoder = this.renderPassEncoders.get(renderPassEncoderIdx);
|
|
renderPassEncoder.setViewport(x, y, width, height, minDepth, maxDepth);
|
|
},
|
|
|
|
...this.renderPassEncoders.interface(true),
|
|
|
|
/* ---------------------- RenderPipeline ---------------------- */
|
|
|
|
/**
|
|
* @param {number} renderPipelineIdx
|
|
* @param {number} groupIndex
|
|
* @returns {number}
|
|
*/
|
|
wgpuRenderPipelineGetBindGroupLayout: (renderPipelineIdx, groupIndex) => {
|
|
const renderPipeline = this.renderPipelines.get(renderPipelineIdx);
|
|
const bindGroupLayout = renderPipeline.getBindGroupLayout(groupIndex);
|
|
return this.bindGroupLayouts.create(bindGroupLayout);
|
|
},
|
|
|
|
...this.renderPipelines.interface(true),
|
|
|
|
/* ---------------------- Sampler ---------------------- */
|
|
|
|
...this.samplers.interface(true),
|
|
|
|
/* ---------------------- ShaderModule ---------------------- */
|
|
|
|
/**
|
|
* @param {number} shaderModuleIdx
|
|
* @param {number} callbackPtr
|
|
* @param {number} userdata
|
|
*/
|
|
wgpuShaderModuleGetCompilationInfo: async (shaderModuleIdx, callbackPtr, userdata) => {
|
|
const shaderModule = this.shaderModules.get(shaderModuleIdx);
|
|
const callback = this.mem.exports.__indirect_function_table.get(callbackPtr);
|
|
|
|
let status = 0;
|
|
let retAddr = 0;
|
|
|
|
const ptrsToFree = [];
|
|
|
|
try {
|
|
const compilationInfo = await shaderModule.getCompilationInfo();
|
|
|
|
const size = compilationInfo.messages.length * 72;
|
|
const addr = this.mem.exports.wgpu_alloc(size);
|
|
ptrsToFree.push(addr);
|
|
compilationInfo.messages.forEach((message, i) => {
|
|
const messageLength = new TextEncoder().encode(message.message).length;
|
|
const messageAddr = this.mem.exports.wgpu_alloc(messageLength);
|
|
ptrsToFree.push(messageAddr);
|
|
this.mem.storeString(messageAddr, message.message);
|
|
this.mem.storeI32(addr + (i * size) + 4);
|
|
|
|
this.mem.storeI32(addr + (i * size) + 8, this.enums.CompilationMessageType.indexOf(message.type));
|
|
|
|
this.mem.storeU64(addr + (i * size) + 16, message.lineNum);
|
|
this.mem.storeU64(addr + (i * size) + 24, message.linePos);
|
|
this.mem.storeU64(addr + (i * size) + 32, message.offset);
|
|
this.mem.storeU64(addr + (i * size) + 40, message.length);
|
|
|
|
// TODO: UTF16 units.
|
|
this.mem.storeU64(addr + (i * size) + 48, message.linePos);
|
|
this.mem.storeU64(addr + (i * size) + 56, message.offset);
|
|
this.mem.storeU64(addr + (i * size) + 64, message.length);
|
|
});
|
|
|
|
retAddr = this.mem.exports.wgpu_alloc(3*this.mem.intSize);
|
|
ptrsToFree.push(retAddr);
|
|
this.mem.storeUint(retAddr + this.mem.intSize, compilationInfo.messages.length);
|
|
this.mem.storeI32(retAddr + this.mem.intSize*2, addr);
|
|
} catch (e) {
|
|
console.warn(e);
|
|
status = 1;
|
|
}
|
|
|
|
callback(status, retAddr, userdata);
|
|
|
|
ptrsToFree.forEach(ptr => this.mem.exports.wgpu_free(ptr));
|
|
},
|
|
|
|
...this.shaderModules.interface(true),
|
|
|
|
/* ---------------------- Surface ---------------------- */
|
|
|
|
/**
|
|
* @param {number} surfaceIdx
|
|
* @param {number} configPtr
|
|
*/
|
|
wgpuSurfaceConfigure: (surfaceIdx, configPtr) => {
|
|
const surface = this.surfaces.get(surfaceIdx);
|
|
const context = surface.getContext('webgpu');
|
|
|
|
const widthOff = 16 + this.mem.intSize + 8;
|
|
surface.width = this.mem.loadU32(configPtr + widthOff);
|
|
surface.height = this.mem.loadU32(configPtr + widthOff + 4);
|
|
|
|
/** @type {GPUCanvasConfiguration} */
|
|
const config = {
|
|
device: this.devices.get(this.mem.loadPtr(configPtr + 4)),
|
|
format: this.enumeration("TextureFormat", configPtr + 8),
|
|
usage: this.mem.loadU32(configPtr + 12),
|
|
viewFormats: this.array(
|
|
this.mem.loadUint(configPtr + 16),
|
|
this.mem.loadPtr(configPtr + 16 + this.mem.intSize),
|
|
(ptr) => this.enumeration("TextureFormat", ptr),
|
|
4,
|
|
),
|
|
alphaMode: this.enumeration("CompositeAlphaMode", configPtr + widthOff - 4),
|
|
// // NOTE: present mode seems unused.
|
|
presentMode: this.enumeration("PresentMode", configPtr + widthOff + 4),
|
|
};
|
|
|
|
context.configure(config);
|
|
},
|
|
|
|
/**
|
|
* @param {number} surfaceIdx
|
|
* @param {number} adapterIdx
|
|
* @param {number} capabilitiesPtr
|
|
*/
|
|
wgpuSurfaceGetCapabilities: (surfaceIdx, adapterIdx, capabilitiesPtr) => {
|
|
const formatStr = navigator.gpu.getPreferredCanvasFormat();
|
|
const format = this.enums.TextureFormat.indexOf(formatStr);
|
|
|
|
this.mem.storeUint(capabilitiesPtr + this.mem.intSize, 1);
|
|
const formatAddr = this.mem.exports.wgpu_alloc(4);
|
|
this.mem.storeI32(formatAddr, format);
|
|
this.mem.storeI32(capabilitiesPtr + this.mem.intSize*2, formatAddr);
|
|
|
|
// NOTE: present modes don't seem to actually do anything in JS, we can just give back a default FIFO though.
|
|
this.mem.storeUint(capabilitiesPtr + this.mem.intSize*3, 1);
|
|
const presentModesAddr = this.mem.exports.wgpu_alloc(4);
|
|
this.mem.storeI32(presentModesAddr, 0);
|
|
this.mem.storeI32(capabilitiesPtr + this.mem.intSize*4, presentModesAddr);
|
|
|
|
// Browser seems to support opaque (1) and premultiplied (2).
|
|
this.mem.storeUint(capabilitiesPtr + this.mem.intSize*5, 2);
|
|
const alphaModesAddr = this.mem.exports.wgpu_alloc(8);
|
|
this.mem.storeI32(alphaModesAddr + 0, 1); // Opaque.
|
|
this.mem.storeI32(alphaModesAddr + 4, 2); // premultiplied.
|
|
this.mem.storeI32(capabilitiesPtr + this.mem.intSize*6, alphaModesAddr);
|
|
},
|
|
|
|
/**
|
|
* @param {number} surfaceIdx
|
|
* @param {number} texturePtr
|
|
*/
|
|
wgpuSurfaceGetCurrentTexture: (surfaceIdx, texturePtr) => {
|
|
const surface = this.surfaces.get(surfaceIdx);
|
|
const context = surface.getContext('webgpu');
|
|
const texture = context.getCurrentTexture();
|
|
|
|
const textureIdx = this.textures.create(texture);
|
|
this.mem.storeI32(texturePtr, textureIdx);
|
|
|
|
// TODO: determine suboptimal and/or status.
|
|
},
|
|
|
|
/**
|
|
* @param {number} surfaceIdx
|
|
* @param {number} texturePtr
|
|
* @returns {number}
|
|
*/
|
|
wgpuSurfaceGetPreferredFormat: (surfaceIdx, adapterIdx) => {
|
|
const formatStr = navigator.gpu.getPreferredCanvasFormat();
|
|
const format = this.enums.TextureFormat.indexOf(formatStr);
|
|
return format;
|
|
},
|
|
|
|
/**
|
|
* @param {number} surfaceIdx
|
|
*/
|
|
wgpuSurfacePresent: (surfaceIdx) => {
|
|
// NOTE: Not really anything to do here.
|
|
},
|
|
|
|
/**
|
|
* @param {number} surfaceIdx
|
|
*/
|
|
wgpuSurfaceUnconfigure: (surfaceIdx) => {
|
|
const surface = this.surfaces.get(surfaceIdx);
|
|
surface.getContext('webgpu').unconfigure();
|
|
},
|
|
|
|
...this.surfaces.interface(true),
|
|
|
|
/* ---------------------- SurfaceCapabilities ---------------------- */
|
|
|
|
/**
|
|
* @param {number} surfaceCapabilitiesPtr
|
|
*/
|
|
wgpuSurfaceCapabilitiesFreeMembers: (surfaceCapabilitiesPtr) => {
|
|
const formatsAddr = this.mem.loadI32(surfaceCapabilitiesPtr + this.mem.intSize*2);
|
|
this.mem.exports.wgpu_free(formatsAddr);
|
|
|
|
const presentModesAddr = this.mem.loadI32(surfaceCapabilitiesPtr + this.mem.intSize*4);
|
|
this.mem.exports.wgpu_free(presentModesAddr);
|
|
|
|
const alphaModesAddr = this.mem.loadI32(surfaceCapabilitiesPtr + this.mem.intSize*6);
|
|
this.mem.exports.wgpu_free(alphaModesAddr);
|
|
},
|
|
|
|
/* ---------------------- Texture ---------------------- */
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @param {0|number} descriptorPtr
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureCreateView: (textureIdx, descriptorPtr) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
|
|
/** @type {?GPUTextureViewDescriptor} */
|
|
let descriptor;
|
|
if (descriptorPtr != 0) {
|
|
descriptor = {
|
|
label: this.mem.loadCstring(descriptorPtr + 4),
|
|
format: this.enumeration("TextureFormat", descriptorPtr + 8),
|
|
dimension: this.enumeration("TextureViewDimension", descriptorPtr + 12),
|
|
baseMipLevel: this.mem.loadU32(descriptorPtr + 16),
|
|
mipLevelCount: this.mem.loadU32(descriptorPtr + 20),
|
|
baseArrayLayer: this.mem.loadU32(descriptorPtr + 24),
|
|
arrayLayerCount: this.mem.loadU32(descriptorPtr + 28),
|
|
aspect: this.enumeration("TextureAspect", descriptorPtr + 32),
|
|
};
|
|
if (descriptor.arrayLayerCount == 0xFFFFFFFF) {
|
|
descriptor.arrayLayerCount = undefined;
|
|
}
|
|
if (descriptor.mipLevelCount == 0xFFFFFFFF) {
|
|
descriptor.mipLevelCount = undefined;
|
|
}
|
|
}
|
|
|
|
const textureView = texture.createView(descriptor);
|
|
return this.textureViews.create(textureView);
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
*/
|
|
wgpuTextureDestroy: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
texture.destroy();
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureDepthOrArrayLayers: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
return texture.depthOrArrayLayers;
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureGetDimension: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
return this.enums.TextureDimension.indexOf(texture.dimension);
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureGetFormat: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
return this.enums.TextureFormat.indexOf(texture.format);
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureGetHeight: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
return texture.height;
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureGetMipLevelCount: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
return texture.mipLevelCount;
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureGetSampleCount: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
return texture.sampleCount;
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureGetUsage: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
return texture.usage;
|
|
},
|
|
|
|
/**
|
|
* @param {number} textureIdx
|
|
* @returns {number}
|
|
*/
|
|
wgpuTextureGetWidth: (textureIdx) => {
|
|
const texture = this.textures.get(textureIdx);
|
|
return texture.width;
|
|
},
|
|
|
|
...this.textures.interface(true),
|
|
|
|
/* ---------------------- TextureView ---------------------- */
|
|
|
|
...this.textureViews.interface(true),
|
|
};
|
|
}
|
|
}
|
|
|
|
/** @template T */
|
|
class WebGPUObjectManager {
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @param {WasmMemoryInterface} mem
|
|
*/
|
|
constructor(name, mem) {
|
|
this.name = name;
|
|
this.mem = mem;
|
|
|
|
this.idx = 0;
|
|
|
|
/** @type {Record<number, { references: number, object: T }>} */
|
|
this.objects = {};
|
|
}
|
|
|
|
/**
|
|
* @param {T} object
|
|
* @returns {number}
|
|
*/
|
|
create(object) {
|
|
this.objects[this.idx] = { references: 1, object };
|
|
this.idx += 1;
|
|
return this.idx;
|
|
}
|
|
|
|
/**
|
|
* @param {number} idx
|
|
* @returns {T}
|
|
*/
|
|
get(idx) {
|
|
return this.objects[idx-1].object;
|
|
}
|
|
|
|
/** @param {number} idx */
|
|
release(idx) {
|
|
this.objects[idx-1].references -= 1;
|
|
if (this.objects[idx-1].references == 0) {
|
|
delete this.objects[idx-1];
|
|
}
|
|
}
|
|
|
|
/** @param {number} idx */
|
|
reference(idx) {
|
|
this.objects[idx-1].references += 1;
|
|
}
|
|
|
|
interface(withLabelSetter = false) {
|
|
const inter = {};
|
|
inter[`wgpu${this.name}Reference`] = this.reference.bind(this);
|
|
inter[`wgpu${this.name}Release`] = this.release.bind(this);
|
|
if (withLabelSetter) {
|
|
inter[`wgpu${this.name}SetLabel`] = (idx, labelPtr) => {
|
|
const obj = this.get(idx);
|
|
obj.label = this.mem.loadCstring(labelPtr);
|
|
};
|
|
}
|
|
return inter;
|
|
}
|
|
}
|
|
|
|
window.odin = window.odin || {};
|
|
window.odin.WebGPUInterface = WebGPUInterface;
|
|
|
|
})();
|