Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
1743 lines
50 KiB
C++
1743 lines
50 KiB
C++
/*************************************************************************/
|
|
/* editor_export.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#include "editor_export.h"
|
|
|
|
#include "core/crypto/crypto_core.h"
|
|
#include "core/io/config_file.h"
|
|
#include "core/io/resource_loader.h"
|
|
#include "core/io/resource_saver.h"
|
|
#include "core/io/zip_io.h"
|
|
#include "core/os/dir_access.h"
|
|
#include "core/os/file_access.h"
|
|
#include "core/project_settings.h"
|
|
#include "core/script_language.h"
|
|
#include "core/version.h"
|
|
#include "editor/editor_file_system.h"
|
|
#include "editor/plugins/script_editor_plugin.h"
|
|
#include "editor_node.h"
|
|
#include "editor_settings.h"
|
|
#include "scene/resources/resource_format_text.h"
|
|
|
|
static int _get_pad(int p_alignment, int p_n) {
|
|
|
|
int rest = p_n % p_alignment;
|
|
int pad = 0;
|
|
if (rest > 0) {
|
|
pad = p_alignment - rest;
|
|
};
|
|
|
|
return pad;
|
|
}
|
|
|
|
#define PCK_PADDING 16
|
|
|
|
bool EditorExportPreset::_set(const StringName &p_name, const Variant &p_value) {
|
|
|
|
if (values.has(p_name)) {
|
|
values[p_name] = p_value;
|
|
EditorExport::singleton->save_presets();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool EditorExportPreset::_get(const StringName &p_name, Variant &r_ret) const {
|
|
|
|
if (values.has(p_name)) {
|
|
r_ret = values[p_name];
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void EditorExportPreset::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
|
|
for (const List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
|
|
|
|
if (platform->get_option_visibility(E->get().name, values)) {
|
|
p_list->push_back(E->get());
|
|
}
|
|
}
|
|
}
|
|
|
|
Ref<EditorExportPlatform> EditorExportPreset::get_platform() const {
|
|
|
|
return platform;
|
|
}
|
|
|
|
Vector<String> EditorExportPreset::get_files_to_export() const {
|
|
|
|
Vector<String> files;
|
|
for (Set<String>::Element *E = selected_files.front(); E; E = E->next()) {
|
|
files.push_back(E->get());
|
|
}
|
|
return files;
|
|
}
|
|
|
|
void EditorExportPreset::set_name(const String &p_name) {
|
|
name = p_name;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
String EditorExportPreset::get_name() const {
|
|
return name;
|
|
}
|
|
|
|
void EditorExportPreset::set_runnable(bool p_enable) {
|
|
|
|
runnable = p_enable;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
bool EditorExportPreset::is_runnable() const {
|
|
|
|
return runnable;
|
|
}
|
|
|
|
void EditorExportPreset::set_export_filter(ExportFilter p_filter) {
|
|
|
|
export_filter = p_filter;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
EditorExportPreset::ExportFilter EditorExportPreset::get_export_filter() const {
|
|
return export_filter;
|
|
}
|
|
|
|
void EditorExportPreset::set_include_filter(const String &p_include) {
|
|
|
|
include_filter = p_include;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
String EditorExportPreset::get_include_filter() const {
|
|
|
|
return include_filter;
|
|
}
|
|
|
|
void EditorExportPreset::set_export_path(const String &p_path) {
|
|
|
|
export_path = p_path;
|
|
/* NOTE(SonerSound): if there is a need to implement a PropertyHint that specifically indicates a relative path,
|
|
* this should be removed. */
|
|
if (export_path.is_abs_path()) {
|
|
String res_path = OS::get_singleton()->get_resource_dir();
|
|
export_path = res_path.path_to_file(export_path);
|
|
}
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
String EditorExportPreset::get_export_path() const {
|
|
|
|
return export_path;
|
|
}
|
|
|
|
void EditorExportPreset::set_exclude_filter(const String &p_exclude) {
|
|
|
|
exclude_filter = p_exclude;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
String EditorExportPreset::get_exclude_filter() const {
|
|
|
|
return exclude_filter;
|
|
}
|
|
|
|
void EditorExportPreset::add_export_file(const String &p_path) {
|
|
|
|
selected_files.insert(p_path);
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
void EditorExportPreset::remove_export_file(const String &p_path) {
|
|
selected_files.erase(p_path);
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
bool EditorExportPreset::has_export_file(const String &p_path) {
|
|
|
|
return selected_files.has(p_path);
|
|
}
|
|
|
|
void EditorExportPreset::add_patch(const String &p_path, int p_at_pos) {
|
|
|
|
if (p_at_pos < 0)
|
|
patches.push_back(p_path);
|
|
else
|
|
patches.insert(p_at_pos, p_path);
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
void EditorExportPreset::remove_patch(int p_idx) {
|
|
patches.remove(p_idx);
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
void EditorExportPreset::set_patch(int p_index, const String &p_path) {
|
|
ERR_FAIL_INDEX(p_index, patches.size());
|
|
patches.write[p_index] = p_path;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
String EditorExportPreset::get_patch(int p_index) {
|
|
|
|
ERR_FAIL_INDEX_V(p_index, patches.size(), String());
|
|
return patches[p_index];
|
|
}
|
|
|
|
Vector<String> EditorExportPreset::get_patches() const {
|
|
return patches;
|
|
}
|
|
|
|
void EditorExportPreset::set_custom_features(const String &p_custom_features) {
|
|
|
|
custom_features = p_custom_features;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
String EditorExportPreset::get_custom_features() const {
|
|
|
|
return custom_features;
|
|
}
|
|
|
|
void EditorExportPreset::set_script_export_mode(int p_mode) {
|
|
|
|
script_mode = p_mode;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
int EditorExportPreset::get_script_export_mode() const {
|
|
|
|
return script_mode;
|
|
}
|
|
|
|
void EditorExportPreset::set_script_encryption_key(const String &p_key) {
|
|
|
|
script_key = p_key;
|
|
EditorExport::singleton->save_presets();
|
|
}
|
|
|
|
String EditorExportPreset::get_script_encryption_key() const {
|
|
|
|
return script_key;
|
|
}
|
|
|
|
EditorExportPreset::EditorExportPreset() :
|
|
export_filter(EXPORT_ALL_RESOURCES),
|
|
export_path(""),
|
|
runnable(false),
|
|
script_mode(MODE_SCRIPT_COMPILED) {
|
|
}
|
|
|
|
///////////////////////////////////
|
|
|
|
void EditorExportPlatform::gen_debug_flags(Vector<String> &r_flags, int p_flags) {
|
|
|
|
String host = EditorSettings::get_singleton()->get("network/debug/remote_host");
|
|
int remote_port = (int)EditorSettings::get_singleton()->get("network/debug/remote_port");
|
|
|
|
if (p_flags & DEBUG_FLAG_REMOTE_DEBUG_LOCALHOST)
|
|
host = "localhost";
|
|
|
|
if (p_flags & DEBUG_FLAG_DUMB_CLIENT) {
|
|
int port = EditorSettings::get_singleton()->get("filesystem/file_server/port");
|
|
String passwd = EditorSettings::get_singleton()->get("filesystem/file_server/password");
|
|
r_flags.push_back("--remote-fs");
|
|
r_flags.push_back(host + ":" + itos(port));
|
|
if (passwd != "") {
|
|
r_flags.push_back("--remote-fs-password");
|
|
r_flags.push_back(passwd);
|
|
}
|
|
}
|
|
|
|
if (p_flags & DEBUG_FLAG_REMOTE_DEBUG) {
|
|
|
|
r_flags.push_back("--remote-debug");
|
|
|
|
r_flags.push_back(host + ":" + String::num(remote_port));
|
|
|
|
List<String> breakpoints;
|
|
ScriptEditor::get_singleton()->get_breakpoints(&breakpoints);
|
|
|
|
if (breakpoints.size()) {
|
|
|
|
r_flags.push_back("--breakpoints");
|
|
String bpoints;
|
|
for (const List<String>::Element *E = breakpoints.front(); E; E = E->next()) {
|
|
|
|
bpoints += E->get().replace(" ", "%20");
|
|
if (E->next())
|
|
bpoints += ",";
|
|
}
|
|
|
|
r_flags.push_back(bpoints);
|
|
}
|
|
}
|
|
|
|
if (p_flags & DEBUG_FLAG_VIEW_COLLISONS) {
|
|
|
|
r_flags.push_back("--debug-collisions");
|
|
}
|
|
|
|
if (p_flags & DEBUG_FLAG_VIEW_NAVIGATION) {
|
|
|
|
r_flags.push_back("--debug-navigation");
|
|
}
|
|
}
|
|
|
|
Error EditorExportPlatform::_save_pack_file(void *p_userdata, const String &p_path, const Vector<uint8_t> &p_data, int p_file, int p_total) {
|
|
|
|
PackData *pd = (PackData *)p_userdata;
|
|
|
|
SavedData sd;
|
|
sd.path_utf8 = p_path.utf8();
|
|
sd.ofs = pd->f->get_position();
|
|
sd.size = p_data.size();
|
|
|
|
pd->f->store_buffer(p_data.ptr(), p_data.size());
|
|
int pad = _get_pad(PCK_PADDING, sd.size);
|
|
for (int i = 0; i < pad; i++) {
|
|
pd->f->store_8(0);
|
|
}
|
|
|
|
{
|
|
unsigned char hash[16];
|
|
CryptoCore::md5(p_data.ptr(), p_data.size(), hash);
|
|
sd.md5.resize(16);
|
|
for (int i = 0; i < 16; i++) {
|
|
sd.md5.write[i] = hash[i];
|
|
}
|
|
}
|
|
|
|
pd->file_ofs.push_back(sd);
|
|
|
|
if (pd->ep->step(TTR("Storing File:") + " " + p_path, 2 + p_file * 100 / p_total, false)) {
|
|
return ERR_SKIP;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorExportPlatform::_save_zip_file(void *p_userdata, const String &p_path, const Vector<uint8_t> &p_data, int p_file, int p_total) {
|
|
|
|
String path = p_path.replace_first("res://", "");
|
|
|
|
ZipData *zd = (ZipData *)p_userdata;
|
|
|
|
zipFile zip = (zipFile)zd->zip;
|
|
|
|
zipOpenNewFileInZip(zip,
|
|
path.utf8().get_data(),
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
Z_DEFLATED,
|
|
Z_DEFAULT_COMPRESSION);
|
|
|
|
zipWriteInFileInZip(zip, p_data.ptr(), p_data.size());
|
|
zipCloseFileInZip(zip);
|
|
|
|
if (zd->ep->step(TTR("Storing File:") + " " + p_path, 2 + p_file * 100 / p_total, false)) {
|
|
return ERR_SKIP;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Ref<ImageTexture> EditorExportPlatform::get_option_icon(int p_index) const {
|
|
Ref<Theme> theme = EditorNode::get_singleton()->get_editor_theme();
|
|
ERR_FAIL_COND_V(theme.is_null(), Ref<ImageTexture>());
|
|
return theme->get_icon("Play", "EditorIcons");
|
|
}
|
|
|
|
String EditorExportPlatform::find_export_template(String template_file_name, String *err) const {
|
|
|
|
String current_version = VERSION_FULL_CONFIG;
|
|
String template_path = EditorSettings::get_singleton()->get_templates_dir().plus_file(current_version).plus_file(template_file_name);
|
|
|
|
if (FileAccess::exists(template_path)) {
|
|
return template_path;
|
|
}
|
|
|
|
// Not found
|
|
if (err) {
|
|
*err += TTR("No export template found at the expected path:") + "\n" + template_path + "\n";
|
|
}
|
|
return String();
|
|
}
|
|
|
|
bool EditorExportPlatform::exists_export_template(String template_file_name, String *err) const {
|
|
return find_export_template(template_file_name, err) != "";
|
|
}
|
|
|
|
Ref<EditorExportPreset> EditorExportPlatform::create_preset() {
|
|
|
|
Ref<EditorExportPreset> preset;
|
|
preset.instance();
|
|
preset->platform = Ref<EditorExportPlatform>(this);
|
|
|
|
List<ExportOption> options;
|
|
get_export_options(&options);
|
|
|
|
for (List<ExportOption>::Element *E = options.front(); E; E = E->next()) {
|
|
|
|
preset->properties.push_back(E->get().option);
|
|
preset->values[E->get().option.name] = E->get().default_value;
|
|
}
|
|
|
|
return preset;
|
|
}
|
|
|
|
void EditorExportPlatform::_export_find_resources(EditorFileSystemDirectory *p_dir, Set<String> &p_paths) {
|
|
|
|
for (int i = 0; i < p_dir->get_subdir_count(); i++) {
|
|
_export_find_resources(p_dir->get_subdir(i), p_paths);
|
|
}
|
|
|
|
for (int i = 0; i < p_dir->get_file_count(); i++) {
|
|
p_paths.insert(p_dir->get_file_path(i));
|
|
}
|
|
}
|
|
|
|
void EditorExportPlatform::_export_find_dependencies(const String &p_path, Set<String> &p_paths) {
|
|
|
|
if (p_paths.has(p_path))
|
|
return;
|
|
|
|
p_paths.insert(p_path);
|
|
|
|
EditorFileSystemDirectory *dir;
|
|
int file_idx;
|
|
dir = EditorFileSystem::get_singleton()->find_file(p_path, &file_idx);
|
|
if (!dir)
|
|
return;
|
|
|
|
Vector<String> deps = dir->get_file_deps(file_idx);
|
|
|
|
for (int i = 0; i < deps.size(); i++) {
|
|
|
|
_export_find_dependencies(deps[i], p_paths);
|
|
}
|
|
}
|
|
|
|
void EditorExportPlatform::_edit_files_with_filter(DirAccess *da, const Vector<String> &p_filters, Set<String> &r_list, bool exclude) {
|
|
|
|
da->list_dir_begin();
|
|
String cur_dir = da->get_current_dir().replace("\\", "/");
|
|
if (!cur_dir.ends_with("/"))
|
|
cur_dir += "/";
|
|
String cur_dir_no_prefix = cur_dir.replace("res://", "");
|
|
|
|
Vector<String> dirs;
|
|
String f;
|
|
while ((f = da->get_next()) != "") {
|
|
if (da->current_is_dir())
|
|
dirs.push_back(f);
|
|
else {
|
|
String fullpath = cur_dir + f;
|
|
// Test also against path without res:// so that filters like `file.txt` can work.
|
|
String fullpath_no_prefix = cur_dir_no_prefix + f;
|
|
for (int i = 0; i < p_filters.size(); ++i) {
|
|
if (fullpath.matchn(p_filters[i]) || fullpath_no_prefix.matchn(p_filters[i])) {
|
|
if (!exclude) {
|
|
r_list.insert(fullpath);
|
|
} else {
|
|
r_list.erase(fullpath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
da->list_dir_end();
|
|
|
|
for (int i = 0; i < dirs.size(); ++i) {
|
|
String dir = dirs[i];
|
|
if (dir.begins_with("."))
|
|
continue;
|
|
da->change_dir(dir);
|
|
_edit_files_with_filter(da, p_filters, r_list, exclude);
|
|
da->change_dir("..");
|
|
}
|
|
}
|
|
|
|
void EditorExportPlatform::_edit_filter_list(Set<String> &r_list, const String &p_filter, bool exclude) {
|
|
|
|
if (p_filter == "")
|
|
return;
|
|
Vector<String> split = p_filter.split(",");
|
|
Vector<String> filters;
|
|
for (int i = 0; i < split.size(); i++) {
|
|
String f = split[i].strip_edges();
|
|
if (f.empty())
|
|
continue;
|
|
filters.push_back(f);
|
|
}
|
|
|
|
DirAccess *da = DirAccess::open("res://");
|
|
ERR_FAIL_NULL(da);
|
|
_edit_files_with_filter(da, filters, r_list, exclude);
|
|
memdelete(da);
|
|
}
|
|
|
|
void EditorExportPlugin::set_export_preset(const Ref<EditorExportPreset> &p_preset) {
|
|
|
|
if (p_preset.is_valid()) {
|
|
export_preset = p_preset;
|
|
}
|
|
}
|
|
|
|
Ref<EditorExportPreset> EditorExportPlugin::get_export_preset() const {
|
|
|
|
return export_preset;
|
|
}
|
|
|
|
void EditorExportPlugin::add_file(const String &p_path, const Vector<uint8_t> &p_file, bool p_remap) {
|
|
|
|
ExtraFile ef;
|
|
ef.data = p_file;
|
|
ef.path = p_path;
|
|
ef.remap = p_remap;
|
|
extra_files.push_back(ef);
|
|
}
|
|
|
|
void EditorExportPlugin::add_shared_object(const String &p_path, const Vector<String> &tags) {
|
|
|
|
shared_objects.push_back(SharedObject(p_path, tags));
|
|
}
|
|
|
|
void EditorExportPlugin::add_ios_framework(const String &p_path) {
|
|
ios_frameworks.push_back(p_path);
|
|
}
|
|
|
|
Vector<String> EditorExportPlugin::get_ios_frameworks() const {
|
|
return ios_frameworks;
|
|
}
|
|
|
|
void EditorExportPlugin::add_ios_plist_content(const String &p_plist_content) {
|
|
ios_plist_content += p_plist_content + "\n";
|
|
}
|
|
|
|
String EditorExportPlugin::get_ios_plist_content() const {
|
|
return ios_plist_content;
|
|
}
|
|
|
|
void EditorExportPlugin::add_ios_linker_flags(const String &p_flags) {
|
|
if (ios_linker_flags.length() > 0) {
|
|
ios_linker_flags += ' ';
|
|
}
|
|
ios_linker_flags += p_flags;
|
|
}
|
|
|
|
String EditorExportPlugin::get_ios_linker_flags() const {
|
|
return ios_linker_flags;
|
|
}
|
|
|
|
void EditorExportPlugin::add_ios_bundle_file(const String &p_path) {
|
|
ios_bundle_files.push_back(p_path);
|
|
}
|
|
|
|
Vector<String> EditorExportPlugin::get_ios_bundle_files() const {
|
|
return ios_bundle_files;
|
|
}
|
|
|
|
void EditorExportPlugin::add_ios_cpp_code(const String &p_code) {
|
|
ios_cpp_code += p_code;
|
|
}
|
|
|
|
String EditorExportPlugin::get_ios_cpp_code() const {
|
|
return ios_cpp_code;
|
|
}
|
|
|
|
void EditorExportPlugin::_export_file_script(const String &p_path, const String &p_type, const PoolVector<String> &p_features) {
|
|
|
|
if (get_script_instance()) {
|
|
get_script_instance()->call("_export_file", p_path, p_type, p_features);
|
|
}
|
|
}
|
|
|
|
void EditorExportPlugin::_export_begin_script(const PoolVector<String> &p_features, bool p_debug, const String &p_path, int p_flags) {
|
|
|
|
if (get_script_instance()) {
|
|
get_script_instance()->call("_export_begin", p_features, p_debug, p_path, p_flags);
|
|
}
|
|
}
|
|
|
|
void EditorExportPlugin::_export_end_script() {
|
|
|
|
if (get_script_instance()) {
|
|
get_script_instance()->call("_export_end");
|
|
}
|
|
}
|
|
|
|
void EditorExportPlugin::_export_file(const String &p_path, const String &p_type, const Set<String> &p_features) {
|
|
}
|
|
|
|
void EditorExportPlugin::_export_begin(const Set<String> &p_features, bool p_debug, const String &p_path, int p_flags) {
|
|
}
|
|
|
|
void EditorExportPlugin::skip() {
|
|
|
|
skipped = true;
|
|
}
|
|
|
|
void EditorExportPlugin::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("add_shared_object", "path", "tags"), &EditorExportPlugin::add_shared_object);
|
|
ClassDB::bind_method(D_METHOD("add_file", "path", "file", "remap"), &EditorExportPlugin::add_file);
|
|
ClassDB::bind_method(D_METHOD("add_ios_framework", "path"), &EditorExportPlugin::add_ios_framework);
|
|
ClassDB::bind_method(D_METHOD("add_ios_plist_content", "plist_content"), &EditorExportPlugin::add_ios_plist_content);
|
|
ClassDB::bind_method(D_METHOD("add_ios_linker_flags", "flags"), &EditorExportPlugin::add_ios_linker_flags);
|
|
ClassDB::bind_method(D_METHOD("add_ios_bundle_file", "path"), &EditorExportPlugin::add_ios_bundle_file);
|
|
ClassDB::bind_method(D_METHOD("add_ios_cpp_code", "code"), &EditorExportPlugin::add_ios_cpp_code);
|
|
ClassDB::bind_method(D_METHOD("skip"), &EditorExportPlugin::skip);
|
|
|
|
BIND_VMETHOD(MethodInfo("_export_file", PropertyInfo(Variant::STRING, "path"), PropertyInfo(Variant::STRING, "type"), PropertyInfo(Variant::POOL_STRING_ARRAY, "features")));
|
|
BIND_VMETHOD(MethodInfo("_export_begin", PropertyInfo(Variant::POOL_STRING_ARRAY, "features"), PropertyInfo(Variant::BOOL, "is_debug"), PropertyInfo(Variant::STRING, "path"), PropertyInfo(Variant::INT, "flags")));
|
|
BIND_VMETHOD(MethodInfo("_export_end"));
|
|
}
|
|
|
|
EditorExportPlugin::EditorExportPlugin() {
|
|
skipped = false;
|
|
}
|
|
|
|
EditorExportPlatform::FeatureContainers EditorExportPlatform::get_feature_containers(const Ref<EditorExportPreset> &p_preset) {
|
|
Ref<EditorExportPlatform> platform = p_preset->get_platform();
|
|
List<String> feature_list;
|
|
platform->get_platform_features(&feature_list);
|
|
platform->get_preset_features(p_preset, &feature_list);
|
|
|
|
FeatureContainers result;
|
|
for (List<String>::Element *E = feature_list.front(); E; E = E->next()) {
|
|
result.features.insert(E->get());
|
|
result.features_pv.push_back(E->get());
|
|
}
|
|
|
|
if (p_preset->get_custom_features() != String()) {
|
|
|
|
Vector<String> tmp_custom_list = p_preset->get_custom_features().split(",");
|
|
|
|
for (int i = 0; i < tmp_custom_list.size(); i++) {
|
|
String f = tmp_custom_list[i].strip_edges();
|
|
if (f != String()) {
|
|
result.features.insert(f);
|
|
result.features_pv.push_back(f);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
EditorExportPlatform::ExportNotifier::ExportNotifier(EditorExportPlatform &p_platform, const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
|
|
FeatureContainers features = p_platform.get_feature_containers(p_preset);
|
|
Vector<Ref<EditorExportPlugin> > export_plugins = EditorExport::get_singleton()->get_export_plugins();
|
|
//initial export plugin callback
|
|
for (int i = 0; i < export_plugins.size(); i++) {
|
|
if (export_plugins[i]->get_script_instance()) { //script based
|
|
export_plugins.write[i]->_export_begin_script(features.features_pv, p_debug, p_path, p_flags);
|
|
} else {
|
|
export_plugins.write[i]->_export_begin(features.features, p_debug, p_path, p_flags);
|
|
}
|
|
}
|
|
}
|
|
|
|
EditorExportPlatform::ExportNotifier::~ExportNotifier() {
|
|
Vector<Ref<EditorExportPlugin> > export_plugins = EditorExport::get_singleton()->get_export_plugins();
|
|
for (int i = 0; i < export_plugins.size(); i++) {
|
|
if (export_plugins[i]->get_script_instance()) {
|
|
export_plugins.write[i]->_export_end_script();
|
|
}
|
|
export_plugins.write[i]->_export_end();
|
|
}
|
|
}
|
|
|
|
Error EditorExportPlatform::export_project_files(const Ref<EditorExportPreset> &p_preset, EditorExportSaveFunction p_func, void *p_udata, EditorExportSaveSharedObject p_so_func) {
|
|
//figure out paths of files that will be exported
|
|
Set<String> paths;
|
|
Vector<String> path_remaps;
|
|
|
|
if (p_preset->get_export_filter() == EditorExportPreset::EXPORT_ALL_RESOURCES) {
|
|
//find stuff
|
|
_export_find_resources(EditorFileSystem::get_singleton()->get_filesystem(), paths);
|
|
} else {
|
|
bool scenes_only = p_preset->get_export_filter() == EditorExportPreset::EXPORT_SELECTED_SCENES;
|
|
|
|
Vector<String> files = p_preset->get_files_to_export();
|
|
for (int i = 0; i < files.size(); i++) {
|
|
if (scenes_only && ResourceLoader::get_resource_type(files[i]) != "PackedScene")
|
|
continue;
|
|
|
|
_export_find_dependencies(files[i], paths);
|
|
}
|
|
}
|
|
|
|
//add native icons to non-resource include list
|
|
_edit_filter_list(paths, String("*.icns"), false);
|
|
_edit_filter_list(paths, String("*.ico"), false);
|
|
|
|
_edit_filter_list(paths, p_preset->get_include_filter(), false);
|
|
_edit_filter_list(paths, p_preset->get_exclude_filter(), true);
|
|
|
|
Vector<Ref<EditorExportPlugin> > export_plugins = EditorExport::get_singleton()->get_export_plugins();
|
|
for (int i = 0; i < export_plugins.size(); i++) {
|
|
|
|
export_plugins.write[i]->set_export_preset(p_preset);
|
|
|
|
if (p_so_func) {
|
|
for (int j = 0; j < export_plugins[i]->shared_objects.size(); j++) {
|
|
p_so_func(p_udata, export_plugins[i]->shared_objects[j]);
|
|
}
|
|
}
|
|
for (int j = 0; j < export_plugins[i]->extra_files.size(); j++) {
|
|
p_func(p_udata, export_plugins[i]->extra_files[j].path, export_plugins[i]->extra_files[j].data, 0, paths.size());
|
|
}
|
|
|
|
export_plugins.write[i]->_clear();
|
|
}
|
|
|
|
FeatureContainers feature_containers = get_feature_containers(p_preset);
|
|
Set<String> &features = feature_containers.features;
|
|
PoolVector<String> &features_pv = feature_containers.features_pv;
|
|
|
|
//store everything in the export medium
|
|
int idx = 0;
|
|
int total = paths.size();
|
|
|
|
for (Set<String>::Element *E = paths.front(); E; E = E->next()) {
|
|
|
|
String path = E->get();
|
|
String type = ResourceLoader::get_resource_type(path);
|
|
|
|
if (FileAccess::exists(path + ".import")) {
|
|
//file is imported, replace by what it imports
|
|
Ref<ConfigFile> config;
|
|
config.instance();
|
|
Error err = config->load(path + ".import");
|
|
if (err != OK) {
|
|
ERR_PRINTS("Could not parse: '" + path + "', not exported.");
|
|
continue;
|
|
}
|
|
|
|
List<String> remaps;
|
|
config->get_section_keys("remap", &remaps);
|
|
|
|
Set<String> remap_features;
|
|
|
|
for (List<String>::Element *F = remaps.front(); F; F = F->next()) {
|
|
|
|
String remap = F->get();
|
|
String feature = remap.get_slice(".", 1);
|
|
if (features.has(feature)) {
|
|
remap_features.insert(feature);
|
|
}
|
|
}
|
|
|
|
if (remap_features.size() > 1) {
|
|
this->resolve_platform_feature_priorities(p_preset, remap_features);
|
|
}
|
|
|
|
err = OK;
|
|
|
|
for (List<String>::Element *F = remaps.front(); F; F = F->next()) {
|
|
|
|
String remap = F->get();
|
|
if (remap == "path") {
|
|
String remapped_path = config->get_value("remap", remap);
|
|
Vector<uint8_t> array = FileAccess::get_file_as_array(remapped_path);
|
|
err = p_func(p_udata, remapped_path, array, idx, total);
|
|
} else if (remap.begins_with("path.")) {
|
|
String feature = remap.get_slice(".", 1);
|
|
|
|
if (remap_features.has(feature)) {
|
|
String remapped_path = config->get_value("remap", remap);
|
|
Vector<uint8_t> array = FileAccess::get_file_as_array(remapped_path);
|
|
err = p_func(p_udata, remapped_path, array, idx, total);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
//also save the .import file
|
|
Vector<uint8_t> array = FileAccess::get_file_as_array(path + ".import");
|
|
err = p_func(p_udata, path + ".import", array, idx, total);
|
|
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
} else {
|
|
|
|
bool do_export = true;
|
|
for (int i = 0; i < export_plugins.size(); i++) {
|
|
if (export_plugins[i]->get_script_instance()) { //script based
|
|
export_plugins.write[i]->_export_file_script(path, type, features_pv);
|
|
} else {
|
|
export_plugins.write[i]->_export_file(path, type, features);
|
|
}
|
|
if (p_so_func) {
|
|
for (int j = 0; j < export_plugins[i]->shared_objects.size(); j++) {
|
|
p_so_func(p_udata, export_plugins[i]->shared_objects[j]);
|
|
}
|
|
}
|
|
|
|
for (int j = 0; j < export_plugins[i]->extra_files.size(); j++) {
|
|
p_func(p_udata, export_plugins[i]->extra_files[j].path, export_plugins[i]->extra_files[j].data, idx, total);
|
|
if (export_plugins[i]->extra_files[j].remap) {
|
|
do_export = false; //if remap, do not
|
|
path_remaps.push_back(path);
|
|
path_remaps.push_back(export_plugins[i]->extra_files[j].path);
|
|
}
|
|
}
|
|
|
|
if (export_plugins[i]->skipped) {
|
|
do_export = false;
|
|
}
|
|
export_plugins.write[i]->_clear();
|
|
|
|
if (!do_export)
|
|
break; //apologies, not exporting
|
|
}
|
|
//just store it as it comes
|
|
if (do_export) {
|
|
Vector<uint8_t> array = FileAccess::get_file_as_array(path);
|
|
p_func(p_udata, path, array, idx, total);
|
|
}
|
|
}
|
|
|
|
idx++;
|
|
}
|
|
|
|
//save config!
|
|
|
|
Vector<String> custom_list;
|
|
|
|
if (p_preset->get_custom_features() != String()) {
|
|
|
|
Vector<String> tmp_custom_list = p_preset->get_custom_features().split(",");
|
|
|
|
for (int i = 0; i < tmp_custom_list.size(); i++) {
|
|
String f = tmp_custom_list[i].strip_edges();
|
|
if (f != String()) {
|
|
custom_list.push_back(f);
|
|
}
|
|
}
|
|
}
|
|
|
|
ProjectSettings::CustomMap custom_map;
|
|
if (path_remaps.size()) {
|
|
if (1) { //new remap mode, use always as it's friendlier with multiple .pck exports
|
|
for (int i = 0; i < path_remaps.size(); i += 2) {
|
|
String from = path_remaps[i];
|
|
String to = path_remaps[i + 1];
|
|
String remap_file = "[remap]\n\npath=\"" + to.c_escape() + "\"\n";
|
|
CharString utf8 = remap_file.utf8();
|
|
Vector<uint8_t> new_file;
|
|
new_file.resize(utf8.length());
|
|
for (int j = 0; j < utf8.length(); j++) {
|
|
new_file.write[j] = utf8[j];
|
|
}
|
|
|
|
p_func(p_udata, from + ".remap", new_file, idx, total);
|
|
}
|
|
} else {
|
|
//old remap mode, will still work, but it's unused because it's not multiple pck export friendly
|
|
custom_map["path_remap/remapped_paths"] = path_remaps;
|
|
}
|
|
}
|
|
|
|
// Store icon and splash images directly, they need to bypass the import system and be loaded as images
|
|
String icon = ProjectSettings::get_singleton()->get("application/config/icon");
|
|
String splash = ProjectSettings::get_singleton()->get("application/boot_splash/image");
|
|
if (icon != String() && FileAccess::exists(icon)) {
|
|
Vector<uint8_t> array = FileAccess::get_file_as_array(icon);
|
|
p_func(p_udata, icon, array, idx, total);
|
|
}
|
|
if (splash != String() && FileAccess::exists(splash) && icon != splash) {
|
|
Vector<uint8_t> array = FileAccess::get_file_as_array(splash);
|
|
p_func(p_udata, splash, array, idx, total);
|
|
}
|
|
|
|
String config_file = "project.binary";
|
|
String engine_cfb = EditorSettings::get_singleton()->get_cache_dir().plus_file("tmp" + config_file);
|
|
ProjectSettings::get_singleton()->save_custom(engine_cfb, custom_map, custom_list);
|
|
Vector<uint8_t> data = FileAccess::get_file_as_array(engine_cfb);
|
|
DirAccess::remove_file_or_error(engine_cfb);
|
|
|
|
p_func(p_udata, "res://" + config_file, data, idx, total);
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorExportPlatform::_add_shared_object(void *p_userdata, const SharedObject &p_so) {
|
|
PackData *pack_data = (PackData *)p_userdata;
|
|
if (pack_data->so_files) {
|
|
pack_data->so_files->push_back(p_so);
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorExportPlatform::save_pack(const Ref<EditorExportPreset> &p_preset, const String &p_path, Vector<SharedObject> *p_so_files, bool p_embed, int64_t *r_embedded_start, int64_t *r_embedded_size) {
|
|
|
|
EditorProgress ep("savepack", TTR("Packing"), 102, true);
|
|
|
|
String tmppath = EditorSettings::get_singleton()->get_cache_dir().plus_file("packtmp");
|
|
FileAccess *ftmp = FileAccess::open(tmppath, FileAccess::WRITE);
|
|
ERR_FAIL_COND_V_MSG(!ftmp, ERR_CANT_CREATE, "Cannot create file '" + tmppath + "'.");
|
|
|
|
PackData pd;
|
|
pd.ep = &ep;
|
|
pd.f = ftmp;
|
|
pd.so_files = p_so_files;
|
|
|
|
Error err = export_project_files(p_preset, _save_pack_file, &pd, _add_shared_object);
|
|
|
|
memdelete(ftmp); //close tmp file
|
|
|
|
if (err != OK) {
|
|
DirAccess::remove_file_or_error(tmppath);
|
|
return err;
|
|
}
|
|
|
|
pd.file_ofs.sort(); //do sort, so we can do binary search later
|
|
|
|
FileAccess *f;
|
|
int64_t embed_pos = 0;
|
|
if (!p_embed) {
|
|
// Regular output to separate PCK file
|
|
f = FileAccess::open(p_path, FileAccess::WRITE);
|
|
if (!f) {
|
|
DirAccess::remove_file_or_error(tmppath);
|
|
ERR_FAIL_V(ERR_CANT_CREATE);
|
|
}
|
|
} else {
|
|
// Append to executable
|
|
f = FileAccess::open(p_path, FileAccess::READ_WRITE);
|
|
if (!f) {
|
|
DirAccess::remove_file_or_error(tmppath);
|
|
ERR_FAIL_V(ERR_FILE_CANT_OPEN);
|
|
}
|
|
|
|
f->seek_end();
|
|
embed_pos = f->get_position();
|
|
|
|
if (r_embedded_start) {
|
|
*r_embedded_start = embed_pos;
|
|
}
|
|
|
|
// Ensure embedded PCK starts at a 64-bit multiple
|
|
int pad = f->get_position() % 8;
|
|
for (int i = 0; i < pad; i++) {
|
|
f->store_8(0);
|
|
}
|
|
}
|
|
|
|
int64_t pck_start_pos = f->get_position();
|
|
|
|
f->store_32(0x43504447); //GDPC
|
|
f->store_32(1); //pack version
|
|
f->store_32(VERSION_MAJOR);
|
|
f->store_32(VERSION_MINOR);
|
|
f->store_32(0); //hmph
|
|
for (int i = 0; i < 16; i++) {
|
|
//reserved
|
|
f->store_32(0);
|
|
}
|
|
|
|
f->store_32(pd.file_ofs.size()); //amount of files
|
|
|
|
int64_t header_size = f->get_position();
|
|
|
|
//precalculate header size
|
|
|
|
for (int i = 0; i < pd.file_ofs.size(); i++) {
|
|
header_size += 4; // size of path string (32 bits is enough)
|
|
int string_len = pd.file_ofs[i].path_utf8.length();
|
|
header_size += string_len + _get_pad(4, string_len); ///size of path string
|
|
header_size += 8; // offset to file _with_ header size included
|
|
header_size += 8; // size of file
|
|
header_size += 16; // md5
|
|
}
|
|
|
|
int header_padding = _get_pad(PCK_PADDING, header_size);
|
|
|
|
for (int i = 0; i < pd.file_ofs.size(); i++) {
|
|
|
|
int string_len = pd.file_ofs[i].path_utf8.length();
|
|
int pad = _get_pad(4, string_len);
|
|
|
|
f->store_32(string_len + pad);
|
|
f->store_buffer((const uint8_t *)pd.file_ofs[i].path_utf8.get_data(), string_len);
|
|
for (int j = 0; j < pad; j++) {
|
|
f->store_8(0);
|
|
}
|
|
|
|
f->store_64(pd.file_ofs[i].ofs + header_padding + header_size);
|
|
f->store_64(pd.file_ofs[i].size); // pay attention here, this is where file is
|
|
f->store_buffer(pd.file_ofs[i].md5.ptr(), 16); //also save md5 for file
|
|
}
|
|
|
|
for (int i = 0; i < header_padding; i++) {
|
|
f->store_8(0);
|
|
}
|
|
|
|
// Save the rest of the data.
|
|
|
|
ftmp = FileAccess::open(tmppath, FileAccess::READ);
|
|
if (!ftmp) {
|
|
memdelete(f);
|
|
DirAccess::remove_file_or_error(tmppath);
|
|
ERR_FAIL_V_MSG(ERR_CANT_CREATE, "Can't open file to read from path '" + String(tmppath) + "'.");
|
|
}
|
|
|
|
const int bufsize = 16384;
|
|
uint8_t buf[bufsize];
|
|
|
|
while (true) {
|
|
|
|
int got = ftmp->get_buffer(buf, bufsize);
|
|
if (got <= 0)
|
|
break;
|
|
f->store_buffer(buf, got);
|
|
}
|
|
|
|
memdelete(ftmp);
|
|
|
|
if (p_embed) {
|
|
// Ensure embedded data ends at a 64-bit multiple
|
|
int64_t embed_end = f->get_position() - embed_pos + 12;
|
|
int pad = embed_end % 8;
|
|
for (int i = 0; i < pad; i++) {
|
|
f->store_8(0);
|
|
}
|
|
|
|
int64_t pck_size = f->get_position() - pck_start_pos;
|
|
f->store_64(pck_size);
|
|
f->store_32(0x43504447); //GDPC
|
|
|
|
if (r_embedded_size) {
|
|
*r_embedded_size = f->get_position() - embed_pos;
|
|
}
|
|
}
|
|
|
|
memdelete(f);
|
|
DirAccess::remove_file_or_error(tmppath);
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorExportPlatform::save_zip(const Ref<EditorExportPreset> &p_preset, const String &p_path) {
|
|
|
|
EditorProgress ep("savezip", TTR("Packing"), 102, true);
|
|
|
|
FileAccess *src_f;
|
|
zlib_filefunc_def io = zipio_create_io_from_file(&src_f);
|
|
zipFile zip = zipOpen2(p_path.utf8().get_data(), APPEND_STATUS_CREATE, NULL, &io);
|
|
|
|
ZipData zd;
|
|
zd.ep = &ep;
|
|
zd.zip = zip;
|
|
|
|
Error err = export_project_files(p_preset, _save_zip_file, &zd);
|
|
if (err != OK && err != ERR_SKIP)
|
|
ERR_PRINT("Failed to export project files");
|
|
|
|
zipClose(zip, NULL);
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error EditorExportPlatform::export_pack(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
|
|
ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);
|
|
return save_pack(p_preset, p_path);
|
|
}
|
|
|
|
Error EditorExportPlatform::export_zip(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
|
|
ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);
|
|
return save_zip(p_preset, p_path);
|
|
}
|
|
|
|
void EditorExportPlatform::gen_export_flags(Vector<String> &r_flags, int p_flags) {
|
|
|
|
String host = EditorSettings::get_singleton()->get("network/debug/remote_host");
|
|
int remote_port = (int)EditorSettings::get_singleton()->get("network/debug/remote_port");
|
|
|
|
if (p_flags & DEBUG_FLAG_REMOTE_DEBUG_LOCALHOST)
|
|
host = "localhost";
|
|
|
|
if (p_flags & DEBUG_FLAG_DUMB_CLIENT) {
|
|
int port = EditorSettings::get_singleton()->get("filesystem/file_server/port");
|
|
String passwd = EditorSettings::get_singleton()->get("filesystem/file_server/password");
|
|
r_flags.push_back("--remote-fs");
|
|
r_flags.push_back(host + ":" + itos(port));
|
|
if (passwd != "") {
|
|
r_flags.push_back("--remote-fs-password");
|
|
r_flags.push_back(passwd);
|
|
}
|
|
}
|
|
|
|
if (p_flags & DEBUG_FLAG_REMOTE_DEBUG) {
|
|
|
|
r_flags.push_back("--remote-debug");
|
|
|
|
r_flags.push_back(host + ":" + String::num(remote_port));
|
|
|
|
List<String> breakpoints;
|
|
ScriptEditor::get_singleton()->get_breakpoints(&breakpoints);
|
|
|
|
if (breakpoints.size()) {
|
|
|
|
r_flags.push_back("--breakpoints");
|
|
String bpoints;
|
|
for (const List<String>::Element *E = breakpoints.front(); E; E = E->next()) {
|
|
|
|
bpoints += E->get().replace(" ", "%20");
|
|
if (E->next())
|
|
bpoints += ",";
|
|
}
|
|
|
|
r_flags.push_back(bpoints);
|
|
}
|
|
}
|
|
|
|
if (p_flags & DEBUG_FLAG_VIEW_COLLISONS) {
|
|
|
|
r_flags.push_back("--debug-collisions");
|
|
}
|
|
|
|
if (p_flags & DEBUG_FLAG_VIEW_NAVIGATION) {
|
|
|
|
r_flags.push_back("--debug-navigation");
|
|
}
|
|
}
|
|
EditorExportPlatform::EditorExportPlatform() {
|
|
}
|
|
|
|
////
|
|
|
|
EditorExport *EditorExport::singleton = NULL;
|
|
|
|
void EditorExport::_save() {
|
|
|
|
Ref<ConfigFile> config;
|
|
config.instance();
|
|
for (int i = 0; i < export_presets.size(); i++) {
|
|
|
|
Ref<EditorExportPreset> preset = export_presets[i];
|
|
String section = "preset." + itos(i);
|
|
|
|
config->set_value(section, "name", preset->get_name());
|
|
config->set_value(section, "platform", preset->get_platform()->get_name());
|
|
config->set_value(section, "runnable", preset->is_runnable());
|
|
config->set_value(section, "custom_features", preset->get_custom_features());
|
|
|
|
bool save_files = false;
|
|
switch (preset->get_export_filter()) {
|
|
case EditorExportPreset::EXPORT_ALL_RESOURCES: {
|
|
config->set_value(section, "export_filter", "all_resources");
|
|
} break;
|
|
case EditorExportPreset::EXPORT_SELECTED_SCENES: {
|
|
config->set_value(section, "export_filter", "scenes");
|
|
save_files = true;
|
|
} break;
|
|
case EditorExportPreset::EXPORT_SELECTED_RESOURCES: {
|
|
config->set_value(section, "export_filter", "resources");
|
|
save_files = true;
|
|
} break;
|
|
}
|
|
|
|
if (save_files) {
|
|
Vector<String> export_files = preset->get_files_to_export();
|
|
config->set_value(section, "export_files", export_files);
|
|
}
|
|
config->set_value(section, "include_filter", preset->get_include_filter());
|
|
config->set_value(section, "exclude_filter", preset->get_exclude_filter());
|
|
config->set_value(section, "export_path", preset->get_export_path());
|
|
config->set_value(section, "patch_list", preset->get_patches());
|
|
config->set_value(section, "script_export_mode", preset->get_script_export_mode());
|
|
config->set_value(section, "script_encryption_key", preset->get_script_encryption_key());
|
|
|
|
String option_section = "preset." + itos(i) + ".options";
|
|
|
|
for (const List<PropertyInfo>::Element *E = preset->get_properties().front(); E; E = E->next()) {
|
|
config->set_value(option_section, E->get().name, preset->get(E->get().name));
|
|
}
|
|
}
|
|
|
|
config->save("res://export_presets.cfg");
|
|
}
|
|
|
|
void EditorExport::save_presets() {
|
|
|
|
if (block_save)
|
|
return;
|
|
save_timer->start();
|
|
}
|
|
|
|
void EditorExport::_bind_methods() {
|
|
|
|
ClassDB::bind_method("_save", &EditorExport::_save);
|
|
}
|
|
|
|
void EditorExport::add_export_platform(const Ref<EditorExportPlatform> &p_platform) {
|
|
|
|
export_platforms.push_back(p_platform);
|
|
}
|
|
|
|
int EditorExport::get_export_platform_count() {
|
|
|
|
return export_platforms.size();
|
|
}
|
|
|
|
Ref<EditorExportPlatform> EditorExport::get_export_platform(int p_idx) {
|
|
|
|
ERR_FAIL_INDEX_V(p_idx, export_platforms.size(), Ref<EditorExportPlatform>());
|
|
|
|
return export_platforms[p_idx];
|
|
}
|
|
|
|
void EditorExport::add_export_preset(const Ref<EditorExportPreset> &p_preset, int p_at_pos) {
|
|
|
|
if (p_at_pos < 0)
|
|
export_presets.push_back(p_preset);
|
|
else
|
|
export_presets.insert(p_at_pos, p_preset);
|
|
}
|
|
|
|
String EditorExportPlatform::test_etc2() const {
|
|
|
|
String driver = ProjectSettings::get_singleton()->get("rendering/quality/driver/driver_name");
|
|
bool driver_fallback = ProjectSettings::get_singleton()->get("rendering/quality/driver/fallback_to_gles2");
|
|
bool etc_supported = ProjectSettings::get_singleton()->get("rendering/vram_compression/import_etc");
|
|
bool etc2_supported = ProjectSettings::get_singleton()->get("rendering/vram_compression/import_etc2");
|
|
|
|
if (driver == "GLES2" && !etc_supported) {
|
|
return TTR("Target platform requires 'ETC' texture compression for GLES2. Enable 'Import Etc' in Project Settings.");
|
|
} else if (driver == "GLES3") {
|
|
String err;
|
|
if (!etc2_supported) {
|
|
err += TTR("Target platform requires 'ETC2' texture compression for GLES3. Enable 'Import Etc 2' in Project Settings.");
|
|
}
|
|
if (driver_fallback && !etc_supported) {
|
|
if (err != String())
|
|
err += "\n";
|
|
err += TTR("Target platform requires 'ETC' texture compression for the driver fallback to GLES2.\nEnable 'Import Etc' in Project Settings, or disable 'Driver Fallback Enabled'.");
|
|
}
|
|
return err;
|
|
}
|
|
return String();
|
|
}
|
|
|
|
int EditorExport::get_export_preset_count() const {
|
|
|
|
return export_presets.size();
|
|
}
|
|
|
|
Ref<EditorExportPreset> EditorExport::get_export_preset(int p_idx) {
|
|
|
|
ERR_FAIL_INDEX_V(p_idx, export_presets.size(), Ref<EditorExportPreset>());
|
|
return export_presets[p_idx];
|
|
}
|
|
|
|
void EditorExport::remove_export_preset(int p_idx) {
|
|
|
|
export_presets.remove(p_idx);
|
|
save_presets();
|
|
}
|
|
|
|
void EditorExport::add_export_plugin(const Ref<EditorExportPlugin> &p_plugin) {
|
|
|
|
if (export_plugins.find(p_plugin) == -1) {
|
|
export_plugins.push_back(p_plugin);
|
|
}
|
|
}
|
|
|
|
void EditorExport::remove_export_plugin(const Ref<EditorExportPlugin> &p_plugin) {
|
|
|
|
export_plugins.erase(p_plugin);
|
|
}
|
|
|
|
Vector<Ref<EditorExportPlugin> > EditorExport::get_export_plugins() {
|
|
|
|
return export_plugins;
|
|
}
|
|
|
|
void EditorExport::_notification(int p_what) {
|
|
|
|
if (p_what == NOTIFICATION_ENTER_TREE) {
|
|
load_config();
|
|
}
|
|
}
|
|
|
|
void EditorExport::load_config() {
|
|
|
|
Ref<ConfigFile> config;
|
|
config.instance();
|
|
Error err = config->load("res://export_presets.cfg");
|
|
if (err != OK)
|
|
return;
|
|
|
|
block_save = true;
|
|
|
|
int index = 0;
|
|
while (true) {
|
|
|
|
String section = "preset." + itos(index);
|
|
if (!config->has_section(section))
|
|
break;
|
|
|
|
String platform = config->get_value(section, "platform");
|
|
|
|
Ref<EditorExportPreset> preset;
|
|
|
|
for (int i = 0; i < export_platforms.size(); i++) {
|
|
if (export_platforms[i]->get_name() == platform) {
|
|
preset = export_platforms.write[i]->create_preset();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!preset.is_valid()) {
|
|
index++;
|
|
ERR_CONTINUE(!preset.is_valid());
|
|
}
|
|
|
|
preset->set_name(config->get_value(section, "name"));
|
|
preset->set_runnable(config->get_value(section, "runnable"));
|
|
|
|
if (config->has_section_key(section, "custom_features")) {
|
|
preset->set_custom_features(config->get_value(section, "custom_features"));
|
|
}
|
|
|
|
String export_filter = config->get_value(section, "export_filter");
|
|
|
|
bool get_files = false;
|
|
|
|
if (export_filter == "all_resources") {
|
|
preset->set_export_filter(EditorExportPreset::EXPORT_ALL_RESOURCES);
|
|
} else if (export_filter == "scenes") {
|
|
preset->set_export_filter(EditorExportPreset::EXPORT_SELECTED_SCENES);
|
|
get_files = true;
|
|
} else if (export_filter == "resources") {
|
|
preset->set_export_filter(EditorExportPreset::EXPORT_SELECTED_RESOURCES);
|
|
get_files = true;
|
|
}
|
|
|
|
if (get_files) {
|
|
|
|
Vector<String> files = config->get_value(section, "export_files");
|
|
|
|
for (int i = 0; i < files.size(); i++) {
|
|
preset->add_export_file(files[i]);
|
|
}
|
|
}
|
|
|
|
preset->set_include_filter(config->get_value(section, "include_filter"));
|
|
preset->set_exclude_filter(config->get_value(section, "exclude_filter"));
|
|
preset->set_export_path(config->get_value(section, "export_path", ""));
|
|
|
|
Vector<String> patch_list = config->get_value(section, "patch_list");
|
|
|
|
for (int i = 0; i < patch_list.size(); i++) {
|
|
preset->add_patch(patch_list[i]);
|
|
}
|
|
|
|
if (config->has_section_key(section, "script_export_mode")) {
|
|
preset->set_script_export_mode(config->get_value(section, "script_export_mode"));
|
|
}
|
|
if (config->has_section_key(section, "script_encryption_key")) {
|
|
preset->set_script_encryption_key(config->get_value(section, "script_encryption_key"));
|
|
}
|
|
|
|
String option_section = "preset." + itos(index) + ".options";
|
|
|
|
List<String> options;
|
|
|
|
config->get_section_keys(option_section, &options);
|
|
|
|
for (List<String>::Element *E = options.front(); E; E = E->next()) {
|
|
|
|
Variant value = config->get_value(option_section, E->get());
|
|
|
|
preset->set(E->get(), value);
|
|
}
|
|
|
|
add_export_preset(preset);
|
|
index++;
|
|
}
|
|
|
|
block_save = false;
|
|
}
|
|
|
|
bool EditorExport::poll_export_platforms() {
|
|
|
|
bool changed = false;
|
|
for (int i = 0; i < export_platforms.size(); i++) {
|
|
if (export_platforms.write[i]->poll_export()) {
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
EditorExport::EditorExport() {
|
|
|
|
save_timer = memnew(Timer);
|
|
add_child(save_timer);
|
|
save_timer->set_wait_time(0.8);
|
|
save_timer->set_one_shot(true);
|
|
save_timer->connect("timeout", this, "_save");
|
|
block_save = false;
|
|
|
|
singleton = this;
|
|
}
|
|
|
|
EditorExport::~EditorExport() {
|
|
}
|
|
|
|
//////////
|
|
|
|
void EditorExportPlatformPC::get_preset_features(const Ref<EditorExportPreset> &p_preset, List<String> *r_features) {
|
|
|
|
if (p_preset->get("texture_format/s3tc")) {
|
|
r_features->push_back("s3tc");
|
|
}
|
|
if (p_preset->get("texture_format/etc")) {
|
|
r_features->push_back("etc");
|
|
}
|
|
if (p_preset->get("texture_format/etc2")) {
|
|
r_features->push_back("etc2");
|
|
}
|
|
|
|
if (p_preset->get("binary_format/64_bits")) {
|
|
r_features->push_back("64");
|
|
} else {
|
|
r_features->push_back("32");
|
|
}
|
|
}
|
|
|
|
void EditorExportPlatformPC::get_export_options(List<ExportOption> *r_options) {
|
|
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "texture_format/bptc"), false));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "texture_format/s3tc"), true));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "texture_format/etc"), false));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "texture_format/etc2"), false));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "texture_format/no_bptc_fallbacks"), true));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "binary_format/64_bits"), true));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::BOOL, "binary_format/embed_pck"), false));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_template/release", PROPERTY_HINT_GLOBAL_FILE), ""));
|
|
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_template/debug", PROPERTY_HINT_GLOBAL_FILE), ""));
|
|
}
|
|
|
|
String EditorExportPlatformPC::get_name() const {
|
|
|
|
return name;
|
|
}
|
|
|
|
String EditorExportPlatformPC::get_os_name() const {
|
|
|
|
return os_name;
|
|
}
|
|
Ref<Texture> EditorExportPlatformPC::get_logo() const {
|
|
|
|
return logo;
|
|
}
|
|
|
|
bool EditorExportPlatformPC::can_export(const Ref<EditorExportPreset> &p_preset, String &r_error, bool &r_missing_templates) const {
|
|
|
|
String err;
|
|
bool valid = true;
|
|
bool use64 = p_preset->get("binary_format/64_bits");
|
|
|
|
if (use64 && (!exists_export_template(debug_file_64, &err) || !exists_export_template(release_file_64, &err))) {
|
|
valid = false;
|
|
}
|
|
|
|
if (!use64 && (!exists_export_template(debug_file_32, &err) || !exists_export_template(release_file_32, &err))) {
|
|
valid = false;
|
|
}
|
|
|
|
String custom_debug_binary = p_preset->get("custom_template/debug");
|
|
String custom_release_binary = p_preset->get("custom_template/release");
|
|
|
|
if (custom_debug_binary == "" && custom_release_binary == "") {
|
|
if (!err.empty())
|
|
r_error = err;
|
|
r_missing_templates = !valid;
|
|
return valid;
|
|
}
|
|
|
|
bool dvalid = true;
|
|
bool rvalid = true;
|
|
|
|
if (!FileAccess::exists(custom_debug_binary)) {
|
|
dvalid = false;
|
|
err += TTR("Custom debug template not found.") + "\n";
|
|
}
|
|
|
|
if (!FileAccess::exists(custom_release_binary)) {
|
|
rvalid = false;
|
|
err += TTR("Custom release template not found.") + "\n";
|
|
}
|
|
|
|
valid = dvalid || rvalid;
|
|
|
|
if (!err.empty())
|
|
r_error = err;
|
|
return valid;
|
|
}
|
|
|
|
List<String> EditorExportPlatformPC::get_binary_extensions(const Ref<EditorExportPreset> &p_preset) const {
|
|
List<String> list;
|
|
for (Map<String, String>::Element *E = extensions.front(); E; E = E->next()) {
|
|
if (p_preset->get(E->key())) {
|
|
list.push_back(extensions[E->key()]);
|
|
return list;
|
|
}
|
|
}
|
|
|
|
if (extensions.has("default")) {
|
|
list.push_back(extensions["default"]);
|
|
return list;
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
Error EditorExportPlatformPC::export_project(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
|
|
ExportNotifier notifier(*this, p_preset, p_debug, p_path, p_flags);
|
|
|
|
if (!DirAccess::exists(p_path.get_base_dir())) {
|
|
return ERR_FILE_BAD_PATH;
|
|
}
|
|
|
|
String custom_debug = p_preset->get("custom_template/debug");
|
|
String custom_release = p_preset->get("custom_template/release");
|
|
|
|
String template_path = p_debug ? custom_debug : custom_release;
|
|
|
|
template_path = template_path.strip_edges();
|
|
|
|
if (template_path == String()) {
|
|
|
|
if (p_preset->get("binary_format/64_bits")) {
|
|
if (p_debug) {
|
|
template_path = find_export_template(debug_file_64);
|
|
} else {
|
|
template_path = find_export_template(release_file_64);
|
|
}
|
|
} else {
|
|
if (p_debug) {
|
|
template_path = find_export_template(debug_file_32);
|
|
} else {
|
|
template_path = find_export_template(release_file_32);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (template_path != String() && !FileAccess::exists(template_path)) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Template file not found:") + "\n" + template_path);
|
|
return ERR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
|
Error err = da->copy(template_path, p_path, get_chmod_flags());
|
|
memdelete(da);
|
|
|
|
if (err == OK) {
|
|
String pck_path;
|
|
if (p_preset->get("binary_format/embed_pck")) {
|
|
pck_path = p_path;
|
|
} else {
|
|
pck_path = p_path.get_basename() + ".pck";
|
|
}
|
|
|
|
Vector<SharedObject> so_files;
|
|
|
|
int64_t embedded_pos;
|
|
int64_t embedded_size;
|
|
err = save_pack(p_preset, pck_path, &so_files, p_preset->get("binary_format/embed_pck"), &embedded_pos, &embedded_size);
|
|
if (err == OK && p_preset->get("binary_format/embed_pck")) {
|
|
|
|
if (embedded_size >= 0x100000000 && !p_preset->get("binary_format/64_bits")) {
|
|
EditorNode::get_singleton()->show_warning(TTR("On 32-bit exports the embedded PCK cannot be bigger than 4 GiB."));
|
|
return ERR_UNAVAILABLE;
|
|
}
|
|
|
|
FixUpEmbeddedPckFunc fixup_func = get_fixup_embedded_pck_func();
|
|
if (fixup_func) {
|
|
err = fixup_func(p_path, embedded_pos, embedded_size);
|
|
}
|
|
}
|
|
|
|
if (err == OK && !so_files.empty()) {
|
|
//if shared object files, copy them
|
|
da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
|
for (int i = 0; i < so_files.size() && err == OK; i++) {
|
|
err = da->copy(so_files[i].path, p_path.get_base_dir().plus_file(so_files[i].path.get_file()));
|
|
if (err == OK) {
|
|
err = sign_shared_object(p_preset, p_debug, p_path.get_base_dir().plus_file(so_files[i].path.get_file()));
|
|
}
|
|
}
|
|
memdelete(da);
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
Error EditorExportPlatformPC::sign_shared_object(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path) {
|
|
return OK;
|
|
}
|
|
|
|
void EditorExportPlatformPC::set_extension(const String &p_extension, const String &p_feature_key) {
|
|
extensions[p_feature_key] = p_extension;
|
|
}
|
|
|
|
void EditorExportPlatformPC::set_name(const String &p_name) {
|
|
name = p_name;
|
|
}
|
|
|
|
void EditorExportPlatformPC::set_os_name(const String &p_name) {
|
|
os_name = p_name;
|
|
}
|
|
|
|
void EditorExportPlatformPC::set_logo(const Ref<Texture> &p_logo) {
|
|
logo = p_logo;
|
|
}
|
|
|
|
void EditorExportPlatformPC::set_release_64(const String &p_file) {
|
|
|
|
release_file_64 = p_file;
|
|
}
|
|
|
|
void EditorExportPlatformPC::set_release_32(const String &p_file) {
|
|
|
|
release_file_32 = p_file;
|
|
}
|
|
void EditorExportPlatformPC::set_debug_64(const String &p_file) {
|
|
|
|
debug_file_64 = p_file;
|
|
}
|
|
void EditorExportPlatformPC::set_debug_32(const String &p_file) {
|
|
|
|
debug_file_32 = p_file;
|
|
}
|
|
|
|
void EditorExportPlatformPC::add_platform_feature(const String &p_feature) {
|
|
|
|
extra_features.insert(p_feature);
|
|
}
|
|
|
|
void EditorExportPlatformPC::get_platform_features(List<String> *r_features) {
|
|
r_features->push_back("pc"); //all pcs support "pc"
|
|
r_features->push_back("s3tc"); //all pcs support "s3tc" compression
|
|
r_features->push_back(get_os_name()); //OS name is a feature
|
|
for (Set<String>::Element *E = extra_features.front(); E; E = E->next()) {
|
|
r_features->push_back(E->get());
|
|
}
|
|
}
|
|
|
|
void EditorExportPlatformPC::resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, Set<String> &p_features) {
|
|
|
|
if (p_features.has("bptc")) {
|
|
if (p_preset->has("texture_format/no_bptc_fallbacks")) {
|
|
p_features.erase("s3tc");
|
|
}
|
|
}
|
|
}
|
|
|
|
int EditorExportPlatformPC::get_chmod_flags() const {
|
|
|
|
return chmod_flags;
|
|
}
|
|
|
|
void EditorExportPlatformPC::set_chmod_flags(int p_flags) {
|
|
|
|
chmod_flags = p_flags;
|
|
}
|
|
|
|
EditorExportPlatformPC::FixUpEmbeddedPckFunc EditorExportPlatformPC::get_fixup_embedded_pck_func() const {
|
|
|
|
return fixup_embedded_pck_func;
|
|
}
|
|
|
|
void EditorExportPlatformPC::set_fixup_embedded_pck_func(FixUpEmbeddedPckFunc p_fixup_embedded_pck_func) {
|
|
|
|
fixup_embedded_pck_func = p_fixup_embedded_pck_func;
|
|
}
|
|
|
|
EditorExportPlatformPC::EditorExportPlatformPC() {
|
|
|
|
chmod_flags = -1;
|
|
fixup_embedded_pck_func = NULL;
|
|
}
|
|
|
|
///////////////////////
|
|
|
|
void EditorExportTextSceneToBinaryPlugin::_export_file(const String &p_path, const String &p_type, const Set<String> &p_features) {
|
|
|
|
String extension = p_path.get_extension().to_lower();
|
|
if (extension != "tres" && extension != "tscn") {
|
|
return;
|
|
}
|
|
|
|
bool convert = GLOBAL_GET("editor/convert_text_resources_to_binary_on_export");
|
|
if (!convert)
|
|
return;
|
|
String tmp_path = EditorSettings::get_singleton()->get_cache_dir().plus_file("tmpfile.res");
|
|
Error err = ResourceFormatLoaderText::convert_file_to_binary(p_path, tmp_path);
|
|
if (err != OK) {
|
|
DirAccess::remove_file_or_error(tmp_path);
|
|
ERR_FAIL();
|
|
}
|
|
Vector<uint8_t> data = FileAccess::get_file_as_array(tmp_path);
|
|
if (data.size() == 0) {
|
|
DirAccess::remove_file_or_error(tmp_path);
|
|
ERR_FAIL();
|
|
}
|
|
DirAccess::remove_file_or_error(tmp_path);
|
|
add_file(p_path + ".converted.res", data, true);
|
|
}
|
|
|
|
EditorExportTextSceneToBinaryPlugin::EditorExportTextSceneToBinaryPlugin() {
|
|
|
|
GLOBAL_DEF("editor/convert_text_resources_to_binary_on_export", false);
|
|
}
|