Metrics collector: measure dirty region

Author: ogoffart

internal/backends/qt/qt_window.rs

@@ -1014,10 +1014,6 @@ impl ItemRenderer for QtItemRenderer<'_> {
             (*painter)->setOpacity((*painter)->opacity() * opacity);
         }}
     }
-
-    fn metrics(&self) -> RenderingMetrics {
-        self.metrics.clone()
-    }
 }
 
 #[derive(Clone)]
@@ -1609,7 +1605,7 @@ impl QtWindow {
                 painter,
                 cache: &self.cache,
                 window: &self.window,
-                metrics: RenderingMetrics { layers_created: Some(0) },
+                metrics: RenderingMetrics { layers_created: Some(0), ..Default::default() },
             };
 
             for (component, origin) in components {
@@ -1624,7 +1620,8 @@ impl QtWindow {
             }
 
             if let Some(collector) = &*self.rendering_metrics_collector.borrow() {
-                collector.measure_frame_rendered(&mut renderer);
+                let metrics = renderer.metrics.clone();
+                collector.measure_frame_rendered(&mut renderer, metrics);
             }
 
             if self.window.has_active_animations() {

internal/core/graphics/rendering_metrics_collector.rs

@@ -29,15 +29,20 @@ pub enum RefreshMode {
 pub struct RenderingMetrics {
     /// The number of layers that were created. None if the renderer does not create layers.
     pub layers_created: Option<usize>,
+
+    /// dirty_region
+    pub dirty_region: Option<crate::partial_renderer::DirtyRegion>,
 }
 
 impl core::fmt::Display for RenderingMetrics {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         if let Some(layer_count) = self.layers_created {
-            write!(f, "[{layer_count} layers created]")
-        } else {
-            Ok(())
+            write!(f, "[{layer_count} layers created]")?
+        }
+        if let Some(dirty_region) = &self.dirty_region {
+            write!(f, "(dirty: {dirty_region:?})")?
         }
+        Ok(())
     }
 }
 
@@ -158,10 +163,11 @@ impl RenderingMetricsCollector {
     pub fn measure_frame_rendered(
         self: &Rc<Self>,
         renderer: &mut dyn crate::item_rendering::ItemRenderer,
+        metrics: RenderingMetrics,
     ) {
         self.collected_frame_data_since_second_ago
             .borrow_mut()
-            .push(FrameData { timestamp: Instant::now(), metrics: renderer.metrics() });
+            .push(FrameData { timestamp: Instant::now(), metrics });
         if matches!(self.refresh_mode, RefreshMode::FullSpeed) {
             crate::animations::CURRENT_ANIMATION_DRIVER
                 .with(|driver| driver.set_has_active_animations());

internal/core/item_rendering.rs

@@ -489,12 +489,6 @@ pub trait ItemRenderer {
 
     /// Return the internal renderer
     fn as_any(&mut self) -> Option<&mut dyn core::any::Any>;
-
-    /// Returns any rendering metrics collecting since the creation of the renderer (typically
-    /// per frame)
-    fn metrics(&self) -> crate::graphics::rendering_metrics_collector::RenderingMetrics {
-        Default::default()
-    }
 }
 
 /// Helper trait to express the features of an item renderer.

internal/core/partial_renderer.rs

@@ -215,12 +215,18 @@ impl PartialRendererCache {
 }
 
 /// A region composed of a few rectangles that need to be redrawn.
-#[derive(Default, Clone, Debug)]
+#[derive(Default, Clone)]
 pub struct DirtyRegion {
     rectangles: [euclid::Box2D<Coord, LogicalPx>; Self::MAX_COUNT],
     count: usize,
 }
 
+impl core::fmt::Debug for DirtyRegion {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:?}", &self.rectangles[..self.count])
+    }
+}
+
 impl DirtyRegion {
     /// The maximum number of rectangles that can be stored in a DirtyRegion
     pub(crate) const MAX_COUNT: usize = 3;

internal/core/software_renderer.rs

@@ -20,7 +20,7 @@ use crate::api::PlatformError;
 use crate::graphics::rendering_metrics_collector::{RefreshMode, RenderingMetricsCollector};
 use crate::graphics::{BorderRadius, Rgba8Pixel, SharedImageBuffer, SharedPixelBuffer};
 use crate::item_rendering::{
-    CachedRenderingData, RenderBorderRectangle, RenderImage, RenderRectangle,
+    CachedRenderingData, ItemRenderer, RenderBorderRectangle, RenderImage, RenderRectangle,
 };
 use crate::item_tree::ItemTreeWeak;
 use crate::items::{ItemRc, TextOverflow, TextWrap};
@@ -634,18 +634,28 @@ impl SoftwareRenderer {
                     }
                 }
 
-                if let Some(metrics) = &self.rendering_metrics_collector {
-                    metrics.measure_frame_rendered(&mut renderer);
-                    if metrics.refresh_mode() == RefreshMode::FullSpeed {
-                        self.partial_rendering_state.force_screen_refresh();
-                    }
-                }
+                self.measure_frame_rendered(&mut renderer);
 
                 dirty_region
             })
             .unwrap_or_default()
     }
 
+    fn measure_frame_rendered(&self, renderer: &mut dyn ItemRenderer) {
+        if let Some(metrics) = &self.rendering_metrics_collector {
+            let prev_frame_dirty = self.prev_frame_dirty.take();
+            let m = crate::graphics::rendering_metrics_collector::RenderingMetrics {
+                dirty_region: Some(prev_frame_dirty.clone()),
+                ..Default::default()
+            };
+            self.prev_frame_dirty.set(prev_frame_dirty);
+            metrics.measure_frame_rendered(renderer, m);
+            if metrics.refresh_mode() == RefreshMode::FullSpeed {
+                self.partial_rendering_state.force_screen_refresh();
+            }
+        }
+    }
+
     /// Render the window, line by line, into the line buffer provided by the [`LineBufferProvider`].
     ///
     /// The renderer uses a cache internally and will only render the part of the window
@@ -1252,12 +1262,7 @@ fn prepare_scene(
         }
     });
 
-    if let Some(metrics) = &software_renderer.rendering_metrics_collector {
-        metrics.measure_frame_rendered(&mut renderer);
-        if metrics.refresh_mode() == RefreshMode::FullSpeed {
-            software_renderer.partial_rendering_state.force_screen_refresh();
-        }
-    }
+    software_renderer.measure_frame_rendered(&mut renderer);
 
     let prepare_scene = renderer.into_inner();
 

internal/renderers/femtovg/itemrenderer.rs

@@ -192,6 +192,10 @@ impl<'a, R: femtovg::Renderer + TextureImporter> GLItemRenderer<'a, R> {
     pub fn global_alpha_transparent(&self) -> bool {
         self.state.last().unwrap().global_alpha == 0.0
     }
+
+    pub fn metrics(&self) -> RenderingMetrics {
+        self.metrics.clone()
+    }
 }
 
 impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer<'a, R> {
@@ -903,10 +907,6 @@ impl<'a, R: femtovg::Renderer + TextureImporter> ItemRenderer for GLItemRenderer
         *state *= opacity;
         self.canvas.borrow_mut().set_global_alpha(*state);
     }
-
-    fn metrics(&self) -> RenderingMetrics {
-        self.metrics.clone()
-    }
 }
 
 #[derive(Clone)]
@@ -1033,7 +1033,7 @@ impl<'a, R: femtovg::Renderer + TextureImporter> GLItemRenderer<'a, R> {
                 global_alpha: 1.,
                 current_render_target: femtovg::RenderTarget::Screen,
             }],
-            metrics: RenderingMetrics { layers_created: Some(0) },
+            metrics: RenderingMetrics { layers_created: Some(0), ..Default::default() },
         }
     }
 

internal/renderers/femtovg/lib.rs

@@ -240,7 +240,8 @@ impl<B: GraphicsBackend> FemtoVGRenderer<B> {
                 }
 
                 if let Some(collector) = &self.rendering_metrics_collector.borrow().as_ref() {
-                    collector.measure_frame_rendered(&mut item_renderer);
+                    let metrics = item_renderer.metrics();
+                    collector.measure_frame_rendered(&mut item_renderer, metrics);
                 }
 
                 let commands = canvas.borrow_mut().flush_to_surface(surface.render_surface());

internal/renderers/skia/lib.rs

@@ -776,7 +776,7 @@ impl SkiaRenderer {
             }
 
             if let Some(collector) = &self.rendering_metrics_collector.borrow_mut().as_ref() {
-                collector.measure_frame_rendered(item_renderer);
+                collector.measure_frame_rendered(item_renderer, Default::default());
                 if collector.refresh_mode()
                     == i_slint_core::graphics::rendering_metrics_collector::RefreshMode::FullSpeed
                 {