femtovg: Fix rendering of children outside a layer's intrinsic bounding rect

The layer clips (by being a texture), so we must make sure to size it
beyond its intrinsic size and include the bounding rect of the children,
in size **and** position.

cc #9808

Author: tronical

internal/renderers/femtovg/itemrenderer.rs

@@ -38,6 +38,10 @@ pub type CanvasRc<R> = Rc<RefCell<Canvas<R>>>;
 
 pub enum ItemGraphicsCacheEntry<R: femtovg::Renderer + TextureImporter> {
     Texture(Rc<Texture<R>>),
+    TextureWithOrigin {
+        texture: Rc<Texture<R>>,
+        origin: PhysicalPoint,
+    },
     ColorizedImage {
         // This original image Rc is kept here to keep the image in the shared image cache, so that
         // changes to the colorization brush will not require re-uploading the image.
@@ -50,6 +54,9 @@ impl<R: femtovg::Renderer + TextureImporter> Clone for ItemGraphicsCacheEntry<R>
     fn clone(&self) -> Self {
         match self {
             Self::Texture(arg0) => Self::Texture(arg0.clone()),
+            Self::TextureWithOrigin { texture, origin } => {
+                Self::TextureWithOrigin { texture: texture.clone(), origin: origin.clone() }
+            }
             Self::ColorizedImage { _original_image, colorized_image } => Self::ColorizedImage {
                 _original_image: _original_image.clone(),
                 colorized_image: colorized_image.clone(),
@@ -62,6 +69,7 @@ impl<R: femtovg::Renderer + TextureImporter> ItemGraphicsCacheEntry<R> {
     fn as_texture(&self) -> &Rc<Texture<R>> {
         match self {
             ItemGraphicsCacheEntry::Texture(image) => image,
+            ItemGraphicsCacheEntry::TextureWithOrigin { texture, .. } => texture,
             ItemGraphicsCacheEntry::ColorizedImage { colorized_image, .. } => colorized_image,
         }
     }
@@ -670,7 +678,9 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
         let border_width = clip_item.border_width();
 
         if !radius.is_zero() {
-            if let Some(layer_image) = self.render_layer(item_rc, &|| item_rc.geometry()) {
+            if let Some((layer_origin, layer_image)) =
+                self.render_layer(item_rc, &|| item_rc.geometry())
+            {
                 let layer_image_paint = layer_image.as_paint();
 
                 let layer_path = clip_path_for_rect_alike_item(
@@ -769,6 +779,7 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
         });
         let image_id = match cache_entry {
             Some(ItemGraphicsCacheEntry::Texture(image)) => image.id,
+            Some(ItemGraphicsCacheEntry::TextureWithOrigin { texture, .. }) => texture.id,
             Some(ItemGraphicsCacheEntry::ColorizedImage { .. }) => unreachable!(),
             None => return,
         };
@@ -1039,114 +1050,110 @@ impl<'a, R: femtovg::Renderer + TextureImporter> GLItemRenderer<'a, R> {
         &mut self,
         item_rc: &ItemRc,
         layer_bounding_rect_fn: &dyn Fn() -> LogicalRect,
-    ) -> Option<Rc<Texture<R>>> {
+    ) -> Option<(PhysicalPoint, Rc<Texture<R>>)> {
         let existing_layer_texture =
             self.graphics_cache.with_entry(item_rc, |cache_entry| match cache_entry {
-                Some(ItemGraphicsCacheEntry::Texture(texture)) => Some(texture.clone()),
+                Some(ItemGraphicsCacheEntry::TextureWithOrigin { texture, .. }) => {
+                    Some(texture.clone())
+                }
                 _ => None,
             });
 
         let cache_entry = self.graphics_cache.get_or_update_cache_entry(item_rc, || {
-            ItemGraphicsCacheEntry::Texture({
-                let bounding_rect = layer_bounding_rect_fn();
-                let size = (bounding_rect.size * self.scale_factor).ceil().try_cast()?;
-
-                let layer_image = existing_layer_texture
-                    .and_then(|layer_texture| {
-                        // If we have an existing layer texture, there must be only one reference from within
-                        // the existing cache entry and one through the `existing_layer_texture` variable.
-                        // Then it is safe to render new content into it in this callback and when we return
-                        // into `get_or_update_cache_entry` the first ref is dropped.
-                        debug_assert_eq!(Rc::strong_count(&layer_texture), 2);
-                        if layer_texture.size() == Some(size.to_untyped()) {
-                            Some(layer_texture)
-                        } else {
-                            None
-                        }
-                    })
-                    .or_else(|| {
-                        *self.metrics.layers_created.as_mut().unwrap() += 1;
-                        Texture::new_empty_on_gpu(&self.canvas, size.width, size.height)
-                    })?;
+            let bounding_rect = layer_bounding_rect_fn();
+            let origin = bounding_rect.origin * self.scale_factor;
+            let size = (bounding_rect.size * self.scale_factor).ceil().try_cast()?;
+
+            let layer_image = existing_layer_texture
+                .and_then(|layer_texture| {
+                    // If we have an existing layer texture, there must be only one reference from within
+                    // the existing cache entry and one through the `existing_layer_texture` variable.
+                    // Then it is safe to render new content into it in this callback and when we return
+                    // into `get_or_update_cache_entry` the first ref is dropped.
+                    debug_assert_eq!(Rc::strong_count(&layer_texture), 2);
+                    if layer_texture.size() == Some(size.to_untyped()) {
+                        Some(layer_texture)
+                    } else {
+                        None
+                    }
+                })
+                .or_else(|| {
+                    *self.metrics.layers_created.as_mut().unwrap() += 1;
+                    Texture::new_empty_on_gpu(&self.canvas, size.width, size.height)
+                })?;
 
-                let previous_render_target = self.current_render_target();
+            let previous_render_target = self.current_render_target();
 
-                {
-                    let mut canvas = self.canvas.borrow_mut();
-                    canvas.save();
+            {
+                let mut canvas = self.canvas.borrow_mut();
+                canvas.save();
 
-                    canvas.set_render_target(layer_image.as_render_target());
+                canvas.set_render_target(layer_image.as_render_target());
 
-                    canvas.reset();
+                canvas.reset();
 
-                    canvas.clear_rect(
-                        0,
-                        0,
-                        size.width,
-                        size.height,
-                        femtovg::Color::rgba(0, 0, 0, 0),
-                    );
+                canvas.clear_rect(0, 0, size.width, size.height, femtovg::Color::rgba(0, 0, 0, 0));
 
-                    let origin = bounding_rect.origin * self.scale_factor;
-                    canvas.translate(-origin.x, -origin.y);
-                }
+                canvas.translate(-origin.x, -origin.y);
+            }
 
-                *self.state.last_mut().unwrap() = State {
-                    scissor: LogicalRect::new(LogicalPoint::default(), bounding_rect.size),
-                    global_alpha: 1.,
-                    current_render_target: layer_image.as_render_target(),
-                };
+            *self.state.last_mut().unwrap() = State {
+                scissor: bounding_rect,
+                global_alpha: 1.,
+                current_render_target: layer_image.as_render_target(),
+            };
 
-                let window_adapter = self.window().window_adapter();
+            let window_adapter = self.window().window_adapter();
 
-                i_slint_core::item_rendering::render_item_children(
-                    self,
-                    item_rc.item_tree(),
-                    item_rc.index() as isize,
-                    &window_adapter,
-                );
+            i_slint_core::item_rendering::render_item_children(
+                self,
+                item_rc.item_tree(),
+                item_rc.index() as isize,
+                &window_adapter,
+            );
 
-                {
-                    let mut canvas = self.canvas.borrow_mut();
-                    canvas.restore();
+            {
+                let mut canvas = self.canvas.borrow_mut();
+                canvas.restore();
 
-                    canvas.set_render_target(previous_render_target);
-                }
+                canvas.set_render_target(previous_render_target);
+            }
 
-                layer_image
-            })
-            .into()
+            Some(ItemGraphicsCacheEntry::TextureWithOrigin { texture: layer_image, origin })
         });
 
-        cache_entry.map(|item_cache_entry| item_cache_entry.as_texture().clone())
+        cache_entry.and_then(|item_cache_entry| match item_cache_entry {
+            ItemGraphicsCacheEntry::TextureWithOrigin { texture, origin } => {
+                Some((origin, texture.clone()))
+            }
+            _ => None,
+        })
     }
 
     fn render_and_blend_layer(&mut self, alpha_tint: f32, item_rc: &ItemRc) -> RenderingResult {
         let current_clip = self.get_current_clip();
-        if let Some((layer_image, layer_size)) = self
-            .render_layer(item_rc, &|| {
-                // We don't need to include the size of the opacity item itself, since it has no content.
-                let children_rect = i_slint_core::properties::evaluate_no_tracking(|| {
-                    item_rc.geometry().union(
-                        &i_slint_core::item_rendering::item_children_bounding_rect(
-                            item_rc.item_tree(),
-                            item_rc.index() as isize,
-                            &current_clip,
-                        ),
-                    )
-                });
-                children_rect
+        if let Some((layer_origin, layer_image)) = self.render_layer(item_rc, &|| {
+            // We don't need to include the size of the opacity item itself, since it has no content.
+            i_slint_core::properties::evaluate_no_tracking(|| {
+                i_slint_core::item_rendering::item_children_bounding_rect(
+                    item_rc.item_tree(),
+                    item_rc.index() as isize,
+                    &current_clip,
+                )
             })
-            .and_then(|image| image.size().map(|size| (image, size)))
+        }) && let Some(layer_size) = layer_image.size()
         {
             let mut layer_path = femtovg::Path::new();
             // On the paint for the layer, we don't need anti-aliasing on the fringes,
             // since we are just blitting a texture. This saves a triangle strip for the stroke.
             let layer_image_paint =
                 layer_image.as_paint_with_alpha(alpha_tint).with_anti_alias(false);
 
-            layer_path.rect(0., 0., layer_size.width as _, layer_size.height as _);
-            self.canvas.borrow_mut().fill_path(&layer_path, &layer_image_paint);
+            self.canvas.borrow_mut().save_with(|canvas| {
+                canvas.translate(layer_origin.x, layer_origin.y);
+                layer_path.rect(0., 0., layer_size.width as _, layer_size.height as _);
+                canvas.fill_path(&layer_path, &layer_image_paint);
+            });
         }
         RenderingResult::ContinueRenderingWithoutChildren
     }