crgb.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <stdint.h>
 
#include "chsv.h"
#include "fl/namespace.h"
#include "color.h"
#include "lib8tion/types.h"
#include "fl/force_inline.h"
#include "fl/template_magic.h"
 
 
namespace fl {
class Str;
}
 
FASTLED_NAMESPACE_BEGIN
 
// Whether to allow HD_COLOR_MIXING
#ifndef FASTLED_HD_COLOR_MIXING
#ifdef __AVR__
// Saves some memory on these constrained devices.
#define FASTLED_HD_COLOR_MIXING 0
#else
#define FASTLED_HD_COLOR_MIXING 1
#endif  // __AVR__
#endif  // FASTLED_HD_COLOR_MIXING
 
 
struct CRGB;
 
 
void hsv2rgb_rainbow( const struct CHSV& hsv, struct CRGB& rgb);
 
 
struct CRGB {
    union {
        struct {
            union {
                uint8_t r;    
                uint8_t red;  
            };
            union {
                uint8_t g;      
                uint8_t green;  
            };
            union {
                uint8_t b;     
                uint8_t blue;  
            };
        };
        uint8_t raw[3];
    };
 
    static CRGB blend(const CRGB& p1, const CRGB& p2, fract8 amountOfP2);
 
    FASTLED_FORCE_INLINE uint8_t& operator[] (uint8_t x)
    {
        return raw[x];
    }
 
    FASTLED_FORCE_INLINE const uint8_t& operator[] (uint8_t x) const
    {
        return raw[x];
    }
 
    FASTLED_FORCE_INLINE CRGB() = default;
 
    constexpr CRGB(uint8_t ir, uint8_t ig, uint8_t ib) noexcept
        : r(ir), g(ig), b(ib)
    {
    }
 
    constexpr CRGB(uint32_t colorcode) noexcept
    : r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
    {
    }
 
    constexpr uint32_t as_uint32_t() const noexcept {
        return uint32_t(0xff000000) |
               (uint32_t{r} << 16) |
               (uint32_t{g} << 8) |
               uint32_t{b};
    }
 
    constexpr CRGB(LEDColorCorrection colorcode) noexcept
    : r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
    {
    }
 
    constexpr CRGB(ColorTemperature colorcode) noexcept
    : r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
    {
    }
 
    FASTLED_FORCE_INLINE CRGB(const CRGB& rhs) = default;
 
    FASTLED_FORCE_INLINE CRGB(const CHSV& rhs)
    {
        hsv2rgb_rainbow( rhs, *this);
    }
 
    FASTLED_FORCE_INLINE CRGB& operator= (const CRGB& rhs) = default;
 
    FASTLED_FORCE_INLINE CRGB& operator= (const uint32_t colorcode)
    {
        r = (colorcode >> 16) & 0xFF;
        g = (colorcode >>  8) & 0xFF;
        b = (colorcode >>  0) & 0xFF;
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& setRGB (uint8_t nr, uint8_t ng, uint8_t nb)
    {
        r = nr;
        g = ng;
        b = nb;
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& setHSV (uint8_t hue, uint8_t sat, uint8_t val)
    {
        hsv2rgb_rainbow( CHSV(hue, sat, val), *this);
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& setHue (uint8_t hue)
    {
        hsv2rgb_rainbow( CHSV(hue, 255, 255), *this);
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& operator= (const CHSV& rhs)
    {
        hsv2rgb_rainbow( rhs, *this);
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& setColorCode (uint32_t colorcode)
    {
        r = (colorcode >> 16) & 0xFF;
        g = (colorcode >>  8) & 0xFF;
        b = (colorcode >>  0) & 0xFF;
        return *this;
    }
 
 
    FASTLED_FORCE_INLINE CRGB& operator+= (const CRGB& rhs);
 
    FASTLED_FORCE_INLINE CRGB& addToRGB (uint8_t d);
 
    FASTLED_FORCE_INLINE CRGB& operator-= (const CRGB& rhs);
 
    FASTLED_FORCE_INLINE CRGB& subtractFromRGB(uint8_t d);
 
    FASTLED_FORCE_INLINE CRGB& operator-- ();
 
    FASTLED_FORCE_INLINE CRGB operator-- (int );
 
    FASTLED_FORCE_INLINE CRGB& operator++ ();
 
    FASTLED_FORCE_INLINE CRGB operator++ (int );
 
    FASTLED_FORCE_INLINE CRGB& operator/= (uint8_t d )
    {
        r /= d;
        g /= d;
        b /= d;
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& operator>>= (uint8_t d)
    {
        r >>= d;
        g >>= d;
        b >>= d;
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& operator*= (uint8_t d);
 
    FASTLED_FORCE_INLINE CRGB& nscale8_video (uint8_t scaledown);
 
    FASTLED_FORCE_INLINE CRGB& operator%= (uint8_t scaledown);
 
    FASTLED_FORCE_INLINE CRGB& fadeLightBy (uint8_t fadefactor );
 
    FASTLED_FORCE_INLINE CRGB& nscale8 (uint8_t scaledown );
 
    FASTLED_FORCE_INLINE CRGB& nscale8 (const CRGB & scaledown );
 
    constexpr CRGB nscale8_constexpr (const CRGB scaledown ) const;
 
 
    FASTLED_FORCE_INLINE CRGB scale8 (uint8_t scaledown ) const;
 
    FASTLED_FORCE_INLINE CRGB scale8 (const CRGB & scaledown ) const;
 
    FASTLED_FORCE_INLINE CRGB& fadeToBlackBy (uint8_t fadefactor );
 
    FASTLED_FORCE_INLINE CRGB& operator|= (const CRGB& rhs )
    {
        if( rhs.r > r) r = rhs.r;
        if( rhs.g > g) g = rhs.g;
        if( rhs.b > b) b = rhs.b;
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& operator|= (uint8_t d )
    {
        if( d > r) r = d;
        if( d > g) g = d;
        if( d > b) b = d;
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& operator&= (const CRGB& rhs )
    {
        if( rhs.r < r) r = rhs.r;
        if( rhs.g < g) g = rhs.g;
        if( rhs.b < b) b = rhs.b;
        return *this;
    }
 
    FASTLED_FORCE_INLINE CRGB& operator&= (uint8_t d )
    {
        if( d < r) r = d;
        if( d < g) g = d;
        if( d < b) b = d;
        return *this;
    }
 
    constexpr explicit operator bool() const
    {
        return r || g || b;
    }
 
    constexpr explicit operator uint32_t() const
    {
        return uint32_t(0xff000000) |
               (uint32_t{r} << 16) |
               (uint32_t{g} << 8) |
               uint32_t{b};
    }
 
    constexpr CRGB operator-() const
    {
        return CRGB(255 - r, 255 - g, 255 - b);
    }
 
#if (defined SmartMatrix_h || defined SmartMatrix3_h)
    operator rgb24() const {
        rgb24 ret;
        ret.red = r;
        ret.green = g;
        ret.blue = b;
        return ret;
    }
#endif
 
    fl::Str toString() const;
 
    FASTLED_FORCE_INLINE uint8_t getLuma() const;
 
    FASTLED_FORCE_INLINE uint8_t getAverageLight() const;
 
    FASTLED_FORCE_INLINE void maximizeBrightness( uint8_t limit = 255 )  {
        uint8_t max = red;
        if( green > max) max = green;
        if( blue > max) max = blue;
 
        // stop div/0 when color is black
        if(max > 0) {
            uint16_t factor = ((uint16_t)(limit) * 256) / max;
            red =   (red   * factor) / 256;
            green = (green * factor) / 256;
            blue =  (blue  * factor) / 256;
        }
    }
 
    static CRGB computeAdjustment(uint8_t scale, const CRGB & colorCorrection, const CRGB & colorTemperature);
 
    FASTLED_FORCE_INLINE CRGB lerp8( const CRGB& other, fract8 frac) const;
 
    FASTLED_FORCE_INLINE CRGB lerp16( const CRGB& other, fract16 frac) const;
    FASTLED_FORCE_INLINE uint8_t getParity()
    {
        uint8_t sum = r + g + b;
        return (sum & 0x01);
    }
 
    FASTLED_FORCE_INLINE void setParity( uint8_t parity)
    {
        uint8_t curparity = getParity();
 
        if( parity == curparity) return;
 
        if( parity ) {
            // going 'up'
            if( (b > 0) && (b < 255)) {
                if( r == g && g == b) {
                    ++r;
                    ++g;
                }
                ++b;
            } else if( (r > 0) && (r < 255)) {
                ++r;
            } else if( (g > 0) && (g < 255)) {
                ++g;
            } else {
                if( r == g && g == b) {
                    r ^= 0x01;
                    g ^= 0x01;
                }
                b ^= 0x01;
            }
        } else {
            // going 'down'
            if( b > 1) {
                if( r == g && g == b) {
                    --r;
                    --g;
                }
                --b;
            } else if( g > 1) {
                --g;
            } else if( r > 1) {
                --r;
            } else {
                if( r == g && g == b) {
                    r ^= 0x01;
                    g ^= 0x01;
                }
                b ^= 0x01;
            }
        }
    }
 
    typedef enum {
        AliceBlue=0xF0F8FF,             
        Amethyst=0x9966CC,              
        AntiqueWhite=0xFAEBD7,          
        Aqua=0x00FFFF,                  
        Aquamarine=0x7FFFD4,            
        Azure=0xF0FFFF,                 
        Beige=0xF5F5DC,                 
        Bisque=0xFFE4C4,                
        Black=0x000000,                 
        BlanchedAlmond=0xFFEBCD,        
        Blue=0x0000FF,                  
        BlueViolet=0x8A2BE2,            
        Brown=0xA52A2A,                 
        BurlyWood=0xDEB887,             
        CadetBlue=0x5F9EA0,             
        Chartreuse=0x7FFF00,            
        Chocolate=0xD2691E,             
        Coral=0xFF7F50,                 
        CornflowerBlue=0x6495ED,        
        Cornsilk=0xFFF8DC,              
        Crimson=0xDC143C,               
        Cyan=0x00FFFF,                  
        DarkBlue=0x00008B,              
        DarkCyan=0x008B8B,              
        DarkGoldenrod=0xB8860B,         
        DarkGray=0xA9A9A9,              
        DarkGrey=0xA9A9A9,              
        DarkGreen=0x006400,             
        DarkKhaki=0xBDB76B,             
        DarkMagenta=0x8B008B,           
        DarkOliveGreen=0x556B2F,        
        DarkOrange=0xFF8C00,            
        DarkOrchid=0x9932CC,            
        DarkRed=0x8B0000,               
        DarkSalmon=0xE9967A,            
        DarkSeaGreen=0x8FBC8F,          
        DarkSlateBlue=0x483D8B,         
        DarkSlateGray=0x2F4F4F,         
        DarkSlateGrey=0x2F4F4F,         
        DarkTurquoise=0x00CED1,         
        DarkViolet=0x9400D3,            
        DeepPink=0xFF1493,              
        DeepSkyBlue=0x00BFFF,           
        DimGray=0x696969,               
        DimGrey=0x696969,               
        DodgerBlue=0x1E90FF,            
        FireBrick=0xB22222,             
        FloralWhite=0xFFFAF0,           
        ForestGreen=0x228B22,           
        Fuchsia=0xFF00FF,               
        Gainsboro=0xDCDCDC,             
        GhostWhite=0xF8F8FF,            
        Gold=0xFFD700,                  
        Goldenrod=0xDAA520,             
        Gray=0x808080,                  
        Grey=0x808080,                  
        Green=0x008000,                 
        GreenYellow=0xADFF2F,           
        Honeydew=0xF0FFF0,              
        HotPink=0xFF69B4,               
        IndianRed=0xCD5C5C,             
        Indigo=0x4B0082,                
        Ivory=0xFFFFF0,                 
        Khaki=0xF0E68C,                 
        Lavender=0xE6E6FA,              
        LavenderBlush=0xFFF0F5,         
        LawnGreen=0x7CFC00,             
        LemonChiffon=0xFFFACD,          
        LightBlue=0xADD8E6,             
        LightCoral=0xF08080,            
        LightCyan=0xE0FFFF,             
        LightGoldenrodYellow=0xFAFAD2,  
        LightGreen=0x90EE90,            
        LightGrey=0xD3D3D3,             
        LightPink=0xFFB6C1,             
        LightSalmon=0xFFA07A,           
        LightSeaGreen=0x20B2AA,         
        LightSkyBlue=0x87CEFA,          
        LightSlateGray=0x778899,        
        LightSlateGrey=0x778899,        
        LightSteelBlue=0xB0C4DE,        
        LightYellow=0xFFFFE0,           
        Lime=0x00FF00,                  
        LimeGreen=0x32CD32,             
        Linen=0xFAF0E6,                 
        Magenta=0xFF00FF,               
        Maroon=0x800000,                
        MediumAquamarine=0x66CDAA,      
        MediumBlue=0x0000CD,            
        MediumOrchid=0xBA55D3,          
        MediumPurple=0x9370DB,          
        MediumSeaGreen=0x3CB371,        
        MediumSlateBlue=0x7B68EE,       
        MediumSpringGreen=0x00FA9A,     
        MediumTurquoise=0x48D1CC,       
        MediumVioletRed=0xC71585,       
        MidnightBlue=0x191970,          
        MintCream=0xF5FFFA,             
        MistyRose=0xFFE4E1,             
        Moccasin=0xFFE4B5,              
        NavajoWhite=0xFFDEAD,           
        Navy=0x000080,                  
        OldLace=0xFDF5E6,               
        Olive=0x808000,                 
        OliveDrab=0x6B8E23,             
        Orange=0xFFA500,                
        OrangeRed=0xFF4500,             
        Orchid=0xDA70D6,                
        PaleGoldenrod=0xEEE8AA,         
        PaleGreen=0x98FB98,             
        PaleTurquoise=0xAFEEEE,         
        PaleVioletRed=0xDB7093,         
        PapayaWhip=0xFFEFD5,            
        PeachPuff=0xFFDAB9,             
        Peru=0xCD853F,                  
        Pink=0xFFC0CB,                  
        Plaid=0xCC5533,                 
        Plum=0xDDA0DD,                  
        PowderBlue=0xB0E0E6,            
        Purple=0x800080,                
        Red=0xFF0000,                   
        RosyBrown=0xBC8F8F,             
        RoyalBlue=0x4169E1,             
        SaddleBrown=0x8B4513,           
        Salmon=0xFA8072,                
        SandyBrown=0xF4A460,            
        SeaGreen=0x2E8B57,              
        Seashell=0xFFF5EE,              
        Sienna=0xA0522D,                
        Silver=0xC0C0C0,                
        SkyBlue=0x87CEEB,               
        SlateBlue=0x6A5ACD,             
        SlateGray=0x708090,             
        SlateGrey=0x708090,             
        Snow=0xFFFAFA,                  
        SpringGreen=0x00FF7F,           
        SteelBlue=0x4682B4,             
        Tan=0xD2B48C,                   
        Teal=0x008080,                  
        Thistle=0xD8BFD8,               
        Tomato=0xFF6347,                
        Turquoise=0x40E0D0,             
        Violet=0xEE82EE,                
        Wheat=0xF5DEB3,                 
        White=0xFFFFFF,                 
        WhiteSmoke=0xF5F5F5,            
        Yellow=0xFFFF00,                
        YellowGreen=0x9ACD32,           
 
        // LED RGB color that roughly approximates
        // the color of incandescent fairy lights,
        // assuming that you're using FastLED
        // color correction on your LEDs (recommended).
        FairyLight=0xFFE42D,           
 
        // If you are using no color correction, use this
        FairyLightNCC=0xFF9D2A         
 
    } HTMLColorCode;
};
 
 
FASTLED_FORCE_INLINE bool operator== (const CRGB& lhs, const CRGB& rhs)
{
    return (lhs.r == rhs.r) && (lhs.g == rhs.g) && (lhs.b == rhs.b);
}
 
FASTLED_FORCE_INLINE bool operator!= (const CRGB& lhs, const CRGB& rhs)
{
    return !(lhs == rhs);
}
 
FASTLED_FORCE_INLINE bool operator== (const CHSV& lhs, const CHSV& rhs)
{
    return (lhs.h == rhs.h) && (lhs.s == rhs.s) && (lhs.v == rhs.v);
}
 
FASTLED_FORCE_INLINE bool operator!= (const CHSV& lhs, const CHSV& rhs)
{
    return !(lhs == rhs);
}
 
FASTLED_FORCE_INLINE bool operator< (const CRGB& lhs, const CRGB& rhs)
{
    uint16_t sl, sr;
    sl = lhs.r + lhs.g + lhs.b;
    sr = rhs.r + rhs.g + rhs.b;
    return sl < sr;
}
 
FASTLED_FORCE_INLINE bool operator> (const CRGB& lhs, const CRGB& rhs)
{
    uint16_t sl, sr;
    sl = lhs.r + lhs.g + lhs.b;
    sr = rhs.r + rhs.g + rhs.b;
    return sl > sr;
}
 
FASTLED_FORCE_INLINE bool operator>= (const CRGB& lhs, const CRGB& rhs)
{
    uint16_t sl, sr;
    sl = lhs.r + lhs.g + lhs.b;
    sr = rhs.r + rhs.g + rhs.b;
    return sl >= sr;
}
 
FASTLED_FORCE_INLINE bool operator<= (const CRGB& lhs, const CRGB& rhs)
{
    uint16_t sl, sr;
    sl = lhs.r + lhs.g + lhs.b;
    sr = rhs.r + rhs.g + rhs.b;
    return sl <= sr;
}
 
 
 
FASTLED_FORCE_INLINE CRGB operator/( const CRGB& p1, uint8_t d)
{
    return CRGB( p1.r/d, p1.g/d, p1.b/d);
}
 
 
FASTLED_FORCE_INLINE CRGB operator&( const CRGB& p1, const CRGB& p2)
{
    return CRGB( p1.r < p2.r ? p1.r : p2.r,
                 p1.g < p2.g ? p1.g : p2.g,
                 p1.b < p2.b ? p1.b : p2.b);
}
 
FASTLED_FORCE_INLINE CRGB operator|( const CRGB& p1, const CRGB& p2)
{
    return CRGB( p1.r > p2.r ? p1.r : p2.r,
                 p1.g > p2.g ? p1.g : p2.g,
                 p1.b > p2.b ? p1.b : p2.b);
}
 
FASTLED_FORCE_INLINE CRGB operator+( const CRGB& p1, const CRGB& p2);
 
FASTLED_FORCE_INLINE CRGB operator-( const CRGB& p1, const CRGB& p2);
 
FASTLED_FORCE_INLINE CRGB operator*( const CRGB& p1, uint8_t d);
 
FASTLED_FORCE_INLINE CRGB operator%( const CRGB& p1, uint8_t d);
 
 
 
FASTLED_NAMESPACE_END