Ensure GDExtension class is the correct type for the Godot engine class

Author: dsnopek

binding_generator.py

@@ -128,6 +128,8 @@ def get_file_list(api_filepath, output_dir, headers=False, sources=False):
  if sources:
  utility_functions_source_path = source_gen_folder / "variant" / "utility_functions.cpp"
  files.append(str(utility_functions_source_path.as_posix()))
+ register_engine_classes_source_path = source_gen_folder / "register_engine_classes.cpp"
+ files.append(str(register_engine_classes_source_path.as_posix()))
 
  return files
 
@@ -1157,6 +1159,10 @@ def generate_engine_classes_bindings(api, output_dir, use_template_get_node):
  generate_engine_class_source(class_api, used_classes, fully_used_classes, use_template_get_node)
  )
 
+ register_engine_classes_filename = Path(output_dir) / "src" / "register_engine_classes.cpp"
+ with register_engine_classes_filename.open("w+") as source_file:
+ source_file.write(generate_register_engine_classes_source(api))
+
  for native_struct in api["native_structures"]:
  struct_name = native_struct["name"]
  snake_struct_name = camel_to_snake(struct_name)
@@ -1551,6 +1557,38 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
  return "\n".join(result)
 
 
+def generate_register_engine_classes_source(api):
+ includes = []
+ registrations = []
+
+ for class_api in api["classes"]:
+ if class_api["name"] == "ClassDB":
+ continue
+
+ class_name = class_api["name"]
+ snake_class_name = camel_to_snake(class_name)
+
+ includes.append(f"#include <godot_cpp/classes/{snake_class_name}.hpp>")
+ registrations.append(f"\tClassDB::register_engine_class<{class_name}>();")
+
+ result = []
+ add_header(f"register_engine_classes.cpp", result)
+
+ result.append("#include <godot_cpp/godot.hpp>")
+ result.append("")
+ result = result + includes
+ result.append("")
+ result.append("namespace godot {")
+ result.append("")
+ result.append("void GDExtensionBinding::register_engine_classes() {")
+ result = result + registrations
+ result.append("}")
+ result.append("")
+ result.append("} // namespace godot ")
+
+ return "\n".join(result)
+
+
 def generate_global_constants(api, output_dir):
  include_gen_folder = Path(output_dir) / "include" / "godot_cpp" / "classes"
  source_gen_folder = Path(output_dir) / "src" / "classes"

gdextension/gdextension_interface.h

@@ -573,6 +573,7 @@ typedef struct {
 
 void (*object_set_instance)(GDExtensionObjectPtr p_o, GDExtensionConstStringNamePtr p_classname, GDExtensionClassInstancePtr p_instance); /* p_classname should be a registered extension class and should extend the p_o object's class. */
 
+GDExtensionBool (*object_get_class_name)(GDExtensionConstObjectPtr p_object, GDExtensionStringNamePtr r_class_name);
 GDExtensionObjectPtr (*object_cast_to)(GDExtensionConstObjectPtr p_object, void *p_class_tag);
 GDExtensionObjectPtr (*object_get_instance_from_id)(GDObjectInstanceID p_instance_id);
 GDObjectInstanceID (*object_get_instance_id)(GDExtensionConstObjectPtr p_object);

include/godot_cpp/classes/ref.hpp

@@ -243,7 +243,7 @@ struct PtrToArg<Ref<T>> {
 GDExtensionRefPtr ref = (GDExtensionRefPtr)p_ptr;
 ERR_FAIL_NULL_V(ref, Ref<T>());
 
-T *obj = reinterpret_cast<T *>(godot::internal::gde_interface->object_get_instance_binding(godot::internal::gde_interface->ref_get_object(ref), godot::internal::token, &T::___binding_callbacks));
+T *obj = reinterpret_cast<T *>(godot::internal::get_object_instance_binding(godot::internal::gde_interface->ref_get_object(ref)));
 return Ref<T>(obj);
 }
 
@@ -266,7 +266,7 @@ struct PtrToArg<const Ref<T> &> {
 typedef Ref<T> EncodeT;
 
 _FORCE_INLINE_ static Ref<T> convert(const void *p_ptr) {
-return Ref<T>(reinterpret_cast<T *>(godot::internal::gde_interface->object_get_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr)), godot::internal::token, &T::___binding_callbacks)));
+return Ref<T>(reinterpret_cast<T *>(godot::internal::get_object_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr)))));
 }
 };
 

include/godot_cpp/core/class_db.hpp

@@ -104,6 +104,7 @@ class ClassDB {
 private:
 // This may only contain custom classes, not Godot classes
 static std::unordered_map<StringName, ClassInfo> classes;
+static std::unordered_map<StringName, const GDExtensionInstanceBindingCallbacks *> instance_binding_callbacks;
 
 static MethodBind *bind_methodfi(uint32_t p_flags, MethodBind *p_bind, const MethodDefinition &method_name, const void **p_defs, int p_defcount);
 static void initialize_class(const ClassInfo &cl);
@@ -117,6 +118,8 @@ class ClassDB {
 static void register_class(bool p_virtual = false);
 template <class T>
 static void register_abstract_class();
+template <class T>
+static void register_engine_class();
 
 template <class N, class M, typename... VarArgs>
 static MethodBind *bind_method(N p_method_name, M p_method, VarArgs... p_args);
@@ -137,6 +140,7 @@ class ClassDB {
 static MethodBind *get_method(const StringName &p_class, const StringName &p_method);
 
 static GDExtensionClassCallVirtual get_virtual_func(void *p_userdata, GDExtensionConstStringNamePtr p_name);
+static const GDExtensionInstanceBindingCallbacks *get_instance_binding_callbacks(const StringName &p_class);
 
 static void initialize(GDExtensionInitializationLevel p_level);
 static void deinitialize(GDExtensionInitializationLevel p_level);
@@ -161,6 +165,8 @@ class ClassDB {
 
 template <class T, bool is_abstract>
 void ClassDB::_register_class(bool p_virtual) {
+instance_binding_callbacks[T::get_class_static()] = &T::___binding_callbacks;
+
 // Register this class within our plugin
 ClassInfo cl;
 cl.name = T::get_class_static();
@@ -213,6 +219,11 @@ void ClassDB::register_abstract_class() {
 ClassDB::_register_class<T, true>();
 }
 
+template <class T>
+void ClassDB::register_engine_class() {
+instance_binding_callbacks[T::get_class_static()] = &T::___binding_callbacks;
+}
+
 template <class N, class M, typename... VarArgs>
 MethodBind *ClassDB::bind_method(N p_method_name, M p_method, VarArgs... p_args) {
 Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.

include/godot_cpp/core/engine_ptrcall.hpp

@@ -51,7 +51,7 @@ O *_call_native_mb_ret_obj(const GDExtensionMethodBindPtr mb, void *instance, co
 if (ret == nullptr) {
 return nullptr;
 }
-return reinterpret_cast<O *>(internal::gde_interface->object_get_instance_binding(ret, internal::token, &O::___binding_callbacks));
+return reinterpret_cast<O *>(internal::get_object_instance_binding(ret));
 }
 
 template <class R, class... Args>
@@ -81,7 +81,7 @@ Object *_call_utility_ret_obj(const GDExtensionPtrUtilityFunction func, void *in
 GodotObject *ret = nullptr;
 std::array<GDExtensionConstTypePtr, sizeof...(Args)> mb_args = { { (GDExtensionConstTypePtr)args... } };
 func(&ret, mb_args.data(), mb_args.size());
-return (Object *)internal::gde_interface->object_get_instance_binding(ret, internal::token, &Object::___binding_callbacks);
+return (Object *)internal::get_object_instance_binding(ret);
 }
 
 template <class... Args>

include/godot_cpp/core/method_ptrcall.hpp

@@ -33,6 +33,7 @@
 
 #include <godot_cpp/core/defs.hpp>
 
+#include <godot_cpp/core/object.hpp>
 #include <godot_cpp/godot.hpp>
 #include <godot_cpp/variant/variant.hpp>
 
@@ -168,7 +169,7 @@ MAKE_PTRARG_BY_REFERENCE(Variant);
 template <class T>
 struct PtrToArg<T *> {
 _FORCE_INLINE_ static T *convert(const void *p_ptr) {
-return reinterpret_cast<T *>(godot::internal::gde_interface->object_get_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr)), godot::internal::token, &T::___binding_callbacks));
+return reinterpret_cast<T *>(godot::internal::get_object_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr))));
 }
 typedef Object *EncodeT;
 _FORCE_INLINE_ static void encode(T *p_var, void *p_ptr) {
@@ -179,7 +180,7 @@ struct PtrToArg<T *> {
 template <class T>
 struct PtrToArg<const T *> {
 _FORCE_INLINE_ static const T *convert(const void *p_ptr) {
-return reinterpret_cast<const T *>(godot::internal::gde_interface->object_get_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr)), godot::internal::token, &T::___binding_callbacks));
+return reinterpret_cast<const T *>(godot::internal::get_object_instance_binding(*reinterpret_cast<GDExtensionObjectPtr *>(const_cast<void *>(p_ptr))));
 }
 typedef const Object *EncodeT;
 _FORCE_INLINE_ static void encode(T *p_var, void *p_ptr) {

include/godot_cpp/core/object.hpp

@@ -52,6 +52,12 @@
 
 namespace godot {
 
+namespace internal {
+
+Object *get_object_instance_binding(GodotObject *);
+
+} // namespace internal
+
 struct MethodInfo {
 StringName name;
 PropertyInfo return_val;
@@ -128,7 +134,7 @@ class ObjectDB {
 if (obj == nullptr) {
 return nullptr;
 }
-return reinterpret_cast<Object *>(internal::gde_interface->object_get_instance_binding(obj, internal::token, &Object::___binding_callbacks));
+return internal::get_object_instance_binding(obj);
 }
 };
 
@@ -142,7 +148,7 @@ T *Object::cast_to(Object *p_object) {
 if (casted == nullptr) {
 return nullptr;
 }
-return dynamic_cast<T *>((Object *)internal::gde_interface->object_get_instance_binding(casted, internal::token, &T::___binding_callbacks));
+return dynamic_cast<T *>(internal::get_object_instance_binding(casted));
 }
 
 template <class T>
@@ -155,7 +161,7 @@ const T *Object::cast_to(const Object *p_object) {
 if (casted == nullptr) {
 return nullptr;
 }
-return dynamic_cast<const T *>((Object *)internal::gde_interface->object_get_instance_binding(casted, internal::token, &T::___binding_callbacks));
+return dynamic_cast<const T *>(internal::get_object_instance_binding(casted));
 }
 
 } // namespace godot

include/godot_cpp/godot.hpp

@@ -51,6 +51,9 @@ enum ModuleInitializationLevel {
 };
 
 class GDExtensionBinding {
+private:
+static void register_engine_classes();
+
 public:
 using Callback = void (*)(ModuleInitializationLevel p_level);
 

src/core/class_db.cpp

@@ -40,6 +40,7 @@
 namespace godot {
 
 std::unordered_map<StringName, ClassDB::ClassInfo> ClassDB::classes;
+std::unordered_map<StringName, const GDExtensionInstanceBindingCallbacks *> ClassDB::instance_binding_callbacks;
 GDExtensionInitializationLevel ClassDB::current_level = GDEXTENSION_INITIALIZATION_CORE;
 
 MethodDefinition D_METHOD(StringName p_name) {
@@ -314,6 +315,12 @@ GDExtensionClassCallVirtual ClassDB::get_virtual_func(void *p_userdata, GDExtens
 return nullptr;
 }
 
+const GDExtensionInstanceBindingCallbacks *ClassDB::get_instance_binding_callbacks(const StringName &p_class) {
+std::unordered_map<StringName, const GDExtensionInstanceBindingCallbacks *>::iterator callbacks_it = instance_binding_callbacks.find(p_class);
+ERR_FAIL_COND_V_MSG(callbacks_it == instance_binding_callbacks.end(), nullptr, String("Cannot find instance binding callbacks for class '{0}'.").format(Array::make(p_class)));
+return callbacks_it->second;
+}
+
 void ClassDB::bind_virtual_method(const StringName &p_class, const StringName &p_method, GDExtensionClassCallVirtual p_call) {
 std::unordered_map<StringName, ClassInfo>::iterator type_it = classes.find(p_class);
 ERR_FAIL_COND_MSG(type_it == classes.end(), String("Class '{0}' doesn't exist.").format(Array::make(p_class)));

src/core/object.cpp

@@ -30,8 +30,38 @@
 
 #include <godot_cpp/core/object.hpp>
 
+#include <godot_cpp/core/class_db.hpp>
+
 namespace godot {
 
+namespace internal {
+
+Object *get_object_instance_binding(GodotObject *p_engine_object) {
+if (p_engine_object == nullptr) {
+return nullptr;
+}
+
+// Get existing instance binding, if one already exists.
+GDExtensionObjectPtr instance = gde_interface->object_get_instance_binding(p_engine_object, token, nullptr);
+if (instance != nullptr) {
+return reinterpret_cast<Object *>(instance);
+}
+
+// Otherwise, try to look up the correct binding callbacks.
+const GDExtensionInstanceBindingCallbacks *binding_callbacks = nullptr;
+StringName class_name;
+if (gde_interface->object_get_class_name(p_engine_object, reinterpret_cast<GDExtensionStringNamePtr>(class_name._native_ptr()))) {
+binding_callbacks = ClassDB::get_instance_binding_callbacks(class_name);
+}
+if (binding_callbacks == nullptr) {
+binding_callbacks = &Object::___binding_callbacks;
+}
+
+return reinterpret_cast<Object *>(gde_interface->object_get_instance_binding(p_engine_object, token, binding_callbacks));
+}
+
+} // namespace internal
+
 MethodInfo::MethodInfo() :
 flags(GDEXTENSION_METHOD_FLAG_NORMAL) {}