diff --git a/ROADMAP.md b/ROADMAP.md index fb2ec29fc..01168c25b 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -51,7 +51,7 @@ PCB / Package, Render, Animation, Simulation, Manufacture/CAM, Drawings. |---|---|---|---| | M0 | Vertical slice | done | — | | M1 | Sketch depth: command coverage implemented — projection/intersect/include as linked geometry (auto-project on faces, lost-reference warnings, break link), full SKETCH create/modify set (slots, polygons, tangent arcs/circles, ellipse, fit/control splines, conic, text, trim/extend/break, fillet/chamfer, offset, mirror, patterns, move/scale, blend curve, centerline), constraints incl. curvature and polygon with over-constraint refusal, Shift-picked line midpoints in Horizontal/Vertical using persisted points and ordinary constraints (#2087), driven/arc-length/linear-diameter dimensions, AutoConstrain, DXF/SVG insert, 3D sketch curves (Project To Surface, Intersection Curve, Isoparametric Curve, Spun Profile), exact free-form profiles (B-spline/NURBS edges, any spline degree, curves cut by crossings), sweeps and pipes along 3D sketch curves, canvases and decals, curvature combs. Exact free-form Extend and certified associative offsets now preserve geometry and IDs through edits, deletion and reopen. Occurrence-frame 3D wires now store explicit coordinate spaces and retain points and analytic fits through moves, refresh, undo and reopen. Constructive sketch solving (Owen 1991, Fudos & Hoffmann 1997) ahead of the numerical solver: points and rigid clusters are placed on the branch the sketch had, so dimension edits and drags keep their solution; edits that would turn a sketch over are refused; drags re-solve only the sketch per frame. Remaining workflow repairs: mixed offset junctions, legacy natural-spline seams, and damaged legacy wire links lacking frame provenance | in progress | 4 | -| M2 | Robust modelling: coplanar booleans in the kernel, holes (placed on faces and on sketch points), threads (cosmetic, then modelled), patterns, mirror, shell, draft, split, construction geometry | in progress | 16 | +| M2 | Robust modelling: coplanar booleans in the kernel, holes (placed on faces, at distances from reference edges, and on sketch points), threads (cosmetic, then modelled), patterns, mirror, shell, draft, split, construction geometry | in progress | 16 | | M3 | General fillets and chamfers (curved edges, chains, vertex blends); saddle rolling-ball surfaces now use continuous seam sections and arc-length fitting with shared contact boundaries and bounded accuracy checks; tiny rim edges remain selected instead of nearby wall seams when filleting (#2498) | in progress | 30 | | M4 | Files: STEP import (done — [docs/step-import.md](docs/step-import.md)), FreeCAD/Rhino solids through cadmpeg (done, desktop, browser and CLI), 3MF export and 3MF/STL import as mesh bodies (done), 3MF with B-rep face tags ([docs/formats/3mf-face-tags.md](docs/formats/3mf-face-tags.md), done), constant-section parametric mesh reconstruction, DXF sketches, OBJ import | in progress | 6 | | M5 | Persistent naming of faces and edges (docs/book/src/dev/naming.md): faces named from their exact kernel-reported history (sketch curve sides, caps, revolve sections, primitive sides, blends, shell inner walls, pattern/mirror copies; split pieces told apart by the faces around them, lumps of a cut body named after their faces), edges by their faces; fillets/chamfers, sketches on faces, shell/draft/offset/replace faces, hole placements, joint origins and face appearances resolve by name first and warn when the entity split or vanished: done. sheet metal edges by base sketch line and flange side, shell inner faces, sweep and loft roles: done. kernel-reported face history: done (merged faces answer to every name; operations without history yet fall back to geometric names, flagged unverified; format 14 keeps older designs' geometric names). Left: history through sheet metal, plastic, surface and emboss features; FaceSource certificates through history | in progress | 20 | diff --git a/assets/locales/en.json b/assets/locales/en.json index ce1d7ded5..01d97b986 100644 --- a/assets/locales/en.json +++ b/assets/locales/en.json @@ -2189,6 +2189,9 @@ "ui.rectangle": "Rectangle", "ui.rectangular_pattern": "Rectangular Pattern", "ui.redo": "Redo", + "ui.reference_1": "Reference 1", + "ui.reference_2": "Reference 2", + "ui.reference_distance": "Reference distance", "ui.relink_design_changed": "The assembly changed while choosing a source. Start Relink Source again.", "ui.relink_done": "Source relinked for all instances.", "ui.relink_not_linked": "This component is not linked to a source design.", diff --git a/assets/locales/ja.json b/assets/locales/ja.json index 0e9e8fdfa..9e77c1425 100644 --- a/assets/locales/ja.json +++ b/assets/locales/ja.json @@ -2189,6 +2189,9 @@ "ui.rectangle": "長方形", "ui.rectangular_pattern": "矩形パターン", "ui.redo": "やり直す", + "ui.reference_1": "参照 1", + "ui.reference_2": "参照 2", + "ui.reference_distance": "参照からの距離", "ui.relink_design_changed": "参照元の選択中にアセンブリが変更されました。再リンクをやり直してください。", "ui.relink_done": "すべてのインスタンスの参照元を再リンクしました。", "ui.relink_not_linked": "このコンポーネントは参照元の設計にリンクされていません。", diff --git a/assets/locales/zh.json b/assets/locales/zh.json index c653ed5af..8807322cb 100644 --- a/assets/locales/zh.json +++ b/assets/locales/zh.json @@ -2189,6 +2189,9 @@ "ui.rectangle": "矩形", "ui.rectangular_pattern": "矩形阵列", "ui.redo": "重做", + "ui.reference_1": "参考 1", + "ui.reference_2": "参考 2", + "ui.reference_distance": "参考距离", "ui.relink_design_changed": "选择源文件时装配已更改。请重新开始链接。", "ui.relink_done": "已为所有实例重新链接源文件。", "ui.relink_not_linked": "此组件未链接到源设计。", diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs index 836ef6322..32327ddd2 100644 --- a/crates/doc/src/document.rs +++ b/crates/doc/src/document.rs @@ -724,6 +724,11 @@ pub enum FeatureKind { /// To Object: drill down to the face (or point) here instead of `depth`. #[serde(default, skip_serializing_if = "Option::is_none")] to: Option, + /// Up to two straight edges of the face (#37): the hole's centre sits at each one's + /// distance from its edge, measured in the face's plane, and follows the edges when the + /// part changes. `position` keeps where it was placed. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + references: Vec, }, /// A thread on a cylindrical face. Cosmetic by default (no geometry change; drawn and /// exported as an annotation); `modeled` cuts the real helical ISO profile into the face. @@ -2019,6 +2024,15 @@ pub enum HoleKind { }, } +/// A Single hole's reference edge (#37): a point on a straight edge of the hole's face, and the +/// distance of the hole's centre from that edge's line, in the face's plane. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)] +pub struct HoleReference { + pub edge: Position, + #[walk(length = "Reference distance")] + pub distance: Expr, +} + /// Pattern layouts. #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)] #[serde(tag = "type", rename_all = "snake_case")] diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index 3694e234b..40dbac3ce 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -3651,6 +3651,7 @@ fn hole_spots(vals: &BTreeMap, st: &ModelState, f: &Feature) -> R _ => { 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 = with_references(vals, st, f, at, dir)?; let dir = hole_dir_into_face(st, at, dir); return Ok((vec![hole_on_surface(st, at, dir, &[])], dir)); } @@ -3698,6 +3699,7 @@ fn hole_spots_raw(vals: &BTreeMap, st: &ModelState, f: &Feature) _ => { let dir = direction.normalized().ok_or_else(|| DocError::Invalid("hole direction".into()))?; let p = single_hole_position(vals, st, position, at, points)?; + let p = if hole_references(f).is_empty() { p } else { with_references(vals, st, f, hole_on_surface(st, p, dir, &[]), dir)? }; Ok((vec![p], hole_dir_into_face(st, hole_on_surface(st, p, dir, &[]), dir))) } } @@ -3719,6 +3721,35 @@ fn single_hole_position( Ok(ss.plane.to_world(p.pos)) } +/// A hole's reference edges (#37); none for any other feature. +fn hole_references(f: &Feature) -> &[crate::HoleReference] { + match &f.kind { + FeatureKind::Hole { references, .. } => references, + _ => &[], + } +} + +/// Where a Single hole with reference edges (#37) is drilled: at its distances from the edges' +/// lines, in the plane of the face at `at` (on the surface), the edges found by their names, else +/// their points. A hole without reference edges stays at `at`. +fn with_references(vals: &BTreeMap, st: &ModelState, f: &Feature, at: Vec3, dir: Vec3) -> Result { + let references = hole_references(f); + if references.is_empty() { + return Ok(at); + } + let mut distances = Vec::with_capacity(references.len()); + for r in references { + distances.push(Document::eval_in(vals, &r.distance, Kind::Length)?); + } + let edges: Vec<(Vec3, Option<&str>)> = references.iter().enumerate().map(|(i, r)| (r.edge.0, f.edge_names.get(i).map(String::as_str))).collect(); + let frame = crate::hole_reference::reference_frame(st, at, dir, &edges, false)?; + let centre = frame.place(at, &distances)?; + if !crate::hole_reference::on_reference_face(st, &frame, centre) { + return Err(DocError::Invalid("the reference distances put the hole's centre off its face".into())); + } + Ok(centre) +} + /// Where a hole placed by position is drilled: its `at` expressions evaluated, so it follows the /// parameters (#1678), else the point it was given. fn hole_position(vals: &BTreeMap, position: &crate::FacePick, at: &Option) -> Result { diff --git a/crates/doc/src/feature_walk_tests/fixtures.rs b/crates/doc/src/feature_walk_tests/fixtures.rs index 60812e46c..651576f64 100644 --- a/crates/doc/src/feature_walk_tests/fixtures.rs +++ b/crates/doc/src/feature_walk_tests/fixtures.rs @@ -72,6 +72,11 @@ pub(super) fn fixtures() -> Vec<(&'static str, Value)> { ("hole_drilled", hole(json!({"type": "drilled", "tip_angle": "hole.tip_angle"}))), ("hole_counterbore", hole(json!({"type": "counterbore", "cb_diameter": "hole.cb_diameter", "cb_depth": "hole.cb_depth"}))), ("hole_countersink", hole(json!({"type": "countersink", "cs_diameter": "hole.cs_diameter", "cs_angle": "hole.cs_angle"}))), + ("hole_references", { + let mut h = hole(json!({"type": "simple"})); + h["references"] = json!([{"edge": o, "distance": "hole.reference1"}, {"edge": o, "distance": "hole.reference2"}]); + h + }), ("thread", json!({"type": "thread", "face": o, "length": "thread.length"})), ("loft", json!({"type": "loft", "sections": []})), ("sweep", json!({"type": "sweep", "sketch": 1, "profiles": {"type": "all"}, "path_sketch": 2, "path": ["l1"]})), @@ -272,6 +277,9 @@ pub(super) fn with_points(name: &str, mut v: Value) -> Value { "surface_revolve" => json!({"axis": line}), "hole_simple" => json!({"points": null, "to": p(4.0)}), "hole_drilled" | "hole_counterbore" | "hole_countersink" => json!({"to": p(4.0)}), + "hole_references" => { + json!({"references": [{"edge": p(11.0), "distance": "hole.reference1"}, {"edge": p(12.0), "distance": "hole.reference2"}]}) + } "emboss" => json!({"face": {"body": "B", "at": p(5.0)}}), "sheet_convert" => json!({"bends": [p(6.0)]}), "sheet_fold" => json!({"fixed": p(7.0)}), diff --git a/crates/doc/src/feature_walk_tests/golden_exprs.txt b/crates/doc/src/feature_walk_tests/golden_exprs.txt index cd30f9340..ff4ba3a82 100644 --- a/crates/doc/src/feature_walk_tests/golden_exprs.txt +++ b/crates/doc/src/feature_walk_tests/golden_exprs.txt @@ -130,6 +130,13 @@ hole_countersink Countersink diameter = hole.cs_diameter (Length) Countersink angle = hole.cs_angle (Angle) expressions: hole.diameter, hole.depth, hole.cs_diameter, hole.cs_angle +hole_references + inputs: + Diameter = hole.diameter (Length) + Depth = hole.depth (Length) + Reference distance = hole.reference1 (Length) + Reference distance = hole.reference2 (Length) + expressions: hole.diameter, hole.depth, hole.reference1, hole.reference2 thread inputs: Length = thread.length (Length) diff --git a/crates/doc/src/feature_walk_tests/golden_geometry.txt b/crates/doc/src/feature_walk_tests/golden_geometry.txt index 61c14aa7f..f33a46bfa 100644 --- a/crates/doc/src/feature_walk_tests/golden_geometry.txt +++ b/crates/doc/src/feature_walk_tests/golden_geometry.txt @@ -56,6 +56,9 @@ hole_counterbore hole_countersink moves: direction[0], direction[2], position[0], position[1], position[2], to[0], to[1], to[2] face points: [4, 4.5, 4.25] +hole_references + moves: direction[0], direction[2], position[0], position[1], position[2], references[0].edge[0], references[0].edge[1], references[0].edge[2], references[1].edge[0], references[1].edge[1], references[1].edge[2] + face points: [0, 0, 0] thread moves: face[0], face[1], face[2] face points: [0, 0, 0] diff --git a/crates/doc/src/feature_walk_tests/golden_refs.txt b/crates/doc/src/feature_walk_tests/golden_refs.txt index 6871a9968..8f30912bf 100644 --- a/crates/doc/src/feature_walk_tests/golden_refs.txt +++ b/crates/doc/src/feature_walk_tests/golden_refs.txt @@ -58,6 +58,7 @@ hole_counterbore hole_countersink sketches: [3] remap_refs: points.sketch +hole_references thread loft sketches: [4, 5, 6] diff --git a/crates/doc/src/format/pending/hole-reference-edges.rs b/crates/doc/src/format/pending/hole-reference-edges.rs new file mode 100644 index 000000000..9a51c1e45 --- /dev/null +++ b/crates/doc/src/format/pending/hole-reference-edges.rs @@ -0,0 +1,6 @@ +//! A Single hole can be placed by distances from up to two straight edges of its face +//! (`references`: each `{"edge": [x, y, z], "distance": "…"}`, the edges' persistent names in the +//! feature's `edge_names`, #37): it is drilled where those distances hold, measured in the face's +//! plane, and follows the edges when the part changes. Older designs need no transformation: a +//! hole without `references` stays at its position, as before; 0.21.x asks for an update instead +//! of drilling a referenced hole where it was first placed. diff --git a/crates/doc/src/hole_reference.rs b/crates/doc/src/hole_reference.rs new file mode 100644 index 000000000..187a1971f --- /dev/null +++ b/crates/doc/src/hole_reference.rs @@ -0,0 +1,251 @@ +//! A Single hole placed by distances from reference edges (#37): up to two straight edges of the +//! face it is drilled into, each with the distance of the hole's centre from that edge's line, +//! measured in the face's plane. The edges are found again by their persistent names, else by +//! their stored points, so the hole follows them when the part changes. + +use solidcraft_geom::{Mesh, Vec3}; + +use crate::{DocError, ModelBody, ModelState, Result}; + +/// The most reference edges a hole takes. +pub const MAX_HOLE_REFERENCES: usize = 2; + +/// A reference edge's line in the face's plane. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct ReferenceLine { + /// A point on the line: the edge's middle, moved into the face's plane. + pub point: Vec3, + /// Along the edge (unit). + pub along: Vec3, + /// In the plane, square to the edge, toward the side the face is on (unit): the way the + /// distance grows. + pub toward: Vec3, +} + +impl ReferenceLine { + /// How far `p` is from the line, toward the face's side (negative on the other side). + pub fn distance(&self, p: Vec3) -> f64 { + (p - self.point).dot(self.toward) + } + + /// The point of the line nearest `p`. + pub fn foot(&self, p: Vec3) -> Vec3 { + self.point + self.along * (p - self.point).dot(self.along) + } +} + +/// The face a referenced hole is drilled into (its plane) and its reference edges' lines. +#[derive(Clone, Debug, PartialEq)] +pub struct ReferenceFrame { + /// The body and the face (its index). + pub body: String, + pub face: usize, + /// A point on the face's plane. + pub origin: Vec3, + /// The face's outward unit normal. + pub normal: Vec3, + pub lines: Vec, + /// The reference edges found (their indices in the body's mesh), one per line. + pub edges: Vec, +} + +impl ReferenceFrame { + /// `p` moved square onto the face's plane. + pub fn onto_plane(&self, p: Vec3) -> Vec3 { + p - self.normal * (p - self.origin).dot(self.normal) + } + + /// How far `p` is from each line (see [`ReferenceLine::distance`]). + pub fn distances(&self, p: Vec3) -> Vec { + let p = self.onto_plane(p); + self.lines.iter().map(|l| l.distance(p)).collect() + } + + /// The hole's centre at `distances` (one per line) from the lines, in the face's plane. With + /// one line, `near` moves square to it (it keeps its place along the edge); with two, the + /// centre is where both distances hold. + pub fn place(&self, near: Vec3, distances: &[f64]) -> Result { + if let Some((i, _)) = distances.iter().enumerate().find(|(_, d)| !(d.is_finite() && **d >= 0.0 && **d < 1e9)) { + return Err(DocError::Invalid(format!("reference distance {} must be a length of 0 or more", i + 1))); + } + let p = self.onto_plane(near); + match (self.lines.as_slice(), distances) { + ([], []) => Ok(p), + ([a], [d]) => Ok(p + a.toward * (d - a.distance(p))), + ([a, b], [d1, d2]) => { + // p + r1 * a.toward + s * e2, with e2 square to a in the plane: a's distance is + // then d1, and s gives b's. + let (r1, r2) = (d1 - a.distance(p), d2 - b.distance(p)); + let e2 = self.normal.cross(a.toward); + let across = b.toward.dot(e2); + if across.abs() < 1e-6 { + return Err(DocError::Invalid("the reference edges are parallel: pick edges that cross".into())); + } + Ok(p + a.toward * r1 + e2 * ((r2 - r1 * a.toward.dot(b.toward)) / across)) + } + _ => Err(DocError::Invalid("a hole takes one distance for each reference edge".into())), + } + } +} + +/// The reference frame of a hole placed at `at` (on the surface), drilled along `dir` (into the +/// material), from its reference edges: a point on each edge and, when it has one, the edge's +/// persistent name. A fresh pick (`exact`) must lie on its edge; a stored one is found by its +/// name, else the edge nearest its point. The face is the flat face under `at` that faces the +/// drill, else the one the edges border. +pub fn reference_frame(st: &ModelState, at: Vec3, dir: Vec3, edges: &[(Vec3, Option<&str>)], exact: bool) -> Result { + if edges.len() > MAX_HOLE_REFERENCES { + return Err(DocError::Invalid(format!("a hole takes at most {MAX_HOLE_REFERENCES} reference edges"))); + } + let dir = dir.normalized().ok_or_else(|| DocError::Invalid("hole direction".into()))?; + if !at.is_finite() || edges.iter().any(|(p, _)| !p.is_finite()) { + return Err(DocError::Invalid("reference edges need finite points".into())); + } + let b = body_at(st, at).ok_or_else(|| DocError::Invalid("no body at the hole for its reference edges".into()))?; + let m = b.mesh(); + let size = b.body.size().max(1e-9); + let mut found = Vec::with_capacity(edges.len()); + for (k, (p, name)) in edges.iter().enumerate() { + found.push(find_edge(b, &m, k, *p, *name, exact)?); + } + let (face, origin, normal) = flat_face(b, &m, at, dir, &found).ok_or_else(|| { + DocError::Invalid("reference edges need the hole on a flat face: no flat face facing the drill at the hole or along its edges".into()) + })?; + let mut lines = Vec::with_capacity(found.len()); + for (k, (a, z, _)) in found.iter().enumerate() { + let flat = |q: Vec3| q - normal * (q - origin).dot(normal); + let (a, z) = (flat(*a), flat(*z)); + let along = (z - a).normalized().ok_or_else(|| DocError::Invalid(format!("reference edge {} is square to the face", k + 1)))?; + let across = normal.cross(along).normalized().ok_or_else(|| DocError::Invalid(format!("reference edge {} is square to the face", k + 1)))?; + let mid = (a + z) * 0.5; + // The side the face is on next to the edge; an edge the face doesn't border (or borders + // on both sides) takes the side the hole is on. + let side = face_side(&m, face, mid, across, normal, size).unwrap_or_else(|| if (at - mid).dot(across) < 0.0 { -1.0 } else { 1.0 }); + lines.push(ReferenceLine { point: mid, along, toward: across * side }); + } + if let [a, b] = lines.as_slice() + && a.along.cross(b.along).len() < 1e-6 + { + return Err(DocError::Invalid("the reference edges are parallel: pick edges that cross".into())); + } + Ok(ReferenceFrame { body: b.name.clone(), face, origin, normal, lines, edges: found.iter().map(|(_, _, i)| *i).collect() }) +} + +/// Whether `p` lies on the flat face a reference frame was made for. +pub fn on_reference_face(st: &ModelState, frame: &ReferenceFrame, p: Vec3) -> bool { + let Some(b) = st.bodies.iter().find(|b| b.name == frame.body) else { return false }; + let m = b.mesh(); + let tol = (b.body.size() * 1e-4).max(1e-6); + m.triangles + .iter() + .zip(&m.tri_face) + .filter(|(_, f)| **f as usize == frame.face) + .any(|(t, _)| m.tri(t).is_some_and(|[a, bb, c]| crate::appearance::closest_on_triangle(p, a, bb, c).dist(p) <= tol)) +} + +/// The persistent names of the edges at `edges`, on the body the hole at `at` is drilled into +/// (empty where an edge has none). +pub fn reference_edge_names(st: &ModelState, at: Vec3, edges: &[Vec3]) -> Vec { + match body_at(st, at) { + Some(b) => crate::naming::edge_names_at(b, edges), + None => Vec::new(), + } +} + +/// The (non-mesh) body whose surface is nearest `p`. +fn body_at(st: &ModelState, p: Vec3) -> Option<&ModelBody> { + st.bodies + .iter() + .filter(|b| !b.body.is_mesh()) + .filter_map(|b| crate::appearance::nearest_face(b, p).map(|(d, _)| (d, b))) + .min_by(|a, b| a.0.total_cmp(&b.0)) + .map(|(_, b)| b) +} + +/// How far `p` is from an edge's polyline. +fn to_polyline(p: Vec3, e: &[Vec3]) -> f64 { + e.windows(2).map(|w| p.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min) +} + +/// Reference edge `k` (its ends, and its index in the mesh), found by `name`, else by the edge +/// nearest `p`: one that runs through `p` for a fresh pick, within a quarter of the body for a +/// stored one. It must be straight. +fn find_edge(b: &ModelBody, m: &Mesh, k: usize, p: Vec3, name: Option<&str>, exact: bool) -> Result<(Vec3, Vec3, usize)> { + let size = b.body.size().max(1e-9); + let by_name = name.filter(|n| !n.is_empty()).and_then(|n| crate::naming::locate_edge(b, n, p).ok()).map(|hit| hit.edge); + let i = match by_name { + Some(i) => i, + None => { + let reach = if exact { (size * 1e-2).max(1e-3) } else { size * 0.25 }; + m.edges + .iter() + .enumerate() + .map(|(i, e)| (to_polyline(p, e), i)) + .filter(|(d, _)| d.is_finite()) + .min_by(|a, b| a.0.total_cmp(&b.0)) + .filter(|(d, _)| *d <= reach) + .map(|(_, i)| i) + .ok_or_else(|| { + DocError::Invalid(if exact { + format!("reference edge {}: no edge at [{}, {}, {}]", k + 1, p.x, p.y, p.z) + } else { + format!("reference edge {} no longer exists", k + 1) + }) + })? + } + }; + let e = m.edges.get(i).ok_or_else(|| DocError::Invalid(format!("reference edge {} no longer exists", k + 1)))?; + let (Some(a), Some(z)) = (e.first().copied(), e.last().copied()) else { + return Err(DocError::Invalid(format!("reference edge {} no longer exists", k + 1))); + }; + let len = a.dist(z); + let straight = len > size * 1e-9 && e.iter().all(|q| q.dist_to_segment(a, z) <= 1e-5 * (1.0 + len)); + if !straight { + return Err(DocError::Invalid(format!("reference edge {} is not straight: pick a straight edge", k + 1))); + } + Ok((a, z, i)) +} + +/// The flat face a referenced hole goes into (its index, a point on it and its outward normal): +/// the one under `at` when it faces the drill, else the one the edges border that faces it most. +fn flat_face(b: &ModelBody, m: &Mesh, at: Vec3, dir: Vec3, edges: &[(Vec3, Vec3, usize)]) -> Option<(usize, Vec3, Vec3)> { + let size = b.body.size().max(1e-9); + let plane = |f: usize| match crate::kernel::face_surface(&b.body, f) { + // Outward, so against the drill. + Some(crate::kernel::FaceSurface::Plane { normal, point }) => { + let normal: Vec3 = normal.into(); + let n = if normal.dot(dir) > 0.0 { -normal } else { normal }; + (n.dot(dir) < -1e-3).then_some((f, point, n)) + } + _ => None, + }; + if let Some((d, f)) = crate::appearance::nearest_face(b, at) + && d <= (size * 1e-4).max(1e-6) + && let Some(hit) = plane(f) + { + return Some(hit); + } + // The faces every edge borders. + let mut faces: Vec = + edges.first().and_then(|(_, _, i)| m.edge_faces.get(*i)).map(|fs| fs.iter().map(|f| *f as usize).collect()).unwrap_or_default(); + for (_, _, i) in edges.iter().skip(1) { + let theirs = m.edge_faces.get(*i).map(Vec::as_slice).unwrap_or(&[]); + faces.retain(|f| theirs.iter().any(|g| *g as usize == *f)); + } + faces.into_iter().filter_map(plane).min_by(|x, y| x.2.dot(dir).total_cmp(&y.2.dot(dir))) +} + +/// Which side of an edge (through `mid`, square to it in the plane along `across`) face `face` +/// lies on: +1 or −1, or `None` when both sides or neither are that face. +fn face_side(m: &Mesh, face: usize, mid: Vec3, across: Vec3, normal: Vec3, size: f64) -> Option { + let step = (size * 1e-3).max(1e-6); + let lands = |s: f64| { + let from = mid + across * (s * step) + normal * step; + m.raycast(from, -normal).is_some_and(|(t, tri)| t <= 2.0 * step && m.tri_face.get(tri).is_some_and(|f| *f as usize == face)) + }; + match (lands(1.0), lands(-1.0)) { + (true, false) => Some(1.0), + (false, true) => Some(-1.0), + _ => None, + } +} diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs index b2e57d3be..8c3517091 100644 --- a/crates/doc/src/lib.rs +++ b/crates/doc/src/lib.rs @@ -31,6 +31,7 @@ pub mod format; mod format_offsets; pub mod frame; mod history_names; +pub mod hole_reference; pub use format_offsets::whole_profile_selection_from_value; pub mod joints; mod lineage; diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index ee475be19..fc60ed31e 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -1037,6 +1037,13 @@ fn edit_feature(s: &mut Session, p: &Value) -> Result { nf.edge_names = solidcraft_doc::sheet::sheet_edge_names(&s.model.state_before(id), &solidcraft_doc::plain(&points(a))); } } + // New reference edges for a hole (#37): the names of the edges there now. + if let (FeatureKind::Hole { references: a, position, .. }, FeatureKind::Hole { references: b, .. }) = (&nf.kind, &f.kind) { + let edges = |r: &[solidcraft_doc::HoleReference]| r.iter().map(|x| x.edge.0).collect::>(); + if edges(a) != edges(b) { + nf.edge_names = solidcraft_doc::hole_reference::reference_edge_names(&s.model.state_before(id), position.0, &edges(a)); + } + } // New bend edges for a conversion: the names of the body's edges there now. if let (FeatureKind::SheetConvert { bends: a, body, .. }, FeatureKind::SheetConvert { bends: b, body: was, .. }) = (&nf.kind, &f.kind) && (a != b || body != was) diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rs index 216b12668..3391c1ecf 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); 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)"), + .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); references?: [{edge: [x,y,z] on a straight edge of the face, distance: expr}] (at most two; the centre goes that far from each edge's line, in the face's plane, and follows the edges; with a numeric position only); 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") @@ -520,6 +520,11 @@ fn add_feature_in(s: &mut Session, p: &Value, kind: FeatureKind, world: bool) -> (Vec::new(), solidcraft_doc::sheet::sheet_edge_names(&s.model.state(), &solidcraft_doc::plain(&points))) } FeatureKind::SheetHem { edges, .. } => (Vec::new(), solidcraft_doc::sheet::sheet_edge_names(&s.model.state(), &solidcraft_doc::plain(edges))), + // A hole's reference edges (#37) are edges of the body it is drilled into. + FeatureKind::Hole { position, references, .. } if !references.is_empty() => { + let edges: Vec = references.iter().map(|r| r.edge.0).collect(); + (Vec::new(), solidcraft_doc::hole_reference::reference_edge_names(&s.model.state(), position.0, &edges)) + } // A conversion's bend edges are edges of the body it converts. FeatureKind::SheetConvert { body, bends, .. } if !bends.is_empty() => { (Vec::new(), solidcraft_doc::sheet::bend_edge_names(&s.model.state(), body, &solidcraft_doc::plain(bends))) @@ -1931,6 +1936,11 @@ fn hole(s: &mut Session, p: &Value) -> Result { } None => None, }; + // Reference edges (#37): the centre sits at these distances from straight edges of its face. + let references = hole_reference_params(s, p, cmd)?; + if !references.is_empty() && (points.is_some() || at.is_some()) { + return Err(bad(cmd, "`references` place a hole by its `position` given as numbers, not at sketch points or length expressions")); + } let position = match (&points, at_value.or_else(|| p.get("position").and_then(vec3))) { (Some((_, first, _)), None) => *first, (_, Some(x)) => x, @@ -1948,6 +1958,24 @@ fn hole(s: &mut Session, p: &Value) -> Result { } }, }; + // Placed by its reference edges: drilled where their distances put it, which `position` + // then keeps. The edges must be straight edges at the given points, and cross. + let position = if references.is_empty() { + position + } else { + let st = s.model.state(); + let mut distances = Vec::with_capacity(references.len()); + for r in &references { + distances.push(s.doc.eval(&r.distance, Kind::Length).map_err(|e| bad(cmd, format!("`references`: {e}")))?); + } + let edges: Vec<(Vec3, Option<&str>)> = references.iter().map(|r| (r.edge.0, None)).collect(); + let frame = solidcraft_doc::hole_reference::reference_frame(&st, position, direction, &edges, true).map_err(|e| bad(cmd, e.to_string()))?; + let centre = frame.place(position, &distances).map_err(|e| bad(cmd, e.to_string()))?; + if !solidcraft_doc::hole_reference::on_reference_face(&st, &frame, centre) { + return Err(bad(cmd, "the reference distances put the hole's centre off its face")); + } + centre + }; // The diameter: given, or the tap drill of the thread (major − pitch), or an ISO 273 // clearance hole for a bolt size (close, normal or loose fit). let diameter = match (expr(p, "diameter"), &thread, str_(p, "clearance")) { @@ -2022,10 +2050,33 @@ fn hole(s: &mut Session, p: &Value) -> Result { points: points.map(|x| x.0), thread, to: to.map(FacePick), + references, }, ) } +/// A hole's reference edges (#37): `references: [{edge: [x, y, z], distance: expr}]`, at most +/// two, each distance a length. +fn hole_reference_params(s: &Session, p: &Value, cmd: &str) -> Result> { + let Some(v) = p.get("references") else { return Ok(Vec::new()) }; + let list = v.as_array().ok_or_else(|| bad(cmd, "`references` must be a list of {edge: [x, y, z], distance}"))?; + let most = solidcraft_doc::hole_reference::MAX_HOLE_REFERENCES; + if list.len() > most { + return Err(bad(cmd, format!("a hole takes at most {most} `references`"))); + } + let mut out = Vec::with_capacity(list.len()); + for (i, r) in list.iter().enumerate() { + let edge = r + .get("edge") + .and_then(vec3) + .ok_or_else(|| bad(cmd, format!("`references[{i}].edge` must be a point [x, y, z] on a straight edge of the face")))?; + let distance = expr(r, "distance").ok_or_else(|| bad(cmd, format!("`references[{i}].distance` must be a number or an expression")))?; + check_expr(s, &distance, Kind::Length, cmd, "references")?; + out.push(solidcraft_doc::HoleReference { edge: Position(edge), distance }); + } + Ok(out) +} + /// The body whose face is nearest `p` (within its pick tolerance), when it belongs to another /// component than the active one. fn body_of_other_component_at(s: &Session, p: Vec3) -> Option { diff --git a/crates/engine/src/hole_reference_tests.rs b/crates/engine/src/hole_reference_tests.rs new file mode 100644 index 000000000..da8ac53a6 --- /dev/null +++ b/crates/engine/src/hole_reference_tests.rs @@ -0,0 +1,167 @@ +//! A Single hole placed by distances from reference edges (#37): the centre sits at the typed +//! distances from straight edges of its face, measured in the face's plane, follows the edges +//! when the part changes (also after the design is saved and reopened), and a bad reference is +//! refused with an error. + +use std::f64::consts::PI; + +use serde_json::{Value, json}; +use solidcraft_doc::FeatureKind; +use solidcraft_geom::Vec3; + +use crate::{EngineError, 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 solid_at(s: &Session, p: Vec3) -> bool { + s.model.state().bodies.iter().any(|b| b.body.contains(p)) +} + +/// The bore (5 mm across, 4 mm deep, down from the top face at z = `top`) is about (x, y): +/// empty on its axis and up to 2 mm from it, solid 3 mm from it in every direction (the margins +/// leave room for the facets of a larger body's coarser mesh). +fn bore_at(s: &Session, x: f64, y: f64, top: f64) { + let at = Vec3::new(x, y, top - 2.0); + for k in 0..8 { + let a = PI / 4.0 * f64::from(k); + let p = |r: f64| at + Vec3::new(a.cos(), a.sin(), 0.0) * r; + assert!(!solid_at(s, p(0.0)) && !solid_at(s, p(2.0)), "the bore about ({x}, {y}) is empty {a} rad from +x"); + assert!(solid_at(s, p(3.0)), "the wall about ({x}, {y}) is solid {a} rad from +x"); + } +} + +/// The last feature's position and reference edges. +fn hole(s: &Session) -> (Vec3, Vec) { + match &s.doc.features.last().map(|f| &f.kind) { + Some(FeatureKind::Hole { position, references, .. }) => (position.0, references.clone()), + other => panic!("the last feature is not a hole: {other:?}"), + } +} + +/// A 50 × 40 × 10 box from the origin whose length and width are parameters. +fn plate() -> Session { + let mut s = Session::default(); + run(&mut s, "parameters.add", json!({"name": "len", "expression": "50 mm"})); + run(&mut s, "parameters.add", json!({"name": "wid", "expression": "40 mm"})); + run(&mut s, "solid.box", json!({"length": "len", "width": "wid", "height": 10, "corner": [0, 0, 0]})); + s +} + +/// A Ø5 × 4 hole picked at (30, 25) on the top, with these references. +fn referenced(references: Value) -> Value { + json!({"position": [30, 25, 10], "diameter": 5, "depth": 4, "name": "H", "references": references}) +} + +#[test] +fn a_hole_sits_at_its_distances_from_two_edges() { + let mut s = plate(); + // 10 mm from the left edge (x = 0) and 12 mm from the front edge (y = 0) of the top. + run(&mut s, "solid.hole", referenced(json!([{"edge": [0, 20, 10], "distance": 10}, {"edge": [25, 0, 10], "distance": "12 mm"}]))); + let (position, refs) = hole(&s); + assert!(position.dist(Vec3::new(10.0, 12.0, 10.0)) < 1e-6, "the hole is placed at (10, 12), not {position:?}"); + assert_eq!(refs.len(), 2); + bore_at(&s, 10.0, 12.0, 10.0); + assert!(solid_at(&s, Vec3::new(30.0, 25.0, 8.0)), "nothing is drilled where the face was picked"); + // The distances are the hole's parameters, named like its other inputs. + let f = s.doc.find_feature("H").unwrap(); + let labels: Vec<&str> = f.kind.inputs().iter().map(|(label, _, _)| *label).collect(); + assert_eq!(labels.iter().filter(|l| **l == "Reference distance").count(), 2, "{labels:?}"); + assert_eq!(f.param_names.len(), labels.len()); + assert_eq!(f.edge_names.len(), 2, "each reference edge keeps its persistent name"); + // One reference: the hole moves square to that edge and keeps its place along it. + run(&mut s, "edit.undo", json!({})); + run(&mut s, "solid.hole", referenced(json!([{"edge": [0, 20, 10], "distance": 10}]))); + bore_at(&s, 10.0, 25.0, 10.0); +} + +#[test] +fn a_hole_follows_its_edges_when_the_box_grows() { + let mut s = plate(); + // From the far edges: 10 mm from x = len, 12 mm from y = wid. + run(&mut s, "solid.hole", referenced(json!([{"edge": [50, 20, 10], "distance": 10}, {"edge": [25, 40, 10], "distance": 12}]))); + bore_at(&s, 40.0, 28.0, 10.0); + let id = s.doc.find_feature("H").unwrap().id; + run(&mut s, "parameters.change", json!({"name": "len", "expression": "80 mm"})); + run(&mut s, "parameters.change", json!({"name": "wid", "expression": "65 mm"})); + assert!(s.model.result(id).is_some_and(|r| r.error.is_none()), "{:?}", s.model.result(id).map(|r| &r.error)); + bore_at(&s, 70.0, 53.0, 10.0); + assert!(solid_at(&s, Vec3::new(40.0, 28.0, 8.0)), "the old spot is solid again"); + // A distance is a parameter too: changing it moves the hole. + let d = s.doc.find_feature("H").unwrap().param_names.last().cloned().unwrap(); + run(&mut s, "parameters.change", json!({"name": d, "expression": "20 mm"})); + bore_at(&s, 70.0, 45.0, 10.0); + // Smaller than where the hole was placed: it still follows its edges. + run(&mut s, "parameters.change", json!({"name": "len", "expression": "30 mm"})); + bore_at(&s, 20.0, 45.0, 10.0); + // Saved and reopened, the hole keeps its references and its place. + let mut t = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap()); + t.refresh(); + bore_at(&t, 20.0, 45.0, 10.0); + assert_eq!(hole(&t).1, hole(&s).1); +} + +#[test] +fn a_bad_reference_is_refused() { + let mut s = plate(); + run(&mut s, "solid.hole", json!({"position": [25, 20, 10], "diameter": 10, "name": "Bore"})); + let before = s.doc.features.len(); + let edge = |p: [f64; 3], d: Value| json!({"edge": p, "distance": d}); + for (refs, why) in [ + (json!([edge([25.0, 30.0, 10.0], json!(5))]), "no edge"), + (json!([edge([30.0, 20.0, 10.0], json!(5))]), "not straight"), + (json!([edge([0.0, 0.0, 5.0], json!(5))]), "square to the face"), + (json!([edge([0.0, 20.0, 10.0], json!(5)), edge([50.0, 20.0, 10.0], json!(5))]), "parallel"), + (json!([edge([0.0, 20.0, 10.0], json!(5)), edge([25.0, 0.0, 10.0], json!(5)), edge([50.0, 20.0, 10.0], json!(5))]), "at most 2"), + (json!([edge([0.0, 20.0, 10.0], json!("-5 mm"))]), "0 or more"), + (json!([edge([0.0, 20.0, 10.0], json!(500))]), "off its face"), + (json!([edge([0.0, 20.0, 10.0], json!("5 deg"))]), "references"), + (json!([edge([0.0, 20.0, 10.0], json!("nope"))]), "references"), + (json!([{"edge": [0, 20], "distance": 5}]), "edge"), + (json!([{"edge": [0, 20, 10]}]), "distance"), + (json!({"edge": [0, 20, 10], "distance": 5}), "list"), + ] { + let p = referenced(refs.clone()); + match s.execute("solid.hole", &p) { + Err(EngineError::Internal(..)) | Ok(_) => panic!("{refs} is refused"), + Err(e) => assert!(e.to_string().contains(why), "{refs}: {e}"), + } + assert_eq!(s.doc.features.len(), before, "{refs} adds nothing"); + } + // Not with sketch points or a position given as expressions. + for p in [ + json!({"position": ["30 mm", "25 mm", "10 mm"], "diameter": 5, "references": [edge([0.0, 20.0, 10.0], json!(5))]}), + json!({"sketch": 1, "points": ["p1"], "diameter": 5, "references": [edge([0.0, 20.0, 10.0], json!(5))]}), + ] { + assert!(s.execute("solid.hole", &p).is_err(), "{p}"); + } +} + +#[test] +fn hostile_references_never_panic() { + let mut s = plate(); + let values = crate::tests::hostile_values(); + let mut panicked = Vec::new(); + for v in &values { + for refs in [ + v.clone(), + json!([v]), + json!([v, v]), + json!([{"edge": v, "distance": 5}]), + json!([{"edge": [0, 20, 10], "distance": v}]), + json!([{"edge": [0, 20, 10], "distance": 5}, {"edge": v, "distance": v}]), + ] { + for at in [json!([30, 25, 10]), json!([0, 0, 10]), json!([1e300, 0, 10]), v.clone()] { + let p = json!({"position": at, "diameter": 5, "references": refs}); + if let Err(EngineError::Internal(id, msg)) = s.execute("solid.hole", &p) { + panicked.push(format!("{id} {p}: {msg}")); + } + } + } + } + assert!(panicked.is_empty(), "solid.hole panicked:\n{}", panicked.join("\n")); +} diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index b69f50091..7084bc65a 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -1250,6 +1250,8 @@ mod hole_face_tests; #[cfg(test)] mod hole_matrix_tests; #[cfg(test)] +mod hole_reference_tests; +#[cfg(test)] mod large_assembly_tests; #[cfg(test)] mod measure_centre_tests; diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 0e2d53fa4..5e1f23df9 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -826,6 +826,7 @@ fn hostile_params_never_panic() { "anchor", "density", "names", + "references", ]; // Commands are independent; worker threads take them one at a time (their costs vary a lot). let ids: Vec<&str> = command_specs() diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs index a4d8a01d7..8bb0481d6 100644 --- a/crates/ui-egui/src/canvas.rs +++ b/crates/ui-egui/src/canvas.rs @@ -375,7 +375,7 @@ fn along(proj: &Proj, pos: Pos2, base: Vec3, dir: Vec3) -> Option { Some((b * e - d) / den) } -fn format_len(v: f64) -> String { +pub(crate) fn format_len(v: f64) -> String { let s = format!("{v:.3}"); let s = s.trim_end_matches('0').trim_end_matches('.'); format!("{} mm", if s == "-0" { "0" } else { s }) @@ -445,7 +445,7 @@ fn draw(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj: &Proj, | Kind::OffsetFaces { .. } | Kind::SketchModify(crate::sketch_modify_ui::Mod::Move { .. }) ); - let focus = std::mem::take(&mut d.focus); + let mut focus = std::mem::take(&mut d.focus); let half_height = app.cam.half_height(); let axis = revolve_axis(app, d); if matches!(d.kind, Kind::Revolve { .. }) { @@ -531,6 +531,11 @@ fn draw(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj: &Proj, opts.all = false; } dir = None; + // A Single hole's distances from its reference edges (#37); a newly picked edge's box + // takes the keyboard. + if crate::hole_refs::canvas(app, ui, painter, proj, d) { + focus = false; + } } // A fillet with a radius spline is shaped by its handles along the edge; the arrow would sit // on one of them. @@ -586,28 +591,42 @@ fn value_box(ui: &mut egui::Ui, label: &str, value: &mut String, at: Pos2, selec /// [`value_box`]; with `keep_tab` Tab stays in the box for the caller (the Move box steps /// through its values with it). fn value_box_with(ui: &mut egui::Ui, label: &str, value: &mut String, at: Pos2, select_all: bool, keep_tab: bool) { + let ids = (egui::Id::new("sc_canvas_area"), egui::Id::new("sc_canvas_value")); + value_box_in(ui, ids, label, value, (at, egui::Align2::LEFT_TOP), select_all, keep_tab); +} + +/// [`value_box_with`] under its own ids (its area's and its field's), for a value beside the main +/// one (a hole's reference distances), with the point of the box that sits at `at`. Returns where +/// the field is. +pub(crate) fn value_box_in( + ui: &mut egui::Ui, + (area, id): (egui::Id, egui::Id), + label: &str, + value: &mut String, + (at, pivot): (Pos2, egui::Align2), + select_all: bool, + keep_tab: bool, +) -> Option { let t = Tokens::get(); - let id = egui::Id::new("sc_canvas_value"); - Container::new(ui.ctx(), Surface::Canvas).area(egui::Id::new("sc_canvas_area")).fixed_pos(at).order(egui::Order::Foreground).show( - ui.ctx(), - |ui| { - Container::popup_frame(ui.style()).inner_margin(egui::Margin::symmetric(6, 3)).show(ui, |ui| { - ui.horizontal(|ui| { - ui.label(egui::RichText::new(crate::i18n::tr_label(label)).color(t.text_dim).size(crate::theme::Tokens::get().font_caption)); - let r = crate::ui_kit::canvas_value_field(ui, id, value, keep_tab); - crate::params_dialog::complete(ui, &r, value); - if select_all { - r.request_focus(); - let n = value.chars().count(); - let mut st = egui::text_edit::TextEditState::load(ui.ctx(), id).unwrap_or_default(); - st.cursor - .set_char_range(Some(egui::text_selection::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(n)))); - st.store(ui.ctx(), id); - } - }); + let mut field = None; + Container::new(ui.ctx(), Surface::Canvas).area(area).fixed_pos(at).pivot(pivot).order(egui::Order::Foreground).show(ui.ctx(), |ui| { + Container::popup_frame(ui.style()).inner_margin(egui::Margin::symmetric(6, 3)).show(ui, |ui| { + ui.horizontal(|ui| { + ui.label(egui::RichText::new(crate::i18n::tr_label(label)).color(t.text_dim).size(crate::theme::Tokens::get().font_caption)); + let r = crate::ui_kit::canvas_value_field(ui, id, value, keep_tab); + crate::params_dialog::complete(ui, &r, value); + if select_all { + r.request_focus(); + let n = value.chars().count(); + let mut st = egui::text_edit::TextEditState::load(ui.ctx(), id).unwrap_or_default(); + st.cursor.set_char_range(Some(egui::text_selection::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(n)))); + st.store(ui.ctx(), id); + } + field = Some(r.rect); }); - }, - ); + }); + }); + field } /// How far (logical points) from an arrow's stem a press still takes the arrow. diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index 8a1b57c7d..afda0175f 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -377,6 +377,13 @@ crate::dialog_descriptor::dialog_descriptors! { /// Holes go on any face (flat or curved; the engine drills against the face's normal there). const HOLE_FACES: Accept = PLANAR_FACES | FACES | selection::POINTS; +/// The Single hole placement's inputs: the face, then up to two reference edges (#37). +fn single_hole_inputs() -> Vec { + let mut v = vec![SelInput::new("Face", HOLE_FACES, true)]; + v.extend(crate::hole_refs::inputs()); + v +} + /// The rest of the Hole dialog: placement, extents, tap type and drill point. #[derive(Clone, Debug, PartialEq)] pub struct HoleOpts { @@ -392,11 +399,22 @@ pub struct HoleOpts { pub thread: String, /// Custom nominal diameter and pitch being edited, separate from the saved designation. pub custom_thread: Option, + /// The Single hole's reference edge distances (`hole_refs`, #37). + pub refs: Box, } impl Default for HoleOpts { fn default() -> Self { - HoleOpts { multiple: false, all: false, angled: true, tip_angle: "118 deg".into(), tapped: false, thread: "M5".into(), custom_thread: None } + HoleOpts { + multiple: false, + all: false, + angled: true, + tip_angle: "118 deg".into(), + tapped: false, + thread: "M5".into(), + custom_thread: None, + refs: Default::default(), + } } } @@ -738,7 +756,7 @@ impl Dialog { ] }), "solid.move" => Dialog::new(crate::dialogs_move::kind(0), crate::dialogs_move::inputs(0)), - "solid.hole" => Dialog::new(hole_defaults(), vec![SelInput::new("Face", HOLE_FACES, true)]), + "solid.hole" => Dialog::new(hole_defaults(), single_hole_inputs()), "solid.box" => Dialog::new( Kind::Primitive { cmd: "solid.box", @@ -1955,7 +1973,7 @@ fn placement_row(d: &mut Dialog, ui: &mut egui::Ui) { choice_row(ui, "Placement", "hole_place", &mut m, &["Single", "Multiple"]); if (m == 1) != opts.multiple { opts.multiple = m == 1; - d.inputs = vec![if opts.multiple { SelInput::new("Points", selection::POINTS, true) } else { SelInput::new("Face", HOLE_FACES, true) }]; + d.inputs = if opts.multiple { vec![SelInput::new("Points", selection::POINTS, true)] } else { single_hole_inputs() }; d.active = 0; d.extra.remove("direction"); } @@ -2004,7 +2022,7 @@ fn stored_revolve_axis(kind: &Kind) -> Option<&Value> { } } -fn input_rows_range(d: &mut Dialog, ui: &mut egui::Ui, s: &Session, range: std::ops::Range) { +pub(crate) fn input_rows_range(d: &mut Dialog, ui: &mut egui::Ui, s: &Session, range: std::ops::Range) { // Edit Text shows its Path input among its own rows. if matches!(d.kind, Kind::Text(_)) { return; @@ -3810,6 +3828,16 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result, S None => json!({ "position": kept.unwrap_or(p) }), })); } + // Reference edges (#37) place the one hole by its distances from them, from where + // it was picked. + let references = crate::hole_refs::params(d); + if !references.is_empty() { + let at = sels(d, 0).iter().find_map(face_point); + match (places.as_mut_slice(), at) { + ([place], Some(at)) => *place = json!({"position": at, "references": references}), + _ => return Err("reference edges place one hole: pick one place on the face".into()), + } + } } let mut out = Vec::new(); for place in places { @@ -4575,7 +4603,7 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option) -> Option { + FeatureKind::Hole { position, at, direction, diameter, depth, hole, points, thread, to, references } => { let mut d = start("solid.hole")?; let mut k = hole_defaults(); if let Kind::Hole { diameter: dia, depth: dep, kind, cb_diameter, cb_depth, cs_diameter, cs_angle, opts } = &mut k { @@ -4643,6 +4671,7 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option) -> Option = at.iter().map(|e| e.as_str()).collect(); d.extra.insert("position_exprs".into(), json!({"at": exprs, "point": pt3(position.0)})); } + crate::hole_refs::restore(s, &mut d, references, &f.edge_names); } } if to.is_some() { diff --git a/crates/ui-egui/src/dialogs_dense.rs b/crates/ui-egui/src/dialogs_dense.rs index 524e693c0..39b5c901c 100644 --- a/crates/ui-egui/src/dialogs_dense.rs +++ b/crates/ui-egui/src/dialogs_dense.rs @@ -183,7 +183,12 @@ pub(super) fn rows(app: &mut SolveApp, ctx: &egui::Context, d: &mut Dialog, ui: ui_kit::text(ui, tr(key), ui_kit::Text::Hint("manage")); } placement_row(d, ui); - input_rows(d, ui, &app.session); + if matches!(&d.kind, Kind::Hole { opts, .. } if !opts.multiple) { + // Each reference edge with its distance (#37). + enter |= crate::hole_refs::input_rows(d, ui, &app.session); + } else { + input_rows(d, ui, &app.session); + } match &mut d.kind { Kind::Material { index } => { let names = app.session.doc.material_names(); diff --git a/crates/ui-egui/src/hole_refs.rs b/crates/ui-egui/src/hole_refs.rs new file mode 100644 index 000000000..876a3f419 --- /dev/null +++ b/crates/ui-egui/src/hole_refs.rs @@ -0,0 +1,352 @@ +//! A Single hole placed by distances from reference edges (#37). After the face pick the Hole +//! dialog takes up to two straight edges of that face (Reference 1 and 2), each with the hole +//! centre's distance from it (Distance 1 and 2). Picking an edge measures its distance from where +//! the hole is; typing a distance (in the dialog or in its box on the canvas) moves the hole +//! there; moving the hole (another pick, or dragging its handle) measures the distances again. +//! The canvas shows each distance as a dimension from its edge to the hole's centre. OK sends the +//! edges and distances as `solid.hole`'s `references`, so the hole follows its edges when the +//! part changes; Edit Feature picks the edges again where they are now. + +use egui::{Color32, Pos2, Stroke, vec2}; +use serde_json::{Value, json}; +use solidcraft_engine::doc::HoleReference; +use solidcraft_engine::doc::expr::Kind as ValueKind; +use solidcraft_engine::doc::hole_reference::{ReferenceFrame, on_reference_face, reference_frame}; +use solidcraft_engine::geom::Vec3; +use solidcraft_engine::{Sel, Session}; + +use crate::SolveApp; +use crate::dialogs::{Dialog, Kind}; +use crate::selection::{EDGES, SelInput}; +use crate::theme::Tokens; +use crate::viewport::Proj; + +/// The reference edge inputs, after the face input. +pub(crate) const REFERENCES: [&str; 2] = ["Reference 1", "Reference 2"]; +/// Each reference edge's distance row (and its box on the canvas). +pub(crate) const DISTANCES: [&str; 2] = ["Distance 1", "Distance 2"]; + +/// The distances typed for the reference edges, what they were last worked out for, the face's +/// frame for the picked edges, and the distance whose canvas box takes the keyboard next (a +/// newly picked edge's, so a number typed straight after the pick sets it). +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Refs { + pub distance: [String; 2], + seen: Option, + frame: Option, + focus: Option, +} + +/// The place, edges and distances the dialog last had in step. +#[derive(Clone, Debug, PartialEq)] +struct Seen { + place: Vec3, + edges: [Option; 2], + distance: [String; 2], +} + +/// The face's frame (with the reference inputs its lines are for) and what it was found for: the +/// design's revision, the place and the edges. +#[derive(Clone, Debug, PartialEq)] +struct Framed { + revision: u64, + place: Vec3, + edges: [Option; 2], + frame: Option<(ReferenceFrame, Vec)>, +} + +/// The reference edge inputs a Single hole's dialog has after its face input. +pub(crate) fn inputs() -> [SelInput; 2] { + REFERENCES.map(|label| SelInput::new(label, EDGES, false)) +} + +/// Is `d` a Single hole's dialog? +fn single(d: &Dialog) -> bool { + matches!(&d.kind, Kind::Hole { opts, .. } if !opts.multiple) +} + +/// The hole's place: the first face pick (its index in the face input, and the point). +fn place(d: &Dialog) -> Option<(usize, Vec3)> { + d.inputs.first()?.items.iter().enumerate().find_map(|(i, x)| match x { + Sel::Face { point, .. } => Some((i, *point)), + _ => None, + }) +} + +/// A point on each reference edge picked, by input. +fn edges(d: &Dialog) -> [Option; 2] { + REFERENCES.map(|label| { + d.inputs.iter().find(|i| i.label == label).and_then(|i| i.items.first()).and_then(|x| match x { + Sel::Edge { point, .. } => Some(*point), + _ => None, + }) + }) +} + +/// A point `[x, y, z]` of a dialog's stored parameters. +fn vec3(v: &Value) -> Option { + let a = v.as_array()?; + let c = |i: usize| a.get(i).and_then(Value::as_f64).filter(|x| x.is_finite()); + (a.len() == 3).then(|| Some(Vec3::new(c(0)?, c(1)?, c(2)?))).flatten() +} + +/// The way the hole drills at `at`: as it was made (editing), else into the face there. +fn direction(s: &Session, d: &Dialog, at: Vec3) -> Option { + d.extra.get("direction").and_then(vec3).or_else(|| solidcraft_engine::doc::hole_direction_at(&s.world_state(), at)) +} + +/// The face's frame at the place for the picked edges (and which reference inputs they are), found +/// again only when the design, the place or the edges change. +fn frame(s: &Session, d: &mut Dialog) -> Option<(ReferenceFrame, Vec)> { + let (_, at) = place(d)?; + let edges = edges(d); + if edges.iter().all(Option::is_none) { + return None; + } + let Kind::Hole { opts, .. } = &d.kind else { return None }; + if let Some(f) = &opts.refs.frame + && f.revision == s.revision + && f.place == at + && f.edges == edges + { + return f.frame.clone(); + } + let picked: Vec<(usize, Vec3)> = edges.iter().enumerate().filter_map(|(k, e)| e.map(|p| (k, p))).collect(); + let found = direction(s, d, at).and_then(|dir| { + let pts: Vec<(Vec3, Option<&str>)> = picked.iter().map(|(_, p)| (*p, None)).collect(); + reference_frame(&s.world_state(), at, dir, &pts, true).ok().map(|f| (f, picked.iter().map(|(k, _)| *k).collect())) + }); + if let Kind::Hole { opts, .. } = &mut d.kind { + opts.refs.frame = Some(Framed { revision: s.revision, place: at, edges, frame: found.clone() }); + } + found +} + +/// Keep the distances and the hole's place in step: a new place or a new edge is measured, a +/// typed distance moves the place there (when it stays on the face). Run before the dialog's +/// commands are made. +pub(crate) fn sync(s: &Session, d: &mut Dialog) { + if !single(d) { + return; + } + let edges = edges(d); + let Some((i, at)) = place(d) else { + if let Kind::Hole { opts, .. } = &mut d.kind { + opts.refs.seen = None; + } + return; + }; + let framed = frame(s, d); + let Kind::Hole { opts, .. } = &mut d.kind else { return }; + let refs = &mut opts.refs; + let mut to = at; + if let Some((f, picked)) = &framed { + let same = refs.seen.as_ref().filter(|sn| sn.place == at && sn.edges == edges); + match same { + // Typed: the hole goes to the distances. + Some(sn) if sn.distance != refs.distance => { + let values: Option> = + picked.iter().map(|k| refs.distance.get(*k).and_then(|e| s.doc.eval(e, ValueKind::Length).ok())).collect(); + if let Some(c) = values.and_then(|v| f.place(at, &v).ok()).filter(|c| on_reference_face(&s.world_state(), f, *c)) { + to = c; + } + } + Some(_) => {} + // A new place, or a new edge: measured from where the hole is. + None => { + let moved = refs.seen.as_ref().is_none_or(|sn| sn.place != at); + for (k, v) in picked.iter().zip(f.distances(at)) { + let new_edge = refs.seen.as_ref().is_none_or(|sn| sn.edges.get(*k) != edges.get(*k)); + if let Some(slot) = refs.distance.get_mut(*k) + && (moved || new_edge || slot.trim().is_empty()) + { + *slot = crate::canvas::format_len(v.max(0.0)); + } + if new_edge && edges.get(*k).is_some_and(Option::is_some) { + refs.focus = Some(*k); + } + } + } + } + } + refs.seen = Some(Seen { place: to, edges, distance: refs.distance.clone() }); + if to != at + && let Some(Sel::Face { point, .. }) = d.inputs.first_mut().and_then(|inp| inp.items.get_mut(i)) + { + *point = to; + } +} + +/// The Single hole's selection rows, each reference edge with its distance on the row below it +/// once it is picked. Whether Enter was pressed in a distance. +pub(crate) fn input_rows(d: &mut Dialog, ui: &mut egui::Ui, s: &Session) -> bool { + let mut enter = false; + for i in 0..d.inputs.len() { + crate::dialogs::input_rows_range(d, ui, s, i..i + 1); + let Some(k) = d.inputs.get(i).filter(|inp| !inp.items.is_empty()).and_then(|inp| REFERENCES.iter().position(|l| *l == inp.label)) else { + continue; + }; + if let Kind::Hole { opts, .. } = &mut d.kind + && let (Some(label), Some(value)) = (DISTANCES.get(k), opts.refs.distance.get_mut(k)) + { + enter |= crate::ui_kit::expr_row(ui, label, value); + } + } + sync(s, d); + enter +} + +/// The `references` OK sends: each picked edge (a point on it) with its distance. +pub(crate) fn params(d: &Dialog) -> Vec { + let Kind::Hole { opts, .. } = &d.kind else { return Vec::new() }; + if opts.multiple { + return Vec::new(); + } + edges(d) + .iter() + .zip(&opts.refs.distance) + .filter_map(|(e, distance)| e.map(|p| json!({"edge": [p.x, p.y, p.z], "distance": distance.trim()}))) + .collect() +} + +/// Editing a hole with reference edges: the edges picked again where they are now, their +/// distances, and the place where those distances put the hole now. +pub(crate) fn restore(s: &Session, d: &mut Dialog, references: &[HoleReference], names: &[String]) { + if references.is_empty() { + return; + } + let Some((i, at)) = place(d) else { return }; + let st = s.world_state(); + let edges: Vec<(Vec3, Option<&str>)> = references.iter().enumerate().map(|(k, r)| (r.edge.0, names.get(k).map(String::as_str))).collect(); + let found = direction(s, d, at).and_then(|dir| reference_frame(&st, at, dir, &edges, false).ok()); + let mesh = found.as_ref().and_then(|f| st.body(&f.body)).map(|b| b.mesh()); + for (k, r) in references.iter().enumerate().take(REFERENCES.len()) { + // Where the edge is now, else where it was picked. + let sel = found.as_ref().zip(mesh.as_ref()).and_then(|(f, m)| { + let index = *f.edges.get(k)?; + let point = crate::selection::polyline_mid(m.edges.get(index)?); + Some(Sel::Edge { body: f.body.clone(), index, point }) + }); + let sel = sel.or_else(|| nearest_edge(s, at, r.edge.0)); + if let (Some(label), Some(sel)) = (REFERENCES.get(k), sel) + && let Some(inp) = d.inputs.iter_mut().find(|inp| inp.label == *label) + { + inp.items = vec![sel]; + } + if let Kind::Hole { opts, .. } = &mut d.kind + && let Some(slot) = opts.refs.distance.get_mut(k) + { + *slot = r.distance.to_string(); + } + } + // The hole where its distances put it now (the part may have changed since it was placed). + let mut to = at; + if let Some(f) = &found + && let Kind::Hole { opts, .. } = &d.kind + { + let values: Option> = opts.refs.distance.iter().take(f.lines.len()).map(|e| s.doc.eval(e, ValueKind::Length).ok()).collect(); + if let Some(c) = values.and_then(|v| f.place(at, &v).ok()).filter(|c| on_reference_face(&st, f, *c)) { + to = c; + } + } + if let Some(Sel::Face { point, .. }) = d.inputs.first_mut().and_then(|inp| inp.items.get_mut(i)) { + *point = to; + } + let edges = self::edges(d); + if let Kind::Hole { opts, .. } = &mut d.kind { + opts.refs.seen = Some(Seen { place: to, edges, distance: opts.refs.distance.clone() }); + } +} + +/// The edge of the body under `at` nearest `p`, picked at `p` (a reference edge that is not +/// found as it was made: OK then reports why). +fn nearest_edge(s: &Session, at: Vec3, p: Vec3) -> Option { + let Some(Sel::Face { body, .. }) = crate::dialogs::face_sel(s, at) else { return None }; + let st = s.world_state(); + let m = st.body(&body)?.mesh(); + let to = |e: &Vec| e.windows(2).map(|w| p.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min); + let index = m.edges.iter().enumerate().map(|(i, e)| (to(e), i)).filter(|(d, _)| d.is_finite()).min_by(|a, b| a.0.total_cmp(&b.0))?.1; + Some(Sel::Edge { body, index, point: p }) +} + +/// The reference distances on the canvas: a dimension from each edge to the hole's centre, and a +/// box beside it to type the distance in. Whether a box took the keyboard (a newly picked edge's), +/// which the dialog's main value then leaves to it. +pub(crate) fn canvas(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj: &Proj, d: &mut Dialog) -> bool { + if !single(d) { + return false; + } + let Some((_, at)) = place(d) else { return false }; + let Some((f, picked)) = frame(&app.session, d) else { return false }; + let mut took = false; + let t = Tokens::get(); + let px = 2.0 * app.cam.half_height() / f64::from(proj.rect.height().max(1.0)); + let centre = f.onto_plane(at); + for (line, k) in f.lines.iter().zip(&picked) { + let foot = line.foot(centre); + let (Some(a), Some(b)) = (proj.to_screen(foot), proj.to_screen(centre)) else { continue }; + // The reference edge's line on either side of where the dimension leaves it. + let reach = line.along * (14.0 * px); + if let (Some(e0), Some(e1)) = (proj.to_screen(foot - reach), proj.to_screen(foot + reach)) { + painter.line_segment([e0, e1], Stroke::new(1.2, t.dimension)); + } + dimension(painter, a, b, t.dimension); + let (Some(label), Kind::Hole { opts, .. }) = (DISTANCES.get(*k), &mut d.kind) else { continue }; + let focus = opts.refs.focus == Some(*k); + if focus { + opts.refs.focus = None; + took = true; + } + let Some(value) = opts.refs.distance.get_mut(*k) else { continue }; + let at = box_beyond(a, b); + let r = crate::canvas::value_box_in( + ui, + (egui::Id::new(("sc_hole_ref_area", *k)), egui::Id::new(("sc_hole_ref", *k))), + label, + value, + at, + focus, + false, + ); + if let Some(r) = r { + crate::scenario::publish_handle(&format!("canvas:{label}"), r.center()); + } + } + took +} + +/// Where a distance's box goes: just past its edge (at `a`, the hole's centre at `b`), on the side +/// away from the hole, so it stays clear of the hole's own value box at its centre. The box's side +/// toward the edge sits there. +fn box_beyond(a: Pos2, b: Pos2) -> (Pos2, egui::Align2) { + const GAP: f32 = 10.0; + let v = a - b; + let out = if v.length() < 1.0 { vec2(1.0, 0.0) } else { v / v.length() }; + if out.x.abs() >= out.y.abs() { + if out.x > 0.0 { (a + vec2(GAP, 0.0), egui::Align2::LEFT_CENTER) } else { (a - vec2(GAP, 0.0), egui::Align2::RIGHT_CENTER) } + } else if out.y > 0.0 { + (a + vec2(0.0, GAP), egui::Align2::CENTER_TOP) + } else { + (a - vec2(0.0, GAP), egui::Align2::CENTER_BOTTOM) + } +} + +/// A dimension line from `a` to `b`, an arrowhead at each end. +fn dimension(painter: &egui::Painter, a: Pos2, b: Pos2, col: Color32) { + let v = b - a; + let l = v.length(); + if l < 1.0 { + return; + } + let u = v / l; + let n = vec2(-u.y, u.x); + painter.line_segment([a, b], Stroke::new(1.2, col)); + let head = 8.0f32.min(l * 0.4); + for (tip, out) in [(a, -u), (b, u)] { + painter.add(egui::Shape::convex_polygon( + vec![tip, tip - out * head + n * head * 0.35, tip - out * head - n * head * 0.35], + col, + Stroke::NONE, + )); + } +} diff --git a/crates/ui-egui/src/hole_refs_ui_tests.rs b/crates/ui-egui/src/hole_refs_ui_tests.rs new file mode 100644 index 000000000..ab170e1b2 --- /dev/null +++ b/crates/ui-egui/src/hole_refs_ui_tests.rs @@ -0,0 +1,162 @@ +//! A Single hole placed by distances from reference edges, through the window (#37): pick the +//! face, pick two edges (each distance is measured from the pick), type the distances (one in +//! the dialog, one in its box on the canvas), OK. The hole sits at those distances; Edit Feature +//! picks the edges again with their distances, and moving the hole's place measures them again. + +use serde_json::json; +use solidcraft_engine::Sel; +use solidcraft_engine::doc::FeatureKind; +use solidcraft_engine::geom::Vec3; + +use crate::dialogs::Kind; +use crate::scenario::Harness; + +/// Where a world point is on screen. +fn screen(h: &mut Harness, p: Vec3) -> [f64; 2] { + h.at(&json!({"world": [p.x, p.y, p.z]})).unwrap() +} + +/// A 50 × 40 × 10 plate from the origin, seen from the top. +fn plate() -> Harness { + let mut h = Harness::new(); + h.app.ui.show_origin = false; + h.app.run("solid.box", json!({"length": 50, "width": 40, "height": 10, "corner": [0, 0, 0]})).unwrap(); + h.step(&json!({"call": "ui.view", "params": {"view": "top"}})).unwrap(); + h.settle(); + h +} + +/// The open Hole dialog's reference distances. +fn distances(h: &Harness) -> [String; 2] { + match h.app.dialog.as_ref().map(|d| &d.kind) { + Some(Kind::Hole { opts, .. }) => opts.refs.distance.clone(), + _ => panic!("the hole dialog is open"), + } +} + +/// Where the open dialog places the hole (its face pick). +fn place(h: &Harness) -> Vec3 { + match h.app.dialog.as_ref().and_then(|d| d.inputs.first()).and_then(|i| i.items.first()) { + Some(Sel::Face { point, .. }) => *point, + other => panic!("a face place, not {other:?}"), + } +} + +/// The edge picked into the open dialog's input `label`. +fn picked_edge(h: &Harness, label: &str) -> Option { + let d = h.app.dialog.as_ref()?; + match d.inputs.iter().find(|i| i.label == label)?.items.first()? { + Sel::Edge { point, .. } => Some(*point), + _ => None, + } +} + +/// Replace the text of the field at `handle` with `text`. +fn type_into(h: &mut Harness, handle: &str, text: &str) { + h.step(&json!({"click": {"handle": handle}})).unwrap(); + h.step(&json!({"key": "A", "cmd": true})).unwrap(); + h.step(&json!({"text": text})).unwrap(); + h.frames(2); +} + +/// Whether the model holds material at `p`. +fn solid_at(h: &Harness, p: Vec3) -> bool { + h.app.session.model.state().bodies.iter().any(|b| b.body.contains(p)) +} + +#[test] +fn a_hole_is_placed_by_its_distances_from_two_edges() { + let mut h = plate(); + h.step(&json!({"start": "solid.hole"})).unwrap(); + let at = screen(&mut h, Vec3::new(30.0, 25.0, 10.0)); + h.step(&json!({"click": at})).unwrap(); + assert!(place(&h).dist(Vec3::new(30.0, 25.0, 10.0)) < 0.5, "the face is picked where clicked: {:?}", place(&h)); + let picked = place(&h); + // The reference inputs come after the face; picking an edge measures its distance from the + // pick, and the second input takes the next edge. + h.step(&json!({"click": {"handle": "dialog:Reference 1"}})).unwrap(); + let left = screen(&mut h, Vec3::new(0.0, 20.0, 10.0)); + h.step(&json!({"click": left})).unwrap(); + let front = screen(&mut h, Vec3::new(25.0, 0.0, 10.0)); + h.step(&json!({"click": front})).unwrap(); + h.frames(2); + assert!(picked_edge(&h, "Reference 1").is_some_and(|p| p.x.abs() < 1e-6), "the left edge is Reference 1: {:?}", picked_edge(&h, "Reference 1")); + assert!(picked_edge(&h, "Reference 2").is_some_and(|p| p.y.abs() < 1e-6), "the front edge is Reference 2: {:?}", picked_edge(&h, "Reference 2")); + let measured = distances(&h); + let value = |s: &str| h.app.session.doc.eval(s, solidcraft_engine::doc::expr::Kind::Length).unwrap(); + assert!((value(&measured[0]) - picked.x).abs() < 1e-3 && (value(&measured[1]) - picked.y).abs() < 1e-3, "{measured:?} from {picked:?}"); + // The distances show on the canvas, each with a box to type in. + assert!(h.at(&json!({"handle": "canvas:Distance 1"})).is_ok() && h.at(&json!({"handle": "canvas:Distance 2"})).is_ok()); + // Typed in the dialog and on the canvas: the hole goes there. + type_into(&mut h, "dialog:Distance 1", "10 mm"); + type_into(&mut h, "canvas:Distance 2", "12 mm"); + assert_eq!(distances(&h), ["10 mm", "12 mm"]); + assert!(place(&h).dist(Vec3::new(10.0, 12.0, 10.0)) < 1e-6, "the hole moved to its distances: {:?}", place(&h)); + h.step(&json!({"widget": "OK"})).unwrap(); + assert!(h.app.dialog.is_none(), "OK closed the dialog: {:?}", h.app.dialog.as_ref().map(|d| &d.error)); + let f = h.app.session.doc.features.last().unwrap().clone(); + let FeatureKind::Hole { position, references, .. } = &f.kind else { panic!("the last feature is a hole: {}", f.kind.type_name()) }; + assert!(position.0.dist(Vec3::new(10.0, 12.0, 10.0)) < 1e-6, "{position:?}"); + assert_eq!(references.iter().map(|r| r.distance.to_string()).collect::>(), ["10 mm", "12 mm"]); + assert!(h.app.session.model.result(f.id).is_some_and(|r| r.error.is_none())); + assert!( + !solid_at(&h, Vec3::new(10.0, 12.0, 8.0)) && solid_at(&h, Vec3::new(30.0, 25.0, 8.0)), + "drilled at (10, 12), not where the face was picked" + ); + + // Edit Feature: the edges picked again with their distances, the hole where they put it. + h.step(&json!({"call": "ui.editFeature", "params": {"feature": f.id}})).unwrap(); + h.frames(4); + assert!(picked_edge(&h, "Reference 1").is_some_and(|p| p.x.abs() < 1e-6), "{:?}", picked_edge(&h, "Reference 1")); + assert!(picked_edge(&h, "Reference 2").is_some_and(|p| p.y.abs() < 1e-6), "{:?}", picked_edge(&h, "Reference 2")); + assert_eq!(distances(&h), ["10 mm", "12 mm"]); + assert!(place(&h).dist(Vec3::new(10.0, 12.0, 10.0)) < 1e-6, "{:?}", place(&h)); + // The hole moved on its face (a new pick, or its handle dragged): the distances follow. + if let Some(Sel::Face { point, .. }) = h.app.dialog.as_mut().and_then(|d| d.inputs.first_mut()).and_then(|i| i.items.first_mut()) { + *point = Vec3::new(20.0, 30.0, 10.0); + } + h.frames(2); + assert_eq!(distances(&h), ["20 mm", "30 mm"]); + h.step(&json!({"widget": "OK"})).unwrap(); + assert!(h.app.dialog.is_none(), "{:?}", h.app.dialog.as_ref().map(|d| &d.error)); + assert!(!solid_at(&h, Vec3::new(20.0, 30.0, 8.0)) && solid_at(&h, Vec3::new(10.0, 12.0, 8.0)), "the edit moved the hole to (20, 30)"); +} + +/// Reference edges place one hole: with places on two faces, OK says to pick one. +#[test] +fn reference_edges_place_one_hole() { + let mut h = plate(); + h.step(&json!({"start": "solid.hole"})).unwrap(); + let at = screen(&mut h, Vec3::new(30.0, 25.0, 10.0)); + h.step(&json!({"click": at})).unwrap(); + // A second hole on another face (the bottom), as a pick there would place it. + let d = h.app.dialog.as_mut().unwrap(); + let Some(Sel::Face { body, index, .. }) = d.inputs[0].items.first().cloned() else { panic!("a face place") }; + d.inputs[0].items.push(Sel::Face { body, index: index + 1, point: Vec3::new(40.0, 10.0, 0.0) }); + h.step(&json!({"click": {"handle": "dialog:Reference 1"}})).unwrap(); + let left = screen(&mut h, Vec3::new(0.0, 20.0, 10.0)); + h.step(&json!({"click": left})).unwrap(); + h.frames(2); + let d = h.app.dialog.as_ref().unwrap(); + let err = crate::dialogs::apply_commands(&h.app, d).unwrap_err(); + assert!(err.contains("one hole"), "{err}"); +} + +/// A number typed straight after an edge pick is that edge's distance, not the diameter. +#[test] +fn a_number_typed_after_an_edge_pick_sets_its_distance() { + let mut h = plate(); + h.step(&json!({"start": "solid.hole"})).unwrap(); + let at = screen(&mut h, Vec3::new(30.0, 25.0, 10.0)); + h.step(&json!({"click": at})).unwrap(); + h.step(&json!({"click": {"handle": "dialog:Reference 1"}})).unwrap(); + let left = screen(&mut h, Vec3::new(0.0, 20.0, 10.0)); + h.step(&json!({"click": left})).unwrap(); + h.frames(2); + h.step(&json!({"text": "7 mm"})).unwrap(); + h.frames(2); + assert_eq!(distances(&h)[0], "7 mm"); + assert!((place(&h).x - 7.0).abs() < 1e-6, "the hole is 7 mm from the left edge: {:?}", place(&h)); + let Some(Kind::Hole { diameter, .. }) = h.app.dialog.as_ref().map(|d| &d.kind) else { panic!("the hole dialog") }; + assert_eq!(diameter, "5 mm", "the diameter is left as it was"); +} diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index c8eec9b3f..0ceb1b21b 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -69,6 +69,9 @@ pub(crate) mod hole_place; mod hole_place_ui_tests; #[cfg(test)] mod hole_placement_ui_tests; +pub(crate) mod hole_refs; +#[cfg(test)] +mod hole_refs_ui_tests; pub mod home; pub mod i18n; #[cfg(test)] diff --git a/crates/ui-egui/src/preselect_tests.rs b/crates/ui-egui/src/preselect_tests.rs index 878ff1fcb..e40d1046f 100644 --- a/crates/ui-egui/src/preselect_tests.rs +++ b/crates/ui-egui/src/preselect_tests.rs @@ -1481,8 +1481,9 @@ fn newer_options_reach_their_commands() { app.dialog = None; let top = face(&app, Vec3::new(20.0, 15.0, 20.0)); let mut d = start(&mut app, vec![top], "solid.hole"); - d.inputs.push(crate::selection::SelInput::new("To Object", crate::selection::FACES | crate::selection::VERTICES, false)); - d.inputs[1].items = vec![face(&app, Vec3::new(20.0, 15.0, 0.0))]; + let mut to = crate::selection::SelInput::new("To Object", crate::selection::FACES | crate::selection::VERTICES, false); + to.items = vec![face(&app, Vec3::new(20.0, 15.0, 0.0))]; + d.inputs.push(to); let p = apply_commands(&app, &d).unwrap().remove(0).1; assert!(p["to"].is_array() && p.get("depth").is_none(), "{p}"); } diff --git a/docs/book/src/guide/features.md b/docs/book/src/guide/features.md index fe2cc43aa..1521f9f35 100644 --- a/docs/book/src/guide/features.md +++ b/docs/book/src/guide/features.md @@ -7,7 +7,7 @@ it. | Panel | Features | |---|---| -| Create | extrude (one side, two sides, symmetric, taper, start offset, to a distance or through all; new body, join, cut, intersect; thin walls along curves), revolve, sweep, loft, box, cylinder, sphere, torus, coil, pipe, rib, web, emboss, hole (simple, counterbore, countersink, tapped; on faces or at sketch points), thread, rectangular/circular/path patterns, mirror | +| Create | extrude (one side, two sides, symmetric, taper, start offset, to a distance or through all; new body, join, cut, intersect; thin walls along curves), revolve, sweep, loft, box, cylinder, sphere, torus, coil, pipe, rib, web, emboss, hole (simple, counterbore, countersink, tapped; on faces, at distances from edges, or at sketch points), thread, rectangular/circular/path patterns, mirror | | Modify | press pull, fillet, chamfer, shell, draft, scale, combine, split body, offset face, replace face, move/copy, align, remove | | Construct | offset plane, plane at angle, plane along path | | Inspect | measure, section analysis, interference, compare bodies, curvature comb and map, zebra, draft, minimum radius, isocurves, centre of mass | @@ -96,6 +96,15 @@ unsupported. A new Emboss without an explicit face infers a unique eligible supp select the face when the target is ambiguous. Older saved features without a face retain their planar placement. +A **Hole** with **Single** placement can also sit at distances from up to two straight edges of +its face. After picking the face, click **Reference 1** and pick an edge, then pick a second one +into **Reference 2**. Each edge gets a **Distance** row, measured from where you picked; the +canvas shows each one as a dimension from the edge to the hole's centre, with a box beside it. +Type a distance in either place and the hole moves so its centre is that far from the edge, +measured in the face's plane. Moving the hole measures the distances again. The hole keeps its +distances when the part changes: it follows its edges, and the distances are parameters like its +diameter. + A **Hole** with **Single** placement drills where you pick a planar face. A pick on or near a point of a shown sketch that lies on that face, such as a circle's centre, places the hole exactly at that point, as **Multiple** placement picks it; **Select Other** (press and hold) also @@ -224,7 +233,7 @@ still be added through `set`. The fields of the common features: | Chamfer | `distance`, `distance2` or `angle`, `flip`, `edges`, `body` | | Box | `length`, `width`, `height`, `corner`, `operation` | | Cylinder | `radius`, `height`, `base`, `axis`, `operation` | -| Hole | `diameter`, `depth`, `position`, `direction`, `hole` (simple, drilled, counterbore, countersink), `thread`, `to` | +| Hole | `diameter`, `depth`, `position`, `direction`, `hole` (simple, drilled, counterbore, countersink), `thread`, `to`, `references` (an `edge` point and a `distance` each) | | Shell | `thickness`, `faces`, `direction`, `body`, `tangent_chain` | | Draft | `angle`, `faces`, `neutral`, `pull`, `body` | | Offset face | `distance`, `faces`, `body` | diff --git a/skills/solidcraft-modeling/reference.md b/skills/solidcraft-modeling/reference.md index 22972dabb..c9435e0b1 100644 --- a/skills/solidcraft-modeling/reference.md +++ b/skills/solidcraft-modeling/reference.md @@ -79,7 +79,7 @@ Distances are unsigned. Draw the geometry on the correct side first, and the dim | `sketch.slot.overall` / `sketch.slot.center_to_center` | `p0`, `p1` (overall ends / arc centres), `width` | Ids and dof are in the "Ids" section above. | | `solid.fillet` / `solid.chamfer` | `edges:[[x,y,z]]`, `radius` / `distance` | The pick snaps to the **nearest** edge, with no distance limit and no error, so check that the face count changed. One pick takes the whole tangent chain: a rounded rim needs 1 point, not 8. | | `solid.shell` | `faces:[[x,y,z]]`, `thickness` | A point on each face to remove, or its name from `body_topology`. Fillet first, except an edge of a removed face (see Order in `SKILL.md`). | -| `solid.hole` | `position:[x,y,z]` on a face (numbers or length expressions such as `["40", "width/2", "t"]`, which the hole then follows) + `diameter`, or `sketch` (+ `points`) | `clearance:"M3"`. `depth` defaults to through all. `type` is one of simple/drilled/counterbore/countersink. A `countersink` needs `cs_diameter` and `cs_angle`; a `counterbore` needs `cb_diameter` and `cb_depth`. `position` is a fixed point. | +| `solid.hole` | `position:[x,y,z]` on a face (numbers or length expressions such as `["40", "width/2", "t"]`, which the hole then follows) + `diameter`, or `sketch` (+ `points`) | `clearance:"M3"`. `depth` defaults to through all. `type` is one of simple/drilled/counterbore/countersink. A `countersink` needs `cs_diameter` and `cs_angle`; a `counterbore` needs `cb_diameter` and `cb_depth`. `position` is a fixed point; to tie it to the part, add `references: [{edge:[x,y,z], distance}]` (up to two straight edges of the face): the centre then sits at those distances from the edges and follows them. | | `solid.pattern.rectangular` | `features`, `dir1`, `count1`, `spacing1` (+ `dir2`, `count2`, `spacing2`) | Spacing takes expressions and follows parameters. | | `solid.pattern.circular` | `features`, `axis` (`"Z"` or `{origin, dir}`), `count` | `angle` defaults to 360 deg. A full pattern keeps the COM on the axis, so check its radius with a top-view screenshot. | | `solid.mirror` | `features:[names]` or `bodies:[names]`, `plane` (`XY`/`XZ`/`YZ`, a construction plane, or `{origin, normal}` whose origin may use length expressions) | Follows parameters. A mirror or pattern feature cannot be listed in `features` of another mirror or pattern, but `bodies` can mirror the body it made. The mirror is a new body with the first free default name: `Body1`, `Body2` from `features`, and `Side (2)`, `Side (3)` from `bodies:["Side"]`. Read the name from `created_bodies`. With `combine:true`, a mirror that overlaps the original joins it and makes no new body. `features` copies only the features listed, so a later cut is left out unless you list it too. `bodies` copies the finished body. To name the mirror, use `body.rename {"body":"Side (2)","name":"Side_L"}`. The new name stays when parameters change. |