Code cleanup

src/camera.rs

@@ -1,4 +1,4 @@
-use glam::{Mat4, Quat, Vec2, Vec3};
+use glam::{Mat4, Quat, Vec3};
 use std::f32::consts::LN_2;
 use std::time::Instant;
 use winit::event::{ElementState, VirtualKeyCode};
@@ -130,7 +130,7 @@ impl Flycam {
         self.update_kinematic(dt);
     }
 
-    fn update_orientation(&mut self, dt: f32) {
+    fn update_orientation(&mut self, _dt: f32) {
         let t = self.turn_sensitivity;
 
         self.euler_x -= t * self.mouse_dy; // mouse +y = 2D plane down  = look down         = 3d space -x

src/mesh.rs

@@ -484,7 +484,7 @@ impl MeshPool {
         };
 
         // TODO: keep track of loaded/unloaded meshes
-        let on_complete = |target| {};
+        let on_complete = |_target| {};
 
         self.staging.flush(commands, get_dst, on_complete);
     }

src/pass.rs

@@ -52,16 +52,21 @@ pub trait RenderPass: Send + Sync {
     /// data to the GPU.
     fn begin_frame(&self, data: &mut Self::FrameData, phases: &mut Vec<Phase>, queue: &wgpu::Queue);
 
-    fn record_commands(&self, data: PhaseData<&Self::FrameData>, cmds: &mut wgpu::CommandEncoder) {}
-
-    fn record_compute<'a>(
-        &'a self,
-        data: PhaseData<&'a Self::FrameData>,
-        cmds: &mut wgpu::ComputePass<'a>,
+    fn record_commands(
+        &self,
+        _data: PhaseData<&Self::FrameData>,
+        _cmds: &mut wgpu::CommandEncoder,
     ) {
     }
 
-    fn record_render(&self, data: PhaseData<&Self::FrameData>) -> Option<wgpu::RenderBundle> {
+    fn record_compute<'a>(
+        &'a self,
+        _data: PhaseData<&'a Self::FrameData>,
+        _cmds: &mut wgpu::ComputePass<'a>,
+    ) {
+    }
+
+    fn record_render(&self, _data: PhaseData<&Self::FrameData>) -> Option<wgpu::RenderBundle> {
         None
     }
 }

src/pass/debug.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::gpu::GpuVec;
 use crate::viewport::ViewportInfo;
 use crate::RenderLayouts;
 
@@ -25,11 +26,8 @@ impl Vertex {
 pub type Index = u32;
 
 pub struct FrameData {
-    vertex_capacity: usize,
-    vertices: wgpu::Buffer,
-    index_capacity: usize,
-    indices: wgpu::Buffer,
-    index_num: usize,
+    vertices: GpuVec<Vertex>,
+    indices: GpuVec<Index>,
 }
 
 pub struct DebugPass {
@@ -106,37 +104,31 @@ impl RenderPass for DebugPass {
     type FrameData = FrameData;
 
     fn create_frame_data(&self) -> FrameData {
-        let vertex_capacity = 1024 * 1024; // TODO resizable buffers
-        let vertices = self.device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("DebugPass Vertex Buffer"),
-            size: (vertex_capacity * std::mem::size_of::<Vertex>()) as wgpu::BufferAddress,
-            mapped_at_creation: false,
-            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
-        });
-
-        let index_capacity = 1024 * 1024; // TODO resizable buffers
-        let indices = self.device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("DebugPass Index Buffer"),
-            size: (index_capacity * std::mem::size_of::<Index>()) as wgpu::BufferAddress,
-            mapped_at_creation: false,
-            usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
-        });
-
-        let index_num = 0;
-
         FrameData {
-            vertex_capacity,
-            vertices,
-            index_capacity,
-            indices,
-            index_num,
+            vertices: GpuVec::new(
+                self.device.clone(),
+                wgpu::BufferUsages::VERTEX,
+                1024 * 1024,
+                Some("Debug Vertex Buffer".to_string()),
+                false,
+            ),
+            indices: GpuVec::new(
+                self.device.clone(),
+                wgpu::BufferUsages::INDEX,
+                1024 * 1024,
+                Some("Debug Index Buffer".to_string()),
+                false,
+            ),
         }
     }
 
     fn begin_frame(&self, data: &mut FrameData, phases: &mut Vec<Phase>, queue: &wgpu::Queue) {
         phases.push(Phase::Overlay);
 
-        let vertices = &[
+        data.vertices.clear();
+        data.indices.clear();
+
+        data.vertices.extend_from_slice(&[
             Vertex {
                 position: [0.0, 0.0, -1.0],
                 color: [1.0, 0.0, 0.0],
@@ -145,13 +137,12 @@ impl RenderPass for DebugPass {
                 position: [0.0, 0.0, 1.0],
                 color: [0.0, 0.0, 1.0],
             },
-        ];
-        queue.write_buffer(&data.vertices, 0, bytemuck::cast_slice(vertices));
+        ]);
 
-        let indices = &[0u32, 1u32];
-        queue.write_buffer(&data.indices, 0, bytemuck::cast_slice(indices));
+        data.indices.extend_from_slice(&[0u32, 1u32]);
 
-        data.index_num = 2;
+        data.vertices.write(queue);
+        data.indices.write(queue);
     }
 
     fn record_render(&self, data: PhaseData<&FrameData>) -> Option<wgpu::RenderBundle> {
@@ -171,12 +162,15 @@ impl RenderPass for DebugPass {
                     multiview: None,
                 });
 
+        let vertices = &data.frame_data.vertices;
+        let indices = &data.frame_data.indices;
+
         cmds.set_pipeline(&self.pipeline);
         cmds.set_bind_group(0, data.bind_viewport, &[]);
-        cmds.set_vertex_buffer(0, data.frame_data.vertices.slice(..));
-        cmds.set_index_buffer(data.frame_data.indices.slice(..), wgpu::IndexFormat::Uint32);
+        cmds.set_vertex_buffer(0, vertices.as_ref().slice(..));
+        cmds.set_index_buffer(indices.as_ref().slice(..), wgpu::IndexFormat::Uint32);
 
-        let index_range = 0..(data.frame_data.index_num as u32);
+        let index_range = 0..(indices.len() as u32);
         cmds.draw_indexed(index_range, 0, 0..1);
 
         Some(cmds.finish(&wgpu::RenderBundleDescriptor::default()))

src/shader.rs

@@ -103,8 +103,8 @@ impl ShaderStore {
 }
 
 pub struct ShaderInfo {
-    handle: ShaderHandle,
-    dependencies: BTreeSet<PathBuf>,
+    pub handle: ShaderHandle,
+    pub dependencies: BTreeSet<PathBuf>,
 }
 
 pub struct ShaderLoader<'a> {