Update wgpu to 0.19

Cargo.toml

@@ -54,8 +54,6 @@ puffin = "0.18"
 raw-window-handle = "0.5.0"
 thiserror = "1.0.37"
 
-# Make the renderer `Sync` even on wasm32, because it makes the code simpler:
-wgpu = { version = "0.18.0", features = ["fragile-send-sync-non-atomic-wasm"] }
-
-# Use this to build wgpu with WebGL support on the Web *instead* of using WebGPU.
-#wgpu = { version = "0.18.0", features = ["webgl"] }
+wgpu = { git = "https://github.com/gfx-rs/wgpu", commit = "7774f31", features = [
+    "fragile-send-sync-non-atomic-wasm",
+] } # Make the renderer `Sync` even on wasm32, because it makes the code simpler:# TODO: Use a stable version of wgpu.

crates/eframe/src/native/glow_integration.rs

@@ -126,7 +126,7 @@ struct Viewport {
     // These three live and die together.
     // TODO(emilk): clump them together into one struct!
     gl_surface: Option<glutin::surface::Surface<glutin::surface::WindowSurface>>,
-    window: Option<Rc<Window>>,
+    window: Option<Arc<Window>>,
     egui_winit: Option<egui_winit::State>,
 }
 
@@ -373,7 +373,7 @@ impl WinitApp for GlowWinitApp {
         self.running.as_ref().map(|r| &r.integration)
     }
 
-    fn window(&self, window_id: WindowId) -> Option<Rc<Window>> {
+    fn window(&self, window_id: WindowId) -> Option<Arc<Window>> {
         let running = self.running.as_ref()?;
         let glutin = running.glutin.borrow();
         let viewport_id = *glutin.viewport_from_window.get(&window_id)?;
@@ -952,7 +952,7 @@ impl GlutinWindowContext {
                 screenshot_requested: false,
                 viewport_ui_cb: None,
                 gl_surface: None,
-                window: window.map(Rc::new),
+                window: window.map(Arc::new),
                 egui_winit: None,
             },
         );
@@ -1031,7 +1031,7 @@ impl GlutinWindowContext {
             );
             viewport.info.minimized = window.is_minimized();
             viewport.info.maximized = Some(window.is_maximized());
-            viewport.window.insert(Rc::new(window))
+            viewport.window.insert(Arc::new(window))
         };
 
         viewport.egui_winit.get_or_insert_with(|| {
@@ -1120,7 +1120,7 @@ impl GlutinWindowContext {
             .expect("viewport doesn't exist")
     }
 
-    fn window(&self, viewport_id: ViewportId) -> Rc<Window> {
+    fn window(&self, viewport_id: ViewportId) -> Arc<Window> {
         self.viewport(viewport_id)
             .window
             .clone()

crates/eframe/src/native/wgpu_integration.rs

@@ -84,7 +84,7 @@ pub struct Viewport {
 
     /// Window surface state that's initialized when the app starts running via a Resumed event
     /// and on Android will also be destroyed if the application is paused.
-    window: Option<Rc<Window>>,
+    window: Option<Arc<Window>>,
 
     /// `window` and `egui_winit` are initialized together.
     egui_winit: Option<egui_winit::State>,
@@ -170,9 +170,11 @@ impl WgpuWinitApp {
             self.native_options.viewport.transparent.unwrap_or(false),
         );
 
+        let window = Arc::new(window);
+
         {
             crate::profile_scope!("set_window");
-            pollster::block_on(painter.set_window(ViewportId::ROOT, Some(&window)))?;
+            pollster::block_on(painter.set_window(ViewportId::ROOT, Some(window.clone())))?;
         }
 
         let wgpu_render_state = painter.render_state();
@@ -260,7 +262,7 @@ impl WgpuWinitApp {
                 },
                 screenshot_requested: false,
                 viewport_ui_cb: None,
-                window: Some(Rc::new(window)),
+                window: Some(window),
                 egui_winit: Some(egui_winit),
             },
         );
@@ -323,7 +325,7 @@ impl WinitApp for WgpuWinitApp {
         self.running.as_ref().map(|r| &r.integration)
     }
 
-    fn window(&self, window_id: WindowId) -> Option<Rc<Window>> {
+    fn window(&self, window_id: WindowId) -> Option<Arc<Window>> {
         self.running
             .as_ref()
             .and_then(|r| {
@@ -544,7 +546,8 @@ impl WgpuWinitRunning {
 
             {
                 crate::profile_scope!("set_window");
-                if let Err(err) = pollster::block_on(painter.set_window(viewport_id, Some(window)))
+                if let Err(err) =
+                    pollster::block_on(painter.set_window(viewport_id, Some(window.clone())))
                 {
                     log::warn!("Failed to set window: {err}");
                 }
@@ -797,7 +800,10 @@ impl Viewport {
             Ok(window) => {
                 windows_id.insert(window.id(), viewport_id);
 
-                if let Err(err) = pollster::block_on(painter.set_window(viewport_id, Some(&window)))
+                let window = Arc::new(window);
+
+                if let Err(err) =
+                    pollster::block_on(painter.set_window(viewport_id, Some(window.clone())))
                 {
                     log::error!("on set_window: viewport_id {viewport_id:?} {err}");
                 }
@@ -813,7 +819,7 @@ impl Viewport {
                 self.info.minimized = window.is_minimized();
                 self.info.maximized = Some(window.is_maximized());
 
-                self.window = Some(Rc::new(window));
+                self.window = Some(window);
             }
             Err(err) => {
                 log::error!("Failed to create window: {err}");
@@ -930,7 +936,7 @@ fn render_immediate_viewport(
 
     {
         crate::profile_scope!("set_window");
-        if let Err(err) = pollster::block_on(painter.set_window(ids.this, Some(window))) {
+        if let Err(err) = pollster::block_on(painter.set_window(ids.this, Some(window.clone()))) {
             log::error!(
                 "when rendering viewport_id={:?}, set_window Error {err}",
                 ids.this

crates/eframe/src/native/winit_integration.rs

@@ -1,4 +1,4 @@
-use std::{rc::Rc, time::Instant};
+use std::{sync::Arc, time::Instant};
 
 use winit::{
     event_loop::EventLoopWindowTarget,
@@ -68,7 +68,7 @@ pub trait WinitApp {
 
     fn integration(&self) -> Option<&EpiIntegration>;
 
-    fn window(&self, window_id: WindowId) -> Option<Rc<Window>>;
+    fn window(&self, window_id: WindowId) -> Option<Arc<Window>>;
 
     fn window_id_from_viewport_id(&self, id: ViewportId) -> Option<WindowId>;
 

crates/eframe/src/web/web_painter_wgpu.rs

@@ -30,7 +30,7 @@ unsafe impl raw_window_handle::HasRawDisplayHandle for EguiWebWindow {
 pub(crate) struct WebPainterWgpu {
     canvas: HtmlCanvasElement,
     canvas_id: String,
-    surface: wgpu::Surface,
+    surface: wgpu::Surface<'static>,
     surface_configuration: wgpu::SurfaceConfiguration,
     render_state: Option<RenderState>,
     on_surface_error: Arc<dyn Fn(wgpu::SurfaceError) -> SurfaceErrorAction>,
@@ -82,20 +82,9 @@ impl WebPainterWgpu {
 
         let canvas = super::canvas_element_or_die(canvas_id);
 
-        let surface = if false {
-            instance.create_surface_from_canvas(canvas.clone())
-        } else {
-            // Workaround for https://github.com/gfx-rs/wgpu/issues/3710:
-            // Don't use `create_surface_from_canvas`, but `create_surface` instead!
-            let raw_window = EguiWebWindow(egui::util::hash(("egui on wgpu", canvas_id)) as u32);
-            canvas.set_attribute("data-raw-handle", &raw_window.0.to_string());
-
-            #[allow(unsafe_code)]
-            unsafe {
-                instance.create_surface(&raw_window)
-            }
-        }
-        .map_err(|err| format!("failed to create wgpu surface: {err}"))?;
+        let surface = instance
+            .create_surface(wgpu::SurfaceTarget::Canvas(canvas.clone()))
+            .map_err(|err| format!("failed to create wgpu surface: {err}"))?;
 
         let depth_format = egui_wgpu::depth_format_from_bits(options.depth_buffer, 0);
         let render_state =

crates/egui-wgpu/Cargo.toml

@@ -51,9 +51,7 @@ wgpu.workspace = true
 ## Enable this when generating docs.
 document-features = { version = "0.2", optional = true }
 
-winit = { version = "0.29.4", default-features = false, optional = true, features = [
-  "rwh_05",
-] }
+winit = { version = "0.29.4", default-features = false, optional = true }
 
 # Native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

crates/egui-wgpu/src/lib.rs

@@ -34,6 +34,10 @@ pub enum WgpuError {
 
     #[error(transparent)]
     CreateSurfaceError(#[from] wgpu::CreateSurfaceError),
+
+    #[cfg(feature = "winit")]
+    #[error(transparent)]
+    HandleError(#[from] ::winit::raw_window_handle::HandleError),
 }
 
 /// Access to the render state for egui.
@@ -63,14 +67,14 @@ impl RenderState {
     pub async fn create(
         config: &WgpuConfiguration,
         instance: &wgpu::Instance,
-        surface: &wgpu::Surface,
+        surface: &wgpu::Surface<'static>,
         depth_format: Option<wgpu::TextureFormat>,
         msaa_samples: u32,
     ) -> Result<Self, WgpuError> {
         crate::profile_scope!("RenderState::create"); // async yield give bad names using `profile_function`
 
         #[cfg(not(target_arch = "wasm32"))]
-        let adapters: Vec<_> = instance.enumerate_adapters(wgpu::Backends::all()).collect();
+        let adapters: Vec<_> = instance.enumerate_adapters(wgpu::Backends::all());
 
         let adapter = {
             crate::profile_scope!("request_adapter");
@@ -228,8 +232,8 @@ impl Default for WgpuConfiguration {
 
                 wgpu::DeviceDescriptor {
                     label: Some("egui wgpu device"),
-                    features: wgpu::Features::default(),
-                    limits: wgpu::Limits {
+                    required_features: wgpu::Features::default(),
+                    required_limits: wgpu::Limits {
                         // When using a depth buffer, we have to be able to create a texture
                         // large enough for the entire surface, and we want to support 4k+ displays.
                         max_texture_dimension_2d: 8192,