Upgrade to WGPU v29 (+ latest vello main)

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

Author: nicoburns

Cargo.lock

@@ -22,7 +22,7 @@ homepage = "https://github.com/dioxuslabs/anyrender"
 repository = "https://github.com/dioxuslabs/anyrender"
 categories = ["gui"]
 edition = "2024"
-rust-version = "1.92.0"
+rust-version = "1.88.0"
 
 [workspace.dependencies]
 # AnyRender dependencies (in-repo)
@@ -52,13 +52,14 @@ color = "0.3"
 linebender_resource_handle = "0.1"
 peniko = "0.6"
 kurbo = "0.13"
+glifo = "0.0.0"
 vello = { version = "0.8", features = [ "wgpu" ] }
 vello_cpu = { version = "0.0.7", default-features = false, features = ["std", "text", "u8_pipeline"] }
 vello_hybrid = { version = "0.0.7" }
 vello_common = { version = "0.0.7" }
 
 # Rendering
-wgpu = "28"
+wgpu = "29"
 raw-window-handle = "0.6.0"
 softbuffer = "0.4"
 pixels = "0.17"
@@ -84,3 +85,4 @@ 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" }
+glifo = { path = "../vello/glifo" }

Cargo.toml

@@ -11,7 +11,7 @@ use vello::{
     AaConfig, AaSupport, RenderParams, Renderer as VelloRenderer, RendererOptions,
     Scene as VelloScene,
 };
-use wgpu::{Features, Limits, PresentMode, SurfaceError, Texture, TextureFormat, TextureUsages};
+use wgpu::{Features, Limits, PresentMode, Texture, TextureFormat, TextureUsages};
 use wgpu_context::{
     DeviceHandle, SurfaceRenderer, SurfaceRendererConfiguration, TextureConfiguration, WGPUContext,
 };
@@ -305,19 +305,11 @@ impl WindowRenderer for VelloWindowRenderer {
         });
         timer.record_time("cmd");
 
-        match render_surface.ensure_current_surface_texture() {
-            Ok(_) => {}
-            Err(SurfaceError::Timeout | SurfaceError::Lost | SurfaceError::Outdated) => {
-                render_surface.clear_surface_texture();
-                return;
-            }
-            Err(SurfaceError::OutOfMemory) => panic!("Out of memory"),
-            Err(SurfaceError::Other) => panic!("Unknown error getting surface"),
+        let Ok(texture_view) = render_surface.target_texture_view() else {
+            // Skip frame in case of error trying to get current surface texture
+            return;
         };
 
-        let texture_view = render_surface
-            .target_texture_view()
-            .expect("handled errors from ensure_current_surface_texture above");
         state
             .renderer
             .render_to_texture(

crates/anyrender_vello/src/window_renderer.rs

@@ -44,7 +44,8 @@ pub struct VelloCpuScenePainter {
 impl VelloCpuScenePainter {
     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);
+        self.render_ctx
+            .render_to_pixmap(&mut self.resources, &mut pixmap);
         pixmap
     }
 }

crates/anyrender_vello_cpu/src/scene.rs

@@ -19,6 +19,7 @@ kurbo = { workspace = true }
 peniko = { workspace = true }
 vello_hybrid = { workspace = true }
 vello_common = { workspace = true }
+glifo = { workspace = true }
 wgpu = { workspace = true }
 rustc-hash = { workspace = true }
 wgpu_context = { workspace = true }

crates/anyrender_vello_hybrid/Cargo.toml

@@ -3,7 +3,7 @@ use kurbo::{Affine, Rect, Shape, Stroke};
 use peniko::{BlendMode, Color, Fill, FontData, ImageBrush, ImageData, StyleRef};
 use rustc_hash::FxHashMap;
 use vello_common::paint::{ImageId, ImageSource, PaintType};
-use vello_hybrid::Renderer;
+use vello_hybrid::{Renderer, Resources};
 use wgpu::{CommandEncoder, Device, Queue};
 
 const DEFAULT_TOLERANCE: f64 = 0.1;
@@ -22,7 +22,7 @@ fn anyrender_paint_to_vello_hybrid_paint<'a>(
                 image: ImageSource::OpaqueId {
                     id: image_id,
                     // TODO: optimize opaque case
-                    may_have_opacities: true,
+                    may_have_transparency: true,
                 },
                 sampler: image_brush.sampler,
             })
@@ -36,6 +36,7 @@ fn anyrender_paint_to_vello_hybrid_paint<'a>(
 
 pub struct ImageManager<'a> {
     pub(crate) renderer: &'a mut Renderer,
+    pub(crate) resources: &'a mut Resources,
     pub(crate) device: &'a Device,
     pub(crate) queue: &'a Queue,
     pub(crate) encoder: &'a mut CommandEncoder,
@@ -45,13 +46,15 @@ pub struct ImageManager<'a> {
 impl<'a> ImageManager<'a> {
     pub fn new(
         renderer: &'a mut Renderer,
+        resources: &'a mut Resources,
         device: &'a Device,
         queue: &'a Queue,
         encoder: &'a mut CommandEncoder,
         cache: &'a mut FxHashMap<u64, ImageId>,
     ) -> Self {
         Self {
             renderer,
+            resources,
             device,
             queue,
             encoder,
@@ -73,9 +76,13 @@ impl<'a> ImageManager<'a> {
         };
 
         // Upload Pixamp
-        let atlas_id = self
-            .renderer
-            .upload_image(self.device, self.queue, self.encoder, &pixmap);
+        let atlas_id = self.renderer.upload_image(
+            self.resources,
+            self.device,
+            self.queue,
+            self.encoder,
+            &pixmap,
+        );
 
         // Store ImageId in cache
         self.cache.insert(peniko_id, atlas_id);
@@ -194,14 +201,14 @@ impl PaintScene for VelloHybridScenePainter<'_> {
         _brush_alpha: f32,
         transform: Affine,
         glyph_transform: Option<Affine>,
-        glyphs: impl Iterator<Item = anyrender::Glyph>,
+        glyphs: impl Iterator<Item = anyrender::Glyph> + Clone,
     ) {
         let paint = anyrender_paint_to_vello_hybrid_paint(paint.into(), &mut self.image_manager);
         self.scene.set_paint(paint);
         self.scene.set_transform(transform);
 
-        fn into_vello_hybrid_glyph(g: anyrender::Glyph) -> vello_common::glyph::Glyph {
-            vello_common::glyph::Glyph {
+        fn into_vello_hybrid_glyph(g: anyrender::Glyph) -> glifo::Glyph {
+            glifo::Glyph {
                 id: g.id,
                 x: g.x,
                 y: g.y,
@@ -213,7 +220,7 @@ impl PaintScene for VelloHybridScenePainter<'_> {
             StyleRef::Fill(fill) => {
                 self.scene.set_fill_rule(fill);
                 self.scene
-                    .glyph_run(font)
+                    .glyph_run(self.image_manager.resources, font)
                     .font_size(font_size)
                     .hint(hint)
                     .normalized_coords(normalized_coords)
@@ -223,7 +230,7 @@ impl PaintScene for VelloHybridScenePainter<'_> {
             StyleRef::Stroke(stroke) => {
                 self.scene.set_stroke(stroke.clone());
                 self.scene
-                    .glyph_run(font)
+                    .glyph_run(self.image_manager.resources, font)
                     .font_size(font_size)
                     .hint(hint)
                     .normalized_coords(normalized_coords)

crates/anyrender_vello_hybrid/src/scene.rs

@@ -6,10 +6,10 @@ use std::future::Future;
 use std::sync::Arc;
 use vello_common::paint::ImageId;
 use vello_hybrid::{
-    RenderSettings, RenderSize, RenderTargetConfig, Renderer as VelloHybridRenderer,
-    Scene as VelloHybridScene,
+    RenderSettings, RenderSize, RenderTargetConfig, Renderer as VelloHybridRenderer, Resources,
+    Scene as VelloHybridScene, TextureBindings,
 };
-use wgpu::{CommandEncoderDescriptor, Features, Limits, PresentMode, SurfaceError, TextureFormat};
+use wgpu::{CommandEncoderDescriptor, Features, Limits, PresentMode, TextureFormat};
 use wgpu_context::{DeviceHandle, SurfaceRenderer, SurfaceRendererConfiguration, WGPUContext};
 
 use crate::{VelloHybridScenePainter, scene::ImageManager};
@@ -30,6 +30,7 @@ fn spawn_init<F: Future<Output = ()>>(f: F) {
 
 struct ActiveRenderState {
     renderer: VelloHybridRenderer,
+    resources: Resources,
     render_surface: SurfaceRenderer<'static>,
 }
 
@@ -223,6 +224,7 @@ impl WindowRenderer for VelloHybridWindowRenderer {
             )
             .expect("Error creating SurfaceRenderer");
 
+            let resources = Resources::new();
             let renderer = VelloHybridRenderer::new(
                 render_surface.device(),
                 &RenderTargetConfig {
@@ -235,6 +237,7 @@ impl WindowRenderer for VelloHybridWindowRenderer {
             let _ = sender.send(InitOutput {
                 active: ActiveRenderState {
                     renderer,
+                    resources,
                     render_surface,
                 },
             });
@@ -293,6 +296,7 @@ impl WindowRenderer for VelloHybridWindowRenderer {
 
         let image_manager = ImageManager {
             renderer: &mut state.renderer,
+            resources: &mut state.resources,
             device: render_surface.device(),
             queue: render_surface.queue(),
             encoder: &mut encoder,
@@ -307,24 +311,16 @@ impl WindowRenderer for VelloHybridWindowRenderer {
         });
         timer.record_time("cmd");
 
-        match render_surface.ensure_current_surface_texture() {
-            Ok(_) => {}
-            Err(SurfaceError::Timeout | SurfaceError::Lost | SurfaceError::Outdated) => {
-                render_surface.clear_surface_texture();
-                return;
-            }
-            Err(SurfaceError::OutOfMemory) => panic!("Out of memory"),
-            Err(SurfaceError::Other) => panic!("Unknown error getting surface"),
+        let Ok(texture_view) = render_surface.target_texture_view() else {
+            // Skip frame in case of error getting surface texture
+            return;
         };
 
-        let texture_view = render_surface
-            .target_texture_view()
-            .expect("handled errors from ensure_current_surface_texture above");
-
         state
             .renderer
             .render(
                 &self.scene,
+                &mut state.resources,
                 render_surface.device(),
                 render_surface.queue(),
                 &mut encoder,
@@ -333,6 +329,8 @@ impl WindowRenderer for VelloHybridWindowRenderer {
                     height: render_surface.config.height,
                 },
                 &texture_view,
+                // TODO: handle texture registration
+                &TextureBindings::new(),
             )
             .expect("failed to render to texture");
         render_surface.queue().submit([encoder.finish()]);

crates/anyrender_vello_hybrid/src/window_renderer.rs

@@ -115,11 +115,15 @@ impl WGPUContext {
         override_limits: Option<Limits>,
     ) -> Self {
         Self {
-            instance: Instance::new(&wgpu::InstanceDescriptor {
+            instance: Instance::new(wgpu::InstanceDescriptor {
                 backends: wgpu::Backends::from_env().unwrap_or_default(),
                 flags: wgpu::InstanceFlags::from_build_config().with_env(),
                 backend_options: wgpu::BackendOptions::from_env_or_default(),
                 memory_budget_thresholds: wgpu::MemoryBudgetThresholds::default(),
+
+                // TODO: support passing display handle
+                // Needed for opengl/webgl
+                display: None,
             }),
             device_pool: Vec::new(),
             extra_features,

crates/wgpu_context/src/lib.rs

@@ -1,10 +1,14 @@
 use crate::{DeviceHandle, WgpuContextError, util::create_texture};
 use wgpu::{
-    CommandEncoderDescriptor, CompositeAlphaMode, Device, PresentMode, Queue, Surface,
-    SurfaceConfiguration, SurfaceError, SurfaceTexture, TextureFormat, TextureUsages, TextureView,
-    TextureViewDescriptor, util::TextureBlitter,
+    CommandEncoderDescriptor, CompositeAlphaMode, CurrentSurfaceTexture, Device, PresentMode,
+    Queue, Surface, SurfaceConfiguration, SurfaceTexture, TextureFormat, TextureUsages,
+    TextureView, TextureViewDescriptor, util::TextureBlitter,
 };
 
+/// Error getting the current surface texture
+#[derive(Clone, Debug)]
+pub struct GetCurrentSurfaceTextureErr;
+
 #[derive(Clone)]
 pub struct TextureConfiguration {
     pub usage: TextureUsages,
@@ -85,7 +89,7 @@ pub struct SurfaceRenderer<'s> {
     pub surface: Surface<'s>,
     pub config: SurfaceConfiguration,
 
-    current_surface_texture: Option<Result<SurfaceTexture, SurfaceError>>,
+    current_surface_texture: Option<CurrentSurfaceTexture>,
     intermediate_texture: Option<Box<IntermediateTextureStuff>>,
 }
 
@@ -189,43 +193,41 @@ impl<'s> SurfaceRenderer<'s> {
         self.current_surface_texture = None;
     }
 
-    pub fn ensure_current_surface_texture(&mut self) -> Result<(), SurfaceError> {
+    pub fn ensure_current_surface_texture(
+        &mut self,
+    ) -> Result<&SurfaceTexture, GetCurrentSurfaceTextureErr> {
         if self.current_surface_texture.is_none() {
             let tex = self.surface.get_current_texture();
-            if let Err(SurfaceError::Lost | SurfaceError::Outdated) = &tex {
-                self.surface
-                    .configure(&self.device_handle.device, &self.config);
+            match &tex {
+                CurrentSurfaceTexture::Lost
+                | CurrentSurfaceTexture::Outdated
+                | CurrentSurfaceTexture::Suboptimal(_) => {
+                    self.surface
+                        .configure(&self.device_handle.device, &self.config);
+                }
+                _ => {}
             }
 
             self.current_surface_texture = Some(tex);
         }
 
-        self.current_surface_texture
-            .as_ref()
-            .unwrap()
-            .as_ref()
-            .map(|_| ())
-            .map_err(|err| err.clone())
+        match self.current_surface_texture.as_ref().unwrap() {
+            CurrentSurfaceTexture::Success(surface_texture) => Ok(surface_texture),
+            _ => Err(GetCurrentSurfaceTextureErr),
+        }
     }
 
     /// Get a target texture view to render to.
     ///
     /// If there is an intermediate texture, this is a view of that intermediate texture, otherwise
     /// it is a view of the surface texture.
-    pub fn target_texture_view(&mut self) -> Result<TextureView, SurfaceError> {
+    pub fn target_texture_view(&mut self) -> Result<TextureView, GetCurrentSurfaceTextureErr> {
         match &self.intermediate_texture {
             Some(intermediate_texture) => Ok(intermediate_texture.texture_view.clone()),
-            None => {
-                self.ensure_current_surface_texture()?;
-                Ok(self
-                    .current_surface_texture
-                    .as_ref()
-                    .unwrap()
-                    .as_ref()
-                    .unwrap()
-                    .texture
-                    .create_view(&TextureViewDescriptor::default()))
-            }
+            None => Ok(self
+                .ensure_current_surface_texture()?
+                .texture
+                .create_view(&TextureViewDescriptor::default())),
         }
     }
 
@@ -234,9 +236,13 @@ impl<'s> SurfaceRenderer<'s> {
     ///
     /// Prior to calling this, [`Self::target_texture_view`] must have been called and some
     /// rendering work must have been scheduled to the resulting view.
-    pub fn maybe_blit_and_present(&mut self) -> Result<(), SurfaceError> {
+    pub fn maybe_blit_and_present(&mut self) -> Result<(), GetCurrentSurfaceTextureErr> {
         self.ensure_current_surface_texture()?;
-        let surface_texture = self.current_surface_texture.take().unwrap().unwrap();
+        let CurrentSurfaceTexture::Success(surface_texture) =
+            self.current_surface_texture.take().unwrap()
+        else {
+            unreachable!("Surface texture was set in ensure_current_surface_texture above");
+        };
 
         if let Some(its) = &self.intermediate_texture {
             self.blit_from_intermediate_texture_to_surface(&surface_texture, its);