lib + include + Godot dossier

GodoBinding/include/gen/ARVRAnchor.hpp

@@ -0,0 +1,54 @@
+#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 Mesh;
+
+class ARVRAnchor : public Spatial {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_anchor_id;
+		godot_method_bind *mb_get_anchor_name;
+		godot_method_bind *mb_get_is_active;
+		godot_method_bind *mb_get_mesh;
+		godot_method_bind *mb_get_plane;
+		godot_method_bind *mb_get_size;
+		godot_method_bind *mb_set_anchor_id;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static ARVRAnchor *_new();
+
+	// methods
+	int64_t get_anchor_id() const;
+	String get_anchor_name() const;
+	bool get_is_active() const;
+	Ref<Mesh> get_mesh() const;
+	Plane get_plane() const;
+	Vector3 get_size() const;
+	void set_anchor_id(const int64_t anchor_id);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ARVRCamera.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static ARVRCamera *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ARVRController.hpp

@@ -0,0 +1,63 @@
+#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 Mesh;
+
+class ARVRController : public Spatial {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_controller_id;
+		godot_method_bind *mb_get_controller_name;
+		godot_method_bind *mb_get_hand;
+		godot_method_bind *mb_get_is_active;
+		godot_method_bind *mb_get_joystick_axis;
+		godot_method_bind *mb_get_joystick_id;
+		godot_method_bind *mb_get_mesh;
+		godot_method_bind *mb_get_rumble;
+		godot_method_bind *mb_is_button_pressed;
+		godot_method_bind *mb_set_controller_id;
+		godot_method_bind *mb_set_rumble;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static ARVRController *_new();
+
+	// methods
+	int64_t get_controller_id() const;
+	String get_controller_name() const;
+	ARVRPositionalTracker::TrackerHand get_hand() const;
+	bool get_is_active() const;
+	real_t get_joystick_axis(const int64_t axis) const;
+	int64_t get_joystick_id() const;
+	Ref<Mesh> get_mesh() const;
+	real_t get_rumble() const;
+	int64_t is_button_pressed(const int64_t button) const;
+	void set_controller_id(const int64_t controller_id);
+	void set_rumble(const real_t rumble);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ARVRInterface.hpp

@@ -0,0 +1,84 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_anchor_detection_is_enabled;
+		godot_method_bind *mb_get_camera_feed_id;
+		godot_method_bind *mb_get_capabilities;
+		godot_method_bind *mb_get_name;
+		godot_method_bind *mb_get_render_targetsize;
+		godot_method_bind *mb_get_tracking_status;
+		godot_method_bind *mb_initialize;
+		godot_method_bind *mb_is_initialized;
+		godot_method_bind *mb_is_primary;
+		godot_method_bind *mb_is_stereo;
+		godot_method_bind *mb_set_anchor_detection_is_enabled;
+		godot_method_bind *mb_set_is_initialized;
+		godot_method_bind *mb_set_is_primary;
+		godot_method_bind *mb_uninitialize;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum Tracking_status {
+		ARVR_NORMAL_TRACKING = 0,
+		ARVR_EXCESSIVE_MOTION = 1,
+		ARVR_INSUFFICIENT_FEATURES = 2,
+		ARVR_UNKNOWN_TRACKING = 3,
+		ARVR_NOT_TRACKING = 4,
+	};
+	enum Eyes {
+		EYE_MONO = 0,
+		EYE_LEFT = 1,
+		EYE_RIGHT = 2,
+	};
+	enum Capabilities {
+		ARVR_NONE = 0,
+		ARVR_MONO = 1,
+		ARVR_STEREO = 2,
+		ARVR_AR = 4,
+		ARVR_EXTERNAL = 8,
+	};
+
+	// constants
+
+	// methods
+	bool get_anchor_detection_is_enabled() const;
+	int64_t get_camera_feed_id();
+	int64_t get_capabilities() const;
+	String get_name() const;
+	Vector2 get_render_targetsize();
+	ARVRInterface::Tracking_status get_tracking_status() const;
+	bool initialize();
+	bool is_initialized() const;
+	bool is_primary();
+	bool is_stereo();
+	void set_anchor_detection_is_enabled(const bool enable);
+	void set_is_initialized(const bool initialized);
+	void set_is_primary(const bool enable);
+	void uninitialize();
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ARVRInterfaceGDNative.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static ARVRInterfaceGDNative *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ARVROrigin.hpp

@@ -0,0 +1,43 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_world_scale;
+		godot_method_bind *mb_set_world_scale;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static ARVROrigin *_new();
+
+	// methods
+	real_t get_world_scale() const;
+	void set_world_scale(const real_t world_scale);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ARVRPositionalTracker.hpp

@@ -0,0 +1,83 @@
+#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 "ARVRPositionalTracker.hpp"
+#include "ARVRServer.hpp"
+
+#include "Object.hpp"
+namespace godot {
+
+class Mesh;
+
+class ARVRPositionalTracker : public Object {
+	struct ___method_bindings {
+		godot_method_bind *mb__set_joy_id;
+		godot_method_bind *mb__set_mesh;
+		godot_method_bind *mb__set_name;
+		godot_method_bind *mb__set_orientation;
+		godot_method_bind *mb__set_rw_position;
+		godot_method_bind *mb__set_type;
+		godot_method_bind *mb_get_hand;
+		godot_method_bind *mb_get_joy_id;
+		godot_method_bind *mb_get_mesh;
+		godot_method_bind *mb_get_name;
+		godot_method_bind *mb_get_orientation;
+		godot_method_bind *mb_get_position;
+		godot_method_bind *mb_get_rumble;
+		godot_method_bind *mb_get_tracks_orientation;
+		godot_method_bind *mb_get_tracks_position;
+		godot_method_bind *mb_get_transform;
+		godot_method_bind *mb_get_type;
+		godot_method_bind *mb_set_rumble;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum TrackerHand {
+		TRACKER_HAND_UNKNOWN = 0,
+		TRACKER_LEFT_HAND = 1,
+		TRACKER_RIGHT_HAND = 2,
+	};
+
+	// constants
+
+
+	static ARVRPositionalTracker *_new();
+
+	// methods
+	void _set_joy_id(const int64_t joy_id);
+	void _set_mesh(const Ref<Mesh> mesh);
+	void _set_name(const String name);
+	void _set_orientation(const Basis orientation);
+	void _set_rw_position(const Vector3 rw_position);
+	void _set_type(const int64_t type);
+	ARVRPositionalTracker::TrackerHand get_hand() const;
+	int64_t get_joy_id() const;
+	Ref<Mesh> get_mesh() const;
+	String get_name() const;
+	Basis get_orientation() const;
+	Vector3 get_position() const;
+	real_t get_rumble() const;
+	bool get_tracks_orientation() const;
+	bool get_tracks_position() const;
+	Transform get_transform(const bool adjust_by_reference_frame) const;
+	ARVRServer::TrackerType get_type() const;
+	void set_rumble(const real_t rumble);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ARVRServer.hpp

@@ -0,0 +1,95 @@
+#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();
+
+	struct ___method_bindings {
+		godot_method_bind *mb_center_on_hmd;
+		godot_method_bind *mb_find_interface;
+		godot_method_bind *mb_get_hmd_transform;
+		godot_method_bind *mb_get_interface;
+		godot_method_bind *mb_get_interface_count;
+		godot_method_bind *mb_get_interfaces;
+		godot_method_bind *mb_get_last_commit_usec;
+		godot_method_bind *mb_get_last_frame_usec;
+		godot_method_bind *mb_get_last_process_usec;
+		godot_method_bind *mb_get_primary_interface;
+		godot_method_bind *mb_get_reference_frame;
+		godot_method_bind *mb_get_tracker;
+		godot_method_bind *mb_get_tracker_count;
+		godot_method_bind *mb_get_world_scale;
+		godot_method_bind *mb_set_primary_interface;
+		godot_method_bind *mb_set_world_scale;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum RotationMode {
+		RESET_FULL_ROTATION = 0,
+		RESET_BUT_KEEP_TILT = 1,
+		DONT_RESET_ROTATION = 2,
+	};
+	enum TrackerType {
+		TRACKER_CONTROLLER = 1,
+		TRACKER_BASESTATION = 2,
+		TRACKER_ANCHOR = 4,
+		TRACKER_ANY_KNOWN = 127,
+		TRACKER_UNKNOWN = 128,
+		TRACKER_ANY = 255,
+	};
+
+	// constants
+
+	// methods
+	void center_on_hmd(const int64_t rotation_mode, const bool keep_height);
+	Ref<ARVRInterface> find_interface(const String name) const;
+	Transform get_hmd_transform();
+	Ref<ARVRInterface> get_interface(const int64_t idx) const;
+	int64_t get_interface_count() const;
+	Array get_interfaces() const;
+	int64_t get_last_commit_usec();
+	int64_t get_last_frame_usec();
+	int64_t get_last_process_usec();
+	Ref<ARVRInterface> get_primary_interface() const;
+	Transform get_reference_frame() const;
+	ARVRPositionalTracker *get_tracker(const int64_t idx) const;
+	int64_t get_tracker_count() const;
+	real_t get_world_scale() const;
+	void set_primary_interface(const Ref<ARVRInterface> interface);
+	void set_world_scale(const real_t arg0);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AStar.hpp

@@ -0,0 +1,89 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb__compute_cost;
+		godot_method_bind *mb__estimate_cost;
+		godot_method_bind *mb_add_point;
+		godot_method_bind *mb_are_points_connected;
+		godot_method_bind *mb_clear;
+		godot_method_bind *mb_connect_points;
+		godot_method_bind *mb_disconnect_points;
+		godot_method_bind *mb_get_available_point_id;
+		godot_method_bind *mb_get_closest_point;
+		godot_method_bind *mb_get_closest_position_in_segment;
+		godot_method_bind *mb_get_id_path;
+		godot_method_bind *mb_get_point_capacity;
+		godot_method_bind *mb_get_point_connections;
+		godot_method_bind *mb_get_point_count;
+		godot_method_bind *mb_get_point_path;
+		godot_method_bind *mb_get_point_position;
+		godot_method_bind *mb_get_point_weight_scale;
+		godot_method_bind *mb_get_points;
+		godot_method_bind *mb_has_point;
+		godot_method_bind *mb_is_point_disabled;
+		godot_method_bind *mb_remove_point;
+		godot_method_bind *mb_reserve_space;
+		godot_method_bind *mb_set_point_disabled;
+		godot_method_bind *mb_set_point_position;
+		godot_method_bind *mb_set_point_weight_scale;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AStar *_new();
+
+	// methods
+	real_t _compute_cost(const int64_t from_id, const int64_t to_id);
+	real_t _estimate_cost(const int64_t from_id, const int64_t to_id);
+	void add_point(const int64_t id, const Vector3 position, const real_t weight_scale = 1);
+	bool are_points_connected(const int64_t id, const int64_t to_id, const bool bidirectional = true) const;
+	void clear();
+	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, const bool bidirectional = true);
+	int64_t get_available_point_id() const;
+	int64_t get_closest_point(const Vector3 to_position, const bool include_disabled = false) const;
+	Vector3 get_closest_position_in_segment(const Vector3 to_position) const;
+	PoolIntArray get_id_path(const int64_t from_id, const int64_t to_id);
+	int64_t get_point_capacity() const;
+	PoolIntArray get_point_connections(const int64_t id);
+	int64_t get_point_count() const;
+	PoolVector3Array get_point_path(const int64_t from_id, const int64_t to_id);
+	Vector3 get_point_position(const int64_t id) const;
+	real_t get_point_weight_scale(const int64_t id) const;
+	Array get_points();
+	bool has_point(const int64_t id) const;
+	bool is_point_disabled(const int64_t id) const;
+	void remove_point(const int64_t id);
+	void reserve_space(const int64_t num_nodes);
+	void set_point_disabled(const int64_t id, const bool disabled = true);
+	void set_point_position(const int64_t id, const Vector3 position);
+	void set_point_weight_scale(const int64_t id, const real_t weight_scale);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AStar2D.hpp

@@ -0,0 +1,85 @@
+#ifndef GODOT_CPP_ASTAR2D_HPP
+#define GODOT_CPP_ASTAR2D_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "Reference.hpp"
+namespace godot {
+
+
+class AStar2D : public Reference {
+	struct ___method_bindings {
+		godot_method_bind *mb_add_point;
+		godot_method_bind *mb_are_points_connected;
+		godot_method_bind *mb_clear;
+		godot_method_bind *mb_connect_points;
+		godot_method_bind *mb_disconnect_points;
+		godot_method_bind *mb_get_available_point_id;
+		godot_method_bind *mb_get_closest_point;
+		godot_method_bind *mb_get_closest_position_in_segment;
+		godot_method_bind *mb_get_id_path;
+		godot_method_bind *mb_get_point_capacity;
+		godot_method_bind *mb_get_point_connections;
+		godot_method_bind *mb_get_point_count;
+		godot_method_bind *mb_get_point_path;
+		godot_method_bind *mb_get_point_position;
+		godot_method_bind *mb_get_point_weight_scale;
+		godot_method_bind *mb_get_points;
+		godot_method_bind *mb_has_point;
+		godot_method_bind *mb_is_point_disabled;
+		godot_method_bind *mb_remove_point;
+		godot_method_bind *mb_reserve_space;
+		godot_method_bind *mb_set_point_disabled;
+		godot_method_bind *mb_set_point_position;
+		godot_method_bind *mb_set_point_weight_scale;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AStar2D"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AStar2D *_new();
+
+	// methods
+	void add_point(const int64_t id, const Vector2 position, const real_t weight_scale = 1);
+	bool are_points_connected(const int64_t id, const int64_t to_id) const;
+	void clear();
+	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);
+	int64_t get_available_point_id() const;
+	int64_t get_closest_point(const Vector2 to_position, const bool include_disabled = false) const;
+	Vector2 get_closest_position_in_segment(const Vector2 to_position) const;
+	PoolIntArray get_id_path(const int64_t from_id, const int64_t to_id);
+	int64_t get_point_capacity() const;
+	PoolIntArray get_point_connections(const int64_t id);
+	int64_t get_point_count() const;
+	PoolVector2Array get_point_path(const int64_t from_id, const int64_t to_id);
+	Vector2 get_point_position(const int64_t id) const;
+	real_t get_point_weight_scale(const int64_t id) const;
+	Array get_points();
+	bool has_point(const int64_t id) const;
+	bool is_point_disabled(const int64_t id) const;
+	void remove_point(const int64_t id);
+	void reserve_space(const int64_t num_nodes);
+	void set_point_disabled(const int64_t id, const bool disabled = true);
+	void set_point_position(const int64_t id, const Vector2 position);
+	void set_point_weight_scale(const int64_t id, const real_t weight_scale);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AcceptDialog.hpp

@@ -0,0 +1,70 @@
+#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 Node;
+
+class AcceptDialog : public WindowDialog {
+	struct ___method_bindings {
+		godot_method_bind *mb__builtin_text_entered;
+		godot_method_bind *mb__custom_action;
+		godot_method_bind *mb__ok;
+		godot_method_bind *mb_add_button;
+		godot_method_bind *mb_add_cancel;
+		godot_method_bind *mb_get_hide_on_ok;
+		godot_method_bind *mb_get_label;
+		godot_method_bind *mb_get_ok;
+		godot_method_bind *mb_get_text;
+		godot_method_bind *mb_has_autowrap;
+		godot_method_bind *mb_register_text_enter;
+		godot_method_bind *mb_set_autowrap;
+		godot_method_bind *mb_set_hide_on_ok;
+		godot_method_bind *mb_set_text;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AcceptDialog *_new();
+
+	// methods
+	void _builtin_text_entered(const String arg0);
+	void _custom_action(const String arg0);
+	void _ok();
+	Button *add_button(const String text, const bool right = false, const String action = "");
+	Button *add_cancel(const String name);
+	bool get_hide_on_ok() const;
+	Label *get_label();
+	Button *get_ok();
+	String get_text() const;
+	bool has_autowrap();
+	void register_text_enter(const Node *line_edit);
+	void set_autowrap(const bool autowrap);
+	void set_hide_on_ok(const bool enabled);
+	void set_text(const String text);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimatedSprite.hpp

@@ -0,0 +1,84 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb__is_playing;
+		godot_method_bind *mb__res_changed;
+		godot_method_bind *mb__set_playing;
+		godot_method_bind *mb_get_animation;
+		godot_method_bind *mb_get_frame;
+		godot_method_bind *mb_get_offset;
+		godot_method_bind *mb_get_speed_scale;
+		godot_method_bind *mb_get_sprite_frames;
+		godot_method_bind *mb_is_centered;
+		godot_method_bind *mb_is_flipped_h;
+		godot_method_bind *mb_is_flipped_v;
+		godot_method_bind *mb_is_playing;
+		godot_method_bind *mb_play;
+		godot_method_bind *mb_set_animation;
+		godot_method_bind *mb_set_centered;
+		godot_method_bind *mb_set_flip_h;
+		godot_method_bind *mb_set_flip_v;
+		godot_method_bind *mb_set_frame;
+		godot_method_bind *mb_set_offset;
+		godot_method_bind *mb_set_speed_scale;
+		godot_method_bind *mb_set_sprite_frames;
+		godot_method_bind *mb_stop;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimatedSprite *_new();
+
+	// methods
+	bool _is_playing() const;
+	void _res_changed();
+	void _set_playing(const bool playing);
+	String get_animation() const;
+	int64_t get_frame() const;
+	Vector2 get_offset() const;
+	real_t get_speed_scale() const;
+	Ref<SpriteFrames> get_sprite_frames() const;
+	bool is_centered() const;
+	bool is_flipped_h() const;
+	bool is_flipped_v() const;
+	bool is_playing() const;
+	void play(const String anim = "", const bool backwards = false);
+	void set_animation(const String animation);
+	void set_centered(const bool centered);
+	void set_flip_h(const bool flip_h);
+	void set_flip_v(const bool flip_v);
+	void set_frame(const int64_t frame);
+	void set_offset(const Vector2 offset);
+	void set_speed_scale(const real_t speed_scale);
+	void set_sprite_frames(const Ref<SpriteFrames> sprite_frames);
+	void stop();
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimatedSprite3D.hpp

@@ -0,0 +1,64 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb__is_playing;
+		godot_method_bind *mb__res_changed;
+		godot_method_bind *mb__set_playing;
+		godot_method_bind *mb_get_animation;
+		godot_method_bind *mb_get_frame;
+		godot_method_bind *mb_get_sprite_frames;
+		godot_method_bind *mb_is_playing;
+		godot_method_bind *mb_play;
+		godot_method_bind *mb_set_animation;
+		godot_method_bind *mb_set_frame;
+		godot_method_bind *mb_set_sprite_frames;
+		godot_method_bind *mb_stop;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimatedSprite3D *_new();
+
+	// methods
+	bool _is_playing() const;
+	void _res_changed();
+	void _set_playing(const bool playing);
+	String get_animation() const;
+	int64_t get_frame() const;
+	Ref<SpriteFrames> get_sprite_frames() const;
+	bool is_playing() const;
+	void play(const String anim = "");
+	void set_animation(const String animation);
+	void set_frame(const int64_t frame);
+	void set_sprite_frames(const Ref<SpriteFrames> sprite_frames);
+	void stop();
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimatedTexture.hpp

@@ -0,0 +1,59 @@
+#ifndef GODOT_CPP_ANIMATEDTEXTURE_HPP
+#define GODOT_CPP_ANIMATEDTEXTURE_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 AnimatedTexture : public Texture {
+	struct ___method_bindings {
+		godot_method_bind *mb__update_proxy;
+		godot_method_bind *mb_get_fps;
+		godot_method_bind *mb_get_frame_delay;
+		godot_method_bind *mb_get_frame_texture;
+		godot_method_bind *mb_get_frames;
+		godot_method_bind *mb_set_fps;
+		godot_method_bind *mb_set_frame_delay;
+		godot_method_bind *mb_set_frame_texture;
+		godot_method_bind *mb_set_frames;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimatedTexture"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+	const static int MAX_FRAMES = 256;
+
+
+	static AnimatedTexture *_new();
+
+	// methods
+	void _update_proxy();
+	real_t get_fps() const;
+	real_t get_frame_delay(const int64_t frame) const;
+	Ref<Texture> get_frame_texture(const int64_t frame) const;
+	int64_t get_frames() const;
+	void set_fps(const real_t fps);
+	void set_frame_delay(const int64_t frame, const real_t delay);
+	void set_frame_texture(const int64_t frame, const Ref<Texture> texture);
+	void set_frames(const int64_t frames);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/Animation.hpp

@@ -0,0 +1,189 @@
+#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 Resource;
+class Animation;
+
+class Animation : public Resource {
+	struct ___method_bindings {
+		godot_method_bind *mb_add_track;
+		godot_method_bind *mb_animation_track_get_key_animation;
+		godot_method_bind *mb_animation_track_insert_key;
+		godot_method_bind *mb_animation_track_set_key_animation;
+		godot_method_bind *mb_audio_track_get_key_end_offset;
+		godot_method_bind *mb_audio_track_get_key_start_offset;
+		godot_method_bind *mb_audio_track_get_key_stream;
+		godot_method_bind *mb_audio_track_insert_key;
+		godot_method_bind *mb_audio_track_set_key_end_offset;
+		godot_method_bind *mb_audio_track_set_key_start_offset;
+		godot_method_bind *mb_audio_track_set_key_stream;
+		godot_method_bind *mb_bezier_track_get_key_in_handle;
+		godot_method_bind *mb_bezier_track_get_key_out_handle;
+		godot_method_bind *mb_bezier_track_get_key_value;
+		godot_method_bind *mb_bezier_track_insert_key;
+		godot_method_bind *mb_bezier_track_interpolate;
+		godot_method_bind *mb_bezier_track_set_key_in_handle;
+		godot_method_bind *mb_bezier_track_set_key_out_handle;
+		godot_method_bind *mb_bezier_track_set_key_value;
+		godot_method_bind *mb_clear;
+		godot_method_bind *mb_copy_track;
+		godot_method_bind *mb_find_track;
+		godot_method_bind *mb_get_length;
+		godot_method_bind *mb_get_step;
+		godot_method_bind *mb_get_track_count;
+		godot_method_bind *mb_has_loop;
+		godot_method_bind *mb_method_track_get_key_indices;
+		godot_method_bind *mb_method_track_get_name;
+		godot_method_bind *mb_method_track_get_params;
+		godot_method_bind *mb_remove_track;
+		godot_method_bind *mb_set_length;
+		godot_method_bind *mb_set_loop;
+		godot_method_bind *mb_set_step;
+		godot_method_bind *mb_track_find_key;
+		godot_method_bind *mb_track_get_interpolation_loop_wrap;
+		godot_method_bind *mb_track_get_interpolation_type;
+		godot_method_bind *mb_track_get_key_count;
+		godot_method_bind *mb_track_get_key_time;
+		godot_method_bind *mb_track_get_key_transition;
+		godot_method_bind *mb_track_get_key_value;
+		godot_method_bind *mb_track_get_path;
+		godot_method_bind *mb_track_get_type;
+		godot_method_bind *mb_track_insert_key;
+		godot_method_bind *mb_track_is_enabled;
+		godot_method_bind *mb_track_is_imported;
+		godot_method_bind *mb_track_move_down;
+		godot_method_bind *mb_track_move_to;
+		godot_method_bind *mb_track_move_up;
+		godot_method_bind *mb_track_remove_key;
+		godot_method_bind *mb_track_remove_key_at_position;
+		godot_method_bind *mb_track_set_enabled;
+		godot_method_bind *mb_track_set_imported;
+		godot_method_bind *mb_track_set_interpolation_loop_wrap;
+		godot_method_bind *mb_track_set_interpolation_type;
+		godot_method_bind *mb_track_set_key_time;
+		godot_method_bind *mb_track_set_key_transition;
+		godot_method_bind *mb_track_set_key_value;
+		godot_method_bind *mb_track_set_path;
+		godot_method_bind *mb_track_swap;
+		godot_method_bind *mb_transform_track_insert_key;
+		godot_method_bind *mb_transform_track_interpolate;
+		godot_method_bind *mb_value_track_get_key_indices;
+		godot_method_bind *mb_value_track_get_update_mode;
+		godot_method_bind *mb_value_track_set_update_mode;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum TrackType {
+		TYPE_VALUE = 0,
+		TYPE_TRANSFORM = 1,
+		TYPE_METHOD = 2,
+		TYPE_BEZIER = 3,
+		TYPE_AUDIO = 4,
+		TYPE_ANIMATION = 5,
+	};
+	enum UpdateMode {
+		UPDATE_CONTINUOUS = 0,
+		UPDATE_DISCRETE = 1,
+		UPDATE_TRIGGER = 2,
+		UPDATE_CAPTURE = 3,
+	};
+	enum InterpolationType {
+		INTERPOLATION_NEAREST = 0,
+		INTERPOLATION_LINEAR = 1,
+		INTERPOLATION_CUBIC = 2,
+	};
+
+	// constants
+
+
+	static Animation *_new();
+
+	// methods
+	int64_t add_track(const int64_t type, const int64_t at_position = -1);
+	String animation_track_get_key_animation(const int64_t track_idx, const int64_t key_idx) const;
+	int64_t animation_track_insert_key(const int64_t track_idx, const real_t time, const String animation);
+	void animation_track_set_key_animation(const int64_t track_idx, const int64_t key_idx, const String animation);
+	real_t audio_track_get_key_end_offset(const int64_t track_idx, const int64_t key_idx) const;
+	real_t audio_track_get_key_start_offset(const int64_t track_idx, const int64_t key_idx) const;
+	Ref<Resource> audio_track_get_key_stream(const int64_t track_idx, const int64_t key_idx) const;
+	int64_t audio_track_insert_key(const int64_t track_idx, const real_t time, const Ref<Resource> stream, const real_t start_offset = 0, const real_t end_offset = 0);
+	void audio_track_set_key_end_offset(const int64_t track_idx, const int64_t key_idx, const real_t offset);
+	void audio_track_set_key_start_offset(const int64_t track_idx, const int64_t key_idx, const real_t offset);
+	void audio_track_set_key_stream(const int64_t track_idx, const int64_t key_idx, const Ref<Resource> stream);
+	Vector2 bezier_track_get_key_in_handle(const int64_t track_idx, const int64_t key_idx) const;
+	Vector2 bezier_track_get_key_out_handle(const int64_t track_idx, const int64_t key_idx) const;
+	real_t bezier_track_get_key_value(const int64_t track_idx, const int64_t key_idx) const;
+	int64_t bezier_track_insert_key(const int64_t track_idx, const real_t time, const real_t value, const Vector2 in_handle = Vector2(0, 0), const Vector2 out_handle = Vector2(0, 0));
+	real_t bezier_track_interpolate(const int64_t track_idx, const real_t time) const;
+	void bezier_track_set_key_in_handle(const int64_t track_idx, const int64_t key_idx, const Vector2 in_handle);
+	void bezier_track_set_key_out_handle(const int64_t track_idx, const int64_t key_idx, const Vector2 out_handle);
+	void bezier_track_set_key_value(const int64_t track_idx, const int64_t key_idx, const real_t value);
+	void clear();
+	void copy_track(const int64_t track_idx, const Ref<Animation> to_animation);
+	int64_t find_track(const NodePath path) const;
+	real_t get_length() const;
+	real_t get_step() const;
+	int64_t get_track_count() const;
+	bool has_loop() const;
+	PoolIntArray method_track_get_key_indices(const int64_t track_idx, const real_t time_sec, const real_t delta) const;
+	String method_track_get_name(const int64_t track_idx, const int64_t key_idx) const;
+	Array method_track_get_params(const int64_t track_idx, const int64_t key_idx) const;
+	void remove_track(const int64_t track_idx);
+	void set_length(const real_t time_sec);
+	void set_loop(const bool enabled);
+	void set_step(const real_t size_sec);
+	int64_t track_find_key(const int64_t track_idx, const real_t time, const bool exact = false) const;
+	bool track_get_interpolation_loop_wrap(const int64_t track_idx) const;
+	Animation::InterpolationType track_get_interpolation_type(const int64_t track_idx) const;
+	int64_t track_get_key_count(const int64_t track_idx) const;
+	real_t track_get_key_time(const int64_t track_idx, const int64_t key_idx) const;
+	real_t track_get_key_transition(const int64_t track_idx, const int64_t key_idx) const;
+	Variant track_get_key_value(const int64_t track_idx, const int64_t key_idx) const;
+	NodePath track_get_path(const int64_t track_idx) const;
+	Animation::TrackType track_get_type(const int64_t track_idx) const;
+	void track_insert_key(const int64_t track_idx, const real_t time, const Variant key, const real_t transition = 1);
+	bool track_is_enabled(const int64_t track_idx) const;
+	bool track_is_imported(const int64_t track_idx) const;
+	void track_move_down(const int64_t track_idx);
+	void track_move_to(const int64_t track_idx, const int64_t to_idx);
+	void track_move_up(const int64_t track_idx);
+	void track_remove_key(const int64_t track_idx, const int64_t key_idx);
+	void track_remove_key_at_position(const int64_t track_idx, const real_t position);
+	void track_set_enabled(const int64_t track_idx, const bool enabled);
+	void track_set_imported(const int64_t track_idx, const bool imported);
+	void track_set_interpolation_loop_wrap(const int64_t track_idx, const bool interpolation);
+	void track_set_interpolation_type(const int64_t track_idx, const int64_t interpolation);
+	void track_set_key_time(const int64_t track_idx, const int64_t key_idx, const real_t time);
+	void track_set_key_transition(const int64_t track_idx, const int64_t key_idx, const real_t transition);
+	void track_set_key_value(const int64_t track_idx, const int64_t key, const Variant value);
+	void track_set_path(const int64_t track_idx, const NodePath path);
+	void track_swap(const int64_t track_idx, const int64_t with_idx);
+	int64_t transform_track_insert_key(const int64_t track_idx, const real_t time, const Vector3 location, const Quat rotation, const Vector3 scale);
+	Array transform_track_interpolate(const int64_t track_idx, const real_t time_sec) const;
+	PoolIntArray value_track_get_key_indices(const int64_t track_idx, const real_t time_sec, const real_t delta) const;
+	Animation::UpdateMode value_track_get_update_mode(const int64_t track_idx) const;
+	void value_track_set_update_mode(const int64_t track_idx, const int64_t mode);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNode.hpp

@@ -0,0 +1,91 @@
+#ifndef GODOT_CPP_ANIMATIONNODE_HPP
+#define GODOT_CPP_ANIMATIONNODE_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "Resource.hpp"
+namespace godot {
+
+class AnimationNode;
+class Object;
+
+class AnimationNode : public Resource {
+	struct ___method_bindings {
+		godot_method_bind *mb__get_filters;
+		godot_method_bind *mb__set_filters;
+		godot_method_bind *mb_add_input;
+		godot_method_bind *mb_blend_animation;
+		godot_method_bind *mb_blend_input;
+		godot_method_bind *mb_blend_node;
+		godot_method_bind *mb_get_caption;
+		godot_method_bind *mb_get_child_by_name;
+		godot_method_bind *mb_get_child_nodes;
+		godot_method_bind *mb_get_input_count;
+		godot_method_bind *mb_get_input_name;
+		godot_method_bind *mb_get_parameter;
+		godot_method_bind *mb_get_parameter_default_value;
+		godot_method_bind *mb_get_parameter_list;
+		godot_method_bind *mb_has_filter;
+		godot_method_bind *mb_is_filter_enabled;
+		godot_method_bind *mb_is_path_filtered;
+		godot_method_bind *mb_process;
+		godot_method_bind *mb_remove_input;
+		godot_method_bind *mb_set_filter_enabled;
+		godot_method_bind *mb_set_filter_path;
+		godot_method_bind *mb_set_parameter;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNode"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum FilterAction {
+		FILTER_IGNORE = 0,
+		FILTER_PASS = 1,
+		FILTER_STOP = 2,
+		FILTER_BLEND = 3,
+	};
+
+	// constants
+
+
+	static AnimationNode *_new();
+
+	// methods
+	Array _get_filters() const;
+	void _set_filters(const Array filters);
+	void add_input(const String name);
+	void blend_animation(const String animation, const real_t time, const real_t delta, const bool seeked, const real_t blend);
+	real_t blend_input(const int64_t input_index, const real_t time, const bool seek, const real_t blend, const int64_t filter = 0, const bool optimize = true);
+	real_t blend_node(const String name, const Ref<AnimationNode> node, const real_t time, const bool seek, const real_t blend, const int64_t filter = 0, const bool optimize = true);
+	String get_caption();
+	Object *get_child_by_name(const String name);
+	Dictionary get_child_nodes();
+	int64_t get_input_count() const;
+	String get_input_name(const int64_t input);
+	Variant get_parameter(const String name) const;
+	Variant get_parameter_default_value(const String name);
+	Array get_parameter_list();
+	String has_filter();
+	bool is_filter_enabled() const;
+	bool is_path_filtered(const NodePath path) const;
+	void process(const real_t time, const bool seek);
+	void remove_input(const int64_t index);
+	void set_filter_enabled(const bool enable);
+	void set_filter_path(const NodePath path, const bool enable);
+	void set_parameter(const String name, const Variant value);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeAdd2.hpp

@@ -0,0 +1,43 @@
+#ifndef GODOT_CPP_ANIMATIONNODEADD2_HPP
+#define GODOT_CPP_ANIMATIONNODEADD2_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeAdd2 : public AnimationNode {
+	struct ___method_bindings {
+		godot_method_bind *mb_is_using_sync;
+		godot_method_bind *mb_set_use_sync;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeAdd2"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeAdd2 *_new();
+
+	// methods
+	bool is_using_sync() const;
+	void set_use_sync(const bool enable);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeAdd3.hpp

@@ -0,0 +1,43 @@
+#ifndef GODOT_CPP_ANIMATIONNODEADD3_HPP
+#define GODOT_CPP_ANIMATIONNODEADD3_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeAdd3 : public AnimationNode {
+	struct ___method_bindings {
+		godot_method_bind *mb_is_using_sync;
+		godot_method_bind *mb_set_use_sync;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeAdd3"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeAdd3 *_new();
+
+	// methods
+	bool is_using_sync() const;
+	void set_use_sync(const bool enable);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeAnimation.hpp

@@ -0,0 +1,43 @@
+#ifndef GODOT_CPP_ANIMATIONNODEANIMATION_HPP
+#define GODOT_CPP_ANIMATIONNODEANIMATION_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationRootNode.hpp"
+namespace godot {
+
+
+class AnimationNodeAnimation : public AnimationRootNode {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_animation;
+		godot_method_bind *mb_set_animation;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeAnimation"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeAnimation *_new();
+
+	// methods
+	String get_animation() const;
+	void set_animation(const String name);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeBlend2.hpp

@@ -0,0 +1,43 @@
+#ifndef GODOT_CPP_ANIMATIONNODEBLEND2_HPP
+#define GODOT_CPP_ANIMATIONNODEBLEND2_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeBlend2 : public AnimationNode {
+	struct ___method_bindings {
+		godot_method_bind *mb_is_using_sync;
+		godot_method_bind *mb_set_use_sync;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeBlend2"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeBlend2 *_new();
+
+	// methods
+	bool is_using_sync() const;
+	void set_use_sync(const bool enable);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeBlend3.hpp

@@ -0,0 +1,43 @@
+#ifndef GODOT_CPP_ANIMATIONNODEBLEND3_HPP
+#define GODOT_CPP_ANIMATIONNODEBLEND3_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeBlend3 : public AnimationNode {
+	struct ___method_bindings {
+		godot_method_bind *mb_is_using_sync;
+		godot_method_bind *mb_set_use_sync;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeBlend3"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeBlend3 *_new();
+
+	// methods
+	bool is_using_sync() const;
+	void set_use_sync(const bool enable);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeBlendSpace1D.hpp

@@ -0,0 +1,74 @@
+#ifndef GODOT_CPP_ANIMATIONNODEBLENDSPACE1D_HPP
+#define GODOT_CPP_ANIMATIONNODEBLENDSPACE1D_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationRootNode.hpp"
+namespace godot {
+
+class AnimationRootNode;
+
+class AnimationNodeBlendSpace1D : public AnimationRootNode {
+	struct ___method_bindings {
+		godot_method_bind *mb__add_blend_point;
+		godot_method_bind *mb__tree_changed;
+		godot_method_bind *mb_add_blend_point;
+		godot_method_bind *mb_get_blend_point_count;
+		godot_method_bind *mb_get_blend_point_node;
+		godot_method_bind *mb_get_blend_point_position;
+		godot_method_bind *mb_get_max_space;
+		godot_method_bind *mb_get_min_space;
+		godot_method_bind *mb_get_snap;
+		godot_method_bind *mb_get_value_label;
+		godot_method_bind *mb_remove_blend_point;
+		godot_method_bind *mb_set_blend_point_node;
+		godot_method_bind *mb_set_blend_point_position;
+		godot_method_bind *mb_set_max_space;
+		godot_method_bind *mb_set_min_space;
+		godot_method_bind *mb_set_snap;
+		godot_method_bind *mb_set_value_label;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeBlendSpace1D"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeBlendSpace1D *_new();
+
+	// methods
+	void _add_blend_point(const int64_t index, const Ref<AnimationRootNode> node);
+	void _tree_changed();
+	void add_blend_point(const Ref<AnimationRootNode> node, const real_t pos, const int64_t at_index = -1);
+	int64_t get_blend_point_count() const;
+	Ref<AnimationRootNode> get_blend_point_node(const int64_t point) const;
+	real_t get_blend_point_position(const int64_t point) const;
+	real_t get_max_space() const;
+	real_t get_min_space() const;
+	real_t get_snap() const;
+	String get_value_label() const;
+	void remove_blend_point(const int64_t point);
+	void set_blend_point_node(const int64_t point, const Ref<AnimationRootNode> node);
+	void set_blend_point_position(const int64_t point, const real_t pos);
+	void set_max_space(const real_t max_space);
+	void set_min_space(const real_t min_space);
+	void set_snap(const real_t snap);
+	void set_value_label(const String text);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeBlendSpace2D.hpp

@@ -0,0 +1,106 @@
+#ifndef GODOT_CPP_ANIMATIONNODEBLENDSPACE2D_HPP
+#define GODOT_CPP_ANIMATIONNODEBLENDSPACE2D_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+#include "AnimationNodeBlendSpace2D.hpp"
+
+#include "AnimationRootNode.hpp"
+namespace godot {
+
+class AnimationRootNode;
+
+class AnimationNodeBlendSpace2D : public AnimationRootNode {
+	struct ___method_bindings {
+		godot_method_bind *mb__add_blend_point;
+		godot_method_bind *mb__get_triangles;
+		godot_method_bind *mb__set_triangles;
+		godot_method_bind *mb__tree_changed;
+		godot_method_bind *mb__update_triangles;
+		godot_method_bind *mb_add_blend_point;
+		godot_method_bind *mb_add_triangle;
+		godot_method_bind *mb_get_auto_triangles;
+		godot_method_bind *mb_get_blend_mode;
+		godot_method_bind *mb_get_blend_point_count;
+		godot_method_bind *mb_get_blend_point_node;
+		godot_method_bind *mb_get_blend_point_position;
+		godot_method_bind *mb_get_max_space;
+		godot_method_bind *mb_get_min_space;
+		godot_method_bind *mb_get_snap;
+		godot_method_bind *mb_get_triangle_count;
+		godot_method_bind *mb_get_triangle_point;
+		godot_method_bind *mb_get_x_label;
+		godot_method_bind *mb_get_y_label;
+		godot_method_bind *mb_remove_blend_point;
+		godot_method_bind *mb_remove_triangle;
+		godot_method_bind *mb_set_auto_triangles;
+		godot_method_bind *mb_set_blend_mode;
+		godot_method_bind *mb_set_blend_point_node;
+		godot_method_bind *mb_set_blend_point_position;
+		godot_method_bind *mb_set_max_space;
+		godot_method_bind *mb_set_min_space;
+		godot_method_bind *mb_set_snap;
+		godot_method_bind *mb_set_x_label;
+		godot_method_bind *mb_set_y_label;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeBlendSpace2D"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum BlendMode {
+		BLEND_MODE_INTERPOLATED = 0,
+		BLEND_MODE_DISCRETE = 1,
+		BLEND_MODE_DISCRETE_CARRY = 2,
+	};
+
+	// constants
+
+
+	static AnimationNodeBlendSpace2D *_new();
+
+	// methods
+	void _add_blend_point(const int64_t index, const Ref<AnimationRootNode> node);
+	PoolIntArray _get_triangles() const;
+	void _set_triangles(const PoolIntArray triangles);
+	void _tree_changed();
+	void _update_triangles();
+	void add_blend_point(const Ref<AnimationRootNode> node, const Vector2 pos, const int64_t at_index = -1);
+	void add_triangle(const int64_t x, const int64_t y, const int64_t z, const int64_t at_index = -1);
+	bool get_auto_triangles() const;
+	AnimationNodeBlendSpace2D::BlendMode get_blend_mode() const;
+	int64_t get_blend_point_count() const;
+	Ref<AnimationRootNode> get_blend_point_node(const int64_t point) const;
+	Vector2 get_blend_point_position(const int64_t point) const;
+	Vector2 get_max_space() const;
+	Vector2 get_min_space() const;
+	Vector2 get_snap() const;
+	int64_t get_triangle_count() const;
+	int64_t get_triangle_point(const int64_t triangle, const int64_t point);
+	String get_x_label() const;
+	String get_y_label() const;
+	void remove_blend_point(const int64_t point);
+	void remove_triangle(const int64_t triangle);
+	void set_auto_triangles(const bool enable);
+	void set_blend_mode(const int64_t mode);
+	void set_blend_point_node(const int64_t point, const Ref<AnimationRootNode> node);
+	void set_blend_point_position(const int64_t point, const Vector2 pos);
+	void set_max_space(const Vector2 max_space);
+	void set_min_space(const Vector2 min_space);
+	void set_snap(const Vector2 snap);
+	void set_x_label(const String text);
+	void set_y_label(const String text);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeBlendTree.hpp

@@ -0,0 +1,72 @@
+#ifndef GODOT_CPP_ANIMATIONNODEBLENDTREE_HPP
+#define GODOT_CPP_ANIMATIONNODEBLENDTREE_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationRootNode.hpp"
+namespace godot {
+
+class AnimationNode;
+
+class AnimationNodeBlendTree : public AnimationRootNode {
+	struct ___method_bindings {
+		godot_method_bind *mb__node_changed;
+		godot_method_bind *mb__tree_changed;
+		godot_method_bind *mb_add_node;
+		godot_method_bind *mb_connect_node;
+		godot_method_bind *mb_disconnect_node;
+		godot_method_bind *mb_get_graph_offset;
+		godot_method_bind *mb_get_node;
+		godot_method_bind *mb_get_node_position;
+		godot_method_bind *mb_has_node;
+		godot_method_bind *mb_remove_node;
+		godot_method_bind *mb_rename_node;
+		godot_method_bind *mb_set_graph_offset;
+		godot_method_bind *mb_set_node_position;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeBlendTree"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+	const static int CONNECTION_ERROR_CONNECTION_EXISTS = 5;
+	const static int CONNECTION_ERROR_NO_INPUT = 1;
+	const static int CONNECTION_ERROR_NO_INPUT_INDEX = 2;
+	const static int CONNECTION_ERROR_NO_OUTPUT = 3;
+	const static int CONNECTION_ERROR_SAME_NODE = 4;
+	const static int CONNECTION_OK = 0;
+
+
+	static AnimationNodeBlendTree *_new();
+
+	// methods
+	void _node_changed(const String node);
+	void _tree_changed();
+	void add_node(const String name, const Ref<AnimationNode> node, const Vector2 position = Vector2(0, 0));
+	void connect_node(const String input_node, const int64_t input_index, const String output_node);
+	void disconnect_node(const String input_node, const int64_t input_index);
+	Vector2 get_graph_offset() const;
+	Ref<AnimationNode> get_node(const String name) const;
+	Vector2 get_node_position(const String name) const;
+	bool has_node(const String name) const;
+	void remove_node(const String name);
+	void rename_node(const String name, const String new_name);
+	void set_graph_offset(const Vector2 offset);
+	void set_node_position(const String name, const Vector2 position);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeOneShot.hpp

@@ -0,0 +1,72 @@
+#ifndef GODOT_CPP_ANIMATIONNODEONESHOT_HPP
+#define GODOT_CPP_ANIMATIONNODEONESHOT_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+#include "AnimationNodeOneShot.hpp"
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeOneShot : public AnimationNode {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_autorestart_delay;
+		godot_method_bind *mb_get_autorestart_random_delay;
+		godot_method_bind *mb_get_fadein_time;
+		godot_method_bind *mb_get_fadeout_time;
+		godot_method_bind *mb_get_mix_mode;
+		godot_method_bind *mb_has_autorestart;
+		godot_method_bind *mb_is_using_sync;
+		godot_method_bind *mb_set_autorestart;
+		godot_method_bind *mb_set_autorestart_delay;
+		godot_method_bind *mb_set_autorestart_random_delay;
+		godot_method_bind *mb_set_fadein_time;
+		godot_method_bind *mb_set_fadeout_time;
+		godot_method_bind *mb_set_mix_mode;
+		godot_method_bind *mb_set_use_sync;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeOneShot"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum MixMode {
+		MIX_MODE_BLEND = 0,
+		MIX_MODE_ADD = 1,
+	};
+
+	// constants
+
+
+	static AnimationNodeOneShot *_new();
+
+	// methods
+	real_t get_autorestart_delay() const;
+	real_t get_autorestart_random_delay() const;
+	real_t get_fadein_time() const;
+	real_t get_fadeout_time() const;
+	AnimationNodeOneShot::MixMode get_mix_mode() const;
+	bool has_autorestart() const;
+	bool is_using_sync() const;
+	void set_autorestart(const bool enable);
+	void set_autorestart_delay(const real_t enable);
+	void set_autorestart_random_delay(const real_t enable);
+	void set_fadein_time(const real_t time);
+	void set_fadeout_time(const real_t time);
+	void set_mix_mode(const int64_t mode);
+	void set_use_sync(const bool enable);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeOutput.hpp

@@ -0,0 +1,39 @@
+#ifndef GODOT_CPP_ANIMATIONNODEOUTPUT_HPP
+#define GODOT_CPP_ANIMATIONNODEOUTPUT_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeOutput : public AnimationNode {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeOutput"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeOutput *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeStateMachine.hpp

@@ -0,0 +1,87 @@
+#ifndef GODOT_CPP_ANIMATIONNODESTATEMACHINE_HPP
+#define GODOT_CPP_ANIMATIONNODESTATEMACHINE_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationRootNode.hpp"
+namespace godot {
+
+class AnimationNode;
+class AnimationNodeStateMachineTransition;
+
+class AnimationNodeStateMachine : public AnimationRootNode {
+	struct ___method_bindings {
+		godot_method_bind *mb__tree_changed;
+		godot_method_bind *mb_add_node;
+		godot_method_bind *mb_add_transition;
+		godot_method_bind *mb_get_end_node;
+		godot_method_bind *mb_get_graph_offset;
+		godot_method_bind *mb_get_node;
+		godot_method_bind *mb_get_node_name;
+		godot_method_bind *mb_get_node_position;
+		godot_method_bind *mb_get_start_node;
+		godot_method_bind *mb_get_transition;
+		godot_method_bind *mb_get_transition_count;
+		godot_method_bind *mb_get_transition_from;
+		godot_method_bind *mb_get_transition_to;
+		godot_method_bind *mb_has_node;
+		godot_method_bind *mb_has_transition;
+		godot_method_bind *mb_remove_node;
+		godot_method_bind *mb_remove_transition;
+		godot_method_bind *mb_remove_transition_by_index;
+		godot_method_bind *mb_rename_node;
+		godot_method_bind *mb_set_end_node;
+		godot_method_bind *mb_set_graph_offset;
+		godot_method_bind *mb_set_node_position;
+		godot_method_bind *mb_set_start_node;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeStateMachine"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeStateMachine *_new();
+
+	// methods
+	void _tree_changed();
+	void add_node(const String name, const Ref<AnimationNode> node, const Vector2 position = Vector2(0, 0));
+	void add_transition(const String from, const String to, const Ref<AnimationNodeStateMachineTransition> transition);
+	String get_end_node() const;
+	Vector2 get_graph_offset() const;
+	Ref<AnimationNode> get_node(const String name) const;
+	String get_node_name(const Ref<AnimationNode> node) const;
+	Vector2 get_node_position(const String name) const;
+	String get_start_node() const;
+	Ref<AnimationNodeStateMachineTransition> get_transition(const int64_t idx) const;
+	int64_t get_transition_count() const;
+	String get_transition_from(const int64_t idx) const;
+	String get_transition_to(const int64_t idx) const;
+	bool has_node(const String name) const;
+	bool has_transition(const String from, const String to) const;
+	void remove_node(const String name);
+	void remove_transition(const String from, const String to);
+	void remove_transition_by_index(const int64_t idx);
+	void rename_node(const String name, const String new_name);
+	void set_end_node(const String name);
+	void set_graph_offset(const Vector2 offset);
+	void set_node_position(const String name, const Vector2 position);
+	void set_start_node(const String name);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeStateMachinePlayback.hpp

@@ -0,0 +1,51 @@
+#ifndef GODOT_CPP_ANIMATIONNODESTATEMACHINEPLAYBACK_HPP
+#define GODOT_CPP_ANIMATIONNODESTATEMACHINEPLAYBACK_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "Resource.hpp"
+namespace godot {
+
+
+class AnimationNodeStateMachinePlayback : public Resource {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_current_node;
+		godot_method_bind *mb_get_travel_path;
+		godot_method_bind *mb_is_playing;
+		godot_method_bind *mb_start;
+		godot_method_bind *mb_stop;
+		godot_method_bind *mb_travel;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeStateMachinePlayback"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeStateMachinePlayback *_new();
+
+	// methods
+	String get_current_node() const;
+	PoolStringArray get_travel_path() const;
+	bool is_playing() const;
+	void start(const String node);
+	void stop();
+	void travel(const String to_node);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeStateMachineTransition.hpp

@@ -0,0 +1,69 @@
+#ifndef GODOT_CPP_ANIMATIONNODESTATEMACHINETRANSITION_HPP
+#define GODOT_CPP_ANIMATIONNODESTATEMACHINETRANSITION_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+#include "AnimationNodeStateMachineTransition.hpp"
+
+#include "Resource.hpp"
+namespace godot {
+
+
+class AnimationNodeStateMachineTransition : public Resource {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_advance_condition;
+		godot_method_bind *mb_get_priority;
+		godot_method_bind *mb_get_switch_mode;
+		godot_method_bind *mb_get_xfade_time;
+		godot_method_bind *mb_has_auto_advance;
+		godot_method_bind *mb_is_disabled;
+		godot_method_bind *mb_set_advance_condition;
+		godot_method_bind *mb_set_auto_advance;
+		godot_method_bind *mb_set_disabled;
+		godot_method_bind *mb_set_priority;
+		godot_method_bind *mb_set_switch_mode;
+		godot_method_bind *mb_set_xfade_time;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeStateMachineTransition"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum SwitchMode {
+		SWITCH_MODE_IMMEDIATE = 0,
+		SWITCH_MODE_SYNC = 1,
+		SWITCH_MODE_AT_END = 2,
+	};
+
+	// constants
+
+
+	static AnimationNodeStateMachineTransition *_new();
+
+	// methods
+	String get_advance_condition() const;
+	int64_t get_priority() const;
+	AnimationNodeStateMachineTransition::SwitchMode get_switch_mode() const;
+	real_t get_xfade_time() const;
+	bool has_auto_advance() const;
+	bool is_disabled() const;
+	void set_advance_condition(const String name);
+	void set_auto_advance(const bool auto_advance);
+	void set_disabled(const bool disabled);
+	void set_priority(const int64_t priority);
+	void set_switch_mode(const int64_t mode);
+	void set_xfade_time(const real_t secs);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeTimeScale.hpp

@@ -0,0 +1,39 @@
+#ifndef GODOT_CPP_ANIMATIONNODETIMESCALE_HPP
+#define GODOT_CPP_ANIMATIONNODETIMESCALE_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeTimeScale : public AnimationNode {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeTimeScale"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeTimeScale *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeTimeSeek.hpp

@@ -0,0 +1,39 @@
+#ifndef GODOT_CPP_ANIMATIONNODETIMESEEK_HPP
+#define GODOT_CPP_ANIMATIONNODETIMESEEK_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeTimeSeek : public AnimationNode {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeTimeSeek"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeTimeSeek *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationNodeTransition.hpp

@@ -0,0 +1,55 @@
+#ifndef GODOT_CPP_ANIMATIONNODETRANSITION_HPP
+#define GODOT_CPP_ANIMATIONNODETRANSITION_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationNodeTransition : public AnimationNode {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_cross_fade_time;
+		godot_method_bind *mb_get_enabled_inputs;
+		godot_method_bind *mb_get_input_caption;
+		godot_method_bind *mb_is_input_set_as_auto_advance;
+		godot_method_bind *mb_set_cross_fade_time;
+		godot_method_bind *mb_set_enabled_inputs;
+		godot_method_bind *mb_set_input_as_auto_advance;
+		godot_method_bind *mb_set_input_caption;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationNodeTransition"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationNodeTransition *_new();
+
+	// methods
+	real_t get_cross_fade_time() const;
+	int64_t get_enabled_inputs();
+	String get_input_caption(const int64_t input) const;
+	bool is_input_set_as_auto_advance(const int64_t input) const;
+	void set_cross_fade_time(const real_t time);
+	void set_enabled_inputs(const int64_t amount);
+	void set_input_as_auto_advance(const int64_t input, const bool enable);
+	void set_input_caption(const int64_t input, const String caption);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationPlayer.hpp

@@ -0,0 +1,139 @@
+#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 Node;
+class Animation;
+
+class AnimationPlayer : public Node {
+	struct ___method_bindings {
+		godot_method_bind *mb__animation_changed;
+		godot_method_bind *mb__node_removed;
+		godot_method_bind *mb_add_animation;
+		godot_method_bind *mb_advance;
+		godot_method_bind *mb_animation_get_next;
+		godot_method_bind *mb_animation_set_next;
+		godot_method_bind *mb_clear_caches;
+		godot_method_bind *mb_clear_queue;
+		godot_method_bind *mb_find_animation;
+		godot_method_bind *mb_get_animation;
+		godot_method_bind *mb_get_animation_list;
+		godot_method_bind *mb_get_animation_process_mode;
+		godot_method_bind *mb_get_assigned_animation;
+		godot_method_bind *mb_get_autoplay;
+		godot_method_bind *mb_get_blend_time;
+		godot_method_bind *mb_get_current_animation;
+		godot_method_bind *mb_get_current_animation_length;
+		godot_method_bind *mb_get_current_animation_position;
+		godot_method_bind *mb_get_default_blend_time;
+		godot_method_bind *mb_get_method_call_mode;
+		godot_method_bind *mb_get_playing_speed;
+		godot_method_bind *mb_get_queue;
+		godot_method_bind *mb_get_root;
+		godot_method_bind *mb_get_speed_scale;
+		godot_method_bind *mb_has_animation;
+		godot_method_bind *mb_is_active;
+		godot_method_bind *mb_is_playing;
+		godot_method_bind *mb_play;
+		godot_method_bind *mb_play_backwards;
+		godot_method_bind *mb_queue;
+		godot_method_bind *mb_remove_animation;
+		godot_method_bind *mb_rename_animation;
+		godot_method_bind *mb_seek;
+		godot_method_bind *mb_set_active;
+		godot_method_bind *mb_set_animation_process_mode;
+		godot_method_bind *mb_set_assigned_animation;
+		godot_method_bind *mb_set_autoplay;
+		godot_method_bind *mb_set_blend_time;
+		godot_method_bind *mb_set_current_animation;
+		godot_method_bind *mb_set_default_blend_time;
+		godot_method_bind *mb_set_method_call_mode;
+		godot_method_bind *mb_set_root;
+		godot_method_bind *mb_set_speed_scale;
+		godot_method_bind *mb_stop;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum AnimationProcessMode {
+		ANIMATION_PROCESS_PHYSICS = 0,
+		ANIMATION_PROCESS_IDLE = 1,
+		ANIMATION_PROCESS_MANUAL = 2,
+	};
+	enum AnimationMethodCallMode {
+		ANIMATION_METHOD_CALL_DEFERRED = 0,
+		ANIMATION_METHOD_CALL_IMMEDIATE = 1,
+	};
+
+	// constants
+
+
+	static AnimationPlayer *_new();
+
+	// methods
+	void _animation_changed();
+	void _node_removed(const Node *arg0);
+	Error add_animation(const String name, const Ref<Animation> animation);
+	void advance(const real_t delta);
+	String animation_get_next(const String anim_from) const;
+	void animation_set_next(const String anim_from, const String anim_to);
+	void clear_caches();
+	void clear_queue();
+	String find_animation(const Ref<Animation> animation) const;
+	Ref<Animation> get_animation(const String name) const;
+	PoolStringArray get_animation_list() const;
+	AnimationPlayer::AnimationProcessMode get_animation_process_mode() const;
+	String get_assigned_animation() const;
+	String get_autoplay() const;
+	real_t get_blend_time(const String anim_from, const String anim_to) const;
+	String get_current_animation() const;
+	real_t get_current_animation_length() const;
+	real_t get_current_animation_position() const;
+	real_t get_default_blend_time() const;
+	AnimationPlayer::AnimationMethodCallMode get_method_call_mode() const;
+	real_t get_playing_speed() const;
+	PoolStringArray get_queue();
+	NodePath get_root() const;
+	real_t get_speed_scale() const;
+	bool has_animation(const String name) const;
+	bool is_active() const;
+	bool is_playing() const;
+	void play(const String name = "", const real_t custom_blend = -1, const real_t custom_speed = 1, const bool from_end = false);
+	void play_backwards(const String name = "", const real_t custom_blend = -1);
+	void queue(const String name);
+	void remove_animation(const String name);
+	void rename_animation(const String name, const String newname);
+	void seek(const real_t seconds, const bool update = false);
+	void set_active(const bool active);
+	void set_animation_process_mode(const int64_t mode);
+	void set_assigned_animation(const String anim);
+	void set_autoplay(const String name);
+	void set_blend_time(const String anim_from, const String anim_to, const real_t sec);
+	void set_current_animation(const String anim);
+	void set_default_blend_time(const real_t sec);
+	void set_method_call_mode(const int64_t mode);
+	void set_root(const NodePath path);
+	void set_speed_scale(const real_t speed);
+	void stop(const bool reset = true);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationRootNode.hpp

@@ -0,0 +1,39 @@
+#ifndef GODOT_CPP_ANIMATIONROOTNODE_HPP
+#define GODOT_CPP_ANIMATIONROOTNODE_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AnimationNode.hpp"
+namespace godot {
+
+
+class AnimationRootNode : public AnimationNode {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationRootNode"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AnimationRootNode *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationTrackEditPlugin.hpp

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

GodoBinding/include/gen/AnimationTree.hpp

@@ -0,0 +1,81 @@
+#ifndef GODOT_CPP_ANIMATIONTREE_HPP
+#define GODOT_CPP_ANIMATIONTREE_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+#include "AnimationTree.hpp"
+
+#include "Node.hpp"
+namespace godot {
+
+class Node;
+class AnimationNode;
+
+class AnimationTree : public Node {
+	struct ___method_bindings {
+		godot_method_bind *mb__clear_caches;
+		godot_method_bind *mb__node_removed;
+		godot_method_bind *mb__tree_changed;
+		godot_method_bind *mb__update_properties;
+		godot_method_bind *mb_advance;
+		godot_method_bind *mb_get_animation_player;
+		godot_method_bind *mb_get_process_mode;
+		godot_method_bind *mb_get_root_motion_track;
+		godot_method_bind *mb_get_root_motion_transform;
+		godot_method_bind *mb_get_tree_root;
+		godot_method_bind *mb_is_active;
+		godot_method_bind *mb_rename_parameter;
+		godot_method_bind *mb_set_active;
+		godot_method_bind *mb_set_animation_player;
+		godot_method_bind *mb_set_process_mode;
+		godot_method_bind *mb_set_root_motion_track;
+		godot_method_bind *mb_set_tree_root;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AnimationTree"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum AnimationProcessMode {
+		ANIMATION_PROCESS_PHYSICS = 0,
+		ANIMATION_PROCESS_IDLE = 1,
+		ANIMATION_PROCESS_MANUAL = 2,
+	};
+
+	// constants
+
+
+	static AnimationTree *_new();
+
+	// methods
+	void _clear_caches();
+	void _node_removed(const Node *arg0);
+	void _tree_changed();
+	void _update_properties();
+	void advance(const real_t delta);
+	NodePath get_animation_player() const;
+	AnimationTree::AnimationProcessMode get_process_mode() const;
+	NodePath get_root_motion_track() const;
+	Transform get_root_motion_transform() const;
+	Ref<AnimationNode> get_tree_root() const;
+	bool is_active() const;
+	void rename_parameter(const String old_name, const String new_name);
+	void set_active(const bool active);
+	void set_animation_player(const NodePath root);
+	void set_process_mode(const int64_t mode);
+	void set_root_motion_track(const NodePath path);
+	void set_tree_root(const Ref<AnimationNode> root);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AnimationTreePlayer.hpp

@@ -0,0 +1,187 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_add_node;
+		godot_method_bind *mb_advance;
+		godot_method_bind *mb_animation_node_get_animation;
+		godot_method_bind *mb_animation_node_get_master_animation;
+		godot_method_bind *mb_animation_node_get_position;
+		godot_method_bind *mb_animation_node_set_animation;
+		godot_method_bind *mb_animation_node_set_filter_path;
+		godot_method_bind *mb_animation_node_set_master_animation;
+		godot_method_bind *mb_are_nodes_connected;
+		godot_method_bind *mb_blend2_node_get_amount;
+		godot_method_bind *mb_blend2_node_set_amount;
+		godot_method_bind *mb_blend2_node_set_filter_path;
+		godot_method_bind *mb_blend3_node_get_amount;
+		godot_method_bind *mb_blend3_node_set_amount;
+		godot_method_bind *mb_blend4_node_get_amount;
+		godot_method_bind *mb_blend4_node_set_amount;
+		godot_method_bind *mb_connect_nodes;
+		godot_method_bind *mb_disconnect_nodes;
+		godot_method_bind *mb_get_animation_process_mode;
+		godot_method_bind *mb_get_base_path;
+		godot_method_bind *mb_get_master_player;
+		godot_method_bind *mb_get_node_list;
+		godot_method_bind *mb_is_active;
+		godot_method_bind *mb_mix_node_get_amount;
+		godot_method_bind *mb_mix_node_set_amount;
+		godot_method_bind *mb_node_exists;
+		godot_method_bind *mb_node_get_input_count;
+		godot_method_bind *mb_node_get_input_source;
+		godot_method_bind *mb_node_get_position;
+		godot_method_bind *mb_node_get_type;
+		godot_method_bind *mb_node_rename;
+		godot_method_bind *mb_node_set_position;
+		godot_method_bind *mb_oneshot_node_get_autorestart_delay;
+		godot_method_bind *mb_oneshot_node_get_autorestart_random_delay;
+		godot_method_bind *mb_oneshot_node_get_fadein_time;
+		godot_method_bind *mb_oneshot_node_get_fadeout_time;
+		godot_method_bind *mb_oneshot_node_has_autorestart;
+		godot_method_bind *mb_oneshot_node_is_active;
+		godot_method_bind *mb_oneshot_node_set_autorestart;
+		godot_method_bind *mb_oneshot_node_set_autorestart_delay;
+		godot_method_bind *mb_oneshot_node_set_autorestart_random_delay;
+		godot_method_bind *mb_oneshot_node_set_fadein_time;
+		godot_method_bind *mb_oneshot_node_set_fadeout_time;
+		godot_method_bind *mb_oneshot_node_set_filter_path;
+		godot_method_bind *mb_oneshot_node_start;
+		godot_method_bind *mb_oneshot_node_stop;
+		godot_method_bind *mb_recompute_caches;
+		godot_method_bind *mb_remove_node;
+		godot_method_bind *mb_reset;
+		godot_method_bind *mb_set_active;
+		godot_method_bind *mb_set_animation_process_mode;
+		godot_method_bind *mb_set_base_path;
+		godot_method_bind *mb_set_master_player;
+		godot_method_bind *mb_timescale_node_get_scale;
+		godot_method_bind *mb_timescale_node_set_scale;
+		godot_method_bind *mb_timeseek_node_seek;
+		godot_method_bind *mb_transition_node_delete_input;
+		godot_method_bind *mb_transition_node_get_current;
+		godot_method_bind *mb_transition_node_get_input_count;
+		godot_method_bind *mb_transition_node_get_xfade_time;
+		godot_method_bind *mb_transition_node_has_input_auto_advance;
+		godot_method_bind *mb_transition_node_set_current;
+		godot_method_bind *mb_transition_node_set_input_auto_advance;
+		godot_method_bind *mb_transition_node_set_input_count;
+		godot_method_bind *mb_transition_node_set_xfade_time;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum AnimationProcessMode {
+		ANIMATION_PROCESS_PHYSICS = 0,
+		ANIMATION_PROCESS_IDLE = 1,
+	};
+	enum NodeType {
+		NODE_OUTPUT = 0,
+		NODE_ANIMATION = 1,
+		NODE_ONESHOT = 2,
+		NODE_MIX = 3,
+		NODE_BLEND2 = 4,
+		NODE_BLEND3 = 5,
+		NODE_BLEND4 = 6,
+		NODE_TIMESCALE = 7,
+		NODE_TIMESEEK = 8,
+		NODE_TRANSITION = 9,
+	};
+
+	// constants
+
+
+	static AnimationTreePlayer *_new();
+
+	// methods
+	void add_node(const int64_t type, const String id);
+	void advance(const real_t delta);
+	Ref<Animation> animation_node_get_animation(const String id) const;
+	String animation_node_get_master_animation(const String id) const;
+	real_t animation_node_get_position(const String id) const;
+	void animation_node_set_animation(const String id, const Ref<Animation> animation);
+	void animation_node_set_filter_path(const String id, const NodePath path, const bool enable);
+	void animation_node_set_master_animation(const String id, const String source);
+	bool are_nodes_connected(const String id, const String dst_id, const int64_t dst_input_idx) const;
+	real_t blend2_node_get_amount(const String id) const;
+	void blend2_node_set_amount(const String id, const real_t blend);
+	void blend2_node_set_filter_path(const String id, const NodePath path, const bool enable);
+	real_t blend3_node_get_amount(const String id) const;
+	void blend3_node_set_amount(const String id, const real_t blend);
+	Vector2 blend4_node_get_amount(const String id) const;
+	void blend4_node_set_amount(const String id, const Vector2 blend);
+	Error connect_nodes(const String id, const String dst_id, const int64_t dst_input_idx);
+	void disconnect_nodes(const String id, const int64_t dst_input_idx);
+	AnimationTreePlayer::AnimationProcessMode get_animation_process_mode() const;
+	NodePath get_base_path() const;
+	NodePath get_master_player() const;
+	PoolStringArray get_node_list();
+	bool is_active() const;
+	real_t mix_node_get_amount(const String id) const;
+	void mix_node_set_amount(const String id, const real_t ratio);
+	bool node_exists(const String node) const;
+	int64_t node_get_input_count(const String id) const;
+	String node_get_input_source(const String id, const int64_t idx) const;
+	Vector2 node_get_position(const String id) const;
+	AnimationTreePlayer::NodeType node_get_type(const String id) const;
+	Error node_rename(const String node, const String new_name);
+	void node_set_position(const String id, const Vector2 screen_position);
+	real_t oneshot_node_get_autorestart_delay(const String id) const;
+	real_t oneshot_node_get_autorestart_random_delay(const String id) const;
+	real_t oneshot_node_get_fadein_time(const String id) const;
+	real_t oneshot_node_get_fadeout_time(const String id) const;
+	bool oneshot_node_has_autorestart(const String id) const;
+	bool oneshot_node_is_active(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 real_t delay_sec);
+	void oneshot_node_set_autorestart_random_delay(const String id, const real_t rand_sec);
+	void oneshot_node_set_fadein_time(const String id, const real_t time_sec);
+	void oneshot_node_set_fadeout_time(const String id, const real_t time_sec);
+	void oneshot_node_set_filter_path(const String id, const NodePath path, const bool enable);
+	void oneshot_node_start(const String id);
+	void oneshot_node_stop(const String id);
+	void recompute_caches();
+	void remove_node(const String id);
+	void reset();
+	void set_active(const bool enabled);
+	void set_animation_process_mode(const int64_t mode);
+	void set_base_path(const NodePath path);
+	void set_master_player(const NodePath nodepath);
+	real_t timescale_node_get_scale(const String id) const;
+	void timescale_node_set_scale(const String id, const real_t scale);
+	void timeseek_node_seek(const String id, const real_t seconds);
+	void transition_node_delete_input(const String id, const int64_t input_idx);
+	int64_t transition_node_get_current(const String id) const;
+	int64_t transition_node_get_input_count(const String id) const;
+	real_t transition_node_get_xfade_time(const String id) const;
+	bool transition_node_has_input_auto_advance(const String id, const int64_t input_idx) const;
+	void transition_node_set_current(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);
+	void transition_node_set_input_count(const String id, const int64_t count);
+	void transition_node_set_xfade_time(const String id, const real_t time_sec);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/Area.hpp

@@ -0,0 +1,148 @@
+#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 Node;
+
+class Area : public CollisionObject {
+	struct ___method_bindings {
+		godot_method_bind *mb__area_enter_tree;
+		godot_method_bind *mb__area_exit_tree;
+		godot_method_bind *mb__area_inout;
+		godot_method_bind *mb__body_enter_tree;
+		godot_method_bind *mb__body_exit_tree;
+		godot_method_bind *mb__body_inout;
+		godot_method_bind *mb_get_angular_damp;
+		godot_method_bind *mb_get_audio_bus;
+		godot_method_bind *mb_get_collision_layer;
+		godot_method_bind *mb_get_collision_layer_bit;
+		godot_method_bind *mb_get_collision_mask;
+		godot_method_bind *mb_get_collision_mask_bit;
+		godot_method_bind *mb_get_gravity;
+		godot_method_bind *mb_get_gravity_distance_scale;
+		godot_method_bind *mb_get_gravity_vector;
+		godot_method_bind *mb_get_linear_damp;
+		godot_method_bind *mb_get_overlapping_areas;
+		godot_method_bind *mb_get_overlapping_bodies;
+		godot_method_bind *mb_get_priority;
+		godot_method_bind *mb_get_reverb_amount;
+		godot_method_bind *mb_get_reverb_bus;
+		godot_method_bind *mb_get_reverb_uniformity;
+		godot_method_bind *mb_get_space_override_mode;
+		godot_method_bind *mb_is_gravity_a_point;
+		godot_method_bind *mb_is_monitorable;
+		godot_method_bind *mb_is_monitoring;
+		godot_method_bind *mb_is_overriding_audio_bus;
+		godot_method_bind *mb_is_using_reverb_bus;
+		godot_method_bind *mb_overlaps_area;
+		godot_method_bind *mb_overlaps_body;
+		godot_method_bind *mb_set_angular_damp;
+		godot_method_bind *mb_set_audio_bus;
+		godot_method_bind *mb_set_audio_bus_override;
+		godot_method_bind *mb_set_collision_layer;
+		godot_method_bind *mb_set_collision_layer_bit;
+		godot_method_bind *mb_set_collision_mask;
+		godot_method_bind *mb_set_collision_mask_bit;
+		godot_method_bind *mb_set_gravity;
+		godot_method_bind *mb_set_gravity_distance_scale;
+		godot_method_bind *mb_set_gravity_is_point;
+		godot_method_bind *mb_set_gravity_vector;
+		godot_method_bind *mb_set_linear_damp;
+		godot_method_bind *mb_set_monitorable;
+		godot_method_bind *mb_set_monitoring;
+		godot_method_bind *mb_set_priority;
+		godot_method_bind *mb_set_reverb_amount;
+		godot_method_bind *mb_set_reverb_bus;
+		godot_method_bind *mb_set_reverb_uniformity;
+		godot_method_bind *mb_set_space_override_mode;
+		godot_method_bind *mb_set_use_reverb_bus;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum SpaceOverride {
+		SPACE_OVERRIDE_DISABLED = 0,
+		SPACE_OVERRIDE_COMBINE = 1,
+		SPACE_OVERRIDE_COMBINE_REPLACE = 2,
+		SPACE_OVERRIDE_REPLACE = 3,
+		SPACE_OVERRIDE_REPLACE_COMBINE = 4,
+	};
+
+	// constants
+
+
+	static Area *_new();
+
+	// methods
+	void _area_enter_tree(const int64_t id);
+	void _area_exit_tree(const int64_t id);
+	void _area_inout(const int64_t arg0, const RID arg1, const int64_t arg2, const int64_t arg3, const int64_t arg4);
+	void _body_enter_tree(const int64_t id);
+	void _body_exit_tree(const int64_t id);
+	void _body_inout(const int64_t arg0, const RID arg1, const int64_t arg2, const int64_t arg3, const int64_t arg4);
+	real_t get_angular_damp() const;
+	String get_audio_bus() const;
+	int64_t get_collision_layer() const;
+	bool get_collision_layer_bit(const int64_t bit) const;
+	int64_t get_collision_mask() const;
+	bool get_collision_mask_bit(const int64_t bit) const;
+	real_t get_gravity() const;
+	real_t get_gravity_distance_scale() const;
+	Vector3 get_gravity_vector() const;
+	real_t get_linear_damp() const;
+	Array get_overlapping_areas() const;
+	Array get_overlapping_bodies() const;
+	real_t get_priority() const;
+	real_t get_reverb_amount() const;
+	String get_reverb_bus() const;
+	real_t get_reverb_uniformity() const;
+	Area::SpaceOverride get_space_override_mode() const;
+	bool is_gravity_a_point() const;
+	bool is_monitorable() const;
+	bool is_monitoring() const;
+	bool is_overriding_audio_bus() const;
+	bool is_using_reverb_bus() const;
+	bool overlaps_area(const Node *area) const;
+	bool overlaps_body(const Node *body) const;
+	void set_angular_damp(const real_t angular_damp);
+	void set_audio_bus(const String name);
+	void set_audio_bus_override(const bool enable);
+	void set_collision_layer(const int64_t collision_layer);
+	void set_collision_layer_bit(const int64_t bit, const bool value);
+	void set_collision_mask(const int64_t collision_mask);
+	void set_collision_mask_bit(const int64_t bit, const bool value);
+	void set_gravity(const real_t gravity);
+	void set_gravity_distance_scale(const real_t distance_scale);
+	void set_gravity_is_point(const bool enable);
+	void set_gravity_vector(const Vector3 vector);
+	void set_linear_damp(const real_t linear_damp);
+	void set_monitorable(const bool enable);
+	void set_monitoring(const bool enable);
+	void set_priority(const real_t priority);
+	void set_reverb_amount(const real_t amount);
+	void set_reverb_bus(const String name);
+	void set_reverb_uniformity(const real_t amount);
+	void set_space_override_mode(const int64_t enable);
+	void set_use_reverb_bus(const bool enable);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/Area2D.hpp

@@ -0,0 +1,132 @@
+#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 Node;
+
+class Area2D : public CollisionObject2D {
+	struct ___method_bindings {
+		godot_method_bind *mb__area_enter_tree;
+		godot_method_bind *mb__area_exit_tree;
+		godot_method_bind *mb__area_inout;
+		godot_method_bind *mb__body_enter_tree;
+		godot_method_bind *mb__body_exit_tree;
+		godot_method_bind *mb__body_inout;
+		godot_method_bind *mb_get_angular_damp;
+		godot_method_bind *mb_get_audio_bus_name;
+		godot_method_bind *mb_get_collision_layer;
+		godot_method_bind *mb_get_collision_layer_bit;
+		godot_method_bind *mb_get_collision_mask;
+		godot_method_bind *mb_get_collision_mask_bit;
+		godot_method_bind *mb_get_gravity;
+		godot_method_bind *mb_get_gravity_distance_scale;
+		godot_method_bind *mb_get_gravity_vector;
+		godot_method_bind *mb_get_linear_damp;
+		godot_method_bind *mb_get_overlapping_areas;
+		godot_method_bind *mb_get_overlapping_bodies;
+		godot_method_bind *mb_get_priority;
+		godot_method_bind *mb_get_space_override_mode;
+		godot_method_bind *mb_is_gravity_a_point;
+		godot_method_bind *mb_is_monitorable;
+		godot_method_bind *mb_is_monitoring;
+		godot_method_bind *mb_is_overriding_audio_bus;
+		godot_method_bind *mb_overlaps_area;
+		godot_method_bind *mb_overlaps_body;
+		godot_method_bind *mb_set_angular_damp;
+		godot_method_bind *mb_set_audio_bus_name;
+		godot_method_bind *mb_set_audio_bus_override;
+		godot_method_bind *mb_set_collision_layer;
+		godot_method_bind *mb_set_collision_layer_bit;
+		godot_method_bind *mb_set_collision_mask;
+		godot_method_bind *mb_set_collision_mask_bit;
+		godot_method_bind *mb_set_gravity;
+		godot_method_bind *mb_set_gravity_distance_scale;
+		godot_method_bind *mb_set_gravity_is_point;
+		godot_method_bind *mb_set_gravity_vector;
+		godot_method_bind *mb_set_linear_damp;
+		godot_method_bind *mb_set_monitorable;
+		godot_method_bind *mb_set_monitoring;
+		godot_method_bind *mb_set_priority;
+		godot_method_bind *mb_set_space_override_mode;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum SpaceOverride {
+		SPACE_OVERRIDE_DISABLED = 0,
+		SPACE_OVERRIDE_COMBINE = 1,
+		SPACE_OVERRIDE_COMBINE_REPLACE = 2,
+		SPACE_OVERRIDE_REPLACE = 3,
+		SPACE_OVERRIDE_REPLACE_COMBINE = 4,
+	};
+
+	// constants
+
+
+	static Area2D *_new();
+
+	// methods
+	void _area_enter_tree(const int64_t id);
+	void _area_exit_tree(const int64_t id);
+	void _area_inout(const int64_t arg0, const RID arg1, const int64_t arg2, const int64_t arg3, const int64_t arg4);
+	void _body_enter_tree(const int64_t id);
+	void _body_exit_tree(const int64_t id);
+	void _body_inout(const int64_t arg0, const RID arg1, const int64_t arg2, const int64_t arg3, const int64_t arg4);
+	real_t get_angular_damp() const;
+	String get_audio_bus_name() const;
+	int64_t get_collision_layer() const;
+	bool get_collision_layer_bit(const int64_t bit) const;
+	int64_t get_collision_mask() const;
+	bool get_collision_mask_bit(const int64_t bit) const;
+	real_t get_gravity() const;
+	real_t get_gravity_distance_scale() const;
+	Vector2 get_gravity_vector() const;
+	real_t get_linear_damp() const;
+	Array get_overlapping_areas() const;
+	Array get_overlapping_bodies() const;
+	real_t get_priority() const;
+	Area2D::SpaceOverride get_space_override_mode() const;
+	bool is_gravity_a_point() const;
+	bool is_monitorable() const;
+	bool is_monitoring() const;
+	bool is_overriding_audio_bus() const;
+	bool overlaps_area(const Node *area) const;
+	bool overlaps_body(const Node *body) const;
+	void set_angular_damp(const real_t angular_damp);
+	void set_audio_bus_name(const String name);
+	void set_audio_bus_override(const bool enable);
+	void set_collision_layer(const int64_t collision_layer);
+	void set_collision_layer_bit(const int64_t bit, const bool value);
+	void set_collision_mask(const int64_t collision_mask);
+	void set_collision_mask_bit(const int64_t bit, const bool value);
+	void set_gravity(const real_t gravity);
+	void set_gravity_distance_scale(const real_t distance_scale);
+	void set_gravity_is_point(const bool enable);
+	void set_gravity_vector(const Vector2 vector);
+	void set_linear_damp(const real_t linear_damp);
+	void set_monitorable(const bool enable);
+	void set_monitoring(const bool enable);
+	void set_priority(const real_t priority);
+	void set_space_override_mode(const int64_t space_override_mode);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ArrayMesh.hpp

@@ -0,0 +1,105 @@
+#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 ArrayMesh : public Mesh {
+	struct ___method_bindings {
+		godot_method_bind *mb_add_blend_shape;
+		godot_method_bind *mb_add_surface_from_arrays;
+		godot_method_bind *mb_clear_blend_shapes;
+		godot_method_bind *mb_get_blend_shape_count;
+		godot_method_bind *mb_get_blend_shape_mode;
+		godot_method_bind *mb_get_blend_shape_name;
+		godot_method_bind *mb_get_custom_aabb;
+		godot_method_bind *mb_lightmap_unwrap;
+		godot_method_bind *mb_regen_normalmaps;
+		godot_method_bind *mb_set_blend_shape_mode;
+		godot_method_bind *mb_set_custom_aabb;
+		godot_method_bind *mb_surface_find_by_name;
+		godot_method_bind *mb_surface_get_array_index_len;
+		godot_method_bind *mb_surface_get_array_len;
+		godot_method_bind *mb_surface_get_format;
+		godot_method_bind *mb_surface_get_name;
+		godot_method_bind *mb_surface_get_primitive_type;
+		godot_method_bind *mb_surface_remove;
+		godot_method_bind *mb_surface_set_name;
+		godot_method_bind *mb_surface_update_region;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum ArrayFormat {
+		ARRAY_FORMAT_VERTEX = 1,
+		ARRAY_FORMAT_NORMAL = 2,
+		ARRAY_FORMAT_TANGENT = 4,
+		ARRAY_FORMAT_COLOR = 8,
+		ARRAY_FORMAT_TEX_UV = 16,
+		ARRAY_FORMAT_TEX_UV2 = 32,
+		ARRAY_FORMAT_BONES = 64,
+		ARRAY_FORMAT_WEIGHTS = 128,
+		ARRAY_FORMAT_INDEX = 256,
+	};
+	enum ArrayType {
+		ARRAY_VERTEX = 0,
+		ARRAY_NORMAL = 1,
+		ARRAY_TANGENT = 2,
+		ARRAY_COLOR = 3,
+		ARRAY_TEX_UV = 4,
+		ARRAY_TEX_UV2 = 5,
+		ARRAY_BONES = 6,
+		ARRAY_WEIGHTS = 7,
+		ARRAY_INDEX = 8,
+		ARRAY_MAX = 9,
+	};
+
+	// 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);
+	void add_surface_from_arrays(const int64_t primitive, const Array arrays, const Array blend_shapes = Array(), const int64_t compress_flags = 97280);
+	void clear_blend_shapes();
+	int64_t get_blend_shape_count() const;
+	Mesh::BlendShapeMode get_blend_shape_mode() const;
+	String get_blend_shape_name(const int64_t index) const;
+	AABB get_custom_aabb() const;
+	Error lightmap_unwrap(const Transform transform, const real_t texel_size);
+	void regen_normalmaps();
+	void set_blend_shape_mode(const int64_t mode);
+	void set_custom_aabb(const AABB aabb);
+	int64_t surface_find_by_name(const String name) const;
+	int64_t surface_get_array_index_len(const int64_t surf_idx) const;
+	int64_t surface_get_array_len(const int64_t surf_idx) const;
+	int64_t surface_get_format(const int64_t surf_idx) const;
+	String surface_get_name(const int64_t surf_idx) const;
+	Mesh::PrimitiveType surface_get_primitive_type(const int64_t surf_idx) const;
+	void surface_remove(const int64_t surf_idx);
+	void surface_set_name(const int64_t surf_idx, const String name);
+	void surface_update_region(const int64_t surf_idx, const int64_t offset, const PoolByteArray data);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AtlasTexture.hpp

@@ -0,0 +1,56 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_atlas;
+		godot_method_bind *mb_get_margin;
+		godot_method_bind *mb_get_region;
+		godot_method_bind *mb_has_filter_clip;
+		godot_method_bind *mb_set_atlas;
+		godot_method_bind *mb_set_filter_clip;
+		godot_method_bind *mb_set_margin;
+		godot_method_bind *mb_set_region;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AtlasTexture *_new();
+
+	// methods
+	Ref<Texture> get_atlas() const;
+	Rect2 get_margin() const;
+	Rect2 get_region() const;
+	bool has_filter_clip() const;
+	void set_atlas(const Ref<Texture> atlas);
+	void set_filter_clip(const bool enable);
+	void set_margin(const Rect2 margin);
+	void set_region(const Rect2 region);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioBusLayout.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioBusLayout *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffect.hpp

@@ -0,0 +1,36 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectAmplify.hpp

@@ -0,0 +1,43 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_volume_db;
+		godot_method_bind *mb_set_volume_db;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectAmplify *_new();
+
+	// methods
+	real_t get_volume_db() const;
+	void set_volume_db(const real_t volume);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectBandLimitFilter.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectBandLimitFilter *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectBandPassFilter.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectBandPassFilter *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectChorus.hpp

@@ -0,0 +1,75 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_dry;
+		godot_method_bind *mb_get_voice_count;
+		godot_method_bind *mb_get_voice_cutoff_hz;
+		godot_method_bind *mb_get_voice_delay_ms;
+		godot_method_bind *mb_get_voice_depth_ms;
+		godot_method_bind *mb_get_voice_level_db;
+		godot_method_bind *mb_get_voice_pan;
+		godot_method_bind *mb_get_voice_rate_hz;
+		godot_method_bind *mb_get_wet;
+		godot_method_bind *mb_set_dry;
+		godot_method_bind *mb_set_voice_count;
+		godot_method_bind *mb_set_voice_cutoff_hz;
+		godot_method_bind *mb_set_voice_delay_ms;
+		godot_method_bind *mb_set_voice_depth_ms;
+		godot_method_bind *mb_set_voice_level_db;
+		godot_method_bind *mb_set_voice_pan;
+		godot_method_bind *mb_set_voice_rate_hz;
+		godot_method_bind *mb_set_wet;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectChorus *_new();
+
+	// methods
+	real_t get_dry() const;
+	int64_t get_voice_count() const;
+	real_t get_voice_cutoff_hz(const int64_t voice_idx) const;
+	real_t get_voice_delay_ms(const int64_t voice_idx) const;
+	real_t get_voice_depth_ms(const int64_t voice_idx) const;
+	real_t get_voice_level_db(const int64_t voice_idx) const;
+	real_t get_voice_pan(const int64_t voice_idx) const;
+	real_t get_voice_rate_hz(const int64_t voice_idx) const;
+	real_t get_wet() const;
+	void set_dry(const real_t amount);
+	void set_voice_count(const int64_t voices);
+	void set_voice_cutoff_hz(const int64_t voice_idx, const real_t cutoff_hz);
+	void set_voice_delay_ms(const int64_t voice_idx, const real_t delay_ms);
+	void set_voice_depth_ms(const int64_t voice_idx, const real_t depth_ms);
+	void set_voice_level_db(const int64_t voice_idx, const real_t level_db);
+	void set_voice_pan(const int64_t voice_idx, const real_t pan);
+	void set_voice_rate_hz(const int64_t voice_idx, const real_t rate_hz);
+	void set_wet(const real_t amount);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectCompressor.hpp

@@ -0,0 +1,67 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_attack_us;
+		godot_method_bind *mb_get_gain;
+		godot_method_bind *mb_get_mix;
+		godot_method_bind *mb_get_ratio;
+		godot_method_bind *mb_get_release_ms;
+		godot_method_bind *mb_get_sidechain;
+		godot_method_bind *mb_get_threshold;
+		godot_method_bind *mb_set_attack_us;
+		godot_method_bind *mb_set_gain;
+		godot_method_bind *mb_set_mix;
+		godot_method_bind *mb_set_ratio;
+		godot_method_bind *mb_set_release_ms;
+		godot_method_bind *mb_set_sidechain;
+		godot_method_bind *mb_set_threshold;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectCompressor *_new();
+
+	// methods
+	real_t get_attack_us() const;
+	real_t get_gain() const;
+	real_t get_mix() const;
+	real_t get_ratio() const;
+	real_t get_release_ms() const;
+	String get_sidechain() const;
+	real_t get_threshold() const;
+	void set_attack_us(const real_t attack_us);
+	void set_gain(const real_t gain);
+	void set_mix(const real_t mix);
+	void set_ratio(const real_t ratio);
+	void set_release_ms(const real_t release_ms);
+	void set_sidechain(const String sidechain);
+	void set_threshold(const real_t threshold);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectDelay.hpp

@@ -0,0 +1,91 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_dry;
+		godot_method_bind *mb_get_feedback_delay_ms;
+		godot_method_bind *mb_get_feedback_level_db;
+		godot_method_bind *mb_get_feedback_lowpass;
+		godot_method_bind *mb_get_tap1_delay_ms;
+		godot_method_bind *mb_get_tap1_level_db;
+		godot_method_bind *mb_get_tap1_pan;
+		godot_method_bind *mb_get_tap2_delay_ms;
+		godot_method_bind *mb_get_tap2_level_db;
+		godot_method_bind *mb_get_tap2_pan;
+		godot_method_bind *mb_is_feedback_active;
+		godot_method_bind *mb_is_tap1_active;
+		godot_method_bind *mb_is_tap2_active;
+		godot_method_bind *mb_set_dry;
+		godot_method_bind *mb_set_feedback_active;
+		godot_method_bind *mb_set_feedback_delay_ms;
+		godot_method_bind *mb_set_feedback_level_db;
+		godot_method_bind *mb_set_feedback_lowpass;
+		godot_method_bind *mb_set_tap1_active;
+		godot_method_bind *mb_set_tap1_delay_ms;
+		godot_method_bind *mb_set_tap1_level_db;
+		godot_method_bind *mb_set_tap1_pan;
+		godot_method_bind *mb_set_tap2_active;
+		godot_method_bind *mb_set_tap2_delay_ms;
+		godot_method_bind *mb_set_tap2_level_db;
+		godot_method_bind *mb_set_tap2_pan;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectDelay *_new();
+
+	// methods
+	real_t get_dry();
+	real_t get_feedback_delay_ms() const;
+	real_t get_feedback_level_db() const;
+	real_t get_feedback_lowpass() const;
+	real_t get_tap1_delay_ms() const;
+	real_t get_tap1_level_db() const;
+	real_t get_tap1_pan() const;
+	real_t get_tap2_delay_ms() const;
+	real_t get_tap2_level_db() const;
+	real_t get_tap2_pan() const;
+	bool is_feedback_active() const;
+	bool is_tap1_active() const;
+	bool is_tap2_active() const;
+	void set_dry(const real_t amount);
+	void set_feedback_active(const bool amount);
+	void set_feedback_delay_ms(const real_t amount);
+	void set_feedback_level_db(const real_t amount);
+	void set_feedback_lowpass(const real_t amount);
+	void set_tap1_active(const bool amount);
+	void set_tap1_delay_ms(const real_t amount);
+	void set_tap1_level_db(const real_t amount);
+	void set_tap1_pan(const real_t amount);
+	void set_tap2_active(const bool amount);
+	void set_tap2_delay_ms(const real_t amount);
+	void set_tap2_level_db(const real_t amount);
+	void set_tap2_pan(const real_t amount);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectDistortion.hpp

@@ -0,0 +1,67 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_drive;
+		godot_method_bind *mb_get_keep_hf_hz;
+		godot_method_bind *mb_get_mode;
+		godot_method_bind *mb_get_post_gain;
+		godot_method_bind *mb_get_pre_gain;
+		godot_method_bind *mb_set_drive;
+		godot_method_bind *mb_set_keep_hf_hz;
+		godot_method_bind *mb_set_mode;
+		godot_method_bind *mb_set_post_gain;
+		godot_method_bind *mb_set_pre_gain;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum Mode {
+		MODE_CLIP = 0,
+		MODE_ATAN = 1,
+		MODE_LOFI = 2,
+		MODE_OVERDRIVE = 3,
+		MODE_WAVESHAPE = 4,
+	};
+
+	// constants
+
+
+	static AudioEffectDistortion *_new();
+
+	// methods
+	real_t get_drive() const;
+	real_t get_keep_hf_hz() const;
+	AudioEffectDistortion::Mode get_mode() const;
+	real_t get_post_gain() const;
+	real_t get_pre_gain() const;
+	void set_drive(const real_t drive);
+	void set_keep_hf_hz(const real_t keep_hf_hz);
+	void set_mode(const int64_t mode);
+	void set_post_gain(const real_t post_gain);
+	void set_pre_gain(const real_t pre_gain);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectEQ.hpp

@@ -0,0 +1,45 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_band_count;
+		godot_method_bind *mb_get_band_gain_db;
+		godot_method_bind *mb_set_band_gain_db;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectEQ *_new();
+
+	// methods
+	int64_t get_band_count() const;
+	real_t get_band_gain_db(const int64_t band_idx) const;
+	void set_band_gain_db(const int64_t band_idx, const real_t volume_db);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectEQ10.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectEQ10 *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectEQ21.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectEQ21 *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectEQ6.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectEQ6 *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectFilter.hpp

@@ -0,0 +1,62 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_cutoff;
+		godot_method_bind *mb_get_db;
+		godot_method_bind *mb_get_gain;
+		godot_method_bind *mb_get_resonance;
+		godot_method_bind *mb_set_cutoff;
+		godot_method_bind *mb_set_db;
+		godot_method_bind *mb_set_gain;
+		godot_method_bind *mb_set_resonance;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum FilterDB {
+		FILTER_6DB = 0,
+		FILTER_12DB = 1,
+		FILTER_18DB = 2,
+		FILTER_24DB = 3,
+	};
+
+	// constants
+
+
+	static AudioEffectFilter *_new();
+
+	// methods
+	real_t get_cutoff() const;
+	AudioEffectFilter::FilterDB get_db() const;
+	real_t get_gain() const;
+	real_t get_resonance() const;
+	void set_cutoff(const real_t freq);
+	void set_db(const int64_t amount);
+	void set_gain(const real_t amount);
+	void set_resonance(const real_t amount);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectHighPassFilter.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectHighPassFilter *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectHighShelfFilter.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectHighShelfFilter *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectInstance.hpp

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

GodoBinding/include/gen/AudioEffectLimiter.hpp

@@ -0,0 +1,55 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_ceiling_db;
+		godot_method_bind *mb_get_soft_clip_db;
+		godot_method_bind *mb_get_soft_clip_ratio;
+		godot_method_bind *mb_get_threshold_db;
+		godot_method_bind *mb_set_ceiling_db;
+		godot_method_bind *mb_set_soft_clip_db;
+		godot_method_bind *mb_set_soft_clip_ratio;
+		godot_method_bind *mb_set_threshold_db;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectLimiter *_new();
+
+	// methods
+	real_t get_ceiling_db() const;
+	real_t get_soft_clip_db() const;
+	real_t get_soft_clip_ratio() const;
+	real_t get_threshold_db() const;
+	void set_ceiling_db(const real_t ceiling);
+	void set_soft_clip_db(const real_t soft_clip);
+	void set_soft_clip_ratio(const real_t soft_clip);
+	void set_threshold_db(const real_t threshold);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectLowPassFilter.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectLowPassFilter *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectLowShelfFilter.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectLowShelfFilter *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectNotchFilter.hpp

@@ -0,0 +1,39 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectNotchFilter *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectPanner.hpp

@@ -0,0 +1,43 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_pan;
+		godot_method_bind *mb_set_pan;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectPanner *_new();
+
+	// methods
+	real_t get_pan() const;
+	void set_pan(const real_t cpanume);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectPhaser.hpp

@@ -0,0 +1,59 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_depth;
+		godot_method_bind *mb_get_feedback;
+		godot_method_bind *mb_get_range_max_hz;
+		godot_method_bind *mb_get_range_min_hz;
+		godot_method_bind *mb_get_rate_hz;
+		godot_method_bind *mb_set_depth;
+		godot_method_bind *mb_set_feedback;
+		godot_method_bind *mb_set_range_max_hz;
+		godot_method_bind *mb_set_range_min_hz;
+		godot_method_bind *mb_set_rate_hz;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectPhaser *_new();
+
+	// methods
+	real_t get_depth() const;
+	real_t get_feedback() const;
+	real_t get_range_max_hz() const;
+	real_t get_range_min_hz() const;
+	real_t get_rate_hz() const;
+	void set_depth(const real_t depth);
+	void set_feedback(const real_t fbk);
+	void set_range_max_hz(const real_t hz);
+	void set_range_min_hz(const real_t hz);
+	void set_rate_hz(const real_t hz);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectPitchShift.hpp

@@ -0,0 +1,60 @@
+#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 "AudioEffectPitchShift.hpp"
+
+#include "AudioEffect.hpp"
+namespace godot {
+
+
+class AudioEffectPitchShift : public AudioEffect {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_fft_size;
+		godot_method_bind *mb_get_oversampling;
+		godot_method_bind *mb_get_pitch_scale;
+		godot_method_bind *mb_set_fft_size;
+		godot_method_bind *mb_set_oversampling;
+		godot_method_bind *mb_set_pitch_scale;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum FFT_Size {
+		FFT_SIZE_256 = 0,
+		FFT_SIZE_512 = 1,
+		FFT_SIZE_1024 = 2,
+		FFT_SIZE_2048 = 3,
+		FFT_SIZE_4096 = 4,
+		FFT_SIZE_MAX = 5,
+	};
+
+	// constants
+
+
+	static AudioEffectPitchShift *_new();
+
+	// methods
+	AudioEffectPitchShift::FFT_Size get_fft_size() const;
+	int64_t get_oversampling() const;
+	real_t get_pitch_scale() const;
+	void set_fft_size(const int64_t size);
+	void set_oversampling(const int64_t amount);
+	void set_pitch_scale(const real_t rate);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectRecord.hpp

@@ -0,0 +1,51 @@
+#ifndef GODOT_CPP_AUDIOEFFECTRECORD_HPP
+#define GODOT_CPP_AUDIOEFFECTRECORD_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+#include "AudioStreamSample.hpp"
+
+#include "AudioEffect.hpp"
+namespace godot {
+
+class AudioStreamSample;
+
+class AudioEffectRecord : public AudioEffect {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_format;
+		godot_method_bind *mb_get_recording;
+		godot_method_bind *mb_is_recording_active;
+		godot_method_bind *mb_set_format;
+		godot_method_bind *mb_set_recording_active;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AudioEffectRecord"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectRecord *_new();
+
+	// methods
+	AudioStreamSample::Format get_format() const;
+	Ref<AudioStreamSample> get_recording() const;
+	bool is_recording_active() const;
+	void set_format(const int64_t format);
+	void set_recording_active(const bool record);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectReverb.hpp

@@ -0,0 +1,71 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_damping;
+		godot_method_bind *mb_get_dry;
+		godot_method_bind *mb_get_hpf;
+		godot_method_bind *mb_get_predelay_feedback;
+		godot_method_bind *mb_get_predelay_msec;
+		godot_method_bind *mb_get_room_size;
+		godot_method_bind *mb_get_spread;
+		godot_method_bind *mb_get_wet;
+		godot_method_bind *mb_set_damping;
+		godot_method_bind *mb_set_dry;
+		godot_method_bind *mb_set_hpf;
+		godot_method_bind *mb_set_predelay_feedback;
+		godot_method_bind *mb_set_predelay_msec;
+		godot_method_bind *mb_set_room_size;
+		godot_method_bind *mb_set_spread;
+		godot_method_bind *mb_set_wet;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectReverb *_new();
+
+	// methods
+	real_t get_damping() const;
+	real_t get_dry() const;
+	real_t get_hpf() const;
+	real_t get_predelay_feedback() const;
+	real_t get_predelay_msec() const;
+	real_t get_room_size() const;
+	real_t get_spread() const;
+	real_t get_wet() const;
+	void set_damping(const real_t amount);
+	void set_dry(const real_t amount);
+	void set_hpf(const real_t amount);
+	void set_predelay_feedback(const real_t feedback);
+	void set_predelay_msec(const real_t msec);
+	void set_room_size(const real_t size);
+	void set_spread(const real_t amount);
+	void set_wet(const real_t amount);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectSpectrumAnalyzer.hpp

@@ -0,0 +1,60 @@
+#ifndef GODOT_CPP_AUDIOEFFECTSPECTRUMANALYZER_HPP
+#define GODOT_CPP_AUDIOEFFECTSPECTRUMANALYZER_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+#include "AudioEffectSpectrumAnalyzer.hpp"
+
+#include "AudioEffect.hpp"
+namespace godot {
+
+
+class AudioEffectSpectrumAnalyzer : public AudioEffect {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_buffer_length;
+		godot_method_bind *mb_get_fft_size;
+		godot_method_bind *mb_get_tap_back_pos;
+		godot_method_bind *mb_set_buffer_length;
+		godot_method_bind *mb_set_fft_size;
+		godot_method_bind *mb_set_tap_back_pos;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AudioEffectSpectrumAnalyzer"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum FFT_Size {
+		FFT_SIZE_256 = 0,
+		FFT_SIZE_512 = 1,
+		FFT_SIZE_1024 = 2,
+		FFT_SIZE_2048 = 3,
+		FFT_SIZE_4096 = 4,
+		FFT_SIZE_MAX = 5,
+	};
+
+	// constants
+
+
+	static AudioEffectSpectrumAnalyzer *_new();
+
+	// methods
+	real_t get_buffer_length() const;
+	AudioEffectSpectrumAnalyzer::FFT_Size get_fft_size() const;
+	real_t get_tap_back_pos() const;
+	void set_buffer_length(const real_t seconds);
+	void set_fft_size(const int64_t size);
+	void set_tap_back_pos(const real_t seconds);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectSpectrumAnalyzerInstance.hpp

@@ -0,0 +1,42 @@
+#ifndef GODOT_CPP_AUDIOEFFECTSPECTRUMANALYZERINSTANCE_HPP
+#define GODOT_CPP_AUDIOEFFECTSPECTRUMANALYZERINSTANCE_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AudioEffectInstance.hpp"
+namespace godot {
+
+
+class AudioEffectSpectrumAnalyzerInstance : public AudioEffectInstance {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_magnitude_for_frequency_range;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AudioEffectSpectrumAnalyzerInstance"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum MagnitudeMode {
+		MAGNITUDE_AVERAGE = 0,
+		MAGNITUDE_MAX = 1,
+	};
+
+	// constants
+
+	// methods
+	Vector2 get_magnitude_for_frequency_range(const real_t from_hz, const real_t to_hz, const int64_t mode = 1) const;
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioEffectStereoEnhance.hpp

@@ -0,0 +1,51 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_pan_pullout;
+		godot_method_bind *mb_get_surround;
+		godot_method_bind *mb_get_time_pullout;
+		godot_method_bind *mb_set_pan_pullout;
+		godot_method_bind *mb_set_surround;
+		godot_method_bind *mb_set_time_pullout;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioEffectStereoEnhance *_new();
+
+	// methods
+	real_t get_pan_pullout() const;
+	real_t get_surround() const;
+	real_t get_time_pullout() const;
+	void set_pan_pullout(const real_t amount);
+	void set_surround(const real_t amount);
+	void set_time_pullout(const real_t amount);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioServer.hpp

@@ -0,0 +1,150 @@
+#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 AudioEffectInstance;
+
+class AudioServer : public Object {
+	static AudioServer *_singleton;
+
+	AudioServer();
+
+	struct ___method_bindings {
+		godot_method_bind *mb_add_bus;
+		godot_method_bind *mb_add_bus_effect;
+		godot_method_bind *mb_capture_get_device;
+		godot_method_bind *mb_capture_get_device_list;
+		godot_method_bind *mb_capture_set_device;
+		godot_method_bind *mb_generate_bus_layout;
+		godot_method_bind *mb_get_bus_channels;
+		godot_method_bind *mb_get_bus_count;
+		godot_method_bind *mb_get_bus_effect;
+		godot_method_bind *mb_get_bus_effect_count;
+		godot_method_bind *mb_get_bus_effect_instance;
+		godot_method_bind *mb_get_bus_index;
+		godot_method_bind *mb_get_bus_name;
+		godot_method_bind *mb_get_bus_peak_volume_left_db;
+		godot_method_bind *mb_get_bus_peak_volume_right_db;
+		godot_method_bind *mb_get_bus_send;
+		godot_method_bind *mb_get_bus_volume_db;
+		godot_method_bind *mb_get_device;
+		godot_method_bind *mb_get_device_list;
+		godot_method_bind *mb_get_global_rate_scale;
+		godot_method_bind *mb_get_mix_rate;
+		godot_method_bind *mb_get_output_latency;
+		godot_method_bind *mb_get_speaker_mode;
+		godot_method_bind *mb_get_time_since_last_mix;
+		godot_method_bind *mb_get_time_to_next_mix;
+		godot_method_bind *mb_is_bus_bypassing_effects;
+		godot_method_bind *mb_is_bus_effect_enabled;
+		godot_method_bind *mb_is_bus_mute;
+		godot_method_bind *mb_is_bus_solo;
+		godot_method_bind *mb_lock;
+		godot_method_bind *mb_move_bus;
+		godot_method_bind *mb_remove_bus;
+		godot_method_bind *mb_remove_bus_effect;
+		godot_method_bind *mb_set_bus_bypass_effects;
+		godot_method_bind *mb_set_bus_count;
+		godot_method_bind *mb_set_bus_effect_enabled;
+		godot_method_bind *mb_set_bus_layout;
+		godot_method_bind *mb_set_bus_mute;
+		godot_method_bind *mb_set_bus_name;
+		godot_method_bind *mb_set_bus_send;
+		godot_method_bind *mb_set_bus_solo;
+		godot_method_bind *mb_set_bus_volume_db;
+		godot_method_bind *mb_set_device;
+		godot_method_bind *mb_set_global_rate_scale;
+		godot_method_bind *mb_swap_bus_effects;
+		godot_method_bind *mb_unlock;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum SpeakerMode {
+		SPEAKER_MODE_STEREO = 0,
+		SPEAKER_SURROUND_31 = 1,
+		SPEAKER_SURROUND_51 = 2,
+		SPEAKER_SURROUND_71 = 3,
+	};
+
+	// constants
+
+	// methods
+	void add_bus(const int64_t at_position = -1);
+	void add_bus_effect(const int64_t bus_idx, const Ref<AudioEffect> effect, const int64_t at_position = -1);
+	String capture_get_device();
+	Array capture_get_device_list();
+	void capture_set_device(const String name);
+	Ref<AudioBusLayout> generate_bus_layout() const;
+	int64_t get_bus_channels(const int64_t bus_idx) const;
+	int64_t get_bus_count() const;
+	Ref<AudioEffect> get_bus_effect(const int64_t bus_idx, const int64_t effect_idx);
+	int64_t get_bus_effect_count(const int64_t bus_idx);
+	Ref<AudioEffectInstance> get_bus_effect_instance(const int64_t bus_idx, const int64_t effect_idx, const int64_t channel = 0);
+	int64_t get_bus_index(const String bus_name) const;
+	String get_bus_name(const int64_t bus_idx) const;
+	real_t get_bus_peak_volume_left_db(const int64_t bus_idx, const int64_t channel) const;
+	real_t get_bus_peak_volume_right_db(const int64_t bus_idx, const int64_t channel) const;
+	String get_bus_send(const int64_t bus_idx) const;
+	real_t get_bus_volume_db(const int64_t bus_idx) const;
+	String get_device();
+	Array get_device_list();
+	real_t get_global_rate_scale() const;
+	real_t get_mix_rate() const;
+	real_t get_output_latency() const;
+	AudioServer::SpeakerMode get_speaker_mode() const;
+	real_t get_time_since_last_mix() const;
+	real_t get_time_to_next_mix() const;
+	bool is_bus_bypassing_effects(const int64_t bus_idx) const;
+	bool is_bus_effect_enabled(const int64_t bus_idx, const int64_t effect_idx) const;
+	bool is_bus_mute(const int64_t bus_idx) const;
+	bool is_bus_solo(const int64_t bus_idx) const;
+	void lock();
+	void move_bus(const int64_t index, const int64_t to_index);
+	void remove_bus(const int64_t index);
+	void remove_bus_effect(const int64_t bus_idx, const int64_t effect_idx);
+	void set_bus_bypass_effects(const int64_t bus_idx, const bool enable);
+	void set_bus_count(const int64_t amount);
+	void set_bus_effect_enabled(const int64_t bus_idx, const int64_t effect_idx, const bool enabled);
+	void set_bus_layout(const Ref<AudioBusLayout> bus_layout);
+	void set_bus_mute(const int64_t bus_idx, const bool enable);
+	void set_bus_name(const int64_t bus_idx, const String name);
+	void set_bus_send(const int64_t bus_idx, const String send);
+	void set_bus_solo(const int64_t bus_idx, const bool enable);
+	void set_bus_volume_db(const int64_t bus_idx, const real_t volume_db);
+	void set_device(const String device);
+	void set_global_rate_scale(const real_t scale);
+	void swap_bus_effects(const int64_t bus_idx, const int64_t effect_idx, const int64_t by_effect_idx);
+	void unlock();
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStream.hpp

@@ -0,0 +1,38 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_length;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+	// methods
+	real_t get_length() const;
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamGenerator.hpp

@@ -0,0 +1,47 @@
+#ifndef GODOT_CPP_AUDIOSTREAMGENERATOR_HPP
+#define GODOT_CPP_AUDIOSTREAMGENERATOR_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AudioStream.hpp"
+namespace godot {
+
+
+class AudioStreamGenerator : public AudioStream {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_buffer_length;
+		godot_method_bind *mb_get_mix_rate;
+		godot_method_bind *mb_set_buffer_length;
+		godot_method_bind *mb_set_mix_rate;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AudioStreamGenerator"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioStreamGenerator *_new();
+
+	// methods
+	real_t get_buffer_length() const;
+	real_t get_mix_rate() const;
+	void set_buffer_length(const real_t seconds);
+	void set_mix_rate(const real_t hz);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamGeneratorPlayback.hpp

@@ -0,0 +1,48 @@
+#ifndef GODOT_CPP_AUDIOSTREAMGENERATORPLAYBACK_HPP
+#define GODOT_CPP_AUDIOSTREAMGENERATORPLAYBACK_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AudioStreamPlaybackResampled.hpp"
+namespace godot {
+
+
+class AudioStreamGeneratorPlayback : public AudioStreamPlaybackResampled {
+	struct ___method_bindings {
+		godot_method_bind *mb_can_push_buffer;
+		godot_method_bind *mb_clear_buffer;
+		godot_method_bind *mb_get_frames_available;
+		godot_method_bind *mb_get_skips;
+		godot_method_bind *mb_push_buffer;
+		godot_method_bind *mb_push_frame;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AudioStreamGeneratorPlayback"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+	// methods
+	bool can_push_buffer(const int64_t amount) const;
+	void clear_buffer();
+	int64_t get_frames_available() const;
+	int64_t get_skips() const;
+	bool push_buffer(const PoolVector2Array frames);
+	bool push_frame(const Vector2 frame);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamMicrophone.hpp

@@ -0,0 +1,39 @@
+#ifndef GODOT_CPP_AUDIOSTREAMMICROPHONE_HPP
+#define GODOT_CPP_AUDIOSTREAMMICROPHONE_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "AudioStream.hpp"
+namespace godot {
+
+
+class AudioStreamMicrophone : public AudioStream {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "AudioStreamMicrophone"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioStreamMicrophone *_new();
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamOGGVorbis.hpp

@@ -0,0 +1,51 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_data;
+		godot_method_bind *mb_get_loop_offset;
+		godot_method_bind *mb_has_loop;
+		godot_method_bind *mb_set_data;
+		godot_method_bind *mb_set_loop;
+		godot_method_bind *mb_set_loop_offset;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioStreamOGGVorbis *_new();
+
+	// methods
+	PoolByteArray get_data() const;
+	real_t get_loop_offset() const;
+	bool has_loop() const;
+	void set_data(const PoolByteArray data);
+	void set_loop(const bool enable);
+	void set_loop_offset(const real_t seconds);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamPlayback.hpp

@@ -0,0 +1,36 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamPlaybackResampled.hpp

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

GodoBinding/include/gen/AudioStreamPlayer.hpp

@@ -0,0 +1,93 @@
+#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 AudioStreamPlayback;
+
+class AudioStreamPlayer : public Node {
+	struct ___method_bindings {
+		godot_method_bind *mb__bus_layout_changed;
+		godot_method_bind *mb__is_active;
+		godot_method_bind *mb__set_playing;
+		godot_method_bind *mb_get_bus;
+		godot_method_bind *mb_get_mix_target;
+		godot_method_bind *mb_get_pitch_scale;
+		godot_method_bind *mb_get_playback_position;
+		godot_method_bind *mb_get_stream;
+		godot_method_bind *mb_get_stream_paused;
+		godot_method_bind *mb_get_stream_playback;
+		godot_method_bind *mb_get_volume_db;
+		godot_method_bind *mb_is_autoplay_enabled;
+		godot_method_bind *mb_is_playing;
+		godot_method_bind *mb_play;
+		godot_method_bind *mb_seek;
+		godot_method_bind *mb_set_autoplay;
+		godot_method_bind *mb_set_bus;
+		godot_method_bind *mb_set_mix_target;
+		godot_method_bind *mb_set_pitch_scale;
+		godot_method_bind *mb_set_stream;
+		godot_method_bind *mb_set_stream_paused;
+		godot_method_bind *mb_set_volume_db;
+		godot_method_bind *mb_stop;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum MixTarget {
+		MIX_TARGET_STEREO = 0,
+		MIX_TARGET_SURROUND = 1,
+		MIX_TARGET_CENTER = 2,
+	};
+
+	// constants
+
+
+	static AudioStreamPlayer *_new();
+
+	// methods
+	void _bus_layout_changed();
+	bool _is_active() const;
+	void _set_playing(const bool enable);
+	String get_bus() const;
+	AudioStreamPlayer::MixTarget get_mix_target() const;
+	real_t get_pitch_scale() const;
+	real_t get_playback_position();
+	Ref<AudioStream> get_stream() const;
+	bool get_stream_paused() const;
+	Ref<AudioStreamPlayback> get_stream_playback();
+	real_t get_volume_db() const;
+	bool is_autoplay_enabled();
+	bool is_playing() const;
+	void play(const real_t from_position = 0);
+	void seek(const real_t to_position);
+	void set_autoplay(const bool enable);
+	void set_bus(const String bus);
+	void set_mix_target(const int64_t mix_target);
+	void set_pitch_scale(const real_t pitch_scale);
+	void set_stream(const Ref<AudioStream> stream);
+	void set_stream_paused(const bool pause);
+	void set_volume_db(const real_t volume_db);
+	void stop();
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamPlayer2D.hpp

@@ -0,0 +1,95 @@
+#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 AudioStreamPlayback;
+
+class AudioStreamPlayer2D : public Node2D {
+	struct ___method_bindings {
+		godot_method_bind *mb__bus_layout_changed;
+		godot_method_bind *mb__is_active;
+		godot_method_bind *mb__set_playing;
+		godot_method_bind *mb_get_area_mask;
+		godot_method_bind *mb_get_attenuation;
+		godot_method_bind *mb_get_bus;
+		godot_method_bind *mb_get_max_distance;
+		godot_method_bind *mb_get_pitch_scale;
+		godot_method_bind *mb_get_playback_position;
+		godot_method_bind *mb_get_stream;
+		godot_method_bind *mb_get_stream_paused;
+		godot_method_bind *mb_get_stream_playback;
+		godot_method_bind *mb_get_volume_db;
+		godot_method_bind *mb_is_autoplay_enabled;
+		godot_method_bind *mb_is_playing;
+		godot_method_bind *mb_play;
+		godot_method_bind *mb_seek;
+		godot_method_bind *mb_set_area_mask;
+		godot_method_bind *mb_set_attenuation;
+		godot_method_bind *mb_set_autoplay;
+		godot_method_bind *mb_set_bus;
+		godot_method_bind *mb_set_max_distance;
+		godot_method_bind *mb_set_pitch_scale;
+		godot_method_bind *mb_set_stream;
+		godot_method_bind *mb_set_stream_paused;
+		godot_method_bind *mb_set_volume_db;
+		godot_method_bind *mb_stop;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioStreamPlayer2D *_new();
+
+	// methods
+	void _bus_layout_changed();
+	bool _is_active() const;
+	void _set_playing(const bool enable);
+	int64_t get_area_mask() const;
+	real_t get_attenuation() const;
+	String get_bus() const;
+	real_t get_max_distance() const;
+	real_t get_pitch_scale() const;
+	real_t get_playback_position();
+	Ref<AudioStream> get_stream() const;
+	bool get_stream_paused() const;
+	Ref<AudioStreamPlayback> get_stream_playback();
+	real_t get_volume_db() const;
+	bool is_autoplay_enabled();
+	bool is_playing() const;
+	void play(const real_t from_position = 0);
+	void seek(const real_t to_position);
+	void set_area_mask(const int64_t mask);
+	void set_attenuation(const real_t curve);
+	void set_autoplay(const bool enable);
+	void set_bus(const String bus);
+	void set_max_distance(const real_t pixels);
+	void set_pitch_scale(const real_t pitch_scale);
+	void set_stream(const Ref<AudioStream> stream);
+	void set_stream_paused(const bool pause);
+	void set_volume_db(const real_t volume_db);
+	void stop();
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamPlayer3D.hpp

@@ -0,0 +1,147 @@
+#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 AudioStreamPlayback;
+
+class AudioStreamPlayer3D : public Spatial {
+	struct ___method_bindings {
+		godot_method_bind *mb__bus_layout_changed;
+		godot_method_bind *mb__is_active;
+		godot_method_bind *mb__set_playing;
+		godot_method_bind *mb_get_area_mask;
+		godot_method_bind *mb_get_attenuation_filter_cutoff_hz;
+		godot_method_bind *mb_get_attenuation_filter_db;
+		godot_method_bind *mb_get_attenuation_model;
+		godot_method_bind *mb_get_bus;
+		godot_method_bind *mb_get_doppler_tracking;
+		godot_method_bind *mb_get_emission_angle;
+		godot_method_bind *mb_get_emission_angle_filter_attenuation_db;
+		godot_method_bind *mb_get_max_db;
+		godot_method_bind *mb_get_max_distance;
+		godot_method_bind *mb_get_out_of_range_mode;
+		godot_method_bind *mb_get_pitch_scale;
+		godot_method_bind *mb_get_playback_position;
+		godot_method_bind *mb_get_stream;
+		godot_method_bind *mb_get_stream_paused;
+		godot_method_bind *mb_get_stream_playback;
+		godot_method_bind *mb_get_unit_db;
+		godot_method_bind *mb_get_unit_size;
+		godot_method_bind *mb_is_autoplay_enabled;
+		godot_method_bind *mb_is_emission_angle_enabled;
+		godot_method_bind *mb_is_playing;
+		godot_method_bind *mb_play;
+		godot_method_bind *mb_seek;
+		godot_method_bind *mb_set_area_mask;
+		godot_method_bind *mb_set_attenuation_filter_cutoff_hz;
+		godot_method_bind *mb_set_attenuation_filter_db;
+		godot_method_bind *mb_set_attenuation_model;
+		godot_method_bind *mb_set_autoplay;
+		godot_method_bind *mb_set_bus;
+		godot_method_bind *mb_set_doppler_tracking;
+		godot_method_bind *mb_set_emission_angle;
+		godot_method_bind *mb_set_emission_angle_enabled;
+		godot_method_bind *mb_set_emission_angle_filter_attenuation_db;
+		godot_method_bind *mb_set_max_db;
+		godot_method_bind *mb_set_max_distance;
+		godot_method_bind *mb_set_out_of_range_mode;
+		godot_method_bind *mb_set_pitch_scale;
+		godot_method_bind *mb_set_stream;
+		godot_method_bind *mb_set_stream_paused;
+		godot_method_bind *mb_set_unit_db;
+		godot_method_bind *mb_set_unit_size;
+		godot_method_bind *mb_stop;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum AttenuationModel {
+		ATTENUATION_INVERSE_DISTANCE = 0,
+		ATTENUATION_INVERSE_SQUARE_DISTANCE = 1,
+		ATTENUATION_LOGARITHMIC = 2,
+		ATTENUATION_DISABLED = 3,
+	};
+	enum OutOfRangeMode {
+		OUT_OF_RANGE_MIX = 0,
+		OUT_OF_RANGE_PAUSE = 1,
+	};
+	enum DopplerTracking {
+		DOPPLER_TRACKING_DISABLED = 0,
+		DOPPLER_TRACKING_IDLE_STEP = 1,
+		DOPPLER_TRACKING_PHYSICS_STEP = 2,
+	};
+
+	// constants
+
+
+	static AudioStreamPlayer3D *_new();
+
+	// methods
+	void _bus_layout_changed();
+	bool _is_active() const;
+	void _set_playing(const bool enable);
+	int64_t get_area_mask() const;
+	real_t get_attenuation_filter_cutoff_hz() const;
+	real_t get_attenuation_filter_db() const;
+	AudioStreamPlayer3D::AttenuationModel get_attenuation_model() const;
+	String get_bus() const;
+	AudioStreamPlayer3D::DopplerTracking get_doppler_tracking() const;
+	real_t get_emission_angle() const;
+	real_t get_emission_angle_filter_attenuation_db() const;
+	real_t get_max_db() const;
+	real_t get_max_distance() const;
+	AudioStreamPlayer3D::OutOfRangeMode get_out_of_range_mode() const;
+	real_t get_pitch_scale() const;
+	real_t get_playback_position();
+	Ref<AudioStream> get_stream() const;
+	bool get_stream_paused() const;
+	Ref<AudioStreamPlayback> get_stream_playback();
+	real_t get_unit_db() const;
+	real_t get_unit_size() const;
+	bool is_autoplay_enabled();
+	bool is_emission_angle_enabled() const;
+	bool is_playing() const;
+	void play(const real_t from_position = 0);
+	void seek(const real_t to_position);
+	void set_area_mask(const int64_t mask);
+	void set_attenuation_filter_cutoff_hz(const real_t degrees);
+	void set_attenuation_filter_db(const real_t db);
+	void set_attenuation_model(const int64_t model);
+	void set_autoplay(const bool enable);
+	void set_bus(const String bus);
+	void set_doppler_tracking(const int64_t mode);
+	void set_emission_angle(const real_t degrees);
+	void set_emission_angle_enabled(const bool enabled);
+	void set_emission_angle_filter_attenuation_db(const real_t db);
+	void set_max_db(const real_t max_db);
+	void set_max_distance(const real_t metres);
+	void set_out_of_range_mode(const int64_t mode);
+	void set_pitch_scale(const real_t pitch_scale);
+	void set_stream(const Ref<AudioStream> stream);
+	void set_stream_paused(const bool pause);
+	void set_unit_db(const real_t unit_db);
+	void set_unit_size(const real_t unit_size);
+	void stop();
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamRandomPitch.hpp

@@ -0,0 +1,48 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_audio_stream;
+		godot_method_bind *mb_get_random_pitch;
+		godot_method_bind *mb_set_audio_stream;
+		godot_method_bind *mb_set_random_pitch;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static AudioStreamRandomPitch *_new();
+
+	// methods
+	Ref<AudioStream> get_audio_stream() const;
+	real_t get_random_pitch() const;
+	void set_audio_stream(const Ref<AudioStream> stream);
+	void set_random_pitch(const real_t scale);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/AudioStreamSample.hpp

@@ -0,0 +1,81 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_data;
+		godot_method_bind *mb_get_format;
+		godot_method_bind *mb_get_loop_begin;
+		godot_method_bind *mb_get_loop_end;
+		godot_method_bind *mb_get_loop_mode;
+		godot_method_bind *mb_get_mix_rate;
+		godot_method_bind *mb_is_stereo;
+		godot_method_bind *mb_save_to_wav;
+		godot_method_bind *mb_set_data;
+		godot_method_bind *mb_set_format;
+		godot_method_bind *mb_set_loop_begin;
+		godot_method_bind *mb_set_loop_end;
+		godot_method_bind *mb_set_loop_mode;
+		godot_method_bind *mb_set_mix_rate;
+		godot_method_bind *mb_set_stereo;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum LoopMode {
+		LOOP_DISABLED = 0,
+		LOOP_FORWARD = 1,
+		LOOP_PING_PONG = 2,
+		LOOP_BACKWARD = 3,
+	};
+	enum Format {
+		FORMAT_8_BITS = 0,
+		FORMAT_16_BITS = 1,
+		FORMAT_IMA_ADPCM = 2,
+	};
+
+	// constants
+
+
+	static AudioStreamSample *_new();
+
+	// methods
+	PoolByteArray get_data() const;
+	AudioStreamSample::Format get_format() const;
+	int64_t get_loop_begin() const;
+	int64_t get_loop_end() const;
+	AudioStreamSample::LoopMode get_loop_mode() const;
+	int64_t get_mix_rate() const;
+	bool is_stereo() const;
+	Error save_to_wav(const String path);
+	void set_data(const PoolByteArray data);
+	void set_format(const int64_t format);
+	void set_loop_begin(const int64_t loop_begin);
+	void set_loop_end(const int64_t loop_end);
+	void set_loop_mode(const int64_t loop_mode);
+	void set_mix_rate(const int64_t mix_rate);
+	void set_stereo(const bool stereo);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BackBufferCopy.hpp

@@ -0,0 +1,53 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_copy_mode;
+		godot_method_bind *mb_get_rect;
+		godot_method_bind *mb_set_copy_mode;
+		godot_method_bind *mb_set_rect;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum CopyMode {
+		COPY_MODE_DISABLED = 0,
+		COPY_MODE_RECT = 1,
+		COPY_MODE_VIEWPORT = 2,
+	};
+
+	// constants
+
+
+	static BackBufferCopy *_new();
+
+	// methods
+	BackBufferCopy::CopyMode get_copy_mode() const;
+	Rect2 get_rect() const;
+	void set_copy_mode(const int64_t copy_mode);
+	void set_rect(const Rect2 rect);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BakedLightmap.hpp

@@ -0,0 +1,106 @@
+#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 Node;
+class BakedLightmapData;
+
+class BakedLightmap : public VisualInstance {
+	struct ___method_bindings {
+		godot_method_bind *mb_bake;
+		godot_method_bind *mb_debug_bake;
+		godot_method_bind *mb_get_bake_cell_size;
+		godot_method_bind *mb_get_bake_default_texels_per_unit;
+		godot_method_bind *mb_get_bake_mode;
+		godot_method_bind *mb_get_bake_quality;
+		godot_method_bind *mb_get_capture_cell_size;
+		godot_method_bind *mb_get_energy;
+		godot_method_bind *mb_get_extents;
+		godot_method_bind *mb_get_image_path;
+		godot_method_bind *mb_get_light_data;
+		godot_method_bind *mb_get_propagation;
+		godot_method_bind *mb_is_hdr;
+		godot_method_bind *mb_set_bake_cell_size;
+		godot_method_bind *mb_set_bake_default_texels_per_unit;
+		godot_method_bind *mb_set_bake_mode;
+		godot_method_bind *mb_set_bake_quality;
+		godot_method_bind *mb_set_capture_cell_size;
+		godot_method_bind *mb_set_energy;
+		godot_method_bind *mb_set_extents;
+		godot_method_bind *mb_set_hdr;
+		godot_method_bind *mb_set_image_path;
+		godot_method_bind *mb_set_light_data;
+		godot_method_bind *mb_set_propagation;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum BakeQuality {
+		BAKE_QUALITY_LOW = 0,
+		BAKE_QUALITY_MEDIUM = 1,
+		BAKE_QUALITY_HIGH = 2,
+	};
+	enum BakeError {
+		BAKE_ERROR_OK = 0,
+		BAKE_ERROR_NO_SAVE_PATH = 1,
+		BAKE_ERROR_NO_MESHES = 2,
+		BAKE_ERROR_CANT_CREATE_IMAGE = 3,
+		BAKE_ERROR_USER_ABORTED = 4,
+	};
+	enum BakeMode {
+		BAKE_MODE_CONE_TRACE = 0,
+		BAKE_MODE_RAY_TRACE = 1,
+	};
+
+	// constants
+
+
+	static BakedLightmap *_new();
+
+	// methods
+	BakedLightmap::BakeError bake(const Node *from_node = nullptr, const bool create_visual_debug = false);
+	void debug_bake();
+	real_t get_bake_cell_size() const;
+	real_t get_bake_default_texels_per_unit() const;
+	BakedLightmap::BakeMode get_bake_mode() const;
+	BakedLightmap::BakeQuality get_bake_quality() const;
+	real_t get_capture_cell_size() const;
+	real_t get_energy() const;
+	Vector3 get_extents() const;
+	String get_image_path() const;
+	Ref<BakedLightmapData> get_light_data() const;
+	real_t get_propagation() const;
+	bool is_hdr() const;
+	void set_bake_cell_size(const real_t bake_cell_size);
+	void set_bake_default_texels_per_unit(const real_t texels);
+	void set_bake_mode(const int64_t bake_mode);
+	void set_bake_quality(const int64_t bake_quality);
+	void set_capture_cell_size(const real_t capture_cell_size);
+	void set_energy(const real_t energy);
+	void set_extents(const Vector3 extents);
+	void set_hdr(const bool hdr);
+	void set_image_path(const String image_path);
+	void set_light_data(const Ref<BakedLightmapData> data);
+	void set_propagation(const real_t propagation);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BakedLightmapData.hpp

@@ -0,0 +1,74 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb__get_user_data;
+		godot_method_bind *mb__set_user_data;
+		godot_method_bind *mb_add_user;
+		godot_method_bind *mb_clear_users;
+		godot_method_bind *mb_get_bounds;
+		godot_method_bind *mb_get_cell_space_transform;
+		godot_method_bind *mb_get_cell_subdiv;
+		godot_method_bind *mb_get_energy;
+		godot_method_bind *mb_get_octree;
+		godot_method_bind *mb_get_user_count;
+		godot_method_bind *mb_get_user_lightmap;
+		godot_method_bind *mb_get_user_path;
+		godot_method_bind *mb_set_bounds;
+		godot_method_bind *mb_set_cell_space_transform;
+		godot_method_bind *mb_set_cell_subdiv;
+		godot_method_bind *mb_set_energy;
+		godot_method_bind *mb_set_octree;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static BakedLightmapData *_new();
+
+	// methods
+	Array _get_user_data() const;
+	void _set_user_data(const Array data);
+	void add_user(const NodePath path, const Ref<Texture> lightmap, const int64_t instance);
+	void clear_users();
+	AABB get_bounds() const;
+	Transform get_cell_space_transform() const;
+	int64_t get_cell_subdiv() const;
+	real_t get_energy() const;
+	PoolByteArray get_octree() const;
+	int64_t get_user_count() const;
+	Ref<Texture> get_user_lightmap(const int64_t user_idx) const;
+	NodePath get_user_path(const int64_t user_idx) const;
+	void set_bounds(const AABB bounds);
+	void set_cell_space_transform(const Transform xform);
+	void set_cell_subdiv(const int64_t cell_subdiv);
+	void set_energy(const real_t energy);
+	void set_octree(const PoolByteArray octree);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BaseButton.hpp

@@ -0,0 +1,104 @@
+#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 ButtonGroup;
+class ShortCut;
+
+class BaseButton : public Control {
+	struct ___method_bindings {
+		godot_method_bind *mb__gui_input;
+		godot_method_bind *mb__pressed;
+		godot_method_bind *mb__toggled;
+		godot_method_bind *mb__unhandled_input;
+		godot_method_bind *mb_get_action_mode;
+		godot_method_bind *mb_get_button_group;
+		godot_method_bind *mb_get_button_mask;
+		godot_method_bind *mb_get_draw_mode;
+		godot_method_bind *mb_get_enabled_focus_mode;
+		godot_method_bind *mb_get_shortcut;
+		godot_method_bind *mb_is_disabled;
+		godot_method_bind *mb_is_hovered;
+		godot_method_bind *mb_is_keep_pressed_outside;
+		godot_method_bind *mb_is_pressed;
+		godot_method_bind *mb_is_shortcut_in_tooltip_enabled;
+		godot_method_bind *mb_is_toggle_mode;
+		godot_method_bind *mb_set_action_mode;
+		godot_method_bind *mb_set_button_group;
+		godot_method_bind *mb_set_button_mask;
+		godot_method_bind *mb_set_disabled;
+		godot_method_bind *mb_set_enabled_focus_mode;
+		godot_method_bind *mb_set_keep_pressed_outside;
+		godot_method_bind *mb_set_pressed;
+		godot_method_bind *mb_set_shortcut;
+		godot_method_bind *mb_set_shortcut_in_tooltip;
+		godot_method_bind *mb_set_toggle_mode;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum ActionMode {
+		ACTION_MODE_BUTTON_PRESS = 0,
+		ACTION_MODE_BUTTON_RELEASE = 1,
+	};
+	enum DrawMode {
+		DRAW_NORMAL = 0,
+		DRAW_PRESSED = 1,
+		DRAW_HOVER = 2,
+		DRAW_DISABLED = 3,
+		DRAW_HOVER_PRESSED = 4,
+	};
+
+	// constants
+
+	// methods
+	void _gui_input(const Ref<InputEvent> arg0);
+	void _pressed();
+	void _toggled(const bool button_pressed);
+	void _unhandled_input(const Ref<InputEvent> arg0);
+	BaseButton::ActionMode get_action_mode() const;
+	Ref<ButtonGroup> get_button_group() const;
+	int64_t get_button_mask() const;
+	BaseButton::DrawMode get_draw_mode() const;
+	Control::FocusMode get_enabled_focus_mode() const;
+	Ref<ShortCut> get_shortcut() const;
+	bool is_disabled() const;
+	bool is_hovered() const;
+	bool is_keep_pressed_outside() const;
+	bool is_pressed() const;
+	bool is_shortcut_in_tooltip_enabled() const;
+	bool is_toggle_mode() const;
+	void set_action_mode(const int64_t mode);
+	void set_button_group(const Ref<ButtonGroup> button_group);
+	void set_button_mask(const int64_t mask);
+	void set_disabled(const bool disabled);
+	void set_enabled_focus_mode(const int64_t mode);
+	void set_keep_pressed_outside(const bool enabled);
+	void set_pressed(const bool pressed);
+	void set_shortcut(const Ref<ShortCut> shortcut);
+	void set_shortcut_in_tooltip(const bool enabled);
+	void set_toggle_mode(const bool enabled);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BitMap.hpp

@@ -0,0 +1,62 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb__get_data;
+		godot_method_bind *mb__set_data;
+		godot_method_bind *mb_create;
+		godot_method_bind *mb_create_from_image_alpha;
+		godot_method_bind *mb_get_bit;
+		godot_method_bind *mb_get_size;
+		godot_method_bind *mb_get_true_bit_count;
+		godot_method_bind *mb_grow_mask;
+		godot_method_bind *mb_opaque_to_polygons;
+		godot_method_bind *mb_set_bit;
+		godot_method_bind *mb_set_bit_rect;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static BitMap *_new();
+
+	// methods
+	Dictionary _get_data() const;
+	void _set_data(const Dictionary arg0);
+	void create(const Vector2 size);
+	void create_from_image_alpha(const Ref<Image> image, const real_t threshold = 0.1);
+	bool get_bit(const Vector2 position) const;
+	Vector2 get_size() const;
+	int64_t get_true_bit_count() const;
+	void grow_mask(const int64_t pixels, const Rect2 rect);
+	Array opaque_to_polygons(const Rect2 rect, const real_t epsilon = 2) const;
+	void set_bit(const Vector2 position, const bool bit);
+	void set_bit_rect(const Rect2 rect, const bool bit);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BitmapFont.hpp

@@ -0,0 +1,81 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb__get_chars;
+		godot_method_bind *mb__get_kernings;
+		godot_method_bind *mb__get_textures;
+		godot_method_bind *mb__set_chars;
+		godot_method_bind *mb__set_kernings;
+		godot_method_bind *mb__set_textures;
+		godot_method_bind *mb_add_char;
+		godot_method_bind *mb_add_kerning_pair;
+		godot_method_bind *mb_add_texture;
+		godot_method_bind *mb_clear;
+		godot_method_bind *mb_create_from_fnt;
+		godot_method_bind *mb_get_char_size;
+		godot_method_bind *mb_get_fallback;
+		godot_method_bind *mb_get_kerning_pair;
+		godot_method_bind *mb_get_texture;
+		godot_method_bind *mb_get_texture_count;
+		godot_method_bind *mb_set_ascent;
+		godot_method_bind *mb_set_distance_field_hint;
+		godot_method_bind *mb_set_fallback;
+		godot_method_bind *mb_set_height;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static BitmapFont *_new();
+
+	// methods
+	PoolIntArray _get_chars() const;
+	PoolIntArray _get_kernings() const;
+	Array _get_textures() const;
+	void _set_chars(const PoolIntArray arg0);
+	void _set_kernings(const PoolIntArray arg0);
+	void _set_textures(const Array arg0);
+	void add_char(const int64_t character, const int64_t texture, const Rect2 rect, const Vector2 align = Vector2(0, 0), const real_t advance = -1);
+	void add_kerning_pair(const int64_t char_a, const int64_t char_b, const int64_t kerning);
+	void add_texture(const Ref<Texture> texture);
+	void clear();
+	Error create_from_fnt(const String path);
+	Vector2 get_char_size(const int64_t _char, const int64_t next = 0) const;
+	Ref<BitmapFont> get_fallback() const;
+	int64_t get_kerning_pair(const int64_t char_a, const int64_t char_b) const;
+	Ref<Texture> get_texture(const int64_t idx) const;
+	int64_t get_texture_count() const;
+	void set_ascent(const real_t px);
+	void set_distance_field_hint(const bool enable);
+	void set_fallback(const Ref<BitmapFont> fallback);
+	void set_height(const real_t px);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/Bone2D.hpp

@@ -0,0 +1,53 @@
+#ifndef GODOT_CPP_BONE2D_HPP
+#define GODOT_CPP_BONE2D_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "Node2D.hpp"
+namespace godot {
+
+
+class Bone2D : public Node2D {
+	struct ___method_bindings {
+		godot_method_bind *mb_apply_rest;
+		godot_method_bind *mb_get_default_length;
+		godot_method_bind *mb_get_index_in_skeleton;
+		godot_method_bind *mb_get_rest;
+		godot_method_bind *mb_get_skeleton_rest;
+		godot_method_bind *mb_set_default_length;
+		godot_method_bind *mb_set_rest;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "Bone2D"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static Bone2D *_new();
+
+	// methods
+	void apply_rest();
+	real_t get_default_length() const;
+	int64_t get_index_in_skeleton() const;
+	Transform2D get_rest() const;
+	Transform2D get_skeleton_rest() const;
+	void set_default_length(const real_t default_length);
+	void set_rest(const Transform2D rest);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BoneAttachment.hpp

@@ -0,0 +1,43 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_bone_name;
+		godot_method_bind *mb_set_bone_name;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static BoneAttachment *_new();
+
+	// methods
+	String get_bone_name() const;
+	void set_bone_name(const String bone_name);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BoxContainer.hpp

@@ -0,0 +1,48 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_add_spacer;
+		godot_method_bind *mb_get_alignment;
+		godot_method_bind *mb_set_alignment;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum AlignMode {
+		ALIGN_BEGIN = 0,
+		ALIGN_CENTER = 1,
+		ALIGN_END = 2,
+	};
+
+	// constants
+
+	// methods
+	void add_spacer(const bool begin);
+	BoxContainer::AlignMode get_alignment() const;
+	void set_alignment(const int64_t alignment);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BoxShape.hpp

@@ -0,0 +1,43 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_extents;
+		godot_method_bind *mb_set_extents;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static BoxShape *_new();
+
+	// methods
+	Vector3 get_extents() const;
+	void set_extents(const Vector3 extents);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BulletPhysicsDirectBodyState.hpp

@@ -0,0 +1,36 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/BulletPhysicsServer.hpp

@@ -0,0 +1,36 @@
+#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 {
+	struct ___method_bindings {
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+	// methods
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/Button.hpp

@@ -0,0 +1,70 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_button_icon;
+		godot_method_bind *mb_get_clip_text;
+		godot_method_bind *mb_get_text;
+		godot_method_bind *mb_get_text_align;
+		godot_method_bind *mb_is_expand_icon;
+		godot_method_bind *mb_is_flat;
+		godot_method_bind *mb_set_button_icon;
+		godot_method_bind *mb_set_clip_text;
+		godot_method_bind *mb_set_expand_icon;
+		godot_method_bind *mb_set_flat;
+		godot_method_bind *mb_set_text;
+		godot_method_bind *mb_set_text_align;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum TextAlign {
+		ALIGN_LEFT = 0,
+		ALIGN_CENTER = 1,
+		ALIGN_RIGHT = 2,
+	};
+
+	// constants
+
+
+	static Button *_new();
+
+	// methods
+	Ref<Texture> get_button_icon() const;
+	bool get_clip_text() const;
+	String get_text() const;
+	Button::TextAlign get_text_align() const;
+	bool is_expand_icon() const;
+	bool is_flat() const;
+	void set_button_icon(const Ref<Texture> texture);
+	void set_clip_text(const bool enabled);
+	void set_expand_icon(const bool arg0);
+	void set_flat(const bool enabled);
+	void set_text(const String text);
+	void set_text_align(const int64_t align);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/ButtonGroup.hpp

@@ -0,0 +1,44 @@
+#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 {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_buttons;
+		godot_method_bind *mb_get_pressed_button;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	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 (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static ButtonGroup *_new();
+
+	// methods
+	Array get_buttons();
+	BaseButton *get_pressed_button();
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/CPUParticles.hpp

@@ -0,0 +1,204 @@
+#ifndef GODOT_CPP_CPUPARTICLES_HPP
+#define GODOT_CPP_CPUPARTICLES_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+#include "CPUParticles.hpp"
+
+#include "GeometryInstance.hpp"
+namespace godot {
+
+class Node;
+class Gradient;
+class Mesh;
+class Curve;
+
+class CPUParticles : public GeometryInstance {
+	struct ___method_bindings {
+		godot_method_bind *mb__update_render_thread;
+		godot_method_bind *mb_convert_from_particles;
+		godot_method_bind *mb_get_amount;
+		godot_method_bind *mb_get_color;
+		godot_method_bind *mb_get_color_ramp;
+		godot_method_bind *mb_get_direction;
+		godot_method_bind *mb_get_draw_order;
+		godot_method_bind *mb_get_emission_box_extents;
+		godot_method_bind *mb_get_emission_colors;
+		godot_method_bind *mb_get_emission_normals;
+		godot_method_bind *mb_get_emission_points;
+		godot_method_bind *mb_get_emission_shape;
+		godot_method_bind *mb_get_emission_sphere_radius;
+		godot_method_bind *mb_get_explosiveness_ratio;
+		godot_method_bind *mb_get_fixed_fps;
+		godot_method_bind *mb_get_flatness;
+		godot_method_bind *mb_get_fractional_delta;
+		godot_method_bind *mb_get_gravity;
+		godot_method_bind *mb_get_lifetime;
+		godot_method_bind *mb_get_lifetime_randomness;
+		godot_method_bind *mb_get_mesh;
+		godot_method_bind *mb_get_one_shot;
+		godot_method_bind *mb_get_param;
+		godot_method_bind *mb_get_param_curve;
+		godot_method_bind *mb_get_param_randomness;
+		godot_method_bind *mb_get_particle_flag;
+		godot_method_bind *mb_get_pre_process_time;
+		godot_method_bind *mb_get_randomness_ratio;
+		godot_method_bind *mb_get_speed_scale;
+		godot_method_bind *mb_get_spread;
+		godot_method_bind *mb_get_use_local_coordinates;
+		godot_method_bind *mb_is_emitting;
+		godot_method_bind *mb_restart;
+		godot_method_bind *mb_set_amount;
+		godot_method_bind *mb_set_color;
+		godot_method_bind *mb_set_color_ramp;
+		godot_method_bind *mb_set_direction;
+		godot_method_bind *mb_set_draw_order;
+		godot_method_bind *mb_set_emission_box_extents;
+		godot_method_bind *mb_set_emission_colors;
+		godot_method_bind *mb_set_emission_normals;
+		godot_method_bind *mb_set_emission_points;
+		godot_method_bind *mb_set_emission_shape;
+		godot_method_bind *mb_set_emission_sphere_radius;
+		godot_method_bind *mb_set_emitting;
+		godot_method_bind *mb_set_explosiveness_ratio;
+		godot_method_bind *mb_set_fixed_fps;
+		godot_method_bind *mb_set_flatness;
+		godot_method_bind *mb_set_fractional_delta;
+		godot_method_bind *mb_set_gravity;
+		godot_method_bind *mb_set_lifetime;
+		godot_method_bind *mb_set_lifetime_randomness;
+		godot_method_bind *mb_set_mesh;
+		godot_method_bind *mb_set_one_shot;
+		godot_method_bind *mb_set_param;
+		godot_method_bind *mb_set_param_curve;
+		godot_method_bind *mb_set_param_randomness;
+		godot_method_bind *mb_set_particle_flag;
+		godot_method_bind *mb_set_pre_process_time;
+		godot_method_bind *mb_set_randomness_ratio;
+		godot_method_bind *mb_set_speed_scale;
+		godot_method_bind *mb_set_spread;
+		godot_method_bind *mb_set_use_local_coordinates;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "CPUParticles"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum Flags {
+		FLAG_ALIGN_Y_TO_VELOCITY = 0,
+		FLAG_ROTATE_Y = 1,
+		FLAG_DISABLE_Z = 2,
+		FLAG_MAX = 3,
+	};
+	enum EmissionShape {
+		EMISSION_SHAPE_POINT = 0,
+		EMISSION_SHAPE_SPHERE = 1,
+		EMISSION_SHAPE_BOX = 2,
+		EMISSION_SHAPE_POINTS = 3,
+		EMISSION_SHAPE_DIRECTED_POINTS = 4,
+		EMISSION_SHAPE_MAX = 5,
+	};
+	enum Parameter {
+		PARAM_INITIAL_LINEAR_VELOCITY = 0,
+		PARAM_ANGULAR_VELOCITY = 1,
+		PARAM_ORBIT_VELOCITY = 2,
+		PARAM_LINEAR_ACCEL = 3,
+		PARAM_RADIAL_ACCEL = 4,
+		PARAM_TANGENTIAL_ACCEL = 5,
+		PARAM_DAMPING = 6,
+		PARAM_ANGLE = 7,
+		PARAM_SCALE = 8,
+		PARAM_HUE_VARIATION = 9,
+		PARAM_ANIM_SPEED = 10,
+		PARAM_ANIM_OFFSET = 11,
+		PARAM_MAX = 12,
+	};
+	enum DrawOrder {
+		DRAW_ORDER_INDEX = 0,
+		DRAW_ORDER_LIFETIME = 1,
+		DRAW_ORDER_VIEW_DEPTH = 2,
+	};
+
+	// constants
+
+
+	static CPUParticles *_new();
+
+	// methods
+	void _update_render_thread();
+	void convert_from_particles(const Node *particles);
+	int64_t get_amount() const;
+	Color get_color() const;
+	Ref<Gradient> get_color_ramp() const;
+	Vector3 get_direction() const;
+	CPUParticles::DrawOrder get_draw_order() const;
+	Vector3 get_emission_box_extents() const;
+	PoolColorArray get_emission_colors() const;
+	PoolVector3Array get_emission_normals() const;
+	PoolVector3Array get_emission_points() const;
+	CPUParticles::EmissionShape get_emission_shape() const;
+	real_t get_emission_sphere_radius() const;
+	real_t get_explosiveness_ratio() const;
+	int64_t get_fixed_fps() const;
+	real_t get_flatness() const;
+	bool get_fractional_delta() const;
+	Vector3 get_gravity() const;
+	real_t get_lifetime() const;
+	real_t get_lifetime_randomness() const;
+	Ref<Mesh> get_mesh() const;
+	bool get_one_shot() const;
+	real_t get_param(const int64_t param) const;
+	Ref<Curve> get_param_curve(const int64_t param) const;
+	real_t get_param_randomness(const int64_t param) const;
+	bool get_particle_flag(const int64_t flag) const;
+	real_t get_pre_process_time() const;
+	real_t get_randomness_ratio() const;
+	real_t get_speed_scale() const;
+	real_t get_spread() const;
+	bool get_use_local_coordinates() const;
+	bool is_emitting() const;
+	void restart();
+	void set_amount(const int64_t amount);
+	void set_color(const Color color);
+	void set_color_ramp(const Ref<Gradient> ramp);
+	void set_direction(const Vector3 direction);
+	void set_draw_order(const int64_t order);
+	void set_emission_box_extents(const Vector3 extents);
+	void set_emission_colors(const PoolColorArray array);
+	void set_emission_normals(const PoolVector3Array array);
+	void set_emission_points(const PoolVector3Array array);
+	void set_emission_shape(const int64_t shape);
+	void set_emission_sphere_radius(const real_t radius);
+	void set_emitting(const bool emitting);
+	void set_explosiveness_ratio(const real_t ratio);
+	void set_fixed_fps(const int64_t fps);
+	void set_flatness(const real_t amount);
+	void set_fractional_delta(const bool enable);
+	void set_gravity(const Vector3 accel_vec);
+	void set_lifetime(const real_t secs);
+	void set_lifetime_randomness(const real_t random);
+	void set_mesh(const Ref<Mesh> mesh);
+	void set_one_shot(const bool enable);
+	void set_param(const int64_t param, const real_t value);
+	void set_param_curve(const int64_t param, const Ref<Curve> curve);
+	void set_param_randomness(const int64_t param, const real_t randomness);
+	void set_particle_flag(const int64_t flag, const bool enable);
+	void set_pre_process_time(const real_t secs);
+	void set_randomness_ratio(const real_t ratio);
+	void set_speed_scale(const real_t scale);
+	void set_spread(const real_t degrees);
+	void set_use_local_coordinates(const bool enable);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/CPUParticles2D.hpp

@@ -0,0 +1,203 @@
+#ifndef GODOT_CPP_CPUPARTICLES2D_HPP
+#define GODOT_CPP_CPUPARTICLES2D_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+#include "CPUParticles2D.hpp"
+
+#include "Node2D.hpp"
+namespace godot {
+
+class Node;
+class Gradient;
+class Texture;
+class Curve;
+
+class CPUParticles2D : public Node2D {
+	struct ___method_bindings {
+		godot_method_bind *mb__update_render_thread;
+		godot_method_bind *mb_convert_from_particles;
+		godot_method_bind *mb_get_amount;
+		godot_method_bind *mb_get_color;
+		godot_method_bind *mb_get_color_ramp;
+		godot_method_bind *mb_get_direction;
+		godot_method_bind *mb_get_draw_order;
+		godot_method_bind *mb_get_emission_colors;
+		godot_method_bind *mb_get_emission_normals;
+		godot_method_bind *mb_get_emission_points;
+		godot_method_bind *mb_get_emission_rect_extents;
+		godot_method_bind *mb_get_emission_shape;
+		godot_method_bind *mb_get_emission_sphere_radius;
+		godot_method_bind *mb_get_explosiveness_ratio;
+		godot_method_bind *mb_get_fixed_fps;
+		godot_method_bind *mb_get_fractional_delta;
+		godot_method_bind *mb_get_gravity;
+		godot_method_bind *mb_get_lifetime;
+		godot_method_bind *mb_get_lifetime_randomness;
+		godot_method_bind *mb_get_normalmap;
+		godot_method_bind *mb_get_one_shot;
+		godot_method_bind *mb_get_param;
+		godot_method_bind *mb_get_param_curve;
+		godot_method_bind *mb_get_param_randomness;
+		godot_method_bind *mb_get_particle_flag;
+		godot_method_bind *mb_get_pre_process_time;
+		godot_method_bind *mb_get_randomness_ratio;
+		godot_method_bind *mb_get_speed_scale;
+		godot_method_bind *mb_get_spread;
+		godot_method_bind *mb_get_texture;
+		godot_method_bind *mb_get_use_local_coordinates;
+		godot_method_bind *mb_is_emitting;
+		godot_method_bind *mb_restart;
+		godot_method_bind *mb_set_amount;
+		godot_method_bind *mb_set_color;
+		godot_method_bind *mb_set_color_ramp;
+		godot_method_bind *mb_set_direction;
+		godot_method_bind *mb_set_draw_order;
+		godot_method_bind *mb_set_emission_colors;
+		godot_method_bind *mb_set_emission_normals;
+		godot_method_bind *mb_set_emission_points;
+		godot_method_bind *mb_set_emission_rect_extents;
+		godot_method_bind *mb_set_emission_shape;
+		godot_method_bind *mb_set_emission_sphere_radius;
+		godot_method_bind *mb_set_emitting;
+		godot_method_bind *mb_set_explosiveness_ratio;
+		godot_method_bind *mb_set_fixed_fps;
+		godot_method_bind *mb_set_fractional_delta;
+		godot_method_bind *mb_set_gravity;
+		godot_method_bind *mb_set_lifetime;
+		godot_method_bind *mb_set_lifetime_randomness;
+		godot_method_bind *mb_set_normalmap;
+		godot_method_bind *mb_set_one_shot;
+		godot_method_bind *mb_set_param;
+		godot_method_bind *mb_set_param_curve;
+		godot_method_bind *mb_set_param_randomness;
+		godot_method_bind *mb_set_particle_flag;
+		godot_method_bind *mb_set_pre_process_time;
+		godot_method_bind *mb_set_randomness_ratio;
+		godot_method_bind *mb_set_speed_scale;
+		godot_method_bind *mb_set_spread;
+		godot_method_bind *mb_set_texture;
+		godot_method_bind *mb_set_use_local_coordinates;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "CPUParticles2D"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+	enum Flags {
+		FLAG_ALIGN_Y_TO_VELOCITY = 0,
+		FLAG_ROTATE_Y = 1,
+		FLAG_DISABLE_Z = 2,
+		FLAG_MAX = 3,
+	};
+	enum EmissionShape {
+		EMISSION_SHAPE_POINT = 0,
+		EMISSION_SHAPE_SPHERE = 1,
+		EMISSION_SHAPE_RECTANGLE = 2,
+		EMISSION_SHAPE_POINTS = 3,
+		EMISSION_SHAPE_DIRECTED_POINTS = 4,
+		EMISSION_SHAPE_MAX = 5,
+	};
+	enum Parameter {
+		PARAM_INITIAL_LINEAR_VELOCITY = 0,
+		PARAM_ANGULAR_VELOCITY = 1,
+		PARAM_ORBIT_VELOCITY = 2,
+		PARAM_LINEAR_ACCEL = 3,
+		PARAM_RADIAL_ACCEL = 4,
+		PARAM_TANGENTIAL_ACCEL = 5,
+		PARAM_DAMPING = 6,
+		PARAM_ANGLE = 7,
+		PARAM_SCALE = 8,
+		PARAM_HUE_VARIATION = 9,
+		PARAM_ANIM_SPEED = 10,
+		PARAM_ANIM_OFFSET = 11,
+		PARAM_MAX = 12,
+	};
+	enum DrawOrder {
+		DRAW_ORDER_INDEX = 0,
+		DRAW_ORDER_LIFETIME = 1,
+	};
+
+	// constants
+
+
+	static CPUParticles2D *_new();
+
+	// methods
+	void _update_render_thread();
+	void convert_from_particles(const Node *particles);
+	int64_t get_amount() const;
+	Color get_color() const;
+	Ref<Gradient> get_color_ramp() const;
+	Vector2 get_direction() const;
+	CPUParticles2D::DrawOrder get_draw_order() const;
+	PoolColorArray get_emission_colors() const;
+	PoolVector2Array get_emission_normals() const;
+	PoolVector2Array get_emission_points() const;
+	Vector2 get_emission_rect_extents() const;
+	CPUParticles2D::EmissionShape get_emission_shape() const;
+	real_t get_emission_sphere_radius() const;
+	real_t get_explosiveness_ratio() const;
+	int64_t get_fixed_fps() const;
+	bool get_fractional_delta() const;
+	Vector2 get_gravity() const;
+	real_t get_lifetime() const;
+	real_t get_lifetime_randomness() const;
+	Ref<Texture> get_normalmap() const;
+	bool get_one_shot() const;
+	real_t get_param(const int64_t param) const;
+	Ref<Curve> get_param_curve(const int64_t param) const;
+	real_t get_param_randomness(const int64_t param) const;
+	bool get_particle_flag(const int64_t flag) const;
+	real_t get_pre_process_time() const;
+	real_t get_randomness_ratio() const;
+	real_t get_speed_scale() const;
+	real_t get_spread() const;
+	Ref<Texture> get_texture() const;
+	bool get_use_local_coordinates() const;
+	bool is_emitting() const;
+	void restart();
+	void set_amount(const int64_t amount);
+	void set_color(const Color color);
+	void set_color_ramp(const Ref<Gradient> ramp);
+	void set_direction(const Vector2 direction);
+	void set_draw_order(const int64_t order);
+	void set_emission_colors(const PoolColorArray array);
+	void set_emission_normals(const PoolVector2Array array);
+	void set_emission_points(const PoolVector2Array array);
+	void set_emission_rect_extents(const Vector2 extents);
+	void set_emission_shape(const int64_t shape);
+	void set_emission_sphere_radius(const real_t radius);
+	void set_emitting(const bool emitting);
+	void set_explosiveness_ratio(const real_t ratio);
+	void set_fixed_fps(const int64_t fps);
+	void set_fractional_delta(const bool enable);
+	void set_gravity(const Vector2 accel_vec);
+	void set_lifetime(const real_t secs);
+	void set_lifetime_randomness(const real_t random);
+	void set_normalmap(const Ref<Texture> normalmap);
+	void set_one_shot(const bool enable);
+	void set_param(const int64_t param, const real_t value);
+	void set_param_curve(const int64_t param, const Ref<Curve> curve);
+	void set_param_randomness(const int64_t param, const real_t randomness);
+	void set_particle_flag(const int64_t flag, const bool enable);
+	void set_pre_process_time(const real_t secs);
+	void set_randomness_ratio(const real_t ratio);
+	void set_speed_scale(const real_t scale);
+	void set_spread(const real_t degrees);
+	void set_texture(const Ref<Texture> texture);
+	void set_use_local_coordinates(const bool enable);
+
+};
+
+}
+
+#endif

GodoBinding/include/gen/CSGBox.hpp

@@ -0,0 +1,56 @@
+#ifndef GODOT_CPP_CSGBOX_HPP
+#define GODOT_CPP_CSGBOX_HPP
+
+
+#include <gdnative_api_struct.gen.h>
+#include <stdint.h>
+
+#include <core/CoreTypes.hpp>
+#include <core/Ref.hpp>
+
+#include "CSGPrimitive.hpp"
+namespace godot {
+
+class Material;
+
+class CSGBox : public CSGPrimitive {
+	struct ___method_bindings {
+		godot_method_bind *mb_get_depth;
+		godot_method_bind *mb_get_height;
+		godot_method_bind *mb_get_material;
+		godot_method_bind *mb_get_width;
+		godot_method_bind *mb_set_depth;
+		godot_method_bind *mb_set_height;
+		godot_method_bind *mb_set_material;
+		godot_method_bind *mb_set_width;
+	};
+	static ___method_bindings ___mb;
+
+public:
+	static void ___init_method_bindings();
+
+	static inline const char *___get_class_name() { return (const char *) "CSGBox"; }
+	static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }
+
+	// enums
+
+	// constants
+
+
+	static CSGBox *_new();
+
+	// methods
+	real_t get_depth() const;
+	real_t get_height() const;
+	Ref<Material> get_material() const;
+	real_t get_width() const;
+	void set_depth(const real_t depth);
+	void set_height(const real_t height);
+	void set_material(const Ref<Material> material);
+	void set_width(const real_t width);
+
+};
+
+}
+
+#endif