diff options
Diffstat (limited to 'platform/javascript/js/libs')
| -rw-r--r-- | platform/javascript/js/libs/audio.worklet.js | 211 | ||||
| -rw-r--r-- | platform/javascript/js/libs/library_godot_audio.js | 484 | ||||
| -rw-r--r-- | platform/javascript/js/libs/library_godot_display.js | 754 | ||||
| -rw-r--r-- | platform/javascript/js/libs/library_godot_fetch.js | 247 | ||||
| -rw-r--r-- | platform/javascript/js/libs/library_godot_input.js | 549 | ||||
| -rw-r--r-- | platform/javascript/js/libs/library_godot_javascript_singleton.js | 346 | ||||
| -rw-r--r-- | platform/javascript/js/libs/library_godot_os.js | 427 | ||||
| -rw-r--r-- | platform/javascript/js/libs/library_godot_runtime.js | 134 |
8 files changed, 0 insertions, 3152 deletions
diff --git a/platform/javascript/js/libs/audio.worklet.js b/platform/javascript/js/libs/audio.worklet.js deleted file mode 100644 index ea4d8cb221..0000000000 --- a/platform/javascript/js/libs/audio.worklet.js +++ /dev/null @@ -1,211 +0,0 @@ -/*************************************************************************/ -/* audio.worklet.js */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2022 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. */ -/*************************************************************************/ - -class RingBuffer { - constructor(p_buffer, p_state, p_threads) { - this.buffer = p_buffer; - this.avail = p_state; - this.threads = p_threads; - this.rpos = 0; - this.wpos = 0; - } - - data_left() { - return this.threads ? Atomics.load(this.avail, 0) : this.avail; - } - - space_left() { - return this.buffer.length - this.data_left(); - } - - read(output) { - const size = this.buffer.length; - let from = 0; - let to_write = output.length; - if (this.rpos + to_write > size) { - const high = size - this.rpos; - output.set(this.buffer.subarray(this.rpos, size)); - from = high; - to_write -= high; - this.rpos = 0; - } - if (to_write) { - output.set(this.buffer.subarray(this.rpos, this.rpos + to_write), from); - } - this.rpos += to_write; - if (this.threads) { - Atomics.add(this.avail, 0, -output.length); - Atomics.notify(this.avail, 0); - } else { - this.avail -= output.length; - } - } - - write(p_buffer) { - const to_write = p_buffer.length; - const mw = this.buffer.length - this.wpos; - if (mw >= to_write) { - this.buffer.set(p_buffer, this.wpos); - this.wpos += to_write; - if (mw === to_write) { - this.wpos = 0; - } - } else { - const high = p_buffer.subarray(0, mw); - const low = p_buffer.subarray(mw); - this.buffer.set(high, this.wpos); - this.buffer.set(low); - this.wpos = low.length; - } - if (this.threads) { - Atomics.add(this.avail, 0, to_write); - Atomics.notify(this.avail, 0); - } else { - this.avail += to_write; - } - } -} - -class GodotProcessor extends AudioWorkletProcessor { - constructor() { - super(); - this.threads = false; - this.running = true; - this.lock = null; - this.notifier = null; - this.output = null; - this.output_buffer = new Float32Array(); - this.input = null; - this.input_buffer = new Float32Array(); - this.port.onmessage = (event) => { - const cmd = event.data['cmd']; - const data = event.data['data']; - this.parse_message(cmd, data); - }; - } - - process_notify() { - if (this.notifier) { - Atomics.add(this.notifier, 0, 1); - Atomics.notify(this.notifier, 0); - } - } - - parse_message(p_cmd, p_data) { - if (p_cmd === 'start' && p_data) { - const state = p_data[0]; - let idx = 0; - this.threads = true; - this.lock = state.subarray(idx, ++idx); - this.notifier = state.subarray(idx, ++idx); - const avail_in = state.subarray(idx, ++idx); - const avail_out = state.subarray(idx, ++idx); - this.input = new RingBuffer(p_data[1], avail_in, true); - this.output = new RingBuffer(p_data[2], avail_out, true); - } else if (p_cmd === 'stop') { - this.running = false; - this.output = null; - this.input = null; - } else if (p_cmd === 'start_nothreads') { - this.output = new RingBuffer(p_data[0], p_data[0].length, false); - } else if (p_cmd === 'chunk') { - this.output.write(p_data); - } - } - - static array_has_data(arr) { - return arr.length && arr[0].length && arr[0][0].length; - } - - process(inputs, outputs, parameters) { - if (!this.running) { - return false; // Stop processing. - } - if (this.output === null) { - return true; // Not ready yet, keep processing. - } - const process_input = GodotProcessor.array_has_data(inputs); - if (process_input) { - const input = inputs[0]; - const chunk = input[0].length * input.length; - if (this.input_buffer.length !== chunk) { - this.input_buffer = new Float32Array(chunk); - } - if (!this.threads) { - GodotProcessor.write_input(this.input_buffer, input); - this.port.postMessage({ 'cmd': 'input', 'data': this.input_buffer }); - } else if (this.input.space_left() >= chunk) { - GodotProcessor.write_input(this.input_buffer, input); - this.input.write(this.input_buffer); - } else { - this.port.postMessage('Input buffer is full! Skipping input frame.'); - } - } - const process_output = GodotProcessor.array_has_data(outputs); - if (process_output) { - const output = outputs[0]; - const chunk = output[0].length * output.length; - if (this.output_buffer.length !== chunk) { - this.output_buffer = new Float32Array(chunk); - } - if (this.output.data_left() >= chunk) { - this.output.read(this.output_buffer); - GodotProcessor.write_output(output, this.output_buffer); - if (!this.threads) { - this.port.postMessage({ 'cmd': 'read', 'data': chunk }); - } - } else { - this.port.postMessage('Output buffer has not enough frames! Skipping output frame.'); - } - } - this.process_notify(); - return true; - } - - static write_output(dest, source) { - const channels = dest.length; - for (let ch = 0; ch < channels; ch++) { - for (let sample = 0; sample < dest[ch].length; sample++) { - dest[ch][sample] = source[sample * channels + ch]; - } - } - } - - static write_input(dest, source) { - const channels = source.length; - for (let ch = 0; ch < channels; ch++) { - for (let sample = 0; sample < source[ch].length; sample++) { - dest[sample * channels + ch] = source[ch][sample]; - } - } - } -} - -registerProcessor('godot-processor', GodotProcessor); diff --git a/platform/javascript/js/libs/library_godot_audio.js b/platform/javascript/js/libs/library_godot_audio.js deleted file mode 100644 index 756c1ac595..0000000000 --- a/platform/javascript/js/libs/library_godot_audio.js +++ /dev/null @@ -1,484 +0,0 @@ -/*************************************************************************/ -/* library_godot_audio.js */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2022 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 GodotAudio = { - $GodotAudio__deps: ['$GodotRuntime', '$GodotOS'], - $GodotAudio: { - ctx: null, - input: null, - driver: null, - interval: 0, - - init: function (mix_rate, latency, onstatechange, onlatencyupdate) { - const opts = {}; - // If mix_rate is 0, let the browser choose. - if (mix_rate) { - opts['sampleRate'] = mix_rate; - } - // Do not specify, leave 'interactive' for good performance. - // opts['latencyHint'] = latency / 1000; - const ctx = new (window.AudioContext || window.webkitAudioContext)(opts); - GodotAudio.ctx = ctx; - ctx.onstatechange = function () { - let state = 0; - switch (ctx.state) { - case 'suspended': - state = 0; - break; - case 'running': - state = 1; - break; - case 'closed': - state = 2; - break; - - // no default - } - onstatechange(state); - }; - ctx.onstatechange(); // Immediately notify state. - // Update computed latency - GodotAudio.interval = setInterval(function () { - let computed_latency = 0; - if (ctx.baseLatency) { - computed_latency += GodotAudio.ctx.baseLatency; - } - if (ctx.outputLatency) { - computed_latency += GodotAudio.ctx.outputLatency; - } - onlatencyupdate(computed_latency); - }, 1000); - GodotOS.atexit(GodotAudio.close_async); - return ctx.destination.channelCount; - }, - - create_input: function (callback) { - if (GodotAudio.input) { - return 0; // Already started. - } - function gotMediaInput(stream) { - try { - GodotAudio.input = GodotAudio.ctx.createMediaStreamSource(stream); - callback(GodotAudio.input); - } catch (e) { - GodotRuntime.error('Failed creaating input.', e); - } - } - if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) { - navigator.mediaDevices.getUserMedia({ - 'audio': true, - }).then(gotMediaInput, function (e) { - GodotRuntime.error('Error getting user media.', e); - }); - } else { - if (!navigator.getUserMedia) { - navigator.getUserMedia = navigator.webkitGetUserMedia || navigator.mozGetUserMedia; - } - if (!navigator.getUserMedia) { - GodotRuntime.error('getUserMedia not available.'); - return 1; - } - navigator.getUserMedia({ - 'audio': true, - }, gotMediaInput, function (e) { - GodotRuntime.print(e); - }); - } - return 0; - }, - - close_async: function (resolve, reject) { - const ctx = GodotAudio.ctx; - GodotAudio.ctx = null; - // Audio was not initialized. - if (!ctx) { - resolve(); - return; - } - // Remove latency callback - if (GodotAudio.interval) { - clearInterval(GodotAudio.interval); - GodotAudio.interval = 0; - } - // Disconnect input, if it was started. - if (GodotAudio.input) { - GodotAudio.input.disconnect(); - GodotAudio.input = null; - } - // Disconnect output - let closed = Promise.resolve(); - if (GodotAudio.driver) { - closed = GodotAudio.driver.close(); - } - closed.then(function () { - return ctx.close(); - }).then(function () { - ctx.onstatechange = null; - resolve(); - }).catch(function (e) { - ctx.onstatechange = null; - GodotRuntime.error('Error closing AudioContext', e); - resolve(); - }); - }, - }, - - godot_audio_is_available__sig: 'i', - godot_audio_is_available__proxy: 'sync', - godot_audio_is_available: function () { - if (!(window.AudioContext || window.webkitAudioContext)) { - return 0; - } - return 1; - }, - - godot_audio_has_worklet__sig: 'i', - godot_audio_has_worklet: function () { - return (GodotAudio.ctx && GodotAudio.ctx.audioWorklet) ? 1 : 0; - }, - - godot_audio_has_script_processor__sig: 'i', - godot_audio_has_script_processor: function () { - return (GodotAudio.ctx && GodotAudio.ctx.createScriptProcessor) ? 1 : 0; - }, - - godot_audio_init__sig: 'iiiii', - godot_audio_init: function (p_mix_rate, p_latency, p_state_change, p_latency_update) { - const statechange = GodotRuntime.get_func(p_state_change); - const latencyupdate = GodotRuntime.get_func(p_latency_update); - const mix_rate = GodotRuntime.getHeapValue(p_mix_rate, 'i32'); - const channels = GodotAudio.init(mix_rate, p_latency, statechange, latencyupdate); - GodotRuntime.setHeapValue(p_mix_rate, GodotAudio.ctx.sampleRate, 'i32'); - return channels; - }, - - godot_audio_resume__sig: 'v', - godot_audio_resume: function () { - if (GodotAudio.ctx && GodotAudio.ctx.state !== 'running') { - GodotAudio.ctx.resume(); - } - }, - - godot_audio_capture_start__proxy: 'sync', - godot_audio_capture_start__sig: 'i', - godot_audio_capture_start: function () { - return GodotAudio.create_input(function (input) { - input.connect(GodotAudio.driver.get_node()); - }); - }, - - godot_audio_capture_stop__proxy: 'sync', - godot_audio_capture_stop__sig: 'v', - godot_audio_capture_stop: function () { - if (GodotAudio.input) { - const tracks = GodotAudio.input['mediaStream']['getTracks'](); - for (let i = 0; i < tracks.length; i++) { - tracks[i]['stop'](); - } - GodotAudio.input.disconnect(); - GodotAudio.input = null; - } - }, -}; - -autoAddDeps(GodotAudio, '$GodotAudio'); -mergeInto(LibraryManager.library, GodotAudio); - -/** - * The AudioWorklet API driver, used when threads are available. - */ -const GodotAudioWorklet = { - $GodotAudioWorklet__deps: ['$GodotAudio', '$GodotConfig'], - $GodotAudioWorklet: { - promise: null, - worklet: null, - ring_buffer: null, - - create: function (channels) { - const path = GodotConfig.locate_file('godot.audio.worklet.js'); - GodotAudioWorklet.promise = GodotAudio.ctx.audioWorklet.addModule(path).then(function () { - GodotAudioWorklet.worklet = new AudioWorkletNode( - GodotAudio.ctx, - 'godot-processor', - { - 'outputChannelCount': [channels], - } - ); - return Promise.resolve(); - }); - GodotAudio.driver = GodotAudioWorklet; - }, - - start: function (in_buf, out_buf, state) { - GodotAudioWorklet.promise.then(function () { - const node = GodotAudioWorklet.worklet; - node.connect(GodotAudio.ctx.destination); - node.port.postMessage({ - 'cmd': 'start', - 'data': [state, in_buf, out_buf], - }); - node.port.onmessage = function (event) { - GodotRuntime.error(event.data); - }; - }); - }, - - start_no_threads: function (p_out_buf, p_out_size, out_callback, p_in_buf, p_in_size, in_callback) { - function RingBuffer() { - let wpos = 0; - let rpos = 0; - let pending_samples = 0; - const wbuf = new Float32Array(p_out_size); - - function send(port) { - if (pending_samples === 0) { - return; - } - const buffer = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size); - const size = buffer.length; - const tot_sent = pending_samples; - out_callback(wpos, pending_samples); - if (wpos + pending_samples >= size) { - const high = size - wpos; - wbuf.set(buffer.subarray(wpos, size)); - pending_samples -= high; - wpos = 0; - } - if (pending_samples > 0) { - wbuf.set(buffer.subarray(wpos, wpos + pending_samples), tot_sent - pending_samples); - } - port.postMessage({ 'cmd': 'chunk', 'data': wbuf.subarray(0, tot_sent) }); - wpos += pending_samples; - pending_samples = 0; - } - this.receive = function (recv_buf) { - const buffer = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size); - const from = rpos; - let to_write = recv_buf.length; - let high = 0; - if (rpos + to_write >= p_in_size) { - high = p_in_size - rpos; - buffer.set(recv_buf.subarray(0, high), rpos); - to_write -= high; - rpos = 0; - } - if (to_write) { - buffer.set(recv_buf.subarray(high, to_write), rpos); - } - in_callback(from, recv_buf.length); - rpos += to_write; - }; - this.consumed = function (size, port) { - pending_samples += size; - send(port); - }; - } - GodotAudioWorklet.ring_buffer = new RingBuffer(); - GodotAudioWorklet.promise.then(function () { - const node = GodotAudioWorklet.worklet; - const buffer = GodotRuntime.heapSlice(HEAPF32, p_out_buf, p_out_size); - node.connect(GodotAudio.ctx.destination); - node.port.postMessage({ - 'cmd': 'start_nothreads', - 'data': [buffer, p_in_size], - }); - node.port.onmessage = function (event) { - if (!GodotAudioWorklet.worklet) { - return; - } - if (event.data['cmd'] === 'read') { - const read = event.data['data']; - GodotAudioWorklet.ring_buffer.consumed(read, GodotAudioWorklet.worklet.port); - } else if (event.data['cmd'] === 'input') { - const buf = event.data['data']; - if (buf.length > p_in_size) { - GodotRuntime.error('Input chunk is too big'); - return; - } - GodotAudioWorklet.ring_buffer.receive(buf); - } else { - GodotRuntime.error(event.data); - } - }; - }); - }, - - get_node: function () { - return GodotAudioWorklet.worklet; - }, - - close: function () { - return new Promise(function (resolve, reject) { - if (GodotAudioWorklet.promise === null) { - return; - } - GodotAudioWorklet.promise.then(function () { - GodotAudioWorklet.worklet.port.postMessage({ - 'cmd': 'stop', - 'data': null, - }); - GodotAudioWorklet.worklet.disconnect(); - GodotAudioWorklet.worklet = null; - GodotAudioWorklet.promise = null; - resolve(); - }).catch(function (err) { /* aborted? */ }); - }); - }, - }, - - godot_audio_worklet_create__sig: 'ii', - godot_audio_worklet_create: function (channels) { - try { - GodotAudioWorklet.create(channels); - } catch (e) { - GodotRuntime.error('Error starting AudioDriverWorklet', e); - return 1; - } - return 0; - }, - - godot_audio_worklet_start__sig: 'viiiii', - godot_audio_worklet_start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, p_state) { - const out_buffer = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size); - const in_buffer = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size); - const state = GodotRuntime.heapSub(HEAP32, p_state, 4); - GodotAudioWorklet.start(in_buffer, out_buffer, state); - }, - - godot_audio_worklet_start_no_threads__sig: 'viiiiii', - godot_audio_worklet_start_no_threads: function (p_out_buf, p_out_size, p_out_callback, p_in_buf, p_in_size, p_in_callback) { - const out_callback = GodotRuntime.get_func(p_out_callback); - const in_callback = GodotRuntime.get_func(p_in_callback); - GodotAudioWorklet.start_no_threads(p_out_buf, p_out_size, out_callback, p_in_buf, p_in_size, in_callback); - }, - - godot_audio_worklet_state_wait__sig: 'iiii', - godot_audio_worklet_state_wait: function (p_state, p_idx, p_expected, p_timeout) { - Atomics.wait(HEAP32, (p_state >> 2) + p_idx, p_expected, p_timeout); - return Atomics.load(HEAP32, (p_state >> 2) + p_idx); - }, - - godot_audio_worklet_state_add__sig: 'iiii', - godot_audio_worklet_state_add: function (p_state, p_idx, p_value) { - return Atomics.add(HEAP32, (p_state >> 2) + p_idx, p_value); - }, - - godot_audio_worklet_state_get__sig: 'iii', - godot_audio_worklet_state_get: function (p_state, p_idx) { - return Atomics.load(HEAP32, (p_state >> 2) + p_idx); - }, -}; - -autoAddDeps(GodotAudioWorklet, '$GodotAudioWorklet'); -mergeInto(LibraryManager.library, GodotAudioWorklet); - -/* - * The deprecated ScriptProcessorNode API, used when threads are disabled. - */ -const GodotAudioScript = { - $GodotAudioScript__deps: ['$GodotAudio'], - $GodotAudioScript: { - script: null, - - create: function (buffer_length, channel_count) { - GodotAudioScript.script = GodotAudio.ctx.createScriptProcessor(buffer_length, 2, channel_count); - GodotAudio.driver = GodotAudioScript; - return GodotAudioScript.script.bufferSize; - }, - - start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, onprocess) { - GodotAudioScript.script.onaudioprocess = function (event) { - // Read input - const inb = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size); - const input = event.inputBuffer; - if (GodotAudio.input) { - const inlen = input.getChannelData(0).length; - for (let ch = 0; ch < 2; ch++) { - const data = input.getChannelData(ch); - for (let s = 0; s < inlen; s++) { - inb[s * 2 + ch] = data[s]; - } - } - } - - // Let Godot process the input/output. - onprocess(); - - // Write the output. - const outb = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size); - const output = event.outputBuffer; - const channels = output.numberOfChannels; - for (let ch = 0; ch < channels; ch++) { - const data = output.getChannelData(ch); - // Loop through samples and assign computed values. - for (let sample = 0; sample < data.length; sample++) { - data[sample] = outb[sample * channels + ch]; - } - } - }; - GodotAudioScript.script.connect(GodotAudio.ctx.destination); - }, - - get_node: function () { - return GodotAudioScript.script; - }, - - close: function () { - return new Promise(function (resolve, reject) { - GodotAudioScript.script.disconnect(); - GodotAudioScript.script.onaudioprocess = null; - GodotAudioScript.script = null; - resolve(); - }); - }, - }, - - godot_audio_script_create__sig: 'iii', - godot_audio_script_create: function (buffer_length, channel_count) { - const buf_len = GodotRuntime.getHeapValue(buffer_length, 'i32'); - try { - const out_len = GodotAudioScript.create(buf_len, channel_count); - GodotRuntime.setHeapValue(buffer_length, out_len, 'i32'); - } catch (e) { - GodotRuntime.error('Error starting AudioDriverScriptProcessor', e); - return 1; - } - return 0; - }, - - godot_audio_script_start__sig: 'viiiii', - godot_audio_script_start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, p_cb) { - const onprocess = GodotRuntime.get_func(p_cb); - GodotAudioScript.start(p_in_buf, p_in_size, p_out_buf, p_out_size, onprocess); - }, -}; - -autoAddDeps(GodotAudioScript, '$GodotAudioScript'); -mergeInto(LibraryManager.library, GodotAudioScript); diff --git a/platform/javascript/js/libs/library_godot_display.js b/platform/javascript/js/libs/library_godot_display.js deleted file mode 100644 index 768eaf9e1d..0000000000 --- a/platform/javascript/js/libs/library_godot_display.js +++ /dev/null @@ -1,754 +0,0 @@ -/*************************************************************************/ -/* library_godot_display.js */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2022 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 GodotDisplayVK = { - - $GodotDisplayVK__deps: ['$GodotRuntime', '$GodotConfig', '$GodotEventListeners'], - $GodotDisplayVK__postset: 'GodotOS.atexit(function(resolve, reject) { GodotDisplayVK.clear(); resolve(); });', - $GodotDisplayVK: { - textinput: null, - textarea: null, - - available: function () { - return GodotConfig.virtual_keyboard && 'ontouchstart' in window; - }, - - init: function (input_cb) { - function create(what) { - const elem = document.createElement(what); - elem.style.display = 'none'; - elem.style.position = 'absolute'; - elem.style.zIndex = '-1'; - elem.style.background = 'transparent'; - elem.style.padding = '0px'; - elem.style.margin = '0px'; - elem.style.overflow = 'hidden'; - elem.style.width = '0px'; - elem.style.height = '0px'; - elem.style.border = '0px'; - elem.style.outline = 'none'; - elem.readonly = true; - elem.disabled = true; - GodotEventListeners.add(elem, 'input', function (evt) { - const c_str = GodotRuntime.allocString(elem.value); - input_cb(c_str, elem.selectionEnd); - GodotRuntime.free(c_str); - }, false); - GodotEventListeners.add(elem, 'blur', function (evt) { - elem.style.display = 'none'; - elem.readonly = true; - elem.disabled = true; - }, false); - GodotConfig.canvas.insertAdjacentElement('beforebegin', elem); - return elem; - } - GodotDisplayVK.textinput = create('input'); - GodotDisplayVK.textarea = create('textarea'); - GodotDisplayVK.updateSize(); - }, - show: function (text, type, start, end) { - if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) { - return; - } - if (GodotDisplayVK.textinput.style.display !== '' || GodotDisplayVK.textarea.style.display !== '') { - GodotDisplayVK.hide(); - } - GodotDisplayVK.updateSize(); - - let elem = GodotDisplayVK.textinput; - switch (type) { - case 0: // KEYBOARD_TYPE_DEFAULT - elem.type = 'text'; - elem.inputmode = ''; - break; - case 1: // KEYBOARD_TYPE_MULTILINE - elem = GodotDisplayVK.textarea; - break; - case 2: // KEYBOARD_TYPE_NUMBER - elem.type = 'text'; - elem.inputmode = 'numeric'; - break; - case 3: // KEYBOARD_TYPE_NUMBER_DECIMAL - elem.type = 'text'; - elem.inputmode = 'decimal'; - break; - case 4: // KEYBOARD_TYPE_PHONE - elem.type = 'tel'; - elem.inputmode = ''; - break; - case 5: // KEYBOARD_TYPE_EMAIL_ADDRESS - elem.type = 'email'; - elem.inputmode = ''; - break; - case 6: // KEYBOARD_TYPE_PASSWORD - elem.type = 'password'; - elem.inputmode = ''; - break; - case 7: // KEYBOARD_TYPE_URL - elem.type = 'url'; - elem.inputmode = ''; - break; - default: - elem.type = 'text'; - elem.inputmode = ''; - break; - } - - elem.readonly = false; - elem.disabled = false; - elem.value = text; - elem.style.display = 'block'; - elem.focus(); - elem.setSelectionRange(start, end); - }, - hide: function () { - if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) { - return; - } - [GodotDisplayVK.textinput, GodotDisplayVK.textarea].forEach(function (elem) { - elem.blur(); - elem.style.display = 'none'; - elem.value = ''; - }); - }, - updateSize: function () { - if (!GodotDisplayVK.textinput || !GodotDisplayVK.textarea) { - return; - } - const rect = GodotConfig.canvas.getBoundingClientRect(); - function update(elem) { - elem.style.left = `${rect.left}px`; - elem.style.top = `${rect.top}px`; - elem.style.width = `${rect.width}px`; - elem.style.height = `${rect.height}px`; - } - update(GodotDisplayVK.textinput); - update(GodotDisplayVK.textarea); - }, - clear: function () { - if (GodotDisplayVK.textinput) { - GodotDisplayVK.textinput.remove(); - GodotDisplayVK.textinput = null; - } - if (GodotDisplayVK.textarea) { - GodotDisplayVK.textarea.remove(); - GodotDisplayVK.textarea = null; - } - }, - }, -}; -mergeInto(LibraryManager.library, GodotDisplayVK); - -/* - * Display server cursor helper. - * Keeps track of cursor status and custom shapes. - */ -const GodotDisplayCursor = { - $GodotDisplayCursor__deps: ['$GodotOS', '$GodotConfig'], - $GodotDisplayCursor__postset: 'GodotOS.atexit(function(resolve, reject) { GodotDisplayCursor.clear(); resolve(); });', - $GodotDisplayCursor: { - shape: 'auto', - visible: true, - cursors: {}, - set_style: function (style) { - GodotConfig.canvas.style.cursor = style; - }, - set_shape: function (shape) { - GodotDisplayCursor.shape = shape; - let css = shape; - if (shape in GodotDisplayCursor.cursors) { - const c = GodotDisplayCursor.cursors[shape]; - css = `url("${c.url}") ${c.x} ${c.y}, auto`; - } - if (GodotDisplayCursor.visible) { - GodotDisplayCursor.set_style(css); - } - }, - clear: function () { - GodotDisplayCursor.set_style(''); - GodotDisplayCursor.shape = 'auto'; - GodotDisplayCursor.visible = true; - Object.keys(GodotDisplayCursor.cursors).forEach(function (key) { - URL.revokeObjectURL(GodotDisplayCursor.cursors[key]); - delete GodotDisplayCursor.cursors[key]; - }); - }, - lockPointer: function () { - const canvas = GodotConfig.canvas; - if (canvas.requestPointerLock) { - canvas.requestPointerLock(); - } - }, - releasePointer: function () { - if (document.exitPointerLock) { - document.exitPointerLock(); - } - }, - isPointerLocked: function () { - return document.pointerLockElement === GodotConfig.canvas; - }, - }, -}; -mergeInto(LibraryManager.library, GodotDisplayCursor); - -const GodotDisplayScreen = { - $GodotDisplayScreen__deps: ['$GodotConfig', '$GodotOS', '$GL', 'emscripten_webgl_get_current_context'], - $GodotDisplayScreen: { - desired_size: [0, 0], - hidpi: true, - getPixelRatio: function () { - return GodotDisplayScreen.hidpi ? window.devicePixelRatio || 1 : 1; - }, - isFullscreen: function () { - const elem = document.fullscreenElement || document.mozFullscreenElement - || document.webkitFullscreenElement || document.msFullscreenElement; - if (elem) { - return elem === GodotConfig.canvas; - } - // But maybe knowing the element is not supported. - return document.fullscreen || document.mozFullScreen - || document.webkitIsFullscreen; - }, - hasFullscreen: function () { - return document.fullscreenEnabled || document.mozFullScreenEnabled - || document.webkitFullscreenEnabled; - }, - requestFullscreen: function () { - if (!GodotDisplayScreen.hasFullscreen()) { - return 1; - } - const canvas = GodotConfig.canvas; - try { - const promise = (canvas.requestFullscreen || canvas.msRequestFullscreen - || canvas.mozRequestFullScreen || canvas.mozRequestFullscreen - || canvas.webkitRequestFullscreen - ).call(canvas); - // Some browsers (Safari) return undefined. - // For the standard ones, we need to catch it. - if (promise) { - promise.catch(function () { - // nothing to do. - }); - } - } catch (e) { - return 1; - } - return 0; - }, - exitFullscreen: function () { - if (!GodotDisplayScreen.isFullscreen()) { - return 0; - } - try { - const promise = document.exitFullscreen(); - if (promise) { - promise.catch(function () { - // nothing to do. - }); - } - } catch (e) { - return 1; - } - return 0; - }, - _updateGL: function () { - const gl_context_handle = _emscripten_webgl_get_current_context(); // eslint-disable-line no-undef - const gl = GL.getContext(gl_context_handle); - if (gl) { - GL.resizeOffscreenFramebuffer(gl); - } - }, - updateSize: function () { - const isFullscreen = GodotDisplayScreen.isFullscreen(); - const wantsFullWindow = GodotConfig.canvas_resize_policy === 2; - const noResize = GodotConfig.canvas_resize_policy === 0; - const wwidth = GodotDisplayScreen.desired_size[0]; - const wheight = GodotDisplayScreen.desired_size[1]; - const canvas = GodotConfig.canvas; - let width = wwidth; - let height = wheight; - if (noResize) { - // Don't resize canvas, just update GL if needed. - if (canvas.width !== width || canvas.height !== height) { - GodotDisplayScreen.desired_size = [canvas.width, canvas.height]; - GodotDisplayScreen._updateGL(); - return 1; - } - return 0; - } - const scale = GodotDisplayScreen.getPixelRatio(); - if (isFullscreen || wantsFullWindow) { - // We need to match screen size. - width = window.innerWidth * scale; - height = window.innerHeight * scale; - } - const csw = `${width / scale}px`; - const csh = `${height / scale}px`; - if (canvas.style.width !== csw || canvas.style.height !== csh || canvas.width !== width || canvas.height !== height) { - // Size doesn't match. - // Resize canvas, set correct CSS pixel size, update GL. - canvas.width = width; - canvas.height = height; - canvas.style.width = csw; - canvas.style.height = csh; - GodotDisplayScreen._updateGL(); - return 1; - } - return 0; - }, - }, -}; -mergeInto(LibraryManager.library, GodotDisplayScreen); - -/** - * Display server interface. - * - * Exposes all the functions needed by DisplayServer implementation. - */ -const GodotDisplay = { - $GodotDisplay__deps: ['$GodotConfig', '$GodotRuntime', '$GodotDisplayCursor', '$GodotEventListeners', '$GodotDisplayScreen', '$GodotDisplayVK'], - $GodotDisplay: { - window_icon: '', - getDPI: function () { - // devicePixelRatio is given in dppx - // https://drafts.csswg.org/css-values/#resolution - // > due to the 1:96 fixed ratio of CSS *in* to CSS *px*, 1dppx is equivalent to 96dpi. - const dpi = Math.round(window.devicePixelRatio * 96); - return dpi >= 96 ? dpi : 96; - }, - }, - - godot_js_display_is_swap_ok_cancel__sig: 'i', - godot_js_display_is_swap_ok_cancel: function () { - const win = (['Windows', 'Win64', 'Win32', 'WinCE']); - const plat = navigator.platform || ''; - if (win.indexOf(plat) !== -1) { - return 1; - } - return 0; - }, - - godot_js_tts_is_speaking__sig: 'i', - godot_js_tts_is_speaking: function () { - return window.speechSynthesis.speaking; - }, - - godot_js_tts_is_paused__sig: 'i', - godot_js_tts_is_paused: function () { - return window.speechSynthesis.paused; - }, - - godot_js_tts_get_voices__sig: 'vi', - godot_js_tts_get_voices: function (p_callback) { - const func = GodotRuntime.get_func(p_callback); - try { - const arr = []; - const voices = window.speechSynthesis.getVoices(); - for (let i = 0; i < voices.length; i++) { - arr.push(`${voices[i].lang};${voices[i].name}`); - } - const c_ptr = GodotRuntime.allocStringArray(arr); - func(arr.length, c_ptr); - GodotRuntime.freeStringArray(c_ptr, arr.length); - } catch (e) { - // Fail graciously. - } - }, - - godot_js_tts_speak__sig: 'viiiffii', - godot_js_tts_speak: function (p_text, p_voice, p_volume, p_pitch, p_rate, p_utterance_id, p_callback) { - const func = GodotRuntime.get_func(p_callback); - - function listener_end(evt) { - evt.currentTarget.cb(1 /*TTS_UTTERANCE_ENDED*/, evt.currentTarget.id, 0); - } - - function listener_start(evt) { - evt.currentTarget.cb(0 /*TTS_UTTERANCE_STARTED*/, evt.currentTarget.id, 0); - } - - function listener_error(evt) { - evt.currentTarget.cb(2 /*TTS_UTTERANCE_CANCELED*/, evt.currentTarget.id, 0); - } - - function listener_bound(evt) { - evt.currentTarget.cb(3 /*TTS_UTTERANCE_BOUNDARY*/, evt.currentTarget.id, evt.charIndex); - } - - const utterance = new SpeechSynthesisUtterance(GodotRuntime.parseString(p_text)); - utterance.rate = p_rate; - utterance.pitch = p_pitch; - utterance.volume = p_volume / 100.0; - utterance.addEventListener('end', listener_end); - utterance.addEventListener('start', listener_start); - utterance.addEventListener('error', listener_error); - utterance.addEventListener('boundary', listener_bound); - utterance.id = p_utterance_id; - utterance.cb = func; - const voice = GodotRuntime.parseString(p_voice); - const voices = window.speechSynthesis.getVoices(); - for (let i = 0; i < voices.length; i++) { - if (voices[i].name === voice) { - utterance.voice = voices[i]; - break; - } - } - window.speechSynthesis.resume(); - window.speechSynthesis.speak(utterance); - }, - - godot_js_tts_pause__sig: 'v', - godot_js_tts_pause: function () { - window.speechSynthesis.pause(); - }, - - godot_js_tts_resume__sig: 'v', - godot_js_tts_resume: function () { - window.speechSynthesis.resume(); - }, - - godot_js_tts_stop__sig: 'v', - godot_js_tts_stop: function () { - window.speechSynthesis.cancel(); - window.speechSynthesis.resume(); - }, - - godot_js_display_alert__sig: 'vi', - godot_js_display_alert: function (p_text) { - window.alert(GodotRuntime.parseString(p_text)); // eslint-disable-line no-alert - }, - - godot_js_display_screen_dpi_get__sig: 'i', - godot_js_display_screen_dpi_get: function () { - return GodotDisplay.getDPI(); - }, - - godot_js_display_pixel_ratio_get__sig: 'f', - godot_js_display_pixel_ratio_get: function () { - return GodotDisplayScreen.getPixelRatio(); - }, - - godot_js_display_fullscreen_request__sig: 'i', - godot_js_display_fullscreen_request: function () { - return GodotDisplayScreen.requestFullscreen(); - }, - - godot_js_display_fullscreen_exit__sig: 'i', - godot_js_display_fullscreen_exit: function () { - return GodotDisplayScreen.exitFullscreen(); - }, - - godot_js_display_desired_size_set__sig: 'vii', - godot_js_display_desired_size_set: function (width, height) { - GodotDisplayScreen.desired_size = [width, height]; - GodotDisplayScreen.updateSize(); - }, - - godot_js_display_size_update__sig: 'i', - godot_js_display_size_update: function () { - const updated = GodotDisplayScreen.updateSize(); - if (updated) { - GodotDisplayVK.updateSize(); - } - return updated; - }, - - godot_js_display_screen_size_get__sig: 'vii', - godot_js_display_screen_size_get: function (width, height) { - const scale = GodotDisplayScreen.getPixelRatio(); - GodotRuntime.setHeapValue(width, window.screen.width * scale, 'i32'); - GodotRuntime.setHeapValue(height, window.screen.height * scale, 'i32'); - }, - - godot_js_display_window_size_get__sig: 'vii', - godot_js_display_window_size_get: function (p_width, p_height) { - GodotRuntime.setHeapValue(p_width, GodotConfig.canvas.width, 'i32'); - GodotRuntime.setHeapValue(p_height, GodotConfig.canvas.height, 'i32'); - }, - - godot_js_display_has_webgl__sig: 'ii', - godot_js_display_has_webgl: function (p_version) { - if (p_version !== 1 && p_version !== 2) { - return false; - } - try { - return !!document.createElement('canvas').getContext(p_version === 2 ? 'webgl2' : 'webgl'); - } catch (e) { /* Not available */ } - return false; - }, - - /* - * Canvas - */ - godot_js_display_canvas_focus__sig: 'v', - godot_js_display_canvas_focus: function () { - GodotConfig.canvas.focus(); - }, - - godot_js_display_canvas_is_focused__sig: 'i', - godot_js_display_canvas_is_focused: function () { - return document.activeElement === GodotConfig.canvas; - }, - - /* - * Touchscreen - */ - godot_js_display_touchscreen_is_available__sig: 'i', - godot_js_display_touchscreen_is_available: function () { - return 'ontouchstart' in window; - }, - - /* - * Clipboard - */ - godot_js_display_clipboard_set__sig: 'ii', - godot_js_display_clipboard_set: function (p_text) { - const text = GodotRuntime.parseString(p_text); - if (!navigator.clipboard || !navigator.clipboard.writeText) { - return 1; - } - navigator.clipboard.writeText(text).catch(function (e) { - // Setting OS clipboard is only possible from an input callback. - GodotRuntime.error('Setting OS clipboard is only possible from an input callback for the HTML5 plafrom. Exception:', e); - }); - return 0; - }, - - godot_js_display_clipboard_get__sig: 'ii', - godot_js_display_clipboard_get: function (callback) { - const func = GodotRuntime.get_func(callback); - try { - navigator.clipboard.readText().then(function (result) { - const ptr = GodotRuntime.allocString(result); - func(ptr); - GodotRuntime.free(ptr); - }).catch(function (e) { - // Fail graciously. - }); - } catch (e) { - // Fail graciously. - } - }, - - /* - * Window - */ - godot_js_display_window_title_set__sig: 'vi', - godot_js_display_window_title_set: function (p_data) { - document.title = GodotRuntime.parseString(p_data); - }, - - godot_js_display_window_icon_set__sig: 'vii', - godot_js_display_window_icon_set: function (p_ptr, p_len) { - let link = document.getElementById('-gd-engine-icon'); - if (link === null) { - link = document.createElement('link'); - link.rel = 'icon'; - link.id = '-gd-engine-icon'; - document.head.appendChild(link); - } - const old_icon = GodotDisplay.window_icon; - const png = new Blob([GodotRuntime.heapSlice(HEAPU8, p_ptr, p_len)], { type: 'image/png' }); - GodotDisplay.window_icon = URL.createObjectURL(png); - link.href = GodotDisplay.window_icon; - if (old_icon) { - URL.revokeObjectURL(old_icon); - } - }, - - /* - * Cursor - */ - godot_js_display_cursor_set_visible__sig: 'vi', - godot_js_display_cursor_set_visible: function (p_visible) { - const visible = p_visible !== 0; - if (visible === GodotDisplayCursor.visible) { - return; - } - GodotDisplayCursor.visible = visible; - if (visible) { - GodotDisplayCursor.set_shape(GodotDisplayCursor.shape); - } else { - GodotDisplayCursor.set_style('none'); - } - }, - - godot_js_display_cursor_is_hidden__sig: 'i', - godot_js_display_cursor_is_hidden: function () { - return !GodotDisplayCursor.visible; - }, - - godot_js_display_cursor_set_shape__sig: 'vi', - godot_js_display_cursor_set_shape: function (p_string) { - GodotDisplayCursor.set_shape(GodotRuntime.parseString(p_string)); - }, - - godot_js_display_cursor_set_custom_shape__sig: 'viiiii', - godot_js_display_cursor_set_custom_shape: function (p_shape, p_ptr, p_len, p_hotspot_x, p_hotspot_y) { - const shape = GodotRuntime.parseString(p_shape); - const old_shape = GodotDisplayCursor.cursors[shape]; - if (p_len > 0) { - const png = new Blob([GodotRuntime.heapSlice(HEAPU8, p_ptr, p_len)], { type: 'image/png' }); - const url = URL.createObjectURL(png); - GodotDisplayCursor.cursors[shape] = { - url: url, - x: p_hotspot_x, - y: p_hotspot_y, - }; - } else { - delete GodotDisplayCursor.cursors[shape]; - } - if (shape === GodotDisplayCursor.shape) { - GodotDisplayCursor.set_shape(GodotDisplayCursor.shape); - } - if (old_shape) { - URL.revokeObjectURL(old_shape.url); - } - }, - - godot_js_display_cursor_lock_set__sig: 'vi', - godot_js_display_cursor_lock_set: function (p_lock) { - if (p_lock) { - GodotDisplayCursor.lockPointer(); - } else { - GodotDisplayCursor.releasePointer(); - } - }, - - godot_js_display_cursor_is_locked__sig: 'i', - godot_js_display_cursor_is_locked: function () { - return GodotDisplayCursor.isPointerLocked() ? 1 : 0; - }, - - /* - * Listeners - */ - godot_js_display_fullscreen_cb__sig: 'vi', - godot_js_display_fullscreen_cb: function (callback) { - const canvas = GodotConfig.canvas; - const func = GodotRuntime.get_func(callback); - function change_cb(evt) { - if (evt.target === canvas) { - func(GodotDisplayScreen.isFullscreen()); - } - } - GodotEventListeners.add(document, 'fullscreenchange', change_cb, false); - GodotEventListeners.add(document, 'mozfullscreenchange', change_cb, false); - GodotEventListeners.add(document, 'webkitfullscreenchange', change_cb, false); - }, - - godot_js_display_window_blur_cb__sig: 'vi', - godot_js_display_window_blur_cb: function (callback) { - const func = GodotRuntime.get_func(callback); - GodotEventListeners.add(window, 'blur', function () { - func(); - }, false); - }, - - godot_js_display_notification_cb__sig: 'viiiii', - godot_js_display_notification_cb: function (callback, p_enter, p_exit, p_in, p_out) { - const canvas = GodotConfig.canvas; - const func = GodotRuntime.get_func(callback); - const notif = [p_enter, p_exit, p_in, p_out]; - ['mouseover', 'mouseleave', 'focus', 'blur'].forEach(function (evt_name, idx) { - GodotEventListeners.add(canvas, evt_name, function () { - func(notif[idx]); - }, true); - }); - }, - - godot_js_display_setup_canvas__sig: 'viiii', - godot_js_display_setup_canvas: function (p_width, p_height, p_fullscreen, p_hidpi) { - const canvas = GodotConfig.canvas; - GodotEventListeners.add(canvas, 'contextmenu', function (ev) { - ev.preventDefault(); - }, false); - GodotEventListeners.add(canvas, 'webglcontextlost', function (ev) { - alert('WebGL context lost, please reload the page'); // eslint-disable-line no-alert - ev.preventDefault(); - }, false); - GodotDisplayScreen.hidpi = !!p_hidpi; - switch (GodotConfig.canvas_resize_policy) { - case 0: // None - GodotDisplayScreen.desired_size = [canvas.width, canvas.height]; - break; - case 1: // Project - GodotDisplayScreen.desired_size = [p_width, p_height]; - break; - default: // Full window - // Ensure we display in the right place, the size will be handled by updateSize - canvas.style.position = 'absolute'; - canvas.style.top = 0; - canvas.style.left = 0; - break; - } - GodotDisplayScreen.updateSize(); - if (p_fullscreen) { - GodotDisplayScreen.requestFullscreen(); - } - }, - - /* - * Virtual Keyboard - */ - godot_js_display_vk_show__sig: 'viiii', - godot_js_display_vk_show: function (p_text, p_type, p_start, p_end) { - const text = GodotRuntime.parseString(p_text); - const start = p_start > 0 ? p_start : 0; - const end = p_end > 0 ? p_end : start; - GodotDisplayVK.show(text, p_type, start, end); - }, - - godot_js_display_vk_hide__sig: 'v', - godot_js_display_vk_hide: function () { - GodotDisplayVK.hide(); - }, - - godot_js_display_vk_available__sig: 'i', - godot_js_display_vk_available: function () { - return GodotDisplayVK.available(); - }, - - godot_js_display_tts_available__sig: 'i', - godot_js_display_tts_available: function () { - return 'speechSynthesis' in window; - }, - - godot_js_display_vk_cb__sig: 'vi', - godot_js_display_vk_cb: function (p_input_cb) { - const input_cb = GodotRuntime.get_func(p_input_cb); - if (GodotDisplayVK.available()) { - GodotDisplayVK.init(input_cb); - } - }, -}; - -autoAddDeps(GodotDisplay, '$GodotDisplay'); -mergeInto(LibraryManager.library, GodotDisplay); diff --git a/platform/javascript/js/libs/library_godot_fetch.js b/platform/javascript/js/libs/library_godot_fetch.js deleted file mode 100644 index 285e50a035..0000000000 --- a/platform/javascript/js/libs/library_godot_fetch.js +++ /dev/null @@ -1,247 +0,0 @@ -/*************************************************************************/ -/* library_godot_fetch.js */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2022 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 GodotFetch = { - $GodotFetch__deps: ['$IDHandler', '$GodotRuntime'], - $GodotFetch: { - - onread: function (id, result) { - const obj = IDHandler.get(id); - if (!obj) { - return; - } - if (result.value) { - obj.chunks.push(result.value); - } - obj.reading = false; - obj.done = result.done; - }, - - onresponse: function (id, response) { - const obj = IDHandler.get(id); - if (!obj) { - return; - } - let chunked = false; - response.headers.forEach(function (value, header) { - const v = value.toLowerCase().trim(); - const h = header.toLowerCase().trim(); - if (h === 'transfer-encoding' && v === 'chunked') { - chunked = true; - } - }); - obj.status = response.status; - obj.response = response; - obj.reader = response.body.getReader(); - obj.chunked = chunked; - }, - - onerror: function (id, err) { - GodotRuntime.error(err); - const obj = IDHandler.get(id); - if (!obj) { - return; - } - obj.error = err; - }, - - create: function (method, url, headers, body) { - const obj = { - request: null, - response: null, - reader: null, - error: null, - done: false, - reading: false, - status: 0, - chunks: [], - bodySize: -1, - }; - const id = IDHandler.add(obj); - const init = { - method: method, - headers: headers, - body: body, - }; - obj.request = fetch(url, init); - obj.request.then(GodotFetch.onresponse.bind(null, id)).catch(GodotFetch.onerror.bind(null, id)); - return id; - }, - - free: function (id) { - const obj = IDHandler.get(id); - if (!obj) { - return; - } - IDHandler.remove(id); - if (!obj.request) { - return; - } - // Try to abort - obj.request.then(function (response) { - response.abort(); - }).catch(function (e) { /* nothing to do */ }); - }, - - read: function (id) { - const obj = IDHandler.get(id); - if (!obj) { - return; - } - if (obj.reader && !obj.reading) { - if (obj.done) { - obj.reader = null; - return; - } - obj.reading = true; - obj.reader.read().then(GodotFetch.onread.bind(null, id)).catch(GodotFetch.onerror.bind(null, id)); - } - }, - }, - - godot_js_fetch_create__sig: 'iiiiiii', - godot_js_fetch_create: function (p_method, p_url, p_headers, p_headers_size, p_body, p_body_size) { - const method = GodotRuntime.parseString(p_method); - const url = GodotRuntime.parseString(p_url); - const headers = GodotRuntime.parseStringArray(p_headers, p_headers_size); - const body = p_body_size ? GodotRuntime.heapSlice(HEAP8, p_body, p_body_size) : null; - return GodotFetch.create(method, url, headers.map(function (hv) { - const idx = hv.indexOf(':'); - if (idx <= 0) { - return []; - } - return [ - hv.slice(0, idx).trim(), - hv.slice(idx + 1).trim(), - ]; - }).filter(function (v) { - return v.length === 2; - }), body); - }, - - godot_js_fetch_state_get__sig: 'ii', - godot_js_fetch_state_get: function (p_id) { - const obj = IDHandler.get(p_id); - if (!obj) { - return -1; - } - if (obj.error) { - return -1; - } - if (!obj.response) { - return 0; - } - if (obj.reader) { - return 1; - } - if (obj.done) { - return 2; - } - return -1; - }, - - godot_js_fetch_http_status_get__sig: 'ii', - godot_js_fetch_http_status_get: function (p_id) { - const obj = IDHandler.get(p_id); - if (!obj || !obj.response) { - return 0; - } - return obj.status; - }, - - godot_js_fetch_read_headers__sig: 'iiii', - godot_js_fetch_read_headers: function (p_id, p_parse_cb, p_ref) { - const obj = IDHandler.get(p_id); - if (!obj || !obj.response) { - return 1; - } - const cb = GodotRuntime.get_func(p_parse_cb); - const arr = []; - obj.response.headers.forEach(function (v, h) { - arr.push(`${h}:${v}`); - }); - const c_ptr = GodotRuntime.allocStringArray(arr); - cb(arr.length, c_ptr, p_ref); - GodotRuntime.freeStringArray(c_ptr, arr.length); - return 0; - }, - - godot_js_fetch_read_chunk__sig: 'iiii', - godot_js_fetch_read_chunk: function (p_id, p_buf, p_buf_size) { - const obj = IDHandler.get(p_id); - if (!obj || !obj.response) { - return 0; - } - let to_read = p_buf_size; - const chunks = obj.chunks; - while (to_read && chunks.length) { - const chunk = obj.chunks[0]; - if (chunk.length > to_read) { - GodotRuntime.heapCopy(HEAP8, chunk.slice(0, to_read), p_buf); - chunks[0] = chunk.slice(to_read); - to_read = 0; - } else { - GodotRuntime.heapCopy(HEAP8, chunk, p_buf); - to_read -= chunk.length; - chunks.pop(); - } - } - if (!chunks.length) { - GodotFetch.read(p_id); - } - return p_buf_size - to_read; - }, - - godot_js_fetch_body_length_get__sig: 'ii', - godot_js_fetch_body_length_get: function (p_id) { - const obj = IDHandler.get(p_id); - if (!obj || !obj.response) { - return -1; - } - return obj.bodySize; - }, - - godot_js_fetch_is_chunked__sig: 'ii', - godot_js_fetch_is_chunked: function (p_id) { - const obj = IDHandler.get(p_id); - if (!obj || !obj.response) { - return -1; - } - return obj.chunked ? 1 : 0; - }, - - godot_js_fetch_free__sig: 'vi', - godot_js_fetch_free: function (id) { - GodotFetch.free(id); - }, -}; - -autoAddDeps(GodotFetch, '$GodotFetch'); -mergeInto(LibraryManager.library, GodotFetch); diff --git a/platform/javascript/js/libs/library_godot_input.js b/platform/javascript/js/libs/library_godot_input.js deleted file mode 100644 index 51571d64a2..0000000000 --- a/platform/javascript/js/libs/library_godot_input.js +++ /dev/null @@ -1,549 +0,0 @@ -/*************************************************************************/ -/* library_godot_input.js */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2022 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. */ -/*************************************************************************/ - -/* - * Gamepad API helper. - */ -const GodotInputGamepads = { - $GodotInputGamepads__deps: ['$GodotRuntime', '$GodotEventListeners'], - $GodotInputGamepads: { - samples: [], - - get_pads: function () { - try { - // Will throw in iframe when permission is denied. - // Will throw/warn in the future for insecure contexts. - // See https://github.com/w3c/gamepad/pull/120 - const pads = navigator.getGamepads(); - if (pads) { - return pads; - } - return []; - } catch (e) { - return []; - } - }, - - get_samples: function () { - return GodotInputGamepads.samples; - }, - - get_sample: function (index) { - const samples = GodotInputGamepads.samples; - return index < samples.length ? samples[index] : null; - }, - - sample: function () { - const pads = GodotInputGamepads.get_pads(); - const samples = []; - for (let i = 0; i < pads.length; i++) { - const pad = pads[i]; - if (!pad) { - samples.push(null); - continue; - } - const s = { - standard: pad.mapping === 'standard', - buttons: [], - axes: [], - connected: pad.connected, - }; - for (let b = 0; b < pad.buttons.length; b++) { - s.buttons.push(pad.buttons[b].value); - } - for (let a = 0; a < pad.axes.length; a++) { - s.axes.push(pad.axes[a]); - } - samples.push(s); - } - GodotInputGamepads.samples = samples; - }, - - init: function (onchange) { - GodotInputGamepads.samples = []; - function add(pad) { - const guid = GodotInputGamepads.get_guid(pad); - const c_id = GodotRuntime.allocString(pad.id); - const c_guid = GodotRuntime.allocString(guid); - onchange(pad.index, 1, c_id, c_guid); - GodotRuntime.free(c_id); - GodotRuntime.free(c_guid); - } - const pads = GodotInputGamepads.get_pads(); - for (let i = 0; i < pads.length; i++) { - // Might be reserved space. - if (pads[i]) { - add(pads[i]); - } - } - GodotEventListeners.add(window, 'gamepadconnected', function (evt) { - if (evt.gamepad) { - add(evt.gamepad); - } - }, false); - GodotEventListeners.add(window, 'gamepaddisconnected', function (evt) { - if (evt.gamepad) { - onchange(evt.gamepad.index, 0); - } - }, false); - }, - - get_guid: function (pad) { - if (pad.mapping) { - return pad.mapping; - } - const ua = navigator.userAgent; - let os = 'Unknown'; - if (ua.indexOf('Android') >= 0) { - os = 'Android'; - } else if (ua.indexOf('Linux') >= 0) { - os = 'Linux'; - } else if (ua.indexOf('iPhone') >= 0) { - os = 'iOS'; - } else if (ua.indexOf('Macintosh') >= 0) { - // Updated iPads will fall into this category. - os = 'MacOSX'; - } else if (ua.indexOf('Windows') >= 0) { - os = 'Windows'; - } - - const id = pad.id; - // Chrom* style: NAME (Vendor: xxxx Product: xxxx) - const exp1 = /vendor: ([0-9a-f]{4}) product: ([0-9a-f]{4})/i; - // Firefox/Safari style (safari may remove leading zeores) - const exp2 = /^([0-9a-f]+)-([0-9a-f]+)-/i; - let vendor = ''; - let product = ''; - if (exp1.test(id)) { - const match = exp1.exec(id); - vendor = match[1].padStart(4, '0'); - product = match[2].padStart(4, '0'); - } else if (exp2.test(id)) { - const match = exp2.exec(id); - vendor = match[1].padStart(4, '0'); - product = match[2].padStart(4, '0'); - } - if (!vendor || !product) { - return `${os}Unknown`; - } - return os + vendor + product; - }, - }, -}; -mergeInto(LibraryManager.library, GodotInputGamepads); - -/* - * Drag and drop helper. - * This is pretty big, but basically detect dropped files on GodotConfig.canvas, - * process them one by one (recursively for directories), and copies them to - * the temporary FS path '/tmp/drop-[random]/' so it can be emitted as a godot - * event (that requires a string array of paths). - * - * NOTE: The temporary files are removed after the callback. This means that - * deferred callbacks won't be able to access the files. - */ -const GodotInputDragDrop = { - $GodotInputDragDrop__deps: ['$FS', '$GodotFS'], - $GodotInputDragDrop: { - promises: [], - pending_files: [], - - add_entry: function (entry) { - if (entry.isDirectory) { - GodotInputDragDrop.add_dir(entry); - } else if (entry.isFile) { - GodotInputDragDrop.add_file(entry); - } else { - GodotRuntime.error('Unrecognized entry...', entry); - } - }, - - add_dir: function (entry) { - GodotInputDragDrop.promises.push(new Promise(function (resolve, reject) { - const reader = entry.createReader(); - reader.readEntries(function (entries) { - for (let i = 0; i < entries.length; i++) { - GodotInputDragDrop.add_entry(entries[i]); - } - resolve(); - }); - })); - }, - - add_file: function (entry) { - GodotInputDragDrop.promises.push(new Promise(function (resolve, reject) { - entry.file(function (file) { - const reader = new FileReader(); - reader.onload = function () { - const f = { - 'path': file.relativePath || file.webkitRelativePath, - 'name': file.name, - 'type': file.type, - 'size': file.size, - 'data': reader.result, - }; - if (!f['path']) { - f['path'] = f['name']; - } - GodotInputDragDrop.pending_files.push(f); - resolve(); - }; - reader.onerror = function () { - GodotRuntime.print('Error reading file'); - reject(); - }; - reader.readAsArrayBuffer(file); - }, function (err) { - GodotRuntime.print('Error!'); - reject(); - }); - })); - }, - - process: function (resolve, reject) { - if (GodotInputDragDrop.promises.length === 0) { - resolve(); - return; - } - GodotInputDragDrop.promises.pop().then(function () { - setTimeout(function () { - GodotInputDragDrop.process(resolve, reject); - }, 0); - }); - }, - - _process_event: function (ev, callback) { - ev.preventDefault(); - if (ev.dataTransfer.items) { - // Use DataTransferItemList interface to access the file(s) - for (let i = 0; i < ev.dataTransfer.items.length; i++) { - const item = ev.dataTransfer.items[i]; - let entry = null; - if ('getAsEntry' in item) { - entry = item.getAsEntry(); - } else if ('webkitGetAsEntry' in item) { - entry = item.webkitGetAsEntry(); - } - if (entry) { - GodotInputDragDrop.add_entry(entry); - } - } - } else { - GodotRuntime.error('File upload not supported'); - } - new Promise(GodotInputDragDrop.process).then(function () { - const DROP = `/tmp/drop-${parseInt(Math.random() * (1 << 30), 10)}/`; - const drops = []; - const files = []; - FS.mkdir(DROP.slice(0, -1)); // Without trailing slash - GodotInputDragDrop.pending_files.forEach((elem) => { - const path = elem['path']; - GodotFS.copy_to_fs(DROP + path, elem['data']); - let idx = path.indexOf('/'); - if (idx === -1) { - // Root file - drops.push(DROP + path); - } else { - // Subdir - const sub = path.substr(0, idx); - idx = sub.indexOf('/'); - if (idx < 0 && drops.indexOf(DROP + sub) === -1) { - drops.push(DROP + sub); - } - } - files.push(DROP + path); - }); - GodotInputDragDrop.promises = []; - GodotInputDragDrop.pending_files = []; - callback(drops); - if (GodotConfig.persistent_drops) { - // Delay removal at exit. - GodotOS.atexit(function (resolve, reject) { - GodotInputDragDrop.remove_drop(files, DROP); - resolve(); - }); - } else { - GodotInputDragDrop.remove_drop(files, DROP); - } - }); - }, - - remove_drop: function (files, drop_path) { - const dirs = [drop_path.substr(0, drop_path.length - 1)]; - // Remove temporary files - files.forEach(function (file) { - FS.unlink(file); - let dir = file.replace(drop_path, ''); - let idx = dir.lastIndexOf('/'); - while (idx > 0) { - dir = dir.substr(0, idx); - if (dirs.indexOf(drop_path + dir) === -1) { - dirs.push(drop_path + dir); - } - idx = dir.lastIndexOf('/'); - } - }); - // Remove dirs. - dirs.sort(function (a, b) { - const al = (a.match(/\//g) || []).length; - const bl = (b.match(/\//g) || []).length; - if (al > bl) { - return -1; - } else if (al < bl) { - return 1; - } - return 0; - }).forEach(function (dir) { - FS.rmdir(dir); - }); - }, - - handler: function (callback) { - return function (ev) { - GodotInputDragDrop._process_event(ev, callback); - }; - }, - }, -}; -mergeInto(LibraryManager.library, GodotInputDragDrop); - -/* - * Godot exposed input functions. - */ -const GodotInput = { - $GodotInput__deps: ['$GodotRuntime', '$GodotConfig', '$GodotEventListeners', '$GodotInputGamepads', '$GodotInputDragDrop'], - $GodotInput: { - getModifiers: function (evt) { - return (evt.shiftKey + 0) + ((evt.altKey + 0) << 1) + ((evt.ctrlKey + 0) << 2) + ((evt.metaKey + 0) << 3); - }, - computePosition: function (evt, rect) { - const canvas = GodotConfig.canvas; - const rw = canvas.width / rect.width; - const rh = canvas.height / rect.height; - const x = (evt.clientX - rect.x) * rw; - const y = (evt.clientY - rect.y) * rh; - return [x, y]; - }, - }, - - /* - * Mouse API - */ - godot_js_input_mouse_move_cb__sig: 'vi', - godot_js_input_mouse_move_cb: function (callback) { - const func = GodotRuntime.get_func(callback); - const canvas = GodotConfig.canvas; - function move_cb(evt) { - const rect = canvas.getBoundingClientRect(); - const pos = GodotInput.computePosition(evt, rect); - // Scale movement - const rw = canvas.width / rect.width; - const rh = canvas.height / rect.height; - const rel_pos_x = evt.movementX * rw; - const rel_pos_y = evt.movementY * rh; - const modifiers = GodotInput.getModifiers(evt); - func(pos[0], pos[1], rel_pos_x, rel_pos_y, modifiers); - } - GodotEventListeners.add(window, 'mousemove', move_cb, false); - }, - - godot_js_input_mouse_wheel_cb__sig: 'vi', - godot_js_input_mouse_wheel_cb: function (callback) { - const func = GodotRuntime.get_func(callback); - function wheel_cb(evt) { - if (func(evt['deltaX'] || 0, evt['deltaY'] || 0)) { - evt.preventDefault(); - } - } - GodotEventListeners.add(GodotConfig.canvas, 'wheel', wheel_cb, false); - }, - - godot_js_input_mouse_button_cb__sig: 'vi', - godot_js_input_mouse_button_cb: function (callback) { - const func = GodotRuntime.get_func(callback); - const canvas = GodotConfig.canvas; - function button_cb(p_pressed, evt) { - const rect = canvas.getBoundingClientRect(); - const pos = GodotInput.computePosition(evt, rect); - const modifiers = GodotInput.getModifiers(evt); - // Since the event is consumed, focus manually. - // NOTE: The iframe container may not have focus yet, so focus even when already active. - if (p_pressed) { - GodotConfig.canvas.focus(); - } - if (func(p_pressed, evt.button, pos[0], pos[1], modifiers)) { - evt.preventDefault(); - } - } - GodotEventListeners.add(canvas, 'mousedown', button_cb.bind(null, 1), false); - GodotEventListeners.add(window, 'mouseup', button_cb.bind(null, 0), false); - }, - - /* - * Touch API - */ - godot_js_input_touch_cb__sig: 'viii', - godot_js_input_touch_cb: function (callback, ids, coords) { - const func = GodotRuntime.get_func(callback); - const canvas = GodotConfig.canvas; - function touch_cb(type, evt) { - // Since the event is consumed, focus manually. - // NOTE: The iframe container may not have focus yet, so focus even when already active. - if (type === 0) { - GodotConfig.canvas.focus(); - } - const rect = canvas.getBoundingClientRect(); - const touches = evt.changedTouches; - for (let i = 0; i < touches.length; i++) { - const touch = touches[i]; - const pos = GodotInput.computePosition(touch, rect); - GodotRuntime.setHeapValue(coords + (i * 2) * 8, pos[0], 'double'); - GodotRuntime.setHeapValue(coords + (i * 2 + 1) * 8, pos[1], 'double'); - GodotRuntime.setHeapValue(ids + i * 4, touch.identifier, 'i32'); - } - func(type, touches.length); - if (evt.cancelable) { - evt.preventDefault(); - } - } - GodotEventListeners.add(canvas, 'touchstart', touch_cb.bind(null, 0), false); - GodotEventListeners.add(canvas, 'touchend', touch_cb.bind(null, 1), false); - GodotEventListeners.add(canvas, 'touchcancel', touch_cb.bind(null, 1), false); - GodotEventListeners.add(canvas, 'touchmove', touch_cb.bind(null, 2), false); - }, - - /* - * Key API - */ - godot_js_input_key_cb__sig: 'viii', - godot_js_input_key_cb: function (callback, code, key) { - const func = GodotRuntime.get_func(callback); - function key_cb(pressed, evt) { - const modifiers = GodotInput.getModifiers(evt); - GodotRuntime.stringToHeap(evt.code, code, 32); - GodotRuntime.stringToHeap(evt.key, key, 32); - func(pressed, evt.repeat, modifiers); - evt.preventDefault(); - } - GodotEventListeners.add(GodotConfig.canvas, 'keydown', key_cb.bind(null, 1), false); - GodotEventListeners.add(GodotConfig.canvas, 'keyup', key_cb.bind(null, 0), false); - }, - - /* - * Gamepad API - */ - godot_js_input_gamepad_cb__sig: 'vi', - godot_js_input_gamepad_cb: function (change_cb) { - const onchange = GodotRuntime.get_func(change_cb); - GodotInputGamepads.init(onchange); - }, - - godot_js_input_gamepad_sample_count__sig: 'i', - godot_js_input_gamepad_sample_count: function () { - return GodotInputGamepads.get_samples().length; - }, - - godot_js_input_gamepad_sample__sig: 'i', - godot_js_input_gamepad_sample: function () { - GodotInputGamepads.sample(); - return 0; - }, - - godot_js_input_gamepad_sample_get__sig: 'iiiiiii', - godot_js_input_gamepad_sample_get: function (p_index, r_btns, r_btns_num, r_axes, r_axes_num, r_standard) { - const sample = GodotInputGamepads.get_sample(p_index); - if (!sample || !sample.connected) { - return 1; - } - const btns = sample.buttons; - const btns_len = btns.length < 16 ? btns.length : 16; - for (let i = 0; i < btns_len; i++) { - GodotRuntime.setHeapValue(r_btns + (i << 2), btns[i], 'float'); - } - GodotRuntime.setHeapValue(r_btns_num, btns_len, 'i32'); - const axes = sample.axes; - const axes_len = axes.length < 10 ? axes.length : 10; - for (let i = 0; i < axes_len; i++) { - GodotRuntime.setHeapValue(r_axes + (i << 2), axes[i], 'float'); - } - GodotRuntime.setHeapValue(r_axes_num, axes_len, 'i32'); - const is_standard = sample.standard ? 1 : 0; - GodotRuntime.setHeapValue(r_standard, is_standard, 'i32'); - return 0; - }, - - /* - * Drag/Drop API - */ - godot_js_input_drop_files_cb__sig: 'vi', - godot_js_input_drop_files_cb: function (callback) { - const func = GodotRuntime.get_func(callback); - const dropFiles = function (files) { - const args = files || []; - if (!args.length) { - return; - } - const argc = args.length; - const argv = GodotRuntime.allocStringArray(args); - func(argv, argc); - GodotRuntime.freeStringArray(argv, argc); - }; - const canvas = GodotConfig.canvas; - GodotEventListeners.add(canvas, 'dragover', function (ev) { - // Prevent default behavior (which would try to open the file(s)) - ev.preventDefault(); - }, false); - GodotEventListeners.add(canvas, 'drop', GodotInputDragDrop.handler(dropFiles)); - }, - - /* Paste API */ - godot_js_input_paste_cb__sig: 'vi', - godot_js_input_paste_cb: function (callback) { - const func = GodotRuntime.get_func(callback); - GodotEventListeners.add(window, 'paste', function (evt) { - const text = evt.clipboardData.getData('text'); - const ptr = GodotRuntime.allocString(text); - func(ptr); - GodotRuntime.free(ptr); - }, false); - }, - - godot_js_input_vibrate_handheld__sig: 'vi', - godot_js_input_vibrate_handheld: function (p_duration_ms) { - if (typeof navigator.vibrate !== 'function') { - GodotRuntime.print('This browser does not support vibration.'); - } else { - navigator.vibrate(p_duration_ms); - } - }, -}; - -autoAddDeps(GodotInput, '$GodotInput'); -mergeInto(LibraryManager.library, GodotInput); diff --git a/platform/javascript/js/libs/library_godot_javascript_singleton.js b/platform/javascript/js/libs/library_godot_javascript_singleton.js deleted file mode 100644 index 692f27676a..0000000000 --- a/platform/javascript/js/libs/library_godot_javascript_singleton.js +++ /dev/null @@ -1,346 +0,0 @@ -/*************************************************************************/ -/* library_godot_eval.js */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2022 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 GodotJSWrapper = { - - $GodotJSWrapper__deps: ['$GodotRuntime', '$IDHandler'], - $GodotJSWrapper__postset: 'GodotJSWrapper.proxies = new Map();', - $GodotJSWrapper: { - proxies: null, - cb_ret: null, - - MyProxy: function (val) { - const id = IDHandler.add(this); - GodotJSWrapper.proxies.set(val, id); - let refs = 1; - this.ref = function () { - refs++; - }; - this.unref = function () { - refs--; - if (refs === 0) { - IDHandler.remove(id); - GodotJSWrapper.proxies.delete(val); - } - }; - this.get_val = function () { - return val; - }; - this.get_id = function () { - return id; - }; - }, - - get_proxied: function (val) { - const id = GodotJSWrapper.proxies.get(val); - if (id === undefined) { - const proxy = new GodotJSWrapper.MyProxy(val); - return proxy.get_id(); - } - IDHandler.get(id).ref(); - return id; - }, - - get_proxied_value: function (id) { - const proxy = IDHandler.get(id); - if (proxy === undefined) { - return undefined; - } - return proxy.get_val(); - }, - - variant2js: function (type, val) { - switch (type) { - case 0: - return null; - case 1: - return !!GodotRuntime.getHeapValue(val, 'i64'); - case 2: - return GodotRuntime.getHeapValue(val, 'i64'); - case 3: - return GodotRuntime.getHeapValue(val, 'double'); - case 4: - return GodotRuntime.parseString(GodotRuntime.getHeapValue(val, '*')); - case 21: // OBJECT - return GodotJSWrapper.get_proxied_value(GodotRuntime.getHeapValue(val, 'i64')); - default: - return undefined; - } - }, - - js2variant: function (p_val, p_exchange) { - if (p_val === undefined || p_val === null) { - return 0; // NIL - } - const type = typeof (p_val); - if (type === 'boolean') { - GodotRuntime.setHeapValue(p_exchange, p_val, 'i64'); - return 1; // BOOL - } else if (type === 'number') { - if (Number.isInteger(p_val)) { - GodotRuntime.setHeapValue(p_exchange, p_val, 'i64'); - return 2; // INT - } - GodotRuntime.setHeapValue(p_exchange, p_val, 'double'); - return 3; // REAL - } else if (type === 'string') { - const c_str = GodotRuntime.allocString(p_val); - GodotRuntime.setHeapValue(p_exchange, c_str, '*'); - return 4; // STRING - } - const id = GodotJSWrapper.get_proxied(p_val); - GodotRuntime.setHeapValue(p_exchange, id, 'i64'); - return 21; - }, - }, - - godot_js_wrapper_interface_get__sig: 'ii', - godot_js_wrapper_interface_get: function (p_name) { - const name = GodotRuntime.parseString(p_name); - if (typeof (window[name]) !== 'undefined') { - return GodotJSWrapper.get_proxied(window[name]); - } - return 0; - }, - - godot_js_wrapper_object_get__sig: 'iiii', - godot_js_wrapper_object_get: function (p_id, p_exchange, p_prop) { - const obj = GodotJSWrapper.get_proxied_value(p_id); - if (obj === undefined) { - return 0; - } - if (p_prop) { - const prop = GodotRuntime.parseString(p_prop); - try { - return GodotJSWrapper.js2variant(obj[prop], p_exchange); - } catch (e) { - GodotRuntime.error(`Error getting variable ${prop} on object`, obj); - return 0; // NIL - } - } - return GodotJSWrapper.js2variant(obj, p_exchange); - }, - - godot_js_wrapper_object_set__sig: 'viiii', - godot_js_wrapper_object_set: function (p_id, p_name, p_type, p_exchange) { - const obj = GodotJSWrapper.get_proxied_value(p_id); - if (obj === undefined) { - return; - } - const name = GodotRuntime.parseString(p_name); - try { - obj[name] = GodotJSWrapper.variant2js(p_type, p_exchange); - } catch (e) { - GodotRuntime.error(`Error setting variable ${name} on object`, obj); - } - }, - - godot_js_wrapper_object_call__sig: 'iiiiiiiii', - godot_js_wrapper_object_call: function (p_id, p_method, p_args, p_argc, p_convert_callback, p_exchange, p_lock, p_free_lock_callback) { - const obj = GodotJSWrapper.get_proxied_value(p_id); - if (obj === undefined) { - return -1; - } - const method = GodotRuntime.parseString(p_method); - const convert = GodotRuntime.get_func(p_convert_callback); - const freeLock = GodotRuntime.get_func(p_free_lock_callback); - const args = new Array(p_argc); - for (let i = 0; i < p_argc; i++) { - const type = convert(p_args, i, p_exchange, p_lock); - const lock = GodotRuntime.getHeapValue(p_lock, '*'); - args[i] = GodotJSWrapper.variant2js(type, p_exchange); - if (lock) { - freeLock(p_lock, type); - } - } - try { - const res = obj[method](...args); - return GodotJSWrapper.js2variant(res, p_exchange); - } catch (e) { - GodotRuntime.error(`Error calling method ${method} on:`, obj, 'error:', e); - return -1; - } - }, - - godot_js_wrapper_object_unref__sig: 'vi', - godot_js_wrapper_object_unref: function (p_id) { - const proxy = IDHandler.get(p_id); - if (proxy !== undefined) { - proxy.unref(); - } - }, - - godot_js_wrapper_create_cb__sig: 'iii', - godot_js_wrapper_create_cb: function (p_ref, p_func) { - const func = GodotRuntime.get_func(p_func); - let id = 0; - const cb = function () { - if (!GodotJSWrapper.get_proxied_value(id)) { - return undefined; - } - // The callback will store the returned value in this variable via - // "godot_js_wrapper_object_set_cb_ret" upon calling the user function. - // This is safe! JavaScript is single threaded (and using it in threads is not a good idea anyway). - GodotJSWrapper.cb_ret = null; - const args = Array.from(arguments); - func(p_ref, GodotJSWrapper.get_proxied(args), args.length); - const ret = GodotJSWrapper.cb_ret; - GodotJSWrapper.cb_ret = null; - return ret; - }; - id = GodotJSWrapper.get_proxied(cb); - return id; - }, - - godot_js_wrapper_object_set_cb_ret__sig: 'vii', - godot_js_wrapper_object_set_cb_ret: function (p_val_type, p_val_ex) { - GodotJSWrapper.cb_ret = GodotJSWrapper.variant2js(p_val_type, p_val_ex); - }, - - godot_js_wrapper_object_getvar__sig: 'iiii', - godot_js_wrapper_object_getvar: function (p_id, p_type, p_exchange) { - const obj = GodotJSWrapper.get_proxied_value(p_id); - if (obj === undefined) { - return -1; - } - const prop = GodotJSWrapper.variant2js(p_type, p_exchange); - if (prop === undefined || prop === null) { - return -1; - } - try { - return GodotJSWrapper.js2variant(obj[prop], p_exchange); - } catch (e) { - GodotRuntime.error(`Error getting variable ${prop} on object`, obj, e); - return -1; - } - }, - - godot_js_wrapper_object_setvar__sig: 'iiiiii', - godot_js_wrapper_object_setvar: function (p_id, p_key_type, p_key_ex, p_val_type, p_val_ex) { - const obj = GodotJSWrapper.get_proxied_value(p_id); - if (obj === undefined) { - return -1; - } - const key = GodotJSWrapper.variant2js(p_key_type, p_key_ex); - try { - obj[key] = GodotJSWrapper.variant2js(p_val_type, p_val_ex); - return 0; - } catch (e) { - GodotRuntime.error(`Error setting variable ${key} on object`, obj); - return -1; - } - }, - - godot_js_wrapper_create_object__sig: 'iiiiiiii', - godot_js_wrapper_create_object: function (p_object, p_args, p_argc, p_convert_callback, p_exchange, p_lock, p_free_lock_callback) { - const name = GodotRuntime.parseString(p_object); - if (typeof (window[name]) === 'undefined') { - return -1; - } - const convert = GodotRuntime.get_func(p_convert_callback); - const freeLock = GodotRuntime.get_func(p_free_lock_callback); - const args = new Array(p_argc); - for (let i = 0; i < p_argc; i++) { - const type = convert(p_args, i, p_exchange, p_lock); - const lock = GodotRuntime.getHeapValue(p_lock, '*'); - args[i] = GodotJSWrapper.variant2js(type, p_exchange); - if (lock) { - freeLock(p_lock, type); - } - } - try { - const res = new window[name](...args); - return GodotJSWrapper.js2variant(res, p_exchange); - } catch (e) { - GodotRuntime.error(`Error calling constructor ${name} with args:`, args, 'error:', e); - return -1; - } - }, -}; - -autoAddDeps(GodotJSWrapper, '$GodotJSWrapper'); -mergeInto(LibraryManager.library, GodotJSWrapper); - -const GodotEval = { - godot_js_eval__deps: ['$GodotRuntime'], - godot_js_eval__sig: 'iiiiiii', - godot_js_eval: function (p_js, p_use_global_ctx, p_union_ptr, p_byte_arr, p_byte_arr_write, p_callback) { - const js_code = GodotRuntime.parseString(p_js); - let eval_ret = null; - try { - if (p_use_global_ctx) { - // indirect eval call grants global execution context - const global_eval = eval; // eslint-disable-line no-eval - eval_ret = global_eval(js_code); - } else { - eval_ret = eval(js_code); // eslint-disable-line no-eval - } - } catch (e) { - GodotRuntime.error(e); - } - - switch (typeof eval_ret) { - case 'boolean': - GodotRuntime.setHeapValue(p_union_ptr, eval_ret, 'i32'); - return 1; // BOOL - - case 'number': - GodotRuntime.setHeapValue(p_union_ptr, eval_ret, 'double'); - return 3; // REAL - - case 'string': - GodotRuntime.setHeapValue(p_union_ptr, GodotRuntime.allocString(eval_ret), '*'); - return 4; // STRING - - case 'object': - if (eval_ret === null) { - break; - } - - if (ArrayBuffer.isView(eval_ret) && !(eval_ret instanceof Uint8Array)) { - eval_ret = new Uint8Array(eval_ret.buffer); - } else if (eval_ret instanceof ArrayBuffer) { - eval_ret = new Uint8Array(eval_ret); - } - if (eval_ret instanceof Uint8Array) { - const func = GodotRuntime.get_func(p_callback); - const bytes_ptr = func(p_byte_arr, p_byte_arr_write, eval_ret.length); - HEAPU8.set(eval_ret, bytes_ptr); - return 20; // POOL_BYTE_ARRAY - } - break; - - // no default - } - return 0; // NIL - }, -}; - -mergeInto(LibraryManager.library, GodotEval); diff --git a/platform/javascript/js/libs/library_godot_os.js b/platform/javascript/js/libs/library_godot_os.js deleted file mode 100644 index 377eec3234..0000000000 --- a/platform/javascript/js/libs/library_godot_os.js +++ /dev/null @@ -1,427 +0,0 @@ -/*************************************************************************/ -/* library_godot_os.js */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2022 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__deps: ['$GodotRuntime'], - $GodotConfig: { - canvas: null, - locale: 'en', - canvas_resize_policy: 2, // Adaptive - virtual_keyboard: false, - persistent_drops: false, - on_execute: null, - on_exit: null, - - init_config: function (p_opts) { - GodotConfig.canvas_resize_policy = p_opts['canvasResizePolicy']; - GodotConfig.canvas = p_opts['canvas']; - GodotConfig.locale = p_opts['locale'] || GodotConfig.locale; - GodotConfig.virtual_keyboard = p_opts['virtualKeyboard']; - GodotConfig.persistent_drops = !!p_opts['persistentDrops']; - GodotConfig.on_execute = p_opts['onExecute']; - GodotConfig.on_exit = p_opts['onExit']; - if (p_opts['focusCanvas']) { - GodotConfig.canvas.focus(); - } - }, - - locate_file: function (file) { - return Module['locateFile'](file); // eslint-disable-line no-undef - }, - clear: function () { - GodotConfig.canvas = null; - GodotConfig.locale = 'en'; - GodotConfig.canvas_resize_policy = 2; - GodotConfig.virtual_keyboard = false; - GodotConfig.persistent_drops = false; - GodotConfig.on_execute = null; - GodotConfig.on_exit = null; - }, - }, - - godot_js_config_canvas_id_get__sig: 'vii', - godot_js_config_canvas_id_get: function (p_ptr, p_ptr_max) { - GodotRuntime.stringToHeap(`#${GodotConfig.canvas.id}`, p_ptr, p_ptr_max); - }, - - godot_js_config_locale_get__sig: 'vii', - godot_js_config_locale_get: function (p_ptr, p_ptr_max) { - GodotRuntime.stringToHeap(GodotConfig.locale, p_ptr, p_ptr_max); - }, -}; - -autoAddDeps(GodotConfig, '$GodotConfig'); -mergeInto(LibraryManager.library, GodotConfig); - -const GodotFS = { - $GodotFS__deps: ['$ERRNO_CODES', '$FS', '$IDBFS', '$GodotRuntime'], - $GodotFS__postset: [ - 'Module["initFS"] = GodotFS.init;', - '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; - GodotRuntime.print(`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) { - GodotRuntime.print('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) { - GodotRuntime.error('Already syncing!'); - return Promise.resolve(); - } - GodotFS._syncing = true; - return new Promise(function (resolve, reject) { - FS.syncfs(false, function (error) { - if (error) { - GodotRuntime.error(`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)); - }, - }, -}; -mergeInto(LibraryManager.library, GodotFS); - -const GodotOS = { - $GodotOS__deps: ['$GodotRuntime', '$GodotConfig', '$GodotFS'], - $GodotOS__postset: [ - 'Module["request_quit"] = function() { GodotOS.request_quit() };', - 'Module["onExit"] = GodotOS.cleanup;', - 'GodotOS._fs_sync_promise = Promise.resolve();', - ].join(''), - $GodotOS: { - request_quit: function () {}, - _async_cbs: [], - _fs_sync_promise: null, - - atexit: function (p_promise_cb) { - GodotOS._async_cbs.push(p_promise_cb); - }, - - cleanup: function (exit_code) { - const cb = GodotConfig.on_exit; - GodotFS.deinit(); - GodotConfig.clear(); - if (cb) { - cb(exit_code); - } - }, - - 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); - }); - }, - }, - - godot_js_os_finish_async__sig: 'vi', - godot_js_os_finish_async: function (p_callback) { - const func = GodotRuntime.get_func(p_callback); - GodotOS.finish_async(func); - }, - - godot_js_os_request_quit_cb__sig: 'vi', - godot_js_os_request_quit_cb: function (p_callback) { - GodotOS.request_quit = GodotRuntime.get_func(p_callback); - }, - - godot_js_os_fs_is_persistent__sig: 'i', - godot_js_os_fs_is_persistent: function () { - return GodotFS.is_persistent(); - }, - - godot_js_os_fs_sync__sig: 'vi', - godot_js_os_fs_sync: function (callback) { - const func = GodotRuntime.get_func(callback); - GodotOS._fs_sync_promise = GodotFS.sync(); - GodotOS._fs_sync_promise.then(function (err) { - func(); - }); - }, - - godot_js_os_execute__sig: 'ii', - godot_js_os_execute: function (p_json) { - const json_args = GodotRuntime.parseString(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__sig: 'vi', - godot_js_os_shell_open: function (p_uri) { - window.open(GodotRuntime.parseString(p_uri), '_blank'); - }, - - godot_js_os_hw_concurrency_get__sig: 'i', - godot_js_os_hw_concurrency_get: function () { - // TODO Godot core needs fixing to avoid spawning too many threads (> 24). - const concurrency = navigator.hardwareConcurrency || 1; - return concurrency < 2 ? concurrency : 2; - }, - - godot_js_os_download_buffer__sig: 'viiii', - godot_js_os_download_buffer: function (p_ptr, p_size, p_name, p_mime) { - const buf = GodotRuntime.heapSlice(HEAP8, p_ptr, p_size); - const name = GodotRuntime.parseString(p_name); - const mime = GodotRuntime.parseString(p_mime); - const blob = new Blob([buf], { type: mime }); - const url = window.URL.createObjectURL(blob); - const a = document.createElement('a'); - a.href = url; - a.download = name; - a.style.display = 'none'; - document.body.appendChild(a); - a.click(); - a.remove(); - window.URL.revokeObjectURL(url); - }, -}; - -autoAddDeps(GodotOS, '$GodotOS'); -mergeInto(LibraryManager.library, GodotOS); - -/* - * Godot event listeners. - * Keeps track of registered event listeners so it can remove them on shutdown. - */ -const GodotEventListeners = { - $GodotEventListeners__deps: ['$GodotOS'], - $GodotEventListeners__postset: 'GodotOS.atexit(function(resolve, reject) { GodotEventListeners.clear(); resolve(); });', - $GodotEventListeners: { - handlers: [], - - has: function (target, event, method, capture) { - return GodotEventListeners.handlers.findIndex(function (e) { - return e.target === target && e.event === event && e.method === method && e.capture === capture; - }) !== -1; - }, - - add: function (target, event, method, capture) { - if (GodotEventListeners.has(target, event, method, capture)) { - return; - } - function Handler(p_target, p_event, p_method, p_capture) { - this.target = p_target; - this.event = p_event; - this.method = p_method; - this.capture = p_capture; - } - GodotEventListeners.handlers.push(new Handler(target, event, method, capture)); - target.addEventListener(event, method, capture); - }, - - clear: function () { - GodotEventListeners.handlers.forEach(function (h) { - h.target.removeEventListener(h.event, h.method, h.capture); - }); - GodotEventListeners.handlers.length = 0; - }, - }, -}; -mergeInto(LibraryManager.library, GodotEventListeners); - -const GodotPWA = { - - $GodotPWA__deps: ['$GodotRuntime', '$GodotEventListeners'], - $GodotPWA: { - hasUpdate: false, - - updateState: function (cb, reg) { - if (!reg) { - return; - } - if (!reg.active) { - return; - } - if (reg.waiting) { - GodotPWA.hasUpdate = true; - cb(); - } - GodotEventListeners.add(reg, 'updatefound', function () { - const installing = reg.installing; - GodotEventListeners.add(installing, 'statechange', function () { - if (installing.state === 'installed') { - GodotPWA.hasUpdate = true; - cb(); - } - }); - }); - }, - }, - - godot_js_pwa_cb__sig: 'vi', - godot_js_pwa_cb: function (p_update_cb) { - if ('serviceWorker' in navigator) { - const cb = GodotRuntime.get_func(p_update_cb); - navigator.serviceWorker.getRegistration().then(GodotPWA.updateState.bind(null, cb)); - } - }, - - godot_js_pwa_update__sig: 'i', - godot_js_pwa_update: function () { - if ('serviceWorker' in navigator && GodotPWA.hasUpdate) { - navigator.serviceWorker.getRegistration().then(function (reg) { - if (!reg || !reg.waiting) { - return; - } - reg.waiting.postMessage('update'); - }); - return 0; - } - return 1; - }, -}; - -autoAddDeps(GodotPWA, '$GodotPWA'); -mergeInto(LibraryManager.library, GodotPWA); diff --git a/platform/javascript/js/libs/library_godot_runtime.js b/platform/javascript/js/libs/library_godot_runtime.js deleted file mode 100644 index e2f7c8dca6..0000000000 --- a/platform/javascript/js/libs/library_godot_runtime.js +++ /dev/null @@ -1,134 +0,0 @@ -/*************************************************************************/ -/* library_godot_runtime.js */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2022 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 GodotRuntime = { - $GodotRuntime: { - /* - * Functions - */ - get_func: function (ptr) { - return wasmTable.get(ptr); // eslint-disable-line no-undef - }, - - /* - * Prints - */ - error: function () { - err.apply(null, Array.from(arguments)); // eslint-disable-line no-undef - }, - - print: function () { - out.apply(null, Array.from(arguments)); // eslint-disable-line no-undef - }, - - /* - * Memory - */ - malloc: function (p_size) { - return _malloc(p_size); // eslint-disable-line no-undef - }, - - free: function (p_ptr) { - _free(p_ptr); // eslint-disable-line no-undef - }, - - getHeapValue: function (p_ptr, p_type) { - return getValue(p_ptr, p_type); // eslint-disable-line no-undef - }, - - setHeapValue: function (p_ptr, p_value, p_type) { - setValue(p_ptr, p_value, p_type); // eslint-disable-line no-undef - }, - - heapSub: function (p_heap, p_ptr, p_len) { - const bytes = p_heap.BYTES_PER_ELEMENT; - return p_heap.subarray(p_ptr / bytes, p_ptr / bytes + p_len); - }, - - heapSlice: function (p_heap, p_ptr, p_len) { - const bytes = p_heap.BYTES_PER_ELEMENT; - return p_heap.slice(p_ptr / bytes, p_ptr / bytes + p_len); - }, - - heapCopy: function (p_dst, p_src, p_ptr) { - const bytes = p_src.BYTES_PER_ELEMENT; - return p_dst.set(p_src, p_ptr / bytes); - }, - - /* - * Strings - */ - parseString: function (p_ptr) { - return UTF8ToString(p_ptr); // eslint-disable-line no-undef - }, - - parseStringArray: function (p_ptr, p_size) { - const strings = []; - const ptrs = GodotRuntime.heapSub(HEAP32, p_ptr, p_size); // TODO wasm64 - ptrs.forEach(function (ptr) { - strings.push(GodotRuntime.parseString(ptr)); - }); - return strings; - }, - - strlen: function (p_str) { - return lengthBytesUTF8(p_str); // eslint-disable-line no-undef - }, - - allocString: function (p_str) { - const length = GodotRuntime.strlen(p_str) + 1; - const c_str = GodotRuntime.malloc(length); - stringToUTF8(p_str, c_str, length); // eslint-disable-line no-undef - return c_str; - }, - - allocStringArray: function (p_strings) { - const size = p_strings.length; - const c_ptr = GodotRuntime.malloc(size * 4); - for (let i = 0; i < size; i++) { - HEAP32[(c_ptr >> 2) + i] = GodotRuntime.allocString(p_strings[i]); - } - return c_ptr; - }, - - freeStringArray: function (p_ptr, p_len) { - for (let i = 0; i < p_len; i++) { - GodotRuntime.free(HEAP32[(p_ptr >> 2) + i]); - } - GodotRuntime.free(p_ptr); - }, - - stringToHeap: function (p_str, p_ptr, p_len) { - return stringToUTF8Array(p_str, HEAP8, p_ptr, p_len); // eslint-disable-line no-undef - }, - }, -}; -autoAddDeps(GodotRuntime, '$GodotRuntime'); -mergeInto(LibraryManager.library, GodotRuntime); |