use peek_poke::PeekPoke;
use std::cmp;
use std::hash::{Hash, Hasher};
#[repr(C)]
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, Serialize)]
pub struct PremultipliedColorF {
pub r: f32,
pub g: f32,
pub b: f32,
pub a: f32,
}
#[allow(missing_docs)]
impl PremultipliedColorF {
pub const BLACK: PremultipliedColorF = PremultipliedColorF { r: 0.0, g: 0.0, b: 0.0, a: 1.0 };
pub const TRANSPARENT: PremultipliedColorF = PremultipliedColorF { r: 0.0, g: 0.0, b: 0.0, a: 0.0 };
pub const WHITE: PremultipliedColorF = PremultipliedColorF { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };
pub fn to_array(&self) -> [f32; 4] {
[self.r, self.g, self.b, self.a]
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Deserialize, MallocSizeOf, PartialEq, Serialize, PeekPoke)]
pub struct ColorF {
pub r: f32,
pub g: f32,
pub b: f32,
pub a: f32,
}
#[allow(missing_docs)]
impl ColorF {
pub const BLACK: ColorF = ColorF { r: 0.0, g: 0.0, b: 0.0, a: 1.0 };
pub const TRANSPARENT: ColorF = ColorF { r: 0.0, g: 0.0, b: 0.0, a: 0.0 };
pub const WHITE: ColorF = ColorF { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };
pub fn new(r: f32, g: f32, b: f32, a: f32) -> Self {
ColorF { r, g, b, a }
}
pub fn scale_rgb(&self, scale: f32) -> Self {
ColorF {
r: self.r * scale,
g: self.g * scale,
b: self.b * scale,
a: self.a,
}
}
pub fn scale_alpha(&self, scale: f32) -> Self {
ColorF {
r: self.r,
g: self.g,
b: self.b,
a: self.a * scale,
}
}
pub fn to_array(&self) -> [f32; 4] {
[self.r, self.g, self.b, self.a]
}
pub fn premultiplied(&self) -> PremultipliedColorF {
let c = self.scale_rgb(self.a);
PremultipliedColorF { r: c.r, g: c.g, b: c.b, a: c.a }
}
}
impl Eq for PremultipliedColorF {}
impl Ord for PremultipliedColorF {
fn cmp(&self, other: &Self) -> cmp::Ordering {
self.partial_cmp(other).unwrap_or(cmp::Ordering::Equal)
}
}
#[cfg_attr(feature = "cargo-clippy", allow(clippy::derive_hash_xor_eq))]
impl Hash for PremultipliedColorF {
fn hash<H: Hasher>(&self, state: &mut H) {
self.r.to_bits().hash(state);
self.g.to_bits().hash(state);
self.b.to_bits().hash(state);
self.a.to_bits().hash(state);
}
}
#[repr(C)]
#[derive(Clone, Copy, Hash, Eq, Debug, Deserialize, MallocSizeOf, PartialEq, PartialOrd, Ord, Serialize)]
pub struct ColorU {
pub r: u8,
pub g: u8,
pub b: u8,
pub a: u8,
}
impl ColorU {
pub fn new(r: u8, g: u8, b: u8, a: u8) -> Self {
ColorU { r, g, b, a }
}
}
fn round_to_int(x: f32) -> u8 {
debug_assert!((0.0 <= x) && (x <= 1.0), "{} should be between 0 and 1", x);
let f = (255.0 * x) + 0.5;
let val = f.floor();
debug_assert!(val <= 255.0);
val as u8
}
impl From<ColorF> for ColorU {
fn from(color: ColorF) -> Self {
ColorU {
r: round_to_int(color.r),
g: round_to_int(color.g),
b: round_to_int(color.b),
a: round_to_int(color.a),
}
}
}
impl From<ColorU> for ColorF {
fn from(color: ColorU) -> Self {
ColorF {
r: color.r as f32 / 255.0,
g: color.g as f32 / 255.0,
b: color.b as f32 / 255.0,
a: color.a as f32 / 255.0,
}
}
}