maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge ea14efef20 into 1aa3c8419b

Browse source
This commit is contained in:
Jérémy Zurcher 2021-11-11 13:05:31 +01:00 committed by GitHub
parent 1aa3c8419b ea14efef20
commit eb1982a8f6
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
28 changed files with 364 additions and 154 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

110
core/input/input.cpp
View file

@ -183,7 +183,7 @@ void Input::get_argument_options(const StringName &p_function, int p_idx, List<S
}
}
void Input::SpeedTrack::update(const Vector2 &p_delta_p) {
void Input::TouchTrack::update(const Vector2 &p_delta_p) {
uint64_t tick = OS::get_singleton()->get_ticks_usec();
uint32_t tdiff = tick - last_tick;
float delta_t = tdiff / 1000000.0;
@ -191,6 +191,8 @@ void Input::SpeedTrack::update(const Vector2 &p_delta_p) {
accum += p_delta_p;
accum_t += delta_t;
last_delta = p_delta_p;
position += p_delta_p;
if (accum_t > max_ref_frame * 10) {
accum_t = max_ref_frame * 10;
@ -206,16 +208,25 @@ void Input::SpeedTrack::update(const Vector2 &p_delta_p) {
}
}
void Input::SpeedTrack::reset() {
void Input::TouchTrack::reset(const Vector2 &p_position_p) {
last_tick = OS::get_singleton()->get_ticks_usec();
speed = Vector2();
position = p_position_p;
last_delta = Vector2();
accum_t = 0;
}
Input::SpeedTrack::SpeedTrack() {
int Input::TouchTrack::sector(const Vector2 &p_center_p) {
Point2 adjusted_position = p_center_p - position;
float raw_angle = fmod(adjusted_position.angle_to(last_delta) + (Math_PI / 4), Math_TAU);
float adjusted_angle = raw_angle >= 0 ? raw_angle : raw_angle + Math_TAU;
return floor(adjusted_angle / (Math_PI / 2));
}
Input::TouchTrack::TouchTrack() {
min_ref_frame = 0.1;
max_ref_frame = 0.3;
reset();
reset(Vector2());
}
bool Input::is_key_pressed(Key p_keycode) const {
@ -454,6 +465,7 @@ void Input::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_em
// require additional handling by this class.
Ref<InputEventKey> k = p_event;
if (k.is_valid() && !k->is_echo() && k->get_keycode() != 0) {
if (k->is_pressed()) {
keys_pressed.insert(k->get_keycode());
@ -509,12 +521,11 @@ void Input::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_em
if (st.is_valid()) {
if (st->is_pressed()) {
SpeedTrack &track = touch_speed_track[st->get_index()];
track.reset();
touch_track[st->get_index()].reset(st->get_position());
} else {
// Since a pointer index may not occur again (OSs may or may not reuse them),
// imperatively remove it from the map to keep no fossil entries in it
touch_speed_track.erase(st->get_index());
touch_track.erase(st->get_index());
}
if (emulate_mouse_from_touch) {
@ -554,9 +565,9 @@ void Input::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_em
Ref<InputEventScreenDrag> sd = p_event;
if (sd.is_valid()) {
SpeedTrack &track = touch_speed_track[sd->get_index()];
track.update(sd->get_relative());
sd->set_speed(track.speed);
TouchTrack &touch = touch_track[sd->get_index()];
touch.update(sd->get_relative());
sd->set_speed(touch.speed);
if (emulate_mouse_from_touch && sd->get_index() == mouse_from_touch_index) {
Ref<InputEventMouseMotion> motion_event;
@ -571,6 +582,79 @@ void Input::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_em
_parse_input_event_impl(motion_event, true);
}
int sz = touch_track.size();
if (sz > 1) {
Point2 center = Point2();
for (Map<int, TouchTrack>::Element *e = touch_track.front(); e; e = e->next()) {
center += e->get().position;
}
center /= sz;
int sector = -1;
for (Map<int, TouchTrack>::Element *e = touch_track.front(); e; e = e->next()) {
int e_sector = e->get().sector(center);
if (sector == -1) {
sector = e_sector;
} else if (sector != e_sector) {
sector = -1;
break;
}
}
if (sector == -1) {
Point2 speed = Point2();
Point2 relative = Point2();
for (Map<int, TouchTrack>::Element *e = touch_track.front(); e; e = e->next()) {
TouchTrack &track = e->get();
speed += track.speed;
relative += track.last_delta;
}
speed /= sz;
relative /= sz;
Ref<InputEventGesturePan> ev;
ev.instantiate();
ev->set_touches(sz);
ev->set_position(center);
ev->set_speed(speed);
ev->set_relative(relative);
_parse_input_event_impl(ev, false);
} else if (sector == 0 || sector == 2) {
float distance = 0;
float distance_p = 0;
for (Map<int, TouchTrack>::Element *e = touch_track.front(); e; e = e->next()) {
TouchTrack &track = e->get();
Vector2 d = track.position - center;
distance += d.length();
distance_p += (d + (track.last_delta / sz)).length();
}
distance /= sz;
distance_p /= sz;
Ref<InputEventGesturePinch> ev;
ev.instantiate();
ev->set_touches(sz);
ev->set_position(center);
ev->set_distance(distance);
ev->set_factor(distance / distance_p);
_parse_input_event_impl(ev, false);
} else if (sector == 1 || sector == 3) {
float rotation = 0;
for (Map<int, TouchTrack>::Element *e = touch_track.front(); e; e = e->next()) {
TouchTrack &track = e->get();
rotation += (track.position - center).angle_to(track.position + (track.last_delta / sz) - center);
}
rotation /= sz;
Ref<InputEventGestureTwist> ev;
ev.instantiate();
ev->set_touches(sz);
ev->set_position(center);
ev->set_rotation(rotation);
_parse_input_event_impl(ev, false);
}
}
}
Ref<InputEventJoypadButton> jb = p_event;
@ -593,12 +677,6 @@ void Input::_parse_input_event_impl(const Ref<InputEvent> &p_event, bool p_is_em
Ref<InputEventGesture> ge = p_event;
if (ge.is_valid()) {
if (event_dispatch_function) {
event_dispatch_function(ge);
}
}
for (OrderedHashMap<StringName, InputMap::Action>::ConstElement E = InputMap::get_singleton()->get_action_map().front(); E; E = E.next()) {
if (InputMap::get_singleton()->event_is_action(p_event, E.key())) {
// If not echo and action pressed state has changed

13
core/input/input.h
View file

@ -116,8 +116,10 @@ private:
int mouse_from_touch_index = -1;
struct SpeedTrack {
struct TouchTrack {
uint64_t last_tick;
Vector2 position;
Vector2 last_delta;
Vector2 speed;
Vector2 accum;
float accum_t;
@ -125,8 +127,9 @@ private:
float max_ref_frame;
void update(const Vector2 &p_delta_p);
void reset();
SpeedTrack();
void reset(const Vector2 &p_position_p);
int sector(const Vector2 &p_center_p);
TouchTrack();
};
struct Joypad {
@ -140,8 +143,8 @@ private:
int hat_current = 0;
};
SpeedTrack mouse_speed_track;
Map<int, SpeedTrack> touch_speed_track;
TouchTrack mouse_speed_track;
Map<int, TouchTrack> touch_track;
Map<int, Joypad> joy_names;
int fallback_mapping = -1;

155
core/input/input_event.cpp
View file

@ -1348,98 +1348,165 @@ void InputEventGesture::set_position(const Vector2 &p_pos) {
pos = p_pos;
}
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");
}
Vector2 InputEventGesture::get_position() const {
return pos;
}
void InputEventGesture::set_touches(const int p_touches) {
touches = p_touches;
}
int InputEventGesture::get_touches() const {
return touches;
}
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);
ClassDB::bind_method(D_METHOD("set_touches", "touches"), &InputEventGesture::set_touches);
ClassDB::bind_method(D_METHOD("get_touches"), &InputEventGesture::get_touches);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position"), "set_position", "get_position");
ADD_PROPERTY(PropertyInfo(Variant::INT, "touches"), "set_touches", "get_touches");
}
///////////////////////////////////
void InputEventMagnifyGesture::set_factor(real_t p_factor) {
void InputEventGesturePan::set_relative(const Vector2 &p_relative) {
relative = p_relative;
}
Vector2 InputEventGesturePan::get_relative() const {
return relative;
}
Vector2 InputEventGesturePan::get_delta() const {
return relative / get_touches();
}
void InputEventGesturePan::set_speed(const Vector2 &p_speed) {
speed = p_speed;
}
Vector2 InputEventGesturePan::get_speed() const {
return speed;
}
Ref<InputEvent> InputEventGesturePan::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventGesturePan> ev;
ev.instantiate();
ev->set_device(get_device());
ev->set_modifiers_from_event(this);
ev->set_position(p_xform.xform(get_position() + p_local_ofs));
ev->set_relative(p_xform.basis_xform(relative));
ev->set_speed(p_xform.basis_xform(speed));
ev->set_touches(get_touches());
return ev;
}
String InputEventGesturePan::as_text() const {
return "InputEventGesturePan : position=(" + String(get_position()) + "), relative=(" + String(get_relative()) + "), speed=(" + String(get_speed()) + ")";
}
void InputEventGesturePan::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventGesturePan::set_relative);
ClassDB::bind_method(D_METHOD("get_relative"), &InputEventGesturePan::get_relative);
ClassDB::bind_method(D_METHOD("get_delta"), &InputEventGesturePan::get_delta);
ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventGesturePan::set_speed);
ClassDB::bind_method(D_METHOD("get_speed"), &InputEventGesturePan::get_speed);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed");
}
/////////////////////////////
void InputEventGesturePinch::set_distance(float p_distance) {
distance = p_distance;
}
float InputEventGesturePinch::get_distance() const {
return distance;
}
void InputEventGesturePinch::set_factor(float p_factor) {
factor = p_factor;
}
real_t InputEventMagnifyGesture::get_factor() const {
float InputEventGesturePinch::get_factor() const {
return factor;
}
Ref<InputEvent> InputEventMagnifyGesture::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventMagnifyGesture> ev;
Ref<InputEvent> InputEventGesturePinch::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventGesturePinch> ev;
ev.instantiate();
ev->set_device(get_device());
ev->set_window_id(get_window_id());
ev->set_modifiers_from_event(this);
ev->set_position(p_xform.xform(get_position() + p_local_ofs));
ev->set_factor(get_factor());
ev->set_distance(distance);
ev->set_factor(factor);
ev->set_touches(get_touches());
return ev;
}
String InputEventMagnifyGesture::as_text() const {
return vformat(RTR("Magnify Gesture at (%s) with factor %s"), String(get_position()), rtos(get_factor()));
String InputEventGesturePinch::as_text() const {
return "InputEventGesturePinch : position=(" + String(get_position()) + "), distance=(" + rtos(get_distance()) + "), factor=(" + rtos(get_factor()) + ")";
}
String InputEventMagnifyGesture::to_string() {
return vformat("InputEventMagnifyGesture: factor=%.2f, position=(%s)", factor, String(get_position()));
}
void InputEventGesturePinch::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_distance", "distance"), &InputEventGesturePinch::set_distance);
ClassDB::bind_method(D_METHOD("get_distance"), &InputEventGesturePinch::get_distance);
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);
ClassDB::bind_method(D_METHOD("set_factor", "factor"), &InputEventGesturePinch::set_factor);
ClassDB::bind_method(D_METHOD("get_factor"), &InputEventGesturePinch::get_factor);
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "distance"), "set_distance", "get_distance");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "factor"), "set_factor", "get_factor");
}
///////////////////////////////////
/////////////////////////////
void InputEventPanGesture::set_delta(const Vector2 &p_delta) {
delta = p_delta;
void InputEventGestureTwist::set_rotation(float p_rotation) {
rotation = p_rotation;
}
Vector2 InputEventPanGesture::get_delta() const {
return delta;
float InputEventGestureTwist::get_rotation() const {
return rotation;
}
Ref<InputEvent> InputEventPanGesture::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventPanGesture> ev;
Ref<InputEvent> InputEventGestureTwist::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventGestureTwist> ev;
ev.instantiate();
ev->set_device(get_device());
ev->set_window_id(get_window_id());
ev->set_modifiers_from_event(this);
ev->set_position(p_xform.xform(get_position() + p_local_ofs));
ev->set_delta(get_delta());
ev->set_rotation(rotation);
return ev;
}
String InputEventPanGesture::as_text() const {
return vformat(RTR("Pan Gesture at (%s) with delta (%s)"), String(get_position()), String(get_delta()));
String InputEventGestureTwist::as_text() const {
return "InputEventGestureTwist : position=(" + String(get_position()) + "), rotation=(" + rtos(get_rotation()) + ")";
}
String InputEventPanGesture::to_string() {
return vformat("InputEventPanGesture: delta=(%s), position=(%s)", String(get_delta()), String(get_position()));
void InputEventGestureTwist::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_rotation", "rotation"), &InputEventGestureTwist::set_rotation);
ClassDB::bind_method(D_METHOD("get_rotation"), &InputEventGestureTwist::get_rotation);
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rotation"), "set_rotation", "get_rotation");
}
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");
}
///////////////////////////////////
/////////////////////////////
void InputEventMIDI::set_channel(const int p_channel) {
channel = p_channel;

68
core/input/input_event.h
View file

@ -452,6 +452,7 @@ class InputEventGesture : public InputEventWithModifiers {
GDCLASS(InputEventGesture, InputEventWithModifiers);
Vector2 pos;
int touches = 0;
protected:
static void _bind_methods();
@ -459,42 +460,63 @@ protected:
public:
void set_position(const Vector2 &p_pos);
Vector2 get_position() const;
void set_touches(const int p_touches);
int get_touches() const;
};
class InputEventMagnifyGesture : public InputEventGesture {
GDCLASS(InputEventMagnifyGesture, InputEventGesture);
real_t factor = 1.0;
class InputEventGesturePan : public InputEventGesture {
GDCLASS(InputEventGesturePan, InputEventGesture);
Vector2 relative;
Vector2 speed;
protected:
static void _bind_methods();
public:
void set_factor(real_t p_factor);
real_t get_factor() const;
void set_relative(const Vector2 &p_relative);
Vector2 get_relative() const;
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
virtual String as_text() const override;
virtual String to_string() override;
InputEventMagnifyGesture() {}
};
class InputEventPanGesture : public InputEventGesture {
GDCLASS(InputEventPanGesture, InputEventGesture);
Vector2 delta;
protected:
static void _bind_methods();
public:
void set_delta(const Vector2 &p_delta);
Vector2 get_delta() const;
void set_speed(const Vector2 &p_speed);
Vector2 get_speed() const;
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
virtual String as_text() const override;
virtual String to_string() override;
};
InputEventPanGesture() {}
class InputEventGesturePinch : public InputEventGesture {
GDCLASS(InputEventGesturePinch, InputEventGesture);
float distance = 0;
float factor = 0;
protected:
static void _bind_methods();
public:
void set_distance(float p_distance);
float get_distance() const;
void set_factor(float p_factor);
float get_factor() const;
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
virtual String as_text() const override;
};
class InputEventGestureTwist : public InputEventGesture {
GDCLASS(InputEventGestureTwist, InputEventGesture);
float rotation = 0;
protected:
static void _bind_methods();
public:
void set_rotation(float p_rotation);
float get_rotation() const;
virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const override;
virtual String as_text() const override;
};
class InputEventMIDI : public InputEvent {

5
core/register_core_types.cpp
View file

@ -161,8 +161,9 @@ void register_core_types() {
GDREGISTER_CLASS(InputEventScreenTouch);
GDREGISTER_CLASS(InputEventAction);
GDREGISTER_VIRTUAL_CLASS(InputEventGesture);
GDREGISTER_CLASS(InputEventMagnifyGesture);
GDREGISTER_CLASS(InputEventPanGesture);
GDREGISTER_CLASS(InputEventGesturePan);
GDREGISTER_CLASS(InputEventGesturePinch);
GDREGISTER_CLASS(InputEventGestureTwist);
GDREGISTER_CLASS(InputEventMIDI);
// Network

2
doc/classes/InputEvent.xml
View file

@ -96,7 +96,7 @@
<argument index="0" name="xform" type="Transform2D" />
<argument index="1" name="local_ofs" type="Vector2" default="Vector2(0, 0)" />
<description>
Returns a copy of the given input event which has been offset by [code]local_ofs[/code] and transformed by [code]xform[/code]. Relevant for events of type [InputEventMouseButton], [InputEventMouseMotion], [InputEventScreenTouch], [InputEventScreenDrag], [InputEventMagnifyGesture] and [InputEventPanGesture].
Returns a copy of the given input event which has been offset by [code]local_ofs[/code] and transformed by [code]xform[/code]. Relevant for events of type [InputEventMouseButton], [InputEventMouseMotion], [InputEventScreenTouch], [InputEventScreenDrag], [InputEventGesturePan], [InputEventGesturePinch] and [InputEventGestureTwist].
</description>
</method>
</methods>

3
doc/classes/InputEventGesture.xml
View file

@ -11,5 +11,8 @@
<member name="position" type="Vector2" setter="set_position" getter="get_position" default="Vector2(0, 0)">
The local gesture position relative to the [Viewport]. If used in [method Control._gui_input], the position is relative to the current [Control] that received this gesture.
</member>
<member name="touches" type="int" setter="set_touches" getter="get_touches" default="0">
Number of touches constituting this gesture event.
</member>
</members>
</class>

27
doc/classes/InputEventGesturePan.xml Normal file
View file

@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="InputEventGesturePan" inherits="InputEventGesture" version="4.0">
<brief_description>
Pan gesture event.
</brief_description>
<description>
A pan gesture event is generated by a translational movement of at least 2 touch points.
</description>
<tutorials>
</tutorials>
<methods>
<method name="get_delta" qualifiers="const">
<return type="Vector2" />
<description>
Returns relative divided by touches.
</description>
</method>
</methods>
<members>
<member name="relative" type="Vector2" setter="set_relative" getter="get_relative" default="Vector2(0, 0)">
The pan position relative to its start position.
</member>
<member name="speed" type="Vector2" setter="set_speed" getter="get_speed" default="Vector2(0, 0)">
The pan speed.
</member>
</members>
</class>

19
doc/classes/InputEventGesturePinch.xml Normal file
View file

@ -0,0 +1,19 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="InputEventGesturePinch" inherits="InputEventGesture" version="4.0">
<brief_description>
Pinch gesture event.
</brief_description>
<description>
A pinch gesture event is generated by at least 2 touch points moving towards or away of each other.
</description>
<tutorials>
</tutorials>
<members>
<member name="distance" type="float" setter="set_distance" getter="get_distance" default="0.0">
The average distance to the center ([member InputEventGesture.position]) of the gesture.
</member>
<member name="factor" type="float" setter="set_factor" getter="get_factor" default="0.0">
The ratio between the current distance and the previous one.
</member>
</members>
</class>

16
doc/classes/InputEventGestureTwist.xml Normal file
View file

@ -0,0 +1,16 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="InputEventGestureTwist" inherits="InputEventGesture" version="4.0">
<brief_description>
Twist gesture event.
</brief_description>
<description>
A twist gesture event is generated by a twist movement of at least 2 touch points.
</description>
<tutorials>
</tutorials>
<members>
<member name="rotation" type="float" setter="set_rotation" getter="get_rotation" default="0.0">
Rotation in radians, relative to the preceding angle.
</member>
</members>
</class>

13
doc/classes/InputEventMagnifyGesture.xml
View file

@ -1,13 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="InputEventMagnifyGesture" inherits="InputEventGesture" version="4.0">
<brief_description>
</brief_description>
<description>
</description>
<tutorials>
</tutorials>
<members>
<member name="factor" type="float" setter="set_factor" getter="get_factor" default="1.0">
</member>
</members>
</class>

13
doc/classes/InputEventPanGesture.xml
View file

@ -1,13 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="InputEventPanGesture" inherits="InputEventGesture" version="4.0">
<brief_description>
</brief_description>
<description>
</description>
<tutorials>
</tutorials>
<members>
<member name="delta" type="Vector2" setter="set_delta" getter="get_delta" default="Vector2(0, 0)">
</member>
</members>
</class>

6
editor/code_editor.cpp
View file

@ -774,10 +774,10 @@ void CodeTextEditor::_text_editor_gui_input(const Ref<InputEvent> &p_event) {
}
}
Ref<InputEventMagnifyGesture> magnify_gesture = p_event;
if (magnify_gesture.is_valid()) {
Ref<InputEventGesturePinch> pinch_gesture = p_event;
if (pinch_gesture.is_valid()) {
font_size = text_editor->get_theme_font_size(SNAME("font_size"));
font_size *= powf(magnify_gesture->get_factor(), 0.25);
font_size *= powf(pinch_gesture->get_factor(), 0.25);
_add_font_size((int)font_size - text_editor->get_theme_font_size(SNAME("font_size")));
return;

2
editor/plugins/animation_state_machine_editor.cpp
View file

@ -387,7 +387,7 @@ void AnimationNodeStateMachineEditor::_state_machine_gui_input(const Ref<InputEv
}
}
Ref<InputEventPanGesture> pan_gesture = p_event;
Ref<InputEventGesturePan> pan_gesture = p_event;
if (pan_gesture.is_valid()) {
h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() * pan_gesture->get_delta().x / 8);
v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * pan_gesture->get_delta().y / 8);

8
editor/plugins/canvas_item_editor_plugin.cpp
View file

@ -1254,14 +1254,14 @@ bool CanvasItemEditor::_gui_input_zoom_or_pan(const Ref<InputEvent> &p_event, bo
}
}
Ref<InputEventMagnifyGesture> magnify_gesture = p_event;
if (magnify_gesture.is_valid() && !p_already_accepted) {
Ref<InputEventGesturePinch> pinch_gesture = p_event;
if (pinch_gesture.is_valid() && !p_already_accepted) {
// Zoom gesture
_zoom_on_position(zoom * magnify_gesture->get_factor(), magnify_gesture->get_position());
_zoom_on_position(zoom * pinch_gesture->get_factor(), pinch_gesture->get_position());
return true;
}
Ref<InputEventPanGesture> pan_gesture = p_event;
Ref<InputEventGesturePan> pan_gesture = p_event;
if (pan_gesture.is_valid() && !p_already_accepted) {
// If ctrl key pressed, then zoom instead of pan.
if (pan_gesture->is_ctrl_pressed()) {

10
editor/plugins/node_3d_editor_plugin.cpp
View file

@ -2149,16 +2149,16 @@ void Node3DEditorViewport::_sinput(const Ref<InputEvent> &p_event) {
}
}
Ref<InputEventMagnifyGesture> magnify_gesture = p_event;
if (magnify_gesture.is_valid()) {
Ref<InputEventGesturePinch> pinch_gesture = p_event;
if (pinch_gesture.is_valid()) {
if (is_freelook_active()) {
scale_freelook_speed(magnify_gesture->get_factor());
scale_freelook_speed(pinch_gesture->get_factor());
} else {
scale_cursor_distance(1.0 / magnify_gesture->get_factor());
scale_cursor_distance(1.0 / pinch_gesture->get_factor());
}
}
Ref<InputEventPanGesture> pan_gesture = p_event;
Ref<InputEventGesturePan> pan_gesture = p_event;
if (pan_gesture.is_valid()) {
NavigationScheme nav_scheme = (NavigationScheme)EditorSettings::get_singleton()->get("editors/3d/navigation/navigation_scheme").operator int();
NavigationMode nav_mode = NAVIGATION_NONE;

8
editor/plugins/polygon_2d_editor_plugin.cpp
View file

@ -913,12 +913,12 @@ void Polygon2DEditor::_uv_input(const Ref<InputEvent> &p_input) {
}
}
Ref<InputEventMagnifyGesture> magnify_gesture = p_input;
if (magnify_gesture.is_valid()) {
uv_zoom->set_value(uv_zoom->get_value() * magnify_gesture->get_factor());
Ref<InputEventGesturePinch> pinch_gesture = p_input;
if (pinch_gesture.is_valid()) {
uv_zoom->set_value(uv_zoom->get_value() * pinch_gesture->get_factor());
}
Ref<InputEventPanGesture> pan_gesture = p_input;
Ref<InputEventGesturePan> pan_gesture = p_input;
if (pan_gesture.is_valid()) {
uv_hscroll->set_value(uv_hscroll->get_value() + uv_hscroll->get_page() * pan_gesture->get_delta().x / 8);
uv_vscroll->set_value(uv_vscroll->get_value() + uv_vscroll->get_page() * pan_gesture->get_delta().y / 8);

8
editor/plugins/texture_region_editor_plugin.cpp
View file

@ -597,12 +597,12 @@ void TextureRegionEditor::_region_input(const Ref<InputEvent> &p_input) {
}
}
Ref<InputEventMagnifyGesture> magnify_gesture = p_input;
if (magnify_gesture.is_valid()) {
_zoom_on_position(draw_zoom * magnify_gesture->get_factor(), magnify_gesture->get_position());
Ref<InputEventGesturePinch> pinch_gesture = p_input;
if (pinch_gesture.is_valid()) {
_zoom_on_position(draw_zoom * pinch_gesture->get_factor(), pinch_gesture->get_position());
}
Ref<InputEventPanGesture> pan_gesture = p_input;
Ref<InputEventGesturePan> pan_gesture = p_input;
if (pan_gesture.is_valid()) {
hscroll->set_value(hscroll->get_value() + hscroll->get_page() * pan_gesture->get_delta().x / 8);
vscroll->set_value(vscroll->get_value() + vscroll->get_page() * pan_gesture->get_delta().y / 8);

2
modules/gridmap/grid_map_editor_plugin.cpp
View file

@ -752,7 +752,7 @@ EditorPlugin::AfterGUIInput GridMapEditor::forward_spatial_input_event(Camera3D
}
}
Ref<InputEventPanGesture> pan_gesture = p_event;
Ref<InputEventGesturePan> pan_gesture = p_event;
if (pan_gesture.is_valid()) {
if (pan_gesture->is_alt_pressed() && (pan_gesture->is_command_pressed() || pan_gesture->is_shift_pressed())) {
const real_t delta = pan_gesture->get_delta().y * 0.5;

4
platform/android/android_input_handler.cpp
View file

@ -385,11 +385,11 @@ MouseButton AndroidInputHandler::_android_button_mask_to_godot_button_mask(int a
}
void AndroidInputHandler::process_scroll(Point2 p_pos) {
Ref<InputEventPanGesture> ev;
Ref<InputEventGesturePan> ev;
ev.instantiate();
_set_key_modifier_state(ev);
ev->set_position(p_pos);
ev->set_delta(p_pos - scroll_prev_pos);
ev->set_relative(p_pos - scroll_prev_pos);
Input::get_singleton()->parse_input_event(ev);
scroll_prev_pos = p_pos;
}

6
platform/osx/display_server_osx.mm
View file

@ -862,7 +862,7 @@ static void _mouseDownEvent(DisplayServer::WindowID window_id, NSEvent *event, M
ERR_FAIL_COND(!DS_OSX->windows.has(window_id));
DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
Ref<InputEventMagnifyGesture> ev;
Ref<InputEventGesturePinch> ev;
ev.instantiate();
ev->set_window_id(window_id);
_get_key_modifier_state([event modifierFlags], ev);
@ -1379,13 +1379,13 @@ inline void sendPanEvent(DisplayServer::WindowID window_id, double dx, double dy
ERR_FAIL_COND(!DS_OSX->windows.has(window_id));
DisplayServerOSX::WindowData &wd = DS_OSX->windows[window_id];
Ref<InputEventPanGesture> pg;
Ref<InputEventGesturePan> pg;
pg.instantiate();
pg->set_window_id(window_id);
_get_key_modifier_state(modifierFlags, pg);
pg->set_position(wd.mouse_pos);
pg->set_delta(Vector2(-dx, -dy));
pg->set_relative(Vector2(-dx, -dy));
Input::get_singleton()->parse_input_event(pg);
}

8
scene/gui/graph_edit.cpp
View file

@ -1313,12 +1313,12 @@ void GraphEdit::gui_input(const Ref<InputEvent> &p_ev) {
}
}
Ref<InputEventMagnifyGesture> magnify_gesture = p_ev;
if (magnify_gesture.is_valid()) {
set_zoom_custom(zoom * magnify_gesture->get_factor(), magnify_gesture->get_position());
Ref<InputEventGesturePinch> pinch_gesture = p_ev;
if (pinch_gesture.is_valid()) {
set_zoom_custom(zoom * pinch_gesture->get_factor(), pinch_gesture->get_position());
}
Ref<InputEventPanGesture> pan_gesture = p_ev;
Ref<InputEventGesturePan> pan_gesture = p_ev;
if (pan_gesture.is_valid()) {
h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() * pan_gesture->get_delta().x / 8);
v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * pan_gesture->get_delta().y / 8);

2
scene/gui/item_list.cpp
View file

@ -823,7 +823,7 @@ void ItemList::gui_input(const Ref<InputEvent> &p_event) {
}
}
Ref<InputEventPanGesture> pan_gesture = p_event;
Ref<InputEventGesturePan> pan_gesture = p_event;
if (pan_gesture.is_valid()) {
scroll_bar->set_value(scroll_bar->get_value() + scroll_bar->get_page() * pan_gesture->get_delta().y / 8);
}

2
scene/gui/rich_text_label.cpp
View file

@ -1648,7 +1648,7 @@ void RichTextLabel::gui_input(const Ref<InputEvent> &p_event) {
}
}
Ref<InputEventPanGesture> pan_gesture = p_event;
Ref<InputEventGesturePan> pan_gesture = p_event;
if (pan_gesture.is_valid()) {
if (scroll_active) {
vscroll->set_value(vscroll->get_value() + vscroll->get_page() * pan_gesture->get_delta().y * 0.5 / 8);

2
scene/gui/scroll_container.cpp
View file

@ -195,7 +195,7 @@ void ScrollContainer::gui_input(const Ref<InputEvent> &p_gui_input) {
}
}
Ref<InputEventPanGesture> pan_gesture = p_gui_input;
Ref<InputEventGesturePan> pan_gesture = p_gui_input;
if (pan_gesture.is_valid()) {
if (h_scroll->is_visible_in_tree()) {
h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() * pan_gesture->get_delta().x / 8);

2
scene/gui/text_edit.cpp
View file

@ -1589,7 +1589,7 @@ void TextEdit::gui_input(const Ref<InputEvent> &p_gui_input) {
}
}
const Ref<InputEventPanGesture> pan_gesture = p_gui_input;
const Ref<InputEventGesturePan> pan_gesture = p_gui_input;
if (pan_gesture.is_valid()) {
const real_t delta = pan_gesture->get_delta().y;
if (delta < 0) {

2
scene/gui/tree.cpp
View file

@ -3386,7 +3386,7 @@ void Tree::gui_input(const Ref<InputEvent> &p_event) {
}
}
Ref<InputEventPanGesture> pan_gesture = p_event;
Ref<InputEventGesturePan> pan_gesture = p_event;
if (pan_gesture.is_valid()) {
double prev_v = v_scroll->get_value();
v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * pan_gesture->get_delta().y / 8);

2
scene/main/viewport.cpp
View file

@ -1263,7 +1263,7 @@ void Viewport::_gui_call_input(Control *p_control, const Ref<InputEvent> &p_inpu
mb->get_button_index() == MOUSE_BUTTON_WHEEL_UP ||
mb->get_button_index() == MOUSE_BUTTON_WHEEL_LEFT ||
mb->get_button_index() == MOUSE_BUTTON_WHEEL_RIGHT));
Ref<InputEventPanGesture> pn = p_input;
Ref<InputEventGesturePan> pn = p_input;
cant_stop_me_now = pn.is_valid() || cant_stop_me_now;
bool ismouse = ev.is_valid() || Object::cast_to<InputEventMouseMotion>(*p_input) != nullptr;