From aaffda23a5eb4d06ec60a2d52f9cb06a4c272924 Mon Sep 17 00:00:00 2001 From: David Snopek Date: Thu, 30 Nov 2023 15:20:08 -0600 Subject: [PATCH 01/12] Avoid error from -Werror=type-limits on GCC 11 (cherry picked from commit cad5be53b1dd81416d644ef5002c85951f07adcc) --- src/godot.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/godot.cpp b/src/godot.cpp index ee4156b5..5c2aaa65 100644 --- a/src/godot.cpp +++ b/src/godot.cpp @@ -271,7 +271,12 @@ GDExtensionBool GDExtensionBinding::init(GDExtensionInterfaceGetProcAddress p_ge } else if (internal::godot_version.minor != GODOT_VERSION_MINOR) { compatible = internal::godot_version.minor > GODOT_VERSION_MINOR; } else { +#if GODOT_VERSION_PATCH > 0 compatible = internal::godot_version.patch >= GODOT_VERSION_PATCH; +#else + // Prevent -Wtype-limits warning due to unsigned comparison. + compatible = true; +#endif } if (!compatible) { // We need to use snprintf() here because vformat() uses Variant, and we haven't loaded From 0472b6bdd40b31d22756976a5ee40300bd20665c Mon Sep 17 00:00:00 2001 From: Aaron Franke Date: Tue, 19 Dec 2023 04:17:20 -0600 Subject: [PATCH 02/12] Add PackedRealArray as an alias for PackedFloat(32/64)Array (cherry picked from commit 646c71c2773b859b2e5f62d400dfe439164fe933) --- include/godot_cpp/variant/variant.hpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/include/godot_cpp/variant/variant.hpp b/include/godot_cpp/variant/variant.hpp index fc41014e..4b586428 100644 --- a/include/godot_cpp/variant/variant.hpp +++ b/include/godot_cpp/variant/variant.hpp @@ -356,6 +356,12 @@ String vformat(const String &p_text, const VarArgs... p_args) { #include +#ifdef REAL_T_IS_DOUBLE +using PackedRealArray = PackedFloat64Array; +#else +using PackedRealArray = PackedFloat32Array; +#endif // REAL_T_IS_DOUBLE + } // namespace godot #endif // GODOT_VARIANT_HPP From 81a72ff06b5ba1819169b35a1eaf9063ec1e8117 Mon Sep 17 00:00:00 2001 From: Aaron Franke Date: Sun, 17 Dec 2023 11:45:31 -0600 Subject: [PATCH 03/12] Allow detecting when building as a GDExtension (cherry picked from commit e17c7bf53060c7f1d34246af68b1d103dd8c01f7) --- tools/godotcpp.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tools/godotcpp.py b/tools/godotcpp.py index e445cad3..0b02eea2 100644 --- a/tools/godotcpp.py +++ b/tools/godotcpp.py @@ -295,6 +295,9 @@ def generate(env): if env["precision"] == "double": env.Append(CPPDEFINES=["REAL_T_IS_DOUBLE"]) + # Allow detecting when building as a GDExtension. + env.Append(CPPDEFINES=["GDEXTENSION"]) + # Suffix suffix = ".{}.{}".format(env["platform"], env["target"]) if env.dev_build: From f9b66e3c722c44861c32f7aa8c982a0254f1e1cb Mon Sep 17 00:00:00 2001 From: ArchLinus Date: Fri, 29 Dec 2023 09:32:14 -0500 Subject: [PATCH 04/12] Add an error message if android NDK is not installed (cherry picked from commit 718d0baea3e310391c6feb5b61b8e2dda6a08533) --- tools/android.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/android.py b/tools/android.py index bee58c4e..0c253541 100644 --- a/tools/android.py +++ b/tools/android.py @@ -64,6 +64,12 @@ def generate(env): elif sys.platform == "darwin": toolchain += "darwin-x86_64" env.Append(LINKFLAGS=["-shared"]) + + if not os.path.exists(toolchain): + print("ERROR: Could not find NDK toolchain at " + toolchain + ".") + print("Make sure NDK version " + get_ndk_version() + " is installed.") + env.Exit(1) + env.PrependENVPath("PATH", toolchain + "/bin") # This does nothing half of the time, but we'll put it here anyways # Get architecture info From 62eed50524cb3187c8c580627b5c340083d67fa8 Mon Sep 17 00:00:00 2001 From: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Date: Sat, 30 Dec 2023 13:23:36 +0100 Subject: [PATCH 05/12] Fix expected argument count for call errors (cherry picked from commit b77cb648c34bd0a34e866a47fe053d74bbb32f25) --- include/godot_cpp/core/binder_common.hpp | 44 ++++++++++++------------ 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/include/godot_cpp/core/binder_common.hpp b/include/godot_cpp/core/binder_common.hpp index a51e15e6..ce90acda 100644 --- a/include/godot_cpp/core/binder_common.hpp +++ b/include/godot_cpp/core/binder_common.hpp @@ -281,13 +281,13 @@ void call_with_variant_args(T *p_instance, void (T::*p_method)(P...), const Vari #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } if ((size_t)p_argcount < sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -299,13 +299,13 @@ void call_with_variant_args_ret(T *p_instance, R (T::*p_method)(P...), const Var #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } if ((size_t)p_argcount < sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -317,13 +317,13 @@ void call_with_variant_args_retc(T *p_instance, R (T::*p_method)(P...) const, co #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } if ((size_t)p_argcount < sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -335,7 +335,7 @@ void call_with_variant_args_dv(T *p_instance, void (T::*p_method)(P...), const G #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -346,7 +346,7 @@ void call_with_variant_args_dv(T *p_instance, void (T::*p_method)(P...), const G #ifdef DEBUG_ENABLED if (missing > dvs) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -370,7 +370,7 @@ void call_with_variant_argsc_dv(T *p_instance, void (T::*p_method)(P...) const, #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -381,7 +381,7 @@ void call_with_variant_argsc_dv(T *p_instance, void (T::*p_method)(P...) const, #ifdef DEBUG_ENABLED if (missing > dvs) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -405,7 +405,7 @@ void call_with_variant_args_ret_dv(T *p_instance, R (T::*p_method)(P...), const #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -416,7 +416,7 @@ void call_with_variant_args_ret_dv(T *p_instance, R (T::*p_method)(P...), const #ifdef DEBUG_ENABLED if (missing > dvs) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -440,7 +440,7 @@ void call_with_variant_args_retc_dv(T *p_instance, R (T::*p_method)(P...) const, #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -451,7 +451,7 @@ void call_with_variant_args_retc_dv(T *p_instance, R (T::*p_method)(P...) const, #ifdef DEBUG_ENABLED if (missing > dvs) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -552,7 +552,7 @@ void call_with_variant_args_static_dv(void (*p_method)(P...), const GDExtensionC #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = sizeof...(P); + r_error.expected = sizeof...(P); return; } #endif @@ -563,7 +563,7 @@ void call_with_variant_args_static_dv(void (*p_method)(P...), const GDExtensionC #ifdef DEBUG_ENABLED if (missing > dvs) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = sizeof...(P); + r_error.expected = sizeof...(P); return; } #endif @@ -597,13 +597,13 @@ void call_with_variant_args_static_ret(R (*p_method)(P...), const Variant **p_ar #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } if ((size_t)p_argcount < sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -615,13 +615,13 @@ void call_with_variant_args_static_ret(void (*p_method)(P...), const Variant **p #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } if ((size_t)p_argcount < sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = (int32_t)sizeof...(P); + r_error.expected = (int32_t)sizeof...(P); return; } #endif @@ -644,7 +644,7 @@ void call_with_variant_args_static_ret_dv(R (*p_method)(P...), const GDExtension #ifdef DEBUG_ENABLED if ((size_t)p_argcount > sizeof...(P)) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument = sizeof...(P); + r_error.expected = sizeof...(P); return; } #endif @@ -655,7 +655,7 @@ void call_with_variant_args_static_ret_dv(R (*p_method)(P...), const GDExtension #ifdef DEBUG_ENABLED if (missing > dvs) { r_error.error = GDEXTENSION_CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument = sizeof...(P); + r_error.expected = sizeof...(P); return; } #endif From c0b2d85ffc76bbfae2a768246515013c6e86b7c1 Mon Sep 17 00:00:00 2001 From: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Date: Sat, 6 Jan 2024 20:54:57 +0100 Subject: [PATCH 06/12] Add missing `OP_POWER` operator to `Variant` (cherry picked from commit f037a697eb2ce45d63840dfe87c48212d7cbf09e) --- binding_generator.py | 1 + include/godot_cpp/variant/variant.hpp | 1 + 2 files changed, 2 insertions(+) diff --git a/binding_generator.py b/binding_generator.py index 478dafe0..a1cd2150 100644 --- a/binding_generator.py +++ b/binding_generator.py @@ -2433,6 +2433,7 @@ def get_operator_id_name(op): "unary-": "negate", "unary+": "positive", "%": "module", + "**": "power", "<<": "shift_left", ">>": "shift_right", "&": "bit_and", diff --git a/include/godot_cpp/variant/variant.hpp b/include/godot_cpp/variant/variant.hpp index 4b586428..3c64791a 100644 --- a/include/godot_cpp/variant/variant.hpp +++ b/include/godot_cpp/variant/variant.hpp @@ -122,6 +122,7 @@ public: OP_NEGATE, OP_POSITIVE, OP_MODULE, + OP_POWER, // bitwise OP_SHIFT_LEFT, OP_SHIFT_RIGHT, From 3129672a4fb91dd57717cefb493a2618383f667c Mon Sep 17 00:00:00 2001 From: Daylily-Zeleen Date: Sun, 7 Jan 2024 15:24:02 +0800 Subject: [PATCH 07/12] Remove "godot" namespace when binding global constants. (cherry picked from commit bd40a94424ca91bc2d2bc76f2a02ac7f8bd5d3cf) --- binding_generator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/binding_generator.py b/binding_generator.py index a1cd2150..27721352 100644 --- a/binding_generator.py +++ b/binding_generator.py @@ -1778,9 +1778,9 @@ def generate_global_constant_binds(api, output_dir): continue if enum_def["is_bitfield"]: - header.append(f'VARIANT_BITFIELD_CAST(godot::{enum_def["name"]});') + header.append(f'VARIANT_BITFIELD_CAST({enum_def["name"]});') else: - header.append(f'VARIANT_ENUM_CAST(godot::{enum_def["name"]});') + header.append(f'VARIANT_ENUM_CAST({enum_def["name"]});') # Variant::Type is not a global enum, but only one line, it is worth to place in this file instead of creating new file. header.append(f"VARIANT_ENUM_CAST(godot::Variant::Type);") From 300e74364be29afbc6c851f1a5166d97e29acf58 Mon Sep 17 00:00:00 2001 From: nightblade9 Date: Sun, 7 Jan 2024 18:53:34 -0500 Subject: [PATCH 08/12] Update README.md with basic pre-requisites (cherry picked from commit ee169b201bc4461accfe31668f7795bf317fbae2) --- README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 69693dfc..9766fb9c 100644 --- a/README.md +++ b/README.md @@ -74,7 +74,10 @@ so formatting is done before your changes are submitted. ## Getting started -It's a bit similar to what it was for 3.x but also a bit different. +You need the same C++ pre-requisites installed that are required for the `godot` repository. Follow the [official build instructions for your target platform](https://docs.godotengine.org/en/latest/contributing/development/compiling/index.html#building-for-target-platforms). + +Getting started with GDExtensions is a bit similar to what it was for 3.x but also a bit different. + This new approach is much more akin to how core Godot modules are structured. Compiling this repository generates a static library to be linked with your shared lib, From 97214ecd7a6f6afc76617f9fc3be034715fc4524 Mon Sep 17 00:00:00 2001 From: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Date: Fri, 12 Jan 2024 18:08:40 +0100 Subject: [PATCH 09/12] Fix `AABB.encloses` failing on shared upper bound (cherry picked from commit 3943e41d2f17a1eef2cdd472333ab1a7585187d8) --- include/godot_cpp/variant/aabb.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/include/godot_cpp/variant/aabb.hpp b/include/godot_cpp/variant/aabb.hpp index dde392b5..7706d511 100644 --- a/include/godot_cpp/variant/aabb.hpp +++ b/include/godot_cpp/variant/aabb.hpp @@ -201,11 +201,11 @@ inline bool AABB::encloses(const AABB &p_aabb) const { return ( (src_min.x <= dst_min.x) && - (src_max.x > dst_max.x) && + (src_max.x >= dst_max.x) && (src_min.y <= dst_min.y) && - (src_max.y > dst_max.y) && + (src_max.y >= dst_max.y) && (src_min.z <= dst_min.z) && - (src_max.z > dst_max.z)); + (src_max.z >= dst_max.z)); } Vector3 AABB::get_support(const Vector3 &p_normal) const { From dc76664cea9c90ad1b60c24da5fe55836bdf475a Mon Sep 17 00:00:00 2001 From: Chris Cranford Date: Fri, 12 Jan 2024 15:25:56 -0500 Subject: [PATCH 10/12] Rework GDCLASS macro to allow pure virtual functions (cherry picked from commit 5f350e257214c490639682d0b601be859a3b4332) --- include/godot_cpp/classes/wrapped.hpp | 29 +------------------------ include/godot_cpp/core/class_db.hpp | 31 +++++++++++++++++++++++++-- test/src/example.h | 15 +++++++++++-- test/src/register_types.cpp | 3 ++- 4 files changed, 45 insertions(+), 33 deletions(-) diff --git a/include/godot_cpp/classes/wrapped.hpp b/include/godot_cpp/classes/wrapped.hpp index f8f921b3..32caf39b 100644 --- a/include/godot_cpp/classes/wrapped.hpp +++ b/include/godot_cpp/classes/wrapped.hpp @@ -48,6 +48,7 @@ typedef void GodotObject; // Base for all engine classes, to contain the pointer to the engine instance. class Wrapped { friend class GDExtensionBinding; + friend class ClassDB; friend void postinitialize_handler(Wrapped *); protected: @@ -131,17 +132,6 @@ struct EngineClassRegistration { } // namespace godot -#ifdef HOT_RELOAD_ENABLED -#define _GDCLASS_RECREATE(m_class, m_inherits) \ - m_class *new_instance = (m_class *)memalloc(sizeof(m_class)); \ - Wrapped::RecreateInstance recreate_data = { new_instance, obj, Wrapped::recreate_instance }; \ - Wrapped::recreate_instance = &recreate_data; \ - memnew_placement(new_instance, m_class); \ - return new_instance; -#else -#define _GDCLASS_RECREATE(m_class, m_inherits) return nullptr; -#endif - // Use this on top of your own classes. // Note: the trail of `***` is to keep sane diffs in PRs, because clang-format otherwise moves every `\` which makes // every line of the macro different @@ -226,15 +216,6 @@ public: return m_inherits::get_class_static(); \ } \ \ - static GDExtensionObjectPtr create(void *data) { \ - m_class *new_object = memnew(m_class); \ - return new_object->_owner; \ - } \ - \ - static GDExtensionClassInstancePtr recreate(void *data, GDExtensionObjectPtr obj) { \ - _GDCLASS_RECREATE(m_class, m_inherits); \ - } \ - \ static void notification_bind(GDExtensionClassInstancePtr p_instance, int32_t p_what, GDExtensionBool p_reversed) { \ if (p_instance && m_class::_get_notification()) { \ if (m_class::_get_notification() != m_inherits::_get_notification()) { \ @@ -437,14 +418,6 @@ public: return m_inherits::get_class_static(); \ } \ \ - static GDExtensionObjectPtr create(void *data) { \ - return nullptr; \ - } \ - \ - static GDExtensionClassInstancePtr recreate(void *data, GDExtensionObjectPtr obj) { \ - return nullptr; \ - } \ - \ static void free(void *data, GDExtensionClassInstancePtr ptr) { \ } \ \ diff --git a/include/godot_cpp/core/class_db.hpp b/include/godot_cpp/core/class_db.hpp index 4196a76b..af394f04 100644 --- a/include/godot_cpp/core/class_db.hpp +++ b/include/godot_cpp/core/class_db.hpp @@ -112,6 +112,33 @@ private: template static void _register_class(bool p_virtual = false, bool p_exposed = true); + template + static GDExtensionObjectPtr _create_instance_func(void *data) { + if constexpr (!std::is_abstract_v) { + T *new_object = memnew(T); + return new_object->_owner; + } else { + return nullptr; + } + } + + template + static GDExtensionClassInstancePtr _recreate_instance_func(void *data, GDExtensionObjectPtr obj) { + if constexpr (!std::is_abstract_v) { +#ifdef HOT_RELOAD_ENABLED + T *new_instance = (T *)memalloc(sizeof(T)); + Wrapped::RecreateInstance recreate_data = { new_instance, obj, Wrapped::recreate_instance }; + Wrapped::recreate_instance = &recreate_data; + memnew_placement(new_instance, T); + return new_instance; +#else + return nullptr; +#endif + } else { + return nullptr; + } + } + public: template static void register_class(bool p_virtual = false); @@ -202,9 +229,9 @@ void ClassDB::_register_class(bool p_virtual, bool p_exposed) { T::to_string_bind, // GDExtensionClassToString to_string_func; nullptr, // GDExtensionClassReference reference_func; nullptr, // GDExtensionClassUnreference unreference_func; - T::create, // GDExtensionClassCreateInstance create_instance_func; /* this one is mandatory */ + &_create_instance_func, // GDExtensionClassCreateInstance create_instance_func; /* this one is mandatory */ T::free, // GDExtensionClassFreeInstance free_instance_func; /* this one is mandatory */ - T::recreate, // GDExtensionClassRecreateInstance recreate_instance_func; + &_recreate_instance_func, // GDExtensionClassRecreateInstance recreate_instance_func; &ClassDB::get_virtual_func, // GDExtensionClassGetVirtual get_virtual_func; nullptr, // GDExtensionClassGetVirtualCallData get_virtual_call_data_func; nullptr, // GDExtensionClassCallVirtualWithData call_virtual_func; diff --git a/test/src/example.h b/test/src/example.h index 72f6783d..c86a51fd 100644 --- a/test/src/example.h +++ b/test/src/example.h @@ -198,11 +198,22 @@ protected: static void _bind_methods() {} }; -class ExampleAbstract : public Object { - GDCLASS(ExampleAbstract, Object); +class ExampleAbstractBase : public Object { + GDCLASS(ExampleAbstractBase, Object); protected: static void _bind_methods() {} + + virtual int test_function() = 0; +}; + +class ExampleConcrete : public ExampleAbstractBase { + GDCLASS(ExampleConcrete, ExampleAbstractBase); + +protected: + static void _bind_methods() {} + + virtual int test_function() override { return 25; } }; #endif // EXAMPLE_CLASS_H diff --git a/test/src/register_types.cpp b/test/src/register_types.cpp index dbb37d90..58080d20 100644 --- a/test/src/register_types.cpp +++ b/test/src/register_types.cpp @@ -25,7 +25,8 @@ void initialize_example_module(ModuleInitializationLevel p_level) { ClassDB::register_class(); ClassDB::register_class(); ClassDB::register_class(true); - ClassDB::register_abstract_class(); + ClassDB::register_abstract_class(); + ClassDB::register_class(); } void uninitialize_example_module(ModuleInitializationLevel p_level) { From 4d070c3e85222928dd9a025908c95c272065b734 Mon Sep 17 00:00:00 2001 From: bruvzg <7645683+bruvzg@users.noreply.github.com> Date: Wed, 10 Jan 2024 15:30:24 +0200 Subject: [PATCH 11/12] Switch to 64-bit ints. (cherry picked from commit 59a5a8b104e3fcf63c13732ffbb12d8c577a26ce) --- binding_generator.py | 24 +- include/godot_cpp/templates/cowdata.hpp | 205 +++++++++++------- include/godot_cpp/templates/safe_refcount.hpp | 9 + include/godot_cpp/templates/vector.hpp | 91 ++++---- include/godot_cpp/variant/char_string.hpp | 18 +- src/variant/char_string.cpp | 36 +-- src/variant/packed_arrays.cpp | 40 ++-- 7 files changed, 253 insertions(+), 170 deletions(-) diff --git a/binding_generator.py b/binding_generator.py index 27721352..7a6fe248 100644 --- a/binding_generator.py +++ b/binding_generator.py @@ -588,17 +588,17 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl # Special cases. if class_name == "String": - result.append("\tstatic String utf8(const char *from, int len = -1);") - result.append("\tvoid parse_utf8(const char *from, int len = -1);") - result.append("\tstatic String utf16(const char16_t *from, int len = -1);") - result.append("\tvoid parse_utf16(const char16_t *from, int len = -1);") + result.append("\tstatic String utf8(const char *from, int64_t len = -1);") + result.append("\tvoid parse_utf8(const char *from, int64_t len = -1);") + result.append("\tstatic String utf16(const char16_t *from, int64_t len = -1);") + result.append("\tvoid parse_utf16(const char16_t *from, int64_t len = -1);") result.append("\tCharString utf8() const;") result.append("\tCharString ascii() const;") result.append("\tChar16String utf16() const;") result.append("\tChar32String utf32() const;") result.append("\tCharWideString wide_string() const;") result.append("\tstatic String num_real(double p_num, bool p_trailing = true);") - result.append("\tError resize(int p_size);") + result.append("\tError resize(int64_t p_size);") if "members" in builtin_api: for member in builtin_api["members"]: @@ -651,8 +651,8 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl result.append("\tString &operator+=(const wchar_t *p_str);") result.append("\tString &operator+=(const char32_t *p_str);") - result.append("\tconst char32_t &operator[](int p_index) const;") - result.append("\tchar32_t &operator[](int p_index);") + result.append("\tconst char32_t &operator[](int64_t p_index) const;") + result.append("\tchar32_t &operator[](int64_t p_index);") result.append("\tconst char32_t *ptr() const;") result.append("\tchar32_t *ptrw();") @@ -670,8 +670,8 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl return_type = "int32_t" elif class_name == "PackedFloat32Array": return_type = "float" - result.append(f"\tconst {return_type} &operator[](int p_index) const;") - result.append(f"\t{return_type} &operator[](int p_index);") + result.append(f"\tconst {return_type} &operator[](int64_t p_index) const;") + result.append(f"\t{return_type} &operator[](int64_t p_index);") result.append(f"\tconst {return_type} *ptr() const;") result.append(f"\t{return_type} *ptrw();") iterators = """ @@ -742,8 +742,8 @@ def generate_builtin_class_header(builtin_api, size, used_classes, fully_used_cl result.append(iterators.replace("$TYPE", return_type)) if class_name == "Array": - result.append("\tconst Variant &operator[](int p_index) const;") - result.append("\tVariant &operator[](int p_index);") + result.append("\tconst Variant &operator[](int64_t p_index) const;") + result.append("\tVariant &operator[](int64_t p_index);") result.append("\tvoid set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script);") result.append("\tvoid _ref(const Array &p_from) const;") @@ -1696,7 +1696,7 @@ def generate_global_constants(api, output_dir): header.append("") for constant in api["global_constants"]: - header.append(f'\tconst int {escape_identifier(constant["name"])} = {constant["value"]};') + header.append(f'\tconst int64_t {escape_identifier(constant["name"])} = {constant["value"]};') header.append("") diff --git a/include/godot_cpp/templates/cowdata.hpp b/include/godot_cpp/templates/cowdata.hpp index 9b36538d..b6f66d7f 100644 --- a/include/godot_cpp/templates/cowdata.hpp +++ b/include/godot_cpp/templates/cowdata.hpp @@ -52,6 +52,8 @@ class VMap; template class CharStringT; +SAFE_NUMERIC_TYPE_PUN_GUARANTEES(uint64_t) + // Silence a false positive warning (see GH-52119). #if defined(__GNUC__) && !defined(__clang__) #pragma GCC diagnostic push @@ -69,52 +71,71 @@ class CowData { template friend class CharStringT; +public: + typedef int64_t Size; + typedef uint64_t USize; + static constexpr USize MAX_INT = INT64_MAX; + private: + // Function to find the next power of 2 to an integer. + static _FORCE_INLINE_ USize next_po2(USize x) { + if (x == 0) { + return 0; + } + + --x; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + if (sizeof(USize) == 8) { + x |= x >> 32; + } + + return ++x; + } + + static constexpr USize ALLOC_PAD = sizeof(USize) * 2; // For size and atomic refcount. + mutable T *_ptr = nullptr; // internal helpers - _FORCE_INLINE_ SafeNumeric *_get_refcount() const { + _FORCE_INLINE_ SafeNumeric *_get_refcount() const { if (!_ptr) { return nullptr; } - return reinterpret_cast *>(_ptr) - 2; + return reinterpret_cast *>(_ptr) - 2; } - _FORCE_INLINE_ uint32_t *_get_size() const { + _FORCE_INLINE_ USize *_get_size() const { if (!_ptr) { return nullptr; } - return reinterpret_cast(_ptr) - 1; + return reinterpret_cast(_ptr) - 1; } - _FORCE_INLINE_ T *_get_data() const { - if (!_ptr) { - return nullptr; - } - return reinterpret_cast(_ptr); + _FORCE_INLINE_ USize _get_alloc_size(USize p_elements) const { + return next_po2(p_elements * sizeof(T)); } - _FORCE_INLINE_ size_t _get_alloc_size(size_t p_elements) const { - return next_power_of_2(p_elements * sizeof(T)); - } - - _FORCE_INLINE_ bool _get_alloc_size_checked(size_t p_elements, size_t *out) const { + _FORCE_INLINE_ bool _get_alloc_size_checked(USize p_elements, USize *out) const { if (unlikely(p_elements == 0)) { *out = 0; return true; } -#if defined(__GNUC__) - size_t o; - size_t p; +#if defined(__GNUC__) && defined(IS_32_BIT) + USize o; + USize p; if (__builtin_mul_overflow(p_elements, sizeof(T), &o)) { *out = 0; return false; } - *out = next_power_of_2(o); - if (__builtin_add_overflow(o, static_cast(32), &p)) { + *out = next_po2(o); + if (__builtin_add_overflow(o, static_cast(32), &p)) { return false; // No longer allocated here. } #else @@ -128,22 +149,22 @@ private: void _unref(void *p_data); void _ref(const CowData *p_from); void _ref(const CowData &p_from); - uint32_t _copy_on_write(); + USize _copy_on_write(); public: void operator=(const CowData &p_from) { _ref(p_from); } _FORCE_INLINE_ T *ptrw() { _copy_on_write(); - return (T *)_get_data(); + return _ptr; } _FORCE_INLINE_ const T *ptr() const { - return _get_data(); + return _ptr; } - _FORCE_INLINE_ int size() const { - uint32_t *size = (uint32_t *)_get_size(); + _FORCE_INLINE_ Size size() const { + USize *size = (USize *)_get_size(); if (size) { return *size; } else { @@ -154,41 +175,42 @@ public: _FORCE_INLINE_ void clear() { resize(0); } _FORCE_INLINE_ bool is_empty() const { return _ptr == nullptr; } - _FORCE_INLINE_ void set(int p_index, const T &p_elem) { + _FORCE_INLINE_ void set(Size p_index, const T &p_elem) { ERR_FAIL_INDEX(p_index, size()); _copy_on_write(); - _get_data()[p_index] = p_elem; + _ptr[p_index] = p_elem; } - _FORCE_INLINE_ T &get_m(int p_index) { + _FORCE_INLINE_ T &get_m(Size p_index) { CRASH_BAD_INDEX(p_index, size()); _copy_on_write(); - return _get_data()[p_index]; + return _ptr[p_index]; } - _FORCE_INLINE_ const T &get(int p_index) const { + _FORCE_INLINE_ const T &get(Size p_index) const { CRASH_BAD_INDEX(p_index, size()); - return _get_data()[p_index]; + return _ptr[p_index]; } - Error resize(int p_size); + template + Error resize(Size p_size); - _FORCE_INLINE_ void remove_at(int p_index) { + _FORCE_INLINE_ void remove_at(Size p_index) { ERR_FAIL_INDEX(p_index, size()); T *p = ptrw(); - int len = size(); - for (int i = p_index; i < len - 1; i++) { + Size len = size(); + for (Size i = p_index; i < len - 1; i++) { p[i] = p[i + 1]; } resize(len - 1); } - Error insert(int p_pos, const T &p_val) { + Error insert(Size p_pos, const T &p_val) { ERR_FAIL_INDEX_V(p_pos, size() + 1, ERR_INVALID_PARAMETER); resize(size() + 1); - for (int i = (size() - 1); i > p_pos; i--) { + for (Size i = (size() - 1); i > p_pos; i--) { set(i, get(i - 1)); } set(p_pos, p_val); @@ -196,11 +218,13 @@ public: return OK; } - int find(const T &p_val, int p_from = 0) const; + Size find(const T &p_val, Size p_from = 0) const; + Size rfind(const T &p_val, Size p_from = -1) const; + Size count(const T &p_val) const; _FORCE_INLINE_ CowData() {} _FORCE_INLINE_ ~CowData(); - _FORCE_INLINE_ CowData(CowData &p_from) { _ref(p_from); } + _FORCE_INLINE_ CowData(CowData &p_from) { _ref(p_from); }; }; template @@ -209,44 +233,45 @@ void CowData::_unref(void *p_data) { return; } - SafeNumeric *refc = _get_refcount(); + SafeNumeric *refc = _get_refcount(); if (refc->decrement() > 0) { return; // still in use } - // clean up + if (!std::is_trivially_destructible::value) { - uint32_t *count = _get_size(); + USize *count = _get_size(); T *data = (T *)(count + 1); - for (uint32_t i = 0; i < *count; ++i) { + for (USize i = 0; i < *count; ++i) { // call destructors data[i].~T(); } } // free mem - Memory::free_static((uint8_t *)p_data, true); + Memory::free_static(((uint8_t *)p_data) - ALLOC_PAD, false); } template -uint32_t CowData::_copy_on_write() { +typename CowData::USize CowData::_copy_on_write() { if (!_ptr) { return 0; } - SafeNumeric *refc = _get_refcount(); + SafeNumeric *refc = _get_refcount(); - uint32_t rc = refc->get(); + USize rc = refc->get(); if (unlikely(rc > 1)) { /* in use by more than me */ - uint32_t current_size = *_get_size(); + USize current_size = *_get_size(); - uint32_t *mem_new = (uint32_t *)Memory::alloc_static(_get_alloc_size(current_size), true); + USize *mem_new = (USize *)Memory::alloc_static(_get_alloc_size(current_size) + ALLOC_PAD, false); + mem_new += 2; - new (mem_new - 2) SafeNumeric(1); // refcount - *(mem_new - 1) = current_size; // size + new (mem_new - 2) SafeNumeric(1); //refcount + *(mem_new - 1) = current_size; //size T *_data = (T *)(mem_new); @@ -255,8 +280,8 @@ uint32_t CowData::_copy_on_write() { memcpy(mem_new, _ptr, current_size * sizeof(T)); } else { - for (uint32_t i = 0; i < current_size; i++) { - memnew_placement(&_data[i], T(_get_data()[i])); + for (USize i = 0; i < current_size; i++) { + memnew_placement(&_data[i], T(_ptr[i])); } } @@ -269,10 +294,11 @@ uint32_t CowData::_copy_on_write() { } template -Error CowData::resize(int p_size) { +template +Error CowData::resize(Size p_size) { ERR_FAIL_COND_V(p_size < 0, ERR_INVALID_PARAMETER); - int current_size = size(); + Size current_size = size(); if (p_size == current_size) { return OK; @@ -286,27 +312,29 @@ Error CowData::resize(int p_size) { } // possibly changing size, copy on write - uint32_t rc = _copy_on_write(); + USize rc = _copy_on_write(); - size_t current_alloc_size = _get_alloc_size(current_size); - size_t alloc_size; + USize current_alloc_size = _get_alloc_size(current_size); + USize alloc_size; ERR_FAIL_COND_V(!_get_alloc_size_checked(p_size, &alloc_size), ERR_OUT_OF_MEMORY); if (p_size > current_size) { if (alloc_size != current_alloc_size) { if (current_size == 0) { // alloc from scratch - uint32_t *ptr = (uint32_t *)Memory::alloc_static(alloc_size, true); + USize *ptr = (USize *)Memory::alloc_static(alloc_size + ALLOC_PAD, false); + ptr += 2; ERR_FAIL_NULL_V(ptr, ERR_OUT_OF_MEMORY); - *(ptr - 1) = 0; // size, currently none - new (ptr - 2) SafeNumeric(1); // refcount + *(ptr - 1) = 0; //size, currently none + new (ptr - 2) SafeNumeric(1); //refcount _ptr = (T *)ptr; } else { - uint32_t *_ptrnew = (uint32_t *)Memory::realloc_static(_ptr, alloc_size, true); + USize *_ptrnew = (USize *)Memory::realloc_static(((uint8_t *)_ptr) - ALLOC_PAD, alloc_size + ALLOC_PAD, false); ERR_FAIL_NULL_V(_ptrnew, ERR_OUT_OF_MEMORY); - new (_ptrnew - 2) SafeNumeric(rc); // refcount + _ptrnew += 2; + new (_ptrnew - 2) SafeNumeric(rc); //refcount _ptr = (T *)(_ptrnew); } @@ -315,11 +343,11 @@ Error CowData::resize(int p_size) { // construct the newly created elements if (!std::is_trivially_constructible::value) { - T *elems = _get_data(); - - for (int i = *_get_size(); i < p_size; i++) { - memnew_placement(&elems[i], T); + for (Size i = *_get_size(); i < p_size; i++) { + memnew_placement(&_ptr[i], T); } + } else if (p_ensure_zero) { + memset((void *)(_ptr + current_size), 0, (p_size - current_size) * sizeof(T)); } *_get_size() = p_size; @@ -327,16 +355,17 @@ Error CowData::resize(int p_size) { } else if (p_size < current_size) { if (!std::is_trivially_destructible::value) { // deinitialize no longer needed elements - for (uint32_t i = p_size; i < *_get_size(); i++) { - T *t = &_get_data()[i]; + for (USize i = p_size; i < *_get_size(); i++) { + T *t = &_ptr[i]; t->~T(); } } if (alloc_size != current_alloc_size) { - uint32_t *_ptrnew = (uint32_t *)Memory::realloc_static(_ptr, alloc_size, true); + USize *_ptrnew = (USize *)Memory::realloc_static(((uint8_t *)_ptr) - ALLOC_PAD, alloc_size + ALLOC_PAD, false); ERR_FAIL_NULL_V(_ptrnew, ERR_OUT_OF_MEMORY); - new (_ptrnew - 2) SafeNumeric(rc); // refcount + _ptrnew += 2; + new (_ptrnew - 2) SafeNumeric(rc); //refcount _ptr = (T *)(_ptrnew); } @@ -348,14 +377,14 @@ Error CowData::resize(int p_size) { } template -int CowData::find(const T &p_val, int p_from) const { - int ret = -1; +typename CowData::Size CowData::find(const T &p_val, Size p_from) const { + Size ret = -1; if (p_from < 0 || size() == 0) { return ret; } - for (int i = p_from; i < size(); i++) { + for (Size i = p_from; i < size(); i++) { if (get(i) == p_val) { ret = i; break; @@ -365,6 +394,36 @@ int CowData::find(const T &p_val, int p_from) const { return ret; } +template +typename CowData::Size CowData::rfind(const T &p_val, Size p_from) const { + const Size s = size(); + + if (p_from < 0) { + p_from = s + p_from; + } + if (p_from < 0 || p_from >= s) { + p_from = s - 1; + } + + for (Size i = p_from; i >= 0; i--) { + if (get(i) == p_val) { + return i; + } + } + return -1; +} + +template +typename CowData::Size CowData::count(const T &p_val) const { + Size amount = 0; + for (Size i = 0; i < size(); i++) { + if (get(i) == p_val) { + amount++; + } + } + return amount; +} + template void CowData::_ref(const CowData *p_from) { _ref(*p_from); diff --git a/include/godot_cpp/templates/safe_refcount.hpp b/include/godot_cpp/templates/safe_refcount.hpp index f8650416..519bbf74 100644 --- a/include/godot_cpp/templates/safe_refcount.hpp +++ b/include/godot_cpp/templates/safe_refcount.hpp @@ -48,6 +48,15 @@ namespace godot { // value and, as an important benefit, you can be sure the value is properly synchronized // even with threads that are already running. +// These are used in very specific areas of the engine where it's critical that these guarantees are held +#define SAFE_NUMERIC_TYPE_PUN_GUARANTEES(m_type) \ + static_assert(sizeof(SafeNumeric) == sizeof(m_type)); \ + static_assert(alignof(SafeNumeric) == alignof(m_type)); \ + static_assert(std::is_trivially_destructible>::value); +#define SAFE_FLAG_TYPE_PUN_GUARANTEES \ + static_assert(sizeof(SafeFlag) == sizeof(bool)); \ + static_assert(alignof(SafeFlag) == alignof(bool)); + template class SafeNumeric { std::atomic value; diff --git a/include/godot_cpp/templates/vector.hpp b/include/godot_cpp/templates/vector.hpp index f5626af0..05b7184c 100644 --- a/include/godot_cpp/templates/vector.hpp +++ b/include/godot_cpp/templates/vector.hpp @@ -50,7 +50,7 @@ namespace godot { template class VectorWriteProxy { public: - _FORCE_INLINE_ T &operator[](int p_index) { + _FORCE_INLINE_ T &operator[](typename CowData::Size p_index) { CRASH_BAD_INDEX(p_index, ((Vector *)(this))->_cowdata.size()); return ((Vector *)(this))->_cowdata.ptrw()[p_index]; @@ -63,22 +63,26 @@ class Vector { public: VectorWriteProxy write; + typedef typename CowData::Size Size; private: CowData _cowdata; public: bool push_back(T p_elem); - _FORCE_INLINE_ bool append(const T &p_elem) { return push_back(p_elem); } // alias + _FORCE_INLINE_ bool append(const T &p_elem) { return push_back(p_elem); } //alias void fill(T p_elem); - void remove_at(int p_index) { _cowdata.remove_at(p_index); } - void erase(const T &p_val) { - int idx = find(p_val); + void remove_at(Size p_index) { _cowdata.remove_at(p_index); } + _FORCE_INLINE_ bool erase(const T &p_val) { + Size idx = find(p_val); if (idx >= 0) { remove_at(idx); + return true; } + return false; } + void reverse(); _FORCE_INLINE_ T *ptrw() { return _cowdata.ptrw(); } @@ -86,37 +90,45 @@ public: _FORCE_INLINE_ void clear() { resize(0); } _FORCE_INLINE_ bool is_empty() const { return _cowdata.is_empty(); } - _FORCE_INLINE_ T get(int p_index) { return _cowdata.get(p_index); } - _FORCE_INLINE_ const T &get(int p_index) const { return _cowdata.get(p_index); } - _FORCE_INLINE_ void set(int p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); } - _FORCE_INLINE_ int size() const { return _cowdata.size(); } - Error resize(int p_size) { return _cowdata.resize(p_size); } - _FORCE_INLINE_ const T &operator[](int p_index) const { return _cowdata.get(p_index); } - Error insert(int p_pos, T p_val) { return _cowdata.insert(p_pos, p_val); } - int find(const T &p_val, int p_from = 0) const { return _cowdata.find(p_val, p_from); } + _FORCE_INLINE_ T get(Size p_index) { return _cowdata.get(p_index); } + _FORCE_INLINE_ const T &get(Size p_index) const { return _cowdata.get(p_index); } + _FORCE_INLINE_ void set(Size p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); } + _FORCE_INLINE_ Size size() const { return _cowdata.size(); } + Error resize(Size p_size) { return _cowdata.resize(p_size); } + Error resize_zeroed(Size p_size) { return _cowdata.template resize(p_size); } + _FORCE_INLINE_ const T &operator[](Size p_index) const { return _cowdata.get(p_index); } + Error insert(Size p_pos, T p_val) { return _cowdata.insert(p_pos, p_val); } + Size find(const T &p_val, Size p_from = 0) const { return _cowdata.find(p_val, p_from); } + Size rfind(const T &p_val, Size p_from = -1) const { return _cowdata.rfind(p_val, p_from); } + Size count(const T &p_val) const { return _cowdata.count(p_val); } void append_array(Vector p_other); _FORCE_INLINE_ bool has(const T &p_val) const { return find(p_val) != -1; } - template - void sort_custom() { - int len = _cowdata.size(); + void sort() { + sort_custom<_DefaultComparator>(); + } + + template + void sort_custom(Args &&...args) { + Size len = _cowdata.size(); if (len == 0) { return; } T *data = ptrw(); - SortArray sorter; + SortArray sorter{ args... }; sorter.sort(data, len); } - void sort() { - sort_custom<_DefaultComparator>(); + Size bsearch(const T &p_value, bool p_before) { + return bsearch_custom<_DefaultComparator>(p_value, p_before); } - int bsearch(const T &p_value, bool p_before) { - SearchArray search; + template + Size bsearch_custom(const Value &p_value, bool p_before, Args &&...args) { + SearchArray search{ args... }; return search.bisect(ptrw(), size(), p_value, p_before); } @@ -125,7 +137,7 @@ public: } void ordered_insert(const T &p_val) { - int i; + Size i; for (i = 0; i < _cowdata.size(); i++) { if (p_val < operator[](i)) { break; @@ -140,33 +152,36 @@ public: Vector to_byte_array() const { Vector ret; + if (is_empty()) { + return ret; + } ret.resize(size() * sizeof(T)); memcpy(ret.ptrw(), ptr(), sizeof(T) * size()); return ret; } - Vector slice(int p_begin, int p_end = INT_MAX) const { + Vector slice(Size p_begin, Size p_end = CowData::MAX_INT) const { Vector result; - const int s = size(); + const Size s = size(); - int begin = Math::clamp(p_begin, -s, s); + Size begin = CLAMP(p_begin, -s, s); if (begin < 0) { begin += s; } - int end = Math::clamp(p_end, -s, s); + Size end = CLAMP(p_end, -s, s); if (end < 0) { end += s; } ERR_FAIL_COND_V(begin > end, result); - int result_size = end - begin; + Size result_size = end - begin; result.resize(result_size); const T *const r = ptr(); T *const w = result.ptrw(); - for (int i = 0; i < result_size; ++i) { + for (Size i = 0; i < result_size; ++i) { w[i] = r[begin + i]; } @@ -174,11 +189,11 @@ public: } bool operator==(const Vector &p_arr) const { - int s = size(); + Size s = size(); if (s != p_arr.size()) { return false; } - for (int i = 0; i < s; i++) { + for (Size i = 0; i < s; i++) { if (operator[](i) != p_arr[i]) { return false; } @@ -187,11 +202,11 @@ public: } bool operator!=(const Vector &p_arr) const { - int s = size(); + Size s = size(); if (s != p_arr.size()) { return true; } - for (int i = 0; i < s; i++) { + for (Size i = 0; i < s; i++) { if (operator[](i) != p_arr[i]) { return true; } @@ -268,7 +283,7 @@ public: Error err = _cowdata.resize(p_init.size()); ERR_FAIL_COND(err); - int i = 0; + Size i = 0; for (const T &element : p_init) { _cowdata.set(i++, element); } @@ -280,7 +295,7 @@ public: template void Vector::reverse() { - for (int i = 0; i < size() / 2; i++) { + for (Size i = 0; i < size() / 2; i++) { T *p = ptrw(); SWAP(p[i], p[size() - i - 1]); } @@ -288,13 +303,13 @@ void Vector::reverse() { template void Vector::append_array(Vector p_other) { - const int ds = p_other.size(); + const Size ds = p_other.size(); if (ds == 0) { return; } - const int bs = size(); + const Size bs = size(); resize(bs + ds); - for (int i = 0; i < ds; ++i) { + for (Size i = 0; i < ds; ++i) { ptrw()[bs + i] = p_other[i]; } } @@ -311,7 +326,7 @@ bool Vector::push_back(T p_elem) { template void Vector::fill(T p_elem) { T *p = ptrw(); - for (int i = 0; i < size(); i++) { + for (Size i = 0; i < size(); i++) { p[i] = p_elem; } } diff --git a/include/godot_cpp/variant/char_string.hpp b/include/godot_cpp/variant/char_string.hpp index fef6a718..993d0467 100644 --- a/include/godot_cpp/variant/char_string.hpp +++ b/include/godot_cpp/variant/char_string.hpp @@ -46,11 +46,11 @@ class CharProxy { template friend class CharStringT; - const int _index; + const int64_t _index; CowData &_cowdata; static inline const T _null = 0; - _FORCE_INLINE_ CharProxy(const int &p_index, CowData &p_cowdata) : + _FORCE_INLINE_ CharProxy(const int64_t &p_index, CowData &p_cowdata) : _index(p_index), _cowdata(p_cowdata) {} @@ -90,19 +90,19 @@ class CharStringT { public: _FORCE_INLINE_ T *ptrw() { return _cowdata.ptrw(); } _FORCE_INLINE_ const T *ptr() const { return _cowdata.ptr(); } - _FORCE_INLINE_ int size() const { return _cowdata.size(); } - Error resize(int p_size) { return _cowdata.resize(p_size); } + _FORCE_INLINE_ int64_t size() const { return _cowdata.size(); } + Error resize(int64_t p_size) { return _cowdata.resize(p_size); } - _FORCE_INLINE_ T get(int p_index) const { return _cowdata.get(p_index); } - _FORCE_INLINE_ void set(int p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); } - _FORCE_INLINE_ const T &operator[](int p_index) const { + _FORCE_INLINE_ T get(int64_t p_index) const { return _cowdata.get(p_index); } + _FORCE_INLINE_ void set(int64_t p_index, const T &p_elem) { _cowdata.set(p_index, p_elem); } + _FORCE_INLINE_ const T &operator[](int64_t p_index) const { if (unlikely(p_index == _cowdata.size())) { return _null; } return _cowdata.get(p_index); } - _FORCE_INLINE_ CharProxy operator[](int p_index) { return CharProxy(p_index, _cowdata); } + _FORCE_INLINE_ CharProxy operator[](int64_t p_index) { return CharProxy(p_index, _cowdata); } _FORCE_INLINE_ CharStringT() {} _FORCE_INLINE_ CharStringT(const CharStringT &p_str) { _cowdata._ref(p_str._cowdata); } @@ -112,7 +112,7 @@ public: void operator=(const T *p_cstr); bool operator<(const CharStringT &p_right) const; CharStringT &operator+=(T p_char); - int length() const { return size() ? size() - 1 : 0; } + int64_t length() const { return size() ? size() - 1 : 0; } const T *get_data() const; operator const T *() const { return get_data(); }; diff --git a/src/variant/char_string.cpp b/src/variant/char_string.cpp index a4083bf4..3c1ac108 100644 --- a/src/variant/char_string.cpp +++ b/src/variant/char_string.cpp @@ -76,7 +76,7 @@ bool CharStringT::operator<(const CharStringT &p_right) const { template CharStringT &CharStringT::operator+=(T p_char) { - const int lhs_len = length(); + const int64_t lhs_len = length(); resize(lhs_len + 2); T *dst = ptrw(); @@ -172,23 +172,23 @@ String::String(const char32_t *from) { internal::gdextension_interface_string_new_with_utf32_chars(_native_ptr(), from); } -String String::utf8(const char *from, int len) { +String String::utf8(const char *from, int64_t len) { String ret; ret.parse_utf8(from, len); return ret; } -void String::parse_utf8(const char *from, int len) { +void String::parse_utf8(const char *from, int64_t len) { internal::gdextension_interface_string_new_with_utf8_chars_and_len(_native_ptr(), from, len); } -String String::utf16(const char16_t *from, int len) { +String String::utf16(const char16_t *from, int64_t len) { String ret; ret.parse_utf16(from, len); return ret; } -void String::parse_utf16(const char16_t *from, int len) { +void String::parse_utf16(const char16_t *from, int64_t len) { internal::gdextension_interface_string_new_with_utf16_chars_and_len(_native_ptr(), from, len); } @@ -230,8 +230,8 @@ String rtoss(double p_val) { } CharString String::utf8() const { - int length = internal::gdextension_interface_string_to_utf8_chars(_native_ptr(), nullptr, 0); - int size = length + 1; + int64_t length = internal::gdextension_interface_string_to_utf8_chars(_native_ptr(), nullptr, 0); + int64_t size = length + 1; CharString str; str.resize(size); internal::gdextension_interface_string_to_utf8_chars(_native_ptr(), str.ptrw(), length); @@ -242,8 +242,8 @@ CharString String::utf8() const { } CharString String::ascii() const { - int length = internal::gdextension_interface_string_to_latin1_chars(_native_ptr(), nullptr, 0); - int size = length + 1; + int64_t length = internal::gdextension_interface_string_to_latin1_chars(_native_ptr(), nullptr, 0); + int64_t size = length + 1; CharString str; str.resize(size); internal::gdextension_interface_string_to_latin1_chars(_native_ptr(), str.ptrw(), length); @@ -254,8 +254,8 @@ CharString String::ascii() const { } Char16String String::utf16() const { - int length = internal::gdextension_interface_string_to_utf16_chars(_native_ptr(), nullptr, 0); - int size = length + 1; + int64_t length = internal::gdextension_interface_string_to_utf16_chars(_native_ptr(), nullptr, 0); + int64_t size = length + 1; Char16String str; str.resize(size); internal::gdextension_interface_string_to_utf16_chars(_native_ptr(), str.ptrw(), length); @@ -266,8 +266,8 @@ Char16String String::utf16() const { } Char32String String::utf32() const { - int length = internal::gdextension_interface_string_to_utf32_chars(_native_ptr(), nullptr, 0); - int size = length + 1; + int64_t length = internal::gdextension_interface_string_to_utf32_chars(_native_ptr(), nullptr, 0); + int64_t size = length + 1; Char32String str; str.resize(size); internal::gdextension_interface_string_to_utf32_chars(_native_ptr(), str.ptrw(), length); @@ -278,8 +278,8 @@ Char32String String::utf32() const { } CharWideString String::wide_string() const { - int length = internal::gdextension_interface_string_to_wide_chars(_native_ptr(), nullptr, 0); - int size = length + 1; + int64_t length = internal::gdextension_interface_string_to_wide_chars(_native_ptr(), nullptr, 0); + int64_t size = length + 1; CharWideString str; str.resize(size); internal::gdextension_interface_string_to_wide_chars(_native_ptr(), str.ptrw(), length); @@ -289,7 +289,7 @@ CharWideString String::wide_string() const { return str; } -Error String::resize(int p_size) { +Error String::resize(int64_t p_size) { return (Error)internal::gdextension_interface_string_resize(_native_ptr(), p_size); } @@ -390,11 +390,11 @@ String &String::operator+=(const char32_t *p_str) { return *this; } -const char32_t &String::operator[](int p_index) const { +const char32_t &String::operator[](int64_t p_index) const { return *internal::gdextension_interface_string_operator_index_const((GDExtensionStringPtr)this, p_index); } -char32_t &String::operator[](int p_index) { +char32_t &String::operator[](int64_t p_index) { return *internal::gdextension_interface_string_operator_index((GDExtensionStringPtr)this, p_index); } diff --git a/src/variant/packed_arrays.cpp b/src/variant/packed_arrays.cpp index 65b00025..fe8b3597 100644 --- a/src/variant/packed_arrays.cpp +++ b/src/variant/packed_arrays.cpp @@ -46,11 +46,11 @@ namespace godot { -const uint8_t &PackedByteArray::operator[](int p_index) const { +const uint8_t &PackedByteArray::operator[](int64_t p_index) const { return *internal::gdextension_interface_packed_byte_array_operator_index_const((GDExtensionTypePtr *)this, p_index); } -uint8_t &PackedByteArray::operator[](int p_index) { +uint8_t &PackedByteArray::operator[](int64_t p_index) { return *internal::gdextension_interface_packed_byte_array_operator_index((GDExtensionTypePtr *)this, p_index); } @@ -62,12 +62,12 @@ uint8_t *PackedByteArray::ptrw() { return internal::gdextension_interface_packed_byte_array_operator_index((GDExtensionTypePtr *)this, 0); } -const Color &PackedColorArray::operator[](int p_index) const { +const Color &PackedColorArray::operator[](int64_t p_index) const { const Color *color = (const Color *)internal::gdextension_interface_packed_color_array_operator_index_const((GDExtensionTypePtr *)this, p_index); return *color; } -Color &PackedColorArray::operator[](int p_index) { +Color &PackedColorArray::operator[](int64_t p_index) { Color *color = (Color *)internal::gdextension_interface_packed_color_array_operator_index((GDExtensionTypePtr *)this, p_index); return *color; } @@ -80,11 +80,11 @@ Color *PackedColorArray::ptrw() { return (Color *)internal::gdextension_interface_packed_color_array_operator_index((GDExtensionTypePtr *)this, 0); } -const float &PackedFloat32Array::operator[](int p_index) const { +const float &PackedFloat32Array::operator[](int64_t p_index) const { return *internal::gdextension_interface_packed_float32_array_operator_index_const((GDExtensionTypePtr *)this, p_index); } -float &PackedFloat32Array::operator[](int p_index) { +float &PackedFloat32Array::operator[](int64_t p_index) { return *internal::gdextension_interface_packed_float32_array_operator_index((GDExtensionTypePtr *)this, p_index); } @@ -96,11 +96,11 @@ float *PackedFloat32Array::ptrw() { return internal::gdextension_interface_packed_float32_array_operator_index((GDExtensionTypePtr *)this, 0); } -const double &PackedFloat64Array::operator[](int p_index) const { +const double &PackedFloat64Array::operator[](int64_t p_index) const { return *internal::gdextension_interface_packed_float64_array_operator_index_const((GDExtensionTypePtr *)this, p_index); } -double &PackedFloat64Array::operator[](int p_index) { +double &PackedFloat64Array::operator[](int64_t p_index) { return *internal::gdextension_interface_packed_float64_array_operator_index((GDExtensionTypePtr *)this, p_index); } @@ -112,11 +112,11 @@ double *PackedFloat64Array::ptrw() { return internal::gdextension_interface_packed_float64_array_operator_index((GDExtensionTypePtr *)this, 0); } -const int32_t &PackedInt32Array::operator[](int p_index) const { +const int32_t &PackedInt32Array::operator[](int64_t p_index) const { return *internal::gdextension_interface_packed_int32_array_operator_index_const((GDExtensionTypePtr *)this, p_index); } -int32_t &PackedInt32Array::operator[](int p_index) { +int32_t &PackedInt32Array::operator[](int64_t p_index) { return *internal::gdextension_interface_packed_int32_array_operator_index((GDExtensionTypePtr *)this, p_index); } @@ -128,11 +128,11 @@ int32_t *PackedInt32Array::ptrw() { return internal::gdextension_interface_packed_int32_array_operator_index((GDExtensionTypePtr *)this, 0); } -const int64_t &PackedInt64Array::operator[](int p_index) const { +const int64_t &PackedInt64Array::operator[](int64_t p_index) const { return *internal::gdextension_interface_packed_int64_array_operator_index_const((GDExtensionTypePtr *)this, p_index); } -int64_t &PackedInt64Array::operator[](int p_index) { +int64_t &PackedInt64Array::operator[](int64_t p_index) { return *internal::gdextension_interface_packed_int64_array_operator_index((GDExtensionTypePtr *)this, p_index); } @@ -144,12 +144,12 @@ int64_t *PackedInt64Array::ptrw() { return internal::gdextension_interface_packed_int64_array_operator_index((GDExtensionTypePtr *)this, 0); } -const String &PackedStringArray::operator[](int p_index) const { +const String &PackedStringArray::operator[](int64_t p_index) const { const String *string = (const String *)internal::gdextension_interface_packed_string_array_operator_index_const((GDExtensionTypePtr *)this, p_index); return *string; } -String &PackedStringArray::operator[](int p_index) { +String &PackedStringArray::operator[](int64_t p_index) { String *string = (String *)internal::gdextension_interface_packed_string_array_operator_index((GDExtensionTypePtr *)this, p_index); return *string; } @@ -162,12 +162,12 @@ String *PackedStringArray::ptrw() { return (String *)internal::gdextension_interface_packed_string_array_operator_index((GDExtensionTypePtr *)this, 0); } -const Vector2 &PackedVector2Array::operator[](int p_index) const { +const Vector2 &PackedVector2Array::operator[](int64_t p_index) const { const Vector2 *vec = (const Vector2 *)internal::gdextension_interface_packed_vector2_array_operator_index_const((GDExtensionTypePtr *)this, p_index); return *vec; } -Vector2 &PackedVector2Array::operator[](int p_index) { +Vector2 &PackedVector2Array::operator[](int64_t p_index) { Vector2 *vec = (Vector2 *)internal::gdextension_interface_packed_vector2_array_operator_index((GDExtensionTypePtr *)this, p_index); return *vec; } @@ -180,12 +180,12 @@ Vector2 *PackedVector2Array::ptrw() { return (Vector2 *)internal::gdextension_interface_packed_vector2_array_operator_index((GDExtensionTypePtr *)this, 0); } -const Vector3 &PackedVector3Array::operator[](int p_index) const { +const Vector3 &PackedVector3Array::operator[](int64_t p_index) const { const Vector3 *vec = (const Vector3 *)internal::gdextension_interface_packed_vector3_array_operator_index_const((GDExtensionTypePtr *)this, p_index); return *vec; } -Vector3 &PackedVector3Array::operator[](int p_index) { +Vector3 &PackedVector3Array::operator[](int64_t p_index) { Vector3 *vec = (Vector3 *)internal::gdextension_interface_packed_vector3_array_operator_index((GDExtensionTypePtr *)this, p_index); return *vec; } @@ -198,12 +198,12 @@ Vector3 *PackedVector3Array::ptrw() { return (Vector3 *)internal::gdextension_interface_packed_vector3_array_operator_index((GDExtensionTypePtr *)this, 0); } -const Variant &Array::operator[](int p_index) const { +const Variant &Array::operator[](int64_t p_index) const { const Variant *var = (const Variant *)internal::gdextension_interface_array_operator_index_const((GDExtensionTypePtr *)this, p_index); return *var; } -Variant &Array::operator[](int p_index) { +Variant &Array::operator[](int64_t p_index) { Variant *var = (Variant *)internal::gdextension_interface_array_operator_index((GDExtensionTypePtr *)this, p_index); return *var; } From 6e3923d9fc01d135ff7a6782bc2780115cab4810 Mon Sep 17 00:00:00 2001 From: MJacred Date: Mon, 22 Jan 2024 10:50:27 +0100 Subject: [PATCH 12/12] Update README: fix godot-cpp issue tracker url (cherry picked from commit 8a535d0ecc473e9c8221342363bb295c11ba6bd5) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9766fb9c..f4f3be0c 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ first-party `godot-cpp` extension. Some compatibility breakage is to be expected as GDExtension and `godot-cpp` get more used, documented, and critical issues get resolved. See the [Godot issue tracker](https://github.com/godotengine/godot/issues?q=is%3Aissue+is%3Aopen+label%3Atopic%3Agdextension) -and the [godot-cpp issue tracker](https://github.com/godotengine/godot/issues) +and the [godot-cpp issue tracker](https://github.com/godotengine/godot-cpp/issues) for a list of known issues, and be sure to provide feedback on issues and PRs which affect your use of this extension.