wgpu: Fall back to software rendering if there are no GPU-backed WGPU adapters

tronical · tronical · commit fd28676ab61e · 2025-08-19T14:57:21.000+02:00
Fixes #9164
diff --git a/internal/backends/winit/lib.rs b/internal/backends/winit/lib.rs
@@ -57,7 +57,7 @@ pub enum WinitWindowEventResult {
 mod renderer {
     use std::sync::Arc;
 
-    use i_slint_core::{graphics::RequestedGraphicsAPI, platform::PlatformError};
+    use i_slint_core::platform::PlatformError;
     use winit::event_loop::ActiveEventLoop;
 
     pub trait WinitCompatibleRenderer {
@@ -74,7 +74,6 @@ mod renderer {
             &self,
             active_event_loop: &ActiveEventLoop,
             window_attributes: winit::window::WindowAttributes,
-            requested_graphics_api: Option<RequestedGraphicsAPI>,
         ) -> Result<Arc<winit::window::Window>, PlatformError>;
     }
 
@@ -145,7 +144,11 @@ fn try_create_window_with_fallback_renderer(
         renderer::skia::WinitSkiaRenderer::new_suspended,
         #[cfg(feature = "renderer-femtovg-wgpu")]
         renderer::femtovg::WGPUFemtoVGRenderer::new_suspended,
-        #[cfg(all(feature = "renderer-femtovg", supports_opengl))]
+        #[cfg(all(
+            feature = "renderer-femtovg",
+            supports_opengl,
+            not(feature = "renderer-femtovg-wgpu")
+        ))]
         renderer::femtovg::GlutinFemtoVGRenderer::new_suspended,
         #[cfg(feature = "renderer-software")]
         renderer::sw::WinitSoftwareRenderer::new_suspended,
@@ -156,7 +159,6 @@ fn try_create_window_with_fallback_renderer(
             shared_backend_data.clone(),
             renderer_factory(&shared_backend_data).ok()?,
             attrs.clone(),
-            None,
             #[cfg(any(enable_accesskit, muda))]
             _proxy.clone(),
             #[cfg(all(muda, target_os = "macos"))]
@@ -363,7 +365,10 @@ impl BackendBuilder {
 
         // Initialize the winit event loop and propagate errors if for example `DISPLAY` or `WAYLAND_DISPLAY` isn't set.
 
-        let shared_data = Rc::new(SharedBackendData::new(event_loop_builder)?);
+        let shared_data = Rc::new(SharedBackendData::new(
+            event_loop_builder,
+            self.requested_graphics_api.clone(),
+        )?);
 
         let renderer_factory_fn = match (
             self.renderer_name.as_deref(),
@@ -373,7 +378,7 @@ impl BackendBuilder {
             (Some("gl"), maybe_graphics_api) | (Some("femtovg"), maybe_graphics_api) => {
                 // If a graphics API was requested, double check that it's GL. FemtoVG doesn't support Metal, etc.
                 if let Some(api) = maybe_graphics_api {
-                    i_slint_core::graphics::RequestedOpenGLVersion::try_from(api.clone())?;
+                    i_slint_core::graphics::RequestedOpenGLVersion::try_from(api)?;
                 }
                 renderer::femtovg::GlutinFemtoVGRenderer::new_suspended
             }
@@ -401,7 +406,7 @@ impl BackendBuilder {
             (Some("skia-opengl"), maybe_graphics_api @ _) => {
                 // If a graphics API was requested, double check that it's GL. FemtoVG doesn't support Metal, etc.
                 if let Some(api) = maybe_graphics_api {
-                    i_slint_core::graphics::RequestedOpenGLVersion::try_from(api.clone())?;
+                    i_slint_core::graphics::RequestedOpenGLVersion::try_from(api)?;
                 }
                 renderer::skia::WinitSkiaRenderer::new_opengl_suspended
             }
@@ -434,7 +439,7 @@ impl BackendBuilder {
                         renderer::skia::WinitSkiaRenderer::factory_for_graphics_api(Some(_requested_graphics_api))?
                     } else if #[cfg(all(feature = "renderer-femtovg", supports_opengl))] {
                         // If a graphics API was requested, double check that it's GL. FemtoVG doesn't support Metal, etc.
-                        i_slint_core::graphics::RequestedOpenGLVersion::try_from(_requested_graphics_api.clone())?;
+                        i_slint_core::graphics::RequestedOpenGLVersion::try_from(_requested_graphics_api)?;
                         renderer::femtovg::GlutinFemtoVGRenderer::new_suspended
                     } else {
                         return Err(format!("Graphics API use requested by the compile-time enabled renderers don't support that").into())
@@ -444,7 +449,6 @@ impl BackendBuilder {
         };
 
         Ok(Backend {
-            requested_graphics_api: self.requested_graphics_api,
             renderer_factory_fn,
             event_loop_state: Default::default(),
             window_attributes_hook: self.window_attributes_hook,
@@ -459,6 +463,7 @@ impl BackendBuilder {
 }
 
 pub(crate) struct SharedBackendData {
+    requested_graphics_api: Option<RequestedGraphicsAPI>,
     #[cfg(enable_skia_renderer)]
     skia_context: i_slint_renderer_skia::SkiaSharedContext,
     active_windows: RefCell<HashMap<winit::window::WindowId, Weak<WinitWindowAdapter>>>,
@@ -473,7 +478,10 @@ pub(crate) struct SharedBackendData {
 }
 
 impl SharedBackendData {
-    fn new(mut builder: EventLoopBuilder) -> Result<Self, PlatformError> {
+    fn new(
+        mut builder: EventLoopBuilder,
+        requested_graphics_api: Option<RequestedGraphicsAPI>,
+    ) -> Result<Self, PlatformError> {
         #[cfg(not(target_arch = "wasm32"))]
         use raw_window_handle::HasDisplayHandle;
 
@@ -526,6 +534,7 @@ impl SharedBackendData {
                 .map_err(|display_err| PlatformError::OtherError(display_err.into()))?,
         );
         Ok(Self {
+            requested_graphics_api,
             #[cfg(enable_skia_renderer)]
             skia_context: i_slint_renderer_skia::SkiaSharedContext::default(),
             active_windows: Default::default(),
@@ -589,7 +598,6 @@ impl SharedBackendData {
 /// slint::platform::set_platform(Box::new(Backend::new().unwrap()));
 /// ```
 pub struct Backend {
-    requested_graphics_api: Option<RequestedGraphicsAPI>,
     renderer_factory_fn:
         fn(&Rc<SharedBackendData>) -> Result<Box<dyn WinitCompatibleRenderer>, PlatformError>,
     event_loop_state: RefCell<Option<crate::event_loop::EventLoopState>>,
@@ -684,7 +692,6 @@ impl i_slint_core::platform::Platform for Backend {
                     self.shared_data.clone(),
                     renderer,
                     attrs.clone(),
-                    self.requested_graphics_api.clone(),
                     #[cfg(any(enable_accesskit, muda))]
                     self.shared_data.event_loop_proxy.clone(),
                     #[cfg(all(muda, target_os = "macos"))]
diff --git a/internal/backends/winit/renderer/femtovg.rs b/internal/backends/winit/renderer/femtovg.rs
@@ -22,14 +22,18 @@ mod glcontext;
 #[cfg(supports_opengl)]
 pub struct GlutinFemtoVGRenderer {
     renderer: FemtoVGRenderer<opengl::OpenGLBackend>,
+    requested_graphics_api: Option<RequestedGraphicsAPI>,
 }
 
 #[cfg(supports_opengl)]
 impl GlutinFemtoVGRenderer {
     pub fn new_suspended(
-        _shared_backend_data: &Rc<crate::SharedBackendData>,
+        shared_backend_data: &Rc<crate::SharedBackendData>,
     ) -> Result<Box<dyn WinitCompatibleRenderer>, PlatformError> {
-        Ok(Box::new(Self { renderer: FemtoVGRenderer::new_suspended() }))
+        Ok(Box::new(Self {
+            renderer: FemtoVGRenderer::new_suspended(),
+            requested_graphics_api: shared_backend_data.requested_graphics_api.clone(),
+        }))
     }
 }
 
@@ -47,15 +51,12 @@ impl super::WinitCompatibleRenderer for GlutinFemtoVGRenderer {
         &self,
         active_event_loop: &ActiveEventLoop,
         window_attributes: winit::window::WindowAttributes,
-        #[cfg_attr(target_arch = "wasm32", allow(unused_variables))] requested_graphics_api: Option<
-            RequestedGraphicsAPI,
-        >,
     ) -> Result<Arc<winit::window::Window>, PlatformError> {
         #[cfg(not(target_arch = "wasm32"))]
         let (winit_window, opengl_context) = glcontext::OpenGLContext::new_context(
             window_attributes,
             active_event_loop,
-            requested_graphics_api.map(TryInto::try_into).transpose()?,
+            self.requested_graphics_api.as_ref().map(TryInto::try_into).transpose()?,
         )?;
 
         #[cfg(target_arch = "wasm32")]
@@ -88,16 +89,23 @@ impl super::WinitCompatibleRenderer for GlutinFemtoVGRenderer {
 #[cfg(all(feature = "renderer-femtovg-wgpu", not(target_family = "wasm")))]
 pub struct WGPUFemtoVGRenderer {
     renderer: FemtoVGRenderer<i_slint_renderer_femtovg::wgpu::WGPUBackend>,
+    requested_graphics_api: Option<RequestedGraphicsAPI>,
 }
 
 #[cfg(all(feature = "renderer-femtovg-wgpu", not(target_family = "wasm")))]
 impl WGPUFemtoVGRenderer {
     pub fn new_suspended(
-        _shared_backend_data: &Rc<crate::SharedBackendData>,
+        shared_backend_data: &Rc<crate::SharedBackendData>,
     ) -> Result<Box<dyn WinitCompatibleRenderer>, PlatformError> {
+        if !i_slint_core::graphics::wgpu_26::any_wgpu26_adapters_with_gpu(
+            shared_backend_data.requested_graphics_api.clone(),
+        ) {
+            return Err(PlatformError::from("WGPU: No GPU adapters found"));
+        }
         Ok(Box::new(Self {
             renderer: FemtoVGRenderer::<i_slint_renderer_femtovg::wgpu::WGPUBackend>::new_suspended(
             ),
+            requested_graphics_api: shared_backend_data.requested_graphics_api.clone(),
         }))
     }
 }
@@ -120,7 +128,6 @@ impl WinitCompatibleRenderer for WGPUFemtoVGRenderer {
         &self,
         active_event_loop: &ActiveEventLoop,
         window_attributes: winit::window::WindowAttributes,
-        requested_graphics_api: Option<RequestedGraphicsAPI>,
     ) -> Result<Arc<winit::window::Window>, PlatformError> {
         let winit_window = Arc::new(active_event_loop.create_window(window_attributes).map_err(
             |winit_os_error| {
@@ -136,7 +143,7 @@ impl WinitCompatibleRenderer for WGPUFemtoVGRenderer {
         self.renderer.set_window_handle(
             Box::new(winit_window.clone()),
             crate::winitwindowadapter::physical_size_to_slint(&size),
-            requested_graphics_api,
+            self.requested_graphics_api.clone(),
         )?;
 
         Ok(winit_window)
diff --git a/internal/backends/winit/renderer/skia.rs b/internal/backends/winit/renderer/skia.rs
@@ -11,58 +11,75 @@ use i_slint_renderer_skia::SkiaRenderer;
 
 pub struct WinitSkiaRenderer {
     renderer: SkiaRenderer,
+    requested_graphics_api: Option<RequestedGraphicsAPI>,
 }
 
 impl WinitSkiaRenderer {
     pub fn new_suspended(
         shared_backend_data: &Rc<crate::SharedBackendData>,
     ) -> Result<Box<dyn super::WinitCompatibleRenderer>, PlatformError> {
-        Ok(Box::new(Self { renderer: SkiaRenderer::default(&shared_backend_data.skia_context) }))
+        Ok(Box::new(Self {
+            renderer: SkiaRenderer::default(&shared_backend_data.skia_context),
+            requested_graphics_api: shared_backend_data.requested_graphics_api.clone(),
+        }))
     }
 
     #[cfg(not(target_os = "android"))]
     pub fn new_software_suspended(
         shared_backend_data: &Rc<crate::SharedBackendData>,
-    ) -> Box<dyn super::WinitCompatibleRenderer> {
-        Box::new(Self {
+    ) -> Result<Box<dyn super::WinitCompatibleRenderer>, PlatformError> {
+        Ok(Box::new(Self {
             renderer: SkiaRenderer::default_software(&shared_backend_data.skia_context),
-        })
+            requested_graphics_api: shared_backend_data.requested_graphics_api.clone(),
+        }))
     }
 
     #[cfg(not(ios_and_friends))]
     pub fn new_opengl_suspended(
         shared_backend_data: &Rc<crate::SharedBackendData>,
-    ) -> Box<dyn super::WinitCompatibleRenderer> {
-        Box::new(Self { renderer: SkiaRenderer::default_opengl(&shared_backend_data.skia_context) })
+    ) -> Result<Box<dyn super::WinitCompatibleRenderer>, PlatformError> {
+        Ok(Box::new(Self {
+            renderer: SkiaRenderer::default_opengl(&shared_backend_data.skia_context),
+            requested_graphics_api: shared_backend_data.requested_graphics_api.clone(),
+        }))
     }
 
     #[cfg(target_vendor = "apple")]
     pub fn new_metal_suspended(
         shared_backend_data: &Rc<crate::SharedBackendData>,
-    ) -> Box<dyn super::WinitCompatibleRenderer> {
-        Box::new(Self { renderer: SkiaRenderer::default_metal(&shared_backend_data.skia_context) })
+    ) -> Result<Box<dyn super::WinitCompatibleRenderer>, PlatformError> {
+        Ok(Box::new(Self {
+            renderer: SkiaRenderer::default_metal(&shared_backend_data.skia_context),
+            requested_graphics_api: shared_backend_data.requested_graphics_api.clone(),
+        }))
     }
 
     #[cfg(feature = "renderer-skia-vulkan")]
     pub fn new_vulkan_suspended(
         shared_backend_data: &Rc<crate::SharedBackendData>,
-    ) -> Box<dyn super::WinitCompatibleRenderer> {
-        Box::new(Self { renderer: SkiaRenderer::default_vulkan(&shared_backend_data.skia_context) })
+    ) -> Result<Box<dyn super::WinitCompatibleRenderer>, PlatformError> {
+        Ok(Box::new(Self {
+            renderer: SkiaRenderer::default_vulkan(&shared_backend_data.skia_context),
+            requested_graphics_api: shared_backend_data.requested_graphics_api.clone(),
+        }))
     }
 
     #[cfg(target_family = "windows")]
     pub fn new_direct3d_suspended(
         shared_backend_data: &Rc<crate::SharedBackendData>,
-    ) -> Box<dyn super::WinitCompatibleRenderer> {
-        Box::new(Self {
+    ) -> Result<Box<dyn super::WinitCompatibleRenderer>, PlatformError> {
+        Ok(Box::new(Self {
             renderer: SkiaRenderer::default_direct3d(&shared_backend_data.skia_context),
-        })
+            requested_graphics_api: shared_backend_data.requested_graphics_api.clone(),
+        }))
     }
 
     pub fn factory_for_graphics_api(
         requested_graphics_api: Option<&RequestedGraphicsAPI>,
     ) -> Result<
-        fn(&Rc<crate::SharedBackendData>) -> Box<dyn crate::WinitCompatibleRenderer>,
+        fn(
+            &Rc<crate::SharedBackendData>,
+        ) -> Result<Box<dyn crate::WinitCompatibleRenderer>, PlatformError>,
         PlatformError,
     > {
         match requested_graphics_api {
@@ -130,7 +147,6 @@ impl super::WinitCompatibleRenderer for WinitSkiaRenderer {
         &self,
         active_event_loop: &winit::event_loop::ActiveEventLoop,
         window_attributes: winit::window::WindowAttributes,
-        requested_graphics_api: Option<RequestedGraphicsAPI>,
     ) -> Result<Arc<winit::window::Window>, PlatformError> {
         let winit_window = Arc::new(active_event_loop.create_window(window_attributes).map_err(
             |winit_os_error| {
@@ -147,7 +163,7 @@ impl super::WinitCompatibleRenderer for WinitSkiaRenderer {
             winit_window.clone(),
             winit_window.clone(),
             physical_size_to_slint(&size),
-            requested_graphics_api,
+            self.requested_graphics_api.clone(),
         )?;
 
         self.renderer.set_pre_present_callback(Some(Box::new({
diff --git a/internal/backends/winit/renderer/sw.rs b/internal/backends/winit/renderer/sw.rs
@@ -5,10 +5,10 @@
 
 use core::num::NonZeroU32;
 use core::ops::DerefMut;
+use i_slint_core::graphics::Rgb8Pixel;
 use i_slint_core::platform::PlatformError;
 pub use i_slint_core::software_renderer::SoftwareRenderer;
 use i_slint_core::software_renderer::{PremultipliedRgbaColor, RepaintBufferType, TargetPixel};
-use i_slint_core::{graphics::RequestedGraphicsAPI, graphics::Rgb8Pixel};
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
@@ -180,7 +180,6 @@ impl super::WinitCompatibleRenderer for WinitSoftwareRenderer {
         &self,
         active_event_loop: &ActiveEventLoop,
         window_attributes: winit::window::WindowAttributes,
-        _requested_graphics_api: Option<RequestedGraphicsAPI>,
     ) -> Result<Arc<winit::window::Window>, PlatformError> {
         let winit_window =
             active_event_loop.create_window(window_attributes).map_err(|winit_os_error| {
diff --git a/internal/backends/winit/winitwindowadapter.rs b/internal/backends/winit/winitwindowadapter.rs
@@ -43,7 +43,7 @@ use corelib::platform::{PlatformError, WindowEvent};
 use corelib::window::{WindowAdapter, WindowAdapterInternal, WindowInner};
 use corelib::Property;
 use corelib::{graphics::*, Coord};
-use i_slint_core::{self as corelib, graphics::RequestedGraphicsAPI};
+use i_slint_core::{self as corelib};
 use std::cell::OnceCell;
 #[cfg(any(enable_accesskit, muda))]
 use winit::event_loop::EventLoopProxy;
@@ -323,7 +323,6 @@ pub struct WinitWindowAdapter {
     fullscreen: Cell<bool>,
 
     pub(crate) renderer: Box<dyn WinitCompatibleRenderer>,
-    requested_graphics_api: Option<RequestedGraphicsAPI>,
     /// We cache the size because winit_window.inner_size() can return different value between calls (eg, on X11)
     /// And we wan see the newer value before the Resized event was received, leading to inconsistencies
     size: Cell<PhysicalSize>,
@@ -382,7 +381,6 @@ impl WinitWindowAdapter {
         shared_backend_data: Rc<SharedBackendData>,
         renderer: Box<dyn WinitCompatibleRenderer>,
         window_attributes: winit::window::WindowAttributes,
-        requested_graphics_api: Option<RequestedGraphicsAPI>,
         #[cfg(any(enable_accesskit, muda))] proxy: EventLoopProxy<SlintEvent>,
         #[cfg(all(muda, target_os = "macos"))] muda_enable_default_menu_bar: bool,
     ) -> Rc<Self> {
@@ -405,7 +403,6 @@ impl WinitWindowAdapter {
             has_explicit_size: Default::default(),
             pending_resize_event_after_show: Default::default(),
             renderer,
-            requested_graphics_api,
             #[cfg(target_arch = "wasm32")]
             virtual_keyboard_helper: Default::default(),
             #[cfg(any(enable_accesskit, muda))]
@@ -484,11 +481,7 @@ impl WinitWindowAdapter {
             window_attributes = window_attributes.with_transparent(false);
         }
 
-        let winit_window = self.renderer.resume(
-            active_event_loop,
-            window_attributes,
-            self.requested_graphics_api.clone(),
-        )?;
+        let winit_window = self.renderer.resume(active_event_loop, window_attributes)?;
 
         let scale_factor =
             overriding_scale_factor.unwrap_or_else(|| winit_window.scale_factor() as f32);
diff --git a/internal/core/graphics.rs b/internal/core/graphics.rs
@@ -195,12 +195,14 @@ pub enum RequestedGraphicsAPI {
     WGPU26(wgpu_26::api::WGPUConfiguration),
 }
 
-impl TryFrom<RequestedGraphicsAPI> for RequestedOpenGLVersion {
+impl TryFrom<&RequestedGraphicsAPI> for RequestedOpenGLVersion {
     type Error = PlatformError;
 
-    fn try_from(requested_graphics_api: RequestedGraphicsAPI) -> Result<Self, Self::Error> {
+    fn try_from(requested_graphics_api: &RequestedGraphicsAPI) -> Result<Self, Self::Error> {
         match requested_graphics_api {
-            RequestedGraphicsAPI::OpenGL(requested_open_glversion) => Ok(requested_open_glversion),
+            RequestedGraphicsAPI::OpenGL(requested_open_glversion) => {
+                Ok(requested_open_glversion.clone())
+            }
             RequestedGraphicsAPI::Metal => {
                 Err("Metal rendering is not supported with an OpenGL renderer".into())
             }
diff --git a/internal/core/graphics/wgpu_26.rs b/internal/core/graphics/wgpu_26.rs
diff --git a/internal/renderers/skia/opengl_surface.rs b/internal/renderers/skia/opengl_surface.rs
