GfxWrap.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef GFXWRAP__H_
#define GFXWRAP__H_
 
#include "GUIComponentManager.h"
 
#include "GUIRect.h"
#include "eC_Math.h"
 
#include "GUIFontResource.h"
#include "GUIImageResource.h"
 
#include "GUIImageData.h"
#include "GUICommonEnums.h"
 
#include "GUIText.h"
#include "GUITrace.h"
#include "GUIImageCache.h"
#include "GUIObject.h"
#include "GUINinePatch.h"
#include "GUIPerfMon.h"
 
#include "GUILayerConfig.h"
 
#include "FntWrap.h"
 
#define GETGFX CGUIComponentManager::GetInstance().GetGfxWrap()
#define GETFNT CGUIComponentManager::GetInstance().GetFntWrap()
 
//#define GETGFX CGfxWrap::GetInstance()
 
class CGUIBitmapPlane;
class CGfxEnv;
 
inline static eC_UInt UINT_FROM_RGB(const eC_UByte& R, const eC_UByte& G, const eC_UByte& B);
inline static eC_UInt UINT_FROM_ARGB(const eC_UByte& A, const eC_UByte& R, const eC_UByte& G, const eC_UByte& B);
inline static eC_UByte GET_A_VAL32(const eC_UInt& argb);
inline static eC_UByte GET_R_VAL32(const eC_UInt& argb);
inline static eC_UByte GET_G_VAL32(const eC_UInt& argb);
inline static eC_UByte GET_B_VAL32(const eC_UInt& argb);
 
 
class CGfxWrap
{
    friend class CGUIResourceManager; 
    friend class CGUIBackgroundImageLoaderThread; 
    friend class CGUIImageCacheImpl; 
    friend class CFntWrap; 
    friend class CGUI; 
    friend class CGUIComponentManager; 
 
public:
    static void DeleteInstance();
 
    // ---------------------------------------------------------------
    //  General functionality
    // ---------------------------------------------------------------
 
    enum RefreshCall_t
    {
        SINGLE_REFRESH,         
        FIRST_REFRESH_OF_FRAME, 
        INTERMEDIATE_REFRESH,   
        LAST_REFRESH_OF_FRAME,  
        FORCED_REFRESH          
    };
 
    inline void ForceRefresh() { m_bForceRefresh = true; }
 
    virtual eC_UInt GetVirtualScreenWidth() = 0;
 
    virtual eC_UInt GetVirtualScreenHeight() = 0;
 
    virtual void SetScreenSize(
        const eC_UInt &uiWidth,
        const eC_UInt &uiHeight);
 
    virtual eC_UInt GetPhysicalScreenWidth() = 0;
 
    virtual eC_UInt GetPhysicalScreenHeight() = 0;
 
    virtual eC_UInt GetScreenVerticalPPI() const { return (72); }
 
    virtual eC_UInt GetScreenHorizontalPPI() const { return (72); }
 
    CGUICommonEnums::ImageType_t GetScreenFormat() const { return m_eScreenFormat; }
 
    void SetScreenFormat(const CGUICommonEnums::ImageType_t& uiScreenFormat) { m_eScreenFormat = uiScreenFormat; }
 
    virtual void StoreWrapperState() {}
 
    virtual void RestoreWrapperState() {}
 
    // ---------------------------------------------------------------
    // Drawing functions
    // ---------------------------------------------------------------
 
 
    void SetForegroundColor(
        const eC_UByte &ubRed,
        const eC_UByte &ubGreen,
        const eC_UByte &ubBlue,
        const eC_UByte &ubAlpha = 255)
    {
        SetForegroundColorImpl(ubRed, ubGreen, ubBlue, ApplyGlobalAlpha(ubAlpha));
    }
 
    void SetForegroundColor(const eC_UInt &uiCol)
    {
        // The value of alpha is multiplied by the scaling factor (in the event of widgets with text, the text's alpha has to be scaled)
        SetForegroundColorImpl(
            GET_R_VAL32(uiCol),
            GET_G_VAL32(uiCol),
            GET_B_VAL32(uiCol),
            ApplyGlobalAlpha(GET_A_VAL32(uiCol)));
    }
 
    void UpdateGlobalAlpha(const eC_UByte &ubAlpha)
    {
        m_ubAlpha = ApplyGlobalAlpha(ubAlpha);
        m_vGlobalAlphaFactor = eC_Div(eC_FromInt(m_ubAlpha), eC_FromFloat(255.0f));
    }
 
    void SetGlobalAlpha(const eC_UByte &ubAlpha)
    {
        m_ubAlpha = ubAlpha;
        m_vGlobalAlphaFactor = eC_Div(eC_FromInt(m_ubAlpha), eC_FromFloat(255.0f));
    }
 
    virtual eC_Value SetLineWidth(const eC_Value& vWidth);
 
    inline eC_UInt GetForegroundColor() const { return m_uiColor; }
 
    inline eC_UByte GetGlobalAlpha() const { return m_ubAlpha; }
 
    inline eC_UByte ApplyGlobalAlpha(const eC_UByte ubAlpha) const { return static_cast<eC_UByte>(eC_ToInt(eC_Mul(eC_FromInt(ubAlpha), m_vGlobalAlphaFactor))); }
 
 
 
    void Line(const CGUIRect& kAbsRect);
 
    void Rect(const CGUIRect& kAbsRect);
 
    void FilledRect(const CGUIRect& kAbsRect);
 
    void Ellipse(const CGUIRect& kAbsRect, const eC_Bool &bFilled);
 
    void Arc(
        const CGUIRect& kAbsRect,
        const eC_Value& vStartAngle,
        const eC_Value& vEndAngle,
        const eC_Value& vRotationAngle,
        const eC_Bool &bFilled);
 
    void Ring(
        const CGUIRect& kAbsRect,
        const eC_Value& vRingWidth,
        const eC_Value& vStartAngle,
        const eC_Value& vEndAngle,
        const eC_Value& vRotationAngle,
        const eC_Bool &bFilled);
 
    void Text(
        const eC_Value& vAbsX1, const eC_Value& vAbsY1,
        const eC_String * const lpString);
 
    void SetGfxEnv(CGfxEnv* pkGfxEnv);
 
    // ---------------------------------------------------------------
    // Clipping and invalidated rectangles
    // ---------------------------------------------------------------
 
 
    virtual void RedrawGUI();
 
    virtual void SetCliprect(const CGUIRect &NewAbsClipRect) = 0;
 
    virtual void ResetCliprect();
 
    virtual void GetCliprect(CGUIRect &AbsClipRect) const;
 
    void InvalidateRect(const CGUIRect &kInvalidRect);
 
    void InvalidateRect(
        const eC_Value& vAbsX1, const eC_Value& vAbsY1,
        const eC_Value& vAbsX2, const eC_Value& vAbsY2)
    {
        InvalidateRect(CGUIRect(vAbsX1, vAbsY1, vAbsX2, vAbsY2));
    }
 
    inline const CGUIRect& GetInvalidatedRect() const
    {
        return m_kInvalidatedRect;
    }
 
    virtual void ClearInvalidRect() {}
 
    // ---------------------------------------------------------------
    // Image-access
    // ---------------------------------------------------------------
    void BlitImg(
        const ImageResource_t &eID,
        const eC_Value& vAbsDestX,
        const eC_Value& vAbsDestY);
 
    void BlitImg(
        const CGUIImageData& kImageData,
        const eC_Value& vAbsDestX,
        const eC_Value& vAbsDestY)
    {
        BlitImgExtImpl(kImageData, vAbsDestX, vAbsDestY);
    }
 
    void BlitImgExt(
        const ImageResource_t &eID,
        const eC_Value& vAbsDestX,
        const eC_Value& vAbsDestY,
        const eC_Value& vWidth,
        const eC_Value& vHeight,
        const eC_Bool &bStretch = true,
        const eC_UByte &ubAlpha = 255);
 
    virtual void BlitImgNinePatch(
        const ImageResource_t &eID,
        const CGUIRect& kAbsRect,
        const eC_UInt uiTopBorder,
        const eC_UInt uiBottomBorder,
        const eC_UInt uiLeftBorder,
        const eC_UInt uiRightBorder,
        const eC_UByte &ubAlpha = 255);
 
    void BlitImgNinePatch(
        const ImageResource_t &eID,
        const CGUIRect& kAbsRect,
        const CGUINinePatch& kNinePatch,
        const eC_UByte &ubAlpha = 255);
 
    void BlitImgExt(
        const ImageResource_t &eID,
        const CGUIRect& kAbsRect,
        const eC_Bool &bStretch = true,
        const eC_UByte &ubAlpha = 255);
 
    void BlitImgExt(
        const ImageResource_t &eID,
        const CGUIRect& kSrcAbsRect,
        const CGUIRect& kDstAbsRect,
        const eC_UByte &ubAlpha = 255);
 
    void BlitImgExt(
        const ImageResource_t &eID,
        const eC_UInt &uiAbsSrcX, const eC_UInt &uiAbsSrcY,
        const eC_UInt &uiSrcWidth, const eC_UInt &uiSrcHeight,
        const eC_Value& vAbsDestX, const eC_Value& vAbsDestY,
        const eC_Value& vDestWidth, const eC_Value& vDestHeight,
        const eC_UByte &ubAlpha = 255,
        const eC_Value& vAngle = eC_FromFloat(0),
        const eC_Value& vRotCenterX = eC_FromFloat(0.5),
        const eC_Value& vRotCenterY = eC_FromFloat(0.5));
 
    eC_UInt GetImgWidth(const ImageResource_t &eID) const;
 
    eC_UInt GetImgHeight(const ImageResource_t &eID) const;
 
    inline CGUIRect GetImgOriginRect(const ImageResource_t &eID) const
    {
        return CGUIRect(eC_FromInt(0), eC_FromInt(0), eC_FromInt(GetImgWidth(eID)), eC_FromInt(GetImgHeight(eID)));
    }
 
 
    // ---------------------------------------------------------------
    // BitmapPlane-Access
    // ---------------------------------------------------------------
 
    virtual eC_Bool DrawToBitmap(GUIBitmapPlaneID_t uiBitmapID);
 
    virtual eC_Bool DrawToScreen();
 
    virtual eC_TArray<eC_UByte>* GetBitmapPlaneData(const GUIBitmapPlaneID_t& eBitmapPlaneID);
 
    virtual void SetTargetLayer(const eC_UInt& uiLayerID) {}
 
    virtual void SetRenderingOffset(const eC_Value& vOffsetX, const eC_Value& vOffsetY);
 
    void GetRenderingOffset(eC_Value& vOffsetX, eC_Value& vOffsetY);
 
#if USE_ZOOM
    void SetZoom(const eC_Value& vZoomFactor, const CGUIRect& kZoomRect)
    {
        m_vZoomFactor = vZoomFactor;
        m_kZoomArea = kZoomRect;
        m_bZoomActive = true;
    }
 
    void GetZoom(eC_Value& vZoomFactor, CGUIRect& kZoomRect) const
    {
        vZoomFactor = m_vZoomFactor;
        kZoomRect = m_kZoomArea;
    }
 
    void ResetZoom()
    {
        m_vZoomFactor = eC_FromInt(1);
        m_bZoomActive = false;
    }
 
    eC_Bool IsZoomActive() const
    {
        return m_bZoomActive;
    }
#endif
 
    virtual GUIBitmapPlaneID_t CreateBitmapPlane(
        const CGUIObject& rkParentObject,
        const eC_Value& vWidth,
        const eC_Value& vHeight);
 
    void DeleteBitmapPlane(const GUIBitmapPlaneID_t uiBitmapID);
 
    void DeleteBitmapPlanes(const CGUIObject* pkObject);
 
    CGUIBitmapPlane& GetBitmapPlane(const GUIBitmapPlaneID_t uiBitmapID);
 
    inline GUIBitmapPlaneID_t GetUsedBitmapPlaneID() const { return m_uiUsedRenderBitmapID; }
 
 
    // ---------------------------------------------------------------
    // Font-access
    // ---------------------------------------------------------------
 
    void SetFont(const FontResource_t &eID);
 
    void SetFontSpacing(const eC_Float &fSpacing);
 
    void RequiredSpace(const eC_String * const pkText, eC_Value& vWidth, eC_Value& vHeight);
 
    void FittingNumChars(
        const eC_String* const pkText,
        eC_Value vWidthMax,
        eC_UInt &uiNumChars,
        const eC_Bool& bStartAtEnd = false);
 
    eC_Int GetAscender() const;
 
    eC_Int GetDescender() const;
 
    eC_Int GetInternalLeading() const;
 
    void GetGlyphMetrics(const eC_Char cChar, CFntWrap::GlyphMetrics_t& kMetrics);
 
    eC_Value GetTextXPosAdjustment(const CGUIText::HorAligned_t eHorAlignment);
 
    eC_Value GetTextYPosAdjustment(const CGUIText::VerAligned_t eVerAlignment);
 
    eC_Bool SetNOFFonts(const eC_UInt uiNOFFonts);
 
    eC_UInt GetNOFFonts();
 
    void ChangeFont(
        const FontResource_t &eFontID,
        const eC_Char* const pcPath,
        const eC_UInt &uiFontSize,
        const CFntWrap::GUIFont_t &eFontStyle);
 
    void LoadFont(const FontResource_t &eFontID);
 
    void UnloadFont(const FontResource_t &eFontID);
 
    virtual eC_Bool SupportCompressedFonts() const { return false; }
 
    virtual void LoadGlyphData(
        CGUIImageData* pkImageData,
        const eC_UInt& uiGlyphWidth,
        const eC_UInt& uiGlyphHeight,
        eC_UByte* pkGlyphBitmap);
 
    virtual void UnloadGlyphData(CGUIImageData* pkImageData);
 
 
    inline virtual eC_UInt GetNOFImages() { return m_uiNOFImages; }
 
    virtual eC_Bool ImageExists(const ImageResource_t eID) const = 0;
 
    inline static eC_UInt GetNextPowerOf2(const eC_Value& vValue)
    {
#if defined NON_POWER_OF_2_TEXTURES
        return eC_ToInt(eC_Ceil(vValue));
#else
        eC_UInt uiPOW = eC_ToInt(vValue);
        --uiPOW;
        uiPOW |= uiPOW >> 16;
        uiPOW |= uiPOW >> 8;
        uiPOW |= uiPOW >> 4;
        uiPOW |= uiPOW >> 2;
        uiPOW |= uiPOW >> 1;
        ++uiPOW;
        return uiPOW;
#endif
    }
 
    inline void SetDoubleBufferingEnforcesFlipping(const eC_Bool bDoubleBufferingEnforcesFlipping)
    {
        m_bDoubleBufferingEnforcesFlipping = bDoubleBufferingEnforcesFlipping;
    }
 
    inline eC_Bool GetDoubleBufferingEnforcesFlipping()
    {
        return m_bDoubleBufferingEnforcesFlipping;
    }
 
#if defined _DEBUG
 
    inline void EnableDebugOutput()
    {
        m_bDebugOutput = true;
    }
 
    inline void DisableDebugOutput()
    {
        m_bDebugOutput = false;
    }
#endif
 
    inline eC_String GetWrapperName() const
    {
        return m_kWrapperName;
    }
 
    virtual void SetOptimizedBlit(const eC_Bool& bOptimizedBlit)
    {
        m_bOptimizedBlit = bOptimizedBlit;
    }
 
    virtual void SetFilteredBlit(const eC_Bool& bFilteredBlit)
    {
        m_bFilteredBlit = bFilteredBlit;
    }
 
    virtual void SetWindowCaption(const eC_String& kText);
 
    virtual eC_UByte* GetWorkingMemory(const eC_UInt& uiSize);
 
    virtual void ReleaseWorkingMemory(eC_UByte* pkMemory);
 
    virtual void SyncWorkingMemory();
 
    virtual void ResetWorkingMemory();
 
protected:
    CGfxWrap();
 
    virtual ~CGfxWrap(void);
 
    void DeInit();
 
 
    virtual void Line(
        const eC_Value& vAbsX1,
        const eC_Value& vAbsY1,
        const eC_Value& vAbsX2,
        const eC_Value& vAbsY2) = 0;
 
    virtual void Rect(
        const eC_Value& vAbsX1, const eC_Value& vAbsY1,
        const eC_Value& vAbsX2, const eC_Value& vAbsY2) = 0;
 
    virtual void FilledRect(
        const eC_Value& vAbsX1,
        const eC_Value& vAbsY1,
        const eC_Value& vAbsX2,
        const eC_Value& vAbsY2) = 0;
 
    virtual void Ellipse(
        const eC_Value& vAbsX1,
        const eC_Value& vAbsY1,
        const eC_Value& vAbsX2,
        const eC_Value& vAbsY2,
        const eC_Bool &bFilled) = 0;
 
    virtual void Arc(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2,
        const eC_Value& vStartAngle,
        const eC_Value& vEndAngle,
        const eC_Value& vRotationAngle,
        const eC_Bool &bFilled) = 0;
 
    virtual void Ring(
        const eC_Value& vX1,
        const eC_Value& vY1,
        const eC_Value& vX2,
        const eC_Value& vY2,
        const eC_Value& vRingWidth,
        const eC_Value& vStartAngle,
        const eC_Value& vEndAngle,
        const eC_Value& vRotationAngle,
        const eC_Bool & bFilled) = 0;
 
 
    virtual eC_Bool Refresh(const RefreshCall_t eRefreshCallType) = 0;
 
    virtual void StartHandleDraw(const CGUIRect &crkClipRect);
 
 
    virtual void StartRedrawGUI() {}
 
    virtual void EndRedrawGUI() {}
 
    virtual void DestroyScreen() {}
 
 
    eC_Bool SetNOFImages(const eC_UInt uiNOFImages)
    {
        m_kGfxWrapSemaphore.Enter();
        eC_Bool bRet = SetNOFImagesImpl(uiNOFImages);
        m_kGfxWrapSemaphore.Leave();
        return bRet;
    }
 
    virtual eC_Bool SetNOFImagesImpl(const eC_UInt uiNOFImages);
 
    void LoadImg(
        const eC_String& kPath,
        const ImageResource_t &eID);
 
    void LoadImg(
        void* pkMemory,
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const eC_UInt& eImageType,
        const ImageResource_t &eID);
 
    virtual void LoadImgImpl(
        const eC_String& kPath,
        const ImageResource_t &eID) = 0;
 
    virtual void LoadImgImpl(
        void* pkMemory,
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const eC_UInt& eImageType,
        const ImageResource_t &eID) = 0;
 
    virtual void RefreshImage(const ImageResource_t& eID, void* pkMemory) {}
 
    virtual void UnloadImg(const ImageResource_t &eID) {}
 
 
 
    virtual eC_UInt GetImageSize(const ImageResource_t& eID) const = 0;
 
    virtual eC_UInt GetImgWidthImpl(const ImageResource_t &eID) const = 0;
 
    virtual eC_UInt GetImgHeightImpl(const ImageResource_t &eID) const = 0;
 
    virtual void BlitImgExtImpl(
        const ImageResource_t &eID,
        const eC_UInt &uiAbsSrcX, const eC_UInt &uiAbsSrcY,
        const eC_UInt &uiSrcWidth, const eC_UInt &uiSrcHeight,
        const eC_Value& vAbsDestX, const eC_Value& vAbsDestY,
        const eC_Value& vDestWidth, const eC_Value& vDestHeight,
        const eC_UByte &ubAlpha = 255,
        const eC_Value& vAngle = eC_FromFloat(0),
        const eC_Value& vRotCenterX = eC_FromFloat(0.5), const eC_Value& vRotCenterY = eC_FromFloat(0.5)) = 0;
 
    virtual void BlitImgExtImpl(const CGUIImageData& kImageData, const eC_Value& vAbsDestX, const eC_Value& vAbsDestY) = 0;
 
    virtual void SetForegroundColorImpl(
        const eC_UByte &ubRed,
        const eC_UByte &ubGreen,
        const eC_UByte &ubBlue,
        const eC_UByte &ubAlpha = 255) = 0;
 
 
    void SetInvalidatedRect(const eC_Value& vAbsX1, const eC_Value& vAbsY1, const eC_Value& vAbsX2, const eC_Value& vAbsY2);
 
    void SetInvalidatedRect(const CGUIRect &NewAbsRect)
    {
        SetInvalidatedRect(NewAbsRect.GetX1(), NewAbsRect.GetY1(), NewAbsRect.GetX2(), NewAbsRect.GetY2());
    }
 
    void ResetInvalidatedRect();
 
    // ---------------------------------------------------------------
    // Bitmap-Access
    // ---------------------------------------------------------------
 
    virtual CGUIBitmapPlane* CreateGfxDependentBitmap(
        GUIBitmapPlaneID_t uiNewBitmapID,
        const CGUIObject& rkParentObject,
        const eC_Value& vWidth, const eC_Value& vHeight);
 
    CGUIBitmapPlane& GetDummyBitmap();
 
    virtual eC_Bool FinishDrawToBitmap();
 
protected:
    eC_UInt m_uiScreenWidth;
 
    eC_UInt m_uiScreenHeight;
 
    eC_TListDoubleLinked<CGUIRect> m_kInvalidatedRectList;
 
    eC_TListDoubleLinked <CGUIRect> m_kLastFrameInvalidatedRectList;
 
    eC_Bool m_bDoubleBufferingEnforcesFlipping;
 
    CGUIRect m_kInvalidatedRect;
 
    CGUIRect m_kClippingRect;
 
    eC_Value m_vLineWidth;
 
    CGfxEnv* m_pkGfxEnv;
 
    eC_UInt m_uiNOFImages;
 
    eC_UInt m_uiColor;
 
    eC_UByte m_ubAlpha;
 
    eC_Value m_vGlobalAlphaFactor;
    eC_Bool m_bInvalidationInLastFrame;
 
    eC_Semaphore m_kGfxWrapSemaphore;
 
    eC_Value m_vRenderingOffsetX;
    eC_Value m_vRenderingOffsetY;
 
    eC_String m_kWrapperName;
 
    eC_Bool m_bOptimizedBlit;
 
    eC_Bool m_bFilteredBlit;
 
    static const eC_Value cvTwoPi;
 
#ifdef USE_ZOOM
    eC_Bool m_bZoomActive;
    eC_Value m_vZoomFactor;
    CGUIRect m_kZoomArea;
#endif
 
#ifdef _DEBUG
    //These two attributes are compared to asssure that the number redraws and refreshes are equal which is important on some wrappers.
    eC_UInt m_uiRedrawGUICounter;
    eC_UInt m_uiRefreshGUICounter;
#endif
 
private:
    GUIBitmapPlaneID_t GetFreeBitmapID();
 
    void ResetInvalidation();
 
    CGfxWrap(const CGfxWrap& kSource);
 
    CGfxWrap& operator=(const CGfxWrap& kSource);
 
private:
    eC_Bool m_bForceRefresh;
 
    CGUICommonEnums::ImageType_t m_eScreenFormat;
 
    CGUIBitmapPlane* m_pkDummyBitmap;
 
    CGUIObject* m_pkDummyGUIObject;
 
    eC_TArray<CGUIBitmapPlane*> m_apBitmaps;
 
    CGUIRect m_kRealInvalidatedRect;
    CGUIRect m_kRealClipRect;
 
    GUIBitmapPlaneID_t m_uiUsedRenderBitmapID;
 
    eC_Bool m_bCurrentlyRedrawing;
 
#ifdef _DEBUG
    eC_Bool m_bDebugOutput;
#endif
 
    static eC_Bool ms_bWatermark;
};
 
// Return an unsigned int value from RGB (Red, Green, Blue) color value. R, G and B are expected to be bytes.
inline static eC_UInt UINT_FROM_RGB(const eC_UByte& R, const eC_UByte& G, const eC_UByte& B)
{
    return (static_cast<eC_UInt>(B)) | ((static_cast<eC_UInt>(G)) << 8) | ((static_cast<eC_UInt>(R)) << 16);
}
 
// Return an unsigned int value from ARGB (Alpha, Red, Green, Blue) color value. A, R, G and B are expected to be bytes.
inline static eC_UInt UINT_FROM_ARGB(const eC_UByte& A, const eC_UByte& R, const eC_UByte& G, const eC_UByte& B)
{
    return (static_cast<eC_UInt>(B)) | ((static_cast<eC_UInt>(G)) << 8) | ((static_cast<eC_UInt>(R)) << 16) | ((static_cast<eC_UInt>(A)) << 24);
}
 
inline static eC_UByte GET_A_VAL32(const eC_UInt& argb)
{
    return static_cast<eC_UByte>((argb >> 24) & 0xFF);
}
inline static eC_UByte GET_R_VAL32(const eC_UInt& argb)
{
    return static_cast<eC_UByte>((argb >> 16) & 0xFF);
}
 
inline static eC_UByte GET_G_VAL32(const eC_UInt& argb)
{
    return static_cast<eC_UByte>((argb >> 8) & 0xFF);
}
 
inline static eC_UByte GET_B_VAL32(const eC_UInt& argb)
{
    return static_cast<eC_UByte>(argb & 0xFF);
}
#endif