vello_cpu: Support custom atlas size

Author: fundon

sparse_strips/vello_common/src/image_cache.rs

@@ -52,6 +52,12 @@ pub struct ImageCache {
     free_idxs: Vec<usize>,
 }
 
+impl Default for ImageCache {
+    fn default() -> Self {
+        Self::new_with_config(AtlasConfig::default())
+    }
+}
+
 impl core::fmt::Debug for ImageCache {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let atlas_stats = self.atlas_manager.atlas_stats();

sparse_strips/vello_cpu/src/render.rs

@@ -10,6 +10,11 @@ use crate::text::{GlyphAtlasResources, GlyphRunBuilder};
 #[cfg(feature = "text")]
 use glifo::GlyphPrepCache;
 
+#[cfg(feature = "text")]
+use vello_common::image_cache::ImageCache;
+#[cfg(feature = "text")]
+use vello_common::multi_atlas::AtlasConfig;
+
 #[cfg(feature = "multithreading")]
 use crate::dispatch::multi_threaded::MultiThreadedDispatcher;
 use crate::dispatch::single_threaded::SingleThreadedDispatcher;
@@ -32,8 +37,6 @@ use vello_common::pixmap::Pixmap;
 use vello_common::render_state::RenderState;
 use vello_common::util::is_axis_aligned;
 
-#[cfg(feature = "text")]
-pub(crate) const DEFAULT_GLYPH_ATLAS_SIZE: u16 = 4096;
 // Why do we need this? The reason is that the way uploaded images work in Vello Hybrid
 // is different from how they work in Vello CPU.
 //
@@ -59,6 +62,8 @@ pub(crate) const ATLAS_IMAGE_ID_BASE: u32 = u32::MAX / 2;
 pub struct Resources {
     pub(crate) image_registry: ImageRegistry,
     #[cfg(feature = "text")]
+    pub(crate) image_cache: ImageCache,
+    #[cfg(feature = "text")]
     pub(crate) glyph_prep_cache: GlyphPrepCache,
     // Will be initialized lazily on first use.
     #[cfg(feature = "text")]
@@ -71,6 +76,13 @@ impl Resources {
         Self::default()
     }
 
+    /// Returns this [`Resources`] with a new [`AtlasConfig`].
+    #[cfg(feature = "text")]
+    pub fn with_atlas_config(mut self, atlas_config: AtlasConfig) -> Self {
+        self.image_cache = ImageCache::new_with_config(atlas_config);
+        self
+    }
+
     pub(crate) fn before_render(&mut self) {
         #[cfg(feature = "text")]
         self.prepare_glyph_cache();
@@ -845,7 +857,7 @@ mod tests {
     #[cfg(feature = "text")]
     use alloc::sync::Arc;
     #[cfg(feature = "text")]
-    use glifo::Glyph;
+    use glifo::{AtlasConfig, Glyph};
     use vello_common::kurbo::{Rect, Shape};
     use vello_common::tile::Tile;
 
@@ -914,4 +926,39 @@ mod tests {
 
         assert!(resources.glyph_resources.is_some());
     }
+
+    #[cfg(feature = "text")]
+    #[test]
+    fn custom_atlas_size() {
+        const ROBOTO_FONT: &[u8] =
+            include_bytes!("../../../examples/assets/roboto/Roboto-Regular.ttf");
+
+        let font = FontData::new(Blob::new(Arc::new(ROBOTO_FONT)), 0);
+        let glyphs = [Glyph {
+            id: 1,
+            x: 0.0,
+            y: 0.0,
+        }];
+
+        let mut resources = crate::Resources::new().with_atlas_config(AtlasConfig {
+            atlas_size: (100, 100),
+            ..AtlasConfig::default()
+        });
+        let mut ctx = RenderContext::new(100, 100);
+
+        ctx.glyph_run(&mut resources, &font)
+            .atlas_cache(true)
+            .fill_glyphs(glyphs.into_iter());
+
+        resources.before_render();
+
+        resources.after_render();
+
+        assert_eq!(resources.image_cache.atlas_count(), 1);
+
+        let stats = resources.image_cache.atlas_manager().atlas_stats()[0].1;
+        assert!(stats.allocated_area > 0);
+        assert_eq!(stats.total_area, 100 * 100);
+        assert_eq!(stats.allocated_count, 1);
+    }
 }

sparse_strips/vello_cpu/src/text.rs

@@ -11,7 +11,7 @@
 //! [`Arc<Pixmap>`]s here, so the CPU renderer can read pixels directly without
 //! any GPU upload step.
 
-use crate::render::{ATLAS_IMAGE_ID_BASE, DEFAULT_GLYPH_ATLAS_SIZE};
+use crate::render::ATLAS_IMAGE_ID_BASE;
 use crate::{
     Image, ImageSource, PaintType, Pixmap, RenderContext, RenderMode, RenderSettings, Resources,
     color, kurbo, peniko,
@@ -22,9 +22,7 @@ use alloc::vec::Vec;
 use color::palette::css::BLACK;
 use core::fmt::Debug;
 use core::ops::RangeInclusive;
-use glifo::atlas::{
-    AtlasConfig, AtlasSlot, GlyphAtlas, GlyphCacheConfig, ImageCache, PendingClearRect,
-};
+use glifo::atlas::{AtlasSlot, GlyphAtlas, GlyphCacheConfig, ImageCache, PendingClearRect};
 use glifo::{AtlasCacher, DrawSink, GlyphRunBackend};
 use glifo::{Glyph, renderer};
 use kurbo::{Affine, BezPath, Rect};
@@ -40,7 +38,6 @@ fn atlas_page_image_id(page_index: u32) -> ImageId {
 #[derive(Debug)]
 pub(crate) struct GlyphAtlasResources {
     pub(crate) glyph_atlas: GlyphAtlas,
-    pub(crate) image_cache: ImageCache,
     pub(crate) glyph_renderer: Box<RenderContext>,
     /// One `Pixmap` per atlas page, grown on demand.
     // It's a bit annoying to have this in an `Arc`, but it needs to be this way. During fine
@@ -68,7 +65,6 @@ impl GlyphAtlasResources {
     ) -> Self {
         Self {
             glyph_atlas: GlyphAtlas::with_config(eviction_config),
-            image_cache: ImageCache::new_with_config(AtlasConfig::default()),
             glyph_renderer: Box::new(RenderContext::new_with(
                 page_width,
                 page_height,
@@ -84,8 +80,8 @@ impl GlyphAtlasResources {
         }
     }
 
-    pub(crate) fn maintain(&mut self) {
-        self.glyph_atlas.maintain(&mut self.image_cache);
+    pub(crate) fn maintain(&mut self, image_cache: &mut ImageCache) {
+        self.glyph_atlas.maintain(image_cache);
     }
 }
 
@@ -112,7 +108,7 @@ impl Resources {
         self.glyph_prep_cache.maintain();
 
         if let Some(glyph_resources) = self.glyph_resources.as_mut() {
-            glyph_resources.maintain();
+            glyph_resources.maintain(&mut self.image_cache);
             let page_count = glyph_resources.pixmaps.len();
             for page_index in 0..page_count {
                 self.image_registry.destroy_atlas_page(page_index as u32);
@@ -123,9 +119,17 @@ impl Resources {
 
     fn ensure_glyph_resources(&mut self, level: Level, render_mode: RenderMode) {
         if self.glyph_resources.is_none() {
+            #[expect(
+                clippy::cast_possible_truncation,
+                reason = "atlas dimensions are configured to fit in u16"
+            )]
+            let (atlas_width, atlas_height) = {
+                let (width, height) = self.image_cache.atlas_manager().config().atlas_size;
+                (width as u16, height as u16)
+            };
             self.glyph_resources = Some(GlyphAtlasResources::with_config(
-                DEFAULT_GLYPH_ATLAS_SIZE,
-                DEFAULT_GLYPH_ATLAS_SIZE,
+                atlas_width,
+                atlas_height,
                 level,
                 render_mode,
                 GlyphCacheConfig::default(),
@@ -231,7 +235,7 @@ impl<'a> CpuGlyphRunBackend<'a> {
                 .expect("glyph atlas resources must exist after initialization");
             AtlasCacher::Enabled(
                 &mut glyph_resources.glyph_atlas,
-                &mut glyph_resources.image_cache,
+                &mut self.resources.image_cache,
             )
         } else {
             AtlasCacher::Disabled