90446fe9f3
Follow-up to #75932. Since these icons are only used by the export plugin, it makes sense to move them and generate the headers there. The whole `detect.is_active()` logic seems to be a leftover from before times, as far back as 1.0-stable it already wasn't used for anything. So I'm removing it and moving the export icon generation to `platform_methods`, where it makes more sense.
539 lines
19 KiB
C++
539 lines
19 KiB
C++
/**************************************************************************/
|
|
/* export_plugin.cpp */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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. */
|
|
/**************************************************************************/
|
|
|
|
#include "export_plugin.h"
|
|
|
|
#include "logo_svg.gen.h"
|
|
#include "run_icon_svg.gen.h"
|
|
|
|
#include "core/config/project_settings.h"
|
|
#include "editor/editor_node.h"
|
|
#include "editor/editor_paths.h"
|
|
#include "editor/editor_scale.h"
|
|
#include "editor/export/editor_export.h"
|
|
|
|
#include "modules/modules_enabled.gen.h" // For svg.
|
|
#ifdef MODULE_SVG_ENABLED
|
|
#include "modules/svg/image_loader_svg.h"
|
|
#endif
|
|
|
|
Error EditorExportPlatformLinuxBSD::_export_debug_script(const Ref<EditorExportPreset> &p_preset, const String &p_app_name, const String &p_pkg_name, const String &p_path) {
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::WRITE);
|
|
if (f.is_null()) {
|
|
add_message(EXPORT_MESSAGE_ERROR, TTR("Debug Script Export"), vformat(TTR("Could not open file \"%s\"."), p_path));
|
|
return ERR_CANT_CREATE;
|
|
}
|
|
|
|
f->store_line("#!/bin/sh");
|
|
f->store_line("echo -ne '\\033c\\033]0;" + p_app_name + "\\a'");
|
|
f->store_line("base_path=\"$(dirname \"$(realpath \"$0\")\")\"");
|
|
f->store_line("\"$base_path/" + p_pkg_name + "\" \"$@\"");
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorExportPlatformLinuxBSD::export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
|
|
bool export_as_zip = p_path.ends_with("zip");
|
|
|
|
String pkg_name;
|
|
if (String(GLOBAL_GET("application/config/name")) != "") {
|
|
pkg_name = String(GLOBAL_GET("application/config/name"));
|
|
} else {
|
|
pkg_name = "Unnamed";
|
|
}
|
|
|
|
pkg_name = OS::get_singleton()->get_safe_dir_name(pkg_name);
|
|
|
|
// Setup temp folder.
|
|
String path = p_path;
|
|
String tmp_dir_path = EditorPaths::get_singleton()->get_cache_dir().path_join(pkg_name);
|
|
|
|
Ref<DirAccess> tmp_app_dir = DirAccess::create_for_path(tmp_dir_path);
|
|
if (export_as_zip) {
|
|
if (tmp_app_dir.is_null()) {
|
|
return ERR_CANT_CREATE;
|
|
}
|
|
if (DirAccess::exists(tmp_dir_path)) {
|
|
if (tmp_app_dir->change_dir(tmp_dir_path) == OK) {
|
|
tmp_app_dir->erase_contents_recursive();
|
|
}
|
|
}
|
|
tmp_app_dir->make_dir_recursive(tmp_dir_path);
|
|
path = tmp_dir_path.path_join(p_path.get_file().get_basename());
|
|
}
|
|
|
|
// Export project.
|
|
Error err = EditorExportPlatformPC::export_project(p_preset, p_debug, path, p_flags);
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
// Save console wrapper.
|
|
if (err == OK) {
|
|
int con_scr = p_preset->get("debug/export_console_wrapper");
|
|
if ((con_scr == 1 && p_debug) || (con_scr == 2)) {
|
|
String scr_path = path.get_basename() + ".sh";
|
|
err = _export_debug_script(p_preset, pkg_name, path.get_file(), scr_path);
|
|
FileAccess::set_unix_permissions(scr_path, 0755);
|
|
if (err != OK) {
|
|
add_message(EXPORT_MESSAGE_ERROR, TTR("Debug Console Export"), TTR("Could not create console wrapper."));
|
|
}
|
|
}
|
|
}
|
|
|
|
// ZIP project.
|
|
if (export_as_zip) {
|
|
if (FileAccess::exists(p_path)) {
|
|
OS::get_singleton()->move_to_trash(p_path);
|
|
}
|
|
|
|
Ref<FileAccess> io_fa_dst;
|
|
zlib_filefunc_def io_dst = zipio_create_io(&io_fa_dst);
|
|
zipFile zip = zipOpen2(p_path.utf8().get_data(), APPEND_STATUS_CREATE, nullptr, &io_dst);
|
|
|
|
zip_folder_recursive(zip, tmp_dir_path, "", pkg_name);
|
|
|
|
zipClose(zip, nullptr);
|
|
|
|
if (tmp_app_dir->change_dir(tmp_dir_path) == OK) {
|
|
tmp_app_dir->erase_contents_recursive();
|
|
tmp_app_dir->change_dir("..");
|
|
tmp_app_dir->remove(pkg_name);
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
String EditorExportPlatformLinuxBSD::get_template_file_name(const String &p_target, const String &p_arch) const {
|
|
return "linux_" + p_target + "." + p_arch;
|
|
}
|
|
|
|
List<String> EditorExportPlatformLinuxBSD::get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const {
|
|
List<String> list;
|
|
list.push_back(p_preset->get("binary_format/architecture"));
|
|
list.push_back("zip");
|
|
|
|
return list;
|
|
}
|
|
|
|
bool EditorExportPlatformLinuxBSD::get_export_option_visibility(const EditorExportPreset *p_preset, const String &p_option) const {
|
|
if (p_preset) {
|
|
// Hide SSH options.
|
|
bool ssh = p_preset->get("ssh_remote_deploy/enabled");
|
|
if (!ssh && p_option != "ssh_remote_deploy/enabled" && p_option.begins_with("ssh_remote_deploy/")) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void EditorExportPlatformLinuxBSD::get_export_options(List<ExportOption> *r_options) const {
|
|
EditorExportPlatformPC::get_export_options(r_options);
|
|
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "binary_format/architecture", PROPERTY_HINT_ENUM, "x86_64,x86_32,arm64,arm32,rv64,ppc64,ppc32"), "x86_64"));
|
|
|
|
String run_script = "#!/usr/bin/env bash\n"
|
|
"export DISPLAY=:0\n"
|
|
"unzip -o -q \"{temp_dir}/{archive_name}\" -d \"{temp_dir}\"\n"
|
|
"\"{temp_dir}/{exe_name}\" {cmd_args}";
|
|
|
|
String cleanup_script = "#!/usr/bin/env bash\n"
|
|
"kill $(pgrep -x -f \"{temp_dir}/{exe_name} {cmd_args}\")\n"
|
|
"rm -rf \"{temp_dir}\"";
|
|
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "ssh_remote_deploy/enabled"), false, true));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/host"), "user@host_ip"));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/port"), "22"));
|
|
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/extra_args_ssh", PROPERTY_HINT_MULTILINE_TEXT), ""));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/extra_args_scp", PROPERTY_HINT_MULTILINE_TEXT), ""));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/run_script", PROPERTY_HINT_MULTILINE_TEXT), run_script));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "ssh_remote_deploy/cleanup_script", PROPERTY_HINT_MULTILINE_TEXT), cleanup_script));
|
|
}
|
|
|
|
bool EditorExportPlatformLinuxBSD::is_elf(const String &p_path) const {
|
|
Ref<FileAccess> fb = FileAccess::open(p_path, FileAccess::READ);
|
|
ERR_FAIL_COND_V_MSG(fb.is_null(), false, vformat("Can't open file: \"%s\".", p_path));
|
|
uint32_t magic = fb->get_32();
|
|
return (magic == 0x464c457f);
|
|
}
|
|
|
|
bool EditorExportPlatformLinuxBSD::is_shebang(const String &p_path) const {
|
|
Ref<FileAccess> fb = FileAccess::open(p_path, FileAccess::READ);
|
|
ERR_FAIL_COND_V_MSG(fb.is_null(), false, vformat("Can't open file: \"%s\".", p_path));
|
|
uint16_t magic = fb->get_16();
|
|
return (magic == 0x2123);
|
|
}
|
|
|
|
bool EditorExportPlatformLinuxBSD::is_executable(const String &p_path) const {
|
|
return is_elf(p_path) || is_shebang(p_path);
|
|
}
|
|
|
|
Error EditorExportPlatformLinuxBSD::fixup_embedded_pck(const String &p_path, int64_t p_embedded_start, int64_t p_embedded_size) {
|
|
// Patch the header of the "pck" section in the ELF file so that it corresponds to the embedded data
|
|
|
|
Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::READ_WRITE);
|
|
if (f.is_null()) {
|
|
add_message(EXPORT_MESSAGE_ERROR, TTR("PCK Embedding"), vformat(TTR("Failed to open executable file \"%s\"."), p_path));
|
|
return ERR_CANT_OPEN;
|
|
}
|
|
|
|
// Read and check ELF magic number
|
|
{
|
|
uint32_t magic = f->get_32();
|
|
if (magic != 0x464c457f) { // 0x7F + "ELF"
|
|
add_message(EXPORT_MESSAGE_ERROR, TTR("PCK Embedding"), TTR("Executable file header corrupted."));
|
|
return ERR_FILE_CORRUPT;
|
|
}
|
|
}
|
|
|
|
// Read program architecture bits from class field
|
|
|
|
int bits = f->get_8() * 32;
|
|
|
|
if (bits == 32 && p_embedded_size >= 0x100000000) {
|
|
add_message(EXPORT_MESSAGE_ERROR, TTR("PCK Embedding"), TTR("32-bit executables cannot have embedded data >= 4 GiB."));
|
|
}
|
|
|
|
// Get info about the section header table
|
|
|
|
int64_t section_table_pos;
|
|
int64_t section_header_size;
|
|
if (bits == 32) {
|
|
section_header_size = 40;
|
|
f->seek(0x20);
|
|
section_table_pos = f->get_32();
|
|
f->seek(0x30);
|
|
} else { // 64
|
|
section_header_size = 64;
|
|
f->seek(0x28);
|
|
section_table_pos = f->get_64();
|
|
f->seek(0x3c);
|
|
}
|
|
int num_sections = f->get_16();
|
|
int string_section_idx = f->get_16();
|
|
|
|
// Load the strings table
|
|
uint8_t *strings;
|
|
{
|
|
// Jump to the strings section header
|
|
f->seek(section_table_pos + string_section_idx * section_header_size);
|
|
|
|
// Read strings data size and offset
|
|
int64_t string_data_pos;
|
|
int64_t string_data_size;
|
|
if (bits == 32) {
|
|
f->seek(f->get_position() + 0x10);
|
|
string_data_pos = f->get_32();
|
|
string_data_size = f->get_32();
|
|
} else { // 64
|
|
f->seek(f->get_position() + 0x18);
|
|
string_data_pos = f->get_64();
|
|
string_data_size = f->get_64();
|
|
}
|
|
|
|
// Read strings data
|
|
f->seek(string_data_pos);
|
|
strings = (uint8_t *)memalloc(string_data_size);
|
|
if (!strings) {
|
|
return ERR_OUT_OF_MEMORY;
|
|
}
|
|
f->get_buffer(strings, string_data_size);
|
|
}
|
|
|
|
// Search for the "pck" section
|
|
|
|
bool found = false;
|
|
for (int i = 0; i < num_sections; ++i) {
|
|
int64_t section_header_pos = section_table_pos + i * section_header_size;
|
|
f->seek(section_header_pos);
|
|
|
|
uint32_t name_offset = f->get_32();
|
|
if (strcmp((char *)strings + name_offset, "pck") == 0) {
|
|
// "pck" section found, let's patch!
|
|
|
|
if (bits == 32) {
|
|
f->seek(section_header_pos + 0x10);
|
|
f->store_32(p_embedded_start);
|
|
f->store_32(p_embedded_size);
|
|
} else { // 64
|
|
f->seek(section_header_pos + 0x18);
|
|
f->store_64(p_embedded_start);
|
|
f->store_64(p_embedded_size);
|
|
}
|
|
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
memfree(strings);
|
|
|
|
if (!found) {
|
|
add_message(EXPORT_MESSAGE_ERROR, TTR("PCK Embedding"), TTR("Executable \"pck\" section not found."));
|
|
return ERR_FILE_CORRUPT;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
Ref<Texture2D> EditorExportPlatformLinuxBSD::get_run_icon() const {
|
|
return run_icon;
|
|
}
|
|
|
|
bool EditorExportPlatformLinuxBSD::poll_export() {
|
|
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;
|
|
}
|
|
}
|
|
|
|
int prev = menu_options;
|
|
menu_options = (preset.is_valid() && preset->get("ssh_remote_deploy/enabled").operator bool());
|
|
if (ssh_pid != 0 || !cleanup_commands.is_empty()) {
|
|
if (menu_options == 0) {
|
|
cleanup();
|
|
} else {
|
|
menu_options += 1;
|
|
}
|
|
}
|
|
return menu_options != prev;
|
|
}
|
|
|
|
Ref<ImageTexture> EditorExportPlatformLinuxBSD::get_option_icon(int p_index) const {
|
|
return p_index == 1 ? stop_icon : EditorExportPlatform::get_option_icon(p_index);
|
|
}
|
|
|
|
int EditorExportPlatformLinuxBSD::get_options_count() const {
|
|
return menu_options;
|
|
}
|
|
|
|
String EditorExportPlatformLinuxBSD::get_option_label(int p_index) const {
|
|
return (p_index) ? TTR("Stop and uninstall") : TTR("Run on remote Linux/BSD system");
|
|
}
|
|
|
|
String EditorExportPlatformLinuxBSD::get_option_tooltip(int p_index) const {
|
|
return (p_index) ? TTR("Stop and uninstall running project from the remote system") : TTR("Run exported project on remote Linux/BSD system");
|
|
}
|
|
|
|
void EditorExportPlatformLinuxBSD::cleanup() {
|
|
if (ssh_pid != 0 && OS::get_singleton()->is_process_running(ssh_pid)) {
|
|
print_line("Terminating connection...");
|
|
OS::get_singleton()->kill(ssh_pid);
|
|
OS::get_singleton()->delay_usec(1000);
|
|
}
|
|
|
|
if (!cleanup_commands.is_empty()) {
|
|
print_line("Stopping and deleting previous version...");
|
|
for (const SSHCleanupCommand &cmd : cleanup_commands) {
|
|
if (cmd.wait) {
|
|
ssh_run_on_remote(cmd.host, cmd.port, cmd.ssh_args, cmd.cmd_args);
|
|
} else {
|
|
ssh_run_on_remote_no_wait(cmd.host, cmd.port, cmd.ssh_args, cmd.cmd_args);
|
|
}
|
|
}
|
|
}
|
|
ssh_pid = 0;
|
|
cleanup_commands.clear();
|
|
}
|
|
|
|
Error EditorExportPlatformLinuxBSD::run(const Ref<EditorExportPreset> &p_preset, int p_device, int p_debug_flags) {
|
|
cleanup();
|
|
if (p_device) { // Stop command, cleanup only.
|
|
return OK;
|
|
}
|
|
|
|
EditorProgress ep("run", TTR("Running..."), 5);
|
|
|
|
const String dest = EditorPaths::get_singleton()->get_cache_dir().path_join("linuxbsd");
|
|
Ref<DirAccess> 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 temp directory:") + "\n" + dest);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
String host = p_preset->get("ssh_remote_deploy/host").operator String();
|
|
String port = p_preset->get("ssh_remote_deploy/port").operator String();
|
|
if (port.is_empty()) {
|
|
port = "22";
|
|
}
|
|
Vector<String> extra_args_ssh = p_preset->get("ssh_remote_deploy/extra_args_ssh").operator String().split(" ", false);
|
|
Vector<String> extra_args_scp = p_preset->get("ssh_remote_deploy/extra_args_scp").operator String().split(" ", false);
|
|
|
|
const String basepath = dest.path_join("tmp_linuxbsd_export");
|
|
|
|
#define CLEANUP_AND_RETURN(m_err) \
|
|
{ \
|
|
if (da->file_exists(basepath + ".zip")) { \
|
|
da->remove(basepath + ".zip"); \
|
|
} \
|
|
if (da->file_exists(basepath + "_start.sh")) { \
|
|
da->remove(basepath + "_start.sh"); \
|
|
} \
|
|
if (da->file_exists(basepath + "_clean.sh")) { \
|
|
da->remove(basepath + "_clean.sh"); \
|
|
} \
|
|
return m_err; \
|
|
} \
|
|
((void)0)
|
|
|
|
if (ep.step(TTR("Exporting project..."), 1)) {
|
|
return ERR_SKIP;
|
|
}
|
|
Error err = export_project(p_preset, true, basepath + ".zip", p_debug_flags);
|
|
if (err != OK) {
|
|
DirAccess::remove_file_or_error(basepath + ".zip");
|
|
return err;
|
|
}
|
|
|
|
String cmd_args;
|
|
{
|
|
Vector<String> cmd_args_list;
|
|
gen_debug_flags(cmd_args_list, p_debug_flags);
|
|
for (int i = 0; i < cmd_args_list.size(); i++) {
|
|
if (i != 0) {
|
|
cmd_args += " ";
|
|
}
|
|
cmd_args += cmd_args_list[i];
|
|
}
|
|
}
|
|
|
|
const bool use_remote = (p_debug_flags & DEBUG_FLAG_REMOTE_DEBUG) || (p_debug_flags & DEBUG_FLAG_DUMB_CLIENT);
|
|
int dbg_port = EditorSettings::get_singleton()->get("network/debug/remote_port");
|
|
|
|
print_line("Creating temporary directory...");
|
|
ep.step(TTR("Creating temporary directory..."), 2);
|
|
String temp_dir;
|
|
err = ssh_run_on_remote(host, port, extra_args_ssh, "mktemp -d", &temp_dir);
|
|
if (err != OK || temp_dir.is_empty()) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
|
|
print_line("Uploading archive...");
|
|
ep.step(TTR("Uploading archive..."), 3);
|
|
err = ssh_push_to_remote(host, port, extra_args_scp, basepath + ".zip", temp_dir);
|
|
if (err != OK) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
|
|
{
|
|
String run_script = p_preset->get("ssh_remote_deploy/run_script");
|
|
run_script = run_script.replace("{temp_dir}", temp_dir);
|
|
run_script = run_script.replace("{archive_name}", basepath.get_file() + ".zip");
|
|
run_script = run_script.replace("{exe_name}", basepath.get_file());
|
|
run_script = run_script.replace("{cmd_args}", cmd_args);
|
|
|
|
Ref<FileAccess> f = FileAccess::open(basepath + "_start.sh", FileAccess::WRITE);
|
|
if (f.is_null()) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
|
|
f->store_string(run_script);
|
|
}
|
|
|
|
{
|
|
String clean_script = p_preset->get("ssh_remote_deploy/cleanup_script");
|
|
clean_script = clean_script.replace("{temp_dir}", temp_dir);
|
|
clean_script = clean_script.replace("{archive_name}", basepath.get_file() + ".zip");
|
|
clean_script = clean_script.replace("{exe_name}", basepath.get_file());
|
|
clean_script = clean_script.replace("{cmd_args}", cmd_args);
|
|
|
|
Ref<FileAccess> f = FileAccess::open(basepath + "_clean.sh", FileAccess::WRITE);
|
|
if (f.is_null()) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
|
|
f->store_string(clean_script);
|
|
}
|
|
|
|
print_line("Uploading scripts...");
|
|
ep.step(TTR("Uploading scripts..."), 4);
|
|
err = ssh_push_to_remote(host, port, extra_args_scp, basepath + "_start.sh", temp_dir);
|
|
if (err != OK) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
err = ssh_run_on_remote(host, port, extra_args_ssh, vformat("chmod +x \"%s/%s\"", temp_dir, basepath.get_file() + "_start.sh"));
|
|
if (err != OK || temp_dir.is_empty()) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
err = ssh_push_to_remote(host, port, extra_args_scp, basepath + "_clean.sh", temp_dir);
|
|
if (err != OK) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
err = ssh_run_on_remote(host, port, extra_args_ssh, vformat("chmod +x \"%s/%s\"", temp_dir, basepath.get_file() + "_clean.sh"));
|
|
if (err != OK || temp_dir.is_empty()) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
|
|
print_line("Starting project...");
|
|
ep.step(TTR("Starting project..."), 5);
|
|
err = ssh_run_on_remote_no_wait(host, port, extra_args_ssh, vformat("\"%s/%s\"", temp_dir, basepath.get_file() + "_start.sh"), &ssh_pid, (use_remote) ? dbg_port : -1);
|
|
if (err != OK) {
|
|
CLEANUP_AND_RETURN(err);
|
|
}
|
|
|
|
cleanup_commands.clear();
|
|
cleanup_commands.push_back(SSHCleanupCommand(host, port, extra_args_ssh, vformat("\"%s/%s\"", temp_dir, basepath.get_file() + "_clean.sh")));
|
|
|
|
print_line("Project started.");
|
|
|
|
CLEANUP_AND_RETURN(OK);
|
|
#undef CLEANUP_AND_RETURN
|
|
}
|
|
|
|
EditorExportPlatformLinuxBSD::EditorExportPlatformLinuxBSD() {
|
|
if (EditorNode::get_singleton()) {
|
|
#ifdef MODULE_SVG_ENABLED
|
|
Ref<Image> img = memnew(Image);
|
|
const bool upsample = !Math::is_equal_approx(Math::round(EDSCALE), EDSCALE);
|
|
|
|
ImageLoaderSVG img_loader;
|
|
img_loader.create_image_from_string(img, _linuxbsd_logo_svg, EDSCALE, upsample, false);
|
|
set_logo(ImageTexture::create_from_image(img));
|
|
|
|
img_loader.create_image_from_string(img, _linuxbsd_run_icon_svg, EDSCALE, upsample, false);
|
|
run_icon = ImageTexture::create_from_image(img);
|
|
#endif
|
|
|
|
Ref<Theme> theme = EditorNode::get_singleton()->get_editor_theme();
|
|
if (theme.is_valid()) {
|
|
stop_icon = theme->get_icon(SNAME("Stop"), SNAME("EditorIcons"));
|
|
} else {
|
|
stop_icon.instantiate();
|
|
}
|
|
}
|
|
}
|