blockworx_editor/render/

route.rs

use blockworx_doc::block_model::Route;
use blockworx_doc::id::RouteLabelId;
use blockworx_geom::{Align2, Angle, Pos2, vec2};

use crate::{
    edit::{lower::accent_from_role, naming::InterfaceLock},
    grid::{PORT_RADIUS, SHIM, px_point},
    presentation::{Crossing, LocAndDirection, RouteDirection},
    theme::{Role, RoleStroke, Style, accent_role},
    widget::auto_route::{RouteGeometry, Wire, text_anchors},
};
use blockworx_paint::Renderer;

use super::{ADD_ROUTE_LABEL_PLACEHOLDER, render_path_with_chamfered_corners};
use crate::edit::naming::Authoring;

/// Which of its labels a route render includes. A tool that draws a label
/// itself — dragged, or under an in-place editor — leaves that one out.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum LabelPass {
    Draw,
    Skip,
    /// Every label but this one.
    Omit(RouteLabelId),
}

impl LabelPass {
    fn draws(self, label: RouteLabelId) -> bool {
        match self {
            LabelPass::Draw => true,
            LabelPass::Skip => false,
            LabelPass::Omit(left_out) => left_out != label,
        }
    }
}

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum RouteRenderMode {
    Normal,
    Highlighted,
    Selected {
        /// Whether the wire's editing affordances — waypoint handles and the
        /// text anchors a new label attaches to — come with the halo. A
        /// read-only session shows the selection without them.
        authoring: Authoring,
    },
    /// Mid-edit: the selection halo without the stored waypoint handles and
    /// text anchors — the editing tool draws its *working* corner set instead,
    /// which the document does not hold until the edit commits.
    Editing,
}

fn draw_text_anchor(
    painter: &mut Style<'_, impl Renderer>,
    ta: Pos2,
    fill: Role,
    stroke: impl Into<RoleStroke>,
) {
    painter.add_convex_polygon(
        [
            ta + vec2(0.0, -PORT_RADIUS.get()),
            ta + vec2(PORT_RADIUS.get(), 0.0),
            ta + vec2(0.0, PORT_RADIUS.get()),
            ta + vec2(-PORT_RADIUS.get(), 0.0),
        ]
        .into(),
        fill,
        stroke,
    );
}

/// Resting wire width, world units.
const ROUTE_WIDTH: f32 = 1.7;
/// Wire width when hovered, world units.
const ROUTE_HOVER_WIDTH: f32 = 2.3;
/// Width of the foreground halo drawn behind a selected route, world units —
/// wide enough to peek out either side of the resting wire on top of it.
const ROUTE_SELECTION_HALO_WIDTH: f32 = 2.8;

/// World-space anchor where a *horizontal* route label is drawn (its bottom
/// center, nudged up off the wire). Shared with the in-place editor so it can
/// sit exactly over the text it replaces.
pub fn horizontal_label_anchor(pos: Pos2) -> Pos2 {
    pos + vec2(0.0, -SHIM / 4.0)
}

/// The color `route`'s label text takes under `mode`: the wire's accent when
/// set, else the mode's resting or highlight color.
pub fn route_text_color(route: &Route, mode: RouteRenderMode) -> Role {
    let accent = accent_role(accent_from_role(route.role));
    match mode {
        RouteRenderMode::Highlighted => accent.unwrap_or(Role::RouteHighlighted),
        _ => accent.unwrap_or(Role::RouteNormal),
    }
}

/// Draw one of `route`'s labels at `at`, oriented along the wire there. An
/// unnamed route shows the faint "add name" prompt (mirroring the pin
/// placeholder); a named one shows the name in `color`.
pub fn render_route_label_at(
    painter: &mut Style<'_, impl Renderer>,
    route: &Route,
    at: LocAndDirection,
    color: Role,
) {
    let name = route.name.as_str();
    let (text, color) = if name.is_empty() {
        (ADD_ROUTE_LABEL_PLACEHOLDER, Role::PinLabelPlaceholder)
    } else {
        (name, color)
    };
    let route_font = &painter.theme().route_font;
    match at.direction {
        RouteDirection::Horizontal => {
            painter.text(
                horizontal_label_anchor(at.location),
                Align2::CENTER_BOTTOM,
                text,
                route_font,
                color,
            );
        }
        RouteDirection::Vertical => {
            let text_size = painter.text_size(text, route_font);
            painter.rotated_text(
                at.location + vec2(text_size.y + SHIM / 4.0, -text_size.x / 2.0),
                Align2::LEFT_TOP,
                text,
                route_font,
                color,
                Angle::QUARTER_TURN,
            );
        }
    }
}

/// Draw waypoint handles: a user-pinned (locked) corner prominently, a
/// structural bend the router laid down faint and small.
pub fn render_waypoint_handles(
    painter: &mut Style<'_, impl Renderer>,
    handles: impl IntoIterator<Item = (Pos2, InterfaceLock)>,
) {
    for (pos, lock) in handles {
        let (radius, fill) = if lock.is_locked() {
            (PORT_RADIUS, Role::WaypointFill)
        } else {
            (PORT_RADIUS * 0.6, Role::ControlHandleFill)
        };
        painter.circle(pos, radius, fill, (0.5, Role::ControlHandleStroke));
    }
}

/// Draw a route's text-anchor diamonds (the spots a new label can attach).
pub fn render_text_anchors(
    painter: &mut Style<'_, impl Renderer>,
    anchors: impl IntoIterator<Item = Pos2>,
) {
    for ta in anchors {
        draw_text_anchor(
            painter,
            ta,
            Role::WaypointFill,
            (0.5, Role::ControlHandleStroke),
        );
    }
}

/// Where a wire is drawn: its solved geometry, and the hops it makes over the
/// wires it crosses. The hops depend on the wires around it, so the caller
/// computes them over what it draws ([`crate::widget::drawing::Drawing::hops`]).
#[derive(Clone, Copy)]
pub struct Course<'a> {
    pub geometry: &'a RouteGeometry,
    pub hops: &'a [Crossing],
}

pub fn render_route(
    painter: &mut Style<'_, impl Renderer>,
    wire: &Wire<'_>,
    Course { geometry, hops }: Course<'_>,
    mode: RouteRenderMode,
    labels: LabelPass,
) {
    let route = wire.route;
    let accent = accent_role(accent_from_role(route.role));
    // The wire's resting color: its accent if set, else the normal route color.
    // The accent wins over the mode color; hover/select add their own emphasis.
    let wire_color = accent.unwrap_or(Role::RouteNormal);
    let points = render_path_with_chamfered_corners(&geometry.points());
    match mode {
        RouteRenderMode::Normal => {
            points.render_with_hops(painter, (ROUTE_WIDTH, wire_color), hops);
        }
        RouteRenderMode::Highlighted => {
            let hl = accent.unwrap_or(Role::RouteHighlighted);
            points.render_with_hops(painter, (ROUTE_HOVER_WIDTH, hl), hops);
        }
        RouteRenderMode::Selected { .. } | RouteRenderMode::Editing => {
            // A wider foreground halo underneath, then the resting wire on top.
            points.render_with_hops(
                painter,
                (ROUTE_SELECTION_HALO_WIDTH, Role::RouteSelected),
                hops,
            );
            points.render_with_hops(painter, (ROUTE_WIDTH, wire_color), hops);
        }
    }
    let color = route_text_color(route, mode);
    for &(_, label) in wire.labels.iter().filter(|(id, _)| labels.draws(*id)) {
        let at = geometry.map_linear_distance_to_position(label);
        render_route_label_at(painter, route, at, color);
    }
    if matches!(
        mode,
        RouteRenderMode::Selected {
            authoring: Authoring::Offered
        }
    ) {
        // Every corner is a waypoint. `Editing` deliberately skips these: the
        // stored set is stale mid-drag, so the tool draws its working set.
        render_waypoint_handles(
            painter,
            route.waypoints.iter().map(|wp| {
                let lock = if wp.locked {
                    InterfaceLock::Locked
                } else {
                    InterfaceLock::Unlocked
                };
                (px_point(wp.pos), lock)
            }),
        );
        render_text_anchors(painter, text_anchors(&wire.labels, geometry));
    }
}