Update wgpu to 0.19 (#3824)

* Closes #3675 --------- Co-authored-by: Andreas Reich <[email protected]> Co-authored-by: Mingun <[email protected]>
emilk · Jan 19, 2024 · b766a48 · b766a48
1 parent 7733d1d
commit b766a48
Show file tree

Hide file tree

Showing 27 changed files with 576 additions and 342 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -51,11 +51,10 @@ opt-level = 2
 criterion = { version = "0.5.1", default-features = false }
 glow = "0.13"
 puffin = "0.18"
-raw-window-handle = "0.5.0"
+raw-window-handle = "0.6.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 = { version = "0.19", features = [
+    # Make the renderer `Sync` even on wasm32, because it makes the code simpler:
+    "fragile-send-sync-non-atomic-wasm",
+] }
+winit = { version = "0.29.4", default-features = false }
diff --git a/clippy.toml b/clippy.toml
@@ -71,5 +71,7 @@ disallowed-types = [
 doc-valid-idents = [
     # You must also update the same list in the root `clippy.toml`!
     "AccessKit",
+    "WebGL",
+    "WebGPU",
     "..",
 ]
diff --git a/crates/eframe/Cargo.toml b/crates/eframe/Cargo.toml
@@ -56,7 +56,14 @@ android-native-activity = ["egui-winit/android-native-activity"]
 default_fonts = ["egui/default_fonts"]
 
 ## Use [`glow`](https://github.com/grovesNL/glow) for painting, via [`egui_glow`](https://github.com/emilk/egui/tree/master/crates/egui_glow).
-glow = ["dep:glow", "dep:egui_glow", "dep:glutin", "dep:glutin-winit"]
+glow = [
+  "dep:egui_glow",
+  "dep:glow",
+  "dep:glutin-winit",
+  "dep:glutin",
+  "dep:rwh_05",
+  "winit/rwh_05",
+]
 
 ## Enable saving app state to disk.
 persistence = [
@@ -92,8 +99,19 @@ web_screen_reader = [
 ]
 
 ## Use [`wgpu`](https://docs.rs/wgpu) for painting (via [`egui-wgpu`](https://github.com/emilk/egui/tree/master/crates/egui-wgpu)).
+##
 ## This overrides the `glow` feature.
-wgpu = ["dep:wgpu", "dep:egui-wgpu", "dep:pollster", "dep:raw-window-handle"]
+##
+## By default, only WebGPU is enabled on web.
+## If you want to enable WebGL, you need to turn on the `webgl` feature of crate `wgpu`:
+##
+## ```ignore
+## wgpu = { version = "*", features = ["webgpu", "webgl"] }
+## ```
+##
+## By default, eframe will prefer WebGPU over WebGL, but
+## you can configure this at run-time with [`NativeOptions::wgpu_options`].
+wgpu = ["dep:wgpu", "dep:egui-wgpu", "dep:pollster"]
 
 ## Enables compiling for x11.
 x11 = ["egui-winit/x11"]
@@ -109,6 +127,7 @@ egui = { version = "0.25.0", path = "../egui", default-features = false, feature
 ] }
 log = { version = "0.4", features = ["std"] }
 parking_lot = "0.12"
+raw-window-handle.workspace = true
 static_assertions = "1.1.0"
 thiserror.workspace = true
 
@@ -118,6 +137,10 @@ document-features = { version = "0.2", optional = true }
 
 egui_glow = { version = "0.25.0", path = "../egui_glow", optional = true, default-features = false }
 glow = { workspace = true, optional = true }
+# glutin stuck on old version of raw-window-handle:
+rwh_05 = { package = "raw-window-handle", version = "0.5.2", optional = true, features = [
+  "std",
+] }
 ron = { version = "0.8", optional = true, features = ["integer128"] }
 serde = { version = "1", optional = true, features = ["derive"] }
 
@@ -131,8 +154,7 @@ egui-winit = { version = "0.25.0", path = "../egui-winit", default-features = fa
 image = { version = "0.24", default-features = false, features = [
   "png",
 ] } # Needed for app icon
-raw-window-handle.workspace = true
-winit = { version = "0.29.4", default-features = false, features = ["rwh_05"] }
+winit = { workspace = true, default-features = false, features = ["rwh_06"] }
 
 # optional native:
 directories-next = { version = "2", optional = true }
@@ -211,5 +233,4 @@ web-sys = { version = "0.3.58", features = [
 
 # optional web:
 egui-wgpu = { version = "0.25.0", path = "../egui-wgpu", optional = true } # if wgpu is used, use it without (!) winit
-raw-window-handle = { workspace = true, optional = true }
 wgpu = { workspace = true, optional = true }
diff --git a/crates/eframe/src/epi.rs b/crates/eframe/src/epi.rs
@@ -15,7 +15,8 @@ pub use crate::native::winit_integration::UserEvent;
 
 #[cfg(not(target_arch = "wasm32"))]
 use raw_window_handle::{
-    HasRawDisplayHandle, HasRawWindowHandle, RawDisplayHandle, RawWindowHandle,
+    DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, RawDisplayHandle,
+    RawWindowHandle, WindowHandle,
 };
 #[cfg(not(target_arch = "wasm32"))]
 use static_assertions::assert_not_impl_any;
@@ -76,30 +77,28 @@ pub struct CreationContext<'s> {
 
     /// Raw platform window handle
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) raw_window_handle: RawWindowHandle,
+    pub(crate) raw_window_handle: Result<RawWindowHandle, HandleError>,
 
     /// Raw platform display handle for window
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) raw_display_handle: RawDisplayHandle,
+    pub(crate) raw_display_handle: Result<RawDisplayHandle, HandleError>,
 }
 
-// Implementing `Clone` would violate the guarantees of `HasRawWindowHandle` and `HasRawDisplayHandle`.
-#[cfg(not(target_arch = "wasm32"))]
-assert_not_impl_any!(CreationContext<'_>: Clone);
-
 #[allow(unsafe_code)]
 #[cfg(not(target_arch = "wasm32"))]
-unsafe impl HasRawWindowHandle for CreationContext<'_> {
-    fn raw_window_handle(&self) -> RawWindowHandle {
-        self.raw_window_handle
+impl HasWindowHandle for CreationContext<'_> {
+    fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
+        // Safety: the lifetime is correct.
+        unsafe { Ok(WindowHandle::borrow_raw(self.raw_window_handle.clone()?)) }
     }
 }
 
 #[allow(unsafe_code)]
 #[cfg(not(target_arch = "wasm32"))]
-unsafe impl HasRawDisplayHandle for CreationContext<'_> {
-    fn raw_display_handle(&self) -> RawDisplayHandle {
-        self.raw_display_handle
+impl HasDisplayHandle for CreationContext<'_> {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        // Safety: the lifetime is correct.
+        unsafe { Ok(DisplayHandle::borrow_raw(self.raw_display_handle.clone()?)) }
     }
 }
 
@@ -599,30 +598,32 @@ pub struct Frame {
 
     /// Raw platform window handle
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) raw_window_handle: RawWindowHandle,
+    pub(crate) raw_window_handle: Result<RawWindowHandle, HandleError>,
 
     /// Raw platform display handle for window
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) raw_display_handle: RawDisplayHandle,
+    pub(crate) raw_display_handle: Result<RawDisplayHandle, HandleError>,
 }
 
-// Implementing `Clone` would violate the guarantees of `HasRawWindowHandle` and `HasRawDisplayHandle`.
+// Implementing `Clone` would violate the guarantees of `HasWindowHandle` and `HasDisplayHandle`.
 #[cfg(not(target_arch = "wasm32"))]
 assert_not_impl_any!(Frame: Clone);
 
 #[allow(unsafe_code)]
 #[cfg(not(target_arch = "wasm32"))]
-unsafe impl HasRawWindowHandle for Frame {
-    fn raw_window_handle(&self) -> RawWindowHandle {
-        self.raw_window_handle
+impl HasWindowHandle for Frame {
+    fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
+        // Safety: the lifetime is correct.
+        unsafe { Ok(WindowHandle::borrow_raw(self.raw_window_handle.clone()?)) }
     }
 }
 
 #[allow(unsafe_code)]
 #[cfg(not(target_arch = "wasm32"))]
-unsafe impl HasRawDisplayHandle for Frame {
-    fn raw_display_handle(&self) -> RawDisplayHandle {
-        self.raw_display_handle
+impl HasDisplayHandle for Frame {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        // Safety: the lifetime is correct.
+        unsafe { Ok(DisplayHandle::borrow_raw(self.raw_display_handle.clone()?)) }
     }
 }
 

diff --git a/crates/eframe/src/native/epi_integration.rs b/crates/eframe/src/native/epi_integration.rs
@@ -4,7 +4,7 @@ use std::time::Instant;
 
 use winit::event_loop::EventLoopWindowTarget;
 
-use raw_window_handle::{HasRawDisplayHandle as _, HasRawWindowHandle as _};
+use raw_window_handle::{HasDisplayHandle as _, HasWindowHandle as _};
 
 use egui::{DeferredViewportUiCallback, NumExt as _, ViewportBuilder, ViewportId};
 use egui_winit::{EventResponse, WindowSettings};
@@ -165,8 +165,8 @@ impl EpiIntegration {
             gl,
             #[cfg(feature = "wgpu")]
             wgpu_render_state,
-            raw_display_handle: window.raw_display_handle(),
-            raw_window_handle: window.raw_window_handle(),
+            raw_display_handle: window.display_handle().map(|h| h.as_raw()),
+            raw_window_handle: window.window_handle().map(|h| h.as_raw()),
         };
 
         let icon = native_options

diff --git a/crates/eframe/src/native/glow_integration.rs b/crates/eframe/src/native/glow_integration.rs
@@ -16,7 +16,6 @@ use glutin::{
     prelude::{GlDisplay, PossiblyCurrentGlContext},
     surface::GlSurface,
 };
-use raw_window_handle::{HasRawDisplayHandle as _, HasRawWindowHandle as _};
 use winit::{
     event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget},
     window::{Window, WindowId},
@@ -126,7 +125,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>,
 }
 
@@ -294,6 +293,9 @@ impl GlowWinitApp {
             .expect("Single-use AppCreator has unexpectedly already been taken");
 
         let app = {
+            // Use latest raw_window_handle for eframe compatibility
+            use raw_window_handle::{HasDisplayHandle as _, HasWindowHandle as _};
+
             let window = glutin.window(ViewportId::ROOT);
             let cc = CreationContext {
                 egui_ctx: integration.egui_ctx.clone(),
@@ -302,8 +304,8 @@ impl GlowWinitApp {
                 gl: Some(gl),
                 #[cfg(feature = "wgpu")]
                 wgpu_render_state: None,
-                raw_display_handle: window.raw_display_handle(),
-                raw_window_handle: window.raw_window_handle(),
+                raw_display_handle: window.display_handle().map(|h| h.as_raw()),
+                raw_window_handle: window.window_handle().map(|h| h.as_raw()),
             };
             crate::profile_scope!("app_creator");
             app_creator(&cc)
@@ -373,7 +375,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)?;
@@ -898,15 +900,18 @@ impl GlutinWindowContext {
             gl_display.version_string(),
             gl_display.supported_features()
         );
-        let raw_window_handle = window.as_ref().map(|w| w.raw_window_handle());
-        log::debug!("creating gl context using raw window handle: {raw_window_handle:?}");
+        let glutin_raw_window_handle = window.as_ref().map(|w| {
+            use rwh_05::HasRawWindowHandle as _; // glutin stuck on old version of raw-window-handle
+            w.raw_window_handle()
+        });
+        log::debug!("creating gl context using raw window handle: {glutin_raw_window_handle:?}");
 
         // create gl context. if core context cannot be created, try gl es context as fallback.
         let context_attributes =
-            glutin::context::ContextAttributesBuilder::new().build(raw_window_handle);
+            glutin::context::ContextAttributesBuilder::new().build(glutin_raw_window_handle);
         let fallback_context_attributes = glutin::context::ContextAttributesBuilder::new()
             .with_context_api(glutin::context::ContextApi::Gles(None))
-            .build(raw_window_handle);
+            .build(glutin_raw_window_handle);
 
         let gl_context_result = unsafe {
             crate::profile_scope!("create_context");
@@ -952,7 +957,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 +1036,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(|| {
@@ -1052,9 +1057,11 @@ impl GlutinWindowContext {
             let (width_px, height_px): (u32, u32) = window.inner_size().into();
             let width_px = std::num::NonZeroU32::new(width_px.at_least(1)).unwrap();
             let height_px = std::num::NonZeroU32::new(height_px.at_least(1)).unwrap();
-            let surface_attributes =
+            let surface_attributes = {
+                use rwh_05::HasRawWindowHandle as _; // glutin stuck on old version of raw-window-handle
                 glutin::surface::SurfaceAttributesBuilder::<glutin::surface::WindowSurface>::new()
-                    .build(window.raw_window_handle(), width_px, height_px);
+                    .build(window.raw_window_handle(), width_px, height_px)
+            };
 
             log::trace!("creating surface with attributes: {surface_attributes:?}");
             let gl_surface = unsafe {
@@ -1120,7 +1127,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()