Update editor debugger to new remote debugger.

Shared RemoteDebuggerPeer code between client and server.
Move editor profilers inside editor/debugger folder.

12 files changed, 2358 insertions, 291 deletions

diff --git a/editor/debugger/editor_debugger_inspector.cpp b/editor/debugger/editor_debugger_inspector.cpp
index 1506d64b63..9587daf93e 100644
--- a/editor/debugger/editor_debugger_inspector.cpp
+++ b/editor/debugger/editor_debugger_inspector.cpp
@@ -30,8 +30,8 @@
 
 #include "editor_debugger_inspector.h"
 
+#include "core/debugger/debugger_marshalls.h"
 #include "core/io/marshalls.h"
-#include "core/script_debugger_remote.h"
 #include "editor/editor_node.h"
 #include "scene/debugger/scene_debugger.h"
 
@@ -226,7 +226,7 @@ Object *EditorDebuggerInspector::get_object(ObjectID p_id) {
 
 void EditorDebuggerInspector::add_stack_variable(const Array &p_array) {
 
-	ScriptDebuggerRemote::ScriptStackVariable var;
+	DebuggerMarshalls::ScriptStackVariable var;
 	var.deserialize(p_array);
 	String n = var.name;
 	Variant v = var.value;
diff --git a/editor/debugger/editor_debugger_node.cpp b/editor/debugger/editor_debugger_node.cpp
index 825883cffe..f4a8102b79 100644
--- a/editor/debugger/editor_debugger_node.cpp
+++ b/editor/debugger/editor_debugger_node.cpp
@@ -240,6 +240,7 @@ void EditorDebuggerNode::_notification(int p_what) {
 		stop();
 		return;
 	}
+	server->poll();
 
 	// Errors and warnings
 	int error_count = 0;
diff --git a/editor/debugger/editor_debugger_server.cpp b/editor/debugger/editor_debugger_server.cpp
index bde0921ced..c80988a662 100644
--- a/editor/debugger/editor_debugger_server.cpp
+++ b/editor/debugger/editor_debugger_server.cpp
@@ -30,7 +30,7 @@
 
 #include "editor_debugger_server.h"
 
-#include "core/io/packet_peer.h"
+#include "core/io/marshalls.h"
 #include "core/io/tcp_server.h"
 #include "core/os/mutex.h"
 #include "core/os/thread.h"
@@ -38,114 +38,18 @@
 #include "editor/editor_node.h"
 #include "editor/editor_settings.h"
 
-class EditorDebuggerPeerTCP : public EditorDebuggerPeer {
-
-private:
-	enum {
-		QUEUE_MAX = 2048,
-		POLL_USEC_MAX = 100,
-	};
-	Ref<StreamPeerTCP> tcp;
-	Ref<PacketPeerStream> packet_peer;
-	List<Array> out_queue;
-	List<Array> in_queue;
-	Mutex mutex;
-	bool connected = false;
-
-public:
-	Error poll() {
-		MutexLock lock(mutex);
-		connected = tcp->get_status() == StreamPeerTCP::STATUS_CONNECTED;
-		Error err = OK;
-		uint64_t ticks = OS::get_singleton()->get_ticks_usec();
-		while (connected && packet_peer->get_available_packet_count() > 0 && in_queue.size() < QUEUE_MAX && OS::get_singleton()->get_ticks_usec() - ticks < POLL_USEC_MAX) {
-			Variant var;
-			err = packet_peer->get_var(var);
-			connected = tcp->get_status() == StreamPeerTCP::STATUS_CONNECTED;
-			if (err != OK) {
-				ERR_PRINT("Error reading variant from peer");
-				break;
-			}
-			ERR_CONTINUE_MSG(var.get_type() != Variant::ARRAY, "Malformed packet received, not an Array.");
-			in_queue.push_back(var);
-		}
-		ticks = OS::get_singleton()->get_ticks_usec();
-		while (connected && out_queue.size() > 0 && OS::get_singleton()->get_ticks_usec() - ticks < POLL_USEC_MAX) {
-			Array arr = out_queue[0];
-			out_queue.pop_front();
-			packet_peer->put_var(arr);
-			connected = tcp->get_status() == StreamPeerTCP::STATUS_CONNECTED;
-		}
-		return err;
-	}
-
-	bool has_message() {
-		return in_queue.size() > 0;
-	}
-
-	Array get_message() {
-		MutexLock lock(mutex);
-		ERR_FAIL_COND_V(!has_message(), Array());
-		Array out = in_queue[0];
-		in_queue.pop_front();
-		return out;
-	}
-
-	Error put_message(const Array p_arr) {
-		MutexLock lock(mutex);
-		if (out_queue.size() > QUEUE_MAX) {
-			return ERR_OUT_OF_MEMORY;
-		}
-		out_queue.push_back(p_arr);
-		return OK;
-	}
-
-	int get_max_message_size() const {
-		return 8 << 20; // 8 MiB
-	}
-
-	bool is_peer_connected() {
-		return connected;
-	}
-
-	void close() {
-		MutexLock lock(mutex);
-		connected = false;
-		tcp->disconnect_from_host();
-	}
-
-	EditorDebuggerPeerTCP(Ref<StreamPeerTCP> p_stream) {
-		packet_peer.instance();
-		tcp = p_stream;
-		if (tcp.is_null()) {
-			tcp.instance(); // Bug?
-		}
-		packet_peer->set_stream_peer(tcp);
-	}
-
-	~EditorDebuggerPeerTCP() {
-		close();
-		packet_peer->set_stream_peer(Ref<StreamPeer>());
-	}
-};
-
 class EditorDebuggerServerTCP : public EditorDebuggerServer {
 
 private:
 	Ref<TCP_Server> server;
-	List<Ref<EditorDebuggerPeer> > peers;
-	Thread *thread = NULL;
-	Mutex mutex;
-	bool running = false;
-
-	static void _poll_func(void *p_ud);
 
 public:
+	virtual void poll() {}
 	virtual Error start();
 	virtual void stop();
 	virtual bool is_active() const;
 	virtual bool is_connection_available() const;
-	virtual Ref<EditorDebuggerPeer> take_connection();
+	virtual Ref<RemoteDebuggerPeer> take_connection();
 
 	EditorDebuggerServerTCP();
 };
@@ -161,19 +65,11 @@ Error EditorDebuggerServerTCP::start() {
 		EditorNode::get_log()->add_message(String("Error listening on port ") + itos(remote_port), EditorLog::MSG_TYPE_ERROR);
 		return err;
 	}
-	running = true;
-	thread = Thread::create(_poll_func, this);
 	return err;
 }
 
 void EditorDebuggerServerTCP::stop() {
 	server->stop();
-	if (thread != NULL) {
-		running = false;
-		Thread::wait_to_finish(thread);
-		memdelete(thread);
-		thread = NULL;
-	}
 }
 
 bool EditorDebuggerServerTCP::is_active() const {
@@ -184,31 +80,9 @@ bool EditorDebuggerServerTCP::is_connection_available() const {
 	return server->is_listening() && server->is_connection_available();
 }
 
-Ref<EditorDebuggerPeer> EditorDebuggerServerTCP::take_connection() {
-	ERR_FAIL_COND_V(!is_connection_available(), Ref<EditorDebuggerPeer>());
-	MutexLock lock(mutex);
-	Ref<EditorDebuggerPeerTCP> peer = memnew(EditorDebuggerPeerTCP(server->take_connection()));
-	peers.push_back(peer);
-	return peer;
-}
-
-void EditorDebuggerServerTCP::_poll_func(void *p_ud) {
-	EditorDebuggerServerTCP *me = (EditorDebuggerServerTCP *)p_ud;
-	while (me->running) {
-		me->mutex.lock();
-		List<Ref<EditorDebuggerPeer> > remove;
-		for (int i = 0; i < me->peers.size(); i++) {
-			Ref<EditorDebuggerPeer> peer = me->peers[i];
-			Error err = ((EditorDebuggerPeerTCP *)peer.ptr())->poll();
-			if (err != OK || !peer->is_peer_connected())
-				remove.push_back(peer);
-		}
-		for (List<Ref<EditorDebuggerPeer> >::Element *E = remove.front(); E; E = E->next()) {
-			me->peers.erase(E->get());
-		}
-		me->mutex.unlock();
-		OS::get_singleton()->delay_usec(50);
-	}
+Ref<RemoteDebuggerPeer> EditorDebuggerServerTCP::take_connection() {
+	ERR_FAIL_COND_V(!is_connection_available(), Ref<RemoteDebuggerPeer>());
+	return memnew(RemoteDebuggerPeerTCP(server->take_connection()));
 }
 
 EditorDebuggerServer *EditorDebuggerServer::create_default() {
diff --git a/editor/debugger/editor_debugger_server.h b/editor/debugger/editor_debugger_server.h
index 4594a8decf..e9798c90b3 100644
--- a/editor/debugger/editor_debugger_server.h
+++ b/editor/debugger/editor_debugger_server.h
@@ -31,29 +31,19 @@
 #ifndef EDITOR_DEBUGGER_CONNECTION_H
 #define EDITOR_DEBUGGER_CONNECTION_H
 
+#include "core/debugger/remote_debugger_peer.h"
 #include "core/reference.h"
 
-class EditorDebuggerPeer : public Reference {
-
-public:
-	virtual bool has_message() = 0;
-	virtual Array get_message() = 0;
-	virtual Error put_message(const Array p_arr) = 0;
-
-	virtual int get_max_message_size() const = 0;
-	virtual bool is_peer_connected() = 0;
-	virtual void close() = 0;
-};
-
 class EditorDebuggerServer : public Reference {
 
 public:
 	static EditorDebuggerServer *create_default();
+	virtual void poll() = 0;
 	virtual Error start() = 0;
 	virtual void stop() = 0;
 	virtual bool is_active() const = 0;
 	virtual bool is_connection_available() const = 0;
-	virtual Ref<EditorDebuggerPeer> take_connection() = 0;
+	virtual Ref<RemoteDebuggerPeer> take_connection() = 0;
 };
 
 #endif // EDITOR_DEBUGGER_CONNECTION_H
diff --git a/editor/debugger/editor_network_profiler.cpp b/editor/debugger/editor_network_profiler.cpp
new file mode 100644
index 0000000000..21ef66d1aa
--- /dev/null
+++ b/editor/debugger/editor_network_profiler.cpp
@@ -0,0 +1,208 @@
+/*************************************************************************/
+/*  editor_network_profiler.cpp                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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_network_profiler.h"
+
+#include "core/os/os.h"
+#include "editor/editor_scale.h"
+#include "editor/editor_settings.h"
+
+void EditorNetworkProfiler::_bind_methods() {
+	ADD_SIGNAL(MethodInfo("enable_profiling", PropertyInfo(Variant::BOOL, "enable")));
+}
+
+void EditorNetworkProfiler::_notification(int p_what) {
+
+	if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) {
+		activate->set_icon(get_icon("Play", "EditorIcons"));
+		clear_button->set_icon(get_icon("Clear", "EditorIcons"));
+		incoming_bandwidth_text->set_right_icon(get_icon("ArrowDown", "EditorIcons"));
+		outgoing_bandwidth_text->set_right_icon(get_icon("ArrowUp", "EditorIcons"));
+
+		// This needs to be done here to set the faded color when the profiler is first opened
+		incoming_bandwidth_text->add_color_override("font_color_uneditable", get_color("font_color", "Editor") * Color(1, 1, 1, 0.5));
+		outgoing_bandwidth_text->add_color_override("font_color_uneditable", get_color("font_color", "Editor") * Color(1, 1, 1, 0.5));
+	}
+}
+
+void EditorNetworkProfiler::_update_frame() {
+
+	counters_display->clear();
+
+	TreeItem *root = counters_display->create_item();
+
+	for (Map<ObjectID, DebuggerMarshalls::MultiplayerNodeInfo>::Element *E = nodes_data.front(); E; E = E->next()) {
+
+		TreeItem *node = counters_display->create_item(root);
+
+		for (int j = 0; j < counters_display->get_columns(); ++j) {
+			node->set_text_align(j, j > 0 ? TreeItem::ALIGN_RIGHT : TreeItem::ALIGN_LEFT);
+		}
+
+		node->set_text(0, E->get().node_path);
+		node->set_text(1, E->get().incoming_rpc == 0 ? "-" : itos(E->get().incoming_rpc));
+		node->set_text(2, E->get().incoming_rset == 0 ? "-" : itos(E->get().incoming_rset));
+		node->set_text(3, E->get().outgoing_rpc == 0 ? "-" : itos(E->get().outgoing_rpc));
+		node->set_text(4, E->get().outgoing_rset == 0 ? "-" : itos(E->get().outgoing_rset));
+	}
+}
+
+void EditorNetworkProfiler::_activate_pressed() {
+
+	if (activate->is_pressed()) {
+		activate->set_icon(get_icon("Stop", "EditorIcons"));
+		activate->set_text(TTR("Stop"));
+	} else {
+		activate->set_icon(get_icon("Play", "EditorIcons"));
+		activate->set_text(TTR("Start"));
+	}
+	emit_signal("enable_profiling", activate->is_pressed());
+}
+
+void EditorNetworkProfiler::_clear_pressed() {
+	nodes_data.clear();
+	set_bandwidth(0, 0);
+	if (frame_delay->is_stopped()) {
+		frame_delay->set_wait_time(0.1);
+		frame_delay->start();
+	}
+}
+
+void EditorNetworkProfiler::add_node_frame_data(const DebuggerMarshalls::MultiplayerNodeInfo p_frame) {
+
+	if (!nodes_data.has(p_frame.node)) {
+		nodes_data.insert(p_frame.node, p_frame);
+	} else {
+		nodes_data[p_frame.node].incoming_rpc += p_frame.incoming_rpc;
+		nodes_data[p_frame.node].incoming_rset += p_frame.incoming_rset;
+		nodes_data[p_frame.node].outgoing_rpc += p_frame.outgoing_rpc;
+		nodes_data[p_frame.node].outgoing_rset += p_frame.outgoing_rset;
+	}
+
+	if (frame_delay->is_stopped()) {
+		frame_delay->set_wait_time(0.1);
+		frame_delay->start();
+	}
+}
+
+void EditorNetworkProfiler::set_bandwidth(int p_incoming, int p_outgoing) {
+
+	incoming_bandwidth_text->set_text(vformat(TTR("%s/s"), String::humanize_size(p_incoming)));
+	outgoing_bandwidth_text->set_text(vformat(TTR("%s/s"), String::humanize_size(p_outgoing)));
+
+	// Make labels more prominent when the bandwidth is greater than 0 to attract user attention
+	incoming_bandwidth_text->add_color_override(
+			"font_color_uneditable",
+			get_color("font_color", "Editor") * Color(1, 1, 1, p_incoming > 0 ? 1 : 0.5));
+	outgoing_bandwidth_text->add_color_override(
+			"font_color_uneditable",
+			get_color("font_color", "Editor") * Color(1, 1, 1, p_outgoing > 0 ? 1 : 0.5));
+}
+
+bool EditorNetworkProfiler::is_profiling() {
+	return activate->is_pressed();
+}
+
+EditorNetworkProfiler::EditorNetworkProfiler() {
+
+	HBoxContainer *hb = memnew(HBoxContainer);
+	hb->add_constant_override("separation", 8 * EDSCALE);
+	add_child(hb);
+
+	activate = memnew(Button);
+	activate->set_toggle_mode(true);
+	activate->set_text(TTR("Start"));
+	activate->connect("pressed", callable_mp(this, &EditorNetworkProfiler::_activate_pressed));
+	hb->add_child(activate);
+
+	clear_button = memnew(Button);
+	clear_button->set_text(TTR("Clear"));
+	clear_button->connect("pressed", callable_mp(this, &EditorNetworkProfiler::_clear_pressed));
+	hb->add_child(clear_button);
+
+	hb->add_spacer();
+
+	Label *lb = memnew(Label);
+	lb->set_text(TTR("Down"));
+	hb->add_child(lb);
+
+	incoming_bandwidth_text = memnew(LineEdit);
+	incoming_bandwidth_text->set_editable(false);
+	incoming_bandwidth_text->set_custom_minimum_size(Size2(120, 0) * EDSCALE);
+	incoming_bandwidth_text->set_align(LineEdit::Align::ALIGN_RIGHT);
+	hb->add_child(incoming_bandwidth_text);
+
+	Control *down_up_spacer = memnew(Control);
+	down_up_spacer->set_custom_minimum_size(Size2(30, 0) * EDSCALE);
+	hb->add_child(down_up_spacer);
+
+	lb = memnew(Label);
+	lb->set_text(TTR("Up"));
+	hb->add_child(lb);
+
+	outgoing_bandwidth_text = memnew(LineEdit);
+	outgoing_bandwidth_text->set_editable(false);
+	outgoing_bandwidth_text->set_custom_minimum_size(Size2(120, 0) * EDSCALE);
+	outgoing_bandwidth_text->set_align(LineEdit::Align::ALIGN_RIGHT);
+	hb->add_child(outgoing_bandwidth_text);
+
+	// Set initial texts in the incoming/outgoing bandwidth labels
+	set_bandwidth(0, 0);
+
+	counters_display = memnew(Tree);
+	counters_display->set_custom_minimum_size(Size2(300, 0) * EDSCALE);
+	counters_display->set_v_size_flags(SIZE_EXPAND_FILL);
+	counters_display->set_hide_folding(true);
+	counters_display->set_hide_root(true);
+	counters_display->set_columns(5);
+	counters_display->set_column_titles_visible(true);
+	counters_display->set_column_title(0, TTR("Node"));
+	counters_display->set_column_expand(0, true);
+	counters_display->set_column_min_width(0, 60 * EDSCALE);
+	counters_display->set_column_title(1, TTR("Incoming RPC"));
+	counters_display->set_column_expand(1, false);
+	counters_display->set_column_min_width(1, 120 * EDSCALE);
+	counters_display->set_column_title(2, TTR("Incoming RSET"));
+	counters_display->set_column_expand(2, false);
+	counters_display->set_column_min_width(2, 120 * EDSCALE);
+	counters_display->set_column_title(3, TTR("Outgoing RPC"));
+	counters_display->set_column_expand(3, false);
+	counters_display->set_column_min_width(3, 120 * EDSCALE);
+	counters_display->set_column_title(4, TTR("Outgoing RSET"));
+	counters_display->set_column_expand(4, false);
+	counters_display->set_column_min_width(4, 120 * EDSCALE);
+	add_child(counters_display);
+
+	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, &EditorNetworkProfiler::_update_frame));
+}
diff --git a/editor/debugger/editor_network_profiler.h b/editor/debugger/editor_network_profiler.h
new file mode 100644
index 0000000000..f532dc5dd0
--- /dev/null
+++ b/editor/debugger/editor_network_profiler.h
@@ -0,0 +1,73 @@
+/*************************************************************************/
+/*  editor_network_profiler.h                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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.                */
+/*************************************************************************/
+
+#ifndef EDITORNETWORKPROFILER_H
+#define EDITORNETWORKPROFILER_H
+
+#include "core/debugger/debugger_marshalls.h"
+#include "scene/gui/box_container.h"
+#include "scene/gui/button.h"
+#include "scene/gui/label.h"
+#include "scene/gui/split_container.h"
+#include "scene/gui/tree.h"
+
+class EditorNetworkProfiler : public VBoxContainer {
+
+	GDCLASS(EditorNetworkProfiler, VBoxContainer)
+
+private:
+	Button *activate;
+	Button *clear_button;
+	Tree *counters_display;
+	LineEdit *incoming_bandwidth_text;
+	LineEdit *outgoing_bandwidth_text;
+
+	Timer *frame_delay;
+
+	Map<ObjectID, DebuggerMarshalls::MultiplayerNodeInfo> nodes_data;
+
+	void _update_frame();
+
+	void _activate_pressed();
+	void _clear_pressed();
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	void add_node_frame_data(const DebuggerMarshalls::MultiplayerNodeInfo p_frame);
+	void set_bandwidth(int p_incoming, int p_outgoing);
+	bool is_profiling();
+
+	EditorNetworkProfiler();
+};
+
+#endif //EDITORNETWORKPROFILER_H
diff --git a/editor/debugger/editor_profiler.cpp b/editor/debugger/editor_profiler.cpp
new file mode 100644
index 0000000000..2f3ad210b2
--- /dev/null
+++ b/editor/debugger/editor_profiler.cpp
@@ -0,0 +1,773 @@
+/*************************************************************************/
+/*  editor_profiler.cpp                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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_profiler.h"
+
+#include "core/os/os.h"
+#include "editor/editor_scale.h"
+#include "editor/editor_settings.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.write[i];
+		for (int j = 0; j < m.categories[i].items.size(); j++) {
+			m.item_ptrs[m.categories[i].items[j].signature] = &m.categories.write[i].items.write[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.write[last_metric] = p_metric;
+	_make_metric_ptrs(frame_metrics.write[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_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(p_final ? 0.1 : 1);
+		frame_delay->start();
+	}
+
+	if (plot_delay->is_stopped()) {
+		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();
+	plot_sigs.clear();
+	plot_sigs.insert("physics_frame_time");
+	plot_sigs.insert("category_frame_time");
+
+	updating_frame = true;
+	cursor_metric_edit->set_min(0);
+	cursor_metric_edit->set_max(100); // Doesn't make much sense, but we can't have min == max. Doesn't hurt.
+	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 EditorProfiler::_get_time_as_text(const Metric &m, float p_time, int p_calls) {
+
+	const int dmode = display_mode->get_selected();
+
+	if (dmode == DISPLAY_FRAME_TIME) {
+		return rtos(p_time * 1000).pad_decimals(2) + " ms";
+	} else if (dmode == DISPLAY_AVERAGE_TIME) {
+		if (p_calls == 0) {
+			return "0.00 ms";
+		} else {
+			return rtos((p_time / p_calls) * 1000).pad_decimals(2) + " ms";
+		}
+	} else if (dmode == DISPLAY_FRAME_PERCENT) {
+		return _get_percent_txt(p_time, m.frame_time);
+	} else if (dmode == DISPLAY_PHYSICS_FRAME_PERCENT) {
+		return _get_percent_txt(p_time, m.physics_frame_time);
+	}
+
+	return "err";
+}
+
+Color EditorProfiler::_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 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();
+	}
+
+	_update_plot();
+}
+
+void EditorProfiler::_update_plot() {
+
+	const int w = graph->get_size().width;
+	const int h = graph->get_size().height;
+	bool reset_texture = false;
+	const 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();
+	const Color background_color = get_color("dark_color_2", "Editor");
+
+	// Clear the previous frame and set the background color.
+	for (int i = 0; i < desired_len; i += 4) {
+		wr[i + 0] = Math::fast_ftoi(background_color.r * 255);
+		wr[i + 1] = Math::fast_ftoi(background_color.g * 255);
+		wr[i + 2] = Math::fast_ftoi(background_color.b * 255);
+		wr[i + 3] = 255;
+	}
+
+	//find highest value
+
+	const bool use_self = display_time->get_selected() == DISPLAY_SELF_TIME;
+	float highest = 0;
+
+	for (int i = 0; i < frame_metrics.size(); i++) {
+		const Metric &m = frame_metrics[i];
+		if (!m.valid)
+			continue;
+
+		for (Set<StringName>::Element *E = plot_sigs.front(); E; E = E->next()) {
+
+			const Map<StringName, Metric::Category *>::Element *F = m.category_ptrs.find(E->get());
+			if (F) {
+				highest = MAX(F->get()->total_time, highest);
+			}
+
+			const 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.ptrw();
+
+		Map<StringName, int> plot_prev;
+		//Map<StringName,int> plot_max;
+
+		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
+					const Metric &m = frame_metrics[idx];
+					if (!m.valid)
+						continue; //skip because invalid
+
+					float value = 0;
+
+					const Map<StringName, Metric::Category *>::Element *F = m.category_ptrs.find(E->get());
+					if (F) {
+						value = F->get()->total_time;
+					}
+
+					const 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) {
+
+				const int a = column[j + 3];
+				if (a > 0) {
+					column[j + 0] /= a;
+					column[j + 1] /= a;
+					column[j + 2] /= a;
+				}
+
+				const uint8_t red = uint8_t(column[j + 0]);
+				const uint8_t green = uint8_t(column[j + 1]);
+				const uint8_t blue = uint8_t(column[j + 2]);
+				const bool is_filled = red >= 1 || green >= 1 || blue >= 1;
+				const int widx = ((j >> 2) * w + i) * 4;
+
+				// If the pixel isn't filled by any profiler line, apply the background color instead.
+				wr[widx + 0] = is_filled ? red : Math::fast_ftoi(background_color.r * 255);
+				wr[widx + 1] = is_filled ? green : Math::fast_ftoi(background_color.g * 255);
+				wr[widx + 2] = is_filled ? blue : Math::fast_ftoi(background_color.b * 255);
+				wr[widx + 3] = 255;
+			}
+		}
+	}
+
+	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 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();
+	const 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_color(0, _get_color_from_signature(m.categories[i].signature));
+		}
+
+		for (int j = m.categories[i].items.size() - 1; j >= 0; j--) {
+			const 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_text_align(2, TreeItem::ALIGN_RIGHT);
+			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_color(0, _get_color_from_signature(it.signature));
+			}
+		}
+	}
+
+	updating_frame = false;
+}
+
+void EditorProfiler::_activate_pressed() {
+
+	if (activate->is_pressed()) {
+		activate->set_icon(get_icon("Stop", "EditorIcons"));
+		activate->set_text(TTR("Stop"));
+	} else {
+		activate->set_icon(get_icon("Play", "EditorIcons"));
+		activate->set_text(TTR("Start"));
+	}
+	emit_signal("enable_profiling", activate->is_pressed());
+}
+
+void EditorProfiler::_clear_pressed() {
+
+	clear();
+	_update_plot();
+}
+
+void EditorProfiler::_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 EditorProfiler::_graph_tex_draw() {
+
+	if (last_metric < 0)
+		return;
+	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 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 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 x = me->get_position().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 (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)
+				cursor_metric_edit->set_value(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_value());
+
+	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() {
+
+	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();
+}
+
+Vector<Vector<String> > EditorProfiler::get_data_as_csv() const {
+	Vector<Vector<String> > res;
+
+	if (frame_metrics.empty()) {
+		return res;
+	}
+
+	// signatures
+	Vector<String> signatures;
+	const Vector<EditorProfiler::Metric::Category> &categories = frame_metrics[0].categories;
+
+	for (int j = 0; j < categories.size(); j++) {
+
+		const EditorProfiler::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<EditorProfiler::Metric::Category> &frame_cat = frame_metrics[index].categories;
+
+		for (int j = 0; j < frame_cat.size(); j++) {
+
+			const EditorProfiler::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);
+	}
+
+	return res;
+}
+
+EditorProfiler::EditorProfiler() {
+
+	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, &EditorProfiler::_activate_pressed));
+	hb->add_child(activate);
+
+	clear_button = memnew(Button);
+	clear_button->set_text(TTR("Clear"));
+	clear_button->connect("pressed", callable_mp(this, &EditorProfiler::_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 (sec)"));
+	display_mode->add_item(TTR("Average Time (sec)"));
+	display_mode->add_item(TTR("Frame %"));
+	display_mode->add_item(TTR("Physics Frame %"));
+	display_mode->connect("item_selected", callable_mp(this, &EditorProfiler::_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", callable_mp(this, &EditorProfiler::_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", callable_mp(this, &EditorProfiler::_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(320, 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 * EDSCALE);
+	variables->set_column_title(1, TTR("Time"));
+	variables->set_column_expand(1, false);
+	variables->set_column_min_width(1, 100 * EDSCALE);
+	variables->set_column_title(2, TTR("Calls"));
+	variables->set_column_expand(2, false);
+	variables->set_column_min_width(2, 60 * EDSCALE);
+	variables->connect("item_edited", callable_mp(this, &EditorProfiler::_item_edited));
+
+	graph = memnew(TextureRect);
+	graph->set_expand(true);
+	graph->set_mouse_filter(MOUSE_FILTER_STOP);
+	graph->connect("draw", callable_mp(this, &EditorProfiler::_graph_tex_draw));
+	graph->connect("gui_input", callable_mp(this, &EditorProfiler::_graph_tex_input));
+	graph->connect("mouse_exited", callable_mp(this, &EditorProfiler::_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;
+	hover_metric = -1;
+
+	EDITOR_DEF("debugger/profiler_frame_max_functions", 64);
+
+	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, &EditorProfiler::_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", callable_mp(this, &EditorProfiler::_update_plot));
+
+	plot_sigs.insert("physics_frame_time");
+	plot_sigs.insert("category_frame_time");
+
+	seeking = false;
+	graph_height = 1;
+}
diff --git a/editor/debugger/editor_profiler.h b/editor/debugger/editor_profiler.h
new file mode 100644
index 0000000000..0a442ddd5c
--- /dev/null
+++ b/editor/debugger/editor_profiler.h
@@ -0,0 +1,177 @@
+/*************************************************************************/
+/*  editor_profiler.h                                                    */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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.                */
+/*************************************************************************/
+
+#ifndef EDITORPROFILER_H
+#define EDITORPROFILER_H
+
+#include "scene/gui/box_container.h"
+#include "scene/gui/button.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 EditorProfiler : public VBoxContainer {
+
+	GDCLASS(EditorProfiler, VBoxContainer);
+
+public:
+	struct Metric {
+
+		bool valid;
+
+		int frame_number;
+		float frame_time;
+		float idle_time;
+		float physics_time;
+		float physics_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_PHYSICS_FRAME_PERCENT,
+	};
+
+	enum DisplayTime {
+		DISPLAY_TOTAL_TIME,
+		DISPLAY_SELF_TIME,
+	};
+
+private:
+	Button *activate;
+	Button *clear_button;
+	TextureRect *graph;
+	Ref<ImageTexture> graph_texture;
+	Vector<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;
+
+	float graph_height;
+
+	bool seeking;
+
+	Timer *frame_delay;
+	Timer *plot_delay;
+
+	void _update_frame();
+
+	void _activate_pressed();
+	void _clear_pressed();
+
+	String _get_time_as_text(const 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 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, bool p_final = false);
+	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;
+
+	EditorProfiler();
+};
+
+#endif // EDITORPROFILER_H
diff --git a/editor/debugger/editor_visual_profiler.cpp b/editor/debugger/editor_visual_profiler.cpp
new file mode 100644
index 0000000000..52aa418922
--- /dev/null
+++ b/editor/debugger/editor_visual_profiler.cpp
@@ -0,0 +1,842 @@
+/*************************************************************************/
+/*  editor_visual_profiler.cpp                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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 rtos(p_time) + "ms";
+	} else if (dmode == DISPLAY_FRAME_PERCENT) {
+		return String::num(p_time * 100 / graph_limit, 2) + "%";
+	}
+
+	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);
+	}
+
+	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.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) {
+					// 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.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_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", 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);
+}
diff --git a/editor/debugger/editor_visual_profiler.h b/editor/debugger/editor_visual_profiler.h
new file mode 100644
index 0000000000..5194c08b96
--- /dev/null
+++ b/editor/debugger/editor_visual_profiler.h
@@ -0,0 +1,154 @@
+/*************************************************************************/
+/*  editor_visual_profiler.h                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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.                */
+/*************************************************************************/
+
+#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;
+	Vector<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/debugger/script_editor_debugger.cpp b/editor/debugger/script_editor_debugger.cpp
index 299f504f1e..920f4d858a 100644
--- a/editor/debugger/script_editor_debugger.cpp
+++ b/editor/debugger/script_editor_debugger.cpp
@@ -30,17 +30,17 @@
 
 #include "script_editor_debugger.h"
 
+#include "core/debugger/debugger_marshalls.h"
 #include "core/io/marshalls.h"
 #include "core/project_settings.h"
-#include "core/script_debugger_remote.h"
 #include "core/ustring.h"
+#include "editor/debugger/editor_network_profiler.h"
+#include "editor/debugger/editor_profiler.h"
+#include "editor/debugger/editor_visual_profiler.h"
 #include "editor/editor_log.h"
-#include "editor/editor_network_profiler.h"
 #include "editor/editor_node.h"
-#include "editor/editor_profiler.h"
 #include "editor/editor_scale.h"
 #include "editor/editor_settings.h"
-#include "editor/editor_visual_profiler.h"
 #include "editor/plugins/canvas_item_editor_plugin.h"
 #include "editor/plugins/spatial_editor_plugin.h"
 #include "editor/property_editor.h"
@@ -144,7 +144,7 @@ void ScriptEditorDebugger::save_node(ObjectID p_id, const String &p_file) {
 	Array msg;
 	msg.push_back(p_id);
 	msg.push_back(p_file);
-	_put_msg("save_node", msg);
+	_put_msg("scene:save_node", msg);
 }
 
 void ScriptEditorDebugger::_file_selected(const String &p_file) {
@@ -186,7 +186,7 @@ void ScriptEditorDebugger::_file_selected(const String &p_file) {
 
 void ScriptEditorDebugger::request_remote_tree() {
 
-	_put_msg("request_scene_tree", Array());
+	_put_msg("scene:request_scene_tree", Array());
 }
 
 const SceneDebuggerTree *ScriptEditorDebugger::get_remote_tree() {
@@ -199,7 +199,7 @@ void ScriptEditorDebugger::update_remote_object(ObjectID p_obj_id, const String
 	msg.push_back(p_obj_id);
 	msg.push_back(p_prop);
 	msg.push_back(p_value);
-	_put_msg("set_object_property", msg);
+	_put_msg("scene:set_object_property", msg);
 }
 
 void ScriptEditorDebugger::request_remote_object(ObjectID p_obj_id) {
@@ -207,7 +207,7 @@ void ScriptEditorDebugger::request_remote_object(ObjectID p_obj_id) {
 	ERR_FAIL_COND(p_obj_id.is_null());
 	Array msg;
 	msg.push_back(p_obj_id);
-	_put_msg("inspect_object", msg);
+	_put_msg("scene:inspect_object", msg);
 }
 
 Object *ScriptEditorDebugger::get_remote_object(ObjectID p_id) {
@@ -229,7 +229,7 @@ void ScriptEditorDebugger::_remote_object_property_updated(ObjectID p_id, const
 
 void ScriptEditorDebugger::_video_mem_request() {
 
-	_put_msg("request_video_mem", Array());
+	_put_msg("core:memory", Array());
 }
 
 Size2 ScriptEditorDebugger::get_minimum_size() const {
@@ -270,36 +270,36 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
 		emit_signal("breaked", false, false);
 		profiler->set_enabled(true);
 		profiler->disable_seeking();
-	} else if (p_msg == "message:set_pid") {
+	} else if (p_msg == "set_pid") {
 
 		ERR_FAIL_COND(p_data.size() < 1);
 		remote_pid = p_data[0];
-	} else if (p_msg == "message:click_ctrl") {
+	} else if (p_msg == "scene:click_ctrl") {
 
 		ERR_FAIL_COND(p_data.size() < 2);
 		clicked_ctrl->set_text(p_data[0]);
 		clicked_ctrl_type->set_text(p_data[1]);
-	} else if (p_msg == "message:scene_tree") {
+	} else if (p_msg == "scene:scene_tree") {
 
 		scene_tree->nodes.clear();
 		scene_tree->deserialize(p_data);
 		emit_signal("remote_tree_updated");
 		_update_buttons_state();
-	} else if (p_msg == "message:inspect_object") {
+	} else if (p_msg == "scene:inspect_object") {
 
 		ObjectID id = inspector->add_object(p_data);
 		if (id.is_valid())
 			emit_signal("remote_object_updated", id);
-	} else if (p_msg == "message:video_mem") {
+	} else if (p_msg == "memory:usage") {
 
 		vmem_tree->clear();
 		TreeItem *root = vmem_tree->create_item();
-		ScriptDebuggerRemote::ResourceUsage usage;
+		DebuggerMarshalls::ResourceUsage usage;
 		usage.deserialize(p_data);
 
 		int total = 0;
 
-		for (List<ScriptDebuggerRemote::ResourceInfo>::Element *E = usage.infos.front(); E; E = E->next()) {
+		for (List<DebuggerMarshalls::ResourceInfo>::Element *E = usage.infos.front(); E; E = E->next()) {
 
 			TreeItem *it = vmem_tree->create_item(root);
 			String type = E->get().type;
@@ -319,7 +319,7 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
 
 	} else if (p_msg == "stack_dump") {
 
-		ScriptDebuggerRemote::ScriptStackDump stack;
+		DebuggerMarshalls::ScriptStackDump stack;
 		stack.deserialize(p_data);
 
 		stack_dump->clear();
@@ -352,10 +352,10 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
 
 	} else if (p_msg == "output") {
 		ERR_FAIL_COND(p_data.size() < 1);
-		String t = p_data[0];
-		EditorNode::get_log()->add_message(t);
-
-	} else if (p_msg == "performance") {
+		ERR_FAIL_COND(p_data[0].get_type() != Variant::PACKED_STRING_ARRAY);
+		Vector<String> strings = p_data[0];
+		EditorNode::get_log()->add_message(String("\n").join(strings));
+	} else if (p_msg == "performance:profile_frame") {
 		Vector<float> p;
 		p.resize(p_data.size());
 		for (int i = 0; i < p_data.size(); i++) {
@@ -388,36 +388,28 @@ 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") {
-		// TODO check me.
-		uint64_t frame = p_data[0];
-		Vector<String> names = p_data[1];
-		Vector<real_t> values = p_data[2];
+	} else if (p_msg == "visual:profile_frame") {
+		DebuggerMarshalls::VisualProfilerFrame frame;
+		frame.deserialize(p_data);
 
 		EditorVisualProfiler::Metric metric;
-		metric.areas.resize(names.size());
-		metric.frame_number = frame;
+		metric.areas.resize(frame.areas.size());
+		metric.frame_number = frame.frame_number;
 		metric.valid = true;
 
 		{
 			EditorVisualProfiler::Metric::Area *areas_ptr = metric.areas.ptrw();
-			int metric_count = names.size();
-
-			const String *rs = names.ptr();
-			const real_t *rr = values.ptr();
-
-			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];
+			for (int i = 0; i < frame.areas.size(); i++) {
+				areas_ptr[i].name = frame.areas[i].name;
+				areas_ptr[i].cpu_time = frame.areas[i].cpu_msec;
+				areas_ptr[i].gpu_time = frame.areas[i].gpu_msec;
 			}
 		}
 		visual_profiler->add_frame_metric(metric);
 
 	} else if (p_msg == "error") {
 
-		ScriptDebuggerRemote::OutputError oe;
+		DebuggerMarshalls::OutputError oe;
 		ERR_FAIL_COND_MSG(oe.deserialize(p_data) == false, "Failed to deserialize error message");
 
 		// Format time.
@@ -523,15 +515,15 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
 		else
 			error_count++;
 
-	} else if (p_msg == "profile_sig") {
+	} else if (p_msg == "servers:function_signature") {
 		// Cache a profiler signature.
-		ScriptDebuggerRemote::ProfilerSignature sig;
+		DebuggerMarshalls::ScriptFunctionSignature sig;
 		sig.deserialize(p_data);
 		profiler_signature[sig.id] = sig.name;
 
-	} else if (p_msg == "profile_frame" || p_msg == "profile_total") {
+	} else if (p_msg == "servers:profile_frame" || p_msg == "servers:profile_total") {
 		EditorProfiler::Metric metric;
-		ScriptDebuggerRemote::ProfilerFrame frame;
+		DebuggerMarshalls::ServersProfilerFrame frame;
 		frame.deserialize(p_data);
 		metric.valid = true;
 		metric.frame_number = frame.frame_number;
@@ -539,10 +531,8 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
 		metric.idle_time = frame.idle_time;
 		metric.physics_time = frame.physics_time;
 		metric.physics_frame_time = frame.physics_frame_time;
-		int frame_data_amount = frame.frames_data.size();
-		int frame_function_amount = frame.frame_functions.size();
 
-		if (frame_data_amount) {
+		if (frame.servers.size()) {
 			EditorProfiler::Metric::Category frame_time;
 			frame_time.signature = "category_frame_time";
 			frame_time.name = "Frame Time";
@@ -576,42 +566,42 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
 			metric.categories.push_back(frame_time);
 		}
 
-		for (int i = 0; i < frame_data_amount; i++) {
+		for (int i = 0; i < frame.servers.size(); i++) {
 
+			const DebuggerMarshalls::ServerInfo &srv = frame.servers[i];
 			EditorProfiler::Metric::Category c;
-			String name = frame.frames_data[i].name;
-			Array values = frame.frames_data[i].data;
+			const String name = srv.name;
 			c.name = name.capitalize();
-			c.items.resize(values.size() / 2);
+			c.items.resize(srv.functions.size());
 			c.total_time = 0;
 			c.signature = "categ::" + name;
-			for (int j = 0; j < values.size(); j += 2) {
+			for (int j = 0; j < srv.functions.size(); j++) {
 
 				EditorProfiler::Metric::Category::Item item;
 				item.calls = 1;
 				item.line = 0;
-				item.name = values[j];
-				item.self = values[j + 1];
+				item.name = srv.functions[j].name;
+				item.self = srv.functions[j].time;
 				item.total = item.self;
 				item.signature = "categ::" + name + "::" + item.name;
 				item.name = item.name.capitalize();
 				c.total_time += item.total;
-				c.items.write[j / 2] = item;
+				c.items.write[j] = item;
 			}
 			metric.categories.push_back(c);
 		}
 
 		EditorProfiler::Metric::Category funcs;
 		funcs.total_time = frame.script_time;
-		funcs.items.resize(frame_function_amount);
+		funcs.items.resize(frame.script_functions.size());
 		funcs.name = "Script Functions";
 		funcs.signature = "script_functions";
-		for (int i = 0; i < frame_function_amount; i++) {
+		for (int i = 0; i < frame.script_functions.size(); i++) {
 
-			int signature = frame.frame_functions[i].sig_id;
-			int calls = frame.frame_functions[i].call_count;
-			float total = frame.frame_functions[i].total_time;
-			float self = frame.frame_functions[i].self_time;
+			int signature = frame.script_functions[i].sig_id;
+			int calls = frame.script_functions[i].call_count;
+			float total = frame.script_functions[i].total_time;
+			float self = frame.script_functions[i].self_time;
 
 			EditorProfiler::Metric::Category::Item item;
 			if (profiler_signature.has(signature)) {
@@ -642,24 +632,28 @@ void ScriptEditorDebugger::_parse_message(const String &p_msg, const Array &p_da
 
 		metric.categories.push_back(funcs);
 
-		if (p_msg == "profile_frame")
+		if (p_msg == "servers:profile_frame")
 			profiler->add_frame_metric(metric, false);
 		else
 			profiler->add_frame_metric(metric, true);
 
-	} else if (p_msg == "network_profile") {
-		ScriptDebuggerRemote::NetworkProfilerFrame frame;
+	} else if (p_msg == "network:profile_frame") {
+		DebuggerMarshalls::NetworkProfilerFrame frame;
 		frame.deserialize(p_data);
 		for (int i = 0; i < frame.infos.size(); i++) {
 			network_profiler->add_node_frame_data(frame.infos[i]);
 		}
-	} else if (p_msg == "network_bandwidth") {
+
+	} else if (p_msg == "network:bandwidth") {
 		ERR_FAIL_COND(p_data.size() < 2);
 		network_profiler->set_bandwidth(p_data[0], p_data[1]);
-	} else if (p_msg == "kill_me") {
 
+	} else if (p_msg == "request_quit") {
 		emit_signal("stop_requested");
 		_stop_and_notify();
+
+	} else {
+		WARN_PRINT("unknown message " + p_msg);
 	}
 }
 
@@ -792,7 +786,7 @@ void ScriptEditorDebugger::_notification(int p_what) {
 
 					Array msg;
 					msg.push_back(transform);
-					_put_msg("override_camera_2D:transform", msg);
+					_put_msg("scene:override_camera_2D:transform", msg);
 
 				} else if (camera_override >= CameraOverride::OVERRIDE_3D_1) {
 					int viewport_idx = camera_override - CameraOverride::OVERRIDE_3D_1;
@@ -810,7 +804,7 @@ void ScriptEditorDebugger::_notification(int p_what) {
 					}
 					msg.push_back(cam->get_znear());
 					msg.push_back(cam->get_zfar());
-					_put_msg("override_camera_3D:transform", msg);
+					_put_msg("scene:override_camera_3D:transform", msg);
 				}
 			}
 
@@ -863,13 +857,14 @@ void ScriptEditorDebugger::_clear_execution() {
 	inspector->clear_stack_variables();
 }
 
-void ScriptEditorDebugger::start(Ref<EditorDebuggerPeer> p_peer) {
+void ScriptEditorDebugger::start(Ref<RemoteDebuggerPeer> p_peer) {
 
 	error_count = 0;
 	warning_count = 0;
 	stop();
 
 	peer = p_peer;
+	ERR_FAIL_COND(p_peer.is_null());
 
 	perf_history.clear();
 	for (int i = 0; i < Performance::MONITOR_MAX; i++) {
@@ -885,14 +880,6 @@ void ScriptEditorDebugger::start(Ref<EditorDebuggerPeer> p_peer) {
 	tabs->set_current_tab(0);
 	_set_reason_text(TTR("Debug session started."), MESSAGE_SUCCESS);
 	_update_buttons_state();
-
-	if (profiler->is_profiling()) {
-		_profiler_activate(true);
-	}
-
-	if (network_profiler->is_profiling()) {
-		_network_profiler_activate(true);
-	}
 }
 
 void ScriptEditorDebugger::_update_buttons_state() {
@@ -939,46 +926,31 @@ void ScriptEditorDebugger::stop() {
 	_update_buttons_state();
 }
 
-void ScriptEditorDebugger::_profiler_activate(bool p_enable) {
-
-	if (p_enable) {
-		profiler_signature.clear();
-		Array msg;
-		int max_funcs = EditorSettings::get_singleton()->get("debugger/profiler_frame_max_functions");
-		max_funcs = CLAMP(max_funcs, 16, 512);
-		msg.push_back(max_funcs);
-		_put_msg("start_profiling", msg);
-		print_verbose("Starting profiling.");
-
-	} else {
-		_put_msg("stop_profiling", Array());
-		print_verbose("Ending profiling.");
-	}
-}
-
-void ScriptEditorDebugger::_visual_profiler_activate(bool p_enable) {
-
-	if (p_enable) {
-		profiler_signature.clear();
-		_put_msg("start_visual_profiling", Array());
-		print_verbose("Starting visual profiling.");
-
-	} else {
-		_put_msg("stop_visual_profiling", Array());
-		print_verbose("Ending visual profiling.");
-	}
-}
-
-void ScriptEditorDebugger::_network_profiler_activate(bool p_enable) {
+void ScriptEditorDebugger::_profiler_activate(bool p_enable, int p_type) {
 
-	if (p_enable) {
-		profiler_signature.clear();
-		_put_msg("start_network_profiling", Array());
-		print_verbose("Starting network profiling.");
-
-	} else {
-		_put_msg("stop_network_profiling", Array());
-		print_verbose("Ending network profiling.");
+	Array data;
+	data.push_back(p_enable);
+	switch (p_type) {
+		case PROFILER_NETWORK:
+			_put_msg("profiler:network", data);
+			break;
+		case PROFILER_VISUAL:
+			_put_msg("profiler:visual", data);
+			break;
+		case PROFILER_SCRIPTS_SERVERS:
+			if (p_enable) {
+				// Clear old script signatures. (should we move all this into the profiler?)
+				profiler_signature.clear();
+				// Add max funcs options to request.
+				Array opts;
+				int max_funcs = EditorSettings::get_singleton()->get("debugger/profiler_frame_max_functions");
+				opts.push_back(CLAMP(max_funcs, 16, 512));
+				data.push_back(opts);
+			}
+			_put_msg("profiler:servers", data);
+			break;
+		default:
+			ERR_FAIL_MSG("Invalid profiler type");
 	}
 }
 
@@ -1029,7 +1001,7 @@ int ScriptEditorDebugger::_get_node_path_cache(const NodePath &p_path) {
 	Array msg;
 	msg.push_back(p_path);
 	msg.push_back(last_path_id);
-	_put_msg("live_node_path", msg);
+	_put_msg("scene:live_node_path", msg);
 
 	return last_path_id;
 }
@@ -1047,7 +1019,7 @@ int ScriptEditorDebugger::_get_res_path_cache(const String &p_path) {
 	Array msg;
 	msg.push_back(p_path);
 	msg.push_back(last_path_id);
-	_put_msg("live_res_path", msg);
+	_put_msg("scene:live_res_path", msg);
 
 	return last_path_id;
 }
@@ -1079,7 +1051,7 @@ void ScriptEditorDebugger::_method_changed(Object *p_base, const StringName &p_n
 			//no pointers, sorry
 			msg.push_back(*argptr[i]);
 		}
-		_put_msg("live_node_call", msg);
+		_put_msg("scene:live_node_call", msg);
 
 		return;
 	}
@@ -1098,7 +1070,7 @@ void ScriptEditorDebugger::_method_changed(Object *p_base, const StringName &p_n
 			//no pointers, sorry
 			msg.push_back(*argptr[i]);
 		}
-		_put_msg("live_res_call", msg);
+		_put_msg("scene:live_res_call", msg);
 
 		return;
 	}
@@ -1124,7 +1096,7 @@ void ScriptEditorDebugger::_property_changed(Object *p_base, const StringName &p
 				msg.push_back(pathid);
 				msg.push_back(p_property);
 				msg.push_back(res->get_path());
-				_put_msg("live_node_prop_res", msg);
+				_put_msg("scene:live_node_prop_res", msg);
 			}
 		} else {
 
@@ -1132,7 +1104,7 @@ void ScriptEditorDebugger::_property_changed(Object *p_base, const StringName &p
 			msg.push_back(pathid);
 			msg.push_back(p_property);
 			msg.push_back(p_value);
-			_put_msg("live_node_prop", msg);
+			_put_msg("scene:live_node_prop", msg);
 		}
 
 		return;
@@ -1153,7 +1125,7 @@ void ScriptEditorDebugger::_property_changed(Object *p_base, const StringName &p
 				msg.push_back(pathid);
 				msg.push_back(p_property);
 				msg.push_back(res2->get_path());
-				_put_msg("live_res_prop_res", msg);
+				_put_msg("scene:live_res_prop_res", msg);
 			}
 		} else {
 
@@ -1161,7 +1133,7 @@ void ScriptEditorDebugger::_property_changed(Object *p_base, const StringName &p
 			msg.push_back(pathid);
 			msg.push_back(p_property);
 			msg.push_back(p_value);
-			_put_msg("live_res_prop", msg);
+			_put_msg("scene:live_res_prop", msg);
 		}
 
 		return;
@@ -1239,7 +1211,7 @@ void ScriptEditorDebugger::update_live_edit_root() {
 		msg.push_back(editor->get_edited_scene()->get_filename());
 	else
 		msg.push_back("");
-	_put_msg("live_set_root", msg);
+	_put_msg("scene:live_set_root", msg);
 	live_edit_root->set_text(np);
 }
 
@@ -1250,7 +1222,7 @@ void ScriptEditorDebugger::live_debug_create_node(const NodePath &p_parent, cons
 		msg.push_back(p_parent);
 		msg.push_back(p_type);
 		msg.push_back(p_name);
-		_put_msg("live_create_node", msg);
+		_put_msg("scene:live_create_node", msg);
 	}
 }
 
@@ -1261,7 +1233,7 @@ void ScriptEditorDebugger::live_debug_instance_node(const NodePath &p_parent, co
 		msg.push_back(p_parent);
 		msg.push_back(p_path);
 		msg.push_back(p_name);
-		_put_msg("live_instance_node", msg);
+		_put_msg("scene:live_instance_node", msg);
 	}
 }
 void ScriptEditorDebugger::live_debug_remove_node(const NodePath &p_at) {
@@ -1269,7 +1241,7 @@ void ScriptEditorDebugger::live_debug_remove_node(const NodePath &p_at) {
 	if (live_debug) {
 		Array msg;
 		msg.push_back(p_at);
-		_put_msg("live_remove_node", msg);
+		_put_msg("scene:live_remove_node", msg);
 	}
 }
 void ScriptEditorDebugger::live_debug_remove_and_keep_node(const NodePath &p_at, ObjectID p_keep_id) {
@@ -1278,7 +1250,7 @@ void ScriptEditorDebugger::live_debug_remove_and_keep_node(const NodePath &p_at,
 		Array msg;
 		msg.push_back(p_at);
 		msg.push_back(p_keep_id);
-		_put_msg("live_remove_and_keep_node", msg);
+		_put_msg("scene:live_remove_and_keep_node", msg);
 	}
 }
 void ScriptEditorDebugger::live_debug_restore_node(ObjectID p_id, const NodePath &p_at, int p_at_pos) {
@@ -1288,7 +1260,7 @@ void ScriptEditorDebugger::live_debug_restore_node(ObjectID p_id, const NodePath
 		msg.push_back(p_id);
 		msg.push_back(p_at);
 		msg.push_back(p_at_pos);
-		_put_msg("live_restore_node", msg);
+		_put_msg("scene:live_restore_node", msg);
 	}
 }
 void ScriptEditorDebugger::live_debug_duplicate_node(const NodePath &p_at, const String &p_new_name) {
@@ -1297,7 +1269,7 @@ void ScriptEditorDebugger::live_debug_duplicate_node(const NodePath &p_at, const
 		Array msg;
 		msg.push_back(p_at);
 		msg.push_back(p_new_name);
-		_put_msg("live_duplicate_node", msg);
+		_put_msg("scene:live_duplicate_node", msg);
 	}
 }
 void ScriptEditorDebugger::live_debug_reparent_node(const NodePath &p_at, const NodePath &p_new_place, const String &p_new_name, int p_at_pos) {
@@ -1308,7 +1280,7 @@ void ScriptEditorDebugger::live_debug_reparent_node(const NodePath &p_at, const
 		msg.push_back(p_new_place);
 		msg.push_back(p_new_name);
 		msg.push_back(p_at_pos);
-		_put_msg("live_reparent_node", msg);
+		_put_msg("scene:live_reparent_node", msg);
 	}
 }
 
@@ -1321,19 +1293,19 @@ void ScriptEditorDebugger::set_camera_override(CameraOverride p_override) {
 	if (p_override == CameraOverride::OVERRIDE_2D && camera_override != CameraOverride::OVERRIDE_2D) {
 		Array msg;
 		msg.push_back(true);
-		_put_msg("override_camera_2D:set", msg);
+		_put_msg("scene:override_camera_2D:set", msg);
 	} else if (p_override != CameraOverride::OVERRIDE_2D && camera_override == CameraOverride::OVERRIDE_2D) {
 		Array msg;
 		msg.push_back(false);
-		_put_msg("override_camera_2D:set", msg);
+		_put_msg("scene:override_camera_2D:set", msg);
 	} else if (p_override >= CameraOverride::OVERRIDE_3D_1 && camera_override < CameraOverride::OVERRIDE_3D_1) {
 		Array msg;
 		msg.push_back(true);
-		_put_msg("override_camera_3D:set", msg);
+		_put_msg("scene:override_camera_3D:set", msg);
 	} else if (p_override < CameraOverride::OVERRIDE_3D_1 && camera_override >= CameraOverride::OVERRIDE_3D_1) {
 		Array msg;
 		msg.push_back(false);
-		_put_msg("override_camera_3D:set", msg);
+		_put_msg("scene:override_camera_3D:set", msg);
 	}
 
 	camera_override = p_override;
@@ -1636,7 +1608,7 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) {
 		profiler = memnew(EditorProfiler);
 		profiler->set_name(TTR("Profiler"));
 		tabs->add_child(profiler);
-		profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate));
+		profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate), varray(PROFILER_SCRIPTS_SERVERS));
 		profiler->connect("break_request", callable_mp(this, &ScriptEditorDebugger::_profiler_seeked));
 	}
 
@@ -1644,14 +1616,14 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) {
 		visual_profiler = memnew(EditorVisualProfiler);
 		visual_profiler->set_name(TTR("Visual Profiler"));
 		tabs->add_child(visual_profiler);
-		visual_profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_visual_profiler_activate));
+		visual_profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate), varray(PROFILER_VISUAL));
 	}
 
 	{ //network profiler
 		network_profiler = memnew(EditorNetworkProfiler);
 		network_profiler->set_name(TTR("Network Profiler"));
 		tabs->add_child(network_profiler);
-		network_profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_network_profiler_activate));
+		network_profiler->connect("enable_profiling", callable_mp(this, &ScriptEditorDebugger::_profiler_activate), varray(PROFILER_NETWORK));
 	}
 
 	{ //monitors
diff --git a/editor/debugger/script_editor_debugger.h b/editor/debugger/script_editor_debugger.h
index 1fd0713fe5..e7ce917543 100644
--- a/editor/debugger/script_editor_debugger.h
+++ b/editor/debugger/script_editor_debugger.h
@@ -67,6 +67,12 @@ private:
 		MESSAGE_SUCCESS,
 	};
 
+	enum ProfilerType {
+		PROFILER_NETWORK,
+		PROFILER_VISUAL,
+		PROFILER_SCRIPTS_SERVERS
+	};
+
 	AcceptDialog *msgdialog;
 
 	LineEdit *clicked_ctrl;
@@ -121,7 +127,7 @@ private:
 	EditorDebuggerInspector *inspector;
 	SceneDebuggerTree *scene_tree;
 
-	Ref<EditorDebuggerPeer> peer;
+	Ref<RemoteDebuggerPeer> peer;
 
 	HashMap<NodePath, int> node_path_cache;
 	int last_path_id;
@@ -171,12 +177,9 @@ private:
 	void _expand_errors_list();
 	void _collapse_errors_list();
 
-	void _visual_profiler_activate(bool p_enable);
-	void _profiler_activate(bool p_enable);
+	void _profiler_activate(bool p_enable, int p_profiler);
 	void _profiler_seeked();
 
-	void _network_profiler_activate(bool p_enable);
-
 	void _clear_errors_list();
 
 	void _error_tree_item_rmb_selected(const Vector2 &p_pos);
@@ -204,7 +207,7 @@ public:
 	void request_remote_tree();
 	const SceneDebuggerTree *get_remote_tree();
 
-	void start(Ref<EditorDebuggerPeer> p_peer);
+	void start(Ref<RemoteDebuggerPeer> p_peer);
 	void stop();
 
 	void debug_skip_breakpoints();