buffers: split out concrete surface and pixbuf implementations into a buffers module

src/buffers.rs

@@ -0,0 +1,140 @@
+use crate::geometry::*;
+use crate::render::{Surface, Shader, Surfaces};
+
+use std::fmt::{Debug, Formatter};
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::io;
+
+#[cfg(feature="threads")]
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct ShaderBinding {
+    shader: Option<Box<dyn Shader>>,
+    rect: Rectangle<u8, Virtual>
+}
+
+#[derive(Clone)]
+pub struct BoundSurface<T> {
+    pub binding: T
+}
+
+impl Debug for BoundSurface<Rc<RefCell<ShaderBinding>>> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BoundSurface")
+        .field("shader", &self.binding.borrow().shader)
+        .finish()
+    }
+}
+
+pub type SimpleSurface = BoundSurface<Rc<RefCell<ShaderBinding>>>;
+
+impl Default for BoundSurface<Rc<RefCell<ShaderBinding>>>{
+    fn default() -> Self {
+        Self {
+            binding: Rc::new(RefCell::new(ShaderBinding {
+                shader: None,
+                rect: Rectangle::everything()
+            })),
+        }
+    }
+}
+
+impl Surface for BoundSurface<Rc<RefCell<ShaderBinding>>> {
+    fn rect(&self) -> Rectangle<u8, Virtual> {
+        self.binding.borrow().rect.clone()
+    }
+
+    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;
+    }
+}
+
+#[cfg(feature="threads")]
+pub type SharedSurface = BoundSurface<Arc<Mutex<ShaderBinding>>>;
+
+#[cfg(feature="threads")]
+impl Default for BoundSurface<Arc<Mutex<ShaderBinding>>> {
+    fn default() -> Self {
+        Self {
+            binding: Arc::new(Mutex::new(ShaderBinding {
+                shader: None,
+                rect: Rectangle::everything()
+            })),
+        }
+    }
+}
+
+#[cfg(feature="threads")]
+impl Surface for BoundSurface<Arc<Mutex<ShaderBinding>>> {
+    fn rect(&self) -> Rectangle<u8, Virtual> {
+        let r = self.binding.lock().unwrap();
+        r.rect.clone()
+        //self.binding.lock().unwrap().rect.clone()
+    }
+
+    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());
+        }
+    }
+
+    fn set_shader(&mut self, shader: Box<dyn Shader>) {
+        self.binding.lock().unwrap().shader = Some(shader);
+    }
+
+    fn clear_shader(&mut self) {
+        self.binding.lock().unwrap().shader = None;
+    }
+}
+
+#[cfg(feature="threads")]
+impl Debug for BoundSurface<Arc<Mutex<ShaderBinding>>> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BoundSurface")
+        .field("shader", &self.binding.lock().unwrap().shader)
+        .finish()
+    }
+}
+
+#[derive(Clone)]
+pub struct SurfacePool<S: Surface + Default> {
+    surfaces: Vec<S>
+}
+
+impl<S: Surface + Debug> Debug for SurfacePool<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.surfaces.fmt(f)
+    }
+}
+
+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> Surfaces<S> for SurfacePool<S> {
+    fn new_surface(&mut self, _area: &Rectangle<u8, Virtual>) -> Result<S, io::Error> {
+        let surface = S::default();
+        self.surfaces.push(surface.clone());
+        return Ok(surface);
+    }
+}