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();
 
    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);
 
    tUInt32 GetRGBA() const
    {
        return GetRGBA(IImage::PF_BGRA_8888);
    }
 
    tUInt32 GetRGBA(tInt oPixelFormat) const;
 
    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);
 
    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; 
};
 
}
 
using dengar::cColor;
}
 
}
 
}