SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Feature walks: generate them from field roles with #[derive(Walk)] (#1251)
JIJINBEI464a6dfad43e
diff --git a/Cargo.lock b/Cargo.lockindex 787a523b63..704ae95298 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -3479,6 +3479,15 @@ dependencies = ["solidcraft-mcp",]+[[package]]+name = "solidcraft-derive"+version = "0.11.0"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]+[[package]]name = "solidcraft-doc"version = "0.11.0"@@ -3487,6 +3496,7 @@ dependencies = ["serde","serde_json","sha2",+ "solidcraft-derive","solidcraft-geom","solidcraft-kernel","solidcraft-render",diff --git a/Cargo.toml b/Cargo.tomlindex 22d28b57a3..2c62dacfc9 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -24,10 +24,15 @@ solidcraft-io = { path = "crates/io" }solidcraft-engine = { path = "crates/engine" }solidcraft-ui-egui = { path = "crates/ui-egui" }solidcraft-mcp = { path = "crates/mcp" }+solidcraft-derive = { path = "crates/derive" }# foundationthiserror = "2"serde = { version = "1", features = ["derive", "rc"] }+# derive macros (crates/derive); already in the tree through serde_derive+proc-macro2 = "1"+quote = "1"+syn = { version = "2", features = ["full"] }serde_json = { version = "1", features = ["float_roundtrip"] }log = "0.4"sha2 = "0.10"diff --git a/crates/derive/Cargo.toml b/crates/derive/Cargo.tomlnew file mode 100644index 0000000000..a4969317d4--- /dev/null+++ b/crates/derive/Cargo.toml@@ -0,0 +1,17 @@+[package]+name = "solidcraft-derive"+description = "SolidCraft derive macros: the walk over a feature's geometry, from role attributes on its fields"+version.workspace = true+edition.workspace = true+license.workspace = true++[lib]+proc-macro = true++[lints]+workspace = true++[dependencies]+proc-macro2 = { workspace = true }+quote = { workspace = true }+syn = { workspace = true }diff --git a/crates/derive/src/lib.rs b/crates/derive/src/lib.rsnew file mode 100644index 0000000000..04a12dae61--- /dev/null+++ b/crates/derive/src/lib.rs@@ -0,0 +1,294 @@+//! `#[derive(Walk)]`: the walks over a feature (`crate::walk::Walk`), generated from the fields of+//! a struct or an enum's variants. Each walk visits the fields in declaration order, and comes in+//! `&` and `&mut`:+//!+//! - expressions (`walk_exprs`): each with its label, kind and role; the inputs' order names their+//! parameters (`dN`);+//! - references (`walk_refs`): sketches by id, features and bodies by name;+//! - geometry (`walk_geometry`): points with their roles, planes, construction references,+//! placement points and profile selections.+//!+//! What a field is, is written once, on the field, with `#[walk(...)]`:+//!+//! - no attribute: the field's own type walks itself (`impl Walk`): a plane, a nested struct, a+//! list of them, or nothing for names, flags and numbers. A bare `Vec3` has no walk, so a point+//! that does not say its role does not compile;+//! - `length = label`, `angle = label`, `unitless = label`: an expression input (a `String`, an+//! optional one, a list or an array of them, or `(f64, String)` pairs). The label is any+//! expression: a `&'static str`, an array of them (one per element), or a closure+//! `|i: usize, n: usize| -> &'static str`; it may read the other fields;+//! - `sketch`, `feature`, `body`: a reference (an id, or a name, optional or a list);+//! - `pick`, `pinned`, `pos`, `dir`: a point (`Vec3`, optional or a list) with that role;+//! `pick_if = cond`: a pick when `cond` holds, else a position;+//! - `placement`: a primitive's placement point (its X, Y and Z expressions are not inputs);+//! - `profiles_of = sketch_field`, optionally with `when = cond`: a profile selection;+//! - `after = field`: visit this field right after `field` instead of in declaration order (where+//! the parameter names already given need it);+//! - `picks_faces`, on a nested value: its positions pick faces here (a `FaceAt` that names the+//! face it is on).+//!+//! Conditions and labels are worked out before the walk starts. The generated code names+//! `crate::walk`, so the derive is for `solidcraft-doc`.++#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]++use proc_macro::TokenStream;+use proc_macro2::{Span, TokenStream as Tokens};+use quote::{format_ident, quote};+use syn::{Data, DeriveInput, Expr, Fields, Ident, Member, parse_macro_input};++#[proc_macro_derive(Walk, attributes(walk))]+pub fn derive_walk(input: TokenStream) -> TokenStream {+ let input = parse_macro_input!(input as DeriveInput);+ match expand(&input) {+ Ok(t) => t.into(),+ Err(e) => e.to_compile_error().into(),+ }+}++/// A field's role in the geometry walk.+enum Geo {+ Points(&'static str),+ PickIf(Expr),+ Placement,+ Profiles { sketch: Ident, when: Option<Expr> },+}++/// What a field is, from its `#[walk(...)]` attributes.+#[derive(Default)]+struct Roles {+ geo: Option<Geo>,+ /// The kind (`Length`, `Angle`, `Unitless`) and the label.+ expr: Option<(&'static str, Expr)>,+ /// `Sketch`, `Feature` or `Body`.+ reference: Option<&'static str>,+ after: Option<Ident>,+ /// The positions inside this (nested) value pick faces here.+ picks_faces: bool,+}++impl Roles {+ /// No role given: the field's type walks itself.+ fn nested(&self) -> bool {+ self.geo.is_none() && self.expr.is_none() && self.reference.is_none()+ }+}++fn roles(field: &syn::Field) -> syn::Result<Roles> {+ let mut r = Roles::default();+ for attr in field.attrs.iter().filter(|a| a.path().is_ident("walk")) {+ let mut sketch = None;+ let mut when = None;+ attr.parse_nested_meta(|meta| {+ let name = meta.path.get_ident().map(Ident::to_string).unwrap_or_default();+ match name.as_str() {+ "pick" => r.geo = Some(Geo::Points("Pick")),+ "pinned" => r.geo = Some(Geo::Points("Pinned")),+ "pos" => r.geo = Some(Geo::Points("Pos")),+ "dir" => r.geo = Some(Geo::Points("Dir")),+ "placement" => r.geo = Some(Geo::Placement),+ "pick_if" => r.geo = Some(Geo::PickIf(meta.value()?.parse()?)),+ "profiles_of" => sketch = Some(meta.value()?.parse::<Ident>()?),+ "when" => when = Some(meta.value()?.parse::<Expr>()?),+ "length" => r.expr = Some(("Length", meta.value()?.parse()?)),+ "angle" => r.expr = Some(("Angle", meta.value()?.parse()?)),+ "unitless" => r.expr = Some(("Unitless", meta.value()?.parse()?)),+ "sketch" => r.reference = Some("Sketch"),+ "feature" => r.reference = Some("Feature"),+ "body" => r.reference = Some("Body"),+ "after" => r.after = Some(meta.value()?.parse()?),+ "picks_faces" => r.picks_faces = true,+ _ => return Err(meta.error("unknown walk role")),+ }+ Ok(())+ })?;+ if let Some(sketch) = sketch {+ r.geo = Some(Geo::Profiles { sketch, when });+ } else if when.is_some() {+ return Err(syn::Error::new_spanned(attr, "`when` goes with `profiles_of`"));+ }+ }+ Ok(r)+}++#[derive(Clone, Copy, PartialEq)]+enum Which {+ Exprs,+ Refs,+ Geometry,+}++/// A value worked out before the walk (a condition, a label, a sketch id) for field `b`.+fn pre(b: &Ident, what: &str) -> Ident {+ format_ident!("__{}_{}", what, b)+}++/// The statements that walk field `b` in walk `which`.+fn walk_field(b: &Ident, r: &Roles, which: Which, mutable: bool) -> Tokens {+ let w = quote!(crate::walk);+ let each = if mutable { quote!(each_mut) } else { quote!(each) };+ if r.nested() {+ let m = match which {+ Which::Exprs => "walk_exprs",+ Which::Refs => "walk_refs",+ Which::Geometry => "walk_geometry",+ };+ let m = if mutable { format_ident!("{}_mut", m) } else { format_ident!("{}", m) };+ if r.picks_faces && which == Which::Geometry {+ return quote! {+ #w::Walk::#m(#b, &mut |g| f(match g { #w::Geo::Pos(p) => #w::Geo::Pick(p), g => g }));+ };+ }+ return quote! { #w::Walk::#m(#b, f); };+ }+ match which {+ Which::Exprs => {+ let label = pre(b, "label");+ match (&r.expr, &r.geo) {+ (Some((kind, _)), _) => {+ let kind = Ident::new(kind, Span::call_site());+ quote! {+ #w::ExprField::#each(#b, &mut |i, n, e| f((#w::Label::at(&#label, i, n), e, #w::Kind::#kind, #w::ExprRole::Input)));+ }+ }+ (None, Some(Geo::Placement)) => quote! {+ #w::ExprField::#each(#b, &mut |i, n, e| f((#w::Label::at(&["X", "Y", "Z"], i, n), e, #w::Kind::Length, #w::ExprRole::Placement)));+ },+ _ => quote!(),+ }+ }+ Which::Refs => match r.reference {+ Some(kind) => {+ let t = if kind == "Sketch" { quote!(u64) } else { quote!(String) };+ let kind = Ident::new(kind, Span::call_site());+ quote! { #w::Each::<#t>::#each(#b, &mut |x| f(#w::Ref::#kind(x))); }+ }+ None => quote!(),+ },+ Which::Geometry => match &r.geo {+ Some(Geo::Points(v)) => {+ let v = Ident::new(v, Span::call_site());+ quote! { #w::Each::<#w::Vec3>::#each(#b, &mut |p| f(#w::Geo::#v(p))); }+ }+ Some(Geo::PickIf(_)) => {+ let pick = pre(b, "pick");+ quote! {+ #w::Each::<#w::Vec3>::#each(#b, &mut |p| f(if #pick { #w::Geo::Pick(p) } else { #w::Geo::Pos(p) }));+ }+ }+ Some(Geo::Placement) => quote! { f(#w::Geo::Placement(#b)); },+ Some(Geo::Profiles { .. }) => {+ let (id, when) = (pre(b, "sketch"), pre(b, "when"));+ quote! {+ if #when && let Some(id) = #id {+ #w::Each::<#w::ProfileSel>::#each(#b, &mut |sel| f(#w::Geo::Profiles(id, sel)));+ }+ }+ }+ None => quote!(),+ },+ }+}++/// The values field `b`'s walk needs, worked out before the walk starts (the walk may hand out+/// the fields they read).+fn pre_values(b: &Ident, r: &Roles, which: Which) -> Tokens {+ let w = quote!(crate::walk);+ match (which, &r.expr, &r.geo) {+ (Which::Exprs, Some((_, label)), _) => {+ let l = pre(b, "label");+ quote! { let #l = #label; }+ }+ (Which::Geometry, _, Some(Geo::PickIf(cond))) => {+ let p = pre(b, "pick");+ quote! { let #p: bool = #cond; }+ }+ (Which::Geometry, _, Some(Geo::Profiles { sketch, when })) => {+ let (id, wh) = (pre(b, "sketch"), pre(b, "when"));+ let when = when.as_ref().map_or(quote!(true), |c| quote!(#c));+ quote! {+ let #wh: bool = #when;+ let mut #id: Option<u64> = None;+ #w::Each::<u64>::each(&*#sketch, &mut |s| #id = Some(*s));+ }+ }+ _ => quote!(),+ }+}++/// A pattern that binds every field of `fields` by name (`_0`, `_1`… for tuple fields), and the+/// body of walk `which` over them.+fn arm(fields: &Fields, which: Which, mutable: bool) -> syn::Result<(Tokens, Tokens)> {+ let mut members = Vec::new();+ let mut walked: Vec<(Ident, Roles)> = Vec::new();+ for (i, field) in fields.iter().enumerate() {+ let b = field.ident.clone().unwrap_or_else(|| format_ident!("_{}", i));+ members.push(field.ident.clone().map_or_else(|| Member::Unnamed(i.into()), Member::Named));+ walked.push((b, roles(field)?));+ }+ let bindings: Vec<Ident> = walked.iter().map(|(b, _)| b.clone()).collect();+ // `after = x` moves a field to just after `x`.+ for b in &bindings {+ let Some(pos) = walked.iter().position(|(x, _)| x == b) else { continue };+ let Some(after) = walked.get(pos).and_then(|(_, r)| r.after.clone()) else { continue };+ let moved = walked.remove(pos);+ let Some(at) = walked.iter().position(|(x, _)| *x == after) else {+ return Err(syn::Error::new_spanned(after, "no such field"));+ };+ walked.insert(at + 1, moved);+ }+ let mut body = Tokens::new();+ for (b, r) in &walked {+ body.extend(pre_values(b, r, which));+ }+ for (b, r) in &walked {+ body.extend(walk_field(b, r, which, mutable));+ }+ let pattern = match fields {+ Fields::Named(_) => quote!({ #(#bindings),* }),+ Fields::Unnamed(_) => quote!({ #(#members: #bindings),* }),+ Fields::Unit => quote!(),+ };+ Ok((pattern, body))+}++fn expand(input: &DeriveInput) -> syn::Result<Tokens> {+ let name = &input.ident;+ let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();+ let w = quote!(crate::walk);+ let mut methods = Tokens::new();+ for (which, method, item) in+ [(Which::Exprs, "walk_exprs", "ExprItem"), (Which::Refs, "walk_refs", "RefItem"), (Which::Geometry, "walk_geometry", "GeoItem")]+ {+ for mutable in [false, true] {+ let body = match &input.data {+ Data::Struct(s) => {+ let (pattern, body) = arm(&s.fields, which, mutable)?;+ quote! { let Self #pattern = self; #body }+ }+ Data::Enum(e) => {+ let mut arms = Tokens::new();+ for v in &e.variants {+ let ident = &v.ident;+ let (pattern, body) = arm(&v.fields, which, mutable)?;+ arms.extend(quote! { Self::#ident #pattern => { #body } });+ }+ quote! { match self { #arms } }+ }+ Data::Union(u) => return Err(syn::Error::new_spanned(u.union_token, "unions are not walked")),+ };+ let (method, item, r) = if mutable {+ (format_ident!("{}_mut", method), format_ident!("{}Mut", item), quote!(&'a mut))+ } else {+ (format_ident!("{}", method), format_ident!("{}", item), quote!(&'a))+ };+ methods.extend(quote! {+ #[allow(unused_variables, unused_mut, clippy::needless_borrow)]+ fn #method<'a>(#r self, f: &mut dyn FnMut(#w::#item<'a>)) { #body }+ });+ }+ }+ Ok(quote! {+ impl #impl_generics #w::Walk for #name #ty_generics #where_clause { #methods }+ })+}diff --git a/crates/doc/Cargo.toml b/crates/doc/Cargo.tomlindex 4c6253dad3..4fac21b0c0 100644--- a/crates/doc/Cargo.toml+++ b/crates/doc/Cargo.toml@@ -13,6 +13,7 @@ solidcraft-geom = { workspace = true }solidcraft-sketch = { workspace = true }solidcraft-kernel = { workspace = true }solidcraft-render = { workspace = true }+solidcraft-derive = { workspace = true }serde = { workspace = true }serde_json = { workspace = true }thiserror = { workspace = true }diff --git a/crates/doc/src/assembly.rs b/crates/doc/src/assembly.rsindex 0d2f5a1ef6..aeda6e2655 100644--- a/crates/doc/src/assembly.rs+++ b/crates/doc/src/assembly.rs@@ -205,6 +205,7 @@ impl FeatureKind {/// Map the feature's world geometry (points, directions, explicit planes) by `m`.pub fn transform_geometry(&mut self, m: &Mat) {use crate::feature_geometry::Geo;+ use crate::walk::Walk;self.walk_geometry_mut(&mut |g| match g {Geo::Pick(p) | Geo::Pos(p) => *p = apply_point(m, *p),Geo::Dir(v) => *v = apply_vector(m, *v),diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex 076513c609..d9b19331db 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -187,48 +187,57 @@ pub enum RevolveConvention {}/// Extent of an extrude.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]pub struct Extent {+ #[walk(length = "Distance")]pub distance: String,#[serde(default)]pub direction: Direction,/// Optional second side distance (two-sided extrude), along the negative normal.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Distance 2")]pub distance2: Option<String>,/// Start offset from the sketch plane (expression), along the sketch normal whatever the/// direction.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Start offset")]pub start_offset: Option<String>,/// Through all bodies in the direction(s) instead of `distance`.#[serde(default, skip_serializing_if = "std::ops::Not::not")]pub through_all: bool,/// Taper angle (expression; positive grows the profile).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Taper angle")]pub taper: Option<String>,/// To Object: end at the face (or vertex/point) at this point, instead of `distance`.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(pick)]pub to: Option<Vec3>,/// Offset past the To Object face (expression; negative stops short).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "To offset")]pub to_offset: Option<String>,/// From Object: start at the face (or point) here instead of the sketch plane (plus/// `start_offset`).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(pick)]pub from: Option<Vec3>,}/// Thin Extrude: a wall of constant thickness along sketch curves instead of the profiles.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]pub struct ThinWall {/// The sketch curves the wall follows: open chains and closed loops, joined where they/// meet end to end.pub curves: Vec<String>,/// The wall thickness (expression); with `side: two_sides`, the thickness inside.+ #[walk(length = "Thickness")]pub thickness: String,#[serde(default, skip_serializing_if = "ThinSide::is_center")]pub side: ThinSide,/// With `side: two_sides`, the thickness outside (expression).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Thickness 2")]pub thickness2: Option<String>,}@@ -263,7 +272,7 @@ impl ThinSide {}/// Revolve axis.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]#[serde(tag = "type", rename_all = "snake_case")]pub enum AxisRef {/// A line of the profile's sketch.@@ -273,13 +282,20 @@ pub enum AxisRef {/// World X / Y / Z axis through the origin.World { axis: String },/// Any line in the sketch plane, in world coordinates.- Line { origin: Vec3, dir: Vec3 },+ Line {+ #[walk(pos)]+ origin: Vec3,+ #[walk(dir)]+ dir: Vec3,+ },}/// Persistent cylindrical Emboss selection, authored in the feature component frame.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]pub struct EmbossFace {+ #[walk(body)]pub body: String,+ #[walk(pinned)]pub at: Vec3,#[serde(default, skip_serializing_if = "Vec::is_empty")]pub path: Vec<u64>,@@ -359,10 +375,13 @@ impl EmbossFace {/// edge's own angle and height (expressions) in place of the feature's. In a design file an/// edge with neither is the point `[x, y, z]`, as every edge was before; one with its own/// values is `{"point": [x, y, z], "angle": "…", "height": "…"}`.-#[derive(Clone, Debug, Default, PartialEq)]+#[derive(Clone, Debug, Default, PartialEq, solidcraft_derive::Walk)]pub struct FlangeEdge {+ #[walk(pos)]pub point: Vec3,+ #[walk(angle = "Edge angle")]pub angle: Option<String>,+ #[walk(length = "Edge height")]pub height: Option<String>,}@@ -423,12 +442,13 @@ impl<'de> Deserialize<'de> for FlangeEdge {}/// Feature definitions.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]#[serde(tag = "type", rename_all = "snake_case")]pub enum FeatureKind {/// A recorded timeline ownership boundary. Geometry is converted from its/// current local frame into the destination component frame exactly once.BodyTransfer {+ #[walk(body)]bodies: Vec<String>,from: u64,to: u64,@@ -440,29 +460,38 @@ pub enum FeatureKind {},Extrude {/// Feature id of the sketch.+ #[walk(sketch)]sketch: u64,+ // A thin extrude follows curves; its profiles are not used.+ #[walk(profiles_of = sketch, when = thin.is_none())]profiles: ProfileSel,extent: Extent,#[serde(default)]operation: Operation,/// Target body names for join/cut/intersect (empty = all bodies).#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]targets: Vec<String>,/// Thin: a wall along sketch curves instead of the profiles (which are then unused).#[serde(default, skip_serializing_if = "Option::is_none")]thin: Option<ThinWall>,},Revolve {+ #[walk(sketch)]sketch: u64,+ #[walk(profiles_of = sketch)]profiles: ProfileSel,axis: AxisRef,+ #[walk(angle = "Angle")]angle: String,#[serde(default)]operation: Operation,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]targets: Vec<String>,/// Two Sides: the angle on the other side.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Angle 2")]angle2: Option<String>,/// Symmetric: `angle` split evenly either side of the profile.#[serde(default, skip_serializing_if = "std::ops::Not::not")]@@ -472,13 +501,17 @@ pub enum FeatureKind {convention: RevolveConvention,/// To Object: turn until the face, vertex or point here.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(pick)]to: Option<Vec3>,},Fillet {/// Reference points on the edges to round (each re-finds the nearest edge).+ #[walk(pos)]edges: Vec<Vec3>,+ #[walk(length = style.radius_label())]radius: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,/// Constant radius (the default), chord length (`radius` is the width across), or a/// radius varying along each edge.@@ -489,56 +522,76 @@ pub enum FeatureKind {fit: FilletFit,},Chamfer {+ #[walk(pos)]edges: Vec<Vec3>,+ #[walk(length = "Distance")]distance: String,/// Unequal chamfers: the distance along the second face…#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Distance 2")]distance2: Option<String>,/// …or the angle the chamfer makes with the first face.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Angle")]angle: Option<String>,/// Swap which face is the first (by default the one facing up most).#[serde(default, skip_serializing_if = "std::ops::Not::not")]flip: bool,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},Box {#[serde(with = "point_expr")]+ #[walk(placement)]corner: PointExpr,+ #[walk(length = "Length")]length: String,+ #[walk(length = "Width")]width: String,+ #[walk(length = "Height")]height: String,#[serde(default)]operation: Operation,},Cylinder {#[serde(with = "point_expr")]+ #[walk(placement)]base: PointExpr,#[serde(default = "z_axis")]+ #[walk(dir)]axis: Vec3,+ #[walk(length = "Radius")]radius: String,+ #[walk(length = "Height")]height: String,#[serde(default)]operation: Operation,},Sphere {#[serde(with = "point_expr")]+ #[walk(placement)]center: PointExpr,+ #[walk(length = "Radius")]radius: String,#[serde(default)]operation: Operation,},Torus {#[serde(with = "point_expr")]+ #[walk(placement)]center: PointExpr,+ #[walk(length = "Major radius")]major: String,+ #[walk(length = "Minor radius")]minor: String,#[serde(default)]operation: Operation,},Combine {+ #[walk(body)]target: String,+ #[walk(body)]tools: Vec<String>,operation: Operation,#[serde(default)]@@ -546,18 +599,22 @@ pub enum FeatureKind {},/// Copies of other features' results, or of bodies (rectangular, circular or along a path).Pattern {+ #[walk(feature)]features: Vec<String>,pattern: PatternKind,/// Copy these bodies (as new bodies) instead of replaying features.#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]bodies: Vec<String>,},/// Mirror copies of other features' results in a plane.Mirror {+ #[walk(feature)]features: Vec<String>,plane: PlaneRef,/// Mirror these bodies instead of replaying features.#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]bodies: Vec<String>,/// Join each mirrored body with its original.#[serde(default, skip_serializing_if = "std::ops::Not::not")]@@ -565,12 +622,16 @@ pub enum FeatureKind {},/// A drilled hole (simple, counterbore or countersink) at a point, into the material.Hole {+ #[walk(pick_if = points.is_none())]position: Vec3,/// Drilling direction (into the material).+ #[walk(dir)]direction: Vec3,+ #[walk(length = "Diameter")]diameter: String,/// Depth to the shoulder; `None` = through all.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Depth")]depth: Option<String>,#[serde(default)]hole: HoleKind,@@ -583,17 +644,20 @@ pub enum FeatureKind {thread: Option<String>,/// To Object: drill down to the face (or point) here instead of `depth`.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(pick)]to: Option<Vec3>,},/// A thread on a cylindrical face. Cosmetic by default (no geometry change; drawn and/// exported as an annotation); `modeled` cuts the real helical ISO profile into the face./// `designation` is an ISO metric size such as "M8" or "M8x1".Thread {+ #[walk(pick)]face: Vec3,#[serde(default, skip_serializing_if = "Option::is_none")]designation: Option<String>,/// Thread length from the face's end nearest `face`; `None` = full length.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Length")]length: Option<String>,#[serde(default, skip_serializing_if = "std::ops::Not::not")]modeled: bool,@@ -604,24 +668,32 @@ pub enum FeatureKind {#[serde(default)]operation: Operation,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]targets: Vec<String>,},/// Sweep profiles along a chain of sketch curves.Sweep {+ #[walk(sketch)]sketch: u64,+ #[walk(profiles_of = sketch)]profiles: ProfileSel,+ #[walk(sketch)]path_sketch: u64,path: Vec<String>,#[serde(default)]operation: Operation,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]targets: Vec<String>,},/// Hollow a body leaving walls of `thickness`, removing the faces at the given points.Shell {+ #[walk(pick)]faces: Vec<Vec3>,+ #[walk(length = "Thickness")]thickness: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,/// inside (default) | outside | both (the wall straddles the faces).#[serde(default, skip_serializing_if = "String::is_empty")]@@ -632,11 +704,15 @@ pub enum FeatureKind {},/// Tilt faces (at the given points) about a neutral plane, leaning toward `pull`.Draft {+ #[walk(pick)]faces: Vec<Vec3>,+ #[walk(angle = "Angle")]angle: String,neutral: PlaneRef,+ #[walk(dir)]pull: Vec3,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// A construction plane (sketch placement, split tool).@@ -646,6 +722,7 @@ pub enum FeatureKind {/// Split a body into the parts on either side of a plane, or of a face of a body (the face/// through `point`, its surface extended) when `tool` is set.Split {+ #[walk(body)]body: String,plane: PlaneRef,#[serde(default, skip_serializing_if = "Option::is_none")]@@ -663,38 +740,50 @@ pub enum FeatureKind {/// a face of a body (`tool`, its surface extended) or a sketch's curves (`sketch`, swept/// along its normal). The pieces are named after the face (`#k`).SplitFace {+ #[walk(pick)]faces: Vec<Vec3>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,plane: PlaneRef,#[serde(default, skip_serializing_if = "Option::is_none")]tool: Option<FaceAt>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(sketch)]sketch: Option<u64>,},/// Scale bodies about a point (uniform, or per axis).Scale {+ #[walk(body)]bodies: Vec<String>,#[serde(default)]+ #[walk(pos)]origin: Vec3,+ #[walk(unitless = "Scale factor")]factor: String,/// Per-axis factors instead of `factor`.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(unitless = ["X scale", "Y scale", "Z scale"])]factors: Option<[String; 3]>,},/// Move planar faces (at the given points) along their normals; the body keeps its shape.OffsetFace {+ #[walk(pick)]faces: Vec<Vec3>,+ #[walk(length = "Distance")]distance: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Remove faces (at the given points) and heal the gap from the neighbouring planes, as when/// a fillet, chamfer, hole or boss is taken off. A picked face brings the rest of its surface/// (both halves of a hole's wall).DeleteFace {+ #[walk(pick)]faces: Vec<Vec3>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,/// Close the gap by extending the neighbouring faces (the default); `false` leaves it/// open, the faces left a surface body.@@ -703,42 +792,55 @@ pub enum FeatureKind {},/// A box around bodies, grown by a margin.BoundingSolid {+ #[walk(body)]bodies: Vec<String>,#[serde(default = "zero_expr")]+ #[walk(length = "Margin")]margin: String,},/// A tube along a chain of sketch curves (solid, or hollow with a wall thickness).Pipe {+ #[walk(sketch)]path_sketch: u64,path: Vec<String>,+ #[walk(length = "Diameter")]diameter: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Wall")]wall: Option<String>,#[serde(default)]operation: Operation,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]targets: Vec<String>,},/// Raise or sink profiles on a planar face, or wrap them on a selected cylindrical wall.Emboss {+ #[walk(sketch)]sketch: u64,+ #[walk(profiles_of = sketch)]profiles: ProfileSel,+ #[walk(length = "Depth")]depth: String,#[serde(default, skip_serializing_if = "std::ops::Not::not")]deboss: bool,#[serde(default, skip_serializing_if = "Option::is_none")]face: Option<EmbossFace>,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]targets: Vec<String>,},/// A thin wall from open sketch curves: `thickness` across the sketch plane, filling from/// the curves toward the body (to the next face, or `depth`). A web makes one per curve.Rib {+ #[walk(sketch)]sketch: u64,curves: Vec<String>,+ #[walk(length = "Thickness")]thickness: String,/// Depth from the curves; `None` = to the next face of the body.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Depth")]depth: Option<String>,/// Fill toward the other side of the curves.#[serde(default, skip_serializing_if = "std::ops::Not::not")]@@ -749,19 +851,26 @@ pub enum FeatureKind {},/// Move planar faces (at the given points) onto a target plane parallel to them.ReplaceFace {+ #[walk(pick)]faces: Vec<Vec3>,target: PlaneRef,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Move bodies so that `from` lands on `to` (and, with normals, the faces meet face to face).Align {+ #[walk(body)]bodies: Vec<String>,+ #[walk(pos)]from: Vec3,+ #[walk(pos)]to: Vec3,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(dir)]from_normal: Option<Vec3>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(dir)]to_normal: Option<Vec3>,/// Normals the same way instead of facing each other.#[serde(default, skip_serializing_if = "std::ops::Not::not")]@@ -771,12 +880,18 @@ pub enum FeatureKind {/// `pitch` per turn, on a helix of `diameter` (the section's centre, or its inside or outside).Coil {#[serde(with = "point_expr")]+ #[walk(placement)]base: PointExpr,#[serde(default = "z_axis")]+ #[walk(dir)]axis: Vec3,+ #[walk(length = "Diameter")]diameter: String,+ #[walk(length = "Pitch")]pitch: String,+ #[walk(unitless = "Revolutions")]turns: String,+ #[walk(length = "Section size")]section_size: String,#[serde(default)]section: CoilSection,@@ -786,6 +901,7 @@ pub enum FeatureKind {/// Start angle about the axis (expression; 0 = from the axis toward +x, or a/// perpendicular direction when the axis is x).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Start angle")]start_angle: Option<String>,/// Turn the other way (left-handed).#[serde(default, skip_serializing_if = "std::ops::Not::not")]@@ -793,11 +909,14 @@ pub enum FeatureKind {#[serde(default)]operation: Operation,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]targets: Vec<String>,},/// Sheet metal base flange: a sheet from a closed profile (thickness from the rule).SheetBase {+ #[walk(sketch)]sketch: u64,+ #[walk(profiles_of = sketch)]profiles: ProfileSel,#[serde(default, skip_serializing_if = "Option::is_none")]rule: Option<String>,@@ -807,8 +926,10 @@ pub enum FeatureKind {},/// Sheet metal contour flange: a sheet bent along an open chain of sketch lines.SheetContour {+ #[walk(sketch)]sketch: u64,curves: Vec<String>,+ #[walk(length = "Distance")]distance: String,#[serde(default, skip_serializing_if = "Option::is_none")]rule: Option<String>,@@ -822,10 +943,14 @@ pub enum FeatureKind {/// Edge flanges on sheet edges (points on the top or bottom edges). `height` and `angle`/// hold for every edge that doesn't carry its own (see [`FlangeEdge`]).SheetFlange {+ #[walk(after = radius)]edges: Vec<FlangeEdge>,+ #[walk(length = "Height")]height: String,+ #[walk(angle = "Angle")]angle: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Bend radius")]radius: Option<String>,/// inside | outside | middle.#[serde(default = "inside_str")]@@ -833,17 +958,22 @@ pub enum FeatureKind {#[serde(default, skip_serializing_if = "std::ops::Not::not")]flip: bool,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Flat hems on sheet edges.SheetHem {+ #[walk(pos)]edges: Vec<Vec3>,+ #[walk(length = "Length")]length: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Gap")]gap: Option<String>,#[serde(default, skip_serializing_if = "std::ops::Not::not")]flip: bool,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// A perforation field (#732): round holes of `diameter` on a staggered (60°) or square grid of `pitch` over the@@ -851,26 +981,35 @@ pub enum FeatureKind {/// a cosmetic thread: the holes go to the flat pattern, the DXF and the measured volume, not into the B-rep, so a/// panel can carry tens of thousands of them.SheetPerforate {+ #[walk(length = "Diameter")]diameter: String,+ #[walk(length = "Pitch")]pitch: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Margin")]margin: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]pattern: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Fold a sheet along a line on its base face: a sketch line (followed when the sketch/// changes), else the points `a`, `b`.SheetFold {#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(sketch)]sketch: Option<u64>,#[serde(default, skip_serializing_if = "Option::is_none")]curve: Option<String>,+ #[walk(pos)]a: Vec3,+ #[walk(pos)]b: Vec3,+ #[walk(angle = "Angle")]angle: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Bend radius")]radius: Option<String>,/// centerline | start | end | mouldposition: String,@@ -878,13 +1017,16 @@ pub enum FeatureKind {flip: bool,/// A point on the side that stays put (default: the larger side).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(pos)]fixed: Option<Vec3>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Unfold a sheet body flat (all bends), or refold it.SheetUnfold {#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,#[serde(default, skip_serializing_if = "std::ops::Not::not")]refold: bool,@@ -893,105 +1035,146 @@ pub enum FeatureKind {/// thickness or, with `bends`, a solid or shelled body whose faces reached from the fixed/// face across those edges become the sheet.SheetConvert {+ #[walk(body)]body: String,+ #[walk(pick_if = !bends.is_empty())]face: Vec3,#[serde(default, skip_serializing_if = "Option::is_none")]rule: Option<String>,/// Points on the sharp edges that become bends.#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(pos)]bends: Vec<Vec3>,},/// Plastic boss: a round post on a face (draft, root fillet, hole, ribs).Boss {+ #[walk(pick)]position: Vec3,/// Out of the face (the boss grows along it).#[serde(default = "z_axis")]+ #[walk(dir)]direction: Vec3,+ #[walk(length = "Diameter")]diameter: String,+ #[walk(length = "Height")]height: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Hole diameter")]hole_diameter: Option<String>,/// Hole depth from the top (default: down to the face).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Hole depth")]hole_depth: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Draft angle")]draft: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Root fillet")]fillet: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(unitless = "Ribs")]ribs: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Rib thickness")]rib_thickness: Option<String>,/// Rib reach out from the boss wall.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Rib length")]rib_length: Option<String>,/// Rib top below the boss top.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Rib offset")]rib_offset: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Plastic lip (raised band) or groove (recess) along the rim face picked at `face`.Lip {+ #[walk(pos)]face: Vec3,+ #[walk(length = "Width")]width: String,+ #[walk(length = "Height")]height: String,#[serde(default, skip_serializing_if = "std::ops::Not::not")]groove: bool,/// Clearance added to a groove's width (and depth).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Gap")]gap: Option<String>,/// Along the rim's outer edge instead of its inner one.#[serde(default, skip_serializing_if = "std::ops::Not::not")]outside: bool,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Plastic snap fit: a cantilever arm on a face with a hook (catch) at its tip.SnapFit {+ #[walk(pick)]position: Vec3,/// The arm grows along this (out of the face).#[serde(default = "z_axis")]+ #[walk(dir)]direction: Vec3,/// The catch sticks out this way.+ #[walk(dir)]hook: Vec3,+ #[walk(length = "Length")]length: String,+ #[walk(length = "Thickness")]thickness: String,+ #[walk(length = "Width")]width: String,+ #[walk(length = "Catch depth")]catch_depth: String,/// The catch's height along the arm.+ #[walk(length = "Catch length")]catch_length: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Plastic rest: a raised pad on a face (round, or a rectangle), solid or a hollow wall,/// with draft.Rest {+ #[walk(pick)]position: Vec3,/// Out of the face (the pad grows along it).#[serde(default = "z_axis")]+ #[walk(dir)]direction: Vec3,/// The rectangle's length runs along this (default: any direction in the face).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(dir)]along: Option<Vec3>,/// Diameter of a round rest, or the rectangle's width.+ #[walk(length = "Width")]width: String,/// The rectangle's length (none: round).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Length", after = height)]length: Option<String>,+ #[walk(length = "Height")]height: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Draft angle")]draft: Option<String>,/// Wall thickness of a hollow rest (none: solid).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Wall thickness")]thickness: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,},/// Boundary Fill: solids from the cells the tool bodies enclose (a cell: inside some/// tools and outside the rest), each picked by a point inside it.BoundaryFill {+ #[walk(body)]tools: Vec<String>,+ #[walk(pos)]cells: Vec<Vec3>,#[serde(default)]operation: Operation,@@ -1001,43 +1184,55 @@ pub enum FeatureKind {},/// Remove bodies from the model (from here on in the timeline).Remove {+ #[walk(body)]bodies: Vec<String>,},/// Surface bodies: planar patches filling sketch regions (`profiles` of `sketch`), or a/// closed loop of a body's edges (`edges`: points on them, on `body`).Patch {#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(sketch)]sketch: Option<u64>,#[serde(default = "all_profiles")]+ #[walk(profiles_of = sketch)]profiles: ProfileSel,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(pos)]edges: Vec<Vec3>,},/// Surface bodies sewn along shared edges into the first one (a solid when they close).Stitch {+ #[walk(body)]bodies: Vec<String>,#[serde(default = "zero_expr")]+ #[walk(length = "Tolerance")]tolerance: String,},/// Surface bodies thickened into solids along their normals (by half each way when/// `symmetric`).Thicken {+ #[walk(body)]bodies: Vec<String>,+ #[walk(length = "Thickness")]thickness: String,#[serde(default)]symmetric: bool,operation: Operation,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(body)]targets: Vec<String>,},/// A surface body swept straight along the sketch normal from open curve chains and the/// boundaries of profiles: walls only, no caps.SurfaceExtrude {+ #[walk(sketch)]sketch: u64,/// Profiles whose boundary loops are swept (none: only `curves`).#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(profiles_of = sketch)]profiles: Option<ProfileSel>,/// Sketch curve ids, grouped into chains of curves that meet end to end.#[serde(default, skip_serializing_if = "Vec::is_empty")]@@ -1047,14 +1242,18 @@ pub enum FeatureKind {/// A body taken apart: each face at `faces` (every face when empty) its own surface body,/// the faces left one surface body under the body's name. A solid comes apart into surfaces.Unstitch {+ #[walk(body)]body: String,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(pos)]faces: Vec<Vec3>,},/// A surface body with the faces at `faces` (every face when empty) turned over.ReverseNormal {+ #[walk(body)]body: String,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(pos)]faces: Vec<Vec3>,},/// The face at `face` restored towards its surface: the inner loops at the `holes` points@@ -1062,8 +1261,11 @@ pub enum FeatureKind {/// back at the surface's natural bounds (an analytic surface's: the face's own span). A new/// surface body; with `in_place`, a surface body's face is untrimmed where it is.SurfaceUntrim {+ // The face is picked (and named); the holes are picked by points on their edges.+ #[walk(picks_faces)]face: FaceAt,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(pos)]holes: Option<Vec<Vec3>>,#[serde(default, skip_serializing_if = "std::ops::Not::not")]outer: bool,@@ -1073,15 +1275,19 @@ pub enum FeatureKind {/// A surface body turned about an axis from open curve chains and the boundaries of/// profiles: walls only, no caps (a solid where a full turn closes them).SurfaceRevolve {+ #[walk(sketch)]sketch: u64,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(profiles_of = sketch)]profiles: Option<ProfileSel>,#[serde(default, skip_serializing_if = "Vec::is_empty")]curves: Vec<String>,axis: AxisRef,+ #[walk(angle = "Angle")]angle: String,/// Two Sides: the angle on the other side.#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Angle 2")]angle2: Option<String>,/// Symmetric: `angle` split evenly either side of the sketch.#[serde(default, skip_serializing_if = "std::ops::Not::not")]@@ -1090,11 +1296,14 @@ pub enum FeatureKind {/// A surface body swept along a chain of sketch curves from open curve chains and the/// boundaries of profiles: walls only, no caps.SurfaceSweep {+ #[walk(sketch)]sketch: u64,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(profiles_of = sketch)]profiles: Option<ProfileSel>,#[serde(default, skip_serializing_if = "Vec::is_empty")]curves: Vec<String>,+ #[walk(sketch)]path_sketch: u64,path: Vec<String>,},@@ -1107,13 +1316,17 @@ pub enum FeatureKind {/// surface body (0 copies them); `chain` takes each pick's whole smooth chain of faces;/// fitted faces within `tolerance`.SurfaceOffset {+ #[walk(pick)]faces: Vec<Vec3>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(body)]body: Option<String>,+ #[walk(length = "Distance")]distance: String,#[serde(default, skip_serializing_if = "std::ops::Not::not")]chain: bool,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Tolerance")]tolerance: Option<String>,},/// A strip of ruled surface `distance` wide hanging off the chain of `body`'s edges through@@ -1121,20 +1334,26 @@ pub enum FeatureKind {/// face's normal; along `direction`), from the face at `face` where it borders the chain;/// `flip` puts it on the other side; sharp corners as `corners` says.SurfaceRuled {+ #[walk(body)]body: String,+ #[walk(pos)]edges: Vec<Vec3>,+ #[walk(length = "Distance")]distance: String,#[serde(default, skip_serializing_if = "RuledMode::is_normal")]mode: RuledMode,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Angle")]angle: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(dir)]direction: Option<Vec3>,#[serde(default, skip_serializing_if = "std::ops::Not::not")]flip: bool,#[serde(default, skip_serializing_if = "RuledCorners::is_mitre")]corners: RuledCorners,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(pick)]face: Option<Vec3>,},/// A surface body's boundary edges through `edges` extended outward: by `distance`, or up@@ -1142,8 +1361,11 @@ pub enum FeatureKind {/// (tangent, curvature). `neighbours`: the edges next to an extended edge are lengthened to/// meet it (else the extension's sides run square to the edge).SurfaceExtend {+ #[walk(body)]body: String,+ #[walk(pos)]edges: Vec<Vec3>,+ #[walk(length = "Distance")]distance: String,#[serde(default, skip_serializing_if = "ExtendMode::is_natural")]mode: ExtendMode,@@ -1155,18 +1377,24 @@ pub enum FeatureKind {/// A surface body trimmed by a plane, or by a face of a body (`tool`), keeping the side of/// `keep`.SurfaceTrim {+ #[walk(body)]body: String,plane: PlaneRef,#[serde(default, skip_serializing_if = "Option::is_none")]tool: Option<FaceAt>,+ #[walk(pos)]keep: Vec3,},Move {+ #[walk(body)]bodies: Vec<String>,+ #[walk(length = ["X distance", "Y distance", "Z distance"])]translate: [String; 3],#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(dir)]rotate_axis: Option<Vec3>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(angle = "Angle")]angle: Option<String>,/// When set, the original bodies are kept and the transform is applied to a new copy/// of each instead of moving them in place.@@ -1187,7 +1415,9 @@ pub enum FeatureKind {},/// Rebuild an upstream constant-section mesh with analytic planar/cylindrical faces.MeshConvert {+ #[walk(body)]body: String,+ #[walk(length = "Tolerance")]tolerance: String,},/// Mesh bodies imported from a 3MF or STL file, embedded in the design.@@ -1218,7 +1448,7 @@ impl ExtendMode {}/// What Extend extends up to instead of a distance.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]#[serde(rename_all = "snake_case")]pub enum ExtendTo {/// A plane.@@ -1230,7 +1460,7 @@ pub enum ExtendTo {}/// How a fillet's size is given.-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]#[serde(tag = "type", rename_all = "snake_case")]pub enum FilletStyle {#[default]@@ -1243,9 +1473,12 @@ pub enum FilletStyle {/// `radius` at the end of each edge nearest `start`, `radius2` at the other; `mid` radii at/// positions between (0 to 1 from the start end); straight between them, or `smooth`.Variable {+ #[walk(length = "End radius")]radius2: String,+ #[walk(pos)]start: Vec3,#[serde(default, skip_serializing_if = "Vec::is_empty")]+ #[walk(length = "Mid radius")]mid: Vec<(f64, String)>,#[serde(default, skip_serializing_if = "std::ops::Not::not")]smooth: bool,@@ -1253,7 +1486,13 @@ pub enum FilletStyle {/// The radius along each edge as a clamped B-spline of the position from the end nearest/// `start` (0) to the other (1): `radius` is its first control radius and `radii` the rest,/// its degree what `knots` leave (knots = control radii + degree + 1).- Spline { start: Vec3, knots: Vec<f64>, radii: Vec<String> },+ Spline {+ #[walk(pos)]+ start: Vec3,+ knots: Vec<f64>,+ #[walk(length = |i: usize, n: usize| if i + 1 == n { "End radius" } else { "Control radius" })]+ radii: Vec<String>,+ },}/// A fillet radius too large for the geometry around its edges: refused (`Exact`, the default),@@ -1280,6 +1519,16 @@ impl FilletStyle {*self == FilletStyle::Constant}+ /// What the feature's `radius` is in this style (the label of its parameter).+ pub fn radius_label(&self) -> &'static str {+ match self {+ FilletStyle::Constant => "Radius",+ FilletStyle::Curvature => "Equivalent radius",+ FilletStyle::Chord => "Chord length",+ FilletStyle::Variable { .. } | FilletStyle::Spline { .. } => "Start radius",+ }+ }+/// The spline of a [`FilletStyle::Spline`] with its control radii `values` (the first is/// the feature's `radius`).pub fn spline(knots: &[f64], values: Vec<f64>) -> solidcraft_kernel::RadiusSpline {@@ -1289,9 +1538,11 @@ impl FilletStyle {}/// A face picked by a point on it, on a named body.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]pub struct FaceAt {+ #[walk(body)]pub body: String,+ #[walk(pos)]pub point: Vec3,}@@ -1308,8 +1559,9 @@ pub struct MeshData {}/// Points of a sketch, by id.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]pub struct SketchPoints {+ #[walk(sketch)]pub sketch: u64,pub ids: Vec<String>,/// Drill the other way: away from the side the holes would go into by themselves.@@ -1329,9 +1581,11 @@ pub struct Component {}/// One loft section: profiles of a sketch.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]pub struct LoftSection {+ #[walk(sketch)]pub sketch: u64,+ #[walk(profiles_of = sketch, when = point.is_none())]pub profiles: ProfileSel,/// A sketch point instead of a profile (the loft closes to it, as a pyramid's apex).#[serde(default, skip_serializing_if = "Option::is_none")]@@ -1340,10 +1594,12 @@ pub struct LoftSection {/// A section of a surface loft: one chain from a sketch (one profile's boundary, or curves/// meeting end to end).-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]pub struct SheetSection {+ #[walk(sketch)]pub sketch: u64,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(profiles_of = sketch)]pub profiles: Option<ProfileSel>,#[serde(default, skip_serializing_if = "Vec::is_empty")]pub curves: Vec<String>,@@ -1363,54 +1619,72 @@ fn is_zero_i8(v: &i8) -> bool {}/// Hole shapes.-#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize, solidcraft_derive::Walk)]#[serde(tag = "type", rename_all = "snake_case")]pub enum HoleKind {/// Plain hole; blind holes get a drill point when `tip_angle` is set.#[default]Simple,Drilled {+ #[walk(angle = "Tip angle")]tip_angle: String,},Counterbore {+ #[walk(length = "Counterbore diameter")]cb_diameter: String,+ #[walk(length = "Counterbore depth")]cb_depth: String,},Countersink {+ #[walk(length = "Countersink diameter")]cs_diameter: String,+ #[walk(angle = "Countersink angle")]cs_angle: String,},}/// Pattern layouts.-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]#[serde(tag = "type", rename_all = "snake_case")]pub enum PatternKind {Rectangular {+ #[walk(dir)]dir1: Vec3,+ #[walk(unitless = "Quantity")]count1: String,+ #[walk(length = "Spacing")]spacing1: String,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(dir)]dir2: Option<Vec3>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(unitless = "Quantity 2")]count2: Option<String>,#[serde(default, skip_serializing_if = "Option::is_none")]+ #[walk(length = "Spacing 2")]spacing2: Option<String>,},Circular {+ #[walk(pos)]origin: Vec3,+ #[walk(dir)]axis: Vec3,+ #[walk(unitless = "Quantity")]count: String,/// Total angle (360 deg = evenly around).+ #[walk(angle = "Total angle")]angle: String,},/// Copies along a chain of sketch curves: instance k moves by path(k·spacing) − path(0),/// measured along the path from its start.Path {+ #[walk(sketch)]path_sketch: u64,path: Vec<String>,+ #[walk(unitless = "Quantity")]count: String,/// Distance along the path between instances, or the whole extent when `extent`.+ #[walk(length = "Distance")]spacing: String,/// `spacing` is the distance from the first to the last instance.#[serde(default, skip_serializing_if = "std::ops::Not::not")]diff --git a/crates/doc/src/feature_geometry.rs b/crates/doc/src/feature_geometry.rsindex 8d1aad9236..0994beeb02 100644--- a/crates/doc/src/feature_geometry.rs+++ b/crates/doc/src/feature_geometry.rs@@ -1,14 +1,13 @@//! The geometry a feature holds, each piece with its role: the points that pick faces (moved//! with the feature, and the source of its persistent face names), other positions, directions,//! planes, construction references, a primitive's placement point and its profile selections.-//! One walk, written once for `&` and `&mut`, behind `transform_geometry`, `face_points`,-//! `profile_sels` and `point_expr`. Every variant is listed, so a new one has to say what each of-//! its points is.+//! The walk (`crate::walk`) is behind `transform_geometry`, `face_points`, `profile_sels` and+//! `point_expr`.use solidcraft_geom::Vec3;-use crate::construct::GeoRef;-use crate::{AxisRef, FeatureKind, PatternKind, PlaneRef, PointExpr, ProfileSel};+use crate::walk::Walk;+use crate::{FeatureKind, PointExpr, ProfileSel};/// A piece of a feature's geometry: `V` is `&Vec3` or `&mut Vec3`, and so on for the others.pub(crate) enum Geo<V, P, G, E, S> {@@ -30,316 +29,7 @@ pub(crate) enum Geo<V, P, G, E, S> {Profiles(u64, S),}-pub(crate) type GeoItem<'a> = Geo<&'a Vec3, &'a PlaneRef, &'a GeoRef, &'a PointExpr, &'a ProfileSel>;-pub(crate) type GeoItemMut<'a> = Geo<&'a mut Vec3, &'a mut PlaneRef, &'a mut GeoRef, &'a mut PointExpr, &'a mut ProfileSel>;--/// Every piece of a feature's geometry, written once for `&` and `&mut`: `$item` is `GeoItem` or-/// `GeoItemMut`, `$refs` the matching `refs` / `refs_mut`, `$m` is `mut` or nothing. Face picks-/// come in the order the feature's face names follow.-macro_rules! geometry_walk {- ($name:ident, $item:ident, $refs:ident $(, $m:tt)?) => {- pub(crate) fn $name<'a>(&'a $($m)? self, f: &mut impl FnMut($item<'a>)) {- use Geo::{Construct, Dir, Pick, Pinned, Placement, Plane, Pos, Profiles};- match self {- FeatureKind::Sketch { plane, .. } | FeatureKind::ConstructionPlane { plane } | FeatureKind::Mirror { plane, .. } => f(Plane(plane)),- FeatureKind::ConstructionAxis { def } => {- for r in def.$refs() {- f(Construct(r));- }- }- FeatureKind::ConstructionPoint { def } => {- for r in def.$refs() {- f(Construct(r));- }- }- FeatureKind::Extrude { sketch, profiles, extent, thin, .. } => {- // A thin extrude follows curves; its profiles are not used.- if thin.is_none() {- f(Profiles(*sketch, profiles));- }- if let Some(p) = & $($m)? extent.to {- f(Pick(p));- }- if let Some(p) = & $($m)? extent.from {- f(Pick(p));- }- }- // Surface Extrude refuses `to` and `from` for now; they would pick faces as for- // Extrude.- FeatureKind::SurfaceExtrude { sketch, profiles, extent, .. } => {- if let Some(s) = profiles {- f(Profiles(*sketch, s));- }- if let Some(p) = & $($m)? extent.to {- f(Pick(p));- }- if let Some(p) = & $($m)? extent.from {- f(Pick(p));- }- }- FeatureKind::Revolve { sketch, profiles, axis, to, .. } => {- f(Profiles(*sketch, profiles));- if let AxisRef::Line { origin, dir } = axis {- f(Pos(origin));- f(Dir(dir));- }- if let Some(p) = to {- f(Pick(p));- }- }- FeatureKind::SurfaceRevolve { sketch, profiles, axis, .. } => {- if let Some(s) = profiles {- f(Profiles(*sketch, s));- }- if let AxisRef::Line { origin, dir } = axis {- f(Pos(origin));- f(Dir(dir));- }- }- FeatureKind::Sweep { sketch, profiles, .. } | FeatureKind::SheetBase { sketch, profiles, .. } => f(Profiles(*sketch, profiles)),- FeatureKind::SurfaceSweep { sketch, profiles, .. } => {- if let Some(s) = profiles {- f(Profiles(*sketch, s));- }- }- FeatureKind::Emboss { sketch, profiles, face, .. } => {- f(Profiles(*sketch, profiles));- if let Some(face) = face {- f(Pinned(& $($m)? face.at));- }- }- FeatureKind::Loft { sections, .. } => {- // A section that is a point has no profile.- for s in sections {- if s.point.is_none() {- f(Profiles(s.sketch, & $($m)? s.profiles));- }- }- }- FeatureKind::SurfaceLoft { sections } => {- for s in sections {- if let Some(p) = & $($m)? s.profiles {- f(Profiles(s.sketch, p));- }- }- }- FeatureKind::Patch { sketch, profiles, edges, .. } => {- if let Some(sketch) = sketch {- f(Profiles(*sketch, profiles));- }- for e in edges {- f(Pos(e));- }- }- FeatureKind::Fillet { edges, style, .. } => {- for e in edges {- f(Pos(e));- }- if let crate::FilletStyle::Variable { start, .. } | crate::FilletStyle::Spline { start, .. } = style {- f(Pos(start));- }- }- FeatureKind::Chamfer { edges, .. } | FeatureKind::SheetHem { edges, .. } => {- for e in edges {- f(Pos(e));- }- }- FeatureKind::SurfaceExtend { edges, up_to, .. } => {- for e in edges {- f(Pos(e));- }- match up_to {- Some(crate::ExtendTo::Plane(plane)) => f(Plane(plane)),- Some(crate::ExtendTo::Face(t)) => f(Pos(& $($m)? t.point)),- Some(crate::ExtendTo::Bounds) | None => {}- }- }- FeatureKind::Shell { faces, .. }- | FeatureKind::OffsetFace { faces, .. }- | FeatureKind::DeleteFace { faces, .. }- | FeatureKind::SurfaceOffset { faces, .. } => {- for p in faces {- f(Pick(p));- }- }- FeatureKind::SurfaceRuled { edges, direction, face, .. } => {- for e in edges {- f(Pos(e));- }- if let Some(d) = direction {- f(Dir(d));- }- if let Some(p) = face {- f(Pick(p));- }- }- FeatureKind::Unstitch { faces, .. } | FeatureKind::ReverseNormal { faces, .. } => {- for p in faces {- f(Pos(p));- }- }- // The face is picked (and named); the holes are picked by points on their edges.- FeatureKind::SurfaceUntrim { face, holes, .. } => {- f(Pick(& $($m)? face.point));- if let Some(points) = holes {- for p in points {- f(Pos(p));- }- }- }- FeatureKind::BoundaryFill { cells, .. } => {- for p in cells {- f(Pos(p));- }- }- FeatureKind::Draft { faces, neutral, pull, .. } => {- for p in faces {- f(Pick(p));- }- f(Plane(neutral));- f(Dir(pull));- }- FeatureKind::ReplaceFace { faces, target, .. } => {- for p in faces {- f(Pick(p));- }- f(Plane(target));- }- FeatureKind::SplitFace { faces, plane, tool, .. } => {- for p in faces {- f(Pick(p));- }- f(Plane(plane));- if let Some(t) = tool {- f(Pos(& $($m)? t.point));- }- }- FeatureKind::Split { plane, tool, .. } => {- f(Plane(plane));- if let Some(t) = tool {- f(Pos(& $($m)? t.point));- }- }- FeatureKind::SurfaceTrim { plane, tool, keep, .. } => {- f(Plane(plane));- if let Some(t) = tool {- f(Pos(& $($m)? t.point));- }- f(Pos(keep));- }- FeatureKind::Box { corner: p, .. } | FeatureKind::Sphere { center: p, .. } | FeatureKind::Torus { center: p, .. } => {- f(Placement(p))- }- FeatureKind::Cylinder { base, axis, .. } | FeatureKind::Coil { base, axis, .. } => {- f(Placement(base));- f(Dir(axis));- }- FeatureKind::Pattern { pattern, .. } => match pattern {- PatternKind::Rectangular { dir1, dir2, .. } => {- f(Dir(dir1));- if let Some(d) = dir2 {- f(Dir(d));- }- }- PatternKind::Circular { origin, axis, .. } => {- f(Pos(origin));- f(Dir(axis));- }- // Follows its path sketch.- PatternKind::Path { .. } => {}- },- FeatureKind::Hole { position, direction, points, to, .. } => {- // Placed at sketch points, the hole names no face by its position.- if points.is_none() {- f(Pick(position));- } else {- f(Pos(position));- }- f(Dir(direction));- if let Some(p) = to {- f(Pick(p));- }- }- FeatureKind::Thread { face, .. } => f(Pick(face)),- FeatureKind::SheetFlange { edges, .. } => {- for e in edges {- f(Pos(& $($m)? e.point));- }- }- FeatureKind::SheetFold { a, b, fixed, .. } => {- f(Pos(a));- f(Pos(b));- if let Some(p) = fixed {- f(Pos(p));- }- }- FeatureKind::SheetConvert { face, bends, .. } => {- // With bend edges the fixed face is found by name (a plate keeps its point).- if bends.is_empty() {- f(Pos(face));- } else {- f(Pick(face));- }- for p in bends {- f(Pos(p));- }- }- FeatureKind::Boss { position, direction, .. } => {- f(Pick(position));- f(Dir(direction));- }- FeatureKind::SnapFit { position, direction, hook, .. } => {- f(Pick(position));- f(Dir(direction));- f(Dir(hook));- }- FeatureKind::Rest { position, direction, along, .. } => {- f(Pick(position));- f(Dir(direction));- if let Some(a) = along {- f(Dir(a));- }- }- FeatureKind::Lip { face, .. } => f(Pos(face)),- FeatureKind::Align { from, to, from_normal, to_normal, .. } => {- f(Pos(from));- f(Pos(to));- if let Some(n) = from_normal {- f(Dir(n));- }- if let Some(n) = to_normal {- f(Dir(n));- }- }- FeatureKind::Scale { origin, .. } => f(Pos(origin)),- FeatureKind::Move { rotate_axis, .. } => {- if let Some(a) = rotate_axis {- f(Dir(a));- }- }- FeatureKind::SheetContour { .. }- | FeatureKind::SheetPerforate { .. }- | FeatureKind::SheetUnfold { .. }- | FeatureKind::Combine { .. }- | FeatureKind::BoundingSolid { .. }- | FeatureKind::Pipe { .. }- | FeatureKind::Rib { .. }- | FeatureKind::Remove { .. }- | FeatureKind::Stitch { .. }- | FeatureKind::Thicken { .. }- | FeatureKind::Import { .. }- | FeatureKind::MeshImport { .. }- | FeatureKind::MeshConvert { .. }- | FeatureKind::BodyTransfer { .. } => {}- }- }- };-}-impl FeatureKind {- geometry_walk!(walk_geometry, GeoItem, refs);- geometry_walk!(walk_geometry_mut, GeoItemMut, refs_mut, mut);-/// The points that pick faces (shell, draft, offset and replace faces, a hole's placement and/// `to`, an extrude's `to` and `from`…), in the order of the feature's persistent face names.pub fn face_points_mut(&mut self) -> Vec<&mut Vec3> {diff --git a/crates/doc/src/feature_refs.rs b/crates/doc/src/feature_refs.rsindex 9a8623a0c7..0c1b4a599d 100644--- a/crates/doc/src/feature_refs.rs+++ b/crates/doc/src/feature_refs.rs@@ -1,12 +1,12 @@//! References from a feature to the rest of the design: the sketches it is built from (by id),//! the features it names (patterned and mirrored features, the construction plane a plane is-//! built on) and the bodies it works on (by name). One walk, written once for `&` and `&mut`,-//! behind `input_sketches`, `remap_refs` and `remap_bodies`. Every variant is listed, so a new-//! one has to say what it refers to.+//! built on) and the bodies it works on (by name). The walk (`crate::walk`) is behind+//! `input_sketches`, `remap_refs` and `remap_bodies`.use std::collections::BTreeMap;-use crate::{FeatureKind, PatternKind, PlaneRef};+use crate::FeatureKind;+use crate::walk::Walk;/// A reference a feature holds: `S` is `&u64` or `&mut u64` (a sketch id), `N` is `&String` or/// `&mut String` (a feature or body name).@@ -16,228 +16,7 @@ pub(crate) enum Ref<S, N> {Body(N),}-/// The construction plane a plane is built on (through offsets and angles), for `&` and `&mut`-/// (`$m` is `mut` or nothing). Nesting is capped like every walk over a plane.-macro_rules! plane_walk {- ($name:ident $(, $m:tt)?) => {- fn $name<'a>(mut p: &'a $($m)? PlaneRef, f: &mut impl FnMut(Ref<&'a $($m)? u64, &'a $($m)? String>)) {- for _ in 0..64 {- match p {- PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => p = base,- PlaneRef::Construction { name } => return f(Ref::Feature(name)),- _ => return,- }- }- }- };-}--plane_walk!(plane_refs);-plane_walk!(plane_refs_mut, mut);--/// Every reference of a feature, written once for `&` and `&mut`: `$plane` is the matching plane-/// walk, `$m` is `mut` or nothing.-macro_rules! feature_walk {- ($name:ident, $plane:ident $(, $m:tt)?) => {- pub(crate) fn $name<'a>(&'a $($m)? self, f: &mut impl FnMut(Ref<&'a $($m)? u64, &'a $($m)? String>)) {- use Ref::{Body as B, Feature as F, Sketch as S};- match self {- FeatureKind::Sketch { plane, .. } | FeatureKind::ConstructionPlane { plane } => $plane(plane, f),- FeatureKind::Extrude { sketch, targets, .. } | FeatureKind::Revolve { sketch, targets, .. } => {- f(S(sketch));- for b in targets {- f(B(b));- }- }- FeatureKind::Emboss { sketch, targets, face, .. } => {- f(S(sketch));- if let Some(face) = face {- f(B(& $($m)? face.body));- }- for b in targets {- f(B(b));- }- }- FeatureKind::SurfaceExtrude { sketch, .. }- | FeatureKind::SurfaceRevolve { sketch, .. }- | FeatureKind::Rib { sketch, .. }- | FeatureKind::SheetBase { sketch, .. }- | FeatureKind::SheetContour { sketch, .. } => f(S(sketch)),- FeatureKind::SurfaceSweep { sketch, path_sketch, .. } => {- f(S(sketch));- f(S(path_sketch));- }- FeatureKind::SurfaceLoft { sections } => {- for s in sections {- f(S(& $($m)? s.sketch));- }- }- FeatureKind::Sweep { sketch, path_sketch, targets, .. } => {- f(S(sketch));- f(S(path_sketch));- for b in targets {- f(B(b));- }- }- FeatureKind::Pipe { path_sketch, targets, .. } => {- f(S(path_sketch));- for b in targets {- f(B(b));- }- }- FeatureKind::Loft { sections, targets, .. } => {- for s in sections {- f(S(& $($m)? s.sketch));- }- for b in targets {- f(B(b));- }- }- FeatureKind::Coil { targets, .. } => {- for b in targets {- f(B(b));- }- }- FeatureKind::Hole { points, .. } => {- if let Some(p) = points {- f(S(& $($m)? p.sketch));- }- }- FeatureKind::Pattern { features, pattern, bodies } => {- for n in features {- f(F(n));- }- if let PatternKind::Path { path_sketch, .. } = pattern {- f(S(path_sketch));- }- for b in bodies {- f(B(b));- }- }- FeatureKind::Mirror { features, plane, bodies, .. } => {- for n in features {- f(F(n));- }- $plane(plane, f);- for b in bodies {- f(B(b));- }- }- FeatureKind::Split { body, plane, tool } | FeatureKind::SurfaceTrim { body, plane, tool, .. } => {- f(B(body));- $plane(plane, f);- if let Some(t) = tool {- f(B(& $($m)? t.body));- }- }- FeatureKind::SplitFace { body, plane, tool, sketch, .. } => {- $plane(plane, f);- if let Some(s) = sketch {- f(S(s));- }- if let Some(b) = body {- f(B(b));- }- if let Some(t) = tool {- f(B(& $($m)? t.body));- }- }- FeatureKind::Draft { neutral: plane, body, .. } | FeatureKind::ReplaceFace { target: plane, body, .. } => {- $plane(plane, f);- if let Some(b) = body {- f(B(b));- }- }- FeatureKind::SheetFold { sketch, body, .. } | FeatureKind::Patch { sketch, body, .. } => {- if let Some(s) = sketch {- f(S(s));- }- if let Some(b) = body {- f(B(b));- }- }- FeatureKind::Fillet { body, .. }- | FeatureKind::Chamfer { body, .. }- | FeatureKind::Shell { body, .. }- | FeatureKind::OffsetFace { body, .. }- | FeatureKind::DeleteFace { body, .. }- | FeatureKind::SheetFlange { body, .. }- | FeatureKind::SheetHem { body, .. }- | FeatureKind::SheetPerforate { body, .. }- | FeatureKind::SheetUnfold { body, .. }- | FeatureKind::Boss { body, .. }- | FeatureKind::Lip { body, .. }- | FeatureKind::SnapFit { body, .. }- | FeatureKind::Rest { body, .. }- | FeatureKind::SurfaceOffset { body, .. } => {- if let Some(b) = body {- f(B(b));- }- }- FeatureKind::SurfaceUntrim { face, .. } => f(B(& $($m)? face.body)),- FeatureKind::SurfaceExtend { body, up_to, .. } => {- f(B(body));- match up_to {- Some(crate::ExtendTo::Plane(plane)) => $plane(plane, f),- Some(crate::ExtendTo::Face(t)) => f(B(& $($m)? t.body)),- Some(crate::ExtendTo::Bounds) | None => {}- }- }- FeatureKind::SheetConvert { body, .. }- | FeatureKind::SurfaceRuled { body, .. }- | FeatureKind::Unstitch { body, .. }- | FeatureKind::ReverseNormal { body, .. }- | FeatureKind::MeshConvert { body, .. } => f(B(body)),- FeatureKind::Combine { target, tools, .. } => {- f(B(target));- for b in tools {- f(B(b));- }- }- FeatureKind::Thicken { bodies, targets, .. } => {- for b in bodies {- f(B(b));- }- for b in targets {- f(B(b));- }- }- FeatureKind::BodyTransfer { bodies, .. }- | FeatureKind::Scale { bodies, .. }- | FeatureKind::BoundingSolid { bodies, .. }- | FeatureKind::Align { bodies, .. }- | FeatureKind::Remove { bodies }- | FeatureKind::Stitch { bodies, .. }- | FeatureKind::Move { bodies, .. } => {- for b in bodies {- f(B(b));- }- }- FeatureKind::BoundaryFill { tools, .. } => {- for b in tools {- f(B(b));- }- }- // Construction axes and points refer to geometry, which copies remap on their own- // (`Feature::remap_clone`).- FeatureKind::ConstructionAxis { .. }- | FeatureKind::ConstructionPoint { .. }- | FeatureKind::Box { .. }- | FeatureKind::Cylinder { .. }- | FeatureKind::Sphere { .. }- | FeatureKind::Torus { .. }- | FeatureKind::Thread { .. }- | FeatureKind::Import { .. }- | FeatureKind::MeshImport { .. } => {}- }- }- };-}-impl FeatureKind {- feature_walk!(walk_refs, plane_refs);- feature_walk!(walk_refs_mut, plane_refs_mut, mut);-/// Sketches the feature is built from (profiles, paths, points): deleting one of them/// deletes the feature.pub fn input_sketches(&self) -> Vec<u64> {diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsindex 11920c49d0..e6fc0f69ea 100644--- a/crates/doc/src/lib.rs+++ b/crates/doc/src/lib.rs@@ -39,6 +39,7 @@ pub mod physical_material;mod piece_names;mod profile_refs;pub mod progress;+mod walk;pub use profile_refs::{capture_profile_selection, profile_selection_indices};pub mod plastic;pub mod project;diff --git a/crates/doc/src/params.rs b/crates/doc/src/params.rsindex 5d28ba8730..ae18f4a092 100644--- a/crates/doc/src/params.rs+++ b/crates/doc/src/params.rs@@ -9,7 +9,8 @@ use std::collections::{BTreeMap, BTreeSet};use serde::{Deserialize, Serialize};use crate::expr::{self, Kind, ParamDef, Value};-use crate::{DocError, Document, FeatureKind, HoleKind, MAX_PARAMS, PatternKind, PlaneRef, Result};+use crate::walk::Walk;+use crate::{DocError, Document, FeatureKind, MAX_PARAMS, Result};/// Whether an expression of a feature is one of its inputs, which become model parameters named/// in walk order (`dN`), or a coordinate of a primitive's placement point, which gets no name and@@ -20,387 +21,11 @@ pub(crate) enum ExprRole {Placement,}-/// The offsets and angles of a plane, outermost first, for `&` and `&mut` (`$m` is `mut` or-/// nothing). Nesting is capped like every walk over a plane.-macro_rules! plane_walk {- ($name:ident $(, $m:tt)?) => {- fn $name<'a>(mut p: &'a $($m)? PlaneRef, f: &mut impl FnMut(&'static str, &'a $($m)? String, Kind, ExprRole)) {- for _ in 0..64 {- match p {- PlaneRef::Offset { base, distance } => {- f("Offset", distance, Kind::Length, ExprRole::Input);- p = base;- }- PlaneRef::AtAngle { base, angle, .. } => {- f("Angle", angle, Kind::Angle, ExprRole::Input);- p = base;- }- PlaneRef::AlongPath { t, .. } => {- f("Distance (0 to 1)", t, Kind::Unitless, ExprRole::Input);- break;- }- _ => break,- }- }- }- };-}--plane_walk!(plane_exprs);-plane_walk!(plane_exprs_mut, mut);--/// Every expression of a feature with its label, kind and role, in a fixed order (the inputs'-/// order names their parameters), written once for `&` and `&mut`: `$plane` is the matching plane-/// walk, `$refs` the matching `refs`/`refs_mut`, `$m` is `mut` or nothing.-macro_rules! feature_walk {- ($name:ident, $plane:ident, $refs:ident $(, $m:tt)?) => {- pub(crate) fn $name<'a>(&'a $($m)? self, f: &mut impl FnMut(&'static str, &'a $($m)? String, Kind, ExprRole)) {- use ExprRole::{Input as I, Placement as P};- use Kind::{Angle as A, Length as L, Unitless as U};- const XYZ: [&str; 3] = ["X", "Y", "Z"];- match self {- FeatureKind::Sketch { plane, .. }- | FeatureKind::ConstructionPlane { plane }- | FeatureKind::Split { plane, .. }- | FeatureKind::SplitFace { plane, .. }- | FeatureKind::Mirror { plane, .. } => $plane(plane, f),- FeatureKind::ConstructionAxis { def } => {- for r in def.$refs() {- if let crate::construct::GeoRef::Plane { plane } = r {- $plane(plane, f);- }- }- }- FeatureKind::ConstructionPoint { def } => match def {- crate::construct::PointDef::AlongPath { t, .. } => f("Distance (0 to 1)", t, U, I),- other => {- for r in other.$refs() {- if let crate::construct::GeoRef::Plane { plane } = r {- $plane(plane, f);- }- }- }- },- FeatureKind::Extrude { extent, thin, .. } => {- f("Distance", & $($m)? extent.distance, L, I);- if let Some(d) = & $($m)? extent.distance2 {- f("Distance 2", d, L, I);- }- if let Some(d) = & $($m)? extent.start_offset {- f("Start offset", d, L, I);- }- if let Some(d) = & $($m)? extent.taper {- f("Taper angle", d, A, I);- }- if let Some(d) = & $($m)? extent.to_offset {- f("To offset", d, L, I);- }- if let Some(thin) = thin {- f("Thickness", & $($m)? thin.thickness, L, I);- if let Some(t) = & $($m)? thin.thickness2 {- f("Thickness 2", t, L, I);- }- }- }- FeatureKind::SurfaceExtrude { extent, .. } => {- f("Distance", & $($m)? extent.distance, L, I);- if let Some(d) = & $($m)? extent.distance2 {- f("Distance 2", d, L, I);- }- if let Some(d) = & $($m)? extent.start_offset {- f("Start offset", d, L, I);- }- if let Some(d) = & $($m)? extent.taper {- f("Taper angle", d, A, I);- }- if let Some(d) = & $($m)? extent.to_offset {- f("To offset", d, L, I);- }- }- FeatureKind::Revolve { angle, angle2, .. } | FeatureKind::SurfaceRevolve { angle, angle2, .. } => {- f("Angle", angle, A, I);- if let Some(a) = angle2 {- f("Angle 2", a, A, I);- }- }- FeatureKind::Fillet { radius, style, .. } => match style {- crate::FilletStyle::Constant => f("Radius", radius, L, I),- crate::FilletStyle::Curvature => f("Equivalent radius", radius, L, I),- crate::FilletStyle::Chord => f("Chord length", radius, L, I),- crate::FilletStyle::Variable { radius2, mid, .. } => {- f("Start radius", radius, L, I);- f("End radius", radius2, L, I);- for (_, r) in mid {- f("Mid radius", r, L, I);- }- }- crate::FilletStyle::Spline { radii, .. } => {- f("Start radius", radius, L, I);- let n = radii.len();- for (i, r) in radii.into_iter().enumerate() {- f(if i + 1 == n { "End radius" } else { "Control radius" }, r, L, I);- }- }- },- FeatureKind::Chamfer { distance, distance2, angle, .. } => {- f("Distance", distance, L, I);- if let Some(d) = distance2 {- f("Distance 2", d, L, I);- }- if let Some(a) = angle {- f("Angle", a, A, I);- }- }- FeatureKind::Box { length, width, height, corner, .. } => {- f("Length", length, L, I);- f("Width", width, L, I);- f("Height", height, L, I);- for (l, c) in XYZ.into_iter().zip(corner) {- f(l, c, L, P);- }- }- FeatureKind::Cylinder { radius, height, base, .. } => {- f("Radius", radius, L, I);- f("Height", height, L, I);- for (l, c) in XYZ.into_iter().zip(base) {- f(l, c, L, P);- }- }- FeatureKind::Sphere { radius, center, .. } => {- f("Radius", radius, L, I);- for (l, c) in XYZ.into_iter().zip(center) {- f(l, c, L, P);- }- }- FeatureKind::Torus { major, minor, center, .. } => {- f("Major radius", major, L, I);- f("Minor radius", minor, L, I);- for (l, c) in XYZ.into_iter().zip(center) {- f(l, c, L, P);- }- }- FeatureKind::Pattern { pattern, .. } => match pattern {- PatternKind::Rectangular { count1, spacing1, count2, spacing2, .. } => {- f("Quantity", count1, U, I);- f("Spacing", spacing1, L, I);- if let Some(c) = count2 {- f("Quantity 2", c, U, I);- }- if let Some(sp) = spacing2 {- f("Spacing 2", sp, L, I);- }- }- PatternKind::Path { count, spacing, .. } => {- f("Quantity", count, U, I);- f("Distance", spacing, L, I);- }- PatternKind::Circular { count, angle, .. } => {- f("Quantity", count, U, I);- f("Total angle", angle, A, I);- }- },- FeatureKind::Shell { thickness, .. } => f("Thickness", thickness, L, I),- FeatureKind::Draft { angle, neutral, .. } => {- f("Angle", angle, A, I);- $plane(neutral, f);- }- FeatureKind::Hole { diameter, depth, hole, .. } => {- f("Diameter", diameter, L, I);- if let Some(d) = depth {- f("Depth", d, L, I);- }- match hole {- HoleKind::Simple => {}- HoleKind::Drilled { tip_angle } => f("Tip angle", tip_angle, A, I),- HoleKind::Counterbore { cb_diameter, cb_depth } => {- f("Counterbore diameter", cb_diameter, L, I);- f("Counterbore depth", cb_depth, L, I);- }- HoleKind::Countersink { cs_diameter, cs_angle } => {- f("Countersink diameter", cs_diameter, L, I);- f("Countersink angle", cs_angle, A, I);- }- }- }- FeatureKind::Thread { length, .. } => {- if let Some(l) = length {- f("Length", l, L, I);- }- }- FeatureKind::Scale { factor, factors, .. } => {- f("Scale factor", factor, U, I);- if let Some([x, y, z]) = factors {- f("X scale", x, U, I);- f("Y scale", y, U, I);- f("Z scale", z, U, I);- }- }- FeatureKind::OffsetFace { distance, .. } => f("Distance", distance, L, I),- FeatureKind::BoundingSolid { margin, .. } => f("Margin", margin, L, I),- FeatureKind::Pipe { diameter, wall, .. } => {- f("Diameter", diameter, L, I);- if let Some(w) = wall {- f("Wall", w, L, I);- }- }- FeatureKind::Move { translate, angle, .. } => {- let [x, y, z] = translate;- f("X distance", x, L, I);- f("Y distance", y, L, I);- f("Z distance", z, L, I);- if let Some(a) = angle {- f("Angle", a, A, I);- }- }- FeatureKind::Emboss { depth, .. } => f("Depth", depth, L, I),- FeatureKind::Boss { diameter, height, hole_diameter, hole_depth, draft, fillet, ribs, rib_thickness, rib_length, rib_offset, .. } => {- f("Diameter", diameter, L, I);- f("Height", height, L, I);- for (l, o, k) in [- ("Hole diameter", hole_diameter, L),- ("Hole depth", hole_depth, L),- ("Draft angle", draft, A),- ("Root fillet", fillet, L),- ("Ribs", ribs, U),- ("Rib thickness", rib_thickness, L),- ("Rib length", rib_length, L),- ("Rib offset", rib_offset, L),- ] {- if let Some(e) = o {- f(l, e, k, I);- }- }- }- FeatureKind::Lip { width, height, gap, .. } => {- f("Width", width, L, I);- f("Height", height, L, I);- if let Some(g) = gap {- f("Gap", g, L, I);- }- }- FeatureKind::Rest { width, length, height, draft, thickness, .. } => {- f("Width", width, L, I);- f("Height", height, L, I);- for (l, o, k) in [("Length", length, L), ("Draft angle", draft, A), ("Wall thickness", thickness, L)] {- if let Some(e) = o {- f(l, e, k, I);- }- }- }- FeatureKind::SnapFit { length, thickness, width, catch_depth, catch_length, .. } => {- f("Length", length, L, I);- f("Thickness", thickness, L, I);- f("Width", width, L, I);- f("Catch depth", catch_depth, L, I);- f("Catch length", catch_length, L, I);- }- FeatureKind::SheetContour { distance, .. } => f("Distance", distance, L, I),- FeatureKind::SheetFlange { edges, height, angle, radius, .. } => {- f("Height", height, L, I);- f("Angle", angle, A, I);- if let Some(r) = radius {- f("Bend radius", r, L, I);- }- // The edges' own values come last, so the inputs above keep their names.- for e in edges {- if let Some(a) = & $($m)? e.angle {- f("Edge angle", a, A, I);- }- if let Some(h) = & $($m)? e.height {- f("Edge height", h, L, I);- }- }- }- FeatureKind::SheetFold { angle, radius, .. } => {- f("Angle", angle, A, I);- if let Some(r) = radius {- f("Bend radius", r, L, I);- }- }- FeatureKind::SheetHem { length, gap, .. } => {- f("Length", length, L, I);- if let Some(g) = gap {- f("Gap", g, L, I);- }- }- FeatureKind::SheetPerforate { diameter, pitch, margin, .. } => {- f("Diameter", diameter, L, I);- f("Pitch", pitch, L, I);- if let Some(m) = margin {- f("Margin", m, L, I);- }- }- FeatureKind::Coil { diameter, pitch, turns, section_size, start_angle, base, .. } => {- f("Diameter", diameter, L, I);- f("Pitch", pitch, L, I);- f("Revolutions", turns, U, I);- f("Section size", section_size, L, I);- if let Some(a) = start_angle {- f("Start angle", a, A, I);- }- for (l, c) in XYZ.into_iter().zip(base) {- f(l, c, L, P);- }- }- FeatureKind::Rib { thickness, depth, .. } => {- f("Thickness", thickness, L, I);- if let Some(d) = depth {- f("Depth", d, L, I);- }- }- FeatureKind::ReplaceFace { target, .. } => $plane(target, f),- FeatureKind::Stitch { tolerance, .. } => f("Tolerance", tolerance, L, I),- FeatureKind::MeshConvert { tolerance, .. } => f("Tolerance", tolerance, L, I),- FeatureKind::Thicken { thickness, .. } => f("Thickness", thickness, L, I),- FeatureKind::SurfaceTrim { plane, .. } => $plane(plane, f),- FeatureKind::SurfaceExtend { distance, up_to, .. } => {- f("Distance", distance, L, I);- if let Some(crate::ExtendTo::Plane(plane)) = up_to {- $plane(plane, f);- }- }- FeatureKind::SurfaceRuled { distance, angle, .. } => {- f("Distance", distance, L, I);- if let Some(a) = angle {- f("Angle", a, A, I);- }- }- FeatureKind::Unstitch { .. } | FeatureKind::ReverseNormal { .. } | FeatureKind::SurfaceUntrim { .. } => {}- FeatureKind::SurfaceOffset { distance, tolerance, .. } => {- f("Distance", distance, L, I);- if let Some(t) = tolerance {- f("Tolerance", t, L, I);- }- }- FeatureKind::Patch { .. } => {}- FeatureKind::Combine { .. }- | FeatureKind::SheetBase { .. }- | FeatureKind::SheetUnfold { .. }- | FeatureKind::SheetConvert { .. }- | FeatureKind::Align { .. }- | FeatureKind::Remove { .. }- | FeatureKind::DeleteFace { .. }- | FeatureKind::BoundaryFill { .. }- | FeatureKind::Loft { .. }- | FeatureKind::Sweep { .. }- | FeatureKind::SurfaceSweep { .. }- | FeatureKind::SurfaceLoft { .. }- | FeatureKind::Import { .. }- | FeatureKind::MeshImport { .. }- | FeatureKind::BodyTransfer { .. } => {}- }- }- };-}-impl FeatureKind {- feature_walk!(walk_exprs, plane_exprs, refs);- feature_walk!(walk_exprs_mut, plane_exprs_mut, refs_mut, mut);-/// The feature's numeric inputs: (label, expression, kind), in a fixed order.pub fn inputs_mut(&mut self) -> Vec<(&'static str, &mut String, Kind)> {let mut v = Vec::new();- self.walk_exprs_mut(&mut |label, e, kind, role| {+ self.walk_exprs_mut(&mut |(label, e, kind, role)| {if role == ExprRole::Input {v.push((label, e, kind));}@@ -411,7 +36,7 @@ impl FeatureKind {/// Read-only view of [`FeatureKind::inputs_mut`]: (label, expression, kind).pub fn inputs(&self) -> Vec<(&'static str, String, Kind)> {let mut v = Vec::new();- self.walk_exprs(&mut |label, e, kind, role| {+ self.walk_exprs(&mut |(label, e, kind, role)| {if role == ExprRole::Input {v.push((label, e.clone(), kind));}@@ -421,9 +46,13 @@ impl FeatureKind {/// Every expression the feature uses: its inputs, then a primitive's placement coordinates.pub fn expressions(&self) -> Vec<&str> {- let mut v = Vec::new();- self.walk_exprs(&mut |_, e, _, _| v.push(e.as_str()));- v+ let (mut inputs, mut placement) = (Vec::new(), Vec::new());+ self.walk_exprs(&mut |(_, e, _, role)| match role {+ ExprRole::Input => inputs.push(e.as_str()),+ ExprRole::Placement => placement.push(e.as_str()),+ });+ inputs.extend(placement);+ inputs}}diff --git a/crates/doc/src/walk.rs b/crates/doc/src/walk.rsnew file mode 100644index 0000000000..c9e233632c--- /dev/null+++ b/crates/doc/src/walk.rs@@ -0,0 +1,358 @@+//! The walks over a feature: its expressions (`params`), its references to the rest of the design+//! (`feature_refs`) and its geometry (`feature_geometry`). `#[derive(Walk)]`+//! (`solidcraft-derive`) generates them from `#[walk(...)]` roles on the fields of `FeatureKind`+//! and the types inside it, so what a field is, is written once, where it is declared. The+//! traits here carry the walks through the types the fields have: options, lists, arrays, planes+//! and construction definitions.++pub(crate) use solidcraft_geom::Vec3;++pub(crate) use crate::ProfileSel;+use crate::construct::{AxisDef, GeoRef, PointDef};+pub(crate) use crate::expr::Kind;+pub(crate) use crate::feature_geometry::Geo;+pub(crate) use crate::feature_refs::Ref;+pub(crate) use crate::params::ExprRole;+use crate::{PlaneRef, PointExpr};++/// An expression: its label, the expression, its kind and its role.+pub(crate) type ExprItem<'a> = (&'static str, &'a String, Kind, ExprRole);+pub(crate) type ExprItemMut<'a> = (&'static str, &'a mut String, Kind, ExprRole);+pub(crate) type RefItem<'a> = Ref<&'a u64, &'a String>;+pub(crate) type RefItemMut<'a> = Ref<&'a mut u64, &'a mut String>;+pub(crate) type GeoItem<'a> = Geo<&'a Vec3, &'a PlaneRef, &'a GeoRef, &'a PointExpr, &'a ProfileSel>;+pub(crate) type GeoItemMut<'a> = Geo<&'a mut Vec3, &'a mut PlaneRef, &'a mut GeoRef, &'a mut PointExpr, &'a mut ProfileSel>;++/// A value's expressions, references and geometry, each walked in order. A type with none of+/// them implements it empty.+pub(crate) trait Walk {+ fn walk_exprs<'a>(&'a self, _: &mut dyn FnMut(ExprItem<'a>)) {}+ fn walk_exprs_mut<'a>(&'a mut self, _: &mut dyn FnMut(ExprItemMut<'a>)) {}+ fn walk_refs<'a>(&'a self, _: &mut dyn FnMut(RefItem<'a>)) {}+ fn walk_refs_mut<'a>(&'a mut self, _: &mut dyn FnMut(RefItemMut<'a>)) {}+ fn walk_geometry<'a>(&'a self, _: &mut dyn FnMut(GeoItem<'a>)) {}+ fn walk_geometry_mut<'a>(&'a mut self, _: &mut dyn FnMut(GeoItemMut<'a>)) {}+}++impl Walk for String {}+impl Walk for std::sync::Arc<str> {}+impl Walk for bool {}+impl Walk for u64 {}+impl Walk for i8 {}+impl Walk for f64 {}+impl Walk for ProfileSel {}+impl Walk for solidcraft_sketch::Sketch {}+impl Walk for solidcraft_kernel::StepNode {}+impl Walk for crate::document::Operation {}+impl Walk for crate::document::Direction {}+impl Walk for crate::document::FilletFit {}+impl Walk for crate::document::MeshData {}+impl Walk for crate::document::RevolveConvention {}+impl Walk for crate::document::CoilSection {}+impl Walk for crate::document::ThinSide {}+impl Walk for crate::document::ExtendMode {}+impl Walk for crate::document::RuledMode {}+impl Walk for crate::document::RuledCorners {}++/// Containers walk what they hold, in order.+macro_rules! walk_each {+ ($([$($g:tt)*] $t:ty),*) => {$(+ impl<$($g)*> Walk for $t {+ fn walk_exprs<'a>(&'a self, f: &mut dyn FnMut(ExprItem<'a>)) {+ for t in self {+ t.walk_exprs(f)+ }+ }+ fn walk_exprs_mut<'a>(&'a mut self, f: &mut dyn FnMut(ExprItemMut<'a>)) {+ for t in self {+ t.walk_exprs_mut(f)+ }+ }+ fn walk_refs<'a>(&'a self, f: &mut dyn FnMut(RefItem<'a>)) {+ for t in self {+ t.walk_refs(f)+ }+ }+ fn walk_refs_mut<'a>(&'a mut self, f: &mut dyn FnMut(RefItemMut<'a>)) {+ for t in self {+ t.walk_refs_mut(f)+ }+ }+ fn walk_geometry<'a>(&'a self, f: &mut dyn FnMut(GeoItem<'a>)) {+ for t in self {+ t.walk_geometry(f)+ }+ }+ fn walk_geometry_mut<'a>(&'a mut self, f: &mut dyn FnMut(GeoItemMut<'a>)) {+ for t in self {+ t.walk_geometry_mut(f)+ }+ }+ }+ )*};+}++walk_each!([T: Walk] Option<T>, [T: Walk] Vec<T>, [T: Walk, const N: usize] [T; N]);++/// The values of a field with a role (`T`, an optional one or a list), in order.+pub(crate) trait Each<T> {+ fn each<'a>(&'a self, f: &mut dyn FnMut(&'a T));+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(&'a mut T));+}++impl<T> Each<T> for T {+ fn each<'a>(&'a self, f: &mut dyn FnMut(&'a T)) {+ f(self)+ }+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(&'a mut T)) {+ f(self)+ }+}++impl<T> Each<T> for Option<T> {+ fn each<'a>(&'a self, f: &mut dyn FnMut(&'a T)) {+ if let Some(t) = self {+ f(t)+ }+ }+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(&'a mut T)) {+ if let Some(t) = self {+ f(t)+ }+ }+}++impl<T> Each<T> for Vec<T> {+ fn each<'a>(&'a self, f: &mut dyn FnMut(&'a T)) {+ for t in self {+ f(t)+ }+ }+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(&'a mut T)) {+ for t in self {+ f(t)+ }+ }+}++impl<T> Each<T> for Option<Vec<T>> {+ fn each<'a>(&'a self, f: &mut dyn FnMut(&'a T)) {+ for t in self.iter().flatten() {+ f(t)+ }+ }+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(&'a mut T)) {+ for t in self.iter_mut().flatten() {+ f(t)+ }+ }+}++/// The expressions of an expression field, each with its index and their count (for its label).+pub(crate) trait ExprField {+ fn each<'a>(&'a self, f: &mut dyn FnMut(usize, usize, &'a String));+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(usize, usize, &'a mut String));+}++impl ExprField for String {+ fn each<'a>(&'a self, f: &mut dyn FnMut(usize, usize, &'a String)) {+ f(0, 1, self)+ }+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(usize, usize, &'a mut String)) {+ f(0, 1, self)+ }+}++/// A position along an edge with its radius (a variable fillet's mid radii).+impl ExprField for (f64, String) {+ fn each<'a>(&'a self, f: &mut dyn FnMut(usize, usize, &'a String)) {+ f(0, 1, &self.1)+ }+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(usize, usize, &'a mut String)) {+ f(0, 1, &mut self.1)+ }+}++impl<T: ExprField> ExprField for Option<T> {+ fn each<'a>(&'a self, f: &mut dyn FnMut(usize, usize, &'a String)) {+ if let Some(t) = self {+ t.each(f)+ }+ }+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(usize, usize, &'a mut String)) {+ if let Some(t) = self {+ t.each_mut(f)+ }+ }+}++/// Lists and arrays number their elements.+macro_rules! expr_list {+ ($([$($g:tt)*] $t:ty),*) => {$(+ impl<$($g)*> ExprField for $t {+ fn each<'a>(&'a self, f: &mut dyn FnMut(usize, usize, &'a String)) {+ let n = self.len();+ for (i, t) in self.iter().enumerate() {+ t.each(&mut |_, _, e| f(i, n, e));+ }+ }+ fn each_mut<'a>(&'a mut self, f: &mut dyn FnMut(usize, usize, &'a mut String)) {+ let n = self.len();+ for (i, t) in self.iter_mut().enumerate() {+ t.each_mut(&mut |_, _, e| f(i, n, e));+ }+ }+ }+ )*};+}++expr_list!([T: ExprField] Vec<T>, [T: ExprField, const N: usize] [T; N]);++/// An expression's label: one for every element, one per element, or worked out from the+/// element's index and the count.+pub(crate) trait Label {+ fn at(&self, i: usize, n: usize) -> &'static str;+}++impl Label for &'static str {+ fn at(&self, _: usize, _: usize) -> &'static str {+ self+ }+}++impl<const N: usize> Label for [&'static str; N] {+ fn at(&self, i: usize, _: usize) -> &'static str {+ self.get(i).copied().unwrap_or("")+ }+}++impl<F: Fn(usize, usize) -> &'static str> Label for F {+ fn at(&self, i: usize, n: usize) -> &'static str {+ self(i, n)+ }+}++/// The offsets and angles of a plane, outermost first (nesting is capped like every walk over a+/// plane), the construction plane it is built on, and the plane itself.+impl Walk for PlaneRef {+ fn walk_exprs<'a>(&'a self, f: &mut dyn FnMut(ExprItem<'a>)) {+ let mut p = self;+ for _ in 0..64 {+ match p {+ PlaneRef::Offset { base, distance } => {+ f(("Offset", distance, Kind::Length, ExprRole::Input));+ p = base;+ }+ PlaneRef::AtAngle { base, angle, .. } => {+ f(("Angle", angle, Kind::Angle, ExprRole::Input));+ p = base;+ }+ PlaneRef::AlongPath { t, .. } => return f(("Distance (0 to 1)", t, Kind::Unitless, ExprRole::Input)),+ _ => return,+ }+ }+ }+ fn walk_exprs_mut<'a>(&'a mut self, f: &mut dyn FnMut(ExprItemMut<'a>)) {+ let mut p = self;+ for _ in 0..64 {+ match p {+ PlaneRef::Offset { base, distance } => {+ f(("Offset", distance, Kind::Length, ExprRole::Input));+ p = base;+ }+ PlaneRef::AtAngle { base, angle, .. } => {+ f(("Angle", angle, Kind::Angle, ExprRole::Input));+ p = base;+ }+ PlaneRef::AlongPath { t, .. } => return f(("Distance (0 to 1)", t, Kind::Unitless, ExprRole::Input)),+ _ => return,+ }+ }+ }+ fn walk_refs<'a>(&'a self, f: &mut dyn FnMut(RefItem<'a>)) {+ let mut p = self;+ for _ in 0..64 {+ match p {+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => p = base,+ PlaneRef::Construction { name } => return f(Ref::Feature(name)),+ _ => return,+ }+ }+ }+ fn walk_refs_mut<'a>(&'a mut self, f: &mut dyn FnMut(RefItemMut<'a>)) {+ let mut p = self;+ for _ in 0..64 {+ match p {+ PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } => p = base,+ PlaneRef::Construction { name } => return f(Ref::Feature(name)),+ _ => return,+ }+ }+ }+ fn walk_geometry<'a>(&'a self, f: &mut dyn FnMut(GeoItem<'a>)) {+ f(Geo::Plane(self))+ }+ fn walk_geometry_mut<'a>(&'a mut self, f: &mut dyn FnMut(GeoItemMut<'a>)) {+ f(Geo::Plane(self))+ }+}++/// Construction axes and points: the expressions of the planes they are built from (and a point+/// along a path's distance), and their references to the model. They name no sketches, features+/// or bodies: copies remap their geometry references on their own (`Feature::remap_clone`).+fn plane_exprs<'a>(refs: Vec<&'a GeoRef>, f: &mut dyn FnMut(ExprItem<'a>)) {+ for r in refs {+ if let GeoRef::Plane { plane } = r {+ plane.walk_exprs(f);+ }+ }+}++fn plane_exprs_mut<'a>(refs: Vec<&'a mut GeoRef>, f: &mut dyn FnMut(ExprItemMut<'a>)) {+ for r in refs {+ if let GeoRef::Plane { plane } = r {+ plane.walk_exprs_mut(f);+ }+ }+}++macro_rules! construct_geometry {+ () => {+ fn walk_geometry<'a>(&'a self, f: &mut dyn FnMut(GeoItem<'a>)) {+ for r in self.refs() {+ f(Geo::Construct(r));+ }+ }+ fn walk_geometry_mut<'a>(&'a mut self, f: &mut dyn FnMut(GeoItemMut<'a>)) {+ for r in self.refs_mut() {+ f(Geo::Construct(r));+ }+ }+ };+}++impl Walk for AxisDef {+ fn walk_exprs<'a>(&'a self, f: &mut dyn FnMut(ExprItem<'a>)) {+ plane_exprs(self.refs(), f)+ }+ fn walk_exprs_mut<'a>(&'a mut self, f: &mut dyn FnMut(ExprItemMut<'a>)) {+ plane_exprs_mut(self.refs_mut(), f)+ }+ construct_geometry!();+}++impl Walk for PointDef {+ fn walk_exprs<'a>(&'a self, f: &mut dyn FnMut(ExprItem<'a>)) {+ match self {+ PointDef::AlongPath { t, .. } => f(("Distance (0 to 1)", t, Kind::Unitless, ExprRole::Input)),+ other => plane_exprs(other.refs(), f),+ }+ }+ fn walk_exprs_mut<'a>(&'a mut self, f: &mut dyn FnMut(ExprItemMut<'a>)) {+ match self {+ PointDef::AlongPath { t, .. } => f(("Distance (0 to 1)", t, Kind::Unitless, ExprRole::Input)),+ other => plane_exprs_mut(other.refs_mut(), f),+ }+ }+ construct_geometry!();+}diff --git a/xtask/src/layers.rs b/xtask/src/layers.rsindex 3b482150c3..b2a5413f94 100644--- a/xtask/src/layers.rs+++ b/xtask/src/layers.rs@@ -36,6 +36,8 @@ impl Class {/// prefix.pub const TABLE: &[(&str, Class)] = &[("geom", Class::Layer(0)),+ // the derive macros (proc-macro, no workspace dependencies)+ ("derive", Class::Standalone),("sketch", Class::Layer(1)),("kernel", Class::Layer(1)),("render", Class::Layer(1)),