Initial anyrender implementation

.cspell/slint-project-words.txt

@@ -15,6 +15,7 @@ amdgpu
 amet
 Amoled
 androideabi
+anyrender
 Appbar
 appicon
 appiconset
@@ -42,6 +43,7 @@ Baselining
 baudrate
 bdata
 Belappetit
+bezpath
 BGRA
 BGRX
 bindgen
@@ -87,6 +89,7 @@ codepoint
 codepoints
 codesign
 codingame
+coeffs
 coldict
 colorspace
 colour
@@ -246,6 +249,7 @@ gltf
 glutin
 glyphclusters
 gnueabihf
+goldens
 grcov
 Grimme
 Grotesk
@@ -308,6 +312,7 @@ kitware
 Klarälvdalens
 kqueue
 ksni
+kurbo
 labore
 laboris
 langtype
@@ -353,6 +358,7 @@ libxrandr
 lightimg
 limax
 linearprogressindicator
+linebender
 linebreaker
 linuxkms
 lipo
@@ -452,6 +458,7 @@ pathlib
 pbjson
 PCLK
 pdoc
+peniko
 picotool
 pixabay
 pixelcolor
@@ -499,6 +506,7 @@ Raleway
 Randriana
 rasterizer
 rasterizes
+rasterizing
 RBUTTONUP
 recompiles
 rects
@@ -610,6 +618,7 @@ targetstruct
 Tdefmt
 tempor
 termcolor
+texels
 texteditor
 textinput
 textinputinterface
@@ -642,6 +651,7 @@ udisksctl
 udivdi
 uintptr
 ullamco
+unclipped
 unfocusable
 unhinted
 unicodes
@@ -653,14 +663,16 @@ unpark
 unparseable
 unpic
 Unpremul
+unpremultiply
 unsendable
 usbc
-userconfig
 usecases
+userconfig
 usize
 usvg
 vbus
 vecmodel
+vello
 veniam
 venv
 verticalbox

.gitattributes

@@ -5,3 +5,6 @@
 tests/driver/rust/tests/*.rs linguist-generated
 # These test files must keep their CRLF line terminators; the syntax test driver checks them.
 internal/compiler/tests/syntax/**/crlf-* -text
+# The anyrender command-stream goldens are compared byte-for-byte; keep LF
+# on every platform so Windows checkouts do not introduce CRLF.
+tests/screenshots/references/anyrender/**/*.json text eol=lf

Cargo.toml

@@ -32,6 +32,7 @@ members = [
   'internal/renderers/software',
   'internal/renderers/skia',
   'internal/renderers/femtovg',
+  'internal/renderers/anyrender',
   'internal/common',
   'internal/compiler',
   'internal/compiler/parser-test-macro',
@@ -92,6 +93,7 @@ i-slint-compiler = { version = "=1.18.0", path = "internal/compiler", default-fe
 i-slint-core = { version = "=1.18.0", path = "internal/core", default-features = false }
 i-slint-core-macros = { version = "=1.18.0", path = "internal/core-macros", default-features = false }
 i-slint-live-preview = { version = "=1.18.0", path = "internal/live-preview", default-features = false }
+i-slint-renderer-anyrender = { version = "=1.18.0", path = "internal/renderers/anyrender", default-features = false }
 i-slint-renderer-femtovg = { version = "=1.18.0", path = "internal/renderers/femtovg", default-features = false }
 i-slint-renderer-skia = { version = "=1.18.0", path = "internal/renderers/skia", default-features = false }
 i-slint-renderer-software = { version = "=1.18.0", path = "internal/renderers/software", default-features = false }

REUSE.toml

@@ -186,6 +186,7 @@ path = [
   "editors/vscode/tests/grammar/**.slint",
 
   "tests/screenshots/**/**.png",
+  "tests/screenshots/references/anyrender/**.json",
 
   "tools/**.md",
   "tools/slintpad/**.html",

internal/renderers/anyrender/Cargo.toml

@@ -0,0 +1,32 @@
+# 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
+
+[package]
+name = "i-slint-renderer-anyrender"
+description = "Slint renderer scaffolding generic over the anyrender backend"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+# Internal for now: no public API commitment yet, and no crates.io release.
+publish = false
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+i-slint-core = { workspace = true, features = ["default", "shared-fontique", "shared-parley", "image-decoders", "svg"] }
+
+vtable = { workspace = true }
+lyon_path = { workspace = true }
+rgb = "0.8.27"
+
+anyrender = { version = "0.11" }
+peniko = { version = "0.6" }
+kurbo = { version = "0.13" }
+
+[package.metadata.docs.rs]
+rustdoc-args = ["--generate-link-to-definition"]

internal/renderers/anyrender/LICENSES/GPL-3.0-only.txt

@@ -0,0 +1 @@
+../../../../LICENSES/GPL-3.0-only.txt

internal/renderers/anyrender/LICENSES/LicenseRef-Slint-Royalty-free-2.0.md

@@ -0,0 +1 @@
+../../../../LICENSES/LicenseRef-Slint-Royalty-free-2.0.md

internal/renderers/anyrender/LICENSES/LicenseRef-Slint-Software-3.0.md

@@ -0,0 +1 @@
+../../../../LICENSES/LicenseRef-Slint-Software-3.0.md

internal/renderers/anyrender/imagecache.rs

@@ -0,0 +1,94 @@
+// 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
+
+//! Shared cache of Slint images converted to [`peniko::ImageData`].
+//!
+//! Converting a Slint image for anyrender means copying pixels (RGB
+//! expansion, SVG rasterization, tile cropping) and wrapping them in a
+//! [`peniko::Blob`]. Doing that per frame is wasteful in itself, but the
+//! bigger cost is downstream: anyrender backends key their own image
+//! resource caches on [`peniko::Blob::id`], so handing out a fresh `Blob`
+//! every frame forces them to re-convert (and, for vello_cpu,
+//! re-premultiply) the image on every fill. This cache returns the *same*
+//! `ImageData` for the same source image across frames, making those
+//! downstream caches effective.
+//!
+//! The caching model mirrors the femtovg renderer's texture cache: this
+//! shared map deduplicates conversions across items, while the strong
+//! references live in the per-item
+//! [`ItemCache`](i_slint_core::item_rendering::ItemCache) held by
+//! `AnyrenderSlintRenderer` (invalidated automatically when item
+//! properties change). [`ImageConversionCache::drain`], called once per
+//! frame, drops entries no item holds on to anymore.
+
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use i_slint_core::graphics::ImageCacheKey;
+
+/// A cached, converted image. Cloning is cheap and shares the underlying
+/// [`peniko::Blob`], keeping its id stable.
+pub type SharedImageData = Rc<peniko::ImageData>;
+
+/// Identifies which derived form of a source image an entry holds.
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub(crate) enum ImageVariant {
+    /// The image data as-is.
+    Full,
+    /// Rasterized at a specific pixel size (SVG).
+    Sized { width: u32, height: u32 },
+    /// A cropped sub-rectangle used as repeating tile. The source image
+    /// dimensions are part of the key because the crop coordinates are in
+    /// image-data space, whose content depends on the rasterized size for
+    /// scalable sources (SVG).
+    Tile { source_width: u32, source_height: u32, x: u32, y: u32, width: u32, height: u32 },
+}
+
+/// See the module documentation.
+#[derive(Default)]
+pub struct ImageConversionCache(HashMap<(ImageCacheKey, ImageVariant), SharedImageData>);
+
+impl ImageConversionCache {
+    /// Look up (or convert and store) the `variant` of the image identified
+    /// by `key`. A `None` (or [`ImageCacheKey::Invalid`]) key means the
+    /// source has no stable identity; the conversion then runs uncached.
+    pub(crate) fn get_or_insert(
+        &mut self,
+        key: Option<ImageCacheKey>,
+        variant: ImageVariant,
+        convert: impl FnOnce() -> Option<peniko::ImageData>,
+    ) -> Option<SharedImageData> {
+        let Some(key) = key.filter(|key| *key != ImageCacheKey::Invalid) else {
+            return convert().map(Rc::new);
+        };
+        match self.0.entry((key, variant)) {
+            std::collections::hash_map::Entry::Occupied(entry) => Some(entry.get().clone()),
+            std::collections::hash_map::Entry::Vacant(slot) => {
+                let image_data = Rc::new(convert()?);
+                slot.insert(image_data.clone());
+                Some(image_data)
+            }
+        }
+    }
+
+    /// Drop entries that are no longer referenced outside the cache. Call
+    /// once per rendered frame, like the femtovg renderer's texture cache
+    /// drain. Tiles are kept as long as their source image survives: they
+    /// are only referenced during the frame (no item holds them), but
+    /// re-cropping them every frame would defeat the cache for tiled
+    /// images.
+    pub(crate) fn drain(&mut self) {
+        self.0.retain(|(_, variant), image_data| {
+            matches!(variant, ImageVariant::Tile { .. }) || Rc::strong_count(image_data) > 1
+        });
+        let live_sources: std::collections::HashSet<ImageCacheKey> = self
+            .0
+            .keys()
+            .filter(|(_, variant)| !matches!(variant, ImageVariant::Tile { .. }))
+            .map(|(key, _)| key.clone())
+            .collect();
+        self.0.retain(|(key, variant), _| {
+            !matches!(variant, ImageVariant::Tile { .. }) || live_sources.contains(key)
+        });
+    }
+}