cSurfaceDC.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSurfaceDC_H
#define _INC_cSurfaceDC_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cSurfaceBase.h"
#include "../Geometry/cRectI.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSurfaceDC);
 
        enum SURF_FILTER_TYPE
        {
                SURF_FILTER_NONE,
                SURF_FILTER_LIGHT,              // just make darker.
                SURF_FILTER_HUE,                        // just add color.
                SURF_FILTER_HUE_AND_LIGHT,
                SURF_FILTER_HUE_CLOTH_AND_LIGHT,
                SURF_FILTER_HUE_CLOTH,
 
                SURF_FILTER_GREYSCALE,
                SURF_FILTER_TRANSPARENT,        // transparent.
                SURF_FILTER_SHADOW,
                SURF_FILTER_BLACK,
        };
 
        struct cSurfaceTextureVert      // pack ?
        {
                int m_u;        
                int m_v;        
                int m_x;        
                int m_y;        
        };
 
        typedef COLOR16_t HUE16_t;              
        typedef COLOR16_t(GRAYCALL* SURF_CvtHueToColor_t)(HUE16_t iHue, int iGamma);
 
        class GRAYLIB_LINK cSurfaceDC
        {
 
                typedef cSurfaceDC THIS_t;
 
        public: // protected:
                cSurfaceBase m_SurfDest;        
                cRectI m_rClipDest;             
 
                cColorRef m_ColorFore;  
                cColorRef m_ColorBack;  
 
        public:
                cSurfaceDC() noexcept;
                cSurfaceDC(COLOR16_t* pDataDest, PIXELS_t cx, PIXELS_t cy, size_t iPitchBytes);
                cSurfaceDC(cSurfaceBase* pSurfDest);
                cSurfaceDC(PIXELS_t x, PIXELS_t y);     // nullptr trap at x,y
                virtual ~cSurfaceDC();
 
                virtual void OnParamsChanged()
                {
                        // m_eFilterType or m_rClipDest has changed.
                }
 
                // clipping.
                inline bool IsInsideClipX(PIXELS_t x) const noexcept
                {
                        return m_rClipDest.IsInsideX(x);
                }
                inline bool IsInsideClipY(PIXELS_t y) const noexcept
                {
                        return m_rClipDest.IsInsideY(y);
                }
 
                void SetClipDestEmpty()
                {
                        m_rClipDest = cRectI(SHRT_MAX, SHRT_MAX, 0, 0);  //  SHRT_MAX
                        OnParamsChanged();
                }
                void SetClipDestAll()
                {
                        m_rClipDest = cRectI(0, 0, m_SurfDest.get_Width(), m_SurfDest.get_Height());
                        OnParamsChanged();
                }
                void SetClipDest(const cRectI& rect);
 
                virtual void DrawEraseClip();
                virtual void DrawBlt(PIXELS_t x, PIXELS_t y, cSurfaceBase* pSrc, const cRectI& srcRect, DWORD rop);
 
                // DrawXLine
                // DrawLine
 
#ifdef _WIN32 
                int FlipToDC(HDC hDC, PIXELS_t XDest, PIXELS_t YDest) const
                {
                        return m_SurfDest.FlipToDC(hDC, XDest, YDest);
                }
#endif
 
                UNITTEST_FRIEND(cSurfaceDC);
        };
 
        class GRAYLIB_LINK cSurfaceDC2 : public cSurfaceDC
        {
 
                typedef cSurfaceDC2 THIS_t;
 
        public: // protected:
 
                cRectI m_rClipSrc;              
                SURF_FILTER_TYPE m_eFilterType; 
                HUE16_t m_wHueColor;    
                signed char m_nGreyScaleCount;
                COLOR_ELEM_t m_Light;                   
                bool m_bClothGrey;              
                bool m_b565Color;
 
        private:
                void DrawXLineTexture(PIXELS_t xstart, PIXELS_t xend, COLOR16_t* pDstLine, int u, int v, int du, int dv, const COLOR16_t* pSrc, int iWidth);
                bool DrawTextureTriangle(const COLOR16_t* pSrc, int iWidth, const cSurfaceTextureVert Vert[3]);
 
        protected:
                void InitFilter();
 
        public:
                cSurfaceDC2();
                cSurfaceDC2(COLOR16_t* pDataDest, PIXELS_t cx, PIXELS_t cy, size_t iPitchBytes);
                cSurfaceDC2(cSurfaceBase* pSurfDest);
                cSurfaceDC2(PIXELS_t x, PIXELS_t y);    // nullptr trap will throw.
                ~cSurfaceDC2();
 
                static COLOR16_t GRAYCALL CvtHueToColor_Stub(HUE16_t iHue, WORD iGamma) noexcept
                {
                        UNREFERENCED_PARAMETER(iGamma);
                        return iHue;
                }
 
                THIS_t& operator = (const THIS_t& SurfDC)
                {
                        CopyBase(SurfDC);
                        return *this;
                }
 
                // Filtered drawing/copying routines.  
                void DrawXLine(COLOR16_t* pDst, const COLOR16_t* pSrc, int iWidth);
                void DrawXLine(PIXELS_t x, PIXELS_t y, const COLOR16_t* pSrc, int iWidth);
 
                void DrawXClip(PIXELS_t x, COLOR16_t* pDstLine, const COLOR16_t* pSrc, int iWidth = 1);
                void DrawXYClip(PIXELS_t x, PIXELS_t y, const COLOR16_t* pSrc, int iWidth);
 
                bool DrawSurf(PIXELS_t x, PIXELS_t y, const cSurfaceBase& SrcSurf, PIXELS_t iWidth, PIXELS_t iHeight);
                bool DrawSurf(PIXELS_t x, PIXELS_t y, const cSurfaceBase& SrcSurf);
 
                bool DrawTexture(const cSurfaceBase& SrcSurf,   
                        int x1, int y1,
                        int x2, int y2,
                        int x3, int y3,
                        int x4, int y4);
 
                void CopyBase(const THIS_t& SurfDC);
 
                void DrawColorSpaceToRGB565();
                bool SetClipSrc(PIXELS_t x, PIXELS_t y, PIXELS_t iWidth, PIXELS_t iHeight);
 
                // filtering.
                HUE16_t GetFilterHue() const noexcept
                {
                        return m_wHueColor;
                }
                SURF_FILTER_TYPE get_Filter() const noexcept
                {
                        return m_eFilterType;
                }
                COLOR_ELEM_t get_FilterLight() const noexcept
                {
                        return m_Light;
                }
 
                void UpdateFilters();
                void put_Filter(SURF_FILTER_TYPE filter)
                {
                        m_eFilterType = filter;
                        OnParamsChanged();
                }
                void put_FilterLight(COLOR_ELEM_t lightlevel = 0);
                void SetFilterHue(HUE16_t wHue = 0);    // HUE_DEFAULT
 
                void SetFilter565Color(bool b565Color);
                void SetFilterCloth(bool bClothGray);
                void SetFilterGrayCount(signed char iVal);
        };
}
#endif // cSurfaceDC