use std::os::raw::c_char;
use std::ptr;
use std::mem;
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventMouseButton {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventMouseButton {
fn class_name() -> &'static str {
"InputEventMouseButton"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventMouseButton {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventMouseButton {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventMouseButtonMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventMouseButton {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_factor(&mut self, factor: f64) -> () {
unsafe { InputEventMouseButton_set_factor(self.this, factor) }
}
#[inline]
pub fn get_factor(&mut self) -> f64 {
unsafe { InputEventMouseButton_get_factor(self.this) }
}
#[inline]
pub fn set_button_index(&mut self, button_index: i64) -> () {
unsafe { InputEventMouseButton_set_button_index(self.this, button_index) }
}
#[inline]
pub fn get_button_index(&self) -> i64 {
unsafe { InputEventMouseButton_get_button_index(self.this) }
}
#[inline]
pub fn set_pressed(&mut self, pressed: bool) -> () {
unsafe { InputEventMouseButton_set_pressed(self.this, pressed) }
}
#[inline]
pub fn set_doubleclick(&mut self, doubleclick: bool) -> () {
unsafe { InputEventMouseButton_set_doubleclick(self.this, doubleclick) }
}
#[inline]
pub fn is_doubleclick(&self) -> bool {
unsafe { InputEventMouseButton_is_doubleclick(self.this) }
}
#[inline]
pub fn set_button_mask(&mut self, button_mask: i64) -> () {
unsafe { InputEventMouse_set_button_mask(self.this, button_mask) }
}
#[inline]
pub fn get_button_mask(&self) -> i64 {
unsafe { InputEventMouse_get_button_mask(self.this) }
}
#[inline]
pub fn set_position(&mut self, position: Vector2) -> () {
unsafe { InputEventMouse_set_position(self.this, position) }
}
#[inline]
pub fn get_position(&self) -> Vector2 {
unsafe { InputEventMouse_get_position(self.this) }
}
#[inline]
pub fn set_global_position(&mut self, global_position: Vector2) -> () {
unsafe { InputEventMouse_set_global_position(self.this, global_position) }
}
#[inline]
pub fn get_global_position(&self) -> Vector2 {
unsafe { InputEventMouse_get_global_position(self.this) }
}
#[inline]
pub fn set_alt(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_alt(self.this, enable) }
}
#[inline]
pub fn get_alt(&self) -> bool {
unsafe { InputEventWithModifiers_get_alt(self.this) }
}
#[inline]
pub fn set_shift(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_shift(self.this, enable) }
}
#[inline]
pub fn get_shift(&self) -> bool {
unsafe { InputEventWithModifiers_get_shift(self.this) }
}
#[inline]
pub fn set_control(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_control(self.this, enable) }
}
#[inline]
pub fn get_control(&self) -> bool {
unsafe { InputEventWithModifiers_get_control(self.this) }
}
#[inline]
pub fn set_metakey(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_metakey(self.this, enable) }
}
#[inline]
pub fn get_metakey(&self) -> bool {
unsafe { InputEventWithModifiers_get_metakey(self.this) }
}
#[inline]
pub fn set_command(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_command(self.this, enable) }
}
#[inline]
pub fn get_command(&self) -> bool {
unsafe { InputEventWithModifiers_get_command(self.this) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event_mouse(&self) -> InputEventMouse {
unsafe {{ object::add_ref(self.this); }}
InputEventMouse { this: self.this }
}
#[inline]
pub fn to_input_event_with_modifiers(&self) -> InputEventWithModifiers {
unsafe {{ object::add_ref(self.this); }}
InputEventWithModifiers { this: self.this }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventMouseButton {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventMouse {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventMouse {
fn class_name() -> &'static str {
"InputEventMouse"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventMouse {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventMouse {
#[inline]
pub fn set_button_mask(&mut self, button_mask: i64) -> () {
unsafe { InputEventMouse_set_button_mask(self.this, button_mask) }
}
#[inline]
pub fn get_button_mask(&self) -> i64 {
unsafe { InputEventMouse_get_button_mask(self.this) }
}
#[inline]
pub fn set_position(&mut self, position: Vector2) -> () {
unsafe { InputEventMouse_set_position(self.this, position) }
}
#[inline]
pub fn get_position(&self) -> Vector2 {
unsafe { InputEventMouse_get_position(self.this) }
}
#[inline]
pub fn set_global_position(&mut self, global_position: Vector2) -> () {
unsafe { InputEventMouse_set_global_position(self.this, global_position) }
}
#[inline]
pub fn get_global_position(&self) -> Vector2 {
unsafe { InputEventMouse_get_global_position(self.this) }
}
#[inline]
pub fn set_alt(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_alt(self.this, enable) }
}
#[inline]
pub fn get_alt(&self) -> bool {
unsafe { InputEventWithModifiers_get_alt(self.this) }
}
#[inline]
pub fn set_shift(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_shift(self.this, enable) }
}
#[inline]
pub fn get_shift(&self) -> bool {
unsafe { InputEventWithModifiers_get_shift(self.this) }
}
#[inline]
pub fn set_control(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_control(self.this, enable) }
}
#[inline]
pub fn get_control(&self) -> bool {
unsafe { InputEventWithModifiers_get_control(self.this) }
}
#[inline]
pub fn set_metakey(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_metakey(self.this, enable) }
}
#[inline]
pub fn get_metakey(&self) -> bool {
unsafe { InputEventWithModifiers_get_metakey(self.this) }
}
#[inline]
pub fn set_command(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_command(self.this, enable) }
}
#[inline]
pub fn get_command(&self) -> bool {
unsafe { InputEventWithModifiers_get_command(self.this) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event_with_modifiers(&self) -> InputEventWithModifiers {
unsafe {{ object::add_ref(self.this); }}
InputEventWithModifiers { this: self.this }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventJoypadButton {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventJoypadButton {
fn class_name() -> &'static str {
"InputEventJoypadButton"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventJoypadButton {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventJoypadButton {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventJoypadButtonMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventJoypadButton {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_button_index(&mut self, button_index: i64) -> () {
unsafe { InputEventJoypadButton_set_button_index(self.this, button_index) }
}
#[inline]
pub fn get_button_index(&self) -> i64 {
unsafe { InputEventJoypadButton_get_button_index(self.this) }
}
#[inline]
pub fn set_pressure(&mut self, pressure: f64) -> () {
unsafe { InputEventJoypadButton_set_pressure(self.this, pressure) }
}
#[inline]
pub fn get_pressure(&self) -> f64 {
unsafe { InputEventJoypadButton_get_pressure(self.this) }
}
#[inline]
pub fn set_pressed(&mut self, pressed: bool) -> () {
unsafe { InputEventJoypadButton_set_pressed(self.this, pressed) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventJoypadButton {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventMouseMotion {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventMouseMotion {
fn class_name() -> &'static str {
"InputEventMouseMotion"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventMouseMotion {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventMouseMotion {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventMouseMotionMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventMouseMotion {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_relative(&mut self, relative: Vector2) -> () {
unsafe { InputEventMouseMotion_set_relative(self.this, relative) }
}
#[inline]
pub fn get_relative(&self) -> Vector2 {
unsafe { InputEventMouseMotion_get_relative(self.this) }
}
#[inline]
pub fn set_speed(&mut self, speed: Vector2) -> () {
unsafe { InputEventMouseMotion_set_speed(self.this, speed) }
}
#[inline]
pub fn get_speed(&self) -> Vector2 {
unsafe { InputEventMouseMotion_get_speed(self.this) }
}
#[inline]
pub fn set_button_mask(&mut self, button_mask: i64) -> () {
unsafe { InputEventMouse_set_button_mask(self.this, button_mask) }
}
#[inline]
pub fn get_button_mask(&self) -> i64 {
unsafe { InputEventMouse_get_button_mask(self.this) }
}
#[inline]
pub fn set_position(&mut self, position: Vector2) -> () {
unsafe { InputEventMouse_set_position(self.this, position) }
}
#[inline]
pub fn get_position(&self) -> Vector2 {
unsafe { InputEventMouse_get_position(self.this) }
}
#[inline]
pub fn set_global_position(&mut self, global_position: Vector2) -> () {
unsafe { InputEventMouse_set_global_position(self.this, global_position) }
}
#[inline]
pub fn get_global_position(&self) -> Vector2 {
unsafe { InputEventMouse_get_global_position(self.this) }
}
#[inline]
pub fn set_alt(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_alt(self.this, enable) }
}
#[inline]
pub fn get_alt(&self) -> bool {
unsafe { InputEventWithModifiers_get_alt(self.this) }
}
#[inline]
pub fn set_shift(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_shift(self.this, enable) }
}
#[inline]
pub fn get_shift(&self) -> bool {
unsafe { InputEventWithModifiers_get_shift(self.this) }
}
#[inline]
pub fn set_control(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_control(self.this, enable) }
}
#[inline]
pub fn get_control(&self) -> bool {
unsafe { InputEventWithModifiers_get_control(self.this) }
}
#[inline]
pub fn set_metakey(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_metakey(self.this, enable) }
}
#[inline]
pub fn get_metakey(&self) -> bool {
unsafe { InputEventWithModifiers_get_metakey(self.this) }
}
#[inline]
pub fn set_command(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_command(self.this, enable) }
}
#[inline]
pub fn get_command(&self) -> bool {
unsafe { InputEventWithModifiers_get_command(self.this) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event_mouse(&self) -> InputEventMouse {
unsafe {{ object::add_ref(self.this); }}
InputEventMouse { this: self.this }
}
#[inline]
pub fn to_input_event_with_modifiers(&self) -> InputEventWithModifiers {
unsafe {{ object::add_ref(self.this); }}
InputEventWithModifiers { this: self.this }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventMouseMotion {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventJoypadMotion {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventJoypadMotion {
fn class_name() -> &'static str {
"InputEventJoypadMotion"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventJoypadMotion {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventJoypadMotion {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventJoypadMotionMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventJoypadMotion {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_axis(&mut self, axis: i64) -> () {
unsafe { InputEventJoypadMotion_set_axis(self.this, axis) }
}
#[inline]
pub fn get_axis(&self) -> i64 {
unsafe { InputEventJoypadMotion_get_axis(self.this) }
}
#[inline]
pub fn set_axis_value(&mut self, axis_value: f64) -> () {
unsafe { InputEventJoypadMotion_set_axis_value(self.this, axis_value) }
}
#[inline]
pub fn get_axis_value(&self) -> f64 {
unsafe { InputEventJoypadMotion_get_axis_value(self.this) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventJoypadMotion {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventScreenDrag {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventScreenDrag {
fn class_name() -> &'static str {
"InputEventScreenDrag"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventScreenDrag {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventScreenDrag {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventScreenDragMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventScreenDrag {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_index(&mut self, index: i64) -> () {
unsafe { InputEventScreenDrag_set_index(self.this, index) }
}
#[inline]
pub fn get_index(&self) -> i64 {
unsafe { InputEventScreenDrag_get_index(self.this) }
}
#[inline]
pub fn set_position(&mut self, position: Vector2) -> () {
unsafe { InputEventScreenDrag_set_position(self.this, position) }
}
#[inline]
pub fn get_position(&self) -> Vector2 {
unsafe { InputEventScreenDrag_get_position(self.this) }
}
#[inline]
pub fn set_relative(&mut self, relative: Vector2) -> () {
unsafe { InputEventScreenDrag_set_relative(self.this, relative) }
}
#[inline]
pub fn get_relative(&self) -> Vector2 {
unsafe { InputEventScreenDrag_get_relative(self.this) }
}
#[inline]
pub fn set_speed(&mut self, speed: Vector2) -> () {
unsafe { InputEventScreenDrag_set_speed(self.this, speed) }
}
#[inline]
pub fn get_speed(&self) -> Vector2 {
unsafe { InputEventScreenDrag_get_speed(self.this) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventScreenDrag {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventScreenTouch {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventScreenTouch {
fn class_name() -> &'static str {
"InputEventScreenTouch"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventScreenTouch {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventScreenTouch {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventScreenTouchMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventScreenTouch {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_index(&mut self, index: i64) -> () {
unsafe { InputEventScreenTouch_set_index(self.this, index) }
}
#[inline]
pub fn get_index(&self) -> i64 {
unsafe { InputEventScreenTouch_get_index(self.this) }
}
#[inline]
pub fn set_position(&mut self, position: Vector2) -> () {
unsafe { InputEventScreenTouch_set_position(self.this, position) }
}
#[inline]
pub fn get_position(&self) -> Vector2 {
unsafe { InputEventScreenTouch_get_position(self.this) }
}
#[inline]
pub fn set_pressed(&mut self, pressed: bool) -> () {
unsafe { InputEventScreenTouch_set_pressed(self.this, pressed) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventScreenTouch {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventMagnifyGesture {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventMagnifyGesture {
fn class_name() -> &'static str {
"InputEventMagnifyGesture"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventMagnifyGesture {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventMagnifyGesture {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventMagnifyGestureMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventMagnifyGesture {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_factor(&mut self, factor: f64) -> () {
unsafe { InputEventMagnifyGesture_set_factor(self.this, factor) }
}
#[inline]
pub fn get_factor(&self) -> f64 {
unsafe { InputEventMagnifyGesture_get_factor(self.this) }
}
#[inline]
pub fn set_position(&mut self, position: Vector2) -> () {
unsafe { InputEventGesture_set_position(self.this, position) }
}
#[inline]
pub fn get_position(&self) -> Vector2 {
unsafe { InputEventGesture_get_position(self.this) }
}
#[inline]
pub fn set_alt(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_alt(self.this, enable) }
}
#[inline]
pub fn get_alt(&self) -> bool {
unsafe { InputEventWithModifiers_get_alt(self.this) }
}
#[inline]
pub fn set_shift(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_shift(self.this, enable) }
}
#[inline]
pub fn get_shift(&self) -> bool {
unsafe { InputEventWithModifiers_get_shift(self.this) }
}
#[inline]
pub fn set_control(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_control(self.this, enable) }
}
#[inline]
pub fn get_control(&self) -> bool {
unsafe { InputEventWithModifiers_get_control(self.this) }
}
#[inline]
pub fn set_metakey(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_metakey(self.this, enable) }
}
#[inline]
pub fn get_metakey(&self) -> bool {
unsafe { InputEventWithModifiers_get_metakey(self.this) }
}
#[inline]
pub fn set_command(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_command(self.this, enable) }
}
#[inline]
pub fn get_command(&self) -> bool {
unsafe { InputEventWithModifiers_get_command(self.this) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event_gesture(&self) -> InputEventGesture {
unsafe {{ object::add_ref(self.this); }}
InputEventGesture { this: self.this }
}
#[inline]
pub fn to_input_event_with_modifiers(&self) -> InputEventWithModifiers {
unsafe {{ object::add_ref(self.this); }}
InputEventWithModifiers { this: self.this }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventMagnifyGesture {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventGesture {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventGesture {
fn class_name() -> &'static str {
"InputEventGesture"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventGesture {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventGesture {
#[inline]
pub fn set_position(&mut self, position: Vector2) -> () {
unsafe { InputEventGesture_set_position(self.this, position) }
}
#[inline]
pub fn get_position(&self) -> Vector2 {
unsafe { InputEventGesture_get_position(self.this) }
}
#[inline]
pub fn set_alt(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_alt(self.this, enable) }
}
#[inline]
pub fn get_alt(&self) -> bool {
unsafe { InputEventWithModifiers_get_alt(self.this) }
}
#[inline]
pub fn set_shift(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_shift(self.this, enable) }
}
#[inline]
pub fn get_shift(&self) -> bool {
unsafe { InputEventWithModifiers_get_shift(self.this) }
}
#[inline]
pub fn set_control(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_control(self.this, enable) }
}
#[inline]
pub fn get_control(&self) -> bool {
unsafe { InputEventWithModifiers_get_control(self.this) }
}
#[inline]
pub fn set_metakey(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_metakey(self.this, enable) }
}
#[inline]
pub fn get_metakey(&self) -> bool {
unsafe { InputEventWithModifiers_get_metakey(self.this) }
}
#[inline]
pub fn set_command(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_command(self.this, enable) }
}
#[inline]
pub fn get_command(&self) -> bool {
unsafe { InputEventWithModifiers_get_command(self.this) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event_with_modifiers(&self) -> InputEventWithModifiers {
unsafe {{ object::add_ref(self.this); }}
InputEventWithModifiers { this: self.this }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventPanGesture {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventPanGesture {
fn class_name() -> &'static str {
"InputEventPanGesture"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventPanGesture {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventPanGesture {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventPanGestureMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventPanGesture {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_delta(&mut self, delta: Vector2) -> () {
unsafe { InputEventPanGesture_set_delta(self.this, delta) }
}
#[inline]
pub fn get_delta(&self) -> Vector2 {
unsafe { InputEventPanGesture_get_delta(self.this) }
}
#[inline]
pub fn set_position(&mut self, position: Vector2) -> () {
unsafe { InputEventGesture_set_position(self.this, position) }
}
#[inline]
pub fn get_position(&self) -> Vector2 {
unsafe { InputEventGesture_get_position(self.this) }
}
#[inline]
pub fn set_alt(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_alt(self.this, enable) }
}
#[inline]
pub fn get_alt(&self) -> bool {
unsafe { InputEventWithModifiers_get_alt(self.this) }
}
#[inline]
pub fn set_shift(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_shift(self.this, enable) }
}
#[inline]
pub fn get_shift(&self) -> bool {
unsafe { InputEventWithModifiers_get_shift(self.this) }
}
#[inline]
pub fn set_control(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_control(self.this, enable) }
}
#[inline]
pub fn get_control(&self) -> bool {
unsafe { InputEventWithModifiers_get_control(self.this) }
}
#[inline]
pub fn set_metakey(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_metakey(self.this, enable) }
}
#[inline]
pub fn get_metakey(&self) -> bool {
unsafe { InputEventWithModifiers_get_metakey(self.this) }
}
#[inline]
pub fn set_command(&mut self, enable: bool) -> () {
unsafe { InputEventWithModifiers_set_command(self.this, enable) }
}
#[inline]
pub fn get_command(&self) -> bool {
unsafe { InputEventWithModifiers_get_command(self.this) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event_gesture(&self) -> InputEventGesture {
unsafe {{ object::add_ref(self.this); }}
InputEventGesture { this: self.this }
}
#[inline]
pub fn to_input_event_with_modifiers(&self) -> InputEventWithModifiers {
unsafe {{ object::add_ref(self.this); }}
InputEventWithModifiers { this: self.this }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventPanGesture {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[allow(non_camel_case_types)]
#[derive(Debug)]
pub struct InputEventAction {
#[doc(hidden)]
pub this: *mut sys::godot_object,
}
unsafe impl GodotObject for InputEventAction {
fn class_name() -> &'static str {
"InputEventAction"
}
unsafe fn from_sys(obj: *mut sys::godot_object) -> Self {
object::add_ref(obj);
Self { this: obj, }
}
unsafe fn to_sys(&self) -> *mut sys::godot_object {
self.this
}
}
impl ToVariant for InputEventAction {
fn to_variant(&self) -> Variant { Variant::from_object(self) }
fn from_variant(variant: &Variant) -> Option<Self> { variant.try_to_object::<Self>() }
}
impl InputEventAction {
pub fn new() -> Self {
unsafe {
let gd_api = get_api();
let ctor = InputEventActionMethodTable::get(gd_api).class_constructor.unwrap();
let obj = ctor();
object::init_ref_count(obj);
InputEventAction {
this: obj
}
}
}
pub fn new_ref(&self) -> Self {
unsafe {
object::add_ref(self.this);
Self {
this: self.this,
}
}
}
#[inline]
pub fn set_action(&mut self, action: GodotString) -> () {
unsafe { InputEventAction_set_action(self.this, action) }
}
#[inline]
pub fn get_action(&self) -> GodotString {
unsafe { InputEventAction_get_action(self.this) }
}
#[inline]
pub fn set_pressed(&mut self, pressed: bool) -> () {
unsafe { InputEventAction_set_pressed(self.this, pressed) }
}
#[inline]
pub fn set_device(&mut self, device: i64) -> () {
unsafe { InputEvent_set_device(self.this, device) }
}
#[inline]
pub fn get_device(&self) -> i64 {
unsafe { InputEvent_get_device(self.this) }
}
#[inline]
pub fn is_action(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action(self.this, action) }
}
#[inline]
pub fn is_action_pressed(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_pressed(self.this, action) }
}
#[inline]
pub fn is_action_released(&self, action: GodotString) -> bool {
unsafe { InputEvent_is_action_released(self.this, action) }
}
#[inline]
pub fn get_action_strength(&self, action: GodotString) -> f64 {
unsafe { InputEvent_get_action_strength(self.this, action) }
}
#[inline]
pub fn is_pressed(&self) -> bool {
unsafe { InputEvent_is_pressed(self.this) }
}
#[inline]
pub fn is_echo(&self) -> bool {
unsafe { InputEvent_is_echo(self.this) }
}
#[inline]
pub fn as_text(&self) -> GodotString {
unsafe { InputEvent_as_text(self.this) }
}
#[inline]
pub fn shortcut_match(&self, event: Option<InputEvent>) -> bool {
unsafe { InputEvent_shortcut_match(self.this, event) }
}
#[inline]
pub fn is_action_type(&self) -> bool {
unsafe { InputEvent_is_action_type(self.this) }
}
#[inline]
pub fn xformed_by(&self, xform: Transform2D, local_ofs: Vector2) -> Option<InputEvent> {
unsafe { InputEvent_xformed_by(self.this, xform, local_ofs) }
}
#[inline]
pub fn _setup_local_to_scene(&mut self) -> () {
unsafe { Resource__setup_local_to_scene(self.this) }
}
#[inline]
pub fn set_path(&mut self, path: GodotString) -> () {
unsafe { Resource_set_path(self.this, path) }
}
#[inline]
pub fn take_over_path(&mut self, path: GodotString) -> () {
unsafe { Resource_take_over_path(self.this, path) }
}
#[inline]
pub fn get_path(&self) -> GodotString {
unsafe { Resource_get_path(self.this) }
}
#[inline]
pub fn set_name(&mut self, name: GodotString) -> () {
unsafe { Resource_set_name(self.this, name) }
}
#[inline]
pub fn get_name(&self) -> GodotString {
unsafe { Resource_get_name(self.this) }
}
#[inline]
pub fn get_rid(&self) -> Rid {
unsafe { Resource_get_rid(self.this) }
}
#[inline]
pub fn set_local_to_scene(&mut self, enable: bool) -> () {
unsafe { Resource_set_local_to_scene(self.this, enable) }
}
#[inline]
pub fn is_local_to_scene(&self) -> bool {
unsafe { Resource_is_local_to_scene(self.this) }
}
#[inline]
pub fn get_local_scene(&self) -> Option<Node> {
unsafe { Resource_get_local_scene(self.this) }
}
#[inline]
pub fn setup_local_to_scene(&mut self) -> () {
unsafe { Resource_setup_local_to_scene(self.this) }
}
#[inline]
pub fn duplicate(&self, subresources: bool) -> Option<Resource> {
unsafe { Resource_duplicate(self.this, subresources) }
}
#[inline]
pub fn init_ref(&mut self) -> bool {
unsafe { Reference_init_ref(self.this) }
}
#[inline]
pub fn _notification(&mut self, what: i64) -> () {
unsafe { Object__notification(self.this, what) }
}
#[inline]
pub fn _set(&mut self, property: GodotString, value: Variant) -> bool {
unsafe { Object__set(self.this, property, value) }
}
#[inline]
pub fn _get(&mut self, property: GodotString) -> Variant {
unsafe { Object__get(self.this, property) }
}
#[inline]
pub fn _get_property_list(&mut self) -> VariantArray {
unsafe { Object__get_property_list(self.this) }
}
#[inline]
pub fn _init(&mut self) -> () {
unsafe { Object__init(self.this) }
}
#[inline]
pub fn get_class(&self) -> GodotString {
unsafe { Object_get_class(self.this) }
}
#[inline]
pub fn is_class(&self, _type: GodotString) -> bool {
unsafe { Object_is_class(self.this, _type) }
}
#[inline]
pub fn set(&mut self, property: GodotString, value: Variant) -> () {
unsafe { Object_set(self.this, property, value) }
}
#[inline]
pub fn get(&self, property: GodotString) -> Variant {
unsafe { Object_get(self.this, property) }
}
#[inline]
pub fn set_indexed(&mut self, property: NodePath, value: Variant) -> () {
unsafe { Object_set_indexed(self.this, property, value) }
}
#[inline]
pub fn get_indexed(&self, property: NodePath) -> Variant {
unsafe { Object_get_indexed(self.this, property) }
}
#[inline]
pub fn get_property_list(&self) -> VariantArray {
unsafe { Object_get_property_list(self.this) }
}
#[inline]
pub fn get_method_list(&self) -> VariantArray {
unsafe { Object_get_method_list(self.this) }
}
#[inline]
pub fn notification(&mut self, what: i64, reversed: bool) -> () {
unsafe { Object_notification(self.this, what, reversed) }
}
#[inline]
pub fn get_instance_id(&self) -> i64 {
unsafe { Object_get_instance_id(self.this) }
}
#[inline]
pub fn set_script(&mut self, script: Option<Reference>) -> () {
unsafe { Object_set_script(self.this, script) }
}
#[inline]
pub fn get_script(&self) -> Option<Reference> {
unsafe { Object_get_script(self.this) }
}
#[inline]
pub fn set_meta(&mut self, name: GodotString, value: Variant) -> () {
unsafe { Object_set_meta(self.this, name, value) }
}
#[inline]
pub fn get_meta(&self, name: GodotString) -> Variant {
unsafe { Object_get_meta(self.this, name) }
}
#[inline]
pub fn has_meta(&self, name: GodotString) -> bool {
unsafe { Object_has_meta(self.this, name) }
}
#[inline]
pub fn get_meta_list(&self) -> StringArray {
unsafe { Object_get_meta_list(self.this) }
}
#[inline]
pub fn add_user_signal(&mut self, signal: GodotString, arguments: VariantArray) -> () {
unsafe { Object_add_user_signal(self.this, signal, arguments) }
}
#[inline]
pub fn has_user_signal(&self, signal: GodotString) -> bool {
unsafe { Object_has_user_signal(self.this, signal) }
}
#[inline]
pub fn emit_signal(&mut self, signal: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_emit_signal(self.this, signal, varargs) }
}
#[inline]
pub fn call(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call(self.this, method, varargs) }
}
#[inline]
pub fn call_deferred(&mut self, method: GodotString, varargs: &[Variant]) -> Variant {
unsafe { Object_call_deferred(self.this, method, varargs) }
}
#[inline]
pub fn callv(&mut self, method: GodotString, arg_array: VariantArray) -> Variant {
unsafe { Object_callv(self.this, method, arg_array) }
}
#[inline]
pub fn has_method(&self, method: GodotString) -> bool {
unsafe { Object_has_method(self.this, method) }
}
#[inline]
pub fn get_signal_list(&self) -> VariantArray {
unsafe { Object_get_signal_list(self.this) }
}
#[inline]
pub fn get_signal_connection_list(&self, signal: GodotString) -> VariantArray {
unsafe { Object_get_signal_connection_list(self.this, signal) }
}
#[inline]
pub fn get_incoming_connections(&self) -> VariantArray {
unsafe { Object_get_incoming_connections(self.this) }
}
#[inline]
pub fn connect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString, binds: VariantArray, flags: i64) -> GodotResult {
unsafe { Object_connect(self.this, signal, target, method, binds, flags) }
}
#[inline]
pub fn disconnect(&mut self, signal: GodotString, target: Option<Object>, method: GodotString) -> () {
unsafe { Object_disconnect(self.this, signal, target, method) }
}
#[inline]
pub fn is_connected(&self, signal: GodotString, target: Option<Object>, method: GodotString) -> bool {
unsafe { Object_is_connected(self.this, signal, target, method) }
}
#[inline]
pub fn set_block_signals(&mut self, enable: bool) -> () {
unsafe { Object_set_block_signals(self.this, enable) }
}
#[inline]
pub fn is_blocking_signals(&self) -> bool {
unsafe { Object_is_blocking_signals(self.this) }
}
#[inline]
pub fn property_list_changed_notify(&mut self) -> () {
unsafe { Object_property_list_changed_notify(self.this) }
}
#[inline]
pub fn set_message_translation(&mut self, enable: bool) -> () {
unsafe { Object_set_message_translation(self.this, enable) }
}
#[inline]
pub fn can_translate_messages(&self) -> bool {
unsafe { Object_can_translate_messages(self.this) }
}
#[inline]
pub fn tr(&self, message: GodotString) -> GodotString {
unsafe { Object_tr(self.this, message) }
}
#[inline]
pub fn is_queued_for_deletion(&self) -> bool {
unsafe { Object_is_queued_for_deletion(self.this) }
}
#[inline]
pub fn to_input_event(&self) -> InputEvent {
unsafe {{ object::add_ref(self.this); }}
InputEvent { this: self.this }
}
#[inline]
pub fn to_resource(&self) -> Resource {
unsafe {{ object::add_ref(self.this); }}
Resource { this: self.this }
}
#[inline]
pub fn to_reference(&self) -> Reference {
unsafe {{ object::add_ref(self.this); }}
Reference { this: self.this }
}
#[inline]
pub fn to_object(&self) -> Object {
Object { this: self.this }
}
pub fn cast<T: GodotObject>(&self) -> Option<T> {
object::godot_cast::<T>(self.this)
}
}
impl Drop for InputEventAction {
fn drop(&mut self) {
unsafe {
if object::unref(self.this) {
(get_api().godot_object_destroy)(self.this);
}
}
}
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventMouseButtonMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_factor: *mut sys::godot_method_bind,
pub get_factor: *mut sys::godot_method_bind,
pub set_button_index: *mut sys::godot_method_bind,
pub get_button_index: *mut sys::godot_method_bind,
pub set_pressed: *mut sys::godot_method_bind,
pub set_doubleclick: *mut sys::godot_method_bind,
pub is_doubleclick: *mut sys::godot_method_bind,
}
impl InputEventMouseButtonMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventMouseButtonMethodTable = InputEventMouseButtonMethodTable {
class_constructor: None,
set_factor: 0 as *mut sys::godot_method_bind,
get_factor: 0 as *mut sys::godot_method_bind,
set_button_index: 0 as *mut sys::godot_method_bind,
get_button_index: 0 as *mut sys::godot_method_bind,
set_pressed: 0 as *mut sys::godot_method_bind,
set_doubleclick: 0 as *mut sys::godot_method_bind,
is_doubleclick: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventMouseButtonMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventMouseButton\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_factor = (gd_api.godot_method_bind_get_method)(class_name, "set_factor\0".as_ptr() as *const c_char );
table.get_factor = (gd_api.godot_method_bind_get_method)(class_name, "get_factor\0".as_ptr() as *const c_char );
table.set_button_index = (gd_api.godot_method_bind_get_method)(class_name, "set_button_index\0".as_ptr() as *const c_char );
table.get_button_index = (gd_api.godot_method_bind_get_method)(class_name, "get_button_index\0".as_ptr() as *const c_char );
table.set_pressed = (gd_api.godot_method_bind_get_method)(class_name, "set_pressed\0".as_ptr() as *const c_char );
table.set_doubleclick = (gd_api.godot_method_bind_get_method)(class_name, "set_doubleclick\0".as_ptr() as *const c_char );
table.is_doubleclick = (gd_api.godot_method_bind_get_method)(class_name, "is_doubleclick\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventMouseButton_set_factor(obj_ptr: *mut sys::godot_object, factor: f64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseButtonMethodTable::get(gd_api).set_factor;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&factor) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouseButton_get_factor(obj_ptr: *mut sys::godot_object) -> f64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseButtonMethodTable::get(gd_api).get_factor;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0.0f64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
pub unsafe fn InputEventMouseButton_set_button_index(obj_ptr: *mut sys::godot_object, button_index: i64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseButtonMethodTable::get(gd_api).set_button_index;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&button_index) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouseButton_get_button_index(obj_ptr: *mut sys::godot_object) -> i64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseButtonMethodTable::get(gd_api).get_button_index;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0i64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
pub unsafe fn InputEventMouseButton_set_pressed(obj_ptr: *mut sys::godot_object, pressed: bool) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseButtonMethodTable::get(gd_api).set_pressed;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&pressed) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouseButton_set_doubleclick(obj_ptr: *mut sys::godot_object, doubleclick: bool) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseButtonMethodTable::get(gd_api).set_doubleclick;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&doubleclick) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouseButton_is_doubleclick(obj_ptr: *mut sys::godot_object) -> bool {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseButtonMethodTable::get(gd_api).is_doubleclick;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = false;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventMouseMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_button_mask: *mut sys::godot_method_bind,
pub get_button_mask: *mut sys::godot_method_bind,
pub set_position: *mut sys::godot_method_bind,
pub get_position: *mut sys::godot_method_bind,
pub set_global_position: *mut sys::godot_method_bind,
pub get_global_position: *mut sys::godot_method_bind,
}
impl InputEventMouseMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventMouseMethodTable = InputEventMouseMethodTable {
class_constructor: None,
set_button_mask: 0 as *mut sys::godot_method_bind,
get_button_mask: 0 as *mut sys::godot_method_bind,
set_position: 0 as *mut sys::godot_method_bind,
get_position: 0 as *mut sys::godot_method_bind,
set_global_position: 0 as *mut sys::godot_method_bind,
get_global_position: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventMouseMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventMouse\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_button_mask = (gd_api.godot_method_bind_get_method)(class_name, "set_button_mask\0".as_ptr() as *const c_char );
table.get_button_mask = (gd_api.godot_method_bind_get_method)(class_name, "get_button_mask\0".as_ptr() as *const c_char );
table.set_position = (gd_api.godot_method_bind_get_method)(class_name, "set_position\0".as_ptr() as *const c_char );
table.get_position = (gd_api.godot_method_bind_get_method)(class_name, "get_position\0".as_ptr() as *const c_char );
table.set_global_position = (gd_api.godot_method_bind_get_method)(class_name, "set_global_position\0".as_ptr() as *const c_char );
table.get_global_position = (gd_api.godot_method_bind_get_method)(class_name, "get_global_position\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventMouse_set_button_mask(obj_ptr: *mut sys::godot_object, button_mask: i64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMethodTable::get(gd_api).set_button_mask;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&button_mask) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouse_get_button_mask(obj_ptr: *mut sys::godot_object) -> i64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMethodTable::get(gd_api).get_button_mask;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0i64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
pub unsafe fn InputEventMouse_set_position(obj_ptr: *mut sys::godot_object, position: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMethodTable::get(gd_api).set_position;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&position) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouse_get_position(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMethodTable::get(gd_api).get_position;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
pub unsafe fn InputEventMouse_set_global_position(obj_ptr: *mut sys::godot_object, global_position: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMethodTable::get(gd_api).set_global_position;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&global_position) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouse_get_global_position(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMethodTable::get(gd_api).get_global_position;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventJoypadButtonMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_button_index: *mut sys::godot_method_bind,
pub get_button_index: *mut sys::godot_method_bind,
pub set_pressure: *mut sys::godot_method_bind,
pub get_pressure: *mut sys::godot_method_bind,
pub set_pressed: *mut sys::godot_method_bind,
}
impl InputEventJoypadButtonMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventJoypadButtonMethodTable = InputEventJoypadButtonMethodTable {
class_constructor: None,
set_button_index: 0 as *mut sys::godot_method_bind,
get_button_index: 0 as *mut sys::godot_method_bind,
set_pressure: 0 as *mut sys::godot_method_bind,
get_pressure: 0 as *mut sys::godot_method_bind,
set_pressed: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventJoypadButtonMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventJoypadButton\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_button_index = (gd_api.godot_method_bind_get_method)(class_name, "set_button_index\0".as_ptr() as *const c_char );
table.get_button_index = (gd_api.godot_method_bind_get_method)(class_name, "get_button_index\0".as_ptr() as *const c_char );
table.set_pressure = (gd_api.godot_method_bind_get_method)(class_name, "set_pressure\0".as_ptr() as *const c_char );
table.get_pressure = (gd_api.godot_method_bind_get_method)(class_name, "get_pressure\0".as_ptr() as *const c_char );
table.set_pressed = (gd_api.godot_method_bind_get_method)(class_name, "set_pressed\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadButton_set_button_index(obj_ptr: *mut sys::godot_object, button_index: i64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadButtonMethodTable::get(gd_api).set_button_index;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&button_index) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadButton_get_button_index(obj_ptr: *mut sys::godot_object) -> i64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadButtonMethodTable::get(gd_api).get_button_index;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0i64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadButton_set_pressure(obj_ptr: *mut sys::godot_object, pressure: f64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadButtonMethodTable::get(gd_api).set_pressure;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&pressure) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadButton_get_pressure(obj_ptr: *mut sys::godot_object) -> f64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadButtonMethodTable::get(gd_api).get_pressure;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0.0f64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadButton_set_pressed(obj_ptr: *mut sys::godot_object, pressed: bool) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadButtonMethodTable::get(gd_api).set_pressed;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&pressed) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventMouseMotionMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_relative: *mut sys::godot_method_bind,
pub get_relative: *mut sys::godot_method_bind,
pub set_speed: *mut sys::godot_method_bind,
pub get_speed: *mut sys::godot_method_bind,
}
impl InputEventMouseMotionMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventMouseMotionMethodTable = InputEventMouseMotionMethodTable {
class_constructor: None,
set_relative: 0 as *mut sys::godot_method_bind,
get_relative: 0 as *mut sys::godot_method_bind,
set_speed: 0 as *mut sys::godot_method_bind,
get_speed: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventMouseMotionMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventMouseMotion\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_relative = (gd_api.godot_method_bind_get_method)(class_name, "set_relative\0".as_ptr() as *const c_char );
table.get_relative = (gd_api.godot_method_bind_get_method)(class_name, "get_relative\0".as_ptr() as *const c_char );
table.set_speed = (gd_api.godot_method_bind_get_method)(class_name, "set_speed\0".as_ptr() as *const c_char );
table.get_speed = (gd_api.godot_method_bind_get_method)(class_name, "get_speed\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventMouseMotion_set_relative(obj_ptr: *mut sys::godot_object, relative: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMotionMethodTable::get(gd_api).set_relative;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&relative) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouseMotion_get_relative(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMotionMethodTable::get(gd_api).get_relative;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
pub unsafe fn InputEventMouseMotion_set_speed(obj_ptr: *mut sys::godot_object, speed: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMotionMethodTable::get(gd_api).set_speed;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&speed) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMouseMotion_get_speed(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMouseMotionMethodTable::get(gd_api).get_speed;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventJoypadMotionMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_axis: *mut sys::godot_method_bind,
pub get_axis: *mut sys::godot_method_bind,
pub set_axis_value: *mut sys::godot_method_bind,
pub get_axis_value: *mut sys::godot_method_bind,
}
impl InputEventJoypadMotionMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventJoypadMotionMethodTable = InputEventJoypadMotionMethodTable {
class_constructor: None,
set_axis: 0 as *mut sys::godot_method_bind,
get_axis: 0 as *mut sys::godot_method_bind,
set_axis_value: 0 as *mut sys::godot_method_bind,
get_axis_value: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventJoypadMotionMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventJoypadMotion\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_axis = (gd_api.godot_method_bind_get_method)(class_name, "set_axis\0".as_ptr() as *const c_char );
table.get_axis = (gd_api.godot_method_bind_get_method)(class_name, "get_axis\0".as_ptr() as *const c_char );
table.set_axis_value = (gd_api.godot_method_bind_get_method)(class_name, "set_axis_value\0".as_ptr() as *const c_char );
table.get_axis_value = (gd_api.godot_method_bind_get_method)(class_name, "get_axis_value\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadMotion_set_axis(obj_ptr: *mut sys::godot_object, axis: i64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadMotionMethodTable::get(gd_api).set_axis;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&axis) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadMotion_get_axis(obj_ptr: *mut sys::godot_object) -> i64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadMotionMethodTable::get(gd_api).get_axis;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0i64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadMotion_set_axis_value(obj_ptr: *mut sys::godot_object, axis_value: f64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadMotionMethodTable::get(gd_api).set_axis_value;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&axis_value) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventJoypadMotion_get_axis_value(obj_ptr: *mut sys::godot_object) -> f64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventJoypadMotionMethodTable::get(gd_api).get_axis_value;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0.0f64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventScreenDragMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_index: *mut sys::godot_method_bind,
pub get_index: *mut sys::godot_method_bind,
pub set_position: *mut sys::godot_method_bind,
pub get_position: *mut sys::godot_method_bind,
pub set_relative: *mut sys::godot_method_bind,
pub get_relative: *mut sys::godot_method_bind,
pub set_speed: *mut sys::godot_method_bind,
pub get_speed: *mut sys::godot_method_bind,
}
impl InputEventScreenDragMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventScreenDragMethodTable = InputEventScreenDragMethodTable {
class_constructor: None,
set_index: 0 as *mut sys::godot_method_bind,
get_index: 0 as *mut sys::godot_method_bind,
set_position: 0 as *mut sys::godot_method_bind,
get_position: 0 as *mut sys::godot_method_bind,
set_relative: 0 as *mut sys::godot_method_bind,
get_relative: 0 as *mut sys::godot_method_bind,
set_speed: 0 as *mut sys::godot_method_bind,
get_speed: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventScreenDragMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventScreenDrag\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_index = (gd_api.godot_method_bind_get_method)(class_name, "set_index\0".as_ptr() as *const c_char );
table.get_index = (gd_api.godot_method_bind_get_method)(class_name, "get_index\0".as_ptr() as *const c_char );
table.set_position = (gd_api.godot_method_bind_get_method)(class_name, "set_position\0".as_ptr() as *const c_char );
table.get_position = (gd_api.godot_method_bind_get_method)(class_name, "get_position\0".as_ptr() as *const c_char );
table.set_relative = (gd_api.godot_method_bind_get_method)(class_name, "set_relative\0".as_ptr() as *const c_char );
table.get_relative = (gd_api.godot_method_bind_get_method)(class_name, "get_relative\0".as_ptr() as *const c_char );
table.set_speed = (gd_api.godot_method_bind_get_method)(class_name, "set_speed\0".as_ptr() as *const c_char );
table.get_speed = (gd_api.godot_method_bind_get_method)(class_name, "get_speed\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventScreenDrag_set_index(obj_ptr: *mut sys::godot_object, index: i64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenDragMethodTable::get(gd_api).set_index;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&index) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventScreenDrag_get_index(obj_ptr: *mut sys::godot_object) -> i64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenDragMethodTable::get(gd_api).get_index;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0i64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
pub unsafe fn InputEventScreenDrag_set_position(obj_ptr: *mut sys::godot_object, position: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenDragMethodTable::get(gd_api).set_position;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&position) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventScreenDrag_get_position(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenDragMethodTable::get(gd_api).get_position;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
pub unsafe fn InputEventScreenDrag_set_relative(obj_ptr: *mut sys::godot_object, relative: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenDragMethodTable::get(gd_api).set_relative;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&relative) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventScreenDrag_get_relative(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenDragMethodTable::get(gd_api).get_relative;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
pub unsafe fn InputEventScreenDrag_set_speed(obj_ptr: *mut sys::godot_object, speed: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenDragMethodTable::get(gd_api).set_speed;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&speed) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventScreenDrag_get_speed(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenDragMethodTable::get(gd_api).get_speed;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventScreenTouchMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_index: *mut sys::godot_method_bind,
pub get_index: *mut sys::godot_method_bind,
pub set_position: *mut sys::godot_method_bind,
pub get_position: *mut sys::godot_method_bind,
pub set_pressed: *mut sys::godot_method_bind,
}
impl InputEventScreenTouchMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventScreenTouchMethodTable = InputEventScreenTouchMethodTable {
class_constructor: None,
set_index: 0 as *mut sys::godot_method_bind,
get_index: 0 as *mut sys::godot_method_bind,
set_position: 0 as *mut sys::godot_method_bind,
get_position: 0 as *mut sys::godot_method_bind,
set_pressed: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventScreenTouchMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventScreenTouch\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_index = (gd_api.godot_method_bind_get_method)(class_name, "set_index\0".as_ptr() as *const c_char );
table.get_index = (gd_api.godot_method_bind_get_method)(class_name, "get_index\0".as_ptr() as *const c_char );
table.set_position = (gd_api.godot_method_bind_get_method)(class_name, "set_position\0".as_ptr() as *const c_char );
table.get_position = (gd_api.godot_method_bind_get_method)(class_name, "get_position\0".as_ptr() as *const c_char );
table.set_pressed = (gd_api.godot_method_bind_get_method)(class_name, "set_pressed\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventScreenTouch_set_index(obj_ptr: *mut sys::godot_object, index: i64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenTouchMethodTable::get(gd_api).set_index;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&index) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventScreenTouch_get_index(obj_ptr: *mut sys::godot_object) -> i64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenTouchMethodTable::get(gd_api).get_index;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0i64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
pub unsafe fn InputEventScreenTouch_set_position(obj_ptr: *mut sys::godot_object, position: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenTouchMethodTable::get(gd_api).set_position;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&position) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventScreenTouch_get_position(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenTouchMethodTable::get(gd_api).get_position;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
pub unsafe fn InputEventScreenTouch_set_pressed(obj_ptr: *mut sys::godot_object, pressed: bool) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventScreenTouchMethodTable::get(gd_api).set_pressed;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&pressed) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventMagnifyGestureMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_factor: *mut sys::godot_method_bind,
pub get_factor: *mut sys::godot_method_bind,
}
impl InputEventMagnifyGestureMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventMagnifyGestureMethodTable = InputEventMagnifyGestureMethodTable {
class_constructor: None,
set_factor: 0 as *mut sys::godot_method_bind,
get_factor: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventMagnifyGestureMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventMagnifyGesture\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_factor = (gd_api.godot_method_bind_get_method)(class_name, "set_factor\0".as_ptr() as *const c_char );
table.get_factor = (gd_api.godot_method_bind_get_method)(class_name, "get_factor\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventMagnifyGesture_set_factor(obj_ptr: *mut sys::godot_object, factor: f64) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMagnifyGestureMethodTable::get(gd_api).set_factor;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&factor) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventMagnifyGesture_get_factor(obj_ptr: *mut sys::godot_object) -> f64 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventMagnifyGestureMethodTable::get(gd_api).get_factor;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = 0.0f64;
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
ret
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventGestureMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_position: *mut sys::godot_method_bind,
pub get_position: *mut sys::godot_method_bind,
}
impl InputEventGestureMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventGestureMethodTable = InputEventGestureMethodTable {
class_constructor: None,
set_position: 0 as *mut sys::godot_method_bind,
get_position: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventGestureMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventGesture\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_position = (gd_api.godot_method_bind_get_method)(class_name, "set_position\0".as_ptr() as *const c_char );
table.get_position = (gd_api.godot_method_bind_get_method)(class_name, "get_position\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventGesture_set_position(obj_ptr: *mut sys::godot_object, position: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventGestureMethodTable::get(gd_api).set_position;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&position) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventGesture_get_position(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventGestureMethodTable::get(gd_api).get_position;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventPanGestureMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_delta: *mut sys::godot_method_bind,
pub get_delta: *mut sys::godot_method_bind,
}
impl InputEventPanGestureMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventPanGestureMethodTable = InputEventPanGestureMethodTable {
class_constructor: None,
set_delta: 0 as *mut sys::godot_method_bind,
get_delta: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventPanGestureMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventPanGesture\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_delta = (gd_api.godot_method_bind_get_method)(class_name, "set_delta\0".as_ptr() as *const c_char );
table.get_delta = (gd_api.godot_method_bind_get_method)(class_name, "get_delta\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventPanGesture_set_delta(obj_ptr: *mut sys::godot_object, delta: Vector2) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventPanGestureMethodTable::get(gd_api).set_delta;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&delta) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventPanGesture_get_delta(obj_ptr: *mut sys::godot_object) -> Vector2 {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventPanGestureMethodTable::get(gd_api).get_delta;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_vector2::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
mem::transmute(ret)
}
#[doc(hidden)]
#[allow(non_camel_case_types)]
pub struct InputEventActionMethodTable {
pub class_constructor: sys::godot_class_constructor,
pub set_action: *mut sys::godot_method_bind,
pub get_action: *mut sys::godot_method_bind,
pub set_pressed: *mut sys::godot_method_bind,
}
impl InputEventActionMethodTable {
unsafe fn get_mut() -> &'static mut Self {
static mut TABLE: InputEventActionMethodTable = InputEventActionMethodTable {
class_constructor: None,
set_action: 0 as *mut sys::godot_method_bind,
get_action: 0 as *mut sys::godot_method_bind,
set_pressed: 0 as *mut sys::godot_method_bind,
};
&mut TABLE
}
pub unsafe fn unchecked_get() -> &'static Self {
Self::get_mut()
}
pub fn get(gd_api: &GodotApi) -> &'static Self {
unsafe {
let table = Self::get_mut();
static INIT: Once = ONCE_INIT;
INIT.call_once(|| {
InputEventActionMethodTable::init(table, gd_api);
});
table
}
}
#[inline(never)]
fn init(table: &mut Self, gd_api: &GodotApi) {
unsafe {
let class_name = b"InputEventAction\0".as_ptr() as *const c_char;
table.class_constructor = (gd_api.godot_get_class_constructor)(class_name);
table.set_action = (gd_api.godot_method_bind_get_method)(class_name, "set_action\0".as_ptr() as *const c_char );
table.get_action = (gd_api.godot_method_bind_get_method)(class_name, "get_action\0".as_ptr() as *const c_char );
table.set_pressed = (gd_api.godot_method_bind_get_method)(class_name, "set_pressed\0".as_ptr() as *const c_char );
}
}
}
#[doc(hidden)]
pub unsafe fn InputEventAction_set_action(obj_ptr: *mut sys::godot_object, action: GodotString) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventActionMethodTable::get(gd_api).set_action;
let mut argument_buffer : [*const libc::c_void; 1] = [
action.sys() as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}
#[doc(hidden)]
pub unsafe fn InputEventAction_get_action(obj_ptr: *mut sys::godot_object) -> GodotString {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventActionMethodTable::get(gd_api).get_action;
let mut argument_buffer : [*const libc::c_void; 0] = [
];
let mut ret = sys::godot_string::default();
let ret_ptr = &mut ret as *mut _;
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
GodotString::from_sys(ret)
}
#[doc(hidden)]
pub unsafe fn InputEventAction_set_pressed(obj_ptr: *mut sys::godot_object, pressed: bool) -> () {
let gd_api = get_api();
let method_bind: *mut sys::godot_method_bind = InputEventActionMethodTable::get(gd_api).set_pressed;
let mut argument_buffer : [*const libc::c_void; 1] = [
(&pressed) as *const _ as *const _,
];
let ret_ptr = ptr::null_mut();
(gd_api.godot_method_bind_ptrcall)(method_bind, obj_ptr, argument_buffer.as_mut_ptr() as *mut _, ret_ptr as *mut _);
}