Lava Lamp FX in the user_fx usermod

usermods/user_fx/user_fx.cpp

@@ -2,12 +2,17 @@
 
 // for information how FX metadata strings work see https://kno.wled.ge/interfaces/json-api/#effect-metadata
 
+// paletteBlend: 0 - wrap when moving, 1 - always wrap, 2 - never wrap, 3 - none (undefined)
+#define PALETTE_SOLID_WRAP   (strip.paletteBlend == 1 || strip.paletteBlend == 3)
+#define PALETTE_MOVING_WRAP !(strip.paletteBlend == 2 || (strip.paletteBlend == 0 && SEGMENT.speed == 0))
+
 // static effect, used if an effect fails to initialize
 static uint16_t mode_static(void) {
   SEGMENT.fill(SEGCOLOR(0));
   return strip.isOffRefreshRequired() ? FRAMETIME : 350;
 }
 
+
 /////////////////////////
 //  User FX functions  //
 /////////////////////////
@@ -89,6 +94,248 @@ unsigned dataSize = cols * rows;  // SEGLEN (virtual length) is equivalent to vW
 static const char _data_FX_MODE_DIFFUSIONFIRE[] PROGMEM = "Diffusion Fire@!,Spark rate,Diffusion Speed,Turbulence,,Use palette;;Color;;2;pal=35";
 
 
+/*
+/  Lava Lamp 2D effect
+*  Uses particles to simulate rising blobs of "lava"
+*  Particles slowly rise, merge to create organic flowing shapes, and then fall to the bottom to start again
+*  Created by Bob Loeffler using claude.ai
+*  The first slider sets the speed of the rising and falling blobs
+*  The second slider sets the number of active blobs
+*  The third slider sets the size range of the blobs
+*  The first checkbox sets the color mode (color wheel or palette)
+*  The second checkbox sets the attraction of blobs (checked will make the blobs attract other close blobs horizontally)
+*/
+
+#define MAX_LAVA_PARTICLES 50
+
+typedef struct LavaParticle {
+  float x, y;           // Position
+  float vx, vy;         // Velocity
+  float size;           // Blob size
+  uint8_t hue;          // Color
+  uint8_t life;         // Lifetime/opacity
+  bool active;          // will not be displayed if false
+} LavaParticle;
+
+static LavaParticle lavaParticles[MAX_LAVA_PARTICLES];
+
+uint16_t mode_2D_lavalamp(void) {
+  if (!strip.isMatrix || !SEGMENT.is2D()) return mode_static(); // not a 2D set-up
+
+  const uint16_t cols = SEGMENT.virtualWidth();
+  const uint16_t rows = SEGMENT.virtualHeight();
+
+  // Initialize particles on first call
+  if (SEGENV.call == 0) {
+    for (int i = 0; i < MAX_LAVA_PARTICLES; i++) {
+      lavaParticles[i].active = false;
+    }
+  }
+
+  // Speed control (slower = more lava lamp like)
+  uint8_t speed = SEGMENT.speed >> 3; // 0-31 range
+  if (speed < 1) speed = 1;
+
+  // Intensity controls number of active particles
+  uint8_t numParticles = (SEGMENT.intensity >> 3) + 3; // 3-34 particles (fewer blobs)
+  if (numParticles > MAX_LAVA_PARTICLES) numParticles = MAX_LAVA_PARTICLES;
+
+  // Track size slider changes
+  static uint8_t lastSizeControl = 128;
+  uint8_t currentSizeControl = SEGMENT.custom1;
+  bool sizeChanged = (currentSizeControl != lastSizeControl);
+
+  if (sizeChanged) {
+    // Recalculate size range based on new slider value
+    float minSize = cols * 0.15f;
+    float maxSize = cols * 0.4f;
+    float newRange = (maxSize - minSize) * (currentSizeControl / 255.0f);
+
+    for (int i = 0; i < MAX_LAVA_PARTICLES; i++) {
+      if (lavaParticles[i].active) {
+        // Assign new random size within the new range
+        lavaParticles[i].size = minSize + random16((int)(newRange * 10)) / 10.0f;
+        // Ensure minimum size
+        if (lavaParticles[i].size < minSize) lavaParticles[i].size = minSize;
+      }
+    }
+
+    lastSizeControl = currentSizeControl;
+  }
+
+  // Spawn new particles at the bottom near the center
+  for (int i = 0; i < MAX_LAVA_PARTICLES; i++) {
+    if (!lavaParticles[i].active && hw_random8() < 32) { // Always spawn when slot available
+      // Spawn in the middle 60% of the width
+      float centerStart = cols * 0.20f;
+      float centerWidth = cols * 0.60f;
+      lavaParticles[i].x = centerStart + (random16((int)(centerWidth * 10)) / 10.0f);
+      lavaParticles[i].y = rows - 1;
+      lavaParticles[i].vx = (random16(7) - 3) / 250.0f;
+
+      // Speed slider controls vertical velocity (faster = more speed)
+      float speedFactor = (SEGMENT.speed + 30) / 100.0f; // 0.3 to 2.85 range
+      lavaParticles[i].vy = -(random16(20) + 10) / 100.0f * speedFactor;
+
+      // Custom1 slider controls blob size (based on matrix width)
+      uint8_t sizeControl = SEGMENT.custom1; // 0-255
+      float minSize = cols * 0.15f; // Minimum 15% of width
+      float maxSize = cols * 0.4f;  // Maximum 40% of width
+      float sizeRange = (maxSize - minSize) * (sizeControl / 255.0f);
+      lavaParticles[i].size = minSize + random16((int)(sizeRange * 10)) / 10.0f;
+
+      lavaParticles[i].hue = SEGMENT.check1 ? hw_random8() : random16(256);
+      lavaParticles[i].life = 255;
+      lavaParticles[i].active = true;
+      break;
+    }
+  }
+
+  // Fade background slightly for trailing effect
+  SEGMENT.fadeToBlackBy(40);
+
+  // Update and draw particles
+  int activeCount = 0;
+  for (int i = 0; i < MAX_LAVA_PARTICLES; i++) {
+    if (!lavaParticles[i].active) continue;
+    activeCount++;
+
+    // Keep particle count on target by deactivating excess particles
+    if (activeCount > numParticles) {
+      lavaParticles[i].active = false;
+      activeCount--;
+      continue;
+    }
+
+    LavaParticle *p = &lavaParticles[i];
+
+    // Physics update
+    p->x += p->vx;
+    p->y += p->vy;
+
+    // Optional blob attraction (enabled with check2)
+    if (SEGMENT.check2) {
+      for (int j = 0; j < MAX_LAVA_PARTICLES; j++) {
+        if (i == j || !lavaParticles[j].active) continue;
+
+        LavaParticle *other = &lavaParticles[j];
+
+        // Only attract if moving in opposite vertical directions
+        if ((p->vy < 0 && other->vy < 0) || (p->vy > 0 && other->vy > 0)) continue;
+
+        float dx = other->x - p->x;
+        float dy = other->y - p->y;
+        float dist = sqrt(dx*dx + dy*dy);
+
+        // Apply weak horizontal attraction only
+        float attractRange = (p->size + other->size) * 1.0f;
+        if (dist > 0 && dist < attractRange) {
+          // Very weak horizontal-only attraction
+          float force = (1.0f - (dist / attractRange)) * 0.0001f;
+          p->vx += (dx / dist) * force;
+        }
+      }
+    }
+
+    // Horizontal oscillation (makes it more organic)
+    p->vx += sin((millis() / 1000.0f + i) * 0.5f) * 0.002f; // Reduced oscillation
+    p->vx *= 0.92f; // Stronger damping for less drift
+
+    // Bounce off sides (don't affect vertical velocity)
+    if (p->x <= 0) {
+      p->x = 1;
+      p->vx = abs(p->vx); // Just reverse horizontal, don't reduce
+    }
+    if (p->x >= cols) {
+      p->x = cols - 1;
+      p->vx = -abs(p->vx); // Just reverse horizontal, don't reduce
+    }
+
+    // Boundary handling with proper reversal
+    // When reaching TOP (y=0 area), reverse to fall back down
+    if (p->y <= 0.5f * p->size) {
+      p->y = 0.5f * p->size;
+      if (p->vy < 0) {
+        p->vy = -p->vy * 0.5f; // Reverse to positive (fall down) at HALF speed
+        // Ensure minimum downward velocity
+        if (p->vy < 0.06f) p->vy = 0.06f;
+      }
+    }
+
+    // When reaching BOTTOM (y=rows-1 area), reverse to rise back up
+    if (p->y >= rows - 0.5f * p->size) {
+      p->y = rows - 0.5f * p->size;
+      if (p->vy > 0) {
+        p->vy = -p->vy; // Reverse to negative (rise up)
+        // Add random speed boost when rising
+        p->vy -= random16(15) / 100.0f; // Subtract to make MORE negative (faster up)
+        // Ensure minimum upward velocity
+        if (p->vy > -0.10f) p->vy = -0.10f;
+      }
+    }
+
+    // Keep blobs alive forever - no fading
+    p->life = 255;
+
+    // Get color
+    uint32_t color;
+    if (SEGMENT.check1) {
+      color = SEGMENT.color_wheel(p->hue);  // Random colors mode
+    } else {
+      color = SEGMENT.color_from_palette(p->hue, false, true, 0);   // Palette mode
+    }
+
+    // Extract RGB
+    uint8_t r = (color >> 16) & 0xFF;
+    uint8_t g = (color >> 8) & 0xFF;
+    uint8_t b = color & 0xFF;
+
+    // Apply life/opacity
+    r = (r * p->life) >> 8;
+    g = (g * p->life) >> 8;
+    b = (b * p->life) >> 8;
+
+    // Draw blob with soft edges (gaussian-like falloff)
+    for (int dy = -(int)p->size; dy <= (int)p->size; dy++) {
+      for (int dx = -(int)p->size; dx <= (int)p->size; dx++) {
+        int px = (int)(p->x + dx);
+        int py = (int)(p->y + dy);
+
+        if (px >= 0 && px < cols && py >= 0 && py < rows) {
+          float dist = sqrt(dx*dx + dy*dy);
+          if (dist < p->size) {
+            // Soft falloff
+            float intensity = 1.0f - (dist / p->size);
+            intensity = intensity * intensity; // Square for smoother falloff
+
+            uint8_t br = r * intensity;
+            uint8_t bg = g * intensity;
+            uint8_t bb = b * intensity;
+
+            // Additive blending for organic merging
+            uint32_t existing = SEGMENT.getPixelColorXY(px, py);
+            uint8_t er = (existing >> 16) & 0xFF;
+            uint8_t eg = (existing >> 8) & 0xFF;
+            uint8_t eb = existing & 0xFF;
+
+            er = qadd8(er, br);
+            eg = qadd8(eg, bg);
+            eb = qadd8(eb, bb);
+
+            SEGMENT.setPixelColorXY(px, py, RGBW32(er, eg, eb, 0));
+          }
+        }
+      }
+    }
+  }
+
+  return FRAMETIME;
+}
+static const char _data_FX_MODE_2D_LAVALAMP[] PROGMEM = "Lava Lamp@Speed,# of blobs,Blob size,,,Color mode,Attract;;!;2;sx=64,ix=64,o2=1,pal=47";
+#undef MAX_LAVA_PARTICLES
+
+
+
 /////////////////////
 //  UserMod Class  //
 /////////////////////
@@ -98,6 +345,7 @@ class UserFxUsermod : public Usermod {
  public:
   void setup() override {
     strip.addEffect(255, &mode_diffusionfire, _data_FX_MODE_DIFFUSIONFIRE);
+    strip.addEffect(255, &mode_2D_lavalamp, _data_FX_MODE_2D_LAVALAMP);
 
     ////////////////////////////////////////
     //  add your effect function(s) here  //