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

implemented instance binding data usage 

This commit changes the way C++ wrapper classes work.
Previously, wrapper classes were merely wrapper *interfaces*.
They used the `this` pointer to store the actual foreign Godot
Object.

With the NativeScript 1.1 extension it is now possible to have
low-overhead language binding data attached to Objects.

The C++ bindings use that feature to implement *proper* wrappers
and enable regular C++ inheritance usage that way.

Some things might still be buggy and untested, but the C++
SimpleDemo works with those changes.
pull/155/head
karroffel 2018-02-11 15:50:01 +01:00
parent 499300ea6a
commit e9517a7b3b
926 changed files with 97309 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -16,3 +16,8 @@ logs/*
*.pdb
*.lib
bin
*.config
*.creator
*.creator.user
*.files
*.includes

88
binding_generator.py
View File

@ -120,13 +120,42 @@ def generate_class_header(used_classes, c):
# generate the class definition here
source.append("class " + class_name + ("" if c["base_class"] == "" else (" : public " + strip_name(c["base_class"])) ) + " {")
if c["base_class"] == "":
# this is Object
source.append("")
source.append("public:")
source.append("\tgodot_object *_owner;")
source.append("")
# TODO decide what to do about virtual methods
# source.append("static void _register_methods();")
# source.append("")
if c["singleton"]:
source.append("\tstatic " + class_name + " *_singleton;")
source.append("")
source.append("\t" + class_name + "();")
source.append("")
source.append("public:")
source.append("")
# ___get_class_name
source.append("\tstatic inline char *___get_class_name() { return (char *) \"" + strip_name(c["name"]) + "\"; }")
if c["singleton"]:
source.append("\tstatic inline " + class_name + " *get_singleton()")
source.append("\t{")
source.append("\t\tif (!" + class_name + "::_singleton) {")
source.append("\t\t\t" + class_name + "::_singleton = new " + class_name + ";")
source.append("\t\t}")
source.append("\t\treturn " + class_name + "::_singleton;")
source.append("\t}")
source.append("")
source.append("\tstatic inline Object *___get_from_variant(Variant a) { return (Object *) a; }")
# godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");"
# ___get_class_name
source.append("\tstatic inline const char *___get_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 (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }")
enum_values = []
@ -146,6 +175,8 @@ def generate_class_header(used_classes, c):
if c["instanciable"]:
source.append("")
source.append("")
source.append("\tstatic void *operator new(size_t);")
source.append("\tstatic void operator delete(void *);")
@ -156,7 +187,8 @@ def generate_class_header(used_classes, c):
method_signature = ""
method_signature += "static " if c["singleton"] else ""
# TODO decide what to do about virtual methods
# method_signature += "virtual " if method["is_virtual"] else ""
method_signature += make_gdnative_type(method["return_type"])
method_name = escape_cpp(method["name"])
method_signature += method_name + "("
@ -224,7 +256,7 @@ def generate_class_header(used_classes, c):
vararg_templates += "\ttemplate <class... Args> " + method_signature + "Args... args){\n\t\treturn " + method_name + "(" + method_arguments + "Array::make(args...));\n\t}\n"""
method_signature += "const Array& __var_args = Array()"
method_signature += ")" + (" const" if method["is_const"] and not c["singleton"] else "")
method_signature += ")" + (" const" if method["is_const"] else "")
source.append("\t" + method_signature + ";")
@ -279,23 +311,20 @@ def generate_class_implementation(icalls, used_classes, c):
source.append("namespace godot {")
core_object_name = ("___static_object_" + strip_name(c["name"])) if c["singleton"] else "this"
core_object_name = "this"
source.append("")
source.append("")
if c["singleton"]:
source.append("static godot_object *" + core_object_name + ";")
source.append("" + class_name + " *" + class_name + "::_singleton = NULL;")
source.append("")
source.append("")
# FIXME Test if inlining has a huge impact on binary size
source.append("static inline void ___singleton_init()")
source.append("{")
source.append("\tif (" + core_object_name + " == nullptr) {")
source.append("\t\t" + core_object_name + " = godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");")
source.append("\t}")
source.append(class_name + "::" + class_name + "() {")
source.append("\t_owner = godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");")
source.append("}")
source.append("")
@ -311,7 +340,7 @@ def generate_class_implementation(icalls, used_classes, c):
source.append("void " + strip_name(c["name"]) + "::operator delete(void *ptr)")
source.append("{")
source.append("\tgodot::api->godot_object_destroy((godot_object *)ptr);")
source.append("\tgodot::api->godot_object_destroy(((Object *)ptr)->_owner);")
source.append("}")
for method in c["methods"]:
@ -332,18 +361,12 @@ def generate_class_implementation(icalls, used_classes, c):
method_signature += ", "
method_signature += "const Array& __var_args"
method_signature += ")" + (" const" if method["is_const"] and not c["singleton"] else "")
method_signature += ")" + (" const" if method["is_const"] else "")
source.append(method_signature + " {")
if c["singleton"]:
source.append("\t___singleton_init();")
source.append("\tstatic godot_method_bind *mb = nullptr;")
source.append("\tif (mb == nullptr) {")
source.append("\tstatic godot_method_bind *mb = nullptr;")
source.append("\tif (mb == nullptr) {")
source.append("\t\tmb = godot::api->godot_method_bind_get_method(\"" + c["name"] +"\", \"" + method["name"] + "\");")
source.append("\t}")
@ -408,7 +431,7 @@ def generate_class_implementation(icalls, used_classes, c):
source.append("")
source.append("\tVariant __result;")
source.append("\t*(godot_variant *) &__result = godot::api->godot_method_bind_call(mb, (godot_object *) " + core_object_name + ", (const godot_variant **) __args, " + size + ", nullptr);")
source.append("\t*(godot_variant *) &__result = godot::api->godot_method_bind_call(mb, ((const Object *) " + core_object_name + ")->_owner, (const godot_variant **) __args, " + size + ", nullptr);")
source.append("")
@ -424,7 +447,7 @@ def generate_class_implementation(icalls, used_classes, c):
if is_reference_type(method["return_type"]):
cast += "Ref<" + strip_name(method["return_type"]) + ">::__internal_constructor(__result);"
else:
cast += "(" + strip_name(method["return_type"]) + " *) (Object *) __result;"
cast += "(" + strip_name(method["return_type"]) + " *) " + strip_name(method["return_type"] + "::___get_from_variant(") + "__result);"
else:
cast += "__result;"
source.append("\treturn " + cast)
@ -445,7 +468,7 @@ def generate_class_implementation(icalls, used_classes, c):
icall_name = get_icall_name(icall_sig)
return_statement += icall_name + "(mb, (godot_object *) " + core_object_name
return_statement += icall_name + "(mb, (const Object *) " + core_object_name
for arg in method["arguments"]:
return_statement += ", " + escape_cpp(arg["name"]) + (".ptr()" if is_reference_type(arg["type"]) else "")
@ -494,7 +517,7 @@ def generate_icall_header(icalls):
method_signature = ""
method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, godot_object *inst"
method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, const Object *inst"
for arg in args:
method_signature += ", const "
@ -547,7 +570,7 @@ def generate_icall_implementation(icalls):
method_signature = ""
method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, godot_object *inst"
method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, const Object *inst"
for i, arg in enumerate(args):
method_signature += ", const "
@ -568,7 +591,7 @@ def generate_icall_implementation(icalls):
source.append(method_signature + " {")
if ret_type != "void":
source.append("\t" + return_type(ret_type) + "ret;")
source.append("\t" + ("godot_object *" if is_class_type(ret_type) else return_type(ret_type)) + "ret;")
if is_class_type(ret_type):
source.append("\tret = nullptr;")
@ -581,7 +604,7 @@ def generate_icall_implementation(icalls):
if is_primitive(arg) or is_core_type(arg):
wrapped_argument += "(void *) &arg" + str(i)
else:
wrapped_argument += "(void *) arg" + str(i)
wrapped_argument += "(void *) arg" + str(i) + "->_owner"
wrapped_argument += ","
source.append(wrapped_argument)
@ -589,10 +612,13 @@ def generate_icall_implementation(icalls):
source.append("\t};")
source.append("")
source.append("\tgodot::api->godot_method_bind_ptrcall(mb, inst, args, " + ("nullptr" if ret_type == "void" else "&ret") + ");")
source.append("\tgodot::api->godot_method_bind_ptrcall(mb, inst->_owner, args, " + ("nullptr" if ret_type == "void" else "&ret") + ");")
if ret_type != "void":
source.append("\treturn ret;")
if is_class_type(ret_type):
source.append("\treturn (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, ret);")
else:
source.append("\treturn ret;")
source.append("}")

33
include/core/Godot.hpp
View File

@ -23,35 +23,14 @@ namespace godot {
template<class T>
T *as(Object *obj)
{
return (T *) godot::nativescript_api->godot_nativescript_get_userdata(obj);
return (T *) godot::nativescript_api->godot_nativescript_get_userdata(obj->_owner);
}
template<class T>
class GodotScript {
public:
T *owner;
// GodotScript() {}
void _init() {}
static const char *___get_base_type_name()
{
return T::___get_class_name();
}
static GodotScript<T> *___get_from_variant(Variant a)
{
return as<GodotScript<T> >((Object *) a);
}
static void _register_methods() {}
};
#define GODOT_CLASS(Name) \
#define GODOT_CLASS(Name, Base) \
public: inline static const char *___get_type_name() { return static_cast<const char *>(#Name); } \
inline static const char *___get_base_type_name() { return Base::___get_class_name(); } \
inline static Object *___get_from_variant(godot::Variant a) { return (godot::Object *) godot::as<Name>(godot::Object::___get_from_variant(a)); } \
private:
#define GODOT_SUBCLASS(Name, Base) \
@ -94,7 +73,7 @@ template<class T>
void *_godot_class_instance_func(godot_object *p, void *method_data)
{
T *d = new T();
*(godot_object **) &d->owner = p;
d->_owner = p;
d->_init();
return d;
}
@ -369,7 +348,7 @@ void register_property(const char *name, P (T::*var), P default_value, godot_met
usage = (godot_property_usage_flags) ((int) usage | GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE);
if (def_val.get_type() == Variant::OBJECT) {
Object *o = def_val;
Object *o = P::___get_from_variant(def_val);
if (o && o->is_class("Resource")) {
hint = (godot_property_hint) ((int) hint | GODOT_PROPERTY_HINT_RESOURCE_TYPE);
hint_string = o->get_class();

3
include/core/GodotGlobal.hpp
View File

@ -10,6 +10,7 @@ namespace godot {
extern "C" const godot_gdnative_core_api_struct *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;
class Godot {
@ -21,6 +22,7 @@ public:
static void gdnative_init(godot_gdnative_init_options *o);
static void gdnative_terminate(godot_gdnative_terminate_options *o);
static void nativescript_init(void *handle);
static void nativescript_terminate(void *handle);
template <class... Args>
static void print(const String& fmt, Args... values) {
@ -32,6 +34,7 @@ public:
struct _RegisterState {
static void *nativescript_handle;
static int language_index;
};
}

2
include/core/Variant.hpp
View File

@ -225,7 +225,7 @@ public:
operator NodePath() const;
operator RID() const;
operator Object*() const;
operator godot_object*() const;
operator Dictionary() const;
operator Array() const;

42
include/gen/ARVRAnchor.hpp Normal file
View File

@ -0,0 +1,42 @@
#ifndef GODOT_CPP_ARVRANCHOR_HPP
#define GODOT_CPP_ARVRANCHOR_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Spatial.hpp>
namespace godot {
class ARVRAnchor : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ARVRAnchor"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ARVRAnchor *_new();
// methods
void set_anchor_id(const int64_t anchor_id);
int64_t get_anchor_id() const;
String get_anchor_name() const;
bool get_is_active() const;
Vector3 get_size() const;
Plane get_plane() const;
};
}
#endif

36
include/gen/ARVRCamera.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_ARVRCAMERA_HPP
#define GODOT_CPP_ARVRCAMERA_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Camera.hpp>
namespace godot {
class ARVRCamera : public Camera {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ARVRCamera"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ARVRCamera *_new();
// methods
};
}
#endif

47
include/gen/ARVRController.hpp Normal file
View File

@ -0,0 +1,47 @@
#ifndef GODOT_CPP_ARVRCONTROLLER_HPP
#define GODOT_CPP_ARVRCONTROLLER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <ARVRPositionalTracker.hpp>
#include <Spatial.hpp>
namespace godot {
class ARVRController : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ARVRController"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ARVRController *_new();
// methods
void set_controller_id(const int64_t controller_id);
int64_t get_controller_id() const;
String get_controller_name() const;
int64_t get_joystick_id() const;
int64_t is_button_pressed(const int64_t button) const;
double get_joystick_axis(const int64_t axis) const;
bool get_is_active() const;
ARVRPositionalTracker::TrackerHand get_hand() const;
double get_rumble() const;
void set_rumble(const double rumble);
};
}
#endif

66
include/gen/ARVRInterface.hpp Normal file
View File

@ -0,0 +1,66 @@
#ifndef GODOT_CPP_ARVRINTERFACE_HPP
#define GODOT_CPP_ARVRINTERFACE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <ARVRInterface.hpp>
#include <Reference.hpp>
namespace godot {
class ARVRInterface : public Reference {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ARVRInterface"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum Tracking_status {
ARVR_NOT_TRACKING = 4,
ARVR_NORMAL_TRACKING = 0,
ARVR_EXCESSIVE_MOTION = 1,
ARVR_UNKNOWN_TRACKING = 3,
ARVR_INSUFFICIENT_FEATURES = 2,
};
enum Eyes {
EYE_LEFT = 1,
EYE_MONO = 0,
EYE_RIGHT = 2,
};
enum Capabilities {
ARVR_EXTERNAL = 8,
ARVR_STEREO = 2,
ARVR_MONO = 1,
ARVR_AR = 4,
ARVR_NONE = 0,
};
// constants
// methods
String get_name() const;
int64_t get_capabilities() const;
bool is_primary();
void set_is_primary(const bool enable);
bool is_initialized();
void set_is_initialized(const bool initialized);
bool initialize();
void uninitialize();
ARVRInterface::Tracking_status get_tracking_status() const;
Vector2 get_render_targetsize();
bool is_stereo();
bool get_anchor_detection_is_enabled() const;
void set_anchor_detection_is_enabled(const bool enable);
};
}
#endif

36
include/gen/ARVRInterfaceGDNative.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_ARVRINTERFACEGDNATIVE_HPP
#define GODOT_CPP_ARVRINTERFACEGDNATIVE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <ARVRInterface.hpp>
namespace godot {
class ARVRInterfaceGDNative : public ARVRInterface {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ARVRInterfaceGDNative"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ARVRInterfaceGDNative *_new();
// methods
};
}
#endif

38
include/gen/ARVROrigin.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_ARVRORIGIN_HPP
#define GODOT_CPP_ARVRORIGIN_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Spatial.hpp>
namespace godot {
class ARVROrigin : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ARVROrigin"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ARVROrigin *_new();
// methods
void set_world_scale(const double world_scale);
double get_world_scale() const;
};
}
#endif

59
include/gen/ARVRPositionalTracker.hpp Normal file
View File

@ -0,0 +1,59 @@
#ifndef GODOT_CPP_ARVRPOSITIONALTRACKER_HPP
#define GODOT_CPP_ARVRPOSITIONALTRACKER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <ARVRServer.hpp>
#include <ARVRPositionalTracker.hpp>
#include <Object.hpp>
namespace godot {
class ARVRPositionalTracker : public Object {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ARVRPositionalTracker"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum TrackerHand {
TRACKER_HAND_UNKNOWN = 0,
TRACKER_LEFT_HAND = 1,
TRACKER_RIGHT_HAND = 2,
};
// constants
static ARVRPositionalTracker *_new();
// methods
ARVRServer::TrackerType get_type() const;
String get_name() const;
int64_t get_joy_id() const;
bool get_tracks_orientation() const;
Basis get_orientation() const;
bool get_tracks_position() const;
Vector3 get_position() const;
ARVRPositionalTracker::TrackerHand get_hand() const;
Transform get_transform(const bool adjust_by_reference_frame) const;
void _set_type(const int64_t type);
void _set_name(const String name);
void _set_joy_id(const int64_t joy_id);
void _set_orientation(const Basis orientation);
void _set_rw_position(const Vector3 rw_position);
double get_rumble() const;
void set_rumble(const double rumble);
};
}
#endif

76
include/gen/ARVRServer.hpp Normal file
View File

@ -0,0 +1,76 @@
#ifndef GODOT_CPP_ARVRSERVER_HPP
#define GODOT_CPP_ARVRSERVER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Object.hpp>
namespace godot {
class ARVRInterface;
class ARVRPositionalTracker;
class ARVRServer : public Object {
static ARVRServer *_singleton;
ARVRServer();
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline ARVRServer *get_singleton()
{
if (!ARVRServer::_singleton) {
ARVRServer::_singleton = new ARVRServer;
}
return ARVRServer::_singleton;
}
static inline const char *___get_class_name() { return (const char *) "ARVRServer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum RotationMode {
RESET_BUT_KEEP_TILT = 1,
DONT_RESET_ROTATION = 2,
RESET_FULL_ROTATION = 0,
};
enum TrackerType {
TRACKER_BASESTATION = 2,
TRACKER_CONTROLLER = 1,
TRACKER_ANY = 255,
TRACKER_ANY_KNOWN = 127,
TRACKER_ANCHOR = 4,
TRACKER_UNKNOWN = 128,
};
// constants
// methods
double get_world_scale() const;
void set_world_scale(const double arg0);
Transform get_reference_frame() const;
void center_on_hmd(const int64_t rotation_mode, const bool keep_height);
Transform get_hmd_transform();
int64_t get_interface_count() const;
Ref<ARVRInterface> get_interface(const int64_t idx) const;
Array get_interfaces() const;
Ref<ARVRInterface> find_interface(const String name) const;
int64_t get_tracker_count() const;
ARVRPositionalTracker *get_tracker(const int64_t idx) const;
Ref<ARVRInterface> get_primary_interface() const;
void set_primary_interface(const Ref<ARVRInterface> interface);
int64_t get_last_process_usec();
int64_t get_last_commit_usec();
int64_t get_last_frame_usec();
};
}
#endif

56
include/gen/AStar.hpp Normal file
View File

@ -0,0 +1,56 @@
#ifndef GODOT_CPP_ASTAR_HPP
#define GODOT_CPP_ASTAR_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Reference.hpp>
namespace godot {
class AStar : public Reference {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AStar"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AStar *_new();
// methods
double _estimate_cost(const int64_t from_id, const int64_t to_id);
double _compute_cost(const int64_t from_id, const int64_t to_id);
int64_t get_available_point_id() const;
void add_point(const int64_t id, const Vector3 position, const double weight_scale = 1);
Vector3 get_point_position(const int64_t id) const;
void set_point_position(const int64_t id, const Vector3 position);
double get_point_weight_scale(const int64_t id) const;
void set_point_weight_scale(const int64_t id, const double weight_scale);
void remove_point(const int64_t id);
bool has_point(const int64_t id) const;
Array get_points();
PoolIntArray get_point_connections(const int64_t id);
void connect_points(const int64_t id, const int64_t to_id, const bool bidirectional = true);
void disconnect_points(const int64_t id, const int64_t to_id);
bool are_points_connected(const int64_t id, const int64_t to_id) const;
void clear();
int64_t get_closest_point(const Vector3 to_position) const;
Vector3 get_closest_position_in_segment(const Vector3 to_position) const;
PoolVector3Array get_point_path(const int64_t from_id, const int64_t to_id);
PoolIntArray get_id_path(const int64_t from_id, const int64_t to_id);
};
}
#endif

51
include/gen/AcceptDialog.hpp Normal file
View File

@ -0,0 +1,51 @@
#ifndef GODOT_CPP_ACCEPTDIALOG_HPP
#define GODOT_CPP_ACCEPTDIALOG_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <WindowDialog.hpp>
namespace godot {
class Button;
class Label;
class Object;
class AcceptDialog : public WindowDialog {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AcceptDialog"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AcceptDialog *_new();
// methods
void _ok();
Button *get_ok();
Label *get_label();
void set_hide_on_ok(const bool enabled);
bool get_hide_on_ok() const;
Button *add_button(const String text, const bool right = false, const String action = "");
Button *add_cancel(const String name);
void _builtin_text_entered(const String arg0);
void register_text_enter(const Object *line_edit);
void _custom_action(const String arg0);
void set_text(const String text);
String get_text() const;
};
}
#endif

57
include/gen/AnimatedSprite.hpp Normal file
View File

@ -0,0 +1,57 @@
#ifndef GODOT_CPP_ANIMATEDSPRITE_HPP
#define GODOT_CPP_ANIMATEDSPRITE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Node2D.hpp>
namespace godot {
class SpriteFrames;
class AnimatedSprite : public Node2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AnimatedSprite"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AnimatedSprite *_new();
// methods
void set_sprite_frames(const Ref<SpriteFrames> sprite_frames);
Ref<SpriteFrames> get_sprite_frames() const;
void set_animation(const String animation);
String get_animation() const;
void _set_playing(const bool playing);
bool _is_playing() const;
void play(const String anim = "");
void stop();
bool is_playing() const;
void set_centered(const bool centered);
bool is_centered() const;
void set_offset(const Vector2 offset);
Vector2 get_offset() const;
void set_flip_h(const bool flip_h);
bool is_flipped_h() const;
void set_flip_v(const bool flip_v);
bool is_flipped_v() const;
void set_frame(const int64_t frame);
int64_t get_frame() const;
void _res_changed();
};
}
#endif

49
include/gen/AnimatedSprite3D.hpp Normal file
View File

@ -0,0 +1,49 @@
#ifndef GODOT_CPP_ANIMATEDSPRITE3D_HPP
#define GODOT_CPP_ANIMATEDSPRITE3D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <SpriteBase3D.hpp>
namespace godot {
class SpriteFrames;
class AnimatedSprite3D : public SpriteBase3D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AnimatedSprite3D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AnimatedSprite3D *_new();
// methods
void set_sprite_frames(const Ref<SpriteFrames> sprite_frames);
Ref<SpriteFrames> get_sprite_frames() const;
void set_animation(const String animation);
String get_animation() const;
void _set_playing(const bool playing);
bool _is_playing() const;
void play(const String anim = "");
void stop();
bool is_playing() const;
void set_frame(const int64_t frame);
int64_t get_frame() const;
void _res_changed();
};
}
#endif

96
include/gen/Animation.hpp Normal file
View File

@ -0,0 +1,96 @@
#ifndef GODOT_CPP_ANIMATION_HPP
#define GODOT_CPP_ANIMATION_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Animation.hpp>
#include <Resource.hpp>
namespace godot {
class Animation;
class Animation : public Resource {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "Animation"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum TrackType {
TYPE_METHOD = 2,
TYPE_VALUE = 0,
TYPE_TRANSFORM = 1,
};
enum UpdateMode {
UPDATE_TRIGGER = 2,
UPDATE_DISCRETE = 1,
UPDATE_CONTINUOUS = 0,
};
enum InterpolationType {
INTERPOLATION_NEAREST = 0,
INTERPOLATION_CUBIC = 2,
INTERPOLATION_LINEAR = 1,
};
// constants
static Animation *_new();
// methods
int64_t add_track(const int64_t type, const int64_t at_position = -1);
void remove_track(const int64_t idx);
int64_t get_track_count() const;
Animation::TrackType track_get_type(const int64_t idx) const;
NodePath track_get_path(const int64_t idx) const;
void track_set_path(const int64_t idx, const NodePath path);
int64_t find_track(const NodePath path) const;
void track_move_up(const int64_t idx);
void track_move_down(const int64_t idx);
void track_set_imported(const int64_t idx, const bool imported);
bool track_is_imported(const int64_t idx) const;
void track_set_enabled(const int64_t idx, const bool enabled);
bool track_is_enabled(const int64_t idx) const;
int64_t transform_track_insert_key(const int64_t idx, const double time, const Vector3 location, const Quat rotation, const Vector3 scale);
void track_insert_key(const int64_t idx, const double time, const Variant key, const double transition = 1);
void track_remove_key(const int64_t idx, const int64_t key_idx);
void track_remove_key_at_position(const int64_t idx, const double position);
void track_set_key_value(const int64_t idx, const int64_t key, const Variant value);
void track_set_key_transition(const int64_t idx, const int64_t key_idx, const double transition);
double track_get_key_transition(const int64_t idx, const int64_t key_idx) const;
int64_t track_get_key_count(const int64_t idx) const;
Variant track_get_key_value(const int64_t idx, const int64_t key_idx) const;
double track_get_key_time(const int64_t idx, const int64_t key_idx) const;
int64_t track_find_key(const int64_t idx, const double time, const bool exact = false) const;
void track_set_interpolation_type(const int64_t idx, const int64_t interpolation);
Animation::InterpolationType track_get_interpolation_type(const int64_t idx) const;
void track_set_interpolation_loop_wrap(const int64_t idx, const bool interpolation);
bool track_get_interpolation_loop_wrap(const int64_t idx) const;
Array transform_track_interpolate(const int64_t idx, const double time_sec) const;
void value_track_set_update_mode(const int64_t idx, const int64_t mode);
Animation::UpdateMode value_track_get_update_mode(const int64_t idx) const;
PoolIntArray value_track_get_key_indices(const int64_t idx, const double time_sec, const double delta) const;
PoolIntArray method_track_get_key_indices(const int64_t idx, const double time_sec, const double delta) const;
String method_track_get_name(const int64_t idx, const int64_t key_idx) const;
Array method_track_get_params(const int64_t idx, const int64_t key_idx) const;
void set_length(const double time_sec);
double get_length() const;
void set_loop(const bool enabled);
bool has_loop() const;
void set_step(const double size_sec);
double get_step() const;
void clear();
void copy_track(const int64_t track, const Ref<Animation> to_animation);
};
}
#endif

83
include/gen/AnimationPlayer.hpp Normal file
View File

@ -0,0 +1,83 @@
#ifndef GODOT_CPP_ANIMATIONPLAYER_HPP
#define GODOT_CPP_ANIMATIONPLAYER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AnimationPlayer.hpp>
#include <Node.hpp>
namespace godot {
class Object;
class Animation;
class AnimationPlayer : public Node {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AnimationPlayer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum AnimationProcessMode {
ANIMATION_PROCESS_IDLE = 1,
ANIMATION_PROCESS_PHYSICS = 0,
};
// constants
static AnimationPlayer *_new();
// methods
void _node_removed(const Object *arg0);
void _animation_changed();
Error add_animation(const String name, const Ref<Animation> animation);
void remove_animation(const String name);
void rename_animation(const String name, const String newname);
bool has_animation(const String name) const;
Ref<Animation> get_animation(const String name) const;
PoolStringArray get_animation_list() const;
void animation_set_next(const String anim_from, const String anim_to);
String animation_get_next(const String anim_from) const;
void set_blend_time(const String anim_from, const String anim_to, const double sec);
double get_blend_time(const String anim_from, const String anim_to) const;
void set_default_blend_time(const double sec);
double get_default_blend_time() const;
void play(const String name = "", const double custom_blend = -1, const double custom_speed = 1, const bool from_end = false);
void play_backwards(const String name = "", const double custom_blend = -1);
void stop(const bool reset = true);
bool is_playing() const;
void set_current_animation(const String anim);
String get_current_animation() const;
void set_assigned_animation(const String anim);
String get_assigned_animation() const;
void queue(const String name);
void clear_queue();
void set_active(const bool active);
bool is_active() const;
void set_speed_scale(const double speed);
double get_speed_scale() const;
void set_autoplay(const String name);
String get_autoplay() const;
void set_root(const NodePath path);
NodePath get_root() const;
String find_animation(const Ref<Animation> animation) const;
void clear_caches();
void set_animation_process_mode(const int64_t mode);
AnimationPlayer::AnimationProcessMode get_animation_process_mode() const;
double get_current_animation_position() const;
double get_current_animation_length() const;
void seek(const double seconds, const bool update = false);
void advance(const double delta);
};
}
#endif

118
include/gen/AnimationTreePlayer.hpp Normal file
View File

@ -0,0 +1,118 @@
#ifndef GODOT_CPP_ANIMATIONTREEPLAYER_HPP
#define GODOT_CPP_ANIMATIONTREEPLAYER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AnimationTreePlayer.hpp>
#include <Node.hpp>
namespace godot {
class Animation;
class AnimationTreePlayer : public Node {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AnimationTreePlayer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum AnimationProcessMode {
ANIMATION_PROCESS_IDLE = 1,
ANIMATION_PROCESS_PHYSICS = 0,
};
enum NodeType {
NODE_ANIMATION = 1,
NODE_OUTPUT = 0,
NODE_ONESHOT = 2,
NODE_MIX = 3,
NODE_TIMESCALE = 7,
NODE_TRANSITION = 9,
NODE_BLEND4 = 6,
NODE_BLEND3 = 5,
NODE_BLEND2 = 4,
NODE_TIMESEEK = 8,
};
// constants
static AnimationTreePlayer *_new();
// methods
void add_node(const int64_t type, const String id);
bool node_exists(const String node) const;
Error node_rename(const String node, const String new_name);
AnimationTreePlayer::NodeType node_get_type(const String id) const;
int64_t node_get_input_count(const String id) const;
String node_get_input_source(const String id, const int64_t idx) const;
void animation_node_set_animation(const String id, const Ref<Animation> animation);
Ref<Animation> animation_node_get_animation(const String id) const;
void animation_node_set_master_animation(const String id, const String source);
String animation_node_get_master_animation(const String id) const;
void animation_node_set_filter_path(const String id, const NodePath path, const bool enable);
void oneshot_node_set_fadein_time(const String id, const double time_sec);
double oneshot_node_get_fadein_time(const String id) const;
void oneshot_node_set_fadeout_time(const String id, const double time_sec);
double oneshot_node_get_fadeout_time(const String id) const;
void oneshot_node_set_autorestart(const String id, const bool enable);
void oneshot_node_set_autorestart_delay(const String id, const double delay_sec);
void oneshot_node_set_autorestart_random_delay(const String id, const double rand_sec);
bool oneshot_node_has_autorestart(const String id) const;
double oneshot_node_get_autorestart_delay(const String id) const;
double oneshot_node_get_autorestart_random_delay(const String id) const;
void oneshot_node_start(const String id);
void oneshot_node_stop(const String id);
bool oneshot_node_is_active(const String id) const;
void oneshot_node_set_filter_path(const String id, const NodePath path, const bool enable);
void mix_node_set_amount(const String id, const double ratio);
double mix_node_get_amount(const String id) const;
void blend2_node_set_amount(const String id, const double blend);
double blend2_node_get_amount(const String id) const;
void blend2_node_set_filter_path(const String id, const NodePath path, const bool enable);
void blend3_node_set_amount(const String id, const double blend);
double blend3_node_get_amount(const String id) const;
void blend4_node_set_amount(const String id, const Vector2 blend);
Vector2 blend4_node_get_amount(const String id) const;
void timescale_node_set_scale(const String id, const double scale);
double timescale_node_get_scale(const String id) const;
void timeseek_node_seek(const String id, const double seconds);
void transition_node_set_input_count(const String id, const int64_t count);
int64_t transition_node_get_input_count(const String id) const;
void transition_node_delete_input(const String id, const int64_t input_idx);
void transition_node_set_input_auto_advance(const String id, const int64_t input_idx, const bool enable);
bool transition_node_has_input_auto_advance(const String id, const int64_t input_idx) const;
void transition_node_set_xfade_time(const String id, const double time_sec);
double transition_node_get_xfade_time(const String id) const;
void transition_node_set_current(const String id, const int64_t input_idx);
int64_t transition_node_get_current(const String id) const;
void node_set_position(const String id, const Vector2 screen_position);
Vector2 node_get_position(const String id) const;
void remove_node(const String id);
Error connect_nodes(const String id, const String dst_id, const int64_t dst_input_idx);
bool are_nodes_connected(const String id, const String dst_id, const int64_t dst_input_idx) const;
void disconnect_nodes(const String id, const int64_t dst_input_idx);
void set_active(const bool enabled);
bool is_active() const;
void set_base_path(const NodePath path);
NodePath get_base_path() const;
void set_master_player(const NodePath nodepath);
NodePath get_master_player() const;
PoolStringArray get_node_list();
void set_animation_process_mode(const int64_t mode);
AnimationTreePlayer::AnimationProcessMode get_animation_process_mode() const;
void advance(const double delta);
void reset();
void recompute_caches();
};
}
#endif

95
include/gen/Area.hpp Normal file
View File

@ -0,0 +1,95 @@
#ifndef GODOT_CPP_AREA_HPP
#define GODOT_CPP_AREA_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Area.hpp>
#include <CollisionObject.hpp>
namespace godot {
class Object;
class Area : public CollisionObject {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "Area"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum SpaceOverride {
SPACE_OVERRIDE_COMBINE_REPLACE = 2,
SPACE_OVERRIDE_COMBINE = 1,
SPACE_OVERRIDE_REPLACE = 3,
SPACE_OVERRIDE_DISABLED = 0,
SPACE_OVERRIDE_REPLACE_COMBINE = 4,
};
// constants
static Area *_new();
// methods
void _body_enter_tree(const int64_t id);
void _body_exit_tree(const int64_t id);
void _area_enter_tree(const int64_t id);
void _area_exit_tree(const int64_t id);
void set_space_override_mode(const int64_t enable);
Area::SpaceOverride get_space_override_mode() const;
void set_gravity_is_point(const bool enable);
bool is_gravity_a_point() const;
void set_gravity_distance_scale(const double distance_scale);
double get_gravity_distance_scale() const;
void set_gravity_vector(const Vector3 vector);
Vector3 get_gravity_vector() const;
void set_gravity(const double gravity);
double get_gravity() const;
void set_angular_damp(const double angular_damp);
double get_angular_damp() const;
void set_linear_damp(const double linear_damp);
double get_linear_damp() const;
void set_priority(const double priority);
double get_priority() const;
void set_collision_mask(const int64_t collision_mask);
int64_t get_collision_mask() const;
void set_collision_layer(const int64_t collision_layer);
int64_t get_collision_layer() const;
void set_collision_mask_bit(const int64_t bit, const bool value);
bool get_collision_mask_bit(const int64_t bit) const;
void set_collision_layer_bit(const int64_t bit, const bool value);
bool get_collision_layer_bit(const int64_t bit) const;
void set_monitorable(const bool enable);
bool is_monitorable() const;
void set_monitoring(const bool enable);
bool is_monitoring() const;
Array get_overlapping_bodies() const;
Array get_overlapping_areas() const;
bool overlaps_body(const Object *body) const;
bool overlaps_area(const Object *area) const;
void _body_inout(const int64_t arg0, const RID arg1, const int64_t arg2, const int64_t arg3, const int64_t arg4);
void _area_inout(const int64_t arg0, const RID arg1, const int64_t arg2, const int64_t arg3, const int64_t arg4);
void set_audio_bus_override(const bool enable);
bool is_overriding_audio_bus() const;
void set_audio_bus(const String name);
String get_audio_bus() const;
void set_use_reverb_bus(const bool enable);
bool is_using_reverb_bus() const;
void set_reverb_bus(const String name);
String get_reverb_bus() const;
void set_reverb_amount(const double amount);
double get_reverb_amount() const;
void set_reverb_uniformity(const double amount);
double get_reverb_uniformity() const;
};
}
#endif

87
include/gen/Area2D.hpp Normal file
View File

@ -0,0 +1,87 @@
#ifndef GODOT_CPP_AREA2D_HPP
#define GODOT_CPP_AREA2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Area2D.hpp>
#include <CollisionObject2D.hpp>
namespace godot {
class Object;
class Area2D : public CollisionObject2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "Area2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum SpaceOverride {
SPACE_OVERRIDE_COMBINE_REPLACE = 2,
SPACE_OVERRIDE_COMBINE = 1,
SPACE_OVERRIDE_REPLACE = 3,
SPACE_OVERRIDE_DISABLED = 0,
SPACE_OVERRIDE_REPLACE_COMBINE = 4,
};
// constants
static Area2D *_new();
// methods
void _body_enter_tree(const int64_t id);
void _body_exit_tree(const int64_t id);
void _area_enter_tree(const int64_t id);
void _area_exit_tree(const int64_t id);
void set_space_override_mode(const int64_t space_override_mode);
Area2D::SpaceOverride get_space_override_mode() const;
void set_gravity_is_point(const bool enable);
bool is_gravity_a_point() const;
void set_gravity_distance_scale(const double distance_scale);
double get_gravity_distance_scale() const;
void set_gravity_vector(const Vector2 vector);
Vector2 get_gravity_vector() const;
void set_gravity(const double gravity);
double get_gravity() const;
void set_linear_damp(const double linear_damp);
double get_linear_damp() const;
void set_angular_damp(const double angular_damp);
double get_angular_damp() const;
void set_priority(const double priority);
double get_priority() const;
void set_collision_mask(const int64_t collision_mask);
int64_t get_collision_mask() const;
void set_collision_layer(const int64_t collision_layer);
int64_t get_collision_layer() const;
void set_collision_mask_bit(const int64_t bit, const bool value);
bool get_collision_mask_bit(const int64_t bit) const;
void set_collision_layer_bit(const int64_t bit, const bool value);
bool get_collision_layer_bit(const int64_t bit) const;
void set_monitoring(const bool enable);
bool is_monitoring() const;
void set_monitorable(const bool enable);
bool is_monitorable() const;
Array get_overlapping_bodies() const;
Array get_overlapping_areas() const;
bool overlaps_body(const Object *body) const;
bool overlaps_area(const Object *area) const;
void set_audio_bus_name(const String name);
String get_audio_bus_name() const;
void set_audio_bus_override(const bool enable);
bool is_overriding_audio_bus() const;
void _body_inout(const int64_t arg0, const RID arg1, const int64_t arg2, const int64_t arg3, const int64_t arg4);
void _area_inout(const int64_t arg0, const RID arg1, const int64_t arg2, const int64_t arg3, const int64_t arg4);
};
}
#endif

88
include/gen/ArrayMesh.hpp Normal file
View File

@ -0,0 +1,88 @@
#ifndef GODOT_CPP_ARRAYMESH_HPP
#define GODOT_CPP_ARRAYMESH_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Mesh.hpp>
#include <Mesh.hpp>
namespace godot {
class Material;
class ArrayMesh : public Mesh {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ArrayMesh"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum ArrayFormat {
ARRAY_FORMAT_WEIGHTS = 128,
ARRAY_FORMAT_COLOR = 8,
ARRAY_FORMAT_TEX_UV = 16,
ARRAY_FORMAT_TEX_UV2 = 32,
ARRAY_FORMAT_INDEX = 256,
ARRAY_FORMAT_BONES = 64,
ARRAY_FORMAT_VERTEX = 1,
ARRAY_FORMAT_TANGENT = 4,
ARRAY_FORMAT_NORMAL = 2,
};
enum ArrayType {
ARRAY_VERTEX = 0,
ARRAY_TEX_UV2 = 5,
ARRAY_MAX = 9,
ARRAY_BONES = 6,
ARRAY_NORMAL = 1,
ARRAY_WEIGHTS = 7,
ARRAY_COLOR = 3,
ARRAY_INDEX = 8,
ARRAY_TANGENT = 2,
ARRAY_TEX_UV = 4,
};
// constants
const static int ARRAY_WEIGHTS_SIZE = 4;
const static int NO_INDEX_ARRAY = -1;
static ArrayMesh *_new();
// methods
void add_blend_shape(const String name);
int64_t get_blend_shape_count() const;
String get_blend_shape_name(const int64_t index) const;
void clear_blend_shapes();
void set_blend_shape_mode(const int64_t mode);
Mesh::BlendShapeMode get_blend_shape_mode() const;
void add_surface_from_arrays(const int64_t primitive, const Array arrays, const Array blend_shapes = Array(), const int64_t compress_flags = 97792);
int64_t get_surface_count() const;
void surface_remove(const int64_t surf_idx);
void surface_update_region(const int64_t surf_idx, const int64_t offset, const PoolByteArray data);
int64_t surface_get_array_len(const int64_t surf_idx) const;
int64_t surface_get_array_index_len(const int64_t surf_idx) const;
int64_t surface_get_format(const int64_t surf_idx) const;
Mesh::PrimitiveType surface_get_primitive_type(const int64_t surf_idx) const;
void surface_set_material(const int64_t surf_idx, const Ref<Material> material);
Ref<Material> surface_get_material(const int64_t surf_idx) const;
void surface_set_name(const int64_t surf_idx, const String name);
String surface_get_name(const int64_t surf_idx) const;
Array surface_get_arrays(const int64_t surf_idx) const;
Array surface_get_blend_shape_arrays(const int64_t surf_idx) const;
void center_geometry();
void regen_normalmaps();
Error lightmap_unwrap(const Transform arg0, const double arg1);
void set_custom_aabb(const AABB aabb);
AABB get_custom_aabb() const;
};
}
#endif

45
include/gen/AtlasTexture.hpp Normal file
View File

@ -0,0 +1,45 @@
#ifndef GODOT_CPP_ATLASTEXTURE_HPP
#define GODOT_CPP_ATLASTEXTURE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Texture.hpp>
namespace godot {
class Texture;
class AtlasTexture : public Texture {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AtlasTexture"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AtlasTexture *_new();
// methods
void set_atlas(const Ref<Texture> atlas);
Ref<Texture> get_atlas() const;
void set_region(const Rect2 region);
Rect2 get_region() const;
void set_margin(const Rect2 margin);
Rect2 get_margin() const;
void set_filter_clip(const bool enable);
bool has_filter_clip() const;
};
}
#endif

36
include/gen/AudioBusLayout.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOBUSLAYOUT_HPP
#define GODOT_CPP_AUDIOBUSLAYOUT_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Resource.hpp>
namespace godot {
class AudioBusLayout : public Resource {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioBusLayout"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioBusLayout *_new();
// methods
};
}
#endif

33
include/gen/AudioEffect.hpp Normal file
View File

@ -0,0 +1,33 @@
#ifndef GODOT_CPP_AUDIOEFFECT_HPP
#define GODOT_CPP_AUDIOEFFECT_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Resource.hpp>
namespace godot {
class AudioEffect : public Resource {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffect"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
// methods
};
}
#endif

38
include/gen/AudioEffectAmplify.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_AUDIOEFFECTAMPLIFY_HPP
#define GODOT_CPP_AUDIOEFFECTAMPLIFY_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectAmplify : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectAmplify"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectAmplify *_new();
// methods
void set_volume_db(const double volume);
double get_volume_db() const;
};
}
#endif

36
include/gen/AudioEffectBandLimitFilter.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTBANDLIMITFILTER_HPP
#define GODOT_CPP_AUDIOEFFECTBANDLIMITFILTER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectFilter.hpp>
namespace godot {
class AudioEffectBandLimitFilter : public AudioEffectFilter {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectBandLimitFilter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectBandLimitFilter *_new();
// methods
};
}
#endif

36
include/gen/AudioEffectBandPassFilter.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTBANDPASSFILTER_HPP
#define GODOT_CPP_AUDIOEFFECTBANDPASSFILTER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectFilter.hpp>
namespace godot {
class AudioEffectBandPassFilter : public AudioEffectFilter {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectBandPassFilter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectBandPassFilter *_new();
// methods
};
}
#endif

54
include/gen/AudioEffectChorus.hpp Normal file
View File

@ -0,0 +1,54 @@
#ifndef GODOT_CPP_AUDIOEFFECTCHORUS_HPP
#define GODOT_CPP_AUDIOEFFECTCHORUS_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectChorus : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectChorus"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectChorus *_new();
// methods
void set_voice_count(const int64_t voices);
int64_t get_voice_count() const;
void set_voice_delay_ms(const int64_t voice_idx, const double delay_ms);
double get_voice_delay_ms(const int64_t voice_idx) const;
void set_voice_rate_hz(const int64_t voice_idx, const double rate_hz);
double get_voice_rate_hz(const int64_t voice_idx) const;
void set_voice_depth_ms(const int64_t voice_idx, const double depth_ms);
double get_voice_depth_ms(const int64_t voice_idx) const;
void set_voice_level_db(const int64_t voice_idx, const double level_db);
double get_voice_level_db(const int64_t voice_idx) const;
void set_voice_cutoff_hz(const int64_t voice_idx, const double cutoff_hz);
double get_voice_cutoff_hz(const int64_t voice_idx) const;
void set_voice_pan(const int64_t voice_idx, const double pan);
double get_voice_pan(const int64_t voice_idx) const;
void set_wet(const double amount);
double get_wet() const;
void set_dry(const double amount);
double get_dry() const;
};
}
#endif

50
include/gen/AudioEffectCompressor.hpp Normal file
View File

@ -0,0 +1,50 @@
#ifndef GODOT_CPP_AUDIOEFFECTCOMPRESSOR_HPP
#define GODOT_CPP_AUDIOEFFECTCOMPRESSOR_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectCompressor : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectCompressor"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectCompressor *_new();
// methods
void set_threshold(const double threshold);
double get_threshold() const;
void set_ratio(const double ratio);
double get_ratio() const;
void set_gain(const double gain);
double get_gain() const;
void set_attack_us(const double attack_us);
double get_attack_us() const;
void set_release_ms(const double release_ms);
double get_release_ms() const;
void set_mix(const double mix);
double get_mix() const;
void set_sidechain(const String sidechain);
String get_sidechain() const;
};
}
#endif

62
include/gen/AudioEffectDelay.hpp Normal file
View File

@ -0,0 +1,62 @@
#ifndef GODOT_CPP_AUDIOEFFECTDELAY_HPP
#define GODOT_CPP_AUDIOEFFECTDELAY_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectDelay : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectDelay"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectDelay *_new();
// methods
void set_dry(const double amount);
double get_dry();
void set_tap1_active(const bool amount);
bool is_tap1_active() const;
void set_tap1_delay_ms(const double amount);
double get_tap1_delay_ms() const;
void set_tap1_level_db(const double amount);
double get_tap1_level_db() const;
void set_tap1_pan(const double amount);
double get_tap1_pan() const;
void set_tap2_active(const bool amount);
bool is_tap2_active() const;
void set_tap2_delay_ms(const double amount);
double get_tap2_delay_ms() const;
void set_tap2_level_db(const double amount);
double get_tap2_level_db() const;
void set_tap2_pan(const double amount);
double get_tap2_pan() const;
void set_feedback_active(const bool amount);
bool is_feedback_active() const;
void set_feedback_delay_ms(const double amount);
double get_feedback_delay_ms() const;
void set_feedback_level_db(const double amount);
double get_feedback_level_db() const;
void set_feedback_lowpass(const double amount);
double get_feedback_lowpass() const;
};
}
#endif

54
include/gen/AudioEffectDistortion.hpp Normal file
View File

@ -0,0 +1,54 @@
#ifndef GODOT_CPP_AUDIOEFFECTDISTORTION_HPP
#define GODOT_CPP_AUDIOEFFECTDISTORTION_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectDistortion.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectDistortion : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectDistortion"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum Mode {
MODE_OVERDRIVE = 3,
MODE_LOFI = 2,
MODE_ATAN = 1,
MODE_WAVESHAPE = 4,
MODE_CLIP = 0,
};
// constants
static AudioEffectDistortion *_new();
// methods
void set_mode(const int64_t mode);
AudioEffectDistortion::Mode get_mode() const;
void set_pre_gain(const double pre_gain);
double get_pre_gain() const;
void set_keep_hf_hz(const double keep_hf_hz);
double get_keep_hf_hz() const;
void set_drive(const double drive);
double get_drive() const;
void set_post_gain(const double post_gain);
double get_post_gain() const;
};
}
#endif

39
include/gen/AudioEffectEQ.hpp Normal file
View File

@ -0,0 +1,39 @@
#ifndef GODOT_CPP_AUDIOEFFECTEQ_HPP
#define GODOT_CPP_AUDIOEFFECTEQ_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectEQ : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectEQ"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectEQ *_new();
// methods
void set_band_gain_db(const int64_t band_idx, const double volume_db);
double get_band_gain_db(const int64_t band_idx) const;
int64_t get_band_count() const;
};
}
#endif

36
include/gen/AudioEffectEQ10.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTEQ10_HPP
#define GODOT_CPP_AUDIOEFFECTEQ10_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectEQ.hpp>
namespace godot {
class AudioEffectEQ10 : public AudioEffectEQ {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectEQ10"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectEQ10 *_new();
// methods
};
}
#endif

36
include/gen/AudioEffectEQ21.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTEQ21_HPP
#define GODOT_CPP_AUDIOEFFECTEQ21_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectEQ.hpp>
namespace godot {
class AudioEffectEQ21 : public AudioEffectEQ {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectEQ21"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectEQ21 *_new();
// methods
};
}
#endif

36
include/gen/AudioEffectEQ6.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTEQ6_HPP
#define GODOT_CPP_AUDIOEFFECTEQ6_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectEQ.hpp>
namespace godot {
class AudioEffectEQ6 : public AudioEffectEQ {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectEQ6"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectEQ6 *_new();
// methods
};
}
#endif

51
include/gen/AudioEffectFilter.hpp Normal file
View File

@ -0,0 +1,51 @@
#ifndef GODOT_CPP_AUDIOEFFECTFILTER_HPP
#define GODOT_CPP_AUDIOEFFECTFILTER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectFilter.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectFilter : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectFilter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum FilterDB {
FILTER_18DB = 2,
FILTER_6DB = 0,
FILTER_24DB = 3,
FILTER_12DB = 1,
};
// constants
static AudioEffectFilter *_new();
// methods
void set_cutoff(const double freq);
double get_cutoff() const;
void set_resonance(const double amount);
double get_resonance() const;
void set_gain(const double amount);
double get_gain() const;
void set_db(const int64_t amount);
AudioEffectFilter::FilterDB get_db() const;
};
}
#endif

36
include/gen/AudioEffectHighPassFilter.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTHIGHPASSFILTER_HPP
#define GODOT_CPP_AUDIOEFFECTHIGHPASSFILTER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectFilter.hpp>
namespace godot {
class AudioEffectHighPassFilter : public AudioEffectFilter {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectHighPassFilter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectHighPassFilter *_new();
// methods
};
}
#endif

36
include/gen/AudioEffectHighShelfFilter.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTHIGHSHELFFILTER_HPP
#define GODOT_CPP_AUDIOEFFECTHIGHSHELFFILTER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectFilter.hpp>
namespace godot {
class AudioEffectHighShelfFilter : public AudioEffectFilter {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectHighShelfFilter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectHighShelfFilter *_new();
// methods
};
}
#endif

44
include/gen/AudioEffectLimiter.hpp Normal file
View File

@ -0,0 +1,44 @@
#ifndef GODOT_CPP_AUDIOEFFECTLIMITER_HPP
#define GODOT_CPP_AUDIOEFFECTLIMITER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectLimiter : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectLimiter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectLimiter *_new();
// methods
void set_ceiling_db(const double ceiling);
double get_ceiling_db() const;
void set_threshold_db(const double threshold);
double get_threshold_db() const;
void set_soft_clip_db(const double soft_clip);
double get_soft_clip_db() const;
void set_soft_clip_ratio(const double soft_clip);
double get_soft_clip_ratio() const;
};
}
#endif

36
include/gen/AudioEffectLowPassFilter.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTLOWPASSFILTER_HPP
#define GODOT_CPP_AUDIOEFFECTLOWPASSFILTER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectFilter.hpp>
namespace godot {
class AudioEffectLowPassFilter : public AudioEffectFilter {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectLowPassFilter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectLowPassFilter *_new();
// methods
};
}
#endif

36
include/gen/AudioEffectLowShelfFilter.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTLOWSHELFFILTER_HPP
#define GODOT_CPP_AUDIOEFFECTLOWSHELFFILTER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectFilter.hpp>
namespace godot {
class AudioEffectLowShelfFilter : public AudioEffectFilter {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectLowShelfFilter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectLowShelfFilter *_new();
// methods
};
}
#endif

36
include/gen/AudioEffectNotchFilter.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_AUDIOEFFECTNOTCHFILTER_HPP
#define GODOT_CPP_AUDIOEFFECTNOTCHFILTER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffectFilter.hpp>
namespace godot {
class AudioEffectNotchFilter : public AudioEffectFilter {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectNotchFilter"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectNotchFilter *_new();
// methods
};
}
#endif

38
include/gen/AudioEffectPanner.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_AUDIOEFFECTPANNER_HPP
#define GODOT_CPP_AUDIOEFFECTPANNER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectPanner : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectPanner"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectPanner *_new();
// methods
void set_pan(const double cpanume);
double get_pan() const;
};
}
#endif

46
include/gen/AudioEffectPhaser.hpp Normal file
View File

@ -0,0 +1,46 @@
#ifndef GODOT_CPP_AUDIOEFFECTPHASER_HPP
#define GODOT_CPP_AUDIOEFFECTPHASER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectPhaser : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectPhaser"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectPhaser *_new();
// methods
void set_range_min_hz(const double hz);
double get_range_min_hz() const;
void set_range_max_hz(const double hz);
double get_range_max_hz() const;
void set_rate_hz(const double hz);
double get_rate_hz() const;
void set_feedback(const double fbk);
double get_feedback() const;
void set_depth(const double depth);
double get_depth() const;
};
}
#endif

38
include/gen/AudioEffectPitchShift.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_AUDIOEFFECTPITCHSHIFT_HPP
#define GODOT_CPP_AUDIOEFFECTPITCHSHIFT_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectPitchShift : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectPitchShift"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectPitchShift *_new();
// methods
void set_pitch_scale(const double rate);
double get_pitch_scale() const;
};
}
#endif

52
include/gen/AudioEffectReverb.hpp Normal file
View File

@ -0,0 +1,52 @@
#ifndef GODOT_CPP_AUDIOEFFECTREVERB_HPP
#define GODOT_CPP_AUDIOEFFECTREVERB_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectReverb : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectReverb"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectReverb *_new();
// methods
void set_predelay_msec(const double msec);
double get_predelay_msec() const;
void set_predelay_feedback(const double feedback);
double get_predelay_feedback() const;
void set_room_size(const double size);
double get_room_size() const;
void set_damping(const double amount);
double get_damping() const;
void set_spread(const double amount);
double get_spread() const;
void set_dry(const double amount);
double get_dry() const;
void set_wet(const double amount);
double get_wet() const;
void set_hpf(const double amount);
double get_hpf() const;
};
}
#endif

42
include/gen/AudioEffectStereoEnhance.hpp Normal file
View File

@ -0,0 +1,42 @@
#ifndef GODOT_CPP_AUDIOEFFECTSTEREOENHANCE_HPP
#define GODOT_CPP_AUDIOEFFECTSTEREOENHANCE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioEffect.hpp>
namespace godot {
class AudioEffectStereoEnhance : public AudioEffect {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioEffectStereoEnhance"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioEffectStereoEnhance *_new();
// methods
void set_pan_pullout(const double amount);
double get_pan_pullout() const;
void set_time_pullout(const double amount);
double get_time_pullout() const;
void set_surround(const double amount);
double get_surround() const;
};
}
#endif

86
include/gen/AudioServer.hpp Normal file
View File

@ -0,0 +1,86 @@
#ifndef GODOT_CPP_AUDIOSERVER_HPP
#define GODOT_CPP_AUDIOSERVER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioServer.hpp>
#include <Object.hpp>
namespace godot {
class AudioEffect;
class AudioBusLayout;
class AudioServer : public Object {
static AudioServer *_singleton;
AudioServer();
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline AudioServer *get_singleton()
{
if (!AudioServer::_singleton) {
AudioServer::_singleton = new AudioServer;
}
return AudioServer::_singleton;
}
static inline const char *___get_class_name() { return (const char *) "AudioServer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum SpeakerMode {
SPEAKER_SURROUND_51 = 2,
SPEAKER_SURROUND_71 = 3,
SPEAKER_MODE_STEREO = 0,
};
// constants
// methods
void set_bus_count(const int64_t amount);
int64_t get_bus_count() const;
void remove_bus(const int64_t index);
void add_bus(const int64_t at_position = -1);
void move_bus(const int64_t index, const int64_t to_index);
void set_bus_name(const int64_t bus_idx, const String name);
String get_bus_name(const int64_t bus_idx) const;
int64_t get_bus_index(const String bus_name) const;
void set_bus_volume_db(const int64_t bus_idx, const double volume_db);
double get_bus_volume_db(const int64_t bus_idx) const;
void set_bus_send(const int64_t bus_idx, const String send);
String get_bus_send(const int64_t bus_idx) const;
void set_bus_solo(const int64_t bus_idx, const bool enable);
bool is_bus_solo(const int64_t bus_idx) const;
void set_bus_mute(const int64_t bus_idx, const bool enable);
bool is_bus_mute(const int64_t bus_idx) const;
void set_bus_bypass_effects(const int64_t bus_idx, const bool enable);
bool is_bus_bypassing_effects(const int64_t bus_idx) const;
void add_bus_effect(const int64_t bus_idx, const Ref<AudioEffect> effect, const int64_t at_position = -1);
void remove_bus_effect(const int64_t bus_idx, const int64_t effect_idx);
int64_t get_bus_effect_count(const int64_t bus_idx);
Ref<AudioEffect> get_bus_effect(const int64_t bus_idx, const int64_t effect_idx);
void swap_bus_effects(const int64_t bus_idx, const int64_t effect_idx, const int64_t by_effect_idx);
void set_bus_effect_enabled(const int64_t bus_idx, const int64_t effect_idx, const bool enabled);
bool is_bus_effect_enabled(const int64_t bus_idx, const int64_t effect_idx) const;
double get_bus_peak_volume_left_db(const int64_t bus_idx, const int64_t channel) const;
double get_bus_peak_volume_right_db(const int64_t bus_idx, const int64_t channel) const;
void lock();
void unlock();
AudioServer::SpeakerMode get_speaker_mode() const;
double get_mix_rate() const;
void set_bus_layout(const Ref<AudioBusLayout> bus_layout);
Ref<AudioBusLayout> generate_bus_layout() const;
};
}
#endif

34
include/gen/AudioStream.hpp Normal file
View File

@ -0,0 +1,34 @@
#ifndef GODOT_CPP_AUDIOSTREAM_HPP
#define GODOT_CPP_AUDIOSTREAM_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Resource.hpp>
namespace godot {
class AudioStream : public Resource {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioStream"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
// methods
double get_length() const;
};
}
#endif

42
include/gen/AudioStreamOGGVorbis.hpp Normal file
View File

@ -0,0 +1,42 @@
#ifndef GODOT_CPP_AUDIOSTREAMOGGVORBIS_HPP
#define GODOT_CPP_AUDIOSTREAMOGGVORBIS_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioStream.hpp>
namespace godot {
class AudioStreamOGGVorbis : public AudioStream {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioStreamOGGVorbis"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioStreamOGGVorbis *_new();
// methods
void _set_data(const PoolByteArray data);
PoolByteArray _get_data() const;
void set_loop(const bool enable);
bool has_loop() const;
void set_loop_offset(const double seconds);
double get_loop_offset() const;
};
}
#endif

33
include/gen/AudioStreamPlayback.hpp Normal file
View File

@ -0,0 +1,33 @@
#ifndef GODOT_CPP_AUDIOSTREAMPLAYBACK_HPP
#define GODOT_CPP_AUDIOSTREAMPLAYBACK_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Reference.hpp>
namespace godot {
class AudioStreamPlayback : public Reference {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioStreamPlayback"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
// methods
};
}
#endif

63
include/gen/AudioStreamPlayer.hpp Normal file
View File

@ -0,0 +1,63 @@
#ifndef GODOT_CPP_AUDIOSTREAMPLAYER_HPP
#define GODOT_CPP_AUDIOSTREAMPLAYER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioStreamPlayer.hpp>
#include <Node.hpp>
namespace godot {
class AudioStream;
class AudioStreamPlayer : public Node {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioStreamPlayer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum MixTarget {
MIX_TARGET_SURROUND = 1,
MIX_TARGET_CENTER = 2,
MIX_TARGET_STEREO = 0,
};
// constants
static AudioStreamPlayer *_new();
// methods
void set_stream(const Ref<AudioStream> stream);
Ref<AudioStream> get_stream() const;
void set_volume_db(const double volume_db);
double get_volume_db() const;
void set_pitch_scale(const double pitch_scale);
double get_pitch_scale() const;
void play(const double from_position = 0);
void seek(const double to_position);
void stop();
bool is_playing() const;
double get_playback_position();
void set_bus(const String bus);
String get_bus() const;
void set_autoplay(const bool enable);
bool is_autoplay_enabled();
void set_mix_target(const int64_t mix_target);
AudioStreamPlayer::MixTarget get_mix_target() const;
void _set_playing(const bool enable);
bool _is_active() const;
void _bus_layout_changed();
};
}
#endif

61
include/gen/AudioStreamPlayer2D.hpp Normal file
View File

@ -0,0 +1,61 @@
#ifndef GODOT_CPP_AUDIOSTREAMPLAYER2D_HPP
#define GODOT_CPP_AUDIOSTREAMPLAYER2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Node2D.hpp>
namespace godot {
class AudioStream;
class AudioStreamPlayer2D : public Node2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioStreamPlayer2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioStreamPlayer2D *_new();
// methods
void set_stream(const Ref<AudioStream> stream);
Ref<AudioStream> get_stream() const;
void set_volume_db(const double volume_db);
double get_volume_db() const;
void set_pitch_scale(const double pitch_scale);
double get_pitch_scale() const;
void play(const double from_position = 0);
void seek(const double to_position);
void stop();
bool is_playing() const;
double get_playback_position();
void set_bus(const String bus);
String get_bus() const;
void set_autoplay(const bool enable);
bool is_autoplay_enabled();
void _set_playing(const bool enable);
bool _is_active() const;
void set_max_distance(const double pixels);
double get_max_distance() const;
void set_attenuation(const double curve);
double get_attenuation() const;
void set_area_mask(const int64_t mask);
int64_t get_area_mask() const;
void _bus_layout_changed();
};
}
#endif

94
include/gen/AudioStreamPlayer3D.hpp Normal file
View File

@ -0,0 +1,94 @@
#ifndef GODOT_CPP_AUDIOSTREAMPLAYER3D_HPP
#define GODOT_CPP_AUDIOSTREAMPLAYER3D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioStreamPlayer3D.hpp>
#include <Spatial.hpp>
namespace godot {
class AudioStream;
class AudioStreamPlayer3D : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioStreamPlayer3D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum AttenuationModel {
ATTENUATION_INVERSE_DISTANCE = 0,
ATTENUATION_LOGARITHMIC = 2,
ATTENUATION_INVERSE_SQUARE_DISTANCE = 1,
};
enum OutOfRangeMode {
OUT_OF_RANGE_MIX = 0,
OUT_OF_RANGE_PAUSE = 1,
};
enum DopplerTracking {
DOPPLER_TRACKING_IDLE_STEP = 1,
DOPPLER_TRACKING_PHYSICS_STEP = 2,
DOPPLER_TRACKING_DISABLED = 0,
};
// constants
static AudioStreamPlayer3D *_new();
// methods
void set_stream(const Ref<AudioStream> stream);
Ref<AudioStream> get_stream() const;
void set_unit_db(const double unit_db);
double get_unit_db() const;
void set_unit_size(const double unit_size);
double get_unit_size() const;
void set_max_db(const double max_db);
double get_max_db() const;
void set_pitch_scale(const double pitch_scale);
double get_pitch_scale() const;
void play(const double from_position = 0);
void seek(const double to_position);
void stop();
bool is_playing() const;
double get_playback_position();
void set_bus(const String bus);
String get_bus() const;
void set_autoplay(const bool enable);
bool is_autoplay_enabled();
void _set_playing(const bool enable);
bool _is_active() const;
void set_max_distance(const double metres);
double get_max_distance() const;
void set_area_mask(const int64_t mask);
int64_t get_area_mask() const;
void set_emission_angle(const double degrees);
double get_emission_angle() const;
void set_emission_angle_enabled(const bool enabled);
bool is_emission_angle_enabled() const;
void set_emission_angle_filter_attenuation_db(const double db);
double get_emission_angle_filter_attenuation_db() const;
void set_attenuation_filter_cutoff_hz(const double degrees);
double get_attenuation_filter_cutoff_hz() const;
void set_attenuation_filter_db(const double db);
double get_attenuation_filter_db() const;
void set_attenuation_model(const int64_t model);
AudioStreamPlayer3D::AttenuationModel get_attenuation_model() const;
void set_out_of_range_mode(const int64_t mode);
AudioStreamPlayer3D::OutOfRangeMode get_out_of_range_mode() const;
void set_doppler_tracking(const int64_t mode);
AudioStreamPlayer3D::DopplerTracking get_doppler_tracking() const;
void _bus_layout_changed();
};
}
#endif

41
include/gen/AudioStreamRandomPitch.hpp Normal file
View File

@ -0,0 +1,41 @@
#ifndef GODOT_CPP_AUDIOSTREAMRANDOMPITCH_HPP
#define GODOT_CPP_AUDIOSTREAMRANDOMPITCH_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioStream.hpp>
namespace godot {
class AudioStream;
class AudioStreamRandomPitch : public AudioStream {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioStreamRandomPitch"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static AudioStreamRandomPitch *_new();
// methods
void set_audio_stream(const Ref<AudioStream> stream);
Ref<AudioStream> get_audio_stream() const;
void set_random_pitch(const double scale);
double get_random_pitch() const;
};
}
#endif

61
include/gen/AudioStreamSample.hpp Normal file
View File

@ -0,0 +1,61 @@
#ifndef GODOT_CPP_AUDIOSTREAMSAMPLE_HPP
#define GODOT_CPP_AUDIOSTREAMSAMPLE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AudioStreamSample.hpp>
#include <AudioStream.hpp>
namespace godot {
class AudioStreamSample : public AudioStream {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "AudioStreamSample"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum LoopMode {
LOOP_PING_PONG = 2,
LOOP_FORWARD = 1,
LOOP_DISABLED = 0,
};
enum Format {
FORMAT_8_BITS = 0,
FORMAT_IMA_ADPCM = 2,
FORMAT_16_BITS = 1,
};
// constants
static AudioStreamSample *_new();
// methods
void set_format(const int64_t format);
AudioStreamSample::Format get_format() const;
void set_loop_mode(const int64_t loop_mode);
AudioStreamSample::LoopMode get_loop_mode() const;
void set_loop_begin(const int64_t loop_begin);
int64_t get_loop_begin() const;
void set_loop_end(const int64_t loop_end);
int64_t get_loop_end() const;
void set_mix_rate(const int64_t mix_rate);
int64_t get_mix_rate() const;
void set_stereo(const bool stereo);
bool is_stereo() const;
void _set_data(const PoolByteArray data);
PoolByteArray _get_data() const;
};
}
#endif

46
include/gen/BackBufferCopy.hpp Normal file
View File

@ -0,0 +1,46 @@
#ifndef GODOT_CPP_BACKBUFFERCOPY_HPP
#define GODOT_CPP_BACKBUFFERCOPY_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <BackBufferCopy.hpp>
#include <Node2D.hpp>
namespace godot {
class BackBufferCopy : public Node2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BackBufferCopy"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum CopyMode {
COPY_MODE_DISABLED = 0,
COPY_MODE_RECT = 1,
COPY_MODE_VIEWPORT = 2,
};
// constants
static BackBufferCopy *_new();
// methods
void set_rect(const Rect2 rect);
Rect2 get_rect() const;
void set_copy_mode(const int64_t copy_mode);
BackBufferCopy::CopyMode get_copy_mode() const;
};
}
#endif

77
include/gen/BakedLightmap.hpp Normal file
View File

@ -0,0 +1,77 @@
#ifndef GODOT_CPP_BAKEDLIGHTMAP_HPP
#define GODOT_CPP_BAKEDLIGHTMAP_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <BakedLightmap.hpp>
#include <VisualInstance.hpp>
namespace godot {
class BakedLightmapData;
class Object;
class BakedLightmap : public VisualInstance {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BakedLightmap"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum BakeQuality {
BAKE_QUALITY_HIGH = 2,
BAKE_QUALITY_LOW = 0,
BAKE_QUALITY_MEDIUM = 1,
};
enum BakeError {
BAKE_ERROR_OK = 0,
BAKE_ERROR_USER_ABORTED = 4,
BAKE_ERROR_NO_MESHES = 2,
BAKE_ERROR_CANT_CREATE_IMAGE = 3,
BAKE_ERROR_NO_SAVE_PATH = 1,
};
enum BakeMode {
BAKE_MODE_CONE_TRACE = 0,
BAKE_MODE_RAY_TRACE = 1,
};
// constants
static BakedLightmap *_new();
// methods
void set_light_data(const Ref<BakedLightmapData> data);
Ref<BakedLightmapData> get_light_data() const;
void set_bake_cell_size(const double bake_cell_size);
double get_bake_cell_size() const;
void set_capture_cell_size(const double capture_cell_size);
double get_capture_cell_size() const;
void set_bake_quality(const int64_t bake_quality);
BakedLightmap::BakeQuality get_bake_quality() const;
void set_bake_mode(const int64_t bake_mode);
BakedLightmap::BakeMode get_bake_mode() const;
void set_extents(const Vector3 extents);
Vector3 get_extents() const;
void set_propagation(const double propagation);
double get_propagation() const;
void set_energy(const double energy);
double get_energy() const;
void set_hdr(const bool hdr);
bool is_hdr() const;
void set_image_path(const String image_path);
String get_image_path() const;
BakedLightmap::BakeError bake(const Object *from_node = nullptr, const bool create_visual_debug = false);
void debug_bake();
};
}
#endif

54
include/gen/BakedLightmapData.hpp Normal file
View File

@ -0,0 +1,54 @@
#ifndef GODOT_CPP_BAKEDLIGHTMAPDATA_HPP
#define GODOT_CPP_BAKEDLIGHTMAPDATA_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Resource.hpp>
namespace godot {
class Texture;
class BakedLightmapData : public Resource {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BakedLightmapData"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static BakedLightmapData *_new();
// methods
void _set_user_data(const Array data);
Array _get_user_data() const;
void set_bounds(const AABB bounds);
AABB get_bounds() const;
void set_cell_space_transform(const Transform xform);
Transform get_cell_space_transform() const;
void set_cell_subdiv(const int64_t cell_subdiv);
int64_t get_cell_subdiv() const;
void set_octree(const PoolByteArray octree);
PoolByteArray get_octree() const;
void set_energy(const double energy);
double get_energy() const;
void add_user(const NodePath path, const Ref<Texture> lightmap, const int64_t instance);
int64_t get_user_count() const;
NodePath get_user_path(const int64_t user_idx) const;
Ref<Texture> get_user_lightmap(const int64_t user_idx) const;
void clear_users();
};
}
#endif

68
include/gen/BaseButton.hpp Normal file
View File

@ -0,0 +1,68 @@
#ifndef GODOT_CPP_BASEBUTTON_HPP
#define GODOT_CPP_BASEBUTTON_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <BaseButton.hpp>
#include <Control.hpp>
#include <Control.hpp>
namespace godot {
class InputEvent;
class ShortCut;
class ButtonGroup;
class BaseButton : public Control {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BaseButton"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum ActionMode {
ACTION_MODE_BUTTON_PRESS = 0,
ACTION_MODE_BUTTON_RELEASE = 1,
};
enum DrawMode {
DRAW_DISABLED = 3,
DRAW_PRESSED = 1,
DRAW_NORMAL = 0,
DRAW_HOVER = 2,
};
// constants
// methods
void _pressed();
void _toggled(const bool button_pressed);
void _gui_input(const Ref<InputEvent> arg0);
void _unhandled_input(const Ref<InputEvent> arg0);
void set_pressed(const bool pressed);
bool is_pressed() const;
bool is_hovered() const;
void set_toggle_mode(const bool enabled);
bool is_toggle_mode() const;
void set_disabled(const bool disabled);
bool is_disabled() const;
void set_action_mode(const int64_t mode);
BaseButton::ActionMode get_action_mode() const;
BaseButton::DrawMode get_draw_mode() const;
void set_enabled_focus_mode(const int64_t mode);
Control::FocusMode get_enabled_focus_mode() const;
void set_shortcut(const Ref<ShortCut> shortcut);
Ref<ShortCut> get_shortcut() const;
void set_button_group(const Ref<ButtonGroup> button_group);
Ref<ButtonGroup> get_button_group() const;
};
}
#endif

46
include/gen/BitMap.hpp Normal file
View File

@ -0,0 +1,46 @@
#ifndef GODOT_CPP_BITMAP_HPP
#define GODOT_CPP_BITMAP_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Resource.hpp>
namespace godot {
class Image;
class BitMap : public Resource {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BitMap"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static BitMap *_new();
// methods
void create(const Vector2 size);
void create_from_image_alpha(const Ref<Image> image, const double threshold = 0.1);
void set_bit(const Vector2 position, const bool bit);
bool get_bit(const Vector2 position) const;
void set_bit_rect(const Rect2 p_rect, const bool bit);
int64_t get_true_bit_count() const;
Vector2 get_size() const;
void _set_data(const Dictionary arg0);
Dictionary _get_data() const;
};
}
#endif

58
include/gen/BitmapFont.hpp Normal file
View File

@ -0,0 +1,58 @@
#ifndef GODOT_CPP_BITMAPFONT_HPP
#define GODOT_CPP_BITMAPFONT_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Font.hpp>
namespace godot {
class Texture;
class BitmapFont;
class BitmapFont : public Font {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BitmapFont"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static BitmapFont *_new();
// methods
Error create_from_fnt(const String path);
void set_height(const double px);
void set_ascent(const double px);
void add_kerning_pair(const int64_t char_a, const int64_t char_b, const int64_t kerning);
int64_t get_kerning_pair(const int64_t char_a, const int64_t char_b) const;
void add_texture(const Ref<Texture> texture);
void add_char(const int64_t character, const int64_t texture, const Rect2 rect, const Vector2 align = Vector2(0, 0), const double advance = -1);
int64_t get_texture_count() const;
Ref<Texture> get_texture(const int64_t idx) const;
Vector2 get_char_size(const int64_t _char, const int64_t next = 0) const;
void set_distance_field_hint(const bool enable);
void clear();
void _set_chars(const PoolIntArray arg0);
PoolIntArray _get_chars() const;
void _set_kernings(const PoolIntArray arg0);
PoolIntArray _get_kernings() const;
void _set_textures(const Array arg0);
Array _get_textures() const;
void set_fallback(const Ref<BitmapFont> fallback);
Ref<BitmapFont> get_fallback() const;
};
}
#endif

38
include/gen/BoneAttachment.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_BONEATTACHMENT_HPP
#define GODOT_CPP_BONEATTACHMENT_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Spatial.hpp>
namespace godot {
class BoneAttachment : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BoneAttachment"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static BoneAttachment *_new();
// methods
void set_bone_name(const String bone_name);
String get_bone_name() const;
};
}
#endif

42
include/gen/BoxContainer.hpp Normal file
View File

@ -0,0 +1,42 @@
#ifndef GODOT_CPP_BOXCONTAINER_HPP
#define GODOT_CPP_BOXCONTAINER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <BoxContainer.hpp>
#include <Container.hpp>
namespace godot {
class BoxContainer : public Container {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BoxContainer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum AlignMode {
ALIGN_END = 2,
ALIGN_BEGIN = 0,
ALIGN_CENTER = 1,
};
// constants
// methods
void add_spacer(const bool begin);
BoxContainer::AlignMode get_alignment() const;
void set_alignment(const int64_t alignment);
};
}
#endif

38
include/gen/BoxShape.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_BOXSHAPE_HPP
#define GODOT_CPP_BOXSHAPE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Shape.hpp>
namespace godot {
class BoxShape : public Shape {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BoxShape"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static BoxShape *_new();
// methods
void set_extents(const Vector3 extents);
Vector3 get_extents() const;
};
}
#endif

33
include/gen/BulletPhysicsDirectBodyState.hpp Normal file
View File

@ -0,0 +1,33 @@
#ifndef GODOT_CPP_BULLETPHYSICSDIRECTBODYSTATE_HPP
#define GODOT_CPP_BULLETPHYSICSDIRECTBODYSTATE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <PhysicsDirectBodyState.hpp>
namespace godot {
class BulletPhysicsDirectBodyState : public PhysicsDirectBodyState {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BulletPhysicsDirectBodyState"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
// methods
};
}
#endif

33
include/gen/BulletPhysicsServer.hpp Normal file
View File

@ -0,0 +1,33 @@
#ifndef GODOT_CPP_BULLETPHYSICSSERVER_HPP
#define GODOT_CPP_BULLETPHYSICSSERVER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <PhysicsServer.hpp>
namespace godot {
class BulletPhysicsServer : public PhysicsServer {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "BulletPhysicsServer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
// methods
};
}
#endif

53
include/gen/Button.hpp Normal file
View File

@ -0,0 +1,53 @@
#ifndef GODOT_CPP_BUTTON_HPP
#define GODOT_CPP_BUTTON_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Button.hpp>
#include <BaseButton.hpp>
namespace godot {
class Texture;
class Button : public BaseButton {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "Button"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum TextAlign {
ALIGN_LEFT = 0,
ALIGN_CENTER = 1,
ALIGN_RIGHT = 2,
};
// constants
static Button *_new();
// methods
void set_text(const String text);
String get_text() const;
void set_button_icon(const Ref<Texture> texture);
Ref<Texture> get_button_icon() const;
void set_flat(const bool enabled);
void set_clip_text(const bool enabled);
bool get_clip_text() const;
void set_text_align(const int64_t align);
Button::TextAlign get_text_align() const;
bool is_flat() const;
};
}
#endif

38
include/gen/ButtonGroup.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_BUTTONGROUP_HPP
#define GODOT_CPP_BUTTONGROUP_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Resource.hpp>
namespace godot {
class BaseButton;
class ButtonGroup : public Resource {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ButtonGroup"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ButtonGroup *_new();
// methods
BaseButton *get_pressed_button();
};
}
#endif

86
include/gen/Camera.hpp Normal file
View File

@ -0,0 +1,86 @@
#ifndef GODOT_CPP_CAMERA_HPP
#define GODOT_CPP_CAMERA_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Camera.hpp>
#include <Spatial.hpp>
namespace godot {
class Environment;
class Camera : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "Camera"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum KeepAspect {
KEEP_WIDTH = 0,
KEEP_HEIGHT = 1,
};
enum Projection {
PROJECTION_PERSPECTIVE = 0,
PROJECTION_ORTHOGONAL = 1,
};
enum DopplerTracking {
DOPPLER_TRACKING_IDLE_STEP = 1,
DOPPLER_TRACKING_PHYSICS_STEP = 2,
DOPPLER_TRACKING_DISABLED = 0,
};
// constants
static Camera *_new();
// methods
Vector3 project_ray_normal(const Vector2 screen_point) const;
Vector3 project_local_ray_normal(const Vector2 screen_point) const;
Vector3 project_ray_origin(const Vector2 screen_point) const;
Vector2 unproject_position(const Vector3 world_point) const;
bool is_position_behind(const Vector3 world_point) const;
Vector3 project_position(const Vector2 screen_point) const;
void set_perspective(const double fov, const double z_near, const double z_far);
void set_orthogonal(const double size, const double z_near, const double z_far);
void make_current();
void clear_current(const bool enable_next = true);
void set_current(const bool arg0);
bool is_current() const;
Transform get_camera_transform() const;
double get_fov() const;
double get_size() const;
double get_zfar() const;
double get_znear() const;
void set_fov(const double arg0);
void set_size(const double arg0);
void set_zfar(const double arg0);
void set_znear(const double arg0);
Camera::Projection get_projection() const;
void set_projection(const int64_t arg0);
void set_h_offset(const double ofs);
double get_h_offset() const;
void set_v_offset(const double ofs);
double get_v_offset() const;
void set_cull_mask(const int64_t mask);
int64_t get_cull_mask() const;
void set_environment(const Ref<Environment> env);
Ref<Environment> get_environment() const;
void set_keep_aspect_mode(const int64_t mode);
Camera::KeepAspect get_keep_aspect_mode() const;
void set_doppler_tracking(const int64_t mode);
Camera::DopplerTracking get_doppler_tracking() const;
};
}
#endif

89
include/gen/Camera2D.hpp Normal file
View File

@ -0,0 +1,89 @@
#ifndef GODOT_CPP_CAMERA2D_HPP
#define GODOT_CPP_CAMERA2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Camera2D.hpp>
#include <Node2D.hpp>
namespace godot {
class Object;
class Node;
class Camera2D : public Node2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "Camera2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum AnchorMode {
ANCHOR_MODE_FIXED_TOP_LEFT = 0,
ANCHOR_MODE_DRAG_CENTER = 1,
};
// constants
static Camera2D *_new();
// methods
void set_offset(const Vector2 offset);
Vector2 get_offset() const;
void set_anchor_mode(const int64_t anchor_mode);
Camera2D::AnchorMode get_anchor_mode() const;
void set_rotating(const bool rotating);
bool is_rotating() const;
void make_current();
void clear_current();
void _make_current(const Object *arg0);
void _update_scroll();
void _set_current(const bool current);
bool is_current() const;
void set_limit(const int64_t margin, const int64_t limit);
int64_t get_limit(const int64_t margin) const;
void set_limit_smoothing_enabled(const bool limit_smoothing_enabled);
bool is_limit_smoothing_enabled() const;
void set_v_drag_enabled(const bool enabled);
bool is_v_drag_enabled() const;
void set_h_drag_enabled(const bool enabled);
bool is_h_drag_enabled() const;
void set_v_offset(const double ofs);
double get_v_offset() const;
void set_h_offset(const double ofs);
double get_h_offset() const;
void set_drag_margin(const int64_t margin, const double drag_margin);
double get_drag_margin(const int64_t margin) const;
Vector2 get_camera_position() const;
Vector2 get_camera_screen_center() const;
void set_zoom(const Vector2 zoom);
Vector2 get_zoom() const;
void set_custom_viewport(const Object *viewport);
Node *get_custom_viewport() const;
void set_follow_smoothing(const double follow_smoothing);
double get_follow_smoothing() const;
void set_enable_follow_smoothing(const bool follow_smoothing);
bool is_follow_smoothing_enabled() const;
void force_update_scroll();
void reset_smoothing();
void align();
void _set_old_smoothing(const double follow_smoothing);
void set_screen_drawing_enabled(const bool screen_drawing_enabled);
bool is_screen_drawing_enabled() const;
void set_limit_drawing_enabled(const bool limit_drawing_enabled);
bool is_limit_drawing_enabled() const;
void set_margin_drawing_enabled(const bool margin_drawing_enabled);
bool is_margin_drawing_enabled() const;
};
}
#endif

129
include/gen/CanvasItem.hpp Normal file
View File

@ -0,0 +1,129 @@
#ifndef GODOT_CPP_CANVASITEM_HPP
#define GODOT_CPP_CANVASITEM_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Node.hpp>
namespace godot {
class Texture;
class StyleBox;
class Font;
class Mesh;
class World2D;
class Material;
class InputEvent;
class CanvasItem : public Node {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CanvasItem"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum BlendMode {
BLEND_MODE_SUB = 2,
BLEND_MODE_MUL = 3,
BLEND_MODE_MIX = 0,
BLEND_MODE_PREMULT_ALPHA = 4,
BLEND_MODE_ADD = 1,
};
// constants
const static int NOTIFICATION_VISIBILITY_CHANGED = 31;
const static int NOTIFICATION_TRANSFORM_CHANGED = 29;
const static int NOTIFICATION_DRAW = 30;
const static int NOTIFICATION_EXIT_CANVAS = 33;
const static int NOTIFICATION_ENTER_CANVAS = 32;
// methods
void _draw();
void _toplevel_raise_self();
void _update_callback();
void _edit_set_state(const Dictionary state);
Dictionary _edit_get_state() const;
void _edit_set_position(const Vector2 position);
Vector2 _edit_get_position() const;
bool _edit_use_position() const;
void _edit_set_rect(const Rect2 rect);
Rect2 _edit_get_rect() const;
bool _edit_use_rect() const;
Rect2 _edit_get_item_and_children_rect() const;
void _edit_set_rotation(const double degrees);
double _edit_get_rotation() const;
bool _edit_use_rotation() const;
void _edit_set_pivot(const Vector2 pivot);
Vector2 _edit_get_pivot() const;
bool _edit_use_pivot() const;
RID get_canvas_item() const;
void set_visible(const bool visible);
bool is_visible() const;
bool is_visible_in_tree() const;
void show();
void hide();
void update();
void set_as_toplevel(const bool enable);
bool is_set_as_toplevel() const;
void set_light_mask(const int64_t light_mask);
int64_t get_light_mask() const;
void set_modulate(const Color modulate);
Color get_modulate() const;
void set_self_modulate(const Color self_modulate);
Color get_self_modulate() const;
void set_draw_behind_parent(const bool enable);
bool is_draw_behind_parent_enabled() const;
void _set_on_top(const bool on_top);
bool _is_on_top() const;
void draw_line(const Vector2 from, const Vector2 to, const Color color, const double width = 1, const bool antialiased = false);
void draw_polyline(const PoolVector2Array points, const Color color, const double width = 1, const bool antialiased = false);
void draw_polyline_colors(const PoolVector2Array points, const PoolColorArray colors, const double width = 1, const bool antialiased = false);
void draw_multiline(const PoolVector2Array points, const Color color, const double width = 1, const bool antialiased = false);
void draw_multiline_colors(const PoolVector2Array points, const PoolColorArray colors, const double width = 1, const bool antialiased = false);
void draw_rect(const Rect2 rect, const Color color, const bool filled = true);
void draw_circle(const Vector2 position, const double radius, const Color color);
void draw_texture(const Ref<Texture> texture, const Vector2 position, const Color modulate = Color(1,1,1,1), const Ref<Texture> normal_map = nullptr);
void draw_texture_rect(const Ref<Texture> texture, const Rect2 rect, const bool tile, const Color modulate = Color(1,1,1,1), const bool transpose = false, const Ref<Texture> normal_map = nullptr);
void draw_texture_rect_region(const Ref<Texture> texture, const Rect2 rect, const Rect2 src_rect, const Color modulate = Color(1,1,1,1), const bool transpose = false, const Ref<Texture> normal_map = nullptr, const bool clip_uv = true);
void draw_style_box(const Ref<StyleBox> style_box, const Rect2 rect);
void draw_primitive(const PoolVector2Array points, const PoolColorArray colors, const PoolVector2Array uvs, const Ref<Texture> texture = nullptr, const double width = 1, const Ref<Texture> normal_map = nullptr);
void draw_polygon(const PoolVector2Array points, const PoolColorArray colors, const PoolVector2Array uvs = PoolVector2Array(), const Ref<Texture> texture = nullptr, const Ref<Texture> normal_map = nullptr, const bool antialiased = false);
void draw_colored_polygon(const PoolVector2Array points, const Color color, const PoolVector2Array uvs = PoolVector2Array(), const Ref<Texture> texture = nullptr, const Ref<Texture> normal_map = nullptr, const bool antialiased = false);
void draw_string(const Ref<Font> font, const Vector2 position, const String text, const Color modulate = Color(1,1,1,1), const int64_t clip_w = -1);
double draw_char(const Ref<Font> font, const Vector2 position, const String _char, const String next, const Color modulate = Color(1,1,1,1));
void draw_mesh(const Ref<Mesh> mesh, const Ref<Texture> texture, const Ref<Texture> normal_map = nullptr);
void draw_multimesh(const Ref<Mesh> mesh, const Ref<Texture> texture, const Ref<Texture> normal_map = nullptr);
void draw_set_transform(const Vector2 position, const double rotation, const Vector2 scale);
void draw_set_transform_matrix(const Transform2D xform);
Transform2D get_transform() const;
Transform2D get_global_transform() const;
Transform2D get_global_transform_with_canvas() const;
Transform2D get_viewport_transform() const;
Rect2 get_viewport_rect() const;
Transform2D get_canvas_transform() const;
Vector2 get_local_mouse_position() const;
Vector2 get_global_mouse_position() const;
RID get_canvas() const;
Ref<World2D> get_world_2d() const;
void set_material(const Ref<Material> material);
Ref<Material> get_material() const;
void set_use_parent_material(const bool enable);
bool get_use_parent_material() const;
void set_notify_local_transform(const bool enable);
bool is_local_transform_notification_enabled() const;
void set_notify_transform(const bool enable);
bool is_transform_notification_enabled() const;
Vector2 make_canvas_position_local(const Vector2 screen_point) const;
Ref<InputEvent> make_input_local(const Ref<InputEvent> event) const;
};
}
#endif

53
include/gen/CanvasItemMaterial.hpp Normal file
View File

@ -0,0 +1,53 @@
#ifndef GODOT_CPP_CANVASITEMMATERIAL_HPP
#define GODOT_CPP_CANVASITEMMATERIAL_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <CanvasItemMaterial.hpp>
#include <Material.hpp>
namespace godot {
class CanvasItemMaterial : public Material {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CanvasItemMaterial"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum LightMode {
LIGHT_MODE_UNSHADED = 1,
LIGHT_MODE_NORMAL = 0,
LIGHT_MODE_LIGHT_ONLY = 2,
};
enum BlendMode {
BLEND_MODE_SUB = 2,
BLEND_MODE_MUL = 3,
BLEND_MODE_MIX = 0,
BLEND_MODE_PREMULT_ALPHA = 4,
BLEND_MODE_ADD = 1,
};
// constants
static CanvasItemMaterial *_new();
// methods
void set_blend_mode(const int64_t blend_mode);
CanvasItemMaterial::BlendMode get_blend_mode() const;
void set_light_mode(const int64_t light_mode);
CanvasItemMaterial::LightMode get_light_mode() const;
};
}
#endif

54
include/gen/CanvasLayer.hpp Normal file
View File

@ -0,0 +1,54 @@
#ifndef GODOT_CPP_CANVASLAYER_HPP
#define GODOT_CPP_CANVASLAYER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Node.hpp>
namespace godot {
class Object;
class Node;
class World2D;
class CanvasLayer : public Node {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CanvasLayer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CanvasLayer *_new();
// methods
void set_layer(const int64_t layer);
int64_t get_layer() const;
void set_transform(const Transform2D transform);
Transform2D get_transform() const;
void set_offset(const Vector2 offset);
Vector2 get_offset() const;
void set_rotation(const double radians);
double get_rotation() const;
void set_rotation_degrees(const double degrees);
double get_rotation_degrees() const;
void set_scale(const Vector2 scale);
Vector2 get_scale() const;
void set_custom_viewport(const Object *viewport);
Node *get_custom_viewport() const;
Ref<World2D> get_world_2d() const;
};
}
#endif

38
include/gen/CanvasModulate.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_CANVASMODULATE_HPP
#define GODOT_CPP_CANVASMODULATE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Node2D.hpp>
namespace godot {
class CanvasModulate : public Node2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CanvasModulate"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CanvasModulate *_new();
// methods
void set_color(const Color color);
Color get_color() const;
};
}
#endif

44
include/gen/CapsuleMesh.hpp Normal file
View File

@ -0,0 +1,44 @@
#ifndef GODOT_CPP_CAPSULEMESH_HPP
#define GODOT_CPP_CAPSULEMESH_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <PrimitiveMesh.hpp>
namespace godot {
class CapsuleMesh : public PrimitiveMesh {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CapsuleMesh"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CapsuleMesh *_new();
// methods
void set_radius(const double radius);
double get_radius() const;
void set_mid_height(const double mid_height);
double get_mid_height() const;
void set_radial_segments(const int64_t segments);
int64_t get_radial_segments() const;
void set_rings(const int64_t rings);
int64_t get_rings() const;
};
}
#endif

40
include/gen/CapsuleShape.hpp Normal file
View File

@ -0,0 +1,40 @@
#ifndef GODOT_CPP_CAPSULESHAPE_HPP
#define GODOT_CPP_CAPSULESHAPE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Shape.hpp>
namespace godot {
class CapsuleShape : public Shape {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CapsuleShape"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CapsuleShape *_new();
// methods
void set_radius(const double radius);
double get_radius() const;
void set_height(const double height);
double get_height() const;
};
}
#endif

40
include/gen/CapsuleShape2D.hpp Normal file
View File

@ -0,0 +1,40 @@
#ifndef GODOT_CPP_CAPSULESHAPE2D_HPP
#define GODOT_CPP_CAPSULESHAPE2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Shape2D.hpp>
namespace godot {
class CapsuleShape2D : public Shape2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CapsuleShape2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CapsuleShape2D *_new();
// methods
void set_radius(const double radius);
double get_radius() const;
void set_height(const double height);
double get_height() const;
};
}
#endif

38
include/gen/CenterContainer.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_CENTERCONTAINER_HPP
#define GODOT_CPP_CENTERCONTAINER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Container.hpp>
namespace godot {
class CenterContainer : public Container {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CenterContainer"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CenterContainer *_new();
// methods
void set_use_top_left(const bool enable);
bool is_using_top_left() const;
};
}
#endif

36
include/gen/CheckBox.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_CHECKBOX_HPP
#define GODOT_CPP_CHECKBOX_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Button.hpp>
namespace godot {
class CheckBox : public Button {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CheckBox"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CheckBox *_new();
// methods
};
}
#endif

36
include/gen/CheckButton.hpp Normal file
View File

@ -0,0 +1,36 @@
#ifndef GODOT_CPP_CHECKBUTTON_HPP
#define GODOT_CPP_CHECKBUTTON_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Button.hpp>
namespace godot {
class CheckButton : public Button {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CheckButton"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CheckButton *_new();
// methods
};
}
#endif

38
include/gen/CircleShape2D.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_CIRCLESHAPE2D_HPP
#define GODOT_CPP_CIRCLESHAPE2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Shape2D.hpp>
namespace godot {
class CircleShape2D : public Shape2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CircleShape2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CircleShape2D *_new();
// methods
void set_radius(const double radius);
double get_radius() const;
};
}
#endif

66
include/gen/ClassDB.hpp Normal file
View File

@ -0,0 +1,66 @@
#ifndef GODOT_CPP_CLASSDB_HPP
#define GODOT_CPP_CLASSDB_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Object.hpp>
namespace godot {
class Object;
class ClassDB : public Object {
static ClassDB *_singleton;
ClassDB();
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline ClassDB *get_singleton()
{
if (!ClassDB::_singleton) {
ClassDB::_singleton = new ClassDB;
}
return ClassDB::_singleton;
}
static inline const char *___get_class_name() { return (const char *) "ClassDB"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
// methods
PoolStringArray get_class_list() const;
PoolStringArray get_inheriters_from_class(const String _class) const;
String get_parent_class(const String _class) const;
bool class_exists(const String _class) const;
bool is_parent_class(const String _class, const String inherits) const;
bool can_instance(const String _class) const;
Variant instance(const String _class) const;
bool class_has_signal(const String _class, const String signal) const;
Dictionary class_get_signal(const String _class, const String signal) const;
Array class_get_signal_list(const String _class, const bool no_inheritance = false) const;
Array class_get_property_list(const String _class, const bool no_inheritance = false) const;
Variant class_get_property(const Object *object, const String property) const;
Error class_set_property(const Object *object, const String property, const Variant value) const;
bool class_has_method(const String _class, const String method, const bool no_inheritance = false) const;
Array class_get_method_list(const String _class, const bool no_inheritance = false) const;
PoolStringArray class_get_integer_constant_list(const String _class, const bool no_inheritance = false) const;
bool class_has_integer_constant(const String _class, const String name) const;
int64_t class_get_integer_constant(const String _class, const String name) const;
String class_get_category(const String _class) const;
bool is_class_enabled(const String _class) const;
};
}
#endif

57
include/gen/CollisionObject.hpp Normal file
View File

@ -0,0 +1,57 @@
#ifndef GODOT_CPP_COLLISIONOBJECT_HPP
#define GODOT_CPP_COLLISIONOBJECT_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Spatial.hpp>
namespace godot {
class Object;
class InputEvent;
class Shape;
class CollisionObject : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CollisionObject"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
// methods
void _input_event(const Object *camera, const Ref<InputEvent> event, const Vector3 click_position, const Vector3 click_normal, const int64_t shape_idx);
void set_ray_pickable(const bool ray_pickable);
bool is_ray_pickable() const;
void set_capture_input_on_drag(const bool enable);
bool get_capture_input_on_drag() const;
RID get_rid() const;
int64_t create_shape_owner(const Object *owner);
void remove_shape_owner(const int64_t owner_id);
Array get_shape_owners();
void shape_owner_set_transform(const int64_t owner_id, const Transform transform);
Transform shape_owner_get_transform(const int64_t owner_id) const;
Object *shape_owner_get_owner(const int64_t owner_id) const;
void shape_owner_set_disabled(const int64_t owner_id, const bool disabled);
bool is_shape_owner_disabled(const int64_t owner_id) const;
void shape_owner_add_shape(const int64_t owner_id, const Ref<Shape> shape);
int64_t shape_owner_get_shape_count(const int64_t owner_id) const;
Ref<Shape> shape_owner_get_shape(const int64_t owner_id, const int64_t shape_id) const;
int64_t shape_owner_get_shape_index(const int64_t owner_id, const int64_t shape_id) const;
void shape_owner_remove_shape(const int64_t owner_id, const int64_t shape_id);
void shape_owner_clear_shapes(const int64_t owner_id);
int64_t shape_find_owner(const int64_t shape_index) const;
};
}
#endif

57
include/gen/CollisionObject2D.hpp Normal file
View File

@ -0,0 +1,57 @@
#ifndef GODOT_CPP_COLLISIONOBJECT2D_HPP
#define GODOT_CPP_COLLISIONOBJECT2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Node2D.hpp>
namespace godot {
class Object;
class InputEvent;
class Shape2D;
class CollisionObject2D : public Node2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CollisionObject2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
// methods
void _input_event(const Object *viewport, const Ref<InputEvent> event, const int64_t shape_idx);
RID get_rid() const;
void set_pickable(const bool enabled);
bool is_pickable() const;
int64_t create_shape_owner(const Object *owner);
void remove_shape_owner(const int64_t owner_id);
Array get_shape_owners();
void shape_owner_set_transform(const int64_t owner_id, const Transform2D transform);
Transform2D shape_owner_get_transform(const int64_t owner_id) const;
Object *shape_owner_get_owner(const int64_t owner_id) const;
void shape_owner_set_disabled(const int64_t owner_id, const bool disabled);
bool is_shape_owner_disabled(const int64_t owner_id) const;
void shape_owner_set_one_way_collision(const int64_t owner_id, const bool enable);
bool is_shape_owner_one_way_collision_enabled(const int64_t owner_id) const;
void shape_owner_add_shape(const int64_t owner_id, const Ref<Shape2D> shape);
int64_t shape_owner_get_shape_count(const int64_t owner_id) const;
Ref<Shape2D> shape_owner_get_shape(const int64_t owner_id, const int64_t shape_id) const;
int64_t shape_owner_get_shape_index(const int64_t owner_id, const int64_t shape_id) const;
void shape_owner_remove_shape(const int64_t owner_id, const int64_t shape_id);
void shape_owner_clear_shapes(const int64_t owner_id);
int64_t shape_find_owner(const int64_t shape_index) const;
};
}
#endif

42
include/gen/CollisionPolygon.hpp Normal file
View File

@ -0,0 +1,42 @@
#ifndef GODOT_CPP_COLLISIONPOLYGON_HPP
#define GODOT_CPP_COLLISIONPOLYGON_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Spatial.hpp>
namespace godot {
class CollisionPolygon : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CollisionPolygon"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CollisionPolygon *_new();
// methods
void set_depth(const double depth);
double get_depth() const;
void set_polygon(const PoolVector2Array polygon);
PoolVector2Array get_polygon() const;
void set_disabled(const bool disabled);
bool is_disabled() const;
};
}
#endif

49
include/gen/CollisionPolygon2D.hpp Normal file
View File

@ -0,0 +1,49 @@
#ifndef GODOT_CPP_COLLISIONPOLYGON2D_HPP
#define GODOT_CPP_COLLISIONPOLYGON2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <CollisionPolygon2D.hpp>
#include <Node2D.hpp>
namespace godot {
class CollisionPolygon2D : public Node2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CollisionPolygon2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum BuildMode {
BUILD_SOLIDS = 0,
BUILD_SEGMENTS = 1,
};
// constants
static CollisionPolygon2D *_new();
// methods
void set_polygon(const PoolVector2Array polygon);
PoolVector2Array get_polygon() const;
void set_build_mode(const int64_t build_mode);
CollisionPolygon2D::BuildMode get_build_mode() const;
void set_disabled(const bool disabled);
bool is_disabled() const;
void set_one_way_collision(const bool enabled);
bool is_one_way_collision_enabled() const;
};
}
#endif

44
include/gen/CollisionShape.hpp Normal file
View File

@ -0,0 +1,44 @@
#ifndef GODOT_CPP_COLLISIONSHAPE_HPP
#define GODOT_CPP_COLLISIONSHAPE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Spatial.hpp>
namespace godot {
class Resource;
class Shape;
class CollisionShape : public Spatial {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CollisionShape"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CollisionShape *_new();
// methods
void resource_changed(const Ref<Resource> resource);
void set_shape(const Ref<Shape> shape);
Ref<Shape> get_shape() const;
void set_disabled(const bool enable);
bool is_disabled() const;
void make_convex_from_brothers();
};
}
#endif

44
include/gen/CollisionShape2D.hpp Normal file
View File

@ -0,0 +1,44 @@
#ifndef GODOT_CPP_COLLISIONSHAPE2D_HPP
#define GODOT_CPP_COLLISIONSHAPE2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Node2D.hpp>
namespace godot {
class Shape2D;
class CollisionShape2D : public Node2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CollisionShape2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CollisionShape2D *_new();
// methods
void set_shape(const Ref<Shape2D> shape);
Ref<Shape2D> get_shape() const;
void set_disabled(const bool disabled);
bool is_disabled() const;
void set_one_way_collision(const bool enabled);
bool is_one_way_collision_enabled() const;
void _shape_changed();
};
}
#endif

60
include/gen/ColorPicker.hpp Normal file
View File

@ -0,0 +1,60 @@
#ifndef GODOT_CPP_COLORPICKER_HPP
#define GODOT_CPP_COLORPICKER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <BoxContainer.hpp>
namespace godot {
class Object;
class InputEvent;
class ColorPicker : public BoxContainer {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ColorPicker"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ColorPicker *_new();
// methods
void set_pick_color(const Color color);
Color get_pick_color() const;
void set_raw_mode(const bool mode);
bool is_raw_mode() const;
void set_edit_alpha(const bool show);
bool is_editing_alpha() const;
void add_preset(const Color color);
void _value_changed(const double arg0);
void _html_entered(const String arg0);
void _text_type_toggled();
void _add_preset_pressed();
void _screen_pick_pressed();
void _sample_draw();
void _update_presets();
void _hsv_draw(const int64_t arg0, const Object *arg1);
void _uv_input(const Ref<InputEvent> arg0);
void _w_input(const Ref<InputEvent> arg0);
void _preset_input(const Ref<InputEvent> arg0);
void _screen_input(const Ref<InputEvent> arg0);
void _focus_enter();
void _focus_exit();
void _html_focus_exit();
};
}
#endif

45
include/gen/ColorPickerButton.hpp Normal file
View File

@ -0,0 +1,45 @@
#ifndef GODOT_CPP_COLORPICKERBUTTON_HPP
#define GODOT_CPP_COLORPICKERBUTTON_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Button.hpp>
namespace godot {
class ColorPicker;
class PopupPanel;
class ColorPickerButton : public Button {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ColorPickerButton"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ColorPickerButton *_new();
// methods
void set_pick_color(const Color color);
Color get_pick_color() const;
ColorPicker *get_picker() const;
PopupPanel *get_popup() const;
void set_edit_alpha(const bool show);
bool is_editing_alpha() const;
void _color_changed(const Color arg0);
};
}
#endif

38
include/gen/ColorRect.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_COLORRECT_HPP
#define GODOT_CPP_COLORRECT_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Control.hpp>
namespace godot {
class ColorRect : public Control {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ColorRect"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ColorRect *_new();
// methods
void set_frame_color(const Color color);
Color get_frame_color() const;
};
}
#endif

38
include/gen/ConcavePolygonShape.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_CONCAVEPOLYGONSHAPE_HPP
#define GODOT_CPP_CONCAVEPOLYGONSHAPE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Shape.hpp>
namespace godot {
class ConcavePolygonShape : public Shape {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ConcavePolygonShape"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ConcavePolygonShape *_new();
// methods
void set_faces(const PoolVector3Array faces);
PoolVector3Array get_faces() const;
};
}
#endif

38
include/gen/ConcavePolygonShape2D.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_CONCAVEPOLYGONSHAPE2D_HPP
#define GODOT_CPP_CONCAVEPOLYGONSHAPE2D_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Shape2D.hpp>
namespace godot {
class ConcavePolygonShape2D : public Shape2D {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ConcavePolygonShape2D"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ConcavePolygonShape2D *_new();
// methods
void set_segments(const PoolVector2Array segments);
PoolVector2Array get_segments() const;
};
}
#endif

50
include/gen/ConeTwistJoint.hpp Normal file
View File

@ -0,0 +1,50 @@
#ifndef GODOT_CPP_CONETWISTJOINT_HPP
#define GODOT_CPP_CONETWISTJOINT_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Joint.hpp>
namespace godot {
class ConeTwistJoint : public Joint {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ConeTwistJoint"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum Param {
PARAM_RELAXATION = 4,
PARAM_SOFTNESS = 3,
PARAM_TWIST_SPAN = 1,
PARAM_SWING_SPAN = 0,
PARAM_MAX = 5,
PARAM_BIAS = 2,
};
// constants
static ConeTwistJoint *_new();
// methods
void set_param(const int64_t param, const double value);
double get_param(const int64_t param) const;
void _set_swing_span(const double swing_span);
double _get_swing_span() const;
void _set_twist_span(const double twist_span);
double _get_twist_span() const;
};
}
#endif

45
include/gen/ConfigFile.hpp Normal file
View File

@ -0,0 +1,45 @@
#ifndef GODOT_CPP_CONFIGFILE_HPP
#define GODOT_CPP_CONFIGFILE_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Reference.hpp>
namespace godot {
class ConfigFile : public Reference {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ConfigFile"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ConfigFile *_new();
// methods
void set_value(const String section, const String key, const Variant value);
Variant get_value(const String section, const String key, const Variant _default = Variant()) const;
bool has_section(const String section) const;
bool has_section_key(const String section, const String key) const;
PoolStringArray get_sections() const;
PoolStringArray get_section_keys(const String section) const;
void erase_section(const String section);
Error load(const String path);
Error save(const String path);
};
}
#endif

38
include/gen/ConfirmationDialog.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef GODOT_CPP_CONFIRMATIONDIALOG_HPP
#define GODOT_CPP_CONFIRMATIONDIALOG_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <AcceptDialog.hpp>
namespace godot {
class Button;
class ConfirmationDialog : public AcceptDialog {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "ConfirmationDialog"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static ConfirmationDialog *_new();
// methods
Button *get_cancel();
};
}
#endif

42
include/gen/Container.hpp Normal file
View File

@ -0,0 +1,42 @@
#ifndef GODOT_CPP_CONTAINER_HPP
#define GODOT_CPP_CONTAINER_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include <Control.hpp>
namespace godot {
class Object;
class Container : public Control {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "Container"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
const static int NOTIFICATION_SORT_CHILDREN = 50;
static Container *_new();
// methods
void _sort_children();
void _child_minsize_changed();
void queue_sort();
void fit_child_in_rect(const Object *child, const Rect2 rect);
};
}
#endif

Some files were not shown because too many files have changed in this diff Show More