feature: Added frame buffering for maze example.

Author: shanecelis

Cargo.toml

@@ -11,6 +11,7 @@ micromath = "2.0.0"
 # runty8-core = { version = "0.1.0", path = "../runty8/src/runty8-core", optional = true, default-features = false }
 runty8-core = { git = "https://github.com/shanecelis/runty8.git", branch = "feature-no-std", optional = true, default-features = false }
 embedded-alloc = "0.5.0"
+embedded-graphics-framebuf = "0.2.0"
 [target.'cfg(not(all(target_arch = "arm", target_os = "none")))'.dependencies]
 embedded-graphics-simulator = "0.4.1"
 

examples/maze.rs

@@ -22,7 +22,7 @@ use embedded_graphics::{
 };
 #[allow(unused_imports)]
 use micromath::F32Ext;
-use trowel::{App, AppResult, Buttons};
+use trowel::{App, AppResult, Buttons, buffered::BufferedApp};
 
 // The original platform had a 160x160 display. Sprig only has a 160x128
 // display.
@@ -81,9 +81,7 @@ where
     }
 
     fn draw(&mut self, display: &mut T) -> AppResult<E> {
-        if self.frame % 10 == 0 {
-            display.clear(to_color(PALETTE[0]))?;
-        }
+        display.clear(to_color(PALETTE[0]))?;
         // Go through each column on screen and draw walls in the center.
         for (x, wall) in self.get_view().iter().enumerate() {
             let (height, shadow) = wall;
@@ -358,5 +356,7 @@ fn main() -> ! {
         player_y: 1.5,
         player_angle: -PI / 2.0,
     };
-    trowel::run(&mut state);
+    let mut app = BufferedApp::new(state);
+    // trowel::run(state);
+    trowel::run(&mut app);
 }

src/buffered.rs

@@ -0,0 +1,83 @@
+
+use embedded_graphics::{
+    draw_target::DrawTarget,
+    image::{Image, ImageRaw, ImageRawBE},
+    pixelcolor::{Rgb565, Rgb888},
+    prelude::*,
+};
+use crate::{App, AppResult, Buttons};
+use embedded_graphics_framebuf::{FrameBuf, backends::FrameBufferBackend};
+
+pub struct Buffer([Rgb565; 20480]);
+
+impl FrameBufferBackend for Buffer {
+    type Color = Rgb565;
+    fn set(&mut self, index: usize, color: Self::Color) {
+        self.0[index] = color;
+    }
+
+    fn get(&self, index: usize) -> Self::Color {
+        self.0[index]
+    }
+
+    fn nr_elements(&self) -> usize {
+        20480
+    }
+}
+
+pub struct BufferedApp<A>
+    where A : App<FrameBuf<Rgb565, Buffer>,
+              core::convert::Infallible>
+{
+    frameBuf : FrameBuf<Rgb565, Buffer>,
+    // buffer : Buffer,
+    app : A
+}
+
+
+impl<A> BufferedApp<A>
+    where A : App<FrameBuf<Rgb565, Buffer>,
+              core::convert::Infallible>
+{
+    pub fn new(app: A) -> Self {
+        let data = Buffer([Rgb565::BLACK; 20480]);
+        BufferedApp {
+            // buffer: data,
+            frameBuf: FrameBuf::new(data, 160, 128),
+            app
+        }
+    }
+}
+
+impl<T, E, A> App<T, E> for BufferedApp<A>
+where
+    T : DrawTarget<Color = Rgb565, Error = E>,
+    A : App<FrameBuf<Rgb565, Buffer>, core::convert::Infallible>
+{
+    fn init(&mut self) -> AppResult<E> {
+        self.app.init();
+        Ok(())
+    }
+
+    fn update(&mut self, buttons: Buttons) -> AppResult<E> {
+        self.app.update(buttons);
+        Ok(())
+    }
+
+    fn draw(&mut self, display: &mut T) -> AppResult<E> {
+        self.app.draw(&mut self.frameBuf);
+
+        display.draw_iter(self.frameBuf.into_iter());
+        Ok(())
+    }
+}
+
+pub fn run<TheirApp,T,E,MyApp>(app : TheirApp) -> !
+where T: DrawTarget<Color = Rgb565, Error = E>,
+      TheirApp: App<FrameBuf<Rgb565, Buffer>,
+              core::convert::Infallible>,
+      MyApp: App<T,E>
+{
+    let mut bufferedApp: BufferedApp<TheirApp> = BufferedApp::new(app);
+    super::run(&mut bufferedApp);
+}

src/lib.rs

@@ -41,6 +41,20 @@ mod sprig;
 #[cfg(all(target_arch = "arm", target_os = "none"))]
 pub use sprig::{run, init_heap};
 
+// #[cfg(all(target_arch = "arm", target_os = "none"))]
+// pub mod buffered;
+
+
+pub mod buffered;
+
+// pub mod buffered {
+// #[cfg(all(target_arch = "arm", target_os = "none"))]
+//     pub use sprig_buffered::run;
+
+// #[cfg(not(all(target_arch = "arm", target_os = "none")))]
+//     pub use crate::pc::run;
+// }
+
 #[cfg(not(all(target_arch = "arm", target_os = "none")))]
 mod pc;
 #[cfg(not(all(target_arch = "arm", target_os = "none")))]

src/pc.rs

@@ -17,6 +17,18 @@ use crate::{App, Buttons};
 
 pub fn init_heap() { }
 
+pub mod buffered {
+    pub use crate::pc::run;
+    // use crate::pc::SimulatorDisplay;
+    // use crate::App;
+    // use crate::Rgb565;
+
+    // pub fn runBuffered(app: &mut impl App<SimulatorDisplay<Rgb565>, core::convert::Infallible>) -> ! {
+    //     super::run(app);
+    // }
+
+}
+
 /// The `run` function configures the RP2040 peripherals, then runs the app.
 pub fn run(app: &mut impl App<SimulatorDisplay<Rgb565>, core::convert::Infallible>) -> ! {
     let mut display: SimulatorDisplay<Rgb565> = SimulatorDisplay::new(Size::new(160, 128));

src/runty8.rs

@@ -18,7 +18,6 @@ struct RuntyApp<G>
     game: G,
     input: Input,
     last_buttons: Buttons
-
 }
 
 impl<G> RuntyApp<G>

src/sprig.rs

@@ -37,6 +37,7 @@ use embedded_alloc::Heap;
 #[used]
 pub static BOOT2: [u8; 256] = rp2040_boot2::BOOT_LOADER_W25Q080;
 
+
 /// External high-speed crystal on the Raspberry Pi Pico board is 12 MHz. Adjust
 /// if your board has a different frequency.
 const XTAL_FREQ_HZ: u32 = 12_000_000u32;