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.

.gitignore

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

binding_generator.py

@@ -119,14 +119,43 @@ 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("")
 
+    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("")
+
+        # godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");"
+
     # ___get_class_name
-    source.append("\tstatic inline char *___get_class_name() { return (char *) \"" + strip_name(c["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) { return (Object *) a; }")
+    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("}")
     

include/core/Godot.hpp

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

include/core/GodotGlobal.hpp

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

include/core/Variant.hpp

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

include/gen/ARVRAnchor.hpp

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

include/gen/ARVRCamera.hpp

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

include/gen/ARVRController.hpp

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

include/gen/ARVRInterface.hpp

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

include/gen/ARVRInterfaceGDNative.hpp

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

include/gen/ARVROrigin.hpp

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

include/gen/ARVRPositionalTracker.hpp

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

include/gen/ARVRServer.hpp

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

include/gen/AStar.hpp

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

include/gen/AcceptDialog.hpp

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

include/gen/AnimatedSprite.hpp

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

include/gen/AnimatedSprite3D.hpp

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

include/gen/Animation.hpp

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

include/gen/AnimationPlayer.hpp

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

include/gen/AnimationTreePlayer.hpp

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

include/gen/Area.hpp

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

include/gen/Area2D.hpp

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

include/gen/ArrayMesh.hpp

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

include/gen/AtlasTexture.hpp

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

include/gen/AudioBusLayout.hpp

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

include/gen/AudioEffect.hpp

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

include/gen/AudioEffectAmplify.hpp

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

include/gen/AudioEffectBandLimitFilter.hpp

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

include/gen/AudioEffectBandPassFilter.hpp

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

include/gen/AudioEffectChorus.hpp

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

include/gen/AudioEffectCompressor.hpp

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

include/gen/AudioEffectDelay.hpp

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

include/gen/AudioEffectDistortion.hpp

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

include/gen/AudioEffectEQ.hpp

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

include/gen/AudioEffectEQ10.hpp

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

include/gen/AudioEffectEQ21.hpp

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

include/gen/AudioEffectEQ6.hpp

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

include/gen/AudioEffectFilter.hpp

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

include/gen/AudioEffectHighPassFilter.hpp

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

include/gen/AudioEffectHighShelfFilter.hpp

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

include/gen/AudioEffectLimiter.hpp

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

include/gen/AudioEffectLowPassFilter.hpp

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

include/gen/AudioEffectLowShelfFilter.hpp

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

include/gen/AudioEffectNotchFilter.hpp

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

include/gen/AudioEffectPanner.hpp

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

include/gen/AudioEffectPhaser.hpp

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

include/gen/AudioEffectPitchShift.hpp

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

include/gen/AudioEffectReverb.hpp

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

include/gen/AudioEffectStereoEnhance.hpp

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

include/gen/AudioServer.hpp

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

include/gen/AudioStream.hpp

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

include/gen/AudioStreamOGGVorbis.hpp

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

include/gen/AudioStreamPlayback.hpp

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

include/gen/AudioStreamPlayer.hpp

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

include/gen/AudioStreamPlayer2D.hpp

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

include/gen/AudioStreamPlayer3D.hpp

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

include/gen/AudioStreamRandomPitch.hpp

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

include/gen/AudioStreamSample.hpp

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

include/gen/BackBufferCopy.hpp

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

include/gen/BakedLightmap.hpp

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

include/gen/BakedLightmapData.hpp

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

include/gen/BaseButton.hpp

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

include/gen/BitMap.hpp

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

include/gen/BitmapFont.hpp

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

include/gen/BoneAttachment.hpp

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

include/gen/BoxContainer.hpp

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

include/gen/BoxShape.hpp

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

include/gen/BulletPhysicsDirectBodyState.hpp

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

include/gen/BulletPhysicsServer.hpp

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

include/gen/Button.hpp

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

include/gen/ButtonGroup.hpp

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

include/gen/Camera.hpp

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

include/gen/Camera2D.hpp

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

include/gen/CanvasItem.hpp

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

include/gen/CanvasItemMaterial.hpp

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

include/gen/CanvasLayer.hpp

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

include/gen/CanvasModulate.hpp

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

include/gen/CapsuleMesh.hpp

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

include/gen/CapsuleShape.hpp

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

include/gen/CapsuleShape2D.hpp

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

include/gen/CenterContainer.hpp

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

include/gen/CheckBox.hpp

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

include/gen/CheckButton.hpp

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

include/gen/CircleShape2D.hpp

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

include/gen/ClassDB.hpp

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

include/gen/CollisionObject.hpp

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

include/gen/CollisionObject2D.hpp

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

include/gen/CollisionPolygon.hpp

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

include/gen/CollisionPolygon2D.hpp

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

include/gen/CollisionShape.hpp

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

include/gen/CollisionShape2D.hpp

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

include/gen/ColorPicker.hpp

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

include/gen/ColorPickerButton.hpp

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

include/gen/ColorRect.hpp

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

include/gen/ConcavePolygonShape.hpp

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

include/gen/ConcavePolygonShape2D.hpp

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

include/gen/ConeTwistJoint.hpp

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

include/gen/ConfigFile.hpp

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

include/gen/ConfirmationDialog.hpp

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

include/gen/Container.hpp

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