TnbBitmapAnimater.h

[詳解]

#pragma once
#include "TnbBitmapImage.h"
#include "TnbSimpleVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
struct IBitmapWipable
{
    virtual ~IBitmapWipable(void) { }
 
    virtual IBitmapWipable* Clone(void) const = 0;
 
    virtual CBitmapHandle Wipe(CBitmapHandle baseBmp, CBitmapHandle overBmp, UINT par, UINT max) const = 0;
 
    typedef CPointerHandleT<IBitmapWipable> Ptr;
};
 
 
 
class CReverseAdaptWiper : public IBitmapWipable
{
    DEFSUPER(IBitmapWipable);
protected:
    IBitmapWipable::Ptr m_pWiper;       
public:
 
    CReverseAdaptWiper(const IBitmapWipable& w) : m_pWiper(w.Clone())
    {
    }
 
    virtual IBitmapWipable* Clone(void) const
    {
        if ( m_pWiper.IsNull() ) return NULL;
        return new CReverseAdaptWiper(*m_pWiper);
    }
 
    virtual CBitmapHandle Wipe(CBitmapHandle baseBmp, CBitmapHandle overBmp, UINT par, UINT max) const
    {
        return m_pWiper->Wipe(overBmp, baseBmp, max - par, max);
    }
};
 
 
 
class CMultiAdaptWiper : public IBitmapWipable
{
    DEFSUPER(IBitmapWipable);
protected:
    typedef CSimpleVectorT<IBitmapWipable::Ptr> CWipablesVecter;
    CWipablesVecter     m_wipers;       
    void m_AllRemove(void)
    {
        m_wipers.RemoveAll();
    }
public:
 
    CMultiAdaptWiper(void)
    {
    }
 
    ~CMultiAdaptWiper(void)
    {
        m_AllRemove();
    }
 
    virtual IBitmapWipable* Clone(void) const
    {
        CMultiAdaptWiper* P = new CMultiAdaptWiper();
        loop ( i, m_wipers.GetSize() )
        {
            P->AddWiper(*m_wipers[i]);
        }
        return P;
    }
 
    virtual CBitmapHandle Wipe(CBitmapHandle baseBmp, CBitmapHandle overBmp, UINT par, UINT max) const
    {
        loop ( i, m_wipers.GetSize() )
        {
            overBmp = m_wipers[i]->Wipe(baseBmp, overBmp, par, max);
        }
        return overBmp;
    }
 
    void SetWiper(const IBitmapWipable& w)
    {
        m_AllRemove();
        AddWiper(w);
    }
 
    void AddWiper(const IBitmapWipable& w)
    {
        m_wipers.Add(w.Clone());
    }
};
 
 
 
class CPenetrateWiper : public IBitmapWipable
{
    DEFSUPER(IBitmapWipable);
public:
    virtual IBitmapWipable* Clone(void) const { return new CPenetrateWiper(); }
 
    virtual CBitmapHandle Wipe(CBitmapHandle baseBmp, CBitmapHandle overBmp, UINT par, UINT max) const
    {
        CBitmapImage bi;
        bi.Set(baseBmp);
        bi.InsertOnAlphaBlend(0, 0, overBmp, 100 * par / max);
        return bi.GetBitmapHandle();
    }
};
 
 
 
class CStretchWiper : public IBitmapWipable
{
    DEFSUPER(IBitmapWipable);
    BYTE    m_pos;  
public:
 
    enum
    {
        HEIGHT_FIX = 0x10,  
        WIDTH_FIX = 0x20    
    };
    
    CStretchWiper(BYTE uPos = 5) : m_pos(uPos)
    {
    }
 
    virtual IBitmapWipable* Clone(void) const { return new CStretchWiper(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;
        if ( (m_pos & WIDTH_FIX) == 0 )
        {
            cx = cx * par / max;
        }
        int cy = size.cy;
        if ( (m_pos & HEIGHT_FIX) == 0 )
        {
            cy = cy * par / max;
        }
        if ( cx > 0 && cy > 0 )
        {
            int po = m_pos & 0x0F;
            int x = size.cx - cx;
            int y = size.cy - cy;
            if ( po >= 7 ) 
            {
                y = 0; 
            }
            else if ( po >= 4 ) 
            {
                y /= 2;
            }
            switch ( po % 3 )
            {
            case 1: x = 0; break;
            case 2: x /= 2; break;
            }
            bi.Insert(x, y, overBmp, SRCCOPY, cx, cy);
        }
        return bi.GetBitmapHandle();
    }
};
 
 
 
class CBitmapAnimater //: CCopyImmposible
{
    struct TBaseFrame
    {
        CBitmapHandle       bmp;        
        UINT                count;      
        IBitmapWipable::Ptr pWiper;     
    };
    CSimpleVectorT<TBaseFrame>      m_frames;   
    size_t                          m_length;   
    CSimpleVectorT<CBitmapHandle>   m_cache;    
    // 全けし
    void m_RemoveAll(void)
    {
        m_frames.RemoveAll();
        m_length = 0;
        m_cache.RemoveAll();
    }
    //
    bool m_AddBaseFrame(CBitmapHandle bmp, UINT count, const IBitmapWipable* pWiper)
    {
        if ( ! bmp.IsNull() )
        {
            if ( count == 0 ) 
            {
                count = 1;
            }
            TBaseFrame b;
            b.bmp = bmp;
            b.count = count;
            if ( pWiper != NULL )
            {
                b.pWiper = pWiper->Clone();
            }
            m_frames.Add(b);
            m_length += b.count;
            return true;
        }
        return false;
    }
public:
 
    CBitmapAnimater(void) : m_length(0)
    {
    }
 
    bool SetFirstFrame(CBitmapHandle bmp, const IBitmapWipable& defaultWiper)
    {
        m_RemoveAll();
        return m_AddBaseFrame(bmp, 1, &defaultWiper);
    }
 
    bool SetFirstFrame(CBitmapHandle bmp)
    {
        m_RemoveAll();
        CPenetrateWiper w;
        return m_AddBaseFrame(bmp, 1, &w);
    }
 
    bool AddBaseFrame(CBitmapHandle bmp, UINT count, const IBitmapWipable& wiper)
    {
        if ( m_length > 0 )
        {
            return m_AddBaseFrame(bmp, count, &wiper);
        }
        return false;
    }
 
    bool AddBaseFrame(CBitmapHandle bmp, UINT count = 1)
    {
        if ( m_length > 0 )
        {
            return m_AddBaseFrame(bmp, count, NULL);
        }
        return false;
    }
 
    size_t GetLength(void) const
    {
        return m_length;
    }
 
    CBitmapHandle FrameAt(INDEX index) const
    {
        if ( index >= m_length ) { return CBitmapHandle(); }
        const TBaseFrame* P = NULL;
        loop ( i, m_frames.GetSize() )
        {
            P = &m_frames[i];
            if ( index < P->count )
            {
                break;
            }
            index -= P->count;
        }
        ASSERTLIB( P != NULL );
        if ( P->count == 1 )
        {
            return P->bmp;
        }
        const IBitmapWipable* pWiper = P->pWiper;
        if ( pWiper == NULL )
        {
            pWiper = m_frames[0].pWiper;
        }
        if ( pWiper == NULL || index + 1 == P->count )
        {
            return P->bmp;
        }
        return pWiper->Wipe((P - 1)->bmp, P->bmp, down_cast<UINT>(index + 1), P->count);
    }
 
    CBitmapHandle FrameAtWithCache(INDEX index)
    {
        CBitmapHandle b;
        if ( index < m_length )
        {
            if ( m_cache.GetSize() != m_length )
            {
                m_cache.SetSize(m_length);
            }
            b = m_cache.At(index);
            if ( b.IsNull() )
            {
                b = FrameAt(index);
                m_cache.Set(index, b);
            }
        }
        return b;
    }
 
    void FlashCache(void)
    {
        m_cache.RemoveAll();
    }
};
 
 
 
}; //TNB