Cleaned up namespaces re: PR comments.

13 files changed, 158 insertions, 161 deletions

diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs
index f7fe9235..fff14910 100644
--- a/glow/src/triangle.rs
+++ b/glow/src/triangle.rs
@@ -4,11 +4,9 @@ mod solid;
 
 use crate::{program, Transformation};
 use glow::HasContext;
-use iced_graphics::layer::{mesh, mesh::attribute_count_of, Mesh};
+use iced_graphics::layer::{mesh, Mesh};
 use std::marker::PhantomData;
 
-use crate::triangle::gradient::GradientProgram;
-use crate::triangle::solid::SolidProgram;
 pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
 
 #[derive(Debug)]
@@ -16,13 +14,13 @@ pub(crate) struct Pipeline {
     vertex_array: <glow::Context as HasContext>::VertexArray,
     vertices: Buffer<Vertex2D>,
     indices: Buffer<u32>,
-    programs: TrianglePrograms,
+    programs: ProgramList,
 }
 
 #[derive(Debug)]
-struct TrianglePrograms {
-    solid: SolidProgram,
-    gradient: GradientProgram,
+struct ProgramList {
+    solid: solid::Program,
+    gradient: gradient::Program,
 }
 
 impl Pipeline {
@@ -65,9 +63,9 @@ impl Pipeline {
             vertex_array,
             vertices,
             indices,
-            programs: TrianglePrograms {
-                solid: SolidProgram::new(gl, shader_version),
-                gradient: GradientProgram::new(gl, shader_version),
+            programs: ProgramList {
+                solid: solid::Program::new(gl, shader_version),
+                gradient: gradient::Program::new(gl, shader_version),
             },
         }
     }
@@ -87,7 +85,7 @@ impl Pipeline {
         }
 
         //count the total amount of vertices & indices we need to handle
-        let (total_vertices, total_indices) = attribute_count_of(meshes);
+        let (total_vertices, total_indices) = mesh::attribute_count_of(meshes);
 
         // Then we ensure the current attribute buffers are big enough, resizing if necessary
         unsafe {
@@ -171,7 +169,7 @@ impl Pipeline {
 
 /// A simple shader program. Uses [`triangle.vert`] for its vertex shader and only binds position
 /// attribute location.
-pub(super) fn simple_triangle_program(
+pub(super) fn program(
     gl: &glow::Context,
     shader_version: &program::Version,
     fragment_shader: &'static str,
diff --git a/glow/src/triangle/gradient.rs b/glow/src/triangle/gradient.rs
index a8bb5ec5..6bca44ee 100644
--- a/glow/src/triangle/gradient.rs
+++ b/glow/src/triangle/gradient.rs
@@ -1,25 +1,25 @@
 use crate::program::Version;
-use crate::triangle::{set_transform, simple_triangle_program};
+use crate::triangle;
 use glow::{Context, HasContext, NativeProgram};
 use iced_graphics::gradient::Gradient;
 use iced_graphics::gradient::Linear;
 use iced_graphics::Transformation;
 
 #[derive(Debug)]
-pub struct GradientProgram {
+pub struct Program {
     pub program: <Context as HasContext>::Program,
-    pub uniform_data: GradientUniformData,
+    pub uniform_data: UniformData,
 }
 
 #[derive(Debug)]
-pub struct GradientUniformData {
+pub struct UniformData {
     gradient: Gradient,
     transform: Transformation,
-    uniform_locations: GradientUniformLocations,
+    uniform_locations: UniformLocations,
 }
 
 #[derive(Debug)]
-struct GradientUniformLocations {
+struct UniformLocations {
     gradient_direction_location: <Context as HasContext>::UniformLocation,
     color_stops_size_location: <Context as HasContext>::UniformLocation,
     //currently the maximum number of stops is 16 due to lack of SSBO in GL2.1
@@ -27,9 +27,9 @@ struct GradientUniformLocations {
     transform_location: <Context as HasContext>::UniformLocation,
 }
 
-impl GradientProgram {
+impl Program {
     pub fn new(gl: &Context, shader_version: &Version) -> Self {
-        let program = simple_triangle_program(
+        let program = triangle::program(
             gl,
             shader_version,
             include_str!("../shader/common/gradient.frag"),
@@ -37,7 +37,7 @@ impl GradientProgram {
 
         Self {
             program,
-            uniform_data: GradientUniformData::new(gl, program),
+            uniform_data: UniformData::new(gl, program),
         }
     }
 
@@ -48,7 +48,7 @@ impl GradientProgram {
         transform: &Transformation,
     ) {
         if transform != &self.uniform_data.transform {
-            set_transform(
+            triangle::set_transform(
                 gl,
                 self.uniform_data.uniform_locations.transform_location,
                 *transform,
@@ -117,12 +117,11 @@ impl GradientProgram {
         transform: &Transformation,
     ) {
         unsafe { gl.use_program(Some(self.program)) }
-
         self.write_uniforms(gl, gradient, transform);
     }
 }
 
-impl GradientUniformData {
+impl UniformData {
     fn new(gl: &Context, program: NativeProgram) -> Self {
         let gradient_direction_location =
             unsafe { gl.get_uniform_location(program, "gradient_direction") }
@@ -141,14 +140,14 @@ impl GradientUniformData {
             unsafe { gl.get_uniform_location(program, "u_Transform") }
                 .expect("Gradient - Get u_Transform.");
 
-        GradientUniformData {
+        Self {
             gradient: Gradient::Linear(Linear {
                 start: Default::default(),
                 end: Default::default(),
                 color_stops: vec![],
             }),
             transform: Transformation::identity(),
-            uniform_locations: GradientUniformLocations {
+            uniform_locations: UniformLocations {
                 gradient_direction_location,
                 color_stops_size_location,
                 color_stops_location,
diff --git a/glow/src/triangle/solid.rs b/glow/src/triangle/solid.rs
index 5ba7f91c..311e3704 100644
--- a/glow/src/triangle/solid.rs
+++ b/glow/src/triangle/solid.rs
@@ -1,24 +1,23 @@
 use crate::program::Version;
-use crate::triangle::{set_transform, simple_triangle_program};
-use crate::Color;
+use crate::{triangle, Color};
 use glow::{Context, HasContext, NativeProgram};
 use iced_graphics::Transformation;
 
 #[derive(Debug)]
-pub struct SolidProgram {
+pub struct Program {
     program: <Context as HasContext>::Program,
-    uniform_data: SolidUniformData,
+    uniform_data: UniformData,
 }
 
 #[derive(Debug)]
-struct SolidUniformData {
+struct UniformData {
     pub color: Color,
     pub color_location: <Context as HasContext>::UniformLocation,
     pub transform: Transformation,
     pub transform_location: <Context as HasContext>::UniformLocation,
 }
 
-impl SolidUniformData {
+impl UniformData {
     fn new(gl: &Context, program: NativeProgram) -> Self {
         Self {
             color: Color::TRANSPARENT,
@@ -35,9 +34,9 @@ impl SolidUniformData {
     }
 }
 
-impl SolidProgram {
+impl Program {
     pub fn new(gl: &Context, shader_version: &Version) -> Self {
-        let program = simple_triangle_program(
+        let program = triangle::program(
             gl,
             shader_version,
             include_str!("../shader/common/triangle.frag"),
@@ -45,7 +44,7 @@ impl SolidProgram {
 
         Self {
             program,
-            uniform_data: SolidUniformData::new(gl, program),
+            uniform_data: UniformData::new(gl, program),
         }
     }
 
@@ -56,7 +55,11 @@ impl SolidProgram {
         transform: &Transformation,
     ) {
         if transform != &self.uniform_data.transform {
-            set_transform(gl, self.uniform_data.transform_location, *transform)
+            triangle::set_transform(
+                gl,
+                self.uniform_data.transform_location,
+                *transform,
+            )
         }
 
         if color != &self.uniform_data.color {
diff --git a/graphics/src/gradient/linear.rs b/graphics/src/gradient/linear.rs
index a9cfd55d..020c65db 100644
--- a/graphics/src/gradient/linear.rs
+++ b/graphics/src/gradient/linear.rs
@@ -134,10 +134,13 @@ impl Builder {
     ///
     /// `offset` must be between `0.0` and `1.0` or the gradient cannot be built.
     ///
-    /// Note: when using the [Glow] backend, any color stop added after the 16th
+    /// Note: when using the [`glow`] backend, any color stop added after the 16th
     /// will not be displayed.
     ///
-    /// On [backend::Wgpu] backend this limitation does not exist (technical limit is 524,288 stops).
+    /// On the [`wgpu`] backend this limitation does not exist (technical limit is 524,288 stops).
+    ///
+    /// [`glow`]: https://docs.rs/iced_glow
+    /// [`wgpu`]: https://docs.rs/iced_wgpu
     pub fn add_stop(mut self, offset: f32, color: Color) -> Self {
         if offset.is_finite() && (0.0..=1.0).contains(&offset) {
             match self.stops.binary_search_by(|stop| {
diff --git a/graphics/src/triangle.rs b/graphics/src/triangle.rs
index f019d55d..39359cfb 100644
--- a/graphics/src/triangle.rs
+++ b/graphics/src/triangle.rs
@@ -7,6 +7,8 @@ pub struct Mesh2D {
     /// The vertices of the mesh
     pub vertices: Vec<Vertex2D>,
     /// The list of vertex indices that defines the triangles of the mesh.
+    ///
+    /// Therefore, this list should always have a length that is a multiple of 3.
     pub indices: Vec<u32>,
 }
 
diff --git a/wgpu/src/buffers.rs b/wgpu/src/buffers.rs
index 6b9f487c..dc9fc6e2 100644
--- a/wgpu/src/buffers.rs
+++ b/wgpu/src/buffers.rs
@@ -56,7 +56,7 @@ impl<T: Pod + Zeroable> StaticBuffer<T> {
 
     /// Returns whether or not the buffer needs to be recreated. This can happen whenever mesh data
     /// changes & a redraw is requested.
-    pub fn recreate_if_needed(
+    pub fn resize(
         &mut self,
         device: &wgpu::Device,
         new_count: usize,
diff --git a/wgpu/src/buffers/dynamic.rs b/wgpu/src/buffers/dynamic.rs
index dc30c56f..63955b6e 100644
--- a/wgpu/src/buffers/dynamic.rs
+++ b/wgpu/src/buffers/dynamic.rs
@@ -4,23 +4,23 @@ use encase::ShaderType;
 use std::marker::PhantomData;
 
 // Currently supported dynamic buffers.
-enum DynamicBufferType {
+enum BufferType {
     Uniform(encase::DynamicUniformBuffer<Vec<u8>>),
     Storage(encase::DynamicStorageBuffer<Vec<u8>>),
 }
 
-impl DynamicBufferType {
+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 {
-            DynamicBufferType::Uniform(buf) => buf
+            BufferType::Uniform(buf) => buf
                 .write(value)
                 .expect("Error when writing to dynamic uniform buffer.")
                 as u32,
-            DynamicBufferType::Storage(buf) => buf
+            BufferType::Storage(buf) => buf
                 .write(value)
                 .expect("Error when writing to dynamic storage buffer.")
                 as u32,
@@ -30,19 +30,19 @@ impl DynamicBufferType {
     /// Returns bytearray of aligned CPU buffer.
     pub(super) fn get_ref(&self) -> &Vec<u8> {
         match self {
-            DynamicBufferType::Uniform(buf) => buf.as_ref(),
-            DynamicBufferType::Storage(buf) => buf.as_ref(),
+            BufferType::Uniform(buf) => buf.as_ref(),
+            BufferType::Storage(buf) => buf.as_ref(),
         }
     }
 
     /// Resets the CPU buffer.
     pub(super) fn clear(&mut self) {
         match self {
-            DynamicBufferType::Uniform(buf) => {
+            BufferType::Uniform(buf) => {
                 buf.as_mut().clear();
                 buf.set_offset(0);
             }
-            DynamicBufferType::Storage(buf) => {
+            BufferType::Storage(buf) => {
                 buf.as_mut().clear();
                 buf.set_offset(0);
             }
@@ -51,21 +51,21 @@ impl DynamicBufferType {
 }
 
 /// A dynamic buffer is any type of buffer which does not have a static offset.
-pub(crate) struct DynamicBuffer<T: ShaderType> {
+pub(crate) struct Buffer<T: ShaderType> {
     offsets: Vec<wgpu::DynamicOffset>,
-    cpu: DynamicBufferType,
+    cpu: BufferType,
     gpu: wgpu::Buffer,
     label: &'static str,
     size: u64,
     _data: PhantomData<T>,
 }
 
-impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
+impl<T: ShaderType + WriteInto> Buffer<T> {
     /// Creates a new dynamic uniform buffer.
     pub fn uniform(device: &wgpu::Device, label: &'static str) -> Self {
-        DynamicBuffer::new(
+        Buffer::new(
             device,
-            DynamicBufferType::Uniform(encase::DynamicUniformBuffer::new(
+            BufferType::Uniform(encase::DynamicUniformBuffer::new(
                 Vec::new(),
             )),
             label,
@@ -75,9 +75,9 @@ impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
 
     /// Creates a new dynamic storage buffer.
     pub fn storage(device: &wgpu::Device, label: &'static str) -> Self {
-        DynamicBuffer::new(
+        Buffer::new(
             device,
-            DynamicBufferType::Storage(encase::DynamicStorageBuffer::new(
+            BufferType::Storage(encase::DynamicStorageBuffer::new(
                 Vec::new(),
             )),
             label,
@@ -87,7 +87,7 @@ impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
 
     fn new(
         device: &wgpu::Device,
-        dynamic_buffer_type: DynamicBufferType,
+        dynamic_buffer_type: BufferType,
         label: &'static str,
         usage: wgpu::BufferUsages,
     ) -> Self {
@@ -96,7 +96,7 @@ impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
         Self {
             offsets: Vec::new(),
             cpu: dynamic_buffer_type,
-            gpu: DynamicBuffer::<T>::create_gpu_buffer(
+            gpu: Buffer::<T>::create_gpu_buffer(
                 device,
                 label,
                 usage,
@@ -139,15 +139,15 @@ impl<T: ShaderType + WriteInto> DynamicBuffer<T> {
 
         if self.size < new_size {
             let usages = match self.cpu {
-                DynamicBufferType::Uniform(_) => {
+                BufferType::Uniform(_) => {
                     wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST
                 }
-                DynamicBufferType::Storage(_) => {
+                BufferType::Storage(_) => {
                     wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST
                 }
             };
 
-            self.gpu = DynamicBuffer::<T>::create_gpu_buffer(
+            self.gpu = Buffer::<T>::create_gpu_buffer(
                 device, self.label, usages, new_size,
             );
             self.size = new_size;
diff --git a/wgpu/src/shader/triangle_gradient.wgsl b/wgpu/src/shader/gradient.wgsl
index 03ba9d88..63825aec 100644
--- a/wgpu/src/shader/triangle_gradient.wgsl
+++ b/wgpu/src/shader/gradient.wgsl
@@ -1,4 +1,4 @@
-struct GradientUniforms {
+struct Uniforms {
     transform: mat4x4<f32>,
     //xy = start, wz = end
     position: vec4<f32>,
@@ -12,7 +12,7 @@ struct Stop {
 };
 
 @group(0) @binding(0)
-var<uniform> uniforms: GradientUniforms;
+var<uniform> uniforms: Uniforms;
 
 @group(0) @binding(1)
 var<storage, read> color_stops: array<Stop>;
@@ -33,7 +33,7 @@ fn vs_main(@location(0) input: vec2<f32>) -> VertexOutput {
 
 //TODO: rewrite without branching
 @fragment
-fn fs_gradient(input: VertexOutput) -> @location(0) vec4<f32> {
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
     let start = uniforms.position.xy;
     let end = uniforms.position.zw;
     let start_stop = uniforms.stop_range.x;
diff --git a/wgpu/src/shader/solid.wgsl b/wgpu/src/shader/solid.wgsl
new file mode 100644
index 00000000..68a8fea3
--- /dev/null
+++ b/wgpu/src/shader/solid.wgsl
@@ -0,0 +1,17 @@
+struct Uniforms {
+    transform: mat4x4<f32>,
+    color: vec4<f32>
+}
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+@vertex
+fn vs_main(@location(0) input: vec2<f32>) -> @builtin(position) vec4<f32> {
+    return uniforms.transform * vec4<f32>(input.xy, 0.0, 1.0);
+}
+
+@fragment
+fn fs_main() -> @location(0) vec4<f32> {
+    return uniforms.color;
+}
diff --git a/wgpu/src/shader/triangle_solid.wgsl b/wgpu/src/shader/triangle_solid.wgsl
deleted file mode 100644
index 9eb2df24..00000000
--- a/wgpu/src/shader/triangle_solid.wgsl
+++ /dev/null
@@ -1,17 +0,0 @@
-struct SolidUniforms {
-    transform: mat4x4<f32>,
-    color: vec4<f32>
-}
-
-@group(0) @binding(0)
-var<uniform> solid_uniforms: SolidUniforms;
-
-@vertex
-fn vs_main(@location(0) input: vec2<f32>) -> @builtin(position) vec4<f32> {
-    return solid_uniforms.transform * vec4<f32>(input.xy, 0.0, 1.0);
-}
-
-@fragment
-fn fs_solid() -> @location(0) vec4<f32> {
-    return solid_uniforms.color;
-}
diff --git a/wgpu/src/triangle.rs b/wgpu/src/triangle.rs
index feca72dc..0956c57d 100644
--- a/wgpu/src/triangle.rs
+++ b/wgpu/src/triangle.rs
@@ -3,12 +3,10 @@ use crate::{settings, Transformation};
 use core::fmt;
 use std::fmt::Formatter;
 
-use iced_graphics::layer::{Mesh, mesh, mesh::attribute_count_of};
+use iced_graphics::layer::{Mesh, mesh};
 use iced_graphics::Size;
 
 use crate::buffers::StaticBuffer;
-use crate::triangle::gradient::GradientPipeline;
-use crate::triangle::solid::SolidPipeline;
 pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
 
 mod solid;
@@ -22,22 +20,22 @@ pub(crate) struct Pipeline {
     vertex_buffer: StaticBuffer<Vertex2D>,
     index_buffer: StaticBuffer<u32>,
     index_strides: Vec<u32>,
-    pipelines: TrianglePipelines,
+    pipelines: PipelineList,
 }
 
 /// Supported triangle pipelines for different fills.
-pub(crate) struct TrianglePipelines {
-    solid: SolidPipeline,
-    gradient: GradientPipeline,
+pub(crate) struct PipelineList {
+    solid: solid::Pipeline,
+    gradient: gradient::Pipeline,
 }
 
-impl fmt::Debug for TrianglePipelines {
+impl fmt::Debug for PipelineList {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.debug_struct("TrianglePipelines").finish()
     }
 }
 
-impl TrianglePipelines {
+impl PipelineList {
     /// Resets each pipeline's buffers.
     fn clear(&mut self) {
         self.solid.buffer.clear();
@@ -78,9 +76,9 @@ impl Pipeline {
                 wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
             ),
             index_strides: Vec::new(),
-            pipelines: TrianglePipelines {
-                solid: SolidPipeline::new(device, format, antialiasing),
-                gradient: GradientPipeline::new(device, format, antialiasing),
+            pipelines: PipelineList {
+                solid: solid::Pipeline::new(device, format, antialiasing),
+                gradient: gradient::Pipeline::new(device, format, antialiasing),
             },
         }
     }
@@ -98,7 +96,7 @@ impl Pipeline {
         meshes: &[Mesh<'_>],
     ) {
         //count the total amount of vertices & indices we need to handle
-        let (total_vertices, total_indices) = attribute_count_of(meshes);
+        let (total_vertices, total_indices) = mesh::attribute_count_of(meshes);
 
         // Then we ensure the current attribute buffers are big enough, resizing if necessary.
 
@@ -107,8 +105,8 @@ impl Pipeline {
         //the majority of use cases. Therefore we will write GPU data every frame (for now).
         let _ = self
             .vertex_buffer
-            .recreate_if_needed(device, total_vertices);
-        let _ = self.index_buffer.recreate_if_needed(device, total_indices);
+            .resize(device, total_vertices);
+        let _ = self.index_buffer.resize(device, total_indices);
 
         //prepare dynamic buffers & data store for writing
         self.index_strides.clear();
@@ -258,7 +256,7 @@ fn vertex_buffer_layout<'a>() -> wgpu::VertexBufferLayout<'a> {
     }
 }
 
-fn default_fragment_target(
+fn fragment_target(
     texture_format: wgpu::TextureFormat,
 ) -> Option<wgpu::ColorTargetState> {
     Some(wgpu::ColorTargetState {
@@ -268,7 +266,7 @@ fn default_fragment_target(
     })
 }
 
-fn default_triangle_primitive_state() -> wgpu::PrimitiveState {
+fn primitive_state() -> wgpu::PrimitiveState {
     wgpu::PrimitiveState {
         topology: wgpu::PrimitiveTopology::TriangleList,
         front_face: wgpu::FrontFace::Cw,
@@ -276,7 +274,7 @@ fn default_triangle_primitive_state() -> wgpu::PrimitiveState {
     }
 }
 
-fn default_multisample_state(
+fn multisample_state(
     antialiasing: Option<settings::Antialiasing>,
 ) -> wgpu::MultisampleState {
     wgpu::MultisampleState {
diff --git a/wgpu/src/triangle/gradient.rs b/wgpu/src/triangle/gradient.rs
index 07551368..92c176af 100644
--- a/wgpu/src/triangle/gradient.rs
+++ b/wgpu/src/triangle/gradient.rs
@@ -1,28 +1,25 @@
-use crate::buffers::dynamic::DynamicBuffer;
+use crate::buffers::dynamic;
 use crate::settings;
-use crate::triangle::{
-    default_fragment_target, default_multisample_state,
-    default_triangle_primitive_state, vertex_buffer_layout,
-};
+use crate::triangle;
 use encase::ShaderType;
 use glam::{IVec4, Vec4};
 use iced_graphics::gradient::Gradient;
 use iced_graphics::Transformation;
 
-pub struct GradientPipeline {
+pub struct Pipeline {
     pipeline: wgpu::RenderPipeline,
-    pub(super) uniform_buffer: DynamicBuffer<GradientUniforms>,
-    pub(super) storage_buffer: DynamicBuffer<GradientStorage>,
+    pub(super) uniform_buffer: dynamic::Buffer<Uniforms>,
+    pub(super) storage_buffer: dynamic::Buffer<Storage>,
     color_stop_offset: i32,
     //Need to store these and then write them all at once
     //or else they will be padded to 256 and cause gaps in the storage buffer
-    color_stops_pending_write: GradientStorage,
+    color_stops_pending_write: Storage,
     bind_group_layout: wgpu::BindGroupLayout,
     bind_group: wgpu::BindGroup,
 }
 
 #[derive(Debug, ShaderType)]
-pub(super) struct GradientUniforms {
+pub(super) struct Uniforms {
     transform: glam::Mat4,
     //xy = start, zw = end
     direction: Vec4,
@@ -37,33 +34,33 @@ pub(super) struct ColorStop {
 }
 
 #[derive(ShaderType)]
-pub(super) struct GradientStorage {
+pub(super) struct Storage {
     #[size(runtime)]
     pub color_stops: Vec<ColorStop>,
 }
 
-impl GradientPipeline {
-    /// Creates a new [GradientPipeline] using `triangle_gradient.wgsl` shader.
+impl Pipeline {
+    /// Creates a new [GradientPipeline] using `gradient.wgsl` shader.
     pub(super) fn new(
         device: &wgpu::Device,
         format: wgpu::TextureFormat,
         antialiasing: Option<settings::Antialiasing>,
     ) -> Self {
-        let uniform_buffer = DynamicBuffer::uniform(
+        let uniform_buffer = dynamic::Buffer::uniform(
             device,
-            "iced_wgpu::triangle [GRADIENT] uniforms",
+            "iced_wgpu::triangle::gradient uniforms",
         );
 
         //Note: with a WASM target storage buffers are not supported. Will need to use UBOs & static
         // sized array (eg like the 32-sized array on OpenGL side right now) to make gradients work
-        let storage_buffer = DynamicBuffer::storage(
+        let storage_buffer = dynamic::Buffer::storage(
             device,
-            "iced_wgpu::triangle [GRADIENT] storage",
+            "iced_wgpu::triangle::gradient storage",
         );
 
         let bind_group_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                label: Some("iced_wgpu::triangle [GRADIENT] bind group layout"),
+                label: Some("iced_wgpu::triangle::gradient bind group layout"),
                 entries: &[
                     wgpu::BindGroupLayoutEntry {
                         binding: 0,
@@ -71,7 +68,7 @@ impl GradientPipeline {
                         ty: wgpu::BindingType::Buffer {
                             ty: wgpu::BufferBindingType::Uniform,
                             has_dynamic_offset: true,
-                            min_binding_size: Some(GradientUniforms::min_size()),
+                            min_binding_size: Some(Uniforms::min_size()),
                         },
                         count: None,
                     },
@@ -83,14 +80,14 @@ impl GradientPipeline {
                                 read_only: true,
                             },
                             has_dynamic_offset: false,
-                            min_binding_size: Some(GradientStorage::min_size()),
+                            min_binding_size: Some(Storage::min_size()),
                         },
                         count: None,
                     },
                 ],
             });
 
-        let bind_group = GradientPipeline::bind_group(
+        let bind_group = Pipeline::bind_group(
             device,
             uniform_buffer.raw(),
             storage_buffer.raw(),
@@ -99,7 +96,7 @@ impl GradientPipeline {
 
         let layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-                label: Some("iced_wgpu::triangle [GRADIENT] pipeline layout"),
+                label: Some("iced_wgpu::triangle::gradient pipeline layout"),
                 bind_group_layouts: &[&bind_group_layout],
                 push_constant_ranges: &[],
             });
@@ -107,30 +104,30 @@ impl GradientPipeline {
         let shader =
             device.create_shader_module(wgpu::ShaderModuleDescriptor {
                 label: Some(
-                    "iced_wgpu::triangle [GRADIENT] create shader module",
+                    "iced_wgpu::triangle::gradient create shader module",
                 ),
                 source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
-                    include_str!("../shader/triangle_gradient.wgsl"),
+                    include_str!("../shader/gradient.wgsl"),
                 )),
             });
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some("iced_wgpu::triangle [GRADIENT] pipeline"),
+                label: Some("iced_wgpu::triangle::gradient pipeline"),
                 layout: Some(&layout),
                 vertex: wgpu::VertexState {
                     module: &shader,
                     entry_point: "vs_main",
-                    buffers: &[vertex_buffer_layout()],
+                    buffers: &[triangle::vertex_buffer_layout()],
                 },
                 fragment: Some(wgpu::FragmentState {
                     module: &shader,
-                    entry_point: "fs_gradient",
-                    targets: &[default_fragment_target(format)],
+                    entry_point: "fs_main",
+                    targets: &[triangle::fragment_target(format)],
                 }),
-                primitive: default_triangle_primitive_state(),
+                primitive: triangle::primitive_state(),
                 depth_stencil: None,
-                multisample: default_multisample_state(antialiasing),
+                multisample: triangle::multisample_state(antialiasing),
                 multiview: None,
             });
 
@@ -139,7 +136,7 @@ impl GradientPipeline {
             uniform_buffer,
             storage_buffer,
             color_stop_offset: 0,
-            color_stops_pending_write: GradientStorage {
+            color_stops_pending_write: Storage {
                 color_stops: vec![],
             },
             bind_group_layout,
@@ -155,7 +152,7 @@ impl GradientPipeline {
                 let end_offset =
                     (linear.color_stops.len() as i32) + start_offset - 1;
 
-                self.uniform_buffer.push(&GradientUniforms {
+                self.uniform_buffer.push(&Uniforms {
                     transform: transform.into(),
                     direction: Vec4::new(
                         linear.start.x,
@@ -194,7 +191,7 @@ impl GradientPipeline {
         layout: &wgpu::BindGroupLayout,
     ) -> wgpu::BindGroup {
         device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("iced_wgpu::triangle [GRADIENT] bind group"),
+            label: Some("iced_wgpu::triangle::gradient bind group"),
             layout,
             entries: &[
                 wgpu::BindGroupEntry {
@@ -203,7 +200,7 @@ impl GradientPipeline {
                         wgpu::BufferBinding {
                             buffer: uniform_buffer,
                             offset: 0,
-                            size: Some(GradientUniforms::min_size()),
+                            size: Some(Uniforms::min_size()),
                         },
                     ),
                 },
@@ -232,7 +229,7 @@ impl GradientPipeline {
 
         if uniforms_resized || storage_resized {
             //recreate bind groups if any buffers were resized
-            self.bind_group = GradientPipeline::bind_group(
+            self.bind_group = Pipeline::bind_group(
                 device,
                 self.uniform_buffer.raw(),
                 self.storage_buffer.raw(),
diff --git a/wgpu/src/triangle/solid.rs b/wgpu/src/triangle/solid.rs
index abba4851..4000b059 100644
--- a/wgpu/src/triangle/solid.rs
+++ b/wgpu/src/triangle/solid.rs
@@ -1,27 +1,24 @@
-use crate::buffers::dynamic::DynamicBuffer;
-use crate::triangle::{
-    default_fragment_target, default_multisample_state,
-    default_triangle_primitive_state, vertex_buffer_layout,
-};
+use crate::buffers::dynamic;
+use crate::triangle;
 use crate::{settings, Color};
 use encase::ShaderType;
 use glam::Vec4;
 use iced_graphics::Transformation;
 
-pub struct SolidPipeline {
+pub struct Pipeline {
     pipeline: wgpu::RenderPipeline,
-    pub(super) buffer: DynamicBuffer<SolidUniforms>,
+    pub(super) buffer: dynamic::Buffer<Uniforms>,
     bind_group_layout: wgpu::BindGroupLayout,
     bind_group: wgpu::BindGroup,
 }
 
 #[derive(Debug, Clone, Copy, ShaderType)]
-pub(super) struct SolidUniforms {
+pub(super) struct Uniforms {
     transform: glam::Mat4,
     color: Vec4,
 }
 
-impl SolidUniforms {
+impl Uniforms {
     pub fn new(transform: Transformation, color: Color) -> Self {
         Self {
             transform: transform.into(),
@@ -30,34 +27,34 @@ impl SolidUniforms {
     }
 }
 
-impl SolidPipeline {
-    /// Creates a new [SolidPipeline] using `triangle_solid.wgsl` shader.
+impl Pipeline {
+    /// Creates a new [SolidPipeline] using `solid.wgsl` shader.
     pub fn new(
         device: &wgpu::Device,
         format: wgpu::TextureFormat,
         antialiasing: Option<settings::Antialiasing>,
     ) -> Self {
-        let buffer = DynamicBuffer::uniform(
+        let buffer = dynamic::Buffer::uniform(
             device,
-            "iced_wgpu::triangle [SOLID] uniforms",
+            "iced_wgpu::triangle::solid uniforms",
         );
 
         let bind_group_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                label: Some("iced_wgpu::triangle [SOLID] bind group layout"),
+                label: Some("iced_wgpu::triangle::solid bind group layout"),
                 entries: &[wgpu::BindGroupLayoutEntry {
                     binding: 0,
                     visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
                     ty: wgpu::BindingType::Buffer {
                         ty: wgpu::BufferBindingType::Uniform,
                         has_dynamic_offset: true,
-                        min_binding_size: Some(SolidUniforms::min_size()),
+                        min_binding_size: Some(Uniforms::min_size()),
                     },
                     count: None,
                 }],
             });
 
-        let bind_group = SolidPipeline::bind_group(
+        let bind_group = Pipeline::bind_group(
             device,
             &buffer.raw(),
             &bind_group_layout,
@@ -65,36 +62,36 @@ impl SolidPipeline {
 
         let layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-                label: Some("iced_wgpu::triangle [SOLID] pipeline layout"),
+                label: Some("iced_wgpu::triangle::solid pipeline layout"),
                 bind_group_layouts: &[&bind_group_layout],
                 push_constant_ranges: &[],
             });
 
         let shader =
             device.create_shader_module(wgpu::ShaderModuleDescriptor {
-                label: Some("iced_wgpu::triangle [SOLID] create shader module"),
+                label: Some("iced_wgpu::triangle::solid create shader module"),
                 source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
-                    include_str!("../shader/triangle_solid.wgsl"),
+                    include_str!("../shader/solid.wgsl"),
                 )),
             });
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some("iced_wgpu::triangle [SOLID] pipeline"),
+                label: Some("iced_wgpu::triangle::solid pipeline"),
                 layout: Some(&layout),
                 vertex: wgpu::VertexState {
                     module: &shader,
                     entry_point: "vs_main",
-                    buffers: &[vertex_buffer_layout()],
+                    buffers: &[triangle::vertex_buffer_layout()],
                 },
                 fragment: Some(wgpu::FragmentState {
                     module: &shader,
-                    entry_point: "fs_solid",
-                    targets: &[default_fragment_target(format)],
+                    entry_point: "fs_main",
+                    targets: &[triangle::fragment_target(format)],
                 }),
-                primitive: default_triangle_primitive_state(),
+                primitive: triangle::primitive_state(),
                 depth_stencil: None,
-                multisample: default_multisample_state(antialiasing),
+                multisample: triangle::multisample_state(antialiasing),
                 multiview: None,
             });
 
@@ -112,14 +109,14 @@ impl SolidPipeline {
         layout: &wgpu::BindGroupLayout,
     ) -> wgpu::BindGroup {
         device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("iced_wgpu::triangle [SOLID] bind group"),
+            label: Some("iced_wgpu::triangle::solid bind group"),
             layout,
             entries: &[wgpu::BindGroupEntry {
                 binding: 0,
                 resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
                     buffer,
                     offset: 0,
-                    size: Some(SolidUniforms::min_size()),
+                    size: Some(Uniforms::min_size()),
                 }),
             }],
         })
@@ -127,7 +124,7 @@ impl SolidPipeline {
 
     /// Pushes a new solid uniform to the CPU buffer.
     pub fn push(&mut self, transform: Transformation, color: &Color) {
-        self.buffer.push(&SolidUniforms::new(transform, *color));
+        self.buffer.push(&Uniforms::new(transform, *color));
     }
 
     /// Writes the contents of the solid CPU buffer to the GPU buffer, resizing the GPU buffer
@@ -141,7 +138,7 @@ impl SolidPipeline {
         let uniforms_resized = self.buffer.resize(device);
 
         if uniforms_resized {
-            self.bind_group = SolidPipeline::bind_group(
+            self.bind_group = Pipeline::bind_group(
                 device,
                 self.buffer.raw(),
                 &self.bind_group_layout,