1786003924

src/trekstor/input.rs

@@ -0,0 +1,100 @@
+use super::screen::Screen;
+use std::collections::HashSet;
+
+use evdev::{AbsoluteAxisCode, Device, EventSummary, KeyCode};
+
+pub struct InputState {
+    device: Device,
+    pub x: i32,
+    pub y: i32,
+    width: i32,
+    height: i32,
+    keys_down: HashSet<KeyCode>,
+    keys_pressed_this_update: HashSet<KeyCode>,
+    keys_released_this_update: HashSet<KeyCode>,
+    clear_before_next_event: bool,
+}
+
+impl InputState {
+    pub fn new(screen: &Screen) -> Self {
+        let Ok(device) = Device::open("/dev/input/event4") else {
+            panic!("No TS");
+        };
+
+        device.set_nonblocking(true).unwrap();
+
+        Self {
+            device,
+            x: 0,
+            y: 0,
+            width: screen.width() as i32,
+            height: screen.height() as i32,
+            keys_down: HashSet::new(),
+            keys_pressed_this_update: HashSet::new(),
+            keys_released_this_update: HashSet::new(),
+            clear_before_next_event: true,
+        }
+    }
+
+    pub(super) fn next_loop(&mut self) {
+        self.clear_before_next_event = true;
+    }
+
+    pub(super) fn handle_event(&mut self) {
+        let Ok(events) = self.device.fetch_events() else {
+            return;
+        };
+
+        if self.clear_before_next_event {
+            self.keys_pressed_this_update.clear();
+            self.keys_released_this_update.clear();
+            self.clear_before_next_event = false;
+        }
+
+        for event in events {
+            match event.destructure() {
+                EventSummary::AbsoluteAxis(_, AbsoluteAxisCode::ABS_X, value) => {
+                    self.x = (((value - 13) as f32 / 882.) * (self.width as f32)) as i32;
+                }
+                EventSummary::AbsoluteAxis(_, AbsoluteAxisCode::ABS_Y, value) => {
+                    self.y = (((value - 13) as f32 / 624.) * (self.height as f32)) as i32;
+                }
+                EventSummary::Key(_, key, value) => match value {
+                    1 => {
+                        if !self.keys_down.contains(&key) {
+                            self.keys_pressed_this_update.insert(key);
+                        }
+                        self.keys_down.insert(key);
+                    }
+                    0 => {
+                        if self.keys_down.contains(&key) {
+                            self.keys_released_this_update.insert(key);
+                        }
+                        self.keys_down.remove(&key);
+                    }
+                    _ => {}
+                },
+                _ => {}
+            }
+        }
+    }
+}
+
+#[allow(unused)]
+impl InputState {
+    pub fn is_just_pressed(&self, key: KeyCode) -> bool {
+        self.keys_pressed_this_update.contains(&key)
+    }
+
+    pub fn is_down(&self, key: KeyCode) -> bool {
+        self.keys_down.contains(&key)
+    }
+
+    pub fn is_just_released(&self, key: KeyCode) -> bool {
+        self.keys_released_this_update.contains(&key)
+    }
+
+    pub fn is_up(&self, key: KeyCode) -> bool {
+        !self.is_down(key)
+    }
+}

src/trekstor/screen.rs

@@ -0,0 +1,76 @@
+use embedded_graphics::{pixelcolor::Rgb888, prelude::*, primitives::Rectangle};
+use linfb::{Framebuffer, shape::Color};
+
+use crate::rgba::Rgba;
+
+pub struct Screen {
+    framebuffer: Framebuffer,
+    width: u32,
+    height: u32,
+}
+
+impl Screen {
+    pub fn new() -> Self {
+        let framebuffer = Framebuffer::open().expect("Failed to open framebuffer");
+
+        let width = framebuffer.screen_info.xres;
+        let height = framebuffer.screen_info.yres;
+
+        Self {
+            framebuffer,
+            width,
+            height,
+        }
+    }
+
+    pub fn flush(&mut self) {
+        self.framebuffer.flush();
+    }
+
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.height
+    }
+}
+
+impl Dimensions for Screen {
+    fn bounding_box(&self) -> Rectangle {
+        Rectangle::new(Point::new(0, 0), Size::new(self.width, self.height))
+    }
+}
+
+impl DrawTarget for Screen {
+    type Color = Rgba<Rgb888>;
+    type Error = Box<dyn std::error::Error>;
+
+    fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
+    where
+        I: IntoIterator<Item = embedded_graphics::Pixel<Self::Color>>,
+    {
+        let width = self.bounding_box().size.width;
+        let height = self.bounding_box().size.height;
+
+        for p in pixels {
+            let x = p.0.x as u32;
+            let y = p.0.y as u32;
+
+            let color = Color {
+                red: p.1.r(),
+                green: p.1.g(),
+                blue: p.1.b(),
+                alpha: p.1.a(),
+            };
+
+            if !(0..width).contains(&x) || !(0..height).contains(&y) {
+                continue;
+            }
+
+            self.framebuffer.set_pixel(x, y, color);
+        }
+
+        Ok(())
+    }
+}