FastLED  3.1
CRGB Struct Reference

Representation of an RGB pixel (Red, Green, Blue) More...

#include <pixeltypes.h>

Public Types

enum  HTMLColorCode {
  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,
  FairyLight =0xFFE42D, FairyLightNCC =0xFF9D2A
}
 Predefined RGB colors.
 

Public Member Functions

uint8_t & operator[] (uint8_t x) __attribute__((always_inline))
 Array access operator to index into the crgb object.
 
const uint8_t & operator[] (uint8_t x) const __attribute__((always_inline))
 Array access operator to index into the crgb object.
 
 CRGB (uint8_t ir, uint8_t ig, uint8_t ib) __attribute__((always_inline))
 allow construction from R, G, B
 
 CRGB (uint32_t colorcode) __attribute__((always_inline))
 allow construction from 32-bit (really 24-bit) bit 0xRRGGBB color code
 
 CRGB (LEDColorCorrection colorcode) __attribute__((always_inline))
 allow construction from a LEDColorCorrection enum
 
 CRGB (ColorTemperature colorcode) __attribute__((always_inline))
 allow construction from a ColorTemperature enum
 
 CRGB (const CRGB &rhs) __attribute__((always_inline))
 allow copy construction
 
 CRGB (const CHSV &rhs) __attribute__((always_inline))
 allow construction from HSV color
 
CRGBoperator= (const CRGB &rhs) __attribute__((always_inline))
 allow assignment from one RGB struct to another
 
CRGBoperator= (const uint32_t colorcode) __attribute__((always_inline))
 allow assignment from 32-bit (really 24-bit) 0xRRGGBB color code
 
CRGBsetRGB (uint8_t nr, uint8_t ng, uint8_t nb) __attribute__((always_inline))
 allow assignment from R, G, and B
 
CRGBsetHSV (uint8_t hue, uint8_t sat, uint8_t val) __attribute__((always_inline))
 allow assignment from H, S, and V
 
CRGBsetHue (uint8_t hue) __attribute__((always_inline))
 allow assignment from just a Hue, saturation and value automatically at max.
 
CRGBoperator= (const CHSV &rhs) __attribute__((always_inline))
 allow assignment from HSV color
 
CRGBsetColorCode (uint32_t colorcode) __attribute__((always_inline))
 allow assignment from 32-bit (really 24-bit) 0xRRGGBB color code
 
CRGBoperator+= (const CRGB &rhs)
 add one RGB to another, saturating at 0xFF for each channel
 
CRGBaddToRGB (uint8_t d)
 add a contstant to each channel, saturating at 0xFF this is NOT an operator+= overload because the compiler can't usefully decide when it's being passed a 32-bit constant (e.g. More...
 
CRGBoperator-= (const CRGB &rhs)
 subtract one RGB from another, saturating at 0x00 for each channel
 
CRGBsubtractFromRGB (uint8_t d)
 subtract a constant from each channel, saturating at 0x00 this is NOT an operator+= overload because the compiler can't usefully decide when it's being passed a 32-bit constant (e.g. More...
 
CRGBoperator-- () __attribute__((always_inline))
 subtract a constant of '1' from each channel, saturating at 0x00
 
CRGB operator-- (int) __attribute__((always_inline))
 subtract a constant of '1' from each channel, saturating at 0x00
 
CRGBoperator++ () __attribute__((always_inline))
 add a constant of '1' from each channel, saturating at 0xFF
 
CRGB operator++ (int) __attribute__((always_inline))
 add a constant of '1' from each channel, saturating at 0xFF
 
CRGBoperator/= (uint8_t d)
 divide each of the channels by a constant
 
CRGBoperator>>= (uint8_t d)
 right shift each of the channels by a constant
 
CRGBoperator*= (uint8_t d)
 multiply each of the channels by a constant, saturating each channel at 0xFF
 
CRGBnscale8_video (uint8_t scaledown)
 scale down a RGB to N 256ths of it's current brightness, using 'video' dimming rules, which means that unless the scale factor is ZERO each channel is guaranteed NOT to dim down to zero. More...
 
CRGBoperator%= (uint8_t scaledown)
 %= is a synonym for nscale8_video. More...
 
CRGBfadeLightBy (uint8_t fadefactor)
 fadeLightBy is a synonym for nscale8_video( ..., 255-fadefactor)
 
CRGBnscale8 (uint8_t scaledown)
 scale down a RGB to N 256ths of it's current brightness, using 'plain math' dimming rules, which means that if the low light levels may dim all the way to 100% black. More...
 
CRGBnscale8 (const CRGB &scaledown)
 scale down a RGB to N 256ths of it's current brightness, using 'plain math' dimming rules, which means that if the low light levels may dim all the way to 100% black. More...
 
CRGB scale8 (const CRGB &scaledown) const
 return a CRGB object that is a scaled down version of this object
 
CRGBfadeToBlackBy (uint8_t fadefactor)
 fadeToBlackBy is a synonym for nscale8( ..., 255-fadefactor)
 
CRGBoperator|= (const CRGB &rhs)
 "or" operator brings each channel up to the higher of the two values
 
CRGBoperator|= (uint8_t d)
 "or" operator brings each channel up to the higher of the two values
 
CRGBoperator&= (const CRGB &rhs)
 "and" operator brings each channel down to the lower of the two values
 
CRGBoperator&= (uint8_t d)
 "and" operator brings each channel down to the lower of the two values
 
 operator bool () const __attribute__((always_inline))
 this allows testing a CRGB for zero-ness
 
CRGB operator- ()
 invert each channel
 
 operator rgb24 () const
 
uint8_t getLuma () const
 Get the 'luma' of a CRGB object - aka roughly how much light the CRGB pixel is putting out (from 0 to 255). More...
 
uint8_t getAverageLight () const
 Get the average of the R, G, and B values.
 
void maximizeBrightness (uint8_t limit=255)
 maximize the brightness of this CRGB object
 
CRGB lerp8 (CRGB &other, fract8 frac)
 return a new CRGB object after performing a linear interpolation between this object and the passed in object
 
CRGB lerp16 (CRGB &other, fract16 frac)
 return a new CRGB object after performing a linear interpolation between this object and the passed in object
 
uint8_t getParity ()
 getParity returns 0 or 1, depending on the lowest bit of the sum of the color components. More...
 
void setParity (uint8_t parity)
 setParity adjusts the color in the smallest way possible so that the parity of the color is now the desired value. More...
 

Public Attributes

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]
 
}; 
 

Detailed Description

Representation of an RGB pixel (Red, Green, Blue)

Definition at line 90 of file pixeltypes.h.

Member Function Documentation

CRGB& CRGB::addToRGB ( uint8_t  d)
inline

add a contstant to each channel, saturating at 0xFF this is NOT an operator+= overload because the compiler can't usefully decide when it's being passed a 32-bit constant (e.g.

CRGB::Red) and an 8-bit one (CRGB::Blue)

Definition at line 237 of file pixeltypes.h.

uint8_t CRGB::getLuma ( ) const
inline

Get the 'luma' of a CRGB object - aka roughly how much light the CRGB pixel is putting out (from 0 to 255).

Definition at line 451 of file pixeltypes.h.

uint8_t CRGB::getParity ( )
inline

getParity returns 0 or 1, depending on the lowest bit of the sum of the color components.

Definition at line 513 of file pixeltypes.h.

CRGB& CRGB::nscale8 ( uint8_t  scaledown)
inline

scale down a RGB to N 256ths of it's current brightness, using 'plain math' dimming rules, which means that if the low light levels may dim all the way to 100% black.

Definition at line 353 of file pixeltypes.h.

CRGB& CRGB::nscale8 ( const CRGB scaledown)
inline

scale down a RGB to N 256ths of it's current brightness, using 'plain math' dimming rules, which means that if the low light levels may dim all the way to 100% black.

Definition at line 362 of file pixeltypes.h.

CRGB& CRGB::nscale8_video ( uint8_t  scaledown)
inline

scale down a RGB to N 256ths of it's current brightness, using 'video' dimming rules, which means that unless the scale factor is ZERO each channel is guaranteed NOT to dim down to zero.

If it's already nonzero, it'll stay nonzero, even if that means the hue shifts a little at low brightness levels.

Definition at line 329 of file pixeltypes.h.

CRGB& CRGB::operator%= ( uint8_t  scaledown)
inline

%= is a synonym for nscale8_video.

Think of it is scaling down by "a percentage"

Definition at line 337 of file pixeltypes.h.

void CRGB::setParity ( uint8_t  parity)
inline

setParity adjusts the color in the smallest way possible so that the parity of the color is now the desired value.

This allows you to 'hide' one bit of information in the color.

Ideally, we find one color channel which already has data in it, and modify just that channel by one. We don't want to light up a channel that's black if we can avoid it, and if the pixel is 'grayscale', (meaning that R==G==B), we modify all three channels at once, to preserve the neutral hue.

There's no such thing as a free lunch; in many cases this 'hidden bit' may actually be visible, but this code makes reasonable efforts to hide it as much as is reasonably possible.

Also, an effort is made to have make it such that repeatedly setting the parity to different values will not cause the color to 'drift'. Toggling the parity twice should generally result in the original color again.

Definition at line 542 of file pixeltypes.h.

CRGB& CRGB::subtractFromRGB ( uint8_t  d)
inline

subtract a constant from each channel, saturating at 0x00 this is NOT an operator+= overload because the compiler can't usefully decide when it's being passed a 32-bit constant (e.g.

CRGB::Red) and an 8-bit one (CRGB::Blue)

Definition at line 258 of file pixeltypes.h.


The documentation for this struct was generated from the following file: