2026-10-17 12:08:30 -05:00
|
|
|
|
//! Wordmark — the luxe logotype, and the light that moves over it.
|
|
|
|
|
|
//!
|
|
|
|
|
|
//! The letters are drawn with three glyphs — the two half blocks and the full block — which every
|
|
|
|
|
|
//! terminal with built-in box drawing synthesizes against the cell box rather than scaling a font
|
|
|
|
|
|
//! outline into it. That is the whole reason the mark looks the same for a reader with a patched
|
|
|
|
|
|
//! Nerd Font and one with the plainest monospace their distribution shipped. See [`art`].
|
|
|
|
|
|
//!
|
|
|
|
|
|
//! Three sizes, picked by [`Wordmark::fit`] from the space on offer: the full 44×7 logotype, a 32×5
|
|
|
|
|
|
//! reduction of the same drawing, and the wordmark set as text for what is left.
|
|
|
|
|
|
//!
|
|
|
|
|
|
//! # The light
|
|
|
|
|
|
//!
|
|
|
|
|
|
//! Two effects, because metal has two. A broad **drift** travels across the letters over about
|
|
|
|
|
|
//! seven seconds, shading each column between the theme's accent and its canvas — that is the
|
|
|
|
|
|
//! diffuse reflection, and it is what makes the mark look like a material rather than a fill. A
|
|
|
|
|
|
//! narrow **shine** crosses in 1.6 seconds and rests for five, blending toward white — the specular
|
|
|
|
|
|
//! highlight, and the one the eye actually catches.
|
|
|
|
|
|
//!
|
|
|
|
|
|
//! Both are pure functions of the tick, so any frame can be reproduced by asking for it, and a still
|
|
|
|
|
|
//! is just the frame at [`STILL_TICK`].
|
|
|
|
|
|
//!
|
|
|
|
|
|
//! Themes whose colors aren't RGB (an ANSI/indexed palette) have nothing to blend. They render the
|
|
|
|
|
|
//! wordmark in the flat accent and skip both rather than approximate them.
|
|
|
|
|
|
|
|
|
|
|
|
mod art;
|
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
|
|
|
|
mod light;
|
2026-10-17 12:08:30 -05:00
|
|
|
|
|
|
|
|
|
|
use art::{column_groups, FULL_ART, LINE_ART, SMALL_ART};
|
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
|
|
|
|
pub use light::smoothstep;
|
|
|
|
|
|
use light::{blend_toward, Pass};
|
2026-10-17 12:08:30 -05:00
|
|
|
|
use ratatui::layout::{Alignment, Rect};
|
|
|
|
|
|
use ratatui::style::{Color, Modifier, Style};
|
|
|
|
|
|
use ratatui::text::{Line, Span};
|
|
|
|
|
|
use ratatui::widgets::Paragraph;
|
|
|
|
|
|
use ratatui::Frame;
|
|
|
|
|
|
use std::sync::LazyLock;
|
|
|
|
|
|
|
|
|
|
|
|
/// Ticks for one full pass of the drift (~7s at the 33ms animation tick).
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Slow on purpose. This is the reflection moving, not an indicator: fast enough to read as motion
|
|
|
|
|
|
/// if you look at it, slow enough that you never catch it starting. Three things have to hold when
|
|
|
|
|
|
/// it is retuned, and the assertions below hold all three.
|
|
|
|
|
|
const DRIFT_TICKS: u64 = 212;
|
|
|
|
|
|
|
|
|
|
|
|
/// How far the drift cuts a column back toward the canvas at its dimmest.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Public because the website animates the same swing in CSS, and the two ends of it have to be the
|
|
|
|
|
|
/// two colors the terminal actually reaches — a second copy of this number is one that drifts.
|
|
|
|
|
|
pub const DRIFT_DEPTH: f32 = 0.55;
|
|
|
|
|
|
|
|
|
|
|
|
/// How much of the drift's wave is visible across the mark at once.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Half a period, which is the only fraction that makes every frame read as *one* light: the wave
|
|
|
|
|
|
/// runs from a trough to a crest across the letters and never folds back, so the mark is never
|
|
|
|
|
|
/// symmetrical about its own middle the way a full period would make it.
|
|
|
|
|
|
const DRIFT_SPREAD: f32 = 0.5;
|
|
|
|
|
|
|
|
|
|
|
|
/// The frame a still is taken at.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Half way through a drift, where the wave sits trough-to-crest across the mark: dimmest at the
|
|
|
|
|
|
/// `l`, the accent untouched at the full stop. A clean gradient, and the drawing at its most
|
|
|
|
|
|
/// legible — which is what a reader with `banner_animation = false` should get, and what the
|
|
|
|
|
|
/// website's generated logotype freezes.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// A whole drift period is added on top. The drift cannot tell — its phase repeats — but the shine
|
|
|
|
|
|
/// runs on its own unrelated cycle, so the multiple is the knob for landing the frame in the
|
|
|
|
|
|
/// shine's *rest*. A still caught mid-sweep is a logotype frozen half-lit, which is not a still, it
|
|
|
|
|
|
/// is a bug that looks like a gradient. The assertion below is what re-checks it.
|
|
|
|
|
|
pub const STILL_TICK: u64 = DRIFT_TICKS + DRIFT_TICKS / 2;
|
|
|
|
|
|
|
|
|
|
|
|
/// Ticks between drift frames while no shine is running.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// A frame is mostly escape sequences for the ~300 cells the gradient touches, so this knob sets
|
|
|
|
|
|
/// both the CPU cost and the bytes a reader at the end of an SSH session receives. Four is where
|
|
|
|
|
|
/// the drift reads as continuous (about 14 fps against 30 at every tick); slower saves little,
|
|
|
|
|
|
/// because the *shine* runs at full rate for 1.6 s of every 6.6 s whatever the drift does.
|
|
|
|
|
|
/// `banner_animation = false` turns both off outright.
|
|
|
|
|
|
const DRIFT_FRAME: u64 = 4;
|
|
|
|
|
|
|
|
|
|
|
|
/// Ticks the highlight takes to cross the logotype (~1.6s at the 33ms animation tick).
|
|
|
|
|
|
const SWEEP_TICKS: u64 = 48;
|
|
|
|
|
|
|
|
|
|
|
|
/// Ticks the logotype rests between passes (~5s).
|
|
|
|
|
|
const REST_TICKS: u64 = 152;
|
|
|
|
|
|
|
|
|
|
|
|
/// One pass plus its rest.
|
|
|
|
|
|
const CYCLE_TICKS: u64 = SWEEP_TICKS + REST_TICKS;
|
|
|
|
|
|
|
|
|
|
|
|
// The rest is most of the cycle, and has to stay that way: the shine is a punctuation mark on an
|
|
|
|
|
|
// otherwise still screen, and a short rest turns it into a strobe an arm's length from the eye.
|
|
|
|
|
|
const _: () = assert!(REST_TICKS > SWEEP_TICKS * 3);
|
|
|
|
|
|
|
|
|
|
|
|
// A still has to be a *resting* frame. Retuning either period can slide `STILL_TICK` into a sweep,
|
|
|
|
|
|
// which freezes the mark half-lit; that is a one-character change nobody would think to re-check, so
|
|
|
|
|
|
// the compiler re-checks it. The drift's own two go the same way: an odd period puts `STILL_TICK`
|
|
|
|
|
|
// half a tick off the midpoint, and a period that is not a whole number of frames leaves a short one
|
|
|
|
|
|
// where the wave wraps.
|
|
|
|
|
|
const _: () = assert!(STILL_TICK % CYCLE_TICKS >= SWEEP_TICKS);
|
|
|
|
|
|
const _: () = assert!(DRIFT_TICKS.is_multiple_of(2) && DRIFT_TICKS.is_multiple_of(DRIFT_FRAME));
|
|
|
|
|
|
|
|
|
|
|
|
// The two lights have to stay out of step. A drift that divides into the shine's cycle lands every
|
|
|
|
|
|
// pass at the same point in the wave, and what should read as two independent lights becomes one
|
|
|
|
|
|
// loop repeating: 200 would realign every 6.6 s, where 212 takes near six minutes.
|
|
|
|
|
|
const _: () = assert!(!DRIFT_TICKS.is_multiple_of(CYCLE_TICKS));
|
|
|
|
|
|
|
|
|
|
|
|
/// Cells the band leans right per row, upward — a `/` slant at the terminal's ~1:2 cell aspect.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Public because the website draws the same band, in this same grid: the mark's SVG is the art
|
|
|
|
|
|
/// scaled by one cell, so the lean carries over as it stands rather than as an angle recomputed
|
|
|
|
|
|
/// from it — and an angle recomputed is an angle that comes out mirrored.
|
|
|
|
|
|
pub const LEAN: f32 = 1.0;
|
|
|
|
|
|
|
|
|
|
|
|
/// Half-width of the highlight as a fraction of the sweep axis.
|
|
|
|
|
|
pub const BAND: f32 = 0.30;
|
|
|
|
|
|
|
|
|
|
|
|
/// How far the highlight blends toward white at its center, on a dark theme and on a light one.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Held well short of white: these letters are large solid shapes, and a band that takes one all the
|
|
|
|
|
|
/// way to white doesn't look lit, it looks blank — the logotype loses the color it is identified by
|
|
|
|
|
|
/// for a third of the pass. A light theme's letters are saturated mid-tones on near-white and wash
|
|
|
|
|
|
/// out sooner still, so they are pushed less far again.
|
|
|
|
|
|
pub const PEAK_DARK: f32 = 0.62;
|
|
|
|
|
|
pub const PEAK_LIGHT: f32 = 0.30;
|
|
|
|
|
|
|
|
|
|
|
|
/// The logotype, in the sizes it comes in.
|
|
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
|
|
|
|
pub enum Wordmark {
|
|
|
|
|
|
/// The full 54×8 logotype.
|
|
|
|
|
|
Full,
|
|
|
|
|
|
/// A 38×6 reduction for a terminal too narrow or too short for [`Self::Full`].
|
|
|
|
|
|
Small,
|
|
|
|
|
|
/// The wordmark set as text, for what's left.
|
|
|
|
|
|
Line,
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// What the logotype is drawn in.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// One hue, not four. A mark is not a legend, so it spends the theme's accent and nothing else — a
|
|
|
|
|
|
/// palette's error red has no business inside the product's name. Everything else about how it
|
|
|
|
|
|
/// looks is light: the drift shades that accent toward the canvas, the shine lifts it toward white.
|
|
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
|
|
|
|
pub struct WordmarkInk {
|
|
|
|
|
|
/// The hue the whole mark is drawn in.
|
|
|
|
|
|
pub accent: Color,
|
|
|
|
|
|
/// The canvas behind the logotype, when the theme names one.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// What the drift shades toward, which is what makes one rule right twice: on a dark theme the
|
|
|
|
|
|
/// letters climb out of the background like brass catching light, and on a light one the same
|
|
|
|
|
|
/// rule reads as ink laid down. A theme that leaves the background to the terminal has nothing
|
|
|
|
|
|
/// to shade toward and gets the accent flat, rather than a guess.
|
|
|
|
|
|
pub canvas: Option<Color>,
|
|
|
|
|
|
/// Whether the active theme is dark, which sets how hard the highlight may push.
|
|
|
|
|
|
pub dark: bool,
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl WordmarkInk {
|
|
|
|
|
|
/// The ink a theme draws the logotype in.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// One place, because two surfaces show the mark now, and a second copy of this rule is how
|
|
|
|
|
|
/// they start disagreeing about what the product's name looks like.
|
|
|
|
|
|
pub fn from_theme(theme: &crate::theme::styles::ThemeStyles) -> Self {
|
|
|
|
|
|
Self {
|
|
|
|
|
|
accent: theme.accent.fg.unwrap_or(Color::Reset),
|
|
|
|
|
|
canvas: theme.background.bg,
|
|
|
|
|
|
dark: theme.dark_mode,
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// What the highlight blends toward. A lit edge is lighter than the thing it crosses, on ink or on
|
|
|
|
|
|
/// metal, so this is white in both modes and only [`PEAK_DARK`]/[`PEAK_LIGHT`] differ.
|
|
|
|
|
|
const HIGHLIGHT: Color = Color::Rgb(0xff, 0xff, 0xff);
|
|
|
|
|
|
|
|
|
|
|
|
impl Wordmark {
|
|
|
|
|
|
/// The largest size that fits `width` × `height`.
|
|
|
|
|
|
pub fn fit(width: u16, height: u16) -> Self {
|
|
|
|
|
|
for size in [Self::Full, Self::Small] {
|
|
|
|
|
|
if width >= size.width() && height >= size.height() {
|
|
|
|
|
|
return size;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
Self::Line
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Cells across.
|
|
|
|
|
|
pub fn width(self) -> u16 {
|
|
|
|
|
|
self.rows()[0].chars().count() as u16
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Rows tall.
|
|
|
|
|
|
pub fn height(self) -> u16 {
|
|
|
|
|
|
self.rows().len() as u16
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// The logotype's rows, shaded for `tick` — or held at [`STILL_TICK`] when `tick` is `None`.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// A still is a frame of the same animation rather than a separate code path, so what a reader
|
|
|
|
|
|
/// sees with `banner_animation = false` is a moment of what everyone else sees moving.
|
|
|
|
|
|
pub fn lines(self, ink: WordmarkInk, tick: Option<u64>) -> Vec<Line<'static>> {
|
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
|
|
|
|
match tick {
|
|
|
|
|
|
Some(tick) => self.lines_at(ink, tick, Some(tick)),
|
|
|
|
|
|
None => self.lines_at(ink, STILL_TICK, None),
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// The logotype's rows with each light set on its own: the drift at `drift`, and the shine at
|
|
|
|
|
|
/// `shine`, or none when that is `None`.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// The terminal runs both from one clock and keeps them out of step on purpose, so its pattern
|
|
|
|
|
|
/// takes minutes to repeat. A recording has to loop, so it sets the two to meet.
|
|
|
|
|
|
pub fn lines_at(self, ink: WordmarkInk, drift: u64, shine: Option<u64>) -> Vec<Line<'static>> {
|
|
|
|
|
|
let pass = shine.and_then(|tick| Pass::at(self, ink, tick));
|
2026-10-17 12:08:30 -05:00
|
|
|
|
self.rows()
|
|
|
|
|
|
.iter()
|
|
|
|
|
|
.enumerate()
|
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
|
|
|
|
.map(|(row, text)| self.row_line(text, row as u16, ink, drift, pass.as_ref()))
|
2026-10-17 12:08:30 -05:00
|
|
|
|
.collect()
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// The logotype's rows, one string per terminal row.
|
|
|
|
|
|
pub fn rows(self) -> &'static [&'static str] {
|
|
|
|
|
|
match self {
|
|
|
|
|
|
Self::Full => &FULL_ART,
|
|
|
|
|
|
Self::Small => &SMALL_ART,
|
|
|
|
|
|
Self::Line => &LINE_ART,
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Distance along the sweep axis of the last cell, which is how far the band has to travel.
|
|
|
|
|
|
fn span(self) -> f32 {
|
|
|
|
|
|
f32::from(self.width() - 1) + LEAN * f32::from(self.height() - 1)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
fn row_line(
|
|
|
|
|
|
self,
|
|
|
|
|
|
text: &str,
|
|
|
|
|
|
row: u16,
|
|
|
|
|
|
ink: WordmarkInk,
|
|
|
|
|
|
tick: u64,
|
|
|
|
|
|
pass: Option<&Pass>,
|
|
|
|
|
|
) -> Line<'static> {
|
|
|
|
|
|
let mut spans: Vec<Span<'static>> = Vec::new();
|
|
|
|
|
|
let mut run = String::new();
|
|
|
|
|
|
let mut run_style = Style::default();
|
|
|
|
|
|
|
|
|
|
|
|
for (column, glyph) in text.chars().enumerate() {
|
|
|
|
|
|
let (glyph, style) = self.cell(glyph, column as u16, row, ink, tick, pass);
|
|
|
|
|
|
|
|
|
|
|
|
// Merge equal-styled neighbors: at rest a whole letter is one span, and a row of the
|
|
|
|
|
|
// full logotype goes from 54 spans to a handful.
|
|
|
|
|
|
if !run.is_empty() && style != run_style {
|
|
|
|
|
|
spans.push(Span::styled(std::mem::take(&mut run), run_style));
|
|
|
|
|
|
}
|
|
|
|
|
|
run_style = style;
|
|
|
|
|
|
run.push(glyph);
|
|
|
|
|
|
}
|
|
|
|
|
|
if !run.is_empty() {
|
|
|
|
|
|
spans.push(Span::styled(run, run_style));
|
|
|
|
|
|
}
|
|
|
|
|
|
Line::from(spans)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// The glyph and style one cell of the art is drawn with.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Two lights, in the order a surface receives them: the drift shades the accent toward the
|
|
|
|
|
|
/// canvas (diffuse), then the shine lifts whatever is left toward white (specular).
|
|
|
|
|
|
fn cell(
|
|
|
|
|
|
self,
|
|
|
|
|
|
glyph: char,
|
|
|
|
|
|
column: u16,
|
|
|
|
|
|
row: u16,
|
|
|
|
|
|
ink: WordmarkInk,
|
|
|
|
|
|
tick: u64,
|
|
|
|
|
|
pass: Option<&Pass>,
|
|
|
|
|
|
) -> (char, Style) {
|
|
|
|
|
|
if glyph == ' ' {
|
|
|
|
|
|
return (glyph, Style::default());
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Diffuse first: the accent cut back toward the canvas by however far the drift has moved.
|
|
|
|
|
|
let base = match ink.canvas {
|
|
|
|
|
|
Some(canvas) => blend_toward(ink.accent, canvas, self.drift(column, tick)),
|
|
|
|
|
|
None => ink.accent,
|
|
|
|
|
|
};
|
|
|
|
|
|
// Then specular, on top, toward white.
|
|
|
|
|
|
let lit = pass.map(|pass| pass.lift(column, row)).unwrap_or(0.0);
|
|
|
|
|
|
let color = blend_toward(base, HIGHLIGHT, lit);
|
|
|
|
|
|
|
|
|
|
|
|
if matches!(self, Self::Line) {
|
|
|
|
|
|
// Real text at the one-line size, where bold is worth something.
|
|
|
|
|
|
return (glyph, Style::default().fg(color).add_modifier(Modifier::BOLD));
|
|
|
|
|
|
}
|
|
|
|
|
|
(glyph, Style::default().fg(color))
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// How far this column is cut back toward the canvas at `tick`.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// A raised cosine, so the wave closes on itself and there is no seam where it wraps. The
|
|
|
|
|
|
/// group, not the raw column, sets the position — which is what keeps a letter one flat tone
|
|
|
|
|
|
/// instead of a gradient running through the middle of it, and keeps the full stop reading as
|
|
|
|
|
|
/// punctuation rather than as the tail of the `e`.
|
|
|
|
|
|
fn drift(self, column: u16, tick: u64) -> f32 {
|
|
|
|
|
|
let group = self.groups().get(usize::from(column)).copied().unwrap_or(0);
|
|
|
|
|
|
self.group_shade(group, tick)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// How far ink group `group` is cut back toward the canvas at `tick`.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// The same number `Self::drift` uses, reachable by group so the generators that produce the
|
|
|
|
|
|
/// website's logotype and color tokens compute the ramp from this rather than from a copy of
|
|
|
|
|
|
/// it. `tick` of [`STILL_TICK`] is the frame a still is taken at.
|
|
|
|
|
|
pub fn group_shade(self, group: usize, tick: u64) -> f32 {
|
|
|
|
|
|
let last = self.groups().last().copied().unwrap_or(0).max(1) as f32;
|
|
|
|
|
|
let phase = (tick % DRIFT_TICKS) as f32 / DRIFT_TICKS as f32;
|
|
|
|
|
|
let turn = (group as f32 / last * DRIFT_SPREAD - phase) * std::f32::consts::TAU;
|
|
|
|
|
|
DRIFT_DEPTH * (1.0 - turn.cos()) / 2.0
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// How many groups of ink this size's art is divided into.
|
|
|
|
|
|
pub fn group_count(self) -> usize {
|
|
|
|
|
|
self.groups().last().copied().unwrap_or(0) + 1
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Which ink group owns each column of this size's art.
|
|
|
|
|
|
pub fn groups(self) -> &'static [usize] {
|
|
|
|
|
|
static TABLES: LazyLock<[Vec<usize>; 3]> = LazyLock::new(|| {
|
|
|
|
|
|
[column_groups(&FULL_ART), column_groups(&SMALL_ART), column_groups(&LINE_ART)]
|
|
|
|
|
|
});
|
|
|
|
|
|
let size = match self {
|
|
|
|
|
|
Self::Full => 0,
|
|
|
|
|
|
Self::Small => 1,
|
|
|
|
|
|
Self::Line => 2,
|
|
|
|
|
|
};
|
|
|
|
|
|
&TABLES[size]
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Whether the logotype owes the screen another frame at `tick`.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// True through a shine pass, and on the drift's own slower cadence in between. The drift changes
|
|
|
|
|
|
/// *color* rather than position — there is no edge for the eye to track — so it does not need the
|
|
|
|
|
|
/// shine's frame rate, and a dashboard nobody is touching should not repaint thirty times a second
|
|
|
|
|
|
/// all day.
|
|
|
|
|
|
pub fn banner_frame_due(tick: u64) -> bool {
|
|
|
|
|
|
shine_active(tick) || tick.is_multiple_of(DRIFT_FRAME)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// The clock every surface that draws the logotype reads.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// One owner, on the app, because two surfaces show the mark and each answering "what frame is it"
|
|
|
|
|
|
/// for itself would let walking from the dashboard to setup stop the light dead. A clock that
|
|
|
|
|
|
/// belongs to the session instead means the mark is the same mark wherever it appears, and
|
|
|
|
|
|
/// `banner_animation = false` turns it off in one place.
|
|
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
|
|
|
|
pub struct BannerClock {
|
|
|
|
|
|
tick: u64,
|
|
|
|
|
|
animate: bool,
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl Default for BannerClock {
|
|
|
|
|
|
fn default() -> Self {
|
|
|
|
|
|
Self { tick: 0, animate: true }
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl BannerClock {
|
|
|
|
|
|
/// A clock the reader's `banner_animation` preference has been applied to.
|
|
|
|
|
|
pub fn new(animate: bool) -> Self {
|
|
|
|
|
|
Self { tick: 0, animate }
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Start at a chosen frame — for a fixture or a test that wants a named moment.
|
|
|
|
|
|
pub fn with_tick(mut self, tick: u64) -> Self {
|
|
|
|
|
|
self.tick = tick;
|
|
|
|
|
|
self
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Turn the light on or off, leaving the frame where it is.
|
|
|
|
|
|
pub fn with_animation(mut self, animate: bool) -> Self {
|
|
|
|
|
|
self.animate = animate;
|
|
|
|
|
|
self
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Advance by one UI tick.
|
|
|
|
|
|
pub fn advance(&mut self) {
|
|
|
|
|
|
if self.animate {
|
|
|
|
|
|
self.tick = self.tick.wrapping_add(1);
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// The frame to draw, or `None` to hold the still.
|
|
|
|
|
|
pub fn frame(self) -> Option<u64> {
|
|
|
|
|
|
self.animate.then_some(self.tick)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Whether the mark owes the screen another frame.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// False through the five-second rest between passes, which is what keeps a surface nobody is
|
|
|
|
|
|
/// touching from repainting thirty times a second all day.
|
|
|
|
|
|
pub fn animating(self) -> bool {
|
|
|
|
|
|
self.animate && banner_frame_due(self.tick)
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Draw the logotype centered in `area`, at the frame `clock` is on.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Every surface that shows the mark calls this, so it is one drawing lit one way — a surface
|
|
|
|
|
|
/// holding its own still would put the light out when you walked to it from the dashboard.
|
|
|
|
|
|
pub fn render_wordmark(
|
|
|
|
|
|
f: &mut Frame,
|
|
|
|
|
|
area: Rect,
|
|
|
|
|
|
theme: &crate::theme::styles::ThemeStyles,
|
|
|
|
|
|
size: Wordmark,
|
|
|
|
|
|
clock: BannerClock,
|
|
|
|
|
|
) {
|
|
|
|
|
|
let lines = size.lines(WordmarkInk::from_theme(theme), clock.frame());
|
|
|
|
|
|
f.render_widget(Paragraph::new(lines).alignment(Alignment::Center), area);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// The ticks a shine pass occupies, and the ticks one whole cycle does.
|
|
|
|
|
|
///
|
|
|
|
|
|
/// Exposed so a caller that wants to reason about the rest between passes asks rather than
|
|
|
|
|
|
/// re-derives: two copies of a timing constant is one that drifts.
|
|
|
|
|
|
pub const SHINE_SWEEP_TICKS: u64 = SWEEP_TICKS;
|
|
|
|
|
|
/// One pass plus its rest, in ticks.
|
|
|
|
|
|
pub const SHINE_CYCLE_TICKS: u64 = CYCLE_TICKS;
|
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
|
|
|
|
/// One whole pass of the drift, in ticks.
|
|
|
|
|
|
pub const DRIFT_PERIOD_TICKS: u64 = DRIFT_TICKS;
|
|
|
|
|
|
/// Ticks between drift frames while no shine runs.
|
|
|
|
|
|
pub const DRIFT_FRAME_TICKS: u64 = DRIFT_FRAME;
|
2026-10-17 12:08:30 -05:00
|
|
|
|
|
|
|
|
|
|
fn shine_active(tick: u64) -> bool {
|
|
|
|
|
|
tick % CYCLE_TICKS < SWEEP_TICKS
|
|
|
|
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
|
|
mod tests;
|