Color.hpp

Go to the documentation of this file.

#pragma once

#include <Gosu/Platform.hpp>
#include <cstdint>

namespace Gosu
{
    class Color
    {
        std::uint32_t rep;
        #ifdef GOSU_IS_LITTLE_ENDIAN
        enum { RED_OFFSET = 0, GREEN_OFFSET = 8, BLUE_OFFSET = 16, ALPHA_OFFSET = 24 };
        #else
        enum { RED_OFFSET = 24, GREEN_OFFSET = 16, BLUE_OFFSET = 8, ALPHA_OFFSET = 0 };
        #endif
        
    public:
        typedef std::uint8_t Channel;
        static const unsigned GL_FORMAT = 0x1908; // GL_RGBA
        
        Color()
        {
        }
        
        Color(unsigned argb)
        : Color((argb >> 24) & 0xff, (argb >> 16) & 0xff, (argb >> 8) & 0xff, (argb >> 0) & 0xff)
        {
        }
        
        Color(Channel red, Channel green, Channel blue)
        : Color(0xff, red, green, blue)
        {
        }
        
        Color(Channel alpha, Channel red, Channel green, Channel blue)
        {
            rep = (alpha << ALPHA_OFFSET) | (red << RED_OFFSET) |
                  (green << GREEN_OFFSET) | (blue << BLUE_OFFSET);
        }
        
        static Color from_hsv(double h, double s, double v);
        
        static Color from_ahsv(Channel alpha, double h, double s, double v);

        Channel red() const
        {
            return static_cast<Channel>(rep >> RED_OFFSET);
        }

        Channel green() const
        {
            return static_cast<Channel>(rep >> GREEN_OFFSET);
        }

        Channel blue() const
        {
            return static_cast<Channel>(rep >> BLUE_OFFSET);
        }

        Channel alpha() const
        {
            return static_cast<Channel>(rep >> ALPHA_OFFSET);
        }

        void set_red(Channel value)
        {
            rep &= ~(0xff << RED_OFFSET);
            rep |= value << RED_OFFSET;
        }

        void set_green(Channel value)
        {
            rep &= ~(0xff << GREEN_OFFSET);
            rep |= value << GREEN_OFFSET;
        }

        void set_blue(Channel value)
        {
            rep &= ~(0xff << BLUE_OFFSET);
            rep |= value << BLUE_OFFSET;
        }

        void set_alpha(Channel value)
        {
            rep &= ~(0xff << ALPHA_OFFSET);
            rep |= value << ALPHA_OFFSET;
        }

        double hue() const;
        
        void set_hue(double h);
        
        double saturation() const;
        
        void set_saturation(double s);
        
        double value() const;
        
        void set_value(double v);

        std::uint32_t argb() const { return alpha() << 24 | red() << 16 | green() << 8 | blue(); }

        std::uint32_t bgr() const { return blue() << 16 | green() << 8 | red(); }

        std::uint32_t abgr() const { return alpha() << 24 | blue() << 16 | green() << 8 | red(); }
        
        std::uint32_t gl() const { return rep; }
        
        static const Color NONE;
        static const Color BLACK;
        static const Color GRAY;
        static const Color WHITE;
        
        static const Color AQUA;
        static const Color RED;
        static const Color GREEN;
        static const Color BLUE;
        static const Color YELLOW;
        static const Color FUCHSIA;
        static const Color CYAN;
    };
    
#ifndef SWIG
    inline bool operator<(Color a, Color b) { return a.gl() < b.gl(); }
    inline bool operator==(Color a, Color b) { return a.gl() == b.gl(); }
    inline bool operator!=(Color a, Color b) { return a.gl() != b.gl(); }

    Color interpolate(Color a, Color b, double weight = 0.5);
    
    Color multiply(Color a, Color b);
#endif
}