SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Standard parts library (parts.library, parts.insert, parts.resize): ISO 4762 socket head cap screws, ISO 4014/4017 hex bolts, ISO 4032 nuts, ISO 7089 washers, ISO 4026 set screws, ISO 8734 dowel pins and 6000/6200/600-series bearing envelopes, M3–M20, built in code from the standards' dimensions as their own components with cosmetic threads; inserted at a hole's rim they get a rigid joint that puts them on the hole's axis seated on its face; resize rebuilds in place. Circle joint origins are named after the cylindrical wall
bherbruckf7c26d8dfecf
diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex f7e581b119..5884930d5a 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -1065,6 +1065,15 @@ 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>,+}+/// The document.#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub struct Document {@@ -1095,6 +1104,9 @@ pub struct Document {/// 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>,/// Configurations (rows of parameter values and suppressions).#[serde(default, skip_serializing_if = "crate::config::ConfigTable::is_empty")]pub configs: crate::config::ConfigTable,@@ -1182,6 +1194,7 @@ impl Document {sheet: Default::default(),plastic: Default::default(),configs: Default::default(),+ parts: Default::default(),body_components: Default::default(),materials: Default::default(),appearances: Default::default(),diff --git a/crates/engine/src/cmd/joints.rs b/crates/engine/src/cmd/joints.rsindex 34c3542737..722f231945 100644--- a/crates/engine/src/cmd/joints.rs+++ b/crates/engine/src/cmd/joints.rs@@ -81,7 +81,7 @@ pub(crate) fn occurrence_id(s: &Session, v: Option<&Value>, cmd: &str) -> Result}/// The occurrence whose bodies are nearest a world point (0 = root bodies).-fn occurrence_at(s: &Session, p: Vec3) -> Option<u64> {+pub(crate) fn occurrence_at(s: &Session, p: Vec3) -> Option<u64> {let st = s.model.state();let mut best: Option<(f64, u64)> = None;for b in &st.bodies {@@ -133,7 +133,13 @@ fn origin_param(s: &Session, v: Option<&Value>, cmd: &str) -> Result<JointOriginlet snap = match what {"face" | "circle" => {let pick = local(world);- let face = solvecraft_doc::naming::face_names_at(&s.model.state(), &[pick]).into_iter().next().filter(|n| !n.is_empty());+ // A circle's name is its cylindrical wall's (a rim pick also touches the end face).+ let named_at = if what == "circle" {+ s.model.state().bodies.iter().filter_map(|b| cylinder_wall_point(&b.body, pick)).next().unwrap_or(pick)+ } else {+ pick+ };+ let face = solvecraft_doc::naming::face_names_at(&s.model.state(), &[named_at]).into_iter().next().filter(|n| !n.is_empty());if what == "face" { Snap::FaceCenter { pick, face } } else { Snap::CircleCenter { pick, face } }}"point" => Snap::Point { point: local(world), z: v.get("z").and_then(vec3).map(local_dir) },@@ -551,3 +557,12 @@ fn interference(s: &mut Session, p: &Value) -> Result<Value> {#[cfg(test)]#[path = "joints_tests.rs"]mod tests;++/// A point in the middle of the cylindrical face at `pick` (on its wall, halfway along).+fn cylinder_wall_point(b: &solvecraft_doc::kernel::Body, pick: Vec3) -> Option<Vec3> {+ let c = solvecraft_doc::kernel::cylinder_face_at(b, pick)?;+ let v = pick - c.axis_point;+ let along = v.dot(c.axis);+ let radial = (v - c.axis * along).normalized()?;+ Some(c.axis_point + c.axis * ((c.start + c.end) / 2.0) + radial * c.radius)+}diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rsindex ed35314942..fc7339c22e 100644--- a/crates/engine/src/cmd/mod.rs+++ b/crates/engine/src/cmd/mod.rs@@ -17,6 +17,7 @@ mod inspect;pub(crate) mod joints;mod measure_sel;pub(crate) mod motion;+mod parts;mod section;pub(crate) use measure_sel::measure_items;mod parameters;@@ -146,6 +147,7 @@ pub fn command_specs() -> Vec<&'static CommandSpec> {v.extend(joints::COMMANDS.iter());v.extend(motion::COMMANDS.iter());v.extend(config::COMMANDS.iter());+ v.extend(parts::COMMANDS.iter());v.extend(browser::COMMANDS.iter());v.extend(delete::COMMANDS.iter());v.extend(edit::COMMANDS.iter());diff --git a/crates/engine/src/cmd/parts.rs b/crates/engine/src/cmd/parts.rsnew file mode 100644index 0000000000..1e366544f3--- /dev/null+++ b/crates/engine/src/cmd/parts.rs@@ -0,0 +1,515 @@+//! Standard parts: ISO metric fasteners, dowel pins and ball bearings, generated in code from+//! the dimensions in the public standards tables (no vendor geometry). Each part is inserted as+//! its own component, built by ordinary features (so it stays parametric and editable), with a+//! cosmetic thread where it has one; at a hole it gets a rigid joint that puts its axis on the+//! hole's and seats it on the face.+//!+//! Part frame: the seating plane is z = 0 (the underside of a head, the bottom of a nut or+//! washer, the top of a set screw or pin); the shank runs down −z.++use serde_json::{Value, json};+use solvecraft_geom::Vec3;++use super::CommandSpec;+use crate::params::{bad, num, str_, vec3};+use crate::{EngineError, Result, Session};++pub static COMMANDS: &[CommandSpec] = &[+ CommandSpec::new("parts.library", "Standard Parts", library)+ .noundo()+ .params("family? → families (name, standard, sizes, lengths) and, with family, each size's dimensions (mm)"),+ CommandSpec::new("parts.insert", "Insert Part", insert).at("SOLID", "INSERT").icon("import").params(+ "family (socket_head_cap_screw | hex_bolt | hex_nut | washer | set_screw | dowel_pin | bearing); size (\"M6\", or \"608\" for bearings); \+ length? (mm; screws, bolts, set screws, pins; default a standard length near 2.5 d); \+ at?: [x,y,z] on a hole's rim or wall (the part seats on the hole's face with a rigid joint) | point?: [x,y,z] with direction?: [x,y,z] (no joint); name?",+ ),+ CommandSpec::new("parts.resize", "Change Part Size", resize)+ .params("component: id|name of an inserted part; size?; length? — rebuilds it (joints keep it seated)"),+];++/// A family: (id, name, standard).+const FAMILIES: [(&str, &str, &str); 7] = [+ ("socket_head_cap_screw", "Socket head cap screw", "ISO 4762"),+ ("hex_bolt", "Hex head bolt / screw", "ISO 4014 / ISO 4017"),+ ("hex_nut", "Hex nut", "ISO 4032"),+ ("washer", "Plain washer", "ISO 7089"),+ ("set_screw", "Hex socket set screw, flat point", "ISO 4026"),+ ("dowel_pin", "Parallel pin (dowel)", "ISO 8734"),+ ("bearing", "Deep groove ball bearing (envelope)", "ISO 15 (6000/6200/600 series)"),+];++/// ISO metric coarse: (size, d, pitch).+const METRIC: [(&str, f64, f64); 9] = [+ ("M3", 3.0, 0.5),+ ("M4", 4.0, 0.7),+ ("M5", 5.0, 0.8),+ ("M6", 6.0, 1.0),+ ("M8", 8.0, 1.25),+ ("M10", 10.0, 1.5),+ ("M12", 12.0, 1.75),+ ("M16", 16.0, 2.0),+ ("M20", 20.0, 2.5),+];++/// ISO 4762: (size, head diameter dk, head height k, socket s, socket depth t).+const SHCS: [(&str, f64, f64, f64, f64); 9] = [+ ("M3", 5.5, 3.0, 2.5, 1.3),+ ("M4", 7.0, 4.0, 3.0, 2.0),+ ("M5", 8.5, 5.0, 4.0, 2.5),+ ("M6", 10.0, 6.0, 5.0, 3.0),+ ("M8", 13.0, 8.0, 6.0, 4.0),+ ("M10", 16.0, 10.0, 8.0, 5.0),+ ("M12", 18.0, 12.0, 10.0, 6.0),+ ("M16", 24.0, 16.0, 14.0, 8.0),+ ("M20", 30.0, 20.0, 17.0, 10.0),+];++/// ISO 4014/4017 hex head: (size, across flats s, head height k).+const HEX_BOLT: [(&str, f64, f64); 9] = [+ ("M3", 5.5, 2.0),+ ("M4", 7.0, 2.8),+ ("M5", 8.0, 3.5),+ ("M6", 10.0, 4.0),+ ("M8", 13.0, 5.3),+ ("M10", 16.0, 6.4),+ ("M12", 18.0, 7.5),+ ("M16", 24.0, 10.0),+ ("M20", 30.0, 12.5),+];++/// ISO 4032: (size, across flats s, height m).+const HEX_NUT: [(&str, f64, f64); 9] = [+ ("M3", 5.5, 2.4),+ ("M4", 7.0, 3.2),+ ("M5", 8.0, 4.7),+ ("M6", 10.0, 5.2),+ ("M8", 13.0, 6.8),+ ("M10", 16.0, 8.4),+ ("M12", 18.0, 10.8),+ ("M16", 24.0, 14.8),+ ("M20", 30.0, 18.0),+];++/// ISO 7089: (size, inner d1, outer d2, thickness h).+const WASHER: [(&str, f64, f64, f64); 9] = [+ ("M3", 3.2, 7.0, 0.5),+ ("M4", 4.3, 9.0, 0.8),+ ("M5", 5.3, 10.0, 1.0),+ ("M6", 6.4, 12.0, 1.6),+ ("M8", 8.4, 16.0, 1.6),+ ("M10", 10.5, 20.0, 2.0),+ ("M12", 13.0, 24.0, 2.5),+ ("M16", 17.0, 30.0, 3.0),+ ("M20", 21.0, 37.0, 3.0),+];++/// ISO 4026: (size, socket s, socket depth t).+const SET_SCREW: [(&str, f64, f64); 7] =+ [("M3", 1.5, 1.2), ("M4", 2.0, 1.5), ("M5", 2.5, 2.0), ("M6", 3.0, 2.0), ("M8", 4.0, 3.0), ("M10", 5.0, 4.0), ("M12", 6.0, 4.8)];++/// ISO 8734 diameters.+const DOWEL: [f64; 9] = [2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 16.0];++/// Bearings: (designation, bore, outside diameter, width).+const BEARINGS: [(&str, f64, f64, f64); 13] = [+ ("625", 5.0, 16.0, 5.0),+ ("626", 6.0, 19.0, 6.0),+ ("608", 8.0, 22.0, 7.0),+ ("6000", 10.0, 26.0, 8.0),+ ("6001", 12.0, 28.0, 8.0),+ ("6002", 15.0, 32.0, 9.0),+ ("6003", 17.0, 35.0, 10.0),+ ("6004", 20.0, 42.0, 12.0),+ ("6200", 10.0, 30.0, 9.0),+ ("6201", 12.0, 32.0, 10.0),+ ("6202", 15.0, 35.0, 11.0),+ ("6203", 17.0, 40.0, 12.0),+ ("6204", 20.0, 47.0, 14.0),+];++/// Standard lengths for screws, bolts and pins (mm).+const LENGTHS: [f64; 22] =+ [4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 16.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 80.0, 90.0, 100.0, 120.0];++fn metric(size: &str) -> Option<(f64, f64)> {+ METRIC.iter().find(|(s, _, _)| s.eq_ignore_ascii_case(size)).map(|(_, d, p)| (*d, *p))+}++fn default_length(d: f64) -> f64 {+ LENGTHS.iter().copied().find(|l| *l >= 2.5 * d).unwrap_or(100.0)+}++/// One part's shape, in its own frame.+#[derive(Clone, Debug, PartialEq)]+enum Shape {+ /// A head (round or hex), a shank down −z, an optional hex socket in the head's top.+ Screw { d: f64, pitch: f64, len: f64, head: Head, socket: Option<(f64, f64)> },+ /// A hex prism with a through hole (nut), z 0…m.+ Nut { d: f64, pitch: f64, s: f64, m: f64 },+ /// A ring (washer, bearing envelope), z 0…h.+ Ring { d_in: f64, d_out: f64, h: f64 },+ /// A cylinder down −z with a socket in its top (set screw), or plain (pin).+ Rod { d: f64, pitch: Option<f64>, len: f64, socket: Option<(f64, f64)> },+}++#[derive(Clone, Copy, Debug, PartialEq)]+enum Head {+ Round { dk: f64, k: f64 },+ Hex { s: f64, k: f64 },+}++fn shape(family: &str, size: &str, length: Option<f64>) -> std::result::Result<Shape, String> {+ let need = |what: &str| format!("no {what} size `{size}` (parts.library lists them)");+ let len = |d: f64| length.unwrap_or_else(|| default_length(d));+ Ok(match family {+ "socket_head_cap_screw" => {+ let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?;+ let (_, dk, k, s, t) = SHCS.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4762"))?;+ Shape::Screw { d, pitch, len: len(d), head: Head::Round { dk, k }, socket: Some((s, t)) }+ }+ "hex_bolt" => {+ let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?;+ let (_, s, k) = HEX_BOLT.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4014"))?;+ Shape::Screw { d, pitch, len: len(d), head: Head::Hex { s, k }, socket: None }+ }+ "hex_nut" => {+ let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?;+ let (_, s, m) = HEX_NUT.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4032"))?;+ Shape::Nut { d, pitch, s, m }+ }+ "washer" => {+ let (_, d1, d2, h) = WASHER.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 7089"))?;+ Shape::Ring { d_in: d1, d_out: d2, h }+ }+ "set_screw" => {+ let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?;+ let (_, s, t) = SET_SCREW.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4026"))?;+ Shape::Rod {+ d,+ pitch: Some(pitch),+ len: length.unwrap_or_else(|| LENGTHS.iter().copied().find(|l| *l >= d).unwrap_or(d)),+ socket: Some((s, t)),+ }+ }+ "dowel_pin" => {+ let d: f64 = size.trim_start_matches(['d', 'D', 'Ø']).trim().parse().map_err(|_| need("dowel pin"))?;+ if !DOWEL.contains(&d) {+ return Err(need("ISO 8734"));+ }+ Shape::Rod { d, pitch: None, len: len(d * 1.6), socket: None }+ }+ "bearing" => {+ let (_, bore, od, w) = BEARINGS.iter().find(|r| r.0 == size.trim()).copied().ok_or_else(|| need("bearing"))?;+ Shape::Ring { d_in: bore, d_out: od, h: w }+ }+ o => return Err(format!("unknown part family `{o}` (parts.library lists them)")),+ })+}++fn run(s: &mut Session, id: &str, p: Value) -> Result<Value> {+ s.execute(id, &p)+}++/// A hex prism (across flats `af`) from z0 to z1, joined or cut.+fn hex(s: &mut Session, af: f64, z0: f64, z1: f64, op: &str) -> Result<()> {+ run(s, "SketchCreate", json!({"plane": "XY", "offset": z0}))?;+ run(s, "ShapePolygonCircumscribed", json!({"center": [0, 0], "radius": af / 2.0, "sides": 6}))?;+ run(s, "SketchStop", json!({}))?;+ let (dist, dir) = if z1 >= z0 { (z1 - z0, "positive") } else { (z0 - z1, "negative") };+ run(s, "Extrude", json!({"distance": dist, "direction": dir, "operation": op}))?;+ Ok(())+}++fn cyl(s: &mut Session, d: f64, z0: f64, z1: f64, op: &str) -> Result<()> {+ run(s, "PrimitiveCylinder", json!({"diameter": d, "height": z1 - z0, "base": [0, 0, z0], "axis": [0, 0, 1], "operation": op}))?;+ Ok(())+}++/// A solid of revolution about z from a closed (r, z) outline, as one body or joined.+fn revolve(s: &mut Session, pts: &[(f64, f64)], op: &str) -> Result<()> {+ run(s, "SketchCreate", json!({"plane": "XZ"}))?;+ let points: Vec<[f64; 2]> = pts.iter().map(|(r, z)| [*r, *z]).collect();+ run(s, "DrawPolyline", json!({"points": points, "closed": true}))?;+ run(s, "SketchStop", json!({}))?;+ run(s, "Revolve", json!({"axis": "y", "operation": op}))?;+ Ok(())+}++fn thread(s: &mut Session, d: f64, pitch: f64, at: Vec3) {+ let _ = run(s, "FusionThreadCommand", json!({"face": at, "designation": format!("M{}x{}", d, pitch)}));+ let _ = d;+}++/// Build a part in the active component.+fn build(s: &mut Session, sh: &Shape) -> Result<()> {+ match *sh {+ Shape::Screw { d, pitch, len, head, socket } => {+ let k = match head {+ // One revolved outline: shank and round head.+ Head::Round { dk, k } => {+ revolve(s, &[(0.0, -len), (d / 2.0, -len), (d / 2.0, 0.0), (dk / 2.0, 0.0), (dk / 2.0, k), (0.0, k)], "new")?;+ k+ }+ // A hex head joined over a shank that runs up into it.+ Head::Hex { s: af, k } => {+ hex(s, af, 0.0, k, "new")?;+ revolve(s, &[(0.0, -len), (d / 2.0, -len), (d / 2.0, k / 2.0), (0.0, k / 2.0)], "join")?;+ k+ }+ };+ if let Some((af, t)) = socket {+ hex(s, af, k, k - t, "cut")?;+ }+ thread(s, d, pitch, Vec3::new(d / 2.0, 0.0, -len / 2.0));+ }+ Shape::Nut { d, pitch, s: af, m } => {+ hex(s, af, 0.0, m, "new")?;+ cyl(s, d, -1.0, m + 1.0, "cut")?;+ thread(s, d, pitch, Vec3::new(d / 2.0, 0.0, m / 2.0));+ }+ Shape::Ring { d_in, d_out, h } => {+ revolve(s, &[(d_in / 2.0, 0.0), (d_out / 2.0, 0.0), (d_out / 2.0, h), (d_in / 2.0, h)], "new")?;+ }+ Shape::Rod { d, pitch, len, socket } => {+ revolve(s, &[(0.0, -len), (d / 2.0, -len), (d / 2.0, 0.0), (0.0, 0.0)], "new")?;+ if let Some((af, t)) = socket {+ hex(s, af, 0.0, -t, "cut")?;+ }+ if let Some(p) = pitch {+ thread(s, d, p, Vec3::new(d / 2.0, 0.0, -len / 2.0));+ }+ }+ }+ Ok(())+}++fn library(_s: &mut Session, p: &Value) -> Result<Value> {+ let fam = |id: &str| -> Value {+ let sizes: Vec<Value> = match id {+ "socket_head_cap_screw" => SHCS.iter().map(|r| json!({"size": r.0, "d": metric(r.0).map(|m| m.0), "pitch": metric(r.0).map(|m| m.1), "head_diameter": r.1, "head_height": r.2, "socket": r.3, "socket_depth": r.4})).collect(),+ "hex_bolt" => HEX_BOLT.iter().map(|r| json!({"size": r.0, "d": metric(r.0).map(|m| m.0), "pitch": metric(r.0).map(|m| m.1), "across_flats": r.1, "head_height": r.2})).collect(),+ "hex_nut" => HEX_NUT.iter().map(|r| json!({"size": r.0, "d": metric(r.0).map(|m| m.0), "pitch": metric(r.0).map(|m| m.1), "across_flats": r.1, "height": r.2})).collect(),+ "washer" => WASHER.iter().map(|r| json!({"size": r.0, "inner": r.1, "outer": r.2, "thickness": r.3})).collect(),+ "set_screw" => SET_SCREW.iter().map(|r| json!({"size": r.0, "d": metric(r.0).map(|m| m.0), "pitch": metric(r.0).map(|m| m.1), "socket": r.1, "socket_depth": r.2})).collect(),+ "dowel_pin" => DOWEL.iter().map(|d| json!({"size": format!("{d}"), "d": d})).collect(),+ "bearing" => BEARINGS.iter().map(|r| json!({"size": r.0, "bore": r.1, "outer": r.2, "width": r.3})).collect(),+ _ => Vec::new(),+ };+ let (_, name, standard) = FAMILIES.iter().find(|f| f.0 == id).copied().unwrap_or(("", "", ""));+ let lengths = matches!(id, "socket_head_cap_screw" | "hex_bolt" | "set_screw" | "dowel_pin").then_some(LENGTHS.to_vec());+ json!({"family": id, "name": name, "standard": standard, "sizes": sizes, "lengths": lengths})+ };+ match str_(p, "family") {+ Some(f) if FAMILIES.iter().any(|x| x.0 == f) => Ok(fam(f)),+ Some(f) => Err(bad("parts.library", format!("unknown part family `{f}`"))),+ None => Ok(json!({"families": FAMILIES.iter().map(|f| fam(f.0)).collect::<Vec<_>>()})),+ }+}++fn part_name(family: &str, size: &str, sh: &Shape) -> String {+ match sh {+ Shape::Screw { len, .. } | Shape::Rod { len, .. } => format!("{} {size}x{len}", label(family)),+ _ => format!("{} {size}", label(family)),+ }+}++fn label(family: &str) -> &'static str {+ match family {+ "socket_head_cap_screw" => "SHCS",+ "hex_bolt" => "Hex Bolt",+ "hex_nut" => "Hex Nut",+ "washer" => "Washer",+ "set_screw" => "Set Screw",+ "dowel_pin" => "Dowel Pin",+ _ => "Bearing",+ }+}++fn length_param(p: &Value, cmd: &str) -> Result<Option<f64>> {+ match p.get("length") {+ None | Some(Value::Null) => Ok(None),+ Some(_) => {+ let l = num(p, "length").filter(|l| l.is_finite() && *l > 0.0 && *l <= 2000.0).ok_or_else(|| bad(cmd, "`length` must be 0…2000 mm"))?;+ Ok(Some(l))+ }+ }+}++fn insert(s: &mut Session, p: &Value) -> Result<Value> {+ let cmd = "parts.insert";+ let family = str_(p, "family").ok_or_else(|| bad(cmd, "`family` is required (parts.library)"))?.to_string();+ let size = str_(p, "size").ok_or_else(|| bad(cmd, "`size` is required"))?.to_string();+ let sh = shape(&family, &size, length_param(p, cmd)?).map_err(|e| bad(cmd, e))?;+ // A pick on a hole's rim also touches its end face: step onto the wall just inside the rim.+ let at = p.get("at").and_then(vec3).map(|a| hole_wall(s, a).unwrap_or(a));+ // The occurrence the hole belongs to, found before the part exists.+ let host = match at {+ Some(a) => Some(super::joints::occurrence_at(s, a).ok_or_else(|| bad(cmd, "no body at `at` (pick a hole's rim or wall)"))?),+ None => None,+ };+ let name = str_(p, "name").map(str::to_string).unwrap_or_else(|| part_name(&family, &size, &sh));+ let active = s.active_component;+ let c = run(s, "FusionCreateNewComponentCommand", json!({"name": name}))?;+ let (comp, occ) = (c["component"].as_u64().unwrap_or(0), c["occurrence"].as_u64().unwrap_or(0));+ build(s, &sh)?;+ s.doc_mut().parts.insert(comp, solvecraft_doc::StandardPart { family: family.clone(), size: size.clone(), length: shape_len(&sh) });+ run(s, "component.activate", json!({"component": active}))?;+ let mut out = json!({"component": comp, "occurrence": occ, "name": name});+ if let (Some(a), Some(h)) = (at, host) {+ // Seat it: its axis on the hole's, its seating plane on the hole's face, the shank going+ // into the hole (the joint mates the part's −z with the face's outward z).+ let j = run(+ s,+ "JointAssembleCmdNew",+ json!({"type": "rigid", "a": {"occurrence": h, "circle": a}, "b": {"occurrence": occ, "point": [0, 0, 0], "z": [0, 0, -1]}, "name": format!("{name} seat")}),+ )?;+ out["joint"] = j["joint"].clone();+ } else if let Some(pt) = p.get("point").and_then(vec3) {+ // Placed at a point, its +z along `direction`.+ let dir = p.get("direction").and_then(vec3).and_then(|d| d.normalized()).unwrap_or(Vec3::Z);+ let m = solvecraft_doc::rigid(+ Vec3::ZERO,+ Vec3::ZERO,+ Vec3::Z.cross(dir).normalized().unwrap_or(Vec3::X),+ Vec3::Z.dot(dir).clamp(-1.0, 1.0).acos(),+ );+ let mut m = m;+ m[3] = [pt.x, pt.y, pt.z, 1.0];+ if let Some(o) = s.doc_mut().occurrences.iter_mut().find(|o| o.id == occ) {+ o.transform = m;+ }+ }+ Ok(out)+}++/// A point on the cylindrical wall of the hole at `a`, a little in from the picked rim.+fn hole_wall(s: &Session, a: Vec3) -> Option<Vec3> {+ let st = s.model.state();+ let dirs = [Vec3::Z * -1.0, Vec3::Z, Vec3::X, Vec3::X * -1.0, Vec3::Y, Vec3::Y * -1.0];+ for step in [0.2, 0.5, 1.0, 2.0] {+ for b in &st.bodies {+ for d in dirs {+ let q = a + d * step;+ if let Some(c) = solvecraft_doc::kernel::cylinder_face_at(&b.body, q) {+ let v = q - c.axis_point;+ let along = v.dot(c.axis);+ let on_wall = ((v - c.axis * along).len() - c.radius).abs() < 1e-3 && along > c.start && along < c.end;+ if on_wall {+ return Some(q);+ }+ }+ }+ }+ }+ None+}++fn shape_len(sh: &Shape) -> Option<f64> {+ match sh {+ Shape::Screw { len, .. } | Shape::Rod { len, .. } => Some(*len),+ _ => None,+ }+}++fn resize(s: &mut Session, p: &Value) -> Result<Value> {+ let cmd = "parts.resize";+ let key = match p.get("component") {+ Some(Value::Number(n)) => n.to_string(),+ Some(Value::String(x)) => x.clone(),+ _ => return Err(bad(cmd, "`component` must be an id or a name")),+ };+ let comp = s.doc.find_component(&key).ok_or_else(|| bad(cmd, format!("no component `{key}`")))?;+ let part = s.doc.parts.get(&comp).cloned().ok_or_else(|| bad(cmd, "that component is not a standard part"))?;+ let size = str_(p, "size").map(str::to_string).unwrap_or(part.size.clone());+ let length = length_param(p, cmd)?.or(if size == part.size { part.length } else { None });+ let sh = shape(&part.family, &size, length).map_err(|e| bad(cmd, e))?;+ // Rebuild: the component's features go, the new shape is built in their place.+ let ids: Vec<u64> = s.doc.features.iter().filter(|f| f.component == comp).map(|f| f.id).collect();+ for id in ids.iter().rev() {+ let _ = s.doc_mut().delete_feature(*id);+ }+ let active = s.active_component;+ run(s, "component.activate", json!({"component": comp}))?;+ build(s, &sh)?;+ let name = part_name(&part.family, &size, &sh);+ s.doc_mut().parts.insert(comp, solvecraft_doc::StandardPart { family: part.family.clone(), size: size.clone(), length: shape_len(&sh) });+ if let Some(c) = s.doc_mut().components.iter_mut().find(|c| c.id == comp) {+ c.name = name.clone();+ }+ run(s, "component.activate", json!({"component": active}))?;+ s.refresh();+ if let Some(e) = s.model.results.iter().find_map(|r| r.error.clone()) {+ return Err(EngineError::Other(e));+ }+ Ok(json!({"component": comp, "name": name, "size": size, "length": shape_len(&sh)}))+}++#[cfg(test)]+mod tests {+ use serde_json::{Value, json};++ use crate::Session;++ fn run(s: &mut Session, id: &str, p: Value) -> Value {+ match s.execute(id, &p) {+ Ok(v) => v,+ Err(e) => panic!("{id} {p}: {e}"),+ }+ }++ fn bbox(s: &Session, prefix: &str) -> (solvecraft_geom::Vec3, solvecraft_geom::Vec3) {+ let st = s.world_state();+ let comp = s.doc.components.iter().find(|c| c.name.starts_with(prefix)).map(|c| c.id).unwrap_or(0);+ let (mut lo, mut hi) = (solvecraft_geom::Vec3::new(f64::MAX, f64::MAX, f64::MAX), solvecraft_geom::Vec3::new(f64::MIN, f64::MIN, f64::MIN));+ for b in st.bodies.iter().filter(|b| s.doc.body_component(&b.name, b.feature) == comp) {+ let m = b.mesh().bounds();+ lo = solvecraft_geom::Vec3::new(lo.x.min(m.min.x), lo.y.min(m.min.y), lo.z.min(m.min.z));+ hi = solvecraft_geom::Vec3::new(hi.x.max(m.max.x), hi.y.max(m.max.y), hi.z.max(m.max.z));+ }+ (lo, hi)+ }++ #[test]+ fn dimensions_follow_the_standard_tables() {+ let l = run(&mut Session::default(), "parts.library", json!({"family": "socket_head_cap_screw"}));+ let m6 = l["sizes"].as_array().and_then(|a| a.iter().find(|x| x["size"] == "M6")).cloned().unwrap_or_default();+ assert_eq!((m6["head_diameter"].as_f64(), m6["head_height"].as_f64(), m6["socket"].as_f64()), (Some(10.0), Some(6.0), Some(5.0)));+ // An M6 x 20 cap screw: head Ø10 x 6, shank 20 long.+ let mut s = Session::default();+ run(&mut s, "parts.insert", json!({"family": "socket_head_cap_screw", "size": "M6", "length": 20}));+ let (lo, hi) = bbox(&s, "SHCS M6x20");+ assert!((hi.x - lo.x - 10.0).abs() < 1e-6 && (lo.z + 20.0).abs() < 1e-6 && (hi.z - 6.0).abs() < 1e-6, "{lo:?} {hi:?}");+ assert!(s.model.state().threads.iter().any(|t| t.designation.starts_with("M6")), "{:?}", s.model.state().threads);+ // An M8 nut: 13 across flats (14.43 across corners), 6.8 high.+ let mut n = Session::default();+ run(&mut n, "parts.insert", json!({"family": "hex_nut", "size": "M8"}));+ let (lo, hi) = bbox(&n, "Hex Nut M8");+ let (w, h) = ((hi.x - lo.x).max(hi.y - lo.y), hi.z - lo.z);+ assert!((w - 13.0 / (std::f64::consts::PI / 6.0).cos()).abs() < 1e-6 && (h - 6.8).abs() < 1e-6, "{w} {h}");+ // A 608 bearing: 8 x 22 x 7.+ let mut b = Session::default();+ run(&mut b, "parts.insert", json!({"family": "bearing", "size": "608"}));+ let (lo, hi) = bbox(&b, "Bearing 608");+ assert!((hi.x - lo.x - 22.0).abs() < 1e-6 && (hi.z - lo.z - 7.0).abs() < 1e-6);+ assert!(b.execute("parts.insert", &json!({"family": "hex_nut", "size": "M7"})).is_err());+ }++ #[test]+ fn a_screw_seats_in_a_hole_and_resizes() {+ let mut s = Session::default();+ run(&mut s, "PrimitiveBox", json!({"length": 40, "width": 30, "height": 10, "body_name": "Plate"}));+ run(&mut s, "FusionHoleCommand", json!({"position": [20, 15, 10], "diameter": 6.4}));+ // Pick the hole's rim at the top face.+ let r = run(&mut s, "parts.insert", json!({"family": "socket_head_cap_screw", "size": "M6", "length": 20, "at": [23.2, 15, 10]}));+ assert!(r["joint"].is_number(), "{r}");+ let (lo, hi) = bbox(&s, "SHCS M6x20");+ // The head sits flush on the top face, the shank down the hole's axis.+ assert!((hi.z - 16.0).abs() < 1e-6 && (lo.z + 10.0).abs() < 1e-6, "{lo:?} {hi:?}");+ assert!(((lo.x + hi.x) / 2.0 - 20.0).abs() < 1e-6 && ((lo.y + hi.y) / 2.0 - 15.0).abs() < 1e-6);+ // M8 x 25: rebuilt in place, still seated.+ let comp = r["component"].as_u64().unwrap_or(0);+ run(&mut s, "parts.resize", json!({"component": comp, "size": "M8", "length": 25}));+ let (lo, hi) = bbox(&s, "SHCS M8x25");+ assert!((hi.z - 18.0).abs() < 1e-6 && (lo.z + 15.0).abs() < 1e-6, "{lo:?} {hi:?}");+ }+}