797 lines
342 KiB
JavaScript
797 lines
342 KiB
JavaScript
|
|
||
|
|
var Godot = (() => {
|
||
|
|
var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
|
||
|
|
|
||
|
|
return (
|
||
|
|
function(Godot) {
|
||
|
|
Godot = Godot || {};
|
||
|
|
|
||
|
|
var Module=typeof Godot!="undefined"?Godot:{};var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise(function(resolve,reject){readyPromiseResolve=resolve;readyPromiseReject=reject});var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary,setWindowTitle;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptDir){scriptDirectory=_scriptDir}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}else{scriptDirectory=""}{read_=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}onerror()};xhr.onerror=onerror;xhr.send(null)}}setWindowTitle=title=>document.title=title}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.warn.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["quit"])quit_=Module["quit"];function warnOnce(text){if(!warnOnce.shown)warnOnce.shown={};if(!warnOnce.shown[text]){warnOnce.shown[text]=1;err(text)}}var tempRet0=0;var setTempRet0=value=>{tempRet0=value};var getTempRet0=()=>tempRet0;var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];var noExitRuntime=Module["noExitRuntime"]||false;if(typeof WebAssembly!="object"){abort("no native wasm support detected")}var wasmMemory;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort(text)}}function getCFunc(ident){var func=Module["_"+ident];return func}function ccall(ident,returnType,argTypes,args,opts){var toC={"string":function(str){var ret=0;if(str!==null&&str!==undefined&&str!==0){var len=(str.length<<2)+1;ret=stackAlloc(len);stringToUTF8(str,ret,len)}return ret},"array":function(arr){var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func.apply(null,cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret}function cwrap(ident,returnType,argTypes,opts){argTypes=argTypes||[];var numericArgs=argTypes.every(function(type){return type==="number"});var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return function(){return ccall(ident,returnType,argTypes,arguments,opts)}}var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(heapOrArray,idx,maxBytesToRead){var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.de
|
||
|
|
|
||
|
|
|
||
|
|
return Godot.ready
|
||
|
|
}
|
||
|
|
);
|
||
|
|
})();
|
||
|
|
if (typeof exports === 'object' && typeof module === 'object')
|
||
|
|
module.exports = Godot;
|
||
|
|
else if (typeof define === 'function' && define['amd'])
|
||
|
|
define([], function() { return Godot; });
|
||
|
|
else if (typeof exports === 'object')
|
||
|
|
exports["Godot"] = Godot;
|
||
|
|
|
||
|
|
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 <doc_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 <doc_command_line_tutorial>`.
|
||
|
|
*
|
||
|
|
* **Note**: :js:meth:`startGame <Engine.prototype.startGame>` will always add the ``--main-pack`` argument.
|
||
|
|
*
|
||
|
|
* @memberof EngineConfig
|
||
|
|
* @type {Array<string>}
|
||
|
|
* @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.<string>}
|
||
|
|
*/
|
||
|
|
persistentPaths: ['/userfs'],
|
||
|
|
/**
|
||
|
|
* @ignore
|
||
|
|
* @type {boolean}
|
||
|
|
*/
|
||
|
|
persistentDrops: false,
|
||
|
|
/**
|
||
|
|
* @ignore
|
||
|
|
* @type {Array.<string>}
|
||
|
|
*/
|
||
|
|
gdnativeLibs: [],
|
||
|
|
/**
|
||
|
|
* @ignore
|
||
|
|
* @type {Array.<string>}
|
||
|
|
*/
|
||
|
|
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.<string>} args The arguments of the "command" to execute.
|
||
|
|
*/
|
||
|
|
/**
|
||
|
|
* @ignore
|
||
|
|
* @type {?function(string, Array.<string>)}
|
||
|
|
*/
|
||
|
|
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];
|
||
|
|
}
|
||
|
|
locale = locale.replace('-', '_');
|
||
|
|
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 <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_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 <doc_customizing_html5_shell>`.
|
||
|
|
*
|
||
|
|
* @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 <Engine.prototype.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 <Engine.prototype.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 <Engine.prototype.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;
|
||
|
|
}
|