const Preloader = /** @constructor */ function () { // eslint-disable-line no-unused-vars function getTrackedResponse(response, load_status) { function onloadprogress(reader, controller) { return reader.read().then(function (result) { if (load_status.done) { return Promise.resolve(); } if (result.value) { controller.enqueue(result.value); load_status.loaded += result.value.length; } if (!result.done) { return onloadprogress(reader, controller); } load_status.done = true; return Promise.resolve(); }); } const reader = response.body.getReader(); return new Response(new ReadableStream({ start: function (controller) { onloadprogress(reader, controller).then(function () { controller.close(); }); }, }), { headers: response.headers }); } function loadFetch(file, tracker, fileSize, raw) { tracker[file] = { total: fileSize || 0, loaded: 0, done: false, }; return fetch(file).then(function (response) { if (!response.ok) { return Promise.reject(new Error(`Failed loading file '${file}'`)); } const tr = getTrackedResponse(response, tracker[file]); if (raw) { return Promise.resolve(tr); } return tr.arrayBuffer(); }); } function retry(func, attempts = 1) { function onerror(err) { if (attempts <= 1) { return Promise.reject(err); } return new Promise(function (resolve, reject) { setTimeout(function () { retry(func, attempts - 1).then(resolve).catch(reject); }, 1000); }); } return func().catch(onerror); } const DOWNLOAD_ATTEMPTS_MAX = 4; const loadingFiles = {}; const lastProgress = { loaded: 0, total: 0 }; let progressFunc = null; const animateProgress = function () { let loaded = 0; let total = 0; let totalIsValid = true; let progressIsFinal = true; Object.keys(loadingFiles).forEach(function (file) { const stat = loadingFiles[file]; if (!stat.done) { progressIsFinal = false; } if (!totalIsValid || stat.total === 0) { totalIsValid = false; total = 0; } else { total += stat.total; } loaded += stat.loaded; }); if (loaded !== lastProgress.loaded || total !== lastProgress.total) { lastProgress.loaded = loaded; lastProgress.total = total; if (typeof progressFunc === 'function') { progressFunc(loaded, total); } } if (!progressIsFinal) { requestAnimationFrame(animateProgress); } }; this.animateProgress = animateProgress; this.setProgressFunc = function (callback) { progressFunc = callback; }; this.loadPromise = function (file, fileSize, raw = false) { return retry(loadFetch.bind(null, file, loadingFiles, fileSize, raw), DOWNLOAD_ATTEMPTS_MAX); }; this.preloadedFiles = []; this.preload = function (pathOrBuffer, destPath, fileSize) { let buffer = null; if (typeof pathOrBuffer === 'string') { const me = this; return this.loadPromise(pathOrBuffer, fileSize).then(function (buf) { me.preloadedFiles.push({ path: destPath || pathOrBuffer, buffer: buf, }); return Promise.resolve(); }); } else if (pathOrBuffer instanceof ArrayBuffer) { buffer = new Uint8Array(pathOrBuffer); } else if (ArrayBuffer.isView(pathOrBuffer)) { buffer = new Uint8Array(pathOrBuffer.buffer); } if (buffer) { this.preloadedFiles.push({ path: destPath, buffer: pathOrBuffer, }); return Promise.resolve(); } return Promise.reject(new Error('Invalid object for preloading')); }; }; /** * An object used to configure the Engine instance based on godot export options, and to override those in custom HTML * templates if needed. * * @header Engine configuration * @summary The Engine configuration object. This is just a typedef, create it like a regular object, e.g.: * * ``const MyConfig = { executable: 'godot', unloadAfterInit: false }`` * * @typedef {Object} EngineConfig */ const EngineConfig = {}; // eslint-disable-line no-unused-vars /** * @struct * @constructor * @ignore */ const InternalConfig = function (initConfig) { // eslint-disable-line no-unused-vars const cfg = /** @lends {InternalConfig.prototype} */ { /** * Whether the unload the engine automatically after the instance is initialized. * * @memberof EngineConfig * @default * @type {boolean} */ unloadAfterInit: true, /** * The HTML DOM Canvas object to use. * * By default, the first canvas element in the document will be used is none is specified. * * @memberof EngineConfig * @default * @type {?HTMLCanvasElement} */ canvas: null, /** * The name of the WASM file without the extension. (Set by Godot Editor export process). * * @memberof EngineConfig * @default * @type {string} */ executable: '', /** * An alternative name for the game pck to load. The executable name is used otherwise. * * @memberof EngineConfig * @default * @type {?string} */ mainPack: null, /** * Specify a language code to select the proper localization for the game. * * The browser locale will be used if none is specified. See complete list of * :ref:`supported locales `. * * @memberof EngineConfig * @type {?string} * @default */ locale: null, /** * The canvas resize policy determines how the canvas should be resized by Godot. * * ``0`` means Godot won't do any resizing. This is useful if you want to control the canvas size from * javascript code in your template. * * ``1`` means Godot will resize the canvas on start, and when changing window size via engine functions. * * ``2`` means Godot will adapt the canvas size to match the whole browser window. * * @memberof EngineConfig * @type {number} * @default */ canvasResizePolicy: 2, /** * The arguments to be passed as command line arguments on startup. * * See :ref:`command line tutorial `. * * **Note**: :js:meth:`startGame ` will always add the ``--main-pack`` argument. * * @memberof EngineConfig * @type {Array} * @default */ args: [], /** * When enabled, the game canvas will automatically grab the focus when the engine starts. * * @memberof EngineConfig * @type {boolean} * @default */ focusCanvas: true, /** * When enabled, this will turn on experimental virtual keyboard support on mobile. * * @memberof EngineConfig * @type {boolean} * @default */ experimentalVK: false, /** * The progressive web app service worker to install. * @memberof EngineConfig * @default * @type {string} */ serviceWorker: '', /** * @ignore * @type {Array.} */ persistentPaths: ['/userfs'], /** * @ignore * @type {boolean} */ persistentDrops: false, /** * @ignore * @type {Array.} */ gdnativeLibs: [], /** * @ignore * @type {Array.} */ fileSizes: [], /** * A callback function for handling Godot's ``OS.execute`` calls. * * This is for example used in the Web Editor template to switch between project manager and editor, and for running the game. * * @callback EngineConfig.onExecute * @param {string} path The path that Godot's wants executed. * @param {Array.} args The arguments of the "command" to execute. */ /** * @ignore * @type {?function(string, Array.)} */ onExecute: null, /** * A callback function for being notified when the Godot instance quits. * * **Note**: This function will not be called if the engine crashes or become unresponsive. * * @callback EngineConfig.onExit * @param {number} status_code The status code returned by Godot on exit. */ /** * @ignore * @type {?function(number)} */ onExit: null, /** * A callback function for displaying download progress. * * The function is called once per frame while downloading files, so the usage of ``requestAnimationFrame()`` * is not necessary. * * If the callback function receives a total amount of bytes as 0, this means that it is impossible to calculate. * Possible reasons include: * * - Files are delivered with server-side chunked compression * - Files are delivered with server-side compression on Chromium * - Not all file downloads have started yet (usually on servers without multi-threading) * * @callback EngineConfig.onProgress * @param {number} current The current amount of downloaded bytes so far. * @param {number} total The total amount of bytes to be downloaded. */ /** * @ignore * @type {?function(number, number)} */ onProgress: null, /** * A callback function for handling the standard output stream. This method should usually only be used in debug pages. * * By default, ``console.log()`` is used. * * @callback EngineConfig.onPrint * @param {...*} [var_args] A variadic number of arguments to be printed. */ /** * @ignore * @type {?function(...*)} */ onPrint: function () { console.log.apply(console, Array.from(arguments)); // eslint-disable-line no-console }, /** * A callback function for handling the standard error stream. This method should usually only be used in debug pages. * * By default, ``console.error()`` is used. * * @callback EngineConfig.onPrintError * @param {...*} [var_args] A variadic number of arguments to be printed as errors. */ /** * @ignore * @type {?function(...*)} */ onPrintError: function (var_args) { console.error.apply(console, Array.from(arguments)); // eslint-disable-line no-console }, }; /** * @ignore * @struct * @constructor * @param {EngineConfig} opts */ function Config(opts) { this.update(opts); } Config.prototype = cfg; /** * @ignore * @param {EngineConfig} opts */ Config.prototype.update = function (opts) { const config = opts || {}; // NOTE: We must explicitly pass the default, accessing it via // the key will fail due to closure compiler renames. function parse(key, def) { if (typeof (config[key]) === 'undefined') { return def; } return config[key]; } // Module config this.unloadAfterInit = parse('unloadAfterInit', this.unloadAfterInit); this.onPrintError = parse('onPrintError', this.onPrintError); this.onPrint = parse('onPrint', this.onPrint); this.onProgress = parse('onProgress', this.onProgress); // Godot config this.canvas = parse('canvas', this.canvas); this.executable = parse('executable', this.executable); this.mainPack = parse('mainPack', this.mainPack); this.locale = parse('locale', this.locale); this.canvasResizePolicy = parse('canvasResizePolicy', this.canvasResizePolicy); this.persistentPaths = parse('persistentPaths', this.persistentPaths); this.persistentDrops = parse('persistentDrops', this.persistentDrops); this.experimentalVK = parse('experimentalVK', this.experimentalVK); this.focusCanvas = parse('focusCanvas', this.focusCanvas); this.serviceWorker = parse('serviceWorker', this.serviceWorker); this.gdnativeLibs = parse('gdnativeLibs', this.gdnativeLibs); this.fileSizes = parse('fileSizes', this.fileSizes); this.args = parse('args', this.args); this.onExecute = parse('onExecute', this.onExecute); this.onExit = parse('onExit', this.onExit); }; /** * @ignore * @param {string} loadPath * @param {Response} response */ Config.prototype.getModuleConfig = function (loadPath, response) { let r = response; return { 'print': this.onPrint, 'printErr': this.onPrintError, 'thisProgram': this.executable, 'noExitRuntime': true, 'dynamicLibraries': [`${loadPath}.side.wasm`], 'instantiateWasm': function (imports, onSuccess) { function done(result) { onSuccess(result['instance'], result['module']); } if (typeof (WebAssembly.instantiateStreaming) !== 'undefined') { WebAssembly.instantiateStreaming(Promise.resolve(r), imports).then(done); } else { r.arrayBuffer().then(function (buffer) { WebAssembly.instantiate(buffer, imports).then(done); }); } r = null; return {}; }, 'locateFile': function (path) { if (path.endsWith('.worker.js')) { return `${loadPath}.worker.js`; } else if (path.endsWith('.audio.worklet.js')) { return `${loadPath}.audio.worklet.js`; } else if (path.endsWith('.js')) { return `${loadPath}.js`; } else if (path.endsWith('.side.wasm')) { return `${loadPath}.side.wasm`; } else if (path.endsWith('.wasm')) { return `${loadPath}.wasm`; } return path; }, }; }; /** * @ignore * @param {function()} cleanup */ Config.prototype.getGodotConfig = function (cleanup) { // Try to find a canvas if (!(this.canvas instanceof HTMLCanvasElement)) { const nodes = document.getElementsByTagName('canvas'); if (nodes.length && nodes[0] instanceof HTMLCanvasElement) { this.canvas = nodes[0]; } if (!this.canvas) { throw new Error('No canvas found in page'); } } // Canvas can grab focus on click, or key events won't work. if (this.canvas.tabIndex < 0) { this.canvas.tabIndex = 0; } // Browser locale, or custom one if defined. let locale = this.locale; if (!locale) { locale = navigator.languages ? navigator.languages[0] : navigator.language; locale = locale.split('.')[0]; } const onExit = this.onExit; // Godot configuration. return { 'canvas': this.canvas, 'canvasResizePolicy': this.canvasResizePolicy, 'locale': locale, 'persistentDrops': this.persistentDrops, 'virtualKeyboard': this.experimentalVK, 'focusCanvas': this.focusCanvas, 'onExecute': this.onExecute, 'onExit': function (p_code) { cleanup(); // We always need to call the cleanup callback to free memory. if (typeof (onExit) === 'function') { onExit(p_code); } }, }; }; return new Config(initConfig); }; /** * Projects exported for the Web expose the :js:class:`Engine` class to the JavaScript environment, that allows * fine control over the engine's start-up process. * * This API is built in an asynchronous manner and requires basic understanding * of `Promises `__. * * @module Engine * @header HTML5 shell class reference */ const Engine = (function () { const preloader = new Preloader(); let loadPromise = null; let loadPath = ''; let initPromise = null; /** * @classdesc The ``Engine`` class provides methods for loading and starting exported projects on the Web. For default export * settings, this is already part of the exported HTML page. To understand practical use of the ``Engine`` class, * see :ref:`Custom HTML page for Web export `. * * @description Create a new Engine instance with the given configuration. * * @global * @constructor * @param {EngineConfig} initConfig The initial config for this instance. */ function Engine(initConfig) { // eslint-disable-line no-shadow this.config = new InternalConfig(initConfig); this.rtenv = null; } /** * Load the engine from the specified base path. * * @param {string} basePath Base path of the engine to load. * @param {number=} [size=0] The file size if known. * @returns {Promise} A Promise that resolves once the engine is loaded. * * @function Engine.load */ Engine.load = function (basePath, size) { if (loadPromise == null) { loadPath = basePath; loadPromise = preloader.loadPromise(`${loadPath}.wasm`, size, true); requestAnimationFrame(preloader.animateProgress); } return loadPromise; }; /** * Unload the engine to free memory. * * This method will be called automatically depending on the configuration. See :js:attr:`unloadAfterInit`. * * @function Engine.unload */ Engine.unload = function () { loadPromise = null; }; /** * Check whether WebGL is available. Optionally, specify a particular version of WebGL to check for. * * @param {number=} [majorVersion=1] The major WebGL version to check for. * @returns {boolean} If the given major version of WebGL is available. * @function Engine.isWebGLAvailable */ Engine.isWebGLAvailable = function (majorVersion = 1) { try { return !!document.createElement('canvas').getContext(['webgl', 'webgl2'][majorVersion - 1]); } catch (e) { /* Not available */ } return false; }; /** * Safe Engine constructor, creates a new prototype for every new instance to avoid prototype pollution. * @ignore * @constructor */ function SafeEngine(initConfig) { const proto = /** @lends Engine.prototype */ { /** * Initialize the engine instance. Optionally, pass the base path to the engine to load it, * if it hasn't been loaded yet. See :js:meth:`Engine.load`. * * @param {string=} basePath Base path of the engine to load. * @return {Promise} A ``Promise`` that resolves once the engine is loaded and initialized. */ init: function (basePath) { if (initPromise) { return initPromise; } if (loadPromise == null) { if (!basePath) { initPromise = Promise.reject(new Error('A base path must be provided when calling `init` and the engine is not loaded.')); return initPromise; } Engine.load(basePath, this.config.fileSizes[`${basePath}.wasm`]); } const me = this; function doInit(promise) { // Care! Promise chaining is bogus with old emscripten versions. // This caused a regression with the Mono build (which uses an older emscripten version). // Make sure to test that when refactoring. return new Promise(function (resolve, reject) { promise.then(function (response) { const cloned = new Response(response.clone().body, { 'headers': [['content-type', 'application/wasm']] }); Godot(me.config.getModuleConfig(loadPath, cloned)).then(function (module) { const paths = me.config.persistentPaths; module['initFS'](paths).then(function (err) { me.rtenv = module; if (me.config.unloadAfterInit) { Engine.unload(); } resolve(); }); }); }); }); } preloader.setProgressFunc(this.config.onProgress); initPromise = doInit(loadPromise); return initPromise; }, /** * Load a file so it is available in the instance's file system once it runs. Must be called **before** starting the * instance. * * If not provided, the ``path`` is derived from the URL of the loaded file. * * @param {string|ArrayBuffer} file The file to preload. * * If a ``string`` the file will be loaded from that path. * * If an ``ArrayBuffer`` or a view on one, the buffer will used as the content of the file. * * @param {string=} path Path by which the file will be accessible. Required, if ``file`` is not a string. * * @returns {Promise} A Promise that resolves once the file is loaded. */ preloadFile: function (file, path) { return preloader.preload(file, path, this.config.fileSizes[file]); }, /** * Start the engine instance using the given override configuration (if any). * :js:meth:`startGame ` can be used in typical cases instead. * * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init `. * The engine must be loaded beforehand. * * Fails if a canvas cannot be found on the page, or not specified in the configuration. * * @param {EngineConfig} override An optional configuration override. * @return {Promise} Promise that resolves once the engine started. */ start: function (override) { this.config.update(override); const me = this; return me.init().then(function () { if (!me.rtenv) { return Promise.reject(new Error('The engine must be initialized before it can be started')); } let config = {}; try { config = me.config.getGodotConfig(function () { me.rtenv = null; }); } catch (e) { return Promise.reject(e); } // Godot configuration. me.rtenv['initConfig'](config); // Preload GDNative libraries. const libs = []; me.config.gdnativeLibs.forEach(function (lib) { libs.push(me.rtenv['loadDynamicLibrary'](lib, { 'loadAsync': true })); }); return Promise.all(libs).then(function () { return new Promise(function (resolve, reject) { preloader.preloadedFiles.forEach(function (file) { me.rtenv['copyToFS'](file.path, file.buffer); }); preloader.preloadedFiles.length = 0; // Clear memory me.rtenv['callMain'](me.config.args); initPromise = null; if (me.config.serviceWorker && 'serviceWorker' in navigator) { navigator.serviceWorker.register(me.config.serviceWorker); } resolve(); }); }); }); }, /** * Start the game instance using the given configuration override (if any). * * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init `. * * This will load the engine if it is not loaded, and preload the main pck. * * This method expects the initial config (or the override) to have both the :js:attr:`executable` and :js:attr:`mainPack` * properties set (normally done by the editor during export). * * @param {EngineConfig} override An optional configuration override. * @return {Promise} Promise that resolves once the game started. */ startGame: function (override) { this.config.update(override); // Add main-pack argument. const exe = this.config.executable; const pack = this.config.mainPack || `${exe}.pck`; this.config.args = ['--main-pack', pack].concat(this.config.args); // Start and init with execName as loadPath if not inited. const me = this; return Promise.all([ this.init(exe), this.preloadFile(pack, pack), ]).then(function () { return me.start.apply(me); }); }, /** * Create a file at the specified ``path`` with the passed as ``buffer`` in the instance's file system. * * @param {string} path The location where the file will be created. * @param {ArrayBuffer} buffer The content of the file. */ copyToFS: function (path, buffer) { if (this.rtenv == null) { throw new Error('Engine must be inited before copying files'); } this.rtenv['copyToFS'](path, buffer); }, /** * Request that the current instance quit. * * This is akin the user pressing the close button in the window manager, and will * have no effect if the engine has crashed, or is stuck in a loop. * */ requestQuit: function () { if (this.rtenv) { this.rtenv['request_quit'](); } }, }; Engine.prototype = proto; // Closure compiler exported instance methods. Engine.prototype['init'] = Engine.prototype.init; Engine.prototype['preloadFile'] = Engine.prototype.preloadFile; Engine.prototype['start'] = Engine.prototype.start; Engine.prototype['startGame'] = Engine.prototype.startGame; Engine.prototype['copyToFS'] = Engine.prototype.copyToFS; Engine.prototype['requestQuit'] = Engine.prototype.requestQuit; // Also expose static methods as instance methods Engine.prototype['load'] = Engine.load; Engine.prototype['unload'] = Engine.unload; Engine.prototype['isWebGLAvailable'] = Engine.isWebGLAvailable; return new Engine(initConfig); } // Closure compiler exported static methods. SafeEngine['load'] = Engine.load; SafeEngine['unload'] = Engine.unload; SafeEngine['isWebGLAvailable'] = Engine.isWebGLAvailable; return SafeEngine; }()); if (typeof window !== 'undefined') { window['Engine'] = Engine; }