827 lines
24 KiB
C++
827 lines
24 KiB
C++
/*************************************************************************/
|
|
/* editor_visual_profiler.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#include "editor_visual_profiler.h"
|
|
|
|
#include "core/os/os.h"
|
|
#include "editor/editor_scale.h"
|
|
#include "editor/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;
|
|
}
|
|
|
|
String EditorVisualProfiler::_get_time_as_text(float p_time) {
|
|
int dmode = display_mode->get_selected();
|
|
|
|
if (dmode == DISPLAY_FRAME_TIME) {
|
|
return TS->format_number(rtos(p_time)) + " " + RTR("ms");
|
|
} else if (dmode == DISPLAY_FRAME_PERCENT) {
|
|
return TS->format_number(String::num(p_time * 100 / graph_limit, 2)) + " " + TS->percent_sign();
|
|
}
|
|
|
|
return "err";
|
|
}
|
|
|
|
Color EditorVisualProfiler::_get_color_from_signature(const StringName &p_signature) const {
|
|
Color bc = get_theme_color(SNAME("error_color"), SNAME("Editor"));
|
|
double rot = ABS(double(p_signature.hash()) / double(0x7FFFFFFF));
|
|
Color c;
|
|
c.set_hsv(rot, bc.get_s(), bc.get_v());
|
|
return c.lerp(get_theme_color(SNAME("base_color"), SNAME("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);
|
|
}
|
|
|
|
uint8_t *wr = graph_image.ptrw();
|
|
|
|
//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;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ref<Image> img;
|
|
img.instantiate();
|
|
img->create(w, h, false, Image::FORMAT_RGBA8, graph_image);
|
|
|
|
if (reset_texture) {
|
|
if (graph_texture.is_null()) {
|
|
graph_texture.instantiate();
|
|
}
|
|
graph_texture->create_from_image(img);
|
|
}
|
|
|
|
graph_texture->update(img);
|
|
|
|
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_theme_icon(SNAME("TrackColor"), SNAME("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 (TreeItem *E : stack) {
|
|
float total_cpu = E->get_metadata(1);
|
|
float total_gpu = E->get_metadata(2);
|
|
total_cpu += cpu_time;
|
|
total_gpu += gpu_time;
|
|
E->set_metadata(1, total_cpu);
|
|
E->set_metadata(2, total_gpu);
|
|
}
|
|
|
|
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 (TreeItem *E : categories) {
|
|
float total_cpu = E->get_metadata(1);
|
|
float total_gpu = E->get_metadata(2);
|
|
E->set_text(1, _get_time_as_text(total_cpu));
|
|
E->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_theme_icon(SNAME("Stop"), SNAME("EditorIcons")));
|
|
activate->set_text(TTR("Stop"));
|
|
_clear_pressed(); //always clear on start
|
|
} else {
|
|
activate->set_icon(get_theme_icon(SNAME("Play"), SNAME("EditorIcons")));
|
|
activate->set_text(TTR("Start"));
|
|
}
|
|
emit_signal(SNAME("enable_profiling"), activate->is_pressed());
|
|
}
|
|
|
|
void EditorVisualProfiler::_clear_pressed() {
|
|
clear();
|
|
_update_plot();
|
|
}
|
|
|
|
void EditorVisualProfiler::_notification(int p_what) {
|
|
if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_LAYOUT_DIRECTION_CHANGED || p_what == NOTIFICATION_TRANSLATION_CHANGED) {
|
|
if (is_layout_rtl()) {
|
|
activate->set_icon(get_theme_icon(SNAME("PlayBackwards"), SNAME("EditorIcons")));
|
|
} else {
|
|
activate->set_icon(get_theme_icon(SNAME("Play"), SNAME("EditorIcons")));
|
|
}
|
|
clear_button->set_icon(get_theme_icon(SNAME("Clear"), SNAME("EditorIcons")));
|
|
}
|
|
}
|
|
|
|
void EditorVisualProfiler::_graph_tex_draw() {
|
|
if (last_metric < 0) {
|
|
return;
|
|
}
|
|
Ref<Font> font = get_theme_font(SNAME("font"), SNAME("Label"));
|
|
int font_size = get_theme_font_size(SNAME("font_size"), SNAME("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, font_size).x - 2, frame_y - 2), limit_str, HALIGN_LEFT, -1, font_size, 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, font_size).x - 2, frame_y - 2), limit_str, HALIGN_LEFT, -1, font_size, Color(1, 1, 1, 0.6));
|
|
}
|
|
|
|
graph->draw_string(font, Vector2(font->get_string_size("X", font_size).x, font->get_ascent(font_size) + 2), "CPU:", HALIGN_LEFT, -1, font_size, Color(1, 1, 1, 0.8));
|
|
graph->draw_string(font, Vector2(font->get_string_size("X", font_size).x + graph->get_size().width / 2, font->get_ascent(font_size) + 2), "GPU:", HALIGN_LEFT, -1, font_size, 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() == MOUSE_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() & MOUSE_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) {
|
|
// Break request is not required, just stop profiling
|
|
}
|
|
}
|
|
|
|
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() {
|
|
ADD_SIGNAL(MethodInfo("enable_profiling", PropertyInfo(Variant::BOOL, "enable")));
|
|
}
|
|
|
|
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.is_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", callable_mp(this, &EditorVisualProfiler::_activate_pressed));
|
|
hb->add_child(activate);
|
|
|
|
clear_button = memnew(Button);
|
|
clear_button->set_text(TTR("Clear"));
|
|
clear_button->connect("pressed", callable_mp(this, &EditorVisualProfiler::_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", callable_mp(this, &EditorVisualProfiler::_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", callable_mp(this, &EditorVisualProfiler::_update_plot));
|
|
linked = memnew(CheckBox(TTR("Linked")));
|
|
linked->set_pressed(true);
|
|
hb->add_child(linked);
|
|
linked->connect("pressed", callable_mp(this, &EditorVisualProfiler::_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", callable_mp(this, &EditorVisualProfiler::_cursor_metric_changed));
|
|
|
|
hb->add_theme_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_clip_content(0, true);
|
|
variables->set_column_custom_minimum_width(0, 60);
|
|
variables->set_column_title(1, TTR("CPU"));
|
|
variables->set_column_expand(1, false);
|
|
variables->set_column_clip_content(1, true);
|
|
variables->set_column_custom_minimum_width(1, 60 * EDSCALE);
|
|
variables->set_column_title(2, TTR("GPU"));
|
|
variables->set_column_expand(2, false);
|
|
variables->set_column_clip_content(2, true);
|
|
variables->set_column_custom_minimum_width(2, 60 * EDSCALE);
|
|
variables->connect("cell_selected", callable_mp(this, &EditorVisualProfiler::_item_selected));
|
|
|
|
graph = memnew(TextureRect);
|
|
graph->set_expand(true);
|
|
graph->set_mouse_filter(MOUSE_FILTER_STOP);
|
|
//graph->set_ignore_mouse(false);
|
|
graph->connect("draw", callable_mp(this, &EditorVisualProfiler::_graph_tex_draw));
|
|
graph->connect("gui_input", callable_mp(this, &EditorVisualProfiler::_graph_tex_input));
|
|
graph->connect("mouse_exited", callable_mp(this, &EditorVisualProfiler::_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", callable_mp(this, &EditorVisualProfiler::_update_frame), make_binds(false));
|
|
|
|
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", callable_mp(this, &EditorVisualProfiler::_update_plot));
|
|
|
|
seeking = false;
|
|
graph_height_cpu = 1;
|
|
graph_height_gpu = 1;
|
|
|
|
graph_limit = 1000 / 60.0;
|
|
|
|
//activate->set_disabled(true);
|
|
}
|