Performance fixes for larger files

crates/rnote-compose/src/ext.rs

@@ -172,6 +172,9 @@ where
         split_size: na::Vector2<f64>,
         split_order: SplitOrder,
     ) -> Vec<Self>;
+    /// Gives an aabb of size split_size, snapped to a multiple of split_size
+    /// This returns the first element of a call to `split_extended_origin_aligned`
+    fn split_first_origin_aligned(self, split_size: na::Vector2<f64>) -> Self;
     /// Converts a Aabb to a kurbo Rectangle
     fn to_kurbo_rect(&self) -> kurbo::Rect;
     /// Converts a kurbo Rectangle to Aabb
@@ -394,6 +397,13 @@ impl AabbExt for Aabb {
         split_aabbs
     }
 
+    fn split_first_origin_aligned(self, split_size: na::Vector2<f64>) -> Self {
+        let offset_outer = (self.mins[1] / split_size[1]).floor() * split_size[1];
+        let offset_inner = (self.mins[0] / split_size[0]).floor() * split_size[0];
+        let mins = na::point![offset_inner, offset_outer];
+        Aabb::new(mins, mins + split_size)
+    }
+
     fn split_extended_origin_aligned(
         self,
         split_size: na::Vector2<f64>,

crates/rnote-engine/src/document/mod.rs

@@ -256,14 +256,14 @@ impl Document {
         );
 
         if include_content {
-            let keys = store.stroke_keys_as_rendered();
-            let content_bounds = if let Some(content_bounds) = store.bounds_for_strokes(&keys) {
-                content_bounds
-                    .extend_right_and_bottom_by(na::vector![padding_horizontal, padding_vertical])
-            } else {
+            let content_bounds = if store.keytree_is_empty() {
                 // If doc is empty, resize to one page with the format size
                 Aabb::new(na::point![0.0, 0.0], self.config.format.size().into())
                     .extend_right_and_bottom_by(na::vector![padding_horizontal, padding_vertical])
+            } else {
+                store
+                    .get_bounds()
+                    .extend_right_and_bottom_by(na::vector![padding_horizontal, padding_vertical])
             };
             new_bounds.merge(&content_bounds);
         }
@@ -301,9 +301,11 @@ impl Document {
             .merged(&viewport.extend_by(na::vector![padding_horizontal, padding_vertical]));
 
         if include_content {
-            let keys = store.stroke_keys_as_rendered();
-            let content_bounds = if let Some(content_bounds) = store.bounds_for_strokes(&keys) {
-                content_bounds.extend_by(na::vector![padding_horizontal, padding_vertical])
+            let rendered_bounds = store.get_bounds();
+
+            let content_bounds = if rendered_bounds.volume() > 0.0 {
+                rendered_bounds
+                    .extend_right_and_bottom_by(na::vector![padding_horizontal, padding_vertical])
             } else {
                 // If doc is empty, resize to one page with the format size
                 Aabb::new(na::point![0.0, 0.0], self.config.format.size().into())

crates/rnote-engine/src/engine/mod.rs

@@ -199,7 +199,7 @@ pub struct Engine {
     background_tile_image: Option<render::Image>,
     #[cfg(feature = "ui")]
     #[serde(skip)]
-    background_rendernodes: Vec<gtk4::gsk::RenderNode>,
+    background_rendernode: Option<gtk4::gsk::RenderNode>,
     // Origin indicator rendering
     #[serde(skip)]
     origin_indicator_image: Option<render::Image>,
@@ -225,7 +225,7 @@ impl Default for Engine {
             tasks_rx: Some(EngineTaskReceiver(tasks_rx)),
             background_tile_image: None,
             #[cfg(feature = "ui")]
-            background_rendernodes: Vec::default(),
+            background_rendernode: None,
             origin_indicator_image: None,
             #[cfg(feature = "ui")]
             origin_indicator_rendernode: None,

crates/rnote-engine/src/engine/rendering.rs

@@ -17,11 +17,9 @@ impl Engine {
         {
             use crate::ext::GrapheneRectExt;
             use gtk4::{graphene, gsk, prelude::*};
-            use rnote_compose::SplitOrder;
             use rnote_compose::ext::AabbExt;
 
             let viewport = self.camera.viewport();
-            let mut rendernodes: Vec<gsk::RenderNode> = vec![];
 
             if let Some(image) = &self.background_tile_image {
                 // Only create the texture once, it is expensive
@@ -35,21 +33,17 @@ impl Engine {
                     }
                 };
 
-                for split_bounds in viewport.split_extended_origin_aligned(
-                    self.document.config.background.tile_size(),
-                    SplitOrder::default(),
-                ) {
-                    rendernodes.push(
-                        gsk::TextureNode::new(
-                            &new_texture,
-                            &graphene::Rect::from_p2d_aabb(split_bounds),
-                        )
-                        .upcast(),
-                    );
-                }
-            }
+                let origin_aabb = viewport
+                    .split_first_origin_aligned(self.document.config.background.tile_size());
 
-            self.background_rendernodes = rendernodes;
+                self.background_rendernode = Some(
+                    gsk::TextureNode::new(
+                        &new_texture,
+                        &graphene::Rect::from_p2d_aabb(origin_aabb),
+                    )
+                    .upcast(),
+                );
+            }
         }
 
         #[cfg(feature = "ui")]
@@ -117,7 +111,7 @@ impl Engine {
         self.origin_indicator_image.take();
         #[cfg(feature = "ui")]
         {
-            self.background_rendernodes.clear();
+            self.background_rendernode = None;
             self.origin_indicator_rendernode.take();
         }
         widget_flags.redraw = true;
@@ -251,17 +245,17 @@ impl Engine {
         snapshot.append_node(
             gsk::ColorNode::new(
                 &gdk::RGBA::from_compose_color(self.document.config.background.color),
-                //&gdk::RGBA::RED,
                 &graphene::Rect::from_p2d_aabb(doc_bounds),
             )
             .upcast(),
         );
+        snapshot.pop();
 
-        for r in self.background_rendernodes.iter() {
-            snapshot.append_node(r);
+        if let Some(render_node) = &self.background_rendernode {
+            snapshot.push_repeat(&graphene::Rect::from_p2d_aabb(doc_bounds), None);
+            snapshot.append_node(render_node);
+            snapshot.pop();
         }
-
-        snapshot.pop();
         Ok(())
     }
 

crates/rnote-engine/src/engine/visual_debug.rs

@@ -49,6 +49,12 @@ pub const COLOR_DOC_BOUNDS: Color = Color {
     b: 0.8,
     a: 1.0,
 };
+pub const COLOR_RTREE_BOUNDS: Color = Color {
+    r: 1.0,
+    g: 0.5,
+    b: 0.0,
+    a: 1.0,
+};
 
 #[cfg(feature = "ui")]
 pub(crate) fn draw_bounds_to_gtk_snapshot(

crates/rnote-engine/src/store/keytree.rs

@@ -2,6 +2,7 @@
 use super::StrokeKey;
 use p2d::bounding_volume::Aabb;
 use rstar::primitives::GeomWithData;
+use std::collections::HashMap;
 
 /// The rtree object that holds the bounds and [StrokeKey].
 type KeyTreeObject = GeomWithData<rstar::primitives::Rectangle<[f64; 2]>, StrokeKey>;
@@ -44,6 +45,17 @@ impl KeyTree {
             .collect()
     }
 
+    /// Return the keys that intersect with the given bounds.
+    pub(crate) fn keys_intersecting_bounds_hashset(&self, bounds: Aabb) -> HashMap<StrokeKey, ()> {
+        self.0
+            .locate_in_envelope_intersecting(&rstar::AABB::from_corners(
+                [bounds.mins[0], bounds.mins[1]],
+                [bounds.maxs[0], bounds.maxs[1]],
+            ))
+            .map(|object| (object.data, ()))
+            .collect()
+    }
+
     /// Return the keys that are completely contained in the given bounds.
     pub(crate) fn keys_in_bounds(&self, bounds: Aabb) -> Vec<StrokeKey> {
         self.0
@@ -69,6 +81,18 @@ impl KeyTree {
     pub(crate) fn clear(&mut self) {
         *self = Self::default()
     }
+
+    pub fn get_bounds(&self) -> Aabb {
+        let aabb_enveloppe = self.0.root().envelope();
+        Aabb::new(
+            na::point![aabb_enveloppe.lower()[0], aabb_enveloppe.lower()[1]],
+            na::point![aabb_enveloppe.upper()[0], aabb_enveloppe.upper()[1]],
+        )
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.0.size() == 0
+    }
 }
 
 fn new_keytree_object(key: StrokeKey, bounds: Aabb) -> KeyTreeObject {

crates/rnote-engine/src/store/mod.rs

@@ -9,6 +9,7 @@ pub mod trash_comp;
 // Re-exports
 pub use chrono_comp::ChronoComponent;
 use keytree::KeyTree;
+use p2d::bounding_volume::Aabb;
 pub use render_comp::RenderComponent;
 pub use selection_comp::SelectionComponent;
 pub use trash_comp::TrashComponent;
@@ -147,6 +148,7 @@ impl StrokeStore {
         let tree_objects = self
             .stroke_components
             .iter()
+            .filter(|(key, _stroke)| self.trashed(*key).is_some_and(|x| !x))
             .map(|(key, stroke)| (key, stroke.bounds()))
             .collect();
         self.key_tree.rebuild_from_vec(tree_objects);
@@ -368,4 +370,12 @@ impl StrokeStore {
 
         widget_flags
     }
+
+    pub(super) fn get_bounds(&self) -> Aabb {
+        self.key_tree.get_bounds()
+    }
+
+    pub(super) fn keytree_is_empty(&self) -> bool {
+        self.key_tree.is_empty()
+    }
 }

crates/rnote-engine/src/store/render_comp.rs

@@ -6,7 +6,6 @@ use crate::strokes::content::GeneratedContentImages;
 use crate::{Drawable, render};
 use p2d::bounding_volume::{Aabb, BoundingVolume};
 use rnote_compose::ext::AabbExt;
-use rnote_compose::shapes::Shapeable;
 use tracing::error;
 
 /// The tolerance where check between scale-factors are considered "equal".
@@ -242,28 +241,46 @@ impl StrokeStore {
         viewport: Aabb,
         image_scale: f64,
     ) {
-        let keys = self.render_components.keys().collect::<Vec<StrokeKey>>();
+        let viewport_extended =
+            viewport.extend_by(viewport.extents() * render::VIEWPORT_EXTENTS_MARGIN_FACTOR);
+
+        // we want to iterate on the keys that are in the viewport using the
+        // rtree but also get from this the keys that are not in here
+        // for that also create a slotmap of keys that are in the viewport
+        // so that we can iterate a second time on keys and filter on elements not in the slotmap
+        let mut keys_in_viewport_hash = self
+            .key_tree
+            .keys_intersecting_bounds_hashset(viewport_extended);
+
+        // if we have a current key in the store, push it as well
+        if let Some(current_stroke_key) = self.current_key() {
+            dbg!("add current stroke key to the viewport");
+            dbg!(current_stroke_key);
+            keys_in_viewport_hash.insert(current_stroke_key, ());
+        }
+
+        // remove stroke keys that we know are not in
+        // the viewport
+        // This way we can skip calculating their bounds
+        for (_key, render_comp) in self
+            .render_components
+            .iter_mut()
+            .filter(|x| !keys_in_viewport_hash.contains_key(&x.0))
+        {
+            #[cfg(feature = "ui")]
+            {
+                render_comp.rendernodes = vec![];
+            }
+            render_comp.images = vec![];
+            render_comp.state = RenderCompState::Dirty;
+        }
 
-        for key in keys {
+        for (key, _) in keys_in_viewport_hash {
             if let (Some(stroke), Some(render_comp)) = (
                 self.stroke_components.get(key),
                 self.render_components.get_mut(key),
             ) {
                 let tasks_tx = tasks_tx.clone();
-                let stroke_bounds = stroke.bounds();
-                let viewport_extended =
-                    viewport.extend_by(viewport.extents() * render::VIEWPORT_EXTENTS_MARGIN_FACTOR);
-
-                // skip and clear image buffer if stroke is not in viewport
-                if !viewport_extended.intersects(&stroke_bounds) {
-                    #[cfg(feature = "ui")]
-                    {
-                        render_comp.rendernodes = vec![];
-                    }
-                    render_comp.images = vec![];
-                    render_comp.state = RenderCompState::Dirty;
-                    continue;
-                }
 
                 // only check if rerendering is not forced
                 if !force_regenerate {
@@ -495,6 +512,7 @@ impl StrokeStore {
         use crate::ext::{GdkRGBAExt, GrapheneRectExt};
         use gtk4::{gdk, graphene, prelude::*};
         use rnote_compose::color;
+        use rnote_compose::shapes::Shapeable;
 
         snapshot.push_clip(&graphene::Rect::from_p2d_aabb(doc_bounds));
 
@@ -575,6 +593,7 @@ impl StrokeStore {
     ) -> anyhow::Result<()> {
         use crate::engine::visual_debug;
         use gtk4::prelude::*;
+        use rnote_compose::shapes::Shapeable;
 
         let border_widths = 1.0 / engine.camera.total_zoom();
 
@@ -656,6 +675,15 @@ impl StrokeStore {
             }
         }
 
+        // draw the rtree root
+        let tree_bounds = self.key_tree.get_bounds();
+        visual_debug::draw_bounds_to_gtk_snapshot(
+            tree_bounds,
+            visual_debug::COLOR_RTREE_BOUNDS,
+            snapshot,
+            border_widths,
+        );
+
         Ok(())
     }
 }

crates/rnote-engine/src/store/stroke_comp.rs

@@ -67,7 +67,7 @@ impl StrokeStore {
             .collect()
     }
 
-    /// Storke keys in the order that they should be rendered.
+    /// Stroke keys in the order that they should be rendered.
     pub(crate) fn stroke_keys_as_rendered(&self) -> Vec<StrokeKey> {
         self.keys_sorted_chrono()
             .into_iter()
@@ -127,17 +127,12 @@ impl StrokeStore {
 
     /// Calculate the height needed to fit all strokes.
     pub(crate) fn calc_height(&self) -> f64 {
-        let strokes_iter = self
-            .stroke_keys_unordered()
-            .into_iter()
-            .filter_map(|key| self.stroke_components.get(key));
-
-        let strokes_min_y = strokes_iter
-            .clone()
-            .fold(0.0, |acc, stroke| stroke.bounds().mins[1].min(acc));
-        let strokes_max_y = strokes_iter.fold(0.0, |acc, stroke| stroke.bounds().maxs[1].max(acc));
-
-        strokes_max_y - strokes_min_y
+        if self.keytree_is_empty() {
+            return 0.0;
+        } else {
+            let bounds = self.key_tree.get_bounds();
+            bounds.maxs[1] - bounds.mins[1]
+        }
     }
 
     /// Calculate the width needed to fit all strokes.

crates/rnote-engine/src/store/trash_comp.rs

@@ -49,6 +49,20 @@ impl StrokeStore {
             .map(Arc::make_mut)
         {
             trash_comp.trashed = trash;
+            // remove the key from the rtree (so that the rtree holds information
+            // only for non trashed strokes)
+            // Remark : the corresponding stroke will hold onto its rendernodes and image
+            // until `regenerate_rendering_in_viewport_threaded` is called again
+            if trash {
+                self.key_tree.remove_with_key(key);
+            } else {
+                if let Some(stroke) = Arc::make_mut(&mut self.stroke_components)
+                    .get_mut(key)
+                    .map(Arc::make_mut)
+                {
+                    self.key_tree.update_with_key(key, stroke.bounds());
+                }
+            }
             self.update_chrono_to_last(key);
         }
     }