1786012991

src/rgba.rs

@@ -1,5 +1,6 @@
 use embedded_graphics_core::pixelcolor::*;
 use linfb::shape::Color;
+use slint::platform::software_renderer::TargetPixel;
 
 /// Simple RGBA color wrapper.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -80,28 +81,45 @@ impl Blend<Rgb888> for Rgba<Rgb888> {
     }
 }
 
-impl From<(u8,u8,u8,u8)> for Rgba<Rgb888> {
+impl TargetPixel for Rgba<Rgb888> {
-    fn from(value: (u8,u8,u8,u8)) -> Self {
+    fn blend(&mut self, color: slint::platform::software_renderer::PremultipliedRgbaColor) {
-        Self(
+        let a = self.a() as u32;
-            Rgb888::new(
+        // if a == 0 {
-                value.0,
+        //     return bg;
-                value.1,
+        // }
-                value.2,
+        // if a == 255 {
-            ),
+        //     return self.rgb();
-            value.3,
+        // }
-        )
+
+        let fr = self.rgb().r() as u32;
+        let fg = self.rgb().g() as u32;
+        let fb = self.rgb().b() as u32;
+
+        let br = color.red as u32;
+        let bgc = color.green as u32;
+        let bb = color.blue 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;
+
+        self.0 = Rgb888::new(r, g, b);
+        self.1 = a as u8;
+    }
+
+    fn from_rgb(red: u8, green: u8, blue: u8) -> Self {
+        Self(Rgb888::new(red, green, blue), 255)
+    }
+}
+
+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(
+        Self(Rgb888::new(value.red, value.green, value.blue), value.alpha)
-            Rgb888::new(
-                value.red,
-                value.green,
-                value.blue,
-            ),
-            value.alpha,
-        )
     }
 }

src/trekstor.rs

@@ -2,11 +2,14 @@ use std::rc::Rc;
 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
+use embedded_graphics::prelude::DrawTarget;
 use evdev::KeyCode;
 use slint::LogicalPosition;
 use slint::platform::software_renderer::{MinimalSoftwareWindow, RepaintBufferType};
 use slint::platform::{Platform, WindowEvent};
 
+use crate::rgba::Rgba;
+
 use self::input::InputState;
 use self::screen::Screen;
 
@@ -50,8 +53,9 @@ impl<S> Trekstor<S> {
     }
 
     pub fn update(&mut self) {
-        dbg!(self.ctx.screen.width() * self.ctx.screen.height());
+        // dbg!(self.ctx.screen.width() * self.ctx.screen.height());
-        let mut buffer1 = [slint::platform::software_renderer::Rgb565Pixel(0); 1];
+
+        let mut buffer1 = [Rgba::from((0, 0, 0, 0)); 614400];
 
         loop {
             self.current_time = Instant::now();
@@ -94,6 +98,11 @@ impl<S> Trekstor<S> {
                 renderer.render(&mut buffer1, self.ctx.screen.width() as usize);
             });
 
+            self.ctx
+                .screen
+                .fill_contiguous(&self.ctx.screen.rect(), buffer1)
+                .unwrap();
+
             self.ctx.screen.flush();
             self.ctx.input.finish();
         }

src/trekstor/screen.rs

@@ -27,13 +27,26 @@ impl Screen {
         self.framebuffer.flush();
     }
 
+    #[inline]
     pub fn width(&self) -> u32 {
         self.width
     }
 
+    #[inline]
     pub fn height(&self) -> u32 {
         self.height
     }
+
+    #[inline]
+    pub fn rect(&self) -> Rectangle {
+        Rectangle {
+            top_left: Point::new(0, 0),
+            size: Size {
+                width: self.width(),
+                height: self.height(),
+            },
+        }
+    }
 }
 
 impl Dimensions for Screen {