input: Map PlayerEvent to InputEvent

This refactor adds InputEvent, which is a processed PlayerEvent:

1. it does not contain gamepad events, as they are already mapped,
2. it always contains click index, as it's inferred when processing input.

Author: kjarosh

core/src/events.rs

@@ -1,4 +1,4 @@
-use crate::display_object::InteractiveObject;
+use crate::{display_object::InteractiveObject, input::InputEvent};
 use std::str::FromStr;
 use swf::ClipEventFlag;
 
@@ -766,17 +766,17 @@ impl ButtonKeyCode {
         })
     }
 
-    pub fn from_player_event(event: PlayerEvent) -> Option<Self> {
+    pub fn from_input_event(event: InputEvent) -> Option<Self> {
         match event {
             // ASCII characters convert directly to keyPress button events.
-            PlayerEvent::TextInput { codepoint }
+            InputEvent::TextInput { codepoint }
                 if codepoint as u32 >= 32 && codepoint as u32 <= 126 =>
             {
                 Some(ButtonKeyCode::from_u8(codepoint as u8).unwrap())
             }
 
             // Special keys have custom values for keyPress.
-            PlayerEvent::KeyDown { key_code, .. } => Self::from_key_code(key_code),
+            InputEvent::KeyDown { key_code, .. } => Self::from_key_code(key_code),
             _ => None,
         }
     }

core/src/input.rs

@@ -1,7 +1,49 @@
-use crate::events::{GamepadButton, KeyCode, MouseButton, PlayerEvent, TextControlCode};
+use crate::events::{
+    GamepadButton, KeyCode, MouseButton, MouseWheelDelta, PlayerEvent, TextControlCode,
+};
 use chrono::{DateTime, TimeDelta, Utc};
 use std::collections::{HashMap, HashSet};
 
+/// An event describing input in general.
+///
+/// It's usually a processed [`PlayerEvent`].
+#[derive(Debug, Clone, Copy)]
+pub enum InputEvent {
+    KeyDown {
+        key_code: KeyCode,
+        key_char: Option<char>,
+    },
+    KeyUp {
+        key_code: KeyCode,
+        key_char: Option<char>,
+    },
+    MouseMove {
+        x: f64,
+        y: f64,
+    },
+    MouseUp {
+        x: f64,
+        y: f64,
+        button: MouseButton,
+    },
+    MouseDown {
+        x: f64,
+        y: f64,
+        button: MouseButton,
+        index: usize,
+    },
+    MouseLeave,
+    MouseWheel {
+        delta: MouseWheelDelta,
+    },
+    TextInput {
+        codepoint: char,
+    },
+    TextControl {
+        code: TextControlCode,
+    },
+}
+
 struct ClickEventData {
     x: f64,
     y: f64,
@@ -67,72 +109,90 @@ impl InputManager {
         }
     }
 
-    pub fn process_input_event(&mut self, event: PlayerEvent) -> Option<PlayerEvent> {
-        // Optionally transform gamepad button events into key events.
+    pub fn process_event(&mut self, event: PlayerEvent) -> Option<InputEvent> {
         let event = match event {
+            // Optionally transform gamepad button events into key events.
             PlayerEvent::GamepadButtonDown { button } => {
                 if let Some(key_code) = self.gamepad_button_mapping.get(&button) {
-                    Some(PlayerEvent::KeyDown {
+                    InputEvent::KeyDown {
                         key_code: *key_code,
                         key_char: None,
-                    })
+                    }
                 } else {
                     // Just ignore this event.
-                    None
+                    return None;
                 }
             }
             PlayerEvent::GamepadButtonUp { button } => {
                 if let Some(key_code) = self.gamepad_button_mapping.get(&button) {
-                    Some(PlayerEvent::KeyUp {
+                    InputEvent::KeyUp {
                         key_code: *key_code,
                         key_char: None,
-                    })
+                    }
                 } else {
                     // Just ignore this event.
-                    None
+                    return None;
                 }
             }
-            _ => Some(event),
+
+            PlayerEvent::KeyDown { key_code, key_char } => {
+                InputEvent::KeyDown { key_code, key_char }
+            }
+            PlayerEvent::KeyUp { key_code, key_char } => InputEvent::KeyUp { key_code, key_char },
+
+            PlayerEvent::MouseMove { x, y } => InputEvent::MouseMove { x, y },
+            PlayerEvent::MouseUp { x, y, button } => InputEvent::MouseUp { x, y, button },
+            PlayerEvent::MouseDown {
+                x,
+                y,
+                button,
+                index,
+            } => InputEvent::MouseDown {
+                x,
+                y,
+                button,
+                index: self.update_last_click(x, y, index),
+            },
+            PlayerEvent::MouseLeave => InputEvent::MouseLeave,
+            PlayerEvent::MouseWheel { delta } => InputEvent::MouseWheel { delta },
+
+            PlayerEvent::TextInput { codepoint } => InputEvent::TextInput { codepoint },
+            PlayerEvent::TextControl { code } => InputEvent::TextControl { code },
+
+            // The following are not input events.
+            PlayerEvent::FocusGained | PlayerEvent::FocusLost => return None,
         };
 
-        if let Some(event) = event {
-            self.handle_event(&event);
-        }
+        self.handle_event(&event);
 
-        event
+        Some(event)
     }
 
-    fn handle_event(&mut self, event: &PlayerEvent) {
+    fn handle_event(&mut self, event: &InputEvent) {
         match *event {
-            PlayerEvent::KeyDown { key_code, key_char } => {
+            InputEvent::KeyDown { key_code, key_char } => {
                 self.last_char = key_char;
                 self.toggle_key(key_code);
                 self.add_key(key_code);
             }
-            PlayerEvent::KeyUp { key_code, key_char } => {
+            InputEvent::KeyUp { key_code, key_char } => {
                 self.last_char = key_char;
                 self.remove_key(key_code);
                 self.last_text_control = None;
             }
-            PlayerEvent::TextControl { code } => {
+            InputEvent::TextControl { code } => {
                 self.last_text_control = Some(code);
             }
-            PlayerEvent::MouseDown {
-                x,
-                y,
-                button,
-                index,
-            } => {
+            InputEvent::MouseDown { button, .. } => {
                 self.toggle_key(button.into());
                 self.add_key(button.into());
-                self.update_last_click(x, y, index);
             }
-            PlayerEvent::MouseUp { button, .. } => self.remove_key(button.into()),
+            InputEvent::MouseUp { button, .. } => self.remove_key(button.into()),
             _ => {}
         }
     }
 
-    fn update_last_click(&mut self, x: f64, y: f64, index: Option<usize>) {
+    fn update_last_click(&mut self, x: f64, y: f64, index: Option<usize>) -> usize {
         let time = Utc::now();
         let index = index.unwrap_or_else(|| {
             let Some(last_click) = self.last_click.as_ref() else {
@@ -149,6 +209,7 @@ impl InputManager {
             }
         });
         self.last_click = Some(ClickEventData { x, y, time, index });
+        index
     }
 
     pub fn is_key_down(&self, key: KeyCode) -> bool {