Skip to content

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.rs
index 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) -> R
live: 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<Pos
live,
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: &P
Some((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: &P
let 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, &param);
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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 {