2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
|
|
|
/* input_event.h */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 14:16:55 +02:00
|
|
|
/* https://godotengine.org */
|
2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
2022-01-03 21:27:34 +01:00
|
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
2014-02-10 02:10:30 +01:00
|
|
|
/* */
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
/* the following conditions: */
|
|
|
|
/* */
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
/* */
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
/*************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
#ifndef INPUT_EVENT_H
|
|
|
|
#define INPUT_EVENT_H
|
|
|
|
|
2021-03-26 00:58:48 +01:00
|
|
|
#include "core/input/input_enums.h"
|
2020-11-07 23:33:38 +01:00
|
|
|
#include "core/io/resource.h"
|
2018-09-11 18:13:45 +02:00
|
|
|
#include "core/math/transform_2d.h"
|
2021-06-20 19:12:33 +02:00
|
|
|
#include "core/os/keyboard.h"
|
2020-11-07 23:33:38 +01:00
|
|
|
#include "core/string/ustring.h"
|
2018-09-11 18:13:45 +02:00
|
|
|
#include "core/typedefs.h"
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
/**
|
|
|
|
* Input Event classes. These are used in the main loop.
|
|
|
|
* The events are pretty obvious.
|
|
|
|
*/
|
|
|
|
|
2021-05-29 15:28:16 +02:00
|
|
|
class Shortcut;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
/**
|
|
|
|
* Input Modifier Status
|
|
|
|
* for keyboard/mouse events.
|
|
|
|
*/
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
class InputEvent : public Resource {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEvent, Resource);
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
int device = 0;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2019-03-09 22:03:27 +01:00
|
|
|
static const int DEVICE_ID_TOUCH_MOUSE;
|
|
|
|
static const int DEVICE_ID_INTERNAL;
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
void set_device(int p_device);
|
|
|
|
int get_device() const;
|
|
|
|
|
Allow checking for exact matches with Action events.
Added additional param to action related methods to test for exactness.
If "p_exact_match" is true, then the action will only be "matched" if the provided input event *exactly* matches with the action event.
Before:
* Action Event = KEY_S
* Input Event = KEY_CONTROL + KEY_S
* Is Action Pressed = True
Now:
You can still do the above, however you can optionally check that the input is exactly what the action event is:
* Action Event = KEY_S
* Input Event = KEY_CONTROL + KEY_S
* p_exact_match = True
* Is Action Pressed = False
* If the Input Event was only KEY_S, then the result would be true.
Usage:
```gdscript
Input.is_action_pressed(action_name: String, exact_match: bool)
Input.is_action_pressed("my_action", true)
InputMap.event_is_action(p_event, "my_action", true)
func _input(event: InputEvent):
event.is_action_pressed("my_action", false, true) # false = "allow_echo", true = "exact_match"
event.is_action("my_action", true)
```
2020-12-13 15:22:42 +01:00
|
|
|
bool is_action(const StringName &p_action, bool p_exact_match = false) const;
|
|
|
|
bool is_action_pressed(const StringName &p_action, bool p_allow_echo = false, bool p_exact_match = false) const;
|
|
|
|
bool is_action_released(const StringName &p_action, bool p_exact_match = false) const;
|
|
|
|
float get_action_strength(const StringName &p_action, bool p_exact_match = false) const;
|
|
|
|
float get_action_raw_strength(const StringName &p_action, bool p_exact_match = false) const;
|
2018-02-21 22:06:34 +01:00
|
|
|
|
|
|
|
// To be removed someday, since they do not make sense for all events
|
2017-05-20 17:38:03 +02:00
|
|
|
virtual bool is_pressed() const;
|
|
|
|
virtual bool is_echo() const;
|
2018-02-21 22:06:34 +01:00
|
|
|
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String as_text() const = 0;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const;
|
|
|
|
|
2020-10-24 11:22:35 +02:00
|
|
|
virtual bool action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const;
|
2021-05-13 19:13:24 +02:00
|
|
|
virtual bool is_match(const Ref<InputEvent> &p_event, bool p_exact_match = true) const;
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
virtual bool is_action_type() const;
|
|
|
|
|
2019-03-03 23:52:18 +01:00
|
|
|
virtual bool accumulate(const Ref<InputEvent> &p_event) { return false; }
|
2020-05-12 17:01:17 +02:00
|
|
|
|
|
|
|
InputEvent() {}
|
2017-05-20 17:38:03 +02:00
|
|
|
};
|
|
|
|
|
2020-03-01 23:14:37 +01:00
|
|
|
class InputEventFromWindow : public InputEvent {
|
|
|
|
GDCLASS(InputEventFromWindow, InputEvent);
|
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
int64_t window_id = 0;
|
2020-03-01 23:14:37 +01:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
void set_window_id(int64_t p_id);
|
|
|
|
int64_t get_window_id() const;
|
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventFromWindow() {}
|
2020-03-01 23:14:37 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class InputEventWithModifiers : public InputEventFromWindow {
|
|
|
|
GDCLASS(InputEventWithModifiers, InputEventFromWindow);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-09-28 16:23:51 +02:00
|
|
|
bool store_command = true;
|
|
|
|
|
2021-04-24 22:33:50 +02:00
|
|
|
bool shift_pressed = false;
|
|
|
|
bool alt_pressed = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
#ifdef APPLE_STYLE_KEYS
|
|
|
|
union {
|
2021-04-24 22:33:50 +02:00
|
|
|
bool command_pressed;
|
|
|
|
bool meta_pressed = false; //< windows/mac key
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2021-04-24 22:33:50 +02:00
|
|
|
bool ctrl_pressed = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
#else
|
|
|
|
union {
|
2021-04-24 22:33:50 +02:00
|
|
|
bool command_pressed; //< windows/mac key
|
|
|
|
bool ctrl_pressed = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
2021-04-24 22:33:50 +02:00
|
|
|
bool meta_pressed = false; //< windows/mac key
|
2014-02-10 02:10:30 +01:00
|
|
|
#endif
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
2020-09-28 16:23:51 +02:00
|
|
|
virtual void _validate_property(PropertyInfo &property) const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
public:
|
2020-09-28 16:23:51 +02:00
|
|
|
void set_store_command(bool p_enabled);
|
|
|
|
bool is_storing_command() const;
|
|
|
|
|
2021-04-24 22:33:50 +02:00
|
|
|
void set_shift_pressed(bool p_pressed);
|
|
|
|
bool is_shift_pressed() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-04-24 22:33:50 +02:00
|
|
|
void set_alt_pressed(bool p_pressed);
|
|
|
|
bool is_alt_pressed() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-04-24 22:33:50 +02:00
|
|
|
void set_ctrl_pressed(bool p_pressed);
|
|
|
|
bool is_ctrl_pressed() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-04-24 22:33:50 +02:00
|
|
|
void set_meta_pressed(bool p_pressed);
|
|
|
|
bool is_meta_pressed() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-04-24 22:33:50 +02:00
|
|
|
void set_command_pressed(bool p_pressed);
|
|
|
|
bool is_command_pressed() const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-11-01 21:49:39 +01:00
|
|
|
void set_modifiers_from_event(const InputEventWithModifiers *event);
|
|
|
|
|
2021-08-13 23:31:57 +02:00
|
|
|
Key get_modifiers_mask() const;
|
2021-05-13 19:13:24 +02:00
|
|
|
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String as_text() const override;
|
|
|
|
virtual String to_string() override;
|
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventWithModifiers() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
class InputEventKey : public InputEventWithModifiers {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventKey, InputEventWithModifiers);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
bool pressed = false; /// otherwise release
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2021-08-13 23:31:57 +02:00
|
|
|
Key keycode = Key::NONE; // Key enum, without modifier masks.
|
|
|
|
Key physical_keycode = Key::NONE;
|
2020-05-12 17:01:17 +02:00
|
|
|
uint32_t unicode = 0; ///unicode
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
bool echo = false; /// true if this is an echo key
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
void set_pressed(bool p_pressed);
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_pressed() const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-06-20 19:12:33 +02:00
|
|
|
void set_keycode(Key p_keycode);
|
|
|
|
Key get_keycode() const;
|
2018-04-05 19:59:35 +02:00
|
|
|
|
2021-06-20 19:12:33 +02:00
|
|
|
void set_physical_keycode(Key p_keycode);
|
|
|
|
Key get_physical_keycode() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-08-13 23:31:57 +02:00
|
|
|
void set_unicode(char32_t p_unicode);
|
|
|
|
char32_t get_unicode() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
void set_echo(bool p_enable);
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_echo() const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-08-13 23:31:57 +02:00
|
|
|
Key get_keycode_with_modifiers() const;
|
|
|
|
Key get_physical_keycode_with_modifiers() const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-10-24 11:22:35 +02:00
|
|
|
virtual bool action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const override;
|
2021-05-13 19:13:24 +02:00
|
|
|
virtual bool is_match(const Ref<InputEvent> &p_event, bool p_exact_match = true) const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_action_type() const override { return true; }
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-06-23 00:57:59 +02:00
|
|
|
|
2021-06-20 19:12:33 +02:00
|
|
|
static Ref<InputEventKey> create_reference(Key p_keycode_with_modifier_masks);
|
2020-12-07 12:31:25 +01:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventKey() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
class InputEventMouse : public InputEventWithModifiers {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventMouse, InputEventWithModifiers);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2021-08-13 23:31:57 +02:00
|
|
|
MouseButton button_mask = MouseButton::NONE;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
Vector2 pos;
|
|
|
|
Vector2 global_pos;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2021-08-13 23:31:57 +02:00
|
|
|
void set_button_mask(MouseButton p_mask);
|
|
|
|
MouseButton get_button_mask() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2017-06-03 10:54:24 +02:00
|
|
|
void set_position(const Vector2 &p_pos);
|
|
|
|
Vector2 get_position() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2017-06-03 10:54:24 +02:00
|
|
|
void set_global_position(const Vector2 &p_global_pos);
|
|
|
|
Vector2 get_global_position() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventMouse() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
class InputEventMouseButton : public InputEventMouse {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventMouseButton, InputEventMouse);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
float factor = 1;
|
2021-08-13 23:31:57 +02:00
|
|
|
MouseButton button_index = MouseButton::NONE;
|
2020-05-12 17:01:17 +02:00
|
|
|
bool pressed = false; //otherwise released
|
2021-04-13 10:25:44 +02:00
|
|
|
bool double_click = false; //last even less than double click time
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
void set_factor(float p_factor);
|
2020-04-25 13:25:00 +02:00
|
|
|
float get_factor() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-03-25 21:56:12 +01:00
|
|
|
void set_button_index(MouseButton p_index);
|
|
|
|
MouseButton get_button_index() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
void set_pressed(bool p_pressed);
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_pressed() const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-04-13 10:25:44 +02:00
|
|
|
void set_double_click(bool p_double_click);
|
|
|
|
bool is_double_click() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
|
2021-05-13 19:13:24 +02:00
|
|
|
|
2020-10-24 11:22:35 +02:00
|
|
|
virtual bool action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const override;
|
2021-05-13 19:13:24 +02:00
|
|
|
virtual bool is_match(const Ref<InputEvent> &p_event, bool p_exact_match = true) const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_action_type() const override { return true; }
|
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventMouseButton() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
class InputEventMouseMotion : public InputEventMouse {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventMouseMotion, InputEventMouse);
|
2018-12-13 21:32:11 +01:00
|
|
|
|
|
|
|
Vector2 tilt;
|
2020-05-12 17:01:17 +02:00
|
|
|
float pressure = 0;
|
2017-05-20 17:38:03 +02:00
|
|
|
Vector2 relative;
|
2021-12-29 14:22:22 +01:00
|
|
|
Vector2 velocity;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2018-12-13 21:32:11 +01:00
|
|
|
void set_tilt(const Vector2 &p_tilt);
|
|
|
|
Vector2 get_tilt() const;
|
|
|
|
|
|
|
|
void set_pressure(float p_pressure);
|
|
|
|
float get_pressure() const;
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
void set_relative(const Vector2 &p_relative);
|
|
|
|
Vector2 get_relative() const;
|
|
|
|
|
2021-12-29 14:22:22 +01:00
|
|
|
void set_velocity(const Vector2 &p_velocity);
|
|
|
|
Vector2 get_velocity() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
|
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool accumulate(const Ref<InputEvent> &p_event) override;
|
2019-03-03 23:52:18 +01:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventMouseMotion() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
class InputEventJoypadMotion : public InputEvent {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventJoypadMotion, InputEvent);
|
2021-03-25 21:56:12 +01:00
|
|
|
JoyAxis axis = (JoyAxis)0; ///< Joypad axis
|
2020-05-12 17:01:17 +02:00
|
|
|
float axis_value = 0; ///< -1 to 1
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2021-03-25 21:56:12 +01:00
|
|
|
void set_axis(JoyAxis p_axis);
|
|
|
|
JoyAxis get_axis() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
void set_axis_value(float p_value);
|
|
|
|
float get_axis_value() const;
|
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_pressed() const override;
|
2018-02-21 22:06:34 +01:00
|
|
|
|
2020-10-24 11:22:35 +02:00
|
|
|
virtual bool action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const override;
|
2021-05-13 19:13:24 +02:00
|
|
|
virtual bool is_match(const Ref<InputEvent> &p_event, bool p_exact_match = true) const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_action_type() const override { return true; }
|
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventJoypadMotion() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
class InputEventJoypadButton : public InputEvent {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventJoypadButton, InputEvent);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2021-03-25 21:56:12 +01:00
|
|
|
JoyButton button_index = (JoyButton)0;
|
2020-05-12 17:01:17 +02:00
|
|
|
bool pressed = false;
|
|
|
|
float pressure = 0; //0 to 1
|
2017-05-20 17:38:03 +02:00
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2021-03-25 21:56:12 +01:00
|
|
|
void set_button_index(JoyButton p_index);
|
|
|
|
JoyButton get_button_index() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
void set_pressed(bool p_pressed);
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_pressed() const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
void set_pressure(float p_pressure);
|
|
|
|
float get_pressure() const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-10-24 11:22:35 +02:00
|
|
|
virtual bool action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const override;
|
2021-05-13 19:13:24 +02:00
|
|
|
virtual bool is_match(const Ref<InputEvent> &p_event, bool p_exact_match = true) const override;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_action_type() const override { return true; }
|
2021-05-13 19:13:24 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-03-25 21:56:12 +01:00
|
|
|
static Ref<InputEventJoypadButton> create_reference(JoyButton p_btn_index);
|
2020-12-07 12:31:25 +01:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventJoypadButton() {}
|
2017-05-20 17:38:03 +02:00
|
|
|
};
|
|
|
|
|
2020-03-01 23:14:37 +01:00
|
|
|
class InputEventScreenTouch : public InputEventFromWindow {
|
|
|
|
GDCLASS(InputEventScreenTouch, InputEventFromWindow);
|
2020-05-12 17:01:17 +02:00
|
|
|
int index = 0;
|
2017-05-20 17:38:03 +02:00
|
|
|
Vector2 pos;
|
2020-05-12 17:01:17 +02:00
|
|
|
bool pressed = false;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
void set_index(int p_index);
|
|
|
|
int get_index() const;
|
|
|
|
|
2017-06-03 10:54:24 +02:00
|
|
|
void set_position(const Vector2 &p_pos);
|
|
|
|
Vector2 get_position() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
void set_pressed(bool p_pressed);
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_pressed() const override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
|
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventScreenTouch() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2020-03-01 23:14:37 +01:00
|
|
|
class InputEventScreenDrag : public InputEventFromWindow {
|
|
|
|
GDCLASS(InputEventScreenDrag, InputEventFromWindow);
|
2020-05-12 17:01:17 +02:00
|
|
|
int index = 0;
|
2017-05-20 17:38:03 +02:00
|
|
|
Vector2 pos;
|
|
|
|
Vector2 relative;
|
2021-12-29 14:22:22 +01:00
|
|
|
Vector2 velocity;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
void set_index(int p_index);
|
|
|
|
int get_index() const;
|
|
|
|
|
2017-06-03 10:54:24 +02:00
|
|
|
void set_position(const Vector2 &p_pos);
|
|
|
|
Vector2 get_position() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
|
|
|
void set_relative(const Vector2 &p_relative);
|
|
|
|
Vector2 get_relative() const;
|
|
|
|
|
2021-12-29 14:22:22 +01:00
|
|
|
void set_velocity(const Vector2 &p_velocity);
|
|
|
|
Vector2 get_velocity() const;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
|
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2021-08-13 00:31:16 +02:00
|
|
|
virtual bool accumulate(const Ref<InputEvent> &p_event) override;
|
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventScreenDrag() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
class InputEventAction : public InputEvent {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventAction, InputEvent);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
StringName action;
|
2020-05-12 17:01:17 +02:00
|
|
|
bool pressed = false;
|
|
|
|
float strength = 1.0f;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
public:
|
|
|
|
void set_action(const StringName &p_action);
|
|
|
|
StringName get_action() const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
void set_pressed(bool p_pressed);
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_pressed() const override;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-06-01 15:31:47 +02:00
|
|
|
void set_strength(float p_strength);
|
|
|
|
float get_strength() const;
|
|
|
|
|
2017-05-20 17:38:03 +02:00
|
|
|
virtual bool is_action(const StringName &p_action) const;
|
|
|
|
|
2020-10-24 11:22:35 +02:00
|
|
|
virtual bool action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const override;
|
2021-05-13 19:13:24 +02:00
|
|
|
virtual bool is_match(const Ref<InputEvent> &p_event, bool p_exact_match = true) const override;
|
2018-09-10 21:15:06 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual bool is_action_type() const override { return true; }
|
2021-05-13 19:13:24 +02:00
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-05-20 17:38:03 +02:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventAction() {}
|
2014-02-10 02:10:30 +01:00
|
|
|
};
|
|
|
|
|
2017-11-01 21:49:39 +01:00
|
|
|
class InputEventGesture : public InputEventWithModifiers {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventGesture, InputEventWithModifiers);
|
2017-11-01 21:49:39 +01:00
|
|
|
|
|
|
|
Vector2 pos;
|
|
|
|
|
2017-11-24 19:22:33 +01:00
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2017-11-01 21:49:39 +01:00
|
|
|
public:
|
|
|
|
void set_position(const Vector2 &p_pos);
|
|
|
|
Vector2 get_position() const;
|
|
|
|
};
|
|
|
|
|
|
|
|
class InputEventMagnifyGesture : public InputEventGesture {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventMagnifyGesture, InputEventGesture);
|
2020-05-12 17:01:17 +02:00
|
|
|
real_t factor = 1.0;
|
2017-11-01 21:49:39 +01:00
|
|
|
|
2017-11-24 19:22:33 +01:00
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2017-11-01 21:49:39 +01:00
|
|
|
public:
|
|
|
|
void set_factor(real_t p_factor);
|
|
|
|
real_t get_factor() const;
|
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
|
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-11-01 21:49:39 +01:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventMagnifyGesture() {}
|
2017-11-01 21:49:39 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class InputEventPanGesture : public InputEventGesture {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventPanGesture, InputEventGesture);
|
2017-11-01 21:49:39 +01:00
|
|
|
Vector2 delta;
|
|
|
|
|
2017-11-24 19:22:33 +01:00
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2017-11-01 21:49:39 +01:00
|
|
|
public:
|
|
|
|
void set_delta(const Vector2 &p_delta);
|
|
|
|
Vector2 get_delta() const;
|
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
|
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2017-11-01 21:49:39 +01:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventPanGesture() {}
|
2017-11-01 21:49:39 +01:00
|
|
|
};
|
2018-07-14 14:11:28 +02:00
|
|
|
|
|
|
|
class InputEventMIDI : public InputEvent {
|
2019-03-19 19:35:57 +01:00
|
|
|
GDCLASS(InputEventMIDI, InputEvent);
|
2018-07-14 14:11:28 +02:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
int channel = 0;
|
2021-08-13 23:31:57 +02:00
|
|
|
MIDIMessage message = MIDIMessage::NONE;
|
2020-05-12 17:01:17 +02:00
|
|
|
int pitch = 0;
|
|
|
|
int velocity = 0;
|
|
|
|
int instrument = 0;
|
|
|
|
int pressure = 0;
|
|
|
|
int controller_number = 0;
|
|
|
|
int controller_value = 0;
|
2018-07-14 14:11:28 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
void set_channel(const int p_channel);
|
|
|
|
int get_channel() const;
|
|
|
|
|
2021-03-25 21:56:12 +01:00
|
|
|
void set_message(const MIDIMessage p_message);
|
|
|
|
MIDIMessage get_message() const;
|
2018-07-14 14:11:28 +02:00
|
|
|
|
|
|
|
void set_pitch(const int p_pitch);
|
|
|
|
int get_pitch() const;
|
|
|
|
|
|
|
|
void set_velocity(const int p_velocity);
|
|
|
|
int get_velocity() const;
|
|
|
|
|
|
|
|
void set_instrument(const int p_instrument);
|
|
|
|
int get_instrument() const;
|
|
|
|
|
|
|
|
void set_pressure(const int p_pressure);
|
|
|
|
int get_pressure() const;
|
|
|
|
|
|
|
|
void set_controller_number(const int p_controller_number);
|
|
|
|
int get_controller_number() const;
|
|
|
|
|
|
|
|
void set_controller_value(const int p_controller_value);
|
|
|
|
int get_controller_value() const;
|
|
|
|
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual String as_text() const override;
|
2020-10-01 14:55:23 +02:00
|
|
|
virtual String to_string() override;
|
2018-07-14 14:11:28 +02:00
|
|
|
|
2020-05-12 17:01:17 +02:00
|
|
|
InputEventMIDI() {}
|
2018-07-14 14:11:28 +02:00
|
|
|
};
|
|
|
|
|
2021-05-29 15:28:16 +02:00
|
|
|
class InputEventShortcut : public InputEvent {
|
|
|
|
GDCLASS(InputEventShortcut, InputEvent);
|
|
|
|
|
|
|
|
Ref<Shortcut> shortcut;
|
|
|
|
|
2021-08-22 17:37:22 +02:00
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2021-05-29 15:28:16 +02:00
|
|
|
public:
|
|
|
|
void set_shortcut(Ref<Shortcut> p_shortcut);
|
|
|
|
Ref<Shortcut> get_shortcut();
|
|
|
|
virtual bool is_pressed() const override;
|
|
|
|
|
|
|
|
virtual String as_text() const override;
|
|
|
|
virtual String to_string() override;
|
|
|
|
};
|
|
|
|
|
2020-03-25 11:10:34 +01:00
|
|
|
#endif // INPUT_EVENT_H
|