basic i/o

src/rgba.rs

@@ -0,0 +1,107 @@
+use embedded_graphics_core::pixelcolor::*;
+use linfb::shape::Color;
+
+/// Simple RGBA color wrapper.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Rgba<C: RgbColor>(C, u8);
+
+#[allow(unused)]
+#[inline(always)]
+fn mul_blend_u8(delta: u32, a: u32) -> u32 {
+    // Exact (delta * a) / 255 using the div255 trick (no slow integer division).
+    // Valid for 0..=65535 inputs; see Hacker's Delight 10-16.
+    let t = delta * a + 128;
+    (t + (t >> 8)) >> 8
+}
+
+#[allow(unused)]
+impl<C: RgbColor> Rgba<C> {
+    /// Create a new RGBA color.
+    pub const fn new(color: C, alpha: u8) -> Self {
+        Self(color, alpha)
+    }
+
+    /// Get the color component.
+    pub const fn rgb(&self) -> C {
+        self.0
+    }
+
+    pub fn r(&self) -> u8 {
+        self.0.r()
+    }
+
+    pub fn g(&self) -> u8 {
+        self.0.g()
+    }
+
+    pub fn b(&self) -> u8 {
+        self.0.b()
+    }
+
+    /// Get the alpha component (0..=255).
+    pub const fn a(&self) -> u8 {
+        self.1
+    }
+}
+
+impl<C: RgbColor> PixelColor for Rgba<C> {
+    type Raw = C::Raw;
+}
+
+#[allow(unused)]
+pub trait Blend<T> {
+    fn blend(&self, bg: T) -> T;
+}
+
+impl Blend<Rgb888> for Rgba<Rgb888> {
+    #[inline(always)]
+    fn blend(&self, bg: Rgb888) -> Rgb888 {
+        let a = self.a() as u32;
+        if a == 0 {
+            return bg;
+        }
+        if a == 255 {
+            return self.rgb();
+        }
+
+        let fr = self.rgb().r() as u32;
+        let fg = self.rgb().g() as u32;
+        let fb = self.rgb().b() as u32;
+
+        let br = bg.r() as u32;
+        let bgc = bg.g() as u32;
+        let bb = bg.b() as u32;
+
+        let r = (br + mul_blend_u8(fr.wrapping_sub(br), a)) as u8;
+        let g = (bgc + mul_blend_u8(fg.wrapping_sub(bgc), a)) as u8;
+        let b = (bb + mul_blend_u8(fb.wrapping_sub(bb), a)) as u8;
+
+        Rgb888::new(r, g, b)
+    }
+}
+
+impl From<(u8,u8,u8,u8)> for Rgba<Rgb888> {
+    fn from(value: (u8,u8,u8,u8)) -> Self {
+        Self(
+            Rgb888::new(
+                value.0,
+                value.1,
+                value.2,
+            ),
+            value.3,
+        )
+    }
+}
+
+impl From<Color> for Rgba<Rgb888> {
+    fn from(value: Color) -> Self {
+        Self(
+            Rgb888::new(
+                value.red,
+                value.green,
+                value.blue,
+            ),
+            value.alpha,
+        )
+    }
+}