2014-02-10 01:10:30 +00:00
|
|
|
/*************************************************************************/
|
|
|
|
|
/* input_event.cpp */
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
/* This file is part of: */
|
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 12:16:55 +00:00
|
|
|
/* https://godotengine.org */
|
2014-02-10 01:10:30 +00:00
|
|
|
/*************************************************************************/
|
2022-01-13 08:45:09 +00:00
|
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
|
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
2014-02-10 01:10:30 +00: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-04 23:50:27 +00:00
|
|
|
|
2014-02-10 01:10:30 +00:00
|
|
|
#include "input_event.h"
|
2017-08-27 19:07:15 +00:00
|
|
|
|
2018-09-11 16:13:45 +00:00
|
|
|
#include "core/input_map.h"
|
|
|
|
|
#include "core/os/keyboard.h"
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2019-03-09 21:03:27 +00:00
|
|
|
const int InputEvent::DEVICE_ID_TOUCH_MOUSE = -1;
|
|
|
|
|
const int InputEvent::DEVICE_ID_INTERNAL = -2;
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEvent::set_device(int p_device) {
|
|
|
|
|
device = p_device;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
2016-03-08 23:00:52 +00:00
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
int InputEvent::get_device() const {
|
|
|
|
|
return device;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
bool InputEvent::is_action(const StringName &p_action, bool p_exact_match) const {
|
|
|
|
|
return InputMap::get_singleton()->event_is_action(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match);
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
bool InputEvent::is_action_pressed(const StringName &p_action, bool p_allow_echo, bool p_exact_match) const {
|
2018-02-21 21:06:34 +00:00
|
|
|
bool pressed;
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match, &pressed, nullptr, nullptr);
|
2019-10-24 21:51:33 +00:00
|
|
|
return valid && pressed && (p_allow_echo || !is_echo());
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
bool InputEvent::is_action_released(const StringName &p_action, bool p_exact_match) const {
|
2018-02-21 21:06:34 +00:00
|
|
|
bool pressed;
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match, &pressed, nullptr, nullptr);
|
2018-02-21 21:06:34 +00:00
|
|
|
return valid && !pressed;
|
|
|
|
|
}
|
|
|
|
|
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
float InputEvent::get_action_strength(const StringName &p_action, bool p_exact_match) const {
|
2018-02-21 21:06:34 +00:00
|
|
|
float strength;
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match, nullptr, &strength, nullptr);
|
2018-02-21 21:06:34 +00:00
|
|
|
return valid ? strength : 0.0f;
|
|
|
|
|
}
|
|
|
|
|
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
float InputEvent::get_action_raw_strength(const StringName &p_action, bool p_exact_match) const {
|
2021-07-23 00:28:08 +00:00
|
|
|
float raw_strength;
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match, nullptr, nullptr, &raw_strength);
|
2021-07-23 00:28:08 +00:00
|
|
|
return valid ? raw_strength : 0.0f;
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-21 21:06:34 +00:00
|
|
|
bool InputEvent::is_pressed() const {
|
|
|
|
|
return false;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool InputEvent::is_echo() const {
|
2017-05-20 15:38:03 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ref<InputEvent> InputEvent::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
|
|
|
|
|
return Ref<InputEvent>((InputEvent *)this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
String InputEvent::as_text() const {
|
|
|
|
|
return String();
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-24 05:10:06 +00:00
|
|
|
bool InputEvent::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
|
2017-05-20 15:38:03 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2021-09-16 05:09:40 +00:00
|
|
|
bool InputEvent::shortcut_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
|
2017-06-22 22:57:59 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
bool InputEvent::is_action_type() const {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEvent::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_device", "device"), &InputEvent::set_device);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_device"), &InputEvent::get_device);
|
|
|
|
|
|
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)
```
Co-authored-by: Eric M <itsjusteza@gmail.com>
2020-12-13 14:22:42 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("is_action", "action", "exact_match"), &InputEvent::is_action, DEFVAL(false));
|
|
|
|
|
ClassDB::bind_method(D_METHOD("is_action_pressed", "action", "allow_echo", "exact_match"), &InputEvent::is_action_pressed, DEFVAL(false), DEFVAL(false));
|
|
|
|
|
ClassDB::bind_method(D_METHOD("is_action_released", "action", "exact_match"), &InputEvent::is_action_released, DEFVAL(false));
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_action_strength", "action", "exact_match"), &InputEvent::get_action_strength, DEFVAL(false));
|
2018-02-21 21:06:34 +00:00
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("is_pressed"), &InputEvent::is_pressed);
|
2017-05-20 15:38:03 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("is_echo"), &InputEvent::is_echo);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("as_text"), &InputEvent::as_text);
|
|
|
|
|
|
2021-09-16 05:09:40 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("shortcut_match", "event", "exact_match"), &InputEvent::shortcut_match, DEFVAL(true));
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("is_action_type"), &InputEvent::is_action_type);
|
|
|
|
|
|
2019-03-03 22:52:18 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("accumulate", "with_event"), &InputEvent::accumulate);
|
|
|
|
|
|
2017-08-09 11:19:41 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("xformed_by", "xform", "local_ofs"), &InputEvent::xformed_by, DEFVAL(Vector2()));
|
2017-06-24 13:28:19 +00:00
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "device"), "set_device", "get_device");
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEvent::InputEvent() {
|
|
|
|
|
device = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventWithModifiers::set_shift(bool p_enabled) {
|
|
|
|
|
shift = p_enabled;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool InputEventWithModifiers::get_shift() const {
|
|
|
|
|
return shift;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventWithModifiers::set_alt(bool p_enabled) {
|
|
|
|
|
alt = p_enabled;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventWithModifiers::get_alt() const {
|
|
|
|
|
return alt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventWithModifiers::set_control(bool p_enabled) {
|
|
|
|
|
control = p_enabled;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventWithModifiers::get_control() const {
|
|
|
|
|
return control;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventWithModifiers::set_metakey(bool p_enabled) {
|
|
|
|
|
meta = p_enabled;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventWithModifiers::get_metakey() const {
|
|
|
|
|
return meta;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventWithModifiers::set_command(bool p_enabled) {
|
|
|
|
|
command = p_enabled;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventWithModifiers::get_command() const {
|
|
|
|
|
return command;
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-01 20:49:39 +00:00
|
|
|
void InputEventWithModifiers::set_modifiers_from_event(const InputEventWithModifiers *event) {
|
|
|
|
|
set_alt(event->get_alt());
|
|
|
|
|
set_shift(event->get_shift());
|
|
|
|
|
set_control(event->get_control());
|
|
|
|
|
set_metakey(event->get_metakey());
|
|
|
|
|
}
|
|
|
|
|
|
2021-09-16 05:09:40 +00:00
|
|
|
uint32_t InputEventWithModifiers::get_modifiers_mask() const {
|
|
|
|
|
uint32_t mask = 0;
|
|
|
|
|
if (get_control()) {
|
|
|
|
|
mask |= KEY_MASK_CTRL;
|
|
|
|
|
}
|
|
|
|
|
if (get_shift()) {
|
|
|
|
|
mask |= KEY_MASK_SHIFT;
|
|
|
|
|
}
|
|
|
|
|
if (get_alt()) {
|
|
|
|
|
mask |= KEY_MASK_ALT;
|
|
|
|
|
}
|
|
|
|
|
if (get_metakey()) {
|
|
|
|
|
mask |= KEY_MASK_META;
|
|
|
|
|
}
|
|
|
|
|
return mask;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventWithModifiers::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_alt", "enable"), &InputEventWithModifiers::set_alt);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_alt"), &InputEventWithModifiers::get_alt);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_shift", "enable"), &InputEventWithModifiers::set_shift);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_shift"), &InputEventWithModifiers::get_shift);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_control", "enable"), &InputEventWithModifiers::set_control);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_control"), &InputEventWithModifiers::get_control);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_metakey", "enable"), &InputEventWithModifiers::set_metakey);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_metakey"), &InputEventWithModifiers::get_metakey);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_command", "enable"), &InputEventWithModifiers::set_command);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_command"), &InputEventWithModifiers::get_command);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "alt"), "set_alt", "get_alt");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "shift"), "set_shift", "get_shift");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "control"), "set_control", "get_control");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "meta"), "set_metakey", "get_metakey");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "command"), "set_command", "get_command");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventWithModifiers::InputEventWithModifiers() {
|
|
|
|
|
alt = false;
|
|
|
|
|
shift = false;
|
|
|
|
|
control = false;
|
|
|
|
|
meta = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventKey::set_pressed(bool p_pressed) {
|
|
|
|
|
pressed = p_pressed;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-25 19:54:18 +00:00
|
|
|
bool InputEventKey::is_pressed() const {
|
2017-05-20 15:38:03 +00:00
|
|
|
return pressed;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventKey::set_scancode(uint32_t p_scancode) {
|
|
|
|
|
scancode = p_scancode;
|
|
|
|
|
}
|
|
|
|
|
uint32_t InputEventKey::get_scancode() const {
|
|
|
|
|
return scancode;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
|
2021-03-07 15:16:42 +00:00
|
|
|
void InputEventKey::set_physical_scancode(uint32_t p_scancode) {
|
|
|
|
|
physical_scancode = p_scancode;
|
|
|
|
|
}
|
|
|
|
|
uint32_t InputEventKey::get_physical_scancode() const {
|
|
|
|
|
return physical_scancode;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventKey::set_unicode(uint32_t p_unicode) {
|
|
|
|
|
unicode = p_unicode;
|
2015-06-23 20:24:48 +00:00
|
|
|
}
|
2017-05-20 15:38:03 +00:00
|
|
|
uint32_t InputEventKey::get_unicode() const {
|
|
|
|
|
return unicode;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventKey::set_echo(bool p_enable) {
|
|
|
|
|
echo = p_enable;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventKey::is_echo() const {
|
|
|
|
|
return echo;
|
2015-06-23 20:24:48 +00:00
|
|
|
}
|
|
|
|
|
|
2014-02-10 01:10:30 +00:00
|
|
|
uint32_t InputEventKey::get_scancode_with_modifiers() const {
|
2021-09-16 05:09:40 +00:00
|
|
|
return scancode | get_modifiers_mask();
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
2016-06-27 12:59:43 +00:00
|
|
|
|
2021-03-07 15:16:42 +00:00
|
|
|
uint32_t InputEventKey::get_physical_scancode_with_modifiers() const {
|
2021-09-16 05:09:40 +00:00
|
|
|
return physical_scancode | get_modifiers_mask();
|
2021-03-07 15:16:42 +00:00
|
|
|
}
|
|
|
|
|
|
2017-06-22 22:57:59 +00:00
|
|
|
String InputEventKey::as_text() const {
|
|
|
|
|
String kc = keycode_get_string(scancode);
|
2021-05-05 10:44:11 +00:00
|
|
|
if (kc == String()) {
|
2017-06-22 22:57:59 +00:00
|
|
|
return kc;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2017-06-22 22:57:59 +00:00
|
|
|
|
|
|
|
|
if (get_metakey()) {
|
2017-10-08 07:23:05 +00:00
|
|
|
kc = find_keycode_name(KEY_META) + ("+" + kc);
|
2017-06-22 22:57:59 +00:00
|
|
|
}
|
|
|
|
|
if (get_alt()) {
|
2017-10-08 07:23:05 +00:00
|
|
|
kc = find_keycode_name(KEY_ALT) + ("+" + kc);
|
2017-06-22 22:57:59 +00:00
|
|
|
}
|
|
|
|
|
if (get_shift()) {
|
2017-10-08 07:23:05 +00:00
|
|
|
kc = find_keycode_name(KEY_SHIFT) + ("+" + kc);
|
2017-06-22 22:57:59 +00:00
|
|
|
}
|
|
|
|
|
if (get_control()) {
|
2017-10-08 07:23:05 +00:00
|
|
|
kc = find_keycode_name(KEY_CONTROL) + ("+" + kc);
|
2017-06-22 22:57:59 +00:00
|
|
|
}
|
|
|
|
|
return kc;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-24 05:10:06 +00:00
|
|
|
bool InputEventKey::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
|
2017-05-20 15:38:03 +00:00
|
|
|
Ref<InputEventKey> key = p_event;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (key.is_null()) {
|
2017-05-20 15:38:03 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2017-05-20 15:38:03 +00:00
|
|
|
|
2021-10-24 05:10:06 +00:00
|
|
|
bool match;
|
|
|
|
|
if (scancode != 0) {
|
|
|
|
|
match = scancode == key->scancode;
|
2021-03-07 15:16:42 +00:00
|
|
|
} else {
|
2021-10-24 05:10:06 +00:00
|
|
|
match = physical_scancode == key->physical_scancode;
|
|
|
|
|
}
|
|
|
|
|
if (p_exact_match) {
|
|
|
|
|
match &= get_modifiers_mask() == key->get_modifiers_mask();
|
2021-03-07 15:16:42 +00:00
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
if (match) {
|
2021-08-15 23:23:50 +00:00
|
|
|
bool pressed = key->is_pressed();
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_pressed != nullptr) {
|
2021-08-15 23:23:50 +00:00
|
|
|
*p_pressed = pressed;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2021-08-15 23:23:50 +00:00
|
|
|
float strength = pressed ? 1.0f : 0.0f;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_strength != nullptr) {
|
2021-07-28 18:42:21 +00:00
|
|
|
*p_strength = strength;
|
|
|
|
|
}
|
|
|
|
|
if (p_raw_strength != nullptr) {
|
|
|
|
|
*p_raw_strength = strength;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
}
|
|
|
|
|
return match;
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
|
|
|
|
|
2021-09-16 05:09:40 +00:00
|
|
|
bool InputEventKey::shortcut_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
|
2017-06-22 22:57:59 +00:00
|
|
|
Ref<InputEventKey> key = p_event;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (key.is_null()) {
|
2017-06-22 22:57:59 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2017-06-22 22:57:59 +00:00
|
|
|
|
2021-10-19 19:19:13 +00:00
|
|
|
if (scancode == 0) {
|
|
|
|
|
return physical_scancode == key->physical_scancode &&
|
2021-10-28 11:23:24 +00:00
|
|
|
(!p_exact_match || get_modifiers_mask() == key->get_modifiers_mask());
|
2021-10-19 19:19:13 +00:00
|
|
|
} else {
|
|
|
|
|
return scancode == key->scancode &&
|
2021-10-28 11:23:24 +00:00
|
|
|
(!p_exact_match || get_modifiers_mask() == key->get_modifiers_mask());
|
2021-10-19 19:19:13 +00:00
|
|
|
}
|
2017-06-22 22:57:59 +00:00
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventKey::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventKey::set_pressed);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_scancode", "scancode"), &InputEventKey::set_scancode);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_scancode"), &InputEventKey::get_scancode);
|
|
|
|
|
|
2021-03-07 15:16:42 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_physical_scancode", "scancode"), &InputEventKey::set_physical_scancode);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_physical_scancode"), &InputEventKey::get_physical_scancode);
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_unicode", "unicode"), &InputEventKey::set_unicode);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_unicode"), &InputEventKey::get_unicode);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_echo", "echo"), &InputEventKey::set_echo);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_scancode_with_modifiers"), &InputEventKey::get_scancode_with_modifiers);
|
2021-03-07 15:16:42 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("get_physical_scancode_with_modifiers"), &InputEventKey::get_physical_scancode_with_modifiers);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "scancode"), "set_scancode", "get_scancode");
|
2021-03-07 15:16:42 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "physical_scancode"), "set_physical_scancode", "get_physical_scancode");
|
2017-05-20 15:38:03 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "unicode"), "set_unicode", "get_unicode");
|
2020-03-01 06:52:37 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "echo"), "set_echo", "is_echo");
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventKey::InputEventKey() {
|
|
|
|
|
pressed = false;
|
|
|
|
|
scancode = 0;
|
2021-03-07 15:16:42 +00:00
|
|
|
physical_scancode = 0;
|
2017-05-20 15:38:03 +00:00
|
|
|
unicode = 0; ///unicode
|
|
|
|
|
echo = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventMouse::set_button_mask(int p_mask) {
|
|
|
|
|
button_mask = p_mask;
|
|
|
|
|
}
|
|
|
|
|
int InputEventMouse::get_button_mask() const {
|
|
|
|
|
return button_mask;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
void InputEventMouse::set_position(const Vector2 &p_pos) {
|
2017-05-20 15:38:03 +00:00
|
|
|
pos = p_pos;
|
|
|
|
|
}
|
2017-06-03 08:54:24 +00:00
|
|
|
Vector2 InputEventMouse::get_position() const {
|
2017-05-20 15:38:03 +00:00
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
void InputEventMouse::set_global_position(const Vector2 &p_global_pos) {
|
2017-05-20 15:38:03 +00:00
|
|
|
global_pos = p_global_pos;
|
|
|
|
|
}
|
2017-06-03 08:54:24 +00:00
|
|
|
Vector2 InputEventMouse::get_global_position() const {
|
2017-05-20 15:38:03 +00:00
|
|
|
return global_pos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMouse::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_button_mask", "button_mask"), &InputEventMouse::set_button_mask);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_button_mask"), &InputEventMouse::get_button_mask);
|
|
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventMouse::set_position);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_position"), &InputEventMouse::get_position);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_global_position", "global_position"), &InputEventMouse::set_global_position);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_global_position"), &InputEventMouse::get_global_position);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_mask"), "set_button_mask", "get_button_mask");
|
2017-06-03 08:54:24 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "global_position"), "set_global_position", "get_global_position");
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventMouse::InputEventMouse() {
|
|
|
|
|
button_mask = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventMouseButton::set_factor(float p_factor) {
|
|
|
|
|
factor = p_factor;
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-25 11:25:00 +00:00
|
|
|
float InputEventMouseButton::get_factor() const {
|
2017-05-20 15:38:03 +00:00
|
|
|
return factor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMouseButton::set_button_index(int p_index) {
|
|
|
|
|
button_index = p_index;
|
|
|
|
|
}
|
|
|
|
|
int InputEventMouseButton::get_button_index() const {
|
|
|
|
|
return button_index;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMouseButton::set_pressed(bool p_pressed) {
|
|
|
|
|
pressed = p_pressed;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventMouseButton::is_pressed() const {
|
|
|
|
|
return pressed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMouseButton::set_doubleclick(bool p_doubleclick) {
|
|
|
|
|
doubleclick = p_doubleclick;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventMouseButton::is_doubleclick() const {
|
|
|
|
|
return doubleclick;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ref<InputEvent> InputEventMouseButton::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
|
2019-09-02 22:58:10 +00:00
|
|
|
Vector2 g = get_global_position();
|
2017-06-03 08:54:24 +00:00
|
|
|
Vector2 l = p_xform.xform(get_position() + p_local_ofs);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
Ref<InputEventMouseButton> mb;
|
|
|
|
|
mb.instance();
|
|
|
|
|
|
|
|
|
|
mb->set_device(get_device());
|
|
|
|
|
|
2017-11-01 20:49:39 +00:00
|
|
|
mb->set_modifiers_from_event(this);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
mb->set_position(l);
|
|
|
|
|
mb->set_global_position(g);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
mb->set_button_mask(get_button_mask());
|
|
|
|
|
mb->set_pressed(pressed);
|
|
|
|
|
mb->set_doubleclick(doubleclick);
|
|
|
|
|
mb->set_factor(factor);
|
|
|
|
|
mb->set_button_index(button_index);
|
|
|
|
|
|
|
|
|
|
return mb;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-24 05:10:06 +00:00
|
|
|
bool InputEventMouseButton::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
|
2017-05-20 15:38:03 +00:00
|
|
|
Ref<InputEventMouseButton> mb = p_event;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (mb.is_null()) {
|
2017-05-20 15:38:03 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2017-05-20 15:38:03 +00:00
|
|
|
|
2018-02-21 21:06:34 +00:00
|
|
|
bool match = mb->button_index == button_index;
|
2021-10-24 05:10:06 +00:00
|
|
|
if (p_exact_match) {
|
|
|
|
|
match &= get_modifiers_mask() == mb->get_modifiers_mask();
|
|
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
if (match) {
|
2021-08-15 23:23:50 +00:00
|
|
|
bool pressed = mb->is_pressed();
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_pressed != nullptr) {
|
2021-08-15 23:23:50 +00:00
|
|
|
*p_pressed = pressed;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2021-08-15 23:23:50 +00:00
|
|
|
float strength = pressed ? 1.0f : 0.0f;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_strength != nullptr) {
|
2021-07-28 18:42:21 +00:00
|
|
|
*p_strength = strength;
|
|
|
|
|
}
|
|
|
|
|
if (p_raw_strength != nullptr) {
|
|
|
|
|
*p_raw_strength = strength;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return match;
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
|
|
|
|
|
2021-09-16 05:09:40 +00:00
|
|
|
bool InputEventMouseButton::shortcut_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
|
|
|
|
|
Ref<InputEventMouseButton> mb = p_event;
|
|
|
|
|
if (mb.is_null()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return button_index == mb->button_index &&
|
2021-10-28 11:23:24 +00:00
|
|
|
(!p_exact_match || get_modifiers_mask() == mb->get_modifiers_mask());
|
2021-09-16 05:09:40 +00:00
|
|
|
}
|
|
|
|
|
|
2017-08-24 16:14:36 +00:00
|
|
|
String InputEventMouseButton::as_text() const {
|
|
|
|
|
String button_index_string = "";
|
|
|
|
|
switch (get_button_index()) {
|
|
|
|
|
case BUTTON_LEFT:
|
|
|
|
|
button_index_string = "BUTTON_LEFT";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_RIGHT:
|
|
|
|
|
button_index_string = "BUTTON_RIGHT";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_MIDDLE:
|
|
|
|
|
button_index_string = "BUTTON_MIDDLE";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_WHEEL_UP:
|
|
|
|
|
button_index_string = "BUTTON_WHEEL_UP";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_WHEEL_DOWN:
|
|
|
|
|
button_index_string = "BUTTON_WHEEL_DOWN";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_WHEEL_LEFT:
|
|
|
|
|
button_index_string = "BUTTON_WHEEL_LEFT";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_WHEEL_RIGHT:
|
|
|
|
|
button_index_string = "BUTTON_WHEEL_RIGHT";
|
|
|
|
|
break;
|
2018-07-05 14:50:30 +00:00
|
|
|
case BUTTON_XBUTTON1:
|
|
|
|
|
button_index_string = "BUTTON_XBUTTON1";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_XBUTTON2:
|
|
|
|
|
button_index_string = "BUTTON_XBUTTON2";
|
|
|
|
|
break;
|
2017-08-24 16:14:36 +00:00
|
|
|
default:
|
|
|
|
|
button_index_string = itos(get_button_index());
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return "InputEventMouseButton : button_index=" + button_index_string + ", pressed=" + (pressed ? "true" : "false") + ", position=(" + String(get_position()) + "), button_mask=" + itos(get_button_mask()) + ", doubleclick=" + (doubleclick ? "true" : "false");
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventMouseButton::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_factor", "factor"), &InputEventMouseButton::set_factor);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_factor"), &InputEventMouseButton::get_factor);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventMouseButton::set_button_index);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventMouseButton::get_button_index);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventMouseButton::set_pressed);
|
|
|
|
|
// ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventMouseButton::is_pressed);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_doubleclick", "doubleclick"), &InputEventMouseButton::set_doubleclick);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("is_doubleclick"), &InputEventMouseButton::is_doubleclick);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "factor"), "set_factor", "get_factor");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "doubleclick"), "set_doubleclick", "is_doubleclick");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventMouseButton::InputEventMouseButton() {
|
2017-05-24 07:40:42 +00:00
|
|
|
factor = 1;
|
2017-05-20 15:38:03 +00:00
|
|
|
button_index = 0;
|
|
|
|
|
pressed = false;
|
|
|
|
|
doubleclick = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////
|
|
|
|
|
|
2018-12-13 20:32:11 +00:00
|
|
|
void InputEventMouseMotion::set_tilt(const Vector2 &p_tilt) {
|
|
|
|
|
tilt = p_tilt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Vector2 InputEventMouseMotion::get_tilt() const {
|
|
|
|
|
return tilt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMouseMotion::set_pressure(float p_pressure) {
|
|
|
|
|
pressure = p_pressure;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
float InputEventMouseMotion::get_pressure() const {
|
|
|
|
|
return pressure;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventMouseMotion::set_relative(const Vector2 &p_relative) {
|
|
|
|
|
relative = p_relative;
|
|
|
|
|
}
|
2018-12-13 20:32:11 +00:00
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
Vector2 InputEventMouseMotion::get_relative() const {
|
|
|
|
|
return relative;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMouseMotion::set_speed(const Vector2 &p_speed) {
|
|
|
|
|
speed = p_speed;
|
|
|
|
|
}
|
2018-12-13 20:32:11 +00:00
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
Vector2 InputEventMouseMotion::get_speed() const {
|
|
|
|
|
return speed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ref<InputEvent> InputEventMouseMotion::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
|
2019-09-02 22:58:10 +00:00
|
|
|
Vector2 g = get_global_position();
|
2017-06-03 08:54:24 +00:00
|
|
|
Vector2 l = p_xform.xform(get_position() + p_local_ofs);
|
2017-05-20 15:38:03 +00:00
|
|
|
Vector2 r = p_xform.basis_xform(get_relative());
|
|
|
|
|
Vector2 s = p_xform.basis_xform(get_speed());
|
|
|
|
|
|
|
|
|
|
Ref<InputEventMouseMotion> mm;
|
|
|
|
|
mm.instance();
|
|
|
|
|
|
|
|
|
|
mm->set_device(get_device());
|
|
|
|
|
|
2017-11-01 20:49:39 +00:00
|
|
|
mm->set_modifiers_from_event(this);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
mm->set_position(l);
|
2018-12-13 20:32:11 +00:00
|
|
|
mm->set_pressure(get_pressure());
|
|
|
|
|
mm->set_tilt(get_tilt());
|
2017-06-03 08:54:24 +00:00
|
|
|
mm->set_global_position(g);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
mm->set_button_mask(get_button_mask());
|
|
|
|
|
mm->set_relative(r);
|
|
|
|
|
mm->set_speed(s);
|
|
|
|
|
|
|
|
|
|
return mm;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-24 16:14:36 +00:00
|
|
|
String InputEventMouseMotion::as_text() const {
|
|
|
|
|
String button_mask_string = "";
|
|
|
|
|
switch (get_button_mask()) {
|
|
|
|
|
case BUTTON_MASK_LEFT:
|
|
|
|
|
button_mask_string = "BUTTON_MASK_LEFT";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_MASK_MIDDLE:
|
|
|
|
|
button_mask_string = "BUTTON_MASK_MIDDLE";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_MASK_RIGHT:
|
|
|
|
|
button_mask_string = "BUTTON_MASK_RIGHT";
|
|
|
|
|
break;
|
2018-07-05 14:50:30 +00:00
|
|
|
case BUTTON_MASK_XBUTTON1:
|
|
|
|
|
button_mask_string = "BUTTON_MASK_XBUTTON1";
|
|
|
|
|
break;
|
|
|
|
|
case BUTTON_MASK_XBUTTON2:
|
|
|
|
|
button_mask_string = "BUTTON_MASK_XBUTTON2";
|
|
|
|
|
break;
|
2017-08-24 16:14:36 +00:00
|
|
|
default:
|
|
|
|
|
button_mask_string = itos(get_button_mask());
|
|
|
|
|
break;
|
|
|
|
|
}
|
2020-05-05 11:53:30 +00:00
|
|
|
return "InputEventMouseMotion : button_mask=" + button_mask_string + ", position=(" + String(get_position()) + "), relative=(" + String(get_relative()) + "), speed=(" + String(get_speed()) + "), pressure=(" + rtos(get_pressure()) + "), tilt=(" + String(get_tilt()) + ")";
|
2017-08-24 16:14:36 +00:00
|
|
|
}
|
|
|
|
|
|
2019-03-03 22:52:18 +00:00
|
|
|
bool InputEventMouseMotion::accumulate(const Ref<InputEvent> &p_event) {
|
|
|
|
|
Ref<InputEventMouseMotion> motion = p_event;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (motion.is_null()) {
|
2019-03-03 22:52:18 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2019-03-03 22:52:18 +00:00
|
|
|
|
|
|
|
|
if (is_pressed() != motion->is_pressed()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (get_button_mask() != motion->get_button_mask()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (get_shift() != motion->get_shift()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (get_control() != motion->get_control()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (get_alt() != motion->get_alt()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (get_metakey() != motion->get_metakey()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set_position(motion->get_position());
|
|
|
|
|
set_global_position(motion->get_global_position());
|
|
|
|
|
set_speed(motion->get_speed());
|
|
|
|
|
relative += motion->get_relative();
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventMouseMotion::_bind_methods() {
|
2018-12-13 20:32:11 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_tilt", "tilt"), &InputEventMouseMotion::set_tilt);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_tilt"), &InputEventMouseMotion::get_tilt);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventMouseMotion::set_pressure);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventMouseMotion::get_pressure);
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventMouseMotion::set_relative);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_relative"), &InputEventMouseMotion::get_relative);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventMouseMotion::set_speed);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_speed"), &InputEventMouseMotion::get_speed);
|
|
|
|
|
|
2018-12-13 20:32:11 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "tilt"), "set_tilt", "get_tilt");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "pressure"), "set_pressure", "get_pressure");
|
2017-05-20 15:38:03 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventMouseMotion::InputEventMouseMotion() {
|
2018-12-13 20:32:11 +00:00
|
|
|
pressure = 0;
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventJoypadMotion::set_axis(int p_axis) {
|
|
|
|
|
axis = p_axis;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventJoypadMotion::get_axis() const {
|
|
|
|
|
return axis;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventJoypadMotion::set_axis_value(float p_value) {
|
|
|
|
|
axis_value = p_value;
|
|
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
float InputEventJoypadMotion::get_axis_value() const {
|
|
|
|
|
return axis_value;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-12 11:03:44 +00:00
|
|
|
bool InputEventJoypadMotion::is_pressed() const {
|
2018-02-21 21:06:34 +00:00
|
|
|
return Math::abs(axis_value) >= 0.5f;
|
2017-08-12 11:03:44 +00:00
|
|
|
}
|
|
|
|
|
|
2021-10-24 05:10:06 +00:00
|
|
|
bool InputEventJoypadMotion::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
|
2017-05-20 15:38:03 +00:00
|
|
|
Ref<InputEventJoypadMotion> jm = p_event;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (jm.is_null()) {
|
2017-05-20 15:38:03 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2017-05-20 15:38:03 +00:00
|
|
|
|
2021-10-24 05:10:06 +00:00
|
|
|
// Matches even if not in the same direction, but returns a "not pressed" event.
|
|
|
|
|
bool match = (axis == jm->axis);
|
|
|
|
|
if (p_exact_match) {
|
|
|
|
|
match &= (axis_value < 0) == (jm->axis_value < 0);
|
|
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
if (match) {
|
2021-07-28 18:42:21 +00:00
|
|
|
float jm_abs_axis_value = Math::abs(jm->get_axis_value());
|
2018-04-25 20:29:39 +00:00
|
|
|
bool same_direction = (((axis_value < 0) == (jm->axis_value < 0)) || jm->axis_value == 0);
|
2021-07-28 18:42:21 +00:00
|
|
|
bool pressed = same_direction ? jm_abs_axis_value >= p_deadzone : false;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_pressed != nullptr) {
|
2018-04-25 20:29:39 +00:00
|
|
|
*p_pressed = pressed;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2021-05-04 14:00:45 +00:00
|
|
|
if (p_strength != nullptr) {
|
2019-05-15 09:21:10 +00:00
|
|
|
if (pressed) {
|
|
|
|
|
if (p_deadzone == 1.0f) {
|
|
|
|
|
*p_strength = 1.0f;
|
|
|
|
|
} else {
|
2021-07-28 18:42:21 +00:00
|
|
|
*p_strength = CLAMP(Math::inverse_lerp(p_deadzone, 1.0f, jm_abs_axis_value), 0.0f, 1.0f);
|
2019-05-15 09:21:10 +00:00
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
*p_strength = 0.0f;
|
|
|
|
|
}
|
|
|
|
|
}
|
2021-07-28 18:42:21 +00:00
|
|
|
if (p_raw_strength != nullptr) {
|
|
|
|
|
if (same_direction) { // NOT pressed, because we want to ignore the deadzone.
|
|
|
|
|
*p_raw_strength = jm_abs_axis_value;
|
|
|
|
|
} else {
|
|
|
|
|
*p_raw_strength = 0.0f;
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
}
|
|
|
|
|
return match;
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
|
|
|
|
|
2021-09-16 05:09:40 +00:00
|
|
|
bool InputEventJoypadMotion::shortcut_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
|
|
|
|
|
Ref<InputEventJoypadMotion> jm = p_event;
|
|
|
|
|
if (jm.is_null()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return axis == jm->axis &&
|
2021-10-28 11:23:24 +00:00
|
|
|
(!p_exact_match || ((axis_value < 0) == (jm->axis_value < 0)));
|
2021-09-16 05:09:40 +00:00
|
|
|
}
|
|
|
|
|
|
2017-08-24 16:14:36 +00:00
|
|
|
String InputEventJoypadMotion::as_text() const {
|
|
|
|
|
return "InputEventJoypadMotion : axis=" + itos(axis) + ", axis_value=" + String(Variant(axis_value));
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventJoypadMotion::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_axis", "axis"), &InputEventJoypadMotion::set_axis);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_axis"), &InputEventJoypadMotion::get_axis);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_axis_value", "axis_value"), &InputEventJoypadMotion::set_axis_value);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_axis_value"), &InputEventJoypadMotion::get_axis_value);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "axis"), "set_axis", "get_axis");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "axis_value"), "set_axis_value", "get_axis_value");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventJoypadMotion::InputEventJoypadMotion() {
|
|
|
|
|
axis = 0;
|
|
|
|
|
axis_value = 0;
|
|
|
|
|
}
|
|
|
|
|
/////////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventJoypadButton::set_button_index(int p_index) {
|
|
|
|
|
button_index = p_index;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventJoypadButton::get_button_index() const {
|
|
|
|
|
return button_index;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventJoypadButton::set_pressed(bool p_pressed) {
|
|
|
|
|
pressed = p_pressed;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventJoypadButton::is_pressed() const {
|
|
|
|
|
return pressed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventJoypadButton::set_pressure(float p_pressure) {
|
|
|
|
|
pressure = p_pressure;
|
|
|
|
|
}
|
|
|
|
|
float InputEventJoypadButton::get_pressure() const {
|
|
|
|
|
return pressure;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-24 05:10:06 +00:00
|
|
|
bool InputEventJoypadButton::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
|
2017-05-20 15:38:03 +00:00
|
|
|
Ref<InputEventJoypadButton> jb = p_event;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (jb.is_null()) {
|
2017-05-20 15:38:03 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2017-05-20 15:38:03 +00:00
|
|
|
|
2018-02-21 21:06:34 +00:00
|
|
|
bool match = button_index == jb->button_index;
|
|
|
|
|
if (match) {
|
2021-08-15 23:23:50 +00:00
|
|
|
bool pressed = jb->is_pressed();
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_pressed != nullptr) {
|
2021-08-15 23:23:50 +00:00
|
|
|
*p_pressed = pressed;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2021-08-15 23:23:50 +00:00
|
|
|
float strength = pressed ? 1.0f : 0.0f;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_strength != nullptr) {
|
2021-07-28 18:42:21 +00:00
|
|
|
*p_strength = strength;
|
|
|
|
|
}
|
|
|
|
|
if (p_raw_strength != nullptr) {
|
|
|
|
|
*p_raw_strength = strength;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2018-02-21 21:06:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return match;
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
|
|
|
|
|
2021-09-16 05:09:40 +00:00
|
|
|
bool InputEventJoypadButton::shortcut_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
|
2019-02-15 23:26:07 +00:00
|
|
|
Ref<InputEventJoypadButton> button = p_event;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (button.is_null()) {
|
2019-02-15 23:26:07 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2019-02-15 23:26:07 +00:00
|
|
|
|
|
|
|
|
return button_index == button->button_index;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-24 16:14:36 +00:00
|
|
|
String InputEventJoypadButton::as_text() const {
|
|
|
|
|
return "InputEventJoypadButton : button_index=" + itos(button_index) + ", pressed=" + (pressed ? "true" : "false") + ", pressure=" + String(Variant(pressure));
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventJoypadButton::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventJoypadButton::set_button_index);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventJoypadButton::get_button_index);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventJoypadButton::set_pressure);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventJoypadButton::get_pressure);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventJoypadButton::set_pressed);
|
|
|
|
|
// ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventJoypadButton::is_pressed);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "pressure"), "set_pressure", "get_pressure");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventJoypadButton::InputEventJoypadButton() {
|
|
|
|
|
button_index = 0;
|
|
|
|
|
pressure = 0;
|
|
|
|
|
pressed = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventScreenTouch::set_index(int p_index) {
|
|
|
|
|
index = p_index;
|
|
|
|
|
}
|
|
|
|
|
int InputEventScreenTouch::get_index() const {
|
|
|
|
|
return index;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
void InputEventScreenTouch::set_position(const Vector2 &p_pos) {
|
2017-05-20 15:38:03 +00:00
|
|
|
pos = p_pos;
|
|
|
|
|
}
|
2017-06-03 08:54:24 +00:00
|
|
|
Vector2 InputEventScreenTouch::get_position() const {
|
2017-05-20 15:38:03 +00:00
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventScreenTouch::set_pressed(bool p_pressed) {
|
|
|
|
|
pressed = p_pressed;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventScreenTouch::is_pressed() const {
|
|
|
|
|
return pressed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ref<InputEvent> InputEventScreenTouch::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
|
|
|
|
|
Ref<InputEventScreenTouch> st;
|
|
|
|
|
st.instance();
|
|
|
|
|
st->set_device(get_device());
|
|
|
|
|
st->set_index(index);
|
2017-06-03 08:54:24 +00:00
|
|
|
st->set_position(p_xform.xform(pos + p_local_ofs));
|
2017-05-20 15:38:03 +00:00
|
|
|
st->set_pressed(pressed);
|
|
|
|
|
|
|
|
|
|
return st;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-24 16:14:36 +00:00
|
|
|
String InputEventScreenTouch::as_text() const {
|
|
|
|
|
return "InputEventScreenTouch : index=" + itos(index) + ", pressed=" + (pressed ? "true" : "false") + ", position=(" + String(get_position()) + ")";
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventScreenTouch::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_index", "index"), &InputEventScreenTouch::set_index);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_index"), &InputEventScreenTouch::get_index);
|
|
|
|
|
|
2017-09-10 13:37:49 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventScreenTouch::set_position);
|
2017-06-03 08:54:24 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("get_position"), &InputEventScreenTouch::get_position);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventScreenTouch::set_pressed);
|
|
|
|
|
//ClassDB::bind_method(D_METHOD("is_pressed"),&InputEventScreenTouch::is_pressed);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index");
|
2017-06-03 08:54:24 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
|
2017-05-20 15:38:03 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventScreenTouch::InputEventScreenTouch() {
|
|
|
|
|
index = 0;
|
|
|
|
|
pressed = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventScreenDrag::set_index(int p_index) {
|
|
|
|
|
index = p_index;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventScreenDrag::get_index() const {
|
|
|
|
|
return index;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
void InputEventScreenDrag::set_position(const Vector2 &p_pos) {
|
2017-05-20 15:38:03 +00:00
|
|
|
pos = p_pos;
|
|
|
|
|
}
|
2017-06-03 08:54:24 +00:00
|
|
|
Vector2 InputEventScreenDrag::get_position() const {
|
2017-05-20 15:38:03 +00:00
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventScreenDrag::set_relative(const Vector2 &p_relative) {
|
|
|
|
|
relative = p_relative;
|
|
|
|
|
}
|
|
|
|
|
Vector2 InputEventScreenDrag::get_relative() const {
|
|
|
|
|
return relative;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventScreenDrag::set_speed(const Vector2 &p_speed) {
|
|
|
|
|
speed = p_speed;
|
|
|
|
|
}
|
|
|
|
|
Vector2 InputEventScreenDrag::get_speed() const {
|
|
|
|
|
return speed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ref<InputEvent> InputEventScreenDrag::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
|
|
|
|
|
Ref<InputEventScreenDrag> sd;
|
|
|
|
|
|
|
|
|
|
sd.instance();
|
|
|
|
|
|
|
|
|
|
sd->set_device(get_device());
|
|
|
|
|
|
|
|
|
|
sd->set_index(index);
|
2017-06-03 08:54:24 +00:00
|
|
|
sd->set_position(p_xform.xform(pos + p_local_ofs));
|
2017-05-20 15:38:03 +00:00
|
|
|
sd->set_relative(p_xform.basis_xform(relative));
|
|
|
|
|
sd->set_speed(p_xform.basis_xform(speed));
|
|
|
|
|
|
|
|
|
|
return sd;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-24 16:14:36 +00:00
|
|
|
String InputEventScreenDrag::as_text() const {
|
|
|
|
|
return "InputEventScreenDrag : index=" + itos(index) + ", position=(" + String(get_position()) + "), relative=(" + String(get_relative()) + "), speed=(" + String(get_speed()) + ")";
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-20 19:30:34 +00:00
|
|
|
bool InputEventScreenDrag::accumulate(const Ref<InputEvent> &p_event) {
|
|
|
|
|
Ref<InputEventScreenDrag> drag = p_event;
|
|
|
|
|
if (drag.is_null())
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if (get_index() != drag->get_index()) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set_position(drag->get_position());
|
|
|
|
|
set_speed(drag->get_speed());
|
|
|
|
|
relative += drag->get_relative();
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventScreenDrag::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_index", "index"), &InputEventScreenDrag::set_index);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_index"), &InputEventScreenDrag::get_index);
|
|
|
|
|
|
2017-06-03 08:54:24 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventScreenDrag::set_position);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_position"), &InputEventScreenDrag::get_position);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventScreenDrag::set_relative);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_relative"), &InputEventScreenDrag::get_relative);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventScreenDrag::set_speed);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_speed"), &InputEventScreenDrag::get_speed);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index");
|
2017-06-03 08:54:24 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
|
2017-05-20 15:38:03 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventScreenDrag::InputEventScreenDrag() {
|
|
|
|
|
index = 0;
|
|
|
|
|
}
|
|
|
|
|
/////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventAction::set_action(const StringName &p_action) {
|
|
|
|
|
action = p_action;
|
|
|
|
|
}
|
|
|
|
|
StringName InputEventAction::get_action() const {
|
|
|
|
|
return action;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventAction::set_pressed(bool p_pressed) {
|
|
|
|
|
pressed = p_pressed;
|
|
|
|
|
}
|
|
|
|
|
bool InputEventAction::is_pressed() const {
|
|
|
|
|
return pressed;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-01 13:31:47 +00:00
|
|
|
void InputEventAction::set_strength(float p_strength) {
|
|
|
|
|
strength = CLAMP(p_strength, 0.0f, 1.0f);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
float InputEventAction::get_strength() const {
|
|
|
|
|
return strength;
|
|
|
|
|
}
|
|
|
|
|
|
2021-09-16 05:09:40 +00:00
|
|
|
bool InputEventAction::shortcut_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_event.is_null()) {
|
2018-07-27 11:02:30 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2018-07-27 11:02:30 +00:00
|
|
|
|
2019-02-15 23:26:07 +00:00
|
|
|
return p_event->is_action(action);
|
2018-07-27 11:02:30 +00:00
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
bool InputEventAction::is_action(const StringName &p_action) const {
|
|
|
|
|
return action == p_action;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-24 05:10:06 +00:00
|
|
|
bool InputEventAction::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
|
2018-09-10 19:15:06 +00:00
|
|
|
Ref<InputEventAction> act = p_event;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (act.is_null()) {
|
2018-09-10 19:15:06 +00:00
|
|
|
return false;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2018-09-10 19:15:06 +00:00
|
|
|
|
|
|
|
|
bool match = action == act->action;
|
|
|
|
|
if (match) {
|
2021-08-15 23:23:50 +00:00
|
|
|
bool pressed = act->pressed;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_pressed != nullptr) {
|
2021-08-15 23:23:50 +00:00
|
|
|
*p_pressed = pressed;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2021-08-15 23:23:50 +00:00
|
|
|
float strength = pressed ? 1.0f : 0.0f;
|
2021-05-05 10:44:11 +00:00
|
|
|
if (p_strength != nullptr) {
|
2021-07-28 18:42:21 +00:00
|
|
|
*p_strength = strength;
|
|
|
|
|
}
|
|
|
|
|
if (p_raw_strength != nullptr) {
|
|
|
|
|
*p_raw_strength = strength;
|
2021-05-05 10:44:11 +00:00
|
|
|
}
|
2018-09-10 19:15:06 +00:00
|
|
|
}
|
|
|
|
|
return match;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-24 16:14:36 +00:00
|
|
|
String InputEventAction::as_text() const {
|
|
|
|
|
return "InputEventAction : action=" + action + ", pressed=(" + (pressed ? "true" : "false");
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
void InputEventAction::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_action", "action"), &InputEventAction::set_action);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_action"), &InputEventAction::get_action);
|
|
|
|
|
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventAction::set_pressed);
|
|
|
|
|
//ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventAction::is_pressed);
|
|
|
|
|
|
2019-06-01 13:31:47 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_strength", "strength"), &InputEventAction::set_strength);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_strength"), &InputEventAction::get_strength);
|
|
|
|
|
|
2017-05-23 12:06:22 +00:00
|
|
|
// ClassDB::bind_method(D_METHOD("is_action", "name"), &InputEventAction::is_action);
|
2017-05-20 15:38:03 +00:00
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "action"), "set_action", "get_action");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
|
2019-06-01 13:31:47 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "strength", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_strength", "get_strength");
|
2017-05-20 15:38:03 +00:00
|
|
|
}
|
2016-06-27 12:59:43 +00:00
|
|
|
|
2017-05-20 15:38:03 +00:00
|
|
|
InputEventAction::InputEventAction() {
|
|
|
|
|
pressed = false;
|
2019-06-01 13:31:47 +00:00
|
|
|
strength = 1.0f;
|
2016-06-27 12:59:43 +00:00
|
|
|
}
|
2017-11-01 20:49:39 +00:00
|
|
|
/////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventGesture::set_position(const Vector2 &p_pos) {
|
|
|
|
|
pos = p_pos;
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-24 18:22:33 +00:00
|
|
|
void InputEventGesture::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventGesture::set_position);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_position"), &InputEventGesture::get_position);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-01 20:49:39 +00:00
|
|
|
Vector2 InputEventGesture::get_position() const {
|
|
|
|
|
return pos;
|
|
|
|
|
}
|
|
|
|
|
/////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventMagnifyGesture::set_factor(real_t p_factor) {
|
|
|
|
|
factor = p_factor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
real_t InputEventMagnifyGesture::get_factor() const {
|
|
|
|
|
return factor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ref<InputEvent> InputEventMagnifyGesture::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
|
|
|
|
|
Ref<InputEventMagnifyGesture> ev;
|
|
|
|
|
ev.instance();
|
|
|
|
|
|
|
|
|
|
ev->set_device(get_device());
|
|
|
|
|
ev->set_modifiers_from_event(this);
|
|
|
|
|
|
|
|
|
|
ev->set_position(p_xform.xform(get_position() + p_local_ofs));
|
|
|
|
|
ev->set_factor(get_factor());
|
|
|
|
|
|
|
|
|
|
return ev;
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-24 03:25:50 +00:00
|
|
|
String InputEventMagnifyGesture::as_text() const {
|
|
|
|
|
return "InputEventMagnifyGesture : factor=" + rtos(get_factor()) + ", position=(" + String(get_position()) + ")";
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-24 18:22:33 +00:00
|
|
|
void InputEventMagnifyGesture::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_factor", "factor"), &InputEventMagnifyGesture::set_factor);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_factor"), &InputEventMagnifyGesture::get_factor);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "factor"), "set_factor", "get_factor");
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-01 20:49:39 +00:00
|
|
|
InputEventMagnifyGesture::InputEventMagnifyGesture() {
|
|
|
|
|
factor = 1.0;
|
|
|
|
|
}
|
|
|
|
|
/////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventPanGesture::set_delta(const Vector2 &p_delta) {
|
|
|
|
|
delta = p_delta;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Vector2 InputEventPanGesture::get_delta() const {
|
|
|
|
|
return delta;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ref<InputEvent> InputEventPanGesture::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
|
|
|
|
|
Ref<InputEventPanGesture> ev;
|
|
|
|
|
ev.instance();
|
|
|
|
|
|
|
|
|
|
ev->set_device(get_device());
|
|
|
|
|
ev->set_modifiers_from_event(this);
|
|
|
|
|
|
|
|
|
|
ev->set_position(p_xform.xform(get_position() + p_local_ofs));
|
|
|
|
|
ev->set_delta(get_delta());
|
|
|
|
|
|
|
|
|
|
return ev;
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-24 03:25:50 +00:00
|
|
|
String InputEventPanGesture::as_text() const {
|
|
|
|
|
return "InputEventPanGesture : delta=(" + String(get_delta()) + "), position=(" + String(get_position()) + ")";
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-24 18:22:33 +00:00
|
|
|
void InputEventPanGesture::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_delta", "delta"), &InputEventPanGesture::set_delta);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_delta"), &InputEventPanGesture::get_delta);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "delta"), "set_delta", "get_delta");
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-01 20:49:39 +00:00
|
|
|
InputEventPanGesture::InputEventPanGesture() {
|
|
|
|
|
delta = Vector2(0, 0);
|
|
|
|
|
}
|
2018-07-14 12:11:28 +00:00
|
|
|
/////////////////////////////
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::set_channel(const int p_channel) {
|
|
|
|
|
channel = p_channel;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventMIDI::get_channel() const {
|
|
|
|
|
return channel;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::set_message(const int p_message) {
|
|
|
|
|
message = p_message;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventMIDI::get_message() const {
|
|
|
|
|
return message;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::set_pitch(const int p_pitch) {
|
|
|
|
|
pitch = p_pitch;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventMIDI::get_pitch() const {
|
|
|
|
|
return pitch;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::set_velocity(const int p_velocity) {
|
|
|
|
|
velocity = p_velocity;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventMIDI::get_velocity() const {
|
|
|
|
|
return velocity;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::set_instrument(const int p_instrument) {
|
|
|
|
|
instrument = p_instrument;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventMIDI::get_instrument() const {
|
|
|
|
|
return instrument;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::set_pressure(const int p_pressure) {
|
|
|
|
|
pressure = p_pressure;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventMIDI::get_pressure() const {
|
|
|
|
|
return pressure;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::set_controller_number(const int p_controller_number) {
|
|
|
|
|
controller_number = p_controller_number;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventMIDI::get_controller_number() const {
|
|
|
|
|
return controller_number;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::set_controller_value(const int p_controller_value) {
|
|
|
|
|
controller_value = p_controller_value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int InputEventMIDI::get_controller_value() const {
|
|
|
|
|
return controller_value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
String InputEventMIDI::as_text() const {
|
|
|
|
|
return "InputEventMIDI : channel=(" + itos(get_channel()) + "), message=(" + itos(get_message()) + ")";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void InputEventMIDI::_bind_methods() {
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_channel", "channel"), &InputEventMIDI::set_channel);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_channel"), &InputEventMIDI::get_channel);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_message", "message"), &InputEventMIDI::set_message);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_message"), &InputEventMIDI::get_message);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pitch", "pitch"), &InputEventMIDI::set_pitch);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_pitch"), &InputEventMIDI::get_pitch);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_velocity", "velocity"), &InputEventMIDI::set_velocity);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_velocity"), &InputEventMIDI::get_velocity);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_instrument", "instrument"), &InputEventMIDI::set_instrument);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_instrument"), &InputEventMIDI::get_instrument);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventMIDI::set_pressure);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventMIDI::get_pressure);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_controller_number", "controller_number"), &InputEventMIDI::set_controller_number);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_controller_number"), &InputEventMIDI::get_controller_number);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("set_controller_value", "controller_value"), &InputEventMIDI::set_controller_value);
|
|
|
|
|
ClassDB::bind_method(D_METHOD("get_controller_value"), &InputEventMIDI::get_controller_value);
|
|
|
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "channel"), "set_channel", "get_channel");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "message"), "set_message", "get_message");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "pitch"), "set_pitch", "get_pitch");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "velocity"), "set_velocity", "get_velocity");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "instrument"), "set_instrument", "get_instrument");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "pressure"), "set_pressure", "get_pressure");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "controller_number"), "set_controller_number", "get_controller_number");
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "controller_value"), "set_controller_value", "get_controller_value");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
InputEventMIDI::InputEventMIDI() {
|
|
|
|
|
channel = 0;
|
|
|
|
|
message = 0;
|
|
|
|
|
pitch = 0;
|
|
|
|
|
velocity = 0;
|
|
|
|
|
instrument = 0;
|
|
|
|
|
pressure = 0;
|
|
|
|
|
controller_number = 0;
|
|
|
|
|
controller_value = 0;
|
|
|
|
|
}
|
