Skip to content

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

fix: a hole placed on a face follows the face along its axis only, and warns when off the face (#510)

NOWN-DEV340ac0313ad6
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index ed87037401..e55a8cdbd3 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -924,7 +924,14 @@ impl Model {
let f = if !explicit_emboss && f.face_names.iter().any(|n| !n.is_empty()) {
let mut g = f.clone();
let mut notes = Vec::new();
- for (p, n) in g.kind.face_points_mut().into_iter().zip(&f.face_names) {
+ // A hole's position is a place on its face, not a pick of the face: it follows
+ // the face along the hole's axis and never slides sideways to the face's nearest
+ // point when the face no longer reaches it.
+ let hole_axis = match &f.kind {
+ FeatureKind::Hole { direction, points: None, .. } => direction.normalized(),
+ _ => None,
+ };
+ for (k, (p, n)) in g.kind.face_points_mut().into_iter().zip(&f.face_names).enumerate() {
if n.is_empty() {
continue;
}
@@ -933,7 +940,18 @@ impl Model {
if let Some(note) = hit.note(n) {
notes.push(note);
}
- *p = hit.point;
+ match (k, hole_axis) {
+ (0, Some(axis)) => match hit.along(&state, *p, axis) {
+ Some(q) => *p = q,
+ // The place still lies on the face (the axis may run along it).
+ None if hit.on_point => {}
+ None => notes.push(format!(
+ "the hole's position [{}, {}, {}] is no longer on face `{n}`: it stays where it was placed",
+ p.x, p.y, p.z
+ )),
+ },
+ _ => *p = hit.point,
+ }
}
None => notes.push(format!("face `{n}` no longer exists; using the face at the picked point")),
}
diff --git a/crates/doc/src/name_lookup.rs b/crates/doc/src/name_lookup.rs
index c9036e7b2f..6dba47d465 100644
--- a/crates/doc/src/name_lookup.rs
+++ b/crates/doc/src/name_lookup.rs
@@ -211,6 +211,35 @@ impl FaceHit {
}
}
+impl FaceHit {
+ /// Where the line through `p` along `dir` meets the face found (the hit nearest `p`, on
+ /// either side of it), `None` when the line misses the face or runs along it. A place on
+ /// a face follows the face this way, along its own axis, instead of sliding sideways to
+ /// [`point`](Self::point), the face's nearest point.
+ pub fn along(&self, st: &ModelState, p: Vec3, dir: Vec3) -> Option<Vec3> {
+ let b = st.bodies.get(self.body)?;
+ let d = dir.normalized()?;
+ let m = b.mesh();
+ let slack = (b.body.size() * 1e-9).max(1e-9);
+ let mut best: Option<f64> = None;
+ for (t, f) in m.triangles.iter().zip(&m.tri_face) {
+ if *f as usize != self.face {
+ continue;
+ }
+ let Some([a, bb, c]) = m.tri(t) else { continue };
+ // A hair's width around each triangle, so a place on the seam of two is on the face.
+ let centre = (a + bb + c) * (1.0 / 3.0);
+ let grow = |v: Vec3| v + (v - centre).normalized().unwrap_or(Vec3::ZERO) * slack;
+ if let Some(hit) = naming::ray_hit(p, d, grow(a), grow(bb), grow(c))
+ && best.is_none_or(|old| hit.abs() < old.abs())
+ {
+ best = Some(hit);
+ }
+ }
+ best.map(|t| p + d * t)
+ }
+}
+
impl EdgeHit {
/// What a feature says about how it found an edge by its stored name `name` (`None`: exactly).
pub fn note(&self, name: &str) -> Option<String> {
diff --git a/crates/doc/src/naming.rs b/crates/doc/src/naming.rs
index a2d0204e3c..cfd38b7a77 100644
--- a/crates/doc/src/naming.rs
+++ b/crates/doc/src/naming.rs
@@ -386,7 +386,7 @@ fn behind(ps: &[Vec3], ns: &[Vec3], inputs: &[(&ModelBody, FaceIndex, Arc<Vec<St
votes.first().filter(|(_, k)| *k * 2 >= ps.len().max(1)).map(|(n, _)| n.clone())
}
-fn ray_hit(o: Vec3, d: Vec3, a: Vec3, b: Vec3, c: Vec3) -> Option<f64> {
+pub(crate) fn ray_hit(o: Vec3, d: Vec3, a: Vec3, b: Vec3, c: Vec3) -> Option<f64> {
let (e1, e2) = (b - a, c - a);
let h = d.cross(e2);
let det = e1.dot(h);
diff --git a/crates/engine/src/hole_face_tests.rs b/crates/engine/src/hole_face_tests.rs
new file mode 100644
index 0000000000..5a51867fdb
--- /dev/null
+++ b/crates/engine/src/hole_face_tests.rs
@@ -0,0 +1,89 @@
+//! A hole placed on a face follows that face along the hole's axis, never sideways: when the face
+//! moves the hole moves with it, and when the face no longer reaches the place the hole stays
+//! where it was put and says so instead of sliding to the face's nearest point.
+
+use serde_json::{Value, json};
+use solidcraft_geom::Vec3;
+
+use crate::Session;
+
+fn run(s: &mut Session, id: &str, p: Value) -> Value {
+ match s.execute(id, &p) {
+ Ok(v) => v,
+ Err(e) => panic!("{id} {p}: {e}"),
+ }
+}
+
+fn change(s: &mut Session, name: &str, expression: &str) {
+ run(s, "parameters.change", json!({"name": name, "expression": expression}));
+}
+
+fn volume(s: &mut Session) -> f64 {
+ run(s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap()
+}
+
+/// Whether the model holds material at (x, y, z).
+fn solid_at(s: &Session, x: f64, y: f64, z: f64) -> bool {
+ s.model.state().bodies.iter().any(|b| b.body.contains(Vec3::new(x, y, z)))
+}
+
+/// What the hole feature says (its error and its warning); empty when it is silent.
+fn said(s: &Session, feature: &str) -> String {
+ let id = s.doc.find_feature(feature).unwrap().id;
+ let r = s.model.result(id).unwrap();
+ format!("{}{}", r.error.clone().unwrap_or_default(), r.warning.clone().unwrap_or_default())
+}
+
+#[test]
+fn a_hole_the_face_no_longer_reaches_stays_where_it_was_placed_and_says_so() {
+ let mut s = Session::default();
+ run(&mut s, "parameters.add", json!({"name": "length", "expression": "100 mm"}));
+ run(&mut s, "solid.box", json!({"length": "length", "width": 50, "height": 20, "name": "Plate"}));
+ run(&mut s, "solid.hole", json!({"position": [80, 25, 20], "diameter": "6 mm", "name": "Hole"}));
+ // The bore is at x = 80, 3 mm either way.
+ let drilled_at_80 = |s: &Session| !solid_at(s, 80.0, 25.0, 10.0) && solid_at(s, 76.0, 25.0, 10.0) && solid_at(s, 84.0, 25.0, 10.0);
+ assert!(drilled_at_80(&s));
+ // Longer: the place is still on the top face, and the hole stays at x = 80.
+ change(&mut s, "length", "150 mm");
+ assert_eq!(said(&s, "Hole"), "");
+ assert!(drilled_at_80(&s));
+ // Shorter than the place: nothing is drilled at the new end, and the hole says why. A hole
+ // moved to the face's nearest point would cut half a hole there (59 717 mm³ left).
+ change(&mut s, "length", "60 mm");
+ let left = volume(&mut s);
+ assert!((left - 60_000.0).abs() < 1.0, "half a hole was cut at the plate's end: {left} mm³ of 60000");
+ let msg = said(&s, "Hole");
+ assert!(msg.contains("no longer on face") && msg.contains("[80, 25, 20]"), "{msg}");
+ // Long again: the hole is back where it was put, with no message.
+ change(&mut s, "length", "100 mm");
+ assert_eq!(said(&s, "Hole"), "");
+ assert!(drilled_at_80(&s));
+}
+
+#[test]
+fn a_slanted_hole_stays_on_its_axis_when_its_face_moves() {
+ let mut s = Session::default();
+ run(&mut s, "parameters.add", json!({"name": "height", "expression": "20 mm"}));
+ run(&mut s, "solid.box", json!({"length": 60, "width": 30, "height": "height", "name": "Block"}));
+ // Entering the top face at x = 20, running on in x as it goes down: 1 across for every 2 down.
+ run(&mut s, "solid.hole", json!({"position": [20, 15, 20], "direction": [1, 0, -2], "diameter": "2 mm", "name": "Hole"}));
+ // The axis is the line through the place along the direction, whatever the height of the block:
+ // x = 20 + (20 - z) / 2. At mid-height the bore is empty on it and solid 3 mm to either side
+ // (the bore is about 2.2 mm wide there).
+ let on_axis = |s: &Session, h: f64| {
+ let (x, z) = (20.0 + (20.0 - h / 2.0) / 2.0, h / 2.0);
+ assert!(!solid_at(s, x, 15.0, z), "block height {h}: the bore should pass through x = {x} at z = {z}");
+ assert!(solid_at(s, x - 3.0, 15.0, z) && solid_at(s, x + 3.0, 15.0, z), "block height {h}: material 3 mm beside the axis");
+ // (The kernel may note a boolean retry for a slanted bore; the hole's place is on its face.)
+ assert!(!said(s, "Hole").contains("no longer on face"), "block height {h}: {}", said(s, "Hole"));
+ };
+ on_axis(&s, 20.0);
+ // Taller: the top face moves up. Moved to the face's nearest point the hole would slide
+ // sideways onto another axis (5 mm further along x at mid-height); along its axis it enters
+ // higher up the same line.
+ change(&mut s, "height", "30 mm");
+ on_axis(&s, 30.0);
+ // Lower: the same line enters further along.
+ change(&mut s, "height", "12 mm");
+ on_axis(&s, 12.0);
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index b9b25a07f1..8e6f73ffaa 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -795,6 +795,8 @@ mod delete_face_tests;
#[cfg(test)]
mod extent_tests;
#[cfg(test)]
+mod hole_face_tests;
+#[cfg(test)]
mod naming_history_tests;
#[cfg(test)]
mod pattern_suppress_tests;
diff --git a/docs/book/src/dev/naming.md b/docs/book/src/dev/naming.md
index 660684c48f..15569af1d0 100644
--- a/docs/book/src/dev/naming.md
+++ b/docs/book/src/dev/naming.md
@@ -80,6 +80,12 @@ longer lies on the face says so: `face ... was found by geometry, not exact hist
An edge name is found as the edge between the two faces it names, each found as above: when
exactly one edge runs between them it is that edge, even after a split of one of its faces.
+A hole placed by a position on a face is the exception to "the point nearest the reference's
+point": its position is a place, not a pick. The hole follows its face along its own axis, so it
+moves with the face when the face moves, and when the face no longer reaches the position it stays
+where it was placed and the feature says so, instead of sliding to the face's edge and drilling
+half a hole there. (Holes at sketch points follow their sketch.)
+
## Older designs
Designs saved before format 14 stored names worked out from geometry, and a few of them name a