diff --git a/src/internal/NeoColorFeatures.h b/src/internal/NeoColorFeatures.h index 83f77bf..dfa60c8 100644 --- a/src/internal/NeoColorFeatures.h +++ b/src/internal/NeoColorFeatures.h @@ -45,6 +45,7 @@ License along with NeoPixel. If not, see #include "features/NeoRgbw64Feature.h" #include "features/NeoRgbwFeature.h" #include "features/NeoRgbwxxFeature.h" +#include "features/NeoGrbcwxFeature.h" #include "features/NeoSm168xxColorFeatures.h" #include "features/NeoTm1814ColorFeatures.h" #include "features/NeoTm1914ColorFeatures.h" diff --git a/src/internal/NeoColors.h b/src/internal/NeoColors.h index 72ccba4..5842209 100644 --- a/src/internal/NeoColors.h +++ b/src/internal/NeoColors.h @@ -41,6 +41,8 @@ License along with NeoPixel. If not, see #include "colors/RgbwColor.h" #include "colors/Rgbw64Color.h" +#include "colors/RgbwwColor.h" + #include "colors/SegmentDigit.h" #include "colors/NeoGamma.h" diff --git a/src/internal/NeoSettings.h b/src/internal/NeoSettings.h index 008dd29..c4ececa 100644 --- a/src/internal/NeoSettings.h +++ b/src/internal/NeoSettings.h @@ -59,4 +59,23 @@ public: const uint16_t GreenTenthMilliAmpere; // in 1/10th ma const uint16_t BlueTenthMilliAmpere; // in 1/10th ma const uint16_t WhiteTenthMilliAmpere; // in 1/10th ma +}; + +class NeoRgbwwCurrentSettings +{ +public: + NeoRgbwwCurrentSettings(uint16_t red, uint16_t green, uint16_t blue, uint16_t warmWhite, uint16_t coolWhite) : + RedTenthMilliAmpere(red), + GreenTenthMilliAmpere(green), + BlueTenthMilliAmpere(blue), + WarmWhiteTenthMilliAmpere(warmWhite), + CoolWhiteTenthMilliAmpere(coolWhite) + { + } + + const uint16_t RedTenthMilliAmpere; // in 1/10th ma + const uint16_t GreenTenthMilliAmpere; // in 1/10th ma + const uint16_t BlueTenthMilliAmpere; // in 1/10th ma + const uint16_t WarmWhiteTenthMilliAmpere; // in 1/10th ma + const uint16_t CoolWhiteTenthMilliAmpere; // in 1/10th ma }; \ No newline at end of file diff --git a/src/internal/colors/RgbwwColor.cpp b/src/internal/colors/RgbwwColor.cpp new file mode 100644 index 0000000..9751bc2 --- /dev/null +++ b/src/internal/colors/RgbwwColor.cpp @@ -0,0 +1,229 @@ +/*------------------------------------------------------------------------- +RgbwwColor provides a color object that can be directly consumed by NeoPixelBus + +Written by Michael C. Miller. + +I invest time and resources providing this open source code, +please support me by dontating (see https://github.com/Makuna/NeoPixelBus) + +------------------------------------------------------------------------- +This file is part of the Makuna/NeoPixelBus library. + +NeoPixelBus is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation, either version 3 of +the License, or (at your option) any later version. + +NeoPixelBus is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with NeoPixel. If not, see +. +-------------------------------------------------------------------------*/ + +#include +#include "../NeoSettings.h" +#include "RgbColorBase.h" +#include "RgbColor.h" +#include "RgbwColor.h" +#include "Rgb48Color.h" +#include "HslColor.h" +#include "HsbColor.h" +#include "HtmlColor.h" + +#include "RgbwwColor.h" + +RgbwwColor::RgbwwColor(const HtmlColor& color) +{ + uint32_t temp = color.Color; + B = (temp & 0xff); + temp = temp >> 8; + G = (temp & 0xff); + temp = temp >> 8; + R = (temp & 0xff); + temp = temp >> 8; + WW = (temp & 0xff); + CW = WW; +}; + +RgbwwColor::RgbwwColor(const HslColor& color) +{ + RgbColor rgbColor(color); + *this = rgbColor; +} + +RgbwwColor::RgbwwColor(const HsbColor& color) +{ + RgbColor rgbColor(color); + *this = rgbColor; +} + +uint8_t RgbwwColor::CalculateBrightness() const +{ + uint8_t colorB = static_cast((static_cast(R) + static_cast(G) + static_cast(B)) / 3); + uint8_t whiteB = static_cast((static_cast(WW) + static_cast(CW)) / 2); + + return (whiteB > colorB) ? whiteB : colorB; +} + +RgbwwColor RgbwwColor::Dim(uint8_t ratio) const +{ + // specifically avoids float math + return RgbwwColor(_elementDim(R, ratio), + _elementDim(G, ratio), + _elementDim(B, ratio), + _elementDim(WW, ratio), + _elementDim(CW, ratio)); +} + +RgbwwColor RgbwwColor::Brighten(uint8_t ratio) const +{ + // specifically avoids float math + return RgbwwColor(_elementBrighten(R, ratio), + _elementBrighten(G, ratio), + _elementBrighten(B, ratio), + _elementBrighten(WW, ratio), + _elementBrighten(CW, ratio)); +} + +void RgbwwColor::Darken(uint8_t delta) +{ + if (R > delta) + { + R -= delta; + } + else + { + R = 0; + } + + if (G > delta) + { + G -= delta; + } + else + { + G = 0; + } + + if (B > delta) + { + B -= delta; + } + else + { + B = 0; + } + + if (WW > delta) + { + WW -= delta; + } + else + { + WW = 0; + } + + if (CW > delta) + { + CW -= delta; + } + else + { + CW = 0; + } +} + +void RgbwwColor::Lighten(uint8_t delta) +{ + if (IsColorLess()) + { + if (WW < 255 - delta) + { + WW += delta; + } + else + { + WW = 255; + } + + if (CW < 255 - delta) + { + CW += delta; + } + else + { + CW = 255; + } + } + else + { + if (R < 255 - delta) + { + R += delta; + } + else + { + R = 255; + } + + if (G < 255 - delta) + { + G += delta; + } + else + { + G = 255; + } + + if (B < 255 - delta) + { + B += delta; + } + else + { + B = 255; + } + } +} + +RgbwwColor RgbwwColor::LinearBlend(const RgbwwColor& left, const RgbwwColor& right, float progress) +{ + return RgbwwColor( left.R + ((static_cast(right.R) - left.R) * progress), + left.G + ((static_cast(right.G) - left.G) * progress), + left.B + ((static_cast(right.B) - left.B) * progress), + left.WW + ((static_cast(right.WW) - left.WW) * progress), + left.CW + ((static_cast(right.CW) - left.CW) * progress)); +} + +RgbwwColor RgbwwColor::LinearBlend(const RgbwwColor& left, const RgbwwColor& right, uint8_t progress) +{ + return RgbwwColor(left.R + (((static_cast(right.R) - left.R) * static_cast(progress) + 1) >> 8), + left.G + (((static_cast(right.G) - left.G) * static_cast(progress) + 1) >> 8), + left.B + (((static_cast(right.B) - left.B) * static_cast(progress) + 1) >> 8), + left.WW + (((static_cast(right.WW) - left.WW) * static_cast(progress) + 1) >> 8), + left.CW + (((static_cast(right.CW) - left.CW) * static_cast(progress) + 1) >> 8)); +} + +RgbwwColor RgbwwColor::BilinearBlend(const RgbwwColor& c00, + const RgbwwColor& c01, + const RgbwwColor& c10, + const RgbwwColor& c11, + float x, + float y) +{ + float v00 = (1.0f - x) * (1.0f - y); + float v10 = x * (1.0f - y); + float v01 = (1.0f - x) * y; + float v11 = x * y; + + return RgbwwColor( + c00.R * v00 + c10.R * v10 + c01.R * v01 + c11.R * v11, + c00.G * v00 + c10.G * v10 + c01.G * v01 + c11.G * v11, + c00.B * v00 + c10.B * v10 + c01.B * v01 + c11.B * v11, + c00.WW * v00 + c10.WW * v10 + c01.WW * v01 + c11.WW * v11, + c00.CW * v00 + c10.CW * v10 + c01.CW * v01 + c11.CW * v11); +} \ No newline at end of file diff --git a/src/internal/colors/RgbwwColor.h b/src/internal/colors/RgbwwColor.h new file mode 100644 index 0000000..8833e78 --- /dev/null +++ b/src/internal/colors/RgbwwColor.h @@ -0,0 +1,325 @@ +/*------------------------------------------------------------------------- +RgbwwColor provides a color object that can be directly consumed by NeoPixelBus + +Written by Michael C. Miller. + +I invest time and resources providing this open source code, +please support me by dontating (see https://github.com/Makuna/NeoPixelBus) + +------------------------------------------------------------------------- +This file is part of the Makuna/NeoPixelBus library. + +NeoPixelBus is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation, either version 3 of +the License, or (at your option) any later version. + +NeoPixelBus is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with NeoPixel. If not, see +. +-------------------------------------------------------------------------*/ +#pragma once + +struct RgbColor; +struct HslColor; +struct HsbColor; + +// ------------------------------------------------------------------------ +// RgbwwColor represents a color object that is represented by Red, Green, Blue +// component values and two extra White components. +// While the white components are labeled as WW (warm) and CW (cool), they can be +// considered as the "warmer" and "cooler" whites of your LEDs; so that if yours +// have Nuetral and Cool, you could consider the WW as your nuetral. +// It contains helpful color routines to manipulate the color. +// ------------------------------------------------------------------------ +struct RgbwwColor : RgbColorBase +{ + typedef NeoRgbwwCurrentSettings SettingsObject; + + // ------------------------------------------------------------------------ + // Construct a RgbwwColor using R, G, B, WW, CW values (0-255) + // ------------------------------------------------------------------------ + RgbwwColor(uint8_t r, uint8_t g, uint8_t b, uint8_t warmW = 0, uint8_t coolW = 0) : + R(r), G(g), B(b), WW(warmW), CW(coolW) + { + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwColor using a single brightness value (0-255) + // This works well for creating gray tone colors + // (0) = black, (255) = white, (128) = gray + // ------------------------------------------------------------------------ + RgbwwColor(uint8_t brightness) : + R(0), G(0), B(0), WW(brightness), CW(brightness) + { + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwColor using RgbColor + // ------------------------------------------------------------------------ + RgbwwColor(const RgbColor& color) : + R(color.R), + G(color.G), + B(color.B), + WW(0), + CW(0) + { + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwColor using RgbwColor + // ------------------------------------------------------------------------ + RgbwwColor(const RgbwColor& color) : + R(color.R), + G(color.G), + B(color.B), + WW(color.W), + CW(color.W) + { + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwColor using HtmlColor + // ------------------------------------------------------------------------ + RgbwwColor(const HtmlColor& color); + + // ------------------------------------------------------------------------ + // Construct a RgbwwColor using HslColor + // ------------------------------------------------------------------------ + RgbwwColor(const HslColor& color); + + // ------------------------------------------------------------------------ + // Construct a RgbwwColor using HsbColor + // ------------------------------------------------------------------------ + RgbwwColor(const HsbColor& color); + + // ------------------------------------------------------------------------ + // Construct a RgbwwColor that will have its values set in latter operations + // CAUTION: The R,G,B, WW, CW members are not initialized and may not be consistent + // ------------------------------------------------------------------------ + RgbwwColor() + { + }; + + // ------------------------------------------------------------------------ + // Comparison operators + // ------------------------------------------------------------------------ + bool operator==(const RgbwwColor& other) const + { + return (R == other.R && G == other.G && B == other.B && WW == other.WW && CW == other.CW); + }; + + bool operator!=(const RgbwwColor& other) const + { + return !(*this == other); + }; + + // ------------------------------------------------------------------------ + // CompareTo method + // compares against another color with the given epsilon (delta allowed) + // returns the greatest difference of a set of elements, + // 0 = equal within epsilon delta + // negative - this is less than other + // positive - this is greater than other + // ------------------------------------------------------------------------ + int16_t CompareTo(const RgbwwColor& other, uint8_t epsilon = 1) + { + return _Compare(*this, other, epsilon); + } + + // ------------------------------------------------------------------------ + // Compare method + // compares two colors with the given epsilon (delta allowed) + // returns the greatest difference of a set of elements, + // 0 = equal within epsilon delta + // negative - left is less than right + // positive - left is greater than right + // ------------------------------------------------------------------------ + static int16_t Compare(const RgbwwColor& left, const RgbwwColor& right, uint8_t epsilon = 1) + { + return _Compare(left, right, epsilon); + } + + // ------------------------------------------------------------------------ + // operator [] - readonly + // access elements in order by index rather than R,G,B,WW,CW + // see static Count for the number of elements + // ------------------------------------------------------------------------ + uint8_t operator[](size_t idx) const + { + switch (idx) + { + case 0: + return R; + case 1: + return G; + case 2: + return B; + case 3: + return WW; + default: + return CW; + } + } + + // ------------------------------------------------------------------------ + // operator [] - read write + // access elements in order by index rather than R,G,B,WW,CW + // see static Count for the number of elements + // ------------------------------------------------------------------------ + uint8_t& operator[](size_t idx) + { + switch (idx) + { + case 0: + return R; + case 1: + return G; + case 2: + return B; + case 3: + return WW; + default: + return CW; + } + } + + // ------------------------------------------------------------------------ + // Returns if the color is grey, all values are equal other than whites + // ------------------------------------------------------------------------ + bool IsMonotone() const + { + return (R == B && R == G); + }; + + // ------------------------------------------------------------------------ + // Returns if the color components are all zero, the white components maybe + // anything + // ------------------------------------------------------------------------ + bool IsColorLess() const + { + return (R == 0 && B == 0 && G == 0); + }; + + // ------------------------------------------------------------------------ + // CalculateBrightness will calculate the overall brightness + // NOTE: This is a simple linear brightness + // ------------------------------------------------------------------------ + uint8_t CalculateBrightness() const; + + // ------------------------------------------------------------------------ + // Dim will return a new color that is blended to black with the given ratio + // ratio - (0-255) where 255 will return the original color and 0 will return black + // + // NOTE: This is a simple linear blend + // ------------------------------------------------------------------------ + RgbwwColor Dim(uint8_t ratio) const; + + // ------------------------------------------------------------------------ + // Brighten will return a new color that is blended to white with the given ratio + // ratio - (0-255) where 255 will return the original color and 0 will return white + // + // NOTE: This is a simple linear blend + // ------------------------------------------------------------------------ + RgbwwColor Brighten(uint8_t ratio) const; + + // ------------------------------------------------------------------------ + // Darken will adjust the color by the given delta toward black + // NOTE: This is a simple linear change + // delta - (0-255) the amount to dim the color + // ------------------------------------------------------------------------ + void Darken(uint8_t delta); + + // ------------------------------------------------------------------------ + // Lighten will adjust the color by the given delta toward white + // NOTE: This is a simple linear change + // delta - (0-255) the amount to lighten the color + // ------------------------------------------------------------------------ + void Lighten(uint8_t delta); + + // ------------------------------------------------------------------------ + // LinearBlend between two colors by the amount defined by progress variable + // left - the color to start the blend at + // right - the color to end the blend at + // progress - (0.0 - 1.0) value where 0 will return left and 1.0 will return right + // and a value between will blend the color weighted linearly between them + // ------------------------------------------------------------------------ + static RgbwwColor LinearBlend(const RgbwwColor& left, const RgbwwColor& right, float progress); + // progress - (0 - 255) value where 0 will return left and 255 will return right + // and a value between will blend the color weighted linearly between them + // ------------------------------------------------------------------------ + static RgbwwColor LinearBlend(const RgbwwColor& left, const RgbwwColor& right, uint8_t progress); + + // ------------------------------------------------------------------------ + // BilinearBlend between four colors by the amount defined by 2d variable + // c00 - upper left quadrant color + // c01 - upper right quadrant color + // c10 - lower left quadrant color + // c11 - lower right quadrant color + // x - unit value (0.0 - 1.0) that defines the blend progress in horizontal space + // y - unit value (0.0 - 1.0) that defines the blend progress in vertical space + // ------------------------------------------------------------------------ + static RgbwwColor BilinearBlend(const RgbwwColor& c00, + const RgbwwColor& c01, + const RgbwwColor& c10, + const RgbwwColor& c11, + float x, + float y); + + uint16_t CalcTotalTenthMilliAmpere(const SettingsObject& settings) + { + auto total = 0; + + total += R * settings.RedTenthMilliAmpere / Max; + total += G * settings.GreenTenthMilliAmpere / Max; + total += B * settings.BlueTenthMilliAmpere / Max; + total += WW * settings.WarmWhiteTenthMilliAmpere / Max; + total += CW * settings.CoolWhiteTenthMilliAmpere / Max; + + return total; + } + + // ------------------------------------------------------------------------ + // Red, Green, Blue, Warm White, Cool White color members (0-255) where + // (0,0,0,0,0) is black and + // (255,255,255, 0, 0) is a white + // (0,0,0,255,0) is warm white and + // (0,0,0,0,255) is cool white and + // Note (255,255,255,255,255) is extreme bright white + // ------------------------------------------------------------------------ + uint8_t R; + uint8_t G; + uint8_t B; + uint8_t WW; + uint8_t CW; + + const static uint8_t Max = 255; + const static size_t Count = 5; // four elements in [] + +private: + inline static uint8_t _elementDim(uint8_t value, uint8_t ratio) + { + return (static_cast(value) * (static_cast(ratio) + 1)) >> 8; + } + + inline static uint8_t _elementBrighten(uint8_t value, uint8_t ratio) + { + uint16_t element = ((static_cast(value) + 1) << 8) / (static_cast(ratio) + 1); + + if (element > Max) + { + element = Max; + } + else + { + element -= 1; + } + return element; + } +}; + diff --git a/src/internal/features/NeoGrbcwxFeature.h b/src/internal/features/NeoGrbcwxFeature.h new file mode 100644 index 0000000..09cf910 --- /dev/null +++ b/src/internal/features/NeoGrbcwxFeature.h @@ -0,0 +1,73 @@ +/*------------------------------------------------------------------------- +NeoGrbcwxFeature provides feature classes to describe color order and +color depth for NeoPixelBus template class + +Written by Michael C. Miller. + +I invest time and resources providing this open source code, +please support me by dontating (see https://github.com/Makuna/NeoPixelBus) + +------------------------------------------------------------------------- +This file is part of the Makuna/NeoPixelBus library. + +NeoPixelBus is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as +published by the Free Software Foundation, either version 3 of +the License, or (at your option) any later version. + +NeoPixelBus is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with NeoPixel. If not, see +. +-------------------------------------------------------------------------*/ +#pragma once + +class NeoGrbcwxFeature : + public NeoByteElements<6, RgbwwColor, uint16_t>, + public NeoElementsNoSettings +{ +public: + static void applyPixelColor(uint8_t* pPixels, uint16_t indexPixel, ColorObject color) + { + uint8_t* p = getPixelAddress(pPixels, indexPixel); + + *p++ = color.G; + *p++ = color.R; + *p++ = color.B; + *p++ = color.CW; + *p++ = color.WW; + *p = 0x00; // X + } + + static ColorObject retrievePixelColor(const uint8_t* pPixels, uint16_t indexPixel) + { + ColorObject color; + const uint8_t* p = getPixelAddress(pPixels, indexPixel); + + color.G = *p++; + color.R = *p++; + color.B = *p++; + color.CW = *p++; + color.WW = *p; + + return color; + } + + static ColorObject retrievePixelColor_P(PGM_VOID_P pPixels, uint16_t indexPixel) + { + ColorObject color; + const uint8_t* p = getPixelAddress(reinterpret_cast(pPixels), indexPixel); + + color.G = pgm_read_byte(p++); + color.R = pgm_read_byte(p++); + color.B = pgm_read_byte(p++); + color.CW = pgm_read_byte(p++); + color.WW = pgm_read_byte(p); + + return color; + } +};