/*************************************************************************/ /* script_editor_debugger.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2019 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/io/marshalls.h" #include "core/project_settings.h" #include "core/ustring.h" #include "editor_node.h" #include "editor_profiler.h" #include "editor_settings.h" #include "main/performance.h" #include "property_editor.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" class ScriptEditorDebuggerVariables : public Object { GDCLASS(ScriptEditorDebuggerVariables, Object); List<PropertyInfo> props; Map<StringName, Variant> values; protected: bool _set(const StringName &p_name, const Variant &p_value) { return false; } bool _get(const StringName &p_name, Variant &r_ret) const { if (!values.has(p_name)) return false; r_ret = values[p_name]; return true; } void _get_property_list(List<PropertyInfo> *p_list) const { for (const List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) p_list->push_back(E->get()); } public: void clear() { props.clear(); values.clear(); } String get_var_value(const String &p_var) const { for (Map<StringName, Variant>::Element *E = values.front(); E; E = E->next()) { String v = E->key().operator String().get_slice("/", 1); if (v == p_var) return E->get(); } return ""; } void add_property(const String &p_name, const Variant &p_value, const PropertyHint &p_hint, const String p_hint_string) { PropertyInfo pinfo; pinfo.name = p_name; pinfo.type = p_value.get_type(); pinfo.hint = p_hint; pinfo.hint_string = p_hint_string; props.push_back(pinfo); values[p_name] = p_value; } void update() { _change_notify(); } ScriptEditorDebuggerVariables() { } }; class ScriptEditorDebuggerInspectedObject : public Object { GDCLASS(ScriptEditorDebuggerInspectedObject, Object); protected: bool _set(const StringName &p_name, const Variant &p_value) { if (!prop_values.has(p_name) || String(p_name).begins_with("Constants/")) return false; prop_values[p_name] = p_value; emit_signal("value_edited", p_name, p_value); return true; } bool _get(const StringName &p_name, Variant &r_ret) const { if (!prop_values.has(p_name)) return false; r_ret = prop_values[p_name]; return true; } void _get_property_list(List<PropertyInfo> *p_list) const { p_list->clear(); //sorry, no want category for (const List<PropertyInfo>::Element *E = prop_list.front(); E; E = E->next()) { p_list->push_back(E->get()); } } static void _bind_methods() { ClassDB::bind_method(D_METHOD("get_title"), &ScriptEditorDebuggerInspectedObject::get_title); ClassDB::bind_method(D_METHOD("get_variant"), &ScriptEditorDebuggerInspectedObject::get_variant); ClassDB::bind_method(D_METHOD("clear"), &ScriptEditorDebuggerInspectedObject::clear); ClassDB::bind_method(D_METHOD("get_remote_object_id"), &ScriptEditorDebuggerInspectedObject::get_remote_object_id); ADD_SIGNAL(MethodInfo("value_edited")); } public: String type_name; ObjectID remote_object_id; List<PropertyInfo> prop_list; Map<StringName, Variant> prop_values; ObjectID get_remote_object_id() { return remote_object_id; } String get_title() { if (remote_object_id) return TTR("Remote ") + String(type_name) + ": " + itos(remote_object_id); else return "<null>"; } Variant get_variant(const StringName &p_name) { Variant var; _get(p_name, var); return var; } void clear() { prop_list.clear(); prop_values.clear(); } void update() { _change_notify(); } void update_single(const char *p_prop) { _change_notify(p_prop); } ScriptEditorDebuggerInspectedObject() { remote_object_id = 0; } }; void ScriptEditorDebugger::debug_copy() { String msg = reason->get_text(); if (msg == "") return; OS::get_singleton()->set_clipboard(msg); } void ScriptEditorDebugger::debug_next() { ERR_FAIL_COND(!breaked); ERR_FAIL_COND(connection.is_null()); ERR_FAIL_COND(!connection->is_connected_to_host()); Array msg; msg.push_back("next"); ppeer->put_var(msg); _clear_execution(); stack_dump->clear(); } void ScriptEditorDebugger::debug_step() { ERR_FAIL_COND(!breaked); ERR_FAIL_COND(connection.is_null()); ERR_FAIL_COND(!connection->is_connected_to_host()); Array msg; msg.push_back("step"); ppeer->put_var(msg); _clear_execution(); stack_dump->clear(); } void ScriptEditorDebugger::debug_break() { ERR_FAIL_COND(breaked); ERR_FAIL_COND(connection.is_null()); ERR_FAIL_COND(!connection->is_connected_to_host()); Array msg; msg.push_back("break"); ppeer->put_var(msg); } void ScriptEditorDebugger::debug_continue() { ERR_FAIL_COND(!breaked); ERR_FAIL_COND(connection.is_null()); ERR_FAIL_COND(!connection->is_connected_to_host()); OS::get_singleton()->enable_for_stealing_focus(EditorNode::get_singleton()->get_child_process_id()); Array msg; _clear_execution(); msg.push_back("continue"); ppeer->put_var(msg); } void ScriptEditorDebugger::_scene_tree_folded(Object *obj) { if (updating_scene_tree) { return; } TreeItem *item = Object::cast_to<TreeItem>(obj); if (!item) return; ObjectID id = item->get_metadata(0); if (item->is_collapsed()) { unfold_cache.erase(id); } else { unfold_cache.insert(id); } } void ScriptEditorDebugger::_scene_tree_selected() { if (updating_scene_tree) { return; } TreeItem *item = inspect_scene_tree->get_selected(); if (!item) { return; } inspected_object_id = item->get_metadata(0); Array msg; msg.push_back("inspect_object"); msg.push_back(inspected_object_id); ppeer->put_var(msg); } void ScriptEditorDebugger::_scene_tree_rmb_selected(const Vector2 &p_position) { TreeItem *item = inspect_scene_tree->get_item_at_position(p_position); if (!item) return; item->select(0); item_menu->clear(); item_menu->add_icon_item(get_icon("CreateNewSceneFrom", "EditorIcons"), TTR("Save Branch as Scene"), ITEM_MENU_SAVE_REMOTE_NODE); item_menu->set_global_position(get_global_mouse_position()); item_menu->popup(); } void ScriptEditorDebugger::_file_selected(const String &p_file) { if (file_dialog_mode == SAVE_NODE) { Array msg; msg.push_back("save_node"); msg.push_back(inspected_object_id); msg.push_back(p_file); ppeer->put_var(msg); } else if (file_dialog_mode == SAVE_CSV) { Error err; FileAccessRef file = FileAccess::open(p_file, FileAccess::WRITE, &err); if (err != OK) { ERR_PRINTS("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 List<Vector<float> >::Element *E = perf_history.back(); while (E) { Vector<float> &perf_data = E->get(); for (int i = 0; i < perf_data.size(); i++) { line.write[i] = String::num_real(perf_data[i]); } file->store_csv_line(line); E = E->prev(); } 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]); } } } void ScriptEditorDebugger::_scene_tree_property_value_edited(const String &p_prop, const Variant &p_value) { Array msg; msg.push_back("set_object_property"); msg.push_back(inspected_object_id); msg.push_back(p_prop); msg.push_back(p_value); ppeer->put_var(msg); inspect_edited_object_timeout = 0.7; //avoid annoyance, don't request soon after editing } void ScriptEditorDebugger::_scene_tree_property_select_object(ObjectID p_object) { inspected_object_id = p_object; Array msg; msg.push_back("inspect_object"); msg.push_back(inspected_object_id); ppeer->put_var(msg); } void ScriptEditorDebugger::_scene_tree_request() { ERR_FAIL_COND(connection.is_null()); ERR_FAIL_COND(!connection->is_connected_to_host()); Array msg; msg.push_back("request_scene_tree"); ppeer->put_var(msg); } void ScriptEditorDebugger::_video_mem_request() { ERR_FAIL_COND(connection.is_null()); ERR_FAIL_COND(!connection->is_connected_to_host()); Array msg; msg.push_back("request_video_mem"); ppeer->put_var(msg); } Size2 ScriptEditorDebugger::get_minimum_size() const { Size2 ms = Control::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") { Array msg; msg.push_back("get_stack_dump"); ppeer->put_var(msg); ERR_FAIL_COND(p_data.size() != 2); bool can_continue = p_data[0]; String error = p_data[1]; step->set_disabled(!can_continue); next->set_disabled(!can_continue); _set_reason_text(error, MESSAGE_ERROR); copy->set_disabled(false); breaked = true; dobreak->set_disabled(true); docontinue->set_disabled(false); emit_signal("breaked", true, can_continue); OS::get_singleton()->move_window_to_foreground(); if (error != "") { tabs->set_current_tab(0); } profiler->set_enabled(false); EditorNode::get_singleton()->get_pause_button()->set_pressed(true); EditorNode::get_singleton()->make_bottom_panel_item_visible(this); _clear_remote_objects(); } else if (p_msg == "debug_exit") { breaked = false; _clear_execution(); copy->set_disabled(true); step->set_disabled(true); next->set_disabled(true); reason->set_text(""); reason->set_tooltip(""); back->set_disabled(true); forward->set_disabled(true); dobreak->set_disabled(false); docontinue->set_disabled(true); emit_signal("breaked", false, false, Variant()); profiler->set_enabled(true); profiler->disable_seeking(); EditorNode::get_singleton()->get_pause_button()->set_pressed(false); } else if (p_msg == "message:click_ctrl") { clicked_ctrl->set_text(p_data[0]); clicked_ctrl_type->set_text(p_data[1]); } else if (p_msg == "message:scene_tree") { inspect_scene_tree->clear(); Map<int, TreeItem *> lv; updating_scene_tree = true; for (int i = 0; i < p_data.size(); i += 4) { TreeItem *p; int level = p_data[i]; if (level == 0) { p = NULL; } else { ERR_CONTINUE(!lv.has(level - 1)); p = lv[level - 1]; } TreeItem *it = inspect_scene_tree->create_item(p); ObjectID id = ObjectID(p_data[i + 3]); it->set_text(0, p_data[i + 1]); Ref<Texture> icon = EditorNode::get_singleton()->get_class_icon(p_data[i + 2], ""); if (icon.is_valid()) it->set_icon(0, icon); it->set_metadata(0, id); if (id == inspected_object_id) { TreeItem *cti = it->get_parent(); //ensure selected is always uncollapsed while (cti) { cti->set_collapsed(false); cti = cti->get_parent(); } it->select(0); } if (p) { if (!unfold_cache.has(id)) { it->set_collapsed(true); } } else { if (unfold_cache.has(id)) { //reverse for root it->set_collapsed(true); } } lv[level] = it; } updating_scene_tree = false; le_clear->set_disabled(false); le_set->set_disabled(false); } else if (p_msg == "message:inspect_object") { ScriptEditorDebuggerInspectedObject *debugObj = NULL; ObjectID id = p_data[0]; String type = p_data[1]; Array properties = p_data[2]; if (remote_objects.has(id)) { debugObj = remote_objects[id]; } else { debugObj = memnew(ScriptEditorDebuggerInspectedObject); debugObj->remote_object_id = id; debugObj->type_name = type; remote_objects[id] = debugObj; debugObj->connect("value_edited", this, "_scene_tree_property_value_edited"); } int old_prop_size = debugObj->prop_list.size(); debugObj->prop_list.clear(); int new_props_added = 0; Set<String> changed; for (int i = 0; i < properties.size(); i++) { Array prop = properties[i]; if (prop.size() != 6) continue; PropertyInfo pinfo; pinfo.name = prop[0]; pinfo.type = Variant::Type(int(prop[1])); pinfo.hint = PropertyHint(int(prop[2])); pinfo.hint_string = prop[3]; pinfo.usage = PropertyUsageFlags(int(prop[4])); Variant var = prop[5]; if (pinfo.type == Variant::OBJECT) { if (var.is_zero()) { var = RES(); } else if (var.get_type() == Variant::STRING) { var = ResourceLoader::load(var); if (pinfo.hint_string == "Script") debugObj->set_script(var); } else if (var.get_type() == Variant::OBJECT) { if (((Object *)var)->is_class("EncodedObjectAsID")) { var = Object::cast_to<EncodedObjectAsID>(var)->get_object_id(); pinfo.type = var.get_type(); pinfo.hint = PROPERTY_HINT_OBJECT_ID; pinfo.hint_string = "Object"; } } } //always add the property, since props may have been added or removed debugObj->prop_list.push_back(pinfo); if (!debugObj->prop_values.has(pinfo.name)) { new_props_added++; debugObj->prop_values[pinfo.name] = var; } else { if (bool(Variant::evaluate(Variant::OP_NOT_EQUAL, debugObj->prop_values[pinfo.name], var))) { debugObj->prop_values[pinfo.name] = var; changed.insert(pinfo.name); } } } if (editor->get_editor_history()->get_current() != debugObj->get_instance_id()) { editor->push_item(debugObj, ""); } else { if (old_prop_size == debugObj->prop_list.size() && new_props_added == 0) { //only some may have changed, if so, then update those, if exist for (Set<String>::Element *E = changed.front(); E; E = E->next()) { EditorNode::get_singleton()->get_inspector()->update_property(E->get()); } } else { //full update, because props were added or removed debugObj->update(); } } } else if (p_msg == "message:video_mem") { vmem_tree->clear(); TreeItem *root = vmem_tree->create_item(); int total = 0; for (int i = 0; i < p_data.size(); i += 4) { TreeItem *it = vmem_tree->create_item(root); String type = p_data[i + 1]; int bytes = p_data[i + 3].operator int(); it->set_text(0, p_data[i + 0]); //path it->set_text(1, type); //type it->set_text(2, p_data[i + 2]); //type it->set_text(3, String::humanize_size(bytes)); //type total += bytes; if (has_icon(type, "EditorIcons")) it->set_icon(0, get_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") { stack_dump->clear(); TreeItem *r = stack_dump->create_item(); for (int i = 0; i < p_data.size(); i++) { Dictionary d = p_data[i]; ERR_CONTINUE(!d.has("function")); ERR_CONTINUE(!d.has("file")); ERR_CONTINUE(!d.has("line")); ERR_CONTINUE(!d.has("id")); TreeItem *s = stack_dump->create_item(r); d["frame"] = i; s->set_metadata(0, d); //String line = itos(i)+" - "+String(d["file"])+":"+itos(d["line"])+" - at func: "+d["function"]; String line = itos(i) + " - " + String(d["file"]) + ":" + itos(d["line"]); s->set_text(0, line); if (i == 0) s->select(0); } } else if (p_msg == "stack_frame_vars") { variables->clear(); int ofs = 0; int mcount = p_data[ofs]; ofs++; for (int i = 0; i < mcount; i++) { String n = p_data[ofs + i * 2 + 0]; Variant v = p_data[ofs + i * 2 + 1]; PropertyHint h = PROPERTY_HINT_NONE; String hs = String(); if (v.get_type() == Variant::OBJECT) { v = Object::cast_to<EncodedObjectAsID>(v)->get_object_id(); h = PROPERTY_HINT_OBJECT_ID; hs = "Object"; } variables->add_property("Locals/" + n, v, h, hs); } ofs += mcount * 2; mcount = p_data[ofs]; ofs++; for (int i = 0; i < mcount; i++) { String n = p_data[ofs + i * 2 + 0]; Variant v = p_data[ofs + i * 2 + 1]; PropertyHint h = PROPERTY_HINT_NONE; String hs = String(); if (v.get_type() == Variant::OBJECT) { v = Object::cast_to<EncodedObjectAsID>(v)->get_object_id(); h = PROPERTY_HINT_OBJECT_ID; hs = "Object"; } variables->add_property("Members/" + n, v, h, hs); } ofs += mcount * 2; mcount = p_data[ofs]; ofs++; for (int i = 0; i < mcount; i++) { String n = p_data[ofs + i * 2 + 0]; Variant v = p_data[ofs + i * 2 + 1]; PropertyHint h = PROPERTY_HINT_NONE; String hs = String(); if (v.get_type() == Variant::OBJECT) { v = Object::cast_to<EncodedObjectAsID>(v)->get_object_id(); h = PROPERTY_HINT_OBJECT_ID; hs = "Object"; } variables->add_property("Globals/" + n, v, h, hs); } variables->update(); inspector->edit(variables); } else if (p_msg == "output") { //OUT for (int i = 0; i < p_data.size(); i++) { String t = p_data[i]; //LOG if (!EditorNode::get_log()->is_visible()) { if (EditorNode::get_singleton()->are_bottom_panels_hidden()) { if (EDITOR_GET("run/output/always_open_output_on_play")) { EditorNode::get_singleton()->make_bottom_panel_item_visible(EditorNode::get_log()); } } } EditorNode::get_log()->add_message(t); } } else if (p_msg == "performance") { Array arr = p_data[0]; Vector<float> p; p.resize(arr.size()); for (int i = 0; i < arr.size(); i++) { p.write[i] = arr[i]; if (i < perf_items.size()) { float v = p[i]; String vs = rtos(v); String tt = vs; switch (Performance::MonitorType((int)perf_items[i]->get_metadata(1))) { case Performance::MONITOR_TYPE_MEMORY: { // for the time being, going above GBs is a bad sign. String unit = "B"; if ((int)v > 1073741824) { unit = "GB"; v /= 1073741824.0; } else if ((int)v > 1048576) { unit = "MB"; v /= 1048576.0; } else if ((int)v > 1024) { unit = "KB"; v /= 1024.0; } tt += " bytes"; vs = String::num(v, 2) + " " + unit; } break; case Performance::MONITOR_TYPE_TIME: { tt += " seconds"; vs += " s"; } break; default: { tt += " " + perf_items[i]->get_text(0); } break; } perf_items[i]->set_text(1, vs); perf_items[i]->set_tooltip(1, tt); if (p[i] > perf_max[i]) perf_max.write[i] = p[i]; } } perf_history.push_front(p); perf_draw->update(); } else if (p_msg == "error") { Array err = p_data[0]; Array vals; vals.push_back(err[0]); vals.push_back(err[1]); vals.push_back(err[2]); vals.push_back(err[3]); bool warning = err[9]; bool e; String time = String("%d:%02d:%02d:%04d").sprintf(vals, &e); String txt = err[8].is_zero() ? String(err[7]) : String(err[8]); TreeItem *r = error_tree->get_root(); if (!r) { r = error_tree->create_item(); } TreeItem *error = error_tree->create_item(r); error->set_collapsed(true); error->set_icon(0, get_icon(warning ? "Warning" : "Error", "EditorIcons")); error->set_text(0, time); error->set_text_align(0, TreeItem::ALIGN_LEFT); error->set_text(1, txt); String source(err[5]); bool source_is_project_file = source.begins_with("res://"); if (source_is_project_file) txt = source.get_file() + ":" + String(err[6]); else txt = source + ":" + String(err[6]); String method = err[4]; if (method.length() > 0) txt += " @ " + method + "()"; TreeItem *c_info = error_tree->create_item(error); c_info->set_text(0, "<" + TTR(source_is_project_file ? "Source" : "C Source") + ">"); c_info->set_text(1, txt); c_info->set_text_align(0, TreeItem::ALIGN_LEFT); if (source_is_project_file) { Array meta; meta.push_back(source); meta.push_back(err[6]); error->set_metadata(0, meta); c_info->set_metadata(0, meta); } int scc = p_data[1]; for (int i = 0; i < scc; i += 3) { String script = p_data[2 + i]; String method2 = p_data[3 + i]; int line = p_data[4 + i]; TreeItem *stack_trace = error_tree->create_item(error); Array meta; meta.push_back(script); meta.push_back(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); } stack_trace->set_text(1, script.get_file() + ":" + itos(line) + " @ " + method2 + "()"); } if (warning) warning_count++; else error_count++; } else if (p_msg == "profile_sig") { //cache a signature profiler_signature[p_data[1]] = p_data[0]; } else if (p_msg == "profile_frame" || p_msg == "profile_total") { EditorProfiler::Metric metric; metric.valid = true; metric.frame_number = p_data[0]; metric.frame_time = p_data[1]; metric.idle_time = p_data[2]; metric.physics_time = p_data[3]; metric.physics_frame_time = p_data[4]; int frame_data_amount = p_data[6]; int frame_function_amount = p_data[7]; if (frame_data_amount) { 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); } int idx = 8; for (int i = 0; i < frame_data_amount; i++) { EditorProfiler::Metric::Category c; String name = p_data[idx++]; Array values = p_data[idx++]; c.name = name.capitalize(); c.items.resize(values.size() / 2); c.total_time = 0; c.signature = "categ::" + name; for (int j = 0; j < values.size(); j += 2) { EditorProfiler::Metric::Category::Item item; item.calls = 1; item.line = 0; item.name = values[j]; item.self = values[j + 1]; item.total = item.self; item.signature = "categ::" + name + "::" + item.name; item.name = item.name.capitalize(); c.total_time += item.total; c.items.write[j / 2] = item; } metric.categories.push_back(c); } EditorProfiler::Metric::Category funcs; funcs.total_time = p_data[5]; //script time funcs.items.resize(frame_function_amount); funcs.name = "Script Functions"; funcs.signature = "script_functions"; for (int i = 0; i < frame_function_amount; i++) { int signature = p_data[idx++]; int calls = p_data[idx++]; float total = p_data[idx++]; float self = p_data[idx++]; 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 == "profile_frame") profiler->add_frame_metric(metric, false); else profiler->add_frame_metric(metric, true); } else if (p_msg == "kill_me") { editor->call_deferred("stop_child_process"); } } void ScriptEditorDebugger::_set_reason_text(const String &p_reason, MessageType p_type) { switch (p_type) { case MESSAGE_ERROR: reason->add_color_override("font_color", get_color("error_color", "Editor")); break; case MESSAGE_WARNING: reason->add_color_override("font_color", get_color("warning_color", "Editor")); break; default: reason->add_color_override("font_color", get_color("success_color", "Editor")); } reason->set_text(p_reason); reason->set_tooltip(p_reason.word_wrap(80)); } void ScriptEditorDebugger::_performance_select() { perf_draw->update(); } void ScriptEditorDebugger::_performance_draw() { Vector<int> which; for (int i = 0; i < perf_items.size(); i++) { if (perf_items[i]->is_checked(0)) which.push_back(i); } Ref<Font> graph_font = get_font("font", "TextEdit"); if (which.empty()) { perf_draw->draw_string(graph_font, Point2(0, graph_font->get_ascent()), TTR("Pick one or more items from the list to display the graph."), get_color("font_color", "Label"), perf_draw->get_size().x); return; } Ref<StyleBox> graph_sb = get_stylebox("normal", "TextEdit"); int cols = Math::ceil(Math::sqrt((float)which.size())); int rows = Math::ceil((float)which.size() / cols); if (which.size() == 1) rows = 1; int margin = 3; int point_sep = 5; Size2i s = Size2i(perf_draw->get_size()) / Size2i(cols, rows); for (int i = 0; i < which.size(); i++) { Point2i p(i % cols, i / cols); Rect2i r(p * s, s); r.position += Point2(margin, margin); r.size -= Point2(margin, margin) * 2.0; perf_draw->draw_style_box(graph_sb, r); r.position += graph_sb->get_offset(); r.size -= graph_sb->get_minimum_size(); int pi = which[i]; Color c = get_color("accent_color", "Editor"); float h = (float)which[i] / (float)(perf_items.size()); c.set_hsv(Math::fmod(h + 0.4, 0.9), c.get_s() * 0.9, c.get_v() * 1.4); c.a = 0.6; perf_draw->draw_string(graph_font, r.position + Point2(0, graph_font->get_ascent()), perf_items[pi]->get_text(0), c, r.size.x); c.a = 0.9; perf_draw->draw_string(graph_font, r.position + Point2(0, graph_font->get_ascent() + graph_font->get_height()), perf_items[pi]->get_text(1), c, r.size.y); float spacing = point_sep / float(cols); float from = r.size.width; List<Vector<float> >::Element *E = perf_history.front(); float prev = -1; while (from >= 0 && E) { float m = perf_max[pi]; if (m == 0) m = 0.00001; float h2 = E->get()[pi] / m; h2 = (1.0 - h2) * r.size.y; c.a = 0.7; if (E != perf_history.front()) perf_draw->draw_line(r.position + Point2(from, h2), r.position + Point2(from + spacing, prev), c, 2.0); prev = h2; E = E->next(); from -= spacing; } } } void ScriptEditorDebugger::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { inspector->edit(variables); copy->set_icon(get_icon("ActionCopy", "EditorIcons")); step->set_icon(get_icon("DebugStep", "EditorIcons")); next->set_icon(get_icon("DebugNext", "EditorIcons")); back->set_icon(get_icon("Back", "EditorIcons")); forward->set_icon(get_icon("Forward", "EditorIcons")); dobreak->set_icon(get_icon("Pause", "EditorIcons")); docontinue->set_icon(get_icon("DebugContinue", "EditorIcons")); //scene_tree_refresh->set_icon( get_icon("Reload","EditorIcons")); le_set->connect("pressed", this, "_live_edit_set"); le_clear->connect("pressed", this, "_live_edit_clear"); error_tree->connect("item_selected", this, "_error_selected"); error_tree->connect("item_activated", this, "_error_activated"); vmem_refresh->set_icon(get_icon("Reload", "EditorIcons")); reason->add_color_override("font_color", get_color("error_color", "Editor")); } break; case NOTIFICATION_PROCESS: { if (connection.is_valid()) { inspect_scene_tree_timeout -= get_process_delta_time(); if (inspect_scene_tree_timeout < 0) { inspect_scene_tree_timeout = EditorSettings::get_singleton()->get("debugger/remote_scene_tree_refresh_interval"); if (inspect_scene_tree->is_visible_in_tree()) { _scene_tree_request(); } } inspect_edited_object_timeout -= get_process_delta_time(); if (inspect_edited_object_timeout < 0) { inspect_edited_object_timeout = EditorSettings::get_singleton()->get("debugger/remote_inspect_refresh_interval"); if (inspected_object_id) { if (ScriptEditorDebuggerInspectedObject *obj = Object::cast_to<ScriptEditorDebuggerInspectedObject>(ObjectDB::get_instance(editor->get_editor_history()->get_current()))) { if (obj->remote_object_id == inspected_object_id) { //take the chance and re-inspect selected object Array msg; msg.push_back("inspect_object"); msg.push_back(inspected_object_id); ppeer->put_var(msg); } } } } } if (error_count != last_error_count || warning_count != last_warning_count) { if (error_count == 0 && warning_count == 0) { errors_tab->set_name(TTR("Errors")); debugger_button->set_text(TTR("Debugger")); debugger_button->set_icon(Ref<Texture>()); tabs->set_tab_icon(errors_tab->get_index(), Ref<Texture>()); } else { errors_tab->set_name(TTR("Errors") + " (" + itos(error_count + warning_count) + ")"); debugger_button->set_text(TTR("Debugger") + " (" + itos(error_count + warning_count) + ")"); if (error_count == 0) { debugger_button->set_icon(get_icon("Warning", "EditorIcons")); tabs->set_tab_icon(errors_tab->get_index(), get_icon("Warning", "EditorIcons")); } else { debugger_button->set_icon(get_icon("Error", "EditorIcons")); tabs->set_tab_icon(errors_tab->get_index(), get_icon("Error", "EditorIcons")); } } last_error_count = error_count; last_warning_count = warning_count; } if (connection.is_null()) { if (server->is_connection_available()) { connection = server->take_connection(); if (connection.is_null()) break; EditorNode::get_log()->add_message("** Debug Process Started **"); ppeer->set_stream_peer(connection); //EditorNode::get_singleton()->make_bottom_panel_item_visible(this); //emit_signal("show_debugger",true); dobreak->set_disabled(false); tabs->set_current_tab(0); _set_reason_text(TTR("Child Process Connected"), MESSAGE_SUCCESS); profiler->clear(); inspect_scene_tree->clear(); le_set->set_disabled(true); le_clear->set_disabled(false); error_tree->clear(); error_count = 0; warning_count = 0; profiler_signature.clear(); //live_edit_root->set_text("/root"); EditorNode::get_singleton()->get_pause_button()->set_pressed(false); EditorNode::get_singleton()->get_pause_button()->set_disabled(false); update_live_edit_root(); if (profiler->is_profiling()) { _profiler_activate(true); } } else { break; } }; if (!connection->is_connected_to_host()) { stop(); editor->notify_child_process_exited(); //somehow, exited break; }; if (ppeer->get_available_packet_count() <= 0) { break; }; const uint64_t until = OS::get_singleton()->get_ticks_msec() + 20; while (ppeer->get_available_packet_count() > 0) { if (pending_in_queue) { int todo = MIN(ppeer->get_available_packet_count(), pending_in_queue); for (int i = 0; i < todo; i++) { Variant cmd; Error ret = ppeer->get_var(cmd); if (ret != OK) { stop(); ERR_FAIL_COND(ret != OK); } message.push_back(cmd); pending_in_queue--; } if (pending_in_queue == 0) { _parse_message(message_type, message); message.clear(); } } else { if (ppeer->get_available_packet_count() >= 2) { Variant cmd; Error ret = ppeer->get_var(cmd); if (ret != OK) { stop(); ERR_FAIL_COND(ret != OK); } if (cmd.get_type() != Variant::STRING) { stop(); ERR_FAIL_COND(cmd.get_type() != Variant::STRING); } message_type = cmd; ret = ppeer->get_var(cmd); if (ret != OK) { stop(); ERR_FAIL_COND(ret != OK); } if (cmd.get_type() != Variant::INT) { stop(); ERR_FAIL_COND(cmd.get_type() != Variant::INT); } pending_in_queue = cmd; if (pending_in_queue == 0) { _parse_message(message_type, Array()); message.clear(); } } else { break; } } if (OS::get_singleton()->get_ticks_msec() > until) break; } } break; case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: { tabs->add_style_override("panel", editor->get_gui_base()->get_stylebox("DebuggerPanel", "EditorStyles")); tabs->add_style_override("tab_fg", editor->get_gui_base()->get_stylebox("DebuggerTabFG", "EditorStyles")); tabs->add_style_override("tab_bg", editor->get_gui_base()->get_stylebox("DebuggerTabBG", "EditorStyles")); tabs->set_margin(MARGIN_LEFT, -EditorNode::get_singleton()->get_gui_base()->get_stylebox("BottomPanelDebuggerOverride", "EditorStyles")->get_margin(MARGIN_LEFT)); tabs->set_margin(MARGIN_RIGHT, EditorNode::get_singleton()->get_gui_base()->get_stylebox("BottomPanelDebuggerOverride", "EditorStyles")->get_margin(MARGIN_RIGHT)); copy->set_icon(get_icon("ActionCopy", "EditorIcons")); step->set_icon(get_icon("DebugStep", "EditorIcons")); next->set_icon(get_icon("DebugNext", "EditorIcons")); back->set_icon(get_icon("Back", "EditorIcons")); forward->set_icon(get_icon("Forward", "EditorIcons")); dobreak->set_icon(get_icon("Pause", "EditorIcons")); docontinue->set_icon(get_icon("DebugContinue", "EditorIcons")); vmem_refresh->set_icon(get_icon("Reload", "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(); } void ScriptEditorDebugger::start() { stop(); if (is_visible_in_tree()) { EditorNode::get_singleton()->make_bottom_panel_item_visible(this); } perf_history.clear(); for (int i = 0; i < Performance::MONITOR_MAX; i++) { perf_max.write[i] = 0; } int remote_port = (int)EditorSettings::get_singleton()->get("network/debug/remote_port"); if (server->listen(remote_port) != OK) { EditorNode::get_log()->add_message(String("Error listening on port ") + itos(remote_port), EditorLog::MSG_TYPE_ERROR); return; } EditorNode::get_singleton()->get_scene_tree_dock()->show_tab_buttons(); auto_switch_remote_scene_tree = (bool)EditorSettings::get_singleton()->get("debugger/auto_switch_to_remote_scene_tree"); if (auto_switch_remote_scene_tree) { EditorNode::get_singleton()->get_scene_tree_dock()->show_remote_tree(); } set_process(true); breaked = false; } void ScriptEditorDebugger::pause() { } void ScriptEditorDebugger::unpause() { } void ScriptEditorDebugger::stop() { set_process(false); breaked = false; _clear_execution(); server->stop(); _clear_remote_objects(); ppeer->set_stream_peer(Ref<StreamPeer>()); if (connection.is_valid()) { EditorNode::get_log()->add_message("** Debug Process Stopped **"); connection.unref(); reason->set_text(""); reason->set_tooltip(""); } pending_in_queue = 0; message.clear(); node_path_cache.clear(); res_path_cache.clear(); profiler_signature.clear(); le_clear->set_disabled(false); le_set->set_disabled(true); profiler->set_enabled(true); inspect_scene_tree->clear(); inspector->edit(NULL); EditorNode::get_singleton()->get_pause_button()->set_pressed(false); EditorNode::get_singleton()->get_pause_button()->set_disabled(true); EditorNode::get_singleton()->get_scene_tree_dock()->hide_remote_tree(); EditorNode::get_singleton()->get_scene_tree_dock()->hide_tab_buttons(); if (hide_on_stop) { if (is_visible_in_tree()) EditorNode::get_singleton()->hide_bottom_panel(); emit_signal("show_debugger", false); } } void ScriptEditorDebugger::_profiler_activate(bool p_enable) { if (!connection.is_valid()) return; if (p_enable) { profiler_signature.clear(); Array msg; msg.push_back("start_profiling"); int max_funcs = EditorSettings::get_singleton()->get("debugger/profiler_frame_max_functions"); max_funcs = CLAMP(max_funcs, 16, 512); msg.push_back(max_funcs); ppeer->put_var(msg); print_verbose("Starting profiling."); } else { Array msg; msg.push_back("stop_profiling"); ppeer->put_var(msg); print_verbose("Ending profiling."); } } void ScriptEditorDebugger::_profiler_seeked() { if (!connection.is_valid() || !connection->is_connected_to_host()) return; if (breaked) return; debug_break(); } void ScriptEditorDebugger::_stack_dump_frame_selected() { TreeItem *ti = stack_dump->get_selected(); if (!ti) return; Dictionary d = ti->get_metadata(0); stack_script = ResourceLoader::load(d["file"]); emit_signal("goto_script_line", stack_script, int(d["line"]) - 1); emit_signal("set_execution", stack_script, int(d["line"]) - 1); stack_script.unref(); if (connection.is_valid() && connection->is_connected_to_host()) { Array msg; msg.push_back("get_stack_frame_vars"); msg.push_back(d["frame"]); ppeer->put_var(msg); } else { inspector->edit(NULL); } } void ScriptEditorDebugger::_output_clear() { //output->clear(); //output->push_color(Color(0,0,0)); } void ScriptEditorDebugger::_export_csv() { file_dialog->set_mode(EditorFileDialog::MODE_SAVE_FILE); file_dialog_mode = SAVE_CSV; file_dialog->popup_centered_ratio(); } String ScriptEditorDebugger::get_var_value(const String &p_var) const { if (!breaked) return String(); return variables->get_var_value(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("live_node_path"); msg.push_back(p_path); msg.push_back(last_path_id); ppeer->put_var(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("live_res_path"); msg.push_back(p_path); msg.push_back(last_path_id); ppeer->put_var(msg); return last_path_id; } void ScriptEditorDebugger::_method_changed(Object *p_base, const StringName &p_name, VARIANT_ARG_DECLARE) { if (!p_base || !live_debug || !connection.is_valid() || !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("live_node_call"); 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]); } ppeer->put_var(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("live_res_call"); 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]); } ppeer->put_var(msg); return; } } void ScriptEditorDebugger::_property_changed(Object *p_base, const StringName &p_property, const Variant &p_value) { if (!p_base || !live_debug || !connection.is_valid() || !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("live_node_prop_res"); msg.push_back(pathid); msg.push_back(p_property); msg.push_back(res->get_path()); ppeer->put_var(msg); } } else { Array msg; msg.push_back("live_node_prop"); msg.push_back(pathid); msg.push_back(p_property); msg.push_back(p_value); ppeer->put_var(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("live_res_prop_res"); msg.push_back(pathid); msg.push_back(p_property); msg.push_back(res2->get_path()); ppeer->put_var(msg); } } else { Array msg; msg.push_back("live_res_prop"); msg.push_back(pathid); msg.push_back(p_property); msg.push_back(p_value); ppeer->put_var(msg); } return; } } void ScriptEditorDebugger::_method_changeds(void *p_ud, Object *p_base, const StringName &p_name, VARIANT_ARG_DECLARE) { ScriptEditorDebugger *sed = (ScriptEditorDebugger *)p_ud; sed->_method_changed(p_base, p_name, VARIANT_ARG_PASS); } void ScriptEditorDebugger::_property_changeds(void *p_ud, Object *p_base, const StringName &p_property, const Variant &p_value) { ScriptEditorDebugger *sed = (ScriptEditorDebugger *)p_ud; sed->_property_changed(p_base, p_property, p_value); } void ScriptEditorDebugger::set_live_debugging(bool p_enable) { live_debug = p_enable; } void ScriptEditorDebugger::_live_edit_set() { if (!connection.is_valid()) return; TreeItem *ti = inspect_scene_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(); if (connection.is_valid()) { Array msg; msg.push_back("live_set_root"); msg.push_back(np); if (editor->get_edited_scene()) msg.push_back(editor->get_edited_scene()->get_filename()); else msg.push_back(""); ppeer->put_var(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 && connection.is_valid()) { Array msg; msg.push_back("live_create_node"); msg.push_back(p_parent); msg.push_back(p_type); msg.push_back(p_name); ppeer->put_var(msg); } } void ScriptEditorDebugger::live_debug_instance_node(const NodePath &p_parent, const String &p_path, const String &p_name) { if (live_debug && connection.is_valid()) { Array msg; msg.push_back("live_instance_node"); msg.push_back(p_parent); msg.push_back(p_path); msg.push_back(p_name); ppeer->put_var(msg); } } void ScriptEditorDebugger::live_debug_remove_node(const NodePath &p_at) { if (live_debug && connection.is_valid()) { Array msg; msg.push_back("live_remove_node"); msg.push_back(p_at); ppeer->put_var(msg); } } void ScriptEditorDebugger::live_debug_remove_and_keep_node(const NodePath &p_at, ObjectID p_keep_id) { if (live_debug && connection.is_valid()) { Array msg; msg.push_back("live_remove_and_keep_node"); msg.push_back(p_at); msg.push_back(p_keep_id); ppeer->put_var(msg); } } void ScriptEditorDebugger::live_debug_restore_node(ObjectID p_id, const NodePath &p_at, int p_at_pos) { if (live_debug && connection.is_valid()) { Array msg; msg.push_back("live_restore_node"); msg.push_back(p_id); msg.push_back(p_at); msg.push_back(p_at_pos); ppeer->put_var(msg); } } void ScriptEditorDebugger::live_debug_duplicate_node(const NodePath &p_at, const String &p_new_name) { if (live_debug && connection.is_valid()) { Array msg; msg.push_back("live_duplicate_node"); msg.push_back(p_at); msg.push_back(p_new_name); ppeer->put_var(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 && connection.is_valid()) { Array msg; msg.push_back("live_reparent_node"); msg.push_back(p_at); msg.push_back(p_new_place); msg.push_back(p_new_name); msg.push_back(p_at_pos); ppeer->put_var(msg); } } void ScriptEditorDebugger::set_breakpoint(const String &p_path, int p_line, bool p_enabled) { if (connection.is_valid()) { Array msg; msg.push_back("breakpoint"); msg.push_back(p_path); msg.push_back(p_line); msg.push_back(p_enabled); ppeer->put_var(msg); } } void ScriptEditorDebugger::reload_scripts() { if (connection.is_valid()) { Array msg; msg.push_back("reload_scripts"); ppeer->put_var(msg); } } 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; } Ref<Script> s = ResourceLoader::load(meta[0]); emit_signal("goto_script_line", s, int(meta[1]) - 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::set_hide_on_stop(bool p_hide) { hide_on_stop = p_hide; } bool ScriptEditorDebugger::get_debug_with_external_editor() const { return enable_external_editor; } void ScriptEditorDebugger::set_debug_with_external_editor(bool p_enabled) { enable_external_editor = p_enabled; } Ref<Script> ScriptEditorDebugger::get_dump_stack_script() const { return stack_script; } void ScriptEditorDebugger::_paused() { ERR_FAIL_COND(connection.is_null()); ERR_FAIL_COND(!connection->is_connected_to_host()); if (!breaked && EditorNode::get_singleton()->get_pause_button()->is_pressed()) { debug_break(); } if (breaked && !EditorNode::get_singleton()->get_pause_button()->is_pressed()) { debug_continue(); } } void ScriptEditorDebugger::_set_remote_object(ObjectID p_id, ScriptEditorDebuggerInspectedObject *p_obj) { if (remote_objects.has(p_id)) memdelete(remote_objects[p_id]); remote_objects[p_id] = p_obj; } void ScriptEditorDebugger::_clear_remote_objects() { for (Map<ObjectID, ScriptEditorDebuggerInspectedObject *>::Element *E = remote_objects.front(); E; E = E->next()) { if (editor->get_editor_history()->get_current() == E->value()->get_instance_id()) { editor->push_item(NULL); } memdelete(E->value()); } remote_objects.clear(); } void ScriptEditorDebugger::_clear_errors_list() { error_tree->clear(); error_count = 0; warning_count = 0; _notification(NOTIFICATION_PROCESS); } // 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_icon("ActionCopy", "EditorIcons"), TTR("Copy Error"), ITEM_MENU_COPY_ERROR); } 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) { switch (p_option) { case ITEM_MENU_COPY_ERROR: { 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_icon("Warning", "EditorIcons")) { type = "W "; } else if (ti->get_icon(0) == get_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(); } OS::get_singleton()->set_clipboard(text); } break; case ITEM_MENU_SAVE_REMOTE_NODE: { file_dialog->set_access(EditorFileDialog::ACCESS_RESOURCES); file_dialog->set_mode(EditorFileDialog::MODE_SAVE_FILE); file_dialog_mode = SAVE_NODE; List<String> extensions; Ref<PackedScene> sd = memnew(PackedScene); ResourceSaver::get_recognized_extensions(sd, &extensions); file_dialog->clear_filters(); for (int i = 0; i < extensions.size(); i++) { file_dialog->add_filter("*." + extensions[i] + " ; " + extensions[i].to_upper()); } file_dialog->popup_centered_ratio(); } break; } } void ScriptEditorDebugger::_bind_methods() { ClassDB::bind_method(D_METHOD("_stack_dump_frame_selected"), &ScriptEditorDebugger::_stack_dump_frame_selected); ClassDB::bind_method(D_METHOD("debug_copy"), &ScriptEditorDebugger::debug_copy); ClassDB::bind_method(D_METHOD("debug_next"), &ScriptEditorDebugger::debug_next); ClassDB::bind_method(D_METHOD("debug_step"), &ScriptEditorDebugger::debug_step); ClassDB::bind_method(D_METHOD("debug_break"), &ScriptEditorDebugger::debug_break); ClassDB::bind_method(D_METHOD("debug_continue"), &ScriptEditorDebugger::debug_continue); ClassDB::bind_method(D_METHOD("_output_clear"), &ScriptEditorDebugger::_output_clear); ClassDB::bind_method(D_METHOD("_export_csv"), &ScriptEditorDebugger::_export_csv); ClassDB::bind_method(D_METHOD("_performance_draw"), &ScriptEditorDebugger::_performance_draw); ClassDB::bind_method(D_METHOD("_performance_select"), &ScriptEditorDebugger::_performance_select); ClassDB::bind_method(D_METHOD("_scene_tree_request"), &ScriptEditorDebugger::_scene_tree_request); ClassDB::bind_method(D_METHOD("_video_mem_request"), &ScriptEditorDebugger::_video_mem_request); ClassDB::bind_method(D_METHOD("_live_edit_set"), &ScriptEditorDebugger::_live_edit_set); ClassDB::bind_method(D_METHOD("_live_edit_clear"), &ScriptEditorDebugger::_live_edit_clear); ClassDB::bind_method(D_METHOD("_error_selected"), &ScriptEditorDebugger::_error_selected); ClassDB::bind_method(D_METHOD("_error_activated"), &ScriptEditorDebugger::_error_activated); ClassDB::bind_method(D_METHOD("_expand_errors_list"), &ScriptEditorDebugger::_expand_errors_list); ClassDB::bind_method(D_METHOD("_collapse_errors_list"), &ScriptEditorDebugger::_collapse_errors_list); ClassDB::bind_method(D_METHOD("_profiler_activate"), &ScriptEditorDebugger::_profiler_activate); ClassDB::bind_method(D_METHOD("_profiler_seeked"), &ScriptEditorDebugger::_profiler_seeked); ClassDB::bind_method(D_METHOD("_clear_errors_list"), &ScriptEditorDebugger::_clear_errors_list); ClassDB::bind_method(D_METHOD("_error_tree_item_rmb_selected"), &ScriptEditorDebugger::_error_tree_item_rmb_selected); ClassDB::bind_method(D_METHOD("_item_menu_id_pressed"), &ScriptEditorDebugger::_item_menu_id_pressed); ClassDB::bind_method(D_METHOD("_paused"), &ScriptEditorDebugger::_paused); ClassDB::bind_method(D_METHOD("_scene_tree_selected"), &ScriptEditorDebugger::_scene_tree_selected); ClassDB::bind_method(D_METHOD("_scene_tree_folded"), &ScriptEditorDebugger::_scene_tree_folded); ClassDB::bind_method(D_METHOD("_scene_tree_rmb_selected"), &ScriptEditorDebugger::_scene_tree_rmb_selected); ClassDB::bind_method(D_METHOD("_file_selected"), &ScriptEditorDebugger::_file_selected); 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("_scene_tree_property_select_object"), &ScriptEditorDebugger::_scene_tree_property_select_object); ClassDB::bind_method(D_METHOD("_scene_tree_property_value_edited"), &ScriptEditorDebugger::_scene_tree_property_value_edited); ADD_SIGNAL(MethodInfo("goto_script_line")); 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("show_debugger", PropertyInfo(Variant::BOOL, "reallydid"))); } ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) { ppeer = Ref<PacketPeerStream>(memnew(PacketPeerStream)); ppeer->set_input_buffer_max_size(1024 * 1024 * 8); //8mb should be enough editor = p_editor; editor->get_inspector()->connect("object_id_selected", this, "_scene_tree_property_select_object"); tabs = memnew(TabContainer); tabs->set_tab_align(TabContainer::ALIGN_LEFT); tabs->add_style_override("panel", editor->get_gui_base()->get_stylebox("DebuggerPanel", "EditorStyles")); tabs->add_style_override("tab_fg", editor->get_gui_base()->get_stylebox("DebuggerTabFG", "EditorStyles")); tabs->add_style_override("tab_bg", editor->get_gui_base()->get_stylebox("DebuggerTabBG", "EditorStyles")); tabs->set_anchors_and_margins_preset(Control::PRESET_WIDE); tabs->set_margin(MARGIN_LEFT, -editor->get_gui_base()->get_stylebox("BottomPanelDebuggerOverride", "EditorStyles")->get_margin(MARGIN_LEFT)); tabs->set_margin(MARGIN_RIGHT, editor->get_gui_base()->get_stylebox("BottomPanelDebuggerOverride", "EditorStyles")->get_margin(MARGIN_RIGHT)); add_child(tabs); { //debugger VBoxContainer *vbc = memnew(VBoxContainer); vbc->set_name(TTR("Debugger")); //tabs->add_child(vbc); 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)); copy = memnew(ToolButton); hbc->add_child(copy); copy->set_tooltip(TTR("Copy Error")); copy->connect("pressed", this, "debug_copy"); hbc->add_child(memnew(VSeparator)); step = memnew(ToolButton); hbc->add_child(step); step->set_tooltip(TTR("Step Into")); step->connect("pressed", this, "debug_step"); next = memnew(ToolButton); hbc->add_child(next); next->set_tooltip(TTR("Step Over")); next->connect("pressed", this, "debug_next"); hbc->add_child(memnew(VSeparator)); dobreak = memnew(ToolButton); hbc->add_child(dobreak); dobreak->set_tooltip(TTR("Break")); dobreak->connect("pressed", this, "debug_break"); docontinue = memnew(ToolButton); hbc->add_child(docontinue); docontinue->set_tooltip(TTR("Continue")); docontinue->connect("pressed", this, "debug_continue"); back = memnew(Button); hbc->add_child(back); back->set_tooltip(TTR("Inspect Previous Instance")); back->hide(); forward = memnew(Button); hbc->add_child(forward); forward->set_tooltip(TTR("Inspect Next Instance")); forward->hide(); 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", this, "_stack_dump_frame_selected"); sc->add_child(stack_dump); inspector = memnew(EditorInspector); inspector->set_h_size_flags(SIZE_EXPAND_FILL); inspector->set_enable_capitalize_paths(false); inspector->set_read_only(true); inspector->connect("object_id_selected", this, "_scene_tree_property_select_object"); sc->add_child(inspector); server.instance(); pending_in_queue = 0; variables = memnew(ScriptEditorDebuggerVariables); breaked = false; 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", this, "_expand_errors_list"); errhb->add_child(expand_all); Button *collapse_all = memnew(Button); collapse_all->set_text(TTR("Collapse All")); collapse_all->connect("pressed", this, "_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", this, "_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", this, "_error_tree_item_rmb_selected"); errors_tab->add_child(error_tree); item_menu = memnew(PopupMenu); item_menu->connect("id_pressed", this, "_item_menu_id_pressed"); error_tree->add_child(item_menu); tabs->add_child(errors_tab); } { // remote scene tree inspect_scene_tree = memnew(Tree); EditorNode::get_singleton()->get_scene_tree_dock()->add_remote_tree_editor(inspect_scene_tree); EditorNode::get_singleton()->get_scene_tree_dock()->connect("remote_tree_selected", this, "_scene_tree_selected"); inspect_scene_tree->set_v_size_flags(SIZE_EXPAND_FILL); inspect_scene_tree->connect("cell_selected", this, "_scene_tree_selected"); inspect_scene_tree->connect("item_collapsed", this, "_scene_tree_folded"); inspect_scene_tree->set_allow_rmb_select(true); inspect_scene_tree->connect("item_rmb_selected", this, "_scene_tree_rmb_selected"); auto_switch_remote_scene_tree = EDITOR_DEF("debugger/auto_switch_to_remote_scene_tree", false); inspect_scene_tree_timeout = EDITOR_DEF("debugger/remote_scene_tree_refresh_interval", 1.0); inspect_edited_object_timeout = EDITOR_DEF("debugger/remote_inspect_refresh_interval", 0.2); inspected_object_id = 0; updating_scene_tree = false; } { // File dialog file_dialog = memnew(EditorFileDialog); file_dialog->connect("file_selected", this, "_file_selected"); add_child(file_dialog); } { //profiler profiler = memnew(EditorProfiler); profiler->set_name(TTR("Profiler")); tabs->add_child(profiler); profiler->connect("enable_profiling", this, "_profiler_activate"); profiler->connect("break_request", this, "_profiler_seeked"); } { //monitors HSplitContainer *hsp = memnew(HSplitContainer); perf_monitors = memnew(Tree); perf_monitors->set_columns(2); perf_monitors->set_column_title(0, TTR("Monitor")); perf_monitors->set_column_title(1, TTR("Value")); perf_monitors->set_column_titles_visible(true); hsp->add_child(perf_monitors); perf_monitors->connect("item_edited", this, "_performance_select"); perf_draw = memnew(Control); perf_draw->connect("draw", this, "_performance_draw"); hsp->add_child(perf_draw); hsp->set_name(TTR("Monitors")); hsp->set_split_offset(340 * EDSCALE); tabs->add_child(hsp); perf_max.resize(Performance::MONITOR_MAX); Map<String, TreeItem *> bases; TreeItem *root = perf_monitors->create_item(); perf_monitors->set_hide_root(true); for (int i = 0; i < Performance::MONITOR_MAX; i++) { String n = Performance::get_singleton()->get_monitor_name(Performance::Monitor(i)); Performance::MonitorType mtype = Performance::get_singleton()->get_monitor_type(Performance::Monitor(i)); String base = n.get_slice("/", 0); String name = n.get_slice("/", 1); if (!bases.has(base)) { TreeItem *b = perf_monitors->create_item(root); b->set_text(0, base.capitalize()); b->set_editable(0, false); b->set_selectable(0, false); b->set_expand_right(0, true); bases[base] = b; } TreeItem *it = perf_monitors->create_item(bases[base]); it->set_metadata(1, mtype); it->set_cell_mode(0, TreeItem::CELL_MODE_CHECK); it->set_editable(0, true); it->set_selectable(0, false); it->set_selectable(1, false); it->set_text(0, name.capitalize()); perf_items.push_back(it); perf_max.write[i] = 0; } } { //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, 1) * EDSCALE); vmem_hb->add_child(vmem_total); vmem_refresh = memnew(ToolButton); vmem_hb->add_child(vmem_refresh); vmem_vb->add_child(vmem_hb); vmem_refresh->connect("pressed", this, "_video_mem_request"); 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 Mem")); 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); vmem_tree->set_column_expand(2, false); vmem_tree->set_column_title(2, TTR("Format")); vmem_tree->set_column_min_width(2, 150); vmem_tree->set_column_expand(3, false); vmem_tree->set_column_title(3, TTR("Usage")); vmem_tree->set_column_min_width(3, 80); 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); 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); le_set->set_disabled(true); le_clear->set_disabled(true); } misc->add_child(memnew(VSeparator)); HBoxContainer *buttons = memnew(HBoxContainer); export_csv = memnew(Button(TTR("Export measures as CSV"))); export_csv->connect("pressed", this, "_export_csv"); buttons->add_child(export_csv); misc->add_child(buttons); } msgdialog = memnew(AcceptDialog); add_child(msgdialog); p_editor->get_undo_redo()->set_method_notify_callback(_method_changeds, this); p_editor->get_undo_redo()->set_property_notify_callback(_property_changeds, this); live_debug = true; last_path_id = false; error_count = 0; warning_count = 0; hide_on_stop = true; enable_external_editor = false; last_error_count = 0; last_warning_count = 0; EditorNode::get_singleton()->get_pause_button()->connect("pressed", this, "_paused"); } ScriptEditorDebugger::~ScriptEditorDebugger() { memdelete(variables); ppeer->set_stream_peer(Ref<StreamPeer>()); server->stop(); _clear_remote_objects(); }