Extrude by pressing on a face or profile and pulling (#4767)

* feat: extrude a face or profile by pressing on it and pulling

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* feat: pull-to-extrude keeps the window open and sets the step by sideways motion

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Pull to extrude: coarser step changes, a step ladder below the pointer, the step in the distance box

The step label sat on top of the distance box at the arrow tip. It is now a ladder of the
step in use between its neighbours, below the pointer, and the distance box also names the
step ("Step 1 mm"). One step change takes 44 px of sideways travel instead of 22.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Pull to extrude: a setting, off by default (Preferences > Navigation)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* Rename the pull setting to Direct interaction

It will also cover other direct gestures in the viewport later (grabbing an edge to round it).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Nathalie Schönwetter <nathalie@cfw-ag.ch>
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Nathalie Schönwetter
2026-10-24 21:52:58 +00:00
committed by GitHub
parent b702ce8c7d
commit cf1b0d67cc
7 changed files with 332 additions and 5 deletions
+27 -4
View File
@@ -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<f64> {
pub(crate) fn along(proj: &Proj, pos: Pos2, base: Vec3, dir: Vec3) -> Option<f64> {
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<egui::Rect> {
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<egui::Rect> {
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);
});
});
+219
View File
@@ -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<Gesture>,
/// The step of the last pull, shown in the window until it closes.
last_step: Option<f64>,
}
/// 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<String> {
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::<f32>() + 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);
}
}
+1
View File
@@ -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)]
+2
View File
@@ -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.
+1
View File
@@ -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");
@@ -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");
}
+16 -1
View File
@@ -159,6 +159,8 @@ pub struct ViewportState {
pub(crate) joint_drag: Option<crate::joint_drag::Drag>,
/// A free part being dragged to a new place (#2804).
pub(crate) occurrence_drag: Option<crate::occurrence_drag::Drag>,
/// 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<GridPlane>,
@@ -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()