Introduce draw_mesh_cache in mesh::Renderer

Author: hecrj

examples/geometry/src/main.rs

@@ -100,7 +100,7 @@ mod rainbow {
 
             let mesh = Mesh::Solid {
                 buffers: mesh::Indexed {
-                    vertices: [
+                    vertices: vec![
                         SolidVertex2D {
                             position: posn_center,
                             color: color::pack([1.0, 1.0, 1.0, 1.0]),
@@ -137,9 +137,8 @@ mod rainbow {
                             position: posn_l,
                             color: color::pack(color_v),
                         },
-                    ]
-                    .into(),
-                    indices: [
+                    ],
+                    indices: vec![
                         0, 1, 2, // TL
                         0, 2, 3, // T
                         0, 3, 4, // TR
@@ -148,8 +147,7 @@ mod rainbow {
                         0, 6, 7, // B
                         0, 7, 8, // BL
                         0, 8, 1, // L
-                    ]
-                    .into(),
+                    ],
                 },
                 transformation: Transformation::IDENTITY,
                 clip_bounds: Rectangle::INFINITE,

graphics/src/mesh.rs

@@ -5,7 +5,8 @@ use crate::gradient;
 
 use bytemuck::{Pod, Zeroable};
 
-use std::sync::Arc;
+use std::sync::atomic::{self, AtomicU64};
+use std::sync::{Arc, Weak};
 
 /// A low-level primitive to render a mesh of triangles.
 #[derive(Debug, Clone, PartialEq)]
@@ -72,12 +73,12 @@ impl Mesh {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Indexed<T> {
     /// The vertices of the mesh
-    pub vertices: Arc<[T]>,
+    pub vertices: Vec<T>,
 
     /// The list of vertex indices that defines the triangles of the mesh.
     ///
     /// Therefore, this list should always have a length that is a multiple of 3.
-    pub indices: Arc<[u32]>,
+    pub indices: Vec<u32>,
 }
 
 /// A two-dimensional vertex with a color.
@@ -143,8 +144,67 @@ pub fn attribute_count_of(meshes: &[Mesh]) -> AttributeCount {
         })
 }
 
+/// A cache of multiple meshes.
+#[derive(Debug, Clone)]
+pub struct Cache {
+    id: Id,
+    batch: Arc<[Mesh]>,
+    version: usize,
+}
+
+/// The unique id of a [`Cache`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Id(u64);
+
+impl Cache {
+    /// Creates a new [`Cache`] for the given meshes.
+    pub fn new(meshes: Arc<[Mesh]>) -> Self {
+        static NEXT_ID: AtomicU64 = AtomicU64::new(0);
+
+        Self {
+            id: Id(NEXT_ID.fetch_add(1, atomic::Ordering::Relaxed)),
+            batch: meshes,
+            version: 0,
+        }
+    }
+
+    /// Returns the [`Id`] of the [`Cache`].
+    pub fn id(&self) -> Id {
+        self.id
+    }
+
+    /// Returns the current version of the [`Cache`].
+    pub fn version(&self) -> usize {
+        self.version
+    }
+
+    /// Returns the batch of meshes in the [`Cache`].
+    pub fn batch(&self) -> &[Mesh] {
+        &self.batch
+    }
+
+    /// Returns a [`Weak`] reference to the contents of the [`Cache`].
+    pub fn downgrade(&self) -> Weak<[Mesh]> {
+        Arc::downgrade(&self.batch)
+    }
+
+    /// Returns true if the [`Cache`] is empty.
+    pub fn is_empty(&self) -> bool {
+        self.batch.is_empty()
+    }
+
+    /// Updates the [`Cache`] with the given meshes.
+    pub fn update(&mut self, meshes: Arc<[Mesh]>) {
+        self.batch = meshes;
+        self.version += 1;
+    }
+}
+
 /// A renderer capable of drawing a [`Mesh`].
 pub trait Renderer {
     /// Draws the given [`Mesh`].
     fn draw_mesh(&mut self, mesh: Mesh);
+
+    /// Draws the given [`Cache`].
+    fn draw_mesh_cache(&mut self, cache: Cache);
 }

renderer/src/fallback.rs

@@ -224,6 +224,10 @@ where
     fn draw_mesh(&mut self, mesh: graphics::Mesh) {
         delegate!(self, renderer, renderer.draw_mesh(mesh));
     }
+
+    fn draw_mesh_cache(&mut self, cache: mesh::Cache) {
+        delegate!(self, renderer, renderer.draw_mesh_cache(cache));
+    }
 }
 
 /// A compositor `A` with a fallback strategy `B`.

tiny_skia/src/lib.rs

@@ -373,6 +373,10 @@ impl graphics::mesh::Renderer for Renderer {
     fn draw_mesh(&mut self, _mesh: graphics::Mesh) {
         log::warn!("iced_tiny_skia does not support drawing meshes");
     }
+
+    fn draw_mesh_cache(&mut self, _cache: iced_graphics::mesh::Cache) {
+        log::warn!("iced_tiny_skia does not support drawing meshes");
+    }
 }
 
 #[cfg(feature = "image")]

wgpu/src/geometry.rs

@@ -13,7 +13,6 @@ use crate::graphics::gradient::{self, Gradient};
 use crate::graphics::mesh::{self, Mesh};
 use crate::graphics::{Image, Text};
 use crate::text;
-use crate::triangle;
 
 use lyon::geom::euclid;
 use lyon::tessellation;
@@ -33,7 +32,7 @@ pub enum Geometry {
 
 #[derive(Debug, Clone, Default)]
 pub struct Cache {
-    pub meshes: Option<triangle::Cache>,
+    pub meshes: Option<mesh::Cache>,
     pub images: Option<Arc<[Image]>>,
     pub text: Option<text::Cache>,
 }
@@ -62,11 +61,17 @@ impl Cached for Geometry {
                     Some(Arc::from(images))
                 };
 
+                let meshes = Arc::from(meshes);
+
                 if let Some(mut previous) = previous {
                     if let Some(cache) = &mut previous.meshes {
                         cache.update(meshes);
                     } else {
-                        previous.meshes = triangle::Cache::new(meshes);
+                        previous.meshes = if meshes.is_empty() {
+                            None
+                        } else {
+                            Some(mesh::Cache::new(meshes))
+                        };
                     }
 
                     if let Some(cache) = &mut previous.text {
@@ -80,7 +85,11 @@ impl Cached for Geometry {
                     previous
                 } else {
                     Cache {
-                        meshes: triangle::Cache::new(meshes),
+                        meshes: if meshes.is_empty() {
+                            None
+                        } else {
+                            Some(mesh::Cache::new(meshes))
+                        },
                         images,
                         text: text::Cache::new(group, text),
                     }
@@ -547,8 +556,8 @@ impl BufferStack {
                 Buffer::Solid(buffer) if !buffer.indices.is_empty() => {
                     Some(Mesh::Solid {
                         buffers: mesh::Indexed {
-                            vertices: buffer.vertices.into(),
-                            indices: buffer.indices.into(),
+                            vertices: buffer.vertices,
+                            indices: buffer.indices,
                         },
                         clip_bounds,
                         transformation: Transformation::IDENTITY,
@@ -557,8 +566,8 @@ impl BufferStack {
                 Buffer::Gradient(buffer) if !buffer.indices.is_empty() => {
                     Some(Mesh::Gradient {
                         buffers: mesh::Indexed {
-                            vertices: buffer.vertices.into(),
-                            indices: buffer.indices.into(),
+                            vertices: buffer.vertices,
+                            indices: buffer.indices,
                         },
                         clip_bounds,
                         transformation: Transformation::IDENTITY,

wgpu/src/layer.rs

@@ -5,6 +5,7 @@ use crate::graphics;
 use crate::graphics::Mesh;
 use crate::graphics::color;
 use crate::graphics::layer;
+use crate::graphics::mesh;
 use crate::graphics::text::{Editor, Paragraph};
 use crate::image::{self, Image};
 use crate::primitive::{self, Primitive};
@@ -230,7 +231,7 @@ impl Layer {
 
     pub fn draw_mesh_cache(
         &mut self,
-        cache: triangle::Cache,
+        cache: mesh::Cache,
         transformation: Transformation,
     ) {
         self.flush_meshes();

wgpu/src/lib.rs

@@ -65,6 +65,7 @@ use crate::core::renderer;
 use crate::core::{
     Background, Color, Font, Pixels, Point, Rectangle, Size, Transformation,
 };
+use crate::graphics::mesh;
 use crate::graphics::text::{Editor, Paragraph};
 use crate::graphics::{Shell, Viewport};
 
@@ -845,6 +846,11 @@ impl graphics::mesh::Renderer for Renderer {
         let (layer, transformation) = self.layers.current_mut();
         layer.draw_mesh(mesh, transformation);
     }
+
+    fn draw_mesh_cache(&mut self, cache: mesh::Cache) {
+        let (layer, transformation) = self.layers.current_mut();
+        layer.draw_mesh_cache(cache, transformation);
+    }
 }
 
 #[cfg(feature = "geometry")]