diff options
Diffstat (limited to 'tools')
| -rw-r--r-- | tools/editor/editor_node.cpp | 17 | ||||
| -rw-r--r-- | tools/editor/editor_node.h | 4 | ||||
| -rw-r--r-- | tools/editor/editor_profiler.cpp | 753 | ||||
| -rw-r--r-- | tools/editor/editor_profiler.h | 143 | ||||
| -rw-r--r-- | tools/editor/script_editor_debugger.cpp | 231 | ||||
| -rw-r--r-- | tools/editor/script_editor_debugger.h | 12 |
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); |