godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/core/input/input_event.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1851 lines
61 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/**************************************************************************/
/* input_event.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-04 23:50:27 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "input_event.h"
Dead code tells no tales
2017-08-27 19:07:15 +00:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
#include "core/input/input_map.h"
Entirely removes BIND_VMETHOD in favor of GDVIRTUAL * `_gui_input`, `_input`, `_unhandled_input` and `_unhandled_key_input` are now regular C++ virutal functions. * Everything else converted to GDVIRTUAL * BIND_VMETHOD is gone, always use the new syntax from now on. Creating `_gui_input` method and using the binder to register events will no longer work, simply override the virtual function now.
2021-08-22 15:37:22 +00:00
#include "core/input/shortcut.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 16:13:45 +00:00
#include "core/os/keyboard.h"
[Web] Detect host OS and use macOS keys on mac hosts.
2022-11-14 14:27:26 +00:00
#include "core/os/os.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix mouse/drag/touch InputEvents having no device id Some internally created emulated/instantiated events didn't have a device id. This PR sets for these cases a device id. Also rename `DEVICE_ID_TOUCH_MOUSE` to the more generic `DEVICE_ID_EMULATION`.
2023-02-04 22:16:54 +00:00
const int InputEvent::DEVICE_ID_EMULATION = -1;
Fix fake null-motion mouse event flood This commit also improves a bit the code quality by making the intent of fake events (and themselves) more explicit. Fixes #26460.
2019-03-09 21:03:27 +00:00
const int InputEvent::DEVICE_ID_INTERNAL = -2;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEvent::set_device(int p_device) {
device = p_device;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
int InputEvent::get_device() const {
return device;
GODOT IS OPEN SOURCE
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) ```
2020-12-13 14:22:42 +00:00
bool InputEvent::is_action(const StringName &p_action, bool p_exact_match) const {
Fix some issues found by cppcheck.
2022-04-05 10:40:26 +00:00
return InputMap::get_singleton()->event_is_action(Ref<InputEvent>(const_cast<InputEvent *>(this)), p_action, p_exact_match);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
GODOT IS OPEN SOURCE
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) ```
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 {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
bool pressed_state;
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>(const_cast<InputEvent *>(this)), p_action, p_exact_match, &pressed_state, nullptr, nullptr);
return valid && pressed_state && (p_allow_echo || !is_echo());
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Allow actions to provide an analog value
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) ```
2020-12-13 14:22:42 +00:00
bool InputEvent::is_action_released(const StringName &p_action, bool p_exact_match) const {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
bool pressed_state;
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>(const_cast<InputEvent *>(this)), p_action, p_exact_match, &pressed_state, nullptr, nullptr);
return valid && !pressed_state;
Allow actions to provide an analog value
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) ```
2020-12-13 14:22:42 +00:00
float InputEvent::get_action_strength(const StringName &p_action, bool p_exact_match) const {
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
float strength;
Fix some issues found by cppcheck.
2022-04-05 10:40:26 +00:00
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>(const_cast<InputEvent *>(this)), p_action, p_exact_match, nullptr, &strength, nullptr);
Allow actions to provide an analog value
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) ```
2020-12-13 14:22:42 +00:00
float InputEvent::get_action_raw_strength(const StringName &p_action, bool p_exact_match) const {
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
float raw_strength;
Fix some issues found by cppcheck.
2022-04-05 10:40:26 +00:00
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>(const_cast<InputEvent *>(this)), p_action, p_exact_match, nullptr, nullptr, &raw_strength);
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
return valid ? raw_strength : 0.0f;
}
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
bool InputEvent::is_canceled() const {
return canceled;
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
bool InputEvent::is_pressed() const {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
return pressed && !canceled;
}
bool InputEvent::is_released() const {
return !pressed && !canceled;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
bool InputEvent::is_echo() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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 {
Fix some issues found by cppcheck.
2022-04-05 10:40:26 +00:00
return Ref<InputEvent>(const_cast<InputEvent *>(this));
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Fix action exact match
2021-10-24 03:38:32 +00:00
bool InputEvent::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, float p_deadzone, bool *r_pressed, float *r_strength, float *r_raw_strength) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return false;
}
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
bool InputEvent::is_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
return false;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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) ```
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));
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
ClassDB::bind_method(D_METHOD("is_canceled"), &InputEvent::is_canceled);
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
ClassDB::bind_method(D_METHOD("is_pressed"), &InputEvent::is_pressed);
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
ClassDB::bind_method(D_METHOD("is_released"), &InputEvent::is_released);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
ClassDB::bind_method(D_METHOD("is_match", "event", "exact_match"), &InputEvent::is_match, DEFVAL(true));
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ClassDB::bind_method(D_METHOD("is_action_type"), &InputEvent::is_action_type);
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
ClassDB::bind_method(D_METHOD("accumulate", "with_event"), &InputEvent::accumulate);
Removes type information from method binds
2017-08-09 11:19:41 +00:00
ClassDB::bind_method(D_METHOD("xformed_by", "xform", "local_ofs"), &InputEvent::xformed_by, DEFVAL(Vector2()));
Make the InputEvent device property get saved Fixes #9299
2017-06-24 13:28:19 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "device"), "set_device", "get_device");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
void InputEventFromWindow::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_window_id", "id"), &InputEventFromWindow::set_window_id);
ClassDB::bind_method(D_METHOD("get_window_id"), &InputEventFromWindow::get_window_id);
ADD_PROPERTY(PropertyInfo(Variant::INT, "window_id"), "set_window_id", "get_window_id");
}
void InputEventFromWindow::set_window_id(int64_t p_id) {
window_id = p_id;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
int64_t InputEventFromWindow::get_window_id() const {
return window_id;
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
void InputEventWithModifiers::set_command_or_control_autoremap(bool p_enabled) {
command_or_control_autoremap = p_enabled;
if (command_or_control_autoremap) {
[Web] Detect host OS and use macOS keys on mac hosts.
2022-11-14 14:27:26 +00:00
if (OS::get_singleton()->has_feature("macos") || OS::get_singleton()->has_feature("web_macos") || OS::get_singleton()->has_feature("web_ios")) {
ctrl_pressed = false;
meta_pressed = true;
} else {
ctrl_pressed = true;
meta_pressed = false;
}
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
} else {
ctrl_pressed = false;
meta_pressed = false;
}
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Made serialization of Command toggleable when saving InputEvents. Made serialization of Command optional. If command is serialized, Control (On Win/Linux) or Meta (on Mac) are not. Example use case: You are on Windows and you set a shortcut to be Control + E. This would serialize as Command=true and Control=true. If you then run this project on Mac, you would need to press Command AND Control to activate the shortcut - which is not what is intended. Now, you can set store_command to true, and it will only serialize to Command = true (no Control serialized). On Windows, this means Control. On Mac, it means only command.
2020-09-28 14:23:51 +00:00
}
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
bool InputEventWithModifiers::is_command_or_control_autoremap() const {
return command_or_control_autoremap;
}
bool InputEventWithModifiers::is_command_or_control_pressed() const {
[Web] Detect host OS and use macOS keys on mac hosts.
2022-11-14 14:27:26 +00:00
if (OS::get_singleton()->has_feature("macos") || OS::get_singleton()->has_feature("web_macos") || OS::get_singleton()->has_feature("web_ios")) {
return meta_pressed;
} else {
return ctrl_pressed;
}
Made serialization of Command toggleable when saving InputEvents. Made serialization of Command optional. If command is serialized, Control (On Win/Linux) or Meta (on Mac) are not. Example use case: You are on Windows and you set a shortcut to be Control + E. This would serialize as Command=true and Control=true. If you then run this project on Mac, you would need to press Command AND Control to activate the shortcut - which is not what is intended. Now, you can set store_command to true, and it will only serialize to Command = true (no Control serialized). On Windows, this means Control. On Mac, it means only command.
2020-09-28 14:23:51 +00:00
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
void InputEventWithModifiers::set_shift_pressed(bool p_enabled) {
shift_pressed = p_enabled;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
bool InputEventWithModifiers::is_shift_pressed() const {
return shift_pressed;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
void InputEventWithModifiers::set_alt_pressed(bool p_enabled) {
alt_pressed = p_enabled;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
bool InputEventWithModifiers::is_alt_pressed() const {
return alt_pressed;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
void InputEventWithModifiers::set_ctrl_pressed(bool p_enabled) {
Fix typo on "autoremapping". Update warning strings to be consistent with the rest of the code base, which uses "Command or Control".
2023-03-28 23:48:18 +00:00
ERR_FAIL_COND_MSG(command_or_control_autoremap, "Command or Control autoremapping is enabled, cannot set Control directly!");
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
ctrl_pressed = p_enabled;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
bool InputEventWithModifiers::is_ctrl_pressed() const {
return ctrl_pressed;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
void InputEventWithModifiers::set_meta_pressed(bool p_enabled) {
Fix typo on "autoremapping". Update warning strings to be consistent with the rest of the code base, which uses "Command or Control".
2023-03-28 23:48:18 +00:00
ERR_FAIL_COND_MSG(command_or_control_autoremap, "Command or Control autoremapping is enabled, cannot set Meta directly!");
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
meta_pressed = p_enabled;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
bool InputEventWithModifiers::is_meta_pressed() const {
return meta_pressed;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
void InputEventWithModifiers::set_modifiers_from_event(const InputEventWithModifiers *event) {
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
set_alt_pressed(event->is_alt_pressed());
set_shift_pressed(event->is_shift_pressed());
set_ctrl_pressed(event->is_ctrl_pressed());
set_meta_pressed(event->is_meta_pressed());
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
}
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
BitField<KeyModifierMask> InputEventWithModifiers::get_modifiers_mask() const {
BitField<KeyModifierMask> mask;
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
if (is_ctrl_pressed()) {
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
mask.set_flag(KeyModifierMask::CTRL);
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
}
if (is_shift_pressed()) {
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
mask.set_flag(KeyModifierMask::SHIFT);
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
}
if (is_alt_pressed()) {
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
mask.set_flag(KeyModifierMask::ALT);
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
}
if (is_meta_pressed()) {
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
mask.set_flag(KeyModifierMask::META);
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
}
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
if (is_command_or_control_autoremap()) {
[Web] Detect host OS and use macOS keys on mac hosts.
2022-11-14 14:27:26 +00:00
if (OS::get_singleton()->has_feature("macos") || OS::get_singleton()->has_feature("web_macos") || OS::get_singleton()->has_feature("web_ios")) {
mask.set_flag(KeyModifierMask::META);
} else {
mask.set_flag(KeyModifierMask::CTRL);
}
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
}
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
return mask;
}
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
String InputEventWithModifiers::as_text() const {
Vector<String> mod_names;
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
if (is_ctrl_pressed()) {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
mod_names.push_back(find_keycode_name(Key::CTRL));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
if (is_shift_pressed()) {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
mod_names.push_back(find_keycode_name(Key::SHIFT));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
if (is_alt_pressed()) {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
mod_names.push_back(find_keycode_name(Key::ALT));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
if (is_meta_pressed()) {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
mod_names.push_back(find_keycode_name(Key::META));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
if (!mod_names.is_empty()) {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
return String("+").join(mod_names);
} else {
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 02:42:42 +00:00
return "";
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
}
String InputEventWithModifiers::to_string() {
return as_text();
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventWithModifiers::_bind_methods() {
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
ClassDB::bind_method(D_METHOD("set_command_or_control_autoremap", "enable"), &InputEventWithModifiers::set_command_or_control_autoremap);
ClassDB::bind_method(D_METHOD("is_command_or_control_autoremap"), &InputEventWithModifiers::is_command_or_control_autoremap);
ClassDB::bind_method(D_METHOD("is_command_or_control_pressed"), &InputEventWithModifiers::is_command_or_control_pressed);
Made serialization of Command toggleable when saving InputEvents. Made serialization of Command optional. If command is serialized, Control (On Win/Linux) or Meta (on Mac) are not. Example use case: You are on Windows and you set a shortcut to be Control + E. This would serialize as Command=true and Control=true. If you then run this project on Mac, you would need to press Command AND Control to activate the shortcut - which is not what is intended. Now, you can set store_command to true, and it will only serialize to Command = true (no Control serialized). On Windows, this means Control. On Mac, it means only command.
2020-09-28 14:23:51 +00:00
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
ClassDB::bind_method(D_METHOD("set_alt_pressed", "pressed"), &InputEventWithModifiers::set_alt_pressed);
ClassDB::bind_method(D_METHOD("is_alt_pressed"), &InputEventWithModifiers::is_alt_pressed);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
ClassDB::bind_method(D_METHOD("set_shift_pressed", "pressed"), &InputEventWithModifiers::set_shift_pressed);
ClassDB::bind_method(D_METHOD("is_shift_pressed"), &InputEventWithModifiers::is_shift_pressed);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
ClassDB::bind_method(D_METHOD("set_ctrl_pressed", "pressed"), &InputEventWithModifiers::set_ctrl_pressed);
ClassDB::bind_method(D_METHOD("is_ctrl_pressed"), &InputEventWithModifiers::is_ctrl_pressed);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
ClassDB::bind_method(D_METHOD("set_meta_pressed", "pressed"), &InputEventWithModifiers::set_meta_pressed);
ClassDB::bind_method(D_METHOD("is_meta_pressed"), &InputEventWithModifiers::is_meta_pressed);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
ClassDB::bind_method(D_METHOD("get_modifiers_mask"), &InputEventWithModifiers::get_modifiers_mask);
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "command_or_control_autoremap"), "set_command_or_control_autoremap", "is_command_or_control_autoremap");
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "alt_pressed"), "set_alt_pressed", "is_alt_pressed");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "shift_pressed"), "set_shift_pressed", "is_shift_pressed");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "ctrl_pressed"), "set_ctrl_pressed", "is_ctrl_pressed");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "meta_pressed"), "set_meta_pressed", "is_meta_pressed");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Make `_validate_property` a multilevel method
2022-08-12 20:57:11 +00:00
void InputEventWithModifiers::_validate_property(PropertyInfo &p_property) const {
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
if (command_or_control_autoremap) {
// Cannot be used with Meta/Command or Control!
Make `_validate_property` a multilevel method
2022-08-12 20:57:11 +00:00
if (p_property.name == "meta_pressed") {
p_property.usage ^= PROPERTY_USAGE_STORAGE;
Made serialization of Command toggleable when saving InputEvents. Made serialization of Command optional. If command is serialized, Control (On Win/Linux) or Meta (on Mac) are not. Example use case: You are on Windows and you set a shortcut to be Control + E. This would serialize as Command=true and Control=true. If you then run this project on Mac, you would need to press Command AND Control to activate the shortcut - which is not what is intended. Now, you can set store_command to true, and it will only serialize to Command = true (no Control serialized). On Windows, this means Control. On Mac, it means only command.
2020-09-28 14:23:51 +00:00
}
Make `_validate_property` a multilevel method
2022-08-12 20:57:11 +00:00
if (p_property.name == "ctrl_pressed") {
p_property.usage ^= PROPERTY_USAGE_STORAGE;
Made serialization of Command toggleable when saving InputEvents. Made serialization of Command optional. If command is serialized, Control (On Win/Linux) or Meta (on Mac) are not. Example use case: You are on Windows and you set a shortcut to be Control + E. This would serialize as Command=true and Control=true. If you then run this project on Mac, you would need to press Command AND Control to activate the shortcut - which is not what is intended. Now, you can set store_command to true, and it will only serialize to Command = true (no Control serialized). On Windows, this means Control. On Mac, it means only command.
2020-09-28 14:23:51 +00:00
}
} else {
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
if (p_property.name == "command_or_control_autoremap") {
Make `_validate_property` a multilevel method
2022-08-12 20:57:11 +00:00
p_property.usage ^= PROPERTY_USAGE_STORAGE;
Made serialization of Command toggleable when saving InputEvents. Made serialization of Command optional. If command is serialized, Control (On Win/Linux) or Meta (on Mac) are not. Example use case: You are on Windows and you set a shortcut to be Control + E. This would serialize as Command=true and Control=true. If you then run this project on Mac, you would need to press Command AND Control to activate the shortcut - which is not what is intended. Now, you can set store_command to true, and it will only serialize to Command = true (no Control serialized). On Windows, this means Control. On Mac, it means only command.
2020-09-28 14:23:51 +00:00
}
}
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventKey::set_pressed(bool p_pressed) {
pressed = p_pressed;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Use Key enum instead of plain integers
2021-06-20 17:12:33 +00:00
void InputEventKey::set_keycode(Key p_keycode) {
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
keycode = p_keycode;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Use Key enum instead of plain integers
2021-06-20 17:12:33 +00:00
Key InputEventKey::get_keycode() const {
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
return keycode;
}
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
void InputEventKey::set_key_label(Key p_key_label) {
key_label = p_key_label;
emit_changed();
}
Key InputEventKey::get_key_label() const {
return key_label;
}
Use Key enum instead of plain integers
2021-06-20 17:12:33 +00:00
void InputEventKey::set_physical_keycode(Key p_keycode) {
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
physical_keycode = p_keycode;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
}
Use Key enum instead of plain integers
2021-06-20 17:12:33 +00:00
Key InputEventKey::get_physical_keycode() const {
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
return physical_keycode;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
void InputEventKey::set_unicode(char32_t p_unicode) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
unicode = p_unicode;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Added helper methods to InputEvent
2015-06-23 20:24:48 +00:00
}
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
char32_t InputEventKey::get_unicode() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return unicode;
}
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
void InputEventKey::set_location(KeyLocation p_key_location) {
location = p_key_location;
emit_changed();
}
KeyLocation InputEventKey::get_location() const {
return location;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventKey::set_echo(bool p_enable) {
echo = p_enable;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
bool InputEventKey::is_echo() const {
return echo;
Added helper methods to InputEvent
2015-06-23 20:24:48 +00:00
}
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
Key InputEventKey::get_keycode_with_modifiers() const {
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
return keycode | (int64_t)get_modifiers_mask();
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
}
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
Key InputEventKey::get_physical_keycode_with_modifiers() const {
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
return physical_keycode | (int64_t)get_modifiers_mask();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Properly deliver localized coordinates when passing gui events through parents, closes #4215
2016-06-27 12:59:43 +00:00
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
Key InputEventKey::get_key_label_with_modifiers() const {
return key_label | get_modifiers_mask();
}
String InputEventKey::as_text_physical_keycode() const {
String kc;
if (physical_keycode != Key::NONE) {
kc = keycode_get_string(physical_keycode);
} else {
kc = "(" + RTR("Unset") + ")";
}
if (kc.is_empty()) {
return kc;
}
String mods_text = InputEventWithModifiers::as_text();
return mods_text.is_empty() ? kc : mods_text + "+" + kc;
}
String InputEventKey::as_text_keycode() const {
String kc;
if (keycode != Key::NONE) {
kc = keycode_get_string(keycode);
} else {
kc = "(" + RTR("Unset") + ")";
}
if (kc.is_empty()) {
return kc;
}
String mods_text = InputEventWithModifiers::as_text();
return mods_text.is_empty() ? kc : mods_text + "+" + kc;
}
String InputEventKey::as_text_key_label() const {
String kc;
if (key_label != Key::NONE) {
kc = keycode_get_string(key_label);
} else {
kc = "(" + RTR("Unset") + ")";
}
if (kc.is_empty()) {
return kc;
}
String mods_text = InputEventWithModifiers::as_text();
return mods_text.is_empty() ? kc : mods_text + "+" + kc;
}
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
String InputEventKey::as_text_location() const {
String loc;
switch (location) {
case KeyLocation::LEFT:
loc = "left";
break;
case KeyLocation::RIGHT:
loc = "right";
break;
default:
break;
}
return loc;
}
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
String InputEventKey::as_text() const {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
String kc;
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
if (keycode == Key::NONE && physical_keycode == Key::NONE && key_label != Key::NONE) {
kc = keycode_get_string(key_label) + " (Unicode)";
} else if (keycode != Key::NONE) {
kc = keycode_get_string(keycode);
} else if (physical_keycode != Key::NONE) {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
kc = keycode_get_string(physical_keycode) + " (" + RTR("Physical") + ")";
} else {
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
kc = "(" + RTR("Unset") + ")";
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (kc.is_empty()) {
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
return kc;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
String mods_text = InputEventWithModifiers::as_text();
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
return mods_text.is_empty() ? kc : mods_text + "+" + kc;
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
String InputEventKey::to_string() {
String p = is_pressed() ? "true" : "false";
String e = is_echo() ? "true" : "false";
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 02:42:42 +00:00
String kc = "";
String physical = "false";
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
String loc = as_text_location();
if (loc.is_empty()) {
loc = "unspecified";
}
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
if (keycode == Key::NONE && physical_keycode == Key::NONE && unicode != 0) {
kc = "U+" + String::num_uint64(unicode, 16) + " (" + String::chr(unicode) + ")";
} else if (keycode != Key::NONE) {
kc = itos((int64_t)keycode) + " (" + keycode_get_string(keycode) + ")";
} else if (physical_keycode != Key::NONE) {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
kc = itos((int64_t)physical_keycode) + " (" + keycode_get_string(physical_keycode) + ")";
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 02:42:42 +00:00
physical = "true";
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
} else {
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
kc = "(" + RTR("Unset") + ")";
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
}
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 02:42:42 +00:00
String mods = InputEventWithModifiers::as_text();
String: Remove TTR and DTR defines in non-tools build This ensures we don't use TTR in runtime code, as it's specifically meant to source translations for the editor.
2022-03-28 13:24:14 +00:00
mods = mods.is_empty() ? "none" : mods;
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 02:42:42 +00:00
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
return vformat("InputEventKey: keycode=%s, mods=%s, physical=%s, location=%s, pressed=%s, echo=%s", kc, mods, physical, loc, p, e);
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
}
Use physical shortcuts for freelook navigation in the editor
2023-02-20 22:11:57 +00:00
Ref<InputEventKey> InputEventKey::create_reference(Key p_keycode, bool p_physical) {
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 11:31:25 +00:00
Ref<InputEventKey> ie;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
ie.instantiate();
Use physical shortcuts for freelook navigation in the editor
2023-02-20 22:11:57 +00:00
if (p_physical) {
ie->set_physical_keycode(p_keycode & KeyModifierMask::CODE_MASK);
} else {
ie->set_keycode(p_keycode & KeyModifierMask::CODE_MASK);
}
Fix various errors when running the unit tests Co-authored-by: bruvzg <7645683+bruvzg@users.noreply.github.com>
2023-05-09 13:50:48 +00:00
char32_t ch = char32_t(p_keycode & KeyModifierMask::CODE_MASK);
if (ch < 0xd800 || (ch > 0xdfff && ch <= 0x10ffff)) {
ie->set_unicode(ch);
}
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 11:31:25 +00:00
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
if ((p_keycode & KeyModifierMask::SHIFT) != Key::NONE) {
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
ie->set_shift_pressed(true);
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 11:31:25 +00:00
}
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
if ((p_keycode & KeyModifierMask::ALT) != Key::NONE) {
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
ie->set_alt_pressed(true);
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 11:31:25 +00:00
}
Fix key mapping changes when moving from macOS to other platform Removes separate `Command` key (use `Meta` instead). Adds an event flag to automatically remap `Command` <-> `Control` (cannot be set alongside `Control` or `Meta`).
2022-09-02 09:37:48 +00:00
if ((p_keycode & KeyModifierMask::CMD_OR_CTRL) != Key::NONE) {
ie->set_command_or_control_autoremap(true);
if ((p_keycode & KeyModifierMask::CTRL) != Key::NONE || (p_keycode & KeyModifierMask::META) != Key::NONE) {
WARN_PRINT("Invalid Key Modifiers: Command or Control autoremapping is enabled, Meta and Control values are ignored!");
}
} else {
if ((p_keycode & KeyModifierMask::CTRL) != Key::NONE) {
ie->set_ctrl_pressed(true);
}
if ((p_keycode & KeyModifierMask::META) != Key::NONE) {
ie->set_meta_pressed(true);
}
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 11:31:25 +00:00
}
return ie;
}
Fix action exact match
2021-10-24 03:38:32 +00:00
bool InputEventKey::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, float p_deadzone, bool *r_pressed, float *r_strength, float *r_raw_strength) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEventKey> key = p_event;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (key.is_null()) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Fix action exact match
2021-10-24 03:38:32 +00:00
bool match;
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
if (keycode == Key::NONE && physical_keycode == Key::NONE && key_label != Key::NONE) {
match = key_label == key->key_label;
} else if (keycode != Key::NONE) {
Fix action exact match
2021-10-24 03:38:32 +00:00
match = keycode == key->keycode;
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
} else if (physical_keycode != Key::NONE) {
match = physical_keycode == key->physical_keycode;
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
if (location != KeyLocation::UNSPECIFIED) {
match &= location == key->location;
}
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
} else {
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
match = false;
Fix action exact match
2021-10-24 03:38:32 +00:00
}
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
Key action_mask = (Key)(int64_t)get_modifiers_mask();
Key key_mask = (Key)(int64_t)key->get_modifiers_mask();
Ensure minimum modifiers are pressed when matching actions
2022-03-20 06:57:28 +00:00
if (key->is_pressed()) {
match &= (action_mask & key_mask) == action_mask;
}
Fix action exact match
2021-10-24 03:38:32 +00:00
if (p_exact_match) {
Ensure minimum modifiers are pressed when matching actions
2022-03-20 06:57:28 +00:00
match &= action_mask == key_mask;
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
if (match) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
bool key_pressed = key->is_pressed();
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_pressed != nullptr) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
*r_pressed = key_pressed;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
float strength = key_pressed ? 1.0f : 0.0f;
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_strength != nullptr) {
*r_strength = strength;
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
}
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_raw_strength != nullptr) {
*r_raw_strength = strength;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
}
return match;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
bool InputEventKey::is_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
Ref<InputEventKey> key = p_event;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (key.is_null()) {
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
if (keycode == Key::NONE && physical_keycode == Key::NONE && key_label != Key::NONE) {
return (key_label == key->key_label) &&
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 13:19:35 +00:00
(!p_exact_match || get_modifiers_mask() == key->get_modifiers_mask());
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
} else if (keycode != Key::NONE) {
return (keycode == key->keycode) &&
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 13:19:35 +00:00
(!p_exact_match || get_modifiers_mask() == key->get_modifiers_mask());
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
} else if (physical_keycode != Key::NONE) {
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
if (location != KeyLocation::UNSPECIFIED && location != key->location) {
return false;
}
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
return (physical_keycode == key->physical_keycode) &&
(!p_exact_match || get_modifiers_mask() == key->get_modifiers_mask());
} else {
return false;
Fix handling multiple "physical key" events in the single input map action.
2021-10-19 19:19:41 +00:00
}
Fix shortcuts, make them visible again and work.
2017-06-22 22:57:59 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventKey::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventKey::set_pressed);
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
ClassDB::bind_method(D_METHOD("set_keycode", "keycode"), &InputEventKey::set_keycode);
ClassDB::bind_method(D_METHOD("get_keycode"), &InputEventKey::get_keycode);
ClassDB::bind_method(D_METHOD("set_physical_keycode", "physical_keycode"), &InputEventKey::set_physical_keycode);
ClassDB::bind_method(D_METHOD("get_physical_keycode"), &InputEventKey::get_physical_keycode);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
ClassDB::bind_method(D_METHOD("set_key_label", "key_label"), &InputEventKey::set_key_label);
ClassDB::bind_method(D_METHOD("get_key_label"), &InputEventKey::get_key_label);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
ClassDB::bind_method(D_METHOD("set_location", "location"), &InputEventKey::set_location);
ClassDB::bind_method(D_METHOD("get_location"), &InputEventKey::get_location);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ClassDB::bind_method(D_METHOD("set_echo", "echo"), &InputEventKey::set_echo);
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
ClassDB::bind_method(D_METHOD("get_keycode_with_modifiers"), &InputEventKey::get_keycode_with_modifiers);
ClassDB::bind_method(D_METHOD("get_physical_keycode_with_modifiers"), &InputEventKey::get_physical_keycode_with_modifiers);
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
ClassDB::bind_method(D_METHOD("get_key_label_with_modifiers"), &InputEventKey::get_key_label_with_modifiers);
ClassDB::bind_method(D_METHOD("as_text_keycode"), &InputEventKey::as_text_keycode);
ClassDB::bind_method(D_METHOD("as_text_physical_keycode"), &InputEventKey::as_text_physical_keycode);
ClassDB::bind_method(D_METHOD("as_text_key_label"), &InputEventKey::as_text_key_label);
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
ClassDB::bind_method(D_METHOD("as_text_location"), &InputEventKey::as_text_location);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
Rename `scancode` to `keycode`. Add `physical_keycode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2018-04-05 17:59:35 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "keycode"), "set_keycode", "get_keycode");
ADD_PROPERTY(PropertyInfo(Variant::INT, "physical_keycode"), "set_physical_keycode", "get_physical_keycode");
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-10 23:21:22 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "key_label"), "set_key_label", "get_key_label");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "unicode"), "set_unicode", "get_unicode");
Add InputEventKey.location to tell left from right This adds a new enum `KeyLocation` and associated property `InputEventKey.location`, which indicates the left/right location of key events which may come from one of two physical keys, eg. Shift, Ctrl. It also adds simulation of missing Shift KEYUP events for Windows. When multiple Shifts are held down at the same time, Windows natively only sends a KEYUP for the last one to be released.
2023-08-03 13:18:26 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "location", PROPERTY_HINT_ENUM, "Unspecified,Left,Right"), "set_location", "get_location");
Fix InputEventKey::echo type from INT to BOOL
2020-03-01 06:52:37 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "echo"), "set_echo", "is_echo");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
void InputEventMouse::set_button_mask(BitField<MouseButtonMask> p_mask) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
button_mask = p_mask;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
BitField<MouseButtonMask> InputEventMouse::get_button_mask() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return button_mask;
}
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
void InputEventMouse::set_position(const Vector2 &p_pos) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
pos = p_pos;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
Vector2 InputEventMouse::get_position() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return pos;
}
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
void InputEventMouse::set_global_position(const Vector2 &p_global_pos) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
global_pos = p_global_pos;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
Vector2 InputEventMouse::get_global_position() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
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);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
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);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_mask"), "set_button_mask", "get_button_mask");
Add suffixes to all nodes and resources
2022-05-20 05:24:41 +00:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position", PROPERTY_HINT_NONE, "suffix:px"), "set_position", "get_position");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "global_position", PROPERTY_HINT_NONE, "suffix:px"), "set_global_position", "get_global_position");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventMouseButton::set_factor(float p_factor) {
factor = p_factor;
}
Add const to InputEventMouseButton::get_factor
2020-04-25 11:25:00 +00:00
float InputEventMouseButton::get_factor() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return factor;
}
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
void InputEventMouseButton::set_button_index(MouseButton p_index) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
button_index = p_index;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
MouseButton InputEventMouseButton::get_button_index() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return button_index;
}
void InputEventMouseButton::set_pressed(bool p_pressed) {
pressed = p_pressed;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
void InputEventMouseButton::set_canceled(bool p_canceled) {
canceled = p_canceled;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Rename `doubleclick` to `double_click`
2021-04-13 08:25:44 +00:00
void InputEventMouseButton::set_double_click(bool p_double_click) {
double_click = p_double_click;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Rename `doubleclick` to `double_click`
2021-04-13 08:25:44 +00:00
bool InputEventMouseButton::is_double_click() const {
return double_click;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Ref<InputEvent> InputEventMouseButton::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Don't transform global position of mouse input
2019-09-02 22:58:10 +00:00
Vector2 g = get_global_position();
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
Vector2 l = p_xform.xform(get_position() + p_local_ofs);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEventMouseButton> mb;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
mb.instantiate();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mb->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
mb->set_window_id(get_window_id());
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
mb->set_modifiers_from_event(this);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
mb->set_position(l);
mb->set_global_position(g);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mb->set_button_mask(get_button_mask());
mb->set_pressed(pressed);
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
mb->set_canceled(canceled);
Rename `doubleclick` to `double_click`
2021-04-13 08:25:44 +00:00
mb->set_double_click(double_click);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mb->set_factor(factor);
mb->set_button_index(button_index);
return mb;
}
Fix action exact match
2021-10-24 03:38:32 +00:00
bool InputEventMouseButton::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, float p_deadzone, bool *r_pressed, float *r_strength, float *r_raw_strength) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEventMouseButton> mb = p_event;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (mb.is_null()) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Fix action exact match
2021-10-24 03:38:32 +00:00
bool match = button_index == mb->button_index;
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
Key action_modifiers_mask = (Key)(int64_t)get_modifiers_mask();
Key button_modifiers_mask = (Key)(int64_t)mb->get_modifiers_mask();
Ensure minimum modifiers are pressed when matching actions
2022-03-20 06:57:28 +00:00
if (mb->is_pressed()) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
match &= (action_modifiers_mask & button_modifiers_mask) == action_modifiers_mask;
Ensure minimum modifiers are pressed when matching actions
2022-03-20 06:57:28 +00:00
}
Fix action exact match
2021-10-24 03:38:32 +00:00
if (p_exact_match) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
match &= action_modifiers_mask == button_modifiers_mask;
Fix action exact match
2021-10-24 03:38:32 +00:00
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
if (match) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
bool mb_pressed = mb->is_pressed();
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_pressed != nullptr) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
*r_pressed = mb_pressed;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
float strength = mb_pressed ? 1.0f : 0.0f;
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_strength != nullptr) {
*r_strength = strength;
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
}
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_raw_strength != nullptr) {
*r_raw_strength = strength;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
}
return match;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
bool InputEventMouseButton::is_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 &&
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 13:19:35 +00:00
(!p_exact_match || get_modifiers_mask() == mb->get_modifiers_mask());
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
}
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
static const char *_mouse_button_descriptions[9] = {
TTRC("Left Mouse Button"),
TTRC("Right Mouse Button"),
TTRC("Middle Mouse Button"),
TTRC("Mouse Wheel Up"),
TTRC("Mouse Wheel Down"),
TTRC("Mouse Wheel Left"),
TTRC("Mouse Wheel Right"),
TTRC("Mouse Thumb Button 1"),
TTRC("Mouse Thumb Button 2")
};
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
String InputEventMouseButton::as_text() const {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
// Modifiers
String mods_text = InputEventWithModifiers::as_text();
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
String full_string = mods_text.is_empty() ? "" : mods_text + "+";
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
// Button
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
MouseButton idx = get_button_index();
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
switch (idx) {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
case MouseButton::LEFT:
case MouseButton::RIGHT:
case MouseButton::MIDDLE:
case MouseButton::WHEEL_UP:
case MouseButton::WHEEL_DOWN:
case MouseButton::WHEEL_LEFT:
case MouseButton::WHEEL_RIGHT:
case MouseButton::MB_XBUTTON1:
case MouseButton::MB_XBUTTON2:
full_string += RTR(_mouse_button_descriptions[(size_t)idx - 1]); // button index starts from 1, array index starts from 0, so subtract 1
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
break;
default:
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
full_string += RTR("Button") + " #" + itos((int64_t)idx);
Added support for extra mouse buttons.
2018-07-05 14:50:30 +00:00
break;
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
// Double Click
Rename `doubleclick` to `double_click`
2021-04-13 08:25:44 +00:00
if (double_click) {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
full_string += " (" + RTR("Double Click") + ")";
}
return full_string;
}
String InputEventMouseButton::to_string() {
String p = is_pressed() ? "true" : "false";
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
String canceled_state = is_canceled() ? "true" : "false";
Rename `doubleclick` to `double_click`
2021-04-13 08:25:44 +00:00
String d = double_click ? "true" : "false";
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
MouseButton idx = get_button_index();
String button_string = itos((int64_t)idx);
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
switch (idx) {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
case MouseButton::LEFT:
case MouseButton::RIGHT:
case MouseButton::MIDDLE:
case MouseButton::WHEEL_UP:
case MouseButton::WHEEL_DOWN:
case MouseButton::WHEEL_LEFT:
case MouseButton::WHEEL_RIGHT:
case MouseButton::MB_XBUTTON1:
case MouseButton::MB_XBUTTON2:
String: Remove TTR and DTR defines in non-tools build This ensures we don't use TTR in runtime code, as it's specifically meant to source translations for the editor.
2022-03-28 13:24:14 +00:00
button_string += vformat(" (%s)", TTRGET(_mouse_button_descriptions[(size_t)idx - 1])); // button index starts from 1, array index starts from 0, so subtract 1
Added support for extra mouse buttons.
2018-07-05 14:50:30 +00:00
break;
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
default:
break;
}
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 02:42:42 +00:00
String mods = InputEventWithModifiers::as_text();
String: Remove TTR and DTR defines in non-tools build This ensures we don't use TTR in runtime code, as it's specifically meant to source translations for the editor.
2022-03-28 13:24:14 +00:00
mods = mods.is_empty() ? "none" : mods;
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 02:42:42 +00:00
// Work around the fact vformat can only take 5 substitutions but 6 need to be passed.
Make printing of InputEvents consistent - Removes the undesired spaces before the colon - Adds missing commas between parameters - Adds quotes or brackets to strings - Removes brackets around single values
2021-05-15 09:06:15 +00:00
String index_and_mods = vformat("button_index=%s, mods=%s", button_index, mods);
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
return vformat("InputEventMouseButton: %s, pressed=%s, canceled=%s, position=(%s), button_mask=%d, double_click=%s", index_and_mods, p, canceled_state, String(get_position()), get_button_mask(), d);
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
ClassDB::bind_method(D_METHOD("set_canceled", "canceled"), &InputEventMouseButton::set_canceled);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Rename `doubleclick` to `double_click`
2021-04-13 08:25:44 +00:00
ClassDB::bind_method(D_METHOD("set_double_click", "double_click"), &InputEventMouseButton::set_double_click);
ClassDB::bind_method(D_METHOD("is_double_click"), &InputEventMouseButton::is_double_click);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "factor"), "set_factor", "get_factor");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index");
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "canceled"), "set_canceled", "is_canceled");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
Rename `doubleclick` to `double_click`
2021-04-13 08:25:44 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "double_click"), "set_double_click", "is_double_click");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
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;
}
[macOS, Windows, X11] Add stylus inverted/eraser support to InputEventMouseMotion event
2022-06-19 09:58:24 +00:00
void InputEventMouseMotion::set_pen_inverted(bool p_inverted) {
pen_inverted = p_inverted;
}
bool InputEventMouseMotion::get_pen_inverted() const {
return pen_inverted;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventMouseMotion::set_relative(const Vector2 &p_relative) {
relative = p_relative;
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Vector2 InputEventMouseMotion::get_relative() const {
return relative;
}
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
void InputEventMouseMotion::set_velocity(const Vector2 &p_velocity) {
velocity = p_velocity;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
Vector2 InputEventMouseMotion::get_velocity() const {
return velocity;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Ref<InputEvent> InputEventMouseMotion::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventMouseMotion> mm;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
mm.instantiate();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mm->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
mm->set_window_id(get_window_id());
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
mm->set_modifiers_from_event(this);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
mm->set_position(p_xform.xform(get_position() + p_local_ofs));
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
mm->set_pressure(get_pressure());
[macOS, Windows, X11] Add stylus inverted/eraser support to InputEventMouseMotion event
2022-06-19 09:58:24 +00:00
mm->set_pen_inverted(get_pen_inverted());
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
mm->set_tilt(get_tilt());
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
mm->set_global_position(get_global_position());
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mm->set_button_mask(get_button_mask());
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
mm->set_relative(p_xform.basis_xform(get_relative()));
mm->set_velocity(p_xform.basis_xform(get_velocity()));
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return mm;
}
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
String InputEventMouseMotion::as_text() const {
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
return vformat(RTR("Mouse motion at position (%s) with velocity (%s)"), String(get_position()), String(get_velocity()));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
String InputEventMouseMotion::to_string() {
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
BitField<MouseButtonMask> mouse_button_mask = get_button_mask();
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
String button_mask_string = itos((int64_t)mouse_button_mask);
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-07 23:55:54 +00:00
if (mouse_button_mask.has_flag(MouseButtonMask::LEFT)) {
button_mask_string += vformat(" (%s)", TTRGET(_mouse_button_descriptions[(size_t)MouseButton::LEFT - 1]));
}
if (mouse_button_mask.has_flag(MouseButtonMask::MIDDLE)) {
button_mask_string += vformat(" (%s)", TTRGET(_mouse_button_descriptions[(size_t)MouseButton::MIDDLE - 1]));
}
if (mouse_button_mask.has_flag(MouseButtonMask::RIGHT)) {
button_mask_string += vformat(" (%s)", TTRGET(_mouse_button_descriptions[(size_t)MouseButton::RIGHT - 1]));
}
if (mouse_button_mask.has_flag(MouseButtonMask::MB_XBUTTON1)) {
button_mask_string += vformat(" (%s)", TTRGET(_mouse_button_descriptions[(size_t)MouseButton::MB_XBUTTON1 - 1]));
}
if (mouse_button_mask.has_flag(MouseButtonMask::MB_XBUTTON2)) {
button_mask_string += vformat(" (%s)", TTRGET(_mouse_button_descriptions[(size_t)MouseButton::MB_XBUTTON2 - 1]));
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
}
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
[macOS, Windows, X11] Add stylus inverted/eraser support to InputEventMouseMotion event
2022-06-19 09:58:24 +00:00
// Work around the fact vformat can only take 5 substitutions but 7 need to be passed.
String mask_and_position_and_relative = vformat("button_mask=%s, position=(%s), relative=(%s)", button_mask_string, String(get_position()), String(get_relative()));
Use %s for bool value in vformat
2022-08-07 01:57:09 +00:00
return vformat("InputEventMouseMotion: %s, velocity=(%s), pressure=%.2f, tilt=(%s), pen_inverted=(%s)", mask_and_position_and_relative, String(get_velocity()), get_pressure(), String(get_tilt()), get_pen_inverted());
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
}
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
bool InputEventMouseMotion::accumulate(const Ref<InputEvent> &p_event) {
Ref<InputEventMouseMotion> motion = p_event;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (motion.is_null()) {
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
if (get_window_id() != motion->get_window_id()) {
return false;
}
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
if (is_canceled() != motion->is_canceled()) {
return false;
}
Add support for event accumlation (off by default, on for editor), fixes #26536
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;
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
if (is_shift_pressed() != motion->is_shift_pressed()) {
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
return false;
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
if (is_ctrl_pressed() != motion->is_ctrl_pressed()) {
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
return false;
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
if (is_alt_pressed() != motion->is_alt_pressed()) {
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
return false;
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
if (is_meta_pressed() != motion->is_meta_pressed()) {
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
return false;
}
set_position(motion->get_position());
set_global_position(motion->get_global_position());
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
set_velocity(motion->get_velocity());
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
relative += motion->get_relative();
return true;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventMouseMotion::_bind_methods() {
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
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);
[macOS, Windows, X11] Add stylus inverted/eraser support to InputEventMouseMotion event
2022-06-19 09:58:24 +00:00
ClassDB::bind_method(D_METHOD("set_pen_inverted", "pen_inverted"), &InputEventMouseMotion::set_pen_inverted);
ClassDB::bind_method(D_METHOD("get_pen_inverted"), &InputEventMouseMotion::get_pen_inverted);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
ClassDB::bind_method(D_METHOD("set_velocity", "velocity"), &InputEventMouseMotion::set_velocity);
ClassDB::bind_method(D_METHOD("get_velocity"), &InputEventMouseMotion::get_velocity);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "tilt"), "set_tilt", "get_tilt");
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "pressure"), "set_pressure", "get_pressure");
[macOS, Windows, X11] Add stylus inverted/eraser support to InputEventMouseMotion event
2022-06-19 09:58:24 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pen_inverted"), "set_pen_inverted", "get_pen_inverted");
Add suffixes to all nodes and resources
2022-05-20 05:24:41 +00:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative", PROPERTY_HINT_NONE, "suffix:px"), "set_relative", "get_relative");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "velocity", PROPERTY_HINT_NONE, "suffix:px/s"), "set_velocity", "get_velocity");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
void InputEventJoypadMotion::set_axis(JoyAxis p_axis) {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
ERR_FAIL_COND(p_axis < JoyAxis::LEFT_X || p_axis > JoyAxis::MAX);
InputEventJoypadMotion::set_axis - reject invalid axis
2021-09-30 10:32:21 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
axis = p_axis;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
JoyAxis InputEventJoypadMotion::get_axis() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return axis;
}
void InputEventJoypadMotion::set_axis_value(float p_value) {
axis_value = p_value;
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
pressed = Math::abs(axis_value) >= 0.5f;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
float InputEventJoypadMotion::get_axis_value() const {
return axis_value;
}
Fix action exact match
2021-10-24 03:38:32 +00:00
bool InputEventJoypadMotion::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, float p_deadzone, bool *r_pressed, float *r_strength, float *r_raw_strength) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEventJoypadMotion> jm = p_event;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (jm.is_null()) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Fix action exact match
2021-10-24 03:38:32 +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);
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
if (match) {
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
float jm_abs_axis_value = Math::abs(jm->get_axis_value());
Fixing input strength and the impossibility to erase action events
2018-04-25 20:29:39 +00:00
bool same_direction = (((axis_value < 0) == (jm->axis_value < 0)) || jm->axis_value == 0);
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
bool pressed_state = same_direction && jm_abs_axis_value >= p_deadzone;
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_pressed != nullptr) {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
*r_pressed = pressed_state;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_strength != nullptr) {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
if (pressed_state) {
Fix NaN with get_action_strength
2019-05-15 09:21:10 +00:00
if (p_deadzone == 1.0f) {
Fix action exact match
2021-10-24 03:38:32 +00:00
*r_strength = 1.0f;
Fix NaN with get_action_strength
2019-05-15 09:21:10 +00:00
} else {
Fix action exact match
2021-10-24 03:38:32 +00:00
*r_strength = CLAMP(Math::inverse_lerp(p_deadzone, 1.0f, jm_abs_axis_value), 0.0f, 1.0f);
Fix NaN with get_action_strength
2019-05-15 09:21:10 +00:00
}
} else {
Fix action exact match
2021-10-24 03:38:32 +00:00
*r_strength = 0.0f;
Fix NaN with get_action_strength
2019-05-15 09:21:10 +00:00
}
}
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_raw_strength != nullptr) {
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
if (same_direction) { // NOT pressed, because we want to ignore the deadzone.
Fix action exact match
2021-10-24 03:38:32 +00:00
*r_raw_strength = jm_abs_axis_value;
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
} else {
Fix action exact match
2021-10-24 03:38:32 +00:00
*r_raw_strength = 0.0f;
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
}
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
}
return match;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
bool InputEventJoypadMotion::is_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 &&
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 13:19:35 +00:00
(!p_exact_match || ((axis_value < 0) == (jm->axis_value < 0)));
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
}
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
static const char *_joy_axis_descriptions[(size_t)JoyAxis::MAX] = {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
TTRC("Left Stick X-Axis, Joystick 0 X-Axis"),
TTRC("Left Stick Y-Axis, Joystick 0 Y-Axis"),
TTRC("Right Stick X-Axis, Joystick 1 X-Axis"),
TTRC("Right Stick Y-Axis, Joystick 1 Y-Axis"),
TTRC("Joystick 2 X-Axis, Left Trigger, Sony L2, Xbox LT"),
TTRC("Joystick 2 Y-Axis, Right Trigger, Sony R2, Xbox RT"),
TTRC("Joystick 3 X-Axis"),
TTRC("Joystick 3 Y-Axis"),
TTRC("Joystick 4 X-Axis"),
TTRC("Joystick 4 Y-Axis"),
};
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
String InputEventJoypadMotion::as_text() const {
String: Remove TTR and DTR defines in non-tools build This ensures we don't use TTR in runtime code, as it's specifically meant to source translations for the editor.
2022-03-28 13:24:14 +00:00
String desc = axis < JoyAxis::MAX ? TTRGET(_joy_axis_descriptions[(size_t)axis]) : RTR("Unknown Joypad Axis");
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
String: Remove TTR and DTR defines in non-tools build This ensures we don't use TTR in runtime code, as it's specifically meant to source translations for the editor.
2022-03-28 13:24:14 +00:00
return vformat(RTR("Joypad Motion on Axis %d (%s) with Value %.2f"), axis, desc, axis_value);
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
String InputEventJoypadMotion::to_string() {
Make printing of InputEvents consistent - Removes the undesired spaces before the colon - Adds missing commas between parameters - Adds quotes or brackets to strings - Removes brackets around single values
2021-05-15 09:06:15 +00:00
return vformat("InputEventJoypadMotion: axis=%d, axis_value=%.2f", axis, axis_value);
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
}
feat(gamepad): improve gamepad behavior with slider and popup_menu
2023-02-09 16:25:56 +00:00
Ref<InputEventJoypadMotion> InputEventJoypadMotion::create_reference(JoyAxis p_axis, float p_value) {
Ref<InputEventJoypadMotion> ie;
ie.instantiate();
ie->set_axis(p_axis);
ie->set_axis_value(p_value);
return ie;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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");
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "axis_value"), "set_axis_value", "get_axis_value");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
void InputEventJoypadButton::set_button_index(JoyButton p_index) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
button_index = p_index;
Added EditorInspectorPlugin to aid in editing InputEvents in resources and shortcuts
2021-06-27 14:15:56 +00:00
emit_changed();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
JoyButton InputEventJoypadButton::get_button_index() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return button_index;
}
void InputEventJoypadButton::set_pressed(bool p_pressed) {
pressed = p_pressed;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventJoypadButton::set_pressure(float p_pressure) {
pressure = p_pressure;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
float InputEventJoypadButton::get_pressure() const {
return pressure;
}
Fix action exact match
2021-10-24 03:38:32 +00:00
bool InputEventJoypadButton::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, float p_deadzone, bool *r_pressed, float *r_strength, float *r_raw_strength) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEventJoypadButton> jb = p_event;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (jb.is_null()) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
bool match = button_index == jb->button_index;
if (match) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
bool jb_pressed = jb->is_pressed();
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_pressed != nullptr) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
*r_pressed = jb_pressed;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
float strength = jb_pressed ? 1.0f : 0.0f;
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_strength != nullptr) {
*r_strength = strength;
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
}
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_raw_strength != nullptr) {
*r_raw_strength = strength;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Allow actions to provide an analog value
2018-02-21 21:06:34 +00:00
}
return match;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
bool InputEventJoypadButton::is_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
Make Button shortcuts triggerable by gamepads This closes #25741.
2019-02-15 23:26:07 +00:00
Ref<InputEventJoypadButton> button = p_event;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (button.is_null()) {
Make Button shortcuts triggerable by gamepads This closes #25741.
2019-02-15 23:26:07 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Make Button shortcuts triggerable by gamepads This closes #25741.
2019-02-15 23:26:07 +00:00
return button_index == button->button_index;
}
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
static const char *_joy_button_descriptions[(size_t)JoyButton::SDL_MAX] = {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
TTRC("Bottom Action, Sony Cross, Xbox A, Nintendo B"),
TTRC("Right Action, Sony Circle, Xbox B, Nintendo A"),
TTRC("Left Action, Sony Square, Xbox X, Nintendo Y"),
TTRC("Top Action, Sony Triangle, Xbox Y, Nintendo X"),
TTRC("Back, Sony Select, Xbox Back, Nintendo -"),
TTRC("Guide, Sony PS, Xbox Home"),
Mention Xbox menu button by name in Start button description Microsoft officially calls it the Menu button: https://support.xbox.com/en-US/help/hardware-network/controller/get-to-know-your-xbox-series-x-s-controller
2023-06-26 07:14:26 +00:00
TTRC("Start, Xbox Menu, Nintendo +"),
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
TTRC("Left Stick, Sony L3, Xbox L/LS"),
TTRC("Right Stick, Sony R3, Xbox R/RS"),
TTRC("Left Shoulder, Sony L1, Xbox LB"),
TTRC("Right Shoulder, Sony R1, Xbox RB"),
TTRC("D-pad Up"),
TTRC("D-pad Down"),
TTRC("D-pad Left"),
TTRC("D-pad Right"),
Add support for new SDL gamecontroller keywords.
2021-02-07 13:52:38 +00:00
TTRC("Xbox Share, PS5 Microphone, Nintendo Capture"),
TTRC("Xbox Paddle 1"),
TTRC("Xbox Paddle 2"),
TTRC("Xbox Paddle 3"),
TTRC("Xbox Paddle 4"),
TTRC("PS4/5 Touchpad"),
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
};
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
String InputEventJoypadButton::as_text() const {
Add some missing translatable editor strings
2023-02-09 16:24:52 +00:00
String text = vformat(RTR("Joypad Button %d"), (int64_t)button_index);
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
if (button_index > JoyButton::INVALID && button_index < JoyButton::SDL_MAX) {
Add some missing translatable editor strings
2023-02-09 16:24:52 +00:00
text += vformat(" (%s)", TTRGET(_joy_button_descriptions[(size_t)button_index]));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
if (pressure != 0) {
Add some missing translatable editor strings
2023-02-09 16:24:52 +00:00
text += ", " + RTR("Pressure:") + " " + String(Variant(pressure));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
return text;
}
String InputEventJoypadButton::to_string() {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
String p = is_pressed() ? "true" : "false";
Make printing of InputEvents consistent - Removes the undesired spaces before the colon - Adds missing commas between parameters - Adds quotes or brackets to strings - Removes brackets around single values
2021-05-15 09:06:15 +00:00
return vformat("InputEventJoypadButton: button_index=%d, pressed=%s, pressure=%.2f", button_index, p, pressure);
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
}
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
Ref<InputEventJoypadButton> InputEventJoypadButton::create_reference(JoyButton p_btn_index) {
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 11:31:25 +00:00
Ref<InputEventJoypadButton> ie;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
ie.instantiate();
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 11:31:25 +00:00
ie->set_button_index(p_btn_index);
return ie;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index");
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "pressure"), "set_pressure", "get_pressure");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventScreenTouch::set_index(int p_index) {
index = p_index;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
int InputEventScreenTouch::get_index() const {
return index;
}
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
void InputEventScreenTouch::set_position(const Vector2 &p_pos) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
pos = p_pos;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
Vector2 InputEventScreenTouch::get_position() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return pos;
}
void InputEventScreenTouch::set_pressed(bool p_pressed) {
pressed = p_pressed;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
void InputEventScreenTouch::set_canceled(bool p_canceled) {
canceled = p_canceled;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Add double_tap attribute to InputEventScreenTouch This provides parity with the `InputEventMouseButton` allowing for proper conversion between the two events.
2022-10-22 14:30:46 +00:00
void InputEventScreenTouch::set_double_tap(bool p_double_tap) {
double_tap = p_double_tap;
}
bool InputEventScreenTouch::is_double_tap() const {
return double_tap;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEvent> InputEventScreenTouch::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventScreenTouch> st;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
st.instantiate();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
st->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
st->set_window_id(get_window_id());
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
st->set_index(index);
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
st->set_position(p_xform.xform(pos + p_local_ofs));
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
st->set_pressed(pressed);
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
st->set_canceled(canceled);
Add double_tap attribute to InputEventScreenTouch This provides parity with the `InputEventMouseButton` allowing for proper conversion between the two events.
2022-10-22 14:30:46 +00:00
st->set_double_tap(double_tap);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return st;
}
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
String InputEventScreenTouch::as_text() const {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
String status = canceled ? RTR("canceled") : (pressed ? RTR("touched") : RTR("released"));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
return vformat(RTR("Screen %s at (%s) with %s touch points"), status, String(get_position()), itos(index));
}
String InputEventScreenTouch::to_string() {
Make printing of InputEvents consistent - Removes the undesired spaces before the colon - Adds missing commas between parameters - Adds quotes or brackets to strings - Removes brackets around single values
2021-05-15 09:06:15 +00:00
String p = pressed ? "true" : "false";
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
String canceled_state = canceled ? "true" : "false";
Add double_tap attribute to InputEventScreenTouch This provides parity with the `InputEventMouseButton` allowing for proper conversion between the two events.
2022-10-22 14:30:46 +00:00
String double_tap_string = double_tap ? "true" : "false";
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
return vformat("InputEventScreenTouch: index=%d, pressed=%s, canceled=%s, position=(%s), double_tap=%s", index, p, canceled_state, String(get_position()), double_tap_string);
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
Rename pos to position in user facing methods and variables Rename user facing methods and variables as well as the corresponding C++ methods according to the folloming changes: * pos -> position * rot -> rotation * loc -> location C++ variables are left as is.
2017-09-10 13:37:49 +00:00
ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventScreenTouch::set_position);
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
ClassDB::bind_method(D_METHOD("get_position"), &InputEventScreenTouch::get_position);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventScreenTouch::set_pressed);
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
ClassDB::bind_method(D_METHOD("set_canceled", "canceled"), &InputEventScreenTouch::set_canceled);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Add double_tap attribute to InputEventScreenTouch This provides parity with the `InputEventMouseButton` allowing for proper conversion between the two events.
2022-10-22 14:30:46 +00:00
ClassDB::bind_method(D_METHOD("set_double_tap", "double_tap"), &InputEventScreenTouch::set_double_tap);
ClassDB::bind_method(D_METHOD("is_double_tap"), &InputEventScreenTouch::is_double_tap);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index");
Add suffixes to all nodes and resources
2022-05-20 05:24:41 +00:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position", PROPERTY_HINT_NONE, "suffix:px"), "set_position", "get_position");
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "canceled"), "set_canceled", "is_canceled");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
Add double_tap attribute to InputEventScreenTouch This provides parity with the `InputEventMouseButton` allowing for proper conversion between the two events.
2022-10-22 14:30:46 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "double_tap"), "set_double_tap", "is_double_tap");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventScreenDrag::set_index(int p_index) {
index = p_index;
}
int InputEventScreenDrag::get_index() const {
return index;
}
[iOS] Add Apple Pencil pressure and tilt support.
2022-12-23 15:37:45 +00:00
void InputEventScreenDrag::set_tilt(const Vector2 &p_tilt) {
tilt = p_tilt;
}
Vector2 InputEventScreenDrag::get_tilt() const {
return tilt;
}
void InputEventScreenDrag::set_pressure(float p_pressure) {
pressure = p_pressure;
}
float InputEventScreenDrag::get_pressure() const {
return pressure;
}
void InputEventScreenDrag::set_pen_inverted(bool p_inverted) {
pen_inverted = p_inverted;
}
bool InputEventScreenDrag::get_pen_inverted() const {
return pen_inverted;
}
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
void InputEventScreenDrag::set_position(const Vector2 &p_pos) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
pos = p_pos;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
Vector2 InputEventScreenDrag::get_position() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return pos;
}
void InputEventScreenDrag::set_relative(const Vector2 &p_relative) {
relative = p_relative;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Vector2 InputEventScreenDrag::get_relative() const {
return relative;
}
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
void InputEventScreenDrag::set_velocity(const Vector2 &p_velocity) {
velocity = p_velocity;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
Vector2 InputEventScreenDrag::get_velocity() const {
return velocity;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Ref<InputEvent> InputEventScreenDrag::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventScreenDrag> sd;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
sd.instantiate();
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
sd->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
sd->set_window_id(get_window_id());
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
sd->set_index(index);
[iOS] Add Apple Pencil pressure and tilt support.
2022-12-23 15:37:45 +00:00
sd->set_pressure(get_pressure());
sd->set_pen_inverted(get_pen_inverted());
sd->set_tilt(get_tilt());
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 08:54:24 +00:00
sd->set_position(p_xform.xform(pos + p_local_ofs));
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
sd->set_relative(p_xform.basis_xform(relative));
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
sd->set_velocity(p_xform.basis_xform(velocity));
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
return sd;
}
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
String InputEventScreenDrag::as_text() const {
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
return vformat(RTR("Screen dragged with %s touch points at position (%s) with velocity of (%s)"), itos(index), String(get_position()), String(get_velocity()));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
String InputEventScreenDrag::to_string() {
[iOS] Add Apple Pencil pressure and tilt support.
2022-12-23 15:37:45 +00:00
return vformat("InputEventScreenDrag: index=%d, position=(%s), relative=(%s), velocity=(%s), pressure=%.2f, tilt=(%s), pen_inverted=(%s)", index, String(get_position()), String(get_relative()), String(get_velocity()), get_pressure(), String(get_tilt()), get_pen_inverted());
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
}
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2021-08-12 22:31:16 +00:00
bool InputEventScreenDrag::accumulate(const Ref<InputEvent> &p_event) {
Ref<InputEventScreenDrag> drag = p_event;
simplify formatting scripts, add a clang-tidy script, and run clang-tidy
2022-01-27 16:34:33 +00:00
if (drag.is_null()) {
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2021-08-12 22:31:16 +00:00
return false;
simplify formatting scripts, add a clang-tidy script, and run clang-tidy
2022-01-27 16:34:33 +00:00
}
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2021-08-12 22:31:16 +00:00
if (get_index() != drag->get_index()) {
return false;
}
set_position(drag->get_position());
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
set_velocity(drag->get_velocity());
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2021-08-12 22:31:16 +00:00
relative += drag->get_relative();
return true;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
[iOS] Add Apple Pencil pressure and tilt support.
2022-12-23 15:37:45 +00:00
ClassDB::bind_method(D_METHOD("set_tilt", "tilt"), &InputEventScreenDrag::set_tilt);
ClassDB::bind_method(D_METHOD("get_tilt"), &InputEventScreenDrag::get_tilt);
ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventScreenDrag::set_pressure);
ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventScreenDrag::get_pressure);
ClassDB::bind_method(D_METHOD("set_pen_inverted", "pen_inverted"), &InputEventScreenDrag::set_pen_inverted);
ClassDB::bind_method(D_METHOD("get_pen_inverted"), &InputEventScreenDrag::get_pen_inverted);
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
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);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
Rename speed to velocity when it's a directional Vector
2021-12-29 13:22:22 +00:00
ClassDB::bind_method(D_METHOD("set_velocity", "velocity"), &InputEventScreenDrag::set_velocity);
ClassDB::bind_method(D_METHOD("get_velocity"), &InputEventScreenDrag::get_velocity);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index");
[iOS] Add Apple Pencil pressure and tilt support.
2022-12-23 15:37:45 +00:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "tilt"), "set_tilt", "get_tilt");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "pressure"), "set_pressure", "get_pressure");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pen_inverted"), "set_pen_inverted", "get_pen_inverted");
Add suffixes to all nodes and resources
2022-05-20 05:24:41 +00:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position", PROPERTY_HINT_NONE, "suffix:px"), "set_position", "get_position");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative", PROPERTY_HINT_NONE, "suffix:px"), "set_relative", "get_relative");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "velocity", PROPERTY_HINT_NONE, "suffix:px/s"), "set_velocity", "get_velocity");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void InputEventAction::set_action(const StringName &p_action) {
action = p_action;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
StringName InputEventAction::get_action() const {
return action;
}
void InputEventAction::set_pressed(bool p_pressed) {
pressed = p_pressed;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Add configurable strength value to InputEventAction
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;
}
Fix InputMap.action_erase_event() failing to erase events correctly.
2021-05-13 17:13:24 +00:00
bool InputEventAction::is_match(const Ref<InputEvent> &p_event, bool p_exact_match) const {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (p_event.is_null()) {
Fixed shortcuts not working with InputEventActions
2018-07-27 11:02:30 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fixed shortcuts not working with InputEventActions
2018-07-27 11:02:30 +00:00
Fix `InputEventAction`'s `is_action` method ignoring `exact_match` parameter
2022-07-17 14:20:37 +00:00
return p_event->is_action(action, p_exact_match);
Fixed shortcuts not working with InputEventActions
2018-07-27 11:02:30 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
bool InputEventAction::is_action(const StringName &p_action) const {
return action == p_action;
}
Fix action exact match
2021-10-24 03:38:32 +00:00
bool InputEventAction::action_match(const Ref<InputEvent> &p_event, bool p_exact_match, float p_deadzone, bool *r_pressed, float *r_strength, float *r_raw_strength) const {
Fix is_action_pressed for InputEventAction.
2018-09-10 19:15:06 +00:00
Ref<InputEventAction> act = p_event;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (act.is_null()) {
Fix is_action_pressed for InputEventAction.
2018-09-10 19:15:06 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix is_action_pressed for InputEventAction.
2018-09-10 19:15:06 +00:00
bool match = action == act->action;
if (match) {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
bool act_pressed = act->is_pressed();
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_pressed != nullptr) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
*r_pressed = act_pressed;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
float act_strength = act_pressed ? 1.0f : 0.0f;
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_strength != nullptr) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
*r_strength = act_strength;
Add raw strength value for internal use
2020-10-24 09:22:35 +00:00
}
Fix action exact match
2021-10-24 03:38:32 +00:00
if (r_raw_strength != nullptr) {
Fix MSVC warnings, rename shadowed variables, fix uninitialized values, change warnings=all to use /W4.
2022-09-29 09:53:28 +00:00
*r_raw_strength = act_strength;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix is_action_pressed for InputEventAction.
2018-09-10 19:15:06 +00:00
}
return match;
}
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
String InputEventAction::as_text() const {
Make InputEventAction as_text() return the text of the first valid event for the action.
2022-10-23 07:08:47 +00:00
const List<Ref<InputEvent>> *events = InputMap::get_singleton()->action_get_events(action);
if (!events) {
return String();
}
for (const Ref<InputEvent> &E : *events) {
if (E.is_valid()) {
return E->as_text();
}
}
return String();
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
String InputEventAction::to_string() {
Augment the `InputEvent` class with a `CANCELED` state The `InputEvent` class currently supports the `pressed` and `released` states, which given the binary nature, is represented by a `bool` field. This commit introduced the `CANCELED` state, which signals that an ongoing input event has been canceled. To represent all the states, the `InputEventState` enum is added and the `InputEvent` logic is refactored accordingly.
2023-05-04 00:57:13 +00:00
String p = is_pressed() ? "true" : "false";
Make printing of InputEvents consistent - Removes the undesired spaces before the colon - Adds missing commas between parameters - Adds quotes or brackets to strings - Removes brackets around single values
2021-05-15 09:06:15 +00:00
return vformat("InputEventAction: action=\"%s\", pressed=%s", action, p);
Show proper string with InputEvent.as_text()
2017-08-24 16:14:36 +00:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
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);
Add configurable strength value to InputEventAction
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);
Added StringName as a variant type. Also changed all relevant properties defined manually to StringName.
2020-02-20 21:58:05 +00:00
ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "action"), "set_action", "get_action");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "strength", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_strength", "get_strength");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
}
Properly deliver localized coordinates when passing gui events through parents, closes #4215
2016-06-27 12:59:43 +00:00
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
void InputEventGesture::set_position(const Vector2 &p_pos) {
pos = p_pos;
}
Core: Bind InputEventGesture events.
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 suffixes to all nodes and resources
2022-05-20 05:24:41 +00:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position", PROPERTY_HINT_NONE, "suffix:px"), "set_position", "get_position");
Core: Bind InputEventGesture events.
2017-11-24 18:22:33 +00:00
}
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
Vector2 InputEventGesture::get_position() const {
return pos;
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
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;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
ev.instantiate();
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
ev->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
ev->set_window_id(get_window_id());
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
ev->set_modifiers_from_event(this);
ev->set_position(p_xform.xform(get_position() + p_local_ofs));
ev->set_factor(get_factor());
return ev;
}
(Magnify|Pan)Gesture: implement as_text
2018-02-24 03:25:50 +00:00
String InputEventMagnifyGesture::as_text() const {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
return vformat(RTR("Magnify Gesture at (%s) with factor %s"), String(get_position()), rtos(get_factor()));
}
String InputEventMagnifyGesture::to_string() {
Make printing of InputEvents consistent - Removes the undesired spaces before the colon - Adds missing commas between parameters - Adds quotes or brackets to strings - Removes brackets around single values
2021-05-15 09:06:15 +00:00
return vformat("InputEventMagnifyGesture: factor=%.2f, position=(%s)", factor, String(get_position()));
(Magnify|Pan)Gesture: implement as_text
2018-02-24 03:25:50 +00:00
}
Core: Bind InputEventGesture events.
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);
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "factor"), "set_factor", "get_factor");
Core: Bind InputEventGesture events.
2017-11-24 18:22:33 +00:00
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
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;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
ev.instantiate();
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
ev->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
ev->set_window_id(get_window_id());
Native pan and zoom for macOS
2017-11-01 20:49:39 +00:00
ev->set_modifiers_from_event(this);
ev->set_position(p_xform.xform(get_position() + p_local_ofs));
ev->set_delta(get_delta());
return ev;
}
(Magnify|Pan)Gesture: implement as_text
2018-02-24 03:25:50 +00:00
String InputEventPanGesture::as_text() const {
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
return vformat(RTR("Pan Gesture at (%s) with delta (%s)"), String(get_position()), String(get_delta()));
}
String InputEventPanGesture::to_string() {
Make printing of InputEvents consistent - Removes the undesired spaces before the colon - Adds missing commas between parameters - Adds quotes or brackets to strings - Removes brackets around single values
2021-05-15 09:06:15 +00:00
return vformat("InputEventPanGesture: delta=(%s), position=(%s)", String(get_delta()), String(get_position()));
(Magnify|Pan)Gesture: implement as_text
2018-02-24 03:25:50 +00:00
}
Core: Bind InputEventGesture events.
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");
}
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
///////////////////////////////////
Added a new MIDIDriver class
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;
}
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
void InputEventMIDI::set_message(const MIDIMessage p_message) {
Added a new MIDIDriver class
2018-07-14 12:11:28 +00:00
message = p_message;
}
Use mouse and joypad enums instead of plain integers Also MIDIMessage
2021-03-25 20:56:12 +00:00
MIDIMessage InputEventMIDI::get_message() const {
Added a new MIDIDriver class
2018-07-14 12:11:28 +00:00
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 {
Use "enum class" for input enums
2021-08-13 21:31:57 +00:00
return vformat(RTR("MIDI Input on Channel=%s Message=%s"), itos(channel), itos((int64_t)message));
InputEvent as_text now returns readable string. Added to_string for debug strings Made InputEvent as_text() return a readable and presentable string. Added to_string() overrides for each which returns a 'debug-friendly' version which is not as presentable but provides more information and in a more structured fashion. Use as_text() for UI display scenarions and to_string() for debug cases
2020-10-01 12:55:23 +00:00
}
String InputEventMIDI::to_string() {
Context aware MIDI event printing
2022-11-18 08:04:26 +00:00
String ret;
switch (message) {
case MIDIMessage::NOTE_ON:
ret = vformat("Note On: channel=%d, pitch=%d, velocity=%d", channel, pitch, velocity);
break;
case MIDIMessage::NOTE_OFF:
ret = vformat("Note Off: channel=%d, pitch=%d, velocity=%d", channel, pitch, velocity);
break;
case MIDIMessage::PITCH_BEND:
ret = vformat("Pitch Bend: channel=%d, pitch=%d", channel, pitch);
break;
case MIDIMessage::CHANNEL_PRESSURE:
ret = vformat("Channel Pressure: channel=%d, pressure=%d", channel, pressure);
break;
case MIDIMessage::CONTROL_CHANGE:
ret = vformat("Control Change: channel=%d, controller_number=%d, controller_value=%d", channel, controller_number, controller_value);
break;
default:
ret = vformat("channel=%d, message=%d, pitch=%d, velocity=%d, pressure=%d, controller_number=%d, controller_value=%d, instrument=%d", channel, message, pitch, velocity, pressure, controller_number, controller_value, instrument);
}
return "InputEventMIDI: " + ret;
Added a new MIDIDriver class
2018-07-14 12:11:28 +00:00
}
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");
}
Added EditorCommandPalette
2021-05-29 13:28:16 +00:00
///////////////////////////////////
void InputEventShortcut::set_shortcut(Ref<Shortcut> p_shortcut) {
shortcut = p_shortcut;
emit_changed();
}
Ref<Shortcut> InputEventShortcut::get_shortcut() {
return shortcut;
}
Entirely removes BIND_VMETHOD in favor of GDVIRTUAL * `_gui_input`, `_input`, `_unhandled_input` and `_unhandled_key_input` are now regular C++ virutal functions. * Everything else converted to GDVIRTUAL * BIND_VMETHOD is gone, always use the new syntax from now on. Creating `_gui_input` method and using the binder to register events will no longer work, simply override the virtual function now.
2021-08-22 15:37:22 +00:00
void InputEventShortcut::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_shortcut", "shortcut"), &InputEventShortcut::set_shortcut);
ClassDB::bind_method(D_METHOD("get_shortcut"), &InputEventShortcut::get_shortcut);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shortcut", PROPERTY_HINT_RESOURCE_TYPE, "Shortcut"), "set_shortcut", "get_shortcut");
}
Added EditorCommandPalette
2021-05-29 13:28:16 +00:00
String InputEventShortcut::as_text() const {
validate 'shortcut' in InputEventShortcut
2021-09-25 14:44:42 +00:00
ERR_FAIL_COND_V(shortcut.is_null(), "None");
Added EditorCommandPalette
2021-05-29 13:28:16 +00:00
return vformat(RTR("Input Event with Shortcut=%s"), shortcut->get_as_text());
}
String InputEventShortcut::to_string() {
validate 'shortcut' in InputEventShortcut
2021-09-25 14:44:42 +00:00
ERR_FAIL_COND_V(shortcut.is_null(), "None");
Added EditorCommandPalette
2021-05-29 13:28:16 +00:00
return vformat("InputEventShortcut: shortcut=%s", shortcut->get_as_text());
}
Make InputEventShortcut always pressed
2023-09-23 17:43:07 +00:00
InputEventShortcut::InputEventShortcut() {
pressed = true;
}