SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Hem: the handle runs along the hem to its tip (#5828) (#5844)
rlartot865575e410d1
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex 6bc558f239..11f59691de 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -132,6 +132,11 @@ pub fn anchor(app: &SolveApp, d: &Dialog) -> Option<(Vec3, Option<Vec3>)> {(at, along_face.or_else(|| st.body(body).and_then(|b| blend_grow_dir(&b.mesh(), *index, at))))}Kind::Fillet { .. } | Kind::Shell { .. } => (at, normal.map(|n| -n)),+ // A hem's handle starts on the centre line of its layer and runs to its tip (#5828).+ Kind::Sheet(crate::dialogs_sheet::Sm::Hem { .. }) => match crate::dialogs_sheet::hem_handle(app, d) {+ Some((start, dir)) => (start, Some(dir)),+ None => (at, normal),+ },Kind::Sheet(_) => (at, crate::dialogs_sheet::arrow(app, d).or(normal)),Kind::Plastic(_) => (at, normal),Kind::PatternRect { .. } => (at, d.inputs.get(1).and_then(|i| i.items.first()).and_then(|x| crate::dialogs::axis_of(app, x)).map(|a| a.1)),diff --git a/crates/ui-egui/src/dialogs_sheet.rs b/crates/ui-egui/src/dialogs_sheet.rsindex e5138081d6..560b10ca6c 100644--- a/crates/ui-egui/src/dialogs_sheet.rs+++ b/crates/ui-egui/src/dialogs_sheet.rs@@ -715,15 +715,24 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind) -> Option<(Kind, Vec<SelI// ---- view -----/// The direction an edge flange or hem grows from its first edge: out of the sheet's larger-/// neighbouring face for a flange, toward it for a hem (flipped with Flip).+/// The direction an edge flange grows from its first edge: out of the sheet's larger+/// neighbouring face (flipped with Flip). A hem's handle runs along the hem instead+/// ([`hem_handle`]).pub fn arrow(app: &SolveApp, d: &Dialog) -> Option<Vec3> {let Kind::Sheet(k) = &d.kind else { return None };let flip = match k {Sm::Flange { ty: 1, flip, .. } => *flip,- Sm::Hem { flip, .. } => !flip,+ Sm::Hem { .. } => return hem_handle(app, d).map(|(_, dir)| dir),_ => return None,};+ let (n, _, _) = edge_frame(app, d)?;+ Some(if flip { -n } else { n })+}++/// The sheet at the dialog's first picked edge: the unit normal of the larger neighbouring face+/// (out of the sheet), the unit normal of the other neighbour (the edge's end face, pointing away+/// from the sheet), and the sheet's thickness along the first.+fn edge_frame(app: &SolveApp, d: &Dialog) -> Option<(Vec3, Vec3, f64)> {let Sel::Edge { body, index, point } = d.inputs.first()?.items.first()? else { return None };let st = app.session.world_state();let m = st.body(body)?.mesh();@@ -737,16 +746,40 @@ pub fn arrow(app: &SolveApp, d: &Dialog) -> Option<Vec3> {.map(|[a, b, c]| (b - a).cross(c - a).len() * 0.5).sum()};+ let normal = |f: u32| -> Option<Vec3> {+ m.triangles+ .iter()+ .zip(&m.tri_face)+ .filter(|(_, tf)| **tf == f)+ .filter_map(|(t, _)| m.tri(t))+ .min_by(|a, b| ((a[0] + a[1] + a[2]) / 3.0).dist(*point).total_cmp(&((b[0] + b[1] + b[2]) / 3.0).dist(*point)))+ .and_then(|[a, b, c]| (b - a).cross(c - a).normalized())+ };let f = faces.iter().copied().max_by(|a, b| area(*a).total_cmp(&area(*b)))?;- let n = m- .triangles- .iter()- .zip(&m.tri_face)- .filter(|(_, tf)| **tf == f)- .filter_map(|(t, _)| m.tri(t))- .min_by(|a, b| ((a[0] + a[1] + a[2]) / 3.0).dist(*point).total_cmp(&((b[0] + b[1] + b[2]) / 3.0).dist(*point)))- .and_then(|[a, b, c]| (b - a).cross(c - a).normalized())?;- Some(if flip { -n } else { n })+ let g = faces.iter().copied().find(|g| *g != f)?;+ let (n, end) = (normal(f)?, normal(g)?);+ // The end face spans the sheet's thickness along the normal.+ let heights = m.triangles.iter().zip(&m.tri_face).filter(|(_, tf)| **tf == g).filter_map(|(t, _)| m.tri(t)).flatten().map(|v| v.dot(n));+ let (lo, hi) = heights.fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), h| (lo.min(h), hi.max(h)));+ let thickness = hi - lo;+ (thickness.is_finite() && thickness > 0.0).then_some((n, end, thickness))+}++/// Where a hem's handle starts and where it points (#5828). Its Length is measured from the outer+/// face of the fold to the hem's tip, so the handle starts on the centre line of the hem layer at+/// that face and runs along the hem toward the tip: square to the picked edge, back over the sheet.+/// The layer lies on the far side of the sheet from the larger face unless flipped. The Gap is+/// taken from the dialog when it holds a number; otherwise the layer sits flat against the sheet.+pub fn hem_handle(app: &SolveApp, d: &Dialog) -> Option<(Vec3, Vec3)> {+ let Kind::Sheet(Sm::Hem { gap, flip, .. }) = &d.kind else { return None };+ let Sel::Edge { point, .. } = d.inputs.first()?.items.first()? else { return None };+ let (n, end, thickness) = edge_frame(app, d)?;+ let gap = app.session.doc.eval(gap, ValueKind::Length).ok().filter(|g| g.is_finite() && *g >= 0.0).unwrap_or(0.0);+ // The hem's side of the sheet, as a unit vector along the larger face's normal, and the+ // distance of the layer's centre line from the face the edge lies on.+ let (side, depth) = if *flip { (n, gap + thickness / 2.0) } else { (-n, thickness + gap + thickness / 2.0) };+ let start = *point + end * (thickness + gap) + side * depth;+ Some((start, -end))}/// Bend line colours: up and down (theme tokens, legible on either theme and in every colourdiff --git a/crates/ui-egui/src/dialogs_sheet_tests.rs b/crates/ui-egui/src/dialogs_sheet_tests.rsindex b752350f2f..eef1501561 100644--- a/crates/ui-egui/src/dialogs_sheet_tests.rs+++ b/crates/ui-egui/src/dialogs_sheet_tests.rs@@ -69,33 +69,6 @@ fn flange_follows_the_picks() {}}-#[test]-fn hem_arrow_points_to_the_side_the_hem_builds_on() {- for mode in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked] {- for z in [0.0, 2.5] {- for flipped in [false, true] {- let mut app = plate(mode);- app.run("sheet.flange", json!({"sketch": "Base"})).unwrap();- let body = app.session.model.state().sheets[0].body.clone();- let before = app.session.world_state().body(&body).unwrap().mesh().bounds();- app.session.selection = vec![edge_sel(&app.session, Vec3::new(50.0, 0.0, z)).unwrap()];- app.start("sheet.hem");- let mut d = app.dialog.clone().unwrap();- let Kind::Sheet(Sm::Hem { flip, .. }) = &mut d.kind else { panic!("hem dialog") };- *flip = flipped;- let direction = arrow(&app, &d).unwrap();- let commands = apply_commands(&app, &d).unwrap();- run_all(&mut app, commands);- let after = app.session.world_state().body(&body).unwrap().mesh().bounds();- assert!(- direction.dot(after.center() - before.center()) > 1e-6,- "the arrow must point toward the added hem: z={z}, flip={flipped}, arrow={direction:?}, before={before:?}, after={after:?}"- );- }- }- }-}-/// Hem takes edges and an optional gap; rules make and pick a rule with its expressions.#[test]fn hem_and_rules() {@@ -953,3 +926,34 @@ fn flat_perforations_cull_offscreen_and_subpixel_holes() {app.flat_view.cam.distance = fitted_distance * 1000.0;assert!(flat_circles(&mut app, &dialog, rect).is_empty());}++/// The hem's handle sits on the centre line of the hem layer, at the outer face of its fold, and+/// points along the hem toward its tip (#5828): dragging it changes the Length, which is measured+/// from the fold's outer face to the tip, so the handle's start plus Length lands on the tip.+#[test]+fn hem_handle_runs_along_the_hem_to_its_tip() {+ for flipped in [false, true] {+ let mut app = plate(crate::shell::LayoutMode::Floating);+ app.run("sheet.flange", json!({"sketch": "Base"})).unwrap();+ let body = app.session.model.state().sheets[0].body.clone();+ app.session.selection = vec![edge_sel(&app.session, Vec3::new(50.0, 0.0, 2.5)).unwrap()];+ app.start("sheet.hem");+ let mut d = app.dialog.clone().unwrap();+ let Kind::Sheet(Sm::Hem { flip, .. }) = &mut d.kind else { panic!("hem dialog") };+ *flip = flipped;+ let (at, dir) = crate::canvas::anchor(&app, &d).unwrap();+ let dir = dir.unwrap();+ let commands = apply_commands(&app, &d).unwrap();+ run_all(&mut app, commands);+ // The 5 mm hem layer: its tip is the far end of the added layer, along the sheet.+ let m = app.session.world_state().body(&body).unwrap().mesh();+ // The straight part of the layer, past the fold.+ let layer_z = |z: f64| if flipped { z > 2.505 } else { z < -0.01 };+ let tip_y = m.positions.iter().filter(|v| layer_z(v.z)).map(|v| v.y).fold(f64::NEG_INFINITY, f64::max);+ let layer: Vec<f64> = m.positions.iter().filter(|v| layer_z(v.z) && v.y > 0.5).map(|v| v.z).collect();+ let centre_z = (layer.iter().copied().fold(f64::INFINITY, f64::min) + layer.iter().copied().fold(f64::NEG_INFINITY, f64::max)) / 2.0;+ assert!(dir.dist(Vec3::Y) < 1e-6, "flip={flipped}: the handle points along the hem to its tip, got {dir:?}");+ assert!((at.z - centre_z).abs() < 0.05, "flip={flipped}: the handle starts on the hem's centre line: {at:?} vs z={centre_z}");+ assert!((at.y + 5.0 - tip_y).abs() < 0.05, "flip={flipped}: start plus Length reaches the tip: {at:?} vs y={tip_y}");+ }+}