diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs index 34404ac3e..6bc558f23 100644 --- a/crates/ui-egui/src/canvas.rs +++ b/crates/ui-egui/src/canvas.rs @@ -368,7 +368,7 @@ pub fn snap_step(half_height: f64) -> f64 { } /// Parameter along the line `base + dir * t` closest to the view ray through `pos`. -fn along(proj: &Proj, pos: Pos2, base: Vec3, dir: Vec3) -> Option { +pub(crate) fn along(proj: &Proj, pos: Pos2, base: Vec3, dir: Vec3) -> Option { let (o, r) = proj.ray(pos); let w0 = base - o; let (b, d, e) = (dir.dot(r), dir.dot(w0), r.dot(w0)); @@ -575,7 +575,8 @@ fn draw(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj: &Proj, box_at = ts + vec2(14.0, -12.0); } } - value_box(ui, label, value, box_at, focus || *value != before); + let note = crate::drag_extrude::step_note(app); + value_box_noted(ui, label, value, box_at, focus || *value != before, note.as_deref()); if *value != before && let Kind::Extrude { all, .. } = &mut d.kind { @@ -600,17 +601,36 @@ fn value_box_with(ui: &mut egui::Ui, label: &str, value: &mut String, at: Pos2, value_box_in(ui, ids, label, value, (at, egui::Align2::LEFT_TOP), select_all, keep_tab); } +/// [`value_box`] with a note after the field (a pull's step size). +fn value_box_noted(ui: &mut egui::Ui, label: &str, value: &mut String, at: Pos2, select_all: bool, note: Option<&str>) { + let ids = (egui::Id::new("sc_canvas_area"), egui::Id::new("sc_canvas_value")); + value_box_full(ui, ids, label, value, (at, egui::Align2::LEFT_TOP), (select_all, false), note); +} + /// [`value_box_with`] under its own ids (its area's and its field's), for a value beside the main /// one (a hole's reference distances), with the point of the box that sits at `at`. Returns where /// the field is. pub(crate) fn value_box_in( + ui: &mut egui::Ui, + ids: (egui::Id, egui::Id), + label: &str, + value: &mut String, + at: (Pos2, egui::Align2), + select_all: bool, + keep_tab: bool, +) -> Option { + value_box_full(ui, ids, label, value, at, (select_all, keep_tab), None) +} + +/// [`value_box_in`] with a short dimmed note after the field (a pull's step size). +fn value_box_full( ui: &mut egui::Ui, (area, id): (egui::Id, egui::Id), label: &str, value: &mut String, (at, pivot): (Pos2, egui::Align2), - select_all: bool, - keep_tab: bool, + (select_all, keep_tab): (bool, bool), + note: Option<&str>, ) -> Option { let t = Tokens::get(); let mut field = None; @@ -627,6 +647,9 @@ pub(crate) fn value_box_in( st.cursor.set_char_range(Some(egui::text_selection::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(n)))); st.store(ui.ctx(), id); } + if let Some(note) = note { + ui.label(egui::RichText::new(note).color(t.text_dim).size(crate::theme::Tokens::get().font_caption)); + } field = Some(r.rect); }); }); diff --git a/crates/ui-egui/src/drag_extrude.rs b/crates/ui-egui/src/drag_extrude.rs new file mode 100644 index 000000000..261666540 --- /dev/null +++ b/crates/ui-egui/src/drag_extrude.rs @@ -0,0 +1,219 @@ +//! Extrude by dragging: press on a planar face (or a sketch profile) and pull. Once the pointer +//! has moved far enough upward, or along the surface's normal on screen, Extrude starts on the +//! pick; the distance follows the pointer along the normal in steps. Moving the pointer sideways +//! while pulling sets the step: to the right it grows (1, 2, 3 ... 10 mm), to the left it +//! shrinks (0.8, 0.5 ... 0.1 mm). The step and the distance show beside the pointer. Letting go +//! leaves the Extrude window open to adjust and confirm with OK. A press that goes any other +//! way stays a box selection. + +use egui::Pos2; +use solidcraft_engine::Sel; +use solidcraft_engine::geom::Vec3; + +use crate::SolveApp; +use crate::dialogs::{Kind, planar_face}; +use crate::viewport::{Hit, Proj}; + +/// Screen distance the pointer must travel before a press counts as a pull. +const START_PX: f32 = 6.0; +/// How closely (cosine) a drag must follow the normal's screen direction to start a pull. +const ALIGNED: f32 = 0.8; +/// Screen distance the pointer travels sideways for one step of the ladder. +const PX_PER_STEP: f32 = 44.0; +/// The step sizes (mm) a pull can snap to, finest first. +const STEPS: [f64; 25] = + [0.01, 0.02, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.65, 0.7, 0.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 20.0, 50.0, 100.0, 200.0, 500.0, 1000.0]; + +/// The ladder position nearest to `step`. +fn nearest_step(step: f64) -> usize { + (0..STEPS.len()).min_by(|a, b| (STEPS[*a] / step).ln().abs().total_cmp(&(STEPS[*b] / step).ln().abs())).unwrap_or(0) +} + +/// The ladder position `dx` screen points sideways from `base`, clamped to the ladder. +fn step_index(base: usize, dx: f32) -> usize { + let moved = (dx / PX_PER_STEP).round() as i64; + (base as i64 + moved).clamp(0, STEPS.len() as i64 - 1) as usize +} + +/// A press on a surface that may turn into a pull. +#[derive(Clone, Debug)] +pub struct Gesture { + press: Pos2, + sel: Sel, + /// A point on the surface where it was pressed, and its unit normal. + base: Vec3, + normal: Vec3, + /// Where along the normal the press was: the distance is measured from here. + grab: f64, + /// Extrude has started (the window is open and follows the pointer). + started: bool, + /// The step at the start (a ladder position) and the pointer's x there: sideways moves + /// from it change the step. + step0: usize, + x0: f32, + /// The step now, and where the pointer is, for the label. + step: f64, + at: Pos2, +} + +#[derive(Debug, Default)] +pub struct State { + gesture: Option, + /// The step of the last pull, shown in the window until it closes. + last_step: Option, +} + +/// A pull has started: the box selection stays out of it. +pub fn started(app: &SolveApp) -> bool { + app.viewport.drag_extrude.gesture.as_ref().is_some_and(|g| g.started) +} + +/// Note a press at `at` when it is on a planar face or a profile. +pub fn press(app: &mut SolveApp, proj: &Proj, at: Pos2) { + app.viewport.drag_extrude.gesture = None; + if !app.preferences.direct_interaction { + return; + } + let hits = crate::viewport::pick(app, proj, at); + let Some((hit, Some(sel))) = crate::viewport::candidate(app, &hits).map(|(h, s)| (h, Some(s))) else { return }; + let (o, d) = proj.ray(at); + let (base, normal) = match (&hit, &sel) { + (Hit::Face { point, .. }, Sel::Face { body, index, .. }) => match planar_face(&app.session, body, *index) { + Some((_, n)) => (*point, n), + None => return, + }, + (Hit::Profile { sketch, .. }, Sel::Profile { .. }) => { + let Some(plane) = crate::canvas::profile_plane(app, *sketch) else { return }; + match plane.intersect_ray(o, d) { + Some(p) => (p, plane.normal()), + None => return, + } + } + _ => return, + }; + let Some(grab) = crate::canvas::along(proj, at, base, normal) else { return }; + app.viewport.drag_extrude.gesture = Some(Gesture { + press: at, + sel, + base, + normal, + grab, + started: false, + step0: nearest_step(crate::canvas::snap_step(app.cam.half_height())), + x0: at.x, + step: 0.0, + at, + }); +} + +/// Whether the move from the press to `p` is a pull: upward, or along the normal on screen. +fn pulls(proj: &Proj, g: &Gesture, p: Pos2) -> bool { + let delta = p - g.press; + if delta.length() < START_PX { + return false; + } + let unit = delta / delta.length(); + let upward = delta.y < 0.0 && -unit.y > ALIGNED; + let along_normal = proj + .to_screen(g.base) + .zip(proj.to_screen(g.base + g.normal)) + .map(|(a, b)| b - a) + .filter(|n| n.length() > 1e-3) + .is_some_and(|n| (n / n.length()).dot(unit).abs() > ALIGNED); + upward || along_normal +} + +/// The pointer is at `p` with the button down. +pub fn to(app: &mut SolveApp, proj: &Proj, p: Pos2) { + let Some(mut g) = app.viewport.drag_extrude.gesture.clone() else { return }; + if !g.started { + if app.dialog.is_some() || !pulls(proj, &g, p) { + return; + } + crate::viewport::select(app, Some(g.sel.clone()), false, false); + app.start("solid.press_pull"); + if !matches!(app.dialog.as_ref().map(|d| &d.kind), Some(Kind::Extrude { .. })) { + app.viewport.drag_extrude.gesture = None; + return; + } + g = Gesture { started: true, x0: p.x, ..g }; + } + g.at = p; + g.step = STEPS[step_index(g.step0, p.x - g.x0)]; + let Some(v) = crate::canvas::along(proj, p, g.base, g.normal) else { + app.viewport.drag_extrude.gesture = Some(g); + return; + }; + let free = crate::tool_modifiers::manipulator_free(); + let travelled = v - g.grab; + let travelled = if free { travelled } else { (travelled / g.step).round() * g.step }; + app.viewport.drag_extrude.last_step = Some(g.step); + app.viewport.drag_extrude.gesture = Some(g); + let Some(Kind::Extrude { distance, direction, .. }) = app.dialog.as_mut().map(|d| &mut d.kind) else { return }; + // A reversed extrude measures its distance against the normal. + let sign = if matches!(*direction, 1 | crate::dialogs::TWO_SIDES_REVERSED) { -1.0 } else { 1.0 }; + *distance = crate::canvas::format_len(travelled * sign); +} + +/// The button is up: the window stays open for the user to adjust and confirm. +pub fn end(app: &mut SolveApp) { + app.viewport.drag_extrude.gesture = None; +} + +/// Forget the last pull's step once the window is gone. +pub fn tick(app: &mut SolveApp) { + if app.dialog.is_none() { + app.viewport.drag_extrude.last_step = None; + } +} + +/// The step of the last pull, for the value box next to the distance. +pub fn step_note(app: &SolveApp) -> Option { + let step = app.viewport.drag_extrude.last_step?; + Some(format!("Step {}", crate::canvas::format_len(step))) +} + +/// The ladder of steps beside the pointer while pulling: the one in use between its neighbours. +/// It sits below the pointer, clear of the distance box at the arrow tip. +pub fn show(app: &SolveApp, painter: &egui::Painter) { + let Some(g) = app.viewport.drag_extrude.gesture.as_ref().filter(|g| g.started) else { return }; + let t = crate::theme::Tokens::get(); + let now = nearest_step(g.step); + let galley = |i: usize, current: bool| { + let size = if current { t.font_body * 1.25 } else { t.font_body }; + let color = if current { t.accent } else { t.text_dim }; + let text = STEPS.get(i).map(|s| crate::canvas::format_len(*s)).unwrap_or_default(); + painter.layout_no_wrap(text, egui::FontId::proportional(size), color) + }; + let cells: Vec<_> = (now.saturating_sub(2)..=(now + 2).min(STEPS.len() - 1)).map(|i| (galley(i, i == now), i == now)).collect(); + let gap = 12.0; + let width = cells.iter().map(|(g, _)| g.size().x).sum::() + gap * cells.len().saturating_sub(1) as f32; + let height = cells.iter().map(|(g, _)| g.size().y).fold(0.0, f32::max); + let pos = g.at + egui::vec2(18.0, 22.0); + let rect = egui::Rect::from_min_size(pos, egui::vec2(width, height)).expand(5.0); + painter.rect_filled(rect, 4.0, t.overlay); + painter.rect_stroke(rect, 4.0, egui::Stroke::new(1.0, t.accent), egui::StrokeKind::Inside); + let mut x = pos.x; + for (g, _) in cells { + let w = g.size().x; + let y = pos.y + (height - g.size().y) / 2.0; + painter.galley(egui::pos2(x, y), g, t.text); + x += w + gap; + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn sideways_moves_walk_the_step_ladder() { + let one = nearest_step(1.0); + assert_eq!(STEPS[one], 1.0); + assert_eq!(STEPS[step_index(one, PX_PER_STEP)], 2.0); + assert_eq!(STEPS[step_index(one, -PX_PER_STEP)], 0.8); + assert_eq!(STEPS[step_index(one, -8.0 * PX_PER_STEP)], 0.1); + assert_eq!(step_index(one, -1e6), 0); + assert_eq!(step_index(one, 1e6), STEPS.len() - 1); + } +} diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 2978e76ec..d8841628b 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -52,6 +52,7 @@ pub mod dim_view; #[cfg(test)] mod dimension_create_ui_tests; pub mod documents; +pub mod drag_extrude; pub mod drag_snap; pub mod edit_clipboard; #[cfg(test)] diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs index ec5e76d70..2048ce72d 100644 --- a/crates/ui-egui/src/prefs.rs +++ b/crates/ui-egui/src/prefs.rs @@ -457,6 +457,8 @@ preference_settings! { navigator_style: NavigatorStyle = NavigatorStyle::default(), PAGE_NAVIGATION; /// Show the radial ring and enable hold/flick gestures for viewport context menus. radial_context_menu: bool = false, PAGE_NAVIGATION => check("Radial context menu"); + /// Work on the model directly in the viewport (pull a face to extrude or cut); off by default. + direct_interaction: bool = false, PAGE_NAVIGATION => check("Direct interaction", "Work on the model directly in the viewport. Press a flat face or a profile and pull: up extrudes, down into a body cuts, and sideways movement sets the step size"); /// Mouse gestures: a ring of tools on the right button. mouse_gestures: crate::mouse_gesture::Config = Default::default(), PAGE_NAVIGATION; /// The wheel zooms out when turned forward. diff --git a/crates/ui-egui/src/prefs/navigation.rs b/crates/ui-egui/src/prefs/navigation.rs index c69a79b9c..40895ccf6 100644 --- a/crates/ui-egui/src/prefs/navigation.rs +++ b/crates/ui-egui/src/prefs/navigation.rs @@ -123,6 +123,7 @@ pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) { .on_hover_text(if touchpad { crate::i18n::tr("nav.touchpad.scroll") } else { crate::i18n::tr("ui.trackpad_pan_tip") }); }); setting::radial_context_menu(app, ui); + setting::direct_interaction(app, ui); }); }); ui_kit::divider(ui, "navigation_view_controls"); diff --git a/crates/ui-egui/src/smart_extrude_ui_tests.rs b/crates/ui-egui/src/smart_extrude_ui_tests.rs index f4beae9f2..f1d451fac 100644 --- a/crates/ui-egui/src/smart_extrude_ui_tests.rs +++ b/crates/ui-egui/src/smart_extrude_ui_tests.rs @@ -151,3 +151,69 @@ fn press_pull_drags_a_hole_wall() { let v = volume(&h); assert!((v - (24000.0 - std::f64::consts::PI * 9.0 * 20.0)).abs() / v < 5e-4, "{v}"); } + +/// Pressing on a top face and pulling it up extrudes it by the distance dragged, without any +/// tool being started; letting go leaves the window open until OK. +#[test] +fn pulling_a_face_up_extrudes_it() { + let mut h = Harness::new(); + h.app.preferences.direct_interaction = true; + h.app.run("solid.box", json!({"length":20,"width":20,"height":10,"corner":[0,0,0]})).unwrap(); + h.step(&json!({"call":"ui.view","params":{"view":"home"}})).unwrap(); + h.step(&json!({"call":"ui.view","params":{"view":"fit"}})).unwrap(); + h.settle(); + h.step(&json!({"drag":[{"world":[10,10,10]},{"world":[10,10,20]}]})).unwrap(); + h.frames(4); + assert!(h.app.dialog.is_some(), "the window stays open after the release"); + assert_eq!(state(&h), (0, JOIN, true), "pulled out: Join"); + h.step(&json!({"key":"Enter"})).unwrap(); + assert!(h.app.dialog.is_none(), "OK applied the extrude"); + let (lo, hi) = bounds_z(&h); + assert!(lo.abs() < 1e-6 && hi > 10.5, "the box grew upward: z {lo}..{hi}"); +} + +/// Direct interaction is a setting, off until someone turns it on: a pull then does nothing. +#[test] +fn direct_interaction_is_off_until_the_setting_is_on() { + let mut h = Harness::new(); + assert!(!h.app.preferences.direct_interaction); + h.app.run("solid.box", json!({"length":20,"width":20,"height":10,"corner":[0,0,0]})).unwrap(); + h.step(&json!({"call":"ui.view","params":{"view":"home"}})).unwrap(); + h.step(&json!({"call":"ui.view","params":{"view":"fit"}})).unwrap(); + h.settle(); + let before = volume(&h); + h.step(&json!({"drag":[{"world":[10,10,10]},{"world":[10,10,20]}]})).unwrap(); + h.frames(4); + assert!(h.app.dialog.is_none(), "no extrude window"); + assert!((volume(&h) - before).abs() < 1e-6); +} + +/// A press on a face that moves sideways is still a box selection: nothing is extruded. +#[test] +fn dragging_sideways_over_a_face_does_not_extrude() { + let mut h = Harness::new(); + h.app.preferences.direct_interaction = true; + h.app.run("solid.box", json!({"length":20,"width":20,"height":10,"corner":[0,0,0]})).unwrap(); + h.step(&json!({"call":"ui.view","params":{"view":"home"}})).unwrap(); + h.step(&json!({"call":"ui.view","params":{"view":"fit"}})).unwrap(); + h.settle(); + let before = volume(&h); + h.step(&json!({"drag":[{"world":[10,10,10]},{"world":[18,10,10]}]})).unwrap(); + h.frames(4); + assert!(h.app.dialog.is_none()); + assert!((volume(&h) - before).abs() < 1e-6); +} + +/// Pulling a face down into the body cuts, and the window waits for OK as well. +#[test] +fn pulling_a_face_down_into_the_body_cuts() { + let mut h = Harness::new(); + h.app.preferences.direct_interaction = true; + h.app.run("solid.box", json!({"length":20,"width":20,"height":10,"corner":[0,0,0]})).unwrap(); + h.step(&json!({"call":"ui.view","params":{"view":"home"}})).unwrap(); + h.step(&json!({"call":"ui.view","params":{"view":"fit"}})).unwrap(); + h.settle(); + h.step(&json!({"drag":[{"world":[10,10,10]},{"world":[10,10,5]}]})).unwrap(); + h.frames(4); + assert_eq!(state(&h).1, CUT, "pushed into the box: Cut"); +} diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs index 4dd6d4c82..b2183e89f 100644 --- a/crates/ui-egui/src/viewport.rs +++ b/crates/ui-egui/src/viewport.rs @@ -159,6 +159,8 @@ pub struct ViewportState { pub(crate) joint_drag: Option, /// A free part being dragged to a new place (#2804). pub(crate) occurrence_drag: Option, + /// Extrude by pulling a face or profile. + pub(crate) drag_extrude: crate::drag_extrude::State, /// The plane the grid was last drawn on while Preferences ▸ Grid follows the view is on /// (#1470), kept so the choice is hysteretic near the thresholds (#1993). pub(crate) grid_plane: std::sync::Mutex, @@ -3533,8 +3535,9 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { && !crate::shell::covered(app, a) && !axes.contains(a) && !crate::occurrence_drag::start(app, &proj, a) + && !crate::joint_drag::start(app, &proj, a) { - crate::joint_drag::start(app, &proj, a); + crate::drag_extrude::press(app, &proj, a); } if resp.dragged_by(egui::PointerButton::Primary) && let Some(p) = hover @@ -3554,6 +3557,15 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { if crate::occurrence_drag::active(app) && (resp.drag_stopped() || !ui.input(|i| i.pointer.primary_down())) { crate::occurrence_drag::end(app); } + // Pulling a face or profile extrudes it; the release applies. + if resp.dragged_by(egui::PointerButton::Primary) + && let Some(p) = hover + { + crate::drag_extrude::to(app, &proj, p); + } + if resp.drag_stopped() || !primary_down { + crate::drag_extrude::end(app); + } // Box selection: a primary drag on the model when no navigation mode is on. if app.tool.is_none() && !held @@ -3562,6 +3574,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { && app.viewport.point_drag.is_none() && !crate::joint_drag::active(app) && !crate::occurrence_drag::active(app) + && !crate::drag_extrude::started(app) && !crate::dim_view::dragging() && !crate::sketch3d::dragging() && !crate::sketch_text_handles::dragging(app) @@ -3599,6 +3612,8 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { crate::inference::show(app, &painter, &proj); crate::drag_snap::show(app, &painter, &proj); hover_highlight(app, &painter, &proj); + crate::drag_extrude::tick(app); + crate::drag_extrude::show(app, &painter); points_2d(app, &painter, &proj); if let Some((plane, sketch)) = crate::sketch_attachment_ui::lost_guide(app) && let Some((low, high)) = sketch.bounds()