color.h

Go to the documentation of this file.

#pragma once
 
#include <adtf_base.h>
#include <adtfdisplaytoolboxgraphics/color_intf.h>
#include <adtfdisplaytoolboxgraphics/image_intf.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{

class cColor : public tColor, public IColor
{
public:
    cColor()
    {
        this->nRed = 0;
        this->nGreen = 0;
        this->nBlue = 0;
        this->nAlpha = 0;
    }

    cColor(const IColor* pColor)
    {
        this->nRed = pColor->GetRed();
        this->nGreen = pColor->GetGreen();
        this->nBlue = pColor->GetBlue();
        this->nAlpha = pColor->GetAlpha();
    }

    cColor(const tColor& oColor)
    {
        this->nRed = oColor.nRed;
        this->nGreen = oColor.nGreen;
        this->nBlue = oColor.nBlue;
        this->nAlpha = oColor.nAlpha;
    }

    cColor(tInt nRedLocal, tInt nGreenLocal, tInt nBlueLocal, tInt nAlphaLocal = 255)
    {
        this->nRed = (tUInt8) nRedLocal;
        this->nGreen = (tUInt8) nGreenLocal;
        this->nBlue = (tUInt8) nBlueLocal;
        this->nAlpha = (tUInt8) nAlphaLocal;
    }

    cColor(tUInt8 nRed, tUInt8 nGreen, tUInt8 nBlue, tUInt8 nAlpha = 255)
    {
        this->nRed = (tUInt8) nRed;
        this->nGreen = (tUInt8) nGreen;
        this->nBlue = (tUInt8) nBlue;
        this->nAlpha = (tUInt8) nAlpha;
    }

    cColor(tFloat32 fRed, tFloat32 fGreen, tFloat32 fBlue, tFloat32 fAlpha = 1.0f)
    {
        this->nRed = (tUInt8) (fRed * 255.0f);
        this->nGreen = (tUInt8) (fGreen * 255.0f);
        this->nBlue = (tUInt8) (fBlue * 255.0f);
        this->nAlpha = (tUInt8) (fAlpha * 255.0f);
    }

    cColor(tUInt32 nRGBA)
    {
        SetRGBA(nRGBA);
    }

    cColor(tUInt32 nRGBA, tInt oPixelFormat)
    {
        SetRGBA(nRGBA, oPixelFormat);
    }

    tVoid Release()
    {
        delete this;
    }

    tVoid Set(tInt nRedLocal, tInt nGreenLocal, tInt nBlueLocal, tInt nAlphaLocal = 255)
    {
        this->nRed = (tUInt8) nRedLocal;
        this->nGreen = (tUInt8) nGreenLocal;
        this->nBlue = (tUInt8) nBlueLocal;
        this->nAlpha = (tUInt8) nAlphaLocal;
    }

    tVoid Set(tUInt8 nRedLocal, tUInt8 nGreenLocal, tUInt8 nBlueLocal, tUInt8 nAlphaLocal = 255)
    {
        this->nRed = nRedLocal;
        this->nGreen = nGreenLocal;
        this->nBlue = nBlueLocal;
        this->nAlpha = nAlphaLocal;
    }

    tVoid Set(tFloat32 fRed, tFloat32 fGreen, tFloat32 fBlue, tFloat32 fAlpha = 1.0f)
    {
        this->nRed = (tUInt8) (fRed * 255.0f);
        this->nGreen = (tUInt8) (fGreen * 255.0f);
        this->nBlue = (tUInt8) (fBlue * 255.0f);
        this->nAlpha = (tUInt8) (fAlpha * 255.0f);
    }

    tVoid SetRGBA(tUInt32 nRGBA)
    {
        SetRGBA(nRGBA, IImage::PF_BGRA_8888);
    }

    tVoid SetRGBA(tUInt32 nRGBA, tInt oPixelFormat)
    {
        switch (oPixelFormat)
        {
            case IImage::PF_RGB_444:
                nBlue = (tUInt8) ((nRGBA & 0xf) << 4);
                nGreen = (tUInt8) (nRGBA & 0xf0);
                nRed = (tUInt8) ((nRGBA & 0xf00) >> 4);
                nAlpha = 0xff;
                break;
 
            case IImage::PF_RGBA_4444:
                nBlue = (tUInt8) ((nRGBA & 0xf) << 4);
                nGreen = (tUInt8) (nRGBA & 0xf0);
                nRed = (tUInt8) ((nRGBA & 0xf00) >> 4);
                nAlpha = (tUInt8) ((nRGBA & 0xf000) >> 8);
                break;
 
            case IImage::PF_RGB_555:
                nBlue = (tUInt8) ((nRGBA & 0x1f) << 3);
                nGreen = (tUInt8) ((nRGBA & 0x3e0) >> 2);
                nRed = (tUInt8) ((nRGBA & 0x7c00) >> 7);
                nAlpha = 0xff;
                break;
 
            case IImage::PF_RGB_565:
                nBlue = (tUInt8) ((nRGBA & 0x1f) << 3);
                nGreen = (tUInt8) ((nRGBA & 0x7e0) >> 3);
                nRed = (tUInt8) ((nRGBA & 0xf800) >> 8);
                nAlpha = 0xff;
                break;
 
            case IImage::PF_RGB_888:
                nBlue = ((tUInt8*) &nRGBA)[0];
                nGreen = ((tUInt8*) &nRGBA)[1];
                nRed = ((tUInt8*) &nRGBA)[2];
                nAlpha = 0xff;
                break;
 
            case IImage::PF_BGR_888:
                nBlue = ((tUInt8*) &nRGBA)[2];
                nGreen = ((tUInt8*) &nRGBA)[1];
                nRed = ((tUInt8*) &nRGBA)[0];
                nAlpha = 0xff;
                break;
 
            case IImage::PF_RGBA_8888:
                nBlue = ((tUInt8*) &nRGBA)[0];
                nGreen = ((tUInt8*) &nRGBA)[1];
                nRed = ((tUInt8*) &nRGBA)[2];
                nAlpha = ((tUInt8*) &nRGBA)[3];
                break;
 
            case IImage::PF_BGRA_8888:
                nBlue = ((tUInt8*) &nRGBA)[2];
                nGreen = ((tUInt8*) &nRGBA)[1];
                nRed = ((tUInt8*) &nRGBA)[0];
                nAlpha = ((tUInt8*) &nRGBA)[3];
                break;
 
            case IImage::PF_ARGB_8888:
                nBlue = ((tUInt8*) &nRGBA)[1];
                nGreen = ((tUInt8*) &nRGBA)[2];
                nRed = ((tUInt8*) &nRGBA)[3];
                nAlpha = ((tUInt8*) &nRGBA)[0];
                break;
 
            case IImage::PF_ABGR_8888:
                nBlue = ((tUInt8*) &nRGBA)[3];
                nGreen = ((tUInt8*) &nRGBA)[2];
                nRed = ((tUInt8*) &nRGBA)[1];
                nAlpha = ((tUInt8*) &nRGBA)[0];
                break;
        }
    }

    tUInt32 GetRGBA() const
    {
        return GetRGBA(IImage::PF_BGRA_8888);
    }

    tUInt32 GetRGBA(tInt oPixelFormat) const
    {
        tUInt32 nResult = 0;
        tUInt8* pResult = (tUInt8*) &nResult;
 
        switch (oPixelFormat)
        {
            case IImage::PF_RGB_444:
                nResult = tUInt32(nBlue >> 4) | tUInt32(nGreen & 0xf0) | tUInt32((nRed & 0xf0) << 4);
                break;
 
            case IImage::PF_RGBA_4444:
                nResult = tUInt32(nBlue >> 4) | tUInt32(nGreen & 0xf0) | tUInt32((nRed & 0xf0) << 4) |
                          tUInt32((nAlpha & 0xf0) << 8);
                break;
 
            case IImage::PF_RGB_555:
                nResult = tUInt32(nBlue >> 3) | tUInt32((nGreen & 0xf8) << 2) | tUInt32((nRed & 0xf8) << 7);
                break;
 
            case IImage::PF_RGB_565:
                nResult = tUInt32(nBlue >> 3) | tUInt32((nGreen & 0xfc) << 3) | tUInt32((nRed & 0xf8) << 8);
                break;
 
            case IImage::PF_RGB_888:
                pResult[0] = nBlue;
                pResult[1] = nGreen;
                pResult[2] = nRed;
                break;
 
            case IImage::PF_BGR_888:
                pResult[0] = nRed;
                pResult[1] = nGreen;
                pResult[2] = nBlue;
                break;
 
            case IImage::PF_RGBA_8888:
                pResult[0] = nBlue;
                pResult[1] = nGreen;
                pResult[2] = nRed;
                pResult[3] = nAlpha;
                break;
 
            case IImage::PF_BGRA_8888:
                pResult[0] = nRed;
                pResult[1] = nGreen;
                pResult[2] = nBlue;
                pResult[3] = nAlpha;
                break;
 
            case IImage::PF_ARGB_8888:
                pResult[0] = nAlpha;
                pResult[1] = nBlue;
                pResult[2] = nGreen;
                pResult[3] = nRed;
                break;
 
            case IImage::PF_ABGR_8888:
                pResult[0] = nAlpha;
                pResult[1] = nRed;
                pResult[2] = nGreen;
                pResult[3] = nBlue;
                break;
        }
 
        return nResult;
    }

    operator tUInt32()
    {
        return GetRGBA(IImage::PF_RGBA_8888);
    }

    tVoid SetRed(tUInt8 nRedValue)
    {
        this->nRed = nRedValue;
    }

    tUInt8 GetRed() const
    {
        return nRed;
    }

    tVoid SetGreen(tUInt8 nGreenValue)
    {
        this->nGreen = nGreenValue;
    }

    tUInt8 GetGreen() const
    {
        return nGreen;
    }

    tVoid SetBlue(tUInt8 nBlueValue)
    {
        this->nBlue = nBlueValue;
    }

    tUInt8 GetBlue() const
    {
        return nBlue;
    }

    tVoid SetAlpha(tUInt8 nAlphaValue)
    {
        this->nAlpha = nAlphaValue;
    }

    tUInt8 GetAlpha() const
    {
        return nAlpha;
    }

    tUInt8 GetBrightness() const
    {
        return (tUInt8) ((116 * nRed + 602 * nGreen + 306 * nBlue) >> 10);
    }
 
public:
    static cColor Scale(const cColor& c, tInt nAlpha)
    {
        return cColor(c.nRed * nAlpha / 255, c.nGreen * nAlpha / 255, c.nBlue * nAlpha / 255);
    }

    static cColor Scale(const cColor& c, tFloat32 fAlpha)
    {
        return cColor(c.nRed * fAlpha, c.nGreen * fAlpha, c.nBlue * fAlpha);
    }

    static cColor Blend(const cColor& c1, const cColor& c2, tInt nAlpha)
    {
        tUInt8 nInvAlpha = (tUInt8) (255 - nAlpha);
 
        return cColor((c1.nRed * nAlpha + c2.nRed * nInvAlpha) / 255,
                      (c1.nGreen * nAlpha + c2.nGreen * nInvAlpha) / 255,
                      (c1.nBlue * nAlpha + c2.nBlue * nInvAlpha) / 255);
    }

    static cColor Blend(const cColor& c1, const cColor& c2, tFloat32 fAlpha)
    {
        tUInt8 nAlpha = (tUInt8) (fAlpha * 255.0f);
        tUInt8 nInvAlpha = (tUInt8) (255 - nAlpha);
 
        return cColor((c1.nRed * nAlpha + c2.nRed * nInvAlpha) / 255,
                      (c1.nGreen * nAlpha + c2.nGreen * nInvAlpha) / 255,
                      (c1.nBlue * nAlpha + c2.nBlue * nInvAlpha) / 255);
    }

    static tResult ColorFromString(const tChar* strColor, cColor& oColor)
    {
        RETURN_IF_POINTER_NULL(strColor);
 
        if (strColor[0] != '#')
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        tInt r, g, b, a;
        r = g = b = 0;
        a = 255;
 
        for (tUInt nIdx = 1; nIdx < strlen(strColor); nIdx++)
        {
            tInt nVal = 0;
            tChar cChar = strColor[nIdx];
 
            switch (cChar)
            {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9': nVal = cChar - '0'; break;
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f': nVal = cChar - 'a' + 10; break;
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F': nVal = cChar - 'A' + 10; break;
                default: RETURN_ERROR(ERR_INVALID_ARG);
            }
 
            switch (nIdx)
            {
                case 1: r = nVal * 16; break;
                case 2: r = r + nVal; break;
                case 3: g = nVal * 16; break;
                case 4: g = g + nVal; break;
                case 5: b = nVal * 16; break;
                case 6: b = b + nVal; break;
                case 7: a = nVal * 16; break;
                case 8: a = a + nVal; break;
            }
        }
 
        oColor.Set(r, g, b, a);
        RETURN_NOERROR;
    }

    explicit operator IColor*()
    {
        return static_cast<IColor*>(this);
    }

    explicit operator const IColor*() const
    {
        return static_cast<const IColor*>(this);
    }
 
public:
    static const cColor Black; 
    static const cColor White; 
    static const cColor Red; 
    static const cColor Green; 
    static const cColor Blue; 
    static const cColor Yellow; 
    static const cColor Cyan; 
    static const cColor Purple; 
};
 
inline const cColor cColor::Black(0, 0, 0);
inline const cColor cColor::White(255, 255, 255);
inline const cColor cColor::Red(255, 0, 0);
inline const cColor cColor::Green(0, 255, 0);
inline const cColor cColor::Blue(0, 0, 255);
inline const cColor cColor::Yellow(255, 255, 0);
inline const cColor cColor::Cyan(0, 255, 255);
inline const cColor cColor::Purple(255, 0, 255);
 
} // namespace dengar
 
using dengar::cColor;
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf