ddsurf.cpp

来自「Windows 图形编程 书籍」· C++ 代码 · 共 674 行 · 第 1/2 页

//-----------------------------------------------------------------------------------//
//              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 )
		return E_FAIL;

	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);