103 lines
2.8 KiB
Rust
103 lines
2.8 KiB
Rust
use {
|
|
prisma::{Rgb},
|
|
cgmath::{Vector2},
|
|
std::boxed::Box,
|
|
crate::{
|
|
view::ColorGrid,
|
|
fpsstat::{FpsStat}
|
|
}
|
|
};
|
|
|
|
pub trait FixtureDriver {
|
|
fn send(&mut self, pixels: &Vec<Rgb<u8>>);
|
|
fn sync(&mut self);
|
|
|
|
fn connect_info(&self) -> String;
|
|
fn avg_fps(&self) -> f32;
|
|
}
|
|
|
|
pub struct Fixture {
|
|
pub resolution: Vector2<u32>,
|
|
pub position: Vector2<f32>,
|
|
pub rotation: f32,
|
|
pub scale: f32,
|
|
pub mirror_y: bool,
|
|
pub brightness: f32,
|
|
pub buffer: Vec< Rgb<u8> >,
|
|
pub driver: Option<Box<dyn FixtureDriver>>,
|
|
}
|
|
|
|
impl Fixture {
|
|
pub fn new_stripe(mirror_y: bool) -> Self {
|
|
let mut fixture = Fixture {
|
|
resolution: Vector2::new(1, 72),
|
|
position: Vector2::new(0.0, 0.0),
|
|
rotation: 0.0,
|
|
scale: 0.015,
|
|
brightness: 0.8,
|
|
mirror_y,
|
|
buffer: Vec::new(),
|
|
driver: None
|
|
};
|
|
fixture.buffer.resize(
|
|
(fixture.resolution.x*fixture.resolution.y) as usize,
|
|
Rgb::new(0,0,0));
|
|
fixture
|
|
}
|
|
|
|
pub fn new_matrix() -> Self {
|
|
let mut fixture = Fixture {
|
|
resolution: Vector2::new(15, 20),
|
|
position: Vector2::new(0.0, 0.0),
|
|
rotation: 0.0,
|
|
scale: 0.03,
|
|
mirror_y: false,
|
|
brightness: 0.8,
|
|
buffer: Vec::new(),
|
|
driver: None
|
|
};
|
|
fixture.buffer.resize(
|
|
(fixture.resolution.x*fixture.resolution.y) as usize,
|
|
Rgb::new(0,0,0)
|
|
);
|
|
fixture
|
|
}
|
|
|
|
pub fn with_driver(mut self, driver: Box<dyn FixtureDriver>) -> Self {
|
|
self.driver = Some(driver);
|
|
self
|
|
}
|
|
|
|
pub fn offset(mut self, offset: Vector2<f32>) -> Self {
|
|
self.position += offset;
|
|
self
|
|
}
|
|
|
|
pub fn get_global_pos(&self, pixel_pos: &Vector2<u32>) -> Vector2<f32> {
|
|
let centered_pixpos : Vector2<f32>
|
|
= pixel_pos.map(|f| f as f32) - (self.resolution.map(|f| f as f32)/2.0);
|
|
self.position + centered_pixpos * self.scale
|
|
}
|
|
|
|
pub fn update_buffer(&mut self, view: &dyn crate::view::Animation) {
|
|
for xi in 0 .. self.resolution.x {
|
|
for yi in 0 ..self.resolution.y {
|
|
let gpos = self.get_global_pos(&Vector2::new(xi, yi));
|
|
let col = view.get(&gpos);
|
|
|
|
let yi = if self.mirror_y {
|
|
self.resolution.y - 1 - yi
|
|
} else {
|
|
yi
|
|
};
|
|
let index = xi + yi * self.resolution.x;
|
|
self.buffer[index as usize] = Rgb::new(
|
|
(col.red() * 255.0 * self.brightness) as u8,
|
|
(col.green() * 255.0 * self.brightness) as u8,
|
|
(col.blue() * 255.0 * self.brightness) as u8
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|