/**

* @license

* Copyright 2011 The Emscripten Authors

* SPDX-License-Identifier: MIT

*/

// Utilities for browser environments

var LibraryBrowser = {

$Browser__deps: ['$setMainLoop', 'emscripten_set_main_loop_timing'],

$Browser__postset: 'Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas) { Browser.requestFullscreen(lockPointer, resizeCanvas) };\n' + // exports

#if ASSERTIONS

'Module["requestFullScreen"] = function Module_requestFullScreen() { Browser.requestFullScreen() };\n' +

#endif

'Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };\n' +

'Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };\n' +

'Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };\n' +

'Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };\n' +

'Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }\n' +

'Module["createContext"] = function Module_createContext(canvas, useWebGL, setInModule, webGLContextAttributes) { return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes) }',

$Browser: {

mainLoop: {

scheduler: null,

method: '',

// Each main loop is numbered with a ID in sequence order. Only one main loop can run at a time. This variable stores the ordinal number of the main loop that is currently

// allowed to run. All previous main loops will quit themselves. This is incremented whenever a new main loop is created.

/** @type{number} */

currentlyRunningMainloop: 0,

func: null, // The main loop tick function that will be called at each iteration.

arg: 0, // The argument that will be passed to the main loop. (of type void*)

timingMode: 0,

timingValue: 0,

currentFrameNumber: 0,

queue: [],

pause: function() {

Browser.mainLoop.scheduler = null;

Browser.mainLoop.currentlyRunningMainloop++; // Incrementing this signals the previous main loop that it's now become old, and it must return.

},

resume: function() {

Browser.mainLoop.currentlyRunningMainloop++;

var timingMode = Browser.mainLoop.timingMode;

var timingValue = Browser.mainLoop.timingValue;

var func = Browser.mainLoop.func;

Browser.mainLoop.func = null;

setMainLoop(func, 0, false, Browser.mainLoop.arg, true /* do not set timing and call scheduler, we will do it on the next lines */);

_emscripten_set_main_loop_timing(timingMode, timingValue);

Browser.mainLoop.scheduler();

},

updateStatus: function() {

if (Module['setStatus']) {

var message = Module['statusMessage'] || 'Please wait...';

var remaining = Browser.mainLoop.remainingBlockers;

var expected = Browser.mainLoop.expectedBlockers;

if (remaining) {

if (remaining < expected) {

Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');

} else {

Module['setStatus'](message);

}

} else {

Module['setStatus']('');

}

}

},

runIter: function(func) {

if (ABORT) return;

if (Module['preMainLoop']) {

var preRet = Module['preMainLoop']();

if (preRet === false) {

return; // |return false| skips a frame

}

}

try {

func();

} catch (e) {

if (e instanceof ExitStatus) {

return;

} else if (e == 'unwind') {

return;

} else {

if (e && typeof e === 'object' && e.stack) err('exception thrown: ' + [e, e.stack]);

throw e;

}

}

if (Module['postMainLoop']) Module['postMainLoop']();

}

},

isFullscreen: false,

pointerLock: false,

moduleContextCreatedCallbacks: [],

workers: [],

init: function() {

if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers

if (Browser.initted) return;

Browser.initted = true;

try {

new Blob();

Browser.hasBlobConstructor = true;

} catch(e) {

Browser.hasBlobConstructor = false;

console.log("warning: no blob constructor, cannot create blobs with mimetypes");

}

Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));

Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;

if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {

console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");

Module.noImageDecoding = true;

}

// Support for plugins that can process preloaded files. You can add more of these to

// your app by creating and appending to Module.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)$/i.test(name);

};

imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {

var b = null;

if (Browser.hasBlobConstructor) {

try {

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) });

}

} catch(e) {

warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');

}

}

if (!b) {

var bb = new Browser.BlobBuilder();

bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range

b = bb.getBlob();

}

var url = Browser.URLObject.createObjectURL(b);

#if ASSERTIONS

assert(typeof url == 'string', 'createObjectURL must return a url as a string');

#endif

var img = new Image();

img.onload = function img_onload() {

assert(img.complete, 'Image ' + name + ' could not be decoded');

var canvas = document.createElement('canvas');

canvas.width = img.width;

canvas.height = img.height;

var ctx = canvas.getContext('2d');

ctx.drawImage(img, 0, 0);

Module["preloadedImages"][name] = canvas;

Browser.URLObject.revokeObjectURL(url);

if (onload) onload(byteArray);

};

img.onerror = function img_onerror(event) {

console.log('Image ' + url + ' could not be decoded');

if (onerror) onerror();

};

img.src = url;

};

Module['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;

Module["preloadedAudios"][name] = audio;

if (onload) onload(byteArray);

}

function fail() {

if (done) return;

done = true;

Module["preloadedAudios"][name] = new Audio(); // empty shim

if (onerror) onerror();

}

if (Browser.hasBlobConstructor) {

try {

var b = new Blob([byteArray], { type: Browser.getMimetype(name) });

} catch(e) {

return fail();

}

var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!

#if ASSERTIONS

assert(typeof url == 'string', 'createObjectURL must return a url as a string');

#endif

var audio = new Audio();

audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926

audio.onerror = function audio_onerror(event) {

if (done) return;

console.log('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

Browser.safeSetTimeout(function() {

finish(audio); // try to use it even though it is not necessarily ready to play

}, 10000);

} else {

return fail();

}

};

Module['preloadPlugins'].push(audioPlugin);

#if MAIN_MODULE

var wasmPlugin = {};

wasmPlugin['asyncWasmLoadPromise'] = new Promise(

function(resolve, reject) { return resolve(); });

wasmPlugin['canHandle'] = function(name) {

return !Module.noWasmDecoding && name.endsWith('.so');

};

wasmPlugin['handle'] = function(byteArray, name, onload, onerror) {

// loadSideModule can not load modules out-of-order, so rather

// than just running the promises in parallel, this makes a chain of

// promises to run in series.

this['asyncWasmLoadPromise'] = this['asyncWasmLoadPromise'].then(

function() {

return loadSideModule(byteArray, {loadAsync: true, nodelete: true});

}).then(

function(module) {

Module['preloadedWasm'][name] = module;

onload();

},

function(err) {

console.warn("Couldn't instantiate wasm: " + name + " '" + err + "'");

onerror();

});

};

Module['preloadPlugins'].push(wasmPlugin);

#endif // MAIN_MODULE

// 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'] ||

function(){};

canvas.exitPointerLock = document['exitPointerLock'] ||

document['mozExitPointerLock'] ||

document['webkitExitPointerLock'] ||

document['msExitPointerLock'] ||

function(){}; // 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", function(ev) {

if (!Browser.pointerLock && Module['canvas'].requestPointerLock) {

Module['canvas'].requestPointerLock();

ev.preventDefault();

}

}, false);

}

}

},

createContext: function(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,

#if MIN_WEBGL_VERSION >= 2

majorVersion: 2,

#else

#if MAX_WEBGL_VERSION >= 2 // library_browser.js defaults: use the WebGL version chosen at compile time (unless overridden below)

majorVersion: (typeof WebGL2RenderingContext !== 'undefined') ? 2 : 1,

#else

majorVersion: 1,

#endif

#endif

};

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);

Module.useWebGL = useWebGL;

Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });

Browser.init();

}

return ctx;

},

destroyContext: function(canvas, useWebGL, setInModule) {},

fullscreenHandlersInstalled: false,

lockPointer: undefined,

resizeCanvas: undefined,

requestFullscreen: function(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);

}

}

if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullscreen);

if (Module['onFullscreen']) 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'] ? function() { canvasContainer['webkitRequestFullscreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null) ||

(canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);

canvasContainer.requestFullscreen();

},

#if ASSERTIONS

requestFullScreen: function() {

abort('Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)');

},

#endif

exitFullscreen: function() {

// 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'] ||

(function() {});

CFS.apply(document, []);

return true;

},

nextRAF: 0,

fakeRequestAnimationFrame: function(func) {

// try to keep 60fps between calls to here

var now = Date.now();

if (Browser.nextRAF === 0) {

Browser.nextRAF = now + 1000/60;

} else {

while (now + 2 >= Browser.nextRAF) { // fudge a little, to avoid timer jitter causing us to do lots of delay:0

Browser.nextRAF += 1000/60;

}

}

var delay = Math.max(Browser.nextRAF - now, 0);

setTimeout(func, delay);

},

requestAnimationFrame: function(func) {

if (typeof requestAnimationFrame === 'function') {

requestAnimationFrame(func);

return;

}

var RAF = Browser.fakeRequestAnimationFrame;

#if LEGACY_VM_SUPPORT

if (typeof window !== 'undefined') {

RAF = window['requestAnimationFrame'] ||

window['mozRequestAnimationFrame'] ||

window['webkitRequestAnimationFrame'] ||

window['msRequestAnimationFrame'] ||

window['oRequestAnimationFrame'] ||

RAF;

}

#endif

RAF(func);

},

// generic abort-aware wrapper for an async callback

safeCallback: function(func) {

return function() {

if (!ABORT) return func.apply(null, arguments);

};

},

// abort and pause-aware versions TODO: build main loop on top of this?

allowAsyncCallbacks: true,

queuedAsyncCallbacks: [],

pauseAsyncCallbacks: function() {

Browser.allowAsyncCallbacks = false;

},

resumeAsyncCallbacks: function() { // marks future callbacks as ok to execute, and synchronously runs any remaining ones right now

Browser.allowAsyncCallbacks = true;

if (Browser.queuedAsyncCallbacks.length > 0) {

var callbacks = Browser.queuedAsyncCallbacks;

Browser.queuedAsyncCallbacks = [];

callbacks.forEach(function(func) {

func();

});

}

},

safeRequestAnimationFrame: function(func) {

return Browser.requestAnimationFrame(function() {

if (ABORT) return;

if (Browser.allowAsyncCallbacks) {

func();

} else {

Browser.queuedAsyncCallbacks.push(func);

}

});

},

safeSetTimeout: function(func, timeout) {

noExitRuntime = true;

return setTimeout(function() {

if (ABORT) return;

if (Browser.allowAsyncCallbacks) {

func();

} else {

Browser.queuedAsyncCallbacks.push(func);

}

}, timeout);

},

safeSetInterval: function(func, timeout) {

noExitRuntime = true;

return setInterval(function() {

if (ABORT) return;

if (Browser.allowAsyncCallbacks) {

func();

} // drop it on the floor otherwise, next interval will kick in

}, timeout);

},

getMimetype: function(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: function(func) {

if(!window.getUserMedia) {

window.getUserMedia = navigator['getUserMedia'] ||

navigator['mozGetUserMedia'];

}

window.getUserMedia(func);

},

getMovementX: function(event) {

return event['movementX'] ||

event['mozMovementX'] ||

event['webkitMovementX'] ||

0;

},

getMovementY: function(event) {

return event['movementY'] ||

event['mozMovementY'] ||

event['webkitMovementY'] ||

0;

},

// Browsers specify wheel direction according to the page CSS pixel Y direction:

// Scrolling mouse wheel down (==towards user/away from screen) on Windows/Linux (and macOS without 'natural scroll' enabled)

// is the positive wheel direction. Scrolling mouse wheel up (towards the screen) is the negative wheel direction.

// This function returns the wheel direction in the browser page coordinate system (+: down, -: up). Note that this is often the

// opposite of native code: In native APIs the positive scroll direction is to scroll up (away from the user).

// NOTE: The mouse wheel delta is a decimal number, and can be a fractional value within -1 and 1. If you need to represent

// this as an integer, don't simply cast to int, or you may receive scroll events for wheel delta == 0.

// NOTE: We convert all units returned by events into steps, i.e. individual wheel notches.

// These conversions are only approximations. Changing browsers, operating systems, or even settings can change the values.

getMouseWheelDelta: function(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: {},

calculateMouseEvent: function(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);

}

// check if SDL is available

if (typeof SDL != "undefined") {

Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;

Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;

} else {

// just add the mouse delta to the current absolut mouse position

// FIXME: ideally this should be clamped against the canvas size and zero

Browser.mouseX += Browser.mouseMovementX;

Browser.mouseY += Browser.mouseMovementY;

}

} else {

// Otherwise, 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 ASSERTIONS

// 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.');

#endif

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 adjustedX = touch.pageX - (scrollX + rect.left);

var adjustedY = touch.pageY - (scrollY + rect.top);

adjustedX = adjustedX * (cw / rect.width);

adjustedY = adjustedY * (ch / rect.height);

var coords = { x: adjustedX, y: adjustedY };

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];

if (!last) last = coords;

Browser.lastTouches[touch.identifier] = last;

Browser.touches[touch.identifier] = coords;

}

return;

}

var x = event.pageX - (scrollX + rect.left);

var y = event.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.

x = x * (cw / rect.width);

y = y * (ch / rect.height);

Browser.mouseMovementX = x - Browser.mouseX;

Browser.mouseMovementY = y - Browser.mouseY;

Browser.mouseX = x;

Browser.mouseY = y;

}

},

asyncLoad: function(url, onload, onerror, noRunDep) {

var dep = !noRunDep ? getUniqueRunDependency('al ' + url) : '';

readAsync(url, function(arrayBuffer) {

assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');

onload(new Uint8Array(arrayBuffer));

if (dep) removeRunDependency(dep);

}, function(event) {

if (onerror) {

onerror();

} else {

throw 'Loading data file "' + url + '" failed.';

}

});

if (dep) addRunDependency(dep);

},

resizeListeners: [],

updateResizeListeners: function() {

var canvas = Module['canvas'];

Browser.resizeListeners.forEach(function(listener) {

listener(canvas.width, canvas.height);

});

},

setCanvasSize: function(width, height, noUpdates) {

var canvas = Module['canvas'];

Browser.updateCanvasDimensions(canvas, width, height);

if (!noUpdates) Browser.updateResizeListeners();

},

windowedWidth: 0,

windowedHeight: 0,

setFullscreenCanvasSize: function() {

// check if SDL is available

if (typeof SDL != "undefined") {

var flags = {{{ makeGetValue('SDL.screen', '0', 'i32', 0, 1) }}};

flags = flags | 0x00800000; // set SDL_FULLSCREEN flag

{{{ makeSetValue('SDL.screen', '0', 'flags', 'i32') }}}

}

Browser.updateCanvasDimensions(Module['canvas']);

Browser.updateResizeListeners();

},

setWindowedCanvasSize: function() {

// check if SDL is available

if (typeof SDL != "undefined") {

var flags = {{{ makeGetValue('SDL.screen', '0', 'i32', 0, 1) }}};

flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag

{{{ makeSetValue('SDL.screen', '0', 'flags', 'i32') }}}

}

Browser.updateCanvasDimensions(Module['canvas']);

Browser.updateResizeListeners();

},

updateCanvasDimensions : function(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");

}

}

}

},

wgetRequests: {},

nextWgetRequestHandle: 0,

getNextWgetRequestHandle: function() {

var handle = Browser.nextWgetRequestHandle;

Browser.nextWgetRequestHandle++;

return handle;

}

},

emscripten_async_wget__deps: ['$PATH_FS'],

emscripten_async_wget__proxy: 'sync',

emscripten_async_wget__sig: 'viiii',

emscripten_async_wget: function(url, file, onload, onerror) {

noExitRuntime = true;

var _url = UTF8ToString(url);

var _file = UTF8ToString(file);

_file = PATH_FS.resolve(_file);

function doCallback(callback) {

if (callback) {

var stack = stackSave();

{{{ makeDynCall('vi', 'callback') }}}(allocate(intArrayFromString(_file), ALLOC_STACK));

stackRestore(stack);

}

}

var destinationDirectory = PATH.dirname(_file);

FS.createPreloadedFile(

destinationDirectory,

PATH.basename(_file),

_url, true, true,

function() {

doCallback(onload);

},

function() {

doCallback(onerror);

},

false, // dontCreateFile

false, // canOwn

function() { // preFinish

// if a file exists there, we overwrite it

try {

FS.unlink(_file);

} catch (e) {}

// if the destination directory does not yet exist, create it

FS.mkdirTree(destinationDirectory);

}

);

},

$funcWrappers: {},

$getFuncWrapper__deps: ['$funcWrappers', '$dynCall'],

$getFuncWrapper: function(func, sig) {

if (!func) return; // on null pointer, return undefined

assert(sig);

if (!funcWrappers[sig]) {

funcWrappers[sig] = {};

}

var sigCache = funcWrappers[sig];

if (!sigCache[func]) {

// optimize away arguments usage in common cases

if (sig.length === 1) {

sigCache[func] = function dynCall_wrapper() {

return dynCall(sig, func);

};

} else if (sig.length === 2) {

sigCache[func] = function dynCall_wrapper(arg) {

return dynCall(sig, func, [arg]);

};

} else {

// general case

sigCache[func] = function dynCall_wrapper() {

return dynCall(sig, func, Array.prototype.slice.call(arguments));

};

}

}

return sigCache[func];

},

emscripten_async_wget_data__proxy: 'sync',

emscripten_async_wget_data__sig: 'viiii',

emscripten_async_wget_data: function(url, arg, onload, onerror) {

Browser.asyncLoad(UTF8ToString(url), function(byteArray) {

var buffer = _malloc(byteArray.length);

HEAPU8.set(byteArray, buffer);

{{{ makeDynCall('viii', 'onload') }}}(arg, buffer, byteArray.length);

_free(buffer);

}, function() {

if (onerror) {{{ makeDynCall('vi', 'onerror') }}}(arg);

}, true /* no need for run dependency, this is async but will not do any prepare etc. step */ );

},

emscripten_async_wget2__deps: ['$PATH_FS'],

emscripten_async_wget2__proxy: 'sync',

emscripten_async_wget2__sig: 'iiiiiiiii',

emscripten_async_wget2: function(url, file, request, param, arg, onload, onerror, onprogress) {

noExitRuntime = true;

var _url = UTF8ToString(url);

var _file = UTF8ToString(file);

_file = PATH_FS.resolve(_file);

var _request = UTF8ToString(request);

var _param = UTF8ToString(param);

var index = _file.lastIndexOf('/');

var http = new XMLHttpRequest();

http.open(_request, _url, true);

http.responseType = 'arraybuffer';

var handle = Browser.getNextWgetRequestHandle();

var destinationDirectory = PATH.dirname(_file);

// LOAD

http.onload = function http_onload(e) {

if (http.status >= 200 && http.status < 300) {

// if a file exists there, we overwrite it

try {

FS.unlink(_file);

} catch (e) {}

// if the destination directory does not yet exist, create it

FS.mkdirTree(destinationDirectory);

FS.createDataFile( _file.substr(0, index), _file.substr(index + 1), new Uint8Array(/** @type{ArrayBuffer}*/(http.response)), true, true, false);

if (onload) {

var stack = stackSave();

{{{ makeDynCall('viii', 'onload') }}}(handle, arg, allocate(intArrayFromString(_file), ALLOC_STACK));

stackRestore(stack);

}

} else {

if (onerror) {{{ makeDynCall('viii', 'onerror') }}}(handle, arg, http.status);

}

delete Browser.wgetRequests[handle];

};

// ERROR

http.onerror = function http_onerror(e) {

if (onerror) {{{ makeDynCall('viii', 'onerror') }}}(handle, arg, http.status);

delete Browser.wgetRequests[handle];

};

// PROGRESS

http.onprogress = function http_onprogress(e) {

if (e.lengthComputable || (e.lengthComputable === undefined && e.total != 0)) {

var percentComplete = (e.loaded / e.total)*100;

if (onprogress) {{{ makeDynCall('viii', 'onprogress') }}}(handle, arg, percentComplete);

}

};

// ABORT

http.onabort = function http_onabort(e) {

delete Browser.wgetRequests[handle];

};

if (_request == "POST") {

//Send the proper header information along with the request

http.setRequestHeader("Content-type", "application/x-www-form-urlencoded");

http.send(_param);

} else {

http.send(null);

}

Browser.wgetRequests[handle] = http;

return handle;

},

emscripten_async_wget2_data__proxy: 'sync',

emscripten_async_wget2_data__sig: 'iiiiiiiii',

emscripten_async_wget2_data: function(url, request, param, arg, free, onload, onerror, onprogress) {

var _url = UTF8ToString(url);

var _request = UTF8ToString(request);

var _param = UTF8ToString(param);

var http = new XMLHttpRequest();

http.open(_request, _url, true);

http.responseType = 'arraybuffer';

var handle = Browser.getNextWgetRequestHandle();

// LOAD

http.onload = function http_onload(e) {

if (http.status >= 200 && http.status < 300 || (http.status === 0 && _url.substr(0,4).toLowerCase() != "http")) {

var byteArray = new Uint8Array(/** @type{ArrayBuffer} */(http.response));

var buffer = _malloc(byteArray.length);

HEAPU8.set(byteArray, buffer);

if (onload) {{{ makeDynCall('viiii', 'onload') }}}(handle, arg, buffer, byteArray.length);

if (free) _free(buffer);

} else {