brep_render/engine_state/

plane_pick.rs

use super::*;

// ===========================================================================
// Construction PLANES as ordinary pick candidates.
//
// A construction plane / DATUM base plane is drawn by the datum WIDGET, not by
// the scene, so `pick::pick` — which walks the render scene's solids — can never
// see one. Before this module a plane was reachable only through the independent
// `datum_pick` widget path, and ONLY when the geometry pick missed: any face,
// edge or vertex under the pointer won outright and the plane was unreachable
// (the reported "I can't select a plane if there is any other geometry under the
// pointer"). Here the plane cards are turned into ordinary
// [`pick::PickCandidate`]s and merged into the SAME ranked list every selection
// path consumes, so a plane competes for a pick like any other entity and shows
// up in the pick-list popup like any face.
//
// HOW A PLANE COMPETES — by KIND, not by depth. The candidate list is sorted
// category-major in the pick-list order
//
//     VERTEX > EDGE > FACE > PLANE > SOLID > COMPONENT
//
// (the `PickKind` discriminant order), nearest-first within a category. So a
// plane ranks straight after faces: any face under the cursor still out-priorities
// it, and the plane cannot swallow a click meant for the model — while it is
// nonetheless IN the list, one row down, reachable through anything. Pure depth
// ordering was rejected precisely because it trades one complaint for its mirror
// image: a plane card in front of the model would win every click near it, and a
// plane behind the model would still lose at a grazing angle.
//
// WHAT COUNTS AS "ON" A PLANE — the drawn rectangle. A construction plane is
// mathematically infinite, but only the card the renderer draws is pickable
// ([`crate::widgets::WidgetRegistry::datum_plane_hits`] → `DatumPlane::hit_point`,
// the same live-camera `half()` extent `build_main_overlay` draws with — never a
// bake, so the pickable region tracks the drawn one across a zoom). Either face
// of the card picks: a plane seen from behind is still a legitimate selection.
//
// DATUMS RIDE ALONG. `refresh_construction_datums` feeds D (datum) and P (plane)
// features through the one `{planes:[…]}` channel — a DATUM contributes its three
// base planes (`{id}:XY|XZ|YZ`), a PLANE its single frame (`{id}`) — so both are
// `PickKind::Plane` candidates with no extra machinery. Datum AXES are not fed by
// that path and stay out of the pick list.
// ===========================================================================

impl EngineState {
    /// EVERY pick candidate under CSS-pixel `(x, y)`: the scene's
    /// vertices/edges/faces/solids ([`pick::pick`]) PLUS the construction PLANE
    /// cards the pointer ray crosses, ranked together category-major
    /// (VERTEX > EDGE > FACE > PLANE > SOLID > COMPONENT), nearest first within a
    /// category.
    ///
    /// This is the RAW list (no selection filter); the filter-honoring callers are
    /// [`Self::candidates_filtered_at`] (the pick-list popup) and
    /// [`Self::pick_top_at`] (every single-hit pick).
    pub fn pick_candidates_at(&self, x: f64, y: f64) -> Vec<pick::PickCandidate> {
        let mut out = pick::pick(&self.scene, &self.camera, x, y, &self.pick_options());
        // Appended AFTER `pick`'s own `MAX_CANDIDATES` truncation, so a plane is
        // never dropped by a crowd of faces under the same pixel.
        out.extend(self.plane_candidates_at(x, y));
        sort_pick_candidates(&mut out);
        out
    }

    /// The construction PLANE candidates under CSS-pixel `(x, y)` — one per DRAWN
    /// datum-plane card the pointer ray crosses, carrying the datum FRAME name
    /// (`Pl`, `Datum:XY`) and the world hit point. `solid` is empty (a plane has no
    /// owning solid) and `screen_dist` is 0 (a card hit is exact, like a face hit).
    ///
    /// Hidden planes are absent by construction: the widget feed
    /// ([`Self::refresh_construction_datums`]) only carries the planes that are
    /// actually drawn, so a Scene-tree-hidden or rolled-back plane cannot be picked.
    pub(super) fn plane_candidates_at(&self, x: f64, y: f64) -> Vec<pick::PickCandidate> {
        let cam = gizmo_camera(&self.camera);
        let (_, _, forward) = self.camera.basis();
        self.widgets
            .datum_plane_hits(&cam, x as f32, y as f32)
            .into_iter()
            .map(|(name, point)| {
                let position = [point[0] as f64, point[1] as f64, point[2] as f64];
                pick::PickCandidate {
                    kind: pick::PickKind::Plane,
                    name,
                    solid: String::new(),
                    depth: crate::view::dot3(
                        crate::view::sub3(position, self.camera.eye),
                        forward,
                    ),
                    screen_dist: 0.0,
                    position,
                }
            })
            .collect()
    }

    /// The TOP-ranked candidate under `(x, y)` whose kind `kinds` admits — the
    /// planes-aware replacement for [`pick::pick_filtered`] (which only sees the
    /// render scene). An EMPTY `kinds` means any kind, matching `pick_filtered`.
    ///
    /// `DATUM` is accepted as an alias of `PLANE` so a reference field whose schema
    /// spells its construction kind `["DATUM"]` picks the same plane cards as
    /// `["PLANE"]` (`ref_select_click` passes the field's RAW strings here).
    pub(super) fn pick_top_at(
        &self,
        x: f64,
        y: f64,
        kinds: &[String],
    ) -> Option<pick::PickCandidate> {
        self.pick_candidates_at(x, y)
            .into_iter()
            // EMPTY = any kind, [`pick::pick_filtered`]'s rule (the callers that
            // mean "select nothing" guard on an empty list BEFORE calling).
            .find(|c| kinds.is_empty() || self.candidate_admitted(kinds, c))
    }

    /// Does `kinds` admit this CANDIDATE? [`kind_admitted`] plus the one
    /// distinction the picker cannot make on its own: a committed SKETCH is drawn
    /// as a synthesized sheet solid, so it and a real body arrive with the same
    /// [`pick::PickKind::Solid`]. `SolidDisplay::is_sketch` splits them, and the
    /// candidate then answers to `"SKETCH"` or to `"SOLID"` — never to both.
    ///
    /// Only the whole-object candidate is reclassified. A sketch's planar FACE and
    /// its drawn EDGES keep their own kinds, which is what the profile fields
    /// (`["SKETCH","FACE"]`, picking a sketch through its sheet face) and the path
    /// fields (`["EDGE"]` on path sweep, picking a sketch curve) rely on.
    pub(super) fn candidate_admitted(
        &self,
        kinds: &[String],
        candidate: &pick::PickCandidate,
    ) -> bool {
        if candidate.kind == pick::PickKind::Solid && self.candidate_is_sketch(candidate) {
            return kinds.iter().any(|k| k.eq_ignore_ascii_case("SKETCH"));
        }
        kind_admitted(kinds, candidate.kind)
    }

    /// The kind LABEL a candidate should present under — `PickKind::as_str`,
    /// except that a committed-sketch sheet reads `"SKETCH"` rather than the
    /// `"SOLID"` its `PickKind` carries. The pick-list popup and the published
    /// candidate JSON both use it, so what a row calls itself matches the filter
    /// lane that admitted it.
    pub fn candidate_kind_label(&self, candidate: &pick::PickCandidate) -> &'static str {
        if candidate.kind == pick::PickKind::Solid && self.candidate_is_sketch(candidate) {
            return "SKETCH";
        }
        candidate.kind.as_str()
    }

    /// Whether a candidate's owning scene solid is a committed-sketch SHEET.
    pub(super) fn candidate_is_sketch(&self, candidate: &pick::PickCandidate) -> bool {
        let name = if candidate.solid.is_empty() {
            candidate.name.as_str()
        } else {
            candidate.solid.as_str()
        };
        self.scene
            .solid(name)
            .is_some_and(|solid| solid.is_sketch)
    }
}

/// Does `kinds` LIST `kind`? Case-insensitive, with `DATUM` as an alias of
/// `PLANE`. Kind-only, so it cannot tell a committed-sketch sheet from a real
/// body — [`EngineState::candidate_admitted`] is the candidate-aware wrapper every
/// picking path actually calls. STRICT: an empty list admits nothing (the "empty = any kind"
/// convenience belongs to the single-hit [`EngineState::pick_top_at`] alone — the
/// pick-LIST builder passes an empty list to mean "no sub-entity kind is
/// admitted", e.g. a COMPONENT-only filter).
pub(super) fn kind_admitted(kinds: &[String], kind: pick::PickKind) -> bool {
    let name = kind.as_str();
    let datum_alias = kind == pick::PickKind::Plane;
    kinds
        .iter()
        .any(|k| k.eq_ignore_ascii_case(name) || (datum_alias && k.eq_ignore_ascii_case("DATUM")))
}

/// The ONE candidate ordering every pick path shares: category-major in the
/// pick-list order (`PickKind`'s discriminant order IS that order —
/// VERTEX > EDGE > FACE > PLANE > SOLID > COMPONENT), nearest (smallest depth)
/// first within a category, then by screen distance. Stable, so equal-depth
/// entries keep the ray ranker's order.
pub(super) fn sort_pick_candidates(candidates: &mut [pick::PickCandidate]) {
    candidates.sort_by(|a, b| {
        (a.kind as u8)
            .cmp(&(b.kind as u8))
            .then(a.depth.total_cmp(&b.depth))
            .then(a.screen_dist.total_cmp(&b.screen_dist))
    });
}

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

    /// A cube spanning 0..10 (index 0) + a DATUM at the world origin (index 1),
    /// whose three base planes are cards centred on `[0,0,0]` — i.e. at the cube's
    /// near-bottom-left CORNER, so a pixel can land on a plane card WITH cube faces
    /// behind it (the reported bug's geometry).
    fn cube_and_datum_history() -> String {
        serde_json::json!({
            "features": [
                {
                    "type": "P.CU",
                    "inputParams": {
                        "id": "Box",
                        "sizeX": 10.0, "sizeY": 10.0, "sizeZ": 10.0,
                        "transform": {
                            "position": [0.0, 0.0, 0.0],
                            "rotationEuler": [0.0, 0.0, 0.0],
                            "scale": [1.0, 1.0, 1.0]
                        },
                        "boolean": { "targets": [], "operation": "NONE" }
                    },
                    "persistentData": {}
                },
                { "type": "D", "inputParams": { "id": "Datum" }, "persistentData": {} }
            ]
        })
        .to_string()
    }

    /// The cube+datum framed straight down −Z with the viewport centre aimed at
    /// `[1.2, 1.2, 5]`: the centre pixel is ~36 CSS px from the datum origin's
    /// projection (inside the XY card's 70 px half-extent) and ~36 px from the
    /// cube's nearest edges (well outside the 6 px edge/vertex threshold), so the
    /// pixel carries cube FACES *and* the datum plane — and nothing else.
    fn engine_with_a_plane_over_the_cube() -> EngineState {
        let mut engine = EngineState::new();
        engine.set_history_json(&cube_and_datum_history()).unwrap();
        engine.resize(800.0, 600.0);
        engine.camera.eye = [1.2, 1.2, 60.0];
        engine.camera.target = [1.2, 1.2, 5.0];
        engine.camera.up = [0.0, 1.0, 0.0];
        // half_height 10 over 600 px → 30 px per world unit.
        engine.camera.projection = crate::view::Projection::Orthographic { half_height: 10.0 };
        engine
    }

    /// THE REPORTED BUG: a construction plane with geometry under the pointer.
    /// The plane is now an ordinary entry in the pick list (right after the faces,
    /// before the solid), and selecting that entry selects the datum — where before
    /// the plane was unreachable because the geometry pick won and the `datum_pick`
    /// fallback only ran on a MISS.
    #[test]
    fn a_plane_under_geometry_is_pickable() {
        let mut engine = engine_with_a_plane_over_the_cube();
        let cands = engine.candidates_filtered_at(400.0, 300.0);

        // Faces of the cube ARE under this pixel (the bug's precondition: without
        // the fix the plane loses to them and never appears).
        assert!(
            cands.iter().any(|c| c.kind == pick::PickKind::Face),
            "the pixel must have geometry under it: {cands:?}"
        );
        // …and the XY datum plane is listed exactly once (XZ/YZ are edge-on).
        let planes: Vec<&pick::PickCandidate> = cands
            .iter()
            .filter(|c| c.kind == pick::PickKind::Plane)
            .collect();
        assert_eq!(planes.len(), 1, "one plane candidate: {cands:?}");
        assert_eq!(planes[0].name, "Datum:XY");

        // Ordering: category-major, so every FACE precedes the PLANE and the PLANE
        // precedes the SOLID entry.
        let ranks: Vec<u8> = cands.iter().map(|c| c.kind as u8).collect();
        assert!(ranks.windows(2).all(|w| w[0] <= w[1]), "category-major: {ranks:?}");
        let plane_at = cands
            .iter()
            .position(|c| c.kind == pick::PickKind::Plane)
            .unwrap();
        assert!(
            cands[..plane_at].iter().all(|c| c.kind == pick::PickKind::Face),
            "faces rank ahead of the plane: {cands:?}"
        );
        assert!(
            cands[plane_at + 1..]
                .iter()
                .all(|c| c.kind == pick::PickKind::Solid),
            "the plane ranks ahead of the solid: {cands:?}"
        );
        // A plane's frame name has the `A:B` shape of a component-namespaced solid
        // (`ACOMP2:Part`), so it must NOT be promoted to a phantom COMPONENT row.
        assert!(
            cands.iter().all(|c| c.kind != pick::PickKind::Component),
            "a plane name is not a component: {cands:?}"
        );

        // Picking the plane entry selects the DATUM (the same selection a
        // Scene-tree row click makes) and drops the geometry selection.
        let plane = planes[0].clone();
        assert!(!engine.candidate_is_selected(&plane));
        engine.select_candidate(&plane);
        assert!(engine.candidate_is_selected(&plane));
        let sel: serde_json::Value = serde_json::from_str(&engine.selection_json()).unwrap();
        assert_eq!(sel["datums"], serde_json::json!(["Datum:XY"]), "{sel}");
        assert!(sel["faces"].as_array().unwrap().is_empty(), "{sel}");
        // The fed plane carries the selection accent (the widget's `hot` flag).
        assert!(
            engine
                .widgets
                .datum_plane_names()
                .iter()
                .any(|(n, hot)| *n == "Datum:XY" && *hot),
            "the selected plane is emphasized"
        );
    }

    /// The FILTER gates planes exactly like faces: unchecking Plane removes every
    /// plane entry (and the plane stops being pickable at all), while the geometry
    /// under the same pixel still picks. Re-checking restores it.
    #[test]
    fn the_plane_filter_gates_plane_picking() {
        let mut engine = engine_with_a_plane_over_the_cube();
        let mut filter = engine.selection_filter();
        assert!(filter.plane, "planes are pickable by default");

        // Plane OFF: no plane candidate, and a plane-only filter picks nothing.
        filter.plane = false;
        engine.set_selection_filter(filter);
        let cands = engine.candidates_filtered_at(400.0, 300.0);
        assert!(
            cands.iter().all(|c| c.kind != pick::PickKind::Plane),
            "unchecking Plane must exclude planes: {cands:?}"
        );
        assert!(!cands.is_empty(), "the geometry under the pixel still lists");
        // A click still reaches the face behind the (now unpickable) plane.
        assert!(engine.select_top_at(400.0, 300.0));
        let sel: serde_json::Value = serde_json::from_str(&engine.selection_json()).unwrap();
        assert_eq!(sel["faces"].as_array().unwrap().len(), 1, "{sel}");
        assert!(sel["datums"].as_array().unwrap().is_empty(), "{sel}");

        // Plane back ON with EVERYTHING else off: the same pixel now picks the
        // plane directly (no face out-priorities it any more).
        engine.set_selection_filter(SelectionFilter {
            solid: false,
            sketch: false,
            face: false,
            edge: false,
            vertex: false,
            plane: true,
            component: false,
        });
        assert!(engine.select_top_at(400.0, 300.0), "plane-only picks the plane");
        let sel: serde_json::Value = serde_json::from_str(&engine.selection_json()).unwrap();
        assert_eq!(sel["datums"], serde_json::json!(["Datum:XY"]), "{sel}");
    }

    /// Only the DRAWN rectangle is pickable, though the plane is mathematically
    /// infinite: a pixel far from the card — but still on the infinite XY plane —
    /// yields no plane candidate. And the card is picked from EITHER side.
    #[test]
    fn only_the_drawn_card_is_pickable_and_from_both_sides() {
        let mut engine = engine_with_a_plane_over_the_cube();
        // The card's half-extent is 70 CSS px; (700, 300) is 300 px right of the
        // centre, far outside it, yet the ray still crosses the infinite XY plane.
        assert!(
            engine.plane_candidates_at(700.0, 300.0).is_empty(),
            "outside the drawn card is a miss"
        );
        let front = engine.plane_candidates_at(400.0, 300.0);
        assert_eq!(front.len(), 1, "on the card is a hit");

        // Same pixel from the OPPOSITE side (camera swung to −Z): the reverse face
        // of the card is still pickable.
        engine.camera.eye = [1.2, 1.2, -50.0];
        engine.camera.target = [1.2, 1.2, 5.0];
        let back = engine.plane_candidates_at(400.0, 300.0);
        assert_eq!(back.len(), 1, "the card picks from behind too");
        assert_eq!(back[0].name, front[0].name);
    }

    /// Hover follows the same ranked list: the top admitted candidate lights up,
    /// so a plane-only filter hover-highlights the plane card (and moving off it
    /// clears the highlight). The unchanged-hover early-out still holds, so a
    /// stationary pointer does not churn frames.
    #[test]
    fn hover_lights_a_plane_and_clears() {
        let mut engine = engine_with_a_plane_over_the_cube();
        engine.set_selection_filter(SelectionFilter {
            solid: false,
            sketch: false,
            face: false,
            edge: false,
            vertex: false,
            plane: true,
            component: false,
        });
        assert!(engine.hover_at(400.0, 300.0), "hover set");
        assert!(engine.emphasis.hovered_datums.contains("Datum:XY"));
        assert!(
            engine
                .widgets
                .datum_plane_names()
                .iter()
                .any(|(n, hot)| *n == "Datum:XY" && *hot),
            "the hovered plane is emphasized"
        );
        assert!(!engine.hover_at(400.0, 300.0), "unchanged hover → no change");
        assert!(engine.hover_at(700.0, 300.0), "moving off the card clears");
        assert!(engine.emphasis.hovered_datums.is_empty());
        assert!(
            engine
                .widgets
                .datum_plane_names()
                .iter()
                .all(|(_, hot)| !*hot),
            "the accent is dropped on hover-out"
        );
        assert!(!engine.has_selection(), "hover never selects");
    }

    /// The REFERENCE-FIELD flow (a sketch's `["PLANE","FACE"]` `sketchPlane`) now
    /// runs through the same ranked list, and its precedence is unchanged: a FACE
    /// under the cursor still wins (the field is not hijacked by the plane card
    /// over the model), while a pixel on the card alone picks the plane. The modal
    /// has no pick list, so the top admitted candidate is the pick — exactly what
    /// the old geometry-miss fallback produced, minus the fallback.
    #[test]
    fn ref_select_plane_face_field_keeps_faces_first() {
        let mut engine = engine_with_a_plane_over_the_cube();
        engine.begin_ref_select(
            "Sk",
            vec!["sketchPlane".to_string()],
            "Sketch plane".to_string(),
            vec!["PLANE".to_string(), "FACE".to_string()],
            false,
            Vec::new(),
        );
        // The constrained filter admits planes AND faces — and nothing else.
        let f = engine.selection_filter();
        assert!(f.plane && f.face && !f.solid && !f.edge && !f.vertex, "{f:?}");

        // Over the cube: the FACE wins, as before.
        engine.ref_select_click(400.0, 300.0);
        let picked = engine.ref_select_names();
        assert_eq!(picked.len(), 1, "one pick: {picked:?}");
        assert!(
            engine.scene.solids()[0].faces.iter().any(|face| face.name == picked[0]),
            "a face under the cursor still out-priorities the plane: {picked:?}"
        );

        // On the plane card with NO geometry behind it (the cube spans 0..10, so a
        // pixel left of x=0 clears it while staying inside the 70 px card):
        // the plane is picked, by frame name.
        engine.ref_select_click(360.0, 300.0);
        assert_eq!(
            engine.ref_select_names(),
            vec!["Datum:XY".to_string()],
            "the card picks the construction plane"
        );
    }

    /// Ctrl/Cmd+click TOGGLES a plane in and out of the selection like any other
    /// candidate, and a plane pick supersedes a geometry selection (they share the
    /// one selection).
    #[test]
    fn toggle_adds_and_removes_a_plane() {
        let mut engine = engine_with_a_plane_over_the_cube();
        let plane = engine
            .candidates_filtered_at(400.0, 300.0)
            .into_iter()
            .find(|c| c.kind == pick::PickKind::Plane)
            .expect("a plane candidate");
        assert!(engine.toggle_candidate(&plane), "added");
        assert!(engine.candidate_is_selected(&plane));
        assert!(!engine.toggle_candidate(&plane), "removed");
        assert!(!engine.candidate_is_selected(&plane));
        assert!(!engine.has_selection());
    }
}