} */(xhr.response || []));
+ }
+ return intArrayFromString(xhr.responseText || '', true);
+ };
+ var lazyArray = this;
+ lazyArray.setDataGetter((chunkNum) => {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof lazyArray.chunks[chunkNum] == 'undefined') {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof lazyArray.chunks[chunkNum] == 'undefined') throw new Error('doXHR failed!');
+ return lazyArray.chunks[chunkNum];
+ });
+
+ if (usesGzip || !datalength) {
+ // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length
+ chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file
+ datalength = this.getter(0).length;
+ chunkSize = datalength;
+ out("LazyFiles on gzip forces download of the whole file when length is accessed");
+ }
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ get length() {
+ if (!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ get chunkSize() {
+ if (!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ }
+
+ if (typeof XMLHttpRequest != 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // Add a function that defers querying the file size until it is asked the first time.
+ Object.defineProperties(node, {
+ usedBytes: {
+ get: function() { return this.contents.length; }
+ }
+ });
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach((key) => {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = (...args) => {
+ FS.forceLoadFile(node);
+ return fn(...args);
+ };
+ });
+ function writeChunks(stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ }
+ // use a custom read function
+ stream_ops.read = (stream, buffer, offset, length, position) => {
+ FS.forceLoadFile(node);
+ return writeChunks(stream, buffer, offset, length, position)
+ };
+ // use a custom mmap function
+ stream_ops.mmap = (stream, length, position, prot, flags) => {
+ FS.forceLoadFile(node);
+ var ptr = mmapAlloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(48);
+ }
+ writeChunks(stream, HEAP8, ptr, length, position);
+ return { ptr, allocated: true };
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },
+ absolutePath() {
+ abort('FS.absolutePath has been removed; use PATH_FS.resolve instead');
+ },
+ createFolder() {
+ abort('FS.createFolder has been removed; use FS.mkdir instead');
+ },
+ createLink() {
+ abort('FS.createLink has been removed; use FS.symlink instead');
+ },
+ joinPath() {
+ abort('FS.joinPath has been removed; use PATH.join instead');
+ },
+ mmapAlloc() {
+ abort('FS.mmapAlloc has been replaced by the top level function mmapAlloc');
+ },
+ standardizePath() {
+ abort('FS.standardizePath has been removed; use PATH.normalize instead');
+ },
+ };
+
+ var SYSCALLS = {
+ DEFAULT_POLLMASK:5,
+ calculateAt(dirfd, path, allowEmpty) {
+ if (PATH.isAbs(path)) {
+ return path;
+ }
+ // relative path
+ var dir;
+ if (dirfd === -100) {
+ dir = FS.cwd();
+ } else {
+ var dirstream = SYSCALLS.getStreamFromFD(dirfd);
+ dir = dirstream.path;
+ }
+ if (path.length == 0) {
+ if (!allowEmpty) {
+ throw new FS.ErrnoError(44);;
+ }
+ return dir;
+ }
+ return PATH.join2(dir, path);
+ },
+ doStat(func, path, buf) {
+ var stat = func(path);
+ HEAP32[((buf)>>2)] = stat.dev;checkInt32(stat.dev);
+ HEAP32[(((buf)+(4))>>2)] = stat.mode;checkInt32(stat.mode);
+ HEAPU32[(((buf)+(8))>>2)] = stat.nlink;checkInt32(stat.nlink);
+ HEAP32[(((buf)+(12))>>2)] = stat.uid;checkInt32(stat.uid);
+ HEAP32[(((buf)+(16))>>2)] = stat.gid;checkInt32(stat.gid);
+ HEAP32[(((buf)+(20))>>2)] = stat.rdev;checkInt32(stat.rdev);
+ (tempI64 = [stat.size>>>0,(tempDouble = stat.size,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(24))>>2)] = tempI64[0],HEAP32[(((buf)+(28))>>2)] = tempI64[1]);checkInt64(stat.size);
+ HEAP32[(((buf)+(32))>>2)] = 4096;checkInt32(4096);
+ HEAP32[(((buf)+(36))>>2)] = stat.blocks;checkInt32(stat.blocks);
+ var atime = stat.atime.getTime();
+ var mtime = stat.mtime.getTime();
+ var ctime = stat.ctime.getTime();
+ (tempI64 = [Math.floor(atime / 1000)>>>0,(tempDouble = Math.floor(atime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(40))>>2)] = tempI64[0],HEAP32[(((buf)+(44))>>2)] = tempI64[1]);checkInt64(Math.floor(atime / 1000));
+ HEAPU32[(((buf)+(48))>>2)] = (atime % 1000) * 1000 * 1000;checkInt32((atime % 1000) * 1000 * 1000);
+ (tempI64 = [Math.floor(mtime / 1000)>>>0,(tempDouble = Math.floor(mtime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(56))>>2)] = tempI64[0],HEAP32[(((buf)+(60))>>2)] = tempI64[1]);checkInt64(Math.floor(mtime / 1000));
+ HEAPU32[(((buf)+(64))>>2)] = (mtime % 1000) * 1000 * 1000;checkInt32((mtime % 1000) * 1000 * 1000);
+ (tempI64 = [Math.floor(ctime / 1000)>>>0,(tempDouble = Math.floor(ctime / 1000),(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(72))>>2)] = tempI64[0],HEAP32[(((buf)+(76))>>2)] = tempI64[1]);checkInt64(Math.floor(ctime / 1000));
+ HEAPU32[(((buf)+(80))>>2)] = (ctime % 1000) * 1000 * 1000;checkInt32((ctime % 1000) * 1000 * 1000);
+ (tempI64 = [stat.ino>>>0,(tempDouble = stat.ino,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[(((buf)+(88))>>2)] = tempI64[0],HEAP32[(((buf)+(92))>>2)] = tempI64[1]);checkInt64(stat.ino);
+ return 0;
+ },
+ doMsync(addr, stream, len, flags, offset) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(43);
+ }
+ if (flags & 2) {
+ // MAP_PRIVATE calls need not to be synced back to underlying fs
+ return 0;
+ }
+ var buffer = HEAPU8.slice(addr, addr + len);
+ FS.msync(stream, buffer, offset, len, flags);
+ },
+ getStreamFromFD(fd) {
+ var stream = FS.getStreamChecked(fd);
+ return stream;
+ },
+ varargs:undefined,
+ getStr(ptr) {
+ var ret = UTF8ToString(ptr);
+ return ret;
+ },
+ };
+ function ___syscall_faccessat(dirfd, path, amode, flags) {
+ try {
+
+ path = SYSCALLS.getStr(path);
+ assert(flags === 0 || flags == 512);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ if (amode & ~7) {
+ // need a valid mode
+ return -28;
+ }
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node) {
+ return -44;
+ }
+ var perms = '';
+ if (amode & 4) perms += 'r';
+ if (amode & 2) perms += 'w';
+ if (amode & 1) perms += 'x';
+ if (perms /* otherwise, they've just passed F_OK */ && FS.nodePermissions(node, perms)) {
+ return -2;
+ }
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+ }
+
+ /** @suppress {duplicate } */
+ var syscallGetVarargI = () => {
+ assert(SYSCALLS.varargs != undefined);
+ // the `+` prepended here is necessary to convince the JSCompiler that varargs is indeed a number.
+ var ret = HEAP32[((+SYSCALLS.varargs)>>2)];
+ SYSCALLS.varargs += 4;
+ return ret;
+ };
+ var syscallGetVarargP = syscallGetVarargI;
+
+
+ function ___syscall_fcntl64(fd, cmd, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ switch (cmd) {
+ case 0: {
+ var arg = syscallGetVarargI();
+ if (arg < 0) {
+ return -28;
+ }
+ while (FS.streams[arg]) {
+ arg++;
+ }
+ var newStream;
+ newStream = FS.dupStream(stream, arg);
+ return newStream.fd;
+ }
+ case 1:
+ case 2:
+ return 0; // FD_CLOEXEC makes no sense for a single process.
+ case 3:
+ return stream.flags;
+ case 4: {
+ var arg = syscallGetVarargI();
+ stream.flags |= arg;
+ return 0;
+ }
+ case 12: {
+ var arg = syscallGetVarargP();
+ var offset = 0;
+ // We're always unlocked.
+ HEAP16[(((arg)+(offset))>>1)] = 2;checkInt16(2);
+ return 0;
+ }
+ case 13:
+ case 14:
+ return 0; // Pretend that the locking is successful.
+ }
+ return -28;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+ }
+
+
+ var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
+ assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!');
+ return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+ };
+ function ___syscall_getcwd(buf, size) {
+ try {
+
+ if (size === 0) return -28;
+ var cwd = FS.cwd();
+ var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1;
+ if (size < cwdLengthInBytes) return -68;
+ stringToUTF8(cwd, buf, size);
+ return cwdLengthInBytes;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+ }
+
+
+ function ___syscall_ioctl(fd, op, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ switch (op) {
+ case 21509: {
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ case 21505: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tcgets) {
+ var termios = stream.tty.ops.ioctl_tcgets(stream);
+ var argp = syscallGetVarargP();
+ HEAP32[((argp)>>2)] = termios.c_iflag || 0;checkInt32(termios.c_iflag || 0);
+ HEAP32[(((argp)+(4))>>2)] = termios.c_oflag || 0;checkInt32(termios.c_oflag || 0);
+ HEAP32[(((argp)+(8))>>2)] = termios.c_cflag || 0;checkInt32(termios.c_cflag || 0);
+ HEAP32[(((argp)+(12))>>2)] = termios.c_lflag || 0;checkInt32(termios.c_lflag || 0);
+ for (var i = 0; i < 32; i++) {
+ HEAP8[(argp + i)+(17)] = termios.c_cc[i] || 0;checkInt8(termios.c_cc[i] || 0);
+ }
+ return 0;
+ }
+ return 0;
+ }
+ case 21510:
+ case 21511:
+ case 21512: {
+ if (!stream.tty) return -59;
+ return 0; // no-op, not actually adjusting terminal settings
+ }
+ case 21506:
+ case 21507:
+ case 21508: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tcsets) {
+ var argp = syscallGetVarargP();
+ var c_iflag = HEAP32[((argp)>>2)];
+ var c_oflag = HEAP32[(((argp)+(4))>>2)];
+ var c_cflag = HEAP32[(((argp)+(8))>>2)];
+ var c_lflag = HEAP32[(((argp)+(12))>>2)];
+ var c_cc = []
+ for (var i = 0; i < 32; i++) {
+ c_cc.push(HEAP8[(argp + i)+(17)]);
+ }
+ return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc });
+ }
+ return 0; // no-op, not actually adjusting terminal settings
+ }
+ case 21519: {
+ if (!stream.tty) return -59;
+ var argp = syscallGetVarargP();
+ HEAP32[((argp)>>2)] = 0;checkInt32(0);
+ return 0;
+ }
+ case 21520: {
+ if (!stream.tty) return -59;
+ return -28; // not supported
+ }
+ case 21531: {
+ var argp = syscallGetVarargP();
+ return FS.ioctl(stream, op, argp);
+ }
+ case 21523: {
+ // TODO: in theory we should write to the winsize struct that gets
+ // passed in, but for now musl doesn't read anything on it
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tiocgwinsz) {
+ var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
+ var argp = syscallGetVarargP();
+ HEAP16[((argp)>>1)] = winsize[0];checkInt16(winsize[0]);
+ HEAP16[(((argp)+(2))>>1)] = winsize[1];checkInt16(winsize[1]);
+ }
+ return 0;
+ }
+ case 21524: {
+ // TODO: technically, this ioctl call should change the window size.
+ // but, since emscripten doesn't have any concept of a terminal window
+ // yet, we'll just silently throw it away as we do TIOCGWINSZ
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ case 21515: {
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ default: return -28; // not supported
+ }
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+ }
+
+
+ function ___syscall_openat(dirfd, path, flags, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ var mode = varargs ? syscallGetVarargI() : 0;
+ return FS.open(path, flags, mode).fd;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+ }
+
+ var __abort_js = () => {
+ abort('native code called abort()');
+ };
+
+ var nowIsMonotonic = 1;
+ var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;
+
+ var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
+
+ var _emscripten_date_now = () => Date.now();
+
+ var JSEvents = {
+ memcpy(target, src, size) {
+ HEAP8.set(HEAP8.subarray(src, src + size), target);
+ },
+ removeAllEventListeners() {
+ while (JSEvents.eventHandlers.length) {
+ JSEvents._removeHandler(JSEvents.eventHandlers.length - 1);
+ }
+ JSEvents.deferredCalls = [];
+ },
+ inEventHandler:0,
+ deferredCalls:[],
+ deferCall(targetFunction, precedence, argsList) {
+ function arraysHaveEqualContent(arrA, arrB) {
+ if (arrA.length != arrB.length) return false;
+
+ for (var i in arrA) {
+ if (arrA[i] != arrB[i]) return false;
+ }
+ return true;
+ }
+ // Test if the given call was already queued, and if so, don't add it again.
+ for (var call of JSEvents.deferredCalls) {
+ if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
+ return;
+ }
+ }
+ JSEvents.deferredCalls.push({
+ targetFunction,
+ precedence,
+ argsList
+ });
+
+ JSEvents.deferredCalls.sort((x,y) => x.precedence < y.precedence);
+ },
+ removeDeferredCalls(targetFunction) {
+ JSEvents.deferredCalls = JSEvents.deferredCalls.filter((call) => call.targetFunction != targetFunction);
+ },
+ canPerformEventHandlerRequests() {
+ if (navigator.userActivation) {
+ // Verify against transient activation status from UserActivation API
+ // whether it is possible to perform a request here without needing to defer. See
+ // https://developer.mozilla.org/en-US/docs/Web/Security/User_activation#transient_activation
+ // and https://caniuse.com/mdn-api_useractivation
+ // At the time of writing, Firefox does not support this API: https://bugzilla.mozilla.org/show_bug.cgi?id=1791079
+ return navigator.userActivation.isActive;
+ }
+
+ return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls;
+ },
+ runDeferredCalls() {
+ if (!JSEvents.canPerformEventHandlerRequests()) {
+ return;
+ }
+ var deferredCalls = JSEvents.deferredCalls;
+ JSEvents.deferredCalls = [];
+ for (var call of deferredCalls) {
+ call.targetFunction(...call.argsList);
+ }
+ },
+ eventHandlers:[],
+ removeAllHandlersOnTarget:(target, eventTypeString) => {
+ for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
+ if (JSEvents.eventHandlers[i].target == target &&
+ (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {
+ JSEvents._removeHandler(i--);
+ }
+ }
+ },
+ _removeHandler(i) {
+ var h = JSEvents.eventHandlers[i];
+ h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);
+ JSEvents.eventHandlers.splice(i, 1);
+ },
+ registerOrRemoveHandler(eventHandler) {
+ if (!eventHandler.target) {
+ err('registerOrRemoveHandler: the target element for event handler registration does not exist, when processing the following event handler registration:');
+ console.dir(eventHandler);
+ return -4;
+ }
+ if (eventHandler.callbackfunc) {
+ eventHandler.eventListenerFunc = function(event) {
+ // Increment nesting count for the event handler.
+ ++JSEvents.inEventHandler;
+ JSEvents.currentEventHandler = eventHandler;
+ // Process any old deferred calls the user has placed.
+ JSEvents.runDeferredCalls();
+ // Process the actual event, calls back to user C code handler.
+ eventHandler.handlerFunc(event);
+ // Process any new deferred calls that were placed right now from this event handler.
+ JSEvents.runDeferredCalls();
+ // Out of event handler - restore nesting count.
+ --JSEvents.inEventHandler;
+ };
+
+ eventHandler.target.addEventListener(eventHandler.eventTypeString,
+ eventHandler.eventListenerFunc,
+ eventHandler.useCapture);
+ JSEvents.eventHandlers.push(eventHandler);
+ } else {
+ for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
+ if (JSEvents.eventHandlers[i].target == eventHandler.target
+ && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
+ JSEvents._removeHandler(i--);
+ }
+ }
+ }
+ return 0;
+ },
+ getNodeNameForTarget(target) {
+ if (!target) return '';
+ if (target == window) return '#window';
+ if (target == screen) return '#screen';
+ return target?.nodeName || '';
+ },
+ fullscreenEnabled() {
+ return document.fullscreenEnabled
+ // Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitFullscreenEnabled.
+ // TODO: If Safari at some point ships with unprefixed version, update the version check above.
+ || document.webkitFullscreenEnabled
+ ;
+ },
+ };
+
+ var maybeCStringToJsString = (cString) => {
+ // "cString > 2" checks if the input is a number, and isn't of the special
+ // values we accept here, EMSCRIPTEN_EVENT_TARGET_* (which map to 0, 1, 2).
+ // In other words, if cString > 2 then it's a pointer to a valid place in
+ // memory, and points to a C string.
+ return cString > 2 ? UTF8ToString(cString) : cString;
+ };
+
+ /** @type {Object} */
+ var specialHTMLTargets = [0, typeof document != 'undefined' ? document : 0, typeof window != 'undefined' ? window : 0];
+ var findEventTarget = (target) => {
+ target = maybeCStringToJsString(target);
+ var domElement = specialHTMLTargets[target] || (typeof document != 'undefined' ? document.querySelector(target) : undefined);
+ return domElement;
+ };
+
+ var getBoundingClientRect = (e) => specialHTMLTargets.indexOf(e) < 0 ? e.getBoundingClientRect() : {'left':0,'top':0};
+ var _emscripten_get_element_css_size = (target, width, height) => {
+ target = findEventTarget(target);
+ if (!target) return -4;
+
+ var rect = getBoundingClientRect(target);
+ HEAPF64[((width)>>3)] = rect.width;
+ HEAPF64[((height)>>3)] = rect.height;
+
+ return 0;
+ };
+
+
+ var fillGamepadEventData = (eventStruct, e) => {
+ HEAPF64[((eventStruct)>>3)] = e.timestamp;
+ for (var i = 0; i < e.axes.length; ++i) {
+ HEAPF64[(((eventStruct+i*8)+(16))>>3)] = e.axes[i];
+ }
+ for (var i = 0; i < e.buttons.length; ++i) {
+ if (typeof e.buttons[i] == 'object') {
+ HEAPF64[(((eventStruct+i*8)+(528))>>3)] = e.buttons[i].value;
+ } else {
+ HEAPF64[(((eventStruct+i*8)+(528))>>3)] = e.buttons[i];
+ }
+ }
+ for (var i = 0; i < e.buttons.length; ++i) {
+ if (typeof e.buttons[i] == 'object') {
+ HEAP8[(eventStruct+i)+(1040)] = e.buttons[i].pressed;checkInt8(e.buttons[i].pressed);
+ } else {
+ // Assigning a boolean to HEAP32, that's ok, but Closure would like to warn about it:
+ /** @suppress {checkTypes} */
+ HEAP8[(eventStruct+i)+(1040)] = e.buttons[i] == 1;checkInt8(e.buttons[i] == 1);
+ }
+ }
+ HEAP8[(eventStruct)+(1104)] = e.connected;checkInt8(e.connected);
+ HEAP32[(((eventStruct)+(1108))>>2)] = e.index;checkInt32(e.index);
+ HEAP32[(((eventStruct)+(8))>>2)] = e.axes.length;checkInt32(e.axes.length);
+ HEAP32[(((eventStruct)+(12))>>2)] = e.buttons.length;checkInt32(e.buttons.length);
+ stringToUTF8(e.id, eventStruct + 1112, 64);
+ stringToUTF8(e.mapping, eventStruct + 1176, 64);
+ };
+ var _emscripten_get_gamepad_status = (index, gamepadState) => {
+ if (!JSEvents.lastGamepadState) throw 'emscripten_get_gamepad_status() can only be called after having first called emscripten_sample_gamepad_data() and that function has returned EMSCRIPTEN_RESULT_SUCCESS!';
+ // INVALID_PARAM is returned on a Gamepad index that never was there.
+ if (index < 0 || index >= JSEvents.lastGamepadState.length) return -5;
+
+ // NO_DATA is returned on a Gamepad index that was removed.
+ // For previously disconnected gamepads there should be an empty slot (null/undefined/false) at the index.
+ // This is because gamepads must keep their original position in the array.
+ // For example, removing the first of two gamepads produces [null/undefined/false, gamepad].
+ if (!JSEvents.lastGamepadState[index]) return -7;
+
+ fillGamepadEventData(gamepadState, JSEvents.lastGamepadState[index]);
+ return 0;
+ };
+
+ var _emscripten_get_now = () => performance.now();
+
+ var _emscripten_get_num_gamepads = () => {
+ if (!JSEvents.lastGamepadState) throw 'emscripten_get_num_gamepads() can only be called after having first called emscripten_sample_gamepad_data() and that function has returned EMSCRIPTEN_RESULT_SUCCESS!';
+ // N.B. Do not call emscripten_get_num_gamepads() unless having first called emscripten_sample_gamepad_data(), and that has returned EMSCRIPTEN_RESULT_SUCCESS.
+ // Otherwise the following line will throw an exception.
+ return JSEvents.lastGamepadState.length;
+ };
+
+ var GLctx;
+
+ var webgl_enable_ANGLE_instanced_arrays = (ctx) => {
+ // Extension available in WebGL 1 from Firefox 26 and Google Chrome 30 onwards. Core feature in WebGL 2.
+ var ext = ctx.getExtension('ANGLE_instanced_arrays');
+ // Because this extension is a core function in WebGL 2, assign the extension entry points in place of
+ // where the core functions will reside in WebGL 2. This way the calling code can call these without
+ // having to dynamically branch depending if running against WebGL 1 or WebGL 2.
+ if (ext) {
+ ctx['vertexAttribDivisor'] = (index, divisor) => ext['vertexAttribDivisorANGLE'](index, divisor);
+ ctx['drawArraysInstanced'] = (mode, first, count, primcount) => ext['drawArraysInstancedANGLE'](mode, first, count, primcount);
+ ctx['drawElementsInstanced'] = (mode, count, type, indices, primcount) => ext['drawElementsInstancedANGLE'](mode, count, type, indices, primcount);
+ return 1;
+ }
+ };
+
+ var webgl_enable_OES_vertex_array_object = (ctx) => {
+ // Extension available in WebGL 1 from Firefox 25 and WebKit 536.28/desktop Safari 6.0.3 onwards. Core feature in WebGL 2.
+ var ext = ctx.getExtension('OES_vertex_array_object');
+ if (ext) {
+ ctx['createVertexArray'] = () => ext['createVertexArrayOES']();
+ ctx['deleteVertexArray'] = (vao) => ext['deleteVertexArrayOES'](vao);
+ ctx['bindVertexArray'] = (vao) => ext['bindVertexArrayOES'](vao);
+ ctx['isVertexArray'] = (vao) => ext['isVertexArrayOES'](vao);
+ return 1;
+ }
+ };
+
+ var webgl_enable_WEBGL_draw_buffers = (ctx) => {
+ // Extension available in WebGL 1 from Firefox 28 onwards. Core feature in WebGL 2.
+ var ext = ctx.getExtension('WEBGL_draw_buffers');
+ if (ext) {
+ ctx['drawBuffers'] = (n, bufs) => ext['drawBuffersWEBGL'](n, bufs);
+ return 1;
+ }
+ };
+
+ var webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance = (ctx) =>
+ // Closure is expected to be allowed to minify the '.dibvbi' property, so not accessing it quoted.
+ !!(ctx.dibvbi = ctx.getExtension('WEBGL_draw_instanced_base_vertex_base_instance'));
+
+ var webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance = (ctx) => {
+ // Closure is expected to be allowed to minify the '.mdibvbi' property, so not accessing it quoted.
+ return !!(ctx.mdibvbi = ctx.getExtension('WEBGL_multi_draw_instanced_base_vertex_base_instance'));
+ };
+
+ var webgl_enable_EXT_polygon_offset_clamp = (ctx) => {
+ return !!(ctx.extPolygonOffsetClamp = ctx.getExtension('EXT_polygon_offset_clamp'));
+ };
+
+ var webgl_enable_EXT_clip_control = (ctx) => {
+ return !!(ctx.extClipControl = ctx.getExtension('EXT_clip_control'));
+ };
+
+ var webgl_enable_WEBGL_polygon_mode = (ctx) => {
+ return !!(ctx.webglPolygonMode = ctx.getExtension('WEBGL_polygon_mode'));
+ };
+
+ var webgl_enable_WEBGL_multi_draw = (ctx) => {
+ // Closure is expected to be allowed to minify the '.multiDrawWebgl' property, so not accessing it quoted.
+ return !!(ctx.multiDrawWebgl = ctx.getExtension('WEBGL_multi_draw'));
+ };
+
+ var getEmscriptenSupportedExtensions = (ctx) => {
+ // Restrict the list of advertised extensions to those that we actually
+ // support.
+ var supportedExtensions = [
+ // WebGL 1 extensions
+ 'ANGLE_instanced_arrays',
+ 'EXT_blend_minmax',
+ 'EXT_disjoint_timer_query',
+ 'EXT_frag_depth',
+ 'EXT_shader_texture_lod',
+ 'EXT_sRGB',
+ 'OES_element_index_uint',
+ 'OES_fbo_render_mipmap',
+ 'OES_standard_derivatives',
+ 'OES_texture_float',
+ 'OES_texture_half_float',
+ 'OES_texture_half_float_linear',
+ 'OES_vertex_array_object',
+ 'WEBGL_color_buffer_float',
+ 'WEBGL_depth_texture',
+ 'WEBGL_draw_buffers',
+ // WebGL 2 extensions
+ 'EXT_color_buffer_float',
+ 'EXT_conservative_depth',
+ 'EXT_disjoint_timer_query_webgl2',
+ 'EXT_texture_norm16',
+ 'NV_shader_noperspective_interpolation',
+ 'WEBGL_clip_cull_distance',
+ // WebGL 1 and WebGL 2 extensions
+ 'EXT_clip_control',
+ 'EXT_color_buffer_half_float',
+ 'EXT_depth_clamp',
+ 'EXT_float_blend',
+ 'EXT_polygon_offset_clamp',
+ 'EXT_texture_compression_bptc',
+ 'EXT_texture_compression_rgtc',
+ 'EXT_texture_filter_anisotropic',
+ 'KHR_parallel_shader_compile',
+ 'OES_texture_float_linear',
+ 'WEBGL_blend_func_extended',
+ 'WEBGL_compressed_texture_astc',
+ 'WEBGL_compressed_texture_etc',
+ 'WEBGL_compressed_texture_etc1',
+ 'WEBGL_compressed_texture_s3tc',
+ 'WEBGL_compressed_texture_s3tc_srgb',
+ 'WEBGL_debug_renderer_info',
+ 'WEBGL_debug_shaders',
+ 'WEBGL_lose_context',
+ 'WEBGL_multi_draw',
+ 'WEBGL_polygon_mode'
+ ];
+ // .getSupportedExtensions() can return null if context is lost, so coerce to empty array.
+ return (ctx.getSupportedExtensions() || []).filter(ext => supportedExtensions.includes(ext));
+ };
+
+
+ var GL = {
+ counter:1,
+ buffers:[],
+ programs:[],
+ framebuffers:[],
+ renderbuffers:[],
+ textures:[],
+ shaders:[],
+ vaos:[],
+ contexts:[],
+ offscreenCanvases:{
+ },
+ queries:[],
+ samplers:[],
+ transformFeedbacks:[],
+ syncs:[],
+ stringCache:{
+ },
+ stringiCache:{
+ },
+ unpackAlignment:4,
+ unpackRowLength:0,
+ recordError:(errorCode) => {
+ if (!GL.lastError) {
+ GL.lastError = errorCode;
+ }
+ },
+ getNewId:(table) => {
+ var ret = GL.counter++;
+ for (var i = table.length; i < ret; i++) {
+ table[i] = null;
+ }
+ return ret;
+ },
+ genObject:(n, buffers, createFunction, objectTable
+ ) => {
+ for (var i = 0; i < n; i++) {
+ var buffer = GLctx[createFunction]();
+ var id = buffer && GL.getNewId(objectTable);
+ if (buffer) {
+ buffer.name = id;
+ objectTable[id] = buffer;
+ } else {
+ GL.recordError(0x502 /* GL_INVALID_OPERATION */);
+ }
+ HEAP32[(((buffers)+(i*4))>>2)] = id;checkInt32(id);
+ }
+ },
+ getSource:(shader, count, string, length) => {
+ var source = '';
+ for (var i = 0; i < count; ++i) {
+ var len = length ? HEAPU32[(((length)+(i*4))>>2)] : undefined;
+ source += UTF8ToString(HEAPU32[(((string)+(i*4))>>2)], len);
+ }
+ return source;
+ },
+ createContext:(/** @type {HTMLCanvasElement} */ canvas, webGLContextAttributes) => {
+
+ // BUG: Workaround Safari WebGL issue: After successfully acquiring WebGL
+ // context on a canvas, calling .getContext() will always return that
+ // context independent of which 'webgl' or 'webgl2'
+ // context version was passed. See:
+ // https://bugs.webkit.org/show_bug.cgi?id=222758
+ // and:
+ // https://github.com/emscripten-core/emscripten/issues/13295.
+ // TODO: Once the bug is fixed and shipped in Safari, adjust the Safari
+ // version field in above check.
+ if (!canvas.getContextSafariWebGL2Fixed) {
+ canvas.getContextSafariWebGL2Fixed = canvas.getContext;
+ /** @type {function(this:HTMLCanvasElement, string, (Object|null)=): (Object|null)} */
+ function fixedGetContext(ver, attrs) {
+ var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);
+ return ((ver == 'webgl') == (gl instanceof WebGLRenderingContext)) ? gl : null;
+ }
+ canvas.getContext = fixedGetContext;
+ }
+
+ var ctx =
+ (webGLContextAttributes.majorVersion > 1)
+ ?
+ canvas.getContext("webgl2", webGLContextAttributes)
+ :
+ (canvas.getContext("webgl", webGLContextAttributes)
+ // https://caniuse.com/#feat=webgl
+ );
+
+ if (!ctx) return 0;
+
+ var handle = GL.registerContext(ctx, webGLContextAttributes);
+
+ return handle;
+ },
+ registerContext:(ctx, webGLContextAttributes) => {
+ // without pthreads a context is just an integer ID
+ var handle = GL.getNewId(GL.contexts);
+
+ var context = {
+ handle,
+ attributes: webGLContextAttributes,
+ version: webGLContextAttributes.majorVersion,
+ GLctx: ctx
+ };
+
+ // Store the created context object so that we can access the context
+ // given a canvas without having to pass the parameters again.
+ if (ctx.canvas) ctx.canvas.GLctxObject = context;
+ GL.contexts[handle] = context;
+ if (typeof webGLContextAttributes.enableExtensionsByDefault == 'undefined' || webGLContextAttributes.enableExtensionsByDefault) {
+ GL.initExtensions(context);
+ }
+
+ return handle;
+ },
+ makeContextCurrent:(contextHandle) => {
+
+ // Active Emscripten GL layer context object.
+ GL.currentContext = GL.contexts[contextHandle];
+ // Active WebGL context object.
+ Module.ctx = GLctx = GL.currentContext?.GLctx;
+ return !(contextHandle && !GLctx);
+ },
+ getContext:(contextHandle) => {
+ return GL.contexts[contextHandle];
+ },
+ deleteContext:(contextHandle) => {
+ if (GL.currentContext === GL.contexts[contextHandle]) {
+ GL.currentContext = null;
+ }
+ if (typeof JSEvents == 'object') {
+ // Release all JS event handlers on the DOM element that the GL context is
+ // associated with since the context is now deleted.
+ JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas);
+ }
+ // Make sure the canvas object no longer refers to the context object so
+ // there are no GC surprises.
+ if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) {
+ GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined;
+ }
+ GL.contexts[contextHandle] = null;
+ },
+ initExtensions:(context) => {
+ // If this function is called without a specific context object, init the
+ // extensions of the currently active context.
+ context ||= GL.currentContext;
+
+ if (context.initExtensionsDone) return;
+ context.initExtensionsDone = true;
+
+ var GLctx = context.GLctx;
+
+ // Detect the presence of a few extensions manually, ction GL interop
+ // layer itself will need to know if they exist.
+
+ // Extensions that are available in both WebGL 1 and WebGL 2
+ webgl_enable_WEBGL_multi_draw(GLctx);
+ webgl_enable_EXT_polygon_offset_clamp(GLctx);
+ webgl_enable_EXT_clip_control(GLctx);
+ webgl_enable_WEBGL_polygon_mode(GLctx);
+ // Extensions that are only available in WebGL 1 (the calls will be no-ops
+ // if called on a WebGL 2 context active)
+ webgl_enable_ANGLE_instanced_arrays(GLctx);
+ webgl_enable_OES_vertex_array_object(GLctx);
+ webgl_enable_WEBGL_draw_buffers(GLctx);
+ // Extensions that are available from WebGL >= 2 (no-op if called on a WebGL 1 context active)
+ webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);
+ webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);
+
+ // On WebGL 2, EXT_disjoint_timer_query is replaced with an alternative
+ // that's based on core APIs, and exposes only the queryCounterEXT()
+ // entrypoint.
+ if (context.version >= 2) {
+ GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2");
+ }
+
+ // However, Firefox exposes the WebGL 1 version on WebGL 2 as well and
+ // thus we look for the WebGL 1 version again if the WebGL 2 version
+ // isn't present. https://bugzilla.mozilla.org/show_bug.cgi?id=1328882
+ if (context.version < 2 || !GLctx.disjointTimerQueryExt)
+ {
+ GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query");
+ }
+
+ getEmscriptenSupportedExtensions(GLctx).forEach((ext) => {
+ // WEBGL_lose_context, WEBGL_debug_renderer_info and WEBGL_debug_shaders
+ // are not enabled by default.
+ if (!ext.includes('lose_context') && !ext.includes('debug')) {
+ // Call .getExtension() to enable that extension permanently.
+ GLctx.getExtension(ext);
+ }
+ });
+ },
+ };
+ /** @suppress {duplicate } */
+ var _glActiveTexture = (x0) => GLctx.activeTexture(x0);
+ var _emscripten_glActiveTexture = _glActiveTexture;
+
+ /** @suppress {duplicate } */
+ var _glAttachShader = (program, shader) => {
+ GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
+ };
+ var _emscripten_glAttachShader = _glAttachShader;
+
+ /** @suppress {duplicate } */
+ var _glBeginQuery = (target, id) => {
+ GLctx.beginQuery(target, GL.queries[id]);
+ };
+ var _emscripten_glBeginQuery = _glBeginQuery;
+
+ /** @suppress {duplicate } */
+ var _glBeginQueryEXT = (target, id) => {
+ GLctx.disjointTimerQueryExt['beginQueryEXT'](target, GL.queries[id]);
+ };
+ var _emscripten_glBeginQueryEXT = _glBeginQueryEXT;
+
+ /** @suppress {duplicate } */
+ var _glBeginTransformFeedback = (x0) => GLctx.beginTransformFeedback(x0);
+ var _emscripten_glBeginTransformFeedback = _glBeginTransformFeedback;
+
+
+ /** @suppress {duplicate } */
+ var _glBindAttribLocation = (program, index, name) => {
+ GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
+ };
+ var _emscripten_glBindAttribLocation = _glBindAttribLocation;
+
+ /** @suppress {duplicate } */
+ var _glBindBuffer = (target, buffer) => {
+
+ if (target == 0x88EB /*GL_PIXEL_PACK_BUFFER*/) {
+ // In WebGL 2 glReadPixels entry point, we need to use a different WebGL 2
+ // API function call when a buffer is bound to
+ // GL_PIXEL_PACK_BUFFER_BINDING point, so must keep track whether that
+ // binding point is non-null to know what is the proper API function to
+ // call.
+ GLctx.currentPixelPackBufferBinding = buffer;
+ } else if (target == 0x88EC /*GL_PIXEL_UNPACK_BUFFER*/) {
+ // In WebGL 2 gl(Compressed)Tex(Sub)Image[23]D entry points, we need to
+ // use a different WebGL 2 API function call when a buffer is bound to
+ // GL_PIXEL_UNPACK_BUFFER_BINDING point, so must keep track whether that
+ // binding point is non-null to know what is the proper API function to
+ // call.
+ GLctx.currentPixelUnpackBufferBinding = buffer;
+ }
+ GLctx.bindBuffer(target, GL.buffers[buffer]);
+ };
+ var _emscripten_glBindBuffer = _glBindBuffer;
+
+ /** @suppress {duplicate } */
+ var _glBindBufferBase = (target, index, buffer) => {
+ GLctx.bindBufferBase(target, index, GL.buffers[buffer]);
+ };
+ var _emscripten_glBindBufferBase = _glBindBufferBase;
+
+ /** @suppress {duplicate } */
+ var _glBindBufferRange = (target, index, buffer, offset, ptrsize) => {
+ GLctx.bindBufferRange(target, index, GL.buffers[buffer], offset, ptrsize);
+ };
+ var _emscripten_glBindBufferRange = _glBindBufferRange;
+
+ /** @suppress {duplicate } */
+ var _glBindFramebuffer = (target, framebuffer) => {
+
+ GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
+
+ };
+ var _emscripten_glBindFramebuffer = _glBindFramebuffer;
+
+ /** @suppress {duplicate } */
+ var _glBindRenderbuffer = (target, renderbuffer) => {
+ GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
+ };
+ var _emscripten_glBindRenderbuffer = _glBindRenderbuffer;
+
+ /** @suppress {duplicate } */
+ var _glBindSampler = (unit, sampler) => {
+ GLctx.bindSampler(unit, GL.samplers[sampler]);
+ };
+ var _emscripten_glBindSampler = _glBindSampler;
+
+ /** @suppress {duplicate } */
+ var _glBindTexture = (target, texture) => {
+ GLctx.bindTexture(target, GL.textures[texture]);
+ };
+ var _emscripten_glBindTexture = _glBindTexture;
+
+ /** @suppress {duplicate } */
+ var _glBindTransformFeedback = (target, id) => {
+ GLctx.bindTransformFeedback(target, GL.transformFeedbacks[id]);
+ };
+ var _emscripten_glBindTransformFeedback = _glBindTransformFeedback;
+
+ /** @suppress {duplicate } */
+ var _glBindVertexArray = (vao) => {
+ GLctx.bindVertexArray(GL.vaos[vao]);
+ };
+ var _emscripten_glBindVertexArray = _glBindVertexArray;
+
+
+ /** @suppress {duplicate } */
+ var _glBindVertexArrayOES = _glBindVertexArray;
+ var _emscripten_glBindVertexArrayOES = _glBindVertexArrayOES;
+
+ /** @suppress {duplicate } */
+ var _glBlendColor = (x0, x1, x2, x3) => GLctx.blendColor(x0, x1, x2, x3);
+ var _emscripten_glBlendColor = _glBlendColor;
+
+ /** @suppress {duplicate } */
+ var _glBlendEquation = (x0) => GLctx.blendEquation(x0);
+ var _emscripten_glBlendEquation = _glBlendEquation;
+
+ /** @suppress {duplicate } */
+ var _glBlendEquationSeparate = (x0, x1) => GLctx.blendEquationSeparate(x0, x1);
+ var _emscripten_glBlendEquationSeparate = _glBlendEquationSeparate;
+
+ /** @suppress {duplicate } */
+ var _glBlendFunc = (x0, x1) => GLctx.blendFunc(x0, x1);
+ var _emscripten_glBlendFunc = _glBlendFunc;
+
+ /** @suppress {duplicate } */
+ var _glBlendFuncSeparate = (x0, x1, x2, x3) => GLctx.blendFuncSeparate(x0, x1, x2, x3);
+ var _emscripten_glBlendFuncSeparate = _glBlendFuncSeparate;
+
+ /** @suppress {duplicate } */
+ var _glBlitFramebuffer = (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) => GLctx.blitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+ var _emscripten_glBlitFramebuffer = _glBlitFramebuffer;
+
+ /** @suppress {duplicate } */
+ var _glBufferData = (target, size, data, usage) => {
+
+ if (GL.currentContext.version >= 2) {
+ // If size is zero, WebGL would interpret uploading the whole input
+ // arraybuffer (starting from given offset), which would not make sense in
+ // WebAssembly, so avoid uploading if size is zero. However we must still
+ // call bufferData to establish a backing storage of zero bytes.
+ if (data && size) {
+ GLctx.bufferData(target, HEAPU8, usage, data, size);
+ } else {
+ GLctx.bufferData(target, size, usage);
+ }
+ return;
+ }
+ // N.b. here first form specifies a heap subarray, second form an integer
+ // size, so the ?: code here is polymorphic. It is advised to avoid
+ // randomly mixing both uses in calling code, to avoid any potential JS
+ // engine JIT issues.
+ GLctx.bufferData(target, data ? HEAPU8.subarray(data, data+size) : size, usage);
+ };
+ var _emscripten_glBufferData = _glBufferData;
+
+ /** @suppress {duplicate } */
+ var _glBufferSubData = (target, offset, size, data) => {
+ if (GL.currentContext.version >= 2) {
+ size && GLctx.bufferSubData(target, offset, HEAPU8, data, size);
+ return;
+ }
+ GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data+size));
+ };
+ var _emscripten_glBufferSubData = _glBufferSubData;
+
+ /** @suppress {duplicate } */
+ var _glCheckFramebufferStatus = (x0) => GLctx.checkFramebufferStatus(x0);
+ var _emscripten_glCheckFramebufferStatus = _glCheckFramebufferStatus;
+
+ /** @suppress {duplicate } */
+ var _glClear = (x0) => GLctx.clear(x0);
+ var _emscripten_glClear = _glClear;
+
+ /** @suppress {duplicate } */
+ var _glClearBufferfi = (x0, x1, x2, x3) => GLctx.clearBufferfi(x0, x1, x2, x3);
+ var _emscripten_glClearBufferfi = _glClearBufferfi;
+
+ /** @suppress {duplicate } */
+ var _glClearBufferfv = (buffer, drawbuffer, value) => {
+
+ GLctx.clearBufferfv(buffer, drawbuffer, HEAPF32, ((value)>>2));
+ };
+ var _emscripten_glClearBufferfv = _glClearBufferfv;
+
+ /** @suppress {duplicate } */
+ var _glClearBufferiv = (buffer, drawbuffer, value) => {
+
+ GLctx.clearBufferiv(buffer, drawbuffer, HEAP32, ((value)>>2));
+ };
+ var _emscripten_glClearBufferiv = _glClearBufferiv;
+
+ /** @suppress {duplicate } */
+ var _glClearBufferuiv = (buffer, drawbuffer, value) => {
+
+ GLctx.clearBufferuiv(buffer, drawbuffer, HEAPU32, ((value)>>2));
+ };
+ var _emscripten_glClearBufferuiv = _glClearBufferuiv;
+
+ /** @suppress {duplicate } */
+ var _glClearColor = (x0, x1, x2, x3) => GLctx.clearColor(x0, x1, x2, x3);
+ var _emscripten_glClearColor = _glClearColor;
+
+ /** @suppress {duplicate } */
+ var _glClearDepthf = (x0) => GLctx.clearDepth(x0);
+ var _emscripten_glClearDepthf = _glClearDepthf;
+
+ /** @suppress {duplicate } */
+ var _glClearStencil = (x0) => GLctx.clearStencil(x0);
+ var _emscripten_glClearStencil = _glClearStencil;
+
+ var convertI32PairToI53 = (lo, hi) => {
+ // This function should not be getting called with too large unsigned numbers
+ // in high part (if hi >= 0x7FFFFFFFF, one should have been calling
+ // convertU32PairToI53())
+ assert(hi === (hi|0));
+ return (lo >>> 0) + hi * 4294967296;
+ };
+ /** @suppress {duplicate } */
+ var _glClientWaitSync = (sync, flags, timeout_low, timeout_high) => {
+ // WebGL2 vs GLES3 differences: in GLES3, the timeout parameter is a uint64, where 0xFFFFFFFFFFFFFFFFULL means GL_TIMEOUT_IGNORED.
+ // In JS, there's no 64-bit value types, so instead timeout is taken to be signed, and GL_TIMEOUT_IGNORED is given value -1.
+ // Inherently the value accepted in the timeout is lossy, and can't take in arbitrary u64 bit pattern (but most likely doesn't matter)
+ // See https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.15
+ var timeout = convertI32PairToI53(timeout_low, timeout_high);
+ return GLctx.clientWaitSync(GL.syncs[sync], flags, timeout);
+ };
+ var _emscripten_glClientWaitSync = _glClientWaitSync;
+
+ /** @suppress {duplicate } */
+ var _glClipControlEXT = (origin, depth) => {
+ GLctx.extClipControl['clipControlEXT'](origin, depth);
+ };
+ var _emscripten_glClipControlEXT = _glClipControlEXT;
+
+ /** @suppress {duplicate } */
+ var _glColorMask = (red, green, blue, alpha) => {
+ GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
+ };
+ var _emscripten_glColorMask = _glColorMask;
+
+ /** @suppress {duplicate } */
+ var _glCompileShader = (shader) => {
+ GLctx.compileShader(GL.shaders[shader]);
+ };
+ var _emscripten_glCompileShader = _glCompileShader;
+
+ /** @suppress {duplicate } */
+ var _glCompressedTexImage2D = (target, level, internalFormat, width, height, border, imageSize, data) => {
+ // `data` may be null here, which means "allocate uniniitalized space but
+ // don't upload" in GLES parlance, but `compressedTexImage2D` requires the
+ // final data parameter, so we simply pass a heap view starting at zero
+ // effectively uploading whatever happens to be near address zero. See
+ // https://github.com/emscripten-core/emscripten/issues/19300.
+ if (GL.currentContext.version >= 2) {
+ if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
+ GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data);
+ return;
+ }
+ GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, HEAPU8, data, imageSize);
+ return;
+ }
+ GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, HEAPU8.subarray((data), data+imageSize));
+ };
+ var _emscripten_glCompressedTexImage2D = _glCompressedTexImage2D;
+
+ /** @suppress {duplicate } */
+ var _glCompressedTexImage3D = (target, level, internalFormat, width, height, depth, border, imageSize, data) => {
+ if (GLctx.currentPixelUnpackBufferBinding) {
+ GLctx.compressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data);
+ } else {
+ GLctx.compressedTexImage3D(target, level, internalFormat, width, height, depth, border, HEAPU8, data, imageSize);
+ }
+ };
+ var _emscripten_glCompressedTexImage3D = _glCompressedTexImage3D;
+
+ /** @suppress {duplicate } */
+ var _glCompressedTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, imageSize, data) => {
+ if (GL.currentContext.version >= 2) {
+ if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
+ GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+ return;
+ }
+ GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize);
+ return;
+ }
+ GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, HEAPU8.subarray((data), data+imageSize));
+ };
+ var _emscripten_glCompressedTexSubImage2D = _glCompressedTexSubImage2D;
+
+ /** @suppress {duplicate } */
+ var _glCompressedTexSubImage3D = (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) => {
+ if (GLctx.currentPixelUnpackBufferBinding) {
+ GLctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+ } else {
+ GLctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, HEAPU8, data, imageSize);
+ }
+ };
+ var _emscripten_glCompressedTexSubImage3D = _glCompressedTexSubImage3D;
+
+ /** @suppress {duplicate } */
+ var _glCopyBufferSubData = (x0, x1, x2, x3, x4) => GLctx.copyBufferSubData(x0, x1, x2, x3, x4);
+ var _emscripten_glCopyBufferSubData = _glCopyBufferSubData;
+
+ /** @suppress {duplicate } */
+ var _glCopyTexImage2D = (x0, x1, x2, x3, x4, x5, x6, x7) => GLctx.copyTexImage2D(x0, x1, x2, x3, x4, x5, x6, x7);
+ var _emscripten_glCopyTexImage2D = _glCopyTexImage2D;
+
+ /** @suppress {duplicate } */
+ var _glCopyTexSubImage2D = (x0, x1, x2, x3, x4, x5, x6, x7) => GLctx.copyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7);
+ var _emscripten_glCopyTexSubImage2D = _glCopyTexSubImage2D;
+
+ /** @suppress {duplicate } */
+ var _glCopyTexSubImage3D = (x0, x1, x2, x3, x4, x5, x6, x7, x8) => GLctx.copyTexSubImage3D(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+ var _emscripten_glCopyTexSubImage3D = _glCopyTexSubImage3D;
+
+ /** @suppress {duplicate } */
+ var _glCreateProgram = () => {
+ var id = GL.getNewId(GL.programs);
+ var program = GLctx.createProgram();
+ // Store additional information needed for each shader program:
+ program.name = id;
+ // Lazy cache results of
+ // glGetProgramiv(GL_ACTIVE_UNIFORM_MAX_LENGTH/GL_ACTIVE_ATTRIBUTE_MAX_LENGTH/GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH)
+ program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0;
+ program.uniformIdCounter = 1;
+ GL.programs[id] = program;
+ return id;
+ };
+ var _emscripten_glCreateProgram = _glCreateProgram;
+
+ /** @suppress {duplicate } */
+ var _glCreateShader = (shaderType) => {
+ var id = GL.getNewId(GL.shaders);
+ GL.shaders[id] = GLctx.createShader(shaderType);
+
+ return id;
+ };
+ var _emscripten_glCreateShader = _glCreateShader;
+
+ /** @suppress {duplicate } */
+ var _glCullFace = (x0) => GLctx.cullFace(x0);
+ var _emscripten_glCullFace = _glCullFace;
+
+ /** @suppress {duplicate } */
+ var _glDeleteBuffers = (n, buffers) => {
+ for (var i = 0; i < n; i++) {
+ var id = HEAP32[(((buffers)+(i*4))>>2)];
+ var buffer = GL.buffers[id];
+
+ // From spec: "glDeleteBuffers silently ignores 0's and names that do not
+ // correspond to existing buffer objects."
+ if (!buffer) continue;
+
+ GLctx.deleteBuffer(buffer);
+ buffer.name = 0;
+ GL.buffers[id] = null;
+
+ if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0;
+ if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0;
+ }
+ };
+ var _emscripten_glDeleteBuffers = _glDeleteBuffers;
+
+ /** @suppress {duplicate } */
+ var _glDeleteFramebuffers = (n, framebuffers) => {
+ for (var i = 0; i < n; ++i) {
+ var id = HEAP32[(((framebuffers)+(i*4))>>2)];
+ var framebuffer = GL.framebuffers[id];
+ if (!framebuffer) continue; // GL spec: "glDeleteFramebuffers silently ignores 0s and names that do not correspond to existing framebuffer objects".
+ GLctx.deleteFramebuffer(framebuffer);
+ framebuffer.name = 0;
+ GL.framebuffers[id] = null;
+ }
+ };
+ var _emscripten_glDeleteFramebuffers = _glDeleteFramebuffers;
+
+ /** @suppress {duplicate } */
+ var _glDeleteProgram = (id) => {
+ if (!id) return;
+ var program = GL.programs[id];
+ if (!program) {
+ // glDeleteProgram actually signals an error when deleting a nonexisting
+ // object, unlike some other GL delete functions.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ GLctx.deleteProgram(program);
+ program.name = 0;
+ GL.programs[id] = null;
+ };
+ var _emscripten_glDeleteProgram = _glDeleteProgram;
+
+ /** @suppress {duplicate } */
+ var _glDeleteQueries = (n, ids) => {
+ for (var i = 0; i < n; i++) {
+ var id = HEAP32[(((ids)+(i*4))>>2)];
+ var query = GL.queries[id];
+ if (!query) continue; // GL spec: "unused names in ids are ignored, as is the name zero."
+ GLctx.deleteQuery(query);
+ GL.queries[id] = null;
+ }
+ };
+ var _emscripten_glDeleteQueries = _glDeleteQueries;
+
+ /** @suppress {duplicate } */
+ var _glDeleteQueriesEXT = (n, ids) => {
+ for (var i = 0; i < n; i++) {
+ var id = HEAP32[(((ids)+(i*4))>>2)];
+ var query = GL.queries[id];
+ if (!query) continue; // GL spec: "unused names in ids are ignored, as is the name zero."
+ GLctx.disjointTimerQueryExt['deleteQueryEXT'](query);
+ GL.queries[id] = null;
+ }
+ };
+ var _emscripten_glDeleteQueriesEXT = _glDeleteQueriesEXT;
+
+ /** @suppress {duplicate } */
+ var _glDeleteRenderbuffers = (n, renderbuffers) => {
+ for (var i = 0; i < n; i++) {
+ var id = HEAP32[(((renderbuffers)+(i*4))>>2)];
+ var renderbuffer = GL.renderbuffers[id];
+ if (!renderbuffer) continue; // GL spec: "glDeleteRenderbuffers silently ignores 0s and names that do not correspond to existing renderbuffer objects".
+ GLctx.deleteRenderbuffer(renderbuffer);
+ renderbuffer.name = 0;
+ GL.renderbuffers[id] = null;
+ }
+ };
+ var _emscripten_glDeleteRenderbuffers = _glDeleteRenderbuffers;
+
+ /** @suppress {duplicate } */
+ var _glDeleteSamplers = (n, samplers) => {
+ for (var i = 0; i < n; i++) {
+ var id = HEAP32[(((samplers)+(i*4))>>2)];
+ var sampler = GL.samplers[id];
+ if (!sampler) continue;
+ GLctx.deleteSampler(sampler);
+ sampler.name = 0;
+ GL.samplers[id] = null;
+ }
+ };
+ var _emscripten_glDeleteSamplers = _glDeleteSamplers;
+
+ /** @suppress {duplicate } */
+ var _glDeleteShader = (id) => {
+ if (!id) return;
+ var shader = GL.shaders[id];
+ if (!shader) {
+ // glDeleteShader actually signals an error when deleting a nonexisting
+ // object, unlike some other GL delete functions.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ GLctx.deleteShader(shader);
+ GL.shaders[id] = null;
+ };
+ var _emscripten_glDeleteShader = _glDeleteShader;
+
+ /** @suppress {duplicate } */
+ var _glDeleteSync = (id) => {
+ if (!id) return;
+ var sync = GL.syncs[id];
+ if (!sync) { // glDeleteSync signals an error when deleting a nonexisting object, unlike some other GL delete functions.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ GLctx.deleteSync(sync);
+ sync.name = 0;
+ GL.syncs[id] = null;
+ };
+ var _emscripten_glDeleteSync = _glDeleteSync;
+
+ /** @suppress {duplicate } */
+ var _glDeleteTextures = (n, textures) => {
+ for (var i = 0; i < n; i++) {
+ var id = HEAP32[(((textures)+(i*4))>>2)];
+ var texture = GL.textures[id];
+ // GL spec: "glDeleteTextures silently ignores 0s and names that do not
+ // correspond to existing textures".
+ if (!texture) continue;
+ GLctx.deleteTexture(texture);
+ texture.name = 0;
+ GL.textures[id] = null;
+ }
+ };
+ var _emscripten_glDeleteTextures = _glDeleteTextures;
+
+ /** @suppress {duplicate } */
+ var _glDeleteTransformFeedbacks = (n, ids) => {
+ for (var i = 0; i < n; i++) {
+ var id = HEAP32[(((ids)+(i*4))>>2)];
+ var transformFeedback = GL.transformFeedbacks[id];
+ if (!transformFeedback) continue; // GL spec: "unused names in ids are ignored, as is the name zero."
+ GLctx.deleteTransformFeedback(transformFeedback);
+ transformFeedback.name = 0;
+ GL.transformFeedbacks[id] = null;
+ }
+ };
+ var _emscripten_glDeleteTransformFeedbacks = _glDeleteTransformFeedbacks;
+
+ /** @suppress {duplicate } */
+ var _glDeleteVertexArrays = (n, vaos) => {
+ for (var i = 0; i < n; i++) {
+ var id = HEAP32[(((vaos)+(i*4))>>2)];
+ GLctx.deleteVertexArray(GL.vaos[id]);
+ GL.vaos[id] = null;
+ }
+ };
+ var _emscripten_glDeleteVertexArrays = _glDeleteVertexArrays;
+
+
+ /** @suppress {duplicate } */
+ var _glDeleteVertexArraysOES = _glDeleteVertexArrays;
+ var _emscripten_glDeleteVertexArraysOES = _glDeleteVertexArraysOES;
+
+ /** @suppress {duplicate } */
+ var _glDepthFunc = (x0) => GLctx.depthFunc(x0);
+ var _emscripten_glDepthFunc = _glDepthFunc;
+
+ /** @suppress {duplicate } */
+ var _glDepthMask = (flag) => {
+ GLctx.depthMask(!!flag);
+ };
+ var _emscripten_glDepthMask = _glDepthMask;
+
+ /** @suppress {duplicate } */
+ var _glDepthRangef = (x0, x1) => GLctx.depthRange(x0, x1);
+ var _emscripten_glDepthRangef = _glDepthRangef;
+
+ /** @suppress {duplicate } */
+ var _glDetachShader = (program, shader) => {
+ GLctx.detachShader(GL.programs[program], GL.shaders[shader]);
+ };
+ var _emscripten_glDetachShader = _glDetachShader;
+
+ /** @suppress {duplicate } */
+ var _glDisable = (x0) => GLctx.disable(x0);
+ var _emscripten_glDisable = _glDisable;
+
+ /** @suppress {duplicate } */
+ var _glDisableVertexAttribArray = (index) => {
+ GLctx.disableVertexAttribArray(index);
+ };
+ var _emscripten_glDisableVertexAttribArray = _glDisableVertexAttribArray;
+
+ /** @suppress {duplicate } */
+ var _glDrawArrays = (mode, first, count) => {
+
+ GLctx.drawArrays(mode, first, count);
+
+ };
+ var _emscripten_glDrawArrays = _glDrawArrays;
+
+ /** @suppress {duplicate } */
+ var _glDrawArraysInstanced = (mode, first, count, primcount) => {
+ GLctx.drawArraysInstanced(mode, first, count, primcount);
+ };
+ var _emscripten_glDrawArraysInstanced = _glDrawArraysInstanced;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawArraysInstancedANGLE = _glDrawArraysInstanced;
+ var _emscripten_glDrawArraysInstancedANGLE = _glDrawArraysInstancedANGLE;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawArraysInstancedARB = _glDrawArraysInstanced;
+ var _emscripten_glDrawArraysInstancedARB = _glDrawArraysInstancedARB;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawArraysInstancedEXT = _glDrawArraysInstanced;
+ var _emscripten_glDrawArraysInstancedEXT = _glDrawArraysInstancedEXT;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawArraysInstancedNV = _glDrawArraysInstanced;
+ var _emscripten_glDrawArraysInstancedNV = _glDrawArraysInstancedNV;
+
+ var tempFixedLengthArray = [];
+
+ /** @suppress {duplicate } */
+ var _glDrawBuffers = (n, bufs) => {
+
+ var bufArray = tempFixedLengthArray[n];
+ for (var i = 0; i < n; i++) {
+ bufArray[i] = HEAP32[(((bufs)+(i*4))>>2)];
+ }
+
+ GLctx.drawBuffers(bufArray);
+ };
+ var _emscripten_glDrawBuffers = _glDrawBuffers;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawBuffersEXT = _glDrawBuffers;
+ var _emscripten_glDrawBuffersEXT = _glDrawBuffersEXT;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawBuffersWEBGL = _glDrawBuffers;
+ var _emscripten_glDrawBuffersWEBGL = _glDrawBuffersWEBGL;
+
+ /** @suppress {duplicate } */
+ var _glDrawElements = (mode, count, type, indices) => {
+
+ GLctx.drawElements(mode, count, type, indices);
+
+ };
+ var _emscripten_glDrawElements = _glDrawElements;
+
+ /** @suppress {duplicate } */
+ var _glDrawElementsInstanced = (mode, count, type, indices, primcount) => {
+ GLctx.drawElementsInstanced(mode, count, type, indices, primcount);
+ };
+ var _emscripten_glDrawElementsInstanced = _glDrawElementsInstanced;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawElementsInstancedANGLE = _glDrawElementsInstanced;
+ var _emscripten_glDrawElementsInstancedANGLE = _glDrawElementsInstancedANGLE;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawElementsInstancedARB = _glDrawElementsInstanced;
+ var _emscripten_glDrawElementsInstancedARB = _glDrawElementsInstancedARB;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawElementsInstancedEXT = _glDrawElementsInstanced;
+ var _emscripten_glDrawElementsInstancedEXT = _glDrawElementsInstancedEXT;
+
+
+ /** @suppress {duplicate } */
+ var _glDrawElementsInstancedNV = _glDrawElementsInstanced;
+ var _emscripten_glDrawElementsInstancedNV = _glDrawElementsInstancedNV;
+
+ /** @suppress {duplicate } */
+ var _glDrawRangeElements = (mode, start, end, count, type, indices) => {
+ // TODO: This should be a trivial pass-though function registered at the bottom of this page as
+ // glFuncs[6][1] += ' drawRangeElements';
+ // but due to https://bugzilla.mozilla.org/show_bug.cgi?id=1202427,
+ // we work around by ignoring the range.
+ _glDrawElements(mode, count, type, indices);
+ };
+ var _emscripten_glDrawRangeElements = _glDrawRangeElements;
+
+ /** @suppress {duplicate } */
+ var _glEnable = (x0) => GLctx.enable(x0);
+ var _emscripten_glEnable = _glEnable;
+
+ /** @suppress {duplicate } */
+ var _glEnableVertexAttribArray = (index) => {
+ GLctx.enableVertexAttribArray(index);
+ };
+ var _emscripten_glEnableVertexAttribArray = _glEnableVertexAttribArray;
+
+ /** @suppress {duplicate } */
+ var _glEndQuery = (x0) => GLctx.endQuery(x0);
+ var _emscripten_glEndQuery = _glEndQuery;
+
+ /** @suppress {duplicate } */
+ var _glEndQueryEXT = (target) => {
+ GLctx.disjointTimerQueryExt['endQueryEXT'](target);
+ };
+ var _emscripten_glEndQueryEXT = _glEndQueryEXT;
+
+ /** @suppress {duplicate } */
+ var _glEndTransformFeedback = () => GLctx.endTransformFeedback();
+ var _emscripten_glEndTransformFeedback = _glEndTransformFeedback;
+
+ /** @suppress {duplicate } */
+ var _glFenceSync = (condition, flags) => {
+ var sync = GLctx.fenceSync(condition, flags);
+ if (sync) {
+ var id = GL.getNewId(GL.syncs);
+ sync.name = id;
+ GL.syncs[id] = sync;
+ return id;
+ }
+ return 0; // Failed to create a sync object
+ };
+ var _emscripten_glFenceSync = _glFenceSync;
+
+ /** @suppress {duplicate } */
+ var _glFinish = () => GLctx.finish();
+ var _emscripten_glFinish = _glFinish;
+
+ /** @suppress {duplicate } */
+ var _glFlush = () => GLctx.flush();
+ var _emscripten_glFlush = _glFlush;
+
+ /** @suppress {duplicate } */
+ var _glFramebufferRenderbuffer = (target, attachment, renderbuffertarget, renderbuffer) => {
+ GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget,
+ GL.renderbuffers[renderbuffer]);
+ };
+ var _emscripten_glFramebufferRenderbuffer = _glFramebufferRenderbuffer;
+
+ /** @suppress {duplicate } */
+ var _glFramebufferTexture2D = (target, attachment, textarget, texture, level) => {
+ GLctx.framebufferTexture2D(target, attachment, textarget,
+ GL.textures[texture], level);
+ };
+ var _emscripten_glFramebufferTexture2D = _glFramebufferTexture2D;
+
+ /** @suppress {duplicate } */
+ var _glFramebufferTextureLayer = (target, attachment, texture, level, layer) => {
+ GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer);
+ };
+ var _emscripten_glFramebufferTextureLayer = _glFramebufferTextureLayer;
+
+ /** @suppress {duplicate } */
+ var _glFrontFace = (x0) => GLctx.frontFace(x0);
+ var _emscripten_glFrontFace = _glFrontFace;
+
+ /** @suppress {duplicate } */
+ var _glGenBuffers = (n, buffers) => {
+ GL.genObject(n, buffers, 'createBuffer', GL.buffers
+ );
+ };
+ var _emscripten_glGenBuffers = _glGenBuffers;
+
+ /** @suppress {duplicate } */
+ var _glGenFramebuffers = (n, ids) => {
+ GL.genObject(n, ids, 'createFramebuffer', GL.framebuffers
+ );
+ };
+ var _emscripten_glGenFramebuffers = _glGenFramebuffers;
+
+ /** @suppress {duplicate } */
+ var _glGenQueries = (n, ids) => {
+ GL.genObject(n, ids, 'createQuery', GL.queries
+ );
+ };
+ var _emscripten_glGenQueries = _glGenQueries;
+
+ /** @suppress {duplicate } */
+ var _glGenQueriesEXT = (n, ids) => {
+ for (var i = 0; i < n; i++) {
+ var query = GLctx.disjointTimerQueryExt['createQueryEXT']();
+ if (!query) {
+ GL.recordError(0x502 /* GL_INVALID_OPERATION */);
+ while (i < n) HEAP32[(((ids)+(i++*4))>>2)] = 0;checkInt32(0);
+ return;
+ }
+ var id = GL.getNewId(GL.queries);
+ query.name = id;
+ GL.queries[id] = query;
+ HEAP32[(((ids)+(i*4))>>2)] = id;checkInt32(id);
+ }
+ };
+ var _emscripten_glGenQueriesEXT = _glGenQueriesEXT;
+
+ /** @suppress {duplicate } */
+ var _glGenRenderbuffers = (n, renderbuffers) => {
+ GL.genObject(n, renderbuffers, 'createRenderbuffer', GL.renderbuffers
+ );
+ };
+ var _emscripten_glGenRenderbuffers = _glGenRenderbuffers;
+
+ /** @suppress {duplicate } */
+ var _glGenSamplers = (n, samplers) => {
+ GL.genObject(n, samplers, 'createSampler', GL.samplers
+ );
+ };
+ var _emscripten_glGenSamplers = _glGenSamplers;
+
+ /** @suppress {duplicate } */
+ var _glGenTextures = (n, textures) => {
+ GL.genObject(n, textures, 'createTexture', GL.textures
+ );
+ };
+ var _emscripten_glGenTextures = _glGenTextures;
+
+ /** @suppress {duplicate } */
+ var _glGenTransformFeedbacks = (n, ids) => {
+ GL.genObject(n, ids, 'createTransformFeedback', GL.transformFeedbacks
+ );
+ };
+ var _emscripten_glGenTransformFeedbacks = _glGenTransformFeedbacks;
+
+ /** @suppress {duplicate } */
+ var _glGenVertexArrays = (n, arrays) => {
+ GL.genObject(n, arrays, 'createVertexArray', GL.vaos
+ );
+ };
+ var _emscripten_glGenVertexArrays = _glGenVertexArrays;
+
+
+ /** @suppress {duplicate } */
+ var _glGenVertexArraysOES = _glGenVertexArrays;
+ var _emscripten_glGenVertexArraysOES = _glGenVertexArraysOES;
+
+ /** @suppress {duplicate } */
+ var _glGenerateMipmap = (x0) => GLctx.generateMipmap(x0);
+ var _emscripten_glGenerateMipmap = _glGenerateMipmap;
+
+
+ var __glGetActiveAttribOrUniform = (funcName, program, index, bufSize, length, size, type, name) => {
+ program = GL.programs[program];
+ var info = GLctx[funcName](program, index);
+ if (info) {
+ // If an error occurs, nothing will be written to length, size and type and name.
+ var numBytesWrittenExclNull = name && stringToUTF8(info.name, name, bufSize);
+ if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull);
+ if (size) HEAP32[((size)>>2)] = info.size;checkInt32(info.size);
+ if (type) HEAP32[((type)>>2)] = info.type;checkInt32(info.type);
+ }
+ };
+
+ /** @suppress {duplicate } */
+ var _glGetActiveAttrib = (program, index, bufSize, length, size, type, name) => {
+ __glGetActiveAttribOrUniform('getActiveAttrib', program, index, bufSize, length, size, type, name);
+ };
+ var _emscripten_glGetActiveAttrib = _glGetActiveAttrib;
+
+
+ /** @suppress {duplicate } */
+ var _glGetActiveUniform = (program, index, bufSize, length, size, type, name) => {
+ __glGetActiveAttribOrUniform('getActiveUniform', program, index, bufSize, length, size, type, name);
+ };
+ var _emscripten_glGetActiveUniform = _glGetActiveUniform;
+
+ /** @suppress {duplicate } */
+ var _glGetActiveUniformBlockName = (program, uniformBlockIndex, bufSize, length, uniformBlockName) => {
+ program = GL.programs[program];
+
+ var result = GLctx.getActiveUniformBlockName(program, uniformBlockIndex);
+ if (!result) return; // If an error occurs, nothing will be written to uniformBlockName or length.
+ if (uniformBlockName && bufSize > 0) {
+ var numBytesWrittenExclNull = stringToUTF8(result, uniformBlockName, bufSize);
+ if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull);
+ } else {
+ if (length) HEAP32[((length)>>2)] = 0;checkInt32(0);
+ }
+ };
+ var _emscripten_glGetActiveUniformBlockName = _glGetActiveUniformBlockName;
+
+ /** @suppress {duplicate } */
+ var _glGetActiveUniformBlockiv = (program, uniformBlockIndex, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if params == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ program = GL.programs[program];
+
+ if (pname == 0x8A41 /* GL_UNIFORM_BLOCK_NAME_LENGTH */) {
+ var name = GLctx.getActiveUniformBlockName(program, uniformBlockIndex);
+ HEAP32[((params)>>2)] = name.length+1;checkInt32(name.length+1);
+ return;
+ }
+
+ var result = GLctx.getActiveUniformBlockParameter(program, uniformBlockIndex, pname);
+ if (result === null) return; // If an error occurs, nothing should be written to params.
+ if (pname == 0x8A43 /*GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES*/) {
+ for (var i = 0; i < result.length; i++) {
+ HEAP32[(((params)+(i*4))>>2)] = result[i];checkInt32(result[i]);
+ }
+ } else {
+ HEAP32[((params)>>2)] = result;checkInt32(result);
+ }
+ };
+ var _emscripten_glGetActiveUniformBlockiv = _glGetActiveUniformBlockiv;
+
+ /** @suppress {duplicate } */
+ var _glGetActiveUniformsiv = (program, uniformCount, uniformIndices, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if params == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ if (uniformCount > 0 && uniformIndices == 0) {
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ program = GL.programs[program];
+ var ids = [];
+ for (var i = 0; i < uniformCount; i++) {
+ ids.push(HEAP32[(((uniformIndices)+(i*4))>>2)]);
+ }
+
+ var result = GLctx.getActiveUniforms(program, ids, pname);
+ if (!result) return; // GL spec: If an error is generated, nothing is written out to params.
+
+ var len = result.length;
+ for (var i = 0; i < len; i++) {
+ HEAP32[(((params)+(i*4))>>2)] = result[i];checkInt32(result[i]);
+ }
+ };
+ var _emscripten_glGetActiveUniformsiv = _glGetActiveUniformsiv;
+
+ /** @suppress {duplicate } */
+ var _glGetAttachedShaders = (program, maxCount, count, shaders) => {
+ var result = GLctx.getAttachedShaders(GL.programs[program]);
+ var len = result.length;
+ if (len > maxCount) {
+ len = maxCount;
+ }
+ HEAP32[((count)>>2)] = len;checkInt32(len);
+ for (var i = 0; i < len; ++i) {
+ var id = GL.shaders.indexOf(result[i]);
+ HEAP32[(((shaders)+(i*4))>>2)] = id;checkInt32(id);
+ }
+ };
+ var _emscripten_glGetAttachedShaders = _glGetAttachedShaders;
+
+
+ /** @suppress {duplicate } */
+ var _glGetAttribLocation = (program, name) => {
+ return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
+ };
+ var _emscripten_glGetAttribLocation = _glGetAttribLocation;
+
+ var readI53FromI64 = (ptr) => {
+ return HEAPU32[((ptr)>>2)] + HEAP32[(((ptr)+(4))>>2)] * 4294967296;
+ };
+
+ var readI53FromU64 = (ptr) => {
+ return HEAPU32[((ptr)>>2)] + HEAPU32[(((ptr)+(4))>>2)] * 4294967296;
+ };
+ var writeI53ToI64 = (ptr, num) => {
+ HEAPU32[((ptr)>>2)] = num;checkInt32(num);
+ var lower = HEAPU32[((ptr)>>2)];
+ HEAPU32[(((ptr)+(4))>>2)] = (num - lower)/4294967296;checkInt32((num - lower)/4294967296);
+ var deserialized = (num >= 0) ? readI53FromU64(ptr) : readI53FromI64(ptr);
+ var offset = ((ptr)>>2);
+ if (deserialized != num) warnOnce(`writeI53ToI64() out of range: serialized JS Number ${num} to Wasm heap as bytes lo=${ptrToString(HEAPU32[offset])}, hi=${ptrToString(HEAPU32[offset+1])}, which deserializes back to ${deserialized} instead!`);
+ };
+
+
+ var webglGetExtensions = function $webglGetExtensions() {
+ var exts = getEmscriptenSupportedExtensions(GLctx);
+ exts = exts.concat(exts.map((e) => "GL_" + e));
+ return exts;
+ };
+
+ var emscriptenWebGLGet = (name_, p, type) => {
+ // Guard against user passing a null pointer.
+ // Note that GLES2 spec does not say anything about how passing a null
+ // pointer should be treated. Testing on desktop core GL 3, the application
+ // crashes on glGetIntegerv to a null pointer, but better to report an error
+ // instead of doing anything random.
+ if (!p) {
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ var ret = undefined;
+ switch (name_) { // Handle a few trivial GLES values
+ case 0x8DFA: // GL_SHADER_COMPILER
+ ret = 1;
+ break;
+ case 0x8DF8: // GL_SHADER_BINARY_FORMATS
+ if (type != 0 && type != 1) {
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ }
+ // Do not write anything to the out pointer, since no binary formats are
+ // supported.
+ return;
+ case 0x87FE: // GL_NUM_PROGRAM_BINARY_FORMATS
+ case 0x8DF9: // GL_NUM_SHADER_BINARY_FORMATS
+ ret = 0;
+ break;
+ case 0x86A2: // GL_NUM_COMPRESSED_TEXTURE_FORMATS
+ // WebGL doesn't have GL_NUM_COMPRESSED_TEXTURE_FORMATS (it's obsolete
+ // since GL_COMPRESSED_TEXTURE_FORMATS returns a JS array that can be
+ // queried for length), so implement it ourselves to allow C++ GLES2
+ // code get the length.
+ var formats = GLctx.getParameter(0x86A3 /*GL_COMPRESSED_TEXTURE_FORMATS*/);
+ ret = formats ? formats.length : 0;
+ break;
+
+ case 0x821D: // GL_NUM_EXTENSIONS
+ if (GL.currentContext.version < 2) {
+ // Calling GLES3/WebGL2 function with a GLES2/WebGL1 context
+ GL.recordError(0x502 /* GL_INVALID_OPERATION */);
+ return;
+ }
+ ret = webglGetExtensions().length;
+ break;
+ case 0x821B: // GL_MAJOR_VERSION
+ case 0x821C: // GL_MINOR_VERSION
+ if (GL.currentContext.version < 2) {
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ return;
+ }
+ ret = name_ == 0x821B ? 3 : 0; // return version 3.0
+ break;
+ }
+
+ if (ret === undefined) {
+ var result = GLctx.getParameter(name_);
+ switch (typeof result) {
+ case "number":
+ ret = result;
+ break;
+ case "boolean":
+ ret = result ? 1 : 0;
+ break;
+ case "string":
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ return;
+ case "object":
+ if (result === null) {
+ // null is a valid result for some (e.g., which buffer is bound -
+ // perhaps nothing is bound), but otherwise can mean an invalid
+ // name_, which we need to report as an error
+ switch (name_) {
+ case 0x8894: // ARRAY_BUFFER_BINDING
+ case 0x8B8D: // CURRENT_PROGRAM
+ case 0x8895: // ELEMENT_ARRAY_BUFFER_BINDING
+ case 0x8CA6: // FRAMEBUFFER_BINDING or DRAW_FRAMEBUFFER_BINDING
+ case 0x8CA7: // RENDERBUFFER_BINDING
+ case 0x8069: // TEXTURE_BINDING_2D
+ case 0x85B5: // WebGL 2 GL_VERTEX_ARRAY_BINDING, or WebGL 1 extension OES_vertex_array_object GL_VERTEX_ARRAY_BINDING_OES
+ case 0x8F36: // COPY_READ_BUFFER_BINDING or COPY_READ_BUFFER
+ case 0x8F37: // COPY_WRITE_BUFFER_BINDING or COPY_WRITE_BUFFER
+ case 0x88ED: // PIXEL_PACK_BUFFER_BINDING
+ case 0x88EF: // PIXEL_UNPACK_BUFFER_BINDING
+ case 0x8CAA: // READ_FRAMEBUFFER_BINDING
+ case 0x8919: // SAMPLER_BINDING
+ case 0x8C1D: // TEXTURE_BINDING_2D_ARRAY
+ case 0x806A: // TEXTURE_BINDING_3D
+ case 0x8E25: // TRANSFORM_FEEDBACK_BINDING
+ case 0x8C8F: // TRANSFORM_FEEDBACK_BUFFER_BINDING
+ case 0x8A28: // UNIFORM_BUFFER_BINDING
+ case 0x8514: { // TEXTURE_BINDING_CUBE_MAP
+ ret = 0;
+ break;
+ }
+ default: {
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ return;
+ }
+ }
+ } else if (result instanceof Float32Array ||
+ result instanceof Uint32Array ||
+ result instanceof Int32Array ||
+ result instanceof Array) {
+ for (var i = 0; i < result.length; ++i) {
+ switch (type) {
+ case 0: HEAP32[(((p)+(i*4))>>2)] = result[i];checkInt32(result[i]); break;
+ case 2: HEAPF32[(((p)+(i*4))>>2)] = result[i]; break;
+ case 4: HEAP8[(p)+(i)] = result[i] ? 1 : 0;checkInt8(result[i] ? 1 : 0); break;
+ }
+ }
+ return;
+ } else {
+ try {
+ ret = result.name | 0;
+ } catch(e) {
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ err(`GL_INVALID_ENUM in glGet${type}v: Unknown object returned from WebGL getParameter(${name_})! (error: ${e})`);
+ return;
+ }
+ }
+ break;
+ default:
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ err(`GL_INVALID_ENUM in glGet${type}v: Native code calling glGet${type}v(${name_}) and it returns ${result} of type ${typeof(result)}!`);
+ return;
+ }
+ }
+
+ switch (type) {
+ case 1: writeI53ToI64(p, ret); break;
+ case 0: HEAP32[((p)>>2)] = ret;checkInt32(ret); break;
+ case 2: HEAPF32[((p)>>2)] = ret; break;
+ case 4: HEAP8[p] = ret ? 1 : 0;checkInt8(ret ? 1 : 0); break;
+ }
+ };
+
+ /** @suppress {duplicate } */
+ var _glGetBooleanv = (name_, p) => emscriptenWebGLGet(name_, p, 4);
+ var _emscripten_glGetBooleanv = _glGetBooleanv;
+
+ /** @suppress {duplicate } */
+ var _glGetBufferParameteri64v = (target, value, data) => {
+ if (!data) {
+ // GLES2 specification does not specify how to behave if data is a null pointer. Since calling this function does not make sense
+ // if data == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ writeI53ToI64(data, GLctx.getBufferParameter(target, value));
+ };
+ var _emscripten_glGetBufferParameteri64v = _glGetBufferParameteri64v;
+
+ /** @suppress {duplicate } */
+ var _glGetBufferParameteriv = (target, value, data) => {
+ if (!data) {
+ // GLES2 specification does not specify how to behave if data is a null
+ // pointer. Since calling this function does not make sense if data ==
+ // null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAP32[((data)>>2)] = GLctx.getBufferParameter(target, value);checkInt32(GLctx.getBufferParameter(target, value));
+ };
+ var _emscripten_glGetBufferParameteriv = _glGetBufferParameteriv;
+
+ /** @suppress {duplicate } */
+ var _glGetError = () => {
+ var error = GLctx.getError() || GL.lastError;
+ GL.lastError = 0/*GL_NO_ERROR*/;
+ return error;
+ };
+ var _emscripten_glGetError = _glGetError;
+
+
+ /** @suppress {duplicate } */
+ var _glGetFloatv = (name_, p) => emscriptenWebGLGet(name_, p, 2);
+ var _emscripten_glGetFloatv = _glGetFloatv;
+
+ /** @suppress {duplicate } */
+ var _glGetFragDataLocation = (program, name) => {
+ return GLctx.getFragDataLocation(GL.programs[program], UTF8ToString(name));
+ };
+ var _emscripten_glGetFragDataLocation = _glGetFragDataLocation;
+
+ /** @suppress {duplicate } */
+ var _glGetFramebufferAttachmentParameteriv = (target, attachment, pname, params) => {
+ var result = GLctx.getFramebufferAttachmentParameter(target, attachment, pname);
+ if (result instanceof WebGLRenderbuffer ||
+ result instanceof WebGLTexture) {
+ result = result.name | 0;
+ }
+ HEAP32[((params)>>2)] = result;checkInt32(result);
+ };
+ var _emscripten_glGetFramebufferAttachmentParameteriv = _glGetFramebufferAttachmentParameteriv;
+
+ var emscriptenWebGLGetIndexed = (target, index, data, type) => {
+ if (!data) {
+ // GLES2 specification does not specify how to behave if data is a null pointer. Since calling this function does not make sense
+ // if data == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ var result = GLctx.getIndexedParameter(target, index);
+ var ret;
+ switch (typeof result) {
+ case 'boolean':
+ ret = result ? 1 : 0;
+ break;
+ case 'number':
+ ret = result;
+ break;
+ case 'object':
+ if (result === null) {
+ switch (target) {
+ case 0x8C8F: // TRANSFORM_FEEDBACK_BUFFER_BINDING
+ case 0x8A28: // UNIFORM_BUFFER_BINDING
+ ret = 0;
+ break;
+ default: {
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ return;
+ }
+ }
+ } else if (result instanceof WebGLBuffer) {
+ ret = result.name | 0;
+ } else {
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ return;
+ }
+ break;
+ default:
+ GL.recordError(0x500); // GL_INVALID_ENUM
+ return;
+ }
+
+ switch (type) {
+ case 1: writeI53ToI64(data, ret); break;
+ case 0: HEAP32[((data)>>2)] = ret;checkInt32(ret); break;
+ case 2: HEAPF32[((data)>>2)] = ret; break;
+ case 4: HEAP8[data] = ret ? 1 : 0;checkInt8(ret ? 1 : 0); break;
+ default: throw 'internal emscriptenWebGLGetIndexed() error, bad type: ' + type;
+ }
+ };
+ /** @suppress {duplicate } */
+ var _glGetInteger64i_v = (target, index, data) =>
+ emscriptenWebGLGetIndexed(target, index, data, 1);
+ var _emscripten_glGetInteger64i_v = _glGetInteger64i_v;
+
+ /** @suppress {duplicate } */
+ var _glGetInteger64v = (name_, p) => {
+ emscriptenWebGLGet(name_, p, 1);
+ };
+ var _emscripten_glGetInteger64v = _glGetInteger64v;
+
+ /** @suppress {duplicate } */
+ var _glGetIntegeri_v = (target, index, data) =>
+ emscriptenWebGLGetIndexed(target, index, data, 0);
+ var _emscripten_glGetIntegeri_v = _glGetIntegeri_v;
+
+
+ /** @suppress {duplicate } */
+ var _glGetIntegerv = (name_, p) => emscriptenWebGLGet(name_, p, 0);
+ var _emscripten_glGetIntegerv = _glGetIntegerv;
+
+ /** @suppress {duplicate } */
+ var _glGetInternalformativ = (target, internalformat, pname, bufSize, params) => {
+ if (bufSize < 0) {
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ if (!params) {
+ // GLES3 specification does not specify how to behave if values is a null pointer. Since calling this function does not make sense
+ // if values == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ var ret = GLctx.getInternalformatParameter(target, internalformat, pname);
+ if (ret === null) return;
+ for (var i = 0; i < ret.length && i < bufSize; ++i) {
+ HEAP32[(((params)+(i*4))>>2)] = ret[i];checkInt32(ret[i]);
+ }
+ };
+ var _emscripten_glGetInternalformativ = _glGetInternalformativ;
+
+ /** @suppress {duplicate } */
+ var _glGetProgramBinary = (program, bufSize, length, binaryFormat, binary) => {
+ GL.recordError(0x502/*GL_INVALID_OPERATION*/);
+ };
+ var _emscripten_glGetProgramBinary = _glGetProgramBinary;
+
+ /** @suppress {duplicate } */
+ var _glGetProgramInfoLog = (program, maxLength, length, infoLog) => {
+ var log = GLctx.getProgramInfoLog(GL.programs[program]);
+ if (log === null) log = '(unknown error)';
+ var numBytesWrittenExclNull = (maxLength > 0 && infoLog) ? stringToUTF8(log, infoLog, maxLength) : 0;
+ if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull);
+ };
+ var _emscripten_glGetProgramInfoLog = _glGetProgramInfoLog;
+
+ /** @suppress {duplicate } */
+ var _glGetProgramiv = (program, pname, p) => {
+ if (!p) {
+ // GLES2 specification does not specify how to behave if p is a null
+ // pointer. Since calling this function does not make sense if p == null,
+ // issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+
+ if (program >= GL.counter) {
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+
+ program = GL.programs[program];
+
+ if (pname == 0x8B84) { // GL_INFO_LOG_LENGTH
+ var log = GLctx.getProgramInfoLog(program);
+ if (log === null) log = '(unknown error)';
+ HEAP32[((p)>>2)] = log.length + 1;checkInt32(log.length + 1);
+ } else if (pname == 0x8B87 /* GL_ACTIVE_UNIFORM_MAX_LENGTH */) {
+ if (!program.maxUniformLength) {
+ var numActiveUniforms = GLctx.getProgramParameter(program, 0x8B86/*GL_ACTIVE_UNIFORMS*/);
+ for (var i = 0; i < numActiveUniforms; ++i) {
+ program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length+1);
+ }
+ }
+ HEAP32[((p)>>2)] = program.maxUniformLength;checkInt32(program.maxUniformLength);
+ } else if (pname == 0x8B8A /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */) {
+ if (!program.maxAttributeLength) {
+ var numActiveAttributes = GLctx.getProgramParameter(program, 0x8B89/*GL_ACTIVE_ATTRIBUTES*/);
+ for (var i = 0; i < numActiveAttributes; ++i) {
+ program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length+1);
+ }
+ }
+ HEAP32[((p)>>2)] = program.maxAttributeLength;checkInt32(program.maxAttributeLength);
+ } else if (pname == 0x8A35 /* GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH */) {
+ if (!program.maxUniformBlockNameLength) {
+ var numActiveUniformBlocks = GLctx.getProgramParameter(program, 0x8A36/*GL_ACTIVE_UNIFORM_BLOCKS*/);
+ for (var i = 0; i < numActiveUniformBlocks; ++i) {
+ program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length+1);
+ }
+ }
+ HEAP32[((p)>>2)] = program.maxUniformBlockNameLength;checkInt32(program.maxUniformBlockNameLength);
+ } else {
+ HEAP32[((p)>>2)] = GLctx.getProgramParameter(program, pname);checkInt32(GLctx.getProgramParameter(program, pname));
+ }
+ };
+ var _emscripten_glGetProgramiv = _glGetProgramiv;
+
+
+ /** @suppress {duplicate } */
+ var _glGetQueryObjecti64vEXT = (id, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if p == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ var query = GL.queries[id];
+ var param;
+ if (GL.currentContext.version < 2)
+ {
+ param = GLctx.disjointTimerQueryExt['getQueryObjectEXT'](query, pname);
+ }
+ else {
+ param = GLctx.getQueryParameter(query, pname);
+ }
+ var ret;
+ if (typeof param == 'boolean') {
+ ret = param ? 1 : 0;
+ } else {
+ ret = param;
+ }
+ writeI53ToI64(params, ret);
+ };
+ var _emscripten_glGetQueryObjecti64vEXT = _glGetQueryObjecti64vEXT;
+
+ /** @suppress {duplicate } */
+ var _glGetQueryObjectivEXT = (id, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if p == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ var query = GL.queries[id];
+ var param = GLctx.disjointTimerQueryExt['getQueryObjectEXT'](query, pname);
+ var ret;
+ if (typeof param == 'boolean') {
+ ret = param ? 1 : 0;
+ } else {
+ ret = param;
+ }
+ HEAP32[((params)>>2)] = ret;checkInt32(ret);
+ };
+ var _emscripten_glGetQueryObjectivEXT = _glGetQueryObjectivEXT;
+
+
+ /** @suppress {duplicate } */
+ var _glGetQueryObjectui64vEXT = _glGetQueryObjecti64vEXT;
+ var _emscripten_glGetQueryObjectui64vEXT = _glGetQueryObjectui64vEXT;
+
+ /** @suppress {duplicate } */
+ var _glGetQueryObjectuiv = (id, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if p == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ var query = GL.queries[id];
+ var param = GLctx.getQueryParameter(query, pname);
+ var ret;
+ if (typeof param == 'boolean') {
+ ret = param ? 1 : 0;
+ } else {
+ ret = param;
+ }
+ HEAP32[((params)>>2)] = ret;checkInt32(ret);
+ };
+ var _emscripten_glGetQueryObjectuiv = _glGetQueryObjectuiv;
+
+
+ /** @suppress {duplicate } */
+ var _glGetQueryObjectuivEXT = _glGetQueryObjectivEXT;
+ var _emscripten_glGetQueryObjectuivEXT = _glGetQueryObjectuivEXT;
+
+ /** @suppress {duplicate } */
+ var _glGetQueryiv = (target, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if p == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAP32[((params)>>2)] = GLctx.getQuery(target, pname);checkInt32(GLctx.getQuery(target, pname));
+ };
+ var _emscripten_glGetQueryiv = _glGetQueryiv;
+
+ /** @suppress {duplicate } */
+ var _glGetQueryivEXT = (target, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if p == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAP32[((params)>>2)] = GLctx.disjointTimerQueryExt['getQueryEXT'](target, pname);checkInt32(GLctx.disjointTimerQueryExt['getQueryEXT'](target, pname));
+ };
+ var _emscripten_glGetQueryivEXT = _glGetQueryivEXT;
+
+ /** @suppress {duplicate } */
+ var _glGetRenderbufferParameteriv = (target, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if params == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAP32[((params)>>2)] = GLctx.getRenderbufferParameter(target, pname);checkInt32(GLctx.getRenderbufferParameter(target, pname));
+ };
+ var _emscripten_glGetRenderbufferParameteriv = _glGetRenderbufferParameteriv;
+
+ /** @suppress {duplicate } */
+ var _glGetSamplerParameterfv = (sampler, pname, params) => {
+ if (!params) {
+ // GLES3 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if p == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAPF32[((params)>>2)] = GLctx.getSamplerParameter(GL.samplers[sampler], pname);
+ };
+ var _emscripten_glGetSamplerParameterfv = _glGetSamplerParameterfv;
+
+ /** @suppress {duplicate } */
+ var _glGetSamplerParameteriv = (sampler, pname, params) => {
+ if (!params) {
+ // GLES3 specification does not specify how to behave if params is a null pointer. Since calling this function does not make sense
+ // if p == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAP32[((params)>>2)] = GLctx.getSamplerParameter(GL.samplers[sampler], pname);checkInt32(GLctx.getSamplerParameter(GL.samplers[sampler], pname));
+ };
+ var _emscripten_glGetSamplerParameteriv = _glGetSamplerParameteriv;
+
+
+ /** @suppress {duplicate } */
+ var _glGetShaderInfoLog = (shader, maxLength, length, infoLog) => {
+ var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
+ if (log === null) log = '(unknown error)';
+ var numBytesWrittenExclNull = (maxLength > 0 && infoLog) ? stringToUTF8(log, infoLog, maxLength) : 0;
+ if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull);
+ };
+ var _emscripten_glGetShaderInfoLog = _glGetShaderInfoLog;
+
+ /** @suppress {duplicate } */
+ var _glGetShaderPrecisionFormat = (shaderType, precisionType, range, precision) => {
+ var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType);
+ HEAP32[((range)>>2)] = result.rangeMin;checkInt32(result.rangeMin);
+ HEAP32[(((range)+(4))>>2)] = result.rangeMax;checkInt32(result.rangeMax);
+ HEAP32[((precision)>>2)] = result.precision;checkInt32(result.precision);
+ };
+ var _emscripten_glGetShaderPrecisionFormat = _glGetShaderPrecisionFormat;
+
+ /** @suppress {duplicate } */
+ var _glGetShaderSource = (shader, bufSize, length, source) => {
+ var result = GLctx.getShaderSource(GL.shaders[shader]);
+ if (!result) return; // If an error occurs, nothing will be written to length or source.
+ var numBytesWrittenExclNull = (bufSize > 0 && source) ? stringToUTF8(result, source, bufSize) : 0;
+ if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull);
+ };
+ var _emscripten_glGetShaderSource = _glGetShaderSource;
+
+ /** @suppress {duplicate } */
+ var _glGetShaderiv = (shader, pname, p) => {
+ if (!p) {
+ // GLES2 specification does not specify how to behave if p is a null
+ // pointer. Since calling this function does not make sense if p == null,
+ // issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ if (pname == 0x8B84) { // GL_INFO_LOG_LENGTH
+ var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
+ if (log === null) log = '(unknown error)';
+ // The GLES2 specification says that if the shader has an empty info log,
+ // a value of 0 is returned. Otherwise the log has a null char appended.
+ // (An empty string is falsey, so we can just check that instead of
+ // looking at log.length.)
+ var logLength = log ? log.length + 1 : 0;
+ HEAP32[((p)>>2)] = logLength;checkInt32(logLength);
+ } else if (pname == 0x8B88) { // GL_SHADER_SOURCE_LENGTH
+ var source = GLctx.getShaderSource(GL.shaders[shader]);
+ // source may be a null, or the empty string, both of which are falsey
+ // values that we report a 0 length for.
+ var sourceLength = source ? source.length + 1 : 0;
+ HEAP32[((p)>>2)] = sourceLength;checkInt32(sourceLength);
+ } else {
+ HEAP32[((p)>>2)] = GLctx.getShaderParameter(GL.shaders[shader], pname);checkInt32(GLctx.getShaderParameter(GL.shaders[shader], pname));
+ }
+ };
+ var _emscripten_glGetShaderiv = _glGetShaderiv;
+
+
+
+ var stringToNewUTF8 = (str) => {
+ var size = lengthBytesUTF8(str) + 1;
+ var ret = _malloc(size);
+ if (ret) stringToUTF8(str, ret, size);
+ return ret;
+ };
+
+
+ /** @suppress {duplicate } */
+ var _glGetString = (name_) => {
+ var ret = GL.stringCache[name_];
+ if (!ret) {
+ switch (name_) {
+ case 0x1F03 /* GL_EXTENSIONS */:
+ ret = stringToNewUTF8(webglGetExtensions().join(' '));
+ break;
+ case 0x1F00 /* GL_VENDOR */:
+ case 0x1F01 /* GL_RENDERER */:
+ case 0x9245 /* UNMASKED_VENDOR_WEBGL */:
+ case 0x9246 /* UNMASKED_RENDERER_WEBGL */:
+ var s = GLctx.getParameter(name_);
+ if (!s) {
+ GL.recordError(0x500/*GL_INVALID_ENUM*/);
+ }
+ ret = s ? stringToNewUTF8(s) : 0;
+ break;
+
+ case 0x1F02 /* GL_VERSION */:
+ var webGLVersion = GLctx.getParameter(0x1F02 /*GL_VERSION*/);
+ // return GLES version string corresponding to the version of the WebGL context
+ var glVersion = `OpenGL ES 2.0 (${webGLVersion})`;
+ if (GL.currentContext.version >= 2) glVersion = `OpenGL ES 3.0 (${webGLVersion})`;
+ ret = stringToNewUTF8(glVersion);
+ break;
+ case 0x8B8C /* GL_SHADING_LANGUAGE_VERSION */:
+ var glslVersion = GLctx.getParameter(0x8B8C /*GL_SHADING_LANGUAGE_VERSION*/);
+ // extract the version number 'N.M' from the string 'WebGL GLSL ES N.M ...'
+ var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;
+ var ver_num = glslVersion.match(ver_re);
+ if (ver_num !== null) {
+ if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + '0'; // ensure minor version has 2 digits
+ glslVersion = `OpenGL ES GLSL ES ${ver_num[1]} (${glslVersion})`;
+ }
+ ret = stringToNewUTF8(glslVersion);
+ break;
+ default:
+ GL.recordError(0x500/*GL_INVALID_ENUM*/);
+ // fall through
+ }
+ GL.stringCache[name_] = ret;
+ }
+ return ret;
+ };
+ var _emscripten_glGetString = _glGetString;
+
+
+ /** @suppress {duplicate } */
+ var _glGetStringi = (name, index) => {
+ if (GL.currentContext.version < 2) {
+ GL.recordError(0x502 /* GL_INVALID_OPERATION */); // Calling GLES3/WebGL2 function with a GLES2/WebGL1 context
+ return 0;
+ }
+ var stringiCache = GL.stringiCache[name];
+ if (stringiCache) {
+ if (index < 0 || index >= stringiCache.length) {
+ GL.recordError(0x501/*GL_INVALID_VALUE*/);
+ return 0;
+ }
+ return stringiCache[index];
+ }
+ switch (name) {
+ case 0x1F03 /* GL_EXTENSIONS */:
+ var exts = webglGetExtensions().map(stringToNewUTF8);
+ stringiCache = GL.stringiCache[name] = exts;
+ if (index < 0 || index >= stringiCache.length) {
+ GL.recordError(0x501/*GL_INVALID_VALUE*/);
+ return 0;
+ }
+ return stringiCache[index];
+ default:
+ GL.recordError(0x500/*GL_INVALID_ENUM*/);
+ return 0;
+ }
+ };
+ var _emscripten_glGetStringi = _glGetStringi;
+
+ /** @suppress {duplicate } */
+ var _glGetSynciv = (sync, pname, bufSize, length, values) => {
+ if (bufSize < 0) {
+ // GLES3 specification does not specify how to behave if bufSize < 0, however in the spec wording for glGetInternalformativ, it does say that GL_INVALID_VALUE should be raised,
+ // so raise GL_INVALID_VALUE here as well.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ if (!values) {
+ // GLES3 specification does not specify how to behave if values is a null pointer. Since calling this function does not make sense
+ // if values == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ var ret = GLctx.getSyncParameter(GL.syncs[sync], pname);
+ if (ret !== null) {
+ HEAP32[((values)>>2)] = ret;checkInt32(ret);
+ if (length) HEAP32[((length)>>2)] = 1;checkInt32(1); // Report a single value outputted.
+ }
+ };
+ var _emscripten_glGetSynciv = _glGetSynciv;
+
+ /** @suppress {duplicate } */
+ var _glGetTexParameterfv = (target, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null
+ // pointer. Since calling this function does not make sense if p == null,
+ // issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAPF32[((params)>>2)] = GLctx.getTexParameter(target, pname);
+ };
+ var _emscripten_glGetTexParameterfv = _glGetTexParameterfv;
+
+ /** @suppress {duplicate } */
+ var _glGetTexParameteriv = (target, pname, params) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null
+ // pointer. Since calling this function does not make sense if p == null,
+ // issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAP32[((params)>>2)] = GLctx.getTexParameter(target, pname);checkInt32(GLctx.getTexParameter(target, pname));
+ };
+ var _emscripten_glGetTexParameteriv = _glGetTexParameteriv;
+
+ /** @suppress {duplicate } */
+ var _glGetTransformFeedbackVarying = (program, index, bufSize, length, size, type, name) => {
+ program = GL.programs[program];
+ var info = GLctx.getTransformFeedbackVarying(program, index);
+ if (!info) return; // If an error occurred, the return parameters length, size, type and name will be unmodified.
+
+ if (name && bufSize > 0) {
+ var numBytesWrittenExclNull = stringToUTF8(info.name, name, bufSize);
+ if (length) HEAP32[((length)>>2)] = numBytesWrittenExclNull;checkInt32(numBytesWrittenExclNull);
+ } else {
+ if (length) HEAP32[((length)>>2)] = 0;checkInt32(0);
+ }
+
+ if (size) HEAP32[((size)>>2)] = info.size;checkInt32(info.size);
+ if (type) HEAP32[((type)>>2)] = info.type;checkInt32(info.type);
+ };
+ var _emscripten_glGetTransformFeedbackVarying = _glGetTransformFeedbackVarying;
+
+ /** @suppress {duplicate } */
+ var _glGetUniformBlockIndex = (program, uniformBlockName) => {
+ return GLctx.getUniformBlockIndex(GL.programs[program], UTF8ToString(uniformBlockName));
+ };
+ var _emscripten_glGetUniformBlockIndex = _glGetUniformBlockIndex;
+
+ /** @suppress {duplicate } */
+ var _glGetUniformIndices = (program, uniformCount, uniformNames, uniformIndices) => {
+ if (!uniformIndices) {
+ // GLES2 specification does not specify how to behave if uniformIndices is a null pointer. Since calling this function does not make sense
+ // if uniformIndices == null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ if (uniformCount > 0 && (uniformNames == 0 || uniformIndices == 0)) {
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ program = GL.programs[program];
+ var names = [];
+ for (var i = 0; i < uniformCount; i++)
+ names.push(UTF8ToString(HEAP32[(((uniformNames)+(i*4))>>2)]));
+
+ var result = GLctx.getUniformIndices(program, names);
+ if (!result) return; // GL spec: If an error is generated, nothing is written out to uniformIndices.
+
+ var len = result.length;
+ for (var i = 0; i < len; i++) {
+ HEAP32[(((uniformIndices)+(i*4))>>2)] = result[i];checkInt32(result[i]);
+ }
+ };
+ var _emscripten_glGetUniformIndices = _glGetUniformIndices;
+
+ /** @suppress {checkTypes} */
+ var jstoi_q = (str) => parseInt(str);
+
+ /** @noinline */
+ var webglGetLeftBracePos = (name) => name.slice(-1) == ']' && name.lastIndexOf('[');
+
+ var webglPrepareUniformLocationsBeforeFirstUse = (program) => {
+ var uniformLocsById = program.uniformLocsById, // Maps GLuint -> WebGLUniformLocation
+ uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, // Maps name -> [uniform array length, GLuint]
+ i, j;
+
+ // On the first time invocation of glGetUniformLocation on this shader program:
+ // initialize cache data structures and discover which uniforms are arrays.
+ if (!uniformLocsById) {
+ // maps GLint integer locations to WebGLUniformLocations
+ program.uniformLocsById = uniformLocsById = {};
+ // maps integer locations back to uniform name strings, so that we can lazily fetch uniform array locations
+ program.uniformArrayNamesById = {};
+
+ var numActiveUniforms = GLctx.getProgramParameter(program, 0x8B86/*GL_ACTIVE_UNIFORMS*/);
+ for (i = 0; i < numActiveUniforms; ++i) {
+ var u = GLctx.getActiveUniform(program, i);
+ var nm = u.name;
+ var sz = u.size;
+ var lb = webglGetLeftBracePos(nm);
+ var arrayName = lb > 0 ? nm.slice(0, lb) : nm;
+
+ // Assign a new location.
+ var id = program.uniformIdCounter;
+ program.uniformIdCounter += sz;
+ // Eagerly get the location of the uniformArray[0] base element.
+ // The remaining indices >0 will be left for lazy evaluation to
+ // improve performance. Those may never be needed to fetch, if the
+ // application fills arrays always in full starting from the first
+ // element of the array.
+ uniformSizeAndIdsByName[arrayName] = [sz, id];
+
+ // Store placeholder integers in place that highlight that these
+ // >0 index locations are array indices pending population.
+ for (j = 0; j < sz; ++j) {
+ uniformLocsById[id] = j;
+ program.uniformArrayNamesById[id++] = arrayName;
+ }
+ }
+ }
+ };
+
+
+
+ /** @suppress {duplicate } */
+ var _glGetUniformLocation = (program, name) => {
+
+ name = UTF8ToString(name);
+
+ if (program = GL.programs[program]) {
+ webglPrepareUniformLocationsBeforeFirstUse(program);
+ var uniformLocsById = program.uniformLocsById; // Maps GLuint -> WebGLUniformLocation
+ var arrayIndex = 0;
+ var uniformBaseName = name;
+
+ // Invariant: when populating integer IDs for uniform locations, we must
+ // maintain the precondition that arrays reside in contiguous addresses,
+ // i.e. for a 'vec4 colors[10];', colors[4] must be at location
+ // colors[0]+4. However, user might call glGetUniformLocation(program,
+ // "colors") for an array, so we cannot discover based on the user input
+ // arguments whether the uniform we are dealing with is an array. The only
+ // way to discover which uniforms are arrays is to enumerate over all the
+ // active uniforms in the program.
+ var leftBrace = webglGetLeftBracePos(name);
+
+ // If user passed an array accessor "[index]", parse the array index off the accessor.
+ if (leftBrace > 0) {
+ arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0; // "index]", coerce parseInt(']') with >>>0 to treat "foo[]" as "foo[0]" and foo[-1] as unsigned out-of-bounds.
+ uniformBaseName = name.slice(0, leftBrace);
+ }
+
+ // Have we cached the location of this uniform before?
+ // A pair [array length, GLint of the uniform location]
+ var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName];
+
+ // If an uniform with this name exists, and if its index is within the
+ // array limits (if it's even an array), query the WebGLlocation, or
+ // return an existing cached location.
+ if (sizeAndId && arrayIndex < sizeAndId[0]) {
+ arrayIndex += sizeAndId[1]; // Add the base location of the uniform to the array index offset.
+ if ((uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name))) {
+ return arrayIndex;
+ }
+ }
+ }
+ else {
+ // N.b. we are currently unable to distinguish between GL program IDs that
+ // never existed vs GL program IDs that have been deleted, so report
+ // GL_INVALID_VALUE in both cases.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ }
+ return -1;
+ };
+ var _emscripten_glGetUniformLocation = _glGetUniformLocation;
+
+ var webglGetUniformLocation = (location) => {
+ var p = GLctx.currentProgram;
+
+ if (p) {
+ var webglLoc = p.uniformLocsById[location];
+ // p.uniformLocsById[location] stores either an integer, or a
+ // WebGLUniformLocation.
+ // If an integer, we have not yet bound the location, so do it now. The
+ // integer value specifies the array index we should bind to.
+ if (typeof webglLoc == 'number') {
+ p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(p, p.uniformArrayNamesById[location] + (webglLoc > 0 ? `[${webglLoc}]` : ''));
+ }
+ // Else an already cached WebGLUniformLocation, return it.
+ return webglLoc;
+ } else {
+ GL.recordError(0x502/*GL_INVALID_OPERATION*/);
+ }
+ };
+
+
+ /** @suppress{checkTypes} */
+ var emscriptenWebGLGetUniform = (program, location, params, type) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null
+ // pointer. Since calling this function does not make sense if params ==
+ // null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ program = GL.programs[program];
+ webglPrepareUniformLocationsBeforeFirstUse(program);
+ var data = GLctx.getUniform(program, webglGetUniformLocation(location));
+ if (typeof data == 'number' || typeof data == 'boolean') {
+ switch (type) {
+ case 0: HEAP32[((params)>>2)] = data;checkInt32(data); break;
+ case 2: HEAPF32[((params)>>2)] = data; break;
+ }
+ } else {
+ for (var i = 0; i < data.length; i++) {
+ switch (type) {
+ case 0: HEAP32[(((params)+(i*4))>>2)] = data[i];checkInt32(data[i]); break;
+ case 2: HEAPF32[(((params)+(i*4))>>2)] = data[i]; break;
+ }
+ }
+ }
+ };
+
+ /** @suppress {duplicate } */
+ var _glGetUniformfv = (program, location, params) => {
+ emscriptenWebGLGetUniform(program, location, params, 2);
+ };
+ var _emscripten_glGetUniformfv = _glGetUniformfv;
+
+
+ /** @suppress {duplicate } */
+ var _glGetUniformiv = (program, location, params) => {
+ emscriptenWebGLGetUniform(program, location, params, 0);
+ };
+ var _emscripten_glGetUniformiv = _glGetUniformiv;
+
+ /** @suppress {duplicate } */
+ var _glGetUniformuiv = (program, location, params) =>
+ emscriptenWebGLGetUniform(program, location, params, 0);
+ var _emscripten_glGetUniformuiv = _glGetUniformuiv;
+
+ /** @suppress{checkTypes} */
+ var emscriptenWebGLGetVertexAttrib = (index, pname, params, type) => {
+ if (!params) {
+ // GLES2 specification does not specify how to behave if params is a null
+ // pointer. Since calling this function does not make sense if params ==
+ // null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ var data = GLctx.getVertexAttrib(index, pname);
+ if (pname == 0x889F/*VERTEX_ATTRIB_ARRAY_BUFFER_BINDING*/) {
+ HEAP32[((params)>>2)] = data && data["name"];checkInt32(data && data["name"]);
+ } else if (typeof data == 'number' || typeof data == 'boolean') {
+ switch (type) {
+ case 0: HEAP32[((params)>>2)] = data;checkInt32(data); break;
+ case 2: HEAPF32[((params)>>2)] = data; break;
+ case 5: HEAP32[((params)>>2)] = Math.fround(data);checkInt32(Math.fround(data)); break;
+ }
+ } else {
+ for (var i = 0; i < data.length; i++) {
+ switch (type) {
+ case 0: HEAP32[(((params)+(i*4))>>2)] = data[i];checkInt32(data[i]); break;
+ case 2: HEAPF32[(((params)+(i*4))>>2)] = data[i]; break;
+ case 5: HEAP32[(((params)+(i*4))>>2)] = Math.fround(data[i]);checkInt32(Math.fround(data[i])); break;
+ }
+ }
+ }
+ };
+ /** @suppress {duplicate } */
+ var _glGetVertexAttribIiv = (index, pname, params) => {
+ // N.B. This function may only be called if the vertex attribute was specified using the function glVertexAttribI4iv(),
+ // otherwise the results are undefined. (GLES3 spec 6.1.12)
+ emscriptenWebGLGetVertexAttrib(index, pname, params, 0);
+ };
+ var _emscripten_glGetVertexAttribIiv = _glGetVertexAttribIiv;
+
+
+ /** @suppress {duplicate } */
+ var _glGetVertexAttribIuiv = _glGetVertexAttribIiv;
+ var _emscripten_glGetVertexAttribIuiv = _glGetVertexAttribIuiv;
+
+ /** @suppress {duplicate } */
+ var _glGetVertexAttribPointerv = (index, pname, pointer) => {
+ if (!pointer) {
+ // GLES2 specification does not specify how to behave if pointer is a null
+ // pointer. Since calling this function does not make sense if pointer ==
+ // null, issue a GL error to notify user about it.
+ GL.recordError(0x501 /* GL_INVALID_VALUE */);
+ return;
+ }
+ HEAP32[((pointer)>>2)] = GLctx.getVertexAttribOffset(index, pname);checkInt32(GLctx.getVertexAttribOffset(index, pname));
+ };
+ var _emscripten_glGetVertexAttribPointerv = _glGetVertexAttribPointerv;
+
+
+ /** @suppress {duplicate } */
+ var _glGetVertexAttribfv = (index, pname, params) => {
+ // N.B. This function may only be called if the vertex attribute was
+ // specified using the function glVertexAttrib*f(), otherwise the results
+ // are undefined. (GLES3 spec 6.1.12)
+ emscriptenWebGLGetVertexAttrib(index, pname, params, 2);
+ };
+ var _emscripten_glGetVertexAttribfv = _glGetVertexAttribfv;
+
+
+ /** @suppress {duplicate } */
+ var _glGetVertexAttribiv = (index, pname, params) => {
+ // N.B. This function may only be called if the vertex attribute was
+ // specified using the function glVertexAttrib*f(), otherwise the results
+ // are undefined. (GLES3 spec 6.1.12)
+ emscriptenWebGLGetVertexAttrib(index, pname, params, 5);
+ };
+ var _emscripten_glGetVertexAttribiv = _glGetVertexAttribiv;
+
+ /** @suppress {duplicate } */
+ var _glHint = (x0, x1) => GLctx.hint(x0, x1);
+ var _emscripten_glHint = _glHint;
+
+ /** @suppress {duplicate } */
+ var _glInvalidateFramebuffer = (target, numAttachments, attachments) => {
+ var list = tempFixedLengthArray[numAttachments];
+ for (var i = 0; i < numAttachments; i++) {
+ list[i] = HEAP32[(((attachments)+(i*4))>>2)];
+ }
+
+ GLctx.invalidateFramebuffer(target, list);
+ };
+ var _emscripten_glInvalidateFramebuffer = _glInvalidateFramebuffer;
+
+ /** @suppress {duplicate } */
+ var _glInvalidateSubFramebuffer = (target, numAttachments, attachments, x, y, width, height) => {
+ var list = tempFixedLengthArray[numAttachments];
+ for (var i = 0; i < numAttachments; i++) {
+ list[i] = HEAP32[(((attachments)+(i*4))>>2)];
+ }
+
+ GLctx.invalidateSubFramebuffer(target, list, x, y, width, height);
+ };
+ var _emscripten_glInvalidateSubFramebuffer = _glInvalidateSubFramebuffer;
+
+ /** @suppress {duplicate } */
+ var _glIsBuffer = (buffer) => {
+ var b = GL.buffers[buffer];
+ if (!b) return 0;
+ return GLctx.isBuffer(b);
+ };
+ var _emscripten_glIsBuffer = _glIsBuffer;
+
+ /** @suppress {duplicate } */
+ var _glIsEnabled = (x0) => GLctx.isEnabled(x0);
+ var _emscripten_glIsEnabled = _glIsEnabled;
+
+ /** @suppress {duplicate } */
+ var _glIsFramebuffer = (framebuffer) => {
+ var fb = GL.framebuffers[framebuffer];
+ if (!fb) return 0;
+ return GLctx.isFramebuffer(fb);
+ };
+ var _emscripten_glIsFramebuffer = _glIsFramebuffer;
+
+ /** @suppress {duplicate } */
+ var _glIsProgram = (program) => {
+ program = GL.programs[program];
+ if (!program) return 0;
+ return GLctx.isProgram(program);
+ };
+ var _emscripten_glIsProgram = _glIsProgram;
+
+ /** @suppress {duplicate } */
+ var _glIsQuery = (id) => {
+ var query = GL.queries[id];
+ if (!query) return 0;
+ return GLctx.isQuery(query);
+ };
+ var _emscripten_glIsQuery = _glIsQuery;
+
+ /** @suppress {duplicate } */
+ var _glIsQueryEXT = (id) => {
+ var query = GL.queries[id];
+ if (!query) return 0;
+ return GLctx.disjointTimerQueryExt['isQueryEXT'](query);
+ };
+ var _emscripten_glIsQueryEXT = _glIsQueryEXT;
+
+ /** @suppress {duplicate } */
+ var _glIsRenderbuffer = (renderbuffer) => {
+ var rb = GL.renderbuffers[renderbuffer];
+ if (!rb) return 0;
+ return GLctx.isRenderbuffer(rb);
+ };
+ var _emscripten_glIsRenderbuffer = _glIsRenderbuffer;
+
+ /** @suppress {duplicate } */
+ var _glIsSampler = (id) => {
+ var sampler = GL.samplers[id];
+ if (!sampler) return 0;
+ return GLctx.isSampler(sampler);
+ };
+ var _emscripten_glIsSampler = _glIsSampler;
+
+ /** @suppress {duplicate } */
+ var _glIsShader = (shader) => {
+ var s = GL.shaders[shader];
+ if (!s) return 0;
+ return GLctx.isShader(s);
+ };
+ var _emscripten_glIsShader = _glIsShader;
+
+ /** @suppress {duplicate } */
+ var _glIsSync = (sync) => GLctx.isSync(GL.syncs[sync]);
+ var _emscripten_glIsSync = _glIsSync;
+
+ /** @suppress {duplicate } */
+ var _glIsTexture = (id) => {
+ var texture = GL.textures[id];
+ if (!texture) return 0;
+ return GLctx.isTexture(texture);
+ };
+ var _emscripten_glIsTexture = _glIsTexture;
+
+ /** @suppress {duplicate } */
+ var _glIsTransformFeedback = (id) => GLctx.isTransformFeedback(GL.transformFeedbacks[id]);
+ var _emscripten_glIsTransformFeedback = _glIsTransformFeedback;
+
+ /** @suppress {duplicate } */
+ var _glIsVertexArray = (array) => {
+
+ var vao = GL.vaos[array];
+ if (!vao) return 0;
+ return GLctx.isVertexArray(vao);
+ };
+ var _emscripten_glIsVertexArray = _glIsVertexArray;
+
+
+ /** @suppress {duplicate } */
+ var _glIsVertexArrayOES = _glIsVertexArray;
+ var _emscripten_glIsVertexArrayOES = _glIsVertexArrayOES;
+
+ /** @suppress {duplicate } */
+ var _glLineWidth = (x0) => GLctx.lineWidth(x0);
+ var _emscripten_glLineWidth = _glLineWidth;
+
+ /** @suppress {duplicate } */
+ var _glLinkProgram = (program) => {
+ program = GL.programs[program];
+ GLctx.linkProgram(program);
+ // Invalidate earlier computed uniform->ID mappings, those have now become stale
+ program.uniformLocsById = 0; // Mark as null-like so that glGetUniformLocation() knows to populate this again.
+ program.uniformSizeAndIdsByName = {};
+
+ };
+ var _emscripten_glLinkProgram = _glLinkProgram;
+
+ /** @suppress {duplicate } */
+ var _glPauseTransformFeedback = () => GLctx.pauseTransformFeedback();
+ var _emscripten_glPauseTransformFeedback = _glPauseTransformFeedback;
+
+ /** @suppress {duplicate } */
+ var _glPixelStorei = (pname, param) => {
+ if (pname == 3317) {
+ GL.unpackAlignment = param;
+ } else if (pname == 3314) {
+ GL.unpackRowLength = param;
+ }
+ GLctx.pixelStorei(pname, param);
+ };
+ var _emscripten_glPixelStorei = _glPixelStorei;
+
+ /** @suppress {duplicate } */
+ var _glPolygonModeWEBGL = (face, mode) => {
+ GLctx.webglPolygonMode['polygonModeWEBGL'](face, mode);
+ };
+ var _emscripten_glPolygonModeWEBGL = _glPolygonModeWEBGL;
+
+ /** @suppress {duplicate } */
+ var _glPolygonOffset = (x0, x1) => GLctx.polygonOffset(x0, x1);
+ var _emscripten_glPolygonOffset = _glPolygonOffset;
+
+ /** @suppress {duplicate } */
+ var _glPolygonOffsetClampEXT = (factor, units, clamp) => {
+ GLctx.extPolygonOffsetClamp['polygonOffsetClampEXT'](factor, units, clamp);
+ };
+ var _emscripten_glPolygonOffsetClampEXT = _glPolygonOffsetClampEXT;
+
+ /** @suppress {duplicate } */
+ var _glProgramBinary = (program, binaryFormat, binary, length) => {
+ GL.recordError(0x500/*GL_INVALID_ENUM*/);
+ };
+ var _emscripten_glProgramBinary = _glProgramBinary;
+
+ /** @suppress {duplicate } */
+ var _glProgramParameteri = (program, pname, value) => {
+ GL.recordError(0x500/*GL_INVALID_ENUM*/);
+ };
+ var _emscripten_glProgramParameteri = _glProgramParameteri;
+
+ /** @suppress {duplicate } */
+ var _glQueryCounterEXT = (id, target) => {
+ GLctx.disjointTimerQueryExt['queryCounterEXT'](GL.queries[id], target);
+ };
+ var _emscripten_glQueryCounterEXT = _glQueryCounterEXT;
+
+ /** @suppress {duplicate } */
+ var _glReadBuffer = (x0) => GLctx.readBuffer(x0);
+ var _emscripten_glReadBuffer = _glReadBuffer;
+
+ var computeUnpackAlignedImageSize = (width, height, sizePerPixel) => {
+ function roundedToNextMultipleOf(x, y) {
+ return (x + y - 1) & -y;
+ }
+ var plainRowSize = (GL.unpackRowLength || width) * sizePerPixel;
+ var alignedRowSize = roundedToNextMultipleOf(plainRowSize, GL.unpackAlignment);
+ return height * alignedRowSize;
+ };
+
+ var colorChannelsInGlTextureFormat = (format) => {
+ // Micro-optimizations for size: map format to size by subtracting smallest
+ // enum value (0x1902) from all values first. Also omit the most common
+ // size value (1) from the list, which is assumed by formats not on the
+ // list.
+ var colorChannels = {
+ // 0x1902 /* GL_DEPTH_COMPONENT */ - 0x1902: 1,
+ // 0x1906 /* GL_ALPHA */ - 0x1902: 1,
+ 5: 3,
+ 6: 4,
+ // 0x1909 /* GL_LUMINANCE */ - 0x1902: 1,
+ 8: 2,
+ 29502: 3,
+ 29504: 4,
+ // 0x1903 /* GL_RED */ - 0x1902: 1,
+ 26917: 2,
+ 26918: 2,
+ // 0x8D94 /* GL_RED_INTEGER */ - 0x1902: 1,
+ 29846: 3,
+ 29847: 4
+ };
+ return colorChannels[format - 0x1902]||1;
+ };
+
+ var heapObjectForWebGLType = (type) => {
+ // Micro-optimization for size: Subtract lowest GL enum number (0x1400/* GL_BYTE */) from type to compare
+ // smaller values for the heap, for shorter generated code size.
+ // Also the type HEAPU16 is not tested for explicitly, but any unrecognized type will return out HEAPU16.
+ // (since most types are HEAPU16)
+ type -= 0x1400;
+ if (type == 0) return HEAP8;
+
+ if (type == 1) return HEAPU8;
+
+ if (type == 2) return HEAP16;
+
+ if (type == 4) return HEAP32;
+
+ if (type == 6) return HEAPF32;
+
+ if (type == 5
+ || type == 28922
+ || type == 28520
+ || type == 30779
+ || type == 30782
+ )
+ return HEAPU32;
+
+ return HEAPU16;
+ };
+
+ var toTypedArrayIndex = (pointer, heap) =>
+ pointer >>> (31 - Math.clz32(heap.BYTES_PER_ELEMENT));
+
+ var emscriptenWebGLGetTexPixelData = (type, format, width, height, pixels, internalFormat) => {
+ var heap = heapObjectForWebGLType(type);
+ var sizePerPixel = colorChannelsInGlTextureFormat(format) * heap.BYTES_PER_ELEMENT;
+ var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel);
+ return heap.subarray(toTypedArrayIndex(pixels, heap), toTypedArrayIndex(pixels + bytes, heap));
+ };
+
+
+
+ /** @suppress {duplicate } */
+ var _glReadPixels = (x, y, width, height, format, type, pixels) => {
+ if (GL.currentContext.version >= 2) {
+ if (GLctx.currentPixelPackBufferBinding) {
+ GLctx.readPixels(x, y, width, height, format, type, pixels);
+ return;
+ }
+ var heap = heapObjectForWebGLType(type);
+ var target = toTypedArrayIndex(pixels, heap);
+ GLctx.readPixels(x, y, width, height, format, type, heap, target);
+ return;
+ }
+ var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format);
+ if (!pixelData) {
+ GL.recordError(0x500/*GL_INVALID_ENUM*/);
+ return;
+ }
+ GLctx.readPixels(x, y, width, height, format, type, pixelData);
+ };
+ var _emscripten_glReadPixels = _glReadPixels;
+
+ /** @suppress {duplicate } */
+ var _glReleaseShaderCompiler = () => {
+ // NOP (as allowed by GLES 2.0 spec)
+ };
+ var _emscripten_glReleaseShaderCompiler = _glReleaseShaderCompiler;
+
+ /** @suppress {duplicate } */
+ var _glRenderbufferStorage = (x0, x1, x2, x3) => GLctx.renderbufferStorage(x0, x1, x2, x3);
+ var _emscripten_glRenderbufferStorage = _glRenderbufferStorage;
+
+ /** @suppress {duplicate } */
+ var _glRenderbufferStorageMultisample = (x0, x1, x2, x3, x4) => GLctx.renderbufferStorageMultisample(x0, x1, x2, x3, x4);
+ var _emscripten_glRenderbufferStorageMultisample = _glRenderbufferStorageMultisample;
+
+ /** @suppress {duplicate } */
+ var _glResumeTransformFeedback = () => GLctx.resumeTransformFeedback();
+ var _emscripten_glResumeTransformFeedback = _glResumeTransformFeedback;
+
+ /** @suppress {duplicate } */
+ var _glSampleCoverage = (value, invert) => {
+ GLctx.sampleCoverage(value, !!invert);
+ };
+ var _emscripten_glSampleCoverage = _glSampleCoverage;
+
+ /** @suppress {duplicate } */
+ var _glSamplerParameterf = (sampler, pname, param) => {
+ GLctx.samplerParameterf(GL.samplers[sampler], pname, param);
+ };
+ var _emscripten_glSamplerParameterf = _glSamplerParameterf;
+
+ /** @suppress {duplicate } */
+ var _glSamplerParameterfv = (sampler, pname, params) => {
+ var param = HEAPF32[((params)>>2)];
+ GLctx.samplerParameterf(GL.samplers[sampler], pname, param);
+ };
+ var _emscripten_glSamplerParameterfv = _glSamplerParameterfv;
+
+ /** @suppress {duplicate } */
+ var _glSamplerParameteri = (sampler, pname, param) => {
+ GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
+ };
+ var _emscripten_glSamplerParameteri = _glSamplerParameteri;
+
+ /** @suppress {duplicate } */
+ var _glSamplerParameteriv = (sampler, pname, params) => {
+ var param = HEAP32[((params)>>2)];
+ GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
+ };
+ var _emscripten_glSamplerParameteriv = _glSamplerParameteriv;
+
+ /** @suppress {duplicate } */
+ var _glScissor = (x0, x1, x2, x3) => GLctx.scissor(x0, x1, x2, x3);
+ var _emscripten_glScissor = _glScissor;
+
+ /** @suppress {duplicate } */
+ var _glShaderBinary = (count, shaders, binaryformat, binary, length) => {
+ GL.recordError(0x500/*GL_INVALID_ENUM*/);
+ };
+ var _emscripten_glShaderBinary = _glShaderBinary;
+
+ /** @suppress {duplicate } */
+ var _glShaderSource = (shader, count, string, length) => {
+ var source = GL.getSource(shader, count, string, length);
+
+ GLctx.shaderSource(GL.shaders[shader], source);
+ };
+ var _emscripten_glShaderSource = _glShaderSource;
+
+ /** @suppress {duplicate } */
+ var _glStencilFunc = (x0, x1, x2) => GLctx.stencilFunc(x0, x1, x2);
+ var _emscripten_glStencilFunc = _glStencilFunc;
+
+ /** @suppress {duplicate } */
+ var _glStencilFuncSeparate = (x0, x1, x2, x3) => GLctx.stencilFuncSeparate(x0, x1, x2, x3);
+ var _emscripten_glStencilFuncSeparate = _glStencilFuncSeparate;
+
+ /** @suppress {duplicate } */
+ var _glStencilMask = (x0) => GLctx.stencilMask(x0);
+ var _emscripten_glStencilMask = _glStencilMask;
+
+ /** @suppress {duplicate } */
+ var _glStencilMaskSeparate = (x0, x1) => GLctx.stencilMaskSeparate(x0, x1);
+ var _emscripten_glStencilMaskSeparate = _glStencilMaskSeparate;
+
+ /** @suppress {duplicate } */
+ var _glStencilOp = (x0, x1, x2) => GLctx.stencilOp(x0, x1, x2);
+ var _emscripten_glStencilOp = _glStencilOp;
+
+ /** @suppress {duplicate } */
+ var _glStencilOpSeparate = (x0, x1, x2, x3) => GLctx.stencilOpSeparate(x0, x1, x2, x3);
+ var _emscripten_glStencilOpSeparate = _glStencilOpSeparate;
+
+
+
+
+ /** @suppress {duplicate } */
+ var _glTexImage2D = (target, level, internalFormat, width, height, border, format, type, pixels) => {
+ if (GL.currentContext.version >= 2) {
+ if (GLctx.currentPixelUnpackBufferBinding) {
+ GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
+ return;
+ }
+ if (pixels) {
+ var heap = heapObjectForWebGLType(type);
+ var index = toTypedArrayIndex(pixels, heap);
+ GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, index);
+ return;
+ }
+ }
+ var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null;
+ GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixelData);
+ };
+ var _emscripten_glTexImage2D = _glTexImage2D;
+
+
+ /** @suppress {duplicate } */
+ var _glTexImage3D = (target, level, internalFormat, width, height, depth, border, format, type, pixels) => {
+ if (GLctx.currentPixelUnpackBufferBinding) {
+ GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels);
+ } else if (pixels) {
+ var heap = heapObjectForWebGLType(type);
+ GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, heap, toTypedArrayIndex(pixels, heap));
+ } else {
+ GLctx.texImage3D(target, level, internalFormat, width, height, depth, border, format, type, null);
+ }
+ };
+ var _emscripten_glTexImage3D = _glTexImage3D;
+
+ /** @suppress {duplicate } */
+ var _glTexParameterf = (x0, x1, x2) => GLctx.texParameterf(x0, x1, x2);
+ var _emscripten_glTexParameterf = _glTexParameterf;
+
+ /** @suppress {duplicate } */
+ var _glTexParameterfv = (target, pname, params) => {
+ var param = HEAPF32[((params)>>2)];
+ GLctx.texParameterf(target, pname, param);
+ };
+ var _emscripten_glTexParameterfv = _glTexParameterfv;
+
+ /** @suppress {duplicate } */
+ var _glTexParameteri = (x0, x1, x2) => GLctx.texParameteri(x0, x1, x2);
+ var _emscripten_glTexParameteri = _glTexParameteri;
+
+ /** @suppress {duplicate } */
+ var _glTexParameteriv = (target, pname, params) => {
+ var param = HEAP32[((params)>>2)];
+ GLctx.texParameteri(target, pname, param);
+ };
+ var _emscripten_glTexParameteriv = _glTexParameteriv;
+
+ /** @suppress {duplicate } */
+ var _glTexStorage2D = (x0, x1, x2, x3, x4) => GLctx.texStorage2D(x0, x1, x2, x3, x4);
+ var _emscripten_glTexStorage2D = _glTexStorage2D;
+
+ /** @suppress {duplicate } */
+ var _glTexStorage3D = (x0, x1, x2, x3, x4, x5) => GLctx.texStorage3D(x0, x1, x2, x3, x4, x5);
+ var _emscripten_glTexStorage3D = _glTexStorage3D;
+
+
+
+
+ /** @suppress {duplicate } */
+ var _glTexSubImage2D = (target, level, xoffset, yoffset, width, height, format, type, pixels) => {
+ if (GL.currentContext.version >= 2) {
+ if (GLctx.currentPixelUnpackBufferBinding) {
+ GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+ return;
+ }
+ if (pixels) {
+ var heap = heapObjectForWebGLType(type);
+ GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, heap, toTypedArrayIndex(pixels, heap));
+ return;
+ }
+ }
+ var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0) : null;
+ GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData);
+ };
+ var _emscripten_glTexSubImage2D = _glTexSubImage2D;
+
+
+ /** @suppress {duplicate } */
+ var _glTexSubImage3D = (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) => {
+ if (GLctx.currentPixelUnpackBufferBinding) {
+ GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+ } else if (pixels) {
+ var heap = heapObjectForWebGLType(type);
+ GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, heap, toTypedArrayIndex(pixels, heap));
+ } else {
+ GLctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null);
+ }
+ };
+ var _emscripten_glTexSubImage3D = _glTexSubImage3D;
+
+ /** @suppress {duplicate } */
+ var _glTransformFeedbackVaryings = (program, count, varyings, bufferMode) => {
+ program = GL.programs[program];
+ var vars = [];
+ for (var i = 0; i < count; i++)
+ vars.push(UTF8ToString(HEAP32[(((varyings)+(i*4))>>2)]));
+
+ GLctx.transformFeedbackVaryings(program, vars, bufferMode);
+ };
+ var _emscripten_glTransformFeedbackVaryings = _glTransformFeedbackVaryings;
+
+
+ /** @suppress {duplicate } */
+ var _glUniform1f = (location, v0) => {
+ GLctx.uniform1f(webglGetUniformLocation(location), v0);
+ };
+ var _emscripten_glUniform1f = _glUniform1f;
+
+
+ var miniTempWebGLFloatBuffers = [];
+
+ /** @suppress {duplicate } */
+ var _glUniform1fv = (location, count, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniform1fv(webglGetUniformLocation(location), HEAPF32, ((value)>>2), count);
+ return;
+ }
+
+ if (count <= 288) {
+ // avoid allocation when uploading few enough uniforms
+ var view = miniTempWebGLFloatBuffers[count];
+ for (var i = 0; i < count; ++i) {
+ view[i] = HEAPF32[(((value)+(4*i))>>2)];
+ }
+ } else
+ {
+ var view = HEAPF32.subarray((((value)>>2)), ((value+count*4)>>2));
+ }
+ GLctx.uniform1fv(webglGetUniformLocation(location), view);
+ };
+ var _emscripten_glUniform1fv = _glUniform1fv;
+
+
+ /** @suppress {duplicate } */
+ var _glUniform1i = (location, v0) => {
+ GLctx.uniform1i(webglGetUniformLocation(location), v0);
+ };
+ var _emscripten_glUniform1i = _glUniform1i;
+
+
+ var miniTempWebGLIntBuffers = [];
+
+ /** @suppress {duplicate } */
+ var _glUniform1iv = (location, count, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniform1iv(webglGetUniformLocation(location), HEAP32, ((value)>>2), count);
+ return;
+ }
+
+ if (count <= 288) {
+ // avoid allocation when uploading few enough uniforms
+ var view = miniTempWebGLIntBuffers[count];
+ for (var i = 0; i < count; ++i) {
+ view[i] = HEAP32[(((value)+(4*i))>>2)];
+ }
+ } else
+ {
+ var view = HEAP32.subarray((((value)>>2)), ((value+count*4)>>2));
+ }
+ GLctx.uniform1iv(webglGetUniformLocation(location), view);
+ };
+ var _emscripten_glUniform1iv = _glUniform1iv;
+
+ /** @suppress {duplicate } */
+ var _glUniform1ui = (location, v0) => {
+ GLctx.uniform1ui(webglGetUniformLocation(location), v0);
+ };
+ var _emscripten_glUniform1ui = _glUniform1ui;
+
+ /** @suppress {duplicate } */
+ var _glUniform1uiv = (location, count, value) => {
+ count && GLctx.uniform1uiv(webglGetUniformLocation(location), HEAPU32, ((value)>>2), count);
+ };
+ var _emscripten_glUniform1uiv = _glUniform1uiv;
+
+
+ /** @suppress {duplicate } */
+ var _glUniform2f = (location, v0, v1) => {
+ GLctx.uniform2f(webglGetUniformLocation(location), v0, v1);
+ };
+ var _emscripten_glUniform2f = _glUniform2f;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniform2fv = (location, count, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, ((value)>>2), count*2);
+ return;
+ }
+
+ if (count <= 144) {
+ // avoid allocation when uploading few enough uniforms
+ count *= 2;
+ var view = miniTempWebGLFloatBuffers[count];
+ for (var i = 0; i < count; i += 2) {
+ view[i] = HEAPF32[(((value)+(4*i))>>2)];
+ view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)];
+ }
+ } else
+ {
+ var view = HEAPF32.subarray((((value)>>2)), ((value+count*8)>>2));
+ }
+ GLctx.uniform2fv(webglGetUniformLocation(location), view);
+ };
+ var _emscripten_glUniform2fv = _glUniform2fv;
+
+
+ /** @suppress {duplicate } */
+ var _glUniform2i = (location, v0, v1) => {
+ GLctx.uniform2i(webglGetUniformLocation(location), v0, v1);
+ };
+ var _emscripten_glUniform2i = _glUniform2i;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniform2iv = (location, count, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, ((value)>>2), count*2);
+ return;
+ }
+
+ if (count <= 144) {
+ // avoid allocation when uploading few enough uniforms
+ count *= 2;
+ var view = miniTempWebGLIntBuffers[count];
+ for (var i = 0; i < count; i += 2) {
+ view[i] = HEAP32[(((value)+(4*i))>>2)];
+ view[i+1] = HEAP32[(((value)+(4*i+4))>>2)];
+ }
+ } else
+ {
+ var view = HEAP32.subarray((((value)>>2)), ((value+count*8)>>2));
+ }
+ GLctx.uniform2iv(webglGetUniformLocation(location), view);
+ };
+ var _emscripten_glUniform2iv = _glUniform2iv;
+
+ /** @suppress {duplicate } */
+ var _glUniform2ui = (location, v0, v1) => {
+ GLctx.uniform2ui(webglGetUniformLocation(location), v0, v1);
+ };
+ var _emscripten_glUniform2ui = _glUniform2ui;
+
+ /** @suppress {duplicate } */
+ var _glUniform2uiv = (location, count, value) => {
+ count && GLctx.uniform2uiv(webglGetUniformLocation(location), HEAPU32, ((value)>>2), count*2);
+ };
+ var _emscripten_glUniform2uiv = _glUniform2uiv;
+
+
+ /** @suppress {duplicate } */
+ var _glUniform3f = (location, v0, v1, v2) => {
+ GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2);
+ };
+ var _emscripten_glUniform3f = _glUniform3f;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniform3fv = (location, count, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, ((value)>>2), count*3);
+ return;
+ }
+
+ if (count <= 96) {
+ // avoid allocation when uploading few enough uniforms
+ count *= 3;
+ var view = miniTempWebGLFloatBuffers[count];
+ for (var i = 0; i < count; i += 3) {
+ view[i] = HEAPF32[(((value)+(4*i))>>2)];
+ view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)];
+ view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)];
+ }
+ } else
+ {
+ var view = HEAPF32.subarray((((value)>>2)), ((value+count*12)>>2));
+ }
+ GLctx.uniform3fv(webglGetUniformLocation(location), view);
+ };
+ var _emscripten_glUniform3fv = _glUniform3fv;
+
+
+ /** @suppress {duplicate } */
+ var _glUniform3i = (location, v0, v1, v2) => {
+ GLctx.uniform3i(webglGetUniformLocation(location), v0, v1, v2);
+ };
+ var _emscripten_glUniform3i = _glUniform3i;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniform3iv = (location, count, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, ((value)>>2), count*3);
+ return;
+ }
+
+ if (count <= 96) {
+ // avoid allocation when uploading few enough uniforms
+ count *= 3;
+ var view = miniTempWebGLIntBuffers[count];
+ for (var i = 0; i < count; i += 3) {
+ view[i] = HEAP32[(((value)+(4*i))>>2)];
+ view[i+1] = HEAP32[(((value)+(4*i+4))>>2)];
+ view[i+2] = HEAP32[(((value)+(4*i+8))>>2)];
+ }
+ } else
+ {
+ var view = HEAP32.subarray((((value)>>2)), ((value+count*12)>>2));
+ }
+ GLctx.uniform3iv(webglGetUniformLocation(location), view);
+ };
+ var _emscripten_glUniform3iv = _glUniform3iv;
+
+ /** @suppress {duplicate } */
+ var _glUniform3ui = (location, v0, v1, v2) => {
+ GLctx.uniform3ui(webglGetUniformLocation(location), v0, v1, v2);
+ };
+ var _emscripten_glUniform3ui = _glUniform3ui;
+
+ /** @suppress {duplicate } */
+ var _glUniform3uiv = (location, count, value) => {
+ count && GLctx.uniform3uiv(webglGetUniformLocation(location), HEAPU32, ((value)>>2), count*3);
+ };
+ var _emscripten_glUniform3uiv = _glUniform3uiv;
+
+
+ /** @suppress {duplicate } */
+ var _glUniform4f = (location, v0, v1, v2, v3) => {
+ GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3);
+ };
+ var _emscripten_glUniform4f = _glUniform4f;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniform4fv = (location, count, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, ((value)>>2), count*4);
+ return;
+ }
+
+ if (count <= 72) {
+ // avoid allocation when uploading few enough uniforms
+ var view = miniTempWebGLFloatBuffers[4*count];
+ // hoist the heap out of the loop for size and for pthreads+growth.
+ var heap = HEAPF32;
+ value = ((value)>>2);
+ count *= 4;
+ for (var i = 0; i < count; i += 4) {
+ var dst = value + i;
+ view[i] = heap[dst];
+ view[i + 1] = heap[dst + 1];
+ view[i + 2] = heap[dst + 2];
+ view[i + 3] = heap[dst + 3];
+ }
+ } else
+ {
+ var view = HEAPF32.subarray((((value)>>2)), ((value+count*16)>>2));
+ }
+ GLctx.uniform4fv(webglGetUniformLocation(location), view);
+ };
+ var _emscripten_glUniform4fv = _glUniform4fv;
+
+
+ /** @suppress {duplicate } */
+ var _glUniform4i = (location, v0, v1, v2, v3) => {
+ GLctx.uniform4i(webglGetUniformLocation(location), v0, v1, v2, v3);
+ };
+ var _emscripten_glUniform4i = _glUniform4i;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniform4iv = (location, count, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, ((value)>>2), count*4);
+ return;
+ }
+
+ if (count <= 72) {
+ // avoid allocation when uploading few enough uniforms
+ count *= 4;
+ var view = miniTempWebGLIntBuffers[count];
+ for (var i = 0; i < count; i += 4) {
+ view[i] = HEAP32[(((value)+(4*i))>>2)];
+ view[i+1] = HEAP32[(((value)+(4*i+4))>>2)];
+ view[i+2] = HEAP32[(((value)+(4*i+8))>>2)];
+ view[i+3] = HEAP32[(((value)+(4*i+12))>>2)];
+ }
+ } else
+ {
+ var view = HEAP32.subarray((((value)>>2)), ((value+count*16)>>2));
+ }
+ GLctx.uniform4iv(webglGetUniformLocation(location), view);
+ };
+ var _emscripten_glUniform4iv = _glUniform4iv;
+
+ /** @suppress {duplicate } */
+ var _glUniform4ui = (location, v0, v1, v2, v3) => {
+ GLctx.uniform4ui(webglGetUniformLocation(location), v0, v1, v2, v3);
+ };
+ var _emscripten_glUniform4ui = _glUniform4ui;
+
+ /** @suppress {duplicate } */
+ var _glUniform4uiv = (location, count, value) => {
+ count && GLctx.uniform4uiv(webglGetUniformLocation(location), HEAPU32, ((value)>>2), count*4);
+ };
+ var _emscripten_glUniform4uiv = _glUniform4uiv;
+
+ /** @suppress {duplicate } */
+ var _glUniformBlockBinding = (program, uniformBlockIndex, uniformBlockBinding) => {
+ program = GL.programs[program];
+
+ GLctx.uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+ };
+ var _emscripten_glUniformBlockBinding = _glUniformBlockBinding;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix2fv = (location, count, transpose, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*4);
+ return;
+ }
+
+ if (count <= 72) {
+ // avoid allocation when uploading few enough uniforms
+ count *= 4;
+ var view = miniTempWebGLFloatBuffers[count];
+ for (var i = 0; i < count; i += 4) {
+ view[i] = HEAPF32[(((value)+(4*i))>>2)];
+ view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)];
+ view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)];
+ view[i+3] = HEAPF32[(((value)+(4*i+12))>>2)];
+ }
+ } else
+ {
+ var view = HEAPF32.subarray((((value)>>2)), ((value+count*16)>>2));
+ }
+ GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, view);
+ };
+ var _emscripten_glUniformMatrix2fv = _glUniformMatrix2fv;
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix2x3fv = (location, count, transpose, value) => {
+ count && GLctx.uniformMatrix2x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*6);
+ };
+ var _emscripten_glUniformMatrix2x3fv = _glUniformMatrix2x3fv;
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix2x4fv = (location, count, transpose, value) => {
+ count && GLctx.uniformMatrix2x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*8);
+ };
+ var _emscripten_glUniformMatrix2x4fv = _glUniformMatrix2x4fv;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix3fv = (location, count, transpose, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*9);
+ return;
+ }
+
+ if (count <= 32) {
+ // avoid allocation when uploading few enough uniforms
+ count *= 9;
+ var view = miniTempWebGLFloatBuffers[count];
+ for (var i = 0; i < count; i += 9) {
+ view[i] = HEAPF32[(((value)+(4*i))>>2)];
+ view[i+1] = HEAPF32[(((value)+(4*i+4))>>2)];
+ view[i+2] = HEAPF32[(((value)+(4*i+8))>>2)];
+ view[i+3] = HEAPF32[(((value)+(4*i+12))>>2)];
+ view[i+4] = HEAPF32[(((value)+(4*i+16))>>2)];
+ view[i+5] = HEAPF32[(((value)+(4*i+20))>>2)];
+ view[i+6] = HEAPF32[(((value)+(4*i+24))>>2)];
+ view[i+7] = HEAPF32[(((value)+(4*i+28))>>2)];
+ view[i+8] = HEAPF32[(((value)+(4*i+32))>>2)];
+ }
+ } else
+ {
+ var view = HEAPF32.subarray((((value)>>2)), ((value+count*36)>>2));
+ }
+ GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, view);
+ };
+ var _emscripten_glUniformMatrix3fv = _glUniformMatrix3fv;
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix3x2fv = (location, count, transpose, value) => {
+ count && GLctx.uniformMatrix3x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*6);
+ };
+ var _emscripten_glUniformMatrix3x2fv = _glUniformMatrix3x2fv;
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix3x4fv = (location, count, transpose, value) => {
+ count && GLctx.uniformMatrix3x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*12);
+ };
+ var _emscripten_glUniformMatrix3x4fv = _glUniformMatrix3x4fv;
+
+
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix4fv = (location, count, transpose, value) => {
+
+ if (GL.currentContext.version >= 2) {
+ count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*16);
+ return;
+ }
+
+ if (count <= 18) {
+ // avoid allocation when uploading few enough uniforms
+ var view = miniTempWebGLFloatBuffers[16*count];
+ // hoist the heap out of the loop for size and for pthreads+growth.
+ var heap = HEAPF32;
+ value = ((value)>>2);
+ count *= 16;
+ for (var i = 0; i < count; i += 16) {
+ var dst = value + i;
+ view[i] = heap[dst];
+ view[i + 1] = heap[dst + 1];
+ view[i + 2] = heap[dst + 2];
+ view[i + 3] = heap[dst + 3];
+ view[i + 4] = heap[dst + 4];
+ view[i + 5] = heap[dst + 5];
+ view[i + 6] = heap[dst + 6];
+ view[i + 7] = heap[dst + 7];
+ view[i + 8] = heap[dst + 8];
+ view[i + 9] = heap[dst + 9];
+ view[i + 10] = heap[dst + 10];
+ view[i + 11] = heap[dst + 11];
+ view[i + 12] = heap[dst + 12];
+ view[i + 13] = heap[dst + 13];
+ view[i + 14] = heap[dst + 14];
+ view[i + 15] = heap[dst + 15];
+ }
+ } else
+ {
+ var view = HEAPF32.subarray((((value)>>2)), ((value+count*64)>>2));
+ }
+ GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view);
+ };
+ var _emscripten_glUniformMatrix4fv = _glUniformMatrix4fv;
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix4x2fv = (location, count, transpose, value) => {
+ count && GLctx.uniformMatrix4x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*8);
+ };
+ var _emscripten_glUniformMatrix4x2fv = _glUniformMatrix4x2fv;
+
+ /** @suppress {duplicate } */
+ var _glUniformMatrix4x3fv = (location, count, transpose, value) => {
+ count && GLctx.uniformMatrix4x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, ((value)>>2), count*12);
+ };
+ var _emscripten_glUniformMatrix4x3fv = _glUniformMatrix4x3fv;
+
+ /** @suppress {duplicate } */
+ var _glUseProgram = (program) => {
+ program = GL.programs[program];
+ GLctx.useProgram(program);
+ // Record the currently active program so that we can access the uniform
+ // mapping table of that program.
+ GLctx.currentProgram = program;
+ };
+ var _emscripten_glUseProgram = _glUseProgram;
+
+ /** @suppress {duplicate } */
+ var _glValidateProgram = (program) => {
+ GLctx.validateProgram(GL.programs[program]);
+ };
+ var _emscripten_glValidateProgram = _glValidateProgram;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttrib1f = (x0, x1) => GLctx.vertexAttrib1f(x0, x1);
+ var _emscripten_glVertexAttrib1f = _glVertexAttrib1f;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttrib1fv = (index, v) => {
+
+ GLctx.vertexAttrib1f(index, HEAPF32[v>>2]);
+ };
+ var _emscripten_glVertexAttrib1fv = _glVertexAttrib1fv;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttrib2f = (x0, x1, x2) => GLctx.vertexAttrib2f(x0, x1, x2);
+ var _emscripten_glVertexAttrib2f = _glVertexAttrib2f;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttrib2fv = (index, v) => {
+
+ GLctx.vertexAttrib2f(index, HEAPF32[v>>2], HEAPF32[v+4>>2]);
+ };
+ var _emscripten_glVertexAttrib2fv = _glVertexAttrib2fv;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttrib3f = (x0, x1, x2, x3) => GLctx.vertexAttrib3f(x0, x1, x2, x3);
+ var _emscripten_glVertexAttrib3f = _glVertexAttrib3f;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttrib3fv = (index, v) => {
+
+ GLctx.vertexAttrib3f(index, HEAPF32[v>>2], HEAPF32[v+4>>2], HEAPF32[v+8>>2]);
+ };
+ var _emscripten_glVertexAttrib3fv = _glVertexAttrib3fv;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttrib4f = (x0, x1, x2, x3, x4) => GLctx.vertexAttrib4f(x0, x1, x2, x3, x4);
+ var _emscripten_glVertexAttrib4f = _glVertexAttrib4f;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttrib4fv = (index, v) => {
+
+ GLctx.vertexAttrib4f(index, HEAPF32[v>>2], HEAPF32[v+4>>2], HEAPF32[v+8>>2], HEAPF32[v+12>>2]);
+ };
+ var _emscripten_glVertexAttrib4fv = _glVertexAttrib4fv;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribDivisor = (index, divisor) => {
+ GLctx.vertexAttribDivisor(index, divisor);
+ };
+ var _emscripten_glVertexAttribDivisor = _glVertexAttribDivisor;
+
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribDivisorANGLE = _glVertexAttribDivisor;
+ var _emscripten_glVertexAttribDivisorANGLE = _glVertexAttribDivisorANGLE;
+
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribDivisorARB = _glVertexAttribDivisor;
+ var _emscripten_glVertexAttribDivisorARB = _glVertexAttribDivisorARB;
+
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribDivisorEXT = _glVertexAttribDivisor;
+ var _emscripten_glVertexAttribDivisorEXT = _glVertexAttribDivisorEXT;
+
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribDivisorNV = _glVertexAttribDivisor;
+ var _emscripten_glVertexAttribDivisorNV = _glVertexAttribDivisorNV;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribI4i = (x0, x1, x2, x3, x4) => GLctx.vertexAttribI4i(x0, x1, x2, x3, x4);
+ var _emscripten_glVertexAttribI4i = _glVertexAttribI4i;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribI4iv = (index, v) => {
+ GLctx.vertexAttribI4i(index, HEAP32[v>>2], HEAP32[v+4>>2], HEAP32[v+8>>2], HEAP32[v+12>>2]);
+ };
+ var _emscripten_glVertexAttribI4iv = _glVertexAttribI4iv;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribI4ui = (x0, x1, x2, x3, x4) => GLctx.vertexAttribI4ui(x0, x1, x2, x3, x4);
+ var _emscripten_glVertexAttribI4ui = _glVertexAttribI4ui;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribI4uiv = (index, v) => {
+ GLctx.vertexAttribI4ui(index, HEAPU32[v>>2], HEAPU32[v+4>>2], HEAPU32[v+8>>2], HEAPU32[v+12>>2]);
+ };
+ var _emscripten_glVertexAttribI4uiv = _glVertexAttribI4uiv;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribIPointer = (index, size, type, stride, ptr) => {
+ GLctx.vertexAttribIPointer(index, size, type, stride, ptr);
+ };
+ var _emscripten_glVertexAttribIPointer = _glVertexAttribIPointer;
+
+ /** @suppress {duplicate } */
+ var _glVertexAttribPointer = (index, size, type, normalized, stride, ptr) => {
+ GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
+ };
+ var _emscripten_glVertexAttribPointer = _glVertexAttribPointer;
+
+ /** @suppress {duplicate } */
+ var _glViewport = (x0, x1, x2, x3) => GLctx.viewport(x0, x1, x2, x3);
+ var _emscripten_glViewport = _glViewport;
+
+ /** @suppress {duplicate } */
+ var _glWaitSync = (sync, flags, timeout_low, timeout_high) => {
+ // See WebGL2 vs GLES3 difference on GL_TIMEOUT_IGNORED above (https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.15)
+ var timeout = convertI32PairToI53(timeout_low, timeout_high);
+ GLctx.waitSync(GL.syncs[sync], flags, timeout);
+ };
+ var _emscripten_glWaitSync = _glWaitSync;
+
+ var getHeapMax = () =>
+ HEAPU8.length;
+
+
+
+ var abortOnCannotGrowMemory = (requestedSize) => {
+ abort(`Cannot enlarge memory arrays to size ${requestedSize} bytes (OOM). Either (1) compile with -sINITIAL_MEMORY=X with X higher than the current value ${HEAP8.length}, (2) compile with -sALLOW_MEMORY_GROWTH which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -sABORTING_MALLOC=0`);
+ };
+ var _emscripten_resize_heap = (requestedSize) => {
+ var oldSize = HEAPU8.length;
+ // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+ requestedSize >>>= 0;
+ abortOnCannotGrowMemory(requestedSize);
+ };
+
+ /** @suppress {checkTypes} */
+ var _emscripten_sample_gamepad_data = () => {
+ try {
+ if (navigator.getGamepads) return (JSEvents.lastGamepadState = navigator.getGamepads())
+ ? 0 : -1;
+ } catch(e) {
+ err(`navigator.getGamepads() exists, but failed to execute with exception ${e}. Disabling Gamepad access.`);
+ navigator.getGamepads = null; // Disable getGamepads() so that it won't be attempted to be used again.
+ }
+ return -1;
+ };
+
+
+ var findCanvasEventTarget = findEventTarget;
+ var _emscripten_set_canvas_element_size = (target, width, height) => {
+ var canvas = findCanvasEventTarget(target);
+ if (!canvas) return -4;
+ canvas.width = width;
+ canvas.height = height;
+ return 0;
+ };
+
+
+
+
+ var fillMouseEventData = (eventStruct, e, target) => {
+ assert(eventStruct % 4 == 0);
+ HEAPF64[((eventStruct)>>3)] = e.timeStamp;
+ var idx = ((eventStruct)>>2);
+ HEAP32[idx + 2] = e.screenX;
+ HEAP32[idx + 3] = e.screenY;
+ HEAP32[idx + 4] = e.clientX;
+ HEAP32[idx + 5] = e.clientY;
+ HEAP8[eventStruct + 24] = e.ctrlKey;
+ HEAP8[eventStruct + 25] = e.shiftKey;
+ HEAP8[eventStruct + 26] = e.altKey;
+ HEAP8[eventStruct + 27] = e.metaKey;
+ HEAP16[idx*2 + 14] = e.button;
+ HEAP16[idx*2 + 15] = e.buttons;
+
+ HEAP32[idx + 8] = e["movementX"]
+ ;
+
+ HEAP32[idx + 9] = e["movementY"]
+ ;
+
+ // Note: rect contains doubles (truncated to placate SAFE_HEAP, which is the same behaviour when writing to HEAP32 anyway)
+ var rect = getBoundingClientRect(target);
+ HEAP32[idx + 10] = e.clientX - (rect.left | 0);
+ HEAP32[idx + 11] = e.clientY - (rect.top | 0);
+
+ };
+
+
+ var registerMouseEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
+ JSEvents.mouseEvent ||= _malloc(64);
+ target = findEventTarget(target);
+
+ var mouseEventHandlerFunc = (e = event) => {
+ // TODO: Make this access thread safe, or this could update live while app is reading it.
+ fillMouseEventData(JSEvents.mouseEvent, e, target);
+
+ if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, JSEvents.mouseEvent, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target,
+ allowsDeferredCalls: eventTypeString != 'mousemove' && eventTypeString != 'mouseenter' && eventTypeString != 'mouseleave', // Mouse move events do not allow fullscreen/pointer lock requests to be handled in them!
+ eventTypeString,
+ callbackfunc,
+ handlerFunc: mouseEventHandlerFunc,
+ useCapture
+ };
+ return JSEvents.registerOrRemoveHandler(eventHandler);
+ };
+ var _emscripten_set_click_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) =>
+ registerMouseEventCallback(target, userData, useCapture, callbackfunc, 4, "click", targetThread);
+
+
+
+
+ var fillFullscreenChangeEventData = (eventStruct) => {
+ var fullscreenElement = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement;
+ var isFullscreen = !!fullscreenElement;
+ // Assigning a boolean to HEAP32 with expected type coercion.
+ /** @suppress{checkTypes} */
+ HEAP8[eventStruct] = isFullscreen;checkInt8(isFullscreen);
+ HEAP8[(eventStruct)+(1)] = JSEvents.fullscreenEnabled();checkInt8(JSEvents.fullscreenEnabled());
+ // If transitioning to fullscreen, report info about the element that is now fullscreen.
+ // If transitioning to windowed mode, report info about the element that just was fullscreen.
+ var reportedElement = isFullscreen ? fullscreenElement : JSEvents.previousFullscreenElement;
+ var nodeName = JSEvents.getNodeNameForTarget(reportedElement);
+ var id = reportedElement?.id || '';
+ stringToUTF8(nodeName, eventStruct + 2, 128);
+ stringToUTF8(id, eventStruct + 130, 128);
+ HEAP32[(((eventStruct)+(260))>>2)] = reportedElement ? reportedElement.clientWidth : 0;checkInt32(reportedElement ? reportedElement.clientWidth : 0);
+ HEAP32[(((eventStruct)+(264))>>2)] = reportedElement ? reportedElement.clientHeight : 0;checkInt32(reportedElement ? reportedElement.clientHeight : 0);
+ HEAP32[(((eventStruct)+(268))>>2)] = screen.width;checkInt32(screen.width);
+ HEAP32[(((eventStruct)+(272))>>2)] = screen.height;checkInt32(screen.height);
+ if (isFullscreen) {
+ JSEvents.previousFullscreenElement = fullscreenElement;
+ }
+ };
+
+
+ var registerFullscreenChangeEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
+ JSEvents.fullscreenChangeEvent ||= _malloc(276);
+
+ var fullscreenChangeEventhandlerFunc = (e = event) => {
+ var fullscreenChangeEvent = JSEvents.fullscreenChangeEvent;
+
+ fillFullscreenChangeEventData(fullscreenChangeEvent);
+
+ if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, fullscreenChangeEvent, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target,
+ eventTypeString,
+ callbackfunc,
+ handlerFunc: fullscreenChangeEventhandlerFunc,
+ useCapture
+ };
+ return JSEvents.registerOrRemoveHandler(eventHandler);
+ };
+
+
+ var _emscripten_set_fullscreenchange_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) => {
+ if (!JSEvents.fullscreenEnabled()) return -1;
+ target = findEventTarget(target);
+ if (!target) return -4;
+
+ // Unprefixed Fullscreen API shipped in Chromium 71 (https://bugs.chromium.org/p/chromium/issues/detail?id=383813)
+ // As of Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitfullscreenchange. TODO: revisit this check once Safari ships unprefixed version.
+ registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "webkitfullscreenchange", targetThread);
+
+ return registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "fullscreenchange", targetThread);
+ };
+
+
+
+
+ var registerGamepadEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
+ JSEvents.gamepadEvent ||= _malloc(1240);
+
+ var gamepadEventHandlerFunc = (e = event) => {
+ var gamepadEvent = JSEvents.gamepadEvent;
+ fillGamepadEventData(gamepadEvent, e["gamepad"]);
+
+ if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, gamepadEvent, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target: findEventTarget(target),
+ allowsDeferredCalls: true,
+ eventTypeString,
+ callbackfunc,
+ handlerFunc: gamepadEventHandlerFunc,
+ useCapture
+ };
+ return JSEvents.registerOrRemoveHandler(eventHandler);
+ };
+
+ var _emscripten_set_gamepadconnected_callback_on_thread = (userData, useCapture, callbackfunc, targetThread) => {
+ if (_emscripten_sample_gamepad_data()) return -1;
+ return registerGamepadEventCallback(2, userData, useCapture, callbackfunc, 26, "gamepadconnected", targetThread);
+ };
+
+
+ var _emscripten_set_gamepaddisconnected_callback_on_thread = (userData, useCapture, callbackfunc, targetThread) => {
+ if (_emscripten_sample_gamepad_data()) return -1;
+ return registerGamepadEventCallback(2, userData, useCapture, callbackfunc, 27, "gamepaddisconnected", targetThread);
+ };
+
+
+
+ var registerUiEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
+ JSEvents.uiEvent ||= _malloc(36);
+
+ target = findEventTarget(target);
+
+ var uiEventHandlerFunc = (e = event) => {
+ if (e.target != target) {
+ // Never take ui events such as scroll via a 'bubbled' route, but always from the direct element that
+ // was targeted. Otherwise e.g. if app logs a message in response to a page scroll, the Emscripten log
+ // message box could cause to scroll, generating a new (bubbled) scroll message, causing a new log print,
+ // causing a new scroll, etc..
+ return;
+ }
+ var b = document.body; // Take document.body to a variable, Closure compiler does not outline access to it on its own.
+ if (!b) {
+ // During a page unload 'body' can be null, with "Cannot read property 'clientWidth' of null" being thrown
+ return;
+ }
+ var uiEvent = JSEvents.uiEvent;
+ HEAP32[((uiEvent)>>2)] = 0;checkInt32(0); // always zero for resize and scroll
+ HEAP32[(((uiEvent)+(4))>>2)] = b.clientWidth;checkInt32(b.clientWidth);
+ HEAP32[(((uiEvent)+(8))>>2)] = b.clientHeight;checkInt32(b.clientHeight);
+ HEAP32[(((uiEvent)+(12))>>2)] = innerWidth;checkInt32(innerWidth);
+ HEAP32[(((uiEvent)+(16))>>2)] = innerHeight;checkInt32(innerHeight);
+ HEAP32[(((uiEvent)+(20))>>2)] = outerWidth;checkInt32(outerWidth);
+ HEAP32[(((uiEvent)+(24))>>2)] = outerHeight;checkInt32(outerHeight);
+ HEAP32[(((uiEvent)+(28))>>2)] = pageXOffset | 0;checkInt32(pageXOffset | 0); // scroll offsets are float
+ HEAP32[(((uiEvent)+(32))>>2)] = pageYOffset | 0;checkInt32(pageYOffset | 0);
+ if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, uiEvent, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target,
+ eventTypeString,
+ callbackfunc,
+ handlerFunc: uiEventHandlerFunc,
+ useCapture
+ };
+ return JSEvents.registerOrRemoveHandler(eventHandler);
+ };
+ var _emscripten_set_resize_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) =>
+ registerUiEventCallback(target, userData, useCapture, callbackfunc, 10, "resize", targetThread);
+
+
+
+
+ var registerTouchEventCallback = (target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) => {
+ JSEvents.touchEvent ||= _malloc(1552);
+
+ target = findEventTarget(target);
+
+ var touchEventHandlerFunc = (e) => {
+ assert(e);
+ var t, touches = {}, et = e.touches;
+ // To ease marshalling different kinds of touches that browser reports (all touches are listed in e.touches,
+ // only changed touches in e.changedTouches, and touches on target at a.targetTouches), mark a boolean in
+ // each Touch object so that we can later loop only once over all touches we see to marshall over to Wasm.
+
+ for (let t of et) {
+ // Browser might recycle the generated Touch objects between each frame (Firefox on Android), so reset any
+ // changed/target states we may have set from previous frame.
+ t.isChanged = t.onTarget = 0;
+ touches[t.identifier] = t;
+ }
+ // Mark which touches are part of the changedTouches list.
+ for (let t of e.changedTouches) {
+ t.isChanged = 1;
+ touches[t.identifier] = t;
+ }
+ // Mark which touches are part of the targetTouches list.
+ for (let t of e.targetTouches) {
+ touches[t.identifier].onTarget = 1;
+ }
+
+ var touchEvent = JSEvents.touchEvent;
+ HEAPF64[((touchEvent)>>3)] = e.timeStamp;
+ HEAP8[touchEvent + 12] = e.ctrlKey;
+ HEAP8[touchEvent + 13] = e.shiftKey;
+ HEAP8[touchEvent + 14] = e.altKey;
+ HEAP8[touchEvent + 15] = e.metaKey;
+ var idx = touchEvent + 16;
+ var targetRect = getBoundingClientRect(target);
+ var numTouches = 0;
+ for (let t of Object.values(touches)) {
+ var idx32 = ((idx)>>2); // Pre-shift the ptr to index to HEAP32 to save code size
+ HEAP32[idx32 + 0] = t.identifier;
+ HEAP32[idx32 + 1] = t.screenX;
+ HEAP32[idx32 + 2] = t.screenY;
+ HEAP32[idx32 + 3] = t.clientX;
+ HEAP32[idx32 + 4] = t.clientY;
+ HEAP32[idx32 + 5] = t.pageX;
+ HEAP32[idx32 + 6] = t.pageY;
+ HEAP8[idx + 28] = t.isChanged;
+ HEAP8[idx + 29] = t.onTarget;
+ HEAP32[idx32 + 8] = t.clientX - (targetRect.left | 0);
+ HEAP32[idx32 + 9] = t.clientY - (targetRect.top | 0);
+
+ idx += 48;
+
+ if (++numTouches > 31) {
+ break;
+ }
+ }
+ HEAP32[(((touchEvent)+(8))>>2)] = numTouches;checkInt32(numTouches);
+
+ if (((a1, a2, a3) => dynCall_iiii(callbackfunc, a1, a2, a3))(eventTypeId, touchEvent, userData)) e.preventDefault();
+ };
+
+ var eventHandler = {
+ target,
+ allowsDeferredCalls: eventTypeString == 'touchstart' || eventTypeString == 'touchend',
+ eventTypeString,
+ callbackfunc,
+ handlerFunc: touchEventHandlerFunc,
+ useCapture
+ };
+ return JSEvents.registerOrRemoveHandler(eventHandler);
+ };
+ var _emscripten_set_touchcancel_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) =>
+ registerTouchEventCallback(target, userData, useCapture, callbackfunc, 25, "touchcancel", targetThread);
+
+ var _emscripten_set_touchend_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) =>
+ registerTouchEventCallback(target, userData, useCapture, callbackfunc, 23, "touchend", targetThread);
+
+ var _emscripten_set_touchmove_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) =>
+ registerTouchEventCallback(target, userData, useCapture, callbackfunc, 24, "touchmove", targetThread);
+
+ var _emscripten_set_touchstart_callback_on_thread = (target, userData, useCapture, callbackfunc, targetThread) =>
+ registerTouchEventCallback(target, userData, useCapture, callbackfunc, 22, "touchstart", targetThread);
+
+ var handleException = (e) => {
+ // Certain exception types we do not treat as errors since they are used for
+ // internal control flow.
+ // 1. ExitStatus, which is thrown by exit()
+ // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
+ // that wish to return to JS event loop.
+ if (e instanceof ExitStatus || e == 'unwind') {
+ return EXITSTATUS;
+ }
+ checkStackCookie();
+ if (e instanceof WebAssembly.RuntimeError) {
+ if (_emscripten_stack_get_current() <= 0) {
+ err('Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to 524288)');
+ }
+ }
+ quit_(1, e);
+ };
+
+
+ var runtimeKeepaliveCounter = 0;
+ var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+ var _proc_exit = (code) => {
+ EXITSTATUS = code;
+ if (!keepRuntimeAlive()) {
+ Module['onExit']?.(code);
+ ABORT = true;
+ }
+ quit_(code, new ExitStatus(code));
+ };
+
+
+ /** @suppress {duplicate } */
+ /** @param {boolean|number=} implicit */
+ var exitJS = (status, implicit) => {
+ EXITSTATUS = status;
+
+ checkUnflushedContent();
+
+ // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down
+ if (keepRuntimeAlive() && !implicit) {
+ var msg = `program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`;
+ err(msg);
+ }
+
+ _proc_exit(status);
+ };
+ var _exit = exitJS;
+
+
+ var maybeExit = () => {
+ if (!keepRuntimeAlive()) {
+ try {
+ _exit(EXITSTATUS);
+ } catch (e) {
+ handleException(e);
+ }
+ }
+ };
+ var callUserCallback = (func) => {
+ if (ABORT) {
+ err('user callback triggered after runtime exited or application aborted. Ignoring.');
+ return;
+ }
+ try {
+ func();
+ maybeExit();
+ } catch (e) {
+ handleException(e);
+ }
+ };
+
+ /** @param {number=} timeout */
+ var safeSetTimeout = (func, timeout) => {
+
+ return setTimeout(() => {
+
+ callUserCallback(func);
+ }, timeout);
+ };
+
+
+
+ var Browser = {
+ useWebGL:false,
+ isFullscreen:false,
+ pointerLock:false,
+ moduleContextCreatedCallbacks:[],
+ workers:[],
+ preloadedImages:{
+ },
+ preloadedAudios:{
+ },
+ init() {
+ if (Browser.initted) return;
+ Browser.initted = true;
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module['noImageDecoding'] && /\.(jpg|jpeg|png|bmp|webp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ var url = URL.createObjectURL(b);
+ assert(typeof url == 'string', 'createObjectURL must return a url as a string');
+ var img = new Image();
+ img.onload = () => {
+ assert(img.complete, `Image ${name} could not be decoded`);
+ var canvas = /** @type {!HTMLCanvasElement} */ (document.createElement('canvas'));
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Browser.preloadedImages[name] = canvas;
+ URL.revokeObjectURL(url);
+ onload?.(byteArray);
+ };
+ img.onerror = (event) => {
+ err(`Image ${url} could not be decoded`);
+ onerror?.();
+ };
+ img.src = url;
+ };
+ preloadPlugins.push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module['noAudioDecoding'] && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Browser.preloadedAudios[name] = audio;
+ onload?.(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Browser.preloadedAudios[name] = new Audio(); // empty shim
+ onerror?.();
+ }
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ var url = URL.createObjectURL(b); // XXX we never revoke this!
+ assert(typeof url == 'string', 'createObjectURL must return a url as a string');
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', () => finish(audio), false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ err(`warning: browser could not fully decode audio ${name}, trying slower base64 approach`);
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ safeSetTimeout(() => {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ };
+ preloadPlugins.push(audioPlugin);
+
+ // Canvas event setup
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === Module['canvas'] ||
+ document['mozPointerLockElement'] === Module['canvas'] ||
+ document['webkitPointerLockElement'] === Module['canvas'] ||
+ document['msPointerLockElement'] === Module['canvas'];
+ }
+ var canvas = Module['canvas'];
+ if (canvas) {
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ (() => {});
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ (() => {}); // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", (ev) => {
+ if (!Browser.pointerLock && Module['canvas'].requestPointerLock) {
+ Module['canvas'].requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ }
+ },
+ createContext(/** @type {HTMLCanvasElement} */ canvas, useWebGL, setInModule, webGLContextAttributes) {
+ if (useWebGL && Module.ctx && canvas == Module['canvas']) return Module.ctx; // no need to recreate GL context if it's already been created for this canvas.
+
+ var ctx;
+ var contextHandle;
+ if (useWebGL) {
+ // For GLES2/desktop GL compatibility, adjust a few defaults to be different to WebGL defaults, so that they align better with the desktop defaults.
+ var contextAttributes = {
+ antialias: false,
+ alpha: false,
+ majorVersion: (typeof WebGL2RenderingContext != 'undefined') ? 2 : 1,
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+ // This check of existence of GL is here to satisfy Closure compiler, which yells if variable GL is referenced below but GL object is not
+ // actually compiled in because application is not doing any GL operations. TODO: Ideally if GL is not being used, this function
+ // Browser.createContext() should not even be emitted.
+ if (typeof GL != 'undefined') {
+ contextHandle = GL.createContext(canvas, contextAttributes);
+ if (contextHandle) {
+ ctx = GL.getContext(contextHandle).GLctx;
+ }
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+
+ if (!ctx) return null;
+
+ if (setInModule) {
+ if (!useWebGL) assert(typeof GLctx == 'undefined', 'cannot set in module if GLctx is used, but we are a non-GL context that would replace it');
+ Module.ctx = ctx;
+ if (useWebGL) GL.makeContextCurrent(contextHandle);
+ Browser.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach((callback) => callback());
+ Browser.init();
+ }
+ return ctx;
+ },
+ fullscreenHandlersInstalled:false,
+ lockPointer:undefined,
+ resizeCanvas:undefined,
+ requestFullscreen(lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer == 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas == 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullscreenChange() {
+ Browser.isFullscreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['fullscreenElement'] || document['mozFullScreenElement'] ||
+ document['msFullscreenElement'] || document['webkitFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.exitFullscreen = Browser.exitFullscreen;
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullscreen = true;
+ if (Browser.resizeCanvas) {
+ Browser.setFullscreenCanvasSize();
+ } else {
+ Browser.updateCanvasDimensions(canvas);
+ }
+ } else {
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) {
+ Browser.setWindowedCanvasSize();
+ } else {
+ Browser.updateCanvasDimensions(canvas);
+ }
+ }
+ Module['onFullScreen']?.(Browser.isFullscreen);
+ Module['onFullscreen']?.(Browser.isFullscreen);
+ }
+
+ if (!Browser.fullscreenHandlersInstalled) {
+ Browser.fullscreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullscreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullscreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullscreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullscreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullscreen = canvasContainer['requestFullscreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullscreen'] ? () => canvasContainer['webkitRequestFullscreen'](Element['ALLOW_KEYBOARD_INPUT']) : null) ||
+ (canvasContainer['webkitRequestFullScreen'] ? () => canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) : null);
+
+ canvasContainer.requestFullscreen();
+ },
+ requestFullScreen() {
+ abort('Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)');
+ },
+ exitFullscreen() {
+ // This is workaround for chrome. Trying to exit from fullscreen
+ // not in fullscreen state will cause "TypeError: Document not active"
+ // in chrome. See https://github.com/emscripten-core/emscripten/pull/8236
+ if (!Browser.isFullscreen) {
+ return false;
+ }
+
+ var CFS = document['exitFullscreen'] ||
+ document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['webkitCancelFullScreen'] ||
+ (() => {});
+ CFS.apply(document, []);
+ return true;
+ },
+ safeSetTimeout(func, timeout) {
+ // Legacy function, this is used by the SDL2 port so we need to keep it
+ // around at least until that is updated.
+ // See https://github.com/libsdl-org/SDL/pull/6304
+ return safeSetTimeout(func, timeout);
+ },
+ getMimetype(name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },
+ getUserMedia(func) {
+ window.getUserMedia ||= navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ window.getUserMedia(func);
+ },
+ getMovementX(event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },
+ getMovementY(event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },
+ getMouseWheelDelta(event) {
+ var delta = 0;
+ switch (event.type) {
+ case 'DOMMouseScroll':
+ // 3 lines make up a step
+ delta = event.detail / 3;
+ break;
+ case 'mousewheel':
+ // 120 units make up a step
+ delta = event.wheelDelta / 120;
+ break;
+ case 'wheel':
+ delta = event.deltaY
+ switch (event.deltaMode) {
+ case 0:
+ // DOM_DELTA_PIXEL: 100 pixels make up a step
+ delta /= 100;
+ break;
+ case 1:
+ // DOM_DELTA_LINE: 3 lines make up a step
+ delta /= 3;
+ break;
+ case 2:
+ // DOM_DELTA_PAGE: A page makes up 80 steps
+ delta *= 80;
+ break;
+ default:
+ throw 'unrecognized mouse wheel delta mode: ' + event.deltaMode;
+ }
+ break;
+ default:
+ throw 'unrecognized mouse wheel event: ' + event.type;
+ }
+ return delta;
+ },
+ mouseX:0,
+ mouseY:0,
+ mouseMovementX:0,
+ mouseMovementY:0,
+ touches:{
+ },
+ lastTouches:{
+ },
+ calculateMouseCoords(pageX, pageY) {
+ // Calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX != 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY != 'undefined') ? window.scrollY : window.pageYOffset);
+ // If this assert lands, it's likely because the browser doesn't support scrollX or pageXOffset
+ // and we have no viable fallback.
+ assert((typeof scrollX != 'undefined') && (typeof scrollY != 'undefined'), 'Unable to retrieve scroll position, mouse positions likely broken.');
+ var adjustedX = pageX - (scrollX + rect.left);
+ var adjustedY = pageY - (scrollY + rect.top);
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ adjustedX = adjustedX * (cw / rect.width);
+ adjustedY = adjustedY * (ch / rect.height);
+
+ return { x: adjustedX, y: adjustedY };
+ },
+ setMouseCoords(pageX, pageY) {
+ const {x, y} = Browser.calculateMouseCoords(pageX, pageY);
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ },
+ calculateMouseEvent(event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // add the mouse delta to the current absolute mouse position
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ } else {
+ if (event.type === 'touchstart' || event.type === 'touchend' || event.type === 'touchmove') {
+ var touch = event.touch;
+ if (touch === undefined) {
+ return; // the "touch" property is only defined in SDL
+
+ }
+ var coords = Browser.calculateMouseCoords(touch.pageX, touch.pageY);
+
+ if (event.type === 'touchstart') {
+ Browser.lastTouches[touch.identifier] = coords;
+ Browser.touches[touch.identifier] = coords;
+ } else if (event.type === 'touchend' || event.type === 'touchmove') {
+ var last = Browser.touches[touch.identifier];
+ last ||= coords;
+ Browser.lastTouches[touch.identifier] = last;
+ Browser.touches[touch.identifier] = coords;
+ }
+ return;
+ }
+
+ Browser.setMouseCoords(event.pageX, event.pageY);
+ }
+ },
+ resizeListeners:[],
+ updateResizeListeners() {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach((listener) => listener(canvas.width, canvas.height));
+ },
+ setCanvasSize(width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },
+ windowedWidth:0,
+ windowedHeight:0,
+ setFullscreenCanvasSize() {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen)>>2)] = flags;checkInt32(flags);
+ }
+ Browser.updateCanvasDimensions(Module['canvas']);
+ Browser.updateResizeListeners();
+ },
+ setWindowedCanvasSize() {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen)>>2)] = flags;checkInt32(flags);
+ }
+ Browser.updateCanvasDimensions(Module['canvas']);
+ Browser.updateResizeListeners();
+ },
+ updateCanvasDimensions(canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['fullscreenElement'] || document['mozFullScreenElement'] ||
+ document['msFullscreenElement'] || document['webkitFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ },
+ };
+
+ var _emscripten_set_window_title = (title) => document.title = UTF8ToString(title);
+
+ var _emscripten_sleep = (ms) => {
+ // emscripten_sleep() does not return a value, but we still need a |return|
+ // here for stack switching support (ASYNCIFY=2). In that mode this function
+ // returns a Promise instead of nothing, and that Promise is what tells the
+ // wasm VM to pause the stack.
+ return Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms));
+ };
+ _emscripten_sleep.isAsync = true;
+
+
+ function _fd_close(fd) {
+ try {
+
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ FS.close(stream);
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+ }
+
+ /** @param {number=} offset */
+ var doReadv = (stream, iov, iovcnt, offset) => {
+ var ret = 0;
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = HEAPU32[((iov)>>2)];
+ var len = HEAPU32[(((iov)+(4))>>2)];
+ iov += 8;
+ var curr = FS.read(stream, HEAP8, ptr, len, offset);
+ if (curr < 0) return -1;
+ ret += curr;
+ if (curr < len) break; // nothing more to read
+ if (typeof offset != 'undefined') {
+ offset += curr;
+ }
+ }
+ return ret;
+ };
+
+ function _fd_read(fd, iov, iovcnt, pnum) {
+ try {
+
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doReadv(stream, iov, iovcnt);
+ HEAPU32[((pnum)>>2)] = num;checkInt32(num);
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+ }
+
+
+ var convertI32PairToI53Checked = (lo, hi) => {
+ assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32
+ assert(hi === (hi|0)); // hi should be a i32
+ return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN;
+ };
+ function _fd_seek(fd,offset_low, offset_high,whence,newOffset) {
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+
+
+ try {
+
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ FS.llseek(stream, offset, whence);
+ (tempI64 = [stream.position>>>0,(tempDouble = stream.position,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? (+(Math.floor((tempDouble)/4294967296.0)))>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)], HEAP32[((newOffset)>>2)] = tempI64[0],HEAP32[(((newOffset)+(4))>>2)] = tempI64[1]);checkInt64(stream.position);
+ if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+ ;
+ }
+
+ /** @param {number=} offset */
+ var doWritev = (stream, iov, iovcnt, offset) => {
+ var ret = 0;
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = HEAPU32[((iov)>>2)];
+ var len = HEAPU32[(((iov)+(4))>>2)];
+ iov += 8;
+ var curr = FS.write(stream, HEAP8, ptr, len, offset);
+ if (curr < 0) return -1;
+ ret += curr;
+ if (curr < len) {
+ // No more space to write.
+ break;
+ }
+ if (typeof offset != 'undefined') {
+ offset += curr;
+ }
+ }
+ return ret;
+ };
+
+ function _fd_write(fd, iov, iovcnt, pnum) {
+ try {
+
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doWritev(stream, iov, iovcnt);
+ HEAPU32[((pnum)>>2)] = num;checkInt32(num);
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ /** @constructor */
+ function GLFW_Window(id, width, height, framebufferWidth, framebufferHeight, title, monitor, share) {
+ this.id = id;
+ this.x = 0;
+ this.y = 0;
+ this.fullscreen = false; // Used to determine if app in fullscreen mode
+ this.storedX = 0; // Used to store X before fullscreen
+ this.storedY = 0; // Used to store Y before fullscreen
+ this.width = width;
+ this.height = height;
+ this.framebufferWidth = framebufferWidth;
+ this.framebufferHeight = framebufferHeight;
+ this.storedWidth = width; // Used to store width before fullscreen
+ this.storedHeight = height; // Used to store height before fullscreen
+ this.title = title;
+ this.monitor = monitor;
+ this.share = share;
+ this.attributes = Object.assign({}, GLFW.hints);
+ this.inputModes = {
+ 0x00033001:0x00034001, // GLFW_CURSOR (GLFW_CURSOR_NORMAL)
+ 0x00033002:0, // GLFW_STICKY_KEYS
+ 0x00033003:0, // GLFW_STICKY_MOUSE_BUTTONS
+ };
+ this.buttons = 0;
+ this.keys = new Array();
+ this.domKeys = new Array();
+ this.shouldClose = 0;
+ this.title = null;
+ this.windowPosFunc = 0; // GLFWwindowposfun
+ this.windowSizeFunc = 0; // GLFWwindowsizefun
+ this.windowCloseFunc = 0; // GLFWwindowclosefun
+ this.windowRefreshFunc = 0; // GLFWwindowrefreshfun
+ this.windowFocusFunc = 0; // GLFWwindowfocusfun
+ this.windowIconifyFunc = 0; // GLFWwindowiconifyfun
+ this.windowMaximizeFunc = 0; // GLFWwindowmaximizefun
+ this.framebufferSizeFunc = 0; // GLFWframebuffersizefun
+ this.windowContentScaleFunc = 0; // GLFWwindowcontentscalefun
+ this.mouseButtonFunc = 0; // GLFWmousebuttonfun
+ this.cursorPosFunc = 0; // GLFWcursorposfun
+ this.cursorEnterFunc = 0; // GLFWcursorenterfun
+ this.scrollFunc = 0; // GLFWscrollfun
+ this.dropFunc = 0; // GLFWdropfun
+ this.keyFunc = 0; // GLFWkeyfun
+ this.charFunc = 0; // GLFWcharfun
+ this.userptr = 0;
+ }
+
+
+ var _emscripten_set_main_loop_timing = (mode, value) => {
+ MainLoop.timingMode = mode;
+ MainLoop.timingValue = value;
+
+ if (!MainLoop.func) {
+ err('emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up.');
+ return 1; // Return non-zero on failure, can't set timing mode when there is no main loop.
+ }
+
+ if (!MainLoop.running) {
+
+ MainLoop.running = true;
+ }
+ if (mode == 0) {
+ MainLoop.scheduler = function MainLoop_scheduler_setTimeout() {
+ var timeUntilNextTick = Math.max(0, MainLoop.tickStartTime + value - _emscripten_get_now())|0;
+ setTimeout(MainLoop.runner, timeUntilNextTick); // doing this each time means that on exception, we stop
+ };
+ MainLoop.method = 'timeout';
+ } else if (mode == 1) {
+ MainLoop.scheduler = function MainLoop_scheduler_rAF() {
+ MainLoop.requestAnimationFrame(MainLoop.runner);
+ };
+ MainLoop.method = 'rAF';
+ } else if (mode == 2) {
+ if (typeof MainLoop.setImmediate == 'undefined') {
+ if (typeof setImmediate == 'undefined') {
+ // Emulate setImmediate. (note: not a complete polyfill, we don't emulate clearImmediate() to keep code size to minimum, since not needed)
+ var setImmediates = [];
+ var emscriptenMainLoopMessageId = 'setimmediate';
+ /** @param {Event} event */
+ var MainLoop_setImmediate_messageHandler = (event) => {
+ // When called in current thread or Worker, the main loop ID is structured slightly different to accommodate for --proxy-to-worker runtime listening to Worker events,
+ // so check for both cases.
+ if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) {
+ event.stopPropagation();
+ setImmediates.shift()();
+ }
+ };
+ addEventListener("message", MainLoop_setImmediate_messageHandler, true);
+ MainLoop.setImmediate = /** @type{function(function(): ?, ...?): number} */((func) => {
+ setImmediates.push(func);
+ if (ENVIRONMENT_IS_WORKER) {
+ Module['setImmediates'] ??= [];
+ Module['setImmediates'].push(func);
+ postMessage({target: emscriptenMainLoopMessageId}); // In --proxy-to-worker, route the message via proxyClient.js
+ } else postMessage(emscriptenMainLoopMessageId, "*"); // On the main thread, can just send the message to itself.
+ });
+ } else {
+ MainLoop.setImmediate = setImmediate;
+ }
+ }
+ MainLoop.scheduler = function MainLoop_scheduler_setImmediate() {
+ MainLoop.setImmediate(MainLoop.runner);
+ };
+ MainLoop.method = 'immediate';
+ }
+ return 0;
+ };
+
+
+
+ /**
+ * @param {number=} arg
+ * @param {boolean=} noSetTiming
+ */
+ var setMainLoop = (iterFunc, fps, simulateInfiniteLoop, arg, noSetTiming) => {
+ assert(!MainLoop.func, 'emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.');
+ MainLoop.func = iterFunc;
+ MainLoop.arg = arg;
+
+ var thisMainLoopId = MainLoop.currentlyRunningMainloop;
+ function checkIsRunning() {
+ if (thisMainLoopId < MainLoop.currentlyRunningMainloop) {
+
+ maybeExit();
+ return false;
+ }
+ return true;
+ }
+
+ // We create the loop runner here but it is not actually running until
+ // _emscripten_set_main_loop_timing is called (which might happen a
+ // later time). This member signifies that the current runner has not
+ // yet been started so that we can call runtimeKeepalivePush when it
+ // gets it timing set for the first time.
+ MainLoop.running = false;
+ MainLoop.runner = function MainLoop_runner() {
+ if (ABORT) return;
+ if (MainLoop.queue.length > 0) {
+ var start = Date.now();
+ var blocker = MainLoop.queue.shift();
+ blocker.func(blocker.arg);
+ if (MainLoop.remainingBlockers) {
+ var remaining = MainLoop.remainingBlockers;
+ var next = remaining%1 == 0 ? remaining-1 : Math.floor(remaining);
+ if (blocker.counted) {
+ MainLoop.remainingBlockers = next;
+ } else {
+ // not counted, but move the progress along a tiny bit
+ next = next + 0.5; // do not steal all the next one's progress
+ MainLoop.remainingBlockers = (8*remaining + next)/9;
+ }
+ }
+ MainLoop.updateStatus();
+
+ // catches pause/resume main loop from blocker execution
+ if (!checkIsRunning()) return;
+
+ setTimeout(MainLoop.runner, 0);
+ return;
+ }
+
+ // catch pauses from non-main loop sources
+ if (!checkIsRunning()) return;
+
+ // Implement very basic swap interval control
+ MainLoop.currentFrameNumber = MainLoop.currentFrameNumber + 1 | 0;
+ if (MainLoop.timingMode == 1 && MainLoop.timingValue > 1 && MainLoop.currentFrameNumber % MainLoop.timingValue != 0) {
+ // Not the scheduled time to render this frame - skip.
+ MainLoop.scheduler();
+ return;
+ } else if (MainLoop.timingMode == 0) {
+ MainLoop.tickStartTime = _emscripten_get_now();
+ }
+
+ if (MainLoop.method === 'timeout' && Module.ctx) {
+ warnOnce('Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!');
+ MainLoop.method = ''; // just warn once per call to set main loop
+ }
+
+ MainLoop.runIter(iterFunc);
+
+ // catch pauses from the main loop itself
+ if (!checkIsRunning()) return;
+
+ MainLoop.scheduler();
+ }
+
+ if (!noSetTiming) {
+ if (fps && fps > 0) {
+ _emscripten_set_main_loop_timing(0, 1000.0 / fps);
+ } else {
+ // Do rAF by rendering each frame (no decimating)
+ _emscripten_set_main_loop_timing(1, 1);
+ }
+
+ MainLoop.scheduler();
+ }
+
+ if (simulateInfiniteLoop) {
+ throw 'unwind';
+ }
+ };
+
+
+ var MainLoop = {
+ running:false,
+ scheduler:null,
+ method:"",
+ currentlyRunningMainloop:0,
+ func:null,
+ arg:0,
+ timingMode:0,
+ timingValue:0,
+ currentFrameNumber:0,
+ queue:[],
+ preMainLoop:[],
+ postMainLoop:[],
+ pause() {
+ MainLoop.scheduler = null;
+ // Incrementing this signals the previous main loop that it's now become old, and it must return.
+ MainLoop.currentlyRunningMainloop++;
+ },
+ resume() {
+ MainLoop.currentlyRunningMainloop++;
+ var timingMode = MainLoop.timingMode;
+ var timingValue = MainLoop.timingValue;
+ var func = MainLoop.func;
+ MainLoop.func = null;
+ // do not set timing and call scheduler, we will do it on the next lines
+ setMainLoop(func, 0, false, MainLoop.arg, true);
+ _emscripten_set_main_loop_timing(timingMode, timingValue);
+ MainLoop.scheduler();
+ },
+ updateStatus() {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = MainLoop.remainingBlockers ?? 0;
+ var expected = MainLoop.expectedBlockers ?? 0;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](`{message} ({expected - remaining}/{expected})`);
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ },
+ init() {
+ Module['preMainLoop'] && MainLoop.preMainLoop.push(Module['preMainLoop']);
+ Module['postMainLoop'] && MainLoop.postMainLoop.push(Module['postMainLoop']);
+ },
+ runIter(func) {
+ if (ABORT) return;
+ for (var pre of MainLoop.preMainLoop) {
+ if (pre() === false) {
+ return; // |return false| skips a frame
+ }
+ }
+ callUserCallback(func);
+ for (var post of MainLoop.postMainLoop) {
+ post();
+ }
+ checkStackCookie();
+ },
+ nextRAF:0,
+ fakeRequestAnimationFrame(func) {
+ // try to keep 60fps between calls to here
+ var now = Date.now();
+ if (MainLoop.nextRAF === 0) {
+ MainLoop.nextRAF = now + 1000/60;
+ } else {
+ while (now + 2 >= MainLoop.nextRAF) { // fudge a little, to avoid timer jitter causing us to do lots of delay:0
+ MainLoop.nextRAF += 1000/60;
+ }
+ }
+ var delay = Math.max(MainLoop.nextRAF - now, 0);
+ setTimeout(func, delay);
+ },
+ requestAnimationFrame(func) {
+ if (typeof requestAnimationFrame == 'function') {
+ requestAnimationFrame(func);
+ return;
+ }
+ var RAF = MainLoop.fakeRequestAnimationFrame;
+ RAF(func);
+ },
+ };
+
+
+
+
+ var GLFW = {
+ WindowFromId:(id) => {
+ if (id <= 0 || !GLFW.windows) return null;
+ return GLFW.windows[id - 1];
+ },
+ joystickFunc:0,
+ errorFunc:0,
+ monitorFunc:0,
+ active:null,
+ scale:null,
+ windows:null,
+ monitors:null,
+ monitorString:null,
+ versionString:null,
+ initialTime:null,
+ extensions:null,
+ devicePixelRatioMQL:null,
+ hints:null,
+ primaryTouchId:null,
+ defaultHints:{
+ 131073:0,
+ 131074:0,
+ 131075:1,
+ 131076:1,
+ 131077:1,
+ 131082:0,
+ 135169:8,
+ 135170:8,
+ 135171:8,
+ 135172:8,
+ 135173:24,
+ 135174:8,
+ 135175:0,
+ 135176:0,
+ 135177:0,
+ 135178:0,
+ 135179:0,
+ 135180:0,
+ 135181:0,
+ 135182:0,
+ 135183:0,
+ 139265:196609,
+ 139266:1,
+ 139267:0,
+ 139268:0,
+ 139269:0,
+ 139270:0,
+ 139271:0,
+ 139272:0,
+ 139276:0,
+ },
+ DOMToGLFWKeyCode:(keycode) => {
+ switch (keycode) {
+ // these keycodes are only defined for GLFW3, assume they are the same for GLFW2
+ case 0x20:return 32; // DOM_VK_SPACE -> GLFW_KEY_SPACE
+ case 0xDE:return 39; // DOM_VK_QUOTE -> GLFW_KEY_APOSTROPHE
+ case 0xBC:return 44; // DOM_VK_COMMA -> GLFW_KEY_COMMA
+ case 0xAD:return 45; // DOM_VK_HYPHEN_MINUS -> GLFW_KEY_MINUS
+ case 0xBD:return 45; // DOM_VK_MINUS -> GLFW_KEY_MINUS
+ case 0xBE:return 46; // DOM_VK_PERIOD -> GLFW_KEY_PERIOD
+ case 0xBF:return 47; // DOM_VK_SLASH -> GLFW_KEY_SLASH
+ case 0x30:return 48; // DOM_VK_0 -> GLFW_KEY_0
+ case 0x31:return 49; // DOM_VK_1 -> GLFW_KEY_1
+ case 0x32:return 50; // DOM_VK_2 -> GLFW_KEY_2
+ case 0x33:return 51; // DOM_VK_3 -> GLFW_KEY_3
+ case 0x34:return 52; // DOM_VK_4 -> GLFW_KEY_4
+ case 0x35:return 53; // DOM_VK_5 -> GLFW_KEY_5
+ case 0x36:return 54; // DOM_VK_6 -> GLFW_KEY_6
+ case 0x37:return 55; // DOM_VK_7 -> GLFW_KEY_7
+ case 0x38:return 56; // DOM_VK_8 -> GLFW_KEY_8
+ case 0x39:return 57; // DOM_VK_9 -> GLFW_KEY_9
+ case 0x3B:return 59; // DOM_VK_SEMICOLON -> GLFW_KEY_SEMICOLON
+ case 0x3D:return 61; // DOM_VK_EQUALS -> GLFW_KEY_EQUAL
+ case 0xBB:return 61; // DOM_VK_EQUALS -> GLFW_KEY_EQUAL
+ case 0x41:return 65; // DOM_VK_A -> GLFW_KEY_A
+ case 0x42:return 66; // DOM_VK_B -> GLFW_KEY_B
+ case 0x43:return 67; // DOM_VK_C -> GLFW_KEY_C
+ case 0x44:return 68; // DOM_VK_D -> GLFW_KEY_D
+ case 0x45:return 69; // DOM_VK_E -> GLFW_KEY_E
+ case 0x46:return 70; // DOM_VK_F -> GLFW_KEY_F
+ case 0x47:return 71; // DOM_VK_G -> GLFW_KEY_G
+ case 0x48:return 72; // DOM_VK_H -> GLFW_KEY_H
+ case 0x49:return 73; // DOM_VK_I -> GLFW_KEY_I
+ case 0x4A:return 74; // DOM_VK_J -> GLFW_KEY_J
+ case 0x4B:return 75; // DOM_VK_K -> GLFW_KEY_K
+ case 0x4C:return 76; // DOM_VK_L -> GLFW_KEY_L
+ case 0x4D:return 77; // DOM_VK_M -> GLFW_KEY_M
+ case 0x4E:return 78; // DOM_VK_N -> GLFW_KEY_N
+ case 0x4F:return 79; // DOM_VK_O -> GLFW_KEY_O
+ case 0x50:return 80; // DOM_VK_P -> GLFW_KEY_P
+ case 0x51:return 81; // DOM_VK_Q -> GLFW_KEY_Q
+ case 0x52:return 82; // DOM_VK_R -> GLFW_KEY_R
+ case 0x53:return 83; // DOM_VK_S -> GLFW_KEY_S
+ case 0x54:return 84; // DOM_VK_T -> GLFW_KEY_T
+ case 0x55:return 85; // DOM_VK_U -> GLFW_KEY_U
+ case 0x56:return 86; // DOM_VK_V -> GLFW_KEY_V
+ case 0x57:return 87; // DOM_VK_W -> GLFW_KEY_W
+ case 0x58:return 88; // DOM_VK_X -> GLFW_KEY_X
+ case 0x59:return 89; // DOM_VK_Y -> GLFW_KEY_Y
+ case 0x5a:return 90; // DOM_VK_Z -> GLFW_KEY_Z
+ case 0xDB:return 91; // DOM_VK_OPEN_BRACKET -> GLFW_KEY_LEFT_BRACKET
+ case 0xDC:return 92; // DOM_VK_BACKSLASH -> GLFW_KEY_BACKSLASH
+ case 0xDD:return 93; // DOM_VK_CLOSE_BRACKET -> GLFW_KEY_RIGHT_BRACKET
+ case 0xC0:return 96; // DOM_VK_BACK_QUOTE -> GLFW_KEY_GRAVE_ACCENT
+
+ case 0x1B:return 256; // DOM_VK_ESCAPE -> GLFW_KEY_ESCAPE
+ case 0x0D:return 257; // DOM_VK_RETURN -> GLFW_KEY_ENTER
+ case 0x09:return 258; // DOM_VK_TAB -> GLFW_KEY_TAB
+ case 0x08:return 259; // DOM_VK_BACK -> GLFW_KEY_BACKSPACE
+ case 0x2D:return 260; // DOM_VK_INSERT -> GLFW_KEY_INSERT
+ case 0x2E:return 261; // DOM_VK_DELETE -> GLFW_KEY_DELETE
+ case 0x27:return 262; // DOM_VK_RIGHT -> GLFW_KEY_RIGHT
+ case 0x25:return 263; // DOM_VK_LEFT -> GLFW_KEY_LEFT
+ case 0x28:return 264; // DOM_VK_DOWN -> GLFW_KEY_DOWN
+ case 0x26:return 265; // DOM_VK_UP -> GLFW_KEY_UP
+ case 0x21:return 266; // DOM_VK_PAGE_UP -> GLFW_KEY_PAGE_UP
+ case 0x22:return 267; // DOM_VK_PAGE_DOWN -> GLFW_KEY_PAGE_DOWN
+ case 0x24:return 268; // DOM_VK_HOME -> GLFW_KEY_HOME
+ case 0x23:return 269; // DOM_VK_END -> GLFW_KEY_END
+ case 0x14:return 280; // DOM_VK_CAPS_LOCK -> GLFW_KEY_CAPS_LOCK
+ case 0x91:return 281; // DOM_VK_SCROLL_LOCK -> GLFW_KEY_SCROLL_LOCK
+ case 0x90:return 282; // DOM_VK_NUM_LOCK -> GLFW_KEY_NUM_LOCK
+ case 0x2C:return 283; // DOM_VK_SNAPSHOT -> GLFW_KEY_PRINT_SCREEN
+ case 0x13:return 284; // DOM_VK_PAUSE -> GLFW_KEY_PAUSE
+ case 0x70:return 290; // DOM_VK_F1 -> GLFW_KEY_F1
+ case 0x71:return 291; // DOM_VK_F2 -> GLFW_KEY_F2
+ case 0x72:return 292; // DOM_VK_F3 -> GLFW_KEY_F3
+ case 0x73:return 293; // DOM_VK_F4 -> GLFW_KEY_F4
+ case 0x74:return 294; // DOM_VK_F5 -> GLFW_KEY_F5
+ case 0x75:return 295; // DOM_VK_F6 -> GLFW_KEY_F6
+ case 0x76:return 296; // DOM_VK_F7 -> GLFW_KEY_F7
+ case 0x77:return 297; // DOM_VK_F8 -> GLFW_KEY_F8
+ case 0x78:return 298; // DOM_VK_F9 -> GLFW_KEY_F9
+ case 0x79:return 299; // DOM_VK_F10 -> GLFW_KEY_F10
+ case 0x7A:return 300; // DOM_VK_F11 -> GLFW_KEY_F11
+ case 0x7B:return 301; // DOM_VK_F12 -> GLFW_KEY_F12
+ case 0x7C:return 302; // DOM_VK_F13 -> GLFW_KEY_F13
+ case 0x7D:return 303; // DOM_VK_F14 -> GLFW_KEY_F14
+ case 0x7E:return 304; // DOM_VK_F15 -> GLFW_KEY_F15
+ case 0x7F:return 305; // DOM_VK_F16 -> GLFW_KEY_F16
+ case 0x80:return 306; // DOM_VK_F17 -> GLFW_KEY_F17
+ case 0x81:return 307; // DOM_VK_F18 -> GLFW_KEY_F18
+ case 0x82:return 308; // DOM_VK_F19 -> GLFW_KEY_F19
+ case 0x83:return 309; // DOM_VK_F20 -> GLFW_KEY_F20
+ case 0x84:return 310; // DOM_VK_F21 -> GLFW_KEY_F21
+ case 0x85:return 311; // DOM_VK_F22 -> GLFW_KEY_F22
+ case 0x86:return 312; // DOM_VK_F23 -> GLFW_KEY_F23
+ case 0x87:return 313; // DOM_VK_F24 -> GLFW_KEY_F24
+ case 0x88:return 314; // 0x88 (not used?) -> GLFW_KEY_F25
+ case 0x60:return 320; // DOM_VK_NUMPAD0 -> GLFW_KEY_KP_0
+ case 0x61:return 321; // DOM_VK_NUMPAD1 -> GLFW_KEY_KP_1
+ case 0x62:return 322; // DOM_VK_NUMPAD2 -> GLFW_KEY_KP_2
+ case 0x63:return 323; // DOM_VK_NUMPAD3 -> GLFW_KEY_KP_3
+ case 0x64:return 324; // DOM_VK_NUMPAD4 -> GLFW_KEY_KP_4
+ case 0x65:return 325; // DOM_VK_NUMPAD5 -> GLFW_KEY_KP_5
+ case 0x66:return 326; // DOM_VK_NUMPAD6 -> GLFW_KEY_KP_6
+ case 0x67:return 327; // DOM_VK_NUMPAD7 -> GLFW_KEY_KP_7
+ case 0x68:return 328; // DOM_VK_NUMPAD8 -> GLFW_KEY_KP_8
+ case 0x69:return 329; // DOM_VK_NUMPAD9 -> GLFW_KEY_KP_9
+ case 0x6E:return 330; // DOM_VK_DECIMAL -> GLFW_KEY_KP_DECIMAL
+ case 0x6F:return 331; // DOM_VK_DIVIDE -> GLFW_KEY_KP_DIVIDE
+ case 0x6A:return 332; // DOM_VK_MULTIPLY -> GLFW_KEY_KP_MULTIPLY
+ case 0x6D:return 333; // DOM_VK_SUBTRACT -> GLFW_KEY_KP_SUBTRACT
+ case 0x6B:return 334; // DOM_VK_ADD -> GLFW_KEY_KP_ADD
+ // case 0x0D:return 335; // DOM_VK_RETURN -> GLFW_KEY_KP_ENTER (DOM_KEY_LOCATION_RIGHT)
+ // case 0x61:return 336; // DOM_VK_EQUALS -> GLFW_KEY_KP_EQUAL (DOM_KEY_LOCATION_RIGHT)
+ case 0x10:return 340; // DOM_VK_SHIFT -> GLFW_KEY_LEFT_SHIFT
+ case 0x11:return 341; // DOM_VK_CONTROL -> GLFW_KEY_LEFT_CONTROL
+ case 0x12:return 342; // DOM_VK_ALT -> GLFW_KEY_LEFT_ALT
+ case 0x5B:return 343; // DOM_VK_WIN -> GLFW_KEY_LEFT_SUPER
+ case 0xE0:return 343; // DOM_VK_META -> GLFW_KEY_LEFT_SUPER
+ // case 0x10:return 344; // DOM_VK_SHIFT -> GLFW_KEY_RIGHT_SHIFT (DOM_KEY_LOCATION_RIGHT)
+ // case 0x11:return 345; // DOM_VK_CONTROL -> GLFW_KEY_RIGHT_CONTROL (DOM_KEY_LOCATION_RIGHT)
+ // case 0x12:return 346; // DOM_VK_ALT -> GLFW_KEY_RIGHT_ALT (DOM_KEY_LOCATION_RIGHT)
+ // case 0x5B:return 347; // DOM_VK_WIN -> GLFW_KEY_RIGHT_SUPER (DOM_KEY_LOCATION_RIGHT)
+ case 0x5D:return 348; // DOM_VK_CONTEXT_MENU -> GLFW_KEY_MENU
+ // XXX: GLFW_KEY_WORLD_1, GLFW_KEY_WORLD_2 what are these?
+ default:return -1; // GLFW_KEY_UNKNOWN
+ };
+ },
+ getModBits:(win) => {
+ var mod = 0;
+ if (win.keys[340]) mod |= 0x0001; // GLFW_MOD_SHIFT
+ if (win.keys[341]) mod |= 0x0002; // GLFW_MOD_CONTROL
+ if (win.keys[342]) mod |= 0x0004; // GLFW_MOD_ALT
+ if (win.keys[343] || win.keys[348]) mod |= 0x0008; // GLFW_MOD_SUPER
+ // add caps and num lock keys? only if lock_key_mod is set
+ return mod;
+ },
+ onKeyPress:(event) => {
+ if (!GLFW.active || !GLFW.active.charFunc) return;
+ if (event.ctrlKey || event.metaKey) return;
+
+ // correct unicode charCode is only available with onKeyPress event
+ var charCode = event.charCode;
+ if (charCode == 0 || (charCode >= 0x00 && charCode <= 0x1F)) return;
+
+ ((a1, a2) => dynCall_vii(GLFW.active.charFunc, a1, a2))(GLFW.active.id, charCode);
+ },
+ onKeyChanged:(keyCode, status) => {
+ if (!GLFW.active) return;
+
+ var key = GLFW.DOMToGLFWKeyCode(keyCode);
+ if (key == -1) return;
+
+ var repeat = status && GLFW.active.keys[key];
+ GLFW.active.keys[key] = status;
+ GLFW.active.domKeys[keyCode] = status;
+
+ if (GLFW.active.keyFunc) {
+ if (repeat) status = 2; // GLFW_REPEAT
+ ((a1, a2, a3, a4, a5) => dynCall_viiiii(GLFW.active.keyFunc, a1, a2, a3, a4, a5))(GLFW.active.id, key, keyCode, status, GLFW.getModBits(GLFW.active));
+ }
+ },
+ onGamepadConnected:(event) => {
+ GLFW.refreshJoysticks();
+ },
+ onGamepadDisconnected:(event) => {
+ GLFW.refreshJoysticks();
+ },
+ onKeydown:(event) => {
+ GLFW.onKeyChanged(event.keyCode, 1); // GLFW_PRESS or GLFW_REPEAT
+
+ // This logic comes directly from the sdl implementation. We cannot
+ // call preventDefault on all keydown events otherwise onKeyPress will
+ // not get called
+ if (event.key == 'Backspace' || event.key == 'Tab') {
+ event.preventDefault();
+ }
+ },
+ onKeyup:(event) => {
+ GLFW.onKeyChanged(event.keyCode, 0); // GLFW_RELEASE
+ },
+ onBlur:(event) => {
+ if (!GLFW.active) return;
+
+ for (var i = 0; i < GLFW.active.domKeys.length; ++i) {
+ if (GLFW.active.domKeys[i]) {
+ GLFW.onKeyChanged(i, 0); // GLFW_RELEASE
+ }
+ }
+ },
+ onMousemove:(event) => {
+ if (!GLFW.active) return;
+
+ if (event.type === 'touchmove') {
+ // Handling for touch events that are being converted to mouse input.
+
+ // Don't let the browser fire a duplicate mouse event.
+ event.preventDefault();
+
+ let primaryChanged = false;
+ for (let i of event.changedTouches) {
+ // If our chosen primary touch moved, update Browser mouse coords
+ if (GLFW.primaryTouchId === i.identifier) {
+ Browser.setMouseCoords(i.pageX, i.pageY);
+ primaryChanged = true;
+ break;
+ }
+ }
+
+ if (!primaryChanged) {
+ // Do not send mouse events if some touch other than the primary triggered this.
+ return;
+ }
+
+ } else {
+ // Handling for non-touch mouse input events.
+ Browser.calculateMouseEvent(event);
+ }
+
+ if (event.target != Module["canvas"] || !GLFW.active.cursorPosFunc) return;
+
+ if (GLFW.active.cursorPosFunc) {
+ ((a1, a2, a3) => dynCall_vidd(GLFW.active.cursorPosFunc, a1, a2, a3))(GLFW.active.id, Browser.mouseX, Browser.mouseY);
+ }
+ },
+ DOMToGLFWMouseButton:(event) => {
+ // DOM and glfw have different button codes.
+ // See http://www.w3schools.com/jsref/event_button.asp.
+ var eventButton = event['button'];
+ if (eventButton > 0) {
+ if (eventButton == 1) {
+ eventButton = 2;
+ } else {
+ eventButton = 1;
+ }
+ }
+ return eventButton;
+ },
+ onMouseenter:(event) => {
+ if (!GLFW.active) return;
+
+ if (event.target != Module["canvas"]) return;
+
+ if (GLFW.active.cursorEnterFunc) {
+ ((a1, a2) => dynCall_vii(GLFW.active.cursorEnterFunc, a1, a2))(GLFW.active.id, 1);
+ }
+ },
+ onMouseleave:(event) => {
+ if (!GLFW.active) return;
+
+ if (event.target != Module["canvas"]) return;
+
+ if (GLFW.active.cursorEnterFunc) {
+ ((a1, a2) => dynCall_vii(GLFW.active.cursorEnterFunc, a1, a2))(GLFW.active.id, 0);
+ }
+ },
+ onMouseButtonChanged:(event, status) => {
+ if (!GLFW.active) return;
+
+ if (event.target != Module["canvas"]) return;
+
+ // Is this from a touch event?
+ const isTouchType = event.type === 'touchstart' || event.type === 'touchend' || event.type === 'touchcancel';
+
+ // Only emulating mouse left-click behavior for touches.
+ let eventButton = 0;
+ if (isTouchType) {
+ // Handling for touch events that are being converted to mouse input.
+
+ // Don't let the browser fire a duplicate mouse event.
+ event.preventDefault();
+
+ let primaryChanged = false;
+
+ // Set a primary touch if we have none.
+ if (GLFW.primaryTouchId === null && event.type === 'touchstart' && event.targetTouches.length > 0) {
+ // Pick the first touch that started in the canvas and treat it as primary.
+ const chosenTouch = event.targetTouches[0];
+ GLFW.primaryTouchId = chosenTouch.identifier;
+
+ Browser.setMouseCoords(chosenTouch.pageX, chosenTouch.pageY);
+ primaryChanged = true;
+ } else if (event.type === 'touchend' || event.type === 'touchcancel') {
+ // Clear the primary touch if it ended.
+ for (let i of event.changedTouches) {
+ // If our chosen primary touch ended, remove it.
+ if (GLFW.primaryTouchId === i.identifier) {
+ GLFW.primaryTouchId = null;
+ primaryChanged = true;
+ break;
+ }
+ }
+ }
+
+ if (!primaryChanged) {
+ // Do not send mouse events if some touch other than the primary triggered this.
+ return;
+ }
+
+ } else {
+ // Handling for non-touch mouse input events.
+ Browser.calculateMouseEvent(event);
+ eventButton = GLFW.DOMToGLFWMouseButton(event);
+ }
+
+ if (status == 1) { // GLFW_PRESS
+ GLFW.active.buttons |= (1 << eventButton);
+ try {
+ event.target.setCapture();
+ } catch (e) {}
+ } else { // GLFW_RELEASE
+ GLFW.active.buttons &= ~(1 << eventButton);
+ }
+
+ // Send mouse event to GLFW.
+ if (GLFW.active.mouseButtonFunc) {
+ ((a1, a2, a3, a4) => dynCall_viiii(GLFW.active.mouseButtonFunc, a1, a2, a3, a4))(GLFW.active.id, eventButton, status, GLFW.getModBits(GLFW.active));
+ }
+ },
+ onMouseButtonDown:(event) => {
+ if (!GLFW.active) return;
+ GLFW.onMouseButtonChanged(event, 1); // GLFW_PRESS
+ },
+ onMouseButtonUp:(event) => {
+ if (!GLFW.active) return;
+ GLFW.onMouseButtonChanged(event, 0); // GLFW_RELEASE
+ },
+ onMouseWheel:(event) => {
+ // Note the minus sign that flips browser wheel direction (positive direction scrolls page down) to native wheel direction (positive direction is mouse wheel up)
+ var delta = -Browser.getMouseWheelDelta(event);
+ delta = (delta == 0) ? 0 : (delta > 0 ? Math.max(delta, 1) : Math.min(delta, -1)); // Quantize to integer so that minimum scroll is at least +/- 1.
+ GLFW.wheelPos += delta;
+
+ if (!GLFW.active || !GLFW.active.scrollFunc || event.target != Module['canvas']) return;
+ var sx = 0;
+ var sy = delta;
+ if (event.type == 'mousewheel') {
+ sx = event.wheelDeltaX;
+ } else {
+ sx = event.deltaX;
+ }
+
+ ((a1, a2, a3) => dynCall_vidd(GLFW.active.scrollFunc, a1, a2, a3))(GLFW.active.id, sx, sy);
+
+ event.preventDefault();
+ },
+ onCanvasResize:(width, height, framebufferWidth, framebufferHeight) => {
+ if (!GLFW.active) return;
+
+ var resizeNeeded = false;
+
+ // If the client is requesting fullscreen mode
+ if (document["fullscreen"] || document["fullScreen"] || document["mozFullScreen"] || document["webkitIsFullScreen"]) {
+ if (!GLFW.active.fullscreen) {
+ resizeNeeded = width != screen.width || height != screen.height;
+ GLFW.active.storedX = GLFW.active.x;
+ GLFW.active.storedY = GLFW.active.y;
+ GLFW.active.storedWidth = GLFW.active.width;
+ GLFW.active.storedHeight = GLFW.active.height;
+ GLFW.active.x = GLFW.active.y = 0;
+ GLFW.active.width = screen.width;
+ GLFW.active.height = screen.height;
+ GLFW.active.fullscreen = true;
+ }
+ // If the client is reverting from fullscreen mode
+ } else if (GLFW.active.fullscreen == true) {
+ resizeNeeded = width != GLFW.active.storedWidth || height != GLFW.active.storedHeight;
+ GLFW.active.x = GLFW.active.storedX;
+ GLFW.active.y = GLFW.active.storedY;
+ GLFW.active.width = GLFW.active.storedWidth;
+ GLFW.active.height = GLFW.active.storedHeight;
+ GLFW.active.fullscreen = false;
+ }
+
+ if (resizeNeeded) {
+ // width or height is changed (fullscreen / exit fullscreen) which will call this listener back
+ // with proper framebufferWidth/framebufferHeight
+ Browser.setCanvasSize(GLFW.active.width, GLFW.active.height);
+ } else if (GLFW.active.width != width ||
+ GLFW.active.height != height ||
+ GLFW.active.framebufferWidth != framebufferWidth ||
+ GLFW.active.framebufferHeight != framebufferHeight) {
+ GLFW.active.width = width;
+ GLFW.active.height = height;
+ GLFW.active.framebufferWidth = framebufferWidth;
+ GLFW.active.framebufferHeight = framebufferHeight;
+ GLFW.onWindowSizeChanged();
+ GLFW.onFramebufferSizeChanged();
+ }
+ },
+ onWindowSizeChanged:() => {
+ if (!GLFW.active) return;
+
+ if (GLFW.active.windowSizeFunc) {
+ ((a1, a2, a3) => dynCall_viii(GLFW.active.windowSizeFunc, a1, a2, a3))(GLFW.active.id, GLFW.active.width, GLFW.active.height);
+ }
+ },
+ onFramebufferSizeChanged:() => {
+ if (!GLFW.active) return;
+
+ if (GLFW.active.framebufferSizeFunc) {
+ ((a1, a2, a3) => dynCall_viii(GLFW.active.framebufferSizeFunc, a1, a2, a3))(GLFW.active.id, GLFW.active.framebufferWidth, GLFW.active.framebufferHeight);
+ }
+ },
+ onWindowContentScaleChanged:(scale) => {
+ GLFW.scale = scale;
+ if (!GLFW.active) return;
+
+ if (GLFW.active.windowContentScaleFunc) {
+ ((a1, a2, a3) => dynCall_viff(GLFW.active.windowContentScaleFunc, a1, a2, a3))(GLFW.active.id, GLFW.scale, GLFW.scale);
+ }
+ },
+ getTime:() => _emscripten_get_now() / 1000,
+ setWindowTitle:(winid, title) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return;
+
+ win.title = title;
+ if (GLFW.active.id == win.id) {
+ _emscripten_set_window_title(title);
+ }
+ },
+ setJoystickCallback:(cbfun) => {
+ var prevcbfun = GLFW.joystickFunc;
+ GLFW.joystickFunc = cbfun;
+ GLFW.refreshJoysticks();
+ return prevcbfun;
+ },
+ joys:{
+ },
+ lastGamepadState:[],
+ lastGamepadStateFrame:null,
+ refreshJoysticks:() => {
+ // Produce a new Gamepad API sample if we are ticking a new game frame, or if not using emscripten_set_main_loop() at all to drive animation.
+ if (MainLoop.currentFrameNumber !== GLFW.lastGamepadStateFrame || !MainLoop.currentFrameNumber) {
+ GLFW.lastGamepadState = navigator.getGamepads ? navigator.getGamepads() : (navigator.webkitGetGamepads || []);
+ GLFW.lastGamepadStateFrame = MainLoop.currentFrameNumber;
+
+ for (var joy = 0; joy < GLFW.lastGamepadState.length; ++joy) {
+ var gamepad = GLFW.lastGamepadState[joy];
+
+ if (gamepad) {
+ if (!GLFW.joys[joy]) {
+ out('glfw joystick connected:',joy);
+ GLFW.joys[joy] = {
+ id: stringToNewUTF8(gamepad.id),
+ buttonsCount: gamepad.buttons.length,
+ axesCount: gamepad.axes.length,
+ buttons: _malloc(gamepad.buttons.length),
+ axes: _malloc(gamepad.axes.length*4),
+ };
+
+ if (GLFW.joystickFunc) {
+ ((a1, a2) => dynCall_vii(GLFW.joystickFunc, a1, a2))(joy, 0x00040001); // GLFW_CONNECTED
+ }
+ }
+
+ var data = GLFW.joys[joy];
+
+ for (var i = 0; i < gamepad.buttons.length; ++i) {
+ HEAP8[data.buttons + i] = gamepad.buttons[i].pressed;checkInt8(gamepad.buttons[i].pressed);
+ }
+
+ for (var i = 0; i < gamepad.axes.length; ++i) {
+ HEAPF32[((data.axes + i*4)>>2)] = gamepad.axes[i];
+ }
+ } else {
+ if (GLFW.joys[joy]) {
+ out('glfw joystick disconnected',joy);
+
+ if (GLFW.joystickFunc) {
+ ((a1, a2) => dynCall_vii(GLFW.joystickFunc, a1, a2))(joy, 0x00040002); // GLFW_DISCONNECTED
+ }
+
+ _free(GLFW.joys[joy].id);
+ _free(GLFW.joys[joy].buttons);
+ _free(GLFW.joys[joy].axes);
+
+ delete GLFW.joys[joy];
+ }
+ }
+ }
+ }
+ },
+ setKeyCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.keyFunc;
+ win.keyFunc = cbfun;
+ return prevcbfun;
+ },
+ setCharCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.charFunc;
+ win.charFunc = cbfun;
+ return prevcbfun;
+ },
+ setMouseButtonCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.mouseButtonFunc;
+ win.mouseButtonFunc = cbfun;
+ return prevcbfun;
+ },
+ setCursorPosCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.cursorPosFunc;
+ win.cursorPosFunc = cbfun;
+ return prevcbfun;
+ },
+ setScrollCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.scrollFunc;
+ win.scrollFunc = cbfun;
+ return prevcbfun;
+ },
+ setDropCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.dropFunc;
+ win.dropFunc = cbfun;
+ return prevcbfun;
+ },
+ onDrop:(event) => {
+ if (!GLFW.active || !GLFW.active.dropFunc) return;
+ if (!event.dataTransfer || !event.dataTransfer.files || event.dataTransfer.files.length == 0) return;
+
+ event.preventDefault();
+
+ var filenames = _malloc(event.dataTransfer.files.length*4);
+ var filenamesArray = [];
+ var count = event.dataTransfer.files.length;
+
+ // Read and save the files to emscripten's FS
+ var written = 0;
+ var drop_dir = '.glfw_dropped_files';
+ FS.createPath('/', drop_dir);
+
+ function save(file) {
+ var path = '/' + drop_dir + '/' + file.name.replace(/\//g, '_');
+ var reader = new FileReader();
+ reader.onloadend = (e) => {
+ if (reader.readyState != 2) { // not DONE
+ ++written;
+ out('failed to read dropped file: '+file.name+': '+reader.error);
+ return;
+ }
+
+ var data = e.target.result;
+ FS.writeFile(path, new Uint8Array(data));
+ if (++written === count) {
+ ((a1, a2, a3) => dynCall_viii(GLFW.active.dropFunc, a1, a2, a3))(GLFW.active.id, count, filenames);
+
+ for (var i = 0; i < filenamesArray.length; ++i) {
+ _free(filenamesArray[i]);
+ }
+ _free(filenames);
+ }
+ };
+ reader.readAsArrayBuffer(file);
+
+ var filename = stringToNewUTF8(path);
+ filenamesArray.push(filename);
+ HEAPU32[((filenames + i*4)>>2)] = filename;checkInt32(filename);
+ }
+
+ for (var i = 0; i < count; ++i) {
+ save(event.dataTransfer.files[i]);
+ }
+
+ return false;
+ },
+ onDragover:(event) => {
+ if (!GLFW.active || !GLFW.active.dropFunc) return;
+
+ event.preventDefault();
+ return false;
+ },
+ setWindowSizeCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.windowSizeFunc;
+ win.windowSizeFunc = cbfun;
+
+ return prevcbfun;
+ },
+ setWindowCloseCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.windowCloseFunc;
+ win.windowCloseFunc = cbfun;
+ return prevcbfun;
+ },
+ setWindowRefreshCallback:(winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.windowRefreshFunc;
+ win.windowRefreshFunc = cbfun;
+ return prevcbfun;
+ },
+ onClickRequestPointerLock:(e) => {
+ if (!Browser.pointerLock && Module['canvas'].requestPointerLock) {
+ Module['canvas'].requestPointerLock();
+ e.preventDefault();
+ }
+ },
+ setInputMode:(winid, mode, value) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return;
+
+ switch (mode) {
+ case 0x00033001: { // GLFW_CURSOR
+ switch (value) {
+ case 0x00034001: { // GLFW_CURSOR_NORMAL
+ win.inputModes[mode] = value;
+ Module['canvas'].removeEventListener('click', GLFW.onClickRequestPointerLock, true);
+ Module['canvas'].exitPointerLock();
+ break;
+ }
+ case 0x00034002: { // GLFW_CURSOR_HIDDEN
+ err('glfwSetInputMode called with GLFW_CURSOR_HIDDEN value not implemented');
+ break;
+ }
+ case 0x00034003: { // GLFW_CURSOR_DISABLED
+ win.inputModes[mode] = value;
+ Module['canvas'].addEventListener('click', GLFW.onClickRequestPointerLock, true);
+ Module['canvas'].requestPointerLock();
+ break;
+ }
+ default: {
+ err(`glfwSetInputMode called with unknown value parameter value: ${value}`);
+ break;
+ }
+ }
+ break;
+ }
+ case 0x00033002: { // GLFW_STICKY_KEYS
+ err('glfwSetInputMode called with GLFW_STICKY_KEYS mode not implemented');
+ break;
+ }
+ case 0x00033003: { // GLFW_STICKY_MOUSE_BUTTONS
+ err('glfwSetInputMode called with GLFW_STICKY_MOUSE_BUTTONS mode not implemented');
+ break;
+ }
+ case 0x00033004: { // GLFW_LOCK_KEY_MODS
+ err('glfwSetInputMode called with GLFW_LOCK_KEY_MODS mode not implemented');
+ break;
+ }
+ case 0x000330005: { // GLFW_RAW_MOUSE_MOTION
+ err('glfwSetInputMode called with GLFW_RAW_MOUSE_MOTION mode not implemented');
+ break;
+ }
+ default: {
+ err(`glfwSetInputMode called with unknown mode parameter value: ${mode}`);
+ break;
+ }
+ }
+ },
+ getKey:(winid, key) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return 0;
+ return win.keys[key];
+ },
+ getMouseButton:(winid, button) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return 0;
+ return (win.buttons & (1 << button)) > 0;
+ },
+ getCursorPos:(winid, x, y) => {
+ HEAPF64[((x)>>3)] = Browser.mouseX;
+ HEAPF64[((y)>>3)] = Browser.mouseY;
+ },
+ getMousePos:(winid, x, y) => {
+ HEAP32[((x)>>2)] = Browser.mouseX;checkInt32(Browser.mouseX);
+ HEAP32[((y)>>2)] = Browser.mouseY;checkInt32(Browser.mouseY);
+ },
+ setCursorPos:(winid, x, y) => {
+ },
+ getWindowPos:(winid, x, y) => {
+ var wx = 0;
+ var wy = 0;
+
+ var win = GLFW.WindowFromId(winid);
+ if (win) {
+ wx = win.x;
+ wy = win.y;
+ }
+
+ if (x) {
+ HEAP32[((x)>>2)] = wx;checkInt32(wx);
+ }
+
+ if (y) {
+ HEAP32[((y)>>2)] = wy;checkInt32(wy);
+ }
+ },
+ setWindowPos:(winid, x, y) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return;
+ win.x = x;
+ win.y = y;
+ },
+ getWindowSize:(winid, width, height) => {
+ var ww = 0;
+ var wh = 0;
+
+ var win = GLFW.WindowFromId(winid);
+ if (win) {
+ ww = win.width;
+ wh = win.height;
+ }
+
+ if (width) {
+ HEAP32[((width)>>2)] = ww;checkInt32(ww);
+ }
+
+ if (height) {
+ HEAP32[((height)>>2)] = wh;checkInt32(wh);
+ }
+ },
+ setWindowSize:(winid, width, height) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return;
+
+ if (GLFW.active.id == win.id) {
+ Browser.setCanvasSize(width, height); // triggers the listener (onCanvasResize) + windowSizeFunc
+ }
+ },
+ defaultWindowHints:() => {
+ GLFW.hints = Object.assign({}, GLFW.defaultHints);
+ },
+ createWindow:(width, height, title, monitor, share) => {
+ var i, id;
+ for (i = 0; i < GLFW.windows.length && GLFW.windows[i] !== null; i++) {
+ // no-op
+ }
+ if (i > 0) throw "glfwCreateWindow only supports one window at time currently";
+
+ // id for window
+ id = i + 1;
+
+ // not valid
+ if (width <= 0 || height <= 0) return 0;
+
+ if (monitor) {
+ Browser.requestFullscreen();
+ } else {
+ Browser.setCanvasSize(width, height);
+ }
+
+ // Create context when there are no existing alive windows
+ for (i = 0; i < GLFW.windows.length && GLFW.windows[i] == null; i++) {
+ // no-op
+ }
+ var useWebGL = GLFW.hints[0x00022001] > 0; // Use WebGL when we are told to based on GLFW_CLIENT_API
+ if (i == GLFW.windows.length) {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: (GLFW.hints[0x0002100D] > 1), // GLFW_SAMPLES
+ depth: (GLFW.hints[0x00021005] > 0), // GLFW_DEPTH_BITS
+ stencil: (GLFW.hints[0x00021006] > 0), // GLFW_STENCIL_BITS
+ alpha: (GLFW.hints[0x00021004] > 0) // GLFW_ALPHA_BITS
+ }
+ Browser.createContext(Module['canvas'], /*useWebGL=*/true, /*setInModule=*/true, contextAttributes);
+ } else {
+ Browser.init();
+ }
+ }
+
+ // If context creation failed, do not return a valid window
+ if (!Module.ctx && useWebGL) return 0;
+
+ // Initializes the framebuffer size from the canvas
+ const canvas = Module['canvas'];
+ var win = new GLFW_Window(id, width, height, canvas.width, canvas.height, title, monitor, share);
+
+ // Set window to array
+ if (id - 1 == GLFW.windows.length) {
+ GLFW.windows.push(win);
+ } else {
+ GLFW.windows[id - 1] = win;
+ }
+
+ GLFW.active = win;
+ GLFW.adjustCanvasDimensions();
+ return win.id;
+ },
+ destroyWindow:(winid) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return;
+
+ if (win.windowCloseFunc) {
+ ((a1) => dynCall_vi(win.windowCloseFunc, a1))(win.id);
+ }
+
+ GLFW.windows[win.id - 1] = null;
+ if (GLFW.active.id == win.id)
+ GLFW.active = null;
+
+ // Destroy context when no alive windows
+ for (var i = 0; i < GLFW.windows.length; i++)
+ if (GLFW.windows[i] !== null) return;
+
+ delete Module.ctx;
+ },
+ swapBuffers:(winid) => {
+ },
+ requestFullscreen(lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer == 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas == 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullscreenChange() {
+ Browser.isFullscreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['fullscreenElement'] || document['mozFullScreenElement'] ||
+ document['msFullscreenElement'] || document['webkitFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.exitFullscreen = Browser.exitFullscreen;
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullscreen = true;
+ if (Browser.resizeCanvas) {
+ Browser.setFullscreenCanvasSize();
+ } else {
+ Browser.updateCanvasDimensions(canvas);
+ Browser.updateResizeListeners();
+ }
+ } else {
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) {
+ Browser.setWindowedCanvasSize();
+ } else {
+ Browser.updateCanvasDimensions(canvas);
+ Browser.updateResizeListeners();
+ }
+ }
+ Module['onFullScreen']?.(Browser.isFullscreen);
+ Module['onFullscreen']?.(Browser.isFullscreen);
+ }
+
+ if (!Browser.fullscreenHandlersInstalled) {
+ Browser.fullscreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullscreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullscreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullscreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullscreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullscreen = canvasContainer['requestFullscreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullscreen'] ? () => canvasContainer['webkitRequestFullscreen'](Element['ALLOW_KEYBOARD_INPUT']) : null) ||
+ (canvasContainer['webkitRequestFullScreen'] ? () => canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) : null);
+
+ canvasContainer.requestFullscreen();
+ },
+ updateCanvasDimensions(canvas, wNative, hNative) {
+ const scale = GLFW.getHiDPIScale();
+
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['fullscreenElement'] || document['mozFullScreenElement'] ||
+ document['msFullscreenElement'] || document['webkitFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ wNative = w;
+ hNative = h;
+ }
+ const wNativeScaled = Math.floor(wNative * scale);
+ const hNativeScaled = Math.floor(hNative * scale);
+ if (canvas.width != wNativeScaled) canvas.width = wNativeScaled;
+ if (canvas.height != hNativeScaled) canvas.height = hNativeScaled;
+ if (typeof canvas.style != 'undefined') {
+ if (!GLFW.isCSSScalingEnabled()) {
+ canvas.style.setProperty( "width", wNative + "px", "important");
+ canvas.style.setProperty("height", hNative + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ },
+ calculateMouseCoords(pageX, pageY) {
+ // Calculate the movement based on the changes
+ // in the coordinates.
+ const rect = Module["canvas"].getBoundingClientRect();
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX != 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY != 'undefined') ? window.scrollY : window.pageYOffset);
+ // If this assert lands, it's likely because the browser doesn't support scrollX or pageXOffset
+ // and we have no viable fallback.
+ assert((typeof scrollX != 'undefined') && (typeof scrollY != 'undefined'), 'Unable to retrieve scroll position, mouse positions likely broken.');
+ var adjustedX = pageX - (scrollX + rect.left);
+ var adjustedY = pageY - (scrollY + rect.top);
+
+ // getBoundingClientRect() returns dimension affected by CSS, so as a result:
+ // - when CSS scaling is enabled, this will fix the mouse coordinates to match the width/height of the window
+ // - otherwise the CSS width/height are forced to the width/height of the GLFW window (see updateCanvasDimensions),
+ // so there is no need to adjust the position
+ if (GLFW.isCSSScalingEnabled() && GLFW.active) {
+ adjustedX = adjustedX * (GLFW.active.width / rect.width);
+ adjustedY = adjustedY * (GLFW.active.height / rect.height);
+ }
+
+ return { x: adjustedX, y: adjustedY };
+ },
+ setWindowAttrib:(winid, attrib, value) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return;
+ const isHiDPIAware = GLFW.isHiDPIAware();
+ win.attributes[attrib] = value;
+ if (isHiDPIAware !== GLFW.isHiDPIAware())
+ GLFW.adjustCanvasDimensions();
+ },
+ getDevicePixelRatio() {
+ return (typeof devicePixelRatio == 'number' && devicePixelRatio) || 1.0;
+ },
+ isHiDPIAware() {
+ if (GLFW.active)
+ return GLFW.active.attributes[0x0002200C] > 0; // GLFW_SCALE_TO_MONITOR
+ else
+ return false;
+ },
+ isCSSScalingEnabled() {
+ return !GLFW.isHiDPIAware();
+ },
+ adjustCanvasDimensions() {
+ if (GLFW.active) {
+ Browser.updateCanvasDimensions(Module['canvas'], GLFW.active.width, GLFW.active.height);
+ Browser.updateResizeListeners();
+ }
+ },
+ getHiDPIScale() {
+ return GLFW.isHiDPIAware() ? GLFW.scale : 1.0;
+ },
+ onDevicePixelRatioChange() {
+ GLFW.onWindowContentScaleChanged(GLFW.getDevicePixelRatio());
+ GLFW.adjustCanvasDimensions();
+ },
+ GLFW2ParamToGLFW3Param:(param) => {
+ var table = {
+ 0x00030001:0, // GLFW_MOUSE_CURSOR
+ 0x00030002:0, // GLFW_STICKY_KEYS
+ 0x00030003:0, // GLFW_STICKY_MOUSE_BUTTONS
+ 0x00030004:0, // GLFW_SYSTEM_KEYS
+ 0x00030005:0, // GLFW_KEY_REPEAT
+ 0x00030006:0, // GLFW_AUTO_POLL_EVENTS
+ 0x00020001:0, // GLFW_OPENED
+ 0x00020002:0, // GLFW_ACTIVE
+ 0x00020003:0, // GLFW_ICONIFIED
+ 0x00020004:0, // GLFW_ACCELERATED
+ 0x00020005:0x00021001, // GLFW_RED_BITS
+ 0x00020006:0x00021002, // GLFW_GREEN_BITS
+ 0x00020007:0x00021003, // GLFW_BLUE_BITS
+ 0x00020008:0x00021004, // GLFW_ALPHA_BITS
+ 0x00020009:0x00021005, // GLFW_DEPTH_BITS
+ 0x0002000A:0x00021006, // GLFW_STENCIL_BITS
+ 0x0002000B:0x0002100F, // GLFW_REFRESH_RATE
+ 0x0002000C:0x00021007, // GLFW_ACCUM_RED_BITS
+ 0x0002000D:0x00021008, // GLFW_ACCUM_GREEN_BITS
+ 0x0002000E:0x00021009, // GLFW_ACCUM_BLUE_BITS
+ 0x0002000F:0x0002100A, // GLFW_ACCUM_ALPHA_BITS
+ 0x00020010:0x0002100B, // GLFW_AUX_BUFFERS
+ 0x00020011:0x0002100C, // GLFW_STEREO
+ 0x00020012:0, // GLFW_WINDOW_NO_RESIZE
+ 0x00020013:0x0002100D, // GLFW_FSAA_SAMPLES
+ 0x00020014:0x00022002, // GLFW_OPENGL_VERSION_MAJOR
+ 0x00020015:0x00022003, // GLFW_OPENGL_VERSION_MINOR
+ 0x00020016:0x00022006, // GLFW_OPENGL_FORWARD_COMPAT
+ 0x00020017:0x00022007, // GLFW_OPENGL_DEBUG_CONTEXT
+ 0x00020018:0x00022008, // GLFW_OPENGL_PROFILE
+ };
+ return table[param];
+ },
+ };
+ var _glfwCreateWindow = (width, height, title, monitor, share) => GLFW.createWindow(width, height, title, monitor, share);
+
+ var _glfwDefaultWindowHints = () => GLFW.defaultWindowHints();
+
+ var _glfwDestroyWindow = (winid) => GLFW.destroyWindow(winid);
+
+ var _glfwGetPrimaryMonitor = () => 1;
+
+ var _glfwGetTime = () => GLFW.getTime() - GLFW.initialTime;
+
+ var _glfwGetVideoModes = (monitor, count) => {
+ HEAP32[((count)>>2)] = 0;checkInt32(0);
+ return 0;
+ };
+
+
+
+ var _glfwInit = () => {
+ if (GLFW.windows) return 1; // GL_TRUE
+
+ GLFW.initialTime = GLFW.getTime();
+ GLFW.defaultWindowHints();
+ GLFW.windows = new Array()
+ GLFW.active = null;
+ GLFW.scale = GLFW.getDevicePixelRatio();
+
+ window.addEventListener("gamepadconnected", GLFW.onGamepadConnected, true);
+ window.addEventListener("gamepaddisconnected", GLFW.onGamepadDisconnected, true);
+ window.addEventListener("keydown", GLFW.onKeydown, true);
+ window.addEventListener("keypress", GLFW.onKeyPress, true);
+ window.addEventListener("keyup", GLFW.onKeyup, true);
+ window.addEventListener("blur", GLFW.onBlur, true);
+
+ // watch for devicePixelRatio changes
+ GLFW.devicePixelRatioMQL = window.matchMedia('(resolution: ' + GLFW.getDevicePixelRatio() + 'dppx)');
+ GLFW.devicePixelRatioMQL.addEventListener('change', GLFW.onDevicePixelRatioChange);
+
+ Module["canvas"].addEventListener("touchmove", GLFW.onMousemove, true);
+ Module["canvas"].addEventListener("touchstart", GLFW.onMouseButtonDown, true);
+ Module["canvas"].addEventListener("touchcancel", GLFW.onMouseButtonUp, true);
+ Module["canvas"].addEventListener("touchend", GLFW.onMouseButtonUp, true);
+ Module["canvas"].addEventListener("mousemove", GLFW.onMousemove, true);
+ Module["canvas"].addEventListener("mousedown", GLFW.onMouseButtonDown, true);
+ Module["canvas"].addEventListener("mouseup", GLFW.onMouseButtonUp, true);
+ Module["canvas"].addEventListener('wheel', GLFW.onMouseWheel, true);
+ Module["canvas"].addEventListener('mousewheel', GLFW.onMouseWheel, true);
+ Module["canvas"].addEventListener('mouseenter', GLFW.onMouseenter, true);
+ Module["canvas"].addEventListener('mouseleave', GLFW.onMouseleave, true);
+ Module["canvas"].addEventListener('drop', GLFW.onDrop, true);
+ Module["canvas"].addEventListener('dragover', GLFW.onDragover, true);
+
+ // Overriding implementation to account for HiDPI
+ Browser.requestFullscreen = GLFW.requestFullscreen;
+ Browser.calculateMouseCoords = GLFW.calculateMouseCoords;
+ Browser.updateCanvasDimensions = GLFW.updateCanvasDimensions;
+
+ Browser.resizeListeners.push((width, height) => {
+ if (GLFW.isHiDPIAware()) {
+ var canvas = Module['canvas'];
+ GLFW.onCanvasResize(canvas.clientWidth, canvas.clientHeight, width, height);
+ } else {
+ GLFW.onCanvasResize(width, height, width, height);
+ }
+ });
+
+ return 1; // GL_TRUE
+ };
+
+ var _glfwMakeContextCurrent = (winid) => {};
+
+ var _glfwSetCharCallback = (winid, cbfun) => GLFW.setCharCallback(winid, cbfun);
+
+ var _glfwSetCursorEnterCallback = (winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.cursorEnterFunc;
+ win.cursorEnterFunc = cbfun;
+ return prevcbfun;
+ };
+
+ var _glfwSetCursorPosCallback = (winid, cbfun) => GLFW.setCursorPosCallback(winid, cbfun);
+
+ var _glfwSetDropCallback = (winid, cbfun) => GLFW.setDropCallback(winid, cbfun);
+
+ var _glfwSetErrorCallback = (cbfun) => {
+ var prevcbfun = GLFW.errorFunc;
+ GLFW.errorFunc = cbfun;
+ return prevcbfun;
+ };
+
+ var _glfwSetKeyCallback = (winid, cbfun) => GLFW.setKeyCallback(winid, cbfun);
+
+ var _glfwSetMouseButtonCallback = (winid, cbfun) => GLFW.setMouseButtonCallback(winid, cbfun);
+
+ var _glfwSetScrollCallback = (winid, cbfun) => GLFW.setScrollCallback(winid, cbfun);
+
+ var _glfwSetWindowFocusCallback = (winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.windowFocusFunc;
+ win.windowFocusFunc = cbfun;
+ return prevcbfun;
+ };
+
+ var _glfwSetWindowIconifyCallback = (winid, cbfun) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return null;
+ var prevcbfun = win.windowIconifyFunc;
+ win.windowIconifyFunc = cbfun;
+ return prevcbfun;
+ };
+
+ var _glfwSetWindowShouldClose = (winid, value) => {
+ var win = GLFW.WindowFromId(winid);
+ if (!win) return;
+ win.shouldClose = value;
+ };
+
+ var _glfwSetWindowSizeCallback = (winid, cbfun) => GLFW.setWindowSizeCallback(winid, cbfun);
+
+ var _glfwSwapBuffers = (winid) => GLFW.swapBuffers(winid);
+
+ var _glfwTerminate = () => {
+ window.removeEventListener("gamepadconnected", GLFW.onGamepadConnected, true);
+ window.removeEventListener("gamepaddisconnected", GLFW.onGamepadDisconnected, true);
+ window.removeEventListener("keydown", GLFW.onKeydown, true);
+ window.removeEventListener("keypress", GLFW.onKeyPress, true);
+ window.removeEventListener("keyup", GLFW.onKeyup, true);
+ window.removeEventListener("blur", GLFW.onBlur, true);
+ Module["canvas"].removeEventListener("touchmove", GLFW.onMousemove, true);
+ Module["canvas"].removeEventListener("touchstart", GLFW.onMouseButtonDown, true);
+ Module["canvas"].removeEventListener("touchcancel", GLFW.onMouseButtonUp, true);
+ Module["canvas"].removeEventListener("touchend", GLFW.onMouseButtonUp, true);
+ Module["canvas"].removeEventListener("mousemove", GLFW.onMousemove, true);
+ Module["canvas"].removeEventListener("mousedown", GLFW.onMouseButtonDown, true);
+ Module["canvas"].removeEventListener("mouseup", GLFW.onMouseButtonUp, true);
+ Module["canvas"].removeEventListener('wheel', GLFW.onMouseWheel, true);
+ Module["canvas"].removeEventListener('mousewheel', GLFW.onMouseWheel, true);
+ Module["canvas"].removeEventListener('mouseenter', GLFW.onMouseenter, true);
+ Module["canvas"].removeEventListener('mouseleave', GLFW.onMouseleave, true);
+ Module["canvas"].removeEventListener('drop', GLFW.onDrop, true);
+ Module["canvas"].removeEventListener('dragover', GLFW.onDragover, true);
+
+ if (GLFW.devicePixelRatioMQL)
+ GLFW.devicePixelRatioMQL.removeEventListener('change', GLFW.onDevicePixelRatioChange);
+
+ Module["canvas"].width = Module["canvas"].height = 1;
+ GLFW.windows = null;
+ GLFW.active = null;
+ };
+
+ var _glfwWindowHint = (target, hint) => {
+ GLFW.hints[target] = hint;
+ };
+
+
+
+
+ var runAndAbortIfError = (func) => {
+ try {
+ return func();
+ } catch (e) {
+ abort(e);
+ }
+ };
+
+
+ var sigToWasmTypes = (sig) => {
+ assert(!sig.includes('j'), 'i64 not permitted in function signatures when WASM_BIGINT is disabled');
+ var typeNames = {
+ 'i': 'i32',
+ 'j': 'i64',
+ 'f': 'f32',
+ 'd': 'f64',
+ 'e': 'externref',
+ 'p': 'i32',
+ };
+ var type = {
+ parameters: [],
+ results: sig[0] == 'v' ? [] : [typeNames[sig[0]]]
+ };
+ for (var i = 1; i < sig.length; ++i) {
+ assert(sig[i] in typeNames, 'invalid signature char: ' + sig[i]);
+ type.parameters.push(typeNames[sig[i]]);
+ }
+ return type;
+ };
+
+ var runtimeKeepalivePush = () => {
+ runtimeKeepaliveCounter += 1;
+ };
+
+ var runtimeKeepalivePop = () => {
+ assert(runtimeKeepaliveCounter > 0);
+ runtimeKeepaliveCounter -= 1;
+ };
+
+
+ var Asyncify = {
+ instrumentWasmImports(imports) {
+ var importPattern = /^(invoke_.*|__asyncjs__.*)$/;
+
+ for (let [x, original] of Object.entries(imports)) {
+ if (typeof original == 'function') {
+ let isAsyncifyImport = original.isAsync || importPattern.test(x);
+ imports[x] = (...args) => {
+ var originalAsyncifyState = Asyncify.state;
+ try {
+ return original(...args);
+ } finally {
+ // Only asyncify-declared imports are allowed to change the
+ // state.
+ // Changing the state from normal to disabled is allowed (in any
+ // function) as that is what shutdown does (and we don't have an
+ // explicit list of shutdown imports).
+ var changedToDisabled =
+ originalAsyncifyState === Asyncify.State.Normal &&
+ Asyncify.state === Asyncify.State.Disabled;
+ // invoke_* functions are allowed to change the state if we do
+ // not ignore indirect calls.
+ var ignoredInvoke = x.startsWith('invoke_') &&
+ true;
+ if (Asyncify.state !== originalAsyncifyState &&
+ !isAsyncifyImport &&
+ !changedToDisabled &&
+ !ignoredInvoke) {
+ throw new Error(`import ${x} was not in ASYNCIFY_IMPORTS, but changed the state`);
+ }
+ }
+ };
+ }
+ }
+ },
+ instrumentWasmExports(exports) {
+ var ret = {};
+ for (let [x, original] of Object.entries(exports)) {
+ if (typeof original == 'function') {
+ ret[x] = (...args) => {
+ Asyncify.exportCallStack.push(x);
+ try {
+ return original(...args);
+ } finally {
+ if (!ABORT) {
+ var y = Asyncify.exportCallStack.pop();
+ assert(y === x);
+ Asyncify.maybeStopUnwind();
+ }
+ }
+ };
+ } else {
+ ret[x] = original;
+ }
+ }
+ return ret;
+ },
+ State:{
+ Normal:0,
+ Unwinding:1,
+ Rewinding:2,
+ Disabled:3,
+ },
+ state:0,
+ StackSize:4096,
+ currData:null,
+ handleSleepReturnValue:0,
+ exportCallStack:[],
+ callStackNameToId:{
+ },
+ callStackIdToName:{
+ },
+ callStackId:0,
+ asyncPromiseHandlers:null,
+ sleepCallbacks:[],
+ getCallStackId(funcName) {
+ var id = Asyncify.callStackNameToId[funcName];
+ if (id === undefined) {
+ id = Asyncify.callStackId++;
+ Asyncify.callStackNameToId[funcName] = id;
+ Asyncify.callStackIdToName[id] = funcName;
+ }
+ return id;
+ },
+ maybeStopUnwind() {
+ if (Asyncify.currData &&
+ Asyncify.state === Asyncify.State.Unwinding &&
+ Asyncify.exportCallStack.length === 0) {
+ // We just finished unwinding.
+ // Be sure to set the state before calling any other functions to avoid
+ // possible infinite recursion here (For example in debug pthread builds
+ // the dbg() function itself can call back into WebAssembly to get the
+ // current pthread_self() pointer).
+ Asyncify.state = Asyncify.State.Normal;
+
+ // Keep the runtime alive so that a re-wind can be done later.
+ runAndAbortIfError(_asyncify_stop_unwind);
+ if (typeof Fibers != 'undefined') {
+ Fibers.trampoline();
+ }
+ }
+ },
+ whenDone() {
+ assert(Asyncify.currData, 'Tried to wait for an async operation when none is in progress.');
+ assert(!Asyncify.asyncPromiseHandlers, 'Cannot have multiple async operations in flight at once');
+ return new Promise((resolve, reject) => {
+ Asyncify.asyncPromiseHandlers = { resolve, reject };
+ });
+ },
+ allocateData() {
+ // An asyncify data structure has three fields:
+ // 0 current stack pos
+ // 4 max stack pos
+ // 8 id of function at bottom of the call stack (callStackIdToName[id] == name of js function)
+ //
+ // The Asyncify ABI only interprets the first two fields, the rest is for the runtime.
+ // We also embed a stack in the same memory region here, right next to the structure.
+ // This struct is also defined as asyncify_data_t in emscripten/fiber.h
+ var ptr = _malloc(12 + Asyncify.StackSize);
+ Asyncify.setDataHeader(ptr, ptr + 12, Asyncify.StackSize);
+ Asyncify.setDataRewindFunc(ptr);
+ return ptr;
+ },
+ setDataHeader(ptr, stack, stackSize) {
+ HEAPU32[((ptr)>>2)] = stack;
+ HEAPU32[(((ptr)+(4))>>2)] = stack + stackSize;
+ },
+ setDataRewindFunc(ptr) {
+ var bottomOfCallStack = Asyncify.exportCallStack[0];
+ var rewindId = Asyncify.getCallStackId(bottomOfCallStack);
+ HEAP32[(((ptr)+(8))>>2)] = rewindId;checkInt32(rewindId);
+ },
+ getDataRewindFuncName(ptr) {
+ var id = HEAP32[(((ptr)+(8))>>2)];
+ var name = Asyncify.callStackIdToName[id];
+ return name;
+ },
+ getDataRewindFunc(name) {
+ var func = wasmExports[name];
+ return func;
+ },
+ doRewind(ptr) {
+ var name = Asyncify.getDataRewindFuncName(ptr);
+ var func = Asyncify.getDataRewindFunc(name);
+ // Once we have rewound and the stack we no longer need to artificially
+ // keep the runtime alive.
+
+ return func();
+ },
+ handleSleep(startAsync) {
+ assert(Asyncify.state !== Asyncify.State.Disabled, 'Asyncify cannot be done during or after the runtime exits');
+ if (ABORT) return;
+ if (Asyncify.state === Asyncify.State.Normal) {
+ // Prepare to sleep. Call startAsync, and see what happens:
+ // if the code decided to call our callback synchronously,
+ // then no async operation was in fact begun, and we don't
+ // need to do anything.
+ var reachedCallback = false;
+ var reachedAfterCallback = false;
+ startAsync((handleSleepReturnValue = 0) => {
+ assert(!handleSleepReturnValue || typeof handleSleepReturnValue == 'number' || typeof handleSleepReturnValue == 'boolean'); // old emterpretify API supported other stuff
+ if (ABORT) return;
+ Asyncify.handleSleepReturnValue = handleSleepReturnValue;
+ reachedCallback = true;
+ if (!reachedAfterCallback) {
+ // We are happening synchronously, so no need for async.
+ return;
+ }
+ // This async operation did not happen synchronously, so we did
+ // unwind. In that case there can be no compiled code on the stack,
+ // as it might break later operations (we can rewind ok now, but if
+ // we unwind again, we would unwind through the extra compiled code
+ // too).
+ assert(!Asyncify.exportCallStack.length, 'Waking up (starting to rewind) must be done from JS, without compiled code on the stack.');
+ Asyncify.state = Asyncify.State.Rewinding;
+ runAndAbortIfError(() => _asyncify_start_rewind(Asyncify.currData));
+ if (typeof MainLoop != 'undefined' && MainLoop.func) {
+ MainLoop.resume();
+ }
+ var asyncWasmReturnValue, isError = false;
+ try {
+ asyncWasmReturnValue = Asyncify.doRewind(Asyncify.currData);
+ } catch (err) {
+ asyncWasmReturnValue = err;
+ isError = true;
+ }
+ // Track whether the return value was handled by any promise handlers.
+ var handled = false;
+ if (!Asyncify.currData) {
+ // All asynchronous execution has finished.
+ // `asyncWasmReturnValue` now contains the final
+ // return value of the exported async WASM function.
+ //
+ // Note: `asyncWasmReturnValue` is distinct from
+ // `Asyncify.handleSleepReturnValue`.
+ // `Asyncify.handleSleepReturnValue` contains the return
+ // value of the last C function to have executed
+ // `Asyncify.handleSleep()`, where as `asyncWasmReturnValue`
+ // contains the return value of the exported WASM function
+ // that may have called C functions that
+ // call `Asyncify.handleSleep()`.
+ var asyncPromiseHandlers = Asyncify.asyncPromiseHandlers;
+ if (asyncPromiseHandlers) {
+ Asyncify.asyncPromiseHandlers = null;
+ (isError ? asyncPromiseHandlers.reject : asyncPromiseHandlers.resolve)(asyncWasmReturnValue);
+ handled = true;
+ }
+ }
+ if (isError && !handled) {
+ // If there was an error and it was not handled by now, we have no choice but to
+ // rethrow that error into the global scope where it can be caught only by
+ // `onerror` or `onunhandledpromiserejection`.
+ throw asyncWasmReturnValue;
+ }
+ });
+ reachedAfterCallback = true;
+ if (!reachedCallback) {
+ // A true async operation was begun; start a sleep.
+ Asyncify.state = Asyncify.State.Unwinding;
+ // TODO: reuse, don't alloc/free every sleep
+ Asyncify.currData = Asyncify.allocateData();
+ if (typeof MainLoop != 'undefined' && MainLoop.func) {
+ MainLoop.pause();
+ }
+ runAndAbortIfError(() => _asyncify_start_unwind(Asyncify.currData));
+ }
+ } else if (Asyncify.state === Asyncify.State.Rewinding) {
+ // Stop a resume.
+ Asyncify.state = Asyncify.State.Normal;
+ runAndAbortIfError(_asyncify_stop_rewind);
+ _free(Asyncify.currData);
+ Asyncify.currData = null;
+ // Call all sleep callbacks now that the sleep-resume is all done.
+ Asyncify.sleepCallbacks.forEach(callUserCallback);
+ } else {
+ abort(`invalid state: ${Asyncify.state}`);
+ }
+ return Asyncify.handleSleepReturnValue;
+ },
+ handleAsync(startAsync) {
+ return Asyncify.handleSleep((wakeUp) => {
+ // TODO: add error handling as a second param when handleSleep implements it.
+ startAsync().then(wakeUp);
+ });
+ },
+ };
+
+ var FS_createPath = FS.createPath;
+
+
+
+ var FS_unlink = (path) => FS.unlink(path);
+
+ var FS_createLazyFile = FS.createLazyFile;
+
+ var FS_createDevice = FS.createDevice;
+
+ FS.createPreloadedFile = FS_createPreloadedFile;
+ FS.staticInit();
+ // Set module methods based on EXPORTED_RUNTIME_METHODS
+ Module["FS_createPath"] = FS.createPath;
+ Module["FS_createDataFile"] = FS.createDataFile;
+ Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
+ Module["FS_unlink"] = FS.unlink;
+ Module["FS_createLazyFile"] = FS.createLazyFile;
+ Module["FS_createDevice"] = FS.createDevice;
+ ;
+for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i));;
+var miniTempWebGLFloatBuffersStorage = new Float32Array(288);
+ // Create GL_POOL_TEMP_BUFFERS_SIZE+1 temporary buffers, for uploads of size 0 through GL_POOL_TEMP_BUFFERS_SIZE inclusive
+ for (/**@suppress{duplicate}*/var i = 0; i <= 288; ++i) {
+ miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i);
+ };
+var miniTempWebGLIntBuffersStorage = new Int32Array(288);
+ // Create GL_POOL_TEMP_BUFFERS_SIZE+1 temporary buffers, for uploads of size 0 through GL_POOL_TEMP_BUFFERS_SIZE inclusive
+ for (/**@suppress{duplicate}*/var i = 0; i <= 288; ++i) {
+ miniTempWebGLIntBuffers[i] = miniTempWebGLIntBuffersStorage.subarray(0, i);
+ };
+
+ // exports
+ Module["requestFullscreen"] = Browser.requestFullscreen;
+ Module["requestFullScreen"] = Browser.requestFullScreen;
+ Module["setCanvasSize"] = Browser.setCanvasSize;
+ Module["getUserMedia"] = Browser.getUserMedia;
+ Module["createContext"] = Browser.createContext;
+ ;
+
+ Module["requestAnimationFrame"] = MainLoop.requestAnimationFrame;
+ Module["pauseMainLoop"] = MainLoop.pause;
+ Module["resumeMainLoop"] = MainLoop.resume;
+ MainLoop.init();;
+function checkIncomingModuleAPI() {
+ ignoredModuleProp('fetchSettings');
+}
+var wasmImports = {
+ /** @export */
+ GetWindowInnerHeight,
+ /** @export */
+ GetWindowInnerWidth,
+ /** @export */
+ __assert_fail: ___assert_fail,
+ /** @export */
+ __handle_stack_overflow: ___handle_stack_overflow,
+ /** @export */
+ __syscall_faccessat: ___syscall_faccessat,
+ /** @export */
+ __syscall_fcntl64: ___syscall_fcntl64,
+ /** @export */
+ __syscall_getcwd: ___syscall_getcwd,
+ /** @export */
+ __syscall_ioctl: ___syscall_ioctl,
+ /** @export */
+ __syscall_openat: ___syscall_openat,
+ /** @export */
+ _abort_js: __abort_js,
+ /** @export */
+ _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
+ /** @export */
+ _emscripten_memcpy_js: __emscripten_memcpy_js,
+ /** @export */
+ emscripten_date_now: _emscripten_date_now,
+ /** @export */
+ emscripten_get_element_css_size: _emscripten_get_element_css_size,
+ /** @export */
+ emscripten_get_gamepad_status: _emscripten_get_gamepad_status,
+ /** @export */
+ emscripten_get_now: _emscripten_get_now,
+ /** @export */
+ emscripten_get_num_gamepads: _emscripten_get_num_gamepads,
+ /** @export */
+ emscripten_glActiveTexture: _emscripten_glActiveTexture,
+ /** @export */
+ emscripten_glAttachShader: _emscripten_glAttachShader,
+ /** @export */
+ emscripten_glBeginQuery: _emscripten_glBeginQuery,
+ /** @export */
+ emscripten_glBeginQueryEXT: _emscripten_glBeginQueryEXT,
+ /** @export */
+ emscripten_glBeginTransformFeedback: _emscripten_glBeginTransformFeedback,
+ /** @export */
+ emscripten_glBindAttribLocation: _emscripten_glBindAttribLocation,
+ /** @export */
+ emscripten_glBindBuffer: _emscripten_glBindBuffer,
+ /** @export */
+ emscripten_glBindBufferBase: _emscripten_glBindBufferBase,
+ /** @export */
+ emscripten_glBindBufferRange: _emscripten_glBindBufferRange,
+ /** @export */
+ emscripten_glBindFramebuffer: _emscripten_glBindFramebuffer,
+ /** @export */
+ emscripten_glBindRenderbuffer: _emscripten_glBindRenderbuffer,
+ /** @export */
+ emscripten_glBindSampler: _emscripten_glBindSampler,
+ /** @export */
+ emscripten_glBindTexture: _emscripten_glBindTexture,
+ /** @export */
+ emscripten_glBindTransformFeedback: _emscripten_glBindTransformFeedback,
+ /** @export */
+ emscripten_glBindVertexArray: _emscripten_glBindVertexArray,
+ /** @export */
+ emscripten_glBindVertexArrayOES: _emscripten_glBindVertexArrayOES,
+ /** @export */
+ emscripten_glBlendColor: _emscripten_glBlendColor,
+ /** @export */
+ emscripten_glBlendEquation: _emscripten_glBlendEquation,
+ /** @export */
+ emscripten_glBlendEquationSeparate: _emscripten_glBlendEquationSeparate,
+ /** @export */
+ emscripten_glBlendFunc: _emscripten_glBlendFunc,
+ /** @export */
+ emscripten_glBlendFuncSeparate: _emscripten_glBlendFuncSeparate,
+ /** @export */
+ emscripten_glBlitFramebuffer: _emscripten_glBlitFramebuffer,
+ /** @export */
+ emscripten_glBufferData: _emscripten_glBufferData,
+ /** @export */
+ emscripten_glBufferSubData: _emscripten_glBufferSubData,
+ /** @export */
+ emscripten_glCheckFramebufferStatus: _emscripten_glCheckFramebufferStatus,
+ /** @export */
+ emscripten_glClear: _emscripten_glClear,
+ /** @export */
+ emscripten_glClearBufferfi: _emscripten_glClearBufferfi,
+ /** @export */
+ emscripten_glClearBufferfv: _emscripten_glClearBufferfv,
+ /** @export */
+ emscripten_glClearBufferiv: _emscripten_glClearBufferiv,
+ /** @export */
+ emscripten_glClearBufferuiv: _emscripten_glClearBufferuiv,
+ /** @export */
+ emscripten_glClearColor: _emscripten_glClearColor,
+ /** @export */
+ emscripten_glClearDepthf: _emscripten_glClearDepthf,
+ /** @export */
+ emscripten_glClearStencil: _emscripten_glClearStencil,
+ /** @export */
+ emscripten_glClientWaitSync: _emscripten_glClientWaitSync,
+ /** @export */
+ emscripten_glClipControlEXT: _emscripten_glClipControlEXT,
+ /** @export */
+ emscripten_glColorMask: _emscripten_glColorMask,
+ /** @export */
+ emscripten_glCompileShader: _emscripten_glCompileShader,
+ /** @export */
+ emscripten_glCompressedTexImage2D: _emscripten_glCompressedTexImage2D,
+ /** @export */
+ emscripten_glCompressedTexImage3D: _emscripten_glCompressedTexImage3D,
+ /** @export */
+ emscripten_glCompressedTexSubImage2D: _emscripten_glCompressedTexSubImage2D,
+ /** @export */
+ emscripten_glCompressedTexSubImage3D: _emscripten_glCompressedTexSubImage3D,
+ /** @export */
+ emscripten_glCopyBufferSubData: _emscripten_glCopyBufferSubData,
+ /** @export */
+ emscripten_glCopyTexImage2D: _emscripten_glCopyTexImage2D,
+ /** @export */
+ emscripten_glCopyTexSubImage2D: _emscripten_glCopyTexSubImage2D,
+ /** @export */
+ emscripten_glCopyTexSubImage3D: _emscripten_glCopyTexSubImage3D,
+ /** @export */
+ emscripten_glCreateProgram: _emscripten_glCreateProgram,
+ /** @export */
+ emscripten_glCreateShader: _emscripten_glCreateShader,
+ /** @export */
+ emscripten_glCullFace: _emscripten_glCullFace,
+ /** @export */
+ emscripten_glDeleteBuffers: _emscripten_glDeleteBuffers,
+ /** @export */
+ emscripten_glDeleteFramebuffers: _emscripten_glDeleteFramebuffers,
+ /** @export */
+ emscripten_glDeleteProgram: _emscripten_glDeleteProgram,
+ /** @export */
+ emscripten_glDeleteQueries: _emscripten_glDeleteQueries,
+ /** @export */
+ emscripten_glDeleteQueriesEXT: _emscripten_glDeleteQueriesEXT,
+ /** @export */
+ emscripten_glDeleteRenderbuffers: _emscripten_glDeleteRenderbuffers,
+ /** @export */
+ emscripten_glDeleteSamplers: _emscripten_glDeleteSamplers,
+ /** @export */
+ emscripten_glDeleteShader: _emscripten_glDeleteShader,
+ /** @export */
+ emscripten_glDeleteSync: _emscripten_glDeleteSync,
+ /** @export */
+ emscripten_glDeleteTextures: _emscripten_glDeleteTextures,
+ /** @export */
+ emscripten_glDeleteTransformFeedbacks: _emscripten_glDeleteTransformFeedbacks,
+ /** @export */
+ emscripten_glDeleteVertexArrays: _emscripten_glDeleteVertexArrays,
+ /** @export */
+ emscripten_glDeleteVertexArraysOES: _emscripten_glDeleteVertexArraysOES,
+ /** @export */
+ emscripten_glDepthFunc: _emscripten_glDepthFunc,
+ /** @export */
+ emscripten_glDepthMask: _emscripten_glDepthMask,
+ /** @export */
+ emscripten_glDepthRangef: _emscripten_glDepthRangef,
+ /** @export */
+ emscripten_glDetachShader: _emscripten_glDetachShader,
+ /** @export */
+ emscripten_glDisable: _emscripten_glDisable,
+ /** @export */
+ emscripten_glDisableVertexAttribArray: _emscripten_glDisableVertexAttribArray,
+ /** @export */
+ emscripten_glDrawArrays: _emscripten_glDrawArrays,
+ /** @export */
+ emscripten_glDrawArraysInstanced: _emscripten_glDrawArraysInstanced,
+ /** @export */
+ emscripten_glDrawArraysInstancedANGLE: _emscripten_glDrawArraysInstancedANGLE,
+ /** @export */
+ emscripten_glDrawArraysInstancedARB: _emscripten_glDrawArraysInstancedARB,
+ /** @export */
+ emscripten_glDrawArraysInstancedEXT: _emscripten_glDrawArraysInstancedEXT,
+ /** @export */
+ emscripten_glDrawArraysInstancedNV: _emscripten_glDrawArraysInstancedNV,
+ /** @export */
+ emscripten_glDrawBuffers: _emscripten_glDrawBuffers,
+ /** @export */
+ emscripten_glDrawBuffersEXT: _emscripten_glDrawBuffersEXT,
+ /** @export */
+ emscripten_glDrawBuffersWEBGL: _emscripten_glDrawBuffersWEBGL,
+ /** @export */
+ emscripten_glDrawElements: _emscripten_glDrawElements,
+ /** @export */
+ emscripten_glDrawElementsInstanced: _emscripten_glDrawElementsInstanced,
+ /** @export */
+ emscripten_glDrawElementsInstancedANGLE: _emscripten_glDrawElementsInstancedANGLE,
+ /** @export */
+ emscripten_glDrawElementsInstancedARB: _emscripten_glDrawElementsInstancedARB,
+ /** @export */
+ emscripten_glDrawElementsInstancedEXT: _emscripten_glDrawElementsInstancedEXT,
+ /** @export */
+ emscripten_glDrawElementsInstancedNV: _emscripten_glDrawElementsInstancedNV,
+ /** @export */
+ emscripten_glDrawRangeElements: _emscripten_glDrawRangeElements,
+ /** @export */
+ emscripten_glEnable: _emscripten_glEnable,
+ /** @export */
+ emscripten_glEnableVertexAttribArray: _emscripten_glEnableVertexAttribArray,
+ /** @export */
+ emscripten_glEndQuery: _emscripten_glEndQuery,
+ /** @export */
+ emscripten_glEndQueryEXT: _emscripten_glEndQueryEXT,
+ /** @export */
+ emscripten_glEndTransformFeedback: _emscripten_glEndTransformFeedback,
+ /** @export */
+ emscripten_glFenceSync: _emscripten_glFenceSync,
+ /** @export */
+ emscripten_glFinish: _emscripten_glFinish,
+ /** @export */
+ emscripten_glFlush: _emscripten_glFlush,
+ /** @export */
+ emscripten_glFramebufferRenderbuffer: _emscripten_glFramebufferRenderbuffer,
+ /** @export */
+ emscripten_glFramebufferTexture2D: _emscripten_glFramebufferTexture2D,
+ /** @export */
+ emscripten_glFramebufferTextureLayer: _emscripten_glFramebufferTextureLayer,
+ /** @export */
+ emscripten_glFrontFace: _emscripten_glFrontFace,
+ /** @export */
+ emscripten_glGenBuffers: _emscripten_glGenBuffers,
+ /** @export */
+ emscripten_glGenFramebuffers: _emscripten_glGenFramebuffers,
+ /** @export */
+ emscripten_glGenQueries: _emscripten_glGenQueries,
+ /** @export */
+ emscripten_glGenQueriesEXT: _emscripten_glGenQueriesEXT,
+ /** @export */
+ emscripten_glGenRenderbuffers: _emscripten_glGenRenderbuffers,
+ /** @export */
+ emscripten_glGenSamplers: _emscripten_glGenSamplers,
+ /** @export */
+ emscripten_glGenTextures: _emscripten_glGenTextures,
+ /** @export */
+ emscripten_glGenTransformFeedbacks: _emscripten_glGenTransformFeedbacks,
+ /** @export */
+ emscripten_glGenVertexArrays: _emscripten_glGenVertexArrays,
+ /** @export */
+ emscripten_glGenVertexArraysOES: _emscripten_glGenVertexArraysOES,
+ /** @export */
+ emscripten_glGenerateMipmap: _emscripten_glGenerateMipmap,
+ /** @export */
+ emscripten_glGetActiveAttrib: _emscripten_glGetActiveAttrib,
+ /** @export */
+ emscripten_glGetActiveUniform: _emscripten_glGetActiveUniform,
+ /** @export */
+ emscripten_glGetActiveUniformBlockName: _emscripten_glGetActiveUniformBlockName,
+ /** @export */
+ emscripten_glGetActiveUniformBlockiv: _emscripten_glGetActiveUniformBlockiv,
+ /** @export */
+ emscripten_glGetActiveUniformsiv: _emscripten_glGetActiveUniformsiv,
+ /** @export */
+ emscripten_glGetAttachedShaders: _emscripten_glGetAttachedShaders,
+ /** @export */
+ emscripten_glGetAttribLocation: _emscripten_glGetAttribLocation,
+ /** @export */
+ emscripten_glGetBooleanv: _emscripten_glGetBooleanv,
+ /** @export */
+ emscripten_glGetBufferParameteri64v: _emscripten_glGetBufferParameteri64v,
+ /** @export */
+ emscripten_glGetBufferParameteriv: _emscripten_glGetBufferParameteriv,
+ /** @export */
+ emscripten_glGetError: _emscripten_glGetError,
+ /** @export */
+ emscripten_glGetFloatv: _emscripten_glGetFloatv,
+ /** @export */
+ emscripten_glGetFragDataLocation: _emscripten_glGetFragDataLocation,
+ /** @export */
+ emscripten_glGetFramebufferAttachmentParameteriv: _emscripten_glGetFramebufferAttachmentParameteriv,
+ /** @export */
+ emscripten_glGetInteger64i_v: _emscripten_glGetInteger64i_v,
+ /** @export */
+ emscripten_glGetInteger64v: _emscripten_glGetInteger64v,
+ /** @export */
+ emscripten_glGetIntegeri_v: _emscripten_glGetIntegeri_v,
+ /** @export */
+ emscripten_glGetIntegerv: _emscripten_glGetIntegerv,
+ /** @export */
+ emscripten_glGetInternalformativ: _emscripten_glGetInternalformativ,
+ /** @export */
+ emscripten_glGetProgramBinary: _emscripten_glGetProgramBinary,
+ /** @export */
+ emscripten_glGetProgramInfoLog: _emscripten_glGetProgramInfoLog,
+ /** @export */
+ emscripten_glGetProgramiv: _emscripten_glGetProgramiv,
+ /** @export */
+ emscripten_glGetQueryObjecti64vEXT: _emscripten_glGetQueryObjecti64vEXT,
+ /** @export */
+ emscripten_glGetQueryObjectivEXT: _emscripten_glGetQueryObjectivEXT,
+ /** @export */
+ emscripten_glGetQueryObjectui64vEXT: _emscripten_glGetQueryObjectui64vEXT,
+ /** @export */
+ emscripten_glGetQueryObjectuiv: _emscripten_glGetQueryObjectuiv,
+ /** @export */
+ emscripten_glGetQueryObjectuivEXT: _emscripten_glGetQueryObjectuivEXT,
+ /** @export */
+ emscripten_glGetQueryiv: _emscripten_glGetQueryiv,
+ /** @export */
+ emscripten_glGetQueryivEXT: _emscripten_glGetQueryivEXT,
+ /** @export */
+ emscripten_glGetRenderbufferParameteriv: _emscripten_glGetRenderbufferParameteriv,
+ /** @export */
+ emscripten_glGetSamplerParameterfv: _emscripten_glGetSamplerParameterfv,
+ /** @export */
+ emscripten_glGetSamplerParameteriv: _emscripten_glGetSamplerParameteriv,
+ /** @export */
+ emscripten_glGetShaderInfoLog: _emscripten_glGetShaderInfoLog,
+ /** @export */
+ emscripten_glGetShaderPrecisionFormat: _emscripten_glGetShaderPrecisionFormat,
+ /** @export */
+ emscripten_glGetShaderSource: _emscripten_glGetShaderSource,
+ /** @export */
+ emscripten_glGetShaderiv: _emscripten_glGetShaderiv,
+ /** @export */
+ emscripten_glGetString: _emscripten_glGetString,
+ /** @export */
+ emscripten_glGetStringi: _emscripten_glGetStringi,
+ /** @export */
+ emscripten_glGetSynciv: _emscripten_glGetSynciv,
+ /** @export */
+ emscripten_glGetTexParameterfv: _emscripten_glGetTexParameterfv,
+ /** @export */
+ emscripten_glGetTexParameteriv: _emscripten_glGetTexParameteriv,
+ /** @export */
+ emscripten_glGetTransformFeedbackVarying: _emscripten_glGetTransformFeedbackVarying,
+ /** @export */
+ emscripten_glGetUniformBlockIndex: _emscripten_glGetUniformBlockIndex,
+ /** @export */
+ emscripten_glGetUniformIndices: _emscripten_glGetUniformIndices,
+ /** @export */
+ emscripten_glGetUniformLocation: _emscripten_glGetUniformLocation,
+ /** @export */
+ emscripten_glGetUniformfv: _emscripten_glGetUniformfv,
+ /** @export */
+ emscripten_glGetUniformiv: _emscripten_glGetUniformiv,
+ /** @export */
+ emscripten_glGetUniformuiv: _emscripten_glGetUniformuiv,
+ /** @export */
+ emscripten_glGetVertexAttribIiv: _emscripten_glGetVertexAttribIiv,
+ /** @export */
+ emscripten_glGetVertexAttribIuiv: _emscripten_glGetVertexAttribIuiv,
+ /** @export */
+ emscripten_glGetVertexAttribPointerv: _emscripten_glGetVertexAttribPointerv,
+ /** @export */
+ emscripten_glGetVertexAttribfv: _emscripten_glGetVertexAttribfv,
+ /** @export */
+ emscripten_glGetVertexAttribiv: _emscripten_glGetVertexAttribiv,
+ /** @export */
+ emscripten_glHint: _emscripten_glHint,
+ /** @export */
+ emscripten_glInvalidateFramebuffer: _emscripten_glInvalidateFramebuffer,
+ /** @export */
+ emscripten_glInvalidateSubFramebuffer: _emscripten_glInvalidateSubFramebuffer,
+ /** @export */
+ emscripten_glIsBuffer: _emscripten_glIsBuffer,
+ /** @export */
+ emscripten_glIsEnabled: _emscripten_glIsEnabled,
+ /** @export */
+ emscripten_glIsFramebuffer: _emscripten_glIsFramebuffer,
+ /** @export */
+ emscripten_glIsProgram: _emscripten_glIsProgram,
+ /** @export */
+ emscripten_glIsQuery: _emscripten_glIsQuery,
+ /** @export */
+ emscripten_glIsQueryEXT: _emscripten_glIsQueryEXT,
+ /** @export */
+ emscripten_glIsRenderbuffer: _emscripten_glIsRenderbuffer,
+ /** @export */
+ emscripten_glIsSampler: _emscripten_glIsSampler,
+ /** @export */
+ emscripten_glIsShader: _emscripten_glIsShader,
+ /** @export */
+ emscripten_glIsSync: _emscripten_glIsSync,
+ /** @export */
+ emscripten_glIsTexture: _emscripten_glIsTexture,
+ /** @export */
+ emscripten_glIsTransformFeedback: _emscripten_glIsTransformFeedback,
+ /** @export */
+ emscripten_glIsVertexArray: _emscripten_glIsVertexArray,
+ /** @export */
+ emscripten_glIsVertexArrayOES: _emscripten_glIsVertexArrayOES,
+ /** @export */
+ emscripten_glLineWidth: _emscripten_glLineWidth,
+ /** @export */
+ emscripten_glLinkProgram: _emscripten_glLinkProgram,
+ /** @export */
+ emscripten_glPauseTransformFeedback: _emscripten_glPauseTransformFeedback,
+ /** @export */
+ emscripten_glPixelStorei: _emscripten_glPixelStorei,
+ /** @export */
+ emscripten_glPolygonModeWEBGL: _emscripten_glPolygonModeWEBGL,
+ /** @export */
+ emscripten_glPolygonOffset: _emscripten_glPolygonOffset,
+ /** @export */
+ emscripten_glPolygonOffsetClampEXT: _emscripten_glPolygonOffsetClampEXT,
+ /** @export */
+ emscripten_glProgramBinary: _emscripten_glProgramBinary,
+ /** @export */
+ emscripten_glProgramParameteri: _emscripten_glProgramParameteri,
+ /** @export */
+ emscripten_glQueryCounterEXT: _emscripten_glQueryCounterEXT,
+ /** @export */
+ emscripten_glReadBuffer: _emscripten_glReadBuffer,
+ /** @export */
+ emscripten_glReadPixels: _emscripten_glReadPixels,
+ /** @export */
+ emscripten_glReleaseShaderCompiler: _emscripten_glReleaseShaderCompiler,
+ /** @export */
+ emscripten_glRenderbufferStorage: _emscripten_glRenderbufferStorage,
+ /** @export */
+ emscripten_glRenderbufferStorageMultisample: _emscripten_glRenderbufferStorageMultisample,
+ /** @export */
+ emscripten_glResumeTransformFeedback: _emscripten_glResumeTransformFeedback,
+ /** @export */
+ emscripten_glSampleCoverage: _emscripten_glSampleCoverage,
+ /** @export */
+ emscripten_glSamplerParameterf: _emscripten_glSamplerParameterf,
+ /** @export */
+ emscripten_glSamplerParameterfv: _emscripten_glSamplerParameterfv,
+ /** @export */
+ emscripten_glSamplerParameteri: _emscripten_glSamplerParameteri,
+ /** @export */
+ emscripten_glSamplerParameteriv: _emscripten_glSamplerParameteriv,
+ /** @export */
+ emscripten_glScissor: _emscripten_glScissor,
+ /** @export */
+ emscripten_glShaderBinary: _emscripten_glShaderBinary,
+ /** @export */
+ emscripten_glShaderSource: _emscripten_glShaderSource,
+ /** @export */
+ emscripten_glStencilFunc: _emscripten_glStencilFunc,
+ /** @export */
+ emscripten_glStencilFuncSeparate: _emscripten_glStencilFuncSeparate,
+ /** @export */
+ emscripten_glStencilMask: _emscripten_glStencilMask,
+ /** @export */
+ emscripten_glStencilMaskSeparate: _emscripten_glStencilMaskSeparate,
+ /** @export */
+ emscripten_glStencilOp: _emscripten_glStencilOp,
+ /** @export */
+ emscripten_glStencilOpSeparate: _emscripten_glStencilOpSeparate,
+ /** @export */
+ emscripten_glTexImage2D: _emscripten_glTexImage2D,
+ /** @export */
+ emscripten_glTexImage3D: _emscripten_glTexImage3D,
+ /** @export */
+ emscripten_glTexParameterf: _emscripten_glTexParameterf,
+ /** @export */
+ emscripten_glTexParameterfv: _emscripten_glTexParameterfv,
+ /** @export */
+ emscripten_glTexParameteri: _emscripten_glTexParameteri,
+ /** @export */
+ emscripten_glTexParameteriv: _emscripten_glTexParameteriv,
+ /** @export */
+ emscripten_glTexStorage2D: _emscripten_glTexStorage2D,
+ /** @export */
+ emscripten_glTexStorage3D: _emscripten_glTexStorage3D,
+ /** @export */
+ emscripten_glTexSubImage2D: _emscripten_glTexSubImage2D,
+ /** @export */
+ emscripten_glTexSubImage3D: _emscripten_glTexSubImage3D,
+ /** @export */
+ emscripten_glTransformFeedbackVaryings: _emscripten_glTransformFeedbackVaryings,
+ /** @export */
+ emscripten_glUniform1f: _emscripten_glUniform1f,
+ /** @export */
+ emscripten_glUniform1fv: _emscripten_glUniform1fv,
+ /** @export */
+ emscripten_glUniform1i: _emscripten_glUniform1i,
+ /** @export */
+ emscripten_glUniform1iv: _emscripten_glUniform1iv,
+ /** @export */
+ emscripten_glUniform1ui: _emscripten_glUniform1ui,
+ /** @export */
+ emscripten_glUniform1uiv: _emscripten_glUniform1uiv,
+ /** @export */
+ emscripten_glUniform2f: _emscripten_glUniform2f,
+ /** @export */
+ emscripten_glUniform2fv: _emscripten_glUniform2fv,
+ /** @export */
+ emscripten_glUniform2i: _emscripten_glUniform2i,
+ /** @export */
+ emscripten_glUniform2iv: _emscripten_glUniform2iv,
+ /** @export */
+ emscripten_glUniform2ui: _emscripten_glUniform2ui,
+ /** @export */
+ emscripten_glUniform2uiv: _emscripten_glUniform2uiv,
+ /** @export */
+ emscripten_glUniform3f: _emscripten_glUniform3f,
+ /** @export */
+ emscripten_glUniform3fv: _emscripten_glUniform3fv,
+ /** @export */
+ emscripten_glUniform3i: _emscripten_glUniform3i,
+ /** @export */
+ emscripten_glUniform3iv: _emscripten_glUniform3iv,
+ /** @export */
+ emscripten_glUniform3ui: _emscripten_glUniform3ui,
+ /** @export */
+ emscripten_glUniform3uiv: _emscripten_glUniform3uiv,
+ /** @export */
+ emscripten_glUniform4f: _emscripten_glUniform4f,
+ /** @export */
+ emscripten_glUniform4fv: _emscripten_glUniform4fv,
+ /** @export */
+ emscripten_glUniform4i: _emscripten_glUniform4i,
+ /** @export */
+ emscripten_glUniform4iv: _emscripten_glUniform4iv,
+ /** @export */
+ emscripten_glUniform4ui: _emscripten_glUniform4ui,
+ /** @export */
+ emscripten_glUniform4uiv: _emscripten_glUniform4uiv,
+ /** @export */
+ emscripten_glUniformBlockBinding: _emscripten_glUniformBlockBinding,
+ /** @export */
+ emscripten_glUniformMatrix2fv: _emscripten_glUniformMatrix2fv,
+ /** @export */
+ emscripten_glUniformMatrix2x3fv: _emscripten_glUniformMatrix2x3fv,
+ /** @export */
+ emscripten_glUniformMatrix2x4fv: _emscripten_glUniformMatrix2x4fv,
+ /** @export */
+ emscripten_glUniformMatrix3fv: _emscripten_glUniformMatrix3fv,
+ /** @export */
+ emscripten_glUniformMatrix3x2fv: _emscripten_glUniformMatrix3x2fv,
+ /** @export */
+ emscripten_glUniformMatrix3x4fv: _emscripten_glUniformMatrix3x4fv,
+ /** @export */
+ emscripten_glUniformMatrix4fv: _emscripten_glUniformMatrix4fv,
+ /** @export */
+ emscripten_glUniformMatrix4x2fv: _emscripten_glUniformMatrix4x2fv,
+ /** @export */
+ emscripten_glUniformMatrix4x3fv: _emscripten_glUniformMatrix4x3fv,
+ /** @export */
+ emscripten_glUseProgram: _emscripten_glUseProgram,
+ /** @export */
+ emscripten_glValidateProgram: _emscripten_glValidateProgram,
+ /** @export */
+ emscripten_glVertexAttrib1f: _emscripten_glVertexAttrib1f,
+ /** @export */
+ emscripten_glVertexAttrib1fv: _emscripten_glVertexAttrib1fv,
+ /** @export */
+ emscripten_glVertexAttrib2f: _emscripten_glVertexAttrib2f,
+ /** @export */
+ emscripten_glVertexAttrib2fv: _emscripten_glVertexAttrib2fv,
+ /** @export */
+ emscripten_glVertexAttrib3f: _emscripten_glVertexAttrib3f,
+ /** @export */
+ emscripten_glVertexAttrib3fv: _emscripten_glVertexAttrib3fv,
+ /** @export */
+ emscripten_glVertexAttrib4f: _emscripten_glVertexAttrib4f,
+ /** @export */
+ emscripten_glVertexAttrib4fv: _emscripten_glVertexAttrib4fv,
+ /** @export */
+ emscripten_glVertexAttribDivisor: _emscripten_glVertexAttribDivisor,
+ /** @export */
+ emscripten_glVertexAttribDivisorANGLE: _emscripten_glVertexAttribDivisorANGLE,
+ /** @export */
+ emscripten_glVertexAttribDivisorARB: _emscripten_glVertexAttribDivisorARB,
+ /** @export */
+ emscripten_glVertexAttribDivisorEXT: _emscripten_glVertexAttribDivisorEXT,
+ /** @export */
+ emscripten_glVertexAttribDivisorNV: _emscripten_glVertexAttribDivisorNV,
+ /** @export */
+ emscripten_glVertexAttribI4i: _emscripten_glVertexAttribI4i,
+ /** @export */
+ emscripten_glVertexAttribI4iv: _emscripten_glVertexAttribI4iv,
+ /** @export */
+ emscripten_glVertexAttribI4ui: _emscripten_glVertexAttribI4ui,
+ /** @export */
+ emscripten_glVertexAttribI4uiv: _emscripten_glVertexAttribI4uiv,
+ /** @export */
+ emscripten_glVertexAttribIPointer: _emscripten_glVertexAttribIPointer,
+ /** @export */
+ emscripten_glVertexAttribPointer: _emscripten_glVertexAttribPointer,
+ /** @export */
+ emscripten_glViewport: _emscripten_glViewport,
+ /** @export */
+ emscripten_glWaitSync: _emscripten_glWaitSync,
+ /** @export */
+ emscripten_resize_heap: _emscripten_resize_heap,
+ /** @export */
+ emscripten_sample_gamepad_data: _emscripten_sample_gamepad_data,
+ /** @export */
+ emscripten_set_canvas_element_size: _emscripten_set_canvas_element_size,
+ /** @export */
+ emscripten_set_click_callback_on_thread: _emscripten_set_click_callback_on_thread,
+ /** @export */
+ emscripten_set_fullscreenchange_callback_on_thread: _emscripten_set_fullscreenchange_callback_on_thread,
+ /** @export */
+ emscripten_set_gamepadconnected_callback_on_thread: _emscripten_set_gamepadconnected_callback_on_thread,
+ /** @export */
+ emscripten_set_gamepaddisconnected_callback_on_thread: _emscripten_set_gamepaddisconnected_callback_on_thread,
+ /** @export */
+ emscripten_set_resize_callback_on_thread: _emscripten_set_resize_callback_on_thread,
+ /** @export */
+ emscripten_set_touchcancel_callback_on_thread: _emscripten_set_touchcancel_callback_on_thread,
+ /** @export */
+ emscripten_set_touchend_callback_on_thread: _emscripten_set_touchend_callback_on_thread,
+ /** @export */
+ emscripten_set_touchmove_callback_on_thread: _emscripten_set_touchmove_callback_on_thread,
+ /** @export */
+ emscripten_set_touchstart_callback_on_thread: _emscripten_set_touchstart_callback_on_thread,
+ /** @export */
+ emscripten_set_window_title: _emscripten_set_window_title,
+ /** @export */
+ emscripten_sleep: _emscripten_sleep,
+ /** @export */
+ exit: _exit,
+ /** @export */
+ fd_close: _fd_close,
+ /** @export */
+ fd_read: _fd_read,
+ /** @export */
+ fd_seek: _fd_seek,
+ /** @export */
+ fd_write: _fd_write,
+ /** @export */
+ glActiveTexture: _glActiveTexture,
+ /** @export */
+ glAttachShader: _glAttachShader,
+ /** @export */
+ glBindAttribLocation: _glBindAttribLocation,
+ /** @export */
+ glBindBuffer: _glBindBuffer,
+ /** @export */
+ glBindTexture: _glBindTexture,
+ /** @export */
+ glBlendEquation: _glBlendEquation,
+ /** @export */
+ glBlendEquationSeparate: _glBlendEquationSeparate,
+ /** @export */
+ glBlendFunc: _glBlendFunc,
+ /** @export */
+ glBlendFuncSeparate: _glBlendFuncSeparate,
+ /** @export */
+ glBufferData: _glBufferData,
+ /** @export */
+ glBufferSubData: _glBufferSubData,
+ /** @export */
+ glClear: _glClear,
+ /** @export */
+ glClearColor: _glClearColor,
+ /** @export */
+ glClearDepthf: _glClearDepthf,
+ /** @export */
+ glCompileShader: _glCompileShader,
+ /** @export */
+ glCompressedTexImage2D: _glCompressedTexImage2D,
+ /** @export */
+ glCreateProgram: _glCreateProgram,
+ /** @export */
+ glCreateShader: _glCreateShader,
+ /** @export */
+ glCullFace: _glCullFace,
+ /** @export */
+ glDeleteBuffers: _glDeleteBuffers,
+ /** @export */
+ glDeleteProgram: _glDeleteProgram,
+ /** @export */
+ glDeleteShader: _glDeleteShader,
+ /** @export */
+ glDeleteTextures: _glDeleteTextures,
+ /** @export */
+ glDepthFunc: _glDepthFunc,
+ /** @export */
+ glDetachShader: _glDetachShader,
+ /** @export */
+ glDisable: _glDisable,
+ /** @export */
+ glDisableVertexAttribArray: _glDisableVertexAttribArray,
+ /** @export */
+ glDrawArrays: _glDrawArrays,
+ /** @export */
+ glDrawElements: _glDrawElements,
+ /** @export */
+ glEnable: _glEnable,
+ /** @export */
+ glEnableVertexAttribArray: _glEnableVertexAttribArray,
+ /** @export */
+ glFrontFace: _glFrontFace,
+ /** @export */
+ glGenBuffers: _glGenBuffers,
+ /** @export */
+ glGenTextures: _glGenTextures,
+ /** @export */
+ glGetAttribLocation: _glGetAttribLocation,
+ /** @export */
+ glGetFloatv: _glGetFloatv,
+ /** @export */
+ glGetProgramInfoLog: _glGetProgramInfoLog,
+ /** @export */
+ glGetProgramiv: _glGetProgramiv,
+ /** @export */
+ glGetShaderInfoLog: _glGetShaderInfoLog,
+ /** @export */
+ glGetShaderiv: _glGetShaderiv,
+ /** @export */
+ glGetString: _glGetString,
+ /** @export */
+ glGetUniformLocation: _glGetUniformLocation,
+ /** @export */
+ glLinkProgram: _glLinkProgram,
+ /** @export */
+ glPixelStorei: _glPixelStorei,
+ /** @export */
+ glReadPixels: _glReadPixels,
+ /** @export */
+ glScissor: _glScissor,
+ /** @export */
+ glShaderSource: _glShaderSource,
+ /** @export */
+ glTexImage2D: _glTexImage2D,
+ /** @export */
+ glTexParameterf: _glTexParameterf,
+ /** @export */
+ glTexParameteri: _glTexParameteri,
+ /** @export */
+ glUniform1i: _glUniform1i,
+ /** @export */
+ glUniform4f: _glUniform4f,
+ /** @export */
+ glUniformMatrix4fv: _glUniformMatrix4fv,
+ /** @export */
+ glUseProgram: _glUseProgram,
+ /** @export */
+ glVertexAttribPointer: _glVertexAttribPointer,
+ /** @export */
+ glViewport: _glViewport,
+ /** @export */
+ glfwCreateWindow: _glfwCreateWindow,
+ /** @export */
+ glfwDefaultWindowHints: _glfwDefaultWindowHints,
+ /** @export */
+ glfwDestroyWindow: _glfwDestroyWindow,
+ /** @export */
+ glfwGetPrimaryMonitor: _glfwGetPrimaryMonitor,
+ /** @export */
+ glfwGetTime: _glfwGetTime,
+ /** @export */
+ glfwGetVideoModes: _glfwGetVideoModes,
+ /** @export */
+ glfwInit: _glfwInit,
+ /** @export */
+ glfwMakeContextCurrent: _glfwMakeContextCurrent,
+ /** @export */
+ glfwSetCharCallback: _glfwSetCharCallback,
+ /** @export */
+ glfwSetCursorEnterCallback: _glfwSetCursorEnterCallback,
+ /** @export */
+ glfwSetCursorPosCallback: _glfwSetCursorPosCallback,
+ /** @export */
+ glfwSetDropCallback: _glfwSetDropCallback,
+ /** @export */
+ glfwSetErrorCallback: _glfwSetErrorCallback,
+ /** @export */
+ glfwSetKeyCallback: _glfwSetKeyCallback,
+ /** @export */
+ glfwSetMouseButtonCallback: _glfwSetMouseButtonCallback,
+ /** @export */
+ glfwSetScrollCallback: _glfwSetScrollCallback,
+ /** @export */
+ glfwSetWindowFocusCallback: _glfwSetWindowFocusCallback,
+ /** @export */
+ glfwSetWindowIconifyCallback: _glfwSetWindowIconifyCallback,
+ /** @export */
+ glfwSetWindowShouldClose: _glfwSetWindowShouldClose,
+ /** @export */
+ glfwSetWindowSizeCallback: _glfwSetWindowSizeCallback,
+ /** @export */
+ glfwSwapBuffers: _glfwSwapBuffers,
+ /** @export */
+ glfwTerminate: _glfwTerminate,
+ /** @export */
+ glfwWindowHint: _glfwWindowHint
+};
+var wasmExports = createWasm();
+var ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors', 0);
+var _free = createExportWrapper('free', 1);
+var _malloc = createExportWrapper('malloc', 1);
+var _main = Module['_main'] = createExportWrapper('main', 2);
+var _fflush = createExportWrapper('fflush', 1);
+var _strerror = createExportWrapper('strerror', 1);
+var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports['emscripten_stack_init'])();
+var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])();
+var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])();
+var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])();
+var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports['_emscripten_stack_restore'])(a0);
+var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'])(a0);
+var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'])();
+var ___set_stack_limits = Module['___set_stack_limits'] = createExportWrapper('__set_stack_limits', 2);
+var dynCall_vii = Module['dynCall_vii'] = createExportWrapper('dynCall_vii', 3);
+var dynCall_viii = Module['dynCall_viii'] = createExportWrapper('dynCall_viii', 4);
+var dynCall_viiiii = Module['dynCall_viiiii'] = createExportWrapper('dynCall_viiiii', 6);
+var dynCall_viiii = Module['dynCall_viiii'] = createExportWrapper('dynCall_viiii', 5);
+var dynCall_vidd = Module['dynCall_vidd'] = createExportWrapper('dynCall_vidd', 4);
+var dynCall_ii = Module['dynCall_ii'] = createExportWrapper('dynCall_ii', 2);
+var dynCall_iiii = Module['dynCall_iiii'] = createExportWrapper('dynCall_iiii', 4);
+var dynCall_vi = Module['dynCall_vi'] = createExportWrapper('dynCall_vi', 2);
+var dynCall_vffff = Module['dynCall_vffff'] = createExportWrapper('dynCall_vffff', 5);
+var dynCall_vf = Module['dynCall_vf'] = createExportWrapper('dynCall_vf', 2);
+var dynCall_viiiiiiii = Module['dynCall_viiiiiiii'] = createExportWrapper('dynCall_viiiiiiii', 9);
+var dynCall_viiiiiiiii = Module['dynCall_viiiiiiiii'] = createExportWrapper('dynCall_viiiiiiiii', 10);
+var dynCall_i = Module['dynCall_i'] = createExportWrapper('dynCall_i', 1);
+var dynCall_vff = Module['dynCall_vff'] = createExportWrapper('dynCall_vff', 3);
+var dynCall_v = Module['dynCall_v'] = createExportWrapper('dynCall_v', 1);
+var dynCall_viiiiiii = Module['dynCall_viiiiiii'] = createExportWrapper('dynCall_viiiiiii', 8);
+var dynCall_iii = Module['dynCall_iii'] = createExportWrapper('dynCall_iii', 3);
+var dynCall_vfi = Module['dynCall_vfi'] = createExportWrapper('dynCall_vfi', 3);
+var dynCall_viif = Module['dynCall_viif'] = createExportWrapper('dynCall_viif', 4);
+var dynCall_vif = Module['dynCall_vif'] = createExportWrapper('dynCall_vif', 3);
+var dynCall_viff = Module['dynCall_viff'] = createExportWrapper('dynCall_viff', 4);
+var dynCall_vifff = Module['dynCall_vifff'] = createExportWrapper('dynCall_vifff', 5);
+var dynCall_viffff = Module['dynCall_viffff'] = createExportWrapper('dynCall_viffff', 6);
+var dynCall_viiiiii = Module['dynCall_viiiiii'] = createExportWrapper('dynCall_viiiiii', 7);
+var dynCall_vfff = Module['dynCall_vfff'] = createExportWrapper('dynCall_vfff', 4);
+var dynCall_viiiiiiiiii = Module['dynCall_viiiiiiiiii'] = createExportWrapper('dynCall_viiiiiiiiii', 11);
+var dynCall_viiiiiiiiiii = Module['dynCall_viiiiiiiiiii'] = createExportWrapper('dynCall_viiiiiiiiiii', 12);
+var dynCall_viifi = Module['dynCall_viifi'] = createExportWrapper('dynCall_viifi', 5);
+var dynCall_iiiii = Module['dynCall_iiiii'] = createExportWrapper('dynCall_iiiii', 5);
+var dynCall_jiji = Module['dynCall_jiji'] = createExportWrapper('dynCall_jiji', 5);
+var dynCall_iidiiii = Module['dynCall_iidiiii'] = createExportWrapper('dynCall_iidiiii', 7);
+var _asyncify_start_unwind = createExportWrapper('asyncify_start_unwind', 1);
+var _asyncify_stop_unwind = createExportWrapper('asyncify_stop_unwind', 0);
+var _asyncify_start_rewind = createExportWrapper('asyncify_start_rewind', 1);
+var _asyncify_stop_rewind = createExportWrapper('asyncify_stop_rewind', 0);
+
+
+// include: postamble.js
+// === Auto-generated postamble setup entry stuff ===
+
+Module['addRunDependency'] = addRunDependency;
+Module['removeRunDependency'] = removeRunDependency;
+Module['FS_createPreloadedFile'] = FS_createPreloadedFile;
+Module['FS_unlink'] = FS_unlink;
+Module['FS_createPath'] = FS_createPath;
+Module['FS_createDevice'] = FS_createDevice;
+Module['FS_createDataFile'] = FS_createDataFile;
+Module['FS_createLazyFile'] = FS_createLazyFile;
+var missingLibrarySymbols = [
+ 'writeI53ToI64Clamped',
+ 'writeI53ToI64Signaling',
+ 'writeI53ToU64Clamped',
+ 'writeI53ToU64Signaling',
+ 'convertU32PairToI53',
+ 'stackAlloc',
+ 'getTempRet0',
+ 'setTempRet0',
+ 'growMemory',
+ 'inetPton4',
+ 'inetNtop4',
+ 'inetPton6',
+ 'inetNtop6',
+ 'readSockaddr',
+ 'writeSockaddr',
+ 'emscriptenLog',
+ 'readEmAsmArgs',
+ 'getExecutableName',
+ 'listenOnce',
+ 'autoResumeAudioContext',
+ 'dynCallLegacy',
+ 'getDynCaller',
+ 'dynCall',
+ 'setWasmTableEntry',
+ 'getWasmTableEntry',
+ 'asmjsMangle',
+ 'HandleAllocator',
+ 'getNativeTypeSize',
+ 'STACK_SIZE',
+ 'STACK_ALIGN',
+ 'POINTER_SIZE',
+ 'ASSERTIONS',
+ 'getCFunc',
+ 'ccall',
+ 'cwrap',
+ 'uleb128Encode',
+ 'generateFuncType',
+ 'convertJsFunctionToWasm',
+ 'getEmptyTableSlot',
+ 'updateTableMap',
+ 'getFunctionAddress',
+ 'addFunction',
+ 'removeFunction',
+ 'reallyNegative',
+ 'unSign',
+ 'strLen',
+ 'reSign',
+ 'formatString',
+ 'intArrayToString',
+ 'AsciiToString',
+ 'stringToAscii',
+ 'UTF16ToString',
+ 'stringToUTF16',
+ 'lengthBytesUTF16',
+ 'UTF32ToString',
+ 'stringToUTF32',
+ 'lengthBytesUTF32',
+ 'stringToUTF8OnStack',
+ 'writeArrayToMemory',
+ 'registerKeyEventCallback',
+ 'registerWheelEventCallback',
+ 'registerFocusEventCallback',
+ 'fillDeviceOrientationEventData',
+ 'registerDeviceOrientationEventCallback',
+ 'fillDeviceMotionEventData',
+ 'registerDeviceMotionEventCallback',
+ 'screenOrientation',
+ 'fillOrientationChangeEventData',
+ 'registerOrientationChangeEventCallback',
+ 'JSEvents_requestFullscreen',
+ 'JSEvents_resizeCanvasForFullscreen',
+ 'registerRestoreOldStyle',
+ 'hideEverythingExceptGivenElement',
+ 'restoreHiddenElements',
+ 'setLetterbox',
+ 'softFullscreenResizeWebGLRenderTarget',
+ 'doRequestFullscreen',
+ 'fillPointerlockChangeEventData',
+ 'registerPointerlockChangeEventCallback',
+ 'registerPointerlockErrorEventCallback',
+ 'requestPointerLock',
+ 'fillVisibilityChangeEventData',
+ 'registerVisibilityChangeEventCallback',
+ 'registerBeforeUnloadEventCallback',
+ 'fillBatteryEventData',
+ 'battery',
+ 'registerBatteryEventCallback',
+ 'setCanvasElementSize',
+ 'getCanvasElementSize',
+ 'jsStackTrace',
+ 'getCallstack',
+ 'convertPCtoSourceLocation',
+ 'getEnvStrings',
+ 'checkWasiClock',
+ 'wasiRightsToMuslOFlags',
+ 'wasiOFlagsToMuslOFlags',
+ 'setImmediateWrapped',
+ 'safeRequestAnimationFrame',
+ 'clearImmediateWrapped',
+ 'polyfillSetImmediate',
+ 'registerPostMainLoop',
+ 'registerPreMainLoop',
+ 'getPromise',
+ 'makePromise',
+ 'idsToPromises',
+ 'makePromiseCallback',
+ 'ExceptionInfo',
+ 'findMatchingCatch',
+ 'Browser_asyncPrepareDataCounter',
+ 'isLeapYear',
+ 'ydayFromDate',
+ 'arraySum',
+ 'addDays',
+ 'getSocketFromFD',
+ 'getSocketAddress',
+ 'FS_mkdirTree',
+ '_setNetworkCallback',
+ 'writeGLArray',
+ 'registerWebGlEventCallback',
+ 'ALLOC_NORMAL',
+ 'ALLOC_STACK',
+ 'allocate',
+ 'writeStringToMemory',
+ 'writeAsciiToMemory',
+ 'setErrNo',
+ 'demangle',
+ 'stackTrace',
+];
+missingLibrarySymbols.forEach(missingLibrarySymbol)
+
+var unexportedSymbols = [
+ 'run',
+ 'addOnPreRun',
+ 'addOnInit',
+ 'addOnPreMain',
+ 'addOnExit',
+ 'addOnPostRun',
+ 'out',
+ 'err',
+ 'callMain',
+ 'abort',
+ 'wasmMemory',
+ 'wasmExports',
+ 'writeStackCookie',
+ 'checkStackCookie',
+ 'writeI53ToI64',
+ 'readI53FromI64',
+ 'readI53FromU64',
+ 'convertI32PairToI53',
+ 'convertI32PairToI53Checked',
+ 'stackSave',
+ 'stackRestore',
+ 'ptrToString',
+ 'zeroMemory',
+ 'exitJS',
+ 'getHeapMax',
+ 'abortOnCannotGrowMemory',
+ 'ENV',
+ 'setStackLimits',
+ 'ERRNO_CODES',
+ 'strError',
+ 'DNS',
+ 'Protocols',
+ 'Sockets',
+ 'timers',
+ 'warnOnce',
+ 'readEmAsmArgsArray',
+ 'jstoi_q',
+ 'jstoi_s',
+ 'handleException',
+ 'keepRuntimeAlive',
+ 'runtimeKeepalivePush',
+ 'runtimeKeepalivePop',
+ 'callUserCallback',
+ 'maybeExit',
+ 'asyncLoad',
+ 'alignMemory',
+ 'mmapAlloc',
+ 'wasmTable',
+ 'noExitRuntime',
+ 'sigToWasmTypes',
+ 'freeTableIndexes',
+ 'functionsInTableMap',
+ 'setValue',
+ 'getValue',
+ 'PATH',
+ 'PATH_FS',
+ 'UTF8Decoder',
+ 'UTF8ArrayToString',
+ 'UTF8ToString',
+ 'stringToUTF8Array',
+ 'stringToUTF8',
+ 'lengthBytesUTF8',
+ 'intArrayFromString',
+ 'UTF16Decoder',
+ 'stringToNewUTF8',
+ 'JSEvents',
+ 'specialHTMLTargets',
+ 'maybeCStringToJsString',
+ 'findEventTarget',
+ 'findCanvasEventTarget',
+ 'getBoundingClientRect',
+ 'fillMouseEventData',
+ 'registerMouseEventCallback',
+ 'registerUiEventCallback',
+ 'fillFullscreenChangeEventData',
+ 'registerFullscreenChangeEventCallback',
+ 'currentFullscreenStrategy',
+ 'restoreOldWindowedStyle',
+ 'registerTouchEventCallback',
+ 'fillGamepadEventData',
+ 'registerGamepadEventCallback',
+ 'UNWIND_CACHE',
+ 'ExitStatus',
+ 'doReadv',
+ 'doWritev',
+ 'initRandomFill',
+ 'randomFill',
+ 'safeSetTimeout',
+ 'promiseMap',
+ 'uncaughtExceptionCount',
+ 'exceptionLast',
+ 'exceptionCaught',
+ 'Browser',
+ 'getPreloadedImageData__data',
+ 'wget',
+ 'MONTH_DAYS_REGULAR',
+ 'MONTH_DAYS_LEAP',
+ 'MONTH_DAYS_REGULAR_CUMULATIVE',
+ 'MONTH_DAYS_LEAP_CUMULATIVE',
+ 'SYSCALLS',
+ 'preloadPlugins',
+ 'FS_modeStringToFlags',
+ 'FS_getMode',
+ 'FS_stdin_getChar_buffer',
+ 'FS_stdin_getChar',
+ 'FS_readFile',
+ 'FS',
+ 'MEMFS',
+ 'TTY',
+ 'PIPEFS',
+ 'SOCKFS',
+ 'tempFixedLengthArray',
+ 'miniTempWebGLFloatBuffers',
+ 'miniTempWebGLIntBuffers',
+ 'heapObjectForWebGLType',
+ 'toTypedArrayIndex',
+ 'webgl_enable_ANGLE_instanced_arrays',
+ 'webgl_enable_OES_vertex_array_object',
+ 'webgl_enable_WEBGL_draw_buffers',
+ 'webgl_enable_WEBGL_multi_draw',
+ 'webgl_enable_EXT_polygon_offset_clamp',
+ 'webgl_enable_EXT_clip_control',
+ 'webgl_enable_WEBGL_polygon_mode',
+ 'GL',
+ 'emscriptenWebGLGet',
+ 'computeUnpackAlignedImageSize',
+ 'colorChannelsInGlTextureFormat',
+ 'emscriptenWebGLGetTexPixelData',
+ 'emscriptenWebGLGetUniform',
+ 'webglGetUniformLocation',
+ 'webglPrepareUniformLocationsBeforeFirstUse',
+ 'webglGetLeftBracePos',
+ 'emscriptenWebGLGetVertexAttrib',
+ '__glGetActiveAttribOrUniform',
+ 'AL',
+ 'GLUT',
+ 'EGL',
+ 'GLEW',
+ 'IDBStore',
+ 'runAndAbortIfError',
+ 'Asyncify',
+ 'Fibers',
+ 'SDL',
+ 'SDL_gfx',
+ 'GLFW_Window',
+ 'GLFW',
+ 'emscriptenWebGLGetIndexed',
+ 'webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance',
+ 'webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance',
+ 'allocateUTF8',
+ 'allocateUTF8OnStack',
+ 'print',
+ 'printErr',
+];
+unexportedSymbols.forEach(unexportedRuntimeSymbol);
+
+
+
+var calledRun;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!calledRun) run();
+ if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+};
+
+function callMain() {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ var entryFunction = _main;
+
+ var argc = 0;
+ var argv = 0;
+
+ try {
+
+ var ret = entryFunction(argc, argv);
+
+ // if we're not running an evented main loop, it's time to exit
+ exitJS(ret, /* implicit = */ true);
+ return ret;
+ }
+ catch (e) {
+ return handleException(e);
+ }
+}
+
+function stackCheckInit() {
+ // This is normally called automatically during __wasm_call_ctors but need to
+ // get these values before even running any of the ctors so we call it redundantly
+ // here.
+ _emscripten_stack_init();
+ // TODO(sbc): Move writeStackCookie to native to to avoid this.
+ writeStackCookie();
+}
+
+function run() {
+
+ if (runDependencies > 0) {
+ return;
+ }
+
+ stackCheckInit();
+
+ preRun();
+
+ // a preRun added a dependency, run will be called later
+ if (runDependencies > 0) {
+ return;
+ }
+
+ function doRun() {
+ // run may have just been called through dependencies being fulfilled just in this very frame,
+ // or while the async setStatus time below was happening
+ if (calledRun) return;
+ calledRun = true;
+ Module['calledRun'] = true;
+
+ if (ABORT) return;
+
+ initRuntime();
+
+ preMain();
+
+ Module['onRuntimeInitialized']?.();
+
+ if (shouldRunNow) callMain();
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(() => {
+ setTimeout(() => Module['setStatus'](''), 1);
+ doRun();
+ }, 1);
+ } else
+ {
+ doRun();
+ }
+ checkStackCookie();
+}
+
+function checkUnflushedContent() {
+ // Compiler settings do not allow exiting the runtime, so flushing
+ // the streams is not possible. but in ASSERTIONS mode we check
+ // if there was something to flush, and if so tell the user they
+ // should request that the runtime be exitable.
+ // Normally we would not even include flush() at all, but in ASSERTIONS
+ // builds we do so just for this check, and here we see if there is any
+ // content to flush, that is, we check if there would have been
+ // something a non-ASSERTIONS build would have not seen.
+ // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
+ // mode (which has its own special function for this; otherwise, all
+ // the code is inside libc)
+ var oldOut = out;
+ var oldErr = err;
+ var has = false;
+ out = err = (x) => {
+ has = true;
+ }
+ try { // it doesn't matter if it fails
+ _fflush(0);
+ // also flush in the JS FS layer
+ ['stdout', 'stderr'].forEach((name) => {
+ var info = FS.analyzePath('/dev/' + name);
+ if (!info) return;
+ var stream = info.object;
+ var rdev = stream.rdev;
+ var tty = TTY.ttys[rdev];
+ if (tty?.output?.length) {
+ has = true;
+ }
+ });
+ } catch(e) {}
+ out = oldOut;
+ err = oldErr;
+ if (has) {
+ warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.');
+ }
+}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+
+if (Module['noInitialRun']) shouldRunNow = false;
+
+run();
+
+// end include: postamble.js
+
diff --git a/docs/assets/enduro/game.wasm b/docs/assets/enduro/game.wasm
new file mode 100755
index 0000000..2d9676b
Binary files /dev/null and b/docs/assets/enduro/game.wasm differ
diff --git a/docs/assets/enduro/game.wasm.map b/docs/assets/enduro/game.wasm.map
new file mode 100644
index 0000000..36be565
--- /dev/null
+++ b/docs/assets/enduro/game.wasm.map
@@ -0,0 +1 @@
+{"version":3,"sources":["../../pufferlib/ocean/enduro/enduro.h","../../pufferlib/puffernet.h","../../pufferlib/ocean/enduro/enduro.c","../../../../emsdk/emscripten/system/lib/gl/gl.c","../../../../emsdk/emscripten/system/lib/gl/libprocaddr.c","../../../../emsdk/emscripten/system/lib/gl/webgl1.c","../../../../emsdk/emscripten/system/lib/gl/webgl2.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/access.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/acosf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/atan2f.c","../../../../emsdk/emscripten/system/lib/libc/musl/include/math.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/atanf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/close.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__rem_pio2_large.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__cosdf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__sindf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__rem_pio2f.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/cosf.c","../../../../emsdk/emscripten/system/lib/libc/emscripten_memcpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memmove.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memset.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/errno/__errno_location.c","../../../../emsdk/emscripten/system/lib/libc/emscripten_time.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_xflowf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/libm.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_oflowf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_uflowf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/expf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fabsf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__lockfile.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fclose.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ferror.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fflush.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__toread.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/floor.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fmax.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fmaxf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fminf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fmod.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fmodf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__fmodeflags.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_seek.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_write.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_read.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_close.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__fdopen.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fopen.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fread.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/frexp.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fseek.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ftell.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__towrite.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fwrite.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/getcwd.c","../../../../emsdk/emscripten/system/lib/pthread/library_pthread_stub.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_invalid.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_invalidf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/lseek.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memchr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memcmp.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/time/clock_nanosleep.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/time/nanosleep.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ofl.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ofl_add.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__overflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fputc.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/putc.h","../../../../emsdk/emscripten/cache/sysroot/include/atomic_arch.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/pthread_impl.h","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/perror.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_xflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_oflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_uflow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/fabs.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/pow.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/powf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/printf.c","../../../../emsdk/emscripten/system/lib/libc/emscripten_syscall_stubs.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/getpid.c","../../../../emsdk/emscripten/system/lib/pthread/pthread_self_stub.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/prng/rand.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/prng/rand_r.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/rewind.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/roundf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/scalbn.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/sinf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/snprintf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/sqrtf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/stdout.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strchr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strchrnul.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcmp.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/stpcpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strdup.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/errno/strerror.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strlen.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/stpncpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strncpy.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcspn.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strpbrk.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memrchr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strrchr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strstr.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/syscall_ret.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/expm1.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/math/tanh.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strnlen.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vfprintf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vprintf.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vsnprintf.c","../../../../emsdk/emscripten/system/lib/libc/wasi-helpers.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/wcrtomb.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/wctomb.c","../../../../emsdk/emscripten/system/lib/libc/musl/src/exit/abort.c","../../../../emsdk/emscripten/system/lib/dlmalloc.c","../../../../emsdk/emscripten/system/lib/libc/emscripten_get_heap_size.c","../../../../emsdk/emscripten/system/lib/libc/sbrk.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/ashlti3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/lshrti3.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/trunctfdf2.c","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc.h","../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc_impl.inc","../../../../b/s/w/ir/x/w/install/emscripten/system/lib/compiler-rt/emscripten_tempret.s","../../../../emsdk/emscripten/system/lib/compiler-rt/stack_limits.S","../../../../emsdk/emscripten/system/lib/compiler-rt/stack_ops.S"],"names":[],"mappings":"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GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EAGA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,G,GAYA,S,UAAA,G,GACA,S,UAAA,GAIF,KAHE,S,SAAA,EF3iBI,I,IAAY,EEsVhB,M,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EAGA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,Q,UAAA,G,EACA,S,UAAA,G,EACA,S,UAAA,GAeF,EAdE,U,SAAA,EFpWI,I,KAAY,EGhFhB,M,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GAKA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GAKA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,Q,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,EACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA,G,EACA,S,UAAA,G,GACA,S,UAAA,G,GACA,S,UAAA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"}
\ No newline at end of file
diff --git a/docs/assets/enduro_thumbnail.png b/docs/assets/enduro_thumbnail.png
new file mode 100644
index 0000000..8f23bff
Binary files /dev/null and b/docs/assets/enduro_thumbnail.png differ
diff --git a/docs/games.js b/docs/games.js
index 096aa4a..08e3b01 100644
--- a/docs/games.js
+++ b/docs/games.js
@@ -55,6 +55,14 @@ const games = {
width: 576,
height: 330,
},
+ enduro: {
+ title: "Enduro",
+ description: "A fast version of the classic Atari game. By Bet. A/D to steer, space to accelerate.",
+ thumbnail: "assets/enduro_thumbnail.png",
+ path: "assets/enduro/game.html",
+ width: 160,
+ height: 210,
+ },
connect4: {
title: "Connect4",
description: "The classic two-player board game. By Spencer, AI enhanced by Jake. Num keys to play in col.",
diff --git a/docs/index.html b/docs/index.html
index 2a41f4d..25e5b10 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -162,6 +162,10 @@
David Bloomin
CARBS integration improvements, 0.4 policy pool/store/selector
+
+ Black Ink South
+ Character art for MOBA
+
Nick Jenkins
Layout for the system architecture diagram. Adversary.design
diff --git a/docs/main.js b/docs/main.js
index 3e87d85..60f5c68 100644
--- a/docs/main.js
+++ b/docs/main.js
@@ -43,7 +43,6 @@ function loadGame(game) {
containerVisible: container.offsetParent !== null
});
-
featured.src = game.path;
document.querySelector('.game-info .game-title').textContent = game.title;
document.querySelector('.game-description').textContent = game.description;