lib8: implement more fastled 8 bit math as lib8 submodules

src/lib8/interpolate.rs

@@ -0,0 +1,57 @@
+use num::PrimInt;
+
+pub fn scale8(i: u8, scale: u8) -> u8 {
+    // borrowed from FastLED
+    (i as u16 * scale as u16).wrapping_shr(8) as u8
+}
+
+pub fn avg7(i: i8, j: i8) -> i8 {
+    i.unsigned_shr(1).wrapping_add(j.unsigned_shr(1)).wrapping_add(i & 0x1)
+}
+
+pub fn grad8(hash: u8, x: i8, y: i8) -> i8 {
+    let mut u: i8;
+    let mut v: i8;
+
+    if hash & 4 != 0 {
+        u = y; v = x;
+    } else {
+        u = x; v = y;
+    }
+
+    if hash & 1 != 0 {
+        u = u.wrapping_neg();
+    }
+    if hash & 2 != 0 {
+        v = v.wrapping_neg();
+    }
+
+    return avg7(u, v);
+}
+
+pub fn lerp7by8(a: i8, b: i8, frac: u8) -> i8 {
+    if b > a {
+        let delta: u8 = b.wrapping_sub(a) as u8;
+        let scaled: u8 = scale8(delta as u8, frac);
+        return a.wrapping_add(scaled as i8);
+    } else {
+        let delta: u8 = a.wrapping_sub(b) as u8;
+        let scaled: u8 = scale8(delta as u8, frac);
+        return a.wrapping_sub(scaled as i8);
+    }
+}
+
+pub fn ease8InOutQuad(i: u8) -> u8 {
+    let j = if i & 0x80 != 0 {
+        255 - i
+    } else {
+        i
+    };
+    let jj = scale8(j, j);
+    let jj2 = jj.unsigned_shl(1);
+    if i & 0x80 == 0 {
+        return jj2
+    } else {
+        return 255 - jj2;
+    }
+}

src/lib8/mod.rs

@@ -1,12 +1,11 @@
+pub mod interpolate;
+pub mod noise;
+pub mod trig;
+
 use palette::encoding::srgb::Srgb;
 
 use rgb::RGB8;
 
-pub fn scale8(i: u8, scale: u8) -> u8 {
-    // borrowed from FastLED
-    (i as u16 * scale as u16).wrapping_shr(8) as u8
-}
-
 pub trait Rgb8Blend {
     fn saturating_add(self, b: Self) -> Self;
 }

src/lib8/noise.rs

@@ -0,0 +1,59 @@
+use crate::lib8::interpolate::*;
+
+use num::PrimInt;
+
+const noise_cube: [u8; 257] = [
+    151, 160, 137,  91,  90,  15, 131,  13, 201,  95,  96,  53, 194, 233,   7, 225,
+140,  36, 103,  30,  69, 142,   8,  99,  37, 240,  21,  10,  23, 190,   6, 148,
+247, 120, 234,  75,   0,  26, 197,  62,  94, 252, 219, 203, 117,  35,  11,  32,
+57, 177,  33,  88, 237, 149,  56,  87, 174,  20, 125, 136, 171, 168,  68, 175,
+74, 165,  71, 134, 139,  48,  27, 166,  77, 146, 158, 231,  83, 111, 229, 122,
+60, 211, 133, 230, 220, 105,  92,  41,  55,  46, 245,  40, 244, 102, 143,  54,
+65,  25,  63, 161,   1, 216,  80,  73, 209,  76, 132, 187, 208,  89,  18, 169,
+200, 196, 135, 130, 116, 188, 159,  86, 164, 100, 109, 198, 173, 186,   3,  64,
+52, 217, 226, 250, 124, 123,   5, 202,  38, 147, 118, 126, 255,  82,  85, 212,
+207, 206,  59, 227,  47,  16,  58,  17, 182, 189,  28,  42, 223, 183, 170, 213,
+119, 248, 152,   2,  44, 154, 163,  70, 221, 153, 101, 155, 167,  43, 172,   9,
+129,  22,  39, 253,  19,  98, 108, 110,  79, 113, 224, 232, 178, 185, 112, 104,
+218, 246,  97, 228, 251,  34, 242, 193, 238, 210, 144,  12, 191, 179, 162, 241,
+81,  51, 145, 235, 249,  14, 239, 107,  49, 192, 214,  31, 181, 199, 106, 157,
+184,  84, 204, 176, 115, 121,  50,  45, 127,   4, 150, 254, 138, 236, 205,  93,
+222, 114,  67,  29,  24,  72, 243, 141, 128, 195,  78,  66, 215,  61, 156, 180,
+151];
+
+const fn P(x: u8) -> u8 {
+    noise_cube[x as usize]
+}
+
+fn inoise8_raw(x: u16, y: u16) -> u8 {
+    let X: u8 = x.unsigned_shr(8) as u8;
+    let Y: u8 = y.unsigned_shr(8) as u8;
+
+    let A: u8 = P(X) + Y;
+    let AA: u8 = P(A);
+    let AB: u8 = P(A+1);
+    let B: u8 = P(X+1) + Y;
+    let BA: u8 = P(B);
+    let BB: u8 = P(B+1);
+
+    let mut u: u8 = x as u8;
+    let mut v: u8 = y as u8;
+
+    let xx: i8 = ((x as u8).unsigned_shr(1) & 0x7f) as i8;
+    let yy: i8 = ((y as u8).unsigned_shr(1) & 0x7f) as i8;
+    let N: i8 = 0x80u8 as i8;
+
+    u = ease8InOutQuad(u);
+    v = ease8InOutQuad(v);
+
+    let X1: i8 = lerp7by8(grad8(P(AA), xx, yy), grad8(P(BA), xx.wrapping_sub(N), yy), u);
+    let X2: i8 = lerp7by8(grad8(P(AB), xx, yy.wrapping_sub(N)), grad8(P(BB), xx.wrapping_sub(N), yy.wrapping_sub(N)), u);
+
+    return lerp7by8(X1, X2, v) as u8;
+}
+
+pub fn inoise8(x: i16, y: i16) -> u8 {
+    let mut n: i8 = inoise8_raw(x as u16, y as u16) as i8;
+    n = n.wrapping_add(64);
+    return n.saturating_add(n) as u8;
+}

src/lib8/trig.rs

@@ -0,0 +1,32 @@
+use num::PrimInt;
+
+const b_m16_interleave: [u8; 8] = [0, 49, 49, 41, 90, 27, 117, 10];
+
+pub fn sin8(theta: u8) -> u8 {
+    let mut offset: u8 = theta;
+    if theta & 0x40 != 0 {
+        offset = 255 - offset;
+    }
+    offset &= 0x3f;
+
+    let mut secoffset: u8 = offset & 0x0f;
+    if theta & 0x40 != 0 {
+        secoffset += 1;
+    }
+
+    let section: u8 = offset.unsigned_shr(4);
+    let s2: u8 = section * 2;
+    let b: u8 = b_m16_interleave[s2 as usize];
+    let m16: u8 = b_m16_interleave[s2 as usize + 1];
+    let mx: u8 = m16.wrapping_mul(secoffset).unsigned_shr(4);
+    let mut y: i8 = mx as i8 + b as i8;
+    if theta & 0x80 != 0 {
+        y = -y;
+    }
+    y = y.wrapping_add(128u8 as i8);
+    return y as u8;
+}
+
+pub fn cos8(theta: u8) -> u8 {
+    sin8(theta.wrapping_add(64))
+}

src/mappings.rs

@@ -1,6 +1,6 @@
 use crate::geometry::*;
 
-use crate::lib8::scale8;
+use crate::lib8::interpolate::scale8;
 
 use std::cmp::max;
 use std::fmt::{Formatter, Debug};