Relintai/gdnative_cpp
1
0
Fork 0
mirror of https://github.com/Relintai/gdnative_cpp.git synced 2025-02-04 16:15:59 +01:00
Code Issues Packages Projects Releases Wiki Activity

Mass api renames.

Browse Source
This commit is contained in:
Relintai 2023-05-31 13:31:45 +02:00
parent 7efc4247e1
commit 663ee4de7a
25 changed files with 719 additions and 719 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.github/workflows_off/ci.yml vendored
View File

@ -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

4
CMakeLists.txt
View File

@ -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)

6
README.md
View File

@ -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<SimpleClass>();

54
binding_generator.py
View File

@ -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)

6
include/core/Array.hpp
View File

@ -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:

6
include/core/Dictionary.hpp
View File

@ -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:

206
include/core/Godot.hpp
View File

@ -35,7 +35,7 @@
#include <cstring>
#include <gdnative_api_struct.gen.h>
#include <nativescript/godot_nativescript.h>
#include <nativescript/pandemonium_nativescript.h>
#include <typeinfo>
#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 <class T>
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 <class T>
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 <class T>
@ -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::GDNativeLibrary>((godot_object *)godot::gdnlib));
// script->set_library(get_wrapper<godot::GDNativeLibrary>((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<T>(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<T>(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<Name>(); \
@ -181,7 +181,7 @@ struct _ArgCast<Variant> {
// instance and destroy funcs
template <class T>
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 <class T>
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 <class T>
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<T>;
pandemonium_instance_create_func create = {};
create.create_func = _pandemonium_class_instance_func<T>;
godot_instance_destroy_func destroy = {};
destroy.destroy_func = _godot_class_destroy_func<T>;
pandemonium_instance_destroy_func destroy = {};
destroy.destroy_func = _pandemonium_class_destroy_func<T>;
_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 <class T>
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<T>;
pandemonium_instance_create_func create = {};
create.create_func = _pandemonium_class_instance_func<T>;
godot_instance_destroy_func destroy = {};
destroy.destroy_func = _godot_class_destroy_func<T>;
pandemonium_instance_destroy_func destroy = {};
destroy.destroy_func = _pandemonium_class_destroy_func<T>;
_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 <class T, class R, class... args>
const char *___get_method_class_name(R (T::*p)(args... a)) {
@ -297,9 +297,9 @@ struct _WrappedMethod<T, void, As...> {
};
template <class T, class R, class... As>
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<T, R, As...> *method = (_WrappedMethod<T, R, As...> *)method_data;
@ -315,14 +315,14 @@ godot_variant __wrapped_method(godot_object *, void *method_data, void *user_dat
template <class T, class R, class... As>
void *___make_wrapper_function(R (T::*f)(As...)) {
using MethodType = _WrappedMethod<T, R, As...>;
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 <class T, class R, class... As>
__godot_wrapper_method ___get_wrapper_function(R (T::* /*f*/)(As...)) {
return (__godot_wrapper_method)&__wrapped_method<T, R, As...>;
__pandemonium_wrapper_method ___get_wrapper_function(R (T::* /*f*/)(As...)) {
return (__pandemonium_wrapper_method)&__wrapped_method<T, R, As...>;
}
template <class T, class R, class... A>
@ -331,28 +331,28 @@ void *___make_wrapper_function(R (T::*f)(A...) const) {
}
template <class T, class R, class... A>
__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 <class M>
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 <class D, class B, class R, class... As>
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<B, D>::value, "Explicit class must derive from method class");
register_method(name, static_cast<R (D::*)(As...)>(method_ptr), rpc_type);
}
@ -360,7 +360,7 @@ void register_method_explicit(const char *name, R (B::*method_ptr)(As...),
template <class T, class P>
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<T, P> *set_func = (_PropertySetFunc<T, P> *)method_data;
T *obj = (T *)user_data;
@ -374,12 +374,12 @@ template <class T, class P>
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<T, P> *get_func = (_PropertyGetFunc<T, P> *)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 <class T, class P>
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<T, P> *set_func = (_PropertyDefaultSetFunc<T, P> *)method_data;
T *obj = (T *)user_data;
@ -405,12 +405,12 @@ struct _PropertyDefaultSetFunc {
template <class T, class P>
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<T, P> *get_func = (_PropertyDefaultGetFunc<T, P> *)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 <class T, class P>
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<Object>(def_val.operator godot_object *());
Object *o = detail::get_wrapper<Object>(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<T, P> *wrapped_set =
(_PropertyDefaultSetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyDefaultSetFunc<T, P>));
(_PropertyDefaultSetFunc<T, P> *)godot::api->pandemonium_alloc(sizeof(_PropertyDefaultSetFunc<T, P>));
wrapped_set->f = var;
_PropertyDefaultGetFunc<T, P> *wrapped_get =
(_PropertyDefaultGetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyDefaultGetFunc<T, P>));
(_PropertyDefaultGetFunc<T, P> *)godot::api->pandemonium_alloc(sizeof(_PropertyDefaultGetFunc<T, P>));
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<T, P>::_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<T, P>::_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 <class T, class P>
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<T, P> *wrapped_set = (_PropertySetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertySetFunc<T, P>));
_PropertySetFunc<T, P> *wrapped_set = (_PropertySetFunc<T, P> *)godot::api->pandemonium_alloc(sizeof(_PropertySetFunc<T, P>));
wrapped_set->f = setter;
_PropertyGetFunc<T, P> *wrapped_get = (_PropertyGetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyGetFunc<T, P>));
_PropertyGetFunc<T, P> *wrapped_get = (_PropertyGetFunc<T, P> *)godot::api->pandemonium_alloc(sizeof(_PropertyGetFunc<T, P>));
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<T, P>::_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<T, P>::_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 <class T, class P>
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 <class T>
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 <class T>
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<T>(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;
}
}

26
include/core/GodotGlobal.hpp
View File

@ -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);

4
include/core/NodePath.hpp
View File

@ -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;
}

182
include/core/PoolArrays.hpp
View File

@ -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);
}
};

4
include/core/RID.hpp
View File

@ -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;

10
include/core/String.hpp
View File

@ -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);

8
include/core/Variant.hpp
View File

@ -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 <typename T>
operator T *() const { return static_cast<T *>(T::___get_from_variant(*this)); }

2
include/core/Wrapped.hpp
View File

@ -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;
};

88
src/core/Array.cpp
View File

@ -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<Variant *>(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<const Variant *>(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

34
src/core/Dictionary.cpp
View File

@ -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<Variant *>(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<Variant *>(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

84
src/core/GodotGlobal.cpp
View File

@ -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

34
src/core/NodePath.cpp
View File

@ -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

256
src/core/PoolArrays.cpp
View File

@ -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

14
src/core/RID.cpp
View File

@ -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 {

228
src/core/String.cpp
View File

@ -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<wchar_t *>(godot::api->godot_string_operator_index(&_godot_string, idx));
return *const_cast<wchar_t *>(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);
}

2
src/core/TagDB.cpp
View File

@ -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);
}

164
src/core/Variant.cpp
View File

@ -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<Type>(godot::api->godot_variant_get_type(&_godot_variant));
return static_cast<Type>(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

2
test/gdexample.gdnlib
View File

@ -2,7 +2,7 @@
singleton=false
load_once=true
symbol_prefix="godot_"
symbol_prefix="pandemonium_"
reloadable=false
[entry]

6
test/src/init.cpp
View File

@ -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<SimpleClass>();