adamf/rust-raytracer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Massive cleanup for state.rs

Browse Source
This commit is contained in:
STP
2023-11-20 20:11:34 -05:00
parent 5e86bc2df3
commit 512f81031b
1 changed files with 73 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
src/state.rs
View File

@@ -21,67 +21,59 @@ const COLOUR_CLEAR: [u8; 4] = [0x22, 0x22, 0x11, 0xff];
pub fn run() {
let event_loop = EventLoop::new();
// Window
let window = {
let window = create_window(&event_loop);
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 pixels = {
let surface_texture = SurfaceTexture::new(window_size.width, window_size.height, &window);
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
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");
fn handle_window_event(event: WindowEvent, control_flow: &mut ControlFlow, state: &mut State) {
match event {
Event::WindowEvent { event, .. } => match event {
WindowEvent::CloseRequested => {
*control_flow = ControlFlow::Exit;
}
WindowEvent::Resized(size) => {
state.resize(&size).expect("Could not resize");
}
WindowEvent::KeyboardInput { input, .. } => {
state.keyboard_input(&input);
}
WindowEvent::MouseInput { button, .. } => {
state.mouse_input(&button);
}
WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
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();
match gui_event {
Some(event) => match event {
GuiEvent::BufferResize | GuiEvent::CameraRelocate => {
let pixels = &self.pixels;
if let Some(event) = self.gui.event.take() {
match event {
GuiEvent::BufferResize | GuiEvent::CameraRelocate => self.resize_buffer(),
GuiEvent::SceneLoad(filename) => self.load_scene(&filename),
}
}
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) {
Err(e) => Err(Box::new(e)),
_ => Ok(()),
}
pixels
.resize_surface(size.width, size.height)
.map_err(Box::new)
}
fn keyboard_input(&mut self, key: &KeyboardInput) {
match key.virtual_keycode {
Some(key) => match key {
VirtualKeyCode::A => {}
_ => {}
},
None => {}
if let Some(VirtualKeyCode::A) = key.virtual_keycode {
// Handle 'A' key event here
}
}
fn mouse_input(&mut self, button: &MouseButton) {}
/// Draw the `World` state to the frame buffer.
///
/// Assumes the default texture format: `wgpu::TextureFormat::Rgba8UnormSrgb`
fn mouse_input(&mut self, _button: &MouseButton) {
// Handle mouse input here
}
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 pixels = self.pixels.clone();
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 colour = self.rays[i].shade_ray(&self.scene);
let rgba = colour.map_or(COLOUR_CLEAR, |colour| [colour.x, colour.y, colour.z, 255]);
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() {
let rgba = [0x00, 0x00, 0x00, 0xff];
pixel.copy_from_slice(&rgba);
for pixel in frame.chunks_exact_mut(4) {
pixel.copy_from_slice(&[0x00, 0x00, 0x00, 0xff]);
}
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(())
}