Move `mesh::Style` to `triangle` and reuse it in `fill` and `stroke`

10 files changed, 72 insertions, 98 deletions

diff --git a/examples/modern_art/src/main.rs b/examples/modern_art/src/main.rs
index db9b0491..0dd21c74 100644
--- a/examples/modern_art/src/main.rs
+++ b/examples/modern_art/src/main.rs
@@ -133,7 +133,7 @@ fn generate_box(frame: &mut Frame, bounds: Size) -> bool {
     if solid {
         frame.fill_rectangle(top_left, size, random_color());
     } else {
-        frame.fill_rectangle(top_left, size, &gradient(top_left, size));
+        frame.fill_rectangle(top_left, size, gradient(top_left, size));
     };
 
     solid
diff --git a/examples/solar_system/src/main.rs b/examples/solar_system/src/main.rs
index 8d27d154..56787a99 100644
--- a/examples/solar_system/src/main.rs
+++ b/examples/solar_system/src/main.rs
@@ -213,7 +213,7 @@ impl<Message> canvas::Program<Message> for State {
                     .build()
                     .expect("Build Earth fill gradient");
 
-                frame.fill(&earth, &earth_fill);
+                frame.fill(&earth, earth_fill);
 
                 frame.with_save(|frame| {
                     frame.rotate(rotation * 10.0);
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);
diff --git a/graphics/src/layer/mesh.rs b/graphics/src/layer/mesh.rs
index 370aab1a..979081f1 100644
--- a/graphics/src/layer/mesh.rs
+++ b/graphics/src/layer/mesh.rs
@@ -1,6 +1,6 @@
 //! A collection of triangle primitives.
-use crate::gradient::Gradient;
-use crate::{triangle, Color, Point, Rectangle};
+use crate::triangle;
+use crate::{Point, Rectangle};
 
 /// A mesh of triangles.
 #[derive(Debug, Clone, Copy)]
@@ -15,22 +15,7 @@ pub struct Mesh<'a> {
     pub clip_bounds: Rectangle<f32>,
 
     /// The shader of the [`Mesh`].
-    pub style: &'a Style,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-/// Supported shaders for primitives.
-pub enum Style {
-    /// Fill a primitive with a solid color.
-    Solid(Color),
-    /// Fill a primitive with an interpolated color.
-    Gradient(Gradient),
-}
-
-impl From<Gradient> for Style {
-    fn from(gradient: Gradient) -> Self {
-        Self::Gradient(gradient)
-    }
+    pub style: &'a triangle::Style,
 }
 
 /// Returns the number of total vertices & total indices of all [`Mesh`]es.
diff --git a/graphics/src/primitive.rs b/graphics/src/primitive.rs
index c0d6bb55..b481ac0b 100644
--- a/graphics/src/primitive.rs
+++ b/graphics/src/primitive.rs
@@ -2,8 +2,8 @@ use iced_native::image;
 use iced_native::svg;
 use iced_native::{Background, Color, Font, Rectangle, Size, Vector};
 
+use crate::alignment;
 use crate::triangle;
-use crate::{alignment, layer::mesh};
 
 use std::sync::Arc;
 
@@ -90,7 +90,7 @@ pub enum Primitive {
         size: Size,
 
         /// The shader of the mesh
-        style: mesh::Style,
+        style: triangle::Style,
     },
     /// A cached primitive.
     ///
diff --git a/graphics/src/triangle.rs b/graphics/src/triangle.rs
index 39359cfb..04ff6d21 100644
--- a/graphics/src/triangle.rs
+++ b/graphics/src/triangle.rs
@@ -1,4 +1,6 @@
 //! Draw geometry using meshes of triangles.
+use crate::{Color, Gradient};
+
 use bytemuck::{Pod, Zeroable};
 
 /// A set of [`Vertex2D`] and indices representing a list of triangles.
@@ -19,3 +21,24 @@ pub struct Vertex2D {
     /// The vertex position in 2D space.
     pub position: [f32; 2],
 }
+
+#[derive(Debug, Clone, PartialEq)]
+/// Supported shaders for triangle primitives.
+pub enum Style {
+    /// Fill a primitive with a solid color.
+    Solid(Color),
+    /// Fill a primitive with an interpolated color.
+    Gradient(Gradient),
+}
+
+impl From<Color> for Style {
+    fn from(color: Color) -> Self {
+        Self::Solid(color)
+    }
+}
+
+impl From<Gradient> for Style {
+    fn from(gradient: Gradient) -> Self {
+        Self::Gradient(gradient)
+    }
+}
diff --git a/graphics/src/widget/canvas/fill.rs b/graphics/src/widget/canvas/fill.rs
index 2be8ed41..c69fc0d7 100644
--- a/graphics/src/widget/canvas/fill.rs
+++ b/graphics/src/widget/canvas/fill.rs
@@ -1,17 +1,15 @@
 //! Fill [crate::widget::canvas::Geometry] with a certain style.
+use crate::{Color, Gradient};
 
-use crate::gradient::Gradient;
-use crate::layer::mesh;
-use crate::widget::canvas::frame::Transform;
-use iced_native::Color;
+pub use crate::triangle::Style;
 
 /// The style used to fill geometry.
 #[derive(Debug, Clone)]
-pub struct Fill<'a> {
+pub struct Fill {
     /// The color or gradient of the fill.
     ///
     /// By default, it is set to [`FillStyle::Solid`] `BLACK`.
-    pub style: Style<'a>,
+    pub style: Style,
 
     /// The fill rule defines how to determine what is inside and what is
     /// outside of a shape.
@@ -24,17 +22,17 @@ pub struct Fill<'a> {
     pub rule: FillRule,
 }
 
-impl<'a> Default for Fill<'a> {
-    fn default() -> Fill<'a> {
-        Fill {
+impl Default for Fill {
+    fn default() -> Self {
+        Self {
             style: Style::Solid(Color::BLACK),
             rule: FillRule::NonZero,
         }
     }
 }
 
-impl<'a> From<Color> for Fill<'a> {
-    fn from(color: Color) -> Fill<'a> {
+impl From<Color> for Fill {
+    fn from(color: Color) -> Fill {
         Fill {
             style: Style::Solid(color),
             ..Fill::default()
@@ -42,8 +40,8 @@ impl<'a> From<Color> for Fill<'a> {
     }
 }
 
-impl<'a> From<&'a Gradient> for Fill<'a> {
-    fn from(gradient: &'a Gradient) -> Self {
+impl From<Gradient> for Fill {
+    fn from(gradient: Gradient) -> Self {
         Fill {
             style: Style::Gradient(gradient),
             ..Default::default()
@@ -51,27 +49,6 @@ impl<'a> From<&'a Gradient> for Fill<'a> {
     }
 }
 
-/// The style of a [`Fill`].
-#[derive(Debug, Clone)]
-pub enum Style<'a> {
-    /// A solid color
-    Solid(Color),
-    /// A color gradient
-    Gradient(&'a Gradient),
-}
-
-impl<'a> Style<'a> {
-    /// Converts a fill's [Style] to a [mesh::Style] for use in the renderer's shader.
-    pub(crate) fn as_mesh_style(&self, transform: &Transform) -> mesh::Style {
-        match self {
-            Style::Solid(color) => mesh::Style::Solid(*color),
-            Style::Gradient(gradient) => mesh::Style::Gradient(
-                transform.transform_gradient((*gradient).clone()),
-            ),
-        }
-    }
-}
-
 /// The fill rule defines how to determine what is inside and what is outside of
 /// a shape.
 ///
diff --git a/graphics/src/widget/canvas/frame.rs b/graphics/src/widget/canvas/frame.rs
index 677d7bc5..ed0578b9 100644
--- a/graphics/src/widget/canvas/frame.rs
+++ b/graphics/src/widget/canvas/frame.rs
@@ -4,7 +4,6 @@ use std::borrow::Cow;
 use iced_native::{Point, Rectangle, Size, Vector};
 
 use crate::gradient::Gradient;
-use crate::layer::mesh;
 use crate::triangle;
 use crate::triangle::Vertex2D;
 use crate::widget::canvas::{path, Fill, Geometry, Path, Stroke, Text};
@@ -26,7 +25,7 @@ pub struct Frame {
 }
 
 struct BufferStack {
-    stack: Vec<(tessellation::VertexBuffers<Vertex2D, u32>, mesh::Style)>,
+    stack: Vec<(tessellation::VertexBuffers<Vertex2D, u32>, triangle::Style)>,
 }
 
 impl BufferStack {
@@ -36,7 +35,7 @@ impl BufferStack {
 
     fn get(
         &mut self,
-        mesh_style: mesh::Style,
+        mesh_style: triangle::Style,
     ) -> tessellation::BuffersBuilder<'_, Vertex2D, u32, Vertex2DBuilder> {
         match self.stack.last_mut() {
             Some((_, current_style)) if current_style == &mesh_style => {}
@@ -74,6 +73,15 @@ impl Transform {
         point.y = transformed.y;
     }
 
+    fn transform_style(&self, style: triangle::Style) -> triangle::Style {
+        match style {
+            triangle::Style::Solid(color) => triangle::Style::Solid(color),
+            triangle::Style::Gradient(gradient) => {
+                triangle::Style::Gradient(self.transform_gradient(gradient))
+            }
+        }
+    }
+
     pub(crate) fn transform_gradient(
         &self,
         mut gradient: Gradient,
@@ -135,12 +143,12 @@ impl Frame {
 
     /// Draws the given [`Path`] on the [`Frame`] by filling it with the
     /// provided style.
-    pub fn fill<'a>(&mut self, path: &Path, fill: impl Into<Fill<'a>>) {
+    pub fn fill(&mut self, path: &Path, fill: impl Into<Fill>) {
         let Fill { style, rule } = fill.into();
 
         let mut buffer = self
             .buffers
-            .get(style.as_mesh_style(&self.transforms.current));
+            .get(self.transforms.current.transform_style(style));
 
         let options =
             tessellation::FillOptions::default().with_fill_rule(rule.into());
@@ -165,17 +173,17 @@ impl Frame {
 
     /// Draws an axis-aligned rectangle given its top-left corner coordinate and
     /// its `Size` on the [`Frame`] by filling it with the provided style.
-    pub fn fill_rectangle<'a>(
+    pub fn fill_rectangle(
         &mut self,
         top_left: Point,
         size: Size,
-        fill: impl Into<Fill<'a>>,
+        fill: impl Into<Fill>,
     ) {
         let Fill { style, rule } = fill.into();
 
         let mut buffer = self
             .buffers
-            .get(style.as_mesh_style(&self.transforms.current));
+            .get(self.transforms.current.transform_style(style));
 
         let top_left =
             self.transforms.current.raw.transform_point(
@@ -206,7 +214,7 @@ impl Frame {
 
         let mut buffer = self
             .buffers
-            .get(stroke.style.as_mesh_style(&self.transforms.current));
+            .get(self.transforms.current.transform_style(stroke.style));
 
         let mut options = tessellation::StrokeOptions::default();
         options.line_width = stroke.width;
diff --git a/graphics/src/widget/canvas/stroke.rs b/graphics/src/widget/canvas/stroke.rs
index 2f02a2f3..f9b8e447 100644
--- a/graphics/src/widget/canvas/stroke.rs
+++ b/graphics/src/widget/canvas/stroke.rs
@@ -1,8 +1,6 @@
 //! Create lines from a [crate::widget::canvas::Path] and assigns them various attributes/styles.
+pub use crate::triangle::Style;
 
-use crate::gradient::Gradient;
-use crate::layer::mesh;
-use crate::widget::canvas::frame::Transform;
 use iced_native::Color;
 
 /// The style of a stroke.
@@ -11,7 +9,7 @@ pub struct Stroke<'a> {
     /// The color or gradient of the stroke.
     ///
     /// By default, it is set to [`StrokeStyle::Solid`] `BLACK`.
-    pub style: Style<'a>,
+    pub style: Style,
     /// The distance between the two edges of the stroke.
     pub width: f32,
     /// The shape to be used at the end of open subpaths when they are stroked.
@@ -60,27 +58,6 @@ impl<'a> Default for Stroke<'a> {
     }
 }
 
-/// The style of a [`Stroke`].
-#[derive(Debug, Clone, Copy)]
-pub enum Style<'a> {
-    /// A solid color
-    Solid(Color),
-    /// A color gradient
-    Gradient(&'a Gradient),
-}
-
-impl<'a> Style<'a> {
-    /// Converts a fill's [Style] to a [mesh::Style] for use in the renderer's shader.
-    pub(crate) fn as_mesh_style(&self, transform: &Transform) -> mesh::Style {
-        match self {
-            Style::Solid(color) => mesh::Style::Solid(*color),
-            Style::Gradient(gradient) => mesh::Style::Gradient(
-                transform.transform_gradient((*gradient).clone()),
-            ),
-        }
-    }
-}
-
 /// The shape used at the end of open subpaths when they are stroked.
 #[derive(Debug, Clone, Copy)]
 pub enum LineCap {
diff --git a/wgpu/src/triangle.rs b/wgpu/src/triangle.rs
index 6e64e189..765f7d30 100644
--- a/wgpu/src/triangle.rs
+++ b/wgpu/src/triangle.rs
@@ -3,7 +3,8 @@ use crate::{settings, Transformation};
 use core::fmt;
 use std::fmt::Formatter;
 
-use iced_graphics::layer::{mesh, Mesh};
+use iced_graphics::layer::mesh::{self, Mesh};
+use iced_graphics::triangle;
 use iced_graphics::Size;
 
 use crate::buffer::r#static::Buffer;
@@ -141,10 +142,10 @@ impl Pipeline {
 
             //push uniform data to CPU buffers
             match mesh.style {
-                mesh::Style::Solid(color) => {
+                triangle::Style::Solid(color) => {
                     self.pipelines.solid.push(transform, color);
                 }
-                mesh::Style::Gradient(gradient) => {
+                triangle::Style::Gradient(gradient) => {
                     self.pipelines.gradient.push(transform, gradient);
                 }
             }
@@ -199,7 +200,7 @@ impl Pipeline {
                 );
 
                 match mesh.style {
-                    mesh::Style::Solid(_) => {
+                    triangle::Style::Solid(_) => {
                         if !last_is_solid.unwrap_or(false) {
                             self.pipelines
                                 .solid
@@ -215,7 +216,7 @@ impl Pipeline {
 
                         num_solids += 1;
                     }
-                    mesh::Style::Gradient(_) => {
+                    triangle::Style::Gradient(_) => {
                         if last_is_solid.unwrap_or(true) {
                             self.pipelines
                                 .gradient