[wgpu-hal] Allow importing external WGL contexts as with EGL

MarijnS95 · MarijnS95 · commit ee7968558e9d · 2024-08-24T11:15:55.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/wgpu-hal/Cargo.toml b/wgpu-hal/Cargo.toml
@@ -207,8 +207,8 @@ env_logger.workspace = true
 glam.workspace = true # for ray-traced-triangle example
 winit.workspace = true # for "halmark" example
 
-[target.'cfg(not(any(target_arch = "wasm32", windows, target_os = "ios")))'.dev-dependencies]
-glutin-winit = { workspace = true, features = ["egl"] } # for "raw-gles" example
-glutin = { workspace = true, features = ["egl"] } # for "raw-gles" example
+[target.'cfg(not(any(target_arch = "wasm32", target_os = "ios")))'.dev-dependencies]
+glutin-winit = { workspace = true, features = ["egl", "wgl"] } # for "raw-gles" example
+glutin = { workspace = true, features = ["egl", "wgl"] } # for "raw-gles" example
 rwh_05 = { version = "0.5", package = "raw-window-handle" } # temporary compatibility for glutin-winit in "raw-gles" example
 winit = { workspace = true, features = ["rwh_05"] } # for "raw-gles" example
diff --git a/wgpu-hal/examples/raw-gles.rs b/wgpu-hal/examples/raw-gles.rs
@@ -10,13 +10,13 @@
 
 extern crate wgpu_hal as hal;
 
-#[cfg(not(any(windows, target_arch = "wasm32", target_os = "ios")))]
+#[cfg(not(any(target_arch = "wasm32", target_os = "ios")))]
 fn main() {
     use std::{ffi::CString, num::NonZeroU32};
 
     use glutin::{
         config::GlConfig as _,
-        context::{NotCurrentGlContext, PossiblyCurrentGlContext as _},
+        context::{AsRawContext as _, NotCurrentGlContext, PossiblyCurrentGlContext as _},
         display::{GetGlDisplay, GlDisplay},
         surface::GlSurface as _,
     };
@@ -137,12 +137,22 @@ fn main() {
                     println!("Hooking up to wgpu-hal");
                     exposed.get_or_insert_with(|| {
                         unsafe {
-                            <hal::api::Gles as hal::Api>::Adapter::new_external(|name| {
-                                // XXX: On WGL this should only be called after the context was made current
-                                gl_config
-                                    .display()
-                                    .get_proc_address(&CString::new(name).expect(name))
-                            })
+                            <hal::api::Gles as hal::Api>::Adapter::new_external(
+                                |name| {
+                                    // XXX: On WGL this should only be called after the context was made current
+                                    gl_config
+                                        .display()
+                                        .get_proc_address(&CString::new(name).expect(name))
+                                },
+                                #[cfg(windows)]
+                                if let glutin::context::RawContext::Wgl(context) =
+                                    gl_context.raw_context()
+                                {
+                                    context.cast_mut()
+                                } else {
+                                    unreachable!()
+                                },
+                            )
                         }
                         .expect("GL adapter can't be initialized")
                     });
@@ -254,7 +264,6 @@ fn main() {
 }
 
 #[cfg(any(
-    windows,
     all(target_arch = "wasm32", not(target_os = "emscripten")),
     target_os = "ios"
 ))]
@@ -263,7 +272,6 @@ fn main() {
 }
 
 #[cfg(not(any(
-    windows,
     all(target_arch = "wasm32", not(target_os = "emscripten")),
     target_os = "ios"
 )))]
diff --git a/wgpu-hal/src/gles/wgl.rs b/wgpu-hal/src/gles/wgl.rs
@@ -1,11 +1,3 @@
-use glow::HasContext;
-use glutin_wgl_sys::wgl_extra::{
-    Wgl, CONTEXT_CORE_PROFILE_BIT_ARB, CONTEXT_DEBUG_BIT_ARB, CONTEXT_FLAGS_ARB,
-    CONTEXT_PROFILE_MASK_ARB,
-};
-use once_cell::sync::Lazy;
-use parking_lot::{Mutex, MutexGuard, RwLock};
-use raw_window_handle::{RawDisplayHandle, RawWindowHandle};
 use std::{
     collections::HashSet,
     ffi::{c_void, CStr, CString},
@@ -19,6 +11,15 @@ use std::{
     thread,
     time::Duration,
 };
+
+use glow::HasContext;
+use glutin_wgl_sys::wgl_extra::{
+    Wgl, CONTEXT_CORE_PROFILE_BIT_ARB, CONTEXT_DEBUG_BIT_ARB, CONTEXT_FLAGS_ARB,
+    CONTEXT_PROFILE_MASK_ARB,
+};
+use once_cell::sync::Lazy;
+use parking_lot::{Mutex, MutexGuard, RwLock};
+use raw_window_handle::{RawDisplayHandle, RawWindowHandle};
 use wgt::InstanceFlags;
 use windows::{
     core::{Error, PCSTR},
@@ -111,14 +112,20 @@ struct WglContext {
 
 impl WglContext {
     fn make_current(&self, device: Gdi::HDC) -> windows::core::Result<()> {
-        unsafe { OpenGL::wglMakeCurrent(device, self.context) }
+        // TODO: Skip this for externally imported context?  Otherwise use wglShareLists()
+        println!("No current");
+        Ok(())
+        // unsafe { OpenGL::wglMakeCurrent(device, self.context) }
     }
 
     fn unmake_current(&self) -> windows::core::Result<()> {
-        if unsafe { OpenGL::wglGetCurrentContext() }.is_invalid() {
-            return Ok(());
-        }
-        unsafe { OpenGL::wglMakeCurrent(None, None) }
+        // TODO: Skip this for externally imported context?
+        println!("No uncurrent");
+        Ok(())
+        // if unsafe { OpenGL::wglGetCurrentContext() }.is_invalid() {
+        //     return Ok(());
+        // }
+        // unsafe { OpenGL::wglMakeCurrent(None, None) }
     }
 }
 
@@ -550,6 +557,45 @@ impl crate::Instance for Instance {
     }
 }
 
+impl super::Adapter {
+    /// Creates a new external adapter using the specified loader function.
+    ///
+    /// # Safety
+    ///
+    /// - The underlying OpenGL ES context must be current.
+    /// - The underlying OpenGL ES context must be current when interfacing with any objects returned by
+    ///   wgpu-hal from this adapter.
+    pub unsafe fn new_external(
+        fun: impl FnMut(&str) -> *const c_void,
+        // gl_context: OpenGL::HGLRC,
+        gl_context: *mut c_void,
+    ) -> Option<crate::ExposedAdapter<super::Api>> {
+        let context = unsafe { glow::Context::from_loader_function(fun) };
+        unsafe {
+            Self::expose(AdapterContext {
+                inner: Arc::new(Mutex::new(Inner {
+                    gl: context,
+                    device: create_instance_device().ok()?,
+                    context: WglContext {
+                        context: OpenGL::HGLRC(gl_context),
+                    },
+                })),
+            })
+        }
+    }
+
+    pub fn adapter_context(&self) -> &AdapterContext {
+        &self.shared.context
+    }
+}
+
+impl super::Device {
+    /// Returns the underlying EGL context.
+    pub fn context(&self) -> &AdapterContext {
+        &self.shared.context
+    }
+}
+
 struct DeviceContextHandle {
     device: Gdi::HDC,
     window: Foundation::HWND,
