Final round of fixes for new version

rog-client/examples/animatrix.rs

@@ -0,0 +1,42 @@
+use rog_client::{AniMeDbusWriter, AniMeMatrix, AniMePacketType, HEIGHT, WIDTH};
+use tinybmp::{Bmp, Pixel};
+
+fn main() {
+    let mut writer = AniMeDbusWriter::new().unwrap();
+
+    let bmp =
+        Bmp::from_slice(include_bytes!("non-skewed_r.bmp")).expect("Failed to parse BMP image");
+    let pixels: Vec<Pixel> = bmp.into_iter().collect();
+    //assert_eq!(pixels.len(), 56 * 56);
+
+    // Try an outline, top and right
+    let mut matrix = AniMeMatrix::new();
+
+    // Aligned left
+    for px in pixels {
+        if (px.x as usize / 2) < WIDTH && (px.y as usize) < HEIGHT {
+            if px.x % 2 == 0 {
+                matrix.get_mut()[px.y as usize][px.x as usize / 2] = px.color as u8;
+            }
+        }
+    }
+
+    // Throw an alignment border up
+    // {
+    //     let tmp = matrix.get_mut();
+    //     for x in tmp[0].iter_mut() {
+    //         *x = 0xff;
+    //     }
+    //     for row in tmp.iter_mut() {
+    //         row[row.len() - 1] = 0xff;
+    //     }
+    // }
+
+    matrix.debug_print();
+
+    let mut matrix: AniMePacketType = AniMePacketType::from(matrix);
+    // println!("{:?}", matrix[0].to_vec());
+    // println!("{:?}", matrix[1].to_vec());
+
+    writer.write_image(&mut matrix).unwrap();
+}

rog-client/examples/ball.rs

@@ -0,0 +1,94 @@
+use rog_client::{AuraDbusWriter, GX502Layout, Key, KeyColourArray, KeyLayout};
+use std::collections::LinkedList;
+
+#[derive(Debug, Clone)]
+struct Ball {
+    position: (i32, i32),
+    direction: (i32, i32),
+    trail: LinkedList<(i32, i32)>,
+}
+impl Ball {
+    fn new(x: i32, y: i32, trail_len: u32) -> Self {
+        let mut trail = LinkedList::new();
+        for _ in 1..=trail_len {
+            trail.push_back((x, y));
+        }
+
+        Ball {
+            position: (x, y),
+            direction: (1, 1),
+            trail,
+        }
+    }
+
+    fn update(&mut self, key_map: &Vec<[Key; 17]>) {
+        let pos = self.position;
+        let dir = self.direction;
+
+        if pos.0 + dir.0 > key_map[pos.1 as usize].len() as i32 - 1 || pos.0 + dir.0 < 0 {
+            self.direction.0 *= -1;
+        } else if key_map[(pos.1) as usize][(pos.0 + dir.0) as usize] == Key::None {
+            self.direction.0 *= -1;
+        }
+
+        if pos.1 + dir.1 > key_map.len() as i32 - 1 || pos.1 + dir.1 < 0 {
+            self.direction.1 *= -1;
+        } else if key_map[(pos.1 + dir.1) as usize][(pos.0) as usize] == Key::None {
+            self.direction.1 *= -1;
+        }
+
+        self.trail.pop_front();
+        self.trail.push_back(self.position);
+
+        self.position.0 += self.direction.0;
+        self.position.1 += self.direction.1;
+
+        if self.position.0 > key_map[self.position.1 as usize].len() as i32 {
+            self.position.0 = key_map[self.position.1 as usize].len() as i32 - 1;
+        }
+    }
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut writer = AuraDbusWriter::new()?;
+
+    let mut colours = KeyColourArray::new();
+
+    let layout = GX502Layout::default();
+
+    let mut balls = [Ball::new(2, 1, 12), Ball::new(4, 6, 12)];
+
+    writer.init_effect()?;
+
+    let rows = layout.get_rows();
+    loop {
+        for (n, ball) in balls.iter_mut().enumerate() {
+            ball.update(rows);
+            for (i, pos) in ball.trail.iter().enumerate() {
+                if let Some(c) = colours.key(rows[pos.1 as usize][pos.0 as usize]) {
+                    *c.0 = 0;
+                    *c.1 = 0;
+                    *c.2 = 0;
+                    if n == 0 {
+                        *c.0 = i as u8 * (255 / ball.trail.len() as u8);
+                    } else if n == 1 {
+                        *c.1 = i as u8 * (255 / ball.trail.len() as u8);
+                    } else if n == 2 {
+                        *c.2 = i as u8 * (255 / ball.trail.len() as u8);
+                    }
+                };
+            }
+
+            if let Some(c) = colours.key(rows[ball.position.1 as usize][ball.position.0 as usize]) {
+                *c.0 = 255;
+                *c.1 = 255;
+                *c.2 = 255;
+            };
+        }
+
+        writer.write_colour_block(&colours)?;
+
+        // can change 100 times per second, so need to slow it down
+        std::thread::sleep(std::time::Duration::from_millis(60));
+    }
+}

rog-client/examples/comet.rs

@@ -0,0 +1,28 @@
+use rog_client::{AuraDbusWriter, GX502Layout, KeyColourArray, KeyLayout};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut writer = AuraDbusWriter::new()?;
+
+    let layout = GX502Layout::default();
+
+    writer.init_effect()?;
+    let rows = layout.get_rows();
+
+    let mut column = 0;
+    loop {
+        let mut key_colours = KeyColourArray::new();
+        for row in rows {
+            if let Some(c) = key_colours.key(row[column as usize]) {
+                *c.0 = 255;
+            };
+        }
+        if column == rows[0].len() - 1 {
+            column = 0
+        } else {
+            column += 1;
+        }
+
+        writer.write_colour_block(&key_colours)?;
+        std::thread::sleep(std::time::Duration::from_millis(250));
+    }
+}

rog-client/examples/iterate-keys.rs

@@ -0,0 +1,53 @@
+use rog_client::{AuraDbusWriter, GX502Layout, Key, KeyColourArray, KeyLayout};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut writer = AuraDbusWriter::new()?;
+
+    let mut key_colours = KeyColourArray::new();
+    let layout = GX502Layout::default();
+
+    writer.init_effect()?;
+    let rows = layout.get_rows();
+    loop {
+        for (r, row) in rows.iter().enumerate() {
+            for (k, key) in row.iter().enumerate() {
+                if let Some(c) = key_colours.key(*key) {
+                    *c.0 = 255;
+                };
+                // Last key of previous row
+                if k == 0 {
+                    if r == 0 {
+                        let k = &rows[rows.len() - 1][rows[rows.len() - 1].len() - 1];
+                        if let Some(c) = key_colours.key(*k) {
+                            *c.0 = 0;
+                        };
+                    } else {
+                        let k = &rows[r - 1][rows[r - 1].len() - 1];
+                        if let Some(c) = key_colours.key(*k) {
+                            *c.0 = 0;
+                        };
+                    }
+                } else {
+                    let k = &rows[r][k - 1];
+                    if let Some(c) = key_colours.key(*k) {
+                        *c.0 = 0;
+                    };
+                }
+                if let Some(c) = key_colours.key(Key::Up) {
+                    *c.0 = 255;
+                };
+                *key_colours.key(Key::Left).unwrap().0 = 255;
+                *key_colours.key(Key::Right).unwrap().0 = 255;
+                *key_colours.key(Key::Down).unwrap().0 = 255;
+
+                *key_colours.key(Key::W).unwrap().0 = 255;
+                *key_colours.key(Key::A).unwrap().0 = 255;
+                *key_colours.key(Key::S).unwrap().0 = 255;
+                *key_colours.key(Key::D).unwrap().0 = 255;
+
+                writer.write_colour_block(&key_colours)?;
+                std::thread::sleep(std::time::Duration::from_millis(100));
+            }
+        }
+    }
+}

rog-client/examples/per-key-effect-2.rs

@@ -0,0 +1,30 @@
+use rog_client::{AuraDbusWriter, Key, KeyColourArray};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut writer = AuraDbusWriter::new()?;
+
+    let mut key_colours = KeyColourArray::new();
+
+    writer.init_effect()?;
+    loop {
+        let count = 49;
+        for _ in 0..count {
+            *key_colours.key(Key::ROG).unwrap().0 += 5;
+            *key_colours.key(Key::L).unwrap().0 += 5;
+            *key_colours.key(Key::I).unwrap().0 += 5;
+            *key_colours.key(Key::N).unwrap().0 += 5;
+            *key_colours.key(Key::U).unwrap().0 += 5;
+            *key_colours.key(Key::X).unwrap().0 += 5;
+            writer.write_colour_block(&key_colours)?;
+        }
+        for _ in 0..count {
+            *key_colours.key(Key::ROG).unwrap().0 -= 5;
+            *key_colours.key(Key::L).unwrap().0 -= 5;
+            *key_colours.key(Key::I).unwrap().0 -= 5;
+            *key_colours.key(Key::N).unwrap().0 -= 5;
+            *key_colours.key(Key::U).unwrap().0 -= 5;
+            *key_colours.key(Key::X).unwrap().0 -= 5;
+            writer.write_colour_block(&key_colours)?;
+        }
+    }
+}

rog-client/examples/pulser.rs

@@ -0,0 +1,37 @@
+use rog_client::{AuraDbusWriter, GX502Layout, KeyColourArray, KeyLayout};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut writer = AuraDbusWriter::new()?;
+
+    let mut key_colours = KeyColourArray::new();
+    let layout = GX502Layout::default();
+
+    writer.init_effect()?;
+    let rows = layout.get_rows();
+
+    let mut fade = 50;
+    let mut flip = false;
+    loop {
+        for row in rows {
+            for (k, key) in row.iter().enumerate() {
+                if let Some(c) = key_colours.key(*key) {
+                    *c.0 = 255 / fade / (k + 1) as u8;
+                };
+            }
+        }
+
+        writer.write_colour_block(&key_colours)?;
+
+        if flip {
+            if fade > 1 {
+                fade -= 1;
+            } else {
+                flip = !flip;
+            }
+        } else if fade < 17 {
+            fade += 1;
+        } else {
+            flip = !flip;
+        }
+    }
+}