renderbug: first implementation of virtual coordinate based rendering

src/render.rs

@@ -1,21 +1,18 @@
-use embedded_graphics::{
-    prelude::*,
-    pixelcolor::Rgb888
-};
-use ws2812_esp32_rmt_driver::lib_embedded_graphics::{Ws2812DrawTarget, LedPixelShape};
-
 use std::rc::Rc;
 use std::cell::RefCell;
-
-use running_average::RealTimeRunningAverage;
+use std::sync::{Arc, Mutex};
+use palette::blend::{BlendWith, Equations, Parameter, PreAlpha};
 
 use crate::task;
 use crate::lib8::RGB8;
 use crate::power;
 use crate::time::Periodically;
+use crate::geometry::*;
+
+use std::time::Instant;
 
 pub trait Shader: Send {
-    fn draw(&self, coords: Point) -> RGB8;
+    fn draw(&self, surface_coords: VirtualCoordinates) -> RGB8;
 }
 
 pub trait Surfaces {
@@ -41,94 +38,41 @@ T: Display {
     }
 }
 
-struct ShaderSlot {
-    shader: Option<Box<dyn Shader>>
+struct ShaderBinding {
+    shader: Option<Box<dyn Shader>>,
+    opacity: u8,
 }
 
+#[derive(Clone)]
 pub struct Surface {
-    slot: Rc<RefCell<ShaderSlot>>
+    pub binding: Arc<Mutex<ShaderBinding>>
 }
 
 impl Surface {
-    fn new(slot: Rc<RefCell<ShaderSlot>>) -> Self {
+    pub fn new() -> Self {
         Self {
-            slot: slot
+            binding: Arc::new(Mutex::new(ShaderBinding {
+                shader: None,
+                opacity: 255,
+            })),
+        }
+    }
+
+    pub fn with_shader<F: FnOnce(&dyn Shader)>(&self, f: F) {
+        if let Some(ref shader) = self.binding.lock().unwrap().shader {
+            f(shader.as_ref());
         }
     }
 
     pub fn set_shader(&mut self, shader: Box<dyn Shader>) {
-        self.slot.borrow_mut().shader = Some(shader);
-    }
-}
-
-pub struct EmbeddedDisplay<T>
-where
-T: DrawTarget {
-    shaders : RefCell<Vec<Rc<RefCell<ShaderSlot>>>>,
-    target: T,
-    total_mw: u32,
-    max_mw: u32,
-    fps: RealTimeRunningAverage<u32>,
-    frame: u32,
-    fps_display: Periodically
-}
-
-impl<T> EmbeddedDisplay<T>
-where
-T: DrawTarget {
-    pub fn new(target: T, max_mw: u32) -> Self {
-        EmbeddedDisplay {
-            shaders: RefCell::new(Vec::new()),
-            target: target,
-            max_mw: max_mw,
-            total_mw: 0,
-            fps: RealTimeRunningAverage::default(),
-            frame: 0,
-            fps_display: Periodically::new_every_n_seconds(5)
-        }
-    }
-}
-
-impl<T> Surfaces for EmbeddedDisplay<T>
-where
-T: DrawTarget {
-    fn new_surface(&mut self) -> Surface {
-        let slot = Rc::new(RefCell::new(ShaderSlot {
-            shader: None
-        }));
-        let surface = Surface::new(slot.clone());
-        self.shaders.borrow_mut().push(slot);
-        return surface;
-    }
-}
-
-impl<T: LedPixelShape> Display for EmbeddedDisplay<Ws2812DrawTarget<'_, T>> {
-    fn start_frame(&mut self) {
-        self.target.clear(Rgb888::BLACK).unwrap();
-        self.total_mw = 0;
-        self.frame = self.frame.wrapping_add(1);
-    }
-
-    fn end_frame(&mut self) {
-        let brightness = power::brightness_for_mw(self.total_mw, 255, self.max_mw);
-        self.target.set_brightness(brightness);
-        self.target.flush().unwrap();
-        self.fps.insert(1);
-        self.fps_display.run(|| {
-            log::info!("FPS: {} frame={} brightness={} mw={}", self.fps.measurement(), self.frame, brightness, self.total_mw);
-        });
-    }
-
-    fn render_frame(&mut self) {
-        for slot in self.shaders.borrow().iter() {
-            if let Some(ref shader) = slot.borrow().shader {
-                for i in 0..T::size().width {
-                    let coords = Point::new(i as i32, 0);
-                    let color = shader.draw(coords);
-                    self.total_mw += power::color_to_mw(&color);
-                    Pixel(coords, Rgb888::new(color.red, color.green, color.blue)).draw(&mut self.target).unwrap();
-                }
-            }
-        }
+        self.binding.lock().unwrap().shader = Some(shader);
+    }
+
+    pub fn clear_shader(&mut self) {
+        self.binding.lock().unwrap().shader = None;
+    }
+
+    pub fn set_opacity(&mut self, opacity: u8) {
+        self.binding.lock().unwrap().opacity = opacity;
     }
 }