asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/core/input/input_event.cpp

1485 lines
47 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* input_event.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
Update copyright statements to 2021 Happy new year to the wonderful Godot community! 2020 has been a tough year for most of us personally, but a good year for Godot development nonetheless with a huge amount of work done towards Godot 4.0 and great improvements backported to the long-lived 3.2 branch. We've had close to 400 contributors to engine code this year, authoring near 7,000 commit! (And that's only for the `master` branch and for the engine code, there's a lot more when counting docs, demos and other first-party repos.) Here's to a great year 2021 for all Godot users 🎆
2021-01-01 20:13:46 +01:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
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-05 00:50:27 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#include "input_event.h"
Dead code tells no tales
2017-08-27 21:07:15 +02:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01:00
#include "core/input/input_map.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 18:13:45 +02:00
#include "core/os/keyboard.h"
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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 22:03:27 +01:00
const int InputEvent::DEVICE_ID_TOUCH_MOUSE = -1;
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 17:38:03 +02:00
void InputEvent::set_device(int p_device) {
device = p_device;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
int InputEvent::get_device() const {
return device;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 15:22:42 +01:00
bool InputEvent::is_action(const StringName &p_action, bool p_exact_match) const {
return InputMap::get_singleton()->event_is_action(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 15:22:42 +01:00
bool InputEvent::is_action_pressed(const StringName &p_action, bool p_allow_echo, bool p_exact_match) const {
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
bool pressed;
Allow checking for exact matches with Action events. Added additional param to action related methods to test for exactness. If "p_exact_match" is true, then the action will only be "matched" if the provided input event *exactly* matches with the action event. Before: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * Is Action Pressed = True Now: You can still do the above, however you can optionally check that the input is exactly what the action event is: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * p_exact_match = True * Is Action Pressed = False * If the Input Event was only KEY_S, then the result would be true. Usage: ```gdscript Input.is_action_pressed(action_name: String, exact_match: bool) Input.is_action_pressed("my_action", true) InputMap.event_is_action(p_event, "my_action", true) func _input(event: InputEvent): event.is_action_pressed("my_action", false, true) # false = "allow_echo", true = "exact_match" event.is_action("my_action", true) ```
2020-12-13 15:22:42 +01:00
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match, &pressed, nullptr, nullptr);
Fix analog input in sliders
2019-10-24 23:51:33 +02:00
return valid && pressed && (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 17:38:03 +02:00
}
Allow actions to provide an analog value
2018-02-21 22:06:34 +01: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 15:22:42 +01:00
bool InputEvent::is_action_released(const StringName &p_action, bool p_exact_match) const {
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
bool pressed;
Allow checking for exact matches with Action events. Added additional param to action related methods to test for exactness. If "p_exact_match" is true, then the action will only be "matched" if the provided input event *exactly* matches with the action event. Before: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * Is Action Pressed = True Now: You can still do the above, however you can optionally check that the input is exactly what the action event is: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * p_exact_match = True * Is Action Pressed = False * If the Input Event was only KEY_S, then the result would be true. Usage: ```gdscript Input.is_action_pressed(action_name: String, exact_match: bool) Input.is_action_pressed("my_action", true) InputMap.event_is_action(p_event, "my_action", true) func _input(event: InputEvent): event.is_action_pressed("my_action", false, true) # false = "allow_echo", true = "exact_match" event.is_action("my_action", true) ```
2020-12-13 15:22:42 +01:00
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match, &pressed, nullptr, nullptr);
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
return valid && !pressed;
}
Allow checking for exact matches with Action events. Added additional param to action related methods to test for exactness. If "p_exact_match" is true, then the action will only be "matched" if the provided input event *exactly* matches with the action event. Before: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * Is Action Pressed = True Now: You can still do the above, however you can optionally check that the input is exactly what the action event is: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * p_exact_match = True * Is Action Pressed = False * If the Input Event was only KEY_S, then the result would be true. Usage: ```gdscript Input.is_action_pressed(action_name: String, exact_match: bool) Input.is_action_pressed("my_action", true) InputMap.event_is_action(p_event, "my_action", true) func _input(event: InputEvent): event.is_action_pressed("my_action", false, true) # false = "allow_echo", true = "exact_match" event.is_action("my_action", true) ```
2020-12-13 15:22:42 +01: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 22:06:34 +01:00
float strength;
Allow checking for exact matches with Action events. Added additional param to action related methods to test for exactness. If "p_exact_match" is true, then the action will only be "matched" if the provided input event *exactly* matches with the action event. Before: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * Is Action Pressed = True Now: You can still do the above, however you can optionally check that the input is exactly what the action event is: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * p_exact_match = True * Is Action Pressed = False * If the Input Event was only KEY_S, then the result would be true. Usage: ```gdscript Input.is_action_pressed(action_name: String, exact_match: bool) Input.is_action_pressed("my_action", true) InputMap.event_is_action(p_event, "my_action", true) func _input(event: InputEvent): event.is_action_pressed("my_action", false, true) # false = "allow_echo", true = "exact_match" event.is_action("my_action", true) ```
2020-12-13 15:22:42 +01:00
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match, nullptr, &strength, nullptr);
Allow actions to provide an analog value
2018-02-21 22:06:34 +01: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 15:22:42 +01: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 11:22:35 +02:00
float raw_strength;
Allow checking for exact matches with Action events. Added additional param to action related methods to test for exactness. If "p_exact_match" is true, then the action will only be "matched" if the provided input event *exactly* matches with the action event. Before: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * Is Action Pressed = True Now: You can still do the above, however you can optionally check that the input is exactly what the action event is: * Action Event = KEY_S * Input Event = KEY_CONTROL + KEY_S * p_exact_match = True * Is Action Pressed = False * If the Input Event was only KEY_S, then the result would be true. Usage: ```gdscript Input.is_action_pressed(action_name: String, exact_match: bool) Input.is_action_pressed("my_action", true) InputMap.event_is_action(p_event, "my_action", true) func _input(event: InputEvent): event.is_action_pressed("my_action", false, true) # false = "allow_echo", true = "exact_match" event.is_action("my_action", true) ```
2020-12-13 15:22:42 +01:00
bool valid = InputMap::get_singleton()->event_get_action_status(Ref<InputEvent>((InputEvent *)this), p_action, p_exact_match, nullptr, nullptr, &raw_strength);
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
return valid ? raw_strength : 0.0f;
}
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
bool InputEvent::is_pressed() const {
return false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 17:38:03 +02:00
return false;
}
Ref<InputEvent> InputEvent::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
return Ref<InputEvent>((InputEvent *)this);
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
bool InputEvent::action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
return false;
}
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02:00
bool InputEvent::shortcut_match(const Ref<InputEvent> &p_event) const {
return false;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 15:22:42 +01: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 22:06:34 +01:00
ClassDB::bind_method(D_METHOD("is_pressed"), &InputEvent::is_pressed);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
ClassDB::bind_method(D_METHOD("is_echo"), &InputEvent::is_echo);
ClassDB::bind_method(D_METHOD("as_text"), &InputEvent::as_text);
Removes type information from method binds
2017-08-09 13:19:41 +02:00
ClassDB::bind_method(D_METHOD("shortcut_match", "event"), &InputEvent::shortcut_match);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 23:52:18 +01:00
ClassDB::bind_method(D_METHOD("accumulate", "with_event"), &InputEvent::accumulate);
Removes type information from method binds
2017-08-09 13:19:41 +02: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 15:28:19 +02: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 17:38:03 +02: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 17:01:17 +02:00
///////////////////////////////////
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01: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;
}
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 14:29:06 +02:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01: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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
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 16:23:51 +02:00
void InputEventWithModifiers::set_store_command(bool p_enabled) {
store_command = p_enabled;
}
bool InputEventWithModifiers::is_storing_command() const {
return store_command;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventWithModifiers::set_shift(bool p_enabled) {
shift = p_enabled;
}
bool InputEventWithModifiers::get_shift() const {
return shift;
}
void InputEventWithModifiers::set_alt(bool p_enabled) {
alt = p_enabled;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventWithModifiers::get_alt() const {
return alt;
}
void InputEventWithModifiers::set_control(bool p_enabled) {
control = p_enabled;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventWithModifiers::get_control() const {
return control;
}
void InputEventWithModifiers::set_metakey(bool p_enabled) {
meta = p_enabled;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventWithModifiers::get_metakey() const {
return meta;
}
void InputEventWithModifiers::set_command(bool p_enabled) {
command = p_enabled;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventWithModifiers::get_command() const {
return command;
}
Native pan and zoom for macOS
2017-11-01 21:49:39 +01:00
void InputEventWithModifiers::set_modifiers_from_event(const InputEventWithModifiers *event) {
set_alt(event->get_alt());
set_shift(event->get_shift());
set_control(event->get_control());
set_metakey(event->get_metakey());
}
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 14:55:23 +02:00
String InputEventWithModifiers::as_text() const {
Vector<String> mod_names;
if (get_control()) {
mod_names.push_back(find_keycode_name(KEY_CONTROL));
}
if (get_shift()) {
mod_names.push_back(find_keycode_name(KEY_SHIFT));
}
if (get_alt()) {
mod_names.push_back(find_keycode_name(KEY_ALT));
}
if (get_metakey()) {
mod_names.push_back(find_keycode_name(KEY_META));
}
Rename empty() to is_empty()
2020-12-15 13:04:21 +01: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 14:55:23 +02:00
return String("+").join(mod_names);
} else {
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 03:42:42 +01: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 14:55:23 +02: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 17:38:03 +02:00
void InputEventWithModifiers::_bind_methods() {
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 16:23:51 +02:00
ClassDB::bind_method(D_METHOD("set_store_command", "enable"), &InputEventWithModifiers::set_store_command);
ClassDB::bind_method(D_METHOD("is_storing_command"), &InputEventWithModifiers::is_storing_command);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
ClassDB::bind_method(D_METHOD("set_alt", "enable"), &InputEventWithModifiers::set_alt);
ClassDB::bind_method(D_METHOD("get_alt"), &InputEventWithModifiers::get_alt);
ClassDB::bind_method(D_METHOD("set_shift", "enable"), &InputEventWithModifiers::set_shift);
ClassDB::bind_method(D_METHOD("get_shift"), &InputEventWithModifiers::get_shift);
ClassDB::bind_method(D_METHOD("set_control", "enable"), &InputEventWithModifiers::set_control);
ClassDB::bind_method(D_METHOD("get_control"), &InputEventWithModifiers::get_control);
ClassDB::bind_method(D_METHOD("set_metakey", "enable"), &InputEventWithModifiers::set_metakey);
ClassDB::bind_method(D_METHOD("get_metakey"), &InputEventWithModifiers::get_metakey);
ClassDB::bind_method(D_METHOD("set_command", "enable"), &InputEventWithModifiers::set_command);
ClassDB::bind_method(D_METHOD("get_command"), &InputEventWithModifiers::get_command);
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 16:23:51 +02:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "store_command"), "set_store_command", "is_storing_command");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "alt"), "set_alt", "get_alt");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "shift"), "set_shift", "get_shift");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "control"), "set_control", "get_control");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "meta"), "set_metakey", "get_metakey");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "command"), "set_command", "get_command");
}
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 16:23:51 +02:00
void InputEventWithModifiers::_validate_property(PropertyInfo &property) const {
if (store_command) {
// If we only want to Store "Command".
#ifdef APPLE_STYLE_KEYS
// Don't store "Meta" on Mac.
if (property.name == "meta") {
property.usage ^= PROPERTY_USAGE_STORAGE;
}
#else
// Don't store "Control".
if (property.name == "control") {
property.usage ^= PROPERTY_USAGE_STORAGE;
}
#endif
} else {
// We don't want to store command, only control or meta (on mac).
if (property.name == "command") {
property.usage ^= PROPERTY_USAGE_STORAGE;
}
}
}
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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventKey::set_pressed(bool p_pressed) {
pressed = p_pressed;
}
Fix virtual methods in InputEventKey. This fixes a lot of problems with key input in the engine.
2017-05-25 21:54:18 +02:00
bool InputEventKey::is_pressed() const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
return pressed;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 19:59:35 +02:00
void InputEventKey::set_keycode(uint32_t p_keycode) {
keycode = p_keycode;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 19:59:35 +02:00
uint32_t InputEventKey::get_keycode() const {
return keycode;
}
void InputEventKey::set_physical_keycode(uint32_t p_keycode) {
physical_keycode = p_keycode;
}
uint32_t InputEventKey::get_physical_keycode() const {
return physical_keycode;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventKey::set_unicode(uint32_t p_unicode) {
unicode = p_unicode;
Added helper methods to InputEvent
2015-06-23 22:24:48 +02: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 19:59:35 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
uint32_t InputEventKey::get_unicode() const {
return unicode;
}
void InputEventKey::set_echo(bool p_enable) {
echo = p_enable;
}
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 19:59:35 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventKey::is_echo() const {
return echo;
Added helper methods to InputEvent
2015-06-23 22:24:48 +02: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 19:59:35 +02:00
uint32_t InputEventKey::get_keycode_with_modifiers() const {
uint32_t sc = keycode;
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 16:41:43 +02:00
if (get_control()) {
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 19:59:35 +02:00
sc |= KEY_MASK_CTRL;
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 16:41:43 +02:00
}
if (get_alt()) {
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 19:59:35 +02:00
sc |= KEY_MASK_ALT;
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 16:41:43 +02:00
}
if (get_shift()) {
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 19:59:35 +02:00
sc |= KEY_MASK_SHIFT;
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 16:41:43 +02:00
}
if (get_metakey()) {
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 19:59:35 +02:00
sc |= KEY_MASK_META;
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 16:41:43 +02: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 19:59:35 +02:00
return sc;
}
uint32_t InputEventKey::get_physical_keycode_with_modifiers() const {
uint32_t sc = physical_keycode;
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 16:41:43 +02:00
if (get_control()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
sc |= KEY_MASK_CTRL;
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 16:41:43 +02:00
}
if (get_alt()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
sc |= KEY_MASK_ALT;
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 16:41:43 +02:00
}
if (get_shift()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
sc |= KEY_MASK_SHIFT;
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 16:41:43 +02:00
}
if (get_metakey()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
sc |= KEY_MASK_META;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return sc;
}
Properly deliver localized coordinates when passing gui events through parents, closes #4215
2016-06-27 14:59:43 +02:00
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02: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 14:55:23 +02:00
String kc;
if (keycode == 0) {
kc = keycode_get_string(physical_keycode) + " (" + RTR("Physical") + ")";
} else {
kc = keycode_get_string(keycode);
}
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 16:41:43 +02:00
if (kc == String()) {
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02: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 16:41:43 +02:00
}
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02: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 14:55:23 +02:00
String mods_text = InputEventWithModifiers::as_text();
return mods_text == "" ? kc : mods_text + "+" + kc;
}
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 03:42:42 +01:00
String kc = "";
String physical = "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 14:55:23 +02:00
if (keycode == 0) {
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 03:42:42 +01:00
kc = itos(physical_keycode) + " " + keycode_get_string(physical_keycode);
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 14:55:23 +02:00
} else {
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 03:42:42 +01:00
kc = itos(keycode) + " " + keycode_get_string(keycode);
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02:00
}
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 03:42:42 +01:00
String mods = InputEventWithModifiers::as_text();
mods = mods == "" ? TTR("None") : mods;
return vformat("InputEventKey: keycode=%s mods=%s physical=%s pressed=%s echo=%s", kc, mods, physical, p, e);
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02:00
}
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 12:31:25 +01:00
Ref<InputEventKey> InputEventKey::create_reference(uint32_t p_keycode) {
Ref<InputEventKey> ie;
ie.instance();
ie->set_keycode(p_keycode & KEY_CODE_MASK);
ie->set_unicode(p_keycode & KEY_CODE_MASK);
if (p_keycode & KEY_MASK_SHIFT) {
ie->set_shift(true);
}
if (p_keycode & KEY_MASK_ALT) {
ie->set_alt(true);
}
if (p_keycode & KEY_MASK_CTRL) {
ie->set_control(true);
}
if (p_keycode & KEY_MASK_CMD) {
ie->set_command(true);
}
if (p_keycode & KEY_MASK_META) {
ie->set_metakey(true);
}
return ie;
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
bool InputEventKey::action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 16:41:43 +02: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 17:38:03 +02: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 16:41:43 +02:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 19:59:35 +02:00
bool match = false;
if (get_keycode() == 0) {
uint32_t code = get_physical_keycode_with_modifiers();
uint32_t event_code = key->get_physical_keycode_with_modifiers();
InputEvent: Restore old behaviour for matching key events to actions. Original code in 9100db7
2017-05-30 22:27:31 +02: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 19:59:35 +02:00
match = get_physical_keycode() == key->get_physical_keycode() && (!key->is_pressed() || (code & event_code) == code);
} else {
uint32_t code = get_keycode_with_modifiers();
uint32_t event_code = key->get_keycode_with_modifiers();
match = get_keycode() == key->get_keycode() && (!key->is_pressed() || (code & event_code) == code);
}
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
if (match) {
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 16:41:43 +02:00
if (p_pressed != nullptr) {
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
*p_pressed = key->is_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 16:41:43 +02:00
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
float strength = (p_pressed != nullptr && *p_pressed) ? 1.0f : 0.0f;
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 16:41:43 +02:00
if (p_strength != nullptr) {
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
*p_strength = strength;
}
if (p_raw_strength != nullptr) {
*p_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 16:41:43 +02:00
}
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
}
return match;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
}
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02:00
bool InputEventKey::shortcut_match(const Ref<InputEvent> &p_event) const {
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 16:41:43 +02:00
if (key.is_null()) {
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02: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 16:41:43 +02:00
}
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02: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 19:59:35 +02:00
uint32_t code = get_keycode_with_modifiers();
uint32_t event_code = key->get_keycode_with_modifiers();
Fix shortcuts, make them visible again and work.
2017-06-23 00:57:59 +02:00
return code == event_code;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 19:59:35 +02: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 17:38:03 +02:00
ClassDB::bind_method(D_METHOD("set_unicode", "unicode"), &InputEventKey::set_unicode);
ClassDB::bind_method(D_METHOD("get_unicode"), &InputEventKey::get_unicode);
ClassDB::bind_method(D_METHOD("set_echo", "echo"), &InputEventKey::set_echo);
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 19:59:35 +02: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);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 19:59:35 +02:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "keycode"), "set_keycode", "get_keycode");
ADD_PROPERTY(PropertyInfo(Variant::INT, "physical_keycode"), "set_physical_keycode", "get_physical_keycode");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "unicode"), "set_unicode", "get_unicode");
Fix InputEventKey::echo type from INT to BOOL
2020-03-01 07:52:37 +01: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 17:38:03 +02: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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventMouse::set_button_mask(int p_mask) {
button_mask = p_mask;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
int InputEventMouse::get_button_mask() const {
return button_mask;
}
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02: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 14:29:06 +02:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02:00
return pos;
}
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02: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 14:29:06 +02:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02: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 10:54:24 +02: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 17:38:03 +02:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_mask"), "set_button_mask", "get_button_mask");
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "global_position"), "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 17:38:03 +02: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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventMouseButton::set_factor(float p_factor) {
factor = p_factor;
}
Add const to InputEventMouseButton::get_factor
2020-04-25 13:25:00 +02: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 17:38:03 +02:00
return factor;
}
void InputEventMouseButton::set_button_index(int p_index) {
button_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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
int InputEventMouseButton::get_button_index() const {
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventMouseButton::is_pressed() const {
return pressed;
}
void InputEventMouseButton::set_doubleclick(bool p_doubleclick) {
doubleclick = p_doubleclick;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventMouseButton::is_doubleclick() const {
return doubleclick;
}
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-03 00:58:10 +02:00
Vector2 g = get_global_position();
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02:00
Ref<InputEventMouseButton> mb;
mb.instance();
mb->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01:00
mb->set_window_id(get_window_id());
Native pan and zoom for macOS
2017-11-01 21:49:39 +01: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 17:38:03 +02:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02:00
mb->set_button_mask(get_button_mask());
mb->set_pressed(pressed);
mb->set_doubleclick(doubleclick);
mb->set_factor(factor);
mb->set_button_index(button_index);
return mb;
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
bool InputEventMouseButton::action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 16:41:43 +02: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 17:38:03 +02: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 16:41:43 +02:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
bool match = mb->button_index == button_index;
if (match) {
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 16:41:43 +02:00
if (p_pressed != nullptr) {
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
*p_pressed = mb->is_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 16:41:43 +02:00
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
float strength = (p_pressed != nullptr && *p_pressed) ? 1.0f : 0.0f;
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 16:41:43 +02:00
if (p_strength != nullptr) {
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
*p_strength = strength;
}
if (p_raw_strength != nullptr) {
*p_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 16:41:43 +02:00
}
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
}
return match;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 14:55:23 +02: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 18:14:36 +02: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 14:55:23 +02:00
// Modifiers
String mods_text = InputEventWithModifiers::as_text();
String full_string = mods_text == "" ? "" : mods_text + "+";
// Button
int idx = get_button_index();
switch (idx) {
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
case BUTTON_LEFT:
case BUTTON_RIGHT:
case BUTTON_MIDDLE:
case BUTTON_WHEEL_UP:
case BUTTON_WHEEL_DOWN:
case BUTTON_WHEEL_LEFT:
case BUTTON_WHEEL_RIGHT:
Added support for extra mouse buttons.
2018-07-05 16:50:30 +02:00
case BUTTON_XBUTTON1:
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 14:55:23 +02:00
case BUTTON_XBUTTON2:
full_string += RTR(_mouse_button_descriptions[idx - 1]); // button index starts from 1, array index starts from 0, so subtract 1
break;
default:
full_string += RTR("Button") + " #" + itos(idx);
Added support for extra mouse buttons.
2018-07-05 16:50:30 +02: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 14:55:23 +02:00
}
// Double Click
if (doubleclick) {
full_string += " (" + RTR("Double Click") + ")";
}
return full_string;
}
String InputEventMouseButton::to_string() {
String p = is_pressed() ? "true" : "false";
String d = doubleclick ? "true" : "false";
int idx = get_button_index();
String button_string = itos(idx);
switch (idx) {
case BUTTON_LEFT:
case BUTTON_RIGHT:
case BUTTON_MIDDLE:
case BUTTON_WHEEL_UP:
case BUTTON_WHEEL_DOWN:
case BUTTON_WHEEL_LEFT:
case BUTTON_WHEEL_RIGHT:
case BUTTON_XBUTTON1:
Added support for extra mouse buttons.
2018-07-05 16:50:30 +02:00
case BUTTON_XBUTTON2:
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 14:55:23 +02:00
button_string += " (" + RTR(_mouse_button_descriptions[idx - 1]) + ")"; // button index starts from 1, array index starts from 0, so subtract 1
Added support for extra mouse buttons.
2018-07-05 16:50:30 +02:00
break;
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02: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 14:55:23 +02:00
Fixed mistakes in InputEvent as_text and to_string implementations.
2020-12-14 03:42:42 +01:00
String mods = InputEventWithModifiers::as_text();
mods = mods == "" ? TTR("None") : mods;
// Work around the fact vformat can only take 5 substitutions but 6 need to be passed.
String index_and_mods = vformat("button_index=%s mods=%s", button_index, mods);
return vformat("InputEventMouseButton: %s pressed=%s position=(%s) button_mask=%s doubleclick=%s", index_and_mods, p, String(get_position()), itos(get_button_mask()), d);
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventMouseButton::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_factor", "factor"), &InputEventMouseButton::set_factor);
ClassDB::bind_method(D_METHOD("get_factor"), &InputEventMouseButton::get_factor);
ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventMouseButton::set_button_index);
ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventMouseButton::get_button_index);
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventMouseButton::set_pressed);
// ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventMouseButton::is_pressed);
ClassDB::bind_method(D_METHOD("set_doubleclick", "doubleclick"), &InputEventMouseButton::set_doubleclick);
ClassDB::bind_method(D_METHOD("is_doubleclick"), &InputEventMouseButton::is_doubleclick);
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 19:20:53 +01: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 17:38:03 +02:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "doubleclick"), "set_doubleclick", "is_doubleclick");
}
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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 21:32:11 +01: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;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 21:32:11 +01:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
Vector2 InputEventMouseMotion::get_relative() const {
return relative;
}
void InputEventMouseMotion::set_speed(const Vector2 &p_speed) {
speed = p_speed;
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 21:32:11 +01:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
Vector2 InputEventMouseMotion::get_speed() const {
return speed;
}
Ref<InputEvent> InputEventMouseMotion::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Don't transform global position of mouse input
2019-09-03 00:58:10 +02:00
Vector2 g = get_global_position();
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02:00
Vector2 r = p_xform.basis_xform(get_relative());
Vector2 s = p_xform.basis_xform(get_speed());
Ref<InputEventMouseMotion> mm;
mm.instance();
mm->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01: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 17:38:03 +02:00
Native pan and zoom for macOS
2017-11-01 21:49:39 +01: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 17:38:03 +02:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02:00
mm->set_position(l);
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 21:32:11 +01:00
mm->set_pressure(get_pressure());
mm->set_tilt(get_tilt());
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02:00
mm->set_global_position(g);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
mm->set_button_mask(get_button_mask());
mm->set_relative(r);
mm->set_speed(s);
return mm;
}
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
String InputEventMouseMotion::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 14:55:23 +02:00
return vformat(RTR("Mouse motion at position (%s) with speed (%s)"), String(get_position()), String(get_speed()));
}
String InputEventMouseMotion::to_string() {
int button_mask = get_button_mask();
String button_mask_string = itos(button_mask);
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
switch (get_button_mask()) {
case BUTTON_MASK_LEFT:
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 14:55:23 +02:00
button_mask_string += " (" + RTR(_mouse_button_descriptions[BUTTON_LEFT - 1]) + ")";
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
break;
case BUTTON_MASK_MIDDLE:
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 14:55:23 +02:00
button_mask_string += " (" + RTR(_mouse_button_descriptions[BUTTON_MIDDLE - 1]) + ")";
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
break;
case BUTTON_MASK_RIGHT:
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 14:55:23 +02:00
button_mask_string += " (" + RTR(_mouse_button_descriptions[BUTTON_RIGHT - 1]) + ")";
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
break;
Added support for extra mouse buttons.
2018-07-05 16:50:30 +02:00
case BUTTON_MASK_XBUTTON1:
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 14:55:23 +02:00
button_mask_string += " (" + RTR(_mouse_button_descriptions[BUTTON_XBUTTON1 - 1]) + ")";
Added support for extra mouse buttons.
2018-07-05 16:50:30 +02:00
break;
case BUTTON_MASK_XBUTTON2:
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 14:55:23 +02:00
button_mask_string += " (" + RTR(_mouse_button_descriptions[BUTTON_XBUTTON2 - 1]) + ")";
Added support for extra mouse buttons.
2018-07-05 16:50:30 +02:00
break;
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02: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 14:55:23 +02:00
[Windows] Add support for the WinTab API for pen input.
2020-05-05 13:16:02 +02:00
return "InputEventMouseMotion : button_mask=" + button_mask_string + ", position=(" + String(get_position()) + "), relative=(" + String(get_relative()) + "), speed=(" + String(get_speed()) + "), pressure=(" + rtos(get_pressure()) + "), tilt=(" + String(get_tilt()) + ")";
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
}
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 23:52:18 +01: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 16:41:43 +02:00
if (motion.is_null()) {
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 23:52:18 +01: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 16:41:43 +02:00
}
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 23:52:18 +01:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01:00
if (get_window_id() != motion->get_window_id()) {
return false;
}
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 23:52:18 +01:00
if (is_pressed() != motion->is_pressed()) {
return false;
}
if (get_button_mask() != motion->get_button_mask()) {
return false;
}
if (get_shift() != motion->get_shift()) {
return false;
}
if (get_control() != motion->get_control()) {
return false;
}
if (get_alt() != motion->get_alt()) {
return false;
}
if (get_metakey() != motion->get_metakey()) {
return false;
}
set_position(motion->get_position());
set_global_position(motion->get_global_position());
set_speed(motion->get_speed());
relative += motion->get_relative();
return true;
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventMouseMotion::_bind_methods() {
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 21:32:11 +01: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);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventMouseMotion::set_relative);
ClassDB::bind_method(D_METHOD("get_relative"), &InputEventMouseMotion::get_relative);
ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventMouseMotion::set_speed);
ClassDB::bind_method(D_METHOD("get_speed"), &InputEventMouseMotion::get_speed);
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 21:32:11 +01: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 19:20:53 +01: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 17:38:03 +02:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed");
}
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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventJoypadMotion::set_axis(int p_axis) {
axis = p_axis;
}
int InputEventJoypadMotion::get_axis() const {
return axis;
}
void InputEventJoypadMotion::set_axis_value(float p_value) {
axis_value = p_value;
}
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
float InputEventJoypadMotion::get_axis_value() const {
return axis_value;
}
InputEventJoypadMotion: Add missing is_pressed() method.
2017-08-12 13:03:44 +02:00
bool InputEventJoypadMotion::is_pressed() const {
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
return Math::abs(axis_value) >= 0.5f;
InputEventJoypadMotion: Add missing is_pressed() method.
2017-08-12 13:03:44 +02:00
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
bool InputEventJoypadMotion::action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 16:41:43 +02: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 17:38:03 +02: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 16:41:43 +02:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
Fixing input strength and the impossibility to erase action events
2018-04-25 22:29:39 +02:00
bool match = (axis == jm->axis); // Matches even if not in the same direction, but returns a "not pressed" event.
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
if (match) {
Add raw strength value for internal use
2020-10-24 11:22:35 +02: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 22:29:39 +02:00
bool same_direction = (((axis_value < 0) == (jm->axis_value < 0)) || jm->axis_value == 0);
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
bool pressed = same_direction && jm_abs_axis_value >= p_deadzone;
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 16:41:43 +02:00
if (p_pressed != nullptr) {
Fixing input strength and the impossibility to erase action events
2018-04-25 22:29:39 +02:00
*p_pressed = 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 16:41:43 +02:00
}
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
if (p_strength != nullptr) {
Fix NaN with get_action_strength
2019-05-15 11:21:10 +02:00
if (pressed) {
if (p_deadzone == 1.0f) {
*p_strength = 1.0f;
} else {
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
*p_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 11:21:10 +02:00
}
} else {
*p_strength = 0.0f;
}
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
if (p_raw_strength != nullptr) {
if (same_direction) { // NOT pressed, because we want to ignore the deadzone.
*p_raw_strength = jm_abs_axis_value;
} else {
*p_raw_strength = 0.0f;
}
}
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
}
return match;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 14:55:23 +02:00
static const char *_joy_axis_descriptions[JOY_AXIS_MAX] = {
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 18:14:36 +02:00
String InputEventJoypadMotion::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 14:55:23 +02:00
String desc = axis < JOY_AXIS_MAX ? RTR(_joy_axis_descriptions[axis]) : TTR("Unknown Joypad Axis");
return vformat(TTR("Joypad Motion on Axis %s (%s) with Value %s"), itos(axis), desc, String(Variant(axis_value)));
}
String InputEventJoypadMotion::to_string() {
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
return "InputEventJoypadMotion : axis=" + itos(axis) + ", axis_value=" + String(Variant(axis_value));
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 19:20:53 +01: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 17:38:03 +02: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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventJoypadButton::set_button_index(int p_index) {
button_index = p_index;
}
int InputEventJoypadButton::get_button_index() const {
return button_index;
}
void InputEventJoypadButton::set_pressed(bool p_pressed) {
pressed = p_pressed;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventJoypadButton::is_pressed() const {
return pressed;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
float InputEventJoypadButton::get_pressure() const {
return pressure;
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
bool InputEventJoypadButton::action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 16:41:43 +02: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 17:38:03 +02: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 16:41:43 +02:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
bool match = button_index == jb->button_index;
if (match) {
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 16:41:43 +02:00
if (p_pressed != nullptr) {
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
*p_pressed = jb->is_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 16:41:43 +02:00
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
float strength = (p_pressed != nullptr && *p_pressed) ? 1.0f : 0.0f;
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 16:41:43 +02:00
if (p_strength != nullptr) {
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
*p_strength = strength;
}
if (p_raw_strength != nullptr) {
*p_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 16:41:43 +02:00
}
Allow actions to provide an analog value
2018-02-21 22:06:34 +01:00
}
return match;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
}
Make Button shortcuts triggerable by gamepads This closes #25741.
2019-02-16 00:26:07 +01:00
bool InputEventJoypadButton::shortcut_match(const Ref<InputEvent> &p_event) const {
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 16:41:43 +02:00
if (button.is_null()) {
Make Button shortcuts triggerable by gamepads This closes #25741.
2019-02-16 00:26:07 +01: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 16:41:43 +02:00
}
Make Button shortcuts triggerable by gamepads This closes #25741.
2019-02-16 00:26:07 +01:00
return button_index == button->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 14:55:23 +02:00
static const char *_joy_button_descriptions[JOY_BUTTON_SDL_MAX] = {
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"),
TTRC("Start, Nintendo +"),
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 14:52:38 +01: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 14:55:23 +02:00
};
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
String InputEventJoypadButton::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 14:55:23 +02:00
String text = "Joypad Button " + itos(button_index);
if (button_index < JOY_BUTTON_SDL_MAX) {
text += vformat(" (%s)", _joy_button_descriptions[button_index]);
}
if (pressure != 0) {
text += ", Pressure:" + String(Variant(pressure));
}
return text;
}
String InputEventJoypadButton::to_string() {
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
return "InputEventJoypadButton : button_index=" + itos(button_index) + ", pressed=" + (pressed ? "true" : "false") + ", pressure=" + String(Variant(pressure));
}
Added convenience create_reference methods for Key and JoyButton inputs
2020-12-07 12:31:25 +01:00
Ref<InputEventJoypadButton> InputEventJoypadButton::create_reference(int p_btn_index) {
Ref<InputEventJoypadButton> ie;
ie.instance();
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 17:38:03 +02:00
void InputEventJoypadButton::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventJoypadButton::set_button_index);
ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventJoypadButton::get_button_index);
ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventJoypadButton::set_pressure);
ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventJoypadButton::get_pressure);
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventJoypadButton::set_pressed);
// ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventJoypadButton::is_pressed);
ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index");
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 19:20:53 +01: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 17:38:03 +02: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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
int InputEventScreenTouch::get_index() const {
return index;
}
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02: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 14:29:06 +02:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02: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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventScreenTouch::is_pressed() const {
return pressed;
}
Ref<InputEvent> InputEventScreenTouch::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventScreenTouch> st;
st.instance();
st->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01: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 17:38:03 +02:00
st->set_index(index);
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02:00
st->set_pressed(pressed);
return st;
}
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
String InputEventScreenTouch::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 14:55:23 +02:00
String status = pressed ? RTR("touched") : RTR("released");
return vformat(RTR("Screen %s at (%s) with %s touch points"), status, String(get_position()), itos(index));
}
String InputEventScreenTouch::to_string() {
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
return "InputEventScreenTouch : index=" + itos(index) + ", pressed=" + (pressed ? "true" : "false") + ", position=(" + String(get_position()) + ")";
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 15:37:49 +02: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 10:54:24 +02: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 17:38:03 +02:00
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventScreenTouch::set_pressed);
//ClassDB::bind_method(D_METHOD("is_pressed"),&InputEventScreenTouch::is_pressed);
ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index");
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventScreenDrag::set_index(int p_index) {
index = p_index;
}
int InputEventScreenDrag::get_index() const {
return index;
}
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02: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 14:29:06 +02:00
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02: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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
Vector2 InputEventScreenDrag::get_relative() const {
return relative;
}
void InputEventScreenDrag::set_speed(const Vector2 &p_speed) {
speed = p_speed;
}
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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
Vector2 InputEventScreenDrag::get_speed() const {
return speed;
}
Ref<InputEvent> InputEventScreenDrag::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventScreenDrag> sd;
sd.instance();
sd->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01: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 17:38:03 +02:00
sd->set_index(index);
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02:00
sd->set_relative(p_xform.basis_xform(relative));
sd->set_speed(p_xform.basis_xform(speed));
return sd;
}
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
String InputEventScreenDrag::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 14:55:23 +02:00
return vformat(RTR("Screen dragged with %s touch points at position (%s) with speed of (%s)"), itos(index), String(get_position()), String(get_speed()));
}
String InputEventScreenDrag::to_string() {
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
return "InputEventScreenDrag : index=" + itos(index) + ", position=(" + String(get_position()) + "), relative=(" + String(get_relative()) + "), speed=(" + String(get_speed()) + ")";
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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);
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02: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 17:38:03 +02:00
ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventScreenDrag::set_relative);
ClassDB::bind_method(D_METHOD("get_relative"), &InputEventScreenDrag::get_relative);
ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventScreenDrag::set_speed);
ClassDB::bind_method(D_METHOD("get_speed"), &InputEventScreenDrag::get_speed);
ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index");
InputEvent: Renamed "pos" property to "position" Make the naming consistent with other classes.
2017-06-03 10:54:24 +02:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed");
}
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 17:01:17 +02:00
///////////////////////////////////
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02: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 14:29:06 +02:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventAction::is_pressed() const {
return pressed;
}
Add configurable strength value to InputEventAction
2019-06-01 15:31:47 +02:00
void InputEventAction::set_strength(float p_strength) {
strength = CLAMP(p_strength, 0.0f, 1.0f);
}
float InputEventAction::get_strength() const {
return strength;
}
Fixed shortcuts not working with InputEventActions
2018-07-27 13:02:30 +02:00
bool InputEventAction::shortcut_match(const Ref<InputEvent> &p_event) 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 16:41:43 +02:00
if (p_event.is_null()) {
Fixed shortcuts not working with InputEventActions
2018-07-27 13:02:30 +02: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 16:41:43 +02:00
}
Fixed shortcuts not working with InputEventActions
2018-07-27 13:02:30 +02:00
Make Button shortcuts triggerable by gamepads This closes #25741.
2019-02-16 00:26:07 +01:00
return p_event->is_action(action);
Fixed shortcuts not working with InputEventActions
2018-07-27 13:02:30 +02:00
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
bool InputEventAction::is_action(const StringName &p_action) const {
return action == p_action;
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
bool InputEventAction::action_match(const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength, float *p_raw_strength, float p_deadzone) const {
Fix is_action_pressed for InputEventAction.
2018-09-10 21:15:06 +02: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 16:41:43 +02:00
if (act.is_null()) {
Fix is_action_pressed for InputEventAction.
2018-09-10 21:15:06 +02: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 16:41:43 +02:00
}
Fix is_action_pressed for InputEventAction.
2018-09-10 21:15:06 +02:00
bool match = action == act->action;
if (match) {
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 16:41:43 +02:00
if (p_pressed != nullptr) {
Fix is_action_pressed for InputEventAction.
2018-09-10 21:15:06 +02:00
*p_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 16:41:43 +02:00
}
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
float strength = (p_pressed != nullptr && *p_pressed) ? 1.0f : 0.0f;
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 16:41:43 +02:00
if (p_strength != nullptr) {
Add raw strength value for internal use
2020-10-24 11:22:35 +02:00
*p_strength = strength;
}
if (p_raw_strength != nullptr) {
*p_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 16:41:43 +02:00
}
Fix is_action_pressed for InputEventAction.
2018-09-10 21:15:06 +02:00
}
return match;
}
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
String InputEventAction::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 14:55:23 +02:00
return vformat(RTR("Input Action %s was %s"), action, pressed ? "pressed" : "released");
}
String InputEventAction::to_string() {
Show proper string with InputEvent.as_text()
2017-08-24 18:14:36 +02:00
return "InputEventAction : action=" + action + ", pressed=(" + (pressed ? "true" : "false");
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
void InputEventAction::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_action", "action"), &InputEventAction::set_action);
ClassDB::bind_method(D_METHOD("get_action"), &InputEventAction::get_action);
ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventAction::set_pressed);
//ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventAction::is_pressed);
Add configurable strength value to InputEventAction
2019-06-01 15:31:47 +02:00
ClassDB::bind_method(D_METHOD("set_strength", "strength"), &InputEventAction::set_strength);
ClassDB::bind_method(D_METHOD("get_strength"), &InputEventAction::get_strength);
-Fix the "set_val" call deferred, it was the only one.. closes #8742 -Removed redundant bind in input_event
2017-05-23 14:06:22 +02:00
// ClassDB::bind_method(D_METHOD("is_action", "name"), &InputEventAction::is_action);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
Added StringName as a variant type. Also changed all relevant properties defined manually to StringName.
2020-02-20 22:58:05 +01: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 17:38:03 +02: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 19:20:53 +01: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 17:38:03 +02:00
}
Properly deliver localized coordinates when passing gui events through parents, closes #4215
2016-06-27 14:59:43 +02: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 17:01:17 +02:00
///////////////////////////////////
Native pan and zoom for macOS
2017-11-01 21:49:39 +01:00
void InputEventGesture::set_position(const Vector2 &p_pos) {
pos = p_pos;
}
Core: Bind InputEventGesture events.
2017-11-24 19:22:33 +01:00
void InputEventGesture::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_position", "position"), &InputEventGesture::set_position);
ClassDB::bind_method(D_METHOD("get_position"), &InputEventGesture::get_position);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
}
Native pan and zoom for macOS
2017-11-01 21:49:39 +01: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 17:01:17 +02:00
///////////////////////////////////
Native pan and zoom for macOS
2017-11-01 21:49:39 +01: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;
ev.instance();
ev->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01:00
ev->set_window_id(get_window_id());
Native pan and zoom for macOS
2017-11-01 21:49:39 +01: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 04:25:50 +01: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 14:55:23 +02:00
return vformat(RTR("Magnify Gesture at (%s) with factor %s"), String(get_position()), rtos(get_factor()));
}
String InputEventMagnifyGesture::to_string() {
(Magnify|Pan)Gesture: implement as_text
2018-02-24 04:25:50 +01:00
return "InputEventMagnifyGesture : factor=" + rtos(get_factor()) + ", position=(" + String(get_position()) + ")";
}
Core: Bind InputEventGesture events.
2017-11-24 19:22:33 +01: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 19:20:53 +01:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "factor"), "set_factor", "get_factor");
Core: Bind InputEventGesture events.
2017-11-24 19:22:33 +01: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 17:01:17 +02:00
///////////////////////////////////
Native pan and zoom for macOS
2017-11-01 21:49:39 +01: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;
ev.instance();
ev->set_device(get_device());
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 23:14:37 +01:00
ev->set_window_id(get_window_id());
Native pan and zoom for macOS
2017-11-01 21:49:39 +01: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 04:25:50 +01: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 14:55:23 +02:00
return vformat(RTR("Pan Gesture at (%s) with delta (%s)"), String(get_position()), String(get_delta()));
}
String InputEventPanGesture::to_string() {
(Magnify|Pan)Gesture: implement as_text
2018-02-24 04:25:50 +01:00
return "InputEventPanGesture : delta=(" + String(get_delta()) + "), position=(" + String(get_position()) + ")";
}
Core: Bind InputEventGesture events.
2017-11-24 19:22:33 +01: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 17:01:17 +02:00
///////////////////////////////////
Added a new MIDIDriver class
2018-07-14 14:11:28 +02:00
void InputEventMIDI::set_channel(const int p_channel) {
channel = p_channel;
}
int InputEventMIDI::get_channel() const {
return channel;
}
void InputEventMIDI::set_message(const int p_message) {
message = p_message;
}
int InputEventMIDI::get_message() const {
return message;
}
void InputEventMIDI::set_pitch(const int p_pitch) {
pitch = p_pitch;
}
int InputEventMIDI::get_pitch() const {
return pitch;
}
void InputEventMIDI::set_velocity(const int p_velocity) {
velocity = p_velocity;
}
int InputEventMIDI::get_velocity() const {
return velocity;
}
void InputEventMIDI::set_instrument(const int p_instrument) {
instrument = p_instrument;
}
int InputEventMIDI::get_instrument() const {
return instrument;
}
void InputEventMIDI::set_pressure(const int p_pressure) {
pressure = p_pressure;
}
int InputEventMIDI::get_pressure() const {
return pressure;
}
void InputEventMIDI::set_controller_number(const int p_controller_number) {
controller_number = p_controller_number;
}
int InputEventMIDI::get_controller_number() const {
return controller_number;
}
void InputEventMIDI::set_controller_value(const int p_controller_value) {
controller_value = p_controller_value;
}
int InputEventMIDI::get_controller_value() const {
return controller_value;
}
String InputEventMIDI::as_text() const {
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 14:55:23 +02:00
return vformat(RTR("MIDI Input on Channel=%s Message=%s"), itos(channel), itos(message));
}
String InputEventMIDI::to_string() {
return vformat("InputEvenMIDI: channel=%s message=%s pitch=%s velocity=%s pressure=%s", itos(channel), itos(message), itos(pitch), itos(velocity), itos(pressure));
Added a new MIDIDriver class
2018-07-14 14:11:28 +02: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");
}
Reference in a new issue Copy permalink