if (!force_background && Thread::is_main_thread()) {

return EditorNode::progress_task_step(task, p_state, p_step, p_force_refresh);

} else {

EditorNode::progress_task_step_bg(task, p_step);

return false;

}

if (!p_force_background && Thread::is_main_thread()) {

EditorNode::progress_add_task(p_task, p_label, p_amount, p_can_cancel);

} else {

EditorNode::progress_add_task_bg(p_task, p_label, p_amount);

}

task = p_task;

force_background = p_force_background;

ERR_FAIL_COND_MSG(p_full_paths.size() != r_filenames.size(), vformat("disambiguate_filenames requires two string vectors of same length (%d != %d).", p_full_paths.size(), r_filenames.size()));

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

// within disambiguated_scene_names which contain the same name.

Vector<RBSet<int>> index_sets;

HashMap<String, int> scene_name_to_set_index;

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

const String &scene_name = r_filenames[i];

if (!scene_name_to_set_index.has(scene_name)) {

index_sets.append(RBSet<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++) {

RBSet<int> iset(index_sets[i]);

while (iset.size() > 1) {

// Append the parent folder to each scene name.

for (const int &E : iset) {

int set_idx = E;

String scene_name = r_filenames[set_idx];

String full_path = p_full_paths[set_idx];

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

scene_name = scene_name.get_basename();

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

full_path = full_path.substr(6);

}

full_path = full_path.get_basename();

// Normalize trailing slashes when normalizing directory names.

scene_name = scene_name.trim_suffix("/");

full_path = full_path.trim_suffix("/");

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_char('/');

slash_idx = parent.rfind_char('/', slash_idx - 1);

parent = (slash_idx >= 0 && parent.length() > 1) ? 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;

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

while (E) {

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

bool duplicate_found = false;

for (const int &F : iset) {

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

continue;

}

const String &other_scene_name = r_filenames[F];

if (other_scene_name == scene_name) {

duplicate_found = true;

break;

}

}

RBSet<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()];

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

scene_name = scene_name.get_basename();

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

path = path.substr(6);

}

path = path.get_basename();

// Normalize trailing slashes when normalizing directory names.

scene_name = scene_name.trim_suffix("/");

path = path.trim_suffix("/");

// We can proceed if 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;

}

}

}

switch (vcs_actions_menu->get_item_id(p_idx)) {

case VCS_METADATA: {

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

} break;

case VCS_SETTINGS: {

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

} break;

}

const String appname = GLOBAL_GET("application/config/name");

String title = (appname.is_empty() ? TTR("Unnamed Project") : appname);

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

if (!edited.is_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);

}

DisplayServer::get_singleton()->window_set_title(title + String(" - ") + GODOT_VERSION_NAME);

if (project_title) {

project_title->set_text(title);

}

bool is_unsaved = EditorUndoRedoManager::get_singleton()->is_history_unsaved(EditorUndoRedoManager::GLOBAL_HISTORY) ||

EditorUndoRedoManager::get_singleton()->is_history_unsaved(editor_data.get_current_edited_scene_history_id());

if (unsaved_cache != is_unsaved) {

unsaved_cache = is_unsaved;

_update_title();

}

// EditorNode::get_singleton()->set_process_input is set to true in ProgressDialog

// only when the progress dialog is visible.

// We need to discard all key events to disable all shortcuts while the progress

// dialog is displayed, simulating an exclusive popup. Mouse events are

// captured by a full-screen container in front of the EditorNode in ProgressDialog,

// allowing interaction with the actual dialog where a Cancel button may be visible.

Ref<InputEventKey> k = p_event;

if (k.is_valid()) {

get_tree()->get_root()->set_input_as_handled();

}

ERR_FAIL_COND(p_event.is_null());

Ref<InputEventKey> k = p_event;

if ((k.is_valid() && k->is_pressed() && !k->is_echo()) || Object::cast_to<InputEventShortcut>(*p_event)) {

bool is_handled = true;

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

FileSystemDock::get_singleton()->focus_on_filter();

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

editor_main_screen->select(EditorMainScreen::EDITOR_2D);

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

editor_main_screen->select(EditorMainScreen::EDITOR_3D);

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

editor_main_screen->select(EditorMainScreen::EDITOR_SCRIPT);

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

editor_main_screen->select(EditorMainScreen::EDITOR_GAME);

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

emit_signal(SNAME("request_help_search"), "");

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

editor_main_screen->select(EditorMainScreen::EDITOR_ASSETLIB);

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

editor_main_screen->select_next();

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

editor_main_screen->select_prev();

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

_open_command_palette();

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

bottom_panel->toggle_last_opened_bottom_panel();

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

EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();

undo_redo->create_action(TTR("Toggle Selected Node(s) Visibility"));

const List<Node *> &selection = editor_selection->get_top_selected_node_list();

for (Node *E : selection) {

Node *node_with_visibility;

node_with_visibility = Object::cast_to<CanvasItem>(E);

if (!node_with_visibility || !node_with_visibility->is_inside_tree()) {

node_with_visibility = Object::cast_to<Node3D>(E);

if (!node_with_visibility || !node_with_visibility->is_inside_tree()) {

continue;

}

}

undo_redo->add_do_method(node_with_visibility, "set_visible", !node_with_visibility->get("visible"));

undo_redo->add_undo_method(node_with_visibility, "set_visible", node_with_visibility->get("visible"));

}

undo_redo->commit_action();

} else {

is_handled = false;

}

if (is_handled) {

get_tree()->get_root()->set_input_as_handled();

}

}

if (!is_inside_tree()) {

return;

}

_update_title();

int current_filter = GLOBAL_GET("rendering/textures/canvas_textures/default_texture_filter");

if (current_filter != scene_root->get_default_canvas_item_texture_filter()) {

Viewport::DefaultCanvasItemTextureFilter tf = (Viewport::DefaultCanvasItemTextureFilter)current_filter;

scene_root->set_default_canvas_item_texture_filter(tf);

}

int current_repeat = GLOBAL_GET("rendering/textures/canvas_textures/default_texture_repeat");

if (current_repeat != scene_root->get_default_canvas_item_texture_repeat()) {

Viewport::DefaultCanvasItemTextureRepeat tr = (Viewport::DefaultCanvasItemTextureRepeat)current_repeat;

scene_root->set_default_canvas_item_texture_repeat(tr);

}

String current_fallback_locale = GLOBAL_GET("internationalization/locale/fallback");

if (current_fallback_locale != TranslationServer::get_singleton()->get_fallback_locale()) {

TranslationServer::get_singleton()->set_fallback_locale(current_fallback_locale);

Ref<TranslationDomain> domain = TranslationServer::get_singleton()->get_main_domain();

if (!domain->is_enabled()) {

domain->set_locale_override(current_fallback_locale);

}

scene_root->propagate_notification(Control::NOTIFICATION_LAYOUT_DIRECTION_CHANGED);

}

RSE::DOFBokehShape dof_shape = RSE::DOFBokehShape(int(GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_bokeh_shape")));

RS::get_singleton()->camera_attributes_set_dof_blur_bokeh_shape(dof_shape);

RSE::DOFBlurQuality dof_quality = RSE::DOFBlurQuality(int(GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_bokeh_quality")));

bool dof_jitter = GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_use_jitter");

RS::get_singleton()->camera_attributes_set_dof_blur_quality(dof_quality, dof_jitter);

RS::get_singleton()->environment_set_ssao_quality(RSE::EnvironmentSSAOQuality(int(GLOBAL_GET("rendering/environment/ssao/quality"))), GLOBAL_GET("rendering/environment/ssao/half_size"), GLOBAL_GET("rendering/environment/ssao/adaptive_target"), GLOBAL_GET("rendering/environment/ssao/blur_passes"), GLOBAL_GET("rendering/environment/ssao/fadeout_from"), GLOBAL_GET("rendering/environment/ssao/fadeout_to"));

RS::get_singleton()->screen_space_roughness_limiter_set_active(GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/enabled"), GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/amount"), GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/limit"));

bool glow_bicubic = int(GLOBAL_GET("rendering/environment/glow/upscale_mode")) > 0;

RS::get_singleton()->environment_set_ssil_quality(RSE::EnvironmentSSILQuality(int(GLOBAL_GET("rendering/environment/ssil/quality"))), GLOBAL_GET("rendering/environment/ssil/half_size"), GLOBAL_GET("rendering/environment/ssil/adaptive_target"), GLOBAL_GET("rendering/environment/ssil/blur_passes"), GLOBAL_GET("rendering/environment/ssil/fadeout_from"), GLOBAL_GET("rendering/environment/ssil/fadeout_to"));

RS::get_singleton()->environment_glow_set_use_bicubic_upscale(glow_bicubic);

RS::get_singleton()->environment_set_ssr_half_size(GLOBAL_GET("rendering/environment/screen_space_reflection/half_size"));

RSE::SubSurfaceScatteringQuality sss_quality = RSE::SubSurfaceScatteringQuality(int(GLOBAL_GET("rendering/environment/subsurface_scattering/subsurface_scattering_quality")));

RS::get_singleton()->sub_surface_scattering_set_quality(sss_quality);

float sss_scale = GLOBAL_GET("rendering/environment/subsurface_scattering/subsurface_scattering_scale");

float sss_depth_scale = GLOBAL_GET("rendering/environment/subsurface_scattering/subsurface_scattering_depth_scale");

RS::get_singleton()->sub_surface_scattering_set_scale(sss_scale, sss_depth_scale);

uint32_t directional_shadow_size = GLOBAL_GET("rendering/lights_and_shadows/directional_shadow/size");

uint32_t directional_shadow_16_bits = GLOBAL_GET("rendering/lights_and_shadows/directional_shadow/16_bits");

RS::get_singleton()->directional_shadow_atlas_set_size(directional_shadow_size, directional_shadow_16_bits);

RSE::ShadowQuality shadows_quality = RSE::ShadowQuality(int(GLOBAL_GET("rendering/lights_and_shadows/positional_shadow/soft_shadow_filter_quality")));

RS::get_singleton()->positional_soft_shadow_filter_set_quality(shadows_quality);

RSE::ShadowQuality directional_shadow_quality = RSE::ShadowQuality(int(GLOBAL_GET("rendering/lights_and_shadows/directional_shadow/soft_shadow_filter_quality")));

RS::get_singleton()->directional_soft_shadow_filter_set_quality(directional_shadow_quality);

float probe_update_speed = GLOBAL_GET("rendering/lightmapping/probe_capture/update_speed");

RS::get_singleton()->lightmap_set_probe_capture_update_speed(probe_update_speed);

RSE::EnvironmentSDFGIFramesToConverge frames_to_converge = RSE::EnvironmentSDFGIFramesToConverge(int(GLOBAL_GET("rendering/global_illumination/sdfgi/frames_to_converge")));

RS::get_singleton()->environment_set_sdfgi_frames_to_converge(frames_to_converge);

RSE::EnvironmentSDFGIRayCount ray_count = RSE::EnvironmentSDFGIRayCount(int(GLOBAL_GET("rendering/global_illumination/sdfgi/probe_ray_count")));

RS::get_singleton()->environment_set_sdfgi_ray_count(ray_count);

RSE::VoxelGIQuality voxel_gi_quality = RSE::VoxelGIQuality(int(GLOBAL_GET("rendering/global_illumination/voxel_gi/quality")));

RS::get_singleton()->voxel_gi_set_quality(voxel_gi_quality);

RS::get_singleton()->environment_set_volumetric_fog_volume_size(GLOBAL_GET("rendering/environment/volumetric_fog/volume_size"), GLOBAL_GET("rendering/environment/volumetric_fog/volume_depth"));

RS::get_singleton()->environment_set_volumetric_fog_filter_active(bool(GLOBAL_GET("rendering/environment/volumetric_fog/use_filter")));

RS::get_singleton()->canvas_set_shadow_texture_size(GLOBAL_GET("rendering/2d/shadow_atlas/size"));

bool use_half_res_gi = GLOBAL_GET("rendering/global_illumination/gi/use_half_resolution");

RS::get_singleton()->gi_set_use_half_resolution(use_half_res_gi);

bool snap_2d_transforms = GLOBAL_GET("rendering/2d/snap/snap_2d_transforms_to_pixel");

scene_root->set_snap_2d_transforms_to_pixel(snap_2d_transforms);

bool snap_2d_vertices = GLOBAL_GET("rendering/2d/snap/snap_2d_vertices_to_pixel");

scene_root->set_snap_2d_vertices_to_pixel(snap_2d_vertices);

Viewport::SDFOversize sdf_oversize = Viewport::SDFOversize(int(GLOBAL_GET("rendering/2d/sdf/oversize")));

scene_root->set_sdf_oversize(sdf_oversize);

Viewport::SDFScale sdf_scale = Viewport::SDFScale(int(GLOBAL_GET("rendering/2d/sdf/scale")));

scene_root->set_sdf_scale(sdf_scale);

Viewport::MSAA msaa = Viewport::MSAA(int(GLOBAL_GET("rendering/anti_aliasing/quality/msaa_2d")));

scene_root->set_msaa_2d(msaa);

// 2D doesn't use a dedicated SubViewport like 3D does, so we apply it on the root viewport instead.

bool use_debanding = GLOBAL_GET("rendering/anti_aliasing/quality/use_debanding");

scene_root->set_use_debanding(use_debanding);

get_viewport()->set_use_debanding(use_debanding);

// Enable HDR if requested.

const bool hdr_requested = GLOBAL_GET("display/window/hdr/request_hdr_output");

DisplayServer::get_singleton()->window_request_hdr_output(hdr_requested);

const bool use_hdr_2d = GLOBAL_GET("rendering/viewport/hdr_2d");

scene_root->set_use_hdr_2d(use_hdr_2d || hdr_requested);

get_viewport()->set_use_hdr_2d(use_hdr_2d || hdr_requested);

if (hdr_requested && !use_hdr_2d) {

WARN_PRINT_ED("HDR 2D was automatically enabled because HDR output was requested in project settings. To avoid this warning, enable rendering/viewport/hdr_2d in the Project Settings.");

}

float mesh_lod_threshold = GLOBAL_GET("rendering/mesh_lod/lod_change/threshold_pixels");

scene_root->set_mesh_lod_threshold(mesh_lod_threshold);

RS::get_singleton()->decals_set_filter(RSE::DecalFilter(int(GLOBAL_GET("rendering/textures/decals/filter"))));

RS::get_singleton()->light_projectors_set_filter(RSE::LightProjectorFilter(int(GLOBAL_GET("rendering/textures/light_projectors/filter"))));

RS::get_singleton()->lightmaps_set_bicubic_filter(GLOBAL_GET("rendering/lightmapping/lightmap_gi/use_bicubic_filter"));

RS::get_singleton()->material_set_use_debanding(GLOBAL_GET("rendering/anti_aliasing/quality/use_debanding"));

SceneTree *tree = get_tree();

tree->set_debug_collisions_color(GLOBAL_GET("debug/shapes/collision/shape_color"));

tree->set_debug_collision_contact_color(GLOBAL_GET("debug/shapes/collision/contact_color"));

if (ProjectSettings::get_singleton()->check_changed_settings_in_group("display/window/hdr/request_hdr_output") || ProjectSettings::get_singleton()->check_changed_settings_in_group("rendering/viewport/hdr_2d")) {

const bool use_hdr = GLOBAL_GET("display/window/hdr/request_hdr_output").operator bool() || GLOBAL_GET("rendering/viewport/hdr_2d").operator bool();

LocalVector<ObjectID> invalid_viewports;

for (const ObjectID &id : hdr_viewports) {

Viewport *vp = ObjectDB::get_instance<Viewport>(id);

if (vp) {

vp->set_use_hdr_2d(use_hdr);

} else {

invalid_viewports.push_back(id);

}

}

for (const ObjectID &id : invalid_viewports) {

hdr_viewports.erase(id);

}

}

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

_update_translations();

#ifdef DEBUG_ENABLED

NavigationServer2D::get_singleton()->set_debug_navigation_edge_connection_color(GLOBAL_GET("debug/shapes/navigation/2d/edge_connection_color"));

NavigationServer2D::get_singleton()->set_debug_navigation_geometry_edge_color(GLOBAL_GET("debug/shapes/navigation/2d/geometry_edge_color"));

NavigationServer2D::get_singleton()->set_debug_navigation_geometry_face_color(GLOBAL_GET("debug/shapes/navigation/2d/geometry_face_color"));

NavigationServer2D::get_singleton()->set_debug_navigation_geometry_edge_disabled_color(GLOBAL_GET("debug/shapes/navigation/2d/geometry_edge_disabled_color"));

NavigationServer2D::get_singleton()->set_debug_navigation_geometry_face_disabled_color(GLOBAL_GET("debug/shapes/navigation/2d/geometry_face_disabled_color"));

NavigationServer2D::get_singleton()->set_debug_navigation_enable_edge_connections(GLOBAL_GET("debug/shapes/navigation/2d/enable_edge_connections"));

NavigationServer2D::get_singleton()->set_debug_navigation_enable_edge_lines(GLOBAL_GET("debug/shapes/navigation/2d/enable_edge_lines"));

NavigationServer2D::get_singleton()->set_debug_navigation_enable_geometry_face_random_color(GLOBAL_GET("debug/shapes/navigation/2d/enable_geometry_face_random_color"));

NavigationServer3D::get_singleton()->set_debug_navigation_edge_connection_color(GLOBAL_GET("debug/shapes/navigation/3d/edge_connection_color"));

NavigationServer3D::get_singleton()->set_debug_navigation_geometry_edge_color(GLOBAL_GET("debug/shapes/navigation/3d/geometry_edge_color"));

NavigationServer3D::get_singleton()->set_debug_navigation_geometry_face_color(GLOBAL_GET("debug/shapes/navigation/3d/geometry_face_color"));

NavigationServer3D::get_singleton()->set_debug_navigation_geometry_edge_disabled_color(GLOBAL_GET("debug/shapes/navigation/3d/geometry_edge_disabled_color"));

NavigationServer3D::get_singleton()->set_debug_navigation_geometry_face_disabled_color(GLOBAL_GET("debug/shapes/navigation/3d/geometry_face_disabled_color"));

NavigationServer3D::get_singleton()->set_debug_navigation_enable_edge_connections(GLOBAL_GET("debug/shapes/navigation/3d/enable_edge_connections"));

NavigationServer3D::get_singleton()->set_debug_navigation_enable_edge_connections_xray(GLOBAL_GET("debug/shapes/navigation/3d/enable_edge_connections_xray"));

NavigationServer3D::get_singleton()->set_debug_navigation_enable_edge_lines(GLOBAL_GET("debug/shapes/navigation/3d/enable_edge_lines"));

NavigationServer3D::get_singleton()->set_debug_navigation_enable_edge_lines_xray(GLOBAL_GET("debug/shapes/navigation/3d/enable_edge_lines_xray"));

NavigationServer3D::get_singleton()->set_debug_navigation_enable_geometry_face_random_color(GLOBAL_GET("debug/shapes/navigation/3d/enable_geometry_face_random_color"));

#endif // DEBUG_ENABLED

// In case the developer is inspecting an object that will be changed by the reload.

InspectorDock::get_inspector_singleton()->update_tree();

// Reload script editor to revalidate GDScript if classes are added or removed.

ScriptEditor::get_singleton()->reload_scripts(true);

// Regenerate documentation without using script documentation cache since that would

// revert doc changes during this session.

EditorHelp::generate_doc(true, false);

Ref<TranslationDomain> main = TranslationServer::get_singleton()->get_main_domain();

TranslationServer::get_singleton()->load_project_translations(main);

if (main->is_enabled()) {

// Check for the exact locale.

if (main->has_translation_for_locale(main->get_locale_override(), true)) {

// The set of translation resources for the current locale changed.

const HashSet<Ref<Translation>> translations = main->find_translations(main->get_locale_override(), false);

if (translations != tracked_translations) {

_translation_resources_changed();

}

} else {

// Translations for the current preview locale is removed.

main->set_enabled(false);

main->set_locale_override(String());

_translation_resources_changed();

}

}

for (const Ref<Translation> &E : tracked_translations) {

E->disconnect_changed(callable_mp(this, &EditorNode::_queue_translation_notification));

}

tracked_translations.clear();

const Ref<TranslationDomain> main = TranslationServer::get_singleton()->get_main_domain();

if (main->is_enabled()) {

const HashSet<Ref<Translation>> translations = main->find_translations(main->get_locale_override(), false);

tracked_translations.reserve(translations.size());

for (const Ref<Translation> &translation : translations) {

translation->connect_changed(callable_mp(this, &EditorNode::_queue_translation_notification));

tracked_translations.insert(translation);

}

}

_queue_translation_notification();

emit_signal(SNAME("preview_locale_changed"));

if (pending_translation_notification) {

return;

}

pending_translation_notification = true;

callable_mp(this, &EditorNode::_propagate_translation_notification).call_deferred();

if (!p_skip_creation) {

theme = EditorThemeManager::generate_theme(theme);

DisplayServer::set_early_window_clear_color_override(true, theme->get_color(SNAME("background"), EditorStringName(Editor)));

#if defined(MODULE_GDSCRIPT_ENABLED) || defined(MODULE_MONO_ENABLED)

if (EditorHelpHighlighter::get_singleton()) {

// Update syntax colors.

EditorHelpHighlighter::free_singleton();

EditorHelpHighlighter::create_singleton();

}

#endif

}

Vector<Ref<Theme>> editor_themes;

editor_themes.push_back(theme);

editor_themes.push_back(ThemeDB::get_singleton()->get_default_theme());

ThemeContext *node_tc = ThemeDB::get_singleton()->get_theme_context(this);

if (node_tc) {

node_tc->set_themes(editor_themes);

} else {

ThemeDB::get_singleton()->create_theme_context(this, editor_themes);

}

Window *window = get_window();

if (window) {

ThemeContext *window_tc = ThemeDB::get_singleton()->get_theme_context(window);

if (window_tc) {

window_tc->set_themes(editor_themes);

} else {

ThemeDB::get_singleton()->create_theme_context(window, editor_themes);

}

}

if (CanvasItemEditor::get_singleton()->get_theme_preview() == CanvasItemEditor::THEME_PREVIEW_EDITOR) {

update_preview_themes(CanvasItemEditor::THEME_PREVIEW_EDITOR);

}

// Update styles.

{

bool dark_mode = DisplayServer::get_singleton()->is_dark_mode_supported() && DisplayServer::get_singleton()->is_dark_mode();

gui_base->add_theme_style_override(SceneStringName(panel), theme->get_stylebox(SNAME("Background"), EditorStringName(EditorStyles)));

main_vbox->set_anchors_and_offsets_preset(Control::PRESET_FULL_RECT, Control::PRESET_MODE_MINSIZE, theme->get_constant(SNAME("window_border_margin"), EditorStringName(Editor)));

main_vbox->add_theme_constant_override("separation", theme->get_constant(SNAME("top_bar_separation"), EditorStringName(Editor)));

if (main_menu_button != nullptr) {

main_menu_button->set_button_icon(theme->get_icon(SNAME("TripleBar"), EditorStringName(EditorIcons)));

}

editor_main_screen->add_theme_style_override(SceneStringName(panel), theme->get_stylebox(SNAME("Content"), EditorStringName(EditorStyles)));

bottom_panel->_theme_changed();

distraction_free->set_button_icon(theme->get_icon(SNAME("DistractionFree"), EditorStringName(EditorIcons)));

update_distraction_free_button_theme();

help_menu->set_item_icon(help_menu->get_item_index(HELP_SEARCH), get_editor_theme_native_menu_icon(SNAME("HelpSearch"), menu_type == MENU_TYPE_GLOBAL, dark_mode));

help_menu->set_item_icon(help_menu->get_item_index(HELP_COPY_SYSTEM_INFO), get_editor_theme_native_menu_icon(SNAME("ActionCopy"), menu_type == MENU_TYPE_GLOBAL, dark_mode));

help_menu->set_item_icon(help_menu->get_item_index(HELP_ABOUT), get_editor_theme_native_menu_icon(SNAME("Godot"), menu_type == MENU_TYPE_GLOBAL, dark_mode));

help_menu->set_item_icon(help_menu->get_item_index(HELP_SUPPORT_GODOT_DEVELOPMENT), get_editor_theme_native_menu_icon(SNAME("Heart"), menu_type == MENU_TYPE_GLOBAL, dark_mode));

_update_renderer_color();

}

Ref<Texture2D> thumbnail_icon = gui_base->get_theme_icon(SNAME("file_thumbnail"), SNAME("FileDialog"));

default_thumbnail.instantiate();

default_thumbnail->set_image(thumbnail_icon->get_image());

editor_dock_manager->update_tab_styles();

editor_dock_manager->update_docks_menu();

editor_dock_manager->set_tab_icon_max_width(theme->get_constant(SNAME("class_icon_size"), EditorStringName(Editor)));

#ifdef ANDROID_ENABLED

DisplayServer::get_singleton()->window_set_color(theme->get_color(SNAME("background"), EditorStringName(Editor)));

#endif

Ref<Texture2D> tx = theme->get_icon(p_name, SNAME("EditorIcons"));

if (!p_global_menu || p_dark_mode == EditorThemeManager::is_dark_icon_and_font()) {

return tx;

}

Ref<DPITexture> new_tx = tx;

if (new_tx.is_null()) {

return tx;

}

new_tx = new_tx->duplicate();

Dictionary color_conversion_map;

if (!p_dark_mode) {

for (KeyValue<Color, Color> &E : EditorColorMap::get_color_conversion_map()) {

color_conversion_map[E.key] = E.value;

}

}

new_tx->set_color_map(color_conversion_map);

return new_tx;

if (!scene_root->is_inside_tree()) {

return; // Too early.

}

Vector<Ref<Theme>> preview_themes;

switch (p_mode) {

case CanvasItemEditor::THEME_PREVIEW_PROJECT:

preview_themes.push_back(ThemeDB::get_singleton()->get_project_theme());

break;

case CanvasItemEditor::THEME_PREVIEW_EDITOR:

preview_themes.push_back(get_editor_theme());

break;

default:

break;

}

preview_themes.push_back(ThemeDB::get_singleton()->get_default_theme());

ThemeContext *preview_context = ThemeDB::get_singleton()->get_theme_context(scene_root);

if (preview_context) {

preview_context->set_themes(preview_themes);

} else {

ThemeDB::get_singleton()->create_theme_context(scene_root, preview_themes);

}

Ref<DirAccess> da = DirAccess::create(DirAccess::ACCESS_RESOURCES);

const String project_data_dir = EditorPaths::get_singleton()->get_project_data_dir();

if (!da->dir_exists(project_data_dir)) {

return true;

}

String project_data_gdignore_file_path = project_data_dir.path_join(".gdignore");

if (!FileAccess::exists(project_data_gdignore_file_path)) {

Ref<FileAccess> f = FileAccess::open(project_data_gdignore_file_path, FileAccess::WRITE);

if (f.is_valid()) {

f->store_line("");

} else {

ERR_PRINT("Failed to create file " + project_data_gdignore_file_path.quote() + ".");

}

}

String uid_cache = ResourceUID::get_singleton()->get_cache_file();

if (!da->file_exists(uid_cache)) {

Error err = ResourceUID::get_singleton()->save_to_cache();

if (err != OK) {

ERR_PRINT("Failed to create file " + uid_cache.quote() + ".");

}

}

const String dirs[] = {

EditorPaths::get_singleton()->get_project_settings_dir(),

ProjectSettings::get_singleton()->get_imported_files_path()

};

for (const String &dir : dirs) {

if (!da->dir_exists(dir)) {

return true;

}

}

return false;

switch (p_what) {

case NOTIFICATION_TRANSLATION_CHANGED: {

_update_title();

callable_mp(this, &EditorNode::_titlebar_resized).call_deferred();

// The rendering method selector.

const String current_renderer_ps = String(GLOBAL_GET("rendering/renderer/rendering_method")).to_lower();

const String current_renderer_os = OS::get_singleton()->get_current_rendering_method().to_lower();

if (current_renderer_ps == current_renderer_os) {

for (int i = 0; i < renderer->get_item_count(); i++) {

renderer->set_item_text(i, _to_rendering_method_display_name(renderer->get_item_metadata(i)));

}

} else {

// TRANSLATORS: The placeholder is the rendering method that has overridden the default one.

renderer->set_item_text(0, vformat(TTR("%s (Overridden)"), _to_rendering_method_display_name(current_renderer_os)));

}

} break;

case NOTIFICATION_POSTINITIALIZE: {

EditorHelp::generate_doc();

#if defined(MODULE_GDSCRIPT_ENABLED) || defined(MODULE_MONO_ENABLED)

EditorHelpHighlighter::create_singleton();

#endif

} break;

case NOTIFICATION_PROCESS: {

if (editor_data.is_scene_changed(-1)) {

scene_tabs->update_scene_tabs();

}

if (update_spinner->is_visible()) {

// 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_spinner->set_button_icon(theme->get_icon("Progress" + itos(update_spinner_step + 1), EditorStringName(EditorIcons)));

}

}

editor_selection->update();

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

if (requested_first_scan) {

requested_first_scan = false;

OS::get_singleton()->benchmark_begin_measure("Editor", "First Scan");

EditorFileSystem::get_singleton()->connect("filesystem_changed", callable_mp(this, &EditorNode::_execute_upgrades), CONNECT_ONE_SHOT);

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

}

if (settings_overrides_changed) {

EditorSettings::get_singleton()->notify_changes();

EditorSettings::get_singleton()->emit_signal(SNAME("settings_changed"));

settings_overrides_changed = false;

}

} break;

case NOTIFICATION_ENTER_TREE: {

get_tree()->set_disable_node_threading(true); // No node threading while running editor.

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

Window *window = get_window();

if (window) {

// Handle macOS fullscreen and extend-to-title changes.

window->connect("titlebar_changed", callable_mp(this, &EditorNode::_titlebar_resized));

}

// Theme has already been created in the constructor, so we can skip that step.

_update_theme(true);

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

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

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

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

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

get_tree()->set_auto_accept_quit(false);

#ifdef ANDROID_ENABLED

get_tree()->set_quit_on_go_back(false);

bool is_fullscreen = EDITOR_DEF("_is_editor_fullscreen", false);

if (is_fullscreen) {

DisplayServer::get_singleton()->window_set_mode(DisplayServerEnums::WINDOW_MODE_FULLSCREEN);

}

#endif

get_tree()->get_root()->connect("files_dropped", callable_mp(this, &EditorNode::_dropped_files));

command_palette->register_shortcuts_as_command();

_begin_first_scan();

last_dark_mode_state = DisplayServer::get_singleton()->is_dark_mode();

last_system_accent_color = DisplayServer::get_singleton()->get_accent_color();

last_system_base_color = DisplayServer::get_singleton()->get_base_color();

DisplayServer::get_singleton()->set_system_theme_change_callback(callable_mp(this, &EditorNode::_check_system_theme_changed));

get_viewport()->connect("size_changed", callable_mp(this, &EditorNode::_viewport_resized));

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

} break;

case NOTIFICATION_EXIT_TREE: {

singleton->active_plugins.clear();

if (progress_dialog) {

progress_dialog->queue_free();

}

if (load_error_dialog) {

load_error_dialog->queue_free();

}

if (execute_output_dialog) {

execute_output_dialog->queue_free();

}

if (warning) {

warning->queue_free();

}

if (accept) {

accept->queue_free();

}

if (save_accept) {

save_accept->queue_free();

}

EditorHelp::save_script_doc_cache();

editor_data.save_editor_external_data();

EditorSettings::get_singleton()->save_project_metadata();

FileAccess::set_file_close_fail_notify_callback(nullptr);

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

editor_data.clear_edited_scenes();

get_viewport()->disconnect("size_changed", callable_mp(this, &EditorNode::_viewport_resized));

} break;

case NOTIFICATION_READY: {

// Store the default order of bottom docks. It can only be determined dynamically.

PackedStringArray bottom_docks;

bottom_docks.reserve_exact(bottom_panel->get_tab_count());

for (int i = 0; i < bottom_panel->get_tab_count(); i++) {

EditorDock *dock = Object::cast_to<EditorDock>(bottom_panel->get_tab_control(i));

bottom_docks.append(dock->get_effective_layout_key());