Implement basic touch support

Cargo.toml

@@ -185,6 +185,14 @@ path = "examples/input/keyboard_input.rs"
 name = "keyboard_input_events"
 path = "examples/input/keyboard_input_events.rs"
 
+[[example]]
+name = "touch_input"
+path = "examples/input/touch_input.rs"
+
+[[example]]
+name = "touch_input_events"
+path = "examples/input/touch_input_events.rs"
+
 [[example]]
 name = "scene"
 path = "examples/scene/scene.rs"

crates/bevy_input/src/lib.rs

@@ -2,16 +2,18 @@ mod input;
 pub mod keyboard;
 pub mod mouse;
 pub mod system;
+pub mod touch;
 
 pub use input::*;
 
 pub mod prelude {
-    pub use crate::{keyboard::KeyCode, mouse::MouseButton, Input};
+    pub use crate::{keyboard::KeyCode, mouse::MouseButton, touch::Finger, Input};
 }
 
 use bevy_app::prelude::*;
 use keyboard::{keyboard_input_system, KeyCode, KeyboardInput};
 use mouse::{mouse_button_input_system, MouseButton, MouseButtonInput, MouseMotion, MouseWheel};
+use touch::{touch_finger_input_system, Finger, TouchFingerInput, TouchMotion};
 
 use bevy_ecs::IntoQuerySystem;
 
@@ -25,6 +27,9 @@ impl Plugin for InputPlugin {
             .add_event::<MouseButtonInput>()
             .add_event::<MouseMotion>()
             .add_event::<MouseWheel>()
+            .add_event::<Finger>()
+            .add_event::<TouchFingerInput>()
+            .add_event::<TouchMotion>()
             .init_resource::<Input<KeyCode>>()
             .add_system_to_stage(
                 bevy_app::stage::EVENT_UPDATE,
@@ -34,6 +39,11 @@ impl Plugin for InputPlugin {
             .add_system_to_stage(
                 bevy_app::stage::EVENT_UPDATE,
                 mouse_button_input_system.system(),
+            )
+            .init_resource::<Input<Finger>>()
+            .add_system_to_stage(
+                bevy_app::stage::EVENT_UPDATE,
+                touch_finger_input_system.system(),
             );
     }
 }

crates/bevy_input/src/touch.rs

@@ -0,0 +1,49 @@
+use super::keyboard::ElementState;
+use crate::Input;
+use bevy_app::prelude::{EventReader, Events};
+use bevy_ecs::{Local, Res, ResMut};
+use bevy_math::Vec2;
+
+/// A finger on a touch screen device
+#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+pub struct Finger(pub u64);
+
+/// A finger pressed event
+#[derive(Debug, Clone)]
+pub struct TouchFingerInput {
+    pub finger: Finger,
+    pub state: ElementState,
+    pub position: Vec2,
+}
+
+/// A finer motion event
+#[derive(Debug, Clone)]
+pub struct TouchMotion {
+    pub finger: Finger,
+    pub position: Vec2,
+}
+
+/// State used by the mouse button input system
+#[derive(Default)]
+pub struct TouchFingerInputState {
+    touch_finger_input_event_reader: EventReader<TouchFingerInput>,
+}
+
+/// Updates the Input<Finger> resource with the latest TouchFingerInput events
+pub fn touch_finger_input_system(
+    mut state: Local<TouchFingerInputState>,
+    mut touch_finger_input: ResMut<Input<Finger>>,
+    touch_finger_input_events: Res<Events<TouchFingerInput>>,
+) {
+    touch_finger_input.update();
+    for event in state
+        .touch_finger_input_event_reader
+        .iter(&touch_finger_input_events)
+    {
+        match event.state {
+            ElementState::Pressed => touch_finger_input.press(event.finger),
+            ElementState::Released => touch_finger_input.release(event.finger),
+        }
+    }
+}

crates/bevy_winit/src/converters.rs

@@ -1,7 +1,9 @@
 use bevy_input::{
     keyboard::{ElementState, KeyCode, KeyboardInput},
     mouse::MouseButton,
+    touch::{Finger, TouchFingerInput},
 };
+use bevy_math::Vec2;
 
 pub fn convert_keyboard_input(keyboard_input: &winit::event::KeyboardInput) -> KeyboardInput {
     KeyboardInput {
@@ -192,3 +194,11 @@ pub fn convert_virtual_key_code(virtual_key_code: winit::event::VirtualKeyCode)
         winit::event::VirtualKeyCode::Cut => KeyCode::Cut,
     }
 }
+
+pub fn convert_touch_input(state: ElementState, touch: &winit::event::Touch) -> TouchFingerInput {
+    TouchFingerInput {
+        finger: Finger(touch.id),
+        state,
+        position: Vec2::new(touch.location.x as f32, touch.location.y as f32),
+    }
+}

crates/bevy_winit/src/lib.rs

@@ -2,8 +2,9 @@ mod converters;
 mod winit_config;
 mod winit_windows;
 use bevy_input::{
-    keyboard::KeyboardInput,
+    keyboard::{ElementState, KeyboardInput},
     mouse::{MouseButtonInput, MouseMotion, MouseScrollUnit, MouseWheel},
+    touch::{Finger, TouchFingerInput, TouchMotion},
 };
 pub use winit_config::*;
 pub use winit_windows::*;
@@ -17,7 +18,7 @@ use bevy_window::{
 use event::Event;
 use winit::{
     event,
-    event::{DeviceEvent, WindowEvent},
+    event::{DeviceEvent, Touch, TouchPhase, WindowEvent},
     event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
 };
 
@@ -192,6 +193,64 @@ pub fn winit_runner(mut app: App) {
                         });
                     }
                 },
+                WindowEvent::Touch(
+                    touch
+                    @
+                    Touch {
+                        phase: TouchPhase::Started,
+                        ..
+                    },
+                ) => {
+                    let mut touch_finger_input_events =
+                        app.resources.get_mut::<Events<TouchFingerInput>>().unwrap();
+                    touch_finger_input_events.send(converters::convert_touch_input(
+                        ElementState::Pressed,
+                        &touch,
+                    ));
+                }
+                WindowEvent::Touch(
+                    touch
+                    @
+                    Touch {
+                        phase: TouchPhase::Ended,
+                        ..
+                    },
+                ) => {
+                    let mut touch_finger_input_events =
+                        app.resources.get_mut::<Events<TouchFingerInput>>().unwrap();
+                    touch_finger_input_events.send(converters::convert_touch_input(
+                        ElementState::Released,
+                        &touch,
+                    ));
+                }
+                WindowEvent::Touch(
+                    touch
+                    @
+                    Touch {
+                        phase: TouchPhase::Cancelled,
+                        ..
+                    },
+                ) => {
+                    let mut touch_finger_input_events =
+                        app.resources.get_mut::<Events<TouchFingerInput>>().unwrap();
+                    touch_finger_input_events.send(converters::convert_touch_input(
+                        ElementState::Released,
+                        &touch,
+                    ));
+                }
+                WindowEvent::Touch(Touch {
+                    phase: TouchPhase::Moved,
+                    id,
+                    location,
+                    ..
+                }) => {
+                    let mut touch_finger_moved_events =
+                        app.resources.get_mut::<Events<TouchMotion>>().unwrap();
+                    touch_finger_moved_events.send(TouchMotion {
+                        finger: Finger(id),
+                        position: Vec2::new(location.x as f32, location.y as f32),
+                    });
+                }
                 _ => {}
             },
             event::Event::DeviceEvent { ref event, .. } => {

examples/input/touch_input.rs

@@ -0,0 +1,23 @@
+use bevy::prelude::*;
+
+fn main() {
+    App::build()
+        .add_default_plugins()
+        .add_system(touch_system.system())
+        .run();
+}
+
+// This system prints messages when you use the touchscreen
+fn touch_system(finger_input: Res<Input<Finger>>) {
+    if finger_input.pressed(Finger(0)) {
+        println!("finger 0 pressed");
+    }
+
+    if finger_input.just_pressed(Finger(0)) {
+        println!("finger 0 just pressed");
+    }
+
+    if finger_input.just_released(Finger(0)) {
+        println!("finger 0 just released");
+    }
+}

examples/input/touch_input_events.rs

@@ -0,0 +1,36 @@
+use bevy::{
+    input::touch::{TouchFingerInput, TouchMotion},
+    prelude::*,
+};
+
+fn main() {
+    App::build()
+        .add_default_plugins()
+        .init_resource::<State>()
+        .add_system(print_touch_events_system.system())
+        .run();
+}
+
+#[derive(Default)]
+struct State {
+    touch_finger_event_reader: EventReader<TouchFingerInput>,
+    touch_motion_event_reader: EventReader<TouchMotion>,
+}
+
+/// This system prints out all touch events as they come in
+fn print_touch_events_system(
+    mut state: ResMut<State>,
+    touch_finger_input_events: Res<Events<TouchFingerInput>>,
+    touch_motion_events: Res<Events<TouchMotion>>,
+) {
+    for event in state
+        .touch_finger_event_reader
+        .iter(&touch_finger_input_events)
+    {
+        println!("{:?}", event);
+    }
+
+    for event in state.touch_motion_event_reader.iter(&touch_motion_events) {
+        println!("{:?}", event);
+    }
+}