moved buffer stuff to a separate module

src/renderer/buffers/mod.rs

@@ -0,0 +1,11 @@
+
+mod node_buffer;
+pub use node_buffer::NodeBuffer;
+
+mod uniform_buffer;
+pub use uniform_buffer::UniformBuffer;
+pub use uniform_buffer::UniformValues;
+
+mod raster_buffer;
+pub use raster_buffer::RasterBuffer;
+pub use raster_buffer::Vertex;

src/renderer/buffers/node_buffer.rs

@@ -0,0 +1,8 @@
+
+pub struct NodeBuffer {
+
+}
+
+impl NodeBuffer {
+
+}

src/renderer/buffers/raster_buffer.rs

@@ -0,0 +1,74 @@
+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 RasterBuffer {
+    pub vertex_buffer: wgpu::Buffer,
+    pub index_buffer: wgpu::Buffer,
+    pub index_len: u32
+}
+
+impl RasterBuffer {
+    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/buffers/uniform_buffer.rs

@@ -0,0 +1,80 @@
+use crate::renderer::camera::Camera;
+use cgmath::SquareMatrix;
+use wgpu::util::DeviceExt;
+
+#[repr(C)]
+#[derive(Default, Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct UniformValues {
+    view_inv: [[f32; 4]; 4],
+    proj_inv: [[f32; 4]; 4],
+    cam_pos: [f32; 3]
+}
+
+impl UniformValues {
+
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn update(&mut self, camera: &Camera) {
+        self.view_inv = camera.view_matrix().invert().unwrap().into();
+        self.proj_inv = camera.proj_matrix().invert().unwrap().into();
+        self.cam_pos = camera.position.into();
+    }
+}
+
+
+pub struct UniformBuffer {
+    pub values: UniformValues,
+    pub buffer: wgpu::Buffer,
+    pub bind_layout: wgpu::BindGroupLayout,
+    pub bind_group: wgpu::BindGroup,
+}
+
+impl UniformBuffer {
+    pub fn new(device: &wgpu::Device) -> Self {
+        // Create values
+        let values = UniformValues::new();
+
+        // Create buffer
+        let buffer = device.create_buffer_init(
+            &wgpu::util::BufferInitDescriptor {
+                label: Some("Uniform buffer"),
+                contents: bytemuck::cast_slice(&[values]),
+                usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
+            }
+        );
+
+        // Create bind group
+        let bind_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStage::FRAGMENT,
+                    ty: wgpu::BindingType::Buffer {
+                        ty: wgpu::BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: None,
+                    },
+                    count: None,
+                }
+            ],
+            label: Some("Uniform buffer layout"),
+        });
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &bind_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: buffer.as_entire_binding(),
+                }
+            ],
+            label: Some("Uniform buffer group"),
+        });
+
+        // Done
+        UniformBuffer { buffer, values, bind_layout, bind_group }
+    }
+}
+
+