// Keep track of a list of "index sets," i.e. sets of indices

// within disambiguated_scene_names which contain the same name.

Vector<Set<int>> index_sets;

Map<String, int> scene_name_to_set_index;

for (int i = 0; i < r_filenames.size(); i++) {

String scene_name = r_filenames[i];

if (!scene_name_to_set_index.has(scene_name)) {

index_sets.push_back(Set<int>());

scene_name_to_set_index.insert(r_filenames[i], index_sets.size() - 1);

}

index_sets.write[scene_name_to_set_index[scene_name]].insert(i);

}

// For each index set with a size > 1, we need to disambiguate

for (int i = 0; i < index_sets.size(); i++) {

Set<int> iset = index_sets[i];

while (iset.size() > 1) {

// Append the parent folder to each scene name

for (Set<int>::Element *E = iset.front(); E; E = E->next()) {

int set_idx = E->get();

String scene_name = r_filenames[set_idx];

String full_path = p_full_paths[set_idx];

// Get rid of file extensions and res:// prefixes

if (scene_name.rfind(".") >= 0) {

scene_name = scene_name.substr(0, scene_name.rfind("."));

}

if (full_path.begins_with("res://")) {

full_path = full_path.substr(6);

}

if (full_path.rfind(".") >= 0) {

full_path = full_path.substr(0, full_path.rfind("."));

}

int scene_name_size = scene_name.size();

int full_path_size = full_path.size();

int difference = full_path_size - scene_name_size;

// Find just the parent folder of the current path and append it.

// If the current name is foo.tscn, and the full path is /some/folder/foo.tscn

// then slash_idx is the second '/', so that we select just "folder", and

// append that to yield "folder/foo.tscn".

if (difference > 0) {

String parent = full_path.substr(0, difference);

int slash_idx = parent.rfind("/");

slash_idx = parent.rfind("/", slash_idx - 1);

parent = slash_idx >= 0 ? parent.substr(slash_idx + 1) : parent;

r_filenames.write[set_idx] = parent + r_filenames[set_idx];

}

}

// Loop back through scene names and remove non-ambiguous names

bool can_proceed = false;

Set<int>::Element *E = iset.front();

while (E) {

String scene_name = r_filenames[E->get()];

bool duplicate_found = false;

for (Set<int>::Element *F = iset.front(); F; F = F->next()) {

if (E->get() == F->get()) {

continue;

}

String other_scene_name = r_filenames[F->get()];

if (other_scene_name == scene_name) {

duplicate_found = true;

break;

}

}

Set<int>::Element *to_erase = duplicate_found ? nullptr : E;

// We need to check that we could actually append anymore names

// if we wanted to for disambiguation. If we can't, then we have

// to abort even with ambiguous names. We clean the full path

// and the scene name first to remove extensions so that this

// comparison actually works.

String path = p_full_paths[E->get()];

if (path.begins_with("res://")) {

path = path.substr(6);

}

if (path.rfind(".") >= 0) {

path = path.substr(0, path.rfind("."));

}

if (scene_name.rfind(".") >= 0) {

scene_name = scene_name.substr(0, scene_name.rfind("."));

}

// We can proceed iff the full path is longer than the scene name,

// meaning that there is at least one more parent folder we can

// tack onto the name.

can_proceed = can_proceed || (path.size() - scene_name.size()) >= 1;

E = E->next();

if (to_erase) {

iset.erase(to_erase);

}

}

if (!can_proceed) {

break;

}

}

}

bool show_rb = EditorSettings::get_singleton()->get("interface/scene_tabs/show_script_button");

OS::get_singleton()->global_menu_clear("_dock");

// Get all scene names, which may be ambiguous

Vector<String> disambiguated_scene_names;

Vector<String> full_path_names;

for (int i = 0; i < editor_data.get_edited_scene_count(); i++) {

disambiguated_scene_names.push_back(editor_data.get_scene_title(i));

full_path_names.push_back(editor_data.get_scene_path(i));

}

disambiguate_filenames(full_path_names, disambiguated_scene_names);

scene_tabs->clear_tabs();

Ref<Texture> script_icon = gui_base->get_icon("Script", "EditorIcons");

for (int i = 0; i < editor_data.get_edited_scene_count(); i++) {

Node *type_node = editor_data.get_edited_scene_root(i);

Ref<Texture> icon;

if (type_node) {

icon = EditorNode::get_singleton()->get_object_icon(type_node, "Node");

}

int current = editor_data.get_edited_scene();

bool unsaved = (i == current) ? saved_version != editor_data.get_undo_redo().get_version() : editor_data.get_scene_version(i) != 0;

scene_tabs->add_tab(disambiguated_scene_names[i] + (unsaved ? "(*)" : ""), icon);

OS::get_singleton()->global_menu_add_item("_dock", editor_data.get_scene_title(i) + (unsaved ? "(*)" : ""), GLOBAL_SCENE, i);

if (show_rb && editor_data.get_scene_root_script(i).is_valid()) {

scene_tabs->set_tab_right_button(i, script_icon);

}

}

OS::get_singleton()->global_menu_add_separator("_dock");

OS::get_singleton()->global_menu_add_item("_dock", TTR("New Window"), GLOBAL_NEW_WINDOW, Variant());

scene_tabs->set_current_tab(editor_data.get_edited_scene());

if (scene_tabs->get_offset_buttons_visible()) {

// move add button to fixed position on the tabbar

if (scene_tab_add->get_parent() == scene_tabs) {

scene_tab_add->set_position(Point2(0, 0));

scene_tabs->remove_child(scene_tab_add);

tabbar_container->add_child(scene_tab_add);

tabbar_container->move_child(scene_tab_add, 1);

}

} else {

// move add button to after last tab

if (scene_tab_add->get_parent() == tabbar_container) {

tabbar_container->remove_child(scene_tab_add);

scene_tabs->add_child(scene_tab_add);

}

Rect2 last_tab = Rect2();

if (scene_tabs->get_tab_count() != 0) {

last_tab = scene_tabs->get_tab_rect(scene_tabs->get_tab_count() - 1);

}

scene_tab_add->set_position(Point2(last_tab.get_position().x + last_tab.get_size().x + 3, last_tab.get_position().y));

}

switch (vcs_actions_menu->get_item_id(p_idx)) {

case RUN_VCS_SETTINGS: {

VersionControlEditorPlugin::get_singleton()->popup_vcs_set_up_dialog(gui_base);

} break;

case RUN_VCS_SHUT_DOWN: {

VersionControlEditorPlugin::get_singleton()->shut_down();

} break;

}

const String appname = ProjectSettings::get_singleton()->get("application/config/name");

String title = (appname.empty() ? TTR("Unnamed Project") : appname) + String(" - ") + VERSION_NAME;

const String edited = editor_data.get_edited_scene_root() ? editor_data.get_edited_scene_root()->get_filename() : String();

if (!edited.empty()) {

// Display the edited scene name before the program name so that it can be seen in the OS task bar.

title = vformat("%s - %s", edited.get_file(), title);

}

if (unsaved_cache) {

// Display the "modified" mark before anything else so that it can always be seen in the OS task bar.

title = vformat("(*) %s", title);

}

OS::get_singleton()->set_window_title(title);

if (Node::get_viewport()->get_modal_stack_top()) {

return; //ignore because of modal window

}

Ref<InputEventKey> k = p_event;

if (k.is_valid() && k->is_pressed() && !k->is_echo() && !gui_base->get_viewport()->gui_has_modal_stack()) {

EditorPlugin *old_editor = editor_plugin_screen;

if (ED_IS_SHORTCUT("editor/next_tab", p_event)) {

int next_tab = editor_data.get_edited_scene() + 1;

next_tab %= editor_data.get_edited_scene_count();

_scene_tab_changed(next_tab);

}

if (ED_IS_SHORTCUT("editor/prev_tab", p_event)) {

int next_tab = editor_data.get_edited_scene() - 1;

next_tab = next_tab >= 0 ? next_tab : editor_data.get_edited_scene_count() - 1;

_scene_tab_changed(next_tab);

}

if (ED_IS_SHORTCUT("editor/filter_files", p_event)) {

filesystem_dock->focus_on_filter();

}

if (ED_IS_SHORTCUT("editor/editor_2d", p_event)) {

_editor_select(EDITOR_2D);

} else if (ED_IS_SHORTCUT("editor/editor_3d", p_event)) {

_editor_select(EDITOR_3D);

} else if (ED_IS_SHORTCUT("editor/editor_script", p_event)) {

_editor_select(EDITOR_SCRIPT);

} else if (ED_IS_SHORTCUT("editor/editor_help", p_event)) {

emit_signal("request_help_search", "");

} else if (ED_IS_SHORTCUT("editor/editor_assetlib", p_event) && AssetLibraryEditorPlugin::is_available()) {

_editor_select(EDITOR_ASSETLIB);

} else if (ED_IS_SHORTCUT("editor/editor_next", p_event)) {

_editor_select_next();

} else if (ED_IS_SHORTCUT("editor/editor_prev", p_event)) {

_editor_select_prev();

}

if (old_editor != editor_plugin_screen) {

get_tree()->set_input_as_handled();

}

}

switch (p_what) {

case NOTIFICATION_PROCESS: {

if (opening_prev && !confirmation->is_visible()) {

opening_prev = false;

}

if (unsaved_cache != (saved_version != editor_data.get_undo_redo().get_version())) {

unsaved_cache = (saved_version != editor_data.get_undo_redo().get_version());

_update_title();

}

if (last_checked_version != editor_data.get_undo_redo().get_version()) {

_update_scene_tabs();

last_checked_version = editor_data.get_undo_redo().get_version();

}

// Update the animation frame of the update spinner.

uint64_t frame = Engine::get_singleton()->get_frames_drawn();

uint64_t tick = OS::get_singleton()->get_ticks_msec();

if (frame != update_spinner_step_frame && (tick - update_spinner_step_msec) > (1000 / 8)) {

update_spinner_step++;

if (update_spinner_step >= 8) {

update_spinner_step = 0;

}

update_spinner_step_msec = tick;

update_spinner_step_frame = frame + 1;

// Update the icon itself only when the spinner is visible.

if (EditorSettings::get_singleton()->get("interface/editor/show_update_spinner")) {

update_spinner->set_icon(gui_base->get_icon("Progress" + itos(update_spinner_step + 1), "EditorIcons"));

}

}

editor_selection->update();

scene_root->set_size_override(true, Size2(GLOBAL_GET_CACHED(real_t, "display/window/size/width"), GLOBAL_GET_CACHED(real_t, "display/window/size/height")));

ResourceImporterTexture::get_singleton()->update_imports();

} break;

case NOTIFICATION_ENTER_TREE: {

Engine::get_singleton()->set_editor_hint(true);

OS::get_singleton()->set_low_processor_usage_mode_sleep_usec(int(EDITOR_GET("interface/editor/low_processor_mode_sleep_usec")));

get_tree()->get_root()->set_usage(Viewport::USAGE_2D_NO_SAMPLING); //reduce memory usage

get_tree()->get_root()->set_disable_3d(true);

get_tree()->get_root()->set_as_audio_listener(false);

get_tree()->get_root()->set_as_audio_listener_2d(false);

get_tree()->set_auto_accept_quit(false);

#ifdef ANDROID_ENABLED

get_tree()->set_quit_on_go_back(false);

#endif

get_tree()->connect("files_dropped", this, "_dropped_files");

get_tree()->connect("global_menu_action", this, "_global_menu_action");

/* DO NOT LOAD SCENES HERE, WAIT FOR FILE SCANNING AND REIMPORT TO COMPLETE */

} break;

case NOTIFICATION_EXIT_TREE: {

editor_data.save_editor_external_data();

FileAccess::set_file_close_fail_notify_callback(nullptr);

log->deinit(); // do not get messages anymore

editor_data.clear_edited_scenes();

} break;

case NOTIFICATION_READY: {

{

_initializing_addons = true;

Vector<String> addons;

if (ProjectSettings::get_singleton()->has_setting("editor_plugins/enabled")) {

addons = ProjectSettings::get_singleton()->get("editor_plugins/enabled");

}

for (int i = 0; i < addons.size(); i++) {

set_addon_plugin_enabled(addons[i], true);

}

_initializing_addons = false;

}

VisualServer::get_singleton()->viewport_set_hide_scenario(get_scene_root()->get_viewport_rid(), true);

VisualServer::get_singleton()->viewport_set_hide_canvas(get_scene_root()->get_viewport_rid(), true);

VisualServer::get_singleton()->viewport_set_disable_environment(get_viewport()->get_viewport_rid(), true);

feature_profile_manager->notify_changed();

if (!main_editor_buttons[EDITOR_3D]->is_visible()) { //may be hidden due to feature profile

_editor_select(EDITOR_2D);

} else {

_editor_select(EDITOR_3D);

}

_update_debug_options();

// Save the project after opening to mark it as last modified, except in headless mode.

if (OS::get_singleton()->can_draw() && !OS::get_singleton()->is_no_window_mode_enabled()) {

ProjectSettings::get_singleton()->save();

}

/* DO NOT LOAD SCENES HERE, WAIT FOR FILE SCANNING AND REIMPORT TO COMPLETE */

} break;

case MainLoop::NOTIFICATION_WM_FOCUS_IN: {

// Restore the original FPS cap after focusing back on the editor.

OS::get_singleton()->set_low_processor_usage_mode_sleep_usec(EDITOR_GET_CACHED(int, "interface/editor/low_processor_mode_sleep_usec"));

EditorFileSystem::get_singleton()->scan_changes();

_scan_external_changes();

} break;

case MainLoop::NOTIFICATION_WM_FOCUS_OUT: {

// Save on focus loss before applying the FPS limit to avoid slowing down the saving process.

if (EDITOR_GET_CACHED(bool, "interface/editor/save_on_focus_loss")) {

_menu_option_confirm(FILE_SAVE_SCENE, false);

}

// Set a low FPS cap to decrease CPU/GPU usage while the editor is unfocused.

OS::get_singleton()->set_low_processor_usage_mode_sleep_usec(EDITOR_GET_CACHED(int, "interface/editor/unfocused_low_processor_mode_sleep_usec"));

} break;

case MainLoop::NOTIFICATION_WM_ABOUT: {

show_about();

} break;

case MainLoop::NOTIFICATION_WM_QUIT_REQUEST: {

_menu_option_confirm(FILE_QUIT, false);

} break;

case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: {

scene_tabs->set_tab_close_display_policy((bool(EDITOR_GET("interface/scene_tabs/always_show_close_button")) ? Tabs::CLOSE_BUTTON_SHOW_ALWAYS : Tabs::CLOSE_BUTTON_SHOW_ACTIVE_ONLY));

FileDialog::set_default_show_hidden_files(EditorSettings::get_singleton()->get("filesystem/file_dialog/show_hidden_files"));

EditorFileDialog::set_default_show_hidden_files(EditorSettings::get_singleton()->get("filesystem/file_dialog/show_hidden_files"));

EditorFileDialog::set_default_display_mode((EditorFileDialog::DisplayMode)EditorSettings::get_singleton()->get("filesystem/file_dialog/display_mode").operator int());

theme = create_custom_theme(theme_base->get_theme());

theme_base->set_theme(theme);

gui_base->set_theme(theme);

gui_base->add_style_override("panel", gui_base->get_stylebox("Background", "EditorStyles"));

scene_root_parent->add_style_override("panel", gui_base->get_stylebox("Content", "EditorStyles"));

bottom_panel->add_style_override("panel", gui_base->get_stylebox("panel", "TabContainer"));

scene_tabs->add_style_override("tab_fg", gui_base->get_stylebox("SceneTabFG", "EditorStyles"));

scene_tabs->add_style_override("tab_bg", gui_base->get_stylebox("SceneTabBG", "EditorStyles"));

file_menu->add_style_override("hover", gui_base->get_stylebox("MenuHover", "EditorStyles"));

project_menu->add_style_override("hover", gui_base->get_stylebox("MenuHover", "EditorStyles"));

debug_menu->add_style_override("hover", gui_base->get_stylebox("MenuHover", "EditorStyles"));

settings_menu->add_style_override("hover", gui_base->get_stylebox("MenuHover", "EditorStyles"));

help_menu->add_style_override("hover", gui_base->get_stylebox("MenuHover", "EditorStyles"));

if (EDITOR_GET("interface/scene_tabs/resize_if_many_tabs")) {

scene_tabs->set_min_width(int(EDITOR_GET("interface/scene_tabs/minimum_width")) * EDSCALE);

} else {

scene_tabs->set_min_width(0);

}

_update_scene_tabs();

recent_scenes->set_as_minsize();

// debugger area

if (ScriptEditor::get_singleton()->get_debugger()->is_visible()) {

bottom_panel->add_style_override("panel", gui_base->get_stylebox("BottomPanelDebuggerOverride", "EditorStyles"));

}

// update_icons

for (int i = 0; i < singleton->main_editor_buttons.size(); i++) {

ToolButton *tb = singleton->main_editor_buttons[i];

EditorPlugin *p_editor = singleton->editor_table[i];

Ref<Texture> icon = p_editor->get_icon();

if (icon.is_valid()) {

tb->set_icon(icon);

} else if (singleton->gui_base->has_icon(p_editor->get_name(), "EditorIcons")) {

tb->set_icon(singleton->gui_base->get_icon(p_editor->get_name(), "EditorIcons"));

}

}

_build_icon_type_cache();

play_button->set_icon(gui_base->get_icon("MainPlay", "EditorIcons"));

play_scene_button->set_icon(gui_base->get_icon("PlayScene", "EditorIcons"));

play_custom_scene_button->set_icon(gui_base->get_icon("PlayCustom", "EditorIcons"));

pause_button->set_icon(gui_base->get_icon("Pause", "EditorIcons"));

stop_button->set_icon(gui_base->get_icon("Stop", "EditorIcons"));

prev_scene->set_icon(gui_base->get_icon("PrevScene", "EditorIcons"));

distraction_free->set_icon(gui_base->get_icon("DistractionFree", "EditorIcons"));

scene_tab_add->set_icon(gui_base->get_icon("Add", "EditorIcons"));

bottom_panel_raise->set_icon(gui_base->get_icon("ExpandBottomDock", "EditorIcons"));

// clear_button->set_icon(gui_base->get_icon("Close", "EditorIcons")); don't have access to that node. needs to become a class property

dock_tab_move_left->set_icon(theme->get_icon("Back", "EditorIcons"));

dock_tab_move_right->set_icon(theme->get_icon("Forward", "EditorIcons"));

PopupMenu *p = help_menu->get_popup();

p->set_item_icon(p->get_item_index(HELP_SEARCH), gui_base->get_icon("HelpSearch", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_DOCS), gui_base->get_icon("ExternalLink", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_QA), gui_base->get_icon("ExternalLink", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_COMMUNITY), gui_base->get_icon("ExternalLink", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_COPY_SYSTEM_INFO), gui_base->get_icon("ActionCopy", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_REPORT_A_BUG), gui_base->get_icon("ExternalLink", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_SUGGEST_A_FEATURE), gui_base->get_icon("ExternalLink", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_SEND_DOCS_FEEDBACK), gui_base->get_icon("ExternalLink", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_ABOUT), gui_base->get_icon("Godot", "EditorIcons"));

p->set_item_icon(p->get_item_index(HELP_SUPPORT_GODOT_DEVELOPMENT), gui_base->get_icon("Heart", "EditorIcons"));

_update_update_spinner();

} break;

case Control::NOTIFICATION_RESIZED: {

_update_scene_tabs();

} break;

}

update_spinner->set_visible(EditorSettings::get_singleton()->get("interface/editor/show_update_spinner"));

const bool update_continuously = EditorSettings::get_singleton()->get("interface/editor/update_continuously");

const bool vital_only = EditorSettings::get_singleton()->get("interface/editor/update_vital_only");

PopupMenu *update_popup = update_spinner->get_popup();

update_popup->set_item_checked(update_popup->get_item_index(SETTINGS_UPDATE_CONTINUOUSLY), update_continuously);

if (update_continuously) {

update_popup->set_item_checked(update_popup->get_item_index(SETTINGS_UPDATE_WHEN_CHANGED), false);

update_popup->set_item_checked(update_popup->get_item_index(SETTINGS_UPDATE_VITAL_ONLY), false);

} else {

update_popup->set_item_checked(update_popup->get_item_index(SETTINGS_UPDATE_WHEN_CHANGED), !vital_only);

update_popup->set_item_checked(update_popup->get_item_index(SETTINGS_UPDATE_VITAL_ONLY), vital_only);

}

if (update_continuously) {

update_spinner->set_tooltip(TTR("Spins when the editor window redraws.\nUpdate Continuously is enabled, which can increase power usage. Click to disable it."));

// Use a different color for the update spinner when Update Continuously is enabled,

// as this feature should only be enabled for troubleshooting purposes.

// Make the icon modulate color overbright because icons are not completely white on a dark theme.

// On a light theme, icons are dark, so we need to modulate them with an even brighter color.

const bool dark_theme = EditorSettings::get_singleton()->is_dark_theme();

update_spinner->set_self_modulate(

gui_base->get_color("error_color", "Editor") * (dark_theme ? Color(1.1, 1.1, 1.1) : Color(4.25, 4.25, 4.25)));

} else {

update_spinner->set_tooltip(TTR("Spins when the editor window redraws."));

update_spinner->set_self_modulate(Color(1, 1, 1));

}

OS::get_singleton()->set_low_processor_usage_mode(!update_continuously);

// Only set low priority redraws to false in the editor.

// When we run the project in the editor, we don't want it to prevent

// rendering any frames.

OS::get_singleton()->set_update_vital_only(vital_only && !update_continuously);

Ref<Script> script = Object::cast_to<Script>(p_script);

if (script.is_null()) {

return;

}

if (p_activate_name.length()) {

set_addon_plugin_enabled(p_activate_name, true);

}

project_settings->update_plugins();

project_settings->hide();

push_item(script.operator->());

ProjectSettings *ps = ProjectSettings::get_singleton();

PoolStringArray enabled_plugins = ps->get("editor_plugins/enabled");

for (int i = 0; i < enabled_plugins.size(); ++i) {

if (enabled_plugins.get(i) == p_name) {

enabled_plugins.remove(i);

break;

}

}

ps->set("editor_plugins/enabled", enabled_plugins);

List<Ref<Resource>> changed;

int rc = p_resources.size();

for (int i = 0; i < rc; i++) {

Ref<Resource> res(ResourceCache::get(p_resources.get(i)));

if (res.is_null()) {

continue;

}

if (!res->editor_can_reload_from_file()) {

continue;

}

if (!res->get_path().is_resource_file() && !res->get_path().is_abs_path()) {

continue;

}

if (!FileAccess::exists(res->get_path())) {

continue;

}

if (res->get_import_path() != String()) {

//this is an imported resource, will be reloaded if reimported via the _resources_reimported() callback

continue;

}

changed.push_back(res);

}

if (changed.size()) {

for (List<Ref<Resource>>::Element *E = changed.front(); E; E = E->next()) {

E->get()->reload_from_file();

}

}

for (Set<FileDialog *>::Element *E = file_dialogs.front(); E; E = E->next()) {

E->get()->invalidate();

}

for (Set<EditorFileDialog *>::Element *E = editor_file_dialogs.front(); E; E = E->next()) {

E->get()->invalidate();

}

_mark_unsaved_scenes();

// FIXME: Move this to a cleaner location, it's hacky to do this is _fs_changed.

String export_error;

Error err = OK;

if (export_defer.preset != "" && !EditorFileSystem::get_singleton()->is_scanning()) {

String preset_name = export_defer.preset;

// Ensures export_project does not loop infinitely, because notifications may

// come during the export.

export_defer.preset = "";

Ref<EditorExportPreset> preset;

for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); ++i) {

preset = EditorExport::get_singleton()->get_export_preset(i);

if (preset->get_name() == preset_name) {

break;

}

preset.unref();

}

if (preset.is_null()) {

DirAccessRef da = DirAccess::create(DirAccess::ACCESS_RESOURCES);

if (da->file_exists("res://export_presets.cfg")) {

err = FAILED;

export_error = vformat(

"Invalid export preset name: %s.\nThe following presets were detected in this project's `export_presets.cfg`:\n\n",

preset_name);

for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); ++i) {

// Write the preset name between double quotes since it needs to be written between quotes on the command line if it contains spaces.

export_error += vformat(" \"%s\"\n", EditorExport::get_singleton()->get_export_preset(i)->get_name());

}

} else {

err = FAILED;

export_error = "This project doesn't have an `export_presets.cfg` file at its root.\nCreate an export preset from the \"Project > Export\" dialog and try again.";

}

} else {

Ref<EditorExportPlatform> platform = preset->get_platform();

const String export_path = export_defer.path.empty() ? preset->get_export_path() : export_defer.path;

if (export_path.empty()) {

err = FAILED;

export_error = vformat("Export preset \"%s\" doesn't have a default export path, and none was specified.", preset_name);

} else if (platform.is_null()) {

err = FAILED;

export_error = vformat("Export preset \"%s\" doesn't have a matching platform.", preset_name);

} else {

if (export_defer.pack_only) { // Only export .pck or .zip data pack.

if (export_path.ends_with(".zip")) {

err = platform->export_zip(preset, export_defer.debug, export_path);

} else if (export_path.ends_with(".pck")) {

err = platform->export_pack(preset, export_defer.debug, export_path);

}

} else { // Normal project export.

String config_error;

bool missing_templates;

if (!platform->can_export(preset, config_error, missing_templates)) {

ERR_PRINT(vformat("Cannot export project with preset \"%s\" due to configuration errors:\n%s", preset_name, config_error));

err = missing_templates ? ERR_FILE_NOT_FOUND : ERR_UNCONFIGURED;

} else {

platform->clear_messages();

err = platform->export_project(preset, export_defer.debug, export_path);

}

}

if (err != OK) {

export_error = vformat("Project export for preset \"%s\" failed.", preset_name);

} else if (platform->get_worst_message_type() >= EditorExportPlatform::EXPORT_MESSAGE_WARNING) {

export_error = vformat("Project export for preset \"%s\" completed with warnings.", preset_name);

}

}

}

if (err != OK) {

ERR_PRINT(export_error);

OS::get_singleton()->set_exit_code(EXIT_FAILURE);

} else if (!export_error.empty()) {

WARN_PRINT(export_error);

}

_exit_editor();

}

List<String> scenes; //will load later

int current_tab = scene_tabs->get_current_tab();

for (int i = 0; i < p_resources.size(); i++) {

String file_type = ResourceLoader::get_resource_type(p_resources[i]);

if (file_type == "PackedScene") {

scenes.push_back(p_resources[i]);

//reload later if needed, first go with normal resources

continue;

}

if (!ResourceCache::has(p_resources[i])) {

continue; //not loaded, no need to reload

}

//reload normally

Resource *resource = ResourceCache::get(p_resources[i]);

if (resource) {

resource->reload_from_file();

}

}

for (List<String>::Element *E = scenes.front(); E; E = E->next()) {

reload_scene(E->get());

}

scene_tabs->set_current_tab(current_tab);

if (waiting_for_first_scan) {

waiting_for_first_scan = false;

// Start preview thread now that it's safe.

if (!singleton->cmdline_export_mode) {

EditorResourcePreview::get_singleton()->start();

}

_load_docks();

if (defer_load_scene != "") {

OS::get_singleton()->benchmark_begin_measure("editor_load_scene");

load_scene(defer_load_scene);

defer_load_scene = "";

OS::get_singleton()->benchmark_end_measure("editor_load_scene");

OS::get_singleton()->benchmark_dump();

}

}

disk_changed_list->clear();

TreeItem *r = disk_changed_list->create_item();

disk_changed_list->set_hide_root(true);

bool need_reload = false;

// Check if any edited scene has changed.

for (int i = 0; i < editor_data.get_edited_scene_count(); i++) {

DirAccessRef da = DirAccess::create(DirAccess::ACCESS_RESOURCES);

if (editor_data.get_scene_path(i) == "" || !da->file_exists(editor_data.get_scene_path(i))) {

continue;

}

uint64_t last_date = editor_data.get_scene_modified_time(i);

uint64_t date = FileAccess::get_modified_time(editor_data.get_scene_path(i));

if (date > last_date) {

TreeItem *ti = disk_changed_list->create_item(r);

ti->set_text(0, editor_data.get_scene_path(i).get_file());

need_reload = true;

}

}

String project_settings_path = ProjectSettings::get_singleton()->get_resource_path().plus_file("project.godot");

if (FileAccess::get_modified_time(project_settings_path) > ProjectSettings::get_singleton()->get_last_saved_time()) {

TreeItem *ti = disk_changed_list->create_item(r);

ti->set_text(0, "project.godot");

need_reload = true;

}

if (need_reload) {

disk_changed->call_deferred("popup_centered_ratio", 0.5);

}

save_all_scenes();

ProjectSettings::get_singleton()->save();

disk_changed->hide();

int current_idx = editor_data.get_edited_scene();

for (int i = 0; i < editor_data.get_edited_scene_count(); i++) {

if (editor_data.get_scene_path(i) == "") {

continue;

}

uint64_t last_date = editor_data.get_scene_modified_time(i);

uint64_t date = FileAccess::get_modified_time(editor_data.get_scene_path(i));

if (date > last_date) {

String filename = editor_data.get_scene_path(i);

editor_data.set_edited_scene(i);

_remove_edited_scene(false);

Error err = load_scene(filename, false, false, true, false, true);

if (err != OK) {

ERR_PRINT(vformat("Failed to load scene: %s", filename));

}

editor_data.move_edited_scene_to_index(i);

}

}

get_undo_redo()->clear_history(false);

set_current_scene(current_idx);

_update_scene_tabs();

disk_changed->hide();

if (get_inspector()) {

get_inspector()->update_tree();

}

int editor = _get_current_main_editor();

do {

if (editor == editor_table.size() - 1) {

editor = 0;

} else {

editor++;

}

} while (!main_editor_buttons[editor]->is_visible());

_editor_select(editor);

int editor = _get_current_main_editor();

do {

if (editor == 0) {

editor = editor_table.size() - 1;

} else {

editor--;

}

} while (!main_editor_buttons[editor]->is_visible());

_editor_select(editor);