Skip to content

Inherited methods bindings #900

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 4 commits into
base: master
Choose a base branch
from
Open

Inherited methods bindings #900

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
71139af
Implement bind_inherited_method
PapyChacal Oct 24, 2022
81500bd
Add an inherited method binding to the example.
PapyChacal Oct 24, 2022
8b34b8e
Remove the TYPED_METHOD_BIND conditional.
PapyChacal Oct 24, 2022
29d64f2
Enforce TYPED_METHOD_BIND.
PapyChacal Oct 25, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 14 additions & 0 deletions include/godot_cpp/core/class_db.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -117,6 +117,9 @@ class ClassDB {
template <class T>
static void register_abstract_class();

template <class C, class N, class M, typename... VarArgs>
static MethodBind *bind_inherited_method(N p_method_name, M p_method, VarArgs... p_args);

template <class N, class M, typename... VarArgs>
static MethodBind *bind_method(N p_method_name, M p_method, VarArgs... p_args);

Expand Down Expand Up @@ -212,6 +215,17 @@ void ClassDB::register_abstract_class() {
ClassDB::_register_class<T, true>();
}

template <class C, class N, class M, typename... VarArgs>
MethodBind *ClassDB::bind_inherited_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.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
MethodBind *bind = create_inherited_method_bind<C>(p_method);
return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, p_method_name, sizeof...(p_args) == 0 ? nullptr : (const void **)argptrs, sizeof...(p_args));
}

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.
Expand Down
115 changes: 36 additions & 79 deletions include/godot_cpp/core/method_bind.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -271,22 +271,11 @@ MethodBind *create_vararg_method_bind(R (T::*p_method)(const Variant **, GDNativ
return a;
}

#ifndef TYPED_METHOD_BIND
class ___UnexistingClass;
#define MB_T ___UnexistingClass
#else
#define MB_T T
#endif

// No return, not const.

#ifdef TYPED_METHOD_BIND
template <class T, class... P>
#else
template <class... P>
#endif // TYPED_METHOD_BIND
class MethodBindT : public MethodBind {
void (MB_T::*method)(P...);
void (T::*method)(P...);

protected:
// GCC raises warnings in the case P = {} as the comparison is always false...
Expand Down Expand Up @@ -321,48 +310,39 @@ class MethodBindT : public MethodBind {
}

virtual Variant call(GDExtensionClassInstancePtr p_instance, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeCallError &r_error) const {
#ifdef TYPED_METHOD_BIND
call_with_variant_args_dv(static_cast<T *>(p_instance), method, p_args, (int)p_argument_count, r_error, get_default_arguments());
#else
call_with_variant_args_dv(reinterpret_cast<MB_T *>(p_instance), method, p_args, p_argument_count, r_error, get_default_arguments());
#endif
return Variant();
}
virtual void ptrcall(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret) const {
#ifdef TYPED_METHOD_BIND
call_with_ptr_args<T, P...>(static_cast<T *>(p_instance), method, p_args, nullptr);
#else
call_with_ptr_args<MB_T, P...>(reinterpret_cast<MB_T *>(p_instance), method, p_args, nullptr);
#endif // TYPED_METHOD_BIND
}

MethodBindT(void (MB_T::*p_method)(P...)) {
MethodBindT(void (T::*p_method)(P...)) {
method = p_method;
generate_argument_types(sizeof...(P));
set_argument_count(sizeof...(P));
}
};

template <class C, class T, class... P>
MethodBind *create_inherited_method_bind(void (T::*p_method)(P...)) {
MethodBind *a = memnew((MethodBindT<C, P...>)(p_method));
a->set_instance_class(C::get_class_static());
return a;
}

template <class T, class... P>
MethodBind *create_method_bind(void (T::*p_method)(P...)) {
#ifdef TYPED_METHOD_BIND
MethodBind *a = memnew((MethodBindT<T, P...>)(p_method));
#else
MethodBind *a = memnew((MethodBindT<P...>)(reinterpret_cast<void (MB_T::*)(P...)>(p_method)));
#endif // TYPED_METHOD_BIND
a->set_instance_class(T::get_class_static());
return a;
}

// No return, const.

#ifdef TYPED_METHOD_BIND
template <class T, class... P>
#else
template <class... P>
#endif // TYPED_METHOD_BIND
class MethodBindTC : public MethodBind {
void (MB_T::*method)(P...) const;
void (T::*method)(P...) const;

protected:
// GCC raises warnings in the case P = {} as the comparison is always false...
Expand Down Expand Up @@ -397,48 +377,39 @@ class MethodBindTC : public MethodBind {
}

virtual Variant call(GDExtensionClassInstancePtr p_instance, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeCallError &r_error) const {
#ifdef TYPED_METHOD_BIND
call_with_variant_argsc_dv(static_cast<T *>(p_instance), method, p_args, (int)p_argument_count, r_error, get_default_arguments());
#else
call_with_variant_argsc_dv(reinterpret_cast<MB_T *>(p_instance), method, p_args, p_argument_count, r_error, get_default_arguments());
#endif
return Variant();
}
virtual void ptrcall(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret) const {
#ifdef TYPED_METHOD_BIND
call_with_ptr_args<T, P...>(static_cast<T *>(p_instance), method, p_args, nullptr);
#else
call_with_ptr_args<MB_T, P...>(reinterpret_cast<MB_T *>(p_instance), method, p_args, nullptr);
#endif // TYPED_METHOD_BIND
}

MethodBindTC(void (MB_T::*p_method)(P...) const) {
MethodBindTC(void (T::*p_method)(P...) const) {
method = p_method;
generate_argument_types(sizeof...(P));
set_argument_count(sizeof...(P));
}
};

template <class C, class T, class... P>
MethodBind *create_method_bind(void (T::*p_method)(P...) const) {
MethodBind *a = memnew((MethodBindTC<C, P...>)(p_method));
a->set_instance_class(T::get_class_static());
return a;
}

template <class T, class... P>
MethodBind *create_method_bind(void (T::*p_method)(P...) const) {
#ifdef TYPED_METHOD_BIND
MethodBind *a = memnew((MethodBindTC<T, P...>)(p_method));
#else
MethodBind *a = memnew((MethodBindTC<P...>)(reinterpret_cast<void (MB_T::*)(P...) const>(p_method)));
#endif // TYPED_METHOD_BIND
a->set_instance_class(T::get_class_static());
return a;
}

// Return, not const.

#ifdef TYPED_METHOD_BIND
template <class T, class R, class... P>
#else
template <class R, class... P>
#endif // TYPED_METHOD_BIND
class MethodBindTR : public MethodBind {
R(MB_T::*method)
R(T::*method)
(P...);

protected:
Expand Down Expand Up @@ -479,49 +450,40 @@ class MethodBindTR : public MethodBind {

virtual Variant call(GDExtensionClassInstancePtr p_instance, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeCallError &r_error) const {
Variant ret;
#ifdef TYPED_METHOD_BIND
call_with_variant_args_ret_dv(static_cast<T *>(p_instance), method, p_args, (int)p_argument_count, ret, r_error, get_default_arguments());
#else
call_with_variant_args_ret_dv((MB_T *)p_instance, method, p_args, p_argument_count, ret, r_error, get_default_arguments());
#endif
return ret;
}
virtual void ptrcall(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret) const {
#ifdef TYPED_METHOD_BIND
call_with_ptr_args<T, R, P...>(static_cast<T *>(p_instance), method, p_args, r_ret);
#else
call_with_ptr_args<MB_T, R, P...>(reinterpret_cast<MB_T *>(p_instance), method, p_args, r_ret);
#endif // TYPED_METHOD_BIND
}

MethodBindTR(R (MB_T::*p_method)(P...)) {
MethodBindTR(R (T::*p_method)(P...)) {
method = p_method;
generate_argument_types(sizeof...(P));
set_argument_count(sizeof...(P));
set_return(true);
}
};

template <class C, class T, class R, class... P>
MethodBind *create_inherited_method_bind(R (T::*p_method)(P...)) {
MethodBind *a = memnew((MethodBindTR<C, R, P...>)(p_method));
a->set_instance_class(C::get_class_static());
return a;
}

template <class T, class R, class... P>
MethodBind *create_method_bind(R (T::*p_method)(P...)) {
#ifdef TYPED_METHOD_BIND
MethodBind *a = memnew((MethodBindTR<T, R, P...>)(p_method));
#else
MethodBind *a = memnew((MethodBindTR<R, P...>)(reinterpret_cast<R (MB_T::*)(P...)>(p_method)));
#endif // TYPED_METHOD_BIND
a->set_instance_class(T::get_class_static());
return a;
}

// Return, const.

#ifdef TYPED_METHOD_BIND
template <class T, class R, class... P>
#else
template <class R, class... P>
#endif // TYPED_METHOD_BIND
class MethodBindTRC : public MethodBind {
R(MB_T::*method)
R(T::*method)
(P...) const;

protected:
Expand Down Expand Up @@ -562,36 +524,31 @@ class MethodBindTRC : public MethodBind {

virtual Variant call(GDExtensionClassInstancePtr p_instance, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeCallError &r_error) const {
Variant ret;
#ifdef TYPED_METHOD_BIND
call_with_variant_args_retc_dv(static_cast<T *>(p_instance), method, p_args, (int)p_argument_count, ret, r_error, get_default_arguments());
#else
call_with_variant_args_retc_dv((MB_T *)p_instance, method, p_args, p_argument_count, ret, r_error, get_default_arguments());
#endif
return ret;
}
virtual void ptrcall(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret) const {
#ifdef TYPED_METHOD_BIND
call_with_ptr_args<T, R, P...>(static_cast<T *>(p_instance), method, p_args, r_ret);
#else
call_with_ptr_args<MB_T, R, P...>(reinterpret_cast<MB_T *>(p_instance), method, p_args, r_ret);
#endif // TYPED_METHOD_BIND
}

MethodBindTRC(R (MB_T::*p_method)(P...) const) {
MethodBindTRC(R (T::*p_method)(P...) const) {
method = p_method;
generate_argument_types(sizeof...(P));
set_argument_count(sizeof...(P));
set_return(true);
}
};

template <class C, class T, class R, class... P>
MethodBind *create_inherited_method_bind(R (T::*p_method)(P...) const) {
MethodBind *a = memnew((MethodBindTRC<C, R, P...>)(p_method));
a->set_instance_class(C::get_class_static());
return a;
}

template <class T, class R, class... P>
MethodBind *create_method_bind(R (T::*p_method)(P...) const) {
#ifdef TYPED_METHOD_BIND
MethodBind *a = memnew((MethodBindTRC<T, R, P...>)(p_method));
#else
MethodBind *a = memnew((MethodBindTRC<R, P...>)(reinterpret_cast<R (MB_T::*)(P...) const>(p_method)));
#endif // TYPED_METHOD_BIND
a->set_instance_class(T::get_class_static());
return a;
}
Expand Down
13 changes: 13 additions & 0 deletions test/src/example.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -270,3 +270,16 @@ bool Example::_has_point(const Vector2 &point) const {

return false;
}

void ExampleBaseClass::example_void_method() {
return;
}

int ExampleBaseClass::example_int_method() {
return 42;
}

void ExampleInheriting::_bind_methods() {
ClassDB::bind_inherited_method<ExampleInheriting>(D_METHOD("example_void_method"), &ExampleInheriting::example_void_method);
ClassDB::bind_inherited_method<ExampleInheriting>(D_METHOD("example_int_method"), &ExampleInheriting::example_int_method);
}
13 changes: 13 additions & 0 deletions test/src/example.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -121,4 +121,17 @@ class ExampleAbstract : public Object {
static void _bind_methods() {}
};

class ExampleBaseClass {
public:
void example_void_method();
int example_int_method();
};

class ExampleInheriting : public ExampleBaseClass, public Object {
GDCLASS(ExampleInheriting, Object)

protected:
static void _bind_methods();
};

#endif // EXAMPLE_CLASS_H