use gpui::{Hsla, Rgba};
pub const fn rgba(r: f32, g: f32, b: f32, a: f32) -> Rgba {
Rgba::new(r, g, b, a)
}
pub fn with_alpha(color: Rgba, alpha: f32) -> Rgba {
Rgba { alpha, ..color }
}
pub fn channels(color: Rgba) -> [f32; 4] {
[
color.color.red,
color.color.green,
color.color.blue,
color.alpha,
]
}
pub fn to_hsla(color: Rgba) -> Hsla {
gpui::rgb_to_hsla(color)
}
fn clamp01(v: f64) -> f64 {
v.clamp(0.0, 1.0)
}
pub fn srgb_to_linear(v: f64) -> f64 {
if v <= 0.04045 {
v / 12.92
} else {
((v + 0.055) / 1.055).powf(2.4)
}
}
pub fn linear_to_srgb(v: f64) -> f64 {
let c = clamp01(v);
if c <= 0.0031308 {
12.92 * c
} else {
1.055 * c.powf(1.0 / 2.4) - 0.055
}
}
pub fn relative_luminance(color: Rgba) -> f64 {
let [r, g, b, _] = channels(color).map(f64::from);
let (r, g, b) = (srgb_to_linear(r), srgb_to_linear(g), srgb_to_linear(b));
0.2126 * r + 0.7152 * g + 0.0722 * b
}
pub fn oklch_to_color(l_in: f64, c_in: f64, h_degrees: f64) -> Rgba {
OklchHue::new(h_degrees).color(l_in, c_in)
}
#[derive(Clone, Copy)]
pub(crate) struct OklchHue {
cos: f64,
sin: f64,
}
impl OklchHue {
pub(crate) fn new(degrees: f64) -> Self {
let degrees = if degrees.is_finite() { degrees } else { 0.0 };
let radians = (degrees % 360.0) * std::f64::consts::PI / 180.0;
Self {
cos: radians.cos(),
sin: radians.sin(),
}
}
pub(crate) fn color(self, l_in: f64, c_in: f64) -> Rgba {
let l = clamp01(l_in);
let c = c_in.max(0.0);
let a_ = c * self.cos;
let b_ = c * self.sin;
let l_ = l + 0.3963377774 * a_ + 0.2158037573 * b_;
let m_ = l - 0.1055613458 * a_ - 0.0638541728 * b_;
let s_ = l - 0.0894841775 * a_ - 1.2914855480 * b_;
let l3 = l_ * l_ * l_;
let m3 = m_ * m_ * m_;
let s3 = s_ * s_ * s_;
let r_lin = 4.0767416621 * l3 - 3.3077115913 * m3 + 0.2309699292 * s3;
let g_lin = -1.2684380046 * l3 + 2.6097574011 * m3 - 0.3413193965 * s3;
let b_lin = -0.0041960863 * l3 - 0.7034186147 * m3 + 1.7076147010 * s3;
rgba(
linear_to_srgb(r_lin) as f32,
linear_to_srgb(g_lin) as f32,
linear_to_srgb(b_lin) as f32,
1.0,
)
}
}
pub const fn argb(hex: u32) -> Rgba {
rgba(
((hex >> 16) & 0xff) as f32 / 255.0,
((hex >> 8) & 0xff) as f32 / 255.0,
(hex & 0xff) as f32 / 255.0,
((hex >> 24) & 0xff) as f32 / 255.0,
)
}
pub fn mix(from: Rgba, to: Rgba, t: f32) -> Rgba {
let channel = |a: f32, b: f32| {
let a = srgb_to_linear(a as f64);
let b = srgb_to_linear(b as f64);
linear_to_srgb(a + (b - a) * t as f64) as f32
};
let [fr, fg, fb, fa] = channels(from);
let [tr, tg, tb, ta] = channels(to);
rgba(
channel(fr, tr),
channel(fg, tg),
channel(fb, tb),
fa + (ta - fa) * t,
)
}
pub fn lerp(from: Rgba, to: Rgba, t: f32) -> Rgba {
let channel = |a: f32, b: f32| a + (b - a) * t;
let [fr, fg, fb, fa] = channels(from);
let [tr, tg, tb, ta] = channels(to);
rgba(
channel(fr, tr),
channel(fg, tg),
channel(fb, tb),
channel(fa, ta),
)
}
pub const WHITE: Rgba = rgba(1.0, 1.0, 1.0, 1.0);
pub const TRANSPARENT: Rgba = rgba(0.0, 0.0, 0.0, 0.0);