wgpu: Added support for wgpu 27 with Skia

cc #9605

Author: tronical

CHANGELOG.md

@@ -40,6 +40,8 @@ All notable changes to this project are documented in this file.
  - Minimum Supported Rust Version (MSRV) is 1.88
  - Slint macro: Use new Rust 1.88 API proc_macro API to be able to access file relative to the .rs file
  - Fixed error in generated Rust code when convering some expressions to void
+ - Upgraded WGPU dependency to version 27: The `unstable-wgpu-27` Cargo feature exists next to the old `unstable-wgpu-26` feature,
+   alongside the `slint::wgpu_27` module.
 
 ### Python
 

Cargo.toml

@@ -170,6 +170,7 @@ unicode-segmentation = { version = "1.12.0" }
 glow = { version = "0.16" }
 tikv-jemallocator = { version = "0.6" }
 wgpu-26 = { package = "wgpu", version = "26", default-features = false }
+wgpu-27 = { package = "wgpu", version = "27", default-features = false }
 input = { version = "0.9.0", default-features = false }
 tr = { version = "0.1", default-features = false }
 fontique = { version = "0.5.0" }

api/cpp/cbindgen.rs

@@ -248,6 +248,7 @@ fn default_config() -> cbindgen::Config {
         ("target_os = android".into(), "__ANDROID__".into()),
         // Disable Rust WGPU specific API feature
         ("feature = unstable-wgpu-26".into(), "SLINT_DISABLED_CODE".into()),
+        ("feature = unstable-wgpu-27".into(), "SLINT_DISABLED_CODE".into()),
     ]
     .iter()
     .cloned()

api/rs/slint/Cargo.toml

@@ -189,7 +189,7 @@ backend-android-activity-05 = [
   "i-slint-backend-android-activity/aa-05",
 ]
 
-## Enable support for [WGPU](http://wgpu.rs) based rendering and expose WGPU based APIs based on WGPU version 25.x.
+## Enable support for [WGPU](http://wgpu.rs) based rendering and expose WGPU based APIs based on WGPU version 26.x.
 ##
 ## APIs guarded with this feature are *NOT* subject to the usual Slint API stability guarantees, because WGPU releases new major
 ## versions frequently. This feature as well as the APIs changed or removed in future minor releases of Slint, likely to be replaced
@@ -199,7 +199,7 @@ backend-android-activity-05 = [
 ## in your `Cargo.toml` when enabling this feature:
 ##
 ## ```toml
-## slint = { version = "~1.13", features = ["unstable-wgpu-26"] }
+## slint = { version = "~1.14", features = ["unstable-wgpu-26"] }
 ## ```
 unstable-wgpu-26 = [
   "i-slint-core/unstable-wgpu-26",
@@ -208,6 +208,25 @@ unstable-wgpu-26 = [
   "dep:wgpu-26",
 ]
 
+## Enable support for [WGPU](http://wgpu.rs) based rendering and expose WGPU based APIs based on WGPU version 27.x.
+##
+## APIs guarded with this feature are *NOT* subject to the usual Slint API stability guarantees, because WGPU releases new major
+## versions frequently. This feature as well as the APIs changed or removed in future minor releases of Slint, likely to be replaced
+## by a feature with a similar name but the WGPU version suffix being bumped.
+##
+## To avoid unintended compilation failures, we recommend to use the [tilde requirement](https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#tilde-requirements)
+## in your `Cargo.toml` when enabling this feature:
+##
+## ```toml
+## slint = { version = "~1.14", features = ["unstable-wgpu-27"] }
+## ```
+unstable-wgpu-27 = [
+  "i-slint-core/unstable-wgpu-27",
+  "i-slint-backend-selector/unstable-wgpu-27",
+  "i-slint-backend-android-activity?/unstable-wgpu-27",
+  "dep:wgpu-27",
+]
+
 ## APIs guarded with this feature are *NOT* subject to the usual Slint API stability guarantees, because winit releases new major
 ## versions more frequently than Slint. This feature as well as the APIs changed or removed in future minor releases of Slint, likely to be replaced
 ## by a feature with a similar name but the winit version suffix being bumped.
@@ -256,6 +275,7 @@ raw-window-handle-06 = { workspace = true, optional = true }
 unicode-segmentation = { workspace = true }
 
 wgpu-26 = { workspace = true, optional = true }
+wgpu-27 = { workspace = true, optional = true }
 
 i-slint-backend-winit = { workspace = true, optional = true }
 
@@ -291,6 +311,7 @@ features = [
   "renderer-femtovg",
   "raw-window-handle-06",
   "unstable-wgpu-26",
+  "unstable-wgpu-27",
   "unstable-winit-030",
   "unstable-libinput-09",
 ]

api/rs/slint/lib.rs

@@ -540,6 +540,103 @@ pub mod wgpu_26 {
     pub use i_slint_core::graphics::wgpu_26::api::*;
 }
 
+#[cfg(feature = "unstable-wgpu-27")]
+pub mod wgpu_27 {
+    //! WGPU 27.x specific types and re-exports.
+    //!
+    //! *Note*: This module is behind a feature flag and may be removed or changed in future minor releases,
+    //!         as new major WGPU releases become available.
+    //!
+    //! Use the types in this module in combination with other APIs to integrate external, WGPU-based rendering engines
+    //! into a UI with Slint.
+    //!
+    //! First, ensure that WGPU is used for rendering with Slint by using [`slint::BackendSelector::require_wgpu_26()`](i_slint_backend_selector::api::BackendSelector::require_wgpu_26()).
+    //! This function accepts a pre-configured WGPU setup or configuration hints such as required features or memory limits.
+    //!
+    //! For rendering, it's crucial that you're using the same [`wgpu::Device`] and [`wgpu::Queue`] for allocating textures or submitting commands as Slint. Obtain the same queue
+    //! by either using [`WGPUConfiguration::Manual`] to make Slint use an existing WGPU configuration, or use [`slint::Window::set_rendering_notifier()`](i_slint_core::api::Window::set_rendering_notifier())
+    //! to let Slint invoke a callback that provides access device, queue, etc. in [`slint::GraphicsAPI::WGPU26`](i_slint_core::api::GraphicsAPI::WGPU26).
+    //!
+    //! To integrate rendering content into a scene shared with a Slint UI, use either [`slint::Window::set_rendering_notifier()`](i_slint_core::api::Window::set_rendering_notifier()) to render an underlay
+    //! or overlay, or integrate externally produced [`wgpu::Texture`]s using [`slint::Image::try_from<wgpu::Texture>()`](i_slint_core::graphics::Image::try_from).
+    //!
+    //! The following example allocates a [`wgpu::Texture`] and, for the sake of simplicity in this documentation, fills with green as color, and then proceeds to set it as a `slint::Image` in the scene.
+    //!
+    //! `Cargo.toml`:
+    //! ```toml
+    //! slint = { version = "~1.14", features = ["unstable-wgpu-27"] }
+    //! ```
+    //!
+    //! `main.rs`:
+    //!```rust,no_run
+    //!
+    //! use slint::wgpu_27::wgpu;
+    //! use wgpu::util::DeviceExt;
+    //!
+    //!slint::slint!{
+    //!    export component HelloWorld inherits Window {
+    //!        preferred-width: 320px;
+    //!        preferred-height: 300px;
+    //!        in-out property <image> app-texture;
+    //!        VerticalLayout {
+    //!            Text {
+    //!                text: "hello world";
+    //!                color: green;
+    //!            }
+    //!            Image { source: root.app-texture; }
+    //!        }
+    //!    }
+    //!}
+    //!fn main() -> Result<(), Box<dyn std::error::Error>> {
+    //!    slint::BackendSelector::new()
+    //!        .require_wgpu_27(slint::wgpu_27::WGPUConfiguration::default())
+    //!        .select()?;
+    //!    let app = HelloWorld::new()?;
+    //!
+    //!    let app_weak = app.as_weak();
+    //!
+    //!    app.window().set_rendering_notifier(move |state, graphics_api| {
+    //!        let (Some(app), slint::RenderingState::RenderingSetup, slint::GraphicsAPI::WGPU27{ device, queue, ..}) = (app_weak.upgrade(), state, graphics_api) else {
+    //!            return;
+    //!        };
+    //!
+    //!        let mut pixels = slint::SharedPixelBuffer::<slint::Rgba8Pixel>::new(320, 200);
+    //!        pixels.make_mut_slice().fill(slint::Rgba8Pixel {
+    //!            r: 0,
+    //!            g: 255,
+    //!            b :0,
+    //!            a: 255,
+    //!        });
+    //!
+    //!        let texture = device.create_texture_with_data(queue,
+    //!            &wgpu::TextureDescriptor {
+    //!                label: None,
+    //!                size: wgpu::Extent3d { width: 320, height: 200, depth_or_array_layers: 1 },
+    //!                mip_level_count: 1,
+    //!                sample_count: 1,
+    //!                dimension: wgpu::TextureDimension::D2,
+    //!                format: wgpu::TextureFormat::Rgba8Unorm,
+    //!                usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+    //!                view_formats: &[],
+    //!            },
+    //!            wgpu::util::TextureDataOrder::default(),
+    //!            pixels.as_bytes(),
+    //!        );
+    //!
+    //!        let imported_image = slint::Image::try_from(texture).unwrap();
+    //!
+    //!        app.set_app_texture(imported_image);
+    //!    })?;
+    //!
+    //!    app.run()?;
+    //!
+    //!    Ok(())
+    //!}
+    //!```
+    //!
+    pub use i_slint_core::graphics::wgpu_27::api::*;
+}
+
 #[cfg(feature = "unstable-winit-030")]
 pub mod winit_030 {
     //! Winit 0.30.x specific types and re-exports.

examples/wgpu_texture/Cargo.toml

@@ -15,8 +15,9 @@ path = "main.rs"
 name = "wgpu_texture"
 
 [dependencies]
-slint = { path = "../../api/rs/slint", features = ["unstable-wgpu-26"] }
+slint = { path = "../../api/rs/slint", features = ["unstable-wgpu-27"] }
 bytemuck = { workspace = true }
+wgpu-27 = { workspace = true, features = ["wgsl"] }
 
 [build-dependencies]
 slint-build = { path = "../../api/rs/build" }

examples/wgpu_texture/main.rs

@@ -3,7 +3,7 @@
 
 slint::include_modules!();
 
-use slint::wgpu_26::{wgpu, WGPUConfiguration, WGPUSettings};
+use slint::wgpu_27::{wgpu, WGPUConfiguration, WGPUSettings};
 
 struct DemoRenderer {
     device: wgpu::Device,
@@ -146,7 +146,7 @@ fn main() {
     wgpu_settings.device_required_limits.max_push_constant_size = 16;
 
     slint::BackendSelector::new()
-        .require_wgpu_26(WGPUConfiguration::Automatic(wgpu_settings))
+        .require_wgpu_27(WGPUConfiguration::Automatic(wgpu_settings))
         .select()
         .expect("Unable to create Slint backend with WGPU based renderer");
 
@@ -163,7 +163,7 @@ fn main() {
             match state {
                 slint::RenderingState::RenderingSetup => {
                     match graphics_api {
-                        slint::GraphicsAPI::WGPU26 { device, queue, .. } => {
+                        slint::GraphicsAPI::WGPU27 { device, queue, .. } => {
                             underlay = Some(DemoRenderer::new(device, queue));
                         }
                         _ => return,

internal/backends/android-activity/Cargo.toml

@@ -21,6 +21,7 @@ native-activity = ["android-activity-06?/native-activity", "android-activity-05?
 aa-06 = ["android-activity-06", "ndk-09"]
 aa-05 = ["android-activity-05", "ndk-08"]
 unstable-wgpu-26 = ["i-slint-renderer-skia/unstable-wgpu-26"]
+unstable-wgpu-27 = ["i-slint-renderer-skia/unstable-wgpu-27"]
 
 [target.'cfg(target_os = "android")'.dependencies]
 i-slint-renderer-skia = { workspace = true }

internal/backends/selector/Cargo.toml

@@ -56,6 +56,12 @@ unstable-wgpu-26 = [
   "i-slint-backend-winit?/unstable-wgpu-26",
 ]
 
+unstable-wgpu-27 = [
+  "i-slint-core/unstable-wgpu-27",
+  "i-slint-renderer-skia?/unstable-wgpu-27",
+  "i-slint-backend-winit?/unstable-wgpu-27",
+]
+
 unstable-winit-030 = ["i-slint-backend-winit"]
 
 unstable-libinput-09 = ["dep:input"]

internal/backends/selector/api.rs

@@ -129,6 +129,24 @@ impl BackendSelector {
         self
     }
 
+    #[i_slint_core_macros::slint_doc]
+    /// Adds the requirement to the selector that the backend must render using [WGPU](http://wgpu.rs).
+    /// Use this when you integrate other WGPU-based renderers with a Slint UI.
+    ///
+    /// *Note*: This function is behind the [`unstable-wgpu-27` feature flag](slint:rust:slint/docs/cargo_features/#backends)
+    ///         and may be removed or changed in future minor releases, as new major WGPU releases become available.
+    ///
+    /// See also the [`slint::wgpu_27`](slint:rust:slint/wgpu_27) module.
+    #[cfg(feature = "unstable-wgpu-27")]
+    #[must_use]
+    pub fn require_wgpu_27(
+        mut self,
+        configuration: i_slint_core::graphics::wgpu_27::api::WGPUConfiguration,
+    ) -> Self {
+        self.requested_graphics_api = Some(RequestedGraphicsAPI::WGPU27(configuration));
+        self
+    }
+
     #[i_slint_core_macros::slint_doc]
     /// Configures this builder to use the specified winit hook that will be called before a Window is created.
     ///