cSurfaceBase.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSurfaceBase_H
#define _INC_cSurfaceBase_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cSurfaceInfo.h"
#include "cColorRef.h"
#include "../WinAPI/WinTypes.h" // COLORREF
#include "GrayCore/include/PtrCast.h"
#include "GrayCore/include/HResult.h"
#include "GrayCore/include/cObject.h"
#include "GrayCore/include/FileName.h"
#include "GrayCore/include/cStream.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSurfaceBase);
 
        class GRAYLIB_LINK cSurfaceBase : protected cMemBlock
        {
 
                friend class cSurfaceDC;
                friend class cSurfaceDC2;
 
        protected:
                cSurfaceInfo m_Info;    
 
        protected:
                cSurfaceBase& operator = (const cSurfaceBase& rSurf)
                {
                        SetPixelData(rSurf);
                        return *this;
                }
 
                bool InitSurfaceInfo(const cSurfaceInfo& rInfo);
                bool InitSurfaceAlign(PIXELS_t cx, PIXELS_t cy, size_t nAlignBytes, SURF_FORM_TYPE ePixelFormat);
                bool InitSurfacePitch(PIXELS_t cx, PIXELS_t cy, size_t uPitchBytes, SURF_FORM_TYPE ePixelFormat);
 
        public:
                cSurfaceBase() noexcept;
                cSurfaceBase(void* pPixelData, const cSurfaceInfo& rInfo);
                cSurfaceBase(void* pPixelData, PIXELS_t cx, PIXELS_t cy, size_t uPitchBytes, SURF_FORM_TYPE ePixelFormat);
                virtual ~cSurfaceBase();
 
                HRESULT SaveRaw(cStreamOutput& file);
                HRESULT SaveRaw(const FILECHAR_t* pszFilename);
 
                virtual void SetEmpty();
 
                bool isValidCheck() const noexcept      // memory allocation and structure definitions are valid.
                {
                        if (!IS_TYPE_OF(cSurfaceBase, this))    // structure definitions are valid..
                                return false;
                        return true;
                }
 
                // Access cSurfaceInfo m_Info
                const cSurfaceInfo& get_Info() const noexcept
                {
                        return m_Info;
                }
                void put_Info(const cSurfaceInfo& rInfo)
                {
                        InitSurfaceInfo(rInfo);
                }
 
                size_t get_PitchBytes() const noexcept
                {
                        return m_Info.get_PitchBytes();
                }
                PIXELS_t get_Width() const noexcept
                {
                        return m_Info.get_Width();
                }
                PIXELS_t get_Height() const noexcept
                {
                        return m_Info.get_Height();
                }
                bool isTopDown() const noexcept
                {
                        return m_Info.isTopDown();
                }
                SURF_FORM_TYPE get_PixelFormat() const noexcept
                {
                        return m_Info.get_PixelFormat();
                }
 
                bool isValidPixelData() const noexcept
                {
                        return isValidPtr();
                }
                void* get_PixelData() const noexcept
                {
                        return get_Data();
                }
                BYTE* get_PixelBytes() const noexcept
                {
                        return get_DataBytes();
                }
 
                void put_PixelData(void* pPixelData) noexcept
                {
                        this->SetBlock(pPixelData, m_Info.get_SurfaceSize());
                }
 
                void* GetLinePtrRaw(PIXELS_t y) const noexcept
                {
                        return get_PixelBytes() + (m_Info.get_PitchBytes() * y);
                }
                BYTE* GetLinePtrByte(PIXELS_t y) const noexcept
                {
                        return (BYTE*)GetLinePtrRaw(y);
                }
                void* GetLinePtr(PIXELS_t y) const noexcept
                {
                        DEBUG_CHECK(get_PixelData() != nullptr);
                        int cy = m_Info.get_HeightRaw();
                        if (cy < 0)     // ! m_Info.isTopDown()
                        {
                                cy = -cy;
                                y = (cy - y) - 1;
                        }
                        DEBUG_CHECK(IS_INDEX_GOOD(y, cy));
                        return GetLinePtrRaw(y);
                }
                void* GetNextLine(const void* pLinePtr) const noexcept
                {
                        INT_PTR nPitchBytes = (INT_PTR)m_Info.get_PitchBytes();
                        if (!m_Info.isTopDown())
                        {
                                nPitchBytes = -nPitchBytes;
                        }
                        return(((BYTE*)pLinePtr) + nPitchBytes);
                }
 
                bool IsValidPixPtr(const void* p) const noexcept
                {
                        // is this pointer inside my space ?
                        // return IsValidPtr(p);
                        ptrdiff_t i = cMem::Diff(p, get_DataBytes());
                        return IS_INDEX_GOOD(i, m_Info.get_SurfaceSize());
                }
 
                inline BYTE* GetPixPtr(const void* pvLine, PIXELS_t x, size_t sizePixel) const noexcept
                {
                        DEBUG_CHECK(IS_INDEX_GOOD(x, m_Info.get_Width()));
                        DEBUG_CHECK(IsValidPixPtr(pvLine));
                        DEBUG_CHECK(m_Info.get_BytesPerPixel() == sizePixel);
                        return ((BYTE*)pvLine) + x * sizePixel;
                }
                inline BYTE* GetPixPtr(PIXELS_t x, PIXELS_t y, size_t sizePixel) const noexcept
                {
                        return GetPixPtr(GetLinePtr(y), x, sizePixel);
                }
                inline COLOR16_t* GetPixPtr16(PIXELS_t x, PIXELS_t y) const noexcept
                {
                        return (COLOR16_t*)GetPixPtr(x, y, 2);
                }
                inline BYTE* GetPixPtr(PIXELS_t x, PIXELS_t y) const noexcept
                {
                        BIT_SIZE_t wBpp = m_Info.get_BitsPerPixel();
                        DEBUG_CHECK(wBpp >= 8 || x == 0);       // ( x % 8 ) == 0 really is ok
                        return ((BYTE*)GetLinePtr(y)) + ((x * wBpp) / 8);
                }
 
                bool Lock()
                {
                        return true;
                }
                void Unlock()
                {
                }
 
                inline static bool GetPixColor1P(const void* pvLine, PIXELS_t x) noexcept
                {
                        return ((const BYTE*)pvLine)[x / 8] & (1 << (7 - (x & 0x7)));
                }
                inline static void SetPixColor1P(void* pvLine, PIXELS_t x, bool b) noexcept
                {
                        BYTE* pb = ((BYTE*)pvLine) + (x / 8);
                        BYTE xb = (1 << (7 - (x & 0x7)));
                        if (b)
                                *pb |= xb;
                        else
                                *pb &= ~xb;
                }
                bool GetPixColor1(const void* pvLine, PIXELS_t x) const
                {
                        ASSERT(m_Info.get_BitsPerPixel() == 1);
                        ASSERT(IsValidPixPtr(pvLine));
                        ASSERT(IS_INDEX_GOOD(x, m_Info.get_Width()));
                        return GetPixColor1P(pvLine, x);
                }
                void SetPixColor1(void* pvLine, PIXELS_t x, bool b)
                {
                        ASSERT(m_Info.get_BitsPerPixel() == 1);
                        ASSERT(IsValidPixPtr(pvLine));
                        ASSERT(IS_INDEX_GOOD(x, m_Info.get_Width()));
                        SetPixColor1P(pvLine, x, b);
                }
 
                // 8 BPP
                inline BYTE GetPixColor8(const void* pvLine, PIXELS_t x) const noexcept
                {
                        const BYTE* pPix = GetPixPtr(pvLine, x, 1);
                        return *pPix;
                }
                inline void SetPixColor8(void* pvLine, PIXELS_t x, BYTE bColor) noexcept
                {
                        BYTE* pPix = GetPixPtr(pvLine, x, 1);
                        *pPix = bColor;
                }
 
                // Assume 16 bit per pixel SURF_FORM_RGB565 colors
                inline COLOR16_t GetPixColor16(const void* pvLine, PIXELS_t x) const noexcept
                {
                        const COLOR16_t* pPix = (const COLOR16_t*)GetPixPtr(pvLine, x, 2);
                        return *pPix;
                }
                inline void SetPixColor16(void* pvLine, PIXELS_t x, COLOR16_t wColor) noexcept
                {
                        COLOR16_t* pPix = (COLOR16_t*)GetPixPtr(pvLine, x, 2);
                        *pPix = wColor;
                }
 
                // Assume 16 bit grey scale
                COLOR16_t GetPixColor16G(const void* pvLine, PIXELS_t x) const;
                COLOR16_t GetPixColor16G(PIXELS_t x, PIXELS_t y) const
                {
                        return GetPixColor16G(GetLinePtr(y), x);
                }
                void SetPixColor16G(void* pvLine, PIXELS_t x, COLOR16_t wVal);
                void SetPixColor16G(PIXELS_t x, PIXELS_t y, COLOR16_t wVal)
                {
                        SetPixColor16G(GetLinePtr(y), x, wVal);
                }
 
                inline COLORREF GetPixColor24g(const void* pvLine, PIXELS_t x) const noexcept
                {
                        const BYTE* pPix = GetPixPtr(pvLine, x, 3);
                        return RGB(pPix[0], pPix[1], pPix[2]);
                }
                inline D3DCOLOR GetPixColor24d(const void* pvLine, PIXELS_t x) const noexcept
                {
                        const BYTE* pPix = GetPixPtr(pvLine, x, 3);
                        return RGB(pPix[2], pPix[1], pPix[0]);
                }
                inline void SetPixColor24g(void* pvLine, PIXELS_t x, COLORREF dwColor) noexcept
                {
                        BYTE* pPix = GetPixPtr(pvLine, x, 3);
                        pPix[0] = cColorRef::GetR(dwColor);
                        pPix[1] = cColorRef::GetG(dwColor);
                        pPix[2] = cColorRef::GetB(dwColor);
                }
                inline void SetPixColor24d(void* pvLine, PIXELS_t x, D3DCOLOR dwColor) noexcept
                {
                        BYTE* pPix = GetPixPtr(pvLine, x, 3);
                        pPix[0] = cColorRef::GetB(dwColor);
                        pPix[1] = cColorRef::GetG(dwColor);
                        pPix[2] = cColorRef::GetR(dwColor);
                }
 
                inline COLORREF GetPixColor32(const void* pvLine, PIXELS_t x) const noexcept
                {
                        const COLORREF* pPix = (const COLORREF*)GetPixPtr(pvLine, x, 4);
                        return *pPix;
                }
                inline void SetPixColor32(void* pvLine, PIXELS_t x, COLORREF dwColor) noexcept
                {
                        COLORREF* pPix = (COLORREF*)GetPixPtr(pvLine, x, 4);
                        *pPix = dwColor;
                }
 
                // convert FROM ANY BPP
                COLORREF GetPixColorRef(const void* pvLine, PIXELS_t x) const; // ABGR
                COLORREF GetPixColorRef(PIXELS_t x, PIXELS_t y) const // ABGR
                {
                        return GetPixColorRef(GetLinePtr(y), x);
                }
                void SetPixColorRef(void* pvLine, PIXELS_t x, COLORREF c); // ABGR
                void SetPixColorRef(PIXELS_t x, PIXELS_t y, COLORREF c)
                {
                        SetPixColorRef(GetLinePtr(y), x, c);
                }
 
                void ScrollPixels(PIXELS_t cx, PIXELS_t cy);
                void FillColor(COLORREF colorBack);
                void SwapTopBottom();
 
                void SetErase()
                {
                        FillColor(0);
                }
                virtual HRESULT SetPixelData(const cSurfaceBase& rSurfSrc);
                virtual HRESULT SetCopySurface(const cSurfaceBase& rSurfSrc) // virtual
                {
                        return SetPixelData(rSurfSrc);
                }
 
                void SetCopyFrom(const cSurfaceBase& TexSrc, PIXELS_t itxs = 0, PIXELS_t itys = 0, bool bTextureXReverse = false, bool bTextureYReverse = false, bool bColorReverse = false);
                void CopyTo(cSurfaceBase& TexDst, PIXELS_t itxs = 0, PIXELS_t itys = 0, bool bTextureXReverse = false, bool bTextureYReverse = false) const;
 
#ifdef _WIN32
                static HBITMAP GRAYCALL CreateBitmapFromPixels(const tagBITMAPINFO* pBMI, const void FAR* pBits);
                HBITMAP CreateBitmapFromSurface() const;
                int FlipToDC(HDC hDC, PIXELS_t XDest = 0, PIXELS_t YDest = 0) const;
                int StretchToDC(HDC hDC, PIXELS_t XDest, PIXELS_t YDest, PIXELS_t nDestWidth, PIXELS_t nDestHeight) const;
                HRGN CreateMaskRegion(COLOR16_t wTransparentColor);
#endif
 
                HRESULT InitTestPattern();
 
                UNITTEST_FRIEND(cSurfaceBase);
        };
 
        class GRAYLIB_LINK cSurfaceFrames
        {
 
        public:
                cWinSize m_SizeOrig;    
                int m_nFrameQty;                
 
                int m_nFrameCur;                
                size_t m_nFrameOffset;  
                POINT m_ptFrameOffset;  
 
        public:
                cSurfaceFrames() noexcept
                        : m_SizeOrig(0, 0)
                        , m_nFrameQty(0)
                        , m_nFrameCur(0)
                        , m_nFrameOffset(0)
                {
                        m_ptFrameOffset.x = 0;
                        m_ptFrameOffset.y = 0;
                }
 
                void InitFrameCur() noexcept
                {
                        m_nFrameCur = 0;
                        m_nFrameOffset = 0;
                        m_ptFrameOffset.x = 0;
                        m_ptFrameOffset.y = 0;
                }
 
                virtual HRESULT SetFrameCurrent(int iFrameNum) = 0;
        };
} 
#endif // _INC_cSurfaceBase_H