Create core vocabulary/traits for driving pixel patterns

lights/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "lights"
+version = "0.1.0"
+authors = ["Tangent 128 <Tangent128@gmail.com>"]
+edition = "2018"
+
+[dependencies]

lights/src/gamma.rs

@@ -0,0 +1,58 @@
+//! Gamma correction tools
+//!
+//! Gamma correction adjusts the color ramp to look *perceptually* linear
+//! (LEDs with pulse-width modulation are pretty good at giving physically linear results already)
+
+use crate::Lights;
+use crate::rgb::Rgb;
+
+/// An RGB value that has been gamma-corrected from perceptual to physical color.
+/// At this point it should probably be passed on to an LED for display, not operated on.
+#[derive(Clone, Copy)]
+pub struct CorrectedRgb(pub u8, pub u8, pub u8);
+
+static GAMMA_LOOKUP: &[u8] = &[
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,
+    1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
+    2,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  5,  5,  5,
+    5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9, 10,
+    10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
+    17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
+    25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
+    37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
+    51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
+    69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
+    90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
+    115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
+    144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
+    177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
+    215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255
+];
+
+#[inline]
+pub fn correct(rgb: &Rgb) -> CorrectedRgb {
+    CorrectedRgb(
+        GAMMA_LOOKUP[rgb.0 as usize],
+        GAMMA_LOOKUP[rgb.1 as usize],
+        GAMMA_LOOKUP[rgb.2 as usize]
+    )
+}
+
+pub struct GammaCorrector<T>(pub T);
+
+impl<T> Lights for GammaCorrector<T>
+    where T: Lights<Pixel = CorrectedRgb>
+{
+    type Pixel = Rgb;
+
+    #[inline]
+    fn render(&mut self, pixel: &Rgb) {
+        self.0.render(&correct(pixel))
+    }
+
+    #[inline]
+    fn latch(&mut self) {
+        self.0.latch();
+    }
+}

lights/src/lib.rs

@@ -0,0 +1,26 @@
+#![no_std]
+
+pub mod gamma;
+pub mod rgb;
+
+use core::borrow::Borrow;
+
+pub trait Lights {
+    type Pixel;
+
+    fn render(&mut self, pixel: &Self::Pixel);
+    fn latch(&mut self);
+}
+
+pub trait PixelIterator<T: Lights> {
+    fn render_to(&mut self, lights: &mut T);
+}
+
+impl<T: Lights, I: Iterator> PixelIterator<T> for I
+    where I::Item: Borrow<T::Pixel>
+{
+    #[inline]
+    fn render_to(&mut self, lights: &mut T) {
+        self.for_each(|pixel| lights.render(pixel.borrow()));
+    }
+}

lights/src/rgb.rs

@@ -0,0 +1,57 @@
+//! Utilities for working with standard 24-bit RGB color pixels
+
+/// An RGB color value in some perceptual color space;
+/// ideally this will be gamma-corrected before display,
+/// but this form is better for doing gradient/fade/etc calculations on.
+#[derive(Clone, Copy)]
+pub struct Rgb(pub u8, pub u8, pub u8);
+
+impl core::ops::Add for Rgb {
+    type Output = Rgb;
+
+    #[inline]
+    fn add(self, rhs: Rgb) -> Rgb {
+        Rgb(
+            self.0.saturating_add(rhs.0),
+            self.1.saturating_add(rhs.1),
+            self.2.saturating_add(rhs.2)
+        )
+    }
+}
+
+impl core::ops::Mul for Rgb {
+    type Output = Rgb;
+
+    #[inline]
+    fn mul(self, rhs: Rgb) -> Rgb {
+        Rgb(
+            (self.0 as usize * rhs.0 as usize / 255) as u8,
+            (self.1 as usize * rhs.1 as usize / 255) as u8,
+            (self.2 as usize * rhs.2 as usize / 255) as u8
+        )
+    }
+}
+
+impl core::ops::Mul<u8> for Rgb
+{
+    type Output = Rgb;
+
+    #[inline]
+    fn mul(self, rhs: u8) -> Rgb {
+        Rgb(
+            self.0.saturating_mul(rhs),
+            self.1.saturating_mul(rhs),
+            self.2.saturating_mul(rhs)
+        )
+    }
+}
+
+#[inline]
+pub fn gray(gray: u8) -> Rgb {
+    Rgb(gray, gray, gray)
+}
+
+#[inline]
+pub fn blend(a: Rgb, b: Rgb, mix: Rgb) -> Rgb {
+    (a * Rgb(255 - mix.0, 255 - mix.1, 255 - mix.2)) + (b * mix)
+}