project structure cleanup

src/app/camera_controller.rs

@@ -1,7 +1,7 @@
 use winit::event::Event;
 use winit::event::{WindowEvent, DeviceEvent, KeyboardInput, ElementState, VirtualKeyCode};
 use cgmath::{InnerSpace, Matrix4, Rad, Deg, Transform, Vector3};
-use crate::camera::Camera;
+use crate::renderer::camera::Camera;
 
 #[derive(Default)]
 struct CameraMovement {

src/app/mod.rs

@@ -0,0 +1,60 @@
+use winit::{
+    event::{Event, WindowEvent, KeyboardInput, ElementState, VirtualKeyCode, MouseButton},
+    window::Window
+};
+use std::sync::Arc;
+
+mod camera_controller; use camera_controller::CameraController;
+use crate::renderer::Renderer;
+
+
+pub struct App {
+    pub window: Window,
+    pub renderer: Renderer,
+    camera_controller: CameraController,
+}
+
+impl App {
+    pub fn new(window: Window, renderer: Renderer) -> Self {
+        let camera_controller = CameraController::new();
+        Self { window, renderer, camera_controller }
+    }
+
+    pub fn input(&mut self, event: Arc<Event<()>>) {
+
+        match event.as_ref() {
+            Event::WindowEvent { ref event, .. } => {
+                match event {
+                    // Escape key
+                    WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, virtual_keycode: Some(VirtualKeyCode::Escape), .. }, .. } => {
+                        self.window.set_cursor_grab(false).unwrap();
+                        self.window.set_cursor_visible(true);
+                        self.camera_controller.set_enabled(false);
+                    }
+                    // Window clicked
+                    WindowEvent::MouseInput { state: ElementState::Pressed, button: MouseButton::Left, .. } => {
+                        self.window.set_cursor_grab(true).unwrap();
+                        self.window.set_cursor_visible(false);
+                        self.camera_controller.set_enabled(true);
+                    }
+                    // Window resized
+                    WindowEvent::Resized(physical_size) => {
+                        self.renderer.resize(Some(*physical_size));
+                    }
+                    WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
+                        self.renderer.resize(Some(**new_inner_size));
+                    }
+                    _ => ()
+                }
+            }
+            _ => ()
+        }
+
+        // Update camera controller
+        self.camera_controller.handle_input(event.as_ref());
+    }
+
+    pub fn update(&mut self, delta: f32) {
+        self.camera_controller.update_camera(&mut self.renderer.camera, delta);
+    }
+}

src/main.rs

@@ -6,75 +6,52 @@ use winit::{
     dpi::LogicalSize
 };
 
-mod vertex;
+
-mod texture;
+mod renderer; use renderer::Renderer;
-mod uniforms;
+mod app; use app::App;
-mod camera;
-mod app;
-mod camera_controller;
-use app::App;
 
 fn main() {
     // Create event loop
     let events = EventLoop::new();
 
-    // Spawn window
+    // Create app
-    let window = WindowBuilder::new()
+    let _window = WindowBuilder::new()
         .with_title("Test")
         .with_inner_size(LogicalSize::new(1280.0, 720.0))
         .build(&events)
         .expect("Failed to create window");
+    let _renderer = futures::executor::block_on(Renderer::new(&_window));
+    let mut app = App::new(_window, _renderer);
 
-    // Create app
+    // Stats
-    let mut app = futures::executor::block_on(App::new(&window));
-
     let mut fps_timer = std::time::Instant::now();
     let mut fps_counter = 0;
     let mut delta_timer = std::time::Instant::now();
 
     // Run event loop
-    events.run(move |e, _, c| {
+    events.run(move |ev, _, c| {
-        let ev = Arc::new(e);
+        // App input
+        let event = Arc::new(ev);
+        app.input(event.clone());
 
-        if app.input(ev.clone()) {
+        // Other
-            // Event consumed
+        match event.as_ref() {
-            return;
-        }
-
-        match ev.as_ref() {
             // Window event
             Event::WindowEvent { ref event, .. } => {
                 match event {
                     // Window closed (ALT+F4,)
-                    WindowEvent::CloseRequested => {
+                    WindowEvent::CloseRequested => { *c = ControlFlow::Exit; }
-                        *c = ControlFlow::Exit;
-                    }
-                    // Escape key
-                    WindowEvent::KeyboardInput { input: KeyboardInput { state: ElementState::Pressed, virtual_keycode: Some(VirtualKeyCode::Escape), .. }, .. } => {
-                        window.set_cursor_grab(false).unwrap();
-                        window.set_cursor_visible(true);
-                        app.camera_controller.set_enabled(false);
-                    }
-                    // Window clicked
-                    WindowEvent::MouseInput { state: ElementState::Pressed, button: MouseButton::Left, .. } => {
-                        window.set_cursor_grab(true).unwrap();
-                        window.set_cursor_visible(false);
-                        app.camera_controller.set_enabled(true);
-                    }
-                    // Window resized
-                    WindowEvent::Resized(physical_size) => {
-                        app.resize(Some(*physical_size));
-                    }
-                    WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
-                        app.resize(Some(**new_inner_size));
-                    }
-                    // Other window events
                     _ => ()
                 }
             }
-            // Request draw
+            // Loop
             Event::MainEventsCleared => {
-                window.request_redraw();
+                // Update
+                app.update(delta_timer.elapsed().as_secs_f32());
+                delta_timer = std::time::Instant::now();
+
+                // Redraw
+                app.window.request_redraw();
             }
             // Draw
             Event::RedrawRequested(_) => {
@@ -88,16 +65,12 @@ fn main() {
                     fps_counter = 0;
                 }
                 fps_counter += 1;
-                
-                // Update and Render
-                app.update(delta_timer.elapsed().as_secs_f32());
-                delta_timer = std::time::Instant::now();
 
                 // Render
-                match app.render() {
+                match app.renderer.render() {
                     Ok(_) => { }
                     // Recreate the swap_chain if lost
-                    Err(wgpu::SwapChainError::Lost) => app.resize(None),
+                    Err(wgpu::SwapChainError::Lost) => app.renderer.resize(None),
                     // The system is out of memory, we should probably quit
                     Err(wgpu::SwapChainError::OutOfMemory) => *c = ControlFlow::Exit,
                     // All other errors (Outdated, Timeout) should be resolved by the next frame

src/renderer/mod.rs

@@ -1,30 +1,22 @@
-use std::sync::Arc;
-use winit::event::Event;
 use winit::{window::Window, dpi::PhysicalSize};
 use wgpu::util::DeviceExt;
 
-use crate::vertex::Vertex;
+mod vertex; use vertex::Vertex;
-use crate::texture::Texture;
+mod texture; use texture::Texture;
-use crate::camera::Camera;
+pub mod camera; use camera::Camera;
-use crate::uniforms::Uniforms;
+mod uniforms; use uniforms::Uniforms;
-use crate::camera_controller::CameraController;
 
 
-// A B
-// C D
 const VERTICES: &[Vertex] = &[
-    Vertex { position: [-1.0, 1.0, 0.0], uv: [-1.0, 1.0] }, // A
+    Vertex { position: [-1.0, 1.0, 0.0], uv: [-1.0, 1.0] }, // top left
-    Vertex { position: [ 1.0, 1.0, 0.0], uv: [1.0, 1.0] }, // B
+    Vertex { position: [ 1.0, 1.0, 0.0], uv: [1.0, 1.0] }, // top right
-    Vertex { position: [ 1.0,-1.0, 0.0], uv: [1.0, -1.0] }, // C
+    Vertex { position: [ 1.0,-1.0, 0.0], uv: [1.0, -1.0] }, // bottom right
-    Vertex { position: [-1.0,-1.0, 0.0], uv: [-1.0, -1.0] }, // D
+    Vertex { position: [-1.0,-1.0, 0.0], uv: [-1.0, -1.0] }, // bottom left
 ];
+const INDICES: &[u16] = &[ 0, 1, 3, 3, 1, 2 ];
 
-const INDICES: &[u16] = &[
-    0, 1, 3,
-    3, 1, 2
-];
 
-pub struct App {
+pub struct Renderer {
     surface: wgpu::Surface,
     device: wgpu::Device,
     queue: wgpu::Queue,
@@ -40,12 +32,11 @@ pub struct App {
     // Texture
     bind_group: wgpu::BindGroup,
     // Camera
-    camera: Camera,
+    pub camera: Camera,
-    pub camera_controller: CameraController,
     uniforms: Uniforms
 }
 
-impl App {
+impl Renderer {
 
     fn create_swapchain(adapter: &wgpu::Adapter, device: &wgpu::Device, surface: &wgpu::Surface, size: PhysicalSize<u32>) -> (wgpu::SwapChainDescriptor, wgpu::SwapChain) {
         let swapchain_desc = wgpu::SwapChainDescriptor {
@@ -67,12 +58,12 @@ impl App {
             push_constant_ranges: &[],
         });
         let vert_state = wgpu::VertexState { //vert
-            module: &device.create_shader_module(&wgpu::include_spirv!("shaders\\bin\\shader.vert.spv")),
+            module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.vert.spv")),
             entry_point: "main",
             buffers: &[Vertex::desc()],
         };
         let frag_state = wgpu::FragmentState { // frag
-            module: &device.create_shader_module(&wgpu::include_spirv!("shaders\\bin\\shader.frag.spv")),
+            module: &device.create_shader_module(&wgpu::include_spirv!("..\\shaders\\bin\\shader.frag.spv")),
             entry_point: "main",
             targets: &[wgpu::ColorTargetState {
                 format: swapchain_desc.format,
@@ -219,7 +210,6 @@ impl App {
         let camera = Camera::new(aspect, 60.0);
         let mut uniforms = Uniforms::new();
         uniforms.update(&camera);
-        let camera_controller = CameraController::new();
 
         // Buffers
         let vertex_buffer = Self::create_buffer(&device, wgpu::BufferUsage::VERTEX, bytemuck::cast_slice(VERTICES));
@@ -237,7 +227,7 @@ impl App {
 
         // Save values in app
         println!("Initialized");
-        Self { surface, device, queue, swapchain_desc, swapchain, pipeline, vertex_buffer, index_buffer, uniform_buffer, bind_group, uniform_bind_group, camera, uniforms, camera_controller }
+        Self { surface, device, queue, swapchain_desc, swapchain, pipeline, vertex_buffer, index_buffer, uniform_buffer, bind_group, uniform_bind_group, camera, uniforms }
     }
 
     pub fn resize(&mut self, new_size: Option<PhysicalSize<u32>>) {
@@ -254,23 +244,15 @@ impl App {
         self.swapchain = self.device.create_swap_chain(&self.surface, &self.swapchain_desc);
     }
 
-    pub fn input(&mut self, event: Arc<Event<()>>) -> bool {
+    pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
-        self.camera_controller.handle_input(event.as_ref())
-    }
 
-    pub fn update(&mut self, delta_time: f32) {
+        // Update uniform buffer
-        // Update camera
-        self.camera_controller.update_camera(&mut self.camera, delta_time);
-
-        // Update projection matrix buffer
         self.uniforms.update(&self.camera);
         self.queue.write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[self.uniforms]));
-    }
-
-    pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
 
         // Get next frame to render to
         let frame = self.swapchain.get_current_frame()?.output;
+
         // Create encoder that will build command buffer for us
         let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"),});
 
@@ -285,19 +267,15 @@ impl App {
 
             let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { 
                 label: Some("Render Pass"),
-                color_attachments: &[
+                color_attachments: &[ wgpu::RenderPassColorAttachmentDescriptor { attachment: &frame.view, resolve_target: None, ops } ],
-                    wgpu::RenderPassColorAttachmentDescriptor {
-                        attachment: &frame.view,
-                        resolve_target: None,
-                        ops: ops
-                    }
-                ],
                 depth_stencil_attachment: None,
             });
 
+            // Data
             render_pass.set_pipeline(&self.pipeline);
             render_pass.set_bind_group(0, &self.bind_group, &[]);
             render_pass.set_bind_group(1, &self.uniform_bind_group, &[]);
+            // Vertices and indices
             render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
             render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
             render_pass.draw_indexed(0..(INDICES.len() as u32), 0, 0..1);

src/renderer/uniforms.rs

@@ -1,6 +1,5 @@
 use cgmath::SquareMatrix;
-
+use super::camera::Camera;
-use crate::camera::Camera;
 
 
 #[repr(C)]