/*************************************************************************/ /* script_editor_debugger.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "script_editor_debugger.h" #include "core/config/project_settings.h" #include "core/debugger/debugger_marshalls.h" #include "core/debugger/remote_debugger.h" #include "core/io/marshalls.h" #include "core/string/ustring.h" #include "editor/debugger/editor_network_profiler.h" #include "editor/debugger/editor_performance_profiler.h" #include "editor/debugger/editor_profiler.h" #include "editor/debugger/editor_visual_profiler.h" #include "editor/editor_log.h" #include "editor/editor_node.h" #include "editor/editor_scale.h" #include "editor/editor_settings.h" #include "editor/plugins/canvas_item_editor_plugin.h" #include "editor/plugins/editor_debugger_plugin.h" #include "editor/plugins/node_3d_editor_plugin.h" #include "editor/property_editor.h" #include "main/performance.h" #include "scene/3d/camera_3d.h" #include "scene/debugger/scene_debugger.h" #include "scene/gui/dialogs.h" #include "scene/gui/label.h" #include "scene/gui/line_edit.h" #include "scene/gui/margin_container.h" #include "scene/gui/rich_text_label.h" #include "scene/gui/separator.h" #include "scene/gui/split_container.h" #include "scene/gui/tab_container.h" #include "scene/gui/texture_button.h" #include "scene/gui/tree.h" #include "scene/resources/packed_scene.h" #include "servers/display_server.h" using CameraOverride = EditorDebuggerNode::CameraOverride; void ScriptEditorDebugger::_put_msg(String p_message, Array p_data) { if (is_session_active()) { Array msg; msg.push_back(p_message); msg.push_back(p_data); peer->put_message(msg); } } void ScriptEditorDebugger::debug_copy() { String msg = reason->get_text(); if (msg == "") { return; } DisplayServer::get_singleton()->clipboard_set(msg); } void ScriptEditorDebugger::debug_skip_breakpoints() { skip_breakpoints_value = !skip_breakpoints_value; if (skip_breakpoints_value) { skip_breakpoints->set_icon(get_theme_icon("DebugSkipBreakpointsOn", "EditorIcons")); } else { skip_breakpoints->set_icon(get_theme_icon("DebugSkipBreakpointsOff", "EditorIcons")); } Array msg; msg.push_back(skip_breakpoints_value); _put_msg("set_skip_breakpoints", msg); } void ScriptEditorDebugger::debug_next() { ERR_FAIL_COND(!breaked); _put_msg("next", Array()); _clear_execution(); } void ScriptEditorDebugger::debug_step() { ERR_FAIL_COND(!breaked); _put_msg("step", Array()); _clear_execution(); } void ScriptEditorDebugger::debug_break() { ERR_FAIL_COND(breaked); _put_msg("break", Array()); } void ScriptEditorDebugger::debug_continue() { ERR_FAIL_COND(!breaked); // Allow focus stealing only if we actually run this client for security. if (remote_pid && EditorNode::get_singleton()->has_child_process(remote_pid)) { DisplayServer::get_singleton()->enable_for_stealing_focus(remote_pid); } _clear_execution(); _put_msg("continue", Array()); } void ScriptEditorDebugger::update_tabs() { if (error_count == 0 && warning_count == 0) { errors_tab->set_name(TTR("Errors")); tabs->set_tab_icon(errors_tab->get_index(), Ref<Texture2D>()); } else { errors_tab->set_name(TTR("Errors") + " (" + itos(error_count + warning_count) + ")"); if (error_count >= 1 && warning_count >= 1) { tabs->set_tab_icon(errors_tab->get_index(), get_theme_icon("ErrorWarning", "EditorIcons")); } else if (error_count >= 1) { tabs->set_tab_icon(errors_tab->get_index(), get_theme_icon("Error", "EditorIcons")); } else { tabs->set_tab_icon(errors_tab->get_index(), get_theme_icon("Warning", "EditorIcons")); } } } void ScriptEditorDebugger::clear_style() { tabs->add_theme_style_override("panel", nullptr); } void ScriptEditorDebugger::save_node(ObjectID p_id, const String &p_file) { Array msg; msg.push_back(p_id); msg.push_back(p_file); _put_msg("scene:save_node", msg); } void ScriptEditorDebugger::_file_selected(const String &p_file) { switch (file_dialog_purpose) { case SAVE_MONITORS_CSV: { Error err; FileAccessRef file = FileAccess::open(p_file, FileAccess::WRITE, &err); if (err != OK) { ERR_PRINT("Failed to open " + p_file); return; } Vector<String> line; line.resize(Performance::MONITOR_MAX); // signatures for (int i = 0; i < Performance::MONITOR_MAX; i++) { line.write[i] = Performance::get_singleton()->get_monitor_name(Performance::Monitor(i)); } file->store_csv_line(line); // values Vector<List<float>::Element *> iterators; iterators.resize(Performance::MONITOR_MAX); bool continue_iteration = false; for (int i = 0; i < Performance::MONITOR_MAX; i++) { iterators.write[i] = performance_profiler->get_monitor_data(Performance::get_singleton()->get_monitor_name(Performance::Monitor(i)))->back(); continue_iteration = continue_iteration || iterators[i]; } while (continue_iteration) { continue_iteration = false; for (int i = 0; i < Performance::MONITOR_MAX; i++) { if (iterators[i]) { line.write[i] = String::num_real(iterators[i]->get()); iterators.write[i] = iterators[i]->prev(); } else { line.write[i] = ""; } continue_iteration = continue_iteration || iterators[i]; } file->store_csv_line(line); } file->store_string("\n"); Vector<Vector<String>> profiler_data = profiler->get_data_as_csv(); for (int i = 0; i < profiler_data.size(); i++) { file->store_csv_line(profiler_data[i]); } } break; case SAVE_VRAM_CSV: { Error err; FileAccessRef file = FileAccess::open(p_file, FileAccess::WRITE, &err); if (err != OK) { ERR_PRINT("Failed to open " + p_file); return; } Vector<String> headers; headers.resize(vmem_tree->get_columns()); for (int i = 0; i < vmem_tree->get_columns(); ++i) { headers.write[i] = vmem_tree->get_column_title(i); } file->store_csv_line(headers); if (vmem_tree->get_root()) { TreeItem *ti = vmem_tree->get_root()->get_children(); while (ti) { Vector<String> values; values.resize(vmem_tree->get_columns()); for (int i = 0; i < vmem_tree->get_columns(); ++i) { values.write[i] = ti->get_text(i); } file->store_csv_line(values); ti = ti->get_next(); } } } break; } } void ScriptEditorDebugger::request_remote_tree() { _put_msg("scene:request_scene_tree", Array()); } const SceneDebuggerTree *ScriptEditorDebugger::get_remote_tree() { return scene_tree; } void ScriptEditorDebugger::update_remote_object(ObjectID p_obj_id, const String &p_prop, const Variant &p_value) { Array msg; msg.push_back(p_obj_id); msg.push_back(p_prop); msg.push_back(p_value); _put_msg("scene:set_object_property", msg); } void ScriptEditorDebugger::request_remote_object(ObjectID p_obj_id) { ERR_FAIL_COND(p_obj_id.is_null()); Array msg; msg.push_back(p_obj_id); _put_msg("scene:inspect_object", msg); } Object *ScriptEditorDebugger::get_remote_object(ObjectID p_id) { return inspector->get_object(p_id); } void ScriptEditorDebugger::_remote_object_selected(ObjectID p_id) { emit_signal("remote_object_requested", p_id); } void ScriptEditorDebugger::_remote_object_edited(ObjectID p_id, const String &p_prop, const Variant &p_value) { update_remote_object(p_id, p_prop, p_value); request_remote_object(p_id); } void ScriptEditorDebugger::_remote_object_property_updated(ObjectID p_id, const String &p_property) { emit_signal("remote_object_property_updated", p_id, p_property); } void ScriptEditorDebugger::_video_mem_request() { _put_msg("core:memory", Array()); } void ScriptEditorDebugger::_video_mem_export() { file_dialog->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE); file_dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM); file_dialog->clear_filters(); file_dialog_purpose = SAVE_VRAM_CSV; file_dialog->popup_file_dialog(); } Size2 ScriptEditorDebugger::get_minimum_size() const { Size2 ms = MarginContainer::get_minimum_size(); ms.y = MAX(ms.y, 250 * EDSCALE); return ms; } void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_data) { if (p_msg == "debug_enter") { _put_msg("get_stack_dump", Array()); ERR_FAIL_COND(p_data.size() != 2); bool can_continue = p_data[0]; String error = p_data[1]; breaked = true; can_debug = can_continue; _update_buttons_state(); _set_reason_text(error, MESSAGE_ERROR); emit_signal("breaked", true, can_continue); DisplayServer::get_singleton()->window_move_to_foreground(); if (error != "") { tabs->set_current_tab(0); } profiler->set_enabled(false); inspector->clear_cache(); // Take a chance to force remote objects update. } else if (p_msg == "debug_exit") { breaked = false; can_debug = false; _clear_execution(); _update_buttons_state(); _set_reason_text(TTR("Execution resumed."), MESSAGE_SUCCESS); emit_signal("breaked", false, false); profiler->set_enabled(true); profiler->disable_seeking(); } else if (p_msg == "set_pid") { ERR_FAIL_COND(p_data.size() < 1); remote_pid = p_data[0]; } else if (p_msg == "scene:click_ctrl") { ERR_FAIL_COND(p_data.size() < 2); clicked_ctrl->set_text(p_data[0]); clicked_ctrl_type->set_text(p_data[1]); } else if (p_msg == "scene:scene_tree") { scene_tree->nodes.clear(); scene_tree->deserialize(p_data); emit_signal("remote_tree_updated"); _update_buttons_state(); } else if (p_msg == "scene:inspect_object") { ObjectID id = inspector->add_object(p_data); if (id.is_valid()) { emit_signal("remote_object_updated", id); } } else if (p_msg == "memory:usage") { vmem_tree->clear(); TreeItem *root = vmem_tree->create_item(); DebuggerMarshalls::ResourceUsage usage; usage.deserialize(p_data); uint64_t total = 0; for (List<DebuggerMarshalls::ResourceInfo>::Element *E = usage.infos.front(); E; E = E->next()) { TreeItem *it = vmem_tree->create_item(root); String type = E->get().type; int bytes = E->get().vram; it->set_text(0, E->get().path); it->set_text(1, type); it->set_text(2, E->get().format); it->set_text(3, String::humanize_size(bytes)); total += bytes; if (has_theme_icon(type, "EditorIcons")) { it->set_icon(0, get_theme_icon(type, "EditorIcons")); } } vmem_total->set_tooltip(TTR("Bytes:") + " " + itos(total)); vmem_total->set_text(String::humanize_size(total)); } else if (p_msg == "stack_dump") { DebuggerMarshalls::ScriptStackDump stack; stack.deserialize(p_data); stack_dump->clear(); inspector->clear_stack_variables(); TreeItem *r = stack_dump->create_item(); for (int i = 0; i < stack.frames.size(); i++) { TreeItem *s = stack_dump->create_item(r); Dictionary d; d["frame"] = i; d["file"] = stack.frames[i].file; d["function"] = stack.frames[i].func; d["line"] = stack.frames[i].line; s->set_metadata(0, d); String line = itos(i) + " - " + String(d["file"]) + ":" + itos(d["line"]) + " - at function: " + d["function"]; s->set_text(0, line); if (i == 0) { s->select(0); } } } else if (p_msg == "stack_frame_vars") { inspector->clear_stack_variables(); } else if (p_msg == "stack_frame_var") { inspector->add_stack_variable(p_data); } else if (p_msg == "output") { ERR_FAIL_COND(p_data.size() != 2); ERR_FAIL_COND(p_data[0].get_type() != Variant::PACKED_STRING_ARRAY); Vector<String> output_strings = p_data[0]; ERR_FAIL_COND(p_data[1].get_type() != Variant::PACKED_INT32_ARRAY); Vector<int> output_types = p_data[1]; ERR_FAIL_COND(output_strings.size() != output_types.size()); for (int i = 0; i < output_strings.size(); i++) { RemoteDebugger::MessageType type = (RemoteDebugger::MessageType)(int)(output_types[i]); EditorLog::MessageType msg_type; switch (type) { case RemoteDebugger::MESSAGE_TYPE_LOG: { msg_type = EditorLog::MSG_TYPE_STD; } break; case RemoteDebugger::MESSAGE_TYPE_ERROR: { msg_type = EditorLog::MSG_TYPE_ERROR; } break; default: { WARN_PRINT("Unhandled script debugger message type: " + itos(type)); msg_type = EditorLog::MSG_TYPE_STD; } break; } EditorNode::get_log()->add_message(output_strings[i], msg_type); } } else if (p_msg == "performance:profile_frame") { Vector<float> frame_data; frame_data.resize(p_data.size()); for (int i = 0; i < p_data.size(); i++) { frame_data.write[i] = p_data[i]; } performance_profiler->add_profile_frame(frame_data); } else if (p_msg == "visual:profile_frame") { DebuggerMarshalls::VisualProfilerFrame frame; frame.deserialize(p_data); EditorVisualProfiler::Metric metric; metric.areas.resize(frame.areas.size()); metric.frame_number = frame.frame_number; metric.valid = true; { EditorVisualProfiler::Metric::Area *areas_ptr = metric.areas.ptrw(); for (int i = 0; i < frame.areas.size(); i++) { areas_ptr[i].name = frame.areas[i].name; areas_ptr[i].cpu_time = frame.areas[i].cpu_msec; areas_ptr[i].gpu_time = frame.areas[i].gpu_msec; } } visual_profiler->add_frame_metric(metric); } else if (p_msg == "error") { DebuggerMarshalls::OutputError oe; ERR_FAIL_COND_MSG(oe.deserialize(p_data) == false, "Failed to deserialize error message"); // Format time. Array time_vals; time_vals.push_back(oe.hr); time_vals.push_back(oe.min); time_vals.push_back(oe.sec); time_vals.push_back(oe.msec); bool e; String time = String("%d:%02d:%02d:%04d").sprintf(time_vals, &e); // Rest of the error data. bool source_is_project_file = oe.source_file.begins_with("res://"); // Metadata to highlight error line in scripts. Array source_meta; source_meta.push_back(oe.source_file); source_meta.push_back(oe.source_line); // Create error tree to display above error or warning details. TreeItem *r = error_tree->get_root(); if (!r) { r = error_tree->create_item(); } // Also provide the relevant details as tooltip to quickly check without // uncollapsing the tree. String tooltip = oe.warning ? TTR("Warning:") : TTR("Error:"); TreeItem *error = error_tree->create_item(r); error->set_collapsed(true); error->set_icon(0, get_theme_icon(oe.warning ? "Warning" : "Error", "EditorIcons")); error->set_text(0, time); error->set_text_align(0, TreeItem::ALIGN_LEFT); String error_title; if (oe.callstack.size() > 0) { // If available, use the script's stack in the error title. error_title = oe.callstack[oe.callstack.size() - 1].func + ": "; } else if (!oe.source_func.is_empty()) { // Otherwise try to use the C++ source function. error_title += oe.source_func + ": "; } // If we have a (custom) error message, use it as title, and add a C++ Error // item with the original error condition. error_title += oe.error_descr.is_empty() ? oe.error : oe.error_descr; error->set_text(1, error_title); tooltip += " " + error_title + "\n"; if (!oe.error_descr.is_empty()) { // Add item for C++ error condition. TreeItem *cpp_cond = error_tree->create_item(error); cpp_cond->set_text(0, "<" + TTR("C++ Error") + ">"); cpp_cond->set_text(1, oe.error); cpp_cond->set_text_align(0, TreeItem::ALIGN_LEFT); tooltip += TTR("C++ Error:") + " " + oe.error + "\n"; if (source_is_project_file) { cpp_cond->set_metadata(0, source_meta); } } Vector<uint8_t> v; v.resize(100); // Source of the error. String source_txt = (source_is_project_file ? oe.source_file.get_file() : oe.source_file) + ":" + itos(oe.source_line); if (!oe.source_func.is_empty()) { source_txt += " @ " + oe.source_func + "()"; } TreeItem *cpp_source = error_tree->create_item(error); cpp_source->set_text(0, "<" + (source_is_project_file ? TTR("Source") : TTR("C++ Source")) + ">"); cpp_source->set_text(1, source_txt); cpp_source->set_text_align(0, TreeItem::ALIGN_LEFT); tooltip += (source_is_project_file ? TTR("Source:") : TTR("C++ Source:")) + " " + source_txt + "\n"; // Set metadata to highlight error line in scripts. if (source_is_project_file) { error->set_metadata(0, source_meta); cpp_source->set_metadata(0, source_meta); } // Format stack trace. // stack_items_count is the number of elements to parse, with 3 items per frame // of the stack trace (script, method, line). const ScriptLanguage::StackInfo *infos = oe.callstack.ptr(); for (unsigned int i = 0; i < (unsigned int)oe.callstack.size(); i++) { TreeItem *stack_trace = error_tree->create_item(error); Array meta; meta.push_back(infos[i].file); meta.push_back(infos[i].line); stack_trace->set_metadata(0, meta); if (i == 0) { stack_trace->set_text(0, "<" + TTR("Stack Trace") + ">"); stack_trace->set_text_align(0, TreeItem::ALIGN_LEFT); error->set_metadata(0, meta); tooltip += TTR("Stack Trace:") + "\n"; } String frame_txt = infos[i].file.get_file() + ":" + itos(infos[i].line) + " @ " + infos[i].func + "()"; tooltip += frame_txt + "\n"; stack_trace->set_text(1, frame_txt); } error->set_tooltip(0, tooltip); error->set_tooltip(1, tooltip); if (oe.warning) { warning_count++; } else { error_count++; } } else if (p_msg == "servers:function_signature") { // Cache a profiler signature. DebuggerMarshalls::ScriptFunctionSignature sig; sig.deserialize(p_data); profiler_signature[sig.id] = sig.name; } else if (p_msg == "servers:profile_frame" || p_msg == "servers:profile_total") { EditorProfiler::Metric metric; DebuggerMarshalls::ServersProfilerFrame frame; frame.deserialize(p_data); metric.valid = true; metric.frame_number = frame.frame_number; metric.frame_time = frame.frame_time; metric.idle_time = frame.idle_time; metric.physics_time = frame.physics_time; metric.physics_frame_time = frame.physics_frame_time; if (frame.servers.size()) { EditorProfiler::Metric::Category frame_time; frame_time.signature = "category_frame_time"; frame_time.name = "Frame Time"; frame_time.total_time = metric.frame_time; EditorProfiler::Metric::Category::Item item; item.calls = 1; item.line = 0; item.name = "Physics Time"; item.total = metric.physics_time; item.self = item.total; item.signature = "physics_time"; frame_time.items.push_back(item); item.name = "Idle Time"; item.total = metric.idle_time; item.self = item.total; item.signature = "idle_time"; frame_time.items.push_back(item); item.name = "Physics Frame Time"; item.total = metric.physics_frame_time; item.self = item.total; item.signature = "physics_frame_time"; frame_time.items.push_back(item); metric.categories.push_back(frame_time); } for (int i = 0; i < frame.servers.size(); i++) { const DebuggerMarshalls::ServerInfo &srv = frame.servers[i]; EditorProfiler::Metric::Category c; const String name = srv.name; c.name = name.capitalize(); c.items.resize(srv.functions.size()); c.total_time = 0; c.signature = "categ::" + name; for (int j = 0; j < srv.functions.size(); j++) { EditorProfiler::Metric::Category::Item item; item.calls = 1; item.line = 0; item.name = srv.functions[j].name; item.self = srv.functions[j].time; item.total = item.self; item.signature = "categ::" + name + "::" + item.name; item.name = item.name.capitalize(); c.total_time += item.total; c.items.write[j] = item; } metric.categories.push_back(c); } EditorProfiler::Metric::Category funcs; funcs.total_time = frame.script_time; funcs.items.resize(frame.script_functions.size()); funcs.name = "Script Functions"; funcs.signature = "script_functions"; for (int i = 0; i < frame.script_functions.size(); i++) { int signature = frame.script_functions[i].sig_id; int calls = frame.script_functions[i].call_count; float total = frame.script_functions[i].total_time; float self = frame.script_functions[i].self_time; EditorProfiler::Metric::Category::Item item; if (profiler_signature.has(signature)) { item.signature = profiler_signature[signature]; String name = profiler_signature[signature]; Vector<String> strings = name.split("::"); if (strings.size() == 3) { item.name = strings[2]; item.script = strings[0]; item.line = strings[1].to_int(); } else if (strings.size() == 4) { //Built-in scripts have an :: in their name item.name = strings[3]; item.script = strings[0] + "::" + strings[1]; item.line = strings[2].to_int(); } } else { item.name = "SigErr " + itos(signature); } item.calls = calls; item.self = self; item.total = total; funcs.items.write[i] = item; } metric.categories.push_back(funcs); if (p_msg == "servers:profile_frame") { profiler->add_frame_metric(metric, false); } else { profiler->add_frame_metric(metric, true); } } else if (p_msg == "network:profile_frame") { DebuggerMarshalls::NetworkProfilerFrame frame; frame.deserialize(p_data); for (int i = 0; i < frame.infos.size(); i++) { network_profiler->add_node_frame_data(frame.infos[i]); } } else if (p_msg == "network:bandwidth") { ERR_FAIL_COND(p_data.size() < 2); network_profiler->set_bandwidth(p_data[0], p_data[1]); } else if (p_msg == "request_quit") { emit_signal("stop_requested"); _stop_and_notify(); } else if (p_msg == "performance:profile_names") { Vector<StringName> monitors; monitors.resize(p_data.size()); for (int i = 0; i < p_data.size(); i++) { ERR_FAIL_COND(p_data[i].get_type() != Variant::STRING_NAME); monitors.set(i, p_data[i]); } performance_profiler->update_monitors(monitors); } else { int colon_index = p_msg.find_char(':'); ERR_FAIL_COND_MSG(colon_index < 1, "Invalid message received"); bool parsed = false; const String cap = p_msg.substr(0, colon_index); Map<StringName, Callable>::Element *element = captures.find(cap); if (element) { Callable &c = element->value(); ERR_FAIL_COND_MSG(c.is_null(), "Invalid callable registered: " + cap); Variant cmd = p_msg.substr(colon_index + 1), data = p_data; const Variant *args[2] = { &cmd, &data }; Variant retval; Callable::CallError err; c.call(args, 2, retval, err); ERR_FAIL_COND_MSG(err.error != Callable::CallError::CALL_OK, "Error calling 'capture' to callable: " + Variant::get_callable_error_text(c, args, 2, err)); ERR_FAIL_COND_MSG(retval.get_type() != Variant::BOOL, "Error calling 'capture' to callable: " + String(c) + ". Return type is not bool."); parsed = retval; } if (!parsed) { WARN_PRINT("unknown message " + p_msg); } } } void ScriptEditorDebugger::_set_reason_text(const String &p_reason, MessageType p_type) { switch (p_type) { case MESSAGE_ERROR: reason->add_theme_color_override("font_color", get_theme_color("error_color", "Editor")); break; case MESSAGE_WARNING: reason->add_theme_color_override("font_color", get_theme_color("warning_color", "Editor")); break; default: reason->add_theme_color_override("font_color", get_theme_color("success_color", "Editor")); } reason->set_text(p_reason); reason->set_tooltip(p_reason.word_wrap(80)); } void ScriptEditorDebugger::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { skip_breakpoints->set_icon(get_theme_icon("DebugSkipBreakpointsOff", "EditorIcons")); copy->set_icon(get_theme_icon("ActionCopy", "EditorIcons")); step->set_icon(get_theme_icon("DebugStep", "EditorIcons")); next->set_icon(get_theme_icon("DebugNext", "EditorIcons")); dobreak->set_icon(get_theme_icon("Pause", "EditorIcons")); docontinue->set_icon(get_theme_icon("DebugContinue", "EditorIcons")); le_set->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_live_edit_set)); le_clear->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_live_edit_clear)); error_tree->connect("item_selected", callable_mp(this, &ScriptEditorDebugger::_error_selected)); error_tree->connect("item_activated", callable_mp(this, &ScriptEditorDebugger::_error_activated)); vmem_refresh->set_icon(get_theme_icon("Reload", "EditorIcons")); vmem_export->set_icon(get_theme_icon("Save", "EditorIcons")); reason->add_theme_color_override("font_color", get_theme_color("error_color", "Editor")); } break; case NOTIFICATION_PROCESS: { if (is_session_active()) { peer->poll(); if (camera_override == CameraOverride::OVERRIDE_2D) { CanvasItemEditor *editor = CanvasItemEditor::get_singleton(); Dictionary state = editor->get_state(); float zoom = state["zoom"]; Point2 offset = state["ofs"]; Transform2D transform; transform.scale_basis(Size2(zoom, zoom)); transform.elements[2] = -offset * zoom; Array msg; msg.push_back(transform); _put_msg("scene:override_camera_2D:transform", msg); } else if (camera_override >= CameraOverride::OVERRIDE_3D_1) { int viewport_idx = camera_override - CameraOverride::OVERRIDE_3D_1; Node3DEditorViewport *viewport = Node3DEditor::get_singleton()->get_editor_viewport(viewport_idx); Camera3D *const cam = viewport->get_camera(); Array msg; msg.push_back(cam->get_camera_transform()); if (cam->get_projection() == Camera3D::PROJECTION_ORTHOGONAL) { msg.push_back(false); msg.push_back(cam->get_size()); } else { msg.push_back(true); msg.push_back(cam->get_fov()); } msg.push_back(cam->get_near()); msg.push_back(cam->get_far()); _put_msg("scene:override_camera_3D:transform", msg); } } const uint64_t until = OS::get_singleton()->get_ticks_msec() + 20; while (peer.is_valid() && peer->has_message()) { Array arr = peer->get_message(); if (arr.size() != 2 || arr[0].get_type() != Variant::STRING || arr[1].get_type() != Variant::ARRAY) { _stop_and_notify(); ERR_FAIL_MSG("Invalid message format received from peer"); } _parse_message(arr[0], arr[1]); if (OS::get_singleton()->get_ticks_msec() > until) { break; } } if (!is_session_active()) { _stop_and_notify(); break; }; } break; case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: { if (tabs->has_theme_stylebox_override("panel")) { tabs->add_theme_style_override("panel", editor->get_gui_base()->get_theme_stylebox("DebuggerPanel", "EditorStyles")); } copy->set_icon(get_theme_icon("ActionCopy", "EditorIcons")); step->set_icon(get_theme_icon("DebugStep", "EditorIcons")); next->set_icon(get_theme_icon("DebugNext", "EditorIcons")); dobreak->set_icon(get_theme_icon("Pause", "EditorIcons")); docontinue->set_icon(get_theme_icon("DebugContinue", "EditorIcons")); vmem_refresh->set_icon(get_theme_icon("Reload", "EditorIcons")); vmem_export->set_icon(get_theme_icon("Save", "EditorIcons")); } break; } } void ScriptEditorDebugger::_clear_execution() { TreeItem *ti = stack_dump->get_selected(); if (!ti) { return; } Dictionary d = ti->get_metadata(0); stack_script = ResourceLoader::load(d["file"]); emit_signal("clear_execution", stack_script); stack_script.unref(); stack_dump->clear(); inspector->clear_stack_variables(); } void ScriptEditorDebugger::start(Ref<RemoteDebuggerPeer> p_peer) { error_count = 0; warning_count = 0; stop(); peer = p_peer; ERR_FAIL_COND(p_peer.is_null()); performance_profiler->reset(); set_process(true); breaked = false; can_debug = true; camera_override = CameraOverride::OVERRIDE_NONE; tabs->set_current_tab(0); _set_reason_text(TTR("Debug session started."), MESSAGE_SUCCESS); _update_buttons_state(); emit_signal("started"); } void ScriptEditorDebugger::_update_buttons_state() { const bool active = is_session_active(); const bool has_editor_tree = active && editor_remote_tree && editor_remote_tree->get_selected(); vmem_refresh->set_disabled(!active); step->set_disabled(!active || !breaked || !can_debug); next->set_disabled(!active || !breaked || !can_debug); copy->set_disabled(!active || !breaked); docontinue->set_disabled(!active || !breaked); dobreak->set_disabled(!active || breaked); le_clear->set_disabled(!active); le_set->set_disabled(!has_editor_tree); } void ScriptEditorDebugger::_stop_and_notify() { stop(); emit_signal("stopped"); _set_reason_text(TTR("Debug session closed."), MESSAGE_WARNING); } void ScriptEditorDebugger::stop() { set_process(false); breaked = false; can_debug = false; remote_pid = 0; _clear_execution(); inspector->clear_cache(); if (peer.is_valid()) { peer->close(); peer.unref(); reason->set_text(""); reason->set_tooltip(""); } node_path_cache.clear(); res_path_cache.clear(); profiler_signature.clear(); inspector->edit(nullptr); _update_buttons_state(); } void ScriptEditorDebugger::_profiler_activate(bool p_enable, int p_type) { Array data; data.push_back(p_enable); switch (p_type) { case PROFILER_NETWORK: _put_msg("profiler:network", data); break; case PROFILER_VISUAL: _put_msg("profiler:visual", data); break; case PROFILER_SCRIPTS_SERVERS: if (p_enable) { // Clear old script signatures. (should we move all this into the profiler?) profiler_signature.clear(); // Add max funcs options to request. Array opts; int max_funcs = EditorSettings::get_singleton()->get("debugger/profiler_frame_max_functions"); opts.push_back(CLAMP(max_funcs, 16, 512)); data.push_back(opts); } _put_msg("profiler:servers", data); break; default: ERR_FAIL_MSG("Invalid profiler type"); } } void ScriptEditorDebugger::_profiler_seeked() { if (breaked) { return; } debug_break(); } void ScriptEditorDebugger::_stack_dump_frame_selected() { emit_signal("stack_frame_selected"); int frame = get_stack_script_frame(); if (is_session_active() && frame >= 0) { Array msg; msg.push_back(frame); _put_msg("get_stack_frame_vars", msg); } else { inspector->edit(nullptr); } } void ScriptEditorDebugger::_export_csv() { file_dialog->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE); file_dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM); file_dialog_purpose = SAVE_MONITORS_CSV; file_dialog->popup_file_dialog(); } String ScriptEditorDebugger::get_var_value(const String &p_var) const { if (!breaked) { return String(); } return inspector->get_stack_variable(p_var); } int ScriptEditorDebugger::_get_node_path_cache(const NodePath &p_path) { const int *r = node_path_cache.getptr(p_path); if (r) { return *r; } last_path_id++; node_path_cache[p_path] = last_path_id; Array msg; msg.push_back(p_path); msg.push_back(last_path_id); _put_msg("scene:live_node_path", msg); return last_path_id; } int ScriptEditorDebugger::_get_res_path_cache(const String &p_path) { Map<String, int>::Element *E = res_path_cache.find(p_path); if (E) { return E->get(); } last_path_id++; res_path_cache[p_path] = last_path_id; Array msg; msg.push_back(p_path); msg.push_back(last_path_id); _put_msg("scene:live_res_path", msg); return last_path_id; } void ScriptEditorDebugger::_method_changed(Object *p_base, const StringName &p_name, VARIANT_ARG_DECLARE) { if (!p_base || !live_debug || !is_session_active() || !editor->get_edited_scene()) { return; } Node *node = Object::cast_to<Node>(p_base); VARIANT_ARGPTRS for (int i = 0; i < VARIANT_ARG_MAX; i++) { //no pointers, sorry if (argptr[i] && (argptr[i]->get_type() == Variant::OBJECT || argptr[i]->get_type() == Variant::RID)) { return; } } if (node) { NodePath path = editor->get_edited_scene()->get_path_to(node); int pathid = _get_node_path_cache(path); Array msg; msg.push_back(pathid); msg.push_back(p_name); for (int i = 0; i < VARIANT_ARG_MAX; i++) { //no pointers, sorry msg.push_back(*argptr[i]); } _put_msg("scene:live_node_call", msg); return; } Resource *res = Object::cast_to<Resource>(p_base); if (res && res->get_path() != String()) { String respath = res->get_path(); int pathid = _get_res_path_cache(respath); Array msg; msg.push_back(pathid); msg.push_back(p_name); for (int i = 0; i < VARIANT_ARG_MAX; i++) { //no pointers, sorry msg.push_back(*argptr[i]); } _put_msg("scene:live_res_call", msg); return; } } void ScriptEditorDebugger::_property_changed(Object *p_base, const StringName &p_property, const Variant &p_value) { if (!p_base || !live_debug || !editor->get_edited_scene()) { return; } Node *node = Object::cast_to<Node>(p_base); if (node) { NodePath path = editor->get_edited_scene()->get_path_to(node); int pathid = _get_node_path_cache(path); if (p_value.is_ref()) { Ref<Resource> res = p_value; if (res.is_valid() && res->get_path() != String()) { Array msg; msg.push_back(pathid); msg.push_back(p_property); msg.push_back(res->get_path()); _put_msg("scene:live_node_prop_res", msg); } } else { Array msg; msg.push_back(pathid); msg.push_back(p_property); msg.push_back(p_value); _put_msg("scene:live_node_prop", msg); } return; } Resource *res = Object::cast_to<Resource>(p_base); if (res && res->get_path() != String()) { String respath = res->get_path(); int pathid = _get_res_path_cache(respath); if (p_value.is_ref()) { Ref<Resource> res2 = p_value; if (res2.is_valid() && res2->get_path() != String()) { Array msg; msg.push_back(pathid); msg.push_back(p_property); msg.push_back(res2->get_path()); _put_msg("scene:live_res_prop_res", msg); } } else { Array msg; msg.push_back(pathid); msg.push_back(p_property); msg.push_back(p_value); _put_msg("scene:live_res_prop", msg); } return; } } String ScriptEditorDebugger::get_stack_script_file() const { TreeItem *ti = stack_dump->get_selected(); if (!ti) { return ""; } Dictionary d = ti->get_metadata(0); return d["file"]; } int ScriptEditorDebugger::get_stack_script_line() const { TreeItem *ti = stack_dump->get_selected(); if (!ti) { return -1; } Dictionary d = ti->get_metadata(0); return d["line"]; } int ScriptEditorDebugger::get_stack_script_frame() const { TreeItem *ti = stack_dump->get_selected(); if (!ti) { return -1; } Dictionary d = ti->get_metadata(0); return d["frame"]; } void ScriptEditorDebugger::set_live_debugging(bool p_enable) { live_debug = p_enable; } void ScriptEditorDebugger::_live_edit_set() { if (!is_session_active() || !editor_remote_tree) { return; } TreeItem *ti = editor_remote_tree->get_selected(); if (!ti) { return; } String path; while (ti) { String lp = ti->get_text(0); path = "/" + lp + path; ti = ti->get_parent(); } NodePath np = path; editor->get_editor_data().set_edited_scene_live_edit_root(np); update_live_edit_root(); } void ScriptEditorDebugger::_live_edit_clear() { NodePath np = NodePath("/root"); editor->get_editor_data().set_edited_scene_live_edit_root(np); update_live_edit_root(); } void ScriptEditorDebugger::update_live_edit_root() { NodePath np = editor->get_editor_data().get_edited_scene_live_edit_root(); Array msg; msg.push_back(np); if (editor->get_edited_scene()) { msg.push_back(editor->get_edited_scene()->get_filename()); } else { msg.push_back(""); } _put_msg("scene:live_set_root", msg); live_edit_root->set_text(np); } void ScriptEditorDebugger::live_debug_create_node(const NodePath &p_parent, const String &p_type, const String &p_name) { if (live_debug) { Array msg; msg.push_back(p_parent); msg.push_back(p_type); msg.push_back(p_name); _put_msg("scene:live_create_node", msg); } } void ScriptEditorDebugger::live_debug_instance_node(const NodePath &p_parent, const String &p_path, const String &p_name) { if (live_debug) { Array msg; msg.push_back(p_parent); msg.push_back(p_path); msg.push_back(p_name); _put_msg("scene:live_instance_node", msg); } } void ScriptEditorDebugger::live_debug_remove_node(const NodePath &p_at) { if (live_debug) { Array msg; msg.push_back(p_at); _put_msg("scene:live_remove_node", msg); } } void ScriptEditorDebugger::live_debug_remove_and_keep_node(const NodePath &p_at, ObjectID p_keep_id) { if (live_debug) { Array msg; msg.push_back(p_at); msg.push_back(p_keep_id); _put_msg("scene:live_remove_and_keep_node", msg); } } void ScriptEditorDebugger::live_debug_restore_node(ObjectID p_id, const NodePath &p_at, int p_at_pos) { if (live_debug) { Array msg; msg.push_back(p_id); msg.push_back(p_at); msg.push_back(p_at_pos); _put_msg("scene:live_restore_node", msg); } } void ScriptEditorDebugger::live_debug_duplicate_node(const NodePath &p_at, const String &p_new_name) { if (live_debug) { Array msg; msg.push_back(p_at); msg.push_back(p_new_name); _put_msg("scene:live_duplicate_node", msg); } } void ScriptEditorDebugger::live_debug_reparent_node(const NodePath &p_at, const NodePath &p_new_place, const String &p_new_name, int p_at_pos) { if (live_debug) { Array msg; msg.push_back(p_at); msg.push_back(p_new_place); msg.push_back(p_new_name); msg.push_back(p_at_pos); _put_msg("scene:live_reparent_node", msg); } } CameraOverride ScriptEditorDebugger::get_camera_override() const { return camera_override; } void ScriptEditorDebugger::set_camera_override(CameraOverride p_override) { if (p_override == CameraOverride::OVERRIDE_2D && camera_override != CameraOverride::OVERRIDE_2D) { Array msg; msg.push_back(true); _put_msg("scene:override_camera_2D:set", msg); } else if (p_override != CameraOverride::OVERRIDE_2D && camera_override == CameraOverride::OVERRIDE_2D) { Array msg; msg.push_back(false); _put_msg("scene:override_camera_2D:set", msg); } else if (p_override >= CameraOverride::OVERRIDE_3D_1 && camera_override < CameraOverride::OVERRIDE_3D_1) { Array msg; msg.push_back(true); _put_msg("scene:override_camera_3D:set", msg); } else if (p_override < CameraOverride::OVERRIDE_3D_1 && camera_override >= CameraOverride::OVERRIDE_3D_1) { Array msg; msg.push_back(false); _put_msg("scene:override_camera_3D:set", msg); } camera_override = p_override; } void ScriptEditorDebugger::set_breakpoint(const String &p_path, int p_line, bool p_enabled) { Array msg; msg.push_back(p_path); msg.push_back(p_line); msg.push_back(p_enabled); _put_msg("breakpoint", msg); } void ScriptEditorDebugger::reload_scripts() { _put_msg("reload_scripts", Array()); } bool ScriptEditorDebugger::is_skip_breakpoints() { return skip_breakpoints_value; } void ScriptEditorDebugger::_error_activated() { TreeItem *selected = error_tree->get_selected(); TreeItem *ci = selected->get_children(); if (ci) { selected->set_collapsed(!selected->is_collapsed()); } } void ScriptEditorDebugger::_error_selected() { TreeItem *selected = error_tree->get_selected(); Array meta = selected->get_metadata(0); if (meta.size() == 0) { return; } emit_signal("error_selected", String(meta[0]), int(meta[1])); } void ScriptEditorDebugger::_expand_errors_list() { TreeItem *root = error_tree->get_root(); if (!root) { return; } TreeItem *item = root->get_children(); while (item) { item->set_collapsed(false); item = item->get_next(); } } void ScriptEditorDebugger::_collapse_errors_list() { TreeItem *root = error_tree->get_root(); if (!root) { return; } TreeItem *item = root->get_children(); while (item) { item->set_collapsed(true); item = item->get_next(); } } void ScriptEditorDebugger::_clear_errors_list() { error_tree->clear(); error_count = 0; warning_count = 0; } // Right click on specific file(s) or folder(s). void ScriptEditorDebugger::_error_tree_item_rmb_selected(const Vector2 &p_pos) { item_menu->clear(); item_menu->set_size(Size2(1, 1)); if (error_tree->is_anything_selected()) { item_menu->add_icon_item(get_theme_icon("ActionCopy", "EditorIcons"), TTR("Copy Error"), 0); } if (item_menu->get_item_count() > 0) { item_menu->set_position(error_tree->get_global_position() + p_pos); item_menu->popup(); } } void ScriptEditorDebugger::_item_menu_id_pressed(int p_option) { TreeItem *ti = error_tree->get_selected(); while (ti->get_parent() != error_tree->get_root()) { ti = ti->get_parent(); } String type; if (ti->get_icon(0) == get_theme_icon("Warning", "EditorIcons")) { type = "W "; } else if (ti->get_icon(0) == get_theme_icon("Error", "EditorIcons")) { type = "E "; } String text = ti->get_text(0) + " "; int rpad_len = text.length(); text = type + text + ti->get_text(1) + "\n"; TreeItem *ci = ti->get_children(); while (ci) { text += " " + ci->get_text(0).rpad(rpad_len) + ci->get_text(1) + "\n"; ci = ci->get_next(); } DisplayServer::get_singleton()->clipboard_set(text); } void ScriptEditorDebugger::_tab_changed(int p_tab) { if (tabs->get_tab_title(p_tab) == TTR("Video RAM")) { // "Video RAM" tab was clicked, refresh the data it's displaying when entering the tab. _video_mem_request(); } } void ScriptEditorDebugger::_bind_methods() { ClassDB::bind_method(D_METHOD("live_debug_create_node"), &ScriptEditorDebugger::live_debug_create_node); ClassDB::bind_method(D_METHOD("live_debug_instance_node"), &ScriptEditorDebugger::live_debug_instance_node); ClassDB::bind_method(D_METHOD("live_debug_remove_node"), &ScriptEditorDebugger::live_debug_remove_node); ClassDB::bind_method(D_METHOD("live_debug_remove_and_keep_node"), &ScriptEditorDebugger::live_debug_remove_and_keep_node); ClassDB::bind_method(D_METHOD("live_debug_restore_node"), &ScriptEditorDebugger::live_debug_restore_node); ClassDB::bind_method(D_METHOD("live_debug_duplicate_node"), &ScriptEditorDebugger::live_debug_duplicate_node); ClassDB::bind_method(D_METHOD("live_debug_reparent_node"), &ScriptEditorDebugger::live_debug_reparent_node); ClassDB::bind_method(D_METHOD("request_remote_object", "id"), &ScriptEditorDebugger::request_remote_object); ClassDB::bind_method(D_METHOD("update_remote_object", "id", "property", "value"), &ScriptEditorDebugger::update_remote_object); ADD_SIGNAL(MethodInfo("started")); ADD_SIGNAL(MethodInfo("stopped")); ADD_SIGNAL(MethodInfo("stop_requested")); ADD_SIGNAL(MethodInfo("stack_frame_selected", PropertyInfo(Variant::INT, "frame"))); ADD_SIGNAL(MethodInfo("error_selected", PropertyInfo(Variant::INT, "error"))); ADD_SIGNAL(MethodInfo("set_execution", PropertyInfo("script"), PropertyInfo(Variant::INT, "line"))); ADD_SIGNAL(MethodInfo("clear_execution", PropertyInfo("script"))); ADD_SIGNAL(MethodInfo("breaked", PropertyInfo(Variant::BOOL, "reallydid"), PropertyInfo(Variant::BOOL, "can_debug"))); ADD_SIGNAL(MethodInfo("remote_object_requested", PropertyInfo(Variant::INT, "id"))); ADD_SIGNAL(MethodInfo("remote_object_updated", PropertyInfo(Variant::INT, "id"))); ADD_SIGNAL(MethodInfo("remote_object_property_updated", PropertyInfo(Variant::INT, "id"), PropertyInfo(Variant::STRING, "property"))); ADD_SIGNAL(MethodInfo("remote_tree_updated")); } void ScriptEditorDebugger::add_debugger_plugin(const Ref<Script> &p_script) { if (!debugger_plugins.has(p_script)) { EditorDebuggerPlugin *plugin = memnew(EditorDebuggerPlugin()); plugin->attach_debugger(this); plugin->set_script(p_script); tabs->add_child(plugin); debugger_plugins.insert(p_script, plugin); } } void ScriptEditorDebugger::remove_debugger_plugin(const Ref<Script> &p_script) { if (debugger_plugins.has(p_script)) { tabs->remove_child(debugger_plugins[p_script]); debugger_plugins[p_script]->detach_debugger(false); memdelete(debugger_plugins[p_script]); debugger_plugins.erase(p_script); } } void ScriptEditorDebugger::send_message(const String &p_message, const Array &p_args) { _put_msg(p_message, p_args); } void ScriptEditorDebugger::register_message_capture(const StringName &p_name, const Callable &p_callable) { ERR_FAIL_COND_MSG(has_capture(p_name), "Capture already registered: " + p_name); captures.insert(p_name, p_callable); } void ScriptEditorDebugger::unregister_message_capture(const StringName &p_name) { ERR_FAIL_COND_MSG(!has_capture(p_name), "Capture not registered: " + p_name); captures.erase(p_name); } bool ScriptEditorDebugger::has_capture(const StringName &p_name) { return captures.has(p_name); } ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) { editor = p_editor; tabs = memnew(TabContainer); tabs->set_tab_align(TabContainer::ALIGN_LEFT); tabs->add_theme_style_override("panel", editor->get_gui_base()->get_theme_stylebox("DebuggerPanel", "EditorStyles")); tabs->connect("tab_changed", callable_mp(this, &ScriptEditorDebugger::_tab_changed)); add_child(tabs); { //debugger VBoxContainer *vbc = memnew(VBoxContainer); vbc->set_name(TTR("Debugger")); Control *dbg = vbc; HBoxContainer *hbc = memnew(HBoxContainer); vbc->add_child(hbc); reason = memnew(Label); reason->set_text(""); hbc->add_child(reason); reason->set_h_size_flags(SIZE_EXPAND_FILL); reason->set_autowrap(true); reason->set_max_lines_visible(3); reason->set_mouse_filter(Control::MOUSE_FILTER_PASS); hbc->add_child(memnew(VSeparator)); skip_breakpoints = memnew(Button); skip_breakpoints->set_flat(true); hbc->add_child(skip_breakpoints); skip_breakpoints->set_tooltip(TTR("Skip Breakpoints")); skip_breakpoints->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_skip_breakpoints)); hbc->add_child(memnew(VSeparator)); copy = memnew(Button); copy->set_flat(true); hbc->add_child(copy); copy->set_tooltip(TTR("Copy Error")); copy->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_copy)); hbc->add_child(memnew(VSeparator)); step = memnew(Button); step->set_flat(true); hbc->add_child(step); step->set_tooltip(TTR("Step Into")); step->set_shortcut(ED_GET_SHORTCUT("debugger/step_into")); step->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_step)); next = memnew(Button); next->set_flat(true); hbc->add_child(next); next->set_tooltip(TTR("Step Over")); next->set_shortcut(ED_GET_SHORTCUT("debugger/step_over")); next->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_next)); hbc->add_child(memnew(VSeparator)); dobreak = memnew(Button); dobreak->set_flat(true); hbc->add_child(dobreak); dobreak->set_tooltip(TTR("Break")); dobreak->set_shortcut(ED_GET_SHORTCUT("debugger/break")); dobreak->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_break)); docontinue = memnew(Button); docontinue->set_flat(true); hbc->add_child(docontinue); docontinue->set_tooltip(TTR("Continue")); docontinue->set_shortcut(ED_GET_SHORTCUT("debugger/continue")); docontinue->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_continue)); HSplitContainer *sc = memnew(HSplitContainer); vbc->add_child(sc); sc->set_v_size_flags(SIZE_EXPAND_FILL); stack_dump = memnew(Tree); stack_dump->set_allow_reselect(true); stack_dump->set_columns(1); stack_dump->set_column_titles_visible(true); stack_dump->set_column_title(0, TTR("Stack Frames")); stack_dump->set_h_size_flags(SIZE_EXPAND_FILL); stack_dump->set_hide_root(true); stack_dump->connect("cell_selected", callable_mp(this, &ScriptEditorDebugger::_stack_dump_frame_selected)); sc->add_child(stack_dump); inspector = memnew(EditorDebuggerInspector); inspector->set_h_size_flags(SIZE_EXPAND_FILL); inspector->set_enable_capitalize_paths(false); inspector->set_read_only(true); inspector->connect("object_selected", callable_mp(this, &ScriptEditorDebugger::_remote_object_selected)); inspector->connect("object_edited", callable_mp(this, &ScriptEditorDebugger::_remote_object_edited)); inspector->connect("object_property_updated", callable_mp(this, &ScriptEditorDebugger::_remote_object_property_updated)); sc->add_child(inspector); tabs->add_child(dbg); } { //errors errors_tab = memnew(VBoxContainer); errors_tab->set_name(TTR("Errors")); HBoxContainer *errhb = memnew(HBoxContainer); errors_tab->add_child(errhb); Button *expand_all = memnew(Button); expand_all->set_text(TTR("Expand All")); expand_all->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_expand_errors_list)); errhb->add_child(expand_all); Button *collapse_all = memnew(Button); collapse_all->set_text(TTR("Collapse All")); collapse_all->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_collapse_errors_list)); errhb->add_child(collapse_all); Control *space = memnew(Control); space->set_h_size_flags(SIZE_EXPAND_FILL); errhb->add_child(space); clearbutton = memnew(Button); clearbutton->set_text(TTR("Clear")); clearbutton->set_h_size_flags(0); clearbutton->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_clear_errors_list)); errhb->add_child(clearbutton); error_tree = memnew(Tree); error_tree->set_columns(2); error_tree->set_column_expand(0, false); error_tree->set_column_min_width(0, 140); error_tree->set_column_expand(1, true); error_tree->set_select_mode(Tree::SELECT_ROW); error_tree->set_hide_root(true); error_tree->set_v_size_flags(SIZE_EXPAND_FILL); error_tree->set_allow_rmb_select(true); error_tree->connect("item_rmb_selected", callable_mp(this, &ScriptEditorDebugger::_error_tree_item_rmb_selected)); errors_tab->add_child(error_tree); item_menu = memnew(PopupMenu); item_menu->connect("id_pressed", callable_mp(this, &ScriptEditorDebugger::_item_menu_id_pressed)); error_tree->add_child(item_menu); tabs->add_child(errors_tab); } { // File dialog file_dialog = memnew(EditorFileDialog); file_dialog->connect("file_selected", callable_mp(this, &ScriptEditorDebugger::_file_selected)); add_child(file_dialog); } { //profiler profiler = memnew(EditorProfiler); profiler->set_name(TTR("Profiler")); tabs->add_child(profiler); profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate), varray(PROFILER_SCRIPTS_SERVERS)); profiler->connect("break_request", callable_mp(this, &ScriptEditorDebugger::_profiler_seeked)); } { //frame profiler visual_profiler = memnew(EditorVisualProfiler); visual_profiler->set_name(TTR("Visual Profiler")); tabs->add_child(visual_profiler); visual_profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate), varray(PROFILER_VISUAL)); } { //network profiler network_profiler = memnew(EditorNetworkProfiler); network_profiler->set_name(TTR("Network Profiler")); tabs->add_child(network_profiler); network_profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate), varray(PROFILER_NETWORK)); } { //monitors performance_profiler = memnew(EditorPerformanceProfiler); tabs->add_child(performance_profiler); } { //vmem inspect VBoxContainer *vmem_vb = memnew(VBoxContainer); HBoxContainer *vmem_hb = memnew(HBoxContainer); Label *vmlb = memnew(Label(TTR("List of Video Memory Usage by Resource:") + " ")); vmlb->set_h_size_flags(SIZE_EXPAND_FILL); vmem_hb->add_child(vmlb); vmem_hb->add_child(memnew(Label(TTR("Total:") + " "))); vmem_total = memnew(LineEdit); vmem_total->set_editable(false); vmem_total->set_custom_minimum_size(Size2(100, 0) * EDSCALE); vmem_hb->add_child(vmem_total); vmem_refresh = memnew(Button); vmem_refresh->set_flat(true); vmem_hb->add_child(vmem_refresh); vmem_export = memnew(Button); vmem_export->set_flat(true); vmem_export->set_tooltip(TTR("Export list to a CSV file")); vmem_hb->add_child(vmem_export); vmem_vb->add_child(vmem_hb); vmem_refresh->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_video_mem_request)); vmem_export->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_video_mem_export)); VBoxContainer *vmmc = memnew(VBoxContainer); vmem_tree = memnew(Tree); vmem_tree->set_v_size_flags(SIZE_EXPAND_FILL); vmem_tree->set_h_size_flags(SIZE_EXPAND_FILL); vmmc->add_child(vmem_tree); vmmc->set_v_size_flags(SIZE_EXPAND_FILL); vmem_vb->add_child(vmmc); vmem_vb->set_name(TTR("Video RAM")); vmem_tree->set_columns(4); vmem_tree->set_column_titles_visible(true); vmem_tree->set_column_title(0, TTR("Resource Path")); vmem_tree->set_column_expand(0, true); vmem_tree->set_column_expand(1, false); vmem_tree->set_column_title(1, TTR("Type")); vmem_tree->set_column_min_width(1, 100 * EDSCALE); vmem_tree->set_column_expand(2, false); vmem_tree->set_column_title(2, TTR("Format")); vmem_tree->set_column_min_width(2, 150 * EDSCALE); vmem_tree->set_column_expand(3, false); vmem_tree->set_column_title(3, TTR("Usage")); vmem_tree->set_column_min_width(3, 80 * EDSCALE); vmem_tree->set_hide_root(true); tabs->add_child(vmem_vb); } { // misc VBoxContainer *misc = memnew(VBoxContainer); misc->set_name(TTR("Misc")); tabs->add_child(misc); GridContainer *info_left = memnew(GridContainer); info_left->set_columns(2); misc->add_child(info_left); clicked_ctrl = memnew(LineEdit); clicked_ctrl->set_h_size_flags(SIZE_EXPAND_FILL); info_left->add_child(memnew(Label(TTR("Clicked Control:")))); info_left->add_child(clicked_ctrl); clicked_ctrl_type = memnew(LineEdit); info_left->add_child(memnew(Label(TTR("Clicked Control Type:")))); info_left->add_child(clicked_ctrl_type); scene_tree = memnew(SceneDebuggerTree); live_edit_root = memnew(LineEdit); live_edit_root->set_h_size_flags(SIZE_EXPAND_FILL); { HBoxContainer *lehb = memnew(HBoxContainer); Label *l = memnew(Label(TTR("Live Edit Root:"))); info_left->add_child(l); lehb->add_child(live_edit_root); le_set = memnew(Button(TTR("Set From Tree"))); lehb->add_child(le_set); le_clear = memnew(Button(TTR("Clear"))); lehb->add_child(le_clear); info_left->add_child(lehb); } misc->add_child(memnew(VSeparator)); HBoxContainer *buttons = memnew(HBoxContainer); export_csv = memnew(Button(TTR("Export measures as CSV"))); export_csv->connect("pressed", callable_mp(this, &ScriptEditorDebugger::_export_csv)); buttons->add_child(export_csv); misc->add_child(buttons); } msgdialog = memnew(AcceptDialog); add_child(msgdialog); live_debug = true; camera_override = CameraOverride::OVERRIDE_NONE; last_path_id = false; error_count = 0; warning_count = 0; _update_buttons_state(); } ScriptEditorDebugger::~ScriptEditorDebugger() { if (peer.is_valid()) { peer->close(); peer.unref(); } memdelete(scene_tree); }