img2num
Version:
Img2Num is a raster vectorization library - it converts images to SVGs
1,585 lines • 145 kB
JavaScript
//#region build-wasm/index.js
async function createImg2NumModule(moduleArg = {}) {
var Module = moduleArg;
var ENVIRONMENT_IS_WEB = !!globalThis.window;
var ENVIRONMENT_IS_WORKER = !!globalThis.WorkerGlobalScope;
var ENVIRONMENT_IS_NODE = globalThis.process?.versions?.node && globalThis.process?.type != "renderer";
if (ENVIRONMENT_IS_NODE) {
const { createRequire } = await import("node:module");
var require = createRequire(import.meta.url);
}
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow;
};
var _scriptName = import.meta.url;
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) return Module["locateFile"](path, scriptDirectory);
return scriptDirectory + path;
}
var readAsync, readBinary;
if (ENVIRONMENT_IS_NODE) {
var fs = require("node:fs");
if (_scriptName.startsWith("file:")) scriptDirectory = require("node:path").dirname(require("node:url").fileURLToPath(_scriptName)) + "/";
readBinary = (filename) => {
filename = isFileURI(filename) ? new URL(filename) : filename;
return fs.readFileSync(filename);
};
readAsync = async (filename, binary = true) => {
filename = isFileURI(filename) ? new URL(filename) : filename;
return fs.readFileSync(filename, binary ? void 0 : "utf8");
};
if (process.argv.length > 1) thisProgram = process.argv[1].replace(/\\/g, "/");
process.argv.slice(2);
quit_ = (status, toThrow) => {
process.exitCode = status;
throw toThrow;
};
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
try {
scriptDirectory = new URL(".", _scriptName).href;
} catch {}
if (ENVIRONMENT_IS_WORKER) readBinary = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(xhr.response);
};
readAsync = async (url) => {
var response = await fetch(url, { credentials: "same-origin" });
if (response.ok) return response.arrayBuffer();
throw new Error(response.status + " : " + response.url);
};
}
var out = console.log.bind(console);
var err = console.error.bind(console);
var wasmBinary;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) abort(text);
}
var isFileURI = (filename) => filename.startsWith("file://");
function writeStackCookie() {
var max = _emscripten_stack_get_end();
if (max == 0) max += 4;
HEAPU32[max >>> 2 >>> 0] = 34821223;
HEAPU32[max + 4 >>> 2 >>> 0] = 2310721022;
HEAPU32[0] = 1668509029;
}
function checkStackCookie() {
if (ABORT) return;
var max = _emscripten_stack_get_end();
if (max == 0) max += 4;
var cookie1 = HEAPU32[max >>> 2 >>> 0];
var cookie2 = HEAPU32[max + 4 >>> 2 >>> 0];
if (cookie1 != 34821223 || cookie2 != 2310721022) abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
if (HEAPU32[0] != 1668509029) abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
}
class EmscriptenEH {}
class CppException extends EmscriptenEH {
constructor(excPtr) {
super();
this.excPtr = excPtr;
}
}
function updateMemoryViews() {
var b = wasmMemory.buffer;
HEAP8 = new Int8Array(b);
HEAP16 = new Int16Array(b);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
HEAPU16 = new Uint16Array(b);
Module["HEAP32"] = HEAP32 = new Int32Array(b);
HEAPU32 = new Uint32Array(b);
HEAPF32 = new Float32Array(b);
HEAPF64 = new Float64Array(b);
HEAP64 = new BigInt64Array(b);
HEAPU64 = new BigUint64Array(b);
}
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) addOnPreRun(Module["preRun"].shift());
}
callRuntimeCallbacks(onPreRuns);
}
function initRuntime() {
checkStackCookie();
if (!Module["noFSInit"] && !FS.initialized) FS.init();
TTY.init();
wasmExports["sa"]();
FS.ignorePermissions = false;
}
function postRun() {
checkStackCookie();
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) addOnPostRun(Module["postRun"].shift());
}
callRuntimeCallbacks(onPostRuns);
}
function abort(what) {
Module["onAbort"]?.(what);
what = `Aborted(${what})`;
err(what);
ABORT = true;
what += ". Build with -sASSERTIONS for more info.";
throw new WebAssembly.RuntimeError(what);
}
var wasmBinaryFile;
function findWasmBinary() {
if (Module["locateFile"]) return locateFile("index.wasm");
return new URL("index.wasm", import.meta.url).href;
}
function getBinarySync(file) {
if (file == wasmBinaryFile && wasmBinary) return new Uint8Array(wasmBinary);
if (readBinary) return readBinary(file);
throw "both async and sync fetching of the wasm failed";
}
async function getWasmBinary(binaryFile) {
if (!wasmBinary) try {
var response = await readAsync(binaryFile);
return new Uint8Array(response);
} catch {}
return getBinarySync(binaryFile);
}
async function instantiateArrayBuffer(binaryFile, imports) {
try {
var binary = await getWasmBinary(binaryFile);
return await WebAssembly.instantiate(binary, imports);
} catch (reason) {
err(`failed to asynchronously prepare wasm: ${reason}`);
abort(reason);
}
}
async function instantiateAsync(binary, binaryFile, imports) {
if (!binary && !ENVIRONMENT_IS_NODE) try {
var response = fetch(binaryFile, { credentials: "same-origin" });
return await WebAssembly.instantiateStreaming(response, imports);
} catch (reason) {
err(`wasm streaming compile failed: ${reason}`);
err("falling back to ArrayBuffer instantiation");
}
return instantiateArrayBuffer(binaryFile, imports);
}
function getWasmImports() {
return { a: wasmImports };
}
async function createWasm() {
function receiveInstance(instance, module) {
wasmExports = instance.exports;
wasmExports = Asyncify.instrumentWasmExports(wasmExports);
wasmExports = applySignatureConversions(wasmExports);
assignWasmExports(wasmExports);
updateMemoryViews();
return wasmExports;
}
function receiveInstantiationResult(result) {
return receiveInstance(result["instance"]);
}
var info = getWasmImports();
if (Module["instantiateWasm"]) return new Promise((resolve, reject) => {
Module["instantiateWasm"](info, (inst, mod) => {
resolve(receiveInstance(inst, mod));
});
});
wasmBinaryFile ??= findWasmBinary();
return receiveInstantiationResult(await instantiateAsync(wasmBinary, wasmBinaryFile, info));
}
class ExitStatus {
name = "ExitStatus";
constructor(status) {
this.message = `Program terminated with exit(${status})`;
this.status = status;
}
}
var HEAP16;
var HEAP32;
var HEAP64;
var HEAP8;
var HEAPF32;
var HEAPF64;
var HEAPU16;
var HEAPU32;
var HEAPU64;
var HEAPU8;
var callRuntimeCallbacks = (callbacks) => {
while (callbacks.length > 0) callbacks.shift()(Module);
};
var onPostRuns = [];
var addOnPostRun = (cb) => onPostRuns.push(cb);
var onPreRuns = [];
var addOnPreRun = (cb) => onPreRuns.push(cb);
var dynCalls = {};
function getValue(ptr, type = "i8") {
if (type.endsWith("*")) type = "*";
switch (type) {
case "i1": return HEAP8[ptr >>> 0];
case "i8": return HEAP8[ptr >>> 0];
case "i16": return HEAP16[ptr >>> 1 >>> 0];
case "i32": return HEAP32[ptr >>> 2 >>> 0];
case "i64": return HEAP64[ptr >>> 3 >>> 0];
case "float": return HEAPF32[ptr >>> 2 >>> 0];
case "double": return HEAPF64[ptr >>> 3 >>> 0];
case "*": return HEAPU32[ptr >>> 2 >>> 0];
default: abort(`invalid type for getValue: ${type}`);
}
}
var noExitRuntime = true;
function ptrToString(ptr) {
ptr >>>= 0;
return "0x" + ptr.toString(16).padStart(8, "0");
}
function setValue(ptr, value, type = "i8") {
if (type.endsWith("*")) type = "*";
switch (type) {
case "i1":
HEAP8[ptr >>> 0] = value;
break;
case "i8":
HEAP8[ptr >>> 0] = value;
break;
case "i16":
HEAP16[ptr >>> 1 >>> 0] = value;
break;
case "i32":
HEAP32[ptr >>> 2 >>> 0] = value;
break;
case "i64":
HEAP64[ptr >>> 3 >>> 0] = BigInt(value);
break;
case "float":
HEAPF32[ptr >>> 2 >>> 0] = value;
break;
case "double":
HEAPF64[ptr >>> 3 >>> 0] = value;
break;
case "*":
HEAPU32[ptr >>> 2 >>> 0] = value;
break;
default: abort(`invalid type for setValue: ${type}`);
}
}
var stackRestore = (val) => __emscripten_stack_restore(val);
var stackSave = () => _emscripten_stack_get_current();
var exceptionCaught = [];
var uncaughtExceptionCount = 0;
var INT53_MAX = 9007199254740992;
var INT53_MIN = -9007199254740992;
var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
function ___cxa_begin_catch(ptr) {
ptr >>>= 0;
var info = new ExceptionInfo(ptr);
if (!info.get_caught()) {
info.set_caught(true);
uncaughtExceptionCount--;
}
info.set_rethrown(false);
exceptionCaught.push(info);
return ___cxa_get_exception_ptr(ptr);
}
var exceptionLast = null;
var ___cxa_end_catch = () => {
_setThrew(0, 0);
var info = exceptionCaught.pop();
___cxa_decrement_exception_refcount(info.excPtr);
exceptionLast = null;
};
class ExceptionInfo {
constructor(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24;
}
set_type(type) {
HEAPU32[this.ptr + 4 >>> 2 >>> 0] = type;
}
get_type() {
return HEAPU32[this.ptr + 4 >>> 2 >>> 0];
}
set_destructor(destructor) {
HEAPU32[this.ptr + 8 >>> 2 >>> 0] = destructor;
}
get_destructor() {
return HEAPU32[this.ptr + 8 >>> 2 >>> 0];
}
set_caught(caught) {
caught = caught ? 1 : 0;
HEAP8[this.ptr + 12 >>> 0] = caught;
}
get_caught() {
return HEAP8[this.ptr + 12 >>> 0] != 0;
}
set_rethrown(rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[this.ptr + 13 >>> 0] = rethrown;
}
get_rethrown() {
return HEAP8[this.ptr + 13 >>> 0] != 0;
}
init(type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor);
}
set_adjusted_ptr(adjustedPtr) {
HEAPU32[this.ptr + 16 >>> 2 >>> 0] = adjustedPtr;
}
get_adjusted_ptr() {
return HEAPU32[this.ptr + 16 >>> 2 >>> 0];
}
}
var setTempRet0 = (val) => __emscripten_tempret_set(val);
var findMatchingCatch = (args) => {
var thrown = exceptionLast?.excPtr;
if (!thrown) {
setTempRet0(0);
return 0;
}
var info = new ExceptionInfo(thrown);
info.set_adjusted_ptr(thrown);
var thrownType = info.get_type();
if (!thrownType) {
setTempRet0(0);
return thrown;
}
for (var caughtType of args) {
if (caughtType === 0 || caughtType === thrownType) break;
var adjusted_ptr_addr = info.ptr + 16;
if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
setTempRet0(caughtType);
return thrown;
}
}
setTempRet0(thrownType);
return thrown;
};
function ___cxa_find_matching_catch_2() {
return findMatchingCatch([]);
}
function ___cxa_find_matching_catch_3(arg0) {
arg0 >>>= 0;
return findMatchingCatch([arg0]);
}
var ___cxa_rethrow = () => {
if (!exceptionCaught.length) abort("no exception to throw");
var info = exceptionCaught.at(-1);
var ptr = info.excPtr;
info.set_rethrown(true);
info.set_caught(false);
uncaughtExceptionCount++;
___cxa_increment_exception_refcount(ptr);
exceptionLast = new CppException(ptr);
throw exceptionLast;
};
function ___cxa_throw(ptr, type, destructor) {
ptr >>>= 0;
type >>>= 0;
destructor >>>= 0;
new ExceptionInfo(ptr).init(type, destructor);
___cxa_increment_exception_refcount(ptr);
exceptionLast = new CppException(ptr);
uncaughtExceptionCount++;
throw exceptionLast;
}
var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount;
function ___resumeException(ptr) {
ptr >>>= 0;
if (!exceptionLast) exceptionLast = new CppException(ptr);
throw exceptionLast;
}
var __abort_js = () => abort("");
var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
outIdx >>>= 0;
if (!(maxBytesToWrite > 0)) return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.codePointAt(i);
if (u <= 127) {
if (outIdx >= endIdx) break;
heap[outIdx++ >>> 0] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
heap[outIdx++ >>> 0] = 192 | u >> 6;
heap[outIdx++ >>> 0] = 128 | u & 63;
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
heap[outIdx++ >>> 0] = 224 | u >> 12;
heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
heap[outIdx++ >>> 0] = 128 | u & 63;
} else {
if (outIdx + 3 >= endIdx) break;
heap[outIdx++ >>> 0] = 240 | u >> 18;
heap[outIdx++ >>> 0] = 128 | u >> 12 & 63;
heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
heap[outIdx++ >>> 0] = 128 | u & 63;
i++;
}
}
heap[outIdx >>> 0] = 0;
return outIdx - startIdx;
};
var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
var __tzset_js = function(timezone, daylight, std_name, dst_name) {
timezone >>>= 0;
daylight >>>= 0;
std_name >>>= 0;
dst_name >>>= 0;
var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
var winter = new Date(currentYear, 0, 1);
var summer = new Date(currentYear, 6, 1);
var winterOffset = winter.getTimezoneOffset();
var summerOffset = summer.getTimezoneOffset();
var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
HEAPU32[timezone >>> 2 >>> 0] = stdTimezoneOffset * 60;
HEAP32[daylight >>> 2 >>> 0] = Number(winterOffset != summerOffset);
var extractZone = (timezoneOffset) => {
var sign = timezoneOffset >= 0 ? "-" : "+";
var absOffset = Math.abs(timezoneOffset);
return `UTC${sign}${String(Math.floor(absOffset / 60)).padStart(2, "0")}${String(absOffset % 60).padStart(2, "0")}`;
};
var winterName = extractZone(winterOffset);
var summerName = extractZone(summerOffset);
if (summerOffset < winterOffset) {
stringToUTF8(winterName, std_name, 17);
stringToUTF8(summerName, dst_name, 17);
} else {
stringToUTF8(winterName, dst_name, 17);
stringToUTF8(summerName, std_name, 17);
}
};
var _emscripten_has_asyncify = () => 1;
var getHeapMax = () => 4294901760;
var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
var growMemory = (size) => {
var pages = (size - wasmMemory.buffer.byteLength + 65535) / 65536 | 0;
try {
wasmMemory.grow(pages);
updateMemoryViews();
return 1;
} catch (e) {}
};
function _emscripten_resize_heap(requestedSize) {
requestedSize >>>= 0;
var oldSize = HEAPU8.length;
var maxHeapSize = getHeapMax();
if (requestedSize > maxHeapSize) return false;
for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
if (growMemory(Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)))) return true;
}
return false;
}
var _emscripten_sleep = function(ms) {
let innerFunc = () => new Promise((resolve) => setTimeout(resolve, ms));
return Asyncify.handleAsync(innerFunc);
};
_emscripten_sleep.isAsync = true;
var lengthBytesUTF8 = (str) => {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var c = str.charCodeAt(i);
if (c <= 127) len++;
else if (c <= 2047) len += 2;
else if (c >= 55296 && c <= 57343) {
len += 4;
++i;
} else len += 3;
}
return len;
};
var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
var stringToUTF8OnStack = (str) => {
var size = lengthBytesUTF8(str) + 1;
var ret = stackAlloc(size);
stringToUTF8(str, ret, size);
return ret;
};
var UTF8Decoder = globalThis.TextDecoder && new TextDecoder();
var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => {
var maxIdx = idx + maxBytesToRead;
if (ignoreNul) return maxIdx;
while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
return idx;
};
var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => {
idx >>>= 0;
var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
var str = "";
while (idx < endPtr) {
var u0 = heapOrArray[idx++];
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = heapOrArray[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode((u0 & 31) << 6 | u1);
continue;
}
var u2 = heapOrArray[idx++] & 63;
if ((u0 & 240) == 224) u0 = (u0 & 15) << 12 | u1 << 6 | u2;
else u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
if (u0 < 65536) str += String.fromCharCode(u0);
else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
}
}
return str;
};
var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => {
ptr >>>= 0;
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : "";
};
var writeI53ToI64 = (ptr, num) => {
HEAPU32[ptr >>> 2 >>> 0] = num;
var lower = HEAPU32[ptr >>> 2 >>> 0];
HEAPU32[ptr + 4 >>> 2 >>> 0] = (num - lower) / 4294967296;
};
var stringToNewUTF8 = (str) => {
var size = lengthBytesUTF8(str) + 1;
var ret = _malloc(size);
if (ret) stringToUTF8(str, ret, size);
return ret;
};
var readI53FromI64 = (ptr) => HEAPU32[ptr >>> 2 >>> 0] + HEAP32[ptr + 4 >>> 2 >>> 0] * 4294967296;
var WebGPU = {
Internals: {
jsObjects: [],
jsObjectInsert: (ptr, jsObject) => {
ptr >>>= 0;
WebGPU.Internals.jsObjects[ptr] = jsObject;
},
bufferOnUnmaps: [],
futures: [],
futureInsert: (futureId, promise) => {
WebGPU.Internals.futures[futureId] = new Promise((resolve) => promise.finally(() => resolve(futureId)));
}
},
getJsObject: (ptr) => {
if (!ptr) return void 0;
ptr >>>= 0;
return WebGPU.Internals.jsObjects[ptr];
},
importJsAdapter: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateAdapter(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsBindGroup: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateBindGroup(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsBindGroupLayout: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateBindGroupLayout(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsBuffer: (buffer, parentPtr = 0) => {
assert(buffer.mapState === "unmapped");
var bufferPtr = _emwgpuImportBuffer(parentPtr);
WebGPU.Internals.jsObjectInsert(bufferPtr, buffer);
return bufferPtr;
},
importJsCommandBuffer: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateCommandBuffer(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsCommandEncoder: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateCommandEncoder(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsComputePassEncoder: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateComputePassEncoder(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsComputePipeline: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateComputePipeline(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsDevice: (device, parentPtr = 0) => {
var queuePtr = _emwgpuCreateQueue(parentPtr);
var devicePtr = _emwgpuCreateDevice(parentPtr, queuePtr);
WebGPU.Internals.jsObjectInsert(queuePtr, device.queue);
WebGPU.Internals.jsObjectInsert(devicePtr, device);
return devicePtr;
},
importJsExternalTexture: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateExternalTexture(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsPipelineLayout: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreatePipelineLayout(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsQuerySet: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateQuerySet(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsQueue: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateQueue(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsRenderBundle: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateRenderBundle(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsRenderBundleEncoder: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateRenderBundleEncoder(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsRenderPassEncoder: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateRenderPassEncoder(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsRenderPipeline: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateRenderPipeline(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsSampler: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateSampler(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsShaderModule: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateShaderModule(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsSurface: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateSurface(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsTexture: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateTexture(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
importJsTextureView: (obj, parentPtr = 0) => {
var ptr = _emwgpuCreateTextureView(parentPtr);
WebGPU.Internals.jsObjects[ptr] = obj;
return ptr;
},
errorCallback: (callback, type, message, userdata) => {
var sp = stackSave();
((a1, a2, a3) => dynCall_viii(callback, a1, a2, a3))(type, stringToUTF8OnStack(message), userdata);
stackRestore(sp);
},
iterateExtensions: (root, handlers) => {
for (var ptr = HEAPU32[root >>> 2 >>> 0]; ptr; ptr = HEAPU32[ptr >>> 2 >>> 0]) handlers[HEAP32[ptr + 4 >>> 2 >>> 0]](ptr);
},
setStringView: (ptr, data, length) => {
HEAPU32[ptr >>> 2 >>> 0] = data;
HEAPU32[ptr + 4 >>> 2 >>> 0] = length;
},
makeStringFromStringView: (stringViewPtr) => {
var ptr = HEAPU32[stringViewPtr >>> 2 >>> 0];
var length = HEAPU32[stringViewPtr + 4 >>> 2 >>> 0];
return UTF8ToString(ptr, length);
},
makeStringFromOptionalStringView: (stringViewPtr) => {
var ptr = HEAPU32[stringViewPtr >>> 2 >>> 0];
var length = HEAPU32[stringViewPtr + 4 >>> 2 >>> 0];
if (!ptr) {
if (length === 0) return "";
return;
}
return UTF8ToString(ptr, length);
},
makeColor: (ptr) => ({
r: HEAPF64[ptr >>> 3 >>> 0],
g: HEAPF64[ptr + 8 >>> 3 >>> 0],
b: HEAPF64[ptr + 16 >>> 3 >>> 0],
a: HEAPF64[ptr + 24 >>> 3 >>> 0]
}),
makeExtent3D: (ptr) => ({
width: HEAPU32[ptr >>> 2 >>> 0],
height: HEAPU32[ptr + 4 >>> 2 >>> 0],
depthOrArrayLayers: HEAPU32[ptr + 8 >>> 2 >>> 0]
}),
makeOrigin3D: (ptr) => ({
x: HEAPU32[ptr >>> 2 >>> 0],
y: HEAPU32[ptr + 4 >>> 2 >>> 0],
z: HEAPU32[ptr + 8 >>> 2 >>> 0]
}),
makeTexelCopyTextureInfo: (ptr) => ({
texture: WebGPU.getJsObject(HEAPU32[ptr >>> 2 >>> 0]),
mipLevel: HEAPU32[ptr + 4 >>> 2 >>> 0],
origin: WebGPU.makeOrigin3D(ptr + 8),
aspect: WebGPU.TextureAspect[HEAP32[ptr + 20 >>> 2 >>> 0]]
}),
makeTexelCopyBufferLayout: (ptr) => {
var bytesPerRow = HEAPU32[ptr + 8 >>> 2 >>> 0];
var rowsPerImage = HEAPU32[ptr + 12 >>> 2 >>> 0];
return {
offset: readI53FromI64(ptr),
bytesPerRow: bytesPerRow === 4294967295 ? void 0 : bytesPerRow,
rowsPerImage: rowsPerImage === 4294967295 ? void 0 : rowsPerImage
};
},
makeTexelCopyBufferInfo: (ptr) => {
var layoutPtr = ptr + 0;
var bufferCopyView = WebGPU.makeTexelCopyBufferLayout(layoutPtr);
bufferCopyView["buffer"] = WebGPU.getJsObject(HEAPU32[ptr + 16 >>> 2 >>> 0]);
return bufferCopyView;
},
makePassTimestampWrites: (ptr) => {
if (ptr === 0) return void 0;
return {
querySet: WebGPU.getJsObject(HEAPU32[ptr + 4 >>> 2 >>> 0]),
beginningOfPassWriteIndex: HEAPU32[ptr + 8 >>> 2 >>> 0],
endOfPassWriteIndex: HEAPU32[ptr + 12 >>> 2 >>> 0]
};
},
makePipelineConstants: (constantCount, constantsPtr) => {
if (!constantCount) return;
var constants = {};
for (var i = 0; i < constantCount; ++i) {
var entryPtr = constantsPtr + 24 * i;
var key = WebGPU.makeStringFromStringView(entryPtr + 4);
constants[key] = HEAPF64[entryPtr + 16 >>> 3 >>> 0];
}
return constants;
},
makePipelineLayout: (layoutPtr) => {
if (!layoutPtr) return "auto";
return WebGPU.getJsObject(layoutPtr);
},
makeComputeState: (ptr) => {
if (!ptr) return void 0;
return {
module: WebGPU.getJsObject(HEAPU32[ptr + 4 >>> 2 >>> 0]),
constants: WebGPU.makePipelineConstants(HEAPU32[ptr + 16 >>> 2 >>> 0], HEAPU32[ptr + 20 >>> 2 >>> 0]),
entryPoint: WebGPU.makeStringFromOptionalStringView(ptr + 8)
};
},
makeComputePipelineDesc: (descriptor) => {
return {
label: WebGPU.makeStringFromOptionalStringView(descriptor + 4),
layout: WebGPU.makePipelineLayout(HEAPU32[descriptor + 12 >>> 2 >>> 0]),
compute: WebGPU.makeComputeState(descriptor + 16)
};
},
makeRenderPipelineDesc: (descriptor) => {
function makePrimitiveState(psPtr) {
if (!psPtr) return void 0;
return {
topology: WebGPU.PrimitiveTopology[HEAP32[psPtr + 4 >>> 2 >>> 0]],
stripIndexFormat: WebGPU.IndexFormat[HEAP32[psPtr + 8 >>> 2 >>> 0]],
frontFace: WebGPU.FrontFace[HEAP32[psPtr + 12 >>> 2 >>> 0]],
cullMode: WebGPU.CullMode[HEAP32[psPtr + 16 >>> 2 >>> 0]],
unclippedDepth: !!HEAPU32[psPtr + 20 >>> 2 >>> 0]
};
}
function makeBlendComponent(bdPtr) {
if (!bdPtr) return void 0;
return {
operation: WebGPU.BlendOperation[HEAP32[bdPtr >>> 2 >>> 0]],
srcFactor: WebGPU.BlendFactor[HEAP32[bdPtr + 4 >>> 2 >>> 0]],
dstFactor: WebGPU.BlendFactor[HEAP32[bdPtr + 8 >>> 2 >>> 0]]
};
}
function makeBlendState(bsPtr) {
if (!bsPtr) return void 0;
return {
alpha: makeBlendComponent(bsPtr + 12),
color: makeBlendComponent(bsPtr + 0)
};
}
function makeColorState(csPtr) {
var format = WebGPU.TextureFormat[HEAP32[csPtr + 4 >>> 2 >>> 0]];
return format ? {
format,
blend: makeBlendState(HEAPU32[csPtr + 8 >>> 2 >>> 0]),
writeMask: HEAPU32[csPtr + 16 >>> 2 >>> 0]
} : void 0;
}
function makeColorStates(count, csArrayPtr) {
var states = [];
for (var i = 0; i < count; ++i) states.push(makeColorState(csArrayPtr + 24 * i));
return states;
}
function makeStencilStateFace(ssfPtr) {
return {
compare: WebGPU.CompareFunction[HEAP32[ssfPtr >>> 2 >>> 0]],
failOp: WebGPU.StencilOperation[HEAP32[ssfPtr + 4 >>> 2 >>> 0]],
depthFailOp: WebGPU.StencilOperation[HEAP32[ssfPtr + 8 >>> 2 >>> 0]],
passOp: WebGPU.StencilOperation[HEAP32[ssfPtr + 12 >>> 2 >>> 0]]
};
}
function makeDepthStencilState(dssPtr) {
if (!dssPtr) return void 0;
return {
format: WebGPU.TextureFormat[HEAP32[dssPtr + 4 >>> 2 >>> 0]],
depthWriteEnabled: !!HEAPU32[dssPtr + 8 >>> 2 >>> 0],
depthCompare: WebGPU.CompareFunction[HEAP32[dssPtr + 12 >>> 2 >>> 0]],
stencilFront: makeStencilStateFace(dssPtr + 16),
stencilBack: makeStencilStateFace(dssPtr + 32),
stencilReadMask: HEAPU32[dssPtr + 48 >>> 2 >>> 0],
stencilWriteMask: HEAPU32[dssPtr + 52 >>> 2 >>> 0],
depthBias: HEAP32[dssPtr + 56 >>> 2 >>> 0],
depthBiasSlopeScale: HEAPF32[dssPtr + 60 >>> 2 >>> 0],
depthBiasClamp: HEAPF32[dssPtr + 64 >>> 2 >>> 0]
};
}
function makeVertexAttribute(vaPtr) {
return {
format: WebGPU.VertexFormat[HEAP32[vaPtr + 4 >>> 2 >>> 0]],
offset: readI53FromI64(vaPtr + 8),
shaderLocation: HEAPU32[vaPtr + 16 >>> 2 >>> 0]
};
}
function makeVertexAttributes(count, vaArrayPtr) {
var vas = [];
for (var i = 0; i < count; ++i) vas.push(makeVertexAttribute(vaArrayPtr + i * 24));
return vas;
}
function makeVertexBuffer(vbPtr) {
if (!vbPtr) return void 0;
var stepMode = WebGPU.VertexStepMode[HEAP32[vbPtr + 4 >>> 2 >>> 0]];
var attributeCount = HEAPU32[vbPtr + 16 >>> 2 >>> 0];
if (!stepMode && !attributeCount) return null;
return {
arrayStride: readI53FromI64(vbPtr + 8),
stepMode,
attributes: makeVertexAttributes(attributeCount, HEAPU32[vbPtr + 20 >>> 2 >>> 0])
};
}
function makeVertexBuffers(count, vbArrayPtr) {
if (!count) return void 0;
var vbs = [];
for (var i = 0; i < count; ++i) vbs.push(makeVertexBuffer(vbArrayPtr + i * 24));
return vbs;
}
function makeVertexState(viPtr) {
if (!viPtr) return void 0;
return {
module: WebGPU.getJsObject(HEAPU32[viPtr + 4 >>> 2 >>> 0]),
constants: WebGPU.makePipelineConstants(HEAPU32[viPtr + 16 >>> 2 >>> 0], HEAPU32[viPtr + 20 >>> 2 >>> 0]),
buffers: makeVertexBuffers(HEAPU32[viPtr + 24 >>> 2 >>> 0], HEAPU32[viPtr + 28 >>> 2 >>> 0]),
entryPoint: WebGPU.makeStringFromOptionalStringView(viPtr + 8)
};
}
function makeMultisampleState(msPtr) {
if (!msPtr) return void 0;
return {
count: HEAPU32[msPtr + 4 >>> 2 >>> 0],
mask: HEAPU32[msPtr + 8 >>> 2 >>> 0],
alphaToCoverageEnabled: !!HEAPU32[msPtr + 12 >>> 2 >>> 0]
};
}
function makeFragmentState(fsPtr) {
if (!fsPtr) return void 0;
return {
module: WebGPU.getJsObject(HEAPU32[fsPtr + 4 >>> 2 >>> 0]),
constants: WebGPU.makePipelineConstants(HEAPU32[fsPtr + 16 >>> 2 >>> 0], HEAPU32[fsPtr + 20 >>> 2 >>> 0]),
targets: makeColorStates(HEAPU32[fsPtr + 24 >>> 2 >>> 0], HEAPU32[fsPtr + 28 >>> 2 >>> 0]),
entryPoint: WebGPU.makeStringFromOptionalStringView(fsPtr + 8)
};
}
return {
label: WebGPU.makeStringFromOptionalStringView(descriptor + 4),
layout: WebGPU.makePipelineLayout(HEAPU32[descriptor + 12 >>> 2 >>> 0]),
vertex: makeVertexState(descriptor + 16),
primitive: makePrimitiveState(descriptor + 48),
depthStencil: makeDepthStencilState(HEAPU32[descriptor + 72 >>> 2 >>> 0]),
multisample: makeMultisampleState(descriptor + 76),
fragment: makeFragmentState(HEAPU32[descriptor + 92 >>> 2 >>> 0])
};
},
fillLimitStruct: (limits, limitsOutPtr) => {
var nextInChainPtr = HEAPU32[limitsOutPtr >>> 2 >>> 0];
function setLimitValueU32(name, basePtr, limitOffset, fallbackValue = 0) {
var limitValue = limits[name] ?? fallbackValue;
HEAPU32[basePtr + limitOffset >>> 2 >>> 0] = limitValue;
}
function setLimitValueU64(name, basePtr, limitOffset, fallbackValue = 0) {
var limitValue = limits[name] ?? fallbackValue;
writeI53ToI64(basePtr + limitOffset, limitValue);
}
setLimitValueU32("maxTextureDimension1D", limitsOutPtr, 4);
setLimitValueU32("maxTextureDimension2D", limitsOutPtr, 8);
setLimitValueU32("maxTextureDimension3D", limitsOutPtr, 12);
setLimitValueU32("maxTextureArrayLayers", limitsOutPtr, 16);
setLimitValueU32("maxBindGroups", limitsOutPtr, 20);
setLimitValueU32("maxBindGroupsPlusVertexBuffers", limitsOutPtr, 24);
setLimitValueU32("maxBindingsPerBindGroup", limitsOutPtr, 28);
setLimitValueU32("maxDynamicUniformBuffersPerPipelineLayout", limitsOutPtr, 32);
setLimitValueU32("maxDynamicStorageBuffersPerPipelineLayout", limitsOutPtr, 36);
setLimitValueU32("maxSampledTexturesPerShaderStage", limitsOutPtr, 40);
setLimitValueU32("maxSamplersPerShaderStage", limitsOutPtr, 44);
setLimitValueU32("maxStorageBuffersPerShaderStage", limitsOutPtr, 48);
setLimitValueU32("maxStorageTexturesPerShaderStage", limitsOutPtr, 52);
setLimitValueU32("maxUniformBuffersPerShaderStage", limitsOutPtr, 56);
setLimitValueU32("minUniformBufferOffsetAlignment", limitsOutPtr, 80);
setLimitValueU32("minStorageBufferOffsetAlignment", limitsOutPtr, 84);
setLimitValueU64("maxUniformBufferBindingSize", limitsOutPtr, 64);
setLimitValueU64("maxStorageBufferBindingSize", limitsOutPtr, 72);
setLimitValueU32("maxVertexBuffers", limitsOutPtr, 88);
setLimitValueU64("maxBufferSize", limitsOutPtr, 96);
setLimitValueU32("maxVertexAttributes", limitsOutPtr, 104);
setLimitValueU32("maxVertexBufferArrayStride", limitsOutPtr, 108);
setLimitValueU32("maxInterStageShaderVariables", limitsOutPtr, 112);
setLimitValueU32("maxColorAttachments", limitsOutPtr, 116);
setLimitValueU32("maxColorAttachmentBytesPerSample", limitsOutPtr, 120);
setLimitValueU32("maxComputeWorkgroupStorageSize", limitsOutPtr, 124);
setLimitValueU32("maxComputeInvocationsPerWorkgroup", limitsOutPtr, 128);
setLimitValueU32("maxComputeWorkgroupSizeX", limitsOutPtr, 132);
setLimitValueU32("maxComputeWorkgroupSizeY", limitsOutPtr, 136);
setLimitValueU32("maxComputeWorkgroupSizeZ", limitsOutPtr, 140);
setLimitValueU32("maxComputeWorkgroupsPerDimension", limitsOutPtr, 144);
setLimitValueU32("maxImmediateSize", limitsOutPtr, 148);
if (nextInChainPtr !== 0) {
HEAP32[nextInChainPtr + 4 >>> 2 >>> 0];
var compatibilityModeLimitsPtr = nextInChainPtr;
setLimitValueU32("maxStorageBuffersInVertexStage", compatibilityModeLimitsPtr, 8, limits.maxStorageBuffersPerShaderStage);
setLimitValueU32("maxStorageBuffersInFragmentStage", compatibilityModeLimitsPtr, 16, limits.maxStorageBuffersPerShaderStage);
setLimitValueU32("maxStorageTexturesInVertexStage", compatibilityModeLimitsPtr, 12, limits.maxStorageTexturesPerShaderStage);
setLimitValueU32("maxStorageTexturesInFragmentStage", compatibilityModeLimitsPtr, 20, limits.maxStorageTexturesPerShaderStage);
}
},
fillAdapterInfoStruct: (info, infoStruct) => {
HEAPU32[infoStruct + 52 >>> 2 >>> 0] = info.subgroupMinSize;
HEAPU32[infoStruct + 56 >>> 2 >>> 0] = info.subgroupMaxSize;
var strPtr = stringToNewUTF8(info.vendor + info.architecture + info.device + info.description);
var vendorLen = lengthBytesUTF8(info.vendor);
WebGPU.setStringView(infoStruct + 4, strPtr, vendorLen);
strPtr += vendorLen;
var architectureLen = lengthBytesUTF8(info.architecture);
WebGPU.setStringView(infoStruct + 12, strPtr, architectureLen);
strPtr += architectureLen;
var deviceLen = lengthBytesUTF8(info.device);
WebGPU.setStringView(infoStruct + 20, strPtr, deviceLen);
strPtr += deviceLen;
var descriptionLen = lengthBytesUTF8(info.description);
WebGPU.setStringView(infoStruct + 28, strPtr, descriptionLen);
strPtr += descriptionLen;
HEAP32[infoStruct + 36 >>> 2 >>> 0] = 2;
var adapterType = info.isFallbackAdapter ? 3 : 4;
HEAP32[infoStruct + 40 >>> 2 >>> 0] = adapterType;
HEAPU32[infoStruct + 44 >>> 2 >>> 0] = 0;
HEAPU32[infoStruct + 48 >>> 2 >>> 0] = 0;
},
AddressMode: [
,
"clamp-to-edge",
"repeat",
"mirror-repeat"
],
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",
"src1",
"one-minus-src1",
"src1-alpha",
"one-minus-src1-alpha"
],
BlendOperation: [
,
"add",
"subtract",
"reverse-subtract",
"min",
"max"
],
BufferBindingType: [
,
,
"uniform",
"storage",
"read-only-storage"
],
BufferMapState: [
,
"unmapped",
"pending",
"mapped"
],
CompareFunction: [
,
"never",
"less",
"equal",
"less-equal",
"greater",
"not-equal",
"greater-equal",
"always"
],
CompilationInfoRequestStatus: [
,
"success",
"callback-cancelled"
],
ComponentSwizzle: [
,
"0",
"1",
"r",
"g",
"b",
"a"
],
CompositeAlphaMode: [
,
"opaque",
"premultiplied",
"unpremultiplied",
"inherit"
],
CullMode: [
,
"none",
"front",
"back"
],
ErrorFilter: [
,
"validation",
"out-of-memory",
"internal"
],
FeatureLevel: [
,
"compatibility",
"core"
],
FeatureName: {
1: "core-features-and-limits",
2: "depth-clip-control",
3: "depth32float-stencil8",
4: "texture-compression-bc",
5: "texture-compression-bc-sliced-3d",
6: "texture-compression-etc2",
7: "texture-compression-astc",
8: "texture-compression-astc-sliced-3d",
9: "timestamp-query",
10: "indirect-first-instance",
11: "shader-f16",
12: "rg11b10ufloat-renderable",
13: "bgra8unorm-storage",
14: "float32-filterable",
15: "float32-blendable",
16: "clip-distances",
17: "dual-source-blending",
18: "subgroups",
19: "texture-formats-tier1",
20: "texture-formats-tier2",
21: "primitive-index",
22: "texture-component-swizzle",
327692: "chromium-experimental-unorm16-texture-formats",
327729: "chromium-experimental-multi-draw-indirect"
},
FilterMode: [
,
"nearest",
"linear"
],
FrontFace: [
,
"ccw",
"cw"
],
IndexFormat: [
,
"uint16",
"uint32"
],
InstanceFeatureName: [
,
"timed-wait-any",
"shader-source-spirv",
"multiple-devices-per-adapter"
],
LoadOp: [
,
"load",
"clear"
],
MipmapFilterMode: [
,
"nearest",
"linear"
],
OptionalBool: ["false", "true"],
PowerPreference: [
,
"low-power",
"high-performance"
],
PredefinedColorSpace: [
,
"srgb",
"display-p3"
],
PrimitiveTopology: [
,
"point-list",
"line-list",
"line-strip",
"triangle-list",
"triangle-strip"
],
QueryType: [
,
"occlusion",
"timestamp"
],
SamplerBindingType: [
,
,
"filtering",
"non-filtering",
"comparison"
],
Status: [
,
"success",
"error"
],
StencilOperation: [
,
"keep",
"zero",
"replace",
"invert",
"increment-clamp",
"decrement-clamp",
"increment-wrap",
"decrement-wrap"
],
StorageTextureAccess: [
,
,
"write-only",
"read-only",
"read-write"
],
StoreOp: [
,
"store",
"discard"
],
SurfaceGetCurrentTextureStatus: [
,
"success-optimal",
"success-suboptimal",
"timeout",
"outdated",
"lost",
"error"
],
TextureAspect: [
,
"all",
"stencil-only",
"depth-only"
],
TextureDimension: [
,
"1d",
"2d",
"3d"
],
TextureFormat: [
,
"r8unorm",
"r8snorm",
"r8uint",
"r8sint",
"r16unorm",
"r16snorm",
"r16uint",
"r16sint",
"r16float",
"rg8unorm",
"rg8snorm",
"rg8uint",
"rg8sint",
"r32float",
"r32uint",
"r32sint",
"rg16unorm",
"rg16snorm",
"rg16uint",
"rg16sint",
"rg16float",
"rgba8unorm",
"rgba8unorm-srgb",
"rgba8snorm",
"rgba8uint",
"rgba8sint",
"bgra8unorm",
"bgra8unorm-srgb",
"rgb10a2uint",
"rgb10a2unorm",
"rg11b10ufloat",
"rgb9e5ufloat",
"rg32float",
"rg32uint",
"rg32sint",
"rgba16unorm",
"rgba16snorm",
"rgba16uint",
"rgba16sint",
"rgba16float",
"rgba32float",
"rgba32uint",
"rgba32sint",
"stencil8",
"depth16unorm",
"depth24plus",
"depth24plus-stencil8",
"depth32float",
"depth32float-stencil8",
"bc1-rgba-unorm",
"bc1-rgba-unorm-srgb",
"bc2-rgba-unorm",
"bc2-rgba-unorm-srgb",
"bc3-rgba-unorm",
"bc3-rgba-unorm-srgb",
"bc4-r-unorm",
"bc4-r-snorm",
"bc5-rg-unorm",
"bc5-rg-snorm",
"bc6h-rgb-ufloat",
"bc6h-rgb-float",
"bc7-rgba-unorm",
"bc7-rgba-unorm-srgb",
"etc2-rgb8unorm",
"etc2-rgb8unorm-srgb",
"etc2-rgb8a1unorm",
"etc2-rgb8a1unorm-srgb",
"etc2-rgba8unorm",
"etc2-rgba8unorm-srgb",
"eac-r11unorm",
"eac-r11snorm",
"eac-rg11unorm",
"eac-rg11snorm",
"astc-4x4-unorm",
"astc-4x4-unorm-srgb",
"astc-5x4-unorm",
"astc-5x4-unorm-srgb",
"astc-5x5-unorm",
"astc-5x5-unorm-srgb",
"astc-6x5-unorm",
"astc-6x5-unorm-srgb",
"astc-6x6-unorm",
"astc-6x6-unorm-srgb",
"astc-8x5-unorm",
"astc-8x5-unorm-srgb",
"astc-8x6-unorm",
"astc-8x6-unorm-srgb",
"astc-8x8-unorm",
"astc-8x8-unorm-srgb",
"astc-10x5-unorm",
"astc-10x5-unorm-srgb",
"astc-10x6-unorm",
"astc-10x6-unorm-srgb",
"astc-10x8-unorm",
"astc-10x8-unorm-srgb",
"astc-10x10-unorm",
"astc-10x10-unorm-srgb",
"astc-12x10-unorm",
"astc-12x10-unorm-srgb",
"astc-12x12-unorm",
"astc-12x12-unorm-srgb"
],
TextureSampleType: [
,
,
"float",
"unfilterable-float",
"depth",
"sint",
"uint"
],
TextureViewDimension: [
,
"1d",
"2d",
"2d-array",
"cube",
"cube-array",
"3d"
],
ToneMappingMode: [
,
"standard",
"extended"
],
VertexFormat: [
,
"uint8",
"uint8x2",
"uint8x4",
"sint8",
"sint8x2",
"sint8x4",
"unorm8",
"unorm8x2",
"unorm8x4",
"snorm8",
"snorm8x2",
"snorm8x4",
"uint16",
"uint16x2",
"uint16x4",
"sint16",
"sint16x2",
"sint16x4",
"unorm16",
"unorm16x2",
"unorm16x4",
"snorm16",
"snorm16x2",
"snorm16x4",
"float16",
"float16x2",
"float16x4",
"float32",
"float32x2",
"float32x3",
"float32x4",
"uint32",
"uint32x2",
"uint32x3",
"uint32x4",
"sint32",
"sint32x2",
"sint32x3",
"sint32x4",
"unorm10-10-10-2",
"unorm8x4-bgra"
],
VertexStepMode: [
,
"vertex",
"instance"
],
WGSLLanguageFeatureName: [
,
"readonly_and_readwrite_storage_textures",
"packed_4x8_integer_dot_product",
"unrestricted_pointer_parameters",
"pointer_composite_access",
"uniform_buffer_standard_layout",
"subgroup_id",
"texture_and_sampler_let",
"subgroup_uniformity",
"texture_formats_tier1",
"linear_indexing"
]
};
var emwgpuStringToInt_DeviceLostReason = {
undefined: 1,
unknown: 1,
destroyed: 2
};
var handleException = (e) => {
if (e instanceof ExitStatus || e == "unwind") return EXITSTATUS;
checkStackCookie();
if (e instanceof WebAssembly.RuntimeError) {
if (_emscripten_stack_get_current() <= 0) err("Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to 65536)");
}
quit_(1, e);
};
var runtimeKeepaliveCounter = 0;
var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
var _proc_exit = (code) => {
EXITSTATUS = code;
if (!keepRuntimeAlive()) {
Module["onExit"]?.(code);
ABORT = true;
}
quit_(code, new ExitStatus(code));
};
var exitJS = (status, implicit) => {
EXITSTATUS = status;
_proc_exit(status);
};
var _exit = exitJS;
var maybeExit = () => {
if (!keepRuntimeAlive()) try {
_exit(EXITSTATUS);
} catch (e) {
handleException(e);
}
};
var callUserCallback = (func) => {
if (ABORT) return;
try {
return func();
} catch (e) {
handleException(e);
} finally {
maybeExit();
}
};
function _emwgpuAdapterRequestDevice(adapterPtr, futureId, deviceLostFutureId, devicePtr, queuePtr, descriptor) {
adapterPtr >>>= 0;
futureId = bigintToI53Checked(futureId);
deviceLostFutureId = bigintToI53Checked(deviceLostFutureId);
devicePtr >>>= 0;
queuePtr >>>= 0;
descriptor >>>= 0;
var adapter = WebGPU.getJsObject(adapterPtr);
var desc = {};
if (descriptor) {
var requiredFeatureCount = HEAPU32[descriptor + 12 >>> 2 >>> 0];
if (requiredFeatureCount) {
var requiredFeaturesPtr = HEAPU32[descriptor + 16 >>> 2 >>> 0];
desc["requiredFeatures"] = Array.from(HEAPU32.subarray(requiredFeaturesPtr >>> 2 >>> 0, requiredFeaturesPtr + requiredFeatureCount * 4 >>> 2 >>> 0), (feature) => WebGPU.FeatureName[feature]);
}
var limitsPtr = HEAPU32[descriptor + 20 >>> 2 >>> 0];
if (limitsPtr) {
var nextInChainPtr = HEAPU32[limitsPtr >>> 2 >>> 0];
var requiredLimits = {};
function setLimitU32IfDefined(name, basePtr, limitOffset, ignoreIfZero = false) {
var ptr = basePtr + limitOffset;
var value = HEAPU32[ptr >>> 2 >>> 0];
if (value != 4294967295 && (!ignoreIfZero || value != 0)) requiredLimits[name] = value;
}
function setLimitU64IfDefined(name, basePtr, limitOffset) {
var ptr = basePtr + limitOffset;
var limitPart1 = HEAPU32[ptr >>> 2 >>> 0];
var limitPart2 = HEAPU32[ptr + 4 >>> 2 >>> 0];
if (limitPart1 != 4294967295 || limitPart2 != 4294967295) requiredLimits[name] = readI53FromI64(ptr);
}
setLimitU32IfDefined("maxTextureDimension1D", limitsPtr, 4);
setLimitU32IfDefined("maxTextureDimension2D", limitsPtr, 8);
setLimitU32IfDefined("maxTextureDimension3D", limitsPtr, 12);
setLimitU32IfDefined("maxTextureArrayLayers", limitsPtr, 16);
setLimitU32IfDefined("maxBindGroups", limitsPtr, 20);
setLimitU32IfDefined("maxBindGroupsPlusVertexBuffers", limitsPtr, 24);
setLimitU32IfDefined("maxBindingsPerBindGroup", limitsPtr, 28);
setLimitU32IfDefined("maxDynamicUniformBuffersPerPipelineLayout", limitsPtr, 32);
setLimitU32IfDefined("maxDynamicStorageBuffersPerPipelineLayout", limitsPtr, 36);
setLimitU32IfDefined("maxSampledTexturesPerShaderStage", limitsPtr, 40);
setLimitU32IfDefined("maxSamplersPerShaderStage", limitsPtr, 44);
setLimitU32IfDefined("maxStorageBuffersPerShaderStage", limitsPtr, 48);
setLimitU32IfDefined("maxStorageTexturesPerShaderStage", limitsPtr, 52);
setLimitU32IfDefined("maxUniformBuffersPerShaderStage", limitsPtr, 56);
setLimitU32IfDefined("minUniformBufferOffsetAlignment", limitsPtr, 80);
setLimitU32IfDefined("minStorageBufferOffsetAlignment", limitsPtr, 84);
setLimitU64IfDefined("maxUniformBufferBindingSize", limitsPtr, 64);
setLimitU64IfDefined("maxStorageBufferBindingSize", limitsPtr, 72);
setLimitU32IfDefined("maxVertexBuffers", limitsPtr, 88);
setLimitU64IfDefined("maxBufferSize", limitsPtr, 96);
setLimitU32IfDefined("maxVertexAttributes", limitsPtr, 104);
setLimitU32IfDefined("maxVertexBufferArrayStride", limitsPtr, 108);
setLimitU32IfDefined("maxInterStageShaderVariables", limitsPtr, 112);
setLimitU32IfDefined("maxColorAttachments", limitsPtr, 116);
setLimitU32IfDefined("maxColorAttachmentBytesPerSample", limitsPtr, 120);
setLimitU32IfDefined("maxComputeWorkgroupStorageSize", limitsPtr, 124);
setLimitU32IfDefined("maxComputeInvocationsPerWorkgroup", limitsPtr, 128);
setLimitU32IfDefined("maxComputeWorkgroupSizeX", limitsPtr, 132);
setLimitU32IfDefined("maxComputeWorkgroupSizeY", limitsPtr, 136);
setLimitU32IfDefined("maxComputeWorkgroupSizeZ", limitsPtr, 140);
setLimitU32IfDefined("maxComputeWorkgroupsPerDimension", limitsPtr, 144);
setLimitU32IfDefined("maxImmediateSize", limitsPtr, 148, true);
if (nextInChainPtr !== 0) {
HEAP32[nextInChainPtr + 4 >>> 2 >>> 0];
var compatibilityModeLimitsPtr = nextInChainPtr;
if ("maxStorageBuffersInVertexStage" in GPUSupportedLimits.prototype) {
setLimitU32IfDefined("maxStorageBuffersInVertexStage", compatibilityModeLimitsPtr, 8);
setLimitU32IfDefined("maxStorageTexturesInVertexStage", compatibilityModeLimitsPtr, 12);
setLimitU32IfDefined("maxStorageBuffersInFragmentStage", compatibilityModeLimitsPtr, 16);
setLimitU32IfDefined("maxStorageTexturesInFragmentStage", compatibilityModeLimitsPtr, 20);
}
}
desc["requiredLimits"] = requiredLimits;
}
var defaultQueuePtr = HEAPU32[descriptor + 24 >>> 2 >>> 0];
if (defaultQueuePtr) desc["defaultQueue"] = { label: WebGPU.makeStringFromOptionalStringView(defaultQueuePtr + 4) };
desc["label"] = WebGPU.makeStringFromOptionalStringView(descriptor + 4);
}
WebGPU.Internals.futureInsert(futureId, adapter.requestDevice(desc).then((device) => {
callUserCallback(() => {
WebGPU.Internals.jsObjectInsert(queuePtr, device.queue);
WebGPU.Internals.jsObjectInsert(devicePtr, device);
WebGPU.Internals.futureInsert(deviceLostFutureId, device.lost.then((info) => {
callUserCallback(() => {
device.onuncapturederror = (ev) => {};
var sp = stackSave();
var messagePtr = stringToUTF8OnStack(info.message);
_emwgpuOnDeviceLostCompleted(deviceLostFutureId, emwgpuStringToInt_DeviceLostReason[info.reason], messagePtr);
stackRestore(sp);
});
}));
device.onuncapturederror = (ev) => {
var type = 5;
if (ev.error instanceof GPUValidationError) type = 2;
else if (ev.error instanceof GPUOutOfMemoryError) type = 3;
else if (ev.error instanceof GPUInternalError) type = 4;
var sp = stackSave();
var messagePtr = stringToUTF8OnStack(ev.error.message);
_emwgpuOnUncapturedError(devicePtr, type, messagePtr);
stackRestore(sp);
};
_emwgpuOnRequestDeviceCompleted(futureId, 1, devicePtr, 0);
});
}, (ex) => {
callUserCallback(() => {
var sp = stackSave();
var messagePtr = stringToUTF8OnStack(ex.message);
_emwgpuOnRequestDeviceCompleted(futureId, 3, devicePtr, messagePtr);
if (deviceLostFutureId) _emwgpuOnDeviceLostCompleted(deviceLostFutureId, 4, messagePtr);
stackRestore(sp);
});
}));
}
function _emwgpuBufferDestroy(bufferPtr) {
bufferPtr >>>= 0;
var buffer = WebGPU.getJsObject(bufferPtr);
var onUnmap = WebGPU.Internals.bufferOnUnmaps[bufferPtr];
if (onUnmap) {
for (var i = 0; i < onUnmap.length; ++i) onUnmap[i]();
delete WebGPU.Internals.bufferOnUnmaps[bufferPtr];
}
buffer.destroy();
}
var warnOnce = (text) => {
warnOnce.shown ||= {};
if (!warnOnce.shown[text]) {
warnOnce.shown[text] = 1;
if (ENVIRONMENT_IS_NODE) text = "warning: " + text;
err(text);
}
};
function _emwgpuBufferGetConstMappedRange(bufferPtr, offset, size) {
bufferPtr >>>= 0;
offset >>>= 0;
size >>>= 0;
var buffer = WebGPU.getJsObject(