Add more things to the renderheap to save memory (fire and attract mode)

Author: ben-xo

attract.cpp

@@ -3,30 +3,27 @@
  */
 
 #include "effects.h"
+#include "renderheap.h"
 
-#define POS_PER_PIXEL (32768 / STRIP_LENGTH) // ratio of attract mode pixel-positions to actual LEDs
 
-static CRGB dot_colors[ATTRACT_MODE_DOTS];
-static uint32_t dot_pos[ATTRACT_MODE_DOTS];
-static uint16_t dot_speeds[ATTRACT_MODE_DOTS];
-static uint8_t dot_age[ATTRACT_MODE_DOTS];
+#define POS_PER_PIXEL (32768 / STRIP_LENGTH) // ratio of attract mode pixel-positions to actual LEDs
 
 static void make_new_dot(uint8_t dot) {
-    dot_colors[dot] = Wheel(random8());
-    dot_pos[dot] = random16(10000); // 32768 * 0.2 (so pixels dont start at the very end of the strip)
-    dot_speeds[dot] = random16(POS_PER_PIXEL/17,POS_PER_PIXEL/5);
-    dot_age[dot] = 0;
+    r.am.dot_colors[dot] = Wheel(random8());
+    r.am.dot_pos[dot] = random16(10000); // 32768 * 0.2 (so pixels dont start at the very end of the strip)
+    r.am.dot_speeds[dot] = random16(POS_PER_PIXEL/17,POS_PER_PIXEL/5);
+    r.am.dot_age[dot] = 0;
 }
 
 static void calculate_overtakes(uint8_t dot) {
   for(uint8_t i = 0; i < ATTRACT_MODE_DOTS; i++) {
-    if((dot_pos[dot] < dot_pos[i]) && (dot_pos[dot] + dot_speeds[dot]) >= dot_pos[i]) {
+    if((r.am.dot_pos[dot] < r.am.dot_pos[i]) && (r.am.dot_pos[dot] + r.am.dot_speeds[dot]) >= r.am.dot_pos[i]) {
       // i will overtake j on next render. Let's make them collide!
-      uint8_t r = ((uint8_t)(dot_colors[i].r) + (uint8_t)(dot_colors[dot].r)) >> 1;
-      uint8_t g = ((uint8_t)(dot_colors[i].g) + (uint8_t)(dot_colors[dot].g)) >> 1;
-      uint8_t b = ((uint8_t)(dot_colors[i].b) + (uint8_t)(dot_colors[dot].b)) >> 1;
-      dot_colors[i] = CRGB(r,g,b);
-      dot_colors[dot] = dot_colors[i];
+      uint8_t new_r = blend8(r.am.dot_colors[i].r, r.am.dot_colors[dot].r, 127);
+      uint8_t new_g = blend8(r.am.dot_colors[i].g, r.am.dot_colors[dot].g, 127);
+      uint8_t new_b = blend8(r.am.dot_colors[i].b, r.am.dot_colors[dot].b, 127);
+      r.am.dot_colors[i] = CRGB(new_r,new_g,new_b);
+      r.am.dot_colors[dot] = r.am.dot_colors[i];
     }
   }
 }
@@ -50,33 +47,33 @@ void render_attract() {
   // this loop scales the dots from their "native res" (0-32768) antialiased to the LED strip (0-60)
   // and keeps track of which LED pixels have actually been rendered to (which is 2x number of dots)
   for(uint8_t dot=0; dot < ATTRACT_MODE_DOTS; dot++) {
-    if(dot_pos[dot] >= 32768) {
+    if(r.am.dot_pos[dot] >= 32768) {
       make_new_dot(dot);
     } 
     // draw adjusted to strip (trying to do anti-aliasing)
     // ratio of pixel in left or right pixels
-    uint16_t led = dot_pos[dot] / POS_PER_PIXEL;
-    leds_offsets[dot] = (dot_pos[dot] % (POS_PER_PIXEL));
+    uint16_t led = r.am.dot_pos[dot] / POS_PER_PIXEL;
+    leds_offsets[dot] = (r.am.dot_pos[dot] % (POS_PER_PIXEL));
     calculate_overtakes(dot);
-    dot_pos[dot] += dot_speeds[dot];
-    if(dot_age[dot] < 255) dot_age[dot]++;
+    r.am.dot_pos[dot] += r.am.dot_speeds[dot];
+    if(r.am.dot_age[dot] < 255) r.am.dot_age[dot]++;
 
     if(led+1 < STRIP_LENGTH) {
       CRGB old_color = leds[led];
       uint8_t old_r = old_color.r;
       uint8_t old_g = old_color.g;
       uint8_t old_b = old_color.b;
-      uint8_t dot_r = dot_colors[dot].r;
-      uint8_t dot_g = dot_colors[dot].g;
-      uint8_t dot_b = dot_colors[dot].b;
+      uint8_t dot_r = r.am.dot_colors[dot].r;
+      uint8_t dot_g = r.am.dot_colors[dot].g;
+      uint8_t dot_b = r.am.dot_colors[dot].b;
 
-      uint16_t r = old_r + dot_r * (dot_age[dot]/255.0) * (POS_PER_PIXEL - leds_offsets[dot])/POS_PER_PIXEL;
-      uint16_t g = old_g + dot_g * (dot_age[dot]/255.0) * (POS_PER_PIXEL - leds_offsets[dot])/POS_PER_PIXEL;
-      uint16_t b = old_b + dot_b * (dot_age[dot]/255.0) * (POS_PER_PIXEL - leds_offsets[dot])/POS_PER_PIXEL;
+      uint16_t new_r = old_r + dot_r * (r.am.dot_age[dot]/255.0) * (POS_PER_PIXEL - leds_offsets[dot])/POS_PER_PIXEL;
+      uint16_t new_g = old_g + dot_g * (r.am.dot_age[dot]/255.0) * (POS_PER_PIXEL - leds_offsets[dot])/POS_PER_PIXEL;
+      uint16_t new_b = old_b + dot_b * (r.am.dot_age[dot]/255.0) * (POS_PER_PIXEL - leds_offsets[dot])/POS_PER_PIXEL;
       leds[led+1] = CRGB( 
-        min(r, 255),
-        min(g, 255), 
-        min(b, 255)
+        min(new_r, 255),
+        min(new_g, 255), 
+        min(new_b, 255)
       );
 //      old_color = strip.getPixelColor(led+1);
 //      old_r = (uint8_t)(old_color >> 16);

fire.cpp

@@ -8,6 +8,7 @@
 
 #include "config.h"
 #include "render.h"
+#include "renderheap.h"
 
 #define COOLING 65
 #define SPARKING 120
@@ -32,14 +33,14 @@ void setPixelHeatColor (int Pixel, byte temperature) {
 }
 
 void render_fire(bool is_beat, unsigned int peakToPeak) {
-  static byte heat[STRIP_LENGTH]; // todo: this is probably wasteful
+  byte *heat = r.fm.heat;
   int cooldown;
 
   // Step 1.  Cool down every cell a little
   for( uint8_t i = 0; i < STRIP_LENGTH; i++) {
     cooldown = random8(COOLING_RANDOM_FACTOR);
 
-    if(cooldown>heat[i]) {
+    if(cooldown>r.fm.heat[i]) {
       heat[i]=0;
     } else {
       heat[i]=heat[i]-cooldown;

render.cpp

@@ -6,6 +6,7 @@
 #include "config.h"
 #include "render.h"
 #include "sampler.h"
+#include "renderheap.h"
 
 #ifndef DEBUG_ONLY
 
@@ -28,37 +29,6 @@ static const uint8_t PROGMEM _gammaTable[256] = {
 243, 244, 245, 245, 246, 247, 248, 249, 249, 250, 251, 252, 253, 253, 254, 255};
 
 
-typedef struct {
-  uint8_t hue, beat_offset;
-} render_vu_with_beat_strobe_type;
-
-typedef struct {
-  uint8_t beat_brightness;
-} render_vu_plus_beat_interleave_type;
-
-typedef struct {
-  uint8_t phase;
-} render_beat_line_type;
-
-typedef struct {
-  bool was_beat_2;
-  uint8_t fade_type;
-} render_double_vu_type;
-
-typedef struct {
-  bool was_beat;
-  bool top;
-  uint16_t hue;
-} render_beat_bounce_flip_type;
-
-typedef union renderheap_t {
-  render_vu_with_beat_strobe_type     rvuwbs;
-  render_vu_plus_beat_interleave_type rvupbi;
-  render_beat_line_type               rbl;
-  render_double_vu_type               rdv;
-  render_beat_bounce_flip_type        rbbf;
-};
-
 renderheap_t r;
 
 uint8_t static gamma8(uint8_t x)  {

vu3.ino

@@ -4,6 +4,10 @@
 
 #include "config.h"
 
+#include "sampler.h"
+#include "ledpwm.h"
+#include "tempo.h"
+
 // this define is for FastLED
 #define NO_CORRECTION 1
 #define FASTLED_ALLOW_INTERRUPTS 1
@@ -14,9 +18,6 @@
 
 struct Framestate F; // the global instance
 
-#include "sampler.h"
-#include "ledpwm.h"
-#include "tempo.h"
 
 #ifdef BEAT_WITH_INTERRUPTS
 // This mode doesn't currently work, because it's all been integrated into this project and isn't needed