functional (#643)

src/NeoPixelBusLg.h

@@ -0,0 +1,130 @@
+/*-------------------------------------------------------------------------
+NeoPixelBus library wrapper template class that provides luminance and gamma control
+
+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
+<http://www.gnu.org/licenses/>.
+-------------------------------------------------------------------------*/
+
+#pragma once
+
+#include "NeoPixelBus.h"
+
+template<typename T_COLOR_FEATURE, typename T_METHOD, typename T_GAMMA = NeoGammaEquationMethod> class NeoPixelBusLg :
+    public NeoPixelBus<T_COLOR_FEATURE, T_METHOD>
+{
+private:
+    typename T_COLOR_FEATURE::ColorObject ConvertColor(typename T_COLOR_FEATURE::ColorObject color)
+    {
+        // dim and then return gamma adjusted
+        color = color.Dim(_luminance);
+        return NeoGamma<T_GAMMA>::Correct(color);
+    }
+
+public:
+    NeoPixelBusLg(uint16_t countPixels, uint8_t pin) :
+        NeoPixelBus<T_COLOR_FEATURE, T_METHOD>(countPixels, pin),
+        _luminance(255)
+    {
+    }
+
+    NeoPixelBusLg(uint16_t countPixels, uint8_t pin, NeoBusChannel channel) :
+        NeoPixelBus<T_COLOR_FEATURE, T_METHOD>(countPixels, pin, channel),
+        _luminance(255)
+    {
+    }
+
+    NeoPixelBusLg(uint16_t countPixels, uint8_t pinClock, uint8_t pinData) :
+        NeoPixelBus<T_COLOR_FEATURE, T_METHOD>(countPixels, pinClock, pinData),
+        _luminance(255)
+    {
+    }
+
+    NeoPixelBusLg(uint16_t countPixels, uint8_t pinClock, uint8_t pinData, uint8_t pinLatch, uint8_t pinOutputEnable = NOT_A_PIN) :
+        NeoPixelBus<T_COLOR_FEATURE, T_METHOD>(countPixels, pinClock, pinData, pinLatch, pinOutputEnable),
+        _luminance(255)
+    {
+    }
+
+    NeoPixelBusLg(uint16_t countPixels) :
+        NeoPixelBus<T_COLOR_FEATURE, T_METHOD>(countPixels),
+        _luminance(255)
+    {
+    }
+
+    void SetLuminance(uint8_t luminance)
+    {
+        // does NOT affect current pixel data as there is no safe way
+        // to reconstruct the original color values after being
+        // modified with both luminance and gama without storing them
+        _luminance = luminance;
+    }
+
+    uint8_t GetLuminance() const
+    {
+        return _luminance;
+    }
+
+    void SetPixelColor(uint16_t indexPixel, typename T_COLOR_FEATURE::ColorObject color)
+    {
+        color = ConvertColor(color);
+        NeoPixelBus<T_COLOR_FEATURE, T_METHOD>::SetPixelColor(indexPixel, color);
+    }
+
+    /*
+     GetPixelColor is not overloaded as the original will be used
+     to just return the fully adjusted color value directly with
+     no reverse conversion since it is fraught with inaccuracy
+    */
+
+    void ClearTo(typename T_COLOR_FEATURE::ColorObject color)
+    {
+        color = ConvertColor(color);
+        NeoPixelBus<T_COLOR_FEATURE, T_METHOD>::ClearTo(color);
+    };
+
+    void ClearTo(typename T_COLOR_FEATURE::ColorObject color, uint16_t first, uint16_t last)
+    {
+        color = ConvertColor(color);
+        NeoPixelBus<T_COLOR_FEATURE, T_METHOD>::ClearTo(color, first, last);
+    }
+
+    // if the Pixels buffer is manipulated directly, then this can be called 
+    // to apply the luminance and gamma correction to those changes
+    void ApplyPostAdjustments()
+    {
+        if (this->IsDirty())
+        {
+            for (uint16_t indexPixel = 0; indexPixel < NeoPixelBus<T_COLOR_FEATURE, T_METHOD>::PixelCount(); indexPixel++)
+            {
+                typename T_COLOR_FEATURE::ColorObject color = NeoPixelBus<T_COLOR_FEATURE, T_METHOD>::GetPixelColor(indexPixel);
+                color = ConvertColor(color);
+                NeoPixelBus<T_COLOR_FEATURE, T_METHOD>::SetPixelColor(indexPixel, color);
+            }
+            this->Dirty();
+        }
+    }
+
+protected:
+    uint8_t _luminance;
+};
+
+

src/internal/NeoGamma.h

@@ -60,19 +60,32 @@ private:
     static const uint8_t _table[256];
 };
 
+// no gamma correction at all
+class NeoGammaNullMethod
+{
+public:
+    static uint8_t Correct(uint8_t value)
+    {
+        return value;
+    }
+    static uint16_t Correct(uint16_t value)
+    {
+        return value;
+    }
+};
 
 // use one of the method classes above as a converter for this template class
 template<typename T_METHOD> class NeoGamma
 {
 public:
-    RgbColor Correct(const RgbColor& original)
+    static RgbColor Correct(const RgbColor& original)
     {
         return RgbColor(T_METHOD::Correct(original.R),
             T_METHOD::Correct(original.G),
             T_METHOD::Correct(original.B));
     }
 
-    RgbwColor Correct(const RgbwColor& original)
+    static RgbwColor Correct(const RgbwColor& original)
     {
         return RgbwColor(T_METHOD::Correct(original.R),
             T_METHOD::Correct(original.G),
@@ -80,14 +93,14 @@ public:
             T_METHOD::Correct(original.W) );
     }
 
-    Rgb48Color Correct(const Rgb48Color& original)
+    static Rgb48Color Correct(const Rgb48Color& original)
     {
         return Rgb48Color(T_METHOD::Correct(original.R),
             T_METHOD::Correct(original.G),
             T_METHOD::Correct(original.B));
     }
 
-    Rgbw64Color Correct(const Rgbw64Color& original)
+    static Rgbw64Color Correct(const Rgbw64Color& original)
     {
         return Rgbw64Color(T_METHOD::Correct(original.R),
             T_METHOD::Correct(original.G),