SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Show imported mesh edges in shaded and wireframe views (#5662) (#5740)
Colin Faulkingham699f5264297e
diff --git a/crates/doc/src/placed_mesh.rs b/crates/doc/src/placed_mesh.rsindex 1b8f00c4d3..4a945b38a2 100644--- a/crates/doc/src/placed_mesh.rs+++ b/crates/doc/src/placed_mesh.rs@@ -87,6 +87,7 @@ impl PlacedMesh {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(),+ display_only_edges: source.display_only_edges,triangles: source.triangles.clone(),tri_face: source.tri_face.clone(),edge_faces: source.edge_faces.clone(),@@ -115,7 +116,51 @@ pub(super) fn definition_plan(}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()+ mesh.get_or_init(|| {+ let mut mesh = body.reference_display_mesh_angular(tolerance, kernel::DISPLAY_ANGLE).unwrap_or_default();+ if let Some((positions, triangles)) = body.triangle_mesh() {+ mesh.edges = mesh_outlines(positions, triangles);+ mesh.display_only_edges = true;+ }+ Arc::new(mesh)+ })+ .clone()+}++/// Display lines for an imported triangle mesh: open boundaries, non-manifold sides and+/// creases of at least 30 degrees. The shared vertex indices come from the existing mesh body;+/// the geometry, winding and triangle topology are left to the importer.+fn mesh_outlines(positions: &[Vec3], triangles: &[[u32; 3]]) -> Vec<Vec<Vec3>> {+ let normal = |index: usize| {+ let t = triangles.get(index)?;+ let (a, b, c) = (positions.get(t[0] as usize)?, positions.get(t[1] as usize)?, positions.get(t[2] as usize)?);+ (*b - *a).cross(*c - *a).normalized()+ };+ // One compact record per side, sorted for deterministic output, instead of a map of+ // separately allocated adjacency lists. Mesh imports already cap the triangle count.+ let mut sides = Vec::with_capacity(triangles.len().saturating_mul(3));+ for (i, t) in triangles.iter().enumerate() {+ let Ok(triangle) = u32::try_from(i) else { continue };+ if normal(i).is_some() {+ for (a, b) in [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])] {+ sides.push((a.min(b), a.max(b), triangle));+ }+ }+ }+ sides.sort_unstable();+ let cos = 30f64.to_radians().cos();+ let mut edges = Vec::new();+ for side in sides.chunk_by(|a, b| (a.0, a.1) == (b.0, b.1)) {+ let Some(&(a, b, _)) = side.first() else { continue };+ let visible = match side {+ [(_, _, i), (_, _, j)] => normal(*i as usize).zip(normal(*j as usize)).is_some_and(|(n, m)| n.dot(m) <= cos),+ _ => true,+ };+ if visible && let (Some(&a), Some(&b)) = (positions.get(a as usize), positions.get(b as usize)) {+ edges.push(vec![a, b]);+ }+ }+ edges}/// Only proper rotations and translations preserve triangle winding, normal lengths and the@@ -135,6 +180,45 @@ fn proper_rigid(m: &crate::Mat) -> bool {mod tests {use super::*;+ #[test]+ fn mesh_outlines_keep_boundaries_and_creases_without_smooth_facet_lines() {+ for (degrees, expected) in [(0.0f64, 4), (15.0, 4), (30.0, 5), (45.0, 5), (90.0, 5)] {+ let angle = degrees.to_radians();+ let p = [Vec3::ZERO, Vec3::X, Vec3::Y, Vec3::new(0., -angle.cos(), angle.sin())];+ let triangles = [[0, 1, 2], [1, 0, 3]];+ let edges = mesh_outlines(&p, &triangles);+ assert_eq!(edges.len(), expected, "hinge angle {degrees}");+ assert_eq!(edges.iter().any(|e| e == &[Vec3::ZERO, Vec3::X]), degrees >= 30.);+ assert_eq!(edges, mesh_outlines(&p, &triangles), "deterministic order");+ }+ // A third triangle makes the common side non-manifold: keep it once, even if coplanar.+ let p = [Vec3::ZERO, Vec3::X, Vec3::Y, -Vec3::Y, Vec3::Y * 2.];+ let edges = mesh_outlines(&p, &[[0, 1, 2], [1, 0, 3], [0, 1, 4]]);+ assert_eq!(edges.len(), 7);+ assert_eq!(edges.iter().filter(|e| **e == [Vec3::ZERO, Vec3::X]).count(), 1);+ // The rings of an open faceted cylinder stay visible, but its smooth wall has no+ // diagonals or longitudinal facet lines.+ let n = 36u32;+ let mut p = Vec::new();+ for z in [0., 10.] {+ p.extend((0..n).map(|i| {+ let a = f64::from(i) * std::f64::consts::TAU / f64::from(n);+ Vec3::new(a.cos(), a.sin(), z)+ }));+ }+ let triangles: Vec<_> = (0..n)+ .flat_map(|i| {+ let j = (i + 1) % n;+ [[i, j, j + n], [i, j + n, i + n]]+ })+ .collect();+ let edges = mesh_outlines(&p, &triangles);+ assert_eq!(edges.len(), 2 * n as usize);+ assert!(edges.iter().all(|e| e[0].z == e[1].z));+ // Bad indices and zero-area facets do not invent outlines or panic.+ assert!(mesh_outlines(&[Vec3::ZERO, Vec3::X, Vec3::X * 2.], &[[0, 1, 99], [0, 1, 2]]).is_empty());+ }+#[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);diff --git a/crates/geom/src/mesh.rs b/crates/geom/src/mesh.rsindex dc166714cf..3a0bd95095 100644--- a/crates/geom/src/mesh.rs+++ b/crates/geom/src/mesh.rs@@ -92,7 +92,7 @@ impl Extend<Vec3> for Aabb3 {}/// An indexed triangle mesh with per-vertex normals, a face id per triangle (the B-rep face it-/// came from) and edge polylines (the B-rep edges, for display and picking).+/// came from) and edge polylines (B-rep edges for display and picking, or mesh outlines).#[derive(Clone, Debug, Default, Serialize, Deserialize)]pub struct Mesh {pub positions: Vec<Vec3>,@@ -101,8 +101,12 @@ pub struct Mesh {pub triangles: Vec<[u32; 3]>,/// B-rep face index per triangle.pub tri_face: Vec<u32>,- /// B-rep edges as polylines.+ /// Edge polylines; mesh outlines have `display_only_edges` set.pub edges: Vec<Vec<Vec3>>,+ /// These polylines belong to a triangle mesh, not selectable B-rep edges. Rebuilt with+ /// the display mesh; never part of the saved design's geometry.+ #[serde(skip)]+ pub display_only_edges: bool,/// Per edge: a seam between two pieces of the same smooth surface (not drawn).#[serde(default)]pub seams: Vec<bool>,@@ -369,13 +373,18 @@ impl Mesh {impl Mesh {/// Visibility in shaded edge presentation, independent of selection/topology.pub fn shaded_edge_visible(&self, index: usize) -> bool {- self.edge_pickable(index) && !self.smooth_edges.get(index).copied().unwrap_or(false)+ self.edge_visible(index) && !self.smooth_edges.get(index).copied().unwrap_or(false)}- pub fn edge_pickable(&self, index: usize) -> bool {+ /// Visibility in wireframe, including triangle-mesh outlines without B-rep identities.+ pub fn edge_visible(&self, index: usize) -> bool {!self.seams.get(index).copied().unwrap_or(false) || self.sharp_edges.get(index).copied().unwrap_or(false)}+ pub fn edge_pickable(&self, index: usize) -> bool {+ !self.display_only_edges && self.edge_visible(index)+ }+/// Edges bounding face `f`.pub fn face_edges(&self, f: u32) -> Vec<usize> {self.edge_faces.iter().enumerate().filter(|(_, fs)| fs.contains(&f)).map(|(i, _)| i).collect()diff --git a/crates/geom/src/tests.rs b/crates/geom/src/tests.rsindex 1aa5948af8..ff9b743688 100644--- a/crates/geom/src/tests.rs+++ b/crates/geom/src/tests.rs@@ -12,6 +12,7 @@ fn cube_mesh(s: f64) -> Mesh {triangles,tri_face: vec![0; n],edges: vec![],+ display_only_edges: false,seams: vec![],smooth_edges: vec![],sharp_edges: vec![],@@ -37,6 +38,9 @@ fn display_edge_masks_keep_identity_and_break_only_certified_sharp_patches() {assert_eq!(mesh.surface_patch(1), vec![1, 2]);assert_eq!(mesh.edges.len(), 2);assert_eq!(mesh.face_edges(1), vec![0, 1]);+ mesh.display_only_edges = true;+ assert!(mesh.edge_visible(0) && mesh.shaded_edge_visible(0));+ assert!(!mesh.edge_pickable(0));assert_eq!(serde_json::to_value(&mesh).unwrap(), stored);let reopened: Mesh = serde_json::from_value(stored).unwrap();assert!(reopened.smooth_edges.is_empty() && reopened.sharp_edges.is_empty());diff --git a/crates/render/src/raster.rs b/crates/render/src/raster.rsindex 606e6fa859..68a3f197e2 100644--- a/crates/render/src/raster.rs+++ b/crates/render/src/raster.rs@@ -382,6 +382,7 @@ mod tests {triangles: vec![[0, 1, 2]],tri_face: vec![0],edges: vec![],+ display_only_edges: false,seams: vec![],smooth_edges: vec![],sharp_edges: vec![],diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 173127bca6..1972aaff08 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -767,7 +767,7 @@ impl BodyDraw {}let at = |p: Vec3| self.place.as_ref().map_or(p, |m| solidcraft_engine::doc::apply_point(m, p)).to_f32();for (ei, e) in m.edges.iter().enumerate().filter(|_| edges) {- if !m.edge_pickable(ei) || (shaded && !m.shaded_edge_visible(ei)) {+ if !m.edge_visible(ei) || (shaded && !m.shaded_edge_visible(ei)) {continue;}for w in e.windows(2) {@@ -5720,6 +5720,43 @@ mod tests {assert_eq!(merged.lines.len(), 3 * segments * crate::gpu::LINE_SIZE);}+ #[test]+ fn imported_mesh_edges_draw_in_each_style_without_brep_picks() {+ let h = crate::scenario::Harness::new();+ let path = h.dir.join("box.3mf");+ let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());+ app.run("solid.box", json!({"length":20,"width":20,"height":10})).unwrap();+ app.run("file.save_mesh", json!({"path":path})).unwrap();+ app.run("file.new", json!({})).unwrap();+ let imported = app.run("file.insert_mesh", json!({"path":path})).unwrap();+ app.run("component.activate", json!({"component":"root"})).unwrap();+ app.run("occurrence.copy", json!({"component":imported["component"],"translate":[40,0,0]})).unwrap();+ app.ui.show_grid = false;+ app.set_origin_shown(false);+ app.ui.ground_shadow = false;+ app.fit_view();+ for style in 0..4 {+ app.ui.visual_style = style;+ let scene = build_scene(&app).merged();+ let lines = if style == 1 { 0 } else { 24 * crate::gpu::LINE_SIZE };+ assert_eq!(scene.lines.len(), lines, "style {style}: twelve edges per placed box");+ assert_eq!(scene.hidden.len(), if style == 3 { lines } else { 0 });+ assert_eq!(scene.tris.is_empty(), style == 2, "wireframe draws only the edges");+ }+ let proj = projection(&app, Rect::from_min_size(Pos2::ZERO, vec2(800., 600.)));+ for body in &app.session.world_state().bodies {+ let mesh = body.mesh();+ assert_eq!(mesh.edges.len(), 12, "the placed mesh keeps its outlines");+ for (i, edge) in mesh.edges.iter().enumerate() {+ assert!(!mesh.edge_pickable(i), "placements keep display-only edge semantics");+ for point in [edge[0], (edge[0] + edge[1]) * 0.5] {+ let hits = pick_all(&app, &proj, proj.to_screen(point).unwrap());+ assert!(!hits.iter().any(|h| matches!(h, Hit::Edge { .. } | Hit::Vertex { .. })), "{hits:?}");+ }+ }+ }+ }+/// Manual GPU benchmark: 25 placements of the mesh `SOLIDCRAFT_BENCH_MESH` (an STL, OBJ or/// 3MF) drawn offscreen at 3600 × 2190 px (divided by `SOLIDCRAFT_BENCH_DIV`) with 4× MSAA/// while the camera turns, each frame waited for: the placements' own triangles (`merged`, as