Rename buffers module to buffer

... and move `StaticBuffer` to nested `static` module

wgpu/src/buffer.rs

@@ -0,0 +1,3 @@
+//! Utilities for buffer operations.
+pub mod dynamic;
+pub mod r#static;

wgpu/src/buffer/dynamic.rs

@@ -3,57 +3,10 @@ use encase::private::WriteInto;
 use encase::ShaderType;
 use std::marker::PhantomData;
 
-// Currently supported dynamic buffers.
-enum BufferType {
-    Uniform(encase::DynamicUniformBuffer<Vec<u8>>),
-    Storage(encase::DynamicStorageBuffer<Vec<u8>>),
-}
-
-impl BufferType {
-    /// Writes the current value to its CPU buffer with proper alignment.
-    pub(super) fn write<T: ShaderType + WriteInto>(
-        &mut self,
-        value: &T,
-    ) -> wgpu::DynamicOffset {
-        match self {
-            BufferType::Uniform(buf) => buf
-                .write(value)
-                .expect("Error when writing to dynamic uniform buffer.")
-                as u32,
-            BufferType::Storage(buf) => buf
-                .write(value)
-                .expect("Error when writing to dynamic storage buffer.")
-                as u32,
-        }
-    }
-
-    /// Returns bytearray of aligned CPU buffer.
-    pub(super) fn get_ref(&self) -> &Vec<u8> {
-        match self {
-            BufferType::Uniform(buf) => buf.as_ref(),
-            BufferType::Storage(buf) => buf.as_ref(),
-        }
-    }
-
-    /// Resets the CPU buffer.
-    pub(super) fn clear(&mut self) {
-        match self {
-            BufferType::Uniform(buf) => {
-                buf.as_mut().clear();
-                buf.set_offset(0);
-            }
-            BufferType::Storage(buf) => {
-                buf.as_mut().clear();
-                buf.set_offset(0);
-            }
-        }
-    }
-}
-
 /// A dynamic buffer is any type of buffer which does not have a static offset.
 pub(crate) struct Buffer<T: ShaderType> {
     offsets: Vec<wgpu::DynamicOffset>,
-    cpu: BufferType,
+    cpu: Internal,
     gpu: wgpu::Buffer,
     label: &'static str,
     size: u64,
@@ -65,7 +18,7 @@ impl<T: ShaderType + WriteInto> Buffer<T> {
     pub fn uniform(device: &wgpu::Device, label: &'static str) -> Self {
         Buffer::new(
             device,
-            BufferType::Uniform(encase::DynamicUniformBuffer::new(Vec::new())),
+            Internal::Uniform(encase::DynamicUniformBuffer::new(Vec::new())),
             label,
             wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
         )
@@ -75,7 +28,7 @@ impl<T: ShaderType + WriteInto> Buffer<T> {
     pub fn storage(device: &wgpu::Device, label: &'static str) -> Self {
         Buffer::new(
             device,
-            BufferType::Storage(encase::DynamicStorageBuffer::new(Vec::new())),
+            Internal::Storage(encase::DynamicStorageBuffer::new(Vec::new())),
             label,
             wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
         )
@@ -83,7 +36,7 @@ impl<T: ShaderType + WriteInto> Buffer<T> {
 
     fn new(
         device: &wgpu::Device,
-        dynamic_buffer_type: BufferType,
+        dynamic_buffer_type: Internal,
         label: &'static str,
         usage: wgpu::BufferUsages,
     ) -> Self {
@@ -135,10 +88,10 @@ impl<T: ShaderType + WriteInto> Buffer<T> {
 
         if self.size < new_size {
             let usages = match self.cpu {
-                BufferType::Uniform(_) => {
+                Internal::Uniform(_) => {
                     wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST
                 }
-                BufferType::Storage(_) => {
+                Internal::Storage(_) => {
                     wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST
                 }
             };
@@ -197,3 +150,50 @@ impl<T: ShaderType + WriteInto> Buffer<T> {
         self.cpu.clear();
     }
 }
+
+// Currently supported dynamic buffers.
+enum Internal {
+    Uniform(encase::DynamicUniformBuffer<Vec<u8>>),
+    Storage(encase::DynamicStorageBuffer<Vec<u8>>),
+}
+
+impl Internal {
+    /// Writes the current value to its CPU buffer with proper alignment.
+    pub(super) fn write<T: ShaderType + WriteInto>(
+        &mut self,
+        value: &T,
+    ) -> wgpu::DynamicOffset {
+        match self {
+            Internal::Uniform(buf) => buf
+                .write(value)
+                .expect("Error when writing to dynamic uniform buffer.")
+                as u32,
+            Internal::Storage(buf) => buf
+                .write(value)
+                .expect("Error when writing to dynamic storage buffer.")
+                as u32,
+        }
+    }
+
+    /// Returns bytearray of aligned CPU buffer.
+    pub(super) fn get_ref(&self) -> &Vec<u8> {
+        match self {
+            Internal::Uniform(buf) => buf.as_ref(),
+            Internal::Storage(buf) => buf.as_ref(),
+        }
+    }
+
+    /// Resets the CPU buffer.
+    pub(super) fn clear(&mut self) {
+        match self {
+            Internal::Uniform(buf) => {
+                buf.as_mut().clear();
+                buf.set_offset(0);
+            }
+            Internal::Storage(buf) => {
+                buf.as_mut().clear();
+                buf.set_offset(0);
+            }
+        }
+    }
+}

wgpu/src/buffer/static.rs

@@ -1,6 +1,3 @@
-//! Utilities for buffer operations.
-pub mod dynamic;
-
 use bytemuck::{Pod, Zeroable};
 use std::marker::PhantomData;
 use std::mem;
@@ -11,7 +8,7 @@ const DEFAULT_STATIC_BUFFER_COUNT: wgpu::BufferAddress = 128;
 /// A generic buffer struct useful for items which have no alignment requirements
 /// (e.g. Vertex, Index buffers) & no dynamic offsets.
 #[derive(Debug)]
-pub(crate) struct StaticBuffer<T> {
+pub(crate) struct Buffer<T> {
     //stored sequentially per mesh iteration; refers to the offset index in the GPU buffer
     offsets: Vec<wgpu::BufferAddress>,
     label: &'static str,
@@ -21,7 +18,7 @@ pub(crate) struct StaticBuffer<T> {
     _data: PhantomData<T>,
 }
 
-impl<T: Pod + Zeroable> StaticBuffer<T> {
+impl<T: Pod + Zeroable> Buffer<T> {
     /// Initialize a new static buffer.
     pub fn new(
         device: &wgpu::Device,

wgpu/src/lib.rs

@@ -43,7 +43,7 @@ pub mod triangle;
 pub mod window;
 
 mod backend;
-mod buffers;
+mod buffer;
 mod quad;
 mod text;
 

wgpu/src/triangle.rs

@@ -6,7 +6,7 @@ use std::fmt::Formatter;
 use iced_graphics::layer::{mesh, Mesh};
 use iced_graphics::Size;
 
-use crate::buffers::StaticBuffer;
+use crate::buffer::r#static::Buffer;
 pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
 
 mod gradient;
@@ -17,8 +17,8 @@ mod solid;
 #[derive(Debug)]
 pub(crate) struct Pipeline {
     blit: Option<msaa::Blit>,
-    vertex_buffer: StaticBuffer<Vertex2D>,
-    index_buffer: StaticBuffer<u32>,
+    vertex_buffer: Buffer<Vertex2D>,
+    index_buffer: Buffer<u32>,
     index_strides: Vec<u32>,
     pipelines: PipelineList,
 }
@@ -65,12 +65,12 @@ impl Pipeline {
     ) -> Pipeline {
         Pipeline {
             blit: antialiasing.map(|a| msaa::Blit::new(device, format, a)),
-            vertex_buffer: StaticBuffer::new(
+            vertex_buffer: Buffer::new(
                 device,
                 "iced_wgpu::triangle vertex buffer",
                 wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
             ),
-            index_buffer: StaticBuffer::new(
+            index_buffer: Buffer::new(
                 device,
                 "iced_wgpu::triangle vertex buffer",
                 wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,

wgpu/src/triangle/gradient.rs

@@ -1,4 +1,4 @@
-use crate::buffers::dynamic;
+use crate::buffer::dynamic;
 use crate::settings;
 use crate::triangle;
 use encase::ShaderType;

wgpu/src/triangle/solid.rs

@@ -1,4 +1,4 @@
-use crate::buffers::dynamic;
+use crate::buffer::dynamic;
 use crate::triangle;
 use crate::{settings, Color};
 use encase::ShaderType;