Files
cocos4/cocos/webgpu/webgpu_wasm.js
T
2022-10-18 10:56:26 +08:00

3680 lines
168 KiB
JavaScript

var wasmDevice = (() => {
var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
return (
function(wasmDevice) {
wasmDevice = wasmDevice || {};
var Module = typeof wasmDevice != "undefined" ? wasmDevice : {};
var readyPromiseResolve, readyPromiseReject;
Module["ready"] = new Promise(function(resolve, reject) {
readyPromiseResolve = resolve;
readyPromiseReject = reject
});
var moduleOverrides = Object.assign({}, Module);
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow
};
var ENVIRONMENT_IS_WEB = true;
var ENVIRONMENT_IS_WORKER = false;
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory)
}
return scriptDirectory + path
}
var read_, readAsync, readBinary, setWindowTitle;
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = self.location.href
} else if (typeof document != "undefined" && document.currentScript) {
scriptDirectory = document.currentScript.src
}
if (_scriptDir) {
scriptDirectory = _scriptDir
}
if (scriptDirectory.indexOf("blob:") !== 0) {
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1)
} else {
scriptDirectory = ""
} {
read_ = url => {
var xhr = new XMLHttpRequest;
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText
};
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 = (url, onload, onerror) => {
var xhr = new XMLHttpRequest;
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = () => {
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
onload(xhr.response);
return
}
onerror()
};
xhr.onerror = onerror;
xhr.send(null)
}
}
setWindowTitle = title => document.title = title
} else {}
var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.warn.bind(console);
Object.assign(Module, moduleOverrides);
moduleOverrides = null;
if (Module["arguments"]) arguments_ = Module["arguments"];
if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
if (Module["quit"]) quit_ = Module["quit"];
var POINTER_SIZE = 4;
var tempRet0 = 0;
var setTempRet0 = value => {
tempRet0 = value
};
var wasmBinary;
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
var noExitRuntime = Module["noExitRuntime"] || true;
if (typeof WebAssembly != "object") {
abort("no native wasm support detected")
}
var wasmMemory;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) {
abort(text)
}
}
var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
var endIdx = idx + maxBytesToRead;
var endPtr = idx;
while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
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
}
function UTF8ToString(ptr, maxBytesToRead) {
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""
}
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
if (!(maxBytesToWrite > 0)) return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i);
u = 65536 + ((u & 1023) << 10) | u1 & 1023
}
if (u <= 127) {
if (outIdx >= endIdx) break;
heap[outIdx++] = u
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
heap[outIdx++] = 192 | u >> 6;
heap[outIdx++] = 128 | u & 63
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
heap[outIdx++] = 224 | u >> 12;
heap[outIdx++] = 128 | u >> 6 & 63;
heap[outIdx++] = 128 | u & 63
} else {
if (outIdx + 3 >= endIdx) break;
heap[outIdx++] = 240 | u >> 18;
heap[outIdx++] = 128 | u >> 12 & 63;
heap[outIdx++] = 128 | u >> 6 & 63;
heap[outIdx++] = 128 | u & 63
}
}
heap[outIdx] = 0;
return outIdx - startIdx
}
function stringToUTF8(str, outPtr, maxBytesToWrite) {
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
}
function 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 buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
function updateGlobalBufferAndViews(buf) {
buffer = buf;
Module["HEAP8"] = HEAP8 = new Int8Array(buf);
Module["HEAP16"] = HEAP16 = new Int16Array(buf);
Module["HEAP32"] = HEAP32 = new Int32Array(buf);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
Module["HEAPF64"] = HEAPF64 = new Float64Array(buf)
}
var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
var wasmTable;
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift())
}
}
callRuntimeCallbacks(__ATPRERUN__)
}
function initRuntime() {
runtimeInitialized = true;
callRuntimeCallbacks(__ATINIT__)
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift())
}
}
callRuntimeCallbacks(__ATPOSTRUN__)
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb)
}
function addOnInit(cb) {
__ATINIT__.unshift(cb)
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb)
}
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
function addRunDependency(id) {
runDependencies++;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies)
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies)
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback()
}
}
}
function abort(what) {
{
if (Module["onAbort"]) {
Module["onAbort"](what)
}
}
what = "Aborted(" + what + ")";
err(what);
ABORT = true;
EXITSTATUS = 1;
what += ". Build with -sASSERTIONS for more info.";
var e = new WebAssembly.RuntimeError(what);
readyPromiseReject(e);
throw e
}
var dataURIPrefix = "data:application/octet-stream;base64,";
function isDataURI(filename) {
return filename.startsWith(dataURIPrefix)
}
var wasmBinaryFile;
wasmBinaryFile = "webgpu_wasm.wasm";
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile)
}
function getBinary(file) {
try {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary)
}
if (readBinary) {
return readBinary(file)
}
throw "both async and sync fetching of the wasm failed"
} catch (err) {
abort(err)
}
}
function getBinaryPromise() {
if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
if (typeof fetch == "function") {
return fetch(wasmBinaryFile, {
credentials: "same-origin"
}).then(function(response) {
if (!response["ok"]) {
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
}
return response["arrayBuffer"]()
}).catch(function() {
return getBinary(wasmBinaryFile)
})
}
}
return Promise.resolve().then(function() {
return getBinary(wasmBinaryFile)
})
}
function createWasm() {
var info = {
"a": asmLibraryArg
};
function receiveInstance(instance, module) {
var exports = instance.exports;
Module["asm"] = exports;
wasmMemory = Module["asm"]["_a"];
updateGlobalBufferAndViews(wasmMemory.buffer);
wasmTable = Module["asm"]["ab"];
addOnInit(Module["asm"]["$a"]);
removeRunDependency("wasm-instantiate")
}
addRunDependency("wasm-instantiate");
function receiveInstantiationResult(result) {
receiveInstance(result["instance"])
}
function instantiateArrayBuffer(receiver) {
return getBinaryPromise().then(function(binary) {
return WebAssembly.instantiate(binary, info)
}).then(function(instance) {
return instance
}).then(receiver, function(reason) {
err("failed to asynchronously prepare wasm: " + reason);
abort(reason)
})
}
function instantiateAsync() {
if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && typeof fetch == "function") {
return fetch(wasmBinaryFile, {
credentials: "same-origin"
}).then(function(response) {
var result = WebAssembly.instantiateStreaming(response, info);
return result.then(receiveInstantiationResult, function(reason) {
err("wasm streaming compile failed: " + reason);
err("falling back to ArrayBuffer instantiation");
return instantiateArrayBuffer(receiveInstantiationResult)
})
})
} else {
return instantiateArrayBuffer(receiveInstantiationResult)
}
}
if (Module["instantiateWasm"]) {
try {
var exports = Module["instantiateWasm"](info, receiveInstance);
return exports
} catch (e) {
err("Module.instantiateWasm callback failed with error: " + e);
return false
}
}
instantiateAsync().catch(readyPromiseReject);
return {}
}
function ExitStatus(status) {
this.name = "ExitStatus";
this.message = "Program terminated with exit(" + status + ")";
this.status = status
}
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
callbacks.shift()(Module)
}
}
function handleException(e) {
if (e instanceof ExitStatus || e == "unwind") {
return EXITSTATUS
}
quit_(1, e)
}
var structRegistrations = {};
function runDestructors(destructors) {
while (destructors.length) {
var ptr = destructors.pop();
var del = destructors.pop();
del(ptr)
}
}
function simpleReadValueFromPointer(pointer) {
return this["fromWireType"](HEAP32[pointer >> 2])
}
var awaitingDependencies = {};
var registeredTypes = {};
var typeDependencies = {};
var char_0 = 48;
var char_9 = 57;
function makeLegalFunctionName(name) {
if (undefined === name) {
return "_unknown"
}
name = name.replace(/[^a-zA-Z0-9_]/g, "$");
var f = name.charCodeAt(0);
if (f >= char_0 && f <= char_9) {
return "_" + name
}
return name
}
function createNamedFunction(name, body) {
name = makeLegalFunctionName(name);
return new Function("body", "return function " + name + "() {\n" + ' "use strict";' + " return body.apply(this, arguments);\n" + "};\n")(body)
}
function extendError(baseErrorType, errorName) {
var errorClass = createNamedFunction(errorName, function(message) {
this.name = errorName;
this.message = message;
var stack = new Error(message).stack;
if (stack !== undefined) {
this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "")
}
});
errorClass.prototype = Object.create(baseErrorType.prototype);
errorClass.prototype.constructor = errorClass;
errorClass.prototype.toString = function() {
if (this.message === undefined) {
return this.name
} else {
return this.name + ": " + this.message
}
};
return errorClass
}
var InternalError = undefined;
function throwInternalError(message) {
throw new InternalError(message)
}
function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
myTypes.forEach(function(type) {
typeDependencies[type] = dependentTypes
});
function onComplete(typeConverters) {
var myTypeConverters = getTypeConverters(typeConverters);
if (myTypeConverters.length !== myTypes.length) {
throwInternalError("Mismatched type converter count")
}
for (var i = 0; i < myTypes.length; ++i) {
registerType(myTypes[i], myTypeConverters[i])
}
}
var typeConverters = new Array(dependentTypes.length);
var unregisteredTypes = [];
var registered = 0;
dependentTypes.forEach((dt, i) => {
if (registeredTypes.hasOwnProperty(dt)) {
typeConverters[i] = registeredTypes[dt]
} else {
unregisteredTypes.push(dt);
if (!awaitingDependencies.hasOwnProperty(dt)) {
awaitingDependencies[dt] = []
}
awaitingDependencies[dt].push(() => {
typeConverters[i] = registeredTypes[dt];
++registered;
if (registered === unregisteredTypes.length) {
onComplete(typeConverters)
}
})
}
});
if (0 === unregisteredTypes.length) {
onComplete(typeConverters)
}
}
function __embind_finalize_value_object(structType) {
var reg = structRegistrations[structType];
delete structRegistrations[structType];
var rawConstructor = reg.rawConstructor;
var rawDestructor = reg.rawDestructor;
var fieldRecords = reg.fields;
var fieldTypes = fieldRecords.map(field => field.getterReturnType).concat(fieldRecords.map(field => field.setterArgumentType));
whenDependentTypesAreResolved([structType], fieldTypes, fieldTypes => {
var fields = {};
fieldRecords.forEach((field, i) => {
var fieldName = field.fieldName;
var getterReturnType = fieldTypes[i];
var getter = field.getter;
var getterContext = field.getterContext;
var setterArgumentType = fieldTypes[i + fieldRecords.length];
var setter = field.setter;
var setterContext = field.setterContext;
fields[fieldName] = {
read: ptr => {
return getterReturnType["fromWireType"](getter(getterContext, ptr))
},
write: (ptr, o) => {
var destructors = [];
setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o));
runDestructors(destructors)
}
}
});
return [{
name: reg.name,
"fromWireType": function(ptr) {
var rv = {};
for (var i in fields) {
rv[i] = fields[i].read(ptr)
}
rawDestructor(ptr);
return rv
},
"toWireType": function(destructors, o) {
for (var fieldName in fields) {
if (!(fieldName in o)) {
throw new TypeError('Missing field: "' + fieldName + '"')
}
}
var ptr = rawConstructor();
for (fieldName in fields) {
fields[fieldName].write(ptr, o[fieldName])
}
if (destructors !== null) {
destructors.push(rawDestructor, ptr)
}
return ptr
},
"argPackAdvance": 8,
"readValueFromPointer": simpleReadValueFromPointer,
destructorFunction: rawDestructor
}]
})
}
function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {}
function getShiftFromSize(size) {
switch (size) {
case 1:
return 0;
case 2:
return 1;
case 4:
return 2;
case 8:
return 3;
default:
throw new TypeError("Unknown type size: " + size)
}
}
function embind_init_charCodes() {
var codes = new Array(256);
for (var i = 0; i < 256; ++i) {
codes[i] = String.fromCharCode(i)
}
embind_charCodes = codes
}
var embind_charCodes = undefined;
function readLatin1String(ptr) {
var ret = "";
var c = ptr;
while (HEAPU8[c]) {
ret += embind_charCodes[HEAPU8[c++]]
}
return ret
}
var BindingError = undefined;
function throwBindingError(message) {
throw new BindingError(message)
}
function registerType(rawType, registeredInstance, options = {}) {
if (!("argPackAdvance" in registeredInstance)) {
throw new TypeError("registerType registeredInstance requires argPackAdvance")
}
var name = registeredInstance.name;
if (!rawType) {
throwBindingError('type "' + name + '" must have a positive integer typeid pointer')
}
if (registeredTypes.hasOwnProperty(rawType)) {
if (options.ignoreDuplicateRegistrations) {
return
} else {
throwBindingError("Cannot register type '" + name + "' twice")
}
}
registeredTypes[rawType] = registeredInstance;
delete typeDependencies[rawType];
if (awaitingDependencies.hasOwnProperty(rawType)) {
var callbacks = awaitingDependencies[rawType];
delete awaitingDependencies[rawType];
callbacks.forEach(cb => cb())
}
}
function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
var shift = getShiftFromSize(size);
name = readLatin1String(name);
registerType(rawType, {
name: name,
"fromWireType": function(wt) {
return !!wt
},
"toWireType": function(destructors, o) {
return o ? trueValue : falseValue
},
"argPackAdvance": 8,
"readValueFromPointer": function(pointer) {
var heap;
if (size === 1) {
heap = HEAP8
} else if (size === 2) {
heap = HEAP16
} else if (size === 4) {
heap = HEAP32
} else {
throw new TypeError("Unknown boolean type size: " + name)
}
return this["fromWireType"](heap[pointer >> shift])
},
destructorFunction: null
})
}
function ClassHandle_isAliasOf(other) {
if (!(this instanceof ClassHandle)) {
return false
}
if (!(other instanceof ClassHandle)) {
return false
}
var leftClass = this.$$.ptrType.registeredClass;
var left = this.$$.ptr;
var rightClass = other.$$.ptrType.registeredClass;
var right = other.$$.ptr;
while (leftClass.baseClass) {
left = leftClass.upcast(left);
leftClass = leftClass.baseClass
}
while (rightClass.baseClass) {
right = rightClass.upcast(right);
rightClass = rightClass.baseClass
}
return leftClass === rightClass && left === right
}
function shallowCopyInternalPointer(o) {
return {
count: o.count,
deleteScheduled: o.deleteScheduled,
preservePointerOnDelete: o.preservePointerOnDelete,
ptr: o.ptr,
ptrType: o.ptrType,
smartPtr: o.smartPtr,
smartPtrType: o.smartPtrType
}
}
function throwInstanceAlreadyDeleted(obj) {
function getInstanceTypeName(handle) {
return handle.$$.ptrType.registeredClass.name
}
throwBindingError(getInstanceTypeName(obj) + " instance already deleted")
}
var finalizationRegistry = false;
function detachFinalizer(handle) {}
function runDestructor($$) {
if ($$.smartPtr) {
$$.smartPtrType.rawDestructor($$.smartPtr)
} else {
$$.ptrType.registeredClass.rawDestructor($$.ptr)
}
}
function releaseClassHandle($$) {
$$.count.value -= 1;
var toDelete = 0 === $$.count.value;
if (toDelete) {
runDestructor($$)
}
}
function downcastPointer(ptr, ptrClass, desiredClass) {
if (ptrClass === desiredClass) {
return ptr
}
if (undefined === desiredClass.baseClass) {
return null
}
var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
if (rv === null) {
return null
}
return desiredClass.downcast(rv)
}
var registeredPointers = {};
function getInheritedInstanceCount() {
return Object.keys(registeredInstances).length
}
function getLiveInheritedInstances() {
var rv = [];
for (var k in registeredInstances) {
if (registeredInstances.hasOwnProperty(k)) {
rv.push(registeredInstances[k])
}
}
return rv
}
var deletionQueue = [];
function flushPendingDeletes() {
while (deletionQueue.length) {
var obj = deletionQueue.pop();
obj.$$.deleteScheduled = false;
obj["delete"]()
}
}
var delayFunction = undefined;
function setDelayFunction(fn) {
delayFunction = fn;
if (deletionQueue.length && delayFunction) {
delayFunction(flushPendingDeletes)
}
}
function init_embind() {
Module["getInheritedInstanceCount"] = getInheritedInstanceCount;
Module["getLiveInheritedInstances"] = getLiveInheritedInstances;
Module["flushPendingDeletes"] = flushPendingDeletes;
Module["setDelayFunction"] = setDelayFunction
}
var registeredInstances = {};
function getBasestPointer(class_, ptr) {
if (ptr === undefined) {
throwBindingError("ptr should not be undefined")
}
while (class_.baseClass) {
ptr = class_.upcast(ptr);
class_ = class_.baseClass
}
return ptr
}
function getInheritedInstance(class_, ptr) {
ptr = getBasestPointer(class_, ptr);
return registeredInstances[ptr]
}
function makeClassHandle(prototype, record) {
if (!record.ptrType || !record.ptr) {
throwInternalError("makeClassHandle requires ptr and ptrType")
}
var hasSmartPtrType = !!record.smartPtrType;
var hasSmartPtr = !!record.smartPtr;
if (hasSmartPtrType !== hasSmartPtr) {
throwInternalError("Both smartPtrType and smartPtr must be specified")
}
record.count = {
value: 1
};
return attachFinalizer(Object.create(prototype, {
$$: {
value: record
}
}))
}
function RegisteredPointer_fromWireType(ptr) {
var rawPointer = this.getPointee(ptr);
if (!rawPointer) {
this.destructor(ptr);
return null
}
var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
if (undefined !== registeredInstance) {
if (0 === registeredInstance.$$.count.value) {
registeredInstance.$$.ptr = rawPointer;
registeredInstance.$$.smartPtr = ptr;
return registeredInstance["clone"]()
} else {
var rv = registeredInstance["clone"]();
this.destructor(ptr);
return rv
}
}
function makeDefaultHandle() {
if (this.isSmartPointer) {
return makeClassHandle(this.registeredClass.instancePrototype, {
ptrType: this.pointeeType,
ptr: rawPointer,
smartPtrType: this,
smartPtr: ptr
})
} else {
return makeClassHandle(this.registeredClass.instancePrototype, {
ptrType: this,
ptr: ptr
})
}
}
var actualType = this.registeredClass.getActualType(rawPointer);
var registeredPointerRecord = registeredPointers[actualType];
if (!registeredPointerRecord) {
return makeDefaultHandle.call(this)
}
var toType;
if (this.isConst) {
toType = registeredPointerRecord.constPointerType
} else {
toType = registeredPointerRecord.pointerType
}
var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
if (dp === null) {
return makeDefaultHandle.call(this)
}
if (this.isSmartPointer) {
return makeClassHandle(toType.registeredClass.instancePrototype, {
ptrType: toType,
ptr: dp,
smartPtrType: this,
smartPtr: ptr
})
} else {
return makeClassHandle(toType.registeredClass.instancePrototype, {
ptrType: toType,
ptr: dp
})
}
}
function attachFinalizer(handle) {
if ("undefined" === typeof FinalizationRegistry) {
attachFinalizer = handle => handle;
return handle
}
finalizationRegistry = new FinalizationRegistry(info => {
releaseClassHandle(info.$$)
});
attachFinalizer = handle => {
var $$ = handle.$$;
var hasSmartPtr = !!$$.smartPtr;
if (hasSmartPtr) {
var info = {
$$: $$
};
finalizationRegistry.register(handle, info, handle)
}
return handle
};
detachFinalizer = handle => finalizationRegistry.unregister(handle);
return attachFinalizer(handle)
}
function ClassHandle_clone() {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this)
}
if (this.$$.preservePointerOnDelete) {
this.$$.count.value += 1;
return this
} else {
var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), {
$$: {
value: shallowCopyInternalPointer(this.$$)
}
}));
clone.$$.count.value += 1;
clone.$$.deleteScheduled = false;
return clone
}
}
function ClassHandle_delete() {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this)
}
if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
throwBindingError("Object already scheduled for deletion")
}
detachFinalizer(this);
releaseClassHandle(this.$$);
if (!this.$$.preservePointerOnDelete) {
this.$$.smartPtr = undefined;
this.$$.ptr = undefined
}
}
function ClassHandle_isDeleted() {
return !this.$$.ptr
}
function ClassHandle_deleteLater() {
if (!this.$$.ptr) {
throwInstanceAlreadyDeleted(this)
}
if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
throwBindingError("Object already scheduled for deletion")
}
deletionQueue.push(this);
if (deletionQueue.length === 1 && delayFunction) {
delayFunction(flushPendingDeletes)
}
this.$$.deleteScheduled = true;
return this
}
function init_ClassHandle() {
ClassHandle.prototype["isAliasOf"] = ClassHandle_isAliasOf;
ClassHandle.prototype["clone"] = ClassHandle_clone;
ClassHandle.prototype["delete"] = ClassHandle_delete;
ClassHandle.prototype["isDeleted"] = ClassHandle_isDeleted;
ClassHandle.prototype["deleteLater"] = ClassHandle_deleteLater
}
function ClassHandle() {}
function ensureOverloadTable(proto, methodName, humanName) {
if (undefined === proto[methodName].overloadTable) {
var prevFunc = proto[methodName];
proto[methodName] = function() {
if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!")
}
return proto[methodName].overloadTable[arguments.length].apply(this, arguments)
};
proto[methodName].overloadTable = [];
proto[methodName].overloadTable[prevFunc.argCount] = prevFunc
}
}
function exposePublicSymbol(name, value, numArguments) {
if (Module.hasOwnProperty(name)) {
if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {
throwBindingError("Cannot register public name '" + name + "' twice")
}
ensureOverloadTable(Module, name, name);
if (Module.hasOwnProperty(numArguments)) {
throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!")
}
Module[name].overloadTable[numArguments] = value
} else {
Module[name] = value;
if (undefined !== numArguments) {
Module[name].numArguments = numArguments
}
}
}
function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
this.name = name;
this.constructor = constructor;
this.instancePrototype = instancePrototype;
this.rawDestructor = rawDestructor;
this.baseClass = baseClass;
this.getActualType = getActualType;
this.upcast = upcast;
this.downcast = downcast;
this.pureVirtualFunctions = []
}
function upcastPointer(ptr, ptrClass, desiredClass) {
while (ptrClass !== desiredClass) {
if (!ptrClass.upcast) {
throwBindingError("Expected null or instance of " + desiredClass.name + ", got an instance of " + ptrClass.name)
}
ptr = ptrClass.upcast(ptr);
ptrClass = ptrClass.baseClass
}
return ptr
}
function constNoSmartPtrRawPointerToWireType(destructors, handle) {
if (handle === null) {
if (this.isReference) {
throwBindingError("null is not a valid " + this.name)
}
return 0
}
if (!handle.$$) {
throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name)
}
if (!handle.$$.ptr) {
throwBindingError("Cannot pass deleted object as a pointer of type " + this.name)
}
var handleClass = handle.$$.ptrType.registeredClass;
var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
return ptr
}
function genericPointerToWireType(destructors, handle) {
var ptr;
if (handle === null) {
if (this.isReference) {
throwBindingError("null is not a valid " + this.name)
}
if (this.isSmartPointer) {
ptr = this.rawConstructor();
if (destructors !== null) {
destructors.push(this.rawDestructor, ptr)
}
return ptr
} else {
return 0
}
}
if (!handle.$$) {
throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name)
}
if (!handle.$$.ptr) {
throwBindingError("Cannot pass deleted object as a pointer of type " + this.name)
}
if (!this.isConst && handle.$$.ptrType.isConst) {
throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name)
}
var handleClass = handle.$$.ptrType.registeredClass;
ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
if (this.isSmartPointer) {
if (undefined === handle.$$.smartPtr) {
throwBindingError("Passing raw pointer to smart pointer is illegal")
}
switch (this.sharingPolicy) {
case 0:
if (handle.$$.smartPtrType === this) {
ptr = handle.$$.smartPtr
} else {
throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name)
}
break;
case 1:
ptr = handle.$$.smartPtr;
break;
case 2:
if (handle.$$.smartPtrType === this) {
ptr = handle.$$.smartPtr
} else {
var clonedHandle = handle["clone"]();
ptr = this.rawShare(ptr, Emval.toHandle(function() {
clonedHandle["delete"]()
}));
if (destructors !== null) {
destructors.push(this.rawDestructor, ptr)
}
}
break;
default:
throwBindingError("Unsupporting sharing policy")
}
}
return ptr
}
function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
if (handle === null) {
if (this.isReference) {
throwBindingError("null is not a valid " + this.name)
}
return 0
}
if (!handle.$$) {
throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name)
}
if (!handle.$$.ptr) {
throwBindingError("Cannot pass deleted object as a pointer of type " + this.name)
}
if (handle.$$.ptrType.isConst) {
throwBindingError("Cannot convert argument of type " + handle.$$.ptrType.name + " to parameter type " + this.name)
}
var handleClass = handle.$$.ptrType.registeredClass;
var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
return ptr
}
function RegisteredPointer_getPointee(ptr) {
if (this.rawGetPointee) {
ptr = this.rawGetPointee(ptr)
}
return ptr
}
function RegisteredPointer_destructor(ptr) {
if (this.rawDestructor) {
this.rawDestructor(ptr)
}
}
function RegisteredPointer_deleteObject(handle) {
if (handle !== null) {
handle["delete"]()
}
}
function init_RegisteredPointer() {
RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;
RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;
RegisteredPointer.prototype["argPackAdvance"] = 8;
RegisteredPointer.prototype["readValueFromPointer"] = simpleReadValueFromPointer;
RegisteredPointer.prototype["deleteObject"] = RegisteredPointer_deleteObject;
RegisteredPointer.prototype["fromWireType"] = RegisteredPointer_fromWireType
}
function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
this.name = name;
this.registeredClass = registeredClass;
this.isReference = isReference;
this.isConst = isConst;
this.isSmartPointer = isSmartPointer;
this.pointeeType = pointeeType;
this.sharingPolicy = sharingPolicy;
this.rawGetPointee = rawGetPointee;
this.rawConstructor = rawConstructor;
this.rawShare = rawShare;
this.rawDestructor = rawDestructor;
if (!isSmartPointer && registeredClass.baseClass === undefined) {
if (isConst) {
this["toWireType"] = constNoSmartPtrRawPointerToWireType;
this.destructorFunction = null
} else {
this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType;
this.destructorFunction = null
}
} else {
this["toWireType"] = genericPointerToWireType
}
}
function replacePublicSymbol(name, value, numArguments) {
if (!Module.hasOwnProperty(name)) {
throwInternalError("Replacing nonexistant public symbol")
}
if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
Module[name].overloadTable[numArguments] = value
} else {
Module[name] = value;
Module[name].argCount = numArguments
}
}
function dynCallLegacy(sig, ptr, args) {
var f = Module["dynCall_" + sig];
return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr)
}
var wasmTableMirror = [];
function getWasmTableEntry(funcPtr) {
var func = wasmTableMirror[funcPtr];
if (!func) {
if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr)
}
return func
}
function dynCall(sig, ptr, args) {
if (sig.includes("j")) {
return dynCallLegacy(sig, ptr, args)
}
var rtn = getWasmTableEntry(ptr).apply(null, args);
return rtn
}
function getDynCaller(sig, ptr) {
var argCache = [];
return function() {
argCache.length = 0;
Object.assign(argCache, arguments);
return dynCall(sig, ptr, argCache)
}
}
function embind__requireFunction(signature, rawFunction) {
signature = readLatin1String(signature);
function makeDynCaller() {
if (signature.includes("j")) {
return getDynCaller(signature, rawFunction)
}
return getWasmTableEntry(rawFunction)
}
var fp = makeDynCaller();
if (typeof fp != "function") {
throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction)
}
return fp
}
var UnboundTypeError = undefined;
function getTypeName(type) {
var ptr = ___getTypeName(type);
var rv = readLatin1String(ptr);
_free(ptr);
return rv
}
function throwUnboundTypeError(message, types) {
var unboundTypes = [];
var seen = {};
function visit(type) {
if (seen[type]) {
return
}
if (registeredTypes[type]) {
return
}
if (typeDependencies[type]) {
typeDependencies[type].forEach(visit);
return
}
unboundTypes.push(type);
seen[type] = true
}
types.forEach(visit);
throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([", "]))
}
function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {
name = readLatin1String(name);
getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
if (upcast) {
upcast = embind__requireFunction(upcastSignature, upcast)
}
if (downcast) {
downcast = embind__requireFunction(downcastSignature, downcast)
}
rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
var legalFunctionName = makeLegalFunctionName(name);
exposePublicSymbol(legalFunctionName, function() {
throwUnboundTypeError("Cannot construct " + name + " due to unbound types", [baseClassRawType])
});
whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], function(base) {
base = base[0];
var baseClass;
var basePrototype;
if (baseClassRawType) {
baseClass = base.registeredClass;
basePrototype = baseClass.instancePrototype
} else {
basePrototype = ClassHandle.prototype
}
var constructor = createNamedFunction(legalFunctionName, function() {
if (Object.getPrototypeOf(this) !== instancePrototype) {
throw new BindingError("Use 'new' to construct " + name)
}
if (undefined === registeredClass.constructor_body) {
throw new BindingError(name + " has no accessible constructor")
}
var body = registeredClass.constructor_body[arguments.length];
if (undefined === body) {
throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!")
}
return body.apply(this, arguments)
});
var instancePrototype = Object.create(basePrototype, {
constructor: {
value: constructor
}
});
constructor.prototype = instancePrototype;
var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false);
var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false);
registeredPointers[rawType] = {
pointerType: pointerConverter,
constPointerType: constPointerConverter
};
replacePublicSymbol(legalFunctionName, constructor);
return [referenceConverter, pointerConverter, constPointerConverter]
})
}
function new_(constructor, argumentList) {
if (!(constructor instanceof Function)) {
throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function")
}
var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() {});
dummy.prototype = constructor.prototype;
var obj = new dummy;
var r = constructor.apply(obj, argumentList);
return r instanceof Object ? r : obj
}
function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {
var argCount = argTypes.length;
if (argCount < 2) {
throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")
}
var isClassMethodFunc = argTypes[1] !== null && classType !== null;
var needsDestructorStack = false;
for (var i = 1; i < argTypes.length; ++i) {
if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
needsDestructorStack = true;
break
}
}
var returns = argTypes[0].name !== "void";
var argsList = "";
var argsListWired = "";
for (var i = 0; i < argCount - 2; ++i) {
argsList += (i !== 0 ? ", " : "") + "arg" + i;
argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired"
}
var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n";
if (needsDestructorStack) {
invokerFnBody += "var destructors = [];\n"
}
var dtorStack = needsDestructorStack ? "destructors" : "null";
var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
if (isClassMethodFunc) {
invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n"
}
for (var i = 0; i < argCount - 2; ++i) {
invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
args1.push("argType" + i);
args2.push(argTypes[i + 2])
}
if (isClassMethodFunc) {
argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired
}
invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n";
if (needsDestructorStack) {
invokerFnBody += "runDestructors(destructors);\n"
} else {
for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
if (argTypes[i].destructorFunction !== null) {
invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
args1.push(paramName + "_dtor");
args2.push(argTypes[i].destructorFunction)
}
}
}
if (returns) {
invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n"
} else {}
invokerFnBody += "}\n";
args1.push(invokerFnBody);
var invokerFunction = new_(Function, args1).apply(null, args2);
return invokerFunction
}
function heap32VectorToArray(count, firstElement) {
var array = [];
for (var i = 0; i < count; i++) {
array.push(HEAPU32[firstElement + i * 4 >> 2])
}
return array
}
function __embind_register_class_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, fn) {
var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
methodName = readLatin1String(methodName);
rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
whenDependentTypesAreResolved([], [rawClassType], function(classType) {
classType = classType[0];
var humanName = classType.name + "." + methodName;
function unboundTypesHandler() {
throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes)
}
if (methodName.startsWith("@@")) {
methodName = Symbol[methodName.substring(2)]
}
var proto = classType.registeredClass.constructor;
if (undefined === proto[methodName]) {
unboundTypesHandler.argCount = argCount - 1;
proto[methodName] = unboundTypesHandler
} else {
ensureOverloadTable(proto, methodName, humanName);
proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler
}
whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) {
var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
var func = craftInvokerFunction(humanName, invokerArgsArray, null, rawInvoker, fn);
if (undefined === proto[methodName].overloadTable) {
func.argCount = argCount - 1;
proto[methodName] = func
} else {
proto[methodName].overloadTable[argCount - 1] = func
}
return []
});
return []
})
}
function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
assert(argCount > 0);
var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
invoker = embind__requireFunction(invokerSignature, invoker);
whenDependentTypesAreResolved([], [rawClassType], function(classType) {
classType = classType[0];
var humanName = "constructor " + classType.name;
if (undefined === classType.registeredClass.constructor_body) {
classType.registeredClass.constructor_body = []
}
if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) {
throw new BindingError("Cannot register multiple constructors with identical number of parameters (" + (argCount - 1) + ") for class '" + classType.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!")
}
classType.registeredClass.constructor_body[argCount - 1] = () => {
throwUnboundTypeError("Cannot construct " + classType.name + " due to unbound types", rawArgTypes)
};
whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) {
argTypes.splice(1, 0, null);
classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
return []
});
return []
})
}
function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual) {
var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
methodName = readLatin1String(methodName);
rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
whenDependentTypesAreResolved([], [rawClassType], function(classType) {
classType = classType[0];
var humanName = classType.name + "." + methodName;
if (methodName.startsWith("@@")) {
methodName = Symbol[methodName.substring(2)]
}
if (isPureVirtual) {
classType.registeredClass.pureVirtualFunctions.push(methodName)
}
function unboundTypesHandler() {
throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes)
}
var proto = classType.registeredClass.instancePrototype;
var method = proto[methodName];
if (undefined === method || undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2) {
unboundTypesHandler.argCount = argCount - 2;
unboundTypesHandler.className = classType.name;
proto[methodName] = unboundTypesHandler
} else {
ensureOverloadTable(proto, methodName, humanName);
proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler
}
whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) {
var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context);
if (undefined === proto[methodName].overloadTable) {
memberFunction.argCount = argCount - 2;
proto[methodName] = memberFunction
} else {
proto[methodName].overloadTable[argCount - 2] = memberFunction
}
return []
});
return []
})
}
function validateThis(this_, classType, humanName) {
if (!(this_ instanceof Object)) {
throwBindingError(humanName + ' with invalid "this": ' + this_)
}
if (!(this_ instanceof classType.registeredClass.constructor)) {
throwBindingError(humanName + ' incompatible with "this" of type ' + this_.constructor.name)
}
if (!this_.$$.ptr) {
throwBindingError("cannot call emscripten binding method " + humanName + " on deleted object")
}
return upcastPointer(this_.$$.ptr, this_.$$.ptrType.registeredClass, classType.registeredClass)
}
function __embind_register_class_property(classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
fieldName = readLatin1String(fieldName);
getter = embind__requireFunction(getterSignature, getter);
whenDependentTypesAreResolved([], [classType], function(classType) {
classType = classType[0];
var humanName = classType.name + "." + fieldName;
var desc = {
get: function() {
throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [getterReturnType, setterArgumentType])
},
enumerable: true,
configurable: true
};
if (setter) {
desc.set = () => {
throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [getterReturnType, setterArgumentType])
}
} else {
desc.set = v => {
throwBindingError(humanName + " is a read-only property")
}
}
Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc);
whenDependentTypesAreResolved([], setter ? [getterReturnType, setterArgumentType] : [getterReturnType], function(types) {
var getterReturnType = types[0];
var desc = {
get: function() {
var ptr = validateThis(this, classType, humanName + " getter");
return getterReturnType["fromWireType"](getter(getterContext, ptr))
},
enumerable: true
};
if (setter) {
setter = embind__requireFunction(setterSignature, setter);
var setterArgumentType = types[1];
desc.set = function(v) {
var ptr = validateThis(this, classType, humanName + " setter");
var destructors = [];
setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, v));
runDestructors(destructors)
}
}
Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc);
return []
});
return []
})
}
var emval_free_list = [];
var emval_handle_array = [{}, {
value: undefined
}, {
value: null
}, {
value: true
}, {
value: false
}];
function __emval_decref(handle) {
if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
emval_handle_array[handle] = undefined;
emval_free_list.push(handle)
}
}
function count_emval_handles() {
var count = 0;
for (var i = 5; i < emval_handle_array.length; ++i) {
if (emval_handle_array[i] !== undefined) {
++count
}
}
return count
}
function get_first_emval() {
for (var i = 5; i < emval_handle_array.length; ++i) {
if (emval_handle_array[i] !== undefined) {
return emval_handle_array[i]
}
}
return null
}
function init_emval() {
Module["count_emval_handles"] = count_emval_handles;
Module["get_first_emval"] = get_first_emval
}
var Emval = {
toValue: handle => {
if (!handle) {
throwBindingError("Cannot use deleted val. handle = " + handle)
}
return emval_handle_array[handle].value
},
toHandle: value => {
switch (value) {
case undefined:
return 1;
case null:
return 2;
case true:
return 3;
case false:
return 4;
default: {
var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;
emval_handle_array[handle] = {
refcount: 1,
value: value
};
return handle
}
}
}
};
function __embind_register_emval(rawType, name) {
name = readLatin1String(name);
registerType(rawType, {
name: name,
"fromWireType": function(handle) {
var rv = Emval.toValue(handle);
__emval_decref(handle);
return rv
},
"toWireType": function(destructors, value) {
return Emval.toHandle(value)
},
"argPackAdvance": 8,
"readValueFromPointer": simpleReadValueFromPointer,
destructorFunction: null
})
}
function embindRepr(v) {
if (v === null) {
return "null"
}
var t = typeof v;
if (t === "object" || t === "array" || t === "function") {
return v.toString()
} else {
return "" + v
}
}
function floatReadValueFromPointer(name, shift) {
switch (shift) {
case 2:
return function(pointer) {
return this["fromWireType"](HEAPF32[pointer >> 2])
};
case 3:
return function(pointer) {
return this["fromWireType"](HEAPF64[pointer >> 3])
};
default:
throw new TypeError("Unknown float type: " + name)
}
}
function __embind_register_float(rawType, name, size) {
var shift = getShiftFromSize(size);
name = readLatin1String(name);
registerType(rawType, {
name: name,
"fromWireType": function(value) {
return value
},
"toWireType": function(destructors, value) {
return value
},
"argPackAdvance": 8,
"readValueFromPointer": floatReadValueFromPointer(name, shift),
destructorFunction: null
})
}
function integerReadValueFromPointer(name, shift, signed) {
switch (shift) {
case 0:
return signed ? function readS8FromPointer(pointer) {
return HEAP8[pointer]
} : function readU8FromPointer(pointer) {
return HEAPU8[pointer]
};
case 1:
return signed ? function readS16FromPointer(pointer) {
return HEAP16[pointer >> 1]
} : function readU16FromPointer(pointer) {
return HEAPU16[pointer >> 1]
};
case 2:
return signed ? function readS32FromPointer(pointer) {
return HEAP32[pointer >> 2]
} : function readU32FromPointer(pointer) {
return HEAPU32[pointer >> 2]
};
default:
throw new TypeError("Unknown integer type: " + name)
}
}
function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
name = readLatin1String(name);
if (maxRange === -1) {
maxRange = 4294967295
}
var shift = getShiftFromSize(size);
var fromWireType = value => value;
if (minRange === 0) {
var bitshift = 32 - 8 * size;
fromWireType = value => value << bitshift >>> bitshift
}
var isUnsignedType = name.includes("unsigned");
var checkAssertions = (value, toTypeName) => {};
var toWireType;
if (isUnsignedType) {
toWireType = function(destructors, value) {
checkAssertions(value, this.name);
return value >>> 0
}
} else {
toWireType = function(destructors, value) {
checkAssertions(value, this.name);
return value
}
}
registerType(primitiveType, {
name: name,
"fromWireType": fromWireType,
"toWireType": toWireType,
"argPackAdvance": 8,
"readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0),
destructorFunction: null
})
}
function __embind_register_memory_view(rawType, dataTypeIndex, name) {
var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
var TA = typeMapping[dataTypeIndex];
function decodeMemoryView(handle) {
handle = handle >> 2;
var heap = HEAPU32;
var size = heap[handle];
var data = heap[handle + 1];
return new TA(buffer, data, size)
}
name = readLatin1String(name);
registerType(rawType, {
name: name,
"fromWireType": decodeMemoryView,
"argPackAdvance": 8,
"readValueFromPointer": decodeMemoryView
}, {
ignoreDuplicateRegistrations: true
})
}
function __embind_register_std_string(rawType, name) {
name = readLatin1String(name);
var stdStringIsUTF8 = name === "std::string";
registerType(rawType, {
name: name,
"fromWireType": function(value) {
var length = HEAPU32[value >> 2];
var payload = value + 4;
var str;
if (stdStringIsUTF8) {
var decodeStartPtr = payload;
for (var i = 0; i <= length; ++i) {
var currentBytePtr = payload + i;
if (i == length || HEAPU8[currentBytePtr] == 0) {
var maxRead = currentBytePtr - decodeStartPtr;
var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
if (str === undefined) {
str = stringSegment
} else {
str += String.fromCharCode(0);
str += stringSegment
}
decodeStartPtr = currentBytePtr + 1
}
}
} else {
var a = new Array(length);
for (var i = 0; i < length; ++i) {
a[i] = String.fromCharCode(HEAPU8[payload + i])
}
str = a.join("")
}
_free(value);
return str
},
"toWireType": function(destructors, value) {
if (value instanceof ArrayBuffer) {
value = new Uint8Array(value)
}
var length;
var valueIsOfTypeString = typeof value == "string";
if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
throwBindingError("Cannot pass non-string to std::string")
}
if (stdStringIsUTF8 && valueIsOfTypeString) {
length = lengthBytesUTF8(value)
} else {
length = value.length
}
var base = _malloc(4 + length + 1);
var ptr = base + 4;
HEAPU32[base >> 2] = length;
if (stdStringIsUTF8 && valueIsOfTypeString) {
stringToUTF8(value, ptr, length + 1)
} else {
if (valueIsOfTypeString) {
for (var i = 0; i < length; ++i) {
var charCode = value.charCodeAt(i);
if (charCode > 255) {
_free(ptr);
throwBindingError("String has UTF-16 code units that do not fit in 8 bits")
}
HEAPU8[ptr + i] = charCode
}
} else {
for (var i = 0; i < length; ++i) {
HEAPU8[ptr + i] = value[i]
}
}
}
if (destructors !== null) {
destructors.push(_free, base)
}
return base
},
"argPackAdvance": 8,
"readValueFromPointer": simpleReadValueFromPointer,
destructorFunction: function(ptr) {
_free(ptr)
}
})
}
var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined;
function UTF16ToString(ptr, maxBytesToRead) {
var endPtr = ptr;
var idx = endPtr >> 1;
var maxIdx = idx + maxBytesToRead / 2;
while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
endPtr = idx << 1;
if (endPtr - ptr > 32 && UTF16Decoder) {
return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr))
} else {
var str = "";
for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
var codeUnit = HEAP16[ptr + i * 2 >> 1];
if (codeUnit == 0) break;
str += String.fromCharCode(codeUnit)
}
return str
}
}
function stringToUTF16(str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647
}
if (maxBytesToWrite < 2) return 0;
maxBytesToWrite -= 2;
var startPtr = outPtr;
var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
for (var i = 0; i < numCharsToWrite; ++i) {
var codeUnit = str.charCodeAt(i);
HEAP16[outPtr >> 1] = codeUnit;
outPtr += 2
}
HEAP16[outPtr >> 1] = 0;
return outPtr - startPtr
}
function lengthBytesUTF16(str) {
return str.length * 2
}
function UTF32ToString(ptr, maxBytesToRead) {
var i = 0;
var str = "";
while (!(i >= maxBytesToRead / 4)) {
var utf32 = HEAP32[ptr + i * 4 >> 2];
if (utf32 == 0) break;
++i;
if (utf32 >= 65536) {
var ch = utf32 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
} else {
str += String.fromCharCode(utf32)
}
}
return str
}
function stringToUTF32(str, outPtr, maxBytesToWrite) {
if (maxBytesToWrite === undefined) {
maxBytesToWrite = 2147483647
}
if (maxBytesToWrite < 4) return 0;
var startPtr = outPtr;
var endPtr = startPtr + maxBytesToWrite - 4;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) {
var trailSurrogate = str.charCodeAt(++i);
codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023
}
HEAP32[outPtr >> 2] = codeUnit;
outPtr += 4;
if (outPtr + 4 > endPtr) break
}
HEAP32[outPtr >> 2] = 0;
return outPtr - startPtr
}
function lengthBytesUTF32(str) {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var codeUnit = str.charCodeAt(i);
if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
len += 4
}
return len
}
function __embind_register_std_wstring(rawType, charSize, name) {
name = readLatin1String(name);
var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
if (charSize === 2) {
decodeString = UTF16ToString;
encodeString = stringToUTF16;
lengthBytesUTF = lengthBytesUTF16;
getHeap = () => HEAPU16;
shift = 1
} else if (charSize === 4) {
decodeString = UTF32ToString;
encodeString = stringToUTF32;
lengthBytesUTF = lengthBytesUTF32;
getHeap = () => HEAPU32;
shift = 2
}
registerType(rawType, {
name: name,
"fromWireType": function(value) {
var length = HEAPU32[value >> 2];
var HEAP = getHeap();
var str;
var decodeStartPtr = value + 4;
for (var i = 0; i <= length; ++i) {
var currentBytePtr = value + 4 + i * charSize;
if (i == length || HEAP[currentBytePtr >> shift] == 0) {
var maxReadBytes = currentBytePtr - decodeStartPtr;
var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
if (str === undefined) {
str = stringSegment
} else {
str += String.fromCharCode(0);
str += stringSegment
}
decodeStartPtr = currentBytePtr + charSize
}
}
_free(value);
return str
},
"toWireType": function(destructors, value) {
if (!(typeof value == "string")) {
throwBindingError("Cannot pass non-string to C++ string type " + name)
}
var length = lengthBytesUTF(value);
var ptr = _malloc(4 + length + charSize);
HEAPU32[ptr >> 2] = length >> shift;
encodeString(value, ptr + 4, length + charSize);
if (destructors !== null) {
destructors.push(_free, ptr)
}
return ptr
},
"argPackAdvance": 8,
"readValueFromPointer": simpleReadValueFromPointer,
destructorFunction: function(ptr) {
_free(ptr)
}
})
}
function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
structRegistrations[rawType] = {
name: readLatin1String(name),
rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
fields: []
}
}
function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
structRegistrations[structType].fields.push({
fieldName: readLatin1String(fieldName),
getterReturnType: getterReturnType,
getter: embind__requireFunction(getterSignature, getter),
getterContext: getterContext,
setterArgumentType: setterArgumentType,
setter: embind__requireFunction(setterSignature, setter),
setterContext: setterContext
})
}
function __embind_register_void(rawType, name) {
name = readLatin1String(name);
registerType(rawType, {
isVoid: true,
name: name,
"argPackAdvance": 0,
"fromWireType": function() {
return undefined
},
"toWireType": function(destructors, o) {
return undefined
}
})
}
function requireRegisteredType(rawType, humanName) {
var impl = registeredTypes[rawType];
if (undefined === impl) {
throwBindingError(humanName + " has unknown type " + getTypeName(rawType))
}
return impl
}
function __emval_as(handle, returnType, destructorsRef) {
handle = Emval.toValue(handle);
returnType = requireRegisteredType(returnType, "emval::as");
var destructors = [];
var rd = Emval.toHandle(destructors);
HEAPU32[destructorsRef >> 2] = rd;
return returnType["toWireType"](destructors, handle)
}
var emval_symbols = {};
function getStringOrSymbol(address) {
var symbol = emval_symbols[address];
if (symbol === undefined) {
return readLatin1String(address)
}
return symbol
}
var emval_methodCallers = [];
function __emval_call_void_method(caller, handle, methodName, args) {
caller = emval_methodCallers[caller];
handle = Emval.toValue(handle);
methodName = getStringOrSymbol(methodName);
caller(handle, methodName, null, args)
}
function emval_addMethodCaller(caller) {
var id = emval_methodCallers.length;
emval_methodCallers.push(caller);
return id
}
function emval_lookupTypes(argCount, argTypes) {
var a = new Array(argCount);
for (var i = 0; i < argCount; ++i) {
a[i] = requireRegisteredType(HEAPU32[argTypes + i * POINTER_SIZE >> 2], "parameter " + i)
}
return a
}
var emval_registeredMethods = [];
function __emval_get_method_caller(argCount, argTypes) {
var types = emval_lookupTypes(argCount, argTypes);
var retType = types[0];
var signatureName = retType.name + "_$" + types.slice(1).map(function(t) {
return t.name
}).join("_") + "$";
var returnId = emval_registeredMethods[signatureName];
if (returnId !== undefined) {
return returnId
}
var params = ["retType"];
var args = [retType];
var argsList = "";
for (var i = 0; i < argCount - 1; ++i) {
argsList += (i !== 0 ? ", " : "") + "arg" + i;
params.push("argType" + i);
args.push(types[1 + i])
}
var functionName = makeLegalFunctionName("methodCaller_" + signatureName);
var functionBody = "return function " + functionName + "(handle, name, destructors, args) {\n";
var offset = 0;
for (var i = 0; i < argCount - 1; ++i) {
functionBody += " var arg" + i + " = argType" + i + ".readValueFromPointer(args" + (offset ? "+" + offset : "") + ");\n";
offset += types[i + 1]["argPackAdvance"]
}
functionBody += " var rv = handle[name](" + argsList + ");\n";
for (var i = 0; i < argCount - 1; ++i) {
if (types[i + 1]["deleteObject"]) {
functionBody += " argType" + i + ".deleteObject(arg" + i + ");\n"
}
}
if (!retType.isVoid) {
functionBody += " return retType.toWireType(destructors, rv);\n"
}
functionBody += "};\n";
params.push(functionBody);
var invokerFunction = new_(Function, params).apply(null, args);
returnId = emval_addMethodCaller(invokerFunction);
emval_registeredMethods[signatureName] = returnId;
return returnId
}
function __emval_get_property(handle, key) {
handle = Emval.toValue(handle);
key = Emval.toValue(key);
return Emval.toHandle(handle[key])
}
function __emval_incref(handle) {
if (handle > 4) {
emval_handle_array[handle].refcount += 1
}
}
function __emval_new_array() {
return Emval.toHandle([])
}
function __emval_new_cstring(v) {
return Emval.toHandle(getStringOrSymbol(v))
}
function __emval_run_destructors(handle) {
var destructors = Emval.toValue(handle);
runDestructors(destructors);
__emval_decref(handle)
}
function __emval_set_property(handle, key, value) {
handle = Emval.toValue(handle);
key = Emval.toValue(key);
value = Emval.toValue(value);
handle[key] = value
}
function __emval_take_value(type, arg) {
type = requireRegisteredType(type, "_emval_take_value");
var v = type["readValueFromPointer"](arg);
return Emval.toHandle(v)
}
function _abort() {
abort("")
}
function _emscripten_memcpy_big(dest, src, num) {
HEAPU8.copyWithin(dest, src, src + num)
}
function getHeapMax() {
return 2147483648
}
function emscripten_realloc_buffer(size) {
try {
wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
updateGlobalBufferAndViews(wasmMemory.buffer);
return 1
} catch (e) {}
}
function _emscripten_resize_heap(requestedSize) {
var oldSize = HEAPU8.length;
requestedSize = requestedSize >>> 0;
var maxHeapSize = getHeapMax();
if (requestedSize > maxHeapSize) {
return false
}
let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
var replacement = emscripten_realloc_buffer(newSize);
if (replacement) {
return true
}
}
return false
}
var WebGPU = {
initManagers: function() {
if (WebGPU.mgrDevice) return;
function Manager() {
this.objects = {};
this.nextId = 1;
this.create = function(object, wrapper) {
wrapper = wrapper || {};
var id = this.nextId++;
wrapper.refcount = 1;
wrapper.object = object;
this.objects[id] = wrapper;
return id
};
this.get = function(id) {
if (!id) return undefined;
var o = this.objects[id];
return o.object
};
this.reference = function(id) {
var o = this.objects[id];
o.refcount++
};
this.release = function(id) {
var o = this.objects[id];
o.refcount--;
if (o.refcount <= 0) {
delete this.objects[id]
}
}
}
WebGPU.mgrSurface = WebGPU.mgrSurface || new Manager;
WebGPU.mgrSwapChain = WebGPU.mgrSwapChain || new Manager;
WebGPU.mgrAdapter = WebGPU.mgrAdapter || new Manager;
WebGPU.mgrDevice = WebGPU.mgrDevice || new Manager;
WebGPU.mgrQueue = WebGPU.mgrQueue || new Manager;
WebGPU.mgrCommandBuffer = WebGPU.mgrCommandBuffer || new Manager;
WebGPU.mgrCommandEncoder = WebGPU.mgrCommandEncoder || new Manager;
WebGPU.mgrRenderPassEncoder = WebGPU.mgrRenderPassEncoder || new Manager;
WebGPU.mgrComputePassEncoder = WebGPU.mgrComputePassEncoder || new Manager;
WebGPU.mgrBindGroup = WebGPU.mgrBindGroup || new Manager;
WebGPU.mgrBuffer = WebGPU.mgrBuffer || new Manager;
WebGPU.mgrSampler = WebGPU.mgrSampler || new Manager;
WebGPU.mgrTexture = WebGPU.mgrTexture || new Manager;
WebGPU.mgrTextureView = WebGPU.mgrTextureView || new Manager;
WebGPU.mgrQuerySet = WebGPU.mgrQuerySet || new Manager;
WebGPU.mgrBindGroupLayout = WebGPU.mgrBindGroupLayout || new Manager;
WebGPU.mgrPipelineLayout = WebGPU.mgrPipelineLayout || new Manager;
WebGPU.mgrRenderPipeline = WebGPU.mgrRenderPipeline || new Manager;
WebGPU.mgrComputePipeline = WebGPU.mgrComputePipeline || new Manager;
WebGPU.mgrShaderModule = WebGPU.mgrShaderModule || new Manager;
WebGPU.mgrRenderBundleEncoder = WebGPU.mgrRenderBundleEncoder || new Manager;
WebGPU.mgrRenderBundle = WebGPU.mgrRenderBundle || new Manager
},
makeColor: function(ptr) {
return {
"r": HEAPF64[ptr >> 3],
"g": HEAPF64[ptr + 8 >> 3],
"b": HEAPF64[ptr + 16 >> 3],
"a": HEAPF64[ptr + 24 >> 3]
}
},
makeExtent3D: function(ptr) {
return {
"width": HEAPU32[ptr >> 2],
"height": HEAPU32[ptr + 4 >> 2],
"depthOrArrayLayers": HEAPU32[ptr + 8 >> 2]
}
},
makeOrigin3D: function(ptr) {
return {
"x": HEAPU32[ptr >> 2],
"y": HEAPU32[ptr + 4 >> 2],
"z": HEAPU32[ptr + 8 >> 2]
}
},
makeImageCopyTexture: function(ptr) {
return {
"texture": WebGPU.mgrTexture.get(HEAPU32[ptr + 4 >> 2]),
"mipLevel": HEAPU32[ptr + 8 >> 2],
"origin": WebGPU.makeOrigin3D(ptr + 12),
"aspect": WebGPU.TextureAspect[HEAPU32[ptr + 24 >> 2]]
}
},
makeTextureDataLayout: function(ptr) {
var bytesPerRow = HEAPU32[ptr + 16 >> 2];
var rowsPerImage = HEAPU32[ptr + 20 >> 2];
return {
"offset": HEAPU32[ptr + 4 + 8 >> 2] * 4294967296 + HEAPU32[ptr + 8 >> 2],
"bytesPerRow": bytesPerRow === 4294967295 ? undefined : bytesPerRow,
"rowsPerImage": rowsPerImage === 4294967295 ? undefined : rowsPerImage
}
},
makeImageCopyBuffer: function(ptr) {
var layoutPtr = ptr + 8;
var bufferCopyView = WebGPU.makeTextureDataLayout(layoutPtr);
bufferCopyView["buffer"] = WebGPU.mgrBuffer.get(HEAPU32[ptr + 32 >> 2]);
return bufferCopyView
},
makePipelineConstants: function(constantCount, constantsPtr) {
if (!constantCount) return;
var constants = {};
for (var i = 0; i < constantCount; ++i) {
var entryPtr = constantsPtr + 16 * i;
var key = UTF8ToString(HEAPU32[entryPtr + 4 >> 2]);
constants[key] = HEAPF64[entryPtr + 8 >> 3]
}
return constants
},
makeProgrammableStageDescriptor: function(ptr) {
if (!ptr) return undefined;
return {
"module": WebGPU.mgrShaderModule.get(HEAPU32[ptr + 4 >> 2]),
"entryPoint": UTF8ToString(HEAPU32[ptr + 8 >> 2]),
"constants": WebGPU.makePipelineConstants(HEAPU32[ptr + 12 >> 2], HEAPU32[ptr + 16 >> 2])
}
},
DeviceLostReason: {
undefined: 0,
destroyed: 1
},
PreferredFormat: {
rgba8unorm: 18,
bgra8unorm: 23
},
AddressMode: ["repeat", "mirror-repeat", "clamp-to-edge"],
BlendFactor: ["zero", "one", "src", "one-minus-src", "src-alpha", "one-minus-src-alpha", "dst", "one-minus-dst", "dst-alpha", "one-minus-dst-alpha", "src-alpha-saturated", "constant", "one-minus-constant"],
BlendOperation: ["add", "subtract", "reverse-subtract", "min", "max"],
BufferBindingType: [, "uniform", "storage", "read-only-storage"],
CompareFunction: [, "never", "less", "less-equal", "greater", "greater-equal", "equal", "not-equal", "always"],
CompilationInfoRequestStatus: ["success", "error", "device-lost", "unknown"],
ComputePassTimestampLocation: ["beginning", "end"],
CullMode: ["none", "front", "back"],
ErrorFilter: ["validation", "out-of-memory"],
FeatureName: {
0: undefined,
1: "depth-clip-control",
2: "depth24unorm-stencil8",
3: "depth32float-stencil8",
4: "timestamp-query",
5: "pipeline-statistics-query",
6: "texture-compression-bc",
7: "texture-compression-etc2",
8: "texture-compression-astc",
9: "indirect-first-instance",
1e3: "depth-clamping"
},
FilterMode: ["nearest", "linear"],
FrontFace: ["ccw", "cw"],
IndexFormat: [, "uint16", "uint32"],
LoadOp: [, "clear", "load"],
PipelineStatisticName: ["vertex-shader-invocations", "clipper-invocations", "clipper-primitives-out", "fragment-shader-invocations", "compute-shader-invocations"],
PowerPreference: [, "low-power", "high-performance"],
PredefinedColorSpace: [, "srgb"],
PrimitiveTopology: ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"],
QueryType: ["occlusion", "pipeline-statistics", "timestamp"],
RenderPassTimestampLocation: ["beginning", "end"],
SamplerBindingType: [, "filtering", "non-filtering", "comparison"],
StencilOperation: ["keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap"],
StorageTextureAccess: [, "write-only"],
StoreOp: [, "store", "discard"],
TextureAspect: ["all", "stencil-only", "depth-only"],
TextureComponentType: ["float", "sint", "uint", "depth-comparison"],
TextureDimension: ["1d", "2d", "3d"],
TextureFormat: [, "r8unorm", "r8snorm", "r8uint", "r8sint", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32float", "r32uint", "r32sint", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb10a2unorm", "rg11b10ufloat", "rgb9e5ufloat", "rg32float", "rg32uint", "rg32sint", "rgba16uint", "rgba16sint", "rgba16float", "rgba32float", "rgba32uint", "rgba32sint", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth24unorm-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"],
VertexFormat: [, "uint8x2", "uint8x4", "sint8x2", "sint8x4", "unorm8x2", "unorm8x4", "snorm8x2", "snorm8x4", "uint16x2", "uint16x4", "sint16x2", "sint16x4", "unorm16x2", "unorm16x4", "snorm16x2", "snorm16x4", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4"],
VertexStepMode: ["vertex", "instance"],
FeatureNameString2Enum: {
undefined: "0",
"depth-clip-control": "1",
"depth24unorm-stencil8": "2",
"depth32float-stencil8": "3",
"timestamp-query": "4",
"pipeline-statistics-query": "5",
"texture-compression-bc": "6",
"texture-compression-etc2": "7",
"texture-compression-astc": "8",
"indirect-first-instance": "9",
"depth-clamping": "1000"
}
};
function _emscripten_webgpu_get_device() {
var device = Module["preinitializedWebGPUDevice"];
var deviceWrapper = {
queueId: WebGPU.mgrQueue.create(device["queue"])
};
return WebGPU.mgrDevice.create(device, deviceWrapper)
}
var ENV = {};
function getExecutableName() {
return thisProgram || "./this.program"
}
function getEnvStrings() {
if (!getEnvStrings.strings) {
var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
var env = {
"USER": "web_user",
"LOGNAME": "web_user",
"PATH": "/",
"PWD": "/",
"HOME": "/home/web_user",
"LANG": lang,
"_": getExecutableName()
};
for (var x in ENV) {
if (ENV[x] === undefined) delete env[x];
else env[x] = ENV[x]
}
var strings = [];
for (var x in env) {
strings.push(x + "=" + env[x])
}
getEnvStrings.strings = strings
}
return getEnvStrings.strings
}
function writeAsciiToMemory(str, buffer, dontAddNull) {
for (var i = 0; i < str.length; ++i) {
HEAP8[buffer++ >> 0] = str.charCodeAt(i)
}
if (!dontAddNull) HEAP8[buffer >> 0] = 0
}
var SYSCALLS = {
varargs: undefined,
get: function() {
SYSCALLS.varargs += 4;
var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
return ret
},
getStr: function(ptr) {
var ret = UTF8ToString(ptr);
return ret
}
};
function _environ_get(__environ, environ_buf) {
var bufSize = 0;
getEnvStrings().forEach(function(string, i) {
var ptr = environ_buf + bufSize;
HEAPU32[__environ + i * 4 >> 2] = ptr;
writeAsciiToMemory(string, ptr);
bufSize += string.length + 1
});
return 0
}
function _environ_sizes_get(penviron_count, penviron_buf_size) {
var strings = getEnvStrings();
HEAPU32[penviron_count >> 2] = strings.length;
var bufSize = 0;
strings.forEach(function(string) {
bufSize += string.length + 1
});
HEAPU32[penviron_buf_size >> 2] = bufSize;
return 0
}
var printCharBuffers = [null, [],
[]
];
function printChar(stream, curr) {
var buffer = printCharBuffers[stream];
if (curr === 0 || curr === 10) {
(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
buffer.length = 0
} else {
buffer.push(curr)
}
}
function _fd_write(fd, iov, iovcnt, pnum) {
var num = 0;
for (var i = 0; i < iovcnt; i++) {
var ptr = HEAPU32[iov >> 2];
var len = HEAPU32[iov + 4 >> 2];
iov += 8;
for (var j = 0; j < len; j++) {
printChar(fd, HEAPU8[ptr + j])
}
num += len
}
HEAPU32[pnum >> 2] = num;
return 0
}
function _setTempRet0(val) {
setTempRet0(val)
}
function _wgpuAdapterGetProperties(adapterId, properties) {
HEAP32[properties + 4 >> 2] = 0;
HEAP32[properties + 8 >> 2] = 0;
HEAP32[properties + 12 >> 2] = 0;
HEAP32[properties + 16 >> 2] = 0;
HEAP32[properties + 20 >> 2] = 3;
HEAP32[properties + 24 >> 2] = 1
}
function _wgpuAdapterHasFeature(adapterId, featureEnumValue) {
var adapter = WebGPU.mgrAdapter.get(adapterId);
return adapter.features.has(WebGPU.FeatureName[featureEnumValue])
}
function _wgpuAdapterRelease(id) {
WebGPU.mgrAdapter.release(id)
}
function _wgpuBindGroupRelease(id) {
WebGPU.mgrBindGroup.release(id)
}
function _wgpuBufferDestroy(bufferId) {
WebGPU.mgrBuffer.get(bufferId)["destroy"]()
}
function _wgpuBufferGetMappedRange(bufferId, offset, size) {
var bufferWrapper = WebGPU.mgrBuffer.objects[bufferId];
if (size === 0) warnOnce("getMappedRange size=0 no longer means WGPU_WHOLE_MAP_SIZE");
size = size >>> 0;
if (size === 4294967295) size = undefined;
if (bufferWrapper.mapMode !== 2) {
return 0
}
var mapped;
try {
mapped = bufferWrapper.object["getMappedRange"](offset, size)
} catch (ex) {
return 0
}
var data = _malloc(mapped.byteLength);
HEAPU8.fill(0, data, mapped.byteLength);
bufferWrapper.onUnmap.push(function() {
new Uint8Array(mapped).set(HEAPU8.subarray(data, data + mapped.byteLength));
_free(data)
});
return data
}
function _wgpuBufferRelease(id) {
WebGPU.mgrBuffer.release(id)
}
function _wgpuBufferUnmap(bufferId) {
var bufferWrapper = WebGPU.mgrBuffer.objects[bufferId];
if (!bufferWrapper.onUnmap) {
return
}
for (var i = 0; i < bufferWrapper.onUnmap.length; ++i) {
bufferWrapper.onUnmap[i]()
}
bufferWrapper.onUnmap = undefined;
bufferWrapper.object["unmap"]()
}
function _wgpuCommandBufferRelease(id) {
WebGPU.mgrCommandBuffer.release(id)
}
function _wgpuCommandEncoderBeginComputePass(encoderId, descriptor) {
var desc;
function makeComputePassTimestampWrite(twPtr) {
return {
"querySet": WebGPU.mgrQuerySet.get(HEAPU32[twPtr >> 2]),
"queryIndex": HEAPU32[twPtr + 4 >> 2],
"location": WebGPU.ComputePassTimestampLocation[HEAPU32[twPtr + 8 >> 2]]
}
}
function makeComputePassTimestampWrites(count, twPtr) {
var timestampWrites = [];
for (var i = 0; i < count; ++i) {
timestampWrites.push(makeComputePassTimestampWrite(twPtr + 12 * i))
}
return timestampWrites
}
if (descriptor) {
desc = {};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var timestampWriteCount = HEAPU32[descriptor + 8 >> 2];
if (timestampWriteCount) {
desc["timestampWrites"] = makeComputePassTimestampWrites(timestampWriteCount, HEAPU32[descriptor + 12 >> 2])
}
}
var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId);
return WebGPU.mgrComputePassEncoder.create(commandEncoder["beginComputePass"](desc))
}
function _wgpuCommandEncoderBeginRenderPass(encoderId, descriptor) {
function makeColorAttachment(caPtr) {
var viewPtr = HEAPU32[caPtr >> 2];
if (viewPtr === 0) {
return undefined
}
var loadOpInt = HEAPU32[caPtr + 8 >> 2];
var storeOpInt = HEAPU32[caPtr + 12 >> 2];
var clearValue = WebGPU.makeColor(caPtr + 16);
return {
"view": WebGPU.mgrTextureView.get(viewPtr),
"resolveTarget": WebGPU.mgrTextureView.get(HEAPU32[caPtr + 4 >> 2]),
"clearValue": clearValue,
"loadOp": WebGPU.LoadOp[loadOpInt],
"storeOp": WebGPU.StoreOp[storeOpInt]
}
}
function makeColorAttachments(count, caPtr) {
var attachments = [];
for (var i = 0; i < count; ++i) {
attachments.push(makeColorAttachment(caPtr + 48 * i))
}
return attachments
}
function makeDepthStencilAttachment(dsaPtr) {
if (dsaPtr === 0) return undefined;
return {
"view": WebGPU.mgrTextureView.get(HEAPU32[dsaPtr >> 2]),
"depthClearValue": HEAPF32[dsaPtr + 12 >> 2],
"depthLoadOp": WebGPU.LoadOp[HEAPU32[dsaPtr + 4 >> 2]],
"depthStoreOp": WebGPU.StoreOp[HEAPU32[dsaPtr + 8 >> 2]],
"depthReadOnly": HEAP8[dsaPtr + 16 >> 0] !== 0,
"stencilClearValue": HEAPU32[dsaPtr + 28 >> 2],
"stencilLoadOp": WebGPU.LoadOp[HEAPU32[dsaPtr + 20 >> 2]],
"stencilStoreOp": WebGPU.StoreOp[HEAPU32[dsaPtr + 24 >> 2]],
"stencilReadOnly": HEAP8[dsaPtr + 32 >> 0] !== 0
}
}
function makeRenderPassTimestampWrite(twPtr) {
return {
"querySet": WebGPU.mgrQuerySet.get(HEAPU32[twPtr >> 2]),
"queryIndex": HEAPU32[twPtr + 4 >> 2],
"location": WebGPU.RenderPassTimestampLocation[HEAPU32[twPtr + 8 >> 2]]
}
}
function makeRenderPassTimestampWrites(count, twPtr) {
var timestampWrites = [];
for (var i = 0; i < count; ++i) {
timestampWrites.push(makeRenderPassTimestampWrite(twPtr + 12 * i))
}
return timestampWrites
}
function makeRenderPassDescriptor(descriptor) {
var desc = {
"label": undefined,
"colorAttachments": makeColorAttachments(HEAPU32[descriptor + 8 >> 2], HEAPU32[descriptor + 12 >> 2]),
"depthStencilAttachment": makeDepthStencilAttachment(HEAPU32[descriptor + 16 >> 2]),
"occlusionQuerySet": WebGPU.mgrQuerySet.get(HEAPU32[descriptor + 20 >> 2])
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var timestampWriteCount = HEAPU32[descriptor + 24 >> 2];
if (timestampWriteCount) {
desc["timestampWrites"] = makeRenderPassTimestampWrites(timestampWriteCount, HEAPU32[descriptor + 28 >> 2])
}
return desc
}
var desc = makeRenderPassDescriptor(descriptor);
var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId);
return WebGPU.mgrRenderPassEncoder.create(commandEncoder["beginRenderPass"](desc))
}
function _wgpuCommandEncoderCopyBufferToBuffer(encoderId, srcId, srcOffset_low, srcOffset_high, dstId, dstOffset_low, dstOffset_high, size_low, size_high) {
var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId);
var src = WebGPU.mgrBuffer.get(srcId);
var dst = WebGPU.mgrBuffer.get(dstId);
commandEncoder["copyBufferToBuffer"](src, srcOffset_high * 4294967296 + srcOffset_low, dst, dstOffset_high * 4294967296 + dstOffset_low, size_high * 4294967296 + size_low)
}
function _wgpuCommandEncoderCopyBufferToTexture(encoderId, srcPtr, dstPtr, copySizePtr) {
var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId);
var copySize = WebGPU.makeExtent3D(copySizePtr);
commandEncoder["copyBufferToTexture"](WebGPU.makeImageCopyBuffer(srcPtr), WebGPU.makeImageCopyTexture(dstPtr), copySize)
}
function _wgpuCommandEncoderCopyTextureToTexture(encoderId, srcPtr, dstPtr, copySizePtr) {
var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId);
var copySize = WebGPU.makeExtent3D(copySizePtr);
commandEncoder["copyTextureToTexture"](WebGPU.makeImageCopyTexture(srcPtr), WebGPU.makeImageCopyTexture(dstPtr), copySize)
}
function _wgpuCommandEncoderFinish(encoderId) {
var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId);
return WebGPU.mgrCommandBuffer.create(commandEncoder["finish"]())
}
function _wgpuCommandEncoderRelease(id) {
WebGPU.mgrCommandEncoder.release(id)
}
function _wgpuComputePassEncoderDispatchWorkgroups(passId, x, y, z) {
var pass = WebGPU.mgrComputePassEncoder.get(passId);
if (pass["dispatchWorkgroups"]) {
pass["dispatchWorkgroups"](x, y, z)
} else {
pass["dispatch"](x, y, z)
}
}
function _wgpuComputePassEncoderDispatchWorkgroupsIndirect(passId, indirectBufferId, indirectOffset_low, indirectOffset_high) {
var indirectBuffer = WebGPU.mgrBuffer.get(indirectBufferId);
var indirectOffset = indirectOffset_high * 4294967296 + indirectOffset_low;
var pass = WebGPU.mgrComputePassEncoder.get(passId);
if (pass["dispatchWorkgroupsIndirect"]) {
pass["dispatchWorkgroupsIndirect"](indirectBuffer, indirectOffset)
} else {
pass["dispatchIndirect"](indirectBuffer, indirectOffset)
}
}
function _wgpuComputePassEncoderEnd(passId) {
var pass = WebGPU.mgrComputePassEncoder.get(passId);
pass["end"]()
}
function _wgpuComputePassEncoderRelease(id) {
WebGPU.mgrComputePassEncoder.release(id)
}
function _wgpuComputePassEncoderSetBindGroup(passId, groupIndex, groupId, dynamicOffsetCount, dynamicOffsetsPtr) {
var pass = WebGPU.mgrComputePassEncoder.get(passId);
var group = WebGPU.mgrBindGroup.get(groupId);
if (dynamicOffsetCount == 0) {
pass["setBindGroup"](groupIndex, group)
} else {
var offsets = [];
for (var i = 0; i < dynamicOffsetCount; i++, dynamicOffsetsPtr += 4) {
offsets.push(HEAPU32[dynamicOffsetsPtr >> 2])
}
pass["setBindGroup"](groupIndex, group, offsets)
}
}
function _wgpuComputePassEncoderSetPipeline(passId, pipelineId) {
var pass = WebGPU.mgrComputePassEncoder.get(passId);
var pipeline = WebGPU.mgrComputePipeline.get(pipelineId);
pass["setPipeline"](pipeline)
}
function _wgpuComputePipelineRelease(id) {
WebGPU.mgrComputePipeline.release(id)
}
function _wgpuDeviceCreateBindGroup(deviceId, descriptor) {
function makeEntry(entryPtr) {
var bufferId = HEAPU32[entryPtr + 8 >> 2];
var samplerId = HEAPU32[entryPtr + 32 >> 2];
var textureViewId = HEAPU32[entryPtr + 36 >> 2];
var binding = HEAPU32[entryPtr + 4 >> 2];
if (bufferId) {
var size_low = HEAPU32[entryPtr + 24 >> 2];
var size_high = HEAPU32[entryPtr + 28 >> 2];
var size = size_high === -1 && size_low === -1 ? undefined : size_high * 4294967296 + size_low;
return {
"binding": binding,
"resource": {
"buffer": WebGPU.mgrBuffer.get(bufferId),
"offset": HEAPU32[entryPtr + 4 + 16 >> 2] * 4294967296 + HEAPU32[entryPtr + 16 >> 2],
"size": size
}
}
} else if (samplerId) {
return {
"binding": binding,
"resource": WebGPU.mgrSampler.get(samplerId)
}
} else {
return {
"binding": binding,
"resource": WebGPU.mgrTextureView.get(textureViewId)
}
}
}
function makeEntries(count, entriesPtrs) {
var entries = [];
for (var i = 0; i < count; ++i) {
entries.push(makeEntry(entriesPtrs + 40 * i))
}
return entries
}
var desc = {
"label": undefined,
"layout": WebGPU.mgrBindGroupLayout.get(HEAPU32[descriptor + 8 >> 2]),
"entries": makeEntries(HEAPU32[descriptor + 12 >> 2], HEAPU32[descriptor + 16 >> 2])
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrBindGroup.create(device["createBindGroup"](desc))
}
function _wgpuDeviceCreateBindGroupLayout(deviceId, descriptor) {
function makeBufferEntry(entryPtr) {
var typeInt = HEAPU32[entryPtr + 4 >> 2];
if (!typeInt) return undefined;
return {
"type": WebGPU.BufferBindingType[typeInt],
"hasDynamicOffset": HEAP8[entryPtr + 8 >> 0] !== 0,
"minBindingSize": HEAPU32[entryPtr + 4 + 16 >> 2] * 4294967296 + HEAPU32[entryPtr + 16 >> 2]
}
}
function makeSamplerEntry(entryPtr) {
var typeInt = HEAPU32[entryPtr + 4 >> 2];
if (!typeInt) return undefined;
return {
"type": WebGPU.SamplerBindingType[typeInt]
}
}
function makeTextureEntry(entryPtr) {
var sampleTypeInt = HEAPU32[entryPtr + 4 >> 2];
if (!sampleTypeInt) return undefined;
return {
"sampleType": WebGPU.TextureSampleType[sampleTypeInt],
"viewDimension": WebGPU.TextureViewDimension[HEAPU32[entryPtr + 8 >> 2]],
"multisampled": HEAP8[entryPtr + 12 >> 0] !== 0
}
}
function makeStorageTextureEntry(entryPtr) {
var accessInt = HEAPU32[entryPtr + 4 >> 2];
if (!accessInt) return undefined;
return {
"access": WebGPU.StorageTextureAccess[accessInt],
"format": WebGPU.TextureFormat[HEAPU32[entryPtr + 8 >> 2]],
"viewDimension": WebGPU.TextureViewDimension[HEAPU32[entryPtr + 12 >> 2]]
}
}
function makeEntry(entryPtr) {
return {
"binding": HEAPU32[entryPtr + 4 >> 2],
"visibility": HEAPU32[entryPtr + 8 >> 2],
"buffer": makeBufferEntry(entryPtr + 16),
"sampler": makeSamplerEntry(entryPtr + 40),
"texture": makeTextureEntry(entryPtr + 48),
"storageTexture": makeStorageTextureEntry(entryPtr + 64)
}
}
function makeEntries(count, entriesPtrs) {
var entries = [];
for (var i = 0; i < count; ++i) {
entries.push(makeEntry(entriesPtrs + 80 * i))
}
return entries
}
var desc = {
"entries": makeEntries(HEAPU32[descriptor + 8 >> 2], HEAPU32[descriptor + 12 >> 2])
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrBindGroupLayout.create(device["createBindGroupLayout"](desc))
}
function _wgpuDeviceCreateBuffer(deviceId, descriptor) {
var mappedAtCreation = HEAP8[descriptor + 24 >> 0] !== 0;
var desc = {
"label": undefined,
"usage": HEAPU32[descriptor + 8 >> 2],
"size": HEAPU32[descriptor + 4 + 16 >> 2] * 4294967296 + HEAPU32[descriptor + 16 >> 2],
"mappedAtCreation": mappedAtCreation
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var device = WebGPU.mgrDevice.get(deviceId);
var bufferWrapper = {};
var id = WebGPU.mgrBuffer.create(device["createBuffer"](desc), bufferWrapper);
if (mappedAtCreation) {
bufferWrapper.mapMode = 2;
bufferWrapper.onUnmap = []
}
return id
}
function _wgpuDeviceCreateCommandEncoder(deviceId, descriptor) {
var desc;
if (descriptor) {
desc = {
"label": undefined
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr)
}
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrCommandEncoder.create(device["createCommandEncoder"](desc))
}
function _wgpuDeviceCreateComputePipeline(deviceId, descriptor) {
var desc = {
"label": undefined,
"layout": WebGPU.mgrPipelineLayout.get(HEAPU32[descriptor + 8 >> 2]),
"compute": WebGPU.makeProgrammableStageDescriptor(descriptor + 12)
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrComputePipeline.create(device["createComputePipeline"](desc))
}
function _wgpuDeviceCreatePipelineLayout(deviceId, descriptor) {
var bglCount = HEAPU32[descriptor + 8 >> 2];
var bglPtr = HEAPU32[descriptor + 12 >> 2];
var bgls = [];
for (var i = 0; i < bglCount; ++i) {
bgls.push(WebGPU.mgrBindGroupLayout.get(HEAPU32[bglPtr + 4 * i >> 2]))
}
var desc = {
"label": undefined,
"bindGroupLayouts": bgls
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrPipelineLayout.create(device["createPipelineLayout"](desc))
}
function _wgpuDeviceCreateRenderPipeline(deviceId, descriptor) {
function makePrimitiveState(rsPtr) {
if (!rsPtr) return undefined;
return {
"topology": WebGPU.PrimitiveTopology[HEAPU32[rsPtr + 4 >> 2]],
"stripIndexFormat": WebGPU.IndexFormat[HEAPU32[rsPtr + 8 >> 2]],
"frontFace": WebGPU.FrontFace[HEAPU32[rsPtr + 12 >> 2]],
"cullMode": WebGPU.CullMode[HEAPU32[rsPtr + 16 >> 2]]
}
}
function makeBlendComponent(bdPtr) {
if (!bdPtr) return undefined;
return {
"operation": WebGPU.BlendOperation[HEAPU32[bdPtr >> 2]],
"srcFactor": WebGPU.BlendFactor[HEAPU32[bdPtr + 4 >> 2]],
"dstFactor": WebGPU.BlendFactor[HEAPU32[bdPtr + 8 >> 2]]
}
}
function makeBlendState(bsPtr) {
if (!bsPtr) return undefined;
return {
"alpha": makeBlendComponent(bsPtr + 12),
"color": makeBlendComponent(bsPtr + 0)
}
}
function makeColorState(csPtr) {
var formatInt = HEAPU32[csPtr + 4 >> 2];
return formatInt === 0 ? undefined : {
"format": WebGPU.TextureFormat[formatInt],
"blend": makeBlendState(HEAPU32[csPtr + 8 >> 2]),
"writeMask": HEAPU32[csPtr + 12 >> 2]
}
}
function makeColorStates(count, csArrayPtr) {
var states = [];
for (var i = 0; i < count; ++i) {
states.push(makeColorState(csArrayPtr + 16 * i))
}
return states
}
function makeStencilStateFace(ssfPtr) {
return {
"compare": WebGPU.CompareFunction[HEAPU32[ssfPtr >> 2]],
"failOp": WebGPU.StencilOperation[HEAPU32[ssfPtr + 4 >> 2]],
"depthFailOp": WebGPU.StencilOperation[HEAPU32[ssfPtr + 8 >> 2]],
"passOp": WebGPU.StencilOperation[HEAPU32[ssfPtr + 12 >> 2]]
}
}
function makeDepthStencilState(dssPtr) {
if (!dssPtr) return undefined;
return {
"format": WebGPU.TextureFormat[HEAPU32[dssPtr + 4 >> 2]],
"depthWriteEnabled": HEAP8[dssPtr + 8 >> 0] !== 0,
"depthCompare": WebGPU.CompareFunction[HEAPU32[dssPtr + 12 >> 2]],
"stencilFront": makeStencilStateFace(dssPtr + 16),
"stencilBack": makeStencilStateFace(dssPtr + 32),
"stencilReadMask": HEAPU32[dssPtr + 48 >> 2],
"stencilWriteMask": HEAPU32[dssPtr + 52 >> 2],
"depthBias": HEAPU32[dssPtr + 56 >> 2],
"depthBiasSlopeScale": HEAPF32[dssPtr + 60 >> 2],
"depthBiasClamp": HEAPF32[dssPtr + 64 >> 2]
}
}
function makeVertexAttribute(vaPtr) {
return {
"format": WebGPU.VertexFormat[HEAPU32[vaPtr >> 2]],
"offset": HEAPU32[vaPtr + 4 + 8 >> 2] * 4294967296 + HEAPU32[vaPtr + 8 >> 2],
"shaderLocation": HEAPU32[vaPtr + 16 >> 2]
}
}
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 undefined;
return {
"arrayStride": HEAPU32[vbPtr + 4 >> 2] * 4294967296 + HEAPU32[vbPtr >> 2],
"stepMode": WebGPU.VertexStepMode[HEAPU32[vbPtr + 8 >> 2]],
"attributes": makeVertexAttributes(HEAPU32[vbPtr + 12 >> 2], HEAPU32[vbPtr + 16 >> 2])
}
}
function makeVertexBuffers(count, vbArrayPtr) {
if (!count) return undefined;
var vbs = [];
for (var i = 0; i < count; ++i) {
vbs.push(makeVertexBuffer(vbArrayPtr + i * 24))
}
return vbs
}
function makeVertexState(viPtr) {
if (!viPtr) return undefined;
return {
"module": WebGPU.mgrShaderModule.get(HEAPU32[viPtr + 4 >> 2]),
"entryPoint": UTF8ToString(HEAPU32[viPtr + 8 >> 2]),
"constants": WebGPU.makePipelineConstants(HEAPU32[viPtr + 12 >> 2], HEAPU32[viPtr + 16 >> 2]),
"buffers": makeVertexBuffers(HEAPU32[viPtr + 20 >> 2], HEAPU32[viPtr + 24 >> 2])
}
}
function makeMultisampleState(msPtr) {
if (!msPtr) return undefined;
return {
"count": HEAPU32[msPtr + 4 >> 2],
"mask": HEAPU32[msPtr + 8 >> 2],
"alphaToCoverageEnabled": HEAP8[msPtr + 12 >> 0] !== 0
}
}
function makeFragmentState(fsPtr) {
if (!fsPtr) return undefined;
return {
"module": WebGPU.mgrShaderModule.get(HEAPU32[fsPtr + 4 >> 2]),
"entryPoint": UTF8ToString(HEAPU32[fsPtr + 8 >> 2]),
"constants": WebGPU.makePipelineConstants(HEAPU32[fsPtr + 12 >> 2], HEAPU32[fsPtr + 16 >> 2]),
"targets": makeColorStates(HEAPU32[fsPtr + 20 >> 2], HEAPU32[fsPtr + 24 >> 2])
}
}
var desc = {
"label": undefined,
"layout": WebGPU.mgrPipelineLayout.get(HEAPU32[descriptor + 8 >> 2]),
"vertex": makeVertexState(descriptor + 12),
"primitive": makePrimitiveState(descriptor + 40),
"depthStencil": makeDepthStencilState(HEAPU32[descriptor + 60 >> 2]),
"multisample": makeMultisampleState(descriptor + 64),
"fragment": makeFragmentState(HEAPU32[descriptor + 80 >> 2])
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrRenderPipeline.create(device["createRenderPipeline"](desc))
}
function _wgpuDeviceCreateSampler(deviceId, descriptor) {
var desc = {
"label": undefined,
"addressModeU": WebGPU.AddressMode[HEAPU32[descriptor + 8 >> 2]],
"addressModeV": WebGPU.AddressMode[HEAPU32[descriptor + 12 >> 2]],
"addressModeW": WebGPU.AddressMode[HEAPU32[descriptor + 16 >> 2]],
"magFilter": WebGPU.FilterMode[HEAPU32[descriptor + 20 >> 2]],
"minFilter": WebGPU.FilterMode[HEAPU32[descriptor + 24 >> 2]],
"mipmapFilter": WebGPU.FilterMode[HEAPU32[descriptor + 28 >> 2]],
"lodMinClamp": HEAPF32[descriptor + 32 >> 2],
"lodMaxClamp": HEAPF32[descriptor + 36 >> 2],
"compare": WebGPU.CompareFunction[HEAPU32[descriptor + 40 >> 2]]
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrSampler.create(device["createSampler"](desc))
}
function _wgpuDeviceCreateShaderModule(deviceId, descriptor) {
var nextInChainPtr = HEAPU32[descriptor >> 2];
var sType = HEAPU32[nextInChainPtr + 4 >> 2];
var desc = {
"label": undefined,
"code": ""
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
switch (sType) {
case 5: {
var count = HEAPU32[nextInChainPtr + 8 >> 2];
var start = HEAPU32[nextInChainPtr + 12 >> 2];
desc["code"] = HEAPU32.subarray(start >> 2, (start >> 2) + count);
break
}
case 6: {
var sourcePtr = HEAPU32[nextInChainPtr + 8 >> 2];
if (sourcePtr) {
desc["code"] = UTF8ToString(sourcePtr)
}
break
}
}
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrShaderModule.create(device["createShaderModule"](desc))
}
function _wgpuDeviceCreateSwapChain(deviceId, surfaceId, descriptor) {
var device = WebGPU.mgrDevice.get(deviceId);
var context = WebGPU.mgrSurface.get(surfaceId);
var canvasSize = [HEAPU32[descriptor + 16 >> 2], HEAPU32[descriptor + 20 >> 2]];
if (canvasSize[0] !== 0) {
context["canvas"]["width"] = canvasSize[0]
}
if (canvasSize[1] !== 0) {
context["canvas"]["height"] = canvasSize[1]
}
var configuration = {
"device": device,
"format": WebGPU.TextureFormat[HEAPU32[descriptor + 12 >> 2]],
"usage": HEAPU32[descriptor + 8 >> 2],
"alphaMode": "opaque"
};
context["configure"](configuration);
return WebGPU.mgrSwapChain.create(context)
}
function _wgpuDeviceCreateTexture(deviceId, descriptor) {
var desc = {
"label": undefined,
"size": WebGPU.makeExtent3D(descriptor + 16),
"mipLevelCount": HEAPU32[descriptor + 32 >> 2],
"sampleCount": HEAPU32[descriptor + 36 >> 2],
"dimension": WebGPU.TextureDimension[HEAPU32[descriptor + 12 >> 2]],
"format": WebGPU.TextureFormat[HEAPU32[descriptor + 28 >> 2]],
"usage": HEAPU32[descriptor + 8 >> 2]
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr);
var viewFormatCount = HEAPU32[descriptor + 40 >> 2];
if (viewFormatCount) {
var viewFormatsPtr = HEAPU32[descriptor + 44 >> 2];
desc["viewFormats"] = Array.from(HEAP32.subarray(viewFormatsPtr >> 2, (viewFormatsPtr >> 2) + viewFormatCount), function(format) {
return WebGPU.TextureFormat[format]
})
}
var device = WebGPU.mgrDevice.get(deviceId);
return WebGPU.mgrTexture.create(device["createTexture"](desc))
}
function _wgpuDeviceGetQueue(deviceId) {
var queueId = WebGPU.mgrDevice.objects[deviceId].queueId;
WebGPU.mgrQueue.reference(queueId);
return queueId
}
function _wgpuDeviceRelease(id) {
WebGPU.mgrDevice.release(id)
}
function maybeCStringToJsString(cString) {
return cString > 2 ? UTF8ToString(cString) : cString
}
var specialHTMLTargets = [0, document, window];
function findEventTarget(target) {
target = maybeCStringToJsString(target);
var domElement = specialHTMLTargets[target] || document.querySelector(target);
return domElement
}
function findCanvasEventTarget(target) {
return findEventTarget(target)
}
function _wgpuInstanceCreateSurface(instanceId, descriptor) {
var nextInChainPtr = HEAPU32[descriptor >> 2];
var descriptorFromCanvasHTMLSelector = nextInChainPtr;
var selectorPtr = HEAPU32[descriptorFromCanvasHTMLSelector + 8 >> 2];
var canvas = findCanvasEventTarget(selectorPtr);
var context = canvas.getContext("webgpu");
if (!context) return 0;
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) context.surfaceLabelWebGPU = UTF8ToString(labelPtr);
return WebGPU.mgrSurface.create(context)
}
function _wgpuInstanceRelease() {}
function callUserCallback(func) {
if (ABORT) {
return
}
try {
func()
} catch (e) {
handleException(e)
}
}
function allocateUTF8(str) {
var size = lengthBytesUTF8(str) + 1;
var ret = _malloc(size);
if (ret) stringToUTF8Array(str, HEAP8, ret, size);
return ret
}
function _wgpuInstanceRequestAdapter(instanceId, options, callback, userdata) {
var opts;
if (options) {
opts = {
"powerPreference": WebGPU.PowerPreference[HEAPU32[options + 8 >> 2]],
"forceFallbackAdapter": HEAP8[options + 12 >> 0] !== 0
}
}
if (!("gpu" in navigator)) {
var messagePtr = allocateUTF8("WebGPU not available on this browser (navigator.gpu is not available)");
getWasmTableEntry(callback)(1, 0, messagePtr, userdata);
_free(messagePtr);
return
}
navigator["gpu"]["requestAdapter"](opts).then(function(adapter) {
callUserCallback(function() {
if (adapter) {
var adapterId = WebGPU.mgrAdapter.create(adapter);
getWasmTableEntry(callback)(0, adapterId, 0, userdata)
} else {
var messagePtr = allocateUTF8("WebGPU not available on this system (requestAdapter returned null)");
getWasmTableEntry(callback)(1, 0, messagePtr, userdata);
_free(messagePtr)
}
})
}, function(ex) {
callUserCallback(function() {
var messagePtr = allocateUTF8(ex.message);
getWasmTableEntry(callback)(2, 0, messagePtr, userdata);
_free(messagePtr)
})
})
}
function _wgpuPipelineLayoutRelease(id) {
WebGPU.mgrPipelineLayout.release(id)
}
function _wgpuQuerySetDestroy(querySetId) {
WebGPU.mgrQuerySet.get(querySetId)["destroy"]()
}
function _wgpuQuerySetRelease(id) {
WebGPU.mgrQuerySet.release(id)
}
function _wgpuQueueOnSubmittedWorkDone(queueId, signalValue_low, signalValue_high, callback, userdata) {
var queue = WebGPU.mgrQueue.get(queueId);
queue["onSubmittedWorkDone"]().then(function() {
callUserCallback(function() {
getWasmTableEntry(callback)(0, userdata)
})
}, function() {
callUserCallback(function() {
getWasmTableEntry(callback)(1, userdata)
})
})
}
function _wgpuQueueRelease(id) {
WebGPU.mgrQueue.release(id)
}
function _wgpuQueueSubmit(queueId, commandCount, commands) {
var queue = WebGPU.mgrQueue.get(queueId);
var cmds = Array.from(HEAP32.subarray(commands >> 2, (commands >> 2) + commandCount), function(id) {
return WebGPU.mgrCommandBuffer.get(id)
});
queue["submit"](cmds)
}
function _wgpuQueueWriteBuffer(queueId, bufferId, bufferOffset_low, bufferOffset_high, data, size) {
var queue = WebGPU.mgrQueue.get(queueId);
var buffer = WebGPU.mgrBuffer.get(bufferId);
var bufferOffset = bufferOffset_high * 4294967296 + bufferOffset_low;
var subarray = HEAPU8.subarray(data, data + size);
queue["writeBuffer"](buffer, bufferOffset, subarray, 0, size)
}
function _wgpuQueueWriteTexture(queueId, destinationPtr, data, dataSize, dataLayoutPtr, writeSizePtr) {
var queue = WebGPU.mgrQueue.get(queueId);
var destination = WebGPU.makeImageCopyTexture(destinationPtr);
var dataLayout = WebGPU.makeTextureDataLayout(dataLayoutPtr);
var writeSize = WebGPU.makeExtent3D(writeSizePtr);
var subarray = HEAPU8.subarray(data, data + dataSize);
queue["writeTexture"](destination, subarray, dataLayout, writeSize)
}
function _wgpuRenderPassEncoderDraw(passId, vertexCount, instanceCount, firstVertex, firstInstance) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
pass["draw"](vertexCount, instanceCount, firstVertex, firstInstance)
}
function _wgpuRenderPassEncoderDrawIndexed(passId, indexCount, instanceCount, firstIndex, baseVertex, firstInstance) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
pass["drawIndexed"](indexCount, instanceCount, firstIndex, baseVertex, firstInstance)
}
function _wgpuRenderPassEncoderDrawIndirect(passId, indirectBufferId, indirectOffset_low, indirectOffset_high) {
var indirectBuffer = WebGPU.mgrBuffer.get(indirectBufferId);
var indirectOffset = indirectOffset_high * 4294967296 + indirectOffset_low;
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
pass["drawIndirect"](indirectBuffer, indirectOffset)
}
function _wgpuRenderPassEncoderEnd(passId) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
pass["end"]()
}
function _wgpuRenderPassEncoderRelease(id) {
WebGPU.mgrRenderPassEncoder.release(id)
}
function _wgpuRenderPassEncoderSetBindGroup(passId, groupIndex, groupId, dynamicOffsetCount, dynamicOffsetsPtr) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
var group = WebGPU.mgrBindGroup.get(groupId);
if (dynamicOffsetCount == 0) {
pass["setBindGroup"](groupIndex, group)
} else {
var offsets = [];
for (var i = 0; i < dynamicOffsetCount; i++, dynamicOffsetsPtr += 4) {
offsets.push(HEAPU32[dynamicOffsetsPtr >> 2])
}
pass["setBindGroup"](groupIndex, group, offsets)
}
}
function _wgpuRenderPassEncoderSetBlendConstant(passId, colorPtr) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
var color = WebGPU.makeColor(colorPtr);
pass["setBlendConstant"](color)
}
function _wgpuRenderPassEncoderSetIndexBuffer(passId, bufferId, format, offset_low, offset_high, size_low, size_high) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
var buffer = WebGPU.mgrBuffer.get(bufferId);
var offset = offset_high * 4294967296 + offset_low;
var size = size_high === -1 && size_low === -1 ? undefined : size_high * 4294967296 + size_low;
pass["setIndexBuffer"](buffer, WebGPU.IndexFormat[format], offset, size)
}
function _wgpuRenderPassEncoderSetPipeline(passId, pipelineId) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
var pipeline = WebGPU.mgrRenderPipeline.get(pipelineId);
pass["setPipeline"](pipeline)
}
function _wgpuRenderPassEncoderSetScissorRect(passId, x, y, w, h) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
pass["setScissorRect"](x, y, w, h)
}
function _wgpuRenderPassEncoderSetStencilReference(passId, reference) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
pass["setStencilReference"](reference)
}
function _wgpuRenderPassEncoderSetVertexBuffer(passId, slot, bufferId, offset_low, offset_high, size_low, size_high) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
var buffer = WebGPU.mgrBuffer.get(bufferId);
var offset = offset_high * 4294967296 + offset_low;
var size = size_high === -1 && size_low === -1 ? undefined : size_high * 4294967296 + size_low;
pass["setVertexBuffer"](slot, buffer, offset, size)
}
function _wgpuRenderPassEncoderSetViewport(passId, x, y, w, h, minDepth, maxDepth) {
var pass = WebGPU.mgrRenderPassEncoder.get(passId);
pass["setViewport"](x, y, w, h, minDepth, maxDepth)
}
function _wgpuRenderPipelineRelease(id) {
WebGPU.mgrRenderPipeline.release(id)
}
function _wgpuSamplerRelease(id) {
WebGPU.mgrSampler.release(id)
}
function _wgpuShaderModuleRelease(id) {
WebGPU.mgrShaderModule.release(id)
}
function _wgpuSurfaceRelease(id) {
WebGPU.mgrSurface.release(id)
}
function _wgpuSwapChainGetCurrentTextureView(swapChainId) {
var context = WebGPU.mgrSwapChain.get(swapChainId);
return WebGPU.mgrTextureView.create(context["getCurrentTexture"]()["createView"]())
}
function _wgpuSwapChainRelease(id) {
WebGPU.mgrSwapChain.release(id)
}
function _wgpuTextureCreateView(textureId, descriptor) {
var desc;
if (descriptor) {
var mipLevelCount = HEAPU32[descriptor + 20 >> 2];
var arrayLayerCount = HEAPU32[descriptor + 28 >> 2];
desc = {
"format": WebGPU.TextureFormat[HEAPU32[descriptor + 8 >> 2]],
"dimension": WebGPU.TextureViewDimension[HEAPU32[descriptor + 12 >> 2]],
"baseMipLevel": HEAPU32[descriptor + 16 >> 2],
"mipLevelCount": mipLevelCount === 4294967295 ? undefined : mipLevelCount,
"baseArrayLayer": HEAPU32[descriptor + 24 >> 2],
"arrayLayerCount": arrayLayerCount === 4294967295 ? undefined : arrayLayerCount,
"aspect": WebGPU.TextureAspect[HEAPU32[descriptor + 32 >> 2]]
};
var labelPtr = HEAPU32[descriptor + 4 >> 2];
if (labelPtr) desc["label"] = UTF8ToString(labelPtr)
}
var texture = WebGPU.mgrTexture.get(textureId);
return WebGPU.mgrTextureView.create(texture["createView"](desc))
}
function _wgpuTextureDestroy(textureId) {
WebGPU.mgrTexture.get(textureId)["destroy"]()
}
function _wgpuTextureRelease(id) {
WebGPU.mgrTexture.release(id)
}
function _wgpuTextureViewRelease(id) {
WebGPU.mgrTextureView.release(id)
}
function warnOnce(text) {
if (!warnOnce.shown) warnOnce.shown = {};
if (!warnOnce.shown[text]) {
warnOnce.shown[text] = 1;
err(text)
}
}
InternalError = Module["InternalError"] = extendError(Error, "InternalError");
embind_init_charCodes();
BindingError = Module["BindingError"] = extendError(Error, "BindingError");
init_ClassHandle();
init_embind();
init_RegisteredPointer();
UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
init_emval();
WebGPU.initManagers();
var asmLibraryArg = {
"h": __embind_finalize_value_object,
"Ta": __embind_register_bigint,
"na": __embind_register_bool,
"m": __embind_register_class,
"K": __embind_register_class_class_function,
"q": __embind_register_class_constructor,
"d": __embind_register_class_function,
"c": __embind_register_class_property,
"ma": __embind_register_emval,
"Q": __embind_register_float,
"s": __embind_register_integer,
"r": __embind_register_memory_view,
"R": __embind_register_std_string,
"D": __embind_register_std_wstring,
"i": __embind_register_value_object,
"a": __embind_register_value_object_field,
"oa": __embind_register_void,
"k": __emval_as,
"V": __emval_call_void_method,
"b": __emval_decref,
"W": __emval_get_method_caller,
"g": __emval_get_property,
"l": __emval_incref,
"p": __emval_new_array,
"n": __emval_new_cstring,
"j": __emval_run_destructors,
"o": __emval_set_property,
"f": __emval_take_value,
"e": _abort,
"ka": _emscripten_memcpy_big,
"C": _emscripten_resize_heap,
"Ba": _emscripten_webgpu_get_device,
"ha": _environ_get,
"ia": _environ_sizes_get,
"ja": _fd_write,
"P": _setTempRet0,
"Ga": _wgpuAdapterGetProperties,
"J": _wgpuAdapterHasFeature,
"Da": _wgpuAdapterRelease,
"Ha": _wgpuBindGroupRelease,
"ca": _wgpuBufferDestroy,
"O": _wgpuBufferGetMappedRange,
"ba": _wgpuBufferRelease,
"B": _wgpuBufferUnmap,
"N": _wgpuCommandBufferRelease,
"Ja": _wgpuCommandEncoderBeginComputePass,
"pa": _wgpuCommandEncoderBeginRenderPass,
"Wa": _wgpuCommandEncoderCopyBufferToBuffer,
"da": _wgpuCommandEncoderCopyBufferToTexture,
"Ka": _wgpuCommandEncoderCopyTextureToTexture,
"u": _wgpuCommandEncoderFinish,
"x": _wgpuCommandEncoderRelease,
"Ia": _wgpuComputePassEncoderDispatchWorkgroups,
"Va": _wgpuComputePassEncoderDispatchWorkgroupsIndirect,
"ya": _wgpuComputePassEncoderEnd,
"wa": _wgpuComputePassEncoderRelease,
"Sa": _wgpuComputePassEncoderSetBindGroup,
"Ra": _wgpuComputePassEncoderSetPipeline,
"S": _wgpuComputePipelineRelease,
"M": _wgpuDeviceCreateBindGroup,
"L": _wgpuDeviceCreateBindGroupLayout,
"v": _wgpuDeviceCreateBuffer,
"y": _wgpuDeviceCreateCommandEncoder,
"va": _wgpuDeviceCreateComputePipeline,
"xa": _wgpuDeviceCreatePipelineLayout,
"ua": _wgpuDeviceCreateRenderPipeline,
"ta": _wgpuDeviceCreateSampler,
"G": _wgpuDeviceCreateShaderModule,
"qa": _wgpuDeviceCreateSwapChain,
"E": _wgpuDeviceCreateTexture,
"Y": _wgpuDeviceGetQueue,
"Ca": _wgpuDeviceRelease,
"Aa": _wgpuInstanceCreateSurface,
"Ea": _wgpuInstanceRelease,
"za": _wgpuInstanceRequestAdapter,
"U": _wgpuPipelineLayoutRelease,
"_": _wgpuQuerySetDestroy,
"Z": _wgpuQuerySetRelease,
"Ua": _wgpuQueueOnSubmittedWorkDone,
"I": _wgpuQueueRelease,
"z": _wgpuQueueSubmit,
"ga": _wgpuQueueWriteBuffer,
"X": _wgpuQueueWriteTexture,
"La": _wgpuRenderPassEncoderDraw,
"ea": _wgpuRenderPassEncoderDrawIndexed,
"Xa": _wgpuRenderPassEncoderDrawIndirect,
"la": _wgpuRenderPassEncoderEnd,
"Za": _wgpuRenderPassEncoderRelease,
"A": _wgpuRenderPassEncoderSetBindGroup,
"Pa": _wgpuRenderPassEncoderSetBlendConstant,
"Ya": _wgpuRenderPassEncoderSetIndexBuffer,
"Qa": _wgpuRenderPassEncoderSetPipeline,
"Na": _wgpuRenderPassEncoderSetScissorRect,
"Ma": _wgpuRenderPassEncoderSetStencilReference,
"fa": _wgpuRenderPassEncoderSetVertexBuffer,
"Oa": _wgpuRenderPassEncoderSetViewport,
"T": _wgpuRenderPipelineRelease,
"sa": _wgpuSamplerRelease,
"H": _wgpuShaderModuleRelease,
"Fa": _wgpuSurfaceRelease,
"F": _wgpuSwapChainGetCurrentTextureView,
"ra": _wgpuSwapChainRelease,
"w": _wgpuTextureCreateView,
"aa": _wgpuTextureDestroy,
"$": _wgpuTextureRelease,
"t": _wgpuTextureViewRelease
};
var asm = createWasm();
var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["$a"]).apply(null, arguments)
};
var _malloc = Module["_malloc"] = function() {
return (_malloc = Module["_malloc"] = Module["asm"]["bb"]).apply(null, arguments)
};
var _free = Module["_free"] = function() {
return (_free = Module["_free"] = Module["asm"]["cb"]).apply(null, arguments)
};
var ___getTypeName = Module["___getTypeName"] = function() {
return (___getTypeName = Module["___getTypeName"] = Module["asm"]["db"]).apply(null, arguments)
};
var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = function() {
return (___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = Module["asm"]["eb"]).apply(null, arguments)
};
var dynCall_jii = Module["dynCall_jii"] = function() {
return (dynCall_jii = Module["dynCall_jii"] = Module["asm"]["fb"]).apply(null, arguments)
};
var dynCall_viij = Module["dynCall_viij"] = function() {
return (dynCall_viij = Module["dynCall_viij"] = Module["asm"]["gb"]).apply(null, arguments)
};
var dynCall_jiji = Module["dynCall_jiji"] = function() {
return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["hb"]).apply(null, arguments)
};
var calledRun;
dependenciesFulfilled = function runCaller() {
if (!calledRun) run();
if (!calledRun) dependenciesFulfilled = runCaller
};
function run(args) {
args = args || arguments_;
if (runDependencies > 0) {
return
}
preRun();
if (runDependencies > 0) {
return
}
function doRun() {
if (calledRun) return;
calledRun = true;
Module["calledRun"] = true;
if (ABORT) return;
initRuntime();
readyPromiseResolve(Module);
if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
postRun()
}
if (Module["setStatus"]) {
Module["setStatus"]("Running...");
setTimeout(function() {
setTimeout(function() {
Module["setStatus"]("")
}, 1);
doRun()
}, 1)
} else {
doRun()
}
}
if (Module["preInit"]) {
if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
while (Module["preInit"].length > 0) {
Module["preInit"].pop()()
}
}
run();
return wasmDevice.ready
}
);
})();
export default wasmDevice;