LED_RGB arduino class

#ifndef LED_RVB_DEF
#define LED_RVB_DEF

namespace Color
{
    class RGB
    {
    public:
        RGB() : m_red{ 0 }, m_green{ 0 }, m_blue{ 0 }
        {}
        RGB(uint32_t const &hex)
        {
            byte red = (hex & 0b111111110000000000000000) >> 16;
            byte green = (hex & 0b000000001111111100000000) >> 8;
            byte blue = (hex & 0b000000000000000011111111);
            m_blue = (byte)blue;
            m_green = (byte)green;
            m_red = (byte)red;
        }
        RGB(byte const &red, byte const &green, byte const &blue) : m_red{ red }, m_green{ green }, m_blue{ blue }
        {}
        RGB(RGB const &color) : m_red{ color.red() }, m_green{ color.green() }, m_blue{ color.blue() }
        {}
        byte red() const { return m_red; }
        byte green() const { return m_green; }
        byte blue() const { return m_blue; }
        void setRed(byte const &red) { if (red < 256) m_red = red; }
        void setGreen(byte const &green) { if (green < 256) m_green = green; }
        void setBlue(byte const &blue) { if (blue < 256) m_blue = blue; }

        void setColor(RGB const &color) {
            m_red = color.red();
            m_green = color.green();
            m_blue = color.blue();
        }
        RGB& operator=(const RGB &color)
        {
            setColor(color);
        }
        RGB& operator+=(const RGB &color)
        {
            m_red = (m_red + color.green()) % 256;
            m_green = (m_green + color.green()) % 256;
            m_blue = (m_blue + color.blue()) % 256;
        }
        RGB& operator-=(const RGB &color)
        {
            m_red -= color.red();
            m_green -= color.green();
            m_blue -= color.blue();
        }
        RGB& operator-()
        {
            m_red = -m_red;
            m_green = -m_green;
            m_blue = -m_blue;
        }
        bool operator==(const RGB &color)
        {
            return m_red == color.red() && m_green == color.green() && m_blue == color.blue();
        }
        bool operator>(const RGB &color)
        {
            return (m_red > color.red() && m_green > color.green()) || (m_red > color.red() && m_blue > color.blue()) || (m_blue > color.blue() && m_green > color.green());
        }
        bool operator!=(const RGB &color)
        {
            return !operator==(color);
        }
        bool operator<(const RGB &color)
        {
            return !operator>(color);
        }
        bool operator>=(const RGB &color)
        {
            return operator>(color) || operator==(color);
        }
        bool operator<=(const RGB &color)
        {
            return operator<(color) || operator==(color);
        }
        RGB& operator++()
        {
            m_red++;
            m_green++;
            m_blue++;
        }
        //OPERATOR
    private:
        byte m_red;
        byte m_green;
        byte m_blue;
    };

    const RGB Red{ 0xFF0000 };
    const RGB Maroon{ 0x800000 };
    const RGB Orange{ 0xFF8000 };
    const RGB Yellow{ 0xFFFF00 };
    const RGB Lime{ 0x00FF00 };
    const RGB Green{ 0x008000 };
    const RGB SpringGreen{ 0x00FF7F };
    const RGB DarkCyan{ 0x008B8B };
    const RGB Cyan{ 0x00FFFF };
    const RGB navy{ 0x0080FF };
    const RGB Blue{ 0x0000FF };
    const RGB Purple{ 0x800080 };
    const RGB Magenta{ 0xFF00FF };
    const RGB pink{ 0xFF0000 };
    const RGB gray{ 0x808080 };
    const RGB black{ 0x000000 };
    const RGB white{ 0xFFFFFF };
    const RGB Teal{ 0x008080 };
};

class LED_RVB
{
public:
    LED_RVB(int pin_R, int pin_V, int pin_B) : m_pinR{ pin_R }, m_pinV{ pin_V }, m_pinB{ pin_B }
    {}
    LED_RVB(int pin_R, int pin_V, int pin_B, Color::RGB const &color) : m_pinR{ pin_R }, m_pinV{ pin_V }, m_pinB{ pin_B }, m_color{ color }
    {}
    void setColor(Color::RGB const &color)
    {
        m_color = color;
    }
    void setBlue(byte const &Blue)
    {
        m_color.setBlue(Blue);
    }
    void setRed(byte const &Red)
    {
        m_color.setRed(Red);
    }
    void setGreen(byte const &Green)
    {
        m_color.setGreen(Green);
    }
    void setColor(byte const &Red, byte const &Green, byte const &Blue)
    {
        m_color = Color::RGB(Red, Green, Blue);
    }
    void setColor(uint32_t const &hex)
    {
        m_color = Color::RGB(hex);
    }
    void update()
    {
        analogWrite(m_pinR, m_color.red());
        analogWrite(m_pinV, m_color.green());
        analogWrite(m_pinB, m_color.blue());
    }
    template<typename Function>
    void fade(Color::RGB const &start, Color::RGB const &end, Function func, unsigned long delay = 10)
    {
        unsigned long currentTime{ millis() };
        Color::RGB current(start);
        while (current != end)
        {
            if (current.blue() < end.blue())
                current.setBlue(current.blue() + 1);
            if (current.green() < end.green())
                current.setGreen(current.green() + 1);
            if (current.red() < end.red())
                current.setRed(current.red() + 1);
            while (currentTime < currentTime + delay)
            {
                func();
            }
            update();
            currentTime = millis();
        }
    }
    Color::RGB getColor() const { return m_color; }
private:
    int m_pinR;
    int m_pinV;
    int m_pinB;
    Color::RGB m_color;
    bool m_isWrite;


};



#endif //LED_RVB_DEF