geop_core_editor/editing/

gizmo.rs

//! [`Gizmo`]: moving, turning and scaling something in the viewport by
//! dragging a manipulator drawn at it — the one way every operation offers
//! a drag in three dimensions.
//!
//! An operation asks for a gizmo at a point, with the modes it allows and,
//! if what it stands on has an orientation of its own, its axes (see
//! [`super::Form::gizmo`]). The editor draws it, tests the pointer against
//! it, follows a drag of one of its parts and snaps it, and sends the
//! operation what the drag did as a [`GizmoDrag`]: a translation, a turn
//! about one of its axes, or a scale along them — always measured from
//! where the drag started, and applied by the operation to its arguments
//! as they were then (see [`crate::step_editor`]).
//!
//! It is laid out in the pointer's reaches (see [`super::Reach`]), so it
//! keeps its size on screen however far away or zoomed in the view is: a
//! ball at its centre to drag freely in the plane facing the eye, an arrow
//! along each axis and a square in each plane of two of them, a ring about
//! each axis, a cube beyond each arrow to stretch along it and one on the
//! diagonal to scale evenly. The viewer draws it by the same sizes, from
//! [`GizmoView`].

use geop_core_math::{primitives::Pose, scalars::Scalar, vector::Vector3};
use serde::Serialize;

use super::{Pointer, hit::nearer};

/// How the gizmo is laid out, in reaches of the pointer at its centre.
pub mod size {
    /// The radius of the ball at the centre.
    pub const FREE: f64 = 1.4;
    /// Where an arrow starts, out from the centre, and where its tip is.
    pub const ARROW: (f64, f64) = (2.5, 10.0);
    /// Where a plane's square starts and ends, along both its axes.
    pub const PLANE: (f64, f64) = (2.5, 4.0);
    /// The radius of the rings.
    pub const RING: f64 = 7.0;
    /// How far out a cube to scale by sits: along its axis, or the
    /// diagonal.
    pub const CUBE_AT: f64 = 12.5;
    /// Half the size of such a cube.
    pub const CUBE: f64 = 0.9;
    /// How near the pointer has to pass to an arrow, a ring or a cube.
    pub const NEAR: f64 = 1.0;
    /// How far from looking along it an arrow, or a cube, is still shown —
    /// and how far from looking along its plane a square is: the sine of
    /// the angle. Nearer, it is foreshortened to a dot or a line on
    /// screen, and a drag of it could not be followed.
    pub const FACING: f64 = 0.2;
}

/// The finest spacing of the grid the viewer draws on a plane worked in,
/// in reaches (20 pixels, a reach being 9): what a translation snaps to is
/// the round step — 1, 2 or 5 times a power of ten — at least this far on
/// screen.
pub const GRID: f64 = 20.0 / 9.0;
/// What a turn snaps to, in degrees.
pub const ANGLE_SNAP: f64 = 15.0;
/// What a scale factor snaps to.
pub const SCALE_SNAP: f64 = 0.1;

/// What a gizmo lets the user do.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize)]
pub struct Modes {
    /// Move along an axis, in a plane of two, or freely.
    pub translate: bool,
    /// Turn about an axis.
    pub rotate: bool,
    /// Scale along an axis, or evenly.
    pub scale: bool,
}

/// A gizmo an operation asks for (see [`super::Form::gizmo`]): at `at`,
/// doing what `modes` allow — oriented along the world's axes, or `axes`,
/// what it stands on's own, orthonormal and right-handed, if it has an
/// orientation of its own: then the user chooses which.
#[derive(Clone, Debug, PartialEq)]
pub struct Gizmo {
    pub at: Vector3,
    pub axes: Option<[Vector3; 3]>,
    pub modes: Modes,
}

impl Gizmo {
    /// A gizmo at `at` that does nothing yet: see [`Gizmo::translate`],
    /// [`Gizmo::rotate`] and [`Gizmo::scale`].
    pub fn new(at: Vector3) -> Self {
        Self {
            at,
            axes: None,
            modes: Modes::default(),
        }
    }

    pub fn translate(mut self) -> Self {
        self.modes.translate = true;
        self
    }

    pub fn rotate(mut self) -> Self {
        self.modes.rotate = true;
        self
    }

    pub fn scale(mut self) -> Self {
        self.modes.scale = true;
        self
    }

    /// Oriented along `axes` too, if the user chooses: orthonormal and
    /// right-handed.
    pub fn local(mut self, axes: [Vector3; 3]) -> Self {
        self.axes = Some(axes);
        self
    }
}

/// Which way a gizmo is turned: along the world's axes, or its own.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Orientation {
    World,
    /// Along what it stands on's own axes, where it has them.
    #[default]
    Local,
}

/// One of a gizmo's three axes, which picks its own from any three things
/// given per axis. Sent as its index, `0` for `x`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Axis {
    X,
    Y,
    Z,
}

impl Axis {
    pub const ALL: [Axis; 3] = [Axis::X, Axis::Y, Axis::Z];

    /// Its own of `per_axis`.
    pub fn of<T>(self, per_axis: &[T; 3]) -> &T {
        let [x, y, z] = per_axis;
        match self {
            Axis::X => x,
            Axis::Y => y,
            Axis::Z => z,
        }
    }

    pub fn of_mut<T>(self, per_axis: &mut [T; 3]) -> &mut T {
        let [x, y, z] = per_axis;
        match self {
            Axis::X => x,
            Axis::Y => y,
            Axis::Z => z,
        }
    }

    /// The two others, in turn: `y` and `z` for `x`.
    pub fn others(self) -> [Axis; 2] {
        match self {
            Axis::X => [Axis::Y, Axis::Z],
            Axis::Y => [Axis::Z, Axis::X],
            Axis::Z => [Axis::X, Axis::Y],
        }
    }

    pub fn name(self) -> &'static str {
        match self {
            Axis::X => "x",
            Axis::Y => "y",
            Axis::Z => "z",
        }
    }
}

impl Serialize for Axis {
    fn serialize<Ser: serde::Serializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
        serializer.serialize_u8(match self {
            Axis::X => 0,
            Axis::Y => 1,
            Axis::Z => 2,
        })
    }
}

/// A part of a gizmo, to hover and drag: by its axis.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
#[serde(tag = "part", content = "axis", rename_all = "snake_case")]
pub enum GizmoPart {
    /// The ball at the centre: moving freely, in the plane facing the eye.
    Free,
    /// An arrow: moving along its axis.
    Move(Axis),
    /// The square in the plane normal to an axis: moving in that plane.
    Plane(Axis),
    /// A ring: turning about its axis.
    Turn(Axis),
    /// A cube beyond an arrow: scaling along its axis.
    Stretch(Axis),
    /// The cube on the diagonal: scaling evenly.
    Scale,
}

/// What a drag of a gizmo did, from where it started.
#[derive(Clone, Debug, PartialEq)]
pub enum Change {
    /// Moved by this much, in world coordinates.
    Translate(Vector3),
    /// Turned by `degrees` about the line through the centre along the
    /// unit vector `axis` — counter-clockwise, looking against it.
    Rotate { axis: Vector3, degrees: f64 },
    /// Scaled about the centre by `factors[i]` along the unit vector
    /// `axes[i]`.
    Scale {
        axes: [Vector3; 3],
        factors: [f64; 3],
    },
}

/// What a drag of a gizmo did, from where it started: a [`Change`] about
/// `centre`, where the gizmo stood when the drag started.
#[derive(Clone, Debug, PartialEq)]
pub struct GizmoDrag {
    pub centre: Vector3,
    pub change: Change,
}

impl GizmoDrag {
    /// Where the change takes the point `p`.
    pub fn apply(&self, p: &Vector3) -> Vector3 {
        let c = &self.centre;
        match &self.change {
            Change::Translate(by) => p.add(by),
            Change::Rotate { .. } => match self.turn() {
                Some(pose) => pose.apply(p),
                None => *p,
            },
            Change::Scale { axes, factors } => {
                let d = p.sub(c);
                axes.iter().zip(factors).fold(*c, |at, (axis, &factor)| {
                    at.add(&axis.prod_scalar(d.prod_dot(axis).mul(Scalar::from_f64(factor))))
                })
            }
        }
    }

    /// Where the change takes the point `p`, given as plain coordinates.
    pub fn apply_f64(&self, p: [f64; 3]) -> [f64; 3] {
        let moved = self.apply(&Vector3::from_array(p.map(Scalar::from_f64)));
        moved.to_array().map(|x| x.to_f64())
    }

    /// The change as a rigid motion: a pose taking where something was to
    /// where it goes — `None` for a scale, which is none.
    pub fn turn(&self) -> Option<Pose> {
        match &self.change {
            Change::Translate(by) => Some(Pose::identity().with_position(*by)),
            Change::Rotate { axis, degrees } => {
                let radians = Scalar::from_f64(degrees.to_radians());
                Pose::rotation_about(&self.centre, axis, radians).ok()
            }
            Change::Scale { .. } => None,
        }
    }
}

/// A gizmo as the viewer draws it: where, along which axes, what it lets
/// the user do, which part the pointer is over and which is dragged, and
/// what a drag under way has done so far, in words.
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct GizmoView {
    pub at: Vector3,
    /// Unit and orthogonal: the world's, or what it stands on's own.
    pub axes: [Vector3; 3],
    #[serde(skip)]
    pub modes: Modes,
    /// The parts it shows, as its modes give them: what a viewer draws,
    /// and the pointer is tested against.
    pub parts: Vec<GizmoPart>,
    pub hover: Option<GizmoPart>,
    pub active: Option<GizmoPart>,
    pub readout: Option<String>,
}

/// The world's axes.
fn world() -> [Vector3; 3] {
    [0, 1, 2].map(Vector3::axis)
}

impl GizmoView {
    /// The gizmo moved by `motion`: drawn where the part it is of is placed.
    pub fn moved(mut self, motion: &geop_core_math::primitives::Motion) -> Self {
        self.at = motion.apply(&self.at);
        self.axes = self.axes.map(|axis| motion.rotate(&axis));
        self
    }

    /// `gizmo` turned as `orientation` says.
    pub fn of(gizmo: &Gizmo, orientation: Orientation) -> Self {
        let axes = match (orientation, gizmo.axes) {
            (Orientation::Local, Some(axes)) => axes,
            _ => world(),
        };
        Self {
            at: gizmo.at,
            axes,
            modes: gizmo.modes,
            parts: Self::parts_of(gizmo.modes),
            hover: None,
            active: None,
            readout: None,
        }
    }

    /// The parts a gizmo of `modes` shows: the ball, arrows and squares
    /// to move by, the rings to turn by, the cubes to scale by.
    fn parts_of(m: Modes) -> Vec<GizmoPart> {
        let mut parts = Vec::new();
        if m.translate {
            parts.push(GizmoPart::Free);
            parts.extend(Axis::ALL.map(GizmoPart::Move));
            parts.extend(Axis::ALL.map(GizmoPart::Plane));
        }
        if m.rotate {
            parts.extend(Axis::ALL.map(GizmoPart::Turn));
        }
        if m.scale {
            parts.extend(Axis::ALL.map(GizmoPart::Stretch));
            parts.push(GizmoPart::Scale);
        }
        parts
    }

    /// The diagonal the even scale's cube sits on.
    pub fn diagonal(&self) -> Option<Vector3> {
        let [a, b, c] = &self.axes;
        a.add(b).add(c).normalize().ok()
    }

    /// Whether `part` is shown looking along `dir` (see [`size::FACING`]).
    pub fn shown(&self, part: GizmoPart, dir: &Vector3) -> bool {
        let across = |a: &Vector3| a.prod_cross(dir).norm().to_f64() >= size::FACING;
        match part {
            GizmoPart::Free | GizmoPart::Turn(_) => true,
            GizmoPart::Move(i) | GizmoPart::Stretch(i) => across(i.of(&self.axes)),
            GizmoPart::Plane(i) => i.of(&self.axes).prod_dot(dir).abs().to_f64() >= size::FACING,
            GizmoPart::Scale => self.diagonal().is_some_and(|d| across(&d)),
        }
    }

    /// How large one reach is at its centre, for `pointer`.
    pub fn reach(&self, pointer: &Pointer) -> Scalar {
        pointer.reach_at(1.0, pointer.ray.closest_to_point(&self.at))
    }

    /// The part `pointer` is over. One it is over as drawn comes first —
    /// the ball, a square, a cube within its own size — before one it only
    /// passes within a reach of: a square is hit only where it is drawn, so
    /// a cube or a ring reaching over it by that reach must not take it.
    /// Then of the cubes and the ball, then the arrows and squares, then
    /// the rings, the one nearest the pointer on screen.
    pub fn hit(&self, pointer: &Pointer) -> Option<GizmoPart> {
        let ray = &pointer.ray;
        let r = self.reach(pointer);
        let out = |d: &Vector3, reaches: f64| {
            self.at
                .add(&d.prod_scalar(r.mul(Scalar::from_f64(reaches))))
        };
        let near = |dist: Scalar, reaches: f64| {
            (!dist.definitely_greater(r.mul(Scalar::from_f64(reaches))))
                .then(|| dist.div(r).unwrap_or(Scalar::ZERO))
        };
        (self.parts.iter().copied())
            .filter(|&part| self.shown(part, ray.dir()))
            .filter_map(|part| {
                // A cube, by its distance from the ray: over it within its
                // own size, near it within a reach more.
                let cube = |at: Vector3| {
                    let dist = ray.distance_to_point(&at).0;
                    let over = near(dist, size::CUBE).is_some();
                    Some((over, 0, near(dist, size::CUBE + size::NEAR)?))
                };
                let (over, rank, dist) = match part {
                    GizmoPart::Free => (
                        true,
                        0,
                        near(ray.distance_to_point(&self.at).0, size::FREE)?,
                    ),
                    GizmoPart::Stretch(i) => cube(out(i.of(&self.axes), size::CUBE_AT))?,
                    GizmoPart::Scale => cube(out(&self.diagonal()?, size::CUBE_AT))?,
                    GizmoPart::Move(i) => {
                        let (a, b) = size::ARROW;
                        let d = i.of(&self.axes);
                        let dist = ray.distance_to_segment(&out(d, a), &out(d, b)).0;
                        (false, 1, near(dist, size::NEAR)?)
                    }
                    GizmoPart::Plane(i) => {
                        let [j, k] = i.others();
                        let (lo, hi) = size::PLANE;
                        let corner = |x: f64, y: f64| {
                            out(j.of(&self.axes), x)
                                .add(&k.of(&self.axes).prod_scalar(r.mul(Scalar::from_f64(y))))
                        };
                        let [p, q, s, t] =
                            [(lo, lo), (hi, lo), (hi, hi), (lo, hi)].map(|(x, y)| corner(x, y));
                        let inside = ray.intersect_triangle(&p, &q, &s).is_some()
                            || ray.intersect_triangle(&p, &s, &t).is_some();
                        (true, 1, inside.then_some(Scalar::ZERO)?)
                    }
                    GizmoPart::Turn(i) => {
                        let ring = self.ring(i, r);
                        let dist = ring
                            .windows(2)
                            .filter_map(|w| match w {
                                [a, b] => Some(ray.distance_to_segment(a, b).0),
                                _ => None,
                            })
                            .min_by(|&a, &b| nearer(a, b))?;
                        (false, 2, near(dist, size::NEAR)?)
                    }
                };
                Some((!over, rank, dist, part))
            })
            .min_by(|a, b| (a.0, a.1).cmp(&(b.0, b.1)).then(nearer(a.2, b.2)))
            .map(|(_, _, _, part)| part)
    }

    /// The ring about axis `i`, as a closed polyline, a reach being `r`:
    /// as the viewer draws it, so it is hit where it is seen.
    pub fn ring(&self, i: Axis, r: Scalar) -> Vec<Vector3> {
        const SEGMENTS: usize = 64;
        let [u, v] = i.others().map(|k| k.of(&self.axes));
        let radius = r.mul(Scalar::from_f64(size::RING));
        (0..=SEGMENTS)
            .map(|k| {
                let a = std::f64::consts::TAU * k as f64 / SEGMENTS as f64;
                let (s, c) = a.sin_cos();
                self.at
                    .add(&u.prod_scalar(radius.mul(Scalar::from_f64(c))))
                    .add(&v.prod_scalar(radius.mul(Scalar::from_f64(s))))
            })
            .collect()
    }
}

/// `value` snapped to `step` — a free choice of where the pointer is,
/// made for the user.
fn snap(value: f64, step: f64) -> f64 {
    (value / step).round() * step
}

/// The step a translation snaps to, a reach being `reach`: 1, 2 or 5
/// times a power of ten, at least [`GRID`] reaches.
pub fn grid_step(reach: f64) -> f64 {
    let least = GRID * reach;
    let power = 10f64.powf(least.log10().floor());
    [1.0, 2.0, 5.0, 10.0]
        .into_iter()
        .map(|m| m * power)
        .find(|&step| step >= least)
        .unwrap_or(10.0 * power)
}

/// `value` written to as many decimals as `step` has.
fn write(value: f64, step: f64) -> String {
    let decimals = (-step.log10()).ceil().max(0.0) as usize;
    let value = if value == 0.0 { 0.0 } else { value };
    format!("{value:.decimals$}")
}

/// A drag of a gizmo under way: the gizmo as it was when the part was
/// pressed — what every event of the drag is measured against — the part,
/// how large a reach was there, and how far a turn has gone, to follow it
/// past half a turn.
#[derive(Clone, Debug)]
pub struct GizmoGrab {
    pub view: GizmoView,
    pub part: GizmoPart,
    reach: Scalar,
    turned: f64,
}

impl GizmoGrab {
    /// Grabbing `part` of `view` with `pointer`.
    pub fn new(view: GizmoView, part: GizmoPart, pointer: &Pointer) -> Self {
        let reach = view.reach(pointer);
        Self {
            view,
            part,
            reach,
            turned: 0.0,
        }
    }

    /// What the drag from `from` to `to` did — snapped unless `free` — and
    /// what to say of it. `None` where the pointer cannot be followed:
    /// looking along an arrow, or along a square's plane.
    pub fn drag(
        &mut self,
        from: &Pointer,
        to: &Pointer,
        free: bool,
    ) -> Option<(GizmoDrag, String)> {
        let view = &self.view;
        let c = view.at;
        let axes = view.axes;
        let step = grid_step(self.reach.to_f64());
        let snapped = |v: f64, step: f64| if free { v } else { snap(v, step) };
        let in_plane = |pointer: &Pointer, normal: &Vector3| {
            pointer.ray.intersect_plane(&c, normal).map(|(_, p)| p)
        };
        // A move by `amounts` along the axes `which`.
        let translate = |which: &[Axis], amounts: Vec<f64>| {
            let by = which
                .iter()
                .zip(&amounts)
                .fold(Vector3::zero(), |by, (&k, &a)| {
                    by.add(&k.of(&axes).prod_scalar(Scalar::from_f64(a)))
                });
            let text = which
                .iter()
                .zip(&amounts)
                .map(|(&k, &a)| format!("{} {}", k.name(), write(a, step)))
                .collect::<Vec<_>>()
                .join("  ");
            (Change::Translate(by), text)
        };
        let (change, text) = match self.part {
            GizmoPart::Move(i) => {
                let s = |p: &Pointer| p.ray.line_parameter(&c, i.of(&axes));
                let moved = s(to)?.sub(s(from)?).to_f64();
                translate(&[i], vec![snapped(moved, step)])
            }
            GizmoPart::Plane(i) => {
                let d = in_plane(to, i.of(&axes))?.sub(&in_plane(from, i.of(&axes))?);
                let which = i.others();
                let amounts = which
                    .iter()
                    .map(|&k| snapped(d.prod_dot(k.of(&axes)).to_f64(), step))
                    .collect();
                translate(&which, amounts)
            }
            GizmoPart::Free => {
                let d = in_plane(to, from.ray.dir())?.sub(&in_plane(from, from.ray.dir())?);
                let amounts = Axis::ALL
                    .iter()
                    .map(|&k| snapped(d.prod_dot(k.of(&axes)).to_f64(), step))
                    .collect();
                translate(&Axis::ALL, amounts)
            }
            GizmoPart::Turn(i) => {
                let a = i.of(&axes);
                if a.prod_dot(from.ray.dir()).abs().to_f64() >= size::FACING {
                    // Round the centre, where the pointer is in the ring's
                    // plane — followed past half a turn: the angle nearest
                    // the last.
                    let v0 = in_plane(from, a)?.sub(&c);
                    let v1 = in_plane(to, a)?.sub(&c);
                    let sin = v0.prod_cross(&v1).prod_dot(a).to_f64();
                    let cos = v0.prod_dot(&v1).to_f64();
                    if sin == 0.0 && cos == 0.0 {
                        return None;
                    }
                    let angle = sin.atan2(cos).to_degrees();
                    let turns = ((self.turned - angle) / 360.0).round();
                    self.turned = angle + 360.0 * turns;
                } else {
                    // Seen nearly edge on, the ring is a line on screen,
                    // and the pointer runs along it: as far along the
                    // ring's tangent where it was grabbed — its side
                    // towards the eye — as the ring's radius turns.
                    let r = self.reach;
                    let grabbed = view
                        .ring(i, r)
                        .into_iter()
                        .filter_map(|p| {
                            let (dist, t) = from.ray.distance_to_point(&p);
                            (!dist.definitely_greater(r.mul(Scalar::from_f64(size::NEAR))))
                                .then_some((t, p))
                        })
                        .min_by(|x, y| nearer(x.0, y.0))?
                        .1;
                    let tangent = a.prod_cross(&grabbed.sub(&c)).normalize().ok()?;
                    let s = |p: &Pointer| p.ray.line_parameter(&grabbed, &tangent);
                    let along = s(to)?.sub(s(from)?).to_f64();
                    self.turned = (along / (size::RING * r.to_f64())).to_degrees();
                }
                let degrees = snapped(self.turned, ANGLE_SNAP);
                let text = format!(
                    "{} {}°",
                    i.name(),
                    write(degrees, if free { 0.1 } else { 1.0 })
                );
                (Change::Rotate { axis: *a, degrees }, text)
            }
            GizmoPart::Stretch(i) => {
                let factor = self.factor(from, to, i.of(&axes), free)?;
                let mut factors = [1.0; 3];
                *i.of_mut(&mut factors) = factor;
                let text = format!("{} ×{}", i.name(), write(factor, SCALE_SNAP / 10.0));
                (Change::Scale { axes, factors }, text)
            }
            GizmoPart::Scale => {
                let factor = self.factor(from, to, &view.diagonal()?, free)?;
                let text = format!("×{}", write(factor, SCALE_SNAP / 10.0));
                (
                    Change::Scale {
                        axes,
                        factors: [factor; 3],
                    },
                    text,
                )
            }
        };
        Some((GizmoDrag { centre: c, change }, text))
    }

    /// How far a cube along `direction` was pulled out, as a factor: how
    /// far out it is now over how far it was — snapped unless `free`, and
    /// never zero or less, which would flatten or turn inside out.
    fn factor(&self, from: &Pointer, to: &Pointer, direction: &Vector3, free: bool) -> Option<f64> {
        let c = &self.view.at;
        let s0 = from.ray.line_parameter(c, direction)?.to_f64();
        let s1 = to.ray.line_parameter(c, direction)?.to_f64();
        let factor = s1 / s0;
        if !factor.is_finite() {
            return None;
        }
        let factor = if free {
            factor
        } else {
            snap(factor, SCALE_SNAP).max(SCALE_SNAP)
        };
        (factor > 0.0).then_some(factor)
    }
}

#[cfg(test)]
mod tests {
    use geop_core_math::{primitives::Ray, scalars::Scalar, vector::Vector3};

    use super::*;
    use crate::editing::Reach;

    fn v(x: f64, y: f64, z: f64) -> Vector3 {
        Vector3::from_array([x, y, z].map(Scalar::from_f64))
    }

    /// From `origin` along `dir`, a reach being a tenth of a unit.
    fn pointer(origin: [f64; 3], dir: [f64; 3]) -> Pointer {
        Pointer {
            cycle: 0,
            ray: Ray::try_new(
                v(origin[0], origin[1], origin[2]),
                v(dir[0], dir[1], dir[2]),
            )
            .unwrap(),
            reach: Reach::Tube {
                radius: Scalar::from_f64(0.1),
            },
        }
    }

    /// Looking straight down `-z` at `(x, y)`.
    fn down(x: f64, y: f64) -> Pointer {
        pointer([x, y, 10.0], [0.0, 0.0, -1.0])
    }

    fn every() -> GizmoView {
        let gizmo = Gizmo::new(v(0.0, 0.0, 0.0)).translate().rotate().scale();
        GizmoView::of(&gizmo, Orientation::World)
    }

    /// Seen from above, each part is hit where it is laid out: the ball,
    /// the arrows, the squares, the rings, the cubes.
    #[test]
    fn parts_are_hit_where_they_are_laid_out() {
        let gizmo = every();
        let hit = |x, y| gizmo.hit(&down(x, y));
        assert_eq!(hit(0.0, 0.0), Some(GizmoPart::Free));
        assert_eq!(hit(0.6, 0.0), Some(GizmoPart::Move(Axis::X)));
        assert_eq!(hit(0.0, 0.9), Some(GizmoPart::Move(Axis::Y)));
        // The xy plane's square is the one normal to z.
        assert_eq!(hit(0.32, 0.32), Some(GizmoPart::Plane(Axis::Z)));
        // The ring about z, between the arrows.
        let r = 0.7 / 2f64.sqrt();
        assert_eq!(hit(r, r), Some(GizmoPart::Turn(Axis::Z)));
        assert_eq!(hit(1.25, 0.0), Some(GizmoPart::Stretch(Axis::X)));
        assert_eq!(hit(3.0, 3.0), None);
        // Translation alone shows no ring and no cube.
        let moving = GizmoView::of(
            &Gizmo::new(v(0.0, 0.0, 0.0)).translate(),
            Orientation::World,
        );
        assert_eq!(moving.hit(&down(r, r)), None);
        assert_eq!(moving.hit(&down(1.25, 0.0)), None);
    }

    /// Where a ring or a cube reaches over a square on screen, the square
    /// is hit: they are hit within a reach of them, a square only where it
    /// is drawn. Over the cube itself, the cube is.
    #[test]
    fn squares_win_over_what_only_reaches_over_them() {
        let gizmo = every();
        let only = |part| GizmoView {
            parts: vec![part],
            ..gizmo.clone()
        };
        // From through `from` on through `to`.
        let through = |from: [f64; 3], to: [f64; 3]| {
            let dir: [f64; 3] = std::array::from_fn(|k| to[k] - from[k]);
            pointer(std::array::from_fn(|k| from[k] - 10.0 * dir[k]), dir)
        };
        let square = GizmoPart::Plane(Axis::Z);
        // The middle of the xy plane's square.
        let on_square = [0.325, 0.325, 0.0];
        // On through the ring about `y`, which runs in the `zx` plane.
        let a = (-0.62f64 / 0.7).asin();
        let ring = through(on_square, [0.7 * a.cos(), 0.0, 0.7 * a.sin()]);
        // On past the diagonal's cube, 0.14 beside its centre: further than
        // its half size, 0.09, within a reach more.
        let c = 1.25 / 3f64.sqrt();
        let s = 0.14 / 2f64.sqrt();
        let beside_cube = through(on_square, [c + s, c - s, c]);
        for (ray, other) in [
            (&ring, GizmoPart::Turn(Axis::Y)),
            (&beside_cube, GizmoPart::Scale),
        ] {
            // Each alone is hit there.
            assert_eq!(only(other).hit(ray), Some(other));
            assert_eq!(only(square).hit(ray), Some(square));
            assert_eq!(gizmo.hit(ray), Some(square), "{other:?}");
        }
        // Through the square and the middle of the cube, the cube.
        assert_eq!(
            gizmo.hit(&through(on_square, [c, c, c])),
            Some(GizmoPart::Scale)
        );
    }

    /// An arrow dragged moves along its axis only, snapped to the grid —
    /// here halves, a reach being a tenth — unless shift is held.
    #[test]
    fn arrows_move_along_their_axis() {
        let side = |z: f64| pointer([0.0, -10.0, z], [0.0, 1.0, 0.0]);
        let gizmo = every();
        let part = gizmo.hit(&side(0.6)).unwrap();
        assert_eq!(part, GizmoPart::Move(Axis::Z));
        let mut grab = GizmoGrab::new(gizmo, part, &side(0.6));
        let (drag, text) = grab.drag(&side(0.6), &side(2.0), false).unwrap();
        let Change::Translate(by) = drag.change else {
            panic!("{drag:?}")
        };
        assert_eq!([0, 1, 2].map(|k| by[k].to_f64()), [0.0, 0.0, 1.5]);
        assert_eq!(text, "z 1.5");
        let (drag, _) = grab.drag(&side(0.6), &side(2.0), true).unwrap();
        let Change::Translate(by) = drag.change else {
            panic!("{drag:?}")
        };
        assert!((by[2].to_f64() - 1.4).abs() < 1e-12);
    }

    /// A ring dragged a quarter round turns by 90 degrees, followed past
    /// half a turn, and snapped to 15 degrees.
    #[test]
    fn rings_turn_about_their_axis() {
        let gizmo = every();
        let at = |a: f64| {
            let a = a.to_radians();
            down(0.7 * a.cos(), 0.7 * a.sin())
        };
        let mut grab = GizmoGrab::new(gizmo, GizmoPart::Turn(Axis::Z), &at(0.0));
        let degrees = |grab: &mut GizmoGrab, a: f64| match grab.drag(&at(0.0), &at(a), false) {
            Some((
                GizmoDrag {
                    change: Change::Rotate { degrees, .. },
                    ..
                },
                _,
            )) => degrees,
            other => panic!("{other:?}"),
        };
        assert_eq!(degrees(&mut grab, 92.0), 90.0);
        assert_eq!(degrees(&mut grab, 170.0), 165.0);
        // Past half a turn: on, not back.
        assert_eq!(degrees(&mut grab, 200.0), 195.0);
        let (drag, text) = grab.drag(&at(0.0), &at(90.0), false).unwrap();
        assert_eq!(text, "z 90°");
        let turned = drag.apply_f64([1.0, 0.0, 0.0]);
        assert!(
            turned[0].abs() < 1e-12 && (turned[1] - 1.0).abs() < 1e-12,
            "{turned:?}"
        );
    }

    /// Seen edge on, a ring turns as far as the pointer runs along it: a
    /// quarter of its circumference, a quarter turn.
    #[test]
    fn rings_seen_edge_on_follow_the_pointer_along_them() {
        let gizmo = every();
        // Looking along `y`, the ring about `z` is a line along `x`; its
        // side towards the eye runs along `x`.
        let side = |x: f64| pointer([x, -10.0, 0.0], [0.0, 1.0, 0.0]);
        let mut grab = GizmoGrab::new(gizmo, GizmoPart::Turn(Axis::Z), &side(0.0));
        let quarter = std::f64::consts::FRAC_PI_2 * 0.7;
        let (drag, _) = grab.drag(&side(0.0), &side(quarter), false).unwrap();
        let Change::Rotate { degrees, .. } = drag.change else {
            panic!("{drag:?}")
        };
        assert_eq!(degrees, 90.0);
    }

    /// A cube pulled out to twice as far scales by two along its axis;
    /// the diagonal's, evenly.
    #[test]
    fn cubes_scale() {
        let gizmo = every();
        let mut grab = GizmoGrab::new(gizmo.clone(), GizmoPart::Stretch(Axis::X), &down(1.25, 0.0));
        let (drag, text) = grab.drag(&down(1.25, 0.0), &down(2.5, 0.0), false).unwrap();
        assert_eq!(text, "x ×2.00");
        let stretched = drag.apply_f64([1.0, 1.0, 1.0]);
        let want = [2.0, 1.0, 1.0];
        assert!(
            (0..3).all(|k| (stretched[k] - want[k]).abs() < 1e-12),
            "{stretched:?}"
        );
        let diagonal = |s: f64| {
            let d = s / 3f64.sqrt();
            pointer([d - 10.0, d + 10.0, d], [1.0, -1.0, 0.0])
        };
        let part = gizmo.hit(&diagonal(1.25)).unwrap();
        assert_eq!(part, GizmoPart::Scale);
        let mut grab = GizmoGrab::new(gizmo, part, &diagonal(1.25));
        let (drag, _) = grab.drag(&diagonal(1.25), &diagonal(0.625), false).unwrap();
        let half = drag.apply_f64([1.0, 1.0, 1.0]);
        assert!(half.iter().all(|c| (c - 0.5).abs() < 1e-12), "{half:?}");
    }

    /// The steps a translation snaps to are round, and at least 20 pixels
    /// on screen.
    #[test]
    fn grid_steps_are_round() {
        assert_eq!(grid_step(0.1), 0.5);
        assert_eq!(grid_step(0.5), 2.0);
        assert_eq!(grid_step(4.0), 10.0);
        assert_eq!(grid_step(0.04), 0.1);
    }

    /// Turned to its own axes, the gizmo moves along them.
    #[test]
    fn local_axes_are_followed() {
        let s = 0.5f64.sqrt();
        let gizmo = Gizmo::new(v(0.0, 0.0, 0.0)).translate().local([
            v(s, s, 0.0),
            v(-s, s, 0.0),
            v(0.0, 0.0, 1.0),
        ]);
        let local = GizmoView::of(&gizmo, Orientation::Local);
        assert_eq!(
            local.hit(&down(0.5 * s, 0.5 * s)),
            Some(GizmoPart::Move(Axis::X))
        );
        let world = GizmoView::of(&gizmo, Orientation::World);
        assert_eq!(world.hit(&down(0.5, 0.0)), Some(GizmoPart::Move(Axis::X)));
        let mut grab = GizmoGrab::new(local, GizmoPart::Plane(Axis::Z), &down(0.4 * s, 0.0));
        let (drag, _) = grab
            .drag(&down(0.0, 0.0), &down(2.0 * s, 2.0 * s), false)
            .unwrap();
        let moved = drag.apply_f64([0.0, 0.0, 0.0]);
        assert!((moved[0] - 2.0 * s).abs() < 1e-12 && (moved[1] - 2.0 * s).abs() < 1e-12);
    }
}