chore(all): style formatting and clippy fixes

1 files changed, 156 insertions, 167 deletions

diff --git a/examples/render-bsp/src/main.rs b/examples/render-bsp/src/main.rs
index aeaf4e6..d4e5ba3 100644
--- a/examples/render-bsp/src/main.rs
+++ b/examples/render-bsp/src/main.rs
@@ -15,29 +15,25 @@
 
 //! Renders ./example.bsp
 
-extern crate stockton_types;
+extern crate log;
+extern crate simple_logger;
 extern crate stockton_levels;
 extern crate stockton_render;
+extern crate stockton_types;
 extern crate winit;
-extern crate log;
-extern crate simple_logger;
 
-use std::time::SystemTime;
 use std::f32::consts::PI;
+use std::time::SystemTime;
 
 use winit::{
-    event::{Event, WindowEvent, ElementState},
+    event::{ElementState, Event, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder
+    window::WindowBuilder,
 };
 
-use stockton_levels::{
-	prelude::*,
-	q3::Q3BSPFile
-};
-use stockton_types::{World, Vector3, Vector2};
+use stockton_levels::{prelude::*, q3::Q3BSPFile};
 use stockton_render::Renderer;
-
+use stockton_types::{Vector2, Vector3, World};
 
 /// Movement speed, world units per second
 const SPEED: f32 = 100.0;
@@ -46,168 +42,161 @@ const SPEED: f32 = 100.0;
 const PIXELS_PER_90D: f32 = 100.0;
 
 /// Sensitivity, derived from above
-const SENSITIVITY: f32 = PI / (2.0	 * PIXELS_PER_90D);
+const SENSITIVITY: f32 = PI / (2.0 * PIXELS_PER_90D);
 
 #[derive(Debug)]
 struct KeyState {
-	pub up: bool,
-	pub left: bool,
-	pub right: bool,
-	pub down: bool,
-	pub inwards: bool,
-	pub out: bool
+    pub up: bool,
+    pub left: bool,
+    pub right: bool,
+    pub down: bool,
+    pub inwards: bool,
+    pub out: bool,
 }
 
 impl KeyState {
-	pub fn new() -> KeyState {
-		KeyState {
-			up: false,
-			left: false,
-			right: false,
-			down: false,
-			inwards: false,
-			out: false,
-		}
-	}
-
-	/// Helper function to get our movement request as a normalized vector
-	pub fn as_vector(&self) -> Vector3 {
-		let mut vec = Vector3::new(0.0, 0.0, 0.0);
-
-		if self.up {
-			vec.y = 1.0;
-		} else if self.down {
-			vec.y = -1.0;
-		}
-
-		if self.right {
-			vec.x = 1.0;
-		} else if self.left {
-			vec.x = -1.0;
-		}
-
-		if self.inwards {
-			vec.z = 1.0;
-		} else if self.out {
-			vec.z = -1.0;
-		}
-
-		vec
-	}
+    pub fn new() -> KeyState {
+        KeyState {
+            up: false,
+            left: false,
+            right: false,
+            down: false,
+            inwards: false,
+            out: false,
+        }
+    }
+
+    /// Helper function to get our movement request as a normalized vector
+    pub fn as_vector(&self) -> Vector3 {
+        let mut vec = Vector3::new(0.0, 0.0, 0.0);
+
+        if self.up {
+            vec.y = 1.0;
+        } else if self.down {
+            vec.y = -1.0;
+        }
+
+        if self.right {
+            vec.x = 1.0;
+        } else if self.left {
+            vec.x = -1.0;
+        }
+
+        if self.inwards {
+            vec.z = 1.0;
+        } else if self.out {
+            vec.z = -1.0;
+        }
+
+        vec
+    }
 }
 
 fn main() {
-	// Initialise logger
-	simple_logger::init_with_level(log::Level::Debug).unwrap();
-
-	// Make a window
-	let event_loop = EventLoop::new();
-	let window = WindowBuilder::new().build(&event_loop).unwrap();
-
-	if let Err(_) = window.set_cursor_grab(true) {
-		println!("warning: cursor not grabbed");
-	}
-	window.set_cursor_visible(false);
-
-	// Parse the map file and swizzle the co-ords
-	let data = include_bytes!("../data/newtest.bsp").to_vec().into_boxed_slice();
-	let bsp: Result<Q3BSPFile<Q3System>, stockton_levels::types::ParseError> = Q3BSPFile::parse_file(&data);
-	let bsp: Q3BSPFile<Q3System> = bsp.unwrap();
-	let bsp: Q3BSPFile<VulkanSystem> = bsp.swizzle_to();
-
-	// Load into a world and create the new renderer
-	let world = World::new(bsp);
-	let mut renderer = Renderer::new(world, &window).unwrap();
-
-	// Done loading - This is our main loop.
-
-	let mut last_update = SystemTime::now();
-	let mut key_state = KeyState::new();
-	let mut last_cursor_pos = Vector2::new(0.0, 0.0);
-
-	// Keep rendering the world
-	event_loop.run(move |event, _, flow| {
-		*flow = ControlFlow::Poll;
-		match event {
-			Event::WindowEvent {
-				event,
-				..
-			} => match event {
-				// Close when requested
-				WindowEvent::CloseRequested => {
-					*flow = ControlFlow::Exit
-				},
-
-				WindowEvent::Resized(_) => {
-					unsafe { renderer.context.handle_surface_change().unwrap() };
-				}
-
-				// Update our keystates
-				WindowEvent::KeyboardInput {input, ..} => match input.scancode {
-					// A
-					30 => key_state.left = input.state == ElementState::Pressed,
-					// D
-					32 => key_state.right = input.state == ElementState::Pressed,
-					// W (in)
-					17 => key_state.inwards = input.state == ElementState::Pressed,
-					// S (out)
-					31 => key_state.out = input.state == ElementState::Pressed,
-					// Space (up)
-					57 => key_state.up = input.state == ElementState::Pressed,
-					// Ctrl (down)
-					42 => key_state.down = input.state == ElementState::Pressed,
-					_ => ()
-				},
-
-				// Look around with mouse
-				WindowEvent::CursorMoved {
-					position,
-					..
-				} => {
-					// Don't do anything on the first frame
-					if last_cursor_pos.x != 0.0 || last_cursor_pos.y == 0.0 {
-						// Figure out how much to rotate by
-						let x_offset = (position.x as f32 - last_cursor_pos.x) * SENSITIVITY;
-						let y_offset = (position.y as f32 - last_cursor_pos.y) * SENSITIVITY;
-
-						// Rotate
-						renderer.context.rotate(Vector3::new(
-							-y_offset,
-							x_offset,
-							0.0
-						));
-					}
- 
- 					// For tracking how much the mouse has moved
-					last_cursor_pos.x = position.x as f32;
-					last_cursor_pos.y = position.y as f32;
-				}
-				_ => ()
-			},
-
-			// Nothing new happened
-			Event::MainEventsCleared => {
-				// Draw as many frames as we can
-				// This isn't ideal, but it'll do for now.
-				window.request_redraw()
-			},
-
-			// Redraw - either from above or resizing, etc
-			Event::RedrawRequested(_) => {
-				// Time since last frame drawn. Again, not ideal.
-				let delta = last_update.elapsed().unwrap().as_secs_f32();
-				last_update = SystemTime::now();
-
-				// Move our camera if needed
-				let delta_pos = key_state.as_vector() * delta * SPEED;
-				if delta_pos.x != 0.0 || delta_pos.y != 0.0 || delta_pos.z != 0.0 {
-					renderer.context.move_camera_relative(delta_pos);
-				}
-
-				// Render the frame
-				renderer.render_frame().unwrap()
-			}
-			_ => ()
-		}
-	});
+    // Initialise logger
+    simple_logger::init_with_level(log::Level::Debug).unwrap();
+
+    // Make a window
+    let event_loop = EventLoop::new();
+    let window = WindowBuilder::new().build(&event_loop).unwrap();
+
+    if window.set_cursor_grab(true).is_err() {
+        println!("warning: cursor not grabbed");
+    }
+    window.set_cursor_visible(false);
+
+    // Parse the map file and swizzle the co-ords
+    let data = include_bytes!("../data/newtest.bsp")
+        .to_vec()
+        .into_boxed_slice();
+    let bsp: Result<Q3BSPFile<Q3System>, stockton_levels::types::ParseError> =
+        Q3BSPFile::parse_file(&data);
+    let bsp: Q3BSPFile<Q3System> = bsp.unwrap();
+    let bsp: Q3BSPFile<VulkanSystem> = bsp.swizzle_to();
+
+    // Load into a world and create the new renderer
+    let world = World::new(bsp);
+    let mut renderer = Renderer::new(world, &window).unwrap();
+
+    // Done loading - This is our main loop.
+
+    let mut last_update = SystemTime::now();
+    let mut key_state = KeyState::new();
+    let mut last_cursor_pos = Vector2::new(0.0, 0.0);
+
+    // Keep rendering the world
+    event_loop.run(move |event, _, flow| {
+        *flow = ControlFlow::Poll;
+        match event {
+            Event::WindowEvent { event, .. } => match event {
+                // Close when requested
+                WindowEvent::CloseRequested => *flow = ControlFlow::Exit,
+
+                WindowEvent::Resized(_) => {
+                    unsafe { renderer.context.handle_surface_change().unwrap() };
+                }
+
+                // Update our keystates
+                WindowEvent::KeyboardInput { input, .. } => match input.scancode {
+                    // A
+                    30 => key_state.left = input.state == ElementState::Pressed,
+                    // D
+                    32 => key_state.right = input.state == ElementState::Pressed,
+                    // W (in)
+                    17 => key_state.inwards = input.state == ElementState::Pressed,
+                    // S (out)
+                    31 => key_state.out = input.state == ElementState::Pressed,
+                    // Space (up)
+                    57 => key_state.up = input.state == ElementState::Pressed,
+                    // Ctrl (down)
+                    42 => key_state.down = input.state == ElementState::Pressed,
+                    _ => (),
+                },
+
+                // Look around with mouse
+                WindowEvent::CursorMoved { position, .. } => {
+                    // Don't do anything on the first frame
+                    if last_cursor_pos.x != 0.0 || last_cursor_pos.y == 0.0 {
+                        // Figure out how much to rotate by
+                        let x_offset = (position.x as f32 - last_cursor_pos.x) * SENSITIVITY;
+                        let y_offset = (position.y as f32 - last_cursor_pos.y) * SENSITIVITY;
+
+                        // Rotate
+                        renderer
+                            .context
+                            .rotate(Vector3::new(-y_offset, x_offset, 0.0));
+                    }
+
+                    // For tracking how much the mouse has moved
+                    last_cursor_pos.x = position.x as f32;
+                    last_cursor_pos.y = position.y as f32;
+                }
+                _ => (),
+            },
+
+            // Nothing new happened
+            Event::MainEventsCleared => {
+                // Draw as many frames as we can
+                // This isn't ideal, but it'll do for now.
+                window.request_redraw()
+            }
+
+            // Redraw - either from above or resizing, etc
+            Event::RedrawRequested(_) => {
+                // Time since last frame drawn. Again, not ideal.
+                let delta = last_update.elapsed().unwrap().as_secs_f32();
+                last_update = SystemTime::now();
+
+                // Move our camera if needed
+                let delta_pos = key_state.as_vector() * delta * SPEED;
+                if delta_pos.x != 0.0 || delta_pos.y != 0.0 || delta_pos.z != 0.0 {
+                    renderer.context.move_camera_relative(delta_pos);
+                }
+
+                // Render the frame
+                renderer.render_frame().unwrap()
+            }
+            _ => (),
+        }
+    });
 }