Skip to content

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

Assembly: reuse reference meshes during rigid joint motion (#2922) (#2924)

takuto-NAb76302e850b6
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index ca8773c4b3..11817bef80 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -1,5 +1,8 @@
//! Timeline evaluation.
+#[path = "placed_mesh.rs"]
+mod placed_mesh;
+
use std::collections::BTreeMap;
use std::hash::{Hash, Hasher};
use std::sync::{Arc, OnceLock};
@@ -28,6 +31,8 @@ pub struct ModelBody {
// Timeline snapshots are cloned before meshes are requested. Share the cell itself so
// meshing any snapshot also warms every unchanged copy of this body.
mesh: Arc<OnceLock<Arc<Mesh>>>,
+ /// Lazy canonical reference triangles for a proper rigid occurrence placement.
+ mesh_placement: Option<Arc<placed_mesh::PlacedMesh>>,
/// The display plan (none when the body has no plan: a mesh body, or one the planner
/// refuses), shared like the mesh. A GPU viewport draws it.
plan: Arc<[OnceLock<Option<Arc<TessPlan>>>; 4]>,
@@ -61,6 +66,7 @@ impl ModelBody {
body,
feature,
mesh: Arc::new(OnceLock::new()),
+ mesh_placement: None,
plan: Arc::new(Default::default()),
plan_mesh: Arc::new(Default::default()),
key: 0,
@@ -83,9 +89,10 @@ impl ModelBody {
// finding their surface, picks naming their face, sketch planes), and a different
// triangulation moved those and changed what designs build. A GPU viewport draws the
// plan ([`ModelBody::display_plan`]).
- self.mesh
- .get_or_init(|| Arc::new(self.body.reference_display_mesh_angular(self.display_tol(), kernel::DISPLAY_ANGLE).unwrap_or_default()))
- .clone()
+ match self.mesh_placement.as_deref() {
+ Some(placed) => self.mesh.get_or_init(|| placed.mesh()).clone(),
+ None => placed_mesh::reference_mesh(&self.body, &self.mesh, self.display_tol()),
+ }
}
/// The display plan of this body at the viewport's display quality
@@ -145,9 +152,10 @@ impl ModelBody {
Some((Arc::new(plan), Arc::new(mesh)))
}
- /// The chord tolerance of [`ModelBody::mesh`] (mm): 1/1000 of the body's size, at least 1 µm.
+ /// The chord tolerance of [`ModelBody::mesh`] (mm): 1/1000 of the definition's size, at least
+ /// 1 µm. Proper rigid placements retain that tolerance along with the reference triangles.
pub fn display_tol(&self) -> f64 {
- (self.body.size() * 1e-3).max(1e-3)
+ self.mesh_placement.as_ref().map(|placed| placed.tolerance).unwrap_or_else(|| (self.body.size() * 1e-3).max(1e-3))
}
/// Already computed display geometry; saving must not trigger cold tessellation.
@@ -5710,11 +5718,19 @@ impl PlacedBodies {
Some((_, placed)) => {
let mut fresh = ModelBody::new(name, placed.body.clone(), b.feature);
fresh.mesh = placed.mesh.clone();
+ fresh.mesh_placement = placed.mesh_placement.clone();
fresh.plan = placed.plan.clone();
fresh.plan_mesh = placed.plan_mesh.clone();
fresh
}
- None => ModelBody::new(name, kernel::transform_matrix(&b.body, *m).unwrap_or_else(|_| b.body.clone()), b.feature),
+ None => match kernel::transform_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);
+ fresh
+ }
+ Err(_) => ModelBody::new(name, b.body.clone(), b.feature),
+ },
}
}
}
diff --git a/crates/doc/src/placed_mesh.rs b/crates/doc/src/placed_mesh.rs
new file mode 100644
index 0000000000..76c7243a41
--- /dev/null
+++ b/crates/doc/src/placed_mesh.rs
@@ -0,0 +1,144 @@
+//! Reference triangles belong to a definition, even while its occurrences move. Keep one lazy
+//! source mesh and map it into each pose; retain the exact placed B-rep separately in ModelBody.
+use std::sync::{Arc, OnceLock};
+
+use solidcraft_geom::{Mesh, Vec3};
+use solidcraft_kernel::{self as kernel, Body};
+
+use super::ModelBody;
+
+#[derive(Debug)]
+pub(super) struct PlacedMesh {
+ body: Body,
+ mesh: Arc<OnceLock<Arc<Mesh>>>,
+ transform: crate::Mat,
+ pub(super) tolerance: f64,
+}
+
+impl PlacedMesh {
+ /// Share the original definition, never a chain of previously placed meshes. A source's
+ /// OnceLock lives with its immutable geometry, so edits get a new source automatically.
+ pub(super) fn new(source: &ModelBody, transform: &crate::Mat) -> Option<Self> {
+ if !proper_rigid(transform) {
+ return None;
+ }
+ Some(match source.mesh_placement.as_deref() {
+ Some(original) => Self {
+ body: original.body.clone(),
+ mesh: original.mesh.clone(),
+ transform: crate::mat_mul(transform, &original.transform),
+ tolerance: original.tolerance,
+ },
+ None => Self { body: source.body.clone(), mesh: source.mesh.clone(), transform: *transform, tolerance: source.display_tol() },
+ })
+ }
+
+ pub(super) fn mesh(&self) -> Arc<Mesh> {
+ let source = reference_mesh(&self.body, &self.mesh, self.tolerance);
+ Arc::new(Mesh {
+ positions: source.positions.iter().map(|p| crate::apply_point(&self.transform, *p)).collect(),
+ normals: source.normals.iter().map(|n| crate::apply_vector(&self.transform, *n)).collect(),
+ edges: source.edges.iter().map(|edge| edge.iter().map(|p| crate::apply_point(&self.transform, *p)).collect()).collect(),
+ triangles: source.triangles.clone(),
+ tri_face: source.tri_face.clone(),
+ edge_faces: source.edge_faces.clone(),
+ seams: source.seams.clone(),
+ smooth_edges: source.smooth_edges.clone(),
+ sharp_edges: source.sharp_edges.clone(),
+ })
+ }
+}
+
+pub(super) fn reference_mesh(body: &Body, mesh: &OnceLock<Arc<Mesh>>, tolerance: f64) -> Arc<Mesh> {
+ mesh.get_or_init(|| Arc::new(body.reference_display_mesh_angular(tolerance, kernel::DISPLAY_ANGLE).unwrap_or_default())).clone()
+}
+
+/// Only proper rotations and translations preserve triangle winding, normal lengths and the
+/// reference chord tolerance. Scale, shear, reflection and malformed matrices use the mesher.
+fn proper_rigid(m: &crate::Mat) -> bool {
+ if m.iter().flatten().any(|v| !v.is_finite()) || m[0][3] != 0. || m[1][3] != 0. || m[2][3] != 0. || m[3][3] != 1. {
+ return false;
+ }
+ let [x, y, z] = [Vec3::new(m[0][0], m[0][1], m[0][2]), Vec3::new(m[1][0], m[1][1], m[1][2]), Vec3::new(m[2][0], m[2][1], m[2][2])];
+ [x, y, z].iter().all(|v| (v.dot(*v) - 1.).abs() < 1e-9)
+ && x.dot(y).abs() < 1e-9
+ && x.dot(z).abs() < 1e-9
+ && y.dot(z).abs() < 1e-9
+ && (x.cross(y).dot(z) - 1.).abs() < 1e-9
+}
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn placed_mesh_is_lazy_and_composes_from_one_immutable_source() {
+ let source = ModelBody::new("Part".into(), kernel::box_solid(Vec3::ZERO, Vec3::new(2., 3., 4.)).unwrap(), 1);
+ let a = crate::rigid(Vec3::new(10., 20., 30.), Vec3::ZERO, Vec3::Z, 0.7);
+ let b = crate::rigid(Vec3::new(3., -5., 2.), Vec3::ZERO, Vec3::X, 0.4);
+ let mut first = ModelBody::new("First".into(), kernel::transform_matrix(&source.body, a).unwrap(), 1);
+ first.mesh_placement = Some(Arc::new(PlacedMesh::new(&source, &a).unwrap()));
+ let mut nested = ModelBody::new("Nested".into(), kernel::transform_matrix(&first.body, b).unwrap(), 1);
+ nested.mesh_placement = Some(Arc::new(PlacedMesh::new(&first, &b).unwrap()));
+ assert_eq!(first.display_tol(), source.display_tol());
+ assert_eq!(nested.display_tol(), source.display_tol());
+ assert!(source.cached_mesh().is_none());
+ assert!(first.cached_mesh().is_none());
+ let mesh = nested.mesh();
+ assert!(source.cached_mesh().is_some(), "the canonical source is warmed on demand");
+ assert!(first.cached_mesh().is_none(), "composition does not retain or evaluate intermediate poses");
+ let local = source.mesh();
+ let matrix = crate::mat_mul(&b, &a);
+ for (p, q) in local.positions.iter().zip(&mesh.positions) {
+ assert!(crate::apply_point(&matrix, *p).dist(*q) < 1e-8);
+ }
+ let (other, work) = kernel::profile::capture(|| first.mesh());
+ assert_eq!(work.tessellate_ms, 0.);
+ assert_eq!(other.tri_face, local.tri_face);
+ assert!(Arc::ptr_eq(&mesh, &nested.mesh()));
+ }
+
+ #[test]
+ fn world_instances_warm_one_definition_and_an_edit_replaces_it() {
+ let mut doc = crate::Document::new("instances");
+ let component = doc.add_component(Some("Part"), 0).unwrap();
+ doc.body_components.insert("Pin".into(), component);
+ let first = doc.occurrences[0].id;
+ doc.occurrences[0].transform = crate::rigid(Vec3::new(10., 0., 0.), Vec3::ZERO, Vec3::Y, 0.3);
+ doc.add_occurrence(component, 0, crate::rigid(Vec3::new(0., 20., 0.), Vec3::ZERO, Vec3::X, 0.6)).unwrap();
+ let mut state = crate::ModelState::default();
+ state.bodies.push(ModelBody::new("Pin".into(), kernel::cylinder(Vec3::ZERO, Vec3::Z, 2., 8.).unwrap(), 1));
+ let mut cache = super::super::PlacedBodies::default();
+ let before = super::super::world_state_reusing(&doc, &state, &mut cache);
+ assert!(state.bodies[0].cached_mesh().is_none(), "placing bodies must remain lazy");
+ let old = before.bodies[0].mesh();
+ assert!(state.bodies[0].cached_mesh().is_some());
+ let (_, work) = kernel::profile::capture(|| before.bodies[1].mesh());
+ assert_eq!(work.tessellate_ms, 0., "the second instance shares the first one's triangulation");
+ doc.occurrences.iter_mut().find(|o| o.id == first).unwrap().transform = crate::rigid(Vec3::new(30., 0., 0.), Vec3::ZERO, Vec3::Y, 0.9);
+ let moved = super::super::world_state_reusing(&doc, &state, &mut cache);
+ let (_, work) = kernel::profile::capture(|| moved.bodies[0].mesh());
+ assert_eq!(work.tessellate_ms, 0., "a new pose shares the same definition");
+ state.bodies[0] = ModelBody::new("Pin".into(), kernel::cylinder(Vec3::ZERO, Vec3::Z, 4., 8.).unwrap(), 1);
+ let edited = super::super::world_state_reusing(&doc, &state, &mut cache);
+ assert!(state.bodies[0].cached_mesh().is_none());
+ let new = edited.bodies[0].mesh();
+ assert!(state.bodies[0].cached_mesh().is_some(), "changed geometry warms its new definition cache");
+ assert_ne!(new.bounds(), moved.bodies[0].mesh().bounds());
+ assert!(Arc::ptr_eq(&old, &before.bodies[0].mesh()), "editing does not mutate older snapshots");
+ }
+ #[test]
+ fn only_proper_rigid_affine_matrices_reuse_reference_meshes() {
+ let source = ModelBody::new("Part".into(), kernel::box_solid(Vec3::ZERO, Vec3::new(2., 3., 4.)).unwrap(), 1);
+ assert!(PlacedMesh::new(&source, &crate::IDENTITY).is_some());
+ for (col, row, value) in [(0, 0, -1.), (0, 0, 2.), (0, 1, 0.5), (0, 3, 0.1), (3, 3, 2.), (3, 0, f64::NAN), (3, 2, f64::INFINITY)] {
+ let mut matrix = crate::IDENTITY;
+ matrix[col][row] = value;
+ assert!(PlacedMesh::new(&source, &matrix).is_none(), "{matrix:?}");
+ }
+ // A positive unit determinant alone is insufficient: this scale changes normals and tolerance.
+ let mut scale = crate::IDENTITY;
+ scale[0][0] = 2.;
+ scale[1][1] = 0.5;
+ assert!(PlacedMesh::new(&source, &scale).is_none());
+ }
+}
diff --git a/crates/engine/src/world_placement_cache_tests.rs b/crates/engine/src/world_placement_cache_tests.rs
index 7d1c4431cc..9bd84a77ec 100644
--- a/crates/engine/src/world_placement_cache_tests.rs
+++ b/crates/engine/src/world_placement_cache_tests.rs
@@ -197,7 +197,7 @@ fn moved_component_bodies_are_not_placed_again_when_something_else_changes() {
let again = after.body(&rim.name).unwrap();
assert!(Arc::ptr_eq(&mesh, &again.mesh()), "an unchanged placed body keeps its mesh");
assert!(again.body.same(&rim.body));
- // The placement moves: placed and meshed again where it now is.
+ // The placement moves: new world coordinates, reusing the definition's triangulation.
run(&mut session, "occurrence.move", json!({"occurrence":occurrence,"translate":[0,50,0]}));
let moved = session.world_state();
let moved_rim = moved.bodies.iter().find(|b| b.source_name.as_deref() == Some("Rim")).unwrap();
@@ -213,3 +213,52 @@ fn moved_component_bodies_are_not_placed_again_when_something_else_changes() {
assert!(source.mesh().bounds().min.dist(Vec3::ZERO) < 1e-6);
assert!(mesh.bounds().min.dist(Vec3::new(100., 0., 0.)) < 1e-6);
}
+
+/// Driving an unchanged definition must map its warm reference triangles, not re-tessellate
+/// the placed B-rep on the first mesh read of every new pose (viewport bounds does that read).
+#[test]
+fn joint_drive_reuses_reference_tessellation_across_rigid_poses() {
+ let mut session = Session::default();
+ run(&mut session, "solid.cylinder", json!({"radius":3,"height":8,"base":[4,0,0],"body_name":"Crank"}));
+ run(&mut session, "component.create", json!({"name":"Crank","parent":"root","activate":false}));
+ run(&mut session, "component.move_bodies", json!({"bodies":["Crank"],"component":"Crank"}));
+ run(
+ &mut session,
+ "joint.as_built",
+ json!({"type":"revolute","name":"Crank","a":0,"b":"Crank","at":{"occurrence":0,"point":[0,0,0],"z":[0,0,1]}}),
+ );
+ let definitions = session.model.state();
+ let original = session.world_state();
+ let local = original.body("Crank").unwrap().mesh();
+ let bounds = local.bounds();
+ for angle in [37., 91., 37., 0.] {
+ let driven = run(&mut session, "joint.drive", json!({"joint":"Crank","value":angle}));
+ assert_eq!(driven["moved"], true);
+ assert!(Arc::ptr_eq(&definitions, &session.model.state()));
+ let world = session.world_state();
+ let body = world.body("Crank").unwrap();
+ let (mesh, work) = crate::kernel::profile::capture(|| body.mesh());
+ assert_eq!(work.tessellate_ms, 0., "a warm definition must not enter the kernel mesher at a new pose: {work:?}");
+ assert_eq!(mesh.positions.len(), local.positions.len());
+ assert_eq!(mesh.normals.len(), local.normals.len());
+ assert_eq!(mesh.edges.iter().map(Vec::len).collect::<Vec<_>>(), local.edges.iter().map(Vec::len).collect::<Vec<_>>());
+ assert_eq!(mesh.triangles, local.triangles);
+ assert_eq!(mesh.tri_face, local.tri_face);
+ assert_eq!(mesh.edge_faces, local.edge_faces);
+ assert_eq!(mesh.seams, local.seams);
+ assert_eq!(mesh.smooth_edges, local.smooth_edges);
+ assert_eq!(mesh.sharp_edges, local.sharp_edges);
+ for (p, q) in local.positions.iter().zip(&mesh.positions) {
+ assert!(crate::doc::apply_point(&body.source_transform, *p).dist(*q) < 1e-8);
+ }
+ for (n, q) in local.normals.iter().zip(&mesh.normals) {
+ assert!(crate::doc::apply_vector(&body.source_transform, *n).dist(*q) < 1e-8);
+ }
+ for (edge, placed) in local.edges.iter().zip(&mesh.edges) {
+ for (p, q) in edge.iter().zip(placed) {
+ assert!(crate::doc::apply_point(&body.source_transform, *p).dist(*q) < 1e-8);
+ }
+ }
+ }
+ assert_eq!(local.bounds(), bounds, "old snapshots stay immutable");
+}