314 lines
9.0 KiB
JavaScript
314 lines
9.0 KiB
JavaScript
/*************************************************************************/
|
|
/* library_godot_os.js */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
const IDHandler = {
|
|
$IDHandler: {
|
|
_last_id: 0,
|
|
_references: {},
|
|
|
|
get: function(p_id) {
|
|
return IDHandler._references[p_id];
|
|
},
|
|
|
|
add: function(p_data) {
|
|
const id = ++IDHandler._last_id;
|
|
IDHandler._references[id] = p_data;
|
|
return id;
|
|
},
|
|
|
|
remove: function(p_id) {
|
|
delete IDHandler._references[p_id];
|
|
},
|
|
},
|
|
};
|
|
|
|
autoAddDeps(IDHandler, "$IDHandler");
|
|
mergeInto(LibraryManager.library, IDHandler);
|
|
|
|
const GodotConfig = {
|
|
|
|
$GodotConfig__postset: 'Module["initConfig"] = GodotConfig.init_config;',
|
|
$GodotConfig: {
|
|
canvas: null,
|
|
locale: "en",
|
|
resize_on_start: false,
|
|
on_execute: null,
|
|
|
|
init_config: function(p_opts) {
|
|
GodotConfig.resize_on_start = p_opts['resizeCanvasOnStart'] ? true : false;
|
|
GodotConfig.canvas = p_opts['canvas'];
|
|
GodotConfig.locale = p_opts['locale'] || GodotConfig.locale;
|
|
GodotConfig.on_execute = p_opts['onExecute'];
|
|
// This is called by emscripten, even if undocumented.
|
|
Module['onExit'] = p_opts['onExit'];
|
|
},
|
|
},
|
|
|
|
godot_js_config_canvas_id_get: function(p_ptr, p_ptr_max) {
|
|
stringToUTF8('#' + GodotConfig.canvas.id, p_ptr, p_ptr_max);
|
|
},
|
|
|
|
godot_js_config_locale_get: function(p_ptr, p_ptr_max) {
|
|
stringToUTF8(GodotConfig.locale, p_ptr, p_ptr_max);
|
|
},
|
|
|
|
godot_js_config_is_resize_on_start: function() {
|
|
return GodotConfig.resize_on_start ? 1 : 0;
|
|
},
|
|
};
|
|
|
|
autoAddDeps(GodotConfig, '$GodotConfig');
|
|
mergeInto(LibraryManager.library, GodotConfig);
|
|
|
|
const GodotFS = {
|
|
$GodotFS__deps: ['$FS', '$IDBFS'],
|
|
$GodotFS__postset: [
|
|
'Module["initFS"] = GodotFS.init;',
|
|
'Module["deinitFS"] = GodotFS.deinit;',
|
|
'Module["copyToFS"] = GodotFS.copy_to_fs;',
|
|
].join(''),
|
|
$GodotFS: {
|
|
_idbfs: false,
|
|
_syncing: false,
|
|
_mount_points: [],
|
|
|
|
is_persistent: function() {
|
|
return GodotFS._idbfs ? 1 : 0;
|
|
},
|
|
|
|
// Initialize godot file system, setting up persistent paths.
|
|
// Returns a promise that resolves when the FS is ready.
|
|
// We keep track of mount_points, so that we can properly close the IDBFS
|
|
// since emscripten is not doing it by itself. (emscripten GH#12516).
|
|
init: function(persistentPaths) {
|
|
GodotFS._idbfs = false;
|
|
if (!Array.isArray(persistentPaths)) {
|
|
return Promise.reject(new Error('Persistent paths must be an array'));
|
|
}
|
|
if (!persistentPaths.length) {
|
|
return Promise.resolve();
|
|
}
|
|
GodotFS._mount_points = persistentPaths.slice();
|
|
|
|
function createRecursive(dir) {
|
|
try {
|
|
FS.stat(dir);
|
|
} catch (e) {
|
|
if (e.errno !== ERRNO_CODES.ENOENT) {
|
|
throw e;
|
|
}
|
|
FS.mkdirTree(dir);
|
|
}
|
|
}
|
|
|
|
GodotFS._mount_points.forEach(function(path) {
|
|
createRecursive(path);
|
|
FS.mount(IDBFS, {}, path);
|
|
});
|
|
return new Promise(function(resolve, reject) {
|
|
FS.syncfs(true, function(err) {
|
|
if (err) {
|
|
GodotFS._mount_points = [];
|
|
GodotFS._idbfs = false;
|
|
console.log("IndexedDB not available: " + err.message);
|
|
} else {
|
|
GodotFS._idbfs = true;
|
|
}
|
|
resolve(err);
|
|
});
|
|
});
|
|
},
|
|
|
|
// Deinit godot file system, making sure to unmount file systems, and close IDBFS(s).
|
|
deinit: function() {
|
|
GodotFS._mount_points.forEach(function(path) {
|
|
try {
|
|
FS.unmount(path);
|
|
} catch (e) {
|
|
console.log("Already unmounted", e);
|
|
}
|
|
if (GodotFS._idbfs && IDBFS.dbs[path]) {
|
|
IDBFS.dbs[path].close();
|
|
delete IDBFS.dbs[path];
|
|
}
|
|
});
|
|
GodotFS._mount_points = [];
|
|
GodotFS._idbfs = false;
|
|
GodotFS._syncing = false;
|
|
},
|
|
|
|
sync: function() {
|
|
if (GodotFS._syncing) {
|
|
err('Already syncing!');
|
|
return Promise.resolve();
|
|
}
|
|
GodotFS._syncing = true;
|
|
return new Promise(function (resolve, reject) {
|
|
FS.syncfs(false, function(error) {
|
|
if (error) {
|
|
err('Failed to save IDB file system: ' + error.message);
|
|
}
|
|
GodotFS._syncing = false;
|
|
resolve(error);
|
|
});
|
|
});
|
|
},
|
|
|
|
// Copies a buffer to the internal file system. Creating directories recursively.
|
|
copy_to_fs: function(path, buffer) {
|
|
const idx = path.lastIndexOf("/");
|
|
let dir = "/";
|
|
if (idx > 0) {
|
|
dir = path.slice(0, idx);
|
|
}
|
|
try {
|
|
FS.stat(dir);
|
|
} catch (e) {
|
|
if (e.errno !== ERRNO_CODES.ENOENT) {
|
|
throw e;
|
|
}
|
|
FS.mkdirTree(dir);
|
|
}
|
|
FS.writeFile(path, new Uint8Array(buffer), {'flags': 'wx+'});
|
|
},
|
|
},
|
|
};
|
|
mergeInto(LibraryManager.library, GodotFS);
|
|
|
|
const GodotOS = {
|
|
$GodotOS__deps: ['$GodotFS'],
|
|
$GodotOS__postset: [
|
|
'Module["request_quit"] = function() { GodotOS.request_quit() };',
|
|
'GodotOS._fs_sync_promise = Promise.resolve();',
|
|
].join(''),
|
|
$GodotOS: {
|
|
|
|
request_quit: function() {},
|
|
_async_cbs: [],
|
|
_fs_sync_promise: null,
|
|
|
|
get_func: function(ptr) {
|
|
return wasmTable.get(ptr);
|
|
},
|
|
|
|
atexit: function(p_promise_cb) {
|
|
GodotOS._async_cbs.push(p_promise_cb);
|
|
},
|
|
|
|
finish_async: function(callback) {
|
|
GodotOS._fs_sync_promise.then(function(err) {
|
|
const promises = [];
|
|
GodotOS._async_cbs.forEach(function(cb) {
|
|
promises.push(new Promise(cb));
|
|
});
|
|
return Promise.all(promises);
|
|
}).then(function() {
|
|
return GodotFS.sync(); // Final FS sync.
|
|
}).then(function(err) {
|
|
// Always deferred.
|
|
setTimeout(function() {
|
|
callback();
|
|
}, 0);
|
|
});
|
|
},
|
|
|
|
allocString: function(p_str) {
|
|
const length = lengthBytesUTF8(p_str)+1;
|
|
const c_str = _malloc(length);
|
|
stringToUTF8(p_str, c_str, length);
|
|
return c_str;
|
|
},
|
|
|
|
allocStringArray: function(strings) {
|
|
const size = strings.length;
|
|
const c_ptr = _malloc(size * 4);
|
|
for (let i = 0; i < size; i++) {
|
|
HEAP32[(c_ptr >> 2) + i] = GodotOS.allocString(strings[i]);
|
|
}
|
|
return c_ptr;
|
|
},
|
|
|
|
freeStringArray: function(c_ptr, size) {
|
|
for (let i = 0; i < size; i++) {
|
|
_free(HEAP32[(c_ptr >> 2) + i]);
|
|
}
|
|
_free(c_ptr);
|
|
},
|
|
|
|
heapSub: function(heap, ptr, size) {
|
|
const bytes = heap.BYTES_PER_ELEMENT;
|
|
return heap.subarray(ptr / bytes, ptr / bytes + size);
|
|
},
|
|
|
|
heapCopy: function(heap, ptr, size) {
|
|
const bytes = heap.BYTES_PER_ELEMENT;
|
|
return heap.slice(ptr / bytes, ptr / bytes + size);
|
|
},
|
|
},
|
|
|
|
godot_js_os_finish_async: function(p_callback) {
|
|
const func = GodotOS.get_func(p_callback);
|
|
GodotOS.finish_async(func);
|
|
},
|
|
|
|
godot_js_os_request_quit_cb: function(p_callback) {
|
|
GodotOS.request_quit = GodotOS.get_func(p_callback);
|
|
},
|
|
|
|
godot_js_os_fs_is_persistent: function() {
|
|
return GodotFS.is_persistent();
|
|
},
|
|
|
|
godot_js_os_fs_sync: function(callback) {
|
|
const func = GodotOS.get_func(callback);
|
|
GodotOS._fs_sync_promise = GodotFS.sync();
|
|
GodotOS._fs_sync_promise.then(function(err) {
|
|
func();
|
|
});
|
|
},
|
|
|
|
godot_js_os_execute: function(p_json) {
|
|
const json_args = UTF8ToString(p_json);
|
|
const args = JSON.parse(json_args);
|
|
if (GodotConfig.on_execute) {
|
|
GodotConfig.on_execute(args);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
},
|
|
|
|
godot_js_os_shell_open: function(p_uri) {
|
|
window.open(UTF8ToString(p_uri), '_blank');
|
|
},
|
|
};
|
|
|
|
autoAddDeps(GodotOS, '$GodotOS');
|
|
mergeInto(LibraryManager.library, GodotOS);
|