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

remove accidentally added files

pull/155/head
karroffel 2018-07-25 14:29:53 +02:00
parent 7fc6a8b98d
commit 7044f45409
458 changed files with 0 additions and 26107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
include/gen/ARVRAnchor.hpp
View File

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

36
include/gen/ARVRCamera.hpp
View File

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

47
include/gen/ARVRController.hpp
View File

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

66
include/gen/ARVRInterface.hpp
View File

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

36
include/gen/ARVRInterfaceGDNative.hpp
View File

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

38
include/gen/ARVROrigin.hpp
View File

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

59
include/gen/ARVRPositionalTracker.hpp
View File

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

76
include/gen/ARVRServer.hpp
View File

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

56
include/gen/AStar.hpp
View File

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

51
include/gen/AcceptDialog.hpp
View File

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

59
include/gen/AnimatedSprite.hpp
View File

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

49
include/gen/AnimatedSprite3D.hpp
View File

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

96
include/gen/Animation.hpp
View File

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

84
include/gen/AnimationPlayer.hpp
View File

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

118
include/gen/AnimationTreePlayer.hpp
View File

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

95
include/gen/Area.hpp
View File

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

87
include/gen/Area2D.hpp
View File

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

88
include/gen/ArrayMesh.hpp
View File

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

45
include/gen/AtlasTexture.hpp
View File

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

36
include/gen/AudioBusLayout.hpp
View File

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

33
include/gen/AudioEffect.hpp
View File

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

38
include/gen/AudioEffectAmplify.hpp
View File

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

36
include/gen/AudioEffectBandLimitFilter.hpp
View File

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

36
include/gen/AudioEffectBandPassFilter.hpp
View File

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

54
include/gen/AudioEffectChorus.hpp
View File

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

50
include/gen/AudioEffectCompressor.hpp
View File

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

62
include/gen/AudioEffectDelay.hpp
View File

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

54
include/gen/AudioEffectDistortion.hpp
View File

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

39
include/gen/AudioEffectEQ.hpp
View File

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

36
include/gen/AudioEffectEQ10.hpp
View File

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

36
include/gen/AudioEffectEQ21.hpp
View File

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

36
include/gen/AudioEffectEQ6.hpp
View File

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

51
include/gen/AudioEffectFilter.hpp
View File

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

36
include/gen/AudioEffectHighPassFilter.hpp
View File

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

36
include/gen/AudioEffectHighShelfFilter.hpp
View File

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

44
include/gen/AudioEffectLimiter.hpp
View File

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

36
include/gen/AudioEffectLowPassFilter.hpp
View File

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

36
include/gen/AudioEffectLowShelfFilter.hpp
View File

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

36
include/gen/AudioEffectNotchFilter.hpp
View File

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

38
include/gen/AudioEffectPanner.hpp
View File

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

46
include/gen/AudioEffectPhaser.hpp
View File

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

38
include/gen/AudioEffectPitchShift.hpp
View File

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

52
include/gen/AudioEffectReverb.hpp
View File

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

42
include/gen/AudioEffectStereoEnhance.hpp
View File

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

89
include/gen/AudioServer.hpp
View File

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

34
include/gen/AudioStream.hpp
View File

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

42
include/gen/AudioStreamOGGVorbis.hpp
View File

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

33
include/gen/AudioStreamPlayback.hpp
View File

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

63
include/gen/AudioStreamPlayer.hpp
View File

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

61
include/gen/AudioStreamPlayer2D.hpp
View File

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

94
include/gen/AudioStreamPlayer3D.hpp
View File

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

41
include/gen/AudioStreamRandomPitch.hpp
View File

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

61
include/gen/AudioStreamSample.hpp
View File

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

46
include/gen/BackBufferCopy.hpp
View File

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

77
include/gen/BakedLightmap.hpp
View File

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

54
include/gen/BakedLightmapData.hpp
View File

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

70
include/gen/BaseButton.hpp
View File

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

46
include/gen/BitMap.hpp
View File

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

58
include/gen/BitmapFont.hpp
View File

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

38
include/gen/BoneAttachment.hpp
View File

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

42
include/gen/BoxContainer.hpp
View File

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

38
include/gen/BoxShape.hpp
View File

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

33
include/gen/BulletPhysicsDirectBodyState.hpp
View File

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

33
include/gen/BulletPhysicsServer.hpp
View File

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

53
include/gen/Button.hpp
View File

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

38
include/gen/ButtonGroup.hpp
View File

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

86
include/gen/Camera.hpp
View File

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

89
include/gen/Camera2D.hpp
View File

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

131
include/gen/CanvasItem.hpp
View File

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

53
include/gen/CanvasItemMaterial.hpp
View File

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

53
include/gen/CanvasLayer.hpp
View File

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

38
include/gen/CanvasModulate.hpp
View File

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

44
include/gen/CapsuleMesh.hpp
View File

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

40
include/gen/CapsuleShape.hpp
View File

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

40
include/gen/CapsuleShape2D.hpp
View File

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

38
include/gen/CenterContainer.hpp
View File

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

36
include/gen/CheckBox.hpp
View File

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

36
include/gen/CheckButton.hpp
View File

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

38
include/gen/CircleShape2D.hpp
View File

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

66
include/gen/ClassDB.hpp
View File

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

57
include/gen/CollisionObject.hpp
View File

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

57
include/gen/CollisionObject2D.hpp
View File

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

43
include/gen/CollisionPolygon.hpp
View File

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

49
include/gen/CollisionPolygon2D.hpp
View File

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

44
include/gen/CollisionShape.hpp
View File

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

44
include/gen/CollisionShape2D.hpp
View File

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

60
include/gen/ColorPicker.hpp
View File

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

46
include/gen/ColorPickerButton.hpp
View File

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

38
include/gen/ColorRect.hpp
View File

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

38
include/gen/ConcavePolygonShape.hpp
View File

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

38
include/gen/ConcavePolygonShape2D.hpp
View File

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

50
include/gen/ConeTwistJoint.hpp
View File

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

45
include/gen/ConfigFile.hpp
View File

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

38
include/gen/ConfirmationDialog.hpp
View File

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

42
include/gen/Container.hpp
View File

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

232
include/gen/Control.hpp
View File

@ -1,232 +0,0 @@
#ifndef GODOT_CPP_CONTROL_HPP
#define GODOT_CPP_CONTROL_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include "Control.hpp"
#include "CanvasItem.hpp"
namespace godot {
class InputEvent;
class Object;
class Control;
class Theme;
class Texture;
class Shader;
class StyleBox;
class Font;
class Control : public CanvasItem {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "Control"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum Anchor {
ANCHOR_BEGIN = 0,
ANCHOR_END = 1,
};
enum FocusMode {
FOCUS_NONE = 0,
FOCUS_ALL = 2,
FOCUS_CLICK = 1,
};
enum LayoutPresetMode {
PRESET_MODE_MINSIZE = 0,
PRESET_MODE_KEEP_WIDTH = 1,
PRESET_MODE_KEEP_SIZE = 3,
PRESET_MODE_KEEP_HEIGHT = 2,
};
enum MouseFilter {
MOUSE_FILTER_STOP = 0,
MOUSE_FILTER_IGNORE = 2,
MOUSE_FILTER_PASS = 1,
};
enum CursorShape {
CURSOR_ARROW = 0,
CURSOR_WAIT = 4,
CURSOR_FORBIDDEN = 8,
CURSOR_CROSS = 3,
CURSOR_DRAG = 6,
CURSOR_FDIAGSIZE = 12,
CURSOR_HSIZE = 10,
CURSOR_MOVE = 13,
CURSOR_IBEAM = 1,
CURSOR_HSPLIT = 15,
CURSOR_BUSY = 5,
CURSOR_HELP = 16,
CURSOR_POINTING_HAND = 2,
CURSOR_VSIZE = 9,
CURSOR_CAN_DROP = 7,
CURSOR_VSPLIT = 14,
CURSOR_BDIAGSIZE = 11,
};
enum GrowDirection {
GROW_DIRECTION_END = 1,
GROW_DIRECTION_BOTH = 2,
GROW_DIRECTION_BEGIN = 0,
};
enum SizeFlags {
SIZE_EXPAND = 2,
SIZE_SHRINK_END = 8,
SIZE_FILL = 1,
SIZE_SHRINK_CENTER = 4,
SIZE_EXPAND_FILL = 3,
};
enum LayoutPreset {
PRESET_TOP_LEFT = 0,
PRESET_CENTER_RIGHT = 6,
PRESET_BOTTOM_LEFT = 2,
PRESET_CENTER_TOP = 5,
PRESET_CENTER_LEFT = 4,
PRESET_WIDE = 15,
PRESET_HCENTER_WIDE = 14,
PRESET_VCENTER_WIDE = 13,
PRESET_CENTER = 8,
PRESET_CENTER_BOTTOM = 7,
PRESET_TOP_RIGHT = 1,
PRESET_TOP_WIDE = 10,
PRESET_RIGHT_WIDE = 11,
PRESET_BOTTOM_RIGHT = 3,
PRESET_LEFT_WIDE = 9,
PRESET_BOTTOM_WIDE = 12,
};
// constants
const static int NOTIFICATION_MOUSE_EXIT = 42;
const static int NOTIFICATION_THEME_CHANGED = 45;
const static int NOTIFICATION_MOUSE_ENTER = 41;
const static int NOTIFICATION_FOCUS_ENTER = 43;
const static int NOTIFICATION_FOCUS_EXIT = 44;
const static int NOTIFICATION_MODAL_CLOSE = 46;
const static int NOTIFICATION_RESIZED = 40;
const static int NOTIFICATION_SCROLL_END = 48;
const static int NOTIFICATION_SCROLL_BEGIN = 47;
static Control *_new();
// methods
void _gui_input(const Ref<InputEvent> event);
Vector2 _get_minimum_size();
Object *get_drag_data(const Vector2 position);
bool can_drop_data(const Vector2 position, const Variant data);
void drop_data(const Vector2 position, const Variant data);
bool has_point(const Vector2 point);
void _size_changed();
void _update_minimum_size();
void accept_event();
Vector2 get_minimum_size() const;
Vector2 get_combined_minimum_size() const;
void set_anchors_preset(const int64_t preset, const bool keep_margin = false);
void set_margins_preset(const int64_t preset, const int64_t resize_mode = 0, const int64_t margin = 0);
void set_anchors_and_margins_preset(const int64_t preset, const int64_t resize_mode = 0, const int64_t margin = 0);
void set_anchor(const int64_t margin, const double anchor, const bool keep_margin = false, const bool push_opposite_anchor = true);
void _set_anchor(const int64_t margin, const double anchor);
double get_anchor(const int64_t margin) const;
void set_margin(const int64_t margin, const double offset);
void set_anchor_and_margin(const int64_t margin, const double anchor, const double offset, const bool push_opposite_anchor = false);
void set_begin(const Vector2 position);
void set_end(const Vector2 position);
void set_position(const Vector2 position);
void set_size(const Vector2 size);
void set_custom_minimum_size(const Vector2 size);
void set_global_position(const Vector2 position);
void set_rotation(const double radians);
void set_rotation_degrees(const double degrees);
void set_scale(const Vector2 scale);
void set_pivot_offset(const Vector2 pivot_offset);
double get_margin(const int64_t margin) const;
Vector2 get_begin() const;
Vector2 get_end() const;
Vector2 get_position() const;
Vector2 get_size() const;
double get_rotation() const;
double get_rotation_degrees() const;
Vector2 get_scale() const;
Vector2 get_pivot_offset() const;
Vector2 get_custom_minimum_size() const;
Vector2 get_parent_area_size() const;
Vector2 get_global_position() const;
Rect2 get_rect() const;
Rect2 get_global_rect() const;
void show_modal(const bool exclusive = false);
void set_focus_mode(const int64_t mode);
Control::FocusMode get_focus_mode() const;
bool has_focus() const;
void grab_focus();
void release_focus();
Control *get_focus_owner() const;
void set_h_size_flags(const int64_t flags);
int64_t get_h_size_flags() const;
void set_stretch_ratio(const double ratio);
double get_stretch_ratio() const;
void set_v_size_flags(const int64_t flags);
int64_t get_v_size_flags() const;
void set_theme(const Ref<Theme> theme);
Ref<Theme> get_theme() const;
void add_icon_override(const String name, const Ref<Texture> texture);
void add_shader_override(const String name, const Ref<Shader> shader);
void add_stylebox_override(const String name, const Ref<StyleBox> stylebox);
void add_font_override(const String name, const Ref<Font> font);
void add_color_override(const String name, const Color color);
void add_constant_override(const String name, const int64_t constant);
Ref<Texture> get_icon(const String name, const String type = "") const;
Ref<StyleBox> get_stylebox(const String name, const String type = "") const;
Ref<Font> get_font(const String name, const String type = "") const;
Color get_color(const String name, const String type = "") const;
int64_t get_constant(const String name, const String type = "") const;
bool has_icon_override(const String name) const;
bool has_shader_override(const String name) const;
bool has_stylebox_override(const String name) const;
bool has_font_override(const String name) const;
bool has_color_override(const String name) const;
bool has_constant_override(const String name) const;
bool has_icon(const String name, const String type = "") const;
bool has_stylebox(const String name, const String type = "") const;
bool has_font(const String name, const String type = "") const;
bool has_color(const String name, const String type = "") const;
bool has_constant(const String name, const String type = "") const;
Control *get_parent_control() const;
void set_h_grow_direction(const int64_t direction);
Control::GrowDirection get_h_grow_direction() const;
void set_v_grow_direction(const int64_t direction);
Control::GrowDirection get_v_grow_direction() const;
void set_tooltip(const String tooltip);
String get_tooltip(const Vector2 at_position = Vector2(0, 0)) const;
String _get_tooltip() const;
void set_default_cursor_shape(const int64_t shape);
Control::CursorShape get_default_cursor_shape() const;
Control::CursorShape get_cursor_shape(const Vector2 position = Vector2(0, 0)) const;
void set_focus_neighbour(const int64_t margin, const NodePath neighbour);
NodePath get_focus_neighbour(const int64_t margin) const;
void set_focus_next(const NodePath next);
NodePath get_focus_next() const;
void set_focus_previous(const NodePath previous);
NodePath get_focus_previous() const;
void force_drag(const Variant data, const Object *preview);
void set_mouse_filter(const int64_t filter);
Control::MouseFilter get_mouse_filter() const;
void set_clip_contents(const bool enable);
bool is_clipping_contents();
void grab_click_focus();
void set_drag_forwarding(const Object *target);
void set_drag_preview(const Object *control);
void warp_mouse(const Vector2 to_position);
void minimum_size_changed();
void _theme_changed();
void _font_changed();
};
}
#endif

38
include/gen/ConvexPolygonShape.hpp
View File

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

39
include/gen/ConvexPolygonShape2D.hpp
View File

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

67
include/gen/CubeMap.hpp
View File

@ -1,67 +0,0 @@
#ifndef GODOT_CPP_CUBEMAP_HPP
#define GODOT_CPP_CUBEMAP_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include "CubeMap.hpp"
#include "Resource.hpp"
namespace godot {
class Image;
class CubeMap : public Resource {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CubeMap"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
enum Flags {
FLAG_MIPMAPS = 1,
FLAG_FILTER = 4,
FLAG_REPEAT = 2,
FLAGS_DEFAULT = 7,
};
enum Side {
SIDE_FRONT = 4,
SIDE_LEFT = 0,
SIDE_BACK = 5,
SIDE_BOTTOM = 2,
SIDE_RIGHT = 1,
SIDE_TOP = 3,
};
enum Storage {
STORAGE_COMPRESS_LOSSLESS = 2,
STORAGE_COMPRESS_LOSSY = 1,
STORAGE_RAW = 0,
};
// constants
static CubeMap *_new();
// methods
int64_t get_width() const;
int64_t get_height() const;
void set_flags(const int64_t flags);
int64_t get_flags() const;
void set_side(const int64_t side, const Ref<Image> image);
Ref<Image> get_side(const int64_t side) const;
void set_storage(const int64_t mode);
CubeMap::Storage get_storage() const;
void set_lossy_storage_quality(const double quality);
double get_lossy_storage_quality() const;
};
}
#endif

44
include/gen/CubeMesh.hpp
View File

@ -1,44 +0,0 @@
#ifndef GODOT_CPP_CUBEMESH_HPP
#define GODOT_CPP_CUBEMESH_HPP
#include <gdnative_api_struct.gen.h>
#include <stdint.h>
#include <core/CoreTypes.hpp>
#include <core/Ref.hpp>
#include "PrimitiveMesh.hpp"
namespace godot {
class CubeMesh : public PrimitiveMesh {
public:
static void *___get_type_tag();
static void *___get_base_type_tag();
static inline const char *___get_class_name() { return (const char *) "CubeMesh"; }
static inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o); }
// enums
// constants
static CubeMesh *_new();
// methods
void set_size(const Vector3 size);
Vector3 get_size() const;
void set_subdivide_width(const int64_t subdivide);
int64_t get_subdivide_width() const;
void set_subdivide_height(const int64_t divisions);
int64_t get_subdivide_height() const;
void set_subdivide_depth(const int64_t divisions);
int64_t get_subdivide_depth() const;
};
}
#endif

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