Fix deriving a custom class with virtual methods

godotengine · Sep 20, 2022 · 24deaa3 · 24deaa3
1 parent a330342
commit 24deaa3
Show file tree

Hide file tree

Showing 2 changed files with 11 additions and 6 deletions.
diff --git a/binding_generator.py b/binding_generator.py
@@ -1071,17 +1071,22 @@ def generate_engine_class_header(class_api, used_classes, fully_used_classes, us
             result.append(method_signature + ";")
 
     result.append("protected:")
-    result.append("\ttemplate <class T>")
+    # T is the custom class we want to register (from which the call initiates, going up the inheritance chain),
+    # B is its base class (can be a custom class too, that's why we pass it).
+    result.append("\ttemplate <class T, class B>")
     result.append("\tstatic void register_virtuals() {")
     if class_name != "Object":
-        result.append(f"\t\t{inherits}::register_virtuals<T>();")
+        result.append(f"\t\t{inherits}::register_virtuals<T, B>();")
         if "methods" in class_api:
             for method in class_api["methods"]:
                 if not method["is_virtual"]:
                     continue
                 method_name = escape_identifier(method["name"])
                 result.append(
-                    f"\t\tif constexpr (!std::is_same_v<decltype(&{class_name}::{method_name}),decltype(&T::{method_name})>) {{"
+                    # If the method is different from the base class, it means T overrides it, so it needs to be bound.
+                    # Note that with an `if constexpr`, the code inside the `if` will not even be compiled if the
+                    # condition returns false (in such cases it can't compile due to ambiguity).
+                    f"\t\tif constexpr (!std::is_same_v<decltype(&B::{method_name}),decltype(&T::{method_name})>) {{"
                 )
                 result.append(f"\t\t\tBIND_VIRTUAL_METHOD(T, {method_name});")
                 result.append("\t\t}")

diff --git a/include/godot_cpp/classes/wrapped.hpp b/include/godot_cpp/classes/wrapped.hpp
@@ -145,9 +145,9 @@ protected:
 		return (::godot::String(::godot::Wrapped::*)()) & m_class::_to_string;                                                                           \
 	}                                                                                                                                                    \
                                                                                                                                                          \
-	template <class T>                                                                                                                                   \
+	template <class T, class B>                                                                                                                          \
 	static void register_virtuals() {                                                                                                                    \
-		m_inherits::register_virtuals<T>();                                                                                                              \
+		m_inherits::register_virtuals<T, B>();                                                                                                           \
 	}                                                                                                                                                    \
                                                                                                                                                          \
 public:                                                                                                                                                  \
@@ -159,7 +159,7 @@ public:
 		m_inherits::initialize_class();                                                                                                                  \
 		if (m_class::_get_bind_methods() != m_inherits::_get_bind_methods()) {                                                                           \
 			_bind_methods();                                                                                                                             \
-			m_inherits::register_virtuals<m_class>();                                                                                                    \
+			m_inherits::register_virtuals<m_class, m_inherits>();                                                                                        \
 		}                                                                                                                                                \
 		initialized = true;                                                                                                                              \
 	}                                                                                                                                                    \