2 files changed, 62 insertions, 14 deletions

diff --git a/renderer/src/geometry.rs b/renderer/src/geometry.rs
index 26e2fed0..04b5d9e6 100644
--- a/renderer/src/geometry.rs
+++ b/renderer/src/geometry.rs
@@ -3,8 +3,8 @@ mod cache;
 pub use cache::Cache;
 
 use crate::core::{Point, Rectangle, Size, Vector};
-use crate::graphics::geometry::{Fill, Geometry, Path, Stroke, Text};
-use crate::Backend;
+use crate::graphics::geometry::{Fill, Path, Stroke, Text};
+use crate::Renderer;
 
 pub enum Frame {
     TinySkia(iced_tiny_skia::geometry::Frame),
@@ -12,6 +12,12 @@ pub enum Frame {
     Wgpu(iced_wgpu::geometry::Frame),
 }
 
+pub enum Geometry {
+    TinySkia(iced_tiny_skia::Primitive),
+    #[cfg(feature = "wgpu")]
+    Wgpu(iced_wgpu::Primitive),
+}
+
 macro_rules! delegate {
     ($frame:expr, $name:ident, $body:expr) => {
         match $frame {
@@ -23,13 +29,13 @@ macro_rules! delegate {
 }
 
 impl Frame {
-    pub fn new<Theme>(renderer: &crate::Renderer<Theme>, size: Size) -> Self {
-        match renderer.backend() {
-            Backend::TinySkia(_) => {
+    pub fn new<Theme>(renderer: &Renderer<Theme>, size: Size) -> Self {
+        match renderer {
+            Renderer::TinySkia(_) => {
                 Frame::TinySkia(iced_tiny_skia::geometry::Frame::new(size))
             }
             #[cfg(feature = "wgpu")]
-            Backend::Wgpu(_) => {
+            Renderer::Wgpu(_) => {
                 Frame::Wgpu(iced_wgpu::geometry::Frame::new(size))
             }
         }
@@ -169,6 +175,10 @@ impl Frame {
     }
 
     pub fn into_geometry(self) -> Geometry {
-        Geometry(delegate!(self, frame, frame.into_primitive()))
+        match self {
+            Self::TinySkia(frame) => Geometry::TinySkia(frame.into_primitive()),
+            #[cfg(feature = "wgpu")]
+            Self::Wgpu(frame) => Geometry::Wgpu(frame.into_primitive()),
+        }
     }
 }
diff --git a/renderer/src/geometry/cache.rs b/renderer/src/geometry/cache.rs
index 2a3534d0..d82e7f69 100644
--- a/renderer/src/geometry/cache.rs
+++ b/renderer/src/geometry/cache.rs
@@ -1,6 +1,5 @@
 use crate::core::Size;
 use crate::geometry::{Frame, Geometry};
-use crate::graphics::Primitive;
 use crate::Renderer;
 
 use std::cell::RefCell;
@@ -21,10 +20,17 @@ enum State {
     Empty,
     Filled {
         bounds: Size,
-        primitive: Arc<Primitive>,
+        primitive: Internal,
     },
 }
 
+#[derive(Debug, Clone)]
+enum Internal {
+    TinySkia(Arc<iced_tiny_skia::Primitive>),
+    #[cfg(feature = "wgpu")]
+    Wgpu(Arc<iced_wgpu::Primitive>),
+}
+
 impl Cache {
     /// Creates a new empty [`Cache`].
     pub fn new() -> Self {
@@ -62,9 +68,21 @@ impl Cache {
         } = self.state.borrow().deref()
         {
             if *cached_bounds == bounds {
-                return Geometry(Primitive::Cache {
-                    content: primitive.clone(),
-                });
+                match primitive {
+                    Internal::TinySkia(primitive) => {
+                        return Geometry::TinySkia(
+                            iced_tiny_skia::Primitive::Cache {
+                                content: primitive.clone(),
+                            },
+                        );
+                    }
+                    #[cfg(feature = "wgpu")]
+                    Internal::Wgpu(primitive) => {
+                        return Geometry::Wgpu(iced_wgpu::Primitive::Cache {
+                            content: primitive.clone(),
+                        });
+                    }
+                }
             }
         }
 
@@ -74,7 +92,15 @@ impl Cache {
         let primitive = {
             let geometry = frame.into_geometry();
 
-            Arc::new(geometry.0)
+            match geometry {
+                Geometry::TinySkia(primitive) => {
+                    Internal::TinySkia(Arc::new(primitive))
+                }
+                #[cfg(feature = "wgpu")]
+                Geometry::Wgpu(primitive) => {
+                    Internal::Wgpu(Arc::new(primitive))
+                }
+            }
         };
 
         *self.state.borrow_mut() = State::Filled {
@@ -82,6 +108,18 @@ impl Cache {
             primitive: primitive.clone(),
         };
 
-        Geometry(Primitive::Cache { content: primitive })
+        match primitive {
+            Internal::TinySkia(primitive) => {
+                Geometry::TinySkia(iced_tiny_skia::Primitive::Cache {
+                    content: primitive,
+                })
+            }
+            #[cfg(feature = "wgpu")]
+            Internal::Wgpu(primitive) => {
+                Geometry::Wgpu(iced_wgpu::Primitive::Cache {
+                    content: primitive,
+                })
+            }
+        }
     }
 }