summaryrefslogtreecommitdiff
path: root/editor
diff options
context:
space:
mode:
Diffstat (limited to 'editor')
-rw-r--r--editor/editor_visual_profiler.cpp833
-rw-r--r--editor/editor_visual_profiler.h124
-rw-r--r--editor/icons/icon_track_color.svg61
-rw-r--r--editor/script_editor_debugger.cpp62
-rw-r--r--editor/script_editor_debugger.h3
5 files changed, 1081 insertions, 2 deletions
diff --git a/editor/editor_visual_profiler.cpp b/editor/editor_visual_profiler.cpp
new file mode 100644
index 0000000000..6511e6e911
--- /dev/null
+++ b/editor/editor_visual_profiler.cpp
@@ -0,0 +1,833 @@
+#include "editor_visual_profiler.h"
+
+#include "core/os/os.h"
+#include "editor_scale.h"
+#include "editor_settings.h"
+
+void EditorVisualProfiler::add_frame_metric(const Metric &p_metric) {
+
+ ++last_metric;
+ if (last_metric >= frame_metrics.size())
+ last_metric = 0;
+
+ frame_metrics.write[last_metric] = p_metric;
+ // _make_metric_ptrs(frame_metrics.write[last_metric]);
+
+ List<String> stack;
+ for (int i = 0; i < frame_metrics[last_metric].areas.size(); i++) {
+ String name = frame_metrics[last_metric].areas[i].name;
+ frame_metrics.write[last_metric].areas.write[i].color_cache = _get_color_from_signature(name);
+ String full_name;
+
+ if (name[0] == '<') {
+ stack.pop_back();
+ }
+
+ if (stack.size()) {
+ full_name = stack.back()->get() + name;
+ } else {
+ full_name = name;
+ }
+
+ if (name[0] == '>') {
+
+ stack.push_back(full_name + "/");
+ }
+
+ frame_metrics.write[last_metric].areas.write[i].fullpath_cache = full_name;
+ }
+
+ updating_frame = true;
+ cursor_metric_edit->set_max(frame_metrics[last_metric].frame_number);
+ cursor_metric_edit->set_min(MAX(frame_metrics[last_metric].frame_number - frame_metrics.size(), 0));
+
+ if (!seeking) {
+ cursor_metric_edit->set_value(frame_metrics[last_metric].frame_number);
+ if (hover_metric != -1) {
+ hover_metric++;
+ if (hover_metric >= frame_metrics.size()) {
+ hover_metric = 0;
+ }
+ }
+ }
+ updating_frame = false;
+
+ if (frame_delay->is_stopped()) {
+
+ frame_delay->set_wait_time(0.1);
+ frame_delay->start();
+ }
+
+ if (plot_delay->is_stopped()) {
+ plot_delay->set_wait_time(0.1);
+ plot_delay->start();
+ }
+}
+
+void EditorVisualProfiler::clear() {
+
+ int metric_size = EditorSettings::get_singleton()->get("debugger/profiler_frame_history_size");
+ metric_size = CLAMP(metric_size, 60, 1024);
+ frame_metrics.clear();
+ frame_metrics.resize(metric_size);
+ last_metric = -1;
+ variables->clear();
+ //activate->set_pressed(false);
+
+ updating_frame = true;
+ cursor_metric_edit->set_min(0);
+ cursor_metric_edit->set_max(0);
+ cursor_metric_edit->set_value(0);
+ updating_frame = false;
+ hover_metric = -1;
+ seeking = false;
+}
+
+static String _get_percent_txt(float p_value, float p_total) {
+ if (p_total == 0)
+ p_total = 0.00001;
+ return String::num((p_value / p_total) * 100, 1) + "%";
+}
+
+String EditorVisualProfiler::_get_time_as_text(float p_time) {
+
+ int dmode = display_mode->get_selected();
+
+ if (dmode == DISPLAY_FRAME_TIME) {
+ return rtos(p_time) + "ms";
+ } else if (dmode == DISPLAY_FRAME_PERCENT) {
+ return String::num(p_time * 100 / graph_limit, 2) + "%"; //_get_percent_txt(p_time, m.frame_time);
+ }
+
+ return "err";
+}
+
+Color EditorVisualProfiler::_get_color_from_signature(const StringName &p_signature) const {
+
+ Color bc = get_color("error_color", "Editor");
+ double rot = ABS(double(p_signature.hash()) / double(0x7FFFFFFF));
+ Color c;
+ c.set_hsv(rot, bc.get_s(), bc.get_v());
+ return c.linear_interpolate(get_color("base_color", "Editor"), 0.07);
+}
+
+void EditorVisualProfiler::_item_selected() {
+
+ if (updating_frame)
+ return;
+
+ TreeItem *item = variables->get_selected();
+ if (!item)
+ return;
+ selected_area = item->get_metadata(0);
+ _update_plot();
+}
+
+void EditorVisualProfiler::_update_plot() {
+
+ int w = graph->get_size().width;
+ int h = graph->get_size().height;
+
+ bool reset_texture = false;
+
+ int desired_len = w * h * 4;
+
+ if (graph_image.size() != desired_len) {
+ reset_texture = true;
+ graph_image.resize(desired_len);
+ }
+
+ PoolVector<uint8_t>::Write wr = graph_image.write();
+
+ //clear
+ for (int i = 0; i < desired_len; i += 4) {
+ wr[i + 0] = 0;
+ wr[i + 1] = 0;
+ wr[i + 2] = 0;
+ wr[i + 3] = 255;
+ }
+
+ //find highest value
+
+ float highest_cpu = 0;
+ float highest_gpu = 0;
+
+ for (int i = 0; i < frame_metrics.size(); i++) {
+ const Metric &m = frame_metrics[i];
+ if (!m.valid)
+ continue;
+
+ if (m.areas.size()) {
+ highest_cpu = MAX(highest_cpu, m.areas[m.areas.size() - 1].cpu_time);
+ highest_gpu = MAX(highest_gpu, m.areas[m.areas.size() - 1].gpu_time);
+ }
+ }
+
+ if (highest_cpu > 0 || highest_gpu > 0) {
+
+ if (frame_relative->is_pressed()) {
+ highest_cpu = MAX(graph_limit, highest_cpu);
+ highest_gpu = MAX(graph_limit, highest_gpu);
+ }
+
+ if (linked->is_pressed()) {
+ float highest = MAX(highest_cpu, highest_gpu);
+ highest_cpu = highest_gpu = highest;
+ }
+
+ //means some data exists..
+ highest_cpu *= 1.2; //leave some upper room
+ highest_gpu *= 1.2; //leave some upper room
+ graph_height_cpu = highest_cpu;
+ graph_height_gpu = highest_gpu;
+
+ Vector<Color> columnv_cpu;
+ columnv_cpu.resize(h);
+ Color *column_cpu = columnv_cpu.ptrw();
+
+ Vector<Color> columnv_gpu;
+ columnv_gpu.resize(h);
+ Color *column_gpu = columnv_gpu.ptrw();
+
+ int half_w = w / 2;
+ for (int i = 0; i < half_w; i++) {
+ for (int j = 0; j < h; j++) {
+ column_cpu[j] = Color(0, 0, 0, 0);
+ column_gpu[j] = Color(0, 0, 0, 0);
+ }
+
+ int current = i * frame_metrics.size() / half_w;
+ int next = (i + 1) * frame_metrics.size() / half_w;
+ if (next > frame_metrics.size()) {
+ next = frame_metrics.size();
+ }
+ if (next == current)
+ next = current + 1; //just because for loop must work
+
+ for (int j = current; j < next; j++) {
+
+ //wrap
+ int idx = last_metric + 1 + j;
+ while (idx >= frame_metrics.size()) {
+ idx -= frame_metrics.size();
+ }
+
+ int area_count = frame_metrics[idx].areas.size();
+ const Metric::Area *areas = frame_metrics[idx].areas.ptr();
+ int prev_cpu = 0;
+ int prev_gpu = 0;
+ for (int k = 1; k < area_count; k++) {
+ int ofs_cpu = int(areas[k].cpu_time * h / highest_cpu);
+ ofs_cpu = CLAMP(ofs_cpu, 0, h - 1);
+ Color color = selected_area == areas[k - 1].fullpath_cache ? Color(1, 1, 1, 1) : areas[k - 1].color_cache;
+
+ for (int l = prev_cpu; l < ofs_cpu; l++) {
+ column_cpu[h - l - 1] += color;
+ }
+ prev_cpu = ofs_cpu;
+
+ int ofs_gpu = int(areas[k].gpu_time * h / highest_gpu);
+ ofs_gpu = CLAMP(ofs_gpu, 0, h - 1);
+ for (int l = prev_gpu; l < ofs_gpu; l++) {
+ column_gpu[h - l - 1] += color;
+ }
+
+ prev_gpu = ofs_gpu;
+ }
+ }
+
+ //plot CPU
+ for (int j = 0; j < h; j++) {
+
+ uint8_t r, g, b;
+
+ if (column_cpu[j].a == 0) {
+ r = 0;
+ g = 0;
+ b = 0;
+ } else {
+ r = CLAMP((column_cpu[j].r / column_cpu[j].a) * 255.0, 0, 255);
+ g = CLAMP((column_cpu[j].g / column_cpu[j].a) * 255.0, 0, 255);
+ b = CLAMP((column_cpu[j].b / column_cpu[j].a) * 255.0, 0, 255);
+ }
+
+ int widx = (j * w + i) * 4;
+ wr[widx + 0] = r;
+ wr[widx + 1] = g;
+ wr[widx + 2] = b;
+ wr[widx + 3] = 255;
+ }
+ //plot GPU
+ for (int j = 0; j < h; j++) {
+
+ uint8_t r, g, b;
+
+ if (column_gpu[j].a == 0) {
+ r = 0;
+ g = 0;
+ b = 0;
+ } else {
+ r = CLAMP((column_gpu[j].r / column_gpu[j].a) * 255.0, 0, 255);
+ g = CLAMP((column_gpu[j].g / column_gpu[j].a) * 255.0, 0, 255);
+ b = CLAMP((column_gpu[j].b / column_gpu[j].a) * 255.0, 0, 255);
+ }
+
+ int widx = (j * w + w / 2 + i) * 4;
+ wr[widx + 0] = r;
+ wr[widx + 1] = g;
+ wr[widx + 2] = b;
+ wr[widx + 3] = 255;
+ }
+ }
+ }
+
+ wr.release();
+
+ Ref<Image> img;
+ img.instance();
+ img->create(w, h, 0, Image::FORMAT_RGBA8, graph_image);
+
+ if (reset_texture) {
+
+ if (graph_texture.is_null()) {
+ graph_texture.instance();
+ }
+ graph_texture->create_from_image(img);
+ }
+
+ graph_texture->update(img, true);
+
+ graph->set_texture(graph_texture);
+ graph->update();
+}
+
+void EditorVisualProfiler::_update_frame(bool p_focus_selected) {
+
+ int cursor_metric = _get_cursor_index();
+
+ Ref<Texture> track_icon = get_icon("TrackColor", "EditorIcons");
+
+ ERR_FAIL_INDEX(cursor_metric, frame_metrics.size());
+
+ updating_frame = true;
+ variables->clear();
+
+ TreeItem *root = variables->create_item();
+ const Metric &m = frame_metrics[cursor_metric];
+
+ List<TreeItem *> stack;
+ List<TreeItem *> categories;
+
+ TreeItem *ensure_selected = nullptr;
+
+ for (int i = 1; i < m.areas.size() - 1; i++) {
+
+ TreeItem *parent = stack.size() ? stack.back()->get() : root;
+
+ String name = m.areas[i].name;
+
+ float cpu_time = m.areas[i].cpu_time;
+ float gpu_time = m.areas[i].gpu_time;
+ if (i < m.areas.size() - 1) {
+ cpu_time = m.areas[i + 1].cpu_time - cpu_time;
+ gpu_time = m.areas[i + 1].gpu_time - gpu_time;
+ }
+
+ if (name.begins_with(">")) {
+ TreeItem *category = variables->create_item(parent);
+
+ stack.push_back(category);
+ categories.push_back(category);
+
+ name = name.substr(1, name.length());
+
+ category->set_text(0, name);
+ category->set_metadata(1, cpu_time);
+ category->set_metadata(2, gpu_time);
+ continue;
+ }
+
+ if (name.begins_with("<")) {
+ stack.pop_back();
+ continue;
+ }
+ TreeItem *category = variables->create_item(parent);
+
+ for (List<TreeItem *>::Element *E = stack.front(); E; E = E->next()) {
+ float total_cpu = E->get()->get_metadata(1);
+ float total_gpu = E->get()->get_metadata(2);
+ total_cpu += cpu_time;
+ total_gpu += gpu_time;
+ E->get()->set_metadata(1, cpu_time);
+ E->get()->set_metadata(2, gpu_time);
+ }
+
+ category->set_icon(0, track_icon);
+ category->set_icon_modulate(0, m.areas[i].color_cache);
+ category->set_selectable(0, true);
+ category->set_metadata(0, m.areas[i].fullpath_cache);
+ category->set_text(0, m.areas[i].name);
+ category->set_text(1, _get_time_as_text(cpu_time));
+ category->set_metadata(1, m.areas[i].cpu_time);
+ category->set_text(2, _get_time_as_text(gpu_time));
+ category->set_metadata(2, m.areas[i].gpu_time);
+
+ if (selected_area == m.areas[i].fullpath_cache) {
+ category->select(0);
+ if (p_focus_selected) {
+ ensure_selected = category;
+ }
+ }
+ }
+
+ for (List<TreeItem *>::Element *E = categories.front(); E; E = E->next()) {
+ float total_cpu = E->get()->get_metadata(1);
+ float total_gpu = E->get()->get_metadata(2);
+ E->get()->set_text(1, _get_time_as_text(total_cpu));
+ E->get()->set_text(2, _get_time_as_text(total_gpu));
+ }
+
+ if (ensure_selected) {
+ variables->ensure_cursor_is_visible();
+ }
+ updating_frame = false;
+}
+
+void EditorVisualProfiler::_activate_pressed() {
+
+ if (activate->is_pressed()) {
+ activate->set_icon(get_icon("Stop", "EditorIcons"));
+ activate->set_text(TTR("Stop"));
+ _clear_pressed(); //always clear on start
+ } else {
+ activate->set_icon(get_icon("Play", "EditorIcons"));
+ activate->set_text(TTR("Start"));
+ }
+ emit_signal("enable_profiling", activate->is_pressed());
+}
+
+void EditorVisualProfiler::_clear_pressed() {
+
+ clear();
+ _update_plot();
+}
+
+void EditorVisualProfiler::_notification(int p_what) {
+
+ if (p_what == NOTIFICATION_ENTER_TREE) {
+ activate->set_icon(get_icon("Play", "EditorIcons"));
+ clear_button->set_icon(get_icon("Clear", "EditorIcons"));
+ }
+}
+
+void EditorVisualProfiler::_graph_tex_draw() {
+
+ if (last_metric < 0)
+ return;
+ Ref<Font> font = get_font("font", "Label");
+ if (seeking) {
+
+ int max_frames = frame_metrics.size();
+ int frame = cursor_metric_edit->get_value() - (frame_metrics[last_metric].frame_number - max_frames + 1);
+ if (frame < 0)
+ frame = 0;
+
+ int half_width = graph->get_size().x / 2;
+ int cur_x = frame * half_width / max_frames;
+ //cur_x /= 2.0;
+
+ graph->draw_line(Vector2(cur_x, 0), Vector2(cur_x, graph->get_size().y), Color(1, 1, 1, 0.8));
+ graph->draw_line(Vector2(cur_x + half_width, 0), Vector2(cur_x + half_width, graph->get_size().y), Color(1, 1, 1, 0.8));
+ }
+
+ if (graph_height_cpu > 0) {
+ int frame_y = graph->get_size().y - graph_limit * graph->get_size().y / graph_height_cpu - 1;
+
+ int half_width = graph->get_size().x / 2;
+
+ graph->draw_line(Vector2(0, frame_y), Vector2(half_width, frame_y), Color(1, 1, 1, 0.3));
+
+ String limit_str = String::num(graph_limit, 2);
+ graph->draw_string(font, Vector2(half_width - font->get_string_size(limit_str).x - 2, frame_y - 2), limit_str, Color(1, 1, 1, 0.6));
+ }
+
+ if (graph_height_gpu > 0) {
+ int frame_y = graph->get_size().y - graph_limit * graph->get_size().y / graph_height_gpu - 1;
+
+ int half_width = graph->get_size().x / 2;
+
+ graph->draw_line(Vector2(half_width, frame_y), Vector2(graph->get_size().x, frame_y), Color(1, 1, 1, 0.3));
+
+ String limit_str = String::num(graph_limit, 2);
+ graph->draw_string(font, Vector2(half_width * 2 - font->get_string_size(limit_str).x - 2, frame_y - 2), limit_str, Color(1, 1, 1, 0.6));
+ }
+
+ graph->draw_string(font, Vector2(font->get_string_size("X").x, font->get_ascent() + 2), "CPU:", Color(1, 1, 1, 0.8));
+ graph->draw_string(font, Vector2(font->get_string_size("X").x + graph->get_size().width / 2, font->get_ascent() + 2), "GPU:", Color(1, 1, 1, 0.8));
+
+ /*
+ if (hover_metric != -1 && frame_metrics[hover_metric].valid) {
+
+ int max_frames = frame_metrics.size();
+ int frame = frame_metrics[hover_metric].frame_number - (frame_metrics[last_metric].frame_number - max_frames + 1);
+ if (frame < 0)
+ frame = 0;
+
+ int cur_x = frame * graph->get_size().x / max_frames;
+
+ graph->draw_line(Vector2(cur_x, 0), Vector2(cur_x, graph->get_size().y), Color(1, 1, 1, 0.4));
+ }
+*/
+}
+
+void EditorVisualProfiler::_graph_tex_mouse_exit() {
+
+ hover_metric = -1;
+ graph->update();
+}
+
+void EditorVisualProfiler::_cursor_metric_changed(double) {
+ if (updating_frame)
+ return;
+
+ graph->update();
+ _update_frame();
+}
+
+void EditorVisualProfiler::_graph_tex_input(const Ref<InputEvent> &p_ev) {
+
+ if (last_metric < 0)
+ return;
+
+ Ref<InputEventMouse> me = p_ev;
+ Ref<InputEventMouseButton> mb = p_ev;
+ Ref<InputEventMouseMotion> mm = p_ev;
+
+ if (
+ (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) ||
+ (mm.is_valid())) {
+
+ int half_w = graph->get_size().width / 2;
+ int x = me->get_position().x;
+ if (x > half_w) {
+ x -= half_w;
+ }
+ x = x * frame_metrics.size() / half_w;
+
+ bool show_hover = x >= 0 && x < frame_metrics.size();
+
+ if (x < 0) {
+ x = 0;
+ }
+
+ if (x >= frame_metrics.size()) {
+ x = frame_metrics.size() - 1;
+ }
+
+ int metric = frame_metrics.size() - x - 1;
+ metric = last_metric - metric;
+ while (metric < 0) {
+ metric += frame_metrics.size();
+ }
+
+ if (show_hover) {
+
+ hover_metric = metric;
+
+ } else {
+ hover_metric = -1;
+ }
+
+ if (mb.is_valid() || mm->get_button_mask() & BUTTON_MASK_LEFT) {
+ //cursor_metric=x;
+ updating_frame = true;
+
+ //metric may be invalid, so look for closest metric that is valid, this makes snap feel better
+ bool valid = false;
+ for (int i = 0; i < frame_metrics.size(); i++) {
+
+ if (frame_metrics[metric].valid) {
+ valid = true;
+ break;
+ }
+
+ metric++;
+ if (metric >= frame_metrics.size())
+ metric = 0;
+ }
+
+ if (!valid) {
+ return;
+ }
+
+ cursor_metric_edit->set_value(frame_metrics[metric].frame_number);
+
+ updating_frame = false;
+
+ if (activate->is_pressed()) {
+ if (!seeking) {
+ //probably not need to break request, can just stop profiling
+ //emit_signal("break_request");
+ }
+ }
+
+ seeking = true;
+
+ if (!frame_delay->is_processing()) {
+ frame_delay->set_wait_time(0.1);
+ frame_delay->start();
+ }
+
+ bool touched_cpu = me->get_position().x < graph->get_size().width * 0.5;
+
+ const Metric::Area *areas = frame_metrics[metric].areas.ptr();
+ int area_count = frame_metrics[metric].areas.size();
+ float posy = (1.0 - (me->get_position().y / graph->get_size().height)) * (touched_cpu ? graph_height_cpu : graph_height_gpu);
+ int last_valid = -1;
+ bool found = false;
+ for (int i = 0; i < area_count - 1; i++) {
+
+ if (areas[i].name[0] != '<' && areas[i].name[0] != '>') {
+ last_valid = i;
+ }
+ float h = touched_cpu ? areas[i + 1].cpu_time : areas[i + 1].gpu_time;
+
+ if (h > posy) {
+ found = true;
+ break;
+ }
+ }
+
+ StringName area_found;
+ if (found && last_valid != -1) {
+ area_found = areas[last_valid].fullpath_cache;
+ }
+
+ if (area_found != selected_area) {
+ selected_area = area_found;
+ _update_frame(true);
+ _update_plot();
+ }
+ }
+
+ graph->update();
+ }
+}
+
+int EditorVisualProfiler::_get_cursor_index() const {
+
+ if (last_metric < 0)
+ return 0;
+ if (!frame_metrics[last_metric].valid)
+ return 0;
+
+ int diff = (frame_metrics[last_metric].frame_number - cursor_metric_edit->get_value());
+
+ int idx = last_metric - diff;
+ while (idx < 0) {
+ idx += frame_metrics.size();
+ }
+
+ return idx;
+}
+
+void EditorVisualProfiler::disable_seeking() {
+
+ seeking = false;
+ graph->update();
+}
+
+void EditorVisualProfiler::_combo_changed(int) {
+
+ _update_frame();
+ _update_plot();
+}
+
+void EditorVisualProfiler::_bind_methods() {
+
+ ClassDB::bind_method(D_METHOD("_update_frame"), &EditorVisualProfiler::_update_frame, DEFVAL(false));
+ ClassDB::bind_method(D_METHOD("_update_plot"), &EditorVisualProfiler::_update_plot);
+ ClassDB::bind_method(D_METHOD("_activate_pressed"), &EditorVisualProfiler::_activate_pressed);
+ ClassDB::bind_method(D_METHOD("_clear_pressed"), &EditorVisualProfiler::_clear_pressed);
+ ClassDB::bind_method(D_METHOD("_graph_tex_draw"), &EditorVisualProfiler::_graph_tex_draw);
+ ClassDB::bind_method(D_METHOD("_graph_tex_input"), &EditorVisualProfiler::_graph_tex_input);
+ ClassDB::bind_method(D_METHOD("_graph_tex_mouse_exit"), &EditorVisualProfiler::_graph_tex_mouse_exit);
+ ClassDB::bind_method(D_METHOD("_cursor_metric_changed"), &EditorVisualProfiler::_cursor_metric_changed);
+ ClassDB::bind_method(D_METHOD("_combo_changed"), &EditorVisualProfiler::_combo_changed);
+
+ ClassDB::bind_method(D_METHOD("_item_selected"), &EditorVisualProfiler::_item_selected);
+ ADD_SIGNAL(MethodInfo("enable_profiling", PropertyInfo(Variant::BOOL, "enable")));
+ ADD_SIGNAL(MethodInfo("break_request"));
+}
+
+void EditorVisualProfiler::set_enabled(bool p_enable) {
+
+ activate->set_disabled(!p_enable);
+}
+
+bool EditorVisualProfiler::is_profiling() {
+ return activate->is_pressed();
+}
+
+Vector<Vector<String> > EditorVisualProfiler::get_data_as_csv() const {
+ Vector<Vector<String> > res;
+#if 0
+ if (frame_metrics.empty()) {
+ return res;
+ }
+
+ // signatures
+ Vector<String> signatures;
+ const Vector<EditorFrameProfiler::Metric::Category> &categories = frame_metrics[0].categories;
+
+ for (int j = 0; j < categories.size(); j++) {
+
+ const EditorFrameProfiler::Metric::Category &c = categories[j];
+ signatures.push_back(c.signature);
+
+ for (int k = 0; k < c.items.size(); k++) {
+ signatures.push_back(c.items[k].signature);
+ }
+ }
+ res.push_back(signatures);
+
+ // values
+ Vector<String> values;
+ values.resize(signatures.size());
+
+ int index = last_metric;
+
+ for (int i = 0; i < frame_metrics.size(); i++) {
+
+ ++index;
+
+ if (index >= frame_metrics.size()) {
+ index = 0;
+ }
+
+ if (!frame_metrics[index].valid) {
+ continue;
+ }
+ int it = 0;
+ const Vector<EditorFrameProfiler::Metric::Category> &frame_cat = frame_metrics[index].categories;
+
+ for (int j = 0; j < frame_cat.size(); j++) {
+
+ const EditorFrameProfiler::Metric::Category &c = frame_cat[j];
+ values.write[it++] = String::num_real(c.total_time);
+
+ for (int k = 0; k < c.items.size(); k++) {
+ values.write[it++] = String::num_real(c.items[k].total);
+ }
+ }
+ res.push_back(values);
+ }
+#endif
+ return res;
+}
+
+EditorVisualProfiler::EditorVisualProfiler() {
+
+ HBoxContainer *hb = memnew(HBoxContainer);
+ add_child(hb);
+ activate = memnew(Button);
+ activate->set_toggle_mode(true);
+ activate->set_text(TTR("Start"));
+ activate->connect("pressed", this, "_activate_pressed");
+ hb->add_child(activate);
+
+ clear_button = memnew(Button);
+ clear_button->set_text(TTR("Clear"));
+ clear_button->connect("pressed", this, "_clear_pressed");
+ hb->add_child(clear_button);
+
+ hb->add_child(memnew(Label(TTR("Measure:"))));
+
+ display_mode = memnew(OptionButton);
+ display_mode->add_item(TTR("Frame Time (msec)"));
+ display_mode->add_item(TTR("Frame %"));
+ display_mode->connect("item_selected", this, "_combo_changed");
+
+ hb->add_child(display_mode);
+
+ frame_relative = memnew(CheckBox(TTR("Fit to Frame")));
+ frame_relative->set_pressed(true);
+ hb->add_child(frame_relative);
+ frame_relative->connect("pressed", this, "_update_plot");
+ linked = memnew(CheckBox(TTR("Linked")));
+ linked->set_pressed(true);
+ hb->add_child(linked);
+ linked->connect("pressed", this, "_update_plot");
+
+ hb->add_spacer();
+
+ hb->add_child(memnew(Label(TTR("Frame #:"))));
+
+ cursor_metric_edit = memnew(SpinBox);
+ cursor_metric_edit->set_h_size_flags(SIZE_FILL);
+ hb->add_child(cursor_metric_edit);
+ cursor_metric_edit->connect("value_changed", this, "_cursor_metric_changed");
+
+ hb->add_constant_override("separation", 8 * EDSCALE);
+
+ h_split = memnew(HSplitContainer);
+ add_child(h_split);
+ h_split->set_v_size_flags(SIZE_EXPAND_FILL);
+
+ variables = memnew(Tree);
+ variables->set_custom_minimum_size(Size2(300, 0) * EDSCALE);
+ variables->set_hide_folding(true);
+ h_split->add_child(variables);
+ variables->set_hide_root(true);
+ variables->set_columns(3);
+ variables->set_column_titles_visible(true);
+ variables->set_column_title(0, TTR("Name"));
+ variables->set_column_expand(0, true);
+ variables->set_column_min_width(0, 60);
+ variables->set_column_title(1, TTR("CPU"));
+ variables->set_column_expand(1, false);
+ variables->set_column_min_width(1, 60 * EDSCALE);
+ variables->set_column_title(2, TTR("GPU"));
+ variables->set_column_expand(2, false);
+ variables->set_column_min_width(2, 60 * EDSCALE);
+ variables->connect("cell_selected", this, "_item_selected");
+
+ graph = memnew(TextureRect);
+ graph->set_expand(true);
+ graph->set_mouse_filter(MOUSE_FILTER_STOP);
+ //graph->set_ignore_mouse(false);
+ graph->connect("draw", this, "_graph_tex_draw");
+ graph->connect("gui_input", this, "_graph_tex_input");
+ graph->connect("mouse_exited", this, "_graph_tex_mouse_exit");
+
+ h_split->add_child(graph);
+ graph->set_h_size_flags(SIZE_EXPAND_FILL);
+
+ int metric_size = CLAMP(int(EDITOR_DEF("debugger/profiler_frame_history_size", 600)), 60, 1024);
+ frame_metrics.resize(metric_size);
+ last_metric = -1;
+ //cursor_metric=-1;
+ hover_metric = -1;
+
+ //display_mode=DISPLAY_FRAME_TIME;
+
+ frame_delay = memnew(Timer);
+ frame_delay->set_wait_time(0.1);
+ frame_delay->set_one_shot(true);
+ add_child(frame_delay);
+ frame_delay->connect("timeout", this, "_update_frame");
+
+ plot_delay = memnew(Timer);
+ plot_delay->set_wait_time(0.1);
+ plot_delay->set_one_shot(true);
+ add_child(plot_delay);
+ plot_delay->connect("timeout", this, "_update_plot");
+
+ seeking = false;
+ graph_height_cpu = 1;
+ graph_height_gpu = 1;
+
+ graph_limit = 1000 / 60.0;
+
+ //activate->set_disabled(true);
+}
diff --git a/editor/editor_visual_profiler.h b/editor/editor_visual_profiler.h
new file mode 100644
index 0000000000..e5e5688997
--- /dev/null
+++ b/editor/editor_visual_profiler.h
@@ -0,0 +1,124 @@
+#ifndef EDITOR_FRAME_PROFILER_H
+#define EDITOR_FRAME_PROFILER_H
+
+#include "scene/gui/box_container.h"
+#include "scene/gui/button.h"
+#include "scene/gui/check_box.h"
+#include "scene/gui/label.h"
+#include "scene/gui/option_button.h"
+#include "scene/gui/spin_box.h"
+#include "scene/gui/split_container.h"
+#include "scene/gui/texture_rect.h"
+#include "scene/gui/tree.h"
+
+class EditorVisualProfiler : public VBoxContainer {
+
+ GDCLASS(EditorVisualProfiler, VBoxContainer);
+
+public:
+ struct Metric {
+
+ bool valid;
+
+ uint64_t frame_number;
+
+ struct Area {
+ String name;
+ Color color_cache;
+ StringName fullpath_cache;
+ float cpu_time = 0;
+ float gpu_time = 0;
+ };
+
+ Vector<Area> areas;
+
+ Metric() {
+ valid = false;
+ }
+ };
+
+ enum DisplayTimeMode {
+ DISPLAY_FRAME_TIME,
+ DISPLAY_FRAME_PERCENT,
+ };
+
+private:
+ Button *activate;
+ Button *clear_button;
+
+ TextureRect *graph;
+ Ref<ImageTexture> graph_texture;
+ PoolVector<uint8_t> graph_image;
+ Tree *variables;
+ HSplitContainer *h_split;
+ CheckBox *frame_relative;
+ CheckBox *linked;
+
+ OptionButton *display_mode;
+
+ SpinBox *cursor_metric_edit;
+
+ Vector<Metric> frame_metrics;
+ int last_metric;
+
+ StringName selected_area;
+
+ bool updating_frame;
+
+ //int cursor_metric;
+ int hover_metric;
+
+ float graph_height_cpu;
+ float graph_height_gpu;
+
+ float graph_limit;
+
+ bool seeking;
+
+ Timer *frame_delay;
+ Timer *plot_delay;
+
+ void _update_frame(bool p_focus_selected = false);
+
+ void _activate_pressed();
+ void _clear_pressed();
+
+ String _get_time_as_text(float p_time);
+
+ //void _make_metric_ptrs(Metric &m);
+ void _item_selected();
+
+ void _update_plot();
+
+ void _graph_tex_mouse_exit();
+
+ void _graph_tex_draw();
+ void _graph_tex_input(const Ref<InputEvent> &p_ev);
+
+ int _get_cursor_index() const;
+
+ Color _get_color_from_signature(const StringName &p_signature) const;
+
+ void _cursor_metric_changed(double);
+
+ void _combo_changed(int);
+
+protected:
+ void _notification(int p_what);
+ static void _bind_methods();
+
+public:
+ void add_frame_metric(const Metric &p_metric);
+ void set_enabled(bool p_enable);
+ bool is_profiling();
+ bool is_seeking() { return seeking; }
+ void disable_seeking();
+
+ void clear();
+
+ Vector<Vector<String> > get_data_as_csv() const;
+
+ EditorVisualProfiler();
+};
+
+#endif // EDITOR_FRAME_PROFILER_H
diff --git a/editor/icons/icon_track_color.svg b/editor/icons/icon_track_color.svg
new file mode 100644
index 0000000000..6a736c7a84
--- /dev/null
+++ b/editor/icons/icon_track_color.svg
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ height="10"
+ viewBox="0 0 10 10"
+ width="10"
+ version="1.1"
+ id="svg4"
+ sodipodi:docname="icon_track_color.svg"
+ inkscape:version="0.92.4 (5da689c313, 2019-01-14)">
+ <metadata
+ id="metadata10">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title></dc:title>
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <defs
+ id="defs8" />
+ <sodipodi:namedview
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1"
+ objecttolerance="10"
+ gridtolerance="10"
+ guidetolerance="10"
+ inkscape:pageopacity="0"
+ inkscape:pageshadow="2"
+ inkscape:window-width="838"
+ inkscape:window-height="480"
+ id="namedview6"
+ showgrid="false"
+ inkscape:zoom="23.6"
+ inkscape:cx="5"
+ inkscape:cy="5"
+ inkscape:window-x="593"
+ inkscape:window-y="314"
+ inkscape:window-maximized="0"
+ inkscape:current-layer="svg4" />
+ <rect
+ fill="#5792f6"
+ height="6.1027"
+ ry=".76286"
+ transform="matrix(.70710678 -.70710678 .70710678 .70710678 0 -1042.4)"
+ width="6.1027"
+ x="-740.13947"
+ y="741.10779"
+ id="rect2"
+ style="fill:#ffffff;fill-opacity:1" />
+</svg>
diff --git a/editor/script_editor_debugger.cpp b/editor/script_editor_debugger.cpp
index 3d73124dd7..fe6f92f0a5 100644
--- a/editor/script_editor_debugger.cpp
+++ b/editor/script_editor_debugger.cpp
@@ -35,8 +35,9 @@
#include "core/ustring.h"
#include "editor/plugins/canvas_item_editor_plugin.h"
#include "editor/plugins/spatial_editor_plugin.h"
-#include "editor_log.h"
-#include "editor_network_profiler.h"
+#include "editor/editor_log.h"
+#include "editor/editor_network_profiler.h"
+#include "editor/editor_visual_profiler.h"
#include "editor_node.h"
#include "editor_profiler.h"
#include "editor_scale.h"
@@ -833,6 +834,32 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
}
perf_history.push_front(p);
perf_draw->update();
+ } else if (p_msg == "visual_profile") {
+ uint64_t frame = p_data[0];
+ PoolVector<String> names = p_data[1];
+ PoolVector<real_t> values = p_data[2];
+
+ EditorVisualProfiler::Metric metric;
+ metric.areas.resize(names.size());
+ metric.frame_number = frame;
+ metric.valid = true;
+
+ {
+ EditorVisualProfiler::Metric::Area *areas_ptr = metric.areas.ptrw();
+ int metric_count = names.size();
+
+ PoolVector<String>::Read rs = names.read();
+ PoolVector<real_t>::Read rr = values.read();
+
+ for (int i = 0; i < metric_count; i++) {
+
+ areas_ptr[i].name = rs[i];
+ areas_ptr[i].cpu_time = rr[i * 2 + 0];
+ areas_ptr[i].gpu_time = rr[i * 2 + 1];
+ }
+ }
+
+ visual_profiler->add_frame_metric(metric);
} else if (p_msg == "error") {
@@ -1565,12 +1592,33 @@ void ScriptEditorDebugger::_profiler_activate(bool p_enable) {
}
}
+void ScriptEditorDebugger::_visual_profiler_activate(bool p_enable) {
+
+ if (!connection.is_valid())
+ return;
+
+ if (p_enable) {
+ profiler_signature.clear();
+ Array msg;
+ msg.push_back("start_visual_profiling");
+ ppeer->put_var(msg);
+ print_verbose("Starting visual profiling.");
+
+ } else {
+ Array msg;
+ msg.push_back("stop_visual_profiling");
+ ppeer->put_var(msg);
+ print_verbose("Ending visual profiling.");
+ }
+}
+
void ScriptEditorDebugger::_network_profiler_activate(bool p_enable) {
if (!connection.is_valid())
return;
if (p_enable) {
+ profiler_signature.clear();
Array msg;
msg.push_back("start_network_profiling");
ppeer->put_var(msg);
@@ -2224,6 +2272,7 @@ void ScriptEditorDebugger::_bind_methods() {
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("_visual_profiler_activate"), &ScriptEditorDebugger::_visual_profiler_activate);
ClassDB::bind_method(D_METHOD("_network_profiler_activate"), &ScriptEditorDebugger::_network_profiler_activate);
ClassDB::bind_method(D_METHOD("_profiler_seeked"), &ScriptEditorDebugger::_profiler_seeked);
ClassDB::bind_method(D_METHOD("_clear_errors_list"), &ScriptEditorDebugger::_clear_errors_list);
@@ -2455,11 +2504,20 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) {
profiler->connect("break_request", this, "_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", this, "_visual_profiler_activate");
+ visual_profiler->connect("break_request", this, "_profiler_seeked");
+ }
+
{ //network profiler
network_profiler = memnew(EditorNetworkProfiler);
network_profiler->set_name(TTR("Network Profiler"));
tabs->add_child(network_profiler);
network_profiler->connect("enable_profiling", this, "_network_profiler_activate");
+ network_profiler->connect("break_request", this, "_profiler_seeked");
}
{ //monitors
diff --git a/editor/script_editor_debugger.h b/editor/script_editor_debugger.h
index 589a011bff..5a821a4a88 100644
--- a/editor/script_editor_debugger.h
+++ b/editor/script_editor_debugger.h
@@ -51,6 +51,7 @@ class TreeItem;
class HSplitContainer;
class ItemList;
class EditorProfiler;
+class EditorVisualProfiler;
class EditorNetworkProfiler;
class ScriptEditorDebuggerInspectedObject;
@@ -169,6 +170,7 @@ private:
Map<String, int> res_path_cache;
EditorProfiler *profiler;
+ EditorVisualProfiler *visual_profiler;
EditorNetworkProfiler *network_profiler;
EditorNode *editor;
@@ -213,6 +215,7 @@ private:
void _expand_errors_list();
void _collapse_errors_list();
+ void _visual_profiler_activate(bool p_enable);
void _profiler_activate(bool p_enable);
void _profiler_seeked();
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-26 03:38:54 +0000