summaryrefslogtreecommitdiff
path: root/tools/editor
diff options
context:
space:
mode:
Diffstat (limited to 'tools/editor')
-rw-r--r--tools/editor/editor_node.cpp17
-rw-r--r--tools/editor/editor_node.h4
-rw-r--r--tools/editor/editor_profiler.cpp753
-rw-r--r--tools/editor/editor_profiler.h143
-rw-r--r--tools/editor/script_editor_debugger.cpp231
-rw-r--r--tools/editor/script_editor_debugger.h12
6 files changed, 1147 insertions, 13 deletions
diff --git a/tools/editor/editor_node.cpp b/tools/editor/editor_node.cpp
index fc676bda7e..25c854ce56 100644
--- a/tools/editor/editor_node.cpp
+++ b/tools/editor/editor_node.cpp
@@ -187,7 +187,7 @@ void EditorNode::_unhandled_input(const InputEvent& p_event) {
break;
case KEY_F5: _menu_option_confirm((p_event.key.mod.control&&p_event.key.mod.shift)?RUN_PLAY_CUSTOM_SCENE:RUN_PLAY,true); break;
case KEY_F6: _menu_option_confirm(RUN_PLAY_SCENE,true); break;
- case KEY_F7: _menu_option_confirm(RUN_PAUSE,true); break;
+ //case KEY_F7: _menu_option_confirm(RUN_PAUSE,true); break;
case KEY_F8: _menu_option_confirm(RUN_STOP,true); break;
}
@@ -2636,11 +2636,6 @@ void EditorNode::_menu_option_confirm(int p_option,bool p_confirmed) {
}
} break;
- case RUN_PAUSE: {
-
- emit_signal("pause_pressed");
-
- } break;
case RUN_STOP: {
if (editor_run.get_status()==EditorRun::STATUS_STOP)
@@ -5597,14 +5592,16 @@ EditorNode::EditorNode() {
- /*pause_button = memnew( ToolButton );
+ pause_button = memnew( ToolButton );
//menu_panel->add_child(pause_button); - not needed for now?
pause_button->set_toggle_mode(true);
pause_button->set_icon(gui_base->get_icon("Pause","EditorIcons"));
pause_button->set_focus_mode(Control::FOCUS_NONE);
- pause_button->connect("pressed", this,"_menu_option",make_binds(RUN_PAUSE));
- pause_button->set_tooltip(TTR("Pause the scene (F7)."));
-*/
+ //pause_button->connect("pressed", this,"_menu_option",make_binds(RUN_PAUSE));
+ pause_button->set_tooltip(TTR("Pause the scene"));
+ pause_button->set_disabled(true);
+ play_hb->add_child(pause_button);
+
stop_button = memnew( ToolButton );
play_hb->add_child(stop_button);
//stop_button->set_toggle_mode(true);
diff --git a/tools/editor/editor_node.h b/tools/editor/editor_node.h
index 8fa6cfefcf..5bd6ef0bdf 100644
--- a/tools/editor/editor_node.h
+++ b/tools/editor/editor_node.h
@@ -159,7 +159,7 @@ private:
OBJECT_CALL_METHOD,
OBJECT_REQUEST_HELP,
RUN_PLAY,
- RUN_PAUSE,
+
RUN_STOP,
RUN_PLAY_SCENE,
RUN_PLAY_NATIVE,
@@ -692,6 +692,8 @@ public:
void update_keying();
+ ToolButton *get_pause_button() { return pause_button; }
+
ToolButton* add_bottom_panel_item(String p_text,Control *p_item);
bool are_bottom_panels_hidden() const;
diff --git a/tools/editor/editor_profiler.cpp b/tools/editor/editor_profiler.cpp
new file mode 100644
index 0000000000..955af6b603
--- /dev/null
+++ b/tools/editor/editor_profiler.cpp
@@ -0,0 +1,753 @@
+#include "editor_profiler.h"
+#include "editor_settings.h"
+#include "os/os.h"
+
+void EditorProfiler::_make_metric_ptrs(Metric& m) {
+
+ for(int i=0;i<m.categories.size();i++) {
+ m.category_ptrs[m.categories[i].signature]=&m.categories[i];
+ for(int j=0;j<m.categories[i].items.size();j++) {
+ m.item_ptrs[m.categories[i].items[j].signature]=&m.categories[i].items[j];
+ }
+ }
+}
+
+void EditorProfiler::add_frame_metric(const Metric& p_metric,bool p_final) {
+
+ ++last_metric;
+ if (last_metric>=frame_metrics.size())
+ last_metric=0;
+
+
+ frame_metrics[last_metric]=p_metric;
+ _make_metric_ptrs(frame_metrics[last_metric]);
+
+ 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_val(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_processing()) {
+
+ frame_delay->set_wait_time(p_final?0.1:1);
+ frame_delay->start();
+ }
+
+ if (!plot_delay->is_processing()) {
+ plot_delay->set_wait_time(0.1);
+ plot_delay->start();
+ }
+
+}
+
+
+
+void EditorProfiler::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);
+ plot_sigs.clear();
+ plot_sigs.insert("fixed_frame_time");
+ plot_sigs.insert("category_frame_time");
+
+ updating_frame=true;
+ cursor_metric_edit->set_min(0);
+ cursor_metric_edit->set_max(0);
+ cursor_metric_edit->set_val(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 EditorProfiler::_get_time_as_text(Metric &m,float p_time,int p_calls) {
+
+ int dmode = display_mode->get_selected();
+
+
+ if (dmode==DISPLAY_FRAME_TIME) {
+ return rtos(p_time);
+ } else if (dmode==DISPLAY_AVERAGE_TIME) {
+ if (p_calls==0)
+ return "0";
+ else
+ return rtos(p_time/p_calls);
+ } else if (dmode==DISPLAY_FRAME_PERCENT) {
+ return _get_percent_txt(p_time,m.frame_time);
+ } else if (dmode==DISPLAY_FIXED_FRAME_PERCENT) {
+
+ return _get_percent_txt(p_time,m.fixed_frame_time);
+ }
+
+ return "err";
+}
+
+Color EditorProfiler::_get_color_from_signature(const StringName& p_signature) const {
+
+ double rot = ABS(double(p_signature.hash())/double(0x7FFFFFFF));
+ Color c;
+ c.set_hsv(rot,1,1);
+ return c;
+
+}
+
+void EditorProfiler::_item_edited() {
+
+ if (updating_frame)
+ return;
+
+ TreeItem *item=variables->get_edited();
+ if (!item)
+ return;
+ StringName signature=item->get_metadata(0);
+ bool checked=item->is_checked(0);
+
+
+ if (checked)
+ plot_sigs.insert(signature);
+ else
+ plot_sigs.erase(signature);
+
+ if (!frame_delay->is_processing()) {
+ frame_delay->set_wait_time(0.1);
+ frame_delay->start();
+ }
+}
+
+void EditorProfiler::_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);
+ }
+
+
+ DVector<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
+
+ bool use_self = display_time->get_selected()==DISPLAY_SELF_TIME;
+ float highest=0;
+
+ for(int i=0;i<frame_metrics.size();i++) {
+ Metric &m = frame_metrics[i];
+ if (!m.valid)
+ continue;
+
+ for (Set<StringName>::Element *E=plot_sigs.front();E;E=E->next()) {
+
+ Map<StringName,Metric::Category*>::Element *F=m.category_ptrs.find(E->get());
+ if (F) {
+ highest=MAX(F->get()->total_time,highest);
+ }
+
+ Map<StringName,Metric::Category::Item*>::Element *G=m.item_ptrs.find(E->get());
+ if (G) {
+ if (use_self) {
+ highest=MAX(G->get()->self,highest);
+ } else {
+ highest=MAX(G->get()->total,highest);
+ }
+ }
+ }
+ }
+
+ if (highest>0) {
+ //means some data exists..
+ highest*=1.2; //leave some upper room
+ graph_height=highest;
+
+ Vector<int> columnv;
+ columnv.resize(h*4);
+
+ int *column = columnv.ptr();
+
+ Map<StringName,int> plot_prev;
+ //Map<StringName,int> plot_max;
+
+ uint64_t time = OS::get_singleton()->get_ticks_usec();
+
+ for(int i=0;i<w;i++) {
+
+
+ for(int j=0;j<h*4;j++) {
+ column[j]=0;
+ }
+
+ int current = i*frame_metrics.size()/w;
+ int next = (i+1)*frame_metrics.size()/w;
+ if (next>frame_metrics.size()) {
+ next=frame_metrics.size();
+ }
+ if (next==current)
+ next=current+1; //just because for loop must work
+
+ for (Set<StringName>::Element *E=plot_sigs.front();E;E=E->next()) {
+
+ int plot_pos=-1;
+
+ for(int j=current;j<next;j++) {
+
+ //wrap
+ int idx = last_metric+1+j;
+ while( idx >= frame_metrics.size() ) {
+ idx-=frame_metrics.size();
+ }
+
+ //get
+ Metric &m = frame_metrics[idx];
+ if (m.valid==false)
+ continue; //skip because invalid
+
+
+ float value=0;
+
+ Map<StringName,Metric::Category*>::Element *F=m.category_ptrs.find(E->get());
+ if (F) {
+ value=F->get()->total_time;
+ }
+
+ Map<StringName,Metric::Category::Item*>::Element *G=m.item_ptrs.find(E->get());
+ if (G) {
+ if (use_self) {
+ value=G->get()->self;
+ } else {
+ value=G->get()->total;
+ }
+ }
+
+
+ plot_pos = MAX( CLAMP(int(value*h/highest),0,h-1), plot_pos );
+
+
+ }
+
+ int prev_plot=plot_pos;
+ Map<StringName,int>::Element *H=plot_prev.find(E->get());
+ if (H) {
+ prev_plot=H->get();
+ H->get()=plot_pos;
+ } else {
+ plot_prev[E->get()]=plot_pos;
+ }
+
+ if (plot_pos==-1 && prev_plot==-1) {
+ //don't bother drawing
+ continue;
+ }
+
+ if (prev_plot!=-1 && plot_pos==-1) {
+
+ plot_pos=prev_plot;
+ }
+
+ if (prev_plot==-1 && plot_pos!=-1) {
+ prev_plot=plot_pos;
+ }
+
+ plot_pos = h- plot_pos -1;
+ prev_plot = h- prev_plot -1;
+
+ if (prev_plot > plot_pos) {
+ SWAP(prev_plot,plot_pos);
+ }
+
+ Color col = _get_color_from_signature(E->get());
+
+ for(int j=prev_plot;j<=plot_pos;j++) {
+
+ column[j*4+0]+=Math::fast_ftoi(CLAMP(col.r*255,0,255));
+ column[j*4+1]+=Math::fast_ftoi(CLAMP(col.g*255,0,255));
+ column[j*4+2]+=Math::fast_ftoi(CLAMP(col.b*255,0,255));
+ column[j*4+3]+=1;
+
+ }
+ }
+
+
+ for(int j=0;j<h*4;j+=4) {
+
+ int a = column[j+3];
+ if (a>0) {
+ column[j+0]/=a;
+ column[j+1]/=a;
+ column[j+2]/=a;
+
+ }
+
+ uint8_t r = uint8_t(column[j+0]);
+ uint8_t g = uint8_t(column[j+1]);
+ uint8_t b = uint8_t(column[j+2]);
+
+ int widx = ((j>>2)*w+i)*4;
+ wr[widx+0]=r;
+ wr[widx+1]=g;
+ wr[widx+2]=b;
+ wr[widx+3]=255;
+ }
+ }
+
+ time = OS::get_singleton()->get_ticks_usec() - time;
+ //print_line("Taken: "+rtos(USEC_TO_SEC(time)));
+
+ }
+
+
+ wr = DVector<uint8_t>::Write();
+
+ Image img(w,h,0,Image::FORMAT_RGBA,graph_image);
+
+ if (reset_texture) {
+
+ if (graph_texture.is_null()) {
+ graph_texture.instance();
+ }
+ graph_texture->create(img.get_width(),img.get_height(),img.get_format(),Texture::FLAG_VIDEO_SURFACE);
+
+ }
+
+ graph_texture->set_data(img);;
+
+
+ graph->set_texture(graph_texture);
+ graph->update();
+
+}
+
+void EditorProfiler::_update_frame() {
+
+ int cursor_metric = _get_cursor_index();
+
+
+ ERR_FAIL_INDEX(cursor_metric,frame_metrics.size());
+
+ updating_frame=true;
+ variables->clear();
+
+ TreeItem* root = variables->create_item();
+ Metric &m = frame_metrics[cursor_metric];
+
+
+ int dtime = display_time->get_selected();
+
+
+ for(int i=0;i<m.categories.size();i++) {
+
+ TreeItem *category = variables->create_item(root);
+ category->set_cell_mode(0,TreeItem::CELL_MODE_CHECK);
+ category->set_editable(0,true);
+ category->set_metadata(0,m.categories[i].signature);
+ category->set_text(0,String(m.categories[i].name));
+ category->set_text(1,_get_time_as_text(m,m.categories[i].total_time,1));
+
+ if (plot_sigs.has(m.categories[i].signature)) {
+ category->set_checked(0,true);
+ category->set_custom_bg_color(0,Color(0,0,0));
+ category->set_custom_color(0,_get_color_from_signature(m.categories[i].signature));
+ }
+
+
+ for(int j=0;j<m.categories[i].items.size();j++) {
+ Metric::Category::Item &it = m.categories[i].items[j];
+
+ TreeItem *item = variables->create_item(category);
+ item->set_cell_mode(0,TreeItem::CELL_MODE_CHECK);
+ item->set_editable(0,true);
+ item->set_text(0,it.name);
+ item->set_metadata(0,it.signature);
+ item->set_metadata(1,it.script);
+ item->set_metadata(2,it.line);
+ item->set_tooltip(0,it.script+":"+itos(it.line));
+
+ float time = dtime == DISPLAY_SELF_TIME ? it.self : it.total;
+
+ item->set_text(1,_get_time_as_text(m,time,it.calls));
+
+ item->set_text(2,itos(it.calls));
+
+ if (plot_sigs.has(it.signature)) {
+ item->set_checked(0,true);
+ item->set_custom_bg_color(0,Color(0,0,0));
+ item->set_custom_color(0,_get_color_from_signature(it.signature));
+ }
+
+ }
+ }
+
+ updating_frame=false;
+
+}
+
+
+void EditorProfiler::_activate_pressed() {
+
+ if (activate->is_pressed()) {
+ clear();
+ activate->set_icon(get_icon("Stop","EditorIcons"));
+ activate->set_text(TTR("Stop Profilinng"));
+ } else {
+ activate->set_icon(get_icon("Play","EditorIcons"));
+ activate->set_text(TTR("Start Profilinng"));
+
+
+ }
+ emit_signal("enable_profiling",activate->is_pressed());
+
+}
+
+
+void EditorProfiler::_notification(int p_what) {
+
+ if (p_what==NOTIFICATION_ENTER_TREE) {
+ activate->set_icon(get_icon("Play","EditorIcons"));
+ }
+}
+
+void EditorProfiler::_graph_tex_draw() {
+
+ if (last_metric<0)
+ return;
+ if (seeking) {
+
+ int max_frames = frame_metrics.size();
+ int frame = cursor_metric_edit->get_val() - (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.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 EditorProfiler::_graph_tex_mouse_exit() {
+
+ hover_metric=-1;
+ graph->update();
+}
+
+
+void EditorProfiler::_cursor_metric_changed(double) {
+ if (updating_frame)
+ return;
+
+
+ graph->update();
+ _update_frame();
+
+}
+
+void EditorProfiler::_graph_tex_input(const InputEvent& p_ev){
+
+ if (last_metric<0)
+ return;
+
+ if (
+ (p_ev.type==InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index==BUTTON_LEFT && p_ev.mouse_button.pressed) ||
+ (p_ev.type==InputEvent::MOUSE_MOTION) ) {
+
+ int x = p_ev.mouse_button.x;
+ x=x*frame_metrics.size()/graph->get_size().width;
+
+ 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 (p_ev.type==InputEvent::MOUSE_BUTTON || p_ev.mouse_motion.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)
+ cursor_metric_edit->set_val(frame_metrics[metric].frame_number);
+
+ updating_frame=false;
+
+ if (activate->is_pressed()) {
+ if (!seeking) {
+ emit_signal("break_request");
+ }
+ }
+
+ seeking=true;
+
+ if (!frame_delay->is_processing()) {
+ frame_delay->set_wait_time(0.1);
+ frame_delay->start();
+ }
+ }
+
+ graph->update();
+
+ }
+
+}
+
+int EditorProfiler::_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_val());
+
+ int idx = last_metric - diff;
+ while (idx<0) {
+ idx+=frame_metrics.size();
+ }
+
+
+ return idx;
+
+}
+
+void EditorProfiler::disable_seeking() {
+
+ seeking=false;
+ graph->update();
+
+}
+
+void EditorProfiler::_combo_changed(int) {
+
+ _update_frame();
+ _update_plot();
+}
+
+void EditorProfiler::_bind_methods() {
+
+ ObjectTypeDB::bind_method(_MD("_update_frame"),&EditorProfiler::_update_frame);
+ ObjectTypeDB::bind_method(_MD("_update_plot"),&EditorProfiler::_update_plot);
+ ObjectTypeDB::bind_method(_MD("_activate_pressed"),&EditorProfiler::_activate_pressed);
+ ObjectTypeDB::bind_method(_MD("_graph_tex_draw"),&EditorProfiler::_graph_tex_draw);
+ ObjectTypeDB::bind_method(_MD("_graph_tex_input"),&EditorProfiler::_graph_tex_input);
+ ObjectTypeDB::bind_method(_MD("_graph_tex_mouse_exit"),&EditorProfiler::_graph_tex_mouse_exit);
+ ObjectTypeDB::bind_method(_MD("_cursor_metric_changed"),&EditorProfiler::_cursor_metric_changed);
+ ObjectTypeDB::bind_method(_MD("_combo_changed"),&EditorProfiler::_combo_changed);
+
+ ObjectTypeDB::bind_method(_MD("_item_edited"),&EditorProfiler::_item_edited);
+ ADD_SIGNAL( MethodInfo("enable_profiling",PropertyInfo(Variant::BOOL,"enable")));
+ ADD_SIGNAL( MethodInfo("break_request"));
+
+}
+
+void EditorProfiler::set_enabled(bool p_enable) {
+
+ activate->set_disabled(!p_enable);
+}
+
+bool EditorProfiler::is_profiling() {
+ return activate->is_pressed();
+}
+
+EditorProfiler::EditorProfiler()
+{
+
+ HBoxContainer *hb = memnew( HBoxContainer );
+ add_child(hb);
+ activate = memnew( Button );
+ activate->set_toggle_mode(true);
+ activate->set_text(TTR("Start Profiling"));
+ activate->connect("pressed",this,"_activate_pressed");
+ hb->add_child(activate);
+
+ hb->add_child( memnew( Label(TTR("Measure:") ) ) );
+
+ display_mode = memnew( OptionButton );
+ display_mode->add_item(TTR("Frame Time (sec)"));
+ display_mode->add_item(TTR("Average Time (sec)"));
+ display_mode->add_item(TTR("Frame %"));
+ display_mode->add_item(TTR("Fixed Frame %"));
+ display_mode->connect("item_selected",this,"_combo_changed");
+
+ hb->add_child( display_mode );
+
+ hb->add_child( memnew( Label(TTR("Time:") ) ) );
+
+ display_time = memnew( OptionButton );
+ display_time->add_item(TTR("Inclusive"));
+ display_time->add_item(TTR("Self"));
+ display_time->connect("item_selected",this,"_combo_changed");
+
+ hb->add_child(display_time);
+
+ 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);
+
+
+
+ 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));
+ 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,"Name");
+ variables->set_column_expand(0,true);
+ variables->set_column_min_width(0,60);
+ variables->set_column_title(1,"Time");
+ variables->set_column_expand(1,false);
+ variables->set_column_min_width(1,60);
+ variables->set_column_title(2,"Calls");
+ variables->set_column_expand(2,false);
+ variables->set_column_min_width(2,60);
+ variables->connect("item_edited",this,"_item_edited");
+
+
+ graph = memnew( TextureFrame );
+ graph->set_expand(true);
+ graph->set_stop_mouse(true);
+ graph->set_ignore_mouse(false);
+ graph->connect("draw",this,"_graph_tex_draw");
+ graph->connect("input_event",this,"_graph_tex_input");
+ graph->connect("mouse_exit",this,"_graph_tex_mouse_exit");
+
+ h_split->add_child(graph);
+ graph->set_h_size_flags(SIZE_EXPAND_FILL);
+
+ add_constant_override("separation",3);
+
+ 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;
+
+
+ EDITOR_DEF("debugger/profiler_frame_max_functions",64);
+
+ //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");
+
+ plot_sigs.insert("fixed_frame_time");
+ plot_sigs.insert("category_frame_time");
+
+ seeking=false;
+ graph_height=1;
+
+// activate->set_disabled(true);
+
+}
diff --git a/tools/editor/editor_profiler.h b/tools/editor/editor_profiler.h
new file mode 100644
index 0000000000..aca3220717
--- /dev/null
+++ b/tools/editor/editor_profiler.h
@@ -0,0 +1,143 @@
+#ifndef EDITORPROFILER_H
+#define EDITORPROFILER_H
+
+
+#include "scene/gui/box_container.h"
+#include "scene/gui/texture_frame.h"
+#include "scene/gui/button.h"
+#include "scene/gui/label.h"
+#include "scene/gui/tree.h"
+#include "scene/gui/split_container.h"
+#include "scene/gui/option_button.h"
+#include "scene/gui/spin_box.h"
+
+
+class EditorProfiler : public VBoxContainer {
+
+ OBJ_TYPE(EditorProfiler,VBoxContainer)
+
+public:
+
+ struct Metric {
+
+ bool valid;
+
+ int frame_number;
+ float frame_time;
+ float idle_time;
+ float fixed_time;
+ float fixed_frame_time;
+
+ struct Category {
+
+ StringName signature;
+ String name;
+ float total_time; //total for category
+
+ struct Item {
+
+ StringName signature;
+ String name;
+ String script;
+ int line;
+ float self;
+ float total;
+ int calls;
+ };
+
+ Vector<Item> items;
+ };
+
+ Vector<Category> categories;
+
+ Map<StringName,Category*> category_ptrs;
+ Map<StringName,Category::Item*> item_ptrs;
+
+
+ Metric() { valid=false; frame_number=0; }
+ };
+
+ enum DisplayMode {
+ DISPLAY_FRAME_TIME,
+ DISPLAY_AVERAGE_TIME,
+ DISPLAY_FRAME_PERCENT,
+ DISPLAY_FIXED_FRAME_PERCENT,
+ };
+
+ enum DisplayTime {
+ DISPLAY_TOTAL_TIME,
+ DISPLAY_SELF_TIME,
+ };
+
+private:
+ Button *activate;
+ TextureFrame *graph;
+ Ref<ImageTexture> graph_texture;
+ DVector<uint8_t> graph_image;
+ Tree *variables;
+ HSplitContainer *h_split;
+
+ Set<StringName> plot_sigs;
+
+ OptionButton *display_mode;
+ OptionButton *display_time;
+
+ SpinBox * cursor_metric_edit;
+
+ Vector<Metric> frame_metrics;
+ int last_metric;
+
+ int max_functions;
+
+ bool updating_frame;
+
+ //int cursor_metric;
+ int hover_metric;
+
+ bool seeking;
+
+ Timer *frame_delay;
+ Timer *plot_delay;
+
+ void _update_frame();
+
+ void _activate_pressed();
+
+ String _get_time_as_text(Metric &m,float p_time,int p_calls);
+
+ void _make_metric_ptrs(Metric& m);
+ void _item_edited();
+
+ void _update_plot();
+
+ void _graph_tex_mouse_exit();
+
+ void _graph_tex_draw();
+ void _graph_tex_input(const 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, bool p_final=false);
+ void set_enabled(bool p_enable);
+ bool is_profiling();
+ bool is_seeking() { return seeking; }
+ void disable_seeking();
+
+ void clear();
+
+ EditorProfiler();
+};
+
+#endif // EDITORPROFILER_H
diff --git a/tools/editor/script_editor_debugger.cpp b/tools/editor/script_editor_debugger.cpp
index 325eadc1e5..b0cd2e925d 100644
--- a/tools/editor/script_editor_debugger.cpp
+++ b/tools/editor/script_editor_debugger.cpp
@@ -41,6 +41,8 @@
#include "globals.h"
#include "editor_node.h"
#include "main/performance.h"
+#include "editor_profiler.h"
+#include "editor_settings.h"
class ScriptEditorDebuggerVariables : public Object {
@@ -208,7 +210,13 @@ void ScriptEditorDebugger::_parse_message(const String& p_msg,const Array& p_dat
docontinue->set_disabled(false);
emit_signal("breaked",true,can_continue);
OS::get_singleton()->move_window_to_foreground();
- tabs->set_current_tab(0);
+ if (!profiler->is_seeking())
+ 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);
@@ -225,6 +233,11 @@ void ScriptEditorDebugger::_parse_message(const String& p_msg,const Array& p_dat
docontinue->set_disabled(true);
emit_signal("breaked",false,false);
//tabs->set_current_tab(0);
+ profiler->set_enabled(true);
+ profiler->disable_seeking();
+
+ EditorNode::get_singleton()->get_pause_button()->set_pressed(false);
+
} else if (p_msg=="message:click_ctrl") {
@@ -441,6 +454,137 @@ void ScriptEditorDebugger::_parse_message(const String& p_msg,const Array& p_dat
packet_peer_stream->put_var(oe.warning);
packet_peer_stream->put_var(oe.callstack);
*/
+
+ } else if (p_msg=="profile_sig") {
+ //cache a signature
+ print_line("SIG: "+String(Variant(p_data)));
+ 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.fixed_time=p_data[3];
+ metric.fixed_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="Fixed Time";
+ item.total=metric.fixed_time;
+ item.self=item.total;
+ item.signature="fixed_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="Fixed Frame Time";
+ item.total=metric.fixed_frame_time;
+ item.self=item.total;
+ item.signature="fixed_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 i=0;i<values.size();i+=2) {
+
+ EditorProfiler::Metric::Category::Item item;
+ item.name=values[i];
+ item.calls=1;
+ item.self=values[i+1];
+ item.total=item.self;
+ item.signature="categ::"+name+"::"+item.name;
+ item.name=item.name.capitalize();
+ c.total_time+=item.total;
+ c.items[i/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 {
+ item.name="SigErr "+itos(signature);
+ }
+
+
+
+
+ item.calls=calls;
+ item.self=self;
+ item.total=total;
+ funcs.items[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");
@@ -586,15 +730,25 @@ void ScriptEditorDebugger::_notification(int p_what) {
reason->set_text(TTR("Child Process Connected"));
reason->set_tooltip(TTR("Child Process Connected"));
+ profiler->clear();
+
scene_tree->clear();
le_set->set_disabled(true);
le_clear->set_disabled(false);
error_list->clear();
error_stack->clear();
error_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 {
@@ -656,6 +810,7 @@ void ScriptEditorDebugger::_notification(int p_what) {
}
message_type=cmd;
+ //print_line("GOT: "+message_type);
ret = ppeer->get_var(cmd);
if (ret!=OK) {
@@ -744,8 +899,14 @@ void ScriptEditorDebugger::stop(){
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);
+
+ EditorNode::get_singleton()->get_pause_button()->set_pressed(false);
+ EditorNode::get_singleton()->get_pause_button()->set_disabled(true);
+
if (hide_on_stop) {
@@ -756,6 +917,44 @@ void ScriptEditorDebugger::stop(){
}
+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_line("BEGIN PROFILING!");
+
+ } else {
+ Array msg;
+ msg.push_back("stop_profiling");
+ ppeer->put_var(msg);
+
+ print_line("END PROFILING!");
+
+ }
+
+}
+
+void ScriptEditorDebugger::_profiler_seeked() {
+
+ if (!connection.is_valid() || !connection->is_connected())
+ return;
+
+ if (breaked)
+ return;
+ debug_break();;
+}
+
void ScriptEditorDebugger::_stack_dump_frame_selected() {
@@ -1172,6 +1371,21 @@ void ScriptEditorDebugger::set_hide_on_stop(bool p_hide) {
hide_on_stop=p_hide;
}
+void ScriptEditorDebugger::_paused() {
+
+ ERR_FAIL_COND(connection.is_null());
+ ERR_FAIL_COND(!connection->is_connected());
+
+ 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::_bind_methods() {
ObjectTypeDB::bind_method(_MD("_stack_dump_frame_selected"),&ScriptEditorDebugger::_stack_dump_frame_selected);
@@ -1189,6 +1403,11 @@ void ScriptEditorDebugger::_bind_methods() {
ObjectTypeDB::bind_method(_MD("_error_selected"),&ScriptEditorDebugger::_error_selected);
ObjectTypeDB::bind_method(_MD("_error_stack_selected"),&ScriptEditorDebugger::_error_stack_selected);
+ ObjectTypeDB::bind_method(_MD("_profiler_activate"),&ScriptEditorDebugger::_profiler_activate);
+ ObjectTypeDB::bind_method(_MD("_profiler_seeked"),&ScriptEditorDebugger::_profiler_seeked);
+
+ ObjectTypeDB::bind_method(_MD("_paused"),&ScriptEditorDebugger::_paused);
+
ObjectTypeDB::bind_method(_MD("live_debug_create_node"),&ScriptEditorDebugger::live_debug_create_node);
ObjectTypeDB::bind_method(_MD("live_debug_instance_node"),&ScriptEditorDebugger::live_debug_instance_node);
@@ -1320,6 +1539,12 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor){
error_split->set_name(TTR("Errors"));
tabs->add_child(error_split);
+ profiler = memnew( EditorProfiler );
+ profiler->set_name("Profiler");
+ tabs->add_child(profiler);
+ profiler->connect("enable_profiling",this,"_profiler_activate");
+ profiler->connect("break_request",this,"_profiler_seeked");
+
HSplitContainer *hsp = memnew( HSplitContainer );
@@ -1334,7 +1559,7 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor){
perf_draw = memnew( Control );
perf_draw->connect("draw",this,"_performance_draw");
hsp->add_child(perf_draw);
- hsp->set_name("Performance");
+ hsp->set_name("Metrics");
hsp->set_split_offset(300);
tabs->add_child(hsp);
perf_max.resize(Performance::MONITOR_MAX);
@@ -1468,6 +1693,8 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor){
hide_on_stop=true;
last_error_count=0;
+ EditorNode::get_singleton()->get_pause_button()->connect("pressed",this,"_paused");
+
}
diff --git a/tools/editor/script_editor_debugger.h b/tools/editor/script_editor_debugger.h
index ecd0494955..1288349884 100644
--- a/tools/editor/script_editor_debugger.h
+++ b/tools/editor/script_editor_debugger.h
@@ -34,6 +34,7 @@
#include "core/io/tcp_server.h"
#include "core/io/packet_peer.h"
+
class Tree;
class PropertyEditor;
class EditorNode;
@@ -46,6 +47,7 @@ class AcceptDialog;
class TreeItem;
class HSplitContainer;
class ItemList;
+class EditorProfiler;
class ScriptEditorDebugger : public Control {
@@ -93,6 +95,8 @@ class ScriptEditorDebugger : public Control {
Vector<float> perf_max;
Vector<TreeItem*> perf_items;
+ Map<int,String> profiler_signature;
+
Tree *perf_monitors;
Control *perf_draw;
@@ -115,6 +119,7 @@ class ScriptEditorDebugger : public Control {
int last_path_id;
Map<String,int> res_path_cache;
+ EditorProfiler *profiler;
EditorNode *editor;
@@ -148,6 +153,13 @@ class ScriptEditorDebugger : public Control {
void _error_selected(int p_idx);
void _error_stack_selected(int p_idx);
+ void _profiler_activate(bool p_enable);
+ void _profiler_seeked();
+
+
+
+ void _paused();
+
protected:
void _notification(int p_what);
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-24 22:32:50 +0000