Reformat

src/render/mod.rs

@@ -4,4 +4,4 @@ pub use pipelines::utils::create_render_pipeline;
 pub use pipelines::{GlobalBindLayout, Pipelines};
 
 mod renderer;
-pub use renderer::{Renderer, DefaultState, State};
+pub use renderer::{DefaultState, Renderer, State};

src/render/pipelines/utils.rs

@@ -56,4 +56,4 @@ pub fn create_render_pipeline(
         // indicates how many array layers the attachments will have.
         multiview: None,
     })
-}
+}

src/render/renderer/default_state.rs

@@ -222,18 +222,15 @@ impl super::State for DefaultState {
     fn input(&mut self, event: &Event<()>) -> bool {
         match event {
             Event::DeviceEvent {
-                event: DeviceEvent::MouseMotion{ delta, },
+                event: DeviceEvent::MouseMotion { delta },
                 ..
             } => {
                 if self.mouse_pressed {
                     self.camera_controller.process_mouse(delta.0, delta.1);
                 }
                 true
-            },
-            Event::WindowEvent {
-                ref event,
-                ..
-            } => match event {
+            }
+            Event::WindowEvent { ref event, .. } => match event {
                 WindowEvent::KeyboardInput {
                     input:
                         KeyboardInput {

src/render/renderer/mod.rs

@@ -5,13 +5,24 @@ pub use renderer::Renderer;
 mod default_state;
 pub use default_state::DefaultState;
 
-use wgpu::{TextureView, CommandEncoder, Queue};
+use wgpu::{CommandEncoder, Queue, TextureView};
 use winit::event::Event;
 
 pub trait State {
-  fn new(renderer: &Renderer) -> Self where Self: Sized;
-  fn resize(&mut self, device: &wgpu::Device, config: &wgpu::SurfaceConfiguration, new_size: winit::dpi::PhysicalSize<u32>);
-  fn input(&mut self, event: &Event<()>) -> bool;
-  fn update(&mut self, queue: &Queue, dt: instant::Duration);
-  fn render(&mut self, view: &TextureView, encoder: &mut CommandEncoder) -> Result<(), wgpu::SurfaceError>;
-}
+    fn new(renderer: &Renderer) -> Self
+    where
+        Self: Sized;
+    fn resize(
+        &mut self,
+        device: &wgpu::Device,
+        config: &wgpu::SurfaceConfiguration,
+        new_size: winit::dpi::PhysicalSize<u32>,
+    );
+    fn input(&mut self, event: &Event<()>) -> bool;
+    fn update(&mut self, queue: &Queue, dt: instant::Duration);
+    fn render(
+        &mut self,
+        view: &TextureView,
+        encoder: &mut CommandEncoder,
+    ) -> Result<(), wgpu::SurfaceError>;
+}

src/render/renderer/renderer.rs

@@ -10,7 +10,7 @@ pub struct Renderer {
     pub queue: wgpu::Queue,
     pub size: winit::dpi::PhysicalSize<u32>,
     pub config: wgpu::SurfaceConfiguration,
-    state: Option<Box<dyn State>>
+    state: Option<Box<dyn State>>,
 }
 
 impl Renderer {
@@ -63,7 +63,7 @@ impl Renderer {
             queue,
             config,
             size,
-            state: None
+            state: None,
         }
     }
 
@@ -75,26 +75,26 @@ impl Renderer {
             self.surface.configure(&self.device, &self.config);
 
             if let Some(state) = self.state.as_mut() {
-              state.resize(&self.device, &self.config, new_size);
+                state.resize(&self.device, &self.config, new_size);
             }
         }
     }
 
     pub fn input(&mut self, event: &Event<()>) -> bool {
         if let Some(state) = self.state.as_mut() {
-          return state.input(event);
+            return state.input(event);
         }
         false
     }
 
     pub fn update(&mut self, dt: instant::Duration) {
-      if let Some(state) = self.state.as_mut() {
-        state.update(&self.queue, dt);
-      }
+        if let Some(state) = self.state.as_mut() {
+            state.update(&self.queue, dt);
+        }
     }
 
     pub fn render(&mut self) -> Result<(), wgpu::SurfaceError> {
-      let output = self.surface.get_current_texture()?;
+        let output = self.surface.get_current_texture()?;
         let view = output
             .texture
             .create_view(&wgpu::TextureViewDescriptor::default());
@@ -106,7 +106,7 @@ impl Renderer {
             });
 
         if let Some(state) = self.state.as_mut() {
-          state.render(&view, &mut encoder)?;
+            state.render(&view, &mut encoder)?;
         }
 
         self.queue.submit(iter::once(encoder.finish()));
@@ -116,6 +116,6 @@ impl Renderer {
     }
 
     pub fn set_state(&mut self, state: Option<Box<dyn State>>) {
-      self.state = state;
+        self.state = state;
     }
 }