Sara.Sync
/
godot-cpp
mirror of https://github.com/godotengine/godot-cpp
0
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Identifiers containing double underscore are reserved according to the C++ standard 

Rename __* to _gde_*

https://timsong-cpp.github.io/cppwp/n3337/global.names

https://en.cppreference.com/w/cpp/language/identifiers

Identifiers appearing as a token or preprocessing token (i.e., not in user-defined-string-literal like operator ""id) (since C++11) of one of the following forms are reserved:
 - identifiers with a double underscore anywhere;
 - identifiers that begin with an underscore followed by an uppercase letter;
 - in the global namespace, identifiers that begin with an underscore.
pull/1048/head
Andy Maloney 2023-02-16 10:38:38 -05:00
parent 1bc9ca7b57
commit db2394dbe7
7 changed files with 130 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
binding_generator.py
View File

@ -791,24 +791,24 @@ def generate_builtin_class_source(builtin_api, size, used_classes, fully_used_cl
result.append("\tString::_init_bindings_constructors_destructor();") result.append("\tString::_init_bindings_constructors_destructor();")
result.append(f"\t{class_name}::_init_bindings_constructors_destructor();") result.append(f"\t{class_name}::_init_bindings_constructors_destructor();")
result.append("\tStringName __name;") result.append("\tStringName _gde_name;")
if "methods" in builtin_api: if "methods" in builtin_api:
for method in builtin_api["methods"]: for method in builtin_api["methods"]:
# TODO: Add error check for hash mismatch. # TODO: Add error check for hash mismatch.
result.append(f'\t__name = StringName("{method["name"]}");') result.append(f'\t_gde_name = StringName("{method["name"]}");')
result.append( result.append(
f'\t_method_bindings.method_{method["name"]} = internal::gdextension_interface_variant_get_ptr_builtin_method({enum_type_name}, __name._native_ptr(), {method["hash"]});' f'\t_method_bindings.method_{method["name"]} = internal::gdextension_interface_variant_get_ptr_builtin_method({enum_type_name}, _gde_name._native_ptr(), {method["hash"]});'
) )
if "members" in builtin_api: if "members" in builtin_api:
for member in builtin_api["members"]: for member in builtin_api["members"]:
result.append(f'\t__name = StringName("{member["name"]}");') result.append(f'\t_gde_name = StringName("{member["name"]}");')
result.append( result.append(
f'\t_method_bindings.member_{member["name"]}_setter = internal::gdextension_interface_variant_get_ptr_setter({enum_type_name}, __name._native_ptr());' f'\t_method_bindings.member_{member["name"]}_setter = internal::gdextension_interface_variant_get_ptr_setter({enum_type_name}, _gde_name._native_ptr());'
) )
result.append( result.append(
f'\t_method_bindings.member_{member["name"]}_getter = internal::gdextension_interface_variant_get_ptr_getter({enum_type_name}, __name._native_ptr());' f'\t_method_bindings.member_{member["name"]}_getter = internal::gdextension_interface_variant_get_ptr_getter({enum_type_name}, _gde_name._native_ptr());'
) )
if "indexing_return_type" in builtin_api: if "indexing_return_type" in builtin_api:
@ -1443,15 +1443,15 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
if is_singleton: if is_singleton:
result.append(f"{class_name} *{class_name}::get_singleton() {{") result.append(f"{class_name} *{class_name}::get_singleton() {{")
result.append(f"\tconst StringName __class_name = {class_name}::get_class_static();") result.append(f"\tconst StringName _gde_class_name = {class_name}::get_class_static();")
result.append( result.append(
"\tstatic GDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton(__class_name._native_ptr());" "\tstatic GDExtensionObjectPtr singleton_obj = internal::gdextension_interface_global_get_singleton(_gde_class_name._native_ptr());"
) )
result.append("#ifdef DEBUG_ENABLED") result.append("#ifdef DEBUG_ENABLED")
result.append("\tERR_FAIL_COND_V(singleton_obj == nullptr, nullptr);") result.append("\tERR_FAIL_COND_V(singleton_obj == nullptr, nullptr);")
result.append("#endif // DEBUG_ENABLED") result.append("#endif // DEBUG_ENABLED")
result.append( result.append(
f"\tstatic {class_name} *singleton = reinterpret_cast<{class_name} *>(internal::gdextension_interface_object_get_instance_binding(singleton_obj, internal::token, &{class_name}::___binding_callbacks));" f"\tstatic {class_name} *singleton = reinterpret_cast<{class_name} *>(internal::gdextension_interface_object_get_instance_binding(singleton_obj, internal::token, &{class_name}::_gde_binding_callbacks));"
) )
result.append("\treturn singleton;") result.append("\treturn singleton;")
result.append("}") result.append("}")
@ -1470,20 +1470,20 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
result.append(method_signature + " {") result.append(method_signature + " {")
# Method body. # Method body.
result.append(f"\tconst StringName __class_name = {class_name}::get_class_static();") result.append(f"\tconst StringName _gde_class_name = {class_name}::get_class_static();")
result.append(f'\tconst StringName __method_name = "{method["name"]}";') result.append(f'\tconst StringName _gde_method_name = "{method["name"]}";')
result.append( result.append(
f'\tstatic GDExtensionMethodBindPtr ___method_bind = internal::gdextension_interface_classdb_get_method_bind(__class_name._native_ptr(), __method_name._native_ptr(), {method["hash"]});' f'\tstatic GDExtensionMethodBindPtr _gde_method_bind = internal::gdextension_interface_classdb_get_method_bind(_gde_class_name._native_ptr(), _gde_method_name._native_ptr(), {method["hash"]});'
) )
method_call = "\t" method_call = "\t"
has_return = "return_value" in method and method["return_value"]["type"] != "void" has_return = "return_value" in method and method["return_value"]["type"] != "void"
if has_return: if has_return:
result.append( result.append(
f'\tCHECK_METHOD_BIND_RET(___method_bind, {get_default_value_for_type(method["return_value"]["type"])});' f'\tCHECK_METHOD_BIND_RET(_gde_method_bind, {get_default_value_for_type(method["return_value"]["type"])});'
) )
else: else:
result.append("\tCHECK_METHOD_BIND(___method_bind);") result.append("\tCHECK_METHOD_BIND(_gde_method_bind);")
is_ref = False is_ref = False
if not vararg: if not vararg:
@ -1492,34 +1492,34 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
meta_type = method["return_value"]["meta"] if "meta" in method["return_value"] else None meta_type = method["return_value"]["meta"] if "meta" in method["return_value"] else None
if is_enum(return_type): if is_enum(return_type):
if method["is_static"]: if method["is_static"]:
method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret<int64_t>(___method_bind, nullptr" method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret<int64_t>(_gde_method_bind, nullptr"
else: else:
method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret<int64_t>(___method_bind, _owner" method_call += f"return ({get_gdextension_type(correct_type(return_type, meta_type))})internal::_call_native_mb_ret<int64_t>(_gde_method_bind, _owner"
elif is_pod_type(return_type) or is_variant(return_type): elif is_pod_type(return_type) or is_variant(return_type):
if method["is_static"]: if method["is_static"]:
method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(___method_bind, nullptr" method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(_gde_method_bind, nullptr"
else: else:
method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(___method_bind, _owner" method_call += f"return internal::_call_native_mb_ret<{get_gdextension_type(correct_type(return_type, meta_type))}>(_gde_method_bind, _owner"
elif is_refcounted(return_type): elif is_refcounted(return_type):
if method["is_static"]: if method["is_static"]:
method_call += f"return Ref<{return_type}>::___internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, nullptr" method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, nullptr"
else: else:
method_call += f"return Ref<{return_type}>::___internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, _owner" method_call += f"return Ref<{return_type}>::_gde_internal_constructor(internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, _owner"
is_ref = True is_ref = True
else: else:
if method["is_static"]: if method["is_static"]:
method_call += ( method_call += (
f"return internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, nullptr" f"return internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, nullptr"
) )
else: else:
method_call += ( method_call += (
f"return internal::_call_native_mb_ret_obj<{return_type}>(___method_bind, _owner" f"return internal::_call_native_mb_ret_obj<{return_type}>(_gde_method_bind, _owner"
) )
else: else:
if method["is_static"]: if method["is_static"]:
method_call += "internal::_call_native_mb_no_ret(___method_bind, nullptr" method_call += "internal::_call_native_mb_no_ret(_gde_method_bind, nullptr"
else: else:
method_call += "internal::_call_native_mb_no_ret(___method_bind, _owner" method_call += "internal::_call_native_mb_no_ret(_gde_method_bind, _owner"
if "arguments" in method: if "arguments" in method:
method_call += ", " method_call += ", "
@ -1536,7 +1536,7 @@ def generate_engine_class_source(class_api, used_classes, fully_used_classes, us
else: # vararg. else: # vararg.
result.append("\tGDExtensionCallError error;") result.append("\tGDExtensionCallError error;")
result.append("\tVariant ret;") result.append("\tVariant ret;")
method_call += "internal::gdextension_interface_object_method_bind_call(___method_bind, _owner, reinterpret_cast<GDExtensionConstVariantPtr *>(args), arg_count, &ret, &error" method_call += "internal::gdextension_interface_object_method_bind_call(_gde_method_bind, _owner, reinterpret_cast<GDExtensionConstVariantPtr *>(args), arg_count, &ret, &error"
if is_ref: if is_ref:
method_call += ")" # Close Ref<> constructor. method_call += ")" # Close Ref<> constructor.
@ -1763,28 +1763,28 @@ def generate_utility_functions(api, output_dir):
# Function body. # Function body.
source.append(f'\tconst StringName __function_name = "{function["name"]}";') source.append(f'\tconst StringName _gde_function_name = "{function["name"]}";')
source.append( source.append(
f'\tstatic GDExtensionPtrUtilityFunction ___function = internal::gdextension_interface_variant_get_ptr_utility_function(__function_name._native_ptr(), {function["hash"]});' f'\tstatic GDExtensionPtrUtilityFunction _gde_function = internal::gdextension_interface_variant_get_ptr_utility_function(_gde_function_name._native_ptr(), {function["hash"]});'
) )
has_return = "return_type" in function and function["return_type"] != "void" has_return = "return_type" in function and function["return_type"] != "void"
if has_return: if has_return:
source.append( source.append(
f'\tCHECK_METHOD_BIND_RET(___function, {get_default_value_for_type(function["return_type"])});' f'\tCHECK_METHOD_BIND_RET(_gde_function, {get_default_value_for_type(function["return_type"])});'
) )
else: else:
source.append("\tCHECK_METHOD_BIND(___function);") source.append("\tCHECK_METHOD_BIND(_gde_function);")
function_call = "\t" function_call = "\t"
if not vararg: if not vararg:
if has_return: if has_return:
function_call += "return " function_call += "return "
if function["return_type"] == "Object": if function["return_type"] == "Object":
function_call += "internal::_call_utility_ret_obj(___function" function_call += "internal::_call_utility_ret_obj(_gde_function"
else: else:
function_call += f'internal::_call_utility_ret<{get_gdextension_type(correct_type(function["return_type"]))}>(___function' function_call += f'internal::_call_utility_ret<{get_gdextension_type(correct_type(function["return_type"]))}>(_gde_function'
else: else:
function_call += "internal::_call_utility_no_ret(___function" function_call += "internal::_call_utility_no_ret(_gde_function"
if "arguments" in function: if "arguments" in function:
function_call += ", " function_call += ", "
@ -1803,7 +1803,7 @@ def generate_utility_functions(api, output_dir):
source.append(f'\t{get_gdextension_type(correct_type(function["return_type"]))} ret;') source.append(f'\t{get_gdextension_type(correct_type(function["return_type"]))} ret;')
else: else:
source.append("\tVariant ret;") source.append("\tVariant ret;")
function_call += "___function(&ret, reinterpret_cast<GDExtensionConstVariantPtr *>(args), arg_count" function_call += "_gde_function(&ret, reinterpret_cast<GDExtensionConstVariantPtr *>(args), arg_count"
function_call += ");" function_call += ");"
source.append(function_call) source.append(function_call)

2
include/godot_cpp/classes/ref.hpp
View File

@ -219,7 +219,7 @@ public:
// Used exclusively in the bindings to recreate the Ref Godot encapsulates in return values, // Used exclusively in the bindings to recreate the Ref Godot encapsulates in return values,
// without adding to the refcount. // without adding to the refcount.
inline static Ref<T> ___internal_constructor(Object *obj) { inline static Ref<T> _gde_internal_constructor(Object *obj) {
Ref<T> r; Ref<T> r;
r.reference = (T *)obj; r.reference = (T *)obj;
return r; return r;

162
include/godot_cpp/classes/wrapped.hpp
View File

@ -109,7 +109,7 @@ protected:
} \ } \
\ \
virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override { \ virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override { \
return &___binding_callbacks; \ return &_gde_binding_callbacks; \
} \ } \
\ \
static void (*_get_bind_methods())() { \ static void (*_get_bind_methods())() { \
@ -288,97 +288,97 @@ public:
} \ } \
} \ } \
\ \
static void *___binding_create_callback(void *p_token, void *p_instance) { \ static void *_gde_binding_create_callback(void *p_token, void *p_instance) { \
return nullptr; \ return nullptr; \
} \ } \
\ \
static void ___binding_free_callback(void *p_token, void *p_instance, void *p_binding) { \ static void _gde_binding_free_callback(void *p_token, void *p_instance, void *p_binding) { \
} \ } \
\ \
static GDExtensionBool ___binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \ static GDExtensionBool _gde_binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \
return true; \ return true; \
} \ } \
\ \
static constexpr GDExtensionInstanceBindingCallbacks ___binding_callbacks = { \ static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = { \
___binding_create_callback, \ _gde_binding_create_callback, \
___binding_free_callback, \ _gde_binding_free_callback, \
___binding_reference_callback, \ _gde_binding_reference_callback, \
}; };
// Don't use this for your classes, use GDCLASS() instead. // Don't use this for your classes, use GDCLASS() instead.
#define GDEXTENSION_CLASS(m_class, m_inherits) \ #define GDEXTENSION_CLASS(m_class, m_inherits) \
private: \ private: \
void operator=(const m_class &p_rval) {} \ void operator=(const m_class &p_rval) {} \
\ \
protected: \ protected: \
virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override { \ virtual const GDExtensionInstanceBindingCallbacks *_get_bindings_callbacks() const override { \
return &___binding_callbacks; \ return &_gde_binding_callbacks; \
} \ } \
\ \
m_class(const char *p_godot_class) : m_inherits(p_godot_class) {} \ m_class(const char *p_godot_class) : m_inherits(p_godot_class) {} \
m_class(GodotObject *p_godot_object) : m_inherits(p_godot_object) {} \ m_class(GodotObject *p_godot_object) : m_inherits(p_godot_object) {} \
\ \
static void (*_get_bind_methods())() { \ static void (*_get_bind_methods())() { \
return nullptr; \ return nullptr; \
} \ } \
\ \
static void (Wrapped::*_get_notification())(int) { \ static void (Wrapped::*_get_notification())(int) { \
return nullptr; \ return nullptr; \
} \ } \
\ \
static bool (Wrapped::*_get_set())(const ::godot::StringName &p_name, const Variant &p_property) { \ static bool (Wrapped::*_get_set())(const ::godot::StringName &p_name, const Variant &p_property) { \
return nullptr; \ return nullptr; \
} \ } \
\ \
static bool (Wrapped::*_get_get())(const ::godot::StringName &p_name, Variant &r_ret) const { \ static bool (Wrapped::*_get_get())(const ::godot::StringName &p_name, Variant &r_ret) const { \
return nullptr; \ return nullptr; \
} \ } \
\ \
static void (Wrapped::*_get_get_property_list())(List<PropertyInfo> * p_list) const { \ static void (Wrapped::*_get_get_property_list())(List<PropertyInfo> * p_list) const { \
return nullptr; \ return nullptr; \
} \ } \
\ \
static bool (Wrapped::*_get_property_can_revert())(const ::godot::StringName &p_name) { \ static bool (Wrapped::*_get_property_can_revert())(const ::godot::StringName &p_name) { \
return nullptr; \ return nullptr; \
} \ } \
\ \
static bool (Wrapped::*_get_property_get_revert())(const ::godot::StringName &p_name, Variant &) { \ static bool (Wrapped::*_get_property_get_revert())(const ::godot::StringName &p_name, Variant &) { \
return nullptr; \ return nullptr; \
} \ } \
\ \
static String (Wrapped::*_get_to_string())() { \ static String (Wrapped::*_get_to_string())() { \
return nullptr; \ return nullptr; \
} \ } \
\ \
public: \ public: \
static void initialize_class() {} \ static void initialize_class() {} \
\ \
static ::godot::StringName &get_class_static() { \ static ::godot::StringName &get_class_static() { \
static ::godot::StringName string_name = ::godot::StringName(#m_class); \ static ::godot::StringName string_name = ::godot::StringName(#m_class); \
return string_name; \ return string_name; \
} \ } \
\ \
static ::godot::StringName &get_parent_class_static() { \ static ::godot::StringName &get_parent_class_static() { \
return m_inherits::get_class_static(); \ return m_inherits::get_class_static(); \
} \ } \
\ \
static void *___binding_create_callback(void *p_token, void *p_instance) { \ static void *_gde_binding_create_callback(void *p_token, void *p_instance) { \
/* Do not call memnew here, we don't want the postinitializer to be called */ \ /* Do not call memnew here, we don't want the post-initializer to be called */ \
return new ("") m_class((GodotObject *)p_instance); \ return new ("") m_class((GodotObject *)p_instance); \
} \ } \
static void ___binding_free_callback(void *p_token, void *p_instance, void *p_binding) { \ static void _gde_binding_free_callback(void *p_token, void *p_instance, void *p_binding) { \
/* Explicitly call the deconstructor to ensure proper lifecycle for non-trivial members */ \ /* Explicitly call the deconstructor to ensure proper lifecycle for non-trivial members */ \
reinterpret_cast<m_class *>(p_binding)->~m_class(); \ reinterpret_cast<m_class *>(p_binding)->~m_class(); \
Memory::free_static(reinterpret_cast<m_class *>(p_binding)); \ Memory::free_static(reinterpret_cast<m_class *>(p_binding)); \
} \ } \
static GDExtensionBool ___binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \ static GDExtensionBool _gde_binding_reference_callback(void *p_token, void *p_instance, GDExtensionBool p_reference) { \
return true; \ return true; \
} \ } \
static constexpr GDExtensionInstanceBindingCallbacks ___binding_callbacks = { \ static constexpr GDExtensionInstanceBindingCallbacks _gde_binding_callbacks = { \
___binding_create_callback, \ _gde_binding_create_callback, \
___binding_free_callback, \ _gde_binding_free_callback, \
___binding_reference_callback, \ _gde_binding_reference_callback, \
}; \ }; \
m_class() : m_class(#m_class) {} m_class() : m_class(#m_class) {}
#endif // GODOT_WRAPPED_HPP #endif // GODOT_WRAPPED_HPP

20
include/godot_cpp/core/class_db.hpp
View File

@ -150,22 +150,22 @@ public:
godot::ClassDB::bind_integer_constant(get_class_static(), "", #m_constant, m_constant); godot::ClassDB::bind_integer_constant(get_class_static(), "", #m_constant, m_constant);
#define BIND_ENUM_CONSTANT(m_constant) \ #define BIND_ENUM_CONSTANT(m_constant) \
godot::ClassDB::bind_integer_constant(get_class_static(), godot::__constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant); godot::ClassDB::bind_integer_constant(get_class_static(), godot::_gde_constant_get_enum_name(m_constant, #m_constant), #m_constant, m_constant);
#define BIND_BITFIELD_FLAG(m_constant) \ #define BIND_BITFIELD_FLAG(m_constant) \
godot::ClassDB::bind_integer_constant(get_class_static(), godot::__constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true); godot::ClassDB::bind_integer_constant(get_class_static(), godot::_gde_constant_get_bitfield_name(m_constant, #m_constant), #m_constant, m_constant, true);
#define BIND_VIRTUAL_METHOD(m_class, m_method) \ #define BIND_VIRTUAL_METHOD(m_class, m_method) \
{ \ { \
auto ___call##m_method = [](GDExtensionObjectPtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr p_ret) -> void { \ auto _call##m_method = [](GDExtensionObjectPtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr p_ret) -> void { \
call_with_ptr_args(reinterpret_cast<m_class *>(p_instance), &m_class::m_method, p_args, p_ret); \ call_with_ptr_args(reinterpret_cast<m_class *>(p_instance), &m_class::m_method, p_args, p_ret); \
}; \ }; \
godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, ___call##m_method); \ godot::ClassDB::bind_virtual_method(m_class::get_class_static(), #m_method, _call##m_method); \
} }
template <class T, bool is_abstract> template <class T, bool is_abstract>
void ClassDB::_register_class(bool p_virtual) { void ClassDB::_register_class(bool p_virtual) {
instance_binding_callbacks[T::get_class_static()] = &T::___binding_callbacks; instance_binding_callbacks[T::get_class_static()] = &T::_gde_binding_callbacks;
// Register this class within our plugin // Register this class within our plugin
ClassInfo cl; ClassInfo cl;
@ -221,7 +221,7 @@ void ClassDB::register_abstract_class() {
template <class T> template <class T>
void ClassDB::register_engine_class() { void ClassDB::register_engine_class() {
instance_binding_callbacks[T::get_class_static()] = &T::___binding_callbacks; instance_binding_callbacks[T::get_class_static()] = &T::_gde_binding_callbacks;
} }
template <class N, class M, typename... VarArgs> template <class N, class M, typename... VarArgs>

4
include/godot_cpp/core/method_bind.hpp
View File

@ -268,8 +268,8 @@ MethodBind *create_vararg_method_bind(R (T::*p_method)(const Variant **, GDExten
} }
#ifndef TYPED_METHOD_BIND #ifndef TYPED_METHOD_BIND
class ___UnexistingClass; class _gde_UnexistingClass;
#define MB_T ___UnexistingClass #define MB_T _gde_UnexistingClass
#else #else
#define MB_T T #define MB_T T
#endif #endif

4
include/godot_cpp/core/type_info.hpp
View File

@ -241,7 +241,7 @@ inline String enum_qualified_name_to_class_info_name(const String &p_qualified_n
TEMPL_MAKE_ENUM_TYPE_INFO(m_enum, const m_enum &) TEMPL_MAKE_ENUM_TYPE_INFO(m_enum, const m_enum &)
template <typename T> template <typename T>
inline StringName __constant_get_enum_name(T param, StringName p_constant) { inline StringName _gde_constant_get_enum_name(T param, StringName p_constant) {
if (GetTypeInfo<T>::VARIANT_TYPE == Variant::NIL) { if (GetTypeInfo<T>::VARIANT_TYPE == Variant::NIL) {
ERR_PRINT(("Missing VARIANT_ENUM_CAST for constant's enum: " + String(p_constant)).utf8().get_data()); ERR_PRINT(("Missing VARIANT_ENUM_CAST for constant's enum: " + String(p_constant)).utf8().get_data());
} }
@ -288,7 +288,7 @@ public:
TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, const m_enum &) TEMPL_MAKE_BITFIELD_TYPE_INFO(m_enum, const m_enum &)
template <typename T> template <typename T>
inline StringName __constant_get_bitfield_name(T param, StringName p_constant) { inline StringName _gde_constant_get_bitfield_name(T param, StringName p_constant) {
if (GetTypeInfo<T>::VARIANT_TYPE == Variant::NIL) { if (GetTypeInfo<T>::VARIANT_TYPE == Variant::NIL) {
ERR_PRINT(("Missing VARIANT_ENUM_CAST for constant's bitfield: " + String(p_constant)).utf8().get_data()); ERR_PRINT(("Missing VARIANT_ENUM_CAST for constant's bitfield: " + String(p_constant)).utf8().get_data());
} }

2
src/core/object.cpp
View File

@ -54,7 +54,7 @@ Object *get_object_instance_binding(GodotObject *p_engine_object) {
binding_callbacks = ClassDB::get_instance_binding_callbacks(class_name); binding_callbacks = ClassDB::get_instance_binding_callbacks(class_name);
} }
if (binding_callbacks == nullptr) { if (binding_callbacks == nullptr) {
binding_callbacks = &Object::___binding_callbacks; binding_callbacks = &Object::_gde_binding_callbacks;
} }
return reinterpret_cast<Object *>(gdextension_interface_object_get_instance_binding(p_engine_object, token, binding_callbacks)); return reinterpret_cast<Object *>(gdextension_interface_object_get_instance_binding(p_engine_object, token, binding_callbacks));