gameimageengine.cpp

本游戏是一款单机版的坦克大战游戏

//////////////////////////////////////////////////////////////////////////////////////////////////
//      #                                                                               #       //
//		#		* File Name:	GameImageEngine.cpp										#	    //
//		#																				#	    //
//		#		* Function:		the image engine of the game							#	    //
//		#																				#	    //
//		#		* Instruction:	Created by JIAN NAN FEI 2008 8 29						#	    //
//      #                                                                               #       //
///////////////////////////////////////////////////////////////////////////////////////////////////

//----------------------------------------------------------------------------------------------//
//										DEFINES REFERENCES HERE									//
//----------------------------------------------------------------------------------------------//

	#define WIN32_LEAN_AND_MEAN
	#ifndef WIN32_LEAN_AND_MEAN
	#endif

//----------------------------------------------------------------------------------------------//
//										HEADFILES REFERENCES HERE								//
//----------------------------------------------------------------------------------------------//

	#include <windows.h>
	#include <windowsx.h>
	#include <ddraw.h>
	#include "GameImageEngine.h"

//----------------------------------------------------------------------------------------------//
//										GLOBAL MEMBER VARIAYS REFERENCES HERE					//
//----------------------------------------------------------------------------------------------//


//----------------------------------------------------------------------------------------------//
//										FUNCTION MEMBERS REFERENCES HERE						//
//----------------------------------------------------------------------------------------------//


//----------------------------------------------------------------------------------------------//
//										FUNCTION MEMBERS COMPLISHMENT							//
//----------------------------------------------------------------------------------------------//

//-----------------------------------------------------------------------------
// Name: DDLoadBitmap()
// Desc: Create a DirectDrawSurface from a bitmap resource.
//-----------------------------------------------------------------------------

	extern "C" IDirectDrawSurface *
	DDLoadBitmap(IDirectDraw * pdd, LPCSTR szBitmap, int dx, int dy)
	{
		HBITMAP                 hbm;
		BITMAP                  bm;
		DDSURFACEDESC         ddsd;
		IDirectDrawSurface    *pdds;

		//
		//  Try to load the bitmap as a resource, if that fails, try it as a file
		//
		hbm = (HBITMAP) LoadImage(GetModuleHandle(NULL), szBitmap, IMAGE_BITMAP, dx,
								  dy, LR_CREATEDIBSECTION);
		if (hbm == NULL)
			hbm = (HBITMAP) LoadImage(NULL, szBitmap, IMAGE_BITMAP, dx, dy,
									  LR_LOADFROMFILE | LR_CREATEDIBSECTION);
		if (hbm == NULL)
		{
			OutputDebugString("the handle is null!\n");
			return NULL;
		}
		//
		// Get size of the bitmap
		//
		GetObject(hbm, sizeof(bm), &bm);
		//
		// Create a DirectDrawSurface for this bitmap
		//
		ZeroMemory(&ddsd, sizeof(ddsd));
		ddsd.dwSize			= sizeof(ddsd);
		ddsd.dwFlags		= DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
		ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
		ddsd.dwWidth		= bm.bmWidth;
		ddsd.dwHeight		= bm.bmHeight;
		if (pdd->CreateSurface(&ddsd, &pdds, NULL) != DD_OK)
			return NULL;
		DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
		DeleteObject(hbm);
		return pdds;
	}

//-----------------------------------------------------------------------------
// Name: DDReLoadBitmap()
// Desc: Load a bitmap from a file or resource into a directdraw surface.
//       normaly used to re-load a surface after a restore.
//-----------------------------------------------------------------------------

	HRESULT DDReLoadBitmap(IDirectDrawSurface * pdds, LPCSTR szBitmap)
	{
		HBITMAP                 hbm;
		HRESULT                 hr;

		//
		//  Try to load the bitmap as a resource, if that fails, try it as a file
		//
		hbm = (HBITMAP) LoadImage(GetModuleHandle(NULL), szBitmap, IMAGE_BITMAP, 0,
								  0, LR_CREATEDIBSECTION);
		if (hbm == NULL)
			hbm = (HBITMAP) LoadImage(NULL, szBitmap, IMAGE_BITMAP, 0, 0,
									  LR_LOADFROMFILE | LR_CREATEDIBSECTION);
		if (hbm == NULL)
		{
			OutputDebugString("handle is null\n");
			return E_FAIL;
		}
		hr = DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
		if (hr != DD_OK)
		{
			OutputDebugString("ddcopybitmap failed\n");
		}
		DeleteObject(hbm);
		return hr;
	}

//-----------------------------------------------------------------------------
// Name: DDCopyBitmap()
// Desc: Draw a bitmap into a DirectDrawSurface
//-----------------------------------------------------------------------------

	extern "C" HRESULT
	DDCopyBitmap(IDirectDrawSurface * pdds, HBITMAP hbm, int x, int y,int dx, int dy)
	{
		HDC                     hdcImage;
		HDC                     hdc;
		BITMAP                  bm;
		DDSURFACEDESC         ddsd;
		HRESULT                 hr;

		if (hbm == NULL || pdds == NULL)
		{
			OutputDebugString("the handle is null!\n");
			return E_FAIL;
		}
		//
		// Make sure this surface is restored.
		//
		pdds->Restore();
		//
		// Select bitmap into a memoryDC so we can use it.
		//
		hdcImage = CreateCompatibleDC(NULL);
		if (!hdcImage)
			OutputDebugString("createcompatible dc failed\n");
		SelectObject(hdcImage, hbm);
		//
		// Get size of the bitmap
		//
		GetObject(hbm, sizeof(bm), &bm);
		dx = dx == 0 ? bm.bmWidth : dx;     // Use the passed size, unless zero
		dy = dy == 0 ? bm.bmHeight : dy;
		//
		// Get size of surface.
		//
		ddsd.dwSize = sizeof(ddsd);
		ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH;
		pdds->GetSurfaceDesc(&ddsd);

		if ((hr = pdds->GetDC(&hdc)) == DD_OK)
		{
			StretchBlt(hdc, 0, 0, ddsd.dwWidth, ddsd.dwHeight, hdcImage, x, y,
					   dx, dy, SRCCOPY);
			pdds->ReleaseDC(hdc);
		}
		DeleteDC(hdcImage);
		return hr;
	}

//-----------------------------------------------------------------------------
// Name: DDLoadPalette()
// Desc: Create a DirectDraw palette object from a bitmap resource
//       if the resource does not exist or NULL is passed create a
//       default 332 palette.
//-----------------------------------------------------------------------------

	extern "C" IDirectDrawPalette *
	DDLoadPalette(IDirectDraw * pdd, LPCSTR szBitmap)
	{
		IDirectDrawPalette     *ddpal;
		int                     i;
		int                     n;
		int                     fh;
		HRSRC                   h;
		LPBITMAPINFOHEADER      lpbi;
		PALETTEENTRY            ape[256];
		RGBQUAD                *prgb;

		//
		// Build a 332 palette as the default.
		//
		for (i = 0; i < 256; i++)
		{
			ape[i].peRed	= (BYTE) (((i >> 5) & 0x07) * 255 / 7);
			ape[i].peGreen	= (BYTE) (((i >> 2) & 0x07) * 255 / 7);
			ape[i].peBlue	= (BYTE) (((i >> 0) & 0x03) * 255 / 3);
			ape[i].peFlags	= (BYTE) 0;
		}
		//
		// Get a pointer to the bitmap resource.
		//
		if (szBitmap && (h = FindResource(NULL, szBitmap, RT_BITMAP)))
		{
			lpbi = (LPBITMAPINFOHEADER) LockResource(LoadResource(NULL, h));
			if (!lpbi)
				OutputDebugString("lock resource failed\n");
			prgb = (RGBQUAD *) ((BYTE *) lpbi + lpbi->biSize);
			if (lpbi == NULL || lpbi->biSize < sizeof(BITMAPINFOHEADER))
				n = 0;
			else if (lpbi->biBitCount > 8)
				n = 0;
			else if (lpbi->biClrUsed == 0)
				n = 1 << lpbi->biBitCount;
			else
				n = lpbi->biClrUsed;
			//
			//  A DIB color table has its colors stored BGR not RGB
			//  so flip them around.
			//
			for (i = 0; i < n; i++)
			{
				ape[i].peRed = prgb[i].rgbRed;
				ape[i].peGreen = prgb[i].rgbGreen;
				ape[i].peBlue = prgb[i].rgbBlue;
				ape[i].peFlags = 0;
			}
		}
		else if (szBitmap && (fh = _lopen(szBitmap, OF_READ)) != -1)
		{
			BITMAPFILEHEADER        bf;
			BITMAPINFOHEADER        bi;

			_lread(fh, &bf, sizeof(bf));
			_lread(fh, &bi, sizeof(bi));
			_lread(fh, ape, sizeof(ape));
			_lclose(fh);
			if (bi.biSize != sizeof(BITMAPINFOHEADER))
				n = 0;
			else if (bi.biBitCount > 8)
				n = 0;
			else if (bi.biClrUsed == 0)
				n = 1 << bi.biBitCount;
			else
				n = bi.biClrUsed;
			//
			//  A DIB color table has its colors stored BGR not RGB
			//  so flip them around.
			//
			for (i = 0; i < n; i++)
			{
				BYTE        r = ape[i].peRed;
				ape[i].peRed = ape[i].peBlue;
				ape[i].peBlue = r;
			}
		}
		pdd->CreatePalette(DDPCAPS_8BIT, ape, &ddpal, NULL);
		return ddpal;
	}

//-----------------------------------------------------------------------------
// Name: DDColorMatch()
// Desc: Convert a RGB color to a pysical color.
//       We do this by leting GDI SetPixel() do the color matching
//       then we lock the memory and see what it got mapped to.
//-----------------------------------------------------------------------------

	extern "C" DWORD
	DDColorMatch(IDirectDrawSurface * pdds, COLORREF rgb)
	{
		COLORREF                rgbT;
		HDC                     hdc;
		DWORD                   dw = CLR_INVALID;
		DDSURFACEDESC         ddsd;
		HRESULT                 hres;

		//
		//  Use GDI SetPixel to color match for us
		//
		if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
		{
			rgbT = GetPixel(hdc, 0, 0);     // Save current pixel value
			SetPixel(hdc, 0, 0, rgb);       // Set our value
			pdds->ReleaseDC(hdc);
		}
		//
		// Now lock the surface so we can read back the converted color
		//
		ddsd.dwSize = sizeof(ddsd);
		while ((hres = pdds->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
			;
		if (hres == DD_OK)
		{
			dw = *(DWORD *) ddsd.lpSurface;                 // Get DWORD
			if (ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
				dw &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount) - 1;  // Mask it to bpp
			pdds->Unlock(NULL);
		}
		//
		//  Now put the color that was there back.
		//
		if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
		{
			SetPixel(hdc, 0, 0, rgbT);
			pdds->ReleaseDC(hdc);
		}
		return dw;
	}




//-----------------------------------------------------------------------------
// Name: DDSetColorKey()
// Desc: Set a color key for a surface, given a RGB.
//       If you pass CLR_INVALID as the color key, the pixel
//       in the upper-left corner will be used.
//-----------------------------------------------------------------------------

	extern "C" HRESULT
	DDSetColorKey(IDirectDrawSurface * pdds, COLORREF rgb)
	{
		DDCOLORKEY              ddck;
		ddck.dwColorSpaceLowValue	= DDColorMatch(pdds, rgb);
		ddck.dwColorSpaceHighValue	= ddck.dwColorSpaceLowValue;
		return pdds->SetColorKey(DDCKEY_SRCBLT, &ddck);
	}

//----------------------------------------------------------------------------------------------//
//										COMPLISHMENT OF THE FILE    							//
//----------------------------------------------------------------------------------------------//