157 lines
4.0 KiB
Rust
157 lines
4.0 KiB
Rust
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>,
|
|
opacity: u8
|
|
}
|
|
|
|
#[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)
|
|
.field("opacity", &self.binding.borrow().opacity)
|
|
.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(),
|
|
opacity: 255
|
|
})),
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
fn set_rect(&mut self, rect: &Rectangle<u8, Virtual>) {
|
|
self.binding.borrow_mut().rect = rect.clone();
|
|
}
|
|
|
|
fn opacity(&self) -> u8 {
|
|
self.binding.borrow().opacity
|
|
}
|
|
|
|
fn set_opacity(&mut self, opacity: u8) {
|
|
self.binding.borrow_mut().opacity = opacity
|
|
}
|
|
}
|
|
|
|
#[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 mut surface = S::default();
|
|
surface.set_rect(area);
|
|
self.surfaces.push(surface.clone());
|
|
return Ok(surface);
|
|
}
|
|
}
|