directdrawwin.cpp

基于DirectX的游戏软件

	{
		TRACE("compressed BMP format\n");
		return 0;
	}

	TRACE("loading '%s': width=%d height=%d depth=%d\n", filename, imagew, imageh, imagebitdepth);

	if (imagebitdepth==8)
	{
		// skip over palette info...
		int ncolors = (bmpinfohdr.biClrUsed==0) ? 256 : bmpinfohdr.biClrUsed;
		bmp.seekg( sizeof(RGBQUAD)*ncolors, ios::cur );
	}

	BYTE* buf=new BYTE[imagesize];
	bmp.read( buf, imagesize );

	if (!Copy_Bmp_Surface( surf, &bmpinfohdr, buf ))
	{
		TRACE("copy failed\n");
		delete [] buf;
		return 0;
	}

	delete [] buf;

	return TRUE;
}
*/
void DirectDrawWin::OnActivateApp(BOOL bActive, HTASK hTask) 
{
	CWnd::OnActivateApp(bActive, hTask);

	window_active = bActive;
}

int DirectDrawWin::OnCreate(LPCREATESTRUCT)
{
	ShowCursor( FALSE );
	if(!InitDirectInput())
	{
		AfxMessageBox("Can't create DirectInput Object!");
		return -1;
	}
	DirectDrawEnumerate( DriverAvailable, this );

	if (totaldrivers==0)
	{
		AfxMessageBox("No DirectDraw drivers detected");
		return -1;
	}

	// insure the first entry is the primary display driver
	if (driver[0].guid!=0 && totaldrivers>1)
	{
		for (int i=1;i<totaldrivers;i++)
			if (driver[i].guid==0)
			{
				DriverInfo tmp;

				tmp.guid=0;
				tmp.desc=driver[i].desc;
				tmp.name=driver[i].name;

				driver[i].guid=driver[0].guid;
				driver[i].desc=driver[0].desc;
				driver[i].name=driver[0].name;

				driver[0].guid=0;
				driver[0].desc=tmp.desc;
				driver[0].name=tmp.name;
			}
	}

	int driverindex=SelectDriver();
	if (driverindex<0)
	{
		TRACE("No DirectDraw driver selected\n");
		return -1;
	}
	else if (driverindex>totaldrivers-1)
	{
		AfxMessageBox("Invalid DirectDraw driver selected\n");
		return -1;
	}

	LPDIRECTDRAW ddraw1;
	DirectDrawCreate( driver[driverindex].guid, &ddraw1, 0 );
	HRESULT r;
	r=ddraw1->QueryInterface( IID_IDirectDraw2, (void**)&ddraw2 );
	if (r!=S_OK)
	{
		AfxMessageBox("DirectDraw2 interface not supported");
		return -1;
	}
	ddraw1->Release(), ddraw1=0;

	ddraw2->SetCooperativeLevel( GetSafeHwnd(), DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX );

	ddraw2->EnumDisplayModes( 0, 0, this, DisplayModeAvailable );
	qsort( displaymode, totaldisplaymodes, sizeof(DisplayModeInfo), CompareModes );
	
	CDC* dc=GetDC();
	displaydepth=dc->GetDeviceCaps( BITSPIXEL );
	displayrect.left=0;
	displayrect.top=0;
	displayrect.right=dc->GetDeviceCaps( HORZRES );
	displayrect.bottom=dc->GetDeviceCaps( VERTRES );
	dc->DeleteDC();	

	int initmode=SelectInitialDisplayMode();
	if (ActivateDisplayMode( initmode )==FALSE)
		return -1;

	return 0;
}

void DirectDrawWin::OnDestroy()
{
	if (primsurf)
		primsurf->Release(), primsurf=0;

	if (palette)
		palette->Release(), palette=0;

	if (ddraw2)
		ddraw2->Release(), ddraw2=0;
	for (int i=0;i<totaldrivers;i++)
	{
		if (driver[i].guid)
			delete [] driver[i].guid;
		free( driver[i].desc );
		free( driver[i].name );
	}
	ReleaseDirectInput();
	ReleaseDirectSound();
}

BOOL DirectDrawWin::OnEraseBkgnd(CDC* pDC) 
{
	return TRUE;
}

BOOL DirectDrawWin::PreDrawScene()
{
	if (window_active && primsurf->IsLost())
	{
		HRESULT r;
		r=primsurf->Restore();
		if (r!=DD_OK)
			TRACE("can't restore primsurf\n");

		if (backsurf)
		{
			r=backsurf->Restore();
			if (r!=DD_OK)
				TRACE("can't restore backsurf\n");
		}
		RestoreSurfaces();
	}
	
	
	return window_active;
}

void DirectDrawWin::PrintSurfaceInfo(LPDIRECTDRAWSURFACE surf, LPCTSTR name)
{
	ASSERT(surf);
	ASSERT(name);

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize=sizeof(desc);
	surf->GetSurfaceDesc( &desc );
	
	TRACE("Description for surface '%s':\n", name );

	if (desc.ddsCaps.dwCaps & DDSCAPS_COMPLEX)
		TRACE("  Complex\n");

	if (desc.ddsCaps.dwCaps & DDSCAPS_FLIP)
		TRACE("  Flipable\n");

	if (desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
		TRACE("  Primary surface\n");

	if (desc.ddsCaps.dwCaps & DDSCAPS_FRONTBUFFER)
		TRACE("  Front buffer\n");

	if (desc.ddsCaps.dwCaps & DDSCAPS_BACKBUFFER)
		TRACE("  Back buffer\n");
	
	if (desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
		TRACE("  Video memory\n");

	if (desc.ddsCaps.dwCaps & DDSCAPS_LOCALVIDMEM)
		TRACE("  Local Video memory\n");
	
	if (desc.ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
		TRACE("  System memory\n");

	if (desc.ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN)
		TRACE("  Offscreen/plain\n");

	if (desc.ddsCaps.dwCaps & DDSCAPS_MODEX)
		TRACE("  Mode X\n");
}
/*
BOOL DirectDrawWin::SaveSurface(LPDIRECTDRAWSURFACE surf, LPCTSTR filename)
{
	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize = sizeof(desc);
	desc.dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
	surf->GetSurfaceDesc( &desc );

	DWORD width  = desc.dwWidth;
	DWORD height = desc.dwHeight;
	DWORD depth  = desc.ddpfPixelFormat.dwRGBBitCount;

	BITMAPFILEHEADER filehdr;
	BITMAPINFOHEADER infohdr;
	RGBQUAD quads[256];
	PALETTEENTRY pe[256];

	ZeroMemory( &filehdr, sizeof(filehdr) );
	*((char*)&filehdr.bfType)='B';
	*(((char*)&filehdr.bfType)+1)='M';
	filehdr.bfOffBits=sizeof(filehdr)+sizeof(infohdr);
	
	if (depth==8)
		filehdr.bfOffBits+=sizeof(quads);

	ZeroMemory( &infohdr, sizeof(infohdr) );
	infohdr.biSize=sizeof(infohdr);
	infohdr.biWidth    = width;
	infohdr.biHeight   = height;
	infohdr.biPlanes   = 1;
	infohdr.biBitCount = depth==8 ? 8 : 24;
	infohdr.biCompression=BI_RGB;
	infohdr.biSizeImage = 0;
	if (depth==8)
		infohdr.biClrUsed = 256;
	else
		infohdr.biClrUsed = 0;

	LPDIRECTDRAWPALETTE palette;
	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 
		ret=FALSE;//not implent
	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;
}
*/

#ifdef _DEBUG

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;
	}
}
#endif

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


void DirectDrawWin::Restore()
{
	if (primsurf)
		primsurf->Release(), primsurf=0;

	if (palette)
		palette->Release(), palette=0;

	if (ddraw2)
		ddraw2->Release(), ddraw2=0;
	for (int i=0;i<totaldrivers;i++)
	{
		if (driver[i].guid)
			delete [] driver[i].guid;
		free( driver[i].desc );
		free( driver[i].name );
	}
}