Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Orbit drags turn from where they began, so erratic drags don't drift (#2842)

bherbruck19ffb0dd75a2
diff --git a/crates/ui-egui/src/navigation.rs b/crates/ui-egui/src/navigation.rs
index b8e4a674c1..a8083ae157 100644
--- a/crates/ui-egui/src/navigation.rs
+++ b/crates/ui-egui/src/navigation.rs
@@ -169,6 +169,7 @@ pub(crate) fn modifier_motion(
let previous = app.viewport.modifier_nav;
if previous.map(|(m, _)| m) != next.map(|(m, _)| m) {
app.viewport.orbit_pivot = None;
+ app.viewport.orbit_from = None;
app.viewport.orbit_free = None;
app.viewport.orbit_snap = None;
}
@@ -481,6 +482,7 @@ pub(crate) fn handle(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect, resp: &e
}
if !dragging && motion.is_none() {
app.viewport.orbit_pivot = None;
+ app.viewport.orbit_from = None;
}
if app.viewport.spin {
// A click on the navigation bar (its own button) is not a stop.
@@ -699,11 +701,32 @@ pub fn orbit(app: &mut SolveApp, rect: egui::Rect, dx: f64, dy: f64, press: Opti
}
}),
};
- let Some(pivot) = pivot else {
- app.cam.orbit(dx, dy);
- return;
+ // The drag's whole turn so far, applied to the camera it began with: the view depends on
+ // where the pointer is, not on the path it took, so fast or erratic drags (a pitch held at
+ // straight up or down for a while, many tiny steps) can't drift. Anything else that moves
+ // the camera meanwhile (a wheel zoom, a new pivot) starts the sum again from there.
+ let from = match app.viewport.orbit_from {
+ Some(f) if f.last == app.cam && f.pivot == pivot => f,
+ _ => OrbitFrom { start: app.cam, dx: 0.0, dy: 0.0, pivot, last: app.cam },
};
- app.cam.orbit_about(dx, dy, pivot);
+ let (dx, dy) = (from.dx + dx, from.dy + dy);
+ app.cam = from.start;
+ match pivot {
+ Some(p) => app.cam.orbit_about(dx, dy, p),
+ None => app.cam.orbit(dx, dy),
+ }
+ app.viewport.orbit_from = Some(OrbitFrom { dx, dy, last: app.cam, ..from });
+}
+
+/// An orbit drag so far: the camera it began with, the pointer's total motion since, the pivot
+/// and the camera that produced.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct OrbitFrom {
+ start: Camera,
+ dx: f64,
+ dy: f64,
+ pivot: Option<Vec3>,
+ last: Camera,
}
#[cfg(test)]
diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index bde68cac68..b365605803 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -96,6 +96,8 @@ pub struct ViewportState {
pub hover_bodies: Vec<String>,
/// The model point an orbit turns around (Preferences: orbit around the cursor).
pub orbit_pivot: Option<Vec3>,
+ /// The orbit drag under way, summed from where it began (see [`crate::navigation::orbit`]).
+ pub orbit_from: Option<crate::navigation::OrbitFrom>,
/// Continuous orbit: the view turns about the vertical until the next click or key.
pub spin: bool,
/// The 3D mouse's motion this frame, for the page showing the camera to apply with what its
@@ -5956,6 +5958,57 @@ mod tests {
}
}
+ /// An erratic orbit drag (big jumps, reversals, the pointer over the panels and back) keeps
+ /// the point picked when it began on its pixel the whole way, and coming back to where it
+ /// began brings back the view it began with (up to the rounding of the pointer's f32 steps).
+ #[test]
+ fn an_erratic_cursor_orbit_keeps_its_pivot_and_comes_back() {
+ for perspective in [false, true] {
+ let mut h = crate::scenario::Harness::new();
+ h.app.preferences.orbit_around = crate::prefs::OrbitAround::Cursor;
+ h.app.ui.perspective = perspective;
+ h.app.run("solid.box", json!({"length":80,"width":50,"height":20})).unwrap();
+ h.app.fit_view();
+ h.frames(2);
+ let rect = h.app.viewport.rect.unwrap();
+ let at = rect.center() + vec2(30.0, 20.0);
+ let pivot = crate::prefs::pivot_under(&h.app, &projection(&h.app, rect), at);
+ let start = h.app.cam;
+ let shift = egui::Modifiers { shift: true, ..Default::default() };
+ let send = |h: &mut crate::scenario::Harness, e: egui::Event| {
+ h.app.synthetic.push(e);
+ h.frame();
+ };
+ send(&mut h, egui::Event::ModifiersChanged(egui::Modifiers::NONE));
+ send(&mut h, egui::Event::PointerMoved(at));
+ send(&mut h, egui::Event::PointerButton { pos: at, button: egui::PointerButton::Middle, pressed: true, modifiers: shift });
+ let mut seed: u32 = 12345;
+ let mut next = move || {
+ seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
+ f32::from((seed >> 16) as u16) / 65535.0
+ };
+ for i in 0..300 {
+ // Mostly small moves, now and then a big jump, some of them over the panels.
+ let p = if i % 17 == 0 { pos2(next() * 1600.0, next() * 1000.0) } else { at + vec2((next() - 0.5) * 900.0, (next() - 0.5) * 200.0) };
+ send(&mut h, egui::Event::PointerMoved(p));
+ assert_eq!(h.app.viewport.orbit_pivot, Some(pivot), "move {i}: the pivot is picked once, when the drag begins");
+ let s = projection(&h.app, rect).to_screen(pivot).unwrap();
+ assert!(s.distance(at) < 1.0, "perspective={perspective}, move {i} to {p:?}: the pivot moved to {s:?}");
+ }
+ send(&mut h, egui::Event::PointerMoved(at));
+ let s = projection(&h.app, rect).to_screen(pivot).unwrap();
+ assert!(s.distance(at) < 1.0, "{s:?}");
+ let back = h.app.cam;
+ assert!(
+ (back.yaw - start.yaw).rem_euclid(std::f64::consts::TAU).min((start.yaw - back.yaw).rem_euclid(std::f64::consts::TAU)) < 1e-6,
+ "{start:?} -> {back:?}"
+ );
+ assert!((back.pitch - start.pitch).abs() < 1e-6, "{start:?} -> {back:?}");
+ assert!((back.target - start.target).len() < 1e-4, "back where it began: {start:?} -> {back:?}");
+ send(&mut h, egui::Event::PointerButton { pos: at, button: egui::PointerButton::Middle, pressed: false, modifiers: shift });
+ }
+ }
+
#[test]
fn shift_orbit_keeps_cursor_pivot_and_default_middle_pan() {
let mut h = crate::scenario::Harness::new();