direct~2.cpp

一个简单的rpg游戏

	if (depth==8)
	{
		primsurf->GetPalette( &palette );
		palette->GetEntries( 0, 0, 256, pe );
		for (int i=0;i<256;i++)
		{
			quads[i].rgbRed   = pe[i].peRed;
			quads[i].rgbGreen = pe[i].peGreen;
			quads[i].rgbBlue  = pe[i].peBlue;
		}
	}

	FILE* fp=fopen( filename, "wb" );
	fwrite( &filehdr, sizeof(filehdr), 1, fp );
	fwrite( &infohdr, sizeof(infohdr), 1, fp );
	if (depth==8)
		fwrite( quads, sizeof(RGBQUAD), 256, fp );

	BOOL ret=FALSE;

	if (depth==8)
		ret=SaveSurface08( surf, fp, width, height );
	else if (depth==16)
		ret=SaveSurface16( surf, fp, width, height );
	else if (depth==24)
		ret=SaveSurface24( surf, fp, width, height );
	else if (depth==32)
		ret=SaveSurface32( surf, fp, width, height );
	else
		ASSERT(FALSE);

	fclose(fp);

	return ret;
}

BOOL DirectDrawWin::SaveSurface08(LPDIRECTDRAWSURFACE surf, FILE* fp, DWORD w, DWORD h)
{
	ASSERT(surf);
	ASSERT(fp);

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize=sizeof(desc);
	HRESULT r;
	r=surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_READONLY, 0 );
	if (r!=DD_OK)
	{
		TRACE("SaveSurface(): Lock() failed\n");
		return FALSE;
	}

	int fillerbytes=((w+3) & ~3)-w;
	BYTE filler[]={0,0,0};

	for (int row=h-1;row>=0;row--)
	{
		BYTE* surfrow=(BYTE*)desc.lpSurface+row*desc.lPitch;
		fwrite( surfrow, w, 1, fp );
		fwrite( filler, 1, fillerbytes, fp );
	}
	surf->Unlock( 0 );

	return TRUE;
}

BOOL DirectDrawWin::SaveSurface16(LPDIRECTDRAWSURFACE surf, FILE* fp, DWORD w, DWORD h)
{
	ASSERT(surf);
	ASSERT(fp);

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize=sizeof(desc);
	HRESULT r;
	r=surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_READONLY, 0 );
	if (r!=DD_OK)
	{
		TRACE("SaveSurface(): Lock() failed\n");
		return FALSE;
	}
	
	int bytesrequired=w*3;
	int bytesgiven=(bytesrequired+3) & ~3;
	int fillerbytes=bytesgiven-bytesrequired;
	BYTE filler[]={0,0,0};

	RGBTRIPLE* bmpbuffer=new RGBTRIPLE[w];
	
	int rmult = (numREDbits  ==5) ? 8 : 4;
	int gmult = (numGREENbits==5) ? 8 : 4;
	int bmult = (numBLUEbits ==5) ? 8 : 4;

	for (int row=h-1;row>=0;row--)
	{
		WORD* surfpixel=(WORD*)((BYTE*)desc.lpSurface+row*desc.lPitch);
		RGBTRIPLE* bmppixel=bmpbuffer;

		for (DWORD col=0;col<w;col++)
		{
			WORD r = (*surfpixel & (WORD)desc.ddpfPixelFormat.dwRBitMask) >> loREDbit;
			WORD g = (*surfpixel & (WORD)desc.ddpfPixelFormat.dwGBitMask) >> loGREENbit;
			WORD b = (*surfpixel & (WORD)desc.ddpfPixelFormat.dwBBitMask) >> loBLUEbit;
			
			bmppixel->rgbtRed   = (BYTE)(r * rmult);
			bmppixel->rgbtGreen = (BYTE)(g * gmult);
			bmppixel->rgbtBlue  = (BYTE)(b * bmult);
			
			surfpixel++;
			bmppixel++;
		}
		fwrite( bmpbuffer, sizeof(RGBTRIPLE), w, fp );
		fwrite( filler, 1, fillerbytes, fp );
	}

	delete [] bmpbuffer;
	surf->Unlock( 0 );

	return TRUE;
}

BOOL DirectDrawWin::SaveSurface24(LPDIRECTDRAWSURFACE surf, FILE* fp, DWORD w, DWORD h)
{
	ASSERT(surf);
	ASSERT(fp);

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize=sizeof(desc);
	HRESULT r;
	r=surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_READONLY, 0 );
	if (r!=DD_OK)
	{
		TRACE("SaveSurface(): Lock() failed\n");
		return FALSE;
	}
	
	int bytesrequired=w*3;
	int bytesgiven=(bytesrequired+3) & ~3;
	int fillerbytes=bytesgiven-bytesrequired;
	BYTE filler[]={0,0,0};

	RGBTRIPLE* bmpbuffer=new RGBTRIPLE[w];
	
	for (int row=h-1;row>=0;row--)
	{
		RGBTRIPLE* surfpixel=(RGBTRIPLE*)((BYTE*)desc.lpSurface+row*desc.lPitch);
		RGBTRIPLE* bmppixel=bmpbuffer;

		for (DWORD col=0;col<w;col++)
		{
			DWORD r = (*(DWORD*)surfpixel & desc.ddpfPixelFormat.dwRBitMask) >> loREDbit;
			DWORD g = (*(DWORD*)surfpixel & desc.ddpfPixelFormat.dwGBitMask) >> loGREENbit;
			DWORD b = (*(DWORD*)surfpixel & desc.ddpfPixelFormat.dwBBitMask) >> loBLUEbit;
			
			bmppixel->rgbtRed   = (BYTE)r;
			bmppixel->rgbtGreen = (BYTE)g;
			bmppixel->rgbtBlue  = (BYTE)b;
			
			surfpixel++;
			bmppixel++;
		}
		fwrite( bmpbuffer, sizeof(RGBTRIPLE), w, fp );
		fwrite( filler, 1, fillerbytes, fp );
	}

	delete [] bmpbuffer;
	surf->Unlock( 0 );

	return TRUE;
}

BOOL DirectDrawWin::SaveSurface32(LPDIRECTDRAWSURFACE surf, FILE* fp, DWORD w, DWORD h)
{
	ASSERT(surf);
	ASSERT(fp);

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize=sizeof(desc);
	HRESULT r;
	r=surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_READONLY, 0 );
	if (r!=DD_OK)
	{
		TRACE("SaveSurface(): Lock() failed\n");
		return FALSE;
	}
	
	int bytesrequired=w*3;
	int bytesgiven=(bytesrequired+3) & ~3;
	int fillerbytes=bytesgiven-bytesrequired;
	BYTE filler[]={0,0,0};

	RGBTRIPLE* bmpbuffer=new RGBTRIPLE[w];
	
	for (int row=h-1;row>=0;row--)
	{
		RGBQUAD* surfpixel=(RGBQUAD*)((BYTE*)desc.lpSurface+row*desc.lPitch);
		RGBTRIPLE* bmppixel=bmpbuffer;

		for (DWORD col=0;col<w;col++)
		{
			DWORD r = (*(DWORD*)surfpixel & desc.ddpfPixelFormat.dwRBitMask) >> loREDbit;
			DWORD g = (*(DWORD*)surfpixel & desc.ddpfPixelFormat.dwGBitMask) >> loGREENbit;
			DWORD b = (*(DWORD*)surfpixel & desc.ddpfPixelFormat.dwBBitMask) >> loBLUEbit;
			
			bmppixel->rgbtRed   = (BYTE)r;
			bmppixel->rgbtGreen = (BYTE)g;
			bmppixel->rgbtBlue  = (BYTE)b;
			
			surfpixel++;
			bmppixel++;
		}
		fwrite( bmpbuffer, sizeof(RGBTRIPLE), w, fp );
		fwrite( filler, 1, fillerbytes, fp );
	}

	delete [] bmpbuffer;
	surf->Unlock( 0 );

	return TRUE;
}

BOOL DirectDrawWin::StorePixelFormatData()
{
	DDPIXELFORMAT format;
	ZeroMemory( &format, sizeof(format) );
	format.dwSize=sizeof(format);
	if (primsurf->GetPixelFormat( &format )!=DD_OK)
	{
		TRACE("StorePixelFormatData() failed\n");
		return FALSE;
	}

	loREDbit = LowBitPos( format.dwRBitMask );
	WORD hiREDbit = HighBitPos( format.dwRBitMask );
	numREDbits=(WORD)(hiREDbit-loREDbit+1);

	loGREENbit = LowBitPos( format.dwGBitMask );
	WORD hiGREENbit = HighBitPos( format.dwGBitMask );
	numGREENbits=(WORD)(hiGREENbit-loGREENbit+1);

	loBLUEbit  = LowBitPos( format.dwBBitMask );
	WORD hiBLUEbit  = HighBitPos( format.dwBBitMask );
	numBLUEbits=(WORD)(hiBLUEbit-loBLUEbit+1);

	return TRUE;
}

void DirectDrawWin::CheckResult( HRESULT result )
{
	TRACE("DirectDraw error: ");
	switch ( result )
	{
	case DD_OK:
		TRACE("ok\n");
		break;
	case DDERR_ALREADYINITIALIZED:
		TRACE("DDERR_ALREADYINITIALIZED\n");
		break;
	case DDERR_BLTFASTCANTCLIP:
		TRACE("DDERR_BLTFASTCANTCLIP\n");
		break;
	case DDERR_CANNOTATTACHSURFACE:
		TRACE("DDERR_CANNOTATTACHSURFACE\n");
		break;
	case DDERR_CANNOTDETACHSURFACE:
		TRACE("DDERR_CANNOTDETACHSURFACE\n");
		break;
	case DDERR_CANTCREATEDC:
		TRACE("DDERR_CANTCREATEDC\n");
		break;
	case DDERR_CANTDUPLICATE:
		TRACE("DDERR_CANTDUPLICATE\n");
		break;
	case DDERR_CANTLOCKSURFACE:
		TRACE("DDERR_CANTLOCKSURFACE\n");
		break;
	case DDERR_CANTPAGELOCK:
		TRACE("DDERR_CANTPAGELOCK\n");
		break;
	case DDERR_CANTPAGEUNLOCK:
		TRACE("DDERR_CANTPAGEUNLOCK\n");
		break;
	case DDERR_CLIPPERISUSINGHWND:
		TRACE("DDERR_CLIPPERISUSINGHWND\n");
		break;
	case DDERR_COLORKEYNOTSET:
		TRACE("DDERR_COLORKEYNOTSET\n");
		break;
	case DDERR_CURRENTLYNOTAVAIL:
		TRACE("DDERR_CURRENTLYNOTAVAIL\n");
		break;
	case DDERR_DCALREADYCREATED:
		TRACE("DDERR_DCALREADYCREATED\n");
		break;
	case DDERR_DIRECTDRAWALREADYCREATED:
		TRACE("DDERR_DIRECTDRAWALREADYCREATED\n");
		break;
	case DDERR_EXCEPTION:
		TRACE("DDERR_EXCEPTION\n");
		break;
	case DDERR_EXCLUSIVEMODEALREADYSET:
		TRACE("DDERR_EXCLUSIVEMODEALREADYSET\n");
		break;
	case DDERR_GENERIC:
		TRACE("DDERR_GENERIC\n"); 
		break;
	case DDERR_HEIGHTALIGN:
		TRACE("DDERR_HEIGHTALIGN\n");
		break;
	case DDERR_HWNDALREADYSET:
		TRACE("DDERR_HWNDALREADYSET\n");
		break;
	case DDERR_HWNDSUBCLASSED:
		TRACE("DDERR_HWNDSUBCLASSED\n");
		break;
	case DDERR_IMPLICITLYCREATED:
		TRACE("DDERR_IMPLICITLYCREATED\n");
		break;
	case DDERR_INCOMPATIBLEPRIMARY:
		TRACE("Incampatible Primary\n"); 
		break;
	case DDERR_INVALIDCAPS:
		TRACE("DDERR_INVALIDCAPS\n");
		break;
	case DDERR_INVALIDCLIPLIST:
		TRACE("DDERR_INVALIDCLIPLIST\n");
		break;
	case DDERR_INVALIDDIRECTDRAWGUID:
		TRACE("DDERR_INVALIDDIRECTDRAWGUID\n");
		break;
	case DDERR_INVALIDMODE:
		TRACE("DDERR_INVALIDMODE\n");
		break;
	case DDERR_INVALIDOBJECT:
		TRACE("DDERR_INVALIDOBJECT\n");
		break;
	case DDERR_INVALIDPARAMS:
		TRACE("DDERR_INVALIDPARAMS\n");
		break;
	case DDERR_INVALIDPIXELFORMAT:
		TRACE("DDERR_INVALIDPIXELFORMAT\n");
		break;
	case DDERR_INVALIDPOSITION:
		TRACE("DDERR_INVALIDPOSITION\n");
		break;
	case DDERR_INVALIDRECT:
		TRACE("DDERR_INVALIDRECT\n");
		break;
	case DDERR_INVALIDSURFACETYPE:
		TRACE("DDERR_INVALIDSURFACETYPE\n");
		break;
	case DDERR_LOCKEDSURFACES:
		TRACE("DDERR_LOCKEDSURFACES\n");
		break;
//	case DDERR_MOREDATA:
//		TRACE("DDERR_MOREDATA\n");
//		break;
	case DDERR_NO3D:
		TRACE("DDERR_NO3D\n");
		break;
	case DDERR_NOALPHAHW:
		TRACE("DDERR_NOALPHAHW\n");
		break;
	case DDERR_NOBLTHW:
		TRACE("DDERR_NOBLTHW\n");
		break;
	case DDERR_NOCLIPLIST:
		TRACE("DDERR_NOCLIPLIST\n");
		break;
	case DDERR_NOCLIPPERATTACHED:
		TRACE("DDERR_NOCLIPPERATTACHED\n");
		break;
	case DDERR_NOCOLORCONVHW:
		TRACE("DDERR_NOCOLORCONVHW\n");
		break;
	case DDERR_NOCOLORKEY:
		TRACE("DDERR_NOCOLORKEY\n");
		break;
	case DDERR_NOCOLORKEYHW:
		TRACE("no colorkey hardware\n");
		break;
	case DDERR_NOCOOPERATIVELEVELSET:
		TRACE("DDERR_NOCOOPERATIVELEVELSET\n");
		break;
	case DDERR_NODC:
		TRACE("DDERR_NODC\n");
		break;
	case DDERR_NODDROPSHW:
		TRACE("DDERR_NODDROPSHW\n");
		break;
	case DDERR_NODIRECTDRAWHW:
		TRACE("DDERR_NODIRECTDRAWHW\n");
		break;
	case DDERR_NODIRECTDRAWSUPPORT:
		TRACE("DDERR_NODIRECTDRAWSUPPORT\n");
		break;
	case DDERR_NOEMULATION:
		TRACE("DDERR_NOEMULATION\n");
		break;
	case DDERR_NOEXCLUSIVEMODE:
		TRACE("DDERR_NOEXCLUSIVEMODE\n");
		break;
	case DDERR_NOFLIPHW:
		TRACE("DDERR_NOFLIPHW\n");
		break;
	case DDERR_NOGDI:
		TRACE("DDERR_NOGDI\n");
		break;
	case DDERR_NOHWND:
		TRACE("DDERR_NOHWND\n");
		break;
	case DDERR_NOMIPMAPHW:
		TRACE("DDERR_NOMIPMAPHW\n");
		break;
	case DDERR_NOMIRRORHW:
		TRACE("DDERR_NOMIRRORHW\n");
		break;
	case DDERR_NOOVERLAYDEST:
		TRACE("DDERR_NOOVERLAYDEST\n");
		break;
	case DDERR_NOOVERLAYHW:
		TRACE("DDERR_NOOVERLAYHW\n");
		break;
	case DDERR_NOPALETTEATTACHED:
		TRACE("DDERR_NOPALETTEATTACHED\n");
		break;
	case DDERR_NOPALETTEHW:
		TRACE("DDERR_NOPALETTEHW\n");
		break;
	case DDERR_NORASTEROPHW:
		TRACE("DDERR_NORASTEROPHW\n");
		break;
	case DDERR_NOROTATIONHW:
		TRACE("DDERR_NOROTATIONHW\n");
		break;
	case DDERR_NOSTRETCHHW:
		TRACE("DDERR_NOSTRETCHHW\n");
		break;
	case DDERR_NOT4BITCOLOR:
		TRACE("DDERR_NOT4BITCOLOR\n");
		break;
	case DDERR_NOT4BITCOLORINDEX:
		TRACE("DDERR_NOT4BITCOLORINDEX\n");
		break;
	case DDERR_NOT8BITCOLOR:
		TRACE("DDERR_NOT8BITCOLOR\n");
		break;
	case DDERR_NOTAOVERLAYSURFACE:
		TRACE("DDERR_NOTAOVERLAYSURFACE\n");
		break;
	case DDERR_NOTEXTUREHW:
		TRACE("DDERR_NOTEXTUREHW\n");
		break;
	case DDERR_NOTFLIPPABLE:
		TRACE("DDERR_NOTFLIPPABLE\n");
		break;
	case DDERR_NOTFOUND:
		TRACE("DDERR_NOTFOUND\n");
		break;
	case DDERR_NOTINITIALIZED:
		TRACE("DDERR_NOTINITIALIZED\n");
		break;
	case DDERR_NOTLOCKED:
		TRACE("DDERR_NOTLOCKED\n");
		break;
	case DDERR_NOTPAGELOCKED:
		TRACE("DDERR_NOTPAGELOCKED\n");
		break;
	case DDERR_NOTPALETTIZED:
		TRACE("DDERR_NOTPALETTIZED\n");
		break;
	case DDERR_NOVSYNCHW:
		TRACE("DDERR_NOVSYNCHW\n");
		break;
	case DDERR_NOZBUFFERHW:
		TRACE("DDERR_NOZBUFFERHW\n");
		break;
	case DDERR_NOZOVERLAYHW:
		TRACE("DDERR_NOZOVERLAYHW\n");
		break;
	case DDERR_OUTOFCAPS:
		TRACE("DDERR_OUTOFCAPS\n");
		break;
	case DDERR_OUTOFMEMORY:
		TRACE("Out of Memory\n");
		break;
	case DDERR_OUTOFVIDEOMEMORY:
		TRACE("DDERR_OUTOFVIDEOMEMORY\n");
		break;
	case DDERR_OVERLAYCANTCLIP:
		TRACE("DDERR_OVERLAYCANTCLIP\n");
		break;
	case DDERR_OVERLAYCOLORKEYONLYONEACTIVE:
		TRACE("DDERR_OVERLAYCOLORKEYONLYONEACTIVE\n");
		break;
	case DDERR_OVERLAYNOTVISIBLE:
		TRACE("DDERR_OVERLAYNOTVISIBLE\n");
		break;
	case DDERR_PALETTEBUSY:
		TRACE("DDERR_PALETTEBUSY\n");
		break;
	case DDERR_PRIMARYSURFACEALREADYEXISTS:
		TRACE("DDERR_PRIMARYSURFACEALREADYEXISTS\n");
		break;
	case DDERR_REGIONTOOSMALL:
		TRACE("DDERR_REGIONTOOSMALL\n");
		break;
	case DDERR_SURFACEALREADYATTACHED:
		TRACE("DDERR_SURFACEALREADYATTACHED\n");
		break;
	case DDERR_SURFACEALREADYDEPENDENT:
		TRACE("DDERR_SURFACEALREADYDEPENDENT\n");
		break;
	case DDERR_SURFACEBUSY:
		TRACE("DDERR_SURFACEBUSY\n");
		break;
	case DDERR_SURFACEISOBSCURED:
		TRACE("DDERR_SURFACEISOBSCURED\n");
		break;
	case DDERR_SURFACELOST:
		TRACE("DDERR_SURFACELOST\n");
		break;
	case DDERR_SURFACENOTATTACHED:
		TRACE("DDERR_SURFACENOTATTACHED\n");
		break;
	case DDERR_TOOBIGHEIGHT:
		TRACE("DDERR_TOOBIGHEIGHT\n");
		break;
	case DDERR_TOOBIGSIZE:
		TRACE("DDERR_TOOBIGSIZE\n");
		break;
	case DDERR_TOOBIGWIDTH:
		TRACE("DDERR_TOOBIGWIDTH\n");
		break;
	case DDERR_UNSUPPORTED:
		TRACE("DDERR_UNSUPPORTED\n");
		break;
	case DDERR_UNSUPPORTEDFORMAT:
		TRACE("DDERR_UNSUPPORTEDFORMAT\n");
		break;
	case DDERR_UNSUPPORTEDMASK:
		TRACE("DDERR_UNSUPPORTEDMASK\n");
		break;
	case DDERR_UNSUPPORTEDMODE:
		TRACE("DDERR_UNSUPPORTEDMODE\n");
		break;
	case DDERR_VERTICALBLANKINPROGRESS:
		TRACE("DDERR_VERTICALBLANKINPROGRESS\n");
		break;
//	case DDERR_VIDEONOTACTIVE:
//		TRACE("DDERR_VIDEONOTACTIVE\n");
//		break;
	case DDERR_WASSTILLDRAWING:
		TRACE("DDERR_WASSTILLDRAWING\n");
		break;
	case DDERR_WRONGMODE:
		TRACE("DDERR_WRONGMODE\n");
		break;
	case DDERR_XALIGN:
		TRACE("DDERR_XALIGN\n");
		break;
	default:
		TRACE("Unknown return value\n");
		break;
	}
}

void Fatal(LPCTSTR msg)
{
	if (GetDDWin())
	{
		LPDIRECTDRAW2 ddraw2=GetDDWin()->GetDDraw();
		if (ddraw2)
		{
			ddraw2->RestoreDisplayMode();
			ddraw2->Release();
		}
	}
	AfxMessageBox( msg );
	exit(1);
}