//! The 3D viewport: navigation, GPU (or CPU fallback) rendering, picking, overlays, the view
//! cube and the navigation bar.

use egui::{Align2, Color32, FontId, Pos2, Rect, Sense, Shape, Stroke, pos2, vec2};
use serde_json::json;
use solvecraft_engine::Sel;
use solvecraft_engine::geom::{Vec2, Vec3};
use solvecraft_engine::render::{Camera, Mat4, Rgb};
use solvecraft_engine::sketch::CurveKind;
use solvecraft_engine::view::{colors, grid_step, sketch_consumed, sketch_lines};
use std::hash::{Hash, Hasher};

use crate::gpu::{GpuScene, GpuTarget, SceneSlot, ViewportCallback};
use crate::selection::{BoxSel, origin_quads, origin_size, ray_quad};
use crate::theme::Tokens;
use crate::{SolveApp, icons};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum NavMode {
    Orbit,
    Pan,
    Zoom,
}

#[derive(Default)]
pub struct ViewportState {
    /// Per-body bounding boxes for fast picking, keyed by the model they were taken from.
    pick_bounds: std::sync::Mutex<Option<(usize, std::sync::Arc<Vec<(String, solvecraft_engine::geom::Aabb3)>>)>>,
    /// The last pick (its key and hits): reused while nothing it depends on changed.
    last_pick: Option<(u64, Vec<Hit>)>,
    pub rect: Option<Rect>,
    pub gpu: Option<GpuTarget>,
    slot: SceneSlot,
    key: u64,
    hl_slot: SceneSlot,
    hl_key: u64,
    cpu: Option<(u64, egui::TextureHandle)>,
    /// Nothing will look at the frame (the headless scenario harness): skip the software render.
    pub no_pixels: bool,
    pub nav: Option<NavMode>,
    /// What a click would pick now (after the active command's filter).
    pub hover: Option<Hit>,
    pub mouse: Option<Pos2>,
    /// Box selection being dragged.
    pub boxsel: Option<BoxSel>,
    /// Timeline item under the cursor: its bodies or resulting faces are highlighted.
    pub hover_feature: Option<u64>,
    /// Bodies whose browser row is under the cursor: highlighted the same way.
    pub hover_bodies: Vec<String>,
    /// The model point an orbit turns around (Preferences: orbit around the cursor).
    pub orbit_pivot: Option<Vec3>,
    /// Continuous orbit: the view turns about the vertical until the next click or key.
    pub spin: bool,
    /// A primary press on the cube: the pointer position used by its last orbit step.
    pub cube_drag: Option<Pos2>,
    pub build_ms: f64,
    /// The right-click menu, open at this screen position.
    pub context_menu: Option<Pos2>,
    /// A sketch point or curve being dragged (its id, the undo depth when the drag began: the
    /// whole drag is one undo step, and for a curve where it was last under the cursor).
    pub point_drag: Option<(String, usize, Option<Vec2>)>,
}

/// Something under the cursor.
#[derive(Clone, Debug, PartialEq)]
pub enum Hit {
    SketchPoint {
        sketch: u64,
        id: String,
        at: Vec2,
    },
    /// A sketch curve; `straight` for lines (usable as an axis).
    SketchCurve {
        sketch: u64,
        id: String,
        straight: bool,
    },
    Vertex {
        body: String,
        point: Vec3,
    },
    Edge {
        body: String,
        index: usize,
        mid: Vec3,
    },
    Profile {
        sketch: u64,
        index: usize,
    },
    Face {
        body: String,
        index: usize,
        point: Vec3,
    },
    /// An origin plane (XY, XZ, YZ) or a construction plane (by name).
    Plane {
        name: String,
        point: Vec3,
    },
    /// An origin axis (X, Y, Z).
    Axis {
        name: String,
    },
}

/// World ↔ screen mapping for the current frame.
#[derive(Clone, Copy)]
pub struct Proj {
    pub cam: Camera,
    pub vp: Mat4,
    pub rect: Rect,
}

impl Proj {
    pub fn to_screen(&self, p: Vec3) -> Option<Pos2> {
        let c = self.vp.apply(p);
        if c[3] <= 1e-9 {
            return None;
        }
        let (x, y) = (c[0] / c[3], c[1] / c[3]);
        Some(pos2(
            self.rect.left() + ((x + 1.0) * 0.5 * self.rect.width() as f64) as f32,
            self.rect.top() + ((1.0 - y) * 0.5 * self.rect.height() as f64) as f32,
        ))
    }
    pub fn ray(&self, p: Pos2) -> (Vec3, Vec3) {
        self.cam.ray((p.x - self.rect.left()) as f64, (p.y - self.rect.top()) as f64, self.rect.width() as f64, self.rect.height() as f64)
    }
}

/// A projected 3D face (convex): an unfeathered triangle fan, outlined one edge at a time (no
/// joins between the edges). Unlike `Shape::convex_polygon`, it stays inside its outline when
/// the face turns edge-on.
pub(crate) fn projected_polygon(pts: &[Pos2], fill: Color32, stroke: Stroke) -> Vec<Shape> {
    let mut mesh = egui::Mesh::default();
    for (i, p) in (0u32..).zip(pts) {
        mesh.colored_vertex(*p, fill);
        if i >= 2 {
            mesh.add_triangle(0, i - 1, i);
        }
    }
    let mut out = vec![Shape::mesh(mesh)];
    out.extend(pts.iter().zip(pts.iter().skip(1).chain(pts.first())).map(|(a, b)| Shape::line_segment([*a, *b], stroke)));
    out
}

/// View directions all round, a few degrees apart, none exactly along an axis.
#[cfg(test)]
pub(crate) fn orbit_directions() -> impl Iterator<Item = Vec3> {
    (0..90).flat_map(|i| {
        (0..45).map(move |j| {
            let (yaw, pitch) = (f64::from(i) * 4.0f64.to_radians() + 0.003, f64::from(j) * 4.0f64.to_radians() - 1.5);
            Vec3::new(pitch.cos() * yaw.cos(), pitch.cos() * yaw.sin(), pitch.sin())
        })
    })
}

/// Every vertex egui draws for `shapes`.
#[cfg(test)]
pub(crate) fn drawn_points(shapes: Vec<Shape>) -> Vec<Pos2> {
    let mut tess = egui::epaint::Tessellator::new(1.0, egui::epaint::TessellationOptions::default(), [1, 1], vec![]);
    let mut mesh = egui::Mesh::default();
    for shape in shapes {
        tess.tessellate_shape(shape, &mut mesh);
    }
    mesh.vertices.iter().map(|v| v.pos).collect()
}

fn rgba(c: Rgb) -> [u8; 4] {
    [c.0, c.1, c.2, 255]
}

pub fn scene_radius(app: &SolveApp) -> f64 {
    let mut b = model_bounds(app);
    if !app.preview.bounds.is_empty() {
        b = b.union(&app.preview.bounds);
    }
    let r = if b.is_empty() { 50.0 } else { b.diagonal() * 0.5 + b.center().dist(app.cam.target) };
    r.max(app.cam.half_height() * 2.0).max(10.0)
}

pub fn projection(app: &SolveApp, rect: Rect) -> Proj {
    let mut cam = app.cam;
    cam.fov = if app.ui.perspective { 0.6 } else { 0.0 };
    let aspect = rect.width() as f64 / rect.height().max(1.0) as f64;
    Proj { cam, vp: cam.view_proj(aspect, scene_radius(app)), rect }
}

/// Sketches drawn in the viewport: the active one, and finished ones not yet used by a feature.
fn visible_sketches(app: &SolveApp) -> Vec<u64> {
    let st = app.session.world_state();
    st.sketches
        .iter()
        .filter(|s| {
            app.session.active_sketch == Some(s.feature)
                || (!app.session.visibility.hidden_sketches.contains(&s.feature)
                    && (app.session.visibility.shown_sketches.contains(&s.feature)
                        || (app.ui.show_sketches && !sketch_consumed(&app.session, s.feature))))
        })
        .map(|s| s.feature)
        .collect()
}

fn scene_key(app: &SolveApp) -> u64 {
    let mut h = std::collections::hash_map::DefaultHasher::new();
    app.session.revision.hash(&mut h);
    app.ui.show_grid.hash(&mut h);
    app.ui.visual_style.hash(&mut h);
    app.ui.ground_shadow.hash(&mut h);
    // The section plane (its cut outlines are part of the model scene).
    section_plane(app).map(|(o, n)| [o.x, o.y, o.z, n.x, n.y, n.z].map(f64::to_bits)).hash(&mut h);
    app.cam.up.hash(&mut h);
    (app.cam.pitch > 0.0).hash(&mut h);
    app.ui.show_sketches.hash(&mut h);
    app.session.visibility.hidden_bodies.hash(&mut h);
    app.session.visibility.hidden_occurrences.hash(&mut h);
    app.session.visibility.hidden_sketches.hash(&mut h);
    app.session.visibility.shown_sketches.hash(&mut h);
    app.ui.hidden_profiles.hash(&mut h);
    app.session.active_component.hash(&mut h);
    app.session.active_occurrence_path.hash(&mut h);
    app.preview.replaced.hash(&mut h);
    crate::theme::is_dark().hash(&mut h);
    app.session.active_sketch.hash(&mut h);
    let (minor, _) = grid_step(app.cam.half_height());
    minor.to_bits().hash(&mut h);
    ((app.cam.target.x / (minor * 5.0)).round() as i64).hash(&mut h);
    ((app.cam.target.y / (minor * 5.0)).round() as i64).hash(&mut h);
    h.finish()
}

/// A sketch curve colour from the engine, in the current theme.
fn sketch_color(t: &Tokens, c: Rgb) -> [u8; 4] {
    if c == colors::SKETCH {
        c4(t.sketch)
    } else if c == colors::SKETCH_DONE || c == colors::SKETCH_FIXED {
        c4(t.sketch_fixed)
    } else if c == colors::SKETCH_LOCKED {
        c4(t.sketch_locked)
    } else {
        rgba(c)
    }
}

fn build_scene(app: &SolveApp) -> GpuScene {
    let tk = Tokens::get();
    let mut sc = GpuScene::default();
    let s = &app.session;
    // Bodies where their occurrences place them.
    let st = s.world_state();
    if app.ui.show_grid && !active_view(app).hide_grid {
        let (minor, major) = grid_step(app.cam.half_height());
        let ext = (app.cam.half_height() * 3.0 / major).ceil() * major;
        // The ground plane: XY with Z up, XZ with Y up (laid out in the camera's Z-up frame).
        let tf = app.cam.to_frame(app.cam.target);
        let c = Vec3::new((tf.x / major).round() * major, (tf.y / major).round() * major, 0.0);
        let w3 = |p: Vec3| app.cam.from_frame(p).to_f32();
        let n = ((ext / minor) as i64).clamp(1, 300);
        for i in -n..=n {
            let t = i as f64 * minor;
            let maj = (t / major).round() * major == t;
            let col = if maj { c4(tk.grid_major) } else { c4(tk.grid) };
            let w = if maj { 1.0 } else { 0.7 };
            sc.under_line(w3(c + Vec3::new(t, -ext, 0.0)), w3(c + Vec3::new(t, ext, 0.0)), col, w);
            sc.under_line(w3(c + Vec3::new(-ext, t, 0.0)), w3(c + Vec3::new(ext, t, 0.0)), col, w);
        }
    }
    let active_bodies = s.active_occurrence_path.as_ref().and_then(|p| s.occurrence_bodies(p, true).ok());
    for b in &st.bodies {
        if !app.session.body_visible(&b.name) || app.preview.replaced.contains(&b.name) {
            continue;
        }
        // With a component active, bodies outside it are drawn faded.
        let faded = if let Some(names) = &active_bodies {
            !names.contains(&b.name)
        } else {
            s.active_component != 0 && !s.doc.component_within(b.component, s.active_component)
        };
        let base = body_color(&s.doc, b).unwrap_or(tk.body);
        let col = if faded { c4(base.gamma_multiply(0.35)) } else { c4(base) };
        let m = b.mesh();
        let (shaded, edges) = match app.ui.visual_style {
            1 => (true, false),
            2 => (false, true),
            _ => (true, true),
        };
        let edge_col = if shaded { c4(tk.body_edge) } else { c4(tk.text) };
        // Shaded with hidden edges: edges behind the model show faintly.
        let hidden_edges = app.ui.visual_style == 3;
        let hidden_col = c4(tk.text.gamma_multiply(0.35));
        // Appearances: the body's opacity, and faces with looks of their own.
        let opacity = s.doc.model_body_look(b).map_or(1.0, |l| l.opacity);
        let face_looks: std::collections::HashMap<usize, solvecraft_engine::doc::appearance::Look> =
            if shaded { s.doc.face_colors(b).into_iter().collect() } else { Default::default() };
        for (ti, t) in m.triangles.iter().enumerate().filter(|_| shaded) {
            let (mut col, a) = match m.tri_face.get(ti).and_then(|f| face_looks.get(&(*f as usize))) {
                Some(l) => {
                    let c = Color32::from_rgb(l.color[0], l.color[1], l.color[2]);
                    (if faded { c4(c.gamma_multiply(0.35)) } else { c4(c) }, l.opacity)
                }
                None => (col, opacity),
            };
            let glass = !faded && a < 0.999;
            if glass {
                col[3] = (a.clamp(0.05, 1.0) * 255.0).round() as u8;
            }
            for k in t {
                let i = *k as usize;
                if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {
                    if faded {
                        sc.trans_tri(p.to_f32(), n.to_f32(), col);
                    } else if glass {
                        sc.glass_tri(p.to_f32(), n.to_f32(), col);
                    } else {
                        sc.tri(p.to_f32(), n.to_f32(), col);
                    }
                }
            }
        }
        for (ei, e) in m.edges.iter().enumerate().filter(|_| edges) {
            if m.seams.get(ei).copied().unwrap_or(false) {
                continue;
            }
            for w in e.windows(2) {
                sc.line(w[0].to_f32(), w[1].to_f32(), edge_col, 1.3, false);
                if hidden_edges {
                    sc.hidden_line(w[0].to_f32(), w[1].to_f32(), hidden_col, 1.0);
                }
            }
        }
    }
    if app.ui.ground_shadow && app.ui.visual_style != 2 && app.cam.pitch > 0.0 {
        ground_shadow(&mut sc, app, &st);
    }
    // Section: the outline of each body where the plane cuts it.
    if let Some((o, n)) = section_plane(app) {
        let col = c4(tk.text.gamma_multiply(0.9));
        for b in st.bodies.iter().filter(|b| app.session.body_visible(&b.name)) {
            for (a, c) in section_segments(&b.mesh(), o, n) {
                sc.line(a.to_f32(), c.to_f32(), col, 1.8, false);
            }
        }
    }
    for sid in visible_sketches(app) {
        let Some(ss) = st.sketch(sid) else { continue };
        let active = s.active_sketch == Some(sid);
        // Closed profiles are shaded (lifted off a face they may lie on).
        let lift = ss.plane.normal() * 0.01;
        let profiles = if app.ui.hidden_profiles.contains(&sid) || ss.sketch.view.hide_profile { &[][..] } else { &ss.profiles[..] };
        for p in profiles {
            for tri in p.region.triangulate(0.05) {
                for q in tri {
                    sc.trans_tri((ss.plane.to_world(q) + lift).to_f32(), [0.0; 3], c4(tk.profile_fill));
                }
            }
        }
        // Construction curves are dashed, centerlines dash-dot (lengths follow the grid).
        let unit = grid_step(app.cam.half_height()).0;
        for (pts, col, cons) in sketch_lines(&ss.sketch, &ss.plane, active, &ss.report.curve_determined) {
            let segs = if !cons {
                pts.windows(2).map(|w| (w[0], w[1])).collect()
            } else if col == colors::SKETCH_CENTERLINE {
                dashes(&pts, &[0.6 * unit, 0.15 * unit, 0.05 * unit, 0.15 * unit])
            } else {
                dashes(&pts, &[0.3 * unit, 0.2 * unit])
            };
            for (a, b) in segs {
                sc.line(a.to_f32(), b.to_f32(), sketch_color(&tk, col), if cons { 1.2 } else { 2.0 }, active);
            }
        }
    }
    sc
}

/// A soft dark ellipse on the ground under the shown bodies (darkest in the middle).
fn ground_shadow(sc: &mut GpuScene, app: &SolveApp, st: &solvecraft_engine::doc::ModelState) {
    // The bodies' box in the camera's Z-up frame (the ground is its XY plane).
    let mut b = solvecraft_engine::geom::Aabb3::EMPTY;
    for x in st.bodies.iter().filter(|x| app.session.body_visible(&x.name)) {
        let bb = x.mesh().bounds();
        if bb.is_empty() {
            continue;
        }
        for i in 0..8 {
            let p = Vec3::new(
                if i & 1 == 0 { bb.min.x } else { bb.max.x },
                if i & 2 == 0 { bb.min.y } else { bb.max.y },
                if i & 4 == 0 { bb.min.z } else { bb.max.z },
            );
            b.add(app.cam.to_frame(p));
        }
    }
    if b.is_empty() {
        return;
    }
    let size = b.size();
    let c = b.center();
    let z = b.min.z - 1e-3 * (1.0 + b.diagonal());
    let (rx, ry) = (size.x * 0.62 + size.z * 0.15, size.y * 0.62 + size.z * 0.15);
    if !(rx > 0.0 && ry > 0.0) {
        return;
    }
    let dark = if crate::theme::is_dark() { 150 } else { 80 };
    // Rings from the middle out, fading to nothing.
    let rings = [(0.0, dark), (0.55, dark * 3 / 4), (0.85, dark / 3), (1.0, 0)];
    let n = 48;
    let at = |r: f64, k: usize| {
        let a = k as f64 / n as f64 * std::f64::consts::TAU;
        app.cam.from_frame(Vec3::new(c.x + rx * r * a.cos(), c.y + ry * r * a.sin(), z)).to_f32()
    };
    for w in rings.windows(2) {
        let ((r0, a0), (r1, a1)) = (w[0], w[1]);
        let (c0, c1) = ([0, 0, 0, a0 as u8], [0, 0, 0, a1 as u8]);
        for k in 0..n {
            let (p00, p01, p10, p11) = (at(r0, k), at(r0, k + 1), at(r1, k), at(r1, k + 1));
            sc.trans_tri(p00, [0.0; 3], c0);
            sc.trans_tri(p10, [0.0; 3], c1);
            sc.trans_tri(p11, [0.0; 3], c1);
            if r0 > 0.0 {
                sc.trans_tri(p00, [0.0; 3], c0);
                sc.trans_tri(p11, [0.0; 3], c1);
                sc.trans_tri(p01, [0.0; 3], c0);
            }
        }
    }
}

/// Where the plane through `o` with normal `n` cuts a mesh: one segment per crossed triangle,
/// nudged a hair to the kept side (so the clip leaves them drawn).
pub(crate) fn section_segments(m: &solvecraft_engine::geom::Mesh, o: Vec3, n: Vec3) -> Vec<(Vec3, Vec3)> {
    let eps = 1e-4 * (1.0 + m.bounds().diagonal());
    let mut out = Vec::new();
    for t in &m.triangles {
        let Some(p) = m.tri(t) else { continue };
        let d = p.map(|q| n.dot(q - o));
        let mut pts = Vec::with_capacity(2);
        for (i, j) in [(0, 1), (1, 2), (2, 0)] {
            if (d[i] < 0.0) != (d[j] < 0.0) {
                let s = d[i] / (d[i] - d[j]);
                pts.push(p[i] + (p[j] - p[i]) * s - n * eps);
            }
        }
        if let [a, b] = pts[..] {
            out.push((a, b));
        }
    }
    out
}

/// The drawn pieces of a polyline in a dash pattern (on, off, on, off… lengths).
pub(crate) fn dashes(pts: &[Vec3], pattern: &[f64]) -> Vec<(Vec3, Vec3)> {
    let mut out = Vec::new();
    if pattern.is_empty() || pattern.iter().any(|l| !(l.is_finite() && *l > 0.0)) {
        return pts.windows(2).map(|w| (w[0], w[1])).collect();
    }
    let (mut k, mut left) = (0usize, pattern[0]);
    for w in pts.windows(2) {
        let (mut a, b) = (w[0], w[1]);
        let mut len = (b - a).len();
        // Cap the pieces per segment so a huge zoom-out can't explode the scene.
        let mut guard = 0;
        while len > 1e-12 && guard < 10_000 {
            guard += 1;
            let step = left.min(len);
            let q = a + (b - a) * (step / len);
            if k % 2 == 0 {
                out.push((a, q));
            }
            left -= step;
            len -= step;
            a = q;
            if left <= 1e-12 {
                k = (k + 1) % pattern.len();
                left = pattern.get(k).copied().unwrap_or(1.0);
            }
        }
    }
    out
}

/// Colour as straight (unpremultiplied) sRGBA bytes for the GPU.
fn c4(c: Color32) -> [u8; 4] {
    c.to_srgba_unmultiplied()
}

/// Origin planes and axes currently shown, sized for the view: (name, normal, quad).
pub fn origin_planes(app: &SolveApp) -> Vec<(&'static str, Vec3, [Vec3; 4])> {
    if !app.origin_visible() {
        return Vec::new();
    }
    // While the Origin is hidden, Create Sketch may bring the planes back (empty design): then
    // every plane; otherwise only those not hidden one by one.
    let creating = !app.ui.show_origin && app.dialog.as_ref().is_some_and(|d| matches!(d.kind, crate::dialogs::Kind::Sketch));
    origin_quads(origin_size(app.cam.half_height()))
        .into_iter()
        .filter(|(n, _, _)| creating || !app.session.visibility.hidden_origin.iter().any(|h| h == n))
        .collect()
}

pub fn origin_axes(app: &SolveApp) -> Vec<(&'static str, Vec3)> {
    if !app.origin_visible() {
        return Vec::new();
    }
    [("X", Vec3::X), ("Y", Vec3::Y), ("Z", Vec3::Z)]
        .into_iter()
        .filter(|(n, _)| !app.session.visibility.hidden_origin.iter().any(|h| h == n))
        .collect()
}

/// Construction axes shown, as segments: across the model where the axis passes it (a little
/// past it either side), at least the origin axes' length around the axis's origin: (name,
/// from, to).
pub fn construction_axis_segments(app: &SolveApp) -> Vec<(String, Vec3, Vec3)> {
    let h = origin_size(app.cam.half_height()) * AXIS_LEN;
    let bb = solvecraft_engine::view::bounds(&app.session);
    solvecraft_engine::view::construction_axes(&app.session)
        .into_iter()
        .filter(|(_, n, _, _)| !app.session.visibility.hidden_origin.contains(n))
        .map(|(_, name, o, d)| {
            let (mut lo, mut hi) = (-h, h);
            if !bb.is_empty() {
                for i in 0..8 {
                    let c = Vec3::new(
                        if i & 1 == 0 { bb.min.x } else { bb.max.x },
                        if i & 2 == 0 { bb.min.y } else { bb.max.y },
                        if i & 4 == 0 { bb.min.z } else { bb.max.z },
                    );
                    let t = (c - o).dot(d);
                    lo = lo.min(t - h * 0.3);
                    hi = hi.max(t + h * 0.3);
                }
            }
            (name, o + d * lo, o + d * hi)
        })
        .collect()
}

/// Construction points shown: (name, position).
pub fn construction_points(app: &SolveApp) -> Vec<(String, Vec3)> {
    solvecraft_engine::view::construction_points(&app.session)
        .into_iter()
        .filter(|(_, n, _)| !app.session.visibility.hidden_origin.contains(n))
        .map(|(_, n, p)| (n, p))
        .collect()
}

/// Construction planes drawn as squares around their origin: (name, normal, quad).
pub fn construction_quads(app: &SolveApp) -> Vec<(String, Vec3, [Vec3; 4])> {
    let h = origin_size(app.cam.half_height()) * 1.2;
    solvecraft_engine::view::construction_planes(&app.session)
        .into_iter()
        .filter(|(_, n, _)| !app.session.visibility.hidden_origin.contains(n))
        .map(|(_, name, pl)| {
            let (o, x, y) = (pl.origin, pl.x * h, pl.y * h);
            (name, pl.normal(), [o - x - y, o + x - y, o + x + y, o - x + y])
        })
        .collect()
}

/// Pick what is under `pos`: sketch points, sketch curves, vertices, edges and axes first, then
/// the surfaces along the ray (profiles, faces, planes) nearest first.
/// Bounding boxes of the shown model's bodies (cached until the model changes).
fn body_bounds(
    app: &SolveApp,
    st: &std::sync::Arc<solvecraft_engine::doc::ModelState>,
) -> std::sync::Arc<Vec<(String, solvecraft_engine::geom::Aabb3)>> {
    let key = std::sync::Arc::as_ptr(st) as usize;
    if let Ok(mut g) = app.viewport.pick_bounds.lock() {
        if let Some((k, b)) = g.as_ref()
            && *k == key
        {
            return b.clone();
        }
        let b = std::sync::Arc::new(st.bodies.iter().map(|b| (b.name.clone(), b.mesh().bounds())).collect::<Vec<_>>());
        *g = Some((key, b.clone()));
        return b;
    }
    std::sync::Arc::new(Vec::new())
}

/// The model's extent: bodies (from the cached boxes) and sketches.
pub fn model_bounds(app: &SolveApp) -> solvecraft_engine::geom::Aabb3 {
    let st = app.session.world_state();
    let mut b = body_bounds(app, &st).iter().fold(solvecraft_engine::geom::Aabb3::EMPTY, |a, (_, x)| a.union(x));
    for ss in &st.sketches {
        if let Some((lo, hi)) = ss.sketch.bounds() {
            for p in [lo, hi] {
                b.add(ss.plane.to_world(p));
            }
        }
    }
    b
}

/// Where a ray enters a box (None: it misses).
fn ray_box(o: Vec3, d: Vec3, b: &solvecraft_engine::geom::Aabb3, pad: f64) -> Option<f64> {
    let (mut t0, mut t1) = (f64::NEG_INFINITY, f64::INFINITY);
    for (oo, dd, lo, hi) in [(o.x, d.x, b.min.x, b.max.x), (o.y, d.y, b.min.y, b.max.y), (o.z, d.z, b.min.z, b.max.z)] {
        let (lo, hi) = (lo - pad, hi + pad);
        if dd.abs() < 1e-15 {
            if oo < lo || oo > hi {
                return None;
            }
        } else {
            let (a, c) = ((lo - oo) / dd, (hi - oo) / dd);
            t0 = t0.max(a.min(c));
            t1 = t1.min(a.max(c));
        }
    }
    (t0 <= t1).then_some(t0)
}

/// A box's outline on screen, grown by `px` (None: behind the eye).
fn screen_box(proj: &Proj, b: &solvecraft_engine::geom::Aabb3, px: f32) -> Option<Rect> {
    let mut r = Rect::NOTHING;
    for i in 0..8 {
        let p = Vec3::new(
            if i & 1 == 0 { b.min.x } else { b.max.x },
            if i & 2 == 0 { b.min.y } else { b.max.y },
            if i & 4 == 0 { b.min.z } else { b.max.z },
        );
        r.extend_with(proj.to_screen(p)?);
    }
    Some(r.expand(px))
}

/// What is under `pos`, reusing the last answer while the cursor, the camera and the model are
/// unchanged.
fn pick_cached(app: &mut SolveApp, proj: &Proj, pos: Pos2) -> Vec<Hit> {
    let mut h = std::collections::hash_map::DefaultHasher::new();
    pos.x.to_bits().hash(&mut h);
    pos.y.to_bits().hash(&mut h);
    for v in [app.cam.yaw, app.cam.pitch, app.cam.distance, app.cam.target.x, app.cam.target.y, app.cam.target.z] {
        v.to_bits().hash(&mut h);
    }
    app.session.revision.hash(&mut h);
    (std::sync::Arc::as_ptr(&app.session.world_state()) as usize).hash(&mut h);
    app.session.active_sketch.hash(&mut h);
    app.dialog.as_ref().and_then(|d| d.active_input()).map(|i| i.accept).hash(&mut h);
    app.session.visibility.hidden_bodies.hash(&mut h);
    app.session.visibility.hidden_occurrences.hash(&mut h);
    app.ui.perspective.hash(&mut h);
    (proj.rect.width().to_bits(), proj.rect.height().to_bits()).hash(&mut h);
    let key = h.finish();
    if let Some((k, hits)) = &app.viewport.last_pick
        && *k == key
    {
        return hits.clone();
    }
    let hits = pick(app, proj, pos);
    app.viewport.last_pick = Some((key, hits.clone()));
    hits
}

pub fn pick(app: &SolveApp, proj: &Proj, pos: Pos2) -> Vec<Hit> {
    let s = &app.session;
    let st = s.world_state();
    let bounds = body_bounds(app, &st);
    let bound = |name: &str| bounds.iter().find(|(n, _)| n == name).map(|(_, b)| *b);
    let mut hits = Vec::new();
    let (o, d) = proj.ray(pos);
    // Sketch points of the active sketch (of every shown sketch while a command takes points).
    let wants_points = app.dialog.as_ref().and_then(|d| d.active_input()).is_some_and(|i| i.accept & crate::selection::POINTS != 0);
    let point_sketches: Vec<u64> = if wants_points { visible_sketches(app) } else { s.active_sketch.into_iter().collect() };
    let mut best: Option<(f32, Hit)> = None;
    for ss in point_sketches.iter().filter_map(|sid| st.sketch(*sid)) {
        let sid = ss.feature;
        for p in &ss.sketch.points {
            if let Some(sp) = proj.to_screen(ss.plane.to_world(p.pos)) {
                let dd = sp.distance(pos);
                if dd < 8.0 && best.as_ref().is_none_or(|(b, _)| dd < *b) {
                    best = Some((dd, Hit::SketchPoint { sketch: sid, id: p.id.clone(), at: p.pos }));
                }
            }
        }
    }
    if let Some((_, h)) = best {
        hits.push(h);
    }
    // Sketch curves (the active sketch wins ties).
    let mut bestc: Option<(f32, Hit)> = None;
    for sid in visible_sketches(app) {
        let Some(ss) = st.sketch(sid) else { continue };
        let bonus = if s.active_sketch == Some(sid) { 2.0 } else { 0.0 };
        for (i, c) in ss.sketch.curves.iter().enumerate() {
            if c.link.is_some() && ss.sketch.view.hide_projected {
                continue;
            }
            let straight = matches!(c.kind, CurveKind::Line { .. });
            for seg in ss.sketch.segs(i) {
                let pts: Vec<Pos2> = seg.polyline(0.05).iter().filter_map(|q| proj.to_screen(ss.plane.to_world(*q))).collect();
                for w in pts.windows(2) {
                    let dd = seg_dist(pos, w[0], w[1]) - bonus;
                    if dd < 6.0 && bestc.as_ref().is_none_or(|(b, _)| dd < *b) {
                        bestc = Some((dd, Hit::SketchCurve { sketch: sid, id: c.id.clone(), straight }));
                    }
                }
            }
        }
        // 3D sketch curves (paths for sweeps and pipes).
        for w in &ss.sketch.wires {
            let pts: Vec<Pos2> = w.pts.iter().filter_map(|q| proj.to_screen(*q)).collect();
            for seg in pts.windows(2) {
                let dd = seg_dist(pos, seg[0], seg[1]) - bonus;
                if dd < 6.0 && bestc.as_ref().is_none_or(|(b, _)| dd < *b) {
                    bestc = Some((dd, Hit::SketchCurve { sketch: sid, id: w.id.clone(), straight: false }));
                }
            }
        }
    }
    if let Some((_, h)) = bestc {
        hits.push(h);
    }
    // Nearest face along the ray (hides what is behind it).
    let mut bestf: Option<(f64, Hit)> = None;
    for b in &st.bodies {
        if !app.session.body_visible(&b.name) {
            continue;
        }
        // Bodies whose box the ray misses (or enters behind the best hit so far) are skipped.
        if let Some(bb) = bound(&b.name) {
            let pad = bb.diagonal() * 1e-6 + 1e-9;
            match ray_box(o, d, &bb, pad) {
                None => continue,
                Some(t0) if bestf.as_ref().is_some_and(|(bt, _)| t0 > *bt) => continue,
                _ => {}
            }
        }
        let m = b.mesh();
        if let Some((t, ti)) = m.raycast(o, d)
            && bestf.as_ref().is_none_or(|(bt, _)| t < *bt)
        {
            let fi = m.tri_face.get(ti).copied().unwrap_or(0) as usize;
            bestf = Some((t, Hit::Face { body: b.name.clone(), index: fi, point: o + d * t }));
        }
    }
    let slack = scene_radius(app) * 0.02;
    let visible = |p: Vec3| bestf.as_ref().is_none_or(|(t, _)| (p - o).dot(d) <= *t + slack);
    // Vertices (edge end points) and edges.
    let mut bestv: Option<(f32, Hit)> = None;
    let mut beste: Option<(f32, Hit)> = None;
    for b in &st.bodies {
        if !app.session.body_visible(&b.name) {
            continue;
        }
        // Only bodies whose outline on screen is near the cursor can have an edge under it.
        if let Some(bb) = bound(&b.name)
            && screen_box(proj, &bb, 8.0).is_some_and(|r| !r.contains(pos))
        {
            continue;
        }
        let m = b.mesh();
        for (ei, e) in m.edges.iter().enumerate() {
            if m.seams.get(ei).copied().unwrap_or(false) {
                continue;
            }
            for v in [e.first(), e.last()].into_iter().flatten() {
                if let Some(sp) = proj.to_screen(*v) {
                    let dd = sp.distance(pos);
                    if dd < 7.0 && visible(*v) && bestv.as_ref().is_none_or(|(bd, _)| dd < *bd) {
                        bestv = Some((dd, Hit::Vertex { body: b.name.clone(), point: *v }));
                    }
                }
            }
            let pts: Vec<Pos2> = e.iter().filter_map(|q| proj.to_screen(*q)).collect();
            for (k, w) in pts.windows(2).enumerate() {
                let dd = seg_dist(pos, w[0], w[1]);
                if dd < 6.0 && beste.as_ref().is_none_or(|(bd, _)| dd < *bd) {
                    let mid = polyline_mid(e);
                    // Visible where the cursor is (not just at the middle).
                    let at = e.get(k).copied().unwrap_or(mid);
                    if visible(at) || visible(mid) {
                        beste = Some((dd, Hit::Edge { body: b.name.clone(), index: ei, mid }));
                    }
                }
            }
        }
    }
    hits.extend(bestv.map(|x| x.1));
    hits.extend(beste.map(|x| x.1));
    // Origin axes.
    let size = origin_size(app.cam.half_height());
    let mut besta: Option<(f32, Hit)> = None;
    for (name, dir) in origin_axes(app) {
        if let (Some(a), Some(b)) = (proj.to_screen(Vec3::ZERO), proj.to_screen(dir * (size * AXIS_LEN))) {
            let dd = seg_dist(pos, a, b);
            if dd < 5.0 && besta.as_ref().is_none_or(|(bd, _)| dd < *bd) {
                besta = Some((dd, Hit::Axis { name: name.into() }));
            }
        }
    }
    // Construction axes, picked like the origin axes.
    for (name, a, b) in construction_axis_segments(app) {
        if let (Some(a), Some(b)) = (proj.to_screen(a), proj.to_screen(b)) {
            let dd = seg_dist(pos, a, b);
            if dd < 5.0 && besta.as_ref().is_none_or(|(bd, _)| dd < *bd) {
                besta = Some((dd, Hit::Axis { name }));
            }
        }
    }
    hits.extend(besta.map(|x| x.1));
    // Surfaces by depth: profiles (slightly preferred over a face they lie on), faces, planes.
    let mut surf: Vec<(f64, Hit)> = Vec::new();
    let mut bestp: Option<(f64, f64, Hit)> = None;
    for sid in visible_sketches(app) {
        let Some(ss) = st.sketch(sid) else { continue };
        let n = ss.plane.normal();
        let den = n.dot(d);
        if den.abs() < 1e-12 {
            continue;
        }
        let t = n.dot(ss.plane.origin - o) / den;
        if t < 0.0 {
            continue;
        }
        let lp = ss.plane.to_local(o + d * t);
        // Show Profile off: the sketch being edited offers no profiles.
        let profiles = if ss.sketch.view.hide_profile && s.active_sketch == Some(sid) { &[][..] } else { &ss.profiles[..] };
        for (pi, p) in profiles.iter().enumerate() {
            if p.region.contains(lp) && bestp.as_ref().is_none_or(|(_, a, _)| p.area < *a) {
                bestp = Some((t, p.area, Hit::Profile { sketch: sid, index: pi }));
            }
        }
    }
    if let Some((t, _, h)) = bestp {
        surf.push((t - slack, h));
    }
    if let Some(f) = bestf {
        surf.push(f);
    }
    // Planes give way to a face or profile at the same depth (a floor on the XZ plane).
    for (name, _, q) in origin_planes(app) {
        if let Some(t) = ray_quad(o, d, &q) {
            surf.push((t + slack, Hit::Plane { name: name.into(), point: o + d * t }));
        }
    }
    for (name, _, q) in construction_quads(app) {
        if let Some(t) = ray_quad(o, d, &q) {
            surf.push((t + slack, Hit::Plane { name, point: o + d * t }));
        }
    }
    surf.sort_by(|a, b| a.0.total_cmp(&b.0));
    hits.extend(surf.into_iter().map(|x| x.1));
    hits
}

/// The section cut shown now: the open Section Analysis dialog's plane, else the session's.
/// The active sketch's display options (defaults when not sketching).
pub fn active_view(app: &SolveApp) -> solvecraft_engine::sketch::SketchView {
    let st = app.session.world_state();
    app.session.active_sketch.and_then(|s| st.sketch(s)).map(|ss| ss.sketch.view.clone()).unwrap_or_default()
}

pub fn section_plane(app: &SolveApp) -> Option<(Vec3, Vec3)> {
    if let Some(d) = app.dialog.as_ref().filter(|d| matches!(d.kind, crate::dialogs::Kind::Section { .. })) {
        let cmds = crate::dialogs::apply_commands(app, d).ok()?;
        let (_, p) = cmds.into_iter().next()?;
        let mut scratch = app.session.scratch();
        scratch.execute("inspect.section", &p).ok()?;
        return scratch.section;
    }
    // Slice (Sketch Palette): cut the model at the plane of the sketch being edited.
    if app.session.section.is_none() {
        let st = app.session.world_state();
        if let Some(ss) = app.session.active_sketch.and_then(|s| st.sketch(s)).filter(|ss| ss.sketch.view.slice) {
            return Some((ss.plane.origin, ss.plane.normal()));
        }
    }
    app.session.section
}

/// Visible geometry belonging to a timeline feature. Body creators retain their whole-body
/// feedback; modifiers use persistent face names, which survive later edits and placement.
/// Do not expand these faces into surface patches: neighbouring faces can belong to another
/// feature even when they share a surface.
fn feature_geometry(app: &SolveApp, id: u64) -> Vec<Sel> {
    if !app.session.model.result(id).is_some_and(|r| !r.skipped && r.error.is_none()) {
        return Vec::new();
    }
    let st = app.session.world_state();
    let prefix = format!("F{id}:");
    let mut out = Vec::new();
    for b in &st.bodies {
        if !app.session.body_visible(&b.name) || app.preview.replaced.contains(&b.name) {
            continue;
        }
        if b.feature == id {
            out.push(Sel::Body { name: b.name.clone() });
            continue;
        }
        let names = solvecraft_engine::doc::naming::face_names(b);
        let m = b.mesh();
        for (index, _) in names.iter().enumerate().filter(|(_, n)| n.starts_with(&prefix)) {
            if let Some(point) = m.triangles.iter().zip(&m.tri_face).find_map(|(t, f)| {
                if *f as usize != index {
                    return None;
                }
                m.tri(t).map(|[a, b, c]| (a + b + c) / 3.0)
            }) {
                out.push(Sel::Face { body: b.name.clone(), index, point });
            }
        }
    }
    out
}

fn displayed_selection(app: &SolveApp, item: &Sel) -> Vec<Sel> {
    match item {
        Sel::Feature { id } => feature_geometry(app, *id),
        Sel::Occurrence { path } => app
            .session
            .occurrence_bodies(path, true)
            .unwrap_or_default()
            .into_iter()
            .filter(|name| app.session.body_visible(name))
            .map(|name| Sel::Body { name })
            .collect(),
        _ => grouped_selection(&app.session, item),
    }
}

/// The box around what is selected (bodies, faces, edges, vertices, sketch curves and the
/// bodies of selected features), where it is shown.
pub fn selection_bounds(app: &SolveApp) -> Option<solvecraft_engine::geom::Aabb3> {
    let st = app.session.world_state();
    let mut b = solvecraft_engine::geom::Aabb3::EMPTY;
    for s in app.session.selection.iter().flat_map(|item| displayed_selection(app, item)) {
        match &s {
            Sel::Body { name } => {
                if let Some(x) = st.body(name) {
                    b = b.union(&x.mesh().bounds());
                }
            }
            Sel::Face { body, index, .. } => {
                if let Some(x) = st.body(body) {
                    let m = x.mesh();
                    for (t, f) in m.triangles.iter().zip(&m.tri_face) {
                        if *f as usize == *index {
                            for p in m.tri(t).into_iter().flatten() {
                                b.add(p);
                            }
                        }
                    }
                }
            }
            Sel::Edge { body, index, .. } => {
                if let Some(e) = st.body(body).and_then(|x| x.mesh().edges.get(*index).cloned()) {
                    for p in e {
                        b.add(p);
                    }
                }
            }
            Sel::Vertex { point, .. } => b.add(*point),
            Sel::SketchCurve { id } => {
                for ss in &st.sketches {
                    if let Some(i) = ss.sketch.curve_index(id) {
                        for q in ss.sketch.polyline(i) {
                            b.add(ss.plane.to_world(q));
                        }
                    }
                }
            }
            _ => {}
        }
    }
    (!b.is_empty()).then_some(b)
}

/// The section as the shader's clip plane (normal, d), zero when there is none.
/// The surface analysis for the shader (see `gpu::ViewportCallback::analysis`).
fn analysis_uniform(app: &SolveApp) -> [f32; 8] {
    use solvecraft_engine::SurfaceAnalysis as A;
    match app.session.analysis {
        Some(A::Zebra { stripes }) => [1.0, stripes as f32, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
        Some(A::Draft { pull, angle }) => [2.0, angle as f32, 0.0, 0.0, pull.x as f32, pull.y as f32, pull.z as f32, 0.0],
        Some(A::Curvature { radius }) => [3.0, radius as f32, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
        Some(A::Environment) => [4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
        Some(A::Access { dir }) => {
            let (scale, size, eps) = crate::access::map(app).map(|m| (m.scale, m.size as f32, 1.5 / m.scale.max(1e-9))).unwrap_or((0.0, 0.0, 0.0));
            [5.0, eps, scale, size, dir.x as f32, dir.y as f32, dir.z as f32, 0.0]
        }
        None => [0.0; 8],
    }
}

fn section_clip(app: &SolveApp) -> [f32; 4] {
    match section_plane(app) {
        Some((o, n)) => [n.x as f32, n.y as f32, n.z as f32, n.dot(o) as f32],
        None => [0.0; 4],
    }
}

/// Space kept free at the top right of the viewport for the view cube (docked dialogs start below).
pub const VIEW_CUBE_CLEARANCE: f32 = 168.0;

/// Axis length as a multiple of the origin plane size (solid part 1, dashed beyond).
const AXIS_LEN: f64 = 1.8;

/// The hit as a plain selection (no command filter).
pub fn hit_sel(h: &Hit) -> Option<Sel> {
    Some(match h {
        Hit::SketchPoint { id, .. } => Sel::SketchPoint { id: id.clone() },
        Hit::SketchCurve { id, .. } => Sel::SketchCurve { id: id.clone() },
        Hit::Vertex { body, point } => Sel::Vertex { body: body.clone(), point: *point },
        Hit::Edge { body, index, mid } => Sel::Edge { body: body.clone(), index: *index, point: *mid },
        Hit::Profile { sketch, index } => Sel::Profile { sketch: *sketch, index: *index },
        Hit::Face { body, index, point } => Sel::Face { body: body.clone(), index: *index, point: *point },
        Hit::Plane { name, .. } => Sel::Plane { name: name.clone() },
        Hit::Axis { name } => Sel::Axis { name: name.clone() },
    })
}

/// What a click would pick: the first hit the open dialog's active input accepts, or with no
/// dialog the first hit (sketch entities only belong to the active sketch).
pub fn candidate(app: &SolveApp, hits: &[Hit]) -> Option<(Hit, Sel)> {
    if let Some(d) = app.dialog.as_ref().filter(|d| d.wants_picks()) {
        return hits.iter().find_map(|h| d.candidate(&app.session, h).map(|s| (h.clone(), s)));
    }
    let off = |k: &str| app.ui.pick_off.iter().any(|x| x == k);
    hits.iter()
        .filter(|h| match h {
            Hit::SketchCurve { sketch, .. } => app.session.active_sketch == Some(*sketch) && !off("sketch") && !off("sketch_curves"),
            Hit::SketchPoint { .. } => !off("sketch") && !off("sketch_points"),
            Hit::Profile { .. } => !off("sketch"),
            Hit::Vertex { .. } => !off("vertices") && !app.ui.pick_bodies,
            Hit::Edge { .. } => !off("edges") && !app.ui.pick_bodies,
            Hit::Face { .. } => !off("faces") || app.ui.pick_bodies,
            Hit::Plane { .. } | Hit::Axis { .. } => true,
        })
        .find_map(|h| match h {
            Hit::Face { body, .. } if app.ui.pick_bodies => Some((h.clone(), Sel::Body { name: body.clone() })),
            _ => hit_sel(h).map(|s| (h.clone(), s)),
        })
}

/// The edge a selection refers to now: by index if it still passes through the stored point,
/// otherwise the edge nearest the point.
fn edge_of(m: &solvecraft_engine::geom::Mesh, index: usize, point: Vec3) -> Option<&Vec<Vec3>> {
    let tol = m.bounds().diagonal().max(1.0) * 1e-6;
    let near = |e: &Vec<Vec3>| e.windows(2).map(|w| point.dist_to_segment(w[0], w[1])).fold(f64::INFINITY, f64::min);
    if let Some(e) = m.edges.get(index)
        && near(e) < tol
    {
        return Some(e);
    }
    m.edges.iter().min_by(|a, b| near(a).total_cmp(&near(b))).filter(|e| near(e) < tol * 1e3)
}

fn face_tris(sc: &mut GpuScene, m: &solvecraft_engine::geom::Mesh, face: usize, col: [u8; 4], lit: bool) {
    for (t, f) in m.triangles.iter().zip(&m.tri_face) {
        if *f as usize != face {
            continue;
        }
        for k in t {
            let i = *k as usize;
            if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {
                sc.tri(p.to_f32(), if lit { n.to_f32() } else { [0.0; 3] }, col);
            }
        }
    }
}

/// A highlighted edge: a halo and a core, and where the model hides it, the core dimmed (so a
/// pick on the far side still shows).
fn edge_lines(sc: &mut GpuScene, e: &[Vec3], core: Color32, halo: Color32, w: f32) {
    for (col, width) in [(halo, w + 3.0), (core, w)] {
        for p in e.windows(2) {
            sc.line(p[0].to_f32(), p[1].to_f32(), c4(col), width, false);
        }
    }
    for p in e.windows(2) {
        sc.hidden_line(p[0].to_f32(), p[1].to_f32(), c4(core.gamma_multiply(0.45)), (w * 0.7).max(1.0));
    }
}

/// The outline of a highlighted face where the model hides it (dimmed).
fn hidden_face_outline(sc: &mut GpuScene, m: &solvecraft_engine::geom::Mesh, face: usize, col: Color32) {
    for (ei, e) in m.edges.iter().enumerate() {
        let on = m.edge_faces.get(ei).is_some_and(|f| f.iter().any(|x| *x as usize == face));
        if on && !m.seams.get(ei).copied().unwrap_or(false) {
            for p in e.windows(2) {
                sc.hidden_line(p[0].to_f32(), p[1].to_f32(), c4(col.gamma_multiply(0.45)), 1.4);
            }
        }
    }
}

fn profile_fill(sc: &mut GpuScene, app: &SolveApp, sketch: u64, index: usize, fill: Color32, edge: Color32) {
    let st = app.session.world_state();
    let Some(ss) = st.sketch(sketch) else { return };
    let Some(p) = ss.profiles.get(index) else { return };
    // Lift toward the eye so a profile on a face shows over it.
    let lift = app.cam.back() * (app.cam.half_height() * 0.002);
    let w = |q: solvecraft_engine::geom::Vec2| (ss.plane.to_world(q) + lift).to_f32();
    let col = c4(fill);
    // In the translucent pass (after the grid and edges) so it covers them.
    for [a, b, c] in p.region.triangulate(0.02) {
        sc.trans_tri(w(a), [0.0; 3], col);
        sc.trans_tri(w(b), [0.0; 3], col);
        sc.trans_tri(w(c), [0.0; 3], col);
    }
    for lp in std::iter::once(&p.region.outer).chain(&p.region.holes) {
        let poly = lp.polyline(0.02);
        let n = poly.len();
        for i in 0..n {
            if let (Some(a), Some(b)) = (poly.get(i), poly.get((i + 1) % n)) {
                sc.line(w(*a), w(*b), c4(edge), 2.0, false);
            }
        }
    }
}

fn quad(sc: &mut GpuScene, q: &[Vec3; 4], fill: Color32, edge: Color32) {
    let col = c4(fill);
    for i in [0, 1, 2, 0, 2, 3] {
        if let Some(p) = q.get(i) {
            sc.trans_tri(p.to_f32(), [0.0; 3], col);
        }
    }
    for i in 0..4 {
        sc.line(q[i].to_f32(), q[(i + 1) % 4].to_f32(), c4(edge), 1.2, false);
    }
}

fn highlight_key(app: &SolveApp) -> u64 {
    let mut h = std::collections::hash_map::DefaultHasher::new();
    app.session.revision.hash(&mut h);
    serde_json::to_string(&app.highlighted()).unwrap_or_default().hash(&mut h);
    format!("{:?}", app.viewport.hover).hash(&mut h);
    app.viewport.hover_feature.hash(&mut h);
    app.viewport.hover_bodies.hash(&mut h);
    app.ui.pick_bodies.hash(&mut h);
    crate::theme::is_dark().hash(&mut h);
    app.preview.replaced.hash(&mut h);
    app.origin_visible().hash(&mut h);
    app.session.visibility.hidden_origin.hash(&mut h);
    app.session.visibility.hidden_bodies.hash(&mut h);
    app.session.visibility.hidden_occurrences.hash(&mut h);
    app.cam.half_height().to_bits().hash(&mut h);
    app.cam.back().x.to_bits().hash(&mut h);
    h.finish()
}

/// The highlight scene: origin widget, construction planes, selection and hover.
fn build_highlight(app: &SolveApp) -> GpuScene {
    let t = Tokens::get();
    let mut sc = GpuScene::default();
    let st = app.session.world_state();
    let mut sel = Vec::new();
    for item in app.highlighted() {
        for piece in displayed_selection(app, &item) {
            if !sel.iter().any(|x| crate::selection::same_item(x, &piece)) {
                sel.push(piece);
            }
        }
    }
    let hover = app.viewport.hover.as_ref();
    let size = origin_size(app.cam.half_height());
    // Origin planes and construction planes.
    let plane_state = |name: &str| {
        let selected = sel.iter().any(|x| matches!(x, Sel::Plane { name: n } if n == name));
        let hovered = matches!(hover, Some(Hit::Plane { name: n, .. }) if n == name);
        (selected, hovered)
    };
    let mut planes: Vec<(String, [Vec3; 4], Color32)> = origin_planes(app).into_iter().map(|(n, _, q)| (n.to_string(), q, t.origin_plane)).collect();
    planes.extend(construction_quads(app).into_iter().map(|(n, _, q)| (n, q, t.construction_plane)));
    for (name, q, base) in &planes {
        let (selected, hovered) = plane_state(name);
        let fill = if hovered {
            t.origin_plane_hover
        } else if selected {
            Color32::from_rgba_unmultiplied(t.sel_face.r(), t.sel_face.g(), t.sel_face.b(), 150)
        } else {
            *base
        };
        quad(&mut sc, q, fill, if selected { t.sel_edge } else { t.origin_plane_edge });
    }
    // Origin axes: solid near the origin, dashed beyond.
    for (name, dir) in origin_axes(app) {
        let col = match name {
            "X" => t.axis_x,
            "Y" => t.axis_y,
            _ => t.axis_z,
        };
        let on = sel.iter().any(|x| matches!(x, Sel::Axis { name: n } if n == name)) || matches!(hover, Some(Hit::Axis { name: n }) if n == name);
        let w = if on { 4.0 } else { 2.0 };
        sc.line([0.0; 3], (dir * size).to_f32(), c4(col), w, false);
        let dash = size * 0.08;
        let mut a = size + dash;
        while a < size * AXIS_LEN {
            sc.line((dir * a).to_f32(), (dir * (a + dash)).to_f32(), c4(col), w * 0.75, false);
            a += dash * 2.0;
        }
    }
    // Construction axes (dashed, the length of the origin axes either side) and points (a
    // small star), in the construction colour.
    for (name, a, b) in construction_axis_segments(app) {
        let on = sel.iter().any(|x| matches!(x, Sel::Axis { name: n } if *n == name)) || matches!(hover, Some(Hit::Axis { name: n }) if *n == name);
        let col = c4(if on { t.sel_edge } else { t.construction_geom });
        let w = if on { 3.0 } else { 1.6 };
        let len = a.dist(b);
        let dash = size * 0.08;
        let mut s = 0.0;
        while s < len {
            let e = (s + dash).min(len);
            sc.line(a.lerp(b, s / len).to_f32(), a.lerp(b, e / len).to_f32(), col, w, false);
            s += dash * 1.6;
        }
    }
    for (_, p) in construction_points(app) {
        let r = size * 0.04;
        for d in [Vec3::X, Vec3::Y, Vec3::Z] {
            sc.line((p - d * r).to_f32(), (p + d * r).to_f32(), c4(t.construction_geom), 2.0, true);
        }
    }
    // Selected things.
    for x in &sel {
        match x {
            Sel::Face { body, index, .. } => {
                // A live preview stands in for the body: its old faces would fight with it.
                if let Some(b) = st.body(body).filter(|_| app.session.body_visible(body) && !app.preview.replaced.contains(body)) {
                    face_tris(&mut sc, &b.mesh(), *index, c4(t.sel_face), false);
                    hidden_face_outline(&mut sc, &b.mesh(), *index, t.sel_edge);
                }
            }
            Sel::Body { name } => {
                if let Some(b) = st.body(name)
                    && app.session.body_visible(name)
                {
                    let m = b.mesh();
                    for f in 0..b.body.face_count() {
                        face_tris(&mut sc, &m, f, c4(t.body_selected), true);
                    }
                }
            }
            Sel::Edge { body, index, point } => {
                if let Some(b) = st.body(body)
                    && app.session.body_visible(body)
                    && let Some(e) = edge_of(&b.mesh(), *index, *point)
                {
                    edge_lines(&mut sc, e, t.sel_edge, t.sel_edge_rim, 3.0);
                }
            }
            Sel::Profile { sketch, index } => profile_fill(&mut sc, app, *sketch, *index, t.sel_profile, t.sel_profile_edge),
            // A 3D sketch curve, in whichever sketch has it.
            Sel::SketchCurve { id } if st.sketches.iter().any(|ss| ss.sketch.wire_index(id).is_some()) => {
                for ss in st.sketches.iter() {
                    if let Some(w) = ss.sketch.wire_index(id).and_then(|i| ss.sketch.wires.get(i)) {
                        for q in w.pts.windows(2) {
                            sc.line(q[0].to_f32(), q[1].to_f32(), c4(t.sel_edge), 3.5, true);
                        }
                    }
                }
            }
            Sel::SketchCurve { id } => {
                if let Some(ss) = app.session.active_sketch.and_then(|sid| st.sketch(sid))
                    && let Some(ci) = ss.sketch.curve_index(id)
                {
                    for seg in ss.sketch.segs(ci) {
                        let pts = seg.polyline(0.02);
                        for w in pts.windows(2) {
                            sc.line(ss.plane.to_world(w[0]).to_f32(), ss.plane.to_world(w[1]).to_f32(), c4(t.sel_edge), 3.5, true);
                        }
                    }
                }
            }
            _ => {}
        }
    }
    // Timeline modifiers light only their resulting faces; browser rows light whole bodies.
    let mut hovered = app.viewport.hover_feature.map(|id| feature_geometry(app, id)).unwrap_or_default();
    hovered.extend(app.viewport.hover_bodies.iter().map(|name| Sel::Body { name: name.clone() }));
    for b in st.bodies.iter().filter(|b| app.session.body_visible(&b.name) && !app.preview.replaced.contains(&b.name)) {
        let whole = hovered.iter().any(|x| matches!(x, Sel::Body { name } if name == &b.name));
        let faces: Vec<_> = if whole {
            (0..b.body.face_count()).collect()
        } else {
            hovered
                .iter()
                .filter_map(|x| match x {
                    Sel::Face { body, index, .. } if body == &b.name => Some(*index),
                    _ => None,
                })
                .collect()
        };
        if faces.is_empty() {
            continue;
        }
        let k = t.hover_face_lift;
        let c = body_rgb(app, &b.name);
        let m = b.mesh();
        for &f in &faces {
            if !sel.iter().any(|x| {
                matches!(x, Sel::Face { body, index, .. } if body == &b.name && *index == f) || matches!(x, Sel::Body { name } if name == &b.name)
            }) {
                face_tris(&mut sc, &m, f, [c.0.saturating_add(k), c.1.saturating_add(k), c.2.saturating_add(k), 255], true);
            }
        }
        for (ei, e) in m.edges.iter().enumerate() {
            if !m.seams.get(ei).copied().unwrap_or(false)
                && (whole || m.edge_faces.get(ei).is_some_and(|fs| fs.iter().any(|f| faces.contains(&(*f as usize)))))
            {
                edge_lines(&mut sc, e, t.hover_edge, t.hover_edge_halo, 1.5);
            }
        }
    }
    // Hover (pre-highlight).
    match hover {
        // Body selection: the whole body lights up.
        Some(Hit::Face { body, .. }) if app.ui.pick_bodies && app.dialog.is_none() && app.tool.is_none() => {
            if let Some(b) = st.body(body) {
                let k = t.hover_face_lift;
                let c = body_rgb(app, body);
                let m = b.mesh();
                for f in 0..b.body.face_count() {
                    face_tris(&mut sc, &m, f, [c.0.saturating_add(k), c.1.saturating_add(k), c.2.saturating_add(k), 255], true);
                }
            }
        }
        Some(Hit::Face { body, index, .. })
            if !app.preview.replaced.contains(body)
                && !sel.iter().any(|x| matches!(x, Sel::Face { body: b, index: i, .. } if b == body && i == index)) =>
        {
            if let Some(b) = st.body(body) {
                let k = t.hover_face_lift;
                let c = body_rgb(app, body);
                let m = b.mesh();
                let patch = m.surface_patch(*index);
                for &f in &patch {
                    face_tris(&mut sc, &m, f, [c.0.saturating_add(k), c.1.saturating_add(k), c.2.saturating_add(k), 255], true);
                }
                for (e, _) in m.edge_faces.iter().enumerate().filter(|(_, fs)| fs.iter().any(|f| patch.contains(&(*f as usize)))) {
                    if let Some(p) = m.edges.get(e)
                        && !m.seams.get(e).copied().unwrap_or(false)
                    {
                        edge_lines(&mut sc, p, t.hover_edge, t.hover_edge_halo, 1.5);
                    }
                }
            }
        }
        Some(Hit::Edge { body, index, mid }) => {
            if let Some(b) = st.body(body) {
                let m = b.mesh();
                for i in m.circular_rim(*index) {
                    let selected = sel.iter().any(|x| matches!(x, Sel::Edge { body: b, index: j, .. } if b == body && *j == i));
                    if !selected && let Some(e) = if i == *index { edge_of(&m, i, *mid) } else { m.edges.get(i) } {
                        edge_lines(&mut sc, e, t.hover_edge, t.hover_edge_halo, 2.0);
                    }
                }
            }
        }
        Some(Hit::Profile { sketch, index })
            if !sel.iter().any(|x| matches!(x, Sel::Profile { sketch: s2, index: i2 } if s2 == sketch && i2 == index)) =>
        {
            profile_fill(&mut sc, app, *sketch, *index, t.hover_profile, t.hover_profile_edge);
        }
        _ => {}
    }
    sc
}

/// A body's display colour (appearance, material or imported colour), if it has one.
fn body_color(doc: &solvecraft_engine::doc::Document, b: &solvecraft_engine::doc::ModelBody) -> Option<Color32> {
    let to8 = |x: f32| (x.clamp(0.0, 1.0) * 255.0).round() as u8;
    doc.body_color(b).map(|[r, g, b]| Color32::from_rgb(to8(r), to8(g), to8(b)))
}

/// A body's display colour (else the theme's) as RGB.
fn body_rgb(app: &SolveApp, name: &str) -> (u8, u8, u8) {
    let st = app.session.world_state();
    let c = st.body(name).and_then(|b| body_color(&app.session.doc, b)).unwrap_or(Tokens::get().body);
    (c.r(), c.g(), c.b())
}

pub(crate) fn polyline_mid(pts: &[Vec3]) -> Vec3 {
    let len: f64 = pts.windows(2).map(|w| w[0].dist(w[1])).sum();
    let mut acc = 0.0;
    for w in pts.windows(2) {
        let l = w[0].dist(w[1]);
        if acc + l >= len * 0.5 && l > 0.0 {
            return w[0].lerp(w[1], (len * 0.5 - acc) / l);
        }
        acc += l;
    }
    pts.first().copied().unwrap_or_default()
}

fn seg_dist(p: Pos2, a: Pos2, b: Pos2) -> f32 {
    let ab = b - a;
    let l2 = ab.length_sq();
    let t = if l2 > 0.0 { ((p - a).dot(ab) / l2).clamp(0.0, 1.0) } else { 0.0 };
    p.distance(a + ab * t)
}

/// Point on the active sketch plane under the cursor (sketch coordinates), snapped to sketch
/// points within a few pixels and otherwise to a fine grid. Returns the snapped point and the
/// id of the sketch point it snapped to.
pub fn sketch_point_at(app: &SolveApp, proj: &Proj, pos: Pos2) -> Option<(Vec2, Option<String>)> {
    let sid = app.session.active_sketch?;
    let st = app.session.world_state();
    let ss = st.sketch(sid)?;
    for h in pick(app, proj, pos) {
        if let Hit::SketchPoint { id, at, .. } = h {
            return Some((at, Some(id)));
        }
    }
    let (o, d) = proj.ray(pos);
    let w = ss.plane.intersect_ray(o, d)?;
    let lp = ss.plane.to_local(w);
    if crate::drag_snap::suppressed() {
        return Some((lp, None));
    }
    let (minor, _) = grid_step(app.cam.half_height());
    let step = minor / 10.0;
    if let Some(p) = crate::sketch_tools::refine_snap(app, proj, &ss.sketch, &ss.plane, lp) {
        return Some(p);
    }
    // With Snap off (Sketch Palette) the point is where the cursor is.
    if ss.sketch.view.no_snap {
        return Some((lp, None));
    }
    Some((Vec2::new((lp.x / step).round() * step, (lp.y / step).round() * step), None))
}

pub fn delete_selection(app: &mut SolveApp) {
    crate::delete::delete_selection(app);
}

pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
    let t = Tokens::get();
    let rect = ui.max_rect();
    app.viewport.rect = Some(rect);
    let resp = ui.interact(rect, ui.id().with("viewport"), Sense::click_and_drag());
    let (hover, scroll, mods, middle, secondary_down, primary_down, delta) = ui.input(|i| {
        (
            i.pointer.hover_pos(),
            i.smooth_scroll_delta.y,
            i.modifiers,
            i.pointer.middle_down(),
            i.pointer.secondary_down(),
            i.pointer.primary_down(),
            i.pointer.delta(),
        )
    });
    // The right button belongs to the marking menu while it is open.
    let secondary_down = secondary_down && app.viewport.context_menu.is_none();
    // The view cube handles its own clicks; the model underneath must not see them.
    let cube = Rect::from_center_size(pos2(rect.right() - 80.0, rect.top() + 80.0), vec2(150.0, 150.0));
    // Floating windows and menus own input over the model, including wheel navigation.
    let inside = resp.contains_pointer() && hover.is_some_and(|p| !cube.contains(p));
    app.viewport.mouse = hover.filter(|_| inside);
    // Ctrl or Alt held: drawing and dragging don't snap.
    crate::drag_snap::set_suppressed(mods.ctrl || mods.alt || mods.command);

    // ---- navigation ----
    let h = rect.height().max(1.0) as f64;
    if inside && scroll != 0.0 {
        let f = (-scroll as f64 * 0.0015 * crate::prefs::zoom_sign(app)).exp();
        // Preferences › Navigation › Zoom to the cursor (off: toward the view's centre).
        let anchor = hover.filter(|_| app.preferences.zoom_to_cursor).map(|p| {
            let proj = projection(app, rect);
            // Toward the model's surface under the cursor, else the target's depth.
            if let Some(q) = pick_cached(app, &proj, p).iter().find_map(|h| if let Hit::Face { point, .. } = h { Some(*point) } else { None }) {
                return q;
            }
            let (o, d) = proj.ray(p);
            let n = app.cam.back();
            let den = d.dot(n);
            if den.abs() > 1e-9 { o + d * ((app.cam.target - o).dot(n) / den) } else { app.cam.target }
        });
        app.cancel_view_animation();
        app.cam.zoom_at(f, anchor);
    }
    let dragging = resp.dragged() || (inside && (middle || secondary_down));
    if dragging && delta != egui::Vec2::ZERO {
        let (dx, dy) = (delta.x as f64, delta.y as f64);
        let mode = if middle || secondary_down {
            crate::prefs::nav_mode(app, middle, secondary_down, mods)
        } else if primary_down && app.viewport.cube_drag.is_none() {
            app.viewport.nav
        } else {
            None
        };
        if mode.is_some() {
            app.cancel_view_animation();
        }
        match mode {
            Some(NavMode::Orbit) => {
                let press = ui.input(|i| i.pointer.press_origin());
                crate::prefs::orbit(app, rect, dx, dy, press);
            }
            Some(NavMode::Pan) => app.cam.pan(dx, dy, h),
            Some(NavMode::Zoom) => app.cam.zoom_at((dy * 0.01).exp(), None),
            None => {}
        }
    }
    if !dragging {
        app.viewport.orbit_pivot = None;
    }
    if app.viewport.spin {
        // A click on the navigation bar (its own button) is not a stop.
        let bar = Rect::from_center_size(pos2(rect.center().x, rect.bottom() - 22.0), vec2(320.0, 30.0));
        let (pressed, key, dt) = ui.input(|i| {
            (
                i.pointer.any_pressed() && inside && !i.pointer.press_origin().is_some_and(|p| bar.contains(p)),
                i.events.iter().any(|e| matches!(e, egui::Event::Key { pressed: true, .. })),
                i.stable_dt,
            )
        });
        if pressed || key || dragging {
            app.viewport.spin = false;
        } else {
            app.cam.orbit(f64::from(dt.min(0.1)) * 30.0, 0.0);
            ui.ctx().request_repaint();
        }
    }
    if !app.cam.is_valid() {
        app.cam = Camera::default();
        app.fit_view();
    }

    let proj = projection(app, rect);
    // Suppress hover for the whole navigation gesture, including frames between pointer
    // events. Testing delta made the highlight reappear whenever a held drag paused.
    // Resolve it before rendering so the GPU scene and screen overlays use the same hit.
    let navigating = scroll != 0.0
        || middle
        || secondary_down
        || (app.viewport.nav.is_some() && primary_down)
        || app.viewport.cube_drag.is_some()
        || app.viewport.spin
        || app.cam_anim.is_some();
    let hits = hover.filter(|_| inside && app.viewport.boxsel.is_none() && !navigating).map(|p| pick_cached(app, &proj, p)).unwrap_or_default();
    let cand = if app.tool.is_some() { hits.first().cloned().map(|h| (h, None)) } else { candidate(app, &hits).map(|(h, s)| (h, Some(s))) };
    app.viewport.hover = cand.as_ref().map(|c| c.0.clone());
    let painter = ui.painter_at(rect);
    // Background gradient.
    let (top, bot) = (t.viewport_top, t.viewport_bottom);
    let mut mesh = egui::Mesh::default();
    mesh.colored_vertex(rect.left_top(), top);
    mesh.colored_vertex(rect.right_top(), top);
    mesh.colored_vertex(rect.right_bottom(), bot);
    mesh.colored_vertex(rect.left_bottom(), bot);
    mesh.add_triangle(0, 1, 2);
    mesh.add_triangle(0, 2, 3);
    painter.add(Shape::mesh(mesh));

    // ---- model ----
    let key = scene_key(app);
    let t0 = crate::now_ms();
    if let Some(_g) = app.viewport.gpu {
        if key != app.viewport.key {
            let sc = build_scene(app);
            if let Ok(mut slot) = app.viewport.slot.lock() {
                *slot = Some(sc);
            }
            app.viewport.key = key;
            app.viewport.build_ms = crate::now_ms() - t0;
        }
        let hk = highlight_key(app);
        if hk != app.viewport.hl_key {
            let hl = build_highlight(app);
            if let Ok(mut slot) = app.viewport.hl_slot.lock() {
                *slot = Some(hl);
            }
            app.viewport.hl_key = hk;
        }
        let ppp = ui.ctx().pixels_per_point();
        let cb = ViewportCallback {
            key: app.viewport.key,
            slot: app.viewport.slot.clone(),
            hl_key: app.viewport.hl_key,
            hl_slot: app.viewport.hl_slot.clone(),
            pv_key: app.preview.key,
            pv_slot: app.preview.slot.clone(),
            clip: section_clip(app),
            cap: t.section_cap.to_normalized_gamma_f32(),
            view_proj: proj.vp.to_f32(),
            back: proj.cam.back().to_f32(),
            size_px: [rect.width() * ppp, rect.height() * ppp],
            images: crate::ref_images::gpu_images(app),
            analysis: analysis_uniform(app),
            access: crate::access::map(app),
            outline: matches!(app.ui.visual_style, 0 | 3),
            eye: {
                let e = proj.cam.eye().to_f32();
                [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }]
            },
        };
        painter.add(egui_wgpu::Callback::new_paint_callback(rect, cb));
    } else {
        cpu_render(app, ui.ctx(), &painter, rect, &proj);
    }

    // ---- interaction ----
    let add = mods.shift || mods.command || mods.ctrl;
    if let Some(p) = hover.filter(|_| inside) {
        if app.tool.is_some() {
            crate::tools::on_hover(app, &proj, p);
        }
        if resp.clicked() {
            if app.tool.is_some() {
                crate::tools::on_click(app, &proj, p);
            } else if app.dialog.as_ref().is_some_and(|d| d.wants_picks()) {
                if let Some(sel) = cand.and_then(|c| c.1)
                    && let Some(mut d) = app.dialog.take()
                {
                    d.pick(&app.session, sel);
                    app.dialog = Some(d);
                }
            } else {
                // Dimensions and constraint glyphs sit on top of the geometry.
                let off = |k: &str| app.ui.pick_off.iter().any(|x| x == k);
                let sketching = app.session.active_sketch.is_some();
                // A dimension's text wins; its lines only where no sketch point or curve is (a
                // diameter's line runs through the centre point).
                let on_geometry = matches!(cand.as_ref().map(|c| &c.0), Some(Hit::SketchPoint { .. } | Hit::SketchCurve { .. }));
                let on_dim = crate::dim_view::hit_text(p)
                    .or_else(|| if on_geometry { None } else { crate::dim_view::hit(p) })
                    .filter(|_| sketching && !off("dimensions"));
                let on_glyph = crate::sketch_tools::glyph_at(p).filter(|_| sketching && !off("constraints"));
                if !crate::sketch3d::click(app, &proj, p) {
                    match on_dim.or(on_glyph) {
                        Some(id) => select(app, Some(Sel::SketchConstraint { id }), add),
                        None => select(app, cand.and_then(|c| c.1), add),
                    }
                }
            }
        }
        // Double-click a dimension: edit its value in place.
        let dim_edit = resp.double_clicked() && app.tool.is_none() && app.dialog.is_none() && crate::dim_view::double_click(app, p);
        // Double-click a sketch curve: select the chain joined to it end to end.
        if resp.double_clicked()
            && !dim_edit
            && app.tool.is_none()
            && app.dialog.is_none()
            && let Some(Hit::SketchCurve { sketch, id, .. }) = app.viewport.hover.clone()
            && app.session.active_sketch == Some(sketch)
            && let Ok(v) = app.session.execute("sketch.chain", &json!({ "curve": id }))
        {
            let items: Vec<Sel> =
                v["curves"].as_array().into_iter().flatten().filter_map(|c| c.as_str()).map(|id| Sel::SketchCurve { id: id.into() }).collect();
            let _ = app.run("select.set", json!({ "items": items, "add": add }));
        }
        // Double-click an edge: select the edges that continue it smoothly (the loop).
        if resp.double_clicked()
            && !dim_edit
            && app.tool.is_none()
            && app.dialog.is_none()
            && let Some(Hit::Edge { body, index, .. }) = app.viewport.hover.clone()
            && let Some(b) = app.session.world_state().body(&body).cloned()
        {
            let m = b.mesh();
            let items: Vec<Sel> = m
                .tangent_chain(index, 2f64.to_radians())
                .into_iter()
                .filter_map(|i| m.edges.get(i).map(|e| Sel::Edge { body: body.clone(), index: i, point: polyline_mid(e) }))
                .collect();
            let _ = app.run("select.set", json!({ "items": items, "add": add }));
        }
        if resp.secondary_clicked() && delta == egui::Vec2::ZERO {
            if app.tool.is_some() {
                crate::tools::finish(app);
            } else if app.dialog.is_none() {
                crate::context_menu::open(app, p);
            }
        }
    }
    // Dragging a sketch point of the active sketch moves it; the solver keeps the constraints.
    if app.tool.is_none() && app.dialog.is_none() && app.viewport.nav.is_none() && app.session.active_sketch.is_some() {
        let on_plane = |app: &SolveApp, p: Pos2| {
            let ss = app.session.active_sketch.and_then(|sid| app.session.world_state().sketch(sid).cloned())?;
            let (o, d) = proj.ray(p);
            ss.plane.intersect_ray(o, d).map(|w| ss.plane.to_local(w))
        };
        // The 3D triad, then a dimension's text, follow a drag that starts on them.
        if resp.drag_started_by(egui::PointerButton::Primary)
            && let Some(a) = ui.input(|i| i.pointer.press_origin())
            && !crate::sketch3d::drag_start(app, &proj, a)
            && let Some(q) = on_plane(app, a)
        {
            crate::dim_view::drag_start(app, a, q);
        }
        if crate::sketch3d::dragging()
            && (resp.dragged_by(egui::PointerButton::Primary) || resp.drag_stopped())
            && let Some(p) = hover
        {
            crate::sketch3d::drag_to(app, &proj, p);
        }
        if crate::dim_view::dragging()
            && (resp.dragged_by(egui::PointerButton::Primary) || resp.drag_stopped())
            && let Some(q) = hover.and_then(|p| on_plane(app, p))
        {
            crate::dim_view::drag_to(app, q);
        }
        // A point or a curve of the sketch being edited follows a drag that starts on it.
        if resp.drag_started_by(egui::PointerButton::Primary)
            && !crate::dim_view::dragging()
            && !crate::sketch3d::dragging()
            && let Some(a) = ui.input(|i| i.pointer.press_origin())
        {
            let active = app.session.active_sketch;
            match pick(app, &proj, a).into_iter().next() {
                Some(Hit::SketchPoint { id, .. }) => app.viewport.point_drag = Some((id, app.session.undo.len(), None)),
                Some(Hit::SketchCurve { sketch, id, .. }) if Some(sketch) == active => {
                    app.viewport.point_drag = on_plane(app, a).map(|q| (id, app.session.undo.len(), Some(q)));
                }
                _ => {}
            }
        }
        if let Some((id, depth, grab)) = app.viewport.point_drag.clone()
            && resp.dragged_by(egui::PointerButton::Primary)
            && let Some(mut q) = hover.and_then(|p| on_plane(app, p))
        {
            let from = grab.unwrap_or(q);
            // Snap the dragged point (or the line's ends) to other geometry, like drawing.
            let snap = {
                let st = app.session.world_state();
                app.session.active_sketch.and_then(|s| st.sketch(s)).and_then(|ss| {
                    let sk = &ss.sketch;
                    let (own, exclude) = crate::drag_snap::moving_points(sk, &id);
                    if own.iter().any(|&p| sk.point_locked(p)) {
                        return crate::drag_snap::find(sk, &[], &[], 0.0);
                    }
                    let a = proj.to_screen(ss.plane.to_world(q))?;
                    let b = proj.to_screen(ss.plane.to_world(q + Vec2::X))?;
                    let mm_px = 1.0 / (a.distance(b) as f64).max(1e-9);
                    let d = q - from;
                    let moving: Vec<(usize, Vec2)> =
                        own.iter().filter_map(|&p| if grab.is_some() { sk.point(p).map(|x| (p, x + d)) } else { Some((p, q)) }).collect();
                    crate::drag_snap::find(sk, &moving, &exclude, mm_px)
                })
            };
            if let Some(s) = snap {
                q += s.offset;
            }
            if app.session.execute("sketch.drag", &json!({"entity": id, "from": [from.x, from.y], "to": [q.x, q.y]})).is_ok() {
                app.session.undo.truncate(depth + 1);
            }
            if grab.is_some() {
                app.viewport.point_drag = Some((id, depth, Some(q)));
            }
        }
        if resp.drag_stopped() {
            if let Some((_, depth, _)) = app.viewport.point_drag.clone() {
                // Let go on a point, midpoint or curve: the matching constraint, in the drag's undo step.
                crate::drag_snap::release(app);
                app.session.undo.truncate(depth + 1);
            }
            crate::drag_snap::clear();
            app.viewport.point_drag = None;
            crate::dim_view::drag_end();
            crate::sketch3d::drag_end();
        }
    }
    // Box selection: a primary drag on the model when no navigation mode is on.
    if app.tool.is_none()
        && app.viewport.nav.is_none()
        && app.viewport.point_drag.is_none()
        && !crate::dim_view::dragging()
        && !crate::sketch3d::dragging()
    {
        let origin = ui.input(|i| i.pointer.press_origin());
        if resp.dragged_by(egui::PointerButton::Primary)
            && let (Some(a), Some(b)) = (origin, hover)
            && rect.contains(a)
            && !cube.contains(a)
        {
            app.viewport.boxsel = Some(BoxSel::from_drag(a, b));
        }
        if resp.drag_stopped()
            && let Some(bx) = app.viewport.boxsel.take()
        {
            box_select(app, &proj, bx, add);
        }
    } else {
        app.viewport.boxsel = None;
    }
    crate::ref_images::show(app, ui, &painter, &proj);
    crate::dialogs_assembly::origins(app, &painter, &proj);
    overlays(app, &painter, &proj);
    crate::dim_view::show(app, ui, &painter, &proj);
    crate::sketch3d::show(app, &painter, &proj);
    crate::inference::show(app, &painter, &proj);
    crate::drag_snap::show(app, &painter, &proj);
    hover_highlight(app, &painter, &proj);
    points_2d(app, &painter, &proj);
    if let Some(bx) = app.viewport.boxsel {
        let col = if bx.crossing { t.box_crossing } else { t.box_window };
        painter.rect_filled(bx.rect, 0.0, col.gamma_multiply(0.12));
        if bx.crossing {
            let c = [bx.rect.left_top(), bx.rect.right_top(), bx.rect.right_bottom(), bx.rect.left_bottom()];
            for i in 0..4 {
                painter.add(Shape::dashed_line(&[c[i], c[(i + 1) % 4]], Stroke::new(1.2, col), 6.0, 4.0));
            }
        } else {
            painter.rect_stroke(bx.rect, 0.0, Stroke::new(1.2, col), egui::StrokeKind::Inside);
        }
    }
    if let Some(tl) = app.tool.as_ref() {
        crate::tools::preview(app, tl, &painter, &proj);
    }
    crate::canvas::show(app, ui, &painter, &proj);
    crate::sketch_tools::show(app, ui, &painter, &proj);
    crate::sketch_dims::show(app, ui, &proj);
    view_cube(app, ui, rect);
    nav_bar(app, ui, rect);
    // Status chip.
    if let Some((msg, at, err)) = app.status.clone() {
        if crate::now_ms() - at < 6000.0 {
            let pos = pos2(rect.left() + 12.0, rect.bottom() - 46.0);
            let galley = painter.layout_no_wrap(msg, FontId::proportional(12.5), if err { t.error } else { t.text });
            let r = Rect::from_min_size(pos, galley.size() + vec2(16.0, 8.0));
            painter.rect_filled(r, 4.0, t.overlay);
            painter.galley(pos + vec2(8.0, 4.0), galley, t.text);
            ui.ctx().request_repaint_after(std::time::Duration::from_millis(500));
        } else {
            app.status = None;
        }
    }
}

/// A click without a command: select the candidate (replacing the selection, or toggling it
/// in with Shift/Ctrl); a click on nothing clears.
fn select(app: &mut SolveApp, sel: Option<Sel>, add: bool) {
    match sel {
        Some(x) => {
            let items = grouped_selection(&app.session, &x);
            if add && items.iter().all(|x| app.session.selection.iter().any(|y| crate::selection::same_item(x, y))) {
                let rest: Vec<Sel> =
                    app.session.selection.iter().filter(|y| !items.iter().any(|x| crate::selection::same_item(x, y))).cloned().collect();
                let _ = app.run("select.set", json!({ "items": rest }));
            } else {
                let _ = app.run("select.set", json!({"items": items, "add": add}));
            }
        }
        None if !add => {
            let _ = app.run("select.clear", json!({}));
        }
        None => {}
    }
}

/// Expand a visible rim or surface into the kernel pieces a command needs. The original
/// face pick keeps its point (used by tools such as Hole and construction geometry).
pub(crate) fn grouped_selection(s: &solvecraft_engine::Session, sel: &Sel) -> Vec<Sel> {
    let st = s.world_state();
    match sel {
        Sel::Edge { body, index, .. } => {
            if let Some(b) = st.body(body) {
                let m = b.mesh();
                return m
                    .circular_rim(*index)
                    .into_iter()
                    .filter_map(|i| m.edges.get(i).map(|e| Sel::Edge { body: body.clone(), index: i, point: polyline_mid(e) }))
                    .collect();
            }
        }
        Sel::Face { body, index, .. } => {
            if let Some(b) = st.body(body) {
                let m = b.mesh();
                let mut patch = m.surface_patch(*index);
                patch.sort_by_key(|i| usize::from(i != index));
                return patch
                    .into_iter()
                    .filter_map(|i| {
                        if i == *index {
                            return Some(sel.clone());
                        }
                        m.triangles.iter().zip(&m.tri_face).find_map(|(t, f)| {
                            if *f as usize != i {
                                return None;
                            }
                            let [a, b, c] = m.tri(t)?;
                            Some(Sel::Face { body: body.clone(), index: i, point: (a + b + c) / 3.0 })
                        })
                    })
                    .collect();
            }
        }
        _ => {}
    }
    vec![sel.clone()]
}

/// Measure keeps one entry per visible item, rather than using its two slots for kernel halves.
pub(crate) fn measurement_selection(s: &solvecraft_engine::Session, sel: &Sel) -> Sel {
    let pieces = grouped_selection(s, sel);
    let mut representative = sel.clone();
    match &mut representative {
        Sel::Edge { index, .. } => {
            if let Some(Sel::Edge { index: i, .. }) = pieces.first() {
                *index = *i;
            }
        }
        Sel::Face { index, .. } => {
            if let Some(i) = pieces
                .iter()
                .filter_map(|p| match p {
                    Sel::Face { index, .. } => Some(*index),
                    _ => None,
                })
                .min()
            {
                *index = i;
            }
        }
        _ => {}
    }
    representative
}

/// What a box selects: sketch entities while sketching, otherwise what the open dialog's
/// active input takes (edges, faces or bodies), otherwise bodies.
fn box_select(app: &mut SolveApp, proj: &Proj, bx: BoxSel, add: bool) {
    use crate::selection::{BODIES, EDGES, FACES, PROFILES};
    let st = app.session.world_state();
    let mut out: Vec<Sel> = Vec::new();
    let to2 = |pts: &[Vec3]| -> Vec<Pos2> { pts.iter().filter_map(|p| proj.to_screen(*p)).collect() };
    if app.dialog.is_none()
        && let Some(ss) = app.session.active_sketch.and_then(|sid| st.sketch(sid))
    {
        // What the selection filter lets through (window: wholly inside; crossing: touching).
        let off = |k: &str| app.ui.pick_off.iter().any(|x| x == k);
        for (i, c) in ss.sketch.curves.iter().enumerate().filter(|_| !off("sketch") && !off("sketch_curves")) {
            if c.link.is_some() && ss.sketch.view.hide_projected {
                continue;
            }
            let pts: Vec<Vec3> = ss.sketch.segs(i).iter().flat_map(|sg| sg.polyline(0.05)).map(|q| ss.plane.to_world(q)).collect();
            if bx.takes(&to2(&pts)) {
                out.push(Sel::SketchCurve { id: c.id.clone() });
            }
        }
        for (i, p) in ss.sketch.points.iter().enumerate().filter(|_| !off("sketch") && !off("sketch_points")) {
            if i != 0 && solvecraft_engine::view::sketch_point_visible(&ss.sketch, i) && bx.takes(&to2(&[ss.plane.to_world(p.pos)])) {
                out.push(Sel::SketchPoint { id: p.id.clone() });
            }
        }
        if !off("dimensions") {
            for (id, r) in crate::dim_view::text_rects() {
                if bx.takes(&[r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom()]) {
                    out.push(Sel::SketchConstraint { id });
                }
            }
        }
        if !off("constraints") {
            for (id, c) in crate::sketch_tools::glyph_positions() {
                if bx.takes(&[c]) {
                    out.push(Sel::SketchConstraint { id });
                }
            }
        }
    } else {
        let accept = app.dialog.as_ref().and_then(|d| d.active_input()).map(|i| i.accept).unwrap_or(BODIES);
        for b in &st.bodies {
            if !app.session.body_visible(&b.name) {
                continue;
            }
            let m = b.mesh();
            if accept & EDGES != 0 {
                for (ei, e) in m.edges.iter().enumerate() {
                    let rim = m.circular_rim(ei);
                    let takes = if bx.crossing { bx.takes(&to2(e)) } else { rim.iter().all(|&i| m.edges.get(i).is_some_and(|p| bx.takes(&to2(p)))) };
                    if !m.seams.get(ei).copied().unwrap_or(false) && takes {
                        out.push(Sel::Edge { body: b.name.clone(), index: ei, point: polyline_mid(e) });
                    }
                }
            } else if accept & FACES != 0 {
                for f in 0..b.body.face_count() {
                    let mut pts: Vec<Vec3> = Vec::new();
                    for e in m.face_edges(u32::try_from(f).unwrap_or(u32::MAX)) {
                        pts.extend(m.edges.get(e).into_iter().flatten().copied());
                    }
                    let point = m
                        .triangles
                        .iter()
                        .zip(&m.tri_face)
                        .find(|(_, tf)| **tf as usize == f)
                        .and_then(|(t, _)| m.tri(t))
                        .map(|[a, bb, c]| (a + bb + c) / 3.0);
                    let takes = bx.takes(&to2(&pts))
                        && (bx.crossing
                            || m.surface_patch(f).iter().all(|&face| {
                                m.face_edges(u32::try_from(face).unwrap_or(u32::MAX))
                                    .iter()
                                    .all(|&e| m.edges.get(e).is_some_and(|p| bx.takes(&to2(p))))
                            }));
                    if let Some(point) = point
                        && takes
                    {
                        out.push(Sel::Face { body: b.name.clone(), index: f, point });
                    }
                }
            } else if accept & BODIES != 0 {
                let crossing_hit = m.edges.iter().any(|e| bx.takes(&to2(e)));
                let all_in = m.edges.iter().all(|e| bx.takes(&to2(e)));
                if (bx.crossing && crossing_hit) || (!bx.crossing && all_in && !m.edges.is_empty()) {
                    out.push(Sel::Body { name: b.name.clone() });
                }
            } else if accept & PROFILES != 0 {
                for sid in visible_sketches(app) {
                    let Some(ss) = st.sketch(sid) else { continue };
                    for (pi, p) in ss.profiles.iter().enumerate() {
                        let pts: Vec<Vec3> = p.region.outer.polyline(0.05).into_iter().map(|q| ss.plane.to_world(q)).collect();
                        if bx.takes(&to2(&pts)) {
                            out.push(Sel::Profile { sketch: sid, index: pi });
                        }
                    }
                }
                break;
            }
        }
    }
    let mut grouped = Vec::new();
    for item in out {
        for piece in grouped_selection(&app.session, &item) {
            if !grouped.iter().any(|x| crate::selection::same_item(x, &piece)) {
                grouped.push(piece);
            }
        }
    }
    let out = grouped;
    if let Some(mut d) = app.dialog.take() {
        d.take_box(&app.session, out, add);
        app.dialog = Some(d);
        return;
    }
    let items = serde_json::to_value(&out).unwrap_or_default();
    let _ = app.run("select.set", json!({"items": items, "add": add}));
}

/// Screen-space dots: the origin point, and hovered or selected body vertices.
fn points_2d(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {
    let t = Tokens::get();
    if app.origin_visible()
        && !app.session.visibility.hidden_origin.iter().any(|h| h == "O")
        && let Some(o) = proj.to_screen(Vec3::ZERO)
    {
        painter.circle(o, 4.5, t.origin_point, Stroke::new(1.0, Color32::from_gray(110)));
    }
    for x in app.highlighted() {
        if let Sel::Vertex { point, .. } = x
            && let Some(p) = proj.to_screen(point)
        {
            painter.circle(p, 4.0, t.sel_vertex, Stroke::new(1.5, t.sel_edge));
        }
    }
    if let Some(Hit::Vertex { point, .. }) = &app.viewport.hover
        && let Some(p) = proj.to_screen(*point)
    {
        painter.circle(p, 4.5, t.hover_edge_halo, Stroke::new(1.5, t.hover_edge));
    }
}

/// Hover feedback for the active sketch's points and curves (drawn on top of everything).
fn hover_highlight(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {
    let col = Tokens::get().hover_profile_edge;
    let st = app.session.world_state();
    match &app.viewport.hover {
        Some(Hit::SketchCurve { sketch, id, .. }) => {
            if let Some(ss) = st.sketch(*sketch)
                && let Some(ci) = ss.sketch.curve_index(id)
            {
                for seg in ss.sketch.segs(ci) {
                    let pts: Vec<Pos2> = seg.polyline(0.05).iter().filter_map(|q| proj.to_screen(ss.plane.to_world(*q))).collect();
                    painter.add(Shape::line(pts, Stroke::new(3.0, col)));
                }
            }
        }
        Some(Hit::SketchPoint { sketch, at, .. }) => {
            if let Some(ss) = st.sketch(*sketch)
                && let Some(p) = proj.to_screen(ss.plane.to_world(*at))
            {
                painter.circle_stroke(p, 6.0, Stroke::new(2.0, col));
            }
        }
        _ => {}
    }
}

/// Sketch points and the status of the active sketch (constraint glyphs: `sketch_tools`).
fn overlays(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {
    let t = Tokens::get();
    let st = app.session.world_state();
    let Some(sid) = app.session.active_sketch else { return };
    let Some(ss) = st.sketch(sid) else { return };
    let sk = &ss.sketch;
    let locked = sk.locked_points();
    for (i, p) in sk.points.iter().enumerate() {
        if !solvecraft_engine::view::sketch_point_visible(sk, i) {
            continue;
        }
        let hidden = (sk.view.hide_points && i != 0) || (sk.view.hide_projected && p.link.is_some());
        let Some(sp) = proj.to_screen(ss.plane.to_world(p.pos)).filter(|_| !hidden) else { continue };
        let det = ss.report.point_determined.get(i).copied().unwrap_or(false);
        let c = if p.link.is_none() && locked.get(i).copied().unwrap_or(false) {
            t.sketch_locked
        } else if det {
            t.sketch_point
        } else {
            t.sketch_point_free
        };
        if i == 0 {
            painter.circle(sp, 3.5, Color32::from_rgb(240, 200, 60), Stroke::new(1.0, t.body_edge));
        } else {
            painter.rect_filled(Rect::from_center_size(sp, vec2(5.0, 5.0)), 0.0, c);
        }
    }
    // Sketch status.
    if let Some(r) = app.viewport.rect {
        let msg = if !ss.report.ok() {
            format!("{} — constraints conflict", ss.name)
        } else if ss.report.dof == 0 {
            format!("{} — fully constrained", ss.name)
        } else {
            format!("{} — {} degrees of freedom", ss.name, ss.report.dof)
        };
        let c = if ss.report.ok() { t.sketch_accent } else { t.error };
        painter.text(pos2(r.left() + 12.0, r.top() + 12.0), Align2::LEFT_TOP, msg, FontId::proportional(13.0), c);
    }
}

fn cpu_render(app: &mut SolveApp, ctx: &egui::Context, painter: &egui::Painter, rect: Rect, proj: &Proj) {
    if app.viewport.no_pixels {
        return;
    }
    let mut h = std::collections::hash_map::DefaultHasher::new();
    scene_key(app).hash(&mut h);
    for v in [proj.cam.yaw, proj.cam.pitch, proj.cam.distance, proj.cam.target.x, proj.cam.target.y, proj.cam.target.z] {
        v.to_bits().hash(&mut h);
    }
    (rect.width() as u32, rect.height() as u32).hash(&mut h);
    let key = h.finish();
    if app.viewport.cpu.as_ref().is_none_or(|(k, _)| *k != key) {
        let scene = solvecraft_engine::view::scene(&app.session, &proj.cam);
        let w = (rect.width() as usize).clamp(16, 4096);
        let hh = (rect.height() as usize).clamp(16, 4096);
        let c = solvecraft_engine::render::render(&scene, &proj.cam, w, hh);
        let img = egui::ColorImage::from_rgba_unmultiplied([c.w, c.h], &c.rgba);
        let tex = ctx.load_texture("sc_cpu_viewport", img, egui::TextureOptions::LINEAR);
        app.viewport.cpu = Some((key, tex));
    }
    if let Some((_, tex)) = &app.viewport.cpu {
        painter.image(tex.id(), rect, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
    }
}

/// Where a point in view-cube units (faces at ±1) is drawn.
pub(crate) fn cube_point(app: &SolveApp, rect: Rect, p: Vec3) -> Pos2 {
    let (r, u, _) = cube_basis(&app.cam);
    pos2(rect.right() - 80.0 + (p.dot(r) * CUBE_SCALE) as f32, rect.top() + 80.0 - (p.dot(u) * CUBE_SCALE) as f32)
}

/// Half a view cube face, in pixels.
const CUBE_SCALE: f64 = 32.0;

/// The view cube (top right): a cube with chamfered corners. Its 14 targets are the 6 faces
/// (orthographic views) and the 8 corner facets (iso views); the edges between them are not
/// targets. Hover lights the face or facet under the pointer, a click turns the view to it, the
/// house goes home.
/// The camera's basis in its up-axis frame (Z up): the cube's TOP is the world's up, X, Y or Z.
fn cube_basis(cam: &Camera) -> (Vec3, Vec3, Vec3) {
    let (r, u, b) = cam.basis();
    (cam.to_frame(r), cam.to_frame(u), cam.to_frame(b))
}

/// Dragging a primary press on the cube orbits about the view centre. A stationary press
/// remains a click; a floating window over the cube owns its input.
fn view_cube_orbit(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect, targets: &[CubeTarget], c: Pos2) -> bool {
    let (pressed, down, decided, origin, pos) = ui.input(|i| {
        let p = &i.pointer;
        (p.primary_pressed(), p.primary_down(), p.is_decidedly_dragging(), p.press_origin(), p.interact_pos())
    });
    if pressed && ui.rect_contains_pointer(rect) {
        let shapes = cube_projected(targets, cube_basis(&app.cam), c);
        app.viewport.cube_drag = origin.filter(|p| cube_hit(&shapes, *p).is_some());
    }
    if !down {
        app.viewport.cube_drag = None;
    }
    let Some(last) = app.viewport.cube_drag.filter(|_| decided) else { return false };
    ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
    // Include the movement that crossed the drag threshold, so the orbit follows the pointer.
    if let Some(p) = pos
        && p != last
    {
        app.cancel_view_animation();
        app.cam.orbit(f64::from(p.x - last.x), f64::from(p.y - last.y));
        app.viewport.cube_drag = Some(p);
        ui.ctx().request_repaint();
    }
    true
}

fn view_cube(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) {
    let t = Tokens::get();
    let c = pos2(rect.right() - 80.0, rect.top() + 80.0);
    let targets = cube_targets();
    let orbiting = view_cube_orbit(app, ui, rect, &targets, c);
    let (r, u, b) = cube_basis(&app.cam);
    let (wr, wu, _) = app.cam.basis();
    let painter = ui.painter_at(rect);
    let hover = ui.input(|i| i.pointer.hover_pos()).filter(|_| ui.rect_contains_pointer(rect));
    let shapes = cube_projected(&targets, (r, u, b), c);
    let hovered = if orbiting { None } else { hover.and_then(|h| cube_hit(&shapes, h)) };
    // Axis triad from the cube's back corner, drawn first: the cube hides what is behind it.
    // The corner is in the cube's frame, the axes are the world's.
    let o = Vec3::new(-1.0, -1.0, -1.0);
    let at = pos2(c.x + (o.dot(r) * CUBE_SCALE) as f32, c.y - (o.dot(u) * CUBE_SCALE) as f32);
    for (d, col) in [(Vec3::X, colors::AXIS_X), (Vec3::Y, colors::AXIS_Y), (Vec3::Z, colors::AXIS_Z)] {
        let tip = at + vec2((d.dot(wr) * CUBE_SCALE * 2.6) as f32, -(d.dot(wu) * CUBE_SCALE * 2.6) as f32);
        painter.line_segment([at, tip], Stroke::new(2.0, Color32::from_rgb(col.0, col.1, col.2)));
    }
    let labels: Vec<String> = targets.iter().filter(|tg| !tg.corner).map(|tg| tg.name.to_uppercase()).collect();
    let size = cube_label_size(ui.ctx(), &labels);
    // Back to front: the faces and facets turned toward the camera.
    for (i, pts) in shapes.iter().rev() {
        let tg = &targets[*i];
        let n = tg.normal();
        let shade = (0.75 + 0.25 * n.dot(b)) as f32;
        let fill = if tg.corner { t.cube_face.gamma_multiply(shade * 0.92) } else { t.cube_face.gamma_multiply(shade) };
        painter.extend(projected_polygon(pts, fill.to_opaque(), Stroke::new(1.0, t.cube_edge)));
        if hovered == Some(*i) {
            painter.extend(projected_polygon(pts, t.accent_soft, Stroke::new(1.0, t.accent)));
        }
        let centre = cube_centroid(pts);
        crate::scenario::publish_handle(&format!("cube:{}", tg.name), centre);
        // Fades out as the face turns edge-on.
        let ink = (n.dot(b) / 0.3).clamp(0.0, 1.0) as f32;
        if !tg.corner && ink > 0.05 {
            let color = Color32::from_rgb(40, 44, 52).gamma_multiply(ink);
            painter.add(cube_label(ui.ctx(), &tg.name.to_uppercase(), size, n, (r, u), c, color));
        }
    }
    crate::scenario::publish_count("cube_highlights", f64::from(u8::from(hovered.is_some())));
    if let Some(i) = hovered {
        crate::scenario::publish_handle(&format!("cube_hover:{}", targets[i].name), hover.unwrap_or(c));
    }
    // Clicked: the view from the face's or facet's direction (target → eye).
    let clicked = hovered.filter(|_| ui.input(|i| i.pointer.primary_clicked())).map(|i| targets[i].dir);
    let home = Rect::from_center_size(pos2(c.x - 52.0, c.y - 48.0), vec2(18.0, 18.0));
    let hr = ui.interact(home, ui.id().with("vc_home"), Sense::click());
    icons::paint(&painter, home, "home", t.icon, if hr.hovered() { t.accent_soft } else { t.overlay }, t.accent);
    if hr.on_hover_text("Home view").clicked() {
        app.animate_view("home");
    }
    if let Some(dir) = clicked {
        let mut to = app.cam.looking_from(app.cam.from_frame(dir));
        // Keep the nearest square heading when looking straight down or up.
        if dir.x == 0.0 && dir.y == 0.0 {
            to.yaw = nearest_quarter_turn(app.cam.yaw);
        }
        app.animate_to(to);
    }
}

/// The nearest square heading. At a halfway tie, prefer the heading nearer the standard
/// plan view, so clicking TOP or BOTTOM from home still puts the front edge at the bottom.
fn nearest_quarter_turn(yaw: f64) -> f64 {
    if !yaw.is_finite() {
        return 0.0;
    }
    let q = std::f64::consts::FRAC_PI_2;
    let lo = (yaw / q).floor() * q;
    let hi = lo + q;
    let (dlo, dhi) = (yaw - lo, hi - yaw);
    if (dlo - dhi).abs() < 1e-6 {
        let off_front = |a: f64| ((a + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU) - std::f64::consts::PI).abs();
        if off_front(lo) <= off_front(hi) { lo } else { hi }
    } else if dlo < dhi {
        lo
    } else {
        hi
    }
}

/// How far along each edge a view cube corner is cut off (the cube's faces are at ±1).
const CUBE_CHAMFER: f64 = 0.38;

/// A view cube target: a face or a corner facet, its view direction (target → eye) and outline
/// (cube units).
#[derive(Clone, Debug)]
pub(crate) struct CubeTarget {
    pub name: String,
    pub dir: Vec3,
    pub corner: bool,
    pub outline: Vec<Vec3>,
}

impl CubeTarget {
    fn normal(&self) -> Vec3 {
        self.dir.normalized().unwrap_or(Vec3::Z)
    }
}

/// The 14 targets: 6 octagonal faces and 8 triangular corner facets.
pub(crate) fn cube_targets() -> Vec<CubeTarget> {
    let k = CUBE_CHAMFER;
    let mut out = Vec::new();
    for (n, name) in [
        (Vec3::new(0.0, -1.0, 0.0), "front"),
        (Vec3::new(0.0, 1.0, 0.0), "back"),
        (Vec3::new(1.0, 0.0, 0.0), "right"),
        (Vec3::new(-1.0, 0.0, 0.0), "left"),
        (Vec3::Z, "top"),
        (Vec3::new(0.0, 0.0, -1.0), "bottom"),
    ] {
        let (e1, e2) = cube_face_axes(n);
        let uv =
            [(-1.0 + k, -1.0), (1.0 - k, -1.0), (1.0, -1.0 + k), (1.0, 1.0 - k), (1.0 - k, 1.0), (-1.0 + k, 1.0), (-1.0, 1.0 - k), (-1.0, -1.0 + k)];
        out.push(CubeTarget { name: name.into(), dir: n, corner: false, outline: uv.iter().map(|(a, b2)| n + e1 * *a + e2 * *b2).collect() });
    }
    for sz in [1.0, -1.0] {
        for sy in [-1.0, 1.0] {
            for sx in [1.0, -1.0] {
                let corner = Vec3::new(sx, sy, sz);
                let name = format!(
                    "{}-{}-{}",
                    if sz > 0.0 { "top" } else { "bottom" },
                    if sy < 0.0 { "front" } else { "back" },
                    if sx > 0.0 { "right" } else { "left" }
                );
                let outline = vec![corner - Vec3::X * (sx * k), corner - Vec3::Y * (sy * k), corner - Vec3::Z * (sz * k)];
                out.push(CubeTarget { name, dir: corner, corner: true, outline });
            }
        }
    }
    out
}

/// Where a point in cube units is drawn, for the camera's right and up `ru` and the cube's
/// centre `c`.
fn cube_to_screen((r, u): (Vec3, Vec3), c: Pos2, p: Vec3) -> Pos2 {
    pos2(c.x + (p.dot(r) * CUBE_SCALE) as f32, c.y - (p.dot(u) * CUBE_SCALE) as f32)
}

/// A face's text directions (right, up): read from outside the cube, and upright in the view
/// of the standard face view (TOP and BOTTOM: yaw 0, front edge at the bottom).
fn cube_label_axes(n: Vec3) -> (Vec3, Vec3) {
    if n.z.abs() > 0.5 { (Vec3::X, Vec3::Y * n.z.signum()) } else { (Vec3::Z.cross(n), Vec3::Z) }
}

/// How much of a face the widest face label spans.
const CUBE_LABEL_WIDTH: f32 = 0.9;

/// The face labels' font size: one size for all, the widest of `labels` spanning
/// `CUBE_LABEL_WIDTH` of a face.
fn cube_label_size(ctx: &egui::Context, labels: &[String]) -> f32 {
    let probe = 10.0;
    let widest = labels
        .iter()
        .map(|s| ctx.fonts_mut(|f| f.layout_no_wrap(s.clone(), FontId::proportional(probe), Color32::WHITE).size().x))
        .fold(0.0, f32::max);
    if widest > 0.0 { probe * CUBE_LABEL_WIDTH * 2.0 * CUBE_SCALE as f32 / widest } else { probe }
}

/// A face's label printed on the face at `size`: laid out flat, then mapped through the cube's
/// projection, so it turns and foreshortens with the face.
fn cube_label(ctx: &egui::Context, text: &str, size: f32, n: Vec3, ru: (Vec3, Vec3), c: Pos2, color: Color32) -> Shape {
    let galley = ctx.fonts_mut(|f| f.layout(text.to_string(), FontId::proportional(size), color, f32::INFINITY));
    let options = egui::epaint::TessellationOptions { round_text_to_pixels: false, ..Default::default() };
    let mut tess = egui::epaint::Tessellator::new(ctx.pixels_per_point(), options, ctx.fonts(|f| f.font_image_size()), vec![]);
    let mut mesh = egui::Mesh::default();
    let at = (-galley.size() / 2.0).to_pos2();
    tess.tessellate_text(&egui::epaint::TextShape::new(at, galley, color), &mut mesh);
    let (right, up) = cube_label_axes(n);
    for v in &mut mesh.vertices {
        let p = n + right * (f64::from(v.pos.x) / CUBE_SCALE) - up * (f64::from(v.pos.y) / CUBE_SCALE);
        v.pos = cube_to_screen(ru, c, p);
    }
    Shape::mesh(mesh)
}

/// The targets turned toward the camera (basis `rub`), front first, as screen polygons around
/// the cube's centre `c`.
pub(crate) fn cube_projected(targets: &[CubeTarget], rub: (Vec3, Vec3, Vec3), c: Pos2) -> Vec<(usize, Vec<Pos2>)> {
    let (r, u, b) = rub;
    let mut v: Vec<(usize, f64, Vec<Pos2>)> = targets
        .iter()
        .enumerate()
        .filter(|(_, tg)| tg.normal().dot(b) > 1e-3)
        .map(|(i, tg)| (i, tg.normal().dot(b), tg.outline.iter().map(|p| cube_to_screen((r, u), c, *p)).collect()))
        .collect();
    v.sort_by(|a, b2| b2.1.total_cmp(&a.1));
    v.into_iter().map(|(i, _, p)| (i, p)).collect()
}

/// The target under `p`. The faces and facets tile the cube, so a point on an edge between two
/// of them (where neither polygon claims it) goes to the nearer one, within a few pixels.
pub(crate) fn cube_hit(shapes: &[(usize, Vec<Pos2>)], p: Pos2) -> Option<usize> {
    if let Some((i, _)) = shapes.iter().find(|(_, pts)| point_in_poly(p, pts)) {
        return Some(*i);
    }
    shapes.iter().map(|(i, pts)| (*i, poly_distance(p, pts))).filter(|(_, d)| *d <= 3.0).min_by(|a, b| a.1.total_cmp(&b.1)).map(|(i, _)| i)
}

fn poly_distance(p: Pos2, pts: &[Pos2]) -> f32 {
    (0..pts.len())
        .map(|i| {
            let (a, b) = (pts[i], pts[(i + 1) % pts.len()]);
            let ab = b - a;
            let t = ((p - a).dot(ab) / ab.length_sq().max(1e-6)).clamp(0.0, 1.0);
            p.distance(a + ab * t)
        })
        .fold(f32::INFINITY, f32::min)
}

fn cube_centroid(pts: &[Pos2]) -> Pos2 {
    let n = pts.len().max(1) as f32;
    pos2(pts.iter().map(|p| p.x).sum::<f32>() / n, pts.iter().map(|p| p.y).sum::<f32>() / n)
}

/// The in-face axes of a view cube face.
fn cube_face_axes(n: Vec3) -> (Vec3, Vec3) {
    if n.z.abs() > 0.5 {
        (Vec3::X, Vec3::Y)
    } else if n.x.abs() > 0.5 {
        (Vec3::Y, Vec3::Z)
    } else {
        (Vec3::X, Vec3::Z)
    }
}

fn point_in_poly(p: Pos2, poly: &[Pos2]) -> bool {
    let n = poly.len();
    let mut inside = false;
    for i in 0..n {
        let (a, b) = (poly[i], poly[(i + 1) % n]);
        if (a.y > p.y) != (b.y > p.y) {
            let x = a.x + (p.y - a.y) / (b.y - a.y) * (b.x - a.x);
            if p.x < x {
                inside = !inside;
            }
        }
    }
    inside
}

/// Navigation bar (bottom centre).
/// Turn the view to face the selected planar face or plane, else the active sketch.
pub fn look_at_selection(app: &mut SolveApp) {
    let target = app.session.selection.iter().find_map(|s| match s {
        Sel::Face { body, index, point } => crate::dialogs::planar_face(&app.session, body, *index).map(|(_, n)| (*point, n)),
        Sel::Plane { name } => solvecraft_engine::geom::Plane::named(name).map(|p| (p.origin, p.normal())),
        _ => None,
    });
    match target {
        Some((p, n)) => {
            let mut to = app.cam.looking_from(n);
            to.target = p;
            app.animate_to(to);
        }
        None => crate::dialogs::look_at_sketch(app),
    }
}

fn nav_bar(app: &mut SolveApp, ui: &mut egui::Ui, rect: Rect) {
    let t = Tokens::get();
    let items: [(&str, &str); 10] = [
        ("orbit", "Orbit (drag; or Shift+middle / right drag)"),
        ("spin", "Continuous orbit (stops at the next click or key)"),
        ("pan", "Pan (drag; or middle drag)"),
        ("zoom", "Zoom (drag; or wheel)"),
        ("fit", "Fit (F6)"),
        ("lookat", "Look At the selected face or plane (or the active sketch)"),
        ("home", "Home view"),
        ("perspective", "Perspective / orthographic"),
        ("style", "Visual style: shaded with edges, shaded, wireframe, shaded with hidden edges"),
        ("settings", "View settings: grid, ground shadow, agent cursor"),
    ];
    let menu_id = ui.id().with("nav_view_menu");
    let mut menu_open = ui.data(|d| d.get_temp::<bool>(menu_id)).unwrap_or(false);
    let w = items.len() as f32 * 30.0 + 10.0;
    let bar = Rect::from_center_size(pos2(rect.center().x, rect.bottom() - 22.0), vec2(w, 30.0));
    let painter = ui.painter_at(rect);
    painter.rect(bar, 6.0, t.overlay, Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
    for (i, (icon, tip)) in items.iter().enumerate() {
        let br = Rect::from_min_size(pos2(bar.left() + 5.0 + i as f32 * 30.0, bar.top() + 2.0), vec2(26.0, 26.0));
        let resp = ui.interact(br, ui.id().with(("nav", *icon)), Sense::click());
        let active = match *icon {
            "orbit" => app.viewport.nav == Some(NavMode::Orbit),
            "pan" => app.viewport.nav == Some(NavMode::Pan),
            "zoom" => app.viewport.nav == Some(NavMode::Zoom),
            "perspective" => app.ui.perspective,
            "settings" => menu_open,
            "spin" => app.viewport.spin,
            _ => false,
        };
        if active || resp.hovered() {
            painter.rect_filled(br, 4.0, if active { t.accent_soft } else { t.hover });
        }
        icons::paint(&painter, br.shrink(4.0), icon, t.icon, t.icon_fill, t.accent);
        if resp.on_hover_text(*tip).clicked() {
            let toggle = |m: NavMode, cur: Option<NavMode>| if cur == Some(m) { None } else { Some(m) };
            match *icon {
                "orbit" => app.viewport.nav = toggle(NavMode::Orbit, app.viewport.nav),
                "pan" => app.viewport.nav = toggle(NavMode::Pan, app.viewport.nav),
                "zoom" => app.viewport.nav = toggle(NavMode::Zoom, app.viewport.nav),
                "fit" => app.animate_view("fit"),
                "spin" => {
                    app.cancel_view_animation();
                    app.viewport.spin = !app.viewport.spin;
                }
                "home" => app.animate_view("home"),
                "lookat" => look_at_selection(app),
                "style" => app.ui.visual_style = (app.ui.visual_style + 1) % 4,
                "perspective" => app.ui.perspective = !app.ui.perspective,
                _ => menu_open = !menu_open,
            }
        }
        if *icon == "settings" {
            crate::scenario::publish_handle("nav:view", br.center());
            if menu_open {
                menu_open = view_menu(app, ui, br);
            }
        }
    }
    ui.data_mut(|d| d.insert_temp(menu_id, menu_open));
}

/// The View settings above the navigation bar's last button: grid, ground shadow and the agent
/// cursor (#35). False once it should close (a click outside it).
fn view_menu(app: &mut SolveApp, ui: &mut egui::Ui, button: Rect) -> bool {
    let area = egui::Area::new(egui::Id::new("sc_view_menu"))
        .order(egui::Order::Foreground)
        .pivot(Align2::RIGHT_BOTTOM)
        .fixed_pos(button.right_top() - vec2(0.0, 6.0));
    let r = area.show(ui.ctx(), |ui| {
        egui::Frame::popup(ui.style()).show(ui, |ui| {
            ui.set_width(220.0);
            ui.label(egui::RichText::new("VIEW").strong().size(11.5));
            ui.checkbox(&mut app.ui.show_grid, "Grid");
            ui.checkbox(&mut app.ui.ground_shadow, "Ground shadow");
            ui.separator();
            let s = &mut app.ui.agent_cursor;
            let show = ui.checkbox(&mut s.show, "Show Agent Cursor");
            crate::scenario::publish_handle("view:agent_cursor", show.rect.center());
            ui.add_enabled_ui(s.show, |ui| {
                ui.horizontal(|ui| {
                    ui.label("Speed");
                    crate::agent_cursor::speed_slider(ui, &mut s.speed);
                });
                ui.checkbox(&mut s.follow_camera, "Follow camera (Look At sketches)");
            });
        });
    });
    let clicked_out = ui.input(|i| i.pointer.any_pressed())
        && ui.input(|i| i.pointer.interact_pos()).is_some_and(|p| !r.response.rect.contains(p) && !button.contains(p));
    !clicked_out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn timeline_modifiers_highlight_on_hover_and_click() {
        for command in ["solid.fillet", "solid.chamfer"] {
            let mut h = crate::scenario::Harness::new();
            h.app.ui.show_origin = false;
            let base = h.app.run("solid.box", json!({"length":20,"width":20,"height":20})).unwrap()["feature"].as_u64().unwrap();
            let id = h.app.run(command, json!({"edges":[[0,0,10]],"radius":2,"distance":2,"name":"Blend"})).unwrap()["feature"].as_u64().unwrap();
            h.app.run("solid.box", json!({"length":5,"width":5,"height":5,"corner":[40,0,0]})).unwrap();
            h.frames(2);
            let geometry = feature_geometry(&h.app, id);
            assert_eq!(geometry.len(), 1, "{command}: {geometry:?}");
            let Sel::Face { body, index, .. } = &geometry[0] else { panic!("a modifier must highlight its face") };
            let st = h.app.session.world_state();
            let m = st.body(body).unwrap().mesh();
            let triangles = m.tri_face.iter().filter(|f| **f as usize == *index).count();
            assert!(triangles > 0 && triangles < m.triangles.len());
            let p = crate::scenario::handle_at("timeline:Blend").unwrap();
            h.step(&json!({"move":[p.x,p.y]})).unwrap();
            assert_eq!(h.app.viewport.hover_feature, Some(id));
            assert_eq!(build_highlight(&h.app).tris.len(), triangles * 3 * crate::gpu::TRI_SIZE);
            assert!(!build_highlight(&h.app).lines.is_empty());
            h.step(&json!({"click":[p.x,p.y]})).unwrap();
            assert_eq!(h.app.session.selection, vec![Sel::Feature { id }]);
            // Moving away removes hover but leaves the selected blend highlighted.
            h.step(&json!({"move":[5,5]})).unwrap();
            assert_eq!(h.app.viewport.hover_feature, None);
            assert_eq!(build_highlight(&h.app).tris.len(), triangles * 3 * crate::gpu::TRI_SIZE);
            let bounds = selection_bounds(&h.app).unwrap();
            assert!(bounds.max.x <= 2.01 && bounds.max.y <= 2.01 && bounds.max.z > 19.99, "{bounds:?}");
            // Creator features retain whole-body feedback, while hidden bodies stay hidden.
            assert_eq!(feature_geometry(&h.app, base), vec![Sel::Body { name: body.clone() }]);
            h.app.session.visibility.hidden_bodies.push(body.clone());
            assert!(feature_geometry(&h.app, id).is_empty());
            assert!(selection_bounds(&h.app).is_none());
            assert!(build_highlight(&h.app).tris.is_empty());
        }
    }

    #[test]
    fn timeline_modifier_highlight_follows_edits_and_rollback() {
        let mut app = SolveApp::new(solvecraft_engine::Session::default(), crate::Services::default());
        app.run("solid.box", json!({"length":20,"width":20,"height":20})).unwrap();
        let id = app.run("solid.fillet", json!({"edges":[[0,0,10]],"radius":2})).unwrap()["feature"].as_u64().unwrap();
        // A later chamfer changes the same body without consuming the fillet.
        app.run("solid.chamfer", json!({"edges":[[20,20,10]],"distance":1})).unwrap();
        app.run("solid.move", json!({"bodies":["Body1"],"translate":[30,0,0]})).unwrap();
        app.run("body.rename", json!({"body":"Body1","name":"Moved"})).unwrap();
        app.session.selection = vec![Sel::Feature { id }];
        let bounds = selection_bounds(&app).unwrap();
        assert!(bounds.min.x >= 29.99 && bounds.max.x <= 32.01, "{bounds:?}");
        assert!(feature_geometry(&app, id).iter().all(|x| matches!(x, Sel::Face { body, .. } if body == "Moved")));
        app.run("timeline.roll_to", json!({"position":1})).unwrap();
        assert!(feature_geometry(&app, id).is_empty());
        app.run("timeline.roll_to", json!({})).unwrap();
        assert!(!feature_geometry(&app, id).is_empty());
        app.run("timeline.suppress", json!({"feature":id})).unwrap();
        assert!(feature_geometry(&app, id).is_empty());
    }

    #[test]
    fn timeline_modifier_highlight_follows_component_instances() {
        let mut app = SolveApp::new(solvecraft_engine::Session::default(), crate::Services::default());
        app.run("component.create", json!({"name":"Part"})).unwrap();
        app.run("solid.box", json!({"length":20,"width":20,"height":20})).unwrap();
        let id = app.run("solid.fillet", json!({"edges":[[0,0,10]],"radius":2})).unwrap()["feature"].as_u64().unwrap();
        app.run("occurrence.move", json!({"occurrence":"Part:1","translate":[30,0,0]})).unwrap();
        app.run("occurrence.copy", json!({"component":"Part","translate":[0,40,0]})).unwrap();
        let geometry = feature_geometry(&app, id);
        assert_eq!(geometry.len(), 2, "both occurrences retain the fillet's face: {geometry:?}");
        app.session.selection = vec![Sel::Feature { id }];
        let bounds = selection_bounds(&app).unwrap();
        assert!(bounds.min.x >= 29.99 && bounds.max.x <= 32.01 && bounds.max.y >= 41.99, "{bounds:?}");
    }

    fn hover_frame(app: &mut SolveApp, ctx: &egui::Context, events: Vec<egui::Event>) {
        let selected = app.highlighted();
        let _ = ctx.run_ui(
            egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), events, ..Default::default() },
            |ui| {
                show(app, ui);
            },
        );
        // Click selection is applied after rendering; hover itself must already be current.
        if app.viewport.gpu.is_some() && selected == app.highlighted() {
            assert_eq!(app.viewport.hl_key, highlight_key(app), "GPU highlight must use this frame's hover");
        }
    }

    fn hover_app(gpu: bool) -> SolveApp {
        let mut s = solvecraft_engine::Session::default();
        s.execute("sketch.create", &json!({"plane": "XY"})).unwrap();
        s.execute("sketch.point", &json!({"point": [0, 0]})).unwrap();
        let mut app = SolveApp::new(s, crate::Services::default());
        app.viewport.no_pixels = true;
        if gpu {
            // The callback is queued by egui; no device is needed to inspect scene updates.
            app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1 });
        }
        app
    }

    #[test]
    fn hover_stays_off_between_navigation_events_and_returns_on_release() {
        for gpu in [false, true] {
            for button in [egui::PointerButton::Middle, egui::PointerButton::Secondary, egui::PointerButton::Primary] {
                let ctx = egui::Context::default();
                let mut app = hover_app(gpu);
                if button == egui::PointerButton::Primary {
                    app.viewport.nav = Some(NavMode::Orbit);
                }
                hover_frame(&mut app, &ctx, vec![]);
                let p = projection(&app, app.viewport.rect.unwrap()).to_screen(Vec3::ZERO).unwrap();
                hover_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(p)]);
                assert!(app.viewport.hover.is_some());
                hover_frame(&mut app, &ctx, vec![egui::Event::PointerButton { pos: p, button, pressed: true, modifiers: Default::default() }]);
                assert!(app.viewport.hover.is_none(), "hover on navigation press");
                for offset in [1.0, 2.0, 3.0] {
                    hover_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(p + vec2(offset, 0.0))]);
                    assert!(app.viewport.hover.is_none(), "hover while moving");
                    for _ in 0..3 {
                        hover_frame(&mut app, &ctx, vec![]);
                        assert!(app.viewport.hover.is_none(), "hover between movement events");
                    }
                }
                hover_frame(&mut app, &ctx, vec![egui::Event::PointerButton { pos: p, button, pressed: false, modifiers: Default::default() }]);
                assert!(app.viewport.hover.is_some(), "hover must return on release");
            }
        }
    }

    #[test]
    fn hover_stays_off_during_spin_and_animated_views() {
        let ctx = egui::Context::default();
        let mut app = hover_app(true);
        hover_frame(&mut app, &ctx, vec![]);
        let p = projection(&app, app.viewport.rect.unwrap()).to_screen(Vec3::ZERO).unwrap();
        hover_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(p)]);
        assert!(app.viewport.hover.is_some());
        app.viewport.spin = true;
        for _ in 0..3 {
            hover_frame(&mut app, &ctx, vec![]);
            assert!(app.viewport.hover.is_none());
        }
        app.viewport.spin = false;
        hover_frame(&mut app, &ctx, vec![]);
        assert!(app.viewport.hover.is_some());
        app.cam_anim = Some(solvecraft_engine::render::CameraAnim::new(app.cam, app.cam, 0.0));
        for _ in 0..3 {
            hover_frame(&mut app, &ctx, vec![]);
            assert!(app.viewport.hover.is_none());
        }
        app.cam_anim = None;
        hover_frame(&mut app, &ctx, vec![]);
        assert!(app.viewport.hover.is_some());
    }

    fn cylinder_app() -> SolveApp {
        let mut s = solvecraft_engine::Session::default();
        s.execute("solid.cylinder", &json!({"radius": 10, "height": 20})).unwrap();
        let mut app = SolveApp::new(s, crate::Services::default());
        app.ui.show_origin = false;
        app
    }

    #[test]
    fn circular_items_measure_as_whole_rims_and_surfaces() {
        let mut app = cylinder_app();
        let st = app.session.world_state();
        let b = &st.bodies[0];
        let m = b.mesh();
        let edges: Vec<Sel> = m
            .edges
            .iter()
            .enumerate()
            .filter(|(_, p)| p.len() > 3 && p.iter().all(|q| (q.z - 20.0).abs() < 1e-6))
            .map(|(index, p)| Sel::Edge { body: b.name.clone(), index, point: polyline_mid(p) })
            .collect();
        let result = app.session.measure_items(&edges);
        assert_eq!(result["items"].as_array().unwrap().len(), 1);
        assert!((result["items"][0]["length_mm"].as_f64().unwrap() - 20.0 * std::f64::consts::PI).abs() < 0.2, "{result}");
        app.session.selection = edges;
        let d = crate::dialogs::Dialog::for_command(&app, "inspect.measure").unwrap();
        assert_eq!(d.items().len(), 1);

        let faces = m.edge_faces.iter().zip(&m.seams).find(|(_, seam)| **seam).unwrap().0;
        let wall = Sel::Face { body: b.name.clone(), index: faces[0] as usize, point: Vec3::new(10.0, 0.0, 10.0) };
        let wall_pieces = grouped_selection(&app.session, &wall);
        let result = app.session.measure_items(&wall_pieces);
        assert_eq!(result["items"].as_array().unwrap().len(), 1);
        assert!((result["items"][0]["area_mm2"].as_f64().unwrap() - 400.0 * std::f64::consts::PI).abs() < 10.0, "{result}");
        let mut d = crate::dialogs::Dialog::for_command(&app, "inspect.measure").unwrap();
        d.pick(&app.session, wall.clone());
        assert_eq!(d.items().len(), 2, "a rim and a wall are two measurement targets");
        d.pick(&app.session, Sel::Face { body: b.name.clone(), index: faces[1] as usize, point: Vec3::new(-10.0, 0.0, 10.0) });
        assert_eq!(d.items().len(), 1, "the other half toggles the same wall");
    }

    #[test]
    fn circular_rim_hover_click_and_dialog_pick_include_both_halves() {
        let mut app = cylinder_app();
        let st = app.session.world_state();
        let b = &st.bodies[0];
        let m = b.mesh();
        let top = m.edges.iter().position(|e| e.len() > 3 && e.iter().all(|p| (p.z - 20.0).abs() < 1e-6)).unwrap();
        let rim = m.circular_rim(top);
        assert_eq!(rim.len(), 2);
        let line_count: usize = rim.iter().map(|&i| m.edges[i].len() - 1).sum();
        for &i in &rim {
            let mid = polyline_mid(&m.edges[i]);
            app.viewport.hover = Some(Hit::Edge { body: b.name.clone(), index: i, mid });
            assert_eq!(build_highlight(&app).lines.len(), 2 * line_count * crate::gpu::LINE_SIZE);
            let item = hit_sel(app.viewport.hover.as_ref().unwrap()).unwrap();
            select(&mut app, Some(item.clone()), false);
            assert_eq!(app.session.selection.len(), 2);
            // Selecting both pieces must not draw each highlight twice.
            assert_eq!(build_highlight(&app).lines.len(), 2 * line_count * crate::gpu::LINE_SIZE);
            // Ctrl/Shift clicking either half deselects the entire rim.
            select(&mut app, Some(item.clone()), true);
            assert!(app.session.selection.is_empty());
            let mut d = crate::dialogs::Dialog::for_command(&app, "solid.chamfer").unwrap();
            if let crate::dialogs::Kind::Fillet { chain, .. } = &mut d.kind {
                *chain = false;
            }
            d.pick(&app.session, item.clone());
            assert_eq!(d.items().len(), 2);
            d.pick(&app.session, item);
            assert!(d.items().is_empty());
        }
        // Screen-space picking works from either side of the rim as the model turns.
        for &i in &rim {
            let mid = polyline_mid(&m.edges[i]);
            app.cam = app.cam.looking_from(Vec3::new(mid.x, mid.y, 20.0));
            app.cam.target = Vec3::new(0.0, 0.0, 10.0);
            for perspective in [false, true] {
                app.ui.perspective = perspective;
                let proj = projection(&app, Rect::from_min_size(pos2(0.0, 0.0), vec2(800.0, 600.0)));
                let hits = pick(&app, &proj, proj.to_screen(mid).unwrap());
                let (_, sel) = candidate(&app, &hits).unwrap();
                assert!(matches!(sel, Sel::Edge { .. }), "{hits:?}");
                assert_eq!(grouped_selection(&app.session, &sel).len(), 2);
            }
        }
    }

    #[test]
    fn curved_face_hover_selection_and_dialogs_cross_the_seam() {
        let mut app = cylinder_app();
        let st = app.session.world_state();
        let b = &st.bodies[0];
        let m = b.mesh();
        let faces = m.edge_faces.iter().zip(&m.seams).find(|(_, seam)| **seam).unwrap().0;
        assert_eq!(faces.len(), 2);
        let triangle_count = m.tri_face.iter().filter(|f| faces.contains(f)).count();
        for &f in faces {
            let index = f as usize;
            let t = m.triangles.iter().zip(&m.tri_face).find(|(_, tf)| **tf == f).unwrap().0;
            let [a, c, d] = m.tri(t).unwrap();
            let point = (a + c + d) / 3.0;
            app.viewport.hover = Some(Hit::Face { body: b.name.clone(), index, point });
            assert_eq!(build_highlight(&app).tris.len(), triangle_count * 3 * crate::gpu::TRI_SIZE);
            let item = hit_sel(app.viewport.hover.as_ref().unwrap()).unwrap();
            select(&mut app, Some(item.clone()), false);
            assert_eq!(app.session.selection.len(), 2);
            assert_eq!(build_highlight(&app).tris.len(), triangle_count * 3 * crate::gpu::TRI_SIZE);
            assert_eq!(app.session.selection.first(), Some(&item), "keep the original tool placement point first");
            let mut dialog = crate::dialogs::Dialog::for_command(&app, "solid.chamfer").unwrap();
            assert_eq!(dialog.items().len(), 2);
            dialog.pick(&app.session, item.clone());
            assert!(dialog.items().is_empty());
            dialog.pick(&app.session, item);
            assert_eq!(dialog.items().len(), 2);
            // A point elsewhere on the opposite half still toggles the whole surface off.
            let other = faces.iter().find(|&&x| x != f).unwrap();
            select(&mut app, Some(Sel::Face { body: b.name.clone(), index: *other as usize, point: m.positions[0] }), true);
            assert!(app.session.selection.is_empty());
        }
        // Planar caps and box corners stay separate.
        let cap = (0..b.body.face_count()).find(|&i| m.surface_patch(i).len() == 1).unwrap();
        assert_eq!(m.surface_patch(cap), vec![cap]);
        app.session.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})).unwrap();
        let st = app.session.world_state();
        let box_body = st.bodies.last().unwrap();
        for i in 0..box_body.body.face_count() {
            assert_eq!(box_body.mesh().surface_patch(i), vec![i]);
        }
    }

    #[test]
    fn shortcuts_window_wheel_does_not_zoom_the_viewport() {
        let ctx = egui::Context::default();
        let mut app = SolveApp::new(solvecraft_engine::Session::default(), crate::Services::default());
        app.viewport.no_pixels = true;
        crate::help::run(&mut app, &ctx, "shortcuts");
        let mut time = 0.0;
        let mut frame = |app: &mut SolveApp, pointer: Option<Pos2>, wheel: f32| {
            time += 1.0 / 60.0;
            let mut events = Vec::new();
            if let Some(p) = pointer {
                events.push(egui::Event::PointerMoved(p));
            }
            if wheel != 0.0 {
                events.push(egui::Event::MouseWheel {
                    unit: egui::MouseWheelUnit::Point,
                    delta: vec2(0.0, wheel),
                    modifiers: egui::Modifiers::NONE,
                    phase: egui::TouchPhase::Move,
                });
            }
            let _ = ctx.run_ui(
                egui::RawInput {
                    screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1100.0, 800.0))),
                    time: Some(time),
                    events,
                    ..Default::default()
                },
                |ui| {
                    egui::CentralPanel::default().show(ui, |ui| show(app, ui));
                    crate::prefs::show(app, ui.ctx());
                },
            );
        };
        // Let egui establish the floating window's size and hit-test widgets.
        for _ in 0..4 {
            frame(&mut app, None, 0.0);
        }
        let window = ctx.memory(|m| m.area_rect(egui::Id::new("sc_prefs"))).unwrap();
        let list = window.center() + vec2(140.0, 0.0);
        let height = app.cam.half_height();
        let target = app.cam.target;
        frame(&mut app, Some(list), 0.0);
        for n in 0..12 {
            frame(&mut app, Some(list), if n == 0 { -120.0 } else { 0.0 });
            assert_eq!(app.cam.half_height(), height, "wheel input over shortcuts must stay in the popup");
            assert_eq!(app.cam.target, target);
        }
        // The window's non-scrolling sidebar must also shield the model.
        frame(&mut app, Some(window.left_center() + vec2(30.0, 0.0)), -120.0);
        assert_eq!(app.cam.half_height(), height);
        // An exposed part of the viewport still accepts wheel navigation with the popup open.
        let exposed = pos2(40.0, 700.0);
        assert!(!window.contains(exposed));
        frame(&mut app, Some(exposed), 0.0);
        frame(&mut app, Some(exposed), -120.0);
        assert_ne!(app.cam.half_height(), height);
        // Closing the popup returns its former area to the viewport.
        app.prefs_window.open = false;
        for _ in 0..12 {
            frame(&mut app, Some(list), 0.0);
        }
        let height = app.cam.half_height();
        frame(&mut app, Some(list), -120.0);
        assert_ne!(app.cam.half_height(), height);
    }

    #[test]
    fn floating_dialog_blocks_viewport_hover_and_clicks() {
        let mut h = crate::scenario::Harness::new();
        h.call("engine.execute", json!({"command": "solid.box", "params": {"length": 40, "width": 30, "height": 20}}));
        h.call("ui.view", json!({"view": "fit"}));
        h.app.ui.pick_bodies = true;
        let p = h.app.viewport.rect.unwrap().center();
        h.call("ui.move", json!({"x": p.x, "y": p.y}));
        assert!(h.app.viewport.hover.is_some(), "the test point must hover over the model");
        h.call("ui.click", json!({"x": p.x, "y": p.y}));
        assert!(!h.app.session.selection.is_empty(), "the uncovered model must be selectable");
        h.app.session.selection.clear();

        h.call("ui.prefs", json!({"open": "Navigation"}));
        let window = h.ctx.memory(|m| m.area_rect(egui::Id::new("sc_prefs"))).unwrap();
        assert!(window.contains(p), "the dialog must cover the model at the test point");
        h.call("ui.move", json!({"x": p.x, "y": p.y}));
        assert!(h.app.viewport.hover.is_none(), "the dialog must block model highlights");
        assert!(h.app.viewport.mouse.is_none());
        h.call("ui.click", json!({"x": p.x, "y": p.y}));
        assert!(h.app.session.selection.is_empty(), "clicks in the dialog must not select the model");

        h.call("ui.prefs", json!({"button": "cancel"}));
        h.call("ui.move", json!({"x": p.x, "y": p.y}));
        assert!(h.app.viewport.hover.is_some(), "closing the dialog must restore model highlights");
        h.call("ui.click", json!({"x": p.x, "y": p.y}));
        assert!(!h.app.session.selection.is_empty());
    }

    #[test]
    fn floating_dialog_blocks_view_cube_highlights_and_clicks() {
        let mut h = crate::scenario::Harness::new();
        h.call("ui.resize", json!({"width": 800, "height": 700}));
        let p = crate::scenario::handle_at("cube:top").unwrap();
        h.call("ui.move", json!({"x": p.x, "y": p.y}));
        assert_eq!(crate::scenario::count_of("cube_highlights"), Some(1.0));
        h.call("ui.prefs", json!({"open": "Navigation"}));
        let window = h.ctx.memory(|m| m.area_rect(egui::Id::new("sc_prefs"))).unwrap();
        assert!(window.contains(p), "the floating dialog must cover the cube target");
        let camera = serde_json::to_value(h.app.cam).unwrap();
        h.call("ui.move", json!({"x": p.x, "y": p.y}));
        assert_eq!(crate::scenario::count_of("cube_highlights"), Some(0.0));
        h.call("ui.click", json!({"x": p.x, "y": p.y}));
        assert_eq!(serde_json::to_value(h.app.cam).unwrap(), camera, "dialog clicks must not turn the view cube");
        h.call("ui.drag", json!({"x0": p.x, "y0": p.y, "x1": p.x + 20.0, "y1": p.y, "steps": 8}));
        assert_eq!(serde_json::to_value(h.app.cam).unwrap(), camera, "dialog drags must not orbit the cube");
        assert!(h.app.viewport.cube_drag.is_none());
        h.call("ui.prefs", json!({"button": "cancel"}));
        h.call("ui.move", json!({"x": p.x, "y": p.y}));
        assert_eq!(crate::scenario::count_of("cube_highlights"), Some(1.0));
        h.call("ui.click", json!({"x": p.x, "y": p.y}));
        assert_ne!(serde_json::to_value(h.app.cam).unwrap(), camera);
    }

    #[test]
    fn view_cube_drag_owns_navigation_and_keeps_the_view_centre() {
        for nav in [None, Some(NavMode::Orbit), Some(NavMode::Pan)] {
            let mut h = crate::scenario::Harness::new();
            h.call("ui.view", json!({"view": "front"}));
            h.app.viewport.nav = nav;
            let before = h.app.cam;
            let p = crate::scenario::handle_at("cube:front").unwrap();
            h.call("ui.drag", json!({"x0": p.x, "y0": p.y, "x1": p.x + 48.0, "y1": p.y, "steps": 8}));
            assert!((h.app.cam.yaw - 48.0 * 0.008).abs() < 1e-6, "{nav:?}: cube drag must orbit exactly once");
            assert_eq!(h.app.cam.target, before.target, "{nav:?}: cube drag must not pan");
            assert_eq!(h.app.cam.distance, before.distance);
            assert_eq!(h.app.cam.pitch, before.pitch);
            assert!(h.app.viewport.cube_drag.is_none(), "release clears the cube gesture");
            assert!(h.app.viewport.boxsel.is_none());
        }
    }

    #[test]
    fn section_outlines_follow_the_cut() {
        let mut s = solvecraft_engine::Session::default();
        s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
        let st = s.model.state();
        let m = st.bodies[0].mesh();
        let (o, n) = (Vec3::new(0.0, 15.0, 0.0), Vec3::new(0.0, -1.0, 0.0));
        let segs = section_segments(&m, o, n);
        assert!(segs.len() >= 4, "{segs:?}");
        // On the plane (a hair to the kept side) and around the 40 x 20 cut.
        let mut len = 0.0;
        for (a, b) in &segs {
            assert!((a.y - 15.0).abs() < 0.01 && (b.y - 15.0).abs() < 0.01);
            len += a.dist(*b);
        }
        assert!((len - 120.0).abs() < 0.5, "outline length {len}");
        // A plane that misses the body cuts nothing.
        assert!(section_segments(&m, Vec3::new(0.0, 99.0, 0.0), n).is_empty());
    }

    #[test]
    fn selection_shows_where_the_model_hides_it() {
        let mut s = solvecraft_engine::Session::default();
        s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
        let mut app = SolveApp::new(s, crate::Services::default());
        assert!(build_highlight(&app).hidden.is_empty());
        // The back face: its outline is drawn (dimmed) where the box hides it.
        app.session.selection = vec![Sel::Face { body: "Body1".into(), index: 3, point: Vec3::new(20.0, 30.0, 10.0) }];
        assert!(!build_highlight(&app).hidden.is_empty());
    }

    /// A camera basis looking from `dir` (target → eye), as the view cube draws with.
    fn basis_from(dir: Vec3) -> (Vec3, Vec3, Vec3) {
        let cam = solvecraft_engine::render::Camera::default().looking_from(dir);
        cam.basis()
    }

    #[test]
    fn view_cube_has_14_targets_each_hit_where_drawn() {
        let targets = cube_targets();
        assert_eq!(targets.len(), 14);
        assert_eq!(targets.iter().filter(|t| t.corner).count(), 8);
        let c = pos2(100.0, 100.0);
        for (i, tg) in targets.iter().enumerate() {
            // Seen from a little off its own direction, its middle hits it.
            let shapes = cube_projected(&targets, basis_from(tg.dir + Vec3::new(0.11, 0.07, 0.05)), c);
            let pts = &shapes.iter().find(|(j, _)| *j == i).expect("visible").1;
            assert_eq!(cube_hit(&shapes, cube_centroid(pts)), Some(i), "{}", tg.name);
        }
        // From an iso view: 3 faces and the 4 facets turned toward it.
        let shapes = cube_projected(&targets, basis_from(Vec3::new(1.0, -1.0, 1.0)), c);
        assert_eq!(shapes.len(), 3 + 4);
        assert_eq!(cube_hit(&shapes, pos2(400.0, 400.0)), None);
    }

    /// From any direction, including faces turned nearly edge-on, everything drawn stays within
    /// the cube.
    #[test]
    fn view_cube_faces_never_spike_past_the_cube() {
        let targets = cube_targets();
        let c = pos2(100.0, 100.0);
        // The cube's circumradius (corner at √3) plus the stroke and feathering.
        let limit = (3f64.sqrt() * CUBE_SCALE) as f32 + 3.0;
        let mut worst = 0.0f32;
        for dir in orbit_directions() {
            for (_, pts) in cube_projected(&targets, basis_from(dir), c) {
                for p in drawn_points(projected_polygon(&pts, Color32::GRAY, Stroke::new(1.0, Color32::BLACK))) {
                    worst = worst.max(p.distance(c));
                }
            }
        }
        assert!(worst <= limit, "a vertex {worst} px from the centre (limit {limit})");
    }

    #[test]
    fn view_cube_labels_read_upright_in_their_own_view() {
        for tg in cube_targets().iter().filter(|t| !t.corner) {
            // The standard face view (TOP and BOTTOM with yaw 0).
            let mut cam = solvecraft_engine::render::Camera::default().looking_from(tg.dir);
            if tg.dir.z.abs() > 0.5 {
                cam.yaw = 0.0;
            }
            let (r, u, _) = cam.basis();
            let (right, up) = cube_label_axes(tg.dir);
            assert!(right.dot(r) > 0.99 && up.dot(u) > 0.99, "{}: right·r {} up·u {}", tg.name, right.dot(r), up.dot(u));
        }
    }

    fn face_labels(targets: &[CubeTarget]) -> Vec<String> {
        targets.iter().filter(|t| !t.corner).map(|t| t.name.to_uppercase()).collect()
    }

    #[test]
    fn view_cube_top_bottom_choose_nearest_square_heading() {
        for (from, to) in [
            (0.0, 0.0),
            (30.0, 0.0),
            (-80.0, -90.0),
            (100.0, 90.0),
            (170.0, 180.0),
            (400.0, 360.0),
            (-400.0, -360.0),
            (-45.0, 0.0),
            (45.0, 0.0),
            (135.0, 90.0),
            (-135.0, -90.0),
            (44.99, 0.0),
            (45.01, 90.0),
            (-44.99, 0.0),
            (-45.01, -90.0),
        ] {
            let got = nearest_quarter_turn(f64::to_radians(from)).to_degrees();
            assert!((got - to).abs() < 1e-9, "{from}° → {got}°, expected {to}°");
        }
        assert_eq!(nearest_quarter_turn(f64::NAN), 0.0);
        assert_eq!(nearest_quarter_turn(f64::INFINITY), 0.0);
    }

    /// The widest label spans 90% of its face, looking straight at it.
    #[test]
    fn view_cube_widest_label_spans_most_of_its_face() {
        let ctx = egui::Context::default();
        let mut span = 0.0f32;
        let _ = ctx.run_ui(egui::RawInput::default(), |ui| {
            let size = cube_label_size(ui.ctx(), &face_labels(&cube_targets()));
            let front = Vec3::new(0.0, -1.0, 0.0);
            let (r, u, _) = basis_from(front);
            let pts = drawn_points(vec![cube_label(ui.ctx(), "BOTTOM", size, front, (r, u), pos2(100.0, 100.0), Color32::BLACK)]);
            let (lo, hi) = pts.iter().fold((f32::INFINITY, f32::NEG_INFINITY), |(lo, hi), p| (lo.min(p.x), hi.max(p.x)));
            span = (hi - lo) / (2.0 * CUBE_SCALE as f32);
        });
        assert!((span - CUBE_LABEL_WIDTH).abs() < 0.05, "BOTTOM spans {span} of the face");
    }

    /// From any direction, each label is printed within its face.
    #[test]
    fn view_cube_labels_stay_on_their_faces() {
        let ctx = egui::Context::default();
        let (mut worst, mut drawn) = (f32::NEG_INFINITY, 0);
        let _ = ctx.run_ui(egui::RawInput::default(), |ui| {
            let targets = cube_targets();
            let size = cube_label_size(ui.ctx(), &face_labels(&targets));
            let c = pos2(100.0, 100.0);
            for dir in orbit_directions().step_by(7) {
                let (r, u, b) = basis_from(dir);
                for (i, pts) in cube_projected(&targets, (r, u, b), c) {
                    let tg = &targets[i];
                    if tg.corner {
                        continue;
                    }
                    for p in drawn_points(vec![cube_label(ui.ctx(), &tg.name.to_uppercase(), size, tg.normal(), (r, u), c, Color32::BLACK)]) {
                        let outside = if point_in_poly(p, &pts) { 0.0 } else { poly_distance(p, &pts) };
                        worst = worst.max(outside);
                        drawn += 1;
                    }
                }
            }
        });
        assert!(drawn > 10_000, "only {drawn} label vertices drawn");
        assert!(worst <= 0.5, "a label vertex {worst} px outside its face");
    }

    #[test]
    fn view_cube_edges_are_not_targets() {
        let targets = cube_targets();
        let c = pos2(100.0, 100.0);
        let shapes = cube_projected(&targets, basis_from(Vec3::new(1.0, -1.2, 0.9)), c);
        let (r, u, _) = basis_from(Vec3::new(1.0, -1.2, 0.9));
        let to2 = |p: Vec3| pos2(c.x + (p.dot(r) * CUBE_SCALE) as f32, c.y - (p.dot(u) * CUBE_SCALE) as f32);
        let name = |i: Option<usize>| i.map(|i| targets[i].name.clone()).unwrap_or_default();
        // On the top-front edge, its middle and near its ends: a neighbouring face (or facet).
        for x in [-0.5, 0.0, 0.5] {
            let hit = name(cube_hit(&shapes, to2(Vec3::new(x, -1.0, 1.0))));
            assert!(hit == "top" || hit == "front", "edge point {x}: {hit}");
        }
        let end = name(cube_hit(&shapes, to2(Vec3::new(0.9, -1.0, 1.0))));
        assert!(["top", "front", "top-front-right"].contains(&end.as_str()), "{end}");
        // Every direction a click turns to is a face's or a corner's: none along an edge.
        for tg in &targets {
            let zeros = [tg.dir.x, tg.dir.y, tg.dir.z].iter().filter(|v| v.abs() < 1e-9).count();
            assert!(zeros == 2 || zeros == 0, "{}: {:?}", tg.name, tg.dir);
        }
    }

    #[test]
    fn construction_axes_span_the_model_and_points_show() {
        let mut s = solvecraft_engine::Session::default();
        s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
        s.execute("construct.axis.two_points", &json!({"a": {"vertex": [0, 0, 20]}, "b": {"vertex": [40, 30, 20]}})).unwrap();
        s.execute("construct.point.vertex", &json!({"point": {"vertex": [40, 0, 20]}})).unwrap();
        let mut app = SolveApp::new(s, crate::Services::default());
        let axes = construction_axis_segments(&app);
        assert_eq!(axes.len(), 1);
        let (name, a, b) = axes[0].clone();
        // The segment runs through both points and past them.
        let d = (b - a).normalized().unwrap();
        for p in [Vec3::new(0.0, 0.0, 20.0), Vec3::new(40.0, 30.0, 20.0)] {
            let t = (p - a).dot(d);
            assert!(t > 0.0 && t < a.dist(b) && (a + d * t).dist(p) < 1e-6, "{p:?} not on {a:?}..{b:?}");
        }
        assert_eq!(construction_points(&app).len(), 1);
        // It is an axis for dialogs (pattern directions, revolve axes), and hiding it hides it.
        let (o, dir) = crate::dialogs::axis_of(&app, &Sel::Axis { name: name.clone() }).unwrap();
        assert!(o.dist(Vec3::new(0.0, 0.0, 20.0)) < 1e-6 && dir.dist(d) < 1e-6);
        app.session.visibility.hidden_origin.push(name);
        assert!(construction_axis_segments(&app).is_empty());
    }
}