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:
committed by
GitHub
parent
b702ce8c7d
commit
cf1b0d67cc
@@ -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);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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)]
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user