color.h

Go to the documentation of this file.

#pragma once

#ifndef COLOR_H
#define COLOR_H


/**
    \file
    \brief Contains Color and OpenCL::ImageFormat classes.
*/




#include "settings.h"

#include <stdint.h>




/*==============================================================================
    ColorFormat enumeration
==============================================================================*/


/// \brief Enumeration over color formats.
enum ColorFormat {

    COLOR_FORMAT_RGBA_8888,    ///< 32-bit RGBA. From high to low: AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR.
    COLOR_FORMAT_RGB_565       ///< 16-bit RGB. From high to low: RRRRR GGGGGG BBBBB.

};




/*==============================================================================
    Color class
==============================================================================*/


/**
    \brief Class storing a color in the format given by its parameter.

    \param t_ColorFormat  Format in which to store the color.

    All of the Color specializations have (roughly) the same interface. The
    constructor takes 8-bit color channel values in the range 0-255, regardless
    of the number of bits used to represent the channels in the underlying
    representation. If some channels (such as alpha) are not included in the
    color format, then they are not included as constructor parameters. The
    default constructor initializes all channels to zero.

    Copy constructors and assignment operators are overloaded to enable
    conversion between colors, but *only* if the destination color contains a
    superset of the channels supported by the source color. In other words, you
    can convert RGBA to RGB, but not the reverse.

    Additionally, there are accessor functions \c Red, \c Green, \c Blue and \c
    Alpha, again only for those channels supported by the format, which return
    channel values in the range 0-255.

    Finally, the \c PackedType typedef is an unsigned integer type representing
    the underlying packed format, and the \c Packed accessor returns the color,
    packed into this format.

    \see \ref ColorFormat
*/
template< int t_ColorFormat >
struct Color;




/*==============================================================================
    Color< COLOR_FORMAT_RGBA_8888 > specialization
==============================================================================*/


/// \brief Color specialization storing 32-bit RGBA colors.
template<>
struct Color< COLOR_FORMAT_RGBA_8888 > {

    typedef uint32_t PackedType;    ///< 32-bit RGBA. From high to low: AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR.


    /// \brief Initializes all channels to zero.
    inline Color();

    /// \brief Constructs a color from the given channel values (all 0-255).
    inline Color( uint8_t const red, uint8_t const green, uint8_t const blue, uint8_t const alpha = 0 );

    inline Color( Color const& other );

    template< int t_OtherColorFormat >
    inline Color( Color< t_OtherColorFormat > const& other );


    inline Color const& operator=( Color const& other );

    template< int t_OtherColorFormat >
    inline Color const& operator=( Color< t_OtherColorFormat > const& other );


    inline PackedType Packed() const;    ///< \brief Returns packed 32-bit RGBA. From high to low: AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR.

    inline uint8_t Red()   const;    ///< \brief Returns red channel (0-255).
    inline uint8_t Green() const;    ///< \brief Returns green channel (0-255).
    inline uint8_t Blue()  const;    ///< \brief Returns blue channel (0-255).
    inline uint8_t Alpha() const;    ///< \brief Returns alpha channel (0-255).


private:

    inline void Set( uint8_t const red, uint8_t const green, uint8_t const blue, uint8_t const alpha );


    uint32_t m_color;
};




/*==============================================================================
    Color< COLOR_FORMAT_RGB_565 > specialization
==============================================================================*/


/// \brief Color specialization storing 16-bit RGB colors.
template<>
struct Color< COLOR_FORMAT_RGB_565 > {

    typedef uint16_t PackedType;    ///< 16-bit RGB. From high to low: RRRRR GGGGGG BBBBB.


    /// \brief Initializes all channels to zero.
    inline Color();

    /// \brief Constructs a color from the given channel values (all 0-255).
    inline Color( uint8_t const red, uint8_t const green, uint8_t const blue );

    inline Color( Color const& other );

    template< int t_OtherColorFormat >
    inline Color( Color< t_OtherColorFormat > const& other );


    inline Color const& operator=( Color const& other );

    template< int t_OtherColorFormat >
    inline Color const& operator=( Color< t_OtherColorFormat > const& other );


    inline PackedType Packed() const;    ///< \brief Returns packed 16-bit RGB. From high to low: RRRRR GGGGGG BBBBB.

    inline uint8_t Red()   const;    ///< \brief Returns red channel (0-255).
    inline uint8_t Green() const;    ///< \brief Returns green channel (0-255).
    inline uint8_t Blue()  const;    ///< \brief Returns blue channel (0-255).
    inline uint8_t Alpha() const;    ///< \brief Returns alpha channel (0-255).


private:

    inline void Set( uint8_t const red, uint8_t const green, uint8_t const blue );

    uint16_t m_color;
};




/*==============================================================================
    Color< COLOR_FORMAT_RGBA_8888 > methods
==============================================================================*/


Color< COLOR_FORMAT_RGBA_8888 >::Color() : m_color( 0 ) {
}


Color< COLOR_FORMAT_RGBA_8888 >::Color(
    uint8_t const red,
    uint8_t const green,
    uint8_t const blue,
    uint8_t const alpha
)
{
    Set( red, green, blue, alpha );
}


Color< COLOR_FORMAT_RGBA_8888 >::Color( Color const& other ) : m_color( other.m_color ) {
}


template< int t_OtherColorFormat >
Color< COLOR_FORMAT_RGBA_8888 >::Color( Color< t_OtherColorFormat > const& other ) {

    Set( other.Red(), other.Green(), other.Blue(), other.Alpha() );
}


Color< COLOR_FORMAT_RGBA_8888 > const& Color< COLOR_FORMAT_RGBA_8888 >::operator=( Color const& other ) {

    m_color = other.m_color;
    return *this;
}


template< int t_OtherColorFormat >
Color< COLOR_FORMAT_RGBA_8888 > const& Color< COLOR_FORMAT_RGBA_8888 >::operator=( Color< t_OtherColorFormat > const& other ) {

    Set( other.Red(), other.Green(), other.Blue(), other.Alpha() );
    return *this;
}


Color< COLOR_FORMAT_RGBA_8888 >::PackedType Color< COLOR_FORMAT_RGBA_8888 >::Packed() const {

    return m_color;
}


uint8_t Color< COLOR_FORMAT_RGBA_8888 >::Red() const {

    return( m_color & 0xff );
}


uint8_t Color< COLOR_FORMAT_RGBA_8888 >::Green() const {

    return( ( m_color >> 8 ) & 0xff );
}


uint8_t Color< COLOR_FORMAT_RGBA_8888 >::Blue() const {

    return( ( m_color >> 16 ) & 0xff );
}


uint8_t Color< COLOR_FORMAT_RGBA_8888 >::Alpha() const {

    return( m_color >> 24 );
}


void Color< COLOR_FORMAT_RGBA_8888 >::Set(
    uint8_t const red,
    uint8_t const green,
    uint8_t const blue,
    uint8_t const alpha
)
{
    m_color = (
        ( static_cast< uint32_t >( alpha ) << 24 ) |
        ( static_cast< uint32_t >( blue  ) << 16 ) |
        ( static_cast< uint32_t >( green ) <<  8 ) |
        ( static_cast< uint32_t >( red   )       )
    );
}




/*==============================================================================
    Color< COLOR_FORMAT_RGB_565 > methods
==============================================================================*/


Color< COLOR_FORMAT_RGB_565 >::Color() : m_color( 0 ) {
}


Color< COLOR_FORMAT_RGB_565 >::Color(
    uint8_t const red,
    uint8_t const green,
    uint8_t const blue
)
{
    Set( red, green, blue );
}


Color< COLOR_FORMAT_RGB_565 >::Color( Color const& other ) : m_color( other.m_color ) {
}


template< int t_OtherColorFormat >
Color< COLOR_FORMAT_RGB_565 >::Color( Color< t_OtherColorFormat > const& other ) {

    Set( other.Red(), other.Green(), other.Blue() );
}


Color< COLOR_FORMAT_RGB_565 > const& Color< COLOR_FORMAT_RGB_565 >::operator=( Color const& other ) {

    m_color = other.m_color;
    return *this;
}


template< int t_OtherColorFormat >
Color< COLOR_FORMAT_RGB_565 > const& Color< COLOR_FORMAT_RGB_565 >::operator=( Color< t_OtherColorFormat > const& other ) {

    Set( other.Red(), other.Green(), other.Blue() );
    return *this;
}


Color< COLOR_FORMAT_RGB_565 >::PackedType Color< COLOR_FORMAT_RGB_565 >::Packed() const {

    return m_color;
}


uint8_t Color< COLOR_FORMAT_RGB_565 >::Red() const {

    uint8_t const channel = ( ( m_color >> 8 ) & 0xf8 );
    return( channel | ( channel >> 5 ) );
}


uint8_t Color< COLOR_FORMAT_RGB_565 >::Green() const {

    uint8_t const channel = ( ( m_color >> 3 ) & 0xfc );
    return( channel | ( channel >> 6 ) );
}


uint8_t Color< COLOR_FORMAT_RGB_565 >::Blue() const {

    uint8_t const channel = ( ( m_color << 3 ) & 0xf8 );
    return( channel | ( channel >> 5 ) );
}


void Color< COLOR_FORMAT_RGB_565 >::Set(
    uint8_t const red,
    uint8_t const green,
    uint8_t const blue
)
{
    m_color = (
        ( static_cast< uint16_t >( red   & 0xf8 ) << 8 ) |
        ( static_cast< uint16_t >( green & 0xfc ) << 3 ) |
        ( static_cast< uint16_t >( blue  & 0xf8 ) >> 3 )
    );
}




/*==============================================================================
    OpenCL::Converter specialization, OpenCL::ImageFormat class
==============================================================================*/


#if ( SETTING_OPENCL != 0 )


#include "opencl_converter.h"

#include <CL/cl.h>


namespace OpenCL {


/// \brief Converter specialization for Color classes.
template< int t_ColorFormat >
struct Converter< Color< t_ColorFormat > > {

    typedef typename Converter< typename Color< t_ColorFormat >::PackedType >::Type Type;

    static Type Convert( Color< t_ColorFormat > const& source ) {

        return Converter< typename Color< t_ColorFormat >::PackedType >::Convert( source.Packed() );
    }
};


/**
    \brief Maps color formats to OpenCL image format descriptors.

    \param t_ColorFormat  Format in which colors are stored.

    This class contains a single static member: format, which is an OpenCL
    image format descriptor (cl_image_format) for images represented with the
    given color format. We use *normalized* color channels, so, when accessing
    the image from OpenCL, it will be as floating-point channel values in the
    range \f$[0,1]\f$.
*/
template< int t_ColorFormat >
struct ImageFormat {

    static cl_image_format const format;
};


}    // namespace OpenCL


#endif    // SETTING_OPENCL




#endif    // COLOR_H