Proof of concept for a hot-reload test case

Author: enetheru

test/project/example.gdextension

@@ -2,6 +2,7 @@
 
 entry_symbol = "example_library_init"
 compatibility_minimum = "4.1"
+reloadable = true
 
 [libraries]
 

test/project/reload.gd

@@ -0,0 +1,14 @@
+@tool
+extends Example
+
+func _notification( what : int ):
+	if what == NOTIFICATION_EXTENSION_RELOADED:
+		print("gdscript: NOTIFICATION_EXTENSION_RELOADED")
+
+func _ready() -> void:
+	custom_signal.connect(func( msg, value) -> void:
+		print("GSExtension Reloaded : %s, %d" % [msg, value])
+		get_tree().quit(0))
+	await get_tree().create_timer(5).timeout
+	print("Timed Out.")
+	get_tree().quit(1)

test/project/reload.tscn

@@ -0,0 +1,6 @@
+[gd_scene load_steps=2 format=3 uid="uid://b4wrd36npp8ov"]
+
+[ext_resource type="Script" uid="uid://cfsxgbu2p7sl3" path="res://reload.gd" id="1_icw2l"]
+
+[node name="Reload" type="Example"]
+script = ExtResource("1_icw2l")

test/src/example.cpp

@@ -114,6 +114,11 @@ void Example::_notification(int p_what) {
 		rpc_config("test_rpc", opts);
 	}
 	//UtilityFunctions::print("Notification: ", String::num(p_what));
+	if ( p_what == NOTIFICATION_EXTENSION_RELOADED) {
+		UtilityFunctions::print( "NOTIFICATION_EXTENSION_RELOADED" );
+		emit_custom_signal("NOTIFICATION_EXTENSION_RELOADED ",0);
+		reloaded_count++;
+	}
 }
 
 bool Example::_set(const StringName &p_name, const Variant &p_value) {
@@ -302,6 +307,12 @@ void Example::_bind_methods() {
 
 	BIND_CONSTANT(CONSTANT_WITHOUT_ENUM);
 	BIND_ENUM_CONSTANT(OUTSIDE_OF_CLASS);
+
+
+	// Test extension reloading
+	ClassDB::bind_method(D_METHOD("get_reload_count"), &Example::get_reload_count);
+	ClassDB::bind_method(D_METHOD("set_reload_count"), &Example::set_reload_count);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "reload_count"), "set_reload_count", "get_reload_count");
 }
 
 bool Example::has_object_instance_binding() const {
@@ -323,6 +334,15 @@ Example::~Example() {
 }
 
 // Methods.
+
+auto Example::get_reload_count() -> int {
+	return reloaded_count;
+}
+
+auto Example::set_reload_count(const int value ) -> void {
+	reloaded_count = value;
+}
+
 void Example::simple_func() {
 	emit_custom_signal("simple_func", 3);
 }

test/src/example.h

@@ -80,6 +80,7 @@ class Example : public Control {
 	String _to_string() const;
 
 private:
+	int reloaded_count = 0;
 	Vector2 custom_position;
 	Vector3 property_from_list;
 	Vector2 dprop[3];
@@ -107,6 +108,9 @@ class Example : public Control {
 	Example();
 	~Example();
 
+	auto get_reload_count() -> int;
+	auto set_reload_count(int value) -> void;
+
 	// Functions.
 	void simple_func();
 	void simple_const_func() const;

test/src/register_types.cpp

@@ -12,38 +12,103 @@
 #include <godot_cpp/godot.hpp>
 
 #include "example.h"
+#include "godot_cpp/classes/dir_access.hpp"
+#include "godot_cpp/classes/editor_interface.hpp"
+#include "godot_cpp/classes/engine.hpp"
+#include "godot_cpp/classes/file_access.hpp"
+#include "godot_cpp/classes/gd_extension_manager.hpp"
 #include "tests.h"
 
 using namespace godot;
 
+// Global flag to control the timer thread
+std::atomic keep_running(true);
+
+// Function to simulate extension reload
+void trigger_extension_reload() {
+	if (Engine::get_singleton()->is_editor_hint()) {
+		if (const EditorInterface *ei = EditorInterface::get_singleton(); ei->get_edited_scene_root()) {
+			UtilityFunctions::print("Editor has a loaded scene: ", ei->get_edited_scene_root()->get_name());
+		} else {
+			return;
+		}
+	}
+
+	keep_running = false;
+	const auto gdextension_path = String{"res://example.gdextension"};
+	UtilityFunctions::print("Simulating GDExtension reload...");
+
+	// Reload all extensions
+	if (GDExtensionManager *ext_manager = GDExtensionManager::get_singleton()) {
+		ext_manager->call_deferred("reload_extension", gdextension_path );
+		UtilityFunctions::print("GDExtensionManager::reload_extension(...) called successfully.");
+	} else {
+		UtilityFunctions::print("Error: GDExtensionManager singleton not available.");
+	}
+}
+
+// Timer thread function
+void timer_thread_function(const float interval_seconds) {
+	// Single cycle for testing: sleep once, trigger reload, then exit (keep_running=false in trigger).
+	while (keep_running) {
+		std::this_thread::sleep_for(std::chrono::seconds(static_cast<int>(interval_seconds)));
+		trigger_extension_reload();
+	}
+}
+
 void initialize_example_module(ModuleInitializationLevel p_level) {
-	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
-		return;
+	if (p_level == MODULE_INITIALIZATION_LEVEL_SCENE) {
+		UtilityFunctions::print( "Initializing Integration Testing Extension" );
+		GDREGISTER_CLASS(ExampleRef);
+		GDREGISTER_CLASS(ExampleMin);
+		GDREGISTER_CLASS(Example);
+		GDREGISTER_VIRTUAL_CLASS(ExampleVirtual);
+		GDREGISTER_ABSTRACT_CLASS(ExampleAbstractBase);
+		GDREGISTER_CLASS(ExampleConcrete);
+		GDREGISTER_CLASS(ExampleBase);
+		GDREGISTER_CLASS(ExampleChild);
+		GDREGISTER_RUNTIME_CLASS(ExampleRuntime);
+		GDREGISTER_CLASS(ExamplePrzykład);
+		GDREGISTER_INTERNAL_CLASS(ExampleInternal);
 	}
+	else if (p_level == MODULE_INITIALIZATION_LEVEL_EDITOR) {
+		const String lock_path = "user://extension_timer_started";
+		for ( const auto &arg : OS::get_singleton()->get_cmdline_args() ) {
+			if (arg.begins_with("reload") && !FileAccess::file_exists(lock_path)) {
+
+				constexpr float reload_interval = 3.0f;
+				UtilityFunctions::print("No lock file found; starting timer thread for hot-reload test.");
+				std::thread timer_thread(timer_thread_function, reload_interval);
+				timer_thread.detach(); // Detach the thread to run independently
 
-	GDREGISTER_CLASS(ExampleRef);
-	GDREGISTER_CLASS(ExampleMin);
-	GDREGISTER_CLASS(Example);
-	GDREGISTER_VIRTUAL_CLASS(ExampleVirtual);
-	GDREGISTER_ABSTRACT_CLASS(ExampleAbstractBase);
-	GDREGISTER_CLASS(ExampleConcrete);
-	GDREGISTER_CLASS(ExampleBase);
-	GDREGISTER_CLASS(ExampleChild);
-	GDREGISTER_RUNTIME_CLASS(ExampleRuntime);
-	GDREGISTER_CLASS(ExamplePrzykład);
-	GDREGISTER_INTERNAL_CLASS(ExampleInternal);
+				// Create the lock file to prevent future inits from starting duplicates.
+				if (const Ref<FileAccess> lock_file = FileAccess::open(lock_path, FileAccess::WRITE); lock_file.is_valid()) {
+					lock_file->close();
+				} else {
+					UtilityFunctions::print("Warning: Failed to create lock file.");
+				}
+			} else {
+				UtilityFunctions::print("Lock file exists; skipping timer thread start (already triggered reload).");
+			}
+		}
+	}
 }
 
 void uninitialize_example_module(ModuleInitializationLevel p_level) {
-	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
-		return;
+	if (p_level == MODULE_INITIALIZATION_LEVEL_SCENE) {
+		UtilityFunctions::print( "Uninitializing Integration Testing Extension" );
+	}
+	else if (p_level == MODULE_INITIALIZATION_LEVEL_EDITOR) {
+		// Stop the timer thread when deinitializing
+		keep_running = false;
 	}
 }
 
+
 extern "C" {
 // Initialization.
 GDExtensionBool GDE_EXPORT example_library_init(GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, GDExtensionInitialization *r_initialization) {
-	godot::GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, r_initialization);
+	GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, r_initialization);
 
 	init_obj.register_initializer(initialize_example_module);
 	init_obj.register_terminator(uninitialize_example_module);