mirage-engine 0.2.0

//! A font is a source like any other: `startup.font` reads one
//! `with_assets` loaded, an `egui::FontDefinitions` names it first in a
//! family, and `startup.set_fonts` draws the UI in it from the first frame
//! on.
//!
//! A corner layer names its own fonts over a scene: three `StationKind`
//! cubes placed around a round platform's edge. Each draws a `Prompt` for
//! `Trigger::Hail` above it; a `bracket` draws its name, a small reading
//! and a large number in the `display` family instead, under hover.
//! Clicking one plays two lines, typed one glyph a tick, in a box sized
//! once from the whole line. `Tab` opens a font sample over the three
//! families the game loaded. The camera turns on its own and by a held
//! left button, and the wheel zooms it about the platform's center.

use core::time::Duration;
use std::sync::Arc;

use mirage_engine::prelude::*;

const PROPORTIONAL_FONT: &str = "pixel-operator";
const MONOSPACE_FONT: &str = "pixel-operator-mono";
const DISPLAY_FONT: &str = "ferrum";
const DISPLAY_FAMILY: &str = "display";
const PIXEL_ONLY_FAMILY: &str = "pixel-only";
const PROMPT_FONT: &str = "kenney-input-keyboard-mouse";
const PROMPT_FAMILY: &str = "prompts";

/// A pixel font's own grid, the sizes it draws crisp at; the `display`
/// and `prompts` families are vector faces and take any size.
const BODY_SIZE: f32 = 16.0;
const HEADING_SIZE: f32 = 32.0;
const NUMBER_SIZE: f32 = 28.0;
const PROMPT_SIZE: f32 = 32.0;
const TEXT_COLOR: egui::Color32 = egui::Color32::from_gray(230);

const PLATFORM_SIZE: f32 = 8.0;
const PLATFORM_COLOR: Color = Color::rgb(0.05, 0.05, 0.06);

/// A `StationKind` center's own distance from the platform's center, and
/// its cube, width by height by depth, in meters.
const STATION_RADIUS: f32 = 3.1;
const STATION_SIZE: Vec3 = Vec3::new(0.6, 0.9, 0.5);
/// The emissive cube set against the `STATION_SIZE` cube's own `-Z` side.
const STATION_FRONT_SIZE: Vec3 = Vec3::new(0.42, 0.5, 0.06);
/// The distance past the `STATION_SIZE` cube's own face the emissive
/// cube's front keeps, in meters, so the two stay flush at a shallow
/// angle.
const STATION_FRONT_OUTWARD: f32 = 0.005;

const RADAR_SWEEP_RATE: f32 = 40.0;
const REACTOR_RATE: f32 = 0.5;
const REACTOR_BASE: f32 = 55.0;
const REACTOR_SWING: f32 = 35.0;

const SUN_DIRECTION: Vec3 = Vec3::new(0.4, -1.0, -0.3);
const SUN_COLOR: Color = Color::rgb(0.6, 0.62, 0.7);

const CAMERA_FOV: f32 = 42.0;
const CAMERA_TARGET: Vec3 = Vec3::new(0.0, STATION_SIZE.y * 0.5, 0.0);
const START_YAW: f32 = 0.4;
const START_PITCH: f32 = 0.35;
/// How far short of straight up or down the pitch may turn, in radians.
const PITCH_LIMIT: f32 = 0.9;
const START_DISTANCE: f32 = 8.0;
const MIN_DISTANCE: f32 = 3.0;
const MAX_DISTANCE: f32 = 14.0;
/// Radians the camera turns by on its own, per second.
const AUTO_TURN_RATE: f32 = 0.12;
/// Radians the pointer's own motion turns the view by, per physical pixel
/// it crosses, while [`Trigger::Hail`] is held.
const TURN_SENSITIVITY: f32 = core::f32::consts::FRAC_PI_2 / 1280.0;
/// The factor one full wheel step divides the distance to the target by.
const ZOOM_STEP: f32 = 1.12;

const BRACKET_MARGIN: f32 = 10.0;
const BRACKET_STROKE: f32 = 2.0;
const BRACKET_CORNER: f32 = 7.0;
/// The gap kept past the line above's own full line height, so a glyph
/// whose `mesh_bounds` reaches past that height still clears the line
/// below.
const STACK_GAP: f32 = 4.0;

/// The gap between a `StationKind`'s own top and the `Prompt` drawn above
/// it, in logical points.
const PROMPT_LIFT: f32 = 20.0;

const DIALOGUE_PADDING_X: f32 = 28.0;
const DIALOGUE_PADDING_Y: f32 = 20.0;
const DIALOGUE_MARGIN: f32 = 24.0;

/// A sample the pixel font holds no glyph for, so `Proportional` falls
/// back to egui's own font and `pixel-only` shows the missing glyph box.
const FALLBACK_SAMPLE: &str = "café λ";
/// Different widths of glyph together, so a family's own advance shows.
const FAMILY_SAMPLE: &str = "mill and wall";
const GRID_SAMPLE: &str = "the quick fox";

meshes! { enum Shape { Cube, Plane } }

/// This game's own sky: a dark, dim gradient, so each `StationKind`'s own
/// emissive glow still reads as the platform's brightest color.
#[derive(Catalog, Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Sky {
    Dusk,
}

impl Skyboxes for Sky {
    fn build(&self, _assets: &Assets) -> SkyboxData {
        SkyboxData::gradient(
            Color::rgb(0.05, 0.06, 0.12),
            Color::rgb(0.18, 0.12, 0.16),
            Color::rgb(0.01, 0.01, 0.02),
        )
        .lit_by(0.25)
    }
}

/// What one `StationKind` is drawn and named as.
struct StationLook {
    name: &'static str,
    color: Color,
    glow: Color,
    lines: [&'static str; 2],
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum StationKind {
    Radar,
    Reactor,
    Clock,
}

impl StationKind {
    const ALL: [Self; 3] = [Self::Radar, Self::Reactor, Self::Clock];

    fn index(self) -> usize {
        self as usize
    }

    fn look(self) -> StationLook {
        match self {
            Self::Radar => StationLook {
                name: "radar",
                color: Color::rgb(0.22, 0.26, 0.30),
                glow: Color::rgb(0.3, 1.4, 1.1),
                lines: [
                    "the radar sweeps the dark past the platform for anything that moves",
                    "nothing answers back tonight",
                ],
            },
            Self::Reactor => StationLook {
                name: "reactor",
                color: Color::rgb(0.30, 0.22, 0.18),
                glow: Color::rgb(1.6, 0.7, 0.2),
                lines: [
                    "the reactor gauge holds steady at a comfortable idle",
                    "plenty of power left for the long watch ahead",
                ],
            },
            Self::Clock => StationLook {
                name: "clock",
                color: Color::rgb(0.20, 0.24, 0.22),
                glow: Color::rgb(0.8, 0.9, 1.6),
                lines: [
                    "the clock keeps the same count it always has",
                    "the watch ends when it says so and not before",
                ],
            },
        }
    }

    /// This `StationKind`'s own center, on the platform's edge.
    fn center(self) -> Vec3 {
        let angle = self.index() as f32 / Self::ALL.len() as f32 * core::f32::consts::TAU;
        Vec3::new(
            STATION_RADIUS * angle.cos(),
            STATION_SIZE.y * 0.5,
            STATION_RADIUS * angle.sin(),
        )
    }

    fn aabb(self) -> (Vec3, Vec3) {
        let half = STATION_SIZE * 0.5;
        (self.center() - half, self.center() + half)
    }

    /// The reading a `bracket` shows through `Monospace`, and the one
    /// large number it shows through the `display` family, both from
    /// `elapsed` seconds.
    fn reading(self, elapsed: f32) -> (String, String) {
        match self {
            Self::Radar => {
                let bearing = (elapsed * RADAR_SWEEP_RATE).rem_euclid(360.0);
                (
                    format!("{bearing:.0} degrees bearing"),
                    format!("{bearing:03.0}"),
                )
            }
            Self::Reactor => {
                let percent = REACTOR_BASE + REACTOR_SWING * (elapsed * REACTOR_RATE).sin();
                (
                    format!("{percent:.0} percent output"),
                    format!("{percent:.0}%"),
                )
            }
            Self::Clock => {
                let seconds = elapsed.rem_euclid(60.0);
                (
                    format!("{seconds:.1} seconds this minute"),
                    format!("{seconds:04.1}"),
                )
            }
        }
    }
}

/// The `StationKind` `ray` lies nearest along, if any.
fn hit_station(ray: Ray) -> Option<StationKind> {
    StationKind::ALL
        .into_iter()
        .filter_map(|station| {
            let (min, max) = station.aabb();
            ray.hit_aabb(min, max).map(|distance| (distance, station))
        })
        .min_by(|(a, _), (b, _)| a.total_cmp(b))
        .map(|(_, station)| station)
}

/// The logical point egui paints `pixel`, a physical pixel, at.
fn logical(pixel: Vec2, pixels_per_point: f32) -> egui::Pos2 {
    let point = pixel / pixels_per_point;
    egui::pos2(point.x, point.y)
}

/// `text` at `font`, in this game's own text color.
fn styled(text: impl Into<String>, font: egui::FontId) -> egui::RichText {
    egui::RichText::new(text.into())
        .font(font)
        .color(TEXT_COLOR)
}

/// The position that draws `galley` with its `mesh_bounds` centered on
/// `center_x` and its `mesh_bounds`'s own bottom at `bottom`.
fn ink_bottom_at(galley: &egui::Galley, center_x: f32, bottom: f32) -> egui::Pos2 {
    let ink = galley.mesh_bounds;
    egui::pos2(center_x - ink.center().x, bottom - ink.max.y)
}

/// How a control reads to a player: a glyph the `prompts` family draws,
/// or a control's own name in the `Proportional` font.
enum Prompt {
    Glyph(char),
    Text(String),
}

impl Prompt {
    fn text(&self) -> String {
        match self {
            Self::Glyph(glyph) => glyph.to_string(),
            Self::Text(text) => text.clone(),
        }
    }

    fn family(&self) -> egui::FontFamily {
        match self {
            Self::Glyph(_) => egui::FontFamily::Name(PROMPT_FAMILY.into()),
            Self::Text(_) => egui::FontFamily::Proportional,
        }
    }
}

/// `binding` read for a player: a mouse glyph for its left or right
/// button, or its own `Display` text otherwise, so a key reads as `E`
/// and a pad button as its name.
fn prompt(binding: &ButtonBinding) -> Prompt {
    match binding {
        ButtonBinding::Mouse(MouseButton::Left) => Prompt::Glyph('\u{E0EC}'),
        ButtonBinding::Mouse(MouseButton::Right) => Prompt::Glyph('\u{E0F0}'),
        other => Prompt::Text(other.to_string()),
    }
}

/// A name in `corners`, a reading and a number, placed one above the
/// other upward from `at`, which sits right above a `StationKind`'s top,
/// one line height clear of it: the name boxed and nearest `at`, the
/// reading a full line height above it, the number a full line height
/// above that, so no two lines and no line and the box ever overlap.
///
/// Each gap is measured in the line below's own full line height, not its
/// smaller `mesh_bounds`, so a glyph whose `mesh_bounds` reaches past that
/// height still clears the line above it. The name's own frame is sized to
/// its `mesh_bounds`, margin included, and the name centers inside it on
/// every side. The caller measures every `Galley`; this only draws. Lifts
/// into another game unchanged.
fn bracket(
    painter: &egui::Painter,
    at: egui::Pos2,
    name: Arc<egui::Galley>,
    reading: Arc<egui::Galley>,
    number: Arc<egui::Galley>,
) {
    let frame_bottom = at.y - name.rect.height();
    let name_ink = name.mesh_bounds;
    let frame_height = name_ink.height() + BRACKET_MARGIN * 2.0;
    let frame = egui::Rect::from_min_size(
        egui::pos2(
            at.x - name_ink.width() * 0.5 - BRACKET_MARGIN,
            frame_bottom - frame_height,
        ),
        egui::vec2(name_ink.width() + BRACKET_MARGIN * 2.0, frame_height),
    );
    let name_pos = ink_bottom_at(&name, at.x, frame_bottom - BRACKET_MARGIN);

    let reading_bottom = frame.top() - STACK_GAP;
    let reading_pos = ink_bottom_at(&reading, at.x, reading_bottom);

    let number_bottom = reading_pos.y - reading.rect.height() - STACK_GAP;
    let number_pos = ink_bottom_at(&number, at.x, number_bottom);

    corners(painter, frame);
    painter.galley(name_pos, name, TEXT_COLOR);
    painter.galley(reading_pos, reading, TEXT_COLOR);
    painter.galley(number_pos, number, TEXT_COLOR);
}

/// `glyph`, its `mesh_bounds` centered on `at`. Lifts into another game
/// unchanged.
fn prompt_at(painter: &egui::Painter, at: egui::Pos2, glyph: Arc<egui::Galley>) {
    let ink = glyph.mesh_bounds;
    let pos = egui::pos2(at.x - ink.center().x, at.y - ink.center().y);
    painter.galley(pos, glyph, TEXT_COLOR);
}

/// Four short lines at `rect`'s own corners, in place of its sides.
fn corners(painter: &egui::Painter, rect: egui::Rect) {
    let stroke = egui::Stroke::new(BRACKET_STROKE, TEXT_COLOR);
    for (corner, inward) in [
        (rect.left_top(), egui::vec2(1.0, 1.0)),
        (rect.right_top(), egui::vec2(-1.0, 1.0)),
        (rect.left_bottom(), egui::vec2(1.0, -1.0)),
        (rect.right_bottom(), egui::vec2(-1.0, -1.0)),
    ] {
        painter.line_segment(
            [corner, corner + egui::vec2(inward.x * BRACKET_CORNER, 0.0)],
            stroke,
        );
        painter.line_segment(
            [corner, corner + egui::vec2(0.0, inward.y * BRACKET_CORNER)],
            stroke,
        );
    }
}

/// A name shown large and one line typed a glyph a tick, over two lines a
/// click steps through. Holds no `StationKind` of its own, so it lifts
/// into another game unchanged.
struct Dialogue {
    name: String,
    lines: [String; 2],
    line: usize,
    revealed: usize,
}

impl Dialogue {
    fn start(name: impl Into<String>, lines: [String; 2]) -> Self {
        Self {
            name: name.into(),
            lines,
            line: 0,
            revealed: 0,
        }
    }

    fn current_line(&self) -> &str {
        &self.lines[self.line]
    }

    /// Shows one more glyph of the current line, up to its whole length.
    fn tick(&mut self) {
        let len = self.current_line().chars().count();
        self.revealed = (self.revealed + 1).min(len);
    }

    /// Steps to the next line; `false` where the last line was already
    /// shown, for the caller to close instead.
    fn advance(&mut self) -> bool {
        if self.line + 1 < self.lines.len() {
            self.line += 1;
            self.revealed = 0;
            true
        } else {
            false
        }
    }

    /// Draws the box at a size `whole_line` set, so it never grows as the
    /// glyphs of the same line arrive: `set_min_size` inside the window
    /// holds that size from the frame this window first draws, rather
    /// than egui's own resize state, which only grows a window to match
    /// what the frame before it drew.
    fn draw(&self, ui: &mut egui::Ui, whole_line: egui::Vec2) {
        let display = egui::FontFamily::Name(DISPLAY_FAMILY.into());
        let box_size = egui::vec2(
            whole_line.x + DIALOGUE_PADDING_X,
            whole_line.y + HEADING_SIZE + DIALOGUE_PADDING_Y,
        );
        egui::Window::new("hail")
            .title_bar(false)
            .resizable(false)
            .collapsible(false)
            .anchor(
                egui::Align2::CENTER_BOTTOM,
                egui::vec2(0.0, -DIALOGUE_MARGIN),
            )
            .show(ui.ctx(), |ui| {
                ui.set_min_size(box_size);
                ui.label(styled(&self.name, egui::FontId::new(HEADING_SIZE, display)));
                let shown: String = self.current_line().chars().take(self.revealed).collect();
                ui.label(styled(shown, egui::FontId::proportional(BODY_SIZE)));
            });
    }
}

/// Every family this game loaded, its name at `16` points beside a sample
/// at `32` in that family; the same sample under `Proportional`, where
/// egui's own fonts back what the pixel font holds no glyph for, beside
/// it again under a family that holds only the pixel font; and the pixel
/// font at `16` points beside itself at `17`, where its own grid stops
/// holding it crisp.
fn sheet(ui: &mut egui::Ui) {
    egui::Window::new("font sheet")
        .anchor(egui::Align2::CENTER_CENTER, egui::Vec2::ZERO)
        .collapsible(false)
        .resizable(false)
        .show(ui.ctx(), |ui| {
            egui::Grid::new("font sheet grid").show(ui, |ui| {
                for (label, family) in [
                    ("proportional", egui::FontFamily::Proportional),
                    ("monospace", egui::FontFamily::Monospace),
                    ("display", egui::FontFamily::Name(DISPLAY_FAMILY.into())),
                ] {
                    ui.label(styled(label, egui::FontId::proportional(BODY_SIZE)));
                    ui.label(styled(
                        FAMILY_SAMPLE,
                        egui::FontId::new(HEADING_SIZE, family),
                    ));
                    ui.end_row();
                }

                let pixel_only = egui::FontFamily::Name(PIXEL_ONLY_FAMILY.into());
                for (label, family) in [
                    ("egui's fonts behind", egui::FontFamily::Proportional),
                    ("pixel font alone", pixel_only),
                ] {
                    ui.label(styled(label, egui::FontId::proportional(BODY_SIZE)));
                    ui.label(styled(
                        FALLBACK_SAMPLE,
                        egui::FontId::new(BODY_SIZE, family),
                    ));
                    ui.end_row();
                }

                for (label, size) in [("16 points", 16.0), ("17 points", 17.0)] {
                    ui.label(styled(label, egui::FontId::proportional(BODY_SIZE)));
                    ui.label(styled(GRID_SAMPLE, egui::FontId::proportional(size)));
                    ui.end_row();
                }
            });
        });
}

#[derive(InputButtonAction, Clone, Copy)]
enum Trigger {
    Hail,
    Sheet,
    Close,
}

impl InputButtonAction for Trigger {
    fn bindings(&self) -> Vec<ButtonBinding> {
        match self {
            Self::Hail => vec![MouseButton::Left.into()],
            Self::Sheet => vec![Key::Tab.into()],
            Self::Close => vec![Key::Escape.into()],
        }
    }
}

/// The pointer's own motion, read only while [`Trigger::Hail`] is held.
#[derive(InputAxis2Action, Clone, Copy)]
enum Turn {
    Look,
}

impl InputAxis2Action for Turn {
    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::Look => vec![Axis2Binding::pointer().scale(TURN_SENSITIVITY)],
        }
    }
}

#[derive(InputAxisAction, Clone, Copy)]
enum Zoom {
    Wheel,
}

impl InputAxisAction for Zoom {
    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Self::Wheel => vec![AxisBinding::from(WheelDelta::Up).scale(4.0)],
        }
    }
}

struct Controls;

impl InputActions for Controls {
    type Button = Trigger;
    type Axis = Zoom;
    type Axis2 = Turn;
}

/// Reads every name in `names` and adds them under `family`, front to
/// back in the order given, ahead of whatever `family` already held.
fn install_family(
    fonts: &mut egui::FontDefinitions,
    startup: &mut Startup,
    family: egui::FontFamily,
    names: &[&str],
) -> Result<(), Error> {
    for &name in names {
        if !fonts.font_data.contains_key(name) {
            fonts
                .font_data
                .insert(name.to_owned(), startup.font(name)?.into());
        }
    }
    let list = fonts.families.entry(family).or_default();
    for &name in names.iter().rev() {
        list.insert(0, name.to_owned());
    }
    Ok(())
}

/// The camera around [`CAMERA_TARGET`], its own distance clamped between
/// [`MIN_DISTANCE`] and [`MAX_DISTANCE`], `yaw` free and `pitch` held to
/// [`PITCH_LIMIT`]. Holds nothing of the game, so it copies into another
/// one with its own values.
struct Orbit {
    yaw: f32,
    pitch: f32,
    distance: f32,
}

impl Default for Orbit {
    fn default() -> Self {
        Self {
            yaw: START_YAW,
            pitch: START_PITCH,
            distance: START_DISTANCE,
        }
    }
}

impl Orbit {
    fn camera(&self) -> Camera {
        let direction = Vec3::new(
            self.pitch.cos() * self.yaw.sin(),
            self.pitch.sin(),
            self.pitch.cos() * self.yaw.cos(),
        );
        Camera::new(
            View::look_at(CAMERA_TARGET + direction * self.distance, CAMERA_TARGET),
            Projection::perspective(CAMERA_FOV),
        )
    }

    /// Turns `yaw` by `-by.x` and `pitch` by `by.y`, `pitch` held to its
    /// limit.
    fn turn(&mut self, by: Vec2) {
        self.yaw -= by.x;
        self.pitch = (self.pitch + by.y).clamp(-PITCH_LIMIT, PITCH_LIMIT);
    }

    /// Divides the distance to [`CAMERA_TARGET`] by `factor`, held to its
    /// own least and most.
    fn zoom(&mut self, factor: f32) {
        self.distance = (self.distance / factor).clamp(MIN_DISTANCE, MAX_DISTANCE);
    }
}

struct WatchRoom {
    elapsed: Duration,
    orbit: Orbit,
    hailed: Option<StationKind>,
    dialogue: Option<Dialogue>,
    sheet_open: bool,
}

impl WatchRoom {
    fn init(ctx: &mut InitContext<'_, Self>) -> Result<Self, Error> {
        let startup = ctx.startup();
        let mut fonts = egui::FontDefinitions::default();
        for (family, names) in [
            (egui::FontFamily::Proportional, &[PROPORTIONAL_FONT][..]),
            (egui::FontFamily::Monospace, &[MONOSPACE_FONT][..]),
            (
                egui::FontFamily::Name(DISPLAY_FAMILY.into()),
                &[DISPLAY_FONT][..],
            ),
            (
                egui::FontFamily::Name(PIXEL_ONLY_FAMILY.into()),
                &[PROPORTIONAL_FONT][..],
            ),
            (
                egui::FontFamily::Name(PROMPT_FAMILY.into()),
                &[PROMPT_FONT, PROPORTIONAL_FONT][..],
            ),
        ] {
            install_family(&mut fonts, startup, family, names)?;
        }
        startup.set_fonts(fonts)?;

        Ok(Self {
            elapsed: Duration::ZERO,
            orbit: Orbit::default(),
            hailed: None,
            dialogue: None,
            sheet_open: false,
        })
    }

    fn handle_hail(&mut self, ctx: &mut TickContext<'_, Self>) {
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let Some(station) = hit_station(ray) else {
            return;
        };

        if self.hailed != Some(station) {
            self.hailed = Some(station);
            let look = station.look();
            self.dialogue = Some(Dialogue::start(look.name, look.lines.map(str::to_owned)));
            return;
        }
        let Some(dialogue) = &mut self.dialogue else {
            return;
        };
        if !dialogue.advance() {
            self.dialogue = None;
            self.hailed = None;
        }
    }

    fn draw_station(&self, ctx: &mut FrameContext<'_, Self>, station: StationKind) {
        let look = station.look();
        let center = station.center();
        let front_offset =
            STATION_SIZE.z * 0.5 - STATION_FRONT_SIZE.z * 0.5 + STATION_FRONT_OUTWARD;
        let front = center - Vec3::new(0.0, 0.0, front_offset);
        for (size, position, material) in [
            (STATION_SIZE, center, Material::lit(look.color)),
            (
                STATION_FRONT_SIZE,
                front,
                Material::color(Color::BLACK).emissive(look.glow),
            ),
        ] {
            ctx.draw(
                Cube.at(Transform::from_scale_rotation_translation(
                    size,
                    Quat::IDENTITY,
                    position,
                ))
                .material(material),
            );
        }
    }

    fn draw_bracket(&self, ctx: &mut FrameContext<'_, Self>, camera: Camera, station: StationKind) {
        let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
        let window_size = ctx.window_size();
        let Some(pixel) = camera.pixel_of(top, window_size) else {
            return;
        };
        let at = logical(pixel, ctx.pixels_per_point());

        let name = ctx.text_layout(station.look().name, egui::FontId::proportional(BODY_SIZE));
        let (reading_text, number_text) = station.reading(self.elapsed.as_secs_f32());
        let reading = ctx.text_layout(&reading_text, egui::FontId::monospace(BODY_SIZE));
        let number = ctx.text_layout(
            &number_text,
            egui::FontId::new(NUMBER_SIZE, egui::FontFamily::Name(DISPLAY_FAMILY.into())),
        );

        ctx.ui(|ui| bracket(ui.painter(), at, name, reading, number));
    }

    /// A `Prompt` for `Trigger::Hail`, above every `StationKind` but
    /// `hovered`: what a player presses to reach one, apart from a hover.
    fn draw_prompts(
        &self,
        ctx: &mut FrameContext<'_, Self>,
        camera: Camera,
        hovered: Option<StationKind>,
    ) {
        let Some(binding) = ctx.bindings(Trigger::Hail).into_iter().next() else {
            return;
        };
        let hint = prompt(&binding);
        let glyph = ctx.text_layout(&hint.text(), egui::FontId::new(PROMPT_SIZE, hint.family()));
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();

        ctx.ui(|ui| {
            let painter = ui.painter();
            for station in StationKind::ALL {
                if Some(station) == hovered {
                    continue;
                }
                let top = station.center() + Vec3::Y * (STATION_SIZE.y * 0.5);
                let Some(pixel) = camera.pixel_of(top, window_size) else {
                    continue;
                };
                let at = logical(pixel, pixels_per_point);
                let at = egui::pos2(at.x, at.y - PROMPT_LIFT);
                prompt_at(painter, at, glyph.clone());
            }
        });
    }

    /// The title, a line and the reading, each in a font this game loaded
    /// rather than egui's own.
    fn panel(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.ui(|ui| {
            ui.label(styled(
                "a game's own fonts",
                egui::FontId::proportional(HEADING_SIZE),
            ));
            ui.label(styled(
                "drawn in Pixel Operator, the game's proportional font",
                egui::FontId::proportional(BODY_SIZE),
            ));
            ui.label(styled(
                "the readings above each station in Pixel Operator Mono",
                egui::FontId::monospace(BODY_SIZE),
            ));
        });
    }

    fn draw_dialogue(&self, ctx: &mut FrameContext<'_, Self>) {
        let Some(dialogue) = &self.dialogue else {
            return;
        };
        let whole = ctx.text_layout(
            dialogue.current_line(),
            egui::FontId::proportional(BODY_SIZE),
        );
        let size = whole.size();
        ctx.ui(|ui| dialogue.draw(ui, size));
    }

    /// The `StationKind` under the pointer, `None` while the UI holds it.
    fn hovered(ctx: &FrameContext<'_, Self>) -> Option<StationKind> {
        if ctx.ui_wants_pointer() {
            return None;
        }
        hit_station(
            ctx.last_camera()
                .ray_through(ctx.pointer(), ctx.window_size()),
        )
    }

    /// A held [`Trigger::Hail`] turns the camera by the pointer's own
    /// motion; the wheel zooms it.
    fn steer(&mut self, ctx: &mut FrameContext<'_, Self>) {
        if !ctx.ui_wants_pointer() && ctx.down(Trigger::Hail) {
            self.orbit.turn(ctx.axis2(Turn::Look));
        }
        let wheel = ctx.axis(Zoom::Wheel);
        if !ctx.ui_wants_pointer() && wheel != 0.0 {
            self.orbit.zoom(ZOOM_STEP.powf(wheel));
        }
    }
}

impl Game for WatchRoom {
    type Meshes = Shape;
    type Sounds = NoSounds;
    type InputActions = Controls;
    type Skyboxes = Sky;
    type SurfaceStyles = NoSurfaceStyles;
    type PostEffects = NoPostEffects;

    fn tick(&mut self, ctx: &mut TickContext<'_, Self>) {
        self.elapsed += ctx.dt();
        self.orbit.yaw += AUTO_TURN_RATE * ctx.dt().as_secs_f32();

        if let Some(dialogue) = &mut self.dialogue {
            dialogue.tick();
        }
        if ctx.pressed(Trigger::Close) {
            self.dialogue = None;
            self.hailed = None;
        }
        if ctx.pressed(Trigger::Sheet) {
            self.sheet_open = !self.sheet_open;
        }
        if ctx.pressed(Trigger::Hail) && !ctx.ui_wants_pointer() {
            self.handle_hail(ctx);
        }
    }

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.steer(ctx);

        let camera = self.orbit.camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Dusk);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    PLATFORM_SIZE,
                    1.0,
                    PLATFORM_SIZE,
                )))
                .material(Material::lit(PLATFORM_COLOR)),
        );
        for station in StationKind::ALL {
            self.draw_station(ctx, station);
        }

        let hovered = Self::hovered(ctx);
        if !self.sheet_open {
            if let Some(station) = hovered {
                ctx.set_cursor(Cursor::Pointer);
                self.draw_bracket(ctx, camera, station);
            }
            self.draw_prompts(ctx, camera, hovered);
        }
        if self.dialogue.is_some() {
            self.draw_dialogue(ctx);
        }
        if self.sheet_open {
            ctx.ui(sheet);
        }
        self.panel(ctx);
    }
}

fn main() {
    run(
        Config::new("Mirage: a game's own fonts")
            .with_size(1280, 720)
            .with_assets([
                "examples/assets/pixel-operator.ttf",
                "examples/assets/pixel-operator-mono.ttf",
                "examples/assets/ferrum.otf",
                "examples/assets/kenney-input-keyboard-mouse.ttf",
            ]),
        WatchRoom::init,
    );
}