From c4565759e4294540f54a81e4d91ddea7a769d3d4 Mon Sep 17 00:00:00 2001 From: bungoboingo Date: Tue, 18 Oct 2022 15:18:37 -0700 Subject: Cleaned up namespaces re: PR comments. --- glow/src/triangle.rs | 22 ++++----- glow/src/triangle/gradient.rs | 27 +++++------ glow/src/triangle/solid.rs | 23 +++++---- graphics/src/gradient/linear.rs | 7 ++- graphics/src/triangle.rs | 2 + wgpu/src/buffers.rs | 2 +- wgpu/src/buffers/dynamic.rs | 40 ++++++++-------- wgpu/src/shader/gradient.wgsl | 88 ++++++++++++++++++++++++++++++++++ wgpu/src/shader/solid.wgsl | 17 +++++++ wgpu/src/shader/triangle_gradient.wgsl | 88 ---------------------------------- wgpu/src/shader/triangle_solid.wgsl | 17 ------- wgpu/src/triangle.rs | 34 +++++++------ wgpu/src/triangle/gradient.rs | 67 +++++++++++++------------- wgpu/src/triangle/solid.rs | 55 ++++++++++----------- 14 files changed, 243 insertions(+), 246 deletions(-) create mode 100644 wgpu/src/shader/gradient.wgsl create mode 100644 wgpu/src/shader/solid.wgsl delete mode 100644 wgpu/src/shader/triangle_gradient.wgsl delete mode 100644 wgpu/src/shader/triangle_solid.wgsl 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: ::VertexArray, vertices: Buffer, indices: Buffer, - 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: ::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: ::UniformLocation, color_stops_size_location: ::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: ::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: ::Program, - uniform_data: SolidUniformData, + uniform_data: UniformData, } #[derive(Debug)] -struct SolidUniformData { +struct UniformData { pub color: Color, pub color_location: ::UniformLocation, pub transform: Transformation, pub transform_location: ::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, /// 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, } 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 StaticBuffer { /// 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>), Storage(encase::DynamicStorageBuffer>), } -impl DynamicBufferType { +impl BufferType { /// Writes the current value to its CPU buffer with proper alignment. pub(super) fn write( &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 { 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 { +pub(crate) struct Buffer { offsets: Vec, - cpu: DynamicBufferType, + cpu: BufferType, gpu: wgpu::Buffer, label: &'static str, size: u64, _data: PhantomData, } -impl DynamicBuffer { +impl Buffer { /// 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 DynamicBuffer { /// 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 DynamicBuffer { 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 DynamicBuffer { Self { offsets: Vec::new(), cpu: dynamic_buffer_type, - gpu: DynamicBuffer::::create_gpu_buffer( + gpu: Buffer::::create_gpu_buffer( device, label, usage, @@ -139,15 +139,15 @@ impl DynamicBuffer { 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::::create_gpu_buffer( + self.gpu = Buffer::::create_gpu_buffer( device, self.label, usages, new_size, ); self.size = new_size; diff --git a/wgpu/src/shader/gradient.wgsl b/wgpu/src/shader/gradient.wgsl new file mode 100644 index 00000000..63825aec --- /dev/null +++ b/wgpu/src/shader/gradient.wgsl @@ -0,0 +1,88 @@ +struct Uniforms { + transform: mat4x4, + //xy = start, wz = end + position: vec4, + //x = start stop, y = end stop, zw = padding + stop_range: vec4, +} + +struct Stop { + color: vec4, + offset: f32, +}; + +@group(0) @binding(0) +var uniforms: Uniforms; + +@group(0) @binding(1) +var color_stops: array; + +struct VertexOutput { + @builtin(position) position: vec4, + @location(0) raw_position: vec2 +} + +@vertex +fn vs_main(@location(0) input: vec2) -> VertexOutput { + var output: VertexOutput; + output.position = uniforms.transform * vec4(input.xy, 0.0, 1.0); + output.raw_position = input; + + return output; +} + +//TODO: rewrite without branching +@fragment +fn fs_main(input: VertexOutput) -> @location(0) vec4 { + let start = uniforms.position.xy; + let end = uniforms.position.zw; + let start_stop = uniforms.stop_range.x; + let end_stop = uniforms.stop_range.y; + + let v1 = end - start; + let v2 = input.raw_position.xy - start; + let unit = normalize(v1); + let offset = dot(unit, v2) / length(v1); + + let min_stop = color_stops[start_stop]; + let max_stop = color_stops[end_stop]; + + var color: vec4; + + if (offset <= min_stop.offset) { + color = min_stop.color; + } else if (offset >= max_stop.offset) { + color = max_stop.color; + } else { + var min = min_stop; + var max = max_stop; + var min_index = start_stop; + var max_index = end_stop; + + loop { + if (min_index >= max_index - 1) { + break; + } + + let index = min_index + (max_index - min_index) / 2; + + let stop = color_stops[index]; + + if (offset <= stop.offset) { + max = stop; + max_index = index; + } else { + min = stop; + min_index = index; + } + } + + color = mix(min.color, max.color, smoothstep( + min.offset, + max.offset, + offset + )); + } + + return color; +} 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, + color: vec4 +} + +@group(0) @binding(0) +var uniforms: Uniforms; + +@vertex +fn vs_main(@location(0) input: vec2) -> @builtin(position) vec4 { + return uniforms.transform * vec4(input.xy, 0.0, 1.0); +} + +@fragment +fn fs_main() -> @location(0) vec4 { + return uniforms.color; +} diff --git a/wgpu/src/shader/triangle_gradient.wgsl b/wgpu/src/shader/triangle_gradient.wgsl deleted file mode 100644 index 03ba9d88..00000000 --- a/wgpu/src/shader/triangle_gradient.wgsl +++ /dev/null @@ -1,88 +0,0 @@ -struct GradientUniforms { - transform: mat4x4, - //xy = start, wz = end - position: vec4, - //x = start stop, y = end stop, zw = padding - stop_range: vec4, -} - -struct Stop { - color: vec4, - offset: f32, -}; - -@group(0) @binding(0) -var uniforms: GradientUniforms; - -@group(0) @binding(1) -var color_stops: array; - -struct VertexOutput { - @builtin(position) position: vec4, - @location(0) raw_position: vec2 -} - -@vertex -fn vs_main(@location(0) input: vec2) -> VertexOutput { - var output: VertexOutput; - output.position = uniforms.transform * vec4(input.xy, 0.0, 1.0); - output.raw_position = input; - - return output; -} - -//TODO: rewrite without branching -@fragment -fn fs_gradient(input: VertexOutput) -> @location(0) vec4 { - let start = uniforms.position.xy; - let end = uniforms.position.zw; - let start_stop = uniforms.stop_range.x; - let end_stop = uniforms.stop_range.y; - - let v1 = end - start; - let v2 = input.raw_position.xy - start; - let unit = normalize(v1); - let offset = dot(unit, v2) / length(v1); - - let min_stop = color_stops[start_stop]; - let max_stop = color_stops[end_stop]; - - var color: vec4; - - if (offset <= min_stop.offset) { - color = min_stop.color; - } else if (offset >= max_stop.offset) { - color = max_stop.color; - } else { - var min = min_stop; - var max = max_stop; - var min_index = start_stop; - var max_index = end_stop; - - loop { - if (min_index >= max_index - 1) { - break; - } - - let index = min_index + (max_index - min_index) / 2; - - let stop = color_stops[index]; - - if (offset <= stop.offset) { - max = stop; - max_index = index; - } else { - min = stop; - min_index = index; - } - } - - color = mix(min.color, max.color, smoothstep( - min.offset, - max.offset, - offset - )); - } - - return 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, - color: vec4 -} - -@group(0) @binding(0) -var solid_uniforms: SolidUniforms; - -@vertex -fn vs_main(@location(0) input: vec2) -> @builtin(position) vec4 { - return solid_uniforms.transform * vec4(input.xy, 0.0, 1.0); -} - -@fragment -fn fs_solid() -> @location(0) vec4 { - 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, index_buffer: StaticBuffer, index_strides: Vec, - 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 { 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, ) -> 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, - pub(super) storage_buffer: DynamicBuffer, + pub(super) uniform_buffer: dynamic::Buffer, + pub(super) storage_buffer: dynamic::Buffer, 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, } -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, ) -> 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, + pub(super) buffer: dynamic::Buffer, 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, ) -> 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, -- cgit