2 files changed, 33 insertions, 22 deletions

diff --git a/graphics/src/geometry/cache.rs b/graphics/src/geometry/cache.rs
index 37d433c2..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,20 +56,24 @@ where
     ) -> Renderer::Geometry {
         use std::ops::Deref;
 
-        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())
             }
-        }
+        };
 
         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 };
@@ -79,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:?} }}")
             }
@@ -100,7 +111,9 @@ enum State<Geometry>
 where
     Geometry: Cached,
 {
-    Empty,
+    Empty {
+        previous: Option<Geometry::Cache>,
+    },
     Filled {
         bounds: Size,
         geometry: Geometry::Cache,
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>>) {}