Axes and points from circular edges and round faces (#3128) (#4610)

* Axes and points from circular edges and round faces

In 3D, a round edge or face stands for its circle wherever a command
takes an axis or a point.

Revolve, Surface Revolve, both Circular Pattern dialogs, Plane at Angle
and Move -> Rotate take a circular edge (through its centre, along its
normal) or a cylinder, cone or torus face (its axis). The features keep
the pick as a model reference, so they follow the model when a parameter
moves it. Straight edges work as before; flat faces are refused.

Every 3D point input takes a circle's centre: construction points (which
follow the circle), To Object, patch points, hole placement, and Move's
pivot and points. Hovering shows the axis as a dashed construction line
or the centre as a star, and the dialog's chip names what the pick
stands for ("centre of edge 10", "axis of face 3").

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Format the round-pick hover check

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Selection chips: name a round pick as a circle centre or axis

The chip has room for little more than the body and a word or two:
"Shaft · circle centre", "Shaft · circle axis", "Shaft · face 2 axis",
and "Shaft · point" for a point of the model.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Move: a circle's centre in a placed component is where the component shows it

Move's pivot and points read a picked circle from the model in its
component's own frame, while the pick is in the world. They now read it
from the world state (and, editing a Move, from the state before it,
placed the same way), as the viewport and the other round picks do.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Plane at Angle on a planar face about a model edge: test that it follows both

Upstream #1956 made a planar face a base for Plane at Angle; this branch makes a model edge an
axis. The rebase keeps both in one PlaneRef::AtAngle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
froglemonade2
2026-10-26 12:27:32 +00:00
committed by GitHub
parent 8630a3f0e5
commit e063a7778e
24 changed files with 1133 additions and 143 deletions
+4 -1
View File
@@ -150,10 +150,13 @@ fn map_plane_ref(m: &Mat, p: &mut PlaneRef) {
map_plane_ref(m, base);
map_geo_ref(m, point);
}
PlaneRef::AtAngle { base, axis_origin, axis_dir, .. } => {
PlaneRef::AtAngle { base, axis_origin, axis_dir, line, .. } => {
map_plane_ref(m, base);
*axis_origin = apply_point(m, *axis_origin);
*axis_dir = apply_vector(m, *axis_dir);
if let Some(g) = line {
map_geo_ref(m, g);
}
}
// Named origin planes and construction planes are the component's own.
PlaneRef::Origin { .. } | PlaneRef::Construction { .. } => {}
+20 -2
View File
@@ -114,11 +114,17 @@ fn remap_plane(p: &mut PlaneRef, ids: &BTreeMap<u64, u64>, bodies: &BTreeMap<Str
return Err(crate::DocError::Invalid("clone plane reference depth exceeded".into()));
}
match p {
PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => remap_plane(base, ids, bodies, depth + 1)?,
PlaneRef::Offset { base, .. } | PlaneRef::Flipped { base, .. } => remap_plane(base, ids, bodies, depth + 1)?,
PlaneRef::ThroughPoint { base, point } => {
remap_plane(base, ids, bodies, depth + 1)?;
remap_geo(point, ids, bodies, depth + 1)?;
}
PlaneRef::AtAngle { base, line, .. } => {
remap_plane(base, ids, bodies, depth + 1)?;
if let Some(g) = line {
remap_geo(g, ids, bodies, depth + 1)?;
}
}
PlaneRef::Face { name, anchor, .. } => {
if let Some(name) = name {
*name = remap_topology(name, ids, bodies);
@@ -209,6 +215,9 @@ impl crate::Feature {
checked_geo(r, 0)?;
}
}
K::Revolve { axis: crate::AxisRef::Model { geo }, .. }
| K::SurfaceRevolve { axis: crate::AxisRef::Model { geo }, .. }
| K::Pattern { pattern: crate::PatternKind::Circular { axis_ref: Some(geo), .. }, .. } => checked_geo(geo, 0)?,
_ => {}
}
// Feature names are remapped once here; the geometry pass below handles only
@@ -269,6 +278,9 @@ impl crate::Feature {
remap_geo(r, ids, bodies, 0)?;
}
}
K::Revolve { axis: crate::AxisRef::Model { geo }, .. }
| K::SurfaceRevolve { axis: crate::AxisRef::Model { geo }, .. }
| K::Pattern { pattern: crate::PatternKind::Circular { axis_ref: Some(geo), .. }, .. } => remap_geo(geo, ids, bodies, 0)?,
_ => {}
}
Ok(())
@@ -289,7 +301,13 @@ fn checked_plane(p: &PlaneRef, depth: usize) -> crate::Result<()> {
return Err(crate::DocError::Invalid("copy reference nesting exceeds 64".into()));
}
match p {
PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => checked_plane(base, depth + 1)?,
PlaneRef::Offset { base, .. } | PlaneRef::Flipped { base, .. } => checked_plane(base, depth + 1)?,
PlaneRef::AtAngle { base, line, .. } => {
checked_plane(base, depth + 1)?;
if let Some(g) = line {
checked_geo(g, depth + 1)?;
}
}
PlaneRef::Midplane { a, b } | PlaneRef::TwoEdges { a, b } => {
checked_geo(a, depth + 1)?;
checked_geo(b, depth + 1)?;
+83 -19
View File
@@ -162,6 +162,11 @@ fn face_of<'a>(st: &'a ModelState, at: Vec3, name: &Option<String>) -> Result<(&
/// The edge picked, as a polyline.
fn edge_points(st: &ModelState, at: Vec3, name: &Option<String>) -> Result<Vec<Vec3>> {
edge_pick(st, at, name).map(|(_, _, pts)| pts)
}
/// The edge picked: its body, its index there (as `Body::edges` lists it) and its polyline.
fn edge_pick<'a>(st: &'a ModelState, at: Vec3, name: &Option<String>) -> Result<(&'a ModelBody, usize, Vec<Vec3>)> {
let mut at = at;
if let Some(n) = name {
for b in bodies(st) {
@@ -171,23 +176,33 @@ fn edge_points(st: &ModelState, at: Vec3, name: &Option<String>) -> Result<Vec<V
}
}
}
let mut best: Option<(f64, Vec<Vec3>)> = None;
let mut best: Option<(f64, &ModelBody, usize, Vec<Vec3>)> = None;
for b in bodies(st) {
let tol = (b.body.size() * 1e-3).max(1e-3);
let Ok(edges) = b.body.edges(tol) else { continue };
for e in edges {
for (i, e) in edges.into_iter().enumerate() {
let d = e.points.windows(2).map(|w| at.dist_to_segment(w[0], w[1])).fold(f64::MAX, f64::min);
if best.as_ref().is_none_or(|(bd, _)| d < *bd) {
best = Some((d, e.points));
if best.as_ref().is_none_or(|(bd, ..)| d < *bd) {
best = Some((d, b, i, e.points));
}
}
}
match best {
Some((d, pts)) if pts.len() >= 2 && d <= 1e-3 + 1e-2 * pts.iter().fold(0.0, |m: f64, p| m.max(p.len())).max(1.0) => Ok(pts),
Some((d, b, i, pts)) if pts.len() >= 2 && d <= 1e-3 + 1e-2 * pts.iter().fold(0.0, |m: f64, p| m.max(p.len())).max(1.0) => Ok((b, i, pts)),
_ => Err(bad(format!("no edge at {at:?}"))),
}
}
/// The circle a picked edge lies on, from its exact curve (`kernel::edge_circle`) when the drawn
/// edge lies on it, else fitted to the drawn points: (centre, unit normal).
fn edge_circle(b: &ModelBody, index: usize, pts: &[Vec3]) -> Option<(Vec3, Vec3)> {
let exact = kernel::edge_circle(&b.body, index).filter(|c| {
let tol = (b.body.size() * 1e-6).max(1e-9) * 10.0;
pts.iter().all(|p| (p.dist(c.center) - c.radius).abs() <= tol && (*p - c.center).dot(*c.axis).abs() <= tol)
});
exact.map(|c| (c.center, *c.axis)).or_else(|| as_circle(pts).map(|(c, n, _)| (c, n)))
}
/// The most edge names a vertex reference keeps.
const MAX_VERTEX_EDGES: usize = 16;
@@ -306,13 +321,52 @@ pub(crate) fn point(ctx: &Ctx, g: &GeoRef) -> Result<Vec3> {
}
}
/// An edge or face of the model as a line: along a straight edge, through the centre of a
/// circular edge along its normal, or the axis of a cylinder, cone or torus face.
fn model_line(st: &ModelState, g: &GeoRef) -> Result<(Vec3, Vec3)> {
match g {
GeoRef::Edge { at, name } => {
let (b, i, pts) = edge_pick(st, *at, name)?;
as_line(&pts).or_else(|| edge_circle(b, i, &pts)).ok_or_else(|| bad("the edge is neither straight nor circular"))
}
GeoRef::Face { at, name } => {
let (b, fi, _) = face_of(st, *at, name)?;
match kernel::face_surface(&b.body, fi) {
Some(FaceSurface::Cylinder { origin, axis, .. }) => Ok((origin, *axis)),
Some(FaceSurface::Cone { apex, axis, .. }) => Ok((apex, *axis)),
Some(FaceSurface::Torus { center, axis, .. }) => Ok((center, *axis)),
_ => Err(bad("the face is not a cylinder, cone or torus")),
}
}
_ => Err(bad("pick a straight or circular edge, or a cylinder, cone or torus face")),
}
}
/// The axis a feature turns about when an edge or face of the model is picked for it (a revolve,
/// a circular pattern, a plane at an angle), as [`model_line`] finds it. The direction is
/// oriented the same way however the edge or surface runs (its largest component positive), so
/// the feature keeps its turn when an edit rebuilds the edge reversed.
pub fn model_axis(st: &ModelState, g: &GeoRef) -> Result<(Vec3, Vec3)> {
let (o, d) = model_line(st, g)?;
let d = d.normalized().filter(|_| o.is_finite()).ok_or_else(|| bad("the axis has no direction"))?;
Ok((o, canonical_dir(d)))
}
/// `d` or `-d`, whichever has its largest component (the first of equal ones) positive: how
/// [`model_axis`] orients an axis, for a preview of one to point the same way.
pub fn canonical_dir(d: Vec3) -> Vec3 {
let c = [d.x, d.y, d.z];
let big = c.iter().fold(0.0_f64, |m, v| m.max(v.abs()));
match c.iter().find(|v| v.abs() >= big - 1e-9) {
Some(v) if *v < 0.0 => -d,
_ => d,
}
}
/// A reference as a line (origin, unit direction).
pub(crate) fn line(ctx: &Ctx, g: &GeoRef) -> Result<(Vec3, Vec3)> {
match g {
GeoRef::Edge { at, name } => {
let pts = edge_points(ctx.st, *at, name)?;
as_line(&pts).or_else(|| as_circle(&pts).map(|(c, n, _)| (c, n))).ok_or_else(|| bad("the edge is neither straight nor circular"))
}
GeoRef::Edge { .. } | GeoRef::Face { .. } => model_line(ctx.st, g),
GeoRef::SketchCurve { sketch, curve } => {
let pts = sketch_curve_points(ctx, *sketch, curve)?;
as_line(&pts).ok_or_else(|| bad(format!("sketch curve `{curve}` is not a line")))
@@ -330,15 +384,6 @@ pub(crate) fn line(ctx: &Ctx, g: &GeoRef) -> Result<(Vec3, Vec3)> {
ConstructGeom::Axis { origin, dir } => Ok((*origin, *dir)),
_ => Err(bad(format!("`{name}` is not an axis"))),
},
GeoRef::Face { at, name } => {
let (b, fi, _) = face_of(ctx.st, *at, name)?;
match kernel::face_surface(&b.body, fi) {
Some(FaceSurface::Cylinder { origin, axis, .. }) => Ok((origin, *axis)),
Some(FaceSurface::Cone { apex, axis, .. }) => Ok((apex, *axis)),
Some(FaceSurface::Torus { center, axis, .. }) => Ok((center, *axis)),
_ => Err(bad("the face is not a cylinder, cone or torus")),
}
}
_ => Err(bad("pick an edge, line or axis")),
}
}
@@ -602,6 +647,20 @@ pub(crate) fn resolve_geo_plane(ctx: &Ctx, p: &PlaneRef) -> Result<Plane> {
}
impl GeoRef {
/// Where a picked edge or face is now, found the way evaluation finds it (by its persistent
/// name, else at the picked point): a point on it. `None` for other references and for an
/// edge or face that is gone.
pub fn picked_point(&self, st: &ModelState) -> Option<Vec3> {
match self {
GeoRef::Edge { at, name } => {
let on = name.as_deref().and_then(|n| bodies(st).find_map(|b| crate::naming::find_edge(b, n, *at).ok())).map_or(*at, |(q, _)| q);
edge_pick(st, on, &None).ok().map(|_| on)
}
GeoRef::Face { at, name } => face_of(st, *at, name).ok().map(|(_, _, p)| p),
_ => None,
}
}
/// Map the reference's world points (component frames).
pub fn map_points(&mut self, pt: &mut dyn FnMut(&mut Vec3), plane: &mut dyn FnMut(&mut PlaneRef)) {
match self {
@@ -710,7 +769,12 @@ impl PlaneRef {
refs.push(point.as_mut());
refs
}
PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => base.refs_mut(),
PlaneRef::AtAngle { base, line, .. } => {
let mut v = base.refs_mut();
v.extend(line.as_deref_mut());
v
}
PlaneRef::Offset { base, .. } | PlaneRef::Flipped { base, .. } => base.refs_mut(),
_ => Vec::new(),
}
}
+28 -4
View File
@@ -57,8 +57,17 @@ pub enum PlaneRef {
/// Another plane moved along its normal until it goes through a point (a vertex, sketch
/// point or construction point), so it follows the point.
ThroughPoint { base: Box<PlaneRef>, point: Box<GeoRef> },
/// Another plane rotated about a line (in world coordinates) by an angle expression.
AtAngle { base: Box<PlaneRef>, axis_origin: Vec3, axis_dir: Vec3, angle: Expr },
/// Another plane rotated about a line (in world coordinates) by an angle expression. With
/// `line`, an edge or round face of the model ([`crate::construct::model_axis`]), the line is
/// found there on each evaluation and `axis_origin`/`axis_dir` are where it was when picked.
AtAngle {
base: Box<PlaneRef>,
axis_origin: Vec3,
axis_dir: Vec3,
angle: Expr,
#[serde(default, skip_serializing_if = "Option::is_none")]
line: Option<Box<GeoRef>>,
},
/// A construction plane feature (by name).
Construction { name: FeatureName },
/// `base` seen from its other side: the normal reversed by a half turn about the base's
@@ -394,6 +403,9 @@ pub enum AxisRef {
World { axis: String },
/// Any line in the sketch plane, in world coordinates.
Line { origin: Position, dir: Dir },
/// An edge or round face of the model (a straight or circular edge, a cylinder, cone or
/// torus face), found again on each evaluation: [`crate::construct::model_axis`].
Model { geo: GeoRef },
/// A construction axis feature, by name, where it is when the revolve is evaluated.
Construction { name: FeatureName },
}
@@ -2152,6 +2164,11 @@ pub enum PatternKind {
alignment: solidcraft_sketch::PatternAlignment,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
reversed: bool,
/// The edge or round face of the model the copies turn about, found again on each
/// evaluation ([`crate::construct::model_axis`]); `origin` and `axis` are where it was
/// when picked.
#[serde(default, skip_serializing_if = "Option::is_none")]
axis_ref: Option<GeoRef>,
/// A construction axis the copies turn about, by name, followed when it moves;
/// `origin` and `axis` are where it was when the pattern was made.
#[serde(default, skip_serializing_if = "Option::is_none")]
@@ -3675,12 +3692,19 @@ impl Document {
let b = self.resolve_plane_in(vals, base, depth + 1, st)?;
Ok(b.offset(Self::eval_in(vals, distance, Kind::Length)?))
}
PlaneRef::AtAngle { base, axis_origin, axis_dir, angle } => {
PlaneRef::AtAngle { base, axis_origin, axis_dir, angle, line } => {
let b = self.resolve_plane_in(vals, base, depth + 1, st)?;
let a = Self::eval_in(vals, angle, Kind::Angle)?;
let (axis_origin, axis_dir) = match line {
Some(g) => {
let st = st.ok_or_else(|| DocError::Invalid("this plane is built from the model: evaluate first".into()))?;
crate::construct::model_axis(st, g)?
}
None => (*axis_origin, *axis_dir),
};
let d = axis_dir.normalized().ok_or_else(|| DocError::Invalid("rotation axis".into()))?;
let rot = |v: Vec3| v * a.cos() + d.cross(v) * a.sin() + d * (d.dot(v) * (1.0 - a.cos()));
let o = *axis_origin + rot(b.origin - *axis_origin);
let o = axis_origin + rot(b.origin - axis_origin);
Plane::new(o, rot(b.x), rot(b.y)).ok_or_else(|| DocError::Invalid("degenerate plane".into()))
}
PlaneRef::Flipped { base, about_y } => Ok(self.resolve_plane_in(vals, base, depth + 1, st)?.flipped(*about_y)),
+48 -20
View File
@@ -4077,17 +4077,15 @@ fn blend_body(
Ok((Traced::step(nb.with_preserved_planar_sources(&mb.body)?, &[&from]), used, tapered))
}
/// The revolve axis in the sketch's 2D coordinates (a point on it, its direction). `construct`
/// gives a construction axis, by name, in the sketch's 3D frame.
pub(crate) fn revolve_axis(ss: &SolvedSketch, axis: &AxisRef, construct: &dyn Fn(&str) -> Result<(Vec3, Vec3)>) -> Result<(Vec2, Vec2)> {
let in_plane = |origin: Vec3, dir: Vec3| {
let pl = &ss.plane;
let d = dir.normalized().ok_or_else(|| DocError::Invalid("revolve axis has no direction".into()))?;
if d.dot(pl.normal()).abs() > 1e-9 || pl.height(origin).abs() > 1e-6 {
return Err(DocError::Invalid("the revolve axis does not lie in the sketch plane".into()));
}
Ok((pl.to_local(origin), Vec2::new(d.dot(pl.x), d.dot(pl.y))))
};
/// The revolve axis in the sketch's plane coordinates (a point and a direction). `st` is the model
/// an axis on an edge or face of it is found in; `construct` gives a construction axis, by name, in
/// the sketch's 3D frame.
pub(crate) fn revolve_axis(
ss: &SolvedSketch,
axis: &AxisRef,
st: &ModelState,
construct: &dyn Fn(&str) -> Result<(Vec3, Vec3)>,
) -> Result<(Vec2, Vec2)> {
match axis {
AxisRef::SketchLine { curve } => {
let ci = ss.sketch.curve_index(curve).ok_or_else(|| DocError::Unknown(format!("sketch line `{curve}`")))?;
@@ -4117,14 +4115,38 @@ pub(crate) fn revolve_axis(ss: &SolvedSketch, axis: &AxisRef, construct: &dyn Fn
}
Ok((pl.to_local(Vec3::ZERO), Vec2::new(d.dot(pl.x), d.dot(pl.y))))
}
AxisRef::Line { origin, dir } => in_plane(origin.0, dir.0),
AxisRef::Line { origin, dir } => line_in_sketch_plane(ss, origin.0, dir.0),
AxisRef::Model { geo } => {
let (o, d) = crate::construct::model_axis(st, geo)?;
line_in_sketch_plane(ss, o, d)
}
AxisRef::Construction { name } => {
let (origin, dir) = construct(name)?;
in_plane(origin, dir)
let (o, d) = construct(name)?;
line_in_sketch_plane(ss, o, d)
}
}
}
/// The model a revolve axis is found in: what construction geometry of component `comp` is built
/// on when the axis is an edge or face of it (only then is it worth placing).
pub(super) fn axis_state<'a>(doc: &Document, st: &'a ModelState, comp: u64, axis: &AxisRef) -> std::borrow::Cow<'a, ModelState> {
match axis {
AxisRef::Model { .. } => construction_state(doc, st, comp),
_ => std::borrow::Cow::Borrowed(st),
}
}
/// A world line through `origin` along `dir` in the sketch's plane coordinates, or an error when it
/// does not lie in the sketch plane.
fn line_in_sketch_plane(ss: &SolvedSketch, origin: Vec3, dir: Vec3) -> Result<(Vec2, Vec2)> {
let pl = &ss.plane;
let d = dir.normalized().ok_or_else(|| DocError::Invalid("revolve axis has no direction".into()))?;
if d.dot(pl.normal()).abs() > 1e-9 || pl.height(origin).abs() > 1e-6 {
return Err(DocError::Invalid("the revolve axis does not lie in the sketch plane".into()));
}
Ok((pl.to_local(origin), Vec2::new(d.dot(pl.x), d.dot(pl.y))))
}
/// A construction axis `name` of the timeline so far, as evaluated, in the frame of component
/// `comp`: a point on it and its direction. Without a document (`doc` None) it is taken in its
/// own component's frame.
@@ -5286,7 +5308,8 @@ fn feature_tools_with_constructor(
f.component,
)?;
let regions = solidcraft_sketch::merge_regions(&select_profiles(&ss, profiles)?);
let (o, d) = revolve_axis(&ss, axis, &|name| construction_axis_in(Some(doc), st, name, f.component))?;
let (o, d) =
revolve_axis(&ss, axis, &axis_state(doc, st, f.component, axis), &|name| construction_axis_in(Some(doc), st, name, f.component))?;
// To Object is in this feature's component frame: the model as seen from there.
let tst = if to.is_some() { state_in_frame(doc, st, f.component) } else { std::borrow::Cow::Borrowed(st) };
// Where the tool meets its targets is measured where they are shown (#3383).
@@ -6100,10 +6123,12 @@ fn pattern_transforms(doc: &Document, vals: &BTreeMap<String, Value>, st: &Model
out.push(m);
}
}
crate::PatternKind::Circular { origin, axis, count: c, angle, alignment, reversed, axis_feature } => {
let (origin, axis) = match axis_feature {
Some(name) => construction_axis_in(Some(doc), st, name, component)?,
None => (origin.0, axis.0),
crate::PatternKind::Circular { origin, axis, count: c, angle, alignment, reversed, axis_ref, axis_feature } => {
// On an edge or round face: about it as it is now; on a construction axis: where it is.
let (origin, axis) = match (axis_ref, axis_feature) {
(Some(g), _) => crate::construct::model_axis(&construction_state(doc, st, component), g)?,
(None, Some(name)) => construction_axis_in(Some(doc), st, name, component)?,
(None, None) => (origin.0, axis.0),
};
let n = count(c)?;
let total = val(vals, angle, Kind::Angle)?;
@@ -6773,11 +6798,12 @@ pub(crate) fn sheet_face_plane_in_frame(doc: &Document, st: &ModelState, comp: u
PlaneRef::Offset { base, distance } => {
PlaneRef::Offset { base: Box::new(sheet_face_plane_in_frame(doc, st, comp, base)?), distance: distance.clone() }
}
PlaneRef::AtAngle { base, axis_origin, axis_dir, angle } => PlaneRef::AtAngle {
PlaneRef::AtAngle { base, axis_origin, axis_dir, angle, line } => PlaneRef::AtAngle {
base: Box::new(sheet_face_plane_in_frame(doc, st, comp, base)?),
axis_origin: *axis_origin,
axis_dir: *axis_dir,
angle: angle.clone(),
line: line.clone(),
},
PlaneRef::Flipped { base, about_y } => {
PlaneRef::Flipped { base: Box::new(sheet_face_plane_in_frame(doc, st, comp, base)?), about_y: *about_y }
@@ -7770,6 +7796,7 @@ fn construction_state<'a>(doc: &Document, st: &'a ModelState, comp: u64) -> std:
fn plane_is_fixed(plane: &PlaneRef) -> bool {
match plane {
PlaneRef::Origin { .. } | PlaneRef::Custom { .. } | PlaneRef::Placed { .. } => true,
PlaneRef::AtAngle { line: Some(_), .. } => false,
PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => plane_is_fixed(base),
_ => false,
}
@@ -7780,6 +7807,7 @@ fn plane_is_fixed(plane: &PlaneRef) -> bool {
fn plane_reads_geometry(plane: &PlaneRef) -> bool {
match plane {
PlaneRef::Origin { .. } | PlaneRef::Custom { .. } | PlaneRef::Placed { .. } | PlaneRef::Construction { .. } => false,
PlaneRef::AtAngle { line: Some(_), .. } => true,
PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => plane_reads_geometry(base),
PlaneRef::ThroughPoint { .. }
| PlaneRef::Midplane { .. }
+3 -1
View File
@@ -304,7 +304,9 @@ pub(super) fn eval(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature,
st.sketch(sketch.0).ok_or_else(|| DocError::Unknown(format!("sketch {sketch} (it must come earlier in the timeline)")))?,
f.component,
)?;
let (o, d) = revolve_axis(&ss, axis, &|name| construction_axis_in(Some(doc), st, name, f.component))?;
let (o, d) = revolve_axis(&ss, axis, &super::axis_state(doc, st, f.component, axis), &|name| {
construction_axis_in(Some(doc), st, name, f.component)
})?;
let a = val(vals, angle, Kind::Angle)?;
let (start, sweep) = match (angle2, symmetric) {
(Some(a2), _) => {
@@ -0,0 +1,7 @@
//! A Revolve, Surface Revolve, Circular Pattern or Plane at Angle can turn about an edge or round
//! face of the model, kept as a reference (`AxisRef::Model`, a pattern's `axis_ref`, an angle
//! plane's `line`: a circular edge's axis through its centre, a cylinder's, cone's or torus's
//! axis, or a straight edge), found again by its persistent name on each evaluation so the
//! feature follows the edge or face when the model changes. Older designs need no
//! transformation: their axes stay the fixed lines or named axes they were saved with. The last
//! release refuses a design saved with this (the newer format number).
+1 -1
View File
@@ -696,7 +696,7 @@ fn role_name(f: &Feature, before: &ModelState, ps: &[Vec3], ns: &[Vec3], fi: usi
}
FeatureKind::Revolve { sketch, axis, .. } => {
let Some(ss) = before.sketch(sketch.0) else { return format!("F{fid}:face:{fi}") };
let Ok((o2, d2)) = crate::eval::revolve_axis(ss, axis, &|name| crate::eval::construction_axis_in(None, before, name, 0)) else {
let Ok((o2, d2)) = crate::eval::revolve_axis(ss, axis, before, &|name| crate::eval::construction_axis_in(None, before, name, 0)) else {
return format!("F{fid}:face:{fi}");
};
let (o, d) = (ss.plane.to_world(o2), (ss.plane.to_world(o2 + d2) - ss.plane.to_world(o2)).normalized().unwrap_or(Vec3::Z));
+31 -2
View File
@@ -394,11 +394,17 @@ impl PlaneRef {
}
match self {
Self::Construction { name } => f(Ref::Feature(name)),
Self::Offset { base, .. } | Self::AtAngle { base, .. } | Self::Flipped { base, .. } => base.walk_feature_refs(f, depth + 1),
Self::Offset { base, .. } | Self::Flipped { base, .. } => base.walk_feature_refs(f, depth + 1),
Self::ThroughPoint { base, point } => {
base.walk_feature_refs(f, depth + 1);
point.walk_feature_refs(f, depth + 1);
}
Self::AtAngle { base, line, .. } => {
base.walk_feature_refs(f, depth + 1);
if let Some(g) = line {
g.walk_feature_refs(f, depth + 1);
}
}
Self::Midplane { a, b } | Self::TwoEdges { a, b } | Self::Perpendicular { plane: a, line: b } => {
a.walk_feature_refs(f, depth + 1);
b.walk_feature_refs(f, depth + 1);
@@ -419,11 +425,17 @@ impl PlaneRef {
}
match self {
Self::Construction { name } => f(Ref::Feature(name)),
Self::Offset { base, .. } | Self::AtAngle { base, .. } | Self::Flipped { base, .. } => base.walk_feature_refs_mut(f, depth + 1),
Self::Offset { base, .. } | Self::Flipped { base, .. } => base.walk_feature_refs_mut(f, depth + 1),
Self::ThroughPoint { base, point } => {
base.walk_feature_refs_mut(f, depth + 1);
point.walk_feature_refs_mut(f, depth + 1);
}
Self::AtAngle { base, line, .. } => {
base.walk_feature_refs_mut(f, depth + 1);
if let Some(g) = line {
g.walk_feature_refs_mut(f, depth + 1);
}
}
Self::Midplane { a, b } | Self::TwoEdges { a, b } | Self::Perpendicular { plane: a, line: b } => {
a.walk_feature_refs_mut(f, depth + 1);
b.walk_feature_refs_mut(f, depth + 1);
@@ -532,6 +544,23 @@ impl Walk for AxisDef {
construct_geometry!();
}
/// A feature's own reference to the model (a revolve's or circular pattern's axis on an edge or
/// round face): walked like a construction axis's.
impl Walk for GeoRef {
fn walk_exprs<'a>(&'a self, f: &mut dyn FnMut(ExprItem<'a>)) {
plane_exprs(vec![self], f)
}
fn walk_exprs_mut<'a>(&'a mut self, f: &mut dyn FnMut(ExprItemMut<'a>)) {
plane_exprs_mut(vec![self], f)
}
fn walk_geometry<'a>(&'a self, f: &mut dyn FnMut(GeoItem<'a>)) {
f(Geo::Construct(self))
}
fn walk_geometry_mut<'a>(&'a mut self, f: &mut dyn FnMut(GeoItemMut<'a>)) {
f(Geo::Construct(self))
}
}
impl Walk for PointDef {
fn walk_exprs<'a>(&'a self, f: &mut dyn FnMut(ExprItem<'a>)) {
match self {
+13
View File
@@ -9,6 +9,7 @@
use serde_json::Value;
use solidcraft_doc::construct::{AxisDef, GeoRef, PointDef};
use solidcraft_doc::{FeatureKind, PlaneRef};
use solidcraft_geom::Vec3;
use super::CommandSpec;
use super::features::{add_feature, check_expr, plane_param, sketch_id};
@@ -88,6 +89,18 @@ pub static COMMANDS: &[CommandSpec] = &[
),
];
/// An axis on an edge or round face of the model (`{edge: [x,y,z]}` or `{face: [x,y,z]}`, the
/// point on it), with the line it gives now (`solidcraft_doc::construct::model_axis`); `None`
/// for any other form of `axis`.
pub(super) fn model_axis_param(s: &Session, v: Option<&Value>, cmd: &str) -> Result<Option<(GeoRef, Vec3, Vec3)>> {
// Also as saved (`{type: edge|face, at, name?}`), as an edit dialog gives back one it kept.
let saved = |v: &Value| matches!(v.get("type").and_then(Value::as_str), Some("edge" | "face"));
let Some(v) = v.filter(|v| v.get("edge").is_some() || v.get("face").is_some() || saved(v)) else { return Ok(None) };
let g = geo(s, Some(v), cmd, "axis")?;
let (o, d) = solidcraft_doc::construct::model_axis(&s.world_state(), &g).map_err(|e| bad(cmd, format!("`axis`: {e}")))?;
Ok(Some((g, o, d)))
}
/// A reference from its JSON form.
pub(super) fn geo(s: &Session, v: Option<&Value>, cmd: &str, what: &str) -> Result<GeoRef> {
let v = v.ok_or_else(|| bad(cmd, format!("`{what}` is required: {REF}")))?;
+37 -18
View File
@@ -29,7 +29,7 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("solid.revolve", "Revolve", revolve)
.at("SOLID", "CREATE")
.icon("revolve")
.params("axis: sketch line id | x | y (sketch axes) | X|Y|Z (world) | construction axis name (followed when edited) | {origin, dir}; angle?: expr (default 360 deg); angle2?: expr (Two Sides: the other side's angle); direction?: symmetric (angle split either side, independent of axis direction); convention?: sketch_normal|legacy_axis_start (default sketch_normal; legacy retains older angular starts); to?: [x,y,z] (To Object: turn until that face, vertex or point); sketch?, profiles? | face: [x,y,z] (a planar body face as the profile) and face_body?: name (whose face, where faces of several bodies meet), operation?, targets?, name?, body_name?"),
.params("axis: sketch line id | x | y (sketch axes) | X|Y|Z (world) | construction axis name (followed when edited) | {origin, dir} | {edge|face: [x,y,z]} (a straight or circular edge, or a cylinder, cone or torus face: about its axis, followed as the model changes); angle?: expr (default 360 deg); angle2?: expr (Two Sides: the other side's angle); direction?: symmetric (angle split either side, independent of axis direction); convention?: sketch_normal|legacy_axis_start (default sketch_normal; legacy retains older angular starts); to?: [x,y,z] (To Object: turn until that face, vertex or point); sketch?, profiles? | face: [x,y,z] (a planar body face as the profile) and face_body?: name (whose face, where faces of several bodies meet), operation?, targets?, name?, body_name?"),
CommandSpec::new("solid.sweep", "Sweep", sweep)
.at("SOLID", "CREATE")
.icon("sweep")
@@ -58,7 +58,7 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("solid.pattern.circular", "Circular Pattern", pattern_circ)
.at("SOLID", "CREATE")
.icon("pattern_circ")
.params("features: [names] | bodies: [names] | components: [names]; axis: X|Y|Z | construction axis name (followed when edited) | {origin, dir}; count; angle? (default 360 deg; partial arcs include both ends); alignment?: left|center|right (default right; original stays fixed); reversed?: bool (Flip; selects the extra side for even centered counts)"),
.params("features: [names] | bodies: [names] | components: [names]; axis: X|Y|Z | construction axis name (followed when edited) | {origin, dir} | {edge|face: [x,y,z]} (a straight or circular edge, or a cylinder, cone or torus face: about its axis, followed as the model changes); count; angle? (default 360 deg; partial arcs include both ends); alignment?: left|center|right (default right; original stays fixed); reversed?: bool (Flip; selects the extra side for even centered counts)"),
CommandSpec::new("solid.pattern.path", "Pattern on Path", pattern_path)
.at("SOLID", "CREATE")
.icon("pattern_path")
@@ -108,7 +108,7 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("construct.plane.at_angle", "Plane at Angle", plane_angle)
.at("SOLID", "CONSTRUCT")
.icon("plane_angle")
.params("base: XY|XZ|YZ|plane name, or a planar face {face: [x,y,z], body?, index?, path?}; axis: X|Y|Z|construction axis name (where it is now)|{origin, dir}; angle: expr; name?"),
.params("base: XY|XZ|YZ|plane name, or a planar face {face: [x,y,z], body?, index?, path?}; axis: X|Y|Z|construction axis name (where it is now)|{origin, dir} | {edge|face: [x,y,z]} (a straight or circular edge, or a cylinder, cone or torus face: about its axis, followed as the model changes); angle: expr; name?"),
CommandSpec::new("solid.split_face", "Split Face", split_face)
.at("SOLID", "MODIFY")
.icon("split_face")
@@ -1171,9 +1171,13 @@ fn revolve(s: &mut Session, p: &Value) -> Result<Value> {
}
/// A revolve axis of `sketch` from its parameter: a sketch line id, the sketch's x or y axis, a
/// world axis, a construction axis by name (followed when it is edited) or {origin, dir}. A line
/// of the sketch wins over a construction axis of the same name.
/// world axis, a construction axis by name (followed when it is edited), {origin, dir}, or an edge
/// or round face of the model ({edge|face: [x,y,z]}), which the revolve follows as the model
/// changes. A line of the sketch wins over a construction axis of the same name.
pub(super) fn axis_param(s: &Session, sketch: u64, p: &Value, cmd: &str) -> Result<AxisRef> {
if let Some((geo, ..)) = super::construct::model_axis_param(s, p.get("axis"), cmd)? {
return Ok(AxisRef::Model { geo });
}
if let Some(o) = p.get("axis").filter(|v| v.is_object()) {
let origin = o.get("origin").and_then(vec3).unwrap_or(Vec3::ZERO);
let dir = o.get("dir").and_then(vec3).ok_or_else(|| bad(cmd, "axis needs `dir`"))?;
@@ -1184,7 +1188,9 @@ pub(super) fn axis_param(s: &Session, sketch: u64, p: &Value, cmd: &str) -> Resu
Some(a @ ("x" | "y")) => Ok(AxisRef::SketchAxis { axis: a.into() }),
Some(name) if !is_sketch_line(s, sketch, name) && is_construction_axis(s, name) => Ok(AxisRef::Construction { name: name.into() }),
Some(id) => Ok(AxisRef::SketchLine { curve: id.into() }),
None => Err(bad(cmd, "`axis` must be a sketch line id, x, y (sketch axes), X, Y, Z, a construction axis or {origin, dir}")),
None => {
Err(bad(cmd, "`axis` must be a sketch line id, x, y (sketch axes), X, Y, Z, a construction axis, {origin, dir} or {edge|face: [x,y,z]}"))
}
}
}
@@ -1773,9 +1779,19 @@ fn source_features(s: &Session, p: &Value, cmd: &str) -> Result<Vec<String>> {
Ok(names)
}
/// An axis line from its parameter, with what it follows: an edge or round face of the model
/// ({edge|face: [x,y,z]}) or a construction axis by name ([`named_axis_line`]).
fn axis_line(s: &Session, p: &Value, cmd: &str) -> Result<(Vec3, Vec3, Option<solidcraft_doc::construct::GeoRef>, Option<FeatureName>)> {
if let Some((geo, o, d)) = super::construct::model_axis_param(s, p.get("axis"), cmd)? {
return Ok((o, d, Some(geo), None));
}
let (o, d, name) = named_axis_line(s, p, cmd)?;
Ok((o, d, None, name))
}
/// An axis line from `axis`: X, Y, Z, a construction axis by name or {origin, dir}. A construction
/// axis comes back where it is now, with its name.
fn axis_line(s: &Session, p: &Value, cmd: &str) -> Result<(Vec3, Vec3, Option<FeatureName>)> {
fn named_axis_line(s: &Session, p: &Value, cmd: &str) -> Result<(Vec3, Vec3, Option<FeatureName>)> {
match p.get("axis") {
Some(Value::String(a)) => match a.to_ascii_uppercase().as_str() {
"X" => Ok((Vec3::ZERO, Vec3::X, None)),
@@ -1788,7 +1804,7 @@ fn axis_line(s: &Session, p: &Value, cmd: &str) -> Result<(Vec3, Vec3, Option<Fe
.ok_or_else(|| bad(cmd, format!("construction axis `{a}` has no geometry: fix its definition first")))?;
Ok((origin, dir, Some(a.as_str().into())))
}
_ => Err(bad(cmd, "axis must be X, Y, Z, a construction axis or {origin, dir}")),
_ => Err(bad(cmd, "axis must be X, Y, Z, a construction axis, {origin, dir} or {edge|face: [x,y,z]}")),
},
Some(o @ Value::Object(_)) => {
let origin = match o.get("origin") {
@@ -1882,7 +1898,7 @@ fn pattern_rect(s: &mut Session, p: &Value) -> Result<Value> {
fn pattern_circ(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "solid.pattern.circular";
let (features, bodies) = pattern_sources(s, p, cmd)?;
let (origin, axis, axis_feature) = axis_line(s, p, cmd)?;
let (origin, axis, axis_ref, axis_feature) = axis_line(s, p, cmd)?;
let count = req_expr(cmd, p, "count")?;
check_expr(s, &count, Kind::Unitless, cmd, "count")?;
let angle = expr(p, "angle").unwrap_or_else(|| "360 deg".into());
@@ -1894,6 +1910,7 @@ fn pattern_circ(s: &mut Session, p: &Value) -> Result<Value> {
angle,
alignment: super::alignment_param(p, "alignment", cmd)?,
reversed: super::reversed_param(p, "reversed", cmd)?,
axis_ref,
axis_feature,
};
finish_pattern(s, p, features, pattern, bodies)
@@ -2086,24 +2103,22 @@ fn plane_offset(s: &mut Session, p: &Value) -> Result<Value> {
fn plane_angle(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "construct.plane.at_angle";
// The plane keeps the axis line as it is now.
let (axis_origin, axis_dir, _) = axis_line(s, p, cmd)?;
// The plane follows an edge or face it is on; a construction axis is kept as it is now.
let (axis_origin, axis_dir, line, _) = axis_line(s, p, cmd)?;
let angle = req_expr(cmd, p, "angle")?;
check_expr(s, &angle, Kind::Angle, cmd, "angle")?;
let line = line.map(Box::new);
// A planar body face: attached exactly, as a sketch on that face is, so the plane follows it.
if let Some(face) = p.get("base").filter(|b| b.get("face").is_some()) {
let base = super::sketch::face::capture(s, face, cmd)?;
super::sketch::face::capture_positions(s, &base)?;
let kind = FeatureKind::ConstructionPlane { plane: solidcraft_doc::PlaneRef::AtAngle { base: Box::new(base), axis_origin, axis_dir, angle } };
let plane = solidcraft_doc::PlaneRef::AtAngle { base: Box::new(base), axis_origin, axis_dir, angle, line };
// The capture is already in the authoring frame.
return add_feature_in(s, p, kind, false);
return add_feature_in(s, p, FeatureKind::ConstructionPlane { plane }, false);
}
let base = plane_param(s, p.get("base"), cmd)?;
add_feature(
s,
p,
FeatureKind::ConstructionPlane { plane: solidcraft_doc::PlaneRef::AtAngle { base: Box::new(base), axis_origin, axis_dir, angle } },
)
let plane = solidcraft_doc::PlaneRef::AtAngle { base: Box::new(base), axis_origin, axis_dir, angle, line };
add_feature(s, p, FeatureKind::ConstructionPlane { plane })
}
fn split_face(s: &mut Session, p: &Value) -> Result<Value> {
@@ -2878,6 +2893,10 @@ fn offset_face(s: &mut Session, p: &Value) -> Result<Value> {
#[path = "patterns_tests.rs"]
mod patterns_tests;
#[cfg(test)]
#[path = "model_axis_tests.rs"]
mod model_axis_tests;
#[cfg(test)]
#[path = "prism_local_tests.rs"]
mod prism_local_tests;
+197
View File
@@ -0,0 +1,197 @@
//! An axis on an edge or round face of the model (`{edge|face: [x,y,z]}`): Revolve, Surface
//! Revolve, Circular Pattern and Plane at Angle turn about a circular edge's or a cylinder's
//! axis, and follow it when a parameter moves the cylinder.
use std::f64::consts::PI;
use serde_json::{Value, json};
use solidcraft_geom::Vec3;
use crate::Session;
use crate::view::construction_planes;
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 volume(s: &mut Session) -> f64 {
run(s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN)
}
fn rel(a: f64, b: f64) -> f64 {
(a - b).abs() / b.abs().max(1e-12)
}
/// A Ø10 × 10 shaft standing on XY at x = `cx` (a parameter, 40 mm).
fn shaft() -> Session {
let mut s = Session::default();
run(&mut s, "parameters.add", json!({"name": "cx", "expression": "40 mm"}));
run(&mut s, "solid.cylinder", json!({"base": ["cx", 0, 0], "radius": 5, "height": 10, "body_name": "Shaft"}));
s
}
const SHAFT: f64 = PI * 25.0 * 10.0;
/// A 2 × 6 rectangle on XZ, x 46…48, z 2…8: 6 to 8 mm from the shaft's axis.
fn ring_profile(s: &mut Session) {
run(s, "sketch.create", json!({"plane": "XZ", "name": "Profile"}));
run(s, "sketch.rectangle.two_point", json!({"p0": [46, -2], "p1": [48, -8]}));
run(s, "sketch.finish", json!({}));
}
/// Pappus: a 2 × 6 section whose centre is `r` from the axis, turned a full turn.
fn ring(r: f64) -> f64 {
2.0 * PI * r * 12.0
}
#[test]
fn revolve_about_a_circular_edge_follows_the_cylinder() {
let mut s = shaft();
ring_profile(&mut s);
// The shaft's top rim.
run(&mut s, "solid.revolve", json!({"sketch": "Profile", "axis": {"edge": [45, 0, 10]}, "operation": "new", "name": "Turn"}));
assert!(rel(volume(&mut s), SHAFT + ring(7.0)) < 1e-4, "turned about the shaft's axis: {}", volume(&mut s));
run(&mut s, "parameters.change", json!({"name": "cx", "expression": "40.5 mm"}));
assert!(rel(volume(&mut s), SHAFT + ring(6.5)) < 1e-4, "follows the shaft: {}", volume(&mut s));
// Saved and opened again it still follows.
let saved = s.doc.to_json();
let mut reopened = Session::new(solidcraft_doc::Document::from_json(&saved).unwrap());
assert!(rel(volume(&mut reopened), volume(&mut s)) < 1e-9);
run(&mut reopened, "parameters.change", json!({"name": "cx", "expression": "40 mm"}));
assert!(rel(volume(&mut reopened), SHAFT + ring(7.0)) < 1e-4);
}
#[test]
fn revolve_about_a_cylinder_wall() {
let mut s = shaft();
ring_profile(&mut s);
run(&mut s, "solid.revolve", json!({"sketch": "Profile", "axis": {"face": [45, 0, 5]}, "operation": "new"}));
assert!(rel(volume(&mut s), SHAFT + ring(7.0)) < 1e-4, "{}", volume(&mut s));
let Some(solidcraft_doc::Feature { kind: solidcraft_doc::FeatureKind::Revolve { axis, .. }, .. }) = s.doc.features.last() else {
panic!("no revolve")
};
assert!(matches!(axis, solidcraft_doc::AxisRef::Model { .. }), "kept as a reference: {axis:?}");
}
#[test]
fn surface_revolve_about_a_circular_edge() {
let mut s = shaft();
ring_profile(&mut s);
run(&mut s, "surface.revolve", json!({"sketch": "Profile", "axis": {"edge": [45, 0, 0]}, "angle": "180 deg"}));
run(&mut s, "parameters.change", json!({"name": "cx", "expression": "41 mm"}));
let st = s.world_state();
// A half turn about x = 41: the far side of the profile ends up at x = 41 − 7 ± 1.
let b = st.bodies.last().map(|b| b.mesh().bounds()).unwrap();
assert!((b.min.x - (41.0 - 7.0)).abs() < 1e-3, "{b:?}");
assert!((b.max.x - 48.0).abs() < 1e-3, "{b:?}");
}
#[test]
fn circular_pattern_about_a_boss_wall_follows_the_boss() {
let mut s = Session::default();
run(&mut s, "parameters.add", json!({"name": "cx", "expression": "100 mm"}));
run(&mut s, "solid.box", json!({"length": 200, "width": 200, "height": 5, "corner": [0, 0, 0], "body_name": "Plate"}));
run(&mut s, "solid.cylinder", json!({"base": ["cx", 100, 0], "radius": 10, "height": 20, "operation": "join", "targets": ["Plate"]}));
run(&mut s, "solid.hole", json!({"position": [130, 100, 5], "diameter": 2, "name": "Hole"}));
run(&mut s, "solid.pattern.circular", json!({"features": ["Hole"], "axis": {"face": [110, 100, 10]}, "count": 4, "name": "Ring"}));
let holes = |s: &Session, cx: f64, r: f64| {
let st = s.world_state();
let body = &st.bodies[0].body;
[(r, 0.0), (0.0, r), (-r, 0.0), (0.0, -r)].iter().all(|(dx, dy)| !body.contains(Vec3::new(cx + dx, 100.0 + dy, 2.5)))
};
assert!(holes(&s, 100.0, 30.0), "four holes round the boss");
run(&mut s, "parameters.change", json!({"name": "cx", "expression": "90 mm"}));
assert!(holes(&s, 90.0, 40.0), "the copies turn about the boss where it is now");
let st = s.world_state();
assert!(st.bodies[0].body.contains(Vec3::new(100.0, 130.0, 2.5)), "not where the boss was");
}
#[test]
fn plane_at_angle_about_a_cylinder_axis_follows_it() {
let mut s = shaft();
run(&mut s, "construct.plane.at_angle", json!({"base": "XZ", "axis": {"face": [45, 0, 5]}, "angle": "90 deg", "name": "Square"}));
let plane = |s: &Session| construction_planes(s).into_iter().find(|p| p.1 == "Square").map(|p| p.2).unwrap();
let pl = plane(&s);
assert!(pl.normal().cross(Vec3::X).len() < 1e-9, "turned square to XZ about Z: {pl:?}");
assert!(pl.height(Vec3::new(40.0, 0.0, 0.0)).abs() < 1e-6, "through the shaft's axis: {pl:?}");
run(&mut s, "parameters.change", json!({"name": "cx", "expression": "25 mm"}));
assert!(plane(&s).height(Vec3::new(25.0, 0.0, 0.0)).abs() < 1e-6, "follows the shaft");
}
#[test]
fn plane_at_angle_on_a_face_about_an_edge_follows_both() {
let mut s = Session::default();
run(&mut s, "parameters.add", json!({"name": "h", "expression": "20 mm"}));
run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": "h", "name": "Base"}));
// The top face, turned 45° about its front edge (y = 0, along X).
run(
&mut s,
"construct.plane.at_angle",
json!({"base": {"face": [5, 5, 20]}, "axis": {"edge": [20, 0, 20]}, "angle": "45 deg", "name": "Slanted"}),
);
let feature = s.doc.find_feature("Slanted").unwrap();
let solidcraft_doc::FeatureKind::ConstructionPlane { plane: solidcraft_doc::PlaneRef::AtAngle { base, line, .. } } = &feature.kind else {
panic!("at_angle plane: {:?}", feature.kind)
};
assert!(matches!(base.as_ref(), solidcraft_doc::PlaneRef::Face { anchor: Some(_), .. }), "{base:?}");
assert!(line.is_some(), "the edge is kept as a model reference");
let plane = |s: &Session| construction_planes(s).into_iter().find(|p| p.1 == "Slanted").map(|p| p.2).unwrap();
let half = 0.5_f64.sqrt();
let pl = plane(&s);
assert!(pl.height(Vec3::new(20.0, 0.0, 20.0)).abs() < 1e-6, "through the edge: {pl:?}");
assert!((pl.normal().z.abs() - half).abs() < 1e-9 && pl.normal().x.abs() < 1e-9, "45° to the top: {pl:?}");
// A taller box: the face and the edge both move up.
run(&mut s, "parameters.change", json!({"name": "h", "expression": "30 mm"}));
let pl = plane(&s);
assert!(pl.height(Vec3::new(20.0, 0.0, 30.0)).abs() < 1e-6, "follows the edge: {pl:?}");
assert!((pl.normal().z.abs() - half).abs() < 1e-9, "{pl:?}");
}
#[test]
fn the_axis_keeps_its_turn_whichever_way_the_edge_runs() {
// The top and bottom rims run opposite ways round the shaft; a quarter turn about either
// lands in the same place.
let quarter = |edge: [f64; 3]| {
let mut s = shaft();
ring_profile(&mut s);
run(&mut s, "solid.revolve", json!({"sketch": "Profile", "axis": {"edge": edge}, "angle": "90 deg", "operation": "new"}));
let st = s.world_state();
st.bodies.last().map(|b| b.mesh().bounds()).unwrap()
};
let (top, bottom) = (quarter([45.0, 0.0, 10.0]), quarter([45.0, 0.0, 0.0]));
assert!(top.min.dist(bottom.min) < 1e-6 && top.max.dist(bottom.max) < 1e-6, "{top:?} vs {bottom:?}");
}
#[test]
fn hostile_model_axes_are_refused_without_panicking() {
let mut s = shaft();
ring_profile(&mut s);
let before = s.doc.to_json();
for axis in [
json!({"edge": [1e9, 0, 0]}),
json!({"face": [1e300, -1e300, 0]}),
json!({"edge": "top"}),
json!({"face": [45, 0]}),
// The flat top: no axis.
json!({"face": [40, 0, 10]}),
// The shaft's axis doesn't lie in a sketch on XY.
] {
for (cmd, p) in [
("solid.revolve", json!({"sketch": "Profile", "axis": axis})),
("surface.revolve", json!({"sketch": "Profile", "axis": axis})),
("solid.pattern.circular", json!({"bodies": ["Shaft"], "axis": axis, "count": 3})),
("construct.plane.at_angle", json!({"base": "XZ", "axis": axis, "angle": "10 deg"})),
] {
assert!(s.execute(cmd, &p).is_err(), "{cmd} {p}");
assert_eq!(s.doc.to_json(), before, "{cmd} {p} left the design as it was");
}
}
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "Flat"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [46, 2], "p1": [48, 8]}));
run(&mut s, "sketch.finish", json!({}));
let e = s.execute("solid.revolve", &json!({"sketch": "Flat", "axis": {"face": [45, 0, 5]}})).unwrap_err().to_string();
assert!(e.contains("does not lie in the sketch plane"), "{e}");
}
+7 -1
View File
@@ -391,7 +391,13 @@ fn angled_attachment_tracks_source_plane_and_reopens() {
let id = run(&mut s, "sketch.create", json!({"plane":pick,"project_edges":false}))["sketch"].as_u64().unwrap();
run(&mut s, "sketch.finish", json!({}));
let solidcraft_doc::FeatureKind::Sketch { plane, .. } = &mut s.doc_mut().feature_mut(id).unwrap().kind else { panic!("not sketch") };
*plane = solidcraft_doc::PlaneRef::AtAngle { base: Box::new(plane.clone()), axis_origin: Vec3::ZERO, axis_dir: Vec3::X, angle: "90 deg".into() };
*plane = solidcraft_doc::PlaneRef::AtAngle {
base: Box::new(plane.clone()),
axis_origin: Vec3::ZERO,
axis_dir: Vec3::X,
angle: "90 deg".into(),
line: None,
};
s.refresh();
let height = s.doc.find_feature("BaseFeature").unwrap().param_names[2].clone();
run(&mut s, "parameters.change", json!({"name":height,"expression":"20 mm"}));
+1 -1
View File
@@ -43,7 +43,7 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("surface.revolve", "Surface Revolve", surface_revolve)
.at("SURFACE", "CREATE")
.icon("surface_revolve")
.params("sketch?: id|name; curves?: [curve ids] and/or profiles? (as surface.extrude); axis: sketch line id|x|y|X|Y|Z|construction axis name|{origin, dir}; angle?: expr (default 360 deg); angle2?: expr (the other side); symmetric?: bool; name?, body_name? (a surface body, no caps; a solid where a full turn closes it)"),
.params("sketch?: id|name; curves?: [curve ids] and/or profiles? (as surface.extrude); axis: sketch line id|x|y|X|Y|Z|construction axis name|{origin, dir} | {edge|face: [x,y,z]} (a straight or circular edge, or a cylinder, cone or torus face: about its axis, followed as the model changes); angle?: expr (default 360 deg); angle2?: expr (the other side); symmetric?: bool; name?, body_name? (a surface body, no caps; a solid where a full turn closes it)"),
CommandSpec::new("surface.sweep", "Surface Sweep", surface_sweep)
.at("SURFACE", "CREATE")
.icon("surface_sweep")
+216 -44
View File
@@ -15,7 +15,8 @@ use solidcraft_engine::geom::{Aabb3, Vec3};
use crate::SolveApp;
use crate::selection::{
self, AXES, Accept, BODIES, CURVES, EDGES, FACES, PLANAR_FACES, PLANES, PROFILES, SelInput, SelectionExt as _, point_value as pt, polyline_mid,
self, AXES, AXIS_PICKS, Accept, BODIES, CURVES, EDGES, FACES, PLANAR_FACES, PLANES, PROFILES, SelInput, SelectionExt as _, point_value as pt,
polyline_mid,
};
use crate::theme::Tokens;
use crate::tool_modifiers::{Audit, Scope, ToolModifiers};
@@ -110,7 +111,7 @@ crate::dialog_descriptor::dialog_descriptors! {
FeatureKind::ConstructionPlane { plane: PlaneRef::Offset { distance, .. } }) {
offset: String = "0 mm".into() => distance.to_string(),
} => json!({"offset": offset});
AnglePlane("construct.plane.at_angle", "PLANE AT ANGLE", [("Plane", PLANES | PLANAR_FACES, false), ("Axis", AXES, false)],
AnglePlane("construct.plane.at_angle", "PLANE AT ANGLE", [("Plane", PLANES | PLANAR_FACES, false), ("Axis", AXIS_PICKS, false)],
FeatureKind::ConstructionPlane { plane: PlaneRef::AtAngle { angle, .. } }) {
angle: String = "45 deg".into() => angle.to_string(),
} => json!({"angle": angle});
@@ -704,7 +705,7 @@ impl Dialog {
),
"solid.revolve" => Dialog::new(
Kind::Revolve { angle: "360 deg".into(), operation: 0, axis: None },
vec![SelInput::new("Profile", PROFILES | PLANAR_FACES, true), SelInput::new("Axis", AXES, false)],
vec![SelInput::new("Profile", PROFILES | PLANAR_FACES, true), SelInput::new("Axis", AXIS_PICKS, false)],
),
"solid.fillet" => Dialog::new(fillet_kind(&length_default(s, "2"), false), vec![SelInput::new("Edges", EDGES | FACES, true)]),
"solid.chamfer" => Dialog::new(fillet_kind(&length_default(s, "1"), true), vec![SelInput::new("Edges", EDGES | FACES, true)]),
@@ -799,7 +800,7 @@ impl Dialog {
),
"solid.pattern.circular" => Dialog::new(
Kind::PatternCirc { count: "6".into(), angle: "360 deg".into() },
vec![SelInput::new("Objects", BODIES, true), SelInput::new("Axis", AXES, false)],
vec![SelInput::new("Objects", BODIES, true), SelInput::new("Axis", AXIS_PICKS, false)],
),
"solid.loft" => Dialog::new(Kind::Loft { operation: usize::from(has_bodies), rail_fit: 0 }, {
let [rail, rail2] = crate::dialogs_sweep::rail_inputs();
@@ -917,7 +918,10 @@ impl Dialog {
_ => true,
};
let takes = |i: &SelInput| {
fits(i.accept, sel) && (i.multi || i.items.is_empty()) && (planar_ok || i.accept & FACES != 0 || !matches!(sel, Sel::Face { .. }))
fits(i.accept, sel)
&& (i.multi || i.items.is_empty())
&& (planar_ok || i.accept & FACES != 0 || !matches!(sel, Sel::Face { .. }))
&& (i.accept != AXIS_PICKS || takes_as_axis(s, sel))
};
if let Some(inp) = d.inputs.iter_mut().find(|i| takes(i)) {
if matches!(d.kind, Kind::Fillet { .. }) {
@@ -1142,6 +1146,14 @@ impl Dialog {
self.inputs.get(self.active)
}
/// Whether a round edge kept in `inp` stands for its centre: a construction point's input,
/// or Move's pivot and points (`dialogs_move::sel_point`). Other point inputs take the
/// centre as a vertex (`circle_centre_pick`).
pub(crate) fn edge_is_centre(&self, inp: &SelInput) -> bool {
inp.accept != selection::AXIS_PICKS
&& (matches!(self.kind, Kind::Move { .. }) || (matches!(self.kind, Kind::Construct { .. }) && inp.accept & selection::VERTICES != 0))
}
/// Everything the inputs hold (for highlighting).
pub fn items(&self) -> Vec<Sel> {
self.inputs.iter().flat_map(|i| i.items.iter().cloned()).collect()
@@ -1201,8 +1213,8 @@ impl Dialog {
}
/// The face under the cursor (the nearest face the pick ray meets, first among `hits`), looked
/// up once for all the sketch points among `hits` when the active input snaps face places to
/// them (the Single hole's); `None` otherwise.
/// up once for all the sketch points and round edges' centres among `hits` when the active
/// input snaps face places to them (the Single hole's); `None` otherwise.
pub(crate) fn face_snap(&self, s: &Session, hits: &[Hit]) -> Option<FaceSnap> {
if !self.active_input().is_some_and(|i| snaps_to_points(i.accept)) {
return None;
@@ -1213,6 +1225,7 @@ impl Dialog {
.iter()
.filter_map(|h| match h {
Hit::SketchPoint { sketch, at, .. } => st.sketch(*sketch).map(|ss| ss.plane.to_world(*at)),
Hit::Edge { body, index, .. } => edge_circle_in(&st, body, *index).map(|(c, ..)| c),
_ => None,
})
.collect();
@@ -1246,8 +1259,37 @@ impl Dialog {
let snap = snap?;
return snap.place_at(s.world_state().sketch(*sketch)?.plane.to_world(*at));
}
if let Some(sel) = self.circle_centre_pick(s, inp, h, snap) {
return Some(sel);
}
// The snap looked the face under the cursor up already, planar or not.
inp.accepts(h, s.active_sketch, |body, face| snap.and_then(|f| f.planar(body, face)).unwrap_or_else(|| planar_face(s, body, face).is_some()))
let sel = inp.accepts(h, s.active_sketch, |body, face| {
snap.and_then(|f| f.planar(body, face)).unwrap_or_else(|| planar_face(s, body, face).is_some())
})?;
(inp.accept != AXIS_PICKS || takes_as_axis(s, &sel)).then_some(sel)
}
/// A round edge where a 3D point is wanted stands for its centre: a construction point's
/// input keeps the edge (its centre is found again as the model changes), a face place
/// (a hole's) is taken at the centre when it lies on the face under the cursor, and any other
/// point input takes the centre as a point. Inputs that take edges themselves keep the edge
/// (Move's points find its centre, `dialogs_move::sel_point`).
fn circle_centre_pick(&self, s: &Session, inp: &SelInput, h: &Hit, snap: Option<&FaceSnap>) -> Option<Sel> {
let Hit::Edge { body, index, mid } = h else { return None };
let a = inp.accept;
let places = snaps_to_points(a);
if a & EDGES != 0 || (a & selection::VERTICES == 0 && !places) {
return None;
}
let (centre, ..) = edge_circle(s, body, *index)?;
if places {
return snap?.place_at(centre);
}
Some(if matches!(self.kind, Kind::Construct { .. }) {
Sel::Edge { body: body.clone(), index: *index, point: *mid }
} else {
Sel::Vertex { body: body.clone(), point: centre }
})
}
/// With automatic To Object enabled and profiles picked, a face or vertex off their plane,
@@ -1890,6 +1932,8 @@ fn hint(inp: &SelInput) -> &'static str {
let a = inp.accept;
if a & PROFILES != 0 {
"click profiles in the view"
} else if a == AXIS_PICKS {
"click an axis, a sketch line, a straight or circular edge, or a cylinder face"
} else if a & EDGES != 0 {
"click edges or faces"
} else if a & PLANES != 0 {
@@ -2036,7 +2080,7 @@ fn placement_row(d: &mut Dialog, ui: &mut egui::Ui, session: &Session) {
),
1 => (
Kind::PatternCirc { count: "6".into(), angle: "360 deg".into() },
vec![SelInput::new("Objects", BODIES, true), SelInput::new("Axis", AXES, false)],
vec![SelInput::new("Objects", BODIES, true), SelInput::new("Axis", AXIS_PICKS, false)],
),
_ => (
Kind::PathPattern { count: "4".into(), spacing: length_default(session, "20") },
@@ -2068,13 +2112,23 @@ fn placement_row(d: &mut Dialog, ui: &mut egui::Ui, session: &Session) {
}
}
fn selection_label(s: &Session, item: &Sel) -> String {
/// A picked item as its chip shows it. A round edge or face says what it stands for in `inp`:
/// its axis in an axis input, a circle's centre in a point input.
pub(crate) fn selection_label(s: &Session, d: &Dialog, inp: &SelInput, item: &Sel) -> String {
let axis = inp.accept == selection::AXIS_PICKS && round_axis(s, item).is_some();
match item {
Sel::SketchCurve { id, .. } => id.clone(),
Sel::SketchPoint { id } => crate::sketch_modify_ui::point_id(s, item).unwrap_or(id).to_string(),
Sel::Plane { name } | Sel::Axis { name } | Sel::ConstructionPoint { name } | Sel::Body { name } => name.clone(),
Sel::Face { body, index, .. } if axis => format!("{body} · face {index} axis"),
Sel::Face { body, index, .. } => format!("{body} · face {index}"),
Sel::Edge { body, .. } if axis => format!("{body} · circle axis"),
Sel::Edge { body, index, .. } if d.edge_is_centre(inp) && edge_circle(s, body, *index).is_some() => {
format!("{body} · circle centre")
}
Sel::Edge { body, index, .. } => format!("{body} · edge {index}"),
// A point of the model: a vertex, or the centre a round edge stands for.
Sel::Vertex { body, .. } if !body.is_empty() => format!("{body} · point"),
Sel::Feature { id } => s.doc.feature(*id).map(|f| f.name.clone()).unwrap_or_else(|| format!("Feature {id}")),
Sel::Vertex { body, point } if body.is_empty() => {
let state = s.world_state();
@@ -2134,7 +2188,7 @@ pub(crate) fn input_rows_range(d: &mut Dialog, ui: &mut egui::Ui, s: &Session, r
RichText::new(if custom_axis || stored_reference.is_some() {
crate::i18n::tr("dialog.custom_axis").into()
} else if !inp.multi {
inp.items.first().map(|item| selection_label(s, item)).unwrap_or_default()
inp.items.first().map(|item| selection_label(s, d, inp, item)).unwrap_or_default()
} else {
let count = if i == 0 { shell_count.unwrap_or(inp.items.len()) } else { inp.items.len() };
crate::i18n::format("dialog.selected_count", &[("count", &count.to_string())])
@@ -2158,11 +2212,15 @@ pub(crate) fn input_rows_range(d: &mut Dialog, ui: &mut egui::Ui, s: &Session, r
reference.to_string()
} else if custom_axis {
if let Some(axis) = stored_revolve_axis(&d.kind) {
format!(
"Custom axis\nOrigin: {}\nDirection: {}\nClick to select a replacement axis",
axis.get("origin").map(ToString::to_string).unwrap_or_default(),
axis.get("dir").map(ToString::to_string).unwrap_or_default()
)
match axis.get("at") {
// A kept edge or face of the model (one no longer found).
Some(at) => format!("Custom axis\nThe edge or face at {at}\nClick to select a replacement axis"),
None => format!(
"Custom axis\nOrigin: {}\nDirection: {}\nClick to select a replacement axis",
axis.get("origin").map(ToString::to_string).unwrap_or_default(),
axis.get("dir").map(ToString::to_string).unwrap_or_default()
),
}
} else {
hint(inp).to_string()
}
@@ -2187,7 +2245,7 @@ pub(crate) fn input_rows_range(d: &mut Dialog, ui: &mut egui::Ui, s: &Session, r
});
if matches!(d.kind, Kind::SketchModify(_)) && inp.multi {
for (index, item) in inp.items.iter().enumerate() {
if crate::ui_kit::list_row(ui, &format!("{}:{index}", inp.label), &selection_label(s, item)).clicked() {
if crate::ui_kit::list_row(ui, &format!("{}:{index}", inp.label), &selection_label(s, d, inp, item)).clicked() {
remove = Some((i, index));
}
}
@@ -3583,7 +3641,8 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S
let axis = match sels(d, 1).first() {
Some(Sel::Axis { name }) => json!(name),
Some(Sel::SketchCurve { id, .. }) => json!(id),
_ => stored_axis.clone().ok_or("select an axis")?,
Some(x) => axis_param(app, x)?,
None => stored_axis.clone().ok_or("select an axis")?,
};
let (sketch, idx) = profiles();
let mut p = json!({"axis": axis, "angle": angle, "operation": OPS.get(*operation).copied().unwrap_or("new")});
@@ -3730,11 +3789,7 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S
need(0, "objects")?;
let axis = match sels(d, 1).first() {
None if d.extra.contains_key("axis") => d.extra.get("axis").cloned().unwrap_or(Value::Null),
Some(Sel::Axis { name }) => json!(name),
Some(x) => {
let (o, dir) = axis_of(app, x).ok_or("the axis must be an origin axis or a sketch line")?;
json!({"origin": pt(o), "dir": pt(dir)})
}
Some(x) => axis_param(app, x)?,
None => return Err("select an axis".into()),
};
let mut p = json!({"axis": axis, "count": count, "angle": angle});
@@ -3848,11 +3903,7 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S
need(0, "a plane")?;
let base = plane_arg(app, sels(d, 0).first())?;
let axis = match sels(d, 1).first() {
Some(Sel::Axis { name }) => json!(name),
Some(x) => {
let (o, dir) = axis_of(app, x).ok_or("the axis must be an origin axis or a sketch line")?;
json!({"origin": pt(o), "dir": pt(dir)})
}
Some(x) => axis_param(app, x)?,
None => d.extra.get("axis").cloned().ok_or("pick an axis")?,
};
("construct.plane.at_angle", json!({"base": base, "axis": axis}))
@@ -4351,25 +4402,115 @@ pub fn axis_of(app: &SolveApp, sel: &Sel) -> Option<(Vec3, Vec3)> {
};
Some((pa, (pb - pa).normalized()?))
}
// A straight model edge, along it.
// A straight model edge, along it; a circular one, about its axis.
Sel::Edge { body, index, .. } => {
let b = app.session.world_state().body(body).cloned()?;
let m = b.mesh();
let e = m.edges.get(*index)?;
let (a, z) = (*e.first()?, *e.last()?);
let dir = (z - a).normalized()?;
let Some(dir) = (z - a).normalized() else { return round_axis(&app.session, sel) };
let tol = 1e-6 * a.dist(z).max(1.0);
if !e.iter().all(|p| (*p - a).cross(dir).len() < tol) {
return None;
return round_axis(&app.session, sel);
}
// An edge along an origin axis points the way the axis does (as picking the axis).
let axis = [Vec3::X, Vec3::Y, Vec3::Z].into_iter().find(|x| dir.dot(*x).abs() > 1.0 - 1e-9);
Some((a, axis.unwrap_or(dir)))
}
// A cylinder, cone or torus face: its axis.
Sel::Face { .. } => round_axis(&app.session, sel),
_ => None,
}
}
/// The circle a picked edge lies on, from its exact curve, when the drawn edge lies on it:
/// (centre, unit normal, radius). A round edge stands for its circle wherever a 3D pick wants
/// an axis (through the centre, along the normal) or a point (the centre).
pub(crate) fn edge_circle(s: &Session, body: &str, index: usize) -> Option<(Vec3, Vec3, f64)> {
edge_circle_in(&s.world_state(), body, index)
}
/// [`edge_circle`] in a given model state (a dialog editing a feature looks at the model before it).
pub(crate) fn edge_circle_in(st: &solidcraft_engine::doc::ModelState, body: &str, index: usize) -> Option<(Vec3, Vec3, f64)> {
let b = st.body(body)?;
let c = solidcraft_engine::kernel::edge_circle(&b.body, index)?;
let tol = (b.body.size() * 1e-6).max(1e-9) * 10.0;
let on = |p: &Vec3| (p.dist(c.center) - c.radius).abs() <= tol && (*p - c.center).dot(*c.axis).abs() <= tol;
b.mesh().edges.get(index)?.iter().all(on).then_some((c.center, *c.axis, c.radius))
}
/// The axis of a circular edge (through its centre, along its normal) or of a cylinder, cone or
/// torus face, pointing the way the command will find it (`construct::canonical_dir`). `None`
/// for any other pick: those have no axis of their own.
pub(crate) fn round_axis(s: &Session, sel: &Sel) -> Option<(Vec3, Vec3)> {
use solidcraft_engine::kernel::{self, FaceSurface};
let (o, d) = match sel {
Sel::Edge { body, index, .. } => edge_circle(s, body, *index).map(|(c, n, _)| (c, n))?,
Sel::Face { body, index, .. } => {
let st = s.world_state();
let b = st.body(body)?;
match kernel::guard("axis of a face", || Ok(kernel::face_surface(&b.body, *index))).ok().flatten()? {
FaceSurface::Cylinder { origin, axis, .. } => (origin, *axis),
FaceSurface::Cone { apex, axis, .. } => (apex, *axis),
FaceSurface::Torus { center, axis, .. } => (center, *axis),
_ => return None,
}
}
_ => return None,
};
o.is_finite().then(|| (o, solidcraft_engine::doc::construct::canonical_dir(d)))
}
/// An axis pick that the command keeps as a reference to the model (`{edge|face: [x,y,z]}`), so
/// the feature follows the edge or face: a circular edge, or a cylinder, cone or torus face.
/// Straight edges stay a fixed line, as they always have.
fn round_axis_ref(app: &SolveApp, sel: &Sel) -> Option<Value> {
round_axis(&app.session, sel)?;
match sel {
Sel::Edge { .. } if !is_straight_edge(&app.session, sel) => construct_ref(app, sel).ok(),
Sel::Face { .. } => construct_ref(app, sel).ok(),
_ => None,
}
}
fn is_straight_edge(s: &Session, sel: &Sel) -> bool {
let Sel::Edge { body, index, .. } = sel else { return false };
let Some(b) = s.world_state().body(body).cloned() else { return false };
let m = b.mesh();
let Some(e) = m.edges.get(*index) else { return false };
let (Some(a), Some(z)) = (e.first().copied(), e.last().copied()) else { return false };
let Some(dir) = (z - a).normalized() else { return false };
let tol = 1e-6 * a.dist(z).max(1.0);
e.iter().all(|p| (*p - a).cross(dir).len() < tol)
}
/// Whether an axis input (`selection::AXIS_PICKS`) takes this pick: an edge or face only where
/// it has an axis (a straight or circular edge, a cylinder, cone or torus face).
pub(crate) fn takes_as_axis(s: &Session, sel: &Sel) -> bool {
match sel {
Sel::Edge { .. } => is_straight_edge(s, sel) || round_axis(s, sel).is_some(),
Sel::Face { .. } => round_axis(s, sel).is_some(),
_ => true,
}
}
/// An axis input's pick as a command's `axis`: a world axis or construction axis by name, a
/// circular edge or round face by reference, anything else (a sketch line, a straight edge) as
/// its line.
pub(crate) fn axis_param(app: &SolveApp, sel: &Sel) -> Result<Value, String> {
if let Sel::Axis { name } = sel {
return Ok(json!(name));
}
if let Some(r) = round_axis_ref(app, sel) {
return Ok(r);
}
let (o, dir) = axis_of(app, sel).ok_or(AXIS_PICK)?;
Ok(json!({"origin": pt(o), "dir": pt(dir)}))
}
const AXIS_PICK: &str =
"the axis must be an origin or construction axis, a sketch line, a straight or circular edge, or a cylinder, cone or torus face";
/// Which profiles of a sketch a profile selection means.
pub(crate) fn profile_indices(ss: &solidcraft_engine::doc::SolvedSketch, sel: &ProfileSel) -> Vec<usize> {
let ps = &ss.profiles;
@@ -4637,6 +4778,18 @@ fn point_sel(s: &Session, g: &solidcraft_engine::doc::construct::GeoRef) -> Opti
}
}
/// A feature's axis on an edge or round face of the model back into a dialog pick: the edge or
/// face where it is now.
pub(crate) fn model_axis_sel(s: &Session, g: &solidcraft_engine::doc::construct::GeoRef) -> Option<Sel> {
use solidcraft_engine::doc::construct::GeoRef;
let at = g.picked_point(&s.world_state())?;
match g {
GeoRef::Edge { .. } => edge_sel(s, at),
GeoRef::Face { .. } => face_sel(s, at),
_ => None,
}
}
/// A stored construction reference back into a dialog pick.
fn geo_sel(s: &Session, g: &solidcraft_engine::doc::construct::GeoRef) -> Option<Sel> {
match g {
@@ -4754,6 +4907,8 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
"origin": pt(solidcraft_engine::doc::apply_point(&frame, origin.0)),
"dir": pt(solidcraft_engine::doc::apply_vector(&frame, dir.0))
})),
// An edge or face that is gone stays the reference until another is picked.
AxisRef::Model { geo } if model_axis_sel(s, geo).is_none() => serde_json::to_value(geo).ok(),
_ => None,
};
d.kind = Kind::Revolve { angle: angle.to_string(), operation: op_index(operation), axis: stored_axis };
@@ -4778,8 +4933,9 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
AxisRef::World { axis } => Some(Sel::Axis { name: axis.to_ascii_uppercase() }),
AxisRef::SketchAxis { axis } => Some(Sel::Axis { name: axis.to_ascii_lowercase() }),
AxisRef::SketchLine { curve } => Some(crate::selection::curve_pick(curve, sketch.0, s.active_sketch)),
AxisRef::Model { geo } => model_axis_sel(s, geo),
AxisRef::Construction { name } => Some(Sel::Axis { name: name.to_string() }),
_ => None,
AxisRef::Line { .. } => None,
};
if let Some(inp) = d.inputs.get_mut(1) {
inp.items = ax.into_iter().collect();
@@ -5192,20 +5348,29 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
}
d
}
PatternKind::Circular { origin, axis, count, angle, alignment, reversed, axis_feature } => {
PatternKind::Circular { origin, axis, count, angle, alignment, reversed, axis_ref, axis_feature } => {
let mut d = start("solid.pattern.circular")?;
d.extra.insert("alignment".into(), json!(alignment));
d.extra.insert("reversed".into(), json!(reversed));
d.kind = Kind::PatternCirc { count: count.to_string(), angle: angle.to_string() };
// The construction axis it turns about, else an origin axis or its line.
let named = axis_feature.as_ref().map(|n| n.to_string());
match named.or_else(|| world_axis(axis.0).filter(|_| origin.len() < 1e-9)) {
Some(name) => {
// The edge or face it turns about, else its construction axis, else an origin
// axis or its line.
let pick = match (axis_ref, axis_feature) {
(Some(g), _) => model_axis_sel(s, g),
(None, Some(name)) => Some(Sel::Axis { name: name.to_string() }),
(None, None) => world_axis(axis.0).filter(|_| origin.len() < 1e-9).map(|name| Sel::Axis { name }),
};
match (pick, axis_ref) {
(Some(pick), _) => {
if let Some(inp) = d.inputs.get_mut(1) {
inp.items = vec![Sel::Axis { name }];
inp.items = vec![pick];
}
}
None => {
// An edge or face that is gone stays the reference until another is picked.
(None, Some(g)) => {
d.extra.insert("axis".into(), serde_json::to_value(g).unwrap_or(Value::Null));
}
(None, None) => {
d.extra.insert("axis".into(), json!({"origin": pt3(origin.0), "dir": pt3(axis.0)}));
}
}
@@ -5316,19 +5481,26 @@ pub fn for_feature(app: &SolveApp, id: u64, marker: Option<usize>) -> Option<Dia
}
d
}
FeatureKind::ConstructionPlane { plane: PlaneRef::AtAngle { base, axis_origin, axis_dir, .. } } => {
FeatureKind::ConstructionPlane { plane: PlaneRef::AtAngle { base, axis_origin, axis_dir, line, .. } } => {
let mut d = start("construct.plane.at_angle")?;
d.kind = Kind::simple_restore(&f.kind)?;
if let Some(inp) = d.inputs.first_mut() {
inp.items = plane_sel(s, base).into_iter().collect();
}
match world_axis(*axis_dir).filter(|_| axis_origin.len() < 1e-9) {
Some(name) => {
let pick = match line {
Some(g) => model_axis_sel(s, g),
None => world_axis(*axis_dir).filter(|_| axis_origin.len() < 1e-9).map(|name| Sel::Axis { name }),
};
match (pick, line) {
(Some(pick), _) => {
if let Some(inp) = d.inputs.get_mut(1) {
inp.items = vec![Sel::Axis { name }];
inp.items = vec![pick];
}
}
None => {
(None, Some(g)) => {
d.extra.insert("axis".into(), serde_json::to_value(g).unwrap_or(Value::Null));
}
(None, None) => {
d.extra.insert("axis".into(), json!({"origin": pt3(*axis_origin), "dir": pt3(*axis_dir)}));
}
}
+22 -8
View File
@@ -12,7 +12,7 @@ use solidcraft_engine::geom::Vec3;
use crate::SolveApp;
use crate::dialogs::{Dialog, Kind};
use crate::gizmo::{self, Change, Drag};
use crate::selection::{AXES, BODIES, EDGES, FACES, ORIGIN, SelInput, VERTICES};
use crate::selection::{AXIS_PICKS, BODIES, EDGES, FACES, ORIGIN, SelInput, VERTICES};
pub const TYPES: [&str; 5] = ["Free Move", "Translate", "Rotate", "Point to Point", "Point to Position"];
pub const FREE: usize = 0;
@@ -34,7 +34,7 @@ pub fn inputs(mode: usize) -> Vec<SelInput> {
let mut v = vec![SelInput::new("Bodies", BODIES, true)];
match mode {
FREE => v.push(SelInput::new("Pivot", POINTS, false)),
ROTATE => v.push(SelInput::new("Axis", AXES | EDGES, false)),
ROTATE => v.push(SelInput::new("Axis", AXIS_PICKS, false)),
POINT_TO_POINT => {
v.push(SelInput::new("From", POINTS, false));
v.push(SelInput::new("To", POINTS, false));
@@ -92,9 +92,19 @@ pub fn rows(ui: &mut egui::Ui, k: &mut Kind) -> bool {
enter
}
fn sel_point(s: Option<&Sel>) -> Option<Vec3> {
/// Where a point pick is: a round edge stands for its centre, where the model is before this
/// move, in the world (a body of a placed component where its occurrence puts it, as it was
/// picked); any other pick is where it was picked.
fn sel_point(app: &SolveApp, d: &Dialog, s: Option<&Sel>) -> Option<Vec3> {
match s? {
Sel::Vertex { point, .. } | Sel::Face { point, .. } | Sel::Edge { point, .. } => Some(*point),
Sel::Edge { body, index, point } => {
let st = match d.editing {
Some((id, _)) => std::sync::Arc::new(solidcraft_engine::doc::world_state(&app.session.doc, &app.session.model.state_before(id))),
None => app.session.world_state(),
};
Some(crate::dialogs::edge_circle_in(&st, body, *index).map_or(*point, |(c, ..)| c))
}
Sel::Vertex { point, .. } | Sel::Face { point, .. } => Some(*point),
_ => None,
}
}
@@ -127,7 +137,7 @@ fn bodies_center(app: &SolveApp, d: &Dialog) -> Option<Vec3> {
/// What a Free Move turns about: the picked pivot, else the kept one (editing), else the
/// bodies' centre.
fn pivot(app: &SolveApp, d: &Dialog) -> Option<Vec3> {
if let Some(p) = sel_point(items(d, 1).first()) {
if let Some(p) = sel_point(app, d, items(d, 1).first()) {
return Some(p);
}
if let Some(a) = d.extra.get("pivot").and_then(|v| serde_json::from_value::<[f64; 3]>(v.clone()).ok()) {
@@ -167,7 +177,7 @@ pub fn params(app: &SolveApp, d: &Dialog) -> Result<Value, String> {
if bodies.is_empty() {
return Err("select bodies first".into());
}
let need_point = |i: usize, what: &str| sel_point(items(d, i).first()).ok_or(format!("select {what} first"));
let need_point = |i: usize, what: &str| sel_point(app, d, items(d, i).first()).ok_or(format!("select {what} first"));
let num = |t: Vec3| json!([mm(t.x), mm(t.y), mm(t.z)]);
let mut p = json!({ "bodies": bodies });
match *mode {
@@ -204,7 +214,10 @@ pub fn params(app: &SolveApp, d: &Dialog) -> Result<Value, String> {
}
}
ROTATE => {
let (o, a) = items(d, 1).first().and_then(|s| axis_line(app, s)).ok_or("select an axis or a straight edge first")?;
let (o, a) = items(d, 1)
.first()
.and_then(|s| axis_line(app, s))
.ok_or("select an axis, a straight or circular edge, or a cylinder, cone or torus face first")?;
let th = ang(app, angle)?;
let r = gizmo::rotation(a, th);
p["translate"] = num(o - gizmo::apply(&r, o));
@@ -227,7 +240,8 @@ pub fn params(app: &SolveApp, d: &Dialog) -> Result<Value, String> {
Ok(p)
}
/// An axis line: origin axes and sketch lines, or a straight body edge.
/// An axis line: origin axes and sketch lines, a straight or circular body edge, or a cylinder,
/// cone or torus face (`dialogs::axis_of`), or a straight edge of a body where it was modelled.
fn axis_line(app: &SolveApp, s: &Sel) -> Option<(Vec3, Vec3)> {
if let Some(a) = crate::dialogs::axis_of(app, s) {
return Some(a);
+11 -3
View File
@@ -12,7 +12,9 @@ use solidcraft_engine::geom::Vec3;
use crate::SolveApp;
use crate::dialogs::{Kind, OP_LABELS, OPS, combo, form_row, op_index};
use crate::selection::{AXES, BODIES, CURVES, EDGES, FACES, PLANES, PROFILES, SelInput, SelectionExt as _, VERTICES, items, point_value as pt};
use crate::selection::{
AXES, AXIS_PICKS, BODIES, CURVES, EDGES, FACES, PLANES, PROFILES, SelInput, SelectionExt as _, VERTICES, items, point_value as pt,
};
use crate::ui_kit;
crate::dialog_descriptor::dialog_descriptors! {
@@ -158,7 +160,7 @@ const RULED_MODES: [(&str, &str); 4] = [("Normal", "normal"), ("Tangent", "tange
fn inputs(k: &Surf) -> Vec<SelInput> {
match k {
Surf::Extrude { .. } => vec![SelInput::new("Profiles or curves", PROFILES | CURVES, true)],
Surf::Revolve { .. } => vec![SelInput::new("Profiles or curves", PROFILES | CURVES, true), SelInput::new("Axis", AXES, false)],
Surf::Revolve { .. } => vec![SelInput::new("Profiles or curves", PROFILES | CURVES, true), SelInput::new("Axis", AXIS_PICKS, false)],
Surf::Sweep(_) => {
let [rail, rail2] = crate::dialogs_sweep::rail_inputs();
vec![
@@ -493,7 +495,8 @@ pub fn commands(app: &SolveApp, k: &Surf, inputs: &[SelInput], extra: &Map<Strin
p["axis"] = match items(inputs, 1).first() {
Some(Sel::Axis { name }) => json!(name),
Some(Sel::SketchCurve { id, .. }) => json!(id),
_ => axis.clone().ok_or("select an axis")?,
Some(x) => crate::dialogs::axis_param(app, x)?,
None => axis.clone().ok_or("select an axis")?,
};
p["angle"] = json!(angle);
if *symmetric {
@@ -818,6 +821,11 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind, frame: &Mat) -> Option<(K
"dir": pt(solidcraft_engine::doc::apply_vector(frame, dir.0))
})),
),
// An edge or face that is gone stays the reference until another is picked.
AxisRef::Model { geo } => match crate::dialogs::model_axis_sel(s, geo) {
Some(pick) => (Some(pick), None),
None => (None, serde_json::to_value(geo).ok()),
},
};
let mut extra = Map::new();
if let Some(a2) = angle2 {
+2
View File
@@ -195,6 +195,8 @@ pub mod render_workspace;
mod revolve_edit_tests;
#[cfg(test)]
mod revolve_manipulator_tests;
#[cfg(test)]
mod round_pick_tests;
mod rule_editor;
#[cfg(test)]
mod rule_editor_tests;
+296
View File
@@ -0,0 +1,296 @@
//! A round edge or face picked in 3D stands for its circle: an axis input (Revolve, Circular
//! Pattern, Plane at Angle, Move's Rotate) takes a circular edge or a cylinder wall as its axis,
//! kept as a reference so the feature follows it; a point input takes a circle's centre; and
//! hovering one draws the axis or centre as construction geometry.
use serde_json::{Value, json};
use solidcraft_engine::Sel;
use solidcraft_engine::doc::{AxisRef, FeatureKind, PatternKind, PlaneRef};
use solidcraft_engine::geom::Vec3;
use crate::dialogs::Kind;
use crate::scenario::Harness;
use crate::viewport::Hit;
/// A Ø10 × 10 shaft at x = `cx` (40 mm) and a 2 × 6 profile on XZ beside it.
fn shaft() -> Harness {
let mut h = Harness::new();
h.app.run("parameters.add", json!({"name": "cx", "expression": "40 mm"})).unwrap();
h.app.run("solid.cylinder", json!({"base": ["cx", 0, 0], "radius": 5, "height": 10, "body_name": "Shaft"})).unwrap();
h.app.run("sketch.create", json!({"plane": "XZ", "name": "Profile"})).unwrap();
h.app.run("sketch.rectangle.two_point", json!({"p0": [46, -2], "p1": [48, -8]})).unwrap();
h.app.run("sketch.finish", json!({})).unwrap();
h.frames(2);
h
}
/// The shaft's wall, top rim and top cap, as picks.
fn picks(h: &Harness) -> (Sel, Sel, Sel) {
use solidcraft_engine::kernel::{FaceSurface, face_surface};
let st = h.app.session.world_state();
let b = st.body("Shaft").unwrap();
let face = |want: fn(&FaceSurface) -> bool, point: Vec3| {
let index = (0..b.body.face_count()).find(|i| face_surface(&b.body, *i).is_some_and(|f| want(&f))).unwrap();
Sel::Face { body: "Shaft".into(), index, point }
};
let wall = face(|f| matches!(f, FaceSurface::Cylinder { .. }), Vec3::new(45.0, 0.0, 5.0));
let cap = face(|f| matches!(f, FaceSurface::Plane { normal, .. } if normal.z > 0.5), Vec3::new(40.0, 0.0, 10.0));
let rim = b
.mesh()
.edges
.iter()
.enumerate()
.find_map(|(index, e)| {
let c = solidcraft_engine::kernel::edge_circle(&b.body, index)?;
(c.center.z > 9.0).then(|| Sel::Edge { body: "Shaft".into(), index, point: e[0] })
})
.unwrap();
(wall, rim, cap)
}
fn hit(sel: &Sel) -> Hit {
match sel {
Sel::Face { body, index, point } => Hit::Face { body: body.clone(), index: *index, point: *point },
Sel::Edge { body, index, point } => Hit::Edge { body: body.clone(), index: *index, mid: *point },
_ => panic!("not a model pick"),
}
}
fn along_z_through(axis: (Vec3, Vec3), x: f64) -> bool {
let (o, d) = axis;
d.cross(Vec3::Z).len() < 1e-9 && (o.x - x).abs() < 1e-6 && o.y.abs() < 1e-6
}
/// The command the open dialog runs, with `sel` in input `input`.
fn command_with(h: &mut Harness, cmd: &str, input: usize, sel: &Sel, setup: impl Fn(&mut crate::dialogs::Dialog)) -> Value {
h.app.start(cmd);
let mut d = h.app.dialog.clone().unwrap();
setup(&mut d);
d.active = input;
d.inputs[input].items = vec![sel.clone()];
let cmds = crate::dialogs::apply_commands(&h.app, &d).unwrap();
h.app.dialog = None;
cmds.into_iter().find(|(c, _)| c == cmd).map(|(_, p)| p).unwrap()
}
fn profile(h: &Harness) -> Sel {
Sel::Profile { sketch: h.app.session.doc.find_feature("Profile").unwrap().id, index: 0 }
}
#[test]
fn a_circular_edge_or_cylinder_wall_is_an_axis_and_a_flat_face_is_not() {
let h = shaft();
let (wall, rim, cap) = picks(&h);
for sel in [&wall, &rim] {
let axis = crate::dialogs::axis_of(&h.app, sel).unwrap();
assert!(along_z_through(axis, 40.0), "{sel:?}: {axis:?}");
assert!(axis.1.z > 0.0, "oriented the way the command finds it");
}
assert!(crate::dialogs::axis_of(&h.app, &cap).is_none());
}
#[test]
fn axis_inputs_take_only_edges_and_faces_that_have_an_axis() {
let mut h = shaft();
let (wall, rim, cap) = picks(&h);
for cmd in ["solid.revolve", "solid.pattern.circular", "construct.plane.at_angle", "surface.revolve"] {
h.app.start(cmd);
let mut d = h.app.dialog.clone().unwrap();
d.active = 1;
assert_eq!(d.inputs[1].accept, crate::selection::AXIS_PICKS, "{cmd}");
assert_eq!(d.candidate(&h.app.session, &hit(&wall)), Some(wall.clone()), "{cmd} takes the wall");
assert_eq!(d.candidate(&h.app.session, &hit(&rim)), Some(rim.clone()), "{cmd} takes the rim");
assert_eq!(d.candidate(&h.app.session, &hit(&cap)), None, "{cmd} refuses the flat cap");
h.app.dialog = None;
}
// Move's Rotate too.
h.app.start("solid.move");
let mut d = h.app.dialog.clone().unwrap();
d.kind = crate::dialogs_move::kind(crate::dialogs_move::ROTATE, &h.app.session.doc);
d.inputs = crate::dialogs_move::inputs(crate::dialogs_move::ROTATE);
d.active = 1;
assert_eq!(d.candidate(&h.app.session, &hit(&wall)), Some(wall));
assert_eq!(d.candidate(&h.app.session, &hit(&cap)), None);
}
#[test]
fn revolve_keeps_a_round_pick_as_a_reference_and_reopens_it() {
let mut h = shaft();
let (_, rim, _) = picks(&h);
let p = profile(&h);
let mut params = command_with(&mut h, "solid.revolve", 1, &rim, |d| d.inputs[0].items = vec![p.clone()]);
assert!(params["axis"].get("edge").is_some(), "{params}");
params["name"] = json!("Turn");
h.app.run("solid.revolve", params).unwrap();
let revolve_axis = |h: &Harness| match &h.app.session.doc.find_feature("Turn").unwrap().kind {
FeatureKind::Revolve { axis, .. } => axis.clone(),
_ => panic!("revolve"),
};
assert!(matches!(revolve_axis(&h), AxisRef::Model { .. }));
// The cylinder moves; editing the revolve shows the rim where it is now and keeps the reference.
h.app.run("parameters.change", json!({"name": "cx", "expression": "41 mm"})).unwrap();
h.step(&json!({"call": "ui.editFeature", "params": {"feature": "Turn"}})).unwrap();
h.frames(4);
let d = h.app.dialog.as_ref().unwrap();
let picked = d.inputs[1].items.first().cloned().unwrap();
assert!(along_z_through(crate::dialogs::axis_of(&h.app, &picked).unwrap(), 41.0), "{picked:?}");
h.step(&json!({"widget": "OK"})).unwrap();
assert!(matches!(revolve_axis(&h), AxisRef::Model { .. }));
}
#[test]
fn circular_pattern_and_angle_plane_keep_a_cylinder_wall() {
let mut h = shaft();
let (wall, ..) = picks(&h);
let params = command_with(&mut h, "solid.pattern.circular", 1, &wall, |d| d.inputs[0].items = vec![Sel::Body { name: "Shaft".into() }]);
assert!(params["axis"].get("face").is_some(), "{params}");
h.app.run("solid.pattern.circular", params).unwrap();
assert!(
h.app
.session
.doc
.features
.iter()
.any(|f| matches!(f.kind, FeatureKind::Pattern { pattern: PatternKind::Circular { axis_ref: Some(_), .. }, .. }))
);
let params = command_with(&mut h, "construct.plane.at_angle", 1, &wall, |d| d.inputs[0].items = vec![Sel::Plane { name: "XZ".into() }]);
assert!(params["axis"].get("face").is_some(), "{params}");
h.app.run("construct.plane.at_angle", params).unwrap();
assert!(
h.app
.session
.doc
.features
.iter()
.any(|f| matches!(&f.kind, FeatureKind::ConstructionPlane { plane: PlaneRef::AtAngle { line: Some(_), .. } }))
);
}
#[test]
fn move_rotates_about_a_cylinder_wall_and_moves_from_a_circle_centre() {
use crate::dialogs_move::{POINT_TO_POINT, ROTATE, inputs, kind, params};
let mut h = shaft();
h.app.run("solid.box", json!({"length": 4, "width": 4, "height": 4, "corner": [60, 0, 0], "body_name": "Lug"})).unwrap();
let (wall, rim, _) = picks(&h);
h.app.start("solid.move");
let mut d = h.app.dialog.clone().unwrap();
d.kind = kind(ROTATE, &h.app.session.doc);
d.inputs = inputs(ROTATE);
d.inputs[0].items = vec![Sel::Body { name: "Lug".into() }];
d.inputs[1].items = vec![wall.clone()];
let p = params(&h.app, &d).unwrap();
let a: Vec<f64> = serde_json::from_value(p["axis"].clone()).unwrap();
assert!((a[2].abs() - 1.0).abs() < 1e-9, "about the shaft's axis: {a:?}");
// The chips say what the round picks stand for.
let label = |d: &crate::dialogs::Dialog, i: usize, sel: &Sel| crate::dialogs::selection_label(&h.app.session, d, &d.inputs[i], sel);
let wall_label = label(&d, 1, &wall);
assert!(wall_label.starts_with("Shaft · face ") && wall_label.ends_with(" axis"), "{wall_label}");
assert!(label(&d, 1, &rim).ends_with("· circle axis"), "{}", label(&d, 1, &rim));
// Point to Point from the rim: from its centre.
d.kind = kind(POINT_TO_POINT, &h.app.session.doc);
d.inputs = inputs(POINT_TO_POINT);
d.inputs[0].items = vec![Sel::Body { name: "Lug".into() }];
assert!(label(&d, 1, &rim).ends_with("· circle centre"), "{}", label(&d, 1, &rim));
d.inputs[1].items = vec![rim];
d.inputs[2].items = vec![Sel::Vertex { body: String::new(), point: Vec3::ZERO }];
let p = params(&h.app, &d).unwrap();
assert_eq!(p["translate"], json!(["-40 mm", "0 mm", "-10 mm"]), "the rim's centre onto the origin");
}
#[test]
fn move_takes_the_centre_of_a_circle_in_a_placed_component_where_it_is_shown() {
use crate::dialogs_move::{POINT_TO_POINT, inputs, kind, params};
let mut h = shaft();
h.app.run("solid.box", json!({"length": 4, "width": 4, "height": 4, "corner": [60, 0, 0], "body_name": "Lug"})).unwrap();
h.app.run("component.from_bodies", json!({"bodies": ["Shaft"]})).unwrap();
let occ = h.app.session.doc.occurrences[0].id;
// A design's first part is grounded when it is made.
h.app.run("occurrence.ground", json!({"occurrence": occ, "grounded": false})).unwrap();
h.app.run("occurrence.move", json!({"occurrence": occ, "translate": [0, 30, 0]})).unwrap();
h.frames(2);
// The rim as picked in the viewport: on the shaft where the occurrence puts it.
let (_, rim, _) = picks(&h);
let Sel::Edge { point, .. } = &rim else { panic!("{rim:?}") };
assert!((point.y - 30.0).abs() < 5.0 + 1e-6, "picked in the world: {point:?}");
h.app.start("solid.move");
let mut d = h.app.dialog.clone().unwrap();
d.kind = kind(POINT_TO_POINT, &h.app.session.doc);
d.inputs = inputs(POINT_TO_POINT);
d.inputs[0].items = vec![Sel::Body { name: "Lug".into() }];
d.inputs[1].items = vec![rim];
d.inputs[2].items = vec![Sel::Vertex { body: String::new(), point: Vec3::ZERO }];
let p = params(&h.app, &d).unwrap();
assert_eq!(p["translate"], json!(["-40 mm", "-30 mm", "-10 mm"]), "the centre where the component shows it");
}
#[test]
fn point_inputs_take_a_circles_centre() {
let mut h = shaft();
let (_, rim, _) = picks(&h);
// A construction point keeps the edge, and lands on its centre.
h.app.start("construct.point.vertex");
let d = h.app.dialog.clone().unwrap();
let got = d.candidate(&h.app.session, &hit(&rim)).unwrap();
assert!(matches!(got, Sel::Edge { .. }), "{got:?}");
let mut d = d;
d.inputs[0].items = vec![got];
let cmds = crate::dialogs::apply_commands(&h.app, &d).unwrap();
h.app.dialog = None;
for (c, p) in cmds {
h.app.run(&c, p).unwrap();
}
let points = solidcraft_engine::view::construction_points(&h.app.session);
assert!(points.iter().any(|p| p.2.dist(Vec3::new(40.0, 0.0, 10.0)) < 1e-6), "{points:?}");
// Revolve's To Object takes the centre as a point.
h.app.start("solid.revolve");
let mut d = h.app.dialog.clone().unwrap();
d.inputs.push(crate::selection::SelInput::new("To Object", crate::selection::FACES | crate::selection::VERTICES, false));
d.active = d.inputs.len() - 1;
let got = d.candidate(&h.app.session, &hit(&rim));
let Some(Sel::Vertex { body, point }) = &got else { panic!("{got:?}") };
assert_eq!(body, "Shaft");
assert!(point.dist(Vec3::new(40.0, 0.0, 10.0)) < 1e-6, "{point:?}");
h.app.dialog = None;
// A hole placed from the top rim goes at its centre, on the cap under the cursor.
let (_, _, cap) = picks(&h);
h.app.start("solid.hole");
let d = h.app.dialog.clone().unwrap();
let hits = [hit(&rim), hit(&cap)];
let snap = d.face_snap(&h.app.session, &hits);
let Some(Sel::Face { point, .. }) = d.candidate_on(&h.app.session, &hit(&rim), snap.as_ref()) else { panic!("no place") };
assert!(point.dist(Vec3::new(40.0, 0.0, 10.0)) < 1e-6, "{point:?}");
}
#[test]
fn hovering_a_round_pick_draws_its_axis_or_centre() {
let mut h = shaft();
let (wall, rim, cap) = picks(&h);
h.app.start("solid.revolve");
if let Some(d) = h.app.dialog.as_mut() {
d.active = 1;
}
for (sel, lines) in [(&wall, 1), (&rim, 1), (&cap, 0)] {
h.app.viewport.hover = Some(hit(sel));
let (axes, centres) = crate::viewport::round_pick_feedback(&h.app);
assert_eq!(axes.len(), lines, "{sel:?}");
assert!(centres.is_empty());
for (a, b) in axes {
assert!(along_z_through((a, (b - a).normalized().unwrap()), 40.0), "{a:?} {b:?}");
}
}
// With the axis picked, it stays drawn.
h.app.viewport.hover = None;
if let Some(d) = h.app.dialog.as_mut() {
d.inputs[1].items = vec![rim.clone()];
}
assert_eq!(crate::viewport::round_pick_feedback(&h.app).0.len(), 1);
// In a point input a circle shows its centre.
h.app.dialog = None;
h.app.start("construct.point.vertex");
h.app.viewport.hover = Some(hit(&rim));
let (axes, centres) = crate::viewport::round_pick_feedback(&h.app);
assert!(axes.is_empty());
assert_eq!(centres.len(), 1);
assert!(centres[0].dist(Vec3::new(40.0, 0.0, 10.0)) < 1e-6);
assert!(!matches!(h.app.dialog.as_ref().map(|d| &d.kind), Some(Kind::Revolve { .. })));
}
+5
View File
@@ -69,6 +69,11 @@ pub const SKETCH_LINES: Accept = 8192;
pub const EXTERNAL_POINTS: Accept = 16384;
/// Named construction points.
pub const CONSTRUCTION_POINTS: Accept = 32768;
/// What a 3D axis input takes (Revolve, Circular Pattern, Plane at Angle, Move's Rotate): an
/// origin or construction axis, a straight sketch line, and an edge or face of the model that
/// has an axis (a straight or circular edge, a cylinder, cone or torus face; the dialog takes
/// only those, `Dialog::candidate_on`).
pub const AXIS_PICKS: Accept = AXES | EDGES | FACES;
/// One selection input of a command dialog ("Profiles", "Edges", "Plane", ...).
#[derive(Clone, Debug, PartialEq)]
@@ -291,6 +291,7 @@ fn nested_anchor_saved_fixed_conversion_preserves_rotated_second_author_plane()
axis_origin: Vec3::ZERO,
axis_dir: Vec3::X,
angle: "15 deg".into(),
line: None,
};
h.app.session = solidcraft_engine::Session::new(document);
let raw = h.app.session.doc.sketch(id).unwrap().clone();
+75 -15
View File
@@ -1382,28 +1382,66 @@ pub fn construction_axis_segments(app: &SolveApp) -> Vec<(String, Vec3, Vec3)> {
if axes.is_empty() {
return Vec::new();
}
let h = origin_size(app.cam.half_height()) * AXIS_LEN;
let bb = view_bounds(app);
axes.into_iter()
.map(|(_, name, o, d)| {
let (mut lo, mut hi) = (-h, h);
if !bb.is_empty() {
for i in 0..8 {
let c = Vec3::new(
if i & 1 == 0 { bb.min.x } else { bb.max.x },
if i & 2 == 0 { bb.min.y } else { bb.max.y },
if i & 4 == 0 { bb.min.z } else { bb.max.z },
);
let t = (c - o).dot(d);
lo = lo.min(t - h * 0.3);
hi = hi.max(t + h * 0.3);
}
}
(name, o + d * lo, o + d * hi)
let (a, b) = axis_span(app, &bb, o, d);
(name, a, b)
})
.collect()
}
/// How far an axis through `o` along `d` is drawn: across the model's box `bb` where it passes
/// it (a little past it either side), at least the origin axes' length around `o`.
fn axis_span(app: &SolveApp, bb: &solidcraft_engine::geom::Aabb3, o: Vec3, d: Vec3) -> (Vec3, Vec3) {
let h = origin_size(app.cam.half_height()) * AXIS_LEN;
let (mut lo, mut hi) = (-h, h);
if !bb.is_empty() {
for i in 0..8 {
let c = Vec3::new(
if i & 1 == 0 { bb.min.x } else { bb.max.x },
if i & 2 == 0 { bb.min.y } else { bb.max.y },
if i & 4 == 0 { bb.min.z } else { bb.max.z },
);
let t = (c - o).dot(d);
lo = lo.min(t - h * 0.3);
hi = hi.max(t + h * 0.3);
}
}
(o + d * lo, o + d * hi)
}
/// What a round edge or face stands for in the open dialog's active input, drawn as construction
/// geometry while it is under the cursor or picked: the axis an axis input takes (a dashed line
/// through a circle's centre along its normal, or along a cylinder's, cone's or torus's axis),
/// or the centre a point input takes from a circular edge (a small star).
pub(crate) fn round_pick_feedback(app: &SolveApp) -> (Vec<(Vec3, Vec3)>, Vec<Vec3>) {
let (mut lines, mut centres): (Vec<(Vec3, Vec3, Vec3, Vec3)>, Vec<Vec3>) = (Vec::new(), Vec::new());
let Some(d) = app.dialog.as_ref() else { return (Vec::new(), centres) };
let Some(inp) = d.active_input() else { return (Vec::new(), centres) };
let s = &app.session;
let hovered = app.viewport.hover.as_ref().and_then(|h| d.candidate(s, h));
if inp.accept == crate::selection::AXIS_PICKS {
let bb = view_bounds(app);
for sel in hovered.iter().chain(inp.items.iter()) {
if let Some((o, dir)) = crate::dialogs::round_axis(s, sel)
&& !lines.iter().any(|(_, _, q, e)| q.dist(o) < 1e-9 && e.cross(dir).len() < 1e-9)
{
let (a, b) = axis_span(app, &bb, o, dir);
lines.push((a, b, o, dir));
}
}
} else if let (Some(Hit::Edge { body, index, .. }), Some(sel)) = (app.viewport.hover.as_ref(), hovered.as_ref()) {
// Where the round edge is taken as its centre (`Dialog::circle_centre_pick`, Move's points).
if (matches!(sel, Sel::Vertex { .. }) || d.edge_is_centre(inp))
&& let Some((c, ..)) = crate::dialogs::edge_circle(s, body, *index)
{
centres.push(c);
}
}
(lines.into_iter().map(|(a, b, ..)| (a, b)).collect(), centres)
}
/// Construction points shown: (name, position).
pub fn construction_points(app: &SolveApp) -> Vec<(String, Vec3)> {
solidcraft_engine::view::construction_points(&app.session)
@@ -2590,6 +2628,8 @@ fn highlight_geometry_key(app: &SolveApp) -> u64 {
app.ui.pick_bodies.hash(&mut h);
app.session.active_sketch.hash(&mut h);
(app.dialog.is_some(), app.tool.is_some()).hash(&mut h);
// Which input is active decides what a round edge or face under the cursor stands for.
app.dialog.as_ref().and_then(|d| d.active_input()).map(|i| i.accept).hash(&mut h);
crate::theme::is_dark().hash(&mut h);
crate::theme::vision().hash(&mut h);
// Two themes may share a light/dark base while drawing different geometry colours.
@@ -2818,6 +2858,26 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {
sc.line((p - d * r).to_f32(), (p + d * r).to_f32(), col, 2.0, true);
}
}
// A round edge or face under the cursor (or picked) in an axis input shows its axis, and a
// circle in a point input its centre, as construction geometry. The axis runs through the
// solid it belongs to, so it is drawn over the model.
let (round_axes, round_centres) = round_pick_feedback(app);
for (a, b) in round_axes {
let len = a.dist(b);
let dash = size * 0.08;
let mut s = 0.0;
while s < len {
let e = (s + dash).min(len);
sc.line(a.lerp(b, s / len).to_f32(), a.lerp(b, e / len).to_f32(), c4(t.construction_geom), 2.0, true);
s += dash * 1.6;
}
}
for p in round_centres {
let r = size * 0.04;
for d in [Vec3::X, Vec3::Y, Vec3::Z] {
sc.line((p - d * r).to_f32(), (p + d * r).to_f32(), c4(t.construction_geom), 2.0, true);
}
}
// Reference widgets follow zoom; the often much larger world-space feedback does not.
let projected = sel.iter().any(|s| matches!(s, Sel::Profile { .. } | Sel::SketchCurve { .. } | Sel::ExternalSketchCurve { .. }))
|| matches!(hover, Some(Hit::Profile { .. }));
+24 -2
View File
@@ -65,7 +65,7 @@ radius of a curve it follows on the inside is refused. Spline walls follow the e
within 0.0001 mm.
Editing an extrusion retains its signed distances, From/To Object inputs, taper expressions
and explicit body targets. Revolve edits retain world, sketch and explicit-line axes, both
and explicit body targets. Revolve edits retain world, sketch, explicit-line and model-edge or face axes, both
angle expressions and To Object targets. An unchanged **All profiles** selection continues
to include profiles added later. Cancel restores the complete timeline; a successful edit is
one undo step, including downstream parameter changes. Editing a placed component previews the
@@ -208,12 +208,34 @@ samples them finer, at the cost of time.
## Editing a feature from a script
For `solid.pattern.circular`, `axis` accepts `X`, `Y`, `Z`, or `{origin, dir}`.
For `solid.pattern.circular`, `axis` accepts `X`, `Y`, `Z`, `{origin, dir}`, or an edge or
round face of the model, `{edge: [x, y, z]}` or `{face: [x, y, z]}` (a point on it).
An explicit origin must contain three finite numeric coordinates in millimetres
(`[x, y, z]` or `{x, y, z}`); omitting it uses the world origin. Expressions and
construction-axis references are not supported. Invalid origins are rejected rather than
silently replaced with zero.
## Axes and points on round edges and faces
Wherever a 3D command takes an axis (Revolve, Surface Revolve, Circular Pattern, Plane at
Angle, and Move's Rotate) you can pick a circular edge, which gives the axis through its centre
along its normal, or a cylinder, cone or torus face, which gives that surface's axis. Hovering
one in an axis input draws the axis as a dashed construction line, and the line stays drawn once
the axis is picked. Flat faces and edges that are neither straight nor circular can't be picked
there.
Revolve, Surface Revolve, Circular Pattern and Plane at Angle keep the picked edge or face as a
reference (`{edge: [x, y, z]}` or `{face: [x, y, z]}` from a script), found again by its
persistent name every time the design is evaluated. If a parameter moves the cylinder, the
feature turns about it where it is now. The axis always points the same way, with its largest
component positive, so a rebuild that reverses the edge doesn't flip the turn. Straight edges
picked as axes keep working as before, as a fixed line.
Where a 3D command takes a point (the construction points, axes and planes built from points,
Revolve and Extrude's To Object, a surface patch's pass-through points, and Move's pivot and
points), a circular edge stands for its centre. A hovered circle shows a small star at its centre.
A construction point keeps the edge, so it follows the circle's centre as the model changes.
`timeline.inspect {feature}` returns a feature's `definition`: the fields `timeline.edit` changes,
with their current values. `timeline.edit {feature, set}` merges `set` into that definition
(objects are merged field by field, anything else replaces the value), rebuilds the feature and
+1 -1
View File
@@ -82,7 +82,7 @@ Distances are unsigned. Draw the geometry on the correct side first, and the dim
| `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`. |
| `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.pattern.circular` | `features`, `axis` (`"Z"`, `{origin, dir}`, or `{face: [x,y,z]}` / `{edge: [x,y,z]}` on a cylinder wall or circular edge, which the pattern follows), `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. |
- **Names:** name every feature (`"name":"Standoff"`) and keep names unique across sketches and features. `timeline.roll_to {"feature":"Plate"}` picks the first match, which can be the sketch.