omatrix 0.1.1

A Matrix-style terminal rain animation for Omarchy users
Documentation
use crossterm::style::Color;

use crate::theme::{Rgb, Theme};

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Palette {
    background: Rgb,
    head: Color,
    rain: Rgb,
    is_light: bool,
}

impl Palette {
    pub fn from_theme(theme: &Theme) -> Self {
        let rain = derive_rain_color(theme);
        let head = choose_head_color(theme, rain);

        Self {
            background: theme.background,
            head: head.into(),
            rain,
            is_light: theme.is_light,
        }
    }

    pub fn background(&self) -> Color {
        self.background.into()
    }

    pub fn color_for(&self, ttl: u16, max_ttl: u16, is_head: bool) -> Color {
        if is_head {
            self.head
        } else {
            let level = if max_ttl == 0 {
                0.0
            } else {
                (ttl as f32 / max_ttl as f32).clamp(0.0, 1.0)
            };
            let mix_amount = trail_mix_amount(self.is_light, level);

            Color::from(self.background.mix(self.rain, mix_amount))
        }
    }
}

fn derive_rain_color(theme: &Theme) -> Rgb {
    let vivid = theme.active_border.vivid(
        if theme.is_light { 0.45 } else { 0.55 },
        if theme.is_light { 0.68 } else { 0.82 },
        if theme.is_light { 0.72 } else { 0.82 },
    );
    let contrasted = if vivid.contrast_ratio(theme.background) < 3.0 {
        if theme.is_light {
            vivid.mix(Rgb::black(), 0.28)
        } else {
            vivid.mix(Rgb::white(), 0.18)
        }
    } else {
        vivid
    };

    contrasted
}

fn choose_head_color(theme: &Theme, rain: Rgb) -> Rgb {
    let brightest_trail = brightest_trail_color(theme, rain);

    [
        theme.cursor,
        theme.foreground,
        theme.ansi[15],
        if theme.is_light {
            theme.foreground.mix(Rgb::black(), 0.18)
        } else {
            theme.foreground.mix(Rgb::white(), 0.18)
        },
        if theme.is_light {
            theme.cursor.mix(Rgb::black(), 0.14)
        } else {
            theme.cursor.mix(Rgb::white(), 0.14)
        },
    ]
    .into_iter()
    .max_by(|left, right| {
        score_head_color(*left, theme.background, brightest_trail).total_cmp(&score_head_color(
            *right,
            theme.background,
            brightest_trail,
        ))
    })
    .unwrap_or(theme.foreground)
}

fn brightest_trail_color(theme: &Theme, rain: Rgb) -> Rgb {
    theme
        .background
        .mix(rain, trail_mix_amount(theme.is_light, 1.0))
}

fn trail_mix_amount(is_light: bool, level: f32) -> f32 {
    if is_light {
        0.35 + 0.55 * level.powf(1.1)
    } else {
        0.12 + 0.72 * level.powf(1.25)
    }
}

fn score_head_color(candidate: Rgb, background: Rgb, brightest_trail: Rgb) -> f32 {
    let background_contrast = candidate.contrast_ratio(background);
    let trail_contrast = candidate.contrast_ratio(brightest_trail);
    let trail_distance = candidate.distance(brightest_trail) as f32 / 255.0;

    background_contrast * 2.0 + trail_contrast * 1.5 + trail_distance
}

#[cfg(test)]
mod tests {
    use super::{brightest_trail_color, choose_head_color, derive_rain_color};
    use crate::theme::{Rgb, Theme};

    #[test]
    fn derives_blue_rain_from_tokyo_night_border() {
        let theme = Theme {
            accent: Rgb::new(0x7a, 0xa2, 0xf7),
            active_border: Rgb::new(0x7a, 0xa2, 0xf7),
            cursor: Rgb::new(0xc0, 0xca, 0xf5),
            foreground: Rgb::new(0xa9, 0xb1, 0xd6),
            background: Rgb::new(0x1a, 0x1b, 0x26),
            selection_foreground: Rgb::new(0xc0, 0xca, 0xf5),
            selection_background: Rgb::new(0x7a, 0xa2, 0xf7),
            ansi: [Rgb::new(0, 0, 0); 16],
            is_light: false,
        };

        let rain = derive_rain_color(&theme);
        assert!(rain.b > rain.g);
        assert!(rain.b > rain.r);
    }

    #[test]
    fn everforest_uses_a_softer_border_derived_rain() {
        let theme = Theme {
            accent: Rgb::new(0x7f, 0xbb, 0xb3),
            active_border: Rgb::new(0x7f, 0xbb, 0xb3),
            cursor: Rgb::new(0xd3, 0xc6, 0xaa),
            foreground: Rgb::new(0xd3, 0xc6, 0xaa),
            background: Rgb::new(0x2d, 0x35, 0x3b),
            selection_foreground: Rgb::new(0x2d, 0x35, 0x3b),
            selection_background: Rgb::new(0xd3, 0xc6, 0xaa),
            ansi: [Rgb::new(0, 0, 0); 16],
            is_light: false,
        };

        let rain = derive_rain_color(&theme);
        assert!(rain.distance(theme.active_border) < 120);
    }

    #[test]
    fn everforest_head_stands_out_from_the_brightest_trail() {
        let theme = Theme {
            accent: Rgb::new(0x7f, 0xbb, 0xb3),
            active_border: Rgb::new(0x7f, 0xbb, 0xb3),
            cursor: Rgb::new(0xd3, 0xc6, 0xaa),
            foreground: Rgb::new(0xd3, 0xc6, 0xaa),
            background: Rgb::new(0x2d, 0x35, 0x3b),
            selection_foreground: Rgb::new(0x2d, 0x35, 0x3b),
            selection_background: Rgb::new(0xd3, 0xc6, 0xaa),
            ansi: [Rgb::new(0, 0, 0); 16],
            is_light: false,
        };

        let rain = derive_rain_color(&theme);
        let head = choose_head_color(&theme, rain);
        let brightest_trail = brightest_trail_color(&theme, rain);

        assert!(head.distance(brightest_trail) >= 100);
        assert!(head.contrast_ratio(brightest_trail) >= 1.25);
    }
}