Skip to content

Commit 48c64ae

Browse files
blazonceksofthack007
blazoncek
authored and
softhack007
committed
Merge pull request wled#3904 from DedeHai/FX_fcn_improvements
added improvements to color scaling and blurring
1 parent 7dc6659 commit 48c64ae

File tree

4 files changed

+168
-114
lines changed

4 files changed

+168
-114
lines changed

‎wled00/FX.h‎

Lines changed: 42 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -617,7 +617,7 @@ typedef struct Segment {
617617
void setPixelColor(float i, CRGB c, bool aa = true) { setPixelColor(i, RGBW32(c.r,c.g,c.b,0), aa); }
618618
uint32_t __attribute__((pure)) getPixelColor(int i); // WLEDMM attribute added
619619
// 1D support functions (some implement 2D as well)
620-
void blur(uint8_t);
620+
void blur(uint8_t, bool smear = false);
621621
void fill(uint32_t c);
622622
void fade_out(uint8_t r);
623623
void fadeToBlackBy(uint8_t fadeBy);
@@ -658,12 +658,15 @@ typedef struct Segment {
658658
return (x%width) + (y%height) * width;
659659
}
660660
void setPixelColorXY(int x, int y, uint32_t c); // set relative pixel within segment with color
661-
void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColorXY(x, y, RGBW32(r,g,b,w)); } // automatically inline
662-
void setPixelColorXY(int x, int y, CRGB c) { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0)); } // automatically inline
663-
void setPixelColorXY(float x, float y, uint32_t c, bool aa = true, bool fast = true);
664-
void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColorXY(x, y, RGBW32(r,g,b,w), aa); }
665-
void setPixelColorXY(float x, float y, CRGB c, bool aa = true) { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0), aa); }
666-
uint32_t __attribute__((pure)) getPixelColorXY(uint16_t x, uint16_t y); // WLEDMM attribute pure
661+
inline void setPixelColorXY(unsigned x, unsigned y, uint32_t c) { setPixelColorXY(int(x), int(y), c); }
662+
inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColorXY(x, y, RGBW32(r,g,b,w)); }
663+
inline void setPixelColorXY(int x, int y, CRGB c) { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0)); }
664+
#ifdef WLED_USE_AA_PIXELS
665+
void setPixelColorXY(float x, float y, uint32_t c, bool aa = true);
666+
inline void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColorXY(x, y, RGBW32(r,g,b,w), aa); }
667+
inline void setPixelColorXY(float x, float y, CRGB c, bool aa = true) { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0), aa); }
668+
#endif
669+
uint32_t __attribute__((pure)) getPixelColorXY(int x, int y);
667670
// 2D support functions
668671
void blendPixelColorXY(uint16_t x, uint16_t y, uint32_t color, uint8_t blend);
669672
void blendPixelColorXY(uint16_t x, uint16_t y, CRGB c, uint8_t blend) { blendPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0), blend); }
@@ -672,8 +675,8 @@ typedef struct Segment {
672675
void addPixelColorXY(int x, int y, CRGB c, bool fast = false) { addPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0), fast); }
673676
void fadePixelColorXY(uint16_t x, uint16_t y, uint8_t fade);
674677
void box_blur(uint16_t i, bool vertical, fract8 blur_amount); // 1D box blur (with weight)
675-
void blurRow(uint16_t row, fract8 blur_amount);
676-
void blurCol(uint16_t col, fract8 blur_amount);
678+
void blurRow(uint32_t row, fract8 blur_amount, bool smear = false);
679+
void blurCol(uint32_t col, fract8 blur_amount, bool smear = false);
677680
void moveX(int8_t delta, bool wrap = false);
678681
void moveY(int8_t delta, bool wrap = false);
679682
void move(uint8_t dir, uint8_t delta, bool wrap = false);
@@ -692,32 +695,36 @@ typedef struct Segment {
692695
void nscale8(uint8_t scale);
693696
bool jsonToPixels(char *name, uint8_t fileNr); //WLEDMM for artifx
694697
#else
695-
uint16_t XY(uint16_t x, uint16_t y) { return x; }
696-
void setPixelColorXY(int x, int y, uint32_t c) { setPixelColor(x, c); }
697-
void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColor(x, RGBW32(r,g,b,w)); }
698-
void setPixelColorXY(int x, int y, CRGB c) { setPixelColor(x, RGBW32(c.r,c.g,c.b,0)); }
699-
void setPixelColorXY(float x, float y, uint32_t c, bool aa = true) { setPixelColor(x, c, aa); }
700-
void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColor(x, RGBW32(r,g,b,w), aa); }
701-
void setPixelColorXY(float x, float y, CRGB c, bool aa = true) { setPixelColor(x, RGBW32(c.r,c.g,c.b,0), aa); }
702-
uint32_t getPixelColorXY(uint16_t x, uint16_t y) { return getPixelColor(x); }
703-
void blendPixelColorXY(uint16_t x, uint16_t y, uint32_t c, uint8_t blend) { blendPixelColor(x, c, blend); }
704-
void blendPixelColorXY(uint16_t x, uint16_t y, CRGB c, uint8_t blend) { blendPixelColor(x, RGBW32(c.r,c.g,c.b,0), blend); }
705-
void addPixelColorXY(int x, int y, uint32_t color, bool fast = false) { addPixelColor(x, color, fast); }
706-
void addPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0, bool fast = false) { addPixelColor(x, RGBW32(r,g,b,w), fast); }
707-
void addPixelColorXY(int x, int y, CRGB c, bool fast = false) { addPixelColor(x, RGBW32(c.r,c.g,c.b,0), fast); }
708-
void fadePixelColorXY(uint16_t x, uint16_t y, uint8_t fade) { fadePixelColor(x, fade); }
709-
void box_blur(uint16_t i, bool vertical, fract8 blur_amount) {}
710-
void blurRow(uint16_t row, fract8 blur_amount) {}
711-
void blurCol(uint16_t col, fract8 blur_amount) {}
712-
void moveX(int8_t delta, bool wrap = false) {}
713-
void moveY(int8_t delta, bool wrap = false) {}
714-
void move(uint8_t dir, uint8_t delta, bool wrap = false) {}
715-
void fill_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c) {}
716-
void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c) {}
717-
void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, CRGB c) {}
718-
void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, uint32_t color) {}
719-
void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, CRGB color) {}
720-
void wu_pixel(uint32_t x, uint32_t y, CRGB c) {}
698+
inline uint16_t XY(uint16_t x, uint16_t y) { return x; }
699+
inline void setPixelColorXY(int x, int y, uint32_t c) { setPixelColor(x, c); }
700+
inline void setPixelColorXY(unsigned x, unsigned y, uint32_t c) { setPixelColor(int(x), c); }
701+
inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColor(x, RGBW32(r,g,b,w)); }
702+
inline void setPixelColorXY(int x, int y, CRGB c) { setPixelColor(x, RGBW32(c.r,c.g,c.b,0)); }
703+
#ifdef WLED_USE_AA_PIXELS
704+
inline void setPixelColorXY(float x, float y, uint32_t c, bool aa = true) { setPixelColor(x, c, aa); }
705+
inline void setPixelColorXY(float x, float y, byte r, byte g, byte b, byte w = 0, bool aa = true) { setPixelColor(x, RGBW32(r,g,b,w), aa); }
706+
inline void setPixelColorXY(float x, float y, CRGB c, bool aa = true) { setPixelColor(x, RGBW32(c.r,c.g,c.b,0), aa); }
707+
#endif
708+
inline uint32_t getPixelColorXY(uint16_t x, uint16_t y) { return getPixelColor(x); }
709+
inline void blendPixelColorXY(uint16_t x, uint16_t y, uint32_t c, uint8_t blend) { blendPixelColor(x, c, blend); }
710+
inline void blendPixelColorXY(uint16_t x, uint16_t y, CRGB c, uint8_t blend) { blendPixelColor(x, RGBW32(c.r,c.g,c.b,0), blend); }
711+
inline void addPixelColorXY(int x, int y, uint32_t color, bool fast = false) { addPixelColor(x, color, fast); }
712+
inline void addPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0, bool fast = false) { addPixelColor(x, RGBW32(r,g,b,w), fast); }
713+
inline void addPixelColorXY(int x, int y, CRGB c, bool fast = false) { addPixelColor(x, RGBW32(c.r,c.g,c.b,0), fast); }
714+
inline void fadePixelColorXY(uint16_t x, uint16_t y, uint8_t fade) { fadePixelColor(x, fade); }
715+
inline void box_blur(uint16_t i, bool vertical, fract8 blur_amount) {}
716+
inline void blurRow(uint32_t row, fract8 blur_amount, bool smear = false) {}
717+
inline void blurCol(uint32_t col, fract8 blur_amount, bool smear = false) {}
718+
inline void moveX(int8_t delta, bool wrap = false) {}
719+
inline void moveY(int8_t delta, bool wrap = false) {}
720+
inline void move(uint8_t dir, uint8_t delta, bool wrap = false) {}
721+
inline void fill_circle(uint16_t cx, uint16_t cy, uint8_t radius, CRGB c) {}
722+
inline void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint32_t c) {}
723+
inline void drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, CRGB c) {}
724+
inline void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, uint32_t color, uint32_t = 0, int8_t = 0) {}
725+
inline void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, CRGB color) {}
726+
inline void drawCharacter(unsigned char chr, int16_t x, int16_t y, uint8_t w, uint8_t h, CRGB c, CRGB c2, int8_t rotate = 0) {}
727+
inline void wu_pixel(uint32_t x, uint32_t y, CRGB c) {}
721728
#endif
722729
uint8_t * getAudioPalette(int pal); //WLEDMM netmindz ar palette
723730
} segment;

‎wled00/FX_2Dfcn.cpp‎

Lines changed: 47 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -221,11 +221,7 @@ void IRAM_ATTR_YN Segment::setPixelColorXY(int x, int y, uint32_t col) //WLEDMM:
221221
uint8_t _bri_t = currentBri(on ? opacity : 0);
222222
if (!_bri_t && !transitional) return;
223223
if (_bri_t < 255) {
224-
byte r = scale8(R(col), _bri_t);
225-
byte g = scale8(G(col), _bri_t);
226-
byte b = scale8(B(col), _bri_t);
227-
byte w = scale8(W(col), _bri_t);
228-
col = RGBW32(r, g, b, w);
224+
col = color_fade(col, _bri_t);
229225
}
230226

231227
if (reverse ) x = virtualWidth() - x - 1;
@@ -310,7 +306,7 @@ void Segment::setPixelColorXY(float x, float y, uint32_t col, bool aa, bool fast
310306
}
311307

312308
// returns RGBW values of pixel
313-
uint32_t Segment::getPixelColorXY(uint16_t x, uint16_t y) {
309+
uint32_t IRAM_ATTR_YN Segment::getPixelColorXY(int x, int y) {
314310
if (!isActive()) return 0; // not active
315311
int i = XY(x,y);
316312
if (ledsrgb) return RGBW32(ledsrgb[i].r, ledsrgb[i].g, ledsrgb[i].b, 0);
@@ -356,59 +352,71 @@ void Segment::fadePixelColorXY(uint16_t x, uint16_t y, uint8_t fade) {
356352
}
357353

358354
// blurRow: perform a blur on a row of a rectangular matrix
359-
void Segment::blurRow(uint16_t row, fract8 blur_amount) {
360-
if (!isActive()) return; // not active
355+
void Segment::blurRow(uint32_t row, fract8 blur_amount, bool smear){
356+
if (!isActive() || blur_amount == 0) return; // not active
361357
const uint_fast16_t cols = virtualWidth();
362358
const uint_fast16_t rows = virtualHeight();
363359

364360
if (row >= rows) return;
365361
// blur one row
366-
uint8_t keep = 255 - blur_amount;
362+
uint8_t keep = smear ? 255 : 255 - blur_amount;
367363
uint8_t seep = blur_amount >> 1;
368-
CRGB carryover = CRGB::Black;
369-
for (uint_fast16_t x = 0; x < cols; x++) {
370-
CRGB cur = getPixelColorXY(x, row);
371-
uint32_t before = uint32_t(cur); // remember color before blur
372-
CRGB part = cur;
373-
part.nscale8(seep);
374-
cur.nscale8(keep);
375-
cur += carryover;
376-
if (x>0) {
377-
CRGB prev = CRGB(getPixelColorXY(x-1, row)) + part;
378-
setPixelColorXY(x-1, row, prev);
364+
uint32_t carryover = BLACK;
365+
uint32_t lastnew;
366+
uint32_t last;
367+
uint32_t curnew;
368+
for (unsigned x = 0; x < cols; x++) {
369+
uint32_t cur = getPixelColorXY(x, row);
370+
uint32_t part = color_fade(cur, seep);
371+
curnew = color_fade(cur, keep);
372+
if (x > 0) {
373+
if (carryover)
374+
curnew = color_add(curnew, carryover, true);
375+
uint32_t prev = color_add(lastnew, part, true);
376+
if (last != prev) // optimization: only set pixel if color has changed
377+
setPixelColorXY(x - 1, row, prev);
379378
}
380-
if (before != uint32_t(cur)) // optimization: only set pixel if color has changed
381-
setPixelColorXY(x, row, cur);
379+
else // first pixel
380+
setPixelColorXY(x, row, curnew);
381+
lastnew = curnew;
382+
last = cur; // save original value for comparison on next iteration
382383
carryover = part;
383384
}
385+
setPixelColorXY(cols-1, row, curnew); // set last pixel
384386
}
385387

386388
// blurCol: perform a blur on a column of a rectangular matrix
387-
void Segment::blurCol(uint16_t col, fract8 blur_amount) {
388-
if (!isActive()) return; // not active
389+
void Segment::blurCol(uint32_t col, fract8 blur_amount, bool smear) {
390+
if (!isActive() || blur_amount == 0) return; // not active
389391
const uint_fast16_t cols = virtualWidth();
390392
const uint_fast16_t rows = virtualHeight();
391393

392394
if (col >= cols) return;
393395
// blur one column
394-
uint8_t keep = 255 - blur_amount;
396+
uint8_t keep = smear ? 255 : 255 - blur_amount;
395397
uint8_t seep = blur_amount >> 1;
396-
CRGB carryover = CRGB::Black;
397-
for (uint_fast16_t y = 0; y < rows; y++) {
398-
CRGB cur = getPixelColorXY(col, y);
399-
CRGB part = cur;
400-
uint32_t before = uint32_t(cur); // remember color before blur
401-
part.nscale8(seep);
402-
cur.nscale8(keep);
403-
cur += carryover;
404-
if (y>0) {
405-
CRGB prev = CRGB(getPixelColorXY(col, y-1)) + part;
406-
setPixelColorXY(col, y-1, prev);
398+
uint32_t carryover = BLACK;
399+
uint32_t lastnew;
400+
uint32_t last;
401+
uint32_t curnew;
402+
for (unsigned y = 0; y < rows; y++) {
403+
uint32_t cur = getPixelColorXY(col, y);
404+
uint32_t part = color_fade(cur, seep);
405+
curnew = color_fade(cur, keep);
406+
if (y > 0) {
407+
if (carryover)
408+
curnew = color_add(curnew, carryover, true);
409+
uint32_t prev = color_add(lastnew, part, true);
410+
if (last != prev) // optimization: only set pixel if color has changed
411+
setPixelColorXY(col, y - 1, prev);
407412
}
408-
if (before != uint32_t(cur)) // optimization: only set pixel if color has changed
409-
setPixelColorXY(col, y, cur);
410-
carryover = part;
413+
else // first pixel
414+
setPixelColorXY(col, y, curnew);
415+
lastnew = curnew;
416+
last = cur; //save original value for comparison on next iteration
417+
carryover = part;
411418
}
419+
setPixelColorXY(col, rows - 1, curnew);
412420
}
413421

414422
// 1D Box blur (with added weight - blur_amount: [0=no blur, 255=max blur])

‎wled00/FX_fcn.cpp‎

Lines changed: 27 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1030,11 +1030,7 @@ void IRAM_ATTR_YN Segment::setPixelColor(int i, uint32_t col) //WLEDMM: IRAM_ATT
10301030
uint8_t _bri_t = currentBri(on ? opacity : 0);
10311031
if (!_bri_t && !transitional && fadeTransition) return; // if _bri_t == 0 && segment is not transitioning && transitions are enabled then save a few CPU cycles
10321032
if (_bri_t < 255) {
1033-
byte r = scale8(R(col), _bri_t);
1034-
byte g = scale8(G(col), _bri_t);
1035-
byte b = scale8(B(col), _bri_t);
1036-
byte w = scale8(W(col), _bri_t);
1037-
col = RGBW32(r, g, b, w);
1033+
col = color_fade(col, _bri_t);
10381034
}
10391035

10401036
// expand pixel (taking into account start, grouping, spacing [and offset])
@@ -1357,42 +1353,43 @@ void Segment::fadeToBlackBy(uint8_t fadeBy) {
13571353
/*
13581354
* blurs segment content, source: FastLED colorutils.cpp
13591355
*/
1360-
void Segment::blur(uint8_t blur_amount)
1361-
{
1356+
void Segment::blur(uint8_t blur_amount, bool smear) {
13621357
if (!isActive() || blur_amount == 0) return; // optimization: 0 means "don't blur"
13631358
#ifndef WLED_DISABLE_2D
13641359
if (is2D()) {
13651360
// compatibility with 2D
1366-
const uint_fast16_t cols = virtualWidth();
1367-
const uint_fast16_t rows = virtualHeight();
1368-
for (uint_fast16_t i = 0; i < rows; i++) blurRow(i, blur_amount); // blur all rows
1369-
for (uint_fast16_t k = 0; k < cols; k++) blurCol(k, blur_amount); // blur all columns
1361+
const unsigned cols = virtualWidth();
1362+
const unsigned rows = virtualHeight();
1363+
for (unsigned i = 0; i < rows; i++) blurRow(i, blur_amount, smear); // blur all rows
1364+
for (unsigned k = 0; k < cols; k++) blurCol(k, blur_amount, smear); // blur all columns
13701365
return;
13711366
}
13721367
#endif
1373-
uint8_t keep = 255 - blur_amount;
1368+
uint8_t keep = smear ? 255 : 255 - blur_amount;
13741369
uint8_t seep = blur_amount >> 1;
1375-
CRGB carryover = CRGB::Black;
1376-
uint_fast16_t vlength = virtualLength();
1377-
for(uint_fast16_t i = 0; i < vlength; i++)
1378-
{
1379-
CRGB cur = CRGB(getPixelColor(i));
1380-
CRGB part = cur;
1381-
uint32_t before = uint32_t(cur); // remember color before blur
1382-
part.nscale8(seep);
1383-
cur.nscale8(keep);
1384-
cur += carryover;
1385-
if(i > 0) {
1386-
uint32_t c = getPixelColor(i-1);
1387-
uint8_t r = R(c);
1388-
uint8_t g = G(c);
1389-
uint8_t b = B(c);
1390-
setPixelColor((uint16_t)(i-1), qadd8(r, part.red), qadd8(g, part.green), qadd8(b, part.blue));
1370+
unsigned vlength = virtualLength();
1371+
uint32_t carryover = BLACK;
1372+
uint32_t lastnew;
1373+
uint32_t last;
1374+
uint32_t curnew;
1375+
for (unsigned i = 0; i < vlength; i++) {
1376+
uint32_t cur = getPixelColor(i);
1377+
uint32_t part = color_fade(cur, seep);
1378+
curnew = color_fade(cur, keep);
1379+
if (i > 0) {
1380+
if (carryover)
1381+
curnew = color_add(curnew, carryover, true);
1382+
uint32_t prev = color_add(lastnew, part, true);
1383+
if (last != prev) // optimization: only set pixel if color has changed
1384+
setPixelColor(i - 1, prev);
13911385
}
1392-
if (before != uint32_t(cur)) // optimization: only set pixel if color has changed
1393-
setPixelColor((uint16_t)i,cur.red, cur.green, cur.blue);
1386+
else // first pixel
1387+
setPixelColor(i, curnew);
1388+
lastnew = curnew;
1389+
last = cur; // save original value for comparison on next iteration
13941390
carryover = part;
13951391
}
1392+
setPixelColor(vlength - 1, curnew);
13961393
}
13971394

13981395
/*

‎wled00/colors.cpp‎

Lines changed: 52 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -37,16 +37,58 @@ IRAM_ATTR_YN uint32_t color_blend(uint32_t color1, uint32_t color2, uint_fast16_
3737
*/
3838
IRAM_ATTR_YN uint32_t color_add(uint32_t c1, uint32_t c2) // WLEDMM added IRAM_ATTR_YN
3939
{
40-
uint32_t r = R(c1) + R(c2);
41-
uint32_t g = G(c1) + G(c2);
42-
uint32_t b = B(c1) + B(c2);
43-
uint32_t w = W(c1) + W(c2);
44-
uint_fast16_t max = r;
45-
if (g > max) max = g;
46-
if (b > max) max = b;
47-
if (w > max) max = w;
48-
if (max < 256) return RGBW32(r, g, b, w);
49-
else return RGBW32(r * 255 / max, g * 255 / max, b * 255 / max, w * 255 / max);
40+
if (fast) {
41+
uint8_t r = R(c1);
42+
uint8_t g = G(c1);
43+
uint8_t b = B(c1);
44+
uint8_t w = W(c1);
45+
r = qadd8(r, R(c2));
46+
g = qadd8(g, G(c2));
47+
b = qadd8(b, B(c2));
48+
w = qadd8(w, W(c2));
49+
return RGBW32(r,g,b,w);
50+
} else {
51+
uint32_t r = R(c1) + R(c2);
52+
uint32_t g = G(c1) + G(c2);
53+
uint32_t b = B(c1) + B(c2);
54+
uint32_t w = W(c1) + W(c2);
55+
uint_fast16_t max = r;
56+
if (g > max) max = g;
57+
if (b > max) max = b;
58+
if (w > max) max = w;
59+
if (max < 256) return RGBW32(r, g, b, w);
60+
else return RGBW32(r * 255 / max, g * 255 / max, b * 255 / max, w * 255 / max);
61+
}
62+
}
63+
64+
/*
65+
* fades color toward black
66+
* if using "video" method the resulting color will never become black unless it is already black
67+
*/
68+
69+
uint32_t color_fade(uint32_t c1, uint8_t amount, bool video)
70+
{
71+
uint32_t scaledcolor; // color order is: W R G B from MSB to LSB
72+
uint32_t r = R(c1);
73+
uint32_t g = G(c1);
74+
uint32_t b = B(c1);
75+
uint32_t w = W(c1);
76+
if (video) {
77+
uint32_t scale = amount; // 32bit for faster calculation
78+
scaledcolor = (((r * scale) >> 8) << 16) + ((r && scale) ? 1 : 0);
79+
scaledcolor |= (((g * scale) >> 8) << 8) + ((g && scale) ? 1 : 0);
80+
scaledcolor |= ((b * scale) >> 8) + ((b && scale) ? 1 : 0);
81+
scaledcolor |= (((w * scale) >> 8) << 24) + ((w && scale) ? 1 : 0);
82+
return scaledcolor;
83+
}
84+
else {
85+
uint32_t scale = 1 + amount;
86+
scaledcolor = ((r * scale) >> 8) << 16;
87+
scaledcolor |= ((g * scale) >> 8) << 8;
88+
scaledcolor |= (b * scale) >> 8;
89+
scaledcolor |= ((w * scale) >> 8) << 24;
90+
return scaledcolor;
91+
}
5092
}
5193

5294
void setRandomColor(byte* rgb)

0 commit comments

Comments
 (0)