gssurface.cpp

来自「网络泡泡被.net管理」· C++ 代码 · 共 356 行

// GsSurface.cpp: implementation of the CGsSurface class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GSLib_Internal.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CGsSurface::CGsSurface(CGsEngine* pEngine) : CDxSurface( pEngine )
{
    m_bColorKeyed = false;
	m_dwKeyColor	= 0xffffffff;
	m_bUseVideoMem	= false;
}

CGsSurface::~CGsSurface()
{

}



//-----------------------------------------------------------------------------
// Name: Lock()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CGsSurface::BeginLock(BYTE* &pDes, LONG &lPitch)
{
	if(!m_pdds)
		return E_FAIL;
	HRESULT hr;
	DDSURFACEDESC2	ddsd;
	memset(&ddsd,0,sizeof(ddsd));
	ddsd.dwSize	= sizeof(ddsd);
	hr = m_pdds->Lock (NULL, &ddsd, DDLOCK_WAIT, NULL);
	if(FAILED(hr))
		return hr;
	pDes	= (BYTE*)ddsd.lpSurface;
	lPitch	= ddsd.lPitch;
	return hr;
}
//-----------------------------------------------------------------------------
// Name: UnLock()
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CGsSurface::EndLock()
{
	if(!m_pdds)
		return E_FAIL;
	return m_pdds->Unlock(NULL);
}


HRESULT CGsSurface::CreateEx(int width, int height, BOOL bUseVideoMem)
{
	HRESULT hr = S_OK;
	if(NULL == m_pEngine)
		return E_FAIL;
    LPDIRECTDRAW7				pDD			= m_pEngine->GetDirectDraw();				
	if(!pDD)
		return E_FAIL;
	SAFE_RELEASE(m_pdds);
	CGsFunc::DxInitSurfaceDesc(m_ddsd);
	m_ddsd.dwFlags         = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH;//|DDSD_PIXELFORMAT;
							   
	m_ddsd.ddsCaps.dwCaps  = DDSCAPS_OFFSCREENPLAIN;//|DDSCAPS_VIDEOMEMORY;
	m_ddsd.ddsCaps.dwCaps2 = 0L;
	m_ddsd.dwWidth         = width;
	m_ddsd.dwHeight        = height;
	m_isUseVideoMemory	= bUseVideoMem;
	if( !m_isUseVideoMemory )
		m_ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
    hr = pDD->CreateSurface( &m_ddsd, &m_pdds, NULL );
    if( FAILED(hr) )
        return hr;
	m_isDismiss	= false;
	m_ddsd.dwSize = sizeof(m_ddsd);
	m_pdds->GetSurfaceDesc( &m_ddsd );

	m_dxsf	= D3DXMakeSurfaceFormat( &m_ddsd.ddpfPixelFormat );
	m_dwColorCount	= m_ddsd.ddpfPixelFormat.dwRGBBitCount;

	m_bUseVideoMem	= bUseVideoMem;

	OnCreate();
	return hr;
}

HRESULT CGsSurface::CreateEx(PIXMAP const& pixmap, BOOL bUseVideoMem)
{
	HRESULT hr = S_OK;

	return hr;
}


HRESULT CGsSurface::CreateFromBitmap( const TCHAR* strBMP, DWORD dwDesiredWidth, DWORD dwDesiredHeight, BOOL bUseVideoMem, DWORD KeyColor )
{
	HRESULT hr = S_OK;

	{
//		// Attempt to load bitmap as a file
//		BITMAPFILEHEADER  bf;
//		BITMAPINFOHEADER  bi;
//		HANDLE            hFile = NULL;
//		DWORD			  dwBytesRead;
//		hFile = CreateFile( strBMP, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
//		if( NULL == hFile )
//			return E_FAIL;
//
//		// Read the BITMAPFILEHEADER
//		ReadFile( hFile, &bf, sizeof(bf), &dwBytesRead, NULL );
//		if( dwBytesRead != sizeof(bf) )
//		{
//			CloseHandle( hFile );
//			return E_FAIL;
//		}
//
//		// Read the BITMAPINFOHEADER
//		ReadFile( hFile, &bi, sizeof(bi), &dwBytesRead, NULL );
//		if( dwBytesRead != sizeof(bi) )
//		{
//			CloseHandle( hFile );
//			return E_FAIL;
//		}
//		CloseHandle( hFile );

		HBITMAP			hBMP = NULL;
		BITMAP			bmp;
		DWORD			width = 0;
		DWORD			height = 0;
		//  Try to load the bitmap as a resource, if that fails, try it as a file
		hBMP = (HBITMAP) LoadImage( GetModuleHandle(NULL), strBMP, 
									IMAGE_BITMAP, width, height, 
									LR_CREATEDIBSECTION );
		if( hBMP == NULL )
		{
			hBMP = (HBITMAP) LoadImage( NULL, strBMP, 
										IMAGE_BITMAP, width, height, 
										LR_LOADFROMFILE | LR_CREATEDIBSECTION );
			if( hBMP == NULL )
				return E_FAIL;
		}

		// Get size of the bitmap
		GetObject( hBMP, sizeof(bmp), &bmp );
		
		if(0==dwDesiredWidth)
			dwDesiredWidth	= bmp.bmWidth;
		if(0==dwDesiredHeight)
			dwDesiredHeight	= bmp.bmHeight;

		DeleteObject( hBMP );
		
	}


	CreateEx( dwDesiredWidth, dwDesiredHeight, bUseVideoMem );

	DrawBitmap( strBMP, dwDesiredWidth, dwDesiredHeight );

	if( KeyColor!=0xffffffff )
	{
		SetColorKey(KeyColor);
	}

	OnCreate();
	return hr;
}


//-----------------------------------------------------------------------------
// Name: 
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CGsSurface::SetColorKey( COLORREF dwColorKey )
{
    if( NULL == m_pdds )
        return E_POINTER;

    m_bColorKeyed = TRUE;
	m_dwKeyColor	= dwColorKey;

    DDCOLORKEY ddck;
    ddck.dwColorSpaceLowValue  = this->ConvertGDIColor( dwColorKey );
    ddck.dwColorSpaceHighValue = ConvertGDIColor( dwColorKey);
    
    return m_pdds->SetColorKey( DDCKEY_SRCBLT, &ddck );
}


//-----------------------------------------------------------------------------
// Name: CGsSurface::ConvertGDIColor()
// Desc: Converts a GDI color (0x00bbggrr) into the equivalent color on a 
//       DirectDrawSurface using its pixel format.  
//-----------------------------------------------------------------------------
DWORD CGsSurface::ConvertGDIColor( COLORREF dwGDIColor )
{
    if( m_pdds == NULL )
	    return 0x00000000;

    COLORREF       rgbT;
    HDC            hdc;
    DWORD          dw = CLR_INVALID;
    DDSURFACEDESC2 ddsd;
    HRESULT        hr;

    //  Use GDI SetPixel to color match for us
    if( dwGDIColor != CLR_INVALID && m_pdds->GetDC(&hdc) == DD_OK)
    {
        rgbT = GetPixel(hdc, 0, 0);     // Save current pixel value
        SetPixel(hdc, 0, 0, dwGDIColor);       // Set our value
        m_pdds->ReleaseDC(hdc);
    }

    // Now lock the surface so we can read back the converted color
    ddsd.dwSize = sizeof(ddsd);
    hr = m_pdds->Lock( NULL, &ddsd, DDLOCK_WAIT, NULL );
    if( hr == DD_OK)
    {
        dw = *(DWORD *) ddsd.lpSurface; 
        if( ddsd.ddpfPixelFormat.dwRGBBitCount < 32 ) // Mask it to bpp
            dw &= ( 1 << ddsd.ddpfPixelFormat.dwRGBBitCount ) - 1;  
        m_pdds->Unlock(NULL);
    }

    //  Now put the color that was there back.
    if( dwGDIColor != CLR_INVALID && m_pdds->GetDC(&hdc) == DD_OK )
    {
        SetPixel( hdc, 0, 0, rgbT );
        m_pdds->ReleaseDC(hdc);
    }
    
    return dw;    
}


BOOL CGsSurface::SetStreamSource(const char *strSource)
{
	if(m_keySource==strSource)
		return TRUE;
	Cleanup();
	m_keySource	= strSource;
	return TRUE;

}

HRESULT CGsSurface::RestoreObjects()
{
	if(m_pdds!=NULL)
		return S_OK;
	HRESULT hr;

	char str[PATH_SIZE];
	strcpy(str, m_keySource.c_str());


	GSFILE_INFO* file_info = m_pEngine->FindSource(m_keySource.c_str());
	if(file_info)
	{
		switch(file_info->fft)
		{
		case GSF_JPG:
			{
				hr = CreateFromJPEG(file_info->strFile);
				if(FAILED(hr))
					return hr;
			}
			break;
		case GSF_TGA:
			{
			}
			break;
		case GSF_GIF:
			{
			}
			break;
//		case GSF_PGG:
//			return E_FAIL;
//			break;
//		case GSF_TXG:
//			return E_FAIL;
//			break;
//		case GSF_INI:
//			return E_FAIL;
//			break;
//		case GSF_TXT:
//			return FALSE;
//			break;
		default:
			return E_FAIL;
			break;
		}
	}
	else
	{
		GSFBUF gsbuf = CGsFunc::GSFBUF_Create(m_keySource.c_str(), "rb");
		if(gsbuf.p_fstream!=NULL)
		{
			switch(CGsFunc::File_GetFFT(m_keySource.c_str()))
			{
			case GSF_JPG:
				{
					hr = CreateFromJPEG(m_keySource.c_str());
					if(FAILED(hr))
						return hr;
				}
				break;
			default:
				return E_FAIL;
				break;
			}

		}
		else
		{

		}	
	}

	return S_OK;

}

HRESULT CGsSurface::CreateFromJPEG(const char* strFile)
{
	HRESULT hr;
	GSFBUF fbuf = CGsFunc::GSFBUF_Create(strFile, "rb");
	if(fbuf.p_fstream==NULL)
		return E_FAIL;
	SIZE size = CGsFunc::FileGetJpegSize(&fbuf);
	if(FAILED(hr=CreateEx(size.cx, size.cy, m_bUseVideoMem)))
	{
		fclose(fbuf.p_fstream);
		return hr;
	}
	if(FAILED(hr=LoadFromJpegFile(&fbuf)))
	{
		fclose(fbuf.p_fstream);
		return hr;
	}
	fclose(fbuf.p_fstream);

	return hr;
}


VOID CGsSurface::ReleaseObjects()
{
	SAFE_RELEASE(m_pdds);
}