Skip to content

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

Cylinder: place by distances from reference edges, like Hole (#6380) (#6381)

tr1pp498abb249c447
diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs
index 1a9fcd0d8c..bf6266ad5a 100644
--- a/crates/doc/src/document.rs
+++ b/crates/doc/src/document.rs
@@ -693,6 +693,11 @@ pub enum FeatureKind {
height: Expr,
#[serde(default)]
operation: Operation,
+ /// Up to two straight edges of the face it stands on (#6380), as a Single hole's
+ /// references: the base centre sits at each one's distance from its edge, in the face's
+ /// plane, and follows the edges when the part changes. `base` keeps where it was placed.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ references: Vec<HoleReference>,
},
Sphere {
#[serde(with = "point_expr")]
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index 1593907692..fab66f79c1 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -4457,17 +4457,24 @@ fn single_hole_position(
Ok(ss.plane.to_world(p.pos))
}
-/// A hole's reference edges (#37); none for any other feature.
+/// A hole's (#37) or a cylinder's (#6380) reference edges; none for any other feature.
fn hole_references(f: &Feature) -> &[crate::HoleReference] {
match &f.kind {
- FeatureKind::Hole { references, .. } => references,
+ FeatureKind::Hole { references, .. } | FeatureKind::Cylinder { 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`.
+/// Where a cylinder stands: its base, or with reference edges (#6380) at their distances in the
+/// plane of the flat face at its base, square to its axis.
+fn cylinder_base(vals: &BTreeMap<String, Value>, st: &ModelState, f: &Feature, base: &crate::PointExpr, axis: Vec3) -> Result<Vec3> {
+ let at = point(vals, base)?;
+ with_references(vals, st, f, at, -axis)
+}
+
+/// Where a Single hole (or a cylinder) with reference edges (#37) is placed: 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 feature without reference edges stays at `at`.
fn with_references(vals: &BTreeMap<String, Value>, st: &ModelState, f: &Feature, at: Vec3, dir: Vec3) -> Result<Vec3> {
let references = hole_references(f);
if references.is_empty() {
@@ -5774,7 +5781,7 @@ fn feature_tools_with_constructor(
Ok(vec![crate::lineage::box_tool(kernel::box_solid(corner, corner + s)?)])
}
FeatureKind::Cylinder { base, axis, radius, height, .. } => Ok(vec![crate::lineage::cylinder_tool(kernel::cylinder(
- point(vals, base)?,
+ cylinder_base(vals, st, f, base, axis.0)?,
axis.0,
val(vals, radius, Kind::Length)?,
val(vals, height, Kind::Length)?,
@@ -7676,8 +7683,9 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
}
apply_traced(doc, st, f, tools, *operation, &[])
}
- FeatureKind::Cylinder { base, axis, radius, height, operation } => {
- let (base, radius, height) = (point(vals, base)?, val(vals, radius, Kind::Length)?, val(vals, height, Kind::Length)?);
+ FeatureKind::Cylinder { base, axis, radius, height, operation, .. } => {
+ let base = cylinder_base(vals, st, f, base, axis.0)?;
+ let (radius, height) = (val(vals, radius, Kind::Length)?, val(vals, height, Kind::Length)?);
let b = kernel::cylinder(base, axis.0, radius, height)?;
let b = if matches!(operation, Operation::NewBody | Operation::Join) { b.with_cylinder_certificate(f.id)? } else { b };
let prism = more::PrimitivePrism::Cylinder { base, axis: axis.0, radius, height };
diff --git a/crates/doc/src/eval_cost_tests.rs b/crates/doc/src/eval_cost_tests.rs
index d4a82fe4b1..c2af067f9e 100644
--- a/crates/doc/src/eval_cost_tests.rs
+++ b/crates/doc/src/eval_cost_tests.rs
@@ -59,6 +59,7 @@ fn joint_face_measurements_are_shared_across_motion_samples_and_snap_kinds() {
radius: "2".into(),
height: "10".into(),
operation: Operation::NewBody,
+ references: Vec::new(),
},
None,
)
@@ -433,6 +434,7 @@ fn a_body_is_measured_once_while_it_stays_the_same() {
radius: "2".into(),
height: "10".into(),
operation: Operation::NewBody,
+ references: Vec::new(),
};
doc.add_feature(kind, None).unwrap();
};
diff --git a/crates/doc/src/feature_walk_tests/fixtures.rs b/crates/doc/src/feature_walk_tests/fixtures.rs
index 3d52ce0286..27037f33e2 100644
--- a/crates/doc/src/feature_walk_tests/fixtures.rs
+++ b/crates/doc/src/feature_walk_tests/fixtures.rs
@@ -56,6 +56,11 @@ pub(super) fn fixtures() -> Vec<(&'static str, Value)> {
),
("box", json!({"type": "box", "corner": ["box.x", "box.y", "box.z"], "length": "box.length", "width": "box.width", "height": "box.height"})),
("cylinder", json!({"type": "cylinder", "base": ["cyl.x", "cyl.y", "cyl.z"], "radius": "cyl.radius", "height": "cyl.height"})),
+ (
+ "cylinder_references",
+ json!({"type": "cylinder", "base": o, "radius": "cyl.radius", "height": "cyl.height",
+ "references": [{"edge": o, "distance": "cyl.reference1"}, {"edge": o, "distance": "cyl.reference2"}]}),
+ ),
("sphere", json!({"type": "sphere", "center": ["sph.x", "sph.y", "sph.z"], "radius": "sph.radius"})),
("torus", json!({"type": "torus", "center": ["tor.x", "tor.y", "tor.z"], "major": "tor.major", "minor": "tor.minor"})),
(
@@ -286,6 +291,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)}),
+ "cylinder_references" => {
+ json!({"references": [{"edge": p(11.0), "distance": "cyl.reference1"}, {"edge": p(12.0), "distance": "cyl.reference2"}]})
+ }
"hole_references" => {
json!({"references": [{"edge": p(11.0), "distance": "hole.reference1"}, {"edge": p(12.0), "distance": "hole.reference2"}]})
}
diff --git a/crates/doc/src/feature_walk_tests/golden_exprs.txt b/crates/doc/src/feature_walk_tests/golden_exprs.txt
index 43da6a37f5..fc766b6a53 100644
--- a/crates/doc/src/feature_walk_tests/golden_exprs.txt
+++ b/crates/doc/src/feature_walk_tests/golden_exprs.txt
@@ -73,6 +73,13 @@ cylinder
Radius = cyl.radius (Length)
Height = cyl.height (Length)
expressions: cyl.radius, cyl.height, cyl.x, cyl.y, cyl.z
+cylinder_references
+ inputs:
+ Radius = cyl.radius (Length)
+ Height = cyl.height (Length)
+ Reference distance = cyl.reference1 (Length)
+ Reference distance = cyl.reference2 (Length)
+ expressions: cyl.radius, cyl.height, cyl.reference1, cyl.reference2, 0, 0, 0
sphere
inputs:
Radius = sph.radius (Length)
diff --git a/crates/doc/src/feature_walk_tests/golden_geometry.txt b/crates/doc/src/feature_walk_tests/golden_geometry.txt
index 30add0647a..ce58eadb27 100644
--- a/crates/doc/src/feature_walk_tests/golden_geometry.txt
+++ b/crates/doc/src/feature_walk_tests/golden_geometry.txt
@@ -30,6 +30,9 @@ box
cylinder
moves: axis[0], axis[2], base[0], base[1], base[2]
placement: cyl.x, cyl.y, cyl.z
+cylinder_references
+ moves: axis[0], axis[2], base[0], base[1], base[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]
+ placement: 0, 0, 0
sphere
moves: center[0], center[1], center[2]
placement: sph.x, sph.y, sph.z
diff --git a/crates/doc/src/feature_walk_tests/golden_refs.txt b/crates/doc/src/feature_walk_tests/golden_refs.txt
index 48bc04e7ff..303007b9d2 100644
--- a/crates/doc/src/feature_walk_tests/golden_refs.txt
+++ b/crates/doc/src/feature_walk_tests/golden_refs.txt
@@ -29,6 +29,7 @@ chamfer
remap_bodies: body
box
cylinder
+cylinder_references
sphere
torus
cone
diff --git a/crates/doc/src/format/pending/cylinder-reference-edges.rs b/crates/doc/src/format/pending/cylinder-reference-edges.rs
new file mode 100644
index 0000000000..de0756ad49
--- /dev/null
+++ b/crates/doc/src/format/pending/cylinder-reference-edges.rs
@@ -0,0 +1,5 @@
+//! A Cylinder can be placed by distances from up to two straight edges of the face it stands on
+//! (`references`: each `{"edge": [x, y, z], "distance": "…"}`, the edges' persistent names in the
+//! feature's `edge_names`, #6380), as a Single hole is: its base centre sits where those
+//! distances hold, measured in the face's plane, and follows the edges when the part changes.
+//! Older designs need no transformation: a cylinder without `references` stays at its `base`.
diff --git a/crates/doc/src/hole_reference.rs b/crates/doc/src/hole_reference.rs
index 187a1971f7..9241104f10 100644
--- a/crates/doc/src/hole_reference.rs
+++ b/crates/doc/src/hole_reference.rs
@@ -152,6 +152,14 @@ pub fn reference_edge_names(st: &ModelState, at: Vec3, edges: &[Vec3]) -> Vec<St
}
}
+/// The persistent names of a cylinder's reference edges (#6380), on the body it stands on at
+/// `base` (its coordinates are numbers when it has reference edges).
+pub fn cylinder_edge_names(st: &ModelState, base: &crate::PointExpr, references: &[crate::HoleReference]) -> Vec<String> {
+ let [x, y, z] = base.clone().map(|c| c.parse::<f64>().unwrap_or(0.0));
+ let edges: Vec<Vec3> = references.iter().map(|r| r.edge.0).collect();
+ reference_edge_names(st, Vec3::new(x, y, z), &edges)
+}
+
/// The (non-mesh) body whose surface is nearest `p`.
fn body_at(st: &ModelState, p: Vec3) -> Option<&ModelBody> {
st.bodies
diff --git a/crates/doc/src/placement_reuse.rs b/crates/doc/src/placement_reuse.rs
index 865451ca32..af5a3f10e6 100644
--- a/crates/doc/src/placement_reuse.rs
+++ b/crates/doc/src/placement_reuse.rs
@@ -70,8 +70,10 @@ pub(super) fn local_geometry(f: &Feature, components: &std::collections::HashMap
return false;
}
match &f.kind {
+ // A cylinder placed by reference edges follows the body it stands on.
+ FeatureKind::Cylinder { references, .. } if !references.is_empty() => false,
FeatureKind::Box { corner: _, length: _, width: _, height: _, operation: Operation::NewBody }
- | FeatureKind::Cylinder { base: _, axis: _, radius: _, height: _, operation: Operation::NewBody }
+ | FeatureKind::Cylinder { base: _, axis: _, radius: _, height: _, operation: Operation::NewBody, references: _ }
| FeatureKind::Sphere { center: _, radius: _, operation: Operation::NewBody }
| FeatureKind::Torus { center: _, major: _, minor: _, operation: Operation::NewBody }
| FeatureKind::Import { file: _, step: _, components: _, skip: _ }
diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rs
index 9f338af0c5..556179d96d 100644
--- a/crates/doc/src/tests.rs
+++ b/crates/doc/src/tests.rs
@@ -436,6 +436,7 @@ fn primitives_and_combine() {
radius: "2".into(),
height: "20".into(),
operation: Operation::NewBody,
+ references: Vec::new(),
},
None,
)
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index 43eafdc343..518e6944f9 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -1143,6 +1143,13 @@ fn edit_feature(s: &mut Session, p: &Value) -> Result<Value> {
nf.edge_names = solidcraft_doc::hole_reference::reference_edge_names(&s.model.state_before(id), position.0, &edges(a));
}
}
+ // New reference edges for a cylinder (#6380): likewise.
+ if let (FeatureKind::Cylinder { references: a, base, .. }, FeatureKind::Cylinder { references: b, .. }) = (&nf.kind, &f.kind) {
+ let edges = |r: &[solidcraft_doc::HoleReference]| r.iter().map(|x| x.edge.0).collect::<Vec<_>>();
+ if edges(a) != edges(b) {
+ nf.edge_names = solidcraft_doc::hole_reference::cylinder_edge_names(&s.model.state_before(id), base, 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 7ff7c1e154..dd52429e10 100644
--- a/crates/engine/src/cmd/features.rs
+++ b/crates/engine/src/cmd/features.rs
@@ -55,7 +55,7 @@ pub static COMMANDS: &[CommandSpec] = &[
.icon("cylinder")
.contract(&CYLINDER_CONTRACT)
.output(output_schema_for::<FeatureResult>)
- .params("radius | diameter, height: expr; base?: [x,y,z] (centre of the bottom: numbers in mm or length expressions; default: the origin); axis?: X|Y|Z|[x,y,z] (default Z); operation?, targets?: [body], name?, body_name?"),
+ .params("radius | diameter, height: expr; base?: [x,y,z] (centre of the bottom: numbers in mm or length expressions; default: the origin); axis?: X|Y|Z|[x,y,z] (default Z); references?: [{edge: [x,y,z] on a straight edge of the face it stands on, distance: expr}] (at most two, as solid.hole's: the base centre goes that far from each edge's line, in the face's plane, and follows the edges; with a numeric base only); operation?, targets?: [body], name?, body_name?"),
CommandSpec::new("solid.sphere", "Sphere", crate::checked!("solid.sphere", prim_sphere))
.at("SOLID", "CREATE")
.icon("sphere")
@@ -680,6 +680,10 @@ fn add_feature_in(s: &mut Session, p: &Value, kind: FeatureKind, world: bool) ->
let edges: Vec<Vec3> = references.iter().map(|r| r.edge.0).collect();
(Vec::new(), solidcraft_doc::hole_reference::reference_edge_names(&s.model.state(), position.0, &edges))
}
+ // A cylinder's reference edges (#6380) are edges of the body it stands on.
+ FeatureKind::Cylinder { base, references, .. } if !references.is_empty() => {
+ (Vec::new(), solidcraft_doc::hole_reference::cylinder_edge_names(&s.model.state(), base, references))
+ }
// 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)))
@@ -1392,7 +1396,19 @@ fn prim_cylinder(s: &mut Session, p: &Value) -> Result<Value> {
check_expr(s, &height, Kind::Length, cmd, "height")?;
let base = point_param(s, p, "base", cmd)?.unwrap_or_else(|| point_expr(Vec3::ZERO));
let axis = axis_dir_param(p, cmd)?;
- add_feature(s, p, FeatureKind::Cylinder { base, axis: Dir(axis), radius, height, operation: operation(p, cmd)? })
+ // Reference edges (#6380), as a Single hole's: the base centre sits at these distances from
+ // straight edges of the face it stands on, and `base` keeps where those put it.
+ let references = hole_reference_params(s, p, cmd)?;
+ let base = if references.is_empty() {
+ base
+ } else {
+ let at = p
+ .get("base")
+ .and_then(vec3)
+ .ok_or_else(|| bad(cmd, "`references` place a cylinder by its `base` given as numbers, not length expressions"))?;
+ point_expr(referenced_centre(s, cmd, &references, at, -axis)?)
+ };
+ add_feature(s, p, FeatureKind::Cylinder { base, axis: Dir(axis), radius, height, operation: operation(p, cmd)?, references })
}
fn prim_sphere(s: &mut Session, p: &Value) -> Result<Value> {
@@ -2506,22 +2522,7 @@ fn hole(s: &mut Session, p: &Value) -> Result<Value> {
};
// 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
- };
+ let position = if references.is_empty() { position } else { referenced_centre(s, cmd, &references, position, direction)? };
// The diameter: given, or a metric-estimate/Unified-table tap drill, 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")) {
@@ -2606,6 +2607,25 @@ fn hole(s: &mut Session, p: &Value) -> Result<Value> {
)
}
+/// Where reference edges (#37) put a hole's (or a cylinder's) centre picked at `at` on a flat
+/// face, `dir` into it: at their distances from the edges, which must be straight edges at the
+/// given points, and cross.
+fn referenced_centre(s: &Session, cmd: &str, references: &[solidcraft_doc::HoleReference], at: Vec3, dir: Vec3) -> Result<Vec3> {
+ 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, at, dir, &edges, true).map_err(|e| bad(cmd, e.to_string()))?;
+ let centre = frame.place(at, &distances).map_err(|e| bad(cmd, e.to_string()))?;
+ if !solidcraft_doc::hole_reference::on_reference_face(&st, &frame, centre) {
+ let what = if cmd == "solid.cylinder" { "cylinder's base" } else { "hole's centre" };
+ return Err(bad(cmd, format!("the reference distances put the {what} off its face")));
+ }
+ Ok(centre)
+}
+
/// 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<Vec<solidcraft_doc::HoleReference>> {
diff --git a/crates/engine/src/hole_reference_tests.rs b/crates/engine/src/hole_reference_tests.rs
index da8ac53a67..48d437e72d 100644
--- a/crates/engine/src/hole_reference_tests.rs
+++ b/crates/engine/src/hole_reference_tests.rs
@@ -1,7 +1,7 @@
//! 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.
+//! refused with an error. A cylinder takes the same references for its base (#6380).
use std::f64::consts::PI;
@@ -165,3 +165,121 @@ fn hostile_references_never_panic() {
}
assert!(panicked.is_empty(), "solid.hole panicked:\n{}", panicked.join("\n"));
}
+
+/// The last feature's base and reference edges.
+fn cylinder(s: &Session) -> (solidcraft_doc::PointExpr, Vec<solidcraft_doc::HoleReference>) {
+ match &s.doc.features.last().map(|f| &f.kind) {
+ Some(FeatureKind::Cylinder { base, references, .. }) => (base.clone(), references.clone()),
+ other => panic!("the last feature is not a cylinder: {other:?}"),
+ }
+}
+
+/// A Ø6 × 5 cylinder joined onto the plate's top (z = 10), picked at (30, 25), with these
+/// references.
+fn standing(references: Value) -> Value {
+ json!({"base": [30, 25, 10], "axis": [0, 0, 1], "radius": 3, "height": 5, "operation": "join", "name": "C", "references": references})
+}
+
+/// The cylinder (Ø6, from z = 10 to 15) stands about (x, y): solid on its axis and up to 2 mm
+/// from it, empty 4 mm from it in every direction.
+fn pin_at(s: &Session, x: f64, y: f64) {
+ let at = Vec3::new(x, y, 12.5);
+ 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 cylinder about ({x}, {y}) is solid {a} rad from +x");
+ assert!(!solid_at(s, p(4.0)), "beside the cylinder about ({x}, {y}) is empty {a} rad from +x");
+ }
+}
+
+#[test]
+fn a_cylinder_follows_its_edges_when_the_plate_changes() {
+ let mut s = plate();
+ // 10 mm from the far edge (x = len), 12 mm from the front edge (y = 0).
+ let refs = json!([{"edge": [50, 20, 10], "distance": 10}, {"edge": [25, 0, 10], "distance": "12 mm"}]);
+ run(&mut s, "solid.cylinder", standing(refs.clone()));
+ let (base, references) = cylinder(&s);
+ assert_eq!(base.map(|c| c.to_string()), ["40", "12", "10"].map(String::from), "the base keeps where the distances put it");
+ assert_eq!(references.len(), 2);
+ pin_at(&s, 40.0, 12.0);
+ let f = s.doc.find_feature("C").unwrap();
+ let id = f.id;
+ assert_eq!(f.edge_names.len(), 2, "each reference edge keeps its persistent name");
+ // The distances are inputs (Inspect Feature lists them) and parameters.
+ let inspected = run(&mut s, "timeline.inspect", json!({"feature": "C"}));
+ let labels: Vec<&str> = inspected["inputs"].as_array().unwrap().iter().filter_map(|i| i["label"].as_str()).collect();
+ assert_eq!(labels.iter().filter(|l| **l == "Reference distance").count(), 2, "{labels:?}");
+ // The plate grows: the cylinder stays 10 mm from its far edge.
+ run(&mut s, "parameters.change", json!({"name": "len", "expression": "80 mm"}));
+ assert!(s.model.result(id).is_some_and(|r| r.error.is_none()), "{:?}", s.model.result(id).map(|r| &r.error));
+ pin_at(&s, 70.0, 12.0);
+ assert!(!solid_at(&s, Vec3::new(40.0, 12.0, 12.5)), "nothing stands at the old spot");
+ // A distance changed as a parameter moves it.
+ let d = s.doc.find_feature("C").unwrap().param_names.last().cloned().unwrap();
+ run(&mut s, "parameters.change", json!({"name": d, "expression": "20 mm"}));
+ pin_at(&s, 70.0, 20.0);
+ // Undo and redo.
+ run(&mut s, "edit.undo", json!({}));
+ pin_at(&s, 70.0, 12.0);
+ run(&mut s, "edit.redo", json!({}));
+ pin_at(&s, 70.0, 20.0);
+ // Saved and reopened, it keeps its references and its place.
+ let mut t = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
+ t.refresh();
+ pin_at(&t, 70.0, 20.0);
+ assert_eq!(cylinder(&t).1, cylinder(&s).1);
+ run(&mut t, "parameters.change", json!({"name": "len", "expression": "60 mm"}));
+ pin_at(&t, 50.0, 20.0);
+}
+
+#[test]
+fn a_cylinder_without_references_stays_at_its_base() {
+ let mut s = plate();
+ run(&mut s, "solid.cylinder", standing(json!([])));
+ assert!(cylinder(&s).1.is_empty());
+ assert!(!s.doc.to_json().contains("references"), "a cylinder without references is saved as before");
+ pin_at(&s, 30.0, 25.0);
+ run(&mut s, "parameters.change", json!({"name": "len", "expression": "80 mm"}));
+ pin_at(&s, 30.0, 25.0);
+ // One reference: it moves square to that edge and keeps its place along it.
+ run(&mut s, "edit.undo", json!({}));
+ run(&mut s, "edit.undo", json!({}));
+ run(&mut s, "solid.cylinder", standing(json!([{"edge": [0, 20, 10], "distance": 10}])));
+ pin_at(&s, 10.0, 25.0);
+}
+
+#[test]
+fn a_bad_cylinder_reference_is_refused() {
+ let mut s = plate();
+ 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([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"),
+ ] {
+ match s.execute("solid.cylinder", &standing(refs.clone())) {
+ 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");
+ }
+ let p = json!({"base": ["30 mm", "25 mm", "10 mm"], "radius": 3, "height": 5, "references": [edge([0.0, 20.0, 10.0], json!(5))]});
+ assert!(s.execute("solid.cylinder", &p).is_err(), "not with a base given as expressions");
+ let values = crate::tests::hostile_values();
+ let mut panicked = Vec::new();
+ for v in &values {
+ for refs in [v.clone(), json!([v]), json!([{"edge": v, "distance": 5}]), json!([{"edge": [0, 20, 10], "distance": v}])] {
+ for base in [json!([30, 25, 10]), json!([1e300, 0, 10]), v.clone()] {
+ let p = json!({"base": base, "radius": 3, "height": 5, "references": refs});
+ if let Err(EngineError::Internal(id, msg)) = s.execute("solid.cylinder", &p) {
+ panicked.push(format!("{id} {p}: {msg}"));
+ }
+ }
+ }
+ }
+ assert!(panicked.is_empty(), "solid.cylinder panicked:\n{}", panicked.join("\n"));
+}
diff --git a/crates/engine/src/large_assembly_tests.rs b/crates/engine/src/large_assembly_tests.rs
index 3fc50e3396..cf256f5cef 100644
--- a/crates/engine/src/large_assembly_tests.rs
+++ b/crates/engine/src/large_assembly_tests.rs
@@ -38,6 +38,7 @@ fn generated_assembly(parts: usize) -> Document {
radius: mm(1.5),
height: mm(4.0 + k as f64),
operation: Operation::NewBody,
+ references: Vec::new(),
};
made.push((i, doc.add_feature(pin, Some(&format!("Pin {i}.{k}"))).unwrap()));
}
diff --git a/crates/engine/src/schema/features.rs b/crates/engine/src/schema/features.rs
index 78a04f321e..7ca08762b5 100644
--- a/crates/engine/src/schema/features.rs
+++ b/crates/engine/src/schema/features.rs
@@ -189,6 +189,12 @@ pub struct CylinderParams {
#[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]
#[schemars(with = "AxisDir")]
pub axis: Option<AxisDir>,
+ /// Up to two straight edges of the face it stands on, each `{edge: [x, y, z], distance: expr}`
+ /// (as `solid.hole`'s): the base centre goes that far from each edge's line, in the face's
+ /// plane, and follows the edges. With a numeric `base` only.
+ #[serde(default)]
+ #[schemars(with = "Option<Vec<serde_json::Value>>")]
+ pub references: Option<serde_json::Value>,
/// How the cylinder combines with existing bodies. Default: new.
#[serde(default)]
pub operation: Option<OperationParam>,
diff --git a/crates/engine/src/schema/features_tests.rs b/crates/engine/src/schema/features_tests.rs
index e3e1679bbe..05d5255d45 100644
--- a/crates/engine/src/schema/features_tests.rs
+++ b/crates/engine/src/schema/features_tests.rs
@@ -49,7 +49,7 @@ fn schemas_and_the_key_check_agree() {
);
assert_keys(
input_schema_for::<CylinderParams>(),
- &["axis", "base", "body_name", "body_names", "diameter", "height", "name", "operation", "participants", "radius", "targets"],
+ &["axis", "base", "body_name", "body_names", "diameter", "height", "name", "operation", "participants", "radius", "references", "targets"],
);
assert_keys(
input_schema_for::<SphereParams>(),
diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rs
index a4abc38a43..fa0c98622d 100644
--- a/crates/io/src/lib.rs
+++ b/crates/io/src/lib.rs
@@ -1059,6 +1059,7 @@ mod tests {
radius: "6".into(),
height: "15".into(),
operation: Operation::NewBody,
+ references: Vec::new(),
},
None,
)
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index 1dec97603d..4172878fd3 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -361,6 +361,13 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj
app.dialog = Some(d);
return;
}
+ // A cylinder's values are typed in its window; its distances from its reference edges
+ // (#6380) are shown and typed on the canvas, as a hole's.
+ if matches!(d.kind, Kind::Primitive { cmd: "solid.cylinder", .. }) {
+ crate::hole_refs::canvas(app, ui, painter, proj, &mut d);
+ app.dialog = Some(d);
+ return;
+ }
if let Some((base, dir)) = anchor(app, &d)
&& let Some(bs) = proj.to_screen(base)
{
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 0cf0bdc37e..dc01b723c0 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -329,6 +329,8 @@ crate::dialog_descriptor::dialog_descriptors! {
/// face is planar. `None` keeps the command's own placement (the origin, or the edited
/// feature's).
at: Option<(Vec3, Option<Vec3>)>,
+ /// A Cylinder's reference edge distances on that face (`hole_refs`, #6380).
+ refs: Box<crate::hole_refs::Refs>,
},
Combine {
operation: usize,
@@ -932,6 +934,7 @@ impl Dialog {
fields: vec![("length", length_default(s, "20")), ("width", length_default(s, "20")), ("height", length_default(s, "20"))],
operation: 0,
at: None,
+ refs: Default::default(),
},
crate::primitive_placement::inputs("solid.box"),
),
@@ -941,11 +944,18 @@ impl Dialog {
fields: vec![("diameter", length_default(s, "20")), ("height", length_default(s, "20"))],
operation: 0,
at: None,
+ refs: Default::default(),
},
- vec![],
+ crate::hole_refs::cylinder_inputs(),
),
"solid.sphere" => Dialog::new(
- Kind::Primitive { cmd: "solid.sphere", fields: vec![("diameter", length_default(s, "20"))], operation: 0, at: None },
+ Kind::Primitive {
+ cmd: "solid.sphere",
+ fields: vec![("diameter", length_default(s, "20"))],
+ operation: 0,
+ at: None,
+ refs: Default::default(),
+ },
vec![],
),
"solid.torus" => Dialog::new(
@@ -954,6 +964,7 @@ impl Dialog {
fields: vec![("major", length_default(s, "20")), ("minor", length_default(s, "5"))],
operation: 0,
at: None,
+ refs: Default::default(),
},
vec![],
),
@@ -967,6 +978,7 @@ impl Dialog {
],
operation: 0,
at: None,
+ refs: Default::default(),
},
vec![],
),
@@ -981,6 +993,7 @@ impl Dialog {
],
operation: 0,
at: None,
+ refs: Default::default(),
},
vec![SelInput::new("Profile", PROFILES, false)],
),
@@ -4474,7 +4487,7 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S
}
return Ok(out);
}
- Kind::Primitive { cmd, fields, operation, at } => {
+ Kind::Primitive { cmd, fields, operation, at, .. } => {
let mut p = serde_json::Map::new();
for (k, v) in fields {
p.insert((*k).into(), json!(v));
@@ -4497,6 +4510,11 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S
if let Some(n) = normal {
p.insert("axis".into(), pt(n));
}
+ // Reference edges (#6380) place the base by its distances from them.
+ let references = crate::hole_refs::params(d);
+ if !references.is_empty() {
+ p.insert("references".into(), json!(references));
+ }
}
_ => {
p.insert("center".into(), pt(point));
@@ -5467,26 +5485,50 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
fields: vec![("length", stored_length(s, length)), ("width", stored_length(s, width)), ("height", stored_length(s, height))],
operation: op_index(operation),
at: None,
+ refs: Default::default(),
};
d.extra.insert("corner".into(), pt_expr(corner));
d
}
- FeatureKind::Cylinder { base, axis, radius, height, operation } => {
+ FeatureKind::Cylinder { base, axis, radius, height, operation, references } => {
let mut d = start("solid.cylinder")?;
d.kind = Kind::Primitive {
cmd: "solid.cylinder",
fields: vec![("radius", stored_length(s, radius)), ("height", stored_length(s, height))],
operation: op_index(operation),
at: None,
+ refs: Default::default(),
};
d.extra.insert("base".into(), pt_expr(base));
d.extra.insert("axis".into(), pt3(axis.0));
+ // Standing on a flat face (a base of numbers there, square to it): placed there, so it
+ // can take reference edges of that face (#6380), with its own picked again. Not the
+ // picks a selection made when the window opened.
+ d.inputs = crate::hole_refs::cylinder_inputs();
+ let [x, y, z] = base.clone().map(|c| c.parse::<f64>().ok());
+ if let (Some(x), Some(y), Some(z)) = (x, y, z)
+ && let Some(face @ Sel::Face { .. }) = face_sel(s, Vec3::new(x, y, z))
+ && let Sel::Face { body, index, .. } = &face
+ && planar_face(s, body, *index).is_some_and(|(_, n)| n.dot(axis.0) > 1.0 - 1e-9)
+ && let Kind::Primitive { at, .. } = &mut d.kind
+ {
+ *at = Some((Vec3::new(x, y, z), Some(axis.0)));
+ if let Some(inp) = d.inputs.first_mut() {
+ inp.items = vec![face];
+ }
+ crate::hole_refs::restore(s, &mut d, references, &f.edge_names);
+ }
d
}
FeatureKind::Sphere { center, radius, operation } => {
let mut d = start("solid.sphere")?;
- d.kind =
- Kind::Primitive { cmd: "solid.sphere", fields: vec![("radius", stored_length(s, radius))], operation: op_index(operation), at: None };
+ d.kind = Kind::Primitive {
+ cmd: "solid.sphere",
+ fields: vec![("radius", stored_length(s, radius))],
+ operation: op_index(operation),
+ at: None,
+ refs: Default::default(),
+ };
d.extra.insert("center".into(), pt_expr(center));
d
}
@@ -5497,6 +5539,7 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
fields: vec![("major", stored_length(s, major)), ("minor", stored_length(s, minor))],
operation: op_index(operation),
at: None,
+ refs: Default::default(),
};
d.extra.insert("center".into(), pt_expr(center));
d
@@ -5528,6 +5571,7 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
],
operation: op_index(operation),
at: None,
+ refs: Default::default(),
};
if let Some(sketch) = sketch {
let items = st.sketch(sketch.0).map(|ss| profile_indices(ss, profiles)).unwrap_or_default();
@@ -5567,6 +5611,7 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
],
operation: op_index(operation),
at: None,
+ refs: Default::default(),
};
d.extra.insert("base".into(), pt_expr(base));
d.extra.insert("axis".into(), pt3(axis.0));
diff --git a/crates/ui-egui/src/dialogs_all_tests.rs b/crates/ui-egui/src/dialogs_all_tests.rs
index bf25da5030..9a6bdccf0b 100644
--- a/crates/ui-egui/src/dialogs_all_tests.rs
+++ b/crates/ui-egui/src/dialogs_all_tests.rs
@@ -69,6 +69,9 @@ fn representative(h: &Harness, command: &str) -> Dialog {
if command == "solid.coil" {
continue; // an empty Profile input keeps the primitive section, which this form checks
}
+ if command == "solid.cylinder" {
+ continue; // its face and reference edges place it (cylinder reference tests); this form checks its fields
+ }
if matches!(input.label, "Rail" | "Second Rail" | "Pass through" | "Direction" | "Roller (optional)" | "Tip (optional)") {
continue;
}
diff --git a/crates/ui-egui/src/dialogs_dense.rs b/crates/ui-egui/src/dialogs_dense.rs
index 708b7c345a..b26ddbcbe4 100644
--- a/crates/ui-egui/src/dialogs_dense.rs
+++ b/crates/ui-egui/src/dialogs_dense.rs
@@ -184,8 +184,8 @@ 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, &app.session);
- if matches!(&d.kind, Kind::Hole { opts, .. } if !opts.multiple) {
- // Each reference edge with its distance (#37).
+ if crate::hole_refs::takes(d) {
+ // Each reference edge with its distance (#37, #6380).
enter |= crate::hole_refs::input_rows(d, ui, &app.session);
} else {
input_rows(d, ui, &app.session);
@@ -793,7 +793,7 @@ fn additional_rows(app: &mut SolveApp, d: &mut Dialog, ui: &mut egui::Ui) -> boo
enter |= crate::dialogs_move::rows(ui, k);
extra_options(ui, "move_options", &mut d.extra, &[("Create Copy", "copy")]);
}
- Kind::Primitive { cmd, fields, operation, at } => {
+ Kind::Primitive { cmd, fields, operation, at, .. } => {
let from_sketch = *cmd == "solid.coil" && d.inputs.first().is_some_and(|i| i.accept & selection::PROFILES != 0 && !i.items.is_empty());
for (k, v) in fields.iter_mut() {
if from_sketch && (*k == "diameter" || *k == "section_size") {
@@ -811,7 +811,10 @@ fn additional_rows(app: &mut SolveApp, d: &mut Dialog, ui: &mut egui::Ui) -> boo
form_row(ui, "Position", |ui| {
ui.horizontal(|ui| {
ui.label(format!("{:.2}, {:.2}, {:.2}", p.x, p.y, p.z));
- if ui_kit::button(ui, "×", ui_kit::Button::Small).on_hover_text(tr("Place at the origin instead")).clicked() {
+ // A cylinder's place is its Face pick, cleared there.
+ if *cmd != "solid.cylinder"
+ && ui_kit::button(ui, "×", ui_kit::Button::Small).on_hover_text(tr("Place at the origin instead")).clicked()
+ {
*at = None;
}
});
diff --git a/crates/ui-egui/src/hole_refs.rs b/crates/ui-egui/src/hole_refs.rs
index fafe8d461b..b2477da0b3 100644
--- a/crates/ui-egui/src/hole_refs.rs
+++ b/crates/ui-egui/src/hole_refs.rs
@@ -5,7 +5,9 @@
//! 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.
+//! part changes; Edit Feature picks the edges again where they are now. A Cylinder takes the same
+//! references for its base centre (#6380): its window picks the face it stands on (or takes the
+//! one selected before it opened), then the edges.
use egui::{Color32, Pos2, Stroke, vec2};
use serde_json::{Value, json};
@@ -17,7 +19,7 @@ use solidcraft_engine::{Sel, Session};
use crate::SolveApp;
use crate::dialogs::{Dialog, Kind};
-use crate::selection::{EDGES, SelInput};
+use crate::selection::{EDGES, FACES, PLANAR_FACES, SelInput, VERTICES};
use crate::theme::Tokens;
use crate::viewport::Proj;
@@ -60,19 +62,75 @@ 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 Cylinder window's inputs: where it stands (a face, or a vertex), then the reference edges.
+pub(crate) fn cylinder_inputs() -> Vec<SelInput> {
+ let mut v = vec![SelInput::new("Face", PLANAR_FACES | FACES | VERTICES, false)];
+ v.extend(inputs());
+ v
}
-/// 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)),
+/// Does `d` take reference edges: a Single hole's dialog, or a Cylinder's?
+pub(crate) fn takes(d: &Dialog) -> bool {
+ match &d.kind {
+ Kind::Hole { opts, .. } => !opts.multiple,
+ Kind::Primitive { cmd, .. } => *cmd == "solid.cylinder",
+ _ => false,
+ }
+}
+
+/// A Cylinder stands where its Face input is picked: on a planar face, along its normal (as it
+/// stood when it is the place it already has); nowhere picked, at the origin.
+fn cylinder_place(s: &Session, d: &mut Dialog) {
+ let picked = d.inputs.first().and_then(|i| i.items.first()).cloned();
+ let Kind::Primitive { cmd: "solid.cylinder", at, .. } = &mut d.kind else { return };
+ let to = match picked {
+ Some(Sel::Face { body, index, point }) => Some((point, crate::dialogs::planar_face(s, &body, index).map(|(_, n)| n))),
+ Some(Sel::Vertex { point, .. }) => Some((point, None)),
+ _ => None,
+ };
+ if to.map(|(p, _)| p) != at.map(|(p, _)| p) {
+ *at = to;
+ }
+}
+
+/// The dialog's reference distances and what they were worked out for.
+fn refs(d: &Dialog) -> Option<&Refs> {
+ match &d.kind {
+ Kind::Hole { opts, .. } => Some(opts.refs.as_ref()),
+ Kind::Primitive { refs, .. } => Some(refs.as_ref()),
+ _ => None,
+ }
+}
+
+fn refs_mut(d: &mut Dialog) -> Option<&mut Refs> {
+ match &mut d.kind {
+ Kind::Hole { opts, .. } => Some(opts.refs.as_mut()),
+ Kind::Primitive { refs, .. } => Some(refs.as_mut()),
+ _ => None,
+ }
+}
+
+/// The place: the cylinder's base, else the hole's first face pick.
+fn place(d: &Dialog) -> Option<Vec3> {
+ if let Kind::Primitive { at, .. } = &d.kind {
+ return at.map(|(p, _)| p);
+ }
+ d.inputs.first()?.items.iter().find_map(|x| match x {
+ Sel::Face { point, .. } => Some(*point),
_ => None,
})
}
+/// Move the place (see [`place`]) to `p`: the face pick, and a cylinder's base with it.
+fn set_place(d: &mut Dialog, p: Vec3) {
+ if let Kind::Primitive { at: Some((point, _)), .. } = &mut d.kind {
+ *point = p;
+ }
+ if let Some(Sel::Face { point, .. }) = d.inputs.first_mut().and_then(|inp| inp.items.iter_mut().find(|x| matches!(x, Sel::Face { .. }))) {
+ *point = p;
+ }
+}
+
/// A point on each reference edge picked, by input.
fn edges(d: &Dialog) -> [Option<Vec3>; 2] {
REFERENCES.map(|label| {
@@ -90,21 +148,24 @@ fn vec3(v: &Value) -> Option<Vec3> {
(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.
+/// The way the hole drills at `at`: as it was made (editing), else into the face there. A
+/// cylinder's: into the face it stands on, against its axis.
fn direction(s: &Session, d: &Dialog, at: Vec3) -> Option<Vec3> {
+ if let Kind::Primitive { at: Some((_, normal)), .. } = &d.kind {
+ return normal.map(|n| -n);
+ }
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<usize>)> {
- let (_, at) = place(d)?;
+ 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
+ if let Some(f) = &refs(d)?.frame
&& f.revision == s.revision
&& f.place == at
&& f.edges == edges
@@ -116,8 +177,8 @@ fn frame(s: &Session, d: &mut Dialog) -> Option<(ReferenceFrame, Vec<usize>)> {
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() });
+ if let Some(refs) = refs_mut(d) {
+ refs.frame = Some(Framed { revision: s.revision, place: at, edges, frame: found.clone() });
}
found
}
@@ -126,19 +187,19 @@ fn frame(s: &Session, d: &mut Dialog) -> Option<(ReferenceFrame, Vec<usize>)> {
/// 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) {
+ if !takes(d) {
return;
}
+ cylinder_place(s, d);
let edges = edges(d);
- let Some((i, at)) = place(d) else {
- if let Kind::Hole { opts, .. } = &mut d.kind {
- opts.refs.seen = None;
+ let Some(at) = place(d) else {
+ if let Some(refs) = refs_mut(d) {
+ refs.seen = None;
}
return;
};
let framed = frame(s, d);
- let Kind::Hole { opts, .. } = &mut d.kind else { return };
- let refs = &mut opts.refs;
+ let Some(refs) = refs_mut(d) else { return };
let mut to = at;
if let Some((f, picked)) = &framed {
let same = refs.seen.as_ref().filter(|sn| sn.place == at && sn.edges == edges);
@@ -170,15 +231,13 @@ pub(crate) fn sync(s: &Session, d: &mut Dialog) {
}
}
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;
+ if to != at {
+ set_place(d, 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.
+/// The Single hole's (or the Cylinder'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() {
@@ -186,8 +245,8 @@ pub(crate) fn input_rows(d: &mut Dialog, ui: &mut egui::Ui, s: &Session) -> bool
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))
+ if let Some(refs) = refs_mut(d)
+ && let (Some(label), Some(value)) = (DISTANCES.get(k), refs.distance.get_mut(k))
{
enter |= crate::ui_kit::expr_row(ui, label, value);
}
@@ -198,24 +257,17 @@ pub(crate) fn input_rows(d: &mut Dialog, ui: &mut egui::Ui, s: &Session) -> bool
/// The `references` OK sends: each picked edge (a point on it) with its distance.
pub(crate) fn params(d: &Dialog) -> Vec<Value> {
- 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()
+ let Some(refs) = refs(d).filter(|_| takes(d)) else { return Vec::new() };
+ edges(d).iter().zip(&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.
+/// Editing a hole (or a cylinder) with reference edges: the edges picked again where they are
+/// now, their distances, and the place where those distances put it 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 Some(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());
@@ -233,8 +285,8 @@ pub(crate) fn restore(s: &Session, d: &mut Dialog, references: &[HoleReference],
{
inp.items = vec![sel];
}
- if let Kind::Hole { opts, .. } = &mut d.kind
- && let Some(slot) = opts.refs.distance.get_mut(k)
+ if let Some(refs) = refs_mut(d)
+ && let Some(slot) = refs.distance.get_mut(k)
{
*slot = r.distance.to_string();
}
@@ -242,19 +294,17 @@ pub(crate) fn restore(s: &Session, d: &mut Dialog, references: &[HoleReference],
// 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 Some(refs) = refs(d)
{
- let values: Option<Vec<f64>> = opts.refs.distance.iter().take(f.lines.len()).map(|e| s.doc.eval(e, ValueKind::Length).ok()).collect();
+ let values: Option<Vec<f64>> = 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;
- }
+ set_place(d, 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() });
+ if let Some(refs) = refs_mut(d) {
+ refs.seen = Some(Seen { place: to, edges, distance: refs.distance.clone() });
}
}
@@ -273,10 +323,10 @@ fn nearest_edge(s: &Session, at: Vec3, p: Vec3) -> Option<Sel> {
/// 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) {
+ if !takes(d) {
return false;
}
- let Some((_, at)) = place(d) else { 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();
@@ -291,13 +341,13 @@ pub(crate) fn canvas(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painter,
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);
+ let (Some(label), Some(refs)) = (DISTANCES.get(*k), refs_mut(d)) else { continue };
+ let focus = refs.focus == Some(*k);
if focus {
- opts.refs.focus = None;
+ refs.focus = None;
took = true;
}
- let Some(value) = opts.refs.distance.get_mut(*k) else { continue };
+ let Some(value) = refs.distance.get_mut(*k) else { continue };
let at = box_beyond(a, b);
let r = crate::canvas::value_box_in(
ui,
diff --git a/crates/ui-egui/src/hole_refs_ui_tests.rs b/crates/ui-egui/src/hole_refs_ui_tests.rs
index f65f691f89..bdc4103057 100644
--- a/crates/ui-egui/src/hole_refs_ui_tests.rs
+++ b/crates/ui-egui/src/hole_refs_ui_tests.rs
@@ -2,6 +2,7 @@
//! 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.
+//! A Cylinder standing on a picked face takes reference edges the same way (#6380).
use serde_json::json;
use solidcraft_engine::Sel;
@@ -160,3 +161,91 @@ fn a_number_typed_after_an_edge_pick_sets_its_distance() {
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");
}
+
+/// The open Cylinder dialog's reference distances and where it stands.
+fn cylinder_dialog(h: &Harness) -> ([String; 2], Vec3) {
+ match h.app.dialog.as_ref().map(|d| &d.kind) {
+ Some(Kind::Primitive { cmd: "solid.cylinder", refs, at: Some((p, _)), .. }) => (refs.distance.clone(), *p),
+ other => panic!("the cylinder dialog is open on a face: {other:?}"),
+ }
+}
+
+/// With the mouse alone: pick the top face, start Cylinder, pick two edges (each distance
+/// measured from the pick), OK. Typing a distance moves the base; Edit Feature picks the edges
+/// again.
+#[test]
+fn a_cylinder_is_placed_by_its_distances_from_two_edges() {
+ let mut h = plate();
+ let at = screen(&mut h, Vec3::new(30.0, 25.0, 10.0));
+ h.step(&json!({"click": at})).unwrap();
+ h.step(&json!({"start": "solid.cylinder"})).unwrap();
+ h.frames(2);
+ let (_, picked) = cylinder_dialog(&h);
+ assert!(picked.dist(Vec3::new(30.0, 25.0, 10.0)) < 0.5, "it stands where the face was picked: {picked:?}");
+ // Reference 1 takes the first edge picked, Reference 2 the next.
+ 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), "{:?}", 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"));
+ let (measured, _) = cylinder_dialog(&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:?}");
+ assert!(h.at(&json!({"handle": "canvas:Distance 1"})).is_ok() && h.at(&json!({"handle": "canvas:Distance 2"})).is_ok());
+ 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::Cylinder { references, .. } = &f.kind else { panic!("the last feature is a cylinder: {}", f.kind.type_name()) };
+ assert_eq!(references.len(), 2);
+ assert_eq!(f.edge_names.len(), 2);
+ assert!(h.app.session.model.result(f.id).is_some_and(|r| r.error.is_none()));
+
+ // Edit Feature (with the face selected): the edges again with their distances, each input
+ // once; a typed distance moves the base.
+ let top = crate::dialogs::face_sel(&h.app.session, Vec3::new(45.0, 35.0, 10.0)).unwrap();
+ h.app.session.selection = vec![top];
+ h.step(&json!({"call": "ui.editFeature", "params": {"feature": f.id}})).unwrap();
+ h.frames(4);
+ let labels: Vec<&str> = h.app.dialog.as_ref().unwrap().inputs.iter().map(|i| i.label).collect();
+ assert_eq!(labels, ["Face", "Reference 1", "Reference 2"]);
+ 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!(cylinder_dialog(&h).0, measured);
+ type_into(&mut h, "dialog:Distance 1", "10 mm");
+ type_into(&mut h, "canvas:Distance 2", "12 mm");
+ assert!(cylinder_dialog(&h).1.dist(Vec3::new(10.0, 12.0, 10.0)) < 1e-6, "{:?}", cylinder_dialog(&h).1);
+ 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(10.0, 12.0, 12.0)) && !solid_at(&h, Vec3::new(picked.x, picked.y, 12.0)), "the edit moved it to (10, 12)");
+}
+
+/// Started with nothing selected, the Cylinder stands at the origin until a face is clicked;
+/// then its edges are picked, all with the mouse.
+#[test]
+fn a_cylinder_started_first_takes_its_face_then_its_edges() {
+ let mut h = plate();
+ h.step(&json!({"start": "solid.cylinder"})).unwrap();
+ h.frames(2);
+ let d = h.app.dialog.as_ref().unwrap();
+ let labels: Vec<&str> = d.inputs.iter().map(|i| i.label).collect();
+ assert_eq!(labels, ["Face", "Reference 1", "Reference 2"]);
+ assert!(matches!(d.kind, Kind::Primitive { at: None, .. }), "nothing picked: at the origin");
+ let at = screen(&mut h, Vec3::new(30.0, 25.0, 10.0));
+ h.step(&json!({"click": at})).unwrap();
+ h.frames(2);
+ let (_, picked) = cylinder_dialog(&h);
+ assert!(picked.dist(Vec3::new(30.0, 25.0, 10.0)) < 0.5, "it stands where the face was clicked: {picked:?}");
+ 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() && picked_edge(&h, "Reference 2").is_some());
+ h.step(&json!({"widget": "OK"})).unwrap();
+ assert!(h.app.dialog.is_none(), "{:?}", h.app.dialog.as_ref().map(|d| &d.error));
+ let f = h.app.session.doc.features.last().unwrap();
+ let FeatureKind::Cylinder { references, .. } = &f.kind else { panic!("the last feature is a cylinder") };
+ assert_eq!(references.len(), 2);
+}
diff --git a/docs/book/src/guide/features.md b/docs/book/src/guide/features.md
index adecfcd965..d70c6fc44f 100644
--- a/docs/book/src/guide/features.md
+++ b/docs/book/src/guide/features.md
@@ -114,6 +114,13 @@ measured in the face's plane. Moving the hole measures the distances again. The
distances when the part changes: it follows its edges, and the distances are parameters like its
diameter.
+A **Cylinder** placed on a planar face takes reference edges the same way. Select the face, then
+start **Cylinder**: it stands where you clicked, and the window has **Reference 1** and
+**Reference 2**. Pick one or two straight edges of that face; each gets a **Distance**, measured
+from where you clicked, which you can also type in the window or in its box on the canvas. The
+cylinder's base centre then follows the edges when the part changes, and the distances are
+parameters like its radius. Edit Feature picks the edges again.
+
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
@@ -271,7 +278,7 @@ still be added through `set`. The fields of the common features:
| Fillet | `radius`, `edges` (a point on each edge), `body`, `style` |
| Chamfer | `distance`, `distance2` or `angle`, `flip`, `edges`, `body` |
| Box | `length`, `width`, `height`, `corner`, `operation` |
-| Cylinder | `radius`, `height`, `base`, `axis`, `operation` |
+| Cylinder | `radius`, `height`, `base`, `axis`, `operation`, `references` (an `edge` point and a `distance` each, as a hole's) |
| 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` |
diff --git a/docs/book/src/reference/glossary.md b/docs/book/src/reference/glossary.md
index 300cc2d09b..211cb58036 100644
--- a/docs/book/src/reference/glossary.md
+++ b/docs/book/src/reference/glossary.md
@@ -258,6 +258,22 @@ The first instance is the original.
- **Elsewhere:** instance, element, occurrence.
- **For translators:** not an occurrence of a component.
+### reference edge
+
+A straight edge of a flat face that a Single hole's centre or a cylinder's base centre keeps a
+set distance from, measured in that face's plane.
+
+Up to two reference edges place one hole or cylinder. Each distance is a parameter, and the
+feature follows its edges when the part changes.
+
+- **In SolidCraft:** the `references` parameter of `solid.hole` and `solid.cylinder` (each
+ `{edge, distance}`); the windows' Reference 1, Reference 2 and Distance 1, Distance 2 rows; the
+ "Reference distance" input (`ui.reference_1`, `ui.reference_2`, `ui.reference_distance`).
+- **Don't use:** datum edge, anchor edge.
+- **Elsewhere:** reference edge, edge offset, distance from edge.
+- **For translators:** an edge of a body, not a construction axis or a reference plane; the
+ distance is a length, not a reference value for light or material.
+
### rollback marker
The marker in the timeline after which no feature is computed.
@@ -351,6 +367,9 @@ share a catalogue entry. Each meaning below gets its own term and, in time, its
| | the middle display quality | normal (quality) | `ui.display_quality_normal` |
| Quantity | the number of pattern instances | count | the pattern dialogs' Quantity rows, `ui.quantity` |
| | what the motion plot shows: value, velocity or acceleration | plotted quantity | the motion study's Quantity row, `motion.plot_quantity` |
+| Reference | an edge a hole or cylinder keeps its distance from | *reference edge* | `references` of `solid.hole` and `solid.cylinder`, `ui.reference_1` |
+| | the measured values a material is checked against | reference (material) | `material.editor.reference` |
+| | the distance a light's intensity is given for | reference distance (light) | `render.cpu_light_reference` |
Some translations show the clash today: Japanese and Chinese show a hole's flat bottom with the
word for "unfold" or "plane", Chinese shows "Round" as "fillet", and Chinese and Russian show the
diff --git a/skills/solidcraft-modeling/reference.md b/skills/solidcraft-modeling/reference.md
index e533f97330..b2f8774725 100644
--- a/skills/solidcraft-modeling/reference.md
+++ b/skills/solidcraft-modeling/reference.md
@@ -76,7 +76,7 @@ Distances are unsigned. Draw the geometry on the correct side first, and the dim
|---|---|---|
| `solid.extrude` | `distance` | `profiles` defaults to **every region**, with a region inside another as a hole in it: two concentric circles give a ring. Pick regions with `[{"point":[x,y]}]` or `[index]`. Other options: `operation` (new/join/cut/intersect/auto), `direction` (positive/negative/symmetric), `through_all: true`, `start_offset`. A cut that misses reports success. |
| `solid.box` | `length`, `width`, `height` | `center:[x,y,z]` or `corner`. The quickest way to block out a part. `body_name` names the body it makes. With `operation:"cut"`, `targets:["Top"]` cuts only the bodies listed, so the cutter can pass through other bodies. |
-| `solid.cylinder` | `radius` or `diameter`, `height` | `base` is the centre of the bottom (default origin), `axis` defaults to `Z`. Expressions work in `base`. Always pass `operation`. `body_name` and `targets` work as for `solid.box`. |
+| `solid.cylinder` | `radius` or `diameter`, `height` | `base` is the centre of the bottom (default origin), `axis` defaults to `Z`. Expressions work in `base`. To tie a cylinder standing on a flat face to the part, give `base` as numbers on that face and add `references: [{edge:[x,y,z], distance}]` (up to two straight edges of the face, as for `solid.hole`): the base centre then sits at those distances from the edges and follows them. Always pass `operation`. `body_name` and `targets` work as for `solid.box`. |
| `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. A pick farther than 5% of the body's size from every edge is refused, 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 or a fillet between curved faces (see Order in `SKILL.md`). Bodies with lofted or swept faces are refused (`offset: only bodies with planes, cylinders, cones, spheres and tori`): hollow a loft with a smaller loft and `operation: cut`. |