From 40f45d7b7e35dd4937abe6b5ce16b6256b4f1eeb Mon Sep 17 00:00:00 2001 From: shan Date: Thu, 29 Sep 2022 10:52:58 -0700 Subject: Adds linear gradient support to 2D meshes in the canvas widget. --- glow/src/triangle.rs | 228 ++++++++++++++++++++++++++------------------------- 1 file changed, 117 insertions(+), 111 deletions(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index ae4f83ef..7d0e14c7 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -1,66 +1,41 @@ -//! Draw meshes of triangles. +//! Draw meshes of triangle. +mod gradient; +mod solid; + use crate::program::{self, Shader}; use crate::Transformation; use glow::HasContext; -use iced_graphics::layer; +use iced_graphics::layer::{Mesh, Meshes}; +use iced_graphics::shader; use std::marker::PhantomData; +use crate::triangle::gradient::GradientProgram; +use crate::triangle::solid::SolidProgram; pub use iced_graphics::triangle::{Mesh2D, Vertex2D}; -const VERTEX_BUFFER_SIZE: usize = 10_000; -const INDEX_BUFFER_SIZE: usize = 10_000; - #[derive(Debug)] pub(crate) struct Pipeline { - program: ::Program, vertex_array: ::VertexArray, vertices: Buffer, indices: Buffer, - transform_location: ::UniformLocation, current_transform: Transformation, + programs: TrianglePrograms, } -impl Pipeline { - pub fn new( - gl: &glow::Context, - shader_version: &program::Version, - ) -> Pipeline { - let program = unsafe { - let vertex_shader = Shader::vertex( - gl, - shader_version, - include_str!("shader/common/triangle.vert"), - ); - let fragment_shader = Shader::fragment( - gl, - shader_version, - include_str!("shader/common/triangle.frag"), - ); - - program::create( - gl, - &[vertex_shader, fragment_shader], - &[(0, "i_Position"), (1, "i_Color")], - ) - }; - - let transform_location = - unsafe { gl.get_uniform_location(program, "u_Transform") } - .expect("Get transform location"); - - unsafe { - gl.use_program(Some(program)); - - let transform: [f32; 16] = Transformation::identity().into(); - gl.uniform_matrix_4_f32_slice( - Some(&transform_location), - false, - &transform, - ); +#[derive(Debug)] +struct TrianglePrograms { + solid: TriangleProgram, + gradient: TriangleProgram, +} - gl.use_program(None); - } +#[derive(Debug)] +enum TriangleProgram { + Solid(SolidProgram), + Gradient(GradientProgram), +} +impl Pipeline { + pub fn new(gl: &glow::Context, shader_version: &program::Version) -> Self { let vertex_array = unsafe { gl.create_vertex_array().expect("Create vertex array") }; @@ -73,7 +48,7 @@ impl Pipeline { gl, glow::ARRAY_BUFFER, glow::DYNAMIC_DRAW, - VERTEX_BUFFER_SIZE, + std::mem::size_of::() as usize, ) }; @@ -82,7 +57,7 @@ impl Pipeline { gl, glow::ELEMENT_ARRAY_BUFFER, glow::DYNAMIC_DRAW, - INDEX_BUFFER_SIZE, + std::mem::size_of::() as usize, ) }; @@ -92,58 +67,45 @@ impl Pipeline { gl.enable_vertex_attrib_array(0); gl.vertex_attrib_pointer_f32(0, 2, glow::FLOAT, false, stride, 0); - gl.enable_vertex_attrib_array(1); - gl.vertex_attrib_pointer_f32( - 1, - 4, - glow::FLOAT, - false, - stride, - 4 * 2, - ); - gl.bind_vertex_array(None); - } + }; - Pipeline { - program, + Self { vertex_array, vertices, indices, - transform_location, current_transform: Transformation::identity(), + programs: TrianglePrograms { + solid: TriangleProgram::Solid(SolidProgram::new( + gl, + shader_version, + )), + gradient: TriangleProgram::Gradient(GradientProgram::new( + gl, + shader_version, + )), + }, } } pub fn draw( &mut self, + meshes: &Meshes<'_>, gl: &glow::Context, target_height: u32, transformation: Transformation, scale_factor: f32, - meshes: &[layer::Mesh<'_>], ) { unsafe { gl.enable(glow::MULTISAMPLE); gl.enable(glow::SCISSOR_TEST); - gl.use_program(Some(self.program)); - gl.bind_vertex_array(Some(self.vertex_array)); + gl.bind_vertex_array(Some(self.vertex_array)) } - // This looks a bit crazy, but we are just counting how many vertices - // and indices we will need to handle. - // TODO: Improve readability - let (total_vertices, total_indices) = meshes - .iter() - .map(|layer::Mesh { buffers, .. }| { - (buffers.vertices.len(), buffers.indices.len()) - }) - .fold((0, 0), |(total_v, total_i), (v, i)| { - (total_v + v, total_i + i) - }); - - // Then we ensure the current buffers are big enough, resizing if - // necessary + //count the total number of vertices & indices we need to handle for all meshes + let (total_vertices, total_indices) = meshes.attribute_count(); + + // Then we ensure the current attribute buffers are big enough, resizing if necessary unsafe { self.vertices.bind(gl, total_vertices); self.indices.bind(gl, total_indices); @@ -153,7 +115,7 @@ impl Pipeline { let mut last_vertex = 0; let mut last_index = 0; - for layer::Mesh { buffers, .. } in meshes { + for Mesh { buffers, .. } in meshes.0.iter() { unsafe { gl.buffer_sub_data_u8_slice( glow::ARRAY_BUFFER, @@ -176,11 +138,12 @@ impl Pipeline { let mut last_vertex = 0; let mut last_index = 0; - for layer::Mesh { + for Mesh { buffers, origin, clip_bounds, - } in meshes + shader, + } in meshes.0.iter() { let transform = transformation * Transformation::translate(origin.x, origin.y); @@ -188,17 +151,6 @@ impl Pipeline { let clip_bounds = (*clip_bounds * scale_factor).snap(); unsafe { - if self.current_transform != transform { - let matrix: [f32; 16] = transform.into(); - gl.uniform_matrix_4_f32_slice( - Some(&self.transform_location), - false, - &matrix, - ); - - self.current_transform = transform; - } - gl.scissor( clip_bounds.x as i32, (target_height - (clip_bounds.y + clip_bounds.height)) @@ -207,6 +159,15 @@ impl Pipeline { clip_bounds.height as i32, ); + let t = if self.current_transform != transform { + self.current_transform = transform; + Some(transform) + } else { + None + }; + + self.use_with_shader(gl, shader, t); + gl.draw_elements_base_vertex( glow::TRIANGLES, buffers.indices.len() as i32, @@ -222,34 +183,79 @@ impl Pipeline { unsafe { gl.bind_vertex_array(None); - gl.use_program(None); gl.disable(glow::SCISSOR_TEST); gl.disable(glow::MULTISAMPLE); } } -} -#[repr(C)] -#[derive(Debug, Clone, Copy)] -struct Uniforms { - transform: [f32; 16], + fn use_with_shader( + &mut self, + gl: &glow::Context, + shader: &shader::Shader, + transform: Option, + ) { + match shader { + shader::Shader::Solid(color) => { + if let TriangleProgram::Solid(solid_program) = + &mut self.programs.solid + { + unsafe { gl.use_program(Some(solid_program.program)) } + solid_program.set_uniforms(gl, color, transform); + } + } + shader::Shader::Gradient(gradient) => { + if let TriangleProgram::Gradient(gradient_program) = + &mut self.programs.gradient + { + unsafe { gl.use_program(Some(gradient_program.program)) } + gradient_program.set_uniforms(gl, gradient, transform); + } + } + } + } } -unsafe impl bytemuck::Zeroable for Uniforms {} -unsafe impl bytemuck::Pod for Uniforms {} - -impl Default for Uniforms { - fn default() -> Self { - Self { - transform: *Transformation::identity().as_ref(), - } +/// A simple shader program. Uses [`triangle.vert`] for its vertex shader and only binds position +/// attribute location. +pub(super) fn simple_triangle_program( + gl: &glow::Context, + shader_version: &program::Version, + fragment_shader: &'static str, +) -> ::Program { + unsafe { + let vertex_shader = Shader::vertex( + gl, + shader_version, + include_str!("shader/common/triangle.vert"), + ); + + let fragment_shader = + Shader::fragment(gl, shader_version, fragment_shader); + + program::create( + gl, + &[vertex_shader, fragment_shader], + &[(0, "i_Position")], + ) } } -impl From for Uniforms { - fn from(transformation: Transformation) -> Uniforms { - Self { - transform: transformation.into(), +pub(super) fn update_transform( + gl: &glow::Context, + program: ::Program, + transform: Option +) { + if let Some(t) = transform { + let transform_location = + unsafe { gl.get_uniform_location(program, "u_Transform") } + .expect("Get transform location."); + + unsafe { + gl.uniform_matrix_4_f32_slice( + Some(&transform_location), + false, + t.as_ref(), + ); } } } -- cgit From e25f3d3dea2d2c1ba7d2778948443df2745084be Mon Sep 17 00:00:00 2001 From: shan Date: Thu, 29 Sep 2022 17:13:32 -0700 Subject: Fixed issue where OpenGL would not render both shaders at once under certain circumstances. --- glow/src/triangle.rs | 52 ++++++++++++++++++++++------------------------------ 1 file changed, 22 insertions(+), 30 deletions(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index 7d0e14c7..85d873fe 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -24,14 +24,8 @@ pub(crate) struct Pipeline { #[derive(Debug)] struct TrianglePrograms { - solid: TriangleProgram, - gradient: TriangleProgram, -} - -#[derive(Debug)] -enum TriangleProgram { - Solid(SolidProgram), - Gradient(GradientProgram), + solid: SolidProgram, + gradient: GradientProgram, } impl Pipeline { @@ -76,14 +70,8 @@ impl Pipeline { indices, current_transform: Transformation::identity(), programs: TrianglePrograms { - solid: TriangleProgram::Solid(SolidProgram::new( - gl, - shader_version, - )), - gradient: TriangleProgram::Gradient(GradientProgram::new( - gl, - shader_version, - )), + solid: SolidProgram::new(gl, shader_version), + gradient: GradientProgram::new(gl, shader_version), }, } } @@ -138,16 +126,21 @@ impl Pipeline { let mut last_vertex = 0; let mut last_index = 0; - for Mesh { + for (index, Mesh { buffers, origin, clip_bounds, shader, - } in meshes.0.iter() + }) in meshes.0.iter().enumerate() { let transform = transformation * Transformation::translate(origin.x, origin.y); + if index == 0 { + //set initial transform uniform for both programs + self.programs.set_transforms(gl, transform); + } + let clip_bounds = (*clip_bounds * scale_factor).snap(); unsafe { @@ -196,25 +189,24 @@ impl Pipeline { ) { match shader { shader::Shader::Solid(color) => { - if let TriangleProgram::Solid(solid_program) = - &mut self.programs.solid - { - unsafe { gl.use_program(Some(solid_program.program)) } - solid_program.set_uniforms(gl, color, transform); - } + unsafe { gl.use_program(Some(self.programs.solid.program)) } + self.programs.solid.set_uniforms(gl, color, transform); } shader::Shader::Gradient(gradient) => { - if let TriangleProgram::Gradient(gradient_program) = - &mut self.programs.gradient - { - unsafe { gl.use_program(Some(gradient_program.program)) } - gradient_program.set_uniforms(gl, gradient, transform); - } + unsafe { gl.use_program(Some(self.programs.gradient.program)) } + self.programs.gradient.set_uniforms(gl, gradient, transform); } } } } +impl TrianglePrograms { + pub fn set_transforms(&self, gl: &glow::Context, transform: Transformation) { + update_transform(gl, self.solid.program, Some(transform)); + update_transform(gl, self.gradient.program, Some(transform)); + } +} + /// A simple shader program. Uses [`triangle.vert`] for its vertex shader and only binds position /// attribute location. pub(super) fn simple_triangle_program( -- cgit From 6e7b3ced0b1daf368e44e181ecdb4ae529877eb6 Mon Sep 17 00:00:00 2001 From: shan Date: Tue, 4 Oct 2022 18:24:46 -0700 Subject: Reworked wgpu buffers, updated glow side to have proper transform location storage, attempting to fix visibility modifiers, implemented some of the feedback received in initial PR. --- glow/src/triangle.rs | 126 +++++++++++++++++---------------------------------- 1 file changed, 41 insertions(+), 85 deletions(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index 85d873fe..f16f8af4 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -2,23 +2,22 @@ mod gradient; mod solid; -use crate::program::{self, Shader}; -use crate::Transformation; +use crate::{program, Transformation}; use glow::HasContext; -use iced_graphics::layer::{Mesh, Meshes}; +use iced_graphics::layer::{attribute_count_of, Mesh}; use iced_graphics::shader; use std::marker::PhantomData; use crate::triangle::gradient::GradientProgram; use crate::triangle::solid::SolidProgram; pub use iced_graphics::triangle::{Mesh2D, Vertex2D}; +use shader::Shader; #[derive(Debug)] pub(crate) struct Pipeline { vertex_array: ::VertexArray, vertices: Buffer, indices: Buffer, - current_transform: Transformation, programs: TrianglePrograms, } @@ -68,7 +67,6 @@ impl Pipeline { vertex_array, vertices, indices, - current_transform: Transformation::identity(), programs: TrianglePrograms { solid: SolidProgram::new(gl, shader_version), gradient: GradientProgram::new(gl, shader_version), @@ -78,7 +76,7 @@ impl Pipeline { pub fn draw( &mut self, - meshes: &Meshes<'_>, + meshes: &[Mesh<'_>], gl: &glow::Context, target_height: u32, transformation: Transformation, @@ -90,8 +88,8 @@ impl Pipeline { gl.bind_vertex_array(Some(self.vertex_array)) } - //count the total number of vertices & indices we need to handle for all meshes - let (total_vertices, total_indices) = meshes.attribute_count(); + //count the total amount of vertices & indices we need to handle + let (total_vertices, total_indices) = attribute_count_of(meshes); // Then we ensure the current attribute buffers are big enough, resizing if necessary unsafe { @@ -100,25 +98,25 @@ impl Pipeline { } // We upload all the vertices and indices upfront - let mut last_vertex = 0; - let mut last_index = 0; + let mut vertex_offset = 0; + let mut index_offset = 0; - for Mesh { buffers, .. } in meshes.0.iter() { + for mesh in meshes { unsafe { gl.buffer_sub_data_u8_slice( glow::ARRAY_BUFFER, - (last_vertex * std::mem::size_of::()) as i32, - bytemuck::cast_slice(&buffers.vertices), + (vertex_offset * std::mem::size_of::()) as i32, + bytemuck::cast_slice(&mesh.buffers.vertices), ); gl.buffer_sub_data_u8_slice( glow::ELEMENT_ARRAY_BUFFER, - (last_index * std::mem::size_of::()) as i32, - bytemuck::cast_slice(&buffers.indices), + (index_offset * std::mem::size_of::()) as i32, + bytemuck::cast_slice(&mesh.buffers.indices), ); - last_vertex += buffers.vertices.len(); - last_index += buffers.indices.len(); + vertex_offset += mesh.buffers.vertices.len(); + index_offset += mesh.buffers.indices.len(); } } @@ -126,22 +124,11 @@ impl Pipeline { let mut last_vertex = 0; let mut last_index = 0; - for (index, Mesh { - buffers, - origin, - clip_bounds, - shader, - }) in meshes.0.iter().enumerate() - { - let transform = - transformation * Transformation::translate(origin.x, origin.y); - - if index == 0 { - //set initial transform uniform for both programs - self.programs.set_transforms(gl, transform); - } + for mesh in meshes { + let transform = transformation + * Transformation::translate(mesh.origin.x, mesh.origin.y); - let clip_bounds = (*clip_bounds * scale_factor).snap(); + let clip_bounds = (mesh.clip_bounds * scale_factor).snap(); unsafe { gl.scissor( @@ -152,25 +139,25 @@ impl Pipeline { clip_bounds.height as i32, ); - let t = if self.current_transform != transform { - self.current_transform = transform; - Some(transform) - } else { - None - }; - - self.use_with_shader(gl, shader, t); + match mesh.shader { + Shader::Solid(color) => { + self.programs.solid.use_program(gl, &color, &transform); + } + Shader::Gradient(gradient) => { + self.programs.gradient.use_program(gl, &gradient, &transform); + } + } gl.draw_elements_base_vertex( glow::TRIANGLES, - buffers.indices.len() as i32, + mesh.buffers.indices.len() as i32, glow::UNSIGNED_INT, (last_index * std::mem::size_of::()) as i32, last_vertex as i32, ); - last_vertex += buffers.vertices.len(); - last_index += buffers.indices.len(); + last_vertex += mesh.buffers.vertices.len(); + last_index += mesh.buffers.indices.len(); } } @@ -180,31 +167,6 @@ impl Pipeline { gl.disable(glow::MULTISAMPLE); } } - - fn use_with_shader( - &mut self, - gl: &glow::Context, - shader: &shader::Shader, - transform: Option, - ) { - match shader { - shader::Shader::Solid(color) => { - unsafe { gl.use_program(Some(self.programs.solid.program)) } - self.programs.solid.set_uniforms(gl, color, transform); - } - shader::Shader::Gradient(gradient) => { - unsafe { gl.use_program(Some(self.programs.gradient.program)) } - self.programs.gradient.set_uniforms(gl, gradient, transform); - } - } - } -} - -impl TrianglePrograms { - pub fn set_transforms(&self, gl: &glow::Context, transform: Transformation) { - update_transform(gl, self.solid.program, Some(transform)); - update_transform(gl, self.gradient.program, Some(transform)); - } } /// A simple shader program. Uses [`triangle.vert`] for its vertex shader and only binds position @@ -215,14 +177,14 @@ pub(super) fn simple_triangle_program( fragment_shader: &'static str, ) -> ::Program { unsafe { - let vertex_shader = Shader::vertex( + let vertex_shader = program::Shader::vertex( gl, shader_version, include_str!("shader/common/triangle.vert"), ); let fragment_shader = - Shader::fragment(gl, shader_version, fragment_shader); + program::Shader::fragment(gl, shader_version, fragment_shader); program::create( gl, @@ -232,23 +194,17 @@ pub(super) fn simple_triangle_program( } } -pub(super) fn update_transform( +pub fn set_transform( gl: &glow::Context, - program: ::Program, - transform: Option + location: ::UniformLocation, + transform: Transformation, ) { - if let Some(t) = transform { - let transform_location = - unsafe { gl.get_uniform_location(program, "u_Transform") } - .expect("Get transform location."); - - unsafe { - gl.uniform_matrix_4_f32_slice( - Some(&transform_location), - false, - t.as_ref(), - ); - } + unsafe { + gl.uniform_matrix_4_f32_slice( + Some(&location), + false, + transform.as_ref() + ); } } -- cgit From 30432cbade3d9b25c4df62656a7494db3f4ea82a Mon Sep 17 00:00:00 2001 From: shan Date: Wed, 5 Oct 2022 10:49:58 -0700 Subject: Readjusted namespaces, removed Geometry example as it's no longer relevant. --- glow/src/triangle.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index f16f8af4..5e58f4e4 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -5,13 +5,13 @@ mod solid; use crate::{program, Transformation}; use glow::HasContext; use iced_graphics::layer::{attribute_count_of, Mesh}; -use iced_graphics::shader; use std::marker::PhantomData; +use iced_graphics::layer; use crate::triangle::gradient::GradientProgram; use crate::triangle::solid::SolidProgram; pub use iced_graphics::triangle::{Mesh2D, Vertex2D}; -use shader::Shader; +use layer::mesh; #[derive(Debug)] pub(crate) struct Pipeline { @@ -139,11 +139,11 @@ impl Pipeline { clip_bounds.height as i32, ); - match mesh.shader { - Shader::Solid(color) => { + match mesh.style { + mesh::Style::Solid(color) => { self.programs.solid.use_program(gl, &color, &transform); } - Shader::Gradient(gradient) => { + mesh::Style::Gradient(gradient) => { self.programs.gradient.use_program(gl, &gradient, &transform); } } -- cgit From cb7c4676543cd508dfae8d4dcbd9cc8b61b1a94e Mon Sep 17 00:00:00 2001 From: shan Date: Thu, 6 Oct 2022 07:28:05 -0700 Subject: Fixed lint issues & cleaned up some documentation. --- glow/src/triangle.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index 5e58f4e4..f26d1cea 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -1,4 +1,4 @@ -//! Draw meshes of triangle. +//! Draw meshes of triangles. mod gradient; mod solid; -- cgit From 215e6c95be7370bdd29c75b904463f06f942b7c0 Mon Sep 17 00:00:00 2001 From: shan Date: Fri, 7 Oct 2022 13:21:32 -0700 Subject: More import adjusting. --- glow/src/triangle.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index f26d1cea..f7fe9235 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -4,14 +4,12 @@ mod solid; use crate::{program, Transformation}; use glow::HasContext; -use iced_graphics::layer::{attribute_count_of, Mesh}; +use iced_graphics::layer::{mesh, mesh::attribute_count_of, Mesh}; use std::marker::PhantomData; -use iced_graphics::layer; use crate::triangle::gradient::GradientProgram; use crate::triangle::solid::SolidProgram; pub use iced_graphics::triangle::{Mesh2D, Vertex2D}; -use layer::mesh; #[derive(Debug)] pub(crate) struct Pipeline { @@ -144,7 +142,9 @@ impl Pipeline { self.programs.solid.use_program(gl, &color, &transform); } mesh::Style::Gradient(gradient) => { - self.programs.gradient.use_program(gl, &gradient, &transform); + self.programs + .gradient + .use_program(gl, &gradient, &transform); } } @@ -203,7 +203,7 @@ pub fn set_transform( gl.uniform_matrix_4_f32_slice( Some(&location), false, - transform.as_ref() + transform.as_ref(), ); } } -- cgit 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 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) (limited to 'glow/src/triangle.rs') 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, -- cgit From 7e22e2d45293c5916812be03dc7367134b69b3ad Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Thu, 3 Nov 2022 04:53:27 +0100 Subject: Fix lints by `clippy` --- glow/src/triangle.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index fff14910..68ebcb00 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -137,12 +137,12 @@ impl Pipeline { match mesh.style { mesh::Style::Solid(color) => { - self.programs.solid.use_program(gl, &color, &transform); + self.programs.solid.use_program(gl, color, &transform); } mesh::Style::Gradient(gradient) => { self.programs .gradient - .use_program(gl, &gradient, &transform); + .use_program(gl, gradient, &transform); } } -- cgit From 84d1b79fefc88534835fdfbe79bc0eb3b43627cf Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Thu, 3 Nov 2022 05:50:53 +0100 Subject: Move `mesh::Style` to `triangle` and reuse it in `fill` and `stroke` --- glow/src/triangle.rs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index 68ebcb00..5d14666c 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -3,8 +3,11 @@ mod gradient; mod solid; use crate::{program, Transformation}; + +use iced_graphics::layer::mesh::{self, Mesh}; +use iced_graphics::triangle; + use glow::HasContext; -use iced_graphics::layer::{mesh, Mesh}; use std::marker::PhantomData; pub use iced_graphics::triangle::{Mesh2D, Vertex2D}; @@ -136,10 +139,10 @@ impl Pipeline { ); match mesh.style { - mesh::Style::Solid(color) => { + triangle::Style::Solid(color) => { self.programs.solid.use_program(gl, color, &transform); } - mesh::Style::Gradient(gradient) => { + triangle::Style::Gradient(gradient) => { self.programs .gradient .use_program(gl, gradient, &transform); -- cgit From f31c8f2504ea7c004c5caed8913e5da28d2e50e2 Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Thu, 3 Nov 2022 06:05:23 +0100 Subject: Refactor imports of `triangle` modules in `iced_glow` and `iced_wgpu` --- glow/src/triangle.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'glow/src/triangle.rs') diff --git a/glow/src/triangle.rs b/glow/src/triangle.rs index 5d14666c..0e27bcf2 100644 --- a/glow/src/triangle.rs +++ b/glow/src/triangle.rs @@ -2,16 +2,15 @@ mod gradient; mod solid; -use crate::{program, Transformation}; +use crate::program; +use crate::Transformation; use iced_graphics::layer::mesh::{self, Mesh}; -use iced_graphics::triangle; +use iced_graphics::triangle::{self, Vertex2D}; use glow::HasContext; use std::marker::PhantomData; -pub use iced_graphics::triangle::{Mesh2D, Vertex2D}; - #[derive(Debug)] pub(crate) struct Pipeline { vertex_array: ::VertexArray, -- cgit