Update threaded graphics resource creation auto-detection

Author: Zylann

engine/gpu/gpu_task_runner.cpp

@@ -26,6 +26,7 @@ GPUTaskRunner::~GPUTaskRunner() {
 
 void GPUTaskRunner::start() {
 	ZN_ASSERT(!_running);
+	ZN_PRINT_VERBOSE("Starting GPUTaskRunner");
 	_running = true;
 	_thread.start(
 			[](void *p_userdata) {

engine/voxel_engine.cpp

@@ -5,6 +5,8 @@
 #include "../streams/load_all_blocks_data_task.h"
 #include "../streams/load_block_data_task.h"
 #include "../streams/save_block_data_task.h"
+#include "../util/godot/classes/os.h"
+#include "../util/godot/classes/project_settings.h"
 #include "../util/godot/classes/rd_sampler_state.h"
 #include "../util/godot/classes/rendering_device.h"
 #include "../util/godot/classes/rendering_server.h"
@@ -82,23 +84,43 @@ VoxelEngine::~VoxelEngine() {
 	_gpu_task_runner.stop();
 }
 
-void VoxelEngine::try_initialize_gpu_features() {
-#ifdef ZN_GODOT
-	// RenderingServer can be null with `tests=yes`.
-	// TODO There is no hook to integrate modules to Godot's test framework, update this when it gets improved
-	RenderingServer *rs = RenderingServer::get_singleton();
-	if (rs != nullptr) {
-		// TODO Enhancement: threaded graphics resource building should be initialized better.
-		// Pick this from the current renderer + user option (at time of writing, Godot 4 has only one
-		// renderer and has not figured out how such option would be exposed). Could use
-		// `can_create_resources_async` but this is internal. AFAIK `is_low_end` will be `true` only for OpenGL
-		// backends, which are the only ones not supporting async resource creation.
-		_threaded_graphics_resource_building_enabled = (rs->is_low_end() == false);
+static bool auto_detect_threaded_graphics_resource_building_support() {
+	const ProjectSettings *project = ProjectSettings::get_singleton();
+	ZN_ASSERT_RETURN_V(project != nullptr, false);
+
+	const zylann::godot::RenderThreadModel rendering_thread_model = zylann::godot::get_render_thread_model(*project);
+	const zylann::godot::RenderMethod rendering_method = zylann::godot::get_current_rendering_method();
+	const zylann::godot::RenderDriverName driver = zylann ::godot::get_current_rendering_driver();
+
+	if (!zylann::godot::is_render_thread_model_safe(rendering_thread_model)) {
+		return false;
 	}
-#elif defined(ZN_GODOT_EXTENSION)
-	// TODO GDX: `RenderingServer::is_low_end` is not defined, so we can't determine if threaded resource creation is
-	// available!
-#endif
+
+	switch (rendering_method) {
+		case zylann::godot::RENDER_METHOD_GL_COMPATIBILITY:
+			return false;
+		case zylann::godot::RENDER_METHOD_UNKNOWN:
+			return false;
+		default:
+			break;
+	}
+
+	switch (driver) {
+		case zylann::godot::RENDER_DRIVER_OPENGL3:
+		case zylann::godot::RENDER_DRIVER_OPENGL3_ANGLE:
+		case zylann::godot::RENDER_DRIVER_OPENGL3_ES:
+		case zylann::godot::RENDER_DRIVER_UNKNOWN:
+			return false;
+		default:
+			return true;
+	}
+}
+
+void VoxelEngine::try_initialize_gpu_features() {
+	_threaded_graphics_resource_building_enabled = auto_detect_threaded_graphics_resource_building_support();
+	ZN_PRINT_VERBOSE(format(
+			"Auto-detected threaded graphics resource building: {}", _threaded_graphics_resource_building_enabled
+	));
 
 	if (_gpu_task_runner.is_running() == false) {
 		_gpu_task_runner.start();
@@ -234,6 +256,10 @@ bool VoxelEngine::is_threaded_graphics_resource_building_enabled() const {
 	return _threaded_graphics_resource_building_enabled;
 }
 
+// void VoxelEngine::set_threaded_graphics_resource_building_enabled(bool enabled) {
+// 	_threaded_graphics_resource_building_enabled = enabled;
+// }
+
 void VoxelEngine::push_async_task(zylann::IThreadedTask *task) {
 	_general_thread_pool.enqueue(task, false);
 }

engine/voxel_engine.h

@@ -190,6 +190,7 @@ class VoxelEngine {
 
 	// This should be fast and safe to access from multiple threads.
 	bool is_threaded_graphics_resource_building_enabled() const;
+	// void set_threaded_graphics_resource_building_enabled(bool enabled);
 
 	void push_main_thread_progressive_task(IProgressiveTask *task);
 

engine/voxel_engine_gd.cpp

@@ -182,11 +182,32 @@ Vector3 VoxelEngine::get_editor_camera_direction() const {
 
 #endif
 
+bool VoxelEngine::_b_get_threaded_graphics_resource_building_enabled() const {
+	const zylann::voxel::VoxelEngine &ve = zylann::voxel::VoxelEngine::get_singleton();
+	return ve.is_threaded_graphics_resource_building_enabled();
+}
+
+// This is normally automatic. This method is mainly to allow overriding it just in case.
+// void VoxelEngine::_b_set_threaded_graphics_resource_building_enabled(bool enabled) {
+// 	zylann::voxel::VoxelEngine &ve = zylann::voxel::VoxelEngine::get_singleton();
+// 	ve.set_threaded_graphics_resource_building_enabled(enabled);
+// }
+
 void VoxelEngine::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_version_major"), &VoxelEngine::get_version_major);
 	ClassDB::bind_method(D_METHOD("get_version_minor"), &VoxelEngine::get_version_minor);
 	ClassDB::bind_method(D_METHOD("get_version_patch"), &VoxelEngine::get_version_patch);
 	ClassDB::bind_method(D_METHOD("get_stats"), &VoxelEngine::get_stats);
+
+	ClassDB::bind_method(
+			D_METHOD("get_threaded_graphics_resource_building_enabled"),
+			&VoxelEngine::_b_get_threaded_graphics_resource_building_enabled
+	);
+
+	// ClassDB::bind_method(
+	// 		D_METHOD("set_threaded_graphics_resource_building_enabled", "enabled"),
+	// 		&VoxelEngine::_b_set_threaded_graphics_resource_building_enabled
+	// );
 }
 
 } // namespace zylann::voxel::godot

engine/voxel_engine_gd.h

@@ -43,6 +43,9 @@ class VoxelEngine : public Object {
 private:
 	void _on_rendering_server_frame_post_draw();
 
+	bool _b_get_threaded_graphics_resource_building_enabled() const;
+	// void _b_set_threaded_graphics_resource_building_enabled(bool enabled);
+
 	static void _bind_methods();
 
 #ifdef TOOLS_ENABLED

util/godot/classes/rendering_server.cpp

@@ -1,4 +1,9 @@
 #include "rendering_server.h"
+#include "../../errors.h"
+#include "../../string/format.h"
+#include "../core/string.h"
+#include "../core/version.h"
+#include "project_settings.h"
 
 namespace zylann::godot {
 
@@ -29,14 +34,115 @@ void get_shader_parameter_list(const RID &shader_rid, StdVector<ShaderParameterI
 #endif
 }
 
-String get_current_rendering_method() {
-	// TODO This is not well exposed at the moment.
+String get_current_rendering_method_name() {
+#if GODOT_VERSION_MAJOR == 4 && GODOT_VERSION_MINOR >= 4
+	RenderingServer *rs = RenderingServer::get_singleton();
+	// RenderingServer can be null with `tests=yes`.
+	ZN_ASSERT_RETURN_V(rs != nullptr, "");
+
+	const String method_name = rs->get_current_rendering_method();
+	return method_name;
+
+#else
+	// See https://github.com/godotengine/godot/pull/85430
+
+#if defined(ZN_GODOT)
+	OS *os = OS::get_singleton();
+	ZN_ASSERT_RETURN(os != nullptr, "");
+	return os->get_current_rendering_method();
+
+#elif defined(ZN_GODOT_EXTENSION)
+	ZN_PRINT_WARNING("Unable to get current rendering method, Godot doesn't expose it.");
+	return "";
+#endif
+
+#endif
+}
+
+RenderMethod get_current_rendering_method() {
+	const String name = get_current_rendering_method_name();
+
+	if (name == "forward_plus") {
+		return RENDER_METHOD_FORWARD_PLUS;
+	}
+	if (name == "mobile") {
+		return RENDER_METHOD_MOBILE;
+	}
+	if (name == "gl_compatibility") {
+		return RENDER_METHOD_GL_COMPATIBILITY;
+	}
+
+	ZN_PRINT_WARNING(format("Rendering method {} is unknown", name));
+	return RENDER_METHOD_UNKNOWN;
+}
+
+String get_current_rendering_driver_name() {
+#if GODOT_VERSION_MAJOR == 4 && GODOT_VERSION_MINOR >= 4
+	RenderingServer *rs = RenderingServer::get_singleton();
+	// RenderingServer can be null with `tests=yes`.
+	ZN_ASSERT_RETURN_V(rs != nullptr, "");
+
+	const String driver_name = rs->get_current_rendering_driver_name();
+	return driver_name;
+
+#else
 	// See https://github.com/godotengine/godot/pull/85430
+
 #if defined(ZN_GODOT)
-	return OS::get_singleton()->get_current_rendering_method();
+	OS *os = OS::get_singleton();
+	ZN_ASSERT_RETURN(os != nullptr, "");
+	return os->get_current_rendering_driver_name();
+
 #elif defined(ZN_GODOT_EXTENSION)
-	return "<unable to get current rendering method, Godot doesn't expose it>";
+	ZN_PRINT_WARNING("Unable to get current rendering driver name, Godot doesn't expose it.");
+	return "";
+#endif
+
 #endif
 }
 
+RenderDriverName get_current_rendering_driver() {
+	const String name = get_current_rendering_driver_name();
+
+	if (name == "vulkan") {
+		return RENDER_DRIVER_VULKAN;
+	}
+	if (name == "d3d12") {
+		return RENDER_DRIVER_D3D12;
+	}
+	if (name == "metal") {
+		return RENDER_DRIVER_METAL;
+	}
+	if (name == "opengl3") {
+		return RENDER_DRIVER_OPENGL3;
+	}
+	if (name == "opengl3_es") {
+		return RENDER_DRIVER_OPENGL3_ES;
+	}
+	if (name == "opengl3_angle") {
+		return RENDER_DRIVER_OPENGL3_ANGLE;
+	}
+
+	ZN_PRINT_WARNING(format("Rendering driver {} is unknown", name));
+	return RENDER_DRIVER_UNKNOWN;
+}
+
+RenderThreadModel get_render_thread_model(const ProjectSettings &settings) {
+	const int rendering_thread_model = settings.get("rendering/driver/threads/thread_model");
+	return static_cast<RenderThreadModel>(rendering_thread_model);
+}
+
+bool is_render_thread_model_safe(const RenderThreadModel mode) {
+	switch (mode) {
+		case RENDER_SEPARATE_THREAD:
+		case RENDER_THREAD_SAFE:
+			return true;
+		case RENDER_THREAD_UNSAFE:
+			return false;
+		default:
+			ZN_PRINT_ERROR("Unhandled enum value");
+			return false;
+	}
+}
+
 } // namespace zylann::godot

util/godot/classes/rendering_server.h

@@ -9,6 +9,9 @@ using namespace godot;
 #endif
 
 #include "../../containers/std_vector.h"
+#include "../macros.h"
+
+ZN_GODOT_FORWARD_DECLARE(class ProjectSettings);
 
 namespace zylann::godot {
 
@@ -27,7 +30,44 @@ struct ShaderParameterInfo {
 
 void get_shader_parameter_list(const RID &shader_rid, StdVector<ShaderParameterInfo> &out_parameters);
 
-String get_current_rendering_method();
+String get_current_rendering_method_name();
+
+// Enum equivalent to strings used in ProjectSettings and RenderingServer.
+enum RenderMethod {
+	RENDER_METHOD_FORWARD_PLUS,
+	RENDER_METHOD_MOBILE,
+	RENDER_METHOD_GL_COMPATIBILITY,
+	RENDER_METHOD_UNKNOWN,
+};
+
+RenderMethod get_current_rendering_method();
+
+String get_current_rendering_driver_name();
+
+enum RenderDriverName {
+	RENDER_DRIVER_VULKAN,
+	RENDER_DRIVER_D3D12,
+	RENDER_DRIVER_METAL,
+	RENDER_DRIVER_OPENGL3,
+	RENDER_DRIVER_OPENGL3_ES,
+	RENDER_DRIVER_OPENGL3_ANGLE,
+	RENDER_DRIVER_UNKNOWN,
+};
+
+RenderDriverName get_current_rendering_driver();
+
+// Enum equivalent of `ProjectSettings.rendering/driver/threads/thread_model`.
+// This is unfortunately not exposed.
+enum RenderThreadModel {
+	RENDER_THREAD_UNSAFE,
+	RENDER_THREAD_SAFE,
+	RENDER_SEPARATE_THREAD,
+};
+
+RenderThreadModel get_render_thread_model(const ProjectSettings &settings);
+
+// Tells if it is safe to call functions of the RenderingServer from a thread other than the main one.
+bool is_render_thread_model_safe(const RenderThreadModel mode);
 
 } // namespace zylann::godot