[add] a basic key event system and setup common event handlers inside the demo app.

Author: vmarcella

crates/lambda-platform/src/winit/mod.rs

@@ -23,7 +23,9 @@ use winit::{
 pub mod winit_exports {
   pub use winit::{
     event::{
+      ElementState,
       Event,
+      VirtualKeyCode,
       WindowEvent,
     },
     event_loop::{

lambda/src/core/events.rs

@@ -1,31 +1,49 @@
 use std::time::Instant;
 
 /// events generated by kernel interactions with the component.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum ComponentEvent {
   Attached { name: String },
   Detached { name: String },
-  Update { delta: Instant },
 }
 
 /// Window events are generated in response to window events coming from
 /// the windowing system.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum WindowEvent {
   Close,
   Resize { width: u32, height: u32 },
 }
 
 /// Kernel events are generated by the kernel itself
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum RuntimeEvent {
   Initialized,
   Shutdown,
 }
 
+/// Exports the winit virtual key codes to this namespace for convenience.
+pub use lambda_platform::winit::winit_exports::VirtualKeyCode as VirtualKey;
+
+#[derive(Debug, Clone)]
+pub enum KeyEvent {
+  KeyPressed {
+    scan_code: u32,
+    virtual_key: VirtualKey,
+  },
+  KeyReleased {
+    scan_code: u32,
+    virtual_key: VirtualKey,
+  },
+  ModifierPressed {
+    modifier: u32,
+    virtual_key: VirtualKey,
+  },
+}
+
 /// Generic Event Enum which encapsulates all possible events that will be
 /// emitted by the LambdaKernel
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Events {
   Component {
     event: ComponentEvent,
@@ -39,4 +57,8 @@ pub enum Events {
     event: RuntimeEvent,
     issued_at: Instant,
   },
+  Keyboard {
+    event: KeyEvent,
+    issued_at: Instant,
+  },
 }

lambda/src/runtimes/mod.rs

@@ -3,6 +3,7 @@ use std::time::Instant;
 use lambda_platform::winit::{
   winit_exports::{
     ControlFlow,
+    ElementState,
     Event as WinitEvent,
     WindowEvent as WinitWindowEvent,
   },
@@ -15,6 +16,7 @@ use crate::core::{
   events::{
     ComponentEvent,
     Events,
+    KeyEvent,
     RuntimeEvent,
     WindowEvent,
   },
@@ -176,10 +178,32 @@ impl Runtime for GenericRuntime {
           WinitWindowEvent::ReceivedCharacter(_) => {}
           WinitWindowEvent::Focused(_) => {}
           WinitWindowEvent::KeyboardInput {
-            device_id,
+            device_id: _,
             input,
             is_synthetic,
-          } => {}
+          } => match (input.state, is_synthetic) {
+            (ElementState::Pressed, false) => {
+              publisher.publish_event(Events::Keyboard {
+                event: KeyEvent::KeyPressed {
+                  scan_code: input.scancode,
+                  virtual_key: input.virtual_keycode.unwrap(),
+                },
+                issued_at: Instant::now(),
+              })
+            }
+            (ElementState::Released, false) => {
+              publisher.publish_event(Events::Keyboard {
+                event: KeyEvent::KeyReleased {
+                  scan_code: input.scancode,
+                  virtual_key: input.virtual_keycode.unwrap(),
+                },
+                issued_at: Instant::now(),
+              })
+            }
+            _ => {
+              println!("Unhandled synthetic keyboard event: {:?}", input);
+            }
+          },
           WinitWindowEvent::ModifiersChanged(_) => {}
           WinitWindowEvent::CursorMoved {
             device_id,

tools/lambda_rs_demo/src/main.rs

@@ -44,7 +44,51 @@ impl Component<Events> for DemoComponent {
 
   fn on_detach(self: &mut DemoComponent) {}
 
-  fn on_event(self: &mut DemoComponent, _event: &lambda::core::events::Events) {
+  fn on_event(self: &mut DemoComponent, event: &lambda::core::events::Events) {
+    match event {
+      Events::Runtime { event, issued_at } => match event {
+        lambda::core::events::RuntimeEvent::Shutdown => {
+          println!("Shutting down the runtime");
+        }
+        _ => {}
+      },
+      Events::Window { event, issued_at } => match event {
+        lambda::core::events::WindowEvent::Resize { width, height } => {
+          println!("Window resized to {}x{}", width, height);
+        }
+        lambda::core::events::WindowEvent::Close => {
+          println!("Window closed");
+        }
+      },
+      Events::Keyboard { event, issued_at } => match event {
+        lambda::core::events::KeyEvent::KeyPressed {
+          scan_code,
+          virtual_key,
+        } => {
+          println!("Key pressed: {:?}", virtual_key);
+        }
+        lambda::core::events::KeyEvent::KeyReleased {
+          scan_code,
+          virtual_key,
+        } => {
+          println!("Key released: {:?}", virtual_key);
+        }
+        lambda::core::events::KeyEvent::ModifierPressed {
+          modifier,
+          virtual_key,
+        } => {
+          println!("Modifier pressed: {:?}", virtual_key);
+        }
+      },
+      Events::Component { event, issued_at } => match event {
+        lambda::core::events::ComponentEvent::Attached { name } => {
+          println!("Component attached: {:?}", name);
+        }
+        lambda::core::events::ComponentEvent::Detached { name } => {
+          println!("Component detached: {:?}", name);
+        }
+      },
+    }
   }
 
   fn on_update(self: &mut DemoComponent, last_frame: &std::time::Duration) {