SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
User scenarios in the real UI, headless: scenario::Harness draws the app frame by frame into an egui context and drives it with control-channel input (toolbar starts, clicks on world/sketch/origin-plane/axis points, keys, typing, drags) and checks the model; tests/scenarios/*.json: box with fillets, shell and hole; revolve on XZ; sketch on a face and cut; mirror; delete and undo. Control: ui.at, ui.dialogInput. Fixes found by them: a shape started on an existing point (the origin, a corner) is tied to it; the Dimension tool's value is edited in place with the value selected, so typing replaces it
bherbruckd5b8aa0375f7
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rsindex 731adf5b67..65c66b6088 100644--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@ -232,6 +232,45 @@ pub fn handle(app: &mut SolveApp, ctx: &egui::Context, req: &ControlRequest) ->crate::sketch3d::handle_points(app, &proj).into_iter().map(|(n, p)| json!({"handle": n, "x": p.x, "y": p.y})).collect::<Vec<_>>()))}+ "ui.dialogInput" => {+ // What clicking a selection input's chip does: make it the one picks go to.+ let i = p.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;+ match app.dialog.as_mut() {+ Some(d) if i < d.inputs.len() => {+ d.active = i;+ ok(json!({"label": d.inputs.get(i).map(|x| x.label)}))+ }+ _ => err("no dialog input with that index"),+ }+ }+ "ui.at" => {+ // A scenario point: {world: [x,y,z]} | {sketch: [x,y]} | {plane: "XY"} (the middle of an+ // origin plane's square) → screen point.+ let Some(rect) = app.viewport.rect else { return err("no viewport") };+ let proj = crate::viewport::projection(app, rect);+ let num = |v: &Value, i: usize| v.get(i).and_then(Value::as_f64).unwrap_or(0.0);+ let world = if let Some(w) = p.get("world") {+ Some(solvecraft_engine::geom::Vec3::new(num(w, 0), num(w, 1), num(w, 2)))+ } else if let Some(s) = p.get("sketch") {+ let st = app.session.model.state();+ app.session+ .active_sketch+ .and_then(|id| st.sketch(id))+ .map(|ss| ss.plane.to_world(solvecraft_engine::geom::Vec2::new(num(s, 0), num(s, 1))))+ } else if let Some(n) = p.get("plane").and_then(Value::as_str) {+ crate::viewport::origin_planes(app).into_iter().find(|(name, _, _)| *name == n).map(|(_, _, q)| (q[0] + q[1] + q[2] + q[3]) / 4.0)+ } else if let Some(n) = p.get("axis").and_then(Value::as_str) {+ // Along an origin axis, on its solid part.+ let size = crate::selection::origin_size(app.cam.half_height());+ crate::viewport::origin_axes(app).into_iter().find(|(name, _)| *name == n).map(|(_, d)| d * (size * 0.8))+ } else {+ None+ };+ match world.and_then(|w| proj.to_screen(w)) {+ Some(q) => ok(json!([q.x, q.y])),+ None => err(format!("not on screen: {}", p)),+ }+ }"ui.worldToScreen" => {let Some(rect) = app.viewport.rect else { return err("no viewport") };let proj = crate::viewport::projection(app, rect);diff --git a/crates/ui-egui/src/dim_view.rs b/crates/ui-egui/src/dim_view.rsindex 3761d3fa45..24f1fbcfd1 100644--- a/crates/ui-egui/src/dim_view.rs+++ b/crates/ui-egui/src/dim_view.rs@@ -37,10 +37,13 @@ struct Drawn {struct Edit {param: String,expr: String,- at: Pos2,+ /// Where it sits (None until the dimension has been drawn).+ at: Option<Pos2>,/// Frames left in which the box (re)takes the keyboard: the rest of the double-click/// that opened it must not close it.fresh: u8,+ /// Frames left to wait for the dimension to be drawn.+ wait: u8,}thread_local! {@@ -103,7 +106,7 @@ pub fn double_click(app: &mut SolveApp, pos: Pos2) -> bool {return true;};let expr = app.session.doc.param(¶m).map(|p| p.expr.clone()).unwrap_or_default();- EDIT.with(|e| *e.borrow_mut() = Some(Edit { param, expr, at: d.text.center(), fresh: FRESH }));+ EDIT.with(|e| *e.borrow_mut() = Some(Edit { param, expr, at: Some(d.text.center()), fresh: FRESH, wait: 0 }));true}@@ -256,11 +259,29 @@ fn pos2_mid_top(r: Rect) -> Pos2 {}/// The inline value editor: Enter applies, Esc (or a click elsewhere) cancels.+/// Edit a dimension's value in place by its parameter (a new dimension from the Dimension tool:+/// its value is selected, so typing replaces it).+pub fn edit_param(app: &SolveApp, param: &str) {+ let expr = app.session.doc.param(param).map(|p| p.expr.clone()).unwrap_or_default();+ EDIT.with(|e| *e.borrow_mut() = Some(Edit { param: param.to_string(), expr, at: None, fresh: FRESH, wait: 10 }));+}+fn edit_box(app: &mut SolveApp, ctx: &egui::Context) {let Some(mut e) = EDIT.with(|x| x.borrow_mut().take()) else { return };+ if e.at.is_none() {+ e.at = DRAWN.with(|d| d.borrow().iter().find(|x| x.param.as_deref() == Some(e.param.as_str())).map(|x| x.text.center()));+ }+ let Some(at) = e.at else {+ // Not drawn yet (this frame's solve): try again next frame, for a few frames.+ if e.wait > 0 {+ e.wait -= 1;+ EDIT.with(|x| *x.borrow_mut() = Some(e));+ }+ return;+ };let id = egui::Id::new("sc_dim_edit");let mut done: Option<bool> = None;- egui::Area::new(egui::Id::new("sc_dim_edit_area")).fixed_pos(e.at - vec2(45.0, 11.0)).order(egui::Order::Foreground).show(ctx, |ui| {+ egui::Area::new(egui::Id::new("sc_dim_edit_area")).fixed_pos(at - vec2(45.0, 11.0)).order(egui::Order::Foreground).show(ctx, |ui| {egui::Frame::popup(ui.style()).inner_margin(egui::Margin::symmetric(3, 1)).show(ui, |ui| {let r = ui.add(egui::TextEdit::singleline(&mut e.expr).id(id).desired_width(90.0));crate::params_dialog::complete(ui, &r, &mut e.expr);diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex eaed32138e..abe5cb9731 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -31,6 +31,7 @@ pub mod params_dialog;mod preselect_tests;pub mod preview;pub mod ref_images;+pub mod scenario;pub mod selection;pub mod sketch3d;pub mod sketch_dims;diff --git a/crates/ui-egui/src/scenario.rs b/crates/ui-egui/src/scenario.rsnew file mode 100644index 0000000000..2a2deee543--- /dev/null+++ b/crates/ui-egui/src/scenario.rs@@ -0,0 +1,269 @@+//! User scenarios run headless: the real app (`SolveApp`) drawn frame by frame into an egui+//! context without a window, driven by the same requests as the control channel (clicks, keys,+//! drags, toolbar starts) the way a person would use it, with checks on the result.+//!+//! A scenario is a JSON list of steps:+//! - `{"start": "Extrude"}`: a toolbar click; `{"key": "E", "shift"?, "cmd"?}`; `{"text": "20"}`+//! - `{"click": AT, "double"?, "shift"?, "ctrl"?, "button"?}`, `{"move": AT}`,+//! `{"drag": [AT, AT], "shift"?, "steps"?}` where AT is `[x, y]` (screen), `{"world": [x,y,z]}`+//! or `{"sketch": [x,y]}` (the sketch being edited)+//! - `{"call": "ui.view", "params": {…}}`: any other control request (`fail: true` expects an+//! error)+//! - `{"shot": "name"}`: a screenshot when run in a window (ignored headless); `{"debug": 1}`+//! prints the UI state+//! - AT may also be `{"plane": "XY"}`: the middle of an origin plane's square+//! - `{"expect": {…}}`: checks, see [`check`]+//!+//! The same files drive the live app over the control channel for screenshots.++use serde_json::{Value, json};+use solvecraft_engine::Session;++use crate::control::{ControlRequest, Outcome, handle};+use crate::{Services, SolveApp};++/// The app in a headless egui context.+pub struct Harness {+ pub app: SolveApp,+ pub ctx: egui::Context,+ time: f64,+ size: egui::Vec2,+}++impl Default for Harness {+ fn default() -> Self {+ Harness::new()+ }+}++impl Harness {+ pub fn new() -> Harness {+ let mut h = Harness {+ app: SolveApp::new(Session::default(), Services::default()),+ ctx: egui::Context::default(),+ time: 0.0,+ size: egui::vec2(1600.0, 1000.0),+ };+ h.frames(3);+ h+ }++ /// Lay out and draw one frame (feeding queued pointer and key events).+ pub fn frame(&mut self) {+ self.time += 1.0 / 60.0;+ let mut raw = egui::RawInput {+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, self.size)),+ time: Some(self.time),+ focused: true,+ ..Default::default()+ };+ self.app.raw_input_hook(&mut raw);+ let app = &mut self.app;+ let mut out = self.ctx.run_ui(raw, |ui| {+ app.logic(ui.ctx());+ app.ui(ui);+ });+ // Nothing is painted: drop the frame's texture changes.+ out.textures_delta.clear();+ }++ pub fn frames(&mut self, n: usize) {+ for _ in 0..n {+ self.frame();+ }+ }++ /// Frames until the queued input is used up (and the view has settled).+ pub fn settle(&mut self) {+ for _ in 0..2000 {+ // Queued input used up and the view no longer moving.+ if self.app.synthetic.is_empty() && self.app.cam_anim.is_none() {+ break;+ }+ self.frame();+ }+ self.frames(4);+ }++ /// One control request, then frames until its input has been handled.+ pub fn call(&mut self, method: &str, params: Value) -> Value {+ let (req, _rx) = ControlRequest::new(method, params);+ let out = match handle(&mut self.app, &self.ctx, &req) {+ Outcome::Done(v) => v,+ Outcome::Screenshot { .. } => json!({"ok": true, "result": null}),+ };+ self.settle();+ out+ }++ /// A step's point on screen.+ pub fn at(&mut self, v: &Value) -> Result<[f64; 2], String> {+ if v.is_array() {+ let x = v.get(0).and_then(Value::as_f64).ok_or_else(|| format!("not a point: {v}"))?;+ let y = v.get(1).and_then(Value::as_f64).ok_or_else(|| format!("not a point: {v}"))?;+ return Ok([x, y]);+ }+ let r = self.call("ui.at", v.clone());+ let p = &r["result"];+ match (p.get(0).and_then(Value::as_f64), p.get(1).and_then(Value::as_f64)) {+ (Some(x), Some(y)) => Ok([x, y]),+ _ => Err(format!("{v} is not on screen: {r}")),+ }+ }++ /// Run one step.+ pub fn step(&mut self, s: &Value) -> Result<(), String> {+ let flag = |k: &str| s.get(k).and_then(Value::as_bool).unwrap_or(false);+ let res = if let Some(id) = s.get("start").and_then(Value::as_str) {+ self.call("ui.start", json!({ "command": id }))+ } else if let Some(k) = s.get("key").and_then(Value::as_str) {+ self.call("ui.key", json!({"key": k, "shift": flag("shift"), "cmd": flag("cmd")}))+ } else if let Some(t) = s.get("text").and_then(Value::as_str) {+ self.call("ui.text", json!({ "text": t }))+ } else if let Some(at) = s.get("click") {+ let [x, y] = self.at(at)?;+ // Hover first, as a hand does.+ self.call("ui.move", json!({"x": x, "y": y}));+ let mut p = json!({"x": x, "y": y, "double": flag("double"), "shift": flag("shift"), "ctrl": flag("ctrl")});+ if let Some(b) = s.get("button") {+ p["button"] = b.clone();+ }+ self.call("ui.click", p)+ } else if let Some(at) = s.get("move") {+ let [x, y] = self.at(at)?;+ self.call("ui.move", json!({"x": x, "y": y}))+ } else if let Some(d) = s.get("drag") {+ let [x0, y0] = self.at(d.get(0).unwrap_or(&Value::Null))?;+ let [x1, y1] = self.at(d.get(1).unwrap_or(&Value::Null))?;+ let steps = s.get("steps").cloned().unwrap_or(json!(8));+ self.call("ui.drag", json!({"x0": x0, "y0": y0, "x1": x1, "y1": y1, "steps": steps, "shift": flag("shift")}))+ } else if let Some(m) = s.get("call").and_then(Value::as_str) {+ self.call(m, s.get("params").cloned().unwrap_or(json!({})))+ } else if s.get("shot").is_some() {+ return Ok(());+ } else if s.get("debug").is_some() {+ let ui = self.call("ui.inspect", json!({}));+ let sel = self.call("ui.selection", json!({}));+ eprintln!(+ "debug: dialog {} tool {} hover {}\nselection {}\nstatus {:?}",+ ui["result"]["dialog"], ui["result"]["tool"], ui["result"]["hover"], sel["result"]["selection"], self.app.status+ );+ return Ok(());+ } else if let Some(e) = s.get("expect") {+ return check(self, e);+ } else {+ return Err(format!("unknown step {s}"));+ };+ let failed = res["ok"] != json!(true);+ if failed != flag("fail") {+ return Err(format!("{s}: {res}"));+ }+ Ok(())+ }++ /// Run a scenario (its steps); the error names the failing step.+ pub fn run(&mut self, steps: &Value) -> Result<(), String> {+ for (i, s) in steps.as_array().ok_or("a scenario is a list of steps")?.iter().enumerate() {+ self.step(s).map_err(|e| format!("step {i}: {e}"))?;+ }+ Ok(())+ }+}++fn approx(got: f64, want: &Value, what: &str) -> Result<(), String> {+ let (w, tol) = match want {+ Value::Array(a) => (a.first().and_then(Value::as_f64).unwrap_or(f64::NAN), a.get(1).and_then(Value::as_f64).unwrap_or(1e-3)),+ v => (v.as_f64().unwrap_or(f64::NAN), 1e-3),+ };+ if (got - w).abs() <= tol * w.abs().max(1.0) { Ok(()) } else { Err(format!("{what}: got {got}, want {w} (±{tol} rel)")) }+}++/// Checks: `bodies` (count), `volume` / `area` (total, number or [value, rel tol]), `faces`,+/// `features` (count), `errors` (timeline features in error, default 0), `dialog` (null: none+/// open, or a word its kind must contain), `tool` (null or command id), `sketching` (bool),+/// `selection` (count), `param` ({name: value}), `sketch_status` (solved|…), `dof`.+pub fn check(h: &mut Harness, e: &Value) -> Result<(), String> {+ let doc = h.call("document.inspect", json!({"measure": true}))["result"].clone();+ let ui = h.call("ui.inspect", json!({}))["result"].clone();+ let sum = |k: &str| doc["bodies"].as_array().into_iter().flatten().filter_map(|b| b[k].as_f64()).sum::<f64>();+ let total = json!({"volume_mm3": sum("volume_mm3"), "area_mm2": sum("area_mm2"), "faces": sum("faces") as u64});+ let total = &total;+ let bodies = doc["bodies"].as_array().map_or(0, Vec::len);+ let obj = e.as_object().ok_or("expect takes an object")?;+ for (k, v) in obj {+ match k.as_str() {+ "bodies" => {+ if v.as_u64() != Some(bodies as u64) {+ return Err(format!("bodies: got {bodies}, want {v}"));+ }+ }+ "volume" => approx(total["volume_mm3"].as_f64().unwrap_or(f64::NAN), v, "volume")?,+ "area" => approx(total["area_mm2"].as_f64().unwrap_or(f64::NAN), v, "area")?,+ "faces" => {+ if total["faces"] != *v {+ return Err(format!("faces: got {}, want {v}", total["faces"]));+ }+ }+ "features" => {+ let n = doc["timeline"].as_array().map_or(0, Vec::len);+ if v.as_u64() != Some(n as u64) {+ return Err(format!("features: got {n}, want {v}"));+ }+ }+ "errors" => {+ let bad: Vec<String> = doc["timeline"]+ .as_array()+ .into_iter()+ .flatten()+ .filter(|f| !f["error"].is_null())+ .map(|f| format!("{}: {}", f["name"], f["error"]))+ .collect();+ if v.as_u64() != Some(bad.len() as u64) {+ return Err(format!("errors: {bad:?}"));+ }+ }+ "dialog" => {+ let d = &ui["dialog"];+ let ok = match v {+ Value::Null => d.is_null(),+ Value::String(w) => d.as_str().is_some_and(|d| d.contains(w.as_str())),+ _ => false,+ };+ if !ok {+ return Err(format!("dialog: got {d}, want {v}"));+ }+ }+ "tool" => {+ if ui["tool"] != *v {+ return Err(format!("tool: got {}, want {v}", ui["tool"]));+ }+ }+ "sketching" => {+ if doc["active_sketch"].is_null() == v.as_bool().unwrap_or(false) {+ return Err(format!("sketching: want {v}, active sketch {}", doc["active_sketch"]));+ }+ }+ "selection" => {+ let n = doc["selection"].as_array().map_or(0, Vec::len);+ if v.as_u64() != Some(n as u64) {+ return Err(format!("selection: got {n}, want {v}"));+ }+ }+ "param" => {+ for (name, want) in v.as_object().into_iter().flatten() {+ let p = doc["params"].as_array().into_iter().flatten().find(|p| p["name"] == json!(name)).cloned().unwrap_or_default();+ approx(p["value"].as_f64().unwrap_or(f64::NAN), want, &format!("param {name}"))?;+ }+ }+ "sketch_status" | "dof" => {+ let si = h.call("engine.execute", json!({"command": "sketch.inspect", "params": {}}))["result"].clone();+ let key = if k == "dof" { "dof" } else { "status" };+ if si[key] != *v {+ return Err(format!("{k}: got {}, want {v}", si[key]));+ }+ }+ other => return Err(format!("unknown check `{other}`")),+ }+ }+ Ok(())+}diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rsindex e706b0ae47..4be487dca8 100644--- a/crates/ui-egui/src/tools.rs+++ b/crates/ui-egui/src/tools.rs@@ -163,7 +163,8 @@ pub fn on_click(app: &mut SolveApp, proj: &Proj, pos: Pos2) {if let Ok(v) = app.run("SketchDimension", json!({"entities": tool.picks}))&& let Some(p) = v["param"].as_str(){- app.dialog = Some(crate::dialogs::Dialog::edit_param(&app.session, p));+ // The value is edited in place, selected so typing replaces it.+ crate::dim_view::edit_param(app, p);}tool.picks.clear();}@@ -237,10 +238,41 @@ fn run_shape(app: &mut SolveApp, t: &Tool) -> Vec<String> {"DrawPoint" => json!({"point": xy(&p[0])}),_ => return Vec::new(),};- app.run(t.cmd, params)+ let curves: Vec<String> = app+ .run(t.cmd, params).ok().map(|v| v["curves"].as_array().into_iter().flatten().filter_map(|c| c.as_str().map(str::to_string)).collect())- .unwrap_or_default()+ .unwrap_or_default();+ tie_snaps(app, t, &curves);+ curves+}++/// A click that snapped to an existing point (the origin, a corner) but went in as plain+/// coordinates: tie the new shape's point there to it, as Fusion does.+fn tie_snaps(app: &mut SolveApp, t: &Tool, curves: &[String]) {+ let mut ties = Vec::new();+ {+ let st = app.session.model.state();+ let Some(ss) = app.session.active_sketch.and_then(|s| st.sketch(s)) else { return };+ let sk = &ss.sketch;+ let new_pts: Vec<usize> =+ curves.iter().filter_map(|c| sk.curve_index(c)).flat_map(|i| sk.curves.get(i).map(|c| c.kind.point_ids()).unwrap_or_default()).collect();+ for (at, r) in &t.pts {+ let Some(r) = r else { continue };+ let Some(target) = sk.resolve_point(r) else { continue };+ if new_pts.contains(&target) {+ continue;+ }+ if let Some(q) = new_pts.iter().copied().find(|q| sk.point(*q).is_some_and(|p| p.dist(*at) < 1e-6))+ && let Some(qid) = sk.points.get(q).map(|p| p.id.clone())+ {+ ties.push((r.clone(), qid));+ }+ }+ }+ for (a, b) in ties {+ let _ = app.run("ConstraintCoincident", json!({"a": a, "b": b}));+ }}fn run_pick(app: &mut SolveApp, t: &Tool) {diff --git a/crates/ui-egui/tests/scenarios.rs b/crates/ui-egui/tests/scenarios.rsnew file mode 100644index 0000000000..88d1d4ff6b--- /dev/null+++ b/crates/ui-egui/tests/scenarios.rs@@ -0,0 +1,25 @@+//! User scenarios in the real UI, headless (see `solvecraft_ui_egui::scenario`). Each JSON file+//! under `tests/scenarios/` is one workflow done with clicks, keys and drags.++use solvecraft_ui_egui::scenario::Harness;++fn run(name: &str) {+ let path = format!("{}/tests/scenarios/{name}.json", env!("CARGO_MANIFEST_DIR"));+ let text = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("{path}: {e}"));+ let steps: serde_json::Value = serde_json::from_str(&text).unwrap_or_else(|e| panic!("{path}: {e}"));+ let mut h = Harness::new();+ if let Err(e) = h.run(&steps) {+ panic!("{name}: {e}");+ }+}++macro_rules! scenarios {+ ($($name:ident),* $(,)?) => {+ $(#[test]+ fn $name() {+ run(stringify!($name));+ })*+ };+}++scenarios!(s01_box_fillet_hole_shell, s02_revolve_on_xz, s03_sketch_on_face_cut, s04_mirror_body, s05_delete_and_undo);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.jsonnew file mode 100644index 0000000000..0a9e5e298c--- /dev/null+++ b/crates/ui-egui/tests/scenarios/s01_box_fillet_hole_shell.json@@ -0,0 +1,206 @@+[+ {+ "start": "SketchCreate"+ },+ {+ "click": {+ "plane": "XY"+ }+ },+ {+ "expect": {+ "sketching": true+ }+ },+ {+ "start": "ShapeRectangleTwoPoint"+ },+ {+ "click": {+ "sketch": [+ 0,+ 0+ ]+ }+ },+ {+ "click": {+ "sketch": [+ 40,+ 30+ ]+ }+ },+ {+ "key": "Escape"+ },+ {+ "expect": {+ "dof": 2+ }+ },+ {+ "start": "SketchDimension"+ },+ {+ "click": {+ "sketch": [+ 20,+ 0+ ]+ }+ },+ {+ "text": "50"+ },+ {+ "key": "Enter"+ },+ {+ "key": "Escape"+ },+ {+ "expect": {+ "dialog": null,+ "param": {+ "d1": 50+ }+ }+ },+ {+ "shot": "s01_sketch"+ },+ {+ "call": "ui.view",+ "params": {+ "view": "iso"+ }+ },+ {+ "start": "SketchStop"+ },+ {+ "expect": {+ "sketching": false+ }+ },+ {+ "start": "Extrude"+ },+ {+ "text": "20"+ },+ {+ "key": "Enter"+ },+ {+ "expect": {+ "bodies": 1,+ "volume": 30000,+ "dialog": null+ }+ },+ {+ "shot": "s01_extrude"+ },+ {+ "start": "FusionFilletEdgesCommand"+ },+ {+ "click": {+ "world": [+ 50,+ 15,+ 20+ ]+ }+ },+ {+ "click": {+ "world": [+ 0,+ 15,+ 20+ ]+ }+ },+ {+ "text": "3"+ },+ {+ "key": "Enter"+ },+ {+ "expect": {+ "bodies": 1,+ "errors": 0,+ "dialog": null,+ "volume": [+ 29884.1,+ 1e-05+ ]+ }+ },+ {+ "shot": "s01_fillet"+ },+ {+ "start": "FusionShellBodyCommand"+ },+ {+ "click": {+ "world": [+ 25,+ 0,+ 10+ ]+ }+ },+ {+ "text": "2"+ },+ {+ "key": "Enter"+ },+ {+ "expect": {+ "bodies": 1,+ "errors": 0,+ "dialog": null+ }+ },+ {+ "shot": "s01_shell"+ },+ {+ "start": "FusionHoleCommand"+ },+ {+ "click": {+ "world": [+ 25,+ 15,+ 20+ ]+ }+ },+ {+ "text": "8"+ },+ {+ "key": "Enter"+ },+ {+ "expect": {+ "bodies": 1,+ "errors": 0,+ "dialog": null+ }+ },+ {+ "debug": 1+ },+ {+ "shot": "s01_hole"+ }+]\ No newline at end of filediff --git a/crates/ui-egui/tests/scenarios/s02_revolve_on_xz.json b/crates/ui-egui/tests/scenarios/s02_revolve_on_xz.jsonnew file mode 100644index 0000000000..381e38239d--- /dev/null+++ b/crates/ui-egui/tests/scenarios/s02_revolve_on_xz.json@@ -0,0 +1,18 @@+[+ {"start": "SketchCreate"},+ {"click": {"plane": "XZ"}},+ {"expect": {"sketching": true}},+ {"start": "ShapeRectangleTwoPoint"},+ {"click": {"sketch": [10, 0]}},+ {"click": {"sketch": [20, 30]}},+ {"key": "Escape"},+ {"shot": "s02_sketch"},+ {"start": "SketchStop"},+ {"call": "ui.view", "params": {"view": "iso"}},+ {"start": "Revolve"},+ {"click": {"axis": "Z"}},+ {"debug": 1},+ {"key": "Enter"},+ {"expect": {"bodies": 1, "errors": 0, "dialog": null, "volume": [28274.33, 1e-3]}},+ {"shot": "s02_revolve"}+]diff --git a/crates/ui-egui/tests/scenarios/s03_sketch_on_face_cut.json b/crates/ui-egui/tests/scenarios/s03_sketch_on_face_cut.jsonnew file mode 100644index 0000000000..0cf29ee01e--- /dev/null+++ b/crates/ui-egui/tests/scenarios/s03_sketch_on_face_cut.json@@ -0,0 +1,30 @@+[+ {"start": "SketchCreate"},+ {"click": {"plane": "XY"}},+ {"start": "ShapeRectangleTwoPoint"},+ {"click": {"sketch": [0, 0]}},+ {"click": {"sketch": [40, 30]}},+ {"key": "Escape"},+ {"start": "SketchStop"},+ {"call": "ui.view", "params": {"view": "iso"}},+ {"start": "Extrude"},+ {"text": "20"},+ {"key": "Enter"},+ {"expect": {"bodies": 1, "volume": 24000}},+ {"start": "SketchCreate"},+ {"click": {"world": [20, 15, 20]}},+ {"expect": {"sketching": true}},+ {"start": "CircleCenterRadius"},+ {"click": {"sketch": [20, 15]}},+ {"click": {"sketch": [25, 15]}},+ {"key": "Escape"},+ {"shot": "s03_sketch_on_face"},+ {"start": "SketchStop"},+ {"start": "Extrude"},+ {"click": {"world": [20, 15, 20]}},+ {"debug": 1},+ {"text": "-10"},+ {"key": "Enter"},+ {"expect": {"bodies": 1, "errors": 0, "dialog": null, "volume": [23214.6, 1e-4]}},+ {"shot": "s03_cut"}+]diff --git a/crates/ui-egui/tests/scenarios/s04_mirror_body.json b/crates/ui-egui/tests/scenarios/s04_mirror_body.jsonnew file mode 100644index 0000000000..d47533cf3a--- /dev/null+++ b/crates/ui-egui/tests/scenarios/s04_mirror_body.json@@ -0,0 +1,22 @@+[+ {"start": "SketchCreate"},+ {"click": {"plane": "XY"}},+ {"start": "CircleCenterRadius"},+ {"click": {"sketch": [20, 10]}},+ {"click": {"sketch": [25, 10]}},+ {"key": "Escape"},+ {"start": "SketchStop"},+ {"call": "ui.view", "params": {"view": "iso"}},+ {"start": "Extrude"},+ {"text": "10"},+ {"key": "Enter"},+ {"expect": {"bodies": 1}},+ {"start": "MirrorCommand"},+ {"click": {"world": [20, 10, 10]}},+ {"call": "ui.dialogInput", "params": {"index": 1}},+ {"click": {"plane": "YZ"}},+ {"debug": 1},+ {"key": "Enter"},+ {"expect": {"bodies": 2, "errors": 0, "dialog": null, "volume": [1570.8, 1e-3]}},+ {"shot": "s04_mirror"}+]diff --git a/crates/ui-egui/tests/scenarios/s05_delete_and_undo.json b/crates/ui-egui/tests/scenarios/s05_delete_and_undo.jsonnew file mode 100644index 0000000000..dc4a0f6e5a--- /dev/null+++ b/crates/ui-egui/tests/scenarios/s05_delete_and_undo.json@@ -0,0 +1,131 @@+[+ {+ "start": "SketchCreate"+ },+ {+ "click": {+ "plane": "XY"+ }+ },+ {+ "start": "ShapeRectangleTwoPoint"+ },+ {+ "click": {+ "sketch": [+ 0,+ 0+ ]+ }+ },+ {+ "click": {+ "sketch": [+ 30,+ 20+ ]+ }+ },+ {+ "key": "Escape"+ },+ {+ "start": "SketchStop"+ },+ {+ "call": "ui.view",+ "params": {+ "view": "iso"+ }+ },+ {+ "start": "Extrude"+ },+ {+ "text": "10"+ },+ {+ "key": "Enter"+ },+ {+ "expect": {+ "bodies": 1,+ "volume": 6000+ }+ },+ {+ "click": {+ "world": [+ 15,+ 10,+ 10+ ]+ }+ },+ {+ "expect": {+ "selection": 1+ }+ },+ {+ "expect": {+ "selection": 1+ }+ },+ {+ "call": "ui.menu",+ "params": {+ "x": 100,+ "y": 260,+ "target": {+ "type": "body",+ "name": "Body1"+ }+ }+ },+ {+ "call": "ui.menuPick",+ "params": {+ "item": "Delete"+ }+ },+ {+ "debug": 1+ },+ {+ "expect": {+ "bodies": 0+ }+ },+ {+ "key": "Z",+ "cmd": true+ },+ {+ "expect": {+ "bodies": 1,+ "volume": 6000+ }+ },+ {+ "key": "Y",+ "cmd": true+ },+ {+ "expect": {+ "bodies": 0+ }+ },+ {+ "key": "Z",+ "cmd": true+ },+ {+ "expect": {+ "bodies": 1+ }+ },+ {+ "shot": "s05_undone"+ }+]\ No newline at end of filediff --git a/docs/control-protocol.md b/docs/control-protocol.mdindex 0935ce7a5a..2dc6e6a04e 100644--- a/docs/control-protocol.md+++ b/docs/control-protocol.md@@ -35,6 +35,8 @@ Commands never open dialogs when run this way. `solvecraft-cli commands` prints| `ui.worldToScreen` | `points`: `[[x, y, z]…]` world points | their screen points || `ui.triad` | | screen points of the 3D sketch move triad's handles (`x`, `y`, `z`, `plane`) || `ui.sketchToScreen` | `points`: `[[x, y]…]` in active-sketch coordinates | their screen points (null when behind the camera) |+| `ui.dialogInput` | `index` | what clicking an input's Select chip does: picks go to that input |+| `ui.at` | `world: [x,y,z]` \| `sketch: [x,y]` \| `plane: "XY"` \| `axis: "Z"` | the screen point (a scenario step's target; see `crates/ui-egui/src/scenario.rs`) || `ui.editFeature` | `feature` (id or name) | what double-clicking a timeline item does: rolls back to it and opens its dialog filled in (sketches open in sketch mode) || `ui.scroll` | `x`, `y`, `delta?` | wheel zoom at the cursor || `ui.key` | `key` (egui key name, `Enter`, `Escape`…), `cmd?`, `shift?` | |