hal/vulkan: add OpenHarmony surface support

The Vulkan backend has no OpenHarmony window-system integration, so surface
creation fails there and GLES is the only usable backend. That rules out
anything needing `VERTEX_STORAGE` or compute, even though OpenHarmony devices
ship a working Vulkan driver.

`ash` generates no OpenHarmony bindings, so `vkCreateSurfaceOHOS` is resolved
via `get_instance_proc_addr` and `VkSurfaceCreateInfoOHOS` is declared locally,
matching the OpenHarmony SDK's `vulkan_ohos.h`.

OpenHarmony is also excluded from the X11/Wayland extension list: it is unix and
reports `target_os = "linux"`, but has neither.

Surfaces are created from the `OHNativeWindow` an XComponent hands out, which
`raw-window-handle` already exposes as `RawWindowHandle::OhosNdk` and the GLES
backend already consumes.

Tested on a HUAWEI MatePad Air (Maleoon 920, HarmonyOS 6.1): the Vulkan adapter
is selected and storage-buffer/compute pipelines build, which the GLES backend
could not do.

Author: ozongzi

CHANGELOG.md

@@ -85,6 +85,7 @@ Bottom level categories:
 
 #### Vulkan
 
+- Add OpenHarmony surface support via `VK_OHOS_surface`. Previously the Vulkan backend could not create a surface on OpenHarmony, leaving GLES as the only usable backend. By @ozongzi in [#9908](https://github.com/gfx-rs/wgpu/pull/9908).
 - Stop passing an un-waited fence to `vkAcquireNextImageKHR` on non-Windows platforms, which triggered `VUID-vkAcquireNextImageKHR-fence-10066` validation errors every frame since v30.0.0. By @ErichDonGubler in [#9855](https://github.com/gfx-rs/wgpu/issues/9855).
 
 #### GLES

wgpu-hal/src/vulkan/instance.rs

@@ -11,6 +11,13 @@ use arrayvec::ArrayVec;
 use ash::{ext, khr, vk};
 use parking_lot::RwLock;
 
+/// Name of the `VK_OHOS_surface` extension.
+///
+/// `ash` does not generate OpenHarmony bindings, so this mirrors
+/// `VK_OHOS_SURFACE_EXTENSION_NAME` from the OpenHarmony SDK's `vulkan_ohos.h`.
+#[cfg(target_env = "ohos")]
+const OHOS_SURFACE_EXTENSION_NAME: &CStr = c"VK_OHOS_surface";
+
 unsafe extern "system" fn debug_utils_messenger_callback(
     message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
     message_type: vk::DebugUtilsMessageTypeFlagsEXT,
@@ -309,10 +316,15 @@ impl super::Instance {
         extensions.push(khr::surface::NAME);
 
         // Platform-specific WSI extensions
+        //
+        // Note: OpenHarmony (`target_env = "ohos"`) reports `target_os = "linux"` and is
+        // unix, but has neither X11 nor Wayland. It must be excluded here and uses
+        // `VK_OHOS_surface` instead (see below).
         if cfg!(all(
             unix,
             not(target_os = "android"),
-            not(target_os = "macos")
+            not(target_os = "macos"),
+            not(target_env = "ohos")
         )) {
             // VK_KHR_xlib_surface
             extensions.push(khr::xlib_surface::NAME);
@@ -325,6 +337,11 @@ impl super::Instance {
             // VK_KHR_android_surface
             extensions.push(khr::android_surface::NAME);
         }
+        #[cfg(target_env = "ohos")]
+        {
+            // VK_OHOS_surface: surfaces are created from an XComponent's `OHNativeWindow`.
+            extensions.push(OHOS_SURFACE_EXTENSION_NAME);
+        }
         if cfg!(target_os = "windows") {
             // VK_KHR_win32_surface
             extensions.push(khr::win32_surface::NAME);
@@ -570,6 +587,74 @@ impl super::Instance {
         Ok(self.create_surface_from_vk_surface_khr(surface, None))
     }
 
+    /// OpenHarmony window-system integration.
+    ///
+    /// `ash` has no `VK_OHOS_surface` bindings, so the `vkCreateSurfaceOHOS` entry point is
+    /// resolved manually and `VkSurfaceCreateInfoOHOS` is declared here, matching the
+    /// OpenHarmony SDK's `vulkan_ohos.h` (`VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS`
+    /// is 1000685000).
+    ///
+    /// `window` is the `OHNativeWindow*` handed out by an XComponent.
+    #[cfg(target_env = "ohos")]
+    fn create_surface_ohos(
+        &self,
+        window: *mut c_void,
+    ) -> Result<super::Surface, crate::InstanceError> {
+        if !self
+            .shared
+            .extensions
+            .contains(&OHOS_SURFACE_EXTENSION_NAME)
+        {
+            return Err(crate::InstanceError::new(String::from(
+                "Vulkan driver does not support VK_OHOS_surface",
+            )));
+        }
+
+        #[repr(C)]
+        struct VkSurfaceCreateInfoOHOS {
+            s_type: vk::StructureType,
+            p_next: *const c_void,
+            flags: vk::Flags,
+            window: *mut c_void,
+        }
+        const S_TYPE_SURFACE_CREATE_INFO_OHOS: vk::StructureType =
+            vk::StructureType::from_raw(1000685000);
+        type PfnCreateSurfaceOHOS = unsafe extern "system" fn(
+            vk::Instance,
+            *const VkSurfaceCreateInfoOHOS,
+            *const vk::AllocationCallbacks,
+            *mut vk::SurfaceKHR,
+        ) -> vk::Result;
+
+        let raw_instance = self.shared.raw.handle();
+        let Some(pfn) = (unsafe {
+            self.shared
+                .entry
+                .get_instance_proc_addr(raw_instance, c"vkCreateSurfaceOHOS".as_ptr())
+        }) else {
+            return Err(crate::InstanceError::new(String::from(
+                "vkCreateSurfaceOHOS not exposed by Vulkan driver",
+            )));
+        };
+        let create: PfnCreateSurfaceOHOS = unsafe { core::mem::transmute(pfn) };
+
+        let info = VkSurfaceCreateInfoOHOS {
+            s_type: S_TYPE_SURFACE_CREATE_INFO_OHOS,
+            p_next: core::ptr::null(),
+            flags: 0,
+            window,
+        };
+        let mut surface = vk::SurfaceKHR::null();
+        let result = unsafe { create(raw_instance, &info, core::ptr::null(), &mut surface) };
+        if result != vk::Result::SUCCESS {
+            return Err(crate::InstanceError::new(format!(
+                "vkCreateSurfaceOHOS failed: {result:?}"
+            )));
+        }
+
+        Ok(self.create_surface_from_vk_surface_khr(surface, None))
+    }
+
     fn create_surface_from_hwnd(
         &self,
         hinstance: vk::HINSTANCE,
@@ -995,6 +1080,8 @@ impl crate::Instance for super::Instance {
             (Rwh::AndroidNdk(handle), _) => {
                 self.create_surface_android(handle.a_native_window.as_ptr())
             }
+            #[cfg(target_env = "ohos")]
+            (Rwh::OhosNdk(handle), _) => self.create_surface_ohos(handle.native_window.as_ptr()),
             (Rwh::Win32(handle), _) => {
                 let hinstance = handle.hinstance.ok_or_else(|| {
                     crate::InstanceError::new(String::from(