Slint 1.16's femtovg-wgpu renderer configures the wgpu surface via get_default_config() and leaves the composite alpha mode at Auto, which resolves to an opaque surface on KWin/Wayland — a borderless transparent window then shows a black rectangular backing behind the rounded card. WGPUConfiguration exposes no surface/alpha hook, so the only fix is a renderer patch. Vendor i-slint-renderer-femtovg-1.16.1 with a preferred_alpha_mode() that picks a supported non-opaque mode (PreMultiplied / PostMultiplied / Inherit, guarded by the surface's advertised alpha_modes, else Auto) and wire it into set_surface(). Pulled in via [patch.crates-io]; Slint stays pinned =1.16.1. The main window is unaffected (it paints opaque). cx
345 lines
13 KiB
Rust
345 lines
13 KiB
Rust
// Copyright © SixtyFPS GmbH <info@slint.dev>
|
|
// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
|
|
|
|
use std::collections::HashMap;
|
|
use std::rc::Rc;
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
use i_slint_core::graphics::BorrowedOpenGLTexture;
|
|
use i_slint_core::graphics::euclid;
|
|
use i_slint_core::graphics::{ImageCacheKey, IntSize, SharedImageBuffer};
|
|
use i_slint_core::items::ImageTiling;
|
|
use i_slint_core::lengths::PhysicalPx;
|
|
use i_slint_core::{ImageInner, items::ImageRendering};
|
|
|
|
use super::itemrenderer::CanvasRc;
|
|
|
|
pub trait TextureImporter
|
|
where
|
|
Self: femtovg::Renderer + Sized,
|
|
{
|
|
#[cfg(not(target_family = "wasm"))]
|
|
fn convert_opengl_texture(opengl_texture: std::num::NonZero<u32>) -> Self::NativeTexture;
|
|
|
|
#[cfg(feature = "unstable-wgpu-28")]
|
|
fn convert_wgpu_28_texture(wgpu_texture: wgpu_28::Texture) -> Self::NativeTexture;
|
|
}
|
|
|
|
impl TextureImporter for femtovg::renderer::OpenGl {
|
|
#[cfg(not(target_family = "wasm"))]
|
|
fn convert_opengl_texture(opengl_texture: std::num::NonZero<u32>) -> Self::NativeTexture {
|
|
glow::NativeTexture(opengl_texture)
|
|
}
|
|
|
|
#[cfg(feature = "unstable-wgpu-28")]
|
|
fn convert_wgpu_28_texture(_wgpu_texture: wgpu_28::Texture) -> Self::NativeTexture {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
|
|
#[cfg(all(feature = "wgpu-28", not(target_family = "wasm")))]
|
|
impl TextureImporter for femtovg::renderer::WGPURenderer {
|
|
fn convert_opengl_texture(_opengl_texture: std::num::NonZero<u32>) -> Self::NativeTexture {
|
|
todo!()
|
|
}
|
|
|
|
#[cfg(feature = "unstable-wgpu-28")]
|
|
fn convert_wgpu_28_texture(wgpu_texture: wgpu_28::Texture) -> Self::NativeTexture {
|
|
wgpu_texture
|
|
}
|
|
}
|
|
pub struct Texture<R: femtovg::Renderer + TextureImporter> {
|
|
pub id: femtovg::ImageId,
|
|
canvas: CanvasRc<R>,
|
|
}
|
|
|
|
impl<R: femtovg::Renderer + TextureImporter> Texture<R> {
|
|
pub fn size(&self) -> Option<IntSize> {
|
|
self.canvas
|
|
.borrow()
|
|
.image_info(self.id)
|
|
.map(|info| [info.width() as u32, info.height() as u32].into())
|
|
.ok()
|
|
}
|
|
|
|
pub fn as_render_target(&self) -> femtovg::RenderTarget {
|
|
femtovg::RenderTarget::Image(self.id)
|
|
}
|
|
|
|
pub fn adopt(canvas: &CanvasRc<R>, image_id: femtovg::ImageId) -> Rc<Texture<R>> {
|
|
Texture { id: image_id, canvas: canvas.clone() }.into()
|
|
}
|
|
|
|
pub fn new_empty_on_gpu(
|
|
canvas: &CanvasRc<R>,
|
|
width: u32,
|
|
height: u32,
|
|
) -> Option<Rc<Texture<R>>> {
|
|
if width == 0 || height == 0 {
|
|
return None;
|
|
}
|
|
let image_id = canvas
|
|
.borrow_mut()
|
|
.create_image_empty(
|
|
width as usize,
|
|
height as usize,
|
|
femtovg::PixelFormat::Rgba8,
|
|
femtovg::ImageFlags::PREMULTIPLIED | femtovg::ImageFlags::FLIP_Y,
|
|
)
|
|
.unwrap();
|
|
Some(Self { canvas: canvas.clone(), id: image_id }.into())
|
|
}
|
|
|
|
pub(crate) fn filter(&self, filter: femtovg::ImageFilter) -> Rc<Self> {
|
|
let size = self.size().unwrap();
|
|
let filtered_image = Self::new_empty_on_gpu(&self.canvas, size.width, size.height).expect(
|
|
"internal error: this can only fail if the filtered image was zero width or height",
|
|
);
|
|
|
|
self.canvas.borrow_mut().filter_image(filtered_image.id, filter, self.id);
|
|
|
|
filtered_image
|
|
}
|
|
|
|
pub fn as_paint(&self) -> femtovg::Paint {
|
|
self.as_paint_with_alpha(1.0)
|
|
}
|
|
|
|
pub fn as_paint_with_alpha(&self, alpha_tint: f32) -> femtovg::Paint {
|
|
let size = self
|
|
.size()
|
|
.expect("internal error: CachedImage::as_paint() called on zero-sized texture");
|
|
femtovg::Paint::image(
|
|
self.id,
|
|
0.,
|
|
0.,
|
|
size.width as f32,
|
|
size.height as f32,
|
|
0.,
|
|
alpha_tint,
|
|
)
|
|
}
|
|
|
|
// Upload the image to the GPU. This function could take just a canvas as parameter,
|
|
// but since an upload requires a current context, this is "enforced" by taking
|
|
// a renderer instead (which implies a current context).
|
|
pub fn new_from_image(
|
|
image: &ImageInner,
|
|
canvas: &CanvasRc<R>,
|
|
target_size_for_scalable_source: Option<euclid::Size2D<u32, PhysicalPx>>,
|
|
scaling: ImageRendering,
|
|
tiling: (ImageTiling, ImageTiling),
|
|
) -> Option<Rc<Self>> {
|
|
let image_flags = base_image_flags(scaling, tiling);
|
|
|
|
let image_id = match image {
|
|
#[cfg(target_arch = "wasm32")]
|
|
ImageInner::HTMLImage(html_image) => {
|
|
if html_image.size().is_some() {
|
|
// Anecdotal evidence suggests that HTMLImageElement converts to a texture with
|
|
// pre-multiplied alpha. It's possible that this is not generally applicable, but it
|
|
// is the case for SVGs.
|
|
let image_flags = if html_image.is_svg() {
|
|
if let Some(target_size) = target_size_for_scalable_source {
|
|
let dom_element = &html_image.dom_element;
|
|
dom_element.set_width(target_size.width);
|
|
dom_element.set_height(target_size.height);
|
|
}
|
|
image_flags | femtovg::ImageFlags::PREMULTIPLIED
|
|
} else {
|
|
image_flags
|
|
};
|
|
canvas.borrow_mut().create_image(&html_image.dom_element, image_flags).unwrap()
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
ImageInner::BorrowedOpenGLTexture(BorrowedOpenGLTexture {
|
|
texture_id,
|
|
size,
|
|
origin,
|
|
..
|
|
}) => {
|
|
let image_flags = match origin {
|
|
i_slint_core::graphics::BorrowedOpenGLTextureOrigin::TopLeft => image_flags,
|
|
i_slint_core::graphics::BorrowedOpenGLTextureOrigin::BottomLeft => {
|
|
image_flags | femtovg::ImageFlags::FLIP_Y
|
|
}
|
|
_ => unimplemented!(
|
|
"internal error: missing implementation for BorrowedOpenGLTextureOrigin"
|
|
),
|
|
};
|
|
canvas
|
|
.borrow_mut()
|
|
.create_image_from_native_texture(
|
|
<R as TextureImporter>::convert_opengl_texture(*texture_id),
|
|
femtovg::ImageInfo::new(
|
|
image_flags,
|
|
size.width as _,
|
|
size.height as _,
|
|
femtovg::PixelFormat::Rgba8,
|
|
),
|
|
)
|
|
.unwrap()
|
|
}
|
|
#[cfg(all(not(target_arch = "wasm32"), feature = "unstable-wgpu-28"))]
|
|
ImageInner::WGPUTexture(i_slint_core::graphics::WGPUTexture::WGPU28Texture(
|
|
texture,
|
|
)) => {
|
|
let texture = texture.clone();
|
|
let size = texture.size();
|
|
|
|
canvas
|
|
.borrow_mut()
|
|
.create_image_from_native_texture(
|
|
<R as TextureImporter>::convert_wgpu_28_texture(texture),
|
|
femtovg::ImageInfo::new(
|
|
image_flags,
|
|
size.width as _,
|
|
size.height as _,
|
|
femtovg::PixelFormat::Rgba8,
|
|
),
|
|
)
|
|
.unwrap()
|
|
}
|
|
#[cfg(all(not(target_arch = "wasm32"), feature = "unstable-wgpu-27"))]
|
|
ImageInner::WGPUTexture(i_slint_core::graphics::WGPUTexture::WGPU27Texture(..)) => {
|
|
return None;
|
|
}
|
|
_ => {
|
|
let buffer = image.render_to_buffer(target_size_for_scalable_source)?;
|
|
let (image_source, flags) = image_buffer_to_image_source(&buffer);
|
|
canvas.borrow_mut().create_image(image_source, image_flags | flags).unwrap()
|
|
}
|
|
};
|
|
|
|
Some(Self::adopt(canvas, image_id))
|
|
}
|
|
}
|
|
|
|
impl<R: femtovg::Renderer + TextureImporter> Drop for Texture<R> {
|
|
fn drop(&mut self) {
|
|
self.canvas.borrow_mut().delete_image(self.id);
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, Hash, Debug)]
|
|
pub struct TextureCacheKey {
|
|
source_key: ImageCacheKey,
|
|
target_size_for_scalable_source: Option<euclid::Size2D<u32, PhysicalPx>>,
|
|
gpu_image_flags: ImageRendering,
|
|
gpu_image_tiling: (ImageTiling, ImageTiling),
|
|
}
|
|
|
|
impl TextureCacheKey {
|
|
pub fn new(
|
|
resource: &ImageInner,
|
|
target_size_for_scalable_source: Option<euclid::Size2D<u32, PhysicalPx>>,
|
|
gpu_image_flags: ImageRendering,
|
|
gpu_image_tiling: (ImageTiling, ImageTiling),
|
|
) -> Option<Self> {
|
|
ImageCacheKey::new(resource).map(|source_key| Self {
|
|
source_key,
|
|
target_size_for_scalable_source,
|
|
gpu_image_flags,
|
|
gpu_image_tiling,
|
|
})
|
|
}
|
|
}
|
|
|
|
// Cache used to avoid repeatedly decoding images from disk. Entries with a count
|
|
// of 1 are drained after flushing the renderer commands to the screen.
|
|
pub struct TextureCache<R: femtovg::Renderer + TextureImporter>(
|
|
HashMap<TextureCacheKey, Rc<Texture<R>>>,
|
|
);
|
|
|
|
impl<R: femtovg::Renderer + TextureImporter> Default for TextureCache<R> {
|
|
fn default() -> Self {
|
|
Self(Default::default())
|
|
}
|
|
}
|
|
|
|
impl<R: femtovg::Renderer + TextureImporter> TextureCache<R> {
|
|
// Look up the given image cache key in the image cache and upgrade the weak reference to a strong one if found,
|
|
// otherwise a new image is created/loaded from the given callback.
|
|
pub(crate) fn lookup_image_in_cache_or_create(
|
|
&mut self,
|
|
cache_key: TextureCacheKey,
|
|
image_create_fn: impl Fn() -> Option<Rc<Texture<R>>>,
|
|
) -> Option<Rc<Texture<R>>> {
|
|
Some(match self.0.entry(cache_key) {
|
|
std::collections::hash_map::Entry::Occupied(existing_entry) => {
|
|
existing_entry.get().clone()
|
|
}
|
|
std::collections::hash_map::Entry::Vacant(vacant_entry) => {
|
|
let new_image = image_create_fn()?;
|
|
vacant_entry.insert(new_image.clone());
|
|
new_image
|
|
}
|
|
})
|
|
}
|
|
|
|
pub(crate) fn drain(&mut self) {
|
|
self.0.retain(|_, cached_image| {
|
|
// * Retain images that are used by elements, so that they can be effectively
|
|
// shared (one image element refers to foo.png, another element is created
|
|
// and refers to the same -> share).
|
|
// * Also retain images that are still loading (async HTML), where the size
|
|
// is not known yet. Otherwise we end up in a loop where an image is not loaded
|
|
// yet, we report (0, 0) to the layout, the image gets removed here, the closure
|
|
// still triggers a load and marks the layout as dirt, which loads the
|
|
// image again, etc.
|
|
Rc::strong_count(cached_image) > 1 || cached_image.size().is_none()
|
|
});
|
|
}
|
|
|
|
pub(crate) fn clear(&mut self) {
|
|
self.0.clear();
|
|
}
|
|
}
|
|
|
|
fn image_buffer_to_image_source(
|
|
buffer: &SharedImageBuffer,
|
|
) -> (femtovg::ImageSource<'_>, femtovg::ImageFlags) {
|
|
match buffer {
|
|
SharedImageBuffer::RGB8(buffer) => (
|
|
{
|
|
imgref::ImgRef::new(buffer.as_slice(), buffer.width() as _, buffer.height() as _)
|
|
.into()
|
|
},
|
|
femtovg::ImageFlags::empty(),
|
|
),
|
|
SharedImageBuffer::RGBA8(buffer) => (
|
|
{
|
|
imgref::ImgRef::new(buffer.as_slice(), buffer.width() as _, buffer.height() as _)
|
|
.into()
|
|
},
|
|
femtovg::ImageFlags::empty(),
|
|
),
|
|
SharedImageBuffer::RGBA8Premultiplied(buffer) => (
|
|
{
|
|
imgref::ImgRef::new(buffer.as_slice(), buffer.width() as _, buffer.height() as _)
|
|
.into()
|
|
},
|
|
femtovg::ImageFlags::PREMULTIPLIED,
|
|
),
|
|
}
|
|
}
|
|
|
|
pub fn base_image_flags(
|
|
scaling: ImageRendering,
|
|
tiling: (ImageTiling, ImageTiling),
|
|
) -> femtovg::ImageFlags {
|
|
(match scaling {
|
|
ImageRendering::Pixelated => femtovg::ImageFlags::NEAREST,
|
|
ImageRendering::Smooth | _ => femtovg::ImageFlags::empty(),
|
|
} | match tiling.0 {
|
|
ImageTiling::Repeat | ImageTiling::Round => femtovg::ImageFlags::REPEAT_X,
|
|
ImageTiling::None | _ => femtovg::ImageFlags::empty(),
|
|
} | match tiling.1 {
|
|
ImageTiling::Repeat | ImageTiling::Round => femtovg::ImageFlags::REPEAT_Y,
|
|
ImageTiling::None | _ => femtovg::ImageFlags::empty(),
|
|
})
|
|
}
|