Workaround crash in release GDExtension builds.

Unlike module builds, RenderingServer::get_singleton() crashes when used
in initialize_voxel_module() in release GDExtension builds.
See #733
And godotengine/godot-cpp#1180

Author: Zylann

engine/gpu/gpu_task_runner.cpp

@@ -46,6 +46,10 @@ void GPUTaskRunner::stop() {
 	_thread.wait_to_finish();
 }
 
+bool GPUTaskRunner::is_running() const {
+	return _running;
+}
+
 void GPUTaskRunner::push(IGPUTask *task) {
 	ZN_ASSERT_RETURN(task != nullptr);
 	MutexLock mlock(_mutex);

engine/gpu/gpu_task_runner.h

@@ -80,6 +80,7 @@ class GPUTaskRunner {
 	void push(IGPUTask *task);
 	unsigned int get_pending_task_count() const;
 	bool has_rendering_device() const;
+	bool is_running() const;
 
 private:
 	void thread_func();

engine/voxel_engine.cpp

@@ -68,15 +68,6 @@ VoxelEngine::VoxelEngine(Config config) {
 	ZN_PRINT_VERBOSE(format("Size of SaveBlockDataTask: {}", sizeof(SaveBlockDataTask)));
 	ZN_PRINT_VERBOSE(format("Size of MeshBlockTask: {}", sizeof(MeshBlockTask)));
 
-	if (RenderingServer::get_singleton() == nullptr) {
-		// Sadly, that happens. This is a problem in GDExtension...
-		ZN_PRINT_ERROR("RenderingServer singleton is null when creating VoxelEngine!");
-		// RenderingServer can also be null with `tests=yes`.
-		// TODO There is no hook to integrate modules to Godot's test framework, update this when it gets improved
-	} else {
-		_gpu_task_runner.start();
-	}
-
 	set_main_thread_time_budget_usec(config.main_thread_budget_usec);
 }
 
@@ -91,6 +82,24 @@ VoxelEngine::~VoxelEngine() {
 	_gpu_task_runner.stop();
 }
 
+void VoxelEngine::try_initialize_gpu_features() {
+	// 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);
+	}
+
+	if (_gpu_task_runner.is_running() == false) {
+		_gpu_task_runner.start();
+	}
+}
+
 void VoxelEngine::wait_and_clear_all_tasks(bool warn) {
 	_general_thread_pool.wait_for_all_tasks();
 
@@ -216,10 +225,6 @@ void VoxelEngine::set_main_thread_time_budget_usec(unsigned int usec) {
 	_main_thread_time_budget_usec = usec;
 }
 
-void VoxelEngine::set_threaded_graphics_resource_building_enabled(bool enable) {
-	_threaded_graphics_resource_building_enabled = enable;
-}
-
 bool VoxelEngine::is_threaded_graphics_resource_building_enabled() const {
 	return _threaded_graphics_resource_building_enabled;
 }

engine/voxel_engine.h

@@ -144,6 +144,12 @@ class VoxelEngine {
 	static void create_singleton(Config config);
 	static void destroy_singleton();
 
+	// This is a separate initialization step due to GDExtension limitations.
+	// It must be called when RenderingServer singleton is available (which is not the case with GDExtension during
+	// class registrations, contrary to modules).
+	// See https://github.com/godotengine/godot-cpp/issues/1180
+	void try_initialize_gpu_features();
+
 	VolumeID add_volume(VolumeCallbacks callbacks);
 	VolumeCallbacks get_volume_callbacks(VolumeID volume_id) const;
 
@@ -182,10 +188,6 @@ class VoxelEngine {
 	int get_main_thread_time_budget_usec() const;
 	void set_main_thread_time_budget_usec(unsigned int usec);
 
-	// Allows/disallows building Mesh and Texture resources from inside threads.
-	// Depends on Godot's efficiency at doing so, and which renderer is used.
-	// For example, the OpenGL renderer does not support this well, but the Vulkan one should.
-	void set_threaded_graphics_resource_building_enabled(bool enable);
 	// This should be fast and safe to access from multiple threads.
 	bool is_threaded_graphics_resource_building_enabled() const;
 
@@ -319,6 +321,9 @@ class VoxelEngine {
 
 	FileLocker _file_locker;
 
+	// Caches whether building Mesh and Texture resources is allowed from inside threads.
+	// Depends on Godot's efficiency at doing so, and which renderer is used.
+	// For example, the OpenGL renderer does not support this well, but the Vulkan one should.
 	bool _threaded_graphics_resource_building_enabled = false;
 
 	GPUTaskRunner _gpu_task_runner;

engine/voxel_engine_updater.cpp

@@ -41,6 +41,8 @@ void VoxelEngineUpdater::ensure_existence(SceneTree *st) {
 	// TODO This can fail (for example if `Node::data.blocked > 0` while in `_ready()`) but Godot offers no API to check
 	// anything. So if this fail, the node will leak.
 	root->add_child(u);
+
+	VoxelEngine::get_singleton().try_initialize_gpu_features();
 }
 
 void VoxelEngineUpdater::_notification(int p_what) {

register_types.cpp

@@ -350,23 +350,6 @@ void initialize_voxel_module(ModuleInitializationLevel p_level) {
 		CheckRefCountDoesNotChange::set_enabled(config.ownership_checks);
 #endif
 		VoxelEngine::create_singleton(config.inner);
-#if defined(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
-		if (RenderingServer::get_singleton() != 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.
-			VoxelEngine::get_singleton().set_threaded_graphics_resource_building_enabled(
-					RenderingServer::get_singleton()->is_low_end() == false
-			);
-		}
-#else
-		// TODO GDX: RenderingServer::is_low_end() is not exposed, can't tell if we can generate graphics resources in
-		// different threads
-#endif
 
 		zylann::voxel::godot::VoxelEngine::create_singleton();
 		zylann::godot::add_singleton("VoxelEngine", zylann::voxel::godot::VoxelEngine::get_singleton());

tests/voxel/test_detail_rendering_gpu.cpp

@@ -12,6 +12,12 @@
 namespace zylann::voxel::tests {
 
 void test_normalmap_render_gpu() {
+#ifdef ZN_GODOT_EXTENSION
+	// https://github.com/godotengine/godot-cpp/issues/1180
+	ZN_PRINT_ERROR("This test might not work in GDExtension builds at the moment.");
+#endif
+	VoxelEngine::get_singleton().try_initialize_gpu_features();
+
 	Ref<VoxelGeneratorGraph> generator;
 	generator.instantiate();
 	{