Module wgpu_24

Available on crate feature unstable-wgpu-24 only.

WGPU 24.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_24(). 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() to let Slint invoke a callback that provides access device, queue, etc. in slint::GraphicsAPI::WGPU24.

To integrate rendering content into a scene shared with a Slint UI, use either slint::Window::set_rendering_notifier() to render an underlay or overlay, or integrate externally produced [wgpu::Texture]s using slint::Image::try_from<wgpu::Texture>().

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:

slint = { version = "~1.12", features = ["unstable-wgpu-24"] }

main.rs:

 use slint::wgpu_24::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_24(slint::wgpu_24::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::WGPU24{ 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(())
}

Re-exports

pub use wgpu_24 as wgpu;

Structs

WGPUSettings

This data structure provides settings for initializing WGPU renderers.

Enums

WGPUConfiguration

This enum describes the different ways to configure WGPU for rendering.