From 53a183fe0d6aed460fbb8155ac9541757277aab3 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Fri, 22 Mar 2024 01:35:14 +0100
Subject: Restore `canvas::Frame` API

---
 graphics/src/geometry/cache.rs | 123 ++++++++++++++++++++++++
 graphics/src/geometry/frame.rs | 208 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 331 insertions(+)
 create mode 100644 graphics/src/geometry/cache.rs
 create mode 100644 graphics/src/geometry/frame.rs

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/cache.rs b/graphics/src/geometry/cache.rs
new file mode 100644
index 00000000..490e69e2
--- /dev/null
+++ b/graphics/src/geometry/cache.rs
@@ -0,0 +1,123 @@
+use crate::core::Size;
+use crate::geometry::{self, Frame, Geometry};
+use crate::Primitive;
+
+use std::cell::RefCell;
+use std::sync::Arc;
+
+/// A simple cache that stores generated [`Geometry`] to avoid recomputation.
+///
+/// A [`Cache`] will not redraw its geometry unless the dimensions of its layer
+/// change or it is explicitly cleared.
+pub struct Cache<Renderer>
+where
+    Renderer: geometry::Renderer,
+{
+    state: RefCell<State<Renderer::Geometry>>,
+}
+
+impl<Renderer> Cache<Renderer>
+where
+    Renderer: geometry::Renderer,
+{
+    /// Creates a new empty [`Cache`].
+    pub fn new() -> Self {
+        Cache {
+            state: RefCell::new(State::Empty),
+        }
+    }
+
+    /// Clears the [`Cache`], forcing a redraw the next time it is used.
+    pub fn clear(&self) {
+        *self.state.borrow_mut() = State::Empty;
+    }
+
+    /// Draws [`Geometry`] using the provided closure and stores it in the
+    /// [`Cache`].
+    ///
+    /// The closure will only be called when
+    /// - the bounds have changed since the previous draw call.
+    /// - the [`Cache`] is empty or has been explicitly cleared.
+    ///
+    /// Otherwise, the previously stored [`Geometry`] will be returned. The
+    /// [`Cache`] is not cleared in this case. In other words, it will keep
+    /// returning the stored [`Geometry`] if needed.
+    pub fn draw(
+        &self,
+        renderer: &Renderer,
+        bounds: Size,
+        draw_fn: impl FnOnce(&mut Frame<Renderer>),
+    ) -> Renderer::Geometry {
+        use std::ops::Deref;
+
+        if let State::Filled {
+            bounds: cached_bounds,
+            geometry,
+        } = self.state.borrow().deref()
+        {
+            if *cached_bounds == bounds {
+                return Geometry::load(geometry);
+            }
+        }
+
+        let mut frame = Frame::new(renderer, bounds);
+        draw_fn(&mut frame);
+
+        let geometry = frame.into_geometry().cache();
+        let result = Geometry::load(&geometry);
+
+        *self.state.borrow_mut() = State::Filled { bounds, geometry };
+
+        result
+    }
+}
+
+impl<Renderer> std::fmt::Debug for Cache<Renderer>
+where
+    Renderer: geometry::Renderer,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let state = self.state.borrow();
+
+        match *state {
+            State::Empty => write!(f, "Cache::Empty"),
+            State::Filled { bounds, .. } => {
+                write!(f, "Cache::Filled {{ bounds: {bounds:?} }}")
+            }
+        }
+    }
+}
+
+impl<Renderer> Default for Cache<Renderer>
+where
+    Renderer: geometry::Renderer,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+enum State<Geometry>
+where
+    Geometry: self::Geometry,
+{
+    Empty,
+    Filled {
+        bounds: Size,
+        geometry: Geometry::Cache,
+    },
+}
+
+impl<T> Geometry for Primitive<T> {
+    type Cache = Arc<Self>;
+
+    fn load(cache: &Arc<Self>) -> Self {
+        Self::Cache {
+            content: cache.clone(),
+        }
+    }
+
+    fn cache(self) -> Arc<Self> {
+        Arc::new(self)
+    }
+}
diff --git a/graphics/src/geometry/frame.rs b/graphics/src/geometry/frame.rs
new file mode 100644
index 00000000..e88c43b0
--- /dev/null
+++ b/graphics/src/geometry/frame.rs
@@ -0,0 +1,208 @@
+use crate::core::{Point, Radians, Rectangle, Size, Vector};
+use crate::geometry::{self, Geometry};
+use crate::geometry::{Fill, Path, Stroke, Text};
+
+pub struct Frame<Renderer>
+where
+    Renderer: geometry::Renderer,
+{
+    raw: Renderer::Frame,
+}
+
+impl<Renderer> Frame<Renderer>
+where
+    Renderer: geometry::Renderer,
+{
+    pub fn new(renderer: &Renderer, size: Size) -> Self {
+        Self {
+            raw: renderer.new_frame(size),
+        }
+    }
+
+    /// Returns the width of the [`Frame`].
+    pub fn width(&self) -> f32 {
+        self.raw.width()
+    }
+
+    /// Returns the height of the [`Frame`].
+    pub fn height(&self) -> f32 {
+        self.raw.height()
+    }
+
+    /// Returns the dimensions of the [`Frame`].
+    pub fn size(&self) -> Size {
+        self.raw.size()
+    }
+
+    /// Returns the coordinate of the center of the [`Frame`].
+    pub fn center(&self) -> Point {
+        self.raw.center()
+    }
+
+    /// Draws the given [`Path`] on the [`Frame`] by filling it with the
+    /// provided style.
+    pub fn fill(&mut self, path: &Path, fill: impl Into<Fill>) {
+        self.raw.fill(path, fill);
+    }
+
+    /// 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(
+        &mut self,
+        top_left: Point,
+        size: Size,
+        fill: impl Into<Fill>,
+    ) {
+        self.raw.fill_rectangle(top_left, size, fill);
+    }
+
+    /// Draws the stroke of the given [`Path`] on the [`Frame`] with the
+    /// provided style.
+    pub fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>) {
+        self.raw.stroke(path, stroke);
+    }
+
+    /// Draws the characters of the given [`Text`] on the [`Frame`], filling
+    /// them with the given color.
+    ///
+    /// __Warning:__ Text currently does not work well with rotations and scale
+    /// transforms! The position will be correctly transformed, but the
+    /// resulting glyphs will not be rotated or scaled properly.
+    ///
+    /// Additionally, all text will be rendered on top of all the layers of
+    /// a `Canvas`. Therefore, it is currently only meant to be used for
+    /// overlays, which is the most common use case.
+    ///
+    /// Support for vectorial text is planned, and should address all these
+    /// limitations.
+    pub fn fill_text(&mut self, text: impl Into<Text>) {
+        self.raw.fill_text(text);
+    }
+
+    /// Stores the current transform of the [`Frame`] and executes the given
+    /// drawing operations, restoring the transform afterwards.
+    ///
+    /// This method is useful to compose transforms and perform drawing
+    /// operations in different coordinate systems.
+    #[inline]
+    pub fn with_save<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R {
+        self.push_transform();
+
+        let result = f(self);
+
+        self.pop_transform();
+
+        result
+    }
+
+    /// Pushes the current transform in the transform stack.
+    pub fn push_transform(&mut self) {
+        self.raw.push_transform();
+    }
+
+    /// Pops a transform from the transform stack and sets it as the current transform.
+    pub fn pop_transform(&mut self) {
+        self.raw.pop_transform();
+    }
+
+    /// Executes the given drawing operations within a [`Rectangle`] region,
+    /// clipping any geometry that overflows its bounds. Any transformations
+    /// performed are local to the provided closure.
+    ///
+    /// This method is useful to perform drawing operations that need to be
+    /// clipped.
+    #[inline]
+    pub fn with_clip<R>(
+        &mut self,
+        region: Rectangle,
+        f: impl FnOnce(&mut Self) -> R,
+    ) -> R {
+        let mut frame = self.draft(region.size());
+
+        let result = f(&mut frame);
+
+        let origin = Point::new(region.x, region.y);
+
+        self.paste(frame, origin);
+
+        result
+    }
+
+    /// Creates a new [`Frame`] with the given [`Size`].
+    ///
+    /// Draw its contents back to this [`Frame`] with [`paste`].
+    ///
+    /// [`paste`]: Self::paste
+    pub fn draft(&mut self, size: Size) -> Self {
+        Self {
+            raw: self.raw.draft(size),
+        }
+    }
+
+    /// Draws the contents of the given [`Frame`] with origin at the given [`Point`].
+    pub fn paste(&mut self, frame: Self, at: Point) {
+        self.raw.paste(frame.raw, at);
+    }
+
+    /// Applies a translation to the current transform of the [`Frame`].
+    pub fn translate(&mut self, translation: Vector) {
+        self.raw.translate(translation);
+    }
+
+    /// Applies a rotation in radians to the current transform of the [`Frame`].
+    pub fn rotate(&mut self, angle: impl Into<Radians>) {
+        self.raw.rotate(angle);
+    }
+
+    /// Applies a uniform scaling to the current transform of the [`Frame`].
+    pub fn scale(&mut self, scale: impl Into<f32>) {
+        self.raw.scale(scale);
+    }
+
+    /// Applies a non-uniform scaling to the current transform of the [`Frame`].
+    pub fn scale_nonuniform(&mut self, scale: impl Into<Vector>) {
+        self.raw.scale_nonuniform(scale);
+    }
+
+    pub fn into_geometry(self) -> Renderer::Geometry {
+        self.raw.into_geometry()
+    }
+}
+
+/// The internal implementation of a [`Frame`].
+///
+/// Analogous to [`Frame`]. See [`Frame`] for the documentation
+/// of each method.
+#[allow(missing_docs)]
+pub trait Backend: Sized {
+    type Geometry: Geometry;
+
+    fn width(&self) -> f32;
+    fn height(&self) -> f32;
+    fn size(&self) -> Size;
+    fn center(&self) -> Point;
+
+    fn push_transform(&mut self);
+    fn pop_transform(&mut self);
+
+    fn translate(&mut self, translation: Vector);
+    fn rotate(&mut self, angle: impl Into<Radians>);
+    fn scale(&mut self, scale: impl Into<f32>);
+    fn scale_nonuniform(&mut self, scale: impl Into<Vector>);
+
+    fn draft(&mut self, size: Size) -> Self;
+    fn paste(&mut self, frame: Self, at: Point);
+
+    fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>);
+
+    fn fill(&mut self, path: &Path, fill: impl Into<Fill>);
+    fn fill_text(&mut self, text: impl Into<Text>);
+    fn fill_rectangle(
+        &mut self,
+        top_left: Point,
+        size: Size,
+        fill: impl Into<Fill>,
+    );
+
+    fn into_geometry(self) -> Self::Geometry;
+}
-- 
cgit 


From 85800c99ab285efd244c0addfdcf3c732a98de1d Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Fri, 22 Mar 2024 01:53:48 +0100
Subject: Fix broken links in documentation

---
 graphics/src/geometry/cache.rs | 33 +++++++++------------------------
 graphics/src/geometry/frame.rs | 11 ++++++++---
 2 files changed, 17 insertions(+), 27 deletions(-)

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/cache.rs b/graphics/src/geometry/cache.rs
index 490e69e2..37d433c2 100644
--- a/graphics/src/geometry/cache.rs
+++ b/graphics/src/geometry/cache.rs
@@ -1,11 +1,10 @@
 use crate::core::Size;
-use crate::geometry::{self, Frame, Geometry};
-use crate::Primitive;
+use crate::geometry::{self, Frame};
+use crate::Cached;
 
 use std::cell::RefCell;
-use std::sync::Arc;
 
-/// A simple cache that stores generated [`Geometry`] to avoid recomputation.
+/// A simple cache that stores generated geometry to avoid recomputation.
 ///
 /// A [`Cache`] will not redraw its geometry unless the dimensions of its layer
 /// change or it is explicitly cleared.
@@ -32,16 +31,16 @@ where
         *self.state.borrow_mut() = State::Empty;
     }
 
-    /// Draws [`Geometry`] using the provided closure and stores it in the
+    /// Draws geometry using the provided closure and stores it in the
     /// [`Cache`].
     ///
     /// The closure will only be called when
     /// - the bounds have changed since the previous draw call.
     /// - the [`Cache`] is empty or has been explicitly cleared.
     ///
-    /// Otherwise, the previously stored [`Geometry`] will be returned. The
+    /// Otherwise, the previously stored geometry will be returned. The
     /// [`Cache`] is not cleared in this case. In other words, it will keep
-    /// returning the stored [`Geometry`] if needed.
+    /// returning the stored geometry if needed.
     pub fn draw(
         &self,
         renderer: &Renderer,
@@ -56,7 +55,7 @@ where
         } = self.state.borrow().deref()
         {
             if *cached_bounds == bounds {
-                return Geometry::load(geometry);
+                return Cached::load(geometry);
             }
         }
 
@@ -64,7 +63,7 @@ where
         draw_fn(&mut frame);
 
         let geometry = frame.into_geometry().cache();
-        let result = Geometry::load(&geometry);
+        let result = Cached::load(&geometry);
 
         *self.state.borrow_mut() = State::Filled { bounds, geometry };
 
@@ -99,7 +98,7 @@ where
 
 enum State<Geometry>
 where
-    Geometry: self::Geometry,
+    Geometry: Cached,
 {
     Empty,
     Filled {
@@ -107,17 +106,3 @@ where
         geometry: Geometry::Cache,
     },
 }
-
-impl<T> Geometry for Primitive<T> {
-    type Cache = Arc<Self>;
-
-    fn load(cache: &Arc<Self>) -> Self {
-        Self::Cache {
-            content: cache.clone(),
-        }
-    }
-
-    fn cache(self) -> Arc<Self> {
-        Arc::new(self)
-    }
-}
diff --git a/graphics/src/geometry/frame.rs b/graphics/src/geometry/frame.rs
index e88c43b0..37e0df38 100644
--- a/graphics/src/geometry/frame.rs
+++ b/graphics/src/geometry/frame.rs
@@ -1,7 +1,10 @@
+//! Draw and generate geometry.
 use crate::core::{Point, Radians, Rectangle, Size, Vector};
-use crate::geometry::{self, Geometry};
-use crate::geometry::{Fill, Path, Stroke, Text};
+use crate::geometry::{self, Fill, Path, Stroke, Text};
+use crate::Cached;
 
+/// The region of a surface that can be used to draw geometry.
+#[allow(missing_debug_implementations)]
 pub struct Frame<Renderer>
 where
     Renderer: geometry::Renderer,
@@ -13,6 +16,7 @@ impl<Renderer> Frame<Renderer>
 where
     Renderer: geometry::Renderer,
 {
+    /// Creates a new [`Frame`] with the given dimensions.
     pub fn new(renderer: &Renderer, size: Size) -> Self {
         Self {
             raw: renderer.new_frame(size),
@@ -164,6 +168,7 @@ where
         self.raw.scale_nonuniform(scale);
     }
 
+    /// Turns the [`Frame`] into its underlying geometry.
     pub fn into_geometry(self) -> Renderer::Geometry {
         self.raw.into_geometry()
     }
@@ -175,7 +180,7 @@ where
 /// of each method.
 #[allow(missing_docs)]
 pub trait Backend: Sized {
-    type Geometry: Geometry;
+    type Geometry: Cached;
 
     fn width(&self) -> f32;
     fn height(&self) -> f32;
-- 
cgit 


From bbafeed13d20f2cbd6fc18b949b34596aa0c6c2e Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Fri, 22 Mar 2024 01:55:28 +0100
Subject: Fix outdated warning in docs of `Frame::fill_text`

---
 graphics/src/geometry/frame.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/frame.rs b/graphics/src/geometry/frame.rs
index 37e0df38..b54fca5d 100644
--- a/graphics/src/geometry/frame.rs
+++ b/graphics/src/geometry/frame.rs
@@ -69,16 +69,9 @@ where
     /// Draws the characters of the given [`Text`] on the [`Frame`], filling
     /// them with the given color.
     ///
-    /// __Warning:__ Text currently does not work well with rotations and scale
-    /// transforms! The position will be correctly transformed, but the
-    /// resulting glyphs will not be rotated or scaled properly.
-    ///
-    /// Additionally, all text will be rendered on top of all the layers of
+    /// __Warning:__ All text will be rendered on top of all the layers of
     /// a `Canvas`. Therefore, it is currently only meant to be used for
     /// overlays, which is the most common use case.
-    ///
-    /// Support for vectorial text is planned, and should address all these
-    /// limitations.
     pub fn fill_text(&mut self, text: impl Into<Text>) {
         self.raw.fill_text(text);
     }
-- 
cgit 


From 1f13a91361258a1607c71f4840a26a6437f88612 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Fri, 22 Mar 2024 05:27:31 +0100
Subject: Make `iced_tiny_skia` optional with a `tiny-skia` feature

---
 graphics/src/geometry/frame.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/frame.rs b/graphics/src/geometry/frame.rs
index b54fca5d..635012d0 100644
--- a/graphics/src/geometry/frame.rs
+++ b/graphics/src/geometry/frame.rs
@@ -1,7 +1,6 @@
 //! Draw and generate geometry.
 use crate::core::{Point, Radians, Rectangle, Size, Vector};
 use crate::geometry::{self, Fill, Path, Stroke, Text};
-use crate::Cached;
 
 /// The region of a surface that can be used to draw geometry.
 #[allow(missing_debug_implementations)]
@@ -173,7 +172,7 @@ where
 /// of each method.
 #[allow(missing_docs)]
 pub trait Backend: Sized {
-    type Geometry: Cached;
+    type Geometry;
 
     fn width(&self) -> f32;
     fn height(&self) -> f32;
-- 
cgit 


From 4f2f40c68b4647f281d34034beb159a41422aa06 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Fri, 22 Mar 2024 05:41:15 +0100
Subject: Fix standalone compilation of `iced_widget` crate

---
 graphics/src/geometry/frame.rs | 46 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/frame.rs b/graphics/src/geometry/frame.rs
index 635012d0..ad35e8ec 100644
--- a/graphics/src/geometry/frame.rs
+++ b/graphics/src/geometry/frame.rs
@@ -203,3 +203,49 @@ pub trait Backend: Sized {
 
     fn into_geometry(self) -> Self::Geometry;
 }
+
+#[cfg(debug_assertions)]
+impl Backend for () {
+    type Geometry = ();
+
+    fn width(&self) -> f32 {
+        0.0
+    }
+
+    fn height(&self) -> f32 {
+        0.0
+    }
+
+    fn size(&self) -> Size {
+        Size::ZERO
+    }
+
+    fn center(&self) -> Point {
+        Point::ORIGIN
+    }
+
+    fn push_transform(&mut self) {}
+    fn pop_transform(&mut self) {}
+
+    fn translate(&mut self, _translation: Vector) {}
+    fn rotate(&mut self, _angle: impl Into<Radians>) {}
+    fn scale(&mut self, _scale: impl Into<f32>) {}
+    fn scale_nonuniform(&mut self, _scale: impl Into<Vector>) {}
+
+    fn draft(&mut self, _size: Size) -> Self {}
+    fn paste(&mut self, _frame: Self, _at: Point) {}
+
+    fn stroke<'a>(&mut self, _path: &Path, _stroke: impl Into<Stroke<'a>>) {}
+
+    fn fill(&mut self, _path: &Path, _fill: impl Into<Fill>) {}
+    fn fill_text(&mut self, _text: impl Into<Text>) {}
+    fn fill_rectangle(
+        &mut self,
+        _top_left: Point,
+        _size: Size,
+        _fill: impl Into<Fill>,
+    ) {
+    }
+
+    fn into_geometry(self) -> Self::Geometry {}
+}
-- 
cgit 


From b05e61f5c8ae61c9f3c7cc08cded53901ebbccfd Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Wed, 3 Apr 2024 21:07:54 +0200
Subject: Redesign `iced_wgpu` layering architecture

---
 graphics/src/geometry/cache.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/cache.rs b/graphics/src/geometry/cache.rs
index 37d433c2..ebbafd14 100644
--- a/graphics/src/geometry/cache.rs
+++ b/graphics/src/geometry/cache.rs
@@ -49,7 +49,7 @@ where
     ) -> Renderer::Geometry {
         use std::ops::Deref;
 
-        if let State::Filled {
+        let previous = if let State::Filled {
             bounds: cached_bounds,
             geometry,
         } = self.state.borrow().deref()
@@ -57,12 +57,16 @@ where
             if *cached_bounds == bounds {
                 return Cached::load(geometry);
             }
-        }
+
+            Some(geometry.clone())
+        } else {
+            None
+        };
 
         let mut frame = Frame::new(renderer, bounds);
         draw_fn(&mut frame);
 
-        let geometry = frame.into_geometry().cache();
+        let geometry = frame.into_geometry().cache(previous);
         let result = Cached::load(&geometry);
 
         *self.state.borrow_mut() = State::Filled { bounds, geometry };
-- 
cgit 


From e2c129c057b521009d451e474a6820601877cf11 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Wed, 3 Apr 2024 23:14:16 +0200
Subject: Fix `geometry::Cache` not reusing previous geometry

---
 graphics/src/geometry/cache.rs | 39 ++++++++++++++++++++++++---------------
 1 file changed, 24 insertions(+), 15 deletions(-)

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/cache.rs b/graphics/src/geometry/cache.rs
index ebbafd14..665e996b 100644
--- a/graphics/src/geometry/cache.rs
+++ b/graphics/src/geometry/cache.rs
@@ -22,13 +22,20 @@ where
     /// Creates a new empty [`Cache`].
     pub fn new() -> Self {
         Cache {
-            state: RefCell::new(State::Empty),
+            state: RefCell::new(State::Empty { previous: None }),
         }
     }
 
     /// Clears the [`Cache`], forcing a redraw the next time it is used.
     pub fn clear(&self) {
-        *self.state.borrow_mut() = State::Empty;
+        use std::ops::Deref;
+
+        let previous = match self.state.borrow().deref() {
+            State::Empty { previous } => previous.clone(),
+            State::Filled { geometry, .. } => Some(geometry.clone()),
+        };
+
+        *self.state.borrow_mut() = State::Empty { previous };
     }
 
     /// Draws geometry using the provided closure and stores it in the
@@ -49,18 +56,18 @@ where
     ) -> Renderer::Geometry {
         use std::ops::Deref;
 
-        let previous = if let State::Filled {
-            bounds: cached_bounds,
-            geometry,
-        } = self.state.borrow().deref()
-        {
-            if *cached_bounds == bounds {
-                return Cached::load(geometry);
-            }
+        let previous = match self.state.borrow().deref() {
+            State::Empty { previous } => previous.clone(),
+            State::Filled {
+                bounds: cached_bounds,
+                geometry,
+            } => {
+                if *cached_bounds == bounds {
+                    return Cached::load(geometry);
+                }
 
-            Some(geometry.clone())
-        } else {
-            None
+                Some(geometry.clone())
+            }
         };
 
         let mut frame = Frame::new(renderer, bounds);
@@ -83,7 +90,7 @@ where
         let state = self.state.borrow();
 
         match *state {
-            State::Empty => write!(f, "Cache::Empty"),
+            State::Empty { .. } => write!(f, "Cache::Empty"),
             State::Filled { bounds, .. } => {
                 write!(f, "Cache::Filled {{ bounds: {bounds:?} }}")
             }
@@ -104,7 +111,9 @@ enum State<Geometry>
 where
     Geometry: Cached,
 {
-    Empty,
+    Empty {
+        previous: Option<Geometry::Cache>,
+    },
     Filled {
         bounds: Size,
         geometry: Geometry::Cache,
-- 
cgit 


From 6d3e1d835e1688fbc58622a03a784ed25ed3f0e1 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Fri, 5 Apr 2024 23:59:21 +0200
Subject: Decouple caching from layering and simplify everything

---
 graphics/src/geometry/frame.rs | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/frame.rs b/graphics/src/geometry/frame.rs
index ad35e8ec..377589d7 100644
--- a/graphics/src/geometry/frame.rs
+++ b/graphics/src/geometry/frame.rs
@@ -113,13 +113,11 @@ where
         region: Rectangle,
         f: impl FnOnce(&mut Self) -> R,
     ) -> R {
-        let mut frame = self.draft(region.size());
+        let mut frame = self.draft(region);
 
         let result = f(&mut frame);
 
-        let origin = Point::new(region.x, region.y);
-
-        self.paste(frame, origin);
+        self.paste(frame, Point::new(region.x, region.y));
 
         result
     }
@@ -129,14 +127,14 @@ where
     /// Draw its contents back to this [`Frame`] with [`paste`].
     ///
     /// [`paste`]: Self::paste
-    pub fn draft(&mut self, size: Size) -> Self {
+    fn draft(&mut self, clip_bounds: Rectangle) -> Self {
         Self {
-            raw: self.raw.draft(size),
+            raw: self.raw.draft(clip_bounds),
         }
     }
 
     /// Draws the contents of the given [`Frame`] with origin at the given [`Point`].
-    pub fn paste(&mut self, frame: Self, at: Point) {
+    fn paste(&mut self, frame: Self, at: Point) {
         self.raw.paste(frame.raw, at);
     }
 
@@ -187,7 +185,7 @@ pub trait Backend: Sized {
     fn scale(&mut self, scale: impl Into<f32>);
     fn scale_nonuniform(&mut self, scale: impl Into<Vector>);
 
-    fn draft(&mut self, size: Size) -> Self;
+    fn draft(&mut self, clip_bounds: Rectangle) -> Self;
     fn paste(&mut self, frame: Self, at: Point);
 
     fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>);
@@ -232,7 +230,7 @@ impl Backend for () {
     fn scale(&mut self, _scale: impl Into<f32>) {}
     fn scale_nonuniform(&mut self, _scale: impl Into<Vector>) {}
 
-    fn draft(&mut self, _size: Size) -> Self {}
+    fn draft(&mut self, _clip_bounds: Rectangle) -> Self {}
     fn paste(&mut self, _frame: Self, _at: Point) {}
 
     fn stroke<'a>(&mut self, _path: &Path, _stroke: impl Into<Stroke<'a>>) {}
-- 
cgit 


From b5b78d505e22cafccb4ecbf57dc61f536ca558ca Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector@hecrj.dev>
Date: Tue, 30 Apr 2024 07:57:54 +0200
Subject: Introduce `canvas::Cache` grouping

Caches with the same `Group` will share their text
atlas!
---
 graphics/src/geometry/cache.rs | 83 ++++++++++++++++++++----------------------
 1 file changed, 39 insertions(+), 44 deletions(-)

(limited to 'graphics/src/geometry')

diff --git a/graphics/src/geometry/cache.rs b/graphics/src/geometry/cache.rs
index 665e996b..d70cee0b 100644
--- a/graphics/src/geometry/cache.rs
+++ b/graphics/src/geometry/cache.rs
@@ -1,8 +1,8 @@
+use crate::cache::{self, Cached};
 use crate::core::Size;
 use crate::geometry::{self, Frame};
-use crate::Cached;
 
-use std::cell::RefCell;
+pub use cache::Group;
 
 /// A simple cache that stores generated geometry to avoid recomputation.
 ///
@@ -12,7 +12,13 @@ pub struct Cache<Renderer>
 where
     Renderer: geometry::Renderer,
 {
-    state: RefCell<State<Renderer::Geometry>>,
+    raw: crate::Cache<Data<<Renderer::Geometry as Cached>::Cache>>,
+}
+
+#[derive(Debug, Clone)]
+struct Data<T> {
+    bounds: Size,
+    geometry: T,
 }
 
 impl<Renderer> Cache<Renderer>
@@ -22,20 +28,25 @@ where
     /// Creates a new empty [`Cache`].
     pub fn new() -> Self {
         Cache {
-            state: RefCell::new(State::Empty { previous: None }),
+            raw: cache::Cache::new(),
+        }
+    }
+
+    /// Creates a new empty [`Cache`] with the given [`Group`].
+    ///
+    /// Caches within the same group may reuse internal rendering storage.
+    ///
+    /// You should generally group caches that are likely to change
+    /// together.
+    pub fn with_group(group: Group) -> Self {
+        Cache {
+            raw: crate::Cache::with_group(group),
         }
     }
 
     /// Clears the [`Cache`], forcing a redraw the next time it is used.
     pub fn clear(&self) {
-        use std::ops::Deref;
-
-        let previous = match self.state.borrow().deref() {
-            State::Empty { previous } => previous.clone(),
-            State::Filled { geometry, .. } => Some(geometry.clone()),
-        };
-
-        *self.state.borrow_mut() = State::Empty { previous };
+        self.raw.clear();
     }
 
     /// Draws geometry using the provided closure and stores it in the
@@ -56,27 +67,30 @@ where
     ) -> Renderer::Geometry {
         use std::ops::Deref;
 
-        let previous = match self.state.borrow().deref() {
-            State::Empty { previous } => previous.clone(),
-            State::Filled {
-                bounds: cached_bounds,
-                geometry,
-            } => {
-                if *cached_bounds == bounds {
-                    return Cached::load(geometry);
+        let state = self.raw.state();
+
+        let previous = match state.borrow().deref() {
+            cache::State::Empty { previous } => {
+                previous.as_ref().map(|data| data.geometry.clone())
+            }
+            cache::State::Filled { current } => {
+                if current.bounds == bounds {
+                    return Cached::load(&current.geometry);
                 }
 
-                Some(geometry.clone())
+                Some(current.geometry.clone())
             }
         };
 
         let mut frame = Frame::new(renderer, bounds);
         draw_fn(&mut frame);
 
-        let geometry = frame.into_geometry().cache(previous);
+        let geometry = frame.into_geometry().cache(self.raw.group(), previous);
         let result = Cached::load(&geometry);
 
-        *self.state.borrow_mut() = State::Filled { bounds, geometry };
+        *state.borrow_mut() = cache::State::Filled {
+            current: Data { bounds, geometry },
+        };
 
         result
     }
@@ -85,16 +99,10 @@ where
 impl<Renderer> std::fmt::Debug for Cache<Renderer>
 where
     Renderer: geometry::Renderer,
+    <Renderer::Geometry as Cached>::Cache: std::fmt::Debug,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let state = self.state.borrow();
-
-        match *state {
-            State::Empty { .. } => write!(f, "Cache::Empty"),
-            State::Filled { bounds, .. } => {
-                write!(f, "Cache::Filled {{ bounds: {bounds:?} }}")
-            }
-        }
+        write!(f, "{:?}", &self.raw)
     }
 }
 
@@ -106,16 +114,3 @@ where
         Self::new()
     }
 }
-
-enum State<Geometry>
-where
-    Geometry: Cached,
-{
-    Empty {
-        previous: Option<Geometry::Cache>,
-    },
-    Filled {
-        bounds: Size,
-        geometry: Geometry::Cache,
-    },
-}
-- 
cgit