Allow custom monitors to select desired type

devloglogan · devloglogan · commit 037b50059c4d · 2025-09-11T16:23:14.000-05:00
diff --git a/core/debugger/remote_debugger.cpp b/core/debugger/remote_debugger.cpp
@@ -62,11 +62,17 @@ class RemoteDebugger::PerformanceProfiler : public EngineProfiler {
 		last_perf_time = pt;
 
 		Array custom_monitor_names = performance->call("get_custom_monitor_names");
+		Array custom_monitor_types = performance->call("get_custom_monitor_types");
+
+		Array custom_monitor_data;
+		custom_monitor_data.clear();
+		custom_monitor_data.append_array(custom_monitor_names);
+		custom_monitor_data.append_array(custom_monitor_types);
 
 		uint64_t monitor_modification_time = performance->call("get_monitor_modification_time");
 		if (monitor_modification_time > last_monitor_modification_time) {
 			last_monitor_modification_time = monitor_modification_time;
-			EngineDebugger::get_singleton()->send_message("performance:profile_names", custom_monitor_names);
+			EngineDebugger::get_singleton()->send_message("performance:profile_names", custom_monitor_data);
 		}
 
 		int max = performance->get("MONITOR_MAX");
diff --git a/doc/classes/Performance.xml b/doc/classes/Performance.xml
@@ -18,6 +18,7 @@
 			<param index="0" name="id" type="StringName" />
 			<param index="1" name="callable" type="Callable" />
 			<param index="2" name="arguments" type="Array" default="[]" />
+			<param index="3" name="type" type="int" enum="Performance.MonitorType" default="0" />
 			<description>
 				Adds a custom monitor with the name [param id]. You can specify the category of the monitor using slash delimiters in [param id] (for example: [code]"Game/NumberOfNPCs"[/code]). If there is more than one slash delimiter, then the default category is used. The default category is [code]"Custom"[/code]. Prints an error if given [param id] is already present.
 				[codeblocks]
@@ -84,6 +85,12 @@
 				Returns the names of active custom monitors in an [Array].
 			</description>
 		</method>
+		<method name="get_custom_monitor_types">
+			<return type="int[]" />
+			<description>
+				Returns the [enum MonitorType] values of active custom monitors in an [Array].
+			</description>
+		</method>
 		<method name="get_monitor" qualifiers="const">
 			<return type="float" />
 			<param index="0" name="monitor" type="int" enum="Performance.Monitor" />
@@ -302,5 +309,17 @@
 		<constant name="MONITOR_MAX" value="59" enum="Monitor">
 			Represents the size of the [enum Monitor] enum.
 		</constant>
+		<constant name="MONITOR_TYPE_QUANTITY" value="0" enum="MonitorType">
+			Monitor output is formatted as an integer value.
+		</constant>
+		<constant name="MONITOR_TYPE_MEMORY" value="1" enum="MonitorType">
+			Monitor output is formatted as computer memory, submitted values should represent number of bytes.
+		</constant>
+		<constant name="MONITOR_TYPE_TIME" value="2" enum="MonitorType">
+			Monitor output is formatted as time in milliseconds, submitted values should represent time in seconds.
+		</constant>
+		<constant name="MONITOR_TYPE_PERCENTAGE" value="3" enum="MonitorType">
+			Monitor output is formatted as a percentage.
+		</constant>
 	</constants>
 </class>
diff --git a/editor/debugger/editor_performance_profiler.cpp b/editor/debugger/editor_performance_profiler.cpp
@@ -88,6 +88,9 @@ String EditorPerformanceProfiler::_create_label(float p_value, Performance::Moni
 		case Performance::MONITOR_TYPE_TIME: {
 			return TS->format_number(rtos(p_value * 1000).pad_decimals(2)) + " " + TTR("ms");
 		}
+		case Performance::MONITOR_TYPE_PERCENTAGE: {
+			return TS->format_number(rtos(p_value).pad_decimals(2)) + "%";
+		}
 		default: {
 			return TS->format_number(rtos(p_value));
 		}
@@ -317,7 +320,7 @@ void EditorPerformanceProfiler::reset() {
 	monitor_draw->queue_redraw();
 }
 
-void EditorPerformanceProfiler::update_monitors(const Vector<StringName> &p_names) {
+void EditorPerformanceProfiler::update_monitors(const Vector<StringName> &p_names, const PackedInt32Array &p_types) {
 	HashMap<StringName, int> names;
 	for (int i = 0; i < p_names.size(); i++) {
 		names.insert("custom:" + p_names[i], Performance::MONITOR_MAX + i);
@@ -340,14 +343,17 @@ void EditorPerformanceProfiler::update_monitors(const Vector<StringName> &p_name
 		}
 	}
 
+	int index = 0;
 	for (const KeyValue<StringName, int> &E : names) {
 		String name = String(E.key).replace_first("custom:", "");
 		String base = "Custom";
 		if (name.get_slice_count("/") == 2) {
 			base = name.get_slicec('/', 0);
 			name = name.get_slicec('/', 1);
 		}
-		monitors.insert(E.key, Monitor(name, base, E.value, Performance::MONITOR_TYPE_QUANTITY, nullptr));
+		Performance::MonitorType type = Performance::MonitorType(p_types[index]);
+		monitors.insert(E.key, Monitor(name, base, E.value, type, nullptr));
+		index++;
 	}
 
 	_build_monitor_tree();
diff --git a/editor/debugger/editor_performance_profiler.h b/editor/debugger/editor_performance_profiler.h
@@ -82,7 +82,7 @@ class EditorPerformanceProfiler : public HSplitContainer {
 
 public:
 	void reset();
-	void update_monitors(const Vector<StringName> &p_names);
+	void update_monitors(const Vector<StringName> &p_names, const PackedInt32Array &p_types);
 	void add_profile_frame(const Vector<float> &p_values);
 	List<float> *get_monitor_data(const StringName &p_name);
 	EditorPerformanceProfiler();
diff --git a/editor/debugger/script_editor_debugger.cpp b/editor/debugger/script_editor_debugger.cpp
@@ -904,13 +904,24 @@ void ScriptEditorDebugger::_msg_show_selection_limit_warning(uint64_t p_thread_i
 }
 
 void ScriptEditorDebugger::_msg_performance_profile_names(uint64_t p_thread_id, const Array &p_data) {
+	Array name_data = p_data.slice(0, p_data.size() / 2);
+	Array type_data = p_data.slice(p_data.size() / 2);
+
 	Vector<StringName> monitors;
-	monitors.resize(p_data.size());
-	for (int i = 0; i < p_data.size(); i++) {
-		ERR_FAIL_COND(p_data[i].get_type() != Variant::STRING_NAME);
-		monitors.set(i, p_data[i]);
+	monitors.resize(name_data.size());
+	for (int i = 0; i < name_data.size(); i++) {
+		ERR_FAIL_COND(name_data[i].get_type() != Variant::STRING_NAME);
+		monitors.set(i, name_data[i]);
 	}
-	performance_profiler->update_monitors(monitors);
+
+	PackedInt32Array types;
+	types.resize(type_data.size());
+	for (int i = 0; i < type_data.size(); i++) {
+		ERR_FAIL_COND(type_data[i].get_type() != Variant::INT);
+		types.set(i, type_data[i]);
+	}
+
+	performance_profiler->update_monitors(monitors, types);
 }
 
 void ScriptEditorDebugger::_msg_filesystem_update_file(uint64_t p_thread_id, const Array &p_data) {
diff --git a/main/performance.cpp b/main/performance.cpp
@@ -55,12 +55,13 @@ Performance *Performance::singleton = nullptr;
 
 void Performance::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_monitor", "monitor"), &Performance::get_monitor);
-	ClassDB::bind_method(D_METHOD("add_custom_monitor", "id", "callable", "arguments"), &Performance::add_custom_monitor, DEFVAL(Array()));
+	ClassDB::bind_method(D_METHOD("add_custom_monitor", "id", "callable", "arguments", "type"), &Performance::add_custom_monitor, DEFVAL(Array()), DEFVAL(MONITOR_TYPE_QUANTITY));
 	ClassDB::bind_method(D_METHOD("remove_custom_monitor", "id"), &Performance::remove_custom_monitor);
 	ClassDB::bind_method(D_METHOD("has_custom_monitor", "id"), &Performance::has_custom_monitor);
 	ClassDB::bind_method(D_METHOD("get_custom_monitor", "id"), &Performance::get_custom_monitor);
 	ClassDB::bind_method(D_METHOD("get_monitor_modification_time"), &Performance::get_monitor_modification_time);
 	ClassDB::bind_method(D_METHOD("get_custom_monitor_names"), &Performance::get_custom_monitor_names);
+	ClassDB::bind_method(D_METHOD("get_custom_monitor_types"), &Performance::get_custom_monitor_types);
 
 	BIND_ENUM_CONSTANT(TIME_FPS);
 	BIND_ENUM_CONSTANT(TIME_PROCESS);
@@ -130,6 +131,11 @@ void Performance::_bind_methods() {
 	BIND_ENUM_CONSTANT(NAVIGATION_3D_OBSTACLE_COUNT);
 #endif // NAVIGATION_3D_DISABLED
 	BIND_ENUM_CONSTANT(MONITOR_MAX);
+
+	BIND_ENUM_CONSTANT(MONITOR_TYPE_QUANTITY);
+	BIND_ENUM_CONSTANT(MONITOR_TYPE_MEMORY);
+	BIND_ENUM_CONSTANT(MONITOR_TYPE_TIME);
+	BIND_ENUM_CONSTANT(MONITOR_TYPE_PERCENTAGE);
 }
 
 int Performance::_get_node_count() const {
@@ -522,9 +528,9 @@ void Performance::set_navigation_process_time(double p_pt) {
 	_navigation_process_time = p_pt;
 }
 
-void Performance::add_custom_monitor(const StringName &p_id, const Callable &p_callable, const Vector<Variant> &p_args) {
+void Performance::add_custom_monitor(const StringName &p_id, const Callable &p_callable, const Vector<Variant> &p_args, MonitorType p_type = MONITOR_TYPE_QUANTITY) {
 	ERR_FAIL_COND_MSG(has_custom_monitor(p_id), "Custom monitor with id '" + String(p_id) + "' already exists.");
-	_monitor_map.insert(p_id, MonitorCall(p_callable, p_args));
+	_monitor_map.insert(p_id, MonitorCall(p_type, p_callable, p_args));
 	_monitor_modification_time = OS::get_singleton()->get_ticks_usec();
 }
 
@@ -561,6 +567,20 @@ TypedArray<StringName> Performance::get_custom_monitor_names() {
 	return return_array;
 }
 
+TypedArray<int> Performance::get_custom_monitor_types() {
+	if (!_monitor_map.size()) {
+		return TypedArray<int>();
+	}
+	TypedArray<int> return_array;
+	return_array.resize(_monitor_map.size());
+	int index = 0;
+	for (KeyValue<StringName, MonitorCall> i : _monitor_map) {
+		return_array.set(index, (int)i.value.get_monitor_type());
+		index++;
+	}
+	return return_array;
+}
+
 uint64_t Performance::get_monitor_modification_time() {
 	return _monitor_modification_time;
 }
@@ -573,7 +593,8 @@ Performance::Performance() {
 	singleton = this;
 }
 
-Performance::MonitorCall::MonitorCall(Callable p_callable, Vector<Variant> p_arguments) {
+Performance::MonitorCall::MonitorCall(Performance::MonitorType p_type, Callable p_callable, Vector<Variant> p_arguments) {
+	_type = p_type;
 	_callable = p_callable;
 	_arguments = p_arguments;
 }
@@ -598,3 +619,7 @@ Variant Performance::MonitorCall::call(bool &r_error, String &r_error_message) {
 	}
 	return return_value;
 }
+
+Performance::MonitorType Performance::MonitorCall::get_monitor_type() {
+	return _type;
+}
diff --git a/main/performance.h b/main/performance.h
@@ -51,19 +51,6 @@ class Performance : public Object {
 	double _physics_process_time;
 	double _navigation_process_time;
 
-	class MonitorCall {
-		Callable _callable;
-		Vector<Variant> _arguments;
-
-	public:
-		MonitorCall(Callable p_callable, Vector<Variant> p_arguments);
-		MonitorCall();
-		Variant call(bool &r_error, String &r_error_message);
-	};
-
-	HashMap<StringName, MonitorCall> _monitor_map;
-	uint64_t _monitor_modification_time;
-
 public:
 	enum Monitor {
 		TIME_FPS,
@@ -131,7 +118,8 @@ class Performance : public Object {
 	enum MonitorType {
 		MONITOR_TYPE_QUANTITY,
 		MONITOR_TYPE_MEMORY,
-		MONITOR_TYPE_TIME
+		MONITOR_TYPE_TIME,
+		MONITOR_TYPE_PERCENTAGE
 	};
 
 	double get_monitor(Monitor p_monitor) const;
@@ -143,17 +131,35 @@ class Performance : public Object {
 	void set_physics_process_time(double p_pt);
 	void set_navigation_process_time(double p_pt);
 
-	void add_custom_monitor(const StringName &p_id, const Callable &p_callable, const Vector<Variant> &p_args);
+	void add_custom_monitor(const StringName &p_id, const Callable &p_callable, const Vector<Variant> &p_args, MonitorType p_type);
 	void remove_custom_monitor(const StringName &p_id);
 	bool has_custom_monitor(const StringName &p_id);
 	Variant get_custom_monitor(const StringName &p_id);
 	TypedArray<StringName> get_custom_monitor_names();
+	TypedArray<int> get_custom_monitor_types();
 
 	uint64_t get_monitor_modification_time();
 
 	static Performance *get_singleton() { return singleton; }
 
 	Performance();
+
+private:
+	class MonitorCall {
+		MonitorType _type = MONITOR_TYPE_QUANTITY;
+		Callable _callable;
+		Vector<Variant> _arguments;
+
+	public:
+		MonitorCall(MonitorType p_type, Callable p_callable, Vector<Variant> p_arguments);
+		MonitorCall();
+		Variant call(bool &r_error, String &r_error_message);
+		MonitorType get_monitor_type();
+	};
+
+	HashMap<StringName, MonitorCall> _monitor_map;
+	uint64_t _monitor_modification_time;
 };
 
 VARIANT_ENUM_CAST(Performance::Monitor);
+VARIANT_ENUM_CAST(Performance::MonitorType);

Original file line number	Diff line number	Diff line change
`@@ -88,6 +88,9 @@ String EditorPerformanceProfiler::_create_label(float p_value, Performance::Moni`
`88`	`88`	`case Performance::MONITOR_TYPE_TIME: {`
`89`	`89`	`return TS->format_number(rtos(p_value * 1000).pad_decimals(2)) + " " + TTR("ms");`
`90`	`90`	`}`
	`91`	`+ case Performance::MONITOR_TYPE_PERCENTAGE: {`
	`92`	`+ return TS->format_number(rtos(p_value).pad_decimals(2)) + "%";`
	`93`	`+ }`
`91`	`94`	`default: {`
`92`	`95`	`return TS->format_number(rtos(p_value));`
`93`	`96`	`}`
`@@ -317,7 +320,7 @@ void EditorPerformanceProfiler::reset() {`
`317`	`320`	`monitor_draw->queue_redraw();`
`318`	`321`	`}`
`319`	`322`
`320`		`-void EditorPerformanceProfiler::update_monitors(const Vector<StringName> &p_names) {`
	`323`	`+void EditorPerformanceProfiler::update_monitors(const Vector<StringName> &p_names, const PackedInt32Array &p_types) {`
`321`	`324`	`HashMap<StringName, int> names;`
`322`	`325`	`for (int i = 0; i < p_names.size(); i++) {`
`323`	`326`	`names.insert("custom:" + p_names[i], Performance::MONITOR_MAX + i);`
`@@ -340,14 +343,17 @@ void EditorPerformanceProfiler::update_monitors(const Vector<StringName> &p_name`
`340`	`343`	`}`
`341`	`344`	`}`
`342`	`345`
	`346`	`+ int index = 0;`
`343`	`347`	`for (const KeyValue<StringName, int> &E : names) {`
`344`	`348`	`String name = String(E.key).replace_first("custom:", "");`
`345`	`349`	`String base = "Custom";`
`346`	`350`	`if (name.get_slice_count("/") == 2) {`
`347`	`351`	`base = name.get_slicec('/', 0);`
`348`	`352`	`name = name.get_slicec('/', 1);`
`349`	`353`	`}`
`350`		`- monitors.insert(E.key, Monitor(name, base, E.value, Performance::MONITOR_TYPE_QUANTITY, nullptr));`
	`354`	`+ Performance::MonitorType type = Performance::MonitorType(p_types[index]);`
	`355`	`+ monitors.insert(E.key, Monitor(name, base, E.value, type, nullptr));`
	`356`	`+ index++;`
`351`	`357`	`}`
`352`	`358`
`353`	`359`	`_build_monitor_tree();`