|
|
@@ -1,5 +1,5 @@
|
|
|
/*************************************************************************/
|
|
|
-/* editor_export.cpp */
|
|
|
+/* editor_export_platform.cpp */
|
|
|
/*************************************************************************/
|
|
|
/* This file is part of: */
|
|
|
/* GODOT ENGINE */
|
|
|
@@ -28,28 +28,21 @@
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
/*************************************************************************/
|
|
|
|
|
|
-#include "editor_export.h"
|
|
|
+#include "editor_export_platform.h"
|
|
|
|
|
|
#include "core/config/project_settings.h"
|
|
|
#include "core/crypto/crypto_core.h"
|
|
|
#include "core/extension/native_extension.h"
|
|
|
-#include "core/io/config_file.h"
|
|
|
-#include "core/io/dir_access.h"
|
|
|
-#include "core/io/file_access.h"
|
|
|
#include "core/io/file_access_encrypted.h"
|
|
|
#include "core/io/file_access_pack.h" // PACK_HEADER_MAGIC, PACK_FORMAT_VERSION
|
|
|
-#include "core/io/resource_loader.h"
|
|
|
-#include "core/io/resource_saver.h"
|
|
|
#include "core/io/zip_io.h"
|
|
|
-#include "core/object/script_language.h"
|
|
|
#include "core/version.h"
|
|
|
#include "editor/editor_file_system.h"
|
|
|
#include "editor/editor_node.h"
|
|
|
#include "editor/editor_paths.h"
|
|
|
#include "editor/editor_scale.h"
|
|
|
-#include "editor/editor_settings.h"
|
|
|
#include "editor/plugins/script_editor_plugin.h"
|
|
|
-#include "scene/resources/resource_format_text.h"
|
|
|
+#include "editor_export_plugin.h"
|
|
|
|
|
|
static int _get_pad(int p_alignment, int p_n) {
|
|
|
int rest = p_n % p_alignment;
|
|
|
@@ -63,196 +56,6 @@ static int _get_pad(int p_alignment, int p_n) {
|
|
|
|
|
|
#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 PropertyInfo &E : properties) {
|
|
|
- if (platform->get_export_option_visibility(E.name, values)) {
|
|
|
- p_list->push_back(E);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-Ref<EditorExportPlatform> EditorExportPreset::get_platform() const {
|
|
|
- return platform;
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPreset::update_files_to_export() {
|
|
|
- Vector<String> to_remove;
|
|
|
- for (const String &E : selected_files) {
|
|
|
- if (!FileAccess::exists(E)) {
|
|
|
- to_remove.push_back(E);
|
|
|
- }
|
|
|
- }
|
|
|
- for (int i = 0; i < to_remove.size(); ++i) {
|
|
|
- selected_files.erase(to_remove[i]);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-Vector<String> EditorExportPreset::get_files_to_export() const {
|
|
|
- Vector<String> files;
|
|
|
- for (const String &E : selected_files) {
|
|
|
- files.push_back(E);
|
|
|
- }
|
|
|
- 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_absolute_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::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_enc_in_filter(const String &p_filter) {
|
|
|
- enc_in_filters = p_filter;
|
|
|
- EditorExport::singleton->save_presets();
|
|
|
-}
|
|
|
-
|
|
|
-String EditorExportPreset::get_enc_in_filter() const {
|
|
|
- return enc_in_filters;
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPreset::set_enc_ex_filter(const String &p_filter) {
|
|
|
- enc_ex_filters = p_filter;
|
|
|
- EditorExport::singleton->save_presets();
|
|
|
-}
|
|
|
-
|
|
|
-String EditorExportPreset::get_enc_ex_filter() const {
|
|
|
- return enc_ex_filters;
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPreset::set_enc_pck(bool p_enabled) {
|
|
|
- enc_pck = p_enabled;
|
|
|
- EditorExport::singleton->save_presets();
|
|
|
-}
|
|
|
-
|
|
|
-bool EditorExportPreset::get_enc_pck() const {
|
|
|
- return enc_pck;
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPreset::set_enc_directory(bool p_enabled) {
|
|
|
- enc_directory = p_enabled;
|
|
|
- EditorExport::singleton->save_presets();
|
|
|
-}
|
|
|
-
|
|
|
-bool EditorExportPreset::get_enc_directory() const {
|
|
|
- return enc_directory;
|
|
|
-}
|
|
|
-
|
|
|
-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;
|
|
|
-}
|
|
|
-
|
|
|
-///////////////////////////////////
|
|
|
-
|
|
|
bool EditorExportPlatform::fill_log_messages(RichTextLabel *p_log, Error p_err) {
|
|
|
bool has_messages = false;
|
|
|
|
|
|
@@ -272,7 +75,7 @@ bool EditorExportPlatform::fill_log_messages(RichTextLabel *p_log, Error p_err)
|
|
|
} else {
|
|
|
p_log->add_image(EditorNode::get_singleton()->get_gui_base()->get_theme_icon(SNAME("StatusSuccess"), SNAME("EditorIcons")), 16 * EDSCALE, 16 * EDSCALE, Color(1.0, 1.0, 1.0), INLINE_ALIGNMENT_CENTER);
|
|
|
p_log->add_text(" ");
|
|
|
- p_log->add_text(TTR("Completed successfully."));
|
|
|
+ p_log->add_text(TTR("Completed sucessfully."));
|
|
|
if (msg_count > 0) {
|
|
|
has_messages = true;
|
|
|
}
|
|
|
@@ -625,138 +428,6 @@ void EditorExportPlatform::_edit_filter_list(HashSet<String> &r_list, const Stri
|
|
|
_edit_files_with_filter(da, filters, r_list, exclude);
|
|
|
}
|
|
|
|
|
|
-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> &p_tags, const String &p_target) {
|
|
|
- shared_objects.push_back(SharedObject(p_path, p_tags, p_target));
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlugin::add_ios_framework(const String &p_path) {
|
|
|
- ios_frameworks.push_back(p_path);
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlugin::add_ios_embedded_framework(const String &p_path) {
|
|
|
- ios_embedded_frameworks.push_back(p_path);
|
|
|
-}
|
|
|
-
|
|
|
-Vector<String> EditorExportPlugin::get_ios_frameworks() const {
|
|
|
- return ios_frameworks;
|
|
|
-}
|
|
|
-
|
|
|
-Vector<String> EditorExportPlugin::get_ios_embedded_frameworks() const {
|
|
|
- return ios_embedded_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::add_macos_plugin_file(const String &p_path) {
|
|
|
- macos_plugin_files.push_back(p_path);
|
|
|
-}
|
|
|
-
|
|
|
-const Vector<String> &EditorExportPlugin::get_macos_plugin_files() const {
|
|
|
- return macos_plugin_files;
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlugin::add_ios_project_static_lib(const String &p_path) {
|
|
|
- ios_project_static_libs.push_back(p_path);
|
|
|
-}
|
|
|
-
|
|
|
-Vector<String> EditorExportPlugin::get_ios_project_static_libs() const {
|
|
|
- return ios_project_static_libs;
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlugin::_export_file_script(const String &p_path, const String &p_type, const Vector<String> &p_features) {
|
|
|
- GDVIRTUAL_CALL(_export_file, p_path, p_type, p_features);
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlugin::_export_begin_script(const Vector<String> &p_features, bool p_debug, const String &p_path, int p_flags) {
|
|
|
- GDVIRTUAL_CALL(_export_begin, p_features, p_debug, p_path, p_flags);
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlugin::_export_end_script() {
|
|
|
- GDVIRTUAL_CALL(_export_end);
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlugin::_export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) {
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlugin::_export_begin(const HashSet<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", "target"), &EditorExportPlugin::add_shared_object);
|
|
|
- ClassDB::bind_method(D_METHOD("add_ios_project_static_lib", "path"), &EditorExportPlugin::add_ios_project_static_lib);
|
|
|
- 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_embedded_framework", "path"), &EditorExportPlugin::add_ios_embedded_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("add_macos_plugin_file", "path"), &EditorExportPlugin::add_macos_plugin_file);
|
|
|
- ClassDB::bind_method(D_METHOD("skip"), &EditorExportPlugin::skip);
|
|
|
-
|
|
|
- GDVIRTUAL_BIND(_export_file, "path", "type", "features");
|
|
|
- GDVIRTUAL_BIND(_export_begin, "features", "is_debug", "path", "flags");
|
|
|
- GDVIRTUAL_BIND(_export_end);
|
|
|
-}
|
|
|
-
|
|
|
-EditorExportPlugin::EditorExportPlugin() {
|
|
|
-}
|
|
|
-
|
|
|
EditorExportPlatform::FeatureContainers EditorExportPlatform::get_feature_containers(const Ref<EditorExportPreset> &p_preset, bool p_debug) {
|
|
|
Ref<EditorExportPlatform> platform = p_preset->get_platform();
|
|
|
List<String> feature_list;
|
|
|
@@ -1504,573 +1175,3 @@ void EditorExportPlatform::gen_export_flags(Vector<String> &r_flags, int p_flags
|
|
|
|
|
|
EditorExportPlatform::EditorExportPlatform() {
|
|
|
}
|
|
|
-
|
|
|
-////
|
|
|
-
|
|
|
-EditorExport *EditorExport::singleton = nullptr;
|
|
|
-
|
|
|
-void EditorExport::_save() {
|
|
|
- Ref<ConfigFile> config;
|
|
|
- config.instantiate();
|
|
|
- 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;
|
|
|
- case EditorExportPreset::EXCLUDE_SELECTED_RESOURCES: {
|
|
|
- config->set_value(section, "export_filter", "exclude");
|
|
|
- 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, "encryption_include_filters", preset->get_enc_in_filter());
|
|
|
- config->set_value(section, "encryption_exclude_filters", preset->get_enc_ex_filter());
|
|
|
- config->set_value(section, "encrypt_pck", preset->get_enc_pck());
|
|
|
- config->set_value(section, "encrypt_directory", preset->get_enc_directory());
|
|
|
- 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 PropertyInfo &E : preset->get_properties()) {
|
|
|
- config->set_value(option_section, E.name, preset->get(E.name));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- config->save("res://export_presets.cfg");
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExport::save_presets() {
|
|
|
- if (block_save) {
|
|
|
- return;
|
|
|
- }
|
|
|
- save_timer->start();
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExport::_bind_methods() {
|
|
|
- ADD_SIGNAL(MethodInfo("export_presets_updated"));
|
|
|
-}
|
|
|
-
|
|
|
-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 {
|
|
|
- const bool etc2_supported = ProjectSettings::get_singleton()->get("rendering/textures/vram_compression/import_etc2");
|
|
|
-
|
|
|
- if (!etc2_supported) {
|
|
|
- return TTR("Target platform requires 'ETC2' texture compression. Enable 'Import Etc 2' in Project Settings.");
|
|
|
- }
|
|
|
-
|
|
|
- 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_at(p_idx);
|
|
|
- save_presets();
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExport::add_export_plugin(const Ref<EditorExportPlugin> &p_plugin) {
|
|
|
- if (!export_plugins.has(p_plugin)) {
|
|
|
- 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) {
|
|
|
- switch (p_what) {
|
|
|
- case NOTIFICATION_ENTER_TREE: {
|
|
|
- load_config();
|
|
|
- } break;
|
|
|
-
|
|
|
- case NOTIFICATION_PROCESS: {
|
|
|
- update_export_presets();
|
|
|
- } break;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExport::load_config() {
|
|
|
- Ref<ConfigFile> config;
|
|
|
- config.instantiate();
|
|
|
- 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;
|
|
|
- } else if (export_filter == "exclude") {
|
|
|
- preset->set_export_filter(EditorExportPreset::EXCLUDE_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++) {
|
|
|
- if (!FileAccess::exists(files[i])) {
|
|
|
- preset->remove_export_file(files[i]);
|
|
|
- } else {
|
|
|
- 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", ""));
|
|
|
-
|
|
|
- if (config->has_section_key(section, "encrypt_pck")) {
|
|
|
- preset->set_enc_pck(config->get_value(section, "encrypt_pck"));
|
|
|
- }
|
|
|
- if (config->has_section_key(section, "encrypt_directory")) {
|
|
|
- preset->set_enc_directory(config->get_value(section, "encrypt_directory"));
|
|
|
- }
|
|
|
- if (config->has_section_key(section, "encryption_include_filters")) {
|
|
|
- preset->set_enc_in_filter(config->get_value(section, "encryption_include_filters"));
|
|
|
- }
|
|
|
- if (config->has_section_key(section, "encryption_exclude_filters")) {
|
|
|
- preset->set_enc_ex_filter(config->get_value(section, "encryption_exclude_filters"));
|
|
|
- }
|
|
|
- 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 (const String &E : options) {
|
|
|
- Variant value = config->get_value(option_section, E);
|
|
|
-
|
|
|
- preset->set(E, value);
|
|
|
- }
|
|
|
-
|
|
|
- add_export_preset(preset);
|
|
|
- index++;
|
|
|
- }
|
|
|
-
|
|
|
- block_save = false;
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExport::update_export_presets() {
|
|
|
- HashMap<StringName, List<EditorExportPlatform::ExportOption>> platform_options;
|
|
|
-
|
|
|
- for (int i = 0; i < export_platforms.size(); i++) {
|
|
|
- Ref<EditorExportPlatform> platform = export_platforms[i];
|
|
|
-
|
|
|
- if (platform->should_update_export_options()) {
|
|
|
- List<EditorExportPlatform::ExportOption> options;
|
|
|
- platform->get_export_options(&options);
|
|
|
-
|
|
|
- platform_options[platform->get_name()] = options;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- bool export_presets_updated = false;
|
|
|
- for (int i = 0; i < export_presets.size(); i++) {
|
|
|
- Ref<EditorExportPreset> preset = export_presets[i];
|
|
|
- if (platform_options.has(preset->get_platform()->get_name())) {
|
|
|
- export_presets_updated = true;
|
|
|
-
|
|
|
- List<EditorExportPlatform::ExportOption> options = platform_options[preset->get_platform()->get_name()];
|
|
|
-
|
|
|
- // Copy the previous preset values
|
|
|
- HashMap<StringName, Variant> previous_values = preset->values;
|
|
|
-
|
|
|
- // Clear the preset properties and values prior to reloading
|
|
|
- preset->properties.clear();
|
|
|
- preset->values.clear();
|
|
|
-
|
|
|
- for (const EditorExportPlatform::ExportOption &E : options) {
|
|
|
- preset->properties.push_back(E.option);
|
|
|
-
|
|
|
- StringName option_name = E.option.name;
|
|
|
- preset->values[option_name] = previous_values.has(option_name) ? previous_values[option_name] : E.default_value;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (export_presets_updated) {
|
|
|
- emit_signal(_export_presets_updated);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-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", callable_mp(this, &EditorExport::_save));
|
|
|
-
|
|
|
- _export_presets_updated = "export_presets_updated";
|
|
|
-
|
|
|
- singleton = this;
|
|
|
- set_process(true);
|
|
|
-}
|
|
|
-
|
|
|
-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) {
|
|
|
- String ext_filter = (get_os_name() == "Windows") ? "*.exe" : "";
|
|
|
- r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_template/debug", PROPERTY_HINT_GLOBAL_FILE, ext_filter), ""));
|
|
|
- r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "custom_template/release", PROPERTY_HINT_GLOBAL_FILE, ext_filter), ""));
|
|
|
-
|
|
|
- r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "debug/export_console_script", PROPERTY_HINT_ENUM, "No,Debug Only,Debug and Release"), 1));
|
|
|
-
|
|
|
- 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::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));
|
|
|
-}
|
|
|
-
|
|
|
-String EditorExportPlatformPC::get_name() const {
|
|
|
- return name;
|
|
|
-}
|
|
|
-
|
|
|
-String EditorExportPlatformPC::get_os_name() const {
|
|
|
- return os_name;
|
|
|
-}
|
|
|
-
|
|
|
-Ref<Texture2D> 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 = false;
|
|
|
-
|
|
|
- // Look for export templates (first official, and if defined custom templates).
|
|
|
-
|
|
|
- bool use64 = p_preset->get("binary_format/64_bits");
|
|
|
- bool dvalid = exists_export_template(get_template_file_name("debug", use64 ? "x86_64" : "x86_32"), &err);
|
|
|
- bool rvalid = exists_export_template(get_template_file_name("release", use64 ? "x86_64" : "x86_32"), &err);
|
|
|
-
|
|
|
- if (p_preset->get("custom_template/debug") != "") {
|
|
|
- dvalid = FileAccess::exists(p_preset->get("custom_template/debug"));
|
|
|
- if (!dvalid) {
|
|
|
- err += TTR("Custom debug template not found.") + "\n";
|
|
|
- }
|
|
|
- }
|
|
|
- if (p_preset->get("custom_template/release") != "") {
|
|
|
- rvalid = FileAccess::exists(p_preset->get("custom_template/release"));
|
|
|
- if (!rvalid) {
|
|
|
- err += TTR("Custom release template not found.") + "\n";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- valid = dvalid || rvalid;
|
|
|
- r_missing_templates = !valid;
|
|
|
-
|
|
|
- if (!err.is_empty()) {
|
|
|
- r_error = err;
|
|
|
- }
|
|
|
- return valid;
|
|
|
-}
|
|
|
-
|
|
|
-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);
|
|
|
-
|
|
|
- Error err = prepare_template(p_preset, p_debug, p_path, p_flags);
|
|
|
- if (err == OK) {
|
|
|
- err = modify_template(p_preset, p_debug, p_path, p_flags);
|
|
|
- }
|
|
|
- if (err == OK) {
|
|
|
- err = export_project_data(p_preset, p_debug, p_path, p_flags);
|
|
|
- }
|
|
|
-
|
|
|
- return err;
|
|
|
-}
|
|
|
-
|
|
|
-Error EditorExportPlatformPC::prepare_template(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
|
|
|
- if (!DirAccess::exists(p_path.get_base_dir())) {
|
|
|
- add_message(EXPORT_MESSAGE_ERROR, TTR("Prepare Template"), TTR("The given export path doesn't exist."));
|
|
|
- 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.is_empty()) {
|
|
|
- template_path = find_export_template(get_template_file_name(p_debug ? "debug" : "release", p_preset->get("binary_format/64_bits") ? "64" : "32"));
|
|
|
- }
|
|
|
-
|
|
|
- if (!template_path.is_empty() && !FileAccess::exists(template_path)) {
|
|
|
- add_message(EXPORT_MESSAGE_ERROR, TTR("Prepare Template"), vformat(TTR("Template file not found: \"%s\"."), template_path));
|
|
|
- return ERR_FILE_NOT_FOUND;
|
|
|
- }
|
|
|
-
|
|
|
- Ref<DirAccess> da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
|
|
- da->make_dir_recursive(p_path.get_base_dir());
|
|
|
- Error err = da->copy(template_path, p_path, get_chmod_flags());
|
|
|
- if (err != OK) {
|
|
|
- add_message(EXPORT_MESSAGE_ERROR, TTR("Prepare Template"), TTR("Failed to copy export template."));
|
|
|
- }
|
|
|
-
|
|
|
- return err;
|
|
|
-}
|
|
|
-
|
|
|
-Error EditorExportPlatformPC::export_project_data(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
|
|
|
- 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;
|
|
|
- Error err = save_pack(p_preset, p_debug, 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")) {
|
|
|
- add_message(EXPORT_MESSAGE_ERROR, TTR("PCK Embedding"), TTR("On 32-bit exports the embedded PCK cannot be bigger than 4 GiB."));
|
|
|
- return ERR_INVALID_PARAMETER;
|
|
|
- }
|
|
|
-
|
|
|
- err = fixup_embedded_pck(p_path, embedded_pos, embedded_size);
|
|
|
- }
|
|
|
-
|
|
|
- if (err == OK && !so_files.is_empty()) {
|
|
|
- // If shared object files, copy them.
|
|
|
- Ref<DirAccess> da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
|
|
|
- for (int i = 0; i < so_files.size() && err == OK; i++) {
|
|
|
- String src_path = ProjectSettings::get_singleton()->globalize_path(so_files[i].path);
|
|
|
- String target_path;
|
|
|
- if (so_files[i].target.is_empty()) {
|
|
|
- target_path = p_path.get_base_dir().plus_file(src_path.get_file());
|
|
|
- } else {
|
|
|
- target_path = p_path.get_base_dir().plus_file(so_files[i].target).plus_file(src_path.get_file());
|
|
|
- }
|
|
|
-
|
|
|
- if (da->dir_exists(src_path)) {
|
|
|
- err = da->make_dir_recursive(target_path);
|
|
|
- if (err == OK) {
|
|
|
- err = da->copy_dir(src_path, target_path, -1, true);
|
|
|
- }
|
|
|
- } else {
|
|
|
- err = da->copy(src_path, target_path);
|
|
|
- if (err == OK) {
|
|
|
- err = sign_shared_object(p_preset, p_debug, target_path);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return err;
|
|
|
-}
|
|
|
-
|
|
|
-Error EditorExportPlatformPC::sign_shared_object(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path) {
|
|
|
- return OK;
|
|
|
-}
|
|
|
-
|
|
|
-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<Texture2D> &p_logo) {
|
|
|
- logo = p_logo;
|
|
|
-}
|
|
|
-
|
|
|
-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().to_lower()); //OS name is a feature
|
|
|
-}
|
|
|
-
|
|
|
-void EditorExportPlatformPC::resolve_platform_feature_priorities(const Ref<EditorExportPreset> &p_preset, HashSet<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;
|
|
|
-}
|
|
|
-
|
|
|
-///////////////////////
|
|
|
-
|
|
|
-void EditorExportTextSceneToBinaryPlugin::_export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) {
|
|
|
- String extension = p_path.get_extension().to_lower();
|
|
|
- if (extension != "tres" && extension != "tscn") {
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- bool convert = GLOBAL_GET("editor/export/convert_text_resources_to_binary");
|
|
|
- if (!convert) {
|
|
|
- return;
|
|
|
- }
|
|
|
- String tmp_path = EditorPaths::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/export/convert_text_resources_to_binary", false);
|
|
|
-}
|
Aaron Franke