compositor: Add code to extract adapter from x11

wgpu/Cargo.toml

@@ -51,3 +51,6 @@ wayland-protocols.workspace = true
 wayland-backend = { version = "0.3.3", features = ["client_system"] }
 wayland-client = { version = "0.31.2" }
 wayland-sys = { version = "0.31.1", features = ["dlopen"] }
+as-raw-xcb-connection = "1.0.1"
+tiny-xlib = "0.2.3"
+x11rb = { version = "0.13.1", features = ["allow-unsafe-code", "dl-libxcb", "dri3"] }

wgpu/src/window.rs

@@ -2,6 +2,8 @@
 pub mod compositor;
 #[cfg(all(unix, not(target_os = "macos")))]
 mod wayland;
+#[cfg(all(unix, not(target_os = "macos")))]
+mod x11;
 
 pub use compositor::Compositor;
 pub use wgpu::Surface;

wgpu/src/window/compositor.rs

@@ -8,6 +8,8 @@ use crate::{Backend, Primitive, Renderer, Settings};
 
 #[cfg(all(unix, not(target_os = "macos")))]
 use super::wayland::get_wayland_device_ids;
+#[cfg(all(unix, not(target_os = "macos")))]
+use super::x11::get_x11_device_ids;
 
 /// A window graphics backend for iced powered by `wgpu`.
 #[allow(missing_debug_implementations)]
@@ -29,7 +31,10 @@ impl Compositor {
         compatible_window: Option<W>,
     ) -> Option<Self> {
         #[cfg(all(unix, not(target_os = "macos")))]
-        let ids = compatible_window.as_ref().and_then(get_wayland_device_ids);
+        let ids = compatible_window.as_ref().and_then(|window| {
+            get_wayland_device_ids(window)
+                .or_else(|| get_x11_device_ids(window))
+        });
 
         // HACK:
         //  1. If we specifically didn't select an nvidia gpu

wgpu/src/window/x11.rs

@@ -0,0 +1,77 @@
+use as_raw_xcb_connection::AsRawXcbConnection;
+use raw_window_handle::{
+    RawDisplayHandle, XcbDisplayHandle, XlibDisplayHandle,
+};
+use rustix::fs::{fstat, major, minor};
+use tiny_xlib::Display;
+use x11rb::{
+    connection::RequestConnection,
+    protocol::extensions::dri3::{
+        ConnectionExt as _, X11_EXTENSION_NAME as DRI3_NAME,
+    },
+    xcb_ffi::XCBConnection,
+};
+
+pub fn get_x11_device_ids<W: Window>(window: &W) -> Option<(u16, u16)> {
+    x11rb::xcb_ffi::load_libxcb().ok()?;
+
+    let (conn, screen) = match window
+        .display_handle()
+        .map(|handle| handle.as_raw())
+    {
+        #[allow(unsafe_code)]
+        Ok(RawDisplayHandle::Xlib(XlibDisplayHandle {
+            display,
+            screen,
+            ..
+        })) => match display {
+            Some(ptr) => unsafe {
+                let xlib_display =
+                    tiny_xlib::Display::from_ptr(ptr.as_ptr()).ok()?;
+                let conn = XCBConnection::from_raw_xcb_connection(
+                    xlib.as_raw_xcb_connection(),
+                    false,
+                )
+                .ok();
+                // intentially leak the display, we don't want to close the connection
+                std::mem::forget(xlib_display);
+
+                (conn?, screen)
+            },
+            None => (XCBConnection::connect(None), screen),
+        },
+        Ok(RawDisplayHandle::Xcb(XcbDisplayHandle {
+            connection,
+            screen,
+            ..
+        })) => match connection {
+            Some(ptr) => (
+                unsafe {
+                    XCBConnection::from_raw_xcb_connection(ptr.as_ptr(), false)
+                        .ok()?
+                },
+                screen,
+            ),
+            None => (XCBConnection::connect(None), screen),
+        },
+        _ => {
+            return None;
+        }
+    };
+
+    // check for DRI3
+    let _ = conn.extension_information(DRI3_NAME).ok()??;
+    // we have dri3, dri3_open exists on any version, so lets skip version checks.
+
+    // provider being NONE tells the X server to use the RandR provider.
+    let screen = &conn.setup().roots[screen];
+    let dri3 = connection
+        .dri3_open(screen.root, x11rb::NONE)?
+        .reply()
+        .ok()?;
+    let device_fd = dri3.device_fd;
+    let stat = fstat(file).ok()?;
+    let dev = stat.st_rdev;
+
+    super::ids_from_dev(dev)
+}