TnbDxDraw.h

[詳解]

#pragma once
#include "TnbPointerHandle.h"
 
 
 
#ifndef INITGUID
 #define INITGUID
#endif
#include <ddraw.h> // SDK
#pragma comment(lib,"ddraw.lib")
#pragma comment(lib,"dxguid.lib")
 
 
 
//TNB Library
namespace TNB{
namespace DX
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
struct TPhReleaseSurface
{
    void operator()(LPDIRECTDRAWSURFACE7 P) { P->Release(); }
};
typedef TNB::CPointerHandleBaseT<LPDIRECTDRAWSURFACE7, TPhReleaseSurface, NULL> CSurfaceHandle;
#endif
 
 
 
class CDirectDraw : CCopyImpossible
{
public:
 
    struct TBuffer
    {
        SIZE    size;               
        int     pitch;              
        int     bitsPixel;          
        union
        {
            BYTE*       pB8;    
            WORD*       pB16;   
            RGBTRIPLE*  pB24;   
            RGBQUAD*    pB32;   
        };
        int Pos(int x, int y) const
        {
            return x + y * pitch;
        }
    };
 
    class CSurface
    {
    public:
 
        ~CSurface()
        {
            m_ReleaseRent();
        }
 
        CSurface(void) : m_isRentBuffer(false), m_hDC(NULL)
        {
            m_CheckSpec();
        }
 
        CSurface(LPDIRECTDRAWSURFACE7 pSurface) : m_hpSurface(pSurface)
        {
            m_CheckSpec();
        }
 
        CSurface(CSurface& other)
        {
            operator=(other);
        }
 
        CSurface& operator=(CSurface& other)
        {
            other.m_ReleaseRent();
            m_hpSurface = other.m_hpSurface;
            m_primarySize = other.m_primarySize;
            m_bitsPixel = other.m_bitsPixel;
            m_isRentBuffer = false;
            m_hDC = NULL;
            return *this;
        }
 
        void Attach(LPDIRECTDRAWSURFACE7 pSurface)
        {
            m_ReleaseRent();
            m_hpSurface = pSurface;
            m_CheckSpec();
        }
 
        HRESULT Create(IDirectDraw7* pDraw, LPDDSURFACEDESC2 pDdsd)
        {
            Destroy();
            LPDIRECTDRAWSURFACE7 P;
            HRESULT r = pDraw->CreateSurface(pDdsd, &P, NULL);
            if ( r == DD_OK )
            {
                m_hpSurface = P;
                m_CheckSpec();
            }
            return r;
        }
 
        void Destroy(void)
        {
            m_ReleaseRent();
            m_hpSurface = NULL;
        }
 
        bool IsValid(void) const
        {
            return ! m_hpSurface.IsNull();
        }
 
        const SIZE& GetSize(void) const
        {
            return m_primarySize;
        }
 
        operator LPDIRECTDRAWSURFACE7(void)
        {
            DEBUG_ONLY( m_ReleaseRent() );
            return m_hpSurface;
        }
 
        LPDIRECTDRAWSURFACE7 operator->(void)
        {
            DEBUG_ONLY( m_ReleaseRent() );
            return m_hpSurface;
        }
 
        HRESULT BltFast(int x, int y, LPDIRECTDRAWSURFACE7 lpDdsSrc, const RECT& srcRect, DWORD dwTrans = 0)
        {
            CRect rc = srcRect;
            HRESULT hr = m_hpSurface->BltFast(x, y, lpDdsSrc, &rc, DDBLTFAST_WAIT | dwTrans);
            if ( hr == DDERR_SURFACELOST )
            {
                m_hpSurface->Restore();
                hr = m_hpSurface->BltFast(x, y, lpDdsSrc, &rc, DDBLTFAST_WAIT | dwTrans);
            }
            return hr;
        }
 
        HRESULT BltFastClip(int x, int y, LPDIRECTDRAWSURFACE7 lpDdsSrc, const RECT& srcRect, DWORD dwTrans = 0)
        {
            RECT rc = srcRect;
            int width = rc.right - rc.left;
            int height = rc.bottom - rc.top;
            // 指定範囲を超えた画像を切り取る
            if ( x < 0 )
            {
                rc.left += (-x);
                x = 0;
            }
            else if ( m_primarySize.cx < x + width )
            {
                rc.right -= (x + width - m_primarySize.cx);
            }
            if ( y < 0)
            {
                rc.top += (-y);
                y = 0;
            }
            else if ( m_primarySize.cy < y + height)
            {
                rc.bottom -= (y + height - m_primarySize.cy);
            }
            //描画
            return BltFast(x, y, lpDdsSrc, rc, dwTrans);
        }
 
        HRESULT Blt(const RECT& dstRect, LPDIRECTDRAWSURFACE7 lpDdsSrc, const RECT& srcRect, DWORD dwTrans = 0)
        {
            CRect rc1 = dstRect;
            CRect rc2 = srcRect;
            HRESULT hr = m_hpSurface->Blt(&rc1, lpDdsSrc, &rc2, DDBLT_WAIT | dwTrans, NULL);
            if ( hr == DDERR_SURFACELOST )
            {
                m_hpSurface->Restore();
                hr = m_hpSurface->Blt(&rc1, lpDdsSrc, &rc2, DDBLT_WAIT | dwTrans, NULL);
            }
            return hr;
        }
 
        HRESULT BltClip(const RECT& dstRect, LPDIRECTDRAWSURFACE7 lpDdsSrc, const RECT& srcRect, DWORD dwTrans = 0)
        {
            RECT dstRc = dstRect;
            RECT srcRc = srcRect;
            SIZE dstSz = { dstRc.right - dstRc.left, dstRc.bottom - dstRc.top };
            SIZE srcSz = { srcRc.right - srcRc.left, srcRc.bottom - srcRc.top };
            const LONG par = 1024;
            LONG parHeight = dstSz.cx * par / srcSz.cx;
            LONG parWidth = dstSz.cy * par / srcSz.cy;
            // 指定範囲を超えた画像を切り取る
            int w1 = dstRc.right - m_clipRect.right;
            if ( w1 > 0 )
            {
                srcRc.right -= w1 * par / parWidth;
                dstRc.right -= w1;
            }
            int w2 = dstRc.left - m_clipRect.left;
            if ( w2 < 0)
            {
                srcRc.left -= w2 * par / parWidth;
                dstRc.left -= w2;
            }
            int h1 = dstRc.bottom - m_clipRect.bottom;
            if ( h1 > 0 )
            {
                srcRc.bottom -= h1 * par / parHeight;
                dstRc.bottom -= h1;
            }
            int h2 = dstRc.top - m_clipRect.top;
            if ( h2 < 0)
            {
                srcRc.top -= h2 * par / parHeight;
                dstRc.top -= h2;
            }
            //
            return Blt(dstRc, lpDdsSrc, srcRc, dwTrans);
        }
 
        HDC GetDC(void)
        {
            if ( IsValid() && m_hDC == NULL )
            {
                ReleaseBuffer();
                if ( m_hpSurface->GetDC(&m_hDC) == DD_OK )
                {
                    return m_hDC;
                }
            }
            return NULL;
        }
 
        void ReleaseDC(void)
        {
            if ( IsValid() && m_hDC != NULL )
            {
                m_hpSurface->ReleaseDC(m_hDC);
                m_hDC = NULL;
            }
        }
 
        const TBuffer* GetBuffer(void)
        {
            if ( IsValid() && ! m_isRentBuffer )
            {
                ReleaseDC();
                DDSURFACEDESC2 ddsd = { sizeof(DDSURFACEDESC2) };
                if ( m_hpSurface->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL) == DD_OK )
                {
                    m_buffer.size = m_primarySize;
                    m_buffer.pitch = ddsd.lPitch / m_bitsPixel * 8;
                    m_buffer.bitsPixel = m_bitsPixel;
                    m_buffer.pB8 = static_cast<BYTE*>(ddsd.lpSurface);
                    m_isRentBuffer = true;
                    return &m_buffer;
                }
            }
            return NULL;
        }
 
        void ReleaseBuffer(void)
        {
            if ( IsValid() && m_isRentBuffer )
            {
                m_hpSurface->Unlock(NULL);
                m_isRentBuffer = false;
            }
        }
 
        void SetClipRect(const RECT& rect)
        {
            m_clipRect = rect;
        }
 
    private:
 
        void m_CheckSpec(void)
        {
            if ( IsValid() )
            {
                DDSURFACEDESC2 ddsd = { sizeof(DDSURFACEDESC2) };
                DDPIXELFORMAT ddpf = { sizeof(DDPIXELFORMAT) };
                if ( m_hpSurface->GetSurfaceDesc(&ddsd) == DD_OK && m_hpSurface->GetPixelFormat(&ddpf) == DD_OK )
                {
                    DWORD f = DDSD_WIDTH | DDSD_HEIGHT;
                    if ( (ddsd.dwFlags & f) == f )
                    {
                        m_primarySize.cx = ddsd.dwWidth;
                        m_primarySize.cy = ddsd.dwHeight;
                        ::SetRect(&m_clipRect, 0, 0, m_primarySize.cx, m_primarySize.cy);
                        m_bitsPixel = ddpf.dwRGBBitCount;
                        return;
                    }
                }
            }
            m_primarySize.cx = 0;
            m_primarySize.cy = 0;
            ::SetRectEmpty(&m_clipRect);
            m_bitsPixel = 0;
        }
        void m_ReleaseRent(void)
        {
            ReleaseDC();
            ReleaseBuffer();
        }
        //
        CSurfaceHandle  m_hpSurface;    
        SIZE            m_primarySize;          
        int             m_bitsPixel;    
        //
        RECT            m_clipRect;     
        //
        bool            m_isRentBuffer; 
        HDC             m_hDC;          
        TBuffer         m_buffer;       
    };
 
 
    //------------------------
        
    
    CDirectDraw(void) : m_pDraw(NULL), m_isFull(false), m_pClip(NULL), m_hDC(NULL), m_pGetBuffSurface(NULL)
    {
        m_primarySize.cx = 0;
        m_primarySize.cy = 0;
        m_backSize.cx = 0;
        m_backSize.cy = 0;
        m_offset.x = 0;
        m_offset.y = 0;
        m_magnific.x = 1;
        m_magnific.y = 1;
    }
 
    ~CDirectDraw(void)
    {
        Destroy();
    }
 
    bool SetFullScreenMode(bool isFull)
    {
        if ( m_isFull != isFull )
        {
            if ( m_pDraw != NULL )
            {
                m_DestroySurface();
                m_isFull = isFull;
                return m_CreateSurface();
            }
            m_isFull = isFull;
        }
        return true;
    }
 
    bool SetSize(const SIZE& size)
    {
        return SetSize(size, size);
    }
 
    bool SetSize(const SIZE& primarySize, const SIZE& backSize)
    {
        m_primarySize = primarySize;
        m_backSize = backSize;
        if ( m_pDraw != NULL )
        {
            m_DestroySurface();
            return m_CreateSurface();
        }
        return true;
    }
 
    bool Create(HWND hWnd, int bitsPixel = -1)
    {
        Destroy();
        m_hWnd = hWnd;
        if ( bitsPixel < 0 )
        {
            DEVMODE dm = { sizeof(DEVMODE) };
            if ( ! ::EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm) )
            {
                return false;
            }
            bitsPixel = dm.dmBitsPerPel;
        }
        m_bitsPixel = bitsPixel;
        C_ASSERT( DD_OK == 0 );
        if ( ::DirectDrawCreateEx(NULL, reinterpret_cast<void**>(&m_pDraw), IID_IDirectDraw7, NULL) != DD_OK )
        {
            return false;
        }
        if ( ! m_CreateSurface() )
        {
            Destroy();
            return false;
        }
        return true;
    }
 
    void Destroy(void)
    {
        if ( m_backbufferSurface.IsValid() && m_hDC != NULL )
        {
            m_backbufferSurface->ReleaseDC(m_hDC);
            m_hDC = NULL;
        }
        m_DestroySurface();
        m_Release(m_pDraw);
    }
 
    const SIZE& GetPrimarySize(void) const
    {
        return m_primarySize;
    }
 
    const SIZE& GetBackbufferSize(void) const
    {
        return m_backSize;
    }
 
    int GetBitsPixel(void) const
    {
        if ( m_pDraw != NULL )
        {
            DDSURFACEDESC2 ddsd = { sizeof(DDSURFACEDESC2) };
            if ( m_pDraw->GetDisplayMode(&ddsd) == DD_OK )
            {
                return (ddsd.lPitch / ddsd.dwWidth) * 8;
            }
        }
        else
        {
            DEVMODE dm = { sizeof(DEVMODE) };
            if ( ::EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm) )
            {
                return dm.dmBitsPerPel;
            }
        }
        return -1;
    }
 
    void SetOffset(int x, int y, int magnificX, int magnificY)
    {
        m_offset.x = x;
        m_offset.y = y;
        m_magnific.x = magnificX;
        if ( m_magnific.x < 1 )
        {
            m_magnific.x = 1;
        }
        m_magnific.y = magnificY;
        if ( m_magnific.y < 1 )
        {
            m_magnific.y = 1;
        }
        Redraw();
    }
 
    void SetOffset(int x = 0, int y = 0, int magnific = 1)
    {
        m_offset.x = x;
        m_offset.y = y;
        if ( magnific < 1 )
        {
            magnific = 1;
        }
        m_magnific.x = magnific;
        m_magnific.y = magnific;
        Redraw();
    }
 
    bool Redraw(void)
    {
        if ( m_primarySurface.IsValid() && ! m_isFull )
        {
            POINT po = { 0, 0 };
            ::ClientToScreen(m_hWnd, &po);
            RECT r2 = { 0, 0, m_primarySize.cx, m_primarySize.cy };
            RECT r1 = r2;
            ::OffsetRect(&r1, po.x, po.y);
            r2.right /= m_magnific.x;
            r2.bottom /= m_magnific.y;
            ::OffsetRect(&r2, m_offset.x, m_offset.y);
            m_pDraw->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, 0); //同期待ち
//          return m_primarySurface->Blt(&r1, m_benchSurface, &r2, DDBLT_WAIT, NULL) == DD_OK; //こっちのほうが早いが画面外にいくと、おかしなところに表示されてしまう
            return m_primarySurface.BltClip(r1, m_benchSurface, r2) == DD_OK;           
        }
        return false;
    }
 
    bool Flip(void)
    {
        bool r = false;
        if ( m_primarySurface.IsValid() )
        {
            if ( m_isFull )
            {
                //== フルモード
                r = m_primarySurface->Flip(0, DDFLIP_WAIT) == DD_OK;
            }
            else
            {
                //== ウィンモード
                r = m_benchSurface->BltFast(0, 0, m_backbufferSurface, NULL, DDBLTFAST_WAIT) == DD_OK;
                if ( r )
                {
                    r = Redraw();
                }
            }
        }
        return r;
    }
 
    void WaitForVerticalBlank(void)
    {
        if ( m_pDraw != NULL )
        {
            m_pDraw->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, 0); //同期待ち
        }
    }
 
    bool ClearBackbufferSurface(void)
    {
        if ( m_primarySurface.IsValid() )
        {
            return m_backbufferSurface->BltFast(0, 0, m_baseSurface, NULL, DDBLTFAST_WAIT) == DD_OK;
        }
        return false;
    }
 
    CSurface& GetBackbufferSurface(void)
    {
        return m_backbufferSurface;
    }
 
    CSurface CreateWorkSurfase(int height, int width)
    {
        CSurface surf;
        DDSURFACEDESC2 ddsd = { sizeof(DDSURFACEDESC2) };
        ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT ;
        ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; 
        ddsd.dwWidth = (height > 0) ? height : m_backSize.cx;
        ddsd.dwHeight = (width > 0) ? width : m_backSize.cy;
        surf.Create(m_pDraw, &ddsd);
        return surf;
    }
 
private:
 
    void m_DestroySurface(void)
    {
        m_Release(m_baseSurface);
        m_Release(m_backbufferSurface);
        m_Release(m_benchSurface);
        m_Release(m_primarySurface);
        m_Release(m_pClip);
    }
 
    // サーフェス作成
    bool m_CreateSurface(void)
    {
        m_DestroySurface();
        ASSERT( m_pDraw != NULL );
        DDSURFACEDESC2 ddsd = { sizeof(DDSURFACEDESC2) };
        HRESULT res = DD_OK;
        if ( m_isFull )
        {
            //== フル
            //協調レベル設定
            res |= m_pDraw->SetCooperativeLevel(m_hWnd, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE);
            //画面設定
            res |= m_pDraw->SetDisplayMode(m_primarySize.cx, m_primarySize.cy, m_bitsPixel, 0, 0);
            //プライマリサーフェイス作成
            ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
            ddsd.ddsCaps.dwCaps =  DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
            ddsd.dwBackBufferCount = 1;
            res |= m_primarySurface.Create(m_pDraw, &ddsd);
            if ( res == DD_OK )
            {
                //バックバッファサーフェス作成
                DDSCAPS2 ddscaps = { 0 };
                ddscaps.dwCaps=DDSCAPS_BACKBUFFER;
                LPDIRECTDRAWSURFACE7 pSur = NULL;
                res |= m_primarySurface->GetAttachedSurface(&ddscaps, &pSur);
                m_backbufferSurface.Attach(pSur);
            }
            ddsd.dwWidth = m_primarySize.cx;
            ddsd.dwHeight = m_primarySize.cy;
        }
        else
        {
            //== ウィン
            //協調レベル設定
            m_pDraw->SetCooperativeLevel(m_hWnd, DDSCL_NORMAL);
            //画面設定
            DEVMODE dm = { sizeof(DEVMODE) };
            if ( ::EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm) )
            {
                dm.dmBitsPerPel = m_bitsPixel;
                dm.dmFields = DM_BITSPERPEL;
                if ( ::ChangeDisplaySettings(&dm, CDS_FULLSCREEN/*一時的の意味で使う*/) != DISP_CHANGE_SUCCESSFUL )
                {
                    res = DD_FALSE;
                }
            }
            else
            {
                res = DD_FALSE;
            }
            //クリッパー作成
            res |= m_pDraw->CreateClipper(0, &m_pClip, NULL);
            if ( res == DD_OK )
            {
                res |= m_pClip->SetHWnd(0, m_hWnd);
                //プライマリサーフェスの作成
                ddsd.dwFlags = DDSD_CAPS;
                ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
                res |= m_primarySurface.Create(m_pDraw, &ddsd);
            }
            if ( res == DD_OK )
            {
                res |= m_primarySurface->SetClipper(m_pClip);
                //クリッピング枠更新
                RECT nowClipRect;
                ::GetClipCursor(&nowClipRect);
                ::ClipCursor(NULL);
                RECT allClipRect;
                ::GetClipCursor(&allClipRect);
                ::ClipCursor(&nowClipRect);
                m_primarySurface.SetClipRect(allClipRect);
                //バックサーフェスの作成
                ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
                ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
                ddsd.dwWidth = m_backSize.cx;
                ddsd.dwHeight = m_backSize.cy;
                res |= m_backbufferSurface.Create(m_pDraw, &ddsd);
                //ベンチサーフェスの作成
                res |= m_benchSurface.Create(m_pDraw, &ddsd);
            }
        }
        //
        if ( res == DD_OK )
        {
            //ベースサーフェス
            ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
            ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; 
            res |= m_baseSurface.Create(m_pDraw, &ddsd);
        }
        //
        if ( res != DD_OK )
        {
            m_DestroySurface();
            return false;
        }
        return true;
    }
 
    template<typename TYP>
    void m_Release(TYP*& P)
    {
        if ( P != NULL )
        {
            P->Release();
            P = NULL;
        }
    }
 
    void m_Release(CSurface& P)
    {
        P.Destroy();
    }
 
    HWND                    m_hWnd;                 
    SIZE                    m_primarySize;          
    SIZE                    m_backSize;             
    int                     m_bitsPixel;            
    bool                    m_isFull;               
    POINT                   m_offset;               
    POINT                   m_magnific;             
    LPDIRECTDRAW7           m_pDraw;                
    CSurface                m_primarySurface;       
    CSurface                m_backbufferSurface;    
    CSurface                m_benchSurface;         
    CSurface                m_baseSurface;          
    LPDIRECTDRAWCLIPPER     m_pClip;                
    //
    HDC                     m_hDC;                  
    TBuffer                 m_buffer;               
    LPDIRECTDRAWSURFACE7    m_pGetBuffSurface;      
};
 
 
 
};//DX
};//TNB
 
 
/*
    画面として、今、こんな感じ。
    
    表示している、「プライマリサーフェス」
    編集用の、「バックバッファサーフェス」
    ウィンドウモード専用に、表示内容の控え、「ベンチサーフェス」
 
 
    バックバッファをクリアするための、「ベースサーフェス」
 
    矩形パターンをおいておく、「パターンサーフェス」　数枚？
 
    背景パターンを並べる、「バックグラウンドサーフェス」　数枚？
        スクロールに対応？！
 
 
 
 
 
 
    ウィンドウモードの場合、オフセット表示が可能。
 
 
 
*/