Massive cleanup for state.rs

src/state.rs

@@ -21,67 +21,59 @@ const COLOUR_CLEAR: [u8; 4] = [0x22, 0x22, 0x11, 0xff];
 
 pub fn run() {
     let event_loop = EventLoop::new();
-    // Window
+    let window = create_window(&event_loop);
-    let window = {
+    let pixels = create_pixels(&window);
+    let gui = Gui::new(&window, &pixels);
+
+    let mut state = State::new(window, pixels, gui);
+    state.clear();
+
+    event_loop.run(move |event, _, control_flow| {
+        state.gui.handle_event(&state.window, &event);
+        state.update().expect("Could not update");
+
+        match event {
+            Event::WindowEvent { event, .. } => {
+                handle_window_event(event, control_flow, &mut state)
+            }
+            Event::RedrawRequested(_) => state.render().expect("Failed to render"),
+            _ => state.window.request_redraw(),
+        }
+    });
+}
+
+fn create_window(event_loop: &EventLoop<()>) -> Window {
     let size = LogicalSize::new(START_WIDTH, START_HEIGHT);
     WindowBuilder::new()
         .with_title("Hello Pixels + Dear ImGui")
         .with_inner_size(size)
         .with_min_inner_size(size)
-            .build(&event_loop)
+        .build(event_loop)
         .unwrap()
-    };
+}
+
+fn create_pixels(window: &Window) -> Pixels {
     let window_size = window.inner_size();
-    //Display Surface
+    let surface_texture = SurfaceTexture::new(window_size.width, window_size.height, window);
-    let pixels = {
-        let surface_texture = SurfaceTexture::new(window_size.width, window_size.height, &window);
     Pixels::new(1, 1, surface_texture).unwrap()
-    };
+}
-    //Gui
-    let gui = Gui::new(&window, &pixels);
 
-    //State
+fn handle_window_event(event: WindowEvent, control_flow: &mut ControlFlow, state: &mut State) {
-    let mut state = State::new(window, pixels, gui);
-    state.clear();
-
-    event_loop.run(move |event, _, control_flow| {
-        // Draw the current frame
-        state.gui.handle_event(&state.window, &event); //Let gui handle its events
-        state.update().expect("Could not update");
     match event {
-            Event::WindowEvent { event, .. } => match event {
+        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                WindowEvent::CloseRequested => {
+        WindowEvent::Resized(size) => state.resize(&size).expect("Could not resize"),
-                    *control_flow = ControlFlow::Exit;
+        WindowEvent::KeyboardInput { input, .. } => state.keyboard_input(&input),
-                }
+        WindowEvent::MouseInput { button, .. } => state.mouse_input(&button),
-                WindowEvent::Resized(size) => {
-                    state.resize(&size).expect("Could not resize");
-                }
-                WindowEvent::KeyboardInput { input, .. } => {
-                    state.keyboard_input(&input);
-                }
-                WindowEvent::MouseInput { button, .. } => {
-                    state.mouse_input(&button);
-                }
         _ => {}
-            },
-            Event::RedrawRequested(_) => {
-                state.render().expect("Failed to render");
     }
-            _ => {
-                state.window.request_redraw();
-            }
-        }
-    });
 }
 
 pub struct State {
     scene: Scene,
     rays: Vec<Ray>,
-
     window: Window,
     buffer_width: u32,
     buffer_height: u32,
-
     pixels: Arc<Mutex<Pixels>>,
     gui: Gui,
     index: usize,
@@ -99,8 +91,6 @@ impl State {
     }
 
     pub fn new(window: Window, pixels: Pixels, gui: Gui) -> Self {
-        // Event Loop
-        //Initalise empty scene for rendering
         let scene = Scene::empty();
         let window_size = window.inner_size();
         let rays = scene
@@ -120,11 +110,16 @@ impl State {
     }
 
     fn update(&mut self) -> Result<(), Box<dyn Error>> {
-        let gui_event = self.gui.event.take();
+        if let Some(event) = self.gui.event.take() {
-        match gui_event {
+            match event {
-            Some(event) => match event {
+                GuiEvent::BufferResize | GuiEvent::CameraRelocate => self.resize_buffer(),
-                GuiEvent::BufferResize | GuiEvent::CameraRelocate => {
+                GuiEvent::SceneLoad(filename) => self.load_scene(&filename),
-                    let pixels = &self.pixels;
+            }
+        }
+        Ok(())
+    }
+
+    fn resize_buffer(&mut self) {
         let size = self.window.inner_size();
         self.buffer_width = (size.width as f32 * self.gui.buffer_proportion) as u32;
         self.buffer_height = (size.height as f32 * self.gui.buffer_proportion) as u32;
@@ -134,65 +129,38 @@ impl State {
             .resize_buffer(self.buffer_width, self.buffer_height)
             .expect("Resize Error");
     }
-                GuiEvent::SceneLoad(filename) => {
-                    println!("Reading {}", filename);
-                    match self.update_scene_from_file(&filename) {
-                        Err(e) => {
-                            println!("{}", e)
-                        }
-                        Ok(()) => {
-                            println!("Loaded file: {filename}")
-                        }
-                    }
 
+    fn load_scene(&mut self, filename: &String) {
+        println!("Reading {}", filename);
+        match self.update_scene_from_file(filename) {
+            Err(e) => println!("{}", e),
+            Ok(()) => println!("Loaded file: {filename}"),
+        }
         self.clear();
     }
-            },
-            None => {}
-        }
-        self.gui.event = None;
-        Ok(())
-    }
 
-    /// Resize the world
     fn resize(&mut self, size: &PhysicalSize<u32>) -> Result<(), Box<dyn Error>> {
-        println!("RESIZING!");
-        let gui = &self.gui;
         let mut pixels = self.pixels.lock().unwrap();
-        match pixels.resize_surface(size.width, size.height) {
+        pixels
-            Err(e) => Err(Box::new(e)),
+            .resize_surface(size.width, size.height)
-            _ => Ok(()),
+            .map_err(Box::new)
-        }
     }
 
     fn keyboard_input(&mut self, key: &KeyboardInput) {
-        match key.virtual_keycode {
+        if let Some(VirtualKeyCode::A) = key.virtual_keycode {
-            Some(key) => match key {
+            // Handle 'A' key event here
-                VirtualKeyCode::A => {}
-                _ => {}
-            },
-            None => {}
         }
     }
-    fn mouse_input(&mut self, button: &MouseButton) {}
 
-    /// Draw the `World` state to the frame buffer.
+    fn mouse_input(&mut self, _button: &MouseButton) {
-    ///
+        // Handle mouse input here
-    /// Assumes the default texture format: `wgpu::TextureFormat::Rgba8UnormSrgb`
+    }
+
     fn draw(&mut self) -> Result<(), Box<dyn Error>> {
-        for i in 0..self.gui.ray_num {
+        for _ in 0..self.gui.ray_num {
             let i = self.index as usize;
-            let ray_num = self.gui.ray_num;
+            let colour = self.rays[i].shade_ray(&self.scene);
-            let pixels = self.pixels.clone();
+            let rgba = colour.map_or(COLOUR_CLEAR, |colour| [colour.x, colour.y, colour.z, 255]);
-            let colour = {
-                let ray = &self.rays[i];
-                raytracer::shade_ray(&self.scene, &ray)
-            };
-
-            let rgba = match colour {
-                Some(colour) => [colour.x, colour.y, colour.z, 255],
-                None => COLOUR_CLEAR,
-            };
             let mut pixels = self.pixels.lock().unwrap();
             let frame = pixels.frame_mut();
             frame[i * 4..(i + 1) * 4].copy_from_slice(&rgba);
@@ -205,9 +173,8 @@ impl State {
         self.index = 0;
         let mut pixels = self.pixels.lock().unwrap();
         let frame = pixels.frame_mut();
-        for (i, pixel) in frame.chunks_exact_mut(4).enumerate() {
+        for pixel in frame.chunks_exact_mut(4) {
-            let rgba = [0x00, 0x00, 0x00, 0xff];
+            pixel.copy_from_slice(&[0x00, 0x00, 0x00, 0xff]);
-            pixel.copy_from_slice(&rgba);
         }
         self.scene.camera.set_position(self.gui.camera_eye);
         self.rays = self
@@ -231,7 +198,6 @@ impl State {
         });
         if let Err(err) = render_result {
             log_error("pixels.render", err);
-            return Ok(());
         }
         Ok(())
     }