Merge pull request #25 from ckaznable/optimize

perf: optimize render frequency

Author: ckaznable

src/app.rs

@@ -8,7 +8,7 @@ use crossterm::{
 use ratatui::{backend::CrosstermBackend, Terminal};
 
 use crate::{
-    cli::Args, state::{EachFrameImpl, State}, tui::{Event, Tui}, ui::ui, widget::AsWeatherWidget
+    cli::Args, state::{EachFrameImpl, ShouldRender, State}, tui::{Event, Tui}, ui::ui, widget::AsWeatherWidget
 };
 
 #[derive(Copy, Clone)]
@@ -21,6 +21,7 @@ pub struct App<T> {
     tui: Tui,
     state: State<T>,
     should_quit: bool,
+    should_render: ShouldRender,
     args: Args,
     frame_in_second: usize,
     runtime_info: AppRuntimeInfo,
@@ -46,6 +47,7 @@ where
             args,
             tui: Tui::new(args.fps as f64, args.tps as f64)?,
             should_quit: false,
+            should_render: ShouldRender::Render,
             frame_in_second: 0,
             runtime_info: AppRuntimeInfo { fps: 0 },
         })
@@ -64,7 +66,7 @@ where
                     Key(key) => self.handle_keyboard(key),
                     Tick => self.on_tick(),
                     Timer => self.on_timer(),
-                    Resize(columns, rows) => self.state.on_resize(columns, rows),
+                    Resize(columns, rows) => self.on_resize(columns, rows),
                 };
             };
 
@@ -83,8 +85,13 @@ where
         }
     }
 
+    fn on_resize(&mut self, columns: u16, rows: u16) {
+        self.state.on_resize(columns, rows);
+        self.should_render = ShouldRender::Render;
+    }
+
     fn on_tick(&mut self) {
-        self.state.tick();
+        self.should_render = self.should_render.or(self.state.tick());
         self.frame_in_second = self.frame_in_second.saturating_add(1);
     }
 
@@ -93,14 +100,19 @@ where
             self.on_tick()
         }
 
-        self.terminal.draw(|f| ui(f, &mut self.state, self.args, self.runtime_info))?;
+        if self.should_render.is_render() {
+            self.should_render = ShouldRender::Skip;
+            self.terminal.draw(|f| ui(f, &mut self.state, self.args, self.runtime_info))?;
+        }
+
         Ok(())
     }
 
     fn on_timer(&mut self) {
         self.state.tick_timer();
         self.runtime_info.fps = self.frame_in_second;
         self.frame_in_second = 0;
+        self.should_render = ShouldRender::Render;
     }
 }
 

src/state/dropping.rs

@@ -1,4 +1,4 @@
-use super::{buffer::RenderBuffer, Cell, Column, CellType, Mode, EachFrameImpl};
+use super::{buffer::RenderBuffer, Cell, CellType, Column, EachFrameImpl, Mode, ShouldRender};
 
 pub struct DroppingState {
     pub threshold: u16,
@@ -104,13 +104,14 @@ impl DroppingState {
 }
 
 impl EachFrameImpl for DroppingState {
-    fn on_frame(&mut self, rb: &mut super::buffer::RenderBuffer, seed: u64, frame: u64) {
+    fn on_frame(&mut self, rb: &mut super::buffer::RenderBuffer, seed: u64, frame: u64) -> ShouldRender {
         // each column
         for i in 0..rb.buf.len() {
             Self::clean_latest_drop(&mut rb.buf[i]);
             Self::drop(&mut rb.buf[i], frame, self.mode);
         }
 
         self.new_drop(rb, seed);
+        ShouldRender::Render
     }
 }

src/state/mod.rs

@@ -20,7 +20,28 @@ pub type Cell = ArrayVec<[CellType; 3]>;
 pub type Column = Rc<RefCell<Vec<Cell>>>;
 
 pub trait EachFrameImpl {
-    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, frame: u64);
+    fn on_frame(&mut self, _: &mut RenderBuffer, _: u64, _: u64) -> ShouldRender {
+        ShouldRender::Skip
+    }
+}
+
+#[derive(PartialEq, Eq, Copy, Clone)]
+pub enum ShouldRender {
+    Render,
+    Skip,
+}
+
+impl ShouldRender {
+    pub fn or(self, sr: Self) -> Self {
+        match sr {
+            Self::Skip => self,
+            Self::Render => sr,
+        }
+    }
+
+    pub fn is_render(&self) -> bool {
+        *self == Self::Render
+    }
 }
 
 #[derive(Copy, Clone, Default)]
@@ -225,11 +246,12 @@ impl<T: EachFrameImpl> State<T> {
         self.timer = Timer::new();
     }
 
-    pub fn tick(&mut self) {
+    pub fn tick(&mut self) -> ShouldRender {
         self.frame = if self.frame == u64::MAX { 0 } else { self.frame.saturating_add(1) };
         self.seed = self.rng.next_u64();
-        self.weather.on_frame(&mut self.rb, self.seed, self.frame);
-        self.timer_state.on_frame(&mut self.rb, self.seed, self.frame);
+
+        self.weather.on_frame(&mut self.rb, self.seed, self.frame)
+            .or(self.timer_state.on_frame(&mut self.rb, self.seed, self.frame))
     }
 }
 

src/state/tail.rs

@@ -1,6 +1,6 @@
 use std::cell::RefCell;
 
-use super::{buffer::RenderBuffer, wind::WindMode, Cell, Column, CellType, EachFrameImpl};
+use super::{buffer::RenderBuffer, wind::WindMode, Cell, CellType, Column, EachFrameImpl, ShouldRender};
 
 #[derive(Default, Copy, Clone, Eq, PartialEq)]
 pub enum TailMode {
@@ -110,11 +110,13 @@ impl TailState {
 }
 
 impl EachFrameImpl for TailState {
-    fn on_frame(&mut self, rb: &mut RenderBuffer, _seed: u64, _frame: u64) {
+    fn on_frame(&mut self, rb: &mut RenderBuffer, _seed: u64, _frame: u64) -> ShouldRender {
         match self.mode {
             TailMode::Left => Self::render_left_tail(&mut rb.buf),
             TailMode::Right => Self::render_right_tail(&mut rb.buf),
             TailMode::Default => Self::render_default_tail(&mut rb.buf),
-        }
+        };
+
+        ShouldRender::Render
     }
 }

src/state/timer.rs

@@ -6,7 +6,7 @@ use ratatui::layout::Rect;
 
 use crate::widget::timer::{TIMER_LAYOUT_HEIGHT, TIMER_LAYOUT_WIDTH};
 
-use super::{buffer::RenderBuffer, Direction, EachFrameImpl, Position};
+use super::{buffer::RenderBuffer, Direction, EachFrameImpl, Position, ShouldRender};
 
 #[derive(Copy, Clone)]
 pub struct Timer {
@@ -90,9 +90,12 @@ impl ColonState {
 }
 
 impl EachFrameImpl for ColonState {
-    fn on_frame(&mut self, _: &mut RenderBuffer, _: u64, frame: u64) {
+    fn on_frame(&mut self, _: &mut RenderBuffer, _: u64, frame: u64) -> ShouldRender {
         if self.blink && frame % 24 == 0 {
-            self.toggle()
+            self.toggle();
+            ShouldRender::Render
+        } else {
+            ShouldRender::Skip
         }
     }
 }
@@ -166,26 +169,27 @@ impl TimerState {
         self.pos.1 == 0 || (self.pos.1 + TIMER_LAYOUT_HEIGHT) >= self.boundary.height
     }
 
-    fn handle_mode(&mut self, frame: u64) {
+    fn handle_mode(&mut self, frame: u64) -> ShouldRender {
         if self.mode.is_none() {
-            return;
+            return ShouldRender::Skip;
         }
 
         if frame % 8 > 0 {
-            return;
+            return ShouldRender::Skip;
         }
 
         match self.mode.unwrap() {
             TimerRenderMode::Dvd(_) => self.on_dvd_frame(),
         }
 
         self.area = Self::get_area_with_pos(self.pos);
+        ShouldRender::Render
     }
 }
 
 impl EachFrameImpl for TimerState {
-    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, frame: u64) {
-        self.handle_mode(frame);
-        self.colon.on_frame(rb, seed, frame);
+    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, frame: u64) -> ShouldRender {
+        self.handle_mode(frame)
+            .or(self.colon.on_frame(rb, seed, frame))
     }
 }

src/state/wind.rs

@@ -1,4 +1,4 @@
-use super::{buffer::RenderBuffer, EachFrameImpl};
+use super::{buffer::RenderBuffer, EachFrameImpl, ShouldRender};
 
 pub trait WindImpl {
     fn direction(&self) -> WindDirection;
@@ -74,7 +74,7 @@ impl WindState {
 }
 
 impl EachFrameImpl for WindState {
-    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, _: u64) {
+    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, _: u64) -> ShouldRender {
         self.direction = match self.mode {
             WindMode::Disable => WindDirection::None,
             WindMode::OnlyLeft => WindDirection::Left,
@@ -83,7 +83,7 @@ impl EachFrameImpl for WindState {
         };
 
         if self.mode == WindMode::Disable {
-            return;
+            return ShouldRender::Skip;
         }
 
         if self.frame == 0 || self.direction == WindDirection::None {
@@ -98,7 +98,7 @@ impl EachFrameImpl for WindState {
         }
 
         if self.direction == WindDirection::None {
-            return;
+            return ShouldRender::Skip;
         }
 
         self.frame = self.frame.saturating_sub(1);
@@ -114,5 +114,7 @@ impl EachFrameImpl for WindState {
         if self.direction == WindDirection::Left {
             rb.buf.reverse();
         }
+
+        ShouldRender::Render
     }
 }

src/weather/dropping.rs

@@ -1,6 +1,6 @@
 use crate::{
     cli::Args,
-    state::{buffer::RenderBuffer, dropping::DroppingState, tail::TailState, wind::WindState, EachFrameImpl, Mode},
+    state::{buffer::RenderBuffer, dropping::DroppingState, tail::TailState, wind::WindState, EachFrameImpl, Mode, ShouldRender},
     widget::{weather::GeneralWeatherWidget, AsWeatherWidget},
 };
 
@@ -29,9 +29,9 @@ impl GeneralDropping {
 impl WeatherImpl for GeneralDropping {}
 
 impl EachFrameImpl for GeneralDropping {
-    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, frame: u64) {
-        self.wind.on_frame(rb, seed, frame);
-        self.dropping.on_frame(rb, seed, frame);
+    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, frame: u64) -> ShouldRender {
+        self.wind.on_frame(rb, seed, frame)
+            .or(self.dropping.on_frame(rb, seed, frame))
     }
 }
 
@@ -70,10 +70,10 @@ impl TailDropping {
 impl WeatherImpl for TailDropping {}
 
 impl EachFrameImpl for TailDropping {
-    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, frame: u64) {
-        self.wind.on_frame(rb, seed, frame);
-        self.dropping.on_frame(rb, seed, frame);
-        self.tail.on_frame(rb, seed, frame);
+    fn on_frame(&mut self, rb: &mut RenderBuffer, seed: u64, frame: u64) -> ShouldRender {
+        self.wind.on_frame(rb, seed, frame)
+            .or(self.dropping.on_frame(rb, seed, frame))
+            .or(self.tail.on_frame(rb, seed, frame))
     }
 }
 

src/weather/empty.rs

@@ -7,10 +7,6 @@ use super::WeatherImpl;
 
 pub struct EmptyWeather;
 
-impl EachFrameImpl for EmptyWeather {
-    fn on_frame(&mut self, _: &mut crate::state::buffer::RenderBuffer, _: u64, _: u64) {}
-}
-
 impl AsWeatherWidget for EmptyWeather {
     type Weather = GeneralWeatherWidget;
 
@@ -19,4 +15,5 @@ impl AsWeatherWidget for EmptyWeather {
     }
 }
 
+impl EachFrameImpl for EmptyWeather {}
 impl WeatherImpl for EmptyWeather {}

src/weather/mod.rs

@@ -1,6 +1,6 @@
 use crate::{
     cli::Args,
-    state::{EachFrameImpl, Mode},
+    state::{EachFrameImpl, Mode, ShouldRender},
     weather::{dropping::{GeneralDropping, TailDropping}, empty::EmptyWeather}, widget::{weather::GeneralWeatherWidget, AsWeatherWidget},
 };
 
@@ -23,7 +23,7 @@ impl Weather {
 }
 
 impl EachFrameImpl for Weather {
-    fn on_frame(&mut self, rb: &mut crate::state::buffer::RenderBuffer, seed: u64, frame: u64) {
+    fn on_frame(&mut self, rb: &mut crate::state::buffer::RenderBuffer, seed: u64, frame: u64) -> ShouldRender {
         self.0.on_frame(rb, seed, frame)
     }
 }