Files
luxe/crates/luxe-tui/examples/wordmark_gif.rs
Evan Whittaker 6501c5ed37 The README opens on the animated wordmark, says how Luxe is built, and CONTRIBUTING asks contributors to disclose AI help
- The README's wordmark is an animated GIF with a transparent background, rendered from the
  dashboard's own art and lights, in light and dark variants for GitHub's two themes.
- The README says Luxe is built with AI assistance, much of it Luxe working on itself, and
  CONTRIBUTING has an AI-assistance section: say what helped, understand the change, write to
  people in your own words.
- The redaction table's Google-key example is joined at compile time, so secret scanning stops
  reading the invented value as a leaked key.
- The MCP trust tests read Luxe's own report of what it started, so a slow runner can neither fail
  them nor pass them falsely.
2026-10-17 22:09:56 -05:00

198 lines
7.7 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! wordmark_gif — the logotype as the terminal lights it, as a looping GIF for the README.
//!
//! Every frame comes from [`Wordmark::lines_at`], the same rows and the same two lights the
//! dashboard draws, so the recording cannot drift from the product. GitHub shows a README image on
//! its own page background, light or dark, so the background is transparent: the art is hard-edged
//! cells, which GIF's one-bit transparency draws exactly.
//!
//! ```sh
//! cargo run -p luxe-tui --example wordmark_gif -- dark > web/src/assets/generated/wordmark-dark.gif
//! cargo run -p luxe-tui --example wordmark_gif -- light > web/src/assets/generated/wordmark-light.gif
//! ```
use luxe_tui::main_loop::ANIMATION_TICK;
use luxe_tui::widgets::{
Wordmark, WordmarkInk, DRIFT_FRAME_TICKS, DRIFT_PERIOD_TICKS, SHINE_CYCLE_TICKS,
SHINE_SWEEP_TICKS,
};
use ratatui::style::Color;
use std::borrow::Cow;
use std::io::Write;
/// Pixels per cell: the 10×22 grid `wordmark_svg` draws, twice over so the mark stays sharp on a
/// high-density screen when the README shows it at half size.
const CELL_W: usize = 20;
const CELL_H: usize = 44;
fn main() {
let dark = match std::env::args().nth(1).as_deref() {
Some("dark") => true,
Some("light") => false,
other => {
eprintln!("usage: wordmark_gif dark|light (got {other:?})");
std::process::exit(2);
}
};
let mut out = Vec::new();
write_gif(&mut out, ink(dark)).expect("encoding into memory cannot fail");
std::io::stdout().write_all(&out).expect("write the GIF to stdout");
}
/// The luxe theme's accent and canvas. `dark` sets how hard the shine pushes toward white: a light
/// page washes the letters out sooner, so it gets the gentler peak the terminal uses on light
/// themes. The canvas stays the dark one either way, so the drift deepens the brass on both.
fn ink(dark: bool) -> WordmarkInk {
let theme = luxe_core::theme::ThemeRegistry::new().resolve("luxe").expect("a built-in theme");
let rgb = |token: &str| match theme.get(token) {
Some(luxe_core::theme::ColorValue::Rgb(red, green, blue)) => {
Color::Rgb(*red, *green, *blue)
}
other => panic!("the luxe theme's {token} is a color, not {other:?}"),
};
WordmarkInk { accent: rgb("accent"), canvas: Some(rgb("background")), dark }
}
/// The ticks a frame is drawn at across one loop: every tick while the shine crosses, every drift
/// frame while it rests, as the terminal repaints.
///
/// One loop is one drift period, which has to close on itself for the GIF to loop without a seam.
/// The shine crosses once at its start and rests for the remainder.
fn frame_ticks() -> Vec<u64> {
(0..DRIFT_PERIOD_TICKS)
.filter(|&tick| tick < SHINE_SWEEP_TICKS || tick % DRIFT_FRAME_TICKS == 0)
.collect()
}
/// Each frame's delay in hundredths of a second, rounded against the running clock so the loop
/// totals the drift period rather than gaining a rounding error per frame.
fn delays(ticks: &[u64]) -> Vec<u16> {
let tick_ms = ANIMATION_TICK.as_millis() as f64;
let at = |tick: u64| (tick as f64 * tick_ms / 10.0).round() as i64;
let ends = ticks.iter().skip(1).copied().chain([DRIFT_PERIOD_TICKS]);
ticks.iter().zip(ends).map(|(&start, end)| (at(end) - at(start)).max(1) as u16).collect()
}
fn write_gif(out: &mut Vec<u8>, ink: WordmarkInk) -> Result<(), gif::EncodingError> {
let size = Wordmark::Full;
let (width, height) = (usize::from(size.width()) * CELL_W, usize::from(size.height()) * CELL_H);
let mut encoder = gif::Encoder::new(out, width as u16, height as u16, &[])?;
encoder.set_repeat(gif::Repeat::Infinite)?;
let ticks = frame_ticks();
for (&tick, delay) in ticks.iter().zip(delays(&ticks)) {
// The shine's own cycle is shorter than the loop; past it the shine rests
let shine = (tick < SHINE_CYCLE_TICKS).then_some(tick);
let (pixels, palette) = render(size, ink, tick, shine, width);
encoder.write_frame(&frame((width, height), pixels, palette, delay))?;
}
Ok(())
}
/// One whole-canvas frame, index 0 transparent.
fn frame(
(width, height): (usize, usize),
pixels: Vec<u8>,
palette: Vec<u8>,
delay: u16,
) -> gif::Frame<'static> {
gif::Frame {
width: width as u16,
height: height as u16,
buffer: Cow::Owned(pixels),
palette: Some(palette),
transparent: Some(0),
delay,
// Cleared between frames, or a cell turned transparent would keep the last frame's ink
dispose: gif::DisposalMethod::Background,
..gif::Frame::default()
}
}
/// One frame as palette indices and the palette, index 0 transparent.
fn render(
size: Wordmark,
ink: WordmarkInk,
drift: u64,
shine: Option<u64>,
width: usize,
) -> (Vec<u8>, Vec<u8>) {
let mut palette = vec![0u8, 0, 0];
let mut pixels = vec![0u8; width * usize::from(size.height()) * CELL_H];
for (row, line) in size.lines_at(ink, drift, shine).iter().enumerate() {
let cells = line
.spans
.iter()
.flat_map(|span| span.content.chars().map(move |glyph| (glyph, span.style.fg)));
for (column, (glyph, fg)) in cells.enumerate() {
let Some(Color::Rgb(red, green, blue)) = fg else { continue };
let index = palette_index(&mut palette, [red, green, blue]);
ink_cell(&mut pixels, width, (column, row), glyph, index);
}
}
(pixels, palette)
}
/// Paints the part of cell `(column, row)` that `glyph` inks: all of it, or the top or bottom half.
fn ink_cell(
pixels: &mut [u8],
width: usize,
(column, row): (usize, usize),
glyph: char,
index: u8,
) {
let (top, bottom) = match glyph {
'█' => (0, CELL_H),
'▀' => (0, CELL_H / 2),
'▄' => (CELL_H / 2, CELL_H),
_ => return,
};
for y in row * CELL_H + top..row * CELL_H + bottom {
pixels[y * width + column * CELL_W..][..CELL_W].fill(index);
}
}
/// The palette slot for `color`, adding it the first time it is seen.
fn palette_index(palette: &mut Vec<u8>, color: [u8; 3]) -> u8 {
let existing = palette.chunks(3).position(|entry| entry == color);
let index = existing.unwrap_or_else(|| {
palette.extend_from_slice(&color);
palette.len() / 3 - 1
});
u8::try_from(index).expect("a frame of one hue lit two ways stays far under 256 colors")
}
#[cfg(test)]
mod tests {
use super::*;
/// The loop is one drift period to the hundredth of a second, so it closes without a jump.
#[test]
fn the_frames_add_up_to_one_drift_period() {
let total: u32 = delays(&frame_ticks()).iter().map(|&delay| u32::from(delay)).sum();
let period_cs =
(DRIFT_PERIOD_TICKS as f64 * ANIMATION_TICK.as_millis() as f64 / 10.0).round();
assert_eq!(f64::from(total), period_cs);
}
/// The shine crosses frame by frame, and the rest repaints at the drift's slower cadence.
#[test]
fn the_shine_gets_every_tick_and_the_rest_every_drift_frame() {
let ticks = frame_ticks();
assert!((0..SHINE_SWEEP_TICKS).all(|tick| ticks.contains(&tick)));
assert!(ticks
.iter()
.filter(|&&tick| tick >= SHINE_SWEEP_TICKS)
.all(|tick| tick % DRIFT_FRAME_TICKS == 0));
}
/// The background is transparent and the letters are ink: a frame has both.
#[test]
fn a_frame_is_transparent_around_inked_letters() {
let size = Wordmark::Full;
let width = usize::from(size.width()) * CELL_W;
let (pixels, palette) = render(size, ink(true), 0, None, width);
assert!(pixels.contains(&0), "transparent background");
assert!(pixels.iter().any(|&index| index != 0), "inked letters");
assert!(palette.len() / 3 > 1);
}
}