asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/platform/javascript/export/export.cpp

1011 lines
37 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* export.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
Update copyright statements to 2021 Happy new year to the wonderful Godot community! 2020 has been a tough year for most of us personally, but a good year for Godot development nonetheless with a huge amount of work done towards Godot 4.0 and great improvements backported to the long-lived 3.2 branch. We've had close to 400 contributors to engine code this year, authoring near 7,000 commit! (And that's only for the `master` branch and for the engine code, there's a lot more when counting docs, demos and other first-party repos.) Here's to a great year 2021 for all Godot users 🎆
2021-01-01 20:13:46 +01:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* */
/* 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. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
[HTML5] Optional icon generation, use export name for it. We used to only generate the favicon if it was specified in the user project settings, now it's optional, will export it to `NAME.icon.png`, (falling back to the default project icon if none is set in project settings), and the `<link>` tag is added using the `$HEAD_INCLUDE` instead of being hardcoded in the template.
2021-03-26 12:44:17 +01:00
#include "core/io/image_loader.h"
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
#include "core/io/stream_peer_ssl.h"
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
#include "core/io/tcp_server.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 18:13:45 +02:00
#include "core/io/zip_io.h"
Remove dependency on the editor directory being in the build's include path. - Add or remove the necessary subdirectorires to the includes to remove dependency on the editor directory being in the build's include path. - Ensure includes in modified files conform to style guideline. - Remove editor from the build include path.
2019-10-09 16:11:04 +02:00
#include "editor/editor_export.h"
Refactoring: rename tools/editor/ to editor/ The other subfolders of tools/ had already been moved to either editor/, misc/ or thirdparty/, so the hiding the editor code that deep was no longer meaningful.
2017-03-05 14:21:25 +01:00
#include "editor/editor_node.h"
Export boot splash and add custom HTML file option in HTML5 export
2017-11-20 00:06:11 +01:00
#include "main/splash.gen.h"
BuildSystem: generated files have .gen.extension
2017-06-23 17:03:41 +02:00
#include "platform/javascript/logo.gen.h"
Use custom native-run icons for Android and HTML5
2017-05-25 20:57:13 +02:00
#include "platform/javascript/run_icon.gen.h"
Removed import/export system, will start new one from scratch.
2017-01-26 01:55:59 +01:00
Rename Reference to RefCounted
2021-06-04 18:03:15 +02:00
class EditorHTTPServer : public RefCounted {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
private:
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 02:48:18 +02:00
Ref<TCPServer> server;
[HTML5] Debug HttpServer now runs in `web` cache subdir. Serving all files in that folder and using a known list of mime types. Makes it easy to add more exported files, while still playing safe.
2021-03-26 11:48:56 +01:00
Map<String, String> mimes;
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
Ref<StreamPeerTCP> tcp;
Ref<StreamPeerSSL> ssl;
Ref<StreamPeer> peer;
Ref<CryptoKey> key;
Ref<X509Certificate> cert;
bool use_ssl = false;
HTML5: Code style cleanup for export code
2020-12-10 13:57:27 +01:00
uint64_t time = 0;
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
uint8_t req_buf[4096];
HTML5: Code style cleanup for export code
2020-12-10 13:57:27 +01:00
int req_pos = 0;
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
void _clear_client() {
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
peer = Ref<StreamPeer>();
ssl = Ref<StreamPeerSSL>();
tcp = Ref<StreamPeerTCP>();
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
memset(req_buf, 0, sizeof(req_buf));
time = 0;
req_pos = 0;
}
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
void _set_internal_certs(Ref<Crypto> p_crypto) {
Implement shader caching * Shader compilation is now cached. Subsequent loads take less than a millisecond. * Improved game, editor and project manager startup time. * Editor uses .godot/shader_cache to store shaders. * Game uses user://shader_cache * Project manager uses $config_dir/shader_cache * Options to tweak shader caching in project settings. * Editor path configuration moved from EditorSettings to new class, EditorPaths, so it can be available early on (before shaders are compiled). * Reworked ShaderCompilerRD to ensure deterministic shader code creation (else shader may change and cache will be invalidated). * Added shader compression with SMOLV: https://github.com/aras-p/smol-v
2021-05-25 02:25:11 +02:00
const String cache_path = EditorPaths::get_singleton()->get_cache_dir();
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
const String key_path = cache_path.plus_file("html5_server.key");
const String crt_path = cache_path.plus_file("html5_server.crt");
bool regen = !FileAccess::exists(key_path) || !FileAccess::exists(crt_path);
if (!regen) {
key = Ref<CryptoKey>(CryptoKey::create());
cert = Ref<X509Certificate>(X509Certificate::create());
if (key->load(key_path) != OK || cert->load(crt_path) != OK) {
regen = true;
}
}
if (regen) {
key = p_crypto->generate_rsa(2048);
key->save(key_path);
cert = p_crypto->generate_self_signed_certificate(key, "CN=godot-debug.local,O=A Game Dev,C=XXA", "20140101000000", "20340101000000");
cert->save(crt_path);
}
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
public:
EditorHTTPServer() {
[HTML5] Debug HttpServer now runs in `web` cache subdir. Serving all files in that folder and using a known list of mime types. Makes it easy to add more exported files, while still playing safe.
2021-03-26 11:48:56 +01:00
mimes["html"] = "text/html";
mimes["js"] = "application/javascript";
mimes["json"] = "application/json";
mimes["pck"] = "application/octet-stream";
mimes["png"] = "image/png";
mimes["svg"] = "image/svg";
mimes["wasm"] = "application/wasm";
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
server.instantiate();
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
stop();
}
void stop() {
server->stop();
_clear_client();
}
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 02:48:18 +02:00
Error listen(int p_port, IPAddress p_address, bool p_use_ssl, String p_ssl_key, String p_ssl_cert) {
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
use_ssl = p_use_ssl;
if (use_ssl) {
Ref<Crypto> crypto = Crypto::create();
if (crypto.is_null()) {
return ERR_UNAVAILABLE;
}
if (!p_ssl_key.is_empty() && !p_ssl_cert.is_empty()) {
key = Ref<CryptoKey>(CryptoKey::create());
Error err = key->load(p_ssl_key);
ERR_FAIL_COND_V(err != OK, err);
cert = Ref<X509Certificate>(X509Certificate::create());
err = cert->load(p_ssl_cert);
ERR_FAIL_COND_V(err != OK, err);
} else {
_set_internal_certs(crypto);
}
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
return server->listen(p_port, p_address);
}
bool is_listening() const {
return server->is_listening();
}
void _send_response() {
Vector<String> psa = String((char *)req_buf).split("\r\n");
int len = psa.size();
ERR_FAIL_COND_MSG(len < 4, "Not enough response headers, got: " + itos(len) + ", expected >= 4.");
Vector<String> req = psa[0].split(" ", false);
ERR_FAIL_COND_MSG(req.size() < 2, "Invalid protocol or status code.");
// Wrong protocol
ERR_FAIL_COND_MSG(req[0] != "GET" || req[2] != "HTTP/1.1", "Invalid method or HTTP version.");
Strip query string when parsing HTTP request line for path
2021-06-24 18:20:28 +02:00
const int query_index = req[1].find_char('?');
const String path = (query_index == -1) ? req[1] : req[1].substr(0, query_index);
const String req_file = path.get_file();
const String req_ext = path.get_extension();
Implement shader caching * Shader compilation is now cached. Subsequent loads take less than a millisecond. * Improved game, editor and project manager startup time. * Editor uses .godot/shader_cache to store shaders. * Game uses user://shader_cache * Project manager uses $config_dir/shader_cache * Options to tweak shader caching in project settings. * Editor path configuration moved from EditorSettings to new class, EditorPaths, so it can be available early on (before shaders are compiled). * Reworked ShaderCompilerRD to ensure deterministic shader code creation (else shader may change and cache will be invalidated). * Added shader compression with SMOLV: https://github.com/aras-p/smol-v
2021-05-25 02:25:11 +02:00
const String cache_path = EditorPaths::get_singleton()->get_cache_dir().plus_file("web");
[HTML5] Debug HttpServer now runs in `web` cache subdir. Serving all files in that folder and using a known list of mime types. Makes it easy to add more exported files, while still playing safe.
2021-03-26 11:48:56 +01:00
const String filepath = cache_path.plus_file(req_file);
if (!mimes.has(req_ext) || !FileAccess::exists(filepath)) {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
String s = "HTTP/1.1 404 Not Found\r\n";
s += "Connection: Close\r\n";
s += "\r\n";
CharString cs = s.utf8();
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
peer->put_data((const uint8_t *)cs.get_data(), cs.size() - 1);
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
return;
}
[HTML5] Debug HttpServer now runs in `web` cache subdir. Serving all files in that folder and using a known list of mime types. Makes it easy to add more exported files, while still playing safe.
2021-03-26 11:48:56 +01:00
const String ctype = mimes[req_ext];
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
FileAccess *f = FileAccess::open(filepath, FileAccess::READ);
ERR_FAIL_COND(!f);
String s = "HTTP/1.1 200 OK\r\n";
s += "Connection: Close\r\n";
Add mime type to responses from debug HTTP server. Get rid of warnings in firefox mentioning performance loss when no mime type is given for wasm files.
2020-01-14 15:01:00 +01:00
s += "Content-Type: " + ctype + "\r\n";
Add COOP/COEP headers to HTML5 "run" server. This allow the page to be considered a SecureContext if the address is localhost (127.0.0.1/::1) and let Firefox (and future Chrome versions) enable extra features needed for the HTML5 threaded export.
2020-09-30 19:12:36 +02:00
s += "Access-Control-Allow-Origin: *\r\n";
s += "Cross-Origin-Opener-Policy: same-origin\r\n";
s += "Cross-Origin-Embedder-Policy: require-corp\r\n";
[HTML5] Builtin HTTP server disable browsers cache We don't want browsers to cache our temporary exports (since they will always differ).
2021-01-25 14:41:23 +01:00
s += "Cache-Control: no-store, max-age=0\r\n";
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
s += "\r\n";
CharString cs = s.utf8();
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
Error err = peer->put_data((const uint8_t *)cs.get_data(), cs.size() - 1);
Properly close files served by debug HTTP server.
2020-01-14 15:06:53 +01:00
if (err != OK) {
memdelete(f);
ERR_FAIL();
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
while (true) {
uint8_t bytes[4096];
Make all file access 64-bit (uint64_t) This changes the types of a big number of variables. General rules: - Using `uint64_t` in general. We also considered `int64_t` but eventually settled on keeping it unsigned, which is also closer to what one would expect with `size_t`/`off_t`. - We only keep `int64_t` for `seek_end` (takes a negative offset from the end) and for the `Variant` bindings, since `Variant::INT` is `int64_t`. This means we only need to guard against passing negative values in `core_bind.cpp`. - Using `uint32_t` integers for concepts not needing such a huge range, like pages, blocks, etc. In addition: - Improve usage of integer types in some related places; namely, `DirAccess`, core binds. Note: - On Windows, `_ftelli64` reports invalid values when using 32-bit MinGW with version < 8.0. This was an upstream bug fixed in 8.0. It breaks support for big files on 32-bit Windows builds made with that toolchain. We might add a workaround. Fixes #44363. Fixes godotengine/godot-proposals#400. Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2019-03-26 18:51:13 +01:00
uint64_t read = f->get_buffer(bytes, 4096);
if (read == 0) {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
break;
}
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
err = peer->put_data(bytes, read);
Properly close files served by debug HTTP server.
2020-01-14 15:06:53 +01:00
if (err != OK) {
memdelete(f);
ERR_FAIL();
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
}
Properly close files served by debug HTTP server.
2020-01-14 15:06:53 +01:00
memdelete(f);
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
}
void poll() {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!server->is_listening()) {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
if (tcp.is_null()) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!server->is_connection_available()) {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
tcp = server->take_connection();
peer = tcp;
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
time = OS::get_singleton()->get_ticks_usec();
}
if (OS::get_singleton()->get_ticks_usec() - time > 1000000) {
_clear_client();
return;
}
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
if (tcp->get_status() != StreamPeerTCP::STATUS_CONNECTED) {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
if (use_ssl) {
if (ssl.is_null()) {
ssl = Ref<StreamPeerSSL>(StreamPeerSSL::create());
peer = ssl;
ssl->set_blocking_handshake_enabled(false);
if (ssl->accept_stream(tcp, key, cert) != OK) {
_clear_client();
return;
}
}
ssl->poll();
if (ssl->get_status() == StreamPeerSSL::STATUS_HANDSHAKING) {
// Still handshaking, keep waiting.
return;
}
if (ssl->get_status() != StreamPeerSSL::STATUS_CONNECTED) {
_clear_client();
return;
}
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
while (true) {
char *r = (char *)req_buf;
int l = req_pos - 1;
if (l > 3 && r[l] == '\n' && r[l - 1] == '\r' && r[l - 2] == '\n' && r[l - 3] == '\r') {
_send_response();
_clear_client();
return;
}
int read = 0;
ERR_FAIL_COND(req_pos >= 4096);
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
Error err = peer->get_partial_data(&req_buf[req_pos], 1, read);
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
if (err != OK) {
// Got an error
_clear_client();
return;
} else if (read != 1) {
// Busy, wait next poll
return;
}
req_pos += read;
}
}
};
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
class EditorExportPlatformJavaScript : public EditorExportPlatform {
Made use of semicolons more consitent, fixed formatting
2019-03-19 19:35:57 +01:00
GDCLASS(EditorExportPlatformJavaScript, EditorExportPlatform);
Revamp web export page
2016-01-20 03:21:29 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Ref<ImageTexture> logo;
Use custom native-run icons for Android and HTML5
2017-05-25 20:57:13 +02:00
Ref<ImageTexture> run_icon;
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
Ref<ImageTexture> stop_icon;
HTML5: Code style cleanup for export code
2020-12-10 13:57:27 +01:00
int menu_options = 0;
Ref<EditorHTTPServer> server;
bool server_quit = false;
Mutex server_lock;
Modernize Thread - Based on C++11's `thread` and `thread_local` - No more need to allocate-deallocate or check for null - No pointer anymore, just a member variable - Platform-specific implementations no longer needed (except for the few cases of non-portable functions) - Simpler for `NO_THREADS` - Thread ids are now the same across platforms (main is 1; others follow)
2021-01-19 13:29:41 +01:00
Thread server_thread;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[HTML5] Allow selecting the export type. Available types: - Regular - GDNative (support dynamic linking and thus GDNative WASM files) - Threads (uses WebAssembly Threads)
2020-12-03 14:42:25 +01:00
enum ExportMode {
EXPORT_MODE_NORMAL = 0,
EXPORT_MODE_THREADS = 1,
EXPORT_MODE_GDNATIVE = 2,
};
String _get_template_name(ExportMode p_mode, bool p_debug) const {
String name = "webassembly";
switch (p_mode) {
case EXPORT_MODE_THREADS:
name += "_threads";
break;
case EXPORT_MODE_GDNATIVE:
name += "_gdnative";
break;
default:
break;
}
if (p_debug) {
name += "_debug.zip";
} else {
name += "_release.zip";
}
return name;
}
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
Ref<Image> _get_project_icon() const {
Ref<Image> icon;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
icon.instantiate();
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
const String icon_path = String(GLOBAL_GET("application/config/icon")).strip_edges();
if (icon_path.is_empty() || ImageLoader::load_image(icon_path, icon) != OK) {
return EditorNode::get_singleton()->get_editor_theme()->get_icon("DefaultProjectIcon", "EditorIcons")->get_image();
}
return icon;
}
Ref<Image> _get_project_splash() const {
Ref<Image> splash;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
splash.instantiate();
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
const String splash_path = String(GLOBAL_GET("application/boot_splash/image")).strip_edges();
if (splash_path.is_empty() || ImageLoader::load_image(splash_path, splash) != OK) {
return Ref<Image>(memnew(Image(boot_splash_png)));
}
return splash;
}
Error _extract_template(const String &p_template, const String &p_dir, const String &p_name, bool pwa);
void _replace_strings(Map<String, String> p_replaces, Vector<uint8_t> &r_template);
[HTML5] Export process writes sizes in template. This allow the loading bar to be much more reliable, even in cases where realible stream loading status is not detectable (server-side compression, chunked encoding).
2021-03-01 17:53:56 +01:00
void _fix_html(Vector<uint8_t> &p_html, const Ref<EditorExportPreset> &p_preset, const String &p_name, bool p_debug, int p_flags, const Vector<SharedObject> p_shared_objects, const Dictionary &p_file_sizes);
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
Error _add_manifest_icon(const String &p_path, const String &p_icon, int p_size, Array &r_arr);
Error _build_pwa(const Ref<EditorExportPreset> &p_preset, const String p_path, const Vector<SharedObject> &p_shared_objects);
Error _write_or_error(const uint8_t *p_content, int p_len, String p_path);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
static void _server_thread_poll(void *data);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
public:
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void get_preset_features(const Ref<EditorExportPreset> &p_preset, List<String> *r_features) override;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void get_export_options(List<ExportOption> *r_options) override;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual String get_name() const override;
virtual String get_os_name() const override;
virtual Ref<Texture2D> get_logo() const override;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual bool can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const override;
virtual List<String> get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const override;
virtual Error export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags = 0) override;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual bool poll_export() override;
virtual int get_options_count() const override;
virtual String get_option_label(int p_index) const override { return p_index ? TTR("Stop HTTP Server") : TTR("Run in Browser"); }
virtual String get_option_tooltip(int p_index) const override { return p_index ? TTR("Stop HTTP Server") : TTR("Run exported HTML in the system's default browser."); }
virtual Ref<ImageTexture> get_option_icon(int p_index) const override;
virtual Error run(const Ref<EditorExportPreset> &p_preset, int p_option, int p_debug_flags) override;
virtual Ref<Texture2D> get_run_icon() const override;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void get_platform_features(List<String> *r_features) override {
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 22:00:46 +02:00
r_features->push_back("web");
Fix HTML5 feature tags 'HTML5' is the platform tag, the 'JavaScript' tag indicates availability of the JavaScript.eval singleton. Also report texture compression support.
2018-01-12 00:15:21 +01:00
r_features->push_back(get_os_name());
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 22:00:46 +02:00
}
Add override keywords.
2020-07-10 12:34:39 +02:00
virtual void resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, Set<String> &p_features) override {
BPTC support
2018-08-22 04:56:04 +02:00
}
Add override keywords.
2020-07-10 12:34:39 +02:00
String get_debug_protocol() const override { return "ws://"; }
Add WebSocket debugger, use it for Javascript.
2020-03-16 17:02:14 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
EditorExportPlatformJavaScript();
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
~EditorExportPlatformJavaScript();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
Error EditorExportPlatformJavaScript::_extract_template(const String &p_template, const String &p_dir, const String &p_name, bool pwa) {
Replace remaining uses of `NULL` with `nullptr` Follow-up to #38736 (these uses were likely added after this PR was merged).
2021-04-29 11:47:24 +02:00
FileAccess *src_f = nullptr;
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
zlib_filefunc_def io = zipio_create_io_from_file(&src_f);
unzFile pkg = unzOpen2(p_template.utf8().get_data(), &io);
if (!pkg) {
EditorNode::get_singleton()->show_warning(TTR("Could not open template for export:") + "\n" + p_template);
return ERR_FILE_NOT_FOUND;
}
if (unzGoToFirstFile(pkg) != UNZ_OK) {
EditorNode::get_singleton()->show_warning(TTR("Invalid export template:") + "\n" + p_template);
unzClose(pkg);
return ERR_FILE_CORRUPT;
}
do {
//get filename
unz_file_info info;
char fname[16384];
Replace remaining uses of `NULL` with `nullptr` Follow-up to #38736 (these uses were likely added after this PR was merged).
2021-04-29 11:47:24 +02:00
unzGetCurrentFileInfo(pkg, &info, fname, 16384, nullptr, 0, nullptr, 0);
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
String file = fname;
// Skip service worker and offline page if not exporting pwa.
if (!pwa && (file == "godot.service.worker.js" || file == "godot.offline.html")) {
continue;
}
Vector<uint8_t> data;
data.resize(info.uncompressed_size);
//read
unzOpenCurrentFile(pkg);
unzReadCurrentFile(pkg, data.ptrw(), data.size());
unzCloseCurrentFile(pkg);
//write
String dst = p_dir.plus_file(file.replace("godot", p_name));
FileAccess *f = FileAccess::open(dst, FileAccess::WRITE);
if (!f) {
EditorNode::get_singleton()->show_warning(TTR("Could not write file:") + "\n" + dst);
unzClose(pkg);
return ERR_FILE_CANT_WRITE;
}
f->store_buffer(data.ptr(), data.size());
memdelete(f);
} while (unzGoToNextFile(pkg) == UNZ_OK);
unzClose(pkg);
return OK;
}
Error EditorExportPlatformJavaScript::_write_or_error(const uint8_t *p_content, int p_size, String p_path) {
FileAccess *f = FileAccess::open(p_path, FileAccess::WRITE);
if (!f) {
EditorNode::get_singleton()->show_warning(TTR("Could not write file:") + "\n" + p_path);
return ERR_FILE_CANT_WRITE;
}
f->store_buffer(p_content, p_size);
memdelete(f);
return OK;
}
void EditorExportPlatformJavaScript::_replace_strings(Map<String, String> p_replaces, Vector<uint8_t> &r_template) {
String str_template = String::utf8(reinterpret_cast<const char *>(r_template.ptr()), r_template.size());
String out;
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
Vector<String> lines = str_template.split("\n");
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
for (int i = 0; i < lines.size(); i++) {
String current_line = lines[i];
for (Map<String, String>::Element *E = p_replaces.front(); E; E = E->next()) {
current_line = current_line.replace(E->key(), E->get());
}
out += current_line + "\n";
}
CharString cs = out.utf8();
r_template.resize(cs.length());
for (int i = 0; i < cs.length(); i++) {
r_template.write[i] = cs[i];
}
}
void EditorExportPlatformJavaScript::_fix_html(Vector<uint8_t> &p_html, const Ref<EditorExportPreset> &p_preset, const String &p_name, bool p_debug, int p_flags, const Vector<SharedObject> p_shared_objects, const Dictionary &p_file_sizes) {
// Engine.js config
Dictionary config;
[HTML5] Easier HTML templates, better deinit/cleanup.
2021-02-07 13:45:04 +01:00
Array libs;
[HTML5] EditorRunNative works with GDNative. This "breaks" our loading bar logic (libraries are not counted). Fixing it is non trivial and probably deserves investigating a different strategy.
2020-12-05 00:37:41 +01:00
for (int i = 0; i < p_shared_objects.size(); i++) {
[HTML5] Easier HTML templates, better deinit/cleanup.
2021-02-07 13:45:04 +01:00
libs.push_back(p_shared_objects[i].path.get_file());
}
Vector<String> flags;
gen_export_flags(flags, p_flags & (~DEBUG_FLAG_DUMB_CLIENT));
Array args;
for (int i = 0; i < flags.size(); i++) {
args.push_back(flags[i]);
[HTML5] EditorRunNative works with GDNative. This "breaks" our loading bar logic (libraries are not counted). Fixing it is non trivial and probably deserves investigating a different strategy.
2020-12-05 00:37:41 +01:00
}
[HTML5] Better fullscreen, canvas resizing. Three canvas resize policies: - `None`: Godot window settings are ignored. - `Project`: Godot handles the canvas like a native app (resizing it when setting the window size). - `Adaptive`: Canvas size will always adapt to browser window size. Use `None` if you want to control the canvas size with custom JavaScript code.
2021-01-30 11:35:03 +01:00
config["canvasResizePolicy"] = p_preset->get("html/canvas_resize_policy");
[HTML5] Opt-in virtual keyboard support. Added as an export option "Experimental Virtual Keyboard". There is no zoom, so text/line edit must be in the top part of the screen, or it will get hidden by the virtual keyboard. UTF8/Latin-1 only (I think regular UTF-8 should work out of the box in 4.0 but I can't test it). It uses an hidden textarea or input, based on the multiline variable, and only gets activated if the device has a touchscreen. This could cause problems on devices with both touchscreen and a real keyboard (although input should still work in general with some minor focus issues). I'm thinking of a system to detect the first physical keystroke and disable it in case, but it might do more harm then good, so it must be well thought.
2021-03-08 23:16:51 +01:00
config["experimentalVK"] = p_preset->get("html/experimental_virtual_keyboard");
[HTML5] Add option to focus canvas on start. Enabled by default.
2021-06-25 19:07:17 +02:00
config["focusCanvas"] = p_preset->get("html/focus_canvas_on_start");
[HTML5] Easier HTML templates, better deinit/cleanup.
2021-02-07 13:45:04 +01:00
config["gdnativeLibs"] = libs;
config["executable"] = p_name;
config["args"] = args;
[HTML5] Export process writes sizes in template. This allow the loading bar to be much more reliable, even in cases where realible stream loading status is not detectable (server-side compression, chunked encoding).
2021-03-01 17:53:56 +01:00
config["fileSizes"] = p_file_sizes;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[HTML5] Optional icon generation, use export name for it. We used to only generate the favicon if it was specified in the user project settings, now it's optional, will export it to `NAME.icon.png`, (falling back to the default project icon if none is set in project settings), and the `<link>` tag is added using the `$HEAD_INCLUDE` instead of being hardcoded in the template.
2021-03-26 12:44:17 +01:00
String head_include;
if (p_preset->get("html/export_icon")) {
head_include += "<link id='-gd-engine-icon' rel='icon' type='image/png' href='" + p_name + ".icon.png' />\n";
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
head_include += "<link rel='apple-touch-icon' href='" + p_name + ".apple-touch-icon.png'/>\n";
[HTML5] Optional icon generation, use export name for it. We used to only generate the favicon if it was specified in the user project settings, now it's optional, will export it to `NAME.icon.png`, (falling back to the default project icon if none is set in project settings), and the `<link>` tag is added using the `$HEAD_INCLUDE` instead of being hardcoded in the template.
2021-03-26 12:44:17 +01:00
}
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
if (p_preset->get("progressive_web_app/enabled")) {
head_include += "<link rel='manifest' href='" + p_name + ".manifest.json'>\n";
head_include += "<script type='application/javascript'>window.addEventListener('load', () => {if ('serviceWorker' in navigator) {navigator.serviceWorker.register('" +
p_name + ".service.worker.js');}});</script>\n";
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
// Replaces HTML string
Consolidate JSON, JSONParseResults and JSONParser into JSON Renames JSON.parse_string() to parse() Renames JSON.decode_data() to stringify()
2020-12-29 19:12:33 +01:00
const String str_config = Variant(config).to_json_string();
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
const String custom_head_include = p_preset->get("html/head_include");
Map<String, String> replaces;
replaces["$GODOT_URL"] = p_name + ".js";
replaces["$GODOT_PROJECT_NAME"] = ProjectSettings::get_singleton()->get_setting("application/config/name");
replaces["$GODOT_HEAD_INCLUDE"] = head_include + custom_head_include;
replaces["$GODOT_CONFIG"] = str_config;
_replace_strings(replaces, p_html);
}
Error EditorExportPlatformJavaScript::_add_manifest_icon(const String &p_path, const String &p_icon, int p_size, Array &r_arr) {
const String name = p_path.get_file().get_basename();
const String icon_name = vformat("%s.%dx%d.png", name, p_size, p_size);
const String icon_dest = p_path.get_base_dir().plus_file(icon_name);
Ref<Image> icon;
if (!p_icon.is_empty()) {
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
icon.instantiate();
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
const Error err = ImageLoader::load_image(p_icon, icon);
if (err != OK) {
EditorNode::get_singleton()->show_warning(TTR("Could not read file:") + "\n" + p_icon);
return err;
}
if (icon->get_width() != p_size || icon->get_height() != p_size) {
icon->resize(p_size, p_size);
}
} else {
icon = _get_project_icon();
icon->resize(p_size, p_size);
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
}
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
const Error err = icon->save_png(icon_dest);
if (err != OK) {
EditorNode::get_singleton()->show_warning(TTR("Could not write file:") + "\n" + icon_dest);
return err;
}
Dictionary icon_dict;
icon_dict["sizes"] = vformat("%dx%d", p_size, p_size);
icon_dict["type"] = "image/png";
icon_dict["src"] = icon_name;
r_arr.push_back(icon_dict);
return err;
}
Error EditorExportPlatformJavaScript::_build_pwa(const Ref<EditorExportPreset> &p_preset, const String p_path, const Vector<SharedObject> &p_shared_objects) {
// Service worker
const String dir = p_path.get_base_dir();
const String name = p_path.get_file().get_basename();
const ExportMode mode = (ExportMode)(int)p_preset->get("variant/export_type");
Map<String, String> replaces;
replaces["@GODOT_VERSION@"] = "1";
replaces["@GODOT_NAME@"] = name;
replaces["@GODOT_OFFLINE_PAGE@"] = name + ".offline.html";
Array files;
Consolidate JSON, JSONParseResults and JSONParser into JSON Renames JSON.parse_string() to parse() Renames JSON.decode_data() to stringify()
2020-12-29 19:12:33 +01:00
replaces["@GODOT_OPT_CACHE@"] = Variant(files).to_json_string();
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
files.push_back(name + ".html");
files.push_back(name + ".js");
files.push_back(name + ".wasm");
files.push_back(name + ".pck");
files.push_back(name + ".offline.html");
if (p_preset->get("html/export_icon")) {
files.push_back(name + ".icon.png");
files.push_back(name + ".apple-touch-icon.png");
}
if (mode == EXPORT_MODE_THREADS) {
files.push_back(name + ".worker.js");
files.push_back(name + ".audio.worklet.js");
} else if (mode == EXPORT_MODE_GDNATIVE) {
files.push_back(name + ".side.wasm");
for (int i = 0; i < p_shared_objects.size(); i++) {
files.push_back(p_shared_objects[i].path.get_file());
}
}
Consolidate JSON, JSONParseResults and JSONParser into JSON Renames JSON.parse_string() to parse() Renames JSON.decode_data() to stringify()
2020-12-29 19:12:33 +01:00
replaces["@GODOT_CACHE@"] = Variant(files).to_json_string();
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
const String sw_path = dir.plus_file(name + ".service.worker.js");
Vector<uint8_t> sw;
{
FileAccess *f = FileAccess::open(sw_path, FileAccess::READ);
if (!f) {
EditorNode::get_singleton()->show_warning(TTR("Could not read file:") + "\n" + sw_path);
return ERR_FILE_CANT_READ;
}
Rename File::get_len() get_length()
2021-05-25 08:58:49 +02:00
sw.resize(f->get_length());
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
f->get_buffer(sw.ptrw(), sw.size());
memdelete(f);
f = nullptr;
}
_replace_strings(replaces, sw);
Error err = _write_or_error(sw.ptr(), sw.size(), dir.plus_file(name + ".service.worker.js"));
if (err != OK) {
return err;
}
// Custom offline page
const String offline_page = p_preset->get("progressive_web_app/offline_page");
if (!offline_page.is_empty()) {
DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
const String offline_dest = dir.plus_file(name + ".offline.html");
err = da->copy(ProjectSettings::get_singleton()->globalize_path(offline_page), offline_dest);
if (err != OK) {
EditorNode::get_singleton()->show_warning(TTR("Could not read file:") + "\n" + offline_dest);
return err;
}
}
// Manifest
const char *modes[4] = { "fullscreen", "standalone", "minimal-ui", "browser" };
const char *orientations[3] = { "any", "landscape", "portrait" };
const int display = CLAMP(int(p_preset->get("progressive_web_app/display")), 0, 4);
const int orientation = CLAMP(int(p_preset->get("progressive_web_app/orientation")), 0, 3);
Dictionary manifest;
String proj_name = ProjectSettings::get_singleton()->get_setting("application/config/name");
if (proj_name.is_empty()) {
proj_name = "Godot Game";
}
manifest["name"] = proj_name;
manifest["start_url"] = "./" + name + ".html";
manifest["display"] = String::utf8(modes[display]);
manifest["orientation"] = String::utf8(orientations[orientation]);
manifest["background_color"] = "#" + p_preset->get("progressive_web_app/background_color").operator Color().to_html(false);
Array icons_arr;
const String icon144_path = p_preset->get("progressive_web_app/icon_144x144");
err = _add_manifest_icon(p_path, icon144_path, 144, icons_arr);
if (err != OK) {
return err;
}
const String icon180_path = p_preset->get("progressive_web_app/icon_180x180");
err = _add_manifest_icon(p_path, icon180_path, 180, icons_arr);
if (err != OK) {
return err;
}
const String icon512_path = p_preset->get("progressive_web_app/icon_512x512");
err = _add_manifest_icon(p_path, icon512_path, 512, icons_arr);
if (err != OK) {
return err;
}
manifest["icons"] = icons_arr;
Consolidate JSON, JSONParseResults and JSONParser into JSON Renames JSON.parse_string() to parse() Renames JSON.decode_data() to stringify()
2020-12-29 19:12:33 +01:00
CharString cs = Variant(manifest).to_json_string().utf8();
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
err = _write_or_error((const uint8_t *)cs.get_data(), cs.length(), dir.plus_file(name + ".manifest.json"));
if (err != OK) {
return err;
}
return OK;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
void EditorExportPlatformJavaScript::get_preset_features(const Ref<EditorExportPreset> &p_preset, List<String> *r_features) {
Improve VRAM texture compression checks for mobile/web For HTML5, we need to support S3TC if running on desktop, and ETC or ETC2 for mobile, so make this explicit. Add logic to check for ETC2 support on GLES3, and remove incorrect ETC feature for GLES3 on Android. Fix ETC check invalidating templates on HTML5. Fixes #26476.
2019-03-03 11:52:53 +01:00
if (p_preset->get("vram_texture_compression/for_desktop")) {
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
r_features->push_back("s3tc");
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Improve VRAM texture compression checks for mobile/web For HTML5, we need to support S3TC if running on desktop, and ETC or ETC2 for mobile, so make this explicit. Add logic to check for ETC2 support on GLES3, and remove incorrect ETC feature for GLES3 on Android. Fix ETC check invalidating templates on HTML5. Fixes #26476.
2019-03-03 11:52:53 +01:00
if (p_preset->get("vram_texture_compression/for_mobile")) {
Reorganize Project Settings -Advanced Settings toggle also hides advanced properties when disabled -Simplified Advanced Bar (errors were just plain redundant) -Reorganized rendering quality settings. -Reorganized miscelaneous settings for clean up.
2021-02-17 17:44:49 +01:00
String driver = ProjectSettings::get_singleton()->get("rendering/driver/driver_name");
Improve VRAM texture compression checks for mobile/web For HTML5, we need to support S3TC if running on desktop, and ETC or ETC2 for mobile, so make this explicit. Add logic to check for ETC2 support on GLES3, and remove incorrect ETC feature for GLES3 on Android. Fix ETC check invalidating templates on HTML5. Fixes #26476.
2019-03-03 11:52:53 +01:00
if (driver == "GLES2") {
r_features->push_back("etc");
Remove obsolete GLES3 backend Due to the port to Vulkan and complete redesign of the rendering backend, the `drivers/gles3` code is no longer usable in this state and is not planned to be ported to the new architecture. The GLES2 backend is kept (while still disabled and non-working) as it will eventually be ported to serve as the low-end renderer for Godot 4.0. Some GLES3 features might be selectively ported to the updated GLES2 backend if there's a need for them, and extensions we can use for that. So long, OpenGL driver bugs!
2020-02-13 10:08:52 +01:00
} else if (driver == "Vulkan") {
// FIXME: Review if this is correct.
Improve VRAM texture compression checks for mobile/web For HTML5, we need to support S3TC if running on desktop, and ETC or ETC2 for mobile, so make this explicit. Add logic to check for ETC2 support on GLES3, and remove incorrect ETC feature for GLES3 on Android. Fix ETC check invalidating templates on HTML5. Fixes #26476.
2019-03-03 11:52:53 +01:00
r_features->push_back("etc2");
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
[HTML5] Make GDNative support feature-based. This is suboptimal as it requires adding an extra compile flag, but rewriting how feature tags work is beyond the scope of this work.
2020-12-03 17:15:14 +01:00
ExportMode mode = (ExportMode)(int)p_preset->get("variant/export_type");
if (mode == EXPORT_MODE_THREADS) {
r_features->push_back("threads");
} else if (mode == EXPORT_MODE_GDNATIVE) {
r_features->push_back("wasm32");
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
void EditorExportPlatformJavaScript::get_export_options(List<ExportOption> *r_options) {
Export: Reorder options for consistency across platforms
2020-11-20 10:45:39 +01:00
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_template/debug", PROPERTY_HINT_GLOBAL_FILE, "*.zip"), ""));
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_template/release", PROPERTY_HINT_GLOBAL_FILE, "*.zip"), ""));
[HTML5] Allow selecting the export type. Available types: - Regular - GDNative (support dynamic linking and thus GDNative WASM files) - Threads (uses WebAssembly Threads)
2020-12-03 14:42:25 +01:00
r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "variant/export_type", PROPERTY_HINT_ENUM, "Regular,Threads,GDNative"), 0)); // Export type.
Improve VRAM texture compression checks for mobile/web For HTML5, we need to support S3TC if running on desktop, and ETC or ETC2 for mobile, so make this explicit. Add logic to check for ETC2 support on GLES3, and remove incorrect ETC feature for GLES3 on Android. Fix ETC check invalidating templates on HTML5. Fixes #26476.
2019-03-03 11:52:53 +01:00
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "vram_texture_compression/for_desktop"), true)); // S3TC
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "vram_texture_compression/for_mobile"), false)); // ETC or ETC2, depending on renderer
Export: Reorder options for consistency across platforms
2020-11-20 10:45:39 +01:00
[HTML5] Optional icon generation, use export name for it. We used to only generate the favicon if it was specified in the user project settings, now it's optional, will export it to `NAME.icon.png`, (falling back to the default project icon if none is set in project settings), and the `<link>` tag is added using the `$HEAD_INCLUDE` instead of being hardcoded in the template.
2021-03-26 12:44:17 +01:00
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "html/export_icon"), true));
Fix file hints Fixes file hints so the file dialog actually displays the files with given extension (e.g. *.apk).
2018-08-23 21:45:48 +02:00
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "html/custom_html_shell", PROPERTY_HINT_FILE, "*.html"), ""));
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "html/head_include", PROPERTY_HINT_MULTILINE_TEXT), ""));
[HTML5] Better fullscreen, canvas resizing. Three canvas resize policies: - `None`: Godot window settings are ignored. - `Project`: Godot handles the canvas like a native app (resizing it when setting the window size). - `Adaptive`: Canvas size will always adapt to browser window size. Use `None` if you want to control the canvas size with custom JavaScript code.
2021-01-30 11:35:03 +01:00
r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "html/canvas_resize_policy", PROPERTY_HINT_ENUM, "None,Project,Adaptive"), 2));
[HTML5] Add option to focus canvas on start. Enabled by default.
2021-06-25 19:07:17 +02:00
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "html/focus_canvas_on_start"), true));
[HTML5] Opt-in virtual keyboard support. Added as an export option "Experimental Virtual Keyboard". There is no zoom, so text/line edit must be in the top part of the screen, or it will get hidden by the virtual keyboard. UTF8/Latin-1 only (I think regular UTF-8 should work out of the box in 4.0 but I can't test it). It uses an hidden textarea or input, based on the multiline variable, and only gets activated if the device has a touchscreen. This could cause problems on devices with both touchscreen and a real keyboard (although input should still work in general with some minor focus issues). I'm thinking of a system to detect the first physical keystroke and disable it in case, but it might do more harm then good, so it must be well thought.
2021-03-08 23:16:51 +01:00
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "html/experimental_virtual_keyboard"), false));
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "progressive_web_app/enabled"), false));
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "progressive_web_app/offline_page", PROPERTY_HINT_FILE, "*.html"), ""));
Tweak dozens of editor property hints for consistency - Update Viewport MSAA property hints to match the currently exposed values. - Add some performance hints to property hints.
2021-05-22 04:30:58 +02:00
r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "progressive_web_app/display", PROPERTY_HINT_ENUM, "Fullscreen,Standalone,Minimal UI,Browser"), 1));
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "progressive_web_app/orientation", PROPERTY_HINT_ENUM, "Any,Landscape,Portrait"), 0));
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "progressive_web_app/icon_144x144", PROPERTY_HINT_FILE, "*.png,*.webp,*.svg,*.svgz"), ""));
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "progressive_web_app/icon_180x180", PROPERTY_HINT_FILE, "*.png,*.webp,*.svg,*.svgz"), ""));
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "progressive_web_app/icon_512x512", PROPERTY_HINT_FILE, "*.png,*.webp,*.svg,*.svgz"), ""));
r_options->push_back(ExportOption(PropertyInfo(Variant::COLOR, "progressive_web_app/background_color", PROPERTY_HINT_COLOR_NO_ALPHA), Color()));
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
String EditorExportPlatformJavaScript::get_name() const {
return "HTML5";
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 22:00:46 +02:00
String EditorExportPlatformJavaScript::get_os_name() const {
Fix HTML5 feature tags 'HTML5' is the platform tag, the 'JavaScript' tag indicates availability of the JavaScript.eval singleton. Also report texture compression support.
2018-01-12 00:15:21 +01:00
return "HTML5";
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 22:00:46 +02:00
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
Ref<Texture2D> EditorExportPlatformJavaScript::get_logo() const {
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
return logo;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
bool EditorExportPlatformJavaScript::can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const {
fix Android/HTML5 custom templates option does not work
2018-08-20 17:35:33 +02:00
String err;
Export: Improve usability of command line interface I'm barely scratching the surface of the changes needed to make the --export command line interface easy to use, but this should already improve things somewhat. - Streamline `can_export()` templates check in all platforms, checking first for the presence of official templates, then of any defined custom template, and reporting on the absence of any. Shouldn't change the actual return value much which is still true if either release or debug is usable - we might want to change that eventually and better validate against the requested target. - Fix discrepancy between platforms using `custom_package/debug` and `custom_template/debug` (resp. `release`). All now use `custom_template`, which will break compatibility for `export_presets.cfg` with earlier projects (but is easy to fix). - Use `can_export()` when attempting a command line export and report the same errors that would be shown in the editor. - Improve error reporting after a failed export attempt, handling missing template and invalid path more gracefully. - Cleanup of unused stuff in EditorNode around the export workflow. - Improve --export documentation in --help a bit. Fixes #16949 (at least many of the misunderstandings listed there). Fixes #18470.
2020-01-07 13:29:02 +01:00
bool valid = false;
[HTML5] Allow selecting the export type. Available types: - Regular - GDNative (support dynamic linking and thus GDNative WASM files) - Threads (uses WebAssembly Threads)
2020-12-03 14:42:25 +01:00
ExportMode mode = (ExportMode)(int)p_preset->get("variant/export_type");
fix Android/HTML5 custom templates option does not work
2018-08-20 17:35:33 +02:00
Export: Improve usability of command line interface I'm barely scratching the surface of the changes needed to make the --export command line interface easy to use, but this should already improve things somewhat. - Streamline `can_export()` templates check in all platforms, checking first for the presence of official templates, then of any defined custom template, and reporting on the absence of any. Shouldn't change the actual return value much which is still true if either release or debug is usable - we might want to change that eventually and better validate against the requested target. - Fix discrepancy between platforms using `custom_package/debug` and `custom_template/debug` (resp. `release`). All now use `custom_template`, which will break compatibility for `export_presets.cfg` with earlier projects (but is easy to fix). - Use `can_export()` when attempting a command line export and report the same errors that would be shown in the editor. - Improve error reporting after a failed export attempt, handling missing template and invalid path more gracefully. - Cleanup of unused stuff in EditorNode around the export workflow. - Improve --export documentation in --help a bit. Fixes #16949 (at least many of the misunderstandings listed there). Fixes #18470.
2020-01-07 13:29:02 +01:00
// Look for export templates (first official, and if defined custom templates).
[HTML5] Allow selecting the export type. Available types: - Regular - GDNative (support dynamic linking and thus GDNative WASM files) - Threads (uses WebAssembly Threads)
2020-12-03 14:42:25 +01:00
bool dvalid = exists_export_template(_get_template_name(mode, true), &err);
bool rvalid = exists_export_template(_get_template_name(mode, false), &err);
fix Android/HTML5 custom templates option does not work
2018-08-20 17:35:33 +02:00
if (p_preset->get("custom_template/debug") != "") {
Export: Improve usability of command line interface I'm barely scratching the surface of the changes needed to make the --export command line interface easy to use, but this should already improve things somewhat. - Streamline `can_export()` templates check in all platforms, checking first for the presence of official templates, then of any defined custom template, and reporting on the absence of any. Shouldn't change the actual return value much which is still true if either release or debug is usable - we might want to change that eventually and better validate against the requested target. - Fix discrepancy between platforms using `custom_package/debug` and `custom_template/debug` (resp. `release`). All now use `custom_template`, which will break compatibility for `export_presets.cfg` with earlier projects (but is easy to fix). - Use `can_export()` when attempting a command line export and report the same errors that would be shown in the editor. - Improve error reporting after a failed export attempt, handling missing template and invalid path more gracefully. - Cleanup of unused stuff in EditorNode around the export workflow. - Improve --export documentation in --help a bit. Fixes #16949 (at least many of the misunderstandings listed there). Fixes #18470.
2020-01-07 13:29:02 +01:00
dvalid = FileAccess::exists(p_preset->get("custom_template/debug"));
if (!dvalid) {
ExportDialog: Make error messages translatable Also fix missing newlines that caused #24202.
2019-01-21 18:34:53 +01:00
err += TTR("Custom debug template not found.") + "\n";
fix Android/HTML5 custom templates option does not work
2018-08-20 17:35:33 +02:00
}
}
if (p_preset->get("custom_template/release") != "") {
Export: Improve usability of command line interface I'm barely scratching the surface of the changes needed to make the --export command line interface easy to use, but this should already improve things somewhat. - Streamline `can_export()` templates check in all platforms, checking first for the presence of official templates, then of any defined custom template, and reporting on the absence of any. Shouldn't change the actual return value much which is still true if either release or debug is usable - we might want to change that eventually and better validate against the requested target. - Fix discrepancy between platforms using `custom_package/debug` and `custom_template/debug` (resp. `release`). All now use `custom_template`, which will break compatibility for `export_presets.cfg` with earlier projects (but is easy to fix). - Use `can_export()` when attempting a command line export and report the same errors that would be shown in the editor. - Improve error reporting after a failed export attempt, handling missing template and invalid path more gracefully. - Cleanup of unused stuff in EditorNode around the export workflow. - Improve --export documentation in --help a bit. Fixes #16949 (at least many of the misunderstandings listed there). Fixes #18470.
2020-01-07 13:29:02 +01:00
rvalid = FileAccess::exists(p_preset->get("custom_template/release"));
if (!rvalid) {
ExportDialog: Make error messages translatable Also fix missing newlines that caused #24202.
2019-01-21 18:34:53 +01:00
err += TTR("Custom release template not found.") + "\n";
fix Android/HTML5 custom templates option does not work
2018-08-20 17:35:33 +02:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Export: Improve usability of command line interface I'm barely scratching the surface of the changes needed to make the --export command line interface easy to use, but this should already improve things somewhat. - Streamline `can_export()` templates check in all platforms, checking first for the presence of official templates, then of any defined custom template, and reporting on the absence of any. Shouldn't change the actual return value much which is still true if either release or debug is usable - we might want to change that eventually and better validate against the requested target. - Fix discrepancy between platforms using `custom_package/debug` and `custom_template/debug` (resp. `release`). All now use `custom_template`, which will break compatibility for `export_presets.cfg` with earlier projects (but is easy to fix). - Use `can_export()` when attempting a command line export and report the same errors that would be shown in the editor. - Improve error reporting after a failed export attempt, handling missing template and invalid path more gracefully. - Cleanup of unused stuff in EditorNode around the export workflow. - Improve --export documentation in --help a bit. Fixes #16949 (at least many of the misunderstandings listed there). Fixes #18470.
2020-01-07 13:29:02 +01:00
valid = dvalid || rvalid;
Improve VRAM texture compression checks for mobile/web For HTML5, we need to support S3TC if running on desktop, and ETC or ETC2 for mobile, so make this explicit. Add logic to check for ETC2 support on GLES3, and remove incorrect ETC feature for GLES3 on Android. Fix ETC check invalidating templates on HTML5. Fixes #26476.
2019-03-03 11:52:53 +01:00
r_missing_templates = !valid;
Export: Improve usability of command line interface I'm barely scratching the surface of the changes needed to make the --export command line interface easy to use, but this should already improve things somewhat. - Streamline `can_export()` templates check in all platforms, checking first for the presence of official templates, then of any defined custom template, and reporting on the absence of any. Shouldn't change the actual return value much which is still true if either release or debug is usable - we might want to change that eventually and better validate against the requested target. - Fix discrepancy between platforms using `custom_package/debug` and `custom_template/debug` (resp. `release`). All now use `custom_template`, which will break compatibility for `export_presets.cfg` with earlier projects (but is easy to fix). - Use `can_export()` when attempting a command line export and report the same errors that would be shown in the editor. - Improve error reporting after a failed export attempt, handling missing template and invalid path more gracefully. - Cleanup of unused stuff in EditorNode around the export workflow. - Improve --export documentation in --help a bit. Fixes #16949 (at least many of the misunderstandings listed there). Fixes #18470.
2020-01-07 13:29:02 +01:00
// Validate the rest of the configuration.
Improve VRAM texture compression checks for mobile/web For HTML5, we need to support S3TC if running on desktop, and ETC or ETC2 for mobile, so make this explicit. Add logic to check for ETC2 support on GLES3, and remove incorrect ETC feature for GLES3 on Android. Fix ETC check invalidating templates on HTML5. Fixes #26476.
2019-03-03 11:52:53 +01:00
if (p_preset->get("vram_texture_compression/for_mobile")) {
String etc_error = test_etc2();
if (etc_error != String()) {
valid = false;
err += etc_error;
}
-Properly handle missing ETC support on export -Added ability for resource importers to save metadata -Added ability for resource importers to validate depending on project settings
2019-02-26 22:43:37 +01:00
}
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
if (!err.is_empty()) {
fix Android/HTML5 custom templates option does not work
2018-08-20 17:35:33 +02:00
r_error = err;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
fix Android/HTML5 custom templates option does not work
2018-08-20 17:35:33 +02:00
return valid;
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Export for OS X on OS X now lets you select .dmg or .zip
2018-10-29 22:18:49 +01:00
List<String> EditorExportPlatformJavaScript::get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const {
List<String> list;
list.push_back("html");
return list;
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
Error EditorExportPlatformJavaScript::export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
Allow configuring iOS export - EditorExportPlugin's _export_begin accepts all the arguments related to the current export (is_debug, path, flags). - EditorExportPlugin API is extended with methods allowing to configure iOS export: add_ios_framework, add_ios_plist_content, add_ios_linker_flags, add_ios_bundle_file. - iOS export template now contains Godot as a static library so that it can be linked with third-party Frameworks and GDNative static libraries. - Adds method to DirAccess for recursive copying of a directory. - Fixes iOS export to work with Xcode 9 (released recently).
2017-10-02 17:01:43 +02:00
ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
const String custom_debug = p_preset->get("custom_template/debug");
const String custom_release = p_preset->get("custom_template/release");
const String custom_html = p_preset->get("html/custom_html_shell");
const bool export_icon = p_preset->get("html/export_icon");
const bool pwa = p_preset->get("progressive_web_app/enabled");
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
const String base_dir = p_path.get_base_dir();
const String base_path = p_path.get_basename();
const String base_name = p_path.get_file().get_basename();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
// Find the correct template
String template_path = p_debug ? custom_debug : custom_release;
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
template_path = template_path.strip_edges();
if (template_path == String()) {
[HTML5] Allow selecting the export type. Available types: - Regular - GDNative (support dynamic linking and thus GDNative WASM files) - Threads (uses WebAssembly Threads)
2020-12-03 14:42:25 +01:00
ExportMode mode = (ExportMode)(int)p_preset->get("variant/export_type");
template_path = find_export_template(_get_template_name(mode, p_debug));
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
if (!DirAccess::exists(base_dir)) {
Fixes misleading error message when trying to export This patch fixes the misleading error message when users try to "export all" into an invalid destination path. Closes #26539
2019-03-05 08:52:45 +01:00
return ERR_FILE_BAD_PATH;
}
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
if (template_path != String() && !FileAccess::exists(template_path)) {
Add missing translation in Javascript export dialog Also remove newlines from translated strings.
2018-01-04 16:08:24 +01:00
EditorNode::get_singleton()->show_warning(TTR("Template file not found:") + "\n" + template_path);
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
return ERR_FILE_NOT_FOUND;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
// Export pck and shared objects
[HTML5] EditorRunNative works with GDNative. This "breaks" our loading bar logic (libraries are not counted). Fixing it is non trivial and probably deserves investigating a different strategy.
2020-12-05 00:37:41 +01:00
Vector<SharedObject> shared_objects;
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
String pck_path = base_path + ".pck";
[HTML5] EditorRunNative works with GDNative. This "breaks" our loading bar logic (libraries are not counted). Fixing it is non trivial and probably deserves investigating a different strategy.
2020-12-05 00:37:41 +01:00
Error error = save_pack(p_preset, pck_path, &shared_objects);
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
if (error != OK) {
Add missing translation in Javascript export dialog Also remove newlines from translated strings.
2018-01-04 16:08:24 +01:00
EditorNode::get_singleton()->show_warning(TTR("Could not write file:") + "\n" + pck_path);
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
return error;
}
[HTML5] EditorRunNative works with GDNative. This "breaks" our loading bar logic (libraries are not counted). Fixing it is non trivial and probably deserves investigating a different strategy.
2020-12-05 00:37:41 +01:00
DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
for (int i = 0; i < shared_objects.size(); i++) {
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
String dst = base_dir.plus_file(shared_objects[i].path.get_file());
[HTML5] EditorRunNative works with GDNative. This "breaks" our loading bar logic (libraries are not counted). Fixing it is non trivial and probably deserves investigating a different strategy.
2020-12-05 00:37:41 +01:00
error = da->copy(shared_objects[i].path, dst);
if (error != OK) {
EditorNode::get_singleton()->show_warning(TTR("Could not write file:") + "\n" + shared_objects[i].path.get_file());
memdelete(da);
return error;
}
}
memdelete(da);
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
da = nullptr;
-fixed export templates not loading/exporting on Windows -fixed TouchScreenButton with stretch2d -fixed(?) OSX crash on startup (test!!) -compilation fixes on windows -CollisionPolygon editor works again -find buttons en find dialog -TileMap editor cleanup (removed "error", made nicer) -viewport flicker fixed -make .scn default extension for saving scenes -export the rest of the network classes to gdscript
2014-02-13 22:03:28 +01:00
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
// Extract templates.
error = _extract_template(template_path, base_dir, base_name, pwa);
if (error) {
return error;
Export boot splash and add custom HTML file option in HTML5 export
2017-11-20 00:06:11 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
// Parse generated file sizes (pck and wasm, to help show a meaningful loading bar).
[HTML5] Export process writes sizes in template. This allow the loading bar to be much more reliable, even in cases where realible stream loading status is not detectable (server-side compression, chunked encoding).
2021-03-01 17:53:56 +01:00
Dictionary file_sizes;
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
FileAccess *f = nullptr;
f = FileAccess::open(pck_path, FileAccess::READ);
if (f) {
Rename File::get_len() get_length()
2021-05-25 08:58:49 +02:00
file_sizes[pck_path.get_file()] = (uint64_t)f->get_length();
Export boot splash and add custom HTML file option in HTML5 export
2017-11-20 00:06:11 +01:00
memdelete(f);
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
f = nullptr;
[HTML5] Export process writes sizes in template. This allow the loading bar to be much more reliable, even in cases where realible stream loading status is not detectable (server-side compression, chunked encoding).
2021-03-01 17:53:56 +01:00
}
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
f = FileAccess::open(base_path + ".wasm", FileAccess::READ);
if (f) {
Rename File::get_len() get_length()
2021-05-25 08:58:49 +02:00
file_sizes[base_name + ".wasm"] = (uint64_t)f->get_length();
Export boot splash and add custom HTML file option in HTML5 export
2017-11-20 00:06:11 +01:00
memdelete(f);
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
f = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
// Read the HTML shell file (custom or from template).
const String html_path = custom_html.is_empty() ? base_path + ".html" : custom_html;
Vector<uint8_t> html;
f = FileAccess::open(html_path, FileAccess::READ);
if (!f) {
EditorNode::get_singleton()->show_warning(TTR("Could not read HTML shell:") + "\n" + html_path);
return ERR_FILE_CANT_READ;
}
Rename File::get_len() get_length()
2021-05-25 08:58:49 +02:00
html.resize(f->get_length());
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
f->get_buffer(html.ptrw(), html.size());
memdelete(f);
f = nullptr;
// Generate HTML file with replaced strings.
_fix_html(html, p_preset, base_name, p_debug, p_flags, shared_objects, file_sizes);
Error err = _write_or_error(html.ptr(), html.size(), p_path);
if (err != OK) {
return err;
Export boot splash and add custom HTML file option in HTML5 export
2017-11-20 00:06:11 +01:00
}
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
html.resize(0);
// Export splash (why?)
Ref<Image> splash = _get_project_splash();
const String splash_png_path = base_path + ".png";
Export and reference the icon as favicon when exporting to HTML5 This makes the project icon display immediately as a favicon when opening the page, without having to wait for the project to finish loading.
2020-01-20 21:46:42 +01:00
if (splash->save_png(splash_png_path) != OK) {
EditorNode::get_singleton()->show_warning(TTR("Could not write file:") + "\n" + splash_png_path);
Export boot splash and add custom HTML file option in HTML5 export
2017-11-20 00:06:11 +01:00
return ERR_FILE_CANT_WRITE;
}
Export and reference the icon as favicon when exporting to HTML5 This makes the project icon display immediately as a favicon when opening the page, without having to wait for the project to finish loading.
2020-01-20 21:46:42 +01:00
// Save a favicon that can be accessed without waiting for the project to finish loading.
// This way, the favicon can be displayed immediately when loading the page.
[HTML5] Optional icon generation, use export name for it. We used to only generate the favicon if it was specified in the user project settings, now it's optional, will export it to `NAME.icon.png`, (falling back to the default project icon if none is set in project settings), and the `<link>` tag is added using the `$HEAD_INCLUDE` instead of being hardcoded in the template.
2021-03-26 12:44:17 +01:00
if (export_icon) {
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
Ref<Image> favicon = _get_project_icon();
const String favicon_png_path = base_path + ".icon.png";
Export and reference the icon as favicon when exporting to HTML5 This makes the project icon display immediately as a favicon when opening the page, without having to wait for the project to finish loading.
2020-01-20 21:46:42 +01:00
if (favicon->save_png(favicon_png_path) != OK) {
EditorNode::get_singleton()->show_warning(TTR("Could not write file:") + "\n" + favicon_png_path);
return ERR_FILE_CANT_WRITE;
}
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
favicon->resize(180, 180);
const String apple_icon_png_path = base_path + ".apple-touch-icon.png";
if (favicon->save_png(apple_icon_png_path) != OK) {
EditorNode::get_singleton()->show_warning(TTR("Could not write file:") + "\n" + apple_icon_png_path);
return ERR_FILE_CANT_WRITE;
}
}
// Generate the PWA worker and manifest
if (pwa) {
err = _build_pwa(p_preset, p_path, shared_objects);
if (err != OK) {
return err;
}
Export and reference the icon as favicon when exporting to HTML5 This makes the project icon display immediately as a favicon when opening the page, without having to wait for the project to finish loading.
2020-01-20 21:46:42 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return OK;
}
Improve EditorExportPlatform interface. Convert all get_device* methods to get_option* and normalize their usage as icon, label, tooltip.
2019-10-11 13:47:28 +02:00
bool EditorExportPlatformJavaScript::poll_export() {
Hide HTML5 native-run icon without runnable preset
2017-06-27 03:13:36 +02:00
Ref<EditorExportPreset> preset;
for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
Ref<EditorExportPreset> ep = EditorExport::get_singleton()->get_export_preset(i);
if (ep->is_runnable() && ep->get_platform() == this) {
preset = ep;
break;
}
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
int prev = menu_options;
menu_options = preset.is_valid();
if (server->is_listening()) {
if (menu_options == 0) {
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
MutexLock lock(server_lock);
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
server->stop();
} else {
menu_options += 1;
}
}
return menu_options != prev;
}
Ref<ImageTexture> EditorExportPlatformJavaScript::get_option_icon(int p_index) const {
return p_index == 1 ? stop_icon : EditorExportPlatform::get_option_icon(p_index);
Hide HTML5 native-run icon without runnable preset
2017-06-27 03:13:36 +02:00
}
Improve EditorExportPlatform interface. Convert all get_device* methods to get_option* and normalize their usage as icon, label, tooltip.
2019-10-11 13:47:28 +02:00
int EditorExportPlatformJavaScript::get_options_count() const {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
return menu_options;
Hide HTML5 native-run icon without runnable preset
2017-06-27 03:13:36 +02:00
}
Improve EditorExportPlatform interface. Convert all get_device* methods to get_option* and normalize their usage as icon, label, tooltip.
2019-10-11 13:47:28 +02:00
Error EditorExportPlatformJavaScript::run(const Ref<EditorExportPreset> &p_preset, int p_option, int p_debug_flags) {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
if (p_option == 1) {
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
MutexLock lock(server_lock);
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
server->stop();
return OK;
}
Implement shader caching * Shader compilation is now cached. Subsequent loads take less than a millisecond. * Improved game, editor and project manager startup time. * Editor uses .godot/shader_cache to store shaders. * Game uses user://shader_cache * Project manager uses $config_dir/shader_cache * Options to tweak shader caching in project settings. * Editor path configuration moved from EditorSettings to new class, EditorPaths, so it can be available early on (before shaders are compiled). * Reworked ShaderCompilerRD to ensure deterministic shader code creation (else shader may change and cache will be invalidated). * Added shader compression with SMOLV: https://github.com/aras-p/smol-v
2021-05-25 02:25:11 +02:00
const String dest = EditorPaths::get_singleton()->get_cache_dir().plus_file("web");
[HTML5] Debug HttpServer now runs in `web` cache subdir. Serving all files in that folder and using a known list of mime types. Makes it easy to add more exported files, while still playing safe.
2021-03-26 11:48:56 +01:00
DirAccessRef da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
if (!da->dir_exists(dest)) {
Error err = da->make_dir_recursive(dest);
if (err != OK) {
EditorNode::get_singleton()->show_warning(TTR("Could not create HTTP server directory:") + "\n" + dest);
return err;
}
}
const String basepath = dest.plus_file("tmp_js_export");
Export and reference the icon as favicon when exporting to HTML5 This makes the project icon display immediately as a favicon when opening the page, without having to wait for the project to finish loading.
2020-01-20 21:46:42 +01:00
Error err = export_project(p_preset, true, basepath + ".html", p_debug_flags);
Export: Remove temp files from cache after export So far we left most temporary files lying around, so this attempts to fix that. I added a helper method to DirAccess to factor out the boilerplate of creating a DirAccess, checking if the file exists, remove it or print an error on failure.
2019-08-09 13:45:30 +02:00
if (err != OK) {
// Export generates several files, clean them up on failure.
DirAccess::remove_file_or_error(basepath + ".html");
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
DirAccess::remove_file_or_error(basepath + ".offline.html");
Export: Remove temp files from cache after export So far we left most temporary files lying around, so this attempts to fix that. I added a helper method to DirAccess to factor out the boilerplate of creating a DirAccess, checking if the file exists, remove it or print an error on failure.
2019-08-09 13:45:30 +02:00
DirAccess::remove_file_or_error(basepath + ".js");
[HTML5] Refactor JS, threads support, closures. - Refactored the Engine code, splitted across files. - Use MODULARIZE option to build emscripten code into it's own closure. - Enable lto support (saves ~2MiB in release). - Enable optional closure compiler pass for JS and generated code. - Enable optional pthreads support. - Can now build with tools=yes (not much to see yet). - Dropped some deprecated code for older toolchains.
2020-03-11 11:55:28 +01:00
DirAccess::remove_file_or_error(basepath + ".worker.js");
[HTML5] AudioWorklet API implementation. Rewrote AudioDriverJavaScript to support multiple processor nodes. The old (and deprecated) ScriptProcessorNode when threads are not available, and the new AudioWorklet API when threads are enabled. The new implementation uses two ring buffers and a shared state to communicated with the AudioWorklet thread. The audio.worklet.js JavaScript file is always added to the export template, but only really used (and downloaded) in the thread build.
2020-11-10 11:05:22 +01:00
DirAccess::remove_file_or_error(basepath + ".audio.worklet.js");
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
DirAccess::remove_file_or_error(basepath + ".service.worker.js");
Export: Remove temp files from cache after export So far we left most temporary files lying around, so this attempts to fix that. I added a helper method to DirAccess to factor out the boilerplate of creating a DirAccess, checking if the file exists, remove it or print an error on failure.
2019-08-09 13:45:30 +02:00
DirAccess::remove_file_or_error(basepath + ".pck");
DirAccess::remove_file_or_error(basepath + ".png");
[HTML5] EditorRunNative works with GDNative. This "breaks" our loading bar logic (libraries are not counted). Fixing it is non trivial and probably deserves investigating a different strategy.
2020-12-05 00:37:41 +01:00
DirAccess::remove_file_or_error(basepath + ".side.wasm");
Export: Remove temp files from cache after export So far we left most temporary files lying around, so this attempts to fix that. I added a helper method to DirAccess to factor out the boilerplate of creating a DirAccess, checking if the file exists, remove it or print an error on failure.
2019-08-09 13:45:30 +02:00
DirAccess::remove_file_or_error(basepath + ".wasm");
[HTML5] Optional icon generation, use export name for it. We used to only generate the favicon if it was specified in the user project settings, now it's optional, will export it to `NAME.icon.png`, (falling back to the default project icon if none is set in project settings), and the `<link>` tag is added using the `$HEAD_INCLUDE` instead of being hardcoded in the template.
2021-03-26 12:44:17 +01:00
DirAccess::remove_file_or_error(basepath + ".icon.png");
[HTML5] Export as Progressive Web App. Adds possibility to export as a progressive web app. Allows customizing base icons, display mode, orientation and offline page.
2021-03-18 16:19:09 +01:00
DirAccess::remove_file_or_error(basepath + ".apple-touch-icon.png");
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return err;
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
Export and reference the icon as favicon when exporting to HTML5 This makes the project icon display immediately as a favicon when opening the page, without having to wait for the project to finish loading.
2020-01-20 21:46:42 +01:00
const uint16_t bind_port = EDITOR_GET("export/web/http_port");
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
// Resolve host if needed.
Export and reference the icon as favicon when exporting to HTML5 This makes the project icon display immediately as a favicon when opening the page, without having to wait for the project to finish loading.
2020-01-20 21:46:42 +01:00
const String bind_host = EDITOR_GET("export/web/http_host");
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 02:48:18 +02:00
IPAddress bind_ip;
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
if (bind_host.is_valid_ip_address()) {
bind_ip = bind_host;
} else {
bind_ip = IP::get_singleton()->resolve_hostname(bind_host);
}
ERR_FAIL_COND_V_MSG(!bind_ip.is_valid(), ERR_INVALID_PARAMETER, "Invalid editor setting 'export/web/http_host': '" + bind_host + "'. Try using '127.0.0.1'.");
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
const bool use_ssl = EDITOR_GET("export/web/use_ssl");
const String ssl_key = EDITOR_GET("export/web/ssl_key");
const String ssl_cert = EDITOR_GET("export/web/ssl_certificate");
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
// Restart server.
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
{
MutexLock lock(server_lock);
server->stop();
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
err = server->listen(bind_port, bind_ip, use_ssl, ssl_key, ssl_cert);
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
}
[HTML5] Debug HttpServer now runs in `web` cache subdir. Serving all files in that folder and using a known list of mime types. Makes it easy to add more exported files, while still playing safe.
2021-03-26 11:48:56 +01:00
if (err != OK) {
EditorNode::get_singleton()->show_warning(TTR("Error starting HTTP server:") + "\n" + itos(err));
return err;
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
OS::get_singleton()->shell_open(String((use_ssl ? "https://" : "http://") + bind_host + ":" + itos(bind_port) + "/tmp_js_export.html"));
Export: Remove temp files from cache after export So far we left most temporary files lying around, so this attempts to fix that. I added a helper method to DirAccess to factor out the boilerplate of creating a DirAccess, checking if the file exists, remove it or print an error on failure.
2019-08-09 13:45:30 +02:00
// FIXME: Find out how to clean up export files after running the successfully
// exported game. Might not be trivial.
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return OK;
}
Texture refactor -Texture renamed to Texture2D -TextureLayered as base now inherits 2Darray, cubemap and cubemap array -Removed all references to flags in textures (they will go in the shader) -Texture3D gone for now (will come back later done properly) -Create base rasterizer for RenderDevice, RasterizerRD
2019-06-11 20:43:37 +02:00
Ref<Texture2D> EditorExportPlatformJavaScript::get_run_icon() const {
Use custom native-run icons for Android and HTML5
2017-05-25 20:57:13 +02:00
return run_icon;
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
void EditorExportPlatformJavaScript::_server_thread_poll(void *data) {
EditorExportPlatformJavaScript *ej = (EditorExportPlatformJavaScript *)data;
while (!ej->server_quit) {
OS::get_singleton()->delay_usec(1000);
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 11:28:13 +01:00
{
MutexLock lock(ej->server_lock);
ej->server->poll();
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
EditorExportPlatformJavaScript::EditorExportPlatformJavaScript() {
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
server.instantiate();
Modernize Thread - Based on C++11's `thread` and `thread_local` - No more need to allocate-deallocate or check for null - No pointer anymore, just a member variable - Platform-specific implementations no longer needed (except for the few cases of non-portable functions) - Simpler for `NO_THREADS` - Thread ids are now the same across platforms (main is 1; others follow)
2021-01-19 13:29:41 +01:00
server_thread.start(_server_thread_poll, this);
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02:00
Ref<Image> img = memnew(Image(_javascript_logo));
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
logo.instantiate();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
logo->create_from_image(img);
Use custom native-run icons for Android and HTML5
2017-05-25 20:57:13 +02:00
img = Ref<Image>(memnew(Image(_javascript_run_icon)));
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
run_icon.instantiate();
Use custom native-run icons for Android and HTML5
2017-05-25 20:57:13 +02:00
run_icon->create_from_image(img);
Hide HTML5 native-run icon without runnable preset
2017-06-27 03:13:36 +02:00
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
Ref<Theme> theme = EditorNode::get_singleton()->get_editor_theme();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (theme.is_valid()) {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
stop_icon = theme->get_icon("Stop", "EditorIcons");
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
} else {
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
stop_icon.instantiate();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
}
EditorExportPlatformJavaScript::~EditorExportPlatformJavaScript() {
server->stop();
server_quit = true;
Modernize Thread - Based on C++11's `thread` and `thread_local` - No more need to allocate-deallocate or check for null - No pointer anymore, just a member variable - Platform-specific implementations no longer needed (except for the few cases of non-portable functions) - Simpler for `NO_THREADS` - Thread ids are now the same across platforms (main is 1; others follow)
2021-01-19 13:29:41 +01:00
server_thread.wait_to_finish();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
void register_javascript_exporter() {
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
EDITOR_DEF("export/web/http_host", "localhost");
EDITOR_DEF("export/web/http_port", 8060);
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
EDITOR_DEF("export/web/use_ssl", false);
EDITOR_DEF("export/web/ssl_key", "");
EDITOR_DEF("export/web/ssl_certificate", "");
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::INT, "export/web/http_port", PROPERTY_HINT_RANGE, "1,65535,1"));
[HTML5] HTTP server uses optional SSL. Generates a key/cert snakeoil pair or use a custom SSL cert/key. This is of course false security, and potentially detrimental for it. But, so long, those are the requirements browser vendors agreed on to use things like the Gamepad API, and more advanced topics like wasm threads. You don't need this if you run on localhost (at least!), but you do need this (or a much safer nginx proxy) to try those things on your local network (e.g. when debugging a phone, networking, etc).
2021-03-11 22:40:30 +01:00
EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "export/web/ssl_key", PROPERTY_HINT_GLOBAL_FILE, "*.key"));
EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "export/web/ssl_certificate", PROPERTY_HINT_GLOBAL_FILE, "*.crt,*.pem"));
Implement HTTP server for HTML5 export Since most browsers no longer allow making async requests from a page loaded from `file://`, we now need a proper HTTP server to load the exported HTML5 game. This should also allow us to get the debugger to work over a WebSocket connection.
2019-08-24 17:27:38 +02:00
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
Ref<EditorExportPlatformJavaScript> platform;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
platform.instantiate();
WebGL 2 export per WebAssembly or asm.js
2017-03-28 03:21:21 +02:00
EditorExport::get_singleton()->add_export_platform(platform);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Reference in a new issue Copy permalink