src: rewrite display to have generic surface implementations

src/render.rs

@@ -1,55 +1,47 @@
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::sync::{Arc, Mutex};
-use palette::blend::{BlendWith, Equations, Parameter, PreAlpha};
+use std::io;
 
-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, surface_coords: VirtualCoordinates) -> RGB8;
 }
 
-pub trait Surfaces {
-    fn new_surface(&mut self) -> Surface;
+pub trait Surface {
+    fn with_shader<F: FnMut(&dyn Shader)>(&self, f: F);
+    fn set_shader(&mut self, shader: Box<dyn Shader>);
+    fn clear_shader(&mut self);
+    fn set_opacity(&mut self, opacity: u8);
 }
 
-pub trait Display: Surfaces {
+pub trait Surfaces<T: Surface> {
+    fn new_surface(&mut self) -> Result<T, io::Error>;
+}
+
+pub trait Display<T: Surface>: Surfaces<T> {
     fn start_frame(&mut self) {}
     fn end_frame(&mut self) {}
-
-    fn render_frame(&mut self) {}
+    fn render_frame(&mut self);
 }
 
-impl<T> task::Task for T
-where
-T: Display {
-    fn name(&self) -> &'static str { "Renderer" }
-
-    fn tick(&mut self) {
-        self.start_frame();
-        self.render_frame();
-        self.end_frame();
-    }
-}
-
-struct ShaderBinding {
+pub struct ShaderBinding {
     shader: Option<Box<dyn Shader>>,
     opacity: u8,
 }
 
 #[derive(Clone)]
-pub struct Surface {
-    pub binding: Arc<Mutex<ShaderBinding>>
+pub struct BoundSurface<T> {
+    pub binding: T
 }
 
-impl Surface {
-    pub fn new() -> Self {
+pub type SharedSurface = BoundSurface<Arc<Mutex<ShaderBinding>>>;
+pub type SimpleSurface = BoundSurface<Rc<RefCell<ShaderBinding>>>;
+
+impl Default for BoundSurface<Arc<Mutex<ShaderBinding>>> {
+    fn default() -> Self {
         Self {
             binding: Arc::new(Mutex::new(ShaderBinding {
                 shader: None,
@@ -57,22 +49,79 @@ impl Surface {
             })),
         }
     }
+}
 
-    pub fn with_shader<F: FnOnce(&dyn Shader)>(&self, f: F) {
+impl Default for BoundSurface<Rc<RefCell<ShaderBinding>>>{
+    fn default() -> Self {
+        Self {
+            binding: Rc::new(RefCell::new(ShaderBinding {
+                shader: None,
+                opacity: 255,
+            })),
+        }
+    }
+}
+
+impl Surface for BoundSurface<Rc<RefCell<ShaderBinding>>> {
+    fn with_shader<F: FnMut(&dyn Shader)>(&self, mut f: F) {
+        if let Some(ref shader) = self.binding.borrow().shader {
+            f(shader.as_ref());
+        }
+    }
+
+    fn set_shader(&mut self, shader: Box<dyn Shader>) {
+        self.binding.borrow_mut().shader = Some(shader);
+    }
+
+    fn clear_shader(&mut self) {
+        self.binding.borrow_mut().shader = None;
+    }
+
+    fn set_opacity(&mut self, opacity: u8) {
+        self.binding.borrow_mut().opacity = opacity;
+    }
+}
+
+impl Surface for BoundSurface<Arc<Mutex<ShaderBinding>>> {
+    fn with_shader<F: FnMut(&dyn Shader)>(&self, mut 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>) {
+    fn set_shader(&mut self, shader: Box<dyn Shader>) {
         self.binding.lock().unwrap().shader = Some(shader);
     }
 
-    pub fn clear_shader(&mut self) {
+    fn clear_shader(&mut self) {
         self.binding.lock().unwrap().shader = None;
     }
 
-    pub fn set_opacity(&mut self, opacity: u8) {
+    fn set_opacity(&mut self, opacity: u8) {
         self.binding.lock().unwrap().opacity = opacity;
     }
 }
+
+pub struct SurfacePool<S: Surface + Default> {
+    surfaces: Vec<S>
+}
+
+impl<S: Surface + Default> SurfacePool<S> {
+    pub const fn new() -> Self {
+        Self {
+            surfaces: Vec::new()
+        }
+    }
+
+    pub fn iter(&self) -> std::slice::Iter<S> {
+        self.surfaces.iter()
+    }
+}
+
+impl<S: Surface + Default + Clone> Surfaces<S> for SurfacePool<S> {
+    fn new_surface(&mut self) -> Result<S, io::Error> {
+        let surface = S::default();
+        self.surfaces.push(surface.clone());
+        return Ok(surface);
+    }
+}