removed vertex and index buffers, we are only rendering fullscreen

src/renderer/buffers/mod.rs

@@ -24,10 +24,6 @@ mod uniform;
 pub use uniform::Uniform;
 pub use uniform::UniformValues;
 
-mod raster;
-pub use raster::Raster;
-pub use raster::Vertex;
-
 mod materials;
 pub use materials::Materials;
 
@@ -35,7 +31,6 @@ pub use materials::Materials;
 
 pub struct Buffers {
     pub uniform_buffer: Uniform,
-    pub raster_buffer: Raster,
     pub node_buffer: Nodes,
     pub brick_buffer: Blocks,
     pub material_buffer: Materials
@@ -45,10 +40,9 @@ 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 }
+        Self { uniform_buffer, node_buffer, brick_buffer, material_buffer }
     }
 }

src/renderer/buffers/raster.rs

@@ -1,74 +0,0 @@
-use wgpu::util::DeviceExt;
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
-pub struct Vertex {
-    pub position: [f32; 3],
-    pub uv: [f32; 2],
-}
-
-impl Vertex {
-    pub fn desc<'a>() -> wgpu::VertexBufferLayout<'a> {
-        wgpu::VertexBufferLayout {
-            array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
-            step_mode: wgpu::InputStepMode::Vertex,
-            attributes: &[
-                // position
-                wgpu::VertexAttribute {
-                    offset: 0,
-                    shader_location: 0,
-                    format: wgpu::VertexFormat::Float3,
-                },
-                // color
-                wgpu::VertexAttribute {
-                    offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
-                    shader_location: 1,
-                    format: wgpu::VertexFormat::Float2,
-                }
-            ]
-        }
-    }
-}
-
-
-const VERTICES: &[Vertex] = &[
-    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] }, // top right
-    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] }, // bottom left
-];
-pub const INDICES: &[u16] = &[ 0, 1, 3, 3, 1, 2 ];
-
-
-pub struct Raster {
-    pub vertex_buffer: wgpu::Buffer,
-    pub index_buffer: wgpu::Buffer,
-    pub index_len: u32
-}
-
-impl Raster {
-    pub fn new(device: &wgpu::Device) -> Self {
-
-        // Create vertex buffer
-        let vertex_buffer = device.create_buffer_init(
-            &wgpu::util::BufferInitDescriptor {
-                label: Some("Vertex buffer"),
-                contents: bytemuck::cast_slice(VERTICES),
-                usage: wgpu::BufferUsage::VERTEX,
-            }
-        );
-
-        // Create index buffer
-        let index_buffer = device.create_buffer_init(
-            &wgpu::util::BufferInitDescriptor {
-                label: Some("Index buffer"),
-                contents: bytemuck::cast_slice(INDICES),
-                usage: wgpu::BufferUsage::INDEX,
-            }
-        );
-        let index_len = INDICES.len() as u32;
-        
-        // Done
-        Self { vertex_buffer, index_buffer, index_len }
-    }
-}

src/renderer/mod.rs

@@ -2,7 +2,7 @@ use winit::{window::Window, dpi::PhysicalSize};
 use cgmath::{Point3};
 
 pub mod buffers; 
-use buffers::{Buffers, Nodes, Blocks, Uniform, Raster, Materials};
+use buffers::Buffers;
 
 mod passes;
 use passes::RaytracePass;

src/renderer/passes/postprocess.rs

@@ -0,0 +1,9 @@
+pub struct PostprocessPass {
+    pub pipeline: wgpu::RenderPipeline
+}
+
+impl PostprocessPass {
+    pub fn new(device: &wgpu::Device, swapchain_desc: &wgpu::SwapChainDescriptor) -> Self {
+        
+    }
+}

src/renderer/passes/raytrace.rs

@@ -1,4 +1,4 @@
-use crate::renderer::buffers::{Vertex, Buffers};
+use crate::renderer::buffers::Buffers;
 
 pub struct RaytracePass {
     pub pipeline: wgpu::RenderPipeline
@@ -11,7 +11,7 @@ impl RaytracePass {
         let vert_state = wgpu::VertexState {
             module: &device.create_shader_module(&wgpu::include_spirv!("..\\..\\shaders\\bin\\shader.vert.spv")),
             entry_point: "main",
-            buffers: &[Vertex::desc()],
+            buffers: &[],
         };
 
         // Fragment shader
@@ -80,15 +80,16 @@ impl RaytracePass {
         // 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, &[]);
+
+        // Vertices and indices
+        render_pass.draw(0..6, 0..1); // 3.
+        // 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);
     }
 }

src/shaders/shader.vert

@@ -1,11 +1,19 @@
 #version 450
 
-layout(location=0) in vec3 in_position;
-layout(location=1) in vec2 in_uv;
 layout(location=0) out vec2 vert_uv;
 
+const vec2 positions[6] = vec2[6](
+    vec2(-1.0, 1.0),
+    vec2( 1.0, 1.0),
+    vec2( 1.0,-1.0),
+
+    vec2(-1.0, 1.0),
+    vec2( 1.0,-1.0),
+    vec2(-1.0,-1.0)
+);
+
 void main() 
 {
-    vert_uv = in_uv;
+    vert_uv = positions[gl_VertexIndex];
-    gl_Position = vec4(in_position, 1.0);
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
 }