Expose Hybrid Image Manager

.github/workflows/ci.yml

@@ -74,6 +74,22 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - run: cargo doc
 
+  check-wasm:
+    name: "Check [wasm32 + webgl]"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: "wasm32-unknown-unknown"
+          cache-all-crates: "true"
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+      - run: cargo clippy -p anyrender_vello_hybrid --target wasm32-unknown-unknown --features webgl -- -D warnings
+
   # just cargo check for now
   matrix_test:
     runs-on: ${{ matrix.platform.os }}

crates/anyrender_vello_hybrid/Cargo.toml

@@ -10,6 +10,7 @@ edition.workspace = true
 
 [features]
 log_frame_times = ["debug_timer/enable"]
+webgl = ["vello_hybrid/webgl"]
 
 [dependencies]
 anyrender = { workspace = true }

crates/anyrender_vello_hybrid/src/lib.rs

@@ -2,7 +2,12 @@
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 mod scene;
+#[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+mod webgl_scene;
 mod window_renderer;
 
+pub use scene::ImageManager;
 pub use scene::VelloHybridScenePainter;
+#[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+pub use webgl_scene::*;
 pub use window_renderer::*;

crates/anyrender_vello_hybrid/src/scene.rs

@@ -10,38 +10,50 @@ const DEFAULT_TOLERANCE: f64 = 0.1;
 
 fn anyrender_paint_to_vello_hybrid_paint<'a>(
     paint: PaintRef<'a>,
-    mut image_manager: &mut Option<&mut ImageManager<'_>>,
+    image_manager: &mut ImageManager<'_>,
 ) -> PaintType {
     match paint {
         Paint::Solid(alpha_color) => PaintType::Solid(alpha_color),
         Paint::Gradient(gradient) => PaintType::Gradient(gradient.clone()),
 
         Paint::Image(image_brush) => {
-            if let Some(image_manager) = &mut image_manager {
-                let image_id = image_manager.upload_image(image_brush.image);
-                PaintType::Image(ImageBrush {
-                    image: ImageSource::OpaqueId(image_id),
-                    sampler: image_brush.sampler,
-                })
-            } else {
-                PaintType::Solid(peniko::color::palette::css::TRANSPARENT)
-            }
+            let image_id = image_manager.upload_image(image_brush.image);
+            PaintType::Image(ImageBrush {
+                image: ImageSource::OpaqueId(image_id),
+                sampler: image_brush.sampler,
+            })
         }
 
         // TODO: custom paint
         Paint::Custom(_) => PaintType::Solid(peniko::color::palette::css::TRANSPARENT),
     }
 }
 
-pub(crate) struct ImageManager<'a> {
+pub struct ImageManager<'a> {
     pub(crate) renderer: &'a mut Renderer,
     pub(crate) device: &'a Device,
     pub(crate) queue: &'a Queue,
     pub(crate) encoder: &'a mut CommandEncoder,
     pub(crate) cache: &'a mut FxHashMap<u64, ImageId>,
 }
 
-impl ImageManager<'_> {
+impl<'a> ImageManager<'a> {
+    pub fn new(
+        renderer: &'a mut Renderer,
+        device: &'a Device,
+        queue: &'a Queue,
+        encoder: &'a mut CommandEncoder,
+        cache: &'a mut FxHashMap<u64, ImageId>,
+    ) -> Self {
+        Self {
+            renderer,
+            device,
+            queue,
+            encoder,
+            cache,
+        }
+    }
+
     pub(crate) fn upload_image(&mut self, image: &ImageData) -> ImageId {
         let peniko_id = image.data.id();
 
@@ -76,15 +88,18 @@ pub(crate) enum LayerKind {
 pub struct VelloHybridScenePainter<'s> {
     pub(crate) scene: &'s mut vello_hybrid::Scene,
     pub(crate) layer_stack: Vec<LayerKind>,
-    pub(crate) image_manager: Option<ImageManager<'s>>,
+    pub(crate) image_manager: ImageManager<'s>,
 }
 
 impl VelloHybridScenePainter<'_> {
-    pub fn new<'s>(scene: &'s mut vello_hybrid::Scene) -> VelloHybridScenePainter<'s> {
+    pub fn new<'s>(
+        scene: &'s mut vello_hybrid::Scene,
+        image_manager: ImageManager<'s>,
+    ) -> VelloHybridScenePainter<'s> {
         VelloHybridScenePainter {
             scene,
             layer_stack: Vec::with_capacity(16),
-            image_manager: None,
+            image_manager,
         }
     }
 }
@@ -138,8 +153,7 @@ impl PaintScene for VelloHybridScenePainter<'_> {
     ) {
         self.scene.set_transform(transform);
         self.scene.set_stroke(style.clone());
-        let paint =
-            anyrender_paint_to_vello_hybrid_paint(paint.into(), &mut self.image_manager.as_mut());
+        let paint = anyrender_paint_to_vello_hybrid_paint(paint.into(), &mut self.image_manager);
         self.scene.set_paint(paint);
         self.scene
             .set_paint_transform(brush_transform.unwrap_or(Affine::IDENTITY));
@@ -156,8 +170,7 @@ impl PaintScene for VelloHybridScenePainter<'_> {
     ) {
         self.scene.set_transform(transform);
         self.scene.set_fill_rule(style);
-        let paint =
-            anyrender_paint_to_vello_hybrid_paint(paint.into(), &mut self.image_manager.as_mut());
+        let paint = anyrender_paint_to_vello_hybrid_paint(paint.into(), &mut self.image_manager);
         self.scene.set_paint(paint);
         self.scene
             .set_paint_transform(brush_transform.unwrap_or(Affine::IDENTITY));
@@ -177,8 +190,7 @@ impl PaintScene for VelloHybridScenePainter<'_> {
         glyph_transform: Option<Affine>,
         glyphs: impl Iterator<Item = anyrender::Glyph>,
     ) {
-        let paint =
-            anyrender_paint_to_vello_hybrid_paint(paint.into(), &mut self.image_manager.as_mut());
+        let paint = anyrender_paint_to_vello_hybrid_paint(paint.into(), &mut self.image_manager);
         self.scene.set_paint(paint);
         self.scene.set_transform(transform);