From 663ee4de7a3089a57c132c749aebc713ce0b4719 Mon Sep 17 00:00:00 2001 From: Relintai Date: Wed, 31 May 2023 13:31:45 +0200 Subject: [PATCH] Mass api renames. --- .github/workflows_off/ci.yml | 8 +- CMakeLists.txt | 4 +- README.md | 6 +- binding_generator.py | 54 ++++---- include/core/Array.hpp | 6 +- include/core/Dictionary.hpp | 6 +- include/core/Godot.hpp | 206 ++++++++++++++-------------- include/core/GodotGlobal.hpp | 26 ++-- include/core/NodePath.hpp | 4 +- include/core/PoolArrays.hpp | 182 ++++++++++++------------- include/core/RID.hpp | 4 +- include/core/String.hpp | 10 +- include/core/Variant.hpp | 8 +- include/core/Wrapped.hpp | 2 +- src/core/Array.cpp | 88 ++++++------ src/core/Dictionary.cpp | 34 ++--- src/core/GodotGlobal.cpp | 84 ++++++------ src/core/NodePath.cpp | 34 ++--- src/core/PoolArrays.cpp | 256 +++++++++++++++++------------------ src/core/RID.cpp | 14 +- src/core/String.cpp | 228 +++++++++++++++---------------- src/core/TagDB.cpp | 2 +- src/core/Variant.cpp | 164 +++++++++++----------- test/gdexample.gdnlib | 2 +- test/src/init.cpp | 6 +- 25 files changed, 719 insertions(+), 719 deletions(-) diff --git a/.github/workflows_off/ci.yml b/.github/workflows_off/ci.yml index 0dc2cdb..159d827 100644 --- a/.github/workflows_off/ci.yml +++ b/.github/workflows_off/ci.yml @@ -22,7 +22,7 @@ jobs: platform: linux artifact-name: godot-cpp-linux-glibc2.27-x86_64-release artifact-path: bin/libgodot-cpp.linux.release.64.a - godot_zip: Godot_v3.5-stable_linux_server.64.zip + pandemonium_zip: Godot_v3.5-stable_linux_server.64.zip executable: Godot_v3.5-stable_linux_server.64 cache-name: linux-x86_64 @@ -47,7 +47,7 @@ jobs: artifact-name: godot-cpp-macos-universal-release artifact-path: bin/libgodot-cpp.osx.release.64.a flags: macos_arch=universal - godot_zip: Godot_v3.5-stable_osx.universal.zip + pandemonium_zip: Godot_v3.5-stable_osx.universal.zip executable: Godot.app/Contents/MacOS/Godot cache-name: macos-unversal @@ -117,8 +117,8 @@ jobs: - name: Run test GDNative library if: ${{ matrix.platform == 'linux' || matrix.platform == 'osx' }} run: | - curl -LO https://downloads.tuxfamily.org/godotengine/3.5/${{ matrix.godot_zip }} - unzip ${{ matrix.godot_zip }} + curl -LO https://downloads.tuxfamily.org/godotengine/3.5/${{ matrix.pandemonium_zip }} + unzip ${{ matrix.pandemonium_zip }} ./${{ matrix.executable }} --path test -s script.gd - name: Upload artifact diff --git a/CMakeLists.txt b/CMakeLists.txt index 2d0de55..9ecab04 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,8 +2,8 @@ # CMAKE_BUILD_TYPE: Compilation target (Debug or Release defaults to Debug) # # godot-cpp cmake arguments -# GODOT_HEADERS_DIR: This is where the gdnative include folder is (godot_source/modules/gdn/include) -# GODOT_CUSTOM_API_FILE: This is if you have another path for the godot_api.json +# GODOT_HEADERS_DIR: This is where the gdnative include folder is (pandemonium_source/modules/gdn/include) +# GODOT_CUSTOM_API_FILE: This is if you have another path for the pandemonium_api.json # # Android cmake arguments # CMAKE_TOOLCHAIN_FILE: The path to the android cmake toolchain ($ANDROID_NDK/build/cmake/android.toolchain.cmake) diff --git a/README.md b/README.md index bef08f9..4888e17 100644 --- a/README.md +++ b/README.md @@ -210,17 +210,17 @@ public: }; /** GDNative Initialize **/ -extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) { +extern "C" void GDN_EXPORT pandemonium_gdnative_init(pandemonium_gdnative_init_options *o) { godot::Godot::gdnative_init(o); } /** GDNative Terminate **/ -extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) { +extern "C" void GDN_EXPORT pandemonium_gdnative_terminate(pandemonium_gdnative_terminate_options *o) { godot::Godot::gdnative_terminate(o); } /** NativeScript Initialize **/ -extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) { +extern "C" void GDN_EXPORT pandemonium_nativescript_init(void *handle) { godot::Godot::nativescript_init(handle); godot::register_class(); diff --git a/binding_generator.py b/binding_generator.py index da4bb61..81b2b9d 100644 --- a/binding_generator.py +++ b/binding_generator.py @@ -48,12 +48,12 @@ def print_file_list(api_filepath, output_dir, headers=False, sources=False): def scons_emit_files(target, source, env): files = [env.File(f) for f in get_file_list(str(source[0]), target[0].abspath, True, True)] env.Clean(target, files) - env["godot_cpp_gen_dir"] = target[0].abspath + env["pandemonium_cpp_gen_dir"] = target[0].abspath return files, source def scons_generate_bindings(target, source, env): - generate_bindings(str(source[0]), env["generate_template_get_node"], env["godot_cpp_gen_dir"]) + generate_bindings(str(source[0]), env["generate_template_get_node"], env["pandemonium_cpp_gen_dir"]) return None @@ -205,7 +205,7 @@ def generate_class_header(used_classes, c, use_template_get_node): source.append("\tstruct ___method_bindings {") for method in c["methods"]: - source.append("\t\tgodot_method_bind *mb_" + method["name"] + ";") + source.append("\t\tpandemonium_method_bind *mb_" + method["name"] + ";") source.append("\t};") source.append("\tstatic ___method_bindings ___mb;") @@ -229,22 +229,22 @@ def generate_class_header(used_classes, c, use_template_get_node): source.append("\t}") source.append("") - # godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");" + # godot::api->pandemonium_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");" # class name: # Two versions needed needed because when the user implements a custom class, - # we want to override `___get_class_name` while `___get_godot_class_name` can keep returning the base name + # we want to override `___get_class_name` while `___get_pandemonium_class_name` can keep returning the base name source.append( '\tstatic inline const char *___get_class_name() { return (const char *) "' + strip_name(c["name"]) + '"; }' ) source.append( - '\tstatic inline const char *___get_godot_class_name() { return (const char *) "' + '\tstatic inline const char *___get_pandemonium_class_name() { return (const char *) "' + strip_name(c["name"]) + '"; }' ) source.append( - "\tstatic inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }" + "\tstatic inline Object *___get_from_variant(Variant a) { pandemonium_object *o = (pandemonium_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->pandemonium_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }" ) enum_values = [] @@ -437,7 +437,7 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node # FIXME Test if inlining has a huge impact on binary size source.append(class_name + "::" + class_name + "() {") - source.append('\t_owner = godot::api->godot_global_get_singleton((char *) "' + strip_name(c["name"]) + '");') + source.append('\t_owner = godot::api->pandemonium_global_get_singleton((char *) "' + strip_name(c["name"]) + '");') source.append("}") source.append("") @@ -456,17 +456,17 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node source.append( "\t___mb.mb_" + method["name"] - + ' = godot::api->godot_method_bind_get_method("' + + ' = godot::api->pandemonium_method_bind_get_method("' + c["name"] + '", "' + ("get_node" if use_template_get_node and method["name"] == "get_node_internal" else method["name"]) + '");' ) - source.append("\tgodot_string_name class_name;") - source.append('\tgodot::api->godot_string_name_new_data(&class_name, "' + c["name"] + '");') - source.append("\t_detail_class_tag = godot::core_1_2_api->godot_get_class_tag(&class_name);") - source.append("\tgodot::api->godot_string_name_destroy(&class_name);") + source.append("\tpandemonium_string_name class_name;") + source.append('\tgodot::api->pandemonium_string_name_new_data(&class_name, "' + c["name"] + '");') + source.append("\t_detail_class_tag = godot::core_1_2_api->pandemonium_get_class_tag(&class_name);") + source.append("\tgodot::api->pandemonium_string_name_destroy(&class_name);") source.append("}") source.append("") @@ -477,7 +477,7 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node source.append( "\treturn (" + class_name - + ' *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, godot::api->godot_get_class_constructor((char *)"' + + ' *) godot::nativescript_1_1_api->pandemonium_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, godot::api->pandemonium_get_class_constructor((char *)"' + c["name"] + '")());' ) @@ -507,7 +507,7 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node if method["name"] == "free": # dirty hack because Object::free is marked virtual but doesn't actually exist... - source.append("\tgodot::api->godot_object_destroy(_owner);") + source.append("\tgodot::api->pandemonium_object_destroy(_owner);") source.append("}") source.append("") continue @@ -541,7 +541,7 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node source.append("\tVariant __given_args[" + str(len(method["arguments"])) + "];") for i, argument in enumerate(method["arguments"]): - source.append("\tgodot::api->godot_variant_new_nil((godot_variant *) &__given_args[" + str(i) + "]);") + source.append("\tgodot::api->pandemonium_variant_new_nil((pandemonium_variant *) &__given_args[" + str(i) + "]);") source.append("") @@ -557,13 +557,13 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node size = "(" + str(len(method["arguments"])) + ")" source.append( - "\tgodot_variant **__args = (godot_variant **) alloca(sizeof(godot_variant *) * " + size + ");" + "\tpandemonium_variant **__args = (pandemonium_variant **) alloca(sizeof(pandemonium_variant *) * " + size + ");" ) source.append("") for i, argument in enumerate(method["arguments"]): - source.append("\t__args[" + str(i) + "] = (godot_variant *) &__given_args[" + str(i) + "];") + source.append("\t__args[" + str(i) + "] = (pandemonium_variant *) &__given_args[" + str(i) + "];") source.append("") @@ -572,7 +572,7 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node source.append( "\t\t__args[i + " + str(len(method["arguments"])) - + "] = (godot_variant *) &((Array &) __var_args)[i];" + + "] = (pandemonium_variant *) &((Array &) __var_args)[i];" ) source.append("\t}") @@ -580,11 +580,11 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node source.append("\tVariant __result;") source.append( - "\t*(godot_variant *) &__result = godot::api->godot_method_bind_call(___mb.mb_" + "\t*(pandemonium_variant *) &__result = godot::api->pandemonium_method_bind_call(___mb.mb_" + method["name"] + ", ((const Object *) " + core_object_name - + ")->_owner, (const godot_variant **) __args, " + + ")->_owner, (const pandemonium_variant **) __args, " + size + ", nullptr);" ) @@ -599,7 +599,7 @@ def generate_class_implementation(icalls, used_classes, c, use_template_get_node source.append("") for i, argument in enumerate(method["arguments"]): - source.append("\tgodot::api->godot_variant_destroy((godot_variant *) &__given_args[" + str(i) + "]);") + source.append("\tgodot::api->pandemonium_variant_destroy((pandemonium_variant *) &__given_args[" + str(i) + "]);") source.append("") @@ -683,7 +683,7 @@ def generate_icall_header(icalls): method_signature = "static inline " method_signature += ( - get_icall_return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, const Object *inst" + get_icall_return_type(ret_type) + get_icall_name(icall) + "(pandemonium_method_bind *mb, const Object *inst" ) for i, arg in enumerate(args): @@ -708,7 +708,7 @@ def generate_icall_header(icalls): if ret_type != "void": source.append( - "\t" + ("godot_object *" if is_class_type(ret_type) else get_icall_return_type(ret_type)) + "ret;" + "\t" + ("pandemonium_object *" if is_class_type(ret_type) else get_icall_return_type(ret_type)) + "ret;" ) if is_class_type(ret_type): source.append("\tret = nullptr;") @@ -730,7 +730,7 @@ def generate_icall_header(icalls): source.append("") source.append( - "\tgodot::api->godot_method_bind_ptrcall(mb, inst->_owner, args, " + "\tgodot::api->pandemonium_method_bind_ptrcall(mb, inst->_owner, args, " + ("nullptr" if ret_type == "void" else "&ret") + ");" ) @@ -739,7 +739,7 @@ def generate_icall_header(icalls): if is_class_type(ret_type): source.append("\tif (ret) {") source.append( - "\t\treturn (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, ret);" + "\t\treturn (Object *) godot::nativescript_1_1_api->pandemonium_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, ret);" ) source.append("\t}") source.append("") @@ -844,7 +844,7 @@ def get_icall_name(sig): ret_type = sig[0] args = sig[1] - name = "___godot_icall_" + name = "___pandemonium_icall_" name += strip_name(ret_type) for arg in args: name += "_" + strip_name(arg) diff --git a/include/core/Array.hpp b/include/core/Array.hpp index 255b569..8af1ded 100644 --- a/include/core/Array.hpp +++ b/include/core/Array.hpp @@ -85,13 +85,13 @@ class PoolColorArray; class Object; class Array { - godot_array _godot_array; + pandemonium_array _pandemonium_array; friend class Variant; friend class Dictionary; friend class String; - inline explicit Array(const godot_array &other) { - _godot_array = other; + inline explicit Array(const pandemonium_array &other) { + _pandemonium_array = other; } public: diff --git a/include/core/Dictionary.hpp b/include/core/Dictionary.hpp index 6537033..63b1745 100644 --- a/include/core/Dictionary.hpp +++ b/include/core/Dictionary.hpp @@ -40,11 +40,11 @@ namespace godot { class Dictionary { - godot_dictionary _godot_dictionary; + pandemonium_dictionary _pandemonium_dictionary; friend Variant::operator Dictionary() const; - inline explicit Dictionary(const godot_dictionary &other) { - _godot_dictionary = other; + inline explicit Dictionary(const pandemonium_dictionary &other) { + _pandemonium_dictionary = other; } public: diff --git a/include/core/Godot.hpp b/include/core/Godot.hpp index 34d297a..fe6a7bd 100644 --- a/include/core/Godot.hpp +++ b/include/core/Godot.hpp @@ -35,7 +35,7 @@ #include #include -#include +#include #include #include "CoreTypes.hpp" @@ -55,8 +55,8 @@ namespace detail { // Godot classes are wrapped by heap-allocated instances mimicking them through the C API. // They all inherit `_Wrapped`. template -T *get_wrapper(godot_object *obj) { - return (T *)godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, obj); +T *get_wrapper(pandemonium_object *obj) { + return (T *)godot::nativescript_1_1_api->pandemonium_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, obj); } // Custom class instances are not obtainable by just casting the pointer to the base class they inherit, @@ -64,7 +64,7 @@ T *get_wrapper(godot_object *obj) { // Yet we want to "fake" it as if they were the same entity. template T *get_custom_class_instance(const Object *obj) { - return (obj) ? (T *)godot::nativescript_api->godot_nativescript_get_userdata(obj->_owner) : nullptr; + return (obj) ? (T *)godot::nativescript_api->pandemonium_nativescript_get_userdata(obj->_owner) : nullptr; } template @@ -77,24 +77,24 @@ inline T *create_custom_class_instance() { // We cannot use wrappers because of https://github.com/godotengine/godot/issues/39181 // godot::NativeScript *script = godot::NativeScript::_new(); - // script->set_library(get_wrapper((godot_object *)godot::gdnlib)); + // script->set_library(get_wrapper((pandemonium_object *)godot::gdnlib)); // script->set_class_name(T::___get_class_name()); static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes"); // So we use the C API directly. - static godot_class_constructor script_constructor = godot::api->godot_get_class_constructor("NativeScript"); - static godot_method_bind *mb_set_library = godot::api->godot_method_bind_get_method("NativeScript", "set_library"); - static godot_method_bind *mb_set_class_name = godot::api->godot_method_bind_get_method("NativeScript", "set_class_name"); - godot_object *script = script_constructor(); + static pandemonium_class_constructor script_constructor = godot::api->pandemonium_get_class_constructor("NativeScript"); + static pandemonium_method_bind *mb_set_library = godot::api->pandemonium_method_bind_get_method("NativeScript", "set_library"); + static pandemonium_method_bind *mb_set_class_name = godot::api->pandemonium_method_bind_get_method("NativeScript", "set_class_name"); + pandemonium_object *script = script_constructor(); { const void *args[] = { godot::gdnlib }; - godot::api->godot_method_bind_ptrcall(mb_set_library, script, args, nullptr); + godot::api->pandemonium_method_bind_ptrcall(mb_set_library, script, args, nullptr); } { const String class_name = T::___get_class_name(); const void *args[] = { &class_name }; - godot::api->godot_method_bind_ptrcall(mb_set_class_name, script, args, nullptr); + godot::api->pandemonium_method_bind_ptrcall(mb_set_class_name, script, args, nullptr); } // Now to instanciate T, we initially did this, however in case of Reference it returns a variant with refcount @@ -103,20 +103,20 @@ inline T *create_custom_class_instance() { //T *instance = godot::get_custom_class_instance(instance_variant); // So we should do this instead, however while convenient, it uses unnecessary wrapper objects. - // Object *base_obj = T::___new_godot_base(); + // Object *base_obj = T::___new_pandemonium_base(); // base_obj->set_script(script); // return get_custom_class_instance(base_obj); // Again using the C API to do exactly what we have to do. - static godot_class_constructor base_constructor = godot::api->godot_get_class_constructor(T::___get_godot_class_name()); - static godot_method_bind *mb_set_script = godot::api->godot_method_bind_get_method("Object", "set_script"); - godot_object *base_obj = base_constructor(); + static pandemonium_class_constructor base_constructor = godot::api->pandemonium_get_class_constructor(T::___get_pandemonium_class_name()); + static pandemonium_method_bind *mb_set_script = godot::api->pandemonium_method_bind_get_method("Object", "set_script"); + pandemonium_object *base_obj = base_constructor(); { const void *args[] = { script }; - godot::api->godot_method_bind_ptrcall(mb_set_script, base_obj, args, nullptr); + godot::api->pandemonium_method_bind_ptrcall(mb_set_script, base_obj, args, nullptr); } - return (T *)godot::nativescript_api->godot_nativescript_get_userdata(base_obj); + return (T *)godot::nativescript_api->pandemonium_nativescript_get_userdata(base_obj); } } // namespace detail @@ -127,7 +127,7 @@ inline T *create_custom_class_instance() { // Base: Name of the direct base class, with namespace if necessary // // ___get_class_name: Name of the class -// ___get_godot_class_name: Name of the Godot base class this class inherits from (i.e not direct) +// ___get_pandemonium_class_name: Name of the Godot base class this class inherits from (i.e not direct) // _new: Creates a new instance of the class // ___get_id: Gets the unique ID of the class. Godot and custom classes are both within that set. // ___get_base_id: Gets the ID of the direct base class, as returned by ___get_id @@ -138,8 +138,8 @@ inline T *create_custom_class_instance() { public: \ inline static const char *___get_class_name() { return #Name; } \ enum { ___CLASS_IS_SCRIPT = 1 }; \ - inline static const char *___get_godot_class_name() { \ - return Base::___get_godot_class_name(); \ + inline static const char *___get_pandemonium_class_name() { \ + return Base::___get_pandemonium_class_name(); \ } \ inline static Name *_new() { \ return godot::detail::create_custom_class_instance(); \ @@ -181,7 +181,7 @@ struct _ArgCast { // instance and destroy funcs template -void *_godot_class_instance_func(godot_object *p, void * /*method_data*/) { +void *_pandemonium_class_instance_func(pandemonium_object *p, void * /*method_data*/) { T *d = new T(); d->_owner = p; d->_type_tag = typeid(T).hash_code(); @@ -190,7 +190,7 @@ void *_godot_class_instance_func(godot_object *p, void * /*method_data*/) { } template -void _godot_class_destroy_func(godot_object * /*p*/, void * /*method_data*/, void *data) { +void _pandemonium_class_destroy_func(pandemonium_object * /*p*/, void * /*method_data*/, void *data) { T *d = (T *)data; delete d; } @@ -199,18 +199,18 @@ template void register_class() { static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes"); - godot_instance_create_func create = {}; - create.create_func = _godot_class_instance_func; + pandemonium_instance_create_func create = {}; + create.create_func = _pandemonium_class_instance_func; - godot_instance_destroy_func destroy = {}; - destroy.destroy_func = _godot_class_destroy_func; + pandemonium_instance_destroy_func destroy = {}; + destroy.destroy_func = _pandemonium_class_destroy_func; _TagDB::register_type(T::___get_id(), T::___get_base_id()); - godot::nativescript_api->godot_nativescript_register_class(godot::_RegisterState::nativescript_handle, + godot::nativescript_api->pandemonium_nativescript_register_class(godot::_RegisterState::nativescript_handle, T::___get_class_name(), T::___get_base_class_name(), create, destroy); - godot::nativescript_1_1_api->godot_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle, + godot::nativescript_1_1_api->pandemonium_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle, T::___get_class_name(), (const void *)T::___get_id()); T::_register_methods(); @@ -220,18 +220,18 @@ template void register_tool_class() { static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes"); - godot_instance_create_func create = {}; - create.create_func = _godot_class_instance_func; + pandemonium_instance_create_func create = {}; + create.create_func = _pandemonium_class_instance_func; - godot_instance_destroy_func destroy = {}; - destroy.destroy_func = _godot_class_destroy_func; + pandemonium_instance_destroy_func destroy = {}; + destroy.destroy_func = _pandemonium_class_destroy_func; _TagDB::register_type(T::___get_id(), T::___get_base_id()); - godot::nativescript_api->godot_nativescript_register_tool_class(godot::_RegisterState::nativescript_handle, + godot::nativescript_api->pandemonium_nativescript_register_tool_class(godot::_RegisterState::nativescript_handle, T::___get_class_name(), T::___get_base_class_name(), create, destroy); - godot::nativescript_1_1_api->godot_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle, + godot::nativescript_1_1_api->pandemonium_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle, T::___get_class_name(), (const void *)T::___get_id()); T::_register_methods(); @@ -239,7 +239,7 @@ void register_tool_class() { // method registering -typedef godot_variant (*__godot_wrapper_method)(godot_object *, void *, void *, int, godot_variant **); +typedef pandemonium_variant (*__pandemonium_wrapper_method)(pandemonium_object *, void *, void *, int, pandemonium_variant **); template const char *___get_method_class_name(R (T::*p)(args... a)) { @@ -297,9 +297,9 @@ struct _WrappedMethod { }; template -godot_variant __wrapped_method(godot_object *, void *method_data, void *user_data, int /*num_args*/, godot_variant **args) { - godot_variant v; - godot::api->godot_variant_new_nil(&v); +pandemonium_variant __wrapped_method(pandemonium_object *, void *method_data, void *user_data, int /*num_args*/, pandemonium_variant **args) { + pandemonium_variant v; + godot::api->pandemonium_variant_new_nil(&v); T *obj = (T *)user_data; _WrappedMethod *method = (_WrappedMethod *)method_data; @@ -315,14 +315,14 @@ godot_variant __wrapped_method(godot_object *, void *method_data, void *user_dat template void *___make_wrapper_function(R (T::*f)(As...)) { using MethodType = _WrappedMethod; - MethodType *p = (MethodType *)godot::api->godot_alloc(sizeof(MethodType)); + MethodType *p = (MethodType *)godot::api->pandemonium_alloc(sizeof(MethodType)); p->f = f; return (void *)p; } template -__godot_wrapper_method ___get_wrapper_function(R (T::* /*f*/)(As...)) { - return (__godot_wrapper_method)&__wrapped_method; +__pandemonium_wrapper_method ___get_wrapper_function(R (T::* /*f*/)(As...)) { + return (__pandemonium_wrapper_method)&__wrapped_method; } template @@ -331,28 +331,28 @@ void *___make_wrapper_function(R (T::*f)(A...) const) { } template -__godot_wrapper_method ___get_wrapper_function(R (T::*f)(A...) const) { +__pandemonium_wrapper_method ___get_wrapper_function(R (T::*f)(A...) const) { return ___get_wrapper_function((R(T::*)(A...))f); } template -void register_method(const char *name, M method_ptr, godot_method_rpc_mode rpc_type = GODOT_METHOD_RPC_MODE_DISABLED) { - godot_instance_method method = {}; +void register_method(const char *name, M method_ptr, pandemonium_method_rpc_mode rpc_type = GODOT_METHOD_RPC_MODE_DISABLED) { + pandemonium_instance_method method = {}; method.method_data = ___make_wrapper_function(method_ptr); - method.free_func = godot::api->godot_free; - method.method = (__godot_wrapper_method)___get_wrapper_function(method_ptr); + method.free_func = godot::api->pandemonium_free; + method.method = (__pandemonium_wrapper_method)___get_wrapper_function(method_ptr); - godot_method_attributes attr = {}; + pandemonium_method_attributes attr = {}; attr.rpc_type = rpc_type; - godot::nativescript_api->godot_nativescript_register_method(godot::_RegisterState::nativescript_handle, + godot::nativescript_api->pandemonium_nativescript_register_method(godot::_RegisterState::nativescript_handle, ___get_method_class_name(method_ptr), name, attr, method); } // User can specify a derived class D to register the method for, instead of it being inferred. template void register_method_explicit(const char *name, R (B::*method_ptr)(As...), - godot_method_rpc_mode rpc_type = GODOT_METHOD_RPC_MODE_DISABLED) { + pandemonium_method_rpc_mode rpc_type = GODOT_METHOD_RPC_MODE_DISABLED) { static_assert(std::is_base_of::value, "Explicit class must derive from method class"); register_method(name, static_cast(method_ptr), rpc_type); } @@ -360,7 +360,7 @@ void register_method_explicit(const char *name, R (B::*method_ptr)(As...), template struct _PropertySetFunc { void (T::*f)(P); - static void _wrapped_setter(godot_object * /*object*/, void *method_data, void *user_data, godot_variant *value) { + static void _wrapped_setter(pandemonium_object * /*object*/, void *method_data, void *user_data, pandemonium_variant *value) { _PropertySetFunc *set_func = (_PropertySetFunc *)method_data; T *obj = (T *)user_data; @@ -374,12 +374,12 @@ template struct _PropertyGetFunc { P(T::*f) (); - static godot_variant _wrapped_getter(godot_object * /*object*/, void *method_data, void *user_data) { + static pandemonium_variant _wrapped_getter(pandemonium_object * /*object*/, void *method_data, void *user_data) { _PropertyGetFunc *get_func = (_PropertyGetFunc *)method_data; T *obj = (T *)user_data; - godot_variant var; - godot::api->godot_variant_new_nil(&var); + pandemonium_variant var; + godot::api->pandemonium_variant_new_nil(&var); Variant *v = (Variant *)&var; @@ -392,7 +392,7 @@ struct _PropertyGetFunc { template struct _PropertyDefaultSetFunc { P(T::*f); - static void _wrapped_setter(godot_object * /*object*/, void *method_data, void *user_data, godot_variant *value) { + static void _wrapped_setter(pandemonium_object * /*object*/, void *method_data, void *user_data, pandemonium_variant *value) { _PropertyDefaultSetFunc *set_func = (_PropertyDefaultSetFunc *)method_data; T *obj = (T *)user_data; @@ -405,12 +405,12 @@ struct _PropertyDefaultSetFunc { template struct _PropertyDefaultGetFunc { P(T::*f); - static godot_variant _wrapped_getter(godot_object * /*object*/, void *method_data, void *user_data) { + static pandemonium_variant _wrapped_getter(pandemonium_object * /*object*/, void *method_data, void *user_data) { _PropertyDefaultGetFunc *get_func = (_PropertyDefaultGetFunc *)method_data; T *obj = (T *)user_data; - godot_variant var; - godot::api->godot_variant_new_nil(&var); + pandemonium_variant var; + godot::api->pandemonium_variant_new_nil(&var); Variant *v = (Variant *)&var; @@ -422,31 +422,31 @@ struct _PropertyDefaultGetFunc { template void register_property(const char *name, P(T::*var), P default_value, - godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, - godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, - godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") { + pandemonium_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, + pandemonium_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, + pandemonium_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") { static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes"); Variant def_val = default_value; - usage = (godot_property_usage_flags)((int)usage | GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE); + usage = (pandemonium_property_usage_flags)((int)usage | GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE); if (def_val.get_type() == Variant::OBJECT) { - Object *o = detail::get_wrapper(def_val.operator godot_object *()); + Object *o = detail::get_wrapper(def_val.operator pandemonium_object *()); if (o && o->is_class("Resource")) { - hint = (godot_property_hint)((int)hint | GODOT_PROPERTY_HINT_RESOURCE_TYPE); + hint = (pandemonium_property_hint)((int)hint | GODOT_PROPERTY_HINT_RESOURCE_TYPE); hint_string = o->get_class(); } } - godot_string *_hint_string = (godot_string *)&hint_string; + pandemonium_string *_hint_string = (pandemonium_string *)&hint_string; - godot_property_attributes attr = {}; + pandemonium_property_attributes attr = {}; if (def_val.get_type() == Variant::NIL) { attr.type = Variant::OBJECT; } else { attr.type = def_val.get_type(); - attr.default_value = *(godot_variant *)&def_val; + attr.default_value = *(pandemonium_variant *)&def_val; } attr.hint = hint; @@ -455,75 +455,75 @@ void register_property(const char *name, P(T::*var), P default_value, attr.hint_string = *_hint_string; _PropertyDefaultSetFunc *wrapped_set = - (_PropertyDefaultSetFunc *)godot::api->godot_alloc(sizeof(_PropertyDefaultSetFunc)); + (_PropertyDefaultSetFunc *)godot::api->pandemonium_alloc(sizeof(_PropertyDefaultSetFunc)); wrapped_set->f = var; _PropertyDefaultGetFunc *wrapped_get = - (_PropertyDefaultGetFunc *)godot::api->godot_alloc(sizeof(_PropertyDefaultGetFunc)); + (_PropertyDefaultGetFunc *)godot::api->pandemonium_alloc(sizeof(_PropertyDefaultGetFunc)); wrapped_get->f = var; - godot_property_set_func set_func = {}; + pandemonium_property_set_func set_func = {}; set_func.method_data = (void *)wrapped_set; - set_func.free_func = godot::api->godot_free; + set_func.free_func = godot::api->pandemonium_free; set_func.set_func = &_PropertyDefaultSetFunc::_wrapped_setter; - godot_property_get_func get_func = {}; + pandemonium_property_get_func get_func = {}; get_func.method_data = (void *)wrapped_get; - get_func.free_func = godot::api->godot_free; + get_func.free_func = godot::api->pandemonium_free; get_func.get_func = &_PropertyDefaultGetFunc::_wrapped_getter; - godot::nativescript_api->godot_nativescript_register_property(godot::_RegisterState::nativescript_handle, + godot::nativescript_api->pandemonium_nativescript_register_property(godot::_RegisterState::nativescript_handle, T::___get_class_name(), name, &attr, set_func, get_func); } template void register_property(const char *name, void (T::*setter)(P), P (T::*getter)(), P default_value, - godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, - godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, - godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") { + pandemonium_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, + pandemonium_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, + pandemonium_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") { static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes"); Variant def_val = default_value; - godot_string *_hint_string = (godot_string *)&hint_string; + pandemonium_string *_hint_string = (pandemonium_string *)&hint_string; - godot_property_attributes attr = {}; + pandemonium_property_attributes attr = {}; if (def_val.get_type() == Variant::NIL) { attr.type = Variant::OBJECT; } else { attr.type = def_val.get_type(); - attr.default_value = *(godot_variant *)&def_val; + attr.default_value = *(pandemonium_variant *)&def_val; } attr.hint = hint; attr.rset_type = rpc_mode; attr.usage = usage; attr.hint_string = *_hint_string; - _PropertySetFunc *wrapped_set = (_PropertySetFunc *)godot::api->godot_alloc(sizeof(_PropertySetFunc)); + _PropertySetFunc *wrapped_set = (_PropertySetFunc *)godot::api->pandemonium_alloc(sizeof(_PropertySetFunc)); wrapped_set->f = setter; - _PropertyGetFunc *wrapped_get = (_PropertyGetFunc *)godot::api->godot_alloc(sizeof(_PropertyGetFunc)); + _PropertyGetFunc *wrapped_get = (_PropertyGetFunc *)godot::api->pandemonium_alloc(sizeof(_PropertyGetFunc)); wrapped_get->f = getter; - godot_property_set_func set_func = {}; + pandemonium_property_set_func set_func = {}; set_func.method_data = (void *)wrapped_set; - set_func.free_func = godot::api->godot_free; + set_func.free_func = godot::api->pandemonium_free; set_func.set_func = &_PropertySetFunc::_wrapped_setter; - godot_property_get_func get_func = {}; + pandemonium_property_get_func get_func = {}; get_func.method_data = (void *)wrapped_get; - get_func.free_func = godot::api->godot_free; + get_func.free_func = godot::api->pandemonium_free; get_func.get_func = &_PropertyGetFunc::_wrapped_getter; - godot::nativescript_api->godot_nativescript_register_property(godot::_RegisterState::nativescript_handle, + godot::nativescript_api->pandemonium_nativescript_register_property(godot::_RegisterState::nativescript_handle, T::___get_class_name(), name, &attr, set_func, get_func); } template void register_property(const char *name, void (T::*setter)(P), P (T::*getter)() const, P default_value, - godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, - godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, - godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") { + pandemonium_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, + pandemonium_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, + pandemonium_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") { register_property(name, setter, (P(T::*)())getter, default_value, rpc_mode, usage, hint, hint_string); } @@ -531,23 +531,23 @@ template void register_signal(String name, Dictionary args) { static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes"); - godot_signal signal = {}; - signal.name = *(godot_string *)&name; + pandemonium_signal signal = {}; + signal.name = *(pandemonium_string *)&name; signal.num_args = args.size(); signal.num_default_args = 0; // Need to check because malloc(0) is platform-dependent. Zero arguments will leave args to nullptr. if (signal.num_args != 0) { - signal.args = (godot_signal_argument *)godot::api->godot_alloc(sizeof(godot_signal_argument) * signal.num_args); - memset((void *)signal.args, 0, sizeof(godot_signal_argument) * signal.num_args); + signal.args = (pandemonium_signal_argument *)godot::api->pandemonium_alloc(sizeof(pandemonium_signal_argument) * signal.num_args); + memset((void *)signal.args, 0, sizeof(pandemonium_signal_argument) * signal.num_args); } for (int i = 0; i < signal.num_args; i++) { // Array entry = args[i]; // String name = entry[0]; String name = args.keys()[i]; - godot_string *_key = (godot_string *)&name; - godot::api->godot_string_new_copy(&signal.args[i].name, _key); + pandemonium_string *_key = (pandemonium_string *)&name; + godot::api->pandemonium_string_new_copy(&signal.args[i].name, _key); // if (entry.size() > 1) { // signal.args[i].type = entry[1]; @@ -555,15 +555,15 @@ void register_signal(String name, Dictionary args) { signal.args[i].type = args.values()[i]; } - godot::nativescript_api->godot_nativescript_register_signal(godot::_RegisterState::nativescript_handle, + godot::nativescript_api->pandemonium_nativescript_register_signal(godot::_RegisterState::nativescript_handle, T::___get_class_name(), &signal); for (int i = 0; i < signal.num_args; i++) { - godot::api->godot_string_destroy(&signal.args[i].name); + godot::api->pandemonium_string_destroy(&signal.args[i].name); } if (signal.args) { - godot::api->godot_free(signal.args); + godot::api->pandemonium_free(signal.args); } } @@ -576,10 +576,10 @@ template void register_signal(String name) { static_assert(T::___CLASS_IS_SCRIPT, "This function must only be used on custom classes"); - godot_signal signal = {}; - signal.name = *(godot_string *)&name; + pandemonium_signal signal = {}; + signal.name = *(pandemonium_string *)&name; - godot::nativescript_api->godot_nativescript_register_signal(godot::_RegisterState::nativescript_handle, + godot::nativescript_api->pandemonium_nativescript_register_signal(godot::_RegisterState::nativescript_handle, T::___get_class_name(), &signal); } @@ -590,7 +590,7 @@ T *Object::cast_to(const Object *obj) { return nullptr; if (T::___CLASS_IS_SCRIPT) { - size_t have_tag = (size_t)godot::nativescript_1_1_api->godot_nativescript_get_type_tag(obj->_owner); + size_t have_tag = (size_t)godot::nativescript_1_1_api->pandemonium_nativescript_get_type_tag(obj->_owner); if (have_tag) { if (!godot::_TagDB::is_type_known((size_t)have_tag)) { have_tag = 0; @@ -605,7 +605,7 @@ T *Object::cast_to(const Object *obj) { return detail::get_custom_class_instance(obj); } } else { - if (godot::core_1_2_api->godot_object_cast_to(obj->_owner, (void *)T::___get_id())) { + if (godot::core_1_2_api->pandemonium_object_cast_to(obj->_owner, (void *)T::___get_id())) { return (T *)obj; } } diff --git a/include/core/GodotGlobal.hpp b/include/core/GodotGlobal.hpp index 847bf32..afc02e4 100644 --- a/include/core/GodotGlobal.hpp +++ b/include/core/GodotGlobal.hpp @@ -37,18 +37,18 @@ namespace godot { -extern "C" const godot_gdnative_core_api_struct *api; -extern "C" const godot_gdnative_core_1_1_api_struct *core_1_1_api; -extern "C" const godot_gdnative_core_1_2_api_struct *core_1_2_api; +extern "C" const pandemonium_gdnative_core_api_struct *api; +extern "C" const pandemonium_gdnative_core_1_1_api_struct *core_1_1_api; +extern "C" const pandemonium_gdnative_core_1_2_api_struct *core_1_2_api; -extern "C" const godot_gdnative_ext_nativescript_api_struct *nativescript_api; -extern "C" const godot_gdnative_ext_nativescript_1_1_api_struct *nativescript_1_1_api; -extern "C" const godot_gdnative_ext_pluginscript_api_struct *pluginscript_api; -extern "C" const godot_gdnative_ext_android_api_struct *android_api; -extern "C" const godot_gdnative_ext_arvr_api_struct *arvr_api; -extern "C" const godot_gdnative_ext_videodecoder_api_struct *videodecoder_api; -extern "C" const godot_gdnative_ext_net_api_struct *net_api; -extern "C" const godot_gdnative_ext_net_3_2_api_struct *net_3_2_api; +extern "C" const pandemonium_gdnative_ext_nativescript_api_struct *nativescript_api; +extern "C" const pandemonium_gdnative_ext_nativescript_1_1_api_struct *nativescript_1_1_api; +extern "C" const pandemonium_gdnative_ext_pluginscript_api_struct *pluginscript_api; +extern "C" const pandemonium_gdnative_ext_android_api_struct *android_api; +extern "C" const pandemonium_gdnative_ext_arvr_api_struct *arvr_api; +extern "C" const pandemonium_gdnative_ext_videodecoder_api_struct *videodecoder_api; +extern "C" const pandemonium_gdnative_ext_net_api_struct *net_api; +extern "C" const pandemonium_gdnative_ext_net_3_2_api_struct *net_3_2_api; extern "C" const void *gdnlib; @@ -58,8 +58,8 @@ public: static void print_warning(const String &description, const String &function, const String &file, int line); static void print_error(const String &description, const String &function, const String &file, int line); - static void gdnative_init(godot_gdnative_init_options *o); - static void gdnative_terminate(godot_gdnative_terminate_options *o); + static void gdnative_init(pandemonium_gdnative_init_options *o); + static void gdnative_terminate(pandemonium_gdnative_terminate_options *o); static void nativescript_init(void *handle); static void nativescript_terminate(void *handle); diff --git a/include/core/NodePath.hpp b/include/core/NodePath.hpp index 9f11827..db1bab4 100644 --- a/include/core/NodePath.hpp +++ b/include/core/NodePath.hpp @@ -38,10 +38,10 @@ namespace godot { class NodePath { - godot_node_path _node_path; + pandemonium_node_path _node_path; friend class Variant; - inline explicit NodePath(godot_node_path node_path) { + inline explicit NodePath(pandemonium_node_path node_path) { _node_path = node_path; } diff --git a/include/core/PoolArrays.hpp b/include/core/PoolArrays.hpp index f0620f6..8be30a3 100644 --- a/include/core/PoolArrays.hpp +++ b/include/core/PoolArrays.hpp @@ -46,18 +46,18 @@ namespace godot { class Array; class PoolByteArray { - godot_pool_byte_array _godot_array; + pandemonium_pool_byte_array _pandemonium_array; friend class String; friend class Variant; - inline explicit PoolByteArray(godot_pool_byte_array a) { - _godot_array = a; + inline explicit PoolByteArray(pandemonium_pool_byte_array a) { + _pandemonium_array = a; } public: class Read { friend class PoolByteArray; - godot_pool_byte_array_read_access *_read_access; + pandemonium_pool_byte_array_read_access *_read_access; public: inline Read() { @@ -65,15 +65,15 @@ public: } inline Read(const Read &p_other) { - _read_access = godot::api->godot_pool_byte_array_read_access_copy(p_other._read_access); + _read_access = godot::api->pandemonium_pool_byte_array_read_access_copy(p_other._read_access); } inline ~Read() { - godot::api->godot_pool_byte_array_read_access_destroy(_read_access); + godot::api->pandemonium_pool_byte_array_read_access_destroy(_read_access); } inline const uint8_t *ptr() const { - return godot::api->godot_pool_byte_array_read_access_ptr(_read_access); + return godot::api->pandemonium_pool_byte_array_read_access_ptr(_read_access); } inline const uint8_t &operator[](int p_idx) const { @@ -81,13 +81,13 @@ public: } inline void operator=(const Read &p_other) { - godot::api->godot_pool_byte_array_read_access_operator_assign(_read_access, p_other._read_access); + godot::api->pandemonium_pool_byte_array_read_access_operator_assign(_read_access, p_other._read_access); } }; class Write { friend class PoolByteArray; - godot_pool_byte_array_write_access *_write_access; + pandemonium_pool_byte_array_write_access *_write_access; public: inline Write() { @@ -95,15 +95,15 @@ public: } inline Write(const Write &p_other) { - _write_access = godot::api->godot_pool_byte_array_write_access_copy(p_other._write_access); + _write_access = godot::api->pandemonium_pool_byte_array_write_access_copy(p_other._write_access); } inline ~Write() { - godot::api->godot_pool_byte_array_write_access_destroy(_write_access); + godot::api->pandemonium_pool_byte_array_write_access_destroy(_write_access); } inline uint8_t *ptr() const { - return godot::api->godot_pool_byte_array_write_access_ptr(_write_access); + return godot::api->pandemonium_pool_byte_array_write_access_ptr(_write_access); } inline uint8_t &operator[](int p_idx) const { @@ -111,7 +111,7 @@ public: } inline void operator=(const Write &p_other) { - godot::api->godot_pool_byte_array_write_access_operator_assign(_write_access, p_other._write_access); + godot::api->pandemonium_pool_byte_array_write_access_operator_assign(_write_access, p_other._write_access); } }; @@ -149,17 +149,17 @@ public: }; class PoolIntArray { - godot_pool_int_array _godot_array; + pandemonium_pool_int_array _pandemonium_array; friend class Variant; - explicit inline PoolIntArray(godot_pool_int_array a) { - _godot_array = a; + explicit inline PoolIntArray(pandemonium_pool_int_array a) { + _pandemonium_array = a; } public: class Read { friend class PoolIntArray; - godot_pool_int_array_read_access *_read_access; + pandemonium_pool_int_array_read_access *_read_access; public: inline Read() { @@ -167,15 +167,15 @@ public: } inline Read(const Read &p_other) { - _read_access = godot::api->godot_pool_int_array_read_access_copy(p_other._read_access); + _read_access = godot::api->pandemonium_pool_int_array_read_access_copy(p_other._read_access); } inline ~Read() { - godot::api->godot_pool_int_array_read_access_destroy(_read_access); + godot::api->pandemonium_pool_int_array_read_access_destroy(_read_access); } inline const int *ptr() const { - return godot::api->godot_pool_int_array_read_access_ptr(_read_access); + return godot::api->pandemonium_pool_int_array_read_access_ptr(_read_access); } inline const int &operator[](int p_idx) const { @@ -183,13 +183,13 @@ public: } inline void operator=(const Read &p_other) { - godot::api->godot_pool_int_array_read_access_operator_assign(_read_access, p_other._read_access); + godot::api->pandemonium_pool_int_array_read_access_operator_assign(_read_access, p_other._read_access); } }; class Write { friend class PoolIntArray; - godot_pool_int_array_write_access *_write_access; + pandemonium_pool_int_array_write_access *_write_access; public: inline Write() { @@ -197,15 +197,15 @@ public: } inline Write(const Write &p_other) { - _write_access = godot::api->godot_pool_int_array_write_access_copy(p_other._write_access); + _write_access = godot::api->pandemonium_pool_int_array_write_access_copy(p_other._write_access); } inline ~Write() { - godot::api->godot_pool_int_array_write_access_destroy(_write_access); + godot::api->pandemonium_pool_int_array_write_access_destroy(_write_access); } inline int *ptr() const { - return godot::api->godot_pool_int_array_write_access_ptr(_write_access); + return godot::api->pandemonium_pool_int_array_write_access_ptr(_write_access); } inline int &operator[](int p_idx) const { @@ -213,7 +213,7 @@ public: } inline void operator=(const Write &p_other) { - godot::api->godot_pool_int_array_write_access_operator_assign(_write_access, p_other._write_access); + godot::api->pandemonium_pool_int_array_write_access_operator_assign(_write_access, p_other._write_access); } }; @@ -251,17 +251,17 @@ public: }; class PoolRealArray { - godot_pool_real_array _godot_array; + pandemonium_pool_real_array _pandemonium_array; friend class Variant; - explicit inline PoolRealArray(godot_pool_real_array a) { - _godot_array = a; + explicit inline PoolRealArray(pandemonium_pool_real_array a) { + _pandemonium_array = a; } public: class Read { friend class PoolRealArray; - godot_pool_real_array_read_access *_read_access; + pandemonium_pool_real_array_read_access *_read_access; public: inline Read() { @@ -269,15 +269,15 @@ public: } inline Read(const Read &p_other) { - _read_access = godot::api->godot_pool_real_array_read_access_copy(p_other._read_access); + _read_access = godot::api->pandemonium_pool_real_array_read_access_copy(p_other._read_access); } inline ~Read() { - godot::api->godot_pool_real_array_read_access_destroy(_read_access); + godot::api->pandemonium_pool_real_array_read_access_destroy(_read_access); } inline const real_t *ptr() const { - return godot::api->godot_pool_real_array_read_access_ptr(_read_access); + return godot::api->pandemonium_pool_real_array_read_access_ptr(_read_access); } inline const real_t &operator[](int p_idx) const { @@ -285,13 +285,13 @@ public: } inline void operator=(const Read &p_other) { - godot::api->godot_pool_real_array_read_access_operator_assign(_read_access, p_other._read_access); + godot::api->pandemonium_pool_real_array_read_access_operator_assign(_read_access, p_other._read_access); } }; class Write { friend class PoolRealArray; - godot_pool_real_array_write_access *_write_access; + pandemonium_pool_real_array_write_access *_write_access; public: inline Write() { @@ -299,15 +299,15 @@ public: } inline Write(const Write &p_other) { - _write_access = godot::api->godot_pool_real_array_write_access_copy(p_other._write_access); + _write_access = godot::api->pandemonium_pool_real_array_write_access_copy(p_other._write_access); } inline ~Write() { - godot::api->godot_pool_real_array_write_access_destroy(_write_access); + godot::api->pandemonium_pool_real_array_write_access_destroy(_write_access); } inline real_t *ptr() const { - return godot::api->godot_pool_real_array_write_access_ptr(_write_access); + return godot::api->pandemonium_pool_real_array_write_access_ptr(_write_access); } inline real_t &operator[](int p_idx) const { @@ -315,7 +315,7 @@ public: } inline void operator=(const Write &p_other) { - godot::api->godot_pool_real_array_write_access_operator_assign(_write_access, p_other._write_access); + godot::api->pandemonium_pool_real_array_write_access_operator_assign(_write_access, p_other._write_access); } }; @@ -353,18 +353,18 @@ public: }; class PoolStringArray { - godot_pool_string_array _godot_array; + pandemonium_pool_string_array _pandemonium_array; friend class String; friend class Variant; - explicit inline PoolStringArray(godot_pool_string_array a) { - _godot_array = a; + explicit inline PoolStringArray(pandemonium_pool_string_array a) { + _pandemonium_array = a; } public: class Read { friend class PoolStringArray; - godot_pool_string_array_read_access *_read_access; + pandemonium_pool_string_array_read_access *_read_access; public: inline Read() { @@ -372,15 +372,15 @@ public: } inline Read(const Read &p_other) { - _read_access = godot::api->godot_pool_string_array_read_access_copy(p_other._read_access); + _read_access = godot::api->pandemonium_pool_string_array_read_access_copy(p_other._read_access); } inline ~Read() { - godot::api->godot_pool_string_array_read_access_destroy(_read_access); + godot::api->pandemonium_pool_string_array_read_access_destroy(_read_access); } inline const String *ptr() const { - return (const String *)godot::api->godot_pool_string_array_read_access_ptr(_read_access); + return (const String *)godot::api->pandemonium_pool_string_array_read_access_ptr(_read_access); } inline const String &operator[](int p_idx) const { @@ -388,13 +388,13 @@ public: } inline void operator=(const Read &p_other) { - godot::api->godot_pool_string_array_read_access_operator_assign(_read_access, p_other._read_access); + godot::api->pandemonium_pool_string_array_read_access_operator_assign(_read_access, p_other._read_access); } }; class Write { friend class PoolStringArray; - godot_pool_string_array_write_access *_write_access; + pandemonium_pool_string_array_write_access *_write_access; public: inline Write() { @@ -402,15 +402,15 @@ public: } inline Write(const Write &p_other) { - _write_access = godot::api->godot_pool_string_array_write_access_copy(p_other._write_access); + _write_access = godot::api->pandemonium_pool_string_array_write_access_copy(p_other._write_access); } inline ~Write() { - godot::api->godot_pool_string_array_write_access_destroy(_write_access); + godot::api->pandemonium_pool_string_array_write_access_destroy(_write_access); } inline String *ptr() const { - return (String *)godot::api->godot_pool_string_array_write_access_ptr(_write_access); + return (String *)godot::api->pandemonium_pool_string_array_write_access_ptr(_write_access); } inline String &operator[](int p_idx) const { @@ -418,7 +418,7 @@ public: } inline void operator=(const Write &p_other) { - godot::api->godot_pool_string_array_write_access_operator_assign(_write_access, p_other._write_access); + godot::api->pandemonium_pool_string_array_write_access_operator_assign(_write_access, p_other._write_access); } }; @@ -456,17 +456,17 @@ public: }; class PoolVector2Array { - godot_pool_vector2_array _godot_array; + pandemonium_pool_vector2_array _pandemonium_array; friend class Variant; - explicit inline PoolVector2Array(godot_pool_vector2_array a) { - _godot_array = a; + explicit inline PoolVector2Array(pandemonium_pool_vector2_array a) { + _pandemonium_array = a; } public: class Read { friend class PoolVector2Array; - godot_pool_vector2_array_read_access *_read_access; + pandemonium_pool_vector2_array_read_access *_read_access; public: inline Read() { @@ -474,15 +474,15 @@ public: } inline Read(const Read &p_other) { - _read_access = godot::api->godot_pool_vector2_array_read_access_copy(p_other._read_access); + _read_access = godot::api->pandemonium_pool_vector2_array_read_access_copy(p_other._read_access); } inline ~Read() { - godot::api->godot_pool_vector2_array_read_access_destroy(_read_access); + godot::api->pandemonium_pool_vector2_array_read_access_destroy(_read_access); } inline const Vector2 *ptr() const { - return (const Vector2 *)godot::api->godot_pool_vector2_array_read_access_ptr(_read_access); + return (const Vector2 *)godot::api->pandemonium_pool_vector2_array_read_access_ptr(_read_access); } inline const Vector2 &operator[](int p_idx) const { @@ -490,13 +490,13 @@ public: } inline void operator=(const Read &p_other) { - godot::api->godot_pool_vector2_array_read_access_operator_assign(_read_access, p_other._read_access); + godot::api->pandemonium_pool_vector2_array_read_access_operator_assign(_read_access, p_other._read_access); } }; class Write { friend class PoolVector2Array; - godot_pool_vector2_array_write_access *_write_access; + pandemonium_pool_vector2_array_write_access *_write_access; public: inline Write() { @@ -504,15 +504,15 @@ public: } inline Write(const Write &p_other) { - _write_access = godot::api->godot_pool_vector2_array_write_access_copy(p_other._write_access); + _write_access = godot::api->pandemonium_pool_vector2_array_write_access_copy(p_other._write_access); } inline ~Write() { - godot::api->godot_pool_vector2_array_write_access_destroy(_write_access); + godot::api->pandemonium_pool_vector2_array_write_access_destroy(_write_access); } inline Vector2 *ptr() const { - return (Vector2 *)godot::api->godot_pool_vector2_array_write_access_ptr(_write_access); + return (Vector2 *)godot::api->pandemonium_pool_vector2_array_write_access_ptr(_write_access); } inline Vector2 &operator[](int p_idx) const { @@ -520,7 +520,7 @@ public: } inline void operator=(const Write &p_other) { - godot::api->godot_pool_vector2_array_write_access_operator_assign(_write_access, p_other._write_access); + godot::api->pandemonium_pool_vector2_array_write_access_operator_assign(_write_access, p_other._write_access); } }; @@ -558,17 +558,17 @@ public: }; class PoolVector3Array { - godot_pool_vector3_array _godot_array; + pandemonium_pool_vector3_array _pandemonium_array; friend class Variant; - explicit inline PoolVector3Array(godot_pool_vector3_array a) { - _godot_array = a; + explicit inline PoolVector3Array(pandemonium_pool_vector3_array a) { + _pandemonium_array = a; } public: class Read { friend class PoolVector3Array; - godot_pool_vector3_array_read_access *_read_access; + pandemonium_pool_vector3_array_read_access *_read_access; public: inline Read() { @@ -576,15 +576,15 @@ public: } inline Read(const Read &p_other) { - _read_access = godot::api->godot_pool_vector3_array_read_access_copy(p_other._read_access); + _read_access = godot::api->pandemonium_pool_vector3_array_read_access_copy(p_other._read_access); } inline ~Read() { - godot::api->godot_pool_vector3_array_read_access_destroy(_read_access); + godot::api->pandemonium_pool_vector3_array_read_access_destroy(_read_access); } inline const Vector3 *ptr() const { - return (const Vector3 *)godot::api->godot_pool_vector3_array_read_access_ptr(_read_access); + return (const Vector3 *)godot::api->pandemonium_pool_vector3_array_read_access_ptr(_read_access); } inline const Vector3 &operator[](int p_idx) const { @@ -592,13 +592,13 @@ public: } inline void operator=(const Read &p_other) { - godot::api->godot_pool_vector3_array_read_access_operator_assign(_read_access, p_other._read_access); + godot::api->pandemonium_pool_vector3_array_read_access_operator_assign(_read_access, p_other._read_access); } }; class Write { friend class PoolVector3Array; - godot_pool_vector3_array_write_access *_write_access; + pandemonium_pool_vector3_array_write_access *_write_access; public: inline Write() { @@ -606,15 +606,15 @@ public: } inline Write(const Write &p_other) { - _write_access = godot::api->godot_pool_vector3_array_write_access_copy(p_other._write_access); + _write_access = godot::api->pandemonium_pool_vector3_array_write_access_copy(p_other._write_access); } inline ~Write() { - godot::api->godot_pool_vector3_array_write_access_destroy(_write_access); + godot::api->pandemonium_pool_vector3_array_write_access_destroy(_write_access); } inline Vector3 *ptr() const { - return (Vector3 *)godot::api->godot_pool_vector3_array_write_access_ptr(_write_access); + return (Vector3 *)godot::api->pandemonium_pool_vector3_array_write_access_ptr(_write_access); } inline Vector3 &operator[](int p_idx) const { @@ -622,7 +622,7 @@ public: } inline void operator=(const Write &p_other) { - godot::api->godot_pool_vector3_array_write_access_operator_assign(_write_access, p_other._write_access); + godot::api->pandemonium_pool_vector3_array_write_access_operator_assign(_write_access, p_other._write_access); } }; @@ -660,17 +660,17 @@ public: }; class PoolColorArray { - godot_pool_color_array _godot_array; + pandemonium_pool_color_array _pandemonium_array; friend class Variant; - explicit inline PoolColorArray(godot_pool_color_array a) { - _godot_array = a; + explicit inline PoolColorArray(pandemonium_pool_color_array a) { + _pandemonium_array = a; } public: class Read { friend class PoolColorArray; - godot_pool_color_array_read_access *_read_access; + pandemonium_pool_color_array_read_access *_read_access; public: inline Read() { @@ -678,15 +678,15 @@ public: } inline Read(const Read &p_other) { - _read_access = godot::api->godot_pool_color_array_read_access_copy(p_other._read_access); + _read_access = godot::api->pandemonium_pool_color_array_read_access_copy(p_other._read_access); } inline ~Read() { - godot::api->godot_pool_color_array_read_access_destroy(_read_access); + godot::api->pandemonium_pool_color_array_read_access_destroy(_read_access); } inline const Color *ptr() const { - return (const Color *)godot::api->godot_pool_color_array_read_access_ptr(_read_access); + return (const Color *)godot::api->pandemonium_pool_color_array_read_access_ptr(_read_access); } inline const Color &operator[](int p_idx) const { @@ -694,13 +694,13 @@ public: } inline void operator=(const Read &p_other) { - godot::api->godot_pool_color_array_read_access_operator_assign(_read_access, p_other._read_access); + godot::api->pandemonium_pool_color_array_read_access_operator_assign(_read_access, p_other._read_access); } }; class Write { friend class PoolColorArray; - godot_pool_color_array_write_access *_write_access; + pandemonium_pool_color_array_write_access *_write_access; public: inline Write() { @@ -708,15 +708,15 @@ public: } inline Write(const Write &p_other) { - _write_access = godot::api->godot_pool_color_array_write_access_copy(p_other._write_access); + _write_access = godot::api->pandemonium_pool_color_array_write_access_copy(p_other._write_access); } inline ~Write() { - godot::api->godot_pool_color_array_write_access_destroy(_write_access); + godot::api->pandemonium_pool_color_array_write_access_destroy(_write_access); } inline Color *ptr() const { - return (Color *)godot::api->godot_pool_color_array_write_access_ptr(_write_access); + return (Color *)godot::api->pandemonium_pool_color_array_write_access_ptr(_write_access); } inline Color &operator[](int p_idx) const { @@ -724,7 +724,7 @@ public: } inline void operator=(const Write &p_other) { - godot::api->godot_pool_color_array_write_access_operator_assign(_write_access, p_other._write_access); + godot::api->pandemonium_pool_color_array_write_access_operator_assign(_write_access, p_other._write_access); } }; diff --git a/include/core/RID.hpp b/include/core/RID.hpp index 6cf7857..254a66b 100644 --- a/include/core/RID.hpp +++ b/include/core/RID.hpp @@ -38,14 +38,14 @@ namespace godot { class Object; class RID { - godot_rid _godot_rid; + pandemonium_rid _pandemonium_rid; public: RID(); RID(Object *p); - godot_rid _get_godot_rid() const; + pandemonium_rid _get_pandemonium_rid() const; int32_t get_id() const; diff --git a/include/core/String.hpp b/include/core/String.hpp index c8b4058..df23035 100644 --- a/include/core/String.hpp +++ b/include/core/String.hpp @@ -46,7 +46,7 @@ class String; class CharString { friend class String; - godot_char_string _char_string; + pandemonium_char_string _char_string; public: ~CharString(); @@ -56,13 +56,13 @@ public: }; class String { - godot_string _godot_string; + pandemonium_string _pandemonium_string; friend class Dictionary; friend class NodePath; friend class Variant; - explicit inline String(godot_string contents) : - _godot_string(contents) {} + explicit inline String(pandemonium_string contents) : + _pandemonium_string(contents) {} public: String(); @@ -78,7 +78,7 @@ public: static String num_scientific(double p_num); static String num_real(double p_num); static String num_int64(int64_t p_num, int base = 10, bool capitalize_hex = false); - static String chr(godot_char_type p_char); + static String chr(pandemonium_char_type p_char); static String md5(const uint8_t *p_md5); static String hex_encode_buffer(const uint8_t *p_buffer, int p_len); diff --git a/include/core/Variant.hpp b/include/core/Variant.hpp index 31b0469..60dd63d 100644 --- a/include/core/Variant.hpp +++ b/include/core/Variant.hpp @@ -57,11 +57,11 @@ class Dictionary; class Array; class Variant { - godot_variant _godot_variant; + pandemonium_variant _pandemonium_variant; friend class Array; - inline explicit Variant(godot_variant v) { - _godot_variant = v; + inline explicit Variant(pandemonium_variant v) { + _pandemonium_variant = v; } public: @@ -258,7 +258,7 @@ public: operator NodePath() const; operator RID() const; - operator godot_object *() const; + operator pandemonium_object *() const; template operator T *() const { return static_cast(T::___get_from_variant(*this)); } diff --git a/include/core/Wrapped.hpp b/include/core/Wrapped.hpp index 8335d29..49a579a 100644 --- a/include/core/Wrapped.hpp +++ b/include/core/Wrapped.hpp @@ -38,7 +38,7 @@ namespace godot { // This is an internal base class used by the bindings. You should not need to access its members. class _Wrapped { public: - godot_object *_owner; + pandemonium_object *_owner; size_t _type_tag; }; diff --git a/src/core/Array.cpp b/src/core/Array.cpp index 72663c9..4b5b7a4 100644 --- a/src/core/Array.cpp +++ b/src/core/Array.cpp @@ -39,49 +39,49 @@ namespace godot { class Object; Array::Array() { - godot::api->godot_array_new(&_godot_array); + godot::api->pandemonium_array_new(&_pandemonium_array); } Array::Array(const Array &other) { - godot::api->godot_array_new_copy(&_godot_array, &other._godot_array); + godot::api->pandemonium_array_new_copy(&_pandemonium_array, &other._pandemonium_array); } Array &Array::operator=(const Array &other) { - godot::api->godot_array_destroy(&_godot_array); - godot::api->godot_array_new_copy(&_godot_array, &other._godot_array); + godot::api->pandemonium_array_destroy(&_pandemonium_array); + godot::api->pandemonium_array_new_copy(&_pandemonium_array, &other._pandemonium_array); return *this; } Array::Array(const PoolByteArray &a) { - godot::api->godot_array_new_pool_byte_array(&_godot_array, (godot_pool_byte_array *)&a); + godot::api->pandemonium_array_new_pool_byte_array(&_pandemonium_array, (pandemonium_pool_byte_array *)&a); } Array::Array(const PoolIntArray &a) { - godot::api->godot_array_new_pool_int_array(&_godot_array, (godot_pool_int_array *)&a); + godot::api->pandemonium_array_new_pool_int_array(&_pandemonium_array, (pandemonium_pool_int_array *)&a); } Array::Array(const PoolRealArray &a) { - godot::api->godot_array_new_pool_real_array(&_godot_array, (godot_pool_real_array *)&a); + godot::api->pandemonium_array_new_pool_real_array(&_pandemonium_array, (pandemonium_pool_real_array *)&a); } Array::Array(const PoolStringArray &a) { - godot::api->godot_array_new_pool_string_array(&_godot_array, (godot_pool_string_array *)&a); + godot::api->pandemonium_array_new_pool_string_array(&_pandemonium_array, (pandemonium_pool_string_array *)&a); } Array::Array(const PoolVector2Array &a) { - godot::api->godot_array_new_pool_vector2_array(&_godot_array, (godot_pool_vector2_array *)&a); + godot::api->pandemonium_array_new_pool_vector2_array(&_pandemonium_array, (pandemonium_pool_vector2_array *)&a); } Array::Array(const PoolVector3Array &a) { - godot::api->godot_array_new_pool_vector3_array(&_godot_array, (godot_pool_vector3_array *)&a); + godot::api->pandemonium_array_new_pool_vector3_array(&_pandemonium_array, (pandemonium_pool_vector3_array *)&a); } Array::Array(const PoolColorArray &a) { - godot::api->godot_array_new_pool_color_array(&_godot_array, (godot_pool_color_array *)&a); + godot::api->pandemonium_array_new_pool_color_array(&_pandemonium_array, (pandemonium_pool_color_array *)&a); } Variant &Array::operator[](const int idx) { - godot_variant *v = godot::api->godot_array_operator_index(&_godot_array, idx); + pandemonium_variant *v = godot::api->pandemonium_array_operator_index(&_pandemonium_array, idx); // We assume it's ok to reinterpret because the value is a pointer whose data is already owned by the array, // so can return a reference without constructing a Variant return *reinterpret_cast(v); @@ -90,137 +90,137 @@ Variant &Array::operator[](const int idx) { const Variant &Array::operator[](const int idx) const { // Yes, I'm casting away the const... you can hate me now. // since the result is - godot_variant *v = godot::api->godot_array_operator_index((godot_array *)&_godot_array, idx); + pandemonium_variant *v = godot::api->pandemonium_array_operator_index((pandemonium_array *)&_pandemonium_array, idx); return *reinterpret_cast(v); } void Array::append(const Variant &v) { - godot::api->godot_array_append(&_godot_array, (godot_variant *)&v); + godot::api->pandemonium_array_append(&_pandemonium_array, (pandemonium_variant *)&v); } void Array::clear() { - godot::api->godot_array_clear(&_godot_array); + godot::api->pandemonium_array_clear(&_pandemonium_array); } int Array::count(const Variant &v) { - return godot::api->godot_array_count(&_godot_array, (godot_variant *)&v); + return godot::api->pandemonium_array_count(&_pandemonium_array, (pandemonium_variant *)&v); } bool Array::empty() const { - return godot::api->godot_array_empty(&_godot_array); + return godot::api->pandemonium_array_empty(&_pandemonium_array); } void Array::erase(const Variant &v) { - godot::api->godot_array_erase(&_godot_array, (godot_variant *)&v); + godot::api->pandemonium_array_erase(&_pandemonium_array, (pandemonium_variant *)&v); } Variant Array::front() const { - godot_variant v = godot::api->godot_array_front(&_godot_array); + pandemonium_variant v = godot::api->pandemonium_array_front(&_pandemonium_array); return Variant(v); } Variant Array::back() const { - godot_variant v = godot::api->godot_array_back(&_godot_array); + pandemonium_variant v = godot::api->pandemonium_array_back(&_pandemonium_array); return Variant(v); } int Array::find(const Variant &what, const int from) const { - return godot::api->godot_array_find(&_godot_array, (godot_variant *)&what, from); + return godot::api->pandemonium_array_find(&_pandemonium_array, (pandemonium_variant *)&what, from); } int Array::find_last(const Variant &what) const { - return godot::api->godot_array_find_last(&_godot_array, (godot_variant *)&what); + return godot::api->pandemonium_array_find_last(&_pandemonium_array, (pandemonium_variant *)&what); } bool Array::has(const Variant &what) const { - return godot::api->godot_array_has(&_godot_array, (godot_variant *)&what); + return godot::api->pandemonium_array_has(&_pandemonium_array, (pandemonium_variant *)&what); } uint32_t Array::hash() const { - return godot::api->godot_array_hash(&_godot_array); + return godot::api->pandemonium_array_hash(&_pandemonium_array); } void Array::insert(const int pos, const Variant &value) { - godot::api->godot_array_insert(&_godot_array, pos, (godot_variant *)&value); + godot::api->pandemonium_array_insert(&_pandemonium_array, pos, (pandemonium_variant *)&value); } void Array::invert() { - godot::api->godot_array_invert(&_godot_array); + godot::api->pandemonium_array_invert(&_pandemonium_array); } Variant Array::pop_back() { - godot_variant v = godot::api->godot_array_pop_back(&_godot_array); + pandemonium_variant v = godot::api->pandemonium_array_pop_back(&_pandemonium_array); return Variant(v); } Variant Array::pop_front() { - godot_variant v = godot::api->godot_array_pop_front(&_godot_array); + pandemonium_variant v = godot::api->pandemonium_array_pop_front(&_pandemonium_array); return Variant(v); } void Array::push_back(const Variant &v) { - godot::api->godot_array_push_back(&_godot_array, (godot_variant *)&v); + godot::api->pandemonium_array_push_back(&_pandemonium_array, (pandemonium_variant *)&v); } void Array::push_front(const Variant &v) { - godot::api->godot_array_push_front(&_godot_array, (godot_variant *)&v); + godot::api->pandemonium_array_push_front(&_pandemonium_array, (pandemonium_variant *)&v); } void Array::remove(const int idx) { - godot::api->godot_array_remove(&_godot_array, idx); + godot::api->pandemonium_array_remove(&_pandemonium_array, idx); } int Array::size() const { - return godot::api->godot_array_size(&_godot_array); + return godot::api->pandemonium_array_size(&_pandemonium_array); } void Array::resize(const int size) { - godot::api->godot_array_resize(&_godot_array, size); + godot::api->pandemonium_array_resize(&_pandemonium_array, size); } int Array::rfind(const Variant &what, const int from) const { - return godot::api->godot_array_rfind(&_godot_array, (godot_variant *)&what, from); + return godot::api->pandemonium_array_rfind(&_pandemonium_array, (pandemonium_variant *)&what, from); } void Array::sort() { - godot::api->godot_array_sort(&_godot_array); + godot::api->pandemonium_array_sort(&_pandemonium_array); } void Array::sort_custom(Object *obj, const String &func) { - godot::api->godot_array_sort_custom(&_godot_array, (godot_object *)obj, (godot_string *)&func); + godot::api->pandemonium_array_sort_custom(&_pandemonium_array, (pandemonium_object *)obj, (pandemonium_string *)&func); } int Array::bsearch(const Variant &value, const bool before) { - return godot::api->godot_array_bsearch(&_godot_array, (godot_variant *)&value, before); + return godot::api->pandemonium_array_bsearch(&_pandemonium_array, (pandemonium_variant *)&value, before); } int Array::bsearch_custom(const Variant &value, const Object *obj, const String &func, const bool before) { - return godot::api->godot_array_bsearch_custom(&_godot_array, (godot_variant *)&value, - (godot_object *)obj, (godot_string *)&func, before); + return godot::api->pandemonium_array_bsearch_custom(&_pandemonium_array, (pandemonium_variant *)&value, + (pandemonium_object *)obj, (pandemonium_string *)&func, before); } Array Array::duplicate(const bool deep) const { - godot_array arr = godot::core_1_1_api->godot_array_duplicate(&_godot_array, deep); + pandemonium_array arr = godot::core_1_1_api->pandemonium_array_duplicate(&_pandemonium_array, deep); return Array(arr); } Variant Array::max() const { - godot_variant v = godot::core_1_1_api->godot_array_max(&_godot_array); + pandemonium_variant v = godot::core_1_1_api->pandemonium_array_max(&_pandemonium_array); return Variant(v); } Variant Array::min() const { - godot_variant v = godot::core_1_1_api->godot_array_min(&_godot_array); + pandemonium_variant v = godot::core_1_1_api->pandemonium_array_min(&_pandemonium_array); return Variant(v); } void Array::shuffle() { - godot::core_1_1_api->godot_array_shuffle(&_godot_array); + godot::core_1_1_api->pandemonium_array_shuffle(&_pandemonium_array); } Array::~Array() { - godot::api->godot_array_destroy(&_godot_array); + godot::api->pandemonium_array_destroy(&_pandemonium_array); } } // namespace godot diff --git a/src/core/Dictionary.cpp b/src/core/Dictionary.cpp index 95e89fb..83f517c 100644 --- a/src/core/Dictionary.cpp +++ b/src/core/Dictionary.cpp @@ -36,75 +36,75 @@ namespace godot { Dictionary::Dictionary() { - godot::api->godot_dictionary_new(&_godot_dictionary); + godot::api->pandemonium_dictionary_new(&_pandemonium_dictionary); } Dictionary::Dictionary(const Dictionary &other) { - godot::api->godot_dictionary_new_copy(&_godot_dictionary, &other._godot_dictionary); + godot::api->pandemonium_dictionary_new_copy(&_pandemonium_dictionary, &other._pandemonium_dictionary); } Dictionary &Dictionary::operator=(const Dictionary &other) { - godot::api->godot_dictionary_destroy(&_godot_dictionary); - godot::api->godot_dictionary_new_copy(&_godot_dictionary, &other._godot_dictionary); + godot::api->pandemonium_dictionary_destroy(&_pandemonium_dictionary); + godot::api->pandemonium_dictionary_new_copy(&_pandemonium_dictionary, &other._pandemonium_dictionary); return *this; } void Dictionary::clear() { - godot::api->godot_dictionary_clear(&_godot_dictionary); + godot::api->pandemonium_dictionary_clear(&_pandemonium_dictionary); } bool Dictionary::empty() const { - return godot::api->godot_dictionary_empty(&_godot_dictionary); + return godot::api->pandemonium_dictionary_empty(&_pandemonium_dictionary); } void Dictionary::erase(const Variant &key) { - godot::api->godot_dictionary_erase(&_godot_dictionary, (godot_variant *)&key); + godot::api->pandemonium_dictionary_erase(&_pandemonium_dictionary, (pandemonium_variant *)&key); } bool Dictionary::has(const Variant &key) const { - return godot::api->godot_dictionary_has(&_godot_dictionary, (godot_variant *)&key); + return godot::api->pandemonium_dictionary_has(&_pandemonium_dictionary, (pandemonium_variant *)&key); } bool Dictionary::has_all(const Array &keys) const { - return godot::api->godot_dictionary_has_all(&_godot_dictionary, (godot_array *)&keys); + return godot::api->pandemonium_dictionary_has_all(&_pandemonium_dictionary, (pandemonium_array *)&keys); } uint32_t Dictionary::hash() const { - return godot::api->godot_dictionary_hash(&_godot_dictionary); + return godot::api->pandemonium_dictionary_hash(&_pandemonium_dictionary); } Array Dictionary::keys() const { - godot_array a = godot::api->godot_dictionary_keys(&_godot_dictionary); + pandemonium_array a = godot::api->pandemonium_dictionary_keys(&_pandemonium_dictionary); return Array(a); } Variant &Dictionary::operator[](const Variant &key) { - godot_variant *v = godot::api->godot_dictionary_operator_index(&_godot_dictionary, (godot_variant *)&key); + pandemonium_variant *v = godot::api->pandemonium_dictionary_operator_index(&_pandemonium_dictionary, (pandemonium_variant *)&key); return *reinterpret_cast(v); } const Variant &Dictionary::operator[](const Variant &key) const { // oops I did it again - godot_variant *v = godot::api->godot_dictionary_operator_index((godot_dictionary *)&_godot_dictionary, (godot_variant *)&key); + pandemonium_variant *v = godot::api->pandemonium_dictionary_operator_index((pandemonium_dictionary *)&_pandemonium_dictionary, (pandemonium_variant *)&key); return *reinterpret_cast(v); } int Dictionary::size() const { - return godot::api->godot_dictionary_size(&_godot_dictionary); + return godot::api->pandemonium_dictionary_size(&_pandemonium_dictionary); } String Dictionary::to_json() const { - godot_string s = godot::api->godot_dictionary_to_json(&_godot_dictionary); + pandemonium_string s = godot::api->pandemonium_dictionary_to_json(&_pandemonium_dictionary); return String(s); } Array Dictionary::values() const { - godot_array a = godot::api->godot_dictionary_values(&_godot_dictionary); + pandemonium_array a = godot::api->pandemonium_dictionary_values(&_pandemonium_dictionary); return Array(a); } Dictionary::~Dictionary() { - godot::api->godot_dictionary_destroy(&_godot_dictionary); + godot::api->pandemonium_dictionary_destroy(&_pandemonium_dictionary); } } // namespace godot diff --git a/src/core/GodotGlobal.cpp b/src/core/GodotGlobal.cpp index 511ed75..92ca1e4 100644 --- a/src/core/GodotGlobal.cpp +++ b/src/core/GodotGlobal.cpp @@ -34,8 +34,8 @@ #include "Wrapped.hpp" -static GDCALLINGCONV void *wrapper_create(void *data, const void *type_tag, godot_object *instance) { - godot::_Wrapped *wrapper_memory = (godot::_Wrapped *)godot::api->godot_alloc(sizeof(godot::_Wrapped)); +static GDCALLINGCONV void *wrapper_create(void *data, const void *type_tag, pandemonium_object *instance) { + godot::_Wrapped *wrapper_memory = (godot::_Wrapped *)godot::api->pandemonium_alloc(sizeof(godot::_Wrapped)); if (!wrapper_memory) return NULL; @@ -47,7 +47,7 @@ static GDCALLINGCONV void *wrapper_create(void *data, const void *type_tag, godo static GDCALLINGCONV void wrapper_destroy(void *data, void *wrapper) { if (wrapper) - godot::api->godot_free(wrapper); + godot::api->pandemonium_free(wrapper); } namespace godot { @@ -55,23 +55,23 @@ namespace godot { void *_RegisterState::nativescript_handle; int _RegisterState::language_index; -const godot_gdnative_core_api_struct *api = nullptr; -const godot_gdnative_core_1_1_api_struct *core_1_1_api = nullptr; -const godot_gdnative_core_1_2_api_struct *core_1_2_api = nullptr; +const pandemonium_gdnative_core_api_struct *api = nullptr; +const pandemonium_gdnative_core_1_1_api_struct *core_1_1_api = nullptr; +const pandemonium_gdnative_core_1_2_api_struct *core_1_2_api = nullptr; -const godot_gdnative_ext_nativescript_api_struct *nativescript_api = nullptr; -const godot_gdnative_ext_nativescript_1_1_api_struct *nativescript_1_1_api = nullptr; -const godot_gdnative_ext_pluginscript_api_struct *pluginscript_api = nullptr; -const godot_gdnative_ext_android_api_struct *android_api = nullptr; -const godot_gdnative_ext_arvr_api_struct *arvr_api = nullptr; -const godot_gdnative_ext_videodecoder_api_struct *videodecoder_api = nullptr; -const godot_gdnative_ext_net_api_struct *net_api = nullptr; -const godot_gdnative_ext_net_3_2_api_struct *net_3_2_api = nullptr; +const pandemonium_gdnative_ext_nativescript_api_struct *nativescript_api = nullptr; +const pandemonium_gdnative_ext_nativescript_1_1_api_struct *nativescript_1_1_api = nullptr; +const pandemonium_gdnative_ext_pluginscript_api_struct *pluginscript_api = nullptr; +const pandemonium_gdnative_ext_android_api_struct *android_api = nullptr; +const pandemonium_gdnative_ext_arvr_api_struct *arvr_api = nullptr; +const pandemonium_gdnative_ext_videodecoder_api_struct *videodecoder_api = nullptr; +const pandemonium_gdnative_ext_net_api_struct *net_api = nullptr; +const pandemonium_gdnative_ext_net_3_2_api_struct *net_3_2_api = nullptr; const void *gdnlib = NULL; void Godot::print(const String &message) { - godot::api->godot_print((godot_string *)&message); + godot::api->pandemonium_print((pandemonium_string *)&message); } void Godot::print_warning(const String &description, const String &function, const String &file, int line) { @@ -82,15 +82,15 @@ void Godot::print_warning(const String &description, const String &function, con char *c_file = file.alloc_c_string(); if (c_desc != nullptr && c_func != nullptr && c_file != nullptr) { - godot::api->godot_print_warning(c_desc, c_func, c_file, line); + godot::api->pandemonium_print_warning(c_desc, c_func, c_file, line); }; if (c_desc != nullptr) - godot::api->godot_free(c_desc); + godot::api->pandemonium_free(c_desc); if (c_func != nullptr) - godot::api->godot_free(c_func); + godot::api->pandemonium_free(c_func); if (c_file != nullptr) - godot::api->godot_free(c_file); + godot::api->pandemonium_free(c_file); } void Godot::print_error(const String &description, const String &function, const String &file, int line) { @@ -101,31 +101,31 @@ void Godot::print_error(const String &description, const String &function, const char *c_file = file.alloc_c_string(); if (c_desc != nullptr && c_func != nullptr && c_file != nullptr) { - godot::api->godot_print_error(c_desc, c_func, c_file, line); + godot::api->pandemonium_print_error(c_desc, c_func, c_file, line); }; if (c_desc != nullptr) - godot::api->godot_free(c_desc); + godot::api->pandemonium_free(c_desc); if (c_func != nullptr) - godot::api->godot_free(c_func); + godot::api->pandemonium_free(c_func); if (c_file != nullptr) - godot::api->godot_free(c_file); + godot::api->pandemonium_free(c_file); } void ___register_types(); void ___init_method_bindings(); -void Godot::gdnative_init(godot_gdnative_init_options *options) { +void Godot::gdnative_init(pandemonium_gdnative_init_options *options) { godot::api = options->api_struct; godot::gdnlib = options->gd_native_library; - const godot_gdnative_api_struct *core_extension = godot::api->next; + const pandemonium_gdnative_api_struct *core_extension = godot::api->next; while (core_extension) { if (core_extension->version.major == 1 && core_extension->version.minor == 1) { - godot::core_1_1_api = (const godot_gdnative_core_1_1_api_struct *)core_extension; + godot::core_1_1_api = (const pandemonium_gdnative_core_1_1_api_struct *)core_extension; } else if (core_extension->version.major == 1 && core_extension->version.minor == 2) { - godot::core_1_2_api = (const godot_gdnative_core_1_2_api_struct *)core_extension; + godot::core_1_2_api = (const pandemonium_gdnative_core_1_2_api_struct *)core_extension; } core_extension = core_extension->next; } @@ -134,38 +134,38 @@ void Godot::gdnative_init(godot_gdnative_init_options *options) { for (int i = 0; i < godot::api->num_extensions; i++) { switch (godot::api->extensions[i]->type) { case GDNATIVE_EXT_NATIVESCRIPT: { - godot::nativescript_api = (const godot_gdnative_ext_nativescript_api_struct *)godot::api->extensions[i]; + godot::nativescript_api = (const pandemonium_gdnative_ext_nativescript_api_struct *)godot::api->extensions[i]; - const godot_gdnative_api_struct *extension = godot::nativescript_api->next; + const pandemonium_gdnative_api_struct *extension = godot::nativescript_api->next; while (extension) { if (extension->version.major == 1 && extension->version.minor == 1) { - godot::nativescript_1_1_api = (const godot_gdnative_ext_nativescript_1_1_api_struct *)extension; + godot::nativescript_1_1_api = (const pandemonium_gdnative_ext_nativescript_1_1_api_struct *)extension; } extension = extension->next; } } break; case GDNATIVE_EXT_PLUGINSCRIPT: { - godot::pluginscript_api = (const godot_gdnative_ext_pluginscript_api_struct *)godot::api->extensions[i]; + godot::pluginscript_api = (const pandemonium_gdnative_ext_pluginscript_api_struct *)godot::api->extensions[i]; } break; case GDNATIVE_EXT_ANDROID: { - godot::android_api = (const godot_gdnative_ext_android_api_struct *)godot::api->extensions[i]; + godot::android_api = (const pandemonium_gdnative_ext_android_api_struct *)godot::api->extensions[i]; } break; case GDNATIVE_EXT_ARVR: { - godot::arvr_api = (const godot_gdnative_ext_arvr_api_struct *)godot::api->extensions[i]; + godot::arvr_api = (const pandemonium_gdnative_ext_arvr_api_struct *)godot::api->extensions[i]; } break; case GDNATIVE_EXT_VIDEODECODER: { - godot::videodecoder_api = (const godot_gdnative_ext_videodecoder_api_struct *)godot::api->extensions[i]; + godot::videodecoder_api = (const pandemonium_gdnative_ext_videodecoder_api_struct *)godot::api->extensions[i]; } break; case GDNATIVE_EXT_NET: { - godot::net_api = (const godot_gdnative_ext_net_api_struct *)godot::api->extensions[i]; + godot::net_api = (const pandemonium_gdnative_ext_net_api_struct *)godot::api->extensions[i]; - const godot_gdnative_api_struct *extension = godot::net_api->next; + const pandemonium_gdnative_api_struct *extension = godot::net_api->next; while (extension) { if (extension->version.major == 3 && extension->version.minor == 2) { - godot::net_3_2_api = (const godot_gdnative_ext_net_3_2_api_struct *)extension; + godot::net_3_2_api = (const pandemonium_gdnative_ext_net_3_2_api_struct *)extension; } extension = extension->next; @@ -178,23 +178,23 @@ void Godot::gdnative_init(godot_gdnative_init_options *options) { } // Initialize the `language_index` here since `__register_types()` makes use of it. - godot_instance_binding_functions binding_funcs = {}; + pandemonium_instance_binding_functions binding_funcs = {}; binding_funcs.alloc_instance_binding_data = wrapper_create; binding_funcs.free_instance_binding_data = wrapper_destroy; - godot::_RegisterState::language_index = godot::nativescript_1_1_api->godot_nativescript_register_instance_binding_data_functions(binding_funcs); + godot::_RegisterState::language_index = godot::nativescript_1_1_api->pandemonium_nativescript_register_instance_binding_data_functions(binding_funcs); // register these now ___register_types(); ___init_method_bindings(); } -void Godot::gdnative_terminate(godot_gdnative_terminate_options *options) { +void Godot::gdnative_terminate(pandemonium_gdnative_terminate_options *options) { // reserved for future use. } void Godot::gdnative_profiling_add_data(const char *p_signature, uint64_t p_time) { - godot::nativescript_1_1_api->godot_nativescript_profiling_add_data(p_signature, p_time); + godot::nativescript_1_1_api->pandemonium_nativescript_profiling_add_data(p_signature, p_time); } void Godot::nativescript_init(void *handle) { @@ -202,7 +202,7 @@ void Godot::nativescript_init(void *handle) { } void Godot::nativescript_terminate(void *handle) { - godot::nativescript_1_1_api->godot_nativescript_unregister_instance_binding_data_functions(godot::_RegisterState::language_index); + godot::nativescript_1_1_api->pandemonium_nativescript_unregister_instance_binding_data_functions(godot::_RegisterState::language_index); } } // namespace godot diff --git a/src/core/NodePath.cpp b/src/core/NodePath.cpp index 0b4d04e..ef75bd1 100644 --- a/src/core/NodePath.cpp +++ b/src/core/NodePath.cpp @@ -38,77 +38,77 @@ namespace godot { NodePath::NodePath() { String from = ""; - godot::api->godot_node_path_new(&_node_path, (godot_string *)&from); + godot::api->pandemonium_node_path_new(&_node_path, (pandemonium_string *)&from); } NodePath::NodePath(const NodePath &other) { String from = other; - godot::api->godot_node_path_new(&_node_path, (godot_string *)&from); + godot::api->pandemonium_node_path_new(&_node_path, (pandemonium_string *)&from); } NodePath::NodePath(const String &from) { - godot::api->godot_node_path_new(&_node_path, (godot_string *)&from); + godot::api->pandemonium_node_path_new(&_node_path, (pandemonium_string *)&from); } NodePath::NodePath(const char *contents) { String from = contents; - godot::api->godot_node_path_new(&_node_path, (godot_string *)&from); + godot::api->pandemonium_node_path_new(&_node_path, (pandemonium_string *)&from); } String NodePath::get_name(const int idx) const { - godot_string str = godot::api->godot_node_path_get_name(&_node_path, idx); + pandemonium_string str = godot::api->pandemonium_node_path_get_name(&_node_path, idx); return String(str); } int NodePath::get_name_count() const { - return godot::api->godot_node_path_get_name_count(&_node_path); + return godot::api->pandemonium_node_path_get_name_count(&_node_path); } String NodePath::get_subname(const int idx) const { - godot_string str = godot::api->godot_node_path_get_subname(&_node_path, idx); + pandemonium_string str = godot::api->pandemonium_node_path_get_subname(&_node_path, idx); return String(str); } int NodePath::get_subname_count() const { - return godot::api->godot_node_path_get_subname_count(&_node_path); + return godot::api->pandemonium_node_path_get_subname_count(&_node_path); } bool NodePath::is_absolute() const { - return godot::api->godot_node_path_is_absolute(&_node_path); + return godot::api->pandemonium_node_path_is_absolute(&_node_path); } bool NodePath::is_empty() const { - return godot::api->godot_node_path_is_empty(&_node_path); + return godot::api->pandemonium_node_path_is_empty(&_node_path); } NodePath NodePath::get_as_property_path() const { - godot_node_path path = godot::core_1_1_api->godot_node_path_get_as_property_path(&_node_path); + pandemonium_node_path path = godot::core_1_1_api->pandemonium_node_path_get_as_property_path(&_node_path); return NodePath(path); } String NodePath::get_concatenated_subnames() const { - godot_string str = godot::api->godot_node_path_get_concatenated_subnames(&_node_path); + pandemonium_string str = godot::api->pandemonium_node_path_get_concatenated_subnames(&_node_path); return String(str); } NodePath::operator String() const { - godot_string str = godot::api->godot_node_path_as_string(&_node_path); + pandemonium_string str = godot::api->pandemonium_node_path_as_string(&_node_path); return String(str); } bool NodePath::operator==(const NodePath &other) { - return godot::api->godot_node_path_operator_equal(&_node_path, &other._node_path); + return godot::api->pandemonium_node_path_operator_equal(&_node_path, &other._node_path); } void NodePath::operator=(const NodePath &other) { - godot::api->godot_node_path_destroy(&_node_path); + godot::api->pandemonium_node_path_destroy(&_node_path); String other_string = (String)other; - godot::api->godot_node_path_new(&_node_path, (godot_string *)&other_string); + godot::api->pandemonium_node_path_new(&_node_path, (pandemonium_string *)&other_string); } NodePath::~NodePath() { - godot::api->godot_node_path_destroy(&_node_path); + godot::api->pandemonium_node_path_destroy(&_node_path); } } // namespace godot diff --git a/src/core/PoolArrays.cpp b/src/core/PoolArrays.cpp index 544844f..380f66d 100644 --- a/src/core/PoolArrays.cpp +++ b/src/core/PoolArrays.cpp @@ -41,531 +41,531 @@ namespace godot { PoolByteArray::PoolByteArray() { - godot::api->godot_pool_byte_array_new(&_godot_array); + godot::api->pandemonium_pool_byte_array_new(&_pandemonium_array); } PoolByteArray::PoolByteArray(const PoolByteArray &p_other) { - godot::api->godot_pool_byte_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_byte_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); } PoolByteArray &PoolByteArray::operator=(const PoolByteArray &p_other) { - godot::api->godot_pool_byte_array_destroy(&_godot_array); - godot::api->godot_pool_byte_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_byte_array_destroy(&_pandemonium_array); + godot::api->pandemonium_pool_byte_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); return *this; } PoolByteArray::PoolByteArray(const Array &array) { - godot::api->godot_pool_byte_array_new_with_array(&_godot_array, (godot_array *)&array); + godot::api->pandemonium_pool_byte_array_new_with_array(&_pandemonium_array, (pandemonium_array *)&array); } PoolByteArray::Read PoolByteArray::read() const { Read read; - read._read_access = godot::api->godot_pool_byte_array_read(&_godot_array); + read._read_access = godot::api->pandemonium_pool_byte_array_read(&_pandemonium_array); return read; } PoolByteArray::Write PoolByteArray::write() { Write write; - write._write_access = godot::api->godot_pool_byte_array_write(&_godot_array); + write._write_access = godot::api->pandemonium_pool_byte_array_write(&_pandemonium_array); return write; } void PoolByteArray::append(const uint8_t data) { - godot::api->godot_pool_byte_array_append(&_godot_array, data); + godot::api->pandemonium_pool_byte_array_append(&_pandemonium_array, data); } void PoolByteArray::append_array(const PoolByteArray &array) { - godot::api->godot_pool_byte_array_append_array(&_godot_array, &array._godot_array); + godot::api->pandemonium_pool_byte_array_append_array(&_pandemonium_array, &array._pandemonium_array); } int PoolByteArray::insert(const int idx, const uint8_t data) { - return godot::api->godot_pool_byte_array_insert(&_godot_array, idx, data); + return godot::api->pandemonium_pool_byte_array_insert(&_pandemonium_array, idx, data); } void PoolByteArray::invert() { - godot::api->godot_pool_byte_array_invert(&_godot_array); + godot::api->pandemonium_pool_byte_array_invert(&_pandemonium_array); } void PoolByteArray::push_back(const uint8_t data) { - godot::api->godot_pool_byte_array_push_back(&_godot_array, data); + godot::api->pandemonium_pool_byte_array_push_back(&_pandemonium_array, data); } void PoolByteArray::remove(const int idx) { - godot::api->godot_pool_byte_array_remove(&_godot_array, idx); + godot::api->pandemonium_pool_byte_array_remove(&_pandemonium_array, idx); } void PoolByteArray::resize(const int size) { - godot::api->godot_pool_byte_array_resize(&_godot_array, size); + godot::api->pandemonium_pool_byte_array_resize(&_pandemonium_array, size); } void PoolByteArray::set(const int idx, const uint8_t data) { - godot::api->godot_pool_byte_array_set(&_godot_array, idx, data); + godot::api->pandemonium_pool_byte_array_set(&_pandemonium_array, idx, data); } uint8_t PoolByteArray::operator[](const int idx) { - return godot::api->godot_pool_byte_array_get(&_godot_array, idx); + return godot::api->pandemonium_pool_byte_array_get(&_pandemonium_array, idx); } int PoolByteArray::size() const { - return godot::api->godot_pool_byte_array_size(&_godot_array); + return godot::api->pandemonium_pool_byte_array_size(&_pandemonium_array); } PoolByteArray::~PoolByteArray() { - godot::api->godot_pool_byte_array_destroy(&_godot_array); + godot::api->pandemonium_pool_byte_array_destroy(&_pandemonium_array); } PoolIntArray::PoolIntArray() { - godot::api->godot_pool_int_array_new(&_godot_array); + godot::api->pandemonium_pool_int_array_new(&_pandemonium_array); } PoolIntArray::PoolIntArray(const PoolIntArray &p_other) { - godot::api->godot_pool_int_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_int_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); } PoolIntArray &PoolIntArray::operator=(const PoolIntArray &p_other) { - godot::api->godot_pool_int_array_destroy(&_godot_array); - godot::api->godot_pool_int_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_int_array_destroy(&_pandemonium_array); + godot::api->pandemonium_pool_int_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); return *this; } PoolIntArray::PoolIntArray(const Array &array) { - godot::api->godot_pool_int_array_new_with_array(&_godot_array, (godot_array *)&array); + godot::api->pandemonium_pool_int_array_new_with_array(&_pandemonium_array, (pandemonium_array *)&array); } PoolIntArray::Read PoolIntArray::read() const { Read read; - read._read_access = godot::api->godot_pool_int_array_read(&_godot_array); + read._read_access = godot::api->pandemonium_pool_int_array_read(&_pandemonium_array); return read; } PoolIntArray::Write PoolIntArray::write() { Write write; - write._write_access = godot::api->godot_pool_int_array_write(&_godot_array); + write._write_access = godot::api->pandemonium_pool_int_array_write(&_pandemonium_array); return write; } void PoolIntArray::append(const int data) { - godot::api->godot_pool_int_array_append(&_godot_array, data); + godot::api->pandemonium_pool_int_array_append(&_pandemonium_array, data); } void PoolIntArray::append_array(const PoolIntArray &array) { - godot::api->godot_pool_int_array_append_array(&_godot_array, &array._godot_array); + godot::api->pandemonium_pool_int_array_append_array(&_pandemonium_array, &array._pandemonium_array); } int PoolIntArray::insert(const int idx, const int data) { - return godot::api->godot_pool_int_array_insert(&_godot_array, idx, data); + return godot::api->pandemonium_pool_int_array_insert(&_pandemonium_array, idx, data); } void PoolIntArray::invert() { - godot::api->godot_pool_int_array_invert(&_godot_array); + godot::api->pandemonium_pool_int_array_invert(&_pandemonium_array); } void PoolIntArray::push_back(const int data) { - godot::api->godot_pool_int_array_push_back(&_godot_array, data); + godot::api->pandemonium_pool_int_array_push_back(&_pandemonium_array, data); } void PoolIntArray::remove(const int idx) { - godot::api->godot_pool_int_array_remove(&_godot_array, idx); + godot::api->pandemonium_pool_int_array_remove(&_pandemonium_array, idx); } void PoolIntArray::resize(const int size) { - godot::api->godot_pool_int_array_resize(&_godot_array, size); + godot::api->pandemonium_pool_int_array_resize(&_pandemonium_array, size); } void PoolIntArray::set(const int idx, const int data) { - godot::api->godot_pool_int_array_set(&_godot_array, idx, data); + godot::api->pandemonium_pool_int_array_set(&_pandemonium_array, idx, data); } int PoolIntArray::operator[](const int idx) { - return godot::api->godot_pool_int_array_get(&_godot_array, idx); + return godot::api->pandemonium_pool_int_array_get(&_pandemonium_array, idx); } int PoolIntArray::size() const { - return godot::api->godot_pool_int_array_size(&_godot_array); + return godot::api->pandemonium_pool_int_array_size(&_pandemonium_array); } PoolIntArray::~PoolIntArray() { - godot::api->godot_pool_int_array_destroy(&_godot_array); + godot::api->pandemonium_pool_int_array_destroy(&_pandemonium_array); } PoolRealArray::PoolRealArray() { - godot::api->godot_pool_real_array_new(&_godot_array); + godot::api->pandemonium_pool_real_array_new(&_pandemonium_array); } PoolRealArray::PoolRealArray(const PoolRealArray &p_other) { - godot::api->godot_pool_real_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_real_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); } PoolRealArray &PoolRealArray::operator=(const PoolRealArray &p_other) { - godot::api->godot_pool_real_array_destroy(&_godot_array); - godot::api->godot_pool_real_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_real_array_destroy(&_pandemonium_array); + godot::api->pandemonium_pool_real_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); return *this; } PoolRealArray::Read PoolRealArray::read() const { Read read; - read._read_access = godot::api->godot_pool_real_array_read(&_godot_array); + read._read_access = godot::api->pandemonium_pool_real_array_read(&_pandemonium_array); return read; } PoolRealArray::Write PoolRealArray::write() { Write write; - write._write_access = godot::api->godot_pool_real_array_write(&_godot_array); + write._write_access = godot::api->pandemonium_pool_real_array_write(&_pandemonium_array); return write; } PoolRealArray::PoolRealArray(const Array &array) { - godot::api->godot_pool_real_array_new_with_array(&_godot_array, (godot_array *)&array); + godot::api->pandemonium_pool_real_array_new_with_array(&_pandemonium_array, (pandemonium_array *)&array); } void PoolRealArray::append(const real_t data) { - godot::api->godot_pool_real_array_append(&_godot_array, data); + godot::api->pandemonium_pool_real_array_append(&_pandemonium_array, data); } void PoolRealArray::append_array(const PoolRealArray &array) { - godot::api->godot_pool_real_array_append_array(&_godot_array, &array._godot_array); + godot::api->pandemonium_pool_real_array_append_array(&_pandemonium_array, &array._pandemonium_array); } int PoolRealArray::insert(const int idx, const real_t data) { - return godot::api->godot_pool_real_array_insert(&_godot_array, idx, data); + return godot::api->pandemonium_pool_real_array_insert(&_pandemonium_array, idx, data); } void PoolRealArray::invert() { - godot::api->godot_pool_real_array_invert(&_godot_array); + godot::api->pandemonium_pool_real_array_invert(&_pandemonium_array); } void PoolRealArray::push_back(const real_t data) { - godot::api->godot_pool_real_array_push_back(&_godot_array, data); + godot::api->pandemonium_pool_real_array_push_back(&_pandemonium_array, data); } void PoolRealArray::remove(const int idx) { - godot::api->godot_pool_real_array_remove(&_godot_array, idx); + godot::api->pandemonium_pool_real_array_remove(&_pandemonium_array, idx); } void PoolRealArray::resize(const int size) { - godot::api->godot_pool_real_array_resize(&_godot_array, size); + godot::api->pandemonium_pool_real_array_resize(&_pandemonium_array, size); } void PoolRealArray::set(const int idx, const real_t data) { - godot::api->godot_pool_real_array_set(&_godot_array, idx, data); + godot::api->pandemonium_pool_real_array_set(&_pandemonium_array, idx, data); } real_t PoolRealArray::operator[](const int idx) { - return godot::api->godot_pool_real_array_get(&_godot_array, idx); + return godot::api->pandemonium_pool_real_array_get(&_pandemonium_array, idx); } int PoolRealArray::size() const { - return godot::api->godot_pool_real_array_size(&_godot_array); + return godot::api->pandemonium_pool_real_array_size(&_pandemonium_array); } PoolRealArray::~PoolRealArray() { - godot::api->godot_pool_real_array_destroy(&_godot_array); + godot::api->pandemonium_pool_real_array_destroy(&_pandemonium_array); } PoolStringArray::PoolStringArray() { - godot::api->godot_pool_string_array_new(&_godot_array); + godot::api->pandemonium_pool_string_array_new(&_pandemonium_array); } PoolStringArray::PoolStringArray(const PoolStringArray &p_other) { - godot::api->godot_pool_string_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_string_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); } PoolStringArray &PoolStringArray::operator=(const PoolStringArray &p_other) { - godot::api->godot_pool_string_array_destroy(&_godot_array); - godot::api->godot_pool_string_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_string_array_destroy(&_pandemonium_array); + godot::api->pandemonium_pool_string_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); return *this; } PoolStringArray::PoolStringArray(const Array &array) { - godot::api->godot_pool_string_array_new_with_array(&_godot_array, (godot_array *)&array); + godot::api->pandemonium_pool_string_array_new_with_array(&_pandemonium_array, (pandemonium_array *)&array); } PoolStringArray::Read PoolStringArray::read() const { Read read; - read._read_access = godot::api->godot_pool_string_array_read(&_godot_array); + read._read_access = godot::api->pandemonium_pool_string_array_read(&_pandemonium_array); return read; } PoolStringArray::Write PoolStringArray::write() { Write write; - write._write_access = godot::api->godot_pool_string_array_write(&_godot_array); + write._write_access = godot::api->pandemonium_pool_string_array_write(&_pandemonium_array); return write; } void PoolStringArray::append(const String &data) { - godot::api->godot_pool_string_array_append(&_godot_array, (godot_string *)&data); + godot::api->pandemonium_pool_string_array_append(&_pandemonium_array, (pandemonium_string *)&data); } void PoolStringArray::append_array(const PoolStringArray &array) { - godot::api->godot_pool_string_array_append_array(&_godot_array, &array._godot_array); + godot::api->pandemonium_pool_string_array_append_array(&_pandemonium_array, &array._pandemonium_array); } int PoolStringArray::insert(const int idx, const String &data) { - return godot::api->godot_pool_string_array_insert(&_godot_array, idx, (godot_string *)&data); + return godot::api->pandemonium_pool_string_array_insert(&_pandemonium_array, idx, (pandemonium_string *)&data); } void PoolStringArray::invert() { - godot::api->godot_pool_string_array_invert(&_godot_array); + godot::api->pandemonium_pool_string_array_invert(&_pandemonium_array); } void PoolStringArray::push_back(const String &data) { - godot::api->godot_pool_string_array_push_back(&_godot_array, (godot_string *)&data); + godot::api->pandemonium_pool_string_array_push_back(&_pandemonium_array, (pandemonium_string *)&data); } void PoolStringArray::remove(const int idx) { - godot::api->godot_pool_string_array_remove(&_godot_array, idx); + godot::api->pandemonium_pool_string_array_remove(&_pandemonium_array, idx); } void PoolStringArray::resize(const int size) { - godot::api->godot_pool_string_array_resize(&_godot_array, size); + godot::api->pandemonium_pool_string_array_resize(&_pandemonium_array, size); } void PoolStringArray::set(const int idx, const String &data) { - godot::api->godot_pool_string_array_set(&_godot_array, idx, (godot_string *)&data); + godot::api->pandemonium_pool_string_array_set(&_pandemonium_array, idx, (pandemonium_string *)&data); } const String PoolStringArray::operator[](const int idx) { String s; - godot_string str = godot::api->godot_pool_string_array_get(&_godot_array, idx); - godot::api->godot_string_new_copy((godot_string *)&s, &str); - godot::api->godot_string_destroy(&str); + pandemonium_string str = godot::api->pandemonium_pool_string_array_get(&_pandemonium_array, idx); + godot::api->pandemonium_string_new_copy((pandemonium_string *)&s, &str); + godot::api->pandemonium_string_destroy(&str); return s; } int PoolStringArray::size() const { - return godot::api->godot_pool_string_array_size(&_godot_array); + return godot::api->pandemonium_pool_string_array_size(&_pandemonium_array); } PoolStringArray::~PoolStringArray() { - godot::api->godot_pool_string_array_destroy(&_godot_array); + godot::api->pandemonium_pool_string_array_destroy(&_pandemonium_array); } PoolVector2Array::PoolVector2Array() { - godot::api->godot_pool_vector2_array_new(&_godot_array); + godot::api->pandemonium_pool_vector2_array_new(&_pandemonium_array); } PoolVector2Array::PoolVector2Array(const PoolVector2Array &p_other) { - godot::api->godot_pool_vector2_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_vector2_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); } PoolVector2Array &PoolVector2Array::operator=(const PoolVector2Array &p_other) { - godot::api->godot_pool_vector2_array_destroy(&_godot_array); - godot::api->godot_pool_vector2_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_vector2_array_destroy(&_pandemonium_array); + godot::api->pandemonium_pool_vector2_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); return *this; } PoolVector2Array::PoolVector2Array(const Array &array) { - godot::api->godot_pool_vector2_array_new_with_array(&_godot_array, (godot_array *)&array); + godot::api->pandemonium_pool_vector2_array_new_with_array(&_pandemonium_array, (pandemonium_array *)&array); } PoolVector2Array::Read PoolVector2Array::read() const { Read read; - read._read_access = godot::api->godot_pool_vector2_array_read(&_godot_array); + read._read_access = godot::api->pandemonium_pool_vector2_array_read(&_pandemonium_array); return read; } PoolVector2Array::Write PoolVector2Array::write() { Write write; - write._write_access = godot::api->godot_pool_vector2_array_write(&_godot_array); + write._write_access = godot::api->pandemonium_pool_vector2_array_write(&_pandemonium_array); return write; } void PoolVector2Array::append(const Vector2 &data) { - godot::api->godot_pool_vector2_array_append(&_godot_array, (godot_vector2 *)&data); + godot::api->pandemonium_pool_vector2_array_append(&_pandemonium_array, (pandemonium_vector2 *)&data); } void PoolVector2Array::append_array(const PoolVector2Array &array) { - godot::api->godot_pool_vector2_array_append_array(&_godot_array, &array._godot_array); + godot::api->pandemonium_pool_vector2_array_append_array(&_pandemonium_array, &array._pandemonium_array); } int PoolVector2Array::insert(const int idx, const Vector2 &data) { - return godot::api->godot_pool_vector2_array_insert(&_godot_array, idx, (godot_vector2 *)&data); + return godot::api->pandemonium_pool_vector2_array_insert(&_pandemonium_array, idx, (pandemonium_vector2 *)&data); } void PoolVector2Array::invert() { - godot::api->godot_pool_vector2_array_invert(&_godot_array); + godot::api->pandemonium_pool_vector2_array_invert(&_pandemonium_array); } void PoolVector2Array::push_back(const Vector2 &data) { - godot::api->godot_pool_vector2_array_push_back(&_godot_array, (godot_vector2 *)&data); + godot::api->pandemonium_pool_vector2_array_push_back(&_pandemonium_array, (pandemonium_vector2 *)&data); } void PoolVector2Array::remove(const int idx) { - godot::api->godot_pool_vector2_array_remove(&_godot_array, idx); + godot::api->pandemonium_pool_vector2_array_remove(&_pandemonium_array, idx); } void PoolVector2Array::resize(const int size) { - godot::api->godot_pool_vector2_array_resize(&_godot_array, size); + godot::api->pandemonium_pool_vector2_array_resize(&_pandemonium_array, size); } void PoolVector2Array::set(const int idx, const Vector2 &data) { - godot::api->godot_pool_vector2_array_set(&_godot_array, idx, (godot_vector2 *)&data); + godot::api->pandemonium_pool_vector2_array_set(&_pandemonium_array, idx, (pandemonium_vector2 *)&data); } const Vector2 PoolVector2Array::operator[](const int idx) { Vector2 v; - *(godot_vector2 *)&v = godot::api->godot_pool_vector2_array_get(&_godot_array, idx); + *(pandemonium_vector2 *)&v = godot::api->pandemonium_pool_vector2_array_get(&_pandemonium_array, idx); return v; } int PoolVector2Array::size() const { - return godot::api->godot_pool_vector2_array_size(&_godot_array); + return godot::api->pandemonium_pool_vector2_array_size(&_pandemonium_array); } PoolVector2Array::~PoolVector2Array() { - godot::api->godot_pool_vector2_array_destroy(&_godot_array); + godot::api->pandemonium_pool_vector2_array_destroy(&_pandemonium_array); } PoolVector3Array::PoolVector3Array() { - godot::api->godot_pool_vector3_array_new(&_godot_array); + godot::api->pandemonium_pool_vector3_array_new(&_pandemonium_array); } PoolVector3Array::PoolVector3Array(const PoolVector3Array &p_other) { - godot::api->godot_pool_vector3_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_vector3_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); } PoolVector3Array &PoolVector3Array::operator=(const PoolVector3Array &p_other) { - godot::api->godot_pool_vector3_array_destroy(&_godot_array); - godot::api->godot_pool_vector3_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_vector3_array_destroy(&_pandemonium_array); + godot::api->pandemonium_pool_vector3_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); return *this; } PoolVector3Array::PoolVector3Array(const Array &array) { - godot::api->godot_pool_vector3_array_new_with_array(&_godot_array, (godot_array *)&array); + godot::api->pandemonium_pool_vector3_array_new_with_array(&_pandemonium_array, (pandemonium_array *)&array); } PoolVector3Array::Read PoolVector3Array::read() const { Read read; - read._read_access = godot::api->godot_pool_vector3_array_read(&_godot_array); + read._read_access = godot::api->pandemonium_pool_vector3_array_read(&_pandemonium_array); return read; } PoolVector3Array::Write PoolVector3Array::write() { Write write; - write._write_access = godot::api->godot_pool_vector3_array_write(&_godot_array); + write._write_access = godot::api->pandemonium_pool_vector3_array_write(&_pandemonium_array); return write; } void PoolVector3Array::append(const Vector3 &data) { - godot::api->godot_pool_vector3_array_append(&_godot_array, (godot_vector3 *)&data); + godot::api->pandemonium_pool_vector3_array_append(&_pandemonium_array, (pandemonium_vector3 *)&data); } void PoolVector3Array::append_array(const PoolVector3Array &array) { - godot::api->godot_pool_vector3_array_append_array(&_godot_array, &array._godot_array); + godot::api->pandemonium_pool_vector3_array_append_array(&_pandemonium_array, &array._pandemonium_array); } int PoolVector3Array::insert(const int idx, const Vector3 &data) { - return godot::api->godot_pool_vector3_array_insert(&_godot_array, idx, (godot_vector3 *)&data); + return godot::api->pandemonium_pool_vector3_array_insert(&_pandemonium_array, idx, (pandemonium_vector3 *)&data); } void PoolVector3Array::invert() { - godot::api->godot_pool_vector3_array_invert(&_godot_array); + godot::api->pandemonium_pool_vector3_array_invert(&_pandemonium_array); } void PoolVector3Array::push_back(const Vector3 &data) { - godot::api->godot_pool_vector3_array_push_back(&_godot_array, (godot_vector3 *)&data); + godot::api->pandemonium_pool_vector3_array_push_back(&_pandemonium_array, (pandemonium_vector3 *)&data); } void PoolVector3Array::remove(const int idx) { - godot::api->godot_pool_vector3_array_remove(&_godot_array, idx); + godot::api->pandemonium_pool_vector3_array_remove(&_pandemonium_array, idx); } void PoolVector3Array::resize(const int size) { - godot::api->godot_pool_vector3_array_resize(&_godot_array, size); + godot::api->pandemonium_pool_vector3_array_resize(&_pandemonium_array, size); } void PoolVector3Array::set(const int idx, const Vector3 &data) { - godot::api->godot_pool_vector3_array_set(&_godot_array, idx, (godot_vector3 *)&data); + godot::api->pandemonium_pool_vector3_array_set(&_pandemonium_array, idx, (pandemonium_vector3 *)&data); } const Vector3 PoolVector3Array::operator[](const int idx) { Vector3 v; - *(godot_vector3 *)&v = godot::api->godot_pool_vector3_array_get(&_godot_array, idx); + *(pandemonium_vector3 *)&v = godot::api->pandemonium_pool_vector3_array_get(&_pandemonium_array, idx); return v; } int PoolVector3Array::size() const { - return godot::api->godot_pool_vector3_array_size(&_godot_array); + return godot::api->pandemonium_pool_vector3_array_size(&_pandemonium_array); } PoolVector3Array::~PoolVector3Array() { - godot::api->godot_pool_vector3_array_destroy(&_godot_array); + godot::api->pandemonium_pool_vector3_array_destroy(&_pandemonium_array); } PoolColorArray::PoolColorArray() { - godot::api->godot_pool_color_array_new(&_godot_array); + godot::api->pandemonium_pool_color_array_new(&_pandemonium_array); } PoolColorArray::PoolColorArray(const PoolColorArray &p_other) { - godot::api->godot_pool_color_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_color_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); } PoolColorArray &PoolColorArray::operator=(const PoolColorArray &p_other) { - godot::api->godot_pool_color_array_destroy(&_godot_array); - godot::api->godot_pool_color_array_new_copy(&_godot_array, &p_other._godot_array); + godot::api->pandemonium_pool_color_array_destroy(&_pandemonium_array); + godot::api->pandemonium_pool_color_array_new_copy(&_pandemonium_array, &p_other._pandemonium_array); return *this; } PoolColorArray::PoolColorArray(const Array &array) { - godot::api->godot_pool_color_array_new_with_array(&_godot_array, (godot_array *)&array); + godot::api->pandemonium_pool_color_array_new_with_array(&_pandemonium_array, (pandemonium_array *)&array); } PoolColorArray::Read PoolColorArray::read() const { Read read; - read._read_access = godot::api->godot_pool_color_array_read(&_godot_array); + read._read_access = godot::api->pandemonium_pool_color_array_read(&_pandemonium_array); return read; } PoolColorArray::Write PoolColorArray::write() { Write write; - write._write_access = godot::api->godot_pool_color_array_write(&_godot_array); + write._write_access = godot::api->pandemonium_pool_color_array_write(&_pandemonium_array); return write; } void PoolColorArray::append(const Color &data) { - godot::api->godot_pool_color_array_append(&_godot_array, (godot_color *)&data); + godot::api->pandemonium_pool_color_array_append(&_pandemonium_array, (pandemonium_color *)&data); } void PoolColorArray::append_array(const PoolColorArray &array) { - godot::api->godot_pool_color_array_append_array(&_godot_array, &array._godot_array); + godot::api->pandemonium_pool_color_array_append_array(&_pandemonium_array, &array._pandemonium_array); } int PoolColorArray::insert(const int idx, const Color &data) { - return godot::api->godot_pool_color_array_insert(&_godot_array, idx, (godot_color *)&data); + return godot::api->pandemonium_pool_color_array_insert(&_pandemonium_array, idx, (pandemonium_color *)&data); } void PoolColorArray::invert() { - godot::api->godot_pool_color_array_invert(&_godot_array); + godot::api->pandemonium_pool_color_array_invert(&_pandemonium_array); } void PoolColorArray::push_back(const Color &data) { - godot::api->godot_pool_color_array_push_back(&_godot_array, (godot_color *)&data); + godot::api->pandemonium_pool_color_array_push_back(&_pandemonium_array, (pandemonium_color *)&data); } void PoolColorArray::remove(const int idx) { - godot::api->godot_pool_color_array_remove(&_godot_array, idx); + godot::api->pandemonium_pool_color_array_remove(&_pandemonium_array, idx); } void PoolColorArray::resize(const int size) { - godot::api->godot_pool_color_array_resize(&_godot_array, size); + godot::api->pandemonium_pool_color_array_resize(&_pandemonium_array, size); } void PoolColorArray::set(const int idx, const Color &data) { - godot::api->godot_pool_color_array_set(&_godot_array, idx, (godot_color *)&data); + godot::api->pandemonium_pool_color_array_set(&_pandemonium_array, idx, (pandemonium_color *)&data); } const Color PoolColorArray::operator[](const int idx) { Color v; - *(godot_color *)&v = godot::api->godot_pool_color_array_get(&_godot_array, idx); + *(pandemonium_color *)&v = godot::api->pandemonium_pool_color_array_get(&_pandemonium_array, idx); return v; } int PoolColorArray::size() const { - return godot::api->godot_pool_color_array_size(&_godot_array); + return godot::api->pandemonium_pool_color_array_size(&_pandemonium_array); } PoolColorArray::~PoolColorArray() { - godot::api->godot_pool_color_array_destroy(&_godot_array); + godot::api->pandemonium_pool_color_array_destroy(&_pandemonium_array); } } // namespace godot diff --git a/src/core/RID.cpp b/src/core/RID.cpp index 11a7ca4..a7f6ef5 100644 --- a/src/core/RID.cpp +++ b/src/core/RID.cpp @@ -37,23 +37,23 @@ namespace godot { RID::RID() { - godot::api->godot_rid_new(&_godot_rid); + godot::api->pandemonium_rid_new(&_pandemonium_rid); } RID::RID(Object *p) { - godot::api->godot_rid_new_with_resource(&_godot_rid, (const godot_object *)p); + godot::api->pandemonium_rid_new_with_resource(&_pandemonium_rid, (const pandemonium_object *)p); } -godot_rid RID::_get_godot_rid() const { - return _godot_rid; +pandemonium_rid RID::_get_pandemonium_rid() const { + return _pandemonium_rid; } int32_t RID::get_id() const { - return godot::api->godot_rid_get_id(&_godot_rid); + return godot::api->pandemonium_rid_get_id(&_pandemonium_rid); } bool RID::operator==(const RID &p_other) const { - return godot::api->godot_rid_operator_equal(&_godot_rid, &p_other._godot_rid); + return godot::api->pandemonium_rid_operator_equal(&_pandemonium_rid, &p_other._pandemonium_rid); } bool RID::operator!=(const RID &p_other) const { @@ -61,7 +61,7 @@ bool RID::operator!=(const RID &p_other) const { } bool RID::operator<(const RID &p_other) const { - return godot::api->godot_rid_operator_less(&_godot_rid, &p_other._godot_rid); + return godot::api->pandemonium_rid_operator_less(&_pandemonium_rid, &p_other._pandemonium_rid); } bool RID::operator>(const RID &p_other) const { diff --git a/src/core/String.cpp b/src/core/String.cpp index 5e76132..7af3ab0 100644 --- a/src/core/String.cpp +++ b/src/core/String.cpp @@ -43,98 +43,98 @@ namespace godot { godot::CharString::~CharString() { - godot::api->godot_char_string_destroy(&_char_string); + godot::api->pandemonium_char_string_destroy(&_char_string); } int godot::CharString::length() const { - return godot::api->godot_char_string_length(&_char_string); + return godot::api->pandemonium_char_string_length(&_char_string); } const char *godot::CharString::get_data() const { - return godot::api->godot_char_string_get_data(&_char_string); + return godot::api->pandemonium_char_string_get_data(&_char_string); } String String::num(double p_num, int p_decimals) { - return String(godot::api->godot_string_num_with_decimals(p_num, p_decimals)); + return String(godot::api->pandemonium_string_num_with_decimals(p_num, p_decimals)); } String String::num_scientific(double p_num) { - return String(godot::api->godot_string_num_scientific(p_num)); + return String(godot::api->pandemonium_string_num_scientific(p_num)); } String String::num_real(double p_num) { - return String(godot::api->godot_string_num_real(p_num)); + return String(godot::api->pandemonium_string_num_real(p_num)); } String String::num_int64(int64_t p_num, int base, bool capitalize_hex) { - return String(godot::api->godot_string_num_int64_capitalized(p_num, base, capitalize_hex)); + return String(godot::api->pandemonium_string_num_int64_capitalized(p_num, base, capitalize_hex)); } -String String::chr(godot_char_type p_char) { - return String(godot::api->godot_string_chr(p_char)); +String String::chr(pandemonium_char_type p_char) { + return String(godot::api->pandemonium_string_chr(p_char)); } String String::md5(const uint8_t *p_md5) { - return String(godot::api->godot_string_md5(p_md5)); + return String(godot::api->pandemonium_string_md5(p_md5)); } String String::hex_encode_buffer(const uint8_t *p_buffer, int p_len) { - return String(godot::api->godot_string_hex_encode_buffer(p_buffer, p_len)); + return String(godot::api->pandemonium_string_hex_encode_buffer(p_buffer, p_len)); } godot::String::String() { - godot::api->godot_string_new(&_godot_string); + godot::api->pandemonium_string_new(&_pandemonium_string); } String::String(const char *contents) { - godot::api->godot_string_new(&_godot_string); - godot::api->godot_string_parse_utf8(&_godot_string, contents); + godot::api->pandemonium_string_new(&_pandemonium_string); + godot::api->pandemonium_string_parse_utf8(&_pandemonium_string, contents); } String::String(const wchar_t *contents) { - godot::api->godot_string_new_with_wide_string(&_godot_string, contents, wcslen(contents)); + godot::api->pandemonium_string_new_with_wide_string(&_pandemonium_string, contents, wcslen(contents)); } String::String(const wchar_t c) { - godot::api->godot_string_new_with_wide_string(&_godot_string, &c, 1); + godot::api->pandemonium_string_new_with_wide_string(&_pandemonium_string, &c, 1); } String::String(const String &other) { - godot::api->godot_string_new_copy(&_godot_string, &other._godot_string); + godot::api->pandemonium_string_new_copy(&_pandemonium_string, &other._pandemonium_string); } String::String(String &&other) { - godot::api->godot_string_new_copy(&_godot_string, &other._godot_string); + godot::api->pandemonium_string_new_copy(&_pandemonium_string, &other._pandemonium_string); } String::~String() { - godot::api->godot_string_destroy(&_godot_string); + godot::api->pandemonium_string_destroy(&_pandemonium_string); } wchar_t &String::operator[](const int idx) { - return *const_cast(godot::api->godot_string_operator_index(&_godot_string, idx)); + return *const_cast(godot::api->pandemonium_string_operator_index(&_pandemonium_string, idx)); } wchar_t String::operator[](const int idx) const { - return *godot::api->godot_string_operator_index((godot_string *)&_godot_string, idx); + return *godot::api->pandemonium_string_operator_index((pandemonium_string *)&_pandemonium_string, idx); } int String::length() const { - return godot::api->godot_string_length(&_godot_string); + return godot::api->pandemonium_string_length(&_pandemonium_string); } void String::operator=(const String &s) { - godot::api->godot_string_destroy(&_godot_string); - godot::api->godot_string_new_copy(&_godot_string, &s._godot_string); + godot::api->pandemonium_string_destroy(&_pandemonium_string); + godot::api->pandemonium_string_new_copy(&_pandemonium_string, &s._pandemonium_string); } void String::operator=(String &&s) { - godot::api->godot_string_destroy(&_godot_string); - godot::api->godot_string_new_copy(&_godot_string, &s._godot_string); + godot::api->pandemonium_string_destroy(&_pandemonium_string); + godot::api->pandemonium_string_new_copy(&_pandemonium_string, &s._pandemonium_string); } bool String::operator==(const String &s) const { - return godot::api->godot_string_operator_equal(&_godot_string, &s._godot_string); + return godot::api->pandemonium_string_operator_equal(&_pandemonium_string, &s._pandemonium_string); } bool String::operator!=(const String &s) const { @@ -142,24 +142,24 @@ bool String::operator!=(const String &s) const { } String String::operator+(const String &s) const { - return String(godot::api->godot_string_operator_plus(&_godot_string, &s._godot_string)); + return String(godot::api->pandemonium_string_operator_plus(&_pandemonium_string, &s._pandemonium_string)); } void String::operator+=(const String &s) { - *this = String(godot::api->godot_string_operator_plus(&_godot_string, &s._godot_string)); + *this = String(godot::api->pandemonium_string_operator_plus(&_pandemonium_string, &s._pandemonium_string)); } void String::operator+=(const wchar_t c) { String _to_be_added = String(c); - *this = String(godot::api->godot_string_operator_plus(&_godot_string, &_to_be_added._godot_string)); + *this = String(godot::api->pandemonium_string_operator_plus(&_pandemonium_string, &_to_be_added._pandemonium_string)); } bool String::operator<(const String &s) const { - return godot::api->godot_string_operator_less(&_godot_string, &s._godot_string); + return godot::api->pandemonium_string_operator_less(&_pandemonium_string, &s._pandemonium_string); } bool String::operator<=(const String &s) const { - return godot::api->godot_string_operator_less(&_godot_string, &s._godot_string) || + return godot::api->pandemonium_string_operator_less(&_pandemonium_string, &s._pandemonium_string) || (*this == s); } @@ -176,21 +176,21 @@ String::operator NodePath() const { } const wchar_t *String::unicode_str() const { - return godot::api->godot_string_wide_str(&_godot_string); + return godot::api->pandemonium_string_wide_str(&_pandemonium_string); } char *String::alloc_c_string() const { - godot_char_string contents = godot::api->godot_string_utf8(&_godot_string); + pandemonium_char_string contents = godot::api->pandemonium_string_utf8(&_pandemonium_string); - int length = godot::api->godot_char_string_length(&contents); + int length = godot::api->pandemonium_char_string_length(&contents); - char *result = (char *)godot::api->godot_alloc(length + 1); + char *result = (char *)godot::api->pandemonium_alloc(length + 1); if (result) { - memcpy(result, godot::api->godot_char_string_get_data(&contents), length + 1); + memcpy(result, godot::api->pandemonium_char_string_get_data(&contents), length + 1); } - godot::api->godot_char_string_destroy(&contents); + godot::api->pandemonium_char_string_destroy(&contents); return result; } @@ -198,7 +198,7 @@ char *String::alloc_c_string() const { CharString String::utf8() const { CharString ret; - ret._char_string = godot::api->godot_string_utf8(&_godot_string); + ret._char_string = godot::api->pandemonium_string_utf8(&_pandemonium_string); return ret; } @@ -207,9 +207,9 @@ CharString String::ascii(bool p_extended) const { CharString ret; if (p_extended) - ret._char_string = godot::api->godot_string_ascii_extended(&_godot_string); + ret._char_string = godot::api->pandemonium_string_ascii_extended(&_pandemonium_string); else - ret._char_string = godot::api->godot_string_ascii(&_godot_string); + ret._char_string = godot::api->pandemonium_string_ascii(&_pandemonium_string); return ret; } @@ -223,299 +223,299 @@ String operator+(const wchar_t *a, const String &b) { } bool String::begins_with(const String &p_string) const { - return godot::api->godot_string_begins_with(&_godot_string, &p_string._godot_string); + return godot::api->pandemonium_string_begins_with(&_pandemonium_string, &p_string._pandemonium_string); } bool String::begins_with_char_array(const char *p_char_array) const { - return godot::api->godot_string_begins_with_char_array(&_godot_string, p_char_array); + return godot::api->pandemonium_string_begins_with_char_array(&_pandemonium_string, p_char_array); } PoolStringArray String::bigrams() const { - godot_array arr = godot::api->godot_string_bigrams(&_godot_string); + pandemonium_array arr = godot::api->pandemonium_string_bigrams(&_pandemonium_string); return Array(arr); } String String::c_escape() const { - return String(godot::api->godot_string_c_escape(&_godot_string)); + return String(godot::api->pandemonium_string_c_escape(&_pandemonium_string)); } String String::c_unescape() const { - return String(godot::api->godot_string_c_unescape(&_godot_string)); + return String(godot::api->pandemonium_string_c_unescape(&_pandemonium_string)); } String String::capitalize() const { - return String(godot::api->godot_string_capitalize(&_godot_string)); + return String(godot::api->pandemonium_string_capitalize(&_pandemonium_string)); } bool String::empty() const { - return godot::api->godot_string_empty(&_godot_string); + return godot::api->pandemonium_string_empty(&_pandemonium_string); } bool String::ends_with(const String &p_string) const { - return godot::api->godot_string_ends_with(&_godot_string, &p_string._godot_string); + return godot::api->pandemonium_string_ends_with(&_pandemonium_string, &p_string._pandemonium_string); } void String::erase(int position, int chars) { - godot::api->godot_string_erase(&_godot_string, position, chars); + godot::api->pandemonium_string_erase(&_pandemonium_string, position, chars); } int String::find(String p_what, int p_from) const { - return godot::api->godot_string_find_from(&_godot_string, p_what._godot_string, p_from); + return godot::api->pandemonium_string_find_from(&_pandemonium_string, p_what._pandemonium_string, p_from); } int String::find_last(String p_what) const { - return godot::api->godot_string_find_last(&_godot_string, p_what._godot_string); + return godot::api->pandemonium_string_find_last(&_pandemonium_string, p_what._pandemonium_string); } int String::findn(String p_what, int p_from) const { - return godot::api->godot_string_findn_from(&_godot_string, p_what._godot_string, p_from); + return godot::api->pandemonium_string_findn_from(&_pandemonium_string, p_what._pandemonium_string, p_from); } String String::format(Variant values) const { - return String(godot::api->godot_string_format(&_godot_string, (godot_variant *)&values)); + return String(godot::api->pandemonium_string_format(&_pandemonium_string, (pandemonium_variant *)&values)); } String String::format(Variant values, String placeholder) const { - godot_char_string contents = godot::api->godot_string_utf8(&placeholder._godot_string); - String new_string(godot::api->godot_string_format_with_custom_placeholder(&_godot_string, (godot_variant *)&values, godot::api->godot_char_string_get_data(&contents))); - godot::api->godot_char_string_destroy(&contents); + pandemonium_char_string contents = godot::api->pandemonium_string_utf8(&placeholder._pandemonium_string); + String new_string(godot::api->pandemonium_string_format_with_custom_placeholder(&_pandemonium_string, (pandemonium_variant *)&values, godot::api->pandemonium_char_string_get_data(&contents))); + godot::api->pandemonium_char_string_destroy(&contents); return new_string; } String String::get_base_dir() const { - return String(godot::api->godot_string_get_base_dir(&_godot_string)); + return String(godot::api->pandemonium_string_get_base_dir(&_pandemonium_string)); } String String::get_basename() const { - return String(godot::api->godot_string_get_basename(&_godot_string)); + return String(godot::api->pandemonium_string_get_basename(&_pandemonium_string)); } String String::get_extension() const { - return String(godot::api->godot_string_get_extension(&_godot_string)); + return String(godot::api->pandemonium_string_get_extension(&_pandemonium_string)); } String String::get_file() const { - return String(godot::api->godot_string_get_file(&_godot_string)); + return String(godot::api->pandemonium_string_get_file(&_pandemonium_string)); } int String::hash() const { - return godot::api->godot_string_hash(&_godot_string); + return godot::api->pandemonium_string_hash(&_pandemonium_string); } int String::hex_to_int() const { - return godot::api->godot_string_hex_to_int(&_godot_string); + return godot::api->pandemonium_string_hex_to_int(&_pandemonium_string); } String String::insert(int position, String what) const { - return String(godot::api->godot_string_insert(&_godot_string, position, what._godot_string)); + return String(godot::api->pandemonium_string_insert(&_pandemonium_string, position, what._pandemonium_string)); } bool String::is_abs_path() const { - return godot::api->godot_string_is_abs_path(&_godot_string); + return godot::api->pandemonium_string_is_abs_path(&_pandemonium_string); } bool String::is_rel_path() const { - return godot::api->godot_string_is_rel_path(&_godot_string); + return godot::api->pandemonium_string_is_rel_path(&_pandemonium_string); } bool String::is_subsequence_of(String text) const { - return godot::api->godot_string_is_subsequence_of(&_godot_string, &text._godot_string); + return godot::api->pandemonium_string_is_subsequence_of(&_pandemonium_string, &text._pandemonium_string); } bool String::is_subsequence_ofi(String text) const { - return godot::api->godot_string_is_subsequence_ofi(&_godot_string, &text._godot_string); + return godot::api->pandemonium_string_is_subsequence_ofi(&_pandemonium_string, &text._pandemonium_string); } bool String::is_valid_float() const { - return godot::api->godot_string_is_valid_float(&_godot_string); + return godot::api->pandemonium_string_is_valid_float(&_pandemonium_string); } bool String::is_valid_html_color() const { - return godot::api->godot_string_is_valid_html_color(&_godot_string); + return godot::api->pandemonium_string_is_valid_html_color(&_pandemonium_string); } bool String::is_valid_identifier() const { - return godot::api->godot_string_is_valid_identifier(&_godot_string); + return godot::api->pandemonium_string_is_valid_identifier(&_pandemonium_string); } bool String::is_valid_integer() const { - return godot::api->godot_string_is_numeric(&_godot_string); + return godot::api->pandemonium_string_is_numeric(&_pandemonium_string); } bool String::is_valid_ip_address() const { - return godot::api->godot_string_is_valid_ip_address(&_godot_string); + return godot::api->pandemonium_string_is_valid_ip_address(&_pandemonium_string); } String String::json_escape() const { - return String(godot::api->godot_string_json_escape(&_godot_string)); + return String(godot::api->pandemonium_string_json_escape(&_pandemonium_string)); } String String::left(int position) const { - return String(godot::api->godot_string_left(&_godot_string, position)); + return String(godot::api->pandemonium_string_left(&_pandemonium_string, position)); } bool String::match(String expr) const { - return godot::api->godot_string_match(&_godot_string, &expr._godot_string); + return godot::api->pandemonium_string_match(&_pandemonium_string, &expr._pandemonium_string); } bool String::matchn(String expr) const { - return godot::api->godot_string_match(&_godot_string, &expr._godot_string); + return godot::api->pandemonium_string_match(&_pandemonium_string, &expr._pandemonium_string); } PoolByteArray String::md5_buffer() const { - godot_pool_byte_array arr = godot::api->godot_string_md5_buffer(&_godot_string); + pandemonium_pool_byte_array arr = godot::api->pandemonium_string_md5_buffer(&_pandemonium_string); return PoolByteArray(arr); } String String::md5_text() const { - return String(godot::api->godot_string_md5_text(&_godot_string)); + return String(godot::api->pandemonium_string_md5_text(&_pandemonium_string)); } int String::ord_at(int at) const { - return godot::api->godot_string_ord_at(&_godot_string, at); + return godot::api->pandemonium_string_ord_at(&_pandemonium_string, at); } String String::pad_decimals(int digits) const { - return String(godot::api->godot_string_pad_decimals(&_godot_string, digits)); + return String(godot::api->pandemonium_string_pad_decimals(&_pandemonium_string, digits)); } String String::pad_zeros(int digits) const { - return String(godot::api->godot_string_pad_zeros(&_godot_string, digits)); + return String(godot::api->pandemonium_string_pad_zeros(&_pandemonium_string, digits)); } String String::percent_decode() const { - return String(godot::api->godot_string_percent_decode(&_godot_string)); + return String(godot::api->pandemonium_string_percent_decode(&_pandemonium_string)); } String String::percent_encode() const { - return String(godot::api->godot_string_percent_encode(&_godot_string)); + return String(godot::api->pandemonium_string_percent_encode(&_pandemonium_string)); } String String::plus_file(String file) const { - return String(godot::api->godot_string_plus_file(&_godot_string, &file._godot_string)); + return String(godot::api->pandemonium_string_plus_file(&_pandemonium_string, &file._pandemonium_string)); } String String::replace(String p_key, String p_with) const { - return String(godot::api->godot_string_replace(&_godot_string, p_key._godot_string, p_with._godot_string)); + return String(godot::api->pandemonium_string_replace(&_pandemonium_string, p_key._pandemonium_string, p_with._pandemonium_string)); } String String::replacen(String what, String forwhat) const { - return String(godot::api->godot_string_replacen(&_godot_string, what._godot_string, forwhat._godot_string)); + return String(godot::api->pandemonium_string_replacen(&_pandemonium_string, what._pandemonium_string, forwhat._pandemonium_string)); } int String::rfind(String p_what, int p_from) const { - return godot::api->godot_string_rfind_from(&_godot_string, p_what._godot_string, p_from); + return godot::api->pandemonium_string_rfind_from(&_pandemonium_string, p_what._pandemonium_string, p_from); } int String::rfindn(String p_what, int p_from) const { - return godot::api->godot_string_rfindn_from(&_godot_string, p_what._godot_string, p_from); + return godot::api->pandemonium_string_rfindn_from(&_pandemonium_string, p_what._pandemonium_string, p_from); } String String::right(int position) const { - return String(godot::api->godot_string_right(&_godot_string, position)); + return String(godot::api->pandemonium_string_right(&_pandemonium_string, position)); } PoolByteArray String::sha256_buffer() const { - godot_pool_byte_array arr = godot::api->godot_string_sha256_buffer(&_godot_string); + pandemonium_pool_byte_array arr = godot::api->pandemonium_string_sha256_buffer(&_pandemonium_string); return PoolByteArray(arr); } String String::sha256_text() const { - return String(godot::api->godot_string_sha256_text(&_godot_string)); + return String(godot::api->pandemonium_string_sha256_text(&_pandemonium_string)); } float String::similarity(String text) const { - return godot::api->godot_string_similarity(&_godot_string, &text._godot_string); + return godot::api->pandemonium_string_similarity(&_pandemonium_string, &text._pandemonium_string); } // TODO Suport allow_empty PoolStringArray String::split(String divisor, bool /*allow_empty*/) const { - godot_array arr = godot::api->godot_string_split(&_godot_string, &divisor._godot_string); + pandemonium_array arr = godot::api->pandemonium_string_split(&_pandemonium_string, &divisor._pandemonium_string); return Array(arr); } // TODO Suport allow_empty PoolIntArray String::split_ints(String divisor, bool /*allow_empty*/) const { - godot_array arr = godot::api->godot_string_split_floats(&_godot_string, &divisor._godot_string); + pandemonium_array arr = godot::api->pandemonium_string_split_floats(&_pandemonium_string, &divisor._pandemonium_string); return Array(arr); } // TODO Suport allow_empty PoolRealArray String::split_floats(String divisor, bool /*allow_empty*/) const { - // TODO The GDNative API returns godot_array, when according to the doc, it should have been godot_pool_real_array - godot_array arr = godot::api->godot_string_split_floats(&_godot_string, &divisor._godot_string); + // TODO The GDNative API returns pandemonium_array, when according to the doc, it should have been pandemonium_pool_real_array + pandemonium_array arr = godot::api->pandemonium_string_split_floats(&_pandemonium_string, &divisor._pandemonium_string); Array wrapped_array(arr); return PoolRealArray(wrapped_array); } String String::strip_edges(bool left, bool right) const { - return String(godot::api->godot_string_strip_edges(&_godot_string, left, right)); + return String(godot::api->pandemonium_string_strip_edges(&_pandemonium_string, left, right)); } String String::substr(int from, int len) const { - return String(godot::api->godot_string_substr(&_godot_string, from, len)); + return String(godot::api->pandemonium_string_substr(&_pandemonium_string, from, len)); } float String::to_float() const { - return godot::api->godot_string_to_float(&_godot_string); + return godot::api->pandemonium_string_to_float(&_pandemonium_string); } int64_t String::to_int() const { - return godot::api->godot_string_to_int(&_godot_string); + return godot::api->pandemonium_string_to_int(&_pandemonium_string); } String String::to_lower() const { - return String(godot::api->godot_string_to_lower(&_godot_string)); + return String(godot::api->pandemonium_string_to_lower(&_pandemonium_string)); } String String::to_upper() const { - return String(godot::api->godot_string_to_upper(&_godot_string)); + return String(godot::api->pandemonium_string_to_upper(&_pandemonium_string)); } String String::xml_escape() const { - return String(godot::api->godot_string_xml_escape(&_godot_string)); + return String(godot::api->pandemonium_string_xml_escape(&_pandemonium_string)); } String String::xml_unescape() const { - return String(godot::api->godot_string_xml_unescape(&_godot_string)); + return String(godot::api->pandemonium_string_xml_unescape(&_pandemonium_string)); } signed char String::casecmp_to(String p_str) const { - return godot::api->godot_string_casecmp_to(&_godot_string, &p_str._godot_string); + return godot::api->pandemonium_string_casecmp_to(&_pandemonium_string, &p_str._pandemonium_string); } signed char String::nocasecmp_to(String p_str) const { - return godot::api->godot_string_nocasecmp_to(&_godot_string, &p_str._godot_string); + return godot::api->pandemonium_string_nocasecmp_to(&_pandemonium_string, &p_str._pandemonium_string); } signed char String::naturalnocasecmp_to(String p_str) const { - return godot::api->godot_string_naturalnocasecmp_to(&_godot_string, &p_str._godot_string); + return godot::api->pandemonium_string_naturalnocasecmp_to(&_pandemonium_string, &p_str._pandemonium_string); } String String::dedent() const { - godot_string s = godot::core_1_1_api->godot_string_dedent(&_godot_string); + pandemonium_string s = godot::core_1_1_api->pandemonium_string_dedent(&_pandemonium_string); return String(s); } PoolStringArray String::rsplit(const String &divisor, const bool allow_empty, const int maxsplit) const { - godot_pool_string_array arr = - godot::core_1_1_api->godot_string_rsplit(&_godot_string, &divisor._godot_string, allow_empty, maxsplit); + pandemonium_pool_string_array arr = + godot::core_1_1_api->pandemonium_string_rsplit(&_pandemonium_string, &divisor._pandemonium_string, allow_empty, maxsplit); return PoolStringArray(arr); } String String::rstrip(const String &chars) const { - godot_string s = godot::core_1_1_api->godot_string_rstrip(&_godot_string, &chars._godot_string); + pandemonium_string s = godot::core_1_1_api->pandemonium_string_rstrip(&_pandemonium_string, &chars._pandemonium_string); return String(s); } String String::trim_prefix(const String &prefix) const { - godot_string s = godot::core_1_1_api->godot_string_trim_prefix(&_godot_string, &prefix._godot_string); + pandemonium_string s = godot::core_1_1_api->pandemonium_string_trim_prefix(&_pandemonium_string, &prefix._pandemonium_string); return String(s); } String String::trim_suffix(const String &suffix) const { - godot_string s = godot::core_1_1_api->godot_string_trim_suffix(&_godot_string, &suffix._godot_string); + pandemonium_string s = godot::core_1_1_api->pandemonium_string_trim_suffix(&_pandemonium_string, &suffix._pandemonium_string); return String(s); } diff --git a/src/core/TagDB.cpp b/src/core/TagDB.cpp index 4a2b133..fbc871a 100644 --- a/src/core/TagDB.cpp +++ b/src/core/TagDB.cpp @@ -52,7 +52,7 @@ bool is_type_known(size_t type_tag) { } void register_global_type(const char *name, size_t type_tag, size_t base_type_tag) { - godot::nativescript_1_1_api->godot_nativescript_set_global_type_tag(godot::_RegisterState::language_index, name, (const void *)type_tag); + godot::nativescript_1_1_api->pandemonium_nativescript_set_global_type_tag(godot::_RegisterState::language_index, name, (const void *)type_tag); register_type(type_tag, base_type_tag); } diff --git a/src/core/Variant.cpp b/src/core/Variant.cpp index 55f661b..8a7bd00 100644 --- a/src/core/Variant.cpp +++ b/src/core/Variant.cpp @@ -40,156 +40,156 @@ namespace godot { Variant::Variant() { - godot::api->godot_variant_new_nil(&_godot_variant); + godot::api->pandemonium_variant_new_nil(&_pandemonium_variant); } Variant::Variant(const Variant &v) { - godot::api->godot_variant_new_copy(&_godot_variant, &v._godot_variant); + godot::api->pandemonium_variant_new_copy(&_pandemonium_variant, &v._pandemonium_variant); } Variant::Variant(bool p_bool) { - godot::api->godot_variant_new_bool(&_godot_variant, p_bool); + godot::api->pandemonium_variant_new_bool(&_pandemonium_variant, p_bool); } Variant::Variant(signed int p_int) // real one { - godot::api->godot_variant_new_int(&_godot_variant, p_int); + godot::api->pandemonium_variant_new_int(&_pandemonium_variant, p_int); } Variant::Variant(unsigned int p_int) { - godot::api->godot_variant_new_uint(&_godot_variant, p_int); + godot::api->pandemonium_variant_new_uint(&_pandemonium_variant, p_int); } Variant::Variant(signed short p_short) // real one { - godot::api->godot_variant_new_int(&_godot_variant, (int)p_short); + godot::api->pandemonium_variant_new_int(&_pandemonium_variant, (int)p_short); } Variant::Variant(int64_t p_char) // real one { - godot::api->godot_variant_new_int(&_godot_variant, p_char); + godot::api->pandemonium_variant_new_int(&_pandemonium_variant, p_char); } Variant::Variant(uint64_t p_char) { - godot::api->godot_variant_new_uint(&_godot_variant, p_char); + godot::api->pandemonium_variant_new_uint(&_pandemonium_variant, p_char); } Variant::Variant(float p_float) { - godot::api->godot_variant_new_real(&_godot_variant, p_float); + godot::api->pandemonium_variant_new_real(&_pandemonium_variant, p_float); } Variant::Variant(double p_double) { - godot::api->godot_variant_new_real(&_godot_variant, p_double); + godot::api->pandemonium_variant_new_real(&_pandemonium_variant, p_double); } Variant::Variant(const String &p_string) { - godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&p_string); + godot::api->pandemonium_variant_new_string(&_pandemonium_variant, (pandemonium_string *)&p_string); } Variant::Variant(const char *const p_cstring) { String s = String(p_cstring); - godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&s); + godot::api->pandemonium_variant_new_string(&_pandemonium_variant, (pandemonium_string *)&s); } Variant::Variant(const wchar_t *p_wstring) { String s = p_wstring; - godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&s); + godot::api->pandemonium_variant_new_string(&_pandemonium_variant, (pandemonium_string *)&s); } Variant::Variant(const Vector2 &p_vector2) { - godot::api->godot_variant_new_vector2(&_godot_variant, (godot_vector2 *)&p_vector2); + godot::api->pandemonium_variant_new_vector2(&_pandemonium_variant, (pandemonium_vector2 *)&p_vector2); } Variant::Variant(const Rect2 &p_rect2) { - godot::api->godot_variant_new_rect2(&_godot_variant, (godot_rect2 *)&p_rect2); + godot::api->pandemonium_variant_new_rect2(&_pandemonium_variant, (pandemonium_rect2 *)&p_rect2); } Variant::Variant(const Vector3 &p_vector3) { - godot::api->godot_variant_new_vector3(&_godot_variant, (godot_vector3 *)&p_vector3); + godot::api->pandemonium_variant_new_vector3(&_pandemonium_variant, (pandemonium_vector3 *)&p_vector3); } Variant::Variant(const Plane &p_plane) { - godot::api->godot_variant_new_plane(&_godot_variant, (godot_plane *)&p_plane); + godot::api->pandemonium_variant_new_plane(&_pandemonium_variant, (pandemonium_plane *)&p_plane); } Variant::Variant(const AABB &p_aabb) { - godot::api->godot_variant_new_aabb(&_godot_variant, (godot_aabb *)&p_aabb); + godot::api->pandemonium_variant_new_aabb(&_pandemonium_variant, (pandemonium_aabb *)&p_aabb); } Variant::Variant(const Quat &p_quat) { - godot::api->godot_variant_new_quat(&_godot_variant, (godot_quat *)&p_quat); + godot::api->pandemonium_variant_new_quat(&_pandemonium_variant, (pandemonium_quat *)&p_quat); } Variant::Variant(const Basis &p_transform) { - godot::api->godot_variant_new_basis(&_godot_variant, (godot_basis *)&p_transform); + godot::api->pandemonium_variant_new_basis(&_pandemonium_variant, (pandemonium_basis *)&p_transform); } Variant::Variant(const Transform2D &p_transform) { - godot::api->godot_variant_new_transform2d(&_godot_variant, (godot_transform2d *)&p_transform); + godot::api->pandemonium_variant_new_transform2d(&_pandemonium_variant, (pandemonium_transform2d *)&p_transform); } Variant::Variant(const Transform &p_transform) { - godot::api->godot_variant_new_transform(&_godot_variant, (godot_transform *)&p_transform); + godot::api->pandemonium_variant_new_transform(&_pandemonium_variant, (pandemonium_transform *)&p_transform); } Variant::Variant(const Color &p_color) { - godot::api->godot_variant_new_color(&_godot_variant, (godot_color *)&p_color); + godot::api->pandemonium_variant_new_color(&_pandemonium_variant, (pandemonium_color *)&p_color); } Variant::Variant(const NodePath &p_path) { - godot::api->godot_variant_new_node_path(&_godot_variant, (godot_node_path *)&p_path); + godot::api->pandemonium_variant_new_node_path(&_pandemonium_variant, (pandemonium_node_path *)&p_path); } Variant::Variant(const RID &p_rid) { - godot::api->godot_variant_new_rid(&_godot_variant, (godot_rid *)&p_rid); + godot::api->pandemonium_variant_new_rid(&_pandemonium_variant, (pandemonium_rid *)&p_rid); } Variant::Variant(const Object *p_object) { if (p_object) - godot::api->godot_variant_new_object(&_godot_variant, p_object->_owner); + godot::api->pandemonium_variant_new_object(&_pandemonium_variant, p_object->_owner); else - godot::api->godot_variant_new_nil(&_godot_variant); + godot::api->pandemonium_variant_new_nil(&_pandemonium_variant); } Variant::Variant(const Dictionary &p_dictionary) { - godot::api->godot_variant_new_dictionary(&_godot_variant, (godot_dictionary *)&p_dictionary); + godot::api->pandemonium_variant_new_dictionary(&_pandemonium_variant, (pandemonium_dictionary *)&p_dictionary); } Variant::Variant(const Array &p_array) { - godot::api->godot_variant_new_array(&_godot_variant, (godot_array *)&p_array); + godot::api->pandemonium_variant_new_array(&_pandemonium_variant, (pandemonium_array *)&p_array); } Variant::Variant(const PoolByteArray &p_raw_array) { - godot::api->godot_variant_new_pool_byte_array(&_godot_variant, (godot_pool_byte_array *)&p_raw_array); + godot::api->pandemonium_variant_new_pool_byte_array(&_pandemonium_variant, (pandemonium_pool_byte_array *)&p_raw_array); } Variant::Variant(const PoolIntArray &p_int_array) { - godot::api->godot_variant_new_pool_int_array(&_godot_variant, (godot_pool_int_array *)&p_int_array); + godot::api->pandemonium_variant_new_pool_int_array(&_pandemonium_variant, (pandemonium_pool_int_array *)&p_int_array); } Variant::Variant(const PoolRealArray &p_real_array) { - godot::api->godot_variant_new_pool_real_array(&_godot_variant, (godot_pool_real_array *)&p_real_array); + godot::api->pandemonium_variant_new_pool_real_array(&_pandemonium_variant, (pandemonium_pool_real_array *)&p_real_array); } Variant::Variant(const PoolStringArray &p_string_array) { - godot::api->godot_variant_new_pool_string_array(&_godot_variant, (godot_pool_string_array *)&p_string_array); + godot::api->pandemonium_variant_new_pool_string_array(&_pandemonium_variant, (pandemonium_pool_string_array *)&p_string_array); } Variant::Variant(const PoolVector2Array &p_vector2_array) { - godot::api->godot_variant_new_pool_vector2_array(&_godot_variant, (godot_pool_vector2_array *)&p_vector2_array); + godot::api->pandemonium_variant_new_pool_vector2_array(&_pandemonium_variant, (pandemonium_pool_vector2_array *)&p_vector2_array); } Variant::Variant(const PoolVector3Array &p_vector3_array) { - godot::api->godot_variant_new_pool_vector3_array(&_godot_variant, (godot_pool_vector3_array *)&p_vector3_array); + godot::api->pandemonium_variant_new_pool_vector3_array(&_pandemonium_variant, (pandemonium_pool_vector3_array *)&p_vector3_array); } Variant::Variant(const PoolColorArray &p_color_array) { - godot::api->godot_variant_new_pool_color_array(&_godot_variant, (godot_pool_color_array *)&p_color_array); + godot::api->pandemonium_variant_new_pool_color_array(&_pandemonium_variant, (pandemonium_pool_color_array *)&p_color_array); } Variant &Variant::operator=(const Variant &v) { - godot::api->godot_variant_destroy(&_godot_variant); - godot::api->godot_variant_new_copy(&_godot_variant, &v._godot_variant); + godot::api->pandemonium_variant_destroy(&_pandemonium_variant); + godot::api->pandemonium_variant_new_copy(&_pandemonium_variant, &v._pandemonium_variant); return *this; } @@ -197,154 +197,154 @@ Variant::operator bool() const { return booleanize(); } Variant::operator signed int() const { - return godot::api->godot_variant_as_int(&_godot_variant); + return godot::api->pandemonium_variant_as_int(&_pandemonium_variant); } Variant::operator unsigned int() const // this is the real one { - return godot::api->godot_variant_as_uint(&_godot_variant); + return godot::api->pandemonium_variant_as_uint(&_pandemonium_variant); } Variant::operator signed short() const { - return godot::api->godot_variant_as_int(&_godot_variant); + return godot::api->pandemonium_variant_as_int(&_pandemonium_variant); } Variant::operator unsigned short() const { - return godot::api->godot_variant_as_uint(&_godot_variant); + return godot::api->pandemonium_variant_as_uint(&_pandemonium_variant); } Variant::operator signed char() const { - return godot::api->godot_variant_as_int(&_godot_variant); + return godot::api->pandemonium_variant_as_int(&_pandemonium_variant); } Variant::operator unsigned char() const { - return godot::api->godot_variant_as_uint(&_godot_variant); + return godot::api->pandemonium_variant_as_uint(&_pandemonium_variant); } Variant::operator int64_t() const { - return godot::api->godot_variant_as_int(&_godot_variant); + return godot::api->pandemonium_variant_as_int(&_pandemonium_variant); } Variant::operator uint64_t() const { - return godot::api->godot_variant_as_uint(&_godot_variant); + return godot::api->pandemonium_variant_as_uint(&_pandemonium_variant); } Variant::operator wchar_t() const { - return godot::api->godot_variant_as_int(&_godot_variant); + return godot::api->pandemonium_variant_as_int(&_pandemonium_variant); } Variant::operator float() const { - return godot::api->godot_variant_as_real(&_godot_variant); + return godot::api->pandemonium_variant_as_real(&_pandemonium_variant); } Variant::operator double() const { - return godot::api->godot_variant_as_real(&_godot_variant); + return godot::api->pandemonium_variant_as_real(&_pandemonium_variant); } Variant::operator String() const { - godot_string s = godot::api->godot_variant_as_string(&_godot_variant); + pandemonium_string s = godot::api->pandemonium_variant_as_string(&_pandemonium_variant); return String(s); } Variant::operator Vector2() const { - godot_vector2 s = godot::api->godot_variant_as_vector2(&_godot_variant); + pandemonium_vector2 s = godot::api->pandemonium_variant_as_vector2(&_pandemonium_variant); return *(Vector2 *)&s; } Variant::operator Rect2() const { - godot_rect2 s = godot::api->godot_variant_as_rect2(&_godot_variant); + pandemonium_rect2 s = godot::api->pandemonium_variant_as_rect2(&_pandemonium_variant); return *(Rect2 *)&s; } Variant::operator Vector3() const { - godot_vector3 s = godot::api->godot_variant_as_vector3(&_godot_variant); + pandemonium_vector3 s = godot::api->pandemonium_variant_as_vector3(&_pandemonium_variant); return *(Vector3 *)&s; } Variant::operator Plane() const { - godot_plane s = godot::api->godot_variant_as_plane(&_godot_variant); + pandemonium_plane s = godot::api->pandemonium_variant_as_plane(&_pandemonium_variant); return *(Plane *)&s; } Variant::operator AABB() const { - godot_aabb s = godot::api->godot_variant_as_aabb(&_godot_variant); + pandemonium_aabb s = godot::api->pandemonium_variant_as_aabb(&_pandemonium_variant); return *(AABB *)&s; } Variant::operator Quat() const { - godot_quat s = godot::api->godot_variant_as_quat(&_godot_variant); + pandemonium_quat s = godot::api->pandemonium_variant_as_quat(&_pandemonium_variant); return *(Quat *)&s; } Variant::operator Basis() const { - godot_basis s = godot::api->godot_variant_as_basis(&_godot_variant); + pandemonium_basis s = godot::api->pandemonium_variant_as_basis(&_pandemonium_variant); return *(Basis *)&s; } Variant::operator Transform() const { - godot_transform s = godot::api->godot_variant_as_transform(&_godot_variant); + pandemonium_transform s = godot::api->pandemonium_variant_as_transform(&_pandemonium_variant); return *(Transform *)&s; } Variant::operator Transform2D() const { - godot_transform2d s = godot::api->godot_variant_as_transform2d(&_godot_variant); + pandemonium_transform2d s = godot::api->pandemonium_variant_as_transform2d(&_pandemonium_variant); return *(Transform2D *)&s; } Variant::operator Color() const { - godot_color s = godot::api->godot_variant_as_color(&_godot_variant); + pandemonium_color s = godot::api->pandemonium_variant_as_color(&_pandemonium_variant); return *(Color *)&s; } Variant::operator NodePath() const { - godot_node_path ret = godot::api->godot_variant_as_node_path(&_godot_variant); + pandemonium_node_path ret = godot::api->pandemonium_variant_as_node_path(&_pandemonium_variant); return NodePath(ret); } Variant::operator RID() const { - godot_rid s = godot::api->godot_variant_as_rid(&_godot_variant); + pandemonium_rid s = godot::api->pandemonium_variant_as_rid(&_pandemonium_variant); return *(RID *)&s; } Variant::operator Dictionary() const { - Dictionary ret(godot::api->godot_variant_as_dictionary(&_godot_variant)); + Dictionary ret(godot::api->pandemonium_variant_as_dictionary(&_pandemonium_variant)); return ret; } Variant::operator Array() const { - Array ret(godot::api->godot_variant_as_array(&_godot_variant)); + Array ret(godot::api->pandemonium_variant_as_array(&_pandemonium_variant)); return ret; } Variant::operator PoolByteArray() const { - godot_pool_byte_array ret = godot::api->godot_variant_as_pool_byte_array(&_godot_variant); + pandemonium_pool_byte_array ret = godot::api->pandemonium_variant_as_pool_byte_array(&_pandemonium_variant); return PoolByteArray(ret); } Variant::operator PoolIntArray() const { - godot_pool_int_array ret = godot::api->godot_variant_as_pool_int_array(&_godot_variant); + pandemonium_pool_int_array ret = godot::api->pandemonium_variant_as_pool_int_array(&_pandemonium_variant); return PoolIntArray(ret); } Variant::operator PoolRealArray() const { - godot_pool_real_array ret = godot::api->godot_variant_as_pool_real_array(&_godot_variant); + pandemonium_pool_real_array ret = godot::api->pandemonium_variant_as_pool_real_array(&_pandemonium_variant); return PoolRealArray(ret); } Variant::operator PoolStringArray() const { - godot_pool_string_array ret = godot::api->godot_variant_as_pool_string_array(&_godot_variant); + pandemonium_pool_string_array ret = godot::api->pandemonium_variant_as_pool_string_array(&_pandemonium_variant); return PoolStringArray(ret); } Variant::operator PoolVector2Array() const { - godot_pool_vector2_array ret = godot::api->godot_variant_as_pool_vector2_array(&_godot_variant); + pandemonium_pool_vector2_array ret = godot::api->pandemonium_variant_as_pool_vector2_array(&_pandemonium_variant); return PoolVector2Array(ret); } Variant::operator PoolVector3Array() const { - godot_pool_vector3_array ret = godot::api->godot_variant_as_pool_vector3_array(&_godot_variant); + pandemonium_pool_vector3_array ret = godot::api->pandemonium_variant_as_pool_vector3_array(&_pandemonium_variant); return PoolVector3Array(ret); } Variant::operator PoolColorArray() const { - godot_pool_color_array ret = godot::api->godot_variant_as_pool_color_array(&_godot_variant); + pandemonium_pool_color_array ret = godot::api->pandemonium_variant_as_pool_color_array(&_pandemonium_variant); return PoolColorArray(ret); } -Variant::operator godot_object *() const { - return godot::api->godot_variant_as_object(&_godot_variant); +Variant::operator pandemonium_object *() const { + return godot::api->pandemonium_variant_as_object(&_pandemonium_variant); } Variant::Type Variant::get_type() const { - return static_cast(godot::api->godot_variant_get_type(&_godot_variant)); + return static_cast(godot::api->pandemonium_variant_get_type(&_pandemonium_variant)); } Variant Variant::call(const String &method, const Variant **args, const int arg_count) { - godot_variant v = godot::api->godot_variant_call( - &_godot_variant, (godot_string *)&method, (const godot_variant **)args, arg_count, nullptr); + pandemonium_variant v = godot::api->pandemonium_variant_call( + &_pandemonium_variant, (pandemonium_string *)&method, (const pandemonium_variant **)args, arg_count, nullptr); return Variant(v); } bool Variant::has_method(const String &method) { - return godot::api->godot_variant_has_method(&_godot_variant, (godot_string *)&method); + return godot::api->pandemonium_variant_has_method(&_pandemonium_variant, (pandemonium_string *)&method); } bool Variant::operator==(const Variant &b) const { - return godot::api->godot_variant_operator_equal(&_godot_variant, &b._godot_variant); + return godot::api->pandemonium_variant_operator_equal(&_pandemonium_variant, &b._pandemonium_variant); } bool Variant::operator!=(const Variant &b) const { @@ -352,7 +352,7 @@ bool Variant::operator!=(const Variant &b) const { } bool Variant::operator<(const Variant &b) const { - return godot::api->godot_variant_operator_less(&_godot_variant, &b._godot_variant); + return godot::api->pandemonium_variant_operator_less(&_pandemonium_variant, &b._pandemonium_variant); } bool Variant::operator<=(const Variant &b) const { @@ -368,15 +368,15 @@ bool Variant::operator>=(const Variant &b) const { } bool Variant::hash_compare(const Variant &b) const { - return godot::api->godot_variant_hash_compare(&_godot_variant, &b._godot_variant); + return godot::api->pandemonium_variant_hash_compare(&_pandemonium_variant, &b._pandemonium_variant); } bool Variant::booleanize() const { - return godot::api->godot_variant_booleanize(&_godot_variant); + return godot::api->pandemonium_variant_booleanize(&_pandemonium_variant); } Variant::~Variant() { - godot::api->godot_variant_destroy(&_godot_variant); + godot::api->pandemonium_variant_destroy(&_pandemonium_variant); } } // namespace godot diff --git a/test/gdexample.gdnlib b/test/gdexample.gdnlib index 9744b98..a7f9a97 100644 --- a/test/gdexample.gdnlib +++ b/test/gdexample.gdnlib @@ -2,7 +2,7 @@ singleton=false load_once=true -symbol_prefix="godot_" +symbol_prefix="pandemonium_" reloadable=false [entry] diff --git a/test/src/init.cpp b/test/src/init.cpp index 9714970..7242a3d 100644 --- a/test/src/init.cpp +++ b/test/src/init.cpp @@ -86,17 +86,17 @@ public: }; /** GDNative Initialize **/ -extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) { +extern "C" void GDN_EXPORT pandemonium_gdnative_init(pandemonium_gdnative_init_options *o) { godot::Godot::gdnative_init(o); } /** GDNative Terminate **/ -extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) { +extern "C" void GDN_EXPORT pandemonium_gdnative_terminate(pandemonium_gdnative_terminate_options *o) { godot::Godot::gdnative_terminate(o); } /** NativeScript Initialize **/ -extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) { +extern "C" void GDN_EXPORT pandemonium_nativescript_init(void *handle) { godot::Godot::nativescript_init(handle); godot::register_class();