Upgrade to new vello WIP

Signed-off-by: Nico Burns <nico@nicoburns.com>

Author: nicoburns

Cargo.lock

@@ -79,8 +79,8 @@ wasm-bindgen-futures = "0.4"
 # Dev-dependencies
 winit = { version = "0.30.2", features = ["rwh_06"] }
 
-# [patch.crates-io]
-# vello = { path = "../vello/vello" }
-# vello_cpu = { path = "../vello/sparse_strips/vello_cpu" }
-# vello_hybrid = { path = "../vello/sparse_strips/vello_hybrid" }
-# vello_common = { path = "../vello/sparse_strips/vello_common" }
+[patch.crates-io]
+vello = { path = "../vello/vello" }
+vello_cpu = { path = "../vello/sparse_strips/vello_cpu" }
+vello_hybrid = { path = "../vello/sparse_strips/vello_hybrid" }
+vello_common = { path = "../vello/sparse_strips/vello_common" }

Cargo.toml

@@ -234,7 +234,7 @@ pub trait PaintScene: RenderContext {
         brush_alpha: f32,
         transform: Affine,
         glyph_transform: Option<Affine>,
-        glyphs: impl Iterator<Item = Glyph>,
+        glyphs: impl Iterator<Item = Glyph> + Clone,
     );
 
     /// Draw a rounded rectangle blurred with a gaussian filter.

crates/anyrender/src/lib.rs

@@ -1,7 +1,7 @@
 use crate::VelloCpuScenePainter;
 use anyrender::{ImageRenderer, RenderContext as AnyRenderContext};
 use debug_timer::debug_timer;
-use vello_cpu::{RenderContext, RenderMode};
+use vello_cpu::{RenderContext, RenderMode, Resources};
 
 pub struct VelloCpuImageRenderer {
     scene: VelloCpuScenePainter,
@@ -13,16 +13,19 @@ impl ImageRenderer for VelloCpuImageRenderer {
 
     fn new(width: u32, height: u32) -> Self {
         Self {
-            scene: VelloCpuScenePainter(RenderContext::new(width as u16, height as u16)),
+            scene: VelloCpuScenePainter {
+                render_ctx: RenderContext::new(width as u16, height as u16),
+                resources: Resources::new(),
+            },
         }
     }
 
     fn resize(&mut self, width: u32, height: u32) {
-        self.scene.0 = RenderContext::new(width as u16, height as u16);
+        self.scene.render_ctx = RenderContext::new(width as u16, height as u16);
     }
 
     fn reset(&mut self) {
-        self.scene.0.reset();
+        self.scene.render_ctx.reset();
     }
 
     fn render<F: FnOnce(&mut Self::ScenePainter<'_>)>(&mut self, draw_fn: F, buffer: &mut [u8]) {
@@ -31,13 +34,14 @@ impl ImageRenderer for VelloCpuImageRenderer {
         draw_fn(&mut self.scene);
         timer.record_time("cmds");
 
-        self.scene.0.flush();
+        self.scene.render_ctx.flush();
         timer.record_time("flush");
 
-        self.scene.0.render_to_buffer(
+        self.scene.render_ctx.render_to_buffer(
+            &mut self.scene.resources,
             buffer,
-            self.scene.0.width(),
-            self.scene.0.height(),
+            self.scene.render_ctx.width(),
+            self.scene.render_ctx.height(),
             RenderMode::OptimizeSpeed,
         );
         timer.record_time("render");
@@ -50,8 +54,8 @@ impl ImageRenderer for VelloCpuImageRenderer {
         draw_fn: F,
         buffer: &mut Vec<u8>,
     ) {
-        let width = self.scene.0.width();
-        let height = self.scene.0.height();
+        let width = self.scene.render_ctx.width();
+        let height = self.scene.render_ctx.height();
         buffer.resize(width as usize * height as usize * 4, 0);
         self.render(draw_fn, buffer);
     }

crates/anyrender_vello_cpu/src/image_renderer.rs

@@ -36,20 +36,23 @@ fn convert_image_cached(image: &peniko::ImageData) -> ImageSource {
         .clone()
 }
 
-pub struct VelloCpuScenePainter(pub vello_cpu::RenderContext);
+pub struct VelloCpuScenePainter {
+    pub render_ctx: vello_cpu::RenderContext,
+    pub resources: vello_cpu::Resources,
+}
 
 impl VelloCpuScenePainter {
-    pub fn finish(self) -> Pixmap {
-        let mut pixmap = Pixmap::new(self.0.width(), self.0.height());
-        self.0.render_to_pixmap(&mut pixmap);
+    pub fn finish(mut self) -> Pixmap {
+        let mut pixmap = Pixmap::new(self.render_ctx.width(), self.render_ctx.height());
+        self.render_ctx.render_to_pixmap(&mut self.resources, &mut pixmap);
         pixmap
     }
 }
 
 impl RenderContext for VelloCpuScenePainter {}
 impl PaintScene for VelloCpuScenePainter {
     fn reset(&mut self) {
-        self.0.reset();
+        self.render_ctx.reset();
     }
 
     fn push_layer(
@@ -59,8 +62,8 @@ impl PaintScene for VelloCpuScenePainter {
         transform: Affine,
         clip: &impl Shape,
     ) {
-        self.0.set_transform(transform);
-        self.0.push_layer(
+        self.render_ctx.set_transform(transform);
+        self.render_ctx.push_layer(
             Some(&clip.into_path(DEFAULT_TOLERANCE)),
             Some(blend.into()),
             Some(alpha),
@@ -70,12 +73,13 @@ impl PaintScene for VelloCpuScenePainter {
     }
 
     fn push_clip_layer(&mut self, transform: Affine, clip: &impl Shape) {
-        self.0.set_transform(transform);
-        self.0.push_clip_layer(&clip.into_path(DEFAULT_TOLERANCE));
+        self.render_ctx.set_transform(transform);
+        self.render_ctx
+            .push_clip_layer(&clip.into_path(DEFAULT_TOLERANCE));
     }
 
     fn pop_layer(&mut self) {
-        self.0.pop_layer();
+        self.render_ctx.pop_layer();
     }
 
     fn stroke<'a>(
@@ -86,13 +90,14 @@ impl PaintScene for VelloCpuScenePainter {
         brush_transform: Option<Affine>,
         shape: &impl Shape,
     ) {
-        self.0.set_transform(transform);
-        self.0.set_stroke(style.clone());
-        self.0
+        self.render_ctx.set_transform(transform);
+        self.render_ctx.set_stroke(style.clone());
+        self.render_ctx
             .set_paint(anyrender_paint_to_vello_cpu_paint(paint.into()));
-        self.0
+        self.render_ctx
             .set_paint_transform(brush_transform.unwrap_or(Affine::IDENTITY));
-        self.0.stroke_path(&shape.into_path(DEFAULT_TOLERANCE));
+        self.render_ctx
+            .stroke_path(&shape.into_path(DEFAULT_TOLERANCE));
     }
 
     fn fill<'a>(
@@ -103,13 +108,14 @@ impl PaintScene for VelloCpuScenePainter {
         brush_transform: Option<Affine>,
         shape: &impl Shape,
     ) {
-        self.0.set_transform(transform);
-        self.0.set_fill_rule(style);
-        self.0
+        self.render_ctx.set_transform(transform);
+        self.render_ctx.set_fill_rule(style);
+        self.render_ctx
             .set_paint(anyrender_paint_to_vello_cpu_paint(paint.into()));
-        self.0
+        self.render_ctx
             .set_paint_transform(brush_transform.unwrap_or(Affine::IDENTITY));
-        self.0.fill_path(&shape.into_path(DEFAULT_TOLERANCE));
+        self.render_ctx
+            .fill_path(&shape.into_path(DEFAULT_TOLERANCE));
     }
 
     fn draw_glyphs<'a, 's: 'a>(
@@ -123,10 +129,10 @@ impl PaintScene for VelloCpuScenePainter {
         _brush_alpha: f32,
         transform: Affine,
         glyph_transform: Option<Affine>,
-        glyphs: impl Iterator<Item = anyrender::Glyph>,
+        glyphs: impl Iterator<Item = anyrender::Glyph> + Clone,
     ) {
-        self.0.set_transform(transform);
-        self.0
+        self.render_ctx.set_transform(transform);
+        self.render_ctx
             .set_paint(anyrender_paint_to_vello_cpu_paint(paint.into()));
 
         fn into_vello_cpu_glyph(g: anyrender::Glyph) -> vello_cpu::Glyph {
@@ -140,19 +146,19 @@ impl PaintScene for VelloCpuScenePainter {
         let style: StyleRef<'a> = style.into();
         match style {
             StyleRef::Fill(fill) => {
-                self.0.set_fill_rule(fill);
-                self.0
-                    .glyph_run(font)
+                self.render_ctx.set_fill_rule(fill);
+                self.render_ctx
+                    .glyph_run(&mut self.resources, font)
                     .font_size(font_size)
                     .hint(hint)
                     .normalized_coords(normalized_coords)
                     .glyph_transform(glyph_transform.unwrap_or_default())
                     .fill_glyphs(glyphs.map(into_vello_cpu_glyph));
             }
             StyleRef::Stroke(stroke) => {
-                self.0.set_stroke(stroke.clone());
-                self.0
-                    .glyph_run(font)
+                self.render_ctx.set_stroke(stroke.clone());
+                self.render_ctx
+                    .glyph_run(&mut self.resources, font)
                     .font_size(font_size)
                     .hint(hint)
                     .normalized_coords(normalized_coords)
@@ -169,9 +175,9 @@ impl PaintScene for VelloCpuScenePainter {
         radius: f64,
         std_dev: f64,
     ) {
-        self.0.set_transform(transform);
-        self.0.set_paint(PaintType::Solid(color));
-        self.0
+        self.render_ctx.set_transform(transform);
+        self.render_ctx.set_paint(PaintType::Solid(color));
+        self.render_ctx
             .fill_blurred_rounded_rect(&rect, radius as f32, std_dev as f32);
     }
 }