andr3/lights
1
0
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

increased render time
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
Andre Henriques 2023-04-14 19:21:09 +01:00
parent df820fa7d8
commit 8f915d1020
1 changed files with 121 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

214
src/render.rs
View File

@ -1,16 +1,16 @@
use ws281x_rpi::Ws2812Rpi;
use crate::{DBPool, animations::Animation};
use crate::{animations::Animation, DBPool};
use smart_leds::{SmartLedsWrite, RGB, RGB8};
use std::error::Error;
use smart_leds::{RGB8, SmartLedsWrite, RGB};
use std::time::{SystemTime, UNIX_EPOCH};
#[derive(Clone, Debug)]
struct LocalLedConfiguration {
tag: Option<String>,
start: usize,
end: usize
end: usize,
}
#[derive(Clone)]
@ -24,7 +24,7 @@ pub struct LigthSetting {
#[derive(Clone)]
pub struct KeyFrame {
duration: u128,
settings: Vec<LigthSetting>
settings: Vec<LigthSetting>,
}
#[derive(Clone)]
@ -44,7 +44,7 @@ pub struct Render {
last_render: u128,
last_update: u128,
ws: Option<Ws2812Rpi>,
last: Vec<RGB<f64>>,
@ -59,12 +59,16 @@ struct GetRender {
time: u128,
}
fn try_into_usize (input: Option<u32>) -> Option<usize> {
if input.is_none() {return None;}
fn try_into_usize(input: Option<u32>) -> Option<usize> {
if input.is_none() {
return None;
}
let t: Result<usize, _> = input.unwrap().try_into();
if t.is_err() {return None;}
if t.is_err() {
return None;
}
return t.ok();
}
@ -100,25 +104,31 @@ impl Render {
let stmt = conn.prepare("SELECT ledcount, tags from configuration;");
if stmt.is_err() || stmt.as_ref().ok().is_none() {
Err(format!("Something went wrong while reading the database {:?}", stmt.as_ref().err()))?;
Err(format!(
"Something went wrong while reading the database {:?}",
stmt.as_ref().err()
))?;
}
let mut stmt = stmt?;
struct Data {
ledcount: u32,
tag: String
tag: String,
}
let version_iter = stmt.query_map([], |row| {
Ok(Data {
ledcount: row.get(0)?,
tag: row.get(1)?
tag: row.get(1)?,
})
});
if version_iter.is_err() || version_iter.as_ref().ok().is_none() {
Err(format!("Something went wrong while reading the database {:?}", version_iter.as_ref().err()))?;
Err(format!(
"Something went wrong while reading the database {:?}",
version_iter.as_ref().err()
))?;
}
let version_iter = version_iter.ok().unwrap();
@ -126,12 +136,15 @@ impl Render {
let mut current_pos = 0;
let mut local_led_config = Vec::new();
for data in version_iter {
for data in version_iter {
let data = data?;
let tag = if data.tag.is_empty() { None } else { Some(data.tag) };
let tag = if data.tag.is_empty() {
None
} else {
Some(data.tag)
};
let start = current_pos;
let end = current_pos + data.ledcount;
@ -148,15 +161,14 @@ impl Render {
let start = start.ok().unwrap();
let end = end.ok().unwrap();
local_led_config.push(LocalLedConfiguration {
tag,
start,
end
});
local_led_config.push(LocalLedConfiguration { tag, start, end });
}
self.num_leds = current_pos;
println!("Loaded: {} leds, with config: {:?}", self.num_leds, local_led_config);
println!(
"Loaded: {} leds, with config: {:?}",
self.num_leds, local_led_config
);
self.local_led_config = local_led_config;
self.ws = Some(Ws2812Rpi::new(current_pos as i32, PIN).unwrap());
@ -165,14 +177,13 @@ impl Render {
}
pub fn add_animation(&mut self, animation: Animation) {
println!("Added animation");
let mut key_frames = Vec::new();
for frame in animation.get_frames().iter() {
let mut light_settings = Vec::new();
for setting in frame.get_settings() {
light_settings.push(LigthSetting {
tags: setting.get_tags(),
@ -182,9 +193,12 @@ impl Render {
});
}
key_frames.push(KeyFrame { duration: (frame.get_duration() as u128) * (1000 as u128), settings: light_settings })
key_frames.push(KeyFrame {
duration: (frame.get_duration() as u128) * (1000 as u128),
settings: light_settings,
})
}
let new_animation = RenderAnimation {
key_frames,
priority: animation.get_priority(),
@ -196,7 +210,8 @@ impl Render {
self.animations.push(new_animation);
self.animations.sort_by(|a,b| a.priority.partial_cmp(&b.priority).unwrap())
self.animations
.sort_by(|a, b| a.priority.partial_cmp(&b.priority).unwrap())
}
pub fn blank(&mut self) {
@ -204,17 +219,18 @@ impl Render {
}
pub fn remove_animation(&mut self, animation_name: String) {
self.animations = self.animations.clone().into_iter().filter(|ani| !ani.name.eq(&animation_name)).collect::<Vec<RenderAnimation>>();
self.animations = self
.animations
.clone()
.into_iter()
.filter(|ani| !ani.name.eq(&animation_name))
.collect::<Vec<RenderAnimation>>();
}
pub fn proccess_settings (&mut self, data: &mut Vec<RGB<f64>>, settings: &Vec<LigthSetting>) {
fn load_led_into_light (data: &mut Vec<RGB<f64>>, color: RGB8, start: usize, end: usize) {
pub fn proccess_settings(&mut self, data: &mut Vec<RGB<f64>>, settings: &Vec<LigthSetting>) {
fn load_led_into_light(data: &mut Vec<RGB<f64>>, color: RGB8, start: usize, end: usize) {
for i in start..=end {
data[i] = RGB::new(
color.r as f64,
color.g as f64,
color.b as f64
);
data[i] = RGB::new(color.r as f64, color.g as f64, color.b as f64);
}
}
@ -231,16 +247,23 @@ impl Render {
}
if setting.start.is_some() && setting.end.is_some() {
load_led_into_light(data, setting.color, setting.start.unwrap(), setting.end.unwrap());
load_led_into_light(
data,
setting.color,
setting.start.unwrap(),
setting.end.unwrap(),
);
}
}
}
fn get_render(&mut self) -> GetRender {
let mut data: Vec<RGB<f64>> = vec![RGB::default(); self.num_leds.try_into().unwrap()];
let time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time went backwards").as_millis();
let time = SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("Time went backwards")
.as_millis();
if self.last_render == 0 {
self.last_render = time;
@ -252,58 +275,62 @@ impl Render {
let mut to_clean: Vec<String> = Vec::new();
let animations = self.animations.clone().iter_mut().map(|animation| {
let mut animation = animation.to_owned();
let animations = self
.animations
.clone()
.iter_mut()
.map(|animation| {
let mut animation = animation.to_owned();
let mut start_time = animation.start_time;
let mut start_time = animation.start_time;
if start_time == 0 {
animation.start_time = time;
animation.current_frame = 0;
if start_time == 0 {
animation.start_time = time;
animation.current_frame = 0;
self.proccess_settings(&mut data, &animation.key_frames[0].settings);
return animation;
}
while start_time + animation.key_frames[animation.current_frame].duration < time {
start_time += animation.key_frames[animation.current_frame].duration;
animation.start_time = start_time;
if animation.current_frame + 1 >= animation.key_frames.len() {
if animation.reset {
animation.start_time = time;
animation.current_frame = 0;
self.proccess_settings(&mut data, &animation.key_frames[0].settings);
} else {
to_clean.push(animation.name.to_string());
}
self.proccess_settings(&mut data, &animation.key_frames[0].settings);
return animation;
}
animation.current_frame += 1;
}
while start_time + animation.key_frames[animation.current_frame].duration < time {
start_time += animation.key_frames[animation.current_frame].duration;
animation.start_time = start_time;
let cf = animation.current_frame;
if animation.current_frame + 1 >= animation.key_frames.len() {
if animation.reset {
animation.start_time = time;
animation.current_frame = 0;
self.proccess_settings(&mut data, &animation.key_frames[0].settings);
} else {
to_clean.push(animation.name.to_string());
}
return animation;
}
self.proccess_settings(&mut data, &animation.key_frames[cf].settings);
animation.current_frame += 1;
}
return animation;
}).collect();
let cf = animation.current_frame;
self.proccess_settings(&mut data, &animation.key_frames[cf].settings);
return animation;
})
.collect();
self.animations = animations;
to_clean.iter().for_each(|i| self.remove_animation(i.to_string()));
to_clean
.iter()
.for_each(|i| self.remove_animation(i.to_string()));
return GetRender {
data,
delta,
time
};
return GetRender { data, delta, time };
}
pub fn render(&mut self) {
if self.ws.is_none() { return; }
if self.ws.is_none() {
return;
}
let get_render = self.get_render();
@ -312,20 +339,22 @@ impl Render {
let time = get_render.time;
if self.last.is_empty() || !self.last.clone().iter().eq(data.clone().iter()) {
if self.last.len() == 0 {
self.last = data.clone();
}
if time - self.last_update == 0 {
if time - self.last_update < 100 {
println!("To Fast! Skiping");
return;
}
self.last_update = time;
let lerp_data: Vec<RGB<f64>> = data.iter().zip(&self.last).map(|(d, l)| l.lerp(d, delta as f64)).collect();
let lerp_data: Vec<RGB<f64>> = data
.iter()
.zip(&self.last)
.map(|(d, l)| l.lerp(d, delta as f64))
.collect();
//println!("d:{:?}\n l:{:?}", data[25], lerp_data[25]);
@ -339,17 +368,16 @@ impl Render {
self.last = lerp_data;
}
}
pub fn im_render(&mut self) {
if self.ws.is_none() { return; }
if self.ws.is_none() {
return;
}
let data = self.get_render().data;
if self.last.is_empty() || !self.last.clone().iter().eq(data.clone().iter()) {
if self.last.len() == 0 {
self.last = data.clone();
}
@ -364,18 +392,14 @@ impl Render {
self.last = data;
}
}
}
pub fn rgbs_f64_to_u8(data: &Vec<RGB<f64>>) -> Vec<RGB<u8>>{
data.clone().iter().map(|a| {
RGB::new(
a.r as u8,
a.g as u8,
a.b as u8
)
}).collect()
pub fn rgbs_f64_to_u8(data: &Vec<RGB<f64>>) -> Vec<RGB<u8>> {
data.clone()
.iter()
.map(|a| RGB::new(a.r as u8, a.g as u8, a.b as u8))
.collect()
}
pub trait Lerp {
@ -385,7 +409,7 @@ pub trait Lerp {
impl Lerp for f64 {
fn lerp(self, other: &Self, diff: f64) -> Self {
let delta = diff / 1000.0;
let change = (*other - self) * 0.8 * delta;
let lerped = self + change;
@ -400,6 +424,10 @@ impl Lerp for f64 {
impl Lerp for RGB<f64> {
fn lerp(self, other: &Self, diff: f64) -> Self {
RGB::new(self.r.lerp(&other.r, diff), self.g.lerp(&other.g, diff), self.b.lerp(&other.b, diff))
RGB::new(
self.r.lerp(&other.r, diff),
self.g.lerp(&other.g, diff),
self.b.lerp(&other.b, diff),
)
}
}