blockworx_egui/

painter.rs

use std::{cell::RefCell, rc::Rc, sync::Arc, time::Duration};

use blockworx_doc::block_model::Asset;
use blockworx_geom::{Align2, Pos2, Rect, Vec2, WorldPx};
use blockworx_paint::{
    AnimKey, Animator, Canvas, Color, Cursor, Easing, EditText, Font, ImageHandle, Palette,
    PaletteStroke, PointerKind, Renderer, Swatch, Tick, Vantage,
};
use egui::{CornerRadius, Stroke, StrokeKind, epaint::TextShape};

use crate::{
    convert::{IntoEgui as _, IntoGeom as _},
    icons::{Icon, Icons},
    image::ImageRegistry,
};

/// Cap on the pixel size an SVG/PNG is rasterized to, so a hugely zoomed image
/// can't ask the loader for an enormous texture.
const MAX_RASTER: u32 = 2048;

/// A transform-aware painter that accepts world-space coordinates and converts them
/// to screen space internally. All sizes — font sizes, stroke widths, radii, rounding —
/// scale with zoom so the diagram looks consistent at any zoom level. Unlike egui's
/// Scene (which applies a GPU-level pixel transform), we re-render at the correct
/// size each frame, so text and edges remain sharp.
pub struct Painter {
    inner: egui::Painter,
    origin: Pos2,
    /// Where the camera stands, and the whole of the world→screen transform
    /// this painter draws under. The math is [`Vantage`]'s so the recording
    /// canvas and this one cannot place a mark differently.
    vantage: Vantage,
    palette: Palette,
    cursor: Option<Cursor>,
    edit_text: Option<EditText>,
    /// Shared with the Canvas ([`View`](crate::View)), so an image
    /// registered once is drawn from the same table on every later frame.
    images: Rc<RefCell<ImageRegistry>>,
    /// Handles for the embedded UI icons (registered once at startup), so tools
    /// can draw them via [`Painter::icon`]. Nothing draws one yet; kept for the
    /// planned toolbar icons.
    icons: Icons,
    /// The session's keyed easings, shared with whoever owns them across
    /// frames: an easing that started on one painter is read back on the next.
    easing: Rc<RefCell<Easing>>,
    /// Whether this painter belongs to a scripted session rather than the
    /// live canvas, and where that session's synthetic pointer rests (world
    /// space).
    scripted: Option<ScriptedInput>,
}

/// A scripted session's input state, standing in for the real pointer.
#[derive(Clone, Copy)]
pub struct ScriptedInput {
    /// Where the session's synthetic events last put the pointer, in world
    /// space — what [`Painter::pointer_world`] reports so hover affordances
    /// light up under the demo cursor.
    pub pointer: Option<Pos2>,
}

impl Painter {
    // The frame's transform, its palette, and the three tables that outlive
    // it (images, icons, easings). Bundling them would name a struct after
    // "the arguments of this constructor", which is what the constructor is.
    #[expect(clippy::too_many_arguments)]
    pub fn new(
        inner: egui::Painter,
        origin: Pos2,
        vantage: Vantage,
        palette: Palette,
        images: Rc<RefCell<ImageRegistry>>,
        icons: Icons,
        easing: Rc<RefCell<Easing>>,
    ) -> Self {
        Self {
            inner,
            origin,
            vantage,
            palette,
            cursor: None,
            edit_text: None,
            images,
            icons,
            easing,
            scripted: None,
        }
    }

    /// A painter with no view transform: world coordinates pass straight through
    /// to `inner` (origin at zero, unity zoom, no translation) over a private
    /// image registry and the default icons. This is what the offline callers —
    /// the headless tool tests — want; a caller with a camera reaches for
    /// [`Painter::new`].
    ///
    /// `easing` is the caller's, not this painter's, because a painter lives
    /// one frame and an easing runs across many: a driver that hands the same
    /// table to successive frames animates the way the canvas does.
    #[cfg(any(test, feature = "test-support"))]
    pub fn headless(inner: egui::Painter, palette: Palette, easing: Rc<RefCell<Easing>>) -> Self {
        Self::new(
            inner,
            Pos2::ZERO,
            Vantage::resting(),
            palette,
            Rc::new(RefCell::new(ImageRegistry::default())),
            Icons::default(),
            easing,
        )
    }

    /// Mark this painter as a scripted session's: from here on,
    /// [`Painter::pointer_world`] reports the session's synthetic pointer
    /// rather than the user's real one.
    #[cfg(any(test, feature = "test-support"))]
    pub fn set_scripted(&mut self, input: ScriptedInput) {
        self.scripted = Some(input);
    }

    /// The pointer position in world space: the real pointer on the live
    /// canvas, the synthetic pointer in a scripted session. This is the seam
    /// hover affordances must read the pointer through — reading
    /// `ctx.input` directly would track the user's mouse inside the video.
    pub fn pointer_world(&self) -> Option<Pos2> {
        match &self.scripted {
            Some(input) => input.pointer,
            None => self
                .inner
                .ctx()
                .input(|i| i.pointer.interact_pos())
                .map(|p| self.screen_to_world(p.geom())),
        }
    }

    /// The registered handle for `icon`, or `None` if it failed to register.
    pub fn icon(&self, icon: Icon) -> Option<&ImageHandle> {
        self.icons.get(icon)
    }

    pub fn take_edit_text(&mut self) -> Option<EditText> {
        self.edit_text.take()
    }

    /// World-space position → screen-space position.
    fn w2s(&self, world: Pos2) -> Pos2 {
        self.vantage.world_to_screen(self.origin, world)
    }

    // ── Coordinate remapping (world → screen, no drawing) ──────────────────

    /// Convert a world-space rect to a screen-space rect.
    pub fn remap_rect(&self, rect: Rect) -> Rect {
        self.vantage.remap_rect(self.origin, rect)
    }

    /// Screen-space position → world-space position (the inverse of `w2s`). Lets
    /// a tool map raw pointer input (which egui reports in screen space) back into
    /// the world coordinates its geometry uses.
    pub fn screen_to_world(&self, screen: Pos2) -> Pos2 {
        self.vantage.screen_to_world(self.origin, screen)
    }

    /// Scale a world-space [`Font`] to screen space (i.e. multiply size by zoom).
    pub fn remap_font(&self, font: &Font) -> Font {
        self.vantage.remap_font(font)
    }

    /// Resolve a [`Swatch`] to a concrete color through the palette.
    fn color(&self, swatch: impl Into<Swatch>) -> Color {
        self.palette.resolve(swatch.into())
    }

    /// World-space length → screen-space length. The single place a world
    /// magnitude (radius, rounding, stroke width, wrap width) loses its unit.
    fn w2s_len(&self, len: WorldPx) -> f32 {
        self.vantage.remap_len(len)
    }

    /// Resolve a palette-based stroke to a concrete egui `Stroke`: width scaled
    /// by the current zoom, color resolved through the palette.
    fn scale_stroke(&self, stroke: impl Into<PaletteStroke>) -> Stroke {
        let s = stroke.into();
        Stroke::new(self.w2s_len(s.width), self.color(s.color).egui())
    }

    /// Lay out `text` at `base_font` scaled to the current zoom, returning the
    /// galley plus the screen-space vertical nudge that cancels epaint's
    /// per-pixel baseline snapping.
    ///
    /// Re-rasterizing at `font.size * zoom` keeps text crisp, but during layout
    /// epaint rounds each glyph's baseline to a whole physical pixel. As zoom
    /// sweeps continuously, that rounded baseline jumps a pixel at a time, which
    /// reads as a vertical "jiggle". The correction is the residual between the
    /// snapped baseline (`row.pos.y + glyph.pos.y`) and the font's unrounded
    /// ascent; shifting the draw position by it lands the first baseline at
    /// `top + ascent`, which moves continuously with zoom. Empty / whitespace
    /// rows have no glyph, so the correction is zero.
    fn layout_baseline_corrected(
        &self,
        text: String,
        base_font: &Font,
        color: Color,
    ) -> (Arc<egui::Galley>, f32) {
        let scaled = self.remap_font(base_font).egui();
        let galley = self.inner.layout_no_wrap(text, scaled, color.egui());
        let correction = galley
            .rows
            .first()
            .and_then(|r| {
                r.glyphs
                    .first()
                    .map(|g| g.font_ascent - (r.pos.y + g.pos.y))
            })
            .unwrap_or(0.0);
        (galley, correction)
    }

    /// Draw text at a world-space position, word-wrapped to `max_width`
    /// ([`WorldPx::UNBOUNDED`] for no wrap). Font size and position scale with
    /// zoom so text grows and shrinks with the diagram, re-rasterized at the
    /// correct size each frame so it stays crisp. Returns the screen-space
    /// bounding rect.
    ///
    /// epaint snaps each row's baseline to a whole physical pixel for crisp
    /// text, which makes a line "jiggle" vertically as zoom sweeps through pixel
    /// boundaries. The snap is applied per row and accumulates downward, so the
    /// lower lines of a multi-line block jiggle the most. To keep every line
    /// gliding smoothly we lay out and draw each row as its own galley, placing
    /// its baseline at a continuous `ascent + row * line_height` offset — font
    /// metrics that are rounded only to 1/32 pt, never to whole pixels.
    // `impl ToString` by value mirrors egui's own `Painter::text`, which this
    // wraps; taking a reference would make every call site differ from egui's.
    #[expect(clippy::needless_pass_by_value)]
    // Mirrors egui's `Painter::text(pos, anchor, text, font, color)`, extended with
    // the wrap width / rotation this canvas needs. Grouping these into a struct
    // would make every call site diverge from the API it wraps.
    #[expect(clippy::too_many_arguments)]
    fn draw_text_wrapped(
        &self,
        pos: Pos2,
        anchor: Align2,
        text: impl ToString,
        font: &Font,
        color: impl Into<Swatch>,
        max_width: WorldPx,
    ) -> Rect {
        let color = self.color(color).egui();
        let scaled = self.remap_font(font).egui();
        let wrap = self.w2s_len(max_width);

        // Lay out the whole block once: gives the anchored bounds (kept
        // identical to `text_size` so the box frame stays in sync) and the
        // per-row glyphs to redraw.
        let galley = self
            .inner
            .layout(text.to_string(), scaled.clone(), color, wrap);
        let rect = anchor.anchor_size(self.w2s(pos), galley.size().geom());

        // Continuous (non-pixel-snapped) line metrics, read from any glyph —
        // ascent and line height are font properties shared by every glyph of
        // the same format. No glyphs means nothing visible to draw.
        let Some(metrics) = galley.rows.iter().flat_map(|r| r.glyphs.iter()).next() else {
            return rect;
        };
        let (ascent, line_height) = (metrics.font_ascent, metrics.line_height);

        for (row, placed) in galley.rows.iter().enumerate() {
            // Reconstruct this row's text from its glyphs (the `\n` is omitted
            // and starts a fresh row), so the split matches egui exactly.
            let line: String = placed.glyphs.iter().map(|g| g.chr).collect();
            if line.is_empty() {
                continue; // blank line: nothing to draw, but it still spaces
            }
            let line_galley = self.inner.layout_no_wrap(line, scaled.clone(), color);
            // This row galley's own pixel-snapped baseline; subtracting it makes
            // the drawn baseline land exactly on the continuous target.
            let snapped = line_galley
                .rows
                .first()
                .and_then(|r| r.glyphs.first().map(|g| r.pos.y + g.pos.y))
                .unwrap_or(0.0);
            let baseline = rect.min.y + ascent + row as f32 * line_height;
            self.inner.galley(
                Pos2::new(rect.min.x, baseline - snapped).egui(),
                line_galley,
                color,
            );
        }
        rect
    }

    /// Measure `text` at `font` in world units, word-wrapped to `max_width`.
    // `impl ToString` by value mirrors egui's own `Painter::text`, which this
    // wraps; taking a reference would make every call site differ from egui's.
    #[expect(clippy::needless_pass_by_value)]
    fn measure_wrapped(&self, text: impl ToString, font: &Font, max_width: WorldPx) -> Vec2 {
        // Laid out to be measured, never painted, so the ink is the "recolor me"
        // sentinel rather than a color this module picked.
        let galley = self.inner.layout(
            text.to_string(),
            self.remap_font(font).egui(),
            Color::PLACEHOLDER.egui(),
            self.w2s_len(max_width),
        );
        galley.size().geom() / self.vantage.zoom.get()
    }

    /// Draw a registered image filling the world-space `rect`. The texture is
    /// pulled from egui's image loader by `handle.uri`; registration (the
    /// one-time `include_bytes`) happened on the Canvas, not here. On the first
    /// frames the loader may still be rasterizing, so request a repaint until it
    /// is `Ready`.
    fn draw_handle(&self, rect: Rect, handle: &ImageHandle) {
        let screen = self.remap_rect(rect);
        if screen.width() <= 0.0 || screen.height() <= 0.0 {
            return;
        }
        let ctx = self.inner.ctx();
        // Rasterize at the on-screen pixel size (capped) so the image stays
        // crisp; `maintain_aspect_ratio` keeps the image undistorted.
        let hint = egui::load::SizeHint::Size {
            width: (screen.width().ceil() as u32).clamp(1, MAX_RASTER),
            height: (screen.height().ceil() as u32).clamp(1, MAX_RASTER),
            maintain_aspect_ratio: true,
        };
        match ctx.try_load_texture(&handle.uri, egui::TextureOptions::LINEAR, hint) {
            Ok(egui::load::TexturePoll::Ready { texture }) => {
                let uv = Rect::from_min_max(Pos2::new(0.0, 0.0), Pos2::new(1.0, 1.0));
                // palette-exempt: egui's image tint is a multiplier, and
                // white is its identity — an untinted image, not a color.
                let untinted = Color::WHITE.egui();
                self.inner
                    .image(texture.id, screen.egui(), uv.egui(), untinted);
            }
            // Still decoding: ask for another frame so it appears once ready.
            Ok(egui::load::TexturePoll::Pending { .. }) => ctx.request_repaint(),
            // Unloadable image (bad bytes, missing loader): draw nothing.
            Err(_) => {}
        }
    }
}

/// The egui `Painter` is the on-screen [`Renderer`] backend: it converts each
/// world-space coordinate and magnitude to screen space (`w2s` / `w2s_len`) and
/// hands the result to egui.
impl Renderer for Painter {
    fn rect(
        &self,
        rect: Rect,
        rounding: WorldPx,
        fill: impl Into<Swatch>,
        stroke: impl Into<PaletteStroke>,
    ) {
        let screen = self.remap_rect(rect);
        let screen_rounding = CornerRadius::same(self.w2s_len(rounding).round().min(255.0) as u8);
        self.inner.rect(
            screen.egui(),
            screen_rounding,
            self.color(fill).egui(),
            self.scale_stroke(stroke),
            StrokeKind::Middle,
        );
    }

    fn line_segment(&self, points: [Pos2; 2], stroke: impl Into<PaletteStroke>) {
        self.inner.line_segment(
            [self.w2s(points[0]).egui(), self.w2s(points[1]).egui()],
            self.scale_stroke(stroke),
        );
    }

    fn line(&self, points: Vec<Pos2>, stroke: impl Into<PaletteStroke>) {
        let screen: Vec<egui::Pos2> = points.into_iter().map(|p| self.w2s(p).egui()).collect();
        self.inner.line(screen, self.scale_stroke(stroke));
    }

    fn circle(
        &self,
        center: Pos2,
        radius: WorldPx,
        fill: impl Into<Swatch>,
        stroke: impl Into<PaletteStroke>,
    ) {
        self.inner.circle(
            self.w2s(center).egui(),
            self.w2s_len(radius),
            self.color(fill).egui(),
            self.scale_stroke(stroke),
        );
    }

    fn add_convex_polygon(
        &self,
        points: Vec<Pos2>,
        fill: impl Into<Swatch>,
        stroke: impl Into<PaletteStroke>,
    ) {
        let screen: Vec<egui::Pos2> = points.into_iter().map(|p| self.w2s(p).egui()).collect();
        let stroke = self.scale_stroke(stroke);
        self.inner.add(egui::Shape::convex_polygon(
            screen,
            self.color(fill).egui(),
            stroke,
        ));
    }

    fn text(
        &self,
        pos: Pos2,
        anchor: Align2,
        text: impl ToString,
        font: &Font,
        color: impl Into<Swatch>,
    ) -> Rect {
        self.draw_text_wrapped(pos, anchor, text, font, color, WorldPx::UNBOUNDED)
    }

    fn text_wrapped(
        &self,
        pos: Pos2,
        anchor: Align2,
        text: impl ToString,
        font: &Font,
        color: impl Into<Swatch>,
        max_width: WorldPx,
    ) -> Rect {
        self.draw_text_wrapped(pos, anchor, text, font, color, max_width)
    }

    /// Draw text rotated by `angle` radians, centered on `pos` via `anchor`.
    /// Font size and position scale with zoom. Use `CENTER_CENTER` for the anchor
    /// to guarantee the text center stays at `pos` after rotation.
    fn rotated_text(
        &self,
        pos: Pos2,
        anchor: Align2,
        text: impl ToString,
        font: &Font,
        color: impl Into<Swatch>,
        angle: f32,
    ) {
        let color = self.color(color);
        let (galley, dy) = self.layout_baseline_corrected(text.to_string(), font, color);
        let shape = TextShape::new(
            (self.w2s(pos) + Vec2::new(0.0, dy)).egui(),
            galley,
            color.egui(),
        )
        .with_angle_and_anchor(angle, anchor.egui());
        self.inner.add(shape);
    }

    fn text_size(&self, text: impl ToString, font: &Font) -> Vec2 {
        self.measure_wrapped(text, font, WorldPx::UNBOUNDED)
    }

    fn text_size_wrapped(&self, text: impl ToString, font: &Font, max_width: WorldPx) -> Vec2 {
        self.measure_wrapped(text, font, max_width)
    }

    /// Draw the image `image` filling the world-space `rect`. The image is
    /// registered with the painter's shared `hash → handle` registry on first
    /// use (content-addressed, so repeat calls are cheap lookups), then drawn
    /// like any other registered image. The caller owns no handle — only the
    /// asset itself.
    fn draw_image(&self, rect: Rect, image: &Asset) {
        let Ok(handle) = self.images.borrow_mut().register(self.inner.ctx(), image) else {
            return;
        };
        self.draw_handle(rect, &handle);
    }

    /// The intrinsic point size of the image `image`, registering/looking it up
    /// in the shared registry. `None` if the bytes are not a valid SVG/PNG.
    fn image_intrinsic_size(&self, image: &Asset) -> Option<Vec2> {
        self.images
            .borrow_mut()
            .register(self.inner.ctx(), image)
            .ok()
            .map(|handle| handle.size)
    }

    fn animator(&self) -> Option<&dyn Animator> {
        Some(self)
    }

    fn visible_world_bounds(&self) -> Option<Rect> {
        let clip = self.inner.clip_rect().geom();
        Some(Rect::from_min_max(
            self.screen_to_world(clip.min),
            self.screen_to_world(clip.max),
        ))
    }
}

impl Animator for Painter {
    /// The table holds the value between frames and reads it half a predicted
    /// frame ahead, so polling every frame is what drives the easing — and a
    /// frame is asked for while one is still running.
    fn animate(&self, key: AnimKey, goal: f32, over: Duration) -> f32 {
        let (now, predicted_dt) = self.inner.ctx().input(|i| (i.time, i.predicted_dt));
        let tick = Tick::predicting(
            Duration::try_from_secs_f64(now).unwrap_or_default(),
            Duration::try_from_secs_f32(predicted_dt).unwrap_or_default(),
        );
        let animated = self.easing.borrow_mut().animate(tick, key, goal, over);
        if animated.in_progress {
            self.inner.ctx().request_repaint();
        }
        animated.value
    }

    fn pointer_world(&self) -> Option<Pos2> {
        Painter::pointer_world(self)
    }
}

impl Canvas for Painter {
    fn set_cursor(&mut self, cursor: Cursor) {
        self.cursor = Some(cursor);
    }

    fn cursor(&self) -> Option<Cursor> {
        self.cursor
    }

    fn set_edit_text(&mut self, edit: EditText) {
        self.edit_text = Some(edit);
    }

    fn remap_rect(&self, world: Rect) -> Rect {
        Painter::remap_rect(self, world)
    }

    fn request_repaint(&self) {
        self.inner.ctx().request_repaint();
    }

    fn request_repaint_after(&self, after: Duration) {
        self.inner.ctx().request_repaint_after(after);
    }

    fn now(&self) -> Duration {
        // A clock that ran backwards would be a broken host, not a lost frame:
        // fall back to zero rather than take the drawing down with it.
        Duration::try_from_secs_f64(self.inner.ctx().input(|i| i.time)).unwrap_or_default()
    }

    fn pointer_kind(&self) -> PointerKind {
        if self.inner.ctx().input(egui::InputState::has_touch_screen) {
            PointerKind::Touch
        } else {
            PointerKind::Mouse
        }
    }

    fn image(&self, rect: Rect, handle: &ImageHandle) {
        self.draw_handle(rect, handle);
    }
}