rename to fastled_slim, add hsv2rgb() convenience aliases, fix FX usage

Author: DedeHai

usermods/user_fx/user_fx.cpp

@@ -117,7 +117,7 @@ static const char _data_FX_MODE_DIFFUSIONFIRE[] PROGMEM = "Diffusion Fire@!,Spar
 
 static void mode_spinning_wheel(void) {
   if (SEGLEN < 1) FX_FALLBACK_STATIC;
-  
+
   unsigned strips = SEGMENT.nrOfVStrips();
   if (strips == 0) FX_FALLBACK_STATIC;
 
@@ -148,15 +148,13 @@ static void mode_spinning_wheel(void) {
 
   // Handle random seeding globally (outside the virtual strip)
   if (SEGENV.call == 0) {
-    random16_set_seed(hw_random16());
     SEGENV.aux1 = (255 << 8) / SEGLEN; // Cache the color scaling
   }
 
   // Check if settings changed (do this once, not per virtual strip)
   uint32_t settingssum = SEGMENT.speed + SEGMENT.intensity + SEGMENT.custom1 + SEGMENT.custom3 + SEGMENT.check1 + SEGMENT.check3;
   bool settingsChanged = (SEGENV.aux0 != settingssum);
   if (settingsChanged) {
-    random16_add_entropy(hw_random16());
     SEGENV.aux0 = settingssum;
   }
 
@@ -166,7 +164,7 @@ static void mode_spinning_wheel(void) {
     uint8_t spinnerSize = map(SEGMENT.custom1, 0, 255, 1, 10);
     uint16_t spin_delay = map(SEGMENT.custom3, 0, 31, 2000, 15000);
     uint32_t now = strip.now;
-    
+
     for (unsigned stripNr = 0; stripNr < strips; stripNr += spinnerSize) {
       uint32_t* stripState = &state[stripNr * stateVarsPerStrip];
       // Check if this spinner is stopped AND has waited its delay
@@ -211,23 +209,23 @@ static void mode_spinning_wheel(void) {
       // Initialize or restart
       if (needsReset && SEGMENT.check1) {   // spin the spinner(s) only if the "Spin me!" checkbox is enabled
         state[CUR_POS_IDX] = 0;
-        
+
         // Set velocity
         uint16_t speed = map(SEGMENT.speed, 0, 255, 300, 800);
         if (speed == 300) {  // random speed (user selected 0 on speed slider)
-          state[VELOCITY_IDX] = random16(200, 900) * 655;   // fixed-point velocity scaling (approx. 65536/100) 
+          state[VELOCITY_IDX] = hw_random16(200, 900) * 655;   // fixed-point velocity scaling (approx. 65536/100) 
         } else {
-          state[VELOCITY_IDX] = random16(speed - 100, speed + 100) * 655;
+          state[VELOCITY_IDX] = hw_random16(speed - 100, speed + 100) * 655;
         }
-        
+
         // Set slowdown start time
         uint16_t slowdown = map(SEGMENT.intensity, 0, 255, 3000, 5000);
         if (slowdown == 3000) {  // random slowdown start time (user selected 0 on intensity slider)
-          state[SLOWDOWN_TIME_IDX] = now + random16(2000, 6000);
+          state[SLOWDOWN_TIME_IDX] = now + hw_random16(2000, 6000);
         } else {
-          state[SLOWDOWN_TIME_IDX] = now + random16(slowdown - 1000, slowdown + 1000);
+          state[SLOWDOWN_TIME_IDX] = now + hw_random16(slowdown - 1000, slowdown + 1000);
         }
-        
+
         state[PHASE_IDX] = 0;
         state[STOP_TIME_IDX] = 0;
         state[WOBBLE_STEP_IDX] = 0;
@@ -250,10 +248,10 @@ static void mode_spinning_wheel(void) {
         // Slowing phase - apply deceleration
         uint32_t decel = velocity / 80;
         if (decel < 100) decel = 100;
-        
+
         velocity = (velocity > decel) ? velocity - decel : 0;
         state[VELOCITY_IDX] = velocity;
-        
+
         // Check if stopped
         if (velocity < 2000) {
           velocity = 0;
@@ -270,7 +268,7 @@ static void mode_spinning_wheel(void) {
         uint32_t wobble_step = state[WOBBLE_STEP_IDX];
         uint16_t stop_pos = state[STOP_POS_IDX];
         uint32_t elapsed = now - state[WOBBLE_TIME_IDX];
-        
+
         if (wobble_step == 0 && elapsed >= 200) {
           // Move back one LED from stop position
           uint16_t back_pos = (stop_pos == 0) ? SEGLEN - 1 : stop_pos - 1;
@@ -291,13 +289,13 @@ static void mode_spinning_wheel(void) {
           state[STOP_TIME_IDX] = now;
         }
       }
-      
+
       // Update position (phases 0 and 1 only)
       if (phase == 0 || phase == 1) {
         pos_fixed += velocity;
         state[CUR_POS_IDX] = pos_fixed;
       }
-      
+
       // Draw LED for all phases
       uint16_t pos = (pos_fixed >> 16) % SEGLEN;
 
@@ -321,7 +319,7 @@ static void mode_spinning_wheel(void) {
         for (uint8_t y = 0; y < spinnerSize; y++) {
           uint16_t drawPos = (pos + y) % SEGLEN;
           int16_t drawStrip = stripNr + x;
-          
+
           // Wrap horizontally if needed, or skip if out of bounds
           if (drawStrip >= 0 && drawStrip < strips) {
             SEGMENT.setPixelColor(indexToVStrip(drawPos, drawStrip), color);
@@ -370,7 +368,7 @@ typedef struct LavaParticle {
 
 static void mode_2D_lavalamp(void) {
   if (!strip.isMatrix || !SEGMENT.is2D()) FX_FALLBACK_STATIC; // not a 2D set-up
-  
+
   const uint16_t cols = SEG_W;
   const uint16_t rows = SEG_H;
   constexpr float MAX_BLOB_RADIUS = 20.0f;  // cap to prevent frame rate drops on large matrices
@@ -405,7 +403,7 @@ static void mode_2D_lavalamp(void) {
 
   uint8_t size = currentSize;
   uint8_t numParticles = currentNumParticles;
-  
+
   // blob size based on matrix width
   const float minSize = cols * 0.15f; // Minimum 15% of width
   const float maxSize = cols * 0.4f;  // Maximum 40% of width
@@ -427,7 +425,7 @@ static void mode_2D_lavalamp(void) {
       lavaParticles[i].y = rows - 1;
       lavaParticles[i].vx = (hw_random16(7) - 3) / 250.0f;
       lavaParticles[i].vy = -(hw_random16(20) + 10) / 100.0f * 0.3f;
-      
+
       lavaParticles[i].size = minSize + (float)hw_random16(rangeInt);
       if (lavaParticles[i].size > MAX_BLOB_RADIUS) lavaParticles[i].size = MAX_BLOB_RADIUS;
 
@@ -444,7 +442,7 @@ static void mode_2D_lavalamp(void) {
 
   // Fade background slightly for trailing effect
   SEGMENT.fadeToBlackBy(40);
-  
+
   // Update and draw particles
   int activeCount = 0;
   unsigned long currentMillis = strip.now;
@@ -460,21 +458,21 @@ static void mode_2D_lavalamp(void) {
     }
 
     LavaParticle *p = &lavaParticles[i];
-    
+
     // Physics update
     p->x += p->vx;
     p->y += p->vy;
-    
+
     // Optional particle/blob attraction
     if (SEGMENT.check2) {
       for (int j = 0; j < MAX_LAVA_PARTICLES; j++) {
         if (i == j || !lavaParticles[j].active) continue;
-        
+
         LavaParticle *other = &lavaParticles[j];
-        
+
         // Skip attraction if moving in same vertical direction (both up or both down)
         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;
 
@@ -580,7 +578,7 @@ static void mode_2D_lavalamp(void) {
     // Get color
     uint32_t color;
     color = SEGMENT.color_from_palette(p->hue, true, PALETTE_SOLID_WRAP, 0);
-    
+
     // Extract RGB and apply life/opacity
     uint8_t w = (W(color) * 255) >> 8;
     uint8_t r = (R(color) * 255) >> 8;
@@ -600,7 +598,7 @@ static void mode_2D_lavalamp(void) {
       for (int dx = -(int)p->size - 1; dx <= (int)p->size + 1; dx++) {
         int px = centerX + dx;
         int py = centerY + dy;
-        
+
         if (px < 0 || px >= cols || py < 0 || py >= rows) continue;
 
         // Sub-pixel distance: measure from true float center to pixel center
@@ -667,34 +665,34 @@ static void drawMagma(const uint16_t width, const uint16_t height, float *ff_y,
 static void drawLavaBombs(const uint16_t width, const uint16_t height, float *particleData, float gravity, uint8_t particleCount) {
   for (uint16_t i = 0; i < particleCount; i++) {
     uint16_t idx = i * 4;
-    
+
     particleData[idx + 3] -= gravity;
     particleData[idx + 0] += particleData[idx + 2];
     particleData[idx + 1] += particleData[idx + 3];
-    
+
     float posX = particleData[idx + 0];
     float posY = particleData[idx + 1];
-    
+
     if (posY > height + height / 4) {
       particleData[idx + 3] = -particleData[idx + 3] * 0.8f;
     }
-    
+
     if (posY < (float)(height / 8) - 1.0f || posX < 0 || posX >= width) {
       particleData[idx + 0] = hw_random(0, width * 100) / 100.0f;
       particleData[idx + 1] = hw_random(0, height * 25) / 100.0f;
       particleData[idx + 2] = hw_random(-75, 75) / 100.0f;
-      
+
       float baseVelocity = hw_random(60, 120) / 100.0f;
       if (hw_random8() < 50) {
         baseVelocity *= 1.6f;
       }
       particleData[idx + 3] = baseVelocity;
       continue;
     }
-    
+
     int16_t xi = (int16_t)posX;
     int16_t yi = (int16_t)posY;
-    
+
     if (xi >= 0 && xi < width && yi >= 0 && yi < height) {
       // Get a random color from the current palette
       uint8_t randomIndex = hw_random8(64, 128);
@@ -705,24 +703,24 @@ static void drawLavaBombs(const uint16_t width, const uint16_t height, float *pa
       float yf = posY - yi;
       float ix = 1.0f - xf;
       float iy = 1.0f - yf;
-      
+
       uint8_t w0 = 255 * ix * iy;
       uint8_t w1 = 255 * xf * iy;
       uint8_t w2 = 255 * ix * yf;
       uint8_t w3 = 255 * xf * yf;
-      
+
       int16_t yFlipped = height - 1 - yi;  // Flip Y coordinate
-  
+
       SEGMENT.addPixelColorXY(xi, yFlipped, pcolor.scale8(w0));
       if (xi + 1 < width) 
         SEGMENT.addPixelColorXY(xi + 1, yFlipped, pcolor.scale8(w1));
       if (yFlipped - 1 >= 0)
         SEGMENT.addPixelColorXY(xi, yFlipped - 1, pcolor.scale8(w2));
-      if (xi + 1 < width && yFlipped - 1 >= 0) 
+      if (xi + 1 < width && yFlipped - 1 >= 0)
         SEGMENT.addPixelColorXY(xi + 1, yFlipped - 1, pcolor.scale8(w3));
     }
   }
-} 
+}
 
 static void mode_2D_magma(void) {
   if (!strip.isMatrix || !SEGMENT.is2D()) FX_FALLBACK_STATIC;  // not a 2D set-up
@@ -746,7 +744,7 @@ static void mode_2D_magma(void) {
   uint32_t settingsKey = (uint32_t)SEGMENT.speed | ((uint32_t)SEGMENT.intensity << 8) |
       ((uint32_t)SEGMENT.custom1 << 16) | ((uint32_t)SEGMENT.custom2 << 24);
   bool settingsChanged = (*settingsSumPtr != settingsKey);
- 
+
   if (SEGENV.call == 0 || settingsChanged) {
     // Intensity slider controls magma height
     uint16_t intensity = SEGMENT.intensity;
@@ -772,7 +770,7 @@ static void mode_2D_magma(void) {
       particleData[idx + 0] = hw_random(0, width * 100) / 100.0f;
       particleData[idx + 1] = hw_random(0, height * 25) / 100.0f;
       particleData[idx + 2] = hw_random(-75, 75) / 100.0f;
-      
+
       float baseVelocity = hw_random(60, 120) / 100.0f;
       if (hw_random8() < 50) {
         baseVelocity *= 1.6f;
@@ -793,7 +791,7 @@ static void mode_2D_magma(void) {
 
   // Gravity control
   float gravity = map(SEGMENT.custom2, 0, 255, 5, 20) / 100.0f;
-  
+
   // Number of particles (lava bombs)
   uint8_t particleCount = map(SEGMENT.custom1, 0, 255, 0, MAGMA_MAX_PARTICLES);
   particleCount = constrain(particleCount, 0, MAGMA_MAX_PARTICLES);
@@ -1035,7 +1033,7 @@ static const char _data_FX_MODE_ANTS[] PROGMEM = "Ants@Ant speed,# of ants,Ant s
 // Build morse code pattern into a buffer
 static void build_morsecode_pattern(const char *morse_code, uint8_t *pattern, uint8_t *wordIndex, uint16_t &index, uint8_t currentWord, int maxSize) {
   const char *c = morse_code;
-  
+
   // Build the dots and dashes into pattern array
   while (*c != '\0') {
     // it's a dot which is 1 pixel
@@ -1082,7 +1080,7 @@ static void build_morsecode_pattern(const char *morse_code, uint8_t *pattern, ui
 
 static void mode_morsecode(void) {
   if (SEGLEN < 1) FX_FALLBACK_STATIC;
-  
+
   // A-Z in Morse Code
   static const char * letters[] = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--",
                      "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};
@@ -1286,7 +1284,7 @@ class UserFxUsermod : public Usermod {
     // strip.addEffect(255, &mode_your_effect3, _data_FX_MODE_YOUR_EFFECT3);
   }
 
-  
+
   ///////////////////////////////////////////////////////////////////////////////////////////////
   //  If you want configuration options in the usermod settings page, implement these methods  //
   ///////////////////////////////////////////////////////////////////////////////////////////////

wled00/FX.cpp

@@ -5007,7 +5007,7 @@ void mode_ColorClouds()
 
     uint32_t pixel;
     if (SEGMENT.palette) { pixel = SEGMENT.color_from_palette(hue, false, true, 0, vol); }
-    else { hsv2rgb(CHSV32(hue, 255, vol), pixel); }
+    else { pixel = CRGBW(CHSV32(hue, 255, vol)); }
 
     // Suppress extremely dark pixels to avoid flickering of plain r/g/b.
     if (int(R(pixel)) + G(pixel) + B(pixel) <= 2) {
@@ -6130,7 +6130,7 @@ void mode_2Dcrazybees(void) {
     uint8_t posX, posY, aimX, aimY, hue;
     int8_t deltaX, deltaY, signX, signY, error;
     void aimed(uint16_t w, uint16_t h) {
-      //random16_set_seed(millis());
+      //prng.setSeed(millis());
       aimX   = prng.random8(0, w);
       aimY   = prng.random8(0, h);
       hue    = prng.random8();

wled00/colors.h

@@ -1,7 +1,7 @@
 #pragma once
 #ifndef WLED_COLORS_H
 #define WLED_COLORS_H
-#include "src/dependencies/fastled/fastled_fcn.h"
+#include "src/dependencies/fastled_slim/fastled_slim.h"
 /*
  * Color structs and color utility functions
  */
@@ -25,7 +25,7 @@
 #define B(c) (byte(c))
 #define W(c) (byte((c) >> 24))
 
-struct CRGBW;
+struct CRGBW; // forward declations
 struct CHSV32;
 
 extern bool gammaCorrectCol;
@@ -196,4 +196,10 @@ inline CHSV32& CHSV32::operator= (const CRGBW& rgb) { // assignment from 32bit r
   rgb2hsv(rgb, *this);
   return *this;
 }
+
+// explicit hsv2rgb conversions for compatibility
+inline CRGBW hsv2rgb(const CHSV32& hsv) { return CRGBW(hsv); }
+inline void  hsv2rgb(const CHSV32& hsv, CRGBW& rgb) { rgb = CRGBW(hsv); }
+inline void  hsv2rgb(const CHSV32& hsv, uint32_t& rgb) { rgb = CRGBW(hsv).color32; }
+
 #endif

wled00/palettes.cpp

@@ -1,5 +1,5 @@
 #include "wled.h"
-#include "src/dependencies/fastled/fastled_fcn.h"
+#include "src/dependencies/fastled_slim/fastled_slim.h"
 
 /*
  * WLED Color palettes

…d00/src/dependencies/fastled/LICENSE.txt …rc/dependencies/fastled_slim/LICENSE.txtwled00/src/dependencies/fastled/LICENSE.txt renamed to wled00/src/dependencies/fastled_slim/LICENSE.txt wled00/src/dependencies/fastled/LICENSE.txt renamed to wled00/src/dependencies/fastled_slim/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2013 FastLED
+Copyright (c) 2013 FastLED modified by @dedehai
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

…src/dependencies/fastled/fastled_fcn.cpp …pendencies/fastled_slim/fastled_slim.cppwled00/src/dependencies/fastled/fastled_fcn.cpp renamed to wled00/src/dependencies/fastled_slim/fastled_slim.cpp wled00/src/dependencies/fastled/fastled_fcn.cpp renamed to wled00/src/dependencies/fastled_slim/fastled_slim.cpp

@@ -1,4 +1,4 @@
-#include "fastled_fcn.h"
+#include "fastled_slim.h"
 
 // Code originally from FastLED version 3.6.0. Optimized for WLED use by @dedehai
 // Licensed unter MIT license, see LICENSE.txt for details