Final results of collaboration with Google and The Forge

core/config/engine.h

@@ -36,6 +36,11 @@
 #include "core/templates/list.h"
 #include "core/templates/vector.h"
 
+#if defined(VULKAN_ENABLED) && (defined(DEBUG_ENABLED) || defined(DEV_ENABLED))
+#define	VK_TRACK_DRIVER_MEMORY
+#define VK_TRACK_DEVICE_MEMORY
+#endif
+
 template <typename T>
 class TypedArray;
 

core/config/project_settings.cpp

@@ -1457,6 +1457,11 @@ ProjectSettings::ProjectSettings() {
 	GLOBAL_DEF("display/window/subwindows/embed_subwindows", true);
 	// Keep the enum values in sync with the `DisplayServer::VSyncMode` enum.
 	custom_prop_info["display/window/vsync/vsync_mode"] = PropertyInfo(Variant::INT, "display/window/vsync/vsync_mode", PROPERTY_HINT_ENUM, "Disabled,Enabled,Adaptive,Mailbox");
+
+	GLOBAL_DEF("display/window/frame_pacing/android/enable_frame_pacing", false);
+	GLOBAL_DEF("display/window/frame_pacing/android/enable_auto_swap", true);
+	GLOBAL_DEF(PropertyInfo(Variant::INT, "display/window/frame_pacing/android/target_frame_rate", PROPERTY_HINT_RANGE, "0.0, 90.0, 1.0"), 60);
+
 	custom_prop_info["rendering/driver/threads/thread_model"] = PropertyInfo(Variant::INT, "rendering/driver/threads/thread_model", PROPERTY_HINT_ENUM, "Single-Unsafe,Single-Safe,Multi-Threaded");
 	GLOBAL_DEF("physics/2d/run_on_separate_thread", false);
 	GLOBAL_DEF("physics/3d/run_on_separate_thread", false);

core/core_bind.cpp

@@ -42,6 +42,17 @@
 #include "core/os/thread_safe.h"
 #include "core/variant/typed_array.h"
 
+
+#if defined(VK_TRACK_DRIVER_MEMORY) || defined(VK_TRACK_DEVICE_MEMORY)
+#include "drivers/vulkan/rendering_context_driver_vulkan.h"
+#endif
+
+// <TF>
+// @ShadyTF script function to get performance report text
+#include "servers/rendering/rendering_device.h"
+// </TF>
+
+
 namespace core_bind {
 
 ////// ResourceLoader //////
@@ -1594,6 +1605,12 @@ int Engine::get_max_fps() const {
 double Engine::get_frames_per_second() const {
 	return ::Engine::get_singleton()->get_frames_per_second();
 }
+// <TF>
+// @ShadyTF script function to get performance report text
+String Engine::get_perf_report() const {
+	return RenderingDevice::get_singleton()->get_perf_report();
+}
+// </TF>
 
 uint64_t Engine::get_physics_frames() const {
 	return ::Engine::get_singleton()->get_physics_frames();
@@ -1603,6 +1620,45 @@ uint64_t Engine::get_process_frames() const {
 	return ::Engine::get_singleton()->get_process_frames();
 }
 
+#if defined(VK_TRACK_DRIVER_MEMORY) || defined(VK_TRACK_DEVICE_MEMORY)
+String Engine::get_tracked_object_name(uint32_t typeIndex) const {
+	return RenderingContextDriverVulkan::get_tracked_object_name(typeIndex);
+}
+uint64_t Engine::get_tracked_object_type_count() const {
+	return RenderingContextDriverVulkan::get_tracked_object_type_count();
+}
+#endif
+
+#if defined(VK_TRACK_DRIVER_MEMORY)
+uint64_t Engine::get_driver_total_memory() const {
+	return RenderingContextDriverVulkan::get_driver_total_memory();
+}
+uint64_t Engine::get_driver_allocation_count() const {
+	return RenderingContextDriverVulkan::get_driver_allocation_count();
+}
+uint64_t Engine::get_driver_memory_by_object_type(uint32_t type) const {
+	return RenderingContextDriverVulkan::get_driver_memory_by_object_type(type);
+}
+uint64_t Engine::get_driver_allocs_by_object_type(uint32_t type) const {
+	return RenderingContextDriverVulkan::get_driver_allocs_by_object_type(type);
+}
+#endif
+
+#if defined(VK_TRACK_DEVICE_MEMORY)
+uint64_t Engine::get_device_total_memory() const {
+	return RenderingContextDriverVulkan::get_device_total_memory();
+}
+uint64_t Engine::get_device_allocation_count() const {
+	return RenderingContextDriverVulkan::get_device_allocation_count();
+}
+uint64_t Engine::get_device_memory_by_object_type(uint32_t type) const {
+	return RenderingContextDriverVulkan::get_device_memory_by_object_type(type);
+}
+uint64_t Engine::get_device_allocs_by_object_type(uint32_t type) const {
+	return RenderingContextDriverVulkan::get_device_allocs_by_object_type(type);
+}
+#endif
+
 void Engine::set_time_scale(double p_scale) {
 	::Engine::get_singleton()->set_time_scale(p_scale);
 }
@@ -1748,10 +1804,34 @@ void Engine::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_time_scale"), &Engine::get_time_scale);
 
 	ClassDB::bind_method(D_METHOD("get_frames_drawn"), &Engine::get_frames_drawn);
+	// <TF>
+	// @ShadyTF script function to get performance report text
 	ClassDB::bind_method(D_METHOD("get_frames_per_second"), &Engine::get_frames_per_second);
+	// </TF>
+
+	ClassDB::bind_method(D_METHOD("get_perf_report"), &Engine::get_perf_report);
 	ClassDB::bind_method(D_METHOD("get_physics_frames"), &Engine::get_physics_frames);
 	ClassDB::bind_method(D_METHOD("get_process_frames"), &Engine::get_process_frames);
 
+#if defined(VK_TRACK_DRIVER_MEMORY) || defined(VK_TRACK_DEVICE_MEMORY)
+	ClassDB::bind_method(D_METHOD("get_tracked_object_name"), &Engine::get_tracked_object_name);
+	ClassDB::bind_method(D_METHOD("get_tracked_object_type_count"), &Engine::get_tracked_object_type_count);
+#endif
+
+#if defined(VK_TRACK_DRIVER_MEMORY)
+	ClassDB::bind_method(D_METHOD("get_driver_total_memory"), &Engine::get_driver_total_memory);
+	ClassDB::bind_method(D_METHOD("get_driver_allocation_count"), &Engine::get_driver_allocation_count);
+	ClassDB::bind_method(D_METHOD("get_driver_memory_by_object_type"), &Engine::get_driver_memory_by_object_type);
+	ClassDB::bind_method(D_METHOD("get_driver_allocs_by_object_type"), &Engine::get_driver_allocs_by_object_type);
+#endif
+
+#if defined(VK_TRACK_DEVICE_MEMORY)
+	ClassDB::bind_method(D_METHOD("get_device_total_memory"), &Engine::get_device_total_memory);
+	ClassDB::bind_method(D_METHOD("get_device_allocation_count"), &Engine::get_device_allocation_count);
+	ClassDB::bind_method(D_METHOD("get_device_memory_by_object_type"), &Engine::get_device_memory_by_object_type);
+	ClassDB::bind_method(D_METHOD("get_device_allocs_by_object_type"), &Engine::get_device_allocs_by_object_type);
+#endif
+
 	ClassDB::bind_method(D_METHOD("get_main_loop"), &Engine::get_main_loop);
 
 	ClassDB::bind_method(D_METHOD("get_version_info"), &Engine::get_version_info);

core/core_bind.h

@@ -489,6 +489,29 @@ class Engine : public Object {
 	double get_frames_per_second() const;
 	uint64_t get_physics_frames() const;
 	uint64_t get_process_frames() const;
+	// <TF>
+	// @ShadyTF script function to get performance report text
+	String get_perf_report() const;
+	// </TF>
+
+#if defined(VK_TRACK_DRIVER_MEMORY) || defined(VK_TRACK_DEVICE_MEMORY)
+	String get_tracked_object_name(uint32_t typeIndex) const;
+	uint64_t get_tracked_object_type_count() const;
+#endif
+
+#if defined(VK_TRACK_DRIVER_MEMORY)
+	uint64_t get_driver_total_memory() const;
+	uint64_t get_driver_allocation_count() const;
+	uint64_t get_driver_memory_by_object_type(uint32_t type) const;
+	uint64_t get_driver_allocs_by_object_type(uint32_t type) const;
+#endif
+
+#if defined(VK_TRACK_DEVICE_MEMORY)
+	uint64_t get_device_total_memory() const;
+	uint64_t get_device_allocation_count() const;
+	uint64_t get_device_memory_by_object_type(uint32_t type) const;
+	uint64_t get_device_allocs_by_object_type(uint32_t type) const;
+#endif
 
 	int get_frames_drawn();
 

core/os/memory.cpp

@@ -65,6 +65,32 @@ SafeNumeric<uint64_t> Memory::max_usage;
 
 SafeNumeric<uint64_t> Memory::alloc_count;
 
+void *Memory::alloc_aligned_static(size_t p_bytes, size_t p_alignment) {
+	void *p1, *p2;
+	if ((p1 = (void *)malloc(p_bytes + p_alignment - 1 + sizeof(uint32_t))) == NULL)
+		return NULL;
+
+	p2 = (void *)(((uintptr_t)p1 + sizeof(uint32_t) + p_alignment - 1) & ~((p_alignment)-1));
+	*((uint32_t *)p2 - 1) = (uint32_t)((uintptr_t)p2 - (uintptr_t)p1);
+	return p2;
+}
+
+void *Memory::realloc_aligned_static(void* p_memory, size_t p_bytes, size_t p_prev_bytes, size_t p_alignment) {
+	if (p_memory == NULL)
+		return alloc_aligned_static(p_bytes, p_alignment);
+
+	void *ret = alloc_aligned_static(p_bytes, p_alignment);
+	memcpy(ret, p_memory, p_prev_bytes);
+	free_aligned_static(p_memory);
+	return ret;
+}
+
+void Memory::free_aligned_static(void* p_memory) {
+	uint32_t offset = *((uint32_t *)p_memory - 1);
+	void *p = (void *)((uint8_t *)p_memory - offset);
+	free(p);
+}
+
 void *Memory::alloc_static(size_t p_bytes, bool p_pad_align) {
 #ifdef DEBUG_ENABLED
 	bool prepad = true;

core/os/memory.h

@@ -62,6 +62,11 @@ class Memory {
 	static void *realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align = false);
 	static void free_static(void *p_ptr, bool p_pad_align = false);
 
+	static void *alloc_aligned_static(size_t p_bytes, size_t p_alignment);
+	static void *realloc_aligned_static(void *p_memory, size_t p_bytes, size_t p_prev_bytes, size_t p_alignment);
+	static void free_aligned_static(void* p_memory);
+
+
 	static uint64_t get_mem_available();
 	static uint64_t get_mem_usage();
 	static uint64_t get_mem_max_usage();

drivers/gles3/storage/texture_storage.cpp

@@ -2583,6 +2583,13 @@ bool TextureStorage::render_target_is_using_hdr(RID p_render_target) const {
 	return rt->hdr;
 }
 
+int64_t TextureStorage::render_target_get_format(RID p_render_target) const {
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	ERR_FAIL_NULL_V(rt, false);
+
+	return RenderingDevice::get_singleton()->framebuffer_get_format(rt->texture);
+}
+
 GLuint TextureStorage::render_target_get_color_internal_format(RID p_render_target) const {
 	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_NULL_V(rt, GL_RGBA8);

drivers/gles3/storage/texture_storage.h

@@ -635,6 +635,7 @@ class TextureStorage : public RendererTextureStorage {
 	virtual void render_target_do_msaa_resolve(RID p_render_target) override {}
 	virtual void render_target_set_use_hdr(RID p_render_target, bool p_use_hdr_2d) override;
 	virtual bool render_target_is_using_hdr(RID p_render_target) const override;
+	virtual int64_t render_target_get_format(RID p_render_target) const override;
 
 	// new
 	void render_target_set_as_unused(RID p_render_target) override {