project structure cleaning

src/renderer/buffers/mod.rs

@@ -30,3 +30,25 @@ pub use raster::Vertex;
 
 mod materials;
 pub use materials::Materials;
+
+// Create buffers
+
+pub struct Buffers {
+    pub uniform_buffer: Uniform,
+    pub raster_buffer: Raster,
+    pub node_buffer: Nodes,
+    pub brick_buffer: Blocks,
+    pub material_buffer: Materials
+}
+
+impl Buffers {
+
+    pub fn new(device: &wgpu::Device) -> Self {
+        let uniform_buffer = Uniform::new(device);
+        let raster_buffer = Raster::new(device);
+        let node_buffer = Nodes::new(device);
+        let brick_buffer = Blocks::new(device);
+        let material_buffer = Materials::new(device);
+        Self { uniform_buffer, raster_buffer, node_buffer, brick_buffer, material_buffer }
+    }
+}

src/renderer/mod.rs

@@ -2,7 +2,7 @@ use winit::{window::Window, dpi::PhysicalSize};
 use cgmath::{Point3};
 
 pub mod buffers; 
-use buffers::{Nodes, Blocks, Uniform, Raster, Materials};
+use buffers::{Buffers, Nodes, Blocks, Uniform, Raster, Materials};
 
 mod passes;
 use passes::RaytracePass;
@@ -17,13 +17,9 @@ pub struct Renderer {
     queue: wgpu::Queue,
     swapchain_desc: wgpu::SwapChainDescriptor,
     swapchain: wgpu::SwapChain,
-    raytrace: RaytracePass,
+    raytrace_pass: RaytracePass,
     // Buffers
-    raster_buffer: Raster,
+    buffers: Buffers,
-    uniform_buffer: Uniform,
-    node_buffer: Nodes,
-    brick_buffer: Blocks,
-    material_buffer: Materials,
     // Other
     pub camera: Camera,
     start: std::time::Instant,
@@ -32,64 +28,46 @@ pub struct Renderer {
 
 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 {
-            usage: wgpu::TextureUsage::RENDER_ATTACHMENT, // render to screen
-            format: adapter.get_swap_chain_preferred_format(&surface),
-            width: size.width,
-            height: size.height,
-            present_mode: wgpu::PresentMode::Fifo, // Fifo = Vsync
-        };
-        let swapchain = device.create_swap_chain(&surface, &swapchain_desc);
-        (swapchain_desc, swapchain)
-    }
-    
     /*
     *   Initializes renderer and all buffers
     */
     pub async fn new(window: &Window) -> Self {
 
-        // Create surface and pick device
+        // Create surface
         let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
         let surface = unsafe { instance.create_surface(window) };
 
-        // Pick adapter (physical gpu)
+        // Pick and initialize device
         let adapter_options = wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, compatible_surface: Some(&surface) };
         let adapter = instance.request_adapter(&adapter_options).await.unwrap();
-        println!("Adapter: {}", adapter.get_info().name);
-
-        // Pick device (logical gpu) from adapter 
         let device_desc = wgpu::DeviceDescriptor { features: wgpu::Features::empty(), limits: wgpu::Limits::default(), label: None };
         let (device, queue) = adapter.request_device(&device_desc, None).await.unwrap();
 
         // Create swapchain
-        let (swapchain_desc, swapchain) = Self::create_swapchain(&adapter, &device, &surface, window.inner_size());
+        let window_size =  window.inner_size();
+        let swapchain_desc = wgpu::SwapChainDescriptor {
+            usage: wgpu::TextureUsage::RENDER_ATTACHMENT, // render to screen
+            format: adapter.get_swap_chain_preferred_format(&surface),
+            width: window_size.width,
+            height: window_size.height,
+            present_mode: wgpu::PresentMode::Fifo, // Fifo = Vsync
+        };
+        let swapchain = device.create_swap_chain(&surface, &swapchain_desc);
 
-        // Cam
+        // Camera
         let aspect = swapchain_desc.width as f32 / swapchain_desc.height as f32;
         let camera = Camera::new(aspect, 60.0);
         
-        // Buffers
-        let uniform_buffer = Uniform::new(&device);
-        let raster_buffer = Raster::new(&device);
-        let node_buffer = Nodes::new(&device);
-        let brick_buffer = Blocks::new(&device);
-        let material_buffer = Materials::new(&device);
-
         // Pipeline
-        let bind_layouts = [
+        let buffers = Buffers::new(&device);
-            &uniform_buffer.bind_layout, 
+        let raytrace_pass = RaytracePass::new(&device, &swapchain_desc, &buffers);
-            &node_buffer.bind_layout, 
-            &brick_buffer.bind_layout,
-            &material_buffer.bind_layout
-        ];
-        let raytrace = RaytracePass::new(&device, &swapchain_desc, &bind_layouts);
 
-        // Save values in app
+        // Other
-        println!("Initialized");
         let start = std::time::Instant::now();
         let changed_bricks: Vec<usize> = Vec::new();
-        Self { surface, device, queue, swapchain_desc, swapchain, raytrace, raster_buffer, uniform_buffer, node_buffer, brick_buffer, material_buffer, camera, start, changed_bricks }
+
+        println!("Initialized");
+        Self { surface, device, queue, swapchain_desc, swapchain, raytrace_pass, buffers, camera, start, changed_bricks }
     }
 
     /*
@@ -115,17 +93,17 @@ impl Renderer {
     pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
 
         // Update uniform buffer
-        self.uniform_buffer.values.update(&self.camera, self.start.elapsed().as_secs_f32());
+        self.buffers.uniform_buffer.values.update(&self.camera, self.start.elapsed().as_secs_f32());
-        self.queue.write_buffer(&self.uniform_buffer.buffer, 0, bytemuck::cast_slice(&[self.uniform_buffer.values]));
+        self.queue.write_buffer(&self.buffers.uniform_buffer.buffer, 0, bytemuck::cast_slice(&[self.buffers.uniform_buffer.values]));
 
         // Update changed nodes
         if self.changed_bricks.len() > 0 {
-            self.node_buffer.write(&self.queue);
+            self.buffers.node_buffer.write(&self.queue);
             for node in &self.changed_bricks {
-                self.brick_buffer.write(&self.queue, *node);
+                self.buffers.brick_buffer.write(&self.queue, *node);
             }
 
-            let used = self.brick_buffer.next_block(false);
+            let used = self.buffers.brick_buffer.next_block(false);
             let total = buffers::BLOCK_TEX_SIZE * buffers::BLOCK_TEX_SIZE;
             let changed = self.changed_bricks.len();
             println!("Used: {}/{} Changed: {}", used, total, changed);
@@ -139,33 +117,7 @@ impl Renderer {
         // Create encoder that will build command buffer for us
         let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"),});
 
-        // Create render pass
+        self.raytrace_pass.render(&mut encoder, &mut self.buffers, &frame.view);
-        {
-            let ops = wgpu::Operations {
-                // Clear command
-                load: wgpu::LoadOp::Clear(wgpu::Color {r: 0.1, g: 0.2, b: 0.3, a: 1.0,}),
-                // Store command
-                store: true,
-            };
-
-            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { 
-                label: Some("Render Pass"),
-                color_attachments: &[ wgpu::RenderPassColorAttachmentDescriptor { attachment: &frame.view, resolve_target: None, ops } ],
-                depth_stencil_attachment: None,
-            });
-
-            // Data
-            render_pass.set_pipeline(&self.raytrace.pipeline);
-            render_pass.set_bind_group(0, &self.uniform_buffer.bind_group, &[]);
-            render_pass.set_bind_group(1, &self.node_buffer.bind_group, &[]);
-            render_pass.set_bind_group(2, &self.brick_buffer.bind_group, &[]);
-            render_pass.set_bind_group(3, &self.material_buffer.bind_group, &[]);
-            // Vertices and indices
-            render_pass.set_vertex_buffer(0, self.raster_buffer.vertex_buffer.slice(..));
-            render_pass.set_index_buffer(self.raster_buffer.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
-            render_pass.draw_indexed(0..self.raster_buffer.index_len, 0, 0..1);
-
-        }
 
         // Submit encoder (command buffer)
         self.queue.submit(std::iter::once(encoder.finish()));
@@ -174,6 +126,8 @@ impl Renderer {
         Ok(())
     }
 
+//TODO: Move things below to a separate struct, maybe trait?
+
     /*
     *   Create or update brick at given location
     */
@@ -189,7 +143,7 @@ impl Renderer {
     pub fn block_set_voxel(&mut self, brick_id:usize, x: usize, y: usize, z:usize, value: u8) {
         let voxel_id = x + buffers::BLOCK_SIZE * (y + buffers::BLOCK_SIZE * z);
         let brick_offset = brick_id * buffers::BLOCK_LEN;
-        self.brick_buffer.blocks[brick_offset + voxel_id] = value;
+        self.buffers.brick_buffer.blocks[brick_offset + voxel_id] = value;
     }
 
     /*
@@ -198,12 +152,12 @@ impl Renderer {
     pub fn block_get_id(&mut self, pos: Point3<usize>, apply: bool) -> usize {
         // Get node
         let node_idx = pos.x + buffers::NODE_TEX_SIZE * (pos.y + buffers::NODE_TEX_SIZE * pos.z);
-        let mut node_value = self.node_buffer.nodes[node_idx];
+        let mut node_value = self.buffers.node_buffer.nodes[node_idx];
 
         // Use new brick if neccesary
         if node_value == 0 { 
-            node_value = self.brick_buffer.next_block(apply) as u32; 
+            node_value = self.buffers.brick_buffer.next_block(apply) as u32; 
-            if apply { self.node_buffer.nodes[node_idx] = node_value; }
+            if apply { self.buffers.node_buffer.nodes[node_idx] = node_value; }
         }
 
         // Get brick id from node value

src/renderer/passes/raytrace.rs

@@ -1,24 +1,21 @@
-use crate::renderer::buffers::Vertex;
+use crate::renderer::buffers::{Vertex, Buffers};
-
 
 pub struct RaytracePass {
     pub pipeline: wgpu::RenderPipeline
 }
 
 impl RaytracePass {
-    pub fn new(device: &wgpu::Device, swapchain_desc: &wgpu::SwapChainDescriptor, bind_group_layouts: &[&wgpu::BindGroupLayout]) -> Self {
+    pub fn new(device: &wgpu::Device, swapchain_desc: &wgpu::SwapChainDescriptor, buffers: &Buffers) -> Self {
-        // Pipeline stuff
+
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        // Vertex shader
-            label: Some("Render Pipeline Layout"),
+        let vert_state = wgpu::VertexState {
-            bind_group_layouts: bind_group_layouts,
-            push_constant_ranges: &[],
-        });
-        let vert_state = wgpu::VertexState { //vert
             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
+
+        // Fragment shader
+        let frag_state = wgpu::FragmentState {
             module: &device.create_shader_module(&wgpu::include_spirv!("..\\..\\shaders\\bin\\shader.frag.spv")),
             entry_point: "main",
             targets: &[wgpu::ColorTargetState {
@@ -28,18 +25,21 @@ impl RaytracePass {
                 write_mask: wgpu::ColorWrite::ALL,
             }],
         };
-        let prim_state = wgpu::PrimitiveState { // primitive
+
-            topology: wgpu::PrimitiveTopology::TriangleList,
+        // Bind group layouts
-            strip_index_format: None,
+        let bind_group_layouts = [
-            front_face: wgpu::FrontFace::Cw,
+            &buffers.uniform_buffer.bind_layout, 
-            cull_mode: wgpu::CullMode::Back,
+            &buffers.node_buffer.bind_layout, 
-            polygon_mode: wgpu::PolygonMode::Fill,
+            &buffers.brick_buffer.bind_layout,
-        };
+            &buffers.material_buffer.bind_layout
-        let multisample_state = wgpu::MultisampleState { // multisample
+        ];
-            count: 1,
+
-            mask: !0,
+        // Pipeline layout
-            alpha_to_coverage_enabled: false,
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-        };
+            label: Some("Render Pipeline Layout"),
+            bind_group_layouts: &bind_group_layouts,
+            push_constant_ranges: &[],
+        });
 
         // Create pipeline
         let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
@@ -47,11 +47,48 @@ impl RaytracePass {
             layout: Some(&pipeline_layout),
             vertex: vert_state, 
             fragment: Some(frag_state),
-            primitive: prim_state,
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleList,
+                strip_index_format: None,
+                front_face: wgpu::FrontFace::Cw,
+                cull_mode: wgpu::CullMode::Back,
+                polygon_mode: wgpu::PolygonMode::Fill,
+            },
             depth_stencil: None,
-            multisample: multisample_state,
+            multisample: wgpu::MultisampleState { count: 1, mask: !0, alpha_to_coverage_enabled: false }
         });
 
         Self { pipeline }
     }
+
+    pub fn render(&mut self, encoder: &mut wgpu::CommandEncoder, buffers: &mut Buffers, attachment: &wgpu::TextureView) {
+        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { 
+            label: Some("Render Pass"),
+            color_attachments: &[ 
+                wgpu::RenderPassColorAttachmentDescriptor { 
+                    attachment: attachment, 
+                    resolve_target: None, 
+                    ops: wgpu::Operations {
+                        // Clear and store
+                        load: wgpu::LoadOp::Clear(wgpu::Color {r: 0.1, g: 0.2, b: 0.3, a: 1.0,}),
+                        store: true,
+                    }
+                }],
+            depth_stencil_attachment: None,
+        });
+
+        // Pipeline
+        render_pass.set_pipeline(&self.pipeline);
+
+        // Vertices and indices
+        render_pass.set_vertex_buffer(0, buffers.raster_buffer.vertex_buffer.slice(..));
+        render_pass.set_index_buffer(buffers.raster_buffer.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
+        render_pass.draw_indexed(0..buffers.raster_buffer.index_len, 0, 0..1);
+
+        // Bind groups
+        render_pass.set_bind_group(0, &buffers.uniform_buffer.bind_group, &[]);
+        render_pass.set_bind_group(1, &buffers.node_buffer.bind_group, &[]);
+        render_pass.set_bind_group(2, &buffers.brick_buffer.bind_group, &[]);
+        render_pass.set_bind_group(3, &buffers.material_buffer.bind_group, &[]);
+    }
 }