Huge input update, FPS Camera controls system

Long day. I now store winit:🪟:Window in a mutex.

game/src/main.rs

@@ -10,12 +10,56 @@ use raidillon_ecs::Transform;
 use raidillon_core::scene::Scene;
 #[cfg(feature = "glium")]
 use raidillon_glium::GliumPlatform;
-use winit::event::{Event, WindowEvent};
+use winit::event::{ElementState, Event, WindowEvent};
+use winit::event::DeviceEvent::MouseMotion;
+use winit::keyboard::{KeyCode, PhysicalKey};
+use raidillon_engine::systems::fps_camera::FPSCameraSystem;
 
 const TEST_GLTF: &str = "pink-monkey.gltf";
 
 const MAIN_SCENE_ID: &str = "main_scene";
 
+#[derive(Default)]
+struct InputTestSystem {
+    mouse_delta: (f64, f64),
+}
+
+impl System for InputTestSystem {
+    fn handle_event(&mut self, ctx: &mut SystemContext) {
+        let event2 = ctx.platform_context.current_event.clone();
+        match event2 {
+            Event::DeviceEvent { device_id, event} => {
+                match event {
+                    MouseMotion { delta } => {
+                        self.mouse_delta.0 += delta.0;
+                        self.mouse_delta.1 += delta.1;
+                        println!("UPDATED mouse delta: ({},{})", self.mouse_delta.0, self.mouse_delta.1);
+                    },
+                    _ => {}
+                }
+            },
+            Event::WindowEvent { event, .. } => match event {
+                WindowEvent::KeyboardInput { device_id, event, is_synthetic} => {
+                    let PhysicalKey::Code(key_code) = event.physical_key else {
+                        return;
+                    };
+
+                    match event.state {
+                        ElementState::Pressed => {
+                            println!("Pressed Key: {:?}", key_code);
+                        }
+                        ElementState::Released => {
+                            println!("Released Key: {:?}", key_code);
+                        }
+                    }
+                }
+                _ => {},
+            }
+            _ => {},
+        }
+    }
+}
+
 #[derive(Default)]
 struct UpdateAspectRatioSystem;
 impl System for UpdateAspectRatioSystem {
@@ -42,16 +86,6 @@ impl System for RenderingTestSystem {
     fn load_world(&mut self, ctx: &mut SystemContext) {
         self.rotation_speed = std::rc::Rc::new(std::cell::RefCell::new(5.0));
 
-        ctx.scene.world.spawn((Camera {
-            eye:    Vec3::new(0.0, 0.0, 2.0),
-            center: Vec3::ZERO,
-            up:     Vec3::Y,
-            fovy:   60_f32.to_radians(),
-            aspect: ctx.platform_context.frame_width / ctx.platform_context.frame_height,
-            znear:  0.1,
-            zfar:   100.0,
-        },));
-
         let mut am = ctx.platform_context.asset_manager.borrow_mut();
 
         am.load_gltf(TEST_GLTF, &model_path(TEST_GLTF));
@@ -72,6 +106,20 @@ impl System for RenderingTestSystem {
         dbg_ui.text(format!("Frame Delta: {}", ctx.platform_context.time_ctx.frame_dt));
         dbg_ui.text(format!("Fixed Delta: {}", ctx.platform_context.time_ctx.fixed_dt));
         dbg_ui.slider_f32("Rotation Speed", -10.0, 10.0, self.rotation_speed.clone());
+
+        let input = ctx.input_state.borrow();
+        if input.key_held(KeyCode::KeyW) {
+            dbg_ui.text("W".to_owned());
+        }
+        if input.key_held(KeyCode::KeyA) {
+            dbg_ui.text("A".to_owned());
+        }
+        if input.key_held(KeyCode::KeyS) {
+            dbg_ui.text("S".to_owned());
+        }
+        if input.key_held(KeyCode::KeyD) {
+            dbg_ui.text("D".to_owned());
+        }
     }
 
     fn fixed_update(&mut self, ctx: &mut SystemContext) {
@@ -85,8 +133,10 @@ impl System for RenderingTestSystem {
 fn main() {
     let mut engine = Engine::new();
     // Define systems
+    engine.system_manager.add::<FPSCameraSystem>();
     engine.system_manager.add::<RenderingTestSystem>();
     engine.system_manager.add::<UpdateAspectRatioSystem>();
+    // engine.system_manager.add::<InputTestSystem>();
 
     // Set up the scene
     let main_scene = Scene::new(
@@ -102,7 +152,7 @@ fn main() {
             engine,
             "Raidillon".to_string(),
             2560,
-            1440,
+            1080,
         );
         platform.run()
     };