Allow optional RawDisplayHandle in InstanceDescriptor

This allows platforms like GLES with EGL context backend to properly
initialize such that their `EGLDisplay` and `EGLContext` are compatible
with an incoming `Surface`, which is otherwise impossible if not for
hotpatching the context (and loosing all resources created on it) when a
surface comes in and that compositor connection becomes known.

This hotpatching is known to break quite a few systems and
initialization ordering (i.e. the alternative is forcing users to create
surfaces before querying adapters, which isn't feasible on platform like
Android), and is better avoided or at least made possible by using the
`(Raw)DisplayHandle` abstraction provided by `raw_display_handle` in the
way it's intended to be used (additionally, removing it from the surface
would be a sensible decision).

There may however be cases where users want to initialize multiple
`Instance`s or perhaps `Adapter`s for independent `RawDisplayHandle`s,
and certain backends may be designed specifically to cope with this
(i.e. Vulkan).

Note that this PR does nothing to address many other soundness problems
inside the EGL backend.

Author: MarijnS95

Cargo.lock

@@ -165,7 +165,7 @@ pp-rs = "0.2.1"
 profiling = { version = "1.0.1", default-features = false }
 quote = "1.0.38"
 raw-window-handle = { version = "0.6.2", default-features = false }
-rwh_05 = { version = "0.5.2", package = "raw-window-handle" } # temporary compatibility for glutin-winit               
+rwh_05 = { version = "0.5.2", package = "raw-window-handle" } # temporary compatibility for glutin-winit
 rayon = "1.3"
 regex-lite = "0.1"
 renderdoc-sys = "1"

Cargo.toml

@@ -162,6 +162,7 @@ impl GPU {
                         gl: wgpu_types::GlBackendOptions::default(),
                         noop: wgpu_types::NoopBackendOptions::default(),
                     },
+                    display: None,
                 },
             )));
             state.borrow::<Instance>()

deno_webgpu/lib.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use wgpu::{Instance, Surface};
+use wgpu::{rwh::HasDisplayHandle, Instance, Surface};
 use winit::{
     dpi::PhysicalSize,
     event::{Event, KeyEvent, StartCause, WindowEvent},
@@ -268,7 +268,10 @@ impl ExampleContext {
     async fn init_async<E: Example>(surface: &mut SurfaceWrapper, window: Arc<Window>) -> Self {
         log::info!("Initializing wgpu...");
 
-        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::from_env_or_default());
+        let mut desc = wgpu::InstanceDescriptor::from_env_or_default();
+        // XXX: Could also come from EventLoop before Window is created
+        desc.display = Some(window.display_handle().unwrap().as_raw());
+        let instance = wgpu::Instance::new(&desc);
         surface.pre_adapter(&instance, window);
 
         let adapter = get_adapter_with_capabilities_or_from_env(

examples/features/src/framework.rs

@@ -68,6 +68,7 @@ pub fn initialize_instance(backends: wgpu::Backends, params: &TestParameters) ->
             // TODO(https://github.com/gfx-rs/wgpu/issues/7119): Enable noop backend?
             noop: wgpu::NoopBackendOptions::default(),
         },
+        display: None,
     })
 }
 

tests/src/init.rs

@@ -41,6 +41,7 @@ mod request_adapter_error {
             flags: wgpu::InstanceFlags::default(),
             memory_budget_thresholds: wgpu::MemoryBudgetThresholds::default(),
             backend_options: wgpu::BackendOptions::default(),
+            display: None,
         }
     }
 

tests/tests/wgpu-validation/api/instance.rs

@@ -8,6 +8,7 @@ use alloc::{
 };
 
 use hashbrown::HashMap;
+use raw_window_handle::DisplayHandle;
 use thiserror::Error;
 use wgt::error::{ErrorType, WebGpuError};
 
@@ -131,6 +132,10 @@ impl Instance {
             flags: self.flags,
             memory_budget_thresholds: instance_desc.memory_budget_thresholds,
             backend_options: instance_desc.backend_options.clone(),
+            display: instance_desc
+                .display
+                // XXX: This assigns a bogus lifetime. hal::InstanceDescriptor should also take Raw?
+                .map(|r| unsafe { DisplayHandle::borrow_raw(r) }),
         };
 
         use hal::Instance as _;

wgpu-core/src/instance.rs

@@ -112,6 +112,7 @@ gles = [
     "dep:hashbrown",
     "dep:js-sys",
     "dep:khronos-egl",
+    "dep:wayland-sys",
     "dep:libloading",
     "dep:log",
     "dep:ndk-sys",
@@ -245,6 +246,9 @@ renderdoc-sys = { workspace = true, optional = true }
 [target.'cfg(unix)'.dependencies]
 # Backend: Vulkan
 libc = { workspace = true, optional = true }
+# backend: GLES
+# XXX: Using crate to copy from glutin. Better yet, use wayland-client or replace entire backend with glutin entirely.
+wayland-sys = { version = "0.31", features = ["client", "dlopen", "egl"], optional = true }
 
 #########################
 ### Platform: Windows ###

wgpu-hal/Cargo.toml

@@ -93,21 +93,24 @@ struct Example<A: hal::Api> {
 
 impl<A: hal::Api> Example<A> {
     fn init(window: &winit::window::Window) -> Result<Self, Box<dyn std::error::Error>> {
+        // XXX: Could be from the EventLoop as well
+        let raw_display_handle = window.display_handle()?;
+
         let instance_desc = hal::InstanceDescriptor {
             name: "example",
             flags: wgpu_types::InstanceFlags::from_build_config().with_env(),
             memory_budget_thresholds: wgpu_types::MemoryBudgetThresholds::default(),
             // Can't rely on having DXC available, so use FXC instead
             backend_options: wgpu_types::BackendOptions::default(),
+            display: Some(raw_display_handle),
         };
         let instance = unsafe { A::Instance::init(&instance_desc)? };
         let surface = {
             let raw_window_handle = window.window_handle()?.as_raw();
-            let raw_display_handle = window.display_handle()?.as_raw();
 
             unsafe {
                 instance
-                    .create_surface(raw_display_handle, raw_window_handle)
+                    .create_surface(raw_display_handle.as_raw(), raw_window_handle)
                     .unwrap()
             }
         };

wgpu-hal/examples/halmark/main.rs

@@ -235,6 +235,9 @@ impl<A: hal::Api> Example<A> {
             log::info!("using index buffer")
         }
 
+        // XXX: Could be from the EventLoop as well
+        let raw_display_handle = window.display_handle()?;
+
         let instance_desc = hal::InstanceDescriptor {
             name: "example",
             flags: wgpu_types::InstanceFlags::default(),
@@ -245,15 +248,16 @@ impl<A: hal::Api> Example<A> {
                 },
                 ..Default::default()
             },
+            // XXX: Coudla
+            display: Some(raw_display_handle),
         };
         let instance = unsafe { A::Instance::init(&instance_desc)? };
         let surface = {
             let raw_window_handle = window.window_handle()?.as_raw();
-            let raw_display_handle = window.display_handle()?.as_raw();
 
             unsafe {
                 instance
-                    .create_surface(raw_display_handle, raw_window_handle)
+                    .create_surface(raw_display_handle.as_raw(), raw_window_handle)
                     .unwrap()
             }
         };