SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
perf: a copy placed for showing doesn't turn its revolved faces again (#3044) (#3104)
bherbruck349a6c6fc442
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 052bf92419..82ccad82df 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -5854,7 +5854,7 @@ impl PlacedBodies {fresh.plan_mesh = placed.plan_mesh.clone();fresh}- None => match kernel::transform_matrix(&b.body, *m) {+ None => match kernel::place_matrix(&b.body, *m) {Ok(body) => {let mut fresh = ModelBody::new(name, body, b.feature);fresh.mesh_placement = placed_mesh::PlacedMesh::new(b, m).map(Arc::new);diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsindex 55627e628d..be11a11993 100644--- a/crates/kernel/src/body.rs+++ b/crates/kernel/src/body.rs@@ -53,6 +53,10 @@ pub struct Body {/// Meshes of this solid kept for reuse, set by [`Body::keeping_meshes`]: a check that/// intersects one large body with many small ones meshes it at the same tolerance each time.pub(crate) meshes: Option<std::sync::Arc<MeshMemo>>,+ /// Its revolved faces were turned away from their seams (see `rephase_revolved`), so a+ /// placed copy, which keeps them where they are, need not turn them again: searching every+ /// revolved face of every placed occurrence was most of the time moving an assembly took.+ pub(crate) phased: bool,}/// The meshes made of one solid (see [`Body::keeping_meshes`]), by tolerance, angle and@@ -413,6 +417,8 @@ fn refined_with_cache(pm: &PolygonMesh, surf: &mt::Surface, tol: f64, memoize: b/// (same geometry) so the face sits around angle π, well away from the wrap.fn rephase_revolved(solid: Solid) -> Solid {use mt::{BoundedCurve, ParametricCurve, SearchNearestParameter};+ #[cfg(test)]+ REPHASED.with(|n| n.set(n.get() + 1));let r = guard("rephase", || {let mut changed = false;let mut shells = Vec::new();@@ -531,6 +537,8 @@ fn polyline_mid(pts: &[Vec3]) -> (Vec3, f64) {thread_local! {/// Solids [`Body::new`] meshed on this thread to orient them (tests count the work an import does).pub(crate) static ORIENTED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };+ /// Solids `rephase_revolved` searched on this thread.+ pub(crate) static REPHASED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };}/// Deflection the orientation mesh uses: coarse enough for a large solid, fine enough that a@@ -623,6 +631,7 @@ impl Body {history: None,display_of: None,meshes: None,+ phased: true,})}@@ -631,11 +640,12 @@ impl Body {/// unless it mirrors them, so its orientation is read from the matrix rather than meshed/// again. Only for closed solids; `coarse` is the input's cached missing-face count, which a/// rigid placement preserves exactly.- pub(crate) fn new_placed(solid: Solid, flip: bool, coarse: Option<(f64, usize)>) -> Result<Body> {+ /// `phased`: the solid was placed from a body whose revolved faces are turned already.+ pub(crate) fn new_placed(solid: Solid, flip: bool, coarse: Option<(f64, usize)>, phased: bool) -> Result<Body> {if solid.boundaries().is_empty() {return Err(KernelError::Failed("empty result".into()));}- Body::placed_as_is(rephase_revolved(solid), flip, coarse)+ Body::placed_as_is(if phased { solid } else { rephase_revolved(solid) }, flip, coarse)}/// [`Body::new_placed`] for a solid whose revolved faces were already turned away from@@ -662,6 +672,7 @@ impl Body {history: None,display_of: None,meshes: None,+ phased: true,})}diff --git a/crates/kernel/src/fair.rs b/crates/kernel/src/fair.rsindex 2c65620b15..95bbfa5337 100644--- a/crates/kernel/src/fair.rs+++ b/crates/kernel/src/fair.rs@@ -920,6 +920,7 @@ pub fn fair_faces(body: &Body, faces: &[usize], opts: &FairOptions) -> Result<(Bresult.volume = Some(std::sync::Arc::new(std::sync::Mutex::new(None)));result.coarse_missing = None;result.history = None;+ result.phased = false;let faces: Vec<crate::history::FaceProv> =(0..all.len()).map(|i| crate::record::from_face(0, i, if picked.contains(&i) { Change::Modified } else { Change::Kept })).collect();let result = crate::record::attach(result, &[crate::record::Operand::new(body)], Some(faces), std::collections::HashMap::new())?;diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex b688104771..4d01043c19 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -193,7 +193,7 @@ pub use native::{decode_native_body, encode_native_body, native_preview_mesh};pub use offset::with_same_surface;pub use ops::{BoolOp, boolean, can_join_all_touching_faces, can_join_touching_faces, compound_disjoint_extrusions, half_space, is_planar, join_apart,- split_by_plane, transform, transform_matrix, union_apart, with_attempt_budget,+ place_matrix, split_by_plane, transform, transform_matrix, union_apart, with_attempt_budget,};pub use polybool::{faceted_boolean, planar_boolean};pub use polyhedron::{HalfSpace, convex_polyhedron, draft, offset_faces, shell};diff --git a/crates/kernel/src/meshbody.rs b/crates/kernel/src/meshbody.rsindex 170c0273c7..07436cf3e5 100644--- a/crates/kernel/src/meshbody.rs+++ b/crates/kernel/src/meshbody.rs@@ -114,6 +114,7 @@ pub fn mesh_body(positions: &[Vec3], triangles: &[[u32; 3]]) -> Result<Body> {history: None,display_of: None,meshes: None,+ phased: false,regularization_protected: false,})}@@ -212,6 +213,7 @@ impl Body {history: None,display_of: None,meshes: None,+ phased: false,regularization_protected: self.regularization_protected,})}diff --git a/crates/kernel/src/native.rs b/crates/kernel/src/native.rsindex 0b1af58a54..97a3bc60fe 100644--- a/crates/kernel/src/native.rs+++ b/crates/kernel/src/native.rs@@ -115,6 +115,7 @@ pub fn decode_native_body(bytes: &[u8]) -> Result<Body> {history: None,display_of: None,meshes: None,+ phased: false,regularization_protected: false,};metadata::apply(&mut body, saved.metadata)?;diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rsindex 3339aa851c..238ee378ba 100644--- a/crates/kernel/src/ops.rs+++ b/crates/kernel/src/ops.rs@@ -2095,6 +2095,19 @@ pub(crate) fn rigid_placement(m: &[[f64; 4]; 4]) -> bool {/// Affine transform by a column-major 4x4 matrix (rotations, translations, reflections).pub fn transform_matrix(body: &Body, m: [[f64; 4]; 4]) -> Result<Body> {+ transform_matrix_keeping(body, m, false)+}++/// [`transform_matrix`] for showing a body where an assembly places it (world placement): the+/// revolved faces stay turned the way the body has them instead of being searched again for+/// every placed copy (#3044). A modelling operation keeps using [`transform_matrix`]: where a+/// face wraps all the way round, the turn it finds depends on the copy's own coordinates, and+/// booleans on the copy depend on that.+pub fn place_matrix(body: &Body, m: [[f64; 4]; 4]) -> Result<Body> {+ transform_matrix_keeping(body, m, body.phased)+}++fn transform_matrix_keeping(body: &Body, m: [[f64; 4]; 4], phased: bool) -> Result<Body> {if m.iter().flatten().any(|x| !x.is_finite()) {return Err(KernelError::Invalid("non-finite transform".into()));}@@ -2129,6 +2142,7 @@ pub fn transform_matrix(body: &Body, m: [[f64; 4]; 4]) -> Result<Body> {edges.as_ref(),det3(&m) < 0.0,rigid_placement(&m).then_some(body.coarse_missing).flatten(),+ phased,)?;Ok(placed.with_color(body.color()).with_paint(body.paint().cloned()).with_face_sources(sources).inherit_regularization_protection(body))})diff --git a/crates/kernel/src/outline.rs b/crates/kernel/src/outline.rsindex 66c73ace4e..e65d9331f6 100644--- a/crates/kernel/src/outline.rs+++ b/crates/kernel/src/outline.rs@@ -514,6 +514,7 @@ fn divided(body: &Body, faces: &[usize], other: &[(mt::Edge, Piece)], fr: &Frameregularization_protected: true,display_of: None,meshes: None,+ phased: false,};Ok(Some(record::rebuilt_body(split, &[&body.solid], &rec)))}diff --git a/crates/kernel/src/record.rs b/crates/kernel/src/record.rsindex 5f6e2702c4..f05de1c584 100644--- a/crates/kernel/src/record.rs+++ b/crates/kernel/src/record.rs@@ -146,8 +146,9 @@ pub(crate) fn build_placed(edges: Option<&HashMap<mt::EdgeID, Vec<EdgeOrigin>>>,flip: bool,coarse: Option<(f64, usize)>,+ phased: bool,) -> Result<Body> {- Ok(traced(Body::new_placed(solid, flip, coarse)?, counts, faces, edges))+ Ok(traced(Body::new_placed(solid, flip, coarse, phased)?, counts, faces, edges))}/// The origins of `body`'s edges by identity, from its history `h` (edges in its edge order).diff --git a/crates/kernel/src/splitface.rs b/crates/kernel/src/splitface.rsindex 9e5194c16d..6575c2c5b0 100644--- a/crates/kernel/src/splitface.rs+++ b/crates/kernel/src/splitface.rs@@ -646,6 +646,7 @@ pub(crate) fn split_edges_at(body: &Body, points: &[Vec3]) -> Result<Body> {history: None,display_of: None,meshes: None,+ phased: false,regularization_protected: true,};Ok(crate::record::rebuilt_body(split, &[&body.solid], &rec))@@ -1182,6 +1183,7 @@ pub(crate) fn split_any(body: &Body, faces: &[usize], tool: &SplitTool) -> Resulhistory: None,display_of: None,meshes: None,+ phased: false,regularization_protected: true,};Ok((crate::record::rebuilt_body(split, &[&body.solid], &imp.rec), imp))diff --git a/crates/kernel/src/surfaces.rs b/crates/kernel/src/surfaces.rsindex f47fd0d0d1..87be141471 100644--- a/crates/kernel/src/surfaces.rs+++ b/crates/kernel/src/surfaces.rs@@ -43,6 +43,7 @@ fn surface_of(shell: mt::Shell) -> Body {history: None,display_of: None,meshes: None,+ phased: false,regularization_protected: false,}}diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsindex 2aaa7738e8..d7546cbc53 100644--- a/crates/kernel/src/tests.rs+++ b/crates/kernel/src/tests.rs@@ -2980,3 +2980,35 @@ fn an_attempt_budget_stops_the_boolean_and_is_shared_by_nesting() {assert!(inner && !after);assert!(boolean(&a, &b, BoolOp::Intersect).unwrap().is_some());}++/// Moving an assembly places every body of it again: a copy placed for showing keeps its+/// revolved faces where its source turned them, so placing searches none of them again (that search was most+/// of the time an occurrence move took on a large assembly, #3044), and the copy is the same+/// solid as placing a freshly turned one.+#[test]+fn placing_a_body_does_not_turn_its_revolved_faces_again() {+ let body = cylinder(Vec3::new(1.0, 2.0, 0.0), Vec3::Z, 3.0, 5.0).unwrap();+ assert!(body.phased);+ let m = [[0.0, 1.0, 0.0, 0.0], [-1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [10.0, 20.0, 30.0, 1.0]];+ crate::body::REPHASED.with(|c| c.set(0));+ let mut placed = body.clone();+ for _ in 0..10 {+ placed = crate::place_matrix(&placed, m).unwrap();+ }+ assert_eq!(crate::body::REPHASED.with(|c| c.get()), 0, "no placement searched the revolved faces again");+ // A modelling move (a pattern's copy, a hole's tool) still turns them in its own frame.+ let _ = crate::transform_matrix(&body, m).unwrap();+ assert_eq!(crate::body::REPHASED.with(|c| c.get()), 1);+ crate::body::REPHASED.with(|c| c.set(0));+ assert!(placed.phased);+ let unphased = Body { phased: false, ..body.clone() };+ let mut turned = unphased;+ for _ in 0..10 {+ turned = crate::place_matrix(&turned, m).unwrap();+ }+ assert!(crate::body::REPHASED.with(|c| c.get()) > 0, "a body not known to be turned still is");+ let (a, b) = (measure(&placed).unwrap(), measure(&turned).unwrap());+ assert!((a.volume - b.volume).abs() < 1e-9 * a.volume && (a.area - b.area).abs() < 1e-9 * a.area);+ assert_eq!(a.faces, b.faces);+ assert!(a.bbox.min.dist(b.bbox.min) < 1e-9 && a.bbox.max.dist(b.bbox.max) < 1e-9);+}