Move/Copy: show a handle for the selected rotation axis (#6822) (#6832)

* claim: #6822

* fix(ui): show selected-axis handle for Move Rotate (#6822)
This commit is contained in:
Colin Faulkingham authored and GitHub committed 2026-10-26 10:42:01 +00:00
1 parent b1bbca97ef
commit abdf9d79cf
4 files changed
+180 -5

No files matched your search

+65 -3
View File
@@ -276,6 +276,12 @@ pub(crate) fn owns_pointer(app: &SolveApp, proj: &Proj, p: Pos2) -> bool {
// The triad only registers an egui hit widget after a handle is under the pointer.
// Test its geometry before navigation, including the first frame entering a handle.
app.dialog.as_ref().and_then(|d| crate::dialogs_move::triad(app, d)).is_some_and(|t| crate::gizmo::contains_pointer(proj, &t, p))
|| app
.dialog
.as_ref()
.and_then(|d| move_rotation(app, d, proj))
.and_then(|r| proj.to_screen(r.point(r.angle)))
.is_some_and(|end| egui::Rect::from_center_size(end, vec2(20.0, 20.0)).contains(p))
|| (app.dialog.is_none()
&& app.tool.is_none()
&& crate::browser::occurrence_triad_model(app).is_some_and(|t| crate::gizmo::contains_pointer(proj, &t, p)))
@@ -318,9 +324,11 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj
dragging = true;
}
// Read the triad again after the drag, so the box follows it in the same frame. Move
// types with no triad (Rotate, Point to Point, Point to Position) put the box on the
// picked bodies instead.
// types with no triad put the box on the picked bodies, or beside Rotate's handle
// once an axis is selected.
let triad = crate::dialogs_move::triad(app, &d);
let rotation = draw_move_rotation(app, ui, painter, proj, &mut d);
dragging |= rotation.is_some_and(|(_, changed)| changed);
let at = triad.map(|t| t.center).or_else(|| anchor(app, &d).map(|(base, _)| base));
// Tab and Shift+Tab in the box show the next or previous value (Y after X; #4776),
// keeping the keyboard in the box.
@@ -340,7 +348,8 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj
// Clear of the triad: its arrows reach LEN_PX and its rings RING of that, so a box
// beside the centre would cover the handles the user is reaching for.
let off = if triad.is_some() { vec2(crate::gizmo::LEN_PX as f32 + 16.0, -12.0) } else { vec2(16.0, -30.0) };
value_box_with(ui, label, value, bs + off, focus || dragging, true);
let box_at = rotation.map_or(bs + off, |(end, _)| end + vec2(16.0, -12.0));
value_box_with(ui, label, value, box_at, focus || dragging, true);
}
app.dialog = Some(d);
return;
@@ -355,6 +364,59 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj
crate::hole_place::show(app, ui, painter, proj);
}
struct MoveRotation {
centre: Vec3,
axis: Vec3,
radius: f64,
angle: f64,
}
impl MoveRotation {
fn point(&self, angle: f64) -> Vec3 {
let e1 = self.axis.any_perp();
let e2 = self.axis.cross(e1);
self.centre + (e1 * angle.cos() + e2 * angle.sin()) * self.radius
}
}
fn move_rotation(app: &SolveApp, d: &Dialog, proj: &Proj) -> Option<MoveRotation> {
let Kind::Move { angle, .. } = &d.kind else { return None };
let (centre, axis) = crate::dialogs_move::rotation_axis(app, d)?;
let angle = crate::length_input::eval(&app.session.doc, angle, ValueKind::Angle).ok().filter(|a| a.is_finite()).unwrap_or(0.0);
Some(MoveRotation { centre, axis, radius: crate::gizmo::ring_radius(proj, centre)?, angle })
}
/// Reuse the angular handle's snapping and edge-on projection for Move's selected axis.
fn draw_move_rotation(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj: &Proj, d: &mut Dialog) -> Option<(Pos2, bool)> {
let r = move_rotation(app, d, proj)?;
let points: Vec<_> = (0..=64).filter_map(|i| proj.to_screen(r.point(i as f64 / 64.0 * std::f64::consts::TAU))).collect();
painter.add(egui::Shape::line(points, Stroke::new(1.8, Tokens::get().manipulator)));
let Kind::Move { angle, .. } = &mut d.kind else { return None };
let before = angle.clone();
let e1 = r.axis.any_perp();
// Keep full turns in the expression while the shared handle works near zero.
let boundary = r.angle % std::f64::consts::TAU;
let offset = r.angle - boundary;
let span = 2.0 * std::f64::consts::TAU;
let end = rotation_handle(
ui,
painter,
proj,
r.centre,
e1,
r.axis.cross(e1),
r.axis,
r.radius,
boundary,
1.0,
offset,
(offset - span, offset + span),
"move_rotate",
angle,
)?;
Some((end, *angle != before))
}
/// A round step for dragged values at this zoom (1, 2 or 5 times a power of ten).
pub fn snap_step(half_height: f64) -> f64 {
let raw = (half_height / 40.0).max(1e-4);
+11
View File
@@ -252,6 +252,17 @@ pub fn triad(app: &SolveApp, d: &Dialog) -> Option<gizmo::Triad> {
Some(gizmo::Triad { center: pivot(app, d)? + t, translate: true, rotate: *mode == FREE })
}
/// Rotate's ring lies on the selected axis, level with the picked bodies' centre.
pub(crate) fn rotation_axis(app: &SolveApp, d: &Dialog) -> Option<(Vec3, Vec3)> {
if !matches!(d.kind, Kind::Move { mode: ROTATE, .. }) {
return None;
}
let centre = bodies_center(app, d)?;
let (origin, axis) = axis_line(app, items(d, 1).first()?)?;
let axis = axis.normalized()?;
Some((origin + axis * (centre - origin).dot(axis), axis))
}
/// Apply a triad drag to the dialog's values (added to the values when the drag began).
/// Which value the canvas box shows and types into, for the types that translate: X, Y or Z
/// (0 to 2), or, in Free Move, the angle about X, Y or Z (3 to 5). Kept in `extra` as
+99 -2
View File
@@ -54,8 +54,105 @@ fn the_main_value_writes_through_to_the_command() {
assert_eq!((x.as_str(), y.as_str(), z.as_str()), ("30 mm", "0 mm", "0 mm"), "the box edits X alone");
}
/// Free Move and Translate carry the triad. The other three have no manipulator yet, so their
/// value box is the only way to drive them: it must still have somewhere to sit.
/// #6822: Rotate must offer a draggable handle after the body and axis are picked.
#[test]
fn rotate_handle_updates_the_angle_without_moving_the_camera() {
let mut h = crate::scenario::Harness::new();
h.app.preferences.nav = "openscad".into();
h.app.run("solid.box", json!({"length": 20, "width": 30, "height": 10})).unwrap();
h.step(&json!({"call": "ui.view", "params": {"view": "top"}})).unwrap();
h.app.cam.distance = 180.0;
h.app.start("solid.move");
{
let d = h.app.dialog.as_mut().unwrap();
d.kind = kind(ROTATE, &h.app.session.doc);
d.inputs = inputs(ROTATE);
d.inputs[0].items = vec![Sel::Body { name: "Body1".into() }];
d.inputs[1].items = vec![Sel::Axis { name: "Z".into() }];
}
h.frames(5);
let before = serde_json::to_value(&*h.app.session.doc).unwrap();
let camera = h.app.cam;
let start = h.at(&json!({"handle": "move_rotate"})).unwrap();
let centre = h.at(&json!({"world": [0, 0, 5]})).unwrap();
// A quarter turn clockwise in the top view is -90 degrees about +Z.
let end = [centre[0] - (start[1] - centre[1]), centre[1] + (start[0] - centre[0])];
h.step(&json!({"drag": [start, end], "steps": 12})).unwrap();
let d = h.app.dialog.as_ref().unwrap();
let p = params(&h.app, d).unwrap();
assert_eq!(p["angle"], "-90 deg");
assert_eq!(p["axis"], json!([0.0, 0.0, 1.0]));
assert_eq!(h.app.cam, camera, "the handle owns the drag");
assert_eq!(serde_json::to_value(&*h.app.session.doc).unwrap(), before, "a preview does not commit the move");
h.step(&json!({"key": "Enter"})).unwrap();
h.settle();
assert!(h.app.dialog.is_none());
let bounds = h.app.session.model.state().body("Body1").unwrap().mesh().bounds();
assert!((bounds.min - Vec3::new(0.0, -20.0, 0.0)).len() < 1e-6, "{bounds:?}");
assert!((bounds.max - Vec3::new(30.0, 0.0, 10.0)).len() < 1e-6, "{bounds:?}");
h.app.run("edit.undo", json!({})).unwrap();
assert_eq!(serde_json::to_value(&*h.app.session.doc).unwrap(), before);
}
#[test]
fn rotate_handle_follows_an_offset_axis_and_preserves_full_turns() {
for (direction, initial, expected, free) in [(Vec3::new(1.0, 1.0, 1.0), "720 deg", 755.0, false), (-Vec3::Z, "", 37.3, true)] {
let mut h = crate::scenario::Harness::new();
h.app.run("solid.box", json!({"length": 20, "width": 30, "height": 10})).unwrap();
let origin = Vec3::new(5.0, 7.0, 9.0);
let end = origin + direction;
h.app
.run(
"construct.axis.two_points",
json!({"a": {"point": [origin.x, origin.y, origin.z]}, "b": {"point": [end.x, end.y, end.z]}, "name": "TurnAxis"}),
)
.unwrap();
h.app.cam = h.app.cam.looking_from(direction);
h.app.cam.distance = 180.0;
h.app.start("solid.move");
{
let d = h.app.dialog.as_mut().unwrap();
d.kind = kind(ROTATE, &h.app.session.doc);
d.inputs = inputs(ROTATE);
d.inputs[0].items = vec![Sel::Body { name: "Body1".into() }];
}
h.frames(3);
assert!(crate::scenario::handle_at("move_rotate").is_none(), "an axis must be selected first");
{
let d = h.app.dialog.as_mut().unwrap();
d.inputs[1].items = vec![Sel::Axis { name: "TurnAxis".into() }];
if let Kind::Move { angle, .. } = &mut d.kind {
*angle = initial.into();
}
}
h.frames(3);
let before = serde_json::to_value(&*h.app.session.doc).unwrap();
let d = h.app.dialog.as_ref().unwrap();
let (centre, axis) = rotation_axis(&h.app, d).unwrap();
assert!((centre - origin).cross(direction).len() < 1e-9);
assert!((axis - direction.normalized().unwrap()).len() < 1e-9);
let proj = crate::viewport::projection(&h.app, h.app.viewport.rect.unwrap());
let radius = crate::gizmo::ring_radius(&proj, centre).unwrap();
let e1 = axis.any_perp();
let e2 = axis.cross(e1);
let th = 37.3_f64.to_radians();
let target = centre + (e1 * th.cos() + e2 * th.sin()) * radius;
h.step(&json!({"drag": [{"handle": "move_rotate"}, {"world": [target.x, target.y, target.z]}], "ctrl": free, "steps": 12})).unwrap();
let d = h.app.dialog.as_ref().unwrap();
let p = params(&h.app, d).unwrap();
let actual = ang(&h.app, p["angle"].as_str().unwrap()).unwrap();
assert!((actual.to_degrees() - expected).abs() < 0.11, "{p}");
let translation: [String; 3] = serde_json::from_value(p["translate"].clone()).unwrap();
let translation = translation.map(|v| len(&h.app, &v).unwrap());
let moved_origin = gizmo::apply(&gizmo::rotation(axis, actual), origin) + Vec3::new(translation[0], translation[1], translation[2]);
assert!((moved_origin - origin).len() < 1e-5, "the selected axis stays fixed");
h.step(&json!({"widget": "Cancel"})).unwrap();
assert_eq!(serde_json::to_value(&*h.app.session.doc).unwrap(), before);
}
}
/// Free Move and Translate carry the triad. The other modes still need a place for their value
/// box before enough geometry is picked to draw a handle.
#[test]
fn every_move_type_has_somewhere_to_put_its_value_box() {
let mut s = Session::default();
+5
View File
@@ -228,6 +228,11 @@ fn mm_per_px(proj: &Proj, c: Vec3) -> Option<f64> {
(px > 1e-9).then(|| 1.0 / px)
}
/// Radius shared by the triad rings and the selected-axis Rotate handle.
pub(crate) fn ring_radius(proj: &Proj, centre: Vec3) -> Option<f64> {
Some(mm_per_px(proj, centre)? * LEN_PX * RING)
}
fn snap(v: f64, step: f64, free: bool) -> f64 {
if free || step <= 0.0 { v } else { (v / step).round() * step }
}