yog-ui 0.42.0

//! GPU rendering for the UI tree via `yog-gfx` draw2d.
//! Only valid inside `on_hud_render`.

use crate::layout::{LayoutNode, Rect};
use crate::text;
use crate::widget::{self, FocusStyle, SLOT_SIZE, Style, Widget, WidgetKind};
use yog_gfx::GfxContext;
use yog_gfx::draw2d::Draw2D;

/// Scrollbar track and knob colors.
const TRACK_COLOR: u32 = 0x44_000000;
const KNOB_COLOR: u32 = 0xAA_888888;
/// Item slot: border and face.
const ITEM_SLOT_BORDER: u32 = 0xFF_444444;
const ITEM_SLOT_FACE: u32 = 0xFF_888888;
/// Inventory slot (vanilla's): face, top/left shadow, bottom/right light.
const INV_SLOT_FACE: u32 = 0xFF_8B8B8B;
const INV_SLOT_SHADOW: u32 = 0xFF_373737;
const INV_SLOT_LIGHT: u32 = 0xFF_FFFFFF;
/// Stack count text color.
const COUNT_COLOR: u32 = 0xFF_FFFFFF;
/// Side of an item icon inside a slot (1 px inset).
const ICON_SIZE: f32 = 16.0;
/// Slack for "drawn whole or not at all" clip checks — absorbs rounding.
pub(crate) const CLIP_SLACK: f32 = 0.5;

/// Recursively render a widget tree starting from the computed layout.
pub fn render_node(gfx: &GfxContext, d2d: &Draw2D, widget: &Widget, node: &LayoutNode) {
    render_clipped(gfx, d2d, widget, node, None);
}

/// Fills `x0..x1 × y0..y1`, cut to `clip`.
fn fill(d2d: &Draw2D, clip: Option<Rect>, x0: f32, y0: f32, x1: f32, y1: f32, color: u32) {
    let r = Rect {
        x: x0,
        y: y0,
        w: x1 - x0,
        h: y1 - y0,
    };
    let r = match clip {
        Some(c) => match r.intersect(&c) {
            Some(r) => r,
            None => return,
        },
        None => r,
    };
    d2d.rect(r.x, r.y, r.x + r.w, r.y + r.h, color);
}

fn fill_rect(d2d: &Draw2D, clip: Option<Rect>, r: Rect, color: u32) {
    fill(d2d, clip, r.x, r.y, r.x + r.w, r.y + r.h, color);
}

/// A 1 px border just inside `r`, cut to `clip`.
fn outline(d2d: &Draw2D, clip: Option<Rect>, r: Rect, color: u32) {
    fill(d2d, clip, r.x, r.y, r.x + r.w, r.y + 1.0, color);
    fill(d2d, clip, r.x, r.y + r.h - 1.0, r.x + r.w, r.y + r.h, color);
    fill(d2d, clip, r.x, r.y, r.x + 1.0, r.y + r.h, color);
    fill(d2d, clip, r.x + r.w - 1.0, r.y, r.x + r.w, r.y + r.h, color);
}

/// Whether a box spanning `y..y + h` lies inside `clip` vertically (text
/// lines and item icons can't be cut, so they're drawn whole or not at all).
/// [`CLIP_SLACK`] absorbs rounding.
fn fits(clip: Option<Rect>, y: f32, h: f32) -> bool {
    clip.is_none_or(|c| y >= c.y - CLIP_SLACK && y + h <= c.y + c.h + CLIP_SLACK)
}

/// `line` cut with `...` to fit `max_w` pixels.
fn ellipsize(line: &str, max_w: f32, font_scale: f32, font: &str) -> String {
    if text::str_width_in(line, font_scale, font) <= max_w {
        return line.to_owned();
    }
    let budget = max_w - text::str_width_in("...", font_scale, font);
    let mut out = String::new();
    let mut w = 0.0;
    for c in line.chars() {
        let cw = text::char_width_in(c, font) * font_scale;
        if w + cw > budget {
            break;
        }
        out.push(c);
        w += cw;
    }
    out.truncate(out.trim_end().len());
    out + "..."
}

fn render_clipped(
    gfx: &GfxContext,
    d2d: &Draw2D,
    widget: &Widget,
    node: &LayoutNode,
    clip: Option<Rect>,
) {
    if !widget.visible || !node.visible {
        return;
    }
    let r = &node.rect;
    let style = widget.effective_style();
    let s: &Style = &style;
    if let Some(c) = clip
        && r.intersect(&c).is_none()
    {
        return;
    }

    // Background
    if s.bg != 0 {
        fill(d2d, clip, r.x, r.y, r.x + r.w, r.y + r.h, s.bg);
    }
    // An image can't be cut: drawn while it's inside the clip.
    if !s.bg_image.is_empty() && fits(clip, r.y, r.h) {
        d2d.image(&s.bg_image, r.x, r.y, r.w, r.h);
    }
    // Focus indicator — style controlled per-widget. Text boxes draw their
    // own (a white border).
    if node.focused && !matches!(widget.kind, WidgetKind::TextBox(_)) {
        let fc = if s.focus_color != 0 {
            s.focus_color
        } else {
            widget::DEFAULT_FOCUS_COLOR
        };
        match s.focus_style {
            FocusStyle::Outline => outline(d2d, clip, *r, fc),
            FocusStyle::Fill => fill_rect(d2d, clip, *r, fc),
            FocusStyle::None => {}
        }
    }

    match &widget.kind {
        WidgetKind::Panel(_) | WidgetKind::Grid(_) => {
            // Containers just draw their children
        }
        // `no_wrap`: always a single line, even wider than the box — it
        // overflows horizontally (still centered) rather than wrapping.
        // No `.max(0.0)` when centered: wrapped lines never exceed the box
        // so this never goes negative for them; a no_wrap line wider than
        // the box legitimately needs a negative offset to stay centered.
        WidgetKind::Label(t) => draw_lines(d2d, t, s, *r, clip, |free| match s.align {
            crate::Align::Center => free / 2.0,
            crate::Align::End => free.max(0.0),
            crate::Align::Start => 0.0,
        }),
        // Each line centered horizontally inside the button.
        WidgetKind::Button(t) => draw_button_text(d2d, t, s, *r, clip),
        WidgetKind::ItemSlot(item_id) => {
            let (ix, iy) = (r.x + s.pad[3], r.y + s.pad[0]);
            if !fits(clip, iy, SLOT_SIZE) {
                return;
            }
            let sz = SLOT_SIZE;
            d2d.rect(ix, iy, ix + sz, iy + sz, ITEM_SLOT_BORDER);
            d2d.rect(
                ix + 1.0,
                iy + 1.0,
                ix + sz - 1.0,
                iy + sz - 1.0,
                ITEM_SLOT_FACE,
            );
            // The item renderer: modded items, 3D block items, any version.
            if !item_id.is_empty() {
                d2d.item(item_id, ix + 1.0, iy + 1.0, ICON_SIZE);
            }
        }
        WidgetKind::InvSlot { item_id, count } => {
            let (ix, iy) = (r.x + s.pad[3], r.y + s.pad[0]);
            if !fits(clip, iy, SLOT_SIZE) {
                return;
            }
            let sz = SLOT_SIZE;
            d2d.rect(ix, iy, ix + sz, iy + sz, INV_SLOT_FACE);
            d2d.rect(ix, iy, ix + sz, iy + 1.0, INV_SLOT_SHADOW);
            d2d.rect(ix, iy + sz - 1.0, ix + sz, iy + sz, INV_SLOT_LIGHT);
            d2d.rect(ix, iy, ix + 1.0, iy + sz, INV_SLOT_SHADOW);
            d2d.rect(ix + sz - 1.0, iy, ix + sz, iy + sz, INV_SLOT_LIGHT);
            // Item icon + count
            if !item_id.is_empty() {
                d2d.item(item_id, ix + 1.0, iy + 1.0, ICON_SIZE);
                if *count > 1 {
                    let count_str = count.to_string();
                    let cw = text::str_width(&count_str, 0.7);
                    d2d.text(
                        &count_str,
                        ix + sz - cw - 1.0,
                        iy + sz - 10.0,
                        COUNT_COLOR,
                        true,
                    );
                }
            }
        }
        WidgetKind::Image(image) => crate::image::render(d2d, image, r.inset(s.pad), clip),
        WidgetKind::Spacer => {} // invisible
        WidgetKind::Surface(id) => {
            let at = r.inset(s.pad);
            match crate::surface::get(id) {
                Some(surface) => surface.paint(gfx, at),
                // Nothing registered to draw it (a designer previewing the
                // markup, a mod that didn't): its place and its name.
                None => {
                    d2d.rect(at.x, at.y, at.x + at.w, at.y + at.h, 0xFF1E2622);
                    let edge = 0xFF4A5A52;
                    d2d.rect(at.x, at.y, at.x + at.w, at.y + 1.0, edge);
                    d2d.rect(at.x, at.y + at.h - 1.0, at.x + at.w, at.y + at.h, edge);
                    d2d.rect(at.x, at.y, at.x + 1.0, at.y + at.h, edge);
                    d2d.rect(at.x + at.w - 1.0, at.y, at.x + at.w, at.y + at.h, edge);
                    let label = format!("Surface {id}");
                    let w = d2d.text_width(&label, "");
                    if w < at.w - 4.0 && at.h >= 10.0 {
                        d2d.text(&label, at.x + (at.w - w) / 2.0, at.y + (at.h - 8.0) / 2.0, 0xFF8FA399, false);
                    }
                }
            }
        }
        WidgetKind::TextBox(tb) => render_text_box(d2d, tb, s, *r, clip, node.focused),
    }

    // Render children — cut to this widget's rect when it clips.
    let child_clip = if s.clip {
        match clip {
            Some(c) => match r.intersect(&c) {
                Some(i) => Some(i),
                None => return,
            },
            None => Some(*r),
        }
    } else {
        clip
    };
    for (i, child_widget) in widget.children.iter().enumerate() {
        if let Some(child_node) = node.children.get(i) {
            render_clipped(gfx, d2d, child_widget, child_node, child_clip);
        }
    }

    if let Some((track, knob)) = node.scrollbar_rects() {
        fill_rect(d2d, clip, track, TRACK_COLOR);
        fill_rect(d2d, clip, knob, KNOB_COLOR);
    }
}

/// Draws a label's / button's text lines inside `r` (less padding), the
/// block centered vertically and each line `place(free width)` from the left.
/// A button's text: centred like vanilla's buttons — one line at
/// `y + (h - 8) / 2` in whole pixels (the glyphs' 8, not the line's 9), so it
/// keeps clear of the frame; several lines centred as a block.
fn draw_button_text(d2d: &Draw2D, t: &str, s: &Style, r: Rect, clip: Option<Rect>) {
    let avail_w = (r.w - s.pad[1] - s.pad[3]).max(0.0);
    let lines = text_lines(t, s, avail_w);
    if lines.len() != 1 || s.font_scale != 1.0 || !text::is_default_font(&s.font) {
        draw_lines(d2d, t, s, r, clip, |free| (free / 2.0).max(0.0));
        return;
    }
    let content_h = r.h - s.pad[0] - s.pad[2];
    let y = r.y + s.pad[0] + ((content_h - 8.0) / 2.0).max(0.0).floor();
    let line = &lines[0];
    if !fits(clip, y, text::LINE_H) {
        return;
    }
    let ink_w = (text::str_width_in(line, 1.0, &s.font) - 1.0).max(0.0);
    let x = r.x + s.pad[3] + ((avail_w - ink_w) / 2.0).max(0.0);
    draw_text(d2d, line, &s.font, x, y, 1.0, s.color, s.text_shadow);
}

fn draw_lines(
    d2d: &Draw2D,
    t: &str,
    s: &Style,
    r: Rect,
    clip: Option<Rect>,
    place: impl Fn(f32) -> f32,
) {
    let avail_w = (r.w - s.pad[1] - s.pad[3]).max(0.0);
    let lines = text_lines(t, s, avail_w);
    let line_h = text::LINE_H * s.font_scale + text::LINE_GAP;
    let total_h = lines.len() as f32 * line_h - text::LINE_GAP;
    let content_h = r.h - s.pad[0] - s.pad[2];
    let start_y = r.y + s.pad[0] + ((content_h - total_h) / 2.0).max(0.0);
    // A span going on past a line goes on into the next: each line is
    // drawn on its own, its spans closed and the next one's reopened.
    let mut open: Vec<String> = Vec::new();
    for (i, line) in lines.iter().enumerate() {
        let mut shown = format!("{}{line}", crate::rich::reopen(&open));
        open = crate::rich::open_spans(&shown);
        shown.push_str(&"}".repeat(open.len()));
        let ly = start_y + i as f32 * line_h;
        if !fits(clip, ly, text::LINE_H * s.font_scale) {
            continue;
        }
        // Placed by the ink: a Minecraft font's advances end in a pixel of
        // spacing after the last glyph, which would pull centred text half
        // a pixel left (a lone `i` in a 9-pixel badge sits off-centre).
        let mut line_w = text::str_width_in(&shown, s.font_scale, &s.font);
        if text::is_default_font(&s.font) && line_w > 0.0 {
            line_w -= s.font_scale;
        }
        let tx = r.x + s.pad[3] + place(avail_w - line_w);
        draw_text(d2d, &shown, &s.font, tx, ly, s.font_scale, s.color, s.text_shadow);
    }
}

/// Text in the widget's font — the plain call for the default font.
fn draw_text(d2d: &Draw2D, line: &str, font: &str, x: f32, y: f32, scale: f32, color: u32, shadow: bool) {
    if scale != 1.0 {
        d2d.text_scaled(line, font, x, y, scale, color, shadow);
    } else if text::is_default_font(font) {
        d2d.text(line, x, y, color, shadow);
    } else {
        d2d.text_font(line, font, x, y, color, shadow);
    }
}

/// A text box: border, then the visible part of the text (or the
/// placeholder), the selection behind it and the caret.
fn render_text_box(
    d2d: &Draw2D,
    tb: &widget::TextBox,
    s: &Style,
    r: Rect,
    clip: Option<Rect>,
    focused: bool,
) {
    let border = if focused {
        if s.focus_color != 0 {
            s.focus_color
        } else {
            widget::TEXT_BOX_FOCUS_BORDER
        }
    } else {
        widget::TEXT_BOX_BORDER
    };
    outline(d2d, clip, r, border);

    let fs = s.font_scale;
    let line_h = text::LINE_H * fs;
    let x0 = r.x + 1.0 + s.pad[3];
    let inner_w = (r.w - 2.0 - s.pad[1] - s.pad[3]).max(0.0);
    let content_h = r.h - s.pad[0] - s.pad[2];
    let ty = (r.y + s.pad[0] + ((content_h - line_h) / 2.0).max(0.0)).round();
    if !fits(clip, ty, line_h) {
        return;
    }
    let cw = |c: char| text::char_width_in(c, &s.font) * fs;

    if tb.text.is_empty() {
        if !tb.placeholder.is_empty() {
            let shown = ellipsize(&tb.placeholder, inner_w, fs, &s.font);
            draw_text(
                d2d,
                &shown,
                &s.font,
                x0,
                ty,
                fs,
                widget::PLACEHOLDER_COLOR,
                false,
            );
        }
    } else {
        let caret = tb.caret.unwrap_or(0);
        let first = crate::textbox::text_box_first(&tb.text, tb.first, caret, inner_w, cw);
        // The characters that fit, from `first`.
        let mut xs = vec![x0];
        let mut visible = String::new();
        for c in tb.text.chars().skip(first) {
            let next = xs[xs.len() - 1] + cw(c);
            if next > x0 + inner_w + 0.5 {
                break;
            }
            visible.push(c);
            xs.push(next);
        }
        let last = first + xs.len() - 1;
        let (a, b) = tb.selection;
        if a < b && b > first && a < last {
            let sx0 = xs[a.max(first) - first];
            let sx1 = xs[b.min(last) - first];
            fill(
                d2d,
                clip,
                sx0,
                ty - 1.0,
                sx1,
                ty + line_h,
                widget::SELECTION_COLOR,
            );
        }
        draw_text(d2d, &visible, &s.font, x0, ty, fs, s.color, s.text_shadow);
    }
    if let Some(caret) = tb.caret
        && tb.caret_visible
    {
        let first = crate::textbox::text_box_first(&tb.text, tb.first, caret, inner_w, cw);
        let cx = x0
            + tb.text
                .chars()
                .skip(first)
                .take(caret.saturating_sub(first))
                .map(cw)
                .sum::<f32>();
        let cx = cx.min(x0 + inner_w);
        fill(d2d, clip, cx, ty - 1.0, cx + 1.0, ty + line_h, s.color);
    }
}

/// The lines a label/button draws: wrapped to `avail_w`, or one line
/// (`no_wrap`), cut with `...` when `ellipsis` is set.
fn text_lines(t: &str, s: &Style, avail_w: f32) -> Vec<String> {
    if s.ellipsis {
        vec![ellipsize(t, avail_w, s.font_scale, &s.font)]
    } else if s.no_wrap {
        t.split('\n').map(str::to_owned).collect()
    } else {
        text::wrap_text_in(t, avail_w, s.font_scale, &s.font)
    }
}

/// Vanilla's tooltip box: near-black fill, a purple gradient frame, white
/// text — 12px right of and above the cursor, flipped to stay on screen.
pub(crate) fn tooltip(d2d: &Draw2D, text: &str, mx: f32, my: f32, sw: f32, sh: f32) {
    const BG: u32 = 0xF0_100010;
    const BORDER_TOP: u32 = 0x50_5000FF;
    const BORDER_BOTTOM: u32 = 0x50_28007F;
    let lines: Vec<&str> = text.lines().collect();
    if lines.is_empty() {
        return;
    }
    let w = lines.iter().map(|l| crate::text::str_width(l, 1.0)).fold(0.0, f32::max);
    let h = lines.len() as f32 * (crate::text::LINE_H + 1.0) - 1.0;
    let mut x = mx + 12.0;
    let mut y = my - 12.0;
    if x + w + 4.0 > sw {
        x = (mx - 16.0 - w).max(4.0);
    }
    y = y.clamp(4.0, (sh - h - 4.0).max(4.0));
    let (x0, y0, x1, y1) = (x - 3.0, y - 3.0, x + w + 3.0, y + h + 3.0);
    d2d.rect(x0, y0 - 1.0, x1, y0, BG);
    d2d.rect(x0, y1, x1, y1 + 1.0, BG);
    d2d.rect(x0, y0, x1, y1, BG);
    d2d.rect(x0 - 1.0, y0, x0, y1, BG);
    d2d.rect(x1, y0, x1 + 1.0, y1, BG);
    d2d.gradient(x0, y0 + 1.0, x0 + 1.0, y1 - 1.0, BORDER_TOP, BORDER_BOTTOM);
    d2d.gradient(x1 - 1.0, y0 + 1.0, x1, y1 - 1.0, BORDER_TOP, BORDER_BOTTOM);
    d2d.rect(x0, y0, x1, y0 + 1.0, BORDER_TOP);
    d2d.rect(x0, y1 - 1.0, x1, y1, BORDER_BOTTOM);
    for (i, line) in lines.iter().enumerate() {
        d2d.text(line, x, y + i as f32 * (crate::text::LINE_H + 1.0), 0xFF_FFFFFF, true);
    }
}

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

    #[test]
    fn ellipsize_fits_the_width() {
        assert_eq!(ellipsize("short", 100.0, 1.0, ""), "short");
        let cut = ellipsize("A rather long description line", 60.0, 1.0, "");
        assert!(cut.ends_with("..."), "{cut}");
        assert!(text::str_width(&cut, 1.0) <= 60.0, "{cut}");
    }

    #[test]
    fn fits_checks_the_clip_vertically() {
        let clip = Some(Rect {
            x: 0.0,
            y: 10.0,
            w: 100.0,
            h: 20.0,
        });
        assert!(fits(clip, 10.0, 9.0));
        assert!(!fits(clip, 5.0, 9.0));
        assert!(!fits(clip, 25.0, 9.0));
        assert!(fits(None, -100.0, 9.0));
    }
}