diff --git a/src/internal/NeoColorFeatures.h b/src/internal/NeoColorFeatures.h index cd88e6d..d7cc9fe 100644 --- a/src/internal/NeoColorFeatures.h +++ b/src/internal/NeoColorFeatures.h @@ -38,6 +38,7 @@ License along with NeoPixel. If not, see #include "features/Neo4ByteFeature.h" #include "features/DotStarX4ByteFeature.h" #include "features/DotStarL4ByteFeature.h" +#include "features/Neo6ByteFeature.h" #include "features/Neo6xByteFeature.h" #include "features/Neo6xxByteFeature.h" #include "features/Neo3WordFeature.h" @@ -53,6 +54,7 @@ License along with NeoPixel. If not, see #include "features/NeoRgbwxxFeatures.h" #include "features/NeoRgbcwxFeatures.h" +#include "features/NeoRgbwwwFeatures.h" #include "features/NeoSm168x3Features.h" #include "features/NeoSm168x4Features.h" #include "features/NeoSm168x5Features.h" diff --git a/src/internal/NeoColors.h b/src/internal/NeoColors.h index 9d4bdd4..89941d1 100644 --- a/src/internal/NeoColors.h +++ b/src/internal/NeoColors.h @@ -45,6 +45,8 @@ License along with NeoPixel. If not, see #include "colors/RgbwwColor.h" #include "colors/Rgbww80Color.h" +#include "colors/RgbwwwColor.h" + #include "colors/SegmentDigit.h" #include "colors/NeoGamma.h" diff --git a/src/internal/NeoSettings.h b/src/internal/NeoSettings.h index 3835d6a..a172aaa 100644 --- a/src/internal/NeoSettings.h +++ b/src/internal/NeoSettings.h @@ -135,4 +135,48 @@ public: const uint16_t BlueTenthMilliAmpere; // in 1/10th ma const uint16_t WarmWhiteTenthMilliAmpere; // in 1/10th ma const uint16_t CoolWhiteTenthMilliAmpere; // in 1/10th ma +}; + +class NeoRgbwwwCurrentSettings +{ +public: + NeoRgbwwwCurrentSettings(uint16_t red, uint16_t green, uint16_t blue, uint16_t white1, uint16_t white2, uint16_t white3) : + RedTenthMilliAmpere(red), + GreenTenthMilliAmpere(green), + BlueTenthMilliAmpere(blue), + W1TenthMilliAmpere(white1), + W2TenthMilliAmpere(white2), + W3TenthMilliAmpere(white3) + { + } + + // ------------------------------------------------------------------------ + // operator [] - readonly + // access elements in order by index rather than member name + // ------------------------------------------------------------------------ + uint16_t operator[](size_t idx) const + { + switch (idx) + { + case 0: + return RedTenthMilliAmpere; + case 1: + return GreenTenthMilliAmpere; + case 2: + return BlueTenthMilliAmpere; + case 3: + return W1TenthMilliAmpere; + case 4: + return W2TenthMilliAmpere; + default: + return W3TenthMilliAmpere; + } + } + + 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 W1TenthMilliAmpere; // in 1/10th ma + const uint16_t W2TenthMilliAmpere; // in 1/10th ma + const uint16_t W3TenthMilliAmpere; // in 1/10th ma }; \ No newline at end of file diff --git a/src/internal/colors/NeoGamma.h b/src/internal/colors/NeoGamma.h index 2f000d3..5dba714 100644 --- a/src/internal/colors/NeoGamma.h +++ b/src/internal/colors/NeoGamma.h @@ -84,6 +84,16 @@ public: T_METHOD::Correct(original.WW), T_METHOD::Correct(original.CW)); } + + static RgbwwwColor Correct(const RgbwwwColor& original) + { + return RgbwwwColor(T_METHOD::Correct(original.R), + T_METHOD::Correct(original.G), + T_METHOD::Correct(original.B), + T_METHOD::Correct(original.W1), + T_METHOD::Correct(original.W2), + T_METHOD::Correct(original.W3)); + } }; diff --git a/src/internal/colors/RgbColorIndexes.h b/src/internal/colors/RgbColorIndexes.h index 9267fd9..48df6b8 100644 --- a/src/internal/colors/RgbColorIndexes.h +++ b/src/internal/colors/RgbColorIndexes.h @@ -33,4 +33,6 @@ const uint8_t ColorIndexB = 2; const uint8_t ColorIndexW = 3; const uint8_t ColorIndexWW = 3; // warmer white const uint8_t ColorIndexCW = 4; // cooler white -const uint8_t ColorIndexY = 4; \ No newline at end of file +const uint8_t ColorIndexW1 = 3; +const uint8_t ColorIndexW2 = 4; +const uint8_t ColorIndexW3 = 5; diff --git a/src/internal/colors/RgbwwwColor.cpp b/src/internal/colors/RgbwwwColor.cpp new file mode 100644 index 0000000..a2eb4e7 --- /dev/null +++ b/src/internal/colors/RgbwwwColor.cpp @@ -0,0 +1,253 @@ +/*------------------------------------------------------------------------- +RgbwwwColor 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 "RgbwwwColor.h" + +RgbwwwColor::RgbwwwColor(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; + W1 = (temp & 0xff); + W2 = W1; + W3 = W1; +}; + +RgbwwwColor::RgbwwwColor(const HslColor& color) +{ + RgbColor rgbColor(color); + *this = rgbColor; +} + +RgbwwwColor::RgbwwwColor(const HsbColor& color) +{ + RgbColor rgbColor(color); + *this = rgbColor; +} + +uint8_t RgbwwwColor::CalculateBrightness() const +{ + uint8_t colorB = static_cast((static_cast(R) + static_cast(G) + static_cast(B)) / 3); + uint8_t whiteB = static_cast((static_cast(W1) + static_cast(W2) + static_cast(W3)) / 3); + + return (whiteB > colorB) ? whiteB : colorB; +} + +RgbwwwColor RgbwwwColor::Dim(uint8_t ratio) const +{ + // specifically avoids float math + return RgbwwwColor(_elementDim(R, ratio), + _elementDim(G, ratio), + _elementDim(B, ratio), + _elementDim(W1, ratio), + _elementDim(W2, ratio), + _elementDim(W3, ratio)); +} + +RgbwwwColor RgbwwwColor::Brighten(uint8_t ratio) const +{ + // specifically avoids float math + return RgbwwwColor(_elementBrighten(R, ratio), + _elementBrighten(G, ratio), + _elementBrighten(B, ratio), + _elementBrighten(W1, ratio), + _elementBrighten(W2, ratio), + _elementBrighten(W3, ratio)); +} + +void RgbwwwColor::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 (W1 > delta) + { + W1 -= delta; + } + else + { + W1 = 0; + } + + if (W2 > delta) + { + W2 -= delta; + } + else + { + W2 = 0; + } + + if (W3 > delta) + { + W3 -= delta; + } + else + { + W3 = 0; + } +} + +void RgbwwwColor::Lighten(uint8_t delta) +{ + if (IsColorLess()) + { + if (W1 < Max - delta) + { + W1 += delta; + } + else + { + W1 = Max; + } + + if (W2 < Max - delta) + { + W2 += delta; + } + else + { + W2 = Max; + } + + if (W3 < Max - delta) + { + W3 += delta; + } + else + { + W3 = Max; + } + } + else + { + if (R < Max - delta) + { + R += delta; + } + else + { + R = Max; + } + + if (G < Max - delta) + { + G += delta; + } + else + { + G = Max; + } + + if (B < Max - delta) + { + B += delta; + } + else + { + B = Max; + } + } +} + +RgbwwwColor RgbwwwColor::LinearBlend(const RgbwwwColor& left, const RgbwwwColor& right, float progress) +{ + return RgbwwwColor( 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.W1 + ((static_cast(right.W1) - left.W1) * progress), + left.W2 + ((static_cast(right.W2) - left.W2) * progress), + left.W3 + ((static_cast(right.W3) - left.W3) * progress)); +} + +RgbwwwColor RgbwwwColor::LinearBlend(const RgbwwwColor& left, const RgbwwwColor& right, uint8_t progress) +{ + return RgbwwwColor(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.W1 + (((static_cast(right.W1) - left.W1) * static_cast(progress) + 1) >> 8), + left.W2 + (((static_cast(right.W2) - left.W2) * static_cast(progress) + 1) >> 8), + left.W3 + (((static_cast(right.W3) - left.W3) * static_cast(progress) + 1) >> 8)); +} + +RgbwwwColor RgbwwwColor::BilinearBlend(const RgbwwwColor& c00, + const RgbwwwColor& c01, + const RgbwwwColor& c10, + const RgbwwwColor& 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 RgbwwwColor( + 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.W1 * v00 + c10.W1 * v10 + c01.W1 * v01 + c11.W1 * v11, + c00.W2 * v00 + c10.W2 * v10 + c01.W2 * v01 + c11.W2 * v11, + c00.W3 * v00 + c10.W3 * v10 + c01.W3 * v01 + c11.W3 * v11); +} \ No newline at end of file diff --git a/src/internal/colors/RgbwwwColor.h b/src/internal/colors/RgbwwwColor.h new file mode 100644 index 0000000..c4c781b --- /dev/null +++ b/src/internal/colors/RgbwwwColor.h @@ -0,0 +1,367 @@ +/*------------------------------------------------------------------------- +RgbwwwColor 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; + +// ------------------------------------------------------------------------ +// RgbwwwColor represents a color object that is represented by Red, Green, Blue +// component values and three extra White components. +// It contains helpful color routines to manipulate the color. +// ------------------------------------------------------------------------ +struct RgbwwwColor : RgbColorBase +{ + typedef NeoRgbwwwCurrentSettings SettingsObject; + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor using R, G, B, W1, W2, W3 values (0-255) + // ------------------------------------------------------------------------ + RgbwwwColor(uint8_t r, uint8_t g, uint8_t b, uint8_t w1, uint8_t w2, uint8_t w3) : + R(r), G(g), B(b), W1(w1), W2(w2), W3(w3) + { + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor using R, G, B, (0-255) and a single W (0-765) + // White is set incrementally across the three whites, + // where 1 = (0,0,1), 2 = (0,1,1), 3 = (1,1,1), 4 = (1,1,2) + // ------------------------------------------------------------------------ + RgbwwwColor(uint8_t r, uint8_t g, uint8_t b, uint16_t w) : + R(r), G(g), B(b) + { + ApplyAsIncrementalWhite(w); + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor using a single brightness value (0-255) + // This works well for creating gray tone colors + // (0) = black, (255) = white, (128) = gray + // ------------------------------------------------------------------------ + RgbwwwColor(uint8_t brightness) : + R(0), G(0), B(0), W1(brightness), W2(brightness), W3(brightness) + { + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor using RgbColor + // ------------------------------------------------------------------------ + RgbwwwColor(const RgbColor& color) : + R(color.R), + G(color.G), + B(color.B), + W1(0), + W2(0), + W3(0) + { + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor using RgbwColor + // ------------------------------------------------------------------------ + RgbwwwColor(const RgbwColor& color) : + R(color.R), + G(color.G), + B(color.B), + W1(color.W), + W2(color.W), + W3(color.W) + { + }; + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor using HtmlColor + // ------------------------------------------------------------------------ + RgbwwwColor(const HtmlColor& color); + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor using HslColor + // ------------------------------------------------------------------------ + RgbwwwColor(const HslColor& color); + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor using HsbColor + // ------------------------------------------------------------------------ + RgbwwwColor(const HsbColor& color); + + // ------------------------------------------------------------------------ + // Construct a RgbwwwColor that will have its values set in latter operations + // CAUTION: The R,G,B, W1, W2, W3 members are not initialized and may not be consistent + // ------------------------------------------------------------------------ + RgbwwwColor() + { + }; + + // ------------------------------------------------------------------------ + // Comparison operators + // ------------------------------------------------------------------------ + bool operator==(const RgbwwwColor& other) const + { + return (R == other.R && G == other.G && B == other.B && W1 == other.W1 && W2 == other.W2 && W3 == other.W3); + }; + + bool operator!=(const RgbwwwColor& 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 RgbwwwColor& 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 RgbwwwColor& left, const RgbwwwColor& right, uint8_t epsilon = 1) + { + return _Compare(left, right, epsilon); + } + + // ------------------------------------------------------------------------ + // operator [] - readonly + // access elements in order by index rather than R,G,B,W1,W2,W3 + // 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 W1; + case 4: + return W2; + default: + return W3; + } + } + + // ------------------------------------------------------------------------ + // operator [] - read write + // access elements in order by index rather than R,G,B,W1,W2 + // 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 W1; + case 4: + return W2; + default: + return W3; + } + } + + // ------------------------------------------------------------------------ + // 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 + // ------------------------------------------------------------------------ + RgbwwwColor 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 + // ------------------------------------------------------------------------ + RgbwwwColor 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 RgbwwwColor LinearBlend(const RgbwwwColor& left, const RgbwwwColor& 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 RgbwwwColor LinearBlend(const RgbwwwColor& left, const RgbwwwColor& 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 RgbwwwColor BilinearBlend(const RgbwwwColor& c00, + const RgbwwwColor& c01, + const RgbwwwColor& c10, + const RgbwwwColor& 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 += W1 * settings.W1TenthMilliAmpere / Max; + total += W2 * settings.W2TenthMilliAmpere / Max; + total += W3 * settings.W3TenthMilliAmpere / Max; + + return total; + } + + // ------------------------------------------------------------------------ + // White is set incrementally across the three whites, + // white (0-765) + // where 1 = (0,0,1), 2 = (0,1,1), 3 = (1,1,1), 4 = (1,1,2) + // ------------------------------------------------------------------------ + void ApplyAsIncrementalWhite(uint16_t white) + { + uint8_t value = white / 3; + uint8_t remainder = white % 3; + + W1 = value; + W2 = value; + W3 = value; + + if (remainder) + { + W3++; + if (remainder == 2) + { + W2++; + } + } + } + + // ------------------------------------------------------------------------ + // Red, Green, Blue, Warm White, Cool White color members (0-255) where + // (0,0,0, 0,0,0) is black and + // (255,255,255, 0,0,0) is a white + // (0,0,0, 255,0,0) is white1 and + // (0,0,0, 0,255,0) is white2 and + // Note (255,255,255, 255,255,255) is extreme bright white + // ------------------------------------------------------------------------ + uint8_t R; + uint8_t G; + uint8_t B; + uint8_t W1; + uint8_t W2; + uint8_t W3; + + const static uint8_t Max = 255; + const static size_t Count = 6; // six elements in [] + const static uint16_t MaxIncrementalWhite = 765; + +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/Neo6ByteFeature.h b/src/internal/features/Neo6ByteFeature.h new file mode 100644 index 0000000..3385208 --- /dev/null +++ b/src/internal/features/Neo6ByteFeature.h @@ -0,0 +1,75 @@ +/*------------------------------------------------------------------------- +Neo6ByteFeature provides feature base class to describe color order for + 6 byte features that all 6 bytes are used + +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 + +template +class Neo6ByteFeature : + public NeoByteElements<6, RgbwwwColor, uint16_t> +{ +public: + static void applyPixelColor(uint8_t* pPixels, uint16_t indexPixel, ColorObject color) + { + uint8_t* p = getPixelAddress(pPixels, indexPixel); + + *p++ = color[V_IC_1]; + *p++ = color[V_IC_2]; + *p++ = color[V_IC_3]; + *p++ = color[V_IC_4]; + *p++ = color[V_IC_5]; + *p = color[V_IC_6]; + } + + static ColorObject retrievePixelColor(const uint8_t* pPixels, uint16_t indexPixel) + { + ColorObject color; + const uint8_t* p = getPixelAddress(pPixels, indexPixel); + + color[V_IC_1] = *p++; + color[V_IC_2] = *p++; + color[V_IC_3] = *p++; + color[V_IC_4] = *p++; + color[V_IC_5] = *p++; + color[V_IC_6] = *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[V_IC_1] = pgm_read_byte(p++); + color[V_IC_2] = pgm_read_byte(p++); + color[V_IC_3] = pgm_read_byte(p++); + color[V_IC_4] = pgm_read_byte(p++); + color[V_IC_5] = pgm_read_byte(p++); + color[V_IC_6] = pgm_read_byte(p); + + return color; + } +}; \ No newline at end of file diff --git a/src/internal/features/NeoRgbwwwFeatures.h b/src/internal/features/NeoRgbwwwFeatures.h new file mode 100644 index 0000000..a45c1c8 --- /dev/null +++ b/src/internal/features/NeoRgbwwwFeatures.h @@ -0,0 +1,33 @@ +/*------------------------------------------------------------------------- +NeoRgbcnwFeature 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 NeoGrbwwwFeature : + public Neo6ByteFeature, + public NeoElementsNoSettings +{ +};