fs/rap/fsSurfCl.cpp

Go to the documentation of this file.

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
/*                          _______      ______    ______          __      */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~    / ____(_)___ / ___ /)  / ____/___  ____/ /__    */
/*     [fsSurfCl]         / /_  / / __ \\__ \|/  / /   / __ \/ __  / _ \   */
/*       rev. 4          / __/ / / /_/ /__/ /   / /___/ /_/ / /_/ /  __/   */
/*    12th Feb 2007     /_/   /_/ ,___/____/    \____/\____/\__,_/\___/    */
/*     [ ] stable              /_/ (c) 2006-7 Filip STOKLAS (FipS)         */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~       http://HOLE.4FipS.com/fips_code.php          */
/*                                                                         */
/* This code is free for personal and commercial use. You may redistribute */
/* it by any means. If you use the code for your own projects please give  */
/* me credit. Please send a bug report. Don't alter or remove this header! */
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#include <fs/rap/fsSurfCl.h>

// >>> COMMON SUPPORT BLOCK (rev. 6)
#if defined(FS_HAS_FSASSERT)
#   include <fs/sys/fsAssert.h>
#else
#   include <cassert>
#   if !defined(FS_ASSERT)
#       define FS_ASSERT(exp) assert(exp)
#   endif
#   if !defined(FS_ASSERT_MSG)
#       define FS_ASSERT_MSG(exp, msg) assert(exp && msg)
#   endif
#   if !defined(FS_VERIFY)
#       define FS_VERIFY(exp) \
        { bool bExp = !!(exp); assert(bExp && #exp); bExp; }
#   endif
#   if !defined(FS_VERIFY_MSG)
#       define FS_VERIFY_MSG(exp, msg) \
        { bool bExp = !!(exp); assert(bExp && #exp && msg); bExp; }
#   endif
#   if !defined(FS_STATIC_ASSERT)
#       define FS_STATIC_ASSERT(exp) { char error[(exp) ? 1 : 0]; error; }
#   endif
#endif
#if !defined(FS_VERIFY_RETURN)
#   define FS_VERIFY_RETURN(exp) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<return>"); return; }
#endif
#if !defined(FS_VERIFY_RETURN_VAL)
#   define FS_VERIFY_RETURN_VAL(exp, ret) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<returns:>" #ret); return (ret); }
#endif
// <<< COMMON SUPPORT BLOCK (rev. 6)

#include <vector>
#include <windows.h>

// provide detailed memory tracking information
#if defined(FS_HAS_FSMEMMGR)
#   include <fs/sys/fsMemMgr.h>
#endif
//---------------------------------------------------------------------------
using namespace fs::rap;
//---------------------------------------------------------------------------
//--- ANONYMOUS NAMESPACE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
namespace {
//---------------------------------------------------------------------------
//--- CLASS SurfClImpl_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
class SurfClImpl_t
{
 public:
 
    SurfClImpl_t(bool bFitCl, int nSurfW, int nSurfH);
    void Clear(const SurfCl_t::PxFmt8888_t &Clr);
    int GetW() const;
    int GetH() const;
    SurfCl_t::PxFmt8888_t * GetData();
    
    void OnSizeEv(const WinApp_t::SizeEv_t &, WinApp_t &);
    void OnDrawEv(const WinApp_t::DrawEv_t &, WinApp_t &);
    
 private:

    SurfClImpl_t(); 
    SurfClImpl_t(const SurfClImpl_t &); 
    SurfClImpl_t & operator = (const SurfClImpl_t &); 
    
    void ReszSurf(int nSurfW, int nSurfH);
    
    //---

    bool m_bFitCl;
    int m_nSurfW, m_nSurfH;
    int m_nClW, m_nClH;
            
    typedef std::vector<SurfCl_t::PxFmt8888_t> Data_t;
    Data_t m_Data;
};
//---------------------------------------------------------------------------
SurfClImpl_t::SurfClImpl_t(bool bFitCl, int nSurfW, int nSurfH):
m_bFitCl(bFitCl),
m_nSurfW(0),
m_nSurfH(0),
m_nClW(0),
m_nClH(0)
{
    FS_VERIFY_RETURN(nSurfW >= 0 && nSurfH >= 0);
    ReszSurf(nSurfW, nSurfH);
}
//---------------------------------------------------------------------------
void SurfClImpl_t::Clear(const SurfCl_t::PxFmt8888_t &Clr)
{
    const SurfCl_t::PxFmt8888_t Clr2 = { Clr.r, Clr.g, Clr.b, 0 };
    FS_ASSERT(!m_Data.empty());
    
    if(Clr2.r == Clr2.g && Clr2.r == Clr2.b)
    {
        ::memset(&m_Data[0], Clr2.r, m_Data.size() * sizeof(Clr2));
    }
    else
    {
        //std::fill(m_Data.begin(), m_Data.end(), Clr2);
        for(size_t i = 0, n = m_Data.size(); i < n; ++i)
            m_Data[i] = Clr2;
    }
}
//---------------------------------------------------------------------------
int SurfClImpl_t::GetW() const
{
    return m_nSurfW;
}
//---------------------------------------------------------------------------
int SurfClImpl_t::GetH() const
{
    return m_nSurfH;
}
//---------------------------------------------------------------------------
SurfCl_t::PxFmt8888_t * SurfClImpl_t::GetData()
{   
    // 'empty data' is a valid state...
    return !m_Data.empty() ? &m_Data[0] : 0;
}
//---------------------------------------------------------------------------
void SurfClImpl_t::OnSizeEv(const WinApp_t::SizeEv_t &SizeEv, WinApp_t &)
{
    FS_VERIFY_RETURN(SizeEv.m_nClW >= 0 && SizeEv.m_nClH >= 0);
        
    m_nClW = SizeEv.m_nClW;
    m_nClH = SizeEv.m_nClH;
    
    if(m_bFitCl)
        ReszSurf(m_nClW, m_nClH);
}
//---------------------------------------------------------------------------
void SurfClImpl_t::OnDrawEv(const WinApp_t::DrawEv_t &, WinApp_t &App)
{
    if(m_Data.empty()) // it's a valid state...
        return;

    HWND hWnd = static_cast<HWND>(App.GetWinHdle());
    FS_ASSERT(hWnd);
    
    HDC hDC = ::GetDC(hWnd);
    FS_ASSERT(hDC);
    
    //---
    
    static BITMAPINFO *pBmpInfo = 0;
    
    static char aBmpInfoBuf[sizeof BITMAPINFO + 16];
    ::memset(aBmpInfoBuf, 0, sizeof BITMAPINFO + 16);
            
    pBmpInfo = reinterpret_cast<BITMAPINFO *>(&aBmpInfoBuf);
    pBmpInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    pBmpInfo->bmiHeader.biPlanes = 1;
    pBmpInfo->bmiHeader.biBitCount = 32;
    pBmpInfo->bmiHeader.biCompression = BI_BITFIELDS;
    pBmpInfo->bmiHeader.biWidth = m_nSurfW;
    pBmpInfo->bmiHeader.biHeight = -m_nSurfH; // '-' means y-mirror
    reinterpret_cast<unsigned long *>(pBmpInfo->bmiColors)[0] = 0x000000FF;
    reinterpret_cast<unsigned long *>(pBmpInfo->bmiColors)[1] = 0x0000FF00;
    reinterpret_cast<unsigned long *>(pBmpInfo->bmiColors)[2] = 0x00FF0000;
        
    //---
    
    FS_ASSERT(!m_Data.empty());
    ::StretchDIBits(
     hDC,
     0, 0, m_nClW, m_nClH,
     0, 0, m_nSurfW, m_nSurfH,
     &m_Data[0],
     pBmpInfo,
     DIB_RGB_COLORS,
     SRCCOPY
    );

    //---
    
    ::ReleaseDC(hWnd, hDC);
}
//---------------------------------------------------------------------------
void SurfClImpl_t::ReszSurf(int nSurfW, int nSurfH)
{
    FS_ASSERT(nSurfW >= 0 && nSurfH >= 0);

    m_nSurfW = nSurfW;
    m_nSurfH = nSurfH;
    
    m_Data.resize(m_nSurfW * m_nSurfH);
}
//---------------------------------------------------------------------------
} // anonymous namespace
//---------------------------------------------------------------------------
//--- CLASS SurfCl_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
SurfCl_t::SurfCl_t(bool bFitCl, int nSurfW, int nSurfH):
m_pImpl(new SurfClImpl_t(bFitCl, nSurfW, nSurfH))
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
}
//---------------------------------------------------------------------------
SurfCl_t::~SurfCl_t()
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    delete static_cast<SurfClImpl_t *>(m_pImpl);
}
//---------------------------------------------------------------------------
void SurfCl_t::Clear(const PxFmt8888_t &Clr)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<SurfClImpl_t *>(m_pImpl)->Clear(Clr);
}
//---------------------------------------------------------------------------
int SurfCl_t::GetW() const
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<SurfClImpl_t *>(m_pImpl)->GetW();
}
//---------------------------------------------------------------------------
int SurfCl_t::GetH() const
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<SurfClImpl_t *>(m_pImpl)->GetH();
}
//---------------------------------------------------------------------------
SurfCl_t::PxFmt8888_t * SurfCl_t::GetData()
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    return static_cast<SurfClImpl_t *>(m_pImpl)->GetData();
}
//---------------------------------------------------------------------------
void SurfCl_t::OnEvent(const WinApp_t::SizeEv_t &SizeEv, WinApp_t &App)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    static_cast<SurfClImpl_t *>(m_pImpl)->OnSizeEv(SizeEv, App);
}
//---------------------------------------------------------------------------
void SurfCl_t::OnEvent(const WinApp_t::DrawEv_t &DrawEv, WinApp_t &App)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    static_cast<SurfClImpl_t *>(m_pImpl)->OnDrawEv(DrawEv, App);
}
//---------------------------------------------------------------------------

---

FipS' Code (Thu Feb 15 22:43:35 2007) - (c) Filip STOKLAS (FipS) - [ www ] [ Guest Book ]