diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index 59a5ffae7..e4bcd2f85 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -2634,12 +2634,13 @@ fn body_at(st: &ModelState, body: &Option, points: &[Vec3]) -> } /// A hole stays on its face when the model changes: a position now inside a body moves back -/// against the drilling direction to the surface, one now above it moves down onto it. -fn hole_on_surface(st: &ModelState, p: Vec3, dir: Vec3) -> Vec3 { +/// against the drilling direction to the surface, one now above it moves down onto it. Only the +/// bodies in `scope` count (every body when it is empty, see [`hole_scope`]). +fn hole_on_surface(st: &ModelState, p: Vec3, dir: Vec3, scope: &[String]) -> Vec3 { let size = st.bodies.iter().map(|b| b.body.size()).fold(1.0, f64::max); let eps = size * 1e-6; let mut best: Option = None; - for b in &st.bodies { + for b in st.bodies.iter().filter(|b| in_hole_scope(scope, b)) { let m = b.mesh(); // Already on the surface: the drill enters right here. if let Some((t, _)) = m.raycast(p - dir * eps, dir) @@ -2920,12 +2921,12 @@ pub(crate) fn revolve_axis(ss: &SolvedSketch, axis: &AxisRef) -> Result<(Vec2, V /// Whether a drill from `p` along `d` reaches material: it starts into a body (`touches`), or, /// when `ahead` is set, a body lies further along `d`. A spot exactly on a surface counts only -/// when the drill enters there, not when it leaves. -fn hole_reaches(st: &ModelState, p: Vec3, d: Vec3, ahead: bool) -> bool { +/// when the drill enters there, not when it leaves. Only the bodies in `scope` count. +fn hole_reaches(st: &ModelState, p: Vec3, d: Vec3, ahead: bool, scope: &[String]) -> bool { let size = st.bodies.iter().map(|b| b.body.size()).fold(1.0, f64::max); let eps = size * 1e-6; let q = p + d * eps; - st.bodies.iter().any(|b| { + st.bodies.iter().filter(|b| in_hole_scope(scope, b)).any(|b| { let m = b.mesh(); m.contains(q) || (ahead && m.raycast(q, d).is_some()) }) @@ -2943,13 +2944,13 @@ pub fn sketch_hole_direction(st: &ModelState, sketch: u64, ids: &[String], flip: let ss = st.sketch(sketch)?; let spots: Vec = ids.iter().map(|id| ss.sketch.points.iter().find(|p| &p.id == id).map(|p| ss.plane.to_world(p.pos))).collect::>()?; - let dir = sketch_hole_dir(st, &spots, ss.plane.normal()); + let dir = sketch_hole_dir(st, &spots, ss.plane.normal(), &[]); Some(if flip { -dir } else { dir }) } -fn sketch_hole_dir(st: &ModelState, spots: &[Vec3], n: Vec3) -> Vec3 { +fn sketch_hole_dir(st: &ModelState, spots: &[Vec3], n: Vec3, scope: &[String]) -> Vec3 { let down = -n; - let any = |d: Vec3, ahead: bool| spots.iter().any(|p| hole_reaches(st, *p, d, ahead)); + let any = |d: Vec3, ahead: bool| spots.iter().any(|p| hole_reaches(st, *p, d, ahead, scope)); if any(down, false) { down } else if any(n, false) { @@ -2961,6 +2962,20 @@ fn sketch_hole_dir(st: &ModelState, spots: &[Vec3], n: Vec3) -> Vec3 { } } +/// The bodies a hole at sketch points finds its side and its faces on: the bodies it cuts when it +/// names them (a hole from a sketch on a body's face cuts that body, #2882), so a body further +/// along can't take the holes meant for it. Empty (every body) otherwise. +fn hole_scope(f: &Feature) -> &[String] { + match &f.kind { + FeatureKind::Hole { points: Some(sp), .. } if !sp.single && !f.participants.iter().any(|b| b == "*") => &f.participants, + _ => &[], + } +} + +fn in_hole_scope(scope: &[String], b: &ModelBody) -> bool { + scope.is_empty() || scope.contains(&b.name) +} + /// Where a hole feature drills (each on the surface) and in which direction: at its sketch /// points perpendicular to the sketch (into the material), else at its position. fn hole_spots(vals: &BTreeMap, st: &ModelState, f: &Feature) -> Result<(Vec, Vec3)> { @@ -2974,21 +2989,21 @@ fn hole_spots(vals: &BTreeMap, st: &ModelState, f: &Feature) -> R let p = ss.sketch.points.iter().find(|p| &p.id == id).ok_or_else(|| DocError::Unknown(format!("sketch point `{id}`")))?; v.push(ss.plane.to_world(p.pos)); } - let dir = sketch_hole_dir(st, &v, ss.plane.normal()); + let dir = sketch_hole_dir(st, &v, ss.plane.normal(), hole_scope(f)); let dir = if sp.flip { -dir } else { dir }; (v, dir) } _ => { let dir = direction.normalized().ok_or_else(|| DocError::Invalid("hole direction".into()))?; - let at = hole_on_surface(st, single_hole_position(vals, st, position, at, points)?, dir); + let at = hole_on_surface(st, single_hole_position(vals, st, position, at, points)?, dir, &[]); let dir = hole_dir_into_face(st, at, dir); - return Ok((vec![hole_on_surface(st, at, dir)], dir)); + return Ok((vec![hole_on_surface(st, at, dir, &[])], dir)); } }; if spots.is_empty() || spots.len() > 10_000 { return Err(DocError::Invalid("a hole needs 1…10000 points".into())); } - Ok((spots.into_iter().map(|p| hole_on_surface(st, p, dir)).collect(), dir)) + Ok((spots.into_iter().map(|p| hole_on_surface(st, p, dir, hole_scope(f))).collect(), dir)) } /// A hole's depth: down to the To Object (where the hole's axis meets the face there, else the @@ -3021,14 +3036,14 @@ fn hole_spots_raw(vals: &BTreeMap, st: &ModelState, f: &Feature) let ss = st.sketch(sp.sketch.0).ok_or_else(|| DocError::Unknown(format!("sketch {}", sp.sketch)))?; let v: Vec = sp.ids.iter().filter_map(|id| ss.sketch.points.iter().find(|p| &p.id == id)).map(|p| ss.plane.to_world(p.pos)).take(10_000).collect(); - let dir = sketch_hole_dir(st, &v, ss.plane.normal()); + let dir = sketch_hole_dir(st, &v, ss.plane.normal(), hole_scope(f)); let dir = if sp.flip { -dir } else { dir }; Ok((v, dir)) } _ => { let dir = direction.normalized().ok_or_else(|| DocError::Invalid("hole direction".into()))?; let p = single_hole_position(vals, st, position, at, points)?; - Ok((vec![p], hole_dir_into_face(st, hole_on_surface(st, p, dir), dir))) + Ok((vec![p], hole_dir_into_face(st, hole_on_surface(st, p, dir, &[]), dir))) } } } @@ -4822,7 +4837,7 @@ fn replay( for (k, m) in mats.iter().enumerate() { let d = crate::apply_vector(m, dir).normalized().ok_or_else(|| DocError::Invalid("hole direction".into()))?; for p in &spots { - let at = hole_on_surface(st, crate::apply_point(m, *p), d); + let at = hole_on_surface(st, crate::apply_point(m, *p), d, hole_scope(src)); let to = to.map(|t| crate::apply_point(m, t.0)); let depth = hole_depth_to(st, &at, d, &to, depth)?; // Each copy's faces are named as the hole's, with the instance. diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rs index 51c5ad8fc..9c26734ad 100644 --- a/crates/engine/src/cmd/features.rs +++ b/crates/engine/src/cmd/features.rs @@ -68,7 +68,7 @@ pub static COMMANDS: &[CommandSpec] = &[ .at("SOLID", "CREATE") .icon("hole") .key("H") - .params("position: [x,y,z] on a face (numbers, or length expressions the hole follows) | sketch + points: [sketch point ids] (one hole each, perpendicular to the sketch, into the material on whichever side of the sketch plane it is) | sketch alone (every sketch point: standalone points and circle centres); flip?: bool (sketch points: drill to the other side); single?: bool (with one sketch point: a Single hole that follows the point, drilled into the face there); direction?: [x,y,z] (default: into the face, against its outward normal; one that leaves the face is mirrored into it; ignored with sketch points unless single); diameter | thread (a tapped hole: the tap drill, major − pitch) | clearance: \"M6\" with fit?: close|normal|loose (ISO 273); depth? (default through all) | to?: [x,y,z] (To Object: drill to that face or point); type?: simple|drilled|counterbore|countersink; tip_angle?; cb_diameter?, cb_depth?; cs_diameter?, cs_angle?; thread?: \"M6\" (cosmetic)"), + .params("position: [x,y,z] on a face (numbers, or length expressions the hole follows) | sketch + points: [sketch point ids] (one hole each, perpendicular to the sketch, into the material on whichever side of the sketch plane it is) | sketch alone (every sketch point: standalone points and circle centres); flip?: bool (sketch points: drill to the other side); single?: bool (with one sketch point: a Single hole that follows the point, drilled into the face there); direction?: [x,y,z] (default: into the face, against its outward normal; one that leaves the face is mirrored into it; ignored with sketch points unless single); diameter | thread (a tapped hole: the tap drill, major − pitch) | clearance: \"M6\" with fit?: close|normal|loose (ISO 273); depth? (default through all) | to?: [x,y,z] (To Object: drill to that face or point); type?: simple|drilled|counterbore|countersink; tip_angle?; cb_diameter?, cb_depth?; cs_diameter?, cs_angle?; thread?: \"M6\" (cosmetic); targets?: [body] (the bodies to drill; holes at the points of a sketch on a body's face default to that body, found along the holes' direction on it alone; explicit targets or participants override, [\"*\"] every body)"), CommandSpec::new("solid.pipe", "Pipe", pipe) .at("SOLID", "CREATE") .icon("pipe") @@ -1853,15 +1853,25 @@ fn hole(s: &mut Session, p: &Value) -> Result { Some(v) => Some(vec3(v).ok_or_else(|| bad(cmd, "`to` must be a point [x, y, z] on the face to drill to"))?), None => None, }; - // A hole picked on a body of another component (a moved one, shown where it is placed) cuts - // that body: the pick is already in that body's frame, and the component's own bodies alone - // would leave nothing to cut. let mut p = p.clone(); - if points.is_none() - && p.get("participants").is_none() - && let Some(body) = body_of_other_component_at(s, position) - { - p["participants"] = json!([body]); + let targets = string_list(&p, "targets"); + if p.get("participants").is_none() { + // The bodies to drill, as `targets` (like an extrude's): its participants. + if !targets.is_empty() { + p["participants"] = json!(targets); + } else if let Some(body) = points.as_ref().filter(|(sp, _, _)| !sp.single).and_then(|(sp, _, _)| sketch_face_body(s, sp.sketch.0)) { + // Holes at the points of a sketch on a body's face drill that body (#2882): a body + // further along, past the face, doesn't take them. Stored, so recomputes and + // reopening keep the same scope. + p["participants"] = json!([body]); + } else if points.is_none() + && let Some(body) = body_of_other_component_at(s, position) + { + // A hole picked on a body of another component (a moved one, shown where it is + // placed) cuts that body: the pick is already in that body's frame, and the + // component's own bodies alone would leave nothing to cut. + p["participants"] = json!([body]); + } } add_feature( s, diff --git a/crates/engine/src/hole_face_tests.rs b/crates/engine/src/hole_face_tests.rs index ededdd431..582a71253 100644 --- a/crates/engine/src/hole_face_tests.rs +++ b/crates/engine/src/hole_face_tests.rs @@ -374,3 +374,44 @@ fn drilled_sketch_points_break_through_a_sloping_back_face() { assert!(reopened.model.result(id).unwrap().error.is_none()); near(volume(&mut reopened), left); } + +/// Back (z 0…6) under a smaller Front (z 14…20), and a sketch on Front's top face with points +/// over Front (`in`) and beyond its edges, over Back (`out1`, `out2`). +fn front_and_back(s: &mut Session) { + run(s, "solid.box", json!({"length": 40, "width": 40, "height": 6, "body_name": "Back"})); + run(s, "solid.box", json!({"corner": [10, 10, 14], "length": 20, "width": 20, "height": 6, "body_name": "Front"})); + run(s, "sketch.create", json!({"plane": {"face": [20, 20, 20]}, "name": "Pts", "project_edges": false})); + for (id, p) in [("in", [20, 20]), ("out1", [5, 5]), ("out2", [35, 35])] { + run(s, "sketch.point", json!({"point": p, "id": id})); + } + run(s, "sketch.finish", json!({})); +} + +/// #2882: holes at the points of a sketch on a body's face drill that body, never one behind it. +#[test] +fn holes_from_a_sketch_on_a_face_drill_that_body_only() { + let mut s = Session::default(); + front_and_back(&mut s); + let base = volume(&mut s); + run(&mut s, "solid.hole", json!({"sketch": "Pts", "points": ["in", "out1", "out2"], "diameter": 5, "depth": 4, "name": "H"})); + assert_eq!(s.doc.find_feature("H").unwrap().participants, vec!["Front".to_string()]); + near(base - volume(&mut s), pi() * 6.25 * 4.0); + assert!(!solid_at(&s, 20.0, 20.0, 18.0), "drilled into Front"); + for (x, y) in [(5.0, 5.0), (35.0, 35.0), (20.0, 20.0)] { + assert!(solid_at(&s, x, y, 5.5) && solid_at(&s, x, y, 3.0), "Back is not drilled at ({x}, {y})"); + } + let mut reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap()); + near(base - volume(&mut reopened), pi() * 6.25 * 4.0); +} + +/// Through all from Front's face stops at Front; `targets` picks another body to drill instead. +#[test] +fn face_sketch_holes_through_all_stay_in_their_body_unless_targets_say_otherwise() { + let mut s = Session::default(); + front_and_back(&mut s); + run(&mut s, "solid.hole", json!({"sketch": "Pts", "points": ["in"], "diameter": 5, "name": "H"})); + assert!(!solid_at(&s, 20.0, 20.0, 15.0) && solid_at(&s, 20.0, 20.0, 3.0)); + run(&mut s, "edit.undo", json!({})); + run(&mut s, "solid.hole", json!({"sketch": "Pts", "points": ["in"], "diameter": 5, "targets": ["Back"], "name": "H"})); + assert!(solid_at(&s, 20.0, 20.0, 15.0) && !solid_at(&s, 20.0, 20.0, 3.0)); +}