//! Values worked out from the document and the selection that several frames show unchanged //! (#1571): a pointer move draws about three frames, and a large selection's outlines, slots and //! mixed values cost milliseconds each time. A value is kept with the document snapshot it was //! made from (compared by pointer: an edit is a new snapshot), the selection and whatever else it //! depends on (`extra`: the view's mapping to the screen, a colour…), and made again when any //! differs. use std::sync::{Arc, Weak}; use figcraft_doc::{Document, Node, NodeId}; /// One kept value and what it was made from. The document is held weakly, so a kept value never /// keeps an old snapshot alive; the weak reference keeps its address from being reused. #[derive(Clone)] struct Kept { doc: Weak, sel: Vec, extra: Vec, value: T, } /// The value `name` for `doc`, `sel` and `extra`: the kept one when they are what it was made /// from, else `make()`, kept for next time. pub(crate) fn cached( ctx: &egui::Context, name: &'static str, doc: &Arc, sel: &[NodeId], extra: &[u64], make: impl FnOnce() -> T, ) -> T { let id = egui::Id::unique(("selection_cache", name)); if let Some(k) = ctx.data(|d| d.get_temp::>(id)) && std::ptr::eq(k.doc.as_ptr(), Arc::as_ptr(doc)) && k.sel == sel && k.extra == extra { return k.value; } let value = make(); ctx.data_mut(|d| d.insert_temp(id, Kept { doc: Arc::downgrade(doc), sel: sel.to_vec(), extra: extra.to_vec(), value: value.clone() })); value } /// While a gesture has only moved the selection (`Interaction::moved_by`): the document it /// started from and how far it moved them (page units). What depends only on the selected layers' /// shapes, not where they are, is worked out from that document, so it is kept for the whole /// gesture instead of made again on every move (#1571). pub(crate) fn moved(ds: &figcraft_engine::DocState) -> Option<(Arc, (f64, f64))> { let it = ds.interaction.as_ref()?; let d = it.moved_by?; (it.selection == ds.selection).then(|| (it.doc.clone(), d)) } /// The document to work out from what a move doesn't change (which layers, their kinds and /// parents): the one a gesture that only moved the selection started from, kept for the whole /// gesture ([`moved`]), else `doc`. pub(crate) fn unmoved(ds: &figcraft_engine::DocState, doc: &Arc) -> Arc { moved(ds).map_or_else(|| doc.clone(), |(base, _)| base) } /// The selected layers of the document the Design panel shows, looked up once: its sections go /// over the whole selection many times a frame (mixed values, which kinds are selected), and with /// hundreds of layers selected the lookups cost more than the rest of the panel (#1571). struct Shown { doc: Weak, sel: Vec, nodes: Vec>>, } thread_local! { static SHOWN: std::cell::RefCell> = const { std::cell::RefCell::new(None) }; } /// The panel is about to show `sel` of `doc`: [`with_nodes`] over exactly these reads the layers /// looked up here, kept while the document snapshot and the selection stay the same. pub(crate) fn show(doc: &Arc, sel: &[NodeId]) { SHOWN.with(|s| { let mut s = s.borrow_mut(); if s.as_ref().is_some_and(|k| std::ptr::eq(k.doc.as_ptr(), Arc::as_ptr(doc)) && k.sel == sel) { return; } *s = Some(Shown { doc: Arc::downgrade(doc), sel: sel.to_vec(), nodes: sel.iter().map(|i| doc.node_arc(*i).cloned()).collect() }); }); } /// `f` over the layers of `ids` in `doc`, in order (`None` for one not in it): the ones [`show`] /// kept when `doc` and `ids` are what it was given, else looked up. The kept document is held /// weakly, so its address can't be another document's and its contents can't change. pub(crate) fn with_nodes(doc: &Document, ids: &[NodeId], f: impl FnOnce(&mut dyn Iterator>) -> R) -> R { SHOWN.with(|s| { let s = s.borrow(); match s.as_ref().filter(|k| std::ptr::eq(k.doc.as_ptr(), doc) && k.sel == ids) { Some(k) => f(&mut k.nodes.iter().map(Option::as_deref)), None => f(&mut ids.iter().map(|i| doc.node(*i))), } }) } /// Whether every one of `ids` is in `doc` and passes `f`. pub(crate) fn every(doc: &Document, ids: &[NodeId], f: impl Fn(&Node) -> bool) -> bool { // `Iterator::all` on the `&mut dyn Iterator` itself (sized), not on the trait object. with_nodes(doc, ids, |mut it| Iterator::all(&mut it, |n| n.is_some_and(&f))) } /// A screen point as key material. pub(crate) fn bits(p: egui::Pos2) -> [u64; 2] { [u64::from(p.x.to_bits()), u64::from(p.y.to_bits())] }