blockworx/render/

bounds.rs

//! Coarse, Painter-free world-space bounds for broad-phase spatial queries.
//!
//! [`Bounded::bounds`] returns a box enclosing an object's whole painted and
//! hittable footprint — including stub and label overhang — computed from pure
//! geometry plus a character-count text-width estimate. It never lays out a
//! galley, so it is cheap enough to compute for every object each time the
//! [`SpatialIndex`](crate::widget::spatial::SpatialIndex) is rebuilt. The shared
//! index (viewport culling + hit-testing) queries these bounds; the exact
//! fine-phase tests then decide the actual hit, so `bounds` only has to *not
//! under-cover* — a slightly generous box costs a few extra candidates, an
//! under-sized one would drop a real hit.

use crate::grid::{BLOCK_TYPE_TEXT_SIZE, GRID_SIZE, ROUTE_TEXT_SIZE, TITLE_TEXT_SIZE};
use crate::presentation::RouteGeometry;
use crate::shape::ShapeRef;
use crate::widget::auto_route::Wire;
use blockworx_geom::{Rect, vec2};

/// How far a shape's footprint can extend past its `gui_rect` from fixed-size
/// decorations: a pin stub reaches one `GRID_SIZE` out, and the widest point-snap
/// margin (`ROUTE_HIT_MARGIN`, ~0.9 grid) plus the tag rise sit within two cells.
/// Query rects are expanded by this before testing, and every indexed bound
/// already includes it.
pub const QUERY_MARGIN: f32 = GRID_SIZE * 2.0;

/// Conservative upper bound on a proportional glyph's advance as a fraction of
/// the font size — lets a label's width be estimated from its character count
/// without a galley. Biased high so the estimate never under-covers a real label.
const CHAR_ADVANCE: f32 = 0.75;

fn estimate_text_width(text: &str, size: f32) -> f32 {
    text.chars().count() as f32 * size * CHAR_ADVANCE
}

/// A world-space bounding box enclosing an object's whole painted/hittable
/// footprint, for broad-phase spatial queries. See the module docs.
pub trait Bounded {
    fn bounds(&self) -> Rect;
}

impl Bounded for ShapeRef<'_> {
    fn bounds(&self) -> Rect {
        shape_bounds_at(self, self.gui_rect())
    }
}

/// [`Bounded::bounds`] for a shape sitting at a hypothetical `rect` — where a
/// drag or resize is previewing it — so a supposed footprint is measured by the
/// same rule as a settled one.
pub fn shape_bounds_at(shape: &ShapeRef<'_>, rect: Rect) -> Rect {
    let mut r = rect;
    // The title is centered above/below the rect: a long one overhangs left
    // and right, and it always adds a line of height. (Pin names anchor
    // inward, so they are already inside `gui_rect`.)
    if let Some(title) = shape.title().filter(|t| !t.hidden) {
        let over_x =
            ((estimate_text_width(title.name, TITLE_TEXT_SIZE) - r.width()) / 2.0).max(0.0);
        r = r.expand2(vec2(over_x, TITLE_TEXT_SIZE));
    }
    // The type label is left-anchored at the top edge and grows rightward and
    // up, so a long one overhangs the right edge.
    if let Some(type_label) = shape
        .type_label()
        .filter(|t| !t.hidden && !t.name.is_empty())
    {
        let over_x =
            (estimate_text_width(type_label.name, BLOCK_TYPE_TEXT_SIZE) - r.width()).max(0.0);
        r.max.x += over_x;
        r.min.y -= BLOCK_TYPE_TEXT_SIZE;
    }
    r.expand(QUERY_MARGIN)
}

/// [`Bounded`] for a route: its painted footprint needs the solved geometry,
/// which lives beside the document, so it can't be a method on either half
/// alone.
pub fn route_bounds(wire: &Wire<'_>, geometry: &RouteGeometry) -> Rect {
    let mut r = Rect::from_points(&geometry.points());
    // A route label is centered on a point of the wire and extends by half its
    // width horizontally and a line vertically, so widen by that when present.
    if !wire.labels.is_empty() {
        let half_w = estimate_text_width(&wire.route.name, ROUTE_TEXT_SIZE) / 2.0;
        r = r.expand2(vec2(half_w, ROUTE_TEXT_SIZE));
    }
    r.expand(QUERY_MARGIN)
}