SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch: the whole sketch updates while you type a dimension's value (#11584) (#11585)
Daniel8fb046aaa84d
diff --git a/crates/ui-egui/src/dim_view.rs b/crates/ui-egui/src/dim_view.rsindex c499ed3ba2..e19bdc4522 100644--- a/crates/ui-egui/src/dim_view.rs+++ b/crates/ui-egui/src/dim_view.rs@@ -65,6 +65,9 @@ struct Edit {/// or a reference, or pressed into the field. Until then every frame starts with the whole/// value selected, so the first key replaces it whatever else moved the caret (#11204).owned: bool,+ /// A value was typed, completed or given a reference: until then the draft is the design as+ /// it is, and the view is not put in its preview (see [`preview_world`]).+ typed: bool,/// Where the box sat last frame: a press only takes the value over once the box stayed put/// under it, so the click that placed or pinned the value does not.shown: Option<Pos2>,@@ -103,6 +106,8 @@ struct DimensionDraft {checked_expr: String,preview_doc: Arc<solidcraft_engine::doc::Document>,preview: Arc<solidcraft_engine::doc::ModelState>,+ /// Which solve `preview` is (see [`next_solve`]).+ solve: u64,error: Option<String>,/// A dimension that would over-constrain the sketch, placed as a driven (reference) one:/// it has no parameter and no value to edit (#320).@@ -231,6 +236,7 @@ pub fn begin_dimension(app: &mut SolveApp, entities: Vec<String>, at: Vec2) -> Rlive: None,selection: None,owned: false,+ typed: false,shown: None,picked: None,sketch: None,@@ -270,6 +276,7 @@ pub fn begin_live(app: &mut SolveApp, entities: Vec<String>, pointer: Option<Poslive,selection: None,owned: false,+ typed: false,shown: None,picked: None,sketch: None,@@ -329,6 +336,7 @@ fn reevaluate(app: &SolveApp, draft: &mut DimensionDraft, expr: &str) {match draft.evaluate(app, expr) {Ok(scratch) => {draft.preview = crate::open_meshing::session_world(&scratch);+ draft.solve = next_solve();draft.preview_doc = scratch.doc.clone();draft.error = None;}@@ -391,6 +399,7 @@ fn draft_of(app: &SolveApp, sketch: u64, entities: &[String], at: Option<Vec2>,at,checked_expr: expr.clone(),preview: crate::open_meshing::session_world(&scratch),+ solve: next_solve(),preview_doc: scratch.doc.clone(),error: None,driven,@@ -451,6 +460,8 @@ thread_local! {/// A text being dragged: dimension id, undo depth at the start, grab offset (sketch).static DRAG: RefCell<Option<(String, usize, Vec2)>> = const { RefCell::new(None) };static EDIT: RefCell<Option<Edit>> = const { RefCell::new(None) };+ /// Solves made for drafts so far: each preview's number, which the sketch scene is keyed on.+ static SOLVES: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };static PLACEMENT: RefCell<Option<Placement>> = const { RefCell::new(None) };/// The half-axis of an ellipse the last placed draft for these picks in this sketch/// measured (see `previous_axis`).@@ -509,6 +520,7 @@ pub fn model_double_click(app: &mut SolveApp, pos: Pos2) -> bool {live: None,selection: None,owned: false,+ typed: false,shown: None,picked: None,sketch: Some(d.sketch),@@ -610,6 +622,7 @@ fn open_editor(app: &mut SolveApp, id: Option<String>) -> bool {live: None,selection: None,owned: false,+ typed: false,shown: None,picked: None,sketch: None,@@ -773,8 +786,11 @@ pub fn show(app: &mut SolveApp, ui: &egui::Ui, painter: &egui::Painter, proj: &PSome((e.param.clone(), draft.clone()))});let placing = !editing();+ // While a value is typed the whole sketch, its other dimensions included, is drawn as the+ // value would leave it (#11584); placing one only measures, so nothing moves.+ let typed = preview_world(app);let draft = editor_draft.or_else(|| placing.then(|| placement_preview(app)).flatten());- let st = crate::open_meshing::session_world(&app.session);+ let st = typed.clone().unwrap_or_else(|| crate::open_meshing::session_world(&app.session));let Some(ss) = app.session.active_sketch.and_then(|s| st.sketch(s)) else {DRAWN.with(|d| d.borrow_mut().clear());// Only a finished sketch's dimension edited from the model view stays open, at its text.@@ -816,11 +832,15 @@ pub fn show(app: &mut SolveApp, ui: &egui::Ui, painter: &egui::Painter, proj: &Plet centres = chain_centres(sk);let draft_sketch = draft.as_ref().and_then(|(_, d)| d.preview.sketch(d.sketch));let draft_centres = draft_sketch.map(|solved| chain_centres(&solved.sketch));- let mut constraints = sk.constraints.iter().map(|c| (ss, c, false)).collect::<Vec<_>>();- if let (Some(source), Some((param, _))) = (draft_sketch, draft.as_ref()) {- // A driven draft is keyed by its constraint id (it has no parameter).- let ours = |c: &&solidcraft_engine::sketch::Constraint| c.param.as_deref() == Some(param.as_str()) || (c.driven && c.id == *param);- constraints.extend(source.sketch.constraints.iter().filter(ours).map(|c| (source, c, true)));+ // A driven draft is keyed by its constraint id (it has no parameter).+ let ours = |c: &solidcraft_engine::sketch::Constraint| {+ draft.as_ref().is_some_and(|(param, _)| c.param.as_deref() == Some(param.as_str()) || (c.driven && c.id == *param))+ };+ // Drawn from the typed value's solve, the sketch already holds the draft: it is told apart+ // by its parameter, as below.+ let mut constraints = sk.constraints.iter().filter(|c| typed.is_none() || !ours(c)).map(|c| (ss, c, false)).collect::<Vec<_>>();+ if let Some(source) = draft_sketch {+ constraints.extend(source.sketch.constraints.iter().filter(|c| ours(c)).map(|c| (source, c, true)));}// Text boxes already drawn this frame, in draw order: a later dimension that would land// on one of them steps clear of it (#44).@@ -965,6 +985,7 @@ pub fn edit_param(app: &SolveApp, param: &str) {live: None,selection: None,owned: false,+ typed: false,shown: None,picked: None,sketch: None,@@ -992,6 +1013,7 @@ fn is_plain_value(text: &str) -> bool {////// The cursor ends just after the name and the field keeps the keyboard.fn insert_reference(ctx: &egui::Context, edit: &mut Edit, name: &str) {+ edit.typed = true;let id = egui::Id::new("sc_dim_edit");let mut state = egui::TextEdit::load_state(ctx, id).unwrap_or_default();let len = edit.expr.chars().count();@@ -1024,7 +1046,7 @@ fn insert_reference(ctx: &egui::Context, edit: &mut Edit, name: &str) {/// Consume dimension clicks while editing: a click on another driving dimension inserts its/// name at the cursor (replacing selected text), keeping what was typed. The second click of a/// double-click on the same dimension does not insert it again.-pub fn pick_reference(ctx: &egui::Context, pos: Pos2, double: bool) -> bool {+pub fn pick_reference(app: &SolveApp, ctx: &egui::Context, pos: Pos2, double: bool) -> bool {EDIT.with(|editor| {let mut editor = editor.borrow_mut();let Some(edit) = editor.as_mut() else { return false };@@ -1043,6 +1065,12 @@ pub fn pick_reference(ctx: &egui::Context, pos: Pos2, double: bool) -> bool {if !repeat {insert_reference(ctx, edit, ¶m);edit.picked = Some((param, now));+ // Solved now, as a typed value is: the overlays read the preview before the+ // editor runs this frame.+ if let Some(draft) = edit.draft.as_mut() {+ let expr = edit.expr.clone();+ reevaluate(app, draft, &expr);+ }}}edit.fresh = FRESH - 1;@@ -1140,6 +1168,14 @@ fn edit_box(app: &mut SolveApp, ctx: &egui::Context) {live.typed |= r.changed() || completed;}e.owned |= r.changed() || completed;+ e.typed |= r.changed() || completed;+ // Solved now, so the next frame draws the sketch at the new value from its start.+ if (r.changed() || completed)+ && let Some(draft) = e.draft.as_mut()+ {+ let expr = e.expr.clone();+ reevaluate(app, draft, &expr);+ }if let Some(error) = e.draft.as_ref().and_then(|d| d.error.as_ref()) {crate::ui_kit::text(ui, error, crate::ui_kit::Text::Report("dimension_error", true));}@@ -1219,11 +1255,57 @@ fn clear_picks(app: &mut SolveApp) {}}+/// While a new dimension's value is typed: the design solved with that value (the last value+/// that solved), so the open sketch is drawn as Enter would leave it. None otherwise.+pub fn preview_world(app: &SolveApp) -> Option<Arc<solidcraft_engine::doc::ModelState>> {+ EDIT.with(|e| e.try_borrow().ok()?.as_ref().filter(|e| e.typed)?.draft.as_ref().filter(|d| !d.driven && d.valid(app)).map(|d| d.preview.clone()))+}++/// A number for a new solve, never one an earlier solve had: a preview's address can be an earlier+/// one's once that is freed, so the sketch scene is keyed on this instead.+fn next_solve() -> u64 {+ SOLVES.with(|n| {+ n.set(n.get() + 1);+ n.get()+ })+}++/// Which solve [`preview_world`] is, while there is one.+pub fn preview_solve(app: &SolveApp) -> Option<u64> {+ EDIT.with(|e| e.try_borrow().ok()?.as_ref().filter(|e| e.typed)?.draft.as_ref().filter(|d| !d.driven && d.valid(app)).map(|d| d.solve))+}++/// The sketch drawn at a typed value (the open one), while there is one: its design curves are+/// not where they are drawn, the other sketches' are.+pub fn previewed_sketch(app: &SolveApp) -> Option<u64> {+ preview_solve(app).and(app.session.active_sketch)+}+/// Is the inline editor open (it has the keyboard)?pub fn editing() -> bool {EDIT.with(|e| e.borrow().is_some())}+/// The open draft's typed text and the text its preview was solved for (tests).+#[cfg(test)]+pub fn solved_for() -> Option<(String, String)> {+ EDIT.with(|edit| {+ let edit = edit.borrow();+ let e = edit.as_ref()?;+ Some((e.expr.clone(), e.draft.as_ref()?.checked_expr.clone()))+ })+}++/// Solve the open draft again for `expr`, as a typed value or a moved text does (tests).+#[cfg(test)]+pub fn resolve(app: &SolveApp, expr: &str) {+ EDIT.with(|edit| {+ if let Some(draft) = edit.borrow_mut().as_mut().and_then(|e| e.draft.as_mut()) {+ reevaluate(app, draft, expr);+ }+ });+}+/// The open draft: its expression, the dimension it adds and the sketch it previews (tests).#[cfg(test)]pub fn draft_preview() -> Option<(String, solidcraft_engine::sketch::Constraint, solidcraft_engine::sketch::Sketch)> {diff --git a/crates/ui-egui/src/dimension_create_ui_tests.rs b/crates/ui-egui/src/dimension_create_ui_tests.rsindex 7693c18a13..869b3585ba 100644--- a/crates/ui-egui/src/dimension_create_ui_tests.rs+++ b/crates/ui-egui/src/dimension_create_ui_tests.rs@@ -668,8 +668,10 @@ fn dimension_to_fillet_virtual_sharp_keeps_the_arc_and_fixed_origin() {assert_eq!(h.app.session.doc.to_json(), baseline);}+/// While a new dimension's value is typed, a committed dimension moves with the sketch drawn at+/// that value and is picked where it is drawn; the draft is no hit target, and Esc puts it back.#[test]-fn draft_annotation_does_not_move_committed_dimension_hitboxes() {+fn a_committed_dimension_moves_with_the_typed_preview_and_is_picked_where_drawn() {crate::dim_view::cancel();let mut h = Harness::new();h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();@@ -685,8 +687,14 @@ fn draft_annotation_does_not_move_committed_dimension_hitboxes() {place(&mut h, &[[0., 0.], [0., 10.]], [-5., 5.]);type_value(&mut h, "12 mm");h.settle();- assert_eq!(crate::dim_view::text_at(&width), Some(at));- assert_eq!(crate::dim_view::drawn(), drawn, "draft annotations must not become committed hit targets");+ // The sketch is drawn at the typed height, so the width on the top side is drawn, and+ // picked, 2 mm higher; the draft itself is no hit target.+ let [_, top] = h.at(&json!({"world":[10,12,0]})).unwrap();+ let [_, was] = h.at(&json!({"world":[10,10,0]})).unwrap();+ let moved = crate::dim_view::text_at(&width).unwrap() - at;+ assert!(moved.x.abs() < 0.5 && (f64::from(moved.y) - (top - was)).abs() < 0.5, "the width follows its side: {moved:?}");+ let ids = |d: Vec<(String, egui::Pos2)>| d.into_iter().map(|(id, _)| id).collect::<Vec<_>>();+ assert_eq!(ids(crate::dim_view::drawn()), ids(drawn.clone()), "draft annotations must not become committed hit targets");assert_eq!(h.app.session.doc.to_json(), baseline);h.step(&json!({"key":"Escape"})).unwrap();assert_eq!(crate::dim_view::drawn(), drawn);@@ -1032,6 +1040,253 @@ fn type_first_escape_cancels_with_no_change() {crate::dim_view::cancel();}+/// The open sketch's lines as the next frame paints them (the viewport's sketch scene, rebuilt+/// only when its key changes, before the frame's dimensions are drawn; the harness has no GPU,+/// so the test does it): their bounds, [min x, min y, max x, max y].+fn drawn_extent(h: &mut Harness) -> [f32; 4] {+ let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));+ let proj = crate::viewport::projection(&h.app, rect);+ crate::viewport::refresh_sketch_scene(&mut h.app, &proj);+ let slot = h.app.viewport.sketch_slot.lock().unwrap();+ let scene = slot.as_ref().expect("a sketch scene");+ let ends = scene.overlay.as_chunks::<32>().0.iter().flat_map(|l| [&l[0..12], &l[12..24]]);+ ends.map(|b| [0, 4].map(|i| b.get(i..i + 4).and_then(|x| x.try_into().ok()).map(f32::from_le_bytes)))+ .filter_map(|[x, y]| Some([x?, y?]))+ .fold([f32::MAX, f32::MAX, f32::MIN, f32::MIN], |m, [x, y]| [m[0].min(x), m[1].min(y), m[2].max(x), m[3].max(y)])+}++fn near(a: [f32; 4], b: [f32; 4]) -> bool {+ a.iter().zip(b).all(|(a, b)| (a - b).abs() < 0.6)+}++fn bounds(sk: &solidcraft_engine::sketch::Sketch) -> [f32; 4] {+ let (lo, hi) = sk.bounds().unwrap_or_default();+ [lo.x, lo.y, hi.x, hi.y].map(|v| v as f32)+}++/// While a value is typed the sketch is drawn as the value leaves it, not only the dimension+/// (#11584), whatever the shape; Esc draws it as it is again.+#[test]+fn typing_a_value_draws_the_sketch_at_that_value_and_escape_restores_it() {+ let fix = |entity: &str| ("sketch.constraint.fix", json!({"entity": entity}));+ let rectangle = vec![("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))];+ let circle = vec![("sketch.circle.center", json!({"center":[10,0],"radius":5})), fix("c1.center")];+ let slot = vec![("sketch.slot.center_to_center", json!({"p0":[-20,0],"p1":[20,0],"width":20}))];+ let arc = vec![("sketch.arc.center_point", json!({"center":[10,0],"start":[18,0],"sweep":90})), fix("a1.center")];+ let spline = vec![+ ("sketch.spline.fit_point", json!({"points": [[-30, 0], [-10, 18], [10, 6], [30, 20]]})),+ ("sketch.line", json!({"points":[[30,20],[30,-10]],"infer":true})),+ ];+ let mixed = vec![+ ("sketch.circle.center", json!({"center":[0,0],"radius":10})),+ ("sketch.circle.center", json!({"center":[40,0],"radius":10})),+ ("sketch.line", json!({"points":[[0,10],[40,10]],"infer":false})),+ ("sketch.constraint.tangent", json!({"a":"l1","b":"c1"})),+ ("sketch.constraint.tangent", json!({"a":"l1","b":"c2"})),+ ("sketch.constraint.equal", json!({"a":"c1","b":"c2"})),+ fix("c1.center"),+ fix("c2.center"),+ ];+ let half = std::f64::consts::FRAC_1_SQRT_2 * 8.0;+ let cases: [(&str, &[(&str, serde_json::Value)], [f64; 2], Vec<[f64; 2]>, &str); 6] = [+ ("rectangle side", &rectangle, [20., 10.], vec![[20., 0.]], "60"),+ ("circle diameter", &circle, [10., 0.], vec![[15., 0.]], "20"),+ ("slot side", &slot, [0., 0.], vec![[0., 10.]], "60"),+ ("arc radius", &arc, [10., 0.], vec![[10. + half, half]], "12"),+ ("spline end", &spline, [0., 5.], vec![[30., 5.]], "50"),+ ("tangent equal circles", &mixed, [20., 0.], vec![[-10., 0.]], "30"),+ ];+ for (name, setup, centre, picks, typed) in cases {+ let mut h = sketch_with(setup, centre);+ // Far enough out that the grown shapes stay in view (the drawn lines stop at its edge).+ h.app.cam.distance = 200.0;+ h.settle();+ let real = bounds(&solved(&h));+ let before = drawn_extent(&mut h);+ assert!(near(before, real), "{name}: drawn {before:?}, sketch {real:?}");+ for p in &picks {+ h.step(&json!({"click":{"world":[p[0],p[1],0]}})).unwrap();+ }+ assert_live(&h);+ keys(&mut h, typed);+ // What the frame after the last key paints, against the typed value's solve a frame later.+ let shown = drawn_extent(&mut h);+ h.frames(1);+ let (_, _, preview) = crate::dim_view::draft_preview().expect("the draft is open");+ let target = bounds(&preview);+ assert!(!near(target, real), "{name}: the typed value changes the sketch: {target:?}");+ assert!(near(shown, target), "{name}: the sketch follows the typed value: drawn {shown:?}, solved {target:?}");+ assert!(near(bounds(&solved(&h)), real), "{name}: nothing changes until Enter");+ // A value that does not solve (here half typed) keeps the last one that did.+ keys(&mut h, "*");+ assert_eq!(crate::dim_view::draft_preview().map(|(expr, _, _)| expr), Some(format!("{typed}*")));+ let kept = drawn_extent(&mut h);+ assert!(near(kept, target), "{name}: an unsolved value keeps the last drawn: {kept:?}");+ h.step(&json!({"key":"Escape"})).unwrap();+ assert!(!crate::dim_view::editing());+ let after = drawn_extent(&mut h);+ assert!(near(after, real), "{name}: Esc draws the sketch as it is: {after:?}");+ crate::dim_view::cancel();+ }+}++/// Each solve of a typed value redraws the sketch, also two between frames (a moved text and a+/// typed value in one frame), and a solve back to an earlier value: the scene is keyed on the+/// solve, not on where its result happens to be in memory.+#[test]+fn every_solve_of_a_typed_value_redraws_the_sketch() {+ let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);+ h.app.cam.distance = 300.0;+ h.settle();+ h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();+ assert_live(&h);+ keys(&mut h, "60");+ let sixty = drawn_extent(&mut h);+ let mut solves = std::collections::BTreeSet::new();+ for _ in 0..4 {+ crate::dim_view::resolve(&h.app, "70");+ crate::dim_view::resolve(&h.app, "80");+ assert!(solves.insert(crate::dim_view::preview_solve(&h.app).expect("a preview")), "a new solve has a new number");+ let (_, _, preview) = crate::dim_view::draft_preview().expect("the draft is open");+ let drawn = drawn_extent(&mut h);+ assert!(!near(drawn, sixty) && near(drawn, bounds(&preview)), "drawn {drawn:?}, solved {:?}", bounds(&preview));+ crate::dim_view::resolve(&h.app, "60");+ assert!(near(drawn_extent(&mut h), sixty));+ }+ crate::dim_view::cancel();+}++/// While a value is typed the sketch is drawn at it, so a profile under the pointer is not lit+/// where the design has it (over the resized one); it is again once the value is let go.+#[test]+fn a_typed_value_does_not_light_the_design_s_profile_under_the_pointer() {+ let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);+ h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();+ assert_live(&h);+ keys(&mut h, "60");+ let sketch = h.app.session.active_sketch.unwrap();+ h.app.viewport.hover = Some(crate::viewport::Hit::Profile { sketch, index: 0 });+ let key = crate::viewport::highlight_key(&h.app);+ assert!(crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "no profile lit while the value is typed");+ h.step(&json!({"key":"Escape"})).unwrap();+ h.app.viewport.hover = Some(crate::viewport::Hit::Profile { sketch, index: 0 });+ assert_ne!(crate::viewport::highlight_key(&h.app), key, "letting the value go lights it again");+ assert!(!crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "lit as before");+ crate::dim_view::cancel();+}++/// Until a value is typed the sketch is drawn as the design has it, so a picked dimension's+/// value box alone does not put the view in the typed preview: the profile under the pointer+/// stays lit. The first key does.+#[test]+fn a_dimension_only_picked_keeps_the_design_view_until_a_value_is_typed() {+ let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);+ h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();+ assert_live(&h);+ assert!(crate::dim_view::preview_solve(&h.app).is_none(), "nothing typed yet: no preview");+ let sketch = h.app.session.active_sketch.unwrap();+ h.app.viewport.hover = Some(crate::viewport::Hit::Profile { sketch, index: 0 });+ assert!(!crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "the profile is lit while only picked");+ keys(&mut h, "6");+ assert!(crate::dim_view::preview_solve(&h.app).is_some(), "a key starts the preview");+ crate::dim_view::cancel();+}++/// A selected profile is not lit where the design has it while a value is typed either.+#[test]+fn a_typed_value_does_not_light_a_selected_design_profile() {+ let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);+ h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();+ assert_live(&h);+ keys(&mut h, "60");+ let sketch = h.app.session.active_sketch.unwrap();+ h.app.session.selection = vec![solidcraft_engine::Sel::Profile { sketch, index: 0 }];+ assert!(crate::dim_view::preview_solve(&h.app).is_some(), "the value is still typed");+ assert!(crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "no profile lit while the value is typed");+ crate::dim_view::cancel();+ assert!(!crate::viewport::build_highlight(&h.app).merged().trans.is_empty(), "lit once the value is let go");+}++/// While a value is typed the sketch's curves are sampled before its profiles: a sketch whose+/// profiles would use up the sampling budget still has its curves drawn (its fills go first).+#[test]+fn a_typed_value_draws_the_curves_before_the_profiles_use_up_the_budget() {+ let mut h = sketch_with(+ &[("sketch.circle.center", json!({"center":[10,0],"radius":5})), ("sketch.constraint.fix", json!({"entity": "c1.center"}))],+ [10., 0.],+ );+ h.step(&json!({"click":{"world":[15,0,0]}})).unwrap();+ assert_live(&h);+ keys(&mut h, "20");+ let (_, _, preview) = crate::dim_view::draft_preview().expect("the draft is open");+ let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));+ let proj = crate::viewport::projection(&h.app, rect);+ let plane = h.app.session.world_state().unwrap().sketch(h.app.session.active_sketch.unwrap()).unwrap().plane;+ let mut all = solidcraft_engine::render::SamplingBudget::new(131_072, 1_048_576);+ let need = crate::sketch_display::curve_with_budget(&preview, 0, &plane, &proj, h.app.viewport.pixels_per_point(), &mut all).vertex_count;+ assert!(need > 4, "the circle takes some vertices: {need}");+ crate::sketch_display::UNCACHED_VERTICES.with(|v| v.set(Some(need)));+ let drawn = drawn_extent(&mut h);+ crate::sketch_display::UNCACHED_VERTICES.with(|v| v.set(None));+ assert!(near(drawn, bounds(&preview)), "the circle is drawn at the typed value: drawn {drawn:?}, solved {:?}", bounds(&preview));+ crate::dim_view::cancel();+}++/// Is a sketch point drawn at `world` this frame (its filled square)?+fn point_drawn(h: &mut Harness, world: [f64; 2]) -> bool {+ let [x, y] = h.at(&json!({"world":[world[0], world[1], 0]})).unwrap();+ let at = egui::pos2(x as f32, y as f32);+ h.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Rect(r) if r.rect.width() == 5.0 && r.rect.center().distance(at) < 0.5))+}++/// Is a sketch curve's hover highlight painted this frame?+fn hover_painted(h: &Harness) -> bool {+ let col = egui::epaint::ColorMode::Solid(crate::theme::Tokens::get().hover_profile_edge);+ h.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::Path(p) if p.stroke.width == 3.0 && p.stroke.color == col))+}++/// While a value is typed, the sketch's points and constraint glyphs are drawn where the value+/// puts them as well as its curves, the next frame already (the value is solved when typed), and+/// no hover highlight traces a curve of the design; Esc puts everything back.+#[test]+fn typing_a_value_draws_points_and_glyphs_there_and_no_hover_of_the_design() {+ let rectangle = [("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))];+ let mut h = sketch_with(&rectangle, [30., 15.]);+ h.app.cam.distance = 200.0;+ h.settle();+ let glyphs = crate::sketch_tools::glyph_positions();+ assert!(!glyphs.is_empty());+ assert!(point_drawn(&mut h, [40., 20.]));+ h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();+ assert_live(&h);+ keys(&mut h, "60");+ // The frame after the last key, as the app draws it.+ h.frames(1);+ assert!(point_drawn(&mut h, [60., 30.]), "the corner is drawn where 60 puts it");+ assert!(!point_drawn(&mut h, [40., 20.]), "no point where the design has it");+ // The right side's glyph moves with its middle, from (40, 10) to (60, 15).+ let [x0, y0] = h.at(&json!({"world":[40,10,0]})).unwrap();+ let [x1, y1] = h.at(&json!({"world":[60,15,0]})).unwrap();+ let shift = egui::vec2((x1 - x0) as f32, (y1 - y0) as f32);+ let typed = crate::sketch_tools::glyph_positions();+ let moved = |id: &String, at: egui::Pos2| glyphs.iter().any(|(was_id, was)| was_id == id && (at - *was - shift).length() < 1.5);+ assert!(typed.iter().any(|(id, at)| moved(id, *at)), "a glyph follows the right side: {glyphs:?} -> {typed:?}, shift {shift:?}");+ // Over where the design's right side is, nothing is drawn, so nothing lights up.+ h.step(&json!({"move":{"world":[40,10,0]}})).unwrap();+ h.frames(1);+ assert!(!hover_painted(&h), "no hover highlight of the design's curve");+ // One more key and one frame: the value is solved in the frame it is typed, so the next+ // frame's sketch scene, built before the dimensions are drawn, is already at that value.+ h.frame_with(vec![egui::Event::Text("5".into())]);+ let (text, solved) = crate::dim_view::solved_for().expect("the draft is open");+ assert_eq!((text.as_str(), solved.as_str()), ("605", "605"));+ h.step(&json!({"key":"Escape"})).unwrap();+ h.frames(1);+ assert!(point_drawn(&mut h, [40., 20.]));+ assert_eq!(crate::sketch_tools::glyph_positions(), glyphs);+ crate::dim_view::cancel();+}+/// Place first still works: a click before typing puts the text there and keeps the value/// (selected, so typing replaces it); Tab leaves the picks for a click to place, as before.#[test]@@ -1733,3 +1988,61 @@ fn the_status_after_a_dimension_is_in_the_interface_language() {}crate::dim_view::cancel();}++/// A selected curve of the sketch is not lit where the design has it while a value is typed, as+/// a selected profile is not.+#[test]+fn a_typed_value_does_not_light_a_selected_design_curve() {+ let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);+ h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();+ assert_live(&h);+ keys(&mut h, "60");+ let sketch = h.app.session.active_sketch.unwrap();+ let id = solved(&h).curves[0].id.clone();+ for sel in [+ solidcraft_engine::Sel::SketchCurve { id: id.clone(), sketch: None },+ solidcraft_engine::Sel::SketchCurve { id: id.clone(), sketch: Some(sketch) },+ solidcraft_engine::Sel::ExternalSketchCurve { sketch, id: id.clone() },+ ] {+ h.app.session.selection = vec![sel.clone()];+ assert!(crate::viewport::build_highlight(&h.app).overlay.is_empty(), "{sel:?}: no curve lit while the value is typed");+ }+ crate::dim_view::cancel();+ assert!(!crate::viewport::build_highlight(&h.app).overlay.is_empty(), "lit once the value is let go");+}++/// The Dimension tool's "x, y" readout gives the design's coordinates: while a value is typed it+/// is not drawn, as the hover highlight is not.+#[test]+fn a_typed_value_hides_the_pointer_readout() {+ let mut h = sketch_with(&[("sketch.rectangle.two_point", json!({"p0":[0,0],"p1":[40,20]}))], [20., 10.]);+ h.step(&json!({"move":{"world":[10,5,0]}})).unwrap();+ h.frames(1);+ assert!(crate::scenario::rect_of("viewport:readout").is_some(), "the readout is drawn while only pointing");+ h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();+ assert_live(&h);+ keys(&mut h, "60");+ h.step(&json!({"move":{"world":[12,6,0]}})).unwrap();+ h.frames(1);+ assert!(crate::scenario::rect_of("viewport:readout").is_none(), "no readout while the value is typed");+ crate::dim_view::cancel();+}++/// A curvature comb's teeth are the design's: while a value is typed they are not drawn.+#[test]+fn a_typed_value_hides_the_curvature_combs() {+ let mut h = sketch_with(&[("sketch.circle.center", json!({"center":[20,10],"radius":5}))], [20., 10.]);+ let id = solved(&h).curves[0].id.clone();+ h.app.run("inspect.curvature_comb", json!({"curves":[id]})).unwrap();+ h.step(&json!({"start":"sketch.dimension"})).unwrap();+ let teeth = egui::epaint::Stroke::new(1.0, crate::theme::Tokens::get().comb_teeth);+ let comb_drawn = |h: &Harness| h.shapes.iter().any(|s| matches!(&s.shape, egui::Shape::LineSegment { stroke, .. } if *stroke == teeth));+ h.frames(1);+ assert!(comb_drawn(&h), "the comb is drawn");+ h.step(&json!({"click":{"world":[25,10,0]}})).unwrap();+ assert_live(&h);+ keys(&mut h, "8");+ h.frames(1);+ assert!(!comb_drawn(&h), "no comb of the design while the value is typed");+ crate::dim_view::cancel();+}diff --git a/crates/ui-egui/src/sketch_display.rs b/crates/ui-egui/src/sketch_display.rsindex 3c186af8f1..82ec84e07e 100644--- a/crates/ui-egui/src/sketch_display.rs+++ b/crates/ui-egui/src/sketch_display.rs@@ -190,6 +190,60 @@ impl Default for SketchBudget {}}+impl SketchBudget {+ fn sampling_left(&self) -> bool {+ self.sampling.remaining_vertices > 0 && self.sampling.remaining_nodes > 0+ }++ fn room_for_curve(&self) -> bool {+ self.curves < SKETCH_CURVES && self.sampling_left()+ }++ fn room_for_profile(&self) -> bool {+ self.profiles < SKETCH_PROFILES && self.sampling_left()+ }+}++/// One sketch sampled past the cache (the open sketch at a dimension's typed value), within the+/// limits the cache gives one sketch: past them a curve or profile is not drawn, as there.+pub(crate) struct Uncached(SketchBudget);++#[cfg(test)]+thread_local! {+ /// A smaller sampling budget for [`Uncached`] (vertices), so a test can run out of it.+ pub(crate) static UNCACHED_VERTICES: std::cell::Cell<Option<usize>> = const { std::cell::Cell::new(None) };+}++impl Default for Uncached {+ fn default() -> Self {+ #[allow(unused_mut)]+ let mut budget = SketchBudget::default();+ #[cfg(test)]+ if let Some(vertices) = UNCACHED_VERTICES.with(std::cell::Cell::get) {+ budget.sampling = SamplingBudget::new(vertices, 1_048_576);+ }+ Self(budget)+ }+}++impl Uncached {+ pub(crate) fn curve(&mut self, sketch: &Sketch, index: usize, plane: &Plane, proj: &Proj, ppp: f32) -> Vec<Vec<Vec3>> {+ if !self.0.room_for_curve() {+ return Vec::new();+ }+ self.0.curves += 1;+ curve_with_budget(sketch, index, plane, proj, ppp, &mut self.0.sampling).parts+ }++ pub(crate) fn profile(&mut self, region: &Region2, plane: &Plane, proj: &Proj, ppp: f32) -> Option<Region2> {+ if !self.0.room_for_profile() {+ return None;+ }+ self.0.profiles += 1;+ display_region_with_budget(region, plane, proj, ppp, &mut self.0.sampling)+ }+}+/// The most curves and profiles one sketch caches per model state and view.const SKETCH_CURVES: usize = 4096;const SKETCH_PROFILES: usize = 1024;@@ -237,11 +291,7 @@ impl DisplayCache {return path.clone();}let budget = self.budgets.entry(sketch).or_default();- if budget.curves >= SKETCH_CURVES- || self.curves.len() >= CACHED_CURVES- || budget.sampling.remaining_vertices == 0- || budget.sampling.remaining_nodes == 0- {+ if !budget.room_for_curve() || self.curves.len() >= CACHED_CURVES {return Arc::new(SampledPath { parts: Vec::new(), quality: SamplingQuality::BudgetLimited, vertex_count: 0 });}let path = Arc::new(state.sketch(sketch).map_or_else(@@ -262,11 +312,7 @@ impl DisplayCache {return region.clone();}let budget = self.budgets.entry(sketch).or_default();- if budget.profiles >= SKETCH_PROFILES- || self.profiles.len() >= CACHED_PROFILES- || budget.sampling.remaining_vertices == 0- || budget.sampling.remaining_nodes == 0- {+ if !budget.room_for_profile() || self.profiles.len() >= CACHED_PROFILES {return Arc::new(None);}let region = Arc::new(diff --git a/crates/ui-egui/src/sketch_tools.rs b/crates/ui-egui/src/sketch_tools.rsindex 04ba29e907..fb666ebe64 100644--- a/crates/ui-egui/src/sketch_tools.rs+++ b/crates/ui-egui/src/sketch_tools.rs@@ -486,6 +486,10 @@ fn comb_options_card(app: &mut SolveApp, ctx: &egui::Context, proj: &Proj) {/// Curvature combs (`Session::comb`): teeth and the envelope through their tips.fn combs(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {let Some(shown) = &app.session.comb else { return };+ // The teeth are the design's: not while a value is typed and the sketch is drawn at it.+ if crate::dim_view::preview_world(app).is_some() {+ return;+ }let tk = crate::theme::Tokens::get();for comb in &shown.teeth {let mut tips: Vec<Pos2> = Vec::new();@@ -1704,7 +1708,8 @@ fn sketch_px_per_mm(plane: &Plane, proj: &Proj) -> Option<f32> {fn glyphs(app: &SolveApp, painter: &egui::Painter, proj: &Proj, hover: Option<Pos2>) {let Some(sid) = active_sketch(app) else { return };- let st = crate::open_meshing::session_world(&app.session);+ // While a dimension's value is typed, the glyphs sit where that value puts their geometry.+ let st = crate::dim_view::preview_world(app).unwrap_or_else(|| crate::open_meshing::session_world(&app.session));let Some(ss) = st.sketch(sid) else { return };if ss.sketch.view.hide_constraints {GLYPHS.with(|g| g.borrow_mut().clear());diff --git a/crates/ui-egui/src/tools.rs b/crates/ui-egui/src/tools.rsindex ad75a22823..8471634c23 100644--- a/crates/ui-egui/src/tools.rs+++ b/crates/ui-egui/src/tools.rs@@ -1178,14 +1178,17 @@ pub fn preview(app: &SolveApp, t: &Tool, painter: &egui::Painter, proj: &Proj) {if snap.as_deref() == Some("Midpoint") && t.kind == Kind::HorizontalVertical {painter.circle_stroke(sp, 8.0, Stroke::new(2.0, tk.accent));}- let readout = painter.text(- crate::tool_cursor::readout_at(painter, proj.rect, sp),- egui::Align2::LEFT_TOP,- format!("{}, {}", crate::prefs::show_mm(app, hp.x, 1), crate::prefs::show_mm(app, hp.y, 1)),- egui::FontId::proportional(crate::theme::Tokens::get().font_small),- tk.text_dim,- );- crate::scenario::publish_rect("viewport:readout", readout);+ // The design's coordinates: not while a value is typed and the sketch is drawn at it.+ if crate::dim_view::preview_world(app).is_none() {+ let readout = painter.text(+ crate::tool_cursor::readout_at(painter, proj.rect, sp),+ egui::Align2::LEFT_TOP,+ format!("{}, {}", crate::prefs::show_mm(app, hp.x, 1), crate::prefs::show_mm(app, hp.y, 1)),+ egui::FontId::proportional(crate::theme::Tokens::get().font_small),+ tk.text_dim,+ );+ crate::scenario::publish_rect("viewport:readout", readout);+ }}if matches!(t.kind, Kind::HorizontalVertical | Kind::Dimension) {for target in &t.point_picks {diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex aa818af2ef..3ac2c8bf37 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -152,7 +152,7 @@ pub struct ViewportState {pub(crate) key: u64,/// Ground geometry is reused independently of the camera-dependent sketch/grid scene.shadow: std::sync::Mutex<Option<ShadowGeometry>>,- sketch_slot: SceneSlot,+ pub(crate) sketch_slot: SceneSlot,sketch_key: u64,physical_scale: f32,pub(crate) display: std::sync::Mutex<crate::sketch_display::DisplayCache>,@@ -660,6 +660,8 @@ fn sketch_scene_key(app: &SolveApp, proj: &Proj) -> u64 {// Conflicting curves in their own colour, or as before (#7244).app.preferences.sketch_conflict_colour.hash(&mut h);(std::sync::Arc::as_ptr(&crate::open_meshing::shown_world(app)) as usize).hash(&mut h);+ // The open sketch follows a dimension's typed value.+ crate::dim_view::preview_solve(app).hash(&mut h);crate::sketch_display::projection_key(proj, app.viewport.pixels_per_point()).hash(&mut h);h.finish()}@@ -1832,6 +1834,18 @@ pub(crate) fn seam_width(order: Option<solidcraft_engine::kernel::Continuity>) -2.6 + past_g2 as f32}+/// Rebuild the sketch scene when what it shows has changed.+pub(crate) fn refresh_sketch_scene(app: &mut SolveApp, proj: &Proj) {+ let sk = sketch_scene_key(app, proj);+ if sk != app.viewport.sketch_key {+ let scene = build_sketch_scene(app, proj);+ if let Ok(mut slot) = app.viewport.sketch_slot.lock() {+ *slot = Some(scene);+ }+ app.viewport.sketch_key = sk;+ }+}+/// View-dependent geometry: grid, sketch feedback and the ground shadow's visibility.pub(crate) fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {let tk = Tokens::get();@@ -1924,16 +1938,38 @@ pub(crate) fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {}}}+ // While a dimension's value is typed, the open sketch as that value leaves it. Sampled past+ // the display cache, which holds the design's own solve for picking.+ let typed = crate::dim_view::preview_world(app);+ let ppp = app.viewport.pixels_per_point();+ let mut uncached = crate::sketch_display::Uncached::default();for sid in visible_sketches(app) {- let Some(ss) = st.sketch(sid) else { continue };let active = s.active_sketch == Some(sid);+ let typed = typed.as_ref().filter(|_| active);+ let Some(ss) = typed.unwrap_or(&st).sketch(sid) else { continue };+ // Its curves are sampled before its profiles, which share their budget: past it a fill+ // goes missing rather than a curve.+ let mut typed_curves: std::collections::HashMap<usize, Vec<Vec<Vec3>>> = match typed {+ Some(_) => (0..ss.sketch.curves.len())+ .filter(|i| solidcraft_engine::view::sketch_curve_visible(&ss.sketch, *i))+ .map(|i| (i, uncached.curve(&ss.sketch, i, &ss.plane, proj, ppp)))+ .collect(),+ None => std::collections::HashMap::new(),+ };// Closed profiles are shaded (lifted off a face they may lie on).let lift = ss.plane.normal() * 0.01;let profiles = if app.session.visibility.hidden_profiles.contains(&sid) || ss.sketch.view.hide_profile { &[][..] } else { &ss.profiles[..] };let profile_fill = sc.color(c4(tk.profile_fill));- for (index, _) in profiles.iter().enumerate() {- let display = crate::sketch_display::profile_region(app, sid, index, &ss.plane, proj);- for tri in display.as_ref().as_ref().map_or_else(Vec::new, |region| crate::sketch_display::fill_triangles(region, &mut fill_budget)) {+ for (index, profile) in profiles.iter().enumerate() {+ let (sampled, cached);+ let display = if typed.is_some() {+ sampled = uncached.profile(&profile.region, &ss.plane, proj, ppp);+ &sampled+ } else {+ cached = crate::sketch_display::profile_region(app, sid, index, &ss.plane, proj);+ cached.as_ref()+ };+ for tri in display.as_ref().map_or_else(Vec::new, |region| crate::sketch_display::fill_triangles(region, &mut fill_budget)) {for q in tri {sc.trans_tri((ss.plane.to_world(q) + lift).to_f32(), [0.0; 3], profile_fill);}@@ -1951,7 +1987,10 @@ pub(crate) fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {let conflict = if active { Conflict::of(app, &ss.sketch, &ss.report) } else { Conflict::default() };let mut owners = Vec::new();let lines = sketch_lines_with_sampler(&ss.sketch, &ss.plane, active, &ss.report.curve_determined, |_, index, plane| {- let parts = crate::sketch_display::curve_sample(app, sid, index, plane, proj).parts.clone();+ let parts = match typed {+ Some(_) => typed_curves.remove(&index).unwrap_or_default(),+ None => crate::sketch_display::curve_sample(app, sid, index, plane, proj).parts.clone(),+ };owners.extend(std::iter::repeat_n(index, parts.len()));parts});@@ -3807,6 +3846,8 @@ pub(crate) fn highlight_key(app: &SolveApp) -> u64 {highlight_geometry_key(app).hash(&mut h);let selected = app.highlighted();app.cam.half_height().to_bits().hash(&mut h);+ // A typed dimension value hides the hovered profile (see `build_highlight`).+ crate::dim_view::preview_solve(app).is_some().hash(&mut h);// Body triangles and outlines live in world space; the GPU applies the new camera.// Only sketch feedback needs projected tessellation and the profile's lift toward the eye.let projected = selected.iter().any(|s| matches!(s, Sel::Profile { .. } | Sel::SketchCurve { .. } | Sel::ExternalSketchCurve { .. }))@@ -4264,7 +4305,12 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {}}}- Sel::Profile { sketch, index } => profile_fill(&mut feedback, app, *sketch, *index, t.sel_profile, t.sel_profile_edge),+ // Not while a dimension's value is typed: the design's profile would show over the+ // sketch drawn at it (as for the hovered one below). Other sketches are drawn where+ // they are.+ Sel::Profile { sketch, index } if crate::dim_view::previewed_sketch(app) != Some(*sketch) => {+ profile_fill(&mut feedback, app, *sketch, *index, t.sel_profile, t.sel_profile_edge)+ }// A 3D sketch curve, in the sketch it names, or whichever sketch has it.Sel::SketchCurve { id, sketch } if st.sketches.iter().any(|ss| ss.sketch.wire_index(id).is_some()) => {let sel_edge = feedback.color(c4(t.sel_edge));@@ -4277,7 +4323,10 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {}}// A curve picked into a dialog from another sketch than the active one names it.- Sel::ExternalSketchCurve { sketch, id } | Sel::SketchCurve { id, sketch: Some(sketch) } => {+ // Not the curves of the sketch drawn at a typed value: the design has them elsewhere.+ Sel::ExternalSketchCurve { sketch, id } | Sel::SketchCurve { id, sketch: Some(sketch) }+ if crate::dim_view::previewed_sketch(app) != Some(*sketch) =>+ {let sel_edge = feedback.color(c4(t.sel_edge));if let Some(ss) = st.sketch(*sketch)&& let Some(ci) = ss.sketch.curve_index(id)@@ -4295,7 +4344,7 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {}}}- Sel::SketchCurve { id, .. } => {+ Sel::SketchCurve { id, .. } if crate::dim_view::previewed_sketch(app).is_none() => {if let Some(ss) = app.session.active_sketch.and_then(|sid| st.sketch(sid))&& let Some(ci) = ss.sketch.curve_index(id){@@ -4425,8 +4474,11 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {}}}+ // While a dimension's value is typed the sketch is drawn at it: the design's profile+ // would show over the resized one.Some(Hit::Profile { sketch, index })- if !sel.iter().any(|x| matches!(x, Sel::Profile { sketch: s2, index: i2 } if s2 == sketch && i2 == index)) =>+ if !sel.iter().any(|x| matches!(x, Sel::Profile { sketch: s2, index: i2 } if s2 == sketch && i2 == index))+ && crate::dim_view::previewed_sketch(app) != Some(*sketch) =>{profile_fill(&mut feedback, app, *sketch, *index, t.hover_profile, t.hover_profile_edge);}@@ -4713,14 +4765,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {app.viewport.build_ms = crate::now_ms() - t0;crate::frame_watch::step(app, "model scene");}- let sk = sketch_scene_key(app, &proj);- if sk != app.viewport.sketch_key {- let scene = build_sketch_scene(app, &proj);- if let Ok(mut slot) = app.viewport.sketch_slot.lock() {- *slot = Some(scene);- }- app.viewport.sketch_key = sk;- }+ refresh_sketch_scene(app, &proj);let hk = highlight_key(app);if hk != app.viewport.hl_key {let hl = build_highlight(app);@@ -4959,7 +5004,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {&& !midpoint_geometry&& !held&& app.dialog.is_none()- && crate::dim_view::pick_reference(ui.ctx(), p, resp.double_clicked());+ && crate::dim_view::pick_reference(app, ui.ctx(), p, resp.double_clicked());// Capture the press too: text editors lose focus before the click is released. A// running tool keeps the keyboard for its own typed values.if !held@@ -6578,9 +6623,16 @@ fn grid_centre(tf: Vec3, back: Vec3, n: Vec3, ext: f64) -> Vec3 {/// Hover feedback for the active sketch's points and curves (drawn on top of everything).fn hover_highlight(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {+ // While a dimension's value is typed the open sketch is drawn at that value, but hover follows+ // the design: a highlight there would trace a curve where none is drawn. Other sketches are+ // drawn where they are.+ let previewed = crate::dim_view::previewed_sketch(app);let col = Tokens::get().hover_profile_edge;let st = crate::open_meshing::shown_world(app);- match &app.viewport.hover {+ let hover = app.viewport.hover.as_ref().filter(|h| {+ !matches!(h, Hit::SketchCurve { sketch, .. } | Hit::SketchMidpoint { sketch, .. } | Hit::SketchPoint { sketch, .. } if previewed == Some(*sketch))+ });+ match hover {// Trim shows the piece it would take away instead (`sketch_tools::preview`, #3052).Some(Hit::SketchCurve { sketch, id, .. }) if crate::sketch_tools::trim_hover_piece(app, *sketch, id).is_some() => {}Some(Hit::SketchCurve { sketch, id, .. }) => {@@ -6611,6 +6663,7 @@ fn hover_highlight(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {}// The centre of the circle or arc hovered last: a cross in a ring, where a click takes it.if let Some((sketch, id)) = &app.viewport.woken_centre+ && previewed != Some(*sketch)&& !matches!(&app.viewport.hover, Some(Hit::SketchPoint { id: h, .. }) if h == id)&& let Some(ss) = st.sketch(*sketch)&& let Some(at) = ss.sketch.resolve_point(id).and_then(|i| ss.sketch.point(i))@@ -6724,6 +6777,8 @@ fn overlays(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {}}let Some(sid) = app.session.active_sketch else { return };+ // While a dimension's value is typed, its points where that value puts them.+ let st = crate::dim_view::preview_world(app).unwrap_or(st);let Some(ss) = st.sketch(sid) else { return };let sk = &ss.sketch;let locked = sk.locked_points();@@ -8112,6 +8167,44 @@ mod tests {);}+ /// While a dimension's value is typed only the open sketch, drawn at that value, loses its+ /// hover highlight: another sketch's curve is drawn where it is, so its hover still shows.+ #[test]+ fn a_typed_value_keeps_the_hover_of_another_sketch() {+ crate::dim_view::cancel();+ let mut h = crate::scenario::Harness::new();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ let line = h.app.run("sketch.line", json!({"points":[[0,30],[40,30]]})).unwrap()["curves"][0].as_str().unwrap().to_string();+ let other = h.app.session.active_sketch.unwrap();+ h.app.run("sketch.finish", json!({})).unwrap();+ h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();+ let own = h.app.run("sketch.line", json!({"points":[[0,0],[40,0]]})).unwrap()["curves"][0].as_str().unwrap().to_string();+ let open = h.app.session.active_sketch.unwrap();+ h.call("ui.view", json!({"view":"top"}));+ h.app.cam.distance = 80.0;+ h.app.cam.target = Vec3::new(20.0, 15.0, 0.0);+ h.settle();+ h.step(&json!({"start":"sketch.dimension"})).unwrap();+ h.step(&json!({"click":{"world":[20,0,0]}})).unwrap();+ h.step(&json!({"text":"60"})).unwrap();+ h.settle();+ assert!(crate::dim_view::preview_solve(&h.app).is_some(), "the value is typed");+ let proj = display_proj(&h.app);+ let drawn = |h: &crate::scenario::Harness| {+ let ctx = crate::fonts::test_context();+ let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {+ hover_highlight(&h.app, &ui.ctx().layer_painter(egui::LayerId::background()), &proj);+ });+ output.textures_delta.clear();+ !output.shapes.is_empty()+ };+ h.app.viewport.hover = Some(Hit::SketchCurve { sketch: other, id: line, straight: true, point: Vec3::ZERO });+ assert!(drawn(&h), "the other sketch's curve is lit under the pointer");+ h.app.viewport.hover = Some(Hit::SketchCurve { sketch: open, id: own, straight: true, point: Vec3::ZERO });+ assert!(!drawn(&h), "the open sketch's design curve is not");+ crate::dim_view::cancel();+ }+#[test]fn construction_drawing_and_hover_overlays_preserve_visible_gaps() {fn length(shape: &Shape) -> f32 {