bump a lot of big changes I dont want to break down into individual commits

src/tasks/render.rs

@@ -1,23 +1,20 @@
 use embassy_time::{Duration, Instant, Timer};
-use esp_hal::{gpio::AnyPin, rmt::Rmt, time::Rate};
+use esp_hal::{gpio::AnyPin, rmt::Rmt, time::Rate, timer::timg::Wdt};
 use esp_hal_smartled::{buffer_size_async, SmartLedsAdapterAsync};
-use figments::{hardware::{Brightness, OutputAsync}, prelude::Hsv, surface::{BufferedSurfacePool, Surfaces}};
+use figments::{prelude::*, surface::{BufferedSurfacePool, Surfaces}};
+use figments_render::gamma::GammaCurve;
+use figments_render::output::{GammaCorrected, OutputAsync};
 use log::{info, warn};
 use rgb::Rgba;
 use nalgebra::ComplexField;
+use alloc::sync::Arc;
 
-use crate::{display::{BikeOutputAsync, BikeSpace}, events::DisplayControls};
-
-#[derive(Default)]
-pub struct Uniforms {
-    pub frame: usize,
-    pub primary_color: Hsv
-}
+use crate::{display::{BikeOutput, SegmentSpace, Uniforms}, events::DisplayControls};
 
 //TODO: Import the bike surfaces from renderbug-prime, somehow make those surfaces into tasks
 
 #[embassy_executor::task]
-pub async fn render(rmt: esp_hal::peripherals::RMT<'static>, gpio: AnyPin<'static>, surfaces: BufferedSurfacePool<Uniforms, BikeSpace, Rgba<u8>>, controls: &'static DisplayControls) {
+pub async fn render(rmt: esp_hal::peripherals::RMT<'static>, gpio: AnyPin<'static>, surfaces: BufferedSurfacePool<Uniforms, SegmentSpace, Rgba<u8>>, controls: Arc<DisplayControls>, mut wdt: Wdt<esp_hal::peripherals::TIMG0<'static>>) {
     let frequency: Rate = Rate::from_mhz(80);
     let rmt = Rmt::new(rmt, frequency)
         .expect("Failed to initialize RMT").into_async();
@@ -33,7 +30,8 @@ pub async fn render(rmt: esp_hal::peripherals::RMT<'static>, gpio: AnyPin<'stati
     
     // You probably don't need to change these values, unless your LED strip is somehow not 5 volts
     const POWER_VOLTS : u32 = 5;
-    const MAX_POWER_MW : u32 = POWER_VOLTS * POWER_MA;
+
+    const MAX_POWER_MW : u32 = if cfg!(feature="max-usb-power") { u32::MAX } else { POWER_VOLTS * POWER_MA };
 
     // This value is used as the 'seed' for rendering each frame, allowing us to do things like run the animation backwards, frames for double FPS, or even use system uptime for more human-paced animations
     let mut uniforms = Uniforms {
@@ -41,29 +39,42 @@ pub async fn render(rmt: esp_hal::peripherals::RMT<'static>, gpio: AnyPin<'stati
         ..Uniforms::default()
     };
 
-    let mut output = BikeOutputAsync::new(target, MAX_POWER_MW);
+    let mut output = BikeOutput::new(target, MAX_POWER_MW, controls.clone());
+    output.set_gamma(GammaCurve::new(1.3));
+    //#[cfg(not(feature="wokwi"))]
+    //output.set_gamma(GammaCurve::new(2.1));
 
     info!("Rendering started! {}ms since boot", Instant::now().as_millis());
     controls.render_is_running.signal(true);
 
-    const FPS: u64 = 60;
+    const FPS: u64 = 80;
     const RENDER_BUDGET: Duration = Duration::from_millis(1000 / FPS);
 
     loop {
+        // FIXME: need to put the rendering loop into a deep sleep when the display is off
         let start = Instant::now();
-        output.blank_async().await.expect("Failed to blank framebuf");
+
+        output.blank();
 
         surfaces.render_to(&mut output, &uniforms);
 
-        // Apply hardware controls
-        output.set_on(controls.on.load(core::sync::atomic::Ordering::Relaxed));
-        output.set_brightness(controls.brightness.load(core::sync::atomic::Ordering::Relaxed));
-
         // Finally, write out the rendered frame
         output.commit_async().await.expect("Failed to commit frame");
 
         let render_duration = Instant::now() - start;
 
+        if !controls.is_on() {
+            warn!("Renderer is sleeping zzzz");
+            //controls.render_is_running.signal(false);
+            output.blank();
+            wdt.disable();
+            controls.wait_for_on().await;
+            wdt.feed();
+            wdt.enable();
+            warn!("Renderer is awake !!!!");
+            //controls.render_is_running.signal(true);
+        }
+
         if render_duration < RENDER_BUDGET {
             let remaining_budget = RENDER_BUDGET - render_duration;
             uniforms.frame += 1;
@@ -74,5 +85,9 @@ pub async fn render(rmt: esp_hal::peripherals::RMT<'static>, gpio: AnyPin<'stati
             // If we took longer than the budget, we need to drop some frames to catch up
             uniforms.frame += dropped_count;
         }
+
+        uniforms.primary_color.hue = uniforms.primary_color.hue.wrapping_add(1);
+
+        wdt.feed();
     }
 }