* claim: #11103 * Hole: Bridge option for counterbores (#11103) A counterbore hole takes an optional `bridge` length: two 3D-printing layers that thick below the counterbore's floor, a slot along X across the counterbore and then a square, both 0.02 mm wider than the hole, so a printer bridges the step instead of sagging into it. Empty (the default) keeps a plain counterbore. The clearance keeps the bore, cut straight through both layers as for a plain counterbore, clear of their sides: at exactly the hole's width it ran tangent along them and broke through. The command and the geometry refuse a layer that is not a positive length, layers that don't fit in the hole below the counterbore, and a bridge on any other hole type. The Hole dialog shows a Bridge field below Drill Point for counterbores. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Hole: translate the Bridge label for the complete catalogs (#11103) Arabic, Hebrew, Japanese, Vietnamese and Chinese carry every English message, so `cargo xtask i18n --check` needs the new label in each. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Hole: bridged counterbores refuse layers past a through hole's exit, too narrow a counterbore and a malformed bridge (#11103) - Through all, the second bridge layer must end inside a body (exact point classification), short of the exit face; the tool's reach is no measure of the material. - A bridged counterbore must be at least 0.04 mm wider than the hole, so the slot's ends have room on its wall (no square root of a negative number reaches the extrude). - `solid.hole` refuses a `bridge` that is given but not a length expression (`true`, `[]`, `""`) instead of making a plain counterbore; `null` still leaves it out. - Loop2 and Seg2 now come from solidcore_record (main moved them). - The "nothing saved" check looks for the `"bridge"` key: `format_pending` names `bridged-counterbore` in every design. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Unit defaults test: solid.hole has the bridge field too Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
4722 lines
214 KiB
Rust
4722 lines
214 KiB
Rust
use serde::{Deserialize, Serialize};
|
||
use solidcore_record::{Plane, Vec2, Vec3};
|
||
use solidcraft_geom::prelude::*;
|
||
use solidcraft_kernel::Continuity;
|
||
use solidcraft_sketch::Sketch;
|
||
|
||
use crate::construct::{AxisDef, GeoRef, PointDef};
|
||
use crate::expr::{self, Expr, Kind};
|
||
use crate::names::{BodyName, FeatureId, FeatureName, SketchId};
|
||
use crate::points::{Dir, FacePick, Position};
|
||
use crate::{DocError, Result};
|
||
|
||
pub const MAX_FEATURES: usize = 10_000;
|
||
pub const MAX_PARAMS: usize = 10_000;
|
||
/// Largest feature id a replayed feature may keep (`Document::insert_feature`): exact in JSON
|
||
/// numbers, and far from overflowing the next id.
|
||
pub const MAX_FEATURE_ID: u64 = 1 << 52;
|
||
|
||
/// A named parameter. User parameters are created by the user; model parameters (`d1`, `d2`…)
|
||
/// are created by dimensions and features.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct Param {
|
||
pub name: String,
|
||
pub expr: String,
|
||
/// `mm`, `deg` or empty (unit-less).
|
||
pub unit: String,
|
||
#[serde(default, skip_serializing_if = "String::is_empty")]
|
||
pub comment: String,
|
||
/// Created by a dimension or feature (not by the user).
|
||
#[serde(default)]
|
||
pub model: bool,
|
||
}
|
||
|
||
impl Param {
|
||
pub fn kind(&self) -> Kind {
|
||
Kind::from_unit(&self.unit)
|
||
}
|
||
}
|
||
|
||
/// Where a sketch lies.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
#[serde(tag = "type", rename_all = "snake_case")]
|
||
pub enum PlaneRef {
|
||
/// `XY`, `XZ` or `YZ`.
|
||
Origin { name: String },
|
||
/// An explicit plane (e.g. picked from a planar face).
|
||
Custom { plane: Plane },
|
||
/// An explicit plane whose origin is given as length expressions
|
||
/// (`{origin: ["half", 0, 0], normal: [1, 0, 0]}`), so it follows parameter changes.
|
||
Placed {
|
||
#[serde(with = "point_expr")]
|
||
origin: PointExpr,
|
||
x_dir: Vec3,
|
||
y_dir: Vec3,
|
||
},
|
||
/// Another plane offset along its normal by an expression.
|
||
Offset { base: Box<PlaneRef>, distance: Expr },
|
||
/// Another plane moved along its normal until it goes through a point (a vertex, sketch
|
||
/// point or construction point), so it follows the point.
|
||
ThroughPoint { base: Box<PlaneRef>, point: Box<GeoRef> },
|
||
/// Another plane rotated about a line (in world coordinates) by an angle expression. With
|
||
/// `line`, an edge or round face of the model ([`crate::construct::model_axis`]), the line is
|
||
/// found there on each evaluation and `axis_origin`/`axis_dir` are where it was when picked.
|
||
AtAngle {
|
||
base: Box<PlaneRef>,
|
||
axis_origin: Vec3,
|
||
axis_dir: Vec3,
|
||
angle: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
line: Option<Box<GeoRef>>,
|
||
},
|
||
/// A construction plane feature (by id).
|
||
Construction { feature: FeatureId },
|
||
/// `base` seen from its other side: the normal reversed by a half turn about the base's
|
||
/// own x axis (y reversed), or about its y axis (x reversed) when `about_y`. A sketch
|
||
/// started from behind a plane faces the viewer this way.
|
||
Flipped {
|
||
base: Box<PlaneRef>,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
about_y: bool,
|
||
},
|
||
/// Halfway between two planes (or planar faces); bisecting them when they meet at an angle.
|
||
Midplane { a: Box<GeoRef>, b: Box<GeoRef> },
|
||
/// Through two straight edges (lines) that lie in one plane.
|
||
TwoEdges { a: Box<GeoRef>, b: Box<GeoRef> },
|
||
/// Through a line (axis) and a point not on that line.
|
||
AxisPoint { axis: Box<GeoRef>, point: Box<GeoRef> },
|
||
/// Through three points.
|
||
ThreePoints { a: Box<GeoRef>, b: Box<GeoRef>, c: Box<GeoRef> },
|
||
/// Tangent to a face (cylinder, cone, sphere, torus) where the point `at` lies over it. With
|
||
/// a `reference` (a plane or planar face), it touches where the face turns towards the
|
||
/// reference instead, turned by `angle` about the face's axis, on the side of `at` (#8822).
|
||
Tangent {
|
||
face: Box<GeoRef>,
|
||
at: Vec3,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
reference: Option<Box<GeoRef>>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
angle: Option<Expr>,
|
||
},
|
||
/// Square to an edge or sketch curve, a fraction `t` (expression, 0…1) of the way along it.
|
||
AlongPath { path: Box<GeoRef>, t: Expr },
|
||
/// Through a straight edge (or line, axis) and square to a plane (or planar face).
|
||
Perpendicular { plane: Box<GeoRef>, line: Box<GeoRef> },
|
||
/// A planar body face. Certified attachments resolve only their exact source and report
|
||
/// an error when it is lost; `plane` then supplies a repair guide. Legacy references without
|
||
/// an anchor try the persistent `name`, then the nearest parallel face at `at`, and retain
|
||
/// the picked `plane` as their historical fallback.
|
||
Face {
|
||
plane: Plane,
|
||
at: Vec3,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
name: Option<String>,
|
||
/// Exact attachment identity for newly certified faces; absent on legacy designs.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
anchor: Option<Box<crate::FaceAnchor>>,
|
||
},
|
||
}
|
||
|
||
/// Complete source curves of an outer boundary and each of its holes. Unlike a
|
||
/// span multiset, this identity is independent of adaptive spline subdivision.
|
||
///
|
||
/// A loop is a set of curves: `outer` is kept sorted, and `holes` sorted by their own ids, as
|
||
/// the sketch's profiles produce them. Any start and either direction of the same loop is
|
||
/// accepted and made canonical on load, so a design written by hand or by another writer still
|
||
/// opens (#6499).
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
|
||
pub struct WholeProfileBoundary {
|
||
pub outer: Vec<String>,
|
||
pub holes: Vec<Vec<String>>,
|
||
}
|
||
|
||
impl<'de> Deserialize<'de> for WholeProfileBoundary {
|
||
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
|
||
/// The written form, before the loop order is dropped.
|
||
#[derive(Deserialize)]
|
||
#[serde(deny_unknown_fields)]
|
||
struct Written {
|
||
outer: Vec<String>,
|
||
holes: Vec<Vec<String>>,
|
||
}
|
||
let Written { mut outer, mut holes } = Written::deserialize(deserializer)?;
|
||
outer.sort();
|
||
for hole in &mut holes {
|
||
hole.sort();
|
||
}
|
||
holes.sort();
|
||
Ok(Self { outer, holes })
|
||
}
|
||
}
|
||
|
||
/// Which closed profiles of a sketch a feature uses.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
#[serde(tag = "type", rename_all = "snake_case")]
|
||
pub enum ProfileSel {
|
||
/// Every profile.
|
||
All,
|
||
/// Profiles by index in the solved sketch's profile list.
|
||
Indices { indices: Vec<usize> },
|
||
/// Profiles whose outer loop is made of exactly these curves, or pieces of them where other
|
||
/// curves cut them (order and repeats don't matter; see `sketch::profile_by_curves`). Found
|
||
/// again on every evaluation, so stable across parameter changes; no match or several is
|
||
/// an error, never another profile.
|
||
Curves { loops: Vec<Vec<String>> },
|
||
/// Complete current boundaries of topology-aware analytic offset associations.
|
||
/// The local association identity survives retirement and resurrection of arc roles.
|
||
OffsetBoundaries { associations: Vec<String> },
|
||
/// Exact whole source coverage, including holes; partial source curves do not match.
|
||
WholeBoundaries { profiles: Vec<WholeProfileBoundary> },
|
||
/// The profile containing each sketch point.
|
||
Points { points: Vec<Vec2> },
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum Operation {
|
||
#[default]
|
||
NewBody,
|
||
Join,
|
||
Cut,
|
||
Intersect,
|
||
}
|
||
|
||
impl Operation {
|
||
pub fn parse(s: &str) -> Option<Operation> {
|
||
Some(match s.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
|
||
"new" | "newbody" | "newcomponent" => Operation::NewBody,
|
||
"join" | "union" | "add" => Operation::Join,
|
||
"cut" | "subtract" | "difference" => Operation::Cut,
|
||
"intersect" | "intersection" => Operation::Intersect,
|
||
_ => return None,
|
||
})
|
||
}
|
||
}
|
||
|
||
/// What a join makes of pieces that share no face: they share no volume and no area, so nothing
|
||
/// fuses them.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum Touching {
|
||
/// A piece that touches another only along an edge or at a point cannot be one solid with it
|
||
/// and becomes a body of its own; pieces that touch nothing stay one body of several pieces.
|
||
#[default]
|
||
Separate,
|
||
/// Every piece stays in one body, also those that touch along an edge or at a point.
|
||
OneBody,
|
||
}
|
||
|
||
impl Touching {
|
||
pub fn parse(s: &str) -> Option<Touching> {
|
||
Some(match s.to_ascii_lowercase().replace([' ', '-'], "_").as_str() {
|
||
"separate" => Touching::Separate,
|
||
"one_body" => Touching::OneBody,
|
||
_ => return None,
|
||
})
|
||
}
|
||
|
||
fn is_separate(&self) -> bool {
|
||
*self == Touching::Separate
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum Direction {
|
||
/// Along the sketch normal.
|
||
#[default]
|
||
Positive,
|
||
Negative,
|
||
/// Both sides; the extent convention determines whether `distance` is total or per side.
|
||
Symmetric,
|
||
}
|
||
|
||
/// The direction a ruled surface leaves its edges (`surface.ruled`).
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum RuledMode {
|
||
/// Along the normal of the face beside each edge.
|
||
#[default]
|
||
Normal,
|
||
/// Continuing the face beside each edge.
|
||
Tangent,
|
||
/// At an angle from a reference direction (the face's normal unless one is given).
|
||
Angle,
|
||
/// Along a fixed direction.
|
||
Direction,
|
||
}
|
||
|
||
impl RuledMode {
|
||
fn is_normal(&self) -> bool {
|
||
*self == RuledMode::Normal
|
||
}
|
||
}
|
||
|
||
/// How a ruled surface's strips meet at sharp corners of its edge chain.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum RuledCorners {
|
||
/// Extended or cut back until they meet.
|
||
#[default]
|
||
Mitre,
|
||
/// Joined by a sector (inside corners are cut back).
|
||
Round,
|
||
}
|
||
|
||
impl RuledCorners {
|
||
fn is_mitre(&self) -> bool {
|
||
*self == RuledCorners::Mitre
|
||
}
|
||
}
|
||
|
||
/// Angular starts in older designs used the raw axis sign. New revolves measure starts
|
||
/// along the same sketch-normal sweep direction as the kernel.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum RevolveConvention {
|
||
#[default]
|
||
LegacyAxisStart,
|
||
SketchNormal,
|
||
}
|
||
|
||
/// Symmetric distance semantics. Missing markers preserve existing designs' thickness.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum ExtrudeConvention {
|
||
#[default]
|
||
LegacyPerSide,
|
||
TotalDistance,
|
||
}
|
||
|
||
impl ExtrudeConvention {
|
||
/// Distance from the mid-plane to either cap for a distance-limited extent.
|
||
pub fn symmetric_half_distance(self, distance: f64) -> f64 {
|
||
match self {
|
||
Self::LegacyPerSide => distance,
|
||
Self::TotalDistance => distance * 0.5,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Extent of an extrude.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct Extent {
|
||
#[walk(length = "Distance")]
|
||
pub distance: Expr,
|
||
#[serde(default)]
|
||
pub convention: ExtrudeConvention,
|
||
#[serde(default)]
|
||
pub direction: Direction,
|
||
/// Optional second side distance (two-sided extrude): the other way from the first side (against
|
||
/// the normal, or along it when the first side goes against it: `direction: negative`, a
|
||
/// negative distance, or a To Object below the sketch).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Distance 2")]
|
||
pub distance2: Option<Expr>,
|
||
/// 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<Expr>,
|
||
/// 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<Expr>,
|
||
/// How a taper closes the profile's sharp corners, when the user chose
|
||
/// ([`solidcraft_kernel::draft_corners`] says what each rule gives at each corner). Without
|
||
/// it each profile takes preserve curvature where the kernel can build it exactly and the
|
||
/// tangent rule where a curve that is neither a line nor an arc has a corner, and the
|
||
/// feature's warning says so.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub corner: Option<solidcraft_kernel::DraftCorner>,
|
||
/// To Object: end at the face (or vertex/point) at this point, instead of `distance`.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub to: Option<FacePick>,
|
||
/// 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<Expr>,
|
||
/// 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")]
|
||
pub from: Option<FacePick>,
|
||
/// A Join To Object leaves the body it runs to as its own body, joining only its targets.
|
||
/// Designs saved before a Join also took that body (format 39 and older, #8151) open with
|
||
/// it set, so they keep the bodies they were built with.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
pub to_body_apart: bool,
|
||
}
|
||
|
||
/// Thin Extrude: a wall of constant thickness along sketch curves instead of the profiles.
|
||
#[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: Expr,
|
||
#[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<Expr>,
|
||
}
|
||
|
||
/// How a swept profile turns as it follows its path.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum SweepOrientation {
|
||
/// Square to the path, turning with it (a rotation-minimising frame).
|
||
#[default]
|
||
Perpendicular,
|
||
/// As drawn: the profile moves along the path without turning.
|
||
Parallel,
|
||
/// Square to the path, its turn about the path fixed by this direction (in the feature's
|
||
/// frame): the direction's projection onto the profile stays where it was at the start.
|
||
Direction(Dir),
|
||
}
|
||
|
||
impl SweepOrientation {
|
||
pub fn is_perpendicular(&self) -> bool {
|
||
*self == SweepOrientation::Perpendicular
|
||
}
|
||
}
|
||
|
||
/// A sweep's or a loft's guide rail: a chain of curves of a sketch, followed from the end nearest
|
||
/// the path's start (the loft's first section).
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct SweepRail {
|
||
pub sketch: SketchId,
|
||
pub curves: Vec<String>,
|
||
}
|
||
|
||
/// How a sweep's guide rails reshape its profile.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum RailFit {
|
||
/// Evenly, with the distance across to the rail (between the rails).
|
||
#[default]
|
||
Scale,
|
||
/// Only across to the rail (between the rails).
|
||
Stretch,
|
||
}
|
||
|
||
impl RailFit {
|
||
pub fn is_scale(&self) -> bool {
|
||
*self == RailFit::Scale
|
||
}
|
||
}
|
||
|
||
/// Where a thin wall lies against its curves. A closed loop's inside is the area it encloses;
|
||
/// an open chain's is the side it bends toward (a straight one's, the left of its first
|
||
/// curve as drawn).
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum ThinSide {
|
||
/// Half the thickness either side of the curves.
|
||
#[default]
|
||
Center,
|
||
Inside,
|
||
Outside,
|
||
/// `thickness` inside and `thickness2` outside.
|
||
TwoSides,
|
||
}
|
||
|
||
impl ThinSide {
|
||
pub fn is_center(&self) -> bool {
|
||
*self == ThinSide::Center
|
||
}
|
||
pub fn parse(s: &str) -> Option<ThinSide> {
|
||
match s.trim().to_ascii_lowercase().replace([' ', '-'], "_").as_str() {
|
||
"center" | "centre" | "centered" | "centred" | "symmetric" => Some(ThinSide::Center),
|
||
"inside" | "side1" | "side_1" => Some(ThinSide::Inside),
|
||
"outside" | "side2" | "side_2" => Some(ThinSide::Outside),
|
||
"two_sides" | "both" => Some(ThinSide::TwoSides),
|
||
_ => None,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Revolve axis.
|
||
#[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.
|
||
SketchLine { curve: String },
|
||
/// Sketch x or y axis through the sketch origin (`x` / `y`).
|
||
SketchAxis { axis: String },
|
||
/// World X / Y / Z axis through the origin.
|
||
World { axis: String },
|
||
/// Any line in the sketch plane, in world coordinates.
|
||
Line { origin: Position, dir: Dir },
|
||
/// An edge or round face of the model (a straight or circular edge, a cylinder, cone or
|
||
/// torus face), found again on each evaluation: [`crate::construct::model_axis`].
|
||
Model { geo: GeoRef },
|
||
/// A construction axis feature, by name, where it is when the revolve is evaluated.
|
||
Construction { name: FeatureName },
|
||
}
|
||
|
||
/// Persistent cylindrical Emboss selection, authored in the feature component frame.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct EmbossFace {
|
||
pub body: BodyName,
|
||
#[walk(pinned)]
|
||
pub at: FacePick,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub path: Vec<u64>,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub author_path: Vec<u64>,
|
||
}
|
||
|
||
impl EmbossFace {
|
||
/// The selected sketch placement, shared by evaluation and interactive guides.
|
||
pub fn sketch_frame(&self, doc: &Document, author: u64, sketch_owner: u64, body: &crate::ModelBody) -> Result<crate::Mat> {
|
||
let owner = doc.model_body_component(body);
|
||
if sketch_owner == owner {
|
||
return Self::component_frame(doc, owner, &self.path);
|
||
}
|
||
if sketch_owner == author {
|
||
return Self::component_frame(doc, author, &self.author_path);
|
||
}
|
||
let path = doc.first_path(sketch_owner);
|
||
let mut component = sketch_owner;
|
||
for _ in 0..64 {
|
||
if component == 0 {
|
||
break;
|
||
}
|
||
let mut occurrences = doc.occurrences.iter().filter(|o| o.component == component);
|
||
let occurrence = occurrences.next().ok_or_else(|| DocError::Invalid("sketch placement no longer exists".into()))?;
|
||
if occurrences.next().is_some() {
|
||
return Err(DocError::Invalid("sketch placement is ambiguous".into()));
|
||
}
|
||
component = occurrence.parent;
|
||
}
|
||
if component != 0 {
|
||
return Err(DocError::Invalid("sketch placement exceeds depth limit".into()));
|
||
}
|
||
Self::component_frame(doc, sketch_owner, &path)
|
||
}
|
||
|
||
/// Resolve this exact placement without expanding every assembly instance.
|
||
pub fn body_frame(&self, doc: &Document, body: &crate::ModelBody) -> Result<crate::Mat> {
|
||
let owner = doc.model_body_component(body);
|
||
let mut frame = Self::component_frame(doc, owner, &self.path)?;
|
||
if let Some(offset) = doc.model_body_offset(body) {
|
||
frame = crate::mat_mul(&frame, offset);
|
||
}
|
||
Ok(frame)
|
||
}
|
||
|
||
/// Resolve one saved component path without expanding other occurrences.
|
||
pub fn component_frame(doc: &Document, owner: u64, path: &[u64]) -> Result<crate::Mat> {
|
||
if path.len() > 64 || doc.occurrences.len() > 100_000 {
|
||
return Err(DocError::Invalid("selected cylinder path exceeds work limits".into()));
|
||
}
|
||
let mut frame = crate::IDENTITY;
|
||
let mut component = 0;
|
||
let mut seen = std::collections::BTreeSet::new();
|
||
for id in path {
|
||
if *id == 0 || !seen.insert(*id) {
|
||
return Err(DocError::Invalid("invalid selected cylinder path".into()));
|
||
}
|
||
let occurrence = doc
|
||
.occurrences
|
||
.iter()
|
||
.find(|o| o.id == *id && o.parent == component)
|
||
.ok_or_else(|| DocError::Invalid("selected cylinder placement no longer exists".into()))?;
|
||
frame = crate::mat_mul(&frame, &occurrence.transform);
|
||
component = occurrence.component;
|
||
}
|
||
if path.is_empty() {
|
||
frame = doc.component_transform(owner);
|
||
} else if component != owner {
|
||
return Err(DocError::Invalid("selected cylinder path belongs to another component".into()));
|
||
}
|
||
Ok(frame)
|
||
}
|
||
}
|
||
|
||
/// One edge of an edge flange feature: a point on the sheet's edge and, where given, this
|
||
/// 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, solidcraft_derive::Walk)]
|
||
pub struct FlangeEdge {
|
||
pub point: Position,
|
||
#[walk(angle = "Edge angle")]
|
||
pub angle: Option<Expr>,
|
||
#[walk(length = "Edge height")]
|
||
pub height: Option<Expr>,
|
||
}
|
||
|
||
impl FlangeEdge {
|
||
/// An edge that takes the feature's angle and height.
|
||
pub fn at(point: Vec3) -> Self {
|
||
Self { point: Position(point), angle: None, height: None }
|
||
}
|
||
}
|
||
|
||
impl Serialize for FlangeEdge {
|
||
fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
|
||
use serde::ser::SerializeMap;
|
||
if self.angle.is_none() && self.height.is_none() {
|
||
return self.point.serialize(s);
|
||
}
|
||
let mut m = s.serialize_map(None)?;
|
||
m.serialize_entry("point", &self.point)?;
|
||
if let Some(a) = &self.angle {
|
||
m.serialize_entry("angle", a)?;
|
||
}
|
||
if let Some(h) = &self.height {
|
||
m.serialize_entry("height", h)?;
|
||
}
|
||
m.end()
|
||
}
|
||
}
|
||
|
||
impl<'de> Deserialize<'de> for FlangeEdge {
|
||
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
|
||
use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
|
||
/// The object form; a key this build doesn't know is refused, not dropped.
|
||
#[derive(Deserialize)]
|
||
#[serde(deny_unknown_fields)]
|
||
struct Own {
|
||
point: Vec3,
|
||
#[serde(default)]
|
||
angle: Option<Expr>,
|
||
#[serde(default)]
|
||
height: Option<Expr>,
|
||
}
|
||
struct Edge;
|
||
impl<'de> serde::de::Visitor<'de> for Edge {
|
||
type Value = FlangeEdge;
|
||
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
||
f.write_str("a point [x, y, z] or an edge {point, angle?, height?}")
|
||
}
|
||
fn visit_seq<A: serde::de::SeqAccess<'de>>(self, seq: A) -> std::result::Result<FlangeEdge, A::Error> {
|
||
Vec3::deserialize(SeqAccessDeserializer::new(seq)).map(FlangeEdge::at)
|
||
}
|
||
fn visit_map<A: serde::de::MapAccess<'de>>(self, map: A) -> std::result::Result<FlangeEdge, A::Error> {
|
||
let o = Own::deserialize(MapAccessDeserializer::new(map))?;
|
||
Ok(FlangeEdge { point: Position(o.point), angle: o.angle, height: o.height })
|
||
}
|
||
}
|
||
d.deserialize_any(Edge)
|
||
}
|
||
}
|
||
|
||
/// One side of an Align by frames (#6257): an origin and a z direction, found again from the
|
||
/// geometry each time the design is evaluated, so the bodies follow it.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
#[serde(tag = "type", rename_all = "snake_case")]
|
||
pub enum AlignFrame {
|
||
/// A joint origin on the model (its component's coordinates): its origin and z.
|
||
Origin { origin: Box<crate::joints::JointOrigin> },
|
||
/// A sketch point; z along the sketch's normal.
|
||
SketchPoint { sketch: SketchId, point: String },
|
||
/// The centre of a sketch circle, arc or ellipse; z along the sketch's normal.
|
||
SketchCurve { sketch: SketchId, curve: String },
|
||
}
|
||
|
||
impl AlignFrame {
|
||
/// The frame's origin and unit z in the model state `st` (its component's coordinates).
|
||
pub fn resolve(&self, doc: &Document, st: &crate::ModelState) -> Result<(Vec3, Vec3)> {
|
||
let sketch = |id: &SketchId| st.sketch(id.0).ok_or_else(|| DocError::Unknown(format!("sketch {id}")));
|
||
let (o, z) = match self {
|
||
AlignFrame::Origin { origin } => {
|
||
let m = crate::joints::resolve_origin(doc, st, origin)?;
|
||
(Vec3::new(m[3][0], m[3][1], m[3][2]), Vec3::new(m[2][0], m[2][1], m[2][2]))
|
||
}
|
||
AlignFrame::SketchPoint { sketch: id, point } => {
|
||
let ss = sketch(id)?;
|
||
let q = ss.sketch.point_index(point).and_then(|i| ss.sketch.point(i));
|
||
(ss.plane.to_world(q.ok_or_else(|| DocError::Unknown(format!("sketch point `{point}`")))?), ss.plane.normal())
|
||
}
|
||
AlignFrame::SketchCurve { sketch: id, curve } => {
|
||
use solidcraft_sketch::CurveKind;
|
||
let ss = sketch(id)?;
|
||
let kind = ss.sketch.curve_index(curve).and_then(|i| ss.sketch.curves.get(i)).map(|c| &c.kind);
|
||
let centre = match kind.ok_or_else(|| DocError::Unknown(format!("sketch curve `{curve}`")))? {
|
||
CurveKind::Circle { c, .. } | CurveKind::Arc { c, .. } | CurveKind::Ellipse { c, .. } => ss.sketch.point(*c),
|
||
_ => return Err(DocError::Invalid(format!("sketch curve `{curve}` is not a circle, arc or ellipse"))),
|
||
};
|
||
(ss.plane.to_world(centre.ok_or_else(|| DocError::Invalid(format!("sketch curve `{curve}` has no centre")))?), ss.plane.normal())
|
||
}
|
||
};
|
||
match z.normalized() {
|
||
Some(z) if o.is_finite() => Ok((o, z)),
|
||
_ => Err(DocError::Invalid("the frame has no finite origin and direction".into())),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Feature definitions.
|
||
#[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 {
|
||
bodies: Vec<BodyName>,
|
||
from: u64,
|
||
to: u64,
|
||
transform: crate::Mat,
|
||
},
|
||
Sketch {
|
||
plane: PlaneRef,
|
||
sketch: Sketch,
|
||
},
|
||
Extrude {
|
||
/// Feature id of the sketch.
|
||
sketch: SketchId,
|
||
// 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")]
|
||
targets: Vec<BodyName>,
|
||
/// 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 {
|
||
sketch: SketchId,
|
||
#[walk(profiles_of = sketch)]
|
||
profiles: ProfileSel,
|
||
axis: AxisRef,
|
||
#[walk(angle = "Angle")]
|
||
angle: Expr,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
targets: Vec<BodyName>,
|
||
/// Two Sides: the angle on the other side.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Angle 2")]
|
||
angle2: Option<Expr>,
|
||
/// Symmetric: `angle` split evenly either side of the profile.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
symmetric: bool,
|
||
/// Missing fields retain the angular placement of existing designs.
|
||
#[serde(default)]
|
||
convention: RevolveConvention,
|
||
/// To Object: turn until the face, vertex or point here.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
to: Option<FacePick>,
|
||
},
|
||
Fillet {
|
||
/// Reference points on the edges to round (each re-finds the nearest edge).
|
||
edges: Vec<Position>,
|
||
#[walk(length = style.radius_label())]
|
||
radius: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
/// Constant radius (the default), chord length (`radius` is the width across), or a
|
||
/// radius varying along each edge.
|
||
#[serde(default, skip_serializing_if = "FilletStyle::is_constant")]
|
||
style: FilletStyle,
|
||
/// What to do when the radius is too large for the geometry around the edges.
|
||
#[serde(default, skip_serializing_if = "FilletFit::is_exact")]
|
||
fit: FilletFit,
|
||
/// What fills the corners where three blended edges meet: the rolling ball's sphere
|
||
/// (default) or a G2 patch repeating each blend up to the second order.
|
||
#[serde(default, skip_serializing_if = "FilletCorner::is_rolling")]
|
||
corner: FilletCorner,
|
||
/// Corners set back: each corner's patch starts its distance along every edge there
|
||
/// from the vertex instead of where the rounds meet (a constant-radius fillet only).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
setbacks: Vec<CornerSetback>,
|
||
/// How two rounds turn where they meet at a sharp side edge: in a mitre (the default) or
|
||
/// swept round it (a constant-radius, exact, rolling-corner fillet without setbacks only).
|
||
#[serde(default, skip_serializing_if = "FilletTurn::is_mitre")]
|
||
turn: FilletTurn,
|
||
/// Round each picked edge's tangent chain with it (the default: edges continuing it
|
||
/// smoothly at its ends, as far as they go), or only the picked edges.
|
||
#[serde(default = "yes", skip_serializing_if = "is_yes")]
|
||
tangent_chain: bool,
|
||
},
|
||
Chamfer {
|
||
edges: Vec<Position>,
|
||
#[walk(length = "Distance")]
|
||
distance: Expr,
|
||
/// Unequal chamfers: the distance along the second face…
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Distance 2")]
|
||
distance2: Option<Expr>,
|
||
/// …or the angle the chamfer makes with the first face.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Angle")]
|
||
angle: Option<Expr>,
|
||
/// 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")]
|
||
body: Option<BodyName>,
|
||
/// Cut each picked edge's tangent chain with it (the default), or only the picked edges.
|
||
#[serde(default = "yes", skip_serializing_if = "is_yes")]
|
||
tangent_chain: bool,
|
||
},
|
||
Box {
|
||
#[serde(with = "point_expr")]
|
||
#[walk(placement)]
|
||
corner: PointExpr,
|
||
#[walk(length = "Length")]
|
||
length: Expr,
|
||
#[walk(length = "Width")]
|
||
width: Expr,
|
||
#[walk(length = "Height")]
|
||
height: Expr,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
},
|
||
Cylinder {
|
||
#[serde(with = "point_expr")]
|
||
#[walk(placement)]
|
||
base: PointExpr,
|
||
#[serde(default = "z_axis")]
|
||
axis: Dir,
|
||
#[walk(length = "Radius")]
|
||
radius: Expr,
|
||
#[walk(length = "Height")]
|
||
height: Expr,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
/// Up to two straight edges of the face it stands on (#6380), as a Single hole's
|
||
/// references: the base centre sits at each one's distance from its edge, in the face's
|
||
/// plane, and follows the edges when the part changes. `base` keeps where it was placed.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
references: Vec<HoleReference>,
|
||
},
|
||
Sphere {
|
||
#[serde(with = "point_expr")]
|
||
#[walk(placement)]
|
||
center: PointExpr,
|
||
#[walk(length = "Radius")]
|
||
radius: Expr,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
},
|
||
Torus {
|
||
#[serde(with = "point_expr")]
|
||
#[walk(placement)]
|
||
center: PointExpr,
|
||
#[walk(length = "Major radius")]
|
||
major: Expr,
|
||
#[walk(length = "Minor radius")]
|
||
minor: Expr,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
},
|
||
/// A cone or a truncated cone (#5641): the base circle's centre `base`, its `radius`, the
|
||
/// radius of the top circle `height` along `axis` (`top_radius`, 0 for a full cone).
|
||
Cone {
|
||
#[serde(with = "point_expr")]
|
||
#[walk(placement)]
|
||
base: PointExpr,
|
||
#[serde(default = "z_axis")]
|
||
axis: Dir,
|
||
#[walk(length = "Radius")]
|
||
radius: Expr,
|
||
#[walk(length = "Top radius")]
|
||
top_radius: Expr,
|
||
#[walk(length = "Height")]
|
||
height: Expr,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
},
|
||
Combine {
|
||
target: BodyName,
|
||
tools: Vec<BodyName>,
|
||
operation: Operation,
|
||
#[serde(default)]
|
||
keep_tools: bool,
|
||
},
|
||
/// Copies of other features' results, or of bodies (rectangular, circular or along a path).
|
||
/// The copied features are named by id (#1134).
|
||
Pattern {
|
||
features: Vec<FeatureId>,
|
||
pattern: PatternKind,
|
||
/// Copy these bodies (as new bodies) instead of replaying features.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
bodies: Vec<BodyName>,
|
||
},
|
||
/// Mirror copies of other features' results in a plane. The copied features are named by
|
||
/// id (#1134).
|
||
Mirror {
|
||
features: Vec<FeatureId>,
|
||
plane: PlaneRef,
|
||
/// Mirror these bodies instead of replaying features.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
bodies: Vec<BodyName>,
|
||
/// Join each mirrored body with its original.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
combine: bool,
|
||
/// Where each of `bodies` is mirrored from: the occurrence path of the placement it was
|
||
/// picked at. The body is mirrored where that placement shows it, in the plane of the
|
||
/// feature's own component, and its copy joins the body's component (or, when that is
|
||
/// placed more than once, the innermost component around it placed once). Empty in older
|
||
/// designs, which mirror the bodies' own geometry.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
placements: Vec<Vec<u64>>,
|
||
},
|
||
/// A drilled hole (simple, counterbore or countersink) at a point, into the material.
|
||
Hole {
|
||
#[walk(pick_if = points.is_none())]
|
||
position: FacePick,
|
||
/// The position as length expressions, when it was given that way (#1678): the hole is
|
||
/// drilled where they evaluate, and follows the parameters. `position` keeps the point
|
||
/// they gave when the hole was made.
|
||
#[serde(default, skip_serializing_if = "Option::is_none", with = "opt_point_expr")]
|
||
#[walk(placement)]
|
||
at: Option<PointExpr>,
|
||
/// Drilling direction (into the material).
|
||
direction: Dir,
|
||
#[walk(length = "Diameter")]
|
||
diameter: Expr,
|
||
/// Depth to the shoulder; `None` = through all.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Depth")]
|
||
depth: Option<Expr>,
|
||
#[serde(default)]
|
||
hole: HoleKind,
|
||
/// Drill at these sketch points instead (one hole each, perpendicular to the sketch, into the material: against the sketch normal, or along it when only that side has material);
|
||
/// the holes follow the points when the sketch changes.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
points: Option<SketchPoints>,
|
||
/// A cosmetic thread in the holes (e.g. "M6x1").
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
thread: Option<String>,
|
||
/// Threaded depth from the cylindrical wall's entry; `None` = its full useful length.
|
||
/// Independent of the drill depth and excluding the drill point and entry recess.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Thread depth")]
|
||
thread_depth: Option<Expr>,
|
||
/// The tapped thread's hand: right (the default) or left; never both.
|
||
#[serde(default, skip_serializing_if = "crate::thread_forms::is_default")]
|
||
hand: crate::thread_forms::ThreadHand,
|
||
/// The tapped thread cut into the wall (the groove between its teeth, as a modelled
|
||
/// `solid.thread` cuts it) instead of only listed.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
modeled: bool,
|
||
/// A modelled tapped thread's inner end, towards the bottom: it fades out over this
|
||
/// length (ISO 3508's runout); none: it stops square, or clear of a blind hole's bottom.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
ease_out: Option<ThreadRunout>,
|
||
/// To Object: drill down to the face (or point) here instead of `depth`.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
to: Option<FacePick>,
|
||
/// Up to two straight edges of the face (#37): the hole's centre sits at each one's
|
||
/// distance from its edge, measured in the face's plane, and follows the edges when the
|
||
/// part changes. `position` keeps where it was placed.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
references: Vec<HoleReference>,
|
||
},
|
||
/// 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 {
|
||
face: FacePick,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
designation: Option<String>,
|
||
/// Thread length from the end it starts at; `None` = full length (or `up_to`).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Length")]
|
||
length: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
modeled: bool,
|
||
/// A point near the end of the face the thread starts at; `None`: the face's only free
|
||
/// end (no material past it), or the end the pick at `face` lies near.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
from: Option<Position>,
|
||
/// Where the thread runs up to from the end it starts at, instead of a length.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
up_to: Option<ThreadLimit>,
|
||
/// The thread's form; `designation`'s prefix names it when this is the default.
|
||
#[serde(default, skip_serializing_if = "crate::thread_forms::is_default")]
|
||
form: crate::thread_forms::ThreadForm,
|
||
#[serde(default, skip_serializing_if = "crate::thread_forms::is_default")]
|
||
hand: crate::thread_forms::ThreadHand,
|
||
/// Starts (1 to 8): the lead is starts × pitch (unless `designation` gives the lead).
|
||
#[serde(default = "crate::thread_forms::one_start", skip_serializing_if = "crate::thread_forms::is_one_start")]
|
||
starts: u32,
|
||
/// The runout at the thread's inner end, the one away from where it starts (a groove
|
||
/// that fades out); none: the groove stops square there.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
ease_out: Option<ThreadRunout>,
|
||
/// The chamfered tip at the thread's free end (ISO 4753).
|
||
#[serde(default, skip_serializing_if = "crate::thread_forms::is_default")]
|
||
tip: crate::thread_forms::ThreadTip,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Chamfer angle")]
|
||
chamfer_angle: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Chamfer depth")]
|
||
chamfer_depth: Option<Expr>,
|
||
/// Buttress forms: which way the steep flank of the screw's teeth faces.
|
||
#[serde(default, skip_serializing_if = "crate::thread_forms::is_default")]
|
||
steep_flank: crate::thread_forms::SteepFlank,
|
||
/// Set on threads saved before holes were sized by their nominal diameter, whose size
|
||
/// was left to the tap drill: a 12 mm hole stays M14 there. New threads leave it off.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
old_auto_size: bool,
|
||
},
|
||
/// Ruled loft through profiles of several sketches, in order.
|
||
Loft {
|
||
sections: Vec<LoftSection>,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
targets: Vec<BodyName>,
|
||
/// Guide rails (one or two) the loft follows between its sections.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
rails: Vec<SweepRail>,
|
||
/// How the rails reshape the sections between.
|
||
#[serde(default, skip_serializing_if = "RailFit::is_scale")]
|
||
rail_fit: RailFit,
|
||
},
|
||
/// Sweep profiles along a chain of sketch curves.
|
||
Sweep {
|
||
sketch: SketchId,
|
||
#[walk(profiles_of = sketch)]
|
||
profiles: ProfileSel,
|
||
path_sketch: SketchId,
|
||
path: Vec<String>,
|
||
/// How the profile turns along the path (default: perpendicular to it).
|
||
#[serde(default, skip_serializing_if = "SweepOrientation::is_perpendicular")]
|
||
orientation: SweepOrientation,
|
||
/// Angle the profile turns about the path over its length.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Twist")]
|
||
twist: Option<Expr>,
|
||
/// The profile's scale at the end of the path (linear along its length).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(unitless = "Scale")]
|
||
scale: Option<Expr>,
|
||
/// Guide rails (one or two) the profile follows, instead of orientation, twist and scale.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
rails: Vec<SweepRail>,
|
||
/// How the rails reshape the profile.
|
||
#[serde(default, skip_serializing_if = "RailFit::is_scale")]
|
||
rail_fit: RailFit,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
targets: Vec<BodyName>,
|
||
},
|
||
/// Hollow a body leaving walls of `thickness`, removing the faces at the given points.
|
||
Shell {
|
||
faces: Vec<FacePick>,
|
||
#[walk(length = "Thickness")]
|
||
thickness: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
/// inside (default) | outside | both (the wall straddles the faces).
|
||
#[serde(default, skip_serializing_if = "String::is_empty")]
|
||
direction: String,
|
||
/// Open the faces smoothly joined to the picked ones too.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
tangent_chain: bool,
|
||
},
|
||
/// Tilt faces (at the given points) about a neutral plane, leaning toward `pull`.
|
||
Draft {
|
||
faces: Vec<FacePick>,
|
||
#[walk(angle = "Angle")]
|
||
angle: Expr,
|
||
neutral: PlaneRef,
|
||
pull: Dir,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// A construction plane (sketch placement, split tool).
|
||
ConstructionPlane {
|
||
plane: PlaneRef,
|
||
},
|
||
/// 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 {
|
||
body: BodyName,
|
||
plane: PlaneRef,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
tool: Option<FaceAt>,
|
||
/// A straight line of this sketch as the tool (#1552): the plane through it along the
|
||
/// sketch's normal, which follows the sketch.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
sketch: Option<SketchId>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
line: Option<String>,
|
||
},
|
||
/// A construction axis (CONSTRUCT axes).
|
||
ConstructionAxis {
|
||
def: AxisDef,
|
||
},
|
||
/// A construction point (CONSTRUCT points).
|
||
ConstructionPoint {
|
||
def: PointDef,
|
||
},
|
||
/// Split faces (at the given points) where a tool meets them, the solid unchanged: a plane,
|
||
/// 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 {
|
||
faces: Vec<FacePick>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
plane: PlaneRef,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
tool: Option<FaceAt>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
sketch: Option<SketchId>,
|
||
},
|
||
/// Scale bodies about a point (uniform, or per axis).
|
||
Scale {
|
||
bodies: Vec<BodyName>,
|
||
#[serde(default)]
|
||
origin: Position,
|
||
#[walk(unitless = "Scale factor")]
|
||
factor: Expr,
|
||
/// Per-axis factors instead of `factor`.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(unitless = ["X scale", "Y scale", "Z scale"])]
|
||
factors: Option<[Expr; 3]>,
|
||
},
|
||
/// Move planar faces (at the given points) along their normals; the body keeps its shape.
|
||
OffsetFace {
|
||
faces: Vec<FacePick>,
|
||
#[walk(length = "Distance")]
|
||
distance: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// 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 {
|
||
faces: Vec<FacePick>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
/// Close the gap by extending the neighbouring faces (the default); `false` leaves it
|
||
/// open, the faces left a surface body.
|
||
#[serde(default = "yes", skip_serializing_if = "is_yes")]
|
||
heal: bool,
|
||
},
|
||
/// A box around bodies, grown by a margin.
|
||
BoundingSolid {
|
||
bodies: Vec<BodyName>,
|
||
#[serde(default = "zero_expr")]
|
||
#[walk(length = "Margin")]
|
||
margin: Expr,
|
||
},
|
||
/// A tube along a chain of sketch curves (solid, or hollow with a wall thickness).
|
||
Pipe {
|
||
path_sketch: SketchId,
|
||
path: Vec<String>,
|
||
#[walk(length = "Diameter")]
|
||
diameter: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Wall")]
|
||
wall: Option<Expr>,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
targets: Vec<BodyName>,
|
||
},
|
||
/// Structural members (#4003): one body per straight line of a frame sketch (2D sketch lines
|
||
/// and 3D sketch lines), its cross-section the profile, square to the line from end to end.
|
||
FrameMember {
|
||
path_sketch: SketchId,
|
||
/// The lines, by curve id; none: every straight line drawn in the sketch (not
|
||
/// construction, not projected or otherwise linked, not of no length).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
lines: Vec<String>,
|
||
profile: crate::frame::MemberProfile,
|
||
/// The profile point that sits on the line.
|
||
#[serde(default, skip_serializing_if = "crate::frame::Anchor::is_origin")]
|
||
anchor: crate::frame::Anchor,
|
||
/// How far the profile turns about the line (see `frame::member_axes`).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Rotation")]
|
||
angle: Option<Expr>,
|
||
/// The profile mirrored across its y axis (before it turns).
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
mirror: bool,
|
||
/// What members without a name of their own are named after (`Rail`, `Rail (2)`...); none:
|
||
/// the profile's description (`Rect Tube 40x40x3`) or the profile sketch's name.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body_name: Option<String>,
|
||
/// Each member's body name, by its line's id, so a member keeps its name when other lines
|
||
/// come and go (`frame::member_names`).
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
names: std::collections::BTreeMap<String, String>,
|
||
},
|
||
/// Raise or sink profiles on a planar face, or wrap them on a selected cylindrical wall.
|
||
Emboss {
|
||
sketch: SketchId,
|
||
#[walk(profiles_of = sketch)]
|
||
profiles: ProfileSel,
|
||
#[walk(length = "Depth")]
|
||
depth: Expr,
|
||
#[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")]
|
||
targets: Vec<BodyName>,
|
||
},
|
||
/// 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`), or with `normal` along the
|
||
/// sketch normal. A web makes one per curve.
|
||
Rib {
|
||
sketch: SketchId,
|
||
curves: Vec<String>,
|
||
#[walk(length = "Thickness")]
|
||
thickness: Expr,
|
||
/// 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<Expr>,
|
||
/// Fill toward the other side of the curves.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
flip: bool,
|
||
/// Web: each curve is its own wall.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
web: bool,
|
||
/// Grow the wall along the sketch normal (thickness across the curves, in the sketch
|
||
/// plane) instead of across the plane from the curves.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
normal: bool,
|
||
},
|
||
/// Move planar faces (at the given points) onto a target plane parallel to them.
|
||
ReplaceFace {
|
||
faces: Vec<FacePick>,
|
||
target: PlaneRef,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// Move bodies so that `from` lands on `to` (and, with normals, the faces meet face to face).
|
||
Align {
|
||
bodies: Vec<BodyName>,
|
||
from: Position,
|
||
to: Position,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
from_normal: Option<Dir>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
to_normal: Option<Dir>,
|
||
/// Normals the same way instead of facing each other.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
flip: bool,
|
||
/// A plane the bodies move with (an origin or construction plane): its origin and normal
|
||
/// are the `from` point and normal, worked out again whenever the plane moves.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
from_plane: Option<PlaneRef>,
|
||
/// A plane the bodies move onto: after turning to meet it (when `from` has a normal) the
|
||
/// `from` point is brought onto the plane along its normal, so the plane may move and the
|
||
/// bodies follow. Replaces `to`.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
to_plane: Option<PlaneRef>,
|
||
/// Point-to-point alignment: the directions the offset moves along (the chosen world
|
||
/// X/Y/Z axes in the frame of the bodies being moved). `None`: all three axes, the
|
||
/// offset in full.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
axes: Option<Vec<Dir>>,
|
||
/// A frame on the bodies (#6257), found again on every evaluation: its origin and z are
|
||
/// the `from` point and normal. Replaces `from`, `from_normal` and `from_plane`.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
from_frame: Option<AlignFrame>,
|
||
/// A frame the bodies move onto, found again on every evaluation, so they follow it when
|
||
/// it moves. Replaces `to`, `to_normal` and `to_plane`.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
to_frame: Option<AlignFrame>,
|
||
/// A turn about the target's direction (its frame's z, face normal or plane normal),
|
||
/// through where `from` lands, after the move.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Angle")]
|
||
angle: Option<Expr>,
|
||
},
|
||
/// A helical coil: a circular or square section swept `turns` times about `axis`, rising
|
||
/// `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")]
|
||
axis: Dir,
|
||
/// The sketch whose plane and profile the coil sweeps. Its absence means the primitive
|
||
/// circular or square section below.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
sketch: Option<SketchId>,
|
||
#[serde(default = "all_profiles", skip_serializing_if = "profiles_are_all")]
|
||
#[walk(profiles_of = sketch)]
|
||
profiles: ProfileSel,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Diameter")]
|
||
diameter: Option<Expr>,
|
||
#[walk(length = "Pitch")]
|
||
pitch: Expr,
|
||
#[walk(unitless = "Revolutions")]
|
||
turns: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Section size")]
|
||
section_size: Option<Expr>,
|
||
#[serde(default)]
|
||
section: CoilSection,
|
||
/// -1 inside, 0 on the centre, 1 outside of the diameter.
|
||
#[serde(default, skip_serializing_if = "is_zero_i8")]
|
||
position: i8,
|
||
/// 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<Expr>,
|
||
/// Turn the other way (left-handed).
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
clockwise: bool,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
targets: Vec<BodyName>,
|
||
},
|
||
/// Sheet metal base flange: a sheet from a closed profile (thickness from the rule).
|
||
SheetBase {
|
||
sketch: SketchId,
|
||
#[walk(profiles_of = sketch)]
|
||
profiles: ProfileSel,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
rule: Option<String>,
|
||
/// Thickness grows against the sketch normal.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
flip: bool,
|
||
},
|
||
/// Sheet metal contour flange: a sheet bent along an open chain of sketch lines.
|
||
SheetContour {
|
||
sketch: SketchId,
|
||
curves: Vec<String>,
|
||
#[walk(length = "Distance")]
|
||
distance: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
rule: Option<String>,
|
||
/// Material on the other side of the chain.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
flip: bool,
|
||
/// Width the other way along the sketch normal.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
reverse: bool,
|
||
},
|
||
/// 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: Expr,
|
||
#[walk(angle = "Angle")]
|
||
angle: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Bend radius")]
|
||
radius: Option<Expr>,
|
||
/// inside | outside | middle | material_outside | tangent (`sheet::SheetBody::add_flanges_each`).
|
||
#[serde(default = "inside_str")]
|
||
position: String,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
flip: bool,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
/// The relief cut where two of this feature's bends meet at a corner of the base, in place
|
||
/// of the rule's: `corner_relief_shape` (notch | round | rectangular | tear) and
|
||
/// `corner_relief`, the size across. Either one left out follows the rule.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
corner_relief_shape: Option<String>,
|
||
/// Walked last, after the edges' values, so the inputs before it keep their names.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Corner relief")]
|
||
corner_relief: Option<Expr>,
|
||
/// Where the heights are measured from: `inner` (the inner virtual sharp) or `tangent`
|
||
/// (past 90° the line square to the flange touching the bend's outside); none is the outer
|
||
/// virtual sharp (`sheet::HeightFrom`).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
height_from: Option<String>,
|
||
},
|
||
/// Flat hems on sheet edges.
|
||
SheetHem {
|
||
edges: Vec<Position>,
|
||
#[walk(length = "Length")]
|
||
length: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Gap")]
|
||
gap: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
flip: bool,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// A perforation field (#732): round holes of `diameter` on a staggered (60°) or square grid of `pitch` over the
|
||
/// whole flat sheet, or inside the closed profiles of `sketch` when it is given, kept `margin` (default: the
|
||
/// diameter) clear of its edges, cut-outs, bend zones and the outline. Stored like 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: Expr,
|
||
#[walk(length = "Pitch")]
|
||
pitch: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Margin")]
|
||
margin: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pattern: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
/// The field's outline: a sketch on a face of the sheet. None: the whole sheet.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
sketch: Option<SketchId>,
|
||
/// Which of the outline sketch's profiles bound the field. None: all of them.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(profiles_of = sketch)]
|
||
profiles: Option<ProfileSel>,
|
||
},
|
||
/// 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")]
|
||
sketch: Option<SketchId>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
curve: Option<String>,
|
||
a: Position,
|
||
b: Position,
|
||
#[walk(angle = "Angle")]
|
||
angle: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Bend radius")]
|
||
radius: Option<Expr>,
|
||
/// centerline | start | end | mould
|
||
position: String,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
flip: bool,
|
||
/// A point on the side that stays put (default: the larger side).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
fixed: Option<Position>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// Path flange: a chain of edge flanges on the sheet edge at `edge` that follows an open
|
||
/// chain of sketch lines drawn across that edge: each line one flange as long as the line,
|
||
/// each corner one bend.
|
||
SheetPath {
|
||
edge: Position,
|
||
sketch: SketchId,
|
||
curves: Vec<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Bend radius")]
|
||
radius: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// Unfold a sheet body flat (all bends), or refold it.
|
||
SheetUnfold {
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
refold: bool,
|
||
},
|
||
/// Convert a body to sheet metal from its fixed face at `face`: a plate of constant
|
||
/// thickness or, with `bends`, a solid or shelled body whose faces reached from the fixed
|
||
/// face across those edges become the sheet.
|
||
SheetConvert {
|
||
body: BodyName,
|
||
#[walk(pick_if = !bends.is_empty())]
|
||
face: FacePick,
|
||
#[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")]
|
||
bends: Vec<Position>,
|
||
},
|
||
/// Plastic boss: a round post on a face (draft, root fillet, hole, ribs).
|
||
Boss {
|
||
position: FacePick,
|
||
/// Out of the face (the boss grows along it).
|
||
#[serde(default = "z_axis")]
|
||
direction: Dir,
|
||
#[walk(length = "Diameter")]
|
||
diameter: Expr,
|
||
#[walk(length = "Height")]
|
||
height: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Hole diameter")]
|
||
hole_diameter: Option<Expr>,
|
||
/// 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<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Draft angle")]
|
||
draft: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Root fillet")]
|
||
fillet: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(unitless = "Ribs")]
|
||
ribs: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Rib thickness")]
|
||
rib_thickness: Option<Expr>,
|
||
/// Rib reach out from the boss wall.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Rib length")]
|
||
rib_length: Option<Expr>,
|
||
/// Rib top below the boss top.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Rib offset")]
|
||
rib_offset: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// Plastic lip (raised band) or groove (recess) along the rim face picked at `face`.
|
||
Lip {
|
||
face: Position,
|
||
#[walk(length = "Width")]
|
||
width: Expr,
|
||
#[walk(length = "Height")]
|
||
height: Expr,
|
||
#[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<Expr>,
|
||
/// 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")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// Plastic snap fit: a cantilever arm on a face with a hook (catch) at its tip.
|
||
SnapFit {
|
||
position: FacePick,
|
||
/// The arm grows along this (out of the face).
|
||
#[serde(default = "z_axis")]
|
||
direction: Dir,
|
||
/// The catch sticks out this way.
|
||
hook: Dir,
|
||
#[walk(length = "Length")]
|
||
length: Expr,
|
||
#[walk(length = "Thickness")]
|
||
thickness: Expr,
|
||
#[walk(length = "Width")]
|
||
width: Expr,
|
||
#[walk(length = "Catch depth")]
|
||
catch_depth: Expr,
|
||
/// The catch's height along the arm.
|
||
#[walk(length = "Catch length")]
|
||
catch_length: Expr,
|
||
/// The base extends this far below the face (none: the arm starts at the face).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Base height")]
|
||
base_height: Option<Expr>,
|
||
/// Make the snap fit its own body instead of joining the target, so it can be
|
||
/// patterned or moved on its own.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
new_body: bool,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// Plastic rest: a raised pad on a face (round, or a rectangle), solid or a hollow wall,
|
||
/// with draft.
|
||
Rest {
|
||
position: FacePick,
|
||
/// Out of the face (the pad grows along it).
|
||
#[serde(default = "z_axis")]
|
||
direction: Dir,
|
||
/// The rectangle's length runs along this (default: any direction in the face).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
along: Option<Dir>,
|
||
/// Diameter of a round rest, or the rectangle's width.
|
||
#[walk(length = "Width")]
|
||
width: Expr,
|
||
/// The rectangle's length (none: round).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Length", after = height)]
|
||
length: Option<Expr>,
|
||
#[walk(length = "Height")]
|
||
height: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Draft angle")]
|
||
draft: Option<Expr>,
|
||
/// Wall thickness of a hollow rest (none: solid).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Wall thickness")]
|
||
thickness: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
},
|
||
/// 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 {
|
||
tools: Vec<BodyName>,
|
||
cells: Vec<Position>,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
/// Remove the tool bodies afterwards.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
remove_tools: bool,
|
||
},
|
||
/// Remove bodies from the model (from here on in the timeline).
|
||
Remove {
|
||
bodies: Vec<BodyName>,
|
||
},
|
||
/// 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")]
|
||
sketch: Option<SketchId>,
|
||
#[serde(default = "all_profiles")]
|
||
#[walk(profiles_of = sketch)]
|
||
profiles: ProfileSel,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
edges: Vec<Position>,
|
||
/// How full a fitted patch's middle is (`crown`, -0.9…3, default 0; a planar loop is an
|
||
/// exact plane whatever this says).
|
||
#[serde(default, skip_serializing_if = "is_zero")]
|
||
crown: f64,
|
||
/// How a patch on edges meets the faces beside its loop (G0 everywhere by default, and
|
||
/// then not saved).
|
||
#[serde(default, skip_serializing_if = "PatchContinuity::is_g0")]
|
||
continuity: PatchContinuity,
|
||
/// Points a patch on edges passes through.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
points: Vec<Position>,
|
||
},
|
||
/// Surface bodies sewn along shared edges into the first one (a solid when they close).
|
||
Stitch {
|
||
bodies: Vec<BodyName>,
|
||
#[serde(default = "zero_expr")]
|
||
#[walk(length = "Tolerance")]
|
||
tolerance: Expr,
|
||
},
|
||
/// Surface bodies thickened into solids along their normals (by half each way when
|
||
/// `symmetric`).
|
||
Thicken {
|
||
bodies: Vec<BodyName>,
|
||
#[walk(length = "Thickness")]
|
||
thickness: Expr,
|
||
#[serde(default)]
|
||
symmetric: bool,
|
||
operation: Operation,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
targets: Vec<BodyName>,
|
||
},
|
||
/// A surface body swept straight along the sketch normal from open curve chains and the
|
||
/// boundaries of profiles: walls only, no caps.
|
||
SurfaceExtrude {
|
||
sketch: SketchId,
|
||
/// 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")]
|
||
curves: Vec<String>,
|
||
extent: Extent,
|
||
},
|
||
/// 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 {
|
||
body: BodyName,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
faces: Vec<Position>,
|
||
},
|
||
/// A surface body with the faces at `faces` (every face when empty) turned over.
|
||
ReverseNormal {
|
||
body: BodyName,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
faces: Vec<Position>,
|
||
},
|
||
/// The face at `face` restored towards its surface: the inner loops at the `holes` points
|
||
/// taken away (every one when `None`; none when empty), and with `outer` its outer boundary
|
||
/// 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")]
|
||
holes: Option<Vec<Position>>,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
outer: bool,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
in_place: bool,
|
||
},
|
||
/// 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 {
|
||
sketch: SketchId,
|
||
#[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: Expr,
|
||
/// Two Sides: the angle on the other side.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Angle 2")]
|
||
angle2: Option<Expr>,
|
||
/// Symmetric: `angle` split evenly either side of the sketch.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
symmetric: bool,
|
||
},
|
||
/// A surface body swept along a chain of sketch curves from open curve chains and the
|
||
/// boundaries of profiles: walls only, no caps.
|
||
SurfaceSweep {
|
||
sketch: SketchId,
|
||
#[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>,
|
||
path_sketch: SketchId,
|
||
path: Vec<String>,
|
||
/// How the profile turns along the path (default: perpendicular to it).
|
||
#[serde(default, skip_serializing_if = "SweepOrientation::is_perpendicular")]
|
||
orientation: SweepOrientation,
|
||
/// Angle the profile turns about the path over its length.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Twist")]
|
||
twist: Option<Expr>,
|
||
/// The profile's scale at the end of the path (linear along its length).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(unitless = "Scale")]
|
||
scale: Option<Expr>,
|
||
/// Guide rails (one or two) the curves follow, instead of orientation, twist and scale.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
rails: Vec<SweepRail>,
|
||
/// How the rails reshape the curves.
|
||
#[serde(default, skip_serializing_if = "RailFit::is_scale")]
|
||
rail_fit: RailFit,
|
||
},
|
||
/// A surface body lofted through sections in order, each one open or closed chain of
|
||
/// sketch curves: walls only, no caps.
|
||
SurfaceLoft {
|
||
sections: Vec<SheetSection>,
|
||
#[serde(default = "loft_plain_continuity", skip_serializing_if = "loft_continuity_is_plain")]
|
||
continuity: [Continuity; 2],
|
||
#[serde(default, skip_serializing_if = "loft_crown_is_plain")]
|
||
crown: [f64; 2],
|
||
/// Guide rails (one or two) the loft follows between its sections.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
rails: Vec<SweepRail>,
|
||
/// How the rails reshape the sections between.
|
||
#[serde(default, skip_serializing_if = "RailFit::is_scale")]
|
||
rail_fit: RailFit,
|
||
},
|
||
/// The faces at `faces` copied out at a signed `distance` along their normals as a new
|
||
/// surface body (0 copies them); `chain` takes each pick's whole smooth chain of faces;
|
||
/// fitted faces within `tolerance`.
|
||
SurfaceOffset {
|
||
faces: Vec<FacePick>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
body: Option<BodyName>,
|
||
#[walk(length = "Distance")]
|
||
distance: Expr,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
chain: bool,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Tolerance")]
|
||
tolerance: Option<Expr>,
|
||
},
|
||
/// A strip of ruled surface `distance` wide hanging off the chain of `body`'s edges through
|
||
/// `edges`, as a new surface body: along `mode` (`angle` from `direction`, or from the
|
||
/// 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. `far`: per chain edge,
|
||
/// the interior control points of a free strip's far curve (moved handles); `None` or
|
||
/// missing, the kernel's default curve.
|
||
SurfaceRuled {
|
||
body: BodyName,
|
||
edges: Vec<Position>,
|
||
#[walk(length = "Distance")]
|
||
distance: Expr,
|
||
#[serde(default, skip_serializing_if = "RuledMode::is_normal")]
|
||
mode: RuledMode,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Angle")]
|
||
angle: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
direction: Option<Dir>,
|
||
#[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")]
|
||
face: Option<FacePick>,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
far: Vec<Option<Vec<Position>>>,
|
||
},
|
||
/// A surface body's boundary edges through `edges` extended outward: by `distance`, or up
|
||
/// to `up_to`; the surface continued (`mode` natural) or a run-off face along each edge
|
||
/// (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 {
|
||
body: BodyName,
|
||
edges: Vec<Position>,
|
||
#[walk(length = "Distance")]
|
||
distance: Expr,
|
||
#[serde(default, skip_serializing_if = "ExtendMode::is_natural")]
|
||
mode: ExtendMode,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
up_to: Option<ExtendTo>,
|
||
#[serde(default = "yes", skip_serializing_if = "is_yes")]
|
||
neighbours: bool,
|
||
},
|
||
/// A blend surface bridging two picked edge chains of two bodies (`surface.blend`): each end
|
||
/// repeats the surface it leaves up to its requested continuity, with the fullness `bulge`.
|
||
SurfaceBlend {
|
||
from: BlendSide,
|
||
to: BlendSide,
|
||
/// How much of each support surface the blend repeats: [from, to].
|
||
#[serde(default = "blend_orders")]
|
||
continuity: [Continuity; 2],
|
||
/// How full each end leaves: [from, to]; 0 is the plain bridge.
|
||
#[serde(default)]
|
||
bulge: [f64; 2],
|
||
/// Points the blend leaves towards, when the faces at the picks do not say: [from, to].
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
align: Option<[Position; 2]>,
|
||
/// Where each chain's stations start, when two closed chains should not pair the way
|
||
/// that keeps the blend from twisting: a point on each chain, [from, to]. An open chain
|
||
/// starts at the end nearer its point.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
seam: Option<[Position; 2]>,
|
||
/// Sew the blend onto its two bodies where the boundaries meet.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
stitch: bool,
|
||
},
|
||
/// One surface patch through a network of two to four boundary curves of a sketch
|
||
/// (`surface.boundary`, issue #763): the patch runs through the curves in loop order and leaves
|
||
/// each boundary at its own `order` — a sketch curve's boundary is a plane, so G1 and up hold
|
||
/// exactly — with `crown` shaping the middle without touching a boundary.
|
||
SurfaceBoundary {
|
||
sketch: SketchId,
|
||
/// The curves in loop order: each one ends where the next begins, and the last where the
|
||
/// first does.
|
||
curves: Vec<String>,
|
||
/// How much of the surface across each boundary the patch repeats, one per curve (none: a
|
||
/// tangent plane, `g1`, on every side).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
orders: Vec<Continuity>,
|
||
/// How full the middle is: 0 the plain construction, up to 3 fuller, down to -0.9 flatter.
|
||
#[serde(default)]
|
||
crown: f64,
|
||
/// The stations every boundary carries.
|
||
#[serde(default = "boundary_samples")]
|
||
samples: usize,
|
||
},
|
||
/// One surface through a curve network (`surface.boundary` with `u` and `v`, issue #763): the
|
||
/// curves `u` run one way (two or more: the surface lofts through them) and `v` cross them the
|
||
/// other way (two each way: a Coons patch; more: a Gordon surface through every curve). A side
|
||
/// may be a point (a three-sided patch). A curve that is a chain of a surface's open edges may
|
||
/// carry G1 or G2 with the face beside it. `operation` join sews the surface into the body of
|
||
/// its first edge curve (a solid when it closes the gap there).
|
||
SurfaceNetwork {
|
||
u: Vec<NetworkCurve>,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
v: Vec<NetworkCurve>,
|
||
#[serde(default)]
|
||
operation: Operation,
|
||
},
|
||
/// One face of a surface body rebuilt against another body (`surface.match`): the rebuilt
|
||
/// boundary nearest the chain of `edges` on `target` takes that chain's place and repeats the
|
||
/// target's own shape along the seam up to `order`, while the boundary opposite it, and the
|
||
/// body's name, stay where they were. `faces` picks the face to rebuild (its first, when none).
|
||
SurfaceMatch {
|
||
body: BodyName,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
faces: Vec<FacePick>,
|
||
target: BodyName,
|
||
edges: Vec<Position>,
|
||
#[serde(default = "match_order")]
|
||
order: Continuity,
|
||
},
|
||
/// The B-spline faces at `faces` of `body` faired (`surface.fair`): each face's interior
|
||
/// control vertices move to flatten the thin-plate (curvature-variation) energy of the face,
|
||
/// `strength` of the full least-squares step at a time, for at most `iterations` steps.
|
||
/// `keep_edges` holds the row of control points next to each edge as well as the boundary row
|
||
/// itself, so the face keeps meeting its neighbours in position and in tangent. `tolerance`
|
||
/// is the farthest a control point may move, so the faired face stays within it of the one the
|
||
/// design asked for; an empty `faces` fairs every face of the body.
|
||
SurfaceFair {
|
||
body: BodyName,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
faces: Vec<FacePick>,
|
||
#[serde(default = "fair_strength")]
|
||
strength: f64,
|
||
#[serde(default = "fair_iterations")]
|
||
iterations: u32,
|
||
#[serde(default = "fair_keep_edges")]
|
||
keep_edges: bool,
|
||
#[walk(length = "Tolerance")]
|
||
tolerance: Expr,
|
||
},
|
||
/// A surface body trimmed by a plane, by a face of a body (`tool`, its surface extended) or
|
||
/// by sketch curves swept onto it (`curves`), keeping the side of `keep`; with `keep_more`,
|
||
/// the regions (pieces that hang together once cut) `keep` and those points pick instead.
|
||
/// With `with`, a mutual trim: `body` and `with` (one face each) cut each other, `with`
|
||
/// keeping the side of its one `keep_with` point or the regions of several; `extend`
|
||
/// extends one that stops short of the other to meet it, and `stitch` sews the two kept
|
||
/// pieces into `body` (`with` is then gone).
|
||
SurfaceTrim {
|
||
body: BodyName,
|
||
plane: PlaneRef,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
tool: Option<FaceAt>,
|
||
keep: Position,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
keep_more: Vec<Position>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
curves: Option<TrimCurves>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
with: Option<BodyName>,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
keep_with: Vec<Position>,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
stitch: bool,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
extend: bool,
|
||
},
|
||
Move {
|
||
bodies: Vec<BodyName>,
|
||
#[walk(length = ["X distance", "Y distance", "Z distance"])]
|
||
translate: [Expr; 3],
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
rotate_axis: Option<Dir>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Angle")]
|
||
angle: Option<Expr>,
|
||
/// When set, the original bodies are kept and the transform is applied to a new copy
|
||
/// of each instead of moving them in place.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
copy: bool,
|
||
},
|
||
/// A non-parametric base feature: bodies imported from a STEP file. The STEP text is kept
|
||
/// in the design (it is the B-rep), so the design reopens without the original file.
|
||
Import {
|
||
/// Source file name (display only).
|
||
file: String,
|
||
/// The STEP (ISO 10303-21) text, shared by every copy of the design (undo states,
|
||
/// previews, scratch sessions): a large file is held once, not once per edit.
|
||
step: std::sync::Arc<str>,
|
||
/// The file's product/assembly tree, kept for components.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
components: Vec<solidcraft_kernel::StepNode>,
|
||
/// The file's bodies (by index) this feature does not build: later instances of a part
|
||
/// the file places more than once, shown by the other occurrences of that part's
|
||
/// component (#1386). Empty in designs from before format 22: every body is built.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
skip: Vec<u64>,
|
||
},
|
||
/// Rebuild an upstream constant-section mesh with analytic planar/cylindrical faces.
|
||
MeshConvert {
|
||
body: BodyName,
|
||
#[walk(length = "Tolerance")]
|
||
tolerance: Expr,
|
||
},
|
||
/// Mesh bodies imported from a 3MF or STL file, embedded in the design.
|
||
MeshImport {
|
||
/// Source file name (display only).
|
||
file: String,
|
||
meshes: Vec<MeshData>,
|
||
},
|
||
/// Repair Part (#8371): faces SMLib refuses rebuilt on their own surfaces, free edges that
|
||
/// pair up within `gap` sewn, and, when `patch_holes`, the loops of free edges left patched
|
||
/// and sewn in (`kernel::repair`).
|
||
Repair {
|
||
body: BodyName,
|
||
#[walk(length = "Gap")]
|
||
gap: Expr,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
patch_holes: bool,
|
||
},
|
||
}
|
||
|
||
/// A fillet corner set back: the vertex at `vertex`, where every edge is rounded, has its corner
|
||
/// patch start `distance` along each of its edges from the vertex, the rounds running whole up to
|
||
/// their sections there. One distance for all of a corner's edges.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct CornerSetback {
|
||
pub vertex: Position,
|
||
#[walk(length = "Setback")]
|
||
pub distance: Expr,
|
||
}
|
||
|
||
/// What fills the corner where three blended edges meet.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum FilletCorner {
|
||
/// A piece of the rolling ball's sphere: tangent (G1) to each blend.
|
||
#[default]
|
||
Rolling,
|
||
/// The corner set back (its distance from the fillet's `setbacks`, else 1.5 × the radius)
|
||
/// and filled with a patch meeting the rounds and the faces round it to the second order
|
||
/// (`solidcraft_kernel::fillet_g2_corners`).
|
||
G2,
|
||
}
|
||
|
||
impl FilletCorner {
|
||
pub fn is_rolling(&self) -> bool {
|
||
matches!(self, FilletCorner::Rolling)
|
||
}
|
||
}
|
||
|
||
/// How two constant rounds of one radius turn round a sharp, straight, convex side edge square to
|
||
/// both on a plane, such as the rounds along a boss's base at its upright edges.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum FilletTurn {
|
||
/// The rounds run on to where they cross and meet in a mitre.
|
||
#[default]
|
||
Mitre,
|
||
/// The rounds end at the side edge and the corner is their section revolved about it, a
|
||
/// torus tangent to both (`solidcraft_kernel::FilletTurn::Swept`).
|
||
Swept,
|
||
}
|
||
|
||
/// Why a swept turn is refused with a fillet's other options: the kernel sweeps the turn of two
|
||
/// constant rounds of one radius, at its own corners only.
|
||
pub const SWEPT_TAKES: &str = "a swept corner turns two constant rounds of one radius: `turn: swept` takes `type: constant`, \
|
||
`corner: rolling`, no `setbacks` and `fit: exact` or `reduce`";
|
||
|
||
impl FilletTurn {
|
||
pub fn is_mitre(&self) -> bool {
|
||
*self == FilletTurn::Mitre
|
||
}
|
||
|
||
/// The kernel's turn.
|
||
pub fn kernel(self) -> solidcraft_kernel::FilletTurn {
|
||
match self {
|
||
FilletTurn::Mitre => solidcraft_kernel::FilletTurn::Mitre,
|
||
FilletTurn::Swept => solidcraft_kernel::FilletTurn::Swept,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// How Extend continues a surface past its edges.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum ExtendMode {
|
||
/// The surface itself, continued.
|
||
#[default]
|
||
Natural,
|
||
/// A ruled run-off in the surface's tangent plane (G1).
|
||
Tangent,
|
||
/// A run-off that keeps the surface's curvature across the edge (G2).
|
||
Curvature,
|
||
}
|
||
|
||
impl ExtendMode {
|
||
pub fn is_natural(&self) -> bool {
|
||
*self == ExtendMode::Natural
|
||
}
|
||
}
|
||
|
||
/// Where a thread runs up to instead of a length.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum ThreadLimit {
|
||
/// Where this point lies along the thread's axis (a point on a face, such as a shoulder).
|
||
Face(FacePick),
|
||
/// Where this plane crosses the thread's axis.
|
||
Plane(PlaneRef),
|
||
}
|
||
|
||
/// A thread's runout length at one end: a length, or ISO 3508's standard (2.5 P) or short
|
||
/// (1.25 P) runout.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum ThreadRunout {
|
||
Standard,
|
||
Short,
|
||
Length {
|
||
#[walk(length = "Runout")]
|
||
length: Expr,
|
||
},
|
||
}
|
||
|
||
/// What Extend extends up to instead of a distance.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum ExtendTo {
|
||
/// A plane.
|
||
Plane(PlaneRef),
|
||
/// The surface of a body's face (extended).
|
||
Face(FaceAt),
|
||
/// The surface's own bounds (natural only): a trim undone.
|
||
Bounds,
|
||
}
|
||
|
||
/// How a fillet's size is given.
|
||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
#[serde(tag = "type", rename_all = "snake_case")]
|
||
pub enum FilletStyle {
|
||
#[default]
|
||
Constant,
|
||
/// `radius` is the chord: the width across the blend.
|
||
Chord,
|
||
/// G2 quintic blend of planar faces along a straight edge. `radius` sets the
|
||
/// equivalent circular setback, not a constant curvature radius.
|
||
Curvature,
|
||
/// `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: Expr,
|
||
start: Position,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
#[walk(length = "Mid radius")]
|
||
mid: Vec<(f64, Expr)>,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
smooth: bool,
|
||
},
|
||
/// 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: Position,
|
||
knots: Vec<f64>,
|
||
#[walk(length = |i: usize, n: usize| if i + 1 == n { "End radius" } else { "Control radius" })]
|
||
radii: Vec<Expr>,
|
||
},
|
||
}
|
||
|
||
/// A fillet radius too large for the geometry around its edges: refused (`Exact`, the default),
|
||
/// reduced to the largest that works for all of them (`Reduce`), or tapered along each edge it
|
||
/// doesn't fit to the room there, down to zero where a face closes to a point (`Taper`); a
|
||
/// warning says what was done.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum FilletFit {
|
||
#[default]
|
||
Exact,
|
||
Reduce,
|
||
Taper,
|
||
}
|
||
|
||
impl FilletFit {
|
||
pub fn is_exact(&self) -> bool {
|
||
*self == FilletFit::Exact
|
||
}
|
||
}
|
||
|
||
impl FilletStyle {
|
||
pub fn is_constant(&self) -> bool {
|
||
*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 {
|
||
let degree = knots.len().saturating_sub(values.len() + 1);
|
||
solidcraft_kernel::RadiusSpline { degree, knots: knots.to_vec(), radii: values }
|
||
}
|
||
}
|
||
|
||
/// Sketch curves a trim cuts with: chains of the curves `curves` (every curve of the sketch
|
||
/// that is not construction geometry when empty) swept along `direction` (the sketch's normal
|
||
/// when none) onto the surface.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct TrimCurves {
|
||
pub sketch: SketchId,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub curves: Vec<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub direction: Option<Dir>,
|
||
}
|
||
|
||
/// A face picked by a point on it, on a named body.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct FaceAt {
|
||
pub body: BodyName,
|
||
pub point: Position,
|
||
}
|
||
|
||
/// One end of a blend: a body and the points that pick the edges of its boundary chain. With two
|
||
/// picks on the same edge the chain is that one edge; more pick a chain that runs on from pick to
|
||
/// pick (the order of the picks does not matter).
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct BlendSide {
|
||
pub body: BodyName,
|
||
pub edges: Vec<Position>,
|
||
}
|
||
|
||
/// One curve of a boundary surface's network ([`FeatureKind::SurfaceNetwork`]): a chain of a
|
||
/// sketch's `curves` (planar or 3D, meeting end to end), a chain of `body`'s edges picked by points
|
||
/// on them (`edges`), or a side collapsed to the point `point` (the apex of a three-sided patch).
|
||
/// A chain of a surface's open edges may carry `continuity` with the face beside it (G0, the
|
||
/// default, G1 or G2).
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct NetworkCurve {
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub sketch: Option<SketchId>,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub curves: Vec<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub body: Option<BodyName>,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub edges: Vec<Position>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub point: Option<Position>,
|
||
#[serde(default = "patch_g0", skip_serializing_if = "is_g0")]
|
||
pub continuity: Continuity,
|
||
}
|
||
|
||
/// How a patch on a loop of edges meets the faces beside the loop: every edge with `all`, but the
|
||
/// edges picked in `edges` with their own.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct PatchContinuity {
|
||
#[serde(default = "patch_g0", skip_serializing_if = "is_g0")]
|
||
pub all: Continuity,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub edges: Vec<EdgeContinuity>,
|
||
}
|
||
|
||
/// One edge of a patch's loop (a point on it) and how the patch meets the face beside it.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct EdgeContinuity {
|
||
pub edge: Position,
|
||
pub g: Continuity,
|
||
}
|
||
|
||
impl Default for PatchContinuity {
|
||
fn default() -> PatchContinuity {
|
||
PatchContinuity { all: Continuity::G0, edges: Vec::new() }
|
||
}
|
||
}
|
||
|
||
impl PatchContinuity {
|
||
/// G0 everywhere: the patch only meets its edges.
|
||
pub fn is_g0(&self) -> bool {
|
||
self.all == Continuity::G0 && self.edges.iter().all(|e| e.g == Continuity::G0)
|
||
}
|
||
}
|
||
|
||
fn patch_g0() -> Continuity {
|
||
Continuity::G0
|
||
}
|
||
|
||
fn is_g0(g: &Continuity) -> bool {
|
||
*g == Continuity::G0
|
||
}
|
||
|
||
/// The continuity a blend repeats by default: the tangent plane on both sides.
|
||
/// The stations a boundary patch carries by default.
|
||
fn boundary_samples() -> usize {
|
||
BOUNDARY_SAMPLES
|
||
}
|
||
|
||
/// The stations a boundary patch carries when a design does not say.
|
||
pub const BOUNDARY_SAMPLES: usize = 25;
|
||
|
||
fn blend_orders() -> [Continuity; 2] {
|
||
[Continuity::G1, Continuity::G1]
|
||
}
|
||
|
||
/// The continuity a match holds by default: position, tangent plane and curvature.
|
||
fn match_order() -> Continuity {
|
||
Continuity::G2
|
||
}
|
||
|
||
/// A fairing's defaults for a design that leaves them out: the whole least-squares step at a
|
||
/// time, and the boundary held (the row next to each edge too, so the face still meets its
|
||
/// neighbours in tangent).
|
||
fn fair_strength() -> f64 {
|
||
1.0
|
||
}
|
||
fn fair_iterations() -> u32 {
|
||
1
|
||
}
|
||
fn fair_keep_edges() -> bool {
|
||
true
|
||
}
|
||
|
||
/// Triangles of one imported mesh body (millimetres). The arrays are shared by clones: every
|
||
/// edit keeps the design as it was for undo, and a scanned part's triangles (hundreds of
|
||
/// megabytes) are not copied for that.
|
||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||
pub struct MeshData {
|
||
pub name: String,
|
||
/// x, y, z per vertex.
|
||
pub positions: std::sync::Arc<[f64]>,
|
||
/// Three vertex indices per triangle.
|
||
pub triangles: std::sync::Arc<[u32]>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub color: Option<[f32; 3]>,
|
||
}
|
||
|
||
/// The same mesh: shared arrays are the same without reading them, so the dirty check and
|
||
/// autosave after an edit elsewhere do not walk a scan's millions of coordinates. Arrays that
|
||
/// are not shared compare value by value, as before. Coordinates are finite (a design that
|
||
/// holds others does not load), so the shortcut only skips work.
|
||
impl PartialEq for MeshData {
|
||
fn eq(&self, other: &Self) -> bool {
|
||
use std::sync::Arc;
|
||
self.name == other.name
|
||
&& self.color == other.color
|
||
&& (Arc::ptr_eq(&self.triangles, &other.triangles) || self.triangles == other.triangles)
|
||
&& (Arc::ptr_eq(&self.positions, &other.positions) || self.positions == other.positions)
|
||
}
|
||
}
|
||
|
||
/// Points of a sketch, by id.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct SketchPoints {
|
||
pub sketch: SketchId,
|
||
pub ids: Vec<String>,
|
||
/// Drill the other way: away from the side the holes would go into by themselves.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
pub flip: bool,
|
||
/// A Single hole snapped to this one point (#2110): drilled at the point as it moves, along
|
||
/// the hole's `direction` (into the face it was placed on) rather than across the sketch.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
pub single: bool,
|
||
}
|
||
|
||
/// A component: a node of the design tree that owns sketches, features and bodies. The root
|
||
/// (id 0) is the design itself and is not stored.
|
||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||
pub struct Component {
|
||
pub id: u64,
|
||
/// Optional identification colour, separate from normal appearances.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub identification_color: Option<[u8; 3]>,
|
||
/// Creation sequence used to select an automatic identification colour.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub identification_color_index: Option<u64>,
|
||
pub name: String,
|
||
/// Parent component (0 = the root).
|
||
#[serde(default)]
|
||
pub parent: u64,
|
||
/// The definition's part properties (part number, description, revision…) and other tools'
|
||
/// data, under the same rules as the design's own `metadata`. Every occurrence shares them;
|
||
/// the bill of materials reads them.
|
||
#[serde(default, skip_serializing_if = "crate::Metadata::is_empty")]
|
||
pub metadata: crate::Metadata,
|
||
/// Free text properties of the definition (material grade, finish, supplier…), by name.
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub properties: std::collections::BTreeMap<String, String>,
|
||
/// Keeps this component's features (and its children's) out of the History bar (#10393).
|
||
/// The features still rebuild and the component still shows in the Browser; imported copies
|
||
/// whose features only exist to rebuild the copy can carry this flag.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
pub history_hidden: bool,
|
||
}
|
||
|
||
/// One loft section: profiles of a sketch.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct LoftSection {
|
||
pub sketch: SketchId,
|
||
#[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")]
|
||
pub point: Option<String>,
|
||
}
|
||
|
||
/// 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, solidcraft_derive::Walk)]
|
||
pub struct SheetSection {
|
||
pub sketch: SketchId,
|
||
#[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>,
|
||
/// A section picked as an edge chain of a body instead of a sketch: `edges` are points on the
|
||
/// chain, and the face the chain bounds is the surface the loft leaves there.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub body: Option<BodyName>,
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub edges: Vec<Position>,
|
||
}
|
||
|
||
/// A loft's continuity where a design does not say: both ends G0, the loft of old, which only
|
||
/// passes through its sections.
|
||
fn loft_plain_continuity() -> [Continuity; 2] {
|
||
[Continuity::G0, Continuity::G0]
|
||
}
|
||
|
||
/// A loft's continuity is plain when it only passes through its sections: both ends G0.
|
||
fn loft_continuity_is_plain(c: &[Continuity; 2]) -> bool {
|
||
*c == [Continuity::G0, Continuity::G0]
|
||
}
|
||
|
||
/// A loft's crown is plain when neither end is filled out.
|
||
fn loft_crown_is_plain(c: &[f64; 2]) -> bool {
|
||
c.iter().all(|v| *v == 0.0)
|
||
}
|
||
|
||
/// Coil cross-sections.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum CoilSection {
|
||
#[default]
|
||
Circular,
|
||
Square,
|
||
}
|
||
|
||
fn is_zero_i8(v: &i8) -> bool {
|
||
*v == 0
|
||
}
|
||
|
||
/// A parameter that is left out when it is 0 (an optional shape knob).
|
||
fn is_zero(v: &f64) -> bool {
|
||
*v == 0.0
|
||
}
|
||
|
||
/// Hole shapes.
|
||
#[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: Expr,
|
||
},
|
||
Counterbore {
|
||
#[walk(length = "Counterbore diameter")]
|
||
cb_diameter: Expr,
|
||
#[walk(length = "Counterbore depth")]
|
||
cb_depth: Expr,
|
||
/// Optional drill point below the narrow cylindrical bore; absent stays flat.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Tip angle")]
|
||
tip_angle: Option<Expr>,
|
||
/// Printing aid: two bridge layers this thick below the counterbore's floor (a slot along
|
||
/// X, then a square), so a printer bridges the step instead of sagging into it. Absent:
|
||
/// a plain counterbore.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Bridge layer")]
|
||
bridge: Option<Expr>,
|
||
},
|
||
Countersink {
|
||
#[walk(length = "Countersink diameter")]
|
||
cs_diameter: Expr,
|
||
#[walk(angle = "Countersink angle")]
|
||
cs_angle: Expr,
|
||
/// Optional drill point, independent of the entry countersink.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(angle = "Tip angle")]
|
||
tip_angle: Option<Expr>,
|
||
},
|
||
}
|
||
|
||
/// A Single hole's reference edge (#37): a point on a straight edge of the hole's face, and the
|
||
/// distance of the hole's centre from that edge's line, in the face's plane.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
pub struct HoleReference {
|
||
pub edge: Position,
|
||
#[walk(length = "Reference distance")]
|
||
pub distance: Expr,
|
||
}
|
||
|
||
/// Pattern layouts.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, solidcraft_derive::Walk)]
|
||
#[serde(tag = "type", rename_all = "snake_case")]
|
||
pub enum PatternKind {
|
||
Rectangular {
|
||
dir1: Dir,
|
||
#[walk(unitless = "Quantity")]
|
||
count1: Expr,
|
||
#[walk(length = "Spacing")]
|
||
spacing1: Expr,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
dir2: Option<Dir>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(unitless = "Quantity 2")]
|
||
count2: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
#[walk(length = "Spacing 2")]
|
||
spacing2: Option<Expr>,
|
||
#[serde(default, skip_serializing_if = "default_pattern_alignment")]
|
||
alignment: solidcraft_sketch::PatternAlignment,
|
||
#[serde(default, skip_serializing_if = "default_pattern_alignment")]
|
||
alignment2: solidcraft_sketch::PatternAlignment,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
reversed: bool,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
reversed2: bool,
|
||
},
|
||
Circular {
|
||
/// A point on the axis the copies turn about: numbers, or length expressions it follows
|
||
/// as the parameters change (#10852).
|
||
#[serde(with = "point_expr")]
|
||
#[walk(placement)]
|
||
origin: PointExpr,
|
||
axis: Dir,
|
||
#[walk(unitless = "Quantity")]
|
||
count: Expr,
|
||
/// Total angle (360 deg = evenly around).
|
||
#[walk(angle = "Total angle")]
|
||
angle: Expr,
|
||
#[serde(default, skip_serializing_if = "default_pattern_alignment")]
|
||
alignment: solidcraft_sketch::PatternAlignment,
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
reversed: bool,
|
||
/// The edge or round face of the model the copies turn about, found again on each
|
||
/// evaluation ([`crate::construct::model_axis`]); `origin` and `axis` are where it was
|
||
/// when picked.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
axis_ref: Option<GeoRef>,
|
||
/// A construction axis the copies turn about, by name, followed when it moves;
|
||
/// `origin` and `axis` are where it was when the pattern was made.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
axis_feature: Option<FeatureName>,
|
||
},
|
||
/// Copies along a chain of sketch curves: instance k moves by path(k·spacing) − path(0),
|
||
/// measured along the path from its start.
|
||
Path {
|
||
path_sketch: SketchId,
|
||
path: Vec<String>,
|
||
#[walk(unitless = "Quantity")]
|
||
count: Expr,
|
||
/// Distance along the path between instances, or the whole extent when `extent`.
|
||
#[walk(length = "Distance")]
|
||
spacing: Expr,
|
||
/// `spacing` is the distance from the first to the last instance.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
extent: bool,
|
||
/// Run from the path's other end.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
flip: bool,
|
||
/// Turn copies with the path's direction (else they keep their orientation).
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
orient: bool,
|
||
},
|
||
}
|
||
|
||
fn default_pattern_alignment(alignment: &solidcraft_sketch::PatternAlignment) -> bool {
|
||
*alignment == solidcraft_sketch::PatternAlignment::Right
|
||
}
|
||
|
||
fn z_axis() -> Dir {
|
||
Dir(Vec3::Z)
|
||
}
|
||
|
||
/// A point whose coordinates are length expressions (`["basin_width / 2", "10 mm", "0"]`), so
|
||
/// it follows parameter changes. Primitives are placed by one.
|
||
pub type PointExpr = [Expr; 3];
|
||
|
||
/// A point as expressions (plain numbers, mm).
|
||
pub fn point_expr(p: Vec3) -> PointExpr {
|
||
[Expr::new(format!("{}", p.x)), Expr::new(format!("{}", p.y)), Expr::new(format!("{}", p.z))]
|
||
}
|
||
|
||
/// Stored as `[x, y, z]`: plain numbers as numbers (as points were before they took
|
||
/// expressions, so such designs read and write the same), anything else as a string.
|
||
mod point_expr {
|
||
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
||
|
||
#[derive(Serialize, Deserialize)]
|
||
#[serde(untagged)]
|
||
enum Coord {
|
||
Num(f64),
|
||
Expr(String),
|
||
}
|
||
|
||
pub fn serialize<S: Serializer>(p: &super::PointExpr, s: S) -> Result<S::Ok, S::Error> {
|
||
let c = |e: &crate::Expr| match e.parse::<f64>() {
|
||
Ok(v) if v.is_finite() && format!("{v}") == e.as_str() => Coord::Num(v),
|
||
_ => Coord::Expr(e.to_string()),
|
||
};
|
||
[c(&p[0]), c(&p[1]), c(&p[2])].serialize(s)
|
||
}
|
||
|
||
pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<super::PointExpr, D::Error> {
|
||
let c = |x: Coord| match x {
|
||
Coord::Num(v) => crate::Expr::new(format!("{v}")),
|
||
Coord::Expr(e) => crate::Expr::new(e),
|
||
};
|
||
let [x, y, z] = <[Coord; 3]>::deserialize(d)?;
|
||
Ok([c(x), c(y), c(z)])
|
||
}
|
||
}
|
||
|
||
/// [`point_expr`] for an optional point.
|
||
mod opt_point_expr {
|
||
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
||
|
||
#[derive(Serialize, Deserialize)]
|
||
struct Wrap(#[serde(with = "super::point_expr")] super::PointExpr);
|
||
|
||
pub fn serialize<S: Serializer>(p: &Option<super::PointExpr>, s: S) -> Result<S::Ok, S::Error> {
|
||
p.as_ref().map(|p| Wrap(p.clone())).serialize(s)
|
||
}
|
||
|
||
pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<super::PointExpr>, D::Error> {
|
||
Ok(Option::<Wrap>::deserialize(d)?.map(|w| w.0))
|
||
}
|
||
}
|
||
|
||
impl FeatureKind {
|
||
/// A sheet metal feature (its result depends on the sheet metal rules).
|
||
pub fn is_plastic(&self) -> bool {
|
||
matches!(self, FeatureKind::Boss { .. } | FeatureKind::Lip { .. } | FeatureKind::SnapFit { .. } | FeatureKind::Rest { .. })
|
||
}
|
||
|
||
pub fn is_sheet(&self) -> bool {
|
||
matches!(
|
||
self,
|
||
FeatureKind::SheetBase { .. }
|
||
| FeatureKind::SheetContour { .. }
|
||
| FeatureKind::SheetFlange { .. }
|
||
| FeatureKind::SheetHem { .. }
|
||
| FeatureKind::SheetPerforate { .. }
|
||
| FeatureKind::SheetFold { .. }
|
||
| FeatureKind::SheetPath { .. }
|
||
| FeatureKind::SheetUnfold { .. }
|
||
| FeatureKind::SheetConvert { .. }
|
||
)
|
||
}
|
||
|
||
/// Short type name (timeline tooltip, `inspect`).
|
||
pub fn type_name(&self) -> &'static str {
|
||
match self {
|
||
FeatureKind::BodyTransfer { .. } => "BodyTransferFeature",
|
||
FeatureKind::Sketch { .. } => "Sketch",
|
||
FeatureKind::Extrude { .. } => "ExtrudeFeature",
|
||
FeatureKind::Revolve { .. } => "RevolveFeature",
|
||
FeatureKind::Fillet { .. } => "FilletFeature",
|
||
FeatureKind::Chamfer { .. } => "ChamferFeature",
|
||
FeatureKind::Box { .. } => "BoxFeature",
|
||
FeatureKind::Cylinder { .. } => "CylinderFeature",
|
||
FeatureKind::Sphere { .. } => "SphereFeature",
|
||
FeatureKind::Torus { .. } => "TorusFeature",
|
||
FeatureKind::Cone { .. } => "ConeFeature",
|
||
FeatureKind::Combine { .. } => "CombineFeature",
|
||
FeatureKind::Pattern { pattern: PatternKind::Rectangular { .. }, .. } => "RectangularPatternFeature",
|
||
FeatureKind::Pattern { pattern: PatternKind::Path { .. }, .. } => "PathPatternFeature",
|
||
FeatureKind::Pattern { .. } => "CircularPatternFeature",
|
||
FeatureKind::Mirror { .. } => "MirrorFeature",
|
||
FeatureKind::ConstructionPlane { .. } => "ConstructionPlane",
|
||
FeatureKind::Hole { .. } => "HoleFeature",
|
||
FeatureKind::Thread { .. } => "ThreadFeature",
|
||
FeatureKind::Loft { .. } => "LoftFeature",
|
||
FeatureKind::Sweep { .. } => "SweepFeature",
|
||
FeatureKind::Shell { .. } => "ShellFeature",
|
||
FeatureKind::Draft { .. } => "DraftFeature",
|
||
FeatureKind::Split { .. } => "SplitBodyFeature",
|
||
FeatureKind::SplitFace { .. } => "SplitFaceFeature",
|
||
FeatureKind::ConstructionAxis { .. } => "ConstructionAxis",
|
||
FeatureKind::ConstructionPoint { .. } => "ConstructionPoint",
|
||
FeatureKind::Move { .. } => "MoveFeature",
|
||
FeatureKind::Scale { .. } => "ScaleFeature",
|
||
FeatureKind::OffsetFace { .. } => "OffsetFacesFeature",
|
||
FeatureKind::DeleteFace { .. } => "DeleteFaceFeature",
|
||
FeatureKind::SurfaceOffset { .. } => "OffsetSurfaceFeature",
|
||
FeatureKind::BoundingSolid { .. } => "BoundingSolidFeature",
|
||
FeatureKind::Pipe { .. } => "PipeFeature",
|
||
FeatureKind::FrameMember { .. } => "FrameMemberFeature",
|
||
FeatureKind::Emboss { .. } => "EmbossFeature",
|
||
FeatureKind::Boss { .. } => "BossFeature",
|
||
FeatureKind::Lip { groove: false, .. } => "LipFeature",
|
||
FeatureKind::Lip { .. } => "GrooveFeature",
|
||
FeatureKind::SnapFit { .. } => "SnapFitFeature",
|
||
FeatureKind::Rest { .. } => "RestFeature",
|
||
FeatureKind::BoundaryFill { .. } => "BoundaryFillFeature",
|
||
FeatureKind::SheetBase { .. } => "BaseFlangeFeature",
|
||
FeatureKind::SheetContour { .. } => "ContourFlangeFeature",
|
||
FeatureKind::SheetFlange { .. } => "EdgeFlangeFeature",
|
||
FeatureKind::SheetHem { .. } => "HemFeature",
|
||
FeatureKind::SheetPerforate { .. } => "PerforateFeature",
|
||
FeatureKind::SheetFold { .. } => "FoldFeature",
|
||
FeatureKind::SheetPath { .. } => "PathFlangeFeature",
|
||
FeatureKind::SheetUnfold { refold: false, .. } => "UnfoldFeature",
|
||
FeatureKind::SheetUnfold { .. } => "RefoldFeature",
|
||
FeatureKind::SheetConvert { .. } => "ConvertToSheetMetalFeature",
|
||
FeatureKind::Coil { .. } => "CoilFeature",
|
||
FeatureKind::Rib { web: false, .. } => "RibFeature",
|
||
FeatureKind::Rib { .. } => "WebFeature",
|
||
FeatureKind::ReplaceFace { .. } => "ReplaceFaceFeature",
|
||
FeatureKind::Align { .. } => "AlignFeature",
|
||
FeatureKind::Remove { .. } => "RemoveFeature",
|
||
FeatureKind::Patch { .. } => "PatchFeature",
|
||
FeatureKind::SurfaceExtrude { .. } => "SurfaceExtrudeFeature",
|
||
FeatureKind::SurfaceRevolve { .. } => "SurfaceRevolveFeature",
|
||
FeatureKind::SurfaceSweep { .. } => "SurfaceSweepFeature",
|
||
FeatureKind::SurfaceLoft { .. } => "SurfaceLoftFeature",
|
||
FeatureKind::SurfaceBlend { .. } => "BlendFeature",
|
||
FeatureKind::SurfaceBoundary { .. } | FeatureKind::SurfaceNetwork { .. } => "BoundaryFeature",
|
||
FeatureKind::SurfaceMatch { .. } => "MatchFeature",
|
||
FeatureKind::SurfaceFair { .. } => "FairFeature",
|
||
FeatureKind::Stitch { .. } => "StitchFeature",
|
||
FeatureKind::Thicken { .. } => "ThickenFeature",
|
||
FeatureKind::SurfaceTrim { .. } => "TrimFeature",
|
||
FeatureKind::SurfaceExtend { .. } => "ExtendFeature",
|
||
FeatureKind::SurfaceRuled { .. } => "RuledSurfaceFeature",
|
||
FeatureKind::Unstitch { .. } => "UnstitchFeature",
|
||
FeatureKind::ReverseNormal { .. } => "ReverseNormalFeature",
|
||
FeatureKind::SurfaceUntrim { .. } => "UntrimFeature",
|
||
FeatureKind::Import { .. } => "BaseFeature",
|
||
FeatureKind::MeshImport { .. } => "MeshFeature",
|
||
FeatureKind::MeshConvert { .. } => "MeshConvertFeature",
|
||
FeatureKind::Repair { .. } => "RepairFeature",
|
||
}
|
||
}
|
||
|
||
/// Design-file variant key (e.g. `"extrude"`, `"box"`, `"sheet_flange"`).
|
||
pub fn kind_key(&self) -> &'static str {
|
||
match self {
|
||
FeatureKind::BodyTransfer { .. } => "body_transfer",
|
||
FeatureKind::Sketch { .. } => "sketch",
|
||
FeatureKind::Extrude { .. } => "extrude",
|
||
FeatureKind::Revolve { .. } => "revolve",
|
||
FeatureKind::Fillet { .. } => "fillet",
|
||
FeatureKind::Chamfer { .. } => "chamfer",
|
||
FeatureKind::Box { .. } => "box",
|
||
FeatureKind::Cylinder { .. } => "cylinder",
|
||
FeatureKind::Sphere { .. } => "sphere",
|
||
FeatureKind::Torus { .. } => "torus",
|
||
FeatureKind::Cone { .. } => "cone",
|
||
FeatureKind::Combine { .. } => "combine",
|
||
FeatureKind::Pattern { .. } => "pattern",
|
||
FeatureKind::Mirror { .. } => "mirror",
|
||
FeatureKind::Hole { .. } => "hole",
|
||
FeatureKind::Thread { .. } => "thread",
|
||
FeatureKind::Loft { .. } => "loft",
|
||
FeatureKind::Sweep { .. } => "sweep",
|
||
FeatureKind::Shell { .. } => "shell",
|
||
FeatureKind::Draft { .. } => "draft",
|
||
FeatureKind::ConstructionPlane { .. } => "construction_plane",
|
||
FeatureKind::Split { .. } => "split",
|
||
FeatureKind::ConstructionAxis { .. } => "construction_axis",
|
||
FeatureKind::ConstructionPoint { .. } => "construction_point",
|
||
FeatureKind::SplitFace { .. } => "split_face",
|
||
FeatureKind::Scale { .. } => "scale",
|
||
FeatureKind::OffsetFace { .. } => "offset_face",
|
||
FeatureKind::DeleteFace { .. } => "delete_face",
|
||
FeatureKind::BoundingSolid { .. } => "bounding_solid",
|
||
FeatureKind::Pipe { .. } => "pipe",
|
||
FeatureKind::FrameMember { .. } => "frame_member",
|
||
FeatureKind::Emboss { .. } => "emboss",
|
||
FeatureKind::Rib { .. } => "rib",
|
||
FeatureKind::ReplaceFace { .. } => "replace_face",
|
||
FeatureKind::Align { .. } => "align",
|
||
FeatureKind::Coil { .. } => "coil",
|
||
FeatureKind::SheetBase { .. } => "sheet_base",
|
||
FeatureKind::SheetContour { .. } => "sheet_contour",
|
||
FeatureKind::SheetFlange { .. } => "sheet_flange",
|
||
FeatureKind::SheetHem { .. } => "sheet_hem",
|
||
FeatureKind::SheetPerforate { .. } => "sheet_perforate",
|
||
FeatureKind::SheetFold { .. } => "sheet_fold",
|
||
FeatureKind::SheetPath { .. } => "sheet_path",
|
||
FeatureKind::SheetUnfold { .. } => "sheet_unfold",
|
||
FeatureKind::SheetConvert { .. } => "sheet_convert",
|
||
FeatureKind::Boss { .. } => "boss",
|
||
FeatureKind::Lip { .. } => "lip",
|
||
FeatureKind::SnapFit { .. } => "snap_fit",
|
||
FeatureKind::Rest { .. } => "rest",
|
||
FeatureKind::BoundaryFill { .. } => "boundary_fill",
|
||
FeatureKind::Remove { .. } => "remove",
|
||
FeatureKind::Patch { .. } => "patch",
|
||
FeatureKind::Stitch { .. } => "stitch",
|
||
FeatureKind::Thicken { .. } => "thicken",
|
||
FeatureKind::SurfaceExtrude { .. } => "surface_extrude",
|
||
FeatureKind::Unstitch { .. } => "unstitch",
|
||
FeatureKind::ReverseNormal { .. } => "reverse_normal",
|
||
FeatureKind::SurfaceUntrim { .. } => "surface_untrim",
|
||
FeatureKind::SurfaceRevolve { .. } => "surface_revolve",
|
||
FeatureKind::SurfaceSweep { .. } => "surface_sweep",
|
||
FeatureKind::SurfaceLoft { .. } => "surface_loft",
|
||
FeatureKind::SurfaceOffset { .. } => "surface_offset",
|
||
FeatureKind::SurfaceRuled { .. } => "surface_ruled",
|
||
FeatureKind::SurfaceExtend { .. } => "surface_extend",
|
||
FeatureKind::SurfaceBlend { .. } => "surface_blend",
|
||
FeatureKind::SurfaceBoundary { .. } => "surface_boundary",
|
||
FeatureKind::SurfaceNetwork { .. } => "surface_network",
|
||
FeatureKind::SurfaceMatch { .. } => "surface_match",
|
||
FeatureKind::SurfaceFair { .. } => "surface_fair",
|
||
FeatureKind::SurfaceTrim { .. } => "surface_trim",
|
||
FeatureKind::Move { .. } => "move",
|
||
FeatureKind::Import { .. } => "import",
|
||
FeatureKind::MeshConvert { .. } => "mesh_convert",
|
||
FeatureKind::MeshImport { .. } => "mesh_import",
|
||
FeatureKind::Repair { .. } => "repair",
|
||
}
|
||
}
|
||
|
||
/// Map a display or Rust type name (e.g. `"HoleFeature"`, `"EdgeFlangeFeature"`)
|
||
/// to the canonical design-file variant key (`"hole"`, `"sheet_flange"`).
|
||
pub fn type_name_to_kind_key(name: &str) -> Option<&'static str> {
|
||
Some(match name {
|
||
"BodyTransferFeature" => "body_transfer",
|
||
"Sketch" => "sketch",
|
||
"ExtrudeFeature" => "extrude",
|
||
"RevolveFeature" => "revolve",
|
||
"FilletFeature" => "fillet",
|
||
"ChamferFeature" => "chamfer",
|
||
"BoxFeature" => "box",
|
||
"CylinderFeature" => "cylinder",
|
||
"SphereFeature" => "sphere",
|
||
"TorusFeature" => "torus",
|
||
"ConeFeature" => "cone",
|
||
"CombineFeature" => "combine",
|
||
"RectangularPatternFeature" | "PathPatternFeature" | "CircularPatternFeature" => "pattern",
|
||
"MirrorFeature" => "mirror",
|
||
"ConstructionPlane" => "construction_plane",
|
||
"HoleFeature" => "hole",
|
||
"ThreadFeature" => "thread",
|
||
"LoftFeature" => "loft",
|
||
"SweepFeature" => "sweep",
|
||
"ShellFeature" => "shell",
|
||
"DraftFeature" => "draft",
|
||
"SplitBodyFeature" => "split",
|
||
"SplitFaceFeature" => "split_face",
|
||
"ConstructionAxis" => "construction_axis",
|
||
"ConstructionPoint" => "construction_point",
|
||
"MoveFeature" => "move",
|
||
"ScaleFeature" => "scale",
|
||
"OffsetFacesFeature" => "offset_face",
|
||
"DeleteFaceFeature" => "delete_face",
|
||
"OffsetSurfaceFeature" => "surface_offset",
|
||
"BoundingSolidFeature" => "bounding_solid",
|
||
"PipeFeature" => "pipe",
|
||
"FrameMemberFeature" => "frame_member",
|
||
"EmbossFeature" => "emboss",
|
||
"BossFeature" => "boss",
|
||
"LipFeature" | "GrooveFeature" => "lip",
|
||
"SnapFitFeature" => "snap_fit",
|
||
"RestFeature" => "rest",
|
||
"BoundaryFillFeature" => "boundary_fill",
|
||
"BaseFlangeFeature" => "sheet_base",
|
||
"ContourFlangeFeature" => "sheet_contour",
|
||
"EdgeFlangeFeature" => "sheet_flange",
|
||
"HemFeature" => "sheet_hem",
|
||
"PerforateFeature" => "sheet_perforate",
|
||
"FoldFeature" => "sheet_fold",
|
||
"PathFlangeFeature" => "sheet_path",
|
||
"UnfoldFeature" | "RefoldFeature" => "sheet_unfold",
|
||
"ConvertToSheetMetalFeature" => "sheet_convert",
|
||
"CoilFeature" => "coil",
|
||
"RibFeature" | "WebFeature" => "rib",
|
||
"ReplaceFaceFeature" => "replace_face",
|
||
"AlignFeature" => "align",
|
||
"RemoveFeature" => "remove",
|
||
"PatchFeature" => "patch",
|
||
"SurfaceExtrudeFeature" => "surface_extrude",
|
||
"SurfaceRevolveFeature" => "surface_revolve",
|
||
"SurfaceSweepFeature" => "surface_sweep",
|
||
"SurfaceLoftFeature" => "surface_loft",
|
||
"BlendFeature" => "surface_blend",
|
||
"BoundaryFeature" => "surface_boundary",
|
||
"MatchFeature" => "surface_match",
|
||
"FairFeature" => "surface_fair",
|
||
"StitchFeature" => "stitch",
|
||
"ThickenFeature" => "thicken",
|
||
"TrimFeature" => "surface_trim",
|
||
"ExtendFeature" => "surface_extend",
|
||
"RuledSurfaceFeature" => "surface_ruled",
|
||
"UnstitchFeature" => "unstitch",
|
||
"ReverseNormalFeature" => "reverse_normal",
|
||
"UntrimFeature" => "surface_untrim",
|
||
"BaseFeature" => "import",
|
||
"MeshFeature" => "mesh_import",
|
||
"MeshConvertFeature" => "mesh_convert",
|
||
"RepairFeature" => "repair",
|
||
_ => return None,
|
||
})
|
||
}
|
||
/// Default name prefix (`Extrude` → `Extrude1`).
|
||
pub fn base_name(&self) -> &'static str {
|
||
match self {
|
||
FeatureKind::BodyTransfer { .. } => "BodyTransfer",
|
||
FeatureKind::Sketch { .. } => "Sketch",
|
||
FeatureKind::Extrude { .. } => "Extrude",
|
||
FeatureKind::Revolve { .. } => "Revolve",
|
||
FeatureKind::Fillet { .. } => "Fillet",
|
||
FeatureKind::Chamfer { .. } => "Chamfer",
|
||
FeatureKind::Box { .. } => "Box",
|
||
FeatureKind::Cylinder { .. } => "Cylinder",
|
||
FeatureKind::Sphere { .. } => "Sphere",
|
||
FeatureKind::Torus { .. } => "Torus",
|
||
FeatureKind::Cone { .. } => "Cone",
|
||
FeatureKind::Combine { .. } => "Combine",
|
||
FeatureKind::Pattern { pattern: PatternKind::Rectangular { .. }, .. } => "RectangularPattern",
|
||
FeatureKind::Pattern { pattern: PatternKind::Path { .. }, .. } => "PathPattern",
|
||
FeatureKind::Pattern { .. } => "CircularPattern",
|
||
FeatureKind::Mirror { .. } => "Mirror",
|
||
FeatureKind::ConstructionPlane { .. } => "Plane",
|
||
FeatureKind::Hole { .. } => "Hole",
|
||
FeatureKind::Thread { .. } => "Thread",
|
||
FeatureKind::Loft { .. } => "Loft",
|
||
FeatureKind::Sweep { .. } => "Sweep",
|
||
FeatureKind::Shell { .. } => "Shell",
|
||
FeatureKind::Draft { .. } => "Draft",
|
||
FeatureKind::Split { .. } => "Split",
|
||
FeatureKind::SplitFace { .. } => "SplitFace",
|
||
FeatureKind::ConstructionAxis { .. } => "Axis",
|
||
FeatureKind::ConstructionPoint { .. } => "Point",
|
||
FeatureKind::Move { .. } => "Move",
|
||
FeatureKind::Scale { .. } => "Scale",
|
||
FeatureKind::OffsetFace { .. } => "OffsetFace",
|
||
FeatureKind::DeleteFace { .. } => "DeleteFace",
|
||
FeatureKind::SurfaceOffset { .. } => "OffsetSurface",
|
||
FeatureKind::BoundingSolid { .. } => "BoundingSolid",
|
||
FeatureKind::Pipe { .. } => "Pipe",
|
||
FeatureKind::FrameMember { .. } => "Member",
|
||
FeatureKind::Emboss { .. } => "Emboss",
|
||
FeatureKind::Boss { .. } => "Boss",
|
||
FeatureKind::Lip { groove: false, .. } => "Lip",
|
||
FeatureKind::Lip { .. } => "Groove",
|
||
FeatureKind::SnapFit { .. } => "SnapFit",
|
||
FeatureKind::Rest { .. } => "Rest",
|
||
FeatureKind::BoundaryFill { .. } => "BoundaryFill",
|
||
FeatureKind::SheetBase { .. } => "BaseFlange",
|
||
FeatureKind::SheetContour { .. } => "ContourFlange",
|
||
FeatureKind::SheetFlange { .. } => "EdgeFlange",
|
||
FeatureKind::SheetHem { .. } => "Hem",
|
||
FeatureKind::SheetPerforate { .. } => "Perforate",
|
||
FeatureKind::SheetFold { .. } => "Fold",
|
||
FeatureKind::SheetPath { .. } => "PathFlange",
|
||
FeatureKind::SheetUnfold { refold: false, .. } => "Unfold",
|
||
FeatureKind::SheetUnfold { .. } => "Refold",
|
||
FeatureKind::SheetConvert { .. } => "ConvertToSheetMetal",
|
||
FeatureKind::Coil { .. } => "Coil",
|
||
FeatureKind::Rib { web: false, .. } => "Rib",
|
||
FeatureKind::Rib { .. } => "Web",
|
||
FeatureKind::ReplaceFace { .. } => "ReplaceFace",
|
||
FeatureKind::Align { .. } => "Align",
|
||
FeatureKind::Remove { .. } => "Remove",
|
||
FeatureKind::Patch { .. } => "Patch",
|
||
FeatureKind::SurfaceExtrude { .. } => "SurfaceExtrude",
|
||
FeatureKind::SurfaceRevolve { .. } => "SurfaceRevolve",
|
||
FeatureKind::SurfaceSweep { .. } => "SurfaceSweep",
|
||
FeatureKind::SurfaceLoft { .. } => "SurfaceLoft",
|
||
FeatureKind::SurfaceBlend { .. } => "Blend",
|
||
FeatureKind::SurfaceBoundary { .. } | FeatureKind::SurfaceNetwork { .. } => "Boundary",
|
||
FeatureKind::SurfaceMatch { .. } => "Match",
|
||
FeatureKind::SurfaceFair { .. } => "Fair",
|
||
FeatureKind::Stitch { .. } => "Stitch",
|
||
FeatureKind::Thicken { .. } => "Thicken",
|
||
FeatureKind::SurfaceTrim { .. } => "Trim",
|
||
FeatureKind::SurfaceExtend { .. } => "Extend",
|
||
FeatureKind::SurfaceRuled { .. } => "RuledSurface",
|
||
FeatureKind::Unstitch { .. } => "Unstitch",
|
||
FeatureKind::ReverseNormal { .. } => "ReverseNormal",
|
||
FeatureKind::SurfaceUntrim { .. } => "Untrim",
|
||
FeatureKind::Import { .. } => "Import",
|
||
FeatureKind::MeshImport { .. } => "Mesh",
|
||
FeatureKind::MeshConvert { .. } => "ConvertMesh",
|
||
FeatureKind::Repair { .. } => "Repair",
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct Feature {
|
||
pub id: u64,
|
||
pub name: String,
|
||
#[serde(default)]
|
||
pub suppressed: bool,
|
||
/// Names for the bodies this feature creates (in order); missing ones are numbered after the
|
||
/// first (`Ribs (4)`), or get `BodyN` when there is none (or see `shell_piece_order`).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub body_names: Vec<String>,
|
||
/// Parameter names of the feature's inputs (see `FeatureKind::inputs`), e.g. `d3`.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub param_names: Vec<String>,
|
||
/// The component the feature (and what it makes) belongs to; 0 = the root.
|
||
#[serde(default, skip_serializing_if = "is_root")]
|
||
pub component: u64,
|
||
/// For each picked edge (fillets, chamfers): where it sat in its body when picked, so it
|
||
/// is found again when earlier edits move or resize the body.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub edge_refs: Vec<crate::EdgeRef>,
|
||
/// Persistent names of the picked edges (resolved first; see `naming`).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub edge_names: Vec<String>,
|
||
/// Persistent names of the faces at the feature's face points (`FeatureKind::face_points`).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub face_names: Vec<String>,
|
||
/// Bodies a join/cut/intersect may change (any component); empty = the feature's own
|
||
/// component's bodies.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub participants: Vec<String>,
|
||
/// The pieces this feature splits a body into take its body names in the kernel's shell order,
|
||
/// as builds before format 14 named them, instead of after their faces (`lineage::order_lumps`).
|
||
/// Set on the features of designs saved before then, whose stored body names mean that order.
|
||
/// Such features also name the bodies past their `body_names` `BodyN`, as those builds did,
|
||
/// where newer ones number them after the first name (`Ribs (4)`, #373).
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
pub shell_piece_order: bool,
|
||
/// The pieces of a face this feature splits are numbered in the kernel's order and by the
|
||
/// index of the face they came from, as builds before #3902 numbered them, instead of by
|
||
/// place. Set on the features of designs saved before then, whose stored `#k` face names
|
||
/// mean that numbering.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
pub kernel_piece_order: bool,
|
||
/// Made by inserting a file (STEP, IGES or a mesh file) into the design: the feature built
|
||
/// the component tree its component is the top of, and deleting it removes that tree
|
||
/// ([`Document::remove_component_tree`]). Not set on other imported bodies, such as the
|
||
/// independent base of a copied component.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
pub inserted: bool,
|
||
/// The Import feature of a linked design (Insert Design): the names that design gave the
|
||
/// faces of its bodies (by body, then face, in the file's order; empty where not known), so
|
||
/// its faces are named after them and references follow them through Update Links (#3330).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub link_faces: Vec<Vec<String>>,
|
||
/// What a join of this feature makes of pieces that share no face: those that touch along an
|
||
/// edge or at a point become separate bodies and those that touch nothing stay one body (the
|
||
/// default), or every piece stays one body.
|
||
#[serde(default, skip_serializing_if = "Touching::is_separate")]
|
||
pub touching: Touching,
|
||
#[serde(flatten)]
|
||
pub kind: FeatureKind,
|
||
}
|
||
|
||
impl Feature {
|
||
/// Where in `body_names` the names of the first `count` bodies the feature builds are kept,
|
||
/// in the order it builds them. The same index for most features. An Import keeps its names
|
||
/// by the file's body index, and builds no body for the file bodies it skips, so its built
|
||
/// bodies pass their slots by (#2175).
|
||
pub fn body_name_slots(&self, count: usize) -> Vec<usize> {
|
||
let skip: std::collections::HashSet<u64> = match &self.kind {
|
||
FeatureKind::Import { skip, .. } => skip.iter().copied().collect(),
|
||
_ => Default::default(),
|
||
};
|
||
(0..count.saturating_add(skip.len())).filter(|k| !skip.contains(&(*k as u64))).take(count).collect()
|
||
}
|
||
|
||
/// Keep `made`, the names the feature's bodies have now (in the order it builds them), as
|
||
/// its stored names, so they stay as they are whatever comes and goes before it. An Import's
|
||
/// skipped file bodies keep the names stored for them.
|
||
pub fn pin_body_names(&mut self, made: &[String]) {
|
||
let slots = self.body_name_slots(made.len());
|
||
self.body_names.resize(slots.last().map_or(0, |s| s + 1), String::new());
|
||
for (slot, name) in slots.iter().zip(made) {
|
||
if let Some(stored) = self.body_names.get_mut(*slot) {
|
||
stored.clone_from(name);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn inside_str() -> String {
|
||
"inside".into()
|
||
}
|
||
|
||
pub(crate) fn all_profiles() -> ProfileSel {
|
||
ProfileSel::All
|
||
}
|
||
|
||
fn profiles_are_all(p: &ProfileSel) -> bool {
|
||
matches!(p, ProfileSel::All)
|
||
}
|
||
|
||
fn yes() -> bool {
|
||
true
|
||
}
|
||
|
||
fn is_yes(b: &bool) -> bool {
|
||
*b
|
||
}
|
||
|
||
fn zero_expr() -> Expr {
|
||
"0".into()
|
||
}
|
||
|
||
fn is_root(c: &u64) -> bool {
|
||
*c == 0
|
||
}
|
||
|
||
/// A standard part (fastener, pin, bearing) inserted as a component.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct StandardPart {
|
||
pub family: String,
|
||
pub size: String,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub length: Option<f64>,
|
||
}
|
||
|
||
/// A component whose contents come from another design file (Insert Design): where that file
|
||
/// is, and the Import feature in the component that holds its bodies (Update Links replaces
|
||
/// them; Break Link keeps them and forgets the file).
|
||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||
pub struct DesignLink {
|
||
/// The design file: relative to this design's folder once this design is saved, else as
|
||
/// given (`/` separates folders).
|
||
pub path: String,
|
||
/// The Import feature holding the linked design's bodies.
|
||
pub feature: u64,
|
||
/// Last inherited values, by Import body slot. Differing assembly assignments are
|
||
/// local overrides and survive a source update. Older links start with no baseline.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub inherited: Vec<LinkedBodyProperties>,
|
||
/// SHA-256 of the design file's bytes as this design last read them ([`Self::file_digest`]):
|
||
/// opened again, this design tells which linked files changed meanwhile (#9739). Links made
|
||
/// before it was kept have none and are taken as up to date.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub file_sha256: Option<String>,
|
||
}
|
||
|
||
impl DesignLink {
|
||
/// What [`Self::file_sha256`] keeps for a design file's `bytes`.
|
||
pub fn file_digest(bytes: &[u8]) -> String {
|
||
use sha2::{Digest, Sha256};
|
||
format!("{:x}", Sha256::digest(bytes))
|
||
}
|
||
}
|
||
|
||
/// The values last inherited by a linked body, not another editable material library.
|
||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||
pub struct LinkedBodyProperties {
|
||
pub material: String,
|
||
/// SHA-256 of the inherited custom definition, for equality only. The complete
|
||
/// engineering card stays in user_materials, not duplicated once per linked body.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub material_fingerprint: Option<String>,
|
||
/// Explicit body/component look only: material fallback must remain a fallback.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub appearance: Option<crate::appearance::Look>,
|
||
/// Last inherited authored face overrides. None marks links saved before face
|
||
/// inheritance; Some(empty) records that the source has no authored face overrides.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub faces: Option<Vec<crate::appearance::FaceLook>>,
|
||
}
|
||
|
||
impl LinkedBodyProperties {
|
||
pub fn fingerprint(material: &UserMaterial) -> Result<String> {
|
||
use sha2::{Digest, Sha256};
|
||
let bytes = serde_json::to_vec(material).map_err(|e| DocError::Invalid(e.to_string()))?;
|
||
Ok(format!("{:x}", Sha256::digest(bytes)))
|
||
}
|
||
}
|
||
|
||
/// A name the design's counter hands out (`Body1`).
|
||
pub fn is_counted_body_name(name: &str) -> bool {
|
||
name.strip_prefix("Body").is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit()) && n.parse::<usize>().is_ok())
|
||
}
|
||
|
||
/// The document.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct Document {
|
||
/// Named image intent and immutable embedded HDR sources. Active jobs and device state are not saved.
|
||
#[serde(default, skip_serializing_if = "crate::render_settings::RenderSettings::is_empty")]
|
||
pub render: std::sync::Arc<crate::render_settings::RenderSettings>,
|
||
#[serde(default = "default_format")]
|
||
pub format: String,
|
||
/// The changes of `format` this design has while they are pending (no release has fixed
|
||
/// that number yet; `crate::format::pending_names`). Empty, and not saved, otherwise.
|
||
#[serde(default = "crate::format::pending_names", skip_serializing_if = "Vec::is_empty")]
|
||
pub format_pending: Vec<String>,
|
||
pub name: String,
|
||
#[serde(default = "default_units")]
|
||
pub units: String,
|
||
/// Design properties (project, author…) and other tools' data, kept as they are (#1015).
|
||
#[serde(default, skip_serializing_if = "crate::Metadata::is_empty")]
|
||
pub metadata: crate::Metadata,
|
||
pub params: Vec<Param>,
|
||
/// Named texts the words of sketch texts can be built from ([`crate::text_params`]).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub text_params: Vec<crate::text_params::TextParam>,
|
||
pub features: Vec<Feature>,
|
||
/// Timeline marker: features at or after this index are rolled back (not evaluated).
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub marker: Option<usize>,
|
||
#[serde(default)]
|
||
pub next_id: u64,
|
||
/// Body names the design used and must not use again: a name a `body.rename` freed (#4957).
|
||
/// The design's own counter starts over at every evaluation, so without these a design that
|
||
/// is evaluated again after a rename hands the freed name to the next body, and a script
|
||
/// that names a body finds another one.
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeSet::is_empty")]
|
||
pub reserved_body_names: std::collections::BTreeSet<String>,
|
||
/// Components below the root, as a tree (by parent).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub components: Vec<Component>,
|
||
/// Next automatic colour sequence number; deletions never rewind it.
|
||
#[serde(default)]
|
||
pub next_component_color_index: u64,
|
||
/// Placements of components in their parents (each non-root component has at least one).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub occurrences: Vec<crate::Occurrence>,
|
||
/// Joints between occurrences, joint origins and motion links.
|
||
#[serde(default, skip_serializing_if = "crate::joints::Assembly::is_empty")]
|
||
pub assembly: crate::joints::Assembly,
|
||
/// Sheet metal rules.
|
||
#[serde(default, skip_serializing_if = "crate::sheet::SheetSettings::is_empty")]
|
||
pub sheet: crate::sheet::SheetSettings,
|
||
/// Plastic rules.
|
||
#[serde(default, skip_serializing_if = "crate::plastic::PlasticSettings::is_empty")]
|
||
pub plastic: crate::plastic::PlasticSettings,
|
||
/// Components that are standard parts (by component id): what to rebuild them from.
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub parts: std::collections::BTreeMap<u64, StandardPart>,
|
||
/// Components linked to another design file (by component id).
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub links: std::collections::BTreeMap<u64, DesignLink>,
|
||
/// Configurations (rows of parameter values and suppressions).
|
||
#[serde(default, skip_serializing_if = "crate::config::ConfigTable::is_empty")]
|
||
pub configs: crate::config::ConfigTable,
|
||
/// Favourite parameters (by name).
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeSet::is_empty")]
|
||
pub favorites: std::collections::BTreeSet<String>,
|
||
/// Reference images on planes (Insert Canvas).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub canvases: Vec<crate::canvas::Canvas>,
|
||
/// Scanned points kept as a reference (Insert Point Cloud).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub point_clouds: Vec<crate::point_cloud::PointCloud>,
|
||
/// Comments of feature-input parameters (by name).
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub param_comments: std::collections::BTreeMap<String, String>,
|
||
/// Physical material per body (by body name); others use the default.
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub materials: std::collections::BTreeMap<String, String>,
|
||
/// The flat face per body (by body name) that a slicer export lays on the print bed.
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub print_faces: std::collections::BTreeMap<String, crate::config::ConfigFaceTarget>,
|
||
/// Physical materials defined in this design (`material.create`), next to the built-in ones.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub user_materials: Vec<UserMaterial>,
|
||
/// Appearance colour per body (by body name, sRGB); it overrides the material's look.
|
||
#[serde(default, skip_serializing_if = "crate::appearance::Appearances::is_empty")]
|
||
pub appearances: crate::appearance::Appearances,
|
||
/// Bodies moved into another component than their feature's (by body name).
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub body_components: std::collections::BTreeMap<String, u64>,
|
||
/// Bodies moved into another component keep their place in the world: the transform from
|
||
/// the new component's frame to the frame the body was made in (by body name).
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub body_offsets: std::collections::BTreeMap<String, crate::Mat>,
|
||
/// Browser groups (folders of bodies, sketches or construction planes).
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub browser_groups: Vec<BrowserGroup>,
|
||
/// Named folders used to organise features in the timeline. They do not affect evaluation
|
||
/// order; feature ids remain the source of truth when features are renamed or reordered.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub timeline_groups: Vec<TimelineGroup>,
|
||
/// Browser order per component folder (`"<component>/<folder>"` → groups and item keys).
|
||
/// The `components` folder orders a component's sub-components (by placement id); it is not
|
||
/// drawn as a folder.
|
||
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
|
||
pub browser_order: std::collections::BTreeMap<String, Vec<BrowserEntry>>,
|
||
/// Named views: saved cameras.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub named_views: Vec<NamedView>,
|
||
/// What was hidden when the design was saved. A session takes it from here when the design
|
||
/// opens and keeps the live state itself (`browser.visibility`: saved, and undone like any
|
||
/// other change), so a document in a session leaves this empty; the session puts it back when
|
||
/// it saves.
|
||
#[serde(default, skip_serializing_if = "Visibility::is_empty")]
|
||
pub visibility: Visibility,
|
||
}
|
||
|
||
/// The browser's view of a design: items and folders hidden or shown, sketch profiles and
|
||
/// dimensions shown, bodies locked. Saved with the design and an undo step of its own.
|
||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||
#[serde(default)]
|
||
pub struct Visibility {
|
||
/// Bodies by name.
|
||
pub hidden_bodies: Vec<String>,
|
||
/// Exact occurrence placements hidden with all descendants.
|
||
pub hidden_occurrences: Vec<Vec<u64>>,
|
||
/// Origin items (O, X, Y, Z, XY, XZ, YZ) and construction geometry, by name.
|
||
pub hidden_origin: Vec<String>,
|
||
/// Sketches by feature id.
|
||
pub hidden_sketches: Vec<u64>,
|
||
/// Finished sketches shown although a feature uses them.
|
||
pub shown_sketches: Vec<u64>,
|
||
/// Assembly joints by id: their glyphs are not drawn (they still constrain and move).
|
||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||
pub hidden_joints: Vec<u64>,
|
||
/// The browser's Origin folder is hidden (`None`: the app's preference decides).
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub origin_hidden: Option<bool>,
|
||
/// Finished sketches whose closed profiles are not shaded, by feature id.
|
||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||
pub hidden_profiles: Vec<u64>,
|
||
/// Finished sketches whose dimensions are shown, by feature id.
|
||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||
pub shown_dimensions: Vec<u64>,
|
||
/// Bodies locked in the browser (no move or delete), by name.
|
||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||
pub locked_bodies: Vec<String>,
|
||
/// Browser folders and groups hidden themselves, by tree key: `<scope>/<folder>` or
|
||
/// `<scope>/g<group id>`, where the scope is `c0` (the design) or `o:<placement path>`
|
||
/// (`o:4/9/bodies`). Their items keep their own state: they are drawn again, as they were,
|
||
/// once the folder is shown.
|
||
#[serde(skip_serializing_if = "Vec::is_empty")]
|
||
pub hidden_folders: Vec<String>,
|
||
}
|
||
|
||
impl Visibility {
|
||
/// Nothing hidden or shown one by one (the default view).
|
||
pub fn is_empty(&self) -> bool {
|
||
self.hidden_bodies.is_empty()
|
||
&& self.hidden_occurrences.is_empty()
|
||
&& self.hidden_origin.is_empty()
|
||
&& self.hidden_sketches.is_empty()
|
||
&& self.shown_sketches.is_empty()
|
||
&& self.hidden_joints.is_empty()
|
||
&& self.origin_hidden.is_none()
|
||
&& self.hidden_profiles.is_empty()
|
||
&& self.shown_dimensions.is_empty()
|
||
&& self.locked_bodies.is_empty()
|
||
&& self.hidden_folders.is_empty()
|
||
}
|
||
}
|
||
|
||
/// A saved camera (orbit camera: target, yaw, pitch, distance; `fov` 0 for orthographic).
|
||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||
pub struct NamedView {
|
||
#[serde(default)]
|
||
pub name: String,
|
||
pub target: solidcore_record::Vec3,
|
||
pub yaw: f64,
|
||
pub pitch: f64,
|
||
pub distance: f64,
|
||
#[serde(default)]
|
||
pub fov: f64,
|
||
}
|
||
|
||
/// A browser group: items of one folder (`bodies`, `sketches` or `construction`) of a
|
||
/// component, by key (body name, or the feature id of a sketch or construction plane).
|
||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||
pub struct BrowserGroup {
|
||
pub id: u64,
|
||
pub name: String,
|
||
#[serde(default)]
|
||
pub component: u64,
|
||
pub folder: String,
|
||
/// The group that holds this one; `None` is the top level of its folder.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub parent: Option<u64>,
|
||
/// The group's items and child groups in display order. A child group missing here still
|
||
/// belongs to it (its `parent` says so) and is listed after the ones that are here.
|
||
#[serde(default)]
|
||
pub items: Vec<BrowserEntry>,
|
||
}
|
||
|
||
/// One line of a browser order list: a group (a number in a saved design) or an item (a string:
|
||
/// an item key or body name, so a body named `"1"` never clashes with group 1).
|
||
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
||
#[serde(untagged)]
|
||
pub enum BrowserEntry {
|
||
Group(u64),
|
||
Item(String),
|
||
}
|
||
|
||
impl From<&str> for BrowserEntry {
|
||
fn from(key: &str) -> Self {
|
||
BrowserEntry::Item(key.to_string())
|
||
}
|
||
}
|
||
|
||
impl From<String> for BrowserEntry {
|
||
fn from(key: String) -> Self {
|
||
BrowserEntry::Item(key)
|
||
}
|
||
}
|
||
|
||
impl BrowserEntry {
|
||
pub fn item(key: &str) -> Self {
|
||
BrowserEntry::Item(key.to_string())
|
||
}
|
||
|
||
pub fn as_item(&self) -> Option<&str> {
|
||
match self {
|
||
BrowserEntry::Item(k) => Some(k),
|
||
BrowserEntry::Group(_) => None,
|
||
}
|
||
}
|
||
|
||
pub fn is_item(&self, key: &str) -> bool {
|
||
self.as_item() == Some(key)
|
||
}
|
||
}
|
||
|
||
/// How many groups may sit inside one another (a top-level group is level 1).
|
||
pub const MAX_GROUP_NESTING: usize = 8;
|
||
|
||
/// The folders a browser group or order list can be for. `components` only orders sub-components.
|
||
pub const BROWSER_FOLDERS: [&str; 4] = ["bodies", "sketches", "construction", "components"];
|
||
|
||
impl BrowserGroup {
|
||
/// The keys of the items directly in this group, in order.
|
||
pub fn item_keys(&self) -> impl Iterator<Item = &str> {
|
||
self.items.iter().filter_map(BrowserEntry::as_item)
|
||
}
|
||
|
||
/// Whether this group holds the item directly.
|
||
pub fn has_item(&self, key: &str) -> bool {
|
||
self.items.iter().any(|e| e.is_item(key))
|
||
}
|
||
}
|
||
|
||
/// A saved history folder. Folders may nest; each feature or joint belongs to at most one folder.
|
||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||
pub struct TimelineGroup {
|
||
pub id: u64,
|
||
pub name: String,
|
||
/// The containing feature folder. `None` places the folder at the timeline root.
|
||
#[serde(default)]
|
||
pub parent: Option<u64>,
|
||
#[serde(default)]
|
||
pub features: Vec<u64>,
|
||
/// Joints stored in this timeline folder.
|
||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||
pub joints: Vec<u64>,
|
||
}
|
||
|
||
/// The first feature-history folder whose own and nested features do not form one
|
||
/// uninterrupted run in the timeline.
|
||
pub fn non_contiguous_timeline_group(features: &[Feature], groups: &[TimelineGroup]) -> Option<u64> {
|
||
let positions: std::collections::BTreeMap<u64, usize> = features.iter().enumerate().map(|(index, feature)| (feature.id, index)).collect();
|
||
let mut stats = std::collections::BTreeMap::new();
|
||
let mut children = std::collections::BTreeMap::new();
|
||
for group in groups {
|
||
let mut count = 0usize;
|
||
let mut first = usize::MAX;
|
||
let mut last = 0usize;
|
||
for index in group.features.iter().filter_map(|feature| positions.get(feature)) {
|
||
count = count.saturating_add(1);
|
||
first = first.min(*index);
|
||
last = last.max(*index);
|
||
}
|
||
stats.insert(group.id, (count, first, last));
|
||
children.entry(group.id).or_insert(0usize);
|
||
if let Some(parent) = group.parent {
|
||
let child_count = children.entry(parent).or_insert(0);
|
||
*child_count = child_count.saturating_add(1);
|
||
}
|
||
}
|
||
let parents: std::collections::BTreeMap<u64, Option<u64>> = groups.iter().map(|group| (group.id, group.parent)).collect();
|
||
let mut pending: Vec<u64> = groups.iter().filter(|group| children.get(&group.id) == Some(&0)).map(|group| group.id).collect();
|
||
while let Some(id) = pending.pop() {
|
||
let (count, first, last) = stats.get(&id).copied().unwrap_or_default();
|
||
if count > 0 && last.saturating_sub(first).saturating_add(1) != count {
|
||
return Some(id);
|
||
}
|
||
if let Some(parent) = parents.get(&id).copied().flatten() {
|
||
if let Some((parent_count, parent_first, parent_last)) = stats.get_mut(&parent) {
|
||
*parent_count = parent_count.saturating_add(count);
|
||
if count > 0 {
|
||
*parent_first = (*parent_first).min(first);
|
||
*parent_last = (*parent_last).max(last);
|
||
}
|
||
}
|
||
if let Some(remaining) = children.get_mut(&parent) {
|
||
*remaining = remaining.saturating_sub(1);
|
||
if *remaining == 0 {
|
||
pending.push(parent);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
fn default_format() -> String {
|
||
crate::format::format_string(crate::format::FORMAT)
|
||
}
|
||
fn default_units() -> String {
|
||
"mm".into()
|
||
}
|
||
|
||
impl Default for Document {
|
||
fn default() -> Self {
|
||
Document::new("Untitled")
|
||
}
|
||
}
|
||
|
||
impl Document {
|
||
/// The next shared identity, including auxiliary lists written by older versions or
|
||
/// populated programmatically. Reading it does not reserve an id (used by joint previews).
|
||
pub fn next_item_id(&self) -> Result<u64> {
|
||
let a = &self.assembly;
|
||
let largest = self
|
||
.browser_groups
|
||
.iter()
|
||
.map(|g| g.id)
|
||
.chain(self.timeline_groups.iter().map(|g| g.id))
|
||
.chain(self.canvases.iter().map(|c| c.id))
|
||
.chain(self.point_clouds.iter().map(|c| c.id))
|
||
.chain(a.joints.iter().map(|j| j.id))
|
||
.chain(a.contact_sets.iter().map(|c| c.id))
|
||
.chain(a.studies.iter().map(|s| s.id))
|
||
.chain(a.exploded.iter().map(|v| v.id))
|
||
.max()
|
||
.unwrap_or(0);
|
||
let floor = largest.checked_add(1).ok_or_else(|| DocError::Invalid("too many items in the design".into()))?;
|
||
Ok(self.next_id.max(floor).max(1))
|
||
}
|
||
|
||
/// Reserve an identity in the saved counter. Removing an item never rewinds this counter.
|
||
pub fn allocate_id(&mut self) -> Result<u64> {
|
||
let id = self.next_item_id()?;
|
||
self.next_id = id.checked_add(1).ok_or_else(|| DocError::Invalid("too many items in the design".into()))?;
|
||
Ok(id)
|
||
}
|
||
|
||
pub fn new(name: &str) -> Self {
|
||
Document {
|
||
render: Default::default(),
|
||
format: default_format(),
|
||
format_pending: crate::format::pending_names(),
|
||
name: name.into(),
|
||
units: default_units(),
|
||
metadata: Default::default(),
|
||
params: Vec::new(),
|
||
text_params: Vec::new(),
|
||
features: Vec::new(),
|
||
marker: None,
|
||
next_id: 1,
|
||
reserved_body_names: Default::default(),
|
||
components: Vec::new(),
|
||
next_component_color_index: 0,
|
||
occurrences: Vec::new(),
|
||
assembly: Default::default(),
|
||
sheet: Default::default(),
|
||
plastic: Default::default(),
|
||
configs: Default::default(),
|
||
parts: Default::default(),
|
||
links: Default::default(),
|
||
body_components: Default::default(),
|
||
body_offsets: Default::default(),
|
||
materials: Default::default(),
|
||
print_faces: Default::default(),
|
||
user_materials: Vec::new(),
|
||
appearances: Default::default(),
|
||
favorites: Default::default(),
|
||
canvases: Vec::new(),
|
||
point_clouds: Vec::new(),
|
||
param_comments: Default::default(),
|
||
browser_groups: Vec::new(),
|
||
timeline_groups: Vec::new(),
|
||
browser_order: Default::default(),
|
||
named_views: Vec::new(),
|
||
visibility: Visibility::default(),
|
||
}
|
||
}
|
||
|
||
/// Rename body `old` to `new` where the design keeps things by body name outside its
|
||
/// features: materials, print faces, appearances, plastic rules, configuration columns, offsets, components and the
|
||
/// browser's groups and order. (The features are the rename command's to change.)
|
||
///
|
||
/// A name the design numbered (`Body1`) is not used again after the rename: the design's
|
||
/// counter starts over at every evaluation, so without this a design that is evaluated
|
||
/// again hands the freed name to the next body (#4957). Every counted name is reserved as
|
||
/// soon as a body has it (`Session::pin_body_names`), so this only matters for a design
|
||
/// that has not been through a command since then. `new` may be a reserved name: a rename
|
||
/// is deliberate, and the body then has what the design keeps under it.
|
||
pub fn rename_body_keys(&mut self, old: &str, new: &str) {
|
||
if is_counted_body_name(old) {
|
||
self.reserved_body_names.insert(old.to_string());
|
||
}
|
||
if let Some(m) = self.materials.remove(old) {
|
||
self.materials.insert(new.to_string(), m);
|
||
}
|
||
if let Some(mut face) = self.print_faces.remove(old) {
|
||
face.body = new.to_string();
|
||
self.print_faces.insert(new.to_string(), face);
|
||
}
|
||
if let Some(rule) = self.plastic.assigned.remove(old) {
|
||
self.plastic.assigned.insert(new.to_string(), rule);
|
||
}
|
||
if let Some(c) = self.appearances.bodies.remove(old) {
|
||
self.appearances.bodies.insert(new.to_string(), c);
|
||
}
|
||
for f in self.appearances.faces.iter_mut().filter(|f| f.body == old) {
|
||
f.body = new.to_string();
|
||
}
|
||
for column in &mut self.configs.columns {
|
||
match column {
|
||
crate::config::Column::Material(body) | crate::config::Column::Appearance(body) if *body == old => {
|
||
*body = new.to_string();
|
||
}
|
||
crate::config::Column::FaceAppearance(target) if target.body == old => {
|
||
target.body = new.to_string();
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
if let Some(o) = self.body_offsets.remove(old) {
|
||
self.body_offsets.insert(new.to_string(), o);
|
||
}
|
||
if let Some(c) = self.body_components.remove(old) {
|
||
self.body_components.insert(new.to_string(), c);
|
||
}
|
||
let rename = |e: &mut BrowserEntry| {
|
||
if e.is_item(old) {
|
||
*e = BrowserEntry::item(new);
|
||
}
|
||
};
|
||
for g in self.browser_groups.iter_mut().filter(|g| g.folder == "bodies") {
|
||
g.items.iter_mut().for_each(rename);
|
||
}
|
||
for (_, v) in self.browser_order.iter_mut().filter(|(k, _)| k.ends_with("/bodies")) {
|
||
v.iter_mut().for_each(rename);
|
||
}
|
||
}
|
||
|
||
/// The single body rename (old name, new name) that turns `previous` into this design,
|
||
/// when that is all that changed: the features' stored body names (`made` gives the names
|
||
/// each feature's bodies have now, by feature id), typed body references, participants and
|
||
/// what [`Document::rename_body_keys`] renames. `None` for any other change.
|
||
pub fn body_rename_from(&self, previous: &Document, made: impl Fn(u64) -> Vec<String>) -> Option<(String, String)> {
|
||
if self.features.len() != previous.features.len() {
|
||
return None;
|
||
}
|
||
let mut rename: Option<(String, String)> = None;
|
||
for (a, b) in previous.features.iter().zip(&self.features) {
|
||
if a.id != b.id {
|
||
return None;
|
||
}
|
||
if a.body_names == b.body_names {
|
||
continue;
|
||
}
|
||
let now = made(a.id);
|
||
// The stored slot of each body built now (an Import's pass its skipped bodies by).
|
||
let at: std::collections::HashMap<usize, &String> = b.body_name_slots(now.len()).into_iter().zip(&now).collect();
|
||
for (k, name) in b.body_names.iter().enumerate() {
|
||
let current = at.get(&k).copied();
|
||
// Slots the rename left alone, and the ones it set to the names they have now.
|
||
if a.body_names.get(k) == Some(name) || name.trim().is_empty() || current == Some(name) {
|
||
continue;
|
||
}
|
||
let pair = (current?.clone(), name.clone());
|
||
match &rename {
|
||
Some(r) if *r != pair => return None,
|
||
_ => rename = Some(pair),
|
||
}
|
||
}
|
||
}
|
||
let (old, new) = rename?;
|
||
let mut expected = previous.clone();
|
||
let bodies = std::collections::BTreeMap::from([(old.clone(), new.clone())]);
|
||
for (f, g) in expected.features.iter_mut().zip(&self.features) {
|
||
f.body_names.clone_from(&g.body_names);
|
||
// Updating references to the renamed body changes no feature input other than its
|
||
// name (#6287). Keep the full comparison below: geometry, expressions, sketch links
|
||
// and face anchors must still agree before the model may reuse its geometry.
|
||
f.kind.remap_bodies(&bodies);
|
||
for body in f.participants.iter_mut().filter(|body| **body == old) {
|
||
body.clone_from(&new);
|
||
}
|
||
}
|
||
expected.rename_body_keys(&old, &new);
|
||
(expected == *self).then_some((old, new))
|
||
}
|
||
|
||
/// The feature whose name alone turns `previous` into this design, when that is all that
|
||
/// changed.
|
||
pub fn feature_rename_from(&self, previous: &Document) -> Option<u64> {
|
||
if self.features.len() != previous.features.len() {
|
||
return None;
|
||
}
|
||
let mut renamed = previous.features.iter().zip(&self.features).filter(|(a, b)| a.id == b.id && a.name != b.name);
|
||
let (_, b) = renamed.next()?;
|
||
if renamed.next().is_some() {
|
||
return None;
|
||
}
|
||
let mut expected = previous.clone();
|
||
expected.feature_mut(b.id)?.name.clone_from(&b.name);
|
||
(expected == *self).then_some(b.id)
|
||
}
|
||
|
||
/// A complete structural proof: no non-render field is allowed to differ. Keeping this
|
||
/// comparison based on the whole Document also includes fields added in future versions.
|
||
/// The clone/comparison is only needed when render intent actually differs.
|
||
pub fn differs_only_in_render(&self, previous: &Document) -> bool {
|
||
if std::sync::Arc::ptr_eq(&self.render, &previous.render) || self.render == previous.render || self.render.validate().is_err() {
|
||
return false;
|
||
}
|
||
let mut normalized = previous.clone();
|
||
normalized.render = self.render.clone();
|
||
*self == normalized
|
||
}
|
||
|
||
/// Only part properties changed (the fields `with_part_properties_of` names): nothing to
|
||
/// evaluate. The same whole-Document proof as [`Document::differs_only_in_render`].
|
||
pub fn differs_only_in_part_properties(&self, previous: &Document) -> bool {
|
||
previous.with_part_properties_of(self).is_some_and(|normalized| normalized == *self)
|
||
}
|
||
|
||
/// This design with `other`'s part properties, or `None` when they are this design's
|
||
/// already (then nothing is copied). The part properties are the fields that change no
|
||
/// geometry: the design's metadata, and each component's metadata and free properties. A
|
||
/// field that joins them is compared and copied here, and nowhere else.
|
||
fn with_part_properties_of(&self, other: &Document) -> Option<Document> {
|
||
let same = self.metadata == other.metadata
|
||
&& self.components.iter().zip(&other.components).all(|(c, o)| c.metadata == o.metadata && c.properties == o.properties);
|
||
if same {
|
||
return None;
|
||
}
|
||
let mut out = self.clone();
|
||
out.metadata.clone_from(&other.metadata);
|
||
// Paired by position: if the components themselves differ, so do the designs.
|
||
for (c, o) in out.components.iter_mut().zip(&other.components) {
|
||
c.metadata.clone_from(&o.metadata);
|
||
c.properties.clone_from(&o.properties);
|
||
}
|
||
Some(out)
|
||
}
|
||
|
||
/// Only appearances (body, face and component looks) changed: evaluation never reads them, so
|
||
/// the model and its placed world stay valid. The same whole-Document proof as
|
||
/// [`Document::differs_only_in_render`].
|
||
pub fn differs_only_in_appearance(&self, previous: &Document) -> bool {
|
||
if self.appearances == previous.appearances {
|
||
return false;
|
||
}
|
||
let mut normalized = previous.clone();
|
||
normalized.appearances = self.appearances.clone();
|
||
*self == normalized
|
||
}
|
||
|
||
/// The colour a body is shown and exported in (sRGB as 0–1 fractions): its appearance,
|
||
/// else its component's, else its material's look, else the colour it was imported with.
|
||
/// (Faces may have their own: `face_looks`.)
|
||
pub fn body_color(&self, b: &crate::ModelBody) -> Option<[f32; 3]> {
|
||
self.model_body_look(b).map(|l| l.rgb()).or_else(|| b.body.color()).or_else(|| b.imported.as_ref().and_then(|i| i.color))
|
||
}
|
||
|
||
/// The model with each body carrying the colour, opacity and face colours it is shown with
|
||
/// (for export).
|
||
pub fn painted(&self, state: &crate::ModelState) -> crate::ModelState {
|
||
self.painted_with_faces(state, true)
|
||
}
|
||
|
||
/// Linked designs carry authored face overrides as editable properties. Their STEP
|
||
/// geometry keeps imported paint, without baking a second copy of those overrides.
|
||
pub fn painted_for_link(&self, state: &crate::ModelState) -> crate::ModelState {
|
||
self.painted_with_faces(state, false)
|
||
}
|
||
|
||
fn painted_with_faces(&self, state: &crate::ModelState, authored_faces: bool) -> crate::ModelState {
|
||
let mut st = state.clone();
|
||
for b in &mut st.bodies {
|
||
let c = self.body_color(b);
|
||
let face_colors = if authored_faces { self.face_colors(b) } else { self.imported_face_colors(b) };
|
||
let faces: Vec<solidcraft_kernel::FacePaint> =
|
||
face_colors.into_iter().map(|(face, l)| solidcraft_kernel::FacePaint { face, color: l.rgb(), opacity: l.opacity as f32 }).collect();
|
||
let opacity = self.model_body_opacity(b) as f32;
|
||
let paint = solidcraft_kernel::Paint { opacity, faces };
|
||
if c != b.body.color() || b.body.paint() != Some(&paint) {
|
||
b.body = b.body.clone().with_color(c).with_paint(Some(paint));
|
||
}
|
||
}
|
||
st
|
||
}
|
||
|
||
/// The material a body's mass is computed with, as the library or this design spells it:
|
||
/// its assigned material when that is known and has a usable density, else
|
||
/// [`DEFAULT_MATERIAL`]. The assignment as stored (`materials`) is left as it is.
|
||
pub fn body_material(&self, body: &str) -> String {
|
||
self.materials
|
||
.get(body)
|
||
.and_then(|m| self.material_name(m))
|
||
.filter(|m| self.material_density(m).is_some())
|
||
.unwrap_or_else(|| DEFAULT_MATERIAL.into())
|
||
}
|
||
|
||
/// Density of a body's material (g/cm³): its [`Document::body_material`]'s, so the name a
|
||
/// body reads and the mass it has never disagree.
|
||
pub fn density(&self, body: &str) -> f64 {
|
||
self.material_density(&self.body_material(body)).unwrap_or(DEFAULT_DENSITY)
|
||
}
|
||
|
||
/// A material defined in this design, by name (case-insensitive).
|
||
pub fn user_material(&self, name: &str) -> Option<&UserMaterial> {
|
||
let name = name.trim();
|
||
self.user_materials.iter().find(|m| m.name.eq_ignore_ascii_case(name))
|
||
}
|
||
|
||
/// A physical material's name as the library or this design spells it (case-insensitive
|
||
/// lookup): built-in materials first, then the design's own.
|
||
pub fn material_name(&self, name: &str) -> Option<String> {
|
||
MATERIALS
|
||
.iter()
|
||
.find(|(n, _)| n.eq_ignore_ascii_case(name.trim()))
|
||
.map(|(n, _)| n.to_string())
|
||
.or_else(|| self.user_material(name).map(|m| m.name.clone()))
|
||
}
|
||
|
||
/// Density of a physical material (g/cm³): built-in or defined in this design. A design
|
||
/// material with an unusable density (a damaged file) has none.
|
||
pub fn material_density(&self, name: &str) -> Option<f64> {
|
||
material_density(name).or_else(|| self.user_material(name).map(|m| m.density).filter(|d| valid_density(*d)))
|
||
}
|
||
|
||
/// The look a physical material gives a body without an appearance of its own.
|
||
pub fn material_look(&self, name: &str) -> Option<crate::appearance::Look> {
|
||
crate::appearance::material_look(name).or_else(|| {
|
||
let mut look = self.user_material(name)?.appearance.clone()?;
|
||
// A damaged file's opacity is shown opaque rather than trusted.
|
||
if !(look.opacity.is_finite() && (0.0..=1.0).contains(&look.opacity)) {
|
||
look.opacity = 1.0;
|
||
}
|
||
Some(look)
|
||
})
|
||
}
|
||
|
||
/// Every physical material's name: the built-in library, then the design's own.
|
||
pub fn material_names(&self) -> Vec<String> {
|
||
MATERIALS.iter().map(|(n, _)| n.to_string()).chain(self.user_materials.iter().map(|m| m.name.clone())).collect()
|
||
}
|
||
|
||
/// The component a body belongs to: where it was moved, else its feature's.
|
||
pub fn body_component(&self, body: &str, feature: u64) -> u64 {
|
||
self.features
|
||
.iter()
|
||
.take(self.marker.unwrap_or(usize::MAX))
|
||
.rev()
|
||
.find_map(|f| {
|
||
if f.suppressed {
|
||
return None;
|
||
}
|
||
match &f.kind {
|
||
FeatureKind::BodyTransfer { bodies, to, .. } if bodies.iter().any(|b| b == body) => Some(*to),
|
||
_ => None,
|
||
}
|
||
})
|
||
.unwrap_or_else(|| self.legacy_body_component(body, feature))
|
||
}
|
||
|
||
pub fn legacy_body_component(&self, body: &str, feature: u64) -> u64 {
|
||
self.body_components.get(body).copied().unwrap_or_else(|| self.feature(feature).map(|f| f.component).unwrap_or(0))
|
||
}
|
||
|
||
/// Ownership in this evaluated timeline state, rather than a later transfer.
|
||
pub fn model_body_component(&self, body: &crate::ModelBody) -> u64 {
|
||
if body.transferred || body.source_name.is_some() { body.component } else { self.legacy_body_component(&body.name, body.feature) }
|
||
}
|
||
|
||
/// [`Document::model_body_component`] of every body of `state`, in its order, with the
|
||
/// timeline looked up once: placing a large assembly asked it of every body for every
|
||
/// placement, each time searching the features.
|
||
pub fn model_body_components(&self, state: &crate::ModelState) -> Vec<u64> {
|
||
let features: std::collections::HashMap<u64, u64> = self.features.iter().rev().map(|f| (f.id, f.component)).collect();
|
||
state
|
||
.bodies
|
||
.iter()
|
||
.map(|b| {
|
||
if b.transferred || b.source_name.is_some() {
|
||
b.component
|
||
} else {
|
||
self.body_components.get(&b.name).copied().unwrap_or_else(|| features.get(&b.feature).copied().unwrap_or(0))
|
||
}
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// The components that own a body in `state` ([`Document::model_body_component`] of each),
|
||
/// in one pass: the timeline is looked up once, not once per body.
|
||
pub fn body_owners(&self, state: &crate::ModelState) -> std::collections::HashSet<u64> {
|
||
let features: std::collections::HashMap<u64, u64> = self.features.iter().rev().map(|f| (f.id, f.component)).collect();
|
||
state
|
||
.bodies
|
||
.iter()
|
||
.map(|b| {
|
||
if b.transferred || b.source_name.is_some() {
|
||
b.component
|
||
} else {
|
||
self.body_components.get(&b.name).copied().unwrap_or_else(|| features.get(&b.feature).copied().unwrap_or(0))
|
||
}
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// Recorded transfers already converted geometry into the new local frame.
|
||
pub fn model_body_offset(&self, body: &crate::ModelBody) -> Option<&crate::Mat> {
|
||
if body.transferred { None } else { self.body_offsets.get(&body.name) }
|
||
}
|
||
|
||
/// Add a component under `parent` and return its id.
|
||
pub fn add_component(&mut self, name: Option<&str>, parent: u64) -> Result<u64> {
|
||
if parent != 0 && !self.components.iter().any(|c| c.id == parent) {
|
||
return Err(DocError::Unknown(format!("component {parent}")));
|
||
}
|
||
if self.components.len() >= 10_000 {
|
||
return Err(DocError::Invalid("too many components".into()));
|
||
}
|
||
self.normalise_component_color_indices()?;
|
||
let color_index = self.next_component_color_index;
|
||
let next_color_index = color_index.checked_add(1).ok_or_else(|| DocError::Invalid("component colour sequence exhausted".into()))?;
|
||
let id = self.next_id.max(1);
|
||
self.next_id = id.checked_add(1).ok_or_else(|| DocError::Invalid("too many items in the design".into()))?;
|
||
let name = match name.map(str::trim) {
|
||
Some(n) if !n.is_empty() => n.to_string(),
|
||
_ => {
|
||
let mut k = self.components.len() + 1;
|
||
while self.components.iter().any(|c| c.name == format!("Component{k}")) {
|
||
k += 1;
|
||
}
|
||
format!("Component{k}")
|
||
}
|
||
};
|
||
self.components.push(Component { id, name, parent, identification_color_index: Some(color_index), ..Default::default() });
|
||
self.next_component_color_index = next_color_index;
|
||
let occurrence = self.add_occurrence(id, parent, crate::IDENTITY)?;
|
||
// The design's first part is grounded, so joints and drags have something fixed to work
|
||
// from (#2804); later parts and copies start free. Only creation decides this: opening a
|
||
// design never grounds anything.
|
||
if parent == 0
|
||
&& !self.occurrences.iter().any(|o| o.parent == 0 && o.id != occurrence)
|
||
&& let Some(o) = self.occurrences.iter_mut().find(|o| o.id == occurrence)
|
||
{
|
||
o.grounded = true;
|
||
}
|
||
Ok(id)
|
||
}
|
||
|
||
/// A component by id or name (0 / "root" is the design itself). A component that carries the
|
||
/// design's own name is found by that name: the design is still named by 0 / "root".
|
||
pub fn find_component(&self, key: &str) -> Option<u64> {
|
||
if key == "0" || key.eq_ignore_ascii_case("root") {
|
||
return Some(0);
|
||
}
|
||
self.components.iter().find(|c| c.id.to_string() == key || c.name == key).map(|c| c.id).or_else(|| (key == self.name).then_some(0))
|
||
}
|
||
|
||
/// Read a design file's JSON (any format this build knows; older ones are upgraded).
|
||
pub fn from_json(s: &str) -> Result<Document> {
|
||
crate::render_resources::check_json_budget(s)?;
|
||
let mut d = crate::format::read(s)?;
|
||
if d.features.len() > MAX_FEATURES || d.params.len() > MAX_PARAMS {
|
||
return Err(DocError::Invalid("document too large".into()));
|
||
}
|
||
// A design from elsewhere may nest groups too deep, loop, or name things that are gone.
|
||
if let Some((groups, order)) = d.browser_pruned() {
|
||
(d.browser_groups, d.browser_order) = (groups, order);
|
||
}
|
||
Ok(d)
|
||
}
|
||
pub fn to_json(&self) -> String {
|
||
serde_json::to_string_pretty(self).unwrap_or_default()
|
||
}
|
||
|
||
pub fn feature(&self, id: u64) -> Option<&Feature> {
|
||
#[cfg(test)]
|
||
crate::eval::cost_tests::count_feature_search();
|
||
self.features.iter().find(|f| f.id == id)
|
||
}
|
||
pub fn feature_mut(&mut self, id: u64) -> Option<&mut Feature> {
|
||
self.features.iter_mut().find(|f| f.id == id)
|
||
}
|
||
pub fn feature_index(&self, id: u64) -> Option<usize> {
|
||
self.features.iter().position(|f| f.id == id)
|
||
}
|
||
/// Find a feature by id (number) or name.
|
||
pub fn find_feature(&self, r: &str) -> Option<&Feature> {
|
||
if let Ok(id) = r.parse::<u64>()
|
||
&& let Some(f) = self.feature(id)
|
||
{
|
||
return Some(f);
|
||
}
|
||
self.features.iter().find(|f| f.name.eq_ignore_ascii_case(r))
|
||
}
|
||
|
||
/// Resolve a textual timeline reference. An exact name wins even when it looks like an id.
|
||
/// Older scripts also pass ids as strings or use a different case for a unique name.
|
||
pub fn resolve_feature_name(&self, name: &str) -> Result<&Feature> {
|
||
if let Some(feature) = self.features.iter().find(|f| f.name == name) {
|
||
return Ok(feature);
|
||
}
|
||
if let Ok(id) = name.parse::<u64>()
|
||
&& let Some(feature) = self.feature(id)
|
||
{
|
||
return Ok(feature);
|
||
}
|
||
let mut matches = self.features.iter().filter(|f| f.name.eq_ignore_ascii_case(name));
|
||
let feature = matches.next().ok_or_else(|| DocError::Invalid(format!("no feature `{name}`")))?;
|
||
if matches.next().is_some() {
|
||
return Err(DocError::Invalid(format!("ambiguous feature `{name}`. Use its exact name or numeric id")));
|
||
}
|
||
Ok(feature)
|
||
}
|
||
|
||
/// The feature a pattern or mirror seed names, resolved the way `replay()` resolved seed
|
||
/// names before seeds were keyed by id (#1134): an exact name match on a feature that is
|
||
/// not a sketch or a construction plane wins — a sketch and its extrude often share a
|
||
/// name, and the feature that makes geometry is the one to copy. Other references use
|
||
/// the timeline lookup.
|
||
pub fn seed_feature(&self, name: &str) -> Option<&Feature> {
|
||
self.features
|
||
.iter()
|
||
.find(|x| x.name == name && !matches!(x.kind, FeatureKind::Sketch { .. } | FeatureKind::ConstructionPlane { .. }))
|
||
.or_else(|| self.resolve_feature_name(name).ok())
|
||
}
|
||
|
||
fn unique_name(&self, base: &str) -> String {
|
||
// The numbers taken after `base`, gathered once: the thousandth cylinder of a design
|
||
// tried Cylinder1, Cylinder2 … each against every feature's name.
|
||
let taken = crate::params::numbers_after(base, self.features.iter().map(|f| f.name.as_str()));
|
||
let n = (1..).find(|n| !taken.contains(n)).unwrap_or(1);
|
||
format!("{base}{n}")
|
||
}
|
||
|
||
/// The deepest timeline folder spanning the insertion slot between `marker - 1` and
|
||
/// `marker`. A slot at a folder's outer boundary is not inside that folder.
|
||
fn timeline_group_at_insertion(&self, marker: usize) -> Option<u64> {
|
||
let before = self.features.get(marker.checked_sub(1)?)?.id;
|
||
let after = self.features.get(marker)?.id;
|
||
let direct = |feature| self.timeline_groups.iter().find(|group| group.features.contains(&feature)).map(|group| group.id);
|
||
let parents: std::collections::BTreeMap<u64, Option<u64>> = self.timeline_groups.iter().map(|group| (group.id, group.parent)).collect();
|
||
|
||
let mut before_ancestors = std::collections::BTreeSet::new();
|
||
let mut current = direct(before);
|
||
let mut steps = 0usize;
|
||
while let Some(id) = current {
|
||
if !before_ancestors.insert(id) || steps >= self.timeline_groups.len() {
|
||
return None;
|
||
}
|
||
current = parents.get(&id).copied().flatten();
|
||
steps = steps.saturating_add(1);
|
||
}
|
||
|
||
current = direct(after);
|
||
steps = 0;
|
||
while let Some(id) = current {
|
||
if before_ancestors.contains(&id) {
|
||
return Some(id);
|
||
}
|
||
if steps >= self.timeline_groups.len() {
|
||
return None;
|
||
}
|
||
current = parents.get(&id).copied().flatten();
|
||
steps = steps.saturating_add(1);
|
||
}
|
||
None
|
||
}
|
||
|
||
/// Insert a feature at the marker (or the end) and return its id.
|
||
pub fn add_feature(&mut self, kind: FeatureKind, name: Option<&str>) -> Result<u64> {
|
||
if self.features.len() >= MAX_FEATURES {
|
||
return Err(DocError::Invalid("too many features".into()));
|
||
}
|
||
let component = if let FeatureKind::BodyTransfer { bodies, from, to, transform } = &kind {
|
||
crate::validate_body_transfer(self, &crate::plain(bodies), *from, *to, transform)?;
|
||
*to
|
||
} else {
|
||
0
|
||
};
|
||
let name = match name {
|
||
Some(n) if !n.trim().is_empty() => n.trim().to_string(),
|
||
_ => self.unique_name(kind.base_name()),
|
||
};
|
||
// Plane references share the feature namespace. A duplicate would silently select
|
||
// the first feature. Other shared names (a sketch and its extrude) remain supported.
|
||
let is_plane = matches!(kind, FeatureKind::ConstructionPlane { .. });
|
||
if self.features.iter().any(|f| f.name == name && (is_plane || matches!(f.kind, FeatureKind::ConstructionPlane { .. }))) {
|
||
return Err(DocError::Invalid(format!("another feature is called `{name}`")));
|
||
}
|
||
let id = self.next_id.max(1);
|
||
self.next_id = id.checked_add(1).ok_or_else(|| DocError::Invalid("too many items in the design".into()))?;
|
||
let f = Feature {
|
||
id,
|
||
name,
|
||
suppressed: false,
|
||
body_names: Vec::new(),
|
||
param_names: Vec::new(),
|
||
component,
|
||
edge_refs: Vec::new(),
|
||
edge_names: Vec::new(),
|
||
face_names: Vec::new(),
|
||
participants: Vec::new(),
|
||
shell_piece_order: false,
|
||
kernel_piece_order: false,
|
||
inserted: false,
|
||
link_faces: Vec::new(),
|
||
touching: Touching::Separate,
|
||
kind,
|
||
};
|
||
self.place_feature(f);
|
||
Ok(id)
|
||
}
|
||
|
||
/// Insert a feature as given, keeping its id, name, parameter names and stored edge and
|
||
/// face names, at the marker (or the end), with the model parameters its sketch dimensions
|
||
/// use: a feature replayed from a script (`timeline.add`) is the feature the design had.
|
||
/// An id of 0 or an empty name gets a new one. The name is kept even when another feature
|
||
/// has it, as a sketch and the feature built from it often share one (#1990). Refused,
|
||
/// changing nothing, when the id or a parameter name is already used, or the feature
|
||
/// belongs to a component this design does not have.
|
||
pub fn insert_feature(&mut self, mut f: Feature, params: Vec<Param>) -> Result<u64> {
|
||
if self.features.len() >= MAX_FEATURES {
|
||
return Err(DocError::Invalid("too many features".into()));
|
||
}
|
||
if f.id == 0 {
|
||
f.id = self.next_id.max(1);
|
||
} else if f.id > MAX_FEATURE_ID {
|
||
return Err(DocError::Invalid(format!("feature id {} is out of range", f.id)));
|
||
} else if self.feature(f.id).is_some() {
|
||
return Err(DocError::Invalid(format!("feature id {} is already used", f.id)));
|
||
}
|
||
f.name = f.name.trim().to_string();
|
||
if f.name.is_empty() {
|
||
f.name = self.unique_name(f.kind.base_name());
|
||
}
|
||
if f.component != 0 && !self.components.iter().any(|c| c.id == f.component) {
|
||
return Err(DocError::Invalid(format!("feature `{}` belongs to an unknown component", f.name)));
|
||
}
|
||
if let FeatureKind::BodyTransfer { bodies, from, to, transform } = &f.kind {
|
||
crate::validate_body_transfer(self, &crate::plain(bodies), *from, *to, transform)?;
|
||
if f.component != *to {
|
||
return Err(DocError::Invalid("a body transfer belongs to its destination component".into()));
|
||
}
|
||
}
|
||
let mut own = std::collections::BTreeSet::new();
|
||
for n in f.param_names.iter().filter(|n| !n.is_empty()) {
|
||
if let Some(why) = Self::param_name_problem(n) {
|
||
return Err(DocError::Invalid(why));
|
||
}
|
||
if self.name_taken(n) || !own.insert(n) {
|
||
return Err(DocError::Invalid(format!("parameter name `{n}` is already used")));
|
||
}
|
||
}
|
||
if self.params.len().saturating_add(params.len()) > MAX_PARAMS {
|
||
return Err(DocError::Invalid("too many parameters".into()));
|
||
}
|
||
for p in ¶ms {
|
||
if let Some(why) = Self::param_name_problem(&p.name) {
|
||
return Err(DocError::Invalid(why));
|
||
}
|
||
if self.name_taken(&p.name) || !own.insert(&p.name) {
|
||
return Err(DocError::Invalid(format!("parameter name `{}` is already used", p.name)));
|
||
}
|
||
if p.expr.len() > 4096 || p.comment.len() > 4096 {
|
||
return Err(DocError::Expr(format!("parameter `{}`: expression or comment too long", p.name)));
|
||
}
|
||
if !p.unit.is_empty() && expr::unit_info(&p.unit).is_none() {
|
||
return Err(DocError::Invalid(format!("parameter `{}`: unknown unit `{}`", p.name, p.unit)));
|
||
}
|
||
}
|
||
let id = f.id;
|
||
self.next_id = self.next_id.max(id.saturating_add(1));
|
||
self.params.extend(params.into_iter().map(|p| Param { model: true, ..p }));
|
||
self.place_feature(f);
|
||
Ok(id)
|
||
}
|
||
|
||
/// Put a feature at the marker (or the end), in the timeline folder that spans that slot,
|
||
/// and name its inputs.
|
||
fn place_feature(&mut self, f: Feature) {
|
||
let id = f.id;
|
||
let insertion_group = self.marker.and_then(|marker| self.timeline_group_at_insertion(marker));
|
||
match self.marker {
|
||
// A marker right after the last feature moves on past a feature added there, or the
|
||
// new feature would be added rolled back (#7741).
|
||
Some(marker) => {
|
||
let position = marker.min(self.features.len());
|
||
self.features.insert(position, f);
|
||
self.marker = Some(position + 1);
|
||
}
|
||
None => self.features.push(f),
|
||
}
|
||
if let Some(group_id) = insertion_group {
|
||
let positions: std::collections::BTreeMap<u64, usize> =
|
||
self.features.iter().enumerate().map(|(index, feature)| (feature.id, index)).collect();
|
||
if let Some(group) = self.timeline_groups.iter_mut().find(|group| group.id == group_id) {
|
||
group.features.push(id);
|
||
group.features.sort_by_key(|feature| positions.get(feature).copied().unwrap_or(usize::MAX));
|
||
}
|
||
}
|
||
self.name_feature_inputs(id);
|
||
}
|
||
|
||
/// Delete a feature (and, for a sketch, the features that use it). The feature of an inserted
|
||
/// file or a linked design takes the component tree it made with it: everything in that tree
|
||
/// and every assembly record that refers to it ([`Document::remove_component_tree`]). Other
|
||
/// imported bodies (a copied component's independent base) go alone.
|
||
pub fn delete_feature(&mut self, id: u64) -> Result<Vec<u64>> {
|
||
let owned = self.feature(id).filter(|f| self.feature_owns_component(f)).map(|f| f.component);
|
||
match owned {
|
||
Some(root) => Ok(self.remove_component_tree(root)?.deleted),
|
||
None => self.delete_features(&[id]),
|
||
}
|
||
}
|
||
|
||
/// Delete features `ids` and the features whose sketches they are. Returns every deleted id,
|
||
/// `ids` first.
|
||
pub(crate) fn delete_features(&mut self, ids: &[u64]) -> Result<Vec<u64>> {
|
||
let mut gone: Vec<u64> = Vec::with_capacity(ids.len());
|
||
for id in ids {
|
||
if self.feature_index(*id).is_none() {
|
||
return Err(DocError::Unknown(format!("feature {id}")));
|
||
}
|
||
if !gone.contains(id) {
|
||
gone.push(*id);
|
||
}
|
||
}
|
||
let dependants: Vec<u64> = self
|
||
.features
|
||
.iter()
|
||
.filter(|f| !gone.contains(&f.id) && f.kind.input_sketches().iter().any(|sketch| gone.contains(sketch)))
|
||
.map(|f| f.id)
|
||
.collect();
|
||
gone.extend(dependants);
|
||
// How many of them come before the rollback marker: it keeps its place among the rest.
|
||
let before_marker = self.marker.map(|m| self.features.iter().take(m).filter(|f| gone.contains(&f.id)).count());
|
||
let gone_params: Vec<String> = self.features.iter().filter(|f| gone.contains(&f.id)).flat_map(|f| f.param_names.clone()).collect();
|
||
self.configs
|
||
.rules
|
||
.retain(|rule| !rule.references_features(&gone) && !rule.parameter_references().iter().any(|name| gone_params.contains(name)));
|
||
self.features.retain(|f| !gone.contains(&f.id));
|
||
for group in &mut self.timeline_groups {
|
||
group.features.retain(|feature| !gone.contains(feature));
|
||
}
|
||
// Configuration columns of deleted features go with them.
|
||
let keep: Vec<bool> = self
|
||
.configs
|
||
.columns
|
||
.iter()
|
||
.map(|c| match c {
|
||
crate::config::Column::Suppress(id) => !gone.contains(id),
|
||
crate::config::Column::Param(name) => !gone_params.contains(name),
|
||
crate::config::Column::FaceAppearance(target) => !gone.contains(&target.origin_feature),
|
||
_ => true,
|
||
})
|
||
.collect();
|
||
self.appearances.faces.retain(|face| {
|
||
!face.strict_name || !face.name.as_ref().and_then(|name| crate::persistent_name::made_by(name)).is_some_and(|made| gone.contains(&made))
|
||
});
|
||
if keep.contains(&false) {
|
||
let mut k = keep.iter();
|
||
self.configs.columns.retain(|_| k.next().copied().unwrap_or(true));
|
||
for r in &mut self.configs.rows {
|
||
let mut k = keep.iter();
|
||
r.cells.retain(|_| k.next().copied().unwrap_or(true));
|
||
}
|
||
}
|
||
if let (Some(m), Some(n)) = (self.marker, before_marker) {
|
||
self.marker = Some(m.saturating_sub(n));
|
||
}
|
||
// Drop model parameters nobody references any more.
|
||
self.prune_model_params();
|
||
Ok(gone)
|
||
}
|
||
|
||
/// Remove model parameters not referenced by any dimension, feature or other parameter.
|
||
pub fn prune_model_params(&mut self) {
|
||
let used = self.referenced_names();
|
||
self.params.retain(|p| !p.model || used.contains(&p.name));
|
||
}
|
||
|
||
fn referenced_names(&self) -> Vec<String> {
|
||
let mut used: Vec<String> = Vec::new();
|
||
for rule in &self.configs.rules {
|
||
used.extend(rule.parameter_references());
|
||
}
|
||
for (index, column) in self.configs.columns.iter().enumerate() {
|
||
if let crate::config::Column::Param(name) = column {
|
||
used.push(name.clone());
|
||
for row in &self.configs.rows {
|
||
if let Some(value) = row.cells.get(index) {
|
||
used.extend(expr::references(value));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for f in &self.features {
|
||
for e in f.kind.expressions() {
|
||
used.extend(expr::references(e));
|
||
}
|
||
if let FeatureKind::Sketch { sketch, .. } = &f.kind {
|
||
used.extend(sketch.constraints.iter().filter_map(|c| c.param.clone()));
|
||
used.extend(sketch.text_exprs().into_iter().flat_map(|(_, e)| expr::references(e)));
|
||
}
|
||
}
|
||
for p in &self.params {
|
||
used.extend(expr::references(&p.expr));
|
||
}
|
||
used
|
||
}
|
||
|
||
pub fn param(&self, name: &str) -> Option<&Param> {
|
||
self.params.iter().find(|p| p.name == name)
|
||
}
|
||
|
||
/// Why a name cannot be a parameter name (None = fine).
|
||
pub fn param_name_problem(name: &str) -> Option<String> {
|
||
let mut cs = name.chars();
|
||
if !matches!(cs.next(), Some(c) if c.is_alphabetic() || c == '_') || !cs.all(|c| c.is_alphanumeric() || c == '_') {
|
||
return Some(format!("`{name}` is not a valid parameter name (letters, digits and _, starting with a letter)"));
|
||
}
|
||
if name.len() > 64 {
|
||
return Some("parameter names are at most 64 characters".into());
|
||
}
|
||
match expr::reserved_kind(name) {
|
||
Some("constant") => Some(format!("`{name}` is a constant, so it cannot be a parameter name")),
|
||
Some(kind) => Some(format!("`{name}` is a {kind} name, so it cannot be a parameter name")),
|
||
None => None,
|
||
}
|
||
}
|
||
|
||
/// Add or change a parameter. Fails if the result would not evaluate. A new parameter
|
||
/// without a unit takes the unit of its value (a length in the design's units, deg or none).
|
||
pub fn set_param(&mut self, name: &str, expr_s: &str, unit: Option<&str>, comment: Option<&str>) -> Result<()> {
|
||
// A text parameter: one with the text unit, or an existing one when no unit is given.
|
||
match (unit.map(crate::text_params::is_text_unit), self.text_param(name).is_some()) {
|
||
(Some(true), _) | (None, true) => return self.set_text_param(name, expr_s, comment),
|
||
(Some(false), true) => return Err(DocError::Invalid(format!("`{name}` is a text parameter"))),
|
||
_ => {}
|
||
}
|
||
if let Some(p) = Self::param_name_problem(name) {
|
||
return Err(DocError::Invalid(p));
|
||
}
|
||
if expr_s.len() > 4096 {
|
||
return Err(DocError::Expr("expression too long".into()));
|
||
}
|
||
if expr_s.trim().is_empty() {
|
||
return Err(DocError::Expr("empty expression".into()));
|
||
}
|
||
if let Some(u) = unit
|
||
&& expr::unit_info(u).is_none()
|
||
{
|
||
return Err(DocError::Expr(format!("unknown unit `{u}` (mm, cm, m, in, ft, deg, rad or none)")));
|
||
}
|
||
if comment.is_some_and(|c| c.len() > 4096) {
|
||
return Err(DocError::Invalid("comment too long".into()));
|
||
}
|
||
if self.features.iter().any(|f| f.param_names.iter().any(|n| n == name)) {
|
||
return Err(DocError::Invalid(format!("`{name}` is a feature's parameter")));
|
||
}
|
||
let mut next = self.clone();
|
||
let inferred = match unit {
|
||
Some(u) => u.trim().to_string(),
|
||
None => next.infer_unit(expr_s),
|
||
};
|
||
match next.params.iter_mut().find(|p| p.name == name) {
|
||
Some(p) => {
|
||
p.expr = expr_s.trim().to_string();
|
||
if let Some(u) = unit {
|
||
p.unit = u.trim().to_string();
|
||
}
|
||
if let Some(c) = comment {
|
||
p.comment = c.to_string();
|
||
}
|
||
}
|
||
None => {
|
||
if next.params.len() >= MAX_PARAMS {
|
||
return Err(DocError::Invalid("too many parameters".into()));
|
||
}
|
||
next.params.push(Param {
|
||
name: name.into(),
|
||
expr: expr_s.trim().into(),
|
||
unit: inferred,
|
||
comment: comment.unwrap_or_default().into(),
|
||
model: false,
|
||
})
|
||
}
|
||
}
|
||
let (_, errors) = next.param_values();
|
||
if let Some(e) = errors.get(name) {
|
||
return Err(DocError::Expr(e.clone()));
|
||
}
|
||
*self = next;
|
||
Ok(())
|
||
}
|
||
|
||
/// Create the next free model parameter `dN` with the given expression and unit.
|
||
pub fn new_model_param(&mut self, expr_s: &str, unit: &str) -> String {
|
||
let name = self.next_d_name();
|
||
self.params.push(Param { name: name.clone(), expr: expr_s.into(), unit: unit.into(), comment: String::new(), model: true });
|
||
name
|
||
}
|
||
|
||
/// Evaluate an expression against the document's parameters.
|
||
pub fn eval(&self, e: &str, kind: Kind) -> Result<f64> {
|
||
// The parameters are evaluated only when the expression names one: most expressions an
|
||
// agent sends are plain values, and evaluating every parameter of a large design for
|
||
// each of them made every new feature cost more than the last.
|
||
let vals: std::cell::OnceCell<std::collections::BTreeMap<String, expr::Value>> = std::cell::OnceCell::new();
|
||
expr::eval_with(e, &|n| {
|
||
vals.get_or_init(|| self.param_values().0).get(n).copied().ok_or_else(|| DocError::Expr(format!("unknown parameter `{n}`")))
|
||
})?
|
||
.to_kind(kind)
|
||
}
|
||
|
||
pub fn eval_in(vals: &std::collections::BTreeMap<String, expr::Value>, e: &str, kind: Kind) -> Result<f64> {
|
||
expr::eval_with(e, &|n| vals.get(n).copied().ok_or_else(|| DocError::Expr(format!("unknown parameter `{n}`"))))?.to_kind(kind)
|
||
}
|
||
|
||
/// Resolve a plane reference.
|
||
pub fn resolve_plane(&self, vals: &std::collections::BTreeMap<String, expr::Value>, p: &PlaneRef, depth: usize) -> Result<Plane> {
|
||
self.resolve_plane_in(vals, p, depth, None)
|
||
}
|
||
|
||
/// Resolve a plane; planes built from model geometry (edges, faces, construction axes and
|
||
/// points) need the model state `st`, and construction planes are read from it when given.
|
||
pub fn resolve_plane_in(
|
||
&self,
|
||
vals: &std::collections::BTreeMap<String, expr::Value>,
|
||
p: &PlaneRef,
|
||
depth: usize,
|
||
st: Option<&crate::ModelState>,
|
||
) -> Result<Plane> {
|
||
if depth > 32 {
|
||
return Err(DocError::Invalid("plane offsets nested too deeply".into()));
|
||
}
|
||
match p {
|
||
PlaneRef::Origin { name } => Plane::named(name).ok_or_else(|| DocError::Unknown(format!("plane `{name}`"))),
|
||
PlaneRef::Custom { plane } | PlaneRef::Face { plane, .. } => {
|
||
Plane::new(plane.origin, plane.x, plane.y).ok_or_else(|| DocError::Invalid("degenerate plane".into()))
|
||
}
|
||
PlaneRef::Placed { origin, x_dir, y_dir } => {
|
||
let [x, y, z] = origin;
|
||
let o =
|
||
Vec3::new(Self::eval_in(vals, x, Kind::Length)?, Self::eval_in(vals, y, Kind::Length)?, Self::eval_in(vals, z, Kind::Length)?);
|
||
if ![o.x, o.y, o.z].iter().all(|c| c.is_finite() && c.abs() < 1e9) {
|
||
return Err(DocError::Invalid("the plane's origin is out of range".into()));
|
||
}
|
||
Plane::new(o, *x_dir, *y_dir).ok_or_else(|| DocError::Invalid("degenerate plane".into()))
|
||
}
|
||
PlaneRef::Offset { base, distance } => {
|
||
let b = self.resolve_plane_in(vals, base, depth + 1, st)?;
|
||
Ok(b.offset(Self::eval_in(vals, distance, Kind::Length)?))
|
||
}
|
||
PlaneRef::AtAngle { base, axis_origin, axis_dir, angle, line } => {
|
||
let b = self.resolve_plane_in(vals, base, depth + 1, st)?;
|
||
let a = Self::eval_in(vals, angle, Kind::Angle)?;
|
||
let (axis_origin, axis_dir) = match line {
|
||
Some(g) => {
|
||
let st = st.ok_or_else(|| DocError::Invalid("this plane is built from the model: evaluate first".into()))?;
|
||
crate::construct::model_axis(st, g)?
|
||
}
|
||
None => (*axis_origin, *axis_dir),
|
||
};
|
||
let d = axis_dir.normalized().ok_or_else(|| DocError::Invalid("rotation axis".into()))?;
|
||
let rot = |v: Vec3| v * a.cos() + d.cross(v) * a.sin() + d * (d.dot(v) * (1.0 - a.cos()));
|
||
let o = axis_origin + rot(b.origin - axis_origin);
|
||
Plane::new(o, rot(b.x), rot(b.y)).ok_or_else(|| DocError::Invalid("degenerate plane".into()))
|
||
}
|
||
PlaneRef::Flipped { base, about_y } => Ok(self.resolve_plane_in(vals, base, depth + 1, st)?.flipped(*about_y)),
|
||
PlaneRef::Construction { feature } => {
|
||
// Evaluated already: as it came out.
|
||
if let Some(c) = st.and_then(|st| st.construct.iter().find(|c| c.feature == feature.0))
|
||
&& let crate::construct::ConstructGeom::Plane(pl) = &c.geom
|
||
{
|
||
return Ok(*pl);
|
||
}
|
||
match self.feature(feature.0).map(|f| &f.kind) {
|
||
Some(FeatureKind::ConstructionPlane { plane }) => self.resolve_plane_in(vals, plane, depth + 1, st),
|
||
// A name that could not be resolved when an older design opened keeps id 0,
|
||
// which no feature has (#1134): the reference dangles, as it always did.
|
||
_ => {
|
||
let shown = self.feature(feature.0).map(|f| f.name.clone()).unwrap_or_else(|| feature.to_string());
|
||
Err(DocError::Unknown(format!("construction plane `{shown}`")))
|
||
}
|
||
}
|
||
}
|
||
PlaneRef::Midplane { .. }
|
||
| PlaneRef::TwoEdges { .. }
|
||
| PlaneRef::AxisPoint { .. }
|
||
| PlaneRef::ThreePoints { .. }
|
||
| PlaneRef::Tangent { .. }
|
||
| PlaneRef::AlongPath { .. }
|
||
| PlaneRef::Perpendicular { .. }
|
||
| PlaneRef::ThroughPoint { .. } => {
|
||
let st = st.ok_or_else(|| DocError::Invalid("this plane is built from the model: evaluate first".into()))?;
|
||
crate::construct::resolve_geo_plane(&crate::construct::Ctx { doc: self, vals, st, depth }, p)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Mutable access to a sketch feature's sketch.
|
||
pub fn sketch_mut(&mut self, id: u64) -> Result<&mut Sketch> {
|
||
match self.feature_mut(id).map(|f| &mut f.kind) {
|
||
Some(FeatureKind::Sketch { sketch, .. }) => Ok(sketch),
|
||
Some(_) => Err(DocError::Invalid(format!("feature {id} is not a sketch"))),
|
||
None => Err(DocError::Unknown(format!("sketch {id}"))),
|
||
}
|
||
}
|
||
pub fn sketch(&self, id: u64) -> Result<&Sketch> {
|
||
match self.feature(id).map(|f| &f.kind) {
|
||
Some(FeatureKind::Sketch { sketch, .. }) => Ok(sketch),
|
||
Some(_) => Err(DocError::Invalid(format!("feature {id} is not a sketch"))),
|
||
None => Err(DocError::Unknown(format!("sketch {id}"))),
|
||
}
|
||
}
|
||
|
||
/// Apply parameter values to every dimension in a sketch, to its points placed by parameters
|
||
/// and to its equation curves (in place).
|
||
pub fn apply_dimension_values(&self, vals: &std::collections::BTreeMap<String, expr::Value>, sk: &mut Sketch) -> Result<()> {
|
||
self.apply_point_values(vals, sk)?;
|
||
self.apply_equation_values(vals, sk)?;
|
||
self.apply_pattern_values(vals, sk)?;
|
||
for c in &mut sk.constraints {
|
||
if let Some(p) = &c.param {
|
||
let kind = if c.kind.is_angle() { Kind::Angle } else { Kind::Length };
|
||
let v = vals.get(p).copied().ok_or_else(|| DocError::Unknown(format!("parameter `{p}`")))?.to_kind(kind)?;
|
||
c.kind.set_value(v);
|
||
}
|
||
}
|
||
for c in &sk.constraints {
|
||
sk.validate(&c.kind)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Resolve circular Quantity expressions before solving. Rebuilding the copies here also
|
||
/// covers cold document evaluation and configuration changes, without an engine dependency.
|
||
pub fn apply_pattern_quantities(&self, vals: &std::collections::BTreeMap<String, expr::Value>, sk: &mut Sketch) -> Result<()> {
|
||
let counts: Vec<_> = sk
|
||
.patterns
|
||
.iter()
|
||
.filter_map(|p| p.count_expression.as_ref().map(|e| (p.id.clone(), e)))
|
||
.map(|(id, e)| {
|
||
let n = crate::eval::val(vals, e, Kind::Unitless)?;
|
||
Ok((id, solidcraft_sketch::SketchPattern::circular_quantity(n)?))
|
||
})
|
||
.collect::<Result<_>>()?;
|
||
for (id, count) in counts {
|
||
sk.resize_circular_pattern(&id, count)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Evaluate the retained pattern inputs before solving its associative relations.
|
||
pub fn apply_pattern_values(&self, vals: &std::collections::BTreeMap<String, expr::Value>, sk: &mut Sketch) -> Result<()> {
|
||
use solidcraft_sketch::SketchPatternKind;
|
||
self.apply_pattern_quantities(vals, sk)?;
|
||
for index in 0..sk.patterns.len() {
|
||
let Some(pattern) = sk.patterns.get(index) else { continue };
|
||
let mut kind = pattern.kind.clone();
|
||
for (key, expression) in &pattern.expressions {
|
||
let unit = match key.as_str() {
|
||
"count" | "count2" => Kind::Unitless,
|
||
"spacing" | "spacing2" => Kind::Length,
|
||
"angle" => Kind::Angle,
|
||
_ => return Err(DocError::Invalid(format!("unknown sketch pattern input `{key}`"))),
|
||
};
|
||
let value = crate::eval::val(vals, expression, unit).map_err(|e| DocError::Expr(format!("pattern {} `{key}`: {e}", pattern.id)))?;
|
||
let count = || -> Result<usize> {
|
||
if !(1.0..=500.0).contains(&value) || value.fract() != 0.0 {
|
||
return Err(DocError::Invalid(format!("pattern `{key}` must be a positive integer from 1 to 500")));
|
||
}
|
||
Ok(value as usize)
|
||
};
|
||
match (&mut kind, key.as_str()) {
|
||
(SketchPatternKind::Circular { count: n, .. } | SketchPatternKind::Rectangular { count: n, .. }, "count") => *n = count()?,
|
||
(SketchPatternKind::Rectangular { count2, .. }, "count2") => *count2 = count()?,
|
||
(SketchPatternKind::Rectangular { spacing, .. }, "spacing") => *spacing = value,
|
||
(SketchPatternKind::Rectangular { spacing2, .. }, "spacing2") => *spacing2 = value,
|
||
(SketchPatternKind::Circular { angle, .. }, "angle") => *angle = value.to_degrees(),
|
||
_ => return Err(DocError::Invalid(format!("invalid sketch pattern input `{key}`"))),
|
||
}
|
||
}
|
||
if kind != pattern.kind {
|
||
sk.update_pattern(index, kind)?;
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Move the points placed by parameters to where their expressions come to (in place). Such
|
||
/// a point is fixed, so the solve keeps it there.
|
||
pub fn apply_point_values(&self, vals: &std::collections::BTreeMap<String, expr::Value>, sk: &mut Sketch) -> Result<()> {
|
||
use crate::eval::val;
|
||
for p in &mut sk.points {
|
||
let Some(exprs) = p.exprs.as_deref() else { continue };
|
||
let mut at = p.pos;
|
||
for (e, slot, what) in [(&exprs.x, &mut at.x, "X"), (&exprs.y, &mut at.y, "Y")] {
|
||
if let Some(e) = e {
|
||
*slot = val(vals, e, Kind::Length).map_err(|error| DocError::Expr(format!("point {} {what}: {error}", p.id)))?;
|
||
}
|
||
}
|
||
if !(at.is_finite() && at.x.abs() < solidcraft_sketch::MAX_COORD && at.y.abs() < solidcraft_sketch::MAX_COORD) {
|
||
return Err(DocError::Invalid(format!("point {} is placed out of range", p.id)));
|
||
}
|
||
p.pos = at;
|
||
p.fixed = true;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Give the texts of a sketch the numbers and words their expressions come to (in place): a
|
||
/// text's height, place and angle that were typed as expressions, and its words built from
|
||
/// text parameters. A text's outlines are rebuilt from them when the sketch's links are
|
||
/// refreshed, so this comes before that. What was typed as such is left as it is.
|
||
pub fn apply_text_values(&self, vals: &std::collections::BTreeMap<String, expr::Value>, sk: &mut Sketch) -> Result<()> {
|
||
use crate::eval::val;
|
||
for link in &mut sk.links {
|
||
let solidcraft_sketch::LinkSource::Text { text, at, height, angle, exprs, .. } = &mut link.source else { continue };
|
||
let number = |e: &Option<String>, kind: Kind, what: &str| -> Result<Option<f64>> {
|
||
match e {
|
||
None => Ok(None),
|
||
Some(e) => val(vals, e, kind).map(Some).map_err(|error| DocError::Expr(format!("{what}: {error}"))),
|
||
}
|
||
};
|
||
if let Some(v) = number(&exprs.x, Kind::Length, "text X")? {
|
||
at.x = v;
|
||
}
|
||
if let Some(v) = number(&exprs.y, Kind::Length, "text Y")? {
|
||
at.y = v;
|
||
}
|
||
if let Some(v) = number(&exprs.height, Kind::Length, "text height")? {
|
||
*height = v;
|
||
}
|
||
if let Some(v) = number(&exprs.angle, Kind::Angle, "text angle")? {
|
||
*angle = v;
|
||
}
|
||
if exprs.height.is_some() && !(*height > 1e-6 && *height < 1e5) {
|
||
return Err(DocError::Invalid("a text's height must be positive".into()));
|
||
}
|
||
if let Some(e) = &exprs.text {
|
||
let words = self.eval_words(e, vals).map_err(|error| DocError::Expr(format!("text: {error}")))?;
|
||
if words.trim().is_empty() || words.chars().count() > solidcraft_sketch::MAX_TEXT_CHARS {
|
||
return Err(DocError::Invalid(format!("text: `{e}` gives no words, or too many")));
|
||
}
|
||
*text = words;
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Apply parameter values to a sketch's dimensions and solve it. `stored` are the values
|
||
/// its geometry is solved for (the stored sketch's): what the solve cannot reach in one
|
||
/// jump it reaches by stepping the changed values from there, and an edit that would turn
|
||
/// the sketch over is refused. Offsets whose sources moved are refreshed and solved again:
|
||
/// from the stored state again after a refused or failed first solve (the geometry is still
|
||
/// the stored one), from the solved one otherwise.
|
||
///
|
||
/// `moved_from`: the stored sketch, when `sk` is that sketch with its links refreshed. A
|
||
/// link's points are where their source is now; the sides and turns the solve keeps are
|
||
/// those of the stored state ([`Sketch::positions_in`]), not the ones read beside a line
|
||
/// that has moved past a point. Where the links moved so far that the solve fails or turns
|
||
/// part of the sketch over, they are walked there in steps
|
||
/// ([`solidcraft_sketch::solve_after_link_move`]).
|
||
pub fn solve_sketch(
|
||
&self,
|
||
vals: &std::collections::BTreeMap<String, expr::Value>,
|
||
sk: &mut Sketch,
|
||
stored: &solidcraft_sketch::DrivingValues,
|
||
moved_from: Option<&Sketch>,
|
||
) -> Result<solidcraft_sketch::SolveReport> {
|
||
self.solve_sketch_with_analysis(vals, sk, stored, moved_from, solidcraft_sketch::Analysis::Full)
|
||
}
|
||
|
||
/// [`Self::solve_sketch`] with the diagnostics needed by an internal edit. Parameter
|
||
/// application, continuation and offset refreshes run regardless of the requested level.
|
||
/// Model evaluation uses `solve_sketch` so its published report always has full diagnostics.
|
||
pub fn solve_sketch_with_analysis(
|
||
&self,
|
||
vals: &std::collections::BTreeMap<String, expr::Value>,
|
||
sk: &mut Sketch,
|
||
stored: &solidcraft_sketch::DrivingValues,
|
||
moved_from: Option<&Sketch>,
|
||
analysis: solidcraft_sketch::Analysis,
|
||
) -> Result<solidcraft_sketch::SolveReport> {
|
||
self.apply_dimension_values(vals, sk)?;
|
||
// A text built anew since it was stored (an expression gave it other words) has other
|
||
// outline entities: the stored sketch is taken with this sketch's, so the points still
|
||
// pair up for the side checks and the walk below.
|
||
let paired = moved_from.and_then(|from| sk.stored_with_rebuilt_texts(from));
|
||
let moved_from = paired.as_ref().or(moved_from);
|
||
let was = |sk: &Sketch| moved_from.and_then(|from| sk.positions_in(from));
|
||
let offsets = !sk.offsets.is_empty() || !sk.freeform_offsets.is_empty();
|
||
// Offsets always require another solve after refresh. Only that last report is
|
||
// published; the first report only decides which state the second solve starts from.
|
||
let first_analysis = if offsets { solidcraft_sketch::Analysis::StatusOnly } else { analysis };
|
||
// A linked or fixed point is not where the stored sketch has it.
|
||
let given_moved = moved_from
|
||
.is_some_and(|from| sk.points.iter().zip(&from.points).any(|(p, q)| (p.fixed || p.link.is_some()) && p.id == q.id && p.pos != q.pos));
|
||
let mut report = solidcraft_sketch::solve_after_edit_with_analysis(sk, stored, was(sk).as_deref(), first_analysis);
|
||
// Links that moved far (a large change of a size upstream): when the jump fails, or
|
||
// lands on the mirror image of a side or turn the stored sketch has, walked there in
|
||
// steps; a turn the walk cannot avoid either is reported as one.
|
||
if let Some(from) = moved_from.filter(|_| given_moved) {
|
||
let flips = if report.ok() { solidcraft_sketch::flips_from_stored(sk, from) } else { Vec::new() };
|
||
if !report.keeps_orientation() || !flips.is_empty() {
|
||
match solidcraft_sketch::solve_after_link_move(sk, from, stored, first_analysis) {
|
||
Some(walked) => report = walked,
|
||
None => {
|
||
for id in flips {
|
||
if !report.failing.contains(&id) {
|
||
report.failing.push(id.clone());
|
||
}
|
||
if !report.folded.contains(&id) {
|
||
report.folded.push(id);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if offsets {
|
||
// Source dimensions may have moved curves during the solve.
|
||
sk.refresh_offsets()?;
|
||
report = if report.ok() {
|
||
solidcraft_sketch::solve_with(sk, &solidcraft_sketch::Hold::default(), None, analysis, None)
|
||
} else {
|
||
solidcraft_sketch::solve_after_edit_with_analysis(sk, stored, was(sk).as_deref(), analysis)
|
||
};
|
||
// An attachment to the old offset can prevent the source from moving at all.
|
||
// Retry from a source-only seed, adopting it only if every constraint still holds.
|
||
if !report.ok()
|
||
&& report.oversized.is_none()
|
||
&& let Some(retried) = sk.solve_after_offset_edit(stored, was(sk).as_deref(), analysis)
|
||
{
|
||
report = retried;
|
||
}
|
||
}
|
||
Ok(report)
|
||
}
|
||
}
|
||
|
||
/// The built-in material library: (name, density), and each material's colour.
|
||
#[path = "../../../assets/materials/library.rs"]
|
||
mod materials;
|
||
pub use materials::{DEFAULT_DENSITY, DEFAULT_MATERIAL, MATERIALS, material_color};
|
||
|
||
/// A physical material defined in a design (`material.create`): its name, its density and,
|
||
/// optionally, the look it gives bodies without an appearance of their own.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct UserMaterial {
|
||
pub name: String,
|
||
/// Density (g/cm³).
|
||
pub density: f64,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub appearance: Option<crate::appearance::Look>,
|
||
/// Candidate engineering data; independent of assigned mass density and optics.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub physical_card: Option<crate::physical_material::ValidatedCard>,
|
||
}
|
||
|
||
/// Bound design-owned definitions consistently in commands and normal file loading.
|
||
pub const MAX_USER_MATERIALS: usize = 1000;
|
||
|
||
/// Largest density a material may have (g/cm³); the densest elements are about 22.6.
|
||
pub const MAX_DENSITY: f64 = 1000.0;
|
||
|
||
/// A density a material can have: finite, above zero and at most [`MAX_DENSITY`] g/cm³.
|
||
pub fn valid_density(d: f64) -> bool {
|
||
d.is_finite() && d > 0.0 && d <= MAX_DENSITY
|
||
}
|
||
|
||
/// Density of a built-in physical material (g/cm³).
|
||
pub fn material_density(name: &str) -> Option<f64> {
|
||
MATERIALS.iter().find(|(n, _)| n.eq_ignore_ascii_case(name.trim())).map(|(_, d)| *d)
|
||
}
|