From d6cdec40dacfa02b4cdac965e60de5d5c341b84e Mon Sep 17 00:00:00 2001 From: bherbruck Date: Sat, 10 Oct 2026 15:05:27 -0400 Subject: [PATCH] Fix modelling regressions and reconcile WIP UI work --- ROADMAP.md | 11 +- apps/solvecraft-cli/src/recipe.rs | 2 +- apps/solvecraft/src/main.rs | 18 ++ crates/doc/src/canvas.rs | 23 +- crates/doc/src/document.rs | 1 + crates/doc/src/eval.rs | 96 +++++++- crates/doc/src/eval_more.rs | 7 +- crates/doc/src/format.rs | 55 ++++- crates/doc/src/lib.rs | 2 +- crates/doc/src/naming.rs | 6 + crates/doc/src/project.rs | 15 +- crates/engine/src/cmd/browser.rs | 4 +- crates/engine/src/cmd/parts.rs | 2 +- crates/engine/src/cmd/section.rs | 2 +- crates/engine/src/cmd/sketch.rs | 11 +- crates/engine/src/cmd/sketch_canvas.rs | 3 + crates/engine/src/cmd/sketch_modify.rs | 14 +- crates/engine/src/cmd/sketch_project.rs | 14 +- crates/engine/src/frames.rs | 43 +++- crates/engine/src/frames_tests.rs | 103 ++++++++ crates/engine/src/tests.rs | 19 +- crates/geom/src/plane.rs | 4 +- crates/geom/src/tests.rs | 4 +- crates/kernel/src/iges_in/tests.rs | 3 +- crates/kernel/src/lib.rs | 2 +- crates/kernel/src/ops.rs | 11 +- crates/kernel/src/prism.rs | 131 +++++++++- crates/kernel/src/splitface.rs | 2 +- crates/kernel/src/tests.rs | 40 +++- crates/sketch/src/lib.rs | 2 + crates/sketch/src/link.rs | 78 +++++- crates/sketch/src/model.rs | 3 + crates/sketch/src/offset.rs | 116 +++++++++ crates/sketch/src/wire.rs | 2 +- crates/ui-egui/src/browser.rs | 50 ++-- crates/ui-egui/src/context_menu.rs | 18 +- crates/ui-egui/src/dialogs.rs | 48 +++- crates/ui-egui/src/dialogs_assembly.rs | 225 +++++++++++++----- crates/ui-egui/src/dialogs_assembly_tests.rs | 38 +++ crates/ui-egui/src/dialogs_motion.rs | 135 ++++++++++- crates/ui-egui/src/documents.rs | 24 +- crates/ui-egui/src/home.rs | 72 ++++-- crates/ui-egui/src/lib.rs | 24 +- crates/ui-egui/src/menu_tests.rs | 6 +- crates/ui-egui/src/ref_images.rs | 4 +- crates/ui-egui/src/scenario.rs | 9 + crates/ui-egui/src/toolbar.rs | 54 ++++- crates/ui-egui/src/tools.rs | 36 +-- crates/ui-egui/src/viewport.rs | 1 + crates/ui-egui/tests/scenarios.rs | 95 ++++++++ .../acceptance_lid_lip_after_resize.json | 3 - .../acceptance_sensor_enclosure.json | 64 +++++ .../acceptance_snap_fit_after_resize.json | 3 - .../scenarios/s01_box_fillet_hole_shell.json | 1 + .../scenarios/s06_edit_early_feature.json | 1 + .../scenarios/s07_components_joint_drive.json | 33 ++- .../scenarios/s10_parameters_drive_model.json | 1 + .../scenarios/s11_sketch_constraints.json | 26 +- .../s20_section_with_joint_drive.json | 31 ++- .../tests/scenarios/s23_configurations.json | 1 + .../scenarios/s26_drive_joint_typed.json | 31 ++- .../s32_cut_in_active_component.json | 6 +- .../tests/scenarios/s37_browser_chevrons.json | 32 ++- ...3_root_sketch_on_moved_component_face.json | 103 ++++++++ .../sketch_on_moved_component_face.json | 3 - .../tests/scenarios/view_cube_y_up.json | 4 +- docs/wip-reconciliation.md | 22 ++ 67 files changed, 1793 insertions(+), 260 deletions(-) create mode 100644 crates/sketch/src/offset.rs create mode 100644 crates/ui-egui/tests/scenarios/s43_root_sketch_on_moved_component_face.json create mode 100644 docs/wip-reconciliation.md diff --git a/ROADMAP.md b/ROADMAP.md index 862bb90c..3a7621ea 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -1,6 +1,6 @@ # SolveCraft roadmap -Status as of **2026-10-09**. SolveCraft targets Fusion-style parametric modelling (sketch → +Status as of **2026-10-10**. SolveCraft targets Fusion-style parametric modelling (sketch → features → parametric timeline) as an open, pure-Rust, agent-drivable application. ## At a glance @@ -10,12 +10,19 @@ features → parametric timeline) as an open, pure-Rust, agent-drivable applicat | Where are we? | **M0, M1, M13 done; M2, M5–M7, M9, M10, M14 in progress.** Sketch with solver and the full SKETCH create/modify set; extrude, revolve (two sides, symmetric, to object), fillet/chamfer (variable radius, chord length, a radius per edge, corner patches), holes, threads (cosmetic and modelled), patterns, mirror, shell (inside/outside/both), draft, loft, sweep, coil, split body and split face, delete face, construction planes, axes and points; persistent naming of faces and edges; parameters and configurations; components, joints, motion studies, exploded views; sheet metal and a plastic enclosure subset; STEP/IGES/3MF/STL/OBJ/DXF; autosave and crash recovery; desktop and browser (wasm) app, CLI, MCP server, oracle harness. | | Command parity (in scope) | **328 / 541 (61%)** in-scope commands; SOLID + SKETCH **185 / 291 (64%)** — [docs/parity.md](docs/parity.md) | | Fusion oracle | **76 / 76 parts match** — [docs/oracle.md](docs/oracle.md) | -| Tests | 596 (41 of them UI scenarios): solver, profiles, kernel booleans/blends/measures, expressions, timeline, persistent naming, file formats and migrations, assemblies, sheet metal, engine end-to-end, hostile-input fuzz over every command | +| Tests | Solver, profiles, kernel booleans/blends/measures, expressions, timeline, persistent naming, file formats and migrations, assemblies, sheet metal, engine end-to-end, hostile-input fuzz over every command and headless UI scenarios. `cargo xtask ci` reports the current passing counts. | | Gates | `cargo xtask ci`: fmt, clippy -D warnings, tests, asset attribution, layering, wasm32 build — green | | Time to a useful alpha (M0–M6) | ≈ **82 agent hours** remain (sum of the M1–M6 estimates below) | ## Scope (owner decision, 2026-10-07) +The issue batch adds preservation of blind pockets in through cuts, associative projected +offsets and plastic face placements, XZ (+Y normal) with a v6 migration preserving older +designs, interactive angle placement, file-picker sketch imports, Home/recent controls, +toolbar overflow, and the remaining component-frame and assembly WIP work. The enclosure +acceptance scenarios now include board resizes; STEP reopening is automated. Inspection in +Fusion remains an external acceptance step. See [WIP reconciliation](docs/wip-reconciliation.md). + In scope, in priority order: 1. SOLID and SKETCH (now). 2. Parameters / functional constraints (done: see `parameters.*`, `expr.evaluate`; unit-aware, diff --git a/apps/solvecraft-cli/src/recipe.rs b/apps/solvecraft-cli/src/recipe.rs index 7a51d47f..6669eaf6 100644 --- a/apps/solvecraft-cli/src/recipe.rs +++ b/apps/solvecraft-cli/src/recipe.rs @@ -10,7 +10,7 @@ fn plane_param(pl: &Value) -> Value { let origin_zero = pl.get("origin").and_then(Value::as_array).is_none_or(|o| o.iter().all(|x| x.as_f64().unwrap_or(0.0).abs() < 1e-12)); let std = match r.to_ascii_uppercase().as_str() { "XY" => Some(([1.0, 0.0, 0.0], [0.0, 1.0, 0.0])), - "XZ" => Some(([1.0, 0.0, 0.0], [0.0, 0.0, 1.0])), + "XZ" => Some(([1.0, 0.0, 0.0], [0.0, 0.0, -1.0])), "YZ" => Some(([0.0, 1.0, 0.0], [0.0, 0.0, 1.0])), _ => None, }; diff --git a/apps/solvecraft/src/main.rs b/apps/solvecraft/src/main.rs index 4dcdcc4d..a3a70162 100644 --- a/apps/solvecraft/src/main.rs +++ b/apps/solvecraft/src/main.rs @@ -61,6 +61,7 @@ fn services() -> Services { .add_filter("STEP", &["step", "stp", "STEP", "STP"]) .add_filter("IGES", &["igs", "iges", "IGS", "IGES"]) .add_filter("Mesh (3MF, STL)", &["3mf", "3MF", "stl", "STL"]) + .add_filter("Sketch drawings (DXF, SVG)", &["dxf", "DXF", "svg", "SVG"]) .add_filter("All files", &["*"]) .pick_file() .map(|p| p.to_string_lossy().to_string()) @@ -69,6 +70,23 @@ fn services() -> Services { rfd::FileDialog::new().set_file_name(name).add_filter("File", exts).save_file().map(|p| p.to_string_lossy().to_string()) })), graphics_path: graphics_path().map(|p| p.to_string_lossy().to_string()), + show_in_folder: Some(Box::new(|path| { + let folder = std::path::Path::new(path).parent().unwrap_or_else(|| std::path::Path::new(".")); + let mut command = std::process::Command::new(if cfg!(target_os = "windows") { + "explorer" + } else if cfg!(target_os = "macos") { + "open" + } else { + "xdg-open" + }); + command.arg(folder); + #[cfg(target_os = "windows")] + { + use std::os::windows::process::CommandExt; + command.creation_flags(0x08000000); + } + let _ = command.spawn(); + })), } } diff --git a/crates/doc/src/canvas.rs b/crates/doc/src/canvas.rs index a9c07f93..2c7cb9cc 100644 --- a/crates/doc/src/canvas.rs +++ b/crates/doc/src/canvas.rs @@ -34,6 +34,14 @@ pub struct Canvas { pub flip: bool, #[serde(default = "yes")] pub visible: bool, + /// The component it belongs to (its plane is in that component's frame, so it moves with + /// the component's occurrence); 0 = the root. + #[serde(default, skip_serializing_if = "is_root")] + pub component: u64, +} + +fn is_root(c: &u64) -> bool { + *c == 0 } fn half() -> f64 { @@ -57,7 +65,7 @@ impl Canvas { let f = if self.flip { -1.0 } else { 1.0 }; [rot(-hw * f, -hh), rot(hw * f, -hh), rot(hw * f, hh), rot(-hw * f, hh)] } - /// Corners in world coordinates. + /// Corners on `plane` (in whatever frame the plane is given). pub fn world_corners(&self, plane: &Plane) -> [Vec3; 4] { self.corners().map(|p| plane.to_world(p)) } @@ -66,6 +74,19 @@ impl Canvas { } } +impl crate::Document { + /// A canvas's plane in the world: resolved in its component's frame, then placed where the + /// component's occurrence puts it. + pub fn canvas_plane(&self, vals: &std::collections::BTreeMap, c: &Canvas) -> crate::Result { + let p = self.resolve_plane(vals, &c.plane, 0)?; + let m = self.component_transform(c.component); + if crate::is_identity(&m) { + return Ok(p); + } + Ok(Plane::new(crate::apply_point(&m, p.origin), crate::apply_vector(&m, p.x), crate::apply_vector(&m, p.y)).unwrap_or(p)) + } +} + /// Image kind and pixel size from the file header (PNG or JPEG). pub fn image_info(b: &[u8]) -> Option<(&'static str, [u32; 2])> { if b.len() > 24 && b.starts_with(b"\x89PNG\r\n\x1a\n") { diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs index 8b0e80ea..c7f70e3a 100644 --- a/crates/doc/src/document.rs +++ b/crates/doc/src/document.rs @@ -1115,6 +1115,7 @@ impl FeatureKind { FeatureKind::Extrude { extent, .. } => extent.to.iter_mut().chain(extent.from.iter_mut()).collect(), FeatureKind::Revolve { to: Some(p), .. } => vec![p], FeatureKind::Thread { face, .. } => vec![face], + FeatureKind::Boss { position, .. } | FeatureKind::SnapFit { position, .. } | FeatureKind::Rest { position, .. } => vec![position], _ => Vec::new(), } } diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index a7229d47..8cd6a94d 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -471,6 +471,22 @@ fn cache_key(f: &Feature, chain_fp: u64, local: u64, ctx: u64, state: &ModelStat h.finish() } +/// Where components are placed, for a sketch that sees other components' geometry (on a face, +/// or with projections): it is resolved in its own component's view of them. +fn placement_digest(doc: &Document, f: &Feature) -> u64 { + let FeatureKind::Sketch { plane, sketch } = &f.kind else { return 0 }; + if doc.occurrences.is_empty() || (!matches!(plane, PlaneRef::Face { .. }) && sketch.links.is_empty()) { + return 0; + } + let mut h = std::collections::hash_map::DefaultHasher::new(); + for o in &doc.occurrences { + o.id.hash(&mut h); + o.transform.iter().flatten().for_each(|x| x.to_bits().hash(&mut h)); + } + serde_json::to_string(&doc.body_offsets).unwrap_or_default().hash(&mut h); + h.finish() +} + fn now() -> web_time::Instant { web_time::Instant::now() } @@ -514,7 +530,7 @@ impl Model { let ctx = context_digest(doc, &vals); for (i, f) in doc.features.iter().enumerate() { let rolled_back = i >= marker; - let mut fp = fingerprint(prev_fp, f, &vals, rolled_back); + let mut fp = fingerprint(prev_fp, f, &vals, rolled_back) ^ placement_digest(doc, f); // Sheet metal features also depend on the rules (and the parameters they use). if f.kind.is_sheet() { let mut h = std::collections::hash_map::DefaultHasher::new(); @@ -570,7 +586,7 @@ impl Model { continue; } // The same feature on the same inputs: its earlier result. - let key = cache_key(f, fp, fingerprint(0, f, &vals, false), ctx, &state); + let key = cache_key(f, fp, fingerprint(0, f, &vals, false) ^ placement_digest(doc, f), ctx, &state); if !self.no_cache && let Some(c) = self.cache.lock().ok().and_then(|mut m| m.get(key)) { @@ -1405,6 +1421,20 @@ fn feature_tools(vals: &BTreeMap, f: &Feature, st: &ModelState) - } let mut tools = Vec::new(); for r in ®ions { + if *operation == Operation::Join { + let exact = kernel::extrude(&ss.plane, std::slice::from_ref(r), lo + off, hi + off)?; + if exact.iter().all(|tool| { + st.bodies + .iter() + .filter(|b| targets.is_empty() || targets.contains(&b.name)) + .any(|b| kernel::can_join_touching_faces(&b.body, tool)) + }) { + // Preserve a whole touching face: extending into a chamfer replaces + // the sewable seam with a coincident curved intersection. + tools.extend(exact); + continue; + } + } let (l2, h2) = extend_for_coplanar(st, &ss.plane, r, lo + off, hi + off, *operation, targets); let probe = |p: Vec2| (1..4).map(|k| ss.plane.to_world(p) + n * (lo + off + (hi - lo) * k as f64 / 4.0)).collect::>(); let r = grow_profile_for_coplanar(st, r, *operation, targets, &probe); @@ -2288,17 +2318,25 @@ fn eval_feature(doc: &Document, vals: &BTreeMap, f: &Feature, st: | FeatureKind::Align { .. } | FeatureKind::Remove { .. } => more::eval(doc, vals, f, st), FeatureKind::Sketch { plane, sketch } => { + let fst = state_in_frame(doc, st, f.component); let (plane, face_warning) = match plane { - PlaneRef::Face { plane: picked, at, name } => face_plane(st, picked, *at, name.as_deref()), - other => (doc.resolve_plane_in(vals, other, 0, Some(st))?, None), + PlaneRef::Face { plane: picked, at, name } => face_plane(&fst, picked, *at, name.as_deref()), + other => (doc.resolve_plane_in(vals, other, 0, Some(&fst))?, None), }; let mut sk = sketch.clone(); - let mut warns = crate::project::refresh_links(doc, vals, st, &plane, &mut sk); + let mut warns = crate::project::refresh_links(doc, vals, &fst, &plane, &mut sk); + drop(fst); + sk.refresh_offsets()?; if let Some(w) = face_warning { warns.insert(0, w); } doc.apply_dimension_values(vals, &mut sk)?; - let report = solve(&mut sk); + let mut report = solve(&mut sk); + if !sk.offsets.is_empty() { + // Source dimensions may have moved curves during the solve. + sk.refresh_offsets()?; + report = solve(&mut sk); + } if !report.ok() { warns.insert(0, format!("the sketch constraints conflict ({})", report.failing.join(", "))); } @@ -2818,6 +2856,52 @@ fn unique_body_name(st: &ModelState, base: &str) -> String { (2..).map(|i| format!("{base} ({i})")).find(|n| st.body(n).is_none()).unwrap_or_else(|| base.to_string()) } +/// The model as a component sees it: bodies and sketches of components placed differently from +/// it are moved into its frame (through both placements), so a sketch on another component's +/// face finds the face where it is shown and projects its edges there. The model itself when +/// every placement agrees (the usual case). +pub fn state_in_frame<'a>(doc: &Document, st: &'a ModelState, comp: u64) -> std::borrow::Cow<'a, ModelState> { + use std::borrow::Cow; + if doc.occurrences.is_empty() && doc.body_offsets.is_empty() { + return Cow::Borrowed(st); + } + let Some(inv) = crate::mat_inverse(&doc.component_transform(comp)) else { return Cow::Borrowed(st) }; + let comp_of_feature = |id: u64| doc.feature(id).map(|f| f.component).unwrap_or(0); + let rel = |c: u64, body: Option<&str>| { + let m = crate::mat_mul(&inv, &doc.component_transform(c)); + match body.and_then(|b| doc.body_offsets.get(b)) { + Some(o) => crate::mat_mul(&m, o), + None => m, + } + }; + let body_m: Vec = st.bodies.iter().map(|b| rel(doc.body_component(&b.name, b.feature), Some(&b.name))).collect(); + let sketch_m: Vec = st.sketches.iter().map(|s| rel(comp_of_feature(s.feature), None)).collect(); + if body_m.iter().chain(&sketch_m).all(crate::is_identity) { + return Cow::Borrowed(st); + } + let mut out = st.clone(); + for (b, m) in out.bodies.iter_mut().zip(&body_m) { + if !crate::is_identity(m) + && let Ok(t) = kernel::transform_matrix(&b.body, *m) + { + // Moving a body keeps its faces (and their order): it keeps their names. + let names = crate::naming::face_names(b); + let mut nb = ModelBody::new(b.name.clone(), t, b.feature); + nb.component = b.component; + nb.names = crate::naming::NameCell::known(names); + *b = nb; + } + } + for (s, m) in out.sketches.iter_mut().zip(&sketch_m) { + if !crate::is_identity(m) + && let Some(np) = Plane::new(crate::apply_point(m, s.plane.origin), crate::apply_vector(m, s.plane.x), crate::apply_vector(m, s.plane.y)) + { + s.plane = np; + } + } + Cow::Owned(out) +} + /// The model placed in the world: each component's bodies, sketches and threads through every /// occurrence of it (bodies of the first placement keep their names; further instances get the /// occurrence path in brackets). Without components this is the model itself. diff --git a/crates/doc/src/eval_more.rs b/crates/doc/src/eval_more.rs index 9006f74e..84b30e53 100644 --- a/crates/doc/src/eval_more.rs +++ b/crates/doc/src/eval_more.rs @@ -613,7 +613,12 @@ fn face_loops(mesh: &solvecraft_geom::Mesh, plane: &Plane, at: Vec3, n: Vec3, le /// The body a placed plastic feature joins: by name, else the one under the point. fn body_under(st: &ModelState, body: &Option, p: Vec3) -> Result { let i = body_at(st, body, &[p])?; - st.bodies.get(i).map(|b| b.name.clone()).ok_or_else(|| DocError::Invalid("there is no body".into())) + let b = st.bodies.get(i).ok_or_else(|| DocError::Invalid("there is no body".into()))?; + let tolerance = (b.body.size() * 1e-5).max(1e-4); + if crate::project::nearest_face(&b.mesh(), p).is_none_or(|(_, _, distance)| distance > tolerance) { + return Err(DocError::Invalid("the plastic feature's placement is no longer on its body face".into())); + } + Ok(b.name.clone()) } /// Axes with z along `z` (and x along `x` when given). diff --git a/crates/doc/src/format.rs b/crates/doc/src/format.rs index abdf81c9..cf0328ec 100644 --- a/crates/doc/src/format.rs +++ b/crates/doc/src/format.rs @@ -18,13 +18,15 @@ //! ["*"]` (every body), which is what they did, so those designs keep their shape. //! - 4: joint origins mate by default (B's z against A's, as Fusion does); `flip` now means //! "don't mate". Older joints keep their placement: their `flip` is inverted. +//! - 6: XZ origin planes use sketch y = -Z and normal +Y. Older XZ references become +//! explicit planes retaining their previous axes, including offset-plane expressions. use serde_json::Value; use crate::{DocError, Document, Result}; /// The format this build writes. -pub const FORMAT: u32 = 5; +pub const FORMAT: u32 = 6; pub fn format_string(n: u32) -> String { format!("solvecraft/{n}") @@ -37,7 +39,30 @@ pub fn version_of(s: &str) -> Option { /// JSON-level upgrades: entry `i` turns format `i + 1` into `i + 2`. type JsonStep = fn(&mut Value) -> Result<()>; -const JSON_STEPS: [JsonStep; 4] = [|_| Ok(()), v2_to_v3, v3_to_v4, v4_to_v5]; +const JSON_STEPS: [JsonStep; 5] = [|_| Ok(()), v2_to_v3, v3_to_v4, v4_to_v5, v5_to_v6]; + +/// Old XZ references retain their exact frame, including nested offset and angled planes. +/// New origin references use +Y; freezing the old frame avoids changing sketch coordinates, +/// dimensions, profiles, extrude directions or parameter expressions in saved designs. +fn v5_to_v6(v: &mut Value) -> Result<()> { + fn preserve(v: &mut Value) { + match v { + Value::Object(o) => { + let old_xz = o.get("type").and_then(Value::as_str) == Some("origin") + && o.get("name").and_then(Value::as_str).is_some_and(|n| n.eq_ignore_ascii_case("XZ") || n.eq_ignore_ascii_case("FRONT")); + if old_xz { + *v = serde_json::json!({"type": "custom", "plane": {"origin": [0, 0, 0], "x_dir": [1, 0, 0], "y_dir": [0, 0, 1]}}); + } else { + o.values_mut().for_each(preserve); + } + } + Value::Array(a) => a.iter_mut().for_each(preserve), + _ => {} + } + } + preserve(v); + Ok(()) +} /// Features in designs with components keep reaching every body. fn v4_to_v5(v: &mut Value) -> Result<()> { @@ -198,6 +223,32 @@ mod tests { assert_eq!(back, d); } + #[test] + fn old_xz_and_nested_offsets_keep_their_frame() { + let mut doc = Document::new("old XZ"); + let id = doc + .add_feature( + crate::FeatureKind::ConstructionPlane { + plane: crate::PlaneRef::Offset { base: Box::new(crate::PlaneRef::Origin { name: "XZ".into() }), distance: "7 mm".into() }, + }, + None, + ) + .unwrap(); + let mut json: Value = serde_json::from_str(&doc.to_json()).unwrap(); + json["format"] = Value::from("solvecraft/5"); + let migrated = read(&json.to_string()).unwrap(); + let crate::FeatureKind::ConstructionPlane { plane } = &migrated.feature(id).unwrap().kind else { panic!("plane") }; + let (values, errors) = migrated.param_values(); + assert!(errors.is_empty()); + let p = migrated.resolve_plane(&values, plane, 0).unwrap(); + assert_eq!(p.y, solvecraft_geom::Vec3::Z); + assert_eq!(p.normal(), -solvecraft_geom::Vec3::Y); + assert_eq!(p.origin, solvecraft_geom::Vec3::new(0.0, -7.0, 0.0)); + assert_eq!(read(&migrated.to_json()).unwrap(), migrated); + let fresh = doc.resolve_plane(&values, &crate::PlaneRef::Origin { name: "XZ".into() }, 0).unwrap(); + assert_eq!(fresh.normal(), solvecraft_geom::Vec3::Y); + } + #[test] fn older_upgraded_newer_refused_others_rejected() { let mut v: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap(); diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs index 10856e30..9f920212 100644 --- a/crates/doc/src/lib.rs +++ b/crates/doc/src/lib.rs @@ -29,7 +29,7 @@ pub use assembly::{IDENTITY, Mat, Occurrence, apply_point, apply_vector, is_iden pub use document::*; pub use eval::{ EdgeRef, FeatureResult, Model, ModelBody, ModelState, SolvedSketch, ThreadInfo, edge_names_for, edge_refs, parse_metric_thread, pattern_matrices, - world_state, + state_in_frame, world_state, }; pub use params::{ParamRow, ParamUser, cycles}; pub use solvecraft_kernel as kernel; diff --git a/crates/doc/src/naming.rs b/crates/doc/src/naming.rs index 72c60881..430c81fa 100644 --- a/crates/doc/src/naming.rs +++ b/crates/doc/src/naming.rs @@ -34,6 +34,12 @@ impl NameCell { pub fn new(origin: Option>) -> Self { NameCell { origin, names: Arc::new(OnceLock::new()) } } + /// Names already known (a moved copy of a body keeps its faces' names). + pub fn known(names: Arc>) -> Self { + let cell = OnceLock::new(); + let _ = cell.set(names); + NameCell { origin: None, names: Arc::new(cell) } + } } /// Deeper chains than this are named by position only (bounded work and stack). diff --git a/crates/doc/src/project.rs b/crates/doc/src/project.rs index d61a79fd..6e42aa42 100644 --- a/crates/doc/src/project.rs +++ b/crates/doc/src/project.rs @@ -273,7 +273,20 @@ pub fn refresh_links(doc: &Document, vals: &BTreeMap, st: &ModelS let mut warn = Vec::new(); let links = sk.links.clone(); for l in &links { - match resolve(doc, vals, st, plane, l.kind, &l.source) { + let mut source = l.source.clone(); + if let (Some(name), LinkSource::Face { at, .. }) = (&l.face_name, &mut source) { + if let Some((p, split)) = crate::naming::point_on_face(st, name, *at) { + *at = p; + if split { + warn.push(format!("projected face `{name}` was split; using the nearest piece")); + } + } else { + sk.set_link_lost(&l.id, true); + warn.push(format!("projected face `{name}` no longer exists")); + continue; + } + } + match resolve(doc, vals, st, plane, l.kind, &source) { Ok(r) => { sk.set_link_source(&l.id, r.source); let _ = sk.set_link_wires(&l.id, &r.wires); diff --git a/crates/engine/src/cmd/browser.rs b/crates/engine/src/cmd/browser.rs index 5bb71272..1740ac04 100644 --- a/crates/engine/src/cmd/browser.rs +++ b/crates/engine/src/cmd/browser.rs @@ -495,7 +495,9 @@ mod tests { assert!((zmax(&mut s) - 5.0).abs() < 1e-6); run(&mut s, "sketch.redefine", json!({"sketch": sk, "plane": "XZ"})); let z = zmax(&mut s); - assert!(z > 9.0, "the profile stands up on XZ: {z}"); + assert!(z.abs() < 1e-6, "positive sketch Y on XZ extends toward -Z: {z}"); + let ymin = run(&mut s, "inspect.measure", json!({}))["bodies"][0]["bbox"]["min"][2].as_f64().unwrap(); + assert!((ymin + 20.0).abs() < 1e-6); assert!(s.execute("sketch.redefine", &json!({"sketch": sk, "plane": "nope"})).is_err()); assert!(s.execute("sketch.redefine", &json!({"sketch": 999, "plane": "XY"})).is_err()); } diff --git a/crates/engine/src/cmd/parts.rs b/crates/engine/src/cmd/parts.rs index f8964ab6..0a5d4401 100644 --- a/crates/engine/src/cmd/parts.rs +++ b/crates/engine/src/cmd/parts.rs @@ -231,7 +231,7 @@ fn cyl(s: &mut Session, d: f64, z0: f64, z1: f64, op: &str) -> Result<()> { /// 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, "sketch.create", json!({"plane": "XZ"}))?; - let points: Vec<[f64; 2]> = pts.iter().map(|(r, z)| [*r, *z]).collect(); + let points: Vec<[f64; 2]> = pts.iter().map(|(r, z)| [*r, -*z]).collect(); run(s, "sketch.line", json!({"points": points, "closed": true}))?; run(s, "sketch.finish", json!({}))?; run(s, "solid.revolve", json!({"axis": "y", "operation": op}))?; diff --git a/crates/engine/src/cmd/section.rs b/crates/engine/src/cmd/section.rs index fcc48cf7..4486817a 100644 --- a/crates/engine/src/cmd/section.rs +++ b/crates/engine/src/cmd/section.rs @@ -10,7 +10,7 @@ use crate::{Result, Session}; pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("inspect.section", "Section Analysis", section).at("SOLID", "INSPECT").icon("section").noundo().params( - "plane: XY|XZ|YZ | {origin, normal}; offset?: expr along the plane's normal (XY: +Z, XZ: -Y, YZ: +X); \ + "plane: XY|XZ|YZ | {origin, normal}; offset?: expr along the plane's normal (XY: +Z, XZ: +Y, YZ: +X); \ at?: expr, the cut's world coordinate on the named plane's axis (XY: Z, XZ: Y, YZ: X), instead of offset; \ flip?: bool; or clear: true. Returns the cut's origin and normal, and for a named plane its axis and at", )]; diff --git a/crates/engine/src/cmd/sketch.rs b/crates/engine/src/cmd/sketch.rs index 865ea5b3..e76bd360 100644 --- a/crates/engine/src/cmd/sketch.rs +++ b/crates/engine/src/cmd/sketch.rs @@ -359,8 +359,10 @@ pub(super) fn plane_ref(s: &Session, p: &Value, cmd: &str) -> Result { } Some(v @ Value::Object(o)) => { if let Some(fp) = o.get("face").and_then(vec3) { - // A planar face of a body at this point. - let st = s.model.state(); + // A planar face of a body at this point, as the active component sees the model + // (another component's face where it is placed). + let model = s.model.state(); + let st = solvecraft_doc::state_in_frame(&s.doc, &model, s.active_component); let mut found = None; let mut face_name = None; for b in &st.bodies { @@ -406,7 +408,10 @@ fn face_contains(m: &solvecraft_geom::Mesh, fi: usize, p: Vec3, tol: f64) -> boo let s1 = (b - a).cross(p - a).dot(n); let s2 = (c - b).cross(p - b).dot(n); let s3 = (a - c).cross(p - c).dot(n); - (s1 >= 0.0 && s2 >= 0.0 && s3 >= 0.0) || (s1 <= 0.0 && s2 <= 0.0 && s3 <= 0.0) + (s1 >= 0.0 && s2 >= 0.0 && s3 >= 0.0) + || (s1 <= 0.0 && s2 <= 0.0 && s3 <= 0.0) + // Exact curved boundaries can sit just outside their tessellated chords. + || p.dist_to_segment(a, b).min(p.dist_to_segment(b, c)).min(p.dist_to_segment(c, a)) <= tol * 0.1 }) } diff --git a/crates/engine/src/cmd/sketch_canvas.rs b/crates/engine/src/cmd/sketch_canvas.rs index 5bb84a89..8c6061f0 100644 --- a/crates/engine/src/cmd/sketch_canvas.rs +++ b/crates/engine/src/cmd/sketch_canvas.rs @@ -57,6 +57,8 @@ fn make(s: &mut Session, p: &Value, cmd: &str, decal: bool) -> Result { return Err(bad(cmd, "`width` must be positive")); } let opacity = num(p, "opacity").unwrap_or(if decal { 1.0 } else { 0.5 }).clamp(0.0, 1.0); + // It belongs to the active component (its plane is in that frame) and moves with it. + let component = s.active_component; let doc = s.doc_mut(); let id = doc.canvases.iter().map(|c| c.id).max().unwrap_or(0) + 1; let base = if decal { "Decal" } else { "Canvas" }; @@ -74,6 +76,7 @@ fn make(s: &mut Session, p: &Value, cmd: &str, decal: bool) -> Result { opacity, flip: bool_(p, "flip").unwrap_or(false), visible: true, + component, }); Ok(json!({"canvas": id, "name": name, "pixels": pixels})) } diff --git a/crates/engine/src/cmd/sketch_modify.rs b/crates/engine/src/cmd/sketch_modify.rs index 76c710e2..14d4b739 100644 --- a/crates/engine/src/cmd/sketch_modify.rs +++ b/crates/engine/src/cmd/sketch_modify.rs @@ -813,6 +813,12 @@ fn offset(s: &mut Session, p: &Value) -> Result { } let ci = sk.add_circle(cc, nr, Some(c), None)?; made.push(ci); + sk.offsets.push(solvecraft_sketch::OffsetChain { + sources: vec![(ids[0].clone(), true)], + outputs: ids_of(sk, &made), + distance: r - nr, + closed: true, + }); return Ok((ids_of(sk, &made), cons)); } let pool: Vec = if use_chain { @@ -916,7 +922,13 @@ fn offset(s: &mut Session, p: &Value) -> Result { } } } - Ok((ids_of(sk, &made), cons)) + let outputs = ids_of(sk, &made); + if pieces.iter().all(|p| !matches!(p, Piece::Free(_))) { + let sources = order.iter().filter_map(|(i, forward)| sk.curves.get(*i).map(|c| (c.id.clone(), *forward))).collect(); + sk.offsets.push(solvecraft_sketch::OffsetChain { sources, outputs: outputs.clone(), distance: d, closed }); + sk.refresh_offsets()?; + } + Ok((outputs, cons)) })?; Ok(json!({"curves": out.0, "constraints": out.1, "sketch": info})) } diff --git a/crates/engine/src/cmd/sketch_project.rs b/crates/engine/src/cmd/sketch_project.rs index c2778ced..b7ee7586 100644 --- a/crates/engine/src/cmd/sketch_project.rs +++ b/crates/engine/src/cmd/sketch_project.rs @@ -140,8 +140,20 @@ pub(super) fn add_link(s: &Session, doc: &Document, id: u64, sk: &mut Sketch, ki let plane = sketch_plane(doc, id)?; let (vals, _) = doc.param_values(); let st = s.model.state_before(id); + // The model as the sketch's component sees it. + let comp = doc.feature(id).map(|f| f.component).unwrap_or(0); + let st = solvecraft_doc::state_in_frame(doc, &st, comp); let r = resolve(doc, &vals, &st, &plane, kind, &src)?; - Ok(sk.add_link_with_wires(kind, r.source, &r.geom, &r.wires)?) + let name = if let LinkSource::Face { at, .. } = &r.source { + solvecraft_doc::naming::face_names_at(&st, &[*at]).into_iter().next().filter(|n| !n.is_empty()) + } else { + None + }; + let link = sk.add_link_with_wires(kind, r.source, &r.geom, &r.wires)?; + if let Some(l) = sk.links.iter_mut().find(|l| l.id == link) { + l.face_name = name; + } + Ok(link) } fn link_json(sk: &Sketch, link: &str) -> Value { diff --git a/crates/engine/src/frames.rs b/crates/engine/src/frames.rs index a4b2de07..b089af96 100644 --- a/crates/engine/src/frames.rs +++ b/crates/engine/src/frames.rs @@ -30,6 +30,12 @@ enum K { Plane, /// A body name, or a list of them. Body, + /// A point (or a list of picks) for the sketch being made or edited: into that sketch's + /// component frame, whichever component the geometry under it belongs to (a sketch in the + /// root on a moved component's face finds the face where it is shown). + Here, + /// A plane object for a new sketch or canvas: into the active component's frame. + HerePlane, } use K::*; @@ -56,11 +62,12 @@ fn table(id: &str) -> &'static [(&'static str, K)] { "plastic.lip" | "sheet.convert" => &[("face", Pick), ("body", Body)], "sheet.flange" | "sheet.hem" => &[("edges", Picks), ("body", Body)], "sheet.fold" => &[("points", Picks), ("fixed", Pick), ("body", Body)], - "sketch.create" | "sketch.redefine" => &[("plane", Plane)], - "canvas.decal" => &[("face", Pick)], - "sketch.intersect" => &[("refs", Picks)], - "sketch.project_to_surface" | "sketch.isoparametric_curve" => &[("face", Pick), ("body", Body)], - "sketch.intersection_curve" => &[("a", Picks), ("b", Picks)], + "sketch.create" | "sketch.redefine" => &[("plane", HerePlane)], + "canvas.decal" => &[("face", Here)], + "canvas.insert" => &[("plane", HerePlane), ("at", Here)], + "sketch.project" | "sketch.intersect" | "sketch.include_3d" => &[("refs", Here), ("ref", Here)], + "sketch.project_to_surface" | "sketch.isoparametric_curve" => &[("face", Here)], + "sketch.intersection_curve" => &[("a", Here), ("b", Here)], "inspect.curvature_comb" | "inspect.minimum_radius" | "inspect.isocurve" => &[("edges", Picks), ("faces", Picks)], "parts.insert" | "parts.fastener" => &[("at", Pick), ("point", Make), ("direction", Dir)], "appearance.assign" => &[("faces", Picks), ("bodies", Body), ("body", Body)], @@ -75,6 +82,8 @@ fn table(id: &str) -> &'static [(&'static str, K)] { struct Frames { bodies: Vec<(String, String, Mat)>, active: Mat, + /// The frame of the sketch being edited (its component), else the active component's. + sketch: Mat, } fn frames(s: &Session) -> Frames { @@ -104,7 +113,8 @@ fn frames(s: &Session) -> Frames { (world, own, m) }) .collect(); - Frames { bodies, active: doc.component_transform(s.active_component) } + let sketch_comp = s.active_sketch.and_then(|id| doc.feature(id)).map(|f| f.component).unwrap_or(s.active_component); + Frames { bodies, active: doc.component_transform(s.active_component), sketch: doc.component_transform(sketch_comp) } } /// Does any placement move anything (so the world differs from the components' frames)? @@ -171,12 +181,14 @@ struct Mapper<'a> { /// The frame of the command's first pick (its directions turn with it). first: Option, changed: bool, + /// Picks go into the sketch's frame (`Here`), not the frame of the body under them. + here: bool, } impl Mapper<'_> { fn pick(&mut self, v: &Value, body: Option<&str>) -> Option { let p = vec3(v)?; - let m = frame_at(self.s, &self.f, p, body).unwrap_or(self.f.active); + let m = if self.here { self.f.sketch } else { frame_at(self.s, &self.f, p, body).unwrap_or(self.f.active) }; self.first.get_or_insert(m); self.local_point(&m, p) } @@ -325,14 +337,14 @@ pub fn to_local(s: &Session, id: &str, params: &Value) -> Option { return None; } let obj = params.as_object()?; - let mut m = Mapper { s, f: frames(s), first: None, changed: false }; + let mut m = Mapper { s, f: frames(s), first: None, changed: false, here: false }; let body = obj.get("body").and_then(Value::as_str).map(str::to_string); let mut out: Map = obj.clone(); // Picks first: their frame turns the directions. for pass in [true, false] { for (k, kind) in keys { let Some(v) = obj.get(*k) else { continue }; - let is_pick = matches!(kind, Pick | Picks | Plane); + let is_pick = matches!(kind, Pick | Picks | Plane | Here | HerePlane); if is_pick != pass { continue; } @@ -343,6 +355,19 @@ pub fn to_local(s: &Session, id: &str, params: &Value) -> Option { Dir => m.dir(v), Plane => m.plane(v), Body => m.body(v), + Here | HerePlane => { + // A new sketch or canvas goes into the active component. + let keep = m.f.sketch; + if *kind == HerePlane { + m.f.sketch = m.f.active; + } + m.here = true; + // Body names stay: the sketch's view of the model keeps them. + let r = if *kind == HerePlane { m.plane(v) } else { m.picks(v, None) }; + m.here = false; + m.f.sketch = keep; + r + } }; if let Some(n) = new { out.insert((*k).to_string(), n); diff --git a/crates/engine/src/frames_tests.rs b/crates/engine/src/frames_tests.rs index df64a15f..751efdf1 100644 --- a/crates/engine/src/frames_tests.rs +++ b/crates/engine/src/frames_tests.rs @@ -144,3 +144,106 @@ fn sketch_on_a_face_follows_a_moved_body() { let c = sketch_point_world(&mut s, "OnTop", "p1"); assert!((c.z - 25.0).abs() < 1e-6, "{c:?}"); } + +/// A 1 x 1 PNG for canvases. +const PNG: &str = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="; + +/// Canvases belong to the active component and move with its occurrence; one put on a moved +/// component's face from the root sits on the face (and stays the root's). +#[test] +fn canvases_move_with_their_component() { + let mut s = moved_part(); + let part = s.active_component; + assert_ne!(part, 0); + run(&mut s, "canvas.insert", json!({"data": PNG, "plane": "XY", "name": "Plan"})); + // From the root, on the moved block's top face (world). + run(&mut s, "component.activate", json!({"component": "root"})); + run(&mut s, "canvas.insert", json!({"data": PNG, "plane": {"face": [65, 10, 10]}, "name": "Lid", "width": 10})); + run(&mut s, "canvas.insert", json!({"data": PNG, "plane": "XZ", "name": "Root"})); + let (vals, _) = s.doc.param_values(); + let world = |s: &Session, name: &str| { + let c = s.doc.canvases.iter().find(|c| c.name == name).unwrap(); + (c.component, s.doc.canvas_plane(&vals, c).unwrap()) + }; + let (c, p) = world(&s, "Plan"); + assert_eq!(c, part); + assert!(near(p.origin, Vec3::new(50.0, 0.0, 0.0)), "{:?}", p.origin); + let (c, p) = world(&s, "Lid"); + assert_eq!(c, 0, "the active component's"); + let lid = s.doc.canvases.iter().find(|c| c.name == "Lid").unwrap(); + let centre = p.to_world(lid.center); + assert!(near(centre, Vec3::new(65.0, 10.0, 10.0)), "{centre:?}"); + assert_eq!(world(&s, "Root").0, 0); + // Moving the occurrence carries its canvases, not the root's. + run(&mut s, "occurrence.move", json!({"occurrence": "Part:1", "translate": [0, 40, 0]})); + let (vals, _) = s.doc.param_values(); + let plan = s.doc.canvases.iter().find(|c| c.name == "Plan").unwrap(); + assert!(near(s.doc.canvas_plane(&vals, plan).unwrap().origin, Vec3::new(50.0, 40.0, 0.0))); + let lid = s.doc.canvases.iter().find(|c| c.name == "Lid").unwrap(); + let centre = s.doc.canvas_plane(&vals, lid).unwrap().to_world(lid.center); + assert!(near(centre, Vec3::new(65.0, 10.0, 10.0)), "{centre:?}"); + let root = s.doc.canvases.iter().find(|c| c.name == "Root").unwrap(); + assert!(near(s.doc.canvas_plane(&vals, root).unwrap().origin, Vec3::ZERO)); + // The component survives a save and reopen. + let back = solvecraft_doc::Document::from_json(&s.doc.to_json()).unwrap(); + assert_eq!(back.canvases, s.doc.canvases); +} + +/// World points of a sketch's curves' points (sorted). +fn sketch_world_points(s: &mut Session, sketch: &str) -> Vec { + let si = run(s, "sketch.inspect", json!({ "sketch": sketch })); + si["points"] + .as_array() + .unwrap() + .iter() + .map(|p| { + let w = &p["world"]; + Vec3::new(w[0].as_f64().unwrap(), w[1].as_f64().unwrap(), w[2].as_f64().unwrap()) + }) + .collect() +} + +/// A block "C" (40 x 30 x 20) in its own component, the root active again. +fn block_in_component() -> Session { + let mut s = Session::default(); + run(&mut s, "component.create", json!({"name": "C"})); + run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20})); + run(&mut s, "component.activate", json!({"component": "root"})); + s +} + +/// The user's "big square": a sketch made in the root on a moved component's face lies on the +/// face where it is shown, its projected loop on the face's edges (moved and turned), and it +/// follows when the occurrence moves on. +#[test] +fn root_sketch_on_a_moved_components_face() { + let mut s = block_in_component(); + run(&mut s, "occurrence.move", json!({"occurrence": "C:1", "translate": [100, 0, 0]})); + let r = run(&mut s, "sketch.create", json!({"plane": {"face": [120, 15, 20]}, "name": "Top"})); + assert!(!r["projected"].is_null(), "the face's edges are projected: {r}"); + run(&mut s, "sketch.finish", json!({})); + let pts = sketch_world_points(&mut s, "Top"); + assert!(pts.len() >= 4, "{pts:?}"); + // Every point but the sketch's origin (the model origin on the face plane). + for p in pts.iter().filter(|p| !near(**p, Vec3::new(0.0, 0.0, 20.0))) { + assert!((p.z - 20.0).abs() < 1e-6 && p.x > 100.0 - 1e-6 && p.x < 140.0 + 1e-6 && p.y > -1e-6 && p.y < 30.0 + 1e-6, "{p:?}"); + } + for corner in [Vec3::new(100.0, 0.0, 20.0), Vec3::new(140.0, 30.0, 20.0)] { + assert!(pts.iter().any(|p| near(*p, corner)), "{corner:?} in {pts:?}"); + } + assert_eq!(s.doc.find_feature("Top").unwrap().component, 0, "the sketch is the root's"); + + // Turned 90 degrees about Z (around the world origin): the top face is now x -30..0, y 0..40. + let mut s = block_in_component(); + run(&mut s, "occurrence.move", json!({"occurrence": "C:1", "axis": [0, 0, 1], "angle": "90 deg", "origin": [0, 0, 0]})); + run(&mut s, "sketch.create", json!({"plane": {"face": [-15, 20, 20]}, "name": "Top"})); + run(&mut s, "sketch.finish", json!({})); + let pts = sketch_world_points(&mut s, "Top"); + for corner in [Vec3::new(0.0, 0.0, 20.0), Vec3::new(-30.0, 40.0, 20.0)] { + assert!(pts.iter().any(|p| near(*p, corner)), "{corner:?} in {pts:?}"); + } + // Projected geometry stays on the face when the occurrence moves on (the link re-resolves). + run(&mut s, "occurrence.move", json!({"occurrence": "C:1", "translate": [0, 0, 5]})); + let pts = sketch_world_points(&mut s, "Top"); + assert!(pts.iter().any(|p| near(*p, Vec3::new(-30.0, 40.0, 25.0))), "{pts:?}"); +} diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 0311b032..3c4a6714 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -20,6 +20,21 @@ fn rel(a: f64, b: f64) -> f64 { (a - b).abs() / b.abs().max(1e-12) } +#[test] +fn join_extrude_from_a_chamfered_top_face() { + let mut s = Session::default(); + run(&mut s, "sketch.create", json!({"plane": "XY"})); + run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 10})); + run(&mut s, "solid.extrude", json!({"distance": 20})); + run(&mut s, "solid.chamfer", json!({"edges": [[10, 0, 20]], "distance": 2})); + let base = volume(&mut s); + run(&mut s, "sketch.create", json!({"plane": {"face": [0, 0, 20]}})); + run(&mut s, "sketch.finish", json!({})); + run(&mut s, "solid.extrude", json!({"distance": 5, "operation": "join"})); + assert_eq!(s.model.state().bodies.len(), 1); + assert!(rel(volume(&mut s), base + PI * 64.0 * 5.0) < 5e-4); +} + mod component_frames; mod robustness; @@ -650,10 +665,10 @@ fn section_analysis() { assert!(s.execute("inspect.section", &json!({"plane": {"normal": [0, 0, 0]}})).is_err()); run(&mut s, "inspect.section", json!({"clear": true})); assert!(s.section.is_none()); - // XZ's normal is -Y: an offset moves the cut to -Y, `at` places it at a world Y, and the + // XZ's normal is +Y: an offset moves the cut to +Y, `at` places it at a world Y, and the // result says where the cut landed either way. let r = run(&mut s, "inspect.section", json!({"plane": "XZ", "offset": 10})); - assert_eq!((r["section"]["axis"].as_str(), r["section"]["at"].as_f64()), (Some("Y"), Some(-10.0)), "{r}"); + assert_eq!((r["section"]["axis"].as_str(), r["section"]["at"].as_f64()), (Some("Y"), Some(10.0)), "{r}"); for (plane, at, flip) in [("XZ", -282.5, false), ("XZ", 7.0, true), ("XY", 3.0, false), ("YZ", -4.0, true)] { let r = run(&mut s, "inspect.section", json!({"plane": plane, "at": at, "flip": flip})); assert_eq!(r["section"]["at"].as_f64(), Some(at), "{plane} {r}"); diff --git a/crates/geom/src/plane.rs b/crates/geom/src/plane.rs index d644e390..ee51a010 100644 --- a/crates/geom/src/plane.rs +++ b/crates/geom/src/plane.rs @@ -17,8 +17,8 @@ pub struct Plane { impl Plane { /// Top: sketch x = +X, y = +Y, normal +Z. pub const XY: Plane = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Y }; - /// Front: sketch x = +X, y = +Z, normal −Y. - pub const XZ: Plane = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Z }; + /// Front: sketch x = +X, y = −Z, normal +Y. + pub const XZ: Plane = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::new(0.0, 0.0, -1.0) }; /// Right: sketch x = +Y, y = +Z, normal +X. pub const YZ: Plane = Plane { origin: Vec3::ZERO, x: Vec3::Y, y: Vec3::Z }; diff --git a/crates/geom/src/tests.rs b/crates/geom/src/tests.rs index 5fe4e25b..af1b6f68 100644 --- a/crates/geom/src/tests.rs +++ b/crates/geom/src/tests.rs @@ -28,10 +28,10 @@ fn raycast_hits_front_face() { #[test] fn planes() { assert_eq!(Plane::XY.normal(), Vec3::Z); - assert_eq!(Plane::XZ.normal(), Vec3::new(0.0, -1.0, 0.0)); + assert_eq!(Plane::XZ.normal(), Vec3::Y); assert_eq!(Plane::YZ.normal(), Vec3::X); let p = Plane::XZ.to_world(Vec2::new(3.0, 4.0)); - assert_eq!(p, Vec3::new(3.0, 0.0, 4.0)); + assert_eq!(p, Vec3::new(3.0, 0.0, -4.0)); assert_eq!(Plane::XZ.to_local(p), Vec2::new(3.0, 4.0)); let hit = Plane::XY.offset(5.0).intersect_ray(Vec3::new(1.0, 2.0, 10.0), Vec3::new(0.0, 0.0, -2.0)).unwrap(); assert!(hit.dist(Vec3::new(1.0, 2.0, 5.0)) < 1e-12); diff --git a/crates/kernel/src/iges_in/tests.rs b/crates/kernel/src/iges_in/tests.rs index cf3e2594..cd9a832e 100644 --- a/crates/kernel/src/iges_in/tests.rs +++ b/crates/kernel/src/iges_in/tests.rs @@ -150,7 +150,8 @@ fn a_drill_point_round_trips_through_iges() { let plate = box_solid(Vec3::new(-20.0, -15.0, 0.0), Vec3::new(20.0, 15.0, 10.0)).unwrap(); let profile = Region2 { outer: Loop2::polygon(&[Vec2::new(0.0, 2.0), Vec2::new(4.0, 5.0), Vec2::new(4.0, 11.0), Vec2::new(0.0, 11.0)]), holes: vec![] }; - let hole = crate::revolve(&Plane::XZ, &[profile], Vec2::ZERO, Vec2::new(0.0, 1.0), std::f64::consts::TAU).unwrap().pop().unwrap(); + let plane = Plane { y: Vec3::Z, ..Plane::XZ }; // Positive profile heights are world +Z. + let hole = crate::revolve(&plane, &[profile], Vec2::ZERO, Vec2::new(0.0, 1.0), std::f64::consts::TAU).unwrap().pop().unwrap(); let drilled = boolean(&plate, &hole, BoolOp::Cut).unwrap().unwrap(); let v = 12000.0 - std::f64::consts::PI * 16.0 * (5.0 + 1.0); assert!(rel(measure(&drilled).unwrap().volume, v) < 1e-3); diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs index 44344d4d..f0e8e878 100644 --- a/crates/kernel/src/lib.rs +++ b/crates/kernel/src/lib.rs @@ -61,7 +61,7 @@ pub use lip::raise_band; pub use measure::{BodyMeasure, measure}; pub use meshbody::{MAX_TRIANGLES, mesh_body}; pub use offset::with_same_surface; -pub use ops::{BoolOp, boolean, split_by_plane, transform, transform_matrix}; +pub use ops::{BoolOp, boolean, can_join_touching_faces, split_by_plane, transform, transform_matrix}; pub use polybool::{faceted_boolean, planar_boolean}; pub use polyhedron::{HalfSpace, convex_polyhedron, draft, offset_faces, shell}; pub use sew::{EdgeSpec, FaceSpec, SurfSpec, sew}; diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rs index ec3dc7a6..b812cbb7 100644 --- a/crates/kernel/src/ops.rs +++ b/crates/kernel/src/ops.rs @@ -15,6 +15,12 @@ pub enum BoolOp { Intersect, } +/// Whether a union can sew two matching planar faces without intersecting them. +/// Callers can retain the exact touching tool instead of extending it into material. +pub fn can_join_touching_faces(a: &Body, b: &Body) -> bool { + a.solid.boundaries().len() == 1 && b.solid.boundaries().len() == 1 && crate::coplanar::glue(a, b).is_some_and(|r| r.is_ok()) +} + /// Shifts applied to both operands on retries. The boolean classifies some faces by casting a /// ray whose direction is derived from point coordinates; moving both solids (and the result /// back) leaves the geometry unchanged but changes those rays. @@ -46,7 +52,10 @@ fn mismatch(a: &solvecraft_geom::Mesh, b: &solvecraft_geom::Mesh, result: &solve let hi = ba.max.min(bb.max); let all = ba.union(&bb); let mut boxes = vec![(all, 300usize)]; - if lo.x < hi.x && lo.y < hi.y && lo.z < hi.z { + // A touching seam can overlap by round-off only. Samples there sit on the + // operands' boundaries, where ray parity cannot classify membership reliably. + let gap = all.diagonal().max(1.0) * 1e-9; + if hi.x - lo.x > gap && hi.y - lo.y > gap && hi.z - lo.z > gap { boxes.push((solvecraft_geom::Aabb3 { min: lo, max: hi }, 900)); } let (ia_idx, ib_idx, ir_idx) = (a.inside_index(), b.inside_index(), result.inside_index()); diff --git a/crates/kernel/src/prism.rs b/crates/kernel/src/prism.rs index 1bf6c30a..b5a75d95 100644 --- a/crates/kernel/src/prism.rs +++ b/crates/kernel/src/prism.rs @@ -77,6 +77,7 @@ fn prism_of(b: &Body, d: Vec3, plane: &Plane, tol: f64) -> Option { let mut hi = f64::NEG_INFINITY; let mut tops: Vec<&mt::Face> = Vec::new(); let mut top_h = Vec::new(); + let mut bottom_h = Vec::new(); for f in b.solid.face_iter() { let surf = f.oriented_surface(); if let mt::Surface::Plane(p) = &surf { @@ -90,6 +91,7 @@ fn prism_of(b: &Body, d: Vec3, plane: &Plane, tol: f64) -> Option { continue; } if n.dot(d) < -1.0 + 1e-9 { + bottom_h.push(h); lo = lo.min(h); continue; } @@ -110,7 +112,7 @@ fn prism_of(b: &Body, d: Vec3, plane: &Plane, tol: f64) -> Option { } } // One height for every top (and bottom) cap. - if top_h.iter().any(|h| (h - hi).abs() > tol) || !(lo.is_finite() && hi > lo + tol) { + if top_h.iter().any(|h| (h - hi).abs() > tol) || bottom_h.iter().any(|h| (h - lo).abs() > tol) || !(lo.is_finite() && hi > lo + tol) { return None; } let mut regions = Vec::new(); @@ -382,6 +384,129 @@ fn boolean2d(a: &[Region2], b: &[Region2], op: BoolOp, tol: f64) -> Option Option> { + if !matches!(seg, Seg2::Line { .. } | Seg2::Arc { .. }) { + return None; + } + let mut ts: Vec = pts + .iter() + .filter_map(|p| { + let t = seg.closest_param(*p); + (t > 1e-9 && t < 1.0 - 1e-9 && seg.point_at(t).dist(*p) < tol).then_some(t) + }) + .collect(); + ts.sort_by(f64::total_cmp); + ts.dedup_by(|x, y| (*x - *y).abs() < 1e-9); + let mut out = Vec::new(); + let mut t0 = 0.0; + for t1 in ts.into_iter().chain(std::iter::once(1.0)) { + out.push(match *seg { + Seg2::Line { .. } => Seg2::Line { a: seg.point_at(t0), b: seg.point_at(t1) }, + Seg2::Arc { center, radius, start, sweep } => Seg2::Arc { center, radius, start: start + sweep * t0, sweep: sweep * (t1 - t0) }, + _ => return None, + }); + t0 = t1; + } + Some(out) +} + +/// The union of two prisms along `d` stacked end to end (or overlapping) with different +/// sections, sewn from its faces: each slab between the prisms' end levels has walls over its +/// section's outline; each level has a face up over the section below less the one above, and +/// a face down over the one above less the one below. Every outline is split where any other +/// meets it, so the faces share their edges. `None` when a slab is empty or a curve isn't a +/// line or an arc. +fn sew_stack(plane: &Plane, d: Vec3, pa: &Prism, pb: &Prism, tol: f64) -> Option> { + use crate::sew::{EdgeSpec, FaceSpec, SurfSpec}; + let mut levels = vec![pa.lo, pa.hi, pb.lo, pb.hi]; + levels.sort_by(f64::total_cmp); + levels.dedup_by(|x, y| (*x - *y).abs() < tol); + let covers = |p: &Prism, z0: f64, z1: f64| p.lo <= z0 + tol && p.hi >= z1 - tol; + let mut slabs: Vec> = Vec::new(); + for w in levels.windows(2) { + let (z0, z1) = (*w.first()?, *w.get(1)?); + let s = match (covers(pa, z0, z1), covers(pb, z0, z1)) { + (true, true) => boolean2d(&pa.regions, &pb.regions, BoolOp::Union, tol)?, + (true, false) => pa.regions.clone(), + (false, true) => pb.regions.clone(), + (false, false) => return None, + }; + slabs.push(oriented(&s)); + } + // Faces at each level: up where the slab below sticks out, down where the one above does. + let diff = |x: &[Region2], y: &[Region2]| -> Option> { + match (x.is_empty(), y.is_empty()) { + (true, _) => Some(Vec::new()), + (false, true) => Some(x.to_vec()), + (false, false) => boolean2d(x, y, BoolOp::Cut, tol).map(|r| oriented(&r)), + } + }; + let mut caps: Vec<(f64, bool, Vec)> = Vec::new(); + for (k, z) in levels.iter().enumerate() { + let below: &[Region2] = if k == 0 { &[] } else { slabs.get(k - 1)? }; + let above: &[Region2] = slabs.get(k).map(Vec::as_slice).unwrap_or(&[]); + caps.push((*z, true, diff(below, above)?)); + caps.push((*z, false, diff(above, below)?)); + } + // Every segment end, everywhere: outlines split there. + let loops_of = + |rs: &[Region2]| -> Vec { rs.iter().flat_map(|r| std::iter::once(r.outer.clone()).chain(r.holes.iter().cloned())).collect() }; + let mut pts: Vec = Vec::new(); + for lp in slabs.iter().flat_map(|s| loops_of(s)).chain(caps.iter().flat_map(|c| loops_of(&c.2))) { + for sg in &lp.segs { + pts.push(sg.start()); + pts.push(sg.end()); + } + } + let at = |u: Vec2, z: f64| plane.to_world(u) + d * z; + let edge = |sg: &Seg2, z: f64| -> EdgeSpec { + match sg { + Seg2::Arc { .. } => EdgeSpec::Arc { a: at(sg.start(), z), b: at(sg.end(), z), mid: at(sg.point_at(0.5), z) }, + _ => EdgeSpec::Line { a: at(sg.start(), z), b: at(sg.end(), z) }, + } + }; + let mut faces: Vec = Vec::new(); + for (i, s) in slabs.iter().enumerate() { + let (z0, z1) = (*levels.get(i)?, *levels.get(i + 1)?); + for lp in loops_of(s) { + for sg0 in &lp.segs { + for sg in split_seg(sg0, &pts, tol)? { + let (a, b) = (sg.start(), sg.end()); + let lp3 = vec![ + edge(&sg, z0), + EdgeSpec::Line { a: at(b, z0), b: at(b, z1) }, + edge(&sg.reversed(), z1), + EdgeSpec::Line { a: at(a, z1), b: at(a, z0) }, + ]; + let tangent = plane.dir_to_world(sg.derivative(0.5)); + let outward = tangent.cross(d).normalized()?; + let surface = match sg { + Seg2::Arc { .. } => SurfSpec::Extruded { a: at(a, z0), b: at(b, z0), mid: at(sg.point_at(0.5), z0), dir: d * (z1 - z0) }, + _ => SurfSpec::Plane, + }; + faces.push(FaceSpec { loops: vec![lp3], surface, probe: Some((at(sg.point_at(0.5), (z0 + z1) / 2.0), outward)) }); + } + } + } + } + for (z, up, rs) in &caps { + for r in rs { + let mut loops = Vec::new(); + for lp in std::iter::once(&r.outer).chain(&r.holes) { + let mut segs: Vec = Vec::new(); + for sg in &lp.segs { + segs.extend(split_seg(sg, &pts, tol)?); + } + let segs: Vec = if *up { segs } else { segs.iter().rev().map(Seg2::reversed).collect() }; + loops.push(segs.iter().map(|sg| edge(sg, *z)).collect::>()); + } + faces.push(FaceSpec { loops, surface: SurfSpec::Plane, probe: None }); + } + } + Some(crate::sew::sew(&faces)) +} + pub(crate) fn prism_boolean(a: &Body, b: &Body, op: BoolOp) -> Option>> { let size = a.size().max(b.size()); let tol = (size * 1e-7).max(1e-9) * 10.0; @@ -423,10 +548,10 @@ pub(crate) fn prism_boolean(a: &Body, b: &Body, op: BoolOp) -> Option tol * (1.0 + u) || (u - y).abs() > tol * (1.0 + u) { - return None; + return sew_stack(&plane, d, &pa, &pb, tol).map(|r| r.map(Some)); } (pa.lo.min(pb.lo), pa.hi.max(pb.hi)) } else { diff --git a/crates/kernel/src/splitface.rs b/crates/kernel/src/splitface.rs index 6eeab3dd..c3432651 100644 --- a/crates/kernel/src/splitface.rs +++ b/crates/kernel/src/splitface.rs @@ -1208,7 +1208,7 @@ mod tests { let m0 = measure(&c).unwrap(); let side = c.faces(0.01).unwrap().iter().position(|f| f.plane_normal.is_none()).unwrap(); // A horizontal line seen from the front (XZ sketch) at z = 5, swept along y. - let xz = Plane::XZ; + let xz = Plane { y: Vec3::Z, ..Plane::XZ }; let tool = SplitTool::Curves { plane: xz, curves: vec![vec![Seg2::Line { a: Vec2::new(-20.0, 5.0), b: Vec2::new(20.0, 5.0) }]] }; let s = split_faces(&c, &[side], &tool).unwrap(); let m = measure(&s).unwrap(); diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rs index 28e53b71..869a2639 100644 --- a/crates/kernel/src/tests.rs +++ b/crates/kernel/src/tests.rs @@ -40,8 +40,8 @@ fn extrude_on_other_planes_and_offsets() { let b = extrude(&Plane::XZ, &[rect(10.0, 5.0)], -2.0, 3.0).unwrap().pop().unwrap(); let m = measure(&b).unwrap(); assert!(rel(m.volume, 250.0) < 1e-9); - // XZ normal is -Y: the body spans y in [-3, 2]. - assert!((m.bbox.min.y + 3.0).abs() < 1e-6 && (m.bbox.max.y - 2.0).abs() < 1e-6, "{:?}", m.bbox); + // XZ normal is +Y: the body spans y in [-2, 3]. + assert!((m.bbox.min.y + 2.0).abs() < 1e-6 && (m.bbox.max.y - 3.0).abs() < 1e-6, "{:?}", m.bbox); } #[test] @@ -52,6 +52,39 @@ fn region_with_hole() { assert!(rel(m.volume, (1200.0 - PI * 25.0) * 10.0) < 5e-4, "{}", m.volume); } +#[test] +fn through_cut_preserves_a_larger_blind_pocket() { + let plate = box_solid(Vec3::new(-30.0, -28.0, 0.0), Vec3::new(60.0, 22.0, 8.0)).unwrap(); + let pocket = cylinder(Vec3::ZERO, Vec3::Z, 11.0, 6.0).unwrap(); + let through = cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, 9.5, 10.0).unwrap(); + let expected = 90.0 * 50.0 * 8.0 - PI * 11.0_f64.powi(2) * 6.0 - PI * 9.5_f64.powi(2) * 2.0; + for reverse in [false, true] { + let (first, second) = if reverse { (&through, &pocket) } else { (&pocket, &through) }; + let cut = boolean(&plate, first, BoolOp::Cut).unwrap().unwrap(); + let result = boolean(&cut, second, BoolOp::Cut).unwrap().unwrap(); + let m = measure(&result).unwrap(); + assert!(rel(m.volume, expected) < 5e-4, "reverse={reverse}: {} vs {expected}", m.volume); + assert_eq!(m.merged.faces, 9); + assert!(!result.tessellate(0.01).unwrap().contains(Vec3::new(10.0, 0.0, 3.0))); + } +} + +#[test] +fn join_a_cylinder_on_its_chamfered_top() { + for seam in [0.0, crate::build::SEAM_ANGLE] { + let region = Region2 { outer: Loop2::circle_from(Vec2::ZERO, 10.0, seam), holes: vec![] }; + let base = extrude(&Plane::XY, &[region], 0.0, 20.0).unwrap().pop().unwrap(); + let base = chamfer(&base, &[Vec3::new(10.0, 0.0, 20.0)], 2.0).unwrap(); + let region = Region2 { outer: Loop2::circle_from(Vec2::new(0.0, -3.774758283725534e-15), 8.0, seam), holes: vec![] }; + let plane = Plane { origin: Vec3::new(0.0, 0.0, 20.000000000000007), ..Plane::XY }; + let tool = extrude(&plane, &[region], 0.0, 5.0).unwrap().pop().unwrap(); + let expected = measure(&base).unwrap().volume + PI * 64.0 * 5.0; + let joined = boolean(&base, &tool, BoolOp::Union).unwrap().unwrap(); + assert!(rel(measure(&joined).unwrap().volume, expected) < 5e-4); + assert_eq!(joined.lumps().unwrap().len(), 1); + } +} + #[test] fn box_fillet_cut_volume() { let b = box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 20.0)).unwrap(); @@ -1344,7 +1377,8 @@ fn boolean_identity_survey() { fn partial_revolve_on_the_axis() { let sq = Region2 { outer: Loop2::polygon(&[Vec2::new(0.0, 0.0), Vec2::new(20.0, 0.0), Vec2::new(20.0, 7.5), Vec2::new(0.0, 7.5)]), holes: vec![] }; - let pie = revolve(&Plane::XZ, &[sq], Vec2::ZERO, Vec2::Y, std::f64::consts::FRAC_PI_2).unwrap().pop().unwrap(); + let plane = Plane { y: Vec3::Z, ..Plane::XZ }; // This fixture's rectangle is above z = 0. + let pie = revolve(&plane, &[sq], Vec2::ZERO, Vec2::Y, std::f64::consts::FRAC_PI_2).unwrap().pop().unwrap(); assert!(pie.validity().is_empty(), "{:?}", pie.validity()); let v = measure(&pie).unwrap().volume; assert!((v - PI * 400.0 / 4.0 * 7.5).abs() < 1e-3 * v, "{v}"); diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rs index 7e507456..81d8af22 100644 --- a/crates/sketch/src/lib.rs +++ b/crates/sketch/src/lib.rs @@ -13,6 +13,7 @@ mod dims; mod linalg; mod link; mod model; +mod offset; mod profiles; mod shape; mod solver; @@ -25,6 +26,7 @@ pub use curves::{ pub use dims::{DimFrame, DimLayout, chain_centres, default_text, dim_frame, dim_layout, encode_text}; pub use link::{Link, LinkGeom, LinkKind, LinkSource, MAX_LINK_ENTITIES}; pub use model::{Constraint, ConstraintKind, Curve, CurveKind, SPoint, Sketch, SketchError, SketchView}; +pub use offset::OffsetChain; pub use profiles::{Profile, find_drawn_profiles, find_profiles, merge_regions}; pub use shape::{Shape, intersections}; pub use solver::{Hold, SolveReport, SolveStatus, solve, solve_holding}; diff --git a/crates/sketch/src/link.rs b/crates/sketch/src/link.rs index a7b3fe42..c02ce3da 100644 --- a/crates/sketch/src/link.rs +++ b/crates/sketch/src/link.rs @@ -104,6 +104,9 @@ pub struct Link { #[serde(default)] pub kind: LinkKind, pub source: LinkSource, + /// Persistent model face identity, resolved by the document before geometry refresh. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub face_name: Option, /// The reference could not be found on the last recompute; the geometry is the last good one. #[serde(default, skip_serializing_if = "std::ops::Not::not")] pub lost: bool, @@ -169,7 +172,7 @@ struct Layout { curves: Vec, } -#[derive(Clone, Copy, PartialEq)] +#[derive(Clone, Copy, Debug, PartialEq)] enum LCurve { Line(usize, usize), Circle(usize, f64), @@ -368,7 +371,7 @@ impl Sketch { return Err(SketchError::TooLarge); } let id = self.fresh("j"); - self.links.push(Link { id: id.clone(), kind, source, lost: false }); + self.links.push(Link { id: id.clone(), kind, source, face_name: None, lost: false }); self.build_link(&id, &lay)?; Ok(id) } @@ -579,6 +582,77 @@ impl Sketch { return Ok(false); } } + // A resized face can enumerate the same boundary in another order. Match the + // shared-point graph in normalized sketch space before discarding its identity. + if let Some(cur) = &cur + && points.len() == lay.pts.len() + && cur.len() == lay.curves.len() + && points.len() <= 512 + { + let old: Vec = points.iter().filter_map(|i| self.point(*i)).collect(); + let normalized = |ps: &[Vec2]| -> Vec { + let lo = ps.iter().fold(Vec2::new(f64::INFINITY, f64::INFINITY), |a, p| Vec2::new(a.x.min(p.x), a.y.min(p.y))); + let hi = ps.iter().fold(Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY), |a, p| Vec2::new(a.x.max(p.x), a.y.max(p.y))); + ps.iter().map(|p| Vec2::new((p.x - lo.x) / (hi.x - lo.x).max(1e-9), (p.y - lo.y) / (hi.y - lo.y).max(1e-9))).collect() + }; + let (a, b) = (normalized(&old), normalized(&lay.pts)); + let mut mapping = Vec::new(); + for p in &a { + let mut candidates: Vec<(usize, f64)> = b.iter().enumerate().map(|(i, q)| (i, p.dist(*q))).collect(); + candidates.sort_by(|x, y| x.1.total_cmp(&y.1)); + if let Some((i, d)) = candidates.first() + && *d < 0.1 + && candidates.get(1).is_none_or(|(_, second)| *d < *second * 0.5) + && !mapping.contains(i) + { + mapping.push(*i); + } else { + break; + } + } + let mut used = Vec::new(); + let mut curve_map = Vec::new(); + if mapping.len() == points.len() { + for c in cur { + let mapped: Option> = curve_points(c).iter().map(|i| mapping.get(*i).copied()).collect(); + let found = lay + .curves + .iter() + .enumerate() + .find(|(i, fresh)| { + if used.contains(i) || !same_shape(c, fresh) { + return false; + } + let fresh_pts = curve_points(fresh); + mapped.as_ref().is_some_and(|p| { + *p == fresh_pts || matches!(c, LCurve::Line(..)) && p.iter().rev().copied().collect::>() == fresh_pts + }) + }) + .map(|(i, _)| i); + if let Some(i) = found { + used.push(i); + curve_map.push(i); + } else { + break; + } + } + } + if curve_map.len() == cur.len() && mapping.len() == points.len() { + for (pi, li) in points.iter().zip(mapping) { + if let (Some(p), Some(q)) = (self.points.get_mut(*pi), lay.pts.get(li)) { + p.pos = *q; + } + } + for (ci, li) in curves.iter().zip(curve_map) { + if let (Some(Curve { kind: CurveKind::Circle { r, .. }, .. }), Some(LCurve::Circle(_, value))) = + (self.curves.get_mut(*ci), lay.curves.get(li)) + { + *r = *value; + } + } + return Ok(false); + } + } // Rebuild: drop the old entities (constraints on them go too) and make new ones. self.drop_link_entities(id); self.build_link(id, &lay)?; diff --git a/crates/sketch/src/model.rs b/crates/sketch/src/model.rs index 844bc999..d86535fb 100644 --- a/crates/sketch/src/model.rs +++ b/crates/sketch/src/model.rs @@ -467,6 +467,8 @@ pub struct Sketch { /// Links to geometry outside the sketch (projections, intersections, includes). #[serde(default, skip_serializing_if = "Vec::is_empty")] pub links: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub offsets: Vec, /// 3D curves (world coordinates) carried by the sketch. #[serde(default, skip_serializing_if = "Vec::is_empty")] pub wires: Vec, @@ -495,6 +497,7 @@ impl Sketch { curves: Vec::new(), constraints: Vec::new(), links: Vec::new(), + offsets: Vec::new(), wires: Vec::new(), counters: Default::default(), view: SketchView::default(), diff --git a/crates/sketch/src/offset.rs b/crates/sketch/src/offset.rs new file mode 100644 index 00000000..b3f06455 --- /dev/null +++ b/crates/sketch/src/offset.rs @@ -0,0 +1,116 @@ +//! Associative offsets keep their output entity ids while their source curves move. +use crate::{CurveKind, Shape, Sketch, SketchError, intersections}; +use serde::{Deserialize, Serialize}; +use solvecraft_geom::Vec2; + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct OffsetChain { + pub sources: Vec<(String, bool)>, + pub outputs: Vec, + pub distance: f64, + pub closed: bool, +} + +impl Sketch { + pub fn refresh_offsets(&mut self) -> Result<(), SketchError> { + for offset in self.offsets.clone() { + if offset.sources.len() != offset.outputs.len() || offset.sources.len() > 10_000 || !offset.distance.is_finite() { + return Err(SketchError::Invalid("damaged offset chain".into())); + } + let bad = || SketchError::Invalid("an offset source vanished or changed shape".into()); + let mut pieces = Vec::new(); + for (id, forward) in &offset.sources { + let i = self.curve_index(id).ok_or_else(bad)?; + let kind = &self.curves.get(i).ok_or_else(bad)?.kind; + let piece = match *kind { + CurveKind::Line { a, b } => { + let (a, b) = (self.point(a).ok_or_else(bad)?, self.point(b).ok_or_else(bad)?); + let (a, b) = if *forward { (a, b) } else { (b, a) }; + let n = (b - a).normalized().ok_or_else(bad)?.perp() * offset.distance; + (Shape::Line { a: a + n, b: b + n }, a + n, b + n) + } + CurveKind::Arc { c, a, b } => { + let (c, a, b) = (self.point(c).ok_or_else(bad)?, self.point(a).ok_or_else(bad)?, self.point(b).ok_or_else(bad)?); + let r = c.dist(a) - if *forward { offset.distance } else { -offset.distance }; + if r <= 1e-9 { + return Err(SketchError::Invalid("the offset collapses an arc".into())); + } + let a = c + (a - c).normalized().ok_or_else(bad)? * r; + let b = c + (b - c).normalized().ok_or_else(bad)? * r; + let (a, b) = if *forward { (a, b) } else { (b, a) }; + (Shape::Round { c, r, start: 0.0, sweep: std::f64::consts::TAU }, a, b) + } + CurveKind::Circle { c, r } => { + let c = self.point(c).ok_or_else(bad)?; + let r = r - offset.distance; + if r <= 1e-9 { + return Err(SketchError::Invalid("the offset collapses a circle".into())); + } + let out = offset.outputs.first().and_then(|id| self.curve_index(id)).ok_or_else(bad)?; + if let Some(crate::Curve { kind: CurveKind::Circle { r: target, .. }, .. }) = self.curves.get_mut(out) { + *target = r; + } else { + return Err(bad()); + } + let _ = c; + continue; + } + _ => return Err(bad()), + }; + pieces.push(piece); + } + if pieces.is_empty() { + continue; + } + let joint = |i: usize, j: usize| -> Result { + let (x, y) = (pieces.get(i).ok_or_else(bad)?, pieces.get(j).ok_or_else(bad)?); + if x.2.dist(y.1) < 1e-6 { + return Ok(x.2); + } + let guess = (x.2 + y.1) * 0.5; + intersections(&x.0, &y.0) + .into_iter() + .min_by(|a, b| a.dist(guess).total_cmp(&b.dist(guess))) + .ok_or_else(|| SketchError::Invalid("the offset curves no longer meet".into())) + }; + let n = pieces.len(); + let mut joints = vec![if offset.closed { joint(n - 1, 0)? } else { pieces.first().ok_or_else(bad)?.1 }]; + for i in 0..n.saturating_sub(1) { + joints.push(joint(i, i + 1)?); + } + if !offset.closed { + joints.push(pieces.last().ok_or_else(bad)?.2); + } + for (i, id) in offset.outputs.iter().enumerate() { + let a = *joints.get(i).ok_or_else(bad)?; + let b = *joints.get(if offset.closed { (i + 1) % n } else { i + 1 }).ok_or_else(bad)?; + let shape = &pieces.get(i).ok_or_else(bad)?.0; + if let Shape::Line { a: p, b: q } = shape + && (b - a).dot(*q - *p) <= 1e-9 + { + return Err(SketchError::Invalid("the offset curves would cross".into())); + } + let ci = self.curve_index(id).ok_or_else(bad)?; + let kind = self.curves.get(ci).ok_or_else(bad)?.kind.clone(); + let (pa, pb) = match kind { + CurveKind::Line { a, b } => (a, b), + CurveKind::Arc { a, b, .. } => { + if offset.sources.get(i).is_some_and(|x| x.1) { + (a, b) + } else { + (b, a) + } + } + _ => return Err(bad()), + }; + for (pi, pos) in [(pa, a), (pb, b)] { + if let Some(p) = self.points.get_mut(pi) { + p.pos = pos; + p.fixed = true; + } + } + } + } + Ok(()) + } +} diff --git a/crates/sketch/src/wire.rs b/crates/sketch/src/wire.rs index 62ff4fe7..ab0fb296 100644 --- a/crates/sketch/src/wire.rs +++ b/crates/sketch/src/wire.rs @@ -98,7 +98,7 @@ impl Sketch { } let id = if geom.is_empty() { let id = self.fresh("j"); - self.links.push(Link { id: id.clone(), kind, source, lost: false }); + self.links.push(Link { id: id.clone(), kind, source, face_name: None, lost: false }); id } else { self.add_link(kind, source, geom)? diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs index f073b10a..5fbc0c8f 100644 --- a/crates/ui-egui/src/browser.rs +++ b/crates/ui-egui/src/browser.rs @@ -232,41 +232,41 @@ const INDENT: f32 = 14.0; /// One row's look. #[derive(Default)] -struct Row<'a> { - depth: usize, +pub(crate) struct Row<'a> { + pub(crate) depth: usize, /// Some(open) for rows that fold. - fold: Option, + pub(crate) fold: Option, /// Some(visible) for rows with an eye. - eye: Option, - icon: &'a str, - label: &'a str, - selected: bool, - dim: bool, - color: Option, + pub(crate) eye: Option, + pub(crate) icon: &'a str, + pub(crate) label: &'a str, + pub(crate) selected: bool, + pub(crate) dim: bool, + pub(crate) color: Option, /// Component rows: is it the active one? - radio: Option, + pub(crate) radio: Option, /// Trailing badges: "lock", "pin". - badges: &'a [&'a str], + pub(crate) badges: &'a [&'a str], } /// What happened on a row. #[derive(Default)] -struct RowResp { - rect: Option, - clicked: bool, - double: bool, - secondary: Option, - fold: bool, - eye: bool, - radio: bool, - hovered: bool, +pub(crate) struct RowResp { + pub(crate) rect: Option, + pub(crate) clicked: bool, + pub(crate) double: bool, + pub(crate) secondary: Option, + pub(crate) fold: bool, + pub(crate) eye: bool, + pub(crate) radio: bool, + pub(crate) hovered: bool, /// The row's response (drag and drop). - resp: Option, + pub(crate) resp: Option, /// The press began on the fold arrow, eye or radio (not a drag of the row). - on_control: bool, + pub(crate) on_control: bool, } -fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp { +pub(crate) fn draw_row(ui: &mut egui::Ui, id: egui::Id, row: &Row) -> RowResp { let t = Tokens::get(); // Rows scrolled out of view only take their space: no widgets, no painting. let r = Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), ROW_H)); @@ -449,11 +449,11 @@ fn sel_of_key(k: &str) -> Option { None } -fn is_open(app: &SolveApp, key: &str, default: bool) -> bool { +pub(crate) fn is_open(app: &SolveApp, key: &str, default: bool) -> bool { if default { !app.tree.collapsed.contains(key) } else { app.tree.expanded.contains(key) } } -fn toggle(app: &mut SolveApp, key: &str, default: bool) { +pub(crate) fn toggle(app: &mut SolveApp, key: &str, default: bool) { if default { if !app.tree.collapsed.remove(key) { app.tree.collapsed.insert(key.to_string()); diff --git a/crates/ui-egui/src/context_menu.rs b/crates/ui-egui/src/context_menu.rs index 6381df63..3b9ba9ab 100644 --- a/crates/ui-egui/src/context_menu.rs +++ b/crates/ui-egui/src/context_menu.rs @@ -493,7 +493,10 @@ fn joint_items(app: &SolveApp, id: u64) -> Vec { let rigid = j.kind == solvecraft_engine::doc::joints::JointKind::Rigid; vec![ act("ui.editJoint", "Edit Joint", "joint").with(json!({ "joint": id })), + act("ui.editJoint", "Edit Joint Limits", "").with(json!({ "joint": id })).on(!rigid), act("ui.driveJoint", "Drive Joint", "").with(json!({ "joint": id })).on(!rigid), + act("ui.animateJoint", "Animate Joint", "").with(json!({ "joint": id })).on(!rigid && !j.suppressed), + act("ui.findJoint", "Find in Window", "").with(json!({ "joint": id })), cmd(app, "joint.edit", if j.suppressed { "Unsuppress" } else { "Suppress" }).with(json!({ "joint": id, "suppressed": !j.suppressed })), Item::sep(), cmd(app, "joint.delete", "Delete").key("Del").with(json!({ "joint": id })), @@ -792,12 +795,17 @@ pub fn run_item(app: &mut SolveApp, item: &Item, at: Pos2) { "ui.canvasVisible" => drop(app.run("canvas.edit", p)), "ui.toolbarPin" | "ui.toolbarRemove" | "ui.toolbarReset" | "ui.shortcutPin" => crate::toolbar_custom::run(app, &item.id, &p), "ui.workspace" => {} - "ui.editJoint" | "ui.driveJoint" => { + "ui.findJoint" => { if let Some(id) = id_of(&p, "joint") { - let d = if item.id == "ui.editJoint" { - crate::dialogs_assembly::edit_joint(app, id) - } else { - crate::dialogs_assembly::drive_joint(app, id) + crate::dialogs_assembly::find_joint(app, id); + } + } + "ui.editJoint" | "ui.driveJoint" | "ui.animateJoint" => { + if let Some(id) = id_of(&p, "joint") { + let d = match item.id.as_str() { + "ui.editJoint" => crate::dialogs_assembly::edit_joint(app, id), + "ui.animateJoint" => crate::dialogs_assembly::animate_joint(app, id), + _ => crate::dialogs_assembly::drive_joint(app, id), }; if let Some(d) = d { app.tool = None; diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index f56162aa..d1382537 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -2691,11 +2691,50 @@ pub(crate) fn profile_indices(ss: &solvecraft_engine::doc::SolvedSketch, sel: &P } } +thread_local! { + /// A dialog is being filled from a feature: its points are in component frames. + static REFILL: std::cell::Cell = const { std::cell::Cell::new(false) }; +} + +/// While filling a dialog from a feature (dropped at the end). +struct Refill; + +impl Refill { + fn start() -> Refill { + REFILL.with(|r| r.set(true)); + Refill + } +} + +impl Drop for Refill { + fn drop(&mut self) { + REFILL.with(|r| r.set(false)); + } +} + +/// A point stored in a feature, as it shows on world body `body`: features keep their picks in +/// the frame of the body they were on, so each body's placement takes the point to the world +/// (a moved component, a pasted instance). Other points are the world already. +fn stored_on(frames: &Option>, body: &str, p: Vec3) -> Vec3 { + frames.as_ref().and_then(|f| f.iter().find(|(n, _)| n == body)).map(|(_, m)| solvecraft_engine::doc::apply_point(m, p)).unwrap_or(p) +} + +/// Body placements while filling a dialog from a feature (when anything is placed). +fn stored_frames(s: &Session) -> Option> { + if !REFILL.with(std::cell::Cell::get) || !solvecraft_engine::frames::placed(s) { + return None; + } + let st = s.model.state(); + Some(s.doc.body_frames(&st).into_iter().map(|(w, _, _, m)| (w, m)).collect()) +} + /// The edge of a visible body through (or nearest) a point. -pub(crate) fn edge_sel(s: &Session, p: Vec3) -> Option { +pub(crate) fn edge_sel(s: &Session, p0: Vec3) -> Option { let st = s.world_state(); + let frames = stored_frames(s); let mut best: Option<(f64, Sel)> = None; for b in &st.bodies { + let p = stored_on(&frames, &b.name, p0); let m = b.mesh(); for (i, e) in m.edges.iter().enumerate() { let d = e.windows(2).map(|w| p.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min); @@ -2708,10 +2747,12 @@ pub(crate) fn edge_sel(s: &Session, p: Vec3) -> Option { } /// The body face containing a point (nearest triangle). -pub(crate) fn face_sel(s: &Session, p: Vec3) -> Option { +pub(crate) fn face_sel(s: &Session, p0: Vec3) -> Option { let st = s.world_state(); + let frames = stored_frames(s); let mut best: Option<(f64, Sel)> = None; for b in &st.bodies { + let p = stored_on(&frames, &b.name, p0); let m = b.mesh(); for (t, f) in m.triangles.iter().zip(&m.tri_face) { let Some([a, bb, c]) = m.tri(t) else { continue }; @@ -2721,7 +2762,7 @@ pub(crate) fn face_sel(s: &Session, p: Vec3) -> Option { } } } - best.filter(|(d, _)| *d < 1e-3 + 1e-6 * p.len()).map(|x| x.1) + best.filter(|(d, _)| *d < 1e-3 + 1e-6 * p0.len()).map(|x| x.1) } pub(crate) fn plane_sel(s: &Session, pl: &PlaneRef) -> Option { @@ -2756,6 +2797,7 @@ fn pt3(v: Vec3) -> Value { /// A dialog that edits an existing feature, filled from it. The timeline is rolled back to just /// before the feature, so its references show on the geometry they refer to. pub fn for_feature(app: &SolveApp, id: u64, marker: Option) -> Option { + let _refill = Refill::start(); let s = &app.session; let f = s.doc.feature(id)?.clone(); let st = s.world_state(); diff --git a/crates/ui-egui/src/dialogs_assembly.rs b/crates/ui-egui/src/dialogs_assembly.rs index ed679646..07d08727 100644 --- a/crates/ui-egui/src/dialogs_assembly.rs +++ b/crates/ui-egui/src/dialogs_assembly.rs @@ -209,6 +209,38 @@ pub fn edit_joint(app: &SolveApp, id: u64) -> Option { } /// The Drive Joints dialog on a joint (by id). +/// Edit Joint with its motion playing (the browser's Animate Joint). +pub fn animate_joint(app: &SolveApp, id: u64) -> Option { + let mut d = edit_joint(app, id)?; + if let Kind::Assembly(Asm::Joint(f)) = &mut d.kind { + f.animate = true; + } + Some(d) +} + +/// Frame the two components a joint connects (the browser's Find in Window). +pub fn find_joint(app: &mut SolveApp, id: u64) { + let s = &app.session; + let Some(j) = s.doc.assembly.joints.iter().find(|j| j.id == id) else { return }; + let occs = [j.a.occurrence, j.b.occurrence]; + let model = s.model.state(); + let world = s.world_state(); + let mut bb = Aabb3::default(); + for (name, _, path, _) in s.doc.body_frames(&model) { + // The root (occurrence 0) holds the bodies outside every occurrence. + let on = occs.iter().any(|o| if *o == 0 { path.is_empty() } else { path.contains(o) }); + if on && let Some(b) = world.body(&name) { + bb = bb.union(&b.mesh().bounds()); + } + } + if bb.is_empty() { + return; + } + let mut cam = app.cam; + cam.fit(&bb); + app.animate_to(cam); +} + pub fn drive_joint(app: &SolveApp, id: u64) -> Option { let joint = app.session.doc.assembly.joints.iter().position(|j| j.id == id)?; Some(Dialog::new(Kind::Assembly(Asm::Drive { joint, values: current_values(&app.session, joint), focus: true }), vec![])) @@ -494,12 +526,25 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Asm, inputs: &mut [Se let cur = s.doc.eval(v, unit_kind).ok().filter(|x| x.is_finite()).unwrap_or(0.0); let (mut shown, scale) = if angle { (cur.to_degrees(), 1f64.to_degrees()) } else { (cur, 1.0) }; row_label(ui, ""); - ui.spacing_mut().slider_width = 124.0; + ui.spacing_mut().slider_width = 160.0; let r = ui.add(egui::Slider::new(&mut shown, lo * scale..=hi * scale).show_value(false)); if r.changed() { *v = if angle { format!("{shown:.1} deg") } else { format!("{shown:.2} mm") }; } ui.end_row(); + // The slider's range: the joint's limits, or the default span when it has none. + let limited = j.limits.get(i).copied().flatten().is_some(); + let fmt = |x: f64| { + let (x, unit) = if angle { (x.to_degrees(), "°") } else { (x, " mm") }; + if x.fract().abs() < 1e-6 { format!("{x:.0}{unit}") } else { format!("{x:.1}{unit}") } + }; + row_label(ui, ""); + ui.label( + RichText::new(format!("{} … {}{}", fmt(lo), fmt(hi), if limited { " (limits)" } else { " (no limits)" })) + .size(11.0) + .color(if limited { t.text } else { t.text_dim }), + ); + ui.end_row(); } } Asm::MotionLink { a, b, ia, ib, ratio, offset } => { @@ -826,6 +871,8 @@ pub fn overlay(app: &SolveApp, painter: &egui::Painter, proj: &Proj, d: &mut Dia } return; } + // A joint names its two picks; a joint origin has one. + let two = matches!(k, Asm::Joint(_)); let hover = match k { Asm::Joint(f) => Some(&mut f.hover), Asm::JointOrigin { hover, .. } => Some(hover), @@ -840,8 +887,9 @@ pub fn overlay(app: &SolveApp, painter: &egui::Painter, proj: &Proj, d: &mut Dia .filter(|(_, i)| i.accept == SNAPS) .filter_map(|(n, i)| i.items.first().and_then(|x| snap_of(&app.session, x)).map(|s| (s, if n == 0 { t.accent } else { t.warning }))) .collect(); - for (s, c) in &picked { - glyph(painter, proj, s, *c, app.cam.half_height()); + for (n, (s, c)) in picked.iter().enumerate() { + let tag = format!("Component {}", n + 1); + glyph(painter, proj, s, *c, app.cam.half_height(), two.then_some(tag.as_str())); } // The snap under the cursor (found again only when the hovered item changes). let accepting = d.inputs.get(d.active).is_some_and(|i| i.accept == SNAPS); @@ -853,7 +901,7 @@ pub fn overlay(app: &SolveApp, painter: &egui::Painter, proj: &Proj, d: &mut Dia *hover = Some((sel.clone(), snap_of(&app.session, &sel))); } if let Some((_, Some(s))) = hover.as_ref() { - glyph(painter, proj, s, t.hover_profile_edge, app.cam.half_height()); + glyph(painter, proj, s, t.hover_profile_edge, app.cam.half_height(), Some(snap_name(s.kind))); } } None => *hover = None, @@ -861,36 +909,70 @@ pub fn overlay(app: &SolveApp, painter: &egui::Painter, proj: &Proj, d: &mut Dia } /// A snap: its kind's marker at the point and the z axis as an arrow. -fn glyph(painter: &egui::Painter, proj: &Proj, s: &SnapPt, col: Color32, half_height: f64) { +fn glyph(painter: &egui::Painter, proj: &Proj, s: &SnapPt, col: Color32, half_height: f64, tag: Option<&str>) { let Some(c) = proj.to_screen(s.at) else { return }; let len = half_height * 2.0 * 0.06; + // A dark halo under every stroke keeps the glyph readable on light and dark faces alike. + let halo = Stroke::new(4.5, Color32::from_black_alpha(150)); + let white = Stroke::new(1.5, Color32::WHITE); if let Some(tip) = proj.to_screen(s.at + s.z * len) { - painter.line_segment([c, tip], Stroke::new(2.0, col)); let d = (tip - c).normalized(); let n = vec2(-d.y, d.x); - painter.add(egui::Shape::convex_polygon(vec![tip, tip - d * 8.0 + n * 4.0, tip - d * 8.0 - n * 4.0], col, Stroke::NONE)); + let head = vec![tip + d * 2.0, tip - d * 9.0 + n * 5.0, tip - d * 9.0 - n * 5.0]; + painter.line_segment([c, tip], halo); + painter.add(egui::Shape::convex_polygon(head.clone(), Color32::TRANSPARENT, halo)); + painter.line_segment([c, tip], Stroke::new(2.0, col)); + painter.add(egui::Shape::convex_polygon(head, col, Stroke::NONE)); } - let white = Stroke::new(1.5, Color32::WHITE); + let shape = |fill: Color32, stroke: Stroke, grow: f32| -> egui::Shape { + match s.kind { + SnapKind::FaceCenter => egui::Shape::rect_filled(egui::Rect::from_center_size(c, vec2(12.0 + grow, 12.0 + grow)), 1.5, fill), + SnapKind::CircleCenter => egui::Shape::circle_filled(c, 7.0 + grow / 2.0, fill), + SnapKind::EdgeMid => { + let r = 8.0 + grow / 2.0; + egui::Shape::convex_polygon(vec![c + vec2(0.0, -r), c + vec2(r * 0.93, r * 0.7), c + vec2(-r * 0.93, r * 0.7)], fill, stroke) + } + SnapKind::Vertex => { + let r = 7.5 + grow / 2.0; + egui::Shape::convex_polygon(vec![c + vec2(0.0, -r), c + vec2(r, 0.0), c + vec2(0.0, r), c + vec2(-r, 0.0)], fill, stroke) + } + } + }; + painter.add(shape(Color32::from_black_alpha(150), Stroke::NONE, 4.0)); + painter.add(shape(col, Stroke::NONE, 0.0)); match s.kind { SnapKind::FaceCenter => { - painter.rect(egui::Rect::from_center_size(c, vec2(10.0, 10.0)), 1.0, col, white, egui::StrokeKind::Middle); + painter.rect_stroke(egui::Rect::from_center_size(c, vec2(12.0, 12.0)), 1.5, white, egui::StrokeKind::Middle); } SnapKind::CircleCenter => { - painter.circle(c, 6.0, col, white); - painter.line_segment([c - vec2(4.0, 0.0), c + vec2(4.0, 0.0)], Stroke::new(1.2, Color32::WHITE)); - painter.line_segment([c - vec2(0.0, 4.0), c + vec2(0.0, 4.0)], Stroke::new(1.2, Color32::WHITE)); + painter.circle_stroke(c, 7.0, white); + painter.line_segment([c - vec2(4.5, 0.0), c + vec2(4.5, 0.0)], Stroke::new(1.2, Color32::WHITE)); + painter.line_segment([c - vec2(0.0, 4.5), c + vec2(0.0, 4.5)], Stroke::new(1.2, Color32::WHITE)); } - SnapKind::EdgeMid => { - painter.add(egui::Shape::convex_polygon(vec![c + vec2(0.0, -7.0), c + vec2(6.5, 5.0), c + vec2(-6.5, 5.0)], col, white)); - } - SnapKind::Vertex => { - painter.add(egui::Shape::convex_polygon( - vec![c + vec2(0.0, -6.5), c + vec2(6.5, 0.0), c + vec2(0.0, 6.5), c + vec2(-6.5, 0.0)], - col, - white, - )); + SnapKind::EdgeMid | SnapKind::Vertex => { + painter.add(shape(Color32::TRANSPARENT, white, 0.0)); } } + // What it snaps to (hovered), or which component it is (picked): a small label. + if let Some(tag) = tag { + let t = Tokens::get(); + let font = egui::FontId::proportional(11.5); + let g = painter.layout_no_wrap(tag.to_string(), font, t.text); + let at = c + vec2(12.0, 10.0); + let r = egui::Rect::from_min_size(at, g.size()).expand2(vec2(5.0, 2.0)); + painter.rect(r, 3.0, t.panel.gamma_multiply(0.92), Stroke::new(1.0, col), egui::StrokeKind::Inside); + painter.galley(at, g, t.text); + } +} + +/// What a snap is called (the hover label). +fn snap_name(k: SnapKind) -> &'static str { + match k { + SnapKind::FaceCenter => "Face center", + SnapKind::CircleCenter => "Circle center", + SnapKind::EdgeMid => "Edge midpoint", + SnapKind::Vertex => "Vertex", + } } // ---- timeline and browser ---- @@ -963,61 +1045,36 @@ pub fn timeline_joints(app: &mut SolveApp, ui: &mut egui::Ui, p: &egui::Painter, /// The Joints folder at the end of the Browser: a row per joint (double-click edits, the menu /// edits, drives, suppresses or deletes). pub fn browser_joints(app: &mut SolveApp, ui: &mut egui::Ui, depth: usize) { - let t = Tokens::get(); + use crate::browser::{Row, draw_row, is_open, toggle}; let joints: Vec<(u64, String, JointKind, bool)> = app.session.doc.assembly.joints.iter().map(|j| (j.id, j.name.clone(), j.kind, j.suppressed)).collect(); if joints.is_empty() { return; } - let fold_id = egui::Id::new("sc_browser_joints_open"); - let mut open = ui.data(|d| d.get_temp::(fold_id)).unwrap_or(true); - let row = |ui: &mut egui::Ui, depth: f32, icon: &str, label: &str, dim: bool, fold: Option| -> egui::Response { - let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), egui::Sense::click()); - if resp.hovered() { - ui.painter().rect_filled(r, 3.0, t.hover); - } - let x = r.left() + 2.0 + depth * 14.0; - let cy = r.center().y; - if let Some(o) = fold { - let c = egui::pos2(x + 6.0, cy); - let pts = if o { - vec![c + vec2(-4.0, -2.0), c + vec2(4.0, -2.0), c + vec2(0.0, 3.0)] - } else { - vec![c + vec2(-2.0, -4.0), c + vec2(3.0, 0.0), c + vec2(-2.0, 4.0)] - }; - ui.painter().add(egui::Shape::convex_polygon(pts, t.text_dim, Stroke::NONE)); - } - let ir = egui::Rect::from_center_size(egui::pos2(x + 26.0, cy), vec2(16.0, 16.0)); - crate::icons::paint(ui.painter(), ir, icon, if dim { t.border } else { t.icon }, t.icon_fill, t.accent); - ui.painter().text( - egui::pos2(x + 38.0, cy), - egui::Align2::LEFT_CENTER, - label, - egui::FontId::proportional(13.0), - if dim { t.text_dim } else { t.text }, - ); - resp - }; - let depth = depth as f32; - if row(ui, depth, "folder", "Joints", false, Some(open)).clicked() { - open = !open; - ui.data_mut(|d| d.insert_temp(fold_id, open)); + // Drawn like every other browser node (its fold and rows publish `fold:Joints`, `row:`). + let key = "c0/joints"; + let open = is_open(app, key, true); + let r = draw_row(ui, ui.id().with(key), &Row { depth, fold: Some(open), icon: "folder", label: "Joints", ..Default::default() }); + if r.fold || r.clicked { + toggle(app, key, true); } if !open { return; } let mut dialog: Option = None; for (id, name, kind, suppressed) in joints { - let resp = row(ui, depth + 1.0, "joint", &name, suppressed, None).on_hover_text(format!("{kind:?} joint")); - if resp.double_clicked() { + let r = + draw_row(ui, ui.id().with(("joint", id)), &Row { depth: depth + 1, icon: "joint", label: &name, dim: suppressed, ..Default::default() }); + if let Some(resp) = &r.resp { + resp.clone().on_hover_text(format!("{kind:?} joint")); + } + if r.double { dialog = edit_joint(app, id); } // The same menus as the rest of the browser. - if resp.secondary_clicked() { - let at = resp.interact_pointer_pos().unwrap_or(resp.rect.left_bottom()); + if let Some(at) = r.secondary { crate::context_menu::open_for(app, at, crate::context_menu::Target::Joint { id }); } - let _ = (kind, suppressed); } if let Some(d) = dialog { app.tool = None; @@ -1028,3 +1085,51 @@ pub fn browser_joints(app: &mut SolveApp, ui: &mut egui::Ui, depth: usize) { #[cfg(test)] #[path = "dialogs_assembly_tests.rs"] mod tests; + +thread_local! { + /// Named joint origins in the world, for the design state they were found in. + static ORIGINS: std::cell::RefCell)>> = const { std::cell::RefCell::new(None) }; +} + +/// Named joint origins in the world: on their occurrence's component, so they move with it +/// (joint drives, free moves not captured yet, Capture Position). +pub fn origins_world(s: &Session) -> Vec<(String, solvecraft_engine::doc::Mat)> { + if s.doc.assembly.origins.is_empty() { + return Vec::new(); + } + let key = format!("{}:{:?}", s.revision, s.pending_moves); + if let Some(v) = ORIGINS.with(|o| o.borrow().as_ref().filter(|(k, _)| *k == key).map(|(_, v)| v.clone())) { + return v; + } + let doc: std::borrow::Cow = if s.pending_moves.is_empty() { + std::borrow::Cow::Borrowed(&*s.doc) + } else { + let mut d = (*s.doc).clone(); + for o in &mut d.occurrences { + if let Some(m) = s.pending_moves.get(&o.id) { + o.transform = *m; + } + } + std::borrow::Cow::Owned(d) + }; + let st = s.model.state(); + let v: Vec<_> = doc.assembly.origins.iter().filter_map(|o| doc.origin_world(&st, &o.origin).ok().map(|m| (o.name.clone(), m))).collect(); + ORIGINS.with(|o| *o.borrow_mut() = Some((key, v.clone()))); + v +} + +/// Named joint origins in the viewport: a small triad where each sits. +pub fn origins(app: &SolveApp, painter: &egui::Painter, proj: &Proj) { + let t = Tokens::get(); + let len = app.cam.half_height() * 2.0 * 0.04; + for (_, m) in origins_world(&app.session) { + let at = solvecraft_engine::doc::apply_point(&m, Vec3::ZERO); + let Some(c) = proj.to_screen(at) else { continue }; + for (axis, col) in [(Vec3::X, t.axis_x), (Vec3::Y, t.axis_y), (Vec3::Z, t.axis_z)] { + if let Some(tip) = proj.to_screen(at + solvecraft_engine::doc::apply_vector(&m, axis) * len) { + painter.line_segment([c, tip], Stroke::new(2.0, col)); + } + } + painter.circle(c, 4.5, t.panel, Stroke::new(1.5, t.text)); + } +} diff --git a/crates/ui-egui/src/dialogs_assembly_tests.rs b/crates/ui-egui/src/dialogs_assembly_tests.rs index 083645fe..ade77ceb 100644 --- a/crates/ui-egui/src/dialogs_assembly_tests.rs +++ b/crates/ui-egui/src/dialogs_assembly_tests.rs @@ -263,3 +263,41 @@ fn drive_value_takes_the_keyboard() { assert!((j.values[0] - 90f64.to_radians()).abs() < 1e-9, "{:?}", j.values); assert!(app.dialog.is_none()); } + +/// Named joint origins are drawn where their component is: a drive of the occurrence, or a free +/// move not captured yet, carries them along. +#[test] +fn joint_origins_follow_their_component() { + let mut app = two_boxes(); + app.session.execute("joint.origin", &json!({"name": "Top of B", "face": [40, 10, 10]})).unwrap(); + let at = |app: &SolveApp| { + let v = origins_world(&app.session); + let (_, m) = v.iter().find(|(n, _)| n == "Top of B").unwrap(); + solvecraft_engine::doc::apply_point(m, Vec3::ZERO) + }; + assert!(at(&app).dist(Vec3::new(40.0, 10.0, 10.0)) < 1e-6, "{:?}", at(&app)); + let b = occ(&app, "B"); + app.session.execute("occurrence.move", &json!({"occurrence": b, "translate": [0, 0, 15]})).unwrap(); + assert!(at(&app).dist(Vec3::new(40.0, 10.0, 25.0)) < 1e-6, "{:?}", at(&app)); + // A drag not captured yet. + let mut m = app.session.doc.occurrence_of(app.session.doc.find_component("B").unwrap()).unwrap().transform; + m[3][0] += 5.0; + app.session.pending_moves.insert(b, m); + assert!(at(&app).dist(Vec3::new(45.0, 10.0, 25.0)) < 1e-6, "{:?}", at(&app)); +} + +/// Edit Feature on a moved component: the dialog shows the feature's picks where the +/// component is (its stored points are in the component's frame). +#[test] +fn edit_feature_on_a_moved_component_refills_in_the_world() { + let mut app = two_boxes(); + let b = occ(&app, "B"); + app.session.execute("occurrence.move", &json!({"occurrence": b, "translate": [0, 0, 15]})).unwrap(); + let r = app.session.execute("solid.fillet", &json!({"edges": [[40, 0, 25]], "radius": 2})).unwrap(); + let id = r["feature"].as_u64().unwrap(); + let d = crate::dialogs::for_feature(&app, id, None).unwrap(); + let items: Vec = d.inputs.iter().flat_map(|i| i.items.clone()).collect(); + let Some(Sel::Edge { body, point, .. }) = items.first() else { panic!("{items:?}") }; + assert_eq!(body, "Body2"); + assert!(point.dist(Vec3::new(40.0, 0.0, 25.0)) < 1e-6, "{point:?}"); +} diff --git a/crates/ui-egui/src/dialogs_motion.rs b/crates/ui-egui/src/dialogs_motion.rs index 02d186f0..5331e429 100644 --- a/crates/ui-egui/src/dialogs_motion.rs +++ b/crates/ui-egui/src/dialogs_motion.rs @@ -41,6 +41,10 @@ pub enum Mo { tracks: Vec, step: f64, playing: bool, + /// Playback starts over at the end (else it stops there). + looping: bool, + /// Playback speed (index into `SPEEDS`). + speed: usize, /// The step the shown pose is for (and its revision). shown: Option<(u64, u64)>, saved: Option>, @@ -101,6 +105,8 @@ pub fn start(app: &SolveApp, id: &str) -> Option<(Kind, Vec)> { tracks: Vec::new(), step: 0.0, playing: false, + looping: true, + speed: 2, shown: None, saved: None, error: None, @@ -116,6 +122,73 @@ pub fn start(app: &SolveApp, id: &str) -> Option<(Kind, Vec)> { // ---- pure mappings (tested) ---- +/// Playback speeds offered (times `STEPS_PER_S`). +pub const SPEEDS: [f64; 5] = [0.25, 0.5, 1.0, 2.0, 4.0]; +/// Steps played per second at 1×. +const STEPS_PER_S: f64 = 24.0; + +/// The next playback step: `by` steps on; at the end it starts over (looping) or stops there. +/// Returns the step and whether it still plays. +pub fn advance(step: f64, by: f64, total: u32, looping: bool) -> (f64, bool) { + let last = f64::from(total); + let next = step + by.max(0.0); + if next <= last { + (next, true) + } else if looping && last > 0.0 { + (next % (last + 1.0), true) + } else { + (last, false) + } +} + +#[derive(Clone, Copy)] +enum Transport { + Start, + Back, + Play, + Stop, + Forward, + End, +} + +/// A media button drawn in code: bars and triangles. +fn transport(ui: &mut egui::Ui, what: Transport, tip: &str) -> egui::Response { + let t = Tokens::get(); + let (r, resp) = ui.allocate_exact_size(vec2(26.0, 22.0), Sense::click()); + let fill = if resp.hovered() { t.hover } else { t.field }; + ui.painter().rect(r, 3.0, fill, Stroke::new(1.0, t.border), egui::StrokeKind::Inside); + let c = r.center(); + let ink = if matches!(what, Transport::Play | Transport::Stop) { t.accent } else { t.icon }; + let p = ui.painter(); + let tri = |dir: f32, x: f32| { + egui::Shape::convex_polygon(vec![pos2(x - 4.0 * dir, c.y - 5.0), pos2(x + 4.0 * dir, c.y), pos2(x - 4.0 * dir, c.y + 5.0)], ink, Stroke::NONE) + }; + let bar = |x: f32| egui::Shape::rect_filled(egui::Rect::from_center_size(pos2(x, c.y), vec2(2.0, 10.0)), 0.0, ink); + match what { + Transport::Play => drop(p.add(tri(1.0, c.x + 1.0))), + Transport::Stop => drop(p.rect_filled(egui::Rect::from_center_size(c, vec2(9.0, 9.0)), 1.0, ink)), + Transport::Back => { + p.add(bar(c.x + 4.0)); + p.add(tri(-1.0, c.x - 1.0)); + } + Transport::Forward => { + p.add(bar(c.x - 4.0)); + p.add(tri(1.0, c.x + 1.0)); + } + Transport::Start => { + p.add(bar(c.x - 6.0)); + p.add(tri(-1.0, c.x - 0.5)); + p.add(tri(-1.0, c.x + 5.0)); + } + Transport::End => { + p.add(tri(1.0, c.x - 5.0)); + p.add(tri(1.0, c.x + 0.5)); + p.add(bar(c.x + 6.0)); + } + } + resp.on_hover_text(tip) +} + /// The study command's parameters. pub fn study_params(s: &Session, name: &str, study: Option<&str>, steps: &str, tracks: &[Track]) -> Result { let steps: u32 = steps.trim().parse().map_err(|_| "steps must be a whole number".to_string())?; @@ -321,7 +394,7 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Mo, inputs: &mut [Sel ui.end_row(); } } - Mo::MotionStudy { name, study, steps, tracks, step, playing, shown, saved, error } => { + Mo::MotionStudy { name, study, steps, tracks, step, playing, looping, speed, shown, saved, error } => { row_label(ui, "Name"); ui.text_edit_singleline(name); ui.end_row(); @@ -336,19 +409,54 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Mo, inputs: &mut [Sel ui.end_row(); return enter; } - // Playback. - row_label(ui, "Step"); + // Playback: to start, step back, play/stop, step on, to end; loop and speed. + row_label(ui, "Playback"); ui.horizontal(|ui| { - if ui.button(if *playing { "■" } else { "▶" }).on_hover_text(if *playing { "Stop" } else { "Play" }).clicked() { + let last = f64::from(total); + if transport(ui, Transport::Start, "To the start").clicked() { + *step = 0.0; + *playing = false; + } + if transport(ui, Transport::Back, "Step back").clicked() { + *step = (step.round() - 1.0).max(0.0); + *playing = false; + } + let (what, tip) = if *playing { (Transport::Stop, "Stop") } else { (Transport::Play, "Play") }; + if transport(ui, what, tip).clicked() { + // Play from the start again when at the end. + if !*playing && step.round() >= last { + *step = 0.0; + } *playing = !*playing; } - ui.spacing_mut().slider_width = 220.0; - ui.add(egui::Slider::new(step, 0.0..=f64::from(total)).integer()); + if transport(ui, Transport::Forward, "Step on").clicked() { + *step = (step.round() + 1.0).min(last); + *playing = false; + } + if transport(ui, Transport::End, "To the end").clicked() { + *step = last; + *playing = false; + } + ui.add_space(6.0); + ui.checkbox(looping, "Loop"); + let names: Vec = SPEEDS.iter().map(|x| format!("{x}×")).collect(); + let refs: Vec<&str> = names.iter().map(String::as_str).collect(); + combo(ui, "ms_speed", &refs, speed); + }); + ui.end_row(); + row_label(ui, "Step"); + ui.horizontal(|ui| { + ui.spacing_mut().slider_width = 260.0; + if ui.add(egui::Slider::new(step, 0.0..=f64::from(total)).integer().show_value(false)).dragged() { + *playing = false; + } + ui.label(RichText::new(format!("{} / {total}", step.round() as u32)).color(t.text_dim)); }); ui.end_row(); if *playing { - let dt = ui.input(|i| i.stable_dt).min(0.1); - *step = (*step + f64::from(dt) * 24.0) % (f64::from(total) + 1.0); + let dt = f64::from(ui.input(|i| i.stable_dt).min(0.1)); + let fps = STEPS_PER_S * SPEEDS.get(*speed).copied().unwrap_or(1.0); + (*step, *playing) = advance(*step, dt * fps, total, *looping); ui.ctx().request_repaint(); } // Tracks: a row per keyed joint value, its keys on a strip under the steps. @@ -667,6 +775,15 @@ pub fn commands(app: &SolveApp, k: &Mo, inputs: &[SelInput]) -> Result DocSlot { /// Make tab `i` the active design. pub fn switch(app: &mut SolveApp, i: usize) { + app.home.open = false; if i == app.docs.active || i >= app.docs.slots.len() { return; } @@ -293,6 +294,25 @@ pub fn control(app: &mut SolveApp, p: &Value) -> Value { /// + for a new design. pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) { let t = Tokens::get(); + let home = Rect::from_min_size(pos2(x0, r.top() + 5.0), vec2(66.0, r.height() - 5.0)); + let response = ui.interact(home, ui.id().with("home_tab"), Sense::click()); + ui.painter().rect_filled( + home, + 5.0, + if app.home.open { + t.toolbar + } else if response.hovered() { + t.hover + } else { + Color32::from_white_alpha(10) + }, + ); + ui.painter().text(home.center(), Align2::CENTER_CENTER, "Home", FontId::proportional(13.0), if app.home.open { t.text } else { t.app_bar_text }); + crate::scenario::publish_handle("tab:home", home.center()); + if response.clicked() { + app.home.show(app.session.revision); + } + let x0 = x0 + 70.0; let info = tabs_info(app); let n = info.len(); let (first, shown, w) = layout(n, app.docs.active, x1 - x0); @@ -301,8 +321,9 @@ pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) { let mut shut: Option = None; for (i, (name, dirty)) in info.iter().enumerate().skip(first).take(shown) { let tr = Rect::from_min_size(pos2(x, r.top() + 5.0), vec2(w - 2.0, r.height() - 5.0)); - let active = i == app.docs.active || app.docs.slots.is_empty(); + let active = !app.home.open && (i == app.docs.active || app.docs.slots.is_empty()); let resp = ui.interact(tr, ui.id().with(("doc_tab", i)), Sense::click_and_drag()); + crate::scenario::publish_handle(&format!("tab:design:{i}"), tr.center()); // The tabs are part of the title bar: dragging one moves the window, a double click // maximizes it. if app.custom_titlebar || app.integrated_titlebar { @@ -389,7 +410,6 @@ pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) { ui.painter().line_segment([c - vec2(0.0, 6.0), c + vec2(0.0, 6.0)], s); if presp.on_hover_text("New Design (Ctrl+N)").clicked() { new_design(app); - app.home.show(app.session.revision); } if let Some(i) = shut { close(app, i, false); diff --git a/crates/ui-egui/src/home.rs b/crates/ui-egui/src/home.rs index 24feb9f9..deab41d2 100644 --- a/crates/ui-egui/src/home.rs +++ b/crates/ui-egui/src/home.rs @@ -1,6 +1,6 @@ //! The start page: New Design, Open, the recent designs and the built-in samples, each with a //! picture of the design rendered from it. Shown on launch without a file and from the house -//! button; it closes when a design is opened or started, or the design changes. +//! button or the first document tab; selecting a design returns to its view. use std::collections::HashMap; @@ -24,8 +24,7 @@ pub struct HomeState { pub open: bool, /// Recent design paths, newest first (kept in the preferences). pub recent: Vec, - /// The session revision when the page opened (a change closes it). - rev: u64, + pub opened_at: std::collections::BTreeMap, thumbs: HashMap>, samples: HashMap, /// Keys asked for and not made yet. @@ -37,9 +36,8 @@ pub struct HomeState { } impl HomeState { - pub fn show(&mut self, rev: u64) { + pub fn show(&mut self, _rev: u64) { self.open = true; - self.rev = rev; } /// Put a design at the top of the recent list. @@ -47,6 +45,8 @@ impl HomeState { self.recent.retain(|p| p != path); self.recent.insert(0, path.to_string()); self.recent.truncate(MAX_RECENT); + self.opened_at.insert(path.to_string(), web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0)); + self.opened_at.retain(|p, _| self.recent.contains(p)); self.thumbs.remove(path); } } @@ -179,9 +179,8 @@ pub fn open_sample(app: &mut SolveApp, i: usize) { } } -fn open_recent(app: &mut SolveApp, path: &str) { +pub fn open_recent(app: &mut SolveApp, path: &str) { if !solvecraft_engine::io::vfs::exists(path) { - app.home.recent.retain(|p| p != path); app.set_status(format!("{path} is no longer there"), true); return; } @@ -191,10 +190,6 @@ fn open_recent(app: &mut SolveApp, path: &str) { /// The page itself (in place of the toolbar, browser and viewport). pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { - if app.session.revision != app.home.rev { - app.home.open = false; - return; - } poll(app, ui.ctx()); let t = Tokens::get(); let samples = solvecraft_engine::sample::samples(); @@ -261,6 +256,19 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { } }); ui.add_space(24.0); + ui.horizontal_wrapped(|ui| { + ui.hyperlink_to("Documentation", crate::help::DOCS_URL); + ui.hyperlink_to("Report an Issue", "https://github.com/bherbruck/solvecraft/issues/new"); + ui.hyperlink_to("What's new", "https://github.com/bherbruck/solvecraft/releases/latest"); + if ui.link("Keyboard Shortcuts").clicked() { + app.keymap.open = true; + app.keymap.read_only = true; + } + if ui.link("Preferences").clicked() { + crate::prefs::open_at(app, 0); + } + }); + ui.add_space(16.0); section(ui, "Recent"); if recent.is_empty() { ui.label(RichText::new("Designs you open or save appear here.").color(t.text_dim)); @@ -269,20 +277,46 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { let Some(p) = recent.get(i) else { return }; let path = std::path::Path::new(p); let name = path.file_stem().map(|x| x.to_string_lossy().to_string()).unwrap_or_else(|| p.clone()); - let folder = path.parent().map(|x| x.to_string_lossy().to_string()).unwrap_or_default(); let missing = !solvecraft_engine::io::vfs::exists(p); - let sub = if missing { + let mut sub = if missing { "missing".to_string() } else if p.starts_with("/opfs/") { // The web build keeps designs in the browser's own storage. "in this browser".to_string() } else { - folder + p.clone() }; - if card(ui, Pic::Ready(app.home.thumbs.get(p.as_str()).and_then(Option::as_ref)), &name, &sub, missing) - .on_hover_text(p.as_str()) - .clicked() - { + if let Some(time) = app.home.opened_at.get(p) { + let now = web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(*time); + let seconds = now.saturating_sub(*time); + let ago = if seconds < 60 { + "just now".to_string() + } else if seconds < 3600 { + format!("{} min ago", seconds / 60) + } else if seconds < 86400 { + format!("{} h ago", seconds / 3600) + } else { + format!("{} days ago", seconds / 86400) + }; + sub.push_str(&format!("\nOpened {ago}")); + } + let response = card(ui, Pic::Ready(app.home.thumbs.get(p.as_str()).and_then(Option::as_ref)), &name, &sub, missing) + .on_hover_text(p.as_str()); + crate::scenario::publish_handle(&format!("home:recent:{i}"), response.rect.center()); + response.context_menu(|ui| { + if ui.button("Remove from list").clicked() { + app.home.recent.retain(|x| x != p); + app.home.opened_at.remove(p); + ui.close(); + } + if !cfg!(target_arch = "wasm32") && ui.button("Show in folder").clicked() { + if let Some(show) = &app.services.show_in_folder { + show(p); + } + ui.close(); + } + }); + if response.clicked() { let p = p.clone(); action = Some(Box::new(move |app: &mut SolveApp| open_recent(app, &p))); } @@ -340,7 +374,7 @@ enum Pic<'a> { /// A design card: its picture (a spinner while it renders), name and a line under it. fn card(ui: &mut egui::Ui, pic: Pic, name: &str, sub: &str, dim: bool) -> egui::Response { let t = Tokens::get(); - let size = vec2(THUMB[0] as f32 + 16.0, THUMB[1] as f32 + 62.0); + let size = vec2(THUMB[0] as f32 + 16.0, THUMB[1] as f32 + 80.0); let (r, resp) = ui.allocate_exact_size(size, Sense::click()); let hover = resp.hovered(); ui.painter().rect( diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index d4093555..35a254d7 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -155,6 +155,7 @@ impl Default for UiState { pub struct Services { pub pick_open: Option Option>>, pub pick_save: Option Option>>, + pub show_in_folder: Option>, /// Where the host reads the anti-aliasing preference at start (a small JSON file). pub graphics_path: Option, } @@ -304,6 +305,7 @@ impl SolveApp { "browser_collapsed": self.tree.collapsed, "browser_expanded": self.tree.expanded, "recent": self.home.recent, + "recent_opened_at": self.home.opened_at, "shortcut_box": self.sbox.prefs(), "shortcuts": self.keymap.prefs(), "toolbar": self.toolbar_custom.prefs(), @@ -319,6 +321,7 @@ impl SolveApp { pub fn load_prefs(&mut self, prefs: &str) { let Ok(v) = serde_json::from_str::(prefs) else { return }; let flag = |k: &str| v.get(k).and_then(Value::as_bool); + self.home.opened_at = v.get("recent_opened_at").and_then(|x| serde_json::from_value(x.clone()).ok()).unwrap_or_default(); if let Some(d) = flag("dark") { self.ui.dark = d; } @@ -430,6 +433,12 @@ impl SolveApp { } self.tool = None; self.home.open = false; + if matches!(id, "sketch.insert_dxf" | "sketch.insert_svg") { + if let Some(path) = self.services.pick_open.as_ref().and_then(|f| f()) { + let _ = self.run(id, json!({"path": path})); + } + return; + } if matches!(id, "file.insert_step" | "file.insert_mesh") { if let Some(p) = self.services.pick_open.as_ref().and_then(|f| f()) { self.insert_path(&p); @@ -480,7 +489,20 @@ impl SolveApp { { self.last_command = Some((spec.id.to_string(), spec.label.to_string())); } - if let Some(t) = tools::Tool::for_command(id) { + if let Some(mut t) = tools::Tool::for_command(id) { + if id == "sketch.dimension" { + t.picks = self + .session + .selection + .iter() + .filter_map(|s| match s { + solvecraft_engine::Sel::SketchCurve { id } | solvecraft_engine::Sel::SketchPoint { id } => Some(id.clone()), + _ => None, + }) + .take(2) + .collect(); + let _ = self.session.execute("select.clear", &json!({})); + } self.tool = Some(t); self.set_status(tools::hint(id), false); return; diff --git a/crates/ui-egui/src/menu_tests.rs b/crates/ui-egui/src/menu_tests.rs index b8c2b7e0..3829dd59 100644 --- a/crates/ui-egui/src/menu_tests.rs +++ b/crates/ui-egui/src/menu_tests.rs @@ -232,8 +232,10 @@ fn delete_key_handles_every_kind_and_asks_about_dependents() { app.run("edit.undo", json!({})).unwrap(); assert_eq!(app.session.doc.features.len(), n); // A face its neighbours can't close (a side of the plate): refused, nothing changes. - let b0 = app.session.model.state().bodies[0].name.clone(); - app.run("select.set", json!({"items": [{"type": "face", "body": b0, "index": 0, "point": [0, 0, 0]}]})).unwrap(); + let body = &app.session.model.state().bodies[0]; + let face = body.body.faces(0.01).unwrap().into_iter().find(|f| f.plane_normal.is_some_and(|n| n.x < -0.99)).unwrap(); + let b0 = body.name.clone(); + app.run("select.set", json!({"items": [{"type": "face", "body": b0, "index": face.index, "point": face.centroid}]})).unwrap(); crate::delete::delete_selection(&mut app); assert!(app.status.as_ref().is_some_and(|s| s.0.contains("Delete Face")), "{:?}", app.status); assert_eq!(app.session.doc.features.len(), n); diff --git a/crates/ui-egui/src/ref_images.rs b/crates/ui-egui/src/ref_images.rs index 60cad5ee..770b5d17 100644 --- a/crates/ui-egui/src/ref_images.rs +++ b/crates/ui-egui/src/ref_images.rs @@ -68,7 +68,7 @@ pub fn gpu_images(app: &SolveApp) -> Vec { .iter() .filter(|c| c.visible && c.opacity > 0.0) .filter_map(|c| { - let plane = doc.resolve_plane(&vals, &c.plane, 0).ok()?; + let plane = doc.canvas_plane(&vals, c).ok()?; let (_, version, size, rgba) = pixels(c)?; let corners = c.world_corners(&plane).map(|p| [p.x as f32, p.y as f32, p.z as f32]); Some(GpuImage { id: c.id, version, size, rgba, corners, opacity: c.opacity.clamp(0.0, 1.0) as f32 }) @@ -105,7 +105,7 @@ pub fn show(app: &SolveApp, ui: &egui::Ui, painter: &egui::Painter, proj: &Proj) } let (vals, _) = doc.param_values(); for c in doc.canvases.iter().filter(|c| c.visible) { - let Ok(plane) = doc.resolve_plane(&vals, &c.plane, 0) else { continue }; + let Ok(plane) = doc.canvas_plane(&vals, c) else { continue }; let Some(tex) = texture(ui.ctx(), c) else { continue }; let [bl, br, _, tl] = c.corners(); let (u, v) = (br - bl, tl - bl); diff --git a/crates/ui-egui/src/scenario.rs b/crates/ui-egui/src/scenario.rs index 55f53c76..476ae7da 100644 --- a/crates/ui-egui/src/scenario.rs +++ b/crates/ui-egui/src/scenario.rs @@ -245,6 +245,15 @@ impl Harness { } pub fn call(&mut self, method: &str, params: Value) -> Value { + if method == "ui.resize" + && let (Some(w), Some(h)) = (params["width"].as_f64(), params["height"].as_f64()) + && w.is_finite() + && h.is_finite() + && w > 0.0 + && h > 0.0 + { + self.size = egui::vec2(w as f32, h as f32); + } let (req, _rx) = ControlRequest::new(method, params); let out = match handle(&mut self.app, &self.ctx, &req) { Outcome::Done(v) => v, diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs index c928c0f3..38abfc1e 100644 --- a/crates/ui-egui/src/toolbar.rs +++ b/crates/ui-egui/src/toolbar.rs @@ -54,6 +54,7 @@ pub fn app_bar(app: &mut SolveApp, ui: &mut egui::Ui) { let br = Rect::from_center_size(pos2(x, r.center().y), vec2(26.0, 26.0)); x += 30.0; let resp = ui.interact(br, ui.id().with(("ab", icon)), Sense::click()); + crate::scenario::publish_handle(&format!("appbar:{icon}"), br.center()); if resp.hovered() { ui.painter().rect_filled(br, 4.0, Color32::from_white_alpha(30)); } @@ -148,8 +149,11 @@ fn file_menu(app: &mut SolveApp, ctx: &egui::Context) { .show(ctx, |ui| { egui::Frame::popup(ui.style()).show(ui, |ui| { ui.set_min_width(190.0); + ui.visuals_mut().widgets.inactive.weak_bg_fill = Color32::TRANSPARENT; + ui.visuals_mut().widgets.inactive.bg_stroke = Stroke::NONE; + ui.visuals_mut().widgets.hovered.weak_bg_fill = Tokens::get().hover; let item = |ui: &mut egui::Ui, label: &str, key: &str| { - ui.add(egui::Button::new(label).shortcut_text(key).frame(false).min_size(vec2(180.0, 22.0))).clicked() + ui.add(egui::Button::new(label).shortcut_text(key).min_size(vec2(180.0, 22.0))).clicked() }; if item(ui, "New Design", "Ctrl+N") { crate::documents::new_design(app); @@ -161,6 +165,24 @@ fn file_menu(app: &mut SolveApp, ctx: &egui::Context) { } close = true; } + ui.menu_button("Open Recent", |ui| { + for path in app.home.recent.clone() { + let missing = !solvecraft_engine::io::vfs::exists(&path); + let label = format!("{path}{}", if missing { " (missing)" } else { "" }); + if ui.button(label).clicked() { + crate::home::open_recent(app, &path); + close = true; + ui.close(); + } + } + ui.separator(); + if ui.button("Clear Recent").clicked() { + app.home.recent.clear(); + app.home.opened_at.clear(); + close = true; + ui.close(); + } + }); if item(ui, "Insert STEP…", "") { app.start("file.insert_step"); close = true; @@ -308,11 +330,16 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) { let top = r.top() + 26.0; let mut drop: Option<(&'static str, &'static str, Option<&'static str>)> = None; let mut menu: Option<(egui::Pos2, &'static str)> = None; + let mut overflow = Vec::new(); for (panel, cmds, promote) in crate::toolbar_custom::panel_lists(&tab) { let panel: &&str = &panel; let shown = crate::toolbar_custom::buttons(app, &tab, panel, &cmds, promote); let n = shown.len().max(1); let width = (n as f32 * 40.0).max(64.0) + 8.0; + if !overflow.is_empty() || px + width > r.right() - 40.0 { + overflow.push((*panel, cmds)); + continue; + } let enabled_panel = !cmds.is_empty() || *panel == "SELECT"; // Dropped on the panel's free space: the button goes to its end. let free = Rect::from_min_size( @@ -433,6 +460,31 @@ pub fn toolbar(app: &mut SolveApp, ui: &mut egui::Ui) { painter.line_segment([pos2(px, top + 4.0), pos2(px, top + 58.0)], Stroke::new(1.0, t.border)); px += 2.0; } + if !overflow.is_empty() { + let at = Rect::from_min_size(pos2(px.min(r.right() - 40.0), top + 4.0), vec2(38.0, 52.0)); + ui.scope_builder(egui::UiBuilder::new().max_rect(at), |ui| { + let response = ui.menu_button("»", |ui| { + for (panel, cmds) in &overflow { + ui.menu_button(*panel, |ui| { + if *panel == "SELECT" { + selection_filter(app, ui); + } + for c in cmds { + let info = c.info(&app.session); + let response = ui.add_enabled(info.enabled, egui::Button::new(c.label).shortcut_text(c.shortcut.unwrap_or(""))); + crate::scenario::publish_handle(&format!("toolbar:{}", c.id), response.rect.center()); + if response.clicked() { + app.start(c.id); + ui.close(); + } + } + }); + } + }); + crate::scenario::publish_handle("toolbar:overflow", response.response.rect.center()); + response.response.on_hover_text("More toolbar panels"); + }); + } painter.line_segment([pos2(r.left(), r.bottom() - 0.5), pos2(r.right(), r.bottom() - 0.5)], Stroke::new(1.0, t.border)); if let Some((id, panel, before)) = drop { crate::toolbar_custom::reorder(app, &tab, id, panel, before); diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rs index 6a89cdea..681f41ba 100644 --- a/crates/ui-egui/src/tools.rs +++ b/crates/ui-egui/src/tools.rs @@ -80,7 +80,7 @@ pub fn hint(id: &str) -> String { "sketch.circle.center" => "Circle: click the centre, then a point on the circle".into(), "sketch.arc.three_point" => "Arc: click start, end, then a point on the arc".into(), "sketch.arc.center_point" => "Arc: click centre, start, then end (counter-clockwise)".into(), - "sketch.dimension" => "Dimension: pick a line, circle or arc (or two points/lines)".into(), + "sketch.dimension" => "Dimension: pick one or two entities, then click to place the value".into(), "sketch.slot.center_to_center" | "sketch.slot.overall" => "Slot: click both ends, then the width".into(), _ if id.starts_with("sketch.constraint.") => "Constraint: pick the sketch entities".into(), _ => crate::sketch_tools::hint(id).unwrap_or_else(|| "Click in the sketch".into()), @@ -142,31 +142,21 @@ pub fn on_click(app: &mut SolveApp, proj: &Proj, pos: Pos2) { Kind::Dimension => { let hits = pick(app, proj, pos); let hit = hits.iter().find_map(|h| match h { - Hit::SketchPoint { id, .. } => Some((id.clone(), true)), - Hit::SketchCurve { id, .. } => Some((id.clone(), false)), + Hit::SketchPoint { id, .. } | Hit::SketchCurve { id, .. } => Some(id.clone()), _ => None, }); - if let Some((id, is_point)) = hit { - tool.picks.push(id.clone()); - let st = app.session.world_state(); - let is_line = app - .session - .active_sketch - .and_then(|s| st.sketch(s)) - .and_then(|ss| ss.sketch.curve_index(&id).and_then(|c| ss.sketch.curves.get(c).cloned())) - .map(|c| matches!(c.kind, solvecraft_engine::sketch::CurveKind::Line { .. })); - let ready = (tool.picks.len() == 1 && !is_point && is_line != Some(true)) || tool.picks.len() >= 2; - let single_line = tool.picks.len() == 1 && is_line == Some(true); - if ready || single_line { - // A single line gets its length right away; a second pick (line or point) replaces it. - if let Ok(v) = app.run("sketch.dimension", json!({"entities": tool.picks})) - && let Some(p) = v["param"].as_str() - { - // The value is edited in place, selected so typing replaces it. - crate::dim_view::edit_param(app, p); - } - tool.picks.clear(); + if let Some(id) = hit { + if !tool.picks.contains(&id) && tool.picks.len() < 2 { + tool.picks.push(id); } + } else if !tool.picks.is_empty() + && let Some((at, _)) = sketch_point_at(app, proj, pos) + && let Ok(v) = app.run("sketch.dimension", json!({"entities": tool.picks, "text_at": [at.x, at.y]})) + { + if let Some(p) = v["param"].as_str() { + crate::dim_view::edit_param(app, p); + } + tool.picks.clear(); } } } diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index 244af677..45c1d11f 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -1682,6 +1682,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { app.viewport.boxsel = None; } crate::ref_images::show(app, ui, &painter, &proj); + crate::dialogs_assembly::origins(app, &painter, &proj); overlays(app, &painter, &proj); crate::dim_view::show(app, ui, &painter, &proj); crate::sketch3d::show(app, &painter, &proj); diff --git a/crates/ui-egui/tests/scenarios.rs b/crates/ui-egui/tests/scenarios.rs index 717a9042..f0ef2c06 100644 --- a/crates/ui-egui/tests/scenarios.rs +++ b/crates/ui-egui/tests/scenarios.rs @@ -31,3 +31,98 @@ fn adhoc() { panic!("{path}: {e}"); } } + +#[test] +fn angle_dimension_both_interactive_workflows() { + use serde_json::json; + for preselect in [false, true] { + let mut h = Harness::new(); + h.run(&json!([ + {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}}, + {"call":"engine.execute","params":{"command":"sketch.line","params":{"points":[[0,0],[40,0]]}}}, + {"call":"engine.execute","params":{"command":"sketch.line","params":{"points":[[0,0],[30,30]]}}}, + {"call":"ui.view","params":{"view":"top"}} + ])) + .unwrap(); + let picks = json!([ + {"click":{"sketch":[20,0]}}, + {"click":{"sketch":[15,15]},"shift":true} + ]); + if preselect { + h.run(&picks).unwrap(); + h.run(&json!([{ "key":"D" }])).unwrap(); + } else { + h.run(&json!([{ "key":"D" }])).unwrap(); + h.run(&picks).unwrap(); + } + h.run(&json!([ + {"click":{"sketch":[20,8]}}, + {"text":"45"}, {"key":"Enter"}, + {"expect":{"errors":0,"param":{"d1":std::f64::consts::FRAC_PI_4}}} + ])) + .unwrap(); + let sk = &h.app.session.model.state().sketches[0].sketch; + assert!(sk.constraints.iter().any(|c| matches!(c.kind, solvecraft_engine::sketch::ConstraintKind::Angle { .. }))); + } +} + +#[test] +fn home_tab_and_file_recent_open_designs() { + use serde_json::json; + let mut h = Harness::new(); + h.run(&json!([ + {"call":"engine.execute","params":{"command":"solid.box","params":{"length":10,"width":10,"height":10}}}, + {"call":"engine.execute","params":{"command":"file.save_as","params":{"path":"$DIR/recent.solvecraft"}}}, + {"click":{"handle":"tab:home"}}, + {"expect":{"home":true,"documents":1}}, + {"click":{"handle":"tab:design:0"}}, + {"expect":{"home":false,"bodies":1}}, + {"click":{"handle":"tab:home"}}, + {"click":{"handle":"home:recent:0"}}, + {"expect":{"home":false,"bodies":1,"documents":2}}, + {"click":{"handle":"appbar:folder"}}, + {"widget":"Open Recent"} + ])) + .unwrap(); + let path = h.dir.join("recent.solvecraft").to_string_lossy().into_owned(); + h.run(&json!([ + {"widget":path}, + {"expect":{"home":false,"bodies":1,"documents":3}} + ])) + .unwrap(); +} + +#[test] +fn sketch_toolbar_imports_use_file_picker() { + use serde_json::json; + let mut h = Harness::new(); + let path = h.dir.join("drawing.svg"); + std::fs::write( + &path, + r#""#, + ) + .unwrap(); + h.run(&json!([ + {"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}}, + {"choose_file":path}, + {"start":"sketch.insert_svg"}, + {"expect":{"errors":0,"sketch_curves":{"own":4}}} + ])) + .unwrap(); +} + +#[test] +fn narrow_toolbar_reaches_collapsed_commands() { + use serde_json::json; + let mut h = Harness::new(); + h.run(&json!([ + {"call":"ui.resize","params":{"width":640,"height":800}}, + {"expect":{"shown_handles":["toolbar:overflow"]}}, + {"click":{"handle":"toolbar:overflow"}}, + {"widget":"CONSTRUCT"}, + {"expect":{"shown_handles":["toolbar:construct.plane.offset"]}}, + {"click":{"handle":"toolbar:construct.plane.offset"}}, + {"expect":{"dialog":"OffsetPlane"}} + ])) + .unwrap(); +} diff --git a/crates/ui-egui/tests/scenarios/acceptance_lid_lip_after_resize.json b/crates/ui-egui/tests/scenarios/acceptance_lid_lip_after_resize.json index 0da30c42..1cec549a 100644 --- a/crates/ui-egui/tests/scenarios/acceptance_lid_lip_after_resize.json +++ b/crates/ui-egui/tests/scenarios/acceptance_lid_lip_after_resize.json @@ -1,7 +1,4 @@ [ - { - "pending": "#40: offsets of projected geometry get new ids on recompute, the lid's lip fails" - }, { "note": "Acceptance (#27): the board grows 60 \u2192 70 mm; the lid's lip (offsets of the case's projected rim) follows." }, diff --git a/crates/ui-egui/tests/scenarios/acceptance_sensor_enclosure.json b/crates/ui-egui/tests/scenarios/acceptance_sensor_enclosure.json index 30f04daa..c5592787 100644 --- a/crates/ui-egui/tests/scenarios/acceptance_sensor_enclosure.json +++ b/crates/ui-egui/tests/scenarios/acceptance_sensor_enclosure.json @@ -87,6 +87,70 @@ } } }, + { + "call": "engine.execute", + "params": { + "command": "parameters.change", + "params": { + "name": "wall", + "expression": "2.4 mm" + } + } + }, + { + "expect": { + "errors": 0, + "bodies": 2 + } + }, + { + "call": "engine.execute", + "params": { + "command": "parameters.change", + "params": { + "name": "height", + "expression": "30 mm" + } + } + }, + { + "expect": { + "errors": 0, + "bodies": 2 + } + }, + { + "call": "engine.execute", + "params": { + "command": "parameters.change", + "params": { + "name": "height", + "expression": "25 mm" + } + } + }, + { + "expect": { + "errors": 0, + "bodies": 2 + } + }, + { + "call": "engine.execute", + "params": { + "command": "parameters.change", + "params": { + "name": "wall", + "expression": "2 mm" + } + } + }, + { + "expect": { + "errors": 0, + "bodies": 2 + } + }, { "call": "engine.execute", "params": { diff --git a/crates/ui-egui/tests/scenarios/acceptance_snap_fit_after_resize.json b/crates/ui-egui/tests/scenarios/acceptance_snap_fit_after_resize.json index d2d51a42..9c6e6e9b 100644 --- a/crates/ui-egui/tests/scenarios/acceptance_snap_fit_after_resize.json +++ b/crates/ui-egui/tests/scenarios/acceptance_snap_fit_after_resize.json @@ -1,7 +1,4 @@ [ - { - "pending": "#41: a snap fit stays at its old point when its wall moves (a floating body)" - }, { "note": "Acceptance (#27): the board grows 40 \u2192 50 mm deep; the snap fit stays on the moved front wall." }, diff --git a/crates/ui-egui/tests/scenarios/s01_box_fillet_hole_shell.json b/crates/ui-egui/tests/scenarios/s01_box_fillet_hole_shell.json index a4bb45de..45c796e3 100644 --- a/crates/ui-egui/tests/scenarios/s01_box_fillet_hole_shell.json +++ b/crates/ui-egui/tests/scenarios/s01_box_fillet_hole_shell.json @@ -50,6 +50,7 @@ ] } }, + {"click": {"sketch": [20, -8]}}, { "text": "50" }, diff --git a/crates/ui-egui/tests/scenarios/s06_edit_early_feature.json b/crates/ui-egui/tests/scenarios/s06_edit_early_feature.json index d94e483d..e0347db9 100644 --- a/crates/ui-egui/tests/scenarios/s06_edit_early_feature.json +++ b/crates/ui-egui/tests/scenarios/s06_edit_early_feature.json @@ -40,6 +40,7 @@ ] } }, + {"click": {"sketch": [20, -8]}}, { "text": "40" }, diff --git a/crates/ui-egui/tests/scenarios/s07_components_joint_drive.json b/crates/ui-egui/tests/scenarios/s07_components_joint_drive.json index 51a108d2..ce212e33 100644 --- a/crates/ui-egui/tests/scenarios/s07_components_joint_drive.json +++ b/crates/ui-egui/tests/scenarios/s07_components_joint_drive.json @@ -76,6 +76,14 @@ { "key": "Enter" }, + { + "call": "ui.set", + "params": { + "hiddenBodies": [ + "Body1" + ] + } + }, { "start": "sketch.create" }, @@ -84,6 +92,12 @@ "plane": "XZ" } }, + { + "call": "ui.set", + "params": { + "hiddenBodies": [] + } + }, { "start": "sketch.rectangle.two_point" }, @@ -99,7 +113,7 @@ "click": { "sketch": [ 50, - 10 + -10 ] } }, @@ -116,16 +130,13 @@ } }, { - "start": "solid.extrude" + "call": "ui.view", + "params": { + "view": "fit" + } }, { - "click": { - "world": [ - 40, - 0, - 5 - ] - } + "start": "solid.extrude" }, { "text": "20" @@ -199,7 +210,7 @@ "max": [ null, null, - 20 + 30 ] } } @@ -231,4 +242,4 @@ { "shot": "s07_driven" } -] \ No newline at end of file +] diff --git a/crates/ui-egui/tests/scenarios/s10_parameters_drive_model.json b/crates/ui-egui/tests/scenarios/s10_parameters_drive_model.json index 2bcb2933..65f227b4 100644 --- a/crates/ui-egui/tests/scenarios/s10_parameters_drive_model.json +++ b/crates/ui-egui/tests/scenarios/s10_parameters_drive_model.json @@ -40,6 +40,7 @@ ] } }, + {"click": {"sketch": [20, -8]}}, { "text": "40" }, diff --git a/crates/ui-egui/tests/scenarios/s11_sketch_constraints.json b/crates/ui-egui/tests/scenarios/s11_sketch_constraints.json index 9a72c5f8..1cdd6062 100644 --- a/crates/ui-egui/tests/scenarios/s11_sketch_constraints.json +++ b/crates/ui-egui/tests/scenarios/s11_sketch_constraints.json @@ -95,6 +95,14 @@ ] } }, + { + "click": { + "sketch": [ + 20, + -8 + ] + } + }, { "text": "40" }, @@ -109,6 +117,14 @@ ] } }, + { + "click": { + "sketch": [ + 48, + 12 + ] + } + }, { "text": "25" }, @@ -123,6 +139,14 @@ ] } }, + { + "click": { + "sketch": [ + 30, + 20 + ] + } + }, { "text": "10" }, @@ -219,4 +243,4 @@ { "shot": "s11_done" } -] \ No newline at end of file +] diff --git a/crates/ui-egui/tests/scenarios/s20_section_with_joint_drive.json b/crates/ui-egui/tests/scenarios/s20_section_with_joint_drive.json index ef953588..aaefdc34 100644 --- a/crates/ui-egui/tests/scenarios/s20_section_with_joint_drive.json +++ b/crates/ui-egui/tests/scenarios/s20_section_with_joint_drive.json @@ -76,6 +76,14 @@ { "key": "Enter" }, + { + "call": "ui.set", + "params": { + "hiddenBodies": [ + "Body1" + ] + } + }, { "start": "sketch.create" }, @@ -84,6 +92,12 @@ "plane": "XZ" } }, + { + "call": "ui.set", + "params": { + "hiddenBodies": [] + } + }, { "start": "sketch.rectangle.two_point" }, @@ -99,7 +113,7 @@ "click": { "sketch": [ 50, - 10 + -10 ] } }, @@ -116,16 +130,13 @@ } }, { - "start": "solid.extrude" + "call": "ui.view", + "params": { + "view": "fit" + } }, { - "click": { - "world": [ - 40, - 0, - 5 - ] - } + "start": "solid.extrude" }, { "text": "20" @@ -236,4 +247,4 @@ { "shot": "s20_section_driven" } -] \ No newline at end of file +] diff --git a/crates/ui-egui/tests/scenarios/s23_configurations.json b/crates/ui-egui/tests/scenarios/s23_configurations.json index c1aa12b4..3d097ae4 100644 --- a/crates/ui-egui/tests/scenarios/s23_configurations.json +++ b/crates/ui-egui/tests/scenarios/s23_configurations.json @@ -43,6 +43,7 @@ ] } }, + {"click": {"sketch": [20, -8]}}, { "text": "40" }, diff --git a/crates/ui-egui/tests/scenarios/s26_drive_joint_typed.json b/crates/ui-egui/tests/scenarios/s26_drive_joint_typed.json index cc01f43d..1785b799 100644 --- a/crates/ui-egui/tests/scenarios/s26_drive_joint_typed.json +++ b/crates/ui-egui/tests/scenarios/s26_drive_joint_typed.json @@ -76,6 +76,14 @@ { "key": "Enter" }, + { + "call": "ui.set", + "params": { + "hiddenBodies": [ + "Body1" + ] + } + }, { "start": "sketch.create" }, @@ -84,6 +92,12 @@ "plane": "XZ" } }, + { + "call": "ui.set", + "params": { + "hiddenBodies": [] + } + }, { "start": "sketch.rectangle.two_point" }, @@ -99,7 +113,7 @@ "click": { "sketch": [ 50, - 10 + -10 ] } }, @@ -116,16 +130,13 @@ } }, { - "start": "solid.extrude" + "call": "ui.view", + "params": { + "view": "fit" + } }, { - "click": { - "world": [ - 40, - 0, - 5 - ] - } + "start": "solid.extrude" }, { "text": "20" @@ -240,4 +251,4 @@ { "shot": "s26_drive_typed" } -] \ No newline at end of file +] diff --git a/crates/ui-egui/tests/scenarios/s32_cut_in_active_component.json b/crates/ui-egui/tests/scenarios/s32_cut_in_active_component.json index 0df6a84d..e4377d17 100644 --- a/crates/ui-egui/tests/scenarios/s32_cut_in_active_component.json +++ b/crates/ui-egui/tests/scenarios/s32_cut_in_active_component.json @@ -102,7 +102,7 @@ "click": { "sketch": [ 52, - 10 + -10 ] } }, @@ -187,7 +187,7 @@ "click": { "sketch": [ 48, - 25 + 15 ] } }, @@ -239,4 +239,4 @@ { "shot": "s27_cut" } -] \ No newline at end of file +] diff --git a/crates/ui-egui/tests/scenarios/s37_browser_chevrons.json b/crates/ui-egui/tests/scenarios/s37_browser_chevrons.json index 83bcc0db..124b89f4 100644 --- a/crates/ui-egui/tests/scenarios/s37_browser_chevrons.json +++ b/crates/ui-egui/tests/scenarios/s37_browser_chevrons.json @@ -1,7 +1,4 @@ [ - { - "pending": "every chevron works; the browser has no Joints folder (solvecraft-shell)" - }, { "note": "Browser chevrons expand and collapse every kind of node (folders, components, groups, the origin, named views, document settings). Model: two components with a body each, a joint, a sketch, an offset plane, a named view." }, @@ -82,6 +79,14 @@ { "key": "Enter" }, + { + "call": "ui.set", + "params": { + "hiddenBodies": [ + "Body1" + ] + } + }, { "start": "sketch.create" }, @@ -90,6 +95,12 @@ "plane": "XZ" } }, + { + "call": "ui.set", + "params": { + "hiddenBodies": [] + } + }, { "start": "sketch.rectangle.two_point" }, @@ -105,7 +116,7 @@ "click": { "sketch": [ 50, - 10 + -10 ] } }, @@ -122,16 +133,13 @@ } }, { - "start": "solid.extrude" + "call": "ui.view", + "params": { + "view": "fit" + } }, { - "click": { - "world": [ - 40, - 0, - 5 - ] - } + "start": "solid.extrude" }, { "text": "20" diff --git a/crates/ui-egui/tests/scenarios/s43_root_sketch_on_moved_component_face.json b/crates/ui-egui/tests/scenarios/s43_root_sketch_on_moved_component_face.json new file mode 100644 index 00000000..5f2b316e --- /dev/null +++ b/crates/ui-egui/tests/scenarios/s43_root_sketch_on_moved_component_face.json @@ -0,0 +1,103 @@ +[ + { + "note": "User bug 1/4 (\"big square\"): with the root active, Create Sketch on a moved component's face puts the sketch on the face where it is shown, its projected loop on the face's edges (not at the component's own coordinates)." + }, + { + "call": "engine.execute", + "params": { + "command": "component.create", + "params": { + "name": "C" + } + } + }, + { + "call": "engine.execute", + "params": { + "command": "solid.box", + "params": { + "length": 40, + "width": 30, + "height": 20 + } + } + }, + { + "call": "engine.execute", + "params": { + "command": "component.activate", + "params": { + "component": "root" + } + } + }, + { + "call": "engine.execute", + "params": { + "command": "occurrence.move", + "params": { + "occurrence": "C:1", + "translate": [ + 100, + 0, + 0 + ] + } + } + }, + { + "call": "ui.view", + "params": { + "view": "fit" + } + }, + { + "start": "sketch.create" + }, + { + "click": { + "world": [ + 120, + 15, + 20 + ] + } + }, + { + "expect": { + "sketching": true + } + }, + { + "expect": { + "sketch_curves": { + "linked": 4, + "own": 0 + } + } + }, + { + "expect": { + "sketch_world": { + "sketch": "Sketch1", + "point": "p1", + "at": [ + 140, + 0, + 20 + ] + } + } + }, + { + "shot": "s43_root_sketch_on_moved_face" + }, + { + "start": "sketch.finish" + }, + { + "expect": { + "errors": 0 + } + } +] \ No newline at end of file diff --git a/crates/ui-egui/tests/scenarios/sketch_on_moved_component_face.json b/crates/ui-egui/tests/scenarios/sketch_on_moved_component_face.json index 5fe13d6a..8de5af8e 100644 --- a/crates/ui-egui/tests/scenarios/sketch_on_moved_component_face.json +++ b/crates/ui-egui/tests/scenarios/sketch_on_moved_component_face.json @@ -1,7 +1,4 @@ [ - { - "pending": "a root-active sketch on a face of a moved component lands in body-local coordinates (solvecraft-dialogs)" - }, { "note": "A box in a new component, the component moved +100 in x, the root active: a sketch on the box's top face projects the face's edges where the face is (x 100-140), not at the body's own coordinates (x 0-40)." }, diff --git a/crates/ui-egui/tests/scenarios/view_cube_y_up.json b/crates/ui-egui/tests/scenarios/view_cube_y_up.json index aa6d1967..98b19040 100644 --- a/crates/ui-egui/tests/scenarios/view_cube_y_up.json +++ b/crates/ui-egui/tests/scenarios/view_cube_y_up.json @@ -1,7 +1,7 @@ [ - {"note": "With Y up (#3) the view cube turns with the world: its TOP is world +Y and clicking it looks down −Y in the standard plan orientation; FRONT looks along −Z."}, + {"note": "With Y up (#3) the view cube turns with the world: its TOP is world +Y and clicking it looks down −Y in the standard plan orientation; FRONT looks along −Z."}, {"call": "engine.execute", "params": {"command": "solid.box", "params": {"length": 40, "width": 30, "height": 20}}}, - {"call": "ui.set", "params": {"upAxis": "y"}}, + {"call": "ui.prefs", "params": {"up_axis": "y"}}, {"call": "ui.view", "params": {"view": "home"}}, {"move": {"cube": [0, 0, 1]}}, {"expect": {"shown_handles": ["cube_hover:top"]}}, diff --git a/docs/wip-reconciliation.md b/docs/wip-reconciliation.md new file mode 100644 index 00000000..40559e11 --- /dev/null +++ b/docs/wip-reconciliation.md @@ -0,0 +1,22 @@ +# WIP branch reconciliation (#6) + +The branches predate the dotted command IDs. Their remaining changes were ported through +`crates/engine/src/legacy_ids.rs` and reconciled with the current implementation. + +| Branches | Result | +|---|---| +| `solvecraft-sk`, `solvecraft-d2` | Ported `62d22e2` and `e0b3138`: sketches/projections see placed components; cache keys include placements; moved feature dialogs resolve world picks; Joints uses Browser rows. | +| `solvecraft-b4` | Ported `2c18dac`: canvases carry component ownership and named joint origins follow component placements. | +| `solvecraft-asm` | Ported `bc05805`: joint snap feedback, Drive limits, joint menus, and Motion Study editing/playback controls. | +| `solvecraft-shell`, `solvecraft-shell-b` | Browser chevrons, shared occurrence Move triad, toolbar customization, workspace switcher and status labels are already present on main. Their scenarios remain active; the Joints chevron scenario is now active too. | +| `solvecraft-kdev3`, `solvecraft-kdev`, `solvecraft-kdev2` | Previously landed as `67c79ec`; the old refs were already removed. | +| `solvecraft-kdev4` | The earlier robustness, shell, blends, wasm and measurement work is already present. Ported the remaining `9f98449` stacked-prism sewing and repaired curved-boundary face picking. | +| `solvecraft-params(-build)` | Previously landed as `517b7a9`. | + +The source WIP refs are retained until this batch merges. Delete them only after the merged +main contains the reconciled changes and passes CI. + +Regression coverage includes root sketches on translated and rotated components, subsequent +component moves, canvas save/reopen, joint origins during pending moves, moved feature dialog +refill, Browser chevrons, sample building, and the UI scenarios. `cargo xtask ci` covers native +tests, wasm, layering and asset attribution.