Initial commit

firmware/sprites/Blob.h

@@ -0,0 +1,67 @@
+#pragma once
+
+class Blob {
+  uint16_t m_pos;
+  int8_t m_velocity;
+  uint8_t m_hue;
+  int16_t m_brightness;
+  uint8_t m_saturation;
+  int8_t m_fadeDir;
+public:
+  Blob()
+    : m_pos(0),
+      m_velocity(1),
+      m_hue(0),
+      m_brightness(1),
+      m_saturation(200),
+      m_fadeDir(1) {}
+
+  void setSaturation(uint8_t v) {
+    m_saturation = v;
+  }
+      
+  void setPos(uint16_t p) {
+    m_pos = p;
+    m_brightness = p % 120 + 1;
+  }
+
+  void setHue(uint8_t p) {
+    m_hue = p;
+  }
+
+  void setBrightness(uint8_t p) {
+    m_brightness = p;
+  }
+
+  void setVelocity(int8_t v) {
+    m_velocity = v;
+  }
+
+  void update() {
+      m_pos += m_velocity;
+      m_hue += 1;
+      m_brightness += m_fadeDir;
+      if (m_brightness >= 255 || m_brightness <= 0) {
+        m_fadeDir *= -1;
+      }
+  }
+  
+  void render(Display* display) const {
+      const uint8_t width = 25;
+      auto map = display->coordinateMapping();
+      // Grab the physical pixel we'll start with
+      PhysicalCoordinates startPos = map->virtualToPhysicalCoords({m_pos, 0});
+      PhysicalCoordinates endPos = map->virtualToPhysicalCoords({m_pos + width, 0});
+      int scaledWidth = std::abs(endPos.x - startPos.x);
+
+      for(uint8_t i = 0;i < scaledWidth; i++) {
+        // Blobs desaturate towards their tail
+        NSFastLED::CHSV blobColor(m_hue, m_saturation, NSFastLED::quadwave8((i / (double)scaledWidth) * m_brightness));
+
+        PhysicalCoordinates pos{startPos.x + (i*m_fadeDir), 0};
+
+        NSFastLED::CRGB src(display->pixelAt(pos));
+        display->pixelAt(pos) = NSFastLED::blend(NSFastLED::CRGB(blobColor), src, 200);
+      }
+  }
+};

firmware/sprites/Chime.h

@@ -0,0 +1,79 @@
+#pragma once
+
+using namespace NSFastLED;
+
+template<int ChimeLength>
+class Chime {
+  uint16_t m_pos;
+  uint8_t m_speed;
+  uint16_t m_hue;
+  uint16_t m_saturation;
+  uint16_t m_brightness;
+  unsigned int m_offset;
+    
+public:
+
+  static const int Length = ChimeLength;
+  
+  Chime()
+    : m_pos(0),
+      m_speed(128),
+      m_hue(210),
+      m_saturation(255),
+      m_brightness(255),
+      m_offset(0) {}
+
+  void setSaturation(uint8_t i) {
+    m_saturation = i % 255;
+  }
+  
+  void setSpeed(uint8_t i) {
+    m_speed = i % 255;
+  }
+
+  void setOffset(unsigned int i) {
+    m_offset = i;
+  }
+  
+  void setPos(uint8_t i) {
+    m_pos = i;
+  }
+  
+  void setHue(uint8_t i) {
+    m_hue = i % 255;
+  }
+
+  void setBrightness(uint8_t i) {
+    m_brightness = i % 255;
+  }
+  
+  void update() {
+    m_pos += 1;
+    
+    if (random(255) > m_speed) {
+      m_pos += 2;
+    }
+    
+    if (m_pos > ChimeLength * 20) {
+      m_pos = 0;
+      m_hue += 3;
+      m_hue %= 255;
+    }
+  }
+  
+  void render(Display* dpy) const {
+    for(int i = 0; i < ChimeLength; i++) {
+      if (i > m_pos) {
+        dpy->pixelAt(i + m_offset) = CHSV(0, 0, 0);
+      } else {
+        uint8_t distance = m_pos - i;
+        uint8_t brightness = NSFastLED::scale8(NSFastLED::quadwave8((ChimeLength / (double)distance) * 255), m_brightness);
+        if (brightness <= 0.2)
+          brightness = 0;
+        dpy->pixelAt(VirtualCoordinates{i + m_offset, 0}) = CHSV(m_hue, min(m_saturation, brightness), brightness);
+      }
+    }
+  }
+};
+
+