?? ddsurf.cpp
字號:
//-----------------------------------------------------------------------------------//
// Windows Graphics Programming: Win32 GDI and DirectDraw //
// ISBN 0-13-086985-6 //
// //
// Written by Yuan, Feng www.fengyuan.com //
// Copyright (c) 2000 by Hewlett-Packard Company www.hp.com //
// Published by Prentice Hall PTR, Prentice-Hall, Inc. www.phptr.com //
// //
// FileName : ddsurf.cpp //
// Description: DirectDraw surface wrapper //
// Version : 1.00.000, May 31, 2000 //
//-----------------------------------------------------------------------------------//
#define STRICT
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdio.h>
#include <assert.h>
#include <ddraw.h>
#include <d3d.h>
#include "basicdib.h"
#include "ddsurf.h"
#include "ddwrap.h"
KDDSurface::KDDSurface()
{
m_pSurface = NULL;
m_hDC = NULL;
memset(& m_ddsd, 0, sizeof(m_ddsd));
m_ddsd.dwSize = sizeof(m_ddsd);
}
void KDDSurface::Discharge(void) // release before destructor
{
ReleaseDC();
SAFE_RELEASE(m_pSurface);
}
BYTE * KDDSurface::LockSurface(RECT * pRect)
{
if ( FAILED(m_pSurface->Lock(pRect, & m_ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL)) )
return NULL;
else
return (BYTE *) m_ddsd.lpSurface;
}
const DDSURFACEDESC2 * KDDSurface::GetSurfaceDesc(void)
{
if ( SUCCEEDED(m_pSurface->GetSurfaceDesc(& m_ddsd)) )
return & m_ddsd;
else
return NULL;
}
HRESULT KDDSurface::Unlock(RECT * pRect)
{
m_ddsd.lpSurface = NULL; // make it unavailable
return m_pSurface->Unlock(pRect);
}
HRESULT KDDSurface::RestoreSurface(void) // restore if lost
{
if ( m_pSurface )
if ( m_pSurface->IsLost() )
return m_pSurface->Restore();
else
return DD_OK;
else
return E_FAIL;
}
HRESULT KDDSurface::GetDC(void)
{
return m_pSurface->GetDC(&m_hDC);
}
HRESULT KDDSurface::ReleaseDC(void)
{
if ( m_hDC==NULL )
return S_OK;
HRESULT hr = m_pSurface->ReleaseDC(m_hDC);
m_hDC = NULL;
return hr;
}
HRESULT KDDSurface::CreatePrimarySurface(IDirectDraw7 * pDD, int nBufferCount)
{
if ( nBufferCount==0 )
{
m_ddsd.dwFlags = DDSD_CAPS;
m_ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
}
else
{
m_ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
m_ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX |
DDSCAPS_VIDEOMEMORY;
m_ddsd.dwBackBufferCount = nBufferCount;
}
return pDD->CreateSurface(& m_ddsd, & m_pSurface, NULL);
}
HRESULT SetPixelFormat(DDPIXELFORMAT & pixelformat, int bpp)
{
memset(& pixelformat, 0, sizeof(pixelformat));
pixelformat.dwSize = sizeof(pixelformat);
switch ( bpp )
{
case 1 :
pixelformat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED1;
pixelformat.dwRGBBitCount = 1;
break;
case 2 :
pixelformat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED2;
pixelformat.dwRGBBitCount = 2;
break;
case 4 :
pixelformat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED4;
pixelformat.dwRGBBitCount = 4;
break;
case 8 :
pixelformat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
pixelformat.dwRGBBitCount = 8;
break;
case 15: // 1-5-5-5
pixelformat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
pixelformat.dwRGBBitCount = 16;
pixelformat.dwRGBAlphaBitMask = 0x00008000;
pixelformat.dwRBitMask = 0x00007C00;
pixelformat.dwGBitMask = 0x000003E0;
pixelformat.dwBBitMask = 0x0000001F;
break;
case 16: // 0-5-6-5
pixelformat.dwFlags = DDPF_RGB;
pixelformat.dwRGBBitCount = 16;
pixelformat.dwRGBAlphaBitMask = 0x00000000;
pixelformat.dwRBitMask = 0x0000F800;
pixelformat.dwGBitMask = 0x000007E0;
pixelformat.dwBBitMask = 0x0000001F;
break;
case 24: // 0-8-8-8
pixelformat.dwFlags = DDPF_RGB;
pixelformat.dwRGBBitCount = 24;
pixelformat.dwRGBAlphaBitMask = 0x00000000;
pixelformat.dwRBitMask = 0x00FF0000;
pixelformat.dwGBitMask = 0x0000FF00;
pixelformat.dwBBitMask = 0x000000FF;
break;
case 32: // 8-8-8-8
pixelformat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
pixelformat.dwRGBBitCount = 32;
pixelformat.dwRGBAlphaBitMask = 0xFF000000;
pixelformat.dwRBitMask = 0x00FF0000;
pixelformat.dwGBitMask = 0x0000FF00;
pixelformat.dwBBitMask = 0x000000FF;
break;
default:
return E_FAIL;
}
return S_OK;
}
const DWORD MEMFLAGS[] =
{
0,
DDSCAPS_SYSTEMMEMORY,
DDSCAPS_NONLOCALVIDMEM | DDSCAPS_VIDEOMEMORY,
DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY
};
HRESULT KOffScreenSurface::CreateOffScreenSurfaceBpp(IDirectDraw7 * pDD, int width, int height, int bpp, int mem)
{
m_ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
m_ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | MEMFLAGS[mem];
m_ddsd.dwWidth = width;
m_ddsd.dwHeight = height;
if ( SUCCEEDED(SetPixelFormat(m_ddsd.ddpfPixelFormat, bpp)) )
return pDD->CreateSurface(& m_ddsd, & m_pSurface, NULL);
else
return E_FAIL;
}
HRESULT KOffScreenSurface::CreateOffScreenSurface(IDirectDraw7 * pDD, int width, int height, int mem)
{
m_ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
m_ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | MEMFLAGS[mem];
m_ddsd.dwWidth = width;
m_ddsd.dwHeight = height;
return pDD->CreateSurface(& m_ddsd, & m_pSurface, NULL);
}
HRESULT CALLBACK TextureCallback(DDPIXELFORMAT* pddpf, void * param)
{
// find a simple >=16-bpp texture format
if ( (pddpf->dwFlags & (DDPF_LUMINANCE|DDPF_BUMPLUMINANCE|DDPF_BUMPDUDV|DDPF_ALPHAPIXELS))==0 )
if ( (pddpf->dwFourCC == 0) && (pddpf->dwRGBBitCount>=16) )
{
memcpy(param, pddpf, sizeof(DDPIXELFORMAT) );
return DDENUMRET_CANCEL; // stop search
}
return DDENUMRET_OK; // continue
}
HRESULT KOffScreenSurface::CreateTextureSurface(IDirect3DDevice7 * pD3DDevice, IDirectDraw7 * pDD, unsigned width, unsigned height)
{
// query device caps
D3DDEVICEDESC7 ddDesc;
HRESULT hr = pD3DDevice->GetCaps(&ddDesc);
if ( FAILED(hr) )
return hr;
m_ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH |
DDSD_PIXELFORMAT | DDSD_TEXTURESTAGE;
m_ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
m_ddsd.dwWidth = width;
m_ddsd.dwHeight = height;
// Turn on texture management for hardware devices
if ( (ddDesc.deviceGUID == IID_IDirect3DHALDevice) ||
(ddDesc.deviceGUID == IID_IDirect3DTnLHalDevice) )
m_ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE;
else
m_ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
// Adjust width and height, if the driver requires it
if ( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2 )
{
for ( m_ddsd.dwWidth=1; width > m_ddsd.dwWidth; m_ddsd.dwWidth<<=1 );
for ( m_ddsd.dwHeight=1; height > m_ddsd.dwHeight; m_ddsd.dwHeight<<=1 );
}
if ( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_SQUAREONLY )
{
if ( m_ddsd.dwWidth > m_ddsd.dwHeight )
m_ddsd.dwHeight = m_ddsd.dwWidth;
else
m_ddsd.dwWidth = m_ddsd.dwHeight;
}
memset(& m_ddsd.ddpfPixelFormat, 0, sizeof(m_ddsd.ddpfPixelFormat));
pD3DDevice->EnumTextureFormats(TextureCallback, & m_ddsd.ddpfPixelFormat);
if ( m_ddsd.ddpfPixelFormat.dwRGBBitCount )
return pDD->CreateSurface( & m_ddsd, & m_pSurface, NULL );
else
return E_FAIL;
}
HRESULT KDDSurface::DrawBitmap(const BITMAPINFO * pDIB, int x, int y, int w, int h)
{
if ( SUCCEEDED(GetDC()) )
{
StretchDIBits(m_hDC, x, y, w, h,
0, 0, pDIB->bmiHeader.biWidth, pDIB->bmiHeader.biHeight,
& pDIB->bmiColors[GetDIBColorCount(pDIB)], pDIB, DIB_RGB_COLORS, SRCCOPY);
return ReleaseDC();
}
else
return E_FAIL;
}
HRESULT KOffScreenSurface::CreateTextureSurface(IDirect3DDevice7 * pD3DDevice, IDirectDraw7 * pDD, const BITMAPINFO * pDIB)
{
if ( pDIB==NULL )
HRESULT hr = CreateTextureSurface(pD3DDevice, pDD, pDIB->bmiHeader.biWidth, pDIB->bmiHeader.biHeight);
if ( FAILED(hr) )
return hr;
return DrawBitmap(pDIB, 0, 0, m_ddsd.dwWidth, m_ddsd.dwHeight);
}
HRESULT KOffScreenSurface::CreateTextureSurface(IDirect3DDevice7 * pD3DDevice, IDirectDraw7 * pDD, const TCHAR * pFileName)
{
BITMAPINFO * pDIB = LoadBMPFile(pFileName);
if ( pDIB )
{
HRESULT hr = CreateTextureSurface(pD3DDevice, pDD, pDIB);
delete [] (BYTE *) pDIB;
return hr;
}
else
return E_FAIL;
}
HRESULT KOffScreenSurface::CreateBitmapSurface(IDirectDraw7 * pDD, const BITMAPINFO * pDIB, int mem)
{
if ( pDIB==NULL )
return E_FAIL;
HRESULT hr = CreateOffScreenSurface(pDD, pDIB->bmiHeader.biWidth, abs(pDIB->bmiHeader.biHeight), mem);
if ( FAILED(hr) )
return hr;
return DrawBitmap(pDIB, 0, 0, m_ddsd.dwWidth, m_ddsd.dwHeight);
}
HRESULT KOffScreenSurface::CreateBitmapSurface(IDirectDraw7 * pDD, const TCHAR * pFileName, int mem)
{
BITMAPINFO * pDIB = LoadBMPFile(pFileName);
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -