feature(lambda-rs): Refactor the current event system to allow components to only implement handlers for events they care about

crates/lambda-rs/examples/immediates.rs

@@ -2,7 +2,10 @@
 
 use lambda::{
   component::Component,
-  events::WindowEvent,
+  events::{
+    EventMask,
+    WindowEvent,
+  },
   logging,
   math::{
     matrix,
@@ -219,23 +222,20 @@ impl Component<ComponentResult, String> for ImmediatesExample {
     return Ok(ComponentResult::Success);
   }
 
-  fn on_event(
-    &mut self,
-    event: lambda::events::Events,
-  ) -> Result<ComponentResult, String> {
-    // Only handle resizes.
+  fn event_mask(&self) -> EventMask {
+    return EventMask::WINDOW;
+  }
+
+  fn on_window_event(&mut self, event: &WindowEvent) -> Result<(), String> {
     match event {
-      lambda::events::Events::Window { event, issued_at } => match event {
-        WindowEvent::Resize { width, height } => {
-          self.width = width;
-          self.height = height;
-          logging::info!("Window resized to {}x{}", width, height);
-        }
-        _ => {}
-      },
+      WindowEvent::Resize { width, height } => {
+        self.width = *width;
+        self.height = *height;
+        logging::info!("Window resized to {}x{}", width, height);
+      }
       _ => {}
-    };
-    return Ok(ComponentResult::Success);
+    }
+    return Ok(());
   }
 
   /// Update elapsed time every frame.

crates/lambda-rs/examples/indexed_multi_vertex_buffers.rs

@@ -9,7 +9,10 @@
 
 use lambda::{
   component::Component,
-  events::WindowEvent,
+  events::{
+    EventMask,
+    WindowEvent,
+  },
   logging,
   render::{
     buffer::{
@@ -227,22 +230,20 @@ impl Component<ComponentResult, String> for IndexedMultiBufferExample {
     return Ok(ComponentResult::Success);
   }
 
-  fn on_event(
-    &mut self,
-    event: lambda::events::Events,
-  ) -> Result<ComponentResult, String> {
+  fn event_mask(&self) -> EventMask {
+    return EventMask::WINDOW;
+  }
+
+  fn on_window_event(&mut self, event: &WindowEvent) -> Result<(), String> {
     match event {
-      lambda::events::Events::Window { event, .. } => match event {
-        WindowEvent::Resize { width, height } => {
-          self.width = width;
-          self.height = height;
-          logging::info!("Window resized to {}x{}", width, height);
-        }
-        _ => {}
-      },
+      WindowEvent::Resize { width, height } => {
+        self.width = *width;
+        self.height = *height;
+        logging::info!("Window resized to {}x{}", width, height);
+      }
       _ => {}
     }
-    return Ok(ComponentResult::Success);
+    return Ok(());
   }
 
   fn on_update(

crates/lambda-rs/examples/instanced_quads.rs

@@ -9,7 +9,10 @@
 
 use lambda::{
   component::Component,
-  events::WindowEvent,
+  events::{
+    EventMask,
+    WindowEvent,
+  },
   logging,
   render::{
     buffer::{
@@ -255,22 +258,20 @@ impl Component<ComponentResult, String> for InstancedQuadsExample {
     return Ok(ComponentResult::Success);
   }
 
-  fn on_event(
-    &mut self,
-    event: lambda::events::Events,
-  ) -> Result<ComponentResult, String> {
+  fn event_mask(&self) -> EventMask {
+    return EventMask::WINDOW;
+  }
+
+  fn on_window_event(&mut self, event: &WindowEvent) -> Result<(), String> {
     match event {
-      lambda::events::Events::Window { event, .. } => match event {
-        WindowEvent::Resize { width, height } => {
-          self.width = width;
-          self.height = height;
-          logging::info!("Window resized to {}x{}", width, height);
-        }
-        _ => {}
-      },
+      WindowEvent::Resize { width, height } => {
+        self.width = *width;
+        self.height = *height;
+        logging::info!("Window resized to {}x{}", width, height);
+      }
       _ => {}
     }
-    return Ok(ComponentResult::Success);
+    return Ok(());
   }
 
   fn on_update(

crates/lambda-rs/examples/offscreen_post.rs

@@ -4,7 +4,10 @@
 
 use lambda::{
   component::Component,
-  events::Events,
+  events::{
+    EventMask,
+    WindowEvent,
+  },
   logging,
   render::{
     bind::{
@@ -213,16 +216,19 @@ impl Component<ComponentResult, String> for OffscreenPostExample {
     return Ok(ComponentResult::Success);
   }
 
-  fn on_event(&mut self, event: Events) -> Result<ComponentResult, String> {
-    if let Events::Window {
-      event: lambda::events::WindowEvent::Resize { width, height },
-      ..
-    } = event
-    {
-      self.width = width;
-      self.height = height;
+  fn event_mask(&self) -> EventMask {
+    return EventMask::WINDOW;
+  }
+
+  fn on_window_event(&mut self, event: &WindowEvent) -> Result<(), String> {
+    match event {
+      WindowEvent::Resize { width, height } => {
+        self.width = *width;
+        self.height = *height;
+      }
+      _ => {}
     }
-    return Ok(ComponentResult::Success);
+    return Ok(());
   }
 
   fn on_update(

crates/lambda-rs/examples/reflective_room.rs

@@ -14,6 +14,12 @@
 
 use lambda::{
   component::Component,
+  events::{
+    EventMask,
+    Key,
+    VirtualKey,
+    WindowEvent,
+  },
   logging,
   math::matrix::Matrix,
   render::{
@@ -203,77 +209,73 @@ impl Component<ComponentResult, String> for ReflectiveRoomExample {
     return Ok(ComponentResult::Success);
   }
 
-  fn on_event(
-    &mut self,
-    event: lambda::events::Events,
-  ) -> Result<ComponentResult, String> {
+  fn event_mask(&self) -> EventMask {
+    return EventMask::WINDOW | EventMask::KEYBOARD;
+  }
+
+  fn on_window_event(&mut self, event: &WindowEvent) -> Result<(), String> {
+    match event {
+      WindowEvent::Resize { width, height } => {
+        self.width = *width;
+        self.height = *height;
+      }
+      _ => {}
+    }
+    return Ok(());
+  }
+
+  fn on_keyboard_event(&mut self, event: &Key) -> Result<(), String> {
     match event {
-      lambda::events::Events::Window { event, .. } => match event {
-        lambda::events::WindowEvent::Resize { width, height } => {
-          self.width = width;
-          self.height = height;
+      Key::Pressed {
+        scan_code: _,
+        virtual_key,
+      } => match virtual_key {
+        Some(VirtualKey::KeyM) => {
+          self.msaa_samples = if self.msaa_samples > 1 { 1 } else { 4 };
+          self.needs_rebuild = true;
+          logging::info!("Toggled MSAA → {}x (key: M)", self.msaa_samples);
+        }
+        Some(VirtualKey::KeyS) => {
+          self.stencil_enabled = !self.stencil_enabled;
+          self.needs_rebuild = true;
+          logging::info!("Toggled Stencil → {} (key: S)", self.stencil_enabled);
+        }
+        Some(VirtualKey::KeyD) => {
+          self.depth_test_enabled = !self.depth_test_enabled;
+          self.needs_rebuild = true;
+          logging::info!(
+            "Toggled Depth Test → {} (key: D)",
+            self.depth_test_enabled
+          );
+        }
+        Some(VirtualKey::KeyF) => {
+          self.mirror_mode = !self.mirror_mode;
+          logging::info!(
+            "Toggled Mirror Mode (hide floor overlay) → {} (key: F)",
+            self.mirror_mode
+          );
+        }
+        Some(VirtualKey::KeyI) => {
+          self.camera_pitch_turns =
+            (self.camera_pitch_turns - 0.01).clamp(0.0, 0.25);
+          logging::info!(
+            "Camera pitch (turns) → {:.3}",
+            self.camera_pitch_turns
+          );
+        }
+        Some(VirtualKey::KeyK) => {
+          self.camera_pitch_turns =
+            (self.camera_pitch_turns + 0.01).clamp(0.0, 0.25);
+          logging::info!(
+            "Camera pitch (turns) → {:.3}",
+            self.camera_pitch_turns
+          );
         }
-        _ => {}
-      },
-      lambda::events::Events::Keyboard { event, .. } => match event {
-        lambda::events::Key::Pressed {
-          scan_code: _,
-          virtual_key,
-        } => match virtual_key {
-          Some(lambda::events::VirtualKey::KeyM) => {
-            self.msaa_samples = if self.msaa_samples > 1 { 1 } else { 4 };
-            self.needs_rebuild = true;
-            logging::info!("Toggled MSAA → {}x (key: M)", self.msaa_samples);
-          }
-          Some(lambda::events::VirtualKey::KeyS) => {
-            self.stencil_enabled = !self.stencil_enabled;
-            self.needs_rebuild = true;
-            logging::info!(
-              "Toggled Stencil → {} (key: S)",
-              self.stencil_enabled
-            );
-          }
-          Some(lambda::events::VirtualKey::KeyD) => {
-            self.depth_test_enabled = !self.depth_test_enabled;
-            self.needs_rebuild = true;
-            logging::info!(
-              "Toggled Depth Test → {} (key: D)",
-              self.depth_test_enabled
-            );
-          }
-          Some(lambda::events::VirtualKey::KeyF) => {
-            self.mirror_mode = !self.mirror_mode;
-            logging::info!(
-              "Toggled Mirror Mode (hide floor overlay) → {} (key: F)",
-              self.mirror_mode
-            );
-          }
-          // 'R' previously forced an unmasked reflection; now disabled.
-          Some(lambda::events::VirtualKey::KeyI) => {
-            // Pitch camera up (reduce downward angle)
-            self.camera_pitch_turns =
-              (self.camera_pitch_turns - 0.01).clamp(0.0, 0.25);
-            logging::info!(
-              "Camera pitch (turns) → {:.3}",
-              self.camera_pitch_turns
-            );
-          }
-          Some(lambda::events::VirtualKey::KeyK) => {
-            // Pitch camera down (increase downward angle)
-            self.camera_pitch_turns =
-              (self.camera_pitch_turns + 0.01).clamp(0.0, 0.25);
-            logging::info!(
-              "Camera pitch (turns) → {:.3}",
-              self.camera_pitch_turns
-            );
-          }
-          _ => {}
-        },
         _ => {}
       },
       _ => {}
     }
-    return Ok(ComponentResult::Success);
+    return Ok(());
   }
 
   fn on_update(

crates/lambda-rs/examples/textured_cube.rs

@@ -7,6 +7,10 @@
 
 use lambda::{
   component::Component,
+  events::{
+    EventMask,
+    WindowEvent,
+  },
   logging,
   math::matrix::Matrix,
   render::{
@@ -364,21 +368,19 @@ impl Component<ComponentResult, String> for TexturedCubeExample {
     return Ok(ComponentResult::Success);
   }
 
-  fn on_event(
-    &mut self,
-    event: lambda::events::Events,
-  ) -> Result<ComponentResult, String> {
+  fn event_mask(&self) -> EventMask {
+    return EventMask::WINDOW;
+  }
+
+  fn on_window_event(&mut self, event: &WindowEvent) -> Result<(), String> {
     match event {
-      lambda::events::Events::Window { event, .. } => match event {
-        lambda::events::WindowEvent::Resize { width, height } => {
-          self.width = width;
-          self.height = height;
-        }
-        _ => {}
-      },
+      WindowEvent::Resize { width, height } => {
+        self.width = *width;
+        self.height = *height;
+      }
       _ => {}
     }
-    return Ok(ComponentResult::Success);
+    return Ok(());
   }
 
   fn on_update(