Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

View: look hidden bodies up in a set (#10496)

kaltenbrunnermarkusab6e6941c72a
diff --git a/crates/engine/src/cmd/browser.rs b/crates/engine/src/cmd/browser.rs
index c1a64c2dca..685f961d5d 100644
--- a/crates/engine/src/cmd/browser.rs
+++ b/crates/engine/src/cmd/browser.rs
@@ -1424,6 +1424,51 @@ mod tests {
assert_eq!(s.selection.len(), 2);
}
+ /// The viewport asks whether each body is shown several times a frame: a lookup reads the
+ /// set of hidden bodies, not the list, and follows every change of the list, one written in
+ /// place included.
+ #[test]
+ fn hidden_body_lookups_do_not_walk_the_hidden_body_list() {
+ use crate::occurrences::visibility_work;
+
+ let mut s = Session::default();
+ let hide_many = |s: &mut Session, n: usize| {
+ s.visibility.hidden_bodies.clear();
+ s.visibility.hidden_bodies.extend((0..n).map(|i| format!("Hidden{i}")));
+ };
+ let walked_by = |s: &Session, name: &str| {
+ visibility_work::take();
+ let visible = s.body_visible(name);
+ (visible, visibility_work::take())
+ };
+ hide_many(&mut s, 10);
+ let (_, few) = walked_by(&s, "Shown");
+ hide_many(&mut s, 10_000);
+ visibility_work::built_take();
+ let (visible, many) = walked_by(&s, "Shown");
+ assert!(visible);
+ assert!(many <= few, "a lookup walked {many} entries of 10,000 hidden bodies and {few} of 10");
+ assert_eq!(visibility_work::built_take(), 10_000, "the hidden bodies are read into the set once");
+ for i in 0..300 {
+ assert!(walked_by(&s, &format!("Body{i}")) == (true, 0));
+ }
+ assert_eq!(visibility_work::built_take(), 0, "and not again for the next lookups");
+ assert!(!s.body_visible("Hidden5000") && !s.body_visible("Hidden9999"));
+ s.visibility.hidden_bodies.retain(|name| name != "Hidden5000");
+ assert!(s.body_visible("Hidden5000"), "shown again in place");
+ s.visibility.hidden_bodies.push("Shown".into());
+ assert!(!s.body_visible("Shown"), "hidden in place");
+ s.visibility.hidden_bodies.clear();
+ assert!(s.body_visible("Shown") && s.body_visible("Hidden0"), "all shown");
+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "Peg"}));
+ run(&mut s, "browser.visibility", json!({"items": ["Peg"], "visible": false}));
+ assert!(!s.body_visible("Peg"));
+ run(&mut s, "edit.undo", json!({}));
+ assert!(s.body_visible("Peg"), "undo shows it again");
+ run(&mut s, "edit.redo", json!({}));
+ assert!(!s.body_visible("Peg"), "redo hides it again");
+ }
+
#[test]
fn show_all_bodies_clears_stale_hidden_names() {
for folder in ["bodies", "all"] {
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index fabb4e0fad..56b27f9598 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -496,9 +496,9 @@ pub struct Session {
/// (see [`Session::solve_joints`]).
joints_settled: Option<(Arc<Document>, std::sync::Weak<solidcraft_doc::ModelState>)>,
occurrence_visibility_cache: std::sync::Mutex<Option<occurrences::VisibilityCache>>,
- /// The hidden joints and folders of the view, as sets: the browser asks about every joint
- /// of the design on every frame (#3892), and an answer that walked the hidden lists made a
- /// frame cost grow with the size of the design.
+ /// The hidden joints, folders and bodies of the view, as sets: the browser asks about every
+ /// joint of the design on every frame (#3892), the viewport about every body, and an answer
+ /// that walked the hidden lists made a frame cost grow with the size of the design.
visibility_index_cache: std::sync::Mutex<Option<occurrences::VisibilityIndex>>,
/// The sketches a feature uses, with the design they were read from
/// ([`view::sketch_consumed`]): the viewport asks about every sketch several times a frame,
diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rs
index 816c567c40..f3978b9195 100644
--- a/crates/engine/src/occurrences.rs
+++ b/crates/engine/src/occurrences.rs
@@ -32,10 +32,11 @@ pub(crate) struct VisibilityCache {
bodies: std::collections::BTreeSet<String>,
}
-/// The hidden joints and folders of the view, as sets: the browser asks about every joint
-/// and every folder of the design on every frame, and an answer that walked the hidden
-/// lists made a frame cost grow with the size of the design (#3892). The sets are built
-/// when the view changes and are kept until it changes again.
+/// The hidden joints, folders and bodies of the view, as sets: the browser asks about every
+/// joint and every folder of the design on every frame, the viewport about every body several
+/// times a frame, and an answer that walked the hidden lists made a frame cost grow with the
+/// size of the design (#3892). The sets are built when the view changes and are kept until it
+/// changes again.
pub(crate) struct VisibilityIndex {
/// The revision of the design the sets were built for.
revision: u64,
@@ -49,11 +50,16 @@ pub(crate) struct VisibilityIndex {
folders_at: ListId,
/// The hidden folder keys.
folder_keys: std::collections::HashSet<String>,
+ /// Where the hidden bodies were when the sets were built.
+ bodies_at: ListId,
+ /// The names of the bodies hidden themselves.
+ body_names: std::collections::HashSet<String>,
/// The hidden joints and folders, as they were when the sets were built: they are
/// compared with these to tell a change of the view from a change of the design alone
/// (the design changes far more often than the view does).
joints: Vec<u64>,
folders: Vec<String>,
+ bodies: Vec<String>,
}
/// Where a list of hidden items was: the address of its buffer and how many items it held.
@@ -77,15 +83,19 @@ impl VisibilityIndex {
fn new(revision: u64, v: &Visibility) -> VisibilityIndex {
let joint_ids: std::collections::HashSet<u64> = v.hidden_joints.iter().copied().collect();
let folder_keys: std::collections::HashSet<String> = v.hidden_folders.iter().cloned().collect();
- visibility_work::built(joint_ids.len() as u64 + folder_keys.len() as u64);
+ let body_names: std::collections::HashSet<String> = v.hidden_bodies.iter().cloned().collect();
+ visibility_work::built(joint_ids.len() as u64 + folder_keys.len() as u64 + body_names.len() as u64);
VisibilityIndex {
revision,
joints_at: ListId::of(&v.hidden_joints),
joint_ids,
folders_at: ListId::of(&v.hidden_folders),
folder_keys,
+ bodies_at: ListId::of(&v.hidden_bodies),
+ body_names,
joints: v.hidden_joints.clone(),
folders: v.hidden_folders.clone(),
+ bodies: v.hidden_bodies.clone(),
}
}
@@ -103,12 +113,15 @@ impl VisibilityIndex {
&& self.joints.last() == v.hidden_joints.last()
&& self.folders.first() == v.hidden_folders.first()
&& self.folders.last() == v.hidden_folders.last()
+ && self.bodies_at == ListId::of(&v.hidden_bodies)
+ && self.bodies.first() == v.hidden_bodies.first()
+ && self.bodies.last() == v.hidden_bodies.last()
}
/// Are the hidden joints and folders the ones the sets were built from? A design that
/// changed without touching the view leaves the sets alone.
fn same_lists(&self, v: &Visibility) -> bool {
- self.joints == v.hidden_joints && self.folders == v.hidden_folders
+ self.joints == v.hidden_joints && self.folders == v.hidden_folders && self.bodies == v.hidden_bodies
}
/// The lists are the ones the sets were built from, at another revision.
@@ -116,6 +129,7 @@ impl VisibilityIndex {
self.revision = revision;
self.joints_at = ListId::of(&v.hidden_joints);
self.folders_at = ListId::of(&v.hidden_folders);
+ self.bodies_at = ListId::of(&v.hidden_bodies);
}
}
@@ -705,10 +719,10 @@ impl Session {
Ok(count)
}
- /// The hidden joints and folders of the view, as sets: the browser asks about every joint
- /// of the design on every frame, and an answer that walked the hidden lists made a frame
- /// cost grow with the size of the design (#3892). The sets are built when the view changes
- /// and are kept until it changes again.
+ /// The hidden joints, folders and bodies of the view, as sets: the browser asks about every
+ /// joint of the design on every frame, and an answer that walked the hidden lists made a
+ /// frame cost grow with the size of the design (#3892). The sets are built when the view
+ /// changes and are kept until it changes again.
fn visibility_index(&self) -> Option<std::sync::MutexGuard<'_, Option<VisibilityIndex>>> {
let mut cache = self.visibility_index_cache.lock().ok()?;
let v = &self.visibility;
@@ -819,7 +833,7 @@ impl Session {
}
pub fn body_visible(&self, name: &str) -> bool {
- if self.visibility.hidden_bodies.iter().any(|n| n == name) || self.body_removed_later(name) {
+ if self.body_hidden_itself(name) || self.body_removed_later(name) {
return false;
}
let v = &self.visibility;
@@ -840,6 +854,16 @@ impl Session {
!self.bodies_hidden_by_parents().contains(name)
}
+ /// Is the body hidden itself (its own eye; a placement, folder or group may still hide it)?
+ fn body_hidden_itself(&self, name: &str) -> bool {
+ if let Some(cache) = self.visibility_index() {
+ return cache.as_ref().is_some_and(|c| c.body_names.contains(name));
+ }
+ // The lock is poisoned: answer from the list itself.
+ visibility_work::add(self.visibility.hidden_bodies.len() as u64);
+ self.visibility.hidden_bodies.iter().any(|n| n == name)
+ }
+
/// World names of the bodies a hidden placement, folder or group above them hides (their
/// own state aside).
fn bodies_hidden_by_parents(&self) -> std::collections::BTreeSet<String> {