Add keyboard event handling and camera movement

src/controller.rs

@@ -1,3 +1,5 @@
+use winit::keyboard::KeyCode;
+use winit::event::KeyEvent;
 use winit::event::WindowEvent;
 
 use crate::camera::Camera;
@@ -22,12 +24,67 @@ impl CameraController{
         }
     }
 
-    pub fn process_input(&mut self, event: &winit::event::WindowEvent){
+
+    pub fn process_events(&mut self, event: &WindowEvent) -> bool {
         match event {
             WindowEvent::KeyboardInput{
-                device_id: ,
-                event: K
+                device_id: _,
+                is_synthetic: _,
+                event: winit::event::KeyEvent{
+                    physical_key: key,
+                    state: state,
+                    ..
+                }
+            } => {
+                if *key == winit::keyboard::KeyCode::KeyW{
+                    self.is_forward_pressed = *state == winit::event::ElementState::Pressed;
+                }
+                if *key == winit::keyboard::KeyCode::KeyS{
+                    self.is_backward_pressed = *state == winit::event::ElementState::Pressed;
+                }
+                if *key == winit::keyboard::KeyCode::KeyA{
+                    self.is_left_pressed = *state == winit::event::ElementState::Pressed;
+                }
+                if *key == winit::keyboard::KeyCode::KeyD{
+                    self.is_right_pressed = (*state == winit::event::ElementState::Pressed);
+                }
+
             }
+            _ => ()
+        }
+    }
+
+    pub fn update_camera(&self, camera: &mut Camera) {
+
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.length();  // Use glam's length method
+    
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
+        }
+        if self.is_backward_pressed {
+            camera.eye -= forward_norm * self.speed;
+        }
+    
+        let right = forward_norm.cross(camera.up);
+    
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.length();
+    
+        if self.is_right_pressed {
+            // Rescale the distance between the target and eye so
+            // that it doesn't change. The eye therefore still
+            // lies on the circle made by the target and eye.
+            let new_forward = (forward + right * self.speed).normalize();
+            camera.eye = camera.target - new_forward * forward_mag;
+        }
+        if self.is_left_pressed {
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
+    
 }

src/input.rs

@@ -0,0 +1,5 @@
+
+
+pub fn handle_key_event(){
+    
+}

src/lib.rs

@@ -343,7 +343,7 @@ impl<'a> State<'a> {
         //let (vertices, indices) = creer_plan_subdivise(1.0, 1.0, 10);
         //let vert = creer_plan_simple(1.0, 1.0);
 
-        let vert = generate_simple_plane();
+        let vert = generate_simple_plane(0.5, 1);
         // Create a buffer with the vertex data
         let vertex_buffer = device.create_buffer_init(
             &wgpu::util::BufferInitDescriptor{

src/main.rs

@@ -5,6 +5,7 @@ mod vertex;
 mod camera;
 mod simple_plane;
 mod controller;
+mod input;
 fn main() {
     pollster::block_on(run());
 }