cColorRef.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cColorRef_H
#define _INC_cColorRef_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cDebugAssert.h"
 
#ifdef __linux__
typedef UINT32 COLORREF;        
#define RGB(r,g,b)              ((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((COLORREF)(BYTE)(b))<<16))) // = COLORREF
#define CLR_INVALID     0xFFFFFFFF
#endif
 
#ifndef D3DCOLOR_DEFINED // ! defined(_d3d9TYPES_H_) defined(USE_DX)
typedef DWORD D3DCOLOR;         
#define D3DCOLOR_DEFINED
#endif
#ifndef D3DCOLOR_ARGB
#define D3DCOLOR_ARGB(a,r,g,b) ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
#define D3DCOLOR_XRGB(r,g,b)   D3DCOLOR_ARGB(0xff,r,g,b)        
#endif
 
namespace GrayLib
{
        typedef BYTE COLOR_ELEM_t;              
        static const COLOR_ELEM_t COLOR_ALPHA_TRANSPARENT = 0;
        static const COLOR_ELEM_t COLOR_ALPHA_OPAQUE = 0xff;
        static const COLOR_ELEM_t COLOR_ELEM_MAX = 0xff;
 
        typedef WORD COLOR16_t;                 
        typedef WORD COLOR565_t;                
        typedef WORD COLOR555_t;                
 
        class cColorRef
        {
 
        public:
                COLORREF m_color;       
 
        public:
                cColorRef(COLORREF color = 0) noexcept
                        : m_color(color)
                {
                }
                cColorRef(COLOR_ELEM_t r, COLOR_ELEM_t g, COLOR_ELEM_t b) noexcept
                        : m_color(GetRGB(r, g, b))
                {
                }
 
                inline bool isValidColor() const noexcept
                {
                        // fully transparent white is not considered to be valid. COLOR_ALPHA_TRANSPARENT. ??? this isnt right !
                        return m_color != CLR_INVALID;
                }
 
                inline COLOR_ELEM_t GetElem(ITERATE_t i) const noexcept
                {
                        DEBUG_CHECK(IS_INDEX_GOOD(i, 4));
#ifdef USE_LITTLE_ENDIAN
                        return ((const COLOR_ELEM_t*)&m_color)[i];
#else
                        return ((const COLOR_ELEM_t*)&m_color)[3 - i];
#endif
                }
                static inline COLORREF GetRGB(COLOR_ELEM_t r, COLOR_ELEM_t g, COLOR_ELEM_t b) noexcept
                {
                        return (((COLORREF)r) | (((COLORREF)g) << 8) | (((COLORREF)b) << 16));
                }
                static inline COLOR_ELEM_t GetR(COLORREF color) noexcept
                {
                        return ((COLOR_ELEM_t)color);
                }
                static inline COLOR_ELEM_t GetG(COLORREF color) noexcept
                {
                        return ((COLOR_ELEM_t)(color >> 8));
                }
                static inline COLOR_ELEM_t GetB(COLORREF color) noexcept
                {
                        return ((COLOR_ELEM_t)(color >> 16));
                }
 
                static inline D3DCOLOR ToD3D(COLORREF color) noexcept
                {
                        return GetRGB(GetB(color), GetG(color), GetR(color)); 
                }
                static inline COLORREF FromD3D(D3DCOLOR color) noexcept
                {
                        return GetRGB(GetB(color), GetG(color), GetR(color)); 
                }
 
                operator COLORREF () const noexcept
                {
                        return m_color;
                }
                inline COLOR_ELEM_t get_R() const noexcept
                {
                        return GetR(m_color);
                }
                inline COLOR_ELEM_t get_G() const noexcept
                {
                        return GetG(m_color);
                }
                inline COLOR_ELEM_t get_B() const noexcept
                {
                        return GetB(m_color);
                }
 
                inline COLOR16_t get_Grey16() const noexcept
                {
                        return ((COLOR16_t)(get_R() | get_G() | get_B())) << 8;
                }
 
                inline COLORREF get_ColorRef() const noexcept
                {
                        return m_color;
                }
                inline D3DCOLOR get_ColorDX() const noexcept
                {
                        // Convert from GUI color to DX color.
                        return ToD3D(m_color);
                }
        };
 
        class cColorDX
        {
        public:
                D3DCOLOR m_color;       
 
        public:
                cColorDX(D3DCOLOR color = 0) noexcept
                        : m_color(color)
                {
                }
                cColorDX(COLOR_ELEM_t r, COLOR_ELEM_t g, COLOR_ELEM_t b) noexcept
                        : m_color(GetXRGB(r, g, b))
                {
                }
                cColorDX(COLOR_ELEM_t a, COLOR_ELEM_t r, COLOR_ELEM_t g, COLOR_ELEM_t b) noexcept
                        : m_color(GetARGB(a, r, g, b))
                {
                }
 
                static const D3DCOLOR k_ALPHA_MASK = 0xFF000000;
                static const int k_ALPHA_SHIFT = 24;
 
                operator D3DCOLOR () const noexcept
                {
                        return m_color;
                }
                static inline COLOR_ELEM_t GetA(D3DCOLOR color) noexcept
                {
                        return ((COLOR_ELEM_t)(color >> k_ALPHA_SHIFT));
                }
                static inline COLOR_ELEM_t GetR(D3DCOLOR color) noexcept
                {
                        return ((COLOR_ELEM_t)(color >> 16));
                }
                static inline COLOR_ELEM_t GetG(D3DCOLOR color) noexcept
                {
                        return ((COLOR_ELEM_t)(color >> 8));
                }
                static inline COLOR_ELEM_t GetB(D3DCOLOR color) noexcept
                {
                        return ((COLOR_ELEM_t)color);
                }
 
                static inline D3DCOLOR GetAC(COLOR_ELEM_t alpha, D3DCOLOR color) noexcept
                {
                        return ((color &~k_ALPHA_MASK) | (((D3DCOLOR)alpha) << k_ALPHA_SHIFT));
                }
                static inline D3DCOLOR GetARGB(COLOR_ELEM_t a, COLOR_ELEM_t r, COLOR_ELEM_t g, COLOR_ELEM_t b) noexcept
                {
                        return ((((D3DCOLOR)a) << 24) | (((D3DCOLOR)r) << 16) | (((D3DCOLOR)g) << 8) | ((D3DCOLOR)b));
                }
                static inline D3DCOLOR GetXRGB(COLOR_ELEM_t r, COLOR_ELEM_t g, COLOR_ELEM_t b) noexcept
                {
                        return GetARGB(COLOR_ALPHA_OPAQUE, r, g, b);
                }
 
                inline COLOR_ELEM_t GetElem(ITERATE_t i) const
                {
                        ASSERT(IS_INDEX_GOOD(i, 4));
#ifdef USE_LITTLE_ENDIAN
                        return ((const COLOR_ELEM_t*)&m_color)[i];
#else
                        return ((const COLOR_ELEM_t*)&m_color)[3 - i];
#endif
                }
 
                inline COLOR_ELEM_t get_R() const noexcept
                {
                        return GetR(m_color);
                }
                inline COLOR_ELEM_t get_G() const noexcept
                {
                        return GetG(m_color);
                }
                inline COLOR_ELEM_t get_B() const noexcept
                {
                        return GetB(m_color);
                }
                inline COLOR_ELEM_t get_A() const noexcept
                {
                        return GetA(m_color);
                }
 
                inline void put_A(COLOR_ELEM_t a) noexcept
                {
                        m_color &= ~k_ALPHA_MASK;
                        m_color |= ((D3DCOLOR)a) << k_ALPHA_SHIFT;
                }
                inline void put_RGB(D3DCOLOR c) noexcept
                {
                        m_color &= k_ALPHA_MASK;
                        m_color |= (c&~k_ALPHA_MASK);
                }
 
                inline COLOR16_t get_Grey16() const noexcept
                {
                        return ((COLOR16_t)(get_R() | get_G() | get_B())) << 8;
                }
                inline COLORREF get_ColorRef() const noexcept
                {
                        // Convert from DX color to GUI color.
                        return cColorRef::FromD3D(m_color);
                }
                inline D3DCOLOR get_ColorDX() const noexcept
                {
                        return m_color;
                }
        };
 
#pragma pack(1)
        class CATTR_PACKED cColor888
        {
        public:
                COLOR_ELEM_t r;         
                COLOR_ELEM_t g;
                COLOR_ELEM_t b;
        public:
                cColor888() noexcept
                {
                        // uninitialized.
                }
                cColor888(COLORREF color) noexcept
                        : r(cColorRef::GetR(color)), g(cColorRef::GetG(color)), b(cColorRef::GetB(color))
                {
                }
                cColor888(COLOR_ELEM_t _r, COLOR_ELEM_t _g, COLOR_ELEM_t _b) noexcept
                        : r(_r), g(_g), b(_b)
                {
                }
                bool operator == (const cColor888& color2) const noexcept
                {
                        return !::memcmp(this, &color2, sizeof(color2)) ;
                }
                bool operator != (const cColor888& color2) const noexcept
                {
                        return ::memcmp(this, &color2, sizeof(color2)) ;
                }
 
                inline COLOR_ELEM_t GetElem(ITERATE_t i) const noexcept
                {
                        DEBUG_CHECK(IS_INDEX_GOOD(i, 3));
                        return (&r)[i];
                }
 
                inline COLOR_ELEM_t get_R() const noexcept
                {
                        return r;
                }
                inline COLOR_ELEM_t get_G() const noexcept
                {
                        return g;
                }
                inline COLOR_ELEM_t get_B() const noexcept
                {
                        return b;
                }
 
                inline COLORREF get_ColorRef() const noexcept
                {
                        return cColorRef::GetRGB(r, g, b);
                }
                inline D3DCOLOR get_ColorDX() const noexcept
                {
                        return cColorDX::GetXRGB(r, g, b);
                }
        };
 
        class cColor555
        {
        public:
                static const COLOR555_t k_ALPHA_MASK = 0x8000;
                COLOR555_t m_color;
 
        public:
                static COLOR555_t inline Make(COLOR_ELEM_t r, COLOR_ELEM_t g, COLOR_ELEM_t b, bool bOpaque) noexcept
                {
                        const COLOR555_t wAlpha = bOpaque ? k_ALPHA_MASK : 0;
                        return (b >> 3) | (((COLOR555_t)g & 0xf8) << 2) | (((COLOR555_t)r & 0xf8) << 7) | wAlpha;
                }
                cColor555(COLOR555_t c = 0) noexcept
                        : m_color(c)
                {
                }
                cColor555(COLOR_ELEM_t _r, COLOR_ELEM_t _g, COLOR_ELEM_t _b, bool bOpaque = true) noexcept
                        : m_color(Make(_r, _g, _b, bOpaque))
                {
                }
 
                operator COLOR555_t () const noexcept
                {
                        return m_color;
                }
 
                inline COLOR_ELEM_t get_R() const noexcept
                {
                        // convert 5 bits to 8 bits.
                        return (COLOR_ELEM_t)((m_color & 0x7c00) >> (10 - 3));
                }
                inline COLOR_ELEM_t get_G() const noexcept
                {
                        // convert 5 bits to 8 bits.
                        return (COLOR_ELEM_t)((m_color & 0x3e0) >> (5 - 3));
                }
                inline COLOR_ELEM_t get_B() const noexcept
                {
                        // convert 5 bits to 8 bits.
                        return (COLOR_ELEM_t)((m_color & 0x1f) << 3);
                }
                inline COLOR_ELEM_t get_A() const noexcept
                {
                        return (m_color & k_ALPHA_MASK) ? COLOR_ALPHA_OPAQUE : COLOR_ALPHA_TRANSPARENT;
                }
 
                void put_ColorRef(COLORREF cVal) noexcept
                {
                        m_color = (COLOR555_t)((((cVal >> 3) & 0x1f) << 10) | (((cVal >> (8 + 3)) & 0x1f) << 5) | ((cVal >> (16 + 3)) & 0x1f));
                }
                inline COLORREF get_ColorRef() const noexcept
                {
                        return cColorRef::GetRGB(get_R(), get_G(), get_B());
                }
                inline D3DCOLOR get_ColorDX() const noexcept
                {
                        return cColorDX::GetARGB(get_A(), get_R(), get_G(), get_B());
                }
        };
 
        class cColor565
        {
        public:
                COLOR565_t m_color;
 
        public:
                static COLOR565_t inline Make(COLOR_ELEM_t r, COLOR_ELEM_t g, COLOR_ELEM_t b) noexcept
                {
                        return (b >> 3) | (((COLOR565_t)g & 0xfc) << 3) | (((COLOR565_t)r & 0xf8) << 8);
                }
 
                cColor565(COLOR565_t c = 0) noexcept
                        : m_color(c)
                {
                }
                cColor565(COLOR_ELEM_t _r, COLOR_ELEM_t _g, COLOR_ELEM_t _b) noexcept
                        : m_color(Make(_r, _g, _b))
                {
                }
 
                operator COLOR565_t () const noexcept
                {
                        return m_color;
                }
                inline COLOR_ELEM_t get_R() const noexcept
                {
                        return (COLOR_ELEM_t)((m_color & 0xf800) >> (11 - 3));
                }
                inline COLOR_ELEM_t get_G() const noexcept
                {
                        return (COLOR_ELEM_t)((m_color & 0x7e0) >> (5 - 2));
                }
                inline COLOR_ELEM_t get_B() const noexcept
                {
                        return (COLOR_ELEM_t)((m_color & 0x1f) << 3);
                }
 
                void put_ColorRef(COLORREF cVal) noexcept
                {
                        m_color = (COLOR565_t)((((cVal >> 3) & 0x1f) << 11) | (((cVal >> (8 + 2)) & 0x3f) << 5) | ((cVal >> (16 + 3)) & 0x1f));
                }
                inline COLORREF get_ColorRef() const noexcept
                {
                        return cColorRef::GetRGB(get_R(), get_G(), get_B());
                }
                inline D3DCOLOR get_ColorDX() const noexcept
                {
                        return cColorDX::GetXRGB(get_R(), get_G(), get_B());
                }
        };
 
#pragma pack()
 
        enum COLORREF_TYPE_
        {
#define ColorRefDEF(n,r,g,b) COLORREF_##n = RGB(r,g,b), // RGB cColorRef::GetRGB
#include "cColorRefs.tbl"
#undef ColorRefDEF
        };
 
        enum D3DCOLOR_TYPE_
        {
 
#define ColorRefDEF(n,r,g,b) D3DCOLOR_##n = D3DCOLOR_XRGB(r,g,b),       // D3DCOLOR_XRGB cColorDX::GetXRGB
#include "cColorRefs.tbl"
#undef ColorRefDEF
        };
 
        class GRAYLIB_LINK cColorConv
        {
 
        public:
                cColor888 m_cAlphaRef;          
                cColor555 m_cAlpha555;          
                cColor565 m_cAlpha565;          
 
        public:
                cColorConv() noexcept
                        : m_cAlphaRef(0)
                        , m_cAlpha555(0)
                        , m_cAlpha565(0)
                {
                }
 
                static void inline Conv_XRGB8888_RGB888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        // copy 3 bytes
                        pbDst[0] = pbSrc[0];
                        pbDst[1] = pbSrc[1];
                        pbDst[2] = pbSrc[2];
                }
                static void inline Conv_BGR888_RGB888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        // reverse 3 bytes
                        // same as Conv_RGB888_BGR888
                        pbDst[0] = pbSrc[2];    // b
                        pbDst[1] = pbSrc[1];    // g
                        pbDst[2] = pbSrc[0];    // r
                }
 
                static void inline Conv_ABGR8888_ARGB8888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        // same as Conv_ARGB8888_ABGR8888, Conv_XRGB8888_XBGR8888
                        Conv_BGR888_RGB888(pbSrc, pbDst);
                        pbDst[3] = pbSrc[3];    // a
                }
 
                static void inline Conv_BGR888_XBGR8888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        // same as Conv_RGB888_XRGB8888,
                        Conv_XRGB8888_RGB888(pbSrc, pbDst);
                        pbDst[3] = COLOR_ALPHA_OPAQUE;  // a
                }
                static void inline Conv_BGR888_XRGB8888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        // same as Conv_RGB888_XBGR8888
                        Conv_BGR888_RGB888(pbSrc, pbDst);
                        pbDst[3] = COLOR_ALPHA_OPAQUE;  // a
                }
 
                void inline Conv_RGB888_ARGB8888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        Conv_XRGB8888_RGB888(pbSrc, pbDst);
                        const bool isKey = (pbSrc[0] == m_cAlphaRef.b) && (pbSrc[1] == m_cAlphaRef.g) && (pbSrc[2] == m_cAlphaRef.r);
                        pbDst[3] = isKey ? COLOR_ALPHA_TRANSPARENT : COLOR_ALPHA_OPAQUE;
                }
                void inline Conv_BGR888_ABGR8888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        Conv_XRGB8888_RGB888(pbSrc, pbDst);
                        const bool isKey = (pbSrc[0] == m_cAlphaRef.r) && (pbSrc[1] == m_cAlphaRef.g) && (pbSrc[2] == m_cAlphaRef.b);
                        pbDst[3] = isKey ? COLOR_ALPHA_TRANSPARENT : COLOR_ALPHA_OPAQUE;
                }
 
                void inline Conv_BGR888_ARGB8888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        Conv_BGR888_RGB888(pbSrc, pbDst);
                        const bool isKey = (pbSrc[0] == m_cAlphaRef.r) && (pbSrc[1] == m_cAlphaRef.g) && (pbSrc[2] == m_cAlphaRef.b);
                        pbDst[3] = isKey ? COLOR_ALPHA_TRANSPARENT : COLOR_ALPHA_OPAQUE;
                }
                void inline Conv_RGB888_ABGR8888(const COLOR_ELEM_t* pbSrc, COLOR_ELEM_t* pbDst) noexcept
                {
                        // same as Conv_XRGB8888_ABGR8888
                        Conv_BGR888_RGB888(pbSrc, pbDst);
                        const bool isKey = (pbSrc[0] == m_cAlphaRef.b) && (pbSrc[1] == m_cAlphaRef.g) && (pbSrc[2] == m_cAlphaRef.r);
                        pbDst[3] = isKey ? COLOR_ALPHA_TRANSPARENT : COLOR_ALPHA_OPAQUE;
                }
 
                static COLOR565_t inline Conv_BGR888_RGB565(const COLOR_ELEM_t* pbSrc) noexcept
                {
                        return (((COLOR565_t)pbSrc[2]) >> 3) |          // b
                                (((COLOR565_t)pbSrc[1] & 0xfc) << 3) |  // g
                                (((COLOR565_t)pbSrc[0] & 0xf8) << 8);           // r
                }
                static COLOR565_t inline Conv_RGB888_RGB565(const COLOR_ELEM_t* pbSrc) noexcept
                {
                        return (((COLOR565_t)pbSrc[0]) >> 3) |          // r
                                (((COLOR565_t)pbSrc[1] & 0xfc) << 3) |  // g
                                (((COLOR565_t)pbSrc[2] & 0xf8) << 8);           // b
                }
 
                static COLOR555_t inline Conv_BGR888_RGB1555(const COLOR_ELEM_t* pbSrc, bool bOpaque) noexcept
                {
                        COLOR555_t wAlpha = bOpaque ? 0x8000 : 0;
                        return (((COLOR555_t)pbSrc[2]) >> 3) |
                                (((COLOR555_t)pbSrc[1] & 0xf8) << 2) |
                                (((COLOR555_t)pbSrc[0] & 0xf8) << 7) |
                                wAlpha;
                }
                static COLOR555_t inline Conv_RGB888_RGB1555(const COLOR_ELEM_t* pbSrc, bool bOpaque) noexcept
                {
                        COLOR555_t wAlpha = bOpaque ? 0x8000 : 0;
                        return (((COLOR555_t)pbSrc[0]) >> 3) |
                                (((COLOR555_t)pbSrc[1] & 0xf8) << 2) |
                                (((COLOR555_t)pbSrc[2] & 0xf8) << 7) |
                                wAlpha;
                }
 
                static void inline Conv_RGB565_BGR888(COLOR565_t c, COLOR_ELEM_t* pbDst) noexcept
                {
                        pbDst[0] = ((c >> 8) & 0xf8) | ((c >> 13) & 0x07);      // r
                        pbDst[1] = ((c >> 3) & 0xfc) | ((c >> 9) & 0x03);       // g
                        pbDst[2] = ((c << 3) & 0xf8) | ((c >> 2) & 0x07);       // b
                }
                static void inline Conv_RGB565_RGB888(COLOR565_t c, COLOR_ELEM_t* pbDst) noexcept
                {
                        pbDst[0] = ((c << 3) & 0xf8) | ((c >> 2) & 0x07);
                        pbDst[1] = ((c >> 3) & 0xfc) | ((c >> 9) & 0x03);
                        pbDst[2] = ((c >> 8) & 0xf8) | ((c >> 13) & 0x07);
                }
 
                static void inline Conv_RGB1555_BGR888(COLOR565_t c, COLOR_ELEM_t* pbDst) noexcept
                {
                        pbDst[0] = ((c >> 7) & 0xf8) | ((c >> 12) & 0x07);
                        pbDst[1] = ((c >> 2) & 0xf8) | ((c >> 7) & 0x07);
                        pbDst[2] = ((c << 3) & 0xf8) | ((c >> 2) & 0x07);
                }
                static void inline Conv_RGB1555_RGB888(COLOR565_t c, COLOR_ELEM_t* pbDst) noexcept
                {
                        pbDst[0] = ((c << 3) & 0xf8) | ((c >> 2) & 0x07);
                        pbDst[1] = ((c >> 2) & 0xf8) | ((c >> 7) & 0x07);
                        pbDst[2] = ((c >> 7) & 0xf8) | ((c >> 12) & 0x07);
                }
 
                static COLOR555_t inline Conv_RGB565_RGB1555(COLOR565_t c, bool bOpaque) noexcept
                {
                        COLOR555_t wAlpha = bOpaque ? 0x8000 : 0;
                        return ((c >> 1) & 0x7fe0) | (c & 0x1f) | wAlpha;
                }
        };
}
 
#endif // _INC_cColorRef_H