TnbBitmapWipers.h

[詳解]

#pragma once
#include "TnbBitmapAnimater.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CShrinkWiper : public IBitmapWipable
{
    DEFSUPER(IBitmapWipable);
public:
    
    virtual IBitmapWipable* Clone(void) const { return new CShrinkWiper(); }
 
    virtual CBitmapHandle Wipe(CBitmapHandle baseBmp, CBitmapHandle overBmp, UINT par, UINT max) const
    {
        CBitmapImage bi;
        bi.Set(baseBmp);
        const SIZE& size = bi.GetSize();
        int cx = size.cx * (max - par) / max;
        int cy = size.cy * (max - par) / max;
        bi.Insert(-cx, -cy, overBmp, SRCCOPY, size.cx + cx * 2, size.cy + cy * 2);
        return bi.GetBitmapHandle();
    }
};
 
 
 
class CSlideWiper : public IBitmapWipable
{
    DEFSUPER(IBitmapWipable);
    UINT    m_pos;  
public:
    
    CSlideWiper(UINT uPos = 5) : m_pos(uPos)
    {
    }
 
    virtual IBitmapWipable* Clone(void) const { return new CSlideWiper(m_pos); }
 
    virtual CBitmapHandle Wipe(CBitmapHandle baseBmp, CBitmapHandle overBmp, UINT par, UINT max) const
    {
        CBitmapImage bi;
        bi.Set(baseBmp);
        const SIZE& size = bi.GetSize();
        int cx = size.cx * (max - par) / max;
        int cy = size.cy * (max - par) / max;
        if ( m_pos >= 7 ) 
        {
            cy = -cy; 
        }
        else if ( m_pos >= 4 ) 
        {
            cy = 0;
        }
        switch ( m_pos % 3 )
        {
        case 2: cx = 0; break;
        case 1: cx = -cx; break;
        }
        bi.Insert(cx, cy, overBmp, SRCCOPY);
        return bi.GetBitmapHandle();
    }
};
 
 
 
class CAbstractMaskWiper : public IBitmapWipable
{
    DEFSUPER(IBitmapWipable);
protected:
    virtual HRGN CreateMaskRgn(const SIZE& size, UINT par, UINT max) const = 0;
 
public:
    virtual CBitmapHandle Wipe(CBitmapHandle baseBmp, CBitmapHandle overBmp, UINT par, UINT max) const
    {
        CBitmapImage bi;
        bi.Set(baseBmp);
        if ( ! bi.IsEmpty() )
        {
            HRGN hRgn = CreateMaskRgn(bi.GetSize(), par, max);
            if ( hRgn != NULL )
            {
                HDC dc = bi.GetDC();
                ::SelectClipRgn(dc, hRgn);
                CBitmapImage b(overBmp);
                b.Draw(dc, 0, 0);
                ::SelectClipRgn(dc, NULL);
                bi.ReleaseDC();
                _DeleteObject(hRgn);
            }
        }
        return bi.GetBitmapHandle();
    }
};
 
 
 
class CSlideMaskWiper : public CAbstractMaskWiper
{
    DEFSUPER(CAbstractMaskWiper);
    UINT    m_pos;  
protected:
    virtual HRGN CreateMaskRgn(const SIZE& size, UINT par, UINT max) const
    {
        HRGN rgn = ::CreateRectRgn(0, 0, size.cx, size.cy);
        int cx = size.cx * (max - par) / max;
        int cy = size.cy * (max - par) / max;
        if ( m_pos >= 7 ) 
        {
            cy = -cy; 
        }
        else if ( m_pos >= 4 ) 
        {
            cy = 0;
        }
        switch ( m_pos % 3 )
        {
        case 2: cx = 0; break;
        case 1: cx = -cx; break;
        }
        ::OffsetRgn(rgn, cx, cy);
        return rgn;
    }
 
public:
 
    CSlideMaskWiper(UINT p) : m_pos(p)
    {
    }
 
    virtual IBitmapWipable* Clone(void) const 
    {
        return new CSlideMaskWiper(m_pos); 
    }
};
 
 
 
class CRandomMaskWiper : public CAbstractMaskWiper
{
    DEFSUPER(CAbstractMaskWiper);
    size_t              m_size;     
    mutable LPRGNDATA   m_pRgnData; 
    mutable CWorkMem    m_rgnWork;
protected:
 
    virtual HRGN CreateMaskRgn(const SIZE& size, UINT par, UINT max) const
    {
        size_t len = m_size * m_size;
        if ( m_pRgnData == NULL )
        {
            m_rgnWork.Resize(sizeof(RGNDATAHEADER) + sizeof(RECT) * len);
            m_pRgnData = reinterpret_cast<LPRGNDATA>(m_rgnWork.Ref());
            LPRECT pRect = reinterpret_cast<LPRECT>(m_pRgnData->Buffer);
            int i = 0;
            loop ( y, m_size )
            {
                loop ( x, m_size )
                {
                    ::SetRect(&pRect[i++], ToInt(x), ToInt(y), ToInt(x + 1), ToInt(y + 1));
                }
            }
            loop ( i, len )
            {
                INDEX m = rand() % len;
                Swap(pRect[i], pRect[m]);
            }
            m_pRgnData->rdh.dwSize          = sizeof(RGNDATAHEADER);
            m_pRgnData->rdh.iType           = RDH_RECTANGLES;
            m_pRgnData->rdh.rcBound.left    = 0;
            m_pRgnData->rdh.rcBound.top     = 0;
            m_pRgnData->rdh.rcBound.right   = size.cx;
            m_pRgnData->rdh.rcBound.bottom  = size.cy;
        }
        //
        size_t c = len * par / max;
        if ( c == 0 ) 
        {
            return NULL; 
        }
        m_pRgnData->rdh.nRgnSize = ToDword(sizeof(RGNDATAHEADER) + sizeof(RECT) * c);
        m_pRgnData->rdh.nCount = ToDword(c);
        HRGN hTmpRgn = ::ExtCreateRegion(NULL, m_pRgnData->rdh.nRgnSize, m_pRgnData);
        HRGN hRgn = ::CreateRectRgn(0, 0, 0, 0);
        loop ( x, (size.cx / m_size) + 1 )
        {
            ::CombineRgn(hRgn, hRgn, hTmpRgn, RGN_OR);
            ::OffsetRgn(hTmpRgn, ToInt(m_size), 0);
        }
        ::CombineRgn(hTmpRgn, hRgn, NULL, RGN_COPY);
        loop ( y, (size.cy / m_size) )
        {
            ::OffsetRgn(hTmpRgn, 0, ToInt(m_size));
            ::CombineRgn(hRgn, hRgn, hTmpRgn, RGN_OR);
        }
        _DeleteObject(hTmpRgn);
        return hRgn;
    }
 
public:
 
    CRandomMaskWiper(size_t size = 32) : m_size(size), m_pRgnData(NULL)
    {
        ASSERT0( size > 1, "CRandomMaskWiper", "1より大きい数値を指定してください。" );
    }
 
    ~CRandomMaskWiper(void)
    {
        if ( m_pRgnData != NULL )
        {
            m_pRgnData = NULL;
            m_rgnWork.Free();
        }
    }
 
    virtual IBitmapWipable* Clone(void) const 
    {
        return new CRandomMaskWiper(m_size); 
    }
};
 
 
 
}; //TNB